diff options
Diffstat (limited to 'Build/source/libs/pplib/pplib-src/src/util/utilcrypt.c')
| -rw-r--r-- | Build/source/libs/pplib/pplib-src/src/util/utilcrypt.c | 1190 |
1 files changed, 0 insertions, 1190 deletions
diff --git a/Build/source/libs/pplib/pplib-src/src/util/utilcrypt.c b/Build/source/libs/pplib/pplib-src/src/util/utilcrypt.c deleted file mode 100644 index 2c77e42a4c7..00000000000 --- a/Build/source/libs/pplib/pplib-src/src/util/utilcrypt.c +++ /dev/null @@ -1,1190 +0,0 @@ - -#include "utilmem.h" -#include "utilcrypt.h" -#include "utilcryptdef.h" -#include "utilmd5.h" - -/* rc4 */ - -/* -Initializer arguments: -- state - crypt state -- map - a space for rc4 bytes map; may be left NULL in which case will be allocated -- vkey - crypt key; may be left NULL iff map is provided and properly initialized -- keylength - the length of crypt key (from 5 to 16 bytes) -*/ - -rc4_state * rc4_state_initialize (rc4_state *state, rc4_map *map, const void *vkey, size_t keylength) -{ - int i, j; - uint8_t tmp; - const uint8_t *key; - key = (const uint8_t *)vkey; - if (keylength == 0 || keylength > 256) - return NULL; - state->flags = 0; - if (map != NULL) - { - state->map = map; - } - else - { - state->map = (rc4_map *)util_malloc(sizeof(rc4_map)); - state->flags |= RC4_STATE_ALLOC; - } - - if (key != NULL) - { - for (i = 0; i < 256; ++i) - state->smap[i] = (uint8_t)i; - for (i = 0, j = 0; i < 256; ++i) - { - j = (j + state->smap[i] + key[i % keylength]) & 255; - tmp = state->smap[i]; - state->smap[i] = state->smap[j]; - state->smap[j] = tmp; - } - } - state->i = 0; - state->j = 0; - state->flush = 0; /* caller is responsible to override if necessary */ - return state; -} - -void rc4_map_save (rc4_state *state, rc4_map *map) -{ - memcpy(map, state->map, sizeof(rc4_map)); -} - -void rc4_map_restore (rc4_state *state, rc4_map *map) -{ - memcpy(state->map, map, sizeof(rc4_map)); - //state->flags = 0; - //state->flush = 0; - state->i = 0; - state->j = 0; -} - -static uint8_t rc4_next_random_byte (rc4_state *state) -{ - uint8_t tmp; - state->i = (state->i + 1) & 255; - state->j = (state->j + state->smap[state->i]) & 255; - tmp = state->smap[state->i]; - state->smap[state->i] = state->smap[state->j]; - state->smap[state->j] = tmp; - return state->smap[(state->smap[state->i] + state->smap[state->j]) & 255]; -} - -iof_status rc4_crypt_state (iof *I, iof *O, rc4_state *state) -{ - uint8_t r; - int c; - while (iof_ensure(O, 1)) - { - if ((c = iof_get(I)) < 0) - return c == IOFERR ? IOFERR : (state->flush ? IOFEOF : IOFEMPTY); - r = rc4_next_random_byte(state); - //r = r ^ ((uint8_t)c); - //iof_set(O, r); - iof_set(O, r ^ ((uint8_t)c)); - } - return IOFFULL; -} - -iof_status rc4_crypt (iof *I, iof *O, const void *key, size_t keylength) -{ - int ret; - rc4_state state; - rc4_map map; - if (rc4_state_initialize(&state, &map, key, keylength) == NULL) - return IOFERR; - state.flush = 1; - ret = rc4_crypt_state(I, O, &state); - rc4_state_close(&state); - return ret; -} - -/* -Variants that operates on c-strings can worn inplace, so output and input can be the same address. -Variant that takes rc4_state pointer expects the state properly initialized. Keep in mind -the crypt procedure modifies rc4 bytes map. All returns the size of encrypted/decrypted -data, which is the same as input data length for rc4. -*/ - -size_t rc4_crypt_data (const void *input, size_t length, void *output, const void *key, size_t keylength) -{ - rc4_state state; - rc4_map map; - if (rc4_state_initialize(&state, &map, key, keylength) == NULL) - return 0; - return rc4_crypt_state_data(&state, input, length, output); - // no need to call rc4_state_close() -} - -size_t rc4_crypt_state_data (rc4_state *state, const void *input, size_t length, void *output) -{ /* state assumed to be initialized and with the proper state of smap */ - const uint8_t *inp; - uint8_t r, *out; - size_t size; - inp = (const uint8_t *)input; - out = (uint8_t *)output; - for (size = 0; size < length; ++size, ++inp, ++out) - { - r = rc4_next_random_byte(state); - *out = r ^ *inp; - } - return length; -} - -void rc4_state_close (rc4_state *state) -{ - if (state->smap != NULL && (state->flags & RC4_STATE_ALLOC)) - { - util_free(state->smap); - state->smap = NULL; - } -} - -/* aes; parts of code excerpted from https://github.com/kokke/tiny-AES128-C */ - -static const uint8_t sbox[256] = { - 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, - 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, - 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, - 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, - 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, - 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, - 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, - 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, - 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, - 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, - 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, - 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, - 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, - 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, - 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, - 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; - -static const uint8_t rsbox[256] = -{ 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, - 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, - 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, - 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, - 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, - 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, - 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, - 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, - 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, - 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, - 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, - 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, - 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, - 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, - 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, - 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d }; - -/* -The round constant word array, rcon[i], contains the values given by -x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(2^8) -Note that i starts at 1, not 0). -*/ - -static const uint8_t rcon[255] = { - 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, - 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, - 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, - 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, - 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, - 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, - 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, - 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, - 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, - 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, - 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, - 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, - 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, - 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, - 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, - 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb }; - -/* block copying */ - -#define aes_copy_block(output, input) memcpy(output, input, 16) - -static void aes_copy_cbc (uint8_t *data, const uint8_t *input) -{ - uint8_t i; - for (i = 0; i < 16; ++i) - data[i] ^= input[i]; -} - -static void aes_copy_xor (uint8_t *data, const uint8_t *input, const uint8_t *iv) -{ - uint8_t i; - for (i = 0; i < 16; ++i) - data[i] = input[i] ^ iv[i]; -} - -/* key expansion */ - -#define AES_COLUMNS 4 // constant in aes - -static void key_expansion (aes_state *state, const uint8_t *key) -{ - uint32_t i, j; - uint8_t t[4], temp; - uint8_t *keydata, keywords, columns; - - keywords = (uint8_t)(state->keylength >> 2); - keydata = (uint8_t *)state->keyblock; - - /* the first round key is the key itself */ - for(i = 0; i < keywords; ++i) - { - keydata[(i * 4) + 0] = key[(i * 4) + 0]; - keydata[(i * 4) + 1] = key[(i * 4) + 1]; - keydata[(i * 4) + 2] = key[(i * 4) + 2]; - keydata[(i * 4) + 3] = key[(i * 4) + 3]; - } - - /* others derived from the first */ - for(columns = AES_COLUMNS * (state->rounds + 1); i < columns; ++i) - { - for(j = 0; j < 4; ++j) - t[j] = keydata[(i - 1) * 4 + j]; - if (i % keywords == 0) - { - /* rotate the 4 bytes in a word to the left once; [a0,a1,a2,a3] becomes [a1,a2,a3,a0] */ - temp = t[0]; - t[0] = t[1]; - t[1] = t[2]; - t[2] = t[3]; - t[3] = temp; - - /* take a four-byte input word and apply the S-box to each of the four bytes to produce an output word */ - t[0] = sbox[t[0]]; - t[1] = sbox[t[1]]; - t[2] = sbox[t[2]]; - t[3] = sbox[t[3]]; - - t[0] = t[0] ^ rcon[i / keywords]; - } - else if (keywords > 6 && i % keywords == 4) - { - t[0] = sbox[t[0]]; - t[1] = sbox[t[1]]; - t[2] = sbox[t[2]]; - t[3] = sbox[t[3]]; - } - keydata[i * 4 + 0] = keydata[(i - keywords) * 4 + 0] ^ t[0]; - keydata[i * 4 + 1] = keydata[(i - keywords) * 4 + 1] ^ t[1]; - keydata[i * 4 + 2] = keydata[(i - keywords) * 4 + 2] ^ t[2]; - keydata[i * 4 + 3] = keydata[(i - keywords) * 4 + 3] ^ t[3]; - } - -} - -/* -An original implementation uses no private buffers except a keyblock. We need private buffers to -keep a CBC vector between calls and to be able to read input data not necessarily in 16-bytes blocks. -Encrypter would actually require only one such buffer, as CBC vector is applied on input data before -the actual cipher procedure. And CBC for the next chunk is simply the output from the previous. -Decrypter, however, applies the cipher first, then applies CBC to the output with a buffered init -vector, and the vector for the next call is the row input before cipher. Hence we need two 16-bytes -buffers for decrypter. -*/ - -/* -aes_state * aes_state_initialize_ecb (aes_state *State, uint8_t *keyblock, const uint8_t *key) -{ - state->flags = 0; - - state->flags |= AES_ECB_MODE; - - if (keyblock == NULL) - { - keyblock = util_malloc(sizeof(aes_keyblock)); - state->flags |= AES_STATE_ALLOC; - } - state->keyblock = keyblock; - key_expansion(state, key); - state->flush = 0; - return state; -} -*/ - -void aes_pdf_mode (aes_state *state) -{ - state->flags |= AES_INLINE_IV; - state->flags &= ~AES_NULL_PADDING; -} - -/* -Initialize arguments: -- state - crypt state -- keyblock - a space for aes key expansion; can be left NULL in which case will be allocated -- key - crypt key; can be left NULL iff keyblock is given and properly initialized -- keylength - the length of the key (16 or 32 bytes) -- iv - 16-bytes CBC initialization vector; - - if left NULL for encoder, one is generated and stored as state->iv - - can also be left NULL for decorer, but then AES_INLINE_IV must be set, as this informs decoder to take - an initialization vector from the beginning of the encrypted stream - -At the first approach, an initialization vector was copied to state block during initialization and encoders -assumed that the state block is the current initialization vector. This simplifies encrypting procedure, -as the output from every 16-bytes chunk encryption is an initialization vector for the next chunk. However, -it makes api usage cumbersome, as the user has to know that iv may need to be copied to state block -before each call. -*/ - -static int aes_key_length (aes_state *state, size_t keylength) -{ - state->keylength = keylength; - switch (keylength) - { - case 16: - state->rounds = 10; - break; - case 24: - state->rounds = 12; - break; - case 32: - state->rounds = 14; - break; - default: - return 0; - } - return 1; -} - -aes_state * aes_encode_initialize (aes_state *state, aes_keyblock *keyblock, const void *key, size_t keylength, const void *iv) -{ - state->flags = 0; - if (!aes_key_length(state, keylength)) - return NULL; - if (iv != NULL) - aes_copy_block(state->iv, iv); - else - aes_generate_iv(state->iv); - state->flags |= AES_HAS_IV; - - if (keyblock == NULL) - { - keyblock = (aes_keyblock *)util_malloc(sizeof(aes_keyblock)); - state->flags |= AES_STATE_ALLOC; - } - state->keyblock = keyblock; - if (key != NULL) /* if NULL we assume keyblock is given and already expanded */ - key_expansion(state, (const uint8_t *)key); - state->flush = 0; - return state; -} - -aes_state * aes_decode_initialize (aes_state *state, aes_keyblock *keyblock, const void *key, size_t keylength, const void *iv) -{ - state->flags = 0; - if (!aes_key_length(state, keylength)) - return NULL; - if (iv != NULL) - { - aes_copy_block(state->iv, iv); - state->flags |= AES_HAS_IV; - } - /* else if AES_INLINE_IV flag is set will be read from input */ - - if (keyblock == NULL) - { - keyblock = (aes_keyblock *)util_malloc(sizeof(aes_keyblock)); - state->flags |= AES_STATE_ALLOC; - } - state->keyblock = keyblock; - if (key != NULL) /* otherwise keyblock is assumed present and properly initialized */ - key_expansion(state, (const uint8_t *)key); - state->flush = 0; - return state; -} - -void aes_state_close (aes_state *state) -{ - if (state->keyblock != NULL && (state->flags & AES_STATE_ALLOC)) - util_free(state->keyblock); -} - -/* add round key */ - -static void aes_round_key (aes_block block, aes_block keyblock) -{ - uint8_t i, j; - for(i = 0; i < 4; ++i) - for(j = 0; j < 4; ++j) - block[i][j] ^= keyblock[i][j]; -} - -#define aes_add_key(block, keyblock, round) aes_round_key(block, (*keyblock)[round]) - -/* substitution */ - -static void aes_encode_sub (aes_block block) -{ - uint8_t i, j, v; - for(i = 0; i < 4; ++i) - for(j = 0; j < 4; ++j) - v = block[i][j], block[i][j] = sbox[v]; -} - -/* rows shift; the row index is the shift offset, the first order is not shifted */ - -static void aes_encode_shift (aes_block block) -{ - uint8_t tmp; - - /* 1st row rotated once */ - tmp = block[0][1]; - block[0][1] = block[1][1]; - block[1][1] = block[2][1]; - block[2][1] = block[3][1]; - block[3][1] = tmp; - - /* 2nd row rotated twice */ - tmp = block[0][2]; - block[0][2] = block[2][2]; - block[2][2] = tmp; - tmp = block[1][2]; - block[1][2] = block[3][2]; - block[3][2] = tmp; - - /* 3rd row rotated 3 times */ - tmp = block[0][3]; - block[0][3] = block[3][3]; - block[3][3] = block[2][3]; - block[2][3] = block[1][3]; - block[1][3] = tmp; -} - -static uint8_t xtime (uint8_t x) -{ - return ((x << 1) ^ (((x >> 7) & 1) * 0x1b)); -} - -/* mix columns */ - -static void aes_encode_mix (aes_block block) -{ - uint8_t i, tmp, tm, t; - - for(i = 0; i < 4; ++i) - { - t = block[i][0]; - tmp = block[i][0] ^ block[i][1] ^ block[i][2] ^ block[i][3] ; - tm = block[i][0] ^ block[i][1]; tm = xtime(tm); block[i][0] ^= tm ^ tmp; - tm = block[i][1] ^ block[i][2]; tm = xtime(tm); block[i][1] ^= tm ^ tmp; - tm = block[i][2] ^ block[i][3]; tm = xtime(tm); block[i][2] ^= tm ^ tmp; - tm = block[i][3] ^ t ; tm = xtime(tm); block[i][3] ^= tm ^ tmp; - } -} - -/* multiply is used to multiply numbers in the field GF(2^8) */ - -#define multiply(x, y) \ - ( ((y & 1) * x) ^ \ - ((y>>1 & 1) * xtime(x)) ^ \ - ((y>>2 & 1) * xtime(xtime(x))) ^ \ - ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^ \ - ((y>>4 & 1) * xtime(xtime(xtime(xtime(x)))))) \ - -/* mix columns */ - -static void aes_decode_mix (aes_block block) -{ - int i; - uint8_t a, b, c, d; - - for(i = 0; i < 4; ++i) - { - a = block[i][0]; - b = block[i][1]; - c = block[i][2]; - d = block[i][3]; - block[i][0] = multiply(a, 0x0e) ^ multiply(b, 0x0b) ^ multiply(c, 0x0d) ^ multiply(d, 0x09); - block[i][1] = multiply(a, 0x09) ^ multiply(b, 0x0e) ^ multiply(c, 0x0b) ^ multiply(d, 0x0d); - block[i][2] = multiply(a, 0x0d) ^ multiply(b, 0x09) ^ multiply(c, 0x0e) ^ multiply(d, 0x0b); - block[i][3] = multiply(a, 0x0b) ^ multiply(b, 0x0d) ^ multiply(c, 0x09) ^ multiply(d, 0x0e); - } -} - -/* inverse substitution */ - -static void aes_decode_sub (aes_block block) -{ - uint8_t i, j, v; - for(i = 0; i < 4; ++i) - for(j = 0; j < 4; ++j) - v = block[i][j], block[i][j] = rsbox[v]; -} - -/* inverse shift rows */ - -static void aes_decode_shift (aes_block block) -{ - uint8_t tmp; - - /* 1st row rotated once right */ - tmp = block[3][1]; - block[3][1] = block[2][1]; - block[2][1] = block[1][1]; - block[1][1] = block[0][1]; - block[0][1] = tmp; - - /* 2st row rotated twice right */ - tmp = block[0][2]; - block[0][2] = block[2][2]; - block[2][2] = tmp; - tmp = block[1][2]; - block[1][2] = block[3][2]; - block[3][2] = tmp; - - /* 3rd row rotated 3 times right */ - tmp = block[0][3]; - block[0][3] = block[1][3]; - block[1][3] = block[2][3]; - block[2][3] = block[3][3]; - block[3][3] = tmp; -} - -/* aes block encoder */ - -static void aes_encode_cipher (aes_state *state) -{ - uint8_t round; - aes_add_key(state->block, state->keyblock, 0); - for (round = 1; round < state->rounds; ++round) - { - aes_encode_sub(state->block); - aes_encode_shift(state->block); - aes_encode_mix(state->block); - aes_add_key(state->block, state->keyblock, round); - } - aes_encode_sub(state->block); - aes_encode_shift(state->block); - aes_add_key(state->block, state->keyblock, state->rounds); -} - -/* aes block decoder */ - -static void aes_decode_cipher (aes_state *state) -{ - uint8_t round; - aes_add_key(state->block, state->keyblock, state->rounds); - for(round = state->rounds - 1; round > 0; --round) - { - aes_decode_shift(state->block); - aes_decode_sub(state->block); - aes_add_key(state->block, state->keyblock, round); - aes_decode_mix(state->block); - } - aes_decode_shift(state->block); - aes_decode_sub(state->block); - aes_add_key(state->block, state->keyblock, 0); -} - -/* tail block padding; RFC 2898, PKCS #5: Password-Based Cryptography Specification Version 2.0; pdf spec p. 119 */ - -#define aes_padding(state) ((state->flags & AES_NULL_PADDING) == 0) - -static void aes_put_padding (aes_state *state, uint8_t length) -{ - uint8_t pad; - pad = (aes_padding(state)) ? 16 - length : 0; - for (; length < 16; ++length) - state->data[length] = state->iv[length] ^ pad; -} - -static int aes_remove_padding (aes_state *state, uint8_t *data, uint8_t *length) -{ - uint8_t pad; - *length = 16; /* block length 16 means leave intact */ - if (aes_padding(state)) - { - pad = data[16 - 1]; - if (pad > 16) - return IOFERR; - for ( ; *length > 16 - pad; --(*length)) - if (data[*length - 1] != pad) - return IOFERR; - } - else - { - for ( ; *length > 0; --(*length)) - if (data[*length - 1] != '\0') - break; - } - return IOFEOF; -} - -/* aes codec */ - -/* make the cipher on input xor-ed with iv, save the output as a new iv, write the output */ -#define aes_encode_output(state, output) \ - (aes_encode_cipher(state), aes_copy_block(state->iv, state->data), aes_copy_block(output, state->data), output += 16) - -iof_status aes_encode_state (iof *I, iof *O, aes_state *state) -{ - int c; - - if (!(state->flags & AES_HAS_IV)) // weird - return IOFERR; - if ((state->flags & AES_INLINE_IV) && !(state->flags & AES_CONTINUE)) - { /* write iv at the beginning of encrypted data */ - if (!iof_ensure(O, 16)) - return IOFFULL; - aes_copy_block(O->pos, state->iv); - O->pos += 16; - state->flags |= AES_CONTINUE; - } - while (iof_ensure(O, 16)) - { - while (state->buffered < 16) - { - if ((c = iof_get(I)) != IOFEOF) - { /* get input byte XORed with iv */ - state->data[state->buffered] = state->iv[state->buffered] ^ ((uint8_t)c); - ++state->buffered; - } - else - { - if (state->flush) - { - if (state->buffered > 0 || aes_padding(state)) - { /* pad the last input chunk; for input divisable by 16, add 16 bytes 0x0f */ - aes_put_padding(state, state->buffered); - state->buffered = 16; - aes_encode_output(state, O->pos); - } - return IOFEOF; - } - else - return IOFEMPTY; - } - } - aes_encode_output(state, O->pos); - state->buffered = 0; - } - return IOFFULL; -} - -/* write iv to the output, save the raw input just buffered as iv for the next chunk, make the cipher, write out xoring with iv */ -#define aes_decode_output(state, output) \ - (aes_copy_block(output, state->iv), aes_copy_block(state->iv, state->data), aes_decode_cipher(state), aes_copy_cbc(output, state->data), output += 16) - -iof_status aes_decode_state (iof *I, iof *O, aes_state *state) -{ - int c, ret; - uint8_t lastlength; - - if ((state->flags & AES_INLINE_IV) && !(state->flags & AES_CONTINUE)) - { - while (state->buffered < 16) - { - if ((c = iof_get(I)) != IOFEOF) - state->iv[state->buffered++] = (uint8_t)c; - else - return state->flush ? IOFERR : IOFEMPTY; - } - state->flags |= AES_CONTINUE|AES_HAS_IV; - state->buffered = 0; - } - while (iof_ensure(O, 16)) - { - while (state->buffered < 16) - { - if ((c = iof_get(I)) != IOFEOF) - state->data[state->buffered++] = (uint8_t)c; - else - return state->flush ? IOFERR : IOFEMPTY; - } - aes_decode_output(state, O->pos); - if (state->flush) - { /* we have to check for EOF here, to remove eventual padding */ - if ((c = iof_get(I)) < 0) - { /* end of input at 16-bytes boundary; remove padding and quit */ - ret = aes_remove_padding(state, O->pos - 16, &lastlength); - O->pos -= 16 - lastlength; - return ret; - } - else - { /* beginning of the next block */ - state->buffered = 1; - state->data[0] = (uint8_t)c; - } - } - else - state->buffered = 0; - } - return IOFFULL; -} - -/* variants that works on c-strings; can work inplace (output==input) except encoder in pdf flavour */ - -/* -Codecs operating on c-string can generally work inplace (output==input), except encoder with AES_INLINE_IV flag set, -which outputs 16 bytes of initialization vector at the beginning of encrypted data. All return the size of encrypted/decrypted -data. Encoders output is the original length padded to a complete 16 bytes (plus eventual 16 bytes of initialization -vector, if AES_INLINE_IV is used). Default padding is unambiguously removed during decryption. AES_NULL_PADDING flag -forces using (ambiguous) NULL-byte padding, only if input length module 16 is greater then zero. - -An input data is supposed to be a complete data to be encrypted or decrypted. It is possible, however, to use those -codecs for scaterred data chunks by manipulating AES_INLINE_IV, AES_NULL_PADDING, AES_CONTINUE flags and data length. -Caller may assume that c-string codecs do not modify state flags. - -Encoder could actually be optimized by writing an initialization vector to a state block once. After every chunk encryption, -the output is the initialization vector for the next chunk. Since we use c-string codec variants on short strings, -the gain is neglectable in comparison with the weight of the aes crypt procedure. -*/ - -size_t aes_encode_data (const void *input, size_t length, void *output, const void *key, size_t keylength, const void *iv, int flags) -{ - aes_state state; - aes_keyblock keyblock; - - if (aes_encode_initialize(&state, &keyblock, key, keylength, iv) == NULL) - return 0; - state.flags |= flags; - return aes_encode_state_data(&state, input, length, output); - // aes_state_close(&state); -} - -size_t aes_encode_state_data (aes_state *state, const void *input, size_t length, void *output) -{ - const uint8_t *inp; - uint8_t *out, tail, t; - size_t size; - - inp = (const uint8_t *)input; - out = (uint8_t *)output; - - if (!(state->flags & AES_HAS_IV)) - return 0; - if ((state->flags & AES_INLINE_IV) && !(state->flags & AES_CONTINUE)) - { - aes_copy_block(out, state->iv); - out += 16; - } - // state->flags |= AES_CONTINUE; // do not modify state flags - - for (size = 0; size + 16 <= length; size += 16) - { - aes_copy_xor(state->data, inp, state->iv); - aes_encode_output(state, out); - inp += 16; - } - - if ((tail = (length % 16)) > 0 || aes_padding(state)) - { - for (t = 0; t < tail; ++t) - state->data[t] = inp[t] ^ state->iv[t]; - aes_put_padding(state, tail); - aes_encode_output(state, out); - size += 16; - } - if (state->flags & AES_INLINE_IV) - size += 16; /* iv written at the beginning of encoded data */ - - return size; -} - -size_t aes_decode_data (const void *input, size_t length, void *output, const void *key, size_t keylength, const void *iv, int flags) -{ - aes_state state; - aes_keyblock keyblock; - - if (aes_decode_initialize(&state, &keyblock, key, keylength, iv) == NULL) - return 0; - state.flags |= flags; - return aes_decode_state_data(&state, input, length, output); - // aes_state_close(&state); -} - -size_t aes_decode_state_data (aes_state *state, const void *input, size_t length, void *output) -{ - const uint8_t *inp; - uint8_t *out, lastlength; - size_t size; - - inp = (const uint8_t *)input; - out = (uint8_t *)output; - - if ((state->flags & AES_INLINE_IV) && !(state->flags & AES_CONTINUE)) - { - aes_copy_block(state->iv, inp); - // state->flags |= AES_HAS_IV; // do not modify state flags - inp += 16; - length = length >= 16 ? length - 16 : 0; - } - else if (!(state->flags & AES_HAS_IV)) - return 0; - // state->flags |= AES_CONTINUE; // do not modify state flags - for (size = 0; size + 16 <= length; size += 16) - { - aes_copy_block(state->data, inp); - aes_decode_output(state, out); - inp += 16; - } - - if (size >= 16) - { - aes_remove_padding(state, out - 16, &lastlength); - size = size - 16 + lastlength; - } - - return size; -} - -/* -pseudo-random bytes chain exceprted from eexec; not expected to have strong cryptographic properties -we only expect that it is (reasonably) unique and different for each call (not only function call, but also -a program call). A current trick with mangling pointer value gives satisfactory results, generally different -for every function call and a programm call. Note that the pseudo-input bytes starts from some inner address -bits, as they vary better; without that, the first byte tends to be "lazy". -*/ - -void random_bytes (uint8_t *output, size_t size) -{ - size_t i; - uint8_t p; - static uint16_t k = 55665; - for (i = 0; i < size; ++i) - { - p = ((uint8_t *)(&output))[(i + 2) % sizeof(uint8_t *)] ^ (uint8_t)size; // pseudo input byte ;) - k = (((p + k) * 52845 + 22719) & 65535); // xor-ed with pseudo-random sequence (kept between calls) - output[i] = p ^ (k >> 8); - } -} - -void aes_generate_iv (uint8_t output[16]) -{ - random_bytes(output, 16); -} - -/* filters */ - -// rc4 decoder function - -static size_t rc4_decoder (iof *F, iof_mode mode) -{ - rc4_state *state; - iof_status status; - size_t tail; - - state = iof_filter_state(rc4_state *, F); - switch(mode) - { - case IOFLOAD: - case IOFREAD: - if (F->flags & IOF_STOPPED) - return 0; - tail = iof_tail(F); - F->pos = F->buf + tail; - F->end = F->buf + F->space; - do { - status = rc4_decode_state(F->next, F, state); - } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F)); - return iof_decoder_retval(F, "rc4", status); - case IOFCLOSE: - rc4_state_close(state); - iof_free(F); - return 0; - default: - break; - } - return 0; -} - -// rc4 encoder function - -static size_t rc4_encoder (iof *F, iof_mode mode) -{ - rc4_state *state; - iof_status status; - - state = iof_filter_state(rc4_state *, F); - switch (mode) - { - case IOFFLUSH: - state->flush = 1; - FALLTHRU // fall through - case IOFWRITE: - F->end = F->pos; - F->pos = F->buf; - status = rc4_encode_state(F, F->next, state); - return iof_encoder_retval(F, "rc4", status); - case IOFCLOSE: - if (!state->flush) - rc4_encoder(F, IOFFLUSH); - rc4_state_close(state); - iof_free(F); - return 0; - default: - break; - } - return 0; -} - -// aes decoder function - -static size_t aes_decoder (iof *F, iof_mode mode) -{ - aes_state *state; - iof_status status; - size_t tail; - - state = iof_filter_state(aes_state *, F); - switch(mode) - { - case IOFLOAD: - case IOFREAD: - if (F->flags & IOF_STOPPED) - return 0; - tail = iof_tail(F); - F->pos = F->buf + tail; - F->end = F->buf + F->space; - do { - status = aes_decode_state(F->next, F, state); - } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F)); - return iof_decoder_retval(F, "aes", status); - case IOFCLOSE: - aes_state_close(state); - iof_free(F); - return 0; - default: - break; - } - return 0; -} - -// aes encoder function - -static size_t aes_encoder (iof *F, iof_mode mode) -{ - aes_state *state; - iof_status status; - - state = iof_filter_state(aes_state *, F); - switch (mode) - { - case IOFFLUSH: - state->flush = 1; - FALLTHRU // fall through - case IOFWRITE: - F->end = F->pos; - F->pos = F->buf; - status = aes_encode_state(F, F->next, state); - return iof_encoder_retval(F, "aes", status); - case IOFCLOSE: - if (!state->flush) - aes_encoder(F, IOFFLUSH); - aes_state_close(state); - iof_free(F); - return 0; - default: - break; - } - return 0; -} - -iof * iof_filter_rc4_decoder (iof *N, const void *key, size_t keylength) -{ - iof *I; - crypt_state_pointer P; - - I = iof_filter_reader(rc4_decoder, sizeof(rc4_state), &P.voidstate); - iof_setup_next(I, N); - if (rc4_state_init(P.rc4state, key, keylength) == NULL) - { - iof_discard(I); - return NULL; - } - P.rc4state->flush = 1; - return I; -} - -iof * iof_filter_rc4_encoder (iof *N, const void *key, size_t keylength) -{ - iof *O; - crypt_state_pointer P; - - O = iof_filter_writer(rc4_encoder, sizeof(rc4_state), &P.voidstate); - iof_setup_next(O, N); - if (rc4_state_init(P.rc4state, key, keylength) == NULL) - { - iof_discard(O); - return NULL; - } - // P.rc4state->flush = 1; - return O; -} - -/* aes crypt filters */ - -iof * iof_filter_aes_decoder (iof *N, const void *key, size_t keylength) -{ - iof *I; - crypt_state_pointer P; - - I = iof_filter_reader(aes_decoder, sizeof(aes_state), &P.voidstate); - iof_setup_next(I, N); - if (aes_decode_init(P.aesstate, key, keylength) == NULL) - { - iof_discard(I); - return NULL; - } - aes_pdf_mode(P.aesstate); - P.aesstate->flush = 1; - return I; -} - -iof * iof_filter_aes_encoder (iof *N, const void *key, size_t keylength) -{ - iof *O; - crypt_state_pointer P; - - O = iof_filter_writer(aes_encoder, sizeof(aes_state), &P.voidstate); - iof_setup_next(O, N); - if (aes_encode_init(P.aesstate, key, keylength) == NULL) - { - iof_discard(O); - return NULL; - } - aes_pdf_mode(P.aesstate); - // P.aesstate->flush = 1; - return O; -} - -/* test */ - -/* -static void show (void *p, size_t size, uint8_t round, uint8_t sym) -{ - uint8_t i; - printf("%c%c:", round, sym); - for (i = 0; i < size; ++i) - printf("%02x", ((uint8_t *)p)[i]); - printf("\n"); -} - -void aes_test (void) -{ - const uint8_t key[] = { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c }; - const uint8_t iv[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }; - const uint8_t inp[] = { - 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a, - 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51, - 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef, - 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17, 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 }; - const uint8_t out[] = { - 0x76, 0x49, 0xab, 0xac, 0x81, 0x19, 0xb2, 0x46, 0xce, 0xe9, 0x8e, 0x9b, 0x12, 0xe9, 0x19, 0x7d, - 0x50, 0x86, 0xcb, 0x9b, 0x50, 0x72, 0x19, 0xee, 0x95, 0xdb, 0x11, 0x3a, 0x91, 0x76, 0x78, 0xb2, - 0x73, 0xbe, 0xd6, 0xb8, 0xe3, 0xc1, 0x74, 0x3b, 0x71, 0x16, 0xe6, 0x9e, 0x22, 0x22, 0x95, 0x16, - 0x3f, 0xf1, 0xca, 0xa1, 0x68, 0x1f, 0xac, 0x09, 0x12, 0x0e, 0xca, 0x30, 0x75, 0x86, 0xe1, 0xa7 }; - - uint8_t input[64], output[64]; - size_t inpsize, outsize; - int flags = AES_NULL_PADDING; - - //////////////////////////////////////////////////////////////////////////// - -//#define ENCODETO output -#define ENCODETO input // inplace - - inpsize = 64; - memcpy(input, inp, inpsize); - show(input, inpsize, '>', '>'); - outsize = aes_encode_data(input, inpsize, ENCODETO, key, 16, iv, flags); - show(ENCODETO, outsize, '<', '<'); - if (outsize == inpsize && memcmp(ENCODETO, out, outsize) == 0) - printf("ENCODER SUCCESS\n"); - else - printf("ENCODER FAILURE\n"); - - //////////////////////////////////////////////////////////////////////////// - -//#define DECODETO input -#define DECODETO output // in place - - outsize = 64; - memcpy(output, out, outsize); - show(output, outsize, '<', '<'); - inpsize = aes_decode_data(output, outsize, DECODETO, key, 16, iv, flags); - show(DECODETO, inpsize, '>', '>'); - if (inpsize == outsize && memcmp(DECODETO, inp, inpsize) == 0) - printf("DECODER SUCCESS\n"); - else - printf("DECODER FAILURE\n"); -} -*/ - -/* -Some example vectors - -================================ AES ECB 128-bit encryption mode ================================ - -Encryption key: 2b7e151628aed2a6abf7158809cf4f3c - -Test vector Cipher text -6bc1bee22e409f96e93d7e117393172a 3ad77bb40d7a3660a89ecaf32466ef97 -ae2d8a571e03ac9c9eb76fac45af8e51 f5d3d58503b9699de785895a96fdbaaf -30c81c46a35ce411e5fbc1191a0a52ef 43b1cd7f598ece23881b00e3ed030688 -f69f2445df4f9b17ad2b417be66c3710 7b0c785e27e8ad3f8223207104725dd4 - - -================================ AES ECB 192-bit encryption mode ================================ - -Encryption key: 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b - -Test vector Cipher text -6bc1bee22e409f96e93d7e117393172a bd334f1d6e45f25ff712a214571fa5cc -ae2d8a571e03ac9c9eb76fac45af8e51 974104846d0ad3ad7734ecb3ecee4eef -30c81c46a35ce411e5fbc1191a0a52ef ef7afd2270e2e60adce0ba2face6444e -f69f2445df4f9b17ad2b417be66c3710 9a4b41ba738d6c72fb16691603c18e0e - - -================================ AES ECB 256-bit encryption mode ================================ - -Encryption key: 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4 - -Test vector Cipher text -6bc1bee22e409f96e93d7e117393172a f3eed1bdb5d2a03c064b5a7e3db181f8 -ae2d8a571e03ac9c9eb76fac45af8e51 591ccb10d410ed26dc5ba74a31362870 -30c81c46a35ce411e5fbc1191a0a52ef b6ed21b99ca6f4f9f153e7b1beafed1d -f69f2445df4f9b17ad2b417be66c3710 23304b7a39f9f3ff067d8d8f9e24ecc7 - -================================ AES CBC 128-bit encryption mode ================================ - -Encryption key: 2b7e151628aed2a6abf7158809cf4f3c - -Initialization vector Test vector Cipher text -000102030405060708090A0B0C0D0E0F 6bc1bee22e409f96e93d7e117393172a 7649abac8119b246cee98e9b12e9197d -7649ABAC8119B246CEE98E9B12E9197D ae2d8a571e03ac9c9eb76fac45af8e51 5086cb9b507219ee95db113a917678b2 -5086CB9B507219EE95DB113A917678B2 30c81c46a35ce411e5fbc1191a0a52ef 73bed6b8e3c1743b7116e69e22229516 -73BED6B8E3C1743B7116E69E22229516 f69f2445df4f9b17ad2b417be66c3710 3ff1caa1681fac09120eca307586e1a7 - -================================ AES CBC 192-bit encryption mode ================================ - -Encryption key: 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b - -Initialization vector Test vector Cipher text -000102030405060708090A0B0C0D0E0F 6bc1bee22e409f96e93d7e117393172a 4f021db243bc633d7178183a9fa071e8 -4F021DB243BC633D7178183A9FA071E8 ae2d8a571e03ac9c9eb76fac45af8e51 b4d9ada9ad7dedf4e5e738763f69145a -B4D9ADA9AD7DEDF4E5E738763F69145A 30c81c46a35ce411e5fbc1191a0a52ef 571b242012fb7ae07fa9baac3df102e0 -571B242012FB7AE07FA9BAAC3DF102E0 f69f2445df4f9b17ad2b417be66c3710 08b0e27988598881d920a9e64f5615cd - -================================ AES CBC 256-bit encryption mode ================================ - -Encryption key: 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4 - -Initialization vector Test vector Cipher text -000102030405060708090A0B0C0D0E0F 6bc1bee22e409f96e93d7e117393172a f58c4c04d6e5f1ba779eabfb5f7bfbd6 -F58C4C04D6E5F1BA779EABFB5F7BFBD6 ae2d8a571e03ac9c9eb76fac45af8e51 9cfc4e967edb808d679f777bc6702c7d -9CFC4E967EDB808D679F777BC6702C7D 30c81c46a35ce411e5fbc1191a0a52ef 39f23369a9d9bacfa530e26304231461 -39F23369A9D9BACFA530E26304231461 f69f2445df4f9b17ad2b417be66c3710 b2eb05e2c39be9fcda6c19078c6a9d1b -*/
\ No newline at end of file |