remove a few levels of stupid indirection

4 files changed, 307 insertions, 419 deletions

diff --git a/aes/include/aes/aes.h b/aes/include/aes/aes.h
index 956496d..99e5f4b 100644
--- a/aes/include/aes/aes.h
+++ b/aes/include/aes/aes.h
@@ -15,62 +15,34 @@
 extern "C" {
 #endif
 
-typedef AES_Block128 AES_AES_Block;
-typedef AES_AES_Block AES_AES128_Block;
-typedef AES_AES_Block AES_AES192_Block;
-typedef AES_AES_Block AES_AES256_Block;
-
 typedef struct {
-    AES_AES_Block key;
-} AES_AES128_Key;
+    AES_Block key;
+} AES128_Key;
 
 typedef struct {
-    AES_AES_Block hi;
-    AES_AES_Block lo;
-} AES_AES192_Key;
+    AES_Block hi;
+    AES_Block lo;
+} AES192_Key;
 
 typedef struct {
-    AES_AES_Block hi;
-    AES_AES_Block lo;
-} AES_AES256_Key;
-
-static inline AES_AES_Block aes_AES_make_block(int hi3, int hi2, int lo1, int lo0) {
-    return aes_make_block128(hi3, hi2, lo1, lo0);
-}
-
-static inline AES_AES128_Block aes_AES128_make_block(int hi3, int hi2, int lo1, int lo0) {
-    return aes_AES_make_block(hi3, hi2, lo1, lo0);
-}
-
-static inline AES_AES192_Block aes_AES192_make_block(int hi3, int hi2, int lo1, int lo0) {
-    return aes_AES_make_block(hi3, hi2, lo1, lo0);
-}
+    AES_Block hi;
+    AES_Block lo;
+} AES256_Key;
 
