Index: uspace/lib/crypto/aes.c =================================================================== --- uspace/lib/crypto/aes.c (revision cc575ef99163b3a869a65477f280acca17c5bdd5) +++ uspace/lib/crypto/aes.c (revision 8a64320e304a59746f5987caeba986e6baf11dd7) @@ -28,7 +28,7 @@ /** @file aes.c - * + * * Implementation of AES-128 symmetric cipher cryptographic algorithm. - * + * * Based on FIPS 197. */ @@ -37,34 +37,33 @@ #include #include - #include "crypto.h" /* Number of elements in rows/columns in AES arrays. */ -#define ELEMS 4 +#define ELEMS 4 /* Number of elements (words) in cipher. */ -#define CIPHER_ELEMS 4 +#define CIPHER_ELEMS 4 /* Length of AES block. */ -#define BLOCK_LEN 16 +#define BLOCK_LEN 16 /* Number of iterations in AES algorithm. */ -#define ROUNDS 10 - -/* - * Irreducible polynomial used in AES algorithm. - * +#define ROUNDS 10 + +/** Irreducible polynomial used in AES algorithm. + * * NOTE: x^8 + x^4 + x^3 + x + 1. - */ -#define AES_IP 0x1B - -/* Precomputed values for AES sub_byte transformation. */ + * + */ +#define AES_IP 0x1b + +/** Precomputed values for AES sub_byte transformation. */ static const uint8_t sbox[BLOCK_LEN][BLOCK_LEN] = { { - 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, + 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76 }, { - 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, + 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0 }, @@ -74,139 +73,139 @@ }, { - 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, + 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75 }, { - 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, + 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84 }, { - 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, + 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf }, { - 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, + 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8 }, { - 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, + 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2 }, { - 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, + 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73 }, { - 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, + 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb }, { - 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, + 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79 }, { - 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, + 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08 }, { - 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, + 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a }, { - 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, + 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e }, { - 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, + 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf }, { - 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, + 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 } }; -/* Precomputed values for AES inv_sub_byte transformation. */ +/** Precomputed values for AES inv_sub_byte transformation. */ static uint8_t inv_sbox[BLOCK_LEN][BLOCK_LEN] = { { - 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, + 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb }, { - 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, + 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb }, { - 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, + 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e }, { - 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, + 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25 }, { - 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, + 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92 }, { - 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, + 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84 }, { - 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, + 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06 }, { - 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, + 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b }, { - 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, + 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73 }, { - 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, + 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e }, { - 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, + 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b }, { - 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, + 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4 }, { - 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, + 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f }, { - 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, + 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef }, { - 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, + 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61 }, { - 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, + 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d } }; -/* Precomputed values of powers of 2 in GF(2^8) left shifted by 24b. */ +/** Precomputed values of powers of 2 in GF(2^8) left shifted by 24b. */ static const uint32_t r_con_array[] = { - 0x01000000, 0x02000000, 0x04000000, 0x08000000, + 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, - 0x1B000000, 0x36000000 + 0x1b000000, 0x36000000 }; -/** - * Perform substitution transformation on given byte. - * +/** Perform substitution transformation on given byte. + * * @param byte Input byte. - * @param inv Flag indicating whether to use inverse table. - * + * @param inv Flag indicating whether to use inverse table. + * * @return Substituted value. + * */ static uint8_t sub_byte(uint8_t byte, bool inv) @@ -215,16 +214,15 @@ uint8_t j = byte & 0xF; - if(!inv) { + if (!inv) return sbox[i][j]; - } else { - return inv_sbox[i][j]; - } -} - -/** - * Perform substitution transformation on state table. - * + + return inv_sbox[i][j]; +} + +/** Perform substitution transformation on state table. + * * @param state State table to be modified. - * @param inv Flag indicating whether to use inverse table. + * @param inv Flag indicating whether to use inverse table. + * */ static void sub_bytes(uint8_t state[ELEMS][ELEMS], bool inv) @@ -232,6 +230,6 @@ uint8_t val; - for(size_t i = 0; i < ELEMS; i++) { - for(size_t j = 0; j < ELEMS; j++) { + for (size_t i = 0; i < ELEMS; i++) { + for (size_t j = 0; j < ELEMS; j++) { val = state[i][j]; state[i][j] = sub_byte(val, inv); @@ -240,8 +238,8 @@ } -/** - * Perform shift rows transformation on state table. - * +/** Perform shift rows transformation on state table. + * * @param state State table to be modified. + * */ static void shift_rows(uint8_t state[ELEMS][ELEMS]) @@ -249,5 +247,5 @@ uint8_t temp[ELEMS]; - for(size_t i = 1; i < ELEMS; i++) { + for (size_t i = 1; i < ELEMS; i++) { memcpy(temp, state[i], i); memcpy(state[i], state[i] + i, ELEMS - i); @@ -256,8 +254,8 @@ } -/** - * Perform inverted shift rows transformation on state table. - * +/** Perform inverted shift rows transformation on state table. + * * @param state State table to be modified. + * */ static void inv_shift_rows(uint8_t state[ELEMS][ELEMS]) @@ -265,5 +263,5 @@ uint8_t temp[ELEMS]; - for(size_t i = 1; i < ELEMS; i++) { + for (size_t i = 1; i < ELEMS; i++) { memcpy(temp, state[i], ELEMS - i); memcpy(state[i], state[i] + ELEMS - i, i); @@ -272,33 +270,37 @@ } -/** - * Multiplication in GF(2^8). - * +/** Multiplication in GF(2^8). + * * @param x First factor. * @param y Second factor. - * + * * @return Multiplication of given factors in GF(2^8). - */ -static uint8_t galois_mult(uint8_t x, uint8_t y) { - uint8_t result = 0; - uint8_t F_bitH; - - for(size_t i = 0; i < 8; i++) { - if (y & 1) + * + */ +static uint8_t galois_mult(uint8_t x, uint8_t y) +{ + uint8_t result = 0; + uint8_t f_bith; + + for (size_t i = 0; i < 8; i++) { + if (y & 1) result ^= x; - F_bitH = (x & 0x80); - x <<= 1; - if (F_bitH) - x ^= AES_IP; - y >>= 1; - } - - return result; -} - -/** - * Perform mix columns transformation on state table. - * + + f_bith = (x & 0x80); + x <<= 1; + + if (f_bith) + x ^= AES_IP; + + y >>= 1; + } + + return result; +} + +/** Perform mix columns transformation on state table. + * * @param state State table to be modified. + * */ static void mix_columns(uint8_t state[ELEMS][ELEMS]) @@ -307,32 +309,32 @@ memcpy(orig_state, state, BLOCK_LEN); - for(size_t j = 0; j < ELEMS; j++) { - state[0][j] = - galois_mult(0x2, orig_state[0][j]) ^ - galois_mult(0x3, orig_state[1][j]) ^ - orig_state[2][j] ^ - orig_state[3][j]; - state[1][j] = - orig_state[0][j] ^ - galois_mult(0x2, orig_state[1][j]) ^ - galois_mult(0x3, orig_state[2][j]) ^ - orig_state[3][j]; - state[2][j] = - orig_state[0][j] ^ - orig_state[1][j] ^ - galois_mult(0x2, orig_state[2][j]) ^ - galois_mult(0x3, orig_state[3][j]); - state[3][j] = - galois_mult(0x3, orig_state[0][j]) ^ - orig_state[1][j] ^ - orig_state[2][j] ^ - galois_mult(0x2, orig_state[3][j]); - } -} - -/** - * Perform inverted mix columns transformation on state table. - * + for (size_t j = 0; j < ELEMS; j++) { + state[0][j] = + galois_mult(0x2, orig_state[0][j]) ^ + galois_mult(0x3, orig_state[1][j]) ^ + orig_state[2][j] ^ + orig_state[3][j]; + state[1][j] = + orig_state[0][j] ^ + galois_mult(0x2, orig_state[1][j]) ^ + galois_mult(0x3, orig_state[2][j]) ^ + orig_state[3][j]; + state[2][j] = + orig_state[0][j] ^ + orig_state[1][j] ^ + galois_mult(0x2, orig_state[2][j]) ^ + galois_mult(0x3, orig_state[3][j]); + state[3][j] = + galois_mult(0x3, orig_state[0][j]) ^ + orig_state[1][j] ^ + orig_state[2][j] ^ + galois_mult(0x2, orig_state[3][j]); + } +} + +/** Perform inverted mix columns transformation on state table. + * * @param state State table to be modified. + * */ static void inv_mix_columns(uint8_t state[ELEMS][ELEMS]) @@ -341,33 +343,33 @@ memcpy(orig_state, state, BLOCK_LEN); - for(size_t j = 0; j < ELEMS; j++) { - state[0][j] = - galois_mult(0x0E, orig_state[0][j]) ^ - galois_mult(0x0B, orig_state[1][j]) ^ - galois_mult(0x0D, orig_state[2][j]) ^ - galois_mult(0x09, orig_state[3][j]); - state[1][j] = - galois_mult(0x09, orig_state[0][j]) ^ - galois_mult(0x0E, orig_state[1][j]) ^ - galois_mult(0x0B, orig_state[2][j]) ^ - galois_mult(0x0D, orig_state[3][j]); - state[2][j] = - galois_mult(0x0D, orig_state[0][j]) ^ - galois_mult(0x09, orig_state[1][j]) ^ - galois_mult(0x0E, orig_state[2][j]) ^ - galois_mult(0x0B, orig_state[3][j]); - state[3][j] = - galois_mult(0x0B, orig_state[0][j]) ^ - galois_mult(0x0D, orig_state[1][j]) ^ - galois_mult(0x09, orig_state[2][j]) ^ - galois_mult(0x0E, orig_state[3][j]); - } -} - -/** - * Perform round key transformation on state table. - * - * @param state State table to be modified. + for (size_t j = 0; j < ELEMS; j++) { + state[0][j] = + galois_mult(0x0e, orig_state[0][j]) ^ + galois_mult(0x0b, orig_state[1][j]) ^ + galois_mult(0x0d, orig_state[2][j]) ^ + galois_mult(0x09, orig_state[3][j]); + state[1][j] = + galois_mult(0x09, orig_state[0][j]) ^ + galois_mult(0x0e, orig_state[1][j]) ^ + galois_mult(0x0b, orig_state[2][j]) ^ + galois_mult(0x0d, orig_state[3][j]); + state[2][j] = + galois_mult(0x0d, orig_state[0][j]) ^ + galois_mult(0x09, orig_state[1][j]) ^ + galois_mult(0x0e, orig_state[2][j]) ^ + galois_mult(0x0b, orig_state[3][j]); + state[3][j] = + galois_mult(0x0b, orig_state[0][j]) ^ + galois_mult(0x0d, orig_state[1][j]) ^ + galois_mult(0x09, orig_state[2][j]) ^ + galois_mult(0x0e, orig_state[3][j]); + } +} + +/** Perform round key transformation on state table. + * + * @param state State table to be modified. * @param round_key Round key to be applied on state table. + * */ static void add_round_key(uint8_t state[ELEMS][ELEMS], uint32_t *round_key) @@ -375,9 +377,9 @@ uint8_t byte_round; uint8_t shift; - uint32_t mask = 0xFF; - - for(size_t j = 0; j < ELEMS; j++) { - for(size_t i = 0; i < ELEMS; i++) { - shift = 24 - 8*i; + uint32_t mask = 0xff; + + for (size_t j = 0; j < ELEMS; j++) { + for (size_t i = 0; i < ELEMS; i++) { + shift = 24 - 8 * i; byte_round = (round_key[j] & (mask << shift)) >> shift; state[i][j] = state[i][j] ^ byte_round; @@ -386,10 +388,10 @@ } -/** - * Perform substitution transformation on given word. - * +/** Perform substitution transformation on given word. + * * @param byte Input word. - * + * * @return Substituted word. + * */ static uint32_t sub_word(uint32_t word) @@ -398,17 +400,16 @@ uint8_t *start = (uint8_t *) &temp; - for(size_t i = 0; i < 4; i++) { - *(start+i) = sub_byte(*(start+i), false); - } + for (size_t i = 0; i < 4; i++) + *(start + i) = sub_byte(*(start + i), false); return temp; } -/** - * Perform left rotation by one byte on given word. - * +/** Perform left rotation by one byte on given word. + * * @param byte Input word. - * + * * @return Rotated word. + * */ static uint32_t rot_word(uint32_t word) @@ -417,9 +418,9 @@ } -/** - * Key expansion procedure for AES algorithm. - * - * @param key Input key. +/** Key expansion procedure for AES algorithm. + * + * @param key Input key. * @param key_exp Result key expansion. + * */ static void key_expansion(uint8_t *key, uint32_t *key_exp) @@ -427,18 +428,18 @@ uint32_t temp; - for(size_t i = 0; i < CIPHER_ELEMS; i++) { - key_exp[i] = - (key[4*i] << 24) + - (key[4*i+1] << 16) + - (key[4*i+2] << 8) + - (key[4*i+3]); - } - - for(size_t i = CIPHER_ELEMS; i < ELEMS * (ROUNDS + 1); i++) { - temp = key_exp[i-1]; - - if((i % CIPHER_ELEMS) == 0) { - temp = sub_word(rot_word(temp)) ^ - r_con_array[i/CIPHER_ELEMS - 1]; + for (size_t i = 0; i < CIPHER_ELEMS; i++) { + key_exp[i] = + (key[4 * i] << 24) + + (key[4 * i + 1] << 16) + + (key[4 * i + 2] << 8) + + (key[4 * i + 3]); + } + + for (size_t i = CIPHER_ELEMS; i < ELEMS * (ROUNDS + 1); i++) { + temp = key_exp[i - 1]; + + if ((i % CIPHER_ELEMS) == 0) { + temp = sub_word(rot_word(temp)) ^ + r_con_array[i / CIPHER_ELEMS - 1]; } @@ -447,32 +448,32 @@ } -/** - * AES-128 encryption algorithm. - * - * @param key Input key. - * @param input Input data sequence to be encrypted. +/** AES-128 encryption algorithm. + * + * @param key Input key. + * @param input Input data sequence to be encrypted. * @param output Encrypted data sequence. - * - * @return EINVAL when input or key not specified, ENOMEM when pointer for - * output is not allocated, otherwise EOK. + * + * @return EINVAL when input or key not specified, + * ENOMEM when pointer for output is not allocated, + * otherwise EOK. + * */ int aes_encrypt(uint8_t *key, uint8_t *input, uint8_t *output) { - if(!key || !input) + if ((!key) || (!input)) return EINVAL; - if(!output) + if (!output) return ENOMEM; /* Create key expansion. */ - uint32_t key_exp[ELEMS * (ROUNDS+1)]; + uint32_t key_exp[ELEMS * (ROUNDS + 1)]; key_expansion(key, key_exp); /* Copy input into state array. */ uint8_t state[ELEMS][ELEMS]; - for(size_t i = 0; i < ELEMS; i++) { - for(size_t j = 0; j < ELEMS; j++) { - state[i][j] = input[i + ELEMS*j]; - } + for (size_t i = 0; i < ELEMS; i++) { + for (size_t j = 0; j < ELEMS; j++) + state[i][j] = input[i + ELEMS * j]; } @@ -480,17 +481,18 @@ add_round_key(state, key_exp); - for(size_t k = 1; k <= ROUNDS; k++) { + for (size_t k = 1; k <= ROUNDS; k++) { sub_bytes(state, false); shift_rows(state); - if(k < ROUNDS) + + if (k < ROUNDS) mix_columns(state); - add_round_key(state, key_exp + k*ELEMS); + + add_round_key(state, key_exp + k * ELEMS); } /* Copy state array into output. */ - for(size_t i = 0; i < ELEMS; i++) { - for(size_t j = 0; j < ELEMS; j++) { - output[i + j*ELEMS] = state[i][j]; - } + for (size_t i = 0; i < ELEMS; i++) { + for (size_t j = 0; j < ELEMS; j++) + output[i + j * ELEMS] = state[i][j]; } @@ -498,50 +500,50 @@ } -/** - * AES-128 decryption algorithm. - * - * @param key Input key. - * @param input Input data sequence to be decrypted. +/** AES-128 decryption algorithm. + * + * @param key Input key. + * @param input Input data sequence to be decrypted. * @param output Decrypted data sequence. - * - * @return EINVAL when input or key not specified, ENOMEM when pointer for - * output is not allocated, otherwise EOK. + * + * @return EINVAL when input or key not specified, + * ENOMEM when pointer for output is not allocated, + * otherwise EOK. + * */ int aes_decrypt(uint8_t *key, uint8_t *input, uint8_t *output) { - if(!key || !input) + if ((!key) || (!input)) return EINVAL; - if(!output) + if (!output) return ENOMEM; /* Create key expansion. */ - uint32_t key_exp[ELEMS * (ROUNDS+1)]; + uint32_t key_exp[ELEMS * (ROUNDS + 1)]; key_expansion(key, key_exp); /* Copy input into state array. */ uint8_t state[ELEMS][ELEMS]; - for(size_t i = 0; i < ELEMS; i++) { - for(size_t j = 0; j < ELEMS; j++) { - state[i][j] = input[i + ELEMS*j]; - } + for (size_t i = 0; i < ELEMS; i++) { + for (size_t j = 0; j < ELEMS; j++) + state[i][j] = input[i + ELEMS * j]; } /* Processing loop. */ - add_round_key(state, key_exp + ROUNDS*ELEMS); - - for(int k = ROUNDS - 1; k >= 0; k--) { + add_round_key(state, key_exp + ROUNDS * ELEMS); + + for (int k = ROUNDS - 1; k >= 0; k--) { inv_shift_rows(state); sub_bytes(state, true); - add_round_key(state, key_exp + k*ELEMS); - if(k > 0) + add_round_key(state, key_exp + k * ELEMS); + + if (k > 0) inv_mix_columns(state); } /* Copy state array into output. */ - for(size_t i = 0; i < ELEMS; i++) { - for(size_t j = 0; j < ELEMS; j++) { - output[i + j*ELEMS] = state[i][j]; - } + for (size_t i = 0; i < ELEMS; i++) { + for (size_t j = 0; j < ELEMS; j++) + output[i + j * ELEMS] = state[i][j]; } Index: uspace/lib/crypto/crypto.c =================================================================== --- uspace/lib/crypto/crypto.c (revision cc575ef99163b3a869a65477f280acca17c5bdd5) +++ uspace/lib/crypto/crypto.c (revision 8a64320e304a59746f5987caeba986e6baf11dd7) @@ -28,5 +28,5 @@ /** @file crypto.c - * + * * Cryptographic functions library. */ @@ -37,30 +37,32 @@ #include #include - #include "crypto.h" -/* Hash function procedure definition. */ -typedef void (*HASH_FUNC)(uint32_t*, uint32_t*); - -/* Length of HMAC block. */ -#define HMAC_BLOCK_LENGTH 64 - -/* Ceiling for UINT32. */ -#define ceil_uint32(val) (((val) - (uint32_t)(val)) > 0 ? \ - (uint32_t)((val) + 1) : (uint32_t)(val)) - -/* Floor for UINT32. */ -#define floor_uint32(val) (((val) - (uint32_t)(val)) < 0 ? \ - (uint32_t)((val) - 1) : (uint32_t)(val)) - -/* Pick value at specified index from array or zero if out of bounds. */ -#define get_at(input, size, i) (i < size ? input[i] : 0) - -/* Init values used in SHA1 and MD5 functions. */ +/** Hash function procedure definition. */ +typedef void (*hash_fnc_t)(uint32_t *, uint32_t *); + +/** Length of HMAC block. */ +#define HMAC_BLOCK_LENGTH 64 + +/** Ceiling for uint32_t. */ +#define ceil_uint32(val) \ + (((val) - (uint32_t) (val)) > 0 ? \ + (uint32_t) ((val) + 1) : (uint32_t) (val)) + +/** Floor for uint32_t. */ +#define floor_uint32(val) \ + (((val) - (uint32_t) (val)) < 0 ? \ + (uint32_t) ((val) - 1) : (uint32_t) (val)) + +/** Pick value at specified index from array or zero if out of bounds. */ +#define get_at(input, size, i) \ + ((i) < (size) ? (input[i]) : 0) + +/** Init values used in SHA1 and MD5 functions. */ static const uint32_t hash_init[] = { - 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 + 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 }; -/* Shift amount array for MD5 algorithm. */ +/** Shift amount array for MD5 algorithm. */ static const uint32_t md5_shift[] = { 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, @@ -70,5 +72,5 @@ }; -/* Substitution box for MD5 algorithm. */ +/** Substitution box for MD5 algorithm. */ static const uint32_t md5_sbox[] = { 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, @@ -90,83 +92,84 @@ }; -/** - * Working procedure of MD5 cryptographic hash function. - * - * @param h Working array with interim hash parts values. +/** Working procedure of MD5 cryptographic hash function. + * + * @param h Working array with interim hash parts values. * @param sched_arr Input array with scheduled values from input string. + * */ static void md5_proc(uint32_t *h, uint32_t *sched_arr) { uint32_t f, g, temp; - uint32_t w[HASH_MD5/4]; - - memcpy(w, h, (HASH_MD5/4) * sizeof(uint32_t)); - - for(size_t k = 0; k < 64; k++) { - if(k < 16) { + uint32_t w[HASH_MD5 / 4]; + + memcpy(w, h, (HASH_MD5 / 4) * sizeof(uint32_t)); + + for (size_t k = 0; k < 64; k++) { + if (k < 16) { f = (w[1] & w[2]) | (~w[1] & w[3]); g = k; - } else if(k >= 16 && k < 32) { + } else if ((k >= 16) && (k < 32)) { f = (w[1] & w[3]) | (w[2] & ~w[3]); - g = (5*k + 1) % 16; - } else if(k >= 32 && k < 48) { + g = (5 * k + 1) % 16; + } else if ((k >= 32) && (k < 48)) { f = w[1] ^ w[2] ^ w[3]; - g = (3*k + 5) % 16; + g = (3 * k + 5) % 16; } else { f = w[2] ^ (w[1] | ~w[3]); - g = 7*k % 16; + g = 7 * k % 16; } + temp = w[3]; w[3] = w[2]; w[2] = w[1]; - w[1] += rotl_uint32(w[0] + f + md5_sbox[k] + - uint32_t_byteorder_swap(sched_arr[g]), - md5_shift[k]); + w[1] += rotl_uint32(w[0] + f + md5_sbox[k] + + uint32_t_byteorder_swap(sched_arr[g]), + md5_shift[k]); w[0] = temp; } - for(uint8_t k = 0; k < HASH_MD5/4; k++) + for (uint8_t k = 0; k < HASH_MD5 / 4; k++) h[k] += w[k]; } -/** - * Working procedure of SHA-1 cryptographic hash function. - * - * @param h Working array with interim hash parts values. +/** Working procedure of SHA-1 cryptographic hash function. + * + * @param h Working array with interim hash parts values. * @param sched_arr Input array with scheduled values from input string. + * */ static void sha1_proc(uint32_t *h, uint32_t *sched_arr) { uint32_t f, cf, temp; - uint32_t w[HASH_SHA1/4]; - - for(size_t k = 16; k < 80; k++) { + uint32_t w[HASH_SHA1 / 4]; + + for (size_t k = 16; k < 80; k++) { sched_arr[k] = rotl_uint32( - sched_arr[k-3] ^ - sched_arr[k-8] ^ - sched_arr[k-14] ^ - sched_arr[k-16], - 1); - } - - memcpy(w, h, (HASH_SHA1/4) * sizeof(uint32_t)); - - for(size_t k = 0; k < 80; k++) { - if(k < 20) { + sched_arr[k-3] ^ + sched_arr[k-8] ^ + sched_arr[k-14] ^ + sched_arr[k-16], + 1); + } + + memcpy(w, h, (HASH_SHA1 / 4) * sizeof(uint32_t)); + + for (size_t k = 0; k < 80; k++) { + if (k < 20) { f = (w[1] & w[2]) | (~w[1] & w[3]); cf = 0x5A827999; - } else if(k >= 20 && k < 40) { + } else if ((k >= 20) && (k < 40)) { f = w[1] ^ w[2] ^ w[3]; - cf = 0x6ED9EBA1; - } else if(k >= 40 && k < 60) { + cf = 0x6ed9eba1; + } else if ((k >= 40) && (k < 60)) { f = (w[1] & w[2]) | (w[1] & w[3]) | (w[2] & w[3]); - cf = 0x8F1BBCDC; + cf = 0x8f1bbcdc; } else { f = w[1] ^ w[2] ^ w[3]; - cf = 0xCA62C1D6; + cf = 0xca62c1d6; } - + temp = rotl_uint32(w[0], 5) + f + w[4] + cf + sched_arr[k]; - + w[4] = w[3]; w[3] = w[2]; @@ -175,30 +178,31 @@ w[0] = temp; } - - for(uint8_t k = 0; k < HASH_SHA1/4; k++) + + for (uint8_t k = 0; k < HASH_SHA1 / 4; k++) h[k] += w[k]; } -/** - * Create hash based on selected algorithm. - * - * @param input Input message byte sequence. +/** Create hash based on selected algorithm. + * + * @param input Input message byte sequence. * @param input_size Size of message sequence. - * @param output Result hash byte sequence. - * @param hash_sel Hash function selector. - * - * @return EINVAL when input not specified, ENOMEM when pointer for - * output hash result is not allocated, otherwise EOK. + * @param output Result hash byte sequence. + * @param hash_sel Hash function selector. + * + * @return EINVAL when input not specified, + * ENOMEM when pointer for output hash result + * is not allocated, otherwise EOK. + * */ int create_hash(uint8_t *input, size_t input_size, uint8_t *output, - hash_func_t hash_sel) -{ - if(!input) + hash_func_t hash_sel) +{ + if (!input) return EINVAL; - if(!output) + if (!output) return ENOMEM; - HASH_FUNC hash_func = (hash_sel == HASH_MD5) ? md5_proc : sha1_proc; + hash_fnc_t hash_func = (hash_sel == HASH_MD5) ? md5_proc : sha1_proc; /* Prepare scheduled input. */ @@ -207,31 +211,31 @@ work_input[input_size] = 0x80; - size_t blocks = ceil_uint32((((double)input_size + 1) / 4 + 2) / 16); + // FIXME: double? + size_t blocks = ceil_uint32((((double) input_size + 1) / 4 + 2) / 16); uint32_t work_arr[blocks * 16]; - for(size_t i = 0; i < blocks; i++) { - for(size_t j = 0; j < 16; j++) { - work_arr[i*16 + j] = - (get_at(work_input, input_size+1, i*64+j*4) << 24) | - (get_at(work_input, input_size+1, i*64+j*4+1) << 16) | - (get_at(work_input, input_size+1, i*64+j*4+2) << 8) | - get_at(work_input, input_size+1, i*64+j*4+3); + for (size_t i = 0; i < blocks; i++) { + for (size_t j = 0; j < 16; j++) { + work_arr[i*16 + j] = + (get_at(work_input, input_size + 1, i * 64 + j * 4) << 24) | + (get_at(work_input, input_size + 1, i * 64 + j * 4 + 1) << 16) | + (get_at(work_input, input_size + 1, i * 64 + j * 4 + 2) << 8) | + get_at(work_input, input_size + 1, i * 64 + j * 4 + 3); } } - uint64_t bits_size = (uint64_t)(input_size * 8); - if(hash_sel == HASH_MD5) + uint64_t bits_size = (uint64_t) (input_size * 8); + if (hash_sel == HASH_MD5) bits_size = uint64_t_byteorder_swap(bits_size); work_arr[(blocks - 1) * 16 + 14] = bits_size >> 32; - work_arr[(blocks - 1) * 16 + 15] = bits_size & 0xFFFFFFFF; + work_arr[(blocks - 1) * 16 + 15] = bits_size & 0xffffffff; /* Hash computation. */ - uint32_t h[hash_sel/4]; - memcpy(h, hash_init, (hash_sel/4) * sizeof(uint32_t)); + uint32_t h[hash_sel / 4]; + memcpy(h, hash_init, (hash_sel / 4) * sizeof(uint32_t)); uint32_t sched_arr[80]; - for(size_t i = 0; i < blocks; i++) { - for(size_t k = 0; k < 16; k++) { - sched_arr[k] = work_arr[i*16 + k]; - } + for (size_t i = 0; i < blocks; i++) { + for (size_t k = 0; k < 16; k++) + sched_arr[k] = work_arr[i * 16 + k]; hash_func(h, sched_arr); @@ -239,8 +243,9 @@ /* Copy hash parts into final result. */ - for(size_t i = 0; i < hash_sel/4; i++) { - if(hash_sel == HASH_SHA1) + for (size_t i = 0; i < hash_sel / 4; i++) { + if (hash_sel == HASH_SHA1) h[i] = uint32_t_byteorder_swap(h[i]); - memcpy(output + i*sizeof(uint32_t), &h[i], sizeof(uint32_t)); + + memcpy(output + i * sizeof(uint32_t), &h[i], sizeof(uint32_t)); } @@ -248,24 +253,25 @@ } -/** - * Hash-based message authentication code. - * - * @param key Cryptographic key sequence. +/** Hash-based message authentication code. + * + * @param key Cryptographic key sequence. * @param key_size Size of key sequence. - * @param msg Message sequence. + * @param msg Message sequence. * @param msg_size Size of message sequence. - * @param hash Output parameter for result hash. + * @param hash Output parameter for result hash. * @param hash_sel Hash function selector. - * - * @return EINVAL when key or message not specified, ENOMEM when pointer for - * output hash result is not allocated, otherwise EOK. + * + * @return EINVAL when key or message not specified, + * ENOMEM when pointer for output hash result + * is not allocated, otherwise EOK. + * */ int hmac(uint8_t *key, size_t key_size, uint8_t *msg, size_t msg_size, - uint8_t *hash, hash_func_t hash_sel) -{ - if(!key || !msg) + uint8_t *hash, hash_func_t hash_sel) +{ + if ((!key) || (!msg)) return EINVAL; - if(!hash) + if (!hash) return ENOMEM; @@ -276,12 +282,11 @@ memset(work_key, 0, HMAC_BLOCK_LENGTH); - if(key_size > HMAC_BLOCK_LENGTH) { + if(key_size > HMAC_BLOCK_LENGTH) create_hash(key, key_size, work_key, hash_sel); - } else { + else memcpy(work_key, key, key_size); - } - - for(size_t i = 0; i < HMAC_BLOCK_LENGTH; i++) { - o_key_pad[i] = work_key[i] ^ 0x5C; + + for (size_t i = 0; i < HMAC_BLOCK_LENGTH; i++) { + o_key_pad[i] = work_key[i] ^ 0x5c; i_key_pad[i] = work_key[i] ^ 0x36; } @@ -291,6 +296,6 @@ memcpy(temp_work + HMAC_BLOCK_LENGTH, msg, msg_size); - create_hash(temp_work, HMAC_BLOCK_LENGTH + msg_size, temp_hash, - hash_sel); + create_hash(temp_work, HMAC_BLOCK_LENGTH + msg_size, temp_hash, + hash_sel); memcpy(temp_work, o_key_pad, HMAC_BLOCK_LENGTH); @@ -302,25 +307,27 @@ } -/** - * Password-Based Key Derivation Function 2 as defined in RFC 2898, - * using HMAC-SHA1 with 4096 iterations and 32 bytes key result used - * for WPA/WPA2. - * - * @param pass Password sequence. +/** Password-Based Key Derivation Function 2. + * + * As defined in RFC 2898, using HMAC-SHA1 with 4096 iterations + * and 32 bytes key result used for WPA/WPA2. + * + * @param pass Password sequence. * @param pass_size Password sequence length. - * @param salt Salt sequence to be used with password. + * @param salt Salt sequence to be used with password. * @param salt_size Salt sequence length. - * @param hash Output parameter for result hash (32 byte value). - * - * @return EINVAL when pass or salt not specified, ENOMEM when pointer for - * output hash result is not allocated, otherwise EOK. - */ -int pbkdf2(uint8_t *pass, size_t pass_size, uint8_t *salt, size_t salt_size, - uint8_t *hash) -{ - if(!pass || !salt) + * @param hash Output parameter for result hash (32 byte value). + * + * @return EINVAL when pass or salt not specified, + * ENOMEM when pointer for output hash result + * is not allocated, otherwise EOK. + * + */ +int pbkdf2(uint8_t *pass, size_t pass_size, uint8_t *salt, size_t salt_size, + uint8_t *hash) +{ + if ((!pass) || (!salt)) return EINVAL; - if(!hash) + if (!hash) return ENOMEM; @@ -330,22 +337,24 @@ uint8_t temp_hmac[HASH_SHA1]; uint8_t xor_hmac[HASH_SHA1]; - uint8_t temp_hash[HASH_SHA1*2]; - - for(size_t i = 0; i < 2; i++) { - uint32_t be_i = host2uint32_t_be(i+1); + uint8_t temp_hash[HASH_SHA1 * 2]; + + for (size_t i = 0; i < 2; i++) { + uint32_t be_i = host2uint32_t_be(i + 1); + memcpy(work_salt + salt_size, &be_i, 4); hmac(pass, pass_size, work_salt, salt_size + 4, - work_hmac, HASH_SHA1); + work_hmac, HASH_SHA1); memcpy(xor_hmac, work_hmac, HASH_SHA1); - for(size_t k = 1; k < 4096; k++) { + for (size_t k = 1; k < 4096; k++) { memcpy(temp_hmac, work_hmac, HASH_SHA1); - hmac(pass, pass_size, temp_hmac, HASH_SHA1, - work_hmac, HASH_SHA1); - for(size_t t = 0; t < HASH_SHA1; t++) { + hmac(pass, pass_size, temp_hmac, HASH_SHA1, + work_hmac, HASH_SHA1); + + for (size_t t = 0; t < HASH_SHA1; t++) xor_hmac[t] ^= work_hmac[t]; - } } - memcpy(temp_hash + i*HASH_SHA1, xor_hmac, HASH_SHA1); + + memcpy(temp_hash + i * HASH_SHA1, xor_hmac, HASH_SHA1); } Index: uspace/lib/crypto/crypto.h =================================================================== --- uspace/lib/crypto/crypto.h (revision cc575ef99163b3a869a65477f280acca17c5bdd5) +++ uspace/lib/crypto/crypto.h (revision 8a64320e304a59746f5987caeba986e6baf11dd7) @@ -32,29 +32,27 @@ #include -#define AES_CIPHER_LENGTH 16 -#define PBKDF2_KEY_LENGTH 32 +#define AES_CIPHER_LENGTH 16 +#define PBKDF2_KEY_LENGTH 32 -/* Left rotation for UINT32. */ -#define rotl_uint32(val, shift) (((val) << shift) | ((val) >> (32 - shift))) +/* Left rotation for uint32_t. */ +#define rotl_uint32(val, shift) \ + (((val) << shift) | ((val) >> (32 - shift))) -/* Right rotation for UINT32. */ -#define rotr_uint32(val, shift) (((val) >> shift) | ((val) << (32 - shift))) +/* Right rotation for uint32_t. */ +#define rotr_uint32(val, shift) \ + (((val) >> shift) | ((val) << (32 - shift))) /** Hash function selector and also result hash length indicator. */ typedef enum { - HASH_MD5 = 16, - HASH_SHA1 = 20 + HASH_MD5 = 16, + HASH_SHA1 = 20 } hash_func_t; -extern int rc4(uint8_t *key, size_t key_size, uint8_t *input, size_t input_size, - size_t skip, uint8_t *output); -extern int aes_encrypt(uint8_t *key, uint8_t *input, uint8_t *output); -extern int aes_decrypt(uint8_t *key, uint8_t *input, uint8_t *output); -extern int create_hash(uint8_t *input, size_t input_size, uint8_t *output, - hash_func_t hash_sel); -extern int hmac(uint8_t *key, size_t key_size, uint8_t *msg, size_t msg_size, - uint8_t *hash, hash_func_t hash_sel); -extern int pbkdf2(uint8_t *pass, size_t pass_size, uint8_t *salt, - size_t salt_size, uint8_t *hash); +extern int rc4(uint8_t *, size_t, uint8_t *, size_t, size_t, uint8_t *); +extern int aes_encrypt(uint8_t *, uint8_t *, uint8_t *); +extern int aes_decrypt(uint8_t *, uint8_t *, uint8_t *); +extern int create_hash(uint8_t *, size_t, uint8_t *, hash_func_t); +extern int hmac(uint8_t *, size_t, uint8_t *, size_t, uint8_t *, hash_func_t); +extern int pbkdf2(uint8_t *, size_t, uint8_t *, size_t, uint8_t *); #endif Index: uspace/lib/crypto/rc4.c =================================================================== --- uspace/lib/crypto/rc4.c (revision cc575ef99163b3a869a65477f280acca17c5bdd5) +++ uspace/lib/crypto/rc4.c (revision 8a64320e304a59746f5987caeba986e6baf11dd7) @@ -28,23 +28,22 @@ /** @file rc4.c - * + * * Implementation of ARC4 symmetric cipher cryptographic algorithm. - * + * */ #include #include - #include "crypto.h" /* Sbox table size. */ -#define SBOX_SIZE 256 +#define SBOX_SIZE 256 -/** - * Swap two values in sbox. - * - * @param i First index of value in sbox to be swapped. - * @param j Second index of value in sbox to be swapped. +/** Swap two values in sbox. + * + * @param i First index of value in sbox to be swapped. + * @param j Second index of value in sbox to be swapped. * @param sbox Sbox to be modified. + * */ static void swap(size_t i, size_t j, uint8_t *sbox) @@ -55,19 +54,18 @@ } -/** - * Sbox initialization procedure. - * - * @param key Input key. +/** Sbox initialization procedure. + * + * @param key Input key. * @param key_size Size of key sequence. - * @param sbox Place for result sbox. + * @param sbox Place for result sbox. + * */ static void create_sbox(uint8_t *key, size_t key_size, uint8_t *sbox) { - for(size_t i = 0; i < SBOX_SIZE; i++) { + for (size_t i = 0; i < SBOX_SIZE; i++) sbox[i] = i; - } uint8_t j = 0; - for(size_t i = 0; i < SBOX_SIZE; i++) { + for (size_t i = 0; i < SBOX_SIZE; i++) { j = j + sbox[i] + key[i % key_size]; swap(i, j, sbox); @@ -75,24 +73,26 @@ } -/** - * ARC4 encryption/decryption algorithm. - * - * @param key Input key. - * @param key_size Size of key sequence. - * @param input Input data sequence to be processed. +/** ARC4 encryption/decryption algorithm. + * + * @param key Input key. + * @param key_size Size of key sequence. + * @param input Input data sequence to be processed. * @param input_size Size of input data sequence. - * @param skip Number of bytes to be skipped from the beginning of key stream. - * @param output Result data sequence. - * - * @return EINVAL when input or key not specified, ENOMEM when pointer for - * output is not allocated, otherwise EOK. + * @param skip Number of bytes to be skipped from + * the beginning of key stream. + * @param output Result data sequence. + * + * @return EINVAL when input or key not specified, + * ENOMEM when pointer for output is not allocated, + * otherwise EOK. + * */ -int rc4(uint8_t *key, size_t key_size, uint8_t *input, size_t input_size, - size_t skip, uint8_t *output) +int rc4(uint8_t *key, size_t key_size, uint8_t *input, size_t input_size, + size_t skip, uint8_t *output) { - if(!key || !input) + if ((!key) || (!input)) return EINVAL; - if(!output) + if (!output) return ENOMEM; @@ -102,6 +102,7 @@ /* Skip first x bytes. */ - uint8_t i = 0, j = 0; - for(size_t k = 0; k < skip; k++) { + uint8_t i = 0; + uint8_t j = 0; + for (size_t k = 0; k < skip; k++) { i = i + 1; j = j + sbox[i]; @@ -111,5 +112,5 @@ /* Processing loop. */ uint8_t val; - for(size_t k = 0; k < input_size; k++) { + for (size_t k = 0; k < input_size; k++) { i = i + 1; j = j + sbox[i];