add .clang-format

8 files changed, 454 insertions, 726 deletions

diff --git a/aes/src/aes.c b/aes/src/aes.c
index 1f7da13..a409b5e 100644
--- a/aes/src/aes.c
+++ b/aes/src/aes.c
@@ -11,11 +11,9 @@
 #include <stdio.h>
 #include <string.h>
 
-AES_StatusCode aes_AES_format_block(
-    AES_AES_BlockString* str,
-    const AES_AES_Block* block,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES_format_block(AES_AES_BlockString* str,
+                                    const AES_AES_Block* block,
+                                    AES_ErrorDetails* err_details) {
     assert(str);
     assert(block);
 
@@ -36,11 +34,9 @@ AES_StatusCode aes_AES_format_block(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES_format_block_as_matrix(
-    AES_AES_BlockMatrixString* str,
-    const AES_AES_Block* block,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES_format_block_as_matrix(AES_AES_BlockMatrixString* str,
+                                              const AES_AES_Block* block,
+                                              AES_ErrorDetails* err_details) {
     assert(str);
     assert(block);
 
@@ -54,8 +50,7 @@ AES_StatusCode aes_AES_format_block_as_matrix(
     AES_ALIGN(unsigned char, 16) bytes[4][4];
     aes_store_block128_aligned(bytes, *block);
 
-    for (int i = 0; i < 4; ++i, cursor += 3)
-    {
+    for (int i = 0; i < 4; ++i, cursor += 3) {
         for (int j = 0; j < 3; ++j, cursor += 3)
             sprintf(cursor, "%02x ", bytes[j][i]);
         sprintf(cursor, "%02x\n", bytes[3][i]);
@@ -65,10 +60,7 @@ 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_AES_Block* block, AES_ErrorDetails* err_details) {
     assert(block);
 
     if (block == NULL)
@@ -84,10 +76,8 @@ AES_StatusCode aes_AES_print_block(
     return ec;
 }
 
-AES_StatusCode aes_AES_print_block_as_matrix(
-    const AES_AES_Block* block,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES_print_block_as_matrix(const AES_AES_Block* block,
+                                             AES_ErrorDetails* err_details) {
     assert(block);
 
     if (block == NULL)
@@ -103,11 +93,9 @@ AES_StatusCode aes_AES_print_block_as_matrix(
     return ec;
 }
 
-AES_StatusCode aes_AES_parse_block(
-    AES_AES_Block* dest,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES_parse_block(AES_AES_Block* dest,
+                                   const char* src,
+                                   AES_ErrorDetails* err_details) {
     assert(dest);
     assert(src);
 
@@ -120,13 +108,12 @@ AES_StatusCode aes_AES_parse_block(
 
     AES_ALIGN(unsigned char, 16) bytes[16];
 
-    for (int i = 0; i < 16; ++i)
-    {
+    for (int i = 0; i < 16; ++i) {
         int n;
         unsigned int byte;
         if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
             return aes_error_parse(err_details, src, "a 128-bit block");
-        bytes[i] = (unsigned char) byte;
+        bytes[i] = (unsigned char)byte;
         cursor += n;
     }
 
@@ -134,11 +121,9 @@ AES_StatusCode aes_AES_parse_block(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES128_format_key(
-    AES_AES128_KeyString* str,
-    const AES_AES128_Key* key,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES128_format_key(AES_AES128_KeyString* str,
+                                     const AES_AES128_Key* key,
+                                     AES_ErrorDetails* err_details) {
     assert(str);
     assert(key);
 
@@ -159,11 +144,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_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES192_format_key(AES_AES192_KeyString* str,
+                                     const AES_AES192_Key* key,
+                                     AES_ErrorDetails* err_details) {
     assert(str);
     assert(key);
 
@@ -194,11 +177,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_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES256_format_key(AES_AES256_KeyString* str,
+                                     const AES_AES256_Key* key,
+                                     AES_ErrorDetails* err_details) {
     assert(str);
     assert(key);
 
@@ -229,17 +210,11 @@ 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 aes_AES128_print_key(const AES_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 aes_AES192_print_key(const AES_AES192_Key* key, AES_ErrorDetails* err_details) {
     assert(key);
 
     if (key == NULL)
@@ -255,10 +230,7 @@ AES_StatusCode aes_AES192_print_key(
     return ec;
 }
 
-AES_StatusCode aes_AES256_print_key(
-    const AES_AES256_Key* key,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES256_print_key(const AES_AES256_Key* key, AES_ErrorDetails* err_details) {
     assert(key);
 
     if (key == NULL)
@@ -274,19 +246,15 @@ AES_StatusCode aes_AES256_print_key(
     return ec;
 }
 
-AES_StatusCode aes_AES128_parse_key(
-    AES_AES128_Key* dest,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_AES128_parse_key(AES_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 aes_AES192_parse_key(AES_AES192_Key* dest,
+                                    const char* src,
+                                    AES_ErrorDetails* err_details) {
     assert(dest);
     assert(src);
 
@@ -300,13 +268,12 @@ AES_StatusCode aes_AES192_parse_key(
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
 
-        for (int i = 0; i < 16; ++i)
-        {
+        for (int i = 0; i < 16; ++i) {
             int n;
             unsigned int byte;
             if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
                 return aes_error_parse(err_details, src, "a 192-bit block");
-            bytes[i] = (unsigned char) byte;
+            bytes[i] = (unsigned char)byte;
             cursor += n;
         }
 
@@ -316,13 +283,12 @@ AES_StatusCode aes_AES192_parse_key(
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
 
-        for (int i = 0; i < 8; ++i)
-        {
+        for (int i = 0; i < 8; ++i) {
             int n;
             unsigned int byte;
             if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
                 return aes_error_parse(err_details, src, "a 192-bit block");
-            bytes[i] = (unsigned char) byte;
+            bytes[i] = (unsigned char)byte;
             cursor += n;
         }
 
@@ -333,11 +299,9 @@ AES_StatusCode aes_AES192_parse_key(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_AES256_parse_key(
-    AES_AES256_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) {
     assert(dest);
     assert(src);
 
@@ -351,13 +315,12 @@ AES_StatusCode aes_AES256_parse_key(
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
 
-        for (int i = 0; i < 16; ++i)
-        {
+        for (int i = 0; i < 16; ++i) {
             int n;
             unsigned int byte;
             if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
                 return aes_error_parse(err_details, src, "a 256-bit block");
-            bytes[i] = (unsigned char) byte;
+            bytes[i] = (unsigned char)byte;
             cursor += n;
         }
 
@@ -367,13 +330,12 @@ AES_StatusCode aes_AES256_parse_key(
     {
         AES_ALIGN(unsigned char, 16) bytes[16];
 
-        for (int i = 0; i < 16; ++i)
-        {
+        for (int i = 0; i < 16; ++i) {
             int n;
             unsigned int byte;
             if (sscanf(cursor, "%2x%n", &byte, &n) != 1)
                 return aes_error_parse(err_details, src, "a 256-bit block");
-            bytes[i] = (unsigned char) byte;
+            bytes[i] = (unsigned char)byte;
             cursor += n;
         }
 
diff --git a/aes/src/box.c b/aes/src/box.c
index c7e1e90..48457c9 100644
--- a/aes/src/box.c
+++ b/aes/src/box.c
@@ -10,30 +10,24 @@
 #include <stdlib.h>
 #include <string.h>
 
-static const AES_BoxAlgorithmInterface* aes_box_algorithms[] =
-{
+static const AES_BoxAlgorithmInterface* aes_box_algorithms[] = {
     &aes_box_algorithm_aes128,
     &aes_box_algorithm_aes192,
     &aes_box_algorithm_aes256,
 };
 
-AES_StatusCode aes_box_init(
-    AES_Box* box,
-    AES_Algorithm algorithm,
-    const AES_BoxKey* box_key,
-    AES_Mode mode,
-    const AES_BoxBlock* iv,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_box_init(AES_Box* box,
+                            AES_Algorithm algorithm,
+                            const AES_BoxKey* box_key,
+                            AES_Mode mode,
+                            const AES_BoxBlock* iv,
+                            AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     box->algorithm = aes_box_algorithms[algorithm];
 
     if (aes_is_error(status = box->algorithm->calc_round_keys(
-            box_key,
-            &box->encryption_keys,
-            &box->decryption_keys,
-            err_details)))
+                         box_key, &box->encryption_keys, &box->decryption_keys, err_details)))
         return status;
 
     box->mode = mode;
@@ -43,109 +37,91 @@ AES_StatusCode aes_box_init(
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_block_ecb(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
-    return box->algorithm->encrypt_block(
-        input, &box->encryption_keys, output, err_details);
+static AES_StatusCode aes_box_encrypt_block_ecb(AES_Box* box,
+                                                const AES_BoxBlock* input,
+                                                AES_BoxBlock* output,
+                                                AES_ErrorDetails* err_details) {
+    return box->algorithm->encrypt_block(input, &box->encryption_keys, output, err_details);
 }
 
-static AES_StatusCode aes_box_encrypt_block_cbc(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_encrypt_block_cbc(AES_Box* box,
+                                                const AES_BoxBlock* input,
+                                                AES_BoxBlock* output,
+                                                AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
     AES_BoxBlock xored_input = *input;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            &xored_input, &box->iv, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(&xored_input, &box->iv, err_details)))
         return status;
 
     if (aes_is_error(status = box->algorithm->encrypt_block(
-            &xored_input, &box->encryption_keys, output, err_details)))
+                         &xored_input, &box->encryption_keys, output, err_details)))
         return status;
 
     box->iv = *output;
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_block_cfb(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_encrypt_block_cfb(AES_Box* box,
+                                                const AES_BoxBlock* input,
+                                                AES_BoxBlock* output,
+                                                AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (aes_is_error(status = box->algorithm->encrypt_block(
-            &box->iv, &box->encryption_keys, output, err_details)))
+                         &box->iv, &box->encryption_keys, output, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, input, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
         return status;
 
     box->iv = *output;
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_block_ofb(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_encrypt_block_ofb(AES_Box* box,
+                                                const AES_BoxBlock* input,
+                                                AES_BoxBlock* output,
+                                                AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (aes_is_error(status = box->algorithm->encrypt_block(
-            &box->iv, &box->encryption_keys, &box->iv, err_details)))
+                         &box->iv, &box->encryption_keys, &box->iv, err_details)))
         return status;
 
     *output = box->iv;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, input, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
         return status;
 
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_block_ctr(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_encrypt_block_ctr(AES_Box* box,
+                                                const AES_BoxBlock* input,
+                                                AES_BoxBlock* output,
+                                                AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (aes_is_error(status = box->algorithm->encrypt_block(
-            &box->iv, &box->encryption_keys, output, err_details)))
+                         &box->iv, &box->encryption_keys, output, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, input, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->inc_block(
-            &box->iv, err_details)))
+    if (aes_is_error(status = box->algorithm->inc_block(&box->iv, err_details)))
         return status;
 
     return status;
 }
 
-typedef AES_StatusCode (*AES_BoxEncryptBlockInMode)(
-    AES_Box*,
-    const AES_BoxBlock*,
-    AES_BoxBlock*,
-    AES_ErrorDetails*);
+typedef AES_StatusCode (*AES_BoxEncryptBlockInMode)(AES_Box*,
+                                                    const AES_BoxBlock*,
+                                                    AES_BoxBlock*,
+                                                    AES_ErrorDetails*);
 
-static AES_BoxEncryptBlockInMode aes_box_encrypt_block_in_mode[] =
-{
+static AES_BoxEncryptBlockInMode aes_box_encrypt_block_in_mode[] = {
     &aes_box_encrypt_block_ecb,
     &aes_box_encrypt_block_cbc,
     &aes_box_encrypt_block_cfb,
@@ -153,60 +129,48 @@ static AES_BoxEncryptBlockInMode aes_box_encrypt_block_in_mode[] =
     &aes_box_encrypt_block_ctr,
 };
 
-AES_StatusCode aes_box_encrypt_block(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
-    return aes_box_encrypt_block_in_mode[box->mode](
-        box, input, output, err_details);
+AES_StatusCode aes_box_encrypt_block(AES_Box* box,
+                                     const AES_BoxBlock* input,
+                                     AES_BoxBlock* output,
+                                     AES_ErrorDetails* err_details) {
+    return aes_box_encrypt_block_in_mode[box->mode](box, input, output, err_details);
 }
 
-static AES_StatusCode aes_box_decrypt_block_ecb(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
-    return box->algorithm->decrypt_block(
-        input, &box->decryption_keys, output, err_details);
+static AES_StatusCode aes_box_decrypt_block_ecb(AES_Box* box,
+                                                const AES_BoxBlock* input,
+                                                AES_BoxBlock* output,
+                                                AES_ErrorDetails* err_details) {
+    return box->algorithm->decrypt_block(input, &box->decryption_keys, output, err_details);
 }
 
-static AES_StatusCode aes_box_decrypt_block_cbc(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_decrypt_block_cbc(AES_Box* box,
+                                                const AES_BoxBlock* input,
+                                                AES_BoxBlock* output,
+                                                AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (aes_is_error(status = box->algorithm->decrypt_block(
-            input, &box->decryption_keys, output, err_details)))
+                         input, &box->decryption_keys, output, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, &box->iv, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, &box->iv, err_details)))
         return status;
 
     box->iv = *input;
     return status;
 }
 
-static AES_StatusCode aes_box_decrypt_block_cfb(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_decrypt_block_cfb(AES_Box* box,
+                                                const AES_BoxBlock* input,
+                                                AES_BoxBlock* output,
+                                                AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (aes_is_error(status = box->algorithm->encrypt_block(
-            &box->iv, &box->encryption_keys, output, err_details)))
+                         &box->iv, &box->encryption_keys, output, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->xor_block(
-            output, input, err_details)))
+    if (aes_is_error(status = box->algorithm->xor_block(output, input, err_details)))
         return status;
 
     box->iv = *input;
@@ -215,8 +179,7 @@ static AES_StatusCode aes_box_decrypt_block_cfb(
 
 typedef AES_BoxEncryptBlockInMode AES_BoxDecryptBlockInMode;
 
-static AES_BoxDecryptBlockInMode aes_box_decrypt_block_in_mode[] =
-{
+static AES_BoxDecryptBlockInMode aes_box_decrypt_block_in_mode[] = {
     &aes_box_decrypt_block_ecb,
     &aes_box_decrypt_block_cbc,
     &aes_box_decrypt_block_cfb,
@@ -224,34 +187,26 @@ static AES_BoxDecryptBlockInMode aes_box_decrypt_block_in_mode[] =
     &aes_box_encrypt_block_ctr,
 };
 
-AES_StatusCode aes_box_decrypt_block(
-    AES_Box* box,
-    const AES_BoxBlock* input,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
-    return aes_box_decrypt_block_in_mode[box->mode](
-        box, input, output, err_details);
+AES_StatusCode aes_box_decrypt_block(AES_Box* box,
+                                     const AES_BoxBlock* input,
+                                     AES_BoxBlock* output,
+                                     AES_ErrorDetails* err_details) {
+    return aes_box_decrypt_block_in_mode[box->mode](box, input, output, err_details);
 }
 
-static AES_StatusCode aes_box_get_encrypted_buffer_size(
-    AES_Box* box,
-    size_t src_size,
-    size_t* dest_size,
-    size_t* padding_size,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_get_encrypted_buffer_size(AES_Box* box,
+                                                        size_t src_size,
+                                                        size_t* dest_size,
+                                                        size_t* padding_size,
+                                                        AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
-    switch (box->mode)
-    {
+    switch (box->mode) {
         case AES_ECB:
-        case AES_CBC:
-        {
+        case AES_CBC: {
             size_t block_size;
 
-            if (aes_is_error(status = box->algorithm->get_block_size(
-                    &block_size, err_details)))
+            if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
                 return status;
 
             *padding_size = block_size - src_size % block_size;
@@ -267,33 +222,27 @@ static AES_StatusCode aes_box_get_encrypted_buffer_size(
             return status;
 
         default:
-            return aes_error_not_implemented(
-                err_details, "unsupported mode of operation");
+            return aes_error_not_implemented(err_details, "unsupported mode of operation");
     }
 }
 
-static AES_StatusCode aes_box_encrypt_buffer_block(
-    AES_Box* box,
-    const void* src,
-    void* dest,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_encrypt_buffer_block(AES_Box* box,
+                                                   const void* src,
+                                                   void* dest,
+                                                   AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     AES_BoxBlock plaintext;
 
-    if (aes_is_error(status = box->algorithm->load_block(
-            &plaintext, src, err_details)))
+    if (aes_is_error(status = box->algorithm->load_block(&plaintext, src, err_details)))
         return status;
 
     AES_BoxBlock ciphertext;
 
-    if (aes_is_error(status = aes_box_encrypt_block(
-            box, &plaintext, &ciphertext, err_details)))
+    if (aes_is_error(status = aes_box_encrypt_block(box, &plaintext, &ciphertext, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->store_block(
-            dest, &ciphertext, err_details)))
+    if (aes_is_error(status = box->algorithm->store_block(dest, &ciphertext, err_details)))
         return status;
 
     return status;
@@ -305,14 +254,12 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block_with_padding(
     size_t src_size,
     void* dest,
     size_t padding_size,
-    AES_ErrorDetails* err_details)
-{
+    AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(
-            &block_size, err_details)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         return status;
 
     void* plaintext_buf = malloc(block_size);
@@ -322,15 +269,12 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block_with_padding(
 
     memcpy(plaintext_buf, src, src_size);
 
-    if (aes_is_error(status = aes_fill_with_padding(
-            AES_PADDING_PKCS7,
-            (char*) plaintext_buf + src_size,
-            padding_size,
-            err_details)))
+    if (aes_is_error(
+            status = aes_fill_with_padding(
+                AES_PADDING_PKCS7, (char*)plaintext_buf + src_size, padding_size, err_details)))
         goto FREE_PLAINTEXT_BUF;
 
-    if (aes_is_error(status = aes_box_encrypt_buffer_block(
-            box, plaintext_buf, dest, err_details)))
+    if (aes_is_error(status = aes_box_encrypt_buffer_block(box, plaintext_buf, dest, err_details)))
         goto FREE_PLAINTEXT_BUF;
 
 FREE_PLAINTEXT_BUF:
@@ -339,13 +283,11 @@ FREE_PLAINTEXT_BUF:
     return status;
 }
 
-static AES_StatusCode aes_box_encrypt_buffer_partial_block(
-    AES_Box* box,
-    const void* src,
-    size_t src_size,
-    void* dest,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_encrypt_buffer_partial_block(AES_Box* box,
+                                                           const void* src,
+                                                           size_t src_size,
+                                                           void* dest,
+                                                           AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (src_size == 0)
@@ -353,8 +295,7 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block(
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(
-            &block_size, err_details)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         return status;
 
     void* plaintext_buf = malloc(block_size);
@@ -367,14 +308,13 @@ static AES_StatusCode aes_box_encrypt_buffer_partial_block(
 
     void* ciphertext_buf = malloc(block_size);
 
-    if (ciphertext_buf == NULL)
-    {
+    if (ciphertext_buf == NULL) {
         status = aes_error_memory_allocation(err_details);
         goto FREE_PLAINTEXT_BUF;
     }
 
-    if (aes_is_error(status = aes_box_encrypt_buffer_block(
-            box, plaintext_buf, ciphertext_buf, err_details)))
+    if (aes_is_error(
+            status = aes_box_encrypt_buffer_block(box, plaintext_buf, ciphertext_buf, err_details)))
         goto FREE_CIPHERTEXT_BUF;
 
     memcpy(dest, ciphertext_buf, src_size);
@@ -388,14 +328,12 @@ FREE_PLAINTEXT_BUF:
     return status;
 }
 
-AES_StatusCode aes_box_encrypt_buffer(
-    AES_Box* box,
-    const void* src,
-    size_t src_size,
-    void* dest,
-    size_t* dest_size,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_box_encrypt_buffer(AES_Box* box,
+                                      const void* src,
+                                      size_t src_size,
+                                      void* dest,
+                                      size_t* dest_size,
+                                      AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (box == NULL)
@@ -406,7 +344,7 @@ AES_StatusCode aes_box_encrypt_buffer(
     size_t padding_size = 0;
 
     if (aes_is_error(status = aes_box_get_encrypted_buffer_size(
-            box, src_size, dest_size, &padding_size, err_details)))
+                         box, src_size, dest_size, &padding_size, err_details)))
         return status;
 
     if (dest == NULL)
@@ -416,20 +354,17 @@ AES_StatusCode aes_box_encrypt_buffer(
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(
-            &block_size, err_details)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         return status;
 
     const size_t src_len = src_size / block_size;
 
-    for (size_t i = 0; i < src_len; ++i)
-    {
-        if (aes_is_error(status = aes_box_encrypt_buffer_block(
-                box, src, dest, err_details)))
+    for (size_t i = 0; i < src_len; ++i) {
+        if (aes_is_error(status = aes_box_encrypt_buffer_block(box, src, dest, err_details)))
             return status;
 
-        src = (char*) src + block_size;
-        dest = (char*) dest + block_size;
+        src = (char*)src + block_size;
+        dest = (char*)dest + block_size;
     }
 
     if (padding_size == 0)
@@ -440,24 +375,19 @@ AES_StatusCode aes_box_encrypt_buffer(
             box, src, src_size % block_size, dest, padding_size, err_details);
 }
 
-static AES_StatusCode aes_box_get_decrypted_buffer_size(
-    AES_Box* box,
-    size_t src_size,
-    size_t* dest_size,
-    size_t* max_padding_size,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_get_decrypted_buffer_size(AES_Box* box,
+                                                        size_t src_size,
+                                                        size_t* dest_size,
+                                                        size_t* max_padding_size,
+                                                        AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
-    switch (box->mode)
-    {
+    switch (box->mode) {
         case AES_ECB:
-        case AES_CBC:
-        {
+        case AES_CBC: {
             size_t block_size;
 
-            if (aes_is_error(status = box->algorithm->get_block_size(
-                    &block_size, err_details)))
+            if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
                 return status;
 
             if (src_size == 0 || src_size % block_size != 0)
@@ -476,45 +406,37 @@ static AES_StatusCode aes_box_get_decrypted_buffer_size(
             return status;
 
         default:
-            return aes_error_not_implemented(
-                err_details, "unsupported mode of operation");
+            return aes_error_not_implemented(err_details, "unsupported mode of operation");
     }
 }
 
-static AES_StatusCode aes_box_decrypt_buffer_block(
-    AES_Box* box,
-    const void* src,
-    void* dest,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_decrypt_buffer_block(AES_Box* box,
+                                                   const void* src,
+                                                   void* dest,
+                                                   AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     AES_BoxBlock ciphertext;
 
-    if (aes_is_error(status = box->algorithm->load_block(
-            &ciphertext, src, err_details)))
+    if (aes_is_error(status = box->algorithm->load_block(&ciphertext, src, err_details)))
         return status;
 
     AES_BoxBlock plaintext;
 
-    if (aes_is_error(status = aes_box_decrypt_block(
-            box, &ciphertext, &plaintext, err_details)))
+    if (aes_is_error(status = aes_box_decrypt_block(box, &ciphertext, &plaintext, err_details)))
         return status;
 
-    if (aes_is_error(status = box->algorithm->store_block(
-            dest, &plaintext, err_details)))
+    if (aes_is_error(status = box->algorithm->store_block(dest, &plaintext, err_details)))
         return status;
 
     return status;
 }
 
-static AES_StatusCode aes_box_decrypt_buffer_partial_block(
-    AES_Box* box,
-    const void* src,
-    size_t src_size,
-    void* dest,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_decrypt_buffer_partial_block(AES_Box* box,
+                                                           const void* src,
+                                                           size_t src_size,
+                                                           void* dest,
+                                                           AES_ErrorDetails* err_details) {
     AES_StatusCode status = AES_SUCCESS;
 
     if (src_size == 0)
@@ -522,8 +444,7 @@ static AES_StatusCode aes_box_decrypt_buffer_partial_block(
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(
-            &block_size, err_details)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         return status;
 
     void* ciphertext_buf = malloc(block_size);
@@ -536,14 +457,13 @@ static AES_StatusCode aes_box_decrypt_buffer_partial_block(
 
     void* plaintext_buf = malloc(block_size);
 
-    if (plaintext_buf == NULL)
-    {
+    if (plaintext_buf == NULL) {
         status = aes_error_memory_allocation(err_details);
         goto FREE_CIPHERTEXT_BUF;
     }
 
-    if (aes_is_error(status = aes_box_decrypt_buffer_block(
-            box, ciphertext_buf, plaintext_buf, err_details)))
+    if (aes_is_error(
+            status = aes_box_decrypt_buffer_block(box, ciphertext_buf, plaintext_buf, err_details)))
         goto FREE_PLAINTEXT_BUF;
 
     memcpy(dest, plaintext_buf, src_size);
@@ -557,14 +477,12 @@ FREE_CIPHERTEXT_BUF:
     return status;
 }
 
-AES_StatusCode aes_box_decrypt_buffer(
-    AES_Box* box,
-    const void* src,
-    size_t src_size,
-    void* dest,
-    size_t* dest_size,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_box_decrypt_buffer(AES_Box* box,
+                                      const void* src,
+                                      size_t src_size,
+                                      void* dest,
+                                      size_t* dest_size,
+                                      AES_ErrorDetails* err_details) {
     if (box == NULL)
         return aes_error_null_argument(err_details, "box");
     if (dest_size == NULL)
@@ -574,7 +492,7 @@ AES_StatusCode aes_box_decrypt_buffer(
     size_t max_padding_size = 0;
 
     if (aes_is_error(status = aes_box_get_decrypted_buffer_size(
-            box, src_size, dest_size, &max_padding_size, err_details)))
+                         box, src_size, dest_size, &max_padding_size, err_details)))
         return status;
 
     if (dest == NULL)
@@ -584,37 +502,30 @@ AES_StatusCode aes_box_decrypt_buffer(
 
     size_t block_size;
 
-    if (aes_is_error(status = box->algorithm->get_block_size(
-            &block_size, err_details)))
+    if (aes_is_error(status = box->algorithm->get_block_size(&block_size, err_details)))
         return status;
 
     const size_t src_len = src_size / block_size;
 
-    for (size_t i = 0; i < src_len; ++i)
-    {
-        if (aes_is_error(status = aes_box_decrypt_buffer_block(
-                box, src, dest, err_details)))
+    for (size_t i = 0; i < src_len; ++i) {
+        if (aes_is_error(status = aes_box_decrypt_buffer_block(box, src, dest, err_details)))
             return status;
 
-        src = (char*) src + block_size;
-        dest = (char*) dest + block_size;
+        src = (char*)src + block_size;
+        dest = (char*)dest + block_size;
     }
 
-    if (max_padding_size == 0)
-    {
+    if (max_padding_size == 0) {
         return aes_box_decrypt_buffer_partial_block(
             box, src, src_size % block_size, dest, err_details);
-    }
-    else
-    {
+    } else {
         size_t padding_size;
 
-        if (aes_is_error(status = aes_extract_padding_size(
-                AES_PADDING_PKCS7,
-                (char*) dest - block_size,
-                block_size,
-                &padding_size,
-                err_details)))
+        if (aes_is_error(status = aes_extract_padding_size(AES_PADDING_PKCS7,
+                                                           (char*)dest - block_size,
+                                                           block_size,
+                                                           &padding_size,
+                                                           err_details)))
             return status;
 
         *dest_size -= padding_size;
@@ -622,62 +533,50 @@ AES_StatusCode aes_box_decrypt_buffer(
     }
 }
 
-AES_StatusCode aes_box_parse_block(
-    AES_BoxBlock* dest,
-    AES_Algorithm algorithm,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_box_parse_block(AES_BoxBlock* dest,
+                                   AES_Algorithm algorithm,
+                                   const char* src,
+                                   AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_box_algorithms[algorithm]->parse_block(
-        dest, src, err_details);
+    return aes_box_algorithms[algorithm]->parse_block(dest, src, err_details);
 }
 
-AES_StatusCode aes_box_parse_key(
-    AES_BoxKey* dest,
-    AES_Algorithm algorithm,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_box_parse_key(AES_BoxKey* dest,
+                                 AES_Algorithm algorithm,
+                                 const char* src,
+                                 AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_box_algorithms[algorithm]->parse_key(
-        dest, src, err_details);
+    return aes_box_algorithms[algorithm]->parse_key(dest, src, err_details);
 }
 
-AES_StatusCode aes_box_format_block(
-    AES_BoxBlockString* dest,
-    AES_Algorithm algorithm,
-    const AES_BoxBlock* src,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_box_format_block(AES_BoxBlockString* dest,
+                                    AES_Algorithm algorithm,
+                                    const AES_BoxBlock* src,
+                                    AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_box_algorithms[algorithm]->format_block(
-        dest, src, err_details);
+    return aes_box_algorithms[algorithm]->format_block(dest, src, err_details);
 }
 
-AES_StatusCode aes_box_format_key(
-    AES_BoxKeyString* dest,
-    AES_Algorithm algorithm,
-    const AES_BoxKey* src,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_box_format_key(AES_BoxKeyString* dest,
+                                  AES_Algorithm algorithm,
+                                  const AES_BoxKey* src,
+                                  AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
         return aes_error_null_argument(err_details, "src");
 
-    return aes_box_algorithms[algorithm]->format_key(
-        dest, src, err_details);
+    return aes_box_algorithms[algorithm]->format_key(dest, src, err_details);
 }
diff --git a/aes/src/box_aes.c b/aes/src/box_aes.c
index 4d08d10..7e78a2c 100644
--- a/aes/src/box_aes.c
+++ b/aes/src/box_aes.c
@@ -10,105 +10,80 @@
 #include <stdlib.h>
 #include <string.h>
 
-static AES_StatusCode aes_box_derive_params_aes128(
-    const AES_BoxKey* box_key,
-    AES_BoxEncryptionRoundKeys* encryption_keys,
-    AES_BoxDecryptionRoundKeys* decryption_keys,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_derive_params_aes128(const AES_BoxKey* box_key,
+                                                   AES_BoxEncryptionRoundKeys* encryption_keys,
+                                                   AES_BoxDecryptionRoundKeys* decryption_keys,
+                                                   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_(
-        &encryption_keys->aes128_encryption_keys,
-        &decryption_keys->aes128_decryption_keys);
+    aes_AES128_expand_key_(box_key->aes128_key.key, &encryption_keys->aes128_encryption_keys);
+    aes_AES128_derive_decryption_keys_(&encryption_keys->aes128_encryption_keys,
+                                       &decryption_keys->aes128_decryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_derive_params_aes192(
-    const AES_BoxKey* box_key,
-    AES_BoxEncryptionRoundKeys* encryption_keys,
-    AES_BoxDecryptionRoundKeys* decryption_keys,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_derive_params_aes192(const AES_BoxKey* box_key,
+                                                   AES_BoxEncryptionRoundKeys* encryption_keys,
+                                                   AES_BoxDecryptionRoundKeys* decryption_keys,
+                                                   AES_ErrorDetails* err_details) {
     AES_UNUSED_PARAMETER(err_details);
     aes_AES192_expand_key_(
-        box_key->aes192_key.lo,
-        box_key->aes192_key.hi,
-        &encryption_keys->aes192_encryption_keys);
-    aes_AES192_derive_decryption_keys_(
-        &encryption_keys->aes192_encryption_keys,
-        &decryption_keys->aes192_decryption_keys);
+        box_key->aes192_key.lo, box_key->aes192_key.hi, &encryption_keys->aes192_encryption_keys);
+    aes_AES192_derive_decryption_keys_(&encryption_keys->aes192_encryption_keys,
+                                       &decryption_keys->aes192_decryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_derive_params_aes256(
-    const AES_BoxKey* box_key,
-    AES_BoxEncryptionRoundKeys* encryption_keys,
-    AES_BoxDecryptionRoundKeys* decryption_keys,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_derive_params_aes256(const AES_BoxKey* box_key,
+                                                   AES_BoxEncryptionRoundKeys* encryption_keys,
+                                                   AES_BoxDecryptionRoundKeys* decryption_keys,
+                                                   AES_ErrorDetails* err_details) {
     AES_UNUSED_PARAMETER(err_details);
     aes_AES256_expand_key_(
-        box_key->aes256_key.lo,
-        box_key->aes256_key.hi,
-        &encryption_keys->aes256_encryption_keys);
-    aes_AES256_derive_decryption_keys_(
-        &encryption_keys->aes256_encryption_keys,
-        &decryption_keys->aes256_decryption_keys);
+        box_key->aes256_key.lo, box_key->aes256_key.hi, &encryption_keys->aes256_encryption_keys);
+    aes_AES256_derive_decryption_keys_(&encryption_keys->aes256_encryption_keys,
+                                       &decryption_keys->aes256_decryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_parse_block_aes(
-    AES_BoxBlock* dest,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_parse_block_aes(AES_BoxBlock* dest,
+                                              const char* src,
+                                              AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
     return aes_AES_parse_block(&dest->aes_block, src, err_details);
 }
 
-static AES_StatusCode aes_box_parse_key_aes128(
-    AES_BoxKey* dest,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_parse_key_aes128(AES_BoxKey* dest,
+                                               const char* src,
+                                               AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
     return aes_AES128_parse_key(&dest->aes128_key, src, err_details);
 }
 
-static AES_StatusCode aes_box_parse_key_aes192(
-    AES_BoxKey* dest,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_parse_key_aes192(AES_BoxKey* dest,
+                                               const char* src,
+                                               AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
     return aes_AES192_parse_key(&dest->aes192_key, src, err_details);
 }
 
-static AES_StatusCode aes_box_parse_key_aes256(
-    AES_BoxKey* dest,
-    const char* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_parse_key_aes256(AES_BoxKey* dest,
+                                               const char* src,
+                                               AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
     return aes_AES256_parse_key(&dest->aes256_key, src, err_details);
 }
 
-static AES_StatusCode aes_box_format_block_aes(
-    AES_BoxBlockString* dest,
-    const AES_BoxBlock* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_format_block_aes(AES_BoxBlockString* dest,
+                                               const AES_BoxBlock* src,
+                                               AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -117,11 +92,9 @@ static AES_StatusCode aes_box_format_block_aes(
     return aes_AES128_format_block(&dest->aes, &src->aes_block, err_details);
 }
 
-static AES_StatusCode aes_box_format_key_aes128(
-    AES_BoxKeyString* dest,
-    const AES_BoxKey* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_format_key_aes128(AES_BoxKeyString* dest,
+                                                const AES_BoxKey* src,
+                                                AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -130,11 +103,9 @@ static AES_StatusCode aes_box_format_key_aes128(
     return aes_AES128_format_key(&dest->aes128, &src->aes128_key, err_details);
 }
 
-static AES_StatusCode aes_box_format_key_aes192(
-    AES_BoxKeyString* dest,
-    const AES_BoxKey* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_format_key_aes192(AES_BoxKeyString* dest,
+                                                const AES_BoxKey* src,
+                                                AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -143,11 +114,9 @@ static AES_StatusCode aes_box_format_key_aes192(
     return aes_AES192_format_key(&dest->aes192, &src->aes192_key, err_details);
 }
 
-static AES_StatusCode aes_box_format_key_aes256(
-    AES_BoxKeyString* dest,
-    const AES_BoxKey* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_format_key_aes256(AES_BoxKeyString* dest,
+                                                const AES_BoxKey* src,
+                                                AES_ErrorDetails* err_details) {
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
     if (src == NULL)
@@ -156,134 +125,104 @@ static AES_StatusCode aes_box_format_key_aes256(
     return aes_AES256_format_key(&dest->aes256, &src->aes256_key, err_details);
 }
 
-static AES_StatusCode aes_box_xor_block_aes(
-    AES_BoxBlock* dest,
-    const AES_BoxBlock* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_xor_block_aes(AES_BoxBlock* dest,
+                                            const AES_BoxBlock* src,
+                                            AES_ErrorDetails* err_details) {
     AES_UNUSED_PARAMETER(err_details);
     dest->aes_block = aes_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)
-{
+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);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_get_block_size_aes(
-    size_t* block_size,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_get_block_size_aes(size_t* block_size,
+                                                 AES_ErrorDetails* err_details) {
     AES_UNUSED_PARAMETER(err_details);
     *block_size = 16;
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_store_block_aes(
-    void* dest,
-    const AES_BoxBlock* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_store_block_aes(void* dest,
+                                              const AES_BoxBlock* src,
+                                              AES_ErrorDetails* err_details) {
     AES_UNUSED_PARAMETER(err_details);
     aes_store_block128(dest, src->aes_block);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_load_block_aes(
-    AES_BoxBlock* dest,
-    const void* src,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_load_block_aes(AES_BoxBlock* dest,
+                                             const void* src,
+                                             AES_ErrorDetails* err_details) {
     AES_UNUSED_PARAMETER(err_details);
     dest->aes_block = aes_load_block128(src);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_encrypt_block_aes128(
-    const AES_BoxBlock* input,
-    const AES_BoxEncryptionRoundKeys* params,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_encrypt_block_aes128(const AES_BoxBlock* input,
+                                                   const AES_BoxEncryptionRoundKeys* params,
+                                                   AES_BoxBlock* output,
+                                                   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 =
+        aes_AES128_encrypt_block_(input->aes_block, &params->aes128_encryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_decrypt_block_aes128(
-    const AES_BoxBlock* input,
-    const AES_BoxDecryptionRoundKeys* params,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_decrypt_block_aes128(const AES_BoxBlock* input,
+                                                   const AES_BoxDecryptionRoundKeys* params,
+                                                   AES_BoxBlock* output,
+                                                   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 =
+        aes_AES128_decrypt_block_(input->aes_block, &params->aes128_decryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_encrypt_block_aes192(
-    const AES_BoxBlock* input,
-    const AES_BoxEncryptionRoundKeys* params,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_encrypt_block_aes192(const AES_BoxBlock* input,
+                                                   const AES_BoxEncryptionRoundKeys* params,
+                                                   AES_BoxBlock* output,
+                                                   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 =
+        aes_AES192_encrypt_block_(input->aes_block, &params->aes192_encryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_decrypt_block_aes192(
-    const AES_BoxBlock* input,
-    const AES_BoxDecryptionRoundKeys* params,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_decrypt_block_aes192(const AES_BoxBlock* input,
+                                                   const AES_BoxDecryptionRoundKeys* params,
+                                                   AES_BoxBlock* output,
+                                                   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 =
+        aes_AES192_decrypt_block_(input->aes_block, &params->aes192_decryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_encrypt_block_aes256(
-    const AES_BoxBlock* input,
-    const AES_BoxEncryptionRoundKeys* params,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_encrypt_block_aes256(const AES_BoxBlock* input,
+                                                   const AES_BoxEncryptionRoundKeys* params,
+                                                   AES_BoxBlock* output,
+                                                   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 =
+        aes_AES256_encrypt_block_(input->aes_block, &params->aes256_encryption_keys);
     return AES_SUCCESS;
 }
 
-static AES_StatusCode aes_box_decrypt_block_aes256(
-    const AES_BoxBlock* input,
-    const AES_BoxDecryptionRoundKeys* params,
-    AES_BoxBlock* output,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_box_decrypt_block_aes256(const AES_BoxBlock* input,
+                                                   const AES_BoxDecryptionRoundKeys* params,
+                                                   AES_BoxBlock* output,
+                                                   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 =
+        aes_AES256_decrypt_block_(input->aes_block, &params->aes256_decryption_keys);
     return AES_SUCCESS;
 }
 
-AES_BoxAlgorithmInterface aes_box_algorithm_aes128 =
-{
+AES_BoxAlgorithmInterface aes_box_algorithm_aes128 = {
     &aes_box_derive_params_aes128,
     &aes_box_parse_block_aes,
     &aes_box_parse_key_aes128,
@@ -298,8 +237,7 @@ AES_BoxAlgorithmInterface aes_box_algorithm_aes128 =
     &aes_box_load_block_aes,
 };
 
-AES_BoxAlgorithmInterface aes_box_algorithm_aes192 =
-{
+AES_BoxAlgorithmInterface aes_box_algorithm_aes192 = {
     &aes_box_derive_params_aes192,
     &aes_box_parse_block_aes,
     &aes_box_parse_key_aes192,
@@ -314,8 +252,7 @@ AES_BoxAlgorithmInterface aes_box_algorithm_aes192 =
     &aes_box_load_block_aes,
 };
 
-AES_BoxAlgorithmInterface aes_box_algorithm_aes256 =
-{
+AES_BoxAlgorithmInterface aes_box_algorithm_aes256 = {
     &aes_box_derive_params_aes256,
     &aes_box_parse_block_aes,
     &aes_box_parse_key_aes256,
diff --git a/aes/src/c/aes128.c b/aes/src/c/aes128.c
index a1bad40..6b3a96a 100644
--- a/aes/src/c/aes128.c
+++ b/aes/src/c/aes128.c
@@ -10,10 +10,8 @@
 #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_AES_Block __fastcall aes_AES128_encrypt_block_(AES_AES_Block plaintext,
+                                                   const AES_AES128_RoundKeys* encryption_keys) {
     plaintext = _mm_xor_si128(plaintext, encryption_keys->keys[0]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[1]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[2]);
@@ -27,10 +25,8 @@ 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_AES_Block __fastcall aes_AES128_decrypt_block_(AES_AES_Block ciphertext,
+                                                   const AES_AES128_RoundKeys* decryption_keys) {
     ciphertext = _mm_xor_si128(ciphertext, decryption_keys->keys[0]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[1]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[2]);
@@ -44,10 +40,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)
-{
+static AES_AES_Block __fastcall aes_aes128_expand_key_assist(AES_AES_Block prev,
+                                                             AES_AES_Block hwgen) {
     AES_AES_Block tmp = prev;
 
     tmp = _mm_slli_si128(tmp, 4);
@@ -63,27 +57,32 @@ 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)
-{
+void __fastcall aes_AES128_expand_key_(AES_AES_Block key, AES_AES128_RoundKeys* encryption_keys) {
     AES_Block128 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] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x02));
-    prev = encryption_keys->keys[3] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x04));
-    prev = encryption_keys->keys[4] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x08));
-    prev = encryption_keys->keys[5] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x10));
-    prev = encryption_keys->keys[6] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x20));
-    prev = encryption_keys->keys[7] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x40));
-    prev = encryption_keys->keys[8] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x80));
-    prev = encryption_keys->keys[9] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x1b));
-    prev = encryption_keys->keys[10] = aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x36));
+    prev = encryption_keys->keys[1] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x01));
+    prev = encryption_keys->keys[2] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x02));
+    prev = encryption_keys->keys[3] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x04));
+    prev = encryption_keys->keys[4] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x08));
+    prev = encryption_keys->keys[5] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x10));
+    prev = encryption_keys->keys[6] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x20));
+    prev = encryption_keys->keys[7] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x40));
+    prev = encryption_keys->keys[8] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x80));
+    prev = encryption_keys->keys[9] =
+        aes_aes128_expand_key_assist(prev, _mm_aeskeygenassist_si128(prev, 0x1b));
+    prev = encryption_keys->keys[10] =
+        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 aes_AES128_derive_decryption_keys_(const AES_AES128_RoundKeys* encryption_keys,
+                                                   AES_AES128_RoundKeys* decryption_keys) {
     decryption_keys->keys[0] = encryption_keys->keys[10];
     decryption_keys->keys[1] = _mm_aesimc_si128(encryption_keys->keys[9]);
     decryption_keys->keys[2] = _mm_aesimc_si128(encryption_keys->keys[8]);
diff --git a/aes/src/c/aes192.c b/aes/src/c/aes192.c
index d661b78..01f6698 100644
--- a/aes/src/c/aes192.c
+++ b/aes/src/c/aes192.c
@@ -10,10 +10,8 @@
 #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_AES_Block __fastcall aes_AES192_encrypt_block_(AES_AES_Block plaintext,
+                                                   const AES_AES192_RoundKeys* encryption_keys) {
     plaintext = _mm_xor_si128(plaintext, encryption_keys->keys[0]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[1]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[2]);
@@ -29,10 +27,8 @@ 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_AES_Block __fastcall aes_AES192_decrypt_block_(AES_AES_Block ciphertext,
+                                                   const AES_AES192_RoundKeys* decryption_keys) {
     ciphertext = _mm_xor_si128(ciphertext, decryption_keys->keys[0]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[1]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[2]);
@@ -48,11 +44,9 @@ AES_AES_Block __fastcall aes_AES192_decrypt_block_(
     return _mm_aesdeclast_si128(ciphertext, decryption_keys->keys[12]);
 }
 
-static void __fastcall aes_aes192_expand_key_assist(
-    AES_AES_Block* prev_lo,
-    AES_AES_Block* prev_hi,
-    AES_AES_Block hwgen)
-{
+static void __fastcall aes_aes192_expand_key_assist(AES_AES_Block* prev_lo,
+                                                    AES_AES_Block* prev_hi,
+                                                    AES_AES_Block hwgen) {
     AES_AES_Block tmp = *prev_lo;
 
     tmp = _mm_slli_si128(tmp, 4);
@@ -73,50 +67,54 @@ 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 aes_AES192_expand_key_(AES_AES_Block key_lo,
+                                       AES_AES_Block key_hi,
+                                       AES_AES192_RoundKeys* encryption_keys) {
     encryption_keys->keys[0] = key_lo;
     encryption_keys->keys[1] = key_hi;
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x01));
-    encryption_keys->keys[1] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[1]), _mm_castsi128_pd(key_lo), 0));
-    encryption_keys->keys[2] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
+    encryption_keys->keys[1] = _mm_castpd_si128(
+        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[1]), _mm_castsi128_pd(key_lo), 0));
+    encryption_keys->keys[2] =
+        _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x02));
     encryption_keys->keys[3] = key_lo;
     encryption_keys->keys[4] = key_hi;
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x04));
-    encryption_keys->keys[4] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[4]), _mm_castsi128_pd(key_lo), 0));
-    encryption_keys->keys[5] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
+    encryption_keys->keys[4] = _mm_castpd_si128(
+        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[4]), _mm_castsi128_pd(key_lo), 0));
+    encryption_keys->keys[5] =
+        _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x08));
     encryption_keys->keys[6] = key_lo;
     encryption_keys->keys[7] = key_hi;
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x10));
-    encryption_keys->keys[7] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[7]), _mm_castsi128_pd(key_lo), 0));
-    encryption_keys->keys[8] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
+    encryption_keys->keys[7] = _mm_castpd_si128(
+        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[7]), _mm_castsi128_pd(key_lo), 0));
+    encryption_keys->keys[8] =
+        _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x20));
     encryption_keys->keys[9] = key_lo;
     encryption_keys->keys[10] = key_hi;
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x40));
-    encryption_keys->keys[10] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[10]), _mm_castsi128_pd(key_lo), 0));
-    encryption_keys->keys[11] = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
+    encryption_keys->keys[10] = _mm_castpd_si128(
+        _mm_shuffle_pd(_mm_castsi128_pd(encryption_keys->keys[10]), _mm_castsi128_pd(key_lo), 0));
+    encryption_keys->keys[11] =
+        _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(key_lo), _mm_castsi128_pd(key_hi), 1));
 
     aes_aes192_expand_key_assist(&key_lo, &key_hi, _mm_aeskeygenassist_si128(key_hi, 0x80));
     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 aes_AES192_derive_decryption_keys_(const AES_AES192_RoundKeys* encryption_keys,
+                                                   AES_AES192_RoundKeys* decryption_keys) {
     decryption_keys->keys[0] = encryption_keys->keys[12];
     decryption_keys->keys[1] = _mm_aesimc_si128(encryption_keys->keys[11]);
     decryption_keys->keys[2] = _mm_aesimc_si128(encryption_keys->keys[10]);
diff --git a/aes/src/c/aes256.c b/aes/src/c/aes256.c
index 2190322..ea64f0f 100644
--- a/aes/src/c/aes256.c
+++ b/aes/src/c/aes256.c
@@ -10,10 +10,8 @@
 #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_AES_Block __fastcall aes_AES256_encrypt_block_(AES_AES_Block plaintext,
+                                                   const AES_AES256_RoundKeys* encryption_keys) {
     plaintext = _mm_xor_si128(plaintext, encryption_keys->keys[0]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[1]);
     plaintext = _mm_aesenc_si128(plaintext, encryption_keys->keys[2]);
@@ -31,10 +29,8 @@ 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_AES_Block __fastcall aes_AES256_decrypt_block_(AES_AES_Block ciphertext,
+                                                   const AES_AES256_RoundKeys* decryption_keys) {
     ciphertext = _mm_xor_si128(ciphertext, decryption_keys->keys[0]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[1]);
     ciphertext = _mm_aesdec_si128(ciphertext, decryption_keys->keys[2]);
@@ -52,11 +48,9 @@ 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_AES_Block __fastcall aes_aes256_expand_key_assist(AES_AES_Block* prev_lo,
+                                                             AES_AES_Block* prev_hi,
+                                                             AES_AES_Block hwgen) {
     AES_AES_Block tmp = *prev_lo;
 
     tmp = _mm_slli_si128(tmp, 4);
@@ -75,11 +69,9 @@ 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 aes_AES256_expand_key_(AES_AES_Block key_lo,
+                                       AES_AES_Block key_hi,
+                                       AES_AES256_RoundKeys* encryption_keys) {
     AES_AES_Block prev_lo, prev_hi;
     AES_AES_Block hwgen;
 
@@ -139,10 +131,8 @@ 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 aes_AES256_derive_decryption_keys_(const AES_AES256_RoundKeys* encryption_keys,
+                                                   AES_AES256_RoundKeys* decryption_keys) {
     decryption_keys->keys[0] = encryption_keys->keys[14];
     decryption_keys->keys[1] = _mm_aesimc_si128(encryption_keys->keys[13]);
     decryption_keys->keys[2] = _mm_aesimc_si128(encryption_keys->keys[12]);
diff --git a/aes/src/error.c b/aes/src/error.c
index d49c456..e498458 100644
--- a/aes/src/error.c
+++ b/aes/src/error.c
@@ -16,11 +16,10 @@
 
 #include <stdarg.h>
 
-#define snprintf c99_snprintf
+#define snprintf  c99_snprintf
 #define vsnprintf c99_vsnprintf
 
-static int c99_vsnprintf(char *dest, size_t dest_size, const char *fmt, va_list ap)
-{
+static int c99_vsnprintf(char* dest, size_t dest_size, const char* fmt, va_list ap) {
     int dest_len = -1;
 
     if (dest_size != 0)
@@ -31,8 +30,7 @@ static int c99_vsnprintf(char *dest, size_t dest_size, const char *fmt, va_list
     return dest_len;
 }
 
-static int c99_snprintf(char *dest, size_t dest_size, const char *fmt, ...)
-{
+static int c99_snprintf(char* dest, size_t dest_size, const char* fmt, ...) {
     va_list ap;
     va_start(ap, fmt);
 
@@ -44,14 +42,12 @@ static int c99_snprintf(char *dest, size_t dest_size, const char *fmt, ...)
 
 #endif
 
-static void aes_fill_string(char* dest, size_t dest_size, const char* src)
-{
+static void aes_fill_string(char* dest, size_t dest_size, const char* src) {
     strncpy(dest, src, dest_size);
     dest[dest_size - 1] = '\0';
 }
 
-static const char* aes_strerror_messages[] =
-{
+static const char* aes_strerror_messages[] = {
     "Success",
     "Invalid argument value NULL",
     "Couldn't parse",
@@ -61,16 +57,13 @@ static const char* aes_strerror_messages[] =
     "Couldn't allocate memory",
 };
 
-const char* aes_strerror(AES_StatusCode ec)
-{
+const char* aes_strerror(AES_StatusCode ec) {
     return aes_strerror_messages[ec];
 }
 
-static size_t aes_format_error_strerror(
-    const AES_ErrorDetails* err_details,\
-    char* dest,
-    size_t dest_size)
-{
+static size_t aes_format_error_strerror(const AES_ErrorDetails* err_details,
+                                        char* dest,
+                                        size_t dest_size) {
     const AES_StatusCode ec = aes_get_error_code(err_details);
     const char* const msg = aes_strerror(ec);
 
@@ -81,11 +74,9 @@ static size_t aes_format_error_strerror(
     return strlen(dest);
 }
 
-static size_t aes_format_null_argument_error(
-    const AES_ErrorDetails* err_details,
-    char* dest,
-    size_t dest_size)
-{
+static size_t aes_format_null_argument_error(const AES_ErrorDetails* err_details,
+                                             char* dest,
+                                             size_t dest_size) {
     static const char* const fmt = "Invalid argument value NULL for parameter '%s'";
     const char* const param_name = err_details->params.null_arg.param_name;
 
@@ -96,11 +87,9 @@ static size_t aes_format_null_argument_error(
     return strlen(dest);
 }
 
-static size_t aes_format_parse_error(
-    const AES_ErrorDetails* err_details,
-    char* dest,
-    size_t dest_size)
-{
+static size_t aes_format_parse_error(const AES_ErrorDetails* err_details,
+                                     char* dest,
+                                     size_t dest_size) {
     static const char* const fmt = "Couldn't parse '%s' (possibly not complete input) as %s";
     const char* const src = err_details->params.parse_error.src;
     const char* const what = err_details->params.parse_error.what;
@@ -112,11 +101,9 @@ static size_t aes_format_parse_error(
     return strlen(dest);
 }
 
-static size_t aes_format_not_implemented_error(
-    const AES_ErrorDetails* err_details,
-    char* dest,
-    size_t dest_size)
-{
+static size_t aes_format_not_implemented_error(const AES_ErrorDetails* err_details,
+                                               char* dest,
+                                               size_t dest_size) {
     static const char* const fmt = "Not implemented: %s";
     const char* const src = err_details->params.not_implemented.what;
 
@@ -129,8 +116,7 @@ static size_t aes_format_not_implemented_error(
 
 typedef size_t (*AES_ErrorFormatter)(const AES_ErrorDetails*, char*, size_t);
 
-static AES_ErrorFormatter err_formatters[] =
-{
+static AES_ErrorFormatter err_formatters[] = {
     &aes_format_error_strerror,
     &aes_format_null_argument_error,
     &aes_format_parse_error,
@@ -140,11 +126,7 @@ static AES_ErrorFormatter err_formatters[] =
     &aes_format_error_strerror,
 };
 
-size_t aes_format_error(
-    const AES_ErrorDetails* err_details,
-    char* dest,
-    size_t dest_size)
-{
+size_t aes_format_error(const AES_ErrorDetails* err_details, char* dest, size_t dest_size) {
     assert(err_details);
 
     return err_formatters[err_details->ec](err_details, dest, dest_size);
@@ -153,22 +135,17 @@ size_t aes_format_error(
 #ifdef WIN32
 #include <windows.h>
 
-static void aes_collect_call_stack(AES_ErrorDetails* err_details)
-{
-    err_details->call_stack_len = CaptureStackBackTrace(
-        1, AES_MAX_CALL_STACK_LENGTH, err_details->call_stack, NULL);
+static void aes_collect_call_stack(AES_ErrorDetails* err_details) {
+    err_details->call_stack_len =
+        CaptureStackBackTrace(1, AES_MAX_CALL_STACK_LENGTH, err_details->call_stack, NULL);
 }
 #else
-static void aes_collect_call_stack(AES_ErrorDetails* err_details)
-{
+static void aes_collect_call_stack(AES_ErrorDetails* err_details) {
     err_details->call_stack_len = 0;
 }
 #endif
 
-static AES_StatusCode aes_make_error(
-    AES_ErrorDetails* err_details,
-    AES_StatusCode ec)
-{
+static AES_StatusCode aes_make_error(AES_ErrorDetails* err_details, AES_StatusCode ec) {
     if (err_details == NULL)
         return ec;
 
@@ -178,74 +155,54 @@ static AES_StatusCode aes_make_error(
     return err_details->ec = ec;
 }
 
-AES_StatusCode aes_success(
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_success(AES_ErrorDetails* err_details) {
     return aes_make_error(err_details, AES_SUCCESS);
 }
 
-AES_StatusCode aes_error_null_argument(
-    AES_ErrorDetails* err_details,
-    const char* param_name)
-{
+AES_StatusCode aes_error_null_argument(AES_ErrorDetails* err_details, const char* param_name) {
     AES_StatusCode status = aes_make_error(err_details, AES_NULL_ARGUMENT_ERROR);
 
     if (err_details != NULL)
-        aes_fill_string(
-            err_details->params.null_arg.param_name,
-            sizeof(err_details->params.null_arg.param_name), param_name);
+        aes_fill_string(err_details->params.null_arg.param_name,
+                        sizeof(err_details->params.null_arg.param_name),
+                        param_name);
 
     return status;
 }
 
-AES_StatusCode aes_error_parse(
-    AES_ErrorDetails* err_details,
-    const char* src,
-    const char* what)
-{
+AES_StatusCode aes_error_parse(AES_ErrorDetails* err_details, const char* src, const char* what) {
     AES_StatusCode status = aes_make_error(err_details, AES_PARSE_ERROR);
 
-    if (err_details != NULL)
-    {
+    if (err_details != NULL) {
         aes_fill_string(
-            err_details->params.parse_error.src,
-            sizeof(err_details->params.parse_error.src), src);
-        aes_fill_string(
-            err_details->params.parse_error.what,
-            sizeof(err_details->params.parse_error.what), what);
+            err_details->params.parse_error.src, sizeof(err_details->params.parse_error.src), src);
+        aes_fill_string(err_details->params.parse_error.what,
+                        sizeof(err_details->params.parse_error.what),
+                        what);
     }
 
     return status;
 }
 
-AES_StatusCode aes_error_invalid_pkcs7_padding(
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_error_invalid_pkcs7_padding(AES_ErrorDetails* err_details) {
     return aes_make_error(err_details, AES_INVALID_PKCS7_PADDING_ERROR);
 }
 
-AES_StatusCode aes_error_not_implemented(
-    AES_ErrorDetails* err_details,
-    const char* what)
-{
+AES_StatusCode aes_error_not_implemented(AES_ErrorDetails* err_details, const char* what) {
     AES_StatusCode status = aes_make_error(err_details, AES_NOT_IMPLEMENTED_ERROR);
 
     if (err_details != NULL)
-        aes_fill_string(
-            err_details->params.not_implemented.what,
-            sizeof(err_details->params.not_implemented.what), what);
+        aes_fill_string(err_details->params.not_implemented.what,
+                        sizeof(err_details->params.not_implemented.what),
+                        what);
 
     return status;
 }
 
-AES_StatusCode aes_error_missing_padding(
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_error_missing_padding(AES_ErrorDetails* err_details) {
     return aes_make_error(err_details, AES_MISSING_PADDING_ERROR);
 }
 
-AES_StatusCode aes_error_memory_allocation(
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_error_memory_allocation(AES_ErrorDetails* err_details) {
     return aes_make_error(err_details, AES_MEMORY_ALLOCATION_ERROR);
 }
diff --git a/aes/src/padding.c b/aes/src/padding.c
index a161ec7..5647ea6 100644
--- a/aes/src/padding.c
+++ b/aes/src/padding.c
@@ -11,13 +11,11 @@
 #include <stdlib.h>
 #include <string.h>
 
-static AES_StatusCode aes_extract_padding_size_pkcs7(
-    const void* src,
-    size_t src_size,
-    size_t* padding_size,
-    AES_ErrorDetails* err_details)
-{
-    const unsigned char* cursor = (const unsigned char*) src + src_size - 1;
+static AES_StatusCode aes_extract_padding_size_pkcs7(const void* src,
+                                                     size_t src_size,
+                                                     size_t* padding_size,
+                                                     AES_ErrorDetails* err_details) {
+    const unsigned char* cursor = (const unsigned char*)src + src_size - 1;
     *padding_size = *cursor;
 
     for (size_t i = 1; i < *padding_size; ++i)
@@ -27,13 +25,11 @@ static AES_StatusCode aes_extract_padding_size_pkcs7(
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_extract_padding_size(
-    AES_PaddingMethod method,
-    const void* src,
-    size_t src_size,
-    size_t* padding_size,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_extract_padding_size(AES_PaddingMethod method,
+                                        const void* src,
+                                        size_t src_size,
+                                        size_t* padding_size,
+                                        AES_ErrorDetails* err_details) {
     assert(src);
     assert(padding_size);
 
@@ -42,47 +38,37 @@ AES_StatusCode aes_extract_padding_size(
     if (padding_size == NULL)
         return aes_error_null_argument(err_details, "padding_size");
 
-    switch (method)
-    {
+    switch (method) {
         case AES_PADDING_PKCS7:
-            return aes_extract_padding_size_pkcs7(
-                src, src_size, padding_size, err_details);
+            return aes_extract_padding_size_pkcs7(src, src_size, padding_size, err_details);
 
         default:
-            return aes_error_not_implemented(
-                err_details, "unsupported padding method");
+            return aes_error_not_implemented(err_details, "unsupported padding method");
     }
 }
 
-static AES_StatusCode aes_fill_with_padding_pkcs7(
-    void* dest,
-    size_t padding_size,
-    AES_ErrorDetails* err_details)
-{
+static AES_StatusCode aes_fill_with_padding_pkcs7(void* dest,
+                                                  size_t padding_size,
+                                                  AES_ErrorDetails* err_details) {
     AES_UNUSED_PARAMETER(err_details);
-    memset(dest, (int) padding_size, padding_size);
+    memset(dest, (int)padding_size, padding_size);
     return AES_SUCCESS;
 }
 
-AES_StatusCode aes_fill_with_padding(
-    AES_PaddingMethod method,
-    void* dest,
-    size_t padding_size,
-    AES_ErrorDetails* err_details)
-{
+AES_StatusCode aes_fill_with_padding(AES_PaddingMethod method,
+                                     void* dest,
+                                     size_t padding_size,
+                                     AES_ErrorDetails* err_details) {
     assert(dest);
 
     if (dest == NULL)
         return aes_error_null_argument(err_details, "dest");
 
-    switch (method)
-    {
+    switch (method) {
         case AES_PADDING_PKCS7:
-            return aes_fill_with_padding_pkcs7(
-                dest, padding_size, err_details);
+            return aes_fill_with_padding_pkcs7(dest, padding_size, err_details);
 
         default:
-            return aes_error_not_implemented(
-                err_details, "unsupported padding method");
+            return aes_error_not_implemented(err_details, "unsupported padding method");
     }
 }