kcenon::logger::security::path_validator Class Reference

Validates file paths to prevent security vulnerabilities. More...

#include <path_validator.h>

Collaboration diagram for kcenon::logger::security::path_validator:

Public Member Functions
	path_validator (std::filesystem::path allowed_base)
	Construct with allowed base directory.
common::VoidResult	validate (const std::filesystem::path &path, bool allow_symlinks=false, bool strict_filename=true) const
	Validate a file path.
const std::filesystem::path &	allowed_base () const
	Get the allowed base directory.

Static Public Member Functions
static bool	is_safe_filename (const std::string &name)
	Check if a filename is safe (contains only allowed characters)
static std::string	sanitize_filename (const std::string &name, char replacement='_')
	Sanitize a filename by removing/replacing invalid characters.
static result< std::filesystem::path >	safe_join (const std::filesystem::path &base, const std::filesystem::path &relative)
	Create a safe path by joining base and relative path.

Private Attributes
std::filesystem::path	allowed_base_

Detailed Description

Validates file paths to prevent security vulnerabilities.

Security features:

• Path traversal prevention (../ attacks)
• Symbolic link validation
• Filename character restrictions
• Base directory enforcement

Definition at line 30 of file path_validator.h.

Constructor & Destructor Documentation

path_validator()

kcenon::logger::security::path_validator::path_validator ( std::filesystem::path allowed_base )

inlineexplicit

Construct with allowed base directory.

Parameters

allowed_base

All paths must be within this directory

Definition at line 36 of file path_validator.h.

        : allowed_base_(std::move(allowed_base)) {
 
        // Convert to canonical path if it exists
        try {
            if (std::filesystem::exists(allowed_base_)) {
                allowed_base_ = std::filesystem::canonical(allowed_base_);
            } else {
                // Use weakly_canonical for non-existent paths
                allowed_base_ = std::filesystem::weakly_canonical(allowed_base_);
            }
        } catch (const std::filesystem::filesystem_error&) {
            // If canonicalization fails, use as-is
            // Validation will catch issues later
        }
    }

References allowed_base_.

Member Function Documentation

allowed_base()

const std::filesystem::path & kcenon::logger::security::path_validator::allowed_base ( ) const

inline

Get the allowed base directory.

Definition at line 122 of file path_validator.h.

                                                  {
        return allowed_base_;
    }

References allowed_base_.

is_safe_filename()

static bool kcenon::logger::security::path_validator::is_safe_filename ( const std::string & name )

inlinestatic

Check if a filename is safe (contains only allowed characters)

Parameters

name	Filename to check

Returns

true if safe, false otherwise

Allowed characters:

• Alphanumeric (a-z, A-Z, 0-9)
• Hyphen (-)
• Underscore (_)
• Period (.)

Definition at line 137 of file path_validator.h.

                                                        {
        // Empty or special names are not allowed
        if (name.empty() || name == "." || name == "..") {
            return false;
        }
 
        // Check each character
        for (char c : name) {
            if (!std::isalnum(static_cast<unsigned char>(c)) &&
                c != '-' && c != '_' && c != '.') {
                return false;
            }
        }
 
        return true;
    }

Referenced by validate().

Here is the caller graph for this function:

safe_join()

static result< std::filesystem::path > kcenon::logger::security::path_validator::safe_join ( const std::filesystem::path & base, const std::filesystem::path & relative )

inlinestatic

Create a safe path by joining base and relative path.

Parameters

base	Base directory
relative	Relative path to join

Returns

Validated absolute path or error

Definition at line 196 of file path_validator.h.

      {
        try {
            // Ensure relative path doesn't contain absolute components
            if (relative.is_absolute()) {
                return result<std::filesystem::path>{
                    logger_error_code::path_traversal_detected,
                    "Cannot join with absolute path"};
            }
 
            // Join paths
            auto joined = base / relative;
 
            // Validate the result
            path_validator validator(base);
            auto validation = validator.validate(joined);
 
            if (validation.is_err()) {
                return result<std::filesystem::path>{
                    get_logger_error_code(validation),
                    get_logger_error_message(validation)};
            }
 
            return result<std::filesystem::path>(joined);
 
        } catch (const std::filesystem::filesystem_error& e) {
            return result<std::filesystem::path>{
                logger_error_code::path_traversal_detected,
                std::string("Path join failed: ") + e.what()};
        }
    }

