message_validator.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <cstdint>
#include <cstddef>
#include <cstring>
#include <string>
#include <string_view>
#include <stdexcept>
#include <algorithm>
 
namespace kcenon::network {
 
struct message_limits {
    static constexpr size_t MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
 
    static constexpr size_t MAX_HEADER_SIZE = 8192;
 
    static constexpr size_t MAX_WEBSOCKET_FRAME = 1 * 1024 * 1024;
 
    static constexpr size_t MAX_HTTP_LINE = 8192;
 
    static constexpr size_t MAX_HEADER_COUNT = 100;
 
    static constexpr size_t MAX_URL_LENGTH = 2048;
 
    static constexpr size_t MAX_COOKIE_SIZE = 4096;
};
 
enum class validation_result {
    ok,                     
    size_exceeded,          
    null_byte_detected,     
    invalid_format,         
    invalid_character,      
    header_count_exceeded   
};
 
inline const char* to_string(validation_result result) {
    switch (result) {
        case validation_result::ok:
            return "ok";
        case validation_result::size_exceeded:
            return "size_exceeded";
        case validation_result::null_byte_detected:
            return "null_byte_detected";
        case validation_result::invalid_format:
            return "invalid_format";
        case validation_result::invalid_character:
            return "invalid_character";
        case validation_result::header_count_exceeded:
            return "header_count_exceeded";
        default:
            return "unknown";
    }
}
 
class message_validator {
public:
    [[nodiscard]] static bool validate_size(
            size_t size,
            size_t max_size = message_limits::MAX_MESSAGE_SIZE) noexcept {
        return size <= max_size;
    }
 
    static void validate_size_or_throw(
            size_t size,
            size_t max_size = message_limits::MAX_MESSAGE_SIZE) {
        if (size > max_size) {
            throw std::length_error(
                "Message size " + std::to_string(size) +
                " exceeds limit " + std::to_string(max_size));
        }
    }
 
    [[nodiscard]] static size_t safe_copy(
            void* dest,
            size_t dest_size,
            const void* src,
            size_t src_size) noexcept {
        if (!dest || !src || dest_size == 0 || src_size == 0) {
            return 0;
        }
 
        size_t copy_size = std::min(dest_size, src_size);
        std::memcpy(dest, src, copy_size);
        return copy_size;
    }
 
    [[nodiscard]] static size_t safe_strcpy(
            char* dest,
            size_t dest_size,
            const char* src) noexcept {
        if (!dest || dest_size == 0 || !src) {
            return 0;
        }
 
        size_t src_len = std::strlen(src);
        size_t copy_len = std::min(dest_size - 1, src_len);
 
        std::memcpy(dest, src, copy_len);
        dest[copy_len] = '\0';
 
        return copy_len;
    }
 
    [[nodiscard]] static validation_result validate_http_header(
            std::string_view header) noexcept {
        // Check size
        if (header.size() > message_limits::MAX_HEADER_SIZE) {
            return validation_result::size_exceeded;
        }
 
        // Check for NULL bytes (NULL byte injection attack)
        if (header.find('\0') != std::string_view::npos) {
            return validation_result::null_byte_detected;
        }
 
        // Check for invalid control characters (except \r\n\t)
        for (char c : header) {
            if (c < 0x20 && c != '\r' && c != '\n' && c != '\t') {
                return validation_result::invalid_character;
            }
        }
 
        return validation_result::ok;
    }
 
    [[nodiscard]] static bool validate_header_count(size_t count) noexcept {
        return count <= message_limits::MAX_HEADER_COUNT;
    }
 
    [[nodiscard]] static bool validate_websocket_frame(
            size_t payload_length,
            size_t max_size = message_limits::MAX_WEBSOCKET_FRAME) noexcept {
        return payload_length <= max_size;
    }
 
    [[nodiscard]] static validation_result validate_url(
            std::string_view url) noexcept {
        if (url.size() > message_limits::MAX_URL_LENGTH) {
            return validation_result::size_exceeded;
        }
 
        if (url.find('\0') != std::string_view::npos) {
            return validation_result::null_byte_detected;
        }
 
        return validation_result::ok;
    }
 
    [[nodiscard]] static bool contains_suspicious_pattern(
            std::string_view data) noexcept {
        // Check for NULL byte injection
        if (data.find('\0') != std::string_view::npos) {
            return true;
        }
 
        // Check for HTTP response splitting
        if (data.find("\r\n\r\n") != std::string_view::npos) {
            return true;
        }
 
        return false;
    }
 
    [[nodiscard]] static std::string sanitize_string(std::string_view input) {
        std::string result;
        result.reserve(input.size());
 
        for (char c : input) {
            // Keep printable ASCII and common whitespace
            if (c >= 0x20 || c == '\t' || c == '\n' || c == '\r') {
                result += c;
            }
        }
 
        return result;
    }
 
    [[nodiscard]] static size_t safe_buffer_size(
            size_t requested_size,
            size_t max_size = message_limits::MAX_MESSAGE_SIZE) noexcept {
        return std::min(requested_size, max_size);
    }
};
 
} // namespace kcenon::network