kcenon::logger::utils::file_utils Class Reference

File utility functions for path validation and sanitization. More...

#include <file_utils.h>

Collaboration diagram for kcenon::logger::utils::file_utils:

Static Public Member Functions
static common::VoidResult	validate_log_path (const std::filesystem::path &path, const std::filesystem::path &allowed_base="")
	Validate log file path against path traversal attacks.
static std::string	sanitize_filename (const std::string &filename)
	Sanitize filename by removing/replacing dangerous characters.
static common::VoidResult	set_file_permissions (const std::filesystem::path &file, std::filesystem::perms perms=std::filesystem::perms::owner_read|std::filesystem::perms::owner_write)
	Set file permissions (Unix/POSIX systems)
static bool	is_absolute (const std::filesystem::path &path)
	Check if path is absolute.
static std::size_t	get_file_size (const std::filesystem::path &path)
	Get file size.
static bool	is_writable (const std::filesystem::path &path)
	Check if file exists and is writable.
static std::string	generate_temp_filename (const std::string &prefix="temp", const std::string &extension=".tmp")
	Generate safe temporary filename.

Detailed Description

File utility functions for path validation and sanitization.

Provides security-focused file operations including path traversal prevention, filename sanitization, and permission management.

Note

These utilities are essential for Phase 4 (Security Hardening).

Definition at line 28 of file file_utils.h.

Member Function Documentation

generate_temp_filename()

static std::string kcenon::logger::utils::file_utils::generate_temp_filename ( const std::string & prefix = "temp", const std::string & extension = ".tmp" )

inlinestatic

Generate safe temporary filename.

Parameters

prefix	Prefix for temporary file
extension	Extension for file (default: .tmp)

Returns

Safe temporary filename with timestamp

Format: prefix_YYYYMMDDHHMMSS_random.extension

Note

Thread-safe. Does not create the file.

Includes timestamp and random component for uniqueness.

Definition at line 311 of file file_utils.h.

      {
        auto now = std::chrono::system_clock::now();
        auto time_t = std::chrono::system_clock::to_time_t(now);
 
        std::tm tm_buf{};
#ifdef _WIN32
        localtime_s(&tm_buf, &time_t);
#else
        localtime_r(&time_t, &tm_buf);
#endif
 
        // Format: prefix_YYYYMMDDHHMMSS_random.ext
        char buffer[64];
        std::snprintf(buffer, sizeof(buffer),
                     "%s_%04d%02d%02d%02d%02d%02d_%d%s",
                     sanitize_filename(prefix).c_str(),
                     tm_buf.tm_year + 1900,
                     tm_buf.tm_mon + 1,
                     tm_buf.tm_mday,
                     tm_buf.tm_hour,
                     tm_buf.tm_min,
                     tm_buf.tm_sec,
                     static_cast<int>(std::chrono::steady_clock::now().time_since_epoch().count() % 10000),
                     extension.c_str());
 
        return std::string(buffer);
    }

References sanitize_filename().

Here is the call graph for this function:

get_file_size()

static std::size_t kcenon::logger::utils::file_utils::get_file_size ( const std::filesystem::path & path )

inlinestatic

Get file size.

Parameters

path	Path to file

Returns

File size in bytes, or 0 if file doesn't exist/error

Note

Thread-safe. Does not modify filesystem.

Returns 0 on error (file not found, no permissions, etc.)

Definition at line 260 of file file_utils.h.

                                                                  {
        std::error_code ec;
        auto size = std::filesystem::file_size(path, ec);
        if (ec) {
            return 0;
        }
        return static_cast<std::size_t>(size);
    }

References kcenon::logger::size.

is_absolute()

static bool kcenon::logger::utils::file_utils::is_absolute ( const std::filesystem::path & path )

inlinestatic

Check if path is absolute.

Parameters

path	Path to check

Returns

true if path is absolute, false otherwise

Note

Thread-safe.

Definition at line 248 of file file_utils.h.

                                                           {
        return path.is_absolute();
    }

is_writable()

static bool kcenon::logger::utils::file_utils::is_writable ( const std::filesystem::path & path )

inlinestatic

Check if file exists and is writable.

Parameters

path	Path to file

Returns

true if file exists and is writable, false otherwise

Note

Thread-safe. Does not modify filesystem.

Definition at line 276 of file file_utils.h.

                                                           {
        std::error_code ec;
 
        // If file doesn't exist, check if parent directory is writable
        if (!std::filesystem::exists(path, ec)) {
            auto parent = path.parent_path();
            if (parent.empty()) {
                parent = ".";
            }
            return std::filesystem::exists(parent, ec) &&
                   !ec;  // Basic existence check
        }
 
        // File exists, check status
        auto status = std::filesystem::status(path, ec);
        if (ec) {
            return false;
        }
 
        // Check if we have write permissions
        auto perms = status.permissions();
        return (perms & std::filesystem::perms::owner_write) != std::filesystem::perms::none;
    }

sanitize_filename()

static std::string kcenon::logger::utils::file_utils::sanitize_filename ( const std::string & filename )

inlinestatic

Sanitize filename by removing/replacing dangerous characters.

Parameters

filename

Filename to sanitize

Returns

Sanitized filename safe for filesystem use

Transformations:

• Removes path separators (/, )
• Replaces control characters with underscore
• Removes null bytes
• Truncates to reasonable length (255 characters)
• Preserves extension if present

Note

Thread-safe. Creates a new string.

Does not validate path components, only sanitizes filename.

Usage example:

std::string safe_name = file_utils::sanitize_filename(
    user_input_filename
);

