1/* BEGIN_HEADER */
2#include "mbedtls/aes.h"
3/* END_HEADER */
4
5/* BEGIN_DEPENDENCIES
6 * depends_on:MBEDTLS_AES_C
7 * END_DEPENDENCIES
8 */
9
10/* BEGIN_CASE */
11void aes_encrypt_ecb( data_t * key_str, data_t * src_str,
12                      data_t * dst, int setkey_result )
13{
14    unsigned char output[100];
15    mbedtls_aes_context ctx;
16
17    memset(output, 0x00, 100);
18
19    mbedtls_aes_init( &ctx );
20
21    TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
22    if( setkey_result == 0 )
23    {
24        TEST_ASSERT( mbedtls_aes_crypt_ecb( &ctx, MBEDTLS_AES_ENCRYPT, src_str->x, output ) == 0 );
25
26        TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
27    }
28
29exit:
30    mbedtls_aes_free( &ctx );
31}
32/* END_CASE */
33
34/* BEGIN_CASE */
35void aes_decrypt_ecb( data_t * key_str, data_t * src_str,
36                      data_t * dst, int setkey_result )
37{
38    unsigned char output[100];
39    mbedtls_aes_context ctx;
40
41    memset(output, 0x00, 100);
42
43    mbedtls_aes_init( &ctx );
44
45    TEST_ASSERT( mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
46    if( setkey_result == 0 )
47    {
48        TEST_ASSERT( mbedtls_aes_crypt_ecb( &ctx, MBEDTLS_AES_DECRYPT, src_str->x, output ) == 0 );
49
50        TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
51    }
52
53exit:
54    mbedtls_aes_free( &ctx );
55}
56/* END_CASE */
57
58/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
59void aes_encrypt_cbc( data_t * key_str, data_t * iv_str,
60                      data_t * src_str, data_t * dst,
61                      int cbc_result )
62{
63    unsigned char output[100];
64    mbedtls_aes_context ctx;
65
66    memset(output, 0x00, 100);
67
68    mbedtls_aes_init( &ctx );
69
70    TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
71    TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
72    if( cbc_result == 0 )
73    {
74
75        TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
76                                          src_str->len, dst->len ) == 0 );
77    }
78
79exit:
80    mbedtls_aes_free( &ctx );
81}
82/* END_CASE */
83
84/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
85void aes_decrypt_cbc( data_t * key_str, data_t * iv_str,
86                      data_t * src_str, data_t * dst,
87                      int cbc_result )
88{
89    unsigned char output[100];
90    mbedtls_aes_context ctx;
91
92    memset(output, 0x00, 100);
93    mbedtls_aes_init( &ctx );
94
95    TEST_ASSERT( mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 ) == 0 );
96    TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
97    if( cbc_result == 0)
98    {
99
100        TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
101                                          src_str->len, dst->len ) == 0 );
102    }
103
104exit:
105    mbedtls_aes_free( &ctx );
106}
107/* END_CASE */
108
109/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
110void aes_encrypt_xts( char *hex_key_string, char *hex_data_unit_string,
111                      char *hex_src_string, char *hex_dst_string )
112{
113    enum { AES_BLOCK_SIZE = 16 };
114    unsigned char *data_unit = NULL;
115    unsigned char *key = NULL;
116    unsigned char *src = NULL;
117    unsigned char *dst = NULL;
118    unsigned char *output = NULL;
119    mbedtls_aes_xts_context ctx;
120    size_t key_len, src_len, dst_len, data_unit_len;
121
122    mbedtls_aes_xts_init( &ctx );
123
124    data_unit = mbedtls_test_unhexify_alloc( hex_data_unit_string,
125                                             &data_unit_len );
126    TEST_ASSERT( data_unit_len == AES_BLOCK_SIZE );
127
128    key = mbedtls_test_unhexify_alloc( hex_key_string, &key_len );
129    TEST_ASSERT( key_len % 2 == 0 );
130
131    src = mbedtls_test_unhexify_alloc( hex_src_string, &src_len );
132    dst = mbedtls_test_unhexify_alloc( hex_dst_string, &dst_len );
133    TEST_ASSERT( src_len == dst_len );
134
135    output = mbedtls_test_zero_alloc( dst_len );
136
137    TEST_ASSERT( mbedtls_aes_xts_setkey_enc( &ctx, key, key_len * 8 ) == 0 );
138    TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, src_len,
139                                        data_unit, src, output ) == 0 );
140
141    TEST_ASSERT( memcmp( output, dst, dst_len ) == 0 );
142
143exit:
144    mbedtls_aes_xts_free( &ctx );
145    mbedtls_free( data_unit );
146    mbedtls_free( key );
147    mbedtls_free( src );
148    mbedtls_free( dst );
149    mbedtls_free( output );
150}
151/* END_CASE */
152
153/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
154void aes_decrypt_xts( char *hex_key_string, char *hex_data_unit_string,
155                      char *hex_dst_string, char *hex_src_string )
156{
157    enum { AES_BLOCK_SIZE = 16 };
158    unsigned char *data_unit = NULL;
159    unsigned char *key = NULL;
160    unsigned char *src = NULL;
161    unsigned char *dst = NULL;
162    unsigned char *output = NULL;
163    mbedtls_aes_xts_context ctx;
164    size_t key_len, src_len, dst_len, data_unit_len;
165
166    mbedtls_aes_xts_init( &ctx );
167
168    data_unit = mbedtls_test_unhexify_alloc( hex_data_unit_string,
169                                             &data_unit_len );
170    TEST_ASSERT( data_unit_len == AES_BLOCK_SIZE );
171
172    key = mbedtls_test_unhexify_alloc( hex_key_string, &key_len );
173    TEST_ASSERT( key_len % 2 == 0 );
174
175    src = mbedtls_test_unhexify_alloc( hex_src_string, &src_len );
176    dst = mbedtls_test_unhexify_alloc( hex_dst_string, &dst_len );
177    TEST_ASSERT( src_len == dst_len );
178
179    output = mbedtls_test_zero_alloc( dst_len );
180
181    TEST_ASSERT( mbedtls_aes_xts_setkey_dec( &ctx, key, key_len * 8 ) == 0 );
182    TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_DECRYPT, src_len,
183                                        data_unit, src, output ) == 0 );
184
185    TEST_ASSERT( memcmp( output, dst, dst_len ) == 0 );
186
187exit:
188    mbedtls_aes_xts_free( &ctx );
189    mbedtls_free( data_unit );
190    mbedtls_free( key );
191    mbedtls_free( src );
192    mbedtls_free( dst );
193    mbedtls_free( output );
194}
195/* END_CASE */
196
197/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
198void aes_crypt_xts_size( int size, int retval )
199{
200    mbedtls_aes_xts_context ctx;
201    const unsigned char src[16] = { 0 };
202    unsigned char output[16];
203    unsigned char data_unit[16];
204    size_t length = size;
205
206    mbedtls_aes_xts_init( &ctx );
207    memset( data_unit, 0x00, sizeof( data_unit ) );
208
209    TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, length, data_unit, src, output ) == retval );
210exit:
211    mbedtls_aes_xts_free( &ctx );
212}
213/* END_CASE */
214
215/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
216void aes_crypt_xts_keysize( int size, int retval )
217{
218    mbedtls_aes_xts_context ctx;
219    const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
220    size_t key_len = size;
221
222    mbedtls_aes_xts_init( &ctx );
223
224    TEST_ASSERT( mbedtls_aes_xts_setkey_enc( &ctx, key, key_len * 8 ) == retval );
225    TEST_ASSERT( mbedtls_aes_xts_setkey_dec( &ctx, key, key_len * 8 ) == retval );
226exit:
227    mbedtls_aes_xts_free( &ctx );
228}
229/* END_CASE */
230
231
232/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
233void aes_encrypt_cfb128( data_t * key_str, data_t * iv_str,
234                         data_t * src_str, data_t * dst )
235{
236    unsigned char output[100];
237    mbedtls_aes_context ctx;
238    size_t iv_offset = 0;
239
240    memset(output, 0x00, 100);
241    mbedtls_aes_init( &ctx );
242
243
244    TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
245    TEST_ASSERT( mbedtls_aes_crypt_cfb128( &ctx, MBEDTLS_AES_ENCRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
246
247    TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
248
249exit:
250    mbedtls_aes_free( &ctx );
251}
252/* END_CASE */
253
254/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
255void aes_decrypt_cfb128( data_t * key_str, data_t * iv_str,
256                         data_t * src_str, data_t * dst )
257{
258    unsigned char output[100];
259    mbedtls_aes_context ctx;
260    size_t iv_offset = 0;
261
262    memset(output, 0x00, 100);
263    mbedtls_aes_init( &ctx );
264
265
266    TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
267    TEST_ASSERT( mbedtls_aes_crypt_cfb128( &ctx, MBEDTLS_AES_DECRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
268
269    TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
270
271exit:
272    mbedtls_aes_free( &ctx );
273}
274/* END_CASE */
275
276/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
277void aes_encrypt_cfb8( data_t * key_str, data_t * iv_str,
278                       data_t * src_str, data_t * dst )
279{
280    unsigned char output[100];
281    mbedtls_aes_context ctx;
282
283    memset(output, 0x00, 100);
284    mbedtls_aes_init( &ctx );
285
286
287    TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
288    TEST_ASSERT( mbedtls_aes_crypt_cfb8( &ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == 0 );
289
290    TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
291                                      src_str->len, dst->len ) == 0 );
292
293exit:
294    mbedtls_aes_free( &ctx );
295}
296/* END_CASE */
297
298/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
299void aes_decrypt_cfb8( data_t * key_str, data_t * iv_str,
300                       data_t * src_str, data_t * dst )
301{
302    unsigned char output[100];
303    mbedtls_aes_context ctx;
304
305    memset(output, 0x00, 100);
306    mbedtls_aes_init( &ctx );
307
308
309    TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
310    TEST_ASSERT( mbedtls_aes_crypt_cfb8( &ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == 0 );
311
312    TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
313                                      src_str->len, dst->len ) == 0 );
314
315exit:
316    mbedtls_aes_free( &ctx );
317}
318/* END_CASE */
319
320/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_OFB */
321void aes_encrypt_ofb( int fragment_size, data_t *key_str,
322                      data_t *iv_str, data_t *src_str,
323                      data_t *expected_output )
324{
325    unsigned char output[32];
326    mbedtls_aes_context ctx;
327    size_t iv_offset = 0;
328    int in_buffer_len;
329    unsigned char* src_str_next;
330
331    memset( output, 0x00, sizeof( output ) );
332    mbedtls_aes_init( &ctx );
333
334    TEST_ASSERT( (size_t)fragment_size < sizeof( output ) );
335
336    TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x,
337                                         key_str->len * 8 ) == 0 );
338    in_buffer_len = src_str->len;
339    src_str_next = src_str->x;
340
341    while( in_buffer_len > 0 )
342    {
343        TEST_ASSERT( mbedtls_aes_crypt_ofb( &ctx, fragment_size, &iv_offset,
344                                            iv_str->x, src_str_next, output ) == 0 );
345
346        TEST_ASSERT( memcmp( output, expected_output->x, fragment_size ) == 0 );
347
348        in_buffer_len -= fragment_size;
349        expected_output->x += fragment_size;
350        src_str_next += fragment_size;
351
352        if( in_buffer_len < fragment_size )
353            fragment_size = in_buffer_len;
354    }
355
356exit:
357    mbedtls_aes_free( &ctx );
358}
359/* END_CASE */
360
361/* BEGIN_CASE depends_on:NOT_DEFINED */
362void aes_invalid_mode( )
363{
364    mbedtls_aes_context aes_ctx;
365    const unsigned char in[16] = { 0 };
366    unsigned char out[16];
367    const int invalid_mode = 42;
368
369    TEST_EQUAL( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
370                mbedtls_aes_crypt_ecb( &aes_ctx, invalid_mode, in, out ) );
371
372#if defined(MBEDTLS_CIPHER_MODE_CBC)
373    TEST_EQUAL( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
374                mbedtls_aes_crypt_cbc( &aes_ctx, invalid_mode, 16,
375                                       out, in, out ) );
376#endif /* MBEDTLS_CIPHER_MODE_CBC */
377
378#if defined(MBEDTLS_CIPHER_MODE_XTS)
379    mbedtls_aes_xts_context xts_ctx;
380
381    TEST_EQUAL( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
382                mbedtls_aes_crypt_xts( &xts_ctx, invalid_mode, 16,
383                                       in, in, out ) );
384#endif /* MBEDTLS_CIPHER_MODE_XTS */
385
386#if defined(MBEDTLS_CIPHER_MODE_CFB)
387    size_t size;
388
389    TEST_EQUAL( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
390                mbedtls_aes_crypt_cfb128( &aes_ctx, invalid_mode, 16,
391                                          &size, out, in, out ) );
392    TEST_EQUAL( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
393                mbedtls_aes_crypt_cfb8( &aes_ctx, invalid_mode, 16,
394                                        out, in, out ) );
395#endif /* MBEDTLS_CIPHER_MODE_CFB */
396}
397/* END_CASE */
398
399/* BEGIN_CASE */
400void aes_misc_params( )
401{
402#if defined(MBEDTLS_CIPHER_MODE_CBC) || \
403    defined(MBEDTLS_CIPHER_MODE_XTS) || \
404    defined(MBEDTLS_CIPHER_MODE_CFB) || \
405    defined(MBEDTLS_CIPHER_MODE_OFB)
406    mbedtls_aes_context aes_ctx;
407    const unsigned char in[16] = { 0 };
408    unsigned char out[16];
409#endif
410#if defined(MBEDTLS_CIPHER_MODE_XTS)
411    mbedtls_aes_xts_context xts_ctx;
412#endif
413#if defined(MBEDTLS_CIPHER_MODE_CFB) || \
414    defined(MBEDTLS_CIPHER_MODE_OFB)
415    size_t size;
416#endif
417
418#if defined(MBEDTLS_CIPHER_MODE_CBC)
419    TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
420                                        15,
421                                        out, in, out )
422                 == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
423    TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
424                                        17,
425                                        out, in, out )
426                 == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
427#endif
428
429#if defined(MBEDTLS_CIPHER_MODE_XTS)
430    TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
431                                        15,
432                                        in, in, out )
433                 == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
434    TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
435                                        (1 << 24) + 1,
436                                        in, in, out )
437                 == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
438#endif
439
440#if defined(MBEDTLS_CIPHER_MODE_CFB)
441    size = 16;
442    TEST_ASSERT( mbedtls_aes_crypt_cfb128( &aes_ctx, MBEDTLS_AES_ENCRYPT, 16,
443                                           &size, out, in, out )
444                 == MBEDTLS_ERR_AES_BAD_INPUT_DATA );
445#endif
446
447#if defined(MBEDTLS_CIPHER_MODE_OFB)
448    size = 16;
449    TEST_ASSERT( mbedtls_aes_crypt_ofb( &aes_ctx, 16, &size, out, in, out )
450                 == MBEDTLS_ERR_AES_BAD_INPUT_DATA );
451#endif
452
453/*
454 * The following line needs to be added to make the code compilable
455 * when all the conditions above will be not define in a specific
456 * choice of features.
457 */
458    TEST_ASSERT( 1 );
459/* TODO: It will be removed when the whole test will be reworked */
460}
461/* END_CASE */
462
463/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
464void aes_selftest(  )
465{
466    TEST_ASSERT( mbedtls_aes_self_test( 1 ) == 0 );
467}
468/* END_CASE */
469