blob: 6073421a9bf944d4438635865d03b324c41c0f3d [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 ) );
k-stachowiak95070a82018-12-19 14:48:37 +010051 TEST_ASSERT( mbedtls_cipher_setup( &valid_ctx, NULL ) ==
52 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +010053
k-stachowiak90b8d4a2018-12-18 16:12:34 +010054 /* mbedtls_cipher_get_block_size() */
55 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_block_size( NULL ) );
k-stachowiak95070a82018-12-19 14:48:37 +010056 TEST_ASSERT( mbedtls_cipher_get_block_size( &invalid_ctx ) == 0 );
k-stachowiak90b8d4a2018-12-18 16:12:34 +010057
58 /* mbedtls_cipher_get_cipher_mode() */
59 TEST_INVALID_PARAM_RET(
60 MBEDTLS_MODE_NONE,
61 mbedtls_cipher_get_cipher_mode( NULL ) );
k-stachowiak95070a82018-12-19 14:48:37 +010062 TEST_ASSERT( mbedtls_cipher_get_cipher_mode( &invalid_ctx ) ==
63 MBEDTLS_MODE_NONE );
k-stachowiak90b8d4a2018-12-18 16:12:34 +010064
65 /* mbedtls_cipher_get_iv_size() */
66 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_iv_size( NULL ) );
k-stachowiak95070a82018-12-19 14:48:37 +010067 TEST_ASSERT( mbedtls_cipher_get_iv_size( &invalid_ctx ) == 0 );
k-stachowiak90b8d4a2018-12-18 16:12:34 +010068
69 /* mbedtls_cipher_get_type() */
70 TEST_INVALID_PARAM_RET(
71 MBEDTLS_CIPHER_NONE,
72 mbedtls_cipher_get_type( NULL ) );
k-stachowiak95070a82018-12-19 14:48:37 +010073 TEST_ASSERT(
74 mbedtls_cipher_get_type( &invalid_ctx ) ==
75 MBEDTLS_CIPHER_NONE);
k-stachowiak90b8d4a2018-12-18 16:12:34 +010076
77 /* mbedtls_cipher_get_name() */
78 TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_name( NULL ) );
k-stachowiak95070a82018-12-19 14:48:37 +010079 TEST_ASSERT( mbedtls_cipher_get_name( &invalid_ctx ) == 0 );
k-stachowiak90b8d4a2018-12-18 16:12:34 +010080
81 /* mbedtls_cipher_get_key_bitlen() */
82 TEST_INVALID_PARAM_RET(
83 MBEDTLS_KEY_LENGTH_NONE,
84 mbedtls_cipher_get_key_bitlen( NULL ) );
k-stachowiak95070a82018-12-19 14:48:37 +010085 TEST_ASSERT( mbedtls_cipher_get_key_bitlen( &invalid_ctx ) ==
86 MBEDTLS_KEY_LENGTH_NONE );
k-stachowiak90b8d4a2018-12-18 16:12:34 +010087
88 /* mbedtls_cipher_get_operation() */
89 TEST_INVALID_PARAM_RET(
90 MBEDTLS_OPERATION_NONE,
91 mbedtls_cipher_get_operation( NULL ) );
k-stachowiak95070a82018-12-19 14:48:37 +010092 TEST_ASSERT( mbedtls_cipher_get_operation( &invalid_ctx ) ==
93 MBEDTLS_OPERATION_NONE );
k-stachowiak90b8d4a2018-12-18 16:12:34 +010094
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010095 /* mbedtls_cipher_setkey() */
96 TEST_INVALID_PARAM_RET(
97 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +010098 mbedtls_cipher_setkey( NULL,
99 valid_buffer,
100 valid_bitlen,
101 valid_operation ) );
k-stachowiak95070a82018-12-19 14:48:37 +0100102 TEST_ASSERT(
k-stachowiaka5390702018-12-17 11:27:03 +0100103 mbedtls_cipher_setkey( &invalid_ctx,
104 valid_buffer,
105 valid_bitlen,
k-stachowiak95070a82018-12-19 14:48:37 +0100106 valid_operation ) ==
107 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +0100108 TEST_INVALID_PARAM_RET(
109 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
110 mbedtls_cipher_setkey( &valid_ctx,
111 NULL,
112 valid_bitlen,
113 valid_operation ) );
114 TEST_INVALID_PARAM_RET(
115 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100116 mbedtls_cipher_setkey( &valid_ctx,
117 valid_buffer,
118 valid_bitlen,
119 invalid_operation ) );
120
k-stachowiaka5390702018-12-17 11:27:03 +0100121 /* mbedtls_cipher_set_iv() */
122 TEST_INVALID_PARAM_RET(
123 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
124 mbedtls_cipher_set_iv( NULL,
125 valid_buffer,
126 valid_size ) );
k-stachowiak95070a82018-12-19 14:48:37 +0100127 TEST_ASSERT(
k-stachowiaka5390702018-12-17 11:27:03 +0100128 mbedtls_cipher_set_iv( &invalid_ctx,
129 valid_buffer,
k-stachowiak95070a82018-12-19 14:48:37 +0100130 valid_size ) ==
131 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +0100132 TEST_INVALID_PARAM_RET(
133 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
134 mbedtls_cipher_set_iv( &valid_ctx,
135 NULL,
136 valid_size ) );
137
138 /* mbedtls_cipher_reset() */
139 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
140 mbedtls_cipher_reset( NULL ) );
k-stachowiak95070a82018-12-19 14:48:37 +0100141 TEST_ASSERT( mbedtls_cipher_reset( &invalid_ctx ) ==
142 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +0100143
144#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
145 /* mbedtls_cipher_update_ad() */
146 TEST_INVALID_PARAM_RET(
147 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
148 mbedtls_cipher_update_ad( NULL,
149 valid_buffer,
150 valid_size ) );
k-stachowiak95070a82018-12-19 14:48:37 +0100151 TEST_ASSERT(
k-stachowiaka5390702018-12-17 11:27:03 +0100152 mbedtls_cipher_update_ad( &invalid_ctx,
153 valid_buffer,
k-stachowiak95070a82018-12-19 14:48:37 +0100154 valid_size ) ==
155 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +0100156 TEST_INVALID_PARAM_RET(
157 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
158 mbedtls_cipher_update_ad( &valid_ctx,
159 NULL,
160 valid_size ) );
161#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
162
163#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100164 /* mbedtls_cipher_set_padding_mode() */
165 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
166 mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
k-stachowiak95070a82018-12-19 14:48:37 +0100167 TEST_ASSERT( mbedtls_cipher_set_padding_mode( &invalid_ctx, valid_mode ) ==
168 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +0100169#endif
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100170
171 /* mbedtls_cipher_update() */
172 TEST_INVALID_PARAM_RET(
173 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100174 mbedtls_cipher_update( NULL,
175 valid_buffer,
176 valid_size,
177 valid_buffer,
178 &size_t_var ) );
k-stachowiak95070a82018-12-19 14:48:37 +0100179 TEST_ASSERT(
k-stachowiaka5390702018-12-17 11:27:03 +0100180 mbedtls_cipher_update( &invalid_ctx,
181 valid_buffer,
182 valid_size,
183 valid_buffer,
k-stachowiak95070a82018-12-19 14:48:37 +0100184 &size_t_var ) ==
185 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +0100186 TEST_INVALID_PARAM_RET(
187 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100188 mbedtls_cipher_update( &valid_ctx,
189 NULL, valid_size,
190 valid_buffer,
191 &size_t_var ) );
192 TEST_INVALID_PARAM_RET(
193 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
194 mbedtls_cipher_update( &valid_ctx,
195 valid_buffer, valid_size,
196 NULL,
197 &size_t_var ) );
198 TEST_INVALID_PARAM_RET(
199 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
200 mbedtls_cipher_update( &valid_ctx,
201 valid_buffer, valid_size,
202 valid_buffer,
203 NULL ) );
204
205 /* mbedtls_cipher_finish() */
206 TEST_INVALID_PARAM_RET(
207 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100208 mbedtls_cipher_finish( NULL,
209 valid_buffer,
210 &size_t_var ) );
k-stachowiak95070a82018-12-19 14:48:37 +0100211 TEST_ASSERT(
k-stachowiaka5390702018-12-17 11:27:03 +0100212 mbedtls_cipher_finish( &invalid_ctx,
213 valid_buffer,
k-stachowiak95070a82018-12-19 14:48:37 +0100214 &size_t_var ) ==
215 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +0100216 TEST_INVALID_PARAM_RET(
217 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100218 mbedtls_cipher_finish( &valid_ctx,
219 NULL,
220 &size_t_var ) );
221 TEST_INVALID_PARAM_RET(
222 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
223 mbedtls_cipher_finish( &valid_ctx,
224 valid_buffer,
225 NULL ) );
226
k-stachowiaka5390702018-12-17 11:27:03 +0100227#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100228 /* mbedtls_cipher_write_tag() */
229 TEST_INVALID_PARAM_RET(
230 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100231 mbedtls_cipher_write_tag( NULL,
232 valid_buffer,
233 valid_size ) );
k-stachowiak95070a82018-12-19 14:48:37 +0100234 TEST_ASSERT(
k-stachowiaka5390702018-12-17 11:27:03 +0100235 mbedtls_cipher_write_tag( &invalid_ctx,
236 valid_buffer,
k-stachowiak95070a82018-12-19 14:48:37 +0100237 valid_size ) ==
238 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +0100239 TEST_INVALID_PARAM_RET(
240 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100241 mbedtls_cipher_write_tag( &valid_ctx,
242 NULL,
243 valid_size ) );
244
245 /* mbedtls_cipher_check_tag() */
246 TEST_INVALID_PARAM_RET(
247 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
k-stachowiaka5390702018-12-17 11:27:03 +0100248 mbedtls_cipher_check_tag( NULL,
249 valid_buffer,
250 valid_size ) );
k-stachowiak95070a82018-12-19 14:48:37 +0100251 TEST_ASSERT(
k-stachowiaka5390702018-12-17 11:27:03 +0100252 mbedtls_cipher_check_tag( &invalid_ctx,
253 valid_buffer,
k-stachowiak95070a82018-12-19 14:48:37 +0100254 valid_size ) ==
255 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
k-stachowiaka5390702018-12-17 11:27:03 +0100256 TEST_INVALID_PARAM_RET(
257 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100258 mbedtls_cipher_check_tag( &valid_ctx,
259 NULL,
260 valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100261#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100262
263 /* mbedtls_cipher_crypt() */
264 TEST_INVALID_PARAM_RET(
265 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
266 mbedtls_cipher_crypt( NULL,
267 valid_buffer, valid_size,
268 valid_buffer, valid_size,
269 valid_buffer, &size_t_var ) );
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100270 TEST_INVALID_PARAM_RET(
271 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
272 mbedtls_cipher_crypt( &valid_ctx,
273 NULL, valid_size,
274 valid_buffer, valid_size,
275 valid_buffer, &size_t_var ) );
276 TEST_INVALID_PARAM_RET(
277 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
278 mbedtls_cipher_crypt( &valid_ctx,
279 valid_buffer, valid_size,
280 NULL, valid_size,
281 valid_buffer, &size_t_var ) );
282 TEST_INVALID_PARAM_RET(
283 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
284 mbedtls_cipher_crypt( &valid_ctx,
285 valid_buffer, valid_size,
286 valid_buffer, valid_size,
287 NULL, &size_t_var ) );
288 TEST_INVALID_PARAM_RET(
289 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
290 mbedtls_cipher_crypt( &valid_ctx,
291 valid_buffer, valid_size,
292 valid_buffer, valid_size,
293 valid_buffer, NULL ) );
294
k-stachowiaka5390702018-12-17 11:27:03 +0100295#if defined(MBEDTLS_CIPHER_MODE_AEAD)
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100296 /* mbedtls_cipher_auth_encrypt() */
297 TEST_INVALID_PARAM_RET(
298 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
299 mbedtls_cipher_auth_encrypt( NULL,
300 valid_buffer, valid_size,
301 valid_buffer, valid_size,
302 valid_buffer, valid_size,
303 valid_buffer, &size_t_var,
304 valid_buffer, valid_size ) );
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100305 TEST_INVALID_PARAM_RET(
306 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
307 mbedtls_cipher_auth_encrypt( &valid_ctx,
308 NULL, valid_size,
309 valid_buffer, valid_size,
310 valid_buffer, valid_size,
311 valid_buffer, &size_t_var,
312 valid_buffer, valid_size ) );
313 TEST_INVALID_PARAM_RET(
314 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
315 mbedtls_cipher_auth_encrypt( &valid_ctx,
316 valid_buffer, valid_size,
317 NULL, valid_size,
318 valid_buffer, valid_size,
319 valid_buffer, &size_t_var,
320 valid_buffer, valid_size ) );
321 TEST_INVALID_PARAM_RET(
322 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
323 mbedtls_cipher_auth_encrypt( &valid_ctx,
324 valid_buffer, valid_size,
325 valid_buffer, valid_size,
326 NULL, valid_size,
327 valid_buffer, &size_t_var,
328 valid_buffer, valid_size ) );
329 TEST_INVALID_PARAM_RET(
330 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
331 mbedtls_cipher_auth_encrypt( &valid_ctx,
332 valid_buffer, valid_size,
333 valid_buffer, valid_size,
334 valid_buffer, valid_size,
335 NULL, &size_t_var,
336 valid_buffer, valid_size ) );
337 TEST_INVALID_PARAM_RET(
338 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
339 mbedtls_cipher_auth_encrypt( &valid_ctx,
340 valid_buffer, valid_size,
341 valid_buffer, valid_size,
342 valid_buffer, valid_size,
343 valid_buffer, NULL,
344 valid_buffer, valid_size ) );
345 TEST_INVALID_PARAM_RET(
346 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
347 mbedtls_cipher_auth_encrypt( &valid_ctx,
348 valid_buffer, valid_size,
349 valid_buffer, valid_size,
350 valid_buffer, valid_size,
351 valid_buffer, &size_t_var,
352 NULL, valid_size ) );
353
354 /* mbedtls_cipher_auth_decrypt() */
355 TEST_INVALID_PARAM_RET(
356 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
357 mbedtls_cipher_auth_decrypt( NULL,
358 valid_buffer, valid_size,
359 valid_buffer, valid_size,
360 valid_buffer, valid_size,
361 valid_buffer, &size_t_var,
362 valid_buffer, valid_size ) );
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100363 TEST_INVALID_PARAM_RET(
364 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
365 mbedtls_cipher_auth_decrypt( &valid_ctx,
366 NULL, valid_size,
367 valid_buffer, valid_size,
368 valid_buffer, valid_size,
369 valid_buffer, &size_t_var,
370 valid_buffer, valid_size ) );
371 TEST_INVALID_PARAM_RET(
372 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
373 mbedtls_cipher_auth_decrypt( &valid_ctx,
374 valid_buffer, valid_size,
375 NULL, valid_size,
376 valid_buffer, valid_size,
377 valid_buffer, &size_t_var,
378 valid_buffer, valid_size ) );
379 TEST_INVALID_PARAM_RET(
380 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
381 mbedtls_cipher_auth_decrypt( &valid_ctx,
382 valid_buffer, valid_size,
383 valid_buffer, valid_size,
384 NULL, valid_size,
385 valid_buffer, &size_t_var,
386 valid_buffer, valid_size ) );
387 TEST_INVALID_PARAM_RET(
388 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
389 mbedtls_cipher_auth_decrypt( &valid_ctx,
390 valid_buffer, valid_size,
391 valid_buffer, valid_size,
392 valid_buffer, valid_size,
393 NULL, &size_t_var,
394 valid_buffer, valid_size ) );
395 TEST_INVALID_PARAM_RET(
396 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
397 mbedtls_cipher_auth_decrypt( &valid_ctx,
398 valid_buffer, valid_size,
399 valid_buffer, valid_size,
400 valid_buffer, valid_size,
401 valid_buffer, NULL,
402 valid_buffer, valid_size ) );
403 TEST_INVALID_PARAM_RET(
404 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
405 mbedtls_cipher_auth_decrypt( &valid_ctx,
406 valid_buffer, valid_size,
407 valid_buffer, valid_size,
408 valid_buffer, valid_size,
409 valid_buffer, &size_t_var,
410 NULL, valid_size ) );
k-stachowiaka5390702018-12-17 11:27:03 +0100411#endif /* defined(MBEDTLS_CIPHER_MODE_AEAD) */
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +0100412
413 /* mbedtls_cipher_free() */
414 TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
415exit:
416 TEST_VALID_PARAM( mbedtls_cipher_free( &invalid_ctx ) );
417 TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
418}
419/* END_CASE */
420
Paul Bakker6a9c7252016-07-14 13:46:10 +0100421/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
Azim Khanf1aaec92017-05-30 14:23:15 +0100422void cipher_special_behaviours( )
Paul Bakker6a9c7252016-07-14 13:46:10 +0100423{
424 const mbedtls_cipher_info_t *cipher_info;
425 mbedtls_cipher_context_t ctx;
426 unsigned char input[32];
427 unsigned char output[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300428#if defined (MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100429 unsigned char iv[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300430#endif
Paul Bakker6a9c7252016-07-14 13:46:10 +0100431 size_t olen = 0;
432
433 mbedtls_cipher_init( &ctx );
434 memset( input, 0, sizeof( input ) );
435 memset( output, 0, sizeof( output ) );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300436#if defined(MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100437 memset( iv, 0, sizeof( iv ) );
438
439 /* Check and get info structures */
Ron Eldor7b012442017-09-25 17:03:12 +0300440 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker6a9c7252016-07-14 13:46:10 +0100441 TEST_ASSERT( NULL != cipher_info );
442
443 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
444
445 /* IV too big */
446 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1 )
447 == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
448
449 /* IV too small */
450 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, 0 )
451 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
452
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300453 mbedtls_cipher_free( &ctx );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300454 mbedtls_cipher_init( &ctx );
Ron Eldor6f90ed82017-09-26 12:08:54 +0300455#endif /* MBEDTLS_CIPHER_MODE_CBC */
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300456 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
Ron Eldor7b012442017-09-25 17:03:12 +0300457 TEST_ASSERT( NULL != cipher_info );
458
459 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
460
Paul Bakker6a9c7252016-07-14 13:46:10 +0100461 /* Update ECB with partial block */
462 TEST_ASSERT( mbedtls_cipher_update( &ctx, input, 1, output, &olen )
463 == MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
464
465exit:
466 mbedtls_cipher_free( &ctx );
467}
468/* END_CASE */
469
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +0200470/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100471void enc_dec_buf( int cipher_id, char * cipher_string, int key_len,
Paul Bakker33b43f12013-08-20 11:48:36 +0200472 int length_val, int pad_mode )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200473{
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200474 size_t length = length_val, outlen, total_len, i, block_size;
Jaeden Amerod906b812018-06-08 11:03:16 +0100475 unsigned char key[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000476 unsigned char iv[16];
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200477 unsigned char ad[13];
478 unsigned char tag[16];
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200479 unsigned char inbuf[64];
480 unsigned char encbuf[64];
481 unsigned char decbuf[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000482
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200483 const mbedtls_cipher_info_t *cipher_info;
484 mbedtls_cipher_context_t ctx_dec;
485 mbedtls_cipher_context_t ctx_enc;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000486
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200487 /*
488 * Prepare contexts
489 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200490 mbedtls_cipher_init( &ctx_dec );
491 mbedtls_cipher_init( &ctx_enc );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200492
493 memset( key, 0x2a, sizeof( key ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000494
495 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200496 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000497 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200498 TEST_ASSERT( mbedtls_cipher_info_from_string( cipher_string ) == cipher_info );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000499
500 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200501 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
502 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200503
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200504 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
505 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000506
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200507#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Paul Bakker33b43f12013-08-20 11:48:36 +0200508 if( -1 != pad_mode )
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200509 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200510 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
511 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200512 }
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200513#else
514 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200515#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200516
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200517 /*
518 * Do a few encode/decode cycles
519 */
520 for( i = 0; i < 3; i++ )
521 {
522 memset( iv , 0x00 + i, sizeof( iv ) );
523 memset( ad, 0x10 + i, sizeof( ad ) );
524 memset( inbuf, 0x20 + i, sizeof( inbuf ) );
525
526 memset( encbuf, 0, sizeof( encbuf ) );
527 memset( decbuf, 0, sizeof( decbuf ) );
528 memset( tag, 0, sizeof( tag ) );
529
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200530 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, sizeof( iv ) ) );
531 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, sizeof( iv ) ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200532
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200533 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
534 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200535
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200536#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200537 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, ad, sizeof( ad ) - i ) );
538 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, ad, sizeof( ad ) - i ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200539#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000540
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200541 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
542 TEST_ASSERT( block_size != 0 );
543
Paul Bakker8123e9d2011-01-06 15:37:30 +0000544 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200545 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, length, encbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200546 total_len = outlen;
547
548 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200549 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200550 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200551 total_len + block_size > length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000552
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200553 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200554 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000555
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200556#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200557 TEST_ASSERT( 0 == mbedtls_cipher_write_tag( &ctx_enc, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200558#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200559
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200560 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200561 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200562 total_len > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200563 total_len <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000564
565 /* decode the previously encoded string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200566 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, total_len, decbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200567 total_len = outlen;
568
569 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200570 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200571 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200572 total_len + block_size >= length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000573
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200574 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200575 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000576
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200577#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200578 TEST_ASSERT( 0 == mbedtls_cipher_check_tag( &ctx_dec, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200579#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200580
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200581 /* check result */
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200582 TEST_ASSERT( total_len == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000583 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200584 }
Paul Bakker8123e9d2011-01-06 15:37:30 +0000585
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200586 /*
587 * Done
588 */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200589exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200590 mbedtls_cipher_free( &ctx_dec );
591 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200592}
Paul Bakker33b43f12013-08-20 11:48:36 +0200593/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000594
Paul Bakker33b43f12013-08-20 11:48:36 +0200595/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100596void enc_fail( int cipher_id, int pad_mode, int key_len, int length_val,
597 int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200598{
Paul Bakker33b43f12013-08-20 11:48:36 +0200599 size_t length = length_val;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200600 unsigned char key[32];
601 unsigned char iv[16];
602
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200603 const mbedtls_cipher_info_t *cipher_info;
604 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200605
606 unsigned char inbuf[64];
607 unsigned char encbuf[64];
608
609 size_t outlen = 0;
610
611 memset( key, 0, 32 );
612 memset( iv , 0, 16 );
613
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200614 mbedtls_cipher_init( &ctx );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200615
616 memset( inbuf, 5, 64 );
617 memset( encbuf, 0, 64 );
618
619 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200620 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200621 TEST_ASSERT( NULL != cipher_info );
622
623 /* Initialise context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200624 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200625 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, key_len, MBEDTLS_ENCRYPT ) );
626#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
627 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200628#else
629 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200630#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
631 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv, 16 ) );
632 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200633#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200634 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200635#endif
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200636
637 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200638 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, inbuf, length, encbuf, &outlen ) );
639 TEST_ASSERT( ret == mbedtls_cipher_finish( &ctx, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200640
641 /* done */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200642exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200643 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200644}
Paul Bakker33b43f12013-08-20 11:48:36 +0200645/* END_CASE */
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200646
Paul Bakker33b43f12013-08-20 11:48:36 +0200647/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100648void dec_empty_buf( )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200649{
Paul Bakker8123e9d2011-01-06 15:37:30 +0000650 unsigned char key[32];
651 unsigned char iv[16];
652
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200653 mbedtls_cipher_context_t ctx_dec;
654 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000655
656 unsigned char encbuf[64];
657 unsigned char decbuf[64];
658
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000659 size_t outlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000660
661 memset( key, 0, 32 );
662 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200663
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200664 mbedtls_cipher_init( &ctx_dec );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200665
Paul Bakker8123e9d2011-01-06 15:37:30 +0000666 memset( encbuf, 0, 64 );
667 memset( decbuf, 0, 64 );
668
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200669 /* Initialise context */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200670 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000671 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200672
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200673 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000674
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200675 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, 128, MBEDTLS_DECRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000676
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200677 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200678
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200679 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200680
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200681#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200682 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200683#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000684
685 /* decode 0-byte string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200686 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, 0, decbuf, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000687 TEST_ASSERT( 0 == outlen );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200688 TEST_ASSERT( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED == mbedtls_cipher_finish(
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200689 &ctx_dec, decbuf + outlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000690 TEST_ASSERT( 0 == outlen );
691
Paul Bakkerbd51b262014-07-10 15:26:12 +0200692exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200693 mbedtls_cipher_free( &ctx_dec );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200694}
Paul Bakker33b43f12013-08-20 11:48:36 +0200695/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000696
Paul Bakker33b43f12013-08-20 11:48:36 +0200697/* BEGIN_CASE */
698void enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700699 int second_length_val, int pad_mode,
700 int first_encrypt_output_len, int second_encrypt_output_len,
701 int first_decrypt_output_len, int second_decrypt_output_len )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200702{
Paul Bakker33b43f12013-08-20 11:48:36 +0200703 size_t first_length = first_length_val;
704 size_t second_length = second_length_val;
Paul Bakker23986e52011-04-24 08:57:21 +0000705 size_t length = first_length + second_length;
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200706 size_t block_size;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000707 unsigned char key[32];
708 unsigned char iv[16];
709
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200710 mbedtls_cipher_context_t ctx_dec;
711 mbedtls_cipher_context_t ctx_enc;
712 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000713
714 unsigned char inbuf[64];
715 unsigned char encbuf[64];
716 unsigned char decbuf[64];
717
Paul Bakker23986e52011-04-24 08:57:21 +0000718 size_t outlen = 0;
719 size_t totaloutlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000720
721 memset( key, 0, 32 );
722 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200723
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200724 mbedtls_cipher_init( &ctx_dec );
725 mbedtls_cipher_init( &ctx_enc );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200726
Paul Bakker8123e9d2011-01-06 15:37:30 +0000727 memset( inbuf, 5, 64 );
728 memset( encbuf, 0, 64 );
729 memset( decbuf, 0, 64 );
730
731 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200732 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000733 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200734
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200735 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
736 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200737
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200738 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
739 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000740
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700741#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
742 if( -1 != pad_mode )
743 {
744 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
745 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
746 }
747#else
748 (void) pad_mode;
749#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
750
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200751 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
752 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200753
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200754 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
755 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200756
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200757#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200758 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
759 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200760#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000761
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200762 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
763 TEST_ASSERT( block_size != 0 );
764
Paul Bakker8123e9d2011-01-06 15:37:30 +0000765 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200766 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, first_length, encbuf, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700767 TEST_ASSERT( (size_t)first_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000768 totaloutlen = outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200769 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf + first_length, second_length, encbuf + totaloutlen, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700770 TEST_ASSERT( (size_t)second_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000771 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200772 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200773 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200774 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200775 totaloutlen + block_size > length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200776
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200777 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + totaloutlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000778 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200779 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200780 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200781 totaloutlen > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200782 totaloutlen <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000783
784 /* decode the previously encoded string */
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700785 second_length = totaloutlen - first_length;
786 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, first_length, decbuf, &outlen ) );
787 TEST_ASSERT( (size_t)first_decrypt_output_len == outlen );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200788 totaloutlen = outlen;
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700789 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf + first_length, second_length, decbuf + totaloutlen, &outlen ) );
790 TEST_ASSERT( (size_t)second_decrypt_output_len == outlen );
791 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200792
793 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200794 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200795 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200796 totaloutlen + block_size >= length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200797
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700798 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + totaloutlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200799 totaloutlen += outlen;
800
801 TEST_ASSERT( totaloutlen == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000802
803 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
804
Paul Bakkerbd51b262014-07-10 15:26:12 +0200805exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200806 mbedtls_cipher_free( &ctx_dec );
807 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200808}
Paul Bakker33b43f12013-08-20 11:48:36 +0200809/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000810
Paul Bakker33b43f12013-08-20 11:48:36 +0200811/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100812void decrypt_test_vec( int cipher_id, int pad_mode, data_t * key,
813 data_t * iv, data_t * cipher,
814 data_t * clear, data_t * ad, data_t * tag,
Azim Khand30ca132017-06-09 04:32:58 +0100815 int finish_result, int tag_result )
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200816{
Manuel Pégourié-Gonnard234e1ce2018-05-10 12:54:32 +0200817 unsigned char output[265];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200818 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200819 size_t outlen, total_len;
820
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200821 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200822
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200823 memset( output, 0x00, sizeof( output ) );
824
Azim Khanf1aaec92017-05-30 14:23:15 +0100825#if !defined(MBEDTLS_GCM_C) && !defined(MBEDTLS_CHACHAPOLY_C)
Mohammad Azim Khancf32c452017-06-13 14:55:58 +0100826 ((void) ad);
827 ((void) tag);
Manuel Pégourié-Gonnarda7496f02013-09-20 11:29:59 +0200828#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200829
830 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200831 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200832 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100833 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200834#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200835 if( pad_mode != -1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200836 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200837#else
838 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200839#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Azim Khand30ca132017-06-09 04:32:58 +0100840 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv->x, iv->len ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200841 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200842#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100843 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, ad->x, ad->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200844#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200845
Azim Khand30ca132017-06-09 04:32:58 +0100846 /* decode buffer and check tag->x */
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200847 total_len = 0;
Azim Khand30ca132017-06-09 04:32:58 +0100848 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, cipher->x, cipher->len, output, &outlen ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200849 total_len += outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200850 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200851 &outlen ) );
852 total_len += outlen;
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200853#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100854 TEST_ASSERT( tag_result == mbedtls_cipher_check_tag( &ctx, tag->x, tag->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200855#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200856
857 /* check plaintext only if everything went fine */
858 if( 0 == finish_result && 0 == tag_result )
859 {
Azim Khand30ca132017-06-09 04:32:58 +0100860 TEST_ASSERT( total_len == clear->len );
861 TEST_ASSERT( 0 == memcmp( output, clear->x, clear->len ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200862 }
863
Paul Bakkerbd51b262014-07-10 15:26:12 +0200864exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200865 mbedtls_cipher_free( &ctx );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200866}
867/* END_CASE */
868
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200869/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_AEAD */
Azim Khan5fcca462018-06-29 11:05:32 +0100870void auth_crypt_tv( int cipher_id, data_t * key, data_t * iv,
871 data_t * ad, data_t * cipher, data_t * tag,
872 char * result, data_t * clear )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200873{
874 int ret;
Manuel Pégourié-Gonnard69767d12018-05-09 12:25:18 +0200875 unsigned char output[267]; /* above + 2 (overwrite check) */
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200876 unsigned char my_tag[20];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200877 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200878 size_t outlen;
879
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200880 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200881
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200882 memset( output, 0xFF, sizeof( output ) );
Azim Khan46c9b1f2017-05-31 20:46:35 +0100883 memset( my_tag, 0xFF, sizeof( my_tag ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200884
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200885
886 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200887 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200888 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100889 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200890
Azim Khand30ca132017-06-09 04:32:58 +0100891 /* decode buffer and check tag->x */
892 ret = mbedtls_cipher_auth_decrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
893 cipher->x, cipher->len, output, &outlen,
894 tag->x, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200895
896 /* make sure we didn't overwrite */
897 TEST_ASSERT( output[outlen + 0] == 0xFF );
898 TEST_ASSERT( output[outlen + 1] == 0xFF );
899
900 /* make sure the message is rejected if it should be */
Azim Khan46c9b1f2017-05-31 20:46:35 +0100901 if( strcmp( result, "FAIL" ) == 0 )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200902 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200903 TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
Paul Bakkerbd51b262014-07-10 15:26:12 +0200904 goto exit;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200905 }
906
907 /* otherwise, make sure it was decrypted properly */
908 TEST_ASSERT( ret == 0 );
909
Azim Khand30ca132017-06-09 04:32:58 +0100910 TEST_ASSERT( outlen == clear->len );
911 TEST_ASSERT( memcmp( output, clear->x, clear->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200912
Azim Khand30ca132017-06-09 04:32:58 +0100913 /* 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 +0200914 memset( output, 0xFF, sizeof( output ) );
915 outlen = 0;
916
Azim Khand30ca132017-06-09 04:32:58 +0100917 ret = mbedtls_cipher_auth_encrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
918 clear->x, clear->len, output, &outlen,
919 my_tag, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200920 TEST_ASSERT( ret == 0 );
921
Azim Khand30ca132017-06-09 04:32:58 +0100922 TEST_ASSERT( outlen == clear->len );
923 TEST_ASSERT( memcmp( output, cipher->x, clear->len ) == 0 );
924 TEST_ASSERT( memcmp( my_tag, tag->x, tag->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200925
926 /* make sure we didn't overwrite */
927 TEST_ASSERT( output[outlen + 0] == 0xFF );
928 TEST_ASSERT( output[outlen + 1] == 0xFF );
Azim Khand30ca132017-06-09 04:32:58 +0100929 TEST_ASSERT( my_tag[tag->len + 0] == 0xFF );
930 TEST_ASSERT( my_tag[tag->len + 1] == 0xFF );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200931
932
Paul Bakkerbd51b262014-07-10 15:26:12 +0200933exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200934 mbedtls_cipher_free( &ctx );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200935}
936/* END_CASE */
937
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200938/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100939void test_vec_ecb( int cipher_id, int operation, data_t * key,
940 data_t * input, data_t * result, int finish_result
Azim Khand30ca132017-06-09 04:32:58 +0100941 )
Paul Bakker5e0efa72013-09-08 23:04:04 +0200942{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200943 mbedtls_cipher_context_t ctx;
Paul Bakker5e0efa72013-09-08 23:04:04 +0200944 unsigned char output[32];
945 size_t outlen;
946
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200947 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200948
Paul Bakker5e0efa72013-09-08 23:04:04 +0200949 memset( output, 0x00, sizeof( output ) );
950
951 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200952 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200953 mbedtls_cipher_info_from_type( cipher_id ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200954
Paul Bakker5e0efa72013-09-08 23:04:04 +0200955
Azim Khand30ca132017-06-09 04:32:58 +0100956 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200957
Azim Khand30ca132017-06-09 04:32:58 +0100958 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, input->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200959 mbedtls_cipher_get_block_size( &ctx ),
Paul Bakker5e0efa72013-09-08 23:04:04 +0200960 output, &outlen ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200961 TEST_ASSERT( outlen == mbedtls_cipher_get_block_size( &ctx ) );
962 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Paul Bakker5e0efa72013-09-08 23:04:04 +0200963 &outlen ) );
964 TEST_ASSERT( 0 == outlen );
965
966 /* check plaintext only if everything went fine */
967 if( 0 == finish_result )
Azim Khand30ca132017-06-09 04:32:58 +0100968 TEST_ASSERT( 0 == memcmp( output, result->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200969 mbedtls_cipher_get_block_size( &ctx ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200970
Paul Bakkerbd51b262014-07-10 15:26:12 +0200971exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200972 mbedtls_cipher_free( &ctx );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200973}
974/* END_CASE */
975
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200976/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Ron Eldor7b012442017-09-25 17:03:12 +0300977void test_vec_crypt( int cipher_id, int operation, char *hex_key,
978 char *hex_iv, char *hex_input, char *hex_result,
979 int finish_result )
980{
981 unsigned char key[50];
982 unsigned char input[16];
983 unsigned char result[16];
984 unsigned char iv[16];
985 size_t key_len, iv_len, inputlen, resultlen;
986 mbedtls_cipher_context_t ctx;
987 unsigned char output[32];
988 size_t outlen;
989
990 mbedtls_cipher_init( &ctx );
991
992 memset( key, 0x00, sizeof( key ) );
993 memset( input, 0x00, sizeof( input ) );
994 memset( result, 0x00, sizeof( result ) );
995 memset( output, 0x00, sizeof( output ) );
996 memset( iv, 0x00, sizeof( iv ) );
997
998 /* Prepare context */
999 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
1000 mbedtls_cipher_info_from_type( cipher_id ) ) );
1001
1002 key_len = unhexify( key, hex_key );
1003 inputlen = unhexify( input, hex_input );
1004 resultlen = unhexify( result, hex_result );
1005
1006 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, 8 * key_len, operation ) );
1007 if( MBEDTLS_MODE_CBC == ctx.cipher_info->mode )
1008 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, MBEDTLS_PADDING_NONE ) );
1009
Ron Eldor4e64e0b2017-09-25 18:22:32 +03001010 iv_len = unhexify( iv, hex_iv );
Ron Eldor7b012442017-09-25 17:03:12 +03001011
1012 TEST_ASSERT( finish_result == mbedtls_cipher_crypt( &ctx, iv_len ? iv : NULL,
1013 iv_len, input, inputlen,
1014 output, &outlen ) );
1015 TEST_ASSERT( resultlen == outlen );
1016 /* check plaintext only if everything went fine */
1017 if( 0 == finish_result )
1018 TEST_ASSERT( 0 == memcmp( output, result, outlen ) );
1019
1020exit:
1021 mbedtls_cipher_free( &ctx );
1022}
1023/* END_CASE */
1024
1025/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Paul Bakker33b43f12013-08-20 11:48:36 +02001026void set_padding( int cipher_id, int pad_mode, int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001027{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001028 const mbedtls_cipher_info_t *cipher_info;
1029 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001030
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001031 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +02001032
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001033 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001034 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +02001035 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001036
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001037 TEST_ASSERT( ret == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +02001038
Paul Bakkerbd51b262014-07-10 15:26:12 +02001039exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001040 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001041}
Paul Bakker33b43f12013-08-20 11:48:36 +02001042/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +00001043
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001044/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
Azim Khan5fcca462018-06-29 11:05:32 +01001045void check_padding( int pad_mode, data_t * input, int ret, int dlen_check
Azim Khand30ca132017-06-09 04:32:58 +01001046 )
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001047{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001048 mbedtls_cipher_info_t cipher_info;
1049 mbedtls_cipher_context_t ctx;
Azim Khanf1aaec92017-05-30 14:23:15 +01001050 size_t dlen;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001051
1052 /* build a fake context just for getting access to get_padding */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001053 mbedtls_cipher_init( &ctx );
1054 cipher_info.mode = MBEDTLS_MODE_CBC;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001055 ctx.cipher_info = &cipher_info;
1056
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001057 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001058
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +02001059
Azim Khand30ca132017-06-09 04:32:58 +01001060 TEST_ASSERT( ret == ctx.get_padding( input->x, input->len, &dlen ) );
Paul Bakker33b43f12013-08-20 11:48:36 +02001061 if( 0 == ret )
1062 TEST_ASSERT( dlen == (size_t) dlen_check );
Paul Bakkerdbd443d2013-08-16 13:38:47 +02001063}
Paul Bakker33b43f12013-08-20 11:48:36 +02001064/* END_CASE */