From 2f7feb1d9222e0afaac8ae17db98d1556aa46aa4 Mon Sep 17 00:00:00 2001 From: Egor Tensin Date: Sun, 2 Aug 2015 20:35:38 +0300 Subject: cxx: more algorithm-agnostic API The code (in the utilities in particular) is a mess though, so a refactoring's coming up. --- cxx/include/aesnixx/aes.hpp | 823 ++++++++++++++----------------------------- cxx/include/aesnixx/all.hpp | 1 + cxx/include/aesnixx/api.hpp | 171 +++++++++ cxx/include/aesnixx/mode.hpp | 108 ++++++ 4 files changed, 536 insertions(+), 567 deletions(-) create mode 100644 cxx/include/aesnixx/api.hpp (limited to 'cxx/include/aesnixx') diff --git a/cxx/include/aesnixx/aes.hpp b/cxx/include/aesnixx/aes.hpp index 5d293ca..b2febf5 100644 --- a/cxx/include/aesnixx/aes.hpp +++ b/cxx/include/aesnixx/aes.hpp @@ -9,581 +9,270 @@ #pragma once #include "algorithm.hpp" -#include "data.hpp" +#include "api.hpp" +#include "error.hpp" #include "mode.hpp" #include +#include + #include namespace aesni { - namespace aes + namespace aes128 + { + typedef AesNI_AES128_Block Block; + typedef AesNI_AES128_RoundKeys RoundKeys; + typedef AesNI_AES128_Key Key; + } + + template <> + struct Types + { + typedef aes128::Block Block; + typedef aes128::RoundKeys RoundKeys; + typedef aes128::Key Key; + }; + + template <> + std::size_t get_number_of_rounds() + { + return 11; + } + + template <> + void from_string(aes128::Block& dest, const char* src) + { + aesni_AES128_parse_block(&dest, src, ErrorDetailsThrowsInDestructor()); + } + + template <> + std::string to_string(const aes128::Block& src) + { + AesNI_AES128_BlockString str; + aesni_AES128_format_block(&str, &src, ErrorDetailsThrowsInDestructor()); + return { str.str }; + } + + template <> + std::string to_matrix_string(const aes128::Block& src) + { + AesNI_AES128_BlockMatrixString str; + aesni_AES128_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor()); + return { str.str }; + } + + template <> + void from_string(aes128::Key& dest, const char* src) + { + aesni_AES128_parse_key(&dest, src, ErrorDetailsThrowsInDestructor()); + } + + template <> + std::string to_string(const aes128::Key& src) + { + AesNI_AES128_KeyString str; + aesni_AES128_format_key(&str, &src, ErrorDetailsThrowsInDestructor()); + return { str.str }; + } + + template <> + inline void expand_key( + const aes128::Key& key, + aes128::RoundKeys& encryption_keys) + { + aesni_AES128_expand_key(&key, &encryption_keys); + } + + template <> + inline void derive_decryption_keys( + const aes128::RoundKeys& encryption_keys, + aes128::RoundKeys& decryption_keys) + { + aesni_AES128_derive_decryption_keys( + &encryption_keys, &decryption_keys); + } + + AESNIXX_ENCRYPT_BLOCK_ECB(AES128); + AESNIXX_DECRYPT_BLOCK_ECB(AES128); + AESNIXX_ENCRYPT_BLOCK_CBC(AES128); + AESNIXX_DECRYPT_BLOCK_CBC(AES128); + AESNIXX_ENCRYPT_BLOCK_CFB(AES128); + AESNIXX_DECRYPT_BLOCK_CFB(AES128); + AESNIXX_ENCRYPT_BLOCK_OFB(AES128); + AESNIXX_DECRYPT_BLOCK_OFB(AES128); + AESNIXX_ENCRYPT_BLOCK_CTR(AES128); + AESNIXX_DECRYPT_BLOCK_CTR(AES128); + + namespace aes192 + { + typedef AesNI_AES192_Block Block; + typedef AesNI_AES192_RoundKeys RoundKeys; + typedef AesNI_AES192_Key Key; + } + + template <> + struct Types + { + typedef aes192::Block Block; + typedef aes192::RoundKeys RoundKeys; + typedef aes192::Key Key; + }; + + template <> + std::size_t get_number_of_rounds() + { + return 13; + } + + template <> + void from_string(aes192::Block& dest, const char* src) + { + aesni_AES192_parse_block(&dest, src, ErrorDetailsThrowsInDestructor()); + } + + template <> + std::string to_string(const aes192::Block& src) + { + AesNI_AES192_BlockString str; + aesni_AES192_format_block(&str, &src, ErrorDetailsThrowsInDestructor()); + return { str.str }; + } + + template <> + std::string to_matrix_string(const aes192::Block& src) + { + AesNI_AES192_BlockMatrixString str; + aesni_AES192_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor()); + return { str.str }; + } + + template <> + void from_string(aes192::Key& dest, const char* src) + { + aesni_AES192_parse_key(&dest, src, ErrorDetailsThrowsInDestructor()); + } + + template <> + std::string to_string(const aes192::Key& src) + { + AesNI_AES192_KeyString str; + aesni_AES192_format_key(&str, &src, ErrorDetailsThrowsInDestructor()); + return { str.str }; + } + + template <> + inline void expand_key( + const aes192::Key& key, + aes192::RoundKeys& encryption_keys) + { + aesni_AES192_expand_key(&key, &encryption_keys); + } + + template <> + inline void derive_decryption_keys( + const aes192::RoundKeys& encryption_keys, + aes192::RoundKeys& decryption_keys) + { + aesni_AES192_derive_decryption_keys( + &encryption_keys, &decryption_keys); + } + + AESNIXX_ENCRYPT_BLOCK_ECB(AES192); + AESNIXX_DECRYPT_BLOCK_ECB(AES192); + AESNIXX_ENCRYPT_BLOCK_CBC(AES192); + AESNIXX_DECRYPT_BLOCK_CBC(AES192); + AESNIXX_ENCRYPT_BLOCK_CFB(AES192); + AESNIXX_DECRYPT_BLOCK_CFB(AES192); + AESNIXX_ENCRYPT_BLOCK_OFB(AES192); + AESNIXX_DECRYPT_BLOCK_OFB(AES192); + AESNIXX_ENCRYPT_BLOCK_CTR(AES192); + AESNIXX_DECRYPT_BLOCK_CTR(AES192); + + namespace aes256 { - typedef AesNI_AES_Block Block; - - typedef AesNI_AES128_Key Key128; - typedef AesNI_AES192_Key Key192; - typedef AesNI_AES256_Key Key256; - - inline void make_block(Block& dest, int hi3, int hi2, int lo1, int lo0) - { - aesni_AES_make_block(&dest, hi3, hi2, lo1, lo0); - } - - inline void make_key(Key128& dest, int hi3, int hi2, int lo1, int lo0) - { - aesni_AES128_make_key(&dest, hi3, hi2, lo1, lo0); - } - - inline void make_key(Key192& dest, int hi5, int hi4, int hi3, int lo2, int lo1, int lo0) - { - aesni_AES192_make_key(&dest, hi5, hi4, hi3, lo2, lo1, lo0); - } - - inline void make_key(Key256& dest, int hi7, int hi6, int hi5, int hi4, int lo3, int lo2, int lo1, int lo0) - { - aesni_AES256_make_key(&dest, hi7, hi6, hi5, hi4, lo3, lo2, lo1, lo0); - } - - std::string to_string(const Block& block) - { - AesNI_AES_BlockString str; - aesni_AES_format_block(&str, &block, ErrorDetailsThrowsInDestructor()); - return std::string(str.str); - } - - std::string to_matrix_string(const Block& block) - { - AesNI_AES_BlockMatrixString str; - aesni_AES_format_block_as_matrix(&str, &block, ErrorDetailsThrowsInDestructor()); - return std::string(str.str); - } - - inline void from_string(Block& dest, const char* src) - { - aesni_AES_parse_block(&dest, src, ErrorDetailsThrowsInDestructor()); - } - - inline void from_string(Block& dest, const std::string& src) - { - from_string(dest, src.c_str()); - } - - std::string to_string(const Key128& block) - { - AesNI_AES128_KeyString str; - aesni_AES128_format_key(&str, &block, ErrorDetailsThrowsInDestructor()); - return std::string(str.str); - } - - std::string to_string(const Key192& block) - { - AesNI_AES192_KeyString str; - aesni_AES192_format_key(&str, &block, ErrorDetailsThrowsInDestructor()); - return std::string(str.str); - } - - std::string to_string(const Key256& block) - { - AesNI_AES256_KeyString str; - aesni_AES256_format_key(&str, &block, ErrorDetailsThrowsInDestructor()); - return std::string(str.str); - } - - inline void from_string(Key128& dest, const char* src) - { - aesni_AES128_parse_key(&dest, src, ErrorDetailsThrowsInDestructor()); - } - - inline void from_string(Key192& dest, const char* src) - { - aesni_AES192_parse_key(&dest, src, ErrorDetailsThrowsInDestructor()); - } - - inline void from_string(Key256& dest, const char* src) - { - aesni_AES256_parse_key(&dest, src, ErrorDetailsThrowsInDestructor()); - } - - inline void from_string(Key128& dest, const std::string& src) - { - return from_string(dest, src.c_str()); - } - - inline void from_string(Key192& dest, const std::string& src) - { - return from_string(dest, src.c_str()); - } - - inline void from_string(Key256& dest, const std::string& src) - { - return from_string(dest, src.c_str()); - } - - typedef AesNI_AES128_RoundKeys RoundKeys128; - typedef AesNI_AES192_RoundKeys RoundKeys192; - typedef AesNI_AES256_RoundKeys RoundKeys256; - - template - inline std::size_t get_number_of_rounds(const RoundKeysT& round_keys) - { - return sizeof(round_keys) / sizeof(Block128); - } - - inline void expand_key( - const Key128& key, - RoundKeys128& encryption_keys) - { - aesni_AES128_expand_key(&key, &encryption_keys); - } - - inline void expand_key( - const Key192& key, - RoundKeys192& encryption_keys) - { - aesni_AES192_expand_key(&key, &encryption_keys); - } - - inline void expand_key( - const Key256& key, - RoundKeys256& encryption_keys) - { - aesni_AES256_expand_key(&key, &encryption_keys); - } - - inline void derive_decryption_keys( - const RoundKeys128& encryption_keys, - RoundKeys128& decryption_keys) - { - aesni_AES128_derive_decryption_keys( - &encryption_keys, &decryption_keys); - } - - inline void derive_decryption_keys( - const RoundKeys192& encryption_keys, - RoundKeys192& decryption_keys) - { - aesni_AES192_derive_decryption_keys( - &encryption_keys, &decryption_keys); - } - - inline void derive_decryption_keys( - const RoundKeys256& encryption_keys, - RoundKeys256& decryption_keys) - { - aesni_AES256_derive_decryption_keys( - &encryption_keys, &decryption_keys); - } - - inline Block encrypt_ecb( - const Block& plaintext, - const RoundKeys128& encryption_keys) - { - return aesni_AES128_encrypt_block_ECB(plaintext, &encryption_keys); - } - - inline Block decrypt_ecb( - const Block& ciphertext, - const RoundKeys128& decryption_keys) - { - return aesni_AES128_decrypt_block_ECB(ciphertext, &decryption_keys); - } - - inline Block encrypt_cbc( - const Block& plaintext, - const RoundKeys128& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES128_encrypt_block_CBC(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_cbc( - const Block& ciphertext, - const RoundKeys128& decryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES128_decrypt_block_CBC(ciphertext, &decryption_keys, iv, &next_iv); - } - - inline Block encrypt_cfb( - const Block& plaintext, - const RoundKeys128& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES128_encrypt_block_CFB(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_cfb( - const Block& ciphertext, - const RoundKeys128& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES128_decrypt_block_CFB(ciphertext, &encryption_keys, iv, &next_iv); - } - - inline Block encrypt_ofb( - const Block& plaintext, - const RoundKeys128& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES128_encrypt_block_OFB(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_ofb( - const Block& ciphertext, - const RoundKeys128& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES128_decrypt_block_OFB(ciphertext, &encryption_keys, iv, &next_iv); - } - - inline Block encrypt_ctr( - const Block& plaintext, - const RoundKeys128& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES128_encrypt_block_CTR(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_ctr( - const Block& ciphertext, - const RoundKeys128& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES128_decrypt_block_CTR(ciphertext, &encryption_keys, iv, &next_iv); - } - - inline Block encrypt_ecb( - const Block& plaintext, - const RoundKeys192& encryption_keys) - { - return aesni_AES192_encrypt_block_ECB(plaintext, &encryption_keys); - } - - inline Block decrypt_ecb( - const Block& ciphertext, - const RoundKeys192& decryption_keys) - { - return aesni_AES192_decrypt_block_ECB(ciphertext, &decryption_keys); - } - - inline Block encrypt_cbc( - const Block& plaintext, - const RoundKeys192& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES192_encrypt_block_CBC(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_cbc( - const Block& ciphertext, - const RoundKeys192& decryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES192_decrypt_block_CBC(ciphertext, &decryption_keys, iv, &next_iv); - } - - inline Block encrypt_cfb( - const Block& plaintext, - const RoundKeys192& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES192_encrypt_block_CFB(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_cfb( - const Block& ciphertext, - const RoundKeys192& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES192_decrypt_block_CFB(ciphertext, &encryption_keys, iv, &next_iv); - } - - inline Block encrypt_ofb( - const Block& plaintext, - const RoundKeys192& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES192_encrypt_block_OFB(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_ofb( - const Block& ciphertext, - const RoundKeys192& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES192_decrypt_block_OFB(ciphertext, &encryption_keys, iv, &next_iv); - } - - inline Block encrypt_ctr( - const Block& plaintext, - const RoundKeys192& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES192_encrypt_block_CTR(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_ctr( - const Block& ciphertext, - const RoundKeys192& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES192_decrypt_block_CTR(ciphertext, &encryption_keys, iv, &next_iv); - } - - inline Block encrypt_ecb( - const Block& plaintext, - const RoundKeys256& encryption_keys) - { - return aesni_AES256_encrypt_block_ECB(plaintext, &encryption_keys); - } - - inline Block decrypt_ecb( - const Block& ciphertext, - const RoundKeys256& decryption_keys) - { - return aesni_AES256_decrypt_block_ECB(ciphertext, &decryption_keys); - } - - inline Block encrypt_cbc( - const Block& plaintext, - const RoundKeys256& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES256_encrypt_block_CBC(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_cbc( - const Block& ciphertext, - const RoundKeys256& decryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES256_decrypt_block_CBC(ciphertext, &decryption_keys, iv, &next_iv); - } - - inline Block encrypt_cfb( - const Block& plaintext, - const RoundKeys256& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES256_encrypt_block_CFB(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_cfb( - const Block& ciphertext, - const RoundKeys256& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES256_decrypt_block_CFB(ciphertext, &encryption_keys, iv, &next_iv); - } - - inline Block encrypt_ofb( - const Block& plaintext, - const RoundKeys256& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES256_encrypt_block_OFB(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_ofb( - const Block& ciphertext, - const RoundKeys256& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES256_decrypt_block_OFB(ciphertext, &encryption_keys, iv, &next_iv); - } - - inline Block encrypt_ctr( - const Block& plaintext, - const RoundKeys256& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES256_encrypt_block_CTR(plaintext, &encryption_keys, iv, &next_iv); - } - - inline Block decrypt_ctr( - const Block& ciphertext, - const RoundKeys256& encryption_keys, - const Block& iv, - Block& next_iv) - { - return aesni_AES256_decrypt_block_CTR(ciphertext, &encryption_keys, iv, &next_iv); - } - - template - struct Types; - - template <> - struct Types - { - typedef aesni::aes::Block BlockT; - typedef aesni::aes::Key128 KeyT; - typedef aesni::aes::RoundKeys128 RoundKeysT; - }; - - template <> - struct Types - { - typedef aesni::aes::Block BlockT; - typedef aesni::aes::Key192 KeyT; - typedef aesni::aes::RoundKeys192 RoundKeysT; - }; - - template <> - struct Types - { - typedef aesni::aes::Block BlockT; - typedef aesni::aes::Key256 KeyT; - typedef aesni::aes::RoundKeys256 RoundKeysT; - }; - - template - struct Encrypt; - - template - struct Encrypt - { - Encrypt(const typename Types::KeyT& key, - const typename Types::BlockT& iv) - { - expand_key(key, encryption_keys); - derive_decryption_keys(encryption_keys, decryption_keys); - } - - inline typename Types::BlockT encrypt(const typename Types::BlockT& plaintext) - { - return encrypt_ecb(plaintext, encryption_keys); - } - - inline typename Types::BlockT decrypt(const typename Types::BlockT& ciphertext) - { - return decrypt_ecb(ciphertext, decryption_keys); - } - - typename Types::RoundKeysT encryption_keys; - typename Types::RoundKeysT decryption_keys; - }; - - template - struct Encrypt - { - Encrypt(const typename Types::KeyT& key, - const typename Types::BlockT& iv) - : iv(iv) - { - expand_key(key, encryption_keys); - derive_decryption_keys(encryption_keys, decryption_keys); - } - - inline typename Types::BlockT encrypt(const typename Types::BlockT& plaintext) - { - return encrypt_cbc(plaintext, encryption_keys, iv, iv); - } - - inline typename Types::BlockT decrypt(const typename Types::BlockT& ciphertext) - { - return decrypt_cbc(ciphertext, decryption_keys, iv, iv); - } - - typename Types::BlockT iv; - typename Types::RoundKeysT encryption_keys; - typename Types::RoundKeysT decryption_keys; - }; - - template - struct Encrypt - { - Encrypt(const typename Types::KeyT& key, - const typename Types::BlockT& iv) - : iv(iv) - { - expand_key(key, encryption_keys); - } - - inline typename Types::BlockT encrypt(const typename Types::BlockT& plaintext) - { - return encrypt_cfb(plaintext, encryption_keys, iv, iv); - } - - inline typename Types::BlockT decrypt(const typename Types::BlockT& ciphertext) - { - return decrypt_cfb(ciphertext, encryption_keys, iv, iv); - } - - typename Types::BlockT iv; - typename Types::RoundKeysT encryption_keys; - }; - - template - struct Encrypt - { - Encrypt(const typename Types::KeyT& key, - const typename Types::BlockT& iv) - : iv(iv) - { - expand_key(key, encryption_keys); - } - - inline typename Types::BlockT encrypt(const typename Types::BlockT& plaintext) - { - return encrypt_ofb(plaintext, encryption_keys, iv, iv); - } - - inline typename Types::BlockT decrypt(const typename Types::BlockT& ciphertext) - { - return decrypt_ofb(ciphertext, encryption_keys, iv, iv); - } - - typename Types::BlockT iv; - typename Types::RoundKeysT encryption_keys; - }; - - template - struct Encrypt - { - Encrypt(const typename Types::KeyT& key, - const typename Types::BlockT& iv) - : iv(iv) - { - expand_key(key, encryption_keys); - } - - inline typename Types::BlockT encrypt(const typename Types::BlockT& plaintext) - { - return encrypt_ctr(plaintext, encryption_keys, iv, iv); - } - - inline typename Types::BlockT decrypt(const typename Types::BlockT& ciphertext) - { - return decrypt_ctr(ciphertext, encryption_keys, iv, iv); - } - - typename Types::RoundKeysT encryption_keys; - typename Types::BlockT iv; - }; + typedef AesNI_AES256_Block Block; + typedef AesNI_AES256_RoundKeys RoundKeys; + typedef AesNI_AES256_Key Key; } + + template <> + struct Types + { + typedef aes256::Block Block; + typedef aes256::RoundKeys RoundKeys; + typedef aes256::Key Key; + }; + + template <> + std::size_t get_number_of_rounds() + { + return 15; + } + + template <> + void from_string(aes256::Block& dest, const char* src) + { + aesni_AES256_parse_block(&dest, src, ErrorDetailsThrowsInDestructor()); + } + + template <> + std::string to_string(const aes256::Block& src) + { + AesNI_AES256_BlockString str; + aesni_AES256_format_block(&str, &src, ErrorDetailsThrowsInDestructor()); + return { str.str }; + } + + template <> + std::string to_matrix_string(const aes256::Block& src) + { + AesNI_AES256_BlockMatrixString str; + aesni_AES256_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor()); + return { str.str }; + } + + template <> + void from_string(aes256::Key& dest, const char* src) + { + aesni_AES256_parse_key(&dest, src, ErrorDetailsThrowsInDestructor()); + } + + template <> + std::string to_string(const aes256::Key& src) + { + AesNI_AES256_KeyString str; + aesni_AES256_format_key(&str, &src, ErrorDetailsThrowsInDestructor()); + return { str.str }; + } + + template <> + inline void expand_key( + const aes256::Key& key, + aes256::RoundKeys& encryption_keys) + { + aesni_AES256_expand_key(&key, &encryption_keys); + } + + template <> + inline void derive_decryption_keys( + const aes256::RoundKeys& encryption_keys, + aes256::RoundKeys& decryption_keys) + { + aesni_AES256_derive_decryption_keys( + &encryption_keys, &decryption_keys); + } + + AESNIXX_ENCRYPT_BLOCK_ECB(AES256); + AESNIXX_DECRYPT_BLOCK_ECB(AES256); + AESNIXX_ENCRYPT_BLOCK_CBC(AES256); + AESNIXX_DECRYPT_BLOCK_CBC(AES256); + AESNIXX_ENCRYPT_BLOCK_CFB(AES256); + AESNIXX_DECRYPT_BLOCK_CFB(AES256); + AESNIXX_ENCRYPT_BLOCK_OFB(AES256); + AESNIXX_DECRYPT_BLOCK_OFB(AES256); + AESNIXX_ENCRYPT_BLOCK_CTR(AES256); + AESNIXX_DECRYPT_BLOCK_CTR(AES256); } diff --git a/cxx/include/aesnixx/all.hpp b/cxx/include/aesnixx/all.hpp index 2bdf301..417d9ea 100644 --- a/cxx/include/aesnixx/all.hpp +++ b/cxx/include/aesnixx/all.hpp @@ -10,6 +10,7 @@ #include "aes.hpp" #include "algorithm.hpp" +#include "api.hpp" #include "data.hpp" #include "debug.hpp" #include "error.hpp" diff --git a/cxx/include/aesnixx/api.hpp b/cxx/include/aesnixx/api.hpp new file mode 100644 index 0000000..6995ae2 --- /dev/null +++ b/cxx/include/aesnixx/api.hpp @@ -0,0 +1,171 @@ +/** + * \file + * \author Egor Tensin + * \date 2015 + * \copyright This file is licensed under the terms of the MIT License. + * See LICENSE.txt for details. + */ + +#pragma once + +#include "algorithm.hpp" +#include "mode.hpp" + +#include + +#include +#include + +namespace aesni +{ + template + struct Types; + + template + std::size_t get_number_of_rounds(); + + template + void from_string( + typename Types::Block&, + const char*); + + template + inline void from_string( + typename Types::Block& dest, + const std::string& src) + { + from_string(dest, src.c_str()); + } + + template + std::string to_string(const typename Types::Block&); + + template + std::string to_matrix_string(const typename Types::Block&); + + template + void from_string( + typename Types::Key&, + const char*); + + template + inline void from_string( + typename Types::Key& dest, + const std::string& src) + { + from_string(dest, src.c_str()); + } + + template + std::string to_string(const typename Types::Key&); + + template + inline void expand_key( + const typename Types::Key& key, + typename Types::RoundKeys& encryption_keys); + + template + inline void derive_decryption_keys( + const typename Types::RoundKeys& encryption_keys, + typename Types::RoundKeys& decryption_keys); + + template ::value>::type* = 0> + inline void encrypt_block( + const typename Types::Block& plaintext, + const typename Types::RoundKeys& round_keys, + typename Types::Block& iv, + typename Types::Block& ciphertext); + + template ::value>::type* = 0> + inline void encrypt_block( + const typename Types::Block& plaintext, + const typename Types::RoundKeys& round_keys, + typename Types::Block& ciphertext); + + template ::value>::type* = 0> + inline void encrypt_block( + const typename Types::Block& plaintext, + const typename Types::RoundKeys& round_keys, + typename Types::Block&, + typename Types::Block& ciphertext) + { + encrypt_block(plaintext, round_keys, ciphertext); + } + + template ::value>::type* = 0> + inline void decrypt_block( + const typename Types::Block& ciphertext, + const typename Types::RoundKeys& round_keys, + typename Types::Block& iv, + typename Types::Block& plaintext); + + template ::value>::type* = 0> + inline void decrypt_block( + const typename Types::Block& ciphertext, + const typename Types::RoundKeys& round_keys, + typename Types::Block& plaintext); + + template ::value>::type* = 0> + inline void decrypt_block( + const typename Types::Block& ciphertext, + const typename Types::RoundKeys& round_keys, + typename Types::Block&, + typename Types::Block& plaintext) + { + decrypt_block(ciphertext, round_keys, plaintext); + } + + template + struct EncryptWrapper + { + EncryptWrapper( + const typename Types::Key& key, + const typename Types::Block& iv) : iv(iv) + { + expand_key(key, encryption_keys); + } + + inline void encrypt_block( + const typename Types::Block& plaintext, + typename Types::Block& ciphertext) + { + aesni::encrypt_block( + plaintext, encryption_keys, iv, ciphertext); + } + + typename Types::Block iv; + typename Types::RoundKeys encryption_keys; + }; + + template + struct DecryptWrapper + { + DecryptWrapper( + const typename Types::Key& key, + const typename Types::Block& iv) : iv(iv) + { + typename Types::RoundKeys encryption_keys; + expand_key(key, encryption_keys); + + if (ModeUsesEncryptionKeysOnly::value) + { + decryption_keys = encryption_keys; + } + else + { + derive_decryption_keys(encryption_keys, decryption_keys); + } + } + + inline void decrypt_block( + const typename Types::Block& ciphertext, + typename Types::Block& plaintext) + { + aesni::decrypt_block( + ciphertext, decryption_keys, iv, plaintext); + } + + typename Types::Block iv; + typename Types::RoundKeys decryption_keys; + }; +} diff --git a/cxx/include/aesnixx/mode.hpp b/cxx/include/aesnixx/mode.hpp index a0af051..e19dbbd 100644 --- a/cxx/include/aesnixx/mode.hpp +++ b/cxx/include/aesnixx/mode.hpp @@ -45,4 +45,112 @@ namespace aesni { return mode != AESNI_ECB && mode != AESNI_CBC; } + +#define AESNIXX_ENCRYPT_BLOCK_ECB(prefix) \ + template <> \ + inline void encrypt_block( \ + const typename Types::Block& plaintext, \ + const typename Types::RoundKeys& encryption_keys, \ + typename Types::Block& ciphertext) \ + { \ + ciphertext = aesni_## prefix ##_encrypt_block_ECB(plaintext, &encryption_keys); \ + } + +#define AESNIXX_DECRYPT_BLOCK_ECB(prefix) \ + template <> \ + inline void decrypt_block( \ + const typename Types::Block& ciphertext, \ + const typename Types::RoundKeys& decryption_keys, \ + typename Types::Block& plaintext) \ + { \ + plaintext = aesni_## prefix ##_decrypt_block_ECB(ciphertext, &decryption_keys); \ + } + +#define AESNIXX_ENCRYPT_BLOCK_CBC(prefix) \ + template <> \ + inline void encrypt_block( \ + const typename Types::Block& plaintext, \ + const typename Types::RoundKeys& encryption_keys, \ + typename Types::Block& iv, \ + typename Types::Block& ciphertext) \ + { \ + ciphertext = aesni_## prefix ##_encrypt_block_CBC(plaintext, &encryption_keys, iv, &iv); \ + } + +#define AESNIXX_DECRYPT_BLOCK_CBC(prefix) \ + template <> \ + inline void decrypt_block( \ + const typename Types::Block& ciphertext, \ + const typename Types::RoundKeys& decryption_keys, \ + typename Types::Block& iv, \ + typename Types::Block& plaintext) \ + { \ + plaintext = aesni_## prefix ##_decrypt_block_CBC(ciphertext, &decryption_keys, iv, &iv); \ + } + +#define AESNIXX_ENCRYPT_BLOCK_CFB(prefix) \ + template <> \ + inline void encrypt_block( \ + const typename Types::Block& plaintext, \ + const typename Types::RoundKeys& encryption_keys, \ + typename Types::Block& iv, \ + typename Types::Block& ciphertext) \ + { \ + ciphertext = aesni_## prefix ##_encrypt_block_CFB(plaintext, &encryption_keys, iv, &iv); \ + } + +#define AESNIXX_DECRYPT_BLOCK_CFB(prefix) \ + template <> \ + inline void decrypt_block( \ + const typename Types::Block& ciphertext, \ + const typename Types::RoundKeys& encryption_keys, \ + typename Types::Block& iv, \ + typename Types::Block& plaintext) \ + { \ + plaintext = aesni_## prefix ##_decrypt_block_CFB(ciphertext, &encryption_keys, iv, &iv); \ + } + +#define AESNIXX_ENCRYPT_BLOCK_OFB(prefix) \ + template <> \ + inline void encrypt_block( \ + const typename Types::Block& plaintext, \ + const typename Types::RoundKeys& encryption_keys, \ + typename Types::Block& iv, \ + typename Types::Block& ciphertext) \ + { \ + ciphertext = aesni_## prefix ##_encrypt_block_OFB(plaintext, &encryption_keys, iv, &iv); \ + } + +#define AESNIXX_DECRYPT_BLOCK_OFB(prefix) \ + template <> \ + inline void decrypt_block( \ + const typename Types::Block& ciphertext, \ + const typename Types::RoundKeys& encryption_keys, \ + typename Types::Block& iv, \ + typename Types::Block& plaintext) \ + { \ + plaintext = aesni_## prefix ##_decrypt_block_OFB(ciphertext, &encryption_keys, iv, &iv); \ + } + +#define AESNIXX_ENCRYPT_BLOCK_CTR(prefix) \ + template <> \ + inline void encrypt_block( \ + const typename Types::Block& plaintext, \ + const typename Types::RoundKeys& encryption_keys, \ + typename Types::Block& iv, \ + typename Types::Block& ciphertext) \ + { \ + ciphertext = aesni_## prefix ##_encrypt_block_CTR(plaintext, &encryption_keys, iv, &iv); \ + } + +#define AESNIXX_DECRYPT_BLOCK_CTR(prefix) \ + template <> \ + inline void decrypt_block( \ + const typename Types::Block& ciphertext, \ + const typename Types::RoundKeys& encryption_keys, \ + typename Types::Block& iv, \ + typename Types::Block& plaintext) \ + { \ + plaintext = aesni_## prefix ##_decrypt_block_CTR(ciphertext, &encryption_keys, iv, &iv); \ + } } -- cgit v1.2.3