blob: dd997b089ee6762905acfaf2be05c5602b9b1872 [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
24/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +010025void cipher_null_args( )
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020026{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020027 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020028
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020029 mbedtls_cipher_init( &ctx );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020030
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020031 TEST_ASSERT( mbedtls_cipher_get_block_size( NULL ) == 0 );
32 TEST_ASSERT( mbedtls_cipher_get_block_size( &ctx ) == 0 );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020033
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020034 TEST_ASSERT( mbedtls_cipher_get_cipher_mode( NULL ) == MBEDTLS_MODE_NONE );
35 TEST_ASSERT( mbedtls_cipher_get_cipher_mode( &ctx ) == MBEDTLS_MODE_NONE );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020036
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020037 TEST_ASSERT( mbedtls_cipher_get_iv_size( NULL ) == 0 );
38 TEST_ASSERT( mbedtls_cipher_get_iv_size( &ctx ) == 0 );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020039
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020040 TEST_ASSERT( mbedtls_cipher_info_from_string( NULL ) == NULL );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020041}
42/* END_CASE */
43
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010044/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
45void cipher_invalid_param( )
46{
47 mbedtls_cipher_context_t invalid_ctx;
48 mbedtls_cipher_context_t valid_ctx;
49
k-stachowiaka5390702018-12-17 11:27:03 +010050 mbedtls_operation_t valid_operation = MBEDTLS_ENCRYPT;
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010051 mbedtls_operation_t invalid_operation = 100;
52 mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
53 unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
54 int valid_size = sizeof(valid_buffer);
55 int valid_bitlen = valid_size * 8;
k-stachowiaka5390702018-12-17 11:27:03 +010056 const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
57 *( mbedtls_cipher_list() ) );
58
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010059 size_t size_t_var;
60
61 /* mbedtls_cipher_init() */
62 TEST_VALID_PARAM( mbedtls_cipher_init( &invalid_ctx ) );
63 TEST_VALID_PARAM( mbedtls_cipher_init( &valid_ctx ) );
64
65 TEST_INVALID_PARAM( mbedtls_cipher_init( NULL ) );
66
k-stachowiaka5390702018-12-17 11:27:03 +010067 /* mbedtls_cipher_setup() */
68 TEST_INVALID_PARAM_RET(
69 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
70 mbedtls_cipher_setup( NULL, valid_info ) );
71 TEST_INVALID_PARAM_RET(
72 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
73 mbedtls_cipher_setup( &valid_ctx, NULL ) );
74
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010075 /* mbedtls_cipher_setkey() */
76 TEST_INVALID_PARAM_RET(
77 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +010078 mbedtls_cipher_setkey( NULL,
79 valid_buffer,
80 valid_bitlen,
81 valid_operation ) );
82 TEST_INVALID_PARAM_RET(
83 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
84 mbedtls_cipher_setkey( &invalid_ctx,
85 valid_buffer,
86 valid_bitlen,
87 valid_operation ) );
88 TEST_INVALID_PARAM_RET(
89 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
90 mbedtls_cipher_setkey( &valid_ctx,
91 NULL,
92 valid_bitlen,
93 valid_operation ) );
94 TEST_INVALID_PARAM_RET(
95 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010096 mbedtls_cipher_setkey( &valid_ctx,
97 valid_buffer,
98 valid_bitlen,
99 invalid_operation ) );
100
k-stachowiaka5390702018-12-17 11:27:03 +0100101 /* mbedtls_cipher_set_iv() */
102 TEST_INVALID_PARAM_RET(
103 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
104 mbedtls_cipher_set_iv( NULL,
105 valid_buffer,
106 valid_size ) );
107 TEST_INVALID_PARAM_RET(
108 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
109 mbedtls_cipher_set_iv( &invalid_ctx,
110 valid_buffer,
111 valid_size ) );
112 TEST_INVALID_PARAM_RET(
113 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
114 mbedtls_cipher_set_iv( &valid_ctx,
115 NULL,
116 valid_size ) );
117
118 /* mbedtls_cipher_reset() */
119 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
120 mbedtls_cipher_reset( NULL ) );
121 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
122 mbedtls_cipher_reset( &invalid_ctx ) );
123
124#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
125 /* mbedtls_cipher_update_ad() */
126 TEST_INVALID_PARAM_RET(
127 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
128 mbedtls_cipher_update_ad( NULL,
129 valid_buffer,
130 valid_size ) );
131 TEST_INVALID_PARAM_RET(
132 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
133 mbedtls_cipher_update_ad( &invalid_ctx,
134 valid_buffer,
135 valid_size ) );
136 TEST_INVALID_PARAM_RET(
137 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
138 mbedtls_cipher_update_ad( &valid_ctx,
139 NULL,
140 valid_size ) );
141#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
142
143#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100144 /* mbedtls_cipher_set_padding_mode() */
145 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
146 mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
147 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
148 mbedtls_cipher_set_padding_mode( &invalid_ctx,
149 valid_mode ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100150#endif
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100151
152 /* mbedtls_cipher_update() */
153 TEST_INVALID_PARAM_RET(
154 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100155 mbedtls_cipher_update( NULL,
156 valid_buffer,
157 valid_size,
158 valid_buffer,
159 &size_t_var ) );
160 TEST_INVALID_PARAM_RET(
161 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
162 mbedtls_cipher_update( &invalid_ctx,
163 valid_buffer,
164 valid_size,
165 valid_buffer,
166 &size_t_var ) );
167 TEST_INVALID_PARAM_RET(
168 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100169 mbedtls_cipher_update( &valid_ctx,
170 NULL, valid_size,
171 valid_buffer,
172 &size_t_var ) );
173 TEST_INVALID_PARAM_RET(
174 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
175 mbedtls_cipher_update( &valid_ctx,
176 valid_buffer, valid_size,
177 NULL,
178 &size_t_var ) );
179 TEST_INVALID_PARAM_RET(
180 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
181 mbedtls_cipher_update( &valid_ctx,
182 valid_buffer, valid_size,
183 valid_buffer,
184 NULL ) );
185
186 /* mbedtls_cipher_finish() */
187 TEST_INVALID_PARAM_RET(
188 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100189 mbedtls_cipher_finish( NULL,
190 valid_buffer,
191 &size_t_var ) );
192 TEST_INVALID_PARAM_RET(
193 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
194 mbedtls_cipher_finish( &invalid_ctx,
195 valid_buffer,
196 &size_t_var ) );
197 TEST_INVALID_PARAM_RET(
198 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100199 mbedtls_cipher_finish( &valid_ctx,
200 NULL,
201 &size_t_var ) );
202 TEST_INVALID_PARAM_RET(
203 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
204 mbedtls_cipher_finish( &valid_ctx,
205 valid_buffer,
206 NULL ) );
207
k-stachowiaka5390702018-12-17 11:27:03 +0100208#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100209 /* mbedtls_cipher_write_tag() */
210 TEST_INVALID_PARAM_RET(
211 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100212 mbedtls_cipher_write_tag( NULL,
213 valid_buffer,
214 valid_size ) );
215 TEST_INVALID_PARAM_RET(
216 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
217 mbedtls_cipher_write_tag( &invalid_ctx,
218 valid_buffer,
219 valid_size ) );
220 TEST_INVALID_PARAM_RET(
221 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100222 mbedtls_cipher_write_tag( &valid_ctx,
223 NULL,
224 valid_size ) );
225
226 /* mbedtls_cipher_check_tag() */
227 TEST_INVALID_PARAM_RET(
228 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100229 mbedtls_cipher_check_tag( NULL,
230 valid_buffer,
231 valid_size ) );
232 TEST_INVALID_PARAM_RET(
233 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
234 mbedtls_cipher_check_tag( &invalid_ctx,
235 valid_buffer,
236 valid_size ) );
237 TEST_INVALID_PARAM_RET(
238 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100239 mbedtls_cipher_check_tag( &valid_ctx,
240 NULL,
241 valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100242#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100243
244 /* mbedtls_cipher_crypt() */
245 TEST_INVALID_PARAM_RET(
246 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
247 mbedtls_cipher_crypt( NULL,
248 valid_buffer, valid_size,
249 valid_buffer, valid_size,
250 valid_buffer, &size_t_var ) );
251 TEST_INVALID_PARAM_RET(
252 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
253 mbedtls_cipher_crypt( &invalid_ctx,
254 valid_buffer, valid_size,
255 valid_buffer, valid_size,
256 valid_buffer, &size_t_var ) );
257 TEST_INVALID_PARAM_RET(
258 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
259 mbedtls_cipher_crypt( &valid_ctx,
260 NULL, valid_size,
261 valid_buffer, valid_size,
262 valid_buffer, &size_t_var ) );
263 TEST_INVALID_PARAM_RET(
264 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
265 mbedtls_cipher_crypt( &valid_ctx,
266 valid_buffer, valid_size,
267 NULL, valid_size,
268 valid_buffer, &size_t_var ) );
269 TEST_INVALID_PARAM_RET(
270 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
271 mbedtls_cipher_crypt( &valid_ctx,
272 valid_buffer, valid_size,
273 valid_buffer, valid_size,
274 NULL, &size_t_var ) );
275 TEST_INVALID_PARAM_RET(
276 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
277 mbedtls_cipher_crypt( &valid_ctx,
278 valid_buffer, valid_size,
279 valid_buffer, valid_size,
280 valid_buffer, NULL ) );
281
k-stachowiaka5390702018-12-17 11:27:03 +0100282#if defined(MBEDTLS_CIPHER_MODE_AEAD)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100283 /* mbedtls_cipher_auth_encrypt() */
284 TEST_INVALID_PARAM_RET(
285 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
286 mbedtls_cipher_auth_encrypt( NULL,
287 valid_buffer, valid_size,
288 valid_buffer, valid_size,
289 valid_buffer, valid_size,
290 valid_buffer, &size_t_var,
291 valid_buffer, valid_size ) );
292 TEST_INVALID_PARAM_RET(
293 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
294 mbedtls_cipher_auth_encrypt( &invalid_ctx,
295 valid_buffer, valid_size,
296 valid_buffer, valid_size,
297 valid_buffer, valid_size,
298 valid_buffer, &size_t_var,
299 valid_buffer, valid_size ) );
300 TEST_INVALID_PARAM_RET(
301 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
302 mbedtls_cipher_auth_encrypt( &valid_ctx,
303 NULL, valid_size,
304 valid_buffer, valid_size,
305 valid_buffer, valid_size,
306 valid_buffer, &size_t_var,
307 valid_buffer, valid_size ) );
308 TEST_INVALID_PARAM_RET(
309 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
310 mbedtls_cipher_auth_encrypt( &valid_ctx,
311 valid_buffer, valid_size,
312 NULL, 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( &valid_ctx,
319 valid_buffer, valid_size,
320 valid_buffer, valid_size,
321 NULL, 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 valid_buffer, valid_size,
328 valid_buffer, valid_size,
329 valid_buffer, valid_size,
330 NULL, &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 valid_buffer, valid_size,
337 valid_buffer, valid_size,
338 valid_buffer, NULL,
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 valid_buffer, valid_size,
346 valid_buffer, &size_t_var,
347 NULL, valid_size ) );
348
349 /* mbedtls_cipher_auth_decrypt() */
350 TEST_INVALID_PARAM_RET(
351 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
352 mbedtls_cipher_auth_decrypt( NULL,
353 valid_buffer, valid_size,
354 valid_buffer, valid_size,
355 valid_buffer, valid_size,
356 valid_buffer, &size_t_var,
357 valid_buffer, valid_size ) );
358 TEST_INVALID_PARAM_RET(
359 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
360 mbedtls_cipher_auth_decrypt( &invalid_ctx,
361 valid_buffer, valid_size,
362 valid_buffer, valid_size,
363 valid_buffer, valid_size,
364 valid_buffer, &size_t_var,
365 valid_buffer, valid_size ) );
366 TEST_INVALID_PARAM_RET(
367 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
368 mbedtls_cipher_auth_decrypt( &valid_ctx,
369 NULL, valid_size,
370 valid_buffer, valid_size,
371 valid_buffer, valid_size,
372 valid_buffer, &size_t_var,
373 valid_buffer, valid_size ) );
374 TEST_INVALID_PARAM_RET(
375 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
376 mbedtls_cipher_auth_decrypt( &valid_ctx,
377 valid_buffer, valid_size,
378 NULL, 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( &valid_ctx,
385 valid_buffer, valid_size,
386 valid_buffer, valid_size,
387 NULL, 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 valid_buffer, valid_size,
394 valid_buffer, valid_size,
395 valid_buffer, valid_size,
396 NULL, &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 valid_buffer, valid_size,
403 valid_buffer, valid_size,
404 valid_buffer, NULL,
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 valid_buffer, valid_size,
412 valid_buffer, &size_t_var,
413 NULL, valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100414#endif /* defined(MBEDTLS_CIPHER_MODE_AEAD) */
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100415
416 /* mbedtls_cipher_free() */
417 TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
418exit:
419 TEST_VALID_PARAM( mbedtls_cipher_free( &invalid_ctx ) );
420 TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
421}
422/* END_CASE */
423
Paul Bakker6a9c7252016-07-14 13:46:10 +0100424/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
Azim Khanf1aaec92017-05-30 14:23:15 +0100425void cipher_special_behaviours( )
Paul Bakker6a9c7252016-07-14 13:46:10 +0100426{
427 const mbedtls_cipher_info_t *cipher_info;
428 mbedtls_cipher_context_t ctx;
429 unsigned char input[32];
430 unsigned char output[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300431#if defined (MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100432 unsigned char iv[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300433#endif
Paul Bakker6a9c7252016-07-14 13:46:10 +0100434 size_t olen = 0;
435
436 mbedtls_cipher_init( &ctx );
437 memset( input, 0, sizeof( input ) );
438 memset( output, 0, sizeof( output ) );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300439#if defined(MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100440 memset( iv, 0, sizeof( iv ) );
441
442 /* Check and get info structures */
Ron Eldor7b012442017-09-25 17:03:12 +0300443 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker6a9c7252016-07-14 13:46:10 +0100444 TEST_ASSERT( NULL != cipher_info );
445
446 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
447
448 /* IV too big */
449 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1 )
450 == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
451
452 /* IV too small */
453 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, 0 )
454 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
455
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300456 mbedtls_cipher_free( &ctx );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300457 mbedtls_cipher_init( &ctx );
Ron Eldor6f90ed82017-09-26 12:08:54 +0300458#endif /* MBEDTLS_CIPHER_MODE_CBC */
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300459 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
Ron Eldor7b012442017-09-25 17:03:12 +0300460 TEST_ASSERT( NULL != cipher_info );
461
462 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
463
Paul Bakker6a9c7252016-07-14 13:46:10 +0100464 /* Update ECB with partial block */
465 TEST_ASSERT( mbedtls_cipher_update( &ctx, input, 1, output, &olen )
466 == MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
467
468exit:
469 mbedtls_cipher_free( &ctx );
470}
471/* END_CASE */
472
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +0200473/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100474void enc_dec_buf( int cipher_id, char * cipher_string, int key_len,
Paul Bakker33b43f12013-08-20 11:48:36 +0200475 int length_val, int pad_mode )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200476{
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200477 size_t length = length_val, outlen, total_len, i, block_size;
Jaeden Amerod906b812018-06-08 11:03:16 +0100478 unsigned char key[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000479 unsigned char iv[16];
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200480 unsigned char ad[13];
481 unsigned char tag[16];
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200482 unsigned char inbuf[64];
483 unsigned char encbuf[64];
484 unsigned char decbuf[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000485
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200486 const mbedtls_cipher_info_t *cipher_info;
487 mbedtls_cipher_context_t ctx_dec;
488 mbedtls_cipher_context_t ctx_enc;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000489
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200490 /*
491 * Prepare contexts
492 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200493 mbedtls_cipher_init( &ctx_dec );
494 mbedtls_cipher_init( &ctx_enc );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200495
496 memset( key, 0x2a, sizeof( key ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000497
498 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200499 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000500 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200501 TEST_ASSERT( mbedtls_cipher_info_from_string( cipher_string ) == cipher_info );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000502
503 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200504 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
505 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200506
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200507 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
508 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000509
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200510#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Paul Bakker33b43f12013-08-20 11:48:36 +0200511 if( -1 != pad_mode )
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200512 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200513 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
514 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200515 }
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200516#else
517 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200518#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200519
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200520 /*
521 * Do a few encode/decode cycles
522 */
523 for( i = 0; i < 3; i++ )
524 {
525 memset( iv , 0x00 + i, sizeof( iv ) );
526 memset( ad, 0x10 + i, sizeof( ad ) );
527 memset( inbuf, 0x20 + i, sizeof( inbuf ) );
528
529 memset( encbuf, 0, sizeof( encbuf ) );
530 memset( decbuf, 0, sizeof( decbuf ) );
531 memset( tag, 0, sizeof( tag ) );
532
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200533 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, sizeof( iv ) ) );
534 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, sizeof( iv ) ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200535
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200536 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
537 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200538
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200539#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200540 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, ad, sizeof( ad ) - i ) );
541 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, ad, sizeof( ad ) - i ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200542#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000543
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200544 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
545 TEST_ASSERT( block_size != 0 );
546
Paul Bakker8123e9d2011-01-06 15:37:30 +0000547 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200548 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, length, encbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200549 total_len = outlen;
550
551 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200552 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200553 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200554 total_len + block_size > length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000555
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200556 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200557 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000558
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200559#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200560 TEST_ASSERT( 0 == mbedtls_cipher_write_tag( &ctx_enc, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200561#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200562
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200563 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200564 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200565 total_len > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200566 total_len <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000567
568 /* decode the previously encoded string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200569 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, total_len, decbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200570 total_len = outlen;
571
572 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200573 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200574 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200575 total_len + block_size >= length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000576
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200577 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200578 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000579
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200580#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200581 TEST_ASSERT( 0 == mbedtls_cipher_check_tag( &ctx_dec, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200582#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200583
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200584 /* check result */
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200585 TEST_ASSERT( total_len == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000586 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200587 }
Paul Bakker8123e9d2011-01-06 15:37:30 +0000588
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200589 /*
590 * Done
591 */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200592exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200593 mbedtls_cipher_free( &ctx_dec );
594 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200595}
Paul Bakker33b43f12013-08-20 11:48:36 +0200596/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000597
Paul Bakker33b43f12013-08-20 11:48:36 +0200598/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100599void enc_fail( int cipher_id, int pad_mode, int key_len, int length_val,
600 int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200601{
Paul Bakker33b43f12013-08-20 11:48:36 +0200602 size_t length = length_val;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200603 unsigned char key[32];
604 unsigned char iv[16];
605
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200606 const mbedtls_cipher_info_t *cipher_info;
607 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200608
609 unsigned char inbuf[64];
610 unsigned char encbuf[64];
611
612 size_t outlen = 0;
613
614 memset( key, 0, 32 );
615 memset( iv , 0, 16 );
616
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200617 mbedtls_cipher_init( &ctx );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200618
619 memset( inbuf, 5, 64 );
620 memset( encbuf, 0, 64 );
621
622 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200623 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200624 TEST_ASSERT( NULL != cipher_info );
625
626 /* Initialise context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200627 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200628 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, key_len, MBEDTLS_ENCRYPT ) );
629#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
630 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200631#else
632 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200633#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
634 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv, 16 ) );
635 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200636#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200637 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200638#endif
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200639
640 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200641 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, inbuf, length, encbuf, &outlen ) );
642 TEST_ASSERT( ret == mbedtls_cipher_finish( &ctx, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200643
644 /* done */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200645exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200646 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200647}
Paul Bakker33b43f12013-08-20 11:48:36 +0200648/* END_CASE */
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200649
Paul Bakker33b43f12013-08-20 11:48:36 +0200650/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100651void dec_empty_buf( )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200652{
Paul Bakker8123e9d2011-01-06 15:37:30 +0000653 unsigned char key[32];
654 unsigned char iv[16];
655
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200656 mbedtls_cipher_context_t ctx_dec;
657 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000658
659 unsigned char encbuf[64];
660 unsigned char decbuf[64];
661
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000662 size_t outlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000663
664 memset( key, 0, 32 );
665 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200666
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200667 mbedtls_cipher_init( &ctx_dec );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200668
Paul Bakker8123e9d2011-01-06 15:37:30 +0000669 memset( encbuf, 0, 64 );
670 memset( decbuf, 0, 64 );
671
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200672 /* Initialise context */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200673 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000674 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200675
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200676 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000677
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200678 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, 128, MBEDTLS_DECRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000679
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200680 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200681
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200682 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200683
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200684#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200685 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200686#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000687
688 /* decode 0-byte string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200689 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, 0, decbuf, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000690 TEST_ASSERT( 0 == outlen );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200691 TEST_ASSERT( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED == mbedtls_cipher_finish(
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200692 &ctx_dec, decbuf + outlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000693 TEST_ASSERT( 0 == outlen );
694
Paul Bakkerbd51b262014-07-10 15:26:12 +0200695exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200696 mbedtls_cipher_free( &ctx_dec );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200697}
Paul Bakker33b43f12013-08-20 11:48:36 +0200698/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000699
Paul Bakker33b43f12013-08-20 11:48:36 +0200700/* BEGIN_CASE */
701void enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700702 int second_length_val, int pad_mode,
703 int first_encrypt_output_len, int second_encrypt_output_len,
704 int first_decrypt_output_len, int second_decrypt_output_len )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200705{
Paul Bakker33b43f12013-08-20 11:48:36 +0200706 size_t first_length = first_length_val;
707 size_t second_length = second_length_val;
Paul Bakker23986e52011-04-24 08:57:21 +0000708 size_t length = first_length + second_length;
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200709 size_t block_size;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000710 unsigned char key[32];
711 unsigned char iv[16];
712
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200713 mbedtls_cipher_context_t ctx_dec;
714 mbedtls_cipher_context_t ctx_enc;
715 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000716
717 unsigned char inbuf[64];
718 unsigned char encbuf[64];
719 unsigned char decbuf[64];
720
Paul Bakker23986e52011-04-24 08:57:21 +0000721 size_t outlen = 0;
722 size_t totaloutlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000723
724 memset( key, 0, 32 );
725 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200726
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200727 mbedtls_cipher_init( &ctx_dec );
728 mbedtls_cipher_init( &ctx_enc );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200729
Paul Bakker8123e9d2011-01-06 15:37:30 +0000730 memset( inbuf, 5, 64 );
731 memset( encbuf, 0, 64 );
732 memset( decbuf, 0, 64 );
733
734 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200735 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000736 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200737
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200738 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
739 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200740
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200741 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
742 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000743
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700744#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
745 if( -1 != pad_mode )
746 {
747 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
748 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
749 }
750#else
751 (void) pad_mode;
752#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
753
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200754 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
755 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200756
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200757 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
758 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200759
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200760#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200761 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
762 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200763#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000764
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200765 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
766 TEST_ASSERT( block_size != 0 );
767
Paul Bakker8123e9d2011-01-06 15:37:30 +0000768 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200769 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, first_length, encbuf, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700770 TEST_ASSERT( (size_t)first_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000771 totaloutlen = outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200772 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf + first_length, second_length, encbuf + totaloutlen, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700773 TEST_ASSERT( (size_t)second_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000774 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200775 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200776 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200777 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200778 totaloutlen + block_size > length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200779
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200780 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + totaloutlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000781 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200782 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200783 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200784 totaloutlen > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200785 totaloutlen <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000786
787 /* decode the previously encoded string */
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700788 second_length = totaloutlen - first_length;
789 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, first_length, decbuf, &outlen ) );
790 TEST_ASSERT( (size_t)first_decrypt_output_len == outlen );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200791 totaloutlen = outlen;
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700792 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf + first_length, second_length, decbuf + totaloutlen, &outlen ) );
793 TEST_ASSERT( (size_t)second_decrypt_output_len == outlen );
794 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200795
796 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200797 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200798 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200799 totaloutlen + block_size >= length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200800
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700801 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + totaloutlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200802 totaloutlen += outlen;
803
804 TEST_ASSERT( totaloutlen == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000805
806 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
807
Paul Bakkerbd51b262014-07-10 15:26:12 +0200808exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200809 mbedtls_cipher_free( &ctx_dec );
810 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200811}
Paul Bakker33b43f12013-08-20 11:48:36 +0200812/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000813
Paul Bakker33b43f12013-08-20 11:48:36 +0200814/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100815void decrypt_test_vec( int cipher_id, int pad_mode, data_t * key,
816 data_t * iv, data_t * cipher,
817 data_t * clear, data_t * ad, data_t * tag,
Azim Khand30ca132017-06-09 04:32:58 +0100818 int finish_result, int tag_result )
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200819{
Manuel Pégourié-Gonnard234e1ce2018-05-10 12:54:32 +0200820 unsigned char output[265];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200821 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200822 size_t outlen, total_len;
823
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200824 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200825
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200826 memset( output, 0x00, sizeof( output ) );
827
Azim Khanf1aaec92017-05-30 14:23:15 +0100828#if !defined(MBEDTLS_GCM_C) && !defined(MBEDTLS_CHACHAPOLY_C)
Mohammad Azim Khancf32c452017-06-13 14:55:58 +0100829 ((void) ad);
830 ((void) tag);
Manuel Pégourié-Gonnarda7496f02013-09-20 11:29:59 +0200831#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200832
833 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200834 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200835 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100836 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200837#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200838 if( pad_mode != -1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200839 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200840#else
841 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200842#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Azim Khand30ca132017-06-09 04:32:58 +0100843 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv->x, iv->len ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200844 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200845#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100846 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, ad->x, ad->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200847#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200848
Azim Khand30ca132017-06-09 04:32:58 +0100849 /* decode buffer and check tag->x */
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200850 total_len = 0;
Azim Khand30ca132017-06-09 04:32:58 +0100851 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, cipher->x, cipher->len, output, &outlen ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200852 total_len += outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200853 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200854 &outlen ) );
855 total_len += outlen;
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200856#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100857 TEST_ASSERT( tag_result == mbedtls_cipher_check_tag( &ctx, tag->x, tag->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200858#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200859
860 /* check plaintext only if everything went fine */
861 if( 0 == finish_result && 0 == tag_result )
862 {
Azim Khand30ca132017-06-09 04:32:58 +0100863 TEST_ASSERT( total_len == clear->len );
864 TEST_ASSERT( 0 == memcmp( output, clear->x, clear->len ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200865 }
866
Paul Bakkerbd51b262014-07-10 15:26:12 +0200867exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200868 mbedtls_cipher_free( &ctx );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200869}
870/* END_CASE */
871
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200872/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_AEAD */
Azim Khan5fcca462018-06-29 11:05:32 +0100873void auth_crypt_tv( int cipher_id, data_t * key, data_t * iv,
874 data_t * ad, data_t * cipher, data_t * tag,
875 char * result, data_t * clear )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200876{
877 int ret;
Manuel Pégourié-Gonnard69767d12018-05-09 12:25:18 +0200878 unsigned char output[267]; /* above + 2 (overwrite check) */
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200879 unsigned char my_tag[20];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200880 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200881 size_t outlen;
882
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200883 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200884
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200885 memset( output, 0xFF, sizeof( output ) );
Azim Khan46c9b1f2017-05-31 20:46:35 +0100886 memset( my_tag, 0xFF, sizeof( my_tag ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200887
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200888
889 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200890 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200891 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100892 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200893
Azim Khand30ca132017-06-09 04:32:58 +0100894 /* decode buffer and check tag->x */
895 ret = mbedtls_cipher_auth_decrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
896 cipher->x, cipher->len, output, &outlen,
897 tag->x, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200898
899 /* make sure we didn't overwrite */
900 TEST_ASSERT( output[outlen + 0] == 0xFF );
901 TEST_ASSERT( output[outlen + 1] == 0xFF );
902
903 /* make sure the message is rejected if it should be */
Azim Khan46c9b1f2017-05-31 20:46:35 +0100904 if( strcmp( result, "FAIL" ) == 0 )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200905 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200906 TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
Paul Bakkerbd51b262014-07-10 15:26:12 +0200907 goto exit;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200908 }
909
910 /* otherwise, make sure it was decrypted properly */
911 TEST_ASSERT( ret == 0 );
912
Azim Khand30ca132017-06-09 04:32:58 +0100913 TEST_ASSERT( outlen == clear->len );
914 TEST_ASSERT( memcmp( output, clear->x, clear->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200915
Azim Khand30ca132017-06-09 04:32:58 +0100916 /* 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 +0200917 memset( output, 0xFF, sizeof( output ) );
918 outlen = 0;
919
Azim Khand30ca132017-06-09 04:32:58 +0100920 ret = mbedtls_cipher_auth_encrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
921 clear->x, clear->len, output, &outlen,
922 my_tag, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200923 TEST_ASSERT( ret == 0 );
924
Azim Khand30ca132017-06-09 04:32:58 +0100925 TEST_ASSERT( outlen == clear->len );
926 TEST_ASSERT( memcmp( output, cipher->x, clear->len ) == 0 );
927 TEST_ASSERT( memcmp( my_tag, tag->x, tag->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200928
929 /* make sure we didn't overwrite */
930 TEST_ASSERT( output[outlen + 0] == 0xFF );
931 TEST_ASSERT( output[outlen + 1] == 0xFF );
Azim Khand30ca132017-06-09 04:32:58 +0100932 TEST_ASSERT( my_tag[tag->len + 0] == 0xFF );
933 TEST_ASSERT( my_tag[tag->len + 1] == 0xFF );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200934
935
Paul Bakkerbd51b262014-07-10 15:26:12 +0200936exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200937 mbedtls_cipher_free( &ctx );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200938}
939/* END_CASE */
940
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200941/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100942void test_vec_ecb( int cipher_id, int operation, data_t * key,
943 data_t * input, data_t * result, int finish_result
Azim Khand30ca132017-06-09 04:32:58 +0100944 )
Paul Bakker5e0efa72013-09-08 23:04:04 +0200945{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200946 mbedtls_cipher_context_t ctx;
Paul Bakker5e0efa72013-09-08 23:04:04 +0200947 unsigned char output[32];
948 size_t outlen;
949
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200950 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200951
Paul Bakker5e0efa72013-09-08 23:04:04 +0200952 memset( output, 0x00, sizeof( output ) );
953
954 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200955 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200956 mbedtls_cipher_info_from_type( cipher_id ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200957
Paul Bakker5e0efa72013-09-08 23:04:04 +0200958
Azim Khand30ca132017-06-09 04:32:58 +0100959 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200960
Azim Khand30ca132017-06-09 04:32:58 +0100961 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, input->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200962 mbedtls_cipher_get_block_size( &ctx ),
Paul Bakker5e0efa72013-09-08 23:04:04 +0200963 output, &outlen ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200964 TEST_ASSERT( outlen == mbedtls_cipher_get_block_size( &ctx ) );
965 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Paul Bakker5e0efa72013-09-08 23:04:04 +0200966 &outlen ) );
967 TEST_ASSERT( 0 == outlen );
968
969 /* check plaintext only if everything went fine */
970 if( 0 == finish_result )
Azim Khand30ca132017-06-09 04:32:58 +0100971 TEST_ASSERT( 0 == memcmp( output, result->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200972 mbedtls_cipher_get_block_size( &ctx ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200973
Paul Bakkerbd51b262014-07-10 15:26:12 +0200974exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200975 mbedtls_cipher_free( &ctx );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200976}
977/* END_CASE */
978
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200979/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Ron Eldor7b012442017-09-25 17:03:12 +0300980void test_vec_crypt( int cipher_id, int operation, char *hex_key,
981 char *hex_iv, char *hex_input, char *hex_result,
982 int finish_result )
983{
984 unsigned char key[50];
985 unsigned char input[16];
986 unsigned char result[16];
987 unsigned char iv[16];
988 size_t key_len, iv_len, inputlen, resultlen;
989 mbedtls_cipher_context_t ctx;
990 unsigned char output[32];
991 size_t outlen;
992
993 mbedtls_cipher_init( &ctx );
994
995 memset( key, 0x00, sizeof( key ) );
996 memset( input, 0x00, sizeof( input ) );
997 memset( result, 0x00, sizeof( result ) );
998 memset( output, 0x00, sizeof( output ) );
999 memset( iv, 0x00, sizeof( iv ) );
1000
1001 /* Prepare context */
1002 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
1003 mbedtls_cipher_info_from_type( cipher_id ) ) );
1004
1005 key_len = unhexify( key, hex_key );
1006 inputlen = unhexify( input, hex_input );
1007 resultlen = unhexify( result, hex_result );
1008
1009 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, 8 * key_len, operation ) );
1010 if( MBEDTLS_MODE_CBC == ctx.cipher_info->mode )
1011 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, MBEDTLS_PADDING_NONE ) );
1012
Ron Eldor4e64e0b2017-09-25 18:22:32 +03001013 iv_len = unhexify( iv, hex_iv );
Ron Eldor7b012442017-09-25 17:03:12 +03001014
1015 TEST_ASSERT( finish_result == mbedtls_cipher_crypt( &ctx, iv_len ? iv : NULL,
1016 iv_len, input, inputlen,
1017 output, &outlen ) );
1018 TEST_ASSERT( resultlen == outlen );
1019 /* check plaintext only if everything went fine */
1020 if( 0 == finish_result )
1021 TEST_ASSERT( 0 == memcmp( output, result, outlen ) );
1022
1023exit:
1024 mbedtls_cipher_free( &ctx );
1025}
1026/* END_CASE */
1027
1028/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Paul Bakker33b43f12013-08-20 11:48:36 +02001029void set_padding( int cipher_id, int pad_mode, int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001030{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001031 const mbedtls_cipher_info_t *cipher_info;
1032 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001033
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001034 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +02001035
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001036 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001037 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +02001038 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001039
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001040 TEST_ASSERT( ret == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001041
Paul Bakkerbd51b262014-07-10 15:26:12 +02001042exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001043 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001044}
Paul Bakker33b43f12013-08-20 11:48:36 +02001045/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +00001046
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001047/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
Azim Khan5fcca462018-06-29 11:05:32 +01001048void check_padding( int pad_mode, data_t * input, int ret, int dlen_check
Azim Khand30ca132017-06-09 04:32:58 +01001049 )
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001050{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001051 mbedtls_cipher_info_t cipher_info;
1052 mbedtls_cipher_context_t ctx;
Azim Khanf1aaec92017-05-30 14:23:15 +01001053 size_t dlen;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001054
1055 /* build a fake context just for getting access to get_padding */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001056 mbedtls_cipher_init( &ctx );
1057 cipher_info.mode = MBEDTLS_MODE_CBC;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001058 ctx.cipher_info = &cipher_info;
1059
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001060 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001061
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001062
Azim Khand30ca132017-06-09 04:32:58 +01001063 TEST_ASSERT( ret == ctx.get_padding( input->x, input->len, &dlen ) );
Paul Bakker33b43f12013-08-20 11:48:36 +02001064 if( 0 == ret )
1065 TEST_ASSERT( dlen == (size_t) dlen_check );
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001066}
Paul Bakker33b43f12013-08-20 11:48:36 +02001067/* END_CASE */