AbstractCiphers.h

#ifndef TENDUKE_CRYPTO_ABSTRACTCIPHERS_H
#define TENDUKE_CRYPTO_ABSTRACTCIPHERS_H
 
#include "Ciphers.h"
#include "CryptoException.h"
#include "../utl/BinaryView.h"
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
 
namespace tenduke { namespace crypto {

class AbstractCiphers : public virtual Ciphers
{
public:
    std::unique_ptr<::tenduke::utl::BinaryData> decrypt(
        const ::tenduke::utl::DataSpan &ciphertext,
        const ::tenduke::utl::DataSpan &encryptionKey
    ) const override
    {
        return decryptBytes(
            ciphertext.data(),
            ciphertext.size_bytes(),
            encryptionKey.data(),
            encryptionKey.size_bytes()
        );
    }

    std::string decryptString(
        const ::tenduke::utl::DataSpan &ciphertext,
        const ::tenduke::utl::DataSpan &encryptionKey
    ) const override
    {
        auto plaintext = decrypt(ciphertext, encryptionKey);
        return std::string(reinterpret_cast<char *>(plaintext->getData()), plaintext->getLength());
    }

    std::unique_ptr<::tenduke::utl::BinaryData> encrypt(
        const ::tenduke::utl::DataSpan &plaintext,
        const ::tenduke::utl::DataSpan &encryptionKey
    ) const override
    {
        return encryptBytes(
            plaintext.data(),
            plaintext.size_bytes(),
            encryptionKey.data(),
            encryptionKey.size_bytes()
        );
    }

    std::unique_ptr<::tenduke::utl::BinaryData> encrypt(
        const std::string &plaintext,
        const ::tenduke::utl::DataSpan &encryptionKey
    ) const override
    {
        return encrypt(
            ::tenduke::utl::make_view(plaintext),
            encryptionKey
        );
    }
 
protected:
    static constexpr std::uint32_t BLOB_MAGIC = 0x44554B45; // "DUKE" in network byte order (big-endian)

    static constexpr std::size_t BLOB_HEADER_SIZE = 6;

    virtual std::unique_ptr<::tenduke::utl::BinaryData> decryptBytes(
        const unsigned char *ciphertext,
        std::size_t ciphertextLength,
        const unsigned char *encryptionKey,
        std::size_t encryptionKeyLength
    ) const = 0;

    virtual std::unique_ptr<::tenduke::utl::BinaryData> encryptBytes(
        const unsigned char *plaintext,
        std::size_t plaintextLength,
        const unsigned char *encryptionKey,
        std::size_t encryptionKeyLength
    ) const = 0;

    virtual void writeHeader(unsigned char *buffer, std::uint16_t version) const
    {
        // Write magic in network byte order (big-endian)
        buffer[0] = static_cast<unsigned char>((BLOB_MAGIC >> 24) & 0xFF);
        buffer[1] = static_cast<unsigned char>((BLOB_MAGIC >> 16) & 0xFF);
        buffer[2] = static_cast<unsigned char>((BLOB_MAGIC >> 8) & 0xFF);
        buffer[3] = static_cast<unsigned char>(BLOB_MAGIC & 0xFF);
 
        // Write version in network byte order (big-endian)
        buffer[4] = static_cast<unsigned char>((version >> 8) & 0xFF);
        buffer[5] = static_cast<unsigned char>(version & 0xFF);
    }

    virtual std::uint16_t readAndValidateHeader(
        const unsigned char *buffer,
        std::size_t bufferLength
    ) const
    {
        if (bufferLength < BLOB_HEADER_SIZE) {
            throw ::tenduke::crypto::CryptoException(
                "cipher_invalid_ciphertext",
                "Ciphertext too short to contain header"
            );
        }
 
        // Read magic in network byte order (big-endian)
        std::uint32_t magic = (static_cast<std::uint32_t>(buffer[0]) << 24) |
                              (static_cast<std::uint32_t>(buffer[1]) << 16) |
                              (static_cast<std::uint32_t>(buffer[2]) << 8) |
                              static_cast<std::uint32_t>(buffer[3]);
 
        if (magic != BLOB_MAGIC) {
            throw ::tenduke::crypto::CryptoException(
                "cipher_invalid_ciphertext",
                "Invalid blob magic value"
            );
        }
 
        // Read version in network byte order (big-endian)
        std::uint16_t version = (static_cast<std::uint16_t>(buffer[4]) << 8) |
                                static_cast<std::uint16_t>(buffer[5]);
 
        return version;
    }
};
 
}}
 
#endif //TENDUKE_CRYPTO_ABSTRACTCIPHERS_H