blob: 3d559a3c9f5bdad340faa1e8b2ef884892541308 [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;
28 const mbedtls_cipher_info_t *info = mbedtls_cipher_info_from_type( *( mbedtls_cipher_list() ) );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020029 unsigned char buf[1] = { 0 };
30 size_t olen;
31
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020032 mbedtls_cipher_init( &ctx );
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_block_size( NULL ) == 0 );
35 TEST_ASSERT( mbedtls_cipher_get_block_size( &ctx ) == 0 );
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_cipher_mode( NULL ) == MBEDTLS_MODE_NONE );
38 TEST_ASSERT( mbedtls_cipher_get_cipher_mode( &ctx ) == MBEDTLS_MODE_NONE );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020039
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020040 TEST_ASSERT( mbedtls_cipher_get_iv_size( NULL ) == 0 );
41 TEST_ASSERT( mbedtls_cipher_get_iv_size( &ctx ) == 0 );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020042
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020043 TEST_ASSERT( mbedtls_cipher_info_from_string( NULL ) == NULL );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020044
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +020045 TEST_ASSERT( mbedtls_cipher_setup( &ctx, NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020046 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +020047 TEST_ASSERT( mbedtls_cipher_setup( NULL, info )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020048 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020049
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020050 TEST_ASSERT( mbedtls_cipher_setkey( NULL, buf, 0, MBEDTLS_ENCRYPT )
51 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
52 TEST_ASSERT( mbedtls_cipher_setkey( &ctx, buf, 0, MBEDTLS_ENCRYPT )
53 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020054
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020055 TEST_ASSERT( mbedtls_cipher_set_iv( NULL, buf, 0 )
56 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
57 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, buf, 0 )
58 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020059
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020060 TEST_ASSERT( mbedtls_cipher_reset( NULL ) == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
61 TEST_ASSERT( mbedtls_cipher_reset( &ctx ) == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020062
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +020063#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020064 TEST_ASSERT( mbedtls_cipher_update_ad( NULL, buf, 0 )
65 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
66 TEST_ASSERT( mbedtls_cipher_update_ad( &ctx, buf, 0 )
67 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020068#endif
69
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020070 TEST_ASSERT( mbedtls_cipher_update( NULL, buf, 0, buf, &olen )
71 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
72 TEST_ASSERT( mbedtls_cipher_update( &ctx, buf, 0, buf, &olen )
73 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020074
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020075 TEST_ASSERT( mbedtls_cipher_finish( NULL, buf, &olen )
76 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
77 TEST_ASSERT( mbedtls_cipher_finish( &ctx, buf, &olen )
78 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020079
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +020080#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020081 TEST_ASSERT( mbedtls_cipher_write_tag( NULL, buf, olen )
82 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
83 TEST_ASSERT( mbedtls_cipher_write_tag( &ctx, buf, olen )
84 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020085
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020086 TEST_ASSERT( mbedtls_cipher_check_tag( NULL, buf, olen )
87 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
88 TEST_ASSERT( mbedtls_cipher_check_tag( &ctx, buf, olen )
89 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +020090#endif
91}
92/* END_CASE */
93
Krzysztof Stachowiake0215d72018-12-17 10:20:30 +010094/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
95void cipher_invalid_param( )
96{
97 mbedtls_cipher_context_t invalid_ctx;
98 mbedtls_cipher_context_t valid_ctx;
99
100 mbedtls_operation_t invalid_operation = 100;
101 mbedtls_cipher_padding_t valid_mode = MBEDTLS_PADDING_ZEROS;
102 unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
103 int valid_size = sizeof(valid_buffer);
104 int valid_bitlen = valid_size * 8;
105 size_t size_t_var;
106
107 /* mbedtls_cipher_init() */
108 TEST_VALID_PARAM( mbedtls_cipher_init( &invalid_ctx ) );
109 TEST_VALID_PARAM( mbedtls_cipher_init( &valid_ctx ) );
110
111 TEST_INVALID_PARAM( mbedtls_cipher_init( NULL ) );
112
113 /* mbedtls_cipher_setkey() */
114 TEST_INVALID_PARAM_RET(
115 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
116 mbedtls_cipher_setkey( &valid_ctx,
117 valid_buffer,
118 valid_bitlen,
119 invalid_operation ) );
120
121 /* mbedtls_cipher_set_padding_mode() */
122 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
123 mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
124 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
125 mbedtls_cipher_set_padding_mode( &invalid_ctx,
126 valid_mode ) );
127
128 /* mbedtls_cipher_update() */
129 TEST_INVALID_PARAM_RET(
130 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
131 mbedtls_cipher_update( &valid_ctx,
132 NULL, valid_size,
133 valid_buffer,
134 &size_t_var ) );
135 TEST_INVALID_PARAM_RET(
136 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
137 mbedtls_cipher_update( &valid_ctx,
138 valid_buffer, valid_size,
139 NULL,
140 &size_t_var ) );
141 TEST_INVALID_PARAM_RET(
142 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
143 mbedtls_cipher_update( &valid_ctx,
144 valid_buffer, valid_size,
145 valid_buffer,
146 NULL ) );
147
148 /* mbedtls_cipher_finish() */
149 TEST_INVALID_PARAM_RET(
150 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
151 mbedtls_cipher_finish( &valid_ctx,
152 NULL,
153 &size_t_var ) );
154 TEST_INVALID_PARAM_RET(
155 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
156 mbedtls_cipher_finish( &valid_ctx,
157 valid_buffer,
158 NULL ) );
159
160 /* mbedtls_cipher_write_tag() */
161 TEST_INVALID_PARAM_RET(
162 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
163 mbedtls_cipher_write_tag( &valid_ctx,
164 NULL,
165 valid_size ) );
166
167 /* mbedtls_cipher_check_tag() */
168 TEST_INVALID_PARAM_RET(
169 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
170 mbedtls_cipher_check_tag( &valid_ctx,
171 NULL,
172 valid_size ) );
173
174 /* mbedtls_cipher_crypt() */
175 TEST_INVALID_PARAM_RET(
176 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
177 mbedtls_cipher_crypt( NULL,
178 valid_buffer, valid_size,
179 valid_buffer, valid_size,
180 valid_buffer, &size_t_var ) );
181 TEST_INVALID_PARAM_RET(
182 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
183 mbedtls_cipher_crypt( &invalid_ctx,
184 valid_buffer, valid_size,
185 valid_buffer, valid_size,
186 valid_buffer, &size_t_var ) );
187 TEST_INVALID_PARAM_RET(
188 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
189 mbedtls_cipher_crypt( &valid_ctx,
190 NULL, valid_size,
191 valid_buffer, valid_size,
192 valid_buffer, &size_t_var ) );
193 TEST_INVALID_PARAM_RET(
194 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
195 mbedtls_cipher_crypt( &valid_ctx,
196 valid_buffer, valid_size,
197 NULL, valid_size,
198 valid_buffer, &size_t_var ) );
199 TEST_INVALID_PARAM_RET(
200 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
201 mbedtls_cipher_crypt( &valid_ctx,
202 valid_buffer, valid_size,
203 valid_buffer, valid_size,
204 NULL, &size_t_var ) );
205 TEST_INVALID_PARAM_RET(
206 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
207 mbedtls_cipher_crypt( &valid_ctx,
208 valid_buffer, valid_size,
209 valid_buffer, valid_size,
210 valid_buffer, NULL ) );
211
212 /* mbedtls_cipher_auth_encrypt() */
213 TEST_INVALID_PARAM_RET(
214 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
215 mbedtls_cipher_auth_encrypt( NULL,
216 valid_buffer, valid_size,
217 valid_buffer, valid_size,
218 valid_buffer, valid_size,
219 valid_buffer, &size_t_var,
220 valid_buffer, valid_size ) );
221 TEST_INVALID_PARAM_RET(
222 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
223 mbedtls_cipher_auth_encrypt( &invalid_ctx,
224 valid_buffer, valid_size,
225 valid_buffer, valid_size,
226 valid_buffer, valid_size,
227 valid_buffer, &size_t_var,
228 valid_buffer, valid_size ) );
229 TEST_INVALID_PARAM_RET(
230 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
231 mbedtls_cipher_auth_encrypt( &valid_ctx,
232 NULL, valid_size,
233 valid_buffer, valid_size,
234 valid_buffer, valid_size,
235 valid_buffer, &size_t_var,
236 valid_buffer, valid_size ) );
237 TEST_INVALID_PARAM_RET(
238 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
239 mbedtls_cipher_auth_encrypt( &valid_ctx,
240 valid_buffer, valid_size,
241 NULL, valid_size,
242 valid_buffer, valid_size,
243 valid_buffer, &size_t_var,
244 valid_buffer, valid_size ) );
245 TEST_INVALID_PARAM_RET(
246 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
247 mbedtls_cipher_auth_encrypt( &valid_ctx,
248 valid_buffer, valid_size,
249 valid_buffer, valid_size,
250 NULL, valid_size,
251 valid_buffer, &size_t_var,
252 valid_buffer, valid_size ) );
253 TEST_INVALID_PARAM_RET(
254 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
255 mbedtls_cipher_auth_encrypt( &valid_ctx,
256 valid_buffer, valid_size,
257 valid_buffer, valid_size,
258 valid_buffer, valid_size,
259 NULL, &size_t_var,
260 valid_buffer, valid_size ) );
261 TEST_INVALID_PARAM_RET(
262 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
263 mbedtls_cipher_auth_encrypt( &valid_ctx,
264 valid_buffer, valid_size,
265 valid_buffer, valid_size,
266 valid_buffer, valid_size,
267 valid_buffer, NULL,
268 valid_buffer, valid_size ) );
269 TEST_INVALID_PARAM_RET(
270 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
271 mbedtls_cipher_auth_encrypt( &valid_ctx,
272 valid_buffer, valid_size,
273 valid_buffer, valid_size,
274 valid_buffer, valid_size,
275 valid_buffer, &size_t_var,
276 NULL, valid_size ) );
277
278 /* mbedtls_cipher_auth_decrypt() */
279 TEST_INVALID_PARAM_RET(
280 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
281 mbedtls_cipher_auth_decrypt( NULL,
282 valid_buffer, valid_size,
283 valid_buffer, valid_size,
284 valid_buffer, valid_size,
285 valid_buffer, &size_t_var,
286 valid_buffer, valid_size ) );
287 TEST_INVALID_PARAM_RET(
288 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
289 mbedtls_cipher_auth_decrypt( &invalid_ctx,
290 valid_buffer, valid_size,
291 valid_buffer, valid_size,
292 valid_buffer, valid_size,
293 valid_buffer, &size_t_var,
294 valid_buffer, valid_size ) );
295 TEST_INVALID_PARAM_RET(
296 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
297 mbedtls_cipher_auth_decrypt( &valid_ctx,
298 NULL, valid_size,
299 valid_buffer, valid_size,
300 valid_buffer, valid_size,
301 valid_buffer, &size_t_var,
302 valid_buffer, valid_size ) );
303 TEST_INVALID_PARAM_RET(
304 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
305 mbedtls_cipher_auth_decrypt( &valid_ctx,
306 valid_buffer, valid_size,
307 NULL, valid_size,
308 valid_buffer, valid_size,
309 valid_buffer, &size_t_var,
310 valid_buffer, valid_size ) );
311 TEST_INVALID_PARAM_RET(
312 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
313 mbedtls_cipher_auth_decrypt( &valid_ctx,
314 valid_buffer, valid_size,
315 valid_buffer, valid_size,
316 NULL, valid_size,
317 valid_buffer, &size_t_var,
318 valid_buffer, valid_size ) );
319 TEST_INVALID_PARAM_RET(
320 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
321 mbedtls_cipher_auth_decrypt( &valid_ctx,
322 valid_buffer, valid_size,
323 valid_buffer, valid_size,
324 valid_buffer, valid_size,
325 NULL, &size_t_var,
326 valid_buffer, valid_size ) );
327 TEST_INVALID_PARAM_RET(
328 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
329 mbedtls_cipher_auth_decrypt( &valid_ctx,
330 valid_buffer, valid_size,
331 valid_buffer, valid_size,
332 valid_buffer, valid_size,
333 valid_buffer, NULL,
334 valid_buffer, valid_size ) );
335 TEST_INVALID_PARAM_RET(
336 MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
337 mbedtls_cipher_auth_decrypt( &valid_ctx,
338 valid_buffer, valid_size,
339 valid_buffer, valid_size,
340 valid_buffer, valid_size,
341 valid_buffer, &size_t_var,
342 NULL, valid_size ) );
343
344 /* mbedtls_cipher_free() */
345 TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
346exit:
347 TEST_VALID_PARAM( mbedtls_cipher_free( &invalid_ctx ) );
348 TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
349}
350/* END_CASE */
351
Paul Bakker6a9c7252016-07-14 13:46:10 +0100352/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
Azim Khanf1aaec92017-05-30 14:23:15 +0100353void cipher_special_behaviours( )
Paul Bakker6a9c7252016-07-14 13:46:10 +0100354{
355 const mbedtls_cipher_info_t *cipher_info;
356 mbedtls_cipher_context_t ctx;
357 unsigned char input[32];
358 unsigned char output[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300359#if defined (MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100360 unsigned char iv[32];
Ron Eldor6f90ed82017-09-26 12:08:54 +0300361#endif
Paul Bakker6a9c7252016-07-14 13:46:10 +0100362 size_t olen = 0;
363
364 mbedtls_cipher_init( &ctx );
365 memset( input, 0, sizeof( input ) );
366 memset( output, 0, sizeof( output ) );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300367#if defined(MBEDTLS_CIPHER_MODE_CBC)
Paul Bakker6a9c7252016-07-14 13:46:10 +0100368 memset( iv, 0, sizeof( iv ) );
369
370 /* Check and get info structures */
Ron Eldor7b012442017-09-25 17:03:12 +0300371 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker6a9c7252016-07-14 13:46:10 +0100372 TEST_ASSERT( NULL != cipher_info );
373
374 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
375
376 /* IV too big */
377 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1 )
378 == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
379
380 /* IV too small */
381 TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, 0 )
382 == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
383
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300384 mbedtls_cipher_free( &ctx );
Ron Eldorbb4bbbb2017-10-01 17:04:54 +0300385 mbedtls_cipher_init( &ctx );
Ron Eldor6f90ed82017-09-26 12:08:54 +0300386#endif /* MBEDTLS_CIPHER_MODE_CBC */
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300387 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
Ron Eldor7b012442017-09-25 17:03:12 +0300388 TEST_ASSERT( NULL != cipher_info );
389
390 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
391
Paul Bakker6a9c7252016-07-14 13:46:10 +0100392 /* Update ECB with partial block */
393 TEST_ASSERT( mbedtls_cipher_update( &ctx, input, 1, output, &olen )
394 == MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
395
396exit:
397 mbedtls_cipher_free( &ctx );
398}
399/* END_CASE */
400
Manuel Pégourié-Gonnard5e7693f2014-06-13 16:08:07 +0200401/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100402void enc_dec_buf( int cipher_id, char * cipher_string, int key_len,
Paul Bakker33b43f12013-08-20 11:48:36 +0200403 int length_val, int pad_mode )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200404{
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200405 size_t length = length_val, outlen, total_len, i, block_size;
Jaeden Amerod906b812018-06-08 11:03:16 +0100406 unsigned char key[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000407 unsigned char iv[16];
Manuel Pégourié-Gonnard9241be72013-08-31 17:31:03 +0200408 unsigned char ad[13];
409 unsigned char tag[16];
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200410 unsigned char inbuf[64];
411 unsigned char encbuf[64];
412 unsigned char decbuf[64];
Paul Bakker8123e9d2011-01-06 15:37:30 +0000413
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200414 const mbedtls_cipher_info_t *cipher_info;
415 mbedtls_cipher_context_t ctx_dec;
416 mbedtls_cipher_context_t ctx_enc;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000417
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200418 /*
419 * Prepare contexts
420 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200421 mbedtls_cipher_init( &ctx_dec );
422 mbedtls_cipher_init( &ctx_enc );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200423
424 memset( key, 0x2a, sizeof( key ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000425
426 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200427 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000428 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200429 TEST_ASSERT( mbedtls_cipher_info_from_string( cipher_string ) == cipher_info );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000430
431 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200432 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
433 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200434
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200435 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
436 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000437
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200438#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Paul Bakker33b43f12013-08-20 11:48:36 +0200439 if( -1 != pad_mode )
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200440 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200441 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
442 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200443 }
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200444#else
445 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200446#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Manuel Pégourié-Gonnard6c978992013-07-26 13:20:42 +0200447
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200448 /*
449 * Do a few encode/decode cycles
450 */
451 for( i = 0; i < 3; i++ )
452 {
453 memset( iv , 0x00 + i, sizeof( iv ) );
454 memset( ad, 0x10 + i, sizeof( ad ) );
455 memset( inbuf, 0x20 + i, sizeof( inbuf ) );
456
457 memset( encbuf, 0, sizeof( encbuf ) );
458 memset( decbuf, 0, sizeof( decbuf ) );
459 memset( tag, 0, sizeof( tag ) );
460
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200461 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, sizeof( iv ) ) );
462 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, sizeof( iv ) ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200463
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200464 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
465 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200466
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200467#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200468 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, ad, sizeof( ad ) - i ) );
469 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, ad, sizeof( ad ) - i ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200470#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000471
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200472 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
473 TEST_ASSERT( block_size != 0 );
474
Paul Bakker8123e9d2011-01-06 15:37:30 +0000475 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200476 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, length, encbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200477 total_len = outlen;
478
479 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200480 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200481 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200482 total_len + block_size > length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000483
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200484 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200485 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000486
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200487#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200488 TEST_ASSERT( 0 == mbedtls_cipher_write_tag( &ctx_enc, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200489#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200490
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200491 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200492 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200493 total_len > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200494 total_len <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000495
496 /* decode the previously encoded string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200497 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, total_len, decbuf, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200498 total_len = outlen;
499
500 TEST_ASSERT( total_len == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200501 ( total_len % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200502 total_len < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200503 total_len + block_size >= length ) );
Paul Bakker343a8702011-06-09 14:27:58 +0000504
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200505 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200506 total_len += outlen;
Paul Bakker343a8702011-06-09 14:27:58 +0000507
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200508#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200509 TEST_ASSERT( 0 == mbedtls_cipher_check_tag( &ctx_dec, tag, sizeof( tag ) ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200510#endif
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200511
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200512 /* check result */
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200513 TEST_ASSERT( total_len == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000514 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200515 }
Paul Bakker8123e9d2011-01-06 15:37:30 +0000516
Manuel Pégourié-Gonnard1af50a22013-09-05 10:30:32 +0200517 /*
518 * Done
519 */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200520exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200521 mbedtls_cipher_free( &ctx_dec );
522 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200523}
Paul Bakker33b43f12013-08-20 11:48:36 +0200524/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000525
Paul Bakker33b43f12013-08-20 11:48:36 +0200526/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100527void enc_fail( int cipher_id, int pad_mode, int key_len, int length_val,
528 int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200529{
Paul Bakker33b43f12013-08-20 11:48:36 +0200530 size_t length = length_val;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200531 unsigned char key[32];
532 unsigned char iv[16];
533
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200534 const mbedtls_cipher_info_t *cipher_info;
535 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200536
537 unsigned char inbuf[64];
538 unsigned char encbuf[64];
539
540 size_t outlen = 0;
541
542 memset( key, 0, 32 );
543 memset( iv , 0, 16 );
544
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200545 mbedtls_cipher_init( &ctx );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200546
547 memset( inbuf, 5, 64 );
548 memset( encbuf, 0, 64 );
549
550 /* Check and get info structures */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200551 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200552 TEST_ASSERT( NULL != cipher_info );
553
554 /* Initialise context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200555 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200556 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, key_len, MBEDTLS_ENCRYPT ) );
557#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
558 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200559#else
560 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200561#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
562 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv, 16 ) );
563 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200564#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200565 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200566#endif
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200567
568 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200569 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, inbuf, length, encbuf, &outlen ) );
570 TEST_ASSERT( ret == mbedtls_cipher_finish( &ctx, encbuf + outlen, &outlen ) );
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200571
572 /* done */
Paul Bakkerbd51b262014-07-10 15:26:12 +0200573exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200574 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200575}
Paul Bakker33b43f12013-08-20 11:48:36 +0200576/* END_CASE */
Manuel Pégourié-Gonnardebdc4132013-07-26 16:50:44 +0200577
Paul Bakker33b43f12013-08-20 11:48:36 +0200578/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100579void dec_empty_buf( )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200580{
Paul Bakker8123e9d2011-01-06 15:37:30 +0000581 unsigned char key[32];
582 unsigned char iv[16];
583
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200584 mbedtls_cipher_context_t ctx_dec;
585 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000586
587 unsigned char encbuf[64];
588 unsigned char decbuf[64];
589
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000590 size_t outlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000591
592 memset( key, 0, 32 );
593 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200594
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200595 mbedtls_cipher_init( &ctx_dec );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200596
Paul Bakker8123e9d2011-01-06 15:37:30 +0000597 memset( encbuf, 0, 64 );
598 memset( decbuf, 0, 64 );
599
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200600 /* Initialise context */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200601 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000602 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200603
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200604 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000605
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200606 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, 128, MBEDTLS_DECRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000607
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200608 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200609
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200610 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200611
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200612#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200613 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200614#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000615
616 /* decode 0-byte string */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200617 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, 0, decbuf, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000618 TEST_ASSERT( 0 == outlen );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200619 TEST_ASSERT( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED == mbedtls_cipher_finish(
Manuel Pégourié-Gonnardaa9ffc52013-09-03 16:19:22 +0200620 &ctx_dec, decbuf + outlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000621 TEST_ASSERT( 0 == outlen );
622
Paul Bakkerbd51b262014-07-10 15:26:12 +0200623exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200624 mbedtls_cipher_free( &ctx_dec );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200625}
Paul Bakker33b43f12013-08-20 11:48:36 +0200626/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000627
Paul Bakker33b43f12013-08-20 11:48:36 +0200628/* BEGIN_CASE */
629void enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700630 int second_length_val, int pad_mode,
631 int first_encrypt_output_len, int second_encrypt_output_len,
632 int first_decrypt_output_len, int second_decrypt_output_len )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200633{
Paul Bakker33b43f12013-08-20 11:48:36 +0200634 size_t first_length = first_length_val;
635 size_t second_length = second_length_val;
Paul Bakker23986e52011-04-24 08:57:21 +0000636 size_t length = first_length + second_length;
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200637 size_t block_size;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000638 unsigned char key[32];
639 unsigned char iv[16];
640
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200641 mbedtls_cipher_context_t ctx_dec;
642 mbedtls_cipher_context_t ctx_enc;
643 const mbedtls_cipher_info_t *cipher_info;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000644
645 unsigned char inbuf[64];
646 unsigned char encbuf[64];
647 unsigned char decbuf[64];
648
Paul Bakker23986e52011-04-24 08:57:21 +0000649 size_t outlen = 0;
650 size_t totaloutlen = 0;
Paul Bakker8123e9d2011-01-06 15:37:30 +0000651
652 memset( key, 0, 32 );
653 memset( iv , 0, 16 );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200654
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200655 mbedtls_cipher_init( &ctx_dec );
656 mbedtls_cipher_init( &ctx_enc );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200657
Paul Bakker8123e9d2011-01-06 15:37:30 +0000658 memset( inbuf, 5, 64 );
659 memset( encbuf, 0, 64 );
660 memset( decbuf, 0, 64 );
661
662 /* Initialise enc and dec contexts */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200663 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000664 TEST_ASSERT( NULL != cipher_info);
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200665
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200666 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
667 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200668
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200669 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
670 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000671
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700672#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
673 if( -1 != pad_mode )
674 {
675 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
676 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
677 }
678#else
679 (void) pad_mode;
680#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
681
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200682 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, 16 ) );
683 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, 16 ) );
Manuel Pégourié-Gonnard9c853b92013-09-03 13:04:44 +0200684
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200685 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
686 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
Manuel Pégourié-Gonnard2adc40c2013-09-03 13:54:12 +0200687
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200688#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200689 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
690 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, NULL, 0 ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200691#endif
Paul Bakker8123e9d2011-01-06 15:37:30 +0000692
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200693 block_size = mbedtls_cipher_get_block_size( &ctx_enc );
694 TEST_ASSERT( block_size != 0 );
695
Paul Bakker8123e9d2011-01-06 15:37:30 +0000696 /* encode length number of bytes from inbuf */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200697 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, first_length, encbuf, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700698 TEST_ASSERT( (size_t)first_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000699 totaloutlen = outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200700 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf + first_length, second_length, encbuf + totaloutlen, &outlen ) );
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700701 TEST_ASSERT( (size_t)second_encrypt_output_len == outlen );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000702 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200703 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200704 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200705 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200706 totaloutlen + block_size > length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200707
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200708 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + totaloutlen, &outlen ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000709 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200710 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200711 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200712 totaloutlen > length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200713 totaloutlen <= length + block_size ) );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000714
715 /* decode the previously encoded string */
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700716 second_length = totaloutlen - first_length;
717 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, first_length, decbuf, &outlen ) );
718 TEST_ASSERT( (size_t)first_decrypt_output_len == outlen );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200719 totaloutlen = outlen;
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700720 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf + first_length, second_length, decbuf + totaloutlen, &outlen ) );
721 TEST_ASSERT( (size_t)second_decrypt_output_len == outlen );
722 totaloutlen += outlen;
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200723
724 TEST_ASSERT( totaloutlen == length ||
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200725 ( totaloutlen % block_size == 0 &&
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200726 totaloutlen < length &&
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200727 totaloutlen + block_size >= length ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200728
Jethro Beekman6c563fa2018-03-27 19:16:17 -0700729 TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + totaloutlen, &outlen ) );
Manuel Pégourié-Gonnard725680f2013-07-25 15:26:54 +0200730 totaloutlen += outlen;
731
732 TEST_ASSERT( totaloutlen == length );
Paul Bakker8123e9d2011-01-06 15:37:30 +0000733
734 TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
735
Paul Bakkerbd51b262014-07-10 15:26:12 +0200736exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200737 mbedtls_cipher_free( &ctx_dec );
738 mbedtls_cipher_free( &ctx_enc );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200739}
Paul Bakker33b43f12013-08-20 11:48:36 +0200740/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000741
Paul Bakker33b43f12013-08-20 11:48:36 +0200742/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100743void decrypt_test_vec( int cipher_id, int pad_mode, data_t * key,
744 data_t * iv, data_t * cipher,
745 data_t * clear, data_t * ad, data_t * tag,
Azim Khand30ca132017-06-09 04:32:58 +0100746 int finish_result, int tag_result )
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200747{
Manuel Pégourié-Gonnard234e1ce2018-05-10 12:54:32 +0200748 unsigned char output[265];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200749 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200750 size_t outlen, total_len;
751
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200752 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200753
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200754 memset( output, 0x00, sizeof( output ) );
755
Azim Khanf1aaec92017-05-30 14:23:15 +0100756#if !defined(MBEDTLS_GCM_C) && !defined(MBEDTLS_CHACHAPOLY_C)
Mohammad Azim Khancf32c452017-06-13 14:55:58 +0100757 ((void) ad);
758 ((void) tag);
Manuel Pégourié-Gonnarda7496f02013-09-20 11:29:59 +0200759#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200760
761 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200762 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200763 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100764 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200765#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200766 if( pad_mode != -1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200767 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnard989ed382013-09-13 14:41:45 +0200768#else
769 (void) pad_mode;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200770#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
Azim Khand30ca132017-06-09 04:32:58 +0100771 TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv->x, iv->len ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200772 TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200773#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100774 TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, ad->x, ad->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200775#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200776
Azim Khand30ca132017-06-09 04:32:58 +0100777 /* decode buffer and check tag->x */
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200778 total_len = 0;
Azim Khand30ca132017-06-09 04:32:58 +0100779 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, cipher->x, cipher->len, output, &outlen ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200780 total_len += outlen;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200781 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200782 &outlen ) );
783 total_len += outlen;
Manuel Pégourié-Gonnarddca3a5d2018-05-07 10:43:27 +0200784#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
Azim Khand30ca132017-06-09 04:32:58 +0100785 TEST_ASSERT( tag_result == mbedtls_cipher_check_tag( &ctx, tag->x, tag->len ) );
Manuel Pégourié-Gonnard8f625632014-06-24 15:26:28 +0200786#endif
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200787
788 /* check plaintext only if everything went fine */
789 if( 0 == finish_result && 0 == tag_result )
790 {
Azim Khand30ca132017-06-09 04:32:58 +0100791 TEST_ASSERT( total_len == clear->len );
792 TEST_ASSERT( 0 == memcmp( output, clear->x, clear->len ) );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200793 }
794
Paul Bakkerbd51b262014-07-10 15:26:12 +0200795exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200796 mbedtls_cipher_free( &ctx );
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200797}
798/* END_CASE */
799
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200800/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_AEAD */
Azim Khan5fcca462018-06-29 11:05:32 +0100801void auth_crypt_tv( int cipher_id, data_t * key, data_t * iv,
802 data_t * ad, data_t * cipher, data_t * tag,
803 char * result, data_t * clear )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200804{
805 int ret;
Manuel Pégourié-Gonnard69767d12018-05-09 12:25:18 +0200806 unsigned char output[267]; /* above + 2 (overwrite check) */
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200807 unsigned char my_tag[20];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200808 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200809 size_t outlen;
810
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200811 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200812
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200813 memset( output, 0xFF, sizeof( output ) );
Azim Khan46c9b1f2017-05-31 20:46:35 +0100814 memset( my_tag, 0xFF, sizeof( my_tag ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200815
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200816
817 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200818 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200819 mbedtls_cipher_info_from_type( cipher_id ) ) );
Azim Khand30ca132017-06-09 04:32:58 +0100820 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200821
Azim Khand30ca132017-06-09 04:32:58 +0100822 /* decode buffer and check tag->x */
823 ret = mbedtls_cipher_auth_decrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
824 cipher->x, cipher->len, output, &outlen,
825 tag->x, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200826
827 /* make sure we didn't overwrite */
828 TEST_ASSERT( output[outlen + 0] == 0xFF );
829 TEST_ASSERT( output[outlen + 1] == 0xFF );
830
831 /* make sure the message is rejected if it should be */
Azim Khan46c9b1f2017-05-31 20:46:35 +0100832 if( strcmp( result, "FAIL" ) == 0 )
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200833 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200834 TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
Paul Bakkerbd51b262014-07-10 15:26:12 +0200835 goto exit;
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200836 }
837
838 /* otherwise, make sure it was decrypted properly */
839 TEST_ASSERT( ret == 0 );
840
Azim Khand30ca132017-06-09 04:32:58 +0100841 TEST_ASSERT( outlen == clear->len );
842 TEST_ASSERT( memcmp( output, clear->x, clear->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200843
Azim Khand30ca132017-06-09 04:32:58 +0100844 /* 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 +0200845 memset( output, 0xFF, sizeof( output ) );
846 outlen = 0;
847
Azim Khand30ca132017-06-09 04:32:58 +0100848 ret = mbedtls_cipher_auth_encrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
849 clear->x, clear->len, output, &outlen,
850 my_tag, tag->len );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200851 TEST_ASSERT( ret == 0 );
852
Azim Khand30ca132017-06-09 04:32:58 +0100853 TEST_ASSERT( outlen == clear->len );
854 TEST_ASSERT( memcmp( output, cipher->x, clear->len ) == 0 );
855 TEST_ASSERT( memcmp( my_tag, tag->x, tag->len ) == 0 );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +0200856
857 /* make sure we didn't overwrite */
858 TEST_ASSERT( output[outlen + 0] == 0xFF );
859 TEST_ASSERT( output[outlen + 1] == 0xFF );
Azim Khand30ca132017-06-09 04:32:58 +0100860 TEST_ASSERT( my_tag[tag->len + 0] == 0xFF );
861 TEST_ASSERT( my_tag[tag->len + 1] == 0xFF );
Manuel Pégourié-Gonnard542eac52014-05-15 16:03:07 +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é-Gonnard542eac52014-05-15 16:03:07 +0200866}
867/* END_CASE */
868
Manuel Pégourié-Gonnard8eccab52013-09-03 18:31:25 +0200869/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100870void test_vec_ecb( int cipher_id, int operation, data_t * key,
871 data_t * input, data_t * result, int finish_result
Azim Khand30ca132017-06-09 04:32:58 +0100872 )
Paul Bakker5e0efa72013-09-08 23:04:04 +0200873{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200874 mbedtls_cipher_context_t ctx;
Paul Bakker5e0efa72013-09-08 23:04:04 +0200875 unsigned char output[32];
876 size_t outlen;
877
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200878 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200879
Paul Bakker5e0efa72013-09-08 23:04:04 +0200880 memset( output, 0x00, sizeof( output ) );
881
882 /* Prepare context */
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200883 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200884 mbedtls_cipher_info_from_type( cipher_id ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200885
Paul Bakker5e0efa72013-09-08 23:04:04 +0200886
Azim Khand30ca132017-06-09 04:32:58 +0100887 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200888
Azim Khand30ca132017-06-09 04:32:58 +0100889 TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, input->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200890 mbedtls_cipher_get_block_size( &ctx ),
Paul Bakker5e0efa72013-09-08 23:04:04 +0200891 output, &outlen ) );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200892 TEST_ASSERT( outlen == mbedtls_cipher_get_block_size( &ctx ) );
893 TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
Paul Bakker5e0efa72013-09-08 23:04:04 +0200894 &outlen ) );
895 TEST_ASSERT( 0 == outlen );
896
897 /* check plaintext only if everything went fine */
898 if( 0 == finish_result )
Azim Khand30ca132017-06-09 04:32:58 +0100899 TEST_ASSERT( 0 == memcmp( output, result->x,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200900 mbedtls_cipher_get_block_size( &ctx ) ) );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200901
Paul Bakkerbd51b262014-07-10 15:26:12 +0200902exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200903 mbedtls_cipher_free( &ctx );
Paul Bakker5e0efa72013-09-08 23:04:04 +0200904}
905/* END_CASE */
906
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200907/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Ron Eldor7b012442017-09-25 17:03:12 +0300908void test_vec_crypt( int cipher_id, int operation, char *hex_key,
909 char *hex_iv, char *hex_input, char *hex_result,
910 int finish_result )
911{
912 unsigned char key[50];
913 unsigned char input[16];
914 unsigned char result[16];
915 unsigned char iv[16];
916 size_t key_len, iv_len, inputlen, resultlen;
917 mbedtls_cipher_context_t ctx;
918 unsigned char output[32];
919 size_t outlen;
920
921 mbedtls_cipher_init( &ctx );
922
923 memset( key, 0x00, sizeof( key ) );
924 memset( input, 0x00, sizeof( input ) );
925 memset( result, 0x00, sizeof( result ) );
926 memset( output, 0x00, sizeof( output ) );
927 memset( iv, 0x00, sizeof( iv ) );
928
929 /* Prepare context */
930 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
931 mbedtls_cipher_info_from_type( cipher_id ) ) );
932
933 key_len = unhexify( key, hex_key );
934 inputlen = unhexify( input, hex_input );
935 resultlen = unhexify( result, hex_result );
936
937 TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, 8 * key_len, operation ) );
938 if( MBEDTLS_MODE_CBC == ctx.cipher_info->mode )
939 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, MBEDTLS_PADDING_NONE ) );
940
Ron Eldor4e64e0b2017-09-25 18:22:32 +0300941 iv_len = unhexify( iv, hex_iv );
Ron Eldor7b012442017-09-25 17:03:12 +0300942
943 TEST_ASSERT( finish_result == mbedtls_cipher_crypt( &ctx, iv_len ? iv : NULL,
944 iv_len, input, inputlen,
945 output, &outlen ) );
946 TEST_ASSERT( resultlen == outlen );
947 /* check plaintext only if everything went fine */
948 if( 0 == finish_result )
949 TEST_ASSERT( 0 == memcmp( output, result, outlen ) );
950
951exit:
952 mbedtls_cipher_free( &ctx );
953}
954/* END_CASE */
955
956/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
Paul Bakker33b43f12013-08-20 11:48:36 +0200957void set_padding( int cipher_id, int pad_mode, int ret )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200958{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200959 const mbedtls_cipher_info_t *cipher_info;
960 mbedtls_cipher_context_t ctx;
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +0200961
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200962 mbedtls_cipher_init( &ctx );
Paul Bakkerd2a2d612014-07-01 15:45:49 +0200963
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200964 cipher_info = mbedtls_cipher_info_from_type( cipher_id );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +0200965 TEST_ASSERT( NULL != cipher_info );
Manuel Pégourié-Gonnard8473f872015-05-14 13:51:45 +0200966 TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +0200967
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200968 TEST_ASSERT( ret == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnardd5fdcaf2013-07-24 18:05:00 +0200969
Paul Bakkerbd51b262014-07-10 15:26:12 +0200970exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200971 mbedtls_cipher_free( &ctx );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200972}
Paul Bakker33b43f12013-08-20 11:48:36 +0200973/* END_CASE */
Paul Bakker8123e9d2011-01-06 15:37:30 +0000974
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200975/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
Azim Khan5fcca462018-06-29 11:05:32 +0100976void check_padding( int pad_mode, data_t * input, int ret, int dlen_check
Azim Khand30ca132017-06-09 04:32:58 +0100977 )
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200978{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200979 mbedtls_cipher_info_t cipher_info;
980 mbedtls_cipher_context_t ctx;
Azim Khanf1aaec92017-05-30 14:23:15 +0100981 size_t dlen;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +0200982
983 /* build a fake context just for getting access to get_padding */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200984 mbedtls_cipher_init( &ctx );
985 cipher_info.mode = MBEDTLS_MODE_CBC;
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +0200986 ctx.cipher_info = &cipher_info;
987
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200988 TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +0200989
Manuel Pégourié-Gonnarda6408492013-07-26 10:55:02 +0200990
Azim Khand30ca132017-06-09 04:32:58 +0100991 TEST_ASSERT( ret == ctx.get_padding( input->x, input->len, &dlen ) );
Paul Bakker33b43f12013-08-20 11:48:36 +0200992 if( 0 == ret )
993 TEST_ASSERT( dlen == (size_t) dlen_check );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200994}
Paul Bakker33b43f12013-08-20 11:48:36 +0200995/* END_CASE */