Utility class for decrypting encrypted log files. More...

#include <encrypted_writer.h>

Collaboration diagram for kcenon::logger::log_decryptor:

Public Member Functions
	log_decryptor (const security::secure_key &key)
	Construct decryptor with key.

	~log_decryptor ()
	Destructor - cleans up key material.

	log_decryptor (const log_decryptor &)=delete

log_decryptor &	operator= (const log_decryptor &)=delete

	log_decryptor (log_decryptor &&)=delete

log_decryptor &	operator= (log_decryptor &&)=delete

result< size_t >	decrypt_file (const std::filesystem::path &input_path, const std::filesystem::path &output_path)
	Decrypt entire file to output file.

result< size_t >	decrypt_file_streaming (const std::filesystem::path &input_path, std::function< void(const std::string &)> callback)
	Decrypt file with callback for each entry.

Private Attributes
security::secure_key	key_

Detailed Description

Utility class for decrypting encrypted log files.

Provides functionality to read and decrypt log files created by encrypted_writer. Supports streaming decryption for large files.

Definition at line 344 of file encrypted_writer.h.

Constructor & Destructor Documentation

◆ log_decryptor() [1/3]

kcenon::logger::log_decryptor::log_decryptor ( const security::secure_key & key )

explicit

Construct decryptor with key.

Parameters

key	Decryption key (copied for safety)

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/writers/encrypted_writer.h.

Definition at line 537 of file encrypted_writer.cpp.

    : key_(key.data())  // Copy key data
{
#ifdef LOGGER_HAS_OPENSSL_CRYPTO
    cipher_ctx_ = EVP_CIPHER_CTX_new();
#endif
}

◆ ~log_decryptor()

kcenon::logger::log_decryptor::~log_decryptor ( )

Destructor - cleans up key material.

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/writers/encrypted_writer.h.

Definition at line 545 of file encrypted_writer.cpp.

                              {
#ifdef LOGGER_HAS_OPENSSL_CRYPTO
    if (cipher_ctx_) {
        EVP_CIPHER_CTX_free(cipher_ctx_);
        cipher_ctx_ = nullptr;
    }
#endif
}

◆ log_decryptor() [2/3]

kcenon::logger::log_decryptor::log_decryptor ( const log_decryptor & )

delete

◆ log_decryptor() [3/3]

kcenon::logger::log_decryptor::log_decryptor ( log_decryptor && )

delete

Member Function Documentation

◆ decrypt_file()

result< size_t > kcenon::logger::log_decryptor::decrypt_file	(	const std::filesystem::path &	input_path,
		const std::filesystem::path &	output_path )

Decrypt entire file to output file.

Parameters

input_path	Encrypted log file path
output_path	Decrypted output file path

Returns: Result containing entry count or error

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/writers/encrypted_writer.h.

Definition at line 554 of file encrypted_writer.cpp.

  {
    std::ofstream output(output_path, std::ios::binary | std::ios::trunc);
    if (!output) {
        return result<size_t>(
            logger_error_code::file_open_failed,
            "Failed to open output file: " + output_path.string()
        );
    }
 
    size_t entry_count = 0;
    auto callback = [&output, &entry_count](const std::string& decrypted) {
        output << decrypted << "\n";
        ++entry_count;
    };
 
    auto stream_result = decrypt_file_streaming(input_path, callback);
    if (!stream_result.has_value()) {
        return stream_result;
    }
 
    return result<size_t>(entry_count);
}

References decrypt_file_streaming(), and kcenon::logger::file_open_failed.

Here is the call graph for this function:

◆ decrypt_file_streaming()

result< size_t > kcenon::logger::log_decryptor::decrypt_file_streaming	(	const std::filesystem::path &	input_path,
		std::function< void(const std::string &)>	callback )

Decrypt file with callback for each entry.

Parameters

input_path	Encrypted log file path
callback	Function called with each decrypted entry

Returns: Result containing entry count or error

Examples: /home/runner/work/logger_system/logger_system/include/kcenon/logger/writers/encrypted_writer.h.

Definition at line 580 of file encrypted_writer.cpp.

  {
#ifdef LOGGER_HAS_OPENSSL_CRYPTO
    std::ifstream input(input_path, std::ios::binary);
    if (!input) {
        return result<size_t>(
            logger_error_code::file_open_failed,
            "Failed to open input file: " + input_path.string()
        );
    }
 
    size_t entry_count = 0;
    std::vector<uint8_t> buffer;
 
    while (input.good()) {
        // Read header
        encrypted_log_header header;
        input.read(reinterpret_cast<char*>(&header), sizeof(header));
 
        if (input.gcount() == 0) {
            break;  // End of file
        }
 
        if (input.gcount() != sizeof(header)) {
            return result<size_t>(
                logger_error_code::file_read_failed,
                "Incomplete header at entry " + std::to_string(entry_count)
            );
        }
 
        // Validate header
        if (header.magic != encrypted_log_header::kMagic) {
            return result<size_t>(
                logger_error_code::decryption_failed,
                "Invalid magic number at entry " + std::to_string(entry_count)
            );
        }
 
        // Read encrypted data
        buffer.resize(sizeof(header) + header.encrypted_length);
        std::memcpy(buffer.data(), &header, sizeof(header));
        input.read(
            reinterpret_cast<char*>(buffer.data() + sizeof(header)),
            header.encrypted_length
        );
 
        if (static_cast<size_t>(input.gcount()) != header.encrypted_length) {
            return result<size_t>(
                logger_error_code::file_read_failed,
                "Incomplete data at entry " + std::to_string(entry_count)
            );
        }
 
        // Decrypt entry
        auto decrypt_result = encrypted_writer::decrypt_entry(buffer, key_);
        if (!decrypt_result.has_value()) {
            return result<size_t>(
                decrypt_result.error_code(),
                "Decryption failed at entry " + std::to_string(entry_count) +
                ": " + decrypt_result.error_message()
            );
        }
 
        callback(decrypt_result.value());
        ++entry_count;
    }
 
    return result<size_t>(entry_count);
#else
    return result<size_t>(
        logger_error_code::decryption_failed,
        "OpenSSL not available - decryption disabled"
    );
#endif
}