blob: 4e616d3ef5ba6313e1fd9b41944a2cca647c7dd4 [file] [log] [blame]
Paul Bakker33b43f12013-08-20 11:48:36 +02001/* BEGIN_HEADER */
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00002#include "mbedtls/cipher.h"
Manuel Pégourié-Gonnardf7ce67f2013-09-03 20:17:35 +02003
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02004#if defined(MBEDTLS_GCM_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00005#include "mbedtls/gcm.h"
Manuel Pégourié-Gonnardf7ce67f2013-09-03 20:17:35 +02006#endif
Paul Bakker33b43f12013-08-20 11:48:36 +02007/* END_HEADER */
Paul Bakker8123e9d2011-01-06 15:37:30 +00008
Paul Bakker33b43f12013-08-20 11:48:36 +02009/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020010 * depends_on:MBEDTLS_CIPHER_C
Paul Bakker33b43f12013-08-20 11:48:36 +020011 * END_DEPENDENCIES
12 */
Paul Bakker5690efc2011-05-26 13:16:06 +000013
Paul Bakker33b43f12013-08-20 11:48:36 +020014/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +010015void mbedtls_cipher_list( )
Manuel Pégourié-Gonnard66dfc5a2014-03-29 16:10:55 +010016{
17 const int *cipher_type;
18
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020019 for( cipher_type = mbedtls_cipher_list(); *cipher_type != 0; cipher_type++ )
20 TEST_ASSERT( mbedtls_cipher_info_from_type( *cipher_type ) != NULL );
Manuel Pégourié-Gonnard66dfc5a2014-03-29 16:10:55 +010021}
22/* END_CASE */
23
k-stachowiaka85edd92018-12-19 18:06:35 +010024/* BEGIN_CASE */
25void cipher_invalid_param_unconditional( )
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010026{
k-stachowiaka85edd92018-12-19 18:06:35 +010027 mbedtls_cipher_context_t valid_ctx;
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010028 mbedtls_cipher_context_t invalid_ctx;
k-stachowiaka85edd92018-12-19 18:06:35 +010029 mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
30 mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
31 unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
32 int valid_size = sizeof(valid_buffer);
33 int valid_bitlen = valid_size * 8;
34 const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
35 *( mbedtls_cipher_list() ) );
36 size_t size_t_var;
37
38 mbedtls_cipher_init( &valid_ctx );
39 mbedtls_cipher_setup( &valid_ctx, valid_info );
40 mbedtls_cipher_init( &invalid_ctx );
41
42 /* mbedtls_cipher_setup() */
43 TEST_ASSERT( mbedtls_cipher_setup( &valid_ctx, NULL ) ==
44 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
45
46 /* mbedtls_cipher_get_block_size() */
47 TEST_ASSERT( mbedtls_cipher_get_block_size( &invalid_ctx ) == 0 );
48
49 /* mbedtls_cipher_get_cipher_mode() */
50 TEST_ASSERT( mbedtls_cipher_get_cipher_mode( &invalid_ctx ) ==
51 MBEDTLS_MODE_NONE );
52
53 /* mbedtls_cipher_get_iv_size() */
54 TEST_ASSERT( mbedtls_cipher_get_iv_size( &invalid_ctx ) == 0 );
55
56 /* mbedtls_cipher_get_type() */
57 TEST_ASSERT(
58 mbedtls_cipher_get_type( &invalid_ctx ) ==
59 MBEDTLS_CIPHER_NONE);
60
61 /* mbedtls_cipher_get_name() */
62 TEST_ASSERT( mbedtls_cipher_get_name( &invalid_ctx ) == 0 );
63
64 /* mbedtls_cipher_get_key_bitlen() */
65 TEST_ASSERT( mbedtls_cipher_get_key_bitlen( &invalid_ctx ) ==
66 MBEDTLS_KEY_LENGTH_NONE );
67
68 /* mbedtls_cipher_get_operation() */
69 TEST_ASSERT( mbedtls_cipher_get_operation( &invalid_ctx ) ==
70 MBEDTLS_OPERATION_NONE );
71
72 /* mbedtls_cipher_setkey() */
73 TEST_ASSERT(
74 mbedtls_cipher_setkey( &invalid_ctx,
75 valid_buffer,
76 valid_bitlen,
77 valid_operation ) ==
78 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
79
80 /* mbedtls_cipher_set_iv() */
81 TEST_ASSERT(
82 mbedtls_cipher_set_iv( &invalid_ctx,
83 valid_buffer,
84 valid_size ) ==
85 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
86
87 /* mbedtls_cipher_reset() */
88 TEST_ASSERT( mbedtls_cipher_reset( &invalid_ctx ) ==
89 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
90
91#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
92 /* mbedtls_cipher_update_ad() */
93 TEST_ASSERT(
94 mbedtls_cipher_update_ad( &invalid_ctx,
95 valid_buffer,
96 valid_size ) ==
97 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
98#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
99
100#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
101 /* mbedtls_cipher_set_padding_mode() */
102 TEST_ASSERT( mbedtls_cipher_set_padding_mode( &invalid_ctx, valid_mode ) ==
103 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
104#endif
105
106 /* mbedtls_cipher_update() */
107 TEST_ASSERT(
108 mbedtls_cipher_update( &invalid_ctx,
109 valid_buffer,
110 valid_size,
111 valid_buffer,
112 &size_t_var ) ==
113 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
114
115 /* mbedtls_cipher_finish() */
116 TEST_ASSERT(
117 mbedtls_cipher_finish( &invalid_ctx,
118 valid_buffer,
119 &size_t_var ) ==
120 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
121
122#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
123 /* mbedtls_cipher_write_tag() */
124 TEST_ASSERT(
125 mbedtls_cipher_write_tag( &invalid_ctx,
126 valid_buffer,
127 valid_size ) ==
128 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
129
130 /* mbedtls_cipher_check_tag() */
131 TEST_ASSERT(
132 mbedtls_cipher_check_tag( &invalid_ctx,
133 valid_buffer,
134 valid_size ) ==
135 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
136#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
137
138exit:
139 mbedtls_cipher_free( &invalid_ctx );
140 mbedtls_cipher_free( &valid_ctx );
141}
142/* END_CASE */
143
144/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
145void cipher_invalid_param_conditional( )
146{
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100147 mbedtls_cipher_context_t valid_ctx;
148
k-stachowiaka5390702018-12-17 11:27:03 +0100149 mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100150 mbedtls_operation_t invalid_operation = 100;
151 mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
152 unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
153 int valid_size = sizeof(valid_buffer);
154 int valid_bitlen = valid_size * 8;
k-stachowiaka5390702018-12-17 11:27:03 +0100155 const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
156 *( mbedtls_cipher_list() ) );
157
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100158 size_t size_t_var;
159
160 /* mbedtls_cipher_init() */
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100161 TEST_VALID_PARAM( mbedtls_cipher_init( &valid_ctx ) );
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100162 TEST_INVALID_PARAM( mbedtls_cipher_init( NULL ) );
163
k-stachowiaka5390702018-12-17 11:27:03 +0100164 /* mbedtls_cipher_setup() */
k-stachowiaka85edd92018-12-19 18:06:35 +0100165 TEST_VALID_PARAM( mbedtls_cipher_setup( &valid_ctx, valid_info ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100166 TEST_INVALID_PARAM_RET(
167 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
168 mbedtls_cipher_setup( NULL, valid_info ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100169
k-stachowiak90b8d4a2018-12-18 16:12:34 +0100170 /* mbedtls_cipher_get_block_size() */
171 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_block_size( NULL ) );
k-stachowiak90b8d4a2018-12-18 16:12:34 +0100172
173 /* mbedtls_cipher_get_cipher_mode() */
174 TEST_INVALID_PARAM_RET(
175 MBEDTLS_MODE_NONE,
176 mbedtls_cipher_get_cipher_mode( NULL ) );
k-stachowiak90b8d4a2018-12-18 16:12:34 +0100177
178 /* mbedtls_cipher_get_iv_size() */
179 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_iv_size( NULL ) );
k-stachowiak90b8d4a2018-12-18 16:12:34 +0100180
181 /* mbedtls_cipher_get_type() */
182 TEST_INVALID_PARAM_RET(
183 MBEDTLS_CIPHER_NONE,
184 mbedtls_cipher_get_type( NULL ) );
k-stachowiak90b8d4a2018-12-18 16:12:34 +0100185
186 /* mbedtls_cipher_get_name() */
187 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_name( NULL ) );
k-stachowiak90b8d4a2018-12-18 16:12:34 +0100188
189 /* mbedtls_cipher_get_key_bitlen() */
190 TEST_INVALID_PARAM_RET(
191 MBEDTLS_KEY_LENGTH_NONE,
192 mbedtls_cipher_get_key_bitlen( NULL ) );
k-stachowiak90b8d4a2018-12-18 16:12:34 +0100193
194 /* mbedtls_cipher_get_operation() */
195 TEST_INVALID_PARAM_RET(
196 MBEDTLS_OPERATION_NONE,
197 mbedtls_cipher_get_operation( NULL ) );
k-stachowiak90b8d4a2018-12-18 16:12:34 +0100198
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100199 /* mbedtls_cipher_setkey() */
200 TEST_INVALID_PARAM_RET(
201 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100202 mbedtls_cipher_setkey( NULL,
203 valid_buffer,
204 valid_bitlen,
205 valid_operation ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100206 TEST_INVALID_PARAM_RET(
207 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
208 mbedtls_cipher_setkey( &valid_ctx,
209 NULL,
210 valid_bitlen,
211 valid_operation ) );
212 TEST_INVALID_PARAM_RET(
213 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100214 mbedtls_cipher_setkey( &valid_ctx,
215 valid_buffer,
216 valid_bitlen,
217 invalid_operation ) );
218
k-stachowiaka5390702018-12-17 11:27:03 +0100219 /* mbedtls_cipher_set_iv() */
220 TEST_INVALID_PARAM_RET(
221 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
222 mbedtls_cipher_set_iv( NULL,
223 valid_buffer,
224 valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100225 TEST_INVALID_PARAM_RET(
226 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
227 mbedtls_cipher_set_iv( &valid_ctx,
228 NULL,
229 valid_size ) );
230
231 /* mbedtls_cipher_reset() */
232 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
233 mbedtls_cipher_reset( NULL ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100234
235#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
236 /* mbedtls_cipher_update_ad() */
237 TEST_INVALID_PARAM_RET(
238 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
239 mbedtls_cipher_update_ad( NULL,
240 valid_buffer,
241 valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100242 TEST_INVALID_PARAM_RET(
243 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
244 mbedtls_cipher_update_ad( &valid_ctx,
245 NULL,
246 valid_size ) );
247#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
248
249#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100250 /* mbedtls_cipher_set_padding_mode() */
251 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
252 mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100253#endif
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100254
255 /* mbedtls_cipher_update() */
256 TEST_INVALID_PARAM_RET(
257 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100258 mbedtls_cipher_update( NULL,
259 valid_buffer,
260 valid_size,
261 valid_buffer,
262 &size_t_var ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100263 TEST_INVALID_PARAM_RET(
264 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100265 mbedtls_cipher_update( &valid_ctx,
266 NULL, valid_size,
267 valid_buffer,
268 &size_t_var ) );
269 TEST_INVALID_PARAM_RET(
270 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
271 mbedtls_cipher_update( &valid_ctx,
272 valid_buffer, valid_size,
273 NULL,
274 &size_t_var ) );
275 TEST_INVALID_PARAM_RET(
276 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
277 mbedtls_cipher_update( &valid_ctx,
278 valid_buffer, valid_size,
279 valid_buffer,
280 NULL ) );
281
282 /* mbedtls_cipher_finish() */
283 TEST_INVALID_PARAM_RET(
284 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100285 mbedtls_cipher_finish( NULL,
286 valid_buffer,
287 &size_t_var ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100288 TEST_INVALID_PARAM_RET(
289 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100290 mbedtls_cipher_finish( &valid_ctx,
291 NULL,
292 &size_t_var ) );
293 TEST_INVALID_PARAM_RET(
294 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
295 mbedtls_cipher_finish( &valid_ctx,
296 valid_buffer,
297 NULL ) );
298
k-stachowiaka5390702018-12-17 11:27:03 +0100299#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100300 /* mbedtls_cipher_write_tag() */
301 TEST_INVALID_PARAM_RET(
302 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100303 mbedtls_cipher_write_tag( NULL,
304 valid_buffer,
305 valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100306 TEST_INVALID_PARAM_RET(
307 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100308 mbedtls_cipher_write_tag( &valid_ctx,
309 NULL,
310 valid_size ) );
311
312 /* mbedtls_cipher_check_tag() */
313 TEST_INVALID_PARAM_RET(
314 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100315 mbedtls_cipher_check_tag( NULL,
316 valid_buffer,
317 valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100318 TEST_INVALID_PARAM_RET(
319 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100320 mbedtls_cipher_check_tag( &valid_ctx,
321 NULL,
322 valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100323#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100324
325 /* mbedtls_cipher_crypt() */
326 TEST_INVALID_PARAM_RET(
327 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
328 mbedtls_cipher_crypt( NULL,
329 valid_buffer, valid_size,
330 valid_buffer, valid_size,
331 valid_buffer, &size_t_var ) );
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100332 TEST_INVALID_PARAM_RET(
333 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
334 mbedtls_cipher_crypt( &valid_ctx,
335 NULL, valid_size,
336 valid_buffer, valid_size,
337 valid_buffer, &size_t_var ) );
338 TEST_INVALID_PARAM_RET(
339 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
340 mbedtls_cipher_crypt( &valid_ctx,
341 valid_buffer, valid_size,
342 NULL, valid_size,
343 valid_buffer, &size_t_var ) );
344 TEST_INVALID_PARAM_RET(
345 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
346 mbedtls_cipher_crypt( &valid_ctx,
347 valid_buffer, valid_size,
348 valid_buffer, valid_size,
349 NULL, &size_t_var ) );
350 TEST_INVALID_PARAM_RET(
351 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
352 mbedtls_cipher_crypt( &valid_ctx,
353 valid_buffer, valid_size,
354 valid_buffer, valid_size,
355 valid_buffer, NULL ) );
356
k-stachowiaka5390702018-12-17 11:27:03 +0100357#if defined(MBEDTLS_CIPHER_MODE_AEAD)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100358 /* mbedtls_cipher_auth_encrypt() */
359 TEST_INVALID_PARAM_RET(
360 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
361 mbedtls_cipher_auth_encrypt( NULL,
362 valid_buffer, valid_size,
363 valid_buffer, valid_size,
364 valid_buffer, valid_size,
365 valid_buffer, &size_t_var,
366 valid_buffer, valid_size ) );
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100367 TEST_INVALID_PARAM_RET(
368 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
369 mbedtls_cipher_auth_encrypt( &valid_ctx,
370 NULL, valid_size,
371 valid_buffer, valid_size,
372 valid_buffer, valid_size,
373 valid_buffer, &size_t_var,
374 valid_buffer, valid_size ) );
375 TEST_INVALID_PARAM_RET(
376 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
377 mbedtls_cipher_auth_encrypt( &valid_ctx,
378 valid_buffer, valid_size,
379 NULL, valid_size,
380 valid_buffer, valid_size,
381 valid_buffer, &size_t_var,
382 valid_buffer, valid_size ) );
383 TEST_INVALID_PARAM_RET(
384 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
385 mbedtls_cipher_auth_encrypt( &valid_ctx,
386 valid_buffer, valid_size,
387 valid_buffer, valid_size,
388 NULL, valid_size,
389 valid_buffer, &size_t_var,
390 valid_buffer, valid_size ) );
391 TEST_INVALID_PARAM_RET(
392 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
393 mbedtls_cipher_auth_encrypt( &valid_ctx,
394 valid_buffer, valid_size,
395 valid_buffer, valid_size,
396 valid_buffer, valid_size,
397 NULL, &size_t_var,
398 valid_buffer, valid_size ) );
399 TEST_INVALID_PARAM_RET(
400 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
401 mbedtls_cipher_auth_encrypt( &valid_ctx,
402 valid_buffer, valid_size,
403 valid_buffer, valid_size,
404 valid_buffer, valid_size,
405 valid_buffer, NULL,
406 valid_buffer, valid_size ) );
407 TEST_INVALID_PARAM_RET(
408 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
409 mbedtls_cipher_auth_encrypt( &valid_ctx,
410 valid_buffer, valid_size,
411 valid_buffer, valid_size,
412 valid_buffer, valid_size,
413 valid_buffer, &size_t_var,
414 NULL, valid_size ) );
415
416 /* mbedtls_cipher_auth_decrypt() */
417 TEST_INVALID_PARAM_RET(
418 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
419 mbedtls_cipher_auth_decrypt( NULL,
420 valid_buffer, valid_size,
421 valid_buffer, valid_size,
422 valid_buffer, valid_size,
423 valid_buffer, &size_t_var,
424 valid_buffer, valid_size ) );
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100425 TEST_INVALID_PARAM_RET(
426 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
427 mbedtls_cipher_auth_decrypt( &valid_ctx,
428 NULL, valid_size,
429 valid_buffer, valid_size,
430 valid_buffer, valid_size,
431 valid_buffer, &size_t_var,
432 valid_buffer, valid_size ) );
433 TEST_INVALID_PARAM_RET(
434 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
435 mbedtls_cipher_auth_decrypt( &valid_ctx,
436 valid_buffer, valid_size,
437 NULL, valid_size,
438 valid_buffer, valid_size,
439 valid_buffer, &size_t_var,
440 valid_buffer, valid_size ) );
441 TEST_INVALID_PARAM_RET(
442 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
443 mbedtls_cipher_auth_decrypt( &valid_ctx,
444 valid_buffer, valid_size,
445 valid_buffer, valid_size,
446 NULL, valid_size,
447 valid_buffer, &size_t_var,
448 valid_buffer, valid_size ) );
449 TEST_INVALID_PARAM_RET(
450 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
451 mbedtls_cipher_auth_decrypt( &valid_ctx,
452 valid_buffer, valid_size,
453 valid_buffer, valid_size,
454 valid_buffer, valid_size,
455 NULL, &size_t_var,
456 valid_buffer, valid_size ) );
457 TEST_INVALID_PARAM_RET(
458 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
459 mbedtls_cipher_auth_decrypt( &valid_ctx,
460 valid_buffer, valid_size,
461 valid_buffer, valid_size,
462 valid_buffer, valid_size,
463 valid_buffer, NULL,
464 valid_buffer, valid_size ) );
465 TEST_INVALID_PARAM_RET(
466 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
467 mbedtls_cipher_auth_decrypt( &valid_ctx,
468 valid_buffer, valid_size,
469 valid_buffer, valid_size,
470 valid_buffer, valid_size,
471 valid_buffer, &size_t_var,
472 NULL, valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100473#endif /* defined(MBEDTLS_CIPHER_MODE_AEAD) */
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100474
475 /* mbedtls_cipher_free() */
476 TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
477exit:
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100478 TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
479}
480/* END_CASE */
481
Paul Bakker6a9c7252016-07-14 13:46:10 +0100482/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
Azim Khanf1aaec92017-05-30 14:23:15 +0100483void cipher_special_behaviours( )
Paul Bakker6a9c7252016-07-14 13:46:10 +0100484{
485 const mbedtls_cipher_info_t *cipher_info;
486 mbedtls_cipher_context_t ctx;
487 unsigned char input[32];
488 unsigned char output[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300489#if defined (MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100490 unsigned char iv[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300491#endif
Paul Bakker6a9c7252016-07-14 13:46:10 +0100492 size_t olen = 0;
493
494 mbedtls_cipher_init( &ctx );
495 memset( input, 0, sizeof( input ) );
496 memset( output, 0, sizeof( output ) );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300497#if defined(MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100498 memset( iv, 0, sizeof( iv ) );
499
500 /* Check and get info structures */
Ron Eldor7b012442017-09-25 17:03:12 +0300501 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker6a9c7252016-07-14 13:46:10 +0100502 TEST_ASSERT( NULL != cipher_info );
503
504 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
505
506 /* IV too big */
507 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1 )
508 == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
509
510 /* IV too small */
511 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, 0 )
512 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
513
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300514 mbedtls_cipher_free( &ctx );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300515 mbedtls_cipher_init( &ctx );
Ron Eldor6f90ed82017-09-26 12:08:54 +0300516#endif /* MBEDTLS_CIPHER_MODE_CBC */
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300517 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
Ron Eldor7b012442017-09-25 17:03:12 +0300518 TEST_ASSERT( NULL != cipher_info );
519
520 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
521
Paul Bakker6a9c7252016-07-14 13:46:10 +0100522 /* Update ECB with partial block */
523 TEST_ASSERT( mbedtls_cipher_update( &ctx, input, 1, output, &olen )
524 == MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
525
526exit:
527 mbedtls_cipher_free( &ctx );
528}
529/* END_CASE */
530
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +0200531/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100532void enc_dec_buf( int cipher_id, char * cipher_string, int key_len,
Paul Bakker33b43f12013-08-20 11:48:36 +0200533 int length_val, int pad_mode )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200534{
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200535 size_t length = length_val, outlen, total_len, i, block_size;
Jaeden Amerod906b812018-06-08 11:03:16 +0100536 unsigned char key[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000537 unsigned char iv[16];
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200538 unsigned char ad[13];
539 unsigned char tag[16];
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200540 unsigned char inbuf[64];
541 unsigned char encbuf[64];
542 unsigned char decbuf[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000543
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200544 const mbedtls_cipher_info_t *cipher_info;
545 mbedtls_cipher_context_t ctx_dec;
546 mbedtls_cipher_context_t ctx_enc;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000547
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200548 /*
549 * Prepare contexts
550 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200551 mbedtls_cipher_init( &ctx_dec );
552 mbedtls_cipher_init( &ctx_enc );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200553
554 memset( key, 0x2a, sizeof( key ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000555
556 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200557 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000558 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200559 TEST_ASSERT( mbedtls_cipher_info_from_string( cipher_string ) == cipher_info );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000560
561 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200562 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
563 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200564
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200565 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
566 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000567
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200568#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Paul Bakker33b43f12013-08-20 11:48:36 +0200569 if( -1 != pad_mode )
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200570 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200571 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
572 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200573 }
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200574#else
575 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200576#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200577
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200578 /*
579 * Do a few encode/decode cycles
580 */
581 for( i = 0; i < 3; i++ )
582 {
583 memset( iv , 0x00 + i, sizeof( iv ) );
584 memset( ad, 0x10 + i, sizeof( ad ) );
585 memset( inbuf, 0x20 + i, sizeof( inbuf ) );
586
587 memset( encbuf, 0, sizeof( encbuf ) );
588 memset( decbuf, 0, sizeof( decbuf ) );
589 memset( tag, 0, sizeof( tag ) );
590
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200591 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, sizeof( iv ) ) );
592 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, sizeof( iv ) ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200593
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200594 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
595 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200596
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200597#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200598 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, ad, sizeof( ad ) - i ) );
599 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, ad, sizeof( ad ) - i ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200600#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000601
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200602 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
603 TEST_ASSERT( block_size != 0 );
604
Paul Bakker8123e9d2011-01-06 15:37:30 +0000605 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200606 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, length, encbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200607 total_len = outlen;
608
609 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200610 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200611 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200612 total_len + block_size > length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000613
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200614 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200615 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000616
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200617#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200618 TEST_ASSERT( 0 == mbedtls_cipher_write_tag( &ctx_enc, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200619#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200620
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200621 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200622 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200623 total_len > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200624 total_len <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000625
626 /* decode the previously encoded string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200627 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, total_len, decbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200628 total_len = outlen;
629
630 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200631 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200632 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200633 total_len + block_size >= length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000634
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200635 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200636 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000637
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200638#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200639 TEST_ASSERT( 0 == mbedtls_cipher_check_tag( &ctx_dec, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200640#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200641
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200642 /* check result */
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200643 TEST_ASSERT( total_len == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000644 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200645 }
Paul Bakker8123e9d2011-01-06 15:37:30 +0000646
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200647 /*
648 * Done
649 */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200650exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200651 mbedtls_cipher_free( &ctx_dec );
652 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200653}
Paul Bakker33b43f12013-08-20 11:48:36 +0200654/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000655
Paul Bakker33b43f12013-08-20 11:48:36 +0200656/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100657void enc_fail( int cipher_id, int pad_mode, int key_len, int length_val,
658 int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200659{
Paul Bakker33b43f12013-08-20 11:48:36 +0200660 size_t length = length_val;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200661 unsigned char key[32];
662 unsigned char iv[16];
663
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200664 const mbedtls_cipher_info_t *cipher_info;
665 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200666
667 unsigned char inbuf[64];
668 unsigned char encbuf[64];
669
670 size_t outlen = 0;
671
672 memset( key, 0, 32 );
673 memset( iv , 0, 16 );
674
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200675 mbedtls_cipher_init( &ctx );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200676
677 memset( inbuf, 5, 64 );
678 memset( encbuf, 0, 64 );
679
680 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200681 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200682 TEST_ASSERT( NULL != cipher_info );
683
684 /* Initialise context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200685 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200686 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, key_len, MBEDTLS_ENCRYPT ) );
687#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
688 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200689#else
690 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200691#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
692 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv, 16 ) );
693 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200694#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200695 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200696#endif
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200697
698 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200699 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, inbuf, length, encbuf, &outlen ) );
700 TEST_ASSERT( ret == mbedtls_cipher_finish( &ctx, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200701
702 /* done */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200703exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200704 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200705}
Paul Bakker33b43f12013-08-20 11:48:36 +0200706/* END_CASE */
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200707
Paul Bakker33b43f12013-08-20 11:48:36 +0200708/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100709void dec_empty_buf( )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200710{
Paul Bakker8123e9d2011-01-06 15:37:30 +0000711 unsigned char key[32];
712 unsigned char iv[16];
713
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200714 mbedtls_cipher_context_t ctx_dec;
715 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000716
717 unsigned char encbuf[64];
718 unsigned char decbuf[64];
719
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000720 size_t outlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000721
722 memset( key, 0, 32 );
723 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200724
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200725 mbedtls_cipher_init( &ctx_dec );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200726
Paul Bakker8123e9d2011-01-06 15:37:30 +0000727 memset( encbuf, 0, 64 );
728 memset( decbuf, 0, 64 );
729
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200730 /* Initialise context */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200731 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000732 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200733
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200734 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000735
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200736 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, 128, MBEDTLS_DECRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000737
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200738 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200739
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200740 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200741
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200742#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200743 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200744#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000745
746 /* decode 0-byte string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200747 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, 0, decbuf, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000748 TEST_ASSERT( 0 == outlen );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200749 TEST_ASSERT( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED == mbedtls_cipher_finish(
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200750 &ctx_dec, decbuf + outlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000751 TEST_ASSERT( 0 == outlen );
752
Paul Bakkerbd51b262014-07-10 15:26:12 +0200753exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200754 mbedtls_cipher_free( &ctx_dec );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200755}
Paul Bakker33b43f12013-08-20 11:48:36 +0200756/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000757
Paul Bakker33b43f12013-08-20 11:48:36 +0200758/* BEGIN_CASE */
759void enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700760 int second_length_val, int pad_mode,
761 int first_encrypt_output_len, int second_encrypt_output_len,
762 int first_decrypt_output_len, int second_decrypt_output_len )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200763{
Paul Bakker33b43f12013-08-20 11:48:36 +0200764 size_t first_length = first_length_val;
765 size_t second_length = second_length_val;
Paul Bakker23986e52011-04-24 08:57:21 +0000766 size_t length = first_length + second_length;
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200767 size_t block_size;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000768 unsigned char key[32];
769 unsigned char iv[16];
770
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200771 mbedtls_cipher_context_t ctx_dec;
772 mbedtls_cipher_context_t ctx_enc;
773 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000774
775 unsigned char inbuf[64];
776 unsigned char encbuf[64];
777 unsigned char decbuf[64];
778
Paul Bakker23986e52011-04-24 08:57:21 +0000779 size_t outlen = 0;
780 size_t totaloutlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000781
782 memset( key, 0, 32 );
783 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200784
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200785 mbedtls_cipher_init( &ctx_dec );
786 mbedtls_cipher_init( &ctx_enc );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200787
Paul Bakker8123e9d2011-01-06 15:37:30 +0000788 memset( inbuf, 5, 64 );
789 memset( encbuf, 0, 64 );
790 memset( decbuf, 0, 64 );
791
792 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200793 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000794 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200795
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200796 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
797 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200798
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200799 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
800 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000801
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700802#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
803 if( -1 != pad_mode )
804 {
805 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
806 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
807 }
808#else
809 (void) pad_mode;
810#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
811
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200812 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
813 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200814
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200815 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
816 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200817
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200818#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200819 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
820 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200821#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000822
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200823 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
824 TEST_ASSERT( block_size != 0 );
825
Paul Bakker8123e9d2011-01-06 15:37:30 +0000826 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200827 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, first_length, encbuf, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700828 TEST_ASSERT( (size_t)first_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000829 totaloutlen = outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200830 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf + first_length, second_length, encbuf + totaloutlen, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700831 TEST_ASSERT( (size_t)second_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000832 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200833 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200834 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200835 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200836 totaloutlen + block_size > length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200837
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200838 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + totaloutlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000839 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200840 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200841 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200842 totaloutlen > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200843 totaloutlen <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000844
845 /* decode the previously encoded string */
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700846 second_length = totaloutlen - first_length;
847 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, first_length, decbuf, &outlen ) );
848 TEST_ASSERT( (size_t)first_decrypt_output_len == outlen );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200849 totaloutlen = outlen;
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700850 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf + first_length, second_length, decbuf + totaloutlen, &outlen ) );
851 TEST_ASSERT( (size_t)second_decrypt_output_len == outlen );
852 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200853
854 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200855 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200856 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200857 totaloutlen + block_size >= length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200858
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700859 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + totaloutlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200860 totaloutlen += outlen;
861
862 TEST_ASSERT( totaloutlen == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000863
864 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
865
Paul Bakkerbd51b262014-07-10 15:26:12 +0200866exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200867 mbedtls_cipher_free( &ctx_dec );
868 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200869}
Paul Bakker33b43f12013-08-20 11:48:36 +0200870/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000871
Paul Bakker33b43f12013-08-20 11:48:36 +0200872/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100873void decrypt_test_vec( int cipher_id, int pad_mode, data_t * key,
874 data_t * iv, data_t * cipher,
875 data_t * clear, data_t * ad, data_t * tag,
Azim Khand30ca132017-06-09 04:32:58 +0100876 int finish_result, int tag_result )
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200877{
Manuel Pégourié-Gonnard234e1ce2018-05-10 12:54:32 +0200878 unsigned char output[265];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200879 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200880 size_t outlen, total_len;
881
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200882 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200883
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200884 memset( output, 0x00, sizeof( output ) );
885
Azim Khanf1aaec92017-05-30 14:23:15 +0100886#if !defined(MBEDTLS_GCM_C) && !defined(MBEDTLS_CHACHAPOLY_C)
Mohammad Azim Khancf32c452017-06-13 14:55:58 +0100887 ((void) ad);
888 ((void) tag);
Manuel Pégourié-Gonnarda7496f02013-09-20 11:29:59 +0200889#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200890
891 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200892 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200893 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100894 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200895#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200896 if( pad_mode != -1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200897 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200898#else
899 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200900#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Azim Khand30ca132017-06-09 04:32:58 +0100901 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv->x, iv->len ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200902 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200903#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100904 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, ad->x, ad->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200905#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200906
Azim Khand30ca132017-06-09 04:32:58 +0100907 /* decode buffer and check tag->x */
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200908 total_len = 0;
Azim Khand30ca132017-06-09 04:32:58 +0100909 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, cipher->x, cipher->len, output, &outlen ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200910 total_len += outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200911 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200912 &outlen ) );
913 total_len += outlen;
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200914#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100915 TEST_ASSERT( tag_result == mbedtls_cipher_check_tag( &ctx, tag->x, tag->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200916#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200917
918 /* check plaintext only if everything went fine */
919 if( 0 == finish_result && 0 == tag_result )
920 {
Azim Khand30ca132017-06-09 04:32:58 +0100921 TEST_ASSERT( total_len == clear->len );
922 TEST_ASSERT( 0 == memcmp( output, clear->x, clear->len ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200923 }
924
Paul Bakkerbd51b262014-07-10 15:26:12 +0200925exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200926 mbedtls_cipher_free( &ctx );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200927}
928/* END_CASE */
929
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200930/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_AEAD */
Azim Khan5fcca462018-06-29 11:05:32 +0100931void auth_crypt_tv( int cipher_id, data_t * key, data_t * iv,
932 data_t * ad, data_t * cipher, data_t * tag,
933 char * result, data_t * clear )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200934{
935 int ret;
Manuel Pégourié-Gonnard69767d12018-05-09 12:25:18 +0200936 unsigned char output[267]; /* above + 2 (overwrite check) */
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200937 unsigned char my_tag[20];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200938 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200939 size_t outlen;
940
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200941 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200942
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200943 memset( output, 0xFF, sizeof( output ) );
Azim Khan46c9b1f2017-05-31 20:46:35 +0100944 memset( my_tag, 0xFF, sizeof( my_tag ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200945
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200946
947 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200948 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200949 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100950 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200951
Azim Khand30ca132017-06-09 04:32:58 +0100952 /* decode buffer and check tag->x */
953 ret = mbedtls_cipher_auth_decrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
954 cipher->x, cipher->len, output, &outlen,
955 tag->x, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200956
957 /* make sure we didn't overwrite */
958 TEST_ASSERT( output[outlen + 0] == 0xFF );
959 TEST_ASSERT( output[outlen + 1] == 0xFF );
960
961 /* make sure the message is rejected if it should be */
Azim Khan46c9b1f2017-05-31 20:46:35 +0100962 if( strcmp( result, "FAIL" ) == 0 )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200963 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200964 TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
Paul Bakkerbd51b262014-07-10 15:26:12 +0200965 goto exit;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200966 }
967
968 /* otherwise, make sure it was decrypted properly */
969 TEST_ASSERT( ret == 0 );
970
Azim Khand30ca132017-06-09 04:32:58 +0100971 TEST_ASSERT( outlen == clear->len );
972 TEST_ASSERT( memcmp( output, clear->x, clear->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200973
Azim Khand30ca132017-06-09 04:32:58 +0100974 /* then encrypt the clear->x and make sure we get the same ciphertext and tag->x */
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200975 memset( output, 0xFF, sizeof( output ) );
976 outlen = 0;
977
Azim Khand30ca132017-06-09 04:32:58 +0100978 ret = mbedtls_cipher_auth_encrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
979 clear->x, clear->len, output, &outlen,
980 my_tag, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200981 TEST_ASSERT( ret == 0 );
982
Azim Khand30ca132017-06-09 04:32:58 +0100983 TEST_ASSERT( outlen == clear->len );
984 TEST_ASSERT( memcmp( output, cipher->x, clear->len ) == 0 );
985 TEST_ASSERT( memcmp( my_tag, tag->x, tag->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200986
987 /* make sure we didn't overwrite */
988 TEST_ASSERT( output[outlen + 0] == 0xFF );
989 TEST_ASSERT( output[outlen + 1] == 0xFF );
Azim Khand30ca132017-06-09 04:32:58 +0100990 TEST_ASSERT( my_tag[tag->len + 0] == 0xFF );
991 TEST_ASSERT( my_tag[tag->len + 1] == 0xFF );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200992
993
Paul Bakkerbd51b262014-07-10 15:26:12 +0200994exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200995 mbedtls_cipher_free( &ctx );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200996}
997/* END_CASE */
998
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200999/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +01001000void test_vec_ecb( int cipher_id, int operation, data_t * key,
1001 data_t * input, data_t * result, int finish_result
Azim Khand30ca132017-06-09 04:32:58 +01001002 )
Paul Bakker5e0efa72013-09-08 23:04:04 +02001003{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001004 mbedtls_cipher_context_t ctx;
Paul Bakker5e0efa72013-09-08 23:04:04 +02001005 unsigned char output[32];
1006 size_t outlen;
1007
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001008 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +02001009
Paul Bakker5e0efa72013-09-08 23:04:04 +02001010 memset( output, 0x00, sizeof( output ) );
1011
1012 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +02001013 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001014 mbedtls_cipher_info_from_type( cipher_id ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +02001015
Paul Bakker5e0efa72013-09-08 23:04:04 +02001016
Azim Khand30ca132017-06-09 04:32:58 +01001017 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +02001018
Azim Khand30ca132017-06-09 04:32:58 +01001019 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, input->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001020 mbedtls_cipher_get_block_size( &ctx ),
Paul Bakker5e0efa72013-09-08 23:04:04 +02001021 output, &outlen ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001022 TEST_ASSERT( outlen == mbedtls_cipher_get_block_size( &ctx ) );
1023 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Paul Bakker5e0efa72013-09-08 23:04:04 +02001024 &outlen ) );
1025 TEST_ASSERT( 0 == outlen );
1026
1027 /* check plaintext only if everything went fine */
1028 if( 0 == finish_result )
Azim Khand30ca132017-06-09 04:32:58 +01001029 TEST_ASSERT( 0 == memcmp( output, result->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001030 mbedtls_cipher_get_block_size( &ctx ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +02001031
Paul Bakkerbd51b262014-07-10 15:26:12 +02001032exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001033 mbedtls_cipher_free( &ctx );
Paul Bakker5e0efa72013-09-08 23:04:04 +02001034}
1035/* END_CASE */
1036
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001037/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Ron Eldor7b012442017-09-25 17:03:12 +03001038void test_vec_crypt( int cipher_id, int operation, char *hex_key,
1039 char *hex_iv, char *hex_input, char *hex_result,
1040 int finish_result )
1041{
1042 unsigned char key[50];
1043 unsigned char input[16];
1044 unsigned char result[16];
1045 unsigned char iv[16];
1046 size_t key_len, iv_len, inputlen, resultlen;
1047 mbedtls_cipher_context_t ctx;
1048 unsigned char output[32];
1049 size_t outlen;
1050
1051 mbedtls_cipher_init( &ctx );
1052
1053 memset( key, 0x00, sizeof( key ) );
1054 memset( input, 0x00, sizeof( input ) );
1055 memset( result, 0x00, sizeof( result ) );
1056 memset( output, 0x00, sizeof( output ) );
1057 memset( iv, 0x00, sizeof( iv ) );
1058
1059 /* Prepare context */
1060 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
1061 mbedtls_cipher_info_from_type( cipher_id ) ) );
1062
1063 key_len = unhexify( key, hex_key );
1064 inputlen = unhexify( input, hex_input );
1065 resultlen = unhexify( result, hex_result );
1066
1067 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, 8 * key_len, operation ) );
1068 if( MBEDTLS_MODE_CBC == ctx.cipher_info->mode )
1069 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, MBEDTLS_PADDING_NONE ) );
1070
Ron Eldor4e64e0b2017-09-25 18:22:32 +03001071 iv_len = unhexify( iv, hex_iv );
Ron Eldor7b012442017-09-25 17:03:12 +03001072
1073 TEST_ASSERT( finish_result == mbedtls_cipher_crypt( &ctx, iv_len ? iv : NULL,
1074 iv_len, input, inputlen,
1075 output, &outlen ) );
1076 TEST_ASSERT( resultlen == outlen );
1077 /* check plaintext only if everything went fine */
1078 if( 0 == finish_result )
1079 TEST_ASSERT( 0 == memcmp( output, result, outlen ) );
1080
1081exit:
1082 mbedtls_cipher_free( &ctx );
1083}
1084/* END_CASE */
1085
1086/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Paul Bakker33b43f12013-08-20 11:48:36 +02001087void set_padding( int cipher_id, int pad_mode, int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001088{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001089 const mbedtls_cipher_info_t *cipher_info;
1090 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001091
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001092 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +02001093
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001094 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001095 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +02001096 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001097
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001098 TEST_ASSERT( ret == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001099
Paul Bakkerbd51b262014-07-10 15:26:12 +02001100exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001101 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001102}
Paul Bakker33b43f12013-08-20 11:48:36 +02001103/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +00001104
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001105/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
Azim Khan5fcca462018-06-29 11:05:32 +01001106void check_padding( int pad_mode, data_t * input, int ret, int dlen_check
Azim Khand30ca132017-06-09 04:32:58 +01001107 )
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001108{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001109 mbedtls_cipher_info_t cipher_info;
1110 mbedtls_cipher_context_t ctx;
Azim Khanf1aaec92017-05-30 14:23:15 +01001111 size_t dlen;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001112
1113 /* build a fake context just for getting access to get_padding */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001114 mbedtls_cipher_init( &ctx );
1115 cipher_info.mode = MBEDTLS_MODE_CBC;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001116 ctx.cipher_info = &cipher_info;
1117
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001118 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001119
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001120
Azim Khand30ca132017-06-09 04:32:58 +01001121 TEST_ASSERT( ret == ctx.get_padding( input->x, input->len, &dlen ) );
Paul Bakker33b43f12013-08-20 11:48:36 +02001122 if( 0 == ret )
1123 TEST_ASSERT( dlen == (size_t) dlen_check );
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001124}
Paul Bakker33b43f12013-08-20 11:48:36 +02001125/* END_CASE */