blob: 1f5d7d61aaf4c8c2169a7dead66fb3773f86ff50 [file] [log] [blame]
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +02001/* BEGIN_HEADER */
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00002#include "mbedtls/pk.h"
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +02003
Manuel Pégourié-Gonnard7c13d692014-11-12 00:01:34 +01004/* For error codes */
Gilles Peskine998fbfb2018-12-19 17:08:51 +01005#include "mbedtls/asn1.h"
6#include "mbedtls/base64.h"
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00007#include "mbedtls/ecp.h"
8#include "mbedtls/rsa.h"
Manuel Pégourié-Gonnard7c13d692014-11-12 00:01:34 +01009
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +010010#include <limits.h>
Andres Amaya Garcia6ff067d2017-06-09 14:26:59 +010011#include <stdint.h>
Andres AG5c79d252017-02-15 10:52:32 +000012
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020013static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len );
14
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020015#define RSA_KEY_SIZE 512
16#define RSA_KEY_LEN 64
17
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020018static int pk_genkey( mbedtls_pk_context *pk )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020019{
Paul Bakkera5320902013-12-19 17:29:52 +010020 ((void) pk);
21
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020022#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
23 if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_RSA )
24 return mbedtls_rsa_gen_key( mbedtls_pk_rsa( *pk ), rnd_std_rand, NULL, RSA_KEY_SIZE, 3 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020025#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020026#if defined(MBEDTLS_ECP_C)
27 if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY ||
28 mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY_DH ||
29 mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECDSA )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020030 {
31 int ret;
Manuel Pégourié-Gonnarde3a062b2015-05-11 18:46:47 +020032 if( ( ret = mbedtls_ecp_group_load( &mbedtls_pk_ec( *pk )->grp,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020033 MBEDTLS_ECP_DP_SECP192R1 ) ) != 0 )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020034 return( ret );
35
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020036 return mbedtls_ecp_gen_keypair( &mbedtls_pk_ec( *pk )->grp, &mbedtls_pk_ec( *pk )->d,
37 &mbedtls_pk_ec( *pk )->Q, rnd_std_rand, NULL );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020038 }
39#endif
40 return( -1 );
41}
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020042
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020043#if defined(MBEDTLS_RSA_C)
44int mbedtls_rsa_decrypt_func( void *ctx, int mode, size_t *olen,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020045 const unsigned char *input, unsigned char *output,
46 size_t output_max_len )
47{
Hanno Becker6ac972d2017-09-07 10:57:48 +010048 return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx,
49 rnd_std_rand, NULL, mode, olen,
50 input, output, output_max_len ) );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020051}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020052int mbedtls_rsa_sign_func( void *ctx,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020053 int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020054 int mode, mbedtls_md_type_t md_alg, unsigned int hashlen,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020055 const unsigned char *hash, unsigned char *sig )
56{
Hanno Beckera5400682017-05-03 16:43:15 +010057 ((void) f_rng);
58 ((void) p_rng);
59 return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx, rnd_std_rand, NULL, mode,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020060 md_alg, hashlen, hash, sig ) );
61}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020062size_t mbedtls_rsa_key_len_func( void *ctx )
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020063{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020064 return( ((const mbedtls_rsa_context *) ctx)->len );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020065}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020066#endif /* MBEDTLS_RSA_C */
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020067/* END_HEADER */
68
69/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020070 * depends_on:MBEDTLS_PK_C
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020071 * END_DEPENDENCIES
72 */
73
74/* BEGIN_CASE */
Gilles Peskine78438e42018-12-19 00:55:07 +010075void valid_parameters( )
76{
77 mbedtls_pk_context pk;
Gilles Peskineee3cfec2018-12-19 17:10:02 +010078 unsigned char buf[1];
Gilles Peskine78438e42018-12-19 00:55:07 +010079 size_t len;
Gilles Peskineee3cfec2018-12-19 17:10:02 +010080 void *options = NULL;
Gilles Peskine78438e42018-12-19 00:55:07 +010081
82 mbedtls_pk_init( &pk );
83
Gilles Peskine1f19fa62018-12-19 14:18:39 +010084 TEST_VALID_PARAM( mbedtls_pk_free( NULL ) );
85
86#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
87 TEST_VALID_PARAM( mbedtls_pk_restart_free( NULL ) );
88#endif
89
Gilles Peskinee146e7d2018-12-19 13:20:21 +010090 TEST_ASSERT( mbedtls_pk_setup( &pk, NULL ) ==
91 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Gilles Peskine78438e42018-12-19 00:55:07 +010092
Gilles Peskinee146e7d2018-12-19 13:20:21 +010093 TEST_ASSERT( mbedtls_pk_get_bitlen( NULL ) == 0 );
Gilles Peskine78438e42018-12-19 00:55:07 +010094
Gilles Peskinee146e7d2018-12-19 13:20:21 +010095 TEST_ASSERT( mbedtls_pk_get_len( NULL ) == 0 );
Gilles Peskine78438e42018-12-19 00:55:07 +010096
Gilles Peskinee146e7d2018-12-19 13:20:21 +010097 TEST_ASSERT( mbedtls_pk_can_do( NULL, MBEDTLS_PK_NONE ) == 0 );
Gilles Peskine78438e42018-12-19 00:55:07 +010098
Gilles Peskineee3cfec2018-12-19 17:10:02 +010099 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
100 MBEDTLS_MD_NONE,
101 NULL, 0,
102 buf, &len,
103 rnd_std_rand, NULL,
104 NULL ) ==
105 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
106
107 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
108 MBEDTLS_MD_NONE,
109 NULL, 0,
110 buf, &len,
111 rnd_std_rand, NULL,
112 NULL ) ==
113 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
114
115 TEST_ASSERT( mbedtls_pk_sign( &pk,
116 MBEDTLS_MD_NONE,
117 NULL, 0,
118 buf, &len,
119 rnd_std_rand, NULL ) ==
120 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
121
122 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk,
123 MBEDTLS_MD_NONE,
124 NULL, 0,
125 buf, sizeof( buf ),
126 NULL ) ==
127 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
128
129 TEST_ASSERT( mbedtls_pk_verify( &pk,
130 MBEDTLS_MD_NONE,
131 NULL, 0,
132 buf, sizeof( buf ) ) ==
133 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
134
135 TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
136 &pk,
137 MBEDTLS_MD_NONE,
138 NULL, 0,
139 buf, sizeof( buf ) ) ==
140 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
141
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100142 TEST_ASSERT( mbedtls_pk_encrypt( &pk,
143 NULL, 0,
144 NULL, &len, 0,
145 rnd_std_rand, NULL ) ==
146 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Gilles Peskine78438e42018-12-19 00:55:07 +0100147
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100148 TEST_ASSERT( mbedtls_pk_decrypt( &pk,
149 NULL, 0,
150 NULL, &len, 0,
151 rnd_std_rand, NULL ) ==
152 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Gilles Peskine78438e42018-12-19 00:55:07 +0100153
154#if defined(MBEDTLS_PK_PARSE_C)
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100155 TEST_ASSERT( mbedtls_pk_parse_key( &pk, NULL, 0, NULL, 1 ) ==
156 MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
Gilles Peskine78438e42018-12-19 00:55:07 +0100157
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100158 TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, NULL, 0 ) ==
159 MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
Gilles Peskine78438e42018-12-19 00:55:07 +0100160#endif /* MBEDTLS_PK_PARSE_C */
Gilles Peskine998fbfb2018-12-19 17:08:51 +0100161}
162/* END_CASE */
Gilles Peskine78438e42018-12-19 00:55:07 +0100163
Gilles Peskine998fbfb2018-12-19 17:08:51 +0100164/* BEGIN_CASE depends_on:MBEDTLS_PK_WRITE_C */
165void valid_parameters_pkwrite( data_t *key_data )
166{
167 mbedtls_pk_context pk;
168
169 /* For the write tests to be effective, we need a valid key pair. */
170 mbedtls_pk_init( &pk );
171 TEST_ASSERT( mbedtls_pk_parse_key( &pk,
172 key_data->x, key_data->len,
173 NULL, 0 ) == 0 );
174
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100175 TEST_ASSERT( mbedtls_pk_write_key_der( &pk, NULL, 0 ) ==
Gilles Peskine998fbfb2018-12-19 17:08:51 +0100176 MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
Gilles Peskine78438e42018-12-19 00:55:07 +0100177
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100178 TEST_ASSERT( mbedtls_pk_write_pubkey_der( &pk, NULL, 0 ) ==
Gilles Peskine998fbfb2018-12-19 17:08:51 +0100179 MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
180
181#if defined(MBEDTLS_PEM_WRITE_C)
182 TEST_ASSERT( mbedtls_pk_write_key_pem( &pk, NULL, 0 ) ==
183 MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
184
185 TEST_ASSERT( mbedtls_pk_write_pubkey_pem( &pk, NULL, 0 ) ==
186 MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
187#endif /* MBEDTLS_PEM_WRITE_C */
188
189exit:
190 mbedtls_pk_free( &pk );
Gilles Peskine78438e42018-12-19 00:55:07 +0100191}
192/* END_CASE */
193
194/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
195void invalid_parameters( )
196{
197 size_t len;
198 unsigned char *null_buf = NULL;
199 unsigned char buf[1];
200 unsigned char *p = buf;
201 char str[1] = {0};
202 mbedtls_pk_context pk;
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100203 mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
Gilles Peskine78438e42018-12-19 00:55:07 +0100204 void *options = buf;
205
206 mbedtls_pk_init( &pk );
207
208 TEST_INVALID_PARAM( mbedtls_pk_init( NULL ) );
209
210#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
211 TEST_INVALID_PARAM( mbedtls_pk_restart_init( NULL ) );
Gilles Peskine78438e42018-12-19 00:55:07 +0100212#endif
213
214 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
215 mbedtls_pk_setup( NULL, NULL ) );
216
217#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
218 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
219 mbedtls_pk_setup_rsa_alt( NULL, buf,
220 NULL, NULL, NULL ) );
221#endif
222
223 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
224 mbedtls_pk_verify_restartable( NULL,
225 MBEDTLS_MD_NONE,
226 buf, sizeof( buf ),
227 buf, sizeof( buf ),
228 NULL ) );
229 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
230 mbedtls_pk_verify_restartable( &pk,
231 MBEDTLS_MD_NONE,
232 NULL, sizeof( buf ),
233 buf, sizeof( buf ),
234 NULL ) );
235 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
236 mbedtls_pk_verify_restartable( &pk,
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100237 valid_md,
238 NULL, 0,
239 buf, sizeof( buf ),
240 NULL ) );
241 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
242 mbedtls_pk_verify_restartable( &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100243 MBEDTLS_MD_NONE,
244 buf, sizeof( buf ),
245 NULL, sizeof( buf ),
246 NULL ) );
247
248 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
249 mbedtls_pk_verify( NULL,
250 MBEDTLS_MD_NONE,
251 buf, sizeof( buf ),
252 buf, sizeof( buf ) ) );
253 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
254 mbedtls_pk_verify( &pk,
255 MBEDTLS_MD_NONE,
256 NULL, sizeof( buf ),
257 buf, sizeof( buf ) ) );
258 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
259 mbedtls_pk_verify( &pk,
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100260 valid_md,
261 NULL, 0,
262 buf, sizeof( buf ) ) );
263 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
264 mbedtls_pk_verify( &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100265 MBEDTLS_MD_NONE,
266 buf, sizeof( buf ),
267 NULL, sizeof( buf ) ) );
268
269 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
270 mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
271 NULL,
272 MBEDTLS_MD_NONE,
273 buf, sizeof( buf ),
274 buf, sizeof( buf ) ) );
275 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
276 mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
277 &pk,
278 MBEDTLS_MD_NONE,
279 NULL, sizeof( buf ),
280 buf, sizeof( buf ) ) );
281 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
282 mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
283 &pk,
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100284 valid_md,
285 NULL, 0,
286 buf, sizeof( buf ) ) );
287 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
288 mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
289 &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100290 MBEDTLS_MD_NONE,
291 buf, sizeof( buf ),
292 NULL, sizeof( buf ) ) );
293
294 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
295 mbedtls_pk_sign_restartable( NULL,
296 MBEDTLS_MD_NONE,
297 buf, sizeof( buf ),
298 buf, &len,
299 rnd_std_rand, NULL,
300 NULL ) );
301 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
302 mbedtls_pk_sign_restartable( &pk,
303 MBEDTLS_MD_NONE,
304 NULL, sizeof( buf ),
305 buf, &len,
306 rnd_std_rand, NULL,
307 NULL ) );
308 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
309 mbedtls_pk_sign_restartable( &pk,
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100310 valid_md,
311 NULL, 0,
312 buf, &len,
313 rnd_std_rand, NULL,
314 NULL ) );
315 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
316 mbedtls_pk_sign_restartable( &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100317 MBEDTLS_MD_NONE,
318 buf, sizeof( buf ),
319 NULL, &len,
320 rnd_std_rand, NULL,
321 NULL ) );
322
323 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
324 mbedtls_pk_sign( NULL,
325 MBEDTLS_MD_NONE,
326 buf, sizeof( buf ),
327 buf, &len,
328 rnd_std_rand, NULL ) );
329 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
330 mbedtls_pk_sign( &pk,
331 MBEDTLS_MD_NONE,
332 NULL, sizeof( buf ),
333 buf, &len,
334 rnd_std_rand, NULL ) );
335 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
336 mbedtls_pk_sign( &pk,
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100337 valid_md,
338 NULL, 0,
339 buf, &len,
340 rnd_std_rand, NULL ) );
341 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
342 mbedtls_pk_sign( &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100343 MBEDTLS_MD_NONE,
344 buf, sizeof( buf ),
345 NULL, &len,
346 rnd_std_rand, NULL ) );
347
348 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
349 mbedtls_pk_decrypt( NULL,
350 buf, sizeof( buf ),
351 buf, &len, sizeof( buf ),
352 rnd_std_rand, NULL ) );
353 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
354 mbedtls_pk_decrypt( &pk,
355 NULL, sizeof( buf ),
356 buf, &len, sizeof( buf ),
357 rnd_std_rand, NULL ) );
358 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
359 mbedtls_pk_decrypt( &pk,
360 buf, sizeof( buf ),
361 NULL, &len, sizeof( buf ),
362 rnd_std_rand, NULL ) );
363 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
364 mbedtls_pk_decrypt( &pk,
365 buf, sizeof( buf ),
366 buf, NULL, sizeof( buf ),
367 rnd_std_rand, NULL ) );
368
369 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
370 mbedtls_pk_encrypt( NULL,
371 buf, sizeof( buf ),
372 buf, &len, sizeof( buf ),
373 rnd_std_rand, NULL ) );
374 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
375 mbedtls_pk_encrypt( &pk,
376 NULL, sizeof( buf ),
377 buf, &len, sizeof( buf ),
378 rnd_std_rand, NULL ) );
379 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
380 mbedtls_pk_encrypt( &pk,
381 buf, sizeof( buf ),
382 NULL, &len, sizeof( buf ),
383 rnd_std_rand, NULL ) );
384 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
385 mbedtls_pk_encrypt( &pk,
386 buf, sizeof( buf ),
387 buf, NULL, sizeof( buf ),
388 rnd_std_rand, NULL ) );
389
390 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
391 mbedtls_pk_check_pair( NULL, &pk ) );
392 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
393 mbedtls_pk_check_pair( &pk, NULL ) );
394
395 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
396 mbedtls_pk_debug( NULL, NULL ) );
397
398#if defined(MBEDTLS_PK_PARSE_C)
399 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
400 mbedtls_pk_load_file( NULL, &p, &len ) );
401 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
402 mbedtls_pk_load_file( str, NULL, &len ) );
403 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
404 mbedtls_pk_load_file( str, &p, NULL ) );
405
406#if defined(MBEDTLS_FS_IO)
407 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
408 mbedtls_pk_parse_keyfile( NULL, str, NULL ) );
409 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
410 mbedtls_pk_parse_keyfile( &pk, NULL, NULL ) );
411
412 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
413 mbedtls_pk_parse_public_keyfile( NULL, str ) );
414 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
415 mbedtls_pk_parse_public_keyfile( &pk, NULL ) );
416#endif
417
418 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
419 mbedtls_pk_parse_subpubkey( NULL, buf, &pk ) );
420 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
421 mbedtls_pk_parse_subpubkey( &null_buf, buf, &pk ) );
422 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
423 mbedtls_pk_parse_subpubkey( &p, NULL, &pk ) );
424 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
425 mbedtls_pk_parse_subpubkey( &p, buf, NULL ) );
426
427 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
428 mbedtls_pk_parse_key( NULL,
429 buf, sizeof( buf ),
430 buf, sizeof( buf ) ) );
431 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
432 mbedtls_pk_parse_key( &pk,
433 NULL, sizeof( buf ),
434 buf, sizeof( buf ) ) );
435 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
436 mbedtls_pk_parse_key( &pk,
437 buf, sizeof( buf ),
438 NULL, sizeof( buf ) ) );
439
440 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
441 mbedtls_pk_parse_public_key( NULL,
442 buf, sizeof( buf ) ) );
443 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
444 mbedtls_pk_parse_public_key( &pk,
445 NULL, sizeof( buf ) ) );
446#endif /* MBEDTLS_PK_PARSE_C */
447
448#if defined(MBEDTLS_PK_WRITE_C)
449 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
450 mbedtls_pk_write_pubkey( NULL, p, &pk ) );
451 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
452 mbedtls_pk_write_pubkey( &null_buf, p, &pk ) );
453 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
454 mbedtls_pk_write_pubkey( &p, NULL, &pk ) );
455 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
456 mbedtls_pk_write_pubkey( &p, p, NULL ) );
457
458 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
459 mbedtls_pk_write_pubkey_der( NULL,
460 buf, sizeof( buf ) ) );
461 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
462 mbedtls_pk_write_pubkey_der( &pk,
463 NULL, sizeof( buf ) ) );
464
465 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
466 mbedtls_pk_write_key_der( NULL,
467 buf, sizeof( buf ) ) );
468 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
469 mbedtls_pk_write_key_der( &pk,
470 NULL, sizeof( buf ) ) );
471
472#if defined(MBEDTLS_PEM_WRITE_C)
473 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
474 mbedtls_pk_write_pubkey_pem( NULL,
475 buf, sizeof( buf ) ) );
476 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
477 mbedtls_pk_write_pubkey_pem( &pk,
478 NULL, sizeof( buf ) ) );
479
480 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
481 mbedtls_pk_write_key_pem( NULL,
482 buf, sizeof( buf ) ) );
483 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
484 mbedtls_pk_write_key_pem( &pk,
485 NULL, sizeof( buf ) ) );
486#endif /* MBEDTLS_PEM_WRITE_C */
487
488#endif /* MBEDTLS_PK_WRITE_C */
489}
490/* END_CASE */
491
492/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100493void pk_utils( int type, int size, int len, char * name )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200494{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200495 mbedtls_pk_context pk;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200496
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200497 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200498
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200499 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200500 TEST_ASSERT( pk_genkey( &pk ) == 0 );
501
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200502 TEST_ASSERT( (int) mbedtls_pk_get_type( &pk ) == type );
503 TEST_ASSERT( mbedtls_pk_can_do( &pk, type ) );
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +0200504 TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == (unsigned) size );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200505 TEST_ASSERT( mbedtls_pk_get_len( &pk ) == (unsigned) len );
506 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200507
Paul Bakkerbd51b262014-07-10 15:26:12 +0200508exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200509 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200510}
511/* END_CASE */
512
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200513/* BEGIN_CASE depends_on:MBEDTLS_PK_PARSE_C:MBEDTLS_FS_IO */
Azim Khanf1aaec92017-05-30 14:23:15 +0100514void mbedtls_pk_check_pair( char * pub_file, char * prv_file, int ret )
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100515{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200516 mbedtls_pk_context pub, prv, alt;
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100517
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200518 mbedtls_pk_init( &pub );
519 mbedtls_pk_init( &prv );
520 mbedtls_pk_init( &alt );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100521
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200522 TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &pub, pub_file ) == 0 );
523 TEST_ASSERT( mbedtls_pk_parse_keyfile( &prv, prv_file, NULL ) == 0 );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100524
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200525 TEST_ASSERT( mbedtls_pk_check_pair( &pub, &prv ) == ret );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100526
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200527#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
528 if( mbedtls_pk_get_type( &prv ) == MBEDTLS_PK_RSA )
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100529 {
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200530 TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, mbedtls_pk_rsa( prv ),
Hanno Becker6ac972d2017-09-07 10:57:48 +0100531 mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
532 mbedtls_rsa_key_len_func ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200533 TEST_ASSERT( mbedtls_pk_check_pair( &pub, &alt ) == ret );
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100534 }
Manuel Pégourié-Gonnard7c13d692014-11-12 00:01:34 +0100535#endif
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100536
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200537 mbedtls_pk_free( &pub );
538 mbedtls_pk_free( &prv );
539 mbedtls_pk_free( &alt );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100540}
541/* END_CASE */
542
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200543/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100544void pk_rsa_verify_test_vec( data_t * message_str, int digest, int mod,
Azim Khand30ca132017-06-09 04:32:58 +0100545 int radix_N, char * input_N, int radix_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100546 char * input_E, data_t * result_str,
Azim Khanf1aaec92017-05-30 14:23:15 +0100547 int result )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200548{
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200549 unsigned char hash_result[1000];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200550 mbedtls_rsa_context *rsa;
551 mbedtls_pk_context pk;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200552 mbedtls_pk_restart_ctx *rs_ctx = NULL;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200553#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200554 mbedtls_pk_restart_ctx ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200555
556 rs_ctx = &ctx;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200557 mbedtls_pk_restart_init( rs_ctx );
Manuel Pégourié-Gonnard4edb9cb2018-07-02 12:23:23 +0200558 // this setting would ensure restart would happen if ECC was used
559 mbedtls_ecp_set_max_ops( 1 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200560#endif
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200561
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200562 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200563
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200564 memset( hash_result, 0x00, 1000 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200565
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200566 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200567 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200568
Paul Bakker42099c32014-01-27 11:45:49 +0100569 rsa->len = mod / 8;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200570 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
571 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200572
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200573
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200574 if( mbedtls_md_info_from_type( digest ) != NULL )
Azim Khand30ca132017-06-09 04:32:58 +0100575 TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200576
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200577 TEST_ASSERT( mbedtls_pk_verify( &pk, digest, hash_result, 0,
Azim Khand30ca132017-06-09 04:32:58 +0100578 result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200579
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200580 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, digest, hash_result, 0,
Manuel Pégourié-Gonnard125af942018-09-11 11:08:12 +0200581 result_str->x, mbedtls_pk_get_len( &pk ), rs_ctx ) == result );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200582
Paul Bakkerbd51b262014-07-10 15:26:12 +0200583exit:
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200584#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200585 mbedtls_pk_restart_free( rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200586#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200587 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200588}
589/* END_CASE */
590
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200591/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100592void pk_rsa_verify_ext_test_vec( data_t * message_str, int digest,
Azim Khand30ca132017-06-09 04:32:58 +0100593 int mod, int radix_N, char * input_N,
594 int radix_E, char * input_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100595 data_t * result_str, int pk_type,
Azim Khanf1aaec92017-05-30 14:23:15 +0100596 int mgf1_hash_id, int salt_len, int result )
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200597{
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200598 unsigned char hash_result[1000];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200599 mbedtls_rsa_context *rsa;
600 mbedtls_pk_context pk;
601 mbedtls_pk_rsassa_pss_options pss_opts;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200602 void *options;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200603 size_t hash_len;
604
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200605 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200606
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200607 memset( hash_result, 0x00, 1000 );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200608
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200609 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200610 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200611
612 rsa->len = mod / 8;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200613 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
614 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200615
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200616
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200617 if( digest != MBEDTLS_MD_NONE )
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200618 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200619 TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ),
Azim Khand30ca132017-06-09 04:32:58 +0100620 message_str->x, message_str->len, hash_result ) == 0 );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200621 hash_len = 0;
622 }
623 else
624 {
Azim Khand30ca132017-06-09 04:32:58 +0100625 memcpy( hash_result, message_str->x, message_str->len );
626 hash_len = message_str->len;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200627 }
628
629 if( mgf1_hash_id < 0 )
630 {
631 options = NULL;
632 }
633 else
634 {
635 options = &pss_opts;
636
637 pss_opts.mgf1_hash_id = mgf1_hash_id;
638 pss_opts.expected_salt_len = salt_len;
639 }
640
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200641 TEST_ASSERT( mbedtls_pk_verify_ext( pk_type, options, &pk,
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200642 digest, hash_result, hash_len,
Azim Khand30ca132017-06-09 04:32:58 +0100643 result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200644
Paul Bakkerbd51b262014-07-10 15:26:12 +0200645exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200646 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200647}
648/* END_CASE */
649
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200650/* BEGIN_CASE depends_on:MBEDTLS_ECDSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100651void pk_ec_test_vec( int type, int id, data_t * key, data_t * hash,
652 data_t * sig, int ret )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200653{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200654 mbedtls_pk_context pk;
655 mbedtls_ecp_keypair *eckey;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200656
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200657 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200658
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200659
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200660 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200661
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200662 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) );
663 eckey = mbedtls_pk_ec( pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200664
Manuel Pégourié-Gonnarde3a062b2015-05-11 18:46:47 +0200665 TEST_ASSERT( mbedtls_ecp_group_load( &eckey->grp, id ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200666 TEST_ASSERT( mbedtls_ecp_point_read_binary( &eckey->grp, &eckey->Q,
Azim Khand30ca132017-06-09 04:32:58 +0100667 key->x, key->len ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200668
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200669 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE,
Azim Khand30ca132017-06-09 04:32:58 +0100670 hash->x, hash->len, sig->x, sig->len ) == ret );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200671
Paul Bakkerbd51b262014-07-10 15:26:12 +0200672exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200673 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200674}
675/* END_CASE */
676
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200677/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECDSA_C:MBEDTLS_ECDSA_DETERMINISTIC */
678void pk_sign_verify_restart( int pk_type, int grp_id, char *d_str,
679 char *QX_str, char *QY_str,
680 int md_alg, char *msg, char *sig_str,
681 int max_ops, int min_restart, int max_restart )
682{
683 int ret, cnt_restart;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200684 mbedtls_pk_restart_ctx rs_ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200685 mbedtls_pk_context prv, pub;
686 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
687 unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
688 unsigned char sig_check[MBEDTLS_ECDSA_MAX_LEN];
689 size_t hlen, slen, slen_check;
690 const mbedtls_md_info_t *md_info;
691
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200692 mbedtls_pk_restart_init( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200693 mbedtls_pk_init( &prv );
694 mbedtls_pk_init( &pub );
695 memset( hash, 0, sizeof( hash ) );
696 memset( sig, 0, sizeof( sig ) );
697 memset( sig_check, 0, sizeof( sig_check ) );
698
699 TEST_ASSERT( mbedtls_pk_setup( &prv, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
700 TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( prv )->grp, grp_id ) == 0 );
701 TEST_ASSERT( mbedtls_mpi_read_string( &mbedtls_pk_ec( prv )->d, 16, d_str ) == 0 );
702
703 TEST_ASSERT( mbedtls_pk_setup( &pub, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
704 TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( pub )->grp, grp_id ) == 0 );
705 TEST_ASSERT( mbedtls_ecp_point_read_string( &mbedtls_pk_ec( pub )->Q, 16, QX_str, QY_str ) == 0 );
706
707 slen_check = unhexify( sig_check, sig_str );
708
709 md_info = mbedtls_md_info_from_type( md_alg );
710 TEST_ASSERT( md_info != NULL );
711
712 hlen = mbedtls_md_get_size( md_info );
713 mbedtls_md( md_info, (const unsigned char *) msg, strlen( msg ), hash );
714
715 mbedtls_ecp_set_max_ops( max_ops );
716
717 slen = sizeof( sig );
718 cnt_restart = 0;
719 do {
720 ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
721 sig, &slen, NULL, NULL, &rs_ctx );
722 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
723
724 TEST_ASSERT( ret == 0 );
725 TEST_ASSERT( slen == slen_check );
726 TEST_ASSERT( memcmp( sig, sig_check, slen ) == 0 );
727
728 TEST_ASSERT( cnt_restart >= min_restart );
729 TEST_ASSERT( cnt_restart <= max_restart );
730
731 cnt_restart = 0;
732 do {
733 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
734 hash, hlen, sig, slen, &rs_ctx );
735 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
736
737 TEST_ASSERT( ret == 0 );
738 TEST_ASSERT( cnt_restart >= min_restart );
739 TEST_ASSERT( cnt_restart <= max_restart );
740
741 hash[0]++;
742 do {
743 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
744 hash, hlen, sig, slen, &rs_ctx );
745 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
746 TEST_ASSERT( ret != 0 );
747 hash[0]--;
748
749 sig[0]++;
750 do {
751 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
752 hash, hlen, sig, slen, &rs_ctx );
753 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
754 TEST_ASSERT( ret != 0 );
755 sig[0]--;
756
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200757 /* Do we leak memory when aborting? try verify then sign
758 * This test only makes sense when we actually restart */
759 if( min_restart > 0 )
760 {
761 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
762 hash, hlen, sig, slen, &rs_ctx );
763 TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
764 mbedtls_pk_restart_free( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200765
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200766 slen = sizeof( sig );
767 ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
768 sig, &slen, NULL, NULL, &rs_ctx );
769 TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
770 }
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200771
772exit:
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200773 mbedtls_pk_restart_free( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200774 mbedtls_pk_free( &prv );
775 mbedtls_pk_free( &pub );
776}
777/* END_CASE */
778
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200779/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200780void pk_sign_verify( int type, int sign_ret, int verify_ret )
781{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200782 mbedtls_pk_context pk;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200783 unsigned char hash[50], sig[5000];
784 size_t sig_len;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200785 void *rs_ctx = NULL;
786#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200787 mbedtls_pk_restart_ctx ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200788
789 rs_ctx = &ctx;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200790 mbedtls_pk_restart_init( rs_ctx );
Manuel Pégourié-Gonnard4edb9cb2018-07-02 12:23:23 +0200791 /* This value is large enough that the operation will complete in one run.
792 * See comments at the top of ecp_test_vect_restart in
793 * test_suite_ecp.function for estimates of operation counts. */
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200794 mbedtls_ecp_set_max_ops( 42000 );
795#endif
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200796
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200797 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200798
799 memset( hash, 0x2a, sizeof hash );
800 memset( sig, 0, sizeof sig );
801
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200802 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200803 TEST_ASSERT( pk_genkey( &pk ) == 0 );
804
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200805 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_SHA256,
806 hash, sizeof hash, sig, &sig_len,
807 rnd_std_rand, NULL, rs_ctx ) == sign_ret );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200808
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200809 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200810 hash, sizeof hash, sig, sig_len ) == verify_ret );
811
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200812 if( verify_ret == 0 )
813 {
814 hash[0]++;
815 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
816 hash, sizeof hash, sig, sig_len ) != 0 );
817 hash[0]--;
818
819 sig[0]++;
820 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
821 hash, sizeof hash, sig, sig_len ) != 0 );
822 sig[0]--;
823 }
824
825 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256, hash, sizeof hash,
826 sig, &sig_len, rnd_std_rand, NULL ) == sign_ret );
827
828 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
829 hash, sizeof hash, sig, sig_len, rs_ctx ) == verify_ret );
830
831 if( verify_ret == 0 )
832 {
833 hash[0]++;
834 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
835 hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
836 hash[0]--;
837
838 sig[0]++;
839 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
840 hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
841 sig[0]--;
842 }
843
Paul Bakkerbd51b262014-07-10 15:26:12 +0200844exit:
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200845#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200846 mbedtls_pk_restart_free( rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200847#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200848 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200849}
850/* END_CASE */
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200851
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200852/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100853void pk_rsa_encrypt_test_vec( data_t * message, int mod, int radix_N,
Azim Khand30ca132017-06-09 04:32:58 +0100854 char * input_N, int radix_E, char * input_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100855 data_t * result, int ret )
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200856{
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200857 unsigned char output[1000];
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200858 rnd_pseudo_info rnd_info;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200859 mbedtls_rsa_context *rsa;
860 mbedtls_pk_context pk;
Azim Khanf1aaec92017-05-30 14:23:15 +0100861 size_t olen;
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200862
863 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200864 memset( output, 0, sizeof( output ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200865
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200866
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200867 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200868 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200869 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200870
871 rsa->len = mod / 8;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200872 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
873 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200874
Azim Khand30ca132017-06-09 04:32:58 +0100875 TEST_ASSERT( mbedtls_pk_encrypt( &pk, message->x, message->len,
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200876 output, &olen, sizeof( output ),
877 rnd_pseudo_rand, &rnd_info ) == ret );
Azim Khand30ca132017-06-09 04:32:58 +0100878 TEST_ASSERT( olen == result->len );
879 TEST_ASSERT( memcmp( output, result->x, olen ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200880
Paul Bakkerbd51b262014-07-10 15:26:12 +0200881exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200882 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200883}
884/* END_CASE */
885
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200886/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100887void pk_rsa_decrypt_test_vec( data_t * cipher, int mod, int radix_P,
Azim Khand30ca132017-06-09 04:32:58 +0100888 char * input_P, int radix_Q, char * input_Q,
889 int radix_N, char * input_N, int radix_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100890 char * input_E, data_t * clear, int ret )
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200891{
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200892 unsigned char output[1000];
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200893 rnd_pseudo_info rnd_info;
Hanno Beckerd71dc152017-08-23 06:32:42 +0100894 mbedtls_mpi N, P, Q, E;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200895 mbedtls_rsa_context *rsa;
896 mbedtls_pk_context pk;
Azim Khanf1aaec92017-05-30 14:23:15 +0100897 size_t olen;
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200898
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200899 mbedtls_pk_init( &pk );
Hanno Beckerd71dc152017-08-23 06:32:42 +0100900 mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
901 mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200902
903 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200904
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200905
906 /* init pk-rsa context */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200907 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200908 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200909
910 /* load public key */
Hanno Beckerd71dc152017-08-23 06:32:42 +0100911 TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
912 TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200913
914 /* load private key */
Hanno Beckerd71dc152017-08-23 06:32:42 +0100915 TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
916 TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
917 TEST_ASSERT( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ) == 0 );
918 TEST_ASSERT( mbedtls_rsa_get_len( rsa ) == (size_t) ( mod / 8 ) );
Hanno Becker7f25f852017-10-10 16:56:22 +0100919 TEST_ASSERT( mbedtls_rsa_complete( rsa ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200920
921 /* decryption test */
922 memset( output, 0, sizeof( output ) );
923 olen = 0;
Azim Khand30ca132017-06-09 04:32:58 +0100924 TEST_ASSERT( mbedtls_pk_decrypt( &pk, cipher->x, cipher->len,
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200925 output, &olen, sizeof( output ),
926 rnd_pseudo_rand, &rnd_info ) == ret );
927 if( ret == 0 )
928 {
Azim Khand30ca132017-06-09 04:32:58 +0100929 TEST_ASSERT( olen == clear->len );
930 TEST_ASSERT( memcmp( output, clear->x, olen ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200931 }
932
Paul Bakkerbd51b262014-07-10 15:26:12 +0200933exit:
Hanno Beckerd71dc152017-08-23 06:32:42 +0100934 mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
935 mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200936 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200937}
938/* END_CASE */
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200939
940/* BEGIN_CASE */
941void pk_ec_nocrypt( int type )
942{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200943 mbedtls_pk_context pk;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200944 unsigned char output[100];
945 unsigned char input[100];
946 rnd_pseudo_info rnd_info;
947 size_t olen = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200948 int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200949
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200950 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200951
952 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
953 memset( output, 0, sizeof( output ) );
954 memset( input, 0, sizeof( input ) );
955
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200956 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200957
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200958 TEST_ASSERT( mbedtls_pk_encrypt( &pk, input, sizeof( input ),
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200959 output, &olen, sizeof( output ),
960 rnd_pseudo_rand, &rnd_info ) == ret );
961
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200962 TEST_ASSERT( mbedtls_pk_decrypt( &pk, input, sizeof( input ),
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200963 output, &olen, sizeof( output ),
964 rnd_pseudo_rand, &rnd_info ) == ret );
965
Paul Bakkerbd51b262014-07-10 15:26:12 +0200966exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200967 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200968}
969/* END_CASE */
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200970
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +0100971/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Andres AG5c79d252017-02-15 10:52:32 +0000972void pk_rsa_overflow( )
973{
974 mbedtls_pk_context pk;
itayzafrir693a1d92018-02-26 12:02:10 +0200975 size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX;
976 unsigned char hash[50], sig[100];
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +0100977
978 if( SIZE_MAX <= UINT_MAX )
979 return;
Andres AG5c79d252017-02-15 10:52:32 +0000980
itayzafrir693a1d92018-02-26 12:02:10 +0200981 memset( hash, 0x2a, sizeof hash );
982 memset( sig, 0, sizeof sig );
Andres AG5c79d252017-02-15 10:52:32 +0000983
984 mbedtls_pk_init( &pk );
985
986 TEST_ASSERT( mbedtls_pk_setup( &pk,
987 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
988
989#if defined(MBEDTLS_PKCS1_V21)
990 TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_RSASSA_PSS, NULL, &pk,
itayzafrir693a1d92018-02-26 12:02:10 +0200991 MBEDTLS_MD_NONE, hash, hash_len, sig, sig_len ) ==
Andres AG5c79d252017-02-15 10:52:32 +0000992 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
993#endif /* MBEDTLS_PKCS1_V21 */
994
itayzafrir693a1d92018-02-26 12:02:10 +0200995 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE, hash, hash_len,
996 sig, sig_len ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres AG5c79d252017-02-15 10:52:32 +0000997
itayzafrir693a1d92018-02-26 12:02:10 +0200998 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, hash, hash_len, sig, &sig_len,
Andres AG5c79d252017-02-15 10:52:32 +0000999 rnd_std_rand, NULL ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
1000
1001exit:
1002 mbedtls_pk_free( &pk );
1003}
1004/* END_CASE */
1005
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001006/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_PK_RSA_ALT_SUPPORT */
Azim Khanf1aaec92017-05-30 14:23:15 +01001007void pk_rsa_alt( )
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001008{
1009 /*
1010 * An rsa_alt context can only do private operations (decrypt, sign).
1011 * Test it against the public operations (encrypt, verify) of a
1012 * corresponding rsa context.
1013 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001014 mbedtls_rsa_context raw;
1015 mbedtls_pk_context rsa, alt;
1016 mbedtls_pk_debug_item dbg_items[10];
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001017 unsigned char hash[50], sig[1000];
1018 unsigned char msg[50], ciph[1000], test[1000];
1019 size_t sig_len, ciph_len, test_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001020 int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001021
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001022 mbedtls_rsa_init( &raw, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE );
1023 mbedtls_pk_init( &rsa ); mbedtls_pk_init( &alt );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001024
1025 memset( hash, 0x2a, sizeof hash );
1026 memset( sig, 0, sizeof sig );
1027 memset( msg, 0x2a, sizeof msg );
1028 memset( ciph, 0, sizeof ciph );
1029 memset( test, 0, sizeof test );
1030
1031 /* Initiliaze PK RSA context with random key */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +02001032 TEST_ASSERT( mbedtls_pk_setup( &rsa,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001033 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001034 TEST_ASSERT( pk_genkey( &rsa ) == 0 );
1035
1036 /* Extract key to the raw rsa context */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001037 TEST_ASSERT( mbedtls_rsa_copy( &raw, mbedtls_pk_rsa( rsa ) ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001038
1039 /* Initialize PK RSA_ALT context */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +02001040 TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, (void *) &raw,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001041 mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001042
1043 /* Test administrative functions */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001044 TEST_ASSERT( mbedtls_pk_can_do( &alt, MBEDTLS_PK_RSA ) );
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +02001045 TEST_ASSERT( mbedtls_pk_get_bitlen( &alt ) == RSA_KEY_SIZE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001046 TEST_ASSERT( mbedtls_pk_get_len( &alt ) == RSA_KEY_LEN );
1047 TEST_ASSERT( mbedtls_pk_get_type( &alt ) == MBEDTLS_PK_RSA_ALT );
1048 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &alt ), "RSA-alt" ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001049
1050 /* Test signature */
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +01001051#if SIZE_MAX > UINT_MAX
1052 TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, SIZE_MAX,
1053 sig, &sig_len, rnd_std_rand, NULL ) ==
Andres AG5c79d252017-02-15 10:52:32 +00001054 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +01001055#endif /* SIZE_MAX > UINT_MAX */
1056 TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, sizeof hash,
1057 sig, &sig_len, rnd_std_rand, NULL ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001058 TEST_ASSERT( sig_len == RSA_KEY_LEN );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001059 TEST_ASSERT( mbedtls_pk_verify( &rsa, MBEDTLS_MD_NONE,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001060 hash, sizeof hash, sig, sig_len ) == 0 );
1061
1062 /* Test decrypt */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001063 TEST_ASSERT( mbedtls_pk_encrypt( &rsa, msg, sizeof msg,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001064 ciph, &ciph_len, sizeof ciph,
1065 rnd_std_rand, NULL ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001066 TEST_ASSERT( mbedtls_pk_decrypt( &alt, ciph, ciph_len,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001067 test, &test_len, sizeof test,
1068 rnd_std_rand, NULL ) == 0 );
1069 TEST_ASSERT( test_len == sizeof msg );
1070 TEST_ASSERT( memcmp( test, msg, test_len ) == 0 );
1071
1072 /* Test forbidden operations */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001073 TEST_ASSERT( mbedtls_pk_encrypt( &alt, msg, sizeof msg,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001074 ciph, &ciph_len, sizeof ciph,
1075 rnd_std_rand, NULL ) == ret );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001076 TEST_ASSERT( mbedtls_pk_verify( &alt, MBEDTLS_MD_NONE,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001077 hash, sizeof hash, sig, sig_len ) == ret );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001078 TEST_ASSERT( mbedtls_pk_debug( &alt, dbg_items ) == ret );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001079
Paul Bakkerbd51b262014-07-10 15:26:12 +02001080exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001081 mbedtls_rsa_free( &raw );
1082 mbedtls_pk_free( &rsa ); mbedtls_pk_free( &alt );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001083}
1084/* END_CASE */