References kcenon::logger::get_logger_error_code(), kcenon::logger::get_logger_error_message(), kcenon::logger::path_traversal_detected, and validate().

Here is the call graph for this function:

sanitize_filename()

static std::string kcenon::logger::security::path_validator::sanitize_filename ( const std::string & name, char replacement = '_' )

inlinestatic

Sanitize a filename by removing/replacing invalid characters.

Parameters

name	Filename to sanitize
replacement	Character to use for invalid characters (default: '_')

Returns

Sanitized filename

Definition at line 160 of file path_validator.h.

      {
        // Handle special cases
        if (name.empty()) {
            return "unnamed";
        }
        if (name == ".") {
            return std::string(1, replacement) + name;
        }
        if (name == "..") {
            return std::string(1, replacement) + '.';
        }
 
        std::string result;
        result.reserve(name.size());
 
        for (char c : name) {
            if (std::isalnum(static_cast<unsigned char>(c)) ||
                c == '-' || c == '_' || c == '.') {
                result += c;
            } else {
                result += replacement;
            }
        }
 
        return result;
    }

validate()

common::VoidResult kcenon::logger::security::path_validator::validate ( const std::filesystem::path & path, bool allow_symlinks = false, bool strict_filename = true ) const

inline

Validate a file path.

Parameters

path	Path to validate
allow_symlinks	Whether symbolic links are allowed (default: false)
strict_filename	Whether to enforce strict filename rules (default: true)

Returns

Success or error describing the security issue

Definition at line 60 of file path_validator.h.

            {
        try {
            // 1. Convert to absolute path and resolve relative components
            std::filesystem::path canonical;
            if (std::filesystem::exists(path)) {
                canonical = std::filesystem::canonical(path);
            } else {
                canonical = std::filesystem::weakly_canonical(path);
            }
 
            // 2. Check for symbolic links (if not allowed)
            if (!allow_symlinks && std::filesystem::exists(path)) {
                if (std::filesystem::is_symlink(path)) {
                    return make_logger_void_result(
                        logger_error_code::path_traversal_detected,
                        "Symbolic links are not allowed for security reasons"
                    );
                }
            }
 
            // 3. Verify path is within allowed base directory
            auto [base_end, path_end] = std::mismatch(
                allowed_base_.begin(), allowed_base_.end(),
                canonical.begin(), canonical.end()
            );
 
            if (base_end != allowed_base_.end()) {
                return make_logger_void_result(
                    logger_error_code::path_traversal_detected,
                    "Path must be within allowed directory: " + allowed_base_.string()
                );
            }
 
            // 4. Validate filename (if strict mode enabled)
            if (strict_filename && path.has_filename()) {
                auto filename = path.filename().string();
 
                if (!is_safe_filename(filename)) {
                    return make_logger_void_result(
                        logger_error_code::invalid_filename,
                        "Filename contains invalid or potentially dangerous characters"
                    );
                }
            }
 
            return common::ok();
 
        } catch (const std::filesystem::filesystem_error& e) {
            return make_logger_void_result(
                logger_error_code::path_traversal_detected,
                std::string("Path validation failed: ") + e.what()
            );
        }
    }

References allowed_base_, kcenon::logger::invalid_filename, is_safe_filename(), kcenon::logger::make_logger_void_result(), kcenon::common::ok(), and kcenon::logger::path_traversal_detected.

Referenced by safe_join().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

allowed_base_

std::filesystem::path kcenon::logger::security::path_validator::allowed_base_

private

Definition at line 231 of file path_validator.h.

Referenced by allowed_base(), path_validator(), and validate().

---

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

• include/kcenon/logger/security/path_validator.h