blob: fba32fdd67e049f348d5f06d44b67310d057b4fb [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
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010024/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
25void cipher_invalid_param( )
26{
27 mbedtls_cipher_context_t invalid_ctx;
28 mbedtls_cipher_context_t valid_ctx;
29
k-stachowiaka5390702018-12-17 11:27:03 +010030 mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010031 mbedtls_operation_t invalid_operation = 100;
32 mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
33 unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
34 int valid_size = sizeof(valid_buffer);
35 int valid_bitlen = valid_size * 8;
k-stachowiaka5390702018-12-17 11:27:03 +010036 const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
37 *( mbedtls_cipher_list() ) );
38
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010039 size_t size_t_var;
40
41 /* mbedtls_cipher_init() */
42 TEST_VALID_PARAM( mbedtls_cipher_init( &invalid_ctx ) );
43 TEST_VALID_PARAM( mbedtls_cipher_init( &valid_ctx ) );
44
45 TEST_INVALID_PARAM( mbedtls_cipher_init( NULL ) );
46
k-stachowiaka5390702018-12-17 11:27:03 +010047 /* mbedtls_cipher_setup() */
48 TEST_INVALID_PARAM_RET(
49 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
50 mbedtls_cipher_setup( NULL, valid_info ) );
51 TEST_INVALID_PARAM_RET(
52 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
53 mbedtls_cipher_setup( &valid_ctx, NULL ) );
54
k-stachowiak90b8d4a2018-12-18 16:12:34 +010055 /* mbedtls_cipher_get_block_size() */
56 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_block_size( NULL ) );
57 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_block_size( &invalid_ctx ) );
58
59 /* mbedtls_cipher_get_cipher_mode() */
60 TEST_INVALID_PARAM_RET(
61 MBEDTLS_MODE_NONE,
62 mbedtls_cipher_get_cipher_mode( NULL ) );
63 TEST_INVALID_PARAM_RET(
64 MBEDTLS_MODE_NONE,
65 mbedtls_cipher_get_cipher_mode( &invalid_ctx ) );
66
67 /* mbedtls_cipher_get_iv_size() */
68 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_iv_size( NULL ) );
69 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_iv_size( &invalid_ctx ) );
70
71 /* mbedtls_cipher_get_type() */
72 TEST_INVALID_PARAM_RET(
73 MBEDTLS_CIPHER_NONE,
74 mbedtls_cipher_get_type( NULL ) );
75 TEST_INVALID_PARAM_RET(
76 MBEDTLS_CIPHER_NONE,
77 mbedtls_cipher_get_type( &invalid_ctx ) );
78
79 /* mbedtls_cipher_get_name() */
80 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_name( NULL ) );
81 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_name( &invalid_ctx ) );
82
83 /* mbedtls_cipher_get_key_bitlen() */
84 TEST_INVALID_PARAM_RET(
85 MBEDTLS_KEY_LENGTH_NONE,
86 mbedtls_cipher_get_key_bitlen( NULL ) );
87 TEST_INVALID_PARAM_RET(
88 MBEDTLS_KEY_LENGTH_NONE,
89 mbedtls_cipher_get_key_bitlen( &invalid_ctx ) );
90
91 /* mbedtls_cipher_get_operation() */
92 TEST_INVALID_PARAM_RET(
93 MBEDTLS_OPERATION_NONE,
94 mbedtls_cipher_get_operation( NULL ) );
95 TEST_INVALID_PARAM_RET(
96 MBEDTLS_OPERATION_NONE,
97 mbedtls_cipher_get_operation( &invalid_ctx ) );
98
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010099 /* mbedtls_cipher_setkey() */
100 TEST_INVALID_PARAM_RET(
101 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100102 mbedtls_cipher_setkey( NULL,
103 valid_buffer,
104 valid_bitlen,
105 valid_operation ) );
106 TEST_INVALID_PARAM_RET(
107 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
108 mbedtls_cipher_setkey( &invalid_ctx,
109 valid_buffer,
110 valid_bitlen,
111 valid_operation ) );
112 TEST_INVALID_PARAM_RET(
113 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
114 mbedtls_cipher_setkey( &valid_ctx,
115 NULL,
116 valid_bitlen,
117 valid_operation ) );
118 TEST_INVALID_PARAM_RET(
119 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100120 mbedtls_cipher_setkey( &valid_ctx,
121 valid_buffer,
122 valid_bitlen,
123 invalid_operation ) );
124
k-stachowiaka5390702018-12-17 11:27:03 +0100125 /* mbedtls_cipher_set_iv() */
126 TEST_INVALID_PARAM_RET(
127 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
128 mbedtls_cipher_set_iv( NULL,
129 valid_buffer,
130 valid_size ) );
131 TEST_INVALID_PARAM_RET(
132 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
133 mbedtls_cipher_set_iv( &invalid_ctx,
134 valid_buffer,
135 valid_size ) );
136 TEST_INVALID_PARAM_RET(
137 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
138 mbedtls_cipher_set_iv( &valid_ctx,
139 NULL,
140 valid_size ) );
141
142 /* mbedtls_cipher_reset() */
143 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
144 mbedtls_cipher_reset( NULL ) );
145 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
146 mbedtls_cipher_reset( &invalid_ctx ) );
147
148#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
149 /* mbedtls_cipher_update_ad() */
150 TEST_INVALID_PARAM_RET(
151 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
152 mbedtls_cipher_update_ad( NULL,
153 valid_buffer,
154 valid_size ) );
155 TEST_INVALID_PARAM_RET(
156 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
157 mbedtls_cipher_update_ad( &invalid_ctx,
158 valid_buffer,
159 valid_size ) );
160 TEST_INVALID_PARAM_RET(
161 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
162 mbedtls_cipher_update_ad( &valid_ctx,
163 NULL,
164 valid_size ) );
165#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
166
167#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100168 /* mbedtls_cipher_set_padding_mode() */
169 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
170 mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
171 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
172 mbedtls_cipher_set_padding_mode( &invalid_ctx,
173 valid_mode ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100174#endif
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100175
176 /* mbedtls_cipher_update() */
177 TEST_INVALID_PARAM_RET(
178 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100179 mbedtls_cipher_update( NULL,
180 valid_buffer,
181 valid_size,
182 valid_buffer,
183 &size_t_var ) );
184 TEST_INVALID_PARAM_RET(
185 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
186 mbedtls_cipher_update( &invalid_ctx,
187 valid_buffer,
188 valid_size,
189 valid_buffer,
190 &size_t_var ) );
191 TEST_INVALID_PARAM_RET(
192 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100193 mbedtls_cipher_update( &valid_ctx,
194 NULL, valid_size,
195 valid_buffer,
196 &size_t_var ) );
197 TEST_INVALID_PARAM_RET(
198 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
199 mbedtls_cipher_update( &valid_ctx,
200 valid_buffer, valid_size,
201 NULL,
202 &size_t_var ) );
203 TEST_INVALID_PARAM_RET(
204 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
205 mbedtls_cipher_update( &valid_ctx,
206 valid_buffer, valid_size,
207 valid_buffer,
208 NULL ) );
209
210 /* mbedtls_cipher_finish() */
211 TEST_INVALID_PARAM_RET(
212 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100213 mbedtls_cipher_finish( NULL,
214 valid_buffer,
215 &size_t_var ) );
216 TEST_INVALID_PARAM_RET(
217 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
218 mbedtls_cipher_finish( &invalid_ctx,
219 valid_buffer,
220 &size_t_var ) );
221 TEST_INVALID_PARAM_RET(
222 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100223 mbedtls_cipher_finish( &valid_ctx,
224 NULL,
225 &size_t_var ) );
226 TEST_INVALID_PARAM_RET(
227 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
228 mbedtls_cipher_finish( &valid_ctx,
229 valid_buffer,
230 NULL ) );
231
k-stachowiaka5390702018-12-17 11:27:03 +0100232#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100233 /* mbedtls_cipher_write_tag() */
234 TEST_INVALID_PARAM_RET(
235 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100236 mbedtls_cipher_write_tag( NULL,
237 valid_buffer,
238 valid_size ) );
239 TEST_INVALID_PARAM_RET(
240 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
241 mbedtls_cipher_write_tag( &invalid_ctx,
242 valid_buffer,
243 valid_size ) );
244 TEST_INVALID_PARAM_RET(
245 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100246 mbedtls_cipher_write_tag( &valid_ctx,
247 NULL,
248 valid_size ) );
249
250 /* mbedtls_cipher_check_tag() */
251 TEST_INVALID_PARAM_RET(
252 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100253 mbedtls_cipher_check_tag( NULL,
254 valid_buffer,
255 valid_size ) );
256 TEST_INVALID_PARAM_RET(
257 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
258 mbedtls_cipher_check_tag( &invalid_ctx,
259 valid_buffer,
260 valid_size ) );
261 TEST_INVALID_PARAM_RET(
262 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100263 mbedtls_cipher_check_tag( &valid_ctx,
264 NULL,
265 valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100266#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100267
268 /* mbedtls_cipher_crypt() */
269 TEST_INVALID_PARAM_RET(
270 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
271 mbedtls_cipher_crypt( NULL,
272 valid_buffer, valid_size,
273 valid_buffer, valid_size,
274 valid_buffer, &size_t_var ) );
275 TEST_INVALID_PARAM_RET(
276 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
277 mbedtls_cipher_crypt( &invalid_ctx,
278 valid_buffer, valid_size,
279 valid_buffer, valid_size,
280 valid_buffer, &size_t_var ) );
281 TEST_INVALID_PARAM_RET(
282 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
283 mbedtls_cipher_crypt( &valid_ctx,
284 NULL, valid_size,
285 valid_buffer, valid_size,
286 valid_buffer, &size_t_var ) );
287 TEST_INVALID_PARAM_RET(
288 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
289 mbedtls_cipher_crypt( &valid_ctx,
290 valid_buffer, valid_size,
291 NULL, valid_size,
292 valid_buffer, &size_t_var ) );
293 TEST_INVALID_PARAM_RET(
294 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
295 mbedtls_cipher_crypt( &valid_ctx,
296 valid_buffer, valid_size,
297 valid_buffer, valid_size,
298 NULL, &size_t_var ) );
299 TEST_INVALID_PARAM_RET(
300 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
301 mbedtls_cipher_crypt( &valid_ctx,
302 valid_buffer, valid_size,
303 valid_buffer, valid_size,
304 valid_buffer, NULL ) );
305
k-stachowiaka5390702018-12-17 11:27:03 +0100306#if defined(MBEDTLS_CIPHER_MODE_AEAD)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100307 /* mbedtls_cipher_auth_encrypt() */
308 TEST_INVALID_PARAM_RET(
309 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
310 mbedtls_cipher_auth_encrypt( NULL,
311 valid_buffer, valid_size,
312 valid_buffer, valid_size,
313 valid_buffer, valid_size,
314 valid_buffer, &size_t_var,
315 valid_buffer, valid_size ) );
316 TEST_INVALID_PARAM_RET(
317 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
318 mbedtls_cipher_auth_encrypt( &invalid_ctx,
319 valid_buffer, valid_size,
320 valid_buffer, valid_size,
321 valid_buffer, valid_size,
322 valid_buffer, &size_t_var,
323 valid_buffer, valid_size ) );
324 TEST_INVALID_PARAM_RET(
325 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
326 mbedtls_cipher_auth_encrypt( &valid_ctx,
327 NULL, valid_size,
328 valid_buffer, valid_size,
329 valid_buffer, valid_size,
330 valid_buffer, &size_t_var,
331 valid_buffer, valid_size ) );
332 TEST_INVALID_PARAM_RET(
333 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
334 mbedtls_cipher_auth_encrypt( &valid_ctx,
335 valid_buffer, valid_size,
336 NULL, valid_size,
337 valid_buffer, valid_size,
338 valid_buffer, &size_t_var,
339 valid_buffer, valid_size ) );
340 TEST_INVALID_PARAM_RET(
341 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
342 mbedtls_cipher_auth_encrypt( &valid_ctx,
343 valid_buffer, valid_size,
344 valid_buffer, valid_size,
345 NULL, valid_size,
346 valid_buffer, &size_t_var,
347 valid_buffer, valid_size ) );
348 TEST_INVALID_PARAM_RET(
349 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
350 mbedtls_cipher_auth_encrypt( &valid_ctx,
351 valid_buffer, valid_size,
352 valid_buffer, valid_size,
353 valid_buffer, valid_size,
354 NULL, &size_t_var,
355 valid_buffer, valid_size ) );
356 TEST_INVALID_PARAM_RET(
357 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
358 mbedtls_cipher_auth_encrypt( &valid_ctx,
359 valid_buffer, valid_size,
360 valid_buffer, valid_size,
361 valid_buffer, valid_size,
362 valid_buffer, NULL,
363 valid_buffer, valid_size ) );
364 TEST_INVALID_PARAM_RET(
365 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
366 mbedtls_cipher_auth_encrypt( &valid_ctx,
367 valid_buffer, valid_size,
368 valid_buffer, valid_size,
369 valid_buffer, valid_size,
370 valid_buffer, &size_t_var,
371 NULL, valid_size ) );
372
373 /* mbedtls_cipher_auth_decrypt() */
374 TEST_INVALID_PARAM_RET(
375 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
376 mbedtls_cipher_auth_decrypt( NULL,
377 valid_buffer, valid_size,
378 valid_buffer, valid_size,
379 valid_buffer, valid_size,
380 valid_buffer, &size_t_var,
381 valid_buffer, valid_size ) );
382 TEST_INVALID_PARAM_RET(
383 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
384 mbedtls_cipher_auth_decrypt( &invalid_ctx,
385 valid_buffer, valid_size,
386 valid_buffer, valid_size,
387 valid_buffer, valid_size,
388 valid_buffer, &size_t_var,
389 valid_buffer, valid_size ) );
390 TEST_INVALID_PARAM_RET(
391 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
392 mbedtls_cipher_auth_decrypt( &valid_ctx,
393 NULL, valid_size,
394 valid_buffer, valid_size,
395 valid_buffer, valid_size,
396 valid_buffer, &size_t_var,
397 valid_buffer, valid_size ) );
398 TEST_INVALID_PARAM_RET(
399 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
400 mbedtls_cipher_auth_decrypt( &valid_ctx,
401 valid_buffer, valid_size,
402 NULL, valid_size,
403 valid_buffer, valid_size,
404 valid_buffer, &size_t_var,
405 valid_buffer, valid_size ) );
406 TEST_INVALID_PARAM_RET(
407 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
408 mbedtls_cipher_auth_decrypt( &valid_ctx,
409 valid_buffer, valid_size,
410 valid_buffer, valid_size,
411 NULL, valid_size,
412 valid_buffer, &size_t_var,
413 valid_buffer, valid_size ) );
414 TEST_INVALID_PARAM_RET(
415 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
416 mbedtls_cipher_auth_decrypt( &valid_ctx,
417 valid_buffer, valid_size,
418 valid_buffer, valid_size,
419 valid_buffer, valid_size,
420 NULL, &size_t_var,
421 valid_buffer, valid_size ) );
422 TEST_INVALID_PARAM_RET(
423 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
424 mbedtls_cipher_auth_decrypt( &valid_ctx,
425 valid_buffer, valid_size,
426 valid_buffer, valid_size,
427 valid_buffer, valid_size,
428 valid_buffer, NULL,
429 valid_buffer, valid_size ) );
430 TEST_INVALID_PARAM_RET(
431 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
432 mbedtls_cipher_auth_decrypt( &valid_ctx,
433 valid_buffer, valid_size,
434 valid_buffer, valid_size,
435 valid_buffer, valid_size,
436 valid_buffer, &size_t_var,
437 NULL, valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100438#endif /* defined(MBEDTLS_CIPHER_MODE_AEAD) */
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100439
440 /* mbedtls_cipher_free() */
441 TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
442exit:
443 TEST_VALID_PARAM( mbedtls_cipher_free( &invalid_ctx ) );
444 TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
445}
446/* END_CASE */
447
Paul Bakker6a9c7252016-07-14 13:46:10 +0100448/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
Azim Khanf1aaec92017-05-30 14:23:15 +0100449void cipher_special_behaviours( )
Paul Bakker6a9c7252016-07-14 13:46:10 +0100450{
451 const mbedtls_cipher_info_t *cipher_info;
452 mbedtls_cipher_context_t ctx;
453 unsigned char input[32];
454 unsigned char output[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300455#if defined (MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100456 unsigned char iv[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300457#endif
Paul Bakker6a9c7252016-07-14 13:46:10 +0100458 size_t olen = 0;
459
460 mbedtls_cipher_init( &ctx );
461 memset( input, 0, sizeof( input ) );
462 memset( output, 0, sizeof( output ) );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300463#if defined(MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100464 memset( iv, 0, sizeof( iv ) );
465
466 /* Check and get info structures */
Ron Eldor7b012442017-09-25 17:03:12 +0300467 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker6a9c7252016-07-14 13:46:10 +0100468 TEST_ASSERT( NULL != cipher_info );
469
470 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
471
472 /* IV too big */
473 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1 )
474 == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
475
476 /* IV too small */
477 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, 0 )
478 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
479
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300480 mbedtls_cipher_free( &ctx );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300481 mbedtls_cipher_init( &ctx );
Ron Eldor6f90ed82017-09-26 12:08:54 +0300482#endif /* MBEDTLS_CIPHER_MODE_CBC */
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300483 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
Ron Eldor7b012442017-09-25 17:03:12 +0300484 TEST_ASSERT( NULL != cipher_info );
485
486 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
487
Paul Bakker6a9c7252016-07-14 13:46:10 +0100488 /* Update ECB with partial block */
489 TEST_ASSERT( mbedtls_cipher_update( &ctx, input, 1, output, &olen )
490 == MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
491
492exit:
493 mbedtls_cipher_free( &ctx );
494}
495/* END_CASE */
496
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +0200497/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100498void enc_dec_buf( int cipher_id, char * cipher_string, int key_len,
Paul Bakker33b43f12013-08-20 11:48:36 +0200499 int length_val, int pad_mode )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200500{
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200501 size_t length = length_val, outlen, total_len, i, block_size;
Jaeden Amerod906b812018-06-08 11:03:16 +0100502 unsigned char key[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000503 unsigned char iv[16];
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200504 unsigned char ad[13];
505 unsigned char tag[16];
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200506 unsigned char inbuf[64];
507 unsigned char encbuf[64];
508 unsigned char decbuf[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000509
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200510 const mbedtls_cipher_info_t *cipher_info;
511 mbedtls_cipher_context_t ctx_dec;
512 mbedtls_cipher_context_t ctx_enc;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000513
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200514 /*
515 * Prepare contexts
516 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200517 mbedtls_cipher_init( &ctx_dec );
518 mbedtls_cipher_init( &ctx_enc );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200519
520 memset( key, 0x2a, sizeof( key ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000521
522 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200523 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000524 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200525 TEST_ASSERT( mbedtls_cipher_info_from_string( cipher_string ) == cipher_info );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000526
527 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200528 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
529 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200530
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200531 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
532 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000533
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200534#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Paul Bakker33b43f12013-08-20 11:48:36 +0200535 if( -1 != pad_mode )
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200536 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200537 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
538 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200539 }
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200540#else
541 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200542#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200543
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200544 /*
545 * Do a few encode/decode cycles
546 */
547 for( i = 0; i < 3; i++ )
548 {
549 memset( iv , 0x00 + i, sizeof( iv ) );
550 memset( ad, 0x10 + i, sizeof( ad ) );
551 memset( inbuf, 0x20 + i, sizeof( inbuf ) );
552
553 memset( encbuf, 0, sizeof( encbuf ) );
554 memset( decbuf, 0, sizeof( decbuf ) );
555 memset( tag, 0, sizeof( tag ) );
556
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200557 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, sizeof( iv ) ) );
558 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, sizeof( iv ) ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200559
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200560 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
561 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200562
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200563#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200564 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, ad, sizeof( ad ) - i ) );
565 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, ad, sizeof( ad ) - i ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200566#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000567
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200568 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
569 TEST_ASSERT( block_size != 0 );
570
Paul Bakker8123e9d2011-01-06 15:37:30 +0000571 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200572 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, length, encbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200573 total_len = outlen;
574
575 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200576 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200577 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200578 total_len + block_size > length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000579
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200580 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200581 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000582
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200583#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200584 TEST_ASSERT( 0 == mbedtls_cipher_write_tag( &ctx_enc, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200585#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200586
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200587 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200588 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200589 total_len > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200590 total_len <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000591
592 /* decode the previously encoded string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200593 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, total_len, decbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200594 total_len = outlen;
595
596 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200597 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200598 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200599 total_len + block_size >= length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000600
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200601 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200602 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000603
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200604#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200605 TEST_ASSERT( 0 == mbedtls_cipher_check_tag( &ctx_dec, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200606#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200607
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200608 /* check result */
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200609 TEST_ASSERT( total_len == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000610 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200611 }
Paul Bakker8123e9d2011-01-06 15:37:30 +0000612
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200613 /*
614 * Done
615 */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200616exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200617 mbedtls_cipher_free( &ctx_dec );
618 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200619}
Paul Bakker33b43f12013-08-20 11:48:36 +0200620/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000621
Paul Bakker33b43f12013-08-20 11:48:36 +0200622/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100623void enc_fail( int cipher_id, int pad_mode, int key_len, int length_val,
624 int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200625{
Paul Bakker33b43f12013-08-20 11:48:36 +0200626 size_t length = length_val;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200627 unsigned char key[32];
628 unsigned char iv[16];
629
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200630 const mbedtls_cipher_info_t *cipher_info;
631 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200632
633 unsigned char inbuf[64];
634 unsigned char encbuf[64];
635
636 size_t outlen = 0;
637
638 memset( key, 0, 32 );
639 memset( iv , 0, 16 );
640
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200641 mbedtls_cipher_init( &ctx );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200642
643 memset( inbuf, 5, 64 );
644 memset( encbuf, 0, 64 );
645
646 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200647 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200648 TEST_ASSERT( NULL != cipher_info );
649
650 /* Initialise context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200651 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200652 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, key_len, MBEDTLS_ENCRYPT ) );
653#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
654 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200655#else
656 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200657#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
658 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv, 16 ) );
659 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200660#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200661 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200662#endif
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200663
664 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200665 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, inbuf, length, encbuf, &outlen ) );
666 TEST_ASSERT( ret == mbedtls_cipher_finish( &ctx, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200667
668 /* done */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200669exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200670 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200671}
Paul Bakker33b43f12013-08-20 11:48:36 +0200672/* END_CASE */
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200673
Paul Bakker33b43f12013-08-20 11:48:36 +0200674/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100675void dec_empty_buf( )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200676{
Paul Bakker8123e9d2011-01-06 15:37:30 +0000677 unsigned char key[32];
678 unsigned char iv[16];
679
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200680 mbedtls_cipher_context_t ctx_dec;
681 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000682
683 unsigned char encbuf[64];
684 unsigned char decbuf[64];
685
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000686 size_t outlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000687
688 memset( key, 0, 32 );
689 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200690
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200691 mbedtls_cipher_init( &ctx_dec );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200692
Paul Bakker8123e9d2011-01-06 15:37:30 +0000693 memset( encbuf, 0, 64 );
694 memset( decbuf, 0, 64 );
695
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200696 /* Initialise context */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200697 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000698 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200699
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200700 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000701
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200702 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, 128, MBEDTLS_DECRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000703
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200704 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200705
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200706 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200707
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200708#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200709 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200710#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000711
712 /* decode 0-byte string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200713 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, 0, decbuf, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000714 TEST_ASSERT( 0 == outlen );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200715 TEST_ASSERT( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED == mbedtls_cipher_finish(
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200716 &ctx_dec, decbuf + outlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000717 TEST_ASSERT( 0 == outlen );
718
Paul Bakkerbd51b262014-07-10 15:26:12 +0200719exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200720 mbedtls_cipher_free( &ctx_dec );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200721}
Paul Bakker33b43f12013-08-20 11:48:36 +0200722/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000723
Paul Bakker33b43f12013-08-20 11:48:36 +0200724/* BEGIN_CASE */
725void enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700726 int second_length_val, int pad_mode,
727 int first_encrypt_output_len, int second_encrypt_output_len,
728 int first_decrypt_output_len, int second_decrypt_output_len )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200729{
Paul Bakker33b43f12013-08-20 11:48:36 +0200730 size_t first_length = first_length_val;
731 size_t second_length = second_length_val;
Paul Bakker23986e52011-04-24 08:57:21 +0000732 size_t length = first_length + second_length;
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200733 size_t block_size;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000734 unsigned char key[32];
735 unsigned char iv[16];
736
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200737 mbedtls_cipher_context_t ctx_dec;
738 mbedtls_cipher_context_t ctx_enc;
739 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000740
741 unsigned char inbuf[64];
742 unsigned char encbuf[64];
743 unsigned char decbuf[64];
744
Paul Bakker23986e52011-04-24 08:57:21 +0000745 size_t outlen = 0;
746 size_t totaloutlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000747
748 memset( key, 0, 32 );
749 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200750
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200751 mbedtls_cipher_init( &ctx_dec );
752 mbedtls_cipher_init( &ctx_enc );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200753
Paul Bakker8123e9d2011-01-06 15:37:30 +0000754 memset( inbuf, 5, 64 );
755 memset( encbuf, 0, 64 );
756 memset( decbuf, 0, 64 );
757
758 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200759 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000760 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200761
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200762 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
763 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200764
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200765 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
766 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000767
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700768#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
769 if( -1 != pad_mode )
770 {
771 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
772 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
773 }
774#else
775 (void) pad_mode;
776#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
777
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200778 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
779 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200780
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200781 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
782 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200783
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200784#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200785 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
786 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200787#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000788
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200789 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
790 TEST_ASSERT( block_size != 0 );
791
Paul Bakker8123e9d2011-01-06 15:37:30 +0000792 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200793 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, first_length, encbuf, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700794 TEST_ASSERT( (size_t)first_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000795 totaloutlen = outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200796 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf + first_length, second_length, encbuf + totaloutlen, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700797 TEST_ASSERT( (size_t)second_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000798 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200799 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200800 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200801 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200802 totaloutlen + block_size > length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200803
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200804 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + totaloutlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000805 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200806 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200807 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200808 totaloutlen > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200809 totaloutlen <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000810
811 /* decode the previously encoded string */
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700812 second_length = totaloutlen - first_length;
813 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, first_length, decbuf, &outlen ) );
814 TEST_ASSERT( (size_t)first_decrypt_output_len == outlen );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200815 totaloutlen = outlen;
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700816 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf + first_length, second_length, decbuf + totaloutlen, &outlen ) );
817 TEST_ASSERT( (size_t)second_decrypt_output_len == outlen );
818 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200819
820 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200821 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200822 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200823 totaloutlen + block_size >= length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200824
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700825 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + totaloutlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200826 totaloutlen += outlen;
827
828 TEST_ASSERT( totaloutlen == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000829
830 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
831
Paul Bakkerbd51b262014-07-10 15:26:12 +0200832exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200833 mbedtls_cipher_free( &ctx_dec );
834 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200835}
Paul Bakker33b43f12013-08-20 11:48:36 +0200836/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000837
Paul Bakker33b43f12013-08-20 11:48:36 +0200838/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100839void decrypt_test_vec( int cipher_id, int pad_mode, data_t * key,
840 data_t * iv, data_t * cipher,
841 data_t * clear, data_t * ad, data_t * tag,
Azim Khand30ca132017-06-09 04:32:58 +0100842 int finish_result, int tag_result )
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200843{
Manuel Pégourié-Gonnard234e1ce2018-05-10 12:54:32 +0200844 unsigned char output[265];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200845 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200846 size_t outlen, total_len;
847
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200848 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200849
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200850 memset( output, 0x00, sizeof( output ) );
851
Azim Khanf1aaec92017-05-30 14:23:15 +0100852#if !defined(MBEDTLS_GCM_C) && !defined(MBEDTLS_CHACHAPOLY_C)
Mohammad Azim Khancf32c452017-06-13 14:55:58 +0100853 ((void) ad);
854 ((void) tag);
Manuel Pégourié-Gonnarda7496f02013-09-20 11:29:59 +0200855#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200856
857 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200858 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200859 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100860 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200861#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200862 if( pad_mode != -1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200863 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200864#else
865 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200866#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Azim Khand30ca132017-06-09 04:32:58 +0100867 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv->x, iv->len ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200868 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200869#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100870 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, ad->x, ad->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200871#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200872
Azim Khand30ca132017-06-09 04:32:58 +0100873 /* decode buffer and check tag->x */
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200874 total_len = 0;
Azim Khand30ca132017-06-09 04:32:58 +0100875 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, cipher->x, cipher->len, output, &outlen ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200876 total_len += outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200877 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200878 &outlen ) );
879 total_len += outlen;
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200880#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100881 TEST_ASSERT( tag_result == mbedtls_cipher_check_tag( &ctx, tag->x, tag->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200882#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200883
884 /* check plaintext only if everything went fine */
885 if( 0 == finish_result && 0 == tag_result )
886 {
Azim Khand30ca132017-06-09 04:32:58 +0100887 TEST_ASSERT( total_len == clear->len );
888 TEST_ASSERT( 0 == memcmp( output, clear->x, clear->len ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200889 }
890
Paul Bakkerbd51b262014-07-10 15:26:12 +0200891exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200892 mbedtls_cipher_free( &ctx );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200893}
894/* END_CASE */
895
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200896/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_AEAD */
Azim Khan5fcca462018-06-29 11:05:32 +0100897void auth_crypt_tv( int cipher_id, data_t * key, data_t * iv,
898 data_t * ad, data_t * cipher, data_t * tag,
899 char * result, data_t * clear )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200900{
901 int ret;
Manuel Pégourié-Gonnard69767d12018-05-09 12:25:18 +0200902 unsigned char output[267]; /* above + 2 (overwrite check) */
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200903 unsigned char my_tag[20];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200904 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200905 size_t outlen;
906
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200907 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200908
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200909 memset( output, 0xFF, sizeof( output ) );
Azim Khan46c9b1f2017-05-31 20:46:35 +0100910 memset( my_tag, 0xFF, sizeof( my_tag ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200911
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200912
913 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200914 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200915 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100916 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200917
Azim Khand30ca132017-06-09 04:32:58 +0100918 /* decode buffer and check tag->x */
919 ret = mbedtls_cipher_auth_decrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
920 cipher->x, cipher->len, output, &outlen,
921 tag->x, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200922
923 /* make sure we didn't overwrite */
924 TEST_ASSERT( output[outlen + 0] == 0xFF );
925 TEST_ASSERT( output[outlen + 1] == 0xFF );
926
927 /* make sure the message is rejected if it should be */
Azim Khan46c9b1f2017-05-31 20:46:35 +0100928 if( strcmp( result, "FAIL" ) == 0 )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200929 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200930 TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
Paul Bakkerbd51b262014-07-10 15:26:12 +0200931 goto exit;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200932 }
933
934 /* otherwise, make sure it was decrypted properly */
935 TEST_ASSERT( ret == 0 );
936
Azim Khand30ca132017-06-09 04:32:58 +0100937 TEST_ASSERT( outlen == clear->len );
938 TEST_ASSERT( memcmp( output, clear->x, clear->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200939
Azim Khand30ca132017-06-09 04:32:58 +0100940 /* 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 +0200941 memset( output, 0xFF, sizeof( output ) );
942 outlen = 0;
943
Azim Khand30ca132017-06-09 04:32:58 +0100944 ret = mbedtls_cipher_auth_encrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
945 clear->x, clear->len, output, &outlen,
946 my_tag, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200947 TEST_ASSERT( ret == 0 );
948
Azim Khand30ca132017-06-09 04:32:58 +0100949 TEST_ASSERT( outlen == clear->len );
950 TEST_ASSERT( memcmp( output, cipher->x, clear->len ) == 0 );
951 TEST_ASSERT( memcmp( my_tag, tag->x, tag->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200952
953 /* make sure we didn't overwrite */
954 TEST_ASSERT( output[outlen + 0] == 0xFF );
955 TEST_ASSERT( output[outlen + 1] == 0xFF );
Azim Khand30ca132017-06-09 04:32:58 +0100956 TEST_ASSERT( my_tag[tag->len + 0] == 0xFF );
957 TEST_ASSERT( my_tag[tag->len + 1] == 0xFF );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200958
959
Paul Bakkerbd51b262014-07-10 15:26:12 +0200960exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200961 mbedtls_cipher_free( &ctx );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200962}
963/* END_CASE */
964
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200965/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100966void test_vec_ecb( int cipher_id, int operation, data_t * key,
967 data_t * input, data_t * result, int finish_result
Azim Khand30ca132017-06-09 04:32:58 +0100968 )
Paul Bakker5e0efa72013-09-08 23:04:04 +0200969{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200970 mbedtls_cipher_context_t ctx;
Paul Bakker5e0efa72013-09-08 23:04:04 +0200971 unsigned char output[32];
972 size_t outlen;
973
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200974 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200975
Paul Bakker5e0efa72013-09-08 23:04:04 +0200976 memset( output, 0x00, sizeof( output ) );
977
978 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200979 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200980 mbedtls_cipher_info_from_type( cipher_id ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200981
Paul Bakker5e0efa72013-09-08 23:04:04 +0200982
Azim Khand30ca132017-06-09 04:32:58 +0100983 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200984
Azim Khand30ca132017-06-09 04:32:58 +0100985 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, input->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200986 mbedtls_cipher_get_block_size( &ctx ),
Paul Bakker5e0efa72013-09-08 23:04:04 +0200987 output, &outlen ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200988 TEST_ASSERT( outlen == mbedtls_cipher_get_block_size( &ctx ) );
989 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Paul Bakker5e0efa72013-09-08 23:04:04 +0200990 &outlen ) );
991 TEST_ASSERT( 0 == outlen );
992
993 /* check plaintext only if everything went fine */
994 if( 0 == finish_result )
Azim Khand30ca132017-06-09 04:32:58 +0100995 TEST_ASSERT( 0 == memcmp( output, result->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200996 mbedtls_cipher_get_block_size( &ctx ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200997
Paul Bakkerbd51b262014-07-10 15:26:12 +0200998exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200999 mbedtls_cipher_free( &ctx );
Paul Bakker5e0efa72013-09-08 23:04:04 +02001000}
1001/* END_CASE */
1002
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001003/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Ron Eldor7b012442017-09-25 17:03:12 +03001004void test_vec_crypt( int cipher_id, int operation, char *hex_key,
1005 char *hex_iv, char *hex_input, char *hex_result,
1006 int finish_result )
1007{
1008 unsigned char key[50];
1009 unsigned char input[16];
1010 unsigned char result[16];
1011 unsigned char iv[16];
1012 size_t key_len, iv_len, inputlen, resultlen;
1013 mbedtls_cipher_context_t ctx;
1014 unsigned char output[32];
1015 size_t outlen;
1016
1017 mbedtls_cipher_init( &ctx );
1018
1019 memset( key, 0x00, sizeof( key ) );
1020 memset( input, 0x00, sizeof( input ) );
1021 memset( result, 0x00, sizeof( result ) );
1022 memset( output, 0x00, sizeof( output ) );
1023 memset( iv, 0x00, sizeof( iv ) );
1024
1025 /* Prepare context */
1026 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
1027 mbedtls_cipher_info_from_type( cipher_id ) ) );
1028
1029 key_len = unhexify( key, hex_key );
1030 inputlen = unhexify( input, hex_input );
1031 resultlen = unhexify( result, hex_result );
1032
1033 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, 8 * key_len, operation ) );
1034 if( MBEDTLS_MODE_CBC == ctx.cipher_info->mode )
1035 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, MBEDTLS_PADDING_NONE ) );
1036
Ron Eldor4e64e0b2017-09-25 18:22:32 +03001037 iv_len = unhexify( iv, hex_iv );
Ron Eldor7b012442017-09-25 17:03:12 +03001038
1039 TEST_ASSERT( finish_result == mbedtls_cipher_crypt( &ctx, iv_len ? iv : NULL,
1040 iv_len, input, inputlen,
1041 output, &outlen ) );
1042 TEST_ASSERT( resultlen == outlen );
1043 /* check plaintext only if everything went fine */
1044 if( 0 == finish_result )
1045 TEST_ASSERT( 0 == memcmp( output, result, outlen ) );
1046
1047exit:
1048 mbedtls_cipher_free( &ctx );
1049}
1050/* END_CASE */
1051
1052/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Paul Bakker33b43f12013-08-20 11:48:36 +02001053void set_padding( int cipher_id, int pad_mode, int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001054{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001055 const mbedtls_cipher_info_t *cipher_info;
1056 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001057
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001058 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +02001059
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001060 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001061 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +02001062 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001063
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001064 TEST_ASSERT( ret == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001065
Paul Bakkerbd51b262014-07-10 15:26:12 +02001066exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001067 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001068}
Paul Bakker33b43f12013-08-20 11:48:36 +02001069/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +00001070
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001071/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
Azim Khan5fcca462018-06-29 11:05:32 +01001072void check_padding( int pad_mode, data_t * input, int ret, int dlen_check
Azim Khand30ca132017-06-09 04:32:58 +01001073 )
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001074{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001075 mbedtls_cipher_info_t cipher_info;
1076 mbedtls_cipher_context_t ctx;
Azim Khanf1aaec92017-05-30 14:23:15 +01001077 size_t dlen;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001078
1079 /* build a fake context just for getting access to get_padding */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001080 mbedtls_cipher_init( &ctx );
1081 cipher_info.mode = MBEDTLS_MODE_CBC;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001082 ctx.cipher_info = &cipher_info;
1083
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001084 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001085
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001086
Azim Khand30ca132017-06-09 04:32:58 +01001087 TEST_ASSERT( ret == ctx.get_padding( input->x, input->len, &dlen ) );
Paul Bakker33b43f12013-08-20 11:48:36 +02001088 if( 0 == ret )
1089 TEST_ASSERT( dlen == (size_t) dlen_check );
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001090}
Paul Bakker33b43f12013-08-20 11:48:36 +02001091/* END_CASE */