remove a few levels of stupid indirection

8 files changed, 137 insertions, 158 deletions

diff --git a/aes/src/aes.c b/aes/src/aes.c
index 95b532d..e2db120 100644
--- a/aes/src/aes.c
+++ b/aes/src/aes.c
@@ -12,8 +12,8 @@
 #include <string.h>
 
 AES_StatusCode aes_AES_format_block(
-    AES_AES_BlockString* str,
-    const AES_AES_Block* block,
+    AES_BlockString* str,
+    const AES_Block* block,
     AES_ErrorDetails* err_details
 ) {
     assert(str);
@@ -27,7 +27,7 @@ AES_StatusCode aes_AES_format_block(
     char* cursor = str->str;
 
     AES_ALIGN(unsigned char, 16) bytes[16];
-    aes_store_block128_aligned(bytes, *block);
+    aes_store_block_aligned(bytes, *block);
 
     for (int i = 0; i < 16; ++i, cursor += 2)
         sprintf(cursor, "%02x", bytes[i]);
@@ -37,8 +37,8 @@ AES_StatusCode aes_AES_format_block(
 }
 
 AES_StatusCode aes_AES_format_block_as_matrix(
-    AES_AES_BlockMatrixString* str,
-    const AES_AES_Block* block,
+    AES_BlockMatrixString* str,
+    const AES_Block* block,
     AES_ErrorDetails* err_details
 ) {
     assert(str);
@@ -52,7 +52,7 @@ AES_StatusCode aes_AES_format_block_as_matrix(
     char* cursor = str->str;
 
     AES_ALIGN(unsigned char, 16) bytes[4][4];
-    aes_store_block128_aligned(bytes, *block);
+    aes_store_block_aligned(bytes, *block);
 
     for (int i = 0; i < 4; ++i, cursor += 3) {
         for (int j = 0; j < 3; ++j, cursor += 3)
@@ -64,14 +64,14 @@ AES_StatusCode aes_AES_format_block_as_matrix(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES_print_block(const AES_AES_Block* block, AES_ErrorDetails* err_details) {
+AES_StatusCode aes_AES_print_block(const AES_Block* block, AES_ErrorDetails* err_details) {
     assert(block);
 
     if (block == NULL)
         return aes_error_null_argument(err_details, "block");
 
     AES_StatusCode ec = AES_SUCCESS;
-    AES_AES_BlockString str;
+    AES_BlockString str;
 
     if (aes_is_error(ec = aes_AES_format_block(&str, block, err_details)))
         return ec;
@@ -81,7 +81,7 @@ AES_StatusCode aes_AES_print_block(const AES_AES_Block* block, AES_ErrorDetails*
 }
 
 AES_StatusCode aes_AES_print_block_as_matrix(
-    const AES_AES_Block* block,
+    const AES_Block* block,
     AES_ErrorDetails* err_details
 ) {
     assert(block);
@@ -90,7 +90,7 @@ AES_StatusCode aes_AES_print_block_as_matrix(
         return aes_error_null_argument(err_details, "block");
 
     AES_StatusCode ec = AES_SUCCESS;
-    AES_AES_BlockMatrixString str;
+    AES_BlockMatrixString str;
 
     if (aes_is_error(ec = aes_AES_format_block_as_matrix(&str, block, err_details)))
         return ec;
@@ -100,7 +100,7 @@ AES_StatusCode aes_AES_print_block_as_matrix(
 }
 
 AES_StatusCode aes_AES_parse_block(
-    AES_AES_Block* dest,
+    AES_Block* dest,
     const char* src,
     AES_ErrorDetails* err_details
 ) {
@@ -125,13 +125,13 @@ AES_StatusCode aes_AES_parse_block(
         cursor += n;
     }
 
-    *dest = aes_load_block128_aligned(bytes);
+    *dest = aes_load_block_aligned(bytes);
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES128_format_key(
-    AES_AES128_KeyString* str,
-    const AES_AES128_Key* key,
+AES_StatusCode aes128_format_key(
+    AES128_KeyString* str,
+    const AES128_Key* key,
     AES_ErrorDetails* err_details
 ) {
     assert(str);
@@ -145,7 +145,7 @@ AES_StatusCode aes_AES128_format_key(
     char* cursor = str->str;
 
     AES_ALIGN(unsigned char, 16) bytes[16];
-    aes_store_block128_aligned(bytes, key->key);
+    aes_store_block_aligned(bytes, key->key);
 
     for (int i = 0; i < 16; ++i, cursor += 2)
         sprintf(cursor, "%02x", bytes[i]);
@@ -154,9 +154,9 @@ AES_StatusCode aes_AES128_format_key(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES192_format_key(
-    AES_AES192_KeyString* str,
-    const AES_AES192_Key* key,
+AES_StatusCode aes192_format_key(
+    AES192_KeyString* str,
+    const AES192_Key* key,
     AES_ErrorDetails* err_details
 ) {
     assert(str);
@@ -171,7 +171,7 @@ AES_StatusCode aes_AES192_format_key(
 
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
-        aes_store_block128_aligned(bytes, key->lo);
+        aes_store_block_aligned(bytes, key->lo);
 
         for (int i = 0; i < 16; ++i, cursor += 2)
             sprintf(cursor, "%02x", bytes[i]);
@@ -179,7 +179,7 @@ AES_StatusCode aes_AES192_format_key(
 
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
-        aes_store_block128_aligned(bytes, key->hi);
+        aes_store_block_aligned(bytes, key->hi);
 
         for (int i = 0; i < 8; ++i, cursor += 2)
             sprintf(cursor, "%02x", bytes[i]);
@@ -189,9 +189,9 @@ AES_StatusCode aes_AES192_format_key(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES256_format_key(
-    AES_AES256_KeyString* str,
-    const AES_AES256_Key* key,
+AES_StatusCode aes256_format_key(
+    AES256_KeyString* str,
+    const AES256_Key* key,
     AES_ErrorDetails* err_details
 ) {
     assert(str);
@@ -206,7 +206,7 @@ AES_StatusCode aes_AES256_format_key(
 
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
-        aes_store_block128_aligned(bytes, key->lo);
+        aes_store_block_aligned(bytes, key->lo);
 
         for (int i = 0; i < 16; ++i, cursor += 2)
             sprintf(cursor, "%02x", bytes[i]);
@@ -214,7 +214,7 @@ AES_StatusCode aes_AES256_format_key(
 
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
-        aes_store_block128_aligned(bytes, key->hi);
+        aes_store_block_aligned(bytes, key->hi);
 
         for (int i = 0; i < 16; ++i, cursor += 2)
             sprintf(cursor, "%02x", bytes[i]);
@@ -224,55 +224,47 @@ AES_StatusCode aes_AES256_format_key(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES128_print_key(const AES_AES128_Key* key, AES_ErrorDetails* err_details) {
+AES_StatusCode aes128_print_key(const AES128_Key* key, AES_ErrorDetails* err_details) {
     return aes_AES_print_block(&key->key, err_details);
 }
 
-AES_StatusCode aes_AES192_print_key(const AES_AES192_Key* key, AES_ErrorDetails* err_details) {
+AES_StatusCode aes192_print_key(const AES192_Key* key, AES_ErrorDetails* err_details) {
     assert(key);
 
     if (key == NULL)
         return aes_error_null_argument(err_details, "key");
 
     AES_StatusCode ec = AES_SUCCESS;
-    AES_AES192_KeyString str;
+    AES192_KeyString str;
 
-    if (aes_is_error(ec = aes_AES192_format_key(&str, key, err_details)))
+    if (aes_is_error(ec = aes192_format_key(&str, key, err_details)))
         return ec;
 
     printf("%s\n", str.str);
     return ec;
 }
 
-AES_StatusCode aes_AES256_print_key(const AES_AES256_Key* key, AES_ErrorDetails* err_details) {
+AES_StatusCode aes256_print_key(const AES256_Key* key, AES_ErrorDetails* err_details) {
     assert(key);
 
     if (key == NULL)
         return aes_error_null_argument(err_details, "key");
 
     AES_StatusCode ec = AES_SUCCESS;
-    AES_AES256_KeyString str;
+    AES256_KeyString str;
 
-    if (aes_is_error(ec = aes_AES256_format_key(&str, key, err_details)))
+    if (aes_is_error(ec = aes256_format_key(&str, key, err_details)))
         return ec;
 
     printf("%s\n", str.str);
     return ec;
 }
 
-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) {
     return aes_AES_parse_block(&dest->key, src, 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) {
     assert(dest);
     assert(src);
 
@@ -295,7 +287,7 @@ AES_StatusCode aes_AES192_parse_key(
             cursor += n;
         }
 
-        dest->lo = aes_load_block128_aligned(bytes);
+        dest->lo = aes_load_block_aligned(bytes);
     }
 
     {
@@ -311,17 +303,13 @@ AES_StatusCode aes_AES192_parse_key(
         }
 
         memset(bytes + 8, 0x00, 8);
-        dest->hi = aes_load_block128_aligned(bytes);
+        dest->hi = aes_load_block_aligned(bytes);
     }
 
     return AES_SUCCESS;
 }
 
-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) {
     assert(dest);
     assert(src);
 
@@ -344,7 +332,7 @@ AES_StatusCode aes_AES256_parse_key(
             cursor += n;
         }
 
-        dest->lo = aes_load_block128_aligned(bytes);
+        dest->lo = aes_load_block_aligned(bytes);
     }
 
     {
@@ -359,7 +347,7 @@ AES_StatusCode aes_AES256_parse_key(
             cursor += n;
         }
 
-        dest->hi = aes_load_block128_aligned(bytes);
+        dest->hi = aes_load_block_aligned(bytes);
     }
 
     return AES_SUCCESS;
diff --git a/aes/src/asm/aes128.asm b/aes/src/asm/aes128.asm
index 80be57c..abf5063 100644
--- a/aes/src/asm/aes128.asm
+++ b/aes/src/asm/aes128.asm
@@ -9,7 +9,7 @@
 
 .code
 
-@aes_AES128_encrypt_block_@20 proc
+@aes128_encrypt_block_@20 proc
     pxor xmm0, [ecx]
     aesenc xmm0, [ecx + 10h]
     aesenc xmm0, [ecx + 20h]
@@ -22,9 +22,9 @@
     aesenc xmm0, [ecx + 90h]
     aesenclast xmm0, [ecx + 0A0h]
     ret
-@aes_AES128_encrypt_block_@20 endp
+@aes128_encrypt_block_@20 endp
 
-@aes_AES128_decrypt_block_@20 proc
+@aes128_decrypt_block_@20 proc
     pxor xmm0, [ecx]
     aesdec xmm0, [ecx + 10h]
     aesdec xmm0, [ecx + 20h]
@@ -37,9 +37,9 @@
     aesdec xmm0, [ecx + 90h]
     aesdeclast xmm0, [ecx + 0A0h]
     ret
-@aes_AES128_decrypt_block_@20 endp
+@aes128_decrypt_block_@20 endp
 
-@aes_AES128_expand_key_@20 proc
+@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]`.
     ;
@@ -166,9 +166,9 @@ aes128_keygen_assist:
     add ecx, 10h          ; ecx = &w[i+8]
 
     ret
-@aes_AES128_expand_key_@20 endp
+@aes128_expand_key_@20 endp
 
-@aes_AES128_derive_decryption_keys_@8 proc
+@aes128_derive_decryption_keys_@8 proc
     movdqa xmm5, [ecx]
     movdqa xmm4, [ecx + 0A0h]
     movdqa [edx], xmm4
@@ -198,6 +198,6 @@ aes128_keygen_assist:
     movdqa [edx + 50h], xmm5
 
     ret
-@aes_AES128_derive_decryption_keys_@8 endp
+@aes128_derive_decryption_keys_@8 endp
 
 end
diff --git a/aes/src/asm/aes192.asm b/aes/src/asm/aes192.asm
index 6a41243..5411419 100644
--- a/aes/src/asm/aes192.asm
+++ b/aes/src/asm/aes192.asm
@@ -9,7 +9,7 @@
 
 .code
 
-@aes_AES192_encrypt_block_@20 proc
+@aes192_encrypt_block_@20 proc
     pxor xmm0, [ecx]
     aesenc xmm0, [ecx + 10h]
     aesenc xmm0, [ecx + 20h]
@@ -24,9 +24,9 @@
     aesenc xmm0, [ecx + 0B0h]
     aesenclast xmm0, [ecx + 0C0h]
     ret
-@aes_AES192_encrypt_block_@20 endp
+@aes192_encrypt_block_@20 endp
 
-@aes_AES192_decrypt_block_@20 proc
+@aes192_decrypt_block_@20 proc
     pxor xmm0, [ecx]
     aesdec xmm0, [ecx + 10h]
     aesdec xmm0, [ecx + 20h]
@@ -41,9 +41,9 @@
     aesdec xmm0, [ecx + 0B0h]
     aesdeclast xmm0, [ecx + 0C0h]
     ret
-@aes_AES192_decrypt_block_@20 endp
+@aes192_decrypt_block_@20 endp
 
-@aes_AES192_expand_key_@36 proc
+@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]`.
     ;
@@ -207,9 +207,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
-@aes_AES192_expand_key_@36 endp
+@aes192_expand_key_@36 endp
 
-@aes_AES192_derive_decryption_keys_@8 proc
+@aes192_derive_decryption_keys_@8 proc
     movdqa xmm5, [ecx]
     movdqa xmm4, [ecx + 0C0h]
     movdqa [edx], xmm4
@@ -244,6 +244,6 @@ aes192_keygen_assist:
     movdqa [edx + 60h], xmm5
 
     ret
-@aes_AES192_derive_decryption_keys_@8 endp
+@aes192_derive_decryption_keys_@8 endp
 
 end
diff --git a/aes/src/asm/aes256.asm b/aes/src/asm/aes256.asm
index 82f5f6f..4c6c07c 100644
--- a/aes/src/asm/aes256.asm
+++ b/aes/src/asm/aes256.asm
@@ -9,7 +9,7 @@
 
 .code
 
-@aes_AES256_encrypt_block_@20 proc
+@aes256_encrypt_block_@20 proc
     pxor xmm0, [ecx]
     aesenc xmm0, [ecx + 10h]
     aesenc xmm0, [ecx + 20h]
@@ -26,9 +26,9 @@
     aesenc xmm0, [ecx + 0D0h]
     aesenclast xmm0, [ecx + 0E0h]
     ret
-@aes_AES256_encrypt_block_@20 endp
+@aes256_encrypt_block_@20 endp
 
-@aes_AES256_decrypt_block_@20 proc
+@aes256_decrypt_block_@20 proc
     pxor xmm0, [ecx]
     aesdec xmm0, [ecx + 10h]
     aesdec xmm0, [ecx + 20h]
@@ -45,9 +45,9 @@
     aesdec xmm0, [ecx + 0D0h]
     aesdeclast xmm0, [ecx + 0E0h]
     ret
-@aes_AES256_decrypt_block_@20 endp
+@aes256_decrypt_block_@20 endp
 
-@aes_AES256_expand_key_@36 proc
+@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]`.
     ;
@@ -240,9 +240,9 @@ aes256_keygen_assist:
     pxor xmm0, xmm1
 
     ret
-@aes_AES256_expand_key_@36 endp
+@aes256_expand_key_@36 endp
 
-@aes_AES256_derive_decryption_keys_@8 proc
+@aes256_derive_decryption_keys_@8 proc
     movdqa xmm5, [ecx]
     movdqa xmm4, [ecx + 0E0h]
     movdqa [edx], xmm4
@@ -282,6 +282,6 @@ aes256_keygen_assist:
     movdqa [edx + 70h], xmm5
 
     ret
-@aes_AES256_derive_decryption_keys_@8 endp
+@aes256_derive_decryption_keys_@8 endp
 
 end
diff --git a/aes/src/box_aes.c b/aes/src/box_aes.c
index 4a91e97..fb858f0 100644
--- a/aes/src/box_aes.c
+++ b/aes/src/box_aes.c
@@ -17,8 +17,8 @@ static AES_StatusCode aes_box_derive_params_aes128(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    aes_AES128_expand_key_(box_key->aes128_key.key, &encryption_keys->aes128_encryption_keys);
-    aes_AES128_derive_decryption_keys_(
+    aes128_expand_key_(box_key->aes128_key.key, &encryption_keys->aes128_encryption_keys);
+    aes128_derive_decryption_keys_(
         &encryption_keys->aes128_encryption_keys, &decryption_keys->aes128_decryption_keys
     );
     return AES_SUCCESS;
@@ -31,10 +31,10 @@ static AES_StatusCode aes_box_derive_params_aes192(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    aes_AES192_expand_key_(
+    aes192_expand_key_(
         box_key->aes192_key.lo, box_key->aes192_key.hi, &encryption_keys->aes192_encryption_keys
     );
-    aes_AES192_derive_decryption_keys_(
+    aes192_derive_decryption_keys_(
         &encryption_keys->aes192_encryption_keys, &decryption_keys->aes192_decryption_keys
     );
     return AES_SUCCESS;
@@ -47,10 +47,10 @@ static AES_StatusCode aes_box_derive_params_aes256(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    aes_AES256_expand_key_(
+    aes256_expand_key_(
         box_key->aes256_key.lo, box_key->aes256_key.hi, &encryption_keys->aes256_encryption_keys
     );
-    aes_AES256_derive_decryption_keys_(
+    aes256_derive_decryption_keys_(
         &encryption_keys->aes256_encryption_keys, &decryption_keys->aes256_decryption_keys
     );
     return AES_SUCCESS;
@@ -75,7 +75,7 @@ static AES_StatusCode aes_box_parse_key_aes128(
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
-    return aes_AES128_parse_key(&dest->aes128_key, src, err_details);
+    return aes128_parse_key(&dest->aes128_key, src, err_details);
 }
 
 static AES_StatusCode aes_box_parse_key_aes192(
@@ -86,7 +86,7 @@ static AES_StatusCode aes_box_parse_key_aes192(
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
-    return aes_AES192_parse_key(&dest->aes192_key, src, err_details);
+    return aes192_parse_key(&dest->aes192_key, src, err_details);
 }
 
 static AES_StatusCode aes_box_parse_key_aes256(
@@ -97,7 +97,7 @@ static AES_StatusCode aes_box_parse_key_aes256(
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
-    return aes_AES256_parse_key(&dest->aes256_key, src, err_details);
+    return aes256_parse_key(&dest->aes256_key, src, err_details);
 }
 
 static AES_StatusCode aes_box_format_block_aes(
@@ -110,7 +110,7 @@ static AES_StatusCode aes_box_format_block_aes(
     if (src == NULL)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_AES128_format_block(&dest->aes, &src->aes_block, err_details);
+    return aes128_format_block(&dest->aes, &src->aes_block, err_details);
 }
 
 static AES_StatusCode aes_box_format_key_aes128(
@@ -123,7 +123,7 @@ static AES_StatusCode aes_box_format_key_aes128(
     if (src == NULL)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_AES128_format_key(&dest->aes128, &src->aes128_key, err_details);
+    return aes128_format_key(&dest->aes128, &src->aes128_key, err_details);
 }
 
 static AES_StatusCode aes_box_format_key_aes192(
@@ -136,7 +136,7 @@ static AES_StatusCode aes_box_format_key_aes192(
     if (src == NULL)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_AES192_format_key(&dest->aes192, &src->aes192_key, err_details);
+    return aes192_format_key(&dest->aes192, &src->aes192_key, err_details);
 }
 
 static AES_StatusCode aes_box_format_key_aes256(
@@ -149,7 +149,7 @@ static AES_StatusCode aes_box_format_key_aes256(
     if (src == NULL)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_AES256_format_key(&dest->aes256, &src->aes256_key, err_details);
+    return aes256_format_key(&dest->aes256, &src->aes256_key, err_details);
 }
 
 static AES_StatusCode aes_box_xor_block_aes(
@@ -158,13 +158,13 @@ static AES_StatusCode aes_box_xor_block_aes(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    dest->aes_block = aes_AES_xor_blocks(dest->aes_block, src->aes_block);
+    dest->aes_block = aes_xor_blocks(dest->aes_block, src->aes_block);
     return AES_SUCCESS;
 }
 
 static AES_StatusCode aes_box_inc_block_aes(AES_BoxBlock* ctr, AES_ErrorDetails* err_details) {
     AES_UNUSED_PARAMETER(err_details);
-    ctr->aes_block = aes_AES_inc_block(ctr->aes_block);
+    ctr->aes_block = aes_inc_block(ctr->aes_block);
     return AES_SUCCESS;
 }
 
@@ -183,7 +183,7 @@ static AES_StatusCode aes_box_store_block_aes(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    aes_store_block128(dest, src->aes_block);
+    aes_store_block(dest, src->aes_block);
     return AES_SUCCESS;
 }
 
@@ -193,7 +193,7 @@ static AES_StatusCode aes_box_load_block_aes(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    dest->aes_block = aes_load_block128(src);
+    dest->aes_block = aes_load_block(src);
     return AES_SUCCESS;
 }
 
@@ -204,8 +204,7 @@ static AES_StatusCode aes_box_encrypt_block_aes128(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    output->aes_block =
-        aes_AES128_encrypt_block_(input->aes_block, &params->aes128_encryption_keys);
+    output->aes_block = aes128_encrypt_block_(input->aes_block, &params->aes128_encryption_keys);
     return AES_SUCCESS;
 }
 
@@ -216,8 +215,7 @@ static AES_StatusCode aes_box_decrypt_block_aes128(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    output->aes_block =
-        aes_AES128_decrypt_block_(input->aes_block, &params->aes128_decryption_keys);
+    output->aes_block = aes128_decrypt_block_(input->aes_block, &params->aes128_decryption_keys);
     return AES_SUCCESS;
 }
 
@@ -228,8 +226,7 @@ static AES_StatusCode aes_box_encrypt_block_aes192(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    output->aes_block =
-        aes_AES192_encrypt_block_(input->aes_block, &params->aes192_encryption_keys);
+    output->aes_block = aes192_encrypt_block_(input->aes_block, &params->aes192_encryption_keys);
     return AES_SUCCESS;
 }
 
@@ -240,8 +237,7 @@ static AES_StatusCode aes_box_decrypt_block_aes192(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    output->aes_block =
-        aes_AES192_decrypt_block_(input->aes_block, &params->aes192_decryption_keys);
+    output->aes_block = aes192_decrypt_block_(input->aes_block, &params->aes192_decryption_keys);
     return AES_SUCCESS;
 }
 
@@ -252,8 +248,7 @@ static AES_StatusCode aes_box_encrypt_block_aes256(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    output->aes_block =
-        aes_AES256_encrypt_block_(input->aes_block, &params->aes256_encryption_keys);
+    output->aes_block = aes256_encrypt_block_(input->aes_block, &params->aes256_encryption_keys);
     return AES_SUCCESS;
 }
 
@@ -264,8 +259,7 @@ static AES_StatusCode aes_box_decrypt_block_aes256(
     AES_ErrorDetails* err_details
 ) {
     AES_UNUSED_PARAMETER(err_details);
-    output->aes_block =
-        aes_AES256_decrypt_block_(input->aes_block, &params->aes256_decryption_keys);
+    output->aes_block = aes256_decrypt_block_(input->aes_block, &params->aes256_decryption_keys);
     return AES_SUCCESS;
 }
 
diff --git a/aes/src/c/aes128.c b/aes/src/c/aes128.c
index d7b7243..cf78722 100644
--- a/aes/src/c/aes128.c
+++ b/aes/src/c/aes128.c
@@ -10,9 +10,9 @@
 #include <emmintrin.h>
 #include <wmmintrin.h>
 
-AES_AES_Block __fastcall aes_AES128_encrypt_block_(
-    AES_AES_Block plaintext,
-    const AES_AES128_RoundKeys* encryption_keys
+AES_Block __fastcall aes128_encrypt_block_(
+    AES_Block plaintext,
+    const AES128_RoundKeys* encryption_keys
 ) {
     plaintext = _mm_xor_si128(plaintext, encryption_keys->keys[0]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[1]);
@@ -27,9 +27,9 @@ AES_AES_Block __fastcall aes_AES128_encrypt_block_(
     return _mm_aesenclast_si128(plaintext, encryption_keys->keys[10]);
 }
 
-AES_AES_Block __fastcall aes_AES128_decrypt_block_(
-    AES_AES_Block ciphertext,
-    const AES_AES128_RoundKeys* decryption_keys
+AES_Block __fastcall aes128_decrypt_block_(
+    AES_Block ciphertext,
+    const AES128_RoundKeys* decryption_keys
 ) {
     ciphertext = _mm_xor_si128(ciphertext, decryption_keys->keys[0]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[1]);
@@ -44,11 +44,8 @@ AES_AES_Block __fastcall aes_AES128_decrypt_block_(
     return _mm_aesdeclast_si128(ciphertext, decryption_keys->keys[10]);
 }
 
-static AES_AES_Block __fastcall aes_aes128_expand_key_assist(
-    AES_AES_Block prev,
-    AES_AES_Block hwgen
-) {
-    AES_AES_Block tmp = prev;
+static AES_Block __fastcall aes_aes128_expand_key_assist(AES_Block prev, AES_Block hwgen) {
+    AES_Block tmp = prev;
 
     tmp = _mm_slli_si128(tmp, 4);
     prev = _mm_xor_si128(prev, tmp);
@@ -63,8 +60,8 @@ static AES_AES_Block __fastcall aes_aes128_expand_key_assist(
     return prev;
 }
 
-void __fastcall aes_AES128_expand_key_(AES_AES_Block key, AES_AES128_RoundKeys* encryption_keys) {
-    AES_Block128 prev = encryption_keys->keys[0] = key;
+void __fastcall aes128_expand_key_(AES_Block key, AES128_RoundKeys* encryption_keys) {
+    AES_Block prev = encryption_keys->keys[0] = key;
     prev = encryption_keys->keys[1] =
         aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x01));
     prev = encryption_keys->keys[2] =
@@ -87,9 +84,9 @@ void __fastcall aes_AES128_expand_key_(AES_AES_Block key, AES_AES128_RoundKeys*
         aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x36));
 }
 
-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
 ) {
     decryption_keys->keys[0] = encryption_keys->keys[10];
     decryption_keys->keys[1] = _mm_aesimc_si128(encryption_keys->keys[9]);
diff --git a/aes/src/c/aes192.c b/aes/src/c/aes192.c
index 901b548..d257df7 100644
--- a/aes/src/c/aes192.c
+++ b/aes/src/c/aes192.c
@@ -10,9 +10,9 @@
 #include <emmintrin.h>
 #include <wmmintrin.h>
 
-AES_AES_Block __fastcall aes_AES192_encrypt_block_(
-    AES_AES_Block plaintext,
-    const AES_AES192_RoundKeys* encryption_keys
+AES_Block __fastcall aes192_encrypt_block_(
+    AES_Block plaintext,
+    const AES192_RoundKeys* encryption_keys
 ) {
     plaintext = _mm_xor_si128(plaintext, encryption_keys->keys[0]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[1]);
@@ -29,9 +29,9 @@ AES_AES_Block __fastcall aes_AES192_encrypt_block_(
     return _mm_aesenclast_si128(plaintext, encryption_keys->keys[12]);
 }
 
-AES_AES_Block __fastcall aes_AES192_decrypt_block_(
-    AES_AES_Block ciphertext,
-    const AES_AES192_RoundKeys* decryption_keys
+AES_Block __fastcall aes192_decrypt_block_(
+    AES_Block ciphertext,
+    const AES192_RoundKeys* decryption_keys
 ) {
     ciphertext = _mm_xor_si128(ciphertext, decryption_keys->keys[0]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[1]);
@@ -49,11 +49,11 @@ AES_AES_Block __fastcall aes_AES192_decrypt_block_(
 }
 
 static void __fastcall aes_aes192_expand_key_assist(
-    AES_AES_Block* prev_lo,
-    AES_AES_Block* prev_hi,
-    AES_AES_Block hwgen
+    AES_Block* prev_lo,
+    AES_Block* prev_hi,
+    AES_Block hwgen
 ) {
-    AES_AES_Block tmp = *prev_lo;
+    AES_Block tmp = *prev_lo;
 
     tmp = _mm_slli_si128(tmp, 4);
     *prev_lo = _mm_xor_si128(*prev_lo, tmp);
@@ -73,10 +73,10 @@ static void __fastcall aes_aes192_expand_key_assist(
     *prev_hi = _mm_xor_si128(*prev_hi, tmp);
 }
 
-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
 ) {
     encryption_keys->keys[0] = key_lo;
     encryption_keys->keys[1] = key_hi;
@@ -125,9 +125,9 @@ void __fastcall aes_AES192_expand_key_(
     encryption_keys->keys[12] = key_lo;
 }
 
-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
 ) {
     decryption_keys->keys[0] = encryption_keys->keys[12];
     decryption_keys->keys[1] = _mm_aesimc_si128(encryption_keys->keys[11]);
diff --git a/aes/src/c/aes256.c b/aes/src/c/aes256.c
index 5bce5b5..f1b5aef 100644
--- a/aes/src/c/aes256.c
+++ b/aes/src/c/aes256.c
@@ -10,9 +10,9 @@
 #include <emmintrin.h>
 #include <wmmintrin.h>
 
-AES_AES_Block __fastcall aes_AES256_encrypt_block_(
-    AES_AES_Block plaintext,
-    const AES_AES256_RoundKeys* encryption_keys
+AES_Block __fastcall aes256_encrypt_block_(
+    AES_Block plaintext,
+    const AES256_RoundKeys* encryption_keys
 ) {
     plaintext = _mm_xor_si128(plaintext, encryption_keys->keys[0]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[1]);
@@ -31,9 +31,9 @@ AES_AES_Block __fastcall aes_AES256_encrypt_block_(
     return _mm_aesenclast_si128(plaintext, encryption_keys->keys[14]);
 }
 
-AES_AES_Block __fastcall aes_AES256_decrypt_block_(
-    AES_AES_Block ciphertext,
-    const AES_AES256_RoundKeys* decryption_keys
+AES_Block __fastcall aes256_decrypt_block_(
+    AES_Block ciphertext,
+    const AES256_RoundKeys* decryption_keys
 ) {
     ciphertext = _mm_xor_si128(ciphertext, decryption_keys->keys[0]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[1]);
@@ -52,12 +52,12 @@ AES_AES_Block __fastcall aes_AES256_decrypt_block_(
     return _mm_aesdeclast_si128(ciphertext, decryption_keys->keys[14]);
 }
 
-static AES_AES_Block __fastcall aes_aes256_expand_key_assist(
-    AES_AES_Block* prev_lo,
-    AES_AES_Block* prev_hi,
-    AES_AES_Block hwgen
+static AES_Block __fastcall aes_aes256_expand_key_assist(
+    AES_Block* prev_lo,
+    AES_Block* prev_hi,
+    AES_Block hwgen
 ) {
-    AES_AES_Block tmp = *prev_lo;
+    AES_Block tmp = *prev_lo;
 
     tmp = _mm_slli_si128(tmp, 4);
     *prev_lo = _mm_xor_si128(*prev_lo, tmp);
@@ -75,13 +75,13 @@ static AES_AES_Block __fastcall aes_aes256_expand_key_assist(
     return *prev_hi;
 }
 
-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
 ) {
-    AES_AES_Block prev_lo, prev_hi;
-    AES_AES_Block hwgen;
+    AES_Block prev_lo, prev_hi;
+    AES_Block hwgen;
 
     prev_lo = encryption_keys->keys[0] = key_lo;
     prev_hi = encryption_keys->keys[1] = key_hi;
@@ -139,9 +139,9 @@ void __fastcall aes_AES256_expand_key_(
     encryption_keys->keys[14] = aes_aes256_expand_key_assist(&prev_lo, &prev_hi, hwgen);
 }
 
-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
 ) {
     decryption_keys->keys[0] = encryption_keys->keys[14];
     decryption_keys->keys[1] = _mm_aesimc_si128(encryption_keys->keys[13]);