1250 lines
41 KiB
C
1250 lines
41 KiB
C
/* BEGIN_HEADER */
|
|
#include "mbedtls/cipher.h"
|
|
#include "mbedtls/aes.h"
|
|
|
|
#if defined(MBEDTLS_GCM_C)
|
|
#include "mbedtls/gcm.h"
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C)
|
|
#define MBEDTLS_CIPHER_AUTH_CRYPT
|
|
#endif
|
|
|
|
/* Check the internal consistency of a cipher info structure, and
|
|
* check it against mbedtls_cipher_info_from_xxx(). */
|
|
static int check_cipher_info(mbedtls_cipher_type_t type,
|
|
const mbedtls_cipher_info_t *info)
|
|
{
|
|
size_t key_bitlen, block_size, iv_size;
|
|
|
|
TEST_ASSERT(info != NULL);
|
|
TEST_EQUAL(type, mbedtls_cipher_info_get_type(info));
|
|
TEST_EQUAL(type, info->type);
|
|
TEST_ASSERT(mbedtls_cipher_info_from_type(type) == info);
|
|
|
|
TEST_EQUAL(info->mode, mbedtls_cipher_info_get_mode(info));
|
|
|
|
/* Insist that get_name() return the string from the structure and
|
|
* not a copy. A copy would have an unknown storage duration. */
|
|
TEST_ASSERT(mbedtls_cipher_info_get_name(info) == info->name);
|
|
TEST_ASSERT(mbedtls_cipher_info_from_string(info->name) == info);
|
|
|
|
key_bitlen = mbedtls_cipher_info_get_key_bitlen(info);
|
|
block_size = mbedtls_cipher_info_get_block_size(info);
|
|
iv_size = mbedtls_cipher_info_get_iv_size(info);
|
|
if (info->type == MBEDTLS_CIPHER_NULL) {
|
|
TEST_ASSERT(key_bitlen == 0);
|
|
TEST_ASSERT(block_size == 1);
|
|
TEST_ASSERT(iv_size == 0);
|
|
} else if (info->mode == MBEDTLS_MODE_XTS) {
|
|
TEST_ASSERT(key_bitlen == 256 ||
|
|
key_bitlen == 384 ||
|
|
key_bitlen == 512);
|
|
} else if (!strncmp(info->name, "DES-EDE3-", 9)) {
|
|
TEST_ASSERT(key_bitlen == 192);
|
|
TEST_ASSERT(!mbedtls_cipher_info_has_variable_key_bitlen(info));
|
|
TEST_ASSERT(block_size == 8);
|
|
} else if (!strncmp(info->name, "DES-EDE-", 8)) {
|
|
TEST_ASSERT(key_bitlen == 128);
|
|
TEST_ASSERT(!mbedtls_cipher_info_has_variable_key_bitlen(info));
|
|
TEST_ASSERT(block_size == 8);
|
|
} else if (!strncmp(info->name, "DES-", 4)) {
|
|
TEST_ASSERT(key_bitlen == 64);
|
|
TEST_ASSERT(!mbedtls_cipher_info_has_variable_key_bitlen(info));
|
|
TEST_ASSERT(block_size == 8);
|
|
} else if (!strncmp(info->name, "AES", 3)) {
|
|
TEST_ASSERT(key_bitlen == 128 ||
|
|
key_bitlen == 192 ||
|
|
key_bitlen == 256);
|
|
TEST_ASSERT(!mbedtls_cipher_info_has_variable_key_bitlen(info));
|
|
TEST_ASSERT(block_size == 16);
|
|
} else {
|
|
TEST_ASSERT(key_bitlen == 128 ||
|
|
key_bitlen == 192 ||
|
|
key_bitlen == 256);
|
|
}
|
|
TEST_LE_U(key_bitlen, MBEDTLS_MAX_KEY_LENGTH * 8);
|
|
TEST_LE_U(block_size, MBEDTLS_MAX_BLOCK_LENGTH);
|
|
TEST_LE_U(iv_size, MBEDTLS_MAX_IV_LENGTH);
|
|
|
|
if (strstr(info->name, "-ECB") != NULL) {
|
|
TEST_ASSERT(iv_size == 0);
|
|
TEST_ASSERT(!mbedtls_cipher_info_has_variable_iv_size(info));
|
|
} else if (strstr(info->name, "-CBC") != NULL ||
|
|
strstr(info->name, "-CTR") != NULL) {
|
|
TEST_ASSERT(iv_size == block_size);
|
|
TEST_ASSERT(!mbedtls_cipher_info_has_variable_iv_size(info));
|
|
} else if (strstr(info->name, "-GCM") != NULL) {
|
|
TEST_ASSERT(iv_size == block_size - 4);
|
|
TEST_ASSERT(mbedtls_cipher_info_has_variable_iv_size(info));
|
|
}
|
|
|
|
return 1;
|
|
|
|
exit:
|
|
return 0;
|
|
}
|
|
|
|
#if defined(MBEDTLS_CIPHER_AUTH_CRYPT)
|
|
/* Helper for resetting key/direction
|
|
*
|
|
* The documentation doesn't explicitly say whether calling
|
|
* mbedtls_cipher_setkey() twice is allowed or not. This currently works with
|
|
* the default software implementation, but only by accident. It isn't
|
|
* guaranteed to work with new ciphers or with alternative implementations of
|
|
* individual ciphers, and it doesn't work with the PSA wrappers. So don't do
|
|
* it, and instead start with a fresh context.
|
|
*/
|
|
static int cipher_reset_key(mbedtls_cipher_context_t *ctx, int cipher_id,
|
|
int use_psa, size_t tag_len, const data_t *key, int direction)
|
|
{
|
|
mbedtls_cipher_free(ctx);
|
|
mbedtls_cipher_init(ctx);
|
|
|
|
#if !defined(MBEDTLS_USE_PSA_CRYPTO) || !defined(MBEDTLS_TEST_DEPRECATED)
|
|
(void) use_psa;
|
|
(void) tag_len;
|
|
#else
|
|
if (use_psa == 1) {
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup_psa(ctx,
|
|
mbedtls_cipher_info_from_type(cipher_id),
|
|
tag_len));
|
|
} else
|
|
#endif /* !MBEDTLS_USE_PSA_CRYPTO || !MBEDTLS_TEST_DEPRECATED */
|
|
{
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(ctx,
|
|
mbedtls_cipher_info_from_type(cipher_id)));
|
|
}
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(ctx, key->x, 8 * key->len,
|
|
direction));
|
|
return 1;
|
|
|
|
exit:
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Check if a buffer is all-0 bytes:
|
|
* return 1 if it is,
|
|
* 0 if it isn't.
|
|
*/
|
|
int buffer_is_all_zero(const uint8_t *buf, size_t size)
|
|
{
|
|
for (size_t i = 0; i < size; i++) {
|
|
if (buf[i] != 0) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
#endif /* MBEDTLS_CIPHER_AUTH_CRYPT */
|
|
|
|
/* END_HEADER */
|
|
|
|
/* BEGIN_DEPENDENCIES
|
|
* depends_on:MBEDTLS_CIPHER_C
|
|
* END_DEPENDENCIES
|
|
*/
|
|
|
|
/* BEGIN_CASE */
|
|
void mbedtls_cipher_list()
|
|
{
|
|
const int *cipher_type;
|
|
|
|
for (cipher_type = mbedtls_cipher_list(); *cipher_type != 0; cipher_type++) {
|
|
const mbedtls_cipher_info_t *info =
|
|
mbedtls_cipher_info_from_type(*cipher_type);
|
|
mbedtls_test_set_step(*cipher_type);
|
|
if (!check_cipher_info(*cipher_type, info)) {
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void cipher_invalid_param_unconditional()
|
|
{
|
|
mbedtls_cipher_context_t valid_ctx;
|
|
mbedtls_cipher_context_t invalid_ctx;
|
|
mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
|
|
mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
|
|
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
|
int valid_size = sizeof(valid_buffer);
|
|
int valid_bitlen = valid_size * 8;
|
|
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
|
|
*(mbedtls_cipher_list()));
|
|
size_t size_t_var;
|
|
|
|
(void) valid_mode; /* In some configurations this is unused */
|
|
|
|
mbedtls_cipher_init(&valid_ctx);
|
|
mbedtls_cipher_init(&invalid_ctx);
|
|
|
|
TEST_ASSERT(mbedtls_cipher_setup(&valid_ctx, valid_info) == 0);
|
|
|
|
/* mbedtls_cipher_setup() */
|
|
TEST_ASSERT(mbedtls_cipher_setup(&valid_ctx, NULL) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
|
|
/* mbedtls_cipher_get_block_size() */
|
|
TEST_ASSERT(mbedtls_cipher_get_block_size(&invalid_ctx) == 0);
|
|
|
|
/* mbedtls_cipher_get_cipher_mode() */
|
|
TEST_ASSERT(mbedtls_cipher_get_cipher_mode(&invalid_ctx) ==
|
|
MBEDTLS_MODE_NONE);
|
|
|
|
/* mbedtls_cipher_get_iv_size() */
|
|
TEST_ASSERT(mbedtls_cipher_get_iv_size(&invalid_ctx) == 0);
|
|
|
|
/* mbedtls_cipher_get_type() */
|
|
TEST_ASSERT(
|
|
mbedtls_cipher_get_type(&invalid_ctx) ==
|
|
MBEDTLS_CIPHER_NONE);
|
|
|
|
/* mbedtls_cipher_get_name() */
|
|
TEST_ASSERT(mbedtls_cipher_get_name(&invalid_ctx) == 0);
|
|
|
|
/* mbedtls_cipher_get_key_bitlen() */
|
|
TEST_ASSERT(mbedtls_cipher_get_key_bitlen(&invalid_ctx) ==
|
|
MBEDTLS_KEY_LENGTH_NONE);
|
|
|
|
/* mbedtls_cipher_get_operation() */
|
|
TEST_ASSERT(mbedtls_cipher_get_operation(&invalid_ctx) ==
|
|
MBEDTLS_OPERATION_NONE);
|
|
|
|
/* mbedtls_cipher_setkey() */
|
|
TEST_ASSERT(
|
|
mbedtls_cipher_setkey(&invalid_ctx,
|
|
valid_buffer,
|
|
valid_bitlen,
|
|
valid_operation) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
|
|
/* mbedtls_cipher_set_iv() */
|
|
TEST_ASSERT(
|
|
mbedtls_cipher_set_iv(&invalid_ctx,
|
|
valid_buffer,
|
|
valid_size) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
|
|
/* mbedtls_cipher_reset() */
|
|
TEST_ASSERT(mbedtls_cipher_reset(&invalid_ctx) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
/* mbedtls_cipher_update_ad() */
|
|
TEST_ASSERT(
|
|
mbedtls_cipher_update_ad(&invalid_ctx,
|
|
valid_buffer,
|
|
valid_size) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
|
|
|
|
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
|
|
/* mbedtls_cipher_set_padding_mode() */
|
|
TEST_ASSERT(mbedtls_cipher_set_padding_mode(&invalid_ctx, valid_mode) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
#endif
|
|
|
|
/* mbedtls_cipher_update() */
|
|
TEST_ASSERT(
|
|
mbedtls_cipher_update(&invalid_ctx,
|
|
valid_buffer,
|
|
valid_size,
|
|
valid_buffer,
|
|
&size_t_var) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
|
|
/* mbedtls_cipher_finish() */
|
|
TEST_ASSERT(
|
|
mbedtls_cipher_finish(&invalid_ctx,
|
|
valid_buffer,
|
|
&size_t_var) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
/* mbedtls_cipher_write_tag() */
|
|
TEST_ASSERT(
|
|
mbedtls_cipher_write_tag(&invalid_ctx,
|
|
valid_buffer,
|
|
valid_size) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
|
|
/* mbedtls_cipher_check_tag() */
|
|
TEST_ASSERT(
|
|
mbedtls_cipher_check_tag(&invalid_ctx,
|
|
valid_buffer,
|
|
valid_size) ==
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
|
|
|
|
exit:
|
|
mbedtls_cipher_free(&invalid_ctx);
|
|
mbedtls_cipher_free(&valid_ctx);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void cipher_invalid_param_conditional()
|
|
{
|
|
mbedtls_cipher_context_t valid_ctx;
|
|
|
|
mbedtls_operation_t invalid_operation = 100;
|
|
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
|
int valid_size = sizeof(valid_buffer);
|
|
int valid_bitlen = valid_size * 8;
|
|
|
|
TEST_EQUAL(
|
|
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
|
mbedtls_cipher_setkey(&valid_ctx,
|
|
valid_buffer,
|
|
valid_bitlen,
|
|
invalid_operation));
|
|
|
|
exit:
|
|
;
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
|
|
void cipher_special_behaviours()
|
|
{
|
|
const mbedtls_cipher_info_t *cipher_info;
|
|
mbedtls_cipher_context_t ctx;
|
|
unsigned char input[32];
|
|
unsigned char output[32];
|
|
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
|
unsigned char iv[32];
|
|
#endif
|
|
size_t olen = 0;
|
|
|
|
mbedtls_cipher_init(&ctx);
|
|
memset(input, 0, sizeof(input));
|
|
memset(output, 0, sizeof(output));
|
|
#if defined(MBEDTLS_CIPHER_MODE_CBC)
|
|
memset(iv, 0, sizeof(iv));
|
|
|
|
/* Check and get info structures */
|
|
cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_CBC);
|
|
TEST_ASSERT(NULL != cipher_info);
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx, cipher_info));
|
|
|
|
/* IV too big */
|
|
TEST_ASSERT(mbedtls_cipher_set_iv(&ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1)
|
|
== MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE);
|
|
|
|
/* IV too small */
|
|
TEST_ASSERT(mbedtls_cipher_set_iv(&ctx, iv, 0)
|
|
== MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
|
|
mbedtls_cipher_free(&ctx);
|
|
mbedtls_cipher_init(&ctx);
|
|
#endif /* MBEDTLS_CIPHER_MODE_CBC */
|
|
cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_ECB);
|
|
TEST_ASSERT(NULL != cipher_info);
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx, cipher_info));
|
|
|
|
/* Update ECB with partial block */
|
|
TEST_ASSERT(mbedtls_cipher_update(&ctx, input, 1, output, &olen)
|
|
== MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED);
|
|
|
|
exit:
|
|
mbedtls_cipher_free(&ctx);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void enc_dec_buf(int cipher_id, char *cipher_string, int key_len,
|
|
int length_val, int pad_mode)
|
|
{
|
|
size_t length = length_val, outlen, total_len, i, block_size, iv_len;
|
|
unsigned char key[64];
|
|
unsigned char iv[16];
|
|
unsigned char ad[13];
|
|
unsigned char tag[16];
|
|
unsigned char inbuf[64];
|
|
unsigned char encbuf[64];
|
|
unsigned char decbuf[64];
|
|
|
|
const mbedtls_cipher_info_t *cipher_info;
|
|
mbedtls_cipher_context_t ctx_dec;
|
|
mbedtls_cipher_context_t ctx_enc;
|
|
|
|
/*
|
|
* Prepare contexts
|
|
*/
|
|
mbedtls_cipher_init(&ctx_dec);
|
|
mbedtls_cipher_init(&ctx_enc);
|
|
|
|
memset(key, 0x2a, sizeof(key));
|
|
|
|
/* Check and get info structures */
|
|
cipher_info = mbedtls_cipher_info_from_type(cipher_id);
|
|
TEST_ASSERT(NULL != cipher_info);
|
|
TEST_ASSERT(mbedtls_cipher_info_from_string(cipher_string) == cipher_info);
|
|
TEST_ASSERT(strcmp(mbedtls_cipher_info_get_name(cipher_info),
|
|
cipher_string) == 0);
|
|
|
|
/* Initialise enc and dec contexts */
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_dec, cipher_info));
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_enc, cipher_info));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_dec, key, key_len, MBEDTLS_DECRYPT));
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_enc, key, key_len, MBEDTLS_ENCRYPT));
|
|
|
|
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
|
|
if (-1 != pad_mode) {
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx_dec, pad_mode));
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx_enc, pad_mode));
|
|
}
|
|
#else
|
|
(void) pad_mode;
|
|
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
|
|
|
|
/*
|
|
* Do a few encode/decode cycles
|
|
*/
|
|
for (i = 0; i < 3; i++) {
|
|
memset(iv, 0x00 + i, sizeof(iv));
|
|
memset(ad, 0x10 + i, sizeof(ad));
|
|
memset(inbuf, 0x20 + i, sizeof(inbuf));
|
|
|
|
memset(encbuf, 0, sizeof(encbuf));
|
|
memset(decbuf, 0, sizeof(decbuf));
|
|
memset(tag, 0, sizeof(tag));
|
|
|
|
if (NULL != strstr(cipher_info->name, "CCM*-NO-TAG")) {
|
|
iv_len = 13; /* For CCM, IV length is expected to be between 7 and 13 bytes.
|
|
* For CCM*-NO-TAG, IV length must be exactly 13 bytes long. */
|
|
} else if (cipher_info->type == MBEDTLS_CIPHER_CHACHA20 ||
|
|
cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) {
|
|
iv_len = 12;
|
|
} else {
|
|
iv_len = sizeof(iv);
|
|
}
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_dec, iv, iv_len));
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_enc, iv, iv_len));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_dec));
|
|
TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_enc));
|
|
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
int expected = (cipher_info->mode == MBEDTLS_MODE_GCM ||
|
|
cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) ?
|
|
0 : MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE;
|
|
|
|
TEST_EQUAL(expected, mbedtls_cipher_update_ad(&ctx_dec, ad, sizeof(ad) - i));
|
|
TEST_EQUAL(expected, mbedtls_cipher_update_ad(&ctx_enc, ad, sizeof(ad) - i));
|
|
#endif
|
|
|
|
block_size = mbedtls_cipher_get_block_size(&ctx_enc);
|
|
TEST_ASSERT(block_size != 0);
|
|
|
|
/* encode length number of bytes from inbuf */
|
|
TEST_ASSERT(0 == mbedtls_cipher_update(&ctx_enc, inbuf, length, encbuf, &outlen));
|
|
total_len = outlen;
|
|
|
|
TEST_ASSERT(total_len == length ||
|
|
(total_len % block_size == 0 &&
|
|
total_len < length &&
|
|
total_len + block_size > length));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_finish(&ctx_enc, encbuf + outlen, &outlen));
|
|
total_len += outlen;
|
|
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
TEST_EQUAL(expected, mbedtls_cipher_write_tag(&ctx_enc, tag, sizeof(tag)));
|
|
#endif
|
|
|
|
TEST_ASSERT(total_len == length ||
|
|
(total_len % block_size == 0 &&
|
|
total_len > length &&
|
|
total_len <= length + block_size));
|
|
|
|
/* decode the previously encoded string */
|
|
TEST_ASSERT(0 == mbedtls_cipher_update(&ctx_dec, encbuf, total_len, decbuf, &outlen));
|
|
total_len = outlen;
|
|
|
|
TEST_ASSERT(total_len == length ||
|
|
(total_len % block_size == 0 &&
|
|
total_len < length &&
|
|
total_len + block_size >= length));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_finish(&ctx_dec, decbuf + outlen, &outlen));
|
|
total_len += outlen;
|
|
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
TEST_EQUAL(expected, mbedtls_cipher_check_tag(&ctx_dec, tag, sizeof(tag)));
|
|
#endif
|
|
|
|
/* check result */
|
|
TEST_ASSERT(total_len == length);
|
|
TEST_ASSERT(0 == memcmp(inbuf, decbuf, length));
|
|
}
|
|
|
|
/*
|
|
* Done
|
|
*/
|
|
exit:
|
|
mbedtls_cipher_free(&ctx_dec);
|
|
mbedtls_cipher_free(&ctx_enc);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void enc_fail(int cipher_id, int pad_mode, int key_len, int length_val,
|
|
int ret)
|
|
{
|
|
size_t length = length_val;
|
|
unsigned char key[32];
|
|
unsigned char iv[16];
|
|
|
|
const mbedtls_cipher_info_t *cipher_info;
|
|
mbedtls_cipher_context_t ctx;
|
|
|
|
unsigned char inbuf[64];
|
|
unsigned char encbuf[64];
|
|
|
|
size_t outlen = 0;
|
|
|
|
memset(key, 0, 32);
|
|
memset(iv, 0, 16);
|
|
|
|
mbedtls_cipher_init(&ctx);
|
|
|
|
memset(inbuf, 5, 64);
|
|
memset(encbuf, 0, 64);
|
|
|
|
/* Check and get info structures */
|
|
cipher_info = mbedtls_cipher_info_from_type(cipher_id);
|
|
TEST_ASSERT(NULL != cipher_info);
|
|
|
|
/* Initialise context */
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx, cipher_info));
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx, key, key_len, MBEDTLS_ENCRYPT));
|
|
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx, pad_mode));
|
|
#else
|
|
(void) pad_mode;
|
|
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx, iv, 16));
|
|
TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx));
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
int expected = (cipher_info->mode == MBEDTLS_MODE_GCM ||
|
|
cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) ?
|
|
0 : MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE;
|
|
|
|
TEST_EQUAL(expected, mbedtls_cipher_update_ad(&ctx, NULL, 0));
|
|
#endif
|
|
|
|
/* encode length number of bytes from inbuf */
|
|
TEST_ASSERT(0 == mbedtls_cipher_update(&ctx, inbuf, length, encbuf, &outlen));
|
|
TEST_ASSERT(ret == mbedtls_cipher_finish(&ctx, encbuf + outlen, &outlen));
|
|
|
|
/* done */
|
|
exit:
|
|
mbedtls_cipher_free(&ctx);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void dec_empty_buf(int cipher,
|
|
int expected_update_ret,
|
|
int expected_finish_ret)
|
|
{
|
|
unsigned char key[32];
|
|
|
|
unsigned char *iv = NULL;
|
|
size_t iv_len = 16;
|
|
|
|
mbedtls_cipher_context_t ctx_dec;
|
|
const mbedtls_cipher_info_t *cipher_info;
|
|
|
|
unsigned char encbuf[64];
|
|
unsigned char decbuf[64];
|
|
|
|
size_t outlen = 0;
|
|
|
|
memset(key, 0, 32);
|
|
|
|
mbedtls_cipher_init(&ctx_dec);
|
|
|
|
memset(encbuf, 0, 64);
|
|
memset(decbuf, 0, 64);
|
|
|
|
/* Initialise context */
|
|
cipher_info = mbedtls_cipher_info_from_type(cipher);
|
|
TEST_ASSERT(NULL != cipher_info);
|
|
|
|
if (cipher_info->type == MBEDTLS_CIPHER_CHACHA20 ||
|
|
cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) {
|
|
iv_len = 12;
|
|
}
|
|
|
|
TEST_CALLOC(iv, iv_len);
|
|
memset(iv, 0, iv_len);
|
|
|
|
TEST_ASSERT(sizeof(key) * 8 >= mbedtls_cipher_info_get_key_bitlen(cipher_info));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_dec, cipher_info));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_dec,
|
|
key, mbedtls_cipher_info_get_key_bitlen(cipher_info),
|
|
MBEDTLS_DECRYPT));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_dec, iv, iv_len));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_dec));
|
|
|
|
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING) && defined(MBEDTLS_CIPHER_PADDING_PKCS7)
|
|
if (ctx_dec.cipher_info->mode == MBEDTLS_MODE_CBC) {
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx_dec,
|
|
MBEDTLS_PADDING_PKCS7));
|
|
}
|
|
#endif
|
|
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
int expected = (cipher_info->mode == MBEDTLS_MODE_GCM ||
|
|
cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) ?
|
|
0 : MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE;
|
|
|
|
TEST_EQUAL(expected, mbedtls_cipher_update_ad(&ctx_dec, NULL, 0));
|
|
#endif
|
|
|
|
/* decode 0-byte string */
|
|
TEST_ASSERT(expected_update_ret ==
|
|
mbedtls_cipher_update(&ctx_dec, encbuf, 0, decbuf, &outlen));
|
|
TEST_ASSERT(0 == outlen);
|
|
|
|
if (expected_finish_ret == 0 &&
|
|
(cipher_info->mode == MBEDTLS_MODE_CBC ||
|
|
cipher_info->mode == MBEDTLS_MODE_ECB)) {
|
|
/* Non-CBC and non-ECB ciphers are OK with decrypting empty buffers and
|
|
* return success, not MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED, when
|
|
* decrypting an empty buffer.
|
|
* On the other hand, CBC and ECB ciphers need a full block of input.
|
|
*/
|
|
expected_finish_ret = MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED;
|
|
}
|
|
|
|
TEST_ASSERT(expected_finish_ret == mbedtls_cipher_finish(
|
|
&ctx_dec, decbuf + outlen, &outlen));
|
|
TEST_ASSERT(0 == outlen);
|
|
|
|
exit:
|
|
mbedtls_free(iv);
|
|
mbedtls_cipher_free(&ctx_dec);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void enc_dec_buf_multipart(int cipher_id, int key_len, int first_length_val,
|
|
int second_length_val, int pad_mode,
|
|
int first_encrypt_output_len, int second_encrypt_output_len,
|
|
int first_decrypt_output_len, int second_decrypt_output_len)
|
|
{
|
|
size_t first_length = first_length_val;
|
|
size_t second_length = second_length_val;
|
|
size_t length = first_length + second_length;
|
|
size_t block_size;
|
|
size_t iv_len;
|
|
unsigned char key[32];
|
|
unsigned char iv[16];
|
|
|
|
mbedtls_cipher_context_t ctx_dec;
|
|
mbedtls_cipher_context_t ctx_enc;
|
|
const mbedtls_cipher_info_t *cipher_info;
|
|
|
|
unsigned char inbuf[64];
|
|
unsigned char encbuf[64];
|
|
unsigned char decbuf[64];
|
|
|
|
size_t outlen = 0;
|
|
size_t totaloutlen = 0;
|
|
|
|
memset(key, 0, 32);
|
|
memset(iv, 0, 16);
|
|
|
|
mbedtls_cipher_init(&ctx_dec);
|
|
mbedtls_cipher_init(&ctx_enc);
|
|
|
|
memset(inbuf, 5, 64);
|
|
memset(encbuf, 0, 64);
|
|
memset(decbuf, 0, 64);
|
|
|
|
/* Initialise enc and dec contexts */
|
|
cipher_info = mbedtls_cipher_info_from_type(cipher_id);
|
|
TEST_ASSERT(NULL != cipher_info);
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_dec, cipher_info));
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_enc, cipher_info));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_dec, key, key_len, MBEDTLS_DECRYPT));
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_enc, key, key_len, MBEDTLS_ENCRYPT));
|
|
|
|
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
|
|
if (-1 != pad_mode) {
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx_dec, pad_mode));
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx_enc, pad_mode));
|
|
}
|
|
#else
|
|
(void) pad_mode;
|
|
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
|
|
|
|
if (NULL != strstr(cipher_info->name, "CCM*-NO-TAG")) {
|
|
iv_len = 13; /* For CCM, IV length is expected to be between 7 and 13 bytes.
|
|
* For CCM*-NO-TAG, IV length must be exactly 13 bytes long. */
|
|
} else if (cipher_info->type == MBEDTLS_CIPHER_CHACHA20 ||
|
|
cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) {
|
|
iv_len = 12;
|
|
} else {
|
|
iv_len = sizeof(iv);
|
|
}
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_dec, iv, iv_len));
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_enc, iv, iv_len));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_dec));
|
|
TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_enc));
|
|
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
int expected = (cipher_info->mode == MBEDTLS_MODE_GCM ||
|
|
cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) ?
|
|
0 : MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE;
|
|
|
|
TEST_EQUAL(expected, mbedtls_cipher_update_ad(&ctx_dec, NULL, 0));
|
|
TEST_EQUAL(expected, mbedtls_cipher_update_ad(&ctx_enc, NULL, 0));
|
|
#endif
|
|
|
|
block_size = mbedtls_cipher_get_block_size(&ctx_enc);
|
|
TEST_ASSERT(block_size != 0);
|
|
|
|
/* encode length number of bytes from inbuf */
|
|
TEST_ASSERT(0 == mbedtls_cipher_update(&ctx_enc, inbuf, first_length, encbuf, &outlen));
|
|
TEST_ASSERT((size_t) first_encrypt_output_len == outlen);
|
|
totaloutlen = outlen;
|
|
TEST_ASSERT(0 ==
|
|
mbedtls_cipher_update(&ctx_enc, inbuf + first_length, second_length,
|
|
encbuf + totaloutlen,
|
|
&outlen));
|
|
TEST_ASSERT((size_t) second_encrypt_output_len == outlen);
|
|
totaloutlen += outlen;
|
|
TEST_ASSERT(totaloutlen == length ||
|
|
(totaloutlen % block_size == 0 &&
|
|
totaloutlen < length &&
|
|
totaloutlen + block_size > length));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_finish(&ctx_enc, encbuf + totaloutlen, &outlen));
|
|
totaloutlen += outlen;
|
|
TEST_ASSERT(totaloutlen == length ||
|
|
(totaloutlen % block_size == 0 &&
|
|
totaloutlen > length &&
|
|
totaloutlen <= length + block_size));
|
|
|
|
/* decode the previously encoded string */
|
|
second_length = totaloutlen - first_length;
|
|
TEST_ASSERT(0 == mbedtls_cipher_update(&ctx_dec, encbuf, first_length, decbuf, &outlen));
|
|
TEST_ASSERT((size_t) first_decrypt_output_len == outlen);
|
|
totaloutlen = outlen;
|
|
TEST_ASSERT(0 ==
|
|
mbedtls_cipher_update(&ctx_dec, encbuf + first_length, second_length,
|
|
decbuf + totaloutlen,
|
|
&outlen));
|
|
TEST_ASSERT((size_t) second_decrypt_output_len == outlen);
|
|
totaloutlen += outlen;
|
|
|
|
TEST_ASSERT(totaloutlen == length ||
|
|
(totaloutlen % block_size == 0 &&
|
|
totaloutlen < length &&
|
|
totaloutlen + block_size >= length));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_finish(&ctx_dec, decbuf + totaloutlen, &outlen));
|
|
totaloutlen += outlen;
|
|
|
|
TEST_ASSERT(totaloutlen == length);
|
|
|
|
TEST_ASSERT(0 == memcmp(inbuf, decbuf, length));
|
|
|
|
exit:
|
|
mbedtls_cipher_free(&ctx_dec);
|
|
mbedtls_cipher_free(&ctx_enc);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void decrypt_test_vec(int cipher_id, int pad_mode, data_t *key,
|
|
data_t *iv, data_t *cipher,
|
|
data_t *clear, data_t *ad, data_t *tag,
|
|
int finish_result, int tag_result)
|
|
{
|
|
unsigned char output[265];
|
|
mbedtls_cipher_context_t ctx;
|
|
size_t outlen, total_len;
|
|
|
|
mbedtls_cipher_init(&ctx);
|
|
|
|
memset(output, 0x00, sizeof(output));
|
|
|
|
#if !defined(MBEDTLS_GCM_C) && !defined(MBEDTLS_CHACHAPOLY_C)
|
|
((void) ad);
|
|
((void) tag);
|
|
#endif
|
|
|
|
/* Prepare context */
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx,
|
|
mbedtls_cipher_info_from_type(cipher_id)));
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT));
|
|
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
|
|
if (pad_mode != -1) {
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx, pad_mode));
|
|
}
|
|
#else
|
|
(void) pad_mode;
|
|
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx, iv->x, iv->len));
|
|
TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx));
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
int expected = (ctx.cipher_info->mode == MBEDTLS_MODE_GCM ||
|
|
ctx.cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) ?
|
|
0 : MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE;
|
|
|
|
TEST_EQUAL(expected, mbedtls_cipher_update_ad(&ctx, ad->x, ad->len));
|
|
#endif
|
|
|
|
/* decode buffer and check tag->x */
|
|
total_len = 0;
|
|
TEST_ASSERT(0 == mbedtls_cipher_update(&ctx, cipher->x, cipher->len, output, &outlen));
|
|
total_len += outlen;
|
|
TEST_ASSERT(finish_result == mbedtls_cipher_finish(&ctx, output + outlen,
|
|
&outlen));
|
|
total_len += outlen;
|
|
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
|
|
int tag_expected = (ctx.cipher_info->mode == MBEDTLS_MODE_GCM ||
|
|
ctx.cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) ?
|
|
tag_result : MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE;
|
|
|
|
TEST_EQUAL(tag_expected, mbedtls_cipher_check_tag(&ctx, tag->x, tag->len));
|
|
#endif
|
|
|
|
/* check plaintext only if everything went fine */
|
|
if (0 == finish_result && 0 == tag_result) {
|
|
TEST_ASSERT(total_len == clear->len);
|
|
TEST_ASSERT(0 == memcmp(output, clear->x, clear->len));
|
|
}
|
|
|
|
exit:
|
|
mbedtls_cipher_free(&ctx);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_AUTH_CRYPT */
|
|
void auth_crypt_tv(int cipher_id, data_t *key, data_t *iv,
|
|
data_t *ad, data_t *cipher, data_t *tag,
|
|
char *result, data_t *clear, int use_psa)
|
|
{
|
|
/*
|
|
* Take an AEAD ciphertext + tag and perform a pair
|
|
* of AEAD decryption and AEAD encryption. Check that
|
|
* this results in the expected plaintext, and that
|
|
* decryption and encryption are inverse to one another.
|
|
*/
|
|
|
|
int ret;
|
|
int using_nist_kw, using_nist_kw_padding;
|
|
|
|
mbedtls_cipher_context_t ctx;
|
|
size_t outlen;
|
|
|
|
unsigned char *cipher_plus_tag = NULL;
|
|
size_t cipher_plus_tag_len;
|
|
unsigned char *decrypt_buf = NULL;
|
|
size_t decrypt_buf_len = 0;
|
|
unsigned char *encrypt_buf = NULL;
|
|
size_t encrypt_buf_len = 0;
|
|
|
|
/* Null pointers are documented as valid for inputs of length 0.
|
|
* The test framework passes non-null pointers, so set them to NULL.
|
|
* key, cipher and tag can't be empty. */
|
|
if (iv->len == 0) {
|
|
iv->x = NULL;
|
|
}
|
|
if (ad->len == 0) {
|
|
ad->x = NULL;
|
|
}
|
|
if (clear->len == 0) {
|
|
clear->x = NULL;
|
|
}
|
|
|
|
mbedtls_cipher_init(&ctx);
|
|
|
|
/* Initialize PSA Crypto */
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
if (use_psa == 1) {
|
|
PSA_ASSERT(psa_crypto_init());
|
|
}
|
|
#else
|
|
(void) use_psa;
|
|
#endif
|
|
|
|
/*
|
|
* Are we using NIST_KW? with padding?
|
|
*/
|
|
using_nist_kw_padding = cipher_id == MBEDTLS_CIPHER_AES_128_KWP ||
|
|
cipher_id == MBEDTLS_CIPHER_AES_192_KWP ||
|
|
cipher_id == MBEDTLS_CIPHER_AES_256_KWP;
|
|
using_nist_kw = cipher_id == MBEDTLS_CIPHER_AES_128_KW ||
|
|
cipher_id == MBEDTLS_CIPHER_AES_192_KW ||
|
|
cipher_id == MBEDTLS_CIPHER_AES_256_KW ||
|
|
using_nist_kw_padding;
|
|
|
|
/*
|
|
* Prepare context for decryption
|
|
*/
|
|
if (!cipher_reset_key(&ctx, cipher_id, use_psa, tag->len, key,
|
|
MBEDTLS_DECRYPT)) {
|
|
goto exit;
|
|
}
|
|
|
|
/*
|
|
* prepare buffer for decryption
|
|
* (we need the tag appended to the ciphertext)
|
|
*/
|
|
cipher_plus_tag_len = cipher->len + tag->len;
|
|
TEST_CALLOC(cipher_plus_tag, cipher_plus_tag_len);
|
|
memcpy(cipher_plus_tag, cipher->x, cipher->len);
|
|
memcpy(cipher_plus_tag + cipher->len, tag->x, tag->len);
|
|
|
|
/*
|
|
* Compute length of output buffer according to the documentation
|
|
*/
|
|
if (using_nist_kw) {
|
|
decrypt_buf_len = cipher_plus_tag_len - 8;
|
|
} else {
|
|
decrypt_buf_len = cipher_plus_tag_len - tag->len;
|
|
}
|
|
|
|
|
|
/*
|
|
* Try decrypting to a buffer that's 1B too small
|
|
*/
|
|
if (decrypt_buf_len != 0) {
|
|
TEST_CALLOC(decrypt_buf, decrypt_buf_len - 1);
|
|
|
|
outlen = 0;
|
|
ret = mbedtls_cipher_auth_decrypt_ext(&ctx, iv->x, iv->len,
|
|
ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
|
|
decrypt_buf, decrypt_buf_len - 1, &outlen, tag->len);
|
|
TEST_ASSERT(ret == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
|
|
|
|
mbedtls_free(decrypt_buf);
|
|
decrypt_buf = NULL;
|
|
}
|
|
|
|
/*
|
|
* Authenticate and decrypt, and check result
|
|
*/
|
|
TEST_CALLOC(decrypt_buf, decrypt_buf_len);
|
|
|
|
outlen = 0;
|
|
ret = mbedtls_cipher_auth_decrypt_ext(&ctx, iv->x, iv->len,
|
|
ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
|
|
decrypt_buf, decrypt_buf_len, &outlen, tag->len);
|
|
|
|
if (strcmp(result, "FAIL") == 0) {
|
|
TEST_ASSERT(ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED);
|
|
TEST_ASSERT(buffer_is_all_zero(decrypt_buf, decrypt_buf_len));
|
|
} else {
|
|
TEST_ASSERT(ret == 0);
|
|
TEST_MEMORY_COMPARE(decrypt_buf, outlen, clear->x, clear->len);
|
|
}
|
|
|
|
mbedtls_free(decrypt_buf);
|
|
decrypt_buf = NULL;
|
|
|
|
/*
|
|
* Encrypt back if test data was authentic
|
|
*/
|
|
if (strcmp(result, "FAIL") != 0) {
|
|
/* prepare context for encryption */
|
|
if (!cipher_reset_key(&ctx, cipher_id, use_psa, tag->len, key,
|
|
MBEDTLS_ENCRYPT)) {
|
|
goto exit;
|
|
}
|
|
|
|
/*
|
|
* Compute size of output buffer according to documentation
|
|
*/
|
|
if (using_nist_kw) {
|
|
encrypt_buf_len = clear->len + 8;
|
|
if (using_nist_kw_padding && encrypt_buf_len % 8 != 0) {
|
|
encrypt_buf_len += 8 - encrypt_buf_len % 8;
|
|
}
|
|
} else {
|
|
encrypt_buf_len = clear->len + tag->len;
|
|
}
|
|
|
|
/*
|
|
* Try encrypting with an output buffer that's 1B too small
|
|
*/
|
|
TEST_CALLOC(encrypt_buf, encrypt_buf_len - 1);
|
|
|
|
outlen = 0;
|
|
ret = mbedtls_cipher_auth_encrypt_ext(&ctx, iv->x, iv->len,
|
|
ad->x, ad->len, clear->x, clear->len,
|
|
encrypt_buf, encrypt_buf_len - 1, &outlen, tag->len);
|
|
TEST_ASSERT(ret != 0);
|
|
|
|
mbedtls_free(encrypt_buf);
|
|
encrypt_buf = NULL;
|
|
|
|
/*
|
|
* Encrypt and check the result
|
|
*/
|
|
TEST_CALLOC(encrypt_buf, encrypt_buf_len);
|
|
|
|
outlen = 0;
|
|
ret = mbedtls_cipher_auth_encrypt_ext(&ctx, iv->x, iv->len,
|
|
ad->x, ad->len, clear->x, clear->len,
|
|
encrypt_buf, encrypt_buf_len, &outlen, tag->len);
|
|
TEST_ASSERT(ret == 0);
|
|
|
|
TEST_ASSERT(outlen == cipher->len + tag->len);
|
|
TEST_ASSERT(memcmp(encrypt_buf, cipher->x, cipher->len) == 0);
|
|
TEST_ASSERT(memcmp(encrypt_buf + cipher->len,
|
|
tag->x, tag->len) == 0);
|
|
|
|
mbedtls_free(encrypt_buf);
|
|
encrypt_buf = NULL;
|
|
}
|
|
|
|
exit:
|
|
|
|
mbedtls_cipher_free(&ctx);
|
|
mbedtls_free(decrypt_buf);
|
|
mbedtls_free(encrypt_buf);
|
|
mbedtls_free(cipher_plus_tag);
|
|
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO)
|
|
if (use_psa == 1) {
|
|
PSA_DONE();
|
|
}
|
|
#endif /* MBEDTLS_USE_PSA_CRYPTO */
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void test_vec_ecb(int cipher_id, int operation, data_t *key,
|
|
data_t *input, data_t *result, int finish_result
|
|
)
|
|
{
|
|
mbedtls_cipher_context_t ctx;
|
|
unsigned char output[32];
|
|
size_t outlen;
|
|
|
|
mbedtls_cipher_init(&ctx);
|
|
|
|
memset(output, 0x00, sizeof(output));
|
|
|
|
/* Prepare context */
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx,
|
|
mbedtls_cipher_info_from_type(cipher_id)));
|
|
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx, key->x, 8 * key->len, operation));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_update(&ctx, input->x,
|
|
mbedtls_cipher_get_block_size(&ctx),
|
|
output, &outlen));
|
|
TEST_ASSERT(outlen == mbedtls_cipher_get_block_size(&ctx));
|
|
TEST_ASSERT(finish_result == mbedtls_cipher_finish(&ctx, output + outlen,
|
|
&outlen));
|
|
TEST_ASSERT(0 == outlen);
|
|
|
|
/* check plaintext only if everything went fine */
|
|
if (0 == finish_result) {
|
|
TEST_ASSERT(0 == memcmp(output, result->x,
|
|
mbedtls_cipher_get_block_size(&ctx)));
|
|
}
|
|
|
|
exit:
|
|
mbedtls_cipher_free(&ctx);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
|
|
void test_vec_crypt(int cipher_id, int operation, data_t *key,
|
|
data_t *iv, data_t *input, data_t *result,
|
|
int finish_result, int use_psa)
|
|
{
|
|
mbedtls_cipher_context_t ctx;
|
|
unsigned char output[32];
|
|
size_t outlen;
|
|
|
|
mbedtls_cipher_init(&ctx);
|
|
|
|
memset(output, 0x00, sizeof(output));
|
|
|
|
/* Prepare context */
|
|
#if !defined(MBEDTLS_USE_PSA_CRYPTO) || !defined(MBEDTLS_TEST_DEPRECATED)
|
|
(void) use_psa;
|
|
#else
|
|
if (use_psa == 1) {
|
|
PSA_ASSERT(psa_crypto_init());
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup_psa(&ctx,
|
|
mbedtls_cipher_info_from_type(cipher_id), 0));
|
|
} else
|
|
#endif /* !MBEDTLS_USE_PSA_CRYPTO || !MBEDTLS_TEST_DEPRECATED*/
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx,
|
|
mbedtls_cipher_info_from_type(cipher_id)));
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx, key->x, 8 * key->len, operation));
|
|
if (MBEDTLS_MODE_CBC == ctx.cipher_info->mode) {
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx, MBEDTLS_PADDING_NONE));
|
|
}
|
|
|
|
TEST_ASSERT(finish_result == mbedtls_cipher_crypt(&ctx, iv->len ? iv->x : NULL,
|
|
iv->len, input->x, input->len,
|
|
output, &outlen));
|
|
TEST_ASSERT(result->len == outlen);
|
|
/* check plaintext only if everything went fine */
|
|
if (0 == finish_result) {
|
|
TEST_ASSERT(0 == memcmp(output, result->x, outlen));
|
|
}
|
|
|
|
exit:
|
|
mbedtls_cipher_free(&ctx);
|
|
#if defined(MBEDTLS_USE_PSA_CRYPTO) && defined(MBEDTLS_TEST_DEPRECATED)
|
|
PSA_DONE();
|
|
#endif /* MBEDTLS_USE_PSA_CRYPTO && MBEDTLS_TEST_DEPRECATED */
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
|
|
void set_padding(int cipher_id, int pad_mode, int ret)
|
|
{
|
|
const mbedtls_cipher_info_t *cipher_info;
|
|
mbedtls_cipher_context_t ctx;
|
|
|
|
mbedtls_cipher_init(&ctx);
|
|
|
|
cipher_info = mbedtls_cipher_info_from_type(cipher_id);
|
|
TEST_ASSERT(NULL != cipher_info);
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx, cipher_info));
|
|
|
|
TEST_ASSERT(ret == mbedtls_cipher_set_padding_mode(&ctx, pad_mode));
|
|
|
|
exit:
|
|
mbedtls_cipher_free(&ctx);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
|
|
void check_padding(int pad_mode, data_t *input, int ret, int dlen_check
|
|
)
|
|
{
|
|
mbedtls_cipher_info_t cipher_info;
|
|
mbedtls_cipher_context_t ctx;
|
|
size_t dlen;
|
|
|
|
/* build a fake context just for getting access to get_padding */
|
|
mbedtls_cipher_init(&ctx);
|
|
cipher_info.mode = MBEDTLS_MODE_CBC;
|
|
ctx.cipher_info = &cipher_info;
|
|
|
|
TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx, pad_mode));
|
|
|
|
|
|
TEST_ASSERT(ret == ctx.get_padding(input->x, input->len, &dlen));
|
|
if (0 == ret) {
|
|
TEST_ASSERT(dlen == (size_t) dlen_check);
|
|
}
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE */
|
|
void iv_len_validity(int cipher_id, char *cipher_string,
|
|
int iv_len_val, int ret)
|
|
{
|
|
size_t iv_len = iv_len_val;
|
|
unsigned char iv[16];
|
|
|
|
/* Initialise iv buffer */
|
|
memset(iv, 0, sizeof(iv));
|
|
|
|
const mbedtls_cipher_info_t *cipher_info;
|
|
mbedtls_cipher_context_t ctx_dec;
|
|
mbedtls_cipher_context_t ctx_enc;
|
|
|
|
/*
|
|
* Prepare contexts
|
|
*/
|
|
mbedtls_cipher_init(&ctx_dec);
|
|
mbedtls_cipher_init(&ctx_enc);
|
|
|
|
/* Check and get info structures */
|
|
cipher_info = mbedtls_cipher_info_from_type(cipher_id);
|
|
TEST_ASSERT(NULL != cipher_info);
|
|
TEST_ASSERT(mbedtls_cipher_info_from_string(cipher_string) == cipher_info);
|
|
TEST_ASSERT(strcmp(mbedtls_cipher_info_get_name(cipher_info),
|
|
cipher_string) == 0);
|
|
|
|
/* Initialise enc and dec contexts */
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_dec, cipher_info));
|
|
TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_enc, cipher_info));
|
|
|
|
TEST_ASSERT(ret == mbedtls_cipher_set_iv(&ctx_dec, iv, iv_len));
|
|
TEST_ASSERT(ret == mbedtls_cipher_set_iv(&ctx_enc, iv, iv_len));
|
|
|
|
exit:
|
|
mbedtls_cipher_free(&ctx_dec);
|
|
mbedtls_cipher_free(&ctx_enc);
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
|
|
void check_set_padding(int cipher_id)
|
|
{
|
|
mbedtls_cipher_context_t ctx;
|
|
unsigned char *key = NULL;
|
|
unsigned char iv[16] = { 0 };
|
|
unsigned char input[16] = { 0 };
|
|
unsigned char output[32] = { 0 };
|
|
size_t outlen = 0;
|
|
const mbedtls_cipher_info_t *cipher_info;
|
|
size_t keylen = 0;
|
|
|
|
cipher_info = mbedtls_cipher_info_from_type(cipher_id);
|
|
|
|
if (cipher_info->mode != MBEDTLS_MODE_CBC) {
|
|
TEST_FAIL("Cipher mode must be CBC");
|
|
}
|
|
|
|
keylen = mbedtls_cipher_info_get_key_bitlen(cipher_info);
|
|
TEST_CALLOC(key, keylen/8);
|
|
memset(key, 0, keylen/8);
|
|
|
|
mbedtls_cipher_init(&ctx);
|
|
|
|
TEST_EQUAL(0, mbedtls_cipher_setup(&ctx, cipher_info));
|
|
|
|
TEST_EQUAL(0, mbedtls_cipher_setkey(&ctx, key, keylen,
|
|
MBEDTLS_ENCRYPT));
|
|
|
|
TEST_EQUAL(MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
|
|
mbedtls_cipher_crypt(&ctx, iv, sizeof(iv), input,
|
|
sizeof(input), output, &outlen));
|
|
|
|
TEST_EQUAL(0, mbedtls_cipher_set_padding_mode(&ctx, MBEDTLS_PADDING_NONE));
|
|
TEST_EQUAL(0, mbedtls_cipher_crypt(&ctx, iv, sizeof(iv), input,
|
|
sizeof(input), output, &outlen));
|
|
|
|
exit:
|
|
mbedtls_cipher_free(&ctx);
|
|
mbedtls_free(key);
|
|
}
|
|
/* END_CASE */
|