bastionguard::rootguard::PolicySecurity Class Reference

#include <PolicySecurity.hpp>

Static Public Member Functions
static std::string	read (const std::filesystem::path &path, bool requireSecureOwnership)

Detailed Description

Definition at line 8 of file PolicySecurity.hpp.

Member Function Documentation

read()

std::string bastionguard::rootguard::PolicySecurity::read ( const std::filesystem::path & path, bool requireSecureOwnership )

staticnodiscard

Definition at line 36 of file PolicySecurity.cpp.

{
    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;
}

References read(), S_IWGRP, and S_IWOTH.

Referenced by bastionguard::rootguard::PolicyLoader::load(), anonymous_namespace{ActionHelper.cpp}::loadPolicy(), anonymous_namespace{main.cpp}::loadPolicy(), and read().

---

The documentation for this class was generated from the following files:

• BastionGuard/src/rootguard/include/rootguard/PolicySecurity.hpp
• BastionGuard/src/rootguard/src/PolicySecurity.cpp