PolicySecurity.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-3.0-or-later
#include "rootguard/PolicySecurity.hpp"
 
#include <cerrno>
#include <cstring>
#include <fcntl.h>
#include <stdexcept>
#include <string>
#include <sys/stat.h>
#include <unistd.h>
 
namespace bastionguard::rootguard {
namespace {
 
constexpr std::size_t kMaximumPolicyBytes = 1024U * 1024U;
 
class UniqueFd final {
public:
    explicit UniqueFd(const int value) noexcept : value_(value) {}
    ~UniqueFd() { if (value_ >= 0) ::close(value_); }
    UniqueFd(const UniqueFd&) = delete;
    UniqueFd& operator=(const UniqueFd&) = delete;
    [[nodiscard]] int get() const noexcept { return value_; }
private:
    int value_;
};
 
[[nodiscard]] std::runtime_error systemError(const char* operation)
{
    return std::runtime_error(std::string(operation) + ": " +
                              std::strerror(errno));
}
 
} // namespace
 
std::string PolicySecurity::read(const std::filesystem::path& path,
                                 const bool requireSecureOwnership)
{
    const int rawFd = ::open(path.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW);
    if (rawFd < 0)
        throw systemError("open policy");
    const UniqueFd fd(rawFd);
 
    struct stat status {};
    if (::fstat(fd.get(), &status) != 0)
        throw systemError("fstat policy");
 
    if (!S_ISREG(status.st_mode))
        throw std::runtime_error("la policy deve essere un file regolare");
    if (status.st_size < 0 ||
        static_cast<std::uintmax_t>(status.st_size) > kMaximumPolicyBytes) {
        throw std::runtime_error("la policy supera il limite di 1 MiB");
    }
 
    if (requireSecureOwnership) {
        if (status.st_uid != 0)
            throw std::runtime_error("la policy deve appartenere a root");
        if ((status.st_mode & (S_IWGRP | S_IWOTH)) != 0) {
            throw std::runtime_error(
                "la policy non deve essere scrivibile da gruppo o altri");
        }
    }
 
    std::string content;
    content.reserve(static_cast<std::size_t>(status.st_size));
    char buffer[4096];
    for (;;) {
        const ssize_t count = ::read(fd.get(), buffer, sizeof(buffer));
        if (count == 0)
            break;
        if (count < 0) {
            if (errno == EINTR)
                continue;
            throw systemError("read policy");
        }
        if (content.size() + static_cast<std::size_t>(count) >
            kMaximumPolicyBytes) {
            throw std::runtime_error("la policy supera il limite di 1 MiB");
        }
        content.append(buffer, static_cast<std::size_t>(count));
    }
 
    struct stat finalStatus {};
    if (::fstat(fd.get(), &finalStatus) != 0)
        throw systemError("fstat policy dopo lettura");
    if (finalStatus.st_dev != status.st_dev ||
        finalStatus.st_ino != status.st_ino ||
        finalStatus.st_size != status.st_size ||
        finalStatus.st_mtim.tv_sec != status.st_mtim.tv_sec ||
        finalStatus.st_mtim.tv_nsec != status.st_mtim.tv_nsec ||
        finalStatus.st_ctim.tv_sec != status.st_ctim.tv_sec ||
        finalStatus.st_ctim.tv_nsec != status.st_ctim.tv_nsec) {
        throw std::runtime_error("la policy è cambiata durante la lettura");
    }
 
    return content;
}
 
} // namespace bastionguard::rootguard