From 0651133db30c0932877780c2f98901e4ca1072e1 Mon Sep 17 00:00:00 2001 From: Egor Tensin Date: Wed, 17 Jun 2015 18:29:40 +0300 Subject: refactoring --- cxx/include/aesnixx/data.hpp | 6 +- examples/aes128cbc.cpp | 8 +- examples/aes128cfb.cpp | 6 +- examples/aes128ctr.cpp | 6 +- examples/aes128ecb.cpp | 8 +- examples/aes128ofb.cpp | 6 +- examples/aes192cbc.cpp | 8 +- examples/aes192cfb.cpp | 6 +- examples/aes192ctr.cpp | 6 +- examples/aes192ecb.cpp | 8 +- examples/aes192ofb.cpp | 6 +- examples/aes256cbc.cpp | 8 +- examples/aes256cfb.cpp | 6 +- examples/aes256ctr.cpp | 6 +- examples/aes256ecb.cpp | 8 +- examples/aes256ofb.cpp | 6 +- include/aesni/aes.h | 955 +++++++++++++++++++++++++++++++++++++++ include/aesni/all.h | 3 +- include/aesni/block.h | 933 -------------------------------------- include/aesni/box.h | 12 +- include/aesni/buffer.h | 4 +- include/aesni/data.h | 18 - include/aesni/raw.h | 218 --------- src/asm/aes128.asm | 16 +- src/asm/aes192.asm | 16 +- src/asm/aes256.asm | 16 +- src/box.c | 24 +- src/buffer.c | 12 +- src/c/aes128.c | 40 +- src/c/aes192.c | 36 +- src/c/aes256.c | 46 +- test/aes128cbc_decrypt_block.c | 8 +- test/aes128cbc_encrypt_block.c | 6 +- test/aes128cfb_decrypt_block.c | 6 +- test/aes128cfb_encrypt_block.c | 6 +- test/aes128ctr_decrypt_block.c | 6 +- test/aes128ctr_encrypt_block.c | 6 +- test/aes128ecb_decrypt_block.c | 8 +- test/aes128ecb_encrypt_block.c | 6 +- test/aes128ofb_decrypt_block.c | 6 +- test/aes128ofb_encrypt_block.c | 6 +- test/aes192cbc_decrypt_block.c | 8 +- test/aes192cbc_encrypt_block.c | 6 +- test/aes192cfb_decrypt_block.c | 6 +- test/aes192cfb_encrypt_block.c | 6 +- test/aes192ctr_decrypt_block.c | 6 +- test/aes192ctr_encrypt_block.c | 6 +- test/aes192ecb_decrypt_block.c | 8 +- test/aes192ecb_encrypt_block.c | 6 +- test/aes192ofb_decrypt_block.c | 6 +- test/aes192ofb_encrypt_block.c | 6 +- test/aes256cbc_decrypt_block.c | 8 +- test/aes256cbc_encrypt_block.c | 6 +- test/aes256cfb_decrypt_block.c | 6 +- test/aes256cfb_encrypt_block.c | 6 +- test/aes256ctr_decrypt_block.c | 6 +- test/aes256ctr_encrypt_block.c | 6 +- test/aes256ecb_decrypt_block.c | 8 +- test/aes256ecb_encrypt_block.c | 6 +- test/aes256ofb_decrypt_block.c | 6 +- test/aes256ofb_encrypt_block.c | 6 +- utils/aes128ecb_decrypt_file.cpp | 6 +- utils/aes128ecb_encrypt_file.cpp | 4 +- 63 files changed, 1222 insertions(+), 1437 deletions(-) create mode 100644 include/aesni/aes.h delete mode 100644 include/aesni/block.h delete mode 100644 include/aesni/raw.h diff --git a/cxx/include/aesnixx/data.hpp b/cxx/include/aesnixx/data.hpp index 7a67b27..c667e94 100644 --- a/cxx/include/aesnixx/data.hpp +++ b/cxx/include/aesnixx/data.hpp @@ -23,9 +23,9 @@ namespace aesni typedef AesNI_Block192 Block192; typedef AesNI_Block256 Block256; - typedef AesNI_KeySchedule128 KeySchedule128; - typedef AesNI_KeySchedule192 KeySchedule192; - typedef AesNI_KeySchedule256 KeySchedule256; + typedef AesNI_Aes128_RoundKeys KeySchedule128; + typedef AesNI_Aes192_RoundKeys KeySchedule192; + typedef AesNI_Aes256_RoundKeys KeySchedule256; template inline std::size_t get_number_of_keys(const KeyScheduleT& key_schedule) diff --git a/examples/aes128cbc.cpp b/examples/aes128cbc.cpp index c7e6550..5bb8c67 100644 --- a/examples/aes128cbc.cpp +++ b/examples/aes128cbc.cpp @@ -29,19 +29,19 @@ int main() make_default_iv(iv); aesni::KeySchedule128 encryption_schedule; - aesni_expand_key_schedule128(key, &encryption_schedule); + aesni_aes128_expand_key(key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); aesni::Block128 next_iv; - const auto ciphertext = aesni_encrypt_block_cbc128(plaintext, &encryption_schedule, iv, &next_iv); + const auto ciphertext = aesni_aes128_encrypt_block_cbc(plaintext, &encryption_schedule, iv, &next_iv); dump_ciphertext(ciphertext); dump_next_iv(next_iv); aesni::KeySchedule128 decryption_schedule; - aesni_invert_key_schedule128(&encryption_schedule, &decryption_schedule); + aesni_aes128_derive_decryption_keys(&encryption_schedule, &decryption_schedule); dump_decryption_schedule(decryption_schedule); - aesni::Block128 decrypted = aesni_decrypt_block_cbc128(ciphertext, &decryption_schedule, iv, &next_iv); + aesni::Block128 decrypted = aesni_aes128_decrypt_block_cbc(ciphertext, &decryption_schedule, iv, &next_iv); dump_decrypted(decrypted); dump_next_iv(next_iv); diff --git a/examples/aes128cfb.cpp b/examples/aes128cfb.cpp index 72a1be0..b5f78a7 100644 --- a/examples/aes128cfb.cpp +++ b/examples/aes128cfb.cpp @@ -29,15 +29,15 @@ int main() make_default_iv(iv); aesni::KeySchedule128 encryption_schedule; - aesni_expand_key_schedule128(key, &encryption_schedule); + aesni_aes128_expand_key(key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); aesni::Block128 next_iv; - const auto ciphertext = aesni_encrypt_block_cfb128(plaintext, &encryption_schedule, iv, &next_iv); + const auto ciphertext = aesni_aes128_encrypt_block_cfb(plaintext, &encryption_schedule, iv, &next_iv); dump_ciphertext(ciphertext); dump_next_iv(next_iv); - const auto decrypted = aesni_decrypt_block_cfb128(ciphertext, &encryption_schedule, iv, &next_iv); + const auto decrypted = aesni_aes128_decrypt_block_cfb(ciphertext, &encryption_schedule, iv, &next_iv); dump_decrypted(decrypted); dump_next_iv(next_iv); diff --git a/examples/aes128ctr.cpp b/examples/aes128ctr.cpp index a02052c..0515336 100644 --- a/examples/aes128ctr.cpp +++ b/examples/aes128ctr.cpp @@ -29,13 +29,13 @@ int main() make_default_iv(iv); aesni::KeySchedule128 encryption_schedule; - aesni_expand_key_schedule128(key, &encryption_schedule); + aesni_aes128_expand_key(key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); - const auto ciphertext = aesni_encrypt_block_ctr128(plaintext, &encryption_schedule, iv, 0); + const auto ciphertext = aesni_aes128_encrypt_block_ctr(plaintext, &encryption_schedule, iv, 0); dump_ciphertext(ciphertext); - const auto decrypted = aesni_decrypt_block_ctr128(ciphertext, &encryption_schedule, iv, 0); + const auto decrypted = aesni_aes128_decrypt_block_ctr(ciphertext, &encryption_schedule, iv, 0); dump_decrypted(decrypted); return 0; diff --git a/examples/aes128ecb.cpp b/examples/aes128ecb.cpp index 8ffda3a..b33c00a 100644 --- a/examples/aes128ecb.cpp +++ b/examples/aes128ecb.cpp @@ -26,17 +26,17 @@ int main() make_default_key(key); aesni::KeySchedule128 encryption_schedule; - aesni_expand_key_schedule128(key, &encryption_schedule); + aesni_aes128_expand_key(key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); - const auto ciphertext = aesni_encrypt_block_ecb128(plaintext, &encryption_schedule); + const auto ciphertext = aesni_aes128_encrypt_block_ecb(plaintext, &encryption_schedule); dump_ciphertext(ciphertext); aesni::KeySchedule128 decryption_schedule; - aesni_invert_key_schedule128(&encryption_schedule, &decryption_schedule); + aesni_aes128_derive_decryption_keys(&encryption_schedule, &decryption_schedule); dump_decryption_schedule(decryption_schedule); - const auto decrypted = aesni_decrypt_block_ecb128(ciphertext, &decryption_schedule); + const auto decrypted = aesni_aes128_decrypt_block_ecb(ciphertext, &decryption_schedule); dump_decrypted(decrypted); return 0; diff --git a/examples/aes128ofb.cpp b/examples/aes128ofb.cpp index 6b63936..da3d750 100644 --- a/examples/aes128ofb.cpp +++ b/examples/aes128ofb.cpp @@ -29,15 +29,15 @@ int main() make_default_iv(iv); aesni::KeySchedule128 encryption_schedule; - aesni_expand_key_schedule128(key, &encryption_schedule); + aesni_aes128_expand_key(key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); aesni::Block128 next_iv; - const auto ciphertext = aesni_encrypt_block_ofb128(plaintext, &encryption_schedule, iv, &next_iv); + const auto ciphertext = aesni_aes128_encrypt_block_ofb(plaintext, &encryption_schedule, iv, &next_iv); dump_ciphertext(ciphertext); dump_next_iv(next_iv); - const auto decrypted = aesni_decrypt_block_ofb128(ciphertext, &encryption_schedule, iv, &next_iv); + const auto decrypted = aesni_aes128_decrypt_block_ofb(ciphertext, &encryption_schedule, iv, &next_iv); dump_decrypted(decrypted); dump_next_iv(next_iv); diff --git a/examples/aes192cbc.cpp b/examples/aes192cbc.cpp index f4341ea..6d7ff74 100644 --- a/examples/aes192cbc.cpp +++ b/examples/aes192cbc.cpp @@ -29,19 +29,19 @@ int main() make_default_iv(iv); aesni::KeySchedule192 encryption_schedule; - aesni_expand_key_schedule192(&key, &encryption_schedule); + aesni_aes192_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); aesni::Block128 next_iv; - const auto ciphertext = aesni_encrypt_block_cbc192(plaintext, &encryption_schedule, iv, &next_iv); + const auto ciphertext = aesni_aes192_encrypt_block_cbc(plaintext, &encryption_schedule, iv, &next_iv); dump_ciphertext(ciphertext); dump_next_iv(next_iv); aesni::KeySchedule192 decryption_schedule; - aesni_invert_key_schedule192(&encryption_schedule, &decryption_schedule); + aesni_aes192_derive_decryption_keys(&encryption_schedule, &decryption_schedule); dump_decryption_schedule(decryption_schedule); - const auto decrypted = aesni_decrypt_block_cbc192(ciphertext, &decryption_schedule, iv, &next_iv); + const auto decrypted = aesni_aes192_decrypt_block_cbc(ciphertext, &decryption_schedule, iv, &next_iv); dump_decrypted(decrypted); dump_next_iv(next_iv); diff --git a/examples/aes192cfb.cpp b/examples/aes192cfb.cpp index 88b94b7..a8662ca 100644 --- a/examples/aes192cfb.cpp +++ b/examples/aes192cfb.cpp @@ -29,15 +29,15 @@ int main() make_default_iv(iv); aesni::KeySchedule192 encryption_schedule; - aesni_expand_key_schedule192(&key, &encryption_schedule); + aesni_aes192_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); aesni::Block128 next_iv; - const auto ciphertext = aesni_encrypt_block_cfb192(plaintext, &encryption_schedule, iv, &next_iv); + const auto ciphertext = aesni_aes192_encrypt_block_cfb(plaintext, &encryption_schedule, iv, &next_iv); dump_ciphertext(ciphertext); dump_next_iv(next_iv); - const auto decrypted = aesni_decrypt_block_cfb192(ciphertext, &encryption_schedule, iv, &next_iv); + const auto decrypted = aesni_aes192_decrypt_block_cfb(ciphertext, &encryption_schedule, iv, &next_iv); dump_decrypted(decrypted); dump_next_iv(next_iv); diff --git a/examples/aes192ctr.cpp b/examples/aes192ctr.cpp index f7278cf..ef4dde6 100644 --- a/examples/aes192ctr.cpp +++ b/examples/aes192ctr.cpp @@ -29,13 +29,13 @@ int main() make_default_iv(iv); aesni::KeySchedule192 encryption_schedule; - aesni_expand_key_schedule192(&key, &encryption_schedule); + aesni_aes192_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); - const auto ciphertext = aesni_encrypt_block_ctr192(plaintext, &encryption_schedule, iv, 0); + const auto ciphertext = aesni_aes192_encrypt_block_ctr(plaintext, &encryption_schedule, iv, 0); dump_ciphertext(ciphertext); - const auto decrypted = aesni_decrypt_block_ctr192(ciphertext, &encryption_schedule, iv, 0); + const auto decrypted = aesni_aes192_decrypt_block_ctr(ciphertext, &encryption_schedule, iv, 0); dump_decrypted(decrypted); } catch (const std::exception& e) diff --git a/examples/aes192ecb.cpp b/examples/aes192ecb.cpp index 139b48b..6faf96f 100644 --- a/examples/aes192ecb.cpp +++ b/examples/aes192ecb.cpp @@ -26,17 +26,17 @@ int main() make_default_key(key); aesni::KeySchedule192 encryption_schedule; - aesni_expand_key_schedule192(&key, &encryption_schedule); + aesni_aes192_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); - const auto ciphertext = aesni_encrypt_block_ecb192(plaintext, &encryption_schedule); + const auto ciphertext = aesni_aes192_encrypt_block_ecb(plaintext, &encryption_schedule); dump_ciphertext(ciphertext); aesni::KeySchedule192 decryption_schedule; - aesni_invert_key_schedule192(&encryption_schedule, &decryption_schedule); + aesni_aes192_derive_decryption_keys(&encryption_schedule, &decryption_schedule); dump_decryption_schedule(decryption_schedule); - const auto decrypted = aesni_decrypt_block_ecb192(ciphertext, &decryption_schedule); + const auto decrypted = aesni_aes192_decrypt_block_ecb(ciphertext, &decryption_schedule); dump_decrypted(decrypted); return 0; diff --git a/examples/aes192ofb.cpp b/examples/aes192ofb.cpp index 5a07278..e7de746 100644 --- a/examples/aes192ofb.cpp +++ b/examples/aes192ofb.cpp @@ -29,15 +29,15 @@ int main() make_default_iv(iv); aesni::KeySchedule192 encryption_schedule; - aesni_expand_key_schedule192(&key, &encryption_schedule); + aesni_aes192_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); aesni::Block128 next_iv; - const auto ciphertext = aesni_encrypt_block_ofb192(plaintext, &encryption_schedule, iv, &next_iv); + const auto ciphertext = aesni_aes192_encrypt_block_ofb(plaintext, &encryption_schedule, iv, &next_iv); dump_ciphertext(ciphertext); dump_next_iv(next_iv); - const auto decrypted = aesni_decrypt_block_ofb192(ciphertext, &encryption_schedule, iv, &next_iv); + const auto decrypted = aesni_aes192_decrypt_block_ofb(ciphertext, &encryption_schedule, iv, &next_iv); dump_decrypted(decrypted); dump_next_iv(next_iv); diff --git a/examples/aes256cbc.cpp b/examples/aes256cbc.cpp index 0253adb..66f7c38 100644 --- a/examples/aes256cbc.cpp +++ b/examples/aes256cbc.cpp @@ -29,19 +29,19 @@ int main() make_default_iv(iv); aesni::KeySchedule256 encryption_schedule; - aesni_expand_key_schedule256(&key, &encryption_schedule); + aesni_aes256_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); aesni::Block128 next_iv; - const auto ciphertext = aesni_encrypt_block_cbc256(plaintext, &encryption_schedule, iv, &next_iv); + const auto ciphertext = aesni_aes256_encrypt_block_cbc(plaintext, &encryption_schedule, iv, &next_iv); dump_ciphertext(ciphertext); dump_next_iv(next_iv); aesni::KeySchedule256 decryption_schedule; - aesni_invert_key_schedule256(&encryption_schedule, &decryption_schedule); + aesni_aes256_derive_decryption_keys(&encryption_schedule, &decryption_schedule); dump_decryption_schedule(decryption_schedule); - const auto decrypted = aesni_decrypt_block_cbc256(ciphertext, &decryption_schedule, iv, &next_iv); + const auto decrypted = aesni_aes256_decrypt_block_cbc(ciphertext, &decryption_schedule, iv, &next_iv); dump_decrypted(decrypted); dump_next_iv(next_iv); diff --git a/examples/aes256cfb.cpp b/examples/aes256cfb.cpp index ce05aec..8a23146 100644 --- a/examples/aes256cfb.cpp +++ b/examples/aes256cfb.cpp @@ -29,15 +29,15 @@ int main() make_default_iv(iv); aesni::KeySchedule256 encryption_schedule; - aesni_expand_key_schedule256(&key, &encryption_schedule); + aesni_aes256_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); aesni::Block128 next_iv; - const auto ciphertext = aesni_encrypt_block_cfb256(plaintext, &encryption_schedule, iv, &next_iv); + const auto ciphertext = aesni_aes256_encrypt_block_cfb(plaintext, &encryption_schedule, iv, &next_iv); dump_ciphertext(ciphertext); dump_next_iv(next_iv); - const auto decrypted = aesni_decrypt_block_cfb256(ciphertext, &encryption_schedule, iv, &next_iv); + const auto decrypted = aesni_aes256_decrypt_block_cfb(ciphertext, &encryption_schedule, iv, &next_iv); dump_decrypted(decrypted); dump_next_iv(next_iv); diff --git a/examples/aes256ctr.cpp b/examples/aes256ctr.cpp index 1be85f7..b5e2ae7 100644 --- a/examples/aes256ctr.cpp +++ b/examples/aes256ctr.cpp @@ -29,13 +29,13 @@ int main() make_default_iv(iv); aesni::KeySchedule256 encryption_schedule; - aesni_expand_key_schedule256(&key, &encryption_schedule); + aesni_aes256_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); - const auto ciphertext = aesni_encrypt_block_ctr256(plaintext, &encryption_schedule, iv, 0); + const auto ciphertext = aesni_aes256_encrypt_block_ctr(plaintext, &encryption_schedule, iv, 0); dump_ciphertext(ciphertext); - const auto decrypted = aesni_decrypt_block_ctr256(ciphertext, &encryption_schedule, iv, 0); + const auto decrypted = aesni_aes256_decrypt_block_ctr(ciphertext, &encryption_schedule, iv, 0); dump_decrypted(decrypted); } catch (const std::exception& e) diff --git a/examples/aes256ecb.cpp b/examples/aes256ecb.cpp index 72f132e..aebd14b 100644 --- a/examples/aes256ecb.cpp +++ b/examples/aes256ecb.cpp @@ -26,17 +26,17 @@ int main() make_default_key(key); aesni::KeySchedule256 encryption_schedule; - aesni_expand_key_schedule256(&key, &encryption_schedule); + aesni_aes256_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); - const auto ciphertext = aesni_encrypt_block_ecb256(plaintext, &encryption_schedule); + const auto ciphertext = aesni_aes256_encrypt_block_ecb(plaintext, &encryption_schedule); dump_ciphertext(ciphertext); aesni::KeySchedule256 decryption_schedule; - aesni_invert_key_schedule256(&encryption_schedule, &decryption_schedule); + aesni_aes256_derive_decryption_keys(&encryption_schedule, &decryption_schedule); dump_decryption_schedule(decryption_schedule); - const auto decrypted = aesni_decrypt_block_ecb256(ciphertext, &decryption_schedule); + const auto decrypted = aesni_aes256_decrypt_block_ecb(ciphertext, &decryption_schedule); dump_decrypted(decrypted); return 0; diff --git a/examples/aes256ofb.cpp b/examples/aes256ofb.cpp index 34f9725..cf1f1a0 100644 --- a/examples/aes256ofb.cpp +++ b/examples/aes256ofb.cpp @@ -29,15 +29,15 @@ int main() make_default_iv(iv); aesni::KeySchedule256 encryption_schedule; - aesni_expand_key_schedule256(&key, &encryption_schedule); + aesni_aes256_expand_key(&key, &encryption_schedule); dump_encryption_schedule(encryption_schedule); aesni::Block128 next_iv; - const auto ciphertext = aesni_encrypt_block_ofb256(plaintext, &encryption_schedule, iv, &next_iv); + const auto ciphertext = aesni_aes256_encrypt_block_ofb(plaintext, &encryption_schedule, iv, &next_iv); dump_ciphertext(ciphertext); dump_next_iv(next_iv); - const auto decrypted = aesni_decrypt_block_ofb256(ciphertext, &encryption_schedule, iv, &next_iv); + const auto decrypted = aesni_aes256_decrypt_block_ofb(ciphertext, &encryption_schedule, iv, &next_iv); dump_decrypted(decrypted); dump_next_iv(next_iv); diff --git a/include/aesni/aes.h b/include/aesni/aes.h new file mode 100644 index 0000000..dcee06b --- /dev/null +++ b/include/aesni/aes.h @@ -0,0 +1,955 @@ +/** + * \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 "data.h" + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct +{ + AesNI_Block128 keys[11]; +} +AesNI_Aes128_RoundKeys; + +typedef struct +{ + AesNI_Block128 keys[13]; +} +AesNI_Aes192_RoundKeys; + +typedef struct +{ + AesNI_Block128 keys[15]; +} +AesNI_Aes256_RoundKeys; + +void __fastcall aesni_aes128_expand_key_( + AesNI_Block128 key, + AesNI_Aes128_RoundKeys* encryption_keys); + +void __fastcall aesni_aes192_expand_key_( + AesNI_Block128 key_lo, + AesNI_Block128 key_hi, + AesNI_Aes192_RoundKeys* encryption_keys); + +void __fastcall aesni_aes256_expand_key_( + AesNI_Block128 key_lo, + AesNI_Block128 key_hi, + AesNI_Aes256_RoundKeys* encryption_keys); + +void __fastcall aesni_aes128_derive_decryption_keys_( + const AesNI_Aes128_RoundKeys* encryption_keys, + AesNI_Aes128_RoundKeys* decryption_keys); + +void __fastcall aesni_aes192_derive_decryption_keys_( + const AesNI_Aes192_RoundKeys* encryption_keys, + AesNI_Aes192_RoundKeys* decryption_keys); + +void __fastcall aesni_aes256_derive_decryption_keys_( + const AesNI_Aes256_RoundKeys* encryption_keys, + AesNI_Aes256_RoundKeys* decryption_keys); + +AesNI_Block128 __fastcall aesni_aes128_encrypt_block_( + AesNI_Block128 plaintext, + const AesNI_Aes128_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes192_encrypt_block_( + AesNI_Block128 plaintext, + const AesNI_Aes192_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes256_encrypt_block_( + AesNI_Block128 plaintext, + const AesNI_Aes256_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes128_decrypt_block_( + AesNI_Block128 ciphertext, + const AesNI_Aes128_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes192_decrypt_block_( + AesNI_Block128 ciphertext, + const AesNI_Aes192_RoundKeys*); + +AesNI_Block128 __fastcall aesni_aes256_decrypt_block_( + AesNI_Block128 ciphertext, + const AesNI_Aes256_RoundKeys*); + + + + +/** + * \brief Expands a key schedule for AES-128 encryption. + * + * \param[in] key The AES-128 key. + * \param[out] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + */ +static __inline void __fastcall aesni_aes128_expand_key( + AesNI_Block128 key, + AesNI_Aes128_RoundKeys* key_schedule) +{ + assert(key_schedule); + + aesni_aes128_expand_key_(key, key_schedule); +} + +/** + * \brief "Inverts" an AES-128 key schedule to prepare for decryption. + * + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[out] inverted_schedule The AES-128 decryption key schedule. Must not + * be `NULL`. + */ +static __inline void __fastcall aesni_aes128_derive_decryption_keys( + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Aes128_RoundKeys* inverted_schedule) +{ + assert(key_schedule); + assert(inverted_schedule); + + aesni_aes128_derive_decryption_keys_(key_schedule, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in ECB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_ecb( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule) +{ + assert(key_schedule); + + return aesni_aes128_encrypt_block_(plain, key_schedule); +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in ECB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-128 decryption key schedule. Must not + * be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_ecb( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* inverted_schedule) +{ + assert(inverted_schedule); + + return aesni_aes128_decrypt_block_(cipher, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in CBC mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_cbc( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_aes128_encrypt_block_( + aesni_xor_block128(plain, init_vector), + key_schedule); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in CBC mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-128 decryption key schedule. Must not + * be `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_cbc( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* inverted_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(inverted_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes128_decrypt_block_(cipher, inverted_schedule), + init_vector); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in CFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_cfb( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_xor_block128( + aesni_aes128_encrypt_block_(init_vector, key_schedule), + plain); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in CFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-128 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_cfb( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes128_encrypt_block_(init_vector, key_schedule), + cipher); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in OFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_ofb( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes128_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, plain); +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in OFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-128 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_ofb( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes128_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, cipher); +} + +/** + * \brief Encrypts a 128-bit block using AES-128 in CTR mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-128 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_encrypt_block_ctr( + AesNI_Block128 plain, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + plain, + aesni_aes128_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \brief Decrypts a 128-bit block using AES-128 in CTR mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-128 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes128_decrypt_block_ctr( + AesNI_Block128 cipher, + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + cipher, + aesni_aes128_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \} + * + * \defgroup aesni_block_api_aes192 AES-192 + * \{ + */ + +/** + * \brief Expands a key schedule for AES-192 encryption. + * + * \param[in] key The AES-192 key. Must not be `NULL`. + * \param[out] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + */ +static __inline void __fastcall aesni_aes192_expand_key( + AesNI_Block192* key, + AesNI_Aes192_RoundKeys* key_schedule) +{ + assert(key); + assert(key_schedule); + + aesni_aes192_expand_key_(key->lo, key->hi, key_schedule); +} + +/** + * \brief "Inverts" an AES-192 key schedule to prepare for decryption. + * + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[out] inverted_schedule The AES-192 decryption key schedule. Must not + * be `NULL`. + */ +static __inline void __fastcall aesni_aes192_derive_decryption_keys( + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Aes192_RoundKeys* inverted_schedule) +{ + assert(key_schedule); + assert(inverted_schedule); + + aesni_aes192_derive_decryption_keys_(key_schedule, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in ECB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_ecb( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule) +{ + assert(key_schedule); + + return aesni_aes192_encrypt_block_(plain, key_schedule); +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in ECB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-192 decryption key schedule. Must not + * be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_ecb( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* inverted_schedule) +{ + assert(inverted_schedule); + + return aesni_aes192_decrypt_block_(cipher, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in CBC mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_cbc( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_aes192_encrypt_block_( + aesni_xor_block128(plain, init_vector), + key_schedule); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in CBC mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-192 decryption key schedule. Must not + * be `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_cbc( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* inverted_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(inverted_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes192_decrypt_block_(cipher, inverted_schedule), + init_vector); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in CFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_cfb( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_xor_block128( + aesni_aes192_encrypt_block_(init_vector, key_schedule), + plain); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in CFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-192 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_cfb( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes192_encrypt_block_(init_vector, key_schedule), + cipher); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in OFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_ofb( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes192_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, plain); +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in OFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-192 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_ofb( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes192_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, cipher); +} + +/** + * \brief Encrypts a 128-bit block using AES-192 in CTR mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-192 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_encrypt_block_ctr( + AesNI_Block128 plain, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + plain, + aesni_aes192_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \brief Decrypts a 128-bit block using AES-192 in CTR mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-192 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes192_decrypt_block_ctr( + AesNI_Block128 cipher, + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + cipher, + aesni_aes192_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \} + * + * \defgroup aesni_block_api_aes256 AES-256 + * \{ + */ + +/** + * \brief Expands a key schedule for AES-256 encryption. + * + * \param[in] key The AES-256 key. Must not be `NULL`. + * \param[out] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + */ +static __inline void __fastcall aesni_aes256_expand_key( + const AesNI_Block256* key, + AesNI_Aes256_RoundKeys* key_schedule) +{ + assert(key); + assert(key_schedule); + + aesni_aes256_expand_key_(key->lo, key->hi, key_schedule); +} + +/** + * \brief "Inverts" an AES-256 key schedule to prepare for decryption. + * + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[out] inverted_schedule The AES-256 decryption key schedule. Must not + * be `NULL`. + */ +static __inline void __fastcall aesni_aes256_derive_decryption_keys( + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Aes256_RoundKeys* inverted_schedule) +{ + assert(key_schedule); + assert(inverted_schedule); + + aesni_aes256_derive_decryption_keys_(key_schedule, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in ECB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_ecb( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule) +{ + assert(key_schedule); + + return aesni_aes256_encrypt_block_(plain, key_schedule); +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in ECB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-256 decryption key schedule. Must not + * be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_ecb( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* inverted_schedule) +{ + assert(inverted_schedule); + + return aesni_aes256_decrypt_block_(cipher, inverted_schedule); +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in CBC mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_cbc( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_aes256_encrypt_block_( + aesni_xor_block128(plain, init_vector), + key_schedule); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in CBC mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] inverted_schedule The AES-256 decryption key schedule. Must not + * be `NULL`. + * \param[in] init_vector The CBC initialization vector. + * \param[out] next_init_vector The next CBC initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_cbc( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* inverted_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(inverted_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes256_decrypt_block_(cipher, inverted_schedule), + init_vector); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in CFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_cfb( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 cipher = aesni_xor_block128( + aesni_aes256_encrypt_block_(init_vector, key_schedule), + plain); + *next_init_vector = cipher; + return cipher; +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in CFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-256 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CFB initialization vector. + * \param[out] next_init_vector The next CFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_cfb( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 plain = aesni_xor_block128( + aesni_aes256_encrypt_block_(init_vector, key_schedule), + cipher); + *next_init_vector = cipher; + return plain; +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in OFB mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_ofb( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes256_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, plain); +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in OFB mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-256 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The OFB initialization vector. + * \param[out] next_init_vector The next OFB initialization vector to be used + * as the initialization vector for the next call. Must not be `NULL`. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_ofb( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + AesNI_Block128* next_init_vector) +{ + assert(key_schedule); + assert(next_init_vector); + + AesNI_Block128 tmp = aesni_aes256_encrypt_block_(init_vector, key_schedule); + *next_init_vector = tmp; + return aesni_xor_block128(tmp, cipher); +} + +/** + * \brief Encrypts a 128-bit block using AES-256 in CTR mode of operation. + * + * \param[in] plain The plaintext to be encrypted. + * \param[in] key_schedule The AES-256 encryption key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The encrypted 128-bit ciphertext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_encrypt_block_ctr( + AesNI_Block128 plain, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + plain, + aesni_aes256_encrypt_block_(init_vector, key_schedule)); +} + +/** + * \brief Decrypts a 128-bit block using AES-256 in CTR mode of operation. + * + * \param[in] cipher The ciphertext to be decrypted. + * \param[in] key_schedule The AES-256 **encryption** key schedule. Must not be + * `NULL`. + * \param[in] init_vector The CTR initialization vector. + * \param[in] counter The counter, typically incremented between consecutive + * calls. + * \return The decrypted 128-bit plaintext. + */ +static __inline AesNI_Block128 __fastcall aesni_aes256_decrypt_block_ctr( + AesNI_Block128 cipher, + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Block128 init_vector, + int counter) +{ + assert(key_schedule); + + init_vector = aesni_be2le128(_mm_add_epi32( + aesni_le2be128(init_vector), + aesni_make_block128(0, 0, 0, counter))); + + return aesni_xor_block128( + cipher, + aesni_aes256_encrypt_block_(init_vector, key_schedule)); +} + +#ifdef __cplusplus +} +#endif diff --git a/include/aesni/all.h b/include/aesni/all.h index 70f5e7e..26f7a41 100644 --- a/include/aesni/all.h +++ b/include/aesni/all.h @@ -15,11 +15,10 @@ * \defgroup aesni AesNI */ +#include "aes.h" #include "algorithm.h" -#include "block.h" #include "box.h" #include "buffer.h" #include "data.h" #include "error.h" #include "mode.h" -#include "raw.h" diff --git a/include/aesni/block.h b/include/aesni/block.h deleted file mode 100644 index 208e9d4..0000000 --- a/include/aesni/block.h +++ /dev/null @@ -1,933 +0,0 @@ -/** - * \file - * \author Egor Tensin - * \date 2015 - * \copyright This file is licensed under the terms of the MIT License. - * See LICENSE.txt for details. - * - * \brief Declares 128-bit block encryption/decryption functions. - */ - -#pragma once - -/** - * \defgroup aesni_block_api Block API - * \brief 128-bit block encryption/decryption functions. - * \ingroup aesni - * \{ - * - * For each of AES-128/192/256, two functions are defined: - * - * * a key schedule "expansion" function to prepare for encryption, - * * a key schedule "reversion" function to prepare for decryption. - * - * The functions, respectively, are: - * - * * `aesni_expand_key_scheduleNNN`, - * * `aesni_reverse_key_scheduleNNN`, - * - * where `NNN` is either `128`, `192` or `256`. - * - * For each of AES-128/192/256 and modes of operation ECB, CBC, CFB, OFB, and - * CTR, two functions are defined: - * - * * a 128-bit block encryption function, - * * a 128-bit block decryption function. - * - * The functions, respectively, are: - * - * * `aesni_encrypt_block_XXXNNN`, - * * `aesni_decrypt_block_XXXNNN`, - * - * where `XXX` is either `ecb`, `cbc`, `cfb`, `ofb` or `ctr`, and `NNN` is - * either `128`, `192` or `256`. - */ - -#include "data.h" -#include "raw.h" - -#include - -#ifdef __cplusplus -extern "C" -{ -#endif - -/** - * \defgroup aesni_block_api_aes128 AES-128 - * \{ - */ - -/** - * \brief Expands a key schedule for AES-128 encryption. - * - * \param[in] key The AES-128 key. - * \param[out] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - */ -static __inline void __fastcall aesni_expand_key_schedule128( - AesNI_Block128 key, - AesNI_KeySchedule128* key_schedule) -{ - assert(key_schedule); - - aesni_raw_expand_key_schedule128(key, key_schedule); -} - -/** - * \brief "Inverts" an AES-128 key schedule to prepare for decryption. - * - * \param[in] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - * \param[out] inverted_schedule The AES-128 decryption key schedule. Must not - * be `NULL`. - */ -static __inline void __fastcall aesni_invert_key_schedule128( - AesNI_KeySchedule128* key_schedule, - AesNI_KeySchedule128* inverted_schedule) -{ - assert(key_schedule); - assert(inverted_schedule); - - aesni_raw_invert_key_schedule128(key_schedule, inverted_schedule); -} - -/** - * \brief Encrypts a 128-bit block using AES-128 in ECB mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ecb128( - AesNI_Block128 plain, - AesNI_KeySchedule128* key_schedule) -{ - assert(key_schedule); - - return aesni_raw_encrypt_block128(plain, key_schedule); -} - -/** - * \brief Decrypts a 128-bit block using AES-128 in ECB mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] inverted_schedule The AES-128 decryption key schedule. Must not - * be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ecb128( - AesNI_Block128 cipher, - AesNI_KeySchedule128* inverted_schedule) -{ - assert(inverted_schedule); - - return aesni_raw_decrypt_block128(cipher, inverted_schedule); -} - -/** - * \brief Encrypts a 128-bit block using AES-128 in CBC mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CBC initialization vector. - * \param[out] next_init_vector The next CBC initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cbc128( - AesNI_Block128 plain, - AesNI_KeySchedule128* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 cipher = aesni_raw_encrypt_block128( - aesni_xor_block128(plain, init_vector), - key_schedule); - *next_init_vector = cipher; - return cipher; -} - -/** - * \brief Decrypts a 128-bit block using AES-128 in CBC mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] inverted_schedule The AES-128 decryption key schedule. Must not - * be `NULL`. - * \param[in] init_vector The CBC initialization vector. - * \param[out] next_init_vector The next CBC initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cbc128( - AesNI_Block128 cipher, - AesNI_KeySchedule128* inverted_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(inverted_schedule); - assert(next_init_vector); - - AesNI_Block128 plain = aesni_xor_block128( - aesni_raw_decrypt_block128(cipher, inverted_schedule), - init_vector); - *next_init_vector = cipher; - return plain; -} - -/** - * \brief Encrypts a 128-bit block using AES-128 in CFB mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CFB initialization vector. - * \param[out] next_init_vector The next CFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cfb128( - AesNI_Block128 plain, - AesNI_KeySchedule128* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 cipher = aesni_xor_block128( - aesni_raw_encrypt_block128(init_vector, key_schedule), - plain); - *next_init_vector = cipher; - return cipher; -} - -/** - * \brief Decrypts a 128-bit block using AES-128 in CFB mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] key_schedule The AES-128 **encryption** key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CFB initialization vector. - * \param[out] next_init_vector The next CFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cfb128( - AesNI_Block128 cipher, - AesNI_KeySchedule128* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 plain = aesni_xor_block128( - aesni_raw_encrypt_block128(init_vector, key_schedule), - cipher); - *next_init_vector = cipher; - return plain; -} - -/** - * \brief Encrypts a 128-bit block using AES-128 in OFB mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The OFB initialization vector. - * \param[out] next_init_vector The next OFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ofb128( - AesNI_Block128 plain, - AesNI_KeySchedule128* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 tmp = aesni_raw_encrypt_block128(init_vector, key_schedule); - *next_init_vector = tmp; - return aesni_xor_block128(tmp, plain); -} - -/** - * \brief Decrypts a 128-bit block using AES-128 in OFB mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] key_schedule The AES-128 **encryption** key schedule. Must not be - * `NULL`. - * \param[in] init_vector The OFB initialization vector. - * \param[out] next_init_vector The next OFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ofb128( - AesNI_Block128 cipher, - AesNI_KeySchedule128* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 tmp = aesni_raw_encrypt_block128(init_vector, key_schedule); - *next_init_vector = tmp; - return aesni_xor_block128(tmp, cipher); -} - -/** - * \brief Encrypts a 128-bit block using AES-128 in CTR mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CTR initialization vector. - * \param[in] counter The counter, typically incremented between consecutive - * calls. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ctr128( - AesNI_Block128 plain, - AesNI_KeySchedule128* key_schedule, - AesNI_Block128 init_vector, - int counter) -{ - assert(key_schedule); - - init_vector = aesni_be2le128(_mm_add_epi32( - aesni_le2be128(init_vector), - aesni_make_block128(0, 0, 0, counter))); - - return aesni_xor_block128( - plain, - aesni_raw_encrypt_block128(init_vector, key_schedule)); -} - -/** - * \brief Decrypts a 128-bit block using AES-128 in CTR mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] key_schedule The AES-128 **encryption** key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CTR initialization vector. - * \param[in] counter The counter, typically incremented between consecutive - * calls. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ctr128( - AesNI_Block128 cipher, - AesNI_KeySchedule128* key_schedule, - AesNI_Block128 init_vector, - int counter) -{ - assert(key_schedule); - - init_vector = aesni_be2le128(_mm_add_epi32( - aesni_le2be128(init_vector), - aesni_make_block128(0, 0, 0, counter))); - - return aesni_xor_block128( - cipher, - aesni_raw_encrypt_block128(init_vector, key_schedule)); -} - -/** - * \} - * - * \defgroup aesni_block_api_aes192 AES-192 - * \{ - */ - -/** - * \brief Expands a key schedule for AES-192 encryption. - * - * \param[in] key The AES-192 key. Must not be `NULL`. - * \param[out] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - */ -static __inline void __fastcall aesni_expand_key_schedule192( - AesNI_Block192* key, - AesNI_KeySchedule192* key_schedule) -{ - assert(key); - assert(key_schedule); - - aesni_raw_expand_key_schedule192(key->lo, key->hi, key_schedule); -} - -/** - * \brief "Inverts" an AES-192 key schedule to prepare for decryption. - * - * \param[in] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - * \param[out] inverted_schedule The AES-192 decryption key schedule. Must not - * be `NULL`. - */ -static __inline void __fastcall aesni_invert_key_schedule192( - AesNI_KeySchedule192* key_schedule, - AesNI_KeySchedule192* inverted_schedule) -{ - assert(key_schedule); - assert(inverted_schedule); - - aesni_raw_invert_key_schedule192(key_schedule, inverted_schedule); -} - -/** - * \brief Encrypts a 128-bit block using AES-192 in ECB mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ecb192( - AesNI_Block128 plain, - AesNI_KeySchedule192* key_schedule) -{ - assert(key_schedule); - - return aesni_raw_encrypt_block192(plain, key_schedule); -} - -/** - * \brief Decrypts a 128-bit block using AES-192 in ECB mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] inverted_schedule The AES-192 decryption key schedule. Must not - * be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ecb192( - AesNI_Block128 cipher, - AesNI_KeySchedule192* inverted_schedule) -{ - assert(inverted_schedule); - - return aesni_raw_decrypt_block192(cipher, inverted_schedule); -} - -/** - * \brief Encrypts a 128-bit block using AES-192 in CBC mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CBC initialization vector. - * \param[out] next_init_vector The next CBC initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cbc192( - AesNI_Block128 plain, - AesNI_KeySchedule192* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 cipher = aesni_raw_encrypt_block192( - aesni_xor_block128(plain, init_vector), - key_schedule); - *next_init_vector = cipher; - return cipher; -} - -/** - * \brief Decrypts a 128-bit block using AES-192 in CBC mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] inverted_schedule The AES-192 decryption key schedule. Must not - * be `NULL`. - * \param[in] init_vector The CBC initialization vector. - * \param[out] next_init_vector The next CBC initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cbc192( - AesNI_Block128 cipher, - AesNI_KeySchedule192* inverted_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(inverted_schedule); - assert(next_init_vector); - - AesNI_Block128 plain = aesni_xor_block128( - aesni_raw_decrypt_block192(cipher, inverted_schedule), - init_vector); - *next_init_vector = cipher; - return plain; -} - -/** - * \brief Encrypts a 128-bit block using AES-192 in CFB mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CFB initialization vector. - * \param[out] next_init_vector The next CFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cfb192( - AesNI_Block128 plain, - AesNI_KeySchedule192* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 cipher = aesni_xor_block128( - aesni_raw_encrypt_block192(init_vector, key_schedule), - plain); - *next_init_vector = cipher; - return cipher; -} - -/** - * \brief Decrypts a 128-bit block using AES-192 in CFB mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] key_schedule The AES-192 **encryption** key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CFB initialization vector. - * \param[out] next_init_vector The next CFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cfb192( - AesNI_Block128 cipher, - AesNI_KeySchedule192* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 plain = aesni_xor_block128( - aesni_raw_encrypt_block192(init_vector, key_schedule), - cipher); - *next_init_vector = cipher; - return plain; -} - -/** - * \brief Encrypts a 128-bit block using AES-192 in OFB mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The OFB initialization vector. - * \param[out] next_init_vector The next OFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ofb192( - AesNI_Block128 plain, - AesNI_KeySchedule192* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 tmp = aesni_raw_encrypt_block192(init_vector, key_schedule); - *next_init_vector = tmp; - return aesni_xor_block128(tmp, plain); -} - -/** - * \brief Decrypts a 128-bit block using AES-192 in OFB mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] key_schedule The AES-192 **encryption** key schedule. Must not be - * `NULL`. - * \param[in] init_vector The OFB initialization vector. - * \param[out] next_init_vector The next OFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ofb192( - AesNI_Block128 cipher, - AesNI_KeySchedule192* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 tmp = aesni_raw_encrypt_block192(init_vector, key_schedule); - *next_init_vector = tmp; - return aesni_xor_block128(tmp, cipher); -} - -/** - * \brief Encrypts a 128-bit block using AES-192 in CTR mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CTR initialization vector. - * \param[in] counter The counter, typically incremented between consecutive - * calls. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ctr192( - AesNI_Block128 plain, - AesNI_KeySchedule192* key_schedule, - AesNI_Block128 init_vector, - int counter) -{ - assert(key_schedule); - - init_vector = aesni_be2le128(_mm_add_epi32( - aesni_le2be128(init_vector), - aesni_make_block128(0, 0, 0, counter))); - - return aesni_xor_block128( - plain, - aesni_raw_encrypt_block192(init_vector, key_schedule)); -} - -/** - * \brief Decrypts a 128-bit block using AES-192 in CTR mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] key_schedule The AES-192 **encryption** key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CTR initialization vector. - * \param[in] counter The counter, typically incremented between consecutive - * calls. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ctr192( - AesNI_Block128 cipher, - AesNI_KeySchedule192* key_schedule, - AesNI_Block128 init_vector, - int counter) -{ - assert(key_schedule); - - init_vector = aesni_be2le128(_mm_add_epi32( - aesni_le2be128(init_vector), - aesni_make_block128(0, 0, 0, counter))); - - return aesni_xor_block128( - cipher, - aesni_raw_encrypt_block192(init_vector, key_schedule)); -} - -/** - * \} - * - * \defgroup aesni_block_api_aes256 AES-256 - * \{ - */ - -/** - * \brief Expands a key schedule for AES-256 encryption. - * - * \param[in] key The AES-256 key. Must not be `NULL`. - * \param[out] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - */ -static __inline void __fastcall aesni_expand_key_schedule256( - AesNI_Block256* key, - AesNI_KeySchedule256* key_schedule) -{ - assert(key); - assert(key_schedule); - - aesni_raw_expand_key_schedule256(key->lo, key->hi, key_schedule); -} - -/** - * \brief "Inverts" an AES-256 key schedule to prepare for decryption. - * - * \param[in] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - * \param[out] inverted_schedule The AES-256 decryption key schedule. Must not - * be `NULL`. - */ -static __inline void __fastcall aesni_invert_key_schedule256( - AesNI_KeySchedule256* key_schedule, - AesNI_KeySchedule256* inverted_schedule) -{ - assert(key_schedule); - assert(inverted_schedule); - - aesni_raw_invert_key_schedule256(key_schedule, inverted_schedule); -} - -/** - * \brief Encrypts a 128-bit block using AES-256 in ECB mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ecb256( - AesNI_Block128 plain, - AesNI_KeySchedule256* key_schedule) -{ - assert(key_schedule); - - return aesni_raw_encrypt_block256(plain, key_schedule); -} - -/** - * \brief Decrypts a 128-bit block using AES-256 in ECB mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] inverted_schedule The AES-256 decryption key schedule. Must not - * be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ecb256( - AesNI_Block128 cipher, - AesNI_KeySchedule256* inverted_schedule) -{ - assert(inverted_schedule); - - return aesni_raw_decrypt_block256(cipher, inverted_schedule); -} - -/** - * \brief Encrypts a 128-bit block using AES-256 in CBC mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CBC initialization vector. - * \param[out] next_init_vector The next CBC initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cbc256( - AesNI_Block128 plain, - AesNI_KeySchedule256* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 cipher = aesni_raw_encrypt_block256( - aesni_xor_block128(plain, init_vector), - key_schedule); - *next_init_vector = cipher; - return cipher; -} - -/** - * \brief Decrypts a 128-bit block using AES-256 in CBC mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] inverted_schedule The AES-256 decryption key schedule. Must not - * be `NULL`. - * \param[in] init_vector The CBC initialization vector. - * \param[out] next_init_vector The next CBC initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cbc256( - AesNI_Block128 cipher, - AesNI_KeySchedule256* inverted_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(inverted_schedule); - assert(next_init_vector); - - AesNI_Block128 plain = aesni_xor_block128( - aesni_raw_decrypt_block256(cipher, inverted_schedule), - init_vector); - *next_init_vector = cipher; - return plain; -} - -/** - * \brief Encrypts a 128-bit block using AES-256 in CFB mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CFB initialization vector. - * \param[out] next_init_vector The next CFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_cfb256( - AesNI_Block128 plain, - AesNI_KeySchedule256* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 cipher = aesni_xor_block128( - aesni_raw_encrypt_block256(init_vector, key_schedule), - plain); - *next_init_vector = cipher; - return cipher; -} - -/** - * \brief Decrypts a 128-bit block using AES-256 in CFB mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] key_schedule The AES-256 **encryption** key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CFB initialization vector. - * \param[out] next_init_vector The next CFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_cfb256( - AesNI_Block128 cipher, - AesNI_KeySchedule256* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 plain = aesni_xor_block128( - aesni_raw_encrypt_block256(init_vector, key_schedule), - cipher); - *next_init_vector = cipher; - return plain; -} - -/** - * \brief Encrypts a 128-bit block using AES-256 in OFB mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The OFB initialization vector. - * \param[out] next_init_vector The next OFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ofb256( - AesNI_Block128 plain, - AesNI_KeySchedule256* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 tmp = aesni_raw_encrypt_block256(init_vector, key_schedule); - *next_init_vector = tmp; - return aesni_xor_block128(tmp, plain); -} - -/** - * \brief Decrypts a 128-bit block using AES-256 in OFB mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] key_schedule The AES-256 **encryption** key schedule. Must not be - * `NULL`. - * \param[in] init_vector The OFB initialization vector. - * \param[out] next_init_vector The next OFB initialization vector to be used - * as the initialization vector for the next call. Must not be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ofb256( - AesNI_Block128 cipher, - AesNI_KeySchedule256* key_schedule, - AesNI_Block128 init_vector, - AesNI_Block128* next_init_vector) -{ - assert(key_schedule); - assert(next_init_vector); - - AesNI_Block128 tmp = aesni_raw_encrypt_block256(init_vector, key_schedule); - *next_init_vector = tmp; - return aesni_xor_block128(tmp, cipher); -} - -/** - * \brief Encrypts a 128-bit block using AES-256 in CTR mode of operation. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CTR initialization vector. - * \param[in] counter The counter, typically incremented between consecutive - * calls. - * \return The encrypted 128-bit ciphertext. - */ -static __inline AesNI_Block128 __fastcall aesni_encrypt_block_ctr256( - AesNI_Block128 plain, - AesNI_KeySchedule256* key_schedule, - AesNI_Block128 init_vector, - int counter) -{ - assert(key_schedule); - - init_vector = aesni_be2le128(_mm_add_epi32( - aesni_le2be128(init_vector), - aesni_make_block128(0, 0, 0, counter))); - - return aesni_xor_block128( - plain, - aesni_raw_encrypt_block256(init_vector, key_schedule)); -} - -/** - * \brief Decrypts a 128-bit block using AES-256 in CTR mode of operation. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] key_schedule The AES-256 **encryption** key schedule. Must not be - * `NULL`. - * \param[in] init_vector The CTR initialization vector. - * \param[in] counter The counter, typically incremented between consecutive - * calls. - * \return The decrypted 128-bit plaintext. - */ -static __inline AesNI_Block128 __fastcall aesni_decrypt_block_ctr256( - AesNI_Block128 cipher, - AesNI_KeySchedule256* key_schedule, - AesNI_Block128 init_vector, - int counter) -{ - assert(key_schedule); - - init_vector = aesni_be2le128(_mm_add_epi32( - aesni_le2be128(init_vector), - aesni_make_block128(0, 0, 0, counter))); - - return aesni_xor_block128( - cipher, - aesni_raw_encrypt_block256(init_vector, key_schedule)); -} - -/** - * \} - */ - -#ifdef __cplusplus -} -#endif - -/** - * \} - */ diff --git a/include/aesni/box.h b/include/aesni/box.h index 2ae6533..70b2787 100644 --- a/include/aesni/box.h +++ b/include/aesni/box.h @@ -20,17 +20,17 @@ extern "C" typedef union { - AesNI_KeySchedule128 aes128_key_schedule; - AesNI_KeySchedule192 aes192_key_schedule; - AesNI_KeySchedule256 aes256_key_schedule; + AesNI_Aes128_RoundKeys aes128_key_schedule; + AesNI_Aes192_RoundKeys aes192_key_schedule; + AesNI_Aes256_RoundKeys aes256_key_schedule; } AesNI_EncryptionParams; typedef union { - AesNI_KeySchedule128 aes128_key_schedule; - AesNI_KeySchedule192 aes192_key_schedule; - AesNI_KeySchedule256 aes256_key_schedule; + AesNI_Aes128_RoundKeys aes128_key_schedule; + AesNI_Aes192_RoundKeys aes192_key_schedule; + AesNI_Aes256_RoundKeys aes256_key_schedule; } AesNI_DecryptionParams; diff --git a/include/aesni/buffer.h b/include/aesni/buffer.h index 2e5ecb9..d153c1b 100644 --- a/include/aesni/buffer.h +++ b/include/aesni/buffer.h @@ -24,14 +24,14 @@ AesNI_StatusCode aesni_encrypt_buffer_ecb128( size_t src_size, void* dest, size_t* dest_size, - AesNI_KeySchedule128* key_schedule, + AesNI_Aes128_RoundKeys* key_schedule, AesNI_ErrorDetails* err_details); AesNI_StatusCode aesni_decrypt_buffer_ecb128( const void* src, size_t src_size, void* dest, size_t* dest_size, - AesNI_KeySchedule128* inverted_schedule, + AesNI_Aes128_RoundKeys* inverted_schedule, AesNI_ErrorDetails* err_details); #ifdef __cplusplus diff --git a/include/aesni/data.h b/include/aesni/data.h index fbe6e31..a6dc71f 100644 --- a/include/aesni/data.h +++ b/include/aesni/data.h @@ -204,24 +204,6 @@ static __inline AesNI_Block256 __fastcall aesni_make_block256( return result; } -typedef struct -{ - AesNI_Block128 keys[11]; -} -AesNI_KeySchedule128; - -typedef struct -{ - AesNI_Block128 keys[13]; -} -AesNI_KeySchedule192; - -typedef struct -{ - AesNI_Block128 keys[15]; -} -AesNI_KeySchedule256; - static __inline AesNI_Block128 __fastcall aesni_reverse_byte_order128(AesNI_Block128 block) { return _mm_shuffle_epi8(block, aesni_make_block128(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)); diff --git a/include/aesni/raw.h b/include/aesni/raw.h deleted file mode 100644 index 03a89e4..0000000 --- a/include/aesni/raw.h +++ /dev/null @@ -1,218 +0,0 @@ -/** - * \file - * \author Egor Tensin - * \date 2015 - * \copyright This file is licensed under the terms of the MIT License. - * See LICENSE.txt for details. - * - * \brief *Don't use.* Declares "raw" 128-bit block encryption/decryption - * functions. - */ - -#pragma once - -/** - * \defgroup aesni_raw_api Raw API - * \brief *Don't use.* "Raw" 128-bit block encryption/decryption functions. - * \ingroup aesni - * \{ - * - * For each of AES-128/192/256, four functions are defined: - * - * * a key schedule "expansion" function to prepare for encryption, - * * a 128-bit block encryption function using the key schedule, - * * a key schedule "inversion" function to prepare for decryption, - * * a 128-bit block decryption function using the "inverted" key schedule. - * - * The functions, respectively, are: - * - * * `aesni_raw_expand_key_scheduleNNN`, - * * `aesni_raw_encrypt_blockNNN`, - * * `aesni_raw_invert_key_scheduleNNN`, - * * `aesni_raw_decrypt_blockNNN`, - * - * where `NNN` is key length (either `128`, `192` or `256`). - */ - -#include "data.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - -/** - * \defgroup aesni_raw_api_aes128 AES-128 - * \{ - */ - -/** - * \brief Expands a key schedule for AES-128 encryption. - * - * \param[in] key The AES-128 key. - * \param[out] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - */ -void __fastcall aesni_raw_expand_key_schedule128( - AesNI_Block128 key, - AesNI_KeySchedule128* key_schedule); - -/** - * \brief "Inverts" an AES-128 key schedule to prepare for decryption. - * - * \param[in] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - * \param[out] inverted_schedule The AES-128 decryption key schedule. Must not - * be `NULL`. - */ -void __fastcall aesni_raw_invert_key_schedule128( - const AesNI_KeySchedule128* key_schedule, - AesNI_KeySchedule128* inverted_schedule); - -/** - * \brief Encrypts a 128-bit block using AES-128. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-128 encryption key schedule. Must not be - * `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -AesNI_Block128 __fastcall aesni_raw_encrypt_block128( - AesNI_Block128 plain, - const AesNI_KeySchedule128* key_schedule); - -/** - * \brief Decrypts a 128-bit block using AES-128. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] inverted_schedule The AES-128 decryption key schedule. Must not - * be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -AesNI_Block128 __fastcall aesni_raw_decrypt_block128( - AesNI_Block128 cipher, - const AesNI_KeySchedule128* inverted_schedule); - -/** - * \} - * - * \defgroup aesni_raw_api_aes192 AES-192 - * \{ - */ - -/** - * \brief Expands a key schedule for AES-192 encryption. - * - * \param[in] key_lo The least significant part of the AES-192 key. - * \param[in] key_hi The most significant part of the AES-192 key. - * \param[out] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - */ -void __fastcall aesni_raw_expand_key_schedule192( - AesNI_Block128 key_lo, - AesNI_Block128 key_hi, - AesNI_KeySchedule192* key_schedule); - -/** - * \brief "Inverts" an AES-192 key schedule to prepare for decryption. - * - * \param[in] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - * \param[out] inverted_schedule The AES-192 decryption key schedule. Must not - * be `NULL`. - */ -void __fastcall aesni_raw_invert_key_schedule192( - const AesNI_KeySchedule192* key_schedule, - AesNI_KeySchedule192* inverted_schedule); - -/** - * \brief Encrypts a 128-bit block using AES-192. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-192 encryption key schedule. Must not be - * `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -AesNI_Block128 __fastcall aesni_raw_encrypt_block192( - AesNI_Block128 plain, - const AesNI_KeySchedule192* key_schedule); - -/** - * \brief Decrypts a 128-bit block using AES-192. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] inverted_schedule The AES-192 decryption key schedule. Must not - * be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -AesNI_Block128 __fastcall aesni_raw_decrypt_block192( - AesNI_Block128 cipher, - const AesNI_KeySchedule192* inverted_schedule); - -/** - * \} - * - * \defgroup aesni_raw_api_aes256 AES-256 - * \{ - */ - -/** - * \brief Expands a key schedule for AES-256 encryption. - * - * \param[in] key_lo The least significant part of the AES-256 key. - * \param[in] key_hi The most significant part of the AES-256 key. - * \param[out] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - */ -void __fastcall aesni_raw_expand_key_schedule256( - AesNI_Block128 key_lo, - AesNI_Block128 key_hi, - AesNI_KeySchedule256* key_schedule); - -/** - * \brief "Inverts" a AES-256 key schedule to prepare for decryption. - * - * \param[in] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - * \param[out] inverted_schedule The AES-256 decryption key schedule. Must not - * be `NULL`. - */ -void __fastcall aesni_raw_invert_key_schedule256( - const AesNI_KeySchedule256* key_schedule, - AesNI_KeySchedule256* inverted_schedule); - -/** - * \brief Encrypts a 128-bit block using AES-256. - * - * \param[in] plain The plaintext to be encrypted. - * \param[in] key_schedule The AES-256 encryption key schedule. Must not be - * `NULL`. - * \return The encrypted 128-bit ciphertext. - */ -AesNI_Block128 __fastcall aesni_raw_encrypt_block256( - AesNI_Block128 plain, - const AesNI_KeySchedule256* key_schedule); - -/** - * \brief Decrypts a 128-bit block using AES-256. - * - * \param[in] cipher The ciphertext to be decrypted. - * \param[in] inverted_schedule The AES-256 decryption key schedule. Must not - * be `NULL`. - * \return The decrypted 128-bit plaintext. - */ -AesNI_Block128 __fastcall aesni_raw_decrypt_block256( - AesNI_Block128 cipher, - const AesNI_KeySchedule256* inverted_schedule); - -/** - * \} - */ - -#ifdef __cplusplus -} -#endif - -/** - * \} - */ diff --git a/src/asm/aes128.asm b/src/asm/aes128.asm index 4f88f09..03a9ace 100644 --- a/src/asm/aes128.asm +++ b/src/asm/aes128.asm @@ -8,7 +8,7 @@ .code -@aesni_raw_encrypt_block128@20 proc +@aesni_aes128_encrypt_block_@20 proc pxor xmm0, [ecx] aesenc xmm0, [ecx + 10h] aesenc xmm0, [ecx + 20h] @@ -21,9 +21,9 @@ aesenc xmm0, [ecx + 90h] aesenclast xmm0, [ecx + 0A0h] ret -@aesni_raw_encrypt_block128@20 endp +@aesni_aes128_encrypt_block_@20 endp -@aesni_raw_decrypt_block128@20 proc +@aesni_aes128_decrypt_block_@20 proc pxor xmm0, [ecx] aesdec xmm0, [ecx + 10h] aesdec xmm0, [ecx + 20h] @@ -36,9 +36,9 @@ aesdec xmm0, [ecx + 90h] aesdeclast xmm0, [ecx + 0A0h] ret -@aesni_raw_decrypt_block128@20 endp +@aesni_aes128_decrypt_block_@20 endp -@aesni_raw_expand_key_schedule128@20 proc +@aesni_aes128_expand_key_@20 proc ; A "word" (in terms of the FIPS 187 standard) is a 32-bit block. ; Words are denoted by `w[N]`. ; @@ -165,9 +165,9 @@ aes128_keygen_assist: add ecx, 10h ; ecx = &w[i+8] ret -@aesni_raw_expand_key_schedule128@20 endp +@aesni_aes128_expand_key_@20 endp -@aesni_raw_invert_key_schedule128@8 proc +@aesni_aes128_derive_decryption_keys_raw@8 proc movdqa xmm5, [ecx] movdqa xmm4, [ecx + 0A0h] movdqa [edx], xmm4 @@ -197,6 +197,6 @@ aes128_keygen_assist: movdqa [edx + 50h], xmm5 ret -@aesni_raw_invert_key_schedule128@8 endp +@aesni_aes128_derive_decryption_keys_raw@8 endp end diff --git a/src/asm/aes192.asm b/src/asm/aes192.asm index e045910..cd28143 100644 --- a/src/asm/aes192.asm +++ b/src/asm/aes192.asm @@ -8,7 +8,7 @@ .code -@aesni_raw_encrypt_block192@20 proc +@aesni_aes192_encrypt_block_@20 proc pxor xmm0, [ecx] aesenc xmm0, [ecx + 10h] aesenc xmm0, [ecx + 20h] @@ -23,9 +23,9 @@ aesenc xmm0, [ecx + 0B0h] aesenclast xmm0, [ecx + 0C0h] ret -@aesni_raw_encrypt_block192@20 endp +@aesni_aes192_encrypt_block_@20 endp -@aesni_raw_decrypt_block192@20 proc +@aesni_aes192_decrypt_block_@20 proc pxor xmm0, [ecx] aesdec xmm0, [ecx + 10h] aesdec xmm0, [ecx + 20h] @@ -40,9 +40,9 @@ aesdec xmm0, [ecx + 0B0h] aesdeclast xmm0, [ecx + 0C0h] ret -@aesni_raw_decrypt_block192@20 endp +@aesni_aes192_decrypt_block_@20 endp -@aesni_raw_expand_key_schedule192@36 proc +@aesni_aes192_expand_key_@36 proc ; A "word" (in terms of the FIPS 187 standard) is a 32-bit block. ; Words are denoted by `w[N]`. ; @@ -206,9 +206,9 @@ aes192_keygen_assist: ; xmm1[31:0] == w[i+10] == RotWord(SubWord(w[i+5]))^Rcon^w[i+4]^w[i+3]^w[i+2]^w[i+1]^w[i] ret -@aesni_raw_expand_key_schedule192@36 endp +@aesni_aes192_expand_key_@36 endp -@aesni_raw_invert_key_schedule192@8 proc +@aesni_aes192_derive_decryption_keys_@8 proc movdqa xmm5, [ecx] movdqa xmm4, [ecx + 0C0h] movdqa [edx], xmm4 @@ -243,6 +243,6 @@ aes192_keygen_assist: movdqa [edx + 60h], xmm5 ret -@aesni_raw_invert_key_schedule192@8 endp +@aesni_aes192_derive_decryption_keys_@8 endp end diff --git a/src/asm/aes256.asm b/src/asm/aes256.asm index 285cf69..f1c3eaf 100644 --- a/src/asm/aes256.asm +++ b/src/asm/aes256.asm @@ -8,7 +8,7 @@ .code -@aesni_raw_encrypt_block256@20 proc +@aesni_aes256_encrypt_block_@20 proc pxor xmm0, [ecx] aesenc xmm0, [ecx + 10h] aesenc xmm0, [ecx + 20h] @@ -25,9 +25,9 @@ aesenc xmm0, [ecx + 0D0h] aesenclast xmm0, [ecx + 0E0h] ret -@aesni_raw_encrypt_block256@20 endp +@aesni_aes256_encrypt_block_@20 endp -@aesni_raw_decrypt_block256@20 proc +@aesni_aes256_decrypt_block_@20 proc pxor xmm0, [ecx] aesdec xmm0, [ecx + 10h] aesdec xmm0, [ecx + 20h] @@ -44,9 +44,9 @@ aesdec xmm0, [ecx + 0D0h] aesdeclast xmm0, [ecx + 0E0h] ret -@aesni_raw_decrypt_block256@20 endp +@aesni_aes256_decrypt_block_@20 endp -@aesni_raw_expand_key_schedule256@36 proc +@aesni_aes256_expand_key_@36 proc ; A "word" (in terms of the FIPS 187 standard) is a 32-bit block. ; Words are denoted by `w[N]`. ; @@ -239,9 +239,9 @@ aes256_keygen_assist: pxor xmm0, xmm1 ret -@aesni_raw_expand_key_schedule256@36 endp +@aesni_aes256_expand_key_@36 endp -@aesni_raw_invert_key_schedule256@8 proc +@aesni_aes256_derive_decryption_keys_raw@8 proc movdqa xmm5, [ecx] movdqa xmm4, [ecx + 0E0h] movdqa [edx], xmm4 @@ -281,6 +281,6 @@ aes256_keygen_assist: movdqa [edx + 70h], xmm5 ret -@aesni_raw_invert_key_schedule256@8 endp +@aesni_aes256_derive_decryption_keys_raw@8 endp end diff --git a/src/box.c b/src/box.c index 61f4439..4484390 100644 --- a/src/box.c +++ b/src/box.c @@ -23,7 +23,7 @@ static AesNI_StatusCode aesni_box_encrypt_aes128( AesNI_State* output, AesNI_ErrorDetails* err_details) { - output->aes_block = aesni_raw_encrypt_block128( + output->aes_block = aesni_aes128_encrypt_block_( input->aes_block, ¶ms->aes128_key_schedule); return AESNI_SUCCESS; @@ -35,7 +35,7 @@ static AesNI_StatusCode aesni_box_decrypt_aes128( AesNI_State* output, AesNI_ErrorDetails* err_details) { - output->aes_block = aesni_raw_decrypt_block128( + output->aes_block = aesni_aes128_decrypt_block_( input->aes_block, ¶ms->aes128_key_schedule); return AESNI_SUCCESS; @@ -47,7 +47,7 @@ static AesNI_StatusCode aesni_box_encrypt_aes192( AesNI_State* output, AesNI_ErrorDetails* err_details) { - output->aes_block = aesni_raw_encrypt_block192( + output->aes_block = aesni_aes192_encrypt_block_( input->aes_block, ¶ms->aes192_key_schedule); return AESNI_SUCCESS; @@ -59,7 +59,7 @@ static AesNI_StatusCode aesni_box_decrypt_aes192( AesNI_State* output, AesNI_ErrorDetails* err_details) { - output->aes_block = aesni_raw_decrypt_block192( + output->aes_block = aesni_aes192_decrypt_block_( input->aes_block, ¶ms->aes192_key_schedule); return AESNI_SUCCESS; @@ -71,7 +71,7 @@ static AesNI_StatusCode aesni_box_encrypt_aes256( AesNI_State* output, AesNI_ErrorDetails* err_details) { - output->aes_block = aesni_raw_encrypt_block256( + output->aes_block = aesni_aes256_encrypt_block_( input->aes_block, ¶ms->aes256_key_schedule); return AESNI_SUCCESS; @@ -83,7 +83,7 @@ static AesNI_StatusCode aesni_box_decrypt_aes256( AesNI_State* output, AesNI_ErrorDetails* err_details) { - output->aes_block = aesni_raw_decrypt_block256( + output->aes_block = aesni_aes256_decrypt_block_( input->aes_block, ¶ms->aes256_key_schedule); return AESNI_SUCCESS; @@ -132,10 +132,10 @@ static AesNI_StatusCode aesni_box_init_aes128( const AesNI_AlgorithmParams* algorithm_params, AesNI_ErrorDetails* err_details) { - aesni_raw_expand_key_schedule128( + aesni_aes128_expand_key_( algorithm_params->aes128_key, &box->encrypt_params.aes128_key_schedule); - aesni_raw_invert_key_schedule128( + aesni_aes128_derive_decryption_keys_( &box->encrypt_params.aes128_key_schedule, &box->decrypt_params.aes128_key_schedule); return AESNI_SUCCESS; @@ -146,11 +146,11 @@ static AesNI_StatusCode aesni_box_init_aes192( const AesNI_AlgorithmParams* algorithm_params, AesNI_ErrorDetails* err_details) { - aesni_raw_expand_key_schedule192( + aesni_aes192_expand_key_( algorithm_params->aes192_key.lo, algorithm_params->aes192_key.hi, &box->encrypt_params.aes192_key_schedule); - aesni_raw_invert_key_schedule192( + aesni_aes192_derive_decryption_keys_( &box->encrypt_params.aes192_key_schedule, &box->decrypt_params.aes192_key_schedule); return AESNI_SUCCESS; @@ -161,11 +161,11 @@ static AesNI_StatusCode aesni_box_init_aes256( const AesNI_AlgorithmParams* algorithm_params, AesNI_ErrorDetails* err_details) { - aesni_raw_expand_key_schedule256( + aesni_aes256_expand_key_( algorithm_params->aes256_key.lo, algorithm_params->aes256_key.hi, &box->encrypt_params.aes256_key_schedule); - aesni_raw_invert_key_schedule256( + aesni_aes256_derive_decryption_keys_( &box->encrypt_params.aes256_key_schedule, &box->decrypt_params.aes256_key_schedule); return AESNI_SUCCESS; diff --git a/src/buffer.c b/src/buffer.c index a4aed96..983c5cf 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -18,7 +18,7 @@ AesNI_StatusCode aesni_encrypt_buffer_ecb128( size_t src_size, void* dest, size_t* dest_size, - AesNI_KeySchedule128* key_schedule, + AesNI_Aes128_RoundKeys* key_schedule, AesNI_ErrorDetails* err_details) { if (dest_size == NULL) @@ -40,7 +40,7 @@ AesNI_StatusCode aesni_encrypt_buffer_ecb128( for (size_t i = 0; i < src_len; ++i, (char*) src += 16, (char*) dest += 16) { AesNI_Block128 plaintext = aesni_load_block128(src); - AesNI_Block128 ciphertext = aesni_encrypt_block_ecb128(plaintext, key_schedule); + AesNI_Block128 ciphertext = aesni_aes128_encrypt_block_ecb(plaintext, key_schedule); aesni_store_block128(dest, ciphertext); } @@ -57,7 +57,7 @@ AesNI_StatusCode aesni_encrypt_buffer_ecb128( } AesNI_Block128 plaintext = aesni_load_block128(padding); - AesNI_Block128 ciphertext = aesni_encrypt_block_ecb128(plaintext, key_schedule); + AesNI_Block128 ciphertext = aesni_aes128_encrypt_block_ecb(plaintext, key_schedule); aesni_store_block128(dest, ciphertext); return AESNI_SUCCESS; @@ -80,7 +80,7 @@ AesNI_StatusCode aesni_decrypt_buffer_ecb128( size_t src_size, void* dest, size_t* dest_size, - AesNI_KeySchedule128* inverted_schedule, + AesNI_Aes128_RoundKeys* inverted_schedule, AesNI_ErrorDetails* err_details) { if (dest_size == NULL) @@ -100,12 +100,12 @@ AesNI_StatusCode aesni_decrypt_buffer_ecb128( for (size_t i = 0; i < src_len - 1; ++i, (char*) src += 16, (char*) dest += 16) { AesNI_Block128 ciphertext = aesni_load_block128(src); - AesNI_Block128 plaintext = aesni_decrypt_block_ecb128(ciphertext, inverted_schedule); + AesNI_Block128 plaintext = aesni_aes128_decrypt_block_ecb(ciphertext, inverted_schedule); aesni_store_block128(dest, plaintext); } AesNI_Block128 ciphertext = aesni_load_block128(src); - AesNI_Block128 plaintext = aesni_decrypt_block_ecb128(ciphertext, inverted_schedule); + AesNI_Block128 plaintext = aesni_aes128_decrypt_block_ecb(ciphertext, inverted_schedule); unsigned char padding[16]; aesni_store_block128(padding, plaintext); diff --git a/src/c/aes128.c b/src/c/aes128.c index 92bc4a6..49ebc4a 100644 --- a/src/c/aes128.c +++ b/src/c/aes128.c @@ -11,9 +11,9 @@ #include #include -AesNI_Block128 __fastcall aesni_raw_encrypt_block128( +AesNI_Block128 __fastcall aesni_aes128_encrypt_block_( AesNI_Block128 plain, - const AesNI_KeySchedule128* key_schedule) + const AesNI_Aes128_RoundKeys* key_schedule) { plain = _mm_xor_si128(plain, key_schedule->keys[0]); plain = _mm_aesenc_si128(plain, key_schedule->keys[1]); @@ -28,9 +28,9 @@ AesNI_Block128 __fastcall aesni_raw_encrypt_block128( return _mm_aesenclast_si128(plain, key_schedule->keys[10]); } -AesNI_Block128 __fastcall aesni_raw_decrypt_block128( +AesNI_Block128 __fastcall aesni_aes128_decrypt_block_( AesNI_Block128 cipher, - const AesNI_KeySchedule128* inverted_schedule) + const AesNI_Aes128_RoundKeys* inverted_schedule) { cipher = _mm_xor_si128(cipher, inverted_schedule->keys[0]); cipher = _mm_aesdec_si128(cipher, inverted_schedule->keys[1]); @@ -45,7 +45,7 @@ AesNI_Block128 __fastcall aesni_raw_decrypt_block128( return _mm_aesdeclast_si128(cipher, inverted_schedule->keys[10]); } -static AesNI_Block128 __fastcall aes128_keygen_assist( +static AesNI_Block128 __fastcall aesni_aes128_expand_key_assist( AesNI_Block128 prev, AesNI_Block128 hwgen) { @@ -64,26 +64,26 @@ static AesNI_Block128 __fastcall aes128_keygen_assist( return prev; } -void __fastcall aesni_raw_expand_key_schedule128( +void __fastcall aesni_aes128_expand_key_( AesNI_Block128 key, - AesNI_KeySchedule128* key_schedule) + AesNI_Aes128_RoundKeys* key_schedule) { AesNI_Block128 prev = key_schedule->keys[0] = key; - prev = key_schedule->keys[1] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x01)); - prev = key_schedule->keys[2] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x02)); - prev = key_schedule->keys[3] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x04)); - prev = key_schedule->keys[4] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x08)); - prev = key_schedule->keys[5] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x10)); - prev = key_schedule->keys[6] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x20)); - prev = key_schedule->keys[7] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x40)); - prev = key_schedule->keys[8] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x80)); - prev = key_schedule->keys[9] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x1b)); - prev = key_schedule->keys[10] = aes128_keygen_assist(prev, _mm_aeskeygenassist_si128(prev, 0x36)); + prev = key_schedule->keys[1] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x01)); + prev = key_schedule->keys[2] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x02)); + prev = key_schedule->keys[3] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x04)); + prev = key_schedule->keys[4] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x08)); + prev = key_schedule->keys[5] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x10)); + prev = key_schedule->keys[6] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x20)); + prev = key_schedule->keys[7] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x40)); + prev = key_schedule->keys[8] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x80)); + prev = key_schedule->keys[9] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x1b)); + prev = key_schedule->keys[10] = aesni_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x36)); } -void __fastcall aesni_raw_invert_key_schedule128( - const AesNI_KeySchedule128* key_schedule, - AesNI_KeySchedule128* inverted_schedule) +void __fastcall aesni_aes128_derive_decryption_keys_( + const AesNI_Aes128_RoundKeys* key_schedule, + AesNI_Aes128_RoundKeys* inverted_schedule) { inverted_schedule->keys[0] = key_schedule->keys[10]; inverted_schedule->keys[1] = _mm_aesimc_si128(key_schedule->keys[9]); diff --git a/src/c/aes192.c b/src/c/aes192.c index b3a7e9f..d6ecea1 100644 --- a/src/c/aes192.c +++ b/src/c/aes192.c @@ -11,9 +11,9 @@ #include #include -AesNI_Block128 __fastcall aesni_raw_encrypt_block192( +AesNI_Block128 __fastcall aesni_aes192_encrypt_block_( AesNI_Block128 plain, - const AesNI_KeySchedule192* key_schedule) + const AesNI_Aes192_RoundKeys* key_schedule) { plain = _mm_xor_si128(plain, key_schedule->keys[0]); plain = _mm_aesenc_si128(plain, key_schedule->keys[1]); @@ -30,9 +30,9 @@ AesNI_Block128 __fastcall aesni_raw_encrypt_block192( return _mm_aesenclast_si128(plain, key_schedule->keys[12]); } -AesNI_Block128 __fastcall aesni_raw_decrypt_block192( +AesNI_Block128 __fastcall aesni_aes192_decrypt_block_( AesNI_Block128 cipher, - const AesNI_KeySchedule192* inverted_schedule) + const AesNI_Aes192_RoundKeys* inverted_schedule) { cipher = _mm_xor_si128(cipher, inverted_schedule->keys[0]); cipher = _mm_aesdec_si128(cipher, inverted_schedule->keys[1]); @@ -49,7 +49,7 @@ AesNI_Block128 __fastcall aesni_raw_decrypt_block192( return _mm_aesdeclast_si128(cipher, inverted_schedule->keys[12]); } -static void __fastcall aes192_keygen_assist( +static void __fastcall aesni_aes192_expand_key_assist( AesNI_Block128* prev_lo, AesNI_Block128* prev_hi, AesNI_Block128 hwgen) @@ -74,49 +74,49 @@ static void __fastcall aes192_keygen_assist( *prev_hi = _mm_xor_si128(*prev_hi, tmp); } -void __fastcall aesni_raw_expand_key_schedule192( +void __fastcall aesni_aes192_expand_key_( AesNI_Block128 key_lo, AesNI_Block128 key_hi, - AesNI_KeySchedule192* key_schedule) + AesNI_Aes192_RoundKeys* key_schedule) { key_schedule->keys[0] = key_lo; key_schedule->keys[1] = key_hi; - aes192_keygen_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x01)); + aesni_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x01)); key_schedule->keys[1] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_schedule->keys[1]), _mm_castsi128_pd(key_lo), 0)); key_schedule->keys[2] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1)); - aes192_keygen_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x02)); + aesni_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x02)); key_schedule->keys[3] = key_lo; key_schedule->keys[4] = key_hi; - aes192_keygen_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x04)); + aesni_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x04)); key_schedule->keys[4] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_schedule->keys[4]), _mm_castsi128_pd(key_lo), 0)); key_schedule->keys[5] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1)); - aes192_keygen_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x08)); + aesni_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x08)); key_schedule->keys[6] = key_lo; key_schedule->keys[7] = key_hi; - aes192_keygen_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x10)); + aesni_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x10)); key_schedule->keys[7] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_schedule->keys[7]), _mm_castsi128_pd(key_lo), 0)); key_schedule->keys[8] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1)); - aes192_keygen_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x20)); + aesni_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x20)); key_schedule->keys[9] = key_lo; key_schedule->keys[10] = key_hi; - aes192_keygen_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x40)); + aesni_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x40)); key_schedule->keys[10] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_schedule->keys[10]), _mm_castsi128_pd(key_lo), 0)); key_schedule->keys[11] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1)); - aes192_keygen_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x80)); + aesni_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x80)); key_schedule->keys[12] = key_lo; } -void __fastcall aesni_raw_invert_key_schedule192( - const AesNI_KeySchedule192* key_schedule, - AesNI_KeySchedule192* inverted_schedule) +void __fastcall aesni_aes192_derive_decryption_keys_( + const AesNI_Aes192_RoundKeys* key_schedule, + AesNI_Aes192_RoundKeys* inverted_schedule) { inverted_schedule->keys[0] = key_schedule->keys[12]; inverted_schedule->keys[1] = _mm_aesimc_si128(key_schedule->keys[11]); diff --git a/src/c/aes256.c b/src/c/aes256.c index cd48d0d..05e643e 100644 --- a/src/c/aes256.c +++ b/src/c/aes256.c @@ -11,9 +11,9 @@ #include #include -AesNI_Block128 __fastcall aesni_raw_encrypt_block256( +AesNI_Block128 __fastcall aesni_aes256_encrypt_block_( AesNI_Block128 plain, - const AesNI_KeySchedule256* key_schedule) + const AesNI_Aes256_RoundKeys* key_schedule) { plain = _mm_xor_si128(plain, key_schedule->keys[0]); plain = _mm_aesenc_si128(plain, key_schedule->keys[1]); @@ -32,9 +32,9 @@ AesNI_Block128 __fastcall aesni_raw_encrypt_block256( return _mm_aesenclast_si128(plain, key_schedule->keys[14]); } -AesNI_Block128 __fastcall aesni_raw_decrypt_block256( +AesNI_Block128 __fastcall aesni_aes256_decrypt_block_( AesNI_Block128 cipher, - const AesNI_KeySchedule256* inverted_schedule) + const AesNI_Aes256_RoundKeys* inverted_schedule) { cipher = _mm_xor_si128(cipher, inverted_schedule->keys[0]); cipher = _mm_aesdec_si128(cipher, inverted_schedule->keys[1]); @@ -53,7 +53,7 @@ AesNI_Block128 __fastcall aesni_raw_decrypt_block256( return _mm_aesdeclast_si128(cipher, inverted_schedule->keys[14]); } -static AesNI_Block128 __fastcall aes256_keygen_assist( +static AesNI_Block128 __fastcall aesni_aes256_expand_key_assist( AesNI_Block128* prev_lo, AesNI_Block128* prev_hi, AesNI_Block128 hwgen) @@ -76,10 +76,10 @@ static AesNI_Block128 __fastcall aes256_keygen_assist( return *prev_hi; } -void __fastcall aesni_raw_expand_key_schedule256( +void __fastcall aesni_aes256_expand_key_( AesNI_Block128 key_lo, AesNI_Block128 key_hi, - AesNI_KeySchedule256* key_schedule) + AesNI_Aes256_RoundKeys* key_schedule) { AesNI_Block128 prev_lo, prev_hi; AesNI_Block128 hwgen; @@ -89,60 +89,60 @@ void __fastcall aesni_raw_expand_key_schedule256( hwgen = _mm_aeskeygenassist_si128(prev_hi, 0x01); hwgen = _mm_shuffle_epi32(hwgen, 0xff); - key_schedule->keys[2] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[2] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0); hwgen = _mm_shuffle_epi32(hwgen, 0xaa); - key_schedule->keys[3] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[3] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0x02); hwgen = _mm_shuffle_epi32(hwgen, 0xff); - key_schedule->keys[4] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[4] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0); hwgen = _mm_shuffle_epi32(hwgen, 0xaa); - key_schedule->keys[5] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[5] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0x04); hwgen = _mm_shuffle_epi32(hwgen, 0xff); - key_schedule->keys[6] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[6] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0); hwgen = _mm_shuffle_epi32(hwgen, 0xaa); - key_schedule->keys[7] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[7] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0x08); hwgen = _mm_shuffle_epi32(hwgen, 0xff); - key_schedule->keys[8] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[8] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0); hwgen = _mm_shuffle_epi32(hwgen, 0xaa); - key_schedule->keys[9] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[9] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0x10); hwgen = _mm_shuffle_epi32(hwgen, 0xff); - key_schedule->keys[10] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[10] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0); hwgen = _mm_shuffle_epi32(hwgen, 0xaa); - key_schedule->keys[11] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[11] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0x20); hwgen = _mm_shuffle_epi32(hwgen, 0xff); - key_schedule->keys[12] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[12] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0); hwgen = _mm_shuffle_epi32(hwgen, 0xaa); - key_schedule->keys[13] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[13] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); hwgen = _mm_aeskeygenassist_si128(prev_hi, 0x40); hwgen = _mm_shuffle_epi32(hwgen, 0xff); - key_schedule->keys[14] = aes256_keygen_assist(&prev_lo, &prev_hi, hwgen); + key_schedule->keys[14] = aesni_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen); } -void __fastcall aesni_raw_invert_key_schedule256( - const AesNI_KeySchedule256* key_schedule, - AesNI_KeySchedule256* inverted_schedule) +void __fastcall aesni_aes256_derive_decryption_keys_( + const AesNI_Aes256_RoundKeys* key_schedule, + AesNI_Aes256_RoundKeys* inverted_schedule) { inverted_schedule->keys[0] = key_schedule->keys[14]; inverted_schedule->keys[1] = _mm_aesimc_si128(key_schedule->keys[13]); diff --git a/test/aes128cbc_decrypt_block.c b/test/aes128cbc_decrypt_block.c index 933c279..73586eb 100644 --- a/test/aes128cbc_decrypt_block.c +++ b/test/aes128cbc_decrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher, iv; - AesNI_KeySchedule128 key_schedule, inverted_schedule; + AesNI_Aes128_RoundKeys key_schedule, inverted_schedule; if (argc < 2) exit_with_usage(); @@ -40,8 +40,8 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); - aesni_invert_key_schedule128(&key_schedule, &inverted_schedule); + aesni_aes128_expand_key(key, &key_schedule); + aesni_aes128_derive_decryption_keys(&key_schedule, &inverted_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_cbc128(cipher, &inverted_schedule, iv, &iv); + plain = aesni_aes128_decrypt_block_cbc(cipher, &inverted_schedule, iv, &iv); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes128cbc_encrypt_block.c b/test/aes128cbc_encrypt_block.c index 109dfc1..dfdd7d3 100644 --- a/test/aes128cbc_encrypt_block.c +++ b/test/aes128cbc_encrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher, iv; - AesNI_KeySchedule128 key_schedule; + AesNI_Aes128_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -40,7 +40,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); + aesni_aes128_expand_key(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -52,7 +52,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_cbc128(plain, &key_schedule, iv, &iv); + cipher = aesni_aes128_encrypt_block_cbc(plain, &key_schedule, iv, &iv); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes128cfb_decrypt_block.c b/test/aes128cfb_decrypt_block.c index 4f4803a..a78f276 100644 --- a/test/aes128cfb_decrypt_block.c +++ b/test/aes128cfb_decrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher, iv; - AesNI_KeySchedule128 key_schedule; + AesNI_Aes128_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -40,7 +40,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); + aesni_aes128_expand_key(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -52,7 +52,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_cfb128(cipher, &key_schedule, iv, &iv); + plain = aesni_aes128_decrypt_block_cfb(cipher, &key_schedule, iv, &iv); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes128cfb_encrypt_block.c b/test/aes128cfb_encrypt_block.c index 90a1a4b..576a2ed 100644 --- a/test/aes128cfb_encrypt_block.c +++ b/test/aes128cfb_encrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher, iv; - AesNI_KeySchedule128 key_schedule; + AesNI_Aes128_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -40,7 +40,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); + aesni_aes128_expand_key(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -52,7 +52,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_cfb128(plain, &key_schedule, iv, &iv); + cipher = aesni_aes128_encrypt_block_cfb(plain, &key_schedule, iv, &iv); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes128ctr_decrypt_block.c b/test/aes128ctr_decrypt_block.c index 54c8375..940d2f4 100644 --- a/test/aes128ctr_decrypt_block.c +++ b/test/aes128ctr_decrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher, iv; - AesNI_KeySchedule128 key_schedule; + AesNI_Aes128_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -40,7 +40,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); + aesni_aes128_expand_key(key, &key_schedule); int ctr = 0; @@ -54,7 +54,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_ctr128(cipher, &key_schedule, iv, ctr++); + plain = aesni_aes128_decrypt_block_ctr(cipher, &key_schedule, iv, ctr++); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes128ctr_encrypt_block.c b/test/aes128ctr_encrypt_block.c index d5cec3b..32dd216 100644 --- a/test/aes128ctr_encrypt_block.c +++ b/test/aes128ctr_encrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher, iv; - AesNI_KeySchedule128 key_schedule; + AesNI_Aes128_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -40,7 +40,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); + aesni_aes128_expand_key(key, &key_schedule); int ctr = 0; @@ -54,7 +54,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_ctr128(plain, &key_schedule, iv, ctr++); + cipher = aesni_aes128_encrypt_block_ctr(plain, &key_schedule, iv, ctr++); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes128ecb_decrypt_block.c b/test/aes128ecb_decrypt_block.c index f470ecc..5885fb9 100644 --- a/test/aes128ecb_decrypt_block.c +++ b/test/aes128ecb_decrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher; - AesNI_KeySchedule128 key_schedule, inverted_schedule; + AesNI_Aes128_RoundKeys key_schedule, inverted_schedule; if (argc < 1) exit_with_usage(); @@ -34,8 +34,8 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); - aesni_invert_key_schedule128(&key_schedule, &inverted_schedule); + aesni_aes128_expand_key(key, &key_schedule); + aesni_aes128_derive_decryption_keys(&key_schedule, &inverted_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { @@ -47,7 +47,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_ecb128(cipher, &inverted_schedule); + plain = aesni_aes128_decrypt_block_ecb(cipher, &inverted_schedule); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes128ecb_encrypt_block.c b/test/aes128ecb_encrypt_block.c index be86d05..040d47d 100644 --- a/test/aes128ecb_encrypt_block.c +++ b/test/aes128ecb_encrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher; - AesNI_KeySchedule128 key_schedule; + AesNI_Aes128_RoundKeys key_schedule; if (argc < 1) exit_with_usage(); @@ -34,7 +34,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); + aesni_aes128_expand_key(key, &key_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { @@ -46,7 +46,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_ecb128(plain, &key_schedule); + cipher = aesni_aes128_encrypt_block_ecb(plain, &key_schedule); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes128ofb_decrypt_block.c b/test/aes128ofb_decrypt_block.c index b8a6880..16f148d 100644 --- a/test/aes128ofb_decrypt_block.c +++ b/test/aes128ofb_decrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher, iv; - AesNI_KeySchedule128 key_schedule; + AesNI_Aes128_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -40,7 +40,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); + aesni_aes128_expand_key(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -52,7 +52,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_ofb128(cipher, &key_schedule, iv, &iv); + plain = aesni_aes128_decrypt_block_ofb(cipher, &key_schedule, iv, &iv); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes128ofb_encrypt_block.c b/test/aes128ofb_encrypt_block.c index a64fa31..4532cc8 100644 --- a/test/aes128ofb_encrypt_block.c +++ b/test/aes128ofb_encrypt_block.c @@ -23,7 +23,7 @@ int main(int argc, char** argv) for (--argc, ++argv; argc > -1; --argc, ++argv) { AesNI_Block128 plain, key, cipher, iv; - AesNI_KeySchedule128 key_schedule; + AesNI_Aes128_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -40,7 +40,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule128(key, &key_schedule); + aesni_aes128_expand_key(key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -52,7 +52,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_ofb128(plain, &key_schedule, iv, &iv); + cipher = aesni_aes128_encrypt_block_ofb(plain, &key_schedule, iv, &iv); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes192cbc_decrypt_block.c b/test/aes192cbc_decrypt_block.c index 2ee439f..9d5e1d6 100644 --- a/test/aes192cbc_decrypt_block.c +++ b/test/aes192cbc_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule, inverted_schedule; + AesNI_Aes192_RoundKeys key_schedule, inverted_schedule; if (argc < 2) exit_with_usage(); @@ -41,8 +41,8 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); - aesni_invert_key_schedule192(&key_schedule, &inverted_schedule); + aesni_aes192_expand_key(&key, &key_schedule); + aesni_aes192_derive_decryption_keys(&key_schedule, &inverted_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -54,7 +54,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_cbc192(cipher, &inverted_schedule, iv, &iv); + plain = aesni_aes192_decrypt_block_cbc(cipher, &inverted_schedule, iv, &iv); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes192cbc_encrypt_block.c b/test/aes192cbc_encrypt_block.c index ffd164e..d562ae5 100644 --- a/test/aes192cbc_encrypt_block.c +++ b/test/aes192cbc_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule; + AesNI_Aes192_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); + aesni_aes192_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_cbc192(plain, &key_schedule, iv, &iv); + cipher = aesni_aes192_encrypt_block_cbc(plain, &key_schedule, iv, &iv); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes192cfb_decrypt_block.c b/test/aes192cfb_decrypt_block.c index 4bd04bd..b5703d1 100644 --- a/test/aes192cfb_decrypt_block.c +++ b/test/aes192cfb_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule; + AesNI_Aes192_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); + aesni_aes192_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_cfb192(cipher, &key_schedule, iv, &iv); + plain = aesni_aes192_decrypt_block_cfb(cipher, &key_schedule, iv, &iv); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes192cfb_encrypt_block.c b/test/aes192cfb_encrypt_block.c index 6248e94..a23aa72 100644 --- a/test/aes192cfb_encrypt_block.c +++ b/test/aes192cfb_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule; + AesNI_Aes192_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); + aesni_aes192_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_cfb192(plain, &key_schedule, iv, &iv); + cipher = aesni_aes192_encrypt_block_cfb(plain, &key_schedule, iv, &iv); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes192ctr_decrypt_block.c b/test/aes192ctr_decrypt_block.c index 6d0387e..14e91d9 100644 --- a/test/aes192ctr_decrypt_block.c +++ b/test/aes192ctr_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule; + AesNI_Aes192_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); + aesni_aes192_expand_key(&key, &key_schedule); int ctr = 0; @@ -55,7 +55,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_ctr192(cipher, &key_schedule, iv, ctr++); + plain = aesni_aes192_decrypt_block_ctr(cipher, &key_schedule, iv, ctr++); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes192ctr_encrypt_block.c b/test/aes192ctr_encrypt_block.c index d0780c1..e613d87 100644 --- a/test/aes192ctr_encrypt_block.c +++ b/test/aes192ctr_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule; + AesNI_Aes192_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); + aesni_aes192_expand_key(&key, &key_schedule); int ctr = 0; @@ -55,7 +55,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_ctr192(plain, &key_schedule, iv, ctr++); + cipher = aesni_aes192_encrypt_block_ctr(plain, &key_schedule, iv, ctr++); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes192ecb_decrypt_block.c b/test/aes192ecb_decrypt_block.c index 399e00c..39689e9 100644 --- a/test/aes192ecb_decrypt_block.c +++ b/test/aes192ecb_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule, inverted_schedule; + AesNI_Aes192_RoundKeys key_schedule, inverted_schedule; if (argc < 1) exit_with_usage(); @@ -35,8 +35,8 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); - aesni_invert_key_schedule192(&key_schedule, &inverted_schedule); + aesni_aes192_expand_key(&key, &key_schedule); + aesni_aes192_derive_decryption_keys(&key_schedule, &inverted_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { @@ -48,7 +48,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_ecb192(cipher, &inverted_schedule); + plain = aesni_aes192_decrypt_block_ecb(cipher, &inverted_schedule); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes192ecb_encrypt_block.c b/test/aes192ecb_encrypt_block.c index 051efc3..167ffd4 100644 --- a/test/aes192ecb_encrypt_block.c +++ b/test/aes192ecb_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule; + AesNI_Aes192_RoundKeys key_schedule; if (argc < 1) exit_with_usage(); @@ -35,7 +35,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); + aesni_aes192_expand_key(&key, &key_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { @@ -47,7 +47,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_ecb192(plain, &key_schedule); + cipher = aesni_aes192_encrypt_block_ecb(plain, &key_schedule); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes192ofb_decrypt_block.c b/test/aes192ofb_decrypt_block.c index 0cc1501..4dd5fbb 100644 --- a/test/aes192ofb_decrypt_block.c +++ b/test/aes192ofb_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule; + AesNI_Aes192_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); + aesni_aes192_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_ofb192(cipher, &key_schedule, iv, &iv); + plain = aesni_aes192_decrypt_block_ofb(cipher, &key_schedule, iv, &iv); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes192ofb_encrypt_block.c b/test/aes192ofb_encrypt_block.c index 8282c23..2a45b79 100644 --- a/test/aes192ofb_encrypt_block.c +++ b/test/aes192ofb_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block192 key; - AesNI_KeySchedule192 key_schedule; + AesNI_Aes192_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule192(&key, &key_schedule); + aesni_aes192_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_ofb192(plain, &key_schedule, iv, &iv); + cipher = aesni_aes192_encrypt_block_ofb(plain, &key_schedule, iv, &iv); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes256cbc_decrypt_block.c b/test/aes256cbc_decrypt_block.c index b3b15ce..7cfd85a 100644 --- a/test/aes256cbc_decrypt_block.c +++ b/test/aes256cbc_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule, inverted_schedule; + AesNI_Aes256_RoundKeys key_schedule, inverted_schedule; if (argc < 2) exit_with_usage(); @@ -41,8 +41,8 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); - aesni_invert_key_schedule256(&key_schedule, &inverted_schedule); + aesni_aes256_expand_key(&key, &key_schedule); + aesni_aes256_derive_decryption_keys(&key_schedule, &inverted_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -54,7 +54,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_cbc256(cipher, &inverted_schedule, iv, &iv); + plain = aesni_aes256_decrypt_block_cbc(cipher, &inverted_schedule, iv, &iv); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes256cbc_encrypt_block.c b/test/aes256cbc_encrypt_block.c index cb3be83..9c0c24b 100644 --- a/test/aes256cbc_encrypt_block.c +++ b/test/aes256cbc_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule; + AesNI_Aes256_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); + aesni_aes256_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_cbc256(plain, &key_schedule, iv, &iv); + cipher = aesni_aes256_encrypt_block_cbc(plain, &key_schedule, iv, &iv); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes256cfb_decrypt_block.c b/test/aes256cfb_decrypt_block.c index cfdfb4b..3f8f696 100644 --- a/test/aes256cfb_decrypt_block.c +++ b/test/aes256cfb_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule; + AesNI_Aes256_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); + aesni_aes256_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_cfb256(cipher, &key_schedule, iv, &iv); + plain = aesni_aes256_decrypt_block_cfb(cipher, &key_schedule, iv, &iv); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes256cfb_encrypt_block.c b/test/aes256cfb_encrypt_block.c index 0a73528..aca05a8 100644 --- a/test/aes256cfb_encrypt_block.c +++ b/test/aes256cfb_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule; + AesNI_Aes256_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); + aesni_aes256_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_cfb256(plain, &key_schedule, iv, &iv); + cipher = aesni_aes256_encrypt_block_cfb(plain, &key_schedule, iv, &iv); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes256ctr_decrypt_block.c b/test/aes256ctr_decrypt_block.c index 6e7f875..8255a11 100644 --- a/test/aes256ctr_decrypt_block.c +++ b/test/aes256ctr_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule; + AesNI_Aes256_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); + aesni_aes256_expand_key(&key, &key_schedule); int ctr = 0; @@ -55,7 +55,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_ctr256(cipher, &key_schedule, iv, ctr++); + plain = aesni_aes256_decrypt_block_ctr(cipher, &key_schedule, iv, ctr++); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes256ctr_encrypt_block.c b/test/aes256ctr_encrypt_block.c index 667b593..580c6e7 100644 --- a/test/aes256ctr_encrypt_block.c +++ b/test/aes256ctr_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule; + AesNI_Aes256_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); + aesni_aes256_expand_key(&key, &key_schedule); int ctr = 0; @@ -55,7 +55,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_ctr256(plain, &key_schedule, iv, ctr++); + cipher = aesni_aes256_encrypt_block_ctr(plain, &key_schedule, iv, ctr++); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes256ecb_decrypt_block.c b/test/aes256ecb_decrypt_block.c index 0ea066a..f4b38c5 100644 --- a/test/aes256ecb_decrypt_block.c +++ b/test/aes256ecb_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule, inverted_schedule; + AesNI_Aes256_RoundKeys key_schedule, inverted_schedule; if (argc < 1) exit_with_usage(); @@ -35,8 +35,8 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); - aesni_invert_key_schedule256(&key_schedule, &inverted_schedule); + aesni_aes256_expand_key(&key, &key_schedule); + aesni_aes256_derive_decryption_keys(&key_schedule, &inverted_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { @@ -48,7 +48,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_ecb256(cipher, &inverted_schedule); + plain = aesni_aes256_decrypt_block_ecb(cipher, &inverted_schedule); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes256ecb_encrypt_block.c b/test/aes256ecb_encrypt_block.c index 289c82f..7752383 100644 --- a/test/aes256ecb_encrypt_block.c +++ b/test/aes256ecb_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule; + AesNI_Aes256_RoundKeys key_schedule; if (argc < 1) exit_with_usage(); @@ -35,7 +35,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); + aesni_aes256_expand_key(&key, &key_schedule); for (--argc, ++argv; argc > 0; --argc, ++argv) { @@ -47,7 +47,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_ecb256(plain, &key_schedule); + cipher = aesni_aes256_encrypt_block_ecb(plain, &key_schedule); aesni_print_block128(&cipher, NULL); } } diff --git a/test/aes256ofb_decrypt_block.c b/test/aes256ofb_decrypt_block.c index e323d79..b1c533d 100644 --- a/test/aes256ofb_decrypt_block.c +++ b/test/aes256ofb_decrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule; + AesNI_Aes256_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); + aesni_aes256_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - plain = aesni_decrypt_block_ofb256(cipher, &key_schedule, iv, &iv); + plain = aesni_aes256_decrypt_block_ofb(cipher, &key_schedule, iv, &iv); aesni_print_block128(&plain, NULL); } } diff --git a/test/aes256ofb_encrypt_block.c b/test/aes256ofb_encrypt_block.c index 7a185eb..975a653 100644 --- a/test/aes256ofb_encrypt_block.c +++ b/test/aes256ofb_encrypt_block.c @@ -24,7 +24,7 @@ int main(int argc, char** argv) { AesNI_Block128 plain, cipher, iv; AesNI_Block256 key; - AesNI_KeySchedule256 key_schedule; + AesNI_Aes256_RoundKeys key_schedule; if (argc < 2) exit_with_usage(); @@ -41,7 +41,7 @@ int main(int argc, char** argv) exit_with_usage(); } - aesni_expand_key_schedule256(&key, &key_schedule); + aesni_aes256_expand_key(&key, &key_schedule); for (argc -= 2, argv += 2; argc > 0; --argc, ++argv) { @@ -53,7 +53,7 @@ int main(int argc, char** argv) fprintf(stderr, "Invalid 128-bit AES block '%s'\n", *argv); continue; } - cipher = aesni_encrypt_block_ofb256(plain, &key_schedule, iv, &iv); + cipher = aesni_aes256_encrypt_block_ofb(plain, &key_schedule, iv, &iv); aesni_print_block128(&cipher, NULL); } } diff --git a/utils/aes128ecb_decrypt_file.cpp b/utils/aes128ecb_decrypt_file.cpp index 5d9afd2..b2abe8f 100644 --- a/utils/aes128ecb_decrypt_file.cpp +++ b/utils/aes128ecb_decrypt_file.cpp @@ -37,7 +37,7 @@ namespace int main(int argc, char** argv) { AesNI_Block128 key; - AesNI_KeySchedule128 key_schedule, inverted_schedule; + AesNI_Aes128_RoundKeys key_schedule, inverted_schedule; if (argc != 4) exit_with_usage(); @@ -60,8 +60,8 @@ int main(int argc, char** argv) src_buf.assign(std::istreambuf_iterator(src_ifs), std::istreambuf_iterator()); - aesni_expand_key_schedule128(key, &key_schedule); - aesni_invert_key_schedule128(&key_schedule, &inverted_schedule); + aesni_aes128_expand_key(key, &key_schedule); + aesni_aes128_derive_decryption_keys(&key_schedule, &inverted_schedule); std::size_t dest_size; diff --git a/utils/aes128ecb_encrypt_file.cpp b/utils/aes128ecb_encrypt_file.cpp index a2d13c6..05863c2 100644 --- a/utils/aes128ecb_encrypt_file.cpp +++ b/utils/aes128ecb_encrypt_file.cpp @@ -37,7 +37,7 @@ namespace int main(int argc, char** argv) { AesNI_Block128 key; - AesNI_KeySchedule128 key_schedule; + AesNI_Aes128_RoundKeys key_schedule; if (argc != 4) exit_with_usage(); @@ -60,7 +60,7 @@ int main(int argc, char** argv) src_buf.assign(std::istreambuf_iterator(src_ifs), std::istreambuf_iterator()); - aesni_expand_key_schedule128(key, &key_schedule); + aesni_aes128_expand_key(key, &key_schedule); std::size_t dest_size; -- cgit v1.2.3