blob: 4e6ab172c81438fbd2d5c96d19bd70e085614dea [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 Peskine6af45ec2018-12-19 17:52:05 +010093 /* In informational functions, we accept NULL where a context pointer
94 * is expected because that's what the library has done forever.
95 * We do not document that NULL is accepted, so we may wish to change
96 * the behavior in a future version. */
Gilles Peskinee146e7d2018-12-19 13:20:21 +010097 TEST_ASSERT( mbedtls_pk_get_bitlen( NULL ) == 0 );
Gilles Peskinee146e7d2018-12-19 13:20:21 +010098 TEST_ASSERT( mbedtls_pk_get_len( NULL ) == 0 );
Gilles Peskinee146e7d2018-12-19 13:20:21 +010099 TEST_ASSERT( mbedtls_pk_can_do( NULL, MBEDTLS_PK_NONE ) == 0 );
Gilles Peskine78438e42018-12-19 00:55:07 +0100100
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100101 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
102 MBEDTLS_MD_NONE,
103 NULL, 0,
104 buf, &len,
105 rnd_std_rand, NULL,
106 NULL ) ==
107 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
108
109 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
110 MBEDTLS_MD_NONE,
111 NULL, 0,
112 buf, &len,
113 rnd_std_rand, NULL,
114 NULL ) ==
115 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
116
117 TEST_ASSERT( mbedtls_pk_sign( &pk,
118 MBEDTLS_MD_NONE,
119 NULL, 0,
120 buf, &len,
121 rnd_std_rand, NULL ) ==
122 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
123
124 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk,
125 MBEDTLS_MD_NONE,
126 NULL, 0,
127 buf, sizeof( buf ),
128 NULL ) ==
129 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
130
131 TEST_ASSERT( mbedtls_pk_verify( &pk,
132 MBEDTLS_MD_NONE,
133 NULL, 0,
134 buf, sizeof( buf ) ) ==
135 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
136
137 TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
138 &pk,
139 MBEDTLS_MD_NONE,
140 NULL, 0,
141 buf, sizeof( buf ) ) ==
142 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
143
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100144 TEST_ASSERT( mbedtls_pk_encrypt( &pk,
145 NULL, 0,
146 NULL, &len, 0,
147 rnd_std_rand, NULL ) ==
148 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Gilles Peskine78438e42018-12-19 00:55:07 +0100149
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100150 TEST_ASSERT( mbedtls_pk_decrypt( &pk,
151 NULL, 0,
152 NULL, &len, 0,
153 rnd_std_rand, NULL ) ==
154 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Gilles Peskine78438e42018-12-19 00:55:07 +0100155
156#if defined(MBEDTLS_PK_PARSE_C)
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100157 TEST_ASSERT( mbedtls_pk_parse_key( &pk, NULL, 0, NULL, 1 ) ==
158 MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
Gilles Peskine78438e42018-12-19 00:55:07 +0100159
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100160 TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, NULL, 0 ) ==
161 MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
Gilles Peskine78438e42018-12-19 00:55:07 +0100162#endif /* MBEDTLS_PK_PARSE_C */
Gilles Peskine998fbfb2018-12-19 17:08:51 +0100163}
164/* END_CASE */
Gilles Peskine78438e42018-12-19 00:55:07 +0100165
Gilles Peskine998fbfb2018-12-19 17:08:51 +0100166/* BEGIN_CASE depends_on:MBEDTLS_PK_WRITE_C */
167void valid_parameters_pkwrite( data_t *key_data )
168{
169 mbedtls_pk_context pk;
170
171 /* For the write tests to be effective, we need a valid key pair. */
172 mbedtls_pk_init( &pk );
173 TEST_ASSERT( mbedtls_pk_parse_key( &pk,
174 key_data->x, key_data->len,
175 NULL, 0 ) == 0 );
176
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100177 TEST_ASSERT( mbedtls_pk_write_key_der( &pk, NULL, 0 ) ==
Gilles Peskine998fbfb2018-12-19 17:08:51 +0100178 MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
Gilles Peskine78438e42018-12-19 00:55:07 +0100179
Gilles Peskinee146e7d2018-12-19 13:20:21 +0100180 TEST_ASSERT( mbedtls_pk_write_pubkey_der( &pk, NULL, 0 ) ==
Gilles Peskine998fbfb2018-12-19 17:08:51 +0100181 MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
182
183#if defined(MBEDTLS_PEM_WRITE_C)
184 TEST_ASSERT( mbedtls_pk_write_key_pem( &pk, NULL, 0 ) ==
185 MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
186
187 TEST_ASSERT( mbedtls_pk_write_pubkey_pem( &pk, NULL, 0 ) ==
188 MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
189#endif /* MBEDTLS_PEM_WRITE_C */
190
191exit:
192 mbedtls_pk_free( &pk );
Gilles Peskine78438e42018-12-19 00:55:07 +0100193}
194/* END_CASE */
195
196/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
197void invalid_parameters( )
198{
199 size_t len;
200 unsigned char *null_buf = NULL;
201 unsigned char buf[1];
202 unsigned char *p = buf;
203 char str[1] = {0};
204 mbedtls_pk_context pk;
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100205 mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
Gilles Peskine78438e42018-12-19 00:55:07 +0100206 void *options = buf;
207
Gilles Peskine88ca3a22018-12-20 12:26:16 +0100208 (void) null_buf;
209 (void) p;
Gilles Peskine743e3982018-12-20 12:29:48 +0100210 (void) str;
Gilles Peskine88ca3a22018-12-20 12:26:16 +0100211
Gilles Peskine78438e42018-12-19 00:55:07 +0100212 mbedtls_pk_init( &pk );
213
214 TEST_INVALID_PARAM( mbedtls_pk_init( NULL ) );
215
216#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
217 TEST_INVALID_PARAM( mbedtls_pk_restart_init( NULL ) );
Gilles Peskine78438e42018-12-19 00:55:07 +0100218#endif
219
220 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
221 mbedtls_pk_setup( NULL, NULL ) );
222
223#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
224 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
225 mbedtls_pk_setup_rsa_alt( NULL, buf,
226 NULL, NULL, NULL ) );
227#endif
228
229 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
230 mbedtls_pk_verify_restartable( NULL,
231 MBEDTLS_MD_NONE,
232 buf, 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,
237 MBEDTLS_MD_NONE,
238 NULL, sizeof( buf ),
239 buf, sizeof( buf ),
240 NULL ) );
241 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
242 mbedtls_pk_verify_restartable( &pk,
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100243 valid_md,
244 NULL, 0,
245 buf, sizeof( buf ),
246 NULL ) );
247 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
248 mbedtls_pk_verify_restartable( &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100249 MBEDTLS_MD_NONE,
250 buf, sizeof( buf ),
251 NULL, sizeof( buf ),
252 NULL ) );
253
254 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
255 mbedtls_pk_verify( NULL,
256 MBEDTLS_MD_NONE,
257 buf, sizeof( buf ),
258 buf, sizeof( buf ) ) );
259 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
260 mbedtls_pk_verify( &pk,
261 MBEDTLS_MD_NONE,
262 NULL, sizeof( buf ),
263 buf, sizeof( buf ) ) );
264 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
265 mbedtls_pk_verify( &pk,
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100266 valid_md,
267 NULL, 0,
268 buf, sizeof( buf ) ) );
269 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
270 mbedtls_pk_verify( &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100271 MBEDTLS_MD_NONE,
272 buf, sizeof( buf ),
273 NULL, sizeof( buf ) ) );
274
275 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
276 mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
277 NULL,
278 MBEDTLS_MD_NONE,
279 buf, 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,
284 MBEDTLS_MD_NONE,
285 NULL, sizeof( buf ),
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 Peskineee3cfec2018-12-19 17:10:02 +0100290 valid_md,
291 NULL, 0,
292 buf, sizeof( buf ) ) );
293 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
294 mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
295 &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100296 MBEDTLS_MD_NONE,
297 buf, sizeof( buf ),
298 NULL, sizeof( buf ) ) );
299
300 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
301 mbedtls_pk_sign_restartable( NULL,
302 MBEDTLS_MD_NONE,
303 buf, sizeof( buf ),
304 buf, &len,
305 rnd_std_rand, NULL,
306 NULL ) );
307 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
308 mbedtls_pk_sign_restartable( &pk,
309 MBEDTLS_MD_NONE,
310 NULL, sizeof( buf ),
311 buf, &len,
312 rnd_std_rand, NULL,
313 NULL ) );
314 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
315 mbedtls_pk_sign_restartable( &pk,
Gilles Peskineee3cfec2018-12-19 17:10:02 +0100316 valid_md,
317 NULL, 0,
318 buf, &len,
319 rnd_std_rand, NULL,
320 NULL ) );
321 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
322 mbedtls_pk_sign_restartable( &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100323 MBEDTLS_MD_NONE,
324 buf, sizeof( buf ),
325 NULL, &len,
326 rnd_std_rand, NULL,
327 NULL ) );
328
329 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
330 mbedtls_pk_sign( NULL,
331 MBEDTLS_MD_NONE,
332 buf, 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,
337 MBEDTLS_MD_NONE,
338 NULL, sizeof( buf ),
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 Peskineee3cfec2018-12-19 17:10:02 +0100343 valid_md,
344 NULL, 0,
345 buf, &len,
346 rnd_std_rand, NULL ) );
347 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
348 mbedtls_pk_sign( &pk,
Gilles Peskine78438e42018-12-19 00:55:07 +0100349 MBEDTLS_MD_NONE,
350 buf, sizeof( buf ),
351 NULL, &len,
352 rnd_std_rand, NULL ) );
353
354 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
355 mbedtls_pk_decrypt( NULL,
356 buf, sizeof( buf ),
357 buf, &len, sizeof( buf ),
358 rnd_std_rand, NULL ) );
359 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
360 mbedtls_pk_decrypt( &pk,
361 NULL, sizeof( buf ),
362 buf, &len, sizeof( buf ),
363 rnd_std_rand, NULL ) );
364 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
365 mbedtls_pk_decrypt( &pk,
366 buf, sizeof( buf ),
367 NULL, &len, sizeof( buf ),
368 rnd_std_rand, NULL ) );
369 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
370 mbedtls_pk_decrypt( &pk,
371 buf, sizeof( buf ),
372 buf, NULL, sizeof( buf ),
373 rnd_std_rand, NULL ) );
374
375 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
376 mbedtls_pk_encrypt( NULL,
377 buf, sizeof( buf ),
378 buf, &len, sizeof( buf ),
379 rnd_std_rand, NULL ) );
380 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
381 mbedtls_pk_encrypt( &pk,
382 NULL, sizeof( buf ),
383 buf, &len, sizeof( buf ),
384 rnd_std_rand, NULL ) );
385 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
386 mbedtls_pk_encrypt( &pk,
387 buf, sizeof( buf ),
388 NULL, &len, sizeof( buf ),
389 rnd_std_rand, NULL ) );
390 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
391 mbedtls_pk_encrypt( &pk,
392 buf, sizeof( buf ),
393 buf, NULL, sizeof( buf ),
394 rnd_std_rand, NULL ) );
395
396 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
397 mbedtls_pk_check_pair( NULL, &pk ) );
398 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
399 mbedtls_pk_check_pair( &pk, NULL ) );
400
401 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
402 mbedtls_pk_debug( NULL, NULL ) );
403
404#if defined(MBEDTLS_PK_PARSE_C)
Gilles Peskined6027112018-12-20 12:15:41 +0100405#if defined(MBEDTLS_FS_IO)
Gilles Peskine78438e42018-12-19 00:55:07 +0100406 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
407 mbedtls_pk_load_file( NULL, &p, &len ) );
408 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
409 mbedtls_pk_load_file( str, NULL, &len ) );
410 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
411 mbedtls_pk_load_file( str, &p, NULL ) );
412
Gilles Peskine78438e42018-12-19 00:55:07 +0100413 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
414 mbedtls_pk_parse_keyfile( NULL, str, NULL ) );
415 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
416 mbedtls_pk_parse_keyfile( &pk, NULL, NULL ) );
417
418 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
419 mbedtls_pk_parse_public_keyfile( NULL, str ) );
420 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
421 mbedtls_pk_parse_public_keyfile( &pk, NULL ) );
422#endif
423
424 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
425 mbedtls_pk_parse_subpubkey( NULL, buf, &pk ) );
426 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
427 mbedtls_pk_parse_subpubkey( &null_buf, buf, &pk ) );
428 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
429 mbedtls_pk_parse_subpubkey( &p, NULL, &pk ) );
430 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
431 mbedtls_pk_parse_subpubkey( &p, buf, NULL ) );
432
433 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
434 mbedtls_pk_parse_key( NULL,
435 buf, sizeof( buf ),
436 buf, sizeof( buf ) ) );
437 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
438 mbedtls_pk_parse_key( &pk,
439 NULL, sizeof( buf ),
440 buf, sizeof( buf ) ) );
Gilles Peskine78438e42018-12-19 00:55:07 +0100441
442 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
443 mbedtls_pk_parse_public_key( NULL,
444 buf, sizeof( buf ) ) );
445 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
446 mbedtls_pk_parse_public_key( &pk,
447 NULL, sizeof( buf ) ) );
448#endif /* MBEDTLS_PK_PARSE_C */
449
450#if defined(MBEDTLS_PK_WRITE_C)
451 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
452 mbedtls_pk_write_pubkey( NULL, p, &pk ) );
453 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
454 mbedtls_pk_write_pubkey( &null_buf, p, &pk ) );
455 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
456 mbedtls_pk_write_pubkey( &p, NULL, &pk ) );
457 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
458 mbedtls_pk_write_pubkey( &p, p, NULL ) );
459
460 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
461 mbedtls_pk_write_pubkey_der( NULL,
462 buf, sizeof( buf ) ) );
463 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
464 mbedtls_pk_write_pubkey_der( &pk,
465 NULL, sizeof( buf ) ) );
466
467 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
468 mbedtls_pk_write_key_der( NULL,
469 buf, sizeof( buf ) ) );
470 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
471 mbedtls_pk_write_key_der( &pk,
472 NULL, sizeof( buf ) ) );
473
474#if defined(MBEDTLS_PEM_WRITE_C)
475 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
476 mbedtls_pk_write_pubkey_pem( NULL,
477 buf, sizeof( buf ) ) );
478 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
479 mbedtls_pk_write_pubkey_pem( &pk,
480 NULL, sizeof( buf ) ) );
481
482 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
483 mbedtls_pk_write_key_pem( NULL,
484 buf, sizeof( buf ) ) );
485 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
486 mbedtls_pk_write_key_pem( &pk,
487 NULL, sizeof( buf ) ) );
488#endif /* MBEDTLS_PEM_WRITE_C */
489
490#endif /* MBEDTLS_PK_WRITE_C */
491}
492/* END_CASE */
493
494/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100495void pk_utils( int type, int size, int len, char * name )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200496{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200497 mbedtls_pk_context pk;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200498
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200499 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200500
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200501 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200502 TEST_ASSERT( pk_genkey( &pk ) == 0 );
503
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200504 TEST_ASSERT( (int) mbedtls_pk_get_type( &pk ) == type );
505 TEST_ASSERT( mbedtls_pk_can_do( &pk, type ) );
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +0200506 TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == (unsigned) size );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200507 TEST_ASSERT( mbedtls_pk_get_len( &pk ) == (unsigned) len );
508 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200509
Paul Bakkerbd51b262014-07-10 15:26:12 +0200510exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200511 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200512}
513/* END_CASE */
514
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200515/* BEGIN_CASE depends_on:MBEDTLS_PK_PARSE_C:MBEDTLS_FS_IO */
Azim Khanf1aaec92017-05-30 14:23:15 +0100516void mbedtls_pk_check_pair( char * pub_file, char * prv_file, int ret )
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100517{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200518 mbedtls_pk_context pub, prv, alt;
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100519
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200520 mbedtls_pk_init( &pub );
521 mbedtls_pk_init( &prv );
522 mbedtls_pk_init( &alt );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100523
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200524 TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &pub, pub_file ) == 0 );
525 TEST_ASSERT( mbedtls_pk_parse_keyfile( &prv, prv_file, NULL ) == 0 );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100526
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200527 TEST_ASSERT( mbedtls_pk_check_pair( &pub, &prv ) == ret );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100528
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200529#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
530 if( mbedtls_pk_get_type( &prv ) == MBEDTLS_PK_RSA )
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100531 {
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200532 TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, mbedtls_pk_rsa( prv ),
Hanno Becker6ac972d2017-09-07 10:57:48 +0100533 mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
534 mbedtls_rsa_key_len_func ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200535 TEST_ASSERT( mbedtls_pk_check_pair( &pub, &alt ) == ret );
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100536 }
Manuel Pégourié-Gonnard7c13d692014-11-12 00:01:34 +0100537#endif
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100538
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200539 mbedtls_pk_free( &pub );
540 mbedtls_pk_free( &prv );
541 mbedtls_pk_free( &alt );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100542}
543/* END_CASE */
544
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200545/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100546void pk_rsa_verify_test_vec( data_t * message_str, int digest, int mod,
Azim Khand30ca132017-06-09 04:32:58 +0100547 int radix_N, char * input_N, int radix_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100548 char * input_E, data_t * result_str,
Azim Khanf1aaec92017-05-30 14:23:15 +0100549 int result )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200550{
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200551 unsigned char hash_result[1000];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200552 mbedtls_rsa_context *rsa;
553 mbedtls_pk_context pk;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200554 mbedtls_pk_restart_ctx *rs_ctx = NULL;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200555#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200556 mbedtls_pk_restart_ctx ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200557
558 rs_ctx = &ctx;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200559 mbedtls_pk_restart_init( rs_ctx );
Manuel Pégourié-Gonnard4edb9cb2018-07-02 12:23:23 +0200560 // this setting would ensure restart would happen if ECC was used
561 mbedtls_ecp_set_max_ops( 1 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200562#endif
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200563
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200564 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200565
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200566 memset( hash_result, 0x00, 1000 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200567
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200568 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200569 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200570
Paul Bakker42099c32014-01-27 11:45:49 +0100571 rsa->len = mod / 8;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200572 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
573 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200574
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200575
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200576 if( mbedtls_md_info_from_type( digest ) != NULL )
Azim Khand30ca132017-06-09 04:32:58 +0100577 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 +0200578
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200579 TEST_ASSERT( mbedtls_pk_verify( &pk, digest, hash_result, 0,
Azim Khand30ca132017-06-09 04:32:58 +0100580 result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200581
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200582 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, digest, hash_result, 0,
Manuel Pégourié-Gonnard125af942018-09-11 11:08:12 +0200583 result_str->x, mbedtls_pk_get_len( &pk ), rs_ctx ) == result );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200584
Paul Bakkerbd51b262014-07-10 15:26:12 +0200585exit:
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200586#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200587 mbedtls_pk_restart_free( rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200588#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200589 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200590}
591/* END_CASE */
592
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200593/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100594void pk_rsa_verify_ext_test_vec( data_t * message_str, int digest,
Azim Khand30ca132017-06-09 04:32:58 +0100595 int mod, int radix_N, char * input_N,
596 int radix_E, char * input_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100597 data_t * result_str, int pk_type,
Azim Khanf1aaec92017-05-30 14:23:15 +0100598 int mgf1_hash_id, int salt_len, int result )
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200599{
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200600 unsigned char hash_result[1000];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200601 mbedtls_rsa_context *rsa;
602 mbedtls_pk_context pk;
603 mbedtls_pk_rsassa_pss_options pss_opts;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200604 void *options;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200605 size_t hash_len;
606
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200607 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200608
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200609 memset( hash_result, 0x00, 1000 );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200610
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200611 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200612 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200613
614 rsa->len = mod / 8;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200615 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
616 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200617
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200618
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200619 if( digest != MBEDTLS_MD_NONE )
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200620 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200621 TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ),
Azim Khand30ca132017-06-09 04:32:58 +0100622 message_str->x, message_str->len, hash_result ) == 0 );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200623 hash_len = 0;
624 }
625 else
626 {
Azim Khand30ca132017-06-09 04:32:58 +0100627 memcpy( hash_result, message_str->x, message_str->len );
628 hash_len = message_str->len;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200629 }
630
631 if( mgf1_hash_id < 0 )
632 {
633 options = NULL;
634 }
635 else
636 {
637 options = &pss_opts;
638
639 pss_opts.mgf1_hash_id = mgf1_hash_id;
640 pss_opts.expected_salt_len = salt_len;
641 }
642
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200643 TEST_ASSERT( mbedtls_pk_verify_ext( pk_type, options, &pk,
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200644 digest, hash_result, hash_len,
Azim Khand30ca132017-06-09 04:32:58 +0100645 result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200646
Paul Bakkerbd51b262014-07-10 15:26:12 +0200647exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200648 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200649}
650/* END_CASE */
651
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200652/* BEGIN_CASE depends_on:MBEDTLS_ECDSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100653void pk_ec_test_vec( int type, int id, data_t * key, data_t * hash,
654 data_t * sig, int ret )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200655{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200656 mbedtls_pk_context pk;
657 mbedtls_ecp_keypair *eckey;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200658
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200659 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200660
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200661
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200662 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200663
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200664 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) );
665 eckey = mbedtls_pk_ec( pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200666
Manuel Pégourié-Gonnarde3a062b2015-05-11 18:46:47 +0200667 TEST_ASSERT( mbedtls_ecp_group_load( &eckey->grp, id ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200668 TEST_ASSERT( mbedtls_ecp_point_read_binary( &eckey->grp, &eckey->Q,
Azim Khand30ca132017-06-09 04:32:58 +0100669 key->x, key->len ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200670
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200671 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE,
Azim Khand30ca132017-06-09 04:32:58 +0100672 hash->x, hash->len, sig->x, sig->len ) == ret );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200673
Paul Bakkerbd51b262014-07-10 15:26:12 +0200674exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200675 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200676}
677/* END_CASE */
678
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200679/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECDSA_C:MBEDTLS_ECDSA_DETERMINISTIC */
680void pk_sign_verify_restart( int pk_type, int grp_id, char *d_str,
681 char *QX_str, char *QY_str,
682 int md_alg, char *msg, char *sig_str,
683 int max_ops, int min_restart, int max_restart )
684{
685 int ret, cnt_restart;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200686 mbedtls_pk_restart_ctx rs_ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200687 mbedtls_pk_context prv, pub;
688 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
689 unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
690 unsigned char sig_check[MBEDTLS_ECDSA_MAX_LEN];
691 size_t hlen, slen, slen_check;
692 const mbedtls_md_info_t *md_info;
693
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200694 mbedtls_pk_restart_init( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200695 mbedtls_pk_init( &prv );
696 mbedtls_pk_init( &pub );
697 memset( hash, 0, sizeof( hash ) );
698 memset( sig, 0, sizeof( sig ) );
699 memset( sig_check, 0, sizeof( sig_check ) );
700
701 TEST_ASSERT( mbedtls_pk_setup( &prv, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
702 TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( prv )->grp, grp_id ) == 0 );
703 TEST_ASSERT( mbedtls_mpi_read_string( &mbedtls_pk_ec( prv )->d, 16, d_str ) == 0 );
704
705 TEST_ASSERT( mbedtls_pk_setup( &pub, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
706 TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( pub )->grp, grp_id ) == 0 );
707 TEST_ASSERT( mbedtls_ecp_point_read_string( &mbedtls_pk_ec( pub )->Q, 16, QX_str, QY_str ) == 0 );
708
709 slen_check = unhexify( sig_check, sig_str );
710
711 md_info = mbedtls_md_info_from_type( md_alg );
712 TEST_ASSERT( md_info != NULL );
713
714 hlen = mbedtls_md_get_size( md_info );
715 mbedtls_md( md_info, (const unsigned char *) msg, strlen( msg ), hash );
716
717 mbedtls_ecp_set_max_ops( max_ops );
718
719 slen = sizeof( sig );
720 cnt_restart = 0;
721 do {
722 ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
723 sig, &slen, NULL, NULL, &rs_ctx );
724 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
725
726 TEST_ASSERT( ret == 0 );
727 TEST_ASSERT( slen == slen_check );
728 TEST_ASSERT( memcmp( sig, sig_check, slen ) == 0 );
729
730 TEST_ASSERT( cnt_restart >= min_restart );
731 TEST_ASSERT( cnt_restart <= max_restart );
732
733 cnt_restart = 0;
734 do {
735 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
736 hash, hlen, sig, slen, &rs_ctx );
737 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
738
739 TEST_ASSERT( ret == 0 );
740 TEST_ASSERT( cnt_restart >= min_restart );
741 TEST_ASSERT( cnt_restart <= max_restart );
742
743 hash[0]++;
744 do {
745 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
746 hash, hlen, sig, slen, &rs_ctx );
747 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
748 TEST_ASSERT( ret != 0 );
749 hash[0]--;
750
751 sig[0]++;
752 do {
753 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
754 hash, hlen, sig, slen, &rs_ctx );
755 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
756 TEST_ASSERT( ret != 0 );
757 sig[0]--;
758
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200759 /* Do we leak memory when aborting? try verify then sign
760 * This test only makes sense when we actually restart */
761 if( min_restart > 0 )
762 {
763 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
764 hash, hlen, sig, slen, &rs_ctx );
765 TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
766 mbedtls_pk_restart_free( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200767
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200768 slen = sizeof( sig );
769 ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
770 sig, &slen, NULL, NULL, &rs_ctx );
771 TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
772 }
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200773
774exit:
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200775 mbedtls_pk_restart_free( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200776 mbedtls_pk_free( &prv );
777 mbedtls_pk_free( &pub );
778}
779/* END_CASE */
780
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200781/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200782void pk_sign_verify( int type, int sign_ret, int verify_ret )
783{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200784 mbedtls_pk_context pk;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200785 unsigned char hash[50], sig[5000];
786 size_t sig_len;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200787 void *rs_ctx = NULL;
788#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200789 mbedtls_pk_restart_ctx ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200790
791 rs_ctx = &ctx;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200792 mbedtls_pk_restart_init( rs_ctx );
Manuel Pégourié-Gonnard4edb9cb2018-07-02 12:23:23 +0200793 /* This value is large enough that the operation will complete in one run.
794 * See comments at the top of ecp_test_vect_restart in
795 * test_suite_ecp.function for estimates of operation counts. */
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200796 mbedtls_ecp_set_max_ops( 42000 );
797#endif
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200798
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200799 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200800
801 memset( hash, 0x2a, sizeof hash );
802 memset( sig, 0, sizeof sig );
803
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200804 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200805 TEST_ASSERT( pk_genkey( &pk ) == 0 );
806
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200807 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_SHA256,
808 hash, sizeof hash, sig, &sig_len,
809 rnd_std_rand, NULL, rs_ctx ) == sign_ret );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200810
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200811 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200812 hash, sizeof hash, sig, sig_len ) == verify_ret );
813
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200814 if( verify_ret == 0 )
815 {
816 hash[0]++;
817 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
818 hash, sizeof hash, sig, sig_len ) != 0 );
819 hash[0]--;
820
821 sig[0]++;
822 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
823 hash, sizeof hash, sig, sig_len ) != 0 );
824 sig[0]--;
825 }
826
827 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256, hash, sizeof hash,
828 sig, &sig_len, rnd_std_rand, NULL ) == sign_ret );
829
830 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
831 hash, sizeof hash, sig, sig_len, rs_ctx ) == verify_ret );
832
833 if( verify_ret == 0 )
834 {
835 hash[0]++;
836 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
837 hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
838 hash[0]--;
839
840 sig[0]++;
841 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
842 hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
843 sig[0]--;
844 }
845
Paul Bakkerbd51b262014-07-10 15:26:12 +0200846exit:
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200847#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200848 mbedtls_pk_restart_free( rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200849#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200850 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200851}
852/* END_CASE */
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200853
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200854/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100855void pk_rsa_encrypt_test_vec( data_t * message, int mod, int radix_N,
Azim Khand30ca132017-06-09 04:32:58 +0100856 char * input_N, int radix_E, char * input_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100857 data_t * result, int ret )
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200858{
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200859 unsigned char output[1000];
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200860 rnd_pseudo_info rnd_info;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200861 mbedtls_rsa_context *rsa;
862 mbedtls_pk_context pk;
Azim Khanf1aaec92017-05-30 14:23:15 +0100863 size_t olen;
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200864
865 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200866 memset( output, 0, sizeof( output ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200867
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200868
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200869 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200870 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200871 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200872
873 rsa->len = mod / 8;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200874 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
875 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200876
Azim Khand30ca132017-06-09 04:32:58 +0100877 TEST_ASSERT( mbedtls_pk_encrypt( &pk, message->x, message->len,
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200878 output, &olen, sizeof( output ),
879 rnd_pseudo_rand, &rnd_info ) == ret );
Azim Khand30ca132017-06-09 04:32:58 +0100880 TEST_ASSERT( olen == result->len );
881 TEST_ASSERT( memcmp( output, result->x, olen ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200882
Paul Bakkerbd51b262014-07-10 15:26:12 +0200883exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200884 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200885}
886/* END_CASE */
887
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200888/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100889void pk_rsa_decrypt_test_vec( data_t * cipher, int mod, int radix_P,
Azim Khand30ca132017-06-09 04:32:58 +0100890 char * input_P, int radix_Q, char * input_Q,
891 int radix_N, char * input_N, int radix_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100892 char * input_E, data_t * clear, int ret )
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200893{
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200894 unsigned char output[1000];
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200895 rnd_pseudo_info rnd_info;
Hanno Beckerd71dc152017-08-23 06:32:42 +0100896 mbedtls_mpi N, P, Q, E;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200897 mbedtls_rsa_context *rsa;
898 mbedtls_pk_context pk;
Azim Khanf1aaec92017-05-30 14:23:15 +0100899 size_t olen;
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200900
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200901 mbedtls_pk_init( &pk );
Hanno Beckerd71dc152017-08-23 06:32:42 +0100902 mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
903 mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200904
905 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200906
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200907
908 /* init pk-rsa context */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200909 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200910 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200911
912 /* load public key */
Hanno Beckerd71dc152017-08-23 06:32:42 +0100913 TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
914 TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200915
916 /* load private key */
Hanno Beckerd71dc152017-08-23 06:32:42 +0100917 TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
918 TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
919 TEST_ASSERT( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ) == 0 );
920 TEST_ASSERT( mbedtls_rsa_get_len( rsa ) == (size_t) ( mod / 8 ) );
Hanno Becker7f25f852017-10-10 16:56:22 +0100921 TEST_ASSERT( mbedtls_rsa_complete( rsa ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200922
923 /* decryption test */
924 memset( output, 0, sizeof( output ) );
925 olen = 0;
Azim Khand30ca132017-06-09 04:32:58 +0100926 TEST_ASSERT( mbedtls_pk_decrypt( &pk, cipher->x, cipher->len,
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200927 output, &olen, sizeof( output ),
928 rnd_pseudo_rand, &rnd_info ) == ret );
929 if( ret == 0 )
930 {
Azim Khand30ca132017-06-09 04:32:58 +0100931 TEST_ASSERT( olen == clear->len );
932 TEST_ASSERT( memcmp( output, clear->x, olen ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200933 }
934
Paul Bakkerbd51b262014-07-10 15:26:12 +0200935exit:
Hanno Beckerd71dc152017-08-23 06:32:42 +0100936 mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
937 mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200938 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200939}
940/* END_CASE */
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200941
942/* BEGIN_CASE */
943void pk_ec_nocrypt( int type )
944{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200945 mbedtls_pk_context pk;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200946 unsigned char output[100];
947 unsigned char input[100];
948 rnd_pseudo_info rnd_info;
949 size_t olen = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200950 int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200951
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200952 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200953
954 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
955 memset( output, 0, sizeof( output ) );
956 memset( input, 0, sizeof( input ) );
957
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200958 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200959
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200960 TEST_ASSERT( mbedtls_pk_encrypt( &pk, input, sizeof( input ),
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200961 output, &olen, sizeof( output ),
962 rnd_pseudo_rand, &rnd_info ) == ret );
963
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200964 TEST_ASSERT( mbedtls_pk_decrypt( &pk, input, sizeof( input ),
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200965 output, &olen, sizeof( output ),
966 rnd_pseudo_rand, &rnd_info ) == ret );
967
Paul Bakkerbd51b262014-07-10 15:26:12 +0200968exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200969 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200970}
971/* END_CASE */
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200972
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +0100973/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Andres AG5c79d252017-02-15 10:52:32 +0000974void pk_rsa_overflow( )
975{
976 mbedtls_pk_context pk;
itayzafrir693a1d92018-02-26 12:02:10 +0200977 size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX;
978 unsigned char hash[50], sig[100];
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +0100979
980 if( SIZE_MAX <= UINT_MAX )
981 return;
Andres AG5c79d252017-02-15 10:52:32 +0000982
itayzafrir693a1d92018-02-26 12:02:10 +0200983 memset( hash, 0x2a, sizeof hash );
984 memset( sig, 0, sizeof sig );
Andres AG5c79d252017-02-15 10:52:32 +0000985
986 mbedtls_pk_init( &pk );
987
988 TEST_ASSERT( mbedtls_pk_setup( &pk,
989 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
990
991#if defined(MBEDTLS_PKCS1_V21)
992 TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_RSASSA_PSS, NULL, &pk,
itayzafrir693a1d92018-02-26 12:02:10 +0200993 MBEDTLS_MD_NONE, hash, hash_len, sig, sig_len ) ==
Andres AG5c79d252017-02-15 10:52:32 +0000994 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
995#endif /* MBEDTLS_PKCS1_V21 */
996
itayzafrir693a1d92018-02-26 12:02:10 +0200997 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE, hash, hash_len,
998 sig, sig_len ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres AG5c79d252017-02-15 10:52:32 +0000999
itayzafrir693a1d92018-02-26 12:02:10 +02001000 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, hash, hash_len, sig, &sig_len,
Andres AG5c79d252017-02-15 10:52:32 +00001001 rnd_std_rand, NULL ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
1002
1003exit:
1004 mbedtls_pk_free( &pk );
1005}
1006/* END_CASE */
1007
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001008/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_PK_RSA_ALT_SUPPORT */
Azim Khanf1aaec92017-05-30 14:23:15 +01001009void pk_rsa_alt( )
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001010{
1011 /*
1012 * An rsa_alt context can only do private operations (decrypt, sign).
1013 * Test it against the public operations (encrypt, verify) of a
1014 * corresponding rsa context.
1015 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001016 mbedtls_rsa_context raw;
1017 mbedtls_pk_context rsa, alt;
1018 mbedtls_pk_debug_item dbg_items[10];
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001019 unsigned char hash[50], sig[1000];
1020 unsigned char msg[50], ciph[1000], test[1000];
1021 size_t sig_len, ciph_len, test_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001022 int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001023
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001024 mbedtls_rsa_init( &raw, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE );
1025 mbedtls_pk_init( &rsa ); mbedtls_pk_init( &alt );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001026
1027 memset( hash, 0x2a, sizeof hash );
1028 memset( sig, 0, sizeof sig );
1029 memset( msg, 0x2a, sizeof msg );
1030 memset( ciph, 0, sizeof ciph );
1031 memset( test, 0, sizeof test );
1032
1033 /* Initiliaze PK RSA context with random key */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +02001034 TEST_ASSERT( mbedtls_pk_setup( &rsa,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001035 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001036 TEST_ASSERT( pk_genkey( &rsa ) == 0 );
1037
1038 /* Extract key to the raw rsa context */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001039 TEST_ASSERT( mbedtls_rsa_copy( &raw, mbedtls_pk_rsa( rsa ) ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001040
1041 /* Initialize PK RSA_ALT context */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +02001042 TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, (void *) &raw,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001043 mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001044
1045 /* Test administrative functions */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001046 TEST_ASSERT( mbedtls_pk_can_do( &alt, MBEDTLS_PK_RSA ) );
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +02001047 TEST_ASSERT( mbedtls_pk_get_bitlen( &alt ) == RSA_KEY_SIZE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001048 TEST_ASSERT( mbedtls_pk_get_len( &alt ) == RSA_KEY_LEN );
1049 TEST_ASSERT( mbedtls_pk_get_type( &alt ) == MBEDTLS_PK_RSA_ALT );
1050 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &alt ), "RSA-alt" ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001051
1052 /* Test signature */
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +01001053#if SIZE_MAX > UINT_MAX
1054 TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, SIZE_MAX,
1055 sig, &sig_len, rnd_std_rand, NULL ) ==
Andres AG5c79d252017-02-15 10:52:32 +00001056 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +01001057#endif /* SIZE_MAX > UINT_MAX */
1058 TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, sizeof hash,
1059 sig, &sig_len, rnd_std_rand, NULL ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001060 TEST_ASSERT( sig_len == RSA_KEY_LEN );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001061 TEST_ASSERT( mbedtls_pk_verify( &rsa, MBEDTLS_MD_NONE,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001062 hash, sizeof hash, sig, sig_len ) == 0 );
1063
1064 /* Test decrypt */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001065 TEST_ASSERT( mbedtls_pk_encrypt( &rsa, msg, sizeof msg,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001066 ciph, &ciph_len, sizeof ciph,
1067 rnd_std_rand, NULL ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001068 TEST_ASSERT( mbedtls_pk_decrypt( &alt, ciph, ciph_len,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001069 test, &test_len, sizeof test,
1070 rnd_std_rand, NULL ) == 0 );
1071 TEST_ASSERT( test_len == sizeof msg );
1072 TEST_ASSERT( memcmp( test, msg, test_len ) == 0 );
1073
1074 /* Test forbidden operations */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001075 TEST_ASSERT( mbedtls_pk_encrypt( &alt, msg, sizeof msg,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001076 ciph, &ciph_len, sizeof ciph,
1077 rnd_std_rand, NULL ) == ret );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001078 TEST_ASSERT( mbedtls_pk_verify( &alt, MBEDTLS_MD_NONE,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001079 hash, sizeof hash, sig, sig_len ) == ret );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001080 TEST_ASSERT( mbedtls_pk_debug( &alt, dbg_items ) == ret );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001081
Paul Bakkerbd51b262014-07-10 15:26:12 +02001082exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001083 mbedtls_rsa_free( &raw );
1084 mbedtls_pk_free( &rsa ); mbedtls_pk_free( &alt );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001085}
1086/* END_CASE */