tests/suites/test_suite_aes.function - mirror/mbed-tls - TrustedFirmware Git Browser

 /* BEGIN_HEADER */
 #include "mbedtls/aes.h"

 /* Test AES with a copied context.
  *
  * enc and dec must be AES context objects. They don't need to
  * be initialized, and are left freed.
  */
 static int test_ctx_alignment(const data_t *key,
                               mbedtls_aes_context *enc,
                               mbedtls_aes_context *dec)
 {
     unsigned char plaintext[16] = {
         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
     };
     unsigned char ciphertext[16];
     unsigned char output[16];

     // Set key and encrypt with original context
     mbedtls_aes_init(enc);
     TEST_ASSERT(mbedtls_aes_setkey_enc(enc, key->x, key->len * 8) == 0);
     TEST_ASSERT(mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_ENCRYPT,
                                       plaintext, ciphertext) == 0);

     // Set key for decryption with original context
     mbedtls_aes_init(dec);
     TEST_ASSERT(mbedtls_aes_setkey_dec(dec, key->x, key->len * 8) == 0);

     // Wipe the original context to make sure nothing from it is used
     memset(enc, 0, sizeof(*enc));
     mbedtls_aes_free(enc);

     // Decrypt
     TEST_ASSERT(mbedtls_aes_crypt_ecb(dec, MBEDTLS_AES_DECRYPT,
                                       ciphertext, output) == 0);
     TEST_BUFFERS_EQUAL(plaintext, 16, output, 16);

     mbedtls_aes_free(dec);

     return 1;

 exit:
     /* Bug: we may be leaving something unfreed. This is harmless
      * in our built-in implementations, but might cause a memory leak
      * with alternative implementations. */
     return 0;
 }

 /* END_HEADER */

 /* BEGIN_DEPENDENCIES
  * depends_on:MBEDTLS_AES_C
  * END_DEPENDENCIES
  */

 /* BEGIN_CASE */
 void aes_encrypt_ecb(data_t *key_str, data_t *src_str,
                      data_t *dst, int setkey_result)
 {
     unsigned char output[100];
     mbedtls_aes_context ctx;

     memset(output, 0x00, 100);

     mbedtls_aes_init(&ctx);

     TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == setkey_result);
     if (setkey_result == 0) {
         TEST_ASSERT(mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_ENCRYPT, src_str->x, output) == 0);

         TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
     }

 exit:
     mbedtls_aes_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void aes_decrypt_ecb(data_t *key_str, data_t *src_str,
                      data_t *dst, int setkey_result)
 {
     unsigned char output[100];
     mbedtls_aes_context ctx;

     memset(output, 0x00, 100);

     mbedtls_aes_init(&ctx);

     TEST_ASSERT(mbedtls_aes_setkey_dec(&ctx, key_str->x, key_str->len * 8) == setkey_result);
     if (setkey_result == 0) {
         TEST_ASSERT(mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_DECRYPT, src_str->x, output) == 0);

         TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
     }

 exit:
     mbedtls_aes_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
 void aes_encrypt_cbc(data_t *key_str, data_t *iv_str,
                      data_t *src_str, data_t *dst,
                      int cbc_result)
 {
     unsigned char output[100];
     mbedtls_aes_context ctx;

     memset(output, 0x00, 100);

     mbedtls_aes_init(&ctx);

     TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
     TEST_ASSERT(mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x,
                                       src_str->x, output) == cbc_result);
     if (cbc_result == 0) {

         TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
                                         src_str->len, dst->len) == 0);
     }

 exit:
     mbedtls_aes_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
 void aes_decrypt_cbc(data_t *key_str, data_t *iv_str,
                      data_t *src_str, data_t *dst,
                      int cbc_result)
 {
     unsigned char output[100];
     mbedtls_aes_context ctx;

     memset(output, 0x00, 100);
     mbedtls_aes_init(&ctx);

     TEST_ASSERT(mbedtls_aes_setkey_dec(&ctx, key_str->x, key_str->len * 8) == 0);
     TEST_ASSERT(mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x,
                                       src_str->x, output) == cbc_result);
     if (cbc_result == 0) {

         TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
                                         src_str->len, dst->len) == 0);
     }

 exit:
     mbedtls_aes_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
 void aes_encrypt_xts(char *hex_key_string, char *hex_data_unit_string,
                      char *hex_src_string, char *hex_dst_string)
 {
     enum { AES_BLOCK_SIZE = 16 };
     unsigned char *data_unit = NULL;
     unsigned char *key = NULL;
     unsigned char *src = NULL;
     unsigned char *dst = NULL;
     unsigned char *output = NULL;
     mbedtls_aes_xts_context ctx;
     size_t key_len, src_len, dst_len, data_unit_len;

     mbedtls_aes_xts_init(&ctx);

     data_unit = mbedtls_test_unhexify_alloc(hex_data_unit_string,
                                             &data_unit_len);
     TEST_ASSERT(data_unit_len == AES_BLOCK_SIZE);

     key = mbedtls_test_unhexify_alloc(hex_key_string, &key_len);
     TEST_ASSERT(key_len % 2 == 0);

     src = mbedtls_test_unhexify_alloc(hex_src_string, &src_len);
     dst = mbedtls_test_unhexify_alloc(hex_dst_string, &dst_len);
     TEST_ASSERT(src_len == dst_len);

     output = mbedtls_test_zero_alloc(dst_len);

     TEST_ASSERT(mbedtls_aes_xts_setkey_enc(&ctx, key, key_len * 8) == 0);
     TEST_ASSERT(mbedtls_aes_crypt_xts(&ctx, MBEDTLS_AES_ENCRYPT, src_len,
                                       data_unit, src, output) == 0);

     TEST_ASSERT(memcmp(output, dst, dst_len) == 0);

 exit:
     mbedtls_aes_xts_free(&ctx);
     mbedtls_free(data_unit);
     mbedtls_free(key);
     mbedtls_free(src);
     mbedtls_free(dst);
     mbedtls_free(output);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
 void aes_decrypt_xts(char *hex_key_string, char *hex_data_unit_string,
                      char *hex_dst_string, char *hex_src_string)
 {
     enum { AES_BLOCK_SIZE = 16 };
     unsigned char *data_unit = NULL;
     unsigned char *key = NULL;
     unsigned char *src = NULL;
     unsigned char *dst = NULL;
     unsigned char *output = NULL;
     mbedtls_aes_xts_context ctx;
     size_t key_len, src_len, dst_len, data_unit_len;

     mbedtls_aes_xts_init(&ctx);

     data_unit = mbedtls_test_unhexify_alloc(hex_data_unit_string,
                                             &data_unit_len);
     TEST_ASSERT(data_unit_len == AES_BLOCK_SIZE);

     key = mbedtls_test_unhexify_alloc(hex_key_string, &key_len);
     TEST_ASSERT(key_len % 2 == 0);

     src = mbedtls_test_unhexify_alloc(hex_src_string, &src_len);
     dst = mbedtls_test_unhexify_alloc(hex_dst_string, &dst_len);
     TEST_ASSERT(src_len == dst_len);

     output = mbedtls_test_zero_alloc(dst_len);

     TEST_ASSERT(mbedtls_aes_xts_setkey_dec(&ctx, key, key_len * 8) == 0);
     TEST_ASSERT(mbedtls_aes_crypt_xts(&ctx, MBEDTLS_AES_DECRYPT, src_len,
                                       data_unit, src, output) == 0);

     TEST_ASSERT(memcmp(output, dst, dst_len) == 0);

 exit:
     mbedtls_aes_xts_free(&ctx);
     mbedtls_free(data_unit);
     mbedtls_free(key);
     mbedtls_free(src);
     mbedtls_free(dst);
     mbedtls_free(output);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
 void aes_crypt_xts_size(int size, int retval)
 {
     mbedtls_aes_xts_context ctx;
     const unsigned char src[16] = { 0 };
     unsigned char output[16];
     unsigned char data_unit[16];
     size_t length = size;

     mbedtls_aes_xts_init(&ctx);
     memset(data_unit, 0x00, sizeof(data_unit));


     /* Valid pointers are passed for builds with MBEDTLS_CHECK_PARAMS, as
      * otherwise we wouldn't get to the size check we're interested in. */
     TEST_ASSERT(mbedtls_aes_crypt_xts(&ctx, MBEDTLS_AES_ENCRYPT, length, data_unit, src,
                                       output) == retval);
 exit:
     mbedtls_aes_xts_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
 void aes_crypt_xts_keysize(int size, int retval)
 {
     mbedtls_aes_xts_context ctx;
     const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
     size_t key_len = size;

     mbedtls_aes_xts_init(&ctx);

     TEST_ASSERT(mbedtls_aes_xts_setkey_enc(&ctx, key, key_len * 8) == retval);
     TEST_ASSERT(mbedtls_aes_xts_setkey_dec(&ctx, key, key_len * 8) == retval);
 exit:
     mbedtls_aes_xts_free(&ctx);
 }
 /* END_CASE */


 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
 void aes_encrypt_cfb128(data_t *key_str, data_t *iv_str,
                         data_t *src_str, data_t *dst)
 {
     unsigned char output[100];
     mbedtls_aes_context ctx;
     size_t iv_offset = 0;

     memset(output, 0x00, 100);
     mbedtls_aes_init(&ctx);


     TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
     TEST_ASSERT(mbedtls_aes_crypt_cfb128(&ctx, MBEDTLS_AES_ENCRYPT, 16, &iv_offset, iv_str->x,
                                          src_str->x, output) == 0);

     TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);

 exit:
     mbedtls_aes_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
 void aes_decrypt_cfb128(data_t *key_str, data_t *iv_str,
                         data_t *src_str, data_t *dst)
 {
     unsigned char output[100];
     mbedtls_aes_context ctx;
     size_t iv_offset = 0;

     memset(output, 0x00, 100);
     mbedtls_aes_init(&ctx);


     TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
     TEST_ASSERT(mbedtls_aes_crypt_cfb128(&ctx, MBEDTLS_AES_DECRYPT, 16, &iv_offset, iv_str->x,
                                          src_str->x, output) == 0);

     TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);

 exit:
     mbedtls_aes_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
 void aes_encrypt_cfb8(data_t *key_str, data_t *iv_str,
                       data_t *src_str, data_t *dst)
 {
     unsigned char output[100];
     mbedtls_aes_context ctx;

     memset(output, 0x00, 100);
     mbedtls_aes_init(&ctx);


     TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
     TEST_ASSERT(mbedtls_aes_crypt_cfb8(&ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x,
                                        src_str->x, output) == 0);

     TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
                                     src_str->len, dst->len) == 0);

 exit:
     mbedtls_aes_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
 void aes_decrypt_cfb8(data_t *key_str, data_t *iv_str,
                       data_t *src_str, data_t *dst)
 {
     unsigned char output[100];
     mbedtls_aes_context ctx;

     memset(output, 0x00, 100);
     mbedtls_aes_init(&ctx);


     TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
     TEST_ASSERT(mbedtls_aes_crypt_cfb8(&ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x,
                                        src_str->x, output) == 0);

     TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
                                     src_str->len, dst->len) == 0);

 exit:
     mbedtls_aes_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_OFB */
 void aes_encrypt_ofb(int fragment_size, data_t *key_str,
                      data_t *iv_str, data_t *src_str,
                      data_t *expected_output)
 {
     unsigned char output[32];
     mbedtls_aes_context ctx;
     size_t iv_offset = 0;
     int in_buffer_len;
     unsigned char *src_str_next;

     memset(output, 0x00, sizeof(output));
     mbedtls_aes_init(&ctx);

     TEST_ASSERT((size_t) fragment_size < sizeof(output));

     TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x,
                                        key_str->len * 8) == 0);
     in_buffer_len = src_str->len;
     src_str_next = src_str->x;

     while (in_buffer_len > 0) {
         TEST_ASSERT(mbedtls_aes_crypt_ofb(&ctx, fragment_size, &iv_offset,
                                           iv_str->x, src_str_next, output) == 0);

         TEST_ASSERT(memcmp(output, expected_output->x, fragment_size) == 0);

         in_buffer_len -= fragment_size;
         expected_output->x += fragment_size;
         src_str_next += fragment_size;

         if (in_buffer_len < fragment_size) {
             fragment_size = in_buffer_len;
         }
     }

 exit:
     mbedtls_aes_free(&ctx);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
 void aes_check_params()
 {
     mbedtls_aes_context aes_ctx;
 #if defined(MBEDTLS_CIPHER_MODE_XTS)
     mbedtls_aes_xts_context xts_ctx;
 #endif
     const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
     const unsigned char in[16] = { 0 };
     unsigned char out[16];
     size_t size;
     const int valid_mode = MBEDTLS_AES_ENCRYPT;
     const int invalid_mode = 42;

     TEST_INVALID_PARAM(mbedtls_aes_init(NULL));
 #if defined(MBEDTLS_CIPHER_MODE_XTS)
     TEST_INVALID_PARAM(mbedtls_aes_xts_init(NULL));
 #endif

     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_setkey_enc(NULL, key, 128));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_setkey_enc(&aes_ctx, NULL, 128));

     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_setkey_dec(NULL, key, 128));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_setkey_dec(&aes_ctx, NULL, 128));

 #if defined(MBEDTLS_CIPHER_MODE_XTS)
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_xts_setkey_enc(NULL, key, 128));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_xts_setkey_enc(&xts_ctx, NULL, 128));

     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_xts_setkey_dec(NULL, key, 128));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_xts_setkey_dec(&xts_ctx, NULL, 128));
 #endif


     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ecb(NULL,
                                                  valid_mode, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ecb(&aes_ctx,
                                                  invalid_mode, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ecb(&aes_ctx,
                                                  valid_mode, NULL, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ecb(&aes_ctx,
                                                  valid_mode, in, NULL));

 #if defined(MBEDTLS_CIPHER_MODE_CBC)
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cbc(NULL,
                                                  valid_mode, 16,
                                                  out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cbc(&aes_ctx,
                                                  invalid_mode, 16,
                                                  out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cbc(&aes_ctx,
                                                  valid_mode, 16,
                                                  NULL, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cbc(&aes_ctx,
                                                  valid_mode, 16,
                                                  out, NULL, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cbc(&aes_ctx,
                                                  valid_mode, 16,
                                                  out, in, NULL));
 #endif /* MBEDTLS_CIPHER_MODE_CBC */

 #if defined(MBEDTLS_CIPHER_MODE_XTS)
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_xts(NULL,
                                                  valid_mode, 16,
                                                  in, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_xts(&xts_ctx,
                                                  invalid_mode, 16,
                                                  in, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_xts(&xts_ctx,
                                                  valid_mode, 16,
                                                  NULL, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_xts(&xts_ctx,
                                                  valid_mode, 16,
                                                  in, NULL, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_xts(&xts_ctx,
                                                  valid_mode, 16,
                                                  in, in, NULL));
 #endif /* MBEDTLS_CIPHER_MODE_XTS */

 #if defined(MBEDTLS_CIPHER_MODE_CFB)
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb128(NULL,
                                                     valid_mode, 16,
                                                     &size, out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb128(&aes_ctx,
                                                     invalid_mode, 16,
                                                     &size, out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb128(&aes_ctx,
                                                     valid_mode, 16,
                                                     NULL, out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb128(&aes_ctx,
                                                     valid_mode, 16,
                                                     &size, NULL, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb128(&aes_ctx,
                                                     valid_mode, 16,
                                                     &size, out, NULL, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb128(&aes_ctx,
                                                     valid_mode, 16,
                                                     &size, out, in, NULL));


     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb8(NULL,
                                                   valid_mode, 16,
                                                   out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb8(&aes_ctx,
                                                   invalid_mode, 16,
                                                   out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb8(&aes_ctx,
                                                   valid_mode, 16,
                                                   NULL, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb8(&aes_ctx,
                                                   valid_mode, 16,
                                                   out, NULL, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_cfb8(&aes_ctx,
                                                   valid_mode, 16,
                                                   out, in, NULL));
 #endif /* MBEDTLS_CIPHER_MODE_CFB */

 #if defined(MBEDTLS_CIPHER_MODE_OFB)
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ofb(NULL, 16,
                                                  &size, out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ofb(&aes_ctx, 16,
                                                  NULL, out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ofb(&aes_ctx, 16,
                                                  &size, NULL, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ofb(&aes_ctx, 16,
                                                  &size, out, NULL, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ofb(&aes_ctx, 16,
                                                  &size, out, in, NULL));
 #endif /* MBEDTLS_CIPHER_MODE_OFB */

 #if defined(MBEDTLS_CIPHER_MODE_CTR)
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ctr(NULL, 16, &size, out,
                                                  out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ctr(&aes_ctx, 16, NULL, out,
                                                  out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, NULL,
                                                  out, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, out,
                                                  NULL, in, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, out,
                                                  out, NULL, out));
     TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
                            mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, out,
                                                  out, in, NULL));
 #endif /* MBEDTLS_CIPHER_MODE_CTR */
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void aes_misc_params()
 {
 #if defined(MBEDTLS_CIPHER_MODE_CBC) || \
     defined(MBEDTLS_CIPHER_MODE_XTS) || \
     defined(MBEDTLS_CIPHER_MODE_CFB) || \
     defined(MBEDTLS_CIPHER_MODE_OFB)
     const unsigned char in[16] = { 0 };
     unsigned char out[16];
 #endif
 #if defined(MBEDTLS_CIPHER_MODE_CBC) || \
     defined(MBEDTLS_CIPHER_MODE_CFB) || \
     defined(MBEDTLS_CIPHER_MODE_OFB)
     mbedtls_aes_context aes_ctx;
 #endif
 #if defined(MBEDTLS_CIPHER_MODE_XTS)
     mbedtls_aes_xts_context xts_ctx;
 #endif
 #if defined(MBEDTLS_CIPHER_MODE_CFB) || \
     defined(MBEDTLS_CIPHER_MODE_OFB)
     size_t size;
 #endif

     /* These calls accept NULL */
     TEST_VALID_PARAM(mbedtls_aes_free(NULL));
 #if defined(MBEDTLS_CIPHER_MODE_XTS)
     TEST_VALID_PARAM(mbedtls_aes_xts_free(NULL));
 #endif

 #if defined(MBEDTLS_CIPHER_MODE_CBC)
     TEST_ASSERT(mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_ENCRYPT,
                                       15,
                                       out, in, out)
                 == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
     TEST_ASSERT(mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_ENCRYPT,
                                       17,
                                       out, in, out)
                 == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
 #endif

 #if defined(MBEDTLS_CIPHER_MODE_XTS)
     TEST_ASSERT(mbedtls_aes_crypt_xts(&xts_ctx, MBEDTLS_AES_ENCRYPT,
                                       15,
                                       in, in, out)
                 == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
     TEST_ASSERT(mbedtls_aes_crypt_xts(&xts_ctx, MBEDTLS_AES_ENCRYPT,
                                       (1 << 24) + 1,
                                       in, in, out)
                 == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
 #endif

 #if defined(MBEDTLS_CIPHER_MODE_CFB)
     size = 16;
     TEST_ASSERT(mbedtls_aes_crypt_cfb128(&aes_ctx, MBEDTLS_AES_ENCRYPT, 16,
                                          &size, out, in, out)
                 == MBEDTLS_ERR_AES_BAD_INPUT_DATA);
 #endif

 #if defined(MBEDTLS_CIPHER_MODE_OFB)
     size = 16;
     TEST_ASSERT(mbedtls_aes_crypt_ofb(&aes_ctx, 16, &size, out, in, out)
                 == MBEDTLS_ERR_AES_BAD_INPUT_DATA);
 #endif
 }
 /* END_CASE */

 /* BEGIN_CASE */
 void aes_ecb_context_alignment(data_t *key)
 {
     /* We test alignment multiple times, with different alignments
      * of the context and of the plaintext/ciphertext. */

     struct align0 {
         mbedtls_aes_context ctx;
     };
     struct align0 *enc0 = NULL;
     struct align0 *dec0 = NULL;

     struct align1 {
         char bump;
         mbedtls_aes_context ctx;
     };
     struct align1 *enc1 = NULL;
     struct align1 *dec1 = NULL;

     /* All peak alignment */
     TEST_CALLOC(enc0, 1);
     TEST_CALLOC(dec0, 1);
     if (!test_ctx_alignment(key, &enc0->ctx, &dec0->ctx)) {
         goto exit;
     }
     mbedtls_free(enc0);
     enc0 = NULL;
     mbedtls_free(dec0);
     dec0 = NULL;

     /* Enc aligned, dec not */
     TEST_CALLOC(enc0, 1);
     TEST_CALLOC(dec1, 1);
     if (!test_ctx_alignment(key, &enc0->ctx, &dec1->ctx)) {
         goto exit;
     }
     mbedtls_free(enc0);
     enc0 = NULL;
     mbedtls_free(dec1);
     dec1 = NULL;

     /* Dec aligned, enc not */
     TEST_CALLOC(enc1, 1);
     TEST_CALLOC(dec0, 1);
     if (!test_ctx_alignment(key, &enc1->ctx, &dec0->ctx)) {
         goto exit;
     }
     mbedtls_free(enc1);
     enc1 = NULL;
     mbedtls_free(dec0);
     dec0 = NULL;

     /* Both shifted */
     TEST_CALLOC(enc1, 1);
     TEST_CALLOC(dec1, 1);
     if (!test_ctx_alignment(key, &enc1->ctx, &dec1->ctx)) {
         goto exit;
     }
     mbedtls_free(enc1);
     enc1 = NULL;
     mbedtls_free(dec1);
     dec1 = NULL;

 exit:
     mbedtls_free(enc0);
     mbedtls_free(dec0);
     mbedtls_free(enc1);
     mbedtls_free(dec1);
 }
 /* END_CASE */

 /* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
 void aes_selftest()
 {
     TEST_ASSERT(mbedtls_aes_self_test(1) == 0);
 }
 /* END_CASE */
	/* BEGIN_HEADER */
	#include "mbedtls/aes.h"

	/* Test AES with a copied context.
	*
	* enc and dec must be AES context objects. They don't need to
	* be initialized, and are left freed.
	*/
	static int test_ctx_alignment(const data_t *key,
	mbedtls_aes_context *enc,
	mbedtls_aes_context *dec)
	{
	unsigned char plaintext[16] = {
	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
	};
	unsigned char ciphertext[16];
	unsigned char output[16];

	// Set key and encrypt with original context
	mbedtls_aes_init(enc);
	TEST_ASSERT(mbedtls_aes_setkey_enc(enc, key->x, key->len * 8) == 0);
	TEST_ASSERT(mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_ENCRYPT,
	plaintext, ciphertext) == 0);

	// Set key for decryption with original context
	mbedtls_aes_init(dec);
	TEST_ASSERT(mbedtls_aes_setkey_dec(dec, key->x, key->len * 8) == 0);

	// Wipe the original context to make sure nothing from it is used
	memset(enc, 0, sizeof(*enc));
	mbedtls_aes_free(enc);

	// Decrypt
	TEST_ASSERT(mbedtls_aes_crypt_ecb(dec, MBEDTLS_AES_DECRYPT,
	ciphertext, output) == 0);
	TEST_BUFFERS_EQUAL(plaintext, 16, output, 16);

	mbedtls_aes_free(dec);

	return 1;

	exit:
	/* Bug: we may be leaving something unfreed. This is harmless
	* in our built-in implementations, but might cause a memory leak
	* with alternative implementations. */
	return 0;
	}

	/* END_HEADER */

	/* BEGIN_DEPENDENCIES
	* depends_on:MBEDTLS_AES_C
	* END_DEPENDENCIES
	*/

	/* BEGIN_CASE */
	void aes_encrypt_ecb(data_t key_str, data_t src_str,
	data_t *dst, int setkey_result)
	{
	unsigned char output[100];
	mbedtls_aes_context ctx;

	memset(output, 0x00, 100);

	mbedtls_aes_init(&ctx);

	TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == setkey_result);
	if (setkey_result == 0) {
	TEST_ASSERT(mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_ENCRYPT, src_str->x, output) == 0);

	TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
	}

	exit:
	mbedtls_aes_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void aes_decrypt_ecb(data_t key_str, data_t src_str,
	data_t *dst, int setkey_result)
	{
	unsigned char output[100];
	mbedtls_aes_context ctx;

	memset(output, 0x00, 100);

	mbedtls_aes_init(&ctx);

	TEST_ASSERT(mbedtls_aes_setkey_dec(&ctx, key_str->x, key_str->len * 8) == setkey_result);
	if (setkey_result == 0) {
	TEST_ASSERT(mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_DECRYPT, src_str->x, output) == 0);

	TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
	}

	exit:
	mbedtls_aes_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
	void aes_encrypt_cbc(data_t key_str, data_t iv_str,
	data_t src_str, data_t dst,
	int cbc_result)
	{
	unsigned char output[100];
	mbedtls_aes_context ctx;

	memset(output, 0x00, 100);

	mbedtls_aes_init(&ctx);

	TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
	TEST_ASSERT(mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x,
	src_str->x, output) == cbc_result);
	if (cbc_result == 0) {

	TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
	src_str->len, dst->len) == 0);
	}

	exit:
	mbedtls_aes_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
	void aes_decrypt_cbc(data_t key_str, data_t iv_str,
	data_t src_str, data_t dst,
	int cbc_result)
	{
	unsigned char output[100];
	mbedtls_aes_context ctx;

	memset(output, 0x00, 100);
	mbedtls_aes_init(&ctx);

	TEST_ASSERT(mbedtls_aes_setkey_dec(&ctx, key_str->x, key_str->len * 8) == 0);
	TEST_ASSERT(mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x,
	src_str->x, output) == cbc_result);
	if (cbc_result == 0) {

	TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
	src_str->len, dst->len) == 0);
	}

	exit:
	mbedtls_aes_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
	void aes_encrypt_xts(char hex_key_string, char hex_data_unit_string,
	char hex_src_string, char hex_dst_string)
	{
	enum { AES_BLOCK_SIZE = 16 };
	unsigned char *data_unit = NULL;
	unsigned char *key = NULL;
	unsigned char *src = NULL;
	unsigned char *dst = NULL;
	unsigned char *output = NULL;
	mbedtls_aes_xts_context ctx;
	size_t key_len, src_len, dst_len, data_unit_len;

	mbedtls_aes_xts_init(&ctx);

	data_unit = mbedtls_test_unhexify_alloc(hex_data_unit_string,
	&data_unit_len);
	TEST_ASSERT(data_unit_len == AES_BLOCK_SIZE);

	key = mbedtls_test_unhexify_alloc(hex_key_string, &key_len);
	TEST_ASSERT(key_len % 2 == 0);

	src = mbedtls_test_unhexify_alloc(hex_src_string, &src_len);
	dst = mbedtls_test_unhexify_alloc(hex_dst_string, &dst_len);
	TEST_ASSERT(src_len == dst_len);

	output = mbedtls_test_zero_alloc(dst_len);

	TEST_ASSERT(mbedtls_aes_xts_setkey_enc(&ctx, key, key_len * 8) == 0);
	TEST_ASSERT(mbedtls_aes_crypt_xts(&ctx, MBEDTLS_AES_ENCRYPT, src_len,
	data_unit, src, output) == 0);

	TEST_ASSERT(memcmp(output, dst, dst_len) == 0);

	exit:
	mbedtls_aes_xts_free(&ctx);
	mbedtls_free(data_unit);
	mbedtls_free(key);
	mbedtls_free(src);
	mbedtls_free(dst);
	mbedtls_free(output);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
	void aes_decrypt_xts(char hex_key_string, char hex_data_unit_string,
	char hex_dst_string, char hex_src_string)
	{
	enum { AES_BLOCK_SIZE = 16 };
	unsigned char *data_unit = NULL;
	unsigned char *key = NULL;
	unsigned char *src = NULL;
	unsigned char *dst = NULL;
	unsigned char *output = NULL;
	mbedtls_aes_xts_context ctx;
	size_t key_len, src_len, dst_len, data_unit_len;

	mbedtls_aes_xts_init(&ctx);

	data_unit = mbedtls_test_unhexify_alloc(hex_data_unit_string,
	&data_unit_len);
	TEST_ASSERT(data_unit_len == AES_BLOCK_SIZE);

	key = mbedtls_test_unhexify_alloc(hex_key_string, &key_len);
	TEST_ASSERT(key_len % 2 == 0);

	src = mbedtls_test_unhexify_alloc(hex_src_string, &src_len);
	dst = mbedtls_test_unhexify_alloc(hex_dst_string, &dst_len);
	TEST_ASSERT(src_len == dst_len);

	output = mbedtls_test_zero_alloc(dst_len);

	TEST_ASSERT(mbedtls_aes_xts_setkey_dec(&ctx, key, key_len * 8) == 0);
	TEST_ASSERT(mbedtls_aes_crypt_xts(&ctx, MBEDTLS_AES_DECRYPT, src_len,
	data_unit, src, output) == 0);

	TEST_ASSERT(memcmp(output, dst, dst_len) == 0);

	exit:
	mbedtls_aes_xts_free(&ctx);
	mbedtls_free(data_unit);
	mbedtls_free(key);
	mbedtls_free(src);
	mbedtls_free(dst);
	mbedtls_free(output);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
	void aes_crypt_xts_size(int size, int retval)
	{
	mbedtls_aes_xts_context ctx;
	const unsigned char src[16] = { 0 };
	unsigned char output[16];
	unsigned char data_unit[16];
	size_t length = size;

	mbedtls_aes_xts_init(&ctx);
	memset(data_unit, 0x00, sizeof(data_unit));


	/* Valid pointers are passed for builds with MBEDTLS_CHECK_PARAMS, as
	* otherwise we wouldn't get to the size check we're interested in. */
	TEST_ASSERT(mbedtls_aes_crypt_xts(&ctx, MBEDTLS_AES_ENCRYPT, length, data_unit, src,
	output) == retval);
	exit:
	mbedtls_aes_xts_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
	void aes_crypt_xts_keysize(int size, int retval)
	{
	mbedtls_aes_xts_context ctx;
	const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
	size_t key_len = size;

	mbedtls_aes_xts_init(&ctx);

	TEST_ASSERT(mbedtls_aes_xts_setkey_enc(&ctx, key, key_len * 8) == retval);
	TEST_ASSERT(mbedtls_aes_xts_setkey_dec(&ctx, key, key_len * 8) == retval);
	exit:
	mbedtls_aes_xts_free(&ctx);
	}
	/* END_CASE */


	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
	void aes_encrypt_cfb128(data_t key_str, data_t iv_str,
	data_t src_str, data_t dst)
	{
	unsigned char output[100];
	mbedtls_aes_context ctx;
	size_t iv_offset = 0;

	memset(output, 0x00, 100);
	mbedtls_aes_init(&ctx);


	TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
	TEST_ASSERT(mbedtls_aes_crypt_cfb128(&ctx, MBEDTLS_AES_ENCRYPT, 16, &iv_offset, iv_str->x,
	src_str->x, output) == 0);

	TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);

	exit:
	mbedtls_aes_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
	void aes_decrypt_cfb128(data_t key_str, data_t iv_str,
	data_t src_str, data_t dst)
	{
	unsigned char output[100];
	mbedtls_aes_context ctx;
	size_t iv_offset = 0;

	memset(output, 0x00, 100);
	mbedtls_aes_init(&ctx);


	TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
	TEST_ASSERT(mbedtls_aes_crypt_cfb128(&ctx, MBEDTLS_AES_DECRYPT, 16, &iv_offset, iv_str->x,
	src_str->x, output) == 0);

	TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);

	exit:
	mbedtls_aes_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
	void aes_encrypt_cfb8(data_t key_str, data_t iv_str,
	data_t src_str, data_t dst)
	{
	unsigned char output[100];
	mbedtls_aes_context ctx;

	memset(output, 0x00, 100);
	mbedtls_aes_init(&ctx);


	TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
	TEST_ASSERT(mbedtls_aes_crypt_cfb8(&ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x,
	src_str->x, output) == 0);

	TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
	src_str->len, dst->len) == 0);

	exit:
	mbedtls_aes_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
	void aes_decrypt_cfb8(data_t key_str, data_t iv_str,
	data_t src_str, data_t dst)
	{
	unsigned char output[100];
	mbedtls_aes_context ctx;

	memset(output, 0x00, 100);
	mbedtls_aes_init(&ctx);


	TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
	TEST_ASSERT(mbedtls_aes_crypt_cfb8(&ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x,
	src_str->x, output) == 0);

	TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
	src_str->len, dst->len) == 0);

	exit:
	mbedtls_aes_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_OFB */
	void aes_encrypt_ofb(int fragment_size, data_t *key_str,
	data_t iv_str, data_t src_str,
	data_t *expected_output)
	{
	unsigned char output[32];
	mbedtls_aes_context ctx;
	size_t iv_offset = 0;
	int in_buffer_len;
	unsigned char *src_str_next;

	memset(output, 0x00, sizeof(output));
	mbedtls_aes_init(&ctx);

	TEST_ASSERT((size_t) fragment_size < sizeof(output));

	TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x,
	key_str->len * 8) == 0);
	in_buffer_len = src_str->len;
	src_str_next = src_str->x;

	while (in_buffer_len > 0) {
	TEST_ASSERT(mbedtls_aes_crypt_ofb(&ctx, fragment_size, &iv_offset,
	iv_str->x, src_str_next, output) == 0);

	TEST_ASSERT(memcmp(output, expected_output->x, fragment_size) == 0);

	in_buffer_len -= fragment_size;
	expected_output->x += fragment_size;
	src_str_next += fragment_size;

	if (in_buffer_len < fragment_size) {
	fragment_size = in_buffer_len;
	}
	}

	exit:
	mbedtls_aes_free(&ctx);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
	void aes_check_params()
	{
	mbedtls_aes_context aes_ctx;
	#if defined(MBEDTLS_CIPHER_MODE_XTS)
	mbedtls_aes_xts_context xts_ctx;
	#endif
	const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
	const unsigned char in[16] = { 0 };
	unsigned char out[16];
	size_t size;
	const int valid_mode = MBEDTLS_AES_ENCRYPT;
	const int invalid_mode = 42;

	TEST_INVALID_PARAM(mbedtls_aes_init(NULL));
	#if defined(MBEDTLS_CIPHER_MODE_XTS)
	TEST_INVALID_PARAM(mbedtls_aes_xts_init(NULL));
	#endif

	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_setkey_enc(NULL, key, 128));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_setkey_enc(&aes_ctx, NULL, 128));

	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_setkey_dec(NULL, key, 128));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_setkey_dec(&aes_ctx, NULL, 128));

	#if defined(MBEDTLS_CIPHER_MODE_XTS)
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_xts_setkey_enc(NULL, key, 128));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_xts_setkey_enc(&xts_ctx, NULL, 128));

	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_xts_setkey_dec(NULL, key, 128));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_xts_setkey_dec(&xts_ctx, NULL, 128));
	#endif


	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ecb(NULL,
	valid_mode, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ecb(&aes_ctx,
	invalid_mode, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ecb(&aes_ctx,
	valid_mode, NULL, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ecb(&aes_ctx,
	valid_mode, in, NULL));

	#if defined(MBEDTLS_CIPHER_MODE_CBC)
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cbc(NULL,
	valid_mode, 16,
	out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cbc(&aes_ctx,
	invalid_mode, 16,
	out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cbc(&aes_ctx,
	valid_mode, 16,
	NULL, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cbc(&aes_ctx,
	valid_mode, 16,
	out, NULL, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cbc(&aes_ctx,
	valid_mode, 16,
	out, in, NULL));
	#endif /* MBEDTLS_CIPHER_MODE_CBC */

	#if defined(MBEDTLS_CIPHER_MODE_XTS)
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_xts(NULL,
	valid_mode, 16,
	in, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_xts(&xts_ctx,
	invalid_mode, 16,
	in, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_xts(&xts_ctx,
	valid_mode, 16,
	NULL, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_xts(&xts_ctx,
	valid_mode, 16,
	in, NULL, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_xts(&xts_ctx,
	valid_mode, 16,
	in, in, NULL));
	#endif /* MBEDTLS_CIPHER_MODE_XTS */

	#if defined(MBEDTLS_CIPHER_MODE_CFB)
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb128(NULL,
	valid_mode, 16,
	&size, out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb128(&aes_ctx,
	invalid_mode, 16,
	&size, out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb128(&aes_ctx,
	valid_mode, 16,
	NULL, out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb128(&aes_ctx,
	valid_mode, 16,
	&size, NULL, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb128(&aes_ctx,
	valid_mode, 16,
	&size, out, NULL, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb128(&aes_ctx,
	valid_mode, 16,
	&size, out, in, NULL));


	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb8(NULL,
	valid_mode, 16,
	out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb8(&aes_ctx,
	invalid_mode, 16,
	out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb8(&aes_ctx,
	valid_mode, 16,
	NULL, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb8(&aes_ctx,
	valid_mode, 16,
	out, NULL, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_cfb8(&aes_ctx,
	valid_mode, 16,
	out, in, NULL));
	#endif /* MBEDTLS_CIPHER_MODE_CFB */

	#if defined(MBEDTLS_CIPHER_MODE_OFB)
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ofb(NULL, 16,
	&size, out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ofb(&aes_ctx, 16,
	NULL, out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ofb(&aes_ctx, 16,
	&size, NULL, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ofb(&aes_ctx, 16,
	&size, out, NULL, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ofb(&aes_ctx, 16,
	&size, out, in, NULL));
	#endif /* MBEDTLS_CIPHER_MODE_OFB */

	#if defined(MBEDTLS_CIPHER_MODE_CTR)
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ctr(NULL, 16, &size, out,
	out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ctr(&aes_ctx, 16, NULL, out,
	out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, NULL,
	out, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, out,
	NULL, in, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, out,
	out, NULL, out));
	TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
	mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, out,
	out, in, NULL));
	#endif /* MBEDTLS_CIPHER_MODE_CTR */
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void aes_misc_params()
	{
	#if defined(MBEDTLS_CIPHER_MODE_CBC) \|\| \
	defined(MBEDTLS_CIPHER_MODE_XTS) \|\| \
	defined(MBEDTLS_CIPHER_MODE_CFB) \|\| \
	defined(MBEDTLS_CIPHER_MODE_OFB)
	const unsigned char in[16] = { 0 };
	unsigned char out[16];
	#endif
	#if defined(MBEDTLS_CIPHER_MODE_CBC) \|\| \
	defined(MBEDTLS_CIPHER_MODE_CFB) \|\| \
	defined(MBEDTLS_CIPHER_MODE_OFB)
	mbedtls_aes_context aes_ctx;
	#endif
	#if defined(MBEDTLS_CIPHER_MODE_XTS)
	mbedtls_aes_xts_context xts_ctx;
	#endif
	#if defined(MBEDTLS_CIPHER_MODE_CFB) \|\| \
	defined(MBEDTLS_CIPHER_MODE_OFB)
	size_t size;
	#endif

	/* These calls accept NULL */
	TEST_VALID_PARAM(mbedtls_aes_free(NULL));
	#if defined(MBEDTLS_CIPHER_MODE_XTS)
	TEST_VALID_PARAM(mbedtls_aes_xts_free(NULL));
	#endif

	#if defined(MBEDTLS_CIPHER_MODE_CBC)
	TEST_ASSERT(mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_ENCRYPT,
	15,
	out, in, out)
	== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
	TEST_ASSERT(mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_ENCRYPT,
	17,
	out, in, out)
	== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
	#endif

	#if defined(MBEDTLS_CIPHER_MODE_XTS)
	TEST_ASSERT(mbedtls_aes_crypt_xts(&xts_ctx, MBEDTLS_AES_ENCRYPT,
	15,
	in, in, out)
	== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
	TEST_ASSERT(mbedtls_aes_crypt_xts(&xts_ctx, MBEDTLS_AES_ENCRYPT,
	(1 << 24) + 1,
	in, in, out)
	== MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
	#endif

	#if defined(MBEDTLS_CIPHER_MODE_CFB)
	size = 16;
	TEST_ASSERT(mbedtls_aes_crypt_cfb128(&aes_ctx, MBEDTLS_AES_ENCRYPT, 16,
	&size, out, in, out)
	== MBEDTLS_ERR_AES_BAD_INPUT_DATA);
	#endif

	#if defined(MBEDTLS_CIPHER_MODE_OFB)
	size = 16;
	TEST_ASSERT(mbedtls_aes_crypt_ofb(&aes_ctx, 16, &size, out, in, out)
	== MBEDTLS_ERR_AES_BAD_INPUT_DATA);
	#endif
	}
	/* END_CASE */

	/* BEGIN_CASE */
	void aes_ecb_context_alignment(data_t *key)
	{
	/* We test alignment multiple times, with different alignments
	* of the context and of the plaintext/ciphertext. */

	struct align0 {
	mbedtls_aes_context ctx;
	};
	struct align0 *enc0 = NULL;
	struct align0 *dec0 = NULL;

	struct align1 {
	char bump;
	mbedtls_aes_context ctx;
	};
	struct align1 *enc1 = NULL;
	struct align1 *dec1 = NULL;

	/* All peak alignment */
	TEST_CALLOC(enc0, 1);
	TEST_CALLOC(dec0, 1);
	if (!test_ctx_alignment(key, &enc0->ctx, &dec0->ctx)) {
	goto exit;
	}
	mbedtls_free(enc0);
	enc0 = NULL;
	mbedtls_free(dec0);
	dec0 = NULL;

	/* Enc aligned, dec not */
	TEST_CALLOC(enc0, 1);
	TEST_CALLOC(dec1, 1);
	if (!test_ctx_alignment(key, &enc0->ctx, &dec1->ctx)) {
	goto exit;
	}
	mbedtls_free(enc0);
	enc0 = NULL;
	mbedtls_free(dec1);
	dec1 = NULL;

	/* Dec aligned, enc not */
	TEST_CALLOC(enc1, 1);
	TEST_CALLOC(dec0, 1);
	if (!test_ctx_alignment(key, &enc1->ctx, &dec0->ctx)) {
	goto exit;
	}
	mbedtls_free(enc1);
	enc1 = NULL;
	mbedtls_free(dec0);
	dec0 = NULL;

	/* Both shifted */
	TEST_CALLOC(enc1, 1);
	TEST_CALLOC(dec1, 1);
	if (!test_ctx_alignment(key, &enc1->ctx, &dec1->ctx)) {
	goto exit;
	}
	mbedtls_free(enc1);
	enc1 = NULL;
	mbedtls_free(dec1);
	dec1 = NULL;

	exit:
	mbedtls_free(enc0);
	mbedtls_free(dec0);
	mbedtls_free(enc1);
	mbedtls_free(dec1);
	}
	/* END_CASE */

	/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
	void aes_selftest()
	{
	TEST_ASSERT(mbedtls_aes_self_test(1) == 0);
	}
	/* END_CASE */