kcenon::logger::security::hmac_sha256_integrity_policy Class Reference

HMAC-SHA256 integrity policy (ISO/IEC 27001 A.12.4.2 default). More...

#include <integrity_policy.h>

Inheritance diagram for kcenon::logger::security::hmac_sha256_integrity_policy:

Collaboration diagram for kcenon::logger::security::hmac_sha256_integrity_policy:

Public Member Functions
	hmac_sha256_integrity_policy (secure_key key)
	Construct from a secure_key.
std::string	sign (const std::string &record) const override
	Produce a signature for record.
bool	verify (const std::string &record, const std::string &signature) const override
	Verify that signature matches record.
std::string	name () const override
	Short identifier used as a prefix in serialized signatures (e.g. "HMAC-SHA256"). Implementations must return a stable non-empty ASCII string.
Public Member Functions inherited from kcenon::logger::security::integrity_policy
virtual	~integrity_policy ()=default

Static Private Member Functions
static std::string	compute_hmac (const std::string &message, const secure_key &key)

Private Attributes
std::shared_ptr< secure_key >	key_

Detailed Description

HMAC-SHA256 integrity policy (ISO/IEC 27001 A.12.4.2 default).

Uses OpenSSL's EVP_MAC API when available; otherwise falls back to a portable, non-cryptographic hash. The fallback is functionally correct (sign/verify round-trip) but MUST NOT be relied on for tamper detection in production. Build with OpenSSL 3.x to get real HMAC-SHA256.

Thread-safety: instances are immutable after construction; sign() and verify() may be called concurrently.

Definition at line 93 of file integrity_policy.h.

Constructor & Destructor Documentation

hmac_sha256_integrity_policy()

kcenon::logger::security::hmac_sha256_integrity_policy::hmac_sha256_integrity_policy ( secure_key key )

inlineexplicit

Construct from a secure_key.

Parameters

key	HMAC key (moved in; policy takes ownership).

The key is stored in a secure_key to guarantee zeroization on destruction (see secure_key_storage.h).

Definition at line 102 of file integrity_policy.h.

        : key_(std::make_shared<secure_key>(std::move(key))) {
    }

Member Function Documentation

compute_hmac()

static std::string kcenon::logger::security::hmac_sha256_integrity_policy::compute_hmac ( const std::string & message, const secure_key & key )

inlinestaticprivate

Definition at line 133 of file integrity_policy.h.

                                                           {
#ifdef LOGGER_INTEGRITY_HAS_OPENSSL
        unsigned char digest[EVP_MAX_MD_SIZE];
        size_t digest_len = 0;
 
        EVP_MAC* mac = EVP_MAC_fetch(nullptr, "HMAC", nullptr);
        if (!mac) {
            return std::string();
        }
 
        EVP_MAC_CTX* ctx = EVP_MAC_CTX_new(mac);
        if (!ctx) {
            EVP_MAC_free(mac);
            return std::string();
        }
 
        OSSL_PARAM params[] = {
            OSSL_PARAM_construct_utf8_string(
                OSSL_MAC_PARAM_DIGEST,
                const_cast<char*>("SHA256"),
                0),
            OSSL_PARAM_END
        };
 
        if (EVP_MAC_init(ctx, key.data().data(), key.size(), params) != 1) {
            EVP_MAC_CTX_free(ctx);
            EVP_MAC_free(mac);
            return std::string();
        }
 
        if (EVP_MAC_update(
                ctx,
                reinterpret_cast<const unsigned char*>(message.data()),
                message.size()) != 1) {
            EVP_MAC_CTX_free(ctx);
            EVP_MAC_free(mac);
            return std::string();
        }
 
        if (EVP_MAC_final(ctx, digest, &digest_len, sizeof(digest)) != 1) {
            EVP_MAC_CTX_free(ctx);
            EVP_MAC_free(mac);
            return std::string();
        }
 
        EVP_MAC_CTX_free(ctx);
        EVP_MAC_free(mac);
 
        std::ostringstream hex;
        hex << std::hex << std::setfill('0');
        for (size_t i = 0; i < digest_len; ++i) {
            hex << std::setw(2) << static_cast<int>(digest[i]);
        }
        return hex.str();
#else
        // Portable fallback. NOT cryptographically secure; intended only
        // to keep sign/verify round-trip working on builds without OpenSSL.
        std::size_t hash = 0xcbf29ce484222325ULL;
        for (size_t i = 0; i < message.size(); ++i) {
            hash ^= static_cast<unsigned char>(message[i]);
            hash *= 0x100000001b3ULL;
            if (i < key.size()) {
                hash ^= key.data()[i];
            }
        }
        std::ostringstream oss;
        oss << std::hex << std::setfill('0') << std::setw(16) << hash;
        return oss.str();
#endif
    }

References kcenon::logger::security::secure_key::data(), and kcenon::logger::security::secure_key::size().

Referenced by sign(), and verify().

Here is the call graph for this function:

Here is the caller graph for this function:

name()

std::string kcenon::logger::security::hmac_sha256_integrity_policy::name ( ) const

inlineoverridevirtual

Short identifier used as a prefix in serialized signatures (e.g. "HMAC-SHA256"). Implementations must return a stable non-empty ASCII string.

Implements kcenon::logger::security::integrity_policy.

Definition at line 128 of file integrity_policy.h.

                                    {
        return "HMAC-SHA256";
    }

sign()

std::string kcenon::logger::security::hmac_sha256_integrity_policy::sign ( const std::string & record ) const

inlineoverridevirtual

Produce a signature for record.

Parameters

record

The serialized log record to sign.

Returns

Hex-encoded signature, or empty string on failure.

Implements kcenon::logger::security::integrity_policy.

Definition at line 106 of file integrity_policy.h.

                                                           {
        return compute_hmac(record, *key_);
    }

References compute_hmac(), and key_.

Here is the call graph for this function:

verify()

bool kcenon::logger::security::hmac_sha256_integrity_policy::verify ( const std::string & record, const std::string & signature ) const

inlineoverridevirtual

Verify that signature matches record.

Parameters

record	The original log record.
signature	The signature previously emitted by sign().

Returns

true if the signature is valid, false otherwise.

Implements kcenon::logger::security::integrity_policy.

Definition at line 110 of file integrity_policy.h.

                                                           {
        if (signature.empty()) {
            return false;
        }
        const std::string expected = compute_hmac(record, *key_);
        if (expected.empty() || expected.size() != signature.size()) {
            return false;
        }
        // Constant-time compare to avoid signature-timing leaks.
        unsigned char diff = 0;
        for (size_t i = 0; i < expected.size(); ++i) {
            diff |= static_cast<unsigned char>(expected[i])
                  ^ static_cast<unsigned char>(signature[i]);
        }
        return diff == 0;
    }

References compute_hmac(), and key_.

Here is the call graph for this function:

Member Data Documentation

key_

std::shared_ptr<secure_key> kcenon::logger::security::hmac_sha256_integrity_policy::key_

private

Definition at line 207 of file integrity_policy.h.

Referenced by sign(), and verify().

---

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

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