Definition at line 138 of file file_utils.h.

                                                                  {
        if (filename.empty()) {
            return "unnamed.log";
        }
 
        std::string result;
        result.reserve(filename.size());
 
        for (char c : filename) {
            // Remove path separators
            if (c == '/' || c == '\\') {
                continue;
            }
 
            // Remove null bytes
            if (c == '\0') {
                continue;
            }
 
            // Replace control characters with underscore
            if (c < 32 || c == 127) {
                result += '_';
                continue;
            }
 
            // Remove potentially dangerous characters
            if (c == ':' || c == '*' || c == '?' || c == '"' ||
                c == '<' || c == '>' || c == '|') {
                result += '_';
                continue;
            }
 
            result += c;
        }
 
        // Truncate to safe length (255 is common filesystem limit)
        if (result.size() > 255) {
            // Try to preserve extension
            size_t ext_pos = result.find_last_of('.');
            if (ext_pos != std::string::npos && ext_pos > 250) {
                // Extension is reasonable, keep it
                std::string ext = result.substr(ext_pos);
                result = result.substr(0, 255 - ext.size()) + ext;
            } else {
                result = result.substr(0, 255);
            }
        }
 
        // Ensure result is not empty
        if (result.empty()) {
            return "unnamed.log";
        }
 
        return result;
    }

Referenced by generate_temp_filename().

Here is the caller graph for this function:

set_file_permissions()

static common::VoidResult kcenon::logger::utils::file_utils::set_file_permissions ( const std::filesystem::path & file, std::filesystem::perms perms = std::filesystem::perms::owner_read | std::filesystem::perms::owner_write )

inlinestatic

Set file permissions (Unix/POSIX systems)

Parameters

file	Path to file
perms	Permissions to set (default: owner read/write only)

Returns

common::VoidResult Success or error

Default permissions (0600):

• Owner: read + write
• Group: none
• Others: none

Note

On Windows, this function has limited effect (read-only flag).

Thread-safe. Modifies filesystem.

Important for Phase 4 security (encryption keys, sensitive logs).

Usage example:

// Make log file readable only by owner
file_utils::set_file_permissions(
    "sensitive.log",
    std::filesystem::perms::owner_read
);

Definition at line 218 of file file_utils.h.

      {
        try {
            if (!std::filesystem::exists(file)) {
                return make_logger_void_result(
                    logger_error_code::file_open_failed,
                    "File does not exist: " + file.string()
                );
            }
 
            std::filesystem::permissions(file, perms);
            return common::ok();
        } catch (const std::filesystem::filesystem_error& e) {
            return make_logger_void_result(
                logger_error_code::file_permission_denied,
                std::string("Failed to set file permissions: ") + e.what()
            );
        }
    }

References kcenon::logger::file_open_failed, kcenon::logger::file_permission_denied, kcenon::logger::make_logger_void_result(), and kcenon::common::ok().

Here is the call graph for this function:

validate_log_path()

static common::VoidResult kcenon::logger::utils::file_utils::validate_log_path ( const std::filesystem::path & path, const std::filesystem::path & allowed_base = "" )

inlinestatic

Validate log file path against path traversal attacks.

Parameters

path	File path to validate
allowed_base	Base directory where log files are allowed (optional)

Returns

common::VoidResult Success if path is valid, error otherwise

Security checks:

• Prevents path traversal (e.g., ../../../etc/passwd)
• Ensures path is within allowed_base directory (if specified)
• Validates path doesn't contain suspicious patterns
• Uses canonical path resolution to prevent symlink attacks

Note

Thread-safe. Does not modify filesystem.

Critical for Phase 4 security requirements.

Usage example:

auto result = file_utils::validate_log_path(
    "logs/app.log",
    "/var/log/myapp"
);
if (!result) {
    // Path is invalid or outside allowed directory
}

Definition at line 56 of file file_utils.h.

      {
        try {
            // Check for obviously suspicious patterns
            std::string path_str = path.string();
 
            // Detect path traversal attempts
            if (path_str.find("..") != std::string::npos) {
                return make_logger_void_result(
                    logger_error_code::sanitization_failed,
                    "Path contains '..' (path traversal attempt)"
                );
            }
 
            // If allowed_base is specified, ensure path is within it
            if (!allowed_base.empty()) {
                // Convert both paths to canonical form (resolves symlinks)
                std::filesystem::path canonical_path;
                std::filesystem::path canonical_base;
 
                // Get canonical base (must exist)
                if (std::filesystem::exists(allowed_base)) {
                    canonical_base = std::filesystem::canonical(allowed_base);
                } else {
                    canonical_base = std::filesystem::absolute(allowed_base);
                }
 
                // Get canonical path (may not exist yet for new files)
                std::filesystem::path parent = path.parent_path();
                if (!parent.empty() && std::filesystem::exists(parent)) {
                    canonical_path = std::filesystem::canonical(parent) / path.filename();
                } else {
                    canonical_path = std::filesystem::absolute(path);
                }
 
                // Check if canonical_path starts with canonical_base
                auto [base_end, path_end] = std::mismatch(
                    canonical_base.begin(), canonical_base.end(),
                    canonical_path.begin(), canonical_path.end()
                );
 
                if (base_end != canonical_base.end()) {
                    return make_logger_void_result(
                        logger_error_code::sanitization_failed,
                        "Path is outside allowed directory: " + path_str
                    );
                }
            }
 
            return common::ok();  // Valid path
        } catch (const std::filesystem::filesystem_error& e) {
            return make_logger_void_result(
                logger_error_code::file_permission_denied,
                std::string("Path validation failed: ") + e.what()
            );
        }
    }

References kcenon::logger::file_permission_denied, kcenon::logger::make_logger_void_result(), kcenon::common::ok(), and kcenon::logger::sanitization_failed.

Here is the call graph for this function:

---

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

• include/kcenon/logger/utils/file_utils.h