diff --git a/sys/crypto/chacha.c b/sys/crypto/chacha.c index b382e74230..044095c654 100644 --- a/sys/crypto/chacha.c +++ b/sys/crypto/chacha.c @@ -34,7 +34,8 @@ #include "byteorder.h" #if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__ -# error "This code is implementented in a way that it will only work for little-endian systems!" +# error \ + "This code is implementented in a way that it will only work for little-endian systems!" #endif #include @@ -46,9 +47,11 @@ static void _r(uint32_t *d, uint32_t *a, const uint32_t *b, unsigned c) *d = (tmp << c) | (tmp >> (32 - c)); } -static void _doubleround(void *output_, const uint32_t input[16], uint8_t rounds) +static void _doubleround(void *output_, const uint32_t input[16], + uint8_t rounds) { - uint32_t *output = (uint32_t *) output_; + uint32_t *output = (uint32_t *)output_; + memcpy(output, input, 64); rounds *= 4; @@ -115,8 +118,9 @@ void chacha_keystream_bytes(chacha_ctx *ctx, void *x) void chacha_encrypt_bytes(chacha_ctx *ctx, const uint8_t *m, uint8_t *c) { uint8_t x[64]; + chacha_keystream_bytes(ctx, x); - for (unsigned i = 0 ; i < 64; ++i) { + for (unsigned i = 0; i < 64; ++i) { c[i] = m[i] ^ x[i]; } } diff --git a/sys/crypto/ciphers.c b/sys/crypto/ciphers.c index 2a6a07884c..e51fa72fad 100644 --- a/sys/crypto/ciphers.c +++ b/sys/crypto/ciphers.c @@ -19,7 +19,7 @@ #include "crypto/ciphers.h" -int cipher_init(cipher_t* cipher, cipher_id_t cipher_id, const uint8_t* key, +int cipher_init(cipher_t *cipher, cipher_id_t cipher_id, const uint8_t *key, uint8_t key_size) { if (key_size > cipher_id->max_key_size) { @@ -32,19 +32,21 @@ int cipher_init(cipher_t* cipher, cipher_id_t cipher_id, const uint8_t* key, } -int cipher_encrypt(const cipher_t* cipher, const uint8_t* input, uint8_t* output) +int cipher_encrypt(const cipher_t *cipher, const uint8_t *input, + uint8_t *output) { return cipher->interface->encrypt(&cipher->context, input, output); } -int cipher_decrypt(const cipher_t* cipher, const uint8_t* input, uint8_t* output) +int cipher_decrypt(const cipher_t *cipher, const uint8_t *input, + uint8_t *output) { return cipher->interface->decrypt(&cipher->context, input, output); } -int cipher_get_block_size(const cipher_t* cipher) +int cipher_get_block_size(const cipher_t *cipher) { return cipher->interface->block_size; } diff --git a/sys/crypto/helper.c b/sys/crypto/helper.c index fcf92ab031..07987ea1f4 100644 --- a/sys/crypto/helper.c +++ b/sys/crypto/helper.c @@ -12,6 +12,7 @@ void crypto_block_inc_ctr(uint8_t block[16], int L) { uint8_t *b = &block[15]; + for (int i = 0; i < L; ++i, --b) { if (++*b != 0) { break; @@ -22,6 +23,7 @@ void crypto_block_inc_ctr(uint8_t block[16], int L) int crypto_equals(const uint8_t *a, const uint8_t *b, size_t len) { uint8_t diff = 0; + for (size_t i = 0; i < len; ++i, ++a, ++b) { diff |= (*a ^ *b); } @@ -37,7 +39,8 @@ int crypto_equals(const uint8_t *a, const uint8_t *b, size_t len) /* Compiler should not be allowed to optimize this */ void crypto_secure_wipe(void *buf, size_t len) { - volatile uint8_t *vbuf = (uint8_t*)buf; + volatile uint8_t *vbuf = (uint8_t *)buf; + for (size_t i = 0; i < len; i++) { vbuf[i] = 0; } diff --git a/sys/crypto/modes/cbc.c b/sys/crypto/modes/cbc.c index 159f0b54f5..15b5e57721 100644 --- a/sys/crypto/modes/cbc.c +++ b/sys/crypto/modes/cbc.c @@ -22,11 +22,11 @@ #include #include "crypto/modes/cbc.h" -int cipher_encrypt_cbc(cipher_t* cipher, uint8_t iv[16], - const uint8_t* input, size_t length, uint8_t* output) +int cipher_encrypt_cbc(cipher_t *cipher, uint8_t iv[16], + const uint8_t *input, size_t length, uint8_t *output) { size_t offset = 0; - uint8_t block_size, input_block[CIPHER_MAX_BLOCK_SIZE] = {0}, + uint8_t block_size, input_block[CIPHER_MAX_BLOCK_SIZE] = { 0 }, *output_block_last; block_size = cipher_get_block_size(cipher); @@ -54,8 +54,8 @@ int cipher_encrypt_cbc(cipher_t* cipher, uint8_t iv[16], } -int cipher_decrypt_cbc(cipher_t* cipher, uint8_t iv[16], - const uint8_t* input, size_t length, uint8_t* output) +int cipher_decrypt_cbc(cipher_t *cipher, uint8_t iv[16], + const uint8_t *input, size_t length, uint8_t *output) { size_t offset = 0; const uint8_t *input_block, *input_block_last; diff --git a/sys/crypto/modes/ccm.c b/sys/crypto/modes/ccm.c index 50ad97008e..0ca5653030 100644 --- a/sys/crypto/modes/ccm.c +++ b/sys/crypto/modes/ccm.c @@ -34,10 +34,10 @@ static inline int min(int a, int b) } } -int ccm_compute_cbc_mac(cipher_t* cipher, const uint8_t iv[16], - const uint8_t* input, size_t length, uint8_t* mac) +int ccm_compute_cbc_mac(cipher_t *cipher, const uint8_t iv[16], + const uint8_t *input, size_t length, uint8_t *mac) { - uint8_t offset, block_size, mac_enc[16] = {0}; + uint8_t offset, block_size, mac_enc[16] = { 0 }; block_size = cipher_get_block_size(cipher); memmove(mac, iv, 16); @@ -63,8 +63,8 @@ int ccm_compute_cbc_mac(cipher_t* cipher, const uint8_t iv[16], } -int ccm_create_mac_iv(cipher_t* cipher, uint8_t auth_data_len, uint8_t M, - uint8_t L, const uint8_t* nonce, uint8_t nonce_len, +int ccm_create_mac_iv(cipher_t *cipher, uint8_t auth_data_len, uint8_t M, + uint8_t L, const uint8_t *nonce, uint8_t nonce_len, size_t plaintext_len, uint8_t X1[16]) { uint8_t M_, L_; @@ -99,7 +99,7 @@ int ccm_create_mac_iv(cipher_t* cipher, uint8_t auth_data_len, uint8_t M, return 0; } -int ccm_compute_adata_mac(cipher_t* cipher, const uint8_t* auth_data, +int ccm_compute_adata_mac(cipher_t *cipher, const uint8_t *auth_data, uint32_t auth_data_len, uint8_t X1[16]) { if (auth_data_len > 0) { @@ -117,13 +117,15 @@ int ccm_compute_adata_mac(cipher_t* cipher, const uint8_t* auth_data, auth_data_encoded[1] = auth_data_len & 0xFF; auth_data_encoded[0] = (auth_data_len >> 8) & 0xFF; - } else { + } + else { DEBUG("UNSUPPORTED Adata length: %" PRIu32 "\n", auth_data_len); return -1; } memcpy(auth_data_encoded + len_encoding, auth_data, auth_data_len); - len = ccm_compute_cbc_mac(cipher, X1, auth_data_encoded, auth_data_len + len_encoding, X1); + len = ccm_compute_cbc_mac(cipher, X1, auth_data_encoded, + auth_data_len + len_encoding, X1); if (len < 0) { return -1; } @@ -140,27 +142,28 @@ static inline int _fits_in_nbytes(size_t value, uint8_t num_bytes) * So we shift by maximum num bits of size_t -1 and compare to 1 */ unsigned shift = (8 * min(sizeof(size_t), num_bytes)) - 1; + return (value >> shift) <= 1; } -int cipher_encrypt_ccm(cipher_t* cipher, - const uint8_t* auth_data, uint32_t auth_data_len, +int cipher_encrypt_ccm(cipher_t *cipher, + const uint8_t *auth_data, uint32_t auth_data_len, uint8_t mac_length, uint8_t length_encoding, - const uint8_t* nonce, size_t nonce_len, - const uint8_t* input, size_t input_len, - uint8_t* output) + const uint8_t *nonce, size_t nonce_len, + const uint8_t *input, size_t input_len, + uint8_t *output) { int len = -1; - uint8_t nonce_counter[16] = {0}, mac_iv[16] = {0}, mac[16] = {0}, - stream_block[16] = {0}, zero_block[16] = {0}, block_size; + uint8_t nonce_counter[16] = { 0 }, mac_iv[16] = { 0 }, mac[16] = { 0 }, + stream_block[16] = { 0 }, zero_block[16] = { 0 }, block_size; if (mac_length % 2 != 0 || mac_length < 4 || mac_length > 16) { return CCM_ERR_INVALID_MAC_LENGTH; } if (length_encoding < 2 || length_encoding > 8 || - !_fits_in_nbytes(input_len, length_encoding)) { + !_fits_in_nbytes(input_len, length_encoding)) { return CCM_ERR_INVALID_LENGTH_ENCODING; } @@ -184,7 +187,7 @@ int cipher_encrypt_ccm(cipher_t* cipher, /* Compute first stream block */ nonce_counter[0] = length_encoding - 1; memcpy(&nonce_counter[1], nonce, - min(nonce_len, (size_t) 15 - length_encoding)); + min(nonce_len, (size_t)15 - length_encoding)); len = cipher_encrypt_ctr(cipher, nonce_counter, block_size, zero_block, block_size, stream_block); if (len < 0) { @@ -208,31 +211,33 @@ int cipher_encrypt_ccm(cipher_t* cipher, } -int cipher_decrypt_ccm(cipher_t* cipher, - const uint8_t* auth_data, uint32_t auth_data_len, +int cipher_decrypt_ccm(cipher_t *cipher, + const uint8_t *auth_data, uint32_t auth_data_len, uint8_t mac_length, uint8_t length_encoding, - const uint8_t* nonce, size_t nonce_len, - const uint8_t* input, size_t input_len, - uint8_t* plain) + const uint8_t *nonce, size_t nonce_len, + const uint8_t *input, size_t input_len, + uint8_t *plain) { int len = -1; - uint8_t nonce_counter[16] = {0}, mac_iv[16] = {0}, mac[16] = {0}, - mac_recv[16] = {0}, stream_block[16] = {0}, zero_block[16] = {0}, - plain_len, block_size; + uint8_t nonce_counter[16] = { 0 }, mac_iv[16] = { 0 }, mac[16] = { 0 }, + mac_recv[16] = { 0 }, stream_block[16] = { 0 }, + zero_block[16] = { 0 }, + plain_len, block_size; if (mac_length % 2 != 0 || mac_length < 4 || mac_length > 16) { return CCM_ERR_INVALID_MAC_LENGTH; } if (length_encoding < 2 || length_encoding > 8 || - !_fits_in_nbytes(input_len, length_encoding)) { + !_fits_in_nbytes(input_len, length_encoding)) { return CCM_ERR_INVALID_LENGTH_ENCODING; } /* Compute first stream block */ nonce_counter[0] = length_encoding - 1; block_size = cipher_get_block_size(cipher); - memcpy(&nonce_counter[1], nonce, min(nonce_len, (size_t) 15 - length_encoding)); + memcpy(&nonce_counter[1], nonce, min(nonce_len, + (size_t)15 - length_encoding)); len = cipher_encrypt_ctr(cipher, nonce_counter, block_size, zero_block, block_size, stream_block); if (len < 0) { diff --git a/sys/crypto/modes/ctr.c b/sys/crypto/modes/ctr.c index ad74c003ed..22c6da37a4 100644 --- a/sys/crypto/modes/ctr.c +++ b/sys/crypto/modes/ctr.c @@ -7,26 +7,26 @@ */ /** -* @ingroup sys_crypto -* @{ -* -* @file -* @brief Crypto mode - Counter -* -* @author Nico von Geyso -* -* @} -*/ + * @ingroup sys_crypto + * @{ + * + * @file + * @brief Crypto mode - Counter + * + * @author Nico von Geyso + * + * @} + */ #include "crypto/helper.h" #include "crypto/modes/ctr.h" -int cipher_encrypt_ctr(cipher_t* cipher, uint8_t nonce_counter[16], - uint8_t nonce_len, const uint8_t* input, size_t length, - uint8_t* output) +int cipher_encrypt_ctr(cipher_t *cipher, uint8_t nonce_counter[16], + uint8_t nonce_len, const uint8_t *input, size_t length, + uint8_t *output) { size_t offset = 0; - uint8_t stream_block[16] = {0}, block_size; + uint8_t stream_block[16] = { 0 }, block_size; block_size = cipher_get_block_size(cipher); do { @@ -49,9 +49,9 @@ int cipher_encrypt_ctr(cipher_t* cipher, uint8_t nonce_counter[16], return offset; } -int cipher_decrypt_ctr(cipher_t* cipher, uint8_t nonce_counter[16], - uint8_t nonce_len, const uint8_t* input, size_t length, - uint8_t* output) +int cipher_decrypt_ctr(cipher_t *cipher, uint8_t nonce_counter[16], + uint8_t nonce_len, const uint8_t *input, size_t length, + uint8_t *output) { return cipher_encrypt_ctr(cipher, nonce_counter, nonce_len, input, length, output); diff --git a/sys/crypto/modes/ecb.c b/sys/crypto/modes/ecb.c index 183e5bfdc9..7859c27b5e 100644 --- a/sys/crypto/modes/ecb.c +++ b/sys/crypto/modes/ecb.c @@ -7,24 +7,24 @@ */ /** -* @ingroup sys_crypto -* @{ -* -* @file -* @brief Crypto mode - electronic code book -* -* @author Nico von Geyso -* -* @} -*/ + * @ingroup sys_crypto + * @{ + * + * @file + * @brief Crypto mode - electronic code book + * + * @author Nico von Geyso + * + * @} + */ #include #include #include "crypto/modes/ecb.h" -int cipher_encrypt_ecb(cipher_t* cipher, uint8_t* input, - size_t length, uint8_t* output) +int cipher_encrypt_ecb(cipher_t *cipher, uint8_t *input, + size_t length, uint8_t *output) { size_t offset; uint8_t block_size; @@ -46,8 +46,8 @@ int cipher_encrypt_ecb(cipher_t* cipher, uint8_t* input, return offset; } -int cipher_decrypt_ecb(cipher_t* cipher, uint8_t* input, - size_t length, uint8_t* output) +int cipher_decrypt_ecb(cipher_t *cipher, uint8_t *input, + size_t length, uint8_t *output) { size_t offset = 0; uint8_t block_size; diff --git a/sys/crypto/modes/ocb.c b/sys/crypto/modes/ocb.c index 003520efd8..d7d0b6840e 100644 --- a/sys/crypto/modes/ocb.c +++ b/sys/crypto/modes/ocb.c @@ -69,14 +69,16 @@ static void calculate_l_i(uint8_t l_zero[16], size_t i, uint8_t output[16]) } } -static void xor_block(uint8_t block1[16], uint8_t block2[16], uint8_t output[16]) +static void xor_block(uint8_t block1[16], uint8_t block2[16], + uint8_t output[16]) { for (uint8_t i = 0; i < 16; ++i) { output[i] = block1[i] ^ block2[i]; } } -static void processBlock(ocb_state_t *state, size_t blockNumber, uint8_t input[16], uint8_t output[16], uint8_t mode) +static void processBlock(ocb_state_t *state, size_t blockNumber, + uint8_t input[16], uint8_t output[16], uint8_t mode) { /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */ uint8_t l_i[16]; @@ -87,10 +89,12 @@ static void processBlock(ocb_state_t *state, size_t blockNumber, uint8_t input[1 uint8_t cipher_output[16], cipher_input[16]; xor_block(input, state->offset, cipher_input); if (mode == OCB_MODE_ENCRYPT) { - state->cipher->interface->encrypt(&(state->cipher->context), cipher_input, cipher_output); + state->cipher->interface->encrypt(&(state->cipher->context), + cipher_input, cipher_output); } else if (mode == OCB_MODE_DECRYPT) { - state->cipher->interface->decrypt(&(state->cipher->context), cipher_input, cipher_output); + state->cipher->interface->decrypt(&(state->cipher->context), + cipher_input, cipher_output); } xor_block(state->offset, cipher_output, output); /* Checksum_i = Checksum_{i-1} xor P_i */ @@ -102,7 +106,8 @@ static void processBlock(ocb_state_t *state, size_t blockNumber, uint8_t input[1 } } -static void hash(ocb_state_t *state, uint8_t *data, size_t data_len, uint8_t output[16]) +static void hash(ocb_state_t *state, uint8_t *data, size_t data_len, + uint8_t output[16]) { /* Calculate the number of full blocks in data */ size_t m = (data_len - (data_len % 16)) / 16; @@ -121,7 +126,8 @@ static void hash(ocb_state_t *state, uint8_t *data, size_t data_len, uint8_t out /* Sum_i = Sum_{i-1} xor ENCIPHER(K, A_i xor Offset_i) */ uint8_t enciphered_block[16], cipher_input[16]; xor_block(data, offset, cipher_input); - state->cipher->interface->encrypt(&(state->cipher->context), cipher_input, enciphered_block); + state->cipher->interface->encrypt(&(state->cipher->context), + cipher_input, enciphered_block); xor_block(output, enciphered_block, output); data += 16; @@ -137,12 +143,14 @@ static void hash(ocb_state_t *state, uint8_t *data, size_t data_len, uint8_t out xor_block(cipher_input, offset, cipher_input); /* Sum = Sum_m xor ENCIPHER(K, CipherInput) */ uint8_t enciphered_block[16]; - state->cipher->interface->encrypt(&(state->cipher->context), cipher_input, enciphered_block); + state->cipher->interface->encrypt(&(state->cipher->context), + cipher_input, enciphered_block); xor_block(output, enciphered_block, output); } } -static void init_ocb(cipher_t *cipher, uint8_t tag_len, uint8_t *nonce, size_t nonce_len, ocb_state_t *state) +static void init_ocb(cipher_t *cipher, uint8_t tag_len, uint8_t *nonce, + size_t nonce_len, ocb_state_t *state) { state->cipher = cipher; @@ -186,16 +194,21 @@ static void init_ocb(cipher_t *cipher, uint8_t tag_len, uint8_t *nonce, size_t n uint8_t offset_start_byte = bottom / 8; uint8_t offset_start_bit = bottom - offset_start_byte * 8; for (uint8_t i = 0; i < 16; ++i) { - state->offset[i] = (stretch[offset_start_byte + i] << offset_start_bit) | (stretch[offset_start_byte + i + 1] >> (8 - offset_start_bit)); + state->offset[i] = + (stretch[offset_start_byte + i] << offset_start_bit) | + (stretch[offset_start_byte + i + 1] >> (8 - offset_start_bit)); } /* Checksum_0 = zeros(128) */ memset(state->checksum, 0, 16); } -static int32_t run_ocb(cipher_t *cipher, uint8_t *auth_data, uint32_t auth_data_len, - uint8_t tag[16], uint8_t tag_len, uint8_t *nonce, size_t nonce_len, - uint8_t *input, size_t input_len, uint8_t *output, uint8_t mode) +static int32_t run_ocb(cipher_t *cipher, uint8_t *auth_data, + uint32_t auth_data_len, + uint8_t tag[16], uint8_t tag_len, uint8_t *nonce, + size_t nonce_len, + uint8_t *input, size_t input_len, uint8_t *output, + uint8_t mode) { /* OCB mode only works for ciphers of block length 16 */ @@ -275,7 +288,8 @@ static int32_t run_ocb(cipher_t *cipher, uint8_t *auth_data, uint32_t auth_data_ return output_pos; } -int32_t cipher_encrypt_ocb(cipher_t *cipher, uint8_t *auth_data, size_t auth_data_len, +int32_t cipher_encrypt_ocb(cipher_t *cipher, uint8_t *auth_data, + size_t auth_data_len, uint8_t tag_len, uint8_t *nonce, size_t nonce_len, uint8_t *input, size_t input_len, uint8_t *output) { @@ -288,7 +302,8 @@ int32_t cipher_encrypt_ocb(cipher_t *cipher, uint8_t *auth_data, size_t auth_dat int cipher_text_length = run_ocb(cipher, auth_data, auth_data_len, tag, tag_len, nonce, nonce_len, - input, input_len, output, OCB_MODE_ENCRYPT); + input, input_len, output, + OCB_MODE_ENCRYPT); if (cipher_text_length < 0) { // An error occured. Return the error code @@ -299,7 +314,8 @@ int32_t cipher_encrypt_ocb(cipher_t *cipher, uint8_t *auth_data, size_t auth_dat return (cipher_text_length + tag_len); } -int32_t cipher_decrypt_ocb(cipher_t *cipher, uint8_t *auth_data, size_t auth_data_len, +int32_t cipher_decrypt_ocb(cipher_t *cipher, uint8_t *auth_data, + size_t auth_data_len, uint8_t tag_len, uint8_t *nonce, size_t nonce_len, uint8_t *input, size_t input_len, uint8_t *output) { @@ -312,7 +328,8 @@ int32_t cipher_decrypt_ocb(cipher_t *cipher, uint8_t *auth_data, size_t auth_dat uint8_t tag[16]; int plain_text_length = run_ocb(cipher, auth_data, auth_data_len, tag, tag_len, nonce, nonce_len, - input, input_len - tag_len, output, OCB_MODE_DECRYPT); + input, input_len - tag_len, output, + OCB_MODE_DECRYPT); if (plain_text_length < 0) { // An error occured. Retur the error code diff --git a/sys/crypto/poly1305.c b/sys/crypto/poly1305.c index d2e0e719a8..ece5ff13ab 100644 --- a/sys/crypto/poly1305.c +++ b/sys/crypto/poly1305.c @@ -27,9 +27,9 @@ static uint32_t u8to32(const uint8_t *p) { return ((uint32_t)p[0] | - ((uint32_t)p[1] << 8) | - ((uint32_t)p[2] << 16) | - ((uint32_t)p[3] << 24)); + ((uint32_t)p[1] << 8) | + ((uint32_t)p[2] << 16) | + ((uint32_t)p[3] << 24)); } static void u32to8(uint8_t *p, uint32_t v) @@ -42,10 +42,10 @@ static void u32to8(uint8_t *p, uint32_t v) static void _clear_c(poly1305_ctx_t *ctx) { - ctx->c[0] = 0; - ctx->c[1] = 0; - ctx->c[2] = 0; - ctx->c[3] = 0; + ctx->c[0] = 0; + ctx->c[1] = 0; + ctx->c[2] = 0; + ctx->c[3] = 0; ctx->c_idx = 0; } @@ -70,10 +70,10 @@ static void poly1305_block(poly1305_ctx_t *ctx, uint8_t c4) const uint32_t s4 = ctx->h[4] + c4; /* (h + c) * r, without carry propagation */ - const uint64_t x0 = s0*r0 + s1*rr3 + s2*rr2 + s3*rr1 +s4*rr0; - const uint64_t x1 = s0*r1 + s1*r0 + s2*rr3 + s3*rr2 +s4*rr1; - const uint64_t x2 = s0*r2 + s1*r1 + s2*r0 + s3*rr3 +s4*rr2; - const uint64_t x3 = s0*r3 + s1*r2 + s2*r1 + s3*r0 +s4*rr3; + const uint64_t x0 = s0 * r0 + s1 * rr3 + s2 * rr2 + s3 * rr1 + s4 * rr0; + const uint64_t x1 = s0 * r1 + s1 * r0 + s2 * rr3 + s3 * rr2 + s4 * rr1; + const uint64_t x2 = s0 * r2 + s1 * r1 + s2 * r0 + s3 * rr3 + s4 * rr2; + const uint64_t x3 = s0 * r3 + s1 * r2 + s2 * r1 + s3 * r0 + s4 * rr3; const uint32_t x4 = s4 * (r0 & 3); /* partial reduction modulo 2^130 - 5 */ @@ -96,6 +96,7 @@ static void _take_input(poly1305_ctx_t *ctx, uint8_t input) { size_t word = ctx->c_idx >> 2; size_t byte = ctx->c_idx & 3; + ctx->c[word] |= (uint32_t)input << (byte * 8); ctx->c_idx++; } @@ -116,10 +117,10 @@ void poly1305_init(poly1305_ctx_t *ctx, const uint8_t *key) /* load and clamp key */ ctx->r[0] = u8to32(key) & 0x0fffffff; for (size_t i = 1; i < 4; i++) { - ctx->r[i] = u8to32(&key[4*i]) & 0x0ffffffc; + ctx->r[i] = u8to32(&key[4 * i]) & 0x0ffffffc; } for (size_t i = 0; i < 4; i++) { - ctx->pad[i] = u8to32(&key[16 + i*4]); + ctx->pad[i] = u8to32(&key[16 + i * 4]); } /* Zero the hash */ @@ -140,11 +141,11 @@ void poly1305_finish(poly1305_ctx_t *ctx, uint8_t *mac) /* check if we should subtract 2^130-5 by performing the * corresponding carry propagation. */ - const uint64_t u0 = (uint64_t)5 + ctx->h[0]; // <= 1_00000004 - const uint64_t u1 = (u0 >> 32) + ctx->h[1]; // <= 1_00000000 - const uint64_t u2 = (u1 >> 32) + ctx->h[2]; // <= 1_00000000 - const uint64_t u3 = (u2 >> 32) + ctx->h[3]; // <= 1_00000000 - const uint64_t u4 = (u3 >> 32) + ctx->h[4]; // <= 5 + const uint64_t u0 = (uint64_t)5 + ctx->h[0]; // <= 1_00000004 + const uint64_t u1 = (u0 >> 32) + ctx->h[1]; // <= 1_00000000 + const uint64_t u2 = (u1 >> 32) + ctx->h[2]; // <= 1_00000000 + const uint64_t u3 = (u2 >> 32) + ctx->h[3]; // <= 1_00000000 + const uint64_t u4 = (u3 >> 32) + ctx->h[4]; // <= 5 /* u4 indicates how many times we should subtract 2^130-5 (0 or 1) */ /* h + pad, minus 2^130-5 if u4 exceeds 3 */ @@ -152,17 +153,18 @@ void poly1305_finish(poly1305_ctx_t *ctx, uint8_t *mac) u32to8(mac, uu0); const uint64_t uu1 = (uu0 >> 32) + ctx->h[1] + ctx->pad[1]; - u32to8(mac+4, uu1); + u32to8(mac + 4, uu1); const uint64_t uu2 = (uu1 >> 32) + ctx->h[2] + ctx->pad[2]; - u32to8(mac+8, uu2); + u32to8(mac + 8, uu2); const uint64_t uu3 = (uu2 >> 32) + ctx->h[3] + ctx->pad[3]; - u32to8(mac+12, uu3); + u32to8(mac + 12, uu3); } -void poly1305_auth(uint8_t *mac, const uint8_t *data, size_t len, const uint8_t *key) +void poly1305_auth(uint8_t *mac, const uint8_t *data, size_t len, + const uint8_t *key) { poly1305_ctx_t ctx; diff --git a/sys/include/crypto/chacha.h b/sys/include/crypto/chacha.h index 9047efa2c5..c8b9eac5ee 100644 --- a/sys/include/crypto/chacha.h +++ b/sys/include/crypto/chacha.h @@ -99,7 +99,8 @@ void chacha_encrypt_bytes(chacha_ctx *ctx, const uint8_t *m, uint8_t *c); /** * @copydoc chacha_encrypt_bytes() */ -static inline void chacha_decrypt_bytes(chacha_ctx *ctx, const uint8_t *m, uint8_t *c) +static inline void chacha_decrypt_bytes(chacha_ctx *ctx, const uint8_t *m, + uint8_t *c) { chacha_encrypt_bytes(ctx, m, c); } diff --git a/sys/include/crypto/chacha20poly1305.h b/sys/include/crypto/chacha20poly1305.h index 398669daf5..25b290e23a 100644 --- a/sys/include/crypto/chacha20poly1305.h +++ b/sys/include/crypto/chacha20poly1305.h @@ -34,21 +34,20 @@ extern "C" { #endif -#define CHACHA20POLY1305_KEY_BYTES (32U) /**< Key length in bytes */ -#define CHACHA20POLY1305_NONCE_BYTES (12U) /**< Nonce length in bytes */ -#define CHACHA20POLY1305_TAG_BYTES (16U) /**< Tag length in bytes */ +#define CHACHA20POLY1305_KEY_BYTES (32U) /**< Key length in bytes */ +#define CHACHA20POLY1305_NONCE_BYTES (12U) /**< Nonce length in bytes */ +#define CHACHA20POLY1305_TAG_BYTES (16U) /**< Tag length in bytes */ /** * @brief Chacha20poly1305 state struct */ -typedef union -{ +typedef union { /* We need both the state matrix and the poly1305 state, but nearly not at * the same time. This works as long as the first 8 members of state * overlap fully or completely not with the first and second key parts * from the @ref poly1305_ctx_t struct */ - uint32_t state[16]; /**< The current state of the key stream. */ - poly1305_ctx_t poly; /**< Poly1305 state for the MAC */ + uint32_t state[16]; /**< The current state of the key stream. */ + poly1305_ctx_t poly; /**< Poly1305 state for the MAC */ } chacha20poly1305_ctx_t; /** diff --git a/sys/include/crypto/ciphers.h b/sys/include/crypto/ciphers.h index 0ad00d3f43..a3487c833c 100644 --- a/sys/include/crypto/ciphers.h +++ b/sys/include/crypto/ciphers.h @@ -148,7 +148,8 @@ int cipher_init(cipher_t *cipher, cipher_id_t cipher_id, const uint8_t *key, * cipher, which is always 1 in case of success * @return A negative value for an error */ -int cipher_encrypt(const cipher_t *cipher, const uint8_t *input, uint8_t *output); +int cipher_encrypt(const cipher_t *cipher, const uint8_t *input, + uint8_t *output); /** @@ -164,7 +165,8 @@ int cipher_encrypt(const cipher_t *cipher, const uint8_t *input, uint8_t *output * cipher, which is always 1 in case of success * @return A negative value for an error */ -int cipher_decrypt(const cipher_t *cipher, const uint8_t *input, uint8_t *output); +int cipher_decrypt(const cipher_t *cipher, const uint8_t *input, + uint8_t *output); /** diff --git a/sys/include/crypto/modes/ccm.h b/sys/include/crypto/modes/ccm.h index aacf2f05a8..19879c43ca 100644 --- a/sys/include/crypto/modes/ccm.h +++ b/sys/include/crypto/modes/ccm.h @@ -57,12 +57,12 @@ extern "C" { * @return Length of encrypted data on a successful encryption * @return A negative error code if something went wrong */ -int cipher_encrypt_ccm(cipher_t* cipher, - const uint8_t* auth_data, uint32_t auth_data_len, +int cipher_encrypt_ccm(cipher_t *cipher, + const uint8_t *auth_data, uint32_t auth_data_len, uint8_t mac_length, uint8_t length_encoding, - const uint8_t* nonce, size_t nonce_len, - const uint8_t* input, size_t input_len, - uint8_t* output); + const uint8_t *nonce, size_t nonce_len, + const uint8_t *input, size_t input_len, + uint8_t *output); /** @@ -86,12 +86,12 @@ int cipher_encrypt_ccm(cipher_t* cipher, * @return Length of the decrypted data on a successful decryption * @return A negative error code if something went wrong */ -int cipher_decrypt_ccm(cipher_t* cipher, - const uint8_t* auth_data, uint32_t auth_data_len, +int cipher_decrypt_ccm(cipher_t *cipher, + const uint8_t *auth_data, uint32_t auth_data_len, uint8_t mac_length, uint8_t length_encoding, - const uint8_t* nonce, size_t nonce_len, - const uint8_t* input, size_t input_len, - uint8_t* output); + const uint8_t *nonce, size_t nonce_len, + const uint8_t *input, size_t input_len, + uint8_t *output); #ifdef __cplusplus } diff --git a/sys/include/crypto/modes/ctr.h b/sys/include/crypto/modes/ctr.h index 45b5223dbc..85f6cce4af 100644 --- a/sys/include/crypto/modes/ctr.h +++ b/sys/include/crypto/modes/ctr.h @@ -44,9 +44,9 @@ extern "C" { * @return Length of encrypted data on a successful encryption * @return A negative error code if something went wrong */ -int cipher_encrypt_ctr(cipher_t* cipher, uint8_t nonce_counter[16], - uint8_t nonce_len, const uint8_t* input, size_t length, - uint8_t* output); +int cipher_encrypt_ctr(cipher_t *cipher, uint8_t nonce_counter[16], + uint8_t nonce_len, const uint8_t *input, size_t length, + uint8_t *output); /** @@ -68,9 +68,9 @@ int cipher_encrypt_ctr(cipher_t* cipher, uint8_t nonce_counter[16], * @return Length of decrypted data on a successful decryption * @return A negative error code if something went wrong */ -int cipher_decrypt_ctr(cipher_t* cipher, uint8_t nonce_counter[16], - uint8_t nonce_len, const uint8_t* input, size_t length, - uint8_t* output); +int cipher_decrypt_ctr(cipher_t *cipher, uint8_t nonce_counter[16], + uint8_t nonce_len, const uint8_t *input, size_t length, + uint8_t *output); #ifdef __cplusplus } diff --git a/sys/include/crypto/modes/ecb.h b/sys/include/crypto/modes/ecb.h index 08a19e7f7a..c89fd47289 100644 --- a/sys/include/crypto/modes/ecb.h +++ b/sys/include/crypto/modes/ecb.h @@ -42,8 +42,8 @@ extern "C" { * @return A negative error code if something went wrong * */ -int cipher_encrypt_ecb(cipher_t* cipher, uint8_t* input, size_t length, - uint8_t* output); +int cipher_encrypt_ecb(cipher_t *cipher, uint8_t *input, size_t length, + uint8_t *output); /** @@ -59,8 +59,8 @@ int cipher_encrypt_ecb(cipher_t* cipher, uint8_t* input, size_t length, * @return Length of decrypted data on a successful decryption * @return A negative error code if something went wrong */ -int cipher_decrypt_ecb(cipher_t* cipher, uint8_t* input, size_t length, - uint8_t* output); +int cipher_decrypt_ecb(cipher_t *cipher, uint8_t *input, size_t length, + uint8_t *output); #ifdef __cplusplus } diff --git a/sys/include/crypto/modes/ocb.h b/sys/include/crypto/modes/ocb.h index 88b8a94c2c..d5afbb80ad 100644 --- a/sys/include/crypto/modes/ocb.h +++ b/sys/include/crypto/modes/ocb.h @@ -77,7 +77,8 @@ extern "C" { * It has to be of size data_len + tag_len. * @return Length of the encrypted data (including the tag) or a (negative) error code */ -int32_t cipher_encrypt_ocb(cipher_t *cipher, uint8_t *auth_data, size_t auth_data_len, +int32_t cipher_encrypt_ocb(cipher_t *cipher, uint8_t *auth_data, + size_t auth_data_len, uint8_t tag_len, uint8_t *nonce, size_t nonce_len, uint8_t *input, size_t input_len, uint8_t *output); @@ -99,7 +100,8 @@ int32_t cipher_encrypt_ocb(cipher_t *cipher, uint8_t *auth_data, size_t auth_dat * Will contain only zeroes, if the authentication fails. * @return Length of the plaintext data or a (negative) error code */ -int32_t cipher_decrypt_ocb(cipher_t *cipher, uint8_t *auth_data, size_t auth_data_len, +int32_t cipher_decrypt_ocb(cipher_t *cipher, uint8_t *auth_data, + size_t auth_data_len, uint8_t tag_len, uint8_t *nonce, size_t nonce_len, uint8_t *input, size_t input_len, uint8_t *output); #ifdef __cplusplus diff --git a/tests/sys_crypto/tests-crypto-aes.c b/tests/sys_crypto/tests-crypto-aes.c index 7308f19737..f7b3e23d6d 100644 --- a/tests/sys_crypto/tests-crypto-aes.c +++ b/tests/sys_crypto/tests-crypto-aes.c @@ -51,14 +51,16 @@ static void test_crypto_aes_encrypt(void) err = aes_encrypt(&ctx, TEST_0_INP, data); TEST_ASSERT_EQUAL_INT(1, err); - TEST_ASSERT_MESSAGE(1 == compare(TEST_0_ENC, data, AES_BLOCK_SIZE), "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == compare(TEST_0_ENC, data, + AES_BLOCK_SIZE), "wrong ciphertext"); err = aes_init(&ctx, TEST_1_KEY, sizeof(TEST_1_KEY)); TEST_ASSERT_EQUAL_INT(1, err); err = aes_encrypt(&ctx, TEST_1_INP, data); TEST_ASSERT_EQUAL_INT(1, err); - TEST_ASSERT_MESSAGE(1 == compare(TEST_1_ENC, data, AES_BLOCK_SIZE), "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == compare(TEST_1_ENC, data, + AES_BLOCK_SIZE), "wrong ciphertext"); } static void test_crypto_aes_decrypt(void) @@ -72,14 +74,16 @@ static void test_crypto_aes_decrypt(void) err = aes_decrypt(&ctx, TEST_0_ENC, data); TEST_ASSERT_EQUAL_INT(1, err); - TEST_ASSERT_MESSAGE(1 == compare(TEST_0_INP, data, AES_BLOCK_SIZE), "wrong plaintext"); + TEST_ASSERT_MESSAGE(1 == compare(TEST_0_INP, data, + AES_BLOCK_SIZE), "wrong plaintext"); err = aes_init(&ctx, TEST_1_KEY, sizeof(TEST_1_KEY)); TEST_ASSERT_EQUAL_INT(1, err); err = aes_decrypt(&ctx, TEST_1_ENC, data); TEST_ASSERT_EQUAL_INT(1, err); - TEST_ASSERT_MESSAGE(1 == compare(TEST_1_INP, data, AES_BLOCK_SIZE), "wrong plaintext"); + TEST_ASSERT_MESSAGE(1 == compare(TEST_1_INP, data, + AES_BLOCK_SIZE), "wrong plaintext"); } static void test_crypto_aes_init_key_length(void) diff --git a/tests/sys_crypto/tests-crypto-chacha.c b/tests/sys_crypto/tests-crypto-chacha.c index 5063493bee..0097239613 100644 --- a/tests/sys_crypto/tests-crypto-chacha.c +++ b/tests/sys_crypto/tests-crypto-chacha.c @@ -97,7 +97,8 @@ static const uint8_t TC8_CHACHA20_BLOCK1[64] = { static void _test_crypto_chacha(unsigned rounds, unsigned keylen, const uint8_t key[32], const uint8_t iv[8], const uint32_t after_init[16], - const uint8_t block0[64], const uint8_t block1[64]) + const uint8_t block0[64], + const uint8_t block1[64]) { chacha_ctx ctx; uint8_t block[64]; @@ -138,5 +139,5 @@ Test *tests_crypto_chacha_tests(void) new_TestFixture(test_crypto_chacha20_tc8), }; EMB_UNIT_TESTCALLER(crypto_chacha_tests, NULL, NULL, fixtures); - return (Test *) &crypto_chacha_tests; + return (Test *)&crypto_chacha_tests; } diff --git a/tests/sys_crypto/tests-crypto-cipher.c b/tests/sys_crypto/tests-crypto-cipher.c index 30f2bf515b..7337bc364a 100644 --- a/tests/sys_crypto/tests-crypto-cipher.c +++ b/tests/sys_crypto/tests-crypto-cipher.c @@ -78,13 +78,19 @@ static void test_crypto_cipher_init_aes_key_length(void) uint8_t unsupported_key_3[8]; memset(unsupported_key_3, 0, sizeof(unsupported_key_3)); - err = cipher_init(&cipher, CIPHER_AES_128, unsupported_key_1, sizeof(unsupported_key_1)); + err = + cipher_init(&cipher, CIPHER_AES_128, unsupported_key_1, + sizeof(unsupported_key_1)); TEST_ASSERT_EQUAL_INT(CIPHER_ERR_INVALID_KEY_SIZE, err); - err = cipher_init(&cipher, CIPHER_AES_128, unsupported_key_2, sizeof(unsupported_key_2)); + err = + cipher_init(&cipher, CIPHER_AES_128, unsupported_key_2, + sizeof(unsupported_key_2)); TEST_ASSERT_EQUAL_INT(CIPHER_ERR_INVALID_KEY_SIZE, err); - err = cipher_init(&cipher, CIPHER_AES_128, unsupported_key_3, sizeof(unsupported_key_3)); + err = + cipher_init(&cipher, CIPHER_AES_128, unsupported_key_3, + sizeof(unsupported_key_3)); TEST_ASSERT_EQUAL_INT(CIPHER_ERR_INVALID_KEY_SIZE, err); } diff --git a/tests/sys_crypto/tests-crypto-helper.c b/tests/sys_crypto/tests-crypto-helper.c index c9cf8d781a..aff5232d0f 100644 --- a/tests/sys_crypto/tests-crypto-helper.c +++ b/tests/sys_crypto/tests-crypto-helper.c @@ -34,5 +34,5 @@ Test *tests_crypto_helper_tests(void) new_TestFixture(test_crypto_wipe), }; EMB_UNIT_TESTCALLER(crypto_helper_tests, NULL, NULL, fixtures); - return (Test *) &crypto_helper_tests; + return (Test *)&crypto_helper_tests; } diff --git a/tests/sys_crypto/tests-crypto-modes-cbc.c b/tests/sys_crypto/tests-crypto-modes-cbc.c index e746e394ea..c4c0ef618f 100644 --- a/tests/sys_crypto/tests-crypto-modes-cbc.c +++ b/tests/sys_crypto/tests-crypto-modes-cbc.c @@ -61,8 +61,8 @@ static uint8_t TEST_1_CIPHER[] = { }; static uint8_t TEST_1_CIPHER_LEN = 64; -static void test_encrypt_op(uint8_t* key, uint8_t key_len, uint8_t iv[16], - uint8_t* input, uint8_t input_len, uint8_t* output, +static void test_encrypt_op(uint8_t *key, uint8_t key_len, uint8_t iv[16], + uint8_t *input, uint8_t input_len, uint8_t *output, uint8_t output_len) { cipher_t cipher; @@ -77,12 +77,12 @@ static void test_encrypt_op(uint8_t* key, uint8_t key_len, uint8_t iv[16], TEST_ASSERT_EQUAL_INT(output_len, len); cmp = compare(output, data, len); - TEST_ASSERT_MESSAGE(1 == cmp , "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == cmp, "wrong ciphertext"); } -static void test_decrypt_op(uint8_t* key, uint8_t key_len, uint8_t iv[16], - uint8_t* input, uint8_t input_len, uint8_t* output, +static void test_decrypt_op(uint8_t *key, uint8_t key_len, uint8_t iv[16], + uint8_t *input, uint8_t input_len, uint8_t *output, uint8_t output_len) { cipher_t cipher; @@ -97,7 +97,7 @@ static void test_decrypt_op(uint8_t* key, uint8_t key_len, uint8_t iv[16], TEST_ASSERT_EQUAL_INT(output_len, len); cmp = compare(output, data, len); - TEST_ASSERT_MESSAGE(1 == cmp , "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == cmp, "wrong ciphertext"); } @@ -114,14 +114,14 @@ static void test_crypto_modes_cbc_decrypt(void) } -Test* tests_crypto_modes_cbc_tests(void) +Test *tests_crypto_modes_cbc_tests(void) { EMB_UNIT_TESTFIXTURES(fixtures) { new_TestFixture(test_crypto_modes_cbc_encrypt), - new_TestFixture(test_crypto_modes_cbc_decrypt) + new_TestFixture(test_crypto_modes_cbc_decrypt) }; EMB_UNIT_TESTCALLER(crypto_modes_cbc_tests, NULL, NULL, fixtures); - return (Test*)&crypto_modes_cbc_tests; + return (Test *)&crypto_modes_cbc_tests; } diff --git a/tests/sys_crypto/tests-crypto-modes-ccm.c b/tests/sys_crypto/tests-crypto-modes-ccm.c index 7f54e80701..ac2096dc73 100644 --- a/tests/sys_crypto/tests-crypto-modes-ccm.c +++ b/tests/sys_crypto/tests-crypto-modes-ccm.c @@ -826,11 +826,11 @@ static const size_t TEST_NIST_3_EXPECTED_LEN = 52; /* Share test buffer output */ static uint8_t data[60]; -static void test_encrypt_op(const uint8_t* key, uint8_t key_len, - const uint8_t* adata, size_t adata_len, - const uint8_t* nonce, uint8_t nonce_len, - const uint8_t* plain, size_t plain_len, - const uint8_t* output_expected, +static void test_encrypt_op(const uint8_t *key, uint8_t key_len, + const uint8_t *adata, size_t adata_len, + const uint8_t *nonce, uint8_t nonce_len, + const uint8_t *plain, size_t plain_len, + const uint8_t *output_expected, size_t output_expected_len, uint8_t mac_length) { @@ -851,15 +851,15 @@ static void test_encrypt_op(const uint8_t* key, uint8_t key_len, TEST_ASSERT_EQUAL_INT(output_expected_len, len); cmp = compare(output_expected, data, len); - TEST_ASSERT_MESSAGE(1 == cmp , "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == cmp, "wrong ciphertext"); } -static void test_decrypt_op(const uint8_t* key, uint8_t key_len, - const uint8_t* adata, size_t adata_len, - const uint8_t* nonce, uint8_t nonce_len, - const uint8_t* encrypted, size_t encrypted_len, - const uint8_t* output_expected, +static void test_decrypt_op(const uint8_t *key, uint8_t key_len, + const uint8_t *adata, size_t adata_len, + const uint8_t *nonce, uint8_t nonce_len, + const uint8_t *encrypted, size_t encrypted_len, + const uint8_t *output_expected, size_t output_expected_len, uint8_t mac_length) { @@ -880,23 +880,23 @@ static void test_decrypt_op(const uint8_t* key, uint8_t key_len, TEST_ASSERT_EQUAL_INT(output_expected_len, len); cmp = compare(output_expected, data, len); - TEST_ASSERT_MESSAGE(1 == cmp , "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == cmp, "wrong ciphertext"); } #define do_test_encrypt_op(name) do { \ - test_encrypt_op(TEST_##name##_KEY, TEST_##name##_KEY_LEN, \ - TEST_##name##_INPUT, TEST_##name##_ADATA_LEN, \ - TEST_##name##_NONCE, TEST_##name##_NONCE_LEN, \ + test_encrypt_op(TEST_ ## name ## _KEY, TEST_ ## name ## _KEY_LEN, \ + TEST_ ## name ## _INPUT, TEST_ ## name ## _ADATA_LEN, \ + TEST_ ## name ## _NONCE, TEST_ ## name ## _NONCE_LEN, \ \ - TEST_##name##_INPUT + TEST_##name##_ADATA_LEN, \ - TEST_##name##_INPUT_LEN, \ + TEST_ ## name ## _INPUT + TEST_ ## name ## _ADATA_LEN, \ + TEST_ ## name ## _INPUT_LEN, \ \ - TEST_##name##_EXPECTED + TEST_##name##_ADATA_LEN, \ - TEST_##name##_EXPECTED_LEN - TEST_##name##_ADATA_LEN, \ + TEST_ ## name ## _EXPECTED + TEST_ ## name ## _ADATA_LEN, \ + TEST_ ## name ## _EXPECTED_LEN - TEST_ ## name ## _ADATA_LEN, \ \ - TEST_##name##_MAC_LEN \ - ); \ + TEST_ ## name ## _MAC_LEN \ + ); \ } while (0) @@ -933,18 +933,18 @@ static void test_crypto_modes_ccm_encrypt(void) } #define do_test_decrypt_op(name) do { \ - test_decrypt_op(TEST_##name##_KEY, TEST_##name##_KEY_LEN, \ - TEST_##name##_INPUT, TEST_##name##_ADATA_LEN, \ - TEST_##name##_NONCE, TEST_##name##_NONCE_LEN, \ + test_decrypt_op(TEST_ ## name ## _KEY, TEST_ ## name ## _KEY_LEN, \ + TEST_ ## name ## _INPUT, TEST_ ## name ## _ADATA_LEN, \ + TEST_ ## name ## _NONCE, TEST_ ## name ## _NONCE_LEN, \ \ - TEST_##name##_EXPECTED + TEST_##name##_ADATA_LEN, \ - TEST_##name##_EXPECTED_LEN - TEST_##name##_ADATA_LEN, \ + TEST_ ## name ## _EXPECTED + TEST_ ## name ## _ADATA_LEN, \ + TEST_ ## name ## _EXPECTED_LEN - TEST_ ## name ## _ADATA_LEN, \ \ - TEST_##name##_INPUT + TEST_##name##_ADATA_LEN, \ - TEST_##name##_INPUT_LEN, \ + TEST_ ## name ## _INPUT + TEST_ ## name ## _ADATA_LEN, \ + TEST_ ## name ## _INPUT_LEN, \ \ - TEST_##name##_MAC_LEN \ - ); \ + TEST_ ## name ## _MAC_LEN \ + ); \ } while (0) static void test_crypto_modes_ccm_decrypt(void) @@ -980,20 +980,22 @@ static void test_crypto_modes_ccm_decrypt(void) } -typedef int (*func_ccm_t)(cipher_t*, const uint8_t*, uint32_t, - uint8_t, uint8_t, const uint8_t*, size_t, - const uint8_t*, size_t, uint8_t*); +typedef int (*func_ccm_t)(cipher_t *, const uint8_t *, uint32_t, + uint8_t, uint8_t, const uint8_t *, size_t, + const uint8_t *, size_t, uint8_t *); static int _test_ccm_len(func_ccm_t func, uint8_t len_encoding, - const uint8_t *input, size_t input_len, size_t adata_len) + const uint8_t *input, size_t input_len, + size_t adata_len) { int ret; cipher_t cipher; uint8_t mac_length = 8; - uint8_t nonce[15] = {0}; - uint8_t key[16] = {0}; + uint8_t nonce[15] = { 0 }; + uint8_t key[16] = { 0 }; uint8_t nonce_len = nonce_and_len_encoding_size - len_encoding; + cipher_init(&cipher, CIPHER_AES_128, key, 16); ret = func(&cipher, NULL, adata_len, mac_length, len_encoding, @@ -1006,6 +1008,7 @@ static int _test_ccm_len(func_ccm_t func, uint8_t len_encoding, static void test_crypto_modes_ccm_check_len(void) { int ret; + /* Just 1 to big to fit */ ret = _test_ccm_len(cipher_encrypt_ccm, 2, NULL, 1 << 16, 0); TEST_ASSERT_EQUAL_INT(CCM_ERR_INVALID_LENGTH_ENCODING, ret); @@ -1044,7 +1047,7 @@ static void test_crypto_modes_ccm_check_len(void) } -Test* tests_crypto_modes_ccm_tests(void) +Test *tests_crypto_modes_ccm_tests(void) { EMB_UNIT_TESTFIXTURES(fixtures) { new_TestFixture(test_crypto_modes_ccm_encrypt), @@ -1054,5 +1057,5 @@ Test* tests_crypto_modes_ccm_tests(void) EMB_UNIT_TESTCALLER(crypto_modes_ccm_tests, NULL, NULL, fixtures); - return (Test*)&crypto_modes_ccm_tests; + return (Test *)&crypto_modes_ccm_tests; } diff --git a/tests/sys_crypto/tests-crypto-modes-ctr.c b/tests/sys_crypto/tests-crypto-modes-ctr.c index 757b2d530f..ee506ae8a6 100644 --- a/tests/sys_crypto/tests-crypto-modes-ctr.c +++ b/tests/sys_crypto/tests-crypto-modes-ctr.c @@ -61,8 +61,8 @@ static uint8_t TEST_1_CIPHER[] = { }; static uint8_t TEST_1_CIPHER_LEN = 64; -static void test_encrypt_op(uint8_t* key, uint8_t key_len, uint8_t ctr[16], - uint8_t* input, uint8_t input_len, uint8_t* output, +static void test_encrypt_op(uint8_t *key, uint8_t key_len, uint8_t ctr[16], + uint8_t *input, uint8_t input_len, uint8_t *output, uint8_t output_len) { cipher_t cipher; @@ -77,12 +77,12 @@ static void test_encrypt_op(uint8_t* key, uint8_t key_len, uint8_t ctr[16], TEST_ASSERT_EQUAL_INT(output_len, len); cmp = compare(output, data, len); - TEST_ASSERT_MESSAGE(1 == cmp , "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == cmp, "wrong ciphertext"); } -static void test_decrypt_op(uint8_t* key, uint8_t key_len, uint8_t ctr[16], - uint8_t* input, uint8_t input_len, uint8_t* output, +static void test_decrypt_op(uint8_t *key, uint8_t key_len, uint8_t ctr[16], + uint8_t *input, uint8_t input_len, uint8_t *output, uint8_t output_len) { cipher_t cipher; @@ -97,7 +97,7 @@ static void test_decrypt_op(uint8_t* key, uint8_t key_len, uint8_t ctr[16], TEST_ASSERT_EQUAL_INT(output_len, len); cmp = compare(output, data, len); - TEST_ASSERT_MESSAGE(1 == cmp , "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == cmp, "wrong ciphertext"); } @@ -120,14 +120,14 @@ static void test_crypto_modes_ctr_decrypt(void) } -Test* tests_crypto_modes_ctr_tests(void) +Test *tests_crypto_modes_ctr_tests(void) { EMB_UNIT_TESTFIXTURES(fixtures) { new_TestFixture(test_crypto_modes_ctr_encrypt), - new_TestFixture(test_crypto_modes_ctr_decrypt) + new_TestFixture(test_crypto_modes_ctr_decrypt) }; EMB_UNIT_TESTCALLER(crypto_modes_ctr_tests, NULL, NULL, fixtures); - return (Test*)&crypto_modes_ctr_tests; + return (Test *)&crypto_modes_ctr_tests; } diff --git a/tests/sys_crypto/tests-crypto-modes-ecb.c b/tests/sys_crypto/tests-crypto-modes-ecb.c index c259850158..c7091bddcd 100644 --- a/tests/sys_crypto/tests-crypto-modes-ecb.c +++ b/tests/sys_crypto/tests-crypto-modes-ecb.c @@ -56,8 +56,8 @@ static uint8_t TEST_1_CIPHER[] = { }; static uint8_t TEST_1_CIPHER_LEN = 64; -static void test_encrypt_op(uint8_t* key, uint8_t key_len, uint8_t* input, - uint8_t input_len, uint8_t* output, +static void test_encrypt_op(uint8_t *key, uint8_t key_len, uint8_t *input, + uint8_t input_len, uint8_t *output, uint8_t output_len) { cipher_t cipher; @@ -72,12 +72,12 @@ static void test_encrypt_op(uint8_t* key, uint8_t key_len, uint8_t* input, TEST_ASSERT_EQUAL_INT(output_len, len); cmp = compare(output, data, len); - TEST_ASSERT_MESSAGE(1 == cmp , "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == cmp, "wrong ciphertext"); } -static void test_decrypt_op(uint8_t* key, uint8_t key_len, uint8_t* input, - uint8_t input_len, uint8_t* output, +static void test_decrypt_op(uint8_t *key, uint8_t key_len, uint8_t *input, + uint8_t input_len, uint8_t *output, uint8_t output_len) { cipher_t cipher; @@ -92,7 +92,7 @@ static void test_decrypt_op(uint8_t* key, uint8_t key_len, uint8_t* input, TEST_ASSERT_EQUAL_INT(output_len, len); cmp = compare(output, data, len); - TEST_ASSERT_MESSAGE(1 == cmp , "wrong ciphertext"); + TEST_ASSERT_MESSAGE(1 == cmp, "wrong ciphertext"); } @@ -104,19 +104,20 @@ static void test_crypto_modes_ecb_encrypt(void) static void test_crypto_modes_ecb_decrypt(void) { - test_decrypt_op(TEST_1_KEY, TEST_1_KEY_LEN, TEST_1_CIPHER, TEST_1_CIPHER_LEN, + test_decrypt_op(TEST_1_KEY, TEST_1_KEY_LEN, TEST_1_CIPHER, + TEST_1_CIPHER_LEN, TEST_1_PLAIN, TEST_1_PLAIN_LEN); } -Test* tests_crypto_modes_ecb_tests(void) +Test *tests_crypto_modes_ecb_tests(void) { EMB_UNIT_TESTFIXTURES(fixtures) { new_TestFixture(test_crypto_modes_ecb_encrypt), - new_TestFixture(test_crypto_modes_ecb_decrypt) + new_TestFixture(test_crypto_modes_ecb_decrypt) }; EMB_UNIT_TESTCALLER(crypto_modes_ecb_tests, NULL, NULL, fixtures); - return (Test*)&crypto_modes_ecb_tests; + return (Test *)&crypto_modes_ecb_tests; } diff --git a/tests/sys_crypto/tests-crypto-modes-ocb.c b/tests/sys_crypto/tests-crypto-modes-ocb.c index 16aa62258e..ac9403d0ca 100644 --- a/tests/sys_crypto/tests-crypto-modes-ocb.c +++ b/tests/sys_crypto/tests-crypto-modes-ocb.c @@ -414,16 +414,20 @@ static void test_crypto_modes_ocb_bad_parameter_values(void) cipher_init(&cipher, CIPHER_AES_128, key, 16); /* tag length must be positive */ - int rv = cipher_encrypt_ocb(&cipher, auth_data, sizeof(auth_data), 0, nonce, 15, input, sizeof(input), output); + int rv = cipher_encrypt_ocb(&cipher, auth_data, sizeof(auth_data), 0, nonce, + 15, input, sizeof(input), output); TEST_ASSERT_EQUAL_INT(OCB_ERR_INVALID_TAG_LENGTH, rv); /* tag length must be <= 16 */ - rv = cipher_encrypt_ocb(&cipher, auth_data, sizeof(auth_data), 17, nonce, 15, input, sizeof(input), output); + rv = cipher_encrypt_ocb(&cipher, auth_data, sizeof(auth_data), 17, nonce, + 15, input, sizeof(input), output); TEST_ASSERT_EQUAL_INT(OCB_ERR_INVALID_TAG_LENGTH, rv); /* nonce must not be empty */ - rv = cipher_encrypt_ocb(&cipher, auth_data, sizeof(auth_data), 16, nonce, 0, input, sizeof(input), output); + rv = cipher_encrypt_ocb(&cipher, auth_data, sizeof(auth_data), 16, nonce, 0, + input, sizeof(input), output); TEST_ASSERT_EQUAL_INT(OCB_ERR_INVALID_NONCE_LENGTH, rv); /* nonce must be <=15 */ - rv = cipher_encrypt_ocb(&cipher, auth_data, sizeof(auth_data), 16, nonce, 16, input, sizeof(input), output); + rv = cipher_encrypt_ocb(&cipher, auth_data, sizeof(auth_data), 16, nonce, + 16, input, sizeof(input), output); TEST_ASSERT_EQUAL_INT(OCB_ERR_INVALID_NONCE_LENGTH, rv); }