diff options
author | Egor Tensin <Egor.Tensin@gmail.com> | 2019-12-21 13:33:50 +0300 |
---|---|---|
committer | Egor Tensin <Egor.Tensin@gmail.com> | 2019-12-21 13:33:50 +0300 |
commit | 351c5188013fff041c7217aed64478cfc7643480 (patch) | |
tree | c918b5093ac45394439f3dff30da37b809173603 /aesxx/include | |
parent | cmake: install libraries & their headers (diff) | |
download | aes-tools-351c5188013fff041c7217aed64478cfc7643480.tar.gz aes-tools-351c5188013fff041c7217aed64478cfc7643480.zip |
restructure the project
Diffstat (limited to 'aesxx/include')
-rw-r--r-- | aesxx/include/aesxx/aes.hpp | 275 | ||||
-rw-r--r-- | aesxx/include/aesxx/algorithm.hpp | 13 | ||||
-rw-r--r-- | aesxx/include/aesxx/all.hpp | 15 | ||||
-rw-r--r-- | aesxx/include/aesxx/api.hpp | 174 | ||||
-rw-r--r-- | aesxx/include/aesxx/box.hpp | 207 | ||||
-rw-r--r-- | aesxx/include/aesxx/data.hpp | 55 | ||||
-rw-r--r-- | aesxx/include/aesxx/debug.hpp | 174 | ||||
-rw-r--r-- | aesxx/include/aesxx/error.hpp | 104 | ||||
-rw-r--r-- | aesxx/include/aesxx/mode.hpp | 153 |
9 files changed, 1170 insertions, 0 deletions
diff --git a/aesxx/include/aesxx/aes.hpp b/aesxx/include/aesxx/aes.hpp new file mode 100644 index 0000000..efac790 --- /dev/null +++ b/aesxx/include/aesxx/aes.hpp @@ -0,0 +1,275 @@ +// Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "AES tools" project. +// For details, see https://github.com/egor-tensin/aes-tools. +// Distributed under the MIT License. + +#pragma once + +#include "algorithm.hpp" +#include "api.hpp" +#include "error.hpp" +#include "mode.hpp" + +#include <aes/all.h> + +#include <cstddef> + +#include <string> + +namespace aes +{ + namespace aes128 + { + typedef AES_AES128_Block Block; + typedef AES_AES128_RoundKeys RoundKeys; + typedef AES_AES128_Key Key; + } + + template <> + struct Types<AES_AES128> + { + typedef aes128::Block Block; + typedef aes128::RoundKeys RoundKeys; + typedef aes128::Key Key; + }; + + template <> + inline std::size_t get_number_of_rounds<AES_AES128>() + { + return 11; + } + + template <> + inline void from_string<AES_AES128>(aes128::Block& dest, const char* src) + { + aes_AES128_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{}); + } + + template <> + inline std::string to_string<AES_AES128>(const aes128::Block& src) + { + AES_AES128_BlockString str; + aes_AES128_format_block(&str, &src, ErrorDetailsThrowsInDestructor{}); + return {str.str}; + } + + template <> + inline std::string to_matrix_string<AES_AES128>(const aes128::Block& src) + { + AES_AES128_BlockMatrixString str; + aes_AES128_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{}); + return {str.str}; + } + + template <> + inline void from_string<AES_AES128>(aes128::Key& dest, const char* src) + { + aes_AES128_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{}); + } + + template <> + inline std::string to_string<AES_AES128>(const aes128::Key& src) + { + AES_AES128_KeyString str; + aes_AES128_format_key(&str, &src, ErrorDetailsThrowsInDestructor{}); + return {str.str}; + } + + template <> + inline void expand_key<AES_AES128>( + const aes128::Key& key, + aes128::RoundKeys& encryption_keys) + { + aes_AES128_expand_key(&key, &encryption_keys); + } + + template <> + inline void derive_decryption_keys<AES_AES128>( + const aes128::RoundKeys& encryption_keys, + aes128::RoundKeys& decryption_keys) + { + aes_AES128_derive_decryption_keys( + &encryption_keys, &decryption_keys); + } + + AESXX_ENCRYPT_BLOCK_ECB(AES128); + AESXX_DECRYPT_BLOCK_ECB(AES128); + AESXX_ENCRYPT_BLOCK_CBC(AES128); + AESXX_DECRYPT_BLOCK_CBC(AES128); + AESXX_ENCRYPT_BLOCK_CFB(AES128); + AESXX_DECRYPT_BLOCK_CFB(AES128); + AESXX_ENCRYPT_BLOCK_OFB(AES128); + AESXX_DECRYPT_BLOCK_OFB(AES128); + AESXX_ENCRYPT_BLOCK_CTR(AES128); + AESXX_DECRYPT_BLOCK_CTR(AES128); + + namespace aes192 + { + typedef AES_AES192_Block Block; + typedef AES_AES192_RoundKeys RoundKeys; + typedef AES_AES192_Key Key; + } + + template <> + struct Types<AES_AES192> + { + typedef aes192::Block Block; + typedef aes192::RoundKeys RoundKeys; + typedef aes192::Key Key; + }; + + template <> + inline std::size_t get_number_of_rounds<AES_AES192>() + { + return 13; + } + + template <> + inline void from_string<AES_AES192>(aes192::Block& dest, const char* src) + { + aes_AES192_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{}); + } + + template <> + inline std::string to_string<AES_AES192>(const aes192::Block& src) + { + AES_AES192_BlockString str; + aes_AES192_format_block(&str, &src, ErrorDetailsThrowsInDestructor{}); + return {str.str}; + } + + template <> + inline std::string to_matrix_string<AES_AES192>(const aes192::Block& src) + { + AES_AES192_BlockMatrixString str; + aes_AES192_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{}); + return {str.str}; + } + + template <> + inline void from_string<AES_AES192>(aes192::Key& dest, const char* src) + { + aes_AES192_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{}); + } + + template <> + inline std::string to_string<AES_AES192>(const aes192::Key& src) + { + AES_AES192_KeyString str; + aes_AES192_format_key(&str, &src, ErrorDetailsThrowsInDestructor{}); + return {str.str}; + } + + template <> + inline void expand_key<AES_AES192>( + const aes192::Key& key, + aes192::RoundKeys& encryption_keys) + { + aes_AES192_expand_key(&key, &encryption_keys); + } + + template <> + inline void derive_decryption_keys<AES_AES192>( + const aes192::RoundKeys& encryption_keys, + aes192::RoundKeys& decryption_keys) + { + aes_AES192_derive_decryption_keys( + &encryption_keys, &decryption_keys); + } + + AESXX_ENCRYPT_BLOCK_ECB(AES192); + AESXX_DECRYPT_BLOCK_ECB(AES192); + AESXX_ENCRYPT_BLOCK_CBC(AES192); + AESXX_DECRYPT_BLOCK_CBC(AES192); + AESXX_ENCRYPT_BLOCK_CFB(AES192); + AESXX_DECRYPT_BLOCK_CFB(AES192); + AESXX_ENCRYPT_BLOCK_OFB(AES192); + AESXX_DECRYPT_BLOCK_OFB(AES192); + AESXX_ENCRYPT_BLOCK_CTR(AES192); + AESXX_DECRYPT_BLOCK_CTR(AES192); + + namespace aes256 + { + typedef AES_AES256_Block Block; + typedef AES_AES256_RoundKeys RoundKeys; + typedef AES_AES256_Key Key; + } + + template <> + struct Types<AES_AES256> + { + typedef aes256::Block Block; + typedef aes256::RoundKeys RoundKeys; + typedef aes256::Key Key; + }; + + template <> + inline std::size_t get_number_of_rounds<AES_AES256>() + { + return 15; + } + + template <> + inline void from_string<AES_AES256>(aes256::Block& dest, const char* src) + { + aes_AES256_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{}); + } + + template <> + inline std::string to_string<AES_AES256>(const aes256::Block& src) + { + AES_AES256_BlockString str; + aes_AES256_format_block(&str, &src, ErrorDetailsThrowsInDestructor{}); + return {str.str}; + } + + template <> + inline std::string to_matrix_string<AES_AES256>(const aes256::Block& src) + { + AES_AES256_BlockMatrixString str; + aes_AES256_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{}); + return {str.str}; + } + + template <> + inline void from_string<AES_AES256>(aes256::Key& dest, const char* src) + { + aes_AES256_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{}); + } + + template <> + inline std::string to_string<AES_AES256>(const aes256::Key& src) + { + AES_AES256_KeyString str; + aes_AES256_format_key(&str, &src, ErrorDetailsThrowsInDestructor{}); + return {str.str}; + } + + template <> + inline void expand_key<AES_AES256>( + const aes256::Key& key, + aes256::RoundKeys& encryption_keys) + { + aes_AES256_expand_key(&key, &encryption_keys); + } + + template <> + inline void derive_decryption_keys<AES_AES256>( + const aes256::RoundKeys& encryption_keys, + aes256::RoundKeys& decryption_keys) + { + aes_AES256_derive_decryption_keys( + &encryption_keys, &decryption_keys); + } + + AESXX_ENCRYPT_BLOCK_ECB(AES256); + AESXX_DECRYPT_BLOCK_ECB(AES256); + AESXX_ENCRYPT_BLOCK_CBC(AES256); + AESXX_DECRYPT_BLOCK_CBC(AES256); + AESXX_ENCRYPT_BLOCK_CFB(AES256); + AESXX_DECRYPT_BLOCK_CFB(AES256); + AESXX_ENCRYPT_BLOCK_OFB(AES256); + AESXX_DECRYPT_BLOCK_OFB(AES256); + AESXX_ENCRYPT_BLOCK_CTR(AES256); + AESXX_DECRYPT_BLOCK_CTR(AES256); +} diff --git a/aesxx/include/aesxx/algorithm.hpp b/aesxx/include/aesxx/algorithm.hpp new file mode 100644 index 0000000..823e57f --- /dev/null +++ b/aesxx/include/aesxx/algorithm.hpp @@ -0,0 +1,13 @@ +// Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "AES tools" project. +// For details, see https://github.com/egor-tensin/aes-tools. +// Distributed under the MIT License. + +#pragma once + +#include <aes/all.h> + +namespace aes +{ + typedef AES_Algorithm Algorithm; +} diff --git a/aesxx/include/aesxx/all.hpp b/aesxx/include/aesxx/all.hpp new file mode 100644 index 0000000..99202a7 --- /dev/null +++ b/aesxx/include/aesxx/all.hpp @@ -0,0 +1,15 @@ +// Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "AES tools" project. +// For details, see https://github.com/egor-tensin/aes-tools. +// Distributed under the MIT License. + +#pragma once + +#include "aes.hpp" +#include "algorithm.hpp" +#include "api.hpp" +#include "box.hpp" +#include "data.hpp" +#include "debug.hpp" +#include "error.hpp" +#include "mode.hpp" diff --git a/aesxx/include/aesxx/api.hpp b/aesxx/include/aesxx/api.hpp new file mode 100644 index 0000000..68112bf --- /dev/null +++ b/aesxx/include/aesxx/api.hpp @@ -0,0 +1,174 @@ +// Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "AES tools" project. +// For details, see https://github.com/egor-tensin/aes-tools. +// Distributed under the MIT License. + +#pragma once + +#include "algorithm.hpp" +#include "mode.hpp" + +#include <cstddef> + +#include <string> +#include <type_traits> + +namespace aes +{ + template <Algorithm algorithm> + struct Types; + + template <Algorithm algorithm> + std::size_t get_number_of_rounds(); + + template <Algorithm algorithm> + void from_string( + typename Types<algorithm>::Block&, + const char*); + + template <Algorithm algorithm> + void from_string( + typename Types<algorithm>::Block& dest, + const std::string& src) + { + from_string<algorithm>(dest, src.c_str()); + } + + template <Algorithm algorithm> + std::string to_string(const typename Types<algorithm>::Block&); + + template <Algorithm algorithm> + std::string to_matrix_string(const typename Types<algorithm>::Block&); + + template <Algorithm algorithm> + void from_string( + typename Types<algorithm>::Key&, + const char*); + + template <Algorithm algorithm> + void from_string( + typename Types<algorithm>::Key& dest, + const std::string& src) + { + from_string<algorithm>(dest, src.c_str()); + } + + template <Algorithm algorithm> + std::string to_string(const typename Types<algorithm>::Key&); + + template <Algorithm algorithm> + void expand_key( + const typename Types<algorithm>::Key& key, + typename Types<algorithm>::RoundKeys& encryption_keys); + + template <Algorithm algorithm> + void derive_decryption_keys( + const typename Types<algorithm>::RoundKeys& encryption_keys, + typename Types<algorithm>::RoundKeys& decryption_keys); + + template <Algorithm algorithm, Mode mode, + typename std::enable_if<ModeRequiresInitVector<mode>::value>::type* = nullptr> + void encrypt_block( + const typename Types<algorithm>::Block& plaintext, + const typename Types<algorithm>::RoundKeys& round_keys, + typename Types<algorithm>::Block& iv, + typename Types<algorithm>::Block& ciphertext); + + template <Algorithm algorithm, Mode mode, + typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr> + void encrypt_block( + const typename Types<algorithm>::Block& plaintext, + const typename Types<algorithm>::RoundKeys& round_keys, + typename Types<algorithm>::Block& ciphertext); + + template <Algorithm algorithm, Mode mode, + typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr> + void encrypt_block( + const typename Types<algorithm>::Block& plaintext, + const typename Types<algorithm>::RoundKeys& round_keys, + typename Types<algorithm>::Block&, + typename Types<algorithm>::Block& ciphertext) + { + encrypt_block<algorithm, mode>(plaintext, round_keys, ciphertext); + } + + template <Algorithm algorithm, Mode mode, + typename std::enable_if<ModeRequiresInitVector<mode>::value>::type* = nullptr> + void decrypt_block( + const typename Types<algorithm>::Block& ciphertext, + const typename Types<algorithm>::RoundKeys& round_keys, + typename Types<algorithm>::Block& iv, + typename Types<algorithm>::Block& plaintext); + + template <Algorithm algorithm, Mode mode, + typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr> + void decrypt_block( + const typename Types<algorithm>::Block& ciphertext, + const typename Types<algorithm>::RoundKeys& round_keys, + typename Types<algorithm>::Block& plaintext); + + template <Algorithm algorithm, Mode mode, + typename std::enable_if<!ModeRequiresInitVector<mode>::value>::type* = nullptr> + void decrypt_block( + const typename Types<algorithm>::Block& ciphertext, + const typename Types<algorithm>::RoundKeys& round_keys, + typename Types<algorithm>::Block&, + typename Types<algorithm>::Block& plaintext) + { + decrypt_block<algorithm, mode>(ciphertext, round_keys, plaintext); + } + + template <Algorithm algorithm, Mode mode> + struct EncryptWrapper + { + EncryptWrapper( + const typename Types<algorithm>::Key& key, + const typename Types<algorithm>::Block& iv) : iv{iv} + { + expand_key<algorithm>(key, encryption_keys); + } + + void encrypt_block( + const typename Types<algorithm>::Block& plaintext, + typename Types<algorithm>::Block& ciphertext) + { + aes::encrypt_block<algorithm, mode>( + plaintext, encryption_keys, iv, ciphertext); + } + + typename Types<algorithm>::Block iv; + typename Types<algorithm>::RoundKeys encryption_keys; + }; + + template <Algorithm algorithm, Mode mode> + struct DecryptWrapper + { + DecryptWrapper( + const typename Types<algorithm>::Key& key, + const typename Types<algorithm>::Block& iv) : iv{iv} + { + typename Types<algorithm>::RoundKeys encryption_keys; + expand_key<algorithm>(key, encryption_keys); + + if (ModeUsesEncryptionKeysOnly<mode>::value) + { + decryption_keys = encryption_keys; + } + else + { + derive_decryption_keys<algorithm>(encryption_keys, decryption_keys); + } + } + + void decrypt_block( + const typename Types<algorithm>::Block& ciphertext, + typename Types<algorithm>::Block& plaintext) + { + aes::decrypt_block<algorithm, mode>( + ciphertext, decryption_keys, iv, plaintext); + } + + typename Types<algorithm>::Block iv; + typename Types<algorithm>::RoundKeys decryption_keys; + }; +} diff --git a/aesxx/include/aesxx/box.hpp b/aesxx/include/aesxx/box.hpp new file mode 100644 index 0000000..076407c --- /dev/null +++ b/aesxx/include/aesxx/box.hpp @@ -0,0 +1,207 @@ +// Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "AES tools" project. +// For details, see https://github.com/egor-tensin/aes-tools. +// Distributed under the MIT License. + +#pragma once + +#include "algorithm.hpp" +#include "error.hpp" +#include "mode.hpp" + +#include <aes/all.h> + +#include <cstddef> + +#include <string> +#include <vector> + +namespace aes +{ + class Box + { + public: + typedef AES_BoxBlock Block; + typedef AES_BoxKey Key; + + static std::string format_key(const Key& src, Algorithm algorithm) + { + AES_BoxKeyString str; + aes_box_format_key( + &str, algorithm, &src, ErrorDetailsThrowsInDestructor{}); + return reinterpret_cast<const char*>(&str); + } + + static std::string format_block(const Block& src, Algorithm algorithm) + { + AES_BoxBlockString str; + aes_box_format_block( + &str, algorithm, &src, ErrorDetailsThrowsInDestructor{}); + return reinterpret_cast<const char*>(&str); + } + + static void parse_block( + Block& dest, + Algorithm algorithm, + const char* src) + { + aes_box_parse_block(&dest, algorithm, src, + ErrorDetailsThrowsInDestructor{}); + } + + static void parse_block( + Block& dest, + Algorithm algorithm, + const std::string& src) + { + parse_block(dest, algorithm, src.c_str()); + } + + static void parse_key( + Key& dest, + Algorithm algorithm, + const char* src) + { + aes_box_parse_key(&dest, algorithm, src, + ErrorDetailsThrowsInDestructor{}); + } + + static void parse_key( + Key& dest, + Algorithm algorithm, + const std::string& src) + { + parse_key(dest, algorithm, src.c_str()); + } + + Box(Algorithm algorithm, const Key& key) + : algorithm{algorithm} + , mode{AES_ECB} + { + aes_box_init(&impl, algorithm, &key, mode, nullptr, + ErrorDetailsThrowsInDestructor{}); + } + + Box(Algorithm algorithm, const Key& key, Mode mode, const Block& iv) + : algorithm{algorithm} + , mode{mode} + { + aes_box_init(&impl, algorithm, &key, mode, &iv, + ErrorDetailsThrowsInDestructor{}); + } + + void encrypt_block(const Block& plaintext, Block& ciphertext) + { + aes_box_encrypt_block( + &impl, &plaintext, &ciphertext, + ErrorDetailsThrowsInDestructor{}); + } + + void decrypt_block(const Block& ciphertext, Block& plaintext) + { + aes_box_decrypt_block( + &impl, &ciphertext, &plaintext, + ErrorDetailsThrowsInDestructor{}); + } + + std::vector<unsigned char> encrypt_buffer( + const void* src_buf, + std::size_t src_size) + { + std::size_t dest_size = 0; + + aes_box_encrypt_buffer( + &impl, + src_buf, + src_size, + nullptr, + &dest_size, + aes::ErrorDetailsThrowsInDestructor{}); + + std::vector<unsigned char> dest_buf; + dest_buf.resize(dest_size); + + aes_box_encrypt_buffer( + &impl, + src_buf, + src_size, + dest_buf.data(), + &dest_size, + aes::ErrorDetailsThrowsInDestructor{}); + + dest_buf.resize(dest_size); + return dest_buf; + } + + std::vector<unsigned char> decrypt_buffer( + const void* src_buf, + std::size_t src_size) + { + std::size_t dest_size = 0; + + aes_box_decrypt_buffer( + &impl, + src_buf, + src_size, + nullptr, + &dest_size, + aes::ErrorDetailsThrowsInDestructor{}); + + std::vector<unsigned char> dest_buf; + dest_buf.resize(dest_size); + + aes_box_decrypt_buffer( + &impl, + src_buf, + src_size, + dest_buf.data(), + &dest_size, + aes::ErrorDetailsThrowsInDestructor{}); + + dest_buf.resize(dest_size); + return dest_buf; + } + + std::string format_block(const Block& src) + { + return format_block(src, get_algorithm()); + } + + std::string format_key(const Key& src) + { + return format_key(src, get_algorithm()); + } + + void parse_block(Block& dest, const char* src) + { + parse_block(dest, get_algorithm(), src); + } + + void parse_block(Block& dest, const std::string& src) + { + parse_block(dest, src.c_str()); + } + + void parse_key(Key& dest, const char* src) + { + parse_key(dest, get_algorithm(), src); + } + + void parse_key(Key& dest, const std::string& src) + { + parse_key(dest, src.c_str()); + } + + Algorithm get_algorithm() const { return algorithm; } + + Mode get_mode() const { return mode; } + + private: + Key key; + + Algorithm algorithm; + Mode mode; + + AES_Box impl; + }; +} diff --git a/aesxx/include/aesxx/data.hpp b/aesxx/include/aesxx/data.hpp new file mode 100644 index 0000000..f36df5e --- /dev/null +++ b/aesxx/include/aesxx/data.hpp @@ -0,0 +1,55 @@ +// Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "AES tools" project. +// For details, see https://github.com/egor-tensin/aes-tools. +// Distributed under the MIT License. + +#pragma once + +#include "error.hpp" + +#include <aes/all.h> + +namespace aes +{ + typedef AES_Block128 Block128; + + inline void make_block(Block128& dest, int hi3, int hi2, int lo1, int lo0) + { + dest = aes_make_block128(hi3, hi2, lo1, lo0); + } + + inline void load_block(Block128& dest, const void* src) + { + dest = aes_load_block128(src); + } + + inline void load_block_aligned(Block128& dest, const void* src) + { + dest = aes_load_block128_aligned(src); + } + + inline void store_block(void* dest, Block128& src) + { + aes_store_block128(dest, src); + } + + inline void store_block_aligned(void* dest, Block128& src) + { + aes_store_block128_aligned(dest, src); + } + + inline Block128 xor_blocks(Block128& a, Block128& b) + { + return aes_xor_block128(a, b); + } + + inline Block128 reverse_byte_order(Block128& block) + { + return aes_reverse_byte_order_block128(block); + } + + inline Block128 inc_block(Block128& block) + { + return aes_inc_block128(block); + } +} diff --git a/aesxx/include/aesxx/debug.hpp b/aesxx/include/aesxx/debug.hpp new file mode 100644 index 0000000..96e81b5 --- /dev/null +++ b/aesxx/include/aesxx/debug.hpp @@ -0,0 +1,174 @@ +// Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "AES tools" project. +// For details, see https://github.com/egor-tensin/aes-tools. +// Distributed under the MIT License. + +#pragma once + +#ifdef WIN32 +#include <windows.h> +#include <DbgHelp.h> +#pragma comment(lib, "DbgHelp.Lib") +#endif + +#include <cstddef> + +#include <sstream> +#include <string> + +namespace aes +{ + namespace aux + { + class CallStackFormatter + { + public: + CallStackFormatter() = default; + + std::string format_address(const void* addr) const + { + #ifdef WIN32 + return format_address_win32(addr); + #else + return format_address_fallback(addr); + #endif + } + + private: + template <typename T> + static std::string put_between_brackets(const T& x) + { + std::ostringstream oss; + oss << "[" << x << "]"; + return oss.str(); + } + + template <typename T> + static std::string stringify(const T& x) + { + std::ostringstream oss; + oss << x; + return oss.str(); + } + + static std::string format_address_fallback(const void* addr) + { + return put_between_brackets(addr); + } + + static std::string format_module( + const std::string& module_name, + const void* offset = nullptr) + { + if (offset == nullptr) + return put_between_brackets(module_name); + else + return put_between_brackets(module_name + "+" + stringify(offset)); + } + + static std::string format_symbol( + const std::string& symbol_name, + const void* offset = nullptr) + { + return format_module(symbol_name, offset); + } + + static std::string format_symbol( + const std::string& module_name, + const std::string& symbol_name, + const void* offset = nullptr) + { + return format_symbol(module_name + "!" + symbol_name, offset); + } + + #ifdef WIN32 + class DbgHelp + { + public: + DbgHelp() + { + initialized_flag = SymInitialize(GetCurrentProcess(), NULL, TRUE) != FALSE; + } + + bool initialized() const + { + return initialized_flag; + } + + ~DbgHelp() + { + if (initialized_flag) + SymCleanup(GetCurrentProcess()); + } + + private: + bool initialized_flag = false; + + DbgHelp(const DbgHelp&) = delete; + DbgHelp& operator=(const DbgHelp&) = delete; + }; + + DbgHelp dbghelp; + + std::string format_address_win32(const void* addr) const + { + if (!dbghelp.initialized()) + return format_address_fallback(addr); + + DWORD64 symbol_info_buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME]; + const auto symbol_info = reinterpret_cast<SYMBOL_INFO*>(symbol_info_buf); + symbol_info->SizeOfStruct = sizeof(SYMBOL_INFO); + symbol_info->MaxNameLen = MAX_SYM_NAME; + + IMAGEHLP_MODULE64 module_info; + module_info.SizeOfStruct = sizeof(IMAGEHLP_MODULE64); + + DWORD64 symbol_offset; + + const auto symbol_resolved = SymFromAddr( + GetCurrentProcess(), + reinterpret_cast<DWORD64>(addr), + &symbol_offset, + symbol_info); + + if (symbol_resolved) + { + const auto module_resolved = SymGetModuleInfo64( + GetCurrentProcess(), + symbol_info->ModBase, + &module_info); + + if (module_resolved) + { + return format_symbol( + module_info.ModuleName, + symbol_info->Name, + reinterpret_cast<const void*>(symbol_offset)); + } + else + { + return format_symbol(symbol_info->Name, addr); + } + } + else + { + const auto module_resolved = SymGetModuleInfo64( + GetCurrentProcess(), + reinterpret_cast<DWORD64>(addr), + &module_info); + + if (module_resolved) + { + const auto module_offset = reinterpret_cast<const char*>(addr) - module_info.BaseOfImage; + return format_module(module_info.ModuleName, module_offset); + } + else + { + return format_address_fallback(addr); + } + } + } + #endif + }; + } +} diff --git a/aesxx/include/aesxx/error.hpp b/aesxx/include/aesxx/error.hpp new file mode 100644 index 0000000..4d2c783 --- /dev/null +++ b/aesxx/include/aesxx/error.hpp @@ -0,0 +1,104 @@ +// Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "AES tools" project. +// For details, see https://github.com/egor-tensin/aes-tools. +// Distributed under the MIT License. + +#pragma once + +#include "debug.hpp" + +#include <aes/all.h> + +#include <boost/config.hpp> + +#include <cstdlib> +#include <cstring> + +#include <algorithm> +#include <functional> +#include <ostream> +#include <stdexcept> +#include <string> +#include <vector> + +namespace aes +{ + class Error : public std::runtime_error + { + public: + Error(const AES_ErrorDetails& err_details) + : std::runtime_error{format_error_message(err_details)} + { + fill_call_stack(err_details); + } + + void for_each_addr( + const std::function<void (const void*, const std::string&)>& callback) const + { + aux::CallStackFormatter formatter; + + std::for_each( + call_stack, + call_stack + call_stack_len, + [&formatter, &callback] (const void* addr) + { + callback(addr, formatter.format_address(addr)); + }); + } + + private: + static std::string format_error_message(const AES_ErrorDetails& err_details) + { + std::vector<char> buf; + buf.resize(aes_format_error(&err_details, NULL, 0)); + aes_format_error(&err_details, buf.data(), buf.size()); + return {buf.begin(), buf.end()}; + } + + void fill_call_stack(const AES_ErrorDetails& err_details) + { + call_stack_len = err_details.call_stack_len; + + if (call_stack_len > AES_MAX_CALL_STACK_LENGTH) + call_stack_len = AES_MAX_CALL_STACK_LENGTH; + + std::memcpy(call_stack, err_details.call_stack, call_stack_len * sizeof(const void*)); + } + + std::size_t call_stack_len = 0; + const void* call_stack[AES_MAX_CALL_STACK_LENGTH] = {nullptr}; + }; + + inline std::ostream& operator<<(std::ostream& os, const Error& error) + { + os << "AES error: " << error.what() << '\n'; + os << "Call stack:\n"; + error.for_each_addr([&os] (const void* addr, const std::string& name) + { + os << '\t' << addr << ' ' << name << '\n'; + }); + return os; + } + + class ErrorDetailsThrowsInDestructor + { + public: + ErrorDetailsThrowsInDestructor() + { + aes_success(get()); + } + + ~ErrorDetailsThrowsInDestructor() BOOST_NOEXCEPT_IF(false) + { + if (aes_is_error(aes_get_error_code(get()))) + throw Error(impl); + } + + AES_ErrorDetails* get() { return &impl; } + + operator AES_ErrorDetails*() { return get(); } + + private: + AES_ErrorDetails impl; + }; +} diff --git a/aesxx/include/aesxx/mode.hpp b/aesxx/include/aesxx/mode.hpp new file mode 100644 index 0000000..1c6c4cf --- /dev/null +++ b/aesxx/include/aesxx/mode.hpp @@ -0,0 +1,153 @@ +// Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com> +// This file is part of the "AES tools" project. +// For details, see https://github.com/egor-tensin/aes-tools. +// Distributed under the MIT License. + +#pragma once + +#include <aes/all.h> + +#include <type_traits> + +namespace aes +{ + typedef AES_Mode Mode; + + template <Mode mode> + struct ModeRequiresInitVector : public std::true_type + { }; + + template <> + struct ModeRequiresInitVector<AES_ECB> : public std::false_type + { }; + + template <Mode mode> + struct ModeUsesEncryptionKeysOnly : public std::true_type + { }; + + inline bool mode_requires_init_vector(Mode mode) + { + return mode != AES_ECB; + } + + template <> + struct ModeUsesEncryptionKeysOnly<AES_ECB> : public std::false_type + { }; + + template <> + struct ModeUsesEncryptionKeysOnly<AES_CBC> : public std::false_type + { }; + + inline bool mode_uses_encryption_keys_only(Mode mode) + { + return mode != AES_ECB && mode != AES_CBC; + } + +#define AESXX_ENCRYPT_BLOCK_ECB(prefix) \ + template <> \ + inline void encrypt_block<AES_## prefix, AES_ECB>( \ + const typename Types<AES_## prefix>::Block& plaintext, \ + const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \ + typename Types<AES_## prefix>::Block& ciphertext) \ + { \ + ciphertext = aes_## prefix ##_encrypt_block_ECB(plaintext, &encryption_keys); \ + } + +#define AESXX_DECRYPT_BLOCK_ECB(prefix) \ + template <> \ + inline void decrypt_block<AES_## prefix, AES_ECB>( \ + const typename Types<AES_## prefix>::Block& ciphertext, \ + const typename Types<AES_## prefix>::RoundKeys& decryption_keys, \ + typename Types<AES_## prefix>::Block& plaintext) \ + { \ + plaintext = aes_## prefix ##_decrypt_block_ECB(ciphertext, &decryption_keys); \ + } + +#define AESXX_ENCRYPT_BLOCK_CBC(prefix) \ + template <> \ + inline void encrypt_block<AES_## prefix, AES_CBC>( \ + const typename Types<AES_## prefix>::Block& plaintext, \ + const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \ + typename Types<AES_## prefix>::Block& iv, \ + typename Types<AES_## prefix>::Block& ciphertext) \ + { \ + ciphertext = aes_## prefix ##_encrypt_block_CBC(plaintext, &encryption_keys, iv, &iv); \ + } + +#define AESXX_DECRYPT_BLOCK_CBC(prefix) \ + template <> \ + inline void decrypt_block<AES_## prefix, AES_CBC>( \ + const typename Types<AES_## prefix>::Block& ciphertext, \ + const typename Types<AES_## prefix>::RoundKeys& decryption_keys, \ + typename Types<AES_## prefix>::Block& iv, \ + typename Types<AES_## prefix>::Block& plaintext) \ + { \ + plaintext = aes_## prefix ##_decrypt_block_CBC(ciphertext, &decryption_keys, iv, &iv); \ + } + +#define AESXX_ENCRYPT_BLOCK_CFB(prefix) \ + template <> \ + inline void encrypt_block<AES_## prefix, AES_CFB>( \ + const typename Types<AES_## prefix>::Block& plaintext, \ + const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \ + typename Types<AES_## prefix>::Block& iv, \ + typename Types<AES_## prefix>::Block& ciphertext) \ + { \ + ciphertext = aes_## prefix ##_encrypt_block_CFB(plaintext, &encryption_keys, iv, &iv); \ + } + +#define AESXX_DECRYPT_BLOCK_CFB(prefix) \ + template <> \ + inline void decrypt_block<AES_## prefix, AES_CFB>( \ + const typename Types<AES_## prefix>::Block& ciphertext, \ + const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \ + typename Types<AES_## prefix>::Block& iv, \ + typename Types<AES_## prefix>::Block& plaintext) \ + { \ + plaintext = aes_## prefix ##_decrypt_block_CFB(ciphertext, &encryption_keys, iv, &iv); \ + } + +#define AESXX_ENCRYPT_BLOCK_OFB(prefix) \ + template <> \ + inline void encrypt_block<AES_## prefix, AES_OFB>( \ + const typename Types<AES_## prefix>::Block& plaintext, \ + const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \ + typename Types<AES_## prefix>::Block& iv, \ + typename Types<AES_## prefix>::Block& ciphertext) \ + { \ + ciphertext = aes_## prefix ##_encrypt_block_OFB(plaintext, &encryption_keys, iv, &iv); \ + } + +#define AESXX_DECRYPT_BLOCK_OFB(prefix) \ + template <> \ + inline void decrypt_block<AES_## prefix, AES_OFB>( \ + const typename Types<AES_## prefix>::Block& ciphertext, \ + const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \ + typename Types<AES_## prefix>::Block& iv, \ + typename Types<AES_## prefix>::Block& plaintext) \ + { \ + plaintext = aes_## prefix ##_decrypt_block_OFB(ciphertext, &encryption_keys, iv, &iv); \ + } + +#define AESXX_ENCRYPT_BLOCK_CTR(prefix) \ + template <> \ + inline void encrypt_block<AES_## prefix, AES_CTR>( \ + const typename Types<AES_## prefix>::Block& plaintext, \ + const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \ + typename Types<AES_## prefix>::Block& iv, \ + typename Types<AES_## prefix>::Block& ciphertext) \ + { \ + ciphertext = aes_## prefix ##_encrypt_block_CTR(plaintext, &encryption_keys, iv, &iv); \ + } + +#define AESXX_DECRYPT_BLOCK_CTR(prefix) \ + template <> \ + inline void decrypt_block<AES_## prefix, AES_CTR>( \ + const typename Types<AES_## prefix>::Block& ciphertext, \ + const typename Types<AES_## prefix>::RoundKeys& encryption_keys, \ + typename Types<AES_## prefix>::Block& iv, \ + typename Types<AES_## prefix>::Block& plaintext) \ + { \ + plaintext = aes_## prefix ##_decrypt_block_CTR(ciphertext, &encryption_keys, iv, &iv); \ + } +} |