AbstractCiphers.h

#ifndef TENDUKE_CRYPTO_ABSTRACTCIPHERS_H
#define TENDUKE_CRYPTO_ABSTRACTCIPHERS_H
 
#include "./Ciphers.h"
#include "./CryptoException.h"
#include "./kdf/PBKDF2.h"
#include "./symmetric/aes/AESGCMCipher.h"
#include "../utl/BinaryView.h"
#include "../utl/DataSink.h"
#include "../utl/SimpleBuffer.h"
#include "../utl/StringSink.h"
#include "../utl/random/RandomBytes.h"
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
 
namespace tenduke { namespace crypto {

class AbstractCiphers : public virtual Ciphers
{
public:
    AbstractCiphers(
        const std::shared_ptr<::tenduke::utl::random::RandomBytes> &random,
        const std::shared_ptr<::tenduke::crypto::PBKDF2> &keyGenerator
    )
    : random_(random)
    , keyGenerator_(keyGenerator)
    {}
 
    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
        );
    }
 
    std::string decryptString(
        const ::tenduke::crypto::Cipher &cipher,
        const ::tenduke::utl::DataSpan &ciphertext
    ) const override
    {
        const auto version = readAndValidateHeader(ciphertext);
        if (version != VERSION_2) {
            throw ::tenduke::crypto::CryptoException(
                "invalid_blob_version",
                "The provided blob is not compatible with this method."
            );
        }
 
        std::string result;
        ::tenduke::utl::StringSink sink(result);
        cipher.decryptData(
            ::tenduke::utl::make_view(ciphertext, BLOB_HEADER_SIZE),
            sink
        );
 
        return result;
    }
 
    void encrypt(
        const ::tenduke::crypto::Cipher &cipher,
        const ::tenduke::utl::DataSpan &plaintext,
        ::tenduke::utl::DataSink &ciphertext
    ) const override
    {
        writeHeader(ciphertext, VERSION_2);
        cipher.encryptData(plaintext, ciphertext);
    }
 
 
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;
 
    // Version #1 is fully automated: The key is automatically generated, the salt used in the key generation is used
    // as IV of the encryption. AES GCM 256 is used to encrypt the data.
    static constexpr std::uint16_t VERSION_1 = 0x0001;
 
    // Version #2 uses user-provided cipher. The caller must take care of password generation and salt storage.
    // Version #2 is used with dedicated methods (the methods taking the cipher as a parameter).
    static constexpr std::uint16_t VERSION_2 = 0x0002;

    static constexpr int PBKDF2_ITERATIONS = 100000;
 
    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
    {
        std::uint8_t saltBytes[::tenduke::crypto::aes::GCM_NONCE_SIZE];
        random_->generate(saltBytes, sizeof(saltBytes));
        const auto salt = ::tenduke::utl::make_view(saltBytes);
 
        const auto key = keyGenerator_->deriveAES256Key(
            ::tenduke::utl::make_view(encryptionKey, encryptionKeyLength),
            salt,
            PBKDF2_ITERATIONS
        );
 
        std::unique_ptr<::tenduke::utl::SimpleBuffer> ciphertext(new ::tenduke::utl::SimpleBuffer());
        writeHeader(*ciphertext, VERSION_1);
 
        key->gcmCipher()->encryptData(
            salt,
            ::tenduke::utl::make_view(plaintext, plaintextLength),
            *ciphertext
        );
 
        return ciphertext;
    }
 
    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
    {
        const std::uint16_t version = readAndValidateHeader(ciphertext, ciphertextLength);
        if (version != VERSION_1) {
            throw ::tenduke::crypto::CryptoException(
                "cipher_unsupported_version",
                "Unsupported blob version"
            );
        }
 
        if (ciphertextLength < BLOB_HEADER_SIZE + ::tenduke::crypto::aes::GCM_NONCE_SIZE + ::tenduke::crypto::aes::GCM_MAC_SIZE) {
            throw ::tenduke::crypto::CryptoException(
                "cipher_invalid_ciphertext",
                "Ciphertext too short to contain header, nonce and authentication tag"
            );
        }
 
        const auto key = keyGenerator_->deriveAES256Key(
            ::tenduke::utl::make_view(encryptionKey, encryptionKeyLength),
            ::tenduke::utl::make_view(ciphertext + BLOB_HEADER_SIZE, ::tenduke::crypto::aes::GCM_NONCE_SIZE),
            PBKDF2_ITERATIONS
        );
 
        std::unique_ptr<::tenduke::utl::SimpleBuffer> plaintext(new ::tenduke::utl::SimpleBuffer());
        key->gcmCipher()->decryptData(
            ::tenduke::utl::make_view(ciphertext + BLOB_HEADER_SIZE, ciphertextLength - BLOB_HEADER_SIZE),
            *plaintext
        );
 
        return plaintext;
    }
 
    virtual void writeHeader(unsigned char *buffer, const std::uint16_t version) const
    {
        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);
        buffer[4] = static_cast<unsigned char>((version >> 8) & 0xFF);
        buffer[5] = static_cast<unsigned char>(version & 0xFF);
    }
 
    virtual void writeHeader(::tenduke::utl::DataSink &output, const std::uint16_t version) const
    {
        output.append(static_cast<std::uint8_t>((BLOB_MAGIC >> 24) & 0xFF));
        output.append(static_cast<std::uint8_t>((BLOB_MAGIC >> 16) & 0xFF));
        output.append(static_cast<std::uint8_t>((BLOB_MAGIC >> 8) & 0xFF));
        output.append(static_cast<std::uint8_t>(BLOB_MAGIC & 0xFF));
        output.append(static_cast<std::uint8_t>((version >> 8) & 0xFF));
        output.append(static_cast<std::uint8_t>(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"
            );
        }
 
        const 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"
            );
        }
 
        return (static_cast<std::uint16_t>(buffer[4]) << 8) |
                static_cast<std::uint16_t>(buffer[5]);
    }
 
    virtual std::uint16_t readAndValidateHeader(const ::tenduke::utl::DataSpan &buffer) const
    {
        return readAndValidateHeader(buffer.data(), buffer.size_bytes());
    }
 
private:
    const std::shared_ptr<::tenduke::utl::random::RandomBytes> random_;
    const std::shared_ptr<::tenduke::crypto::PBKDF2> keyGenerator_;
};
 
}}
 
#endif //TENDUKE_CRYPTO_ABSTRACTCIPHERS_H