-static inline AES_AES256_Block aes_AES256_make_block(int hi3, int hi2, int lo1, int lo0) {
-    return aes_AES_make_block(hi3, hi2, lo1, lo0);
-}
-
-static inline AES_AES128_Key aes_AES128_make_key(int hi3, int hi2, int lo1, int lo0) {
-    AES_AES128_Key key;
-    key.key = aes_AES_make_block(hi3, hi2, lo1, lo0);
+static inline AES128_Key aes128_make_key(int hi3, int hi2, int lo1, int lo0) {
+    AES128_Key key;
+    key.key = aes_make_block(hi3, hi2, lo1, lo0);
     return key;
 }
 
-static inline AES_AES192_Key aes_AES192_make_key(
-    int hi5,
-    int hi4,
-    int lo3,
-    int lo2,
-    int lo1,
-    int lo0
-) {
-    AES_AES192_Key key;
-    key.hi = aes_AES_make_block(0, 0, hi5, hi4);
-    key.lo = aes_AES_make_block(lo3, lo2, lo1, lo0);
+static inline AES192_Key aes192_make_key(int hi5, int hi4, int lo3, int lo2, int lo1, int lo0) {
+    AES192_Key key;
+    key.hi = aes_make_block(0, 0, hi5, hi4);
+    key.lo = aes_make_block(lo3, lo2, lo1, lo0);
     return key;
 }
 
-static inline AES_AES256_Key aes_AES256_make_key(
+static inline AES256_Key aes256_make_key(
     int hi7,
     int hi6,
     int hi5,
@@ -80,154 +52,150 @@ static inline AES_AES256_Key aes_AES256_make_key(
     int lo1,
     int lo0
 ) {
-    AES_AES256_Key key;
-    key.hi = aes_AES_make_block(hi7, hi6, hi5, hi4);
-    key.lo = aes_AES_make_block(lo3, lo2, lo1, lo0);
+    AES256_Key key;
+    key.hi = aes_make_block(hi7, hi6, hi5, hi4);
+    key.lo = aes_make_block(lo3, lo2, lo1, lo0);
     return key;
 }
 
 typedef struct {
     char str[33];
-} AES_AES_BlockString;
+} AES_BlockString;
 
-typedef AES_AES_BlockString AES_AES128_BlockString;
-typedef AES_AES_BlockString AES_AES192_BlockString;
-typedef AES_AES_BlockString AES_AES256_BlockString;
+typedef AES_BlockString AES128_BlockString;
+typedef AES_BlockString AES192_BlockString;
+typedef AES_BlockString AES256_BlockString;
 
 typedef struct {
     char str[49];
-} AES_AES_BlockMatrixString;
+} AES_BlockMatrixString;
 
-typedef AES_AES_BlockMatrixString AES_AES128_BlockMatrixString;
-typedef AES_AES_BlockMatrixString AES_AES192_BlockMatrixString;
-typedef AES_AES_BlockMatrixString AES_AES256_BlockMatrixString;
+typedef AES_BlockMatrixString AES128_BlockMatrixString;
+typedef AES_BlockMatrixString AES192_BlockMatrixString;
+typedef AES_BlockMatrixString AES256_BlockMatrixString;
 
-AES_StatusCode aes_AES_format_block(AES_AES_BlockString*, const AES_AES_Block*, AES_ErrorDetails*);
+AES_StatusCode aes_AES_format_block(AES_BlockString*, const AES_Block*, AES_ErrorDetails*);
 
-static inline AES_StatusCode aes_AES128_format_block(
-    AES_AES128_BlockString* dest,
-    const AES_AES128_Block* src,
+static inline AES_StatusCode aes128_format_block(
+    AES128_BlockString* dest,
+    const AES_Block* src,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_format_block(dest, src, err_details);
 }
 
-static inline AES_StatusCode aes_AES192_format_block(
-    AES_AES192_BlockString* dest,
-    const AES_AES192_Block* src,
+static inline AES_StatusCode aes192_format_block(
+    AES192_BlockString* dest,
+    const AES_Block* src,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_format_block(dest, src, err_details);
 }
 
-static inline AES_StatusCode aes_AES256_format_block(
-    AES_AES256_BlockString* dest,
-    const AES_AES256_Block* src,
+static inline AES_StatusCode aes256_format_block(
+    AES256_BlockString* dest,
+    const AES_Block* src,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_format_block(dest, src, err_details);
 }
 
 AES_StatusCode aes_AES_format_block_as_matrix(
-    AES_AES_BlockMatrixString*,
-    const AES_AES_Block*,
+    AES_BlockMatrixString*,
+    const AES_Block*,
     AES_ErrorDetails*
 );
 
-static inline AES_StatusCode aes_AES128_format_block_as_matrix(
-    AES_AES128_BlockMatrixString* dest,
-    const AES_AES128_Block* src,
+static inline AES_StatusCode aes128_format_block_as_matrix(
+    AES128_BlockMatrixString* dest,
+    const AES_Block* src,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_format_block_as_matrix(dest, src, err_details);
 }
 
-static inline AES_StatusCode aes_AES192_format_block_as_matrix(
-    AES_AES192_BlockMatrixString* dest,
-    const AES_AES192_Block* src,
+static inline AES_StatusCode aes192_format_block_as_matrix(
+    AES192_BlockMatrixString* dest,
+    const AES_Block* src,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_format_block_as_matrix(dest, src, err_details);
 }
 
-static inline AES_StatusCode aes_AES256_format_block_as_matrix(
-    AES_AES256_BlockMatrixString* dest,
-    const AES_AES256_Block* src,
+static inline AES_StatusCode aes256_format_block_as_matrix(
+    AES256_BlockMatrixString* dest,
+    const AES_Block* src,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_format_block_as_matrix(dest, src, err_details);
 }
 
-AES_StatusCode aes_AES_print_block(const AES_AES_Block*, AES_ErrorDetails*);
+AES_StatusCode aes_AES_print_block(const AES_Block*, AES_ErrorDetails*);
 
-static inline AES_StatusCode aes_AES128_print_block(
-    const AES_AES128_Block* block,
+static inline AES_StatusCode aes128_print_block(
+    const AES_Block* block,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_print_block(block, err_details);
 }
 
-static inline AES_StatusCode aes_AES192_print_block(
-    const AES_AES192_Block* block,
+static inline AES_StatusCode aes192_print_block(
+    const AES_Block* block,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_print_block(block, err_details);
 }
 
-static inline AES_StatusCode aes_AES256_print_block(
-    const AES_AES256_Block* block,
+static inline AES_StatusCode aes256_print_block(
+    const AES_Block* block,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_print_block(block, err_details);
 }
 
-AES_StatusCode aes_AES_print_block_as_matrix(const AES_AES_Block*, AES_ErrorDetails*);
+AES_StatusCode aes_AES_print_block_as_matrix(const AES_Block*, AES_ErrorDetails*);
 
-static inline AES_StatusCode aes_AES128_print_block_as_matrix(
-    const AES_AES128_Block* block,
+static inline AES_StatusCode aes128_print_block_as_matrix(
+    const AES_Block* block,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_print_block_as_matrix(block, err_details);
 }
 
-static inline AES_StatusCode aes_AES192_print_block_as_matrix(
-    const AES_AES192_Block* block,
+static inline AES_StatusCode aes192_print_block_as_matrix(
+    const AES_Block* block,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_print_block_as_matrix(block, err_details);
 }
 
-static inline AES_StatusCode aes_AES256_print_block_as_matrix(
-    const AES_AES256_Block* block,
+static inline AES_StatusCode aes256_print_block_as_matrix(
+    const AES_Block* block,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_print_block_as_matrix(block, err_details);
 }
 
-AES_StatusCode aes_AES_parse_block(
-    AES_AES_Block* dest,
-    const char* src,
-    AES_ErrorDetails* err_details
-);
+AES_StatusCode aes_AES_parse_block(AES_Block* dest, const char* src, AES_ErrorDetails* err_details);
 
-static inline AES_StatusCode aes_AES128_parse_block(
-    AES_AES128_Block* dest,
+static inline AES_StatusCode aes128_parse_block(
+    AES_Block* dest,
     const char* src,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_parse_block(dest, src, err_details);
 }
 
-static inline AES_StatusCode aes_AES192_parse_block(
-    AES_AES192_Block* dest,
+static inline AES_StatusCode aes192_parse_block(
+    AES_Block* dest,
     const char* src,
     AES_ErrorDetails* err_details
 ) {
     return aes_AES_parse_block(dest, src, err_details);
 }
 
-static inline AES_StatusCode aes_AES256_parse_block(
-    AES_AES256_Block* dest,
+static inline AES_StatusCode aes256_parse_block(
+    AES_Block* dest,
     const char* src,
     AES_ErrorDetails* err_details
 ) {
@@ -236,204 +204,119 @@ static inline AES_StatusCode aes_AES256_parse_block(
 
 typedef struct {
     char str[33];
-} AES_AES128_KeyString;
+} AES128_KeyString;
 
 typedef struct {
     char str[49];
-} AES_AES192_KeyString;
+} AES192_KeyString;
 
 typedef struct {
     char str[65];
-} AES_AES256_KeyString;
+} AES256_KeyString;
 
-AES_StatusCode aes_AES128_format_key(
-    AES_AES128_KeyString*,
-    const AES_AES128_Key*,
-    AES_ErrorDetails*
-);
+AES_StatusCode aes128_format_key(AES128_KeyString*, const AES128_Key*, AES_ErrorDetails*);
 
-AES_StatusCode aes_AES192_format_key(
-    AES_AES192_KeyString*,
-    const AES_AES192_Key*,
-    AES_ErrorDetails*
-);
+AES_StatusCode aes192_format_key(AES192_KeyString*, const AES192_Key*, AES_ErrorDetails*);
 
-AES_StatusCode aes_AES256_format_key(
-    AES_AES256_KeyString*,
-    const AES_AES256_Key*,
-    AES_ErrorDetails*
-);
+AES_StatusCode aes256_format_key(AES256_KeyString*, const AES256_Key*, AES_ErrorDetails*);
 
-AES_StatusCode aes_AES128_print_key(const AES_AES128_Key*, AES_ErrorDetails*);
+AES_StatusCode aes128_print_key(const AES128_Key*, AES_ErrorDetails*);
 
-AES_StatusCode aes_AES192_print_key(const AES_AES192_Key*, AES_ErrorDetails*);
+AES_StatusCode aes192_print_key(const AES192_Key*, AES_ErrorDetails*);
 
-AES_StatusCode aes_AES256_print_key(const AES_AES256_Key*, AES_ErrorDetails*);
+AES_StatusCode aes256_print_key(const AES256_Key*, AES_ErrorDetails*);
 
-AES_StatusCode aes_AES128_parse_key(
-    AES_AES128_Key* dest,
-    const char* src,
-    AES_ErrorDetails* err_details
-);
+AES_StatusCode aes128_parse_key(AES128_Key* dest, const char* src, AES_ErrorDetails* err_details);
 
-AES_StatusCode aes_AES192_parse_key(
-    AES_AES192_Key* dest,
-    const char* src,
-    AES_ErrorDetails* err_details
-);
+AES_StatusCode aes192_parse_key(AES192_Key* dest, const char* src, AES_ErrorDetails* err_details);
 
-AES_StatusCode aes_AES256_parse_key(
-    AES_AES256_Key* dest,
-    const char* src,
-    AES_ErrorDetails* err_details
-);
+AES_StatusCode aes256_parse_key(AES256_Key* dest, const char* src, AES_ErrorDetails* err_details);
 
 typedef struct {
-    AES_AES_Block keys[11];
-} AES_AES128_RoundKeys;
+    AES_Block keys[11];
+} AES128_RoundKeys;
 
 typedef struct {
-    AES_AES_Block keys[13];
-} AES_AES192_RoundKeys;
+    AES_Block keys[13];
+} AES192_RoundKeys;
 
 typedef struct {
-    AES_AES_Block keys[15];
-} AES_AES256_RoundKeys;
+    AES_Block keys[15];
+} AES256_RoundKeys;
 
-void __fastcall aes_AES128_expand_key_(AES_AES_Block key, AES_AES128_RoundKeys* encryption_keys);
+void __fastcall aes128_expand_key_(AES_Block key, AES128_RoundKeys* encryption_keys);
 
-void __fastcall aes_AES192_expand_key_(
-    AES_AES_Block key_lo,
-    AES_AES_Block key_hi,
-    AES_AES192_RoundKeys* encryption_keys
+void __fastcall aes192_expand_key_(
+    AES_Block key_lo,
+    AES_Block key_hi,
+    AES192_RoundKeys* encryption_keys
 );
 
-void __fastcall aes_AES256_expand_key_(
-    AES_AES_Block key_lo,
-    AES_AES_Block key_hi,
-    AES_AES256_RoundKeys* encryption_keys
+void __fastcall aes256_expand_key_(
+    AES_Block key_lo,
+    AES_Block key_hi,
+    AES256_RoundKeys* encryption_keys
 );
 
-void __fastcall aes_AES128_derive_decryption_keys_(
-    const AES_AES128_RoundKeys* encryption_keys,
-    AES_AES128_RoundKeys* decryption_keys
+void __fastcall aes128_derive_decryption_keys_(
+    const AES128_RoundKeys* encryption_keys,
+    AES128_RoundKeys* decryption_keys
 );
 
-void __fastcall aes_AES192_derive_decryption_keys_(
-    const AES_AES192_RoundKeys* encryption_keys,
-    AES_AES192_RoundKeys* decryption_keys
+void __fastcall aes192_derive_decryption_keys_(
+    const AES192_RoundKeys* encryption_keys,
+    AES192_RoundKeys* decryption_keys
 );
 
-void __fastcall aes_AES256_derive_decryption_keys_(
-    const AES_AES256_RoundKeys* encryption_keys,
-    AES_AES256_RoundKeys* decryption_keys
+void __fastcall aes256_derive_decryption_keys_(
+    const AES256_RoundKeys* encryption_keys,
+    AES256_RoundKeys* decryption_keys
 );
 
-AES_AES_Block __fastcall aes_AES128_encrypt_block_(
-    AES_AES_Block plaintext,
-    const AES_AES128_RoundKeys*
-);
+AES_Block __fastcall aes128_encrypt_block_(AES_Block plaintext, const AES128_RoundKeys*);
 
-AES_AES_Block __fastcall aes_AES192_encrypt_block_(
-    AES_AES_Block plaintext,
-    const AES_AES192_RoundKeys*
-);
+AES_Block __fastcall aes192_encrypt_block_(AES_Block plaintext, const AES192_RoundKeys*);
 
-AES_AES_Block __fastcall aes_AES256_encrypt_block_(
-    AES_AES_Block plaintext,
-    const AES_AES256_RoundKeys*
-);
+AES_Block __fastcall aes256_encrypt_block_(AES_Block plaintext, const AES256_RoundKeys*);
 
-AES_AES_Block __fastcall aes_AES128_decrypt_block_(
-    AES_AES_Block ciphertext,
-    const AES_AES128_RoundKeys*
-);
+AES_Block __fastcall aes128_decrypt_block_(AES_Block ciphertext, const AES128_RoundKeys*);
 
-AES_AES_Block __fastcall aes_AES192_decrypt_block_(
-    AES_AES_Block ciphertext,
-    const AES_AES192_RoundKeys*
-);
-
-AES_AES_Block __fastcall aes_AES256_decrypt_block_(
-    AES_AES_Block ciphertext,
-    const AES_AES256_RoundKeys*
-);
+AES_Block __fastcall aes192_decrypt_block_(AES_Block ciphertext, const AES192_RoundKeys*);
 
-static inline AES_AES_Block __fastcall aes_AES_xor_blocks(AES_AES_Block a, AES_AES_Block b) {
-    return aes_xor_block128(a, b);
-}
-
-static inline AES_AES_Block __fastcall aes_AES128_xor_blocks(
-    AES_AES128_Block a,
-    AES_AES128_Block b
-) {
-    return aes_AES_xor_blocks(a, b);
-}
-
-static inline AES_AES_Block __fastcall aes_AES192_xor_blocks(
-    AES_AES192_Block a,
-    AES_AES192_Block b
-) {
-    return aes_AES_xor_blocks(a, b);
-}
-
-static inline AES_AES_Block __fastcall aes_AES256_xor_blocks(
-    AES_AES256_Block a,
-    AES_AES256_Block b
-) {
-    return aes_AES_xor_blocks(a, b);
-}
-
-static inline AES_AES_Block __fastcall aes_AES_inc_block(AES_AES_Block block) {
-    block = aes_reverse_byte_order_block128(block);
-    block = aes_inc_block128(block);
-    return aes_reverse_byte_order_block128(block);
-}
-
-static inline AES_AES_Block __fastcall aes_AES128_inc_block(AES_AES128_Block block) {
-    return aes_AES_inc_block(block);
-}
-
-static inline AES_AES_Block __fastcall aes_AES192_inc_block(AES_AES192_Block block) {
-    return aes_AES_inc_block(block);
-}
-
-static inline AES_AES_Block __fastcall aes_AES256_inc_block(AES_AES256_Block block) {
-    return aes_AES_inc_block(block);
-}
+AES_Block __fastcall aes256_decrypt_block_(AES_Block ciphertext, const AES256_RoundKeys*);
 
-AES_ENCRYPT_BLOCK_ECB(AES128)
-AES_DECRYPT_BLOCK_ECB(AES128)
-AES_ENCRYPT_BLOCK_CBC(AES128)
-AES_DECRYPT_BLOCK_CBC(AES128)
-AES_ENCRYPT_BLOCK_CFB(AES128)
-AES_DECRYPT_BLOCK_CFB(AES128)
-AES_ENCRYPT_BLOCK_OFB(AES128)
-AES_DECRYPT_BLOCK_OFB(AES128)
-AES_ENCRYPT_BLOCK_CTR(AES128)
-AES_DECRYPT_BLOCK_CTR(AES128)
+AES_ENCRYPT_BLOCK_ECB(128)
+AES_DECRYPT_BLOCK_ECB(128)
+AES_ENCRYPT_BLOCK_CBC(128)
+AES_DECRYPT_BLOCK_CBC(128)
+AES_ENCRYPT_BLOCK_CFB(128)
+AES_DECRYPT_BLOCK_CFB(128)
+AES_ENCRYPT_BLOCK_OFB(128)
+AES_DECRYPT_BLOCK_OFB(128)
+AES_ENCRYPT_BLOCK_CTR(128)
+AES_DECRYPT_BLOCK_CTR(128)
 
-AES_ENCRYPT_BLOCK_ECB(AES192)
-AES_DECRYPT_BLOCK_ECB(AES192)
-AES_ENCRYPT_BLOCK_CBC(AES192)
-AES_DECRYPT_BLOCK_CBC(AES192)
-AES_ENCRYPT_BLOCK_CFB(AES192)
-AES_DECRYPT_BLOCK_CFB(AES192)
-AES_ENCRYPT_BLOCK_OFB(AES192)
-AES_DECRYPT_BLOCK_OFB(AES192)
-AES_ENCRYPT_BLOCK_CTR(AES192)
-AES_DECRYPT_BLOCK_CTR(AES192)
+AES_ENCRYPT_BLOCK_ECB(192)
+AES_DECRYPT_BLOCK_ECB(192)
+AES_ENCRYPT_BLOCK_CBC(192)
+AES_DECRYPT_BLOCK_CBC(192)
+AES_ENCRYPT_BLOCK_CFB(192)
+AES_DECRYPT_BLOCK_CFB(192)
+AES_ENCRYPT_BLOCK_OFB(192)
+AES_DECRYPT_BLOCK_OFB(192)
+AES_ENCRYPT_BLOCK_CTR(192)
+AES_DECRYPT_BLOCK_CTR(192)
 
-AES_ENCRYPT_BLOCK_ECB(AES256)
-AES_DECRYPT_BLOCK_ECB(AES256)
-AES_ENCRYPT_BLOCK_CBC(AES256)
-AES_DECRYPT_BLOCK_CBC(AES256)
-AES_ENCRYPT_BLOCK_CFB(AES256)
-AES_DECRYPT_BLOCK_CFB(AES256)
-AES_ENCRYPT_BLOCK_OFB(AES256)
-AES_DECRYPT_BLOCK_OFB(AES256)
-AES_ENCRYPT_BLOCK_CTR(AES256)
-AES_DECRYPT_BLOCK_CTR(AES256)
+AES_ENCRYPT_BLOCK_ECB(256)
+AES_DECRYPT_BLOCK_ECB(256)
+AES_ENCRYPT_BLOCK_CBC(256)
+AES_DECRYPT_BLOCK_CBC(256)
+AES_ENCRYPT_BLOCK_CFB(256)
+AES_DECRYPT_BLOCK_CFB(256)
+AES_ENCRYPT_BLOCK_OFB(256)
+AES_DECRYPT_BLOCK_OFB(256)
+AES_ENCRYPT_BLOCK_CTR(256)
+AES_DECRYPT_BLOCK_CTR(256)
 
 /**
  * \brief Expands an AES-128 key into 10 encryption round keys.
@@ -441,13 +324,13 @@ AES_DECRYPT_BLOCK_CTR(AES256)
  * \param[in] key The AES-128 key.
  * \param[out] encryption_keys The AES-128 encryption round keys. Must not be `NULL`.
  */
-static inline void __fastcall aes_AES128_expand_key(
-    const AES_AES128_Key* key,
-    AES_AES128_RoundKeys* encryption_keys
+static inline void __fastcall aes128_expand_key(
+    const AES128_Key* key,
+    AES128_RoundKeys* encryption_keys
 ) {
     assert(encryption_keys);
 
-    aes_AES128_expand_key_(key->key, encryption_keys);
+    aes128_expand_key_(key->key, encryption_keys);
 }
 
 /**
@@ -456,14 +339,14 @@ static inline void __fastcall aes_AES128_expand_key(
  * \param[in] encryption_keys The AES-128 encryption round keys. Must not be `NULL`.
  * \param[out] decryption_keys The AES-128 decryption round keys. Must not be `NULL`.
  */
-static inline void __fastcall aes_AES128_derive_decryption_keys(
-    const AES_AES128_RoundKeys* encryption_keys,
-    AES_AES128_RoundKeys* decryption_keys
+static inline void __fastcall aes128_derive_decryption_keys(
+    const AES128_RoundKeys* encryption_keys,
+    AES128_RoundKeys* decryption_keys
 ) {
     assert(encryption_keys);
     assert(decryption_keys);
 
-    aes_AES128_derive_decryption_keys_(encryption_keys, decryption_keys);
+    aes128_derive_decryption_keys_(encryption_keys, decryption_keys);
 }
 
 /**
@@ -472,14 +355,14 @@ static inline void __fastcall aes_AES128_derive_decryption_keys(
  * \param[in] key The AES-192 key.
  * \param[out] encryption_keys The AES-192 encryption round keys. Must not be `NULL`.
  */
-static inline void __fastcall aes_AES192_expand_key(
-    const AES_AES192_Key* key,
-    AES_AES192_RoundKeys* encryption_keys
+static inline void __fastcall aes192_expand_key(
+    const AES192_Key* key,
+    AES192_RoundKeys* encryption_keys
 ) {
     assert(key);
     assert(encryption_keys);
 
-    aes_AES192_expand_key_(key->lo, key->hi, encryption_keys);
+    aes192_expand_key_(key->lo, key->hi, encryption_keys);
 }
 
 /**
@@ -488,14 +371,14 @@ static inline void __fastcall aes_AES192_expand_key(
  * \param[in] encryption_keys The AES-192 encryption round keys. Must not be `NULL`.
  * \param[out] decryption_keys The AES-192 decryption round keys. Must not be `NULL`.
  */
-static inline void __fastcall aes_AES192_derive_decryption_keys(
-    const AES_AES192_RoundKeys* encryption_keys,
-    AES_AES192_RoundKeys* decryption_keys
+static inline void __fastcall aes192_derive_decryption_keys(
+    const AES192_RoundKeys* encryption_keys,
+    AES192_RoundKeys* decryption_keys
 ) {
     assert(encryption_keys);
     assert(decryption_keys);
 
-    aes_AES192_derive_decryption_keys_(encryption_keys, decryption_keys);
+    aes192_derive_decryption_keys_(encryption_keys, decryption_keys);
 }
 
 /**
@@ -504,14 +387,14 @@ static inline void __fastcall aes_AES192_derive_decryption_keys(
  * \param[in] key The AES-256 key.
  * \param[out] encryption_keys The AES-256 encryption round keys. Must not be `NULL`.
  */
-static inline void __fastcall aes_AES256_expand_key(
-    const AES_AES256_Key* key,
-    AES_AES256_RoundKeys* encryption_keys
+static inline void __fastcall aes256_expand_key(
+    const AES256_Key* key,
+    AES256_RoundKeys* encryption_keys
 ) {
     assert(key);
     assert(encryption_keys);
 
-    aes_AES256_expand_key_(key->lo, key->hi, encryption_keys);
+    aes256_expand_key_(key->lo, key->hi, encryption_keys);
 }
 
 /**
@@ -520,14 +403,14 @@ static inline void __fastcall aes_AES256_expand_key(
  * \param[in] encryption_keys The AES-256 encryption round keys. Must not be `NULL`.
  * \param[out] decryption_keys The AES-256 decryption round keys. Must not be `NULL`.
  */
-static inline void __fastcall aes_AES256_derive_decryption_keys(
-    const AES_AES256_RoundKeys* encryption_keys,
-    AES_AES256_RoundKeys* decryption_keys
+static inline void __fastcall aes256_derive_decryption_keys(
+    const AES256_RoundKeys* encryption_keys,
+    AES256_RoundKeys* decryption_keys
 ) {
     assert(encryption_keys);
     assert(decryption_keys);
 
-    aes_AES256_derive_decryption_keys_(encryption_keys, decryption_keys);
+    aes256_derive_decryption_keys_(encryption_keys, decryption_keys);
 }
 
 #ifdef __cplusplus
diff --git a/aes/include/aes/box_data.h b/aes/include/aes/box_data.h
index a95a742..5e5ab98 100644
--- a/aes/include/aes/box_data.h
+++ b/aes/include/aes/box_data.h
@@ -16,35 +16,35 @@ extern "C" {
 #endif
 
 typedef union {
-    AES_AES128_Key aes128_key;
-    AES_AES192_Key aes192_key;
-    AES_AES256_Key aes256_key;
+    AES128_Key aes128_key;
+    AES192_Key aes192_key;
+    AES256_Key aes256_key;
 } AES_BoxKey;
 
 typedef union {
-    AES_AES128_RoundKeys aes128_encryption_keys;
-    AES_AES192_RoundKeys aes192_encryption_keys;
-    AES_AES256_RoundKeys aes256_encryption_keys;
+    AES128_RoundKeys aes128_encryption_keys;
+    AES192_RoundKeys aes192_encryption_keys;
+    AES256_RoundKeys aes256_encryption_keys;
 } AES_BoxEncryptionRoundKeys;
 
 typedef union {
-    AES_AES128_RoundKeys aes128_decryption_keys;
-    AES_AES192_RoundKeys aes192_decryption_keys;
-    AES_AES256_RoundKeys aes256_decryption_keys;
+    AES128_RoundKeys aes128_decryption_keys;
+    AES192_RoundKeys aes192_decryption_keys;
+    AES256_RoundKeys aes256_decryption_keys;
 } AES_BoxDecryptionRoundKeys;
 
 typedef union {
-    AES_AES128_KeyString aes128;
-    AES_AES192_KeyString aes192;
-    AES_AES256_KeyString aes256;
+    AES128_KeyString aes128;
+    AES192_KeyString aes192;
+    AES256_KeyString aes256;
 } AES_BoxKeyString;
 
 typedef union {
-    AES_AES_Block aes_block;
+    AES_Block aes_block;
 } AES_BoxBlock;
 
 typedef union {
-    AES_AES_BlockString aes;
+    AES_BlockString aes;
 } AES_BoxBlockString;
 
 typedef AES_StatusCode (*AES_BoxCalculateRoundKeys)(
diff --git a/aes/include/aes/data.h b/aes/include/aes/data.h
index 1aec404..b83cb1d 100644
--- a/aes/include/aes/data.h
+++ b/aes/include/aes/data.h
@@ -13,9 +13,9 @@ extern "C" {
 #endif
 
 /**
- * \brief Represents a 128-bit block.
+ * \brief Represents a 128-bit AES block.
  */
-typedef __m128i AES_Block128;
+typedef __m128i AES_Block;
 
 /**
  * \brief Loads a 128-bit block from a memory location.
@@ -24,8 +24,8 @@ typedef __m128i AES_Block128;
  *
  * \return The loaded 128-bit block.
  */
-static inline AES_Block128 aes_load_block128(const void* src) {
-    return _mm_loadu_si128((AES_Block128*)src);
+static inline AES_Block aes_load_block(const void* src) {
+    return _mm_loadu_si128((AES_Block*)src);
 }
 
 /**
@@ -35,8 +35,8 @@ static inline AES_Block128 aes_load_block128(const void* src) {
  *
  * \return The loaded 128-bit block.
  */
-static inline AES_Block128 aes_load_block128_aligned(const void* src) {
-    return _mm_load_si128((AES_Block128*)src);
+static inline AES_Block aes_load_block_aligned(const void* src) {
+    return _mm_load_si128((AES_Block*)src);
 }
 
 /**
@@ -46,8 +46,8 @@ static inline AES_Block128 aes_load_block128_aligned(const void* src) {
  *
  * \param[in] block The block to be stored.
  */
-static inline void __fastcall aes_store_block128(void* dest, AES_Block128 block) {
-    _mm_storeu_si128((AES_Block128*)dest, block);
+static inline void __fastcall aes_store_block(void* dest, AES_Block block) {
+    _mm_storeu_si128((AES_Block*)dest, block);
 }
 
 /**
@@ -57,8 +57,8 @@ static inline void __fastcall aes_store_block128(void* dest, AES_Block128 block)
  *
  * \param[in] block The block to be stored.
  */
-static inline void __fastcall aes_store_block128_aligned(void* dest, AES_Block128 block) {
-    _mm_store_si128((AES_Block128*)dest, block);
+static inline void __fastcall aes_store_block_aligned(void* dest, AES_Block block) {
+    _mm_store_si128((AES_Block*)dest, block);
 }
 
 /**
@@ -69,7 +69,7 @@ static inline void __fastcall aes_store_block128_aligned(void* dest, AES_Block12
  *
  * \return `a^b`.
  */
-static inline AES_Block128 __fastcall aes_xor_block128(AES_Block128 a, AES_Block128 b) {
+static inline AES_Block __fastcall aes_xor_blocks(AES_Block a, AES_Block b) {
     return _mm_xor_si128(a, b);
 }
 
@@ -90,18 +90,23 @@ static inline AES_Block128 __fastcall aes_xor_block128(AES_Block128 a, AES_Block
  *
  * \return The built 128-bit block.
  */
-static inline AES_Block128 __fastcall aes_make_block128(int hi3, int hi2, int lo1, int lo0) {
+static inline AES_Block __fastcall aes_make_block(int hi3, int hi2, int lo1, int lo0) {
     return _mm_set_epi32(hi3, hi2, lo1, lo0);
 }
 
-static inline AES_Block128 __fastcall aes_reverse_byte_order_block128(AES_Block128 block) {
-    return _mm_shuffle_epi8(
-        block, aes_make_block128(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f)
-    );
+static inline AES_Block __fastcall aes_reverse_byte_order_block(AES_Block block) {
+    return _mm_shuffle_epi8(block, aes_make_block(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f));
 }
 
-static inline AES_Block128 __fastcall aes_inc_block128(AES_Block128 x) {
-    return _mm_add_epi32(x, aes_make_block128(0, 0, 0, 1));
+static inline AES_Block __fastcall _aes_inc_block(AES_Block x) {
+    return _mm_add_epi32(x, aes_make_block(0, 0, 0, 1));
+}
+
+static inline AES_Block __fastcall aes_inc_block(AES_Block x) {
+    x = aes_reverse_byte_order_block(x);
+    x = _aes_inc_block(x);
+    x = aes_reverse_byte_order_block(x);
+    return x;
 }
 
 #ifdef __cplusplus
diff --git a/aes/include/aes/mode.h b/aes/include/aes/mode.h
index 0974281..656388f 100644
--- a/aes/include/aes/mode.h
+++ b/aes/include/aes/mode.h
@@ -19,148 +19,148 @@ typedef enum {
     AES_CTR,
 } AES_Mode;
 
-#define AES_ENCRYPT_BLOCK_ECB(prefix)                                                   \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_ECB(     \
-        AES_##prefix##_Block plaintext, const AES_##prefix##_RoundKeys* encryption_keys \
-    ) {                                                                                 \
-        assert(encryption_keys);                                                        \
-                                                                                        \
-        return aes_##prefix##_encrypt_block_(plaintext, encryption_keys);               \
+#define AES_ENCRYPT_BLOCK_ECB(version)                                       \
+    static inline AES_Block __fastcall aes##version##_encrypt_block_ECB(     \
+        AES_Block plaintext, const AES##version##_RoundKeys* encryption_keys \
+    ) {                                                                      \
+        assert(encryption_keys);                                             \
+                                                                             \
+        return aes##version##_encrypt_block_(plaintext, encryption_keys);    \
     }
 
-#define AES_DECRYPT_BLOCK_ECB(prefix)                                                    \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_ECB(      \
-        AES_##prefix##_Block ciphertext, const AES_##prefix##_RoundKeys* decryption_keys \
-    ) {                                                                                  \
-        assert(decryption_keys);                                                         \
-                                                                                         \
-        return aes_##prefix##_decrypt_block_(ciphertext, decryption_keys);               \
+#define AES_DECRYPT_BLOCK_ECB(version)                                        \
+    static inline AES_Block __fastcall aes##version##_decrypt_block_ECB(      \
+        AES_Block ciphertext, const AES##version##_RoundKeys* decryption_keys \
+    ) {                                                                       \
+        assert(decryption_keys);                                              \
+                                                                              \
+        return aes##version##_decrypt_block_(ciphertext, decryption_keys);    \
     }
 
-#define AES_ENCRYPT_BLOCK_CBC(prefix)                                                 \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_CBC(   \
-        AES_##prefix##_Block plaintext,                                               \
-        const AES_##prefix##_RoundKeys* encryption_keys,                              \
-        AES_##prefix##_Block init_vector,                                             \
-        AES_##prefix##_Block* next_init_vector                                        \
-    ) {                                                                               \
-        assert(encryption_keys);                                                      \
-        assert(next_init_vector);                                                     \
-                                                                                      \
-        return *next_init_vector = aes_##prefix##_encrypt_block_(                     \
-                   aes_##prefix##_xor_blocks(plaintext, init_vector), encryption_keys \
-               );                                                                     \
+#define AES_ENCRYPT_BLOCK_CBC(version)                                     \
+    static inline AES_Block __fastcall aes##version##_encrypt_block_CBC(   \
+        AES_Block plaintext,                                               \
+        const AES##version##_RoundKeys* encryption_keys,                   \
+        AES_Block init_vector,                                             \
+        AES_Block* next_init_vector                                        \
+    ) {                                                                    \
+        assert(encryption_keys);                                           \
+        assert(next_init_vector);                                          \
+                                                                           \
+        return *next_init_vector = aes##version##_encrypt_block_(          \
+                   aes_xor_blocks(plaintext, init_vector), encryption_keys \
+               );                                                          \
     }
 
-#define AES_DECRYPT_BLOCK_CBC(prefix)                                               \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_CBC( \
-        AES_##prefix##_Block ciphertext,                                            \
-        const AES_##prefix##_RoundKeys* decryption_keys,                            \
-        AES_##prefix##_Block init_vector,                                           \
-        AES_##prefix##_Block* next_init_vector                                      \
+#define AES_DECRYPT_BLOCK_CBC(version)                                              \
+    static inline AES_Block __fastcall aes##version##_decrypt_block_CBC(            \
+        AES_Block ciphertext,                                                       \
+        const AES##version##_RoundKeys* decryption_keys,                            \
+        AES_Block init_vector,                                                      \
+        AES_Block* next_init_vector                                                 \
     ) {                                                                             \
         assert(decryption_keys);                                                    \
         assert(next_init_vector);                                                   \
                                                                                     \
-        AES_##prefix##_Block plaintext = aes_##prefix##_xor_blocks(                 \
-            aes_##prefix##_decrypt_block_(ciphertext, decryption_keys), init_vector \
+        AES_Block plaintext = aes_xor_blocks(                                       \
+            aes##version##_decrypt_block_(ciphertext, decryption_keys), init_vector \
         );                                                                          \
         *next_init_vector = ciphertext;                                             \
         return plaintext;                                                           \
     }
 
-#define AES_ENCRYPT_BLOCK_CFB(prefix)                                                     \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_CFB(       \
-        AES_##prefix##_Block plaintext,                                                   \
-        const AES_##prefix##_RoundKeys* encryption_keys,                                  \
-        AES_##prefix##_Block init_vector,                                                 \
-        AES_##prefix##_Block* next_init_vector                                            \
+#define AES_ENCRYPT_BLOCK_CFB(version)                                                    \
+    static inline AES_Block __fastcall aes##version##_encrypt_block_CFB(                  \
+        AES_Block plaintext,                                                              \
+        const AES##version##_RoundKeys* encryption_keys,                                  \
+        AES_Block init_vector,                                                            \
+        AES_Block* next_init_vector                                                       \
     ) {                                                                                   \
         assert(encryption_keys);                                                          \
         assert(next_init_vector);                                                         \
                                                                                           \
-        return *next_init_vector = aes_##prefix##_xor_blocks(                             \
-                   aes_##prefix##_encrypt_block_(init_vector, encryption_keys), plaintext \
+        return *next_init_vector = aes_xor_blocks(                                        \
+                   aes##version##_encrypt_block_(init_vector, encryption_keys), plaintext \
                );                                                                         \
     }
 
-#define AES_DECRYPT_BLOCK_CFB(prefix)                                               \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_CFB( \
-        AES_##prefix##_Block ciphertext,                                            \
-        const AES_##prefix##_RoundKeys* encryption_keys,                            \
-        AES_##prefix##_Block init_vector,                                           \
-        AES_##prefix##_Block* next_init_vector                                      \
+#define AES_DECRYPT_BLOCK_CFB(version)                                              \
+    static inline AES_Block __fastcall aes##version##_decrypt_block_CFB(            \
+        AES_Block ciphertext,                                                       \
+        const AES##version##_RoundKeys* encryption_keys,                            \
+        AES_Block init_vector,                                                      \
+        AES_Block* next_init_vector                                                 \
     ) {                                                                             \
         assert(encryption_keys);                                                    \
         assert(next_init_vector);                                                   \
                                                                                     \
-        AES_##prefix##_Block plaintext = aes_##prefix##_xor_blocks(                 \
-            aes_##prefix##_encrypt_block_(init_vector, encryption_keys), ciphertext \
+        AES_Block plaintext = aes_xor_blocks(                                       \
+            aes##version##_encrypt_block_(init_vector, encryption_keys), ciphertext \
         );                                                                          \
         *next_init_vector = ciphertext;                                             \
         return plaintext;                                                           \
     }
 
-#define AES_ENCRYPT_BLOCK_OFB(prefix)                                                           \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_OFB(             \
-        AES_##prefix##_Block plaintext,                                                         \
-        const AES_##prefix##_RoundKeys* encryption_keys,                                        \
-        AES_##prefix##_Block init_vector,                                                       \
-        AES_##prefix##_Block* next_init_vector                                                  \
-    ) {                                                                                         \
-        assert(encryption_keys);                                                                \
-        assert(next_init_vector);                                                               \
-                                                                                                \
-        AES_##prefix##_Block tmp = aes_##prefix##_encrypt_block_(init_vector, encryption_keys); \
-        *next_init_vector = tmp;                                                                \
-        return aes_##prefix##_xor_blocks(tmp, plaintext);                                       \
+#define AES_ENCRYPT_BLOCK_OFB(version)                                               \
+    static inline AES_Block __fastcall aes##version##_encrypt_block_OFB(             \
+        AES_Block plaintext,                                                         \
+        const AES##version##_RoundKeys* encryption_keys,                             \
+        AES_Block init_vector,                                                       \
+        AES_Block* next_init_vector                                                  \
+    ) {                                                                              \
+        assert(encryption_keys);                                                     \
+        assert(next_init_vector);                                                    \
+                                                                                     \
+        AES_Block tmp = aes##version##_encrypt_block_(init_vector, encryption_keys); \
+        *next_init_vector = tmp;                                                     \
+        return aes_xor_blocks(tmp, plaintext);                                       \
     }
 
-#define AES_DECRYPT_BLOCK_OFB(prefix)                                               \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_OFB( \
-        AES_##prefix##_Block ciphertext,                                            \
-        const AES_##prefix##_RoundKeys* encryption_keys,                            \
-        AES_##prefix##_Block init_vector,                                           \
-        AES_##prefix##_Block* next_init_vector                                      \
-    ) {                                                                             \
-        assert(encryption_keys);                                                    \
-        assert(next_init_vector);                                                   \
-                                                                                    \
-        return aes_##prefix##_encrypt_block_OFB(                                    \
-            ciphertext, encryption_keys, init_vector, next_init_vector              \
-        );                                                                          \
+#define AES_DECRYPT_BLOCK_OFB(version)                                   \
+    static inline AES_Block __fastcall aes##version##_decrypt_block_OFB( \
+        AES_Block ciphertext,                                            \
+        const AES##version##_RoundKeys* encryption_keys,                 \
+        AES_Block init_vector,                                           \
+        AES_Block* next_init_vector                                      \
+    ) {                                                                  \
+        assert(encryption_keys);                                         \
+        assert(next_init_vector);                                        \
+                                                                         \
+        return aes##version##_encrypt_block_OFB(                         \
+            ciphertext, encryption_keys, init_vector, next_init_vector   \
+        );                                                               \
     }
 
-#define AES_ENCRYPT_BLOCK_CTR(prefix)                                               \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_encrypt_block_CTR( \
-        AES_##prefix##_Block plaintext,                                             \
-        const AES_##prefix##_RoundKeys* encryption_keys,                            \
-        AES_##prefix##_Block init_vector,                                           \
-        AES_##prefix##_Block* next_init_vector                                      \
-    ) {                                                                             \
-        assert(encryption_keys);                                                    \
-        assert(next_init_vector);                                                   \
-                                                                                    \
-        AES_##prefix##_Block ciphertext = aes_##prefix##_xor_blocks(                \
-            plaintext, aes_##prefix##_encrypt_block_(init_vector, encryption_keys)  \
-        );                                                                          \
-        *next_init_vector = aes_##prefix##_inc_block(init_vector);                  \
-        return ciphertext;                                                          \
+#define AES_ENCRYPT_BLOCK_CTR(version)                                             \
+    static inline AES_Block __fastcall aes##version##_encrypt_block_CTR(           \
+        AES_Block plaintext,                                                       \
+        const AES##version##_RoundKeys* encryption_keys,                           \
+        AES_Block init_vector,                                                     \
+        AES_Block* next_init_vector                                                \
+    ) {                                                                            \
+        assert(encryption_keys);                                                   \
+        assert(next_init_vector);                                                  \
+                                                                                   \
+        AES_Block ciphertext = aes_xor_blocks(                                     \
+            plaintext, aes##version##_encrypt_block_(init_vector, encryption_keys) \
+        );                                                                         \
+        *next_init_vector = aes_inc_block(init_vector);                            \
+        return ciphertext;                                                         \
     }
 
-#define AES_DECRYPT_BLOCK_CTR(prefix)                                               \
-    static inline AES_##prefix##_Block __fastcall aes_##prefix##_decrypt_block_CTR( \
-        AES_##prefix##_Block ciphertext,                                            \
-        const AES_##prefix##_RoundKeys* encryption_keys,                            \
-        AES_##prefix##_Block init_vector,                                           \
-        AES_##prefix##_Block* next_init_vector                                      \
-    ) {                                                                             \
-        assert(encryption_keys);                                                    \
-        assert(next_init_vector);                                                   \
-                                                                                    \
-        return aes_##prefix##_encrypt_block_CTR(                                    \
-            ciphertext, encryption_keys, init_vector, next_init_vector              \
-        );                                                                          \
+#define AES_DECRYPT_BLOCK_CTR(version)                                   \
+    static inline AES_Block __fastcall aes##version##_decrypt_block_CTR( \
+        AES_Block ciphertext,                                            \
+        const AES##version##_RoundKeys* encryption_keys,                 \
+        AES_Block init_vector,                                           \
+        AES_Block* next_init_vector                                      \
+    ) {                                                                  \
+        assert(encryption_keys);                                         \
+        assert(next_init_vector);                                        \
+                                                                         \
+        return aes##version##_encrypt_block_CTR(                         \
+            ciphertext, encryption_keys, init_vector, next_init_vector   \
+        );                                                               \
     }
 
 #ifdef __cplusplus