audit_log_cipher.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, kcenon
// See the LICENSE file in the project root for full license information.
 
#ifndef PACS_SECURITY_AUDIT_LOG_CIPHER_HPP
#define PACS_SECURITY_AUDIT_LOG_CIPHER_HPP
 
#include "kcenon/pacs/core/result.h"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace kcenon::pacs::security {
 
// =============================================================================
// Constants (ISO 27799 §7.9 mapped values)
// =============================================================================
 
inline constexpr const char* audit_cipher_format_tag = "PACSAUDIT";
inline constexpr const char* audit_cipher_format_version = "v1";
 
inline constexpr std::size_t audit_cipher_key_bytes = 32;
 
inline constexpr std::size_t audit_cipher_mac_key_bytes = 32;
 
inline constexpr std::size_t audit_cipher_iv_bytes = 12;
 
inline constexpr std::size_t audit_cipher_tag_bytes = 16;
 
// =============================================================================
// Key Material
// =============================================================================
 
struct audit_cipher_key {
    std::string key_id;
 
    std::array<std::uint8_t, audit_cipher_key_bytes> data_key{};
 
    std::array<std::uint8_t, audit_cipher_mac_key_bytes> mac_key{};
 
    void wipe() noexcept;
 
    ~audit_cipher_key();
    audit_cipher_key() = default;
    audit_cipher_key(const audit_cipher_key&) = default;
    audit_cipher_key(audit_cipher_key&&) noexcept = default;
    audit_cipher_key& operator=(const audit_cipher_key&) = default;
    audit_cipher_key& operator=(audit_cipher_key&&) noexcept = default;
};
 
// =============================================================================
// Key Manager
// =============================================================================
 
class audit_key_manager {
public:
    audit_key_manager() = default;
 
    void register_key(audit_cipher_key key);
 
    [[nodiscard]] VoidResult set_active(const std::string& key_id);
 
    [[nodiscard]] const audit_cipher_key* find(const std::string& key_id) const;
 
    [[nodiscard]] Result<audit_cipher_key> active() const;
 
    void forget(const std::string& key_id);
 
    [[nodiscard]] std::size_t size() const;
 
    [[nodiscard]] VoidResult load_from_env();
 
    [[nodiscard]] static VoidResult decode_key(
        const std::string& encoded,
        std::uint8_t* out,
        std::size_t out_size);
 
private:
    mutable std::mutex mutex_;
    std::unordered_map<std::string, audit_cipher_key> keys_;
    std::string active_id_;
};
 
// =============================================================================
// Cipher
// =============================================================================
 
class audit_log_cipher {
public:
    explicit audit_log_cipher(audit_key_manager& keys);
 
    [[nodiscard]] Result<std::string> encrypt_record(
        const std::string& plaintext) const;
 
    [[nodiscard]] Result<std::string> decrypt_record(
        const std::string& encoded) const;
 
    [[nodiscard]] VoidResult verify_record(const std::string& encoded) const;
 
    [[nodiscard]] static bool looks_encrypted(const std::string& line) noexcept;
 
private:
    audit_key_manager& keys_;
};
 
// =============================================================================
// Small Encoding Helpers (exposed for tests)
// =============================================================================
 
namespace detail {
 
[[nodiscard]] std::string base64_encode(const std::uint8_t* data,
                                        std::size_t size);
 
[[nodiscard]] bool base64_decode(const std::string& in,
                                 std::vector<std::uint8_t>& out);
 
[[nodiscard]] bool hex_decode(const std::string& in,
                              std::uint8_t* out,
                              std::size_t out_size);
 
[[nodiscard]] bool constant_time_equal(const std::uint8_t* a,
                                       const std::uint8_t* b,
                                       std::size_t n) noexcept;
 
}  // namespace detail
 
}  // namespace kcenon::pacs::security
 
#endif  // PACS_SECURITY_AUDIT_LOG_CIPHER_HPP