blob: b46cf05cfb2c37ff123df00cec5356700c0ffadb [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 */
Andrzej Kurekc470b6b2019-01-31 08:20:20 -05005#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
Gilles Peskine33b1c692019-12-19 00:09:47 +010013/* Needed only for test case data under #if defined(MBEDTLS_USE_PSA_CRYPTO),
14 * but the test code generator requires test case data to be valid C code
15 * unconditionally (https://github.com/ARMmbed/mbedtls/issues/2023). */
16#include "psa/crypto.h"
17
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020018#define RSA_KEY_SIZE 512
19#define RSA_KEY_LEN 64
20
Gilles Peskinee48fe552019-11-05 16:42:13 +010021/** Generate a key of the desired type.
22 *
23 * \param pk The PK object to fill. It must have been initialized
24 * with mbedtls_pk_setup().
25 * \param parameter - For RSA keys, the key size in bits.
26 * - For EC keys, the curve (\c MBEDTLS_ECP_DP_xxx).
27 *
28 * \return The status from the underlying type-specific key
29 * generation function.
30 * \return -1 if the key type is not recognized.
31 */
32static int pk_genkey( mbedtls_pk_context *pk, int parameter )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020033{
Paul Bakkera5320902013-12-19 17:29:52 +010034 ((void) pk);
Gilles Peskinee48fe552019-11-05 16:42:13 +010035 (void) parameter;
Paul Bakkera5320902013-12-19 17:29:52 +010036
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020037#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
38 if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_RSA )
Gilles Peskinee48fe552019-11-05 16:42:13 +010039 return mbedtls_rsa_gen_key( mbedtls_pk_rsa( *pk ),
Ronald Cron351f0ee2020-06-10 12:12:18 +020040 mbedtls_test_rnd_std_rand, NULL,
Gilles Peskinee48fe552019-11-05 16:42:13 +010041 parameter, 3 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020042#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020043#if defined(MBEDTLS_ECP_C)
44 if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY ||
45 mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY_DH ||
46 mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECDSA )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020047 {
48 int ret;
Manuel Pégourié-Gonnarde3a062b2015-05-11 18:46:47 +020049 if( ( ret = mbedtls_ecp_group_load( &mbedtls_pk_ec( *pk )->grp,
Gilles Peskinee48fe552019-11-05 16:42:13 +010050 parameter ) ) != 0 )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020051 return( ret );
52
Ronald Cron6c5bd7f2020-06-10 14:08:26 +020053 return mbedtls_ecp_gen_keypair( &mbedtls_pk_ec( *pk )->grp,
54 &mbedtls_pk_ec( *pk )->d,
55 &mbedtls_pk_ec( *pk )->Q,
56 mbedtls_test_rnd_std_rand, NULL );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +020057 }
58#endif
59 return( -1 );
60}
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020061
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020062#if defined(MBEDTLS_RSA_C)
Thomas Daubney99914142021-05-06 15:17:03 +010063int mbedtls_rsa_decrypt_func( void *ctx, size_t *olen,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020064 const unsigned char *input, unsigned char *output,
65 size_t output_max_len )
66{
Hanno Becker6ac972d2017-09-07 10:57:48 +010067 return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx,
Thomas Daubney99914142021-05-06 15:17:03 +010068 mbedtls_test_rnd_std_rand, NULL,
Ronald Cron6c5bd7f2020-06-10 14:08:26 +020069 olen, input, output, output_max_len ) );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020070}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020071int mbedtls_rsa_sign_func( void *ctx,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020072 int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
Thomas Daubneyfa1581e2021-05-18 12:38:33 +010073 mbedtls_md_type_t md_alg, unsigned int hashlen,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020074 const unsigned char *hash, unsigned char *sig )
75{
Hanno Beckera5400682017-05-03 16:43:15 +010076 ((void) f_rng);
77 ((void) p_rng);
Ronald Cron6c5bd7f2020-06-10 14:08:26 +020078 return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx,
Thomas Daubney140184d2021-05-18 16:04:07 +010079 mbedtls_test_rnd_std_rand, NULL,
Ronald Cron6c5bd7f2020-06-10 14:08:26 +020080 md_alg, hashlen, hash, sig ) );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020081}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020082size_t mbedtls_rsa_key_len_func( void *ctx )
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020083{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020084 return( ((const mbedtls_rsa_context *) ctx)->len );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +020085}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020086#endif /* MBEDTLS_RSA_C */
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +010087
88#if defined(MBEDTLS_USE_PSA_CRYPTO)
89
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +010090/*
Ronald Cron5425a212020-08-04 14:58:35 +020091 * Generate a key using PSA and return the key identifier of that key,
Gilles Peskined2d45c12019-05-27 14:53:13 +020092 * or 0 if the key generation failed.
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +010093 * The key uses NIST P-256 and is usable for signing with SHA-256.
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +010094 */
Ronald Cron5425a212020-08-04 14:58:35 +020095mbedtls_svc_key_id_t pk_psa_genkey( void )
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +010096{
Ronald Cron5425a212020-08-04 14:58:35 +020097 mbedtls_svc_key_id_t key;
Gilles Peskined2d45c12019-05-27 14:53:13 +020098 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine89177e82019-12-03 21:19:09 +010099 const psa_key_type_t type =
Paul Elliott8ff510a2020-06-02 17:19:28 +0100100 PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 );
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100101 const size_t bits = 256;
102
Gilles Peskine89d8c5c2019-11-26 17:01:59 +0100103 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
Gilles Peskined2d45c12019-05-27 14:53:13 +0200104 psa_set_key_algorithm( &attributes, PSA_ALG_ECDSA(PSA_ALG_SHA_256) );
105 psa_set_key_type( &attributes, type );
106 psa_set_key_bits( &attributes, bits );
107 PSA_ASSERT( psa_generate_key( &attributes, &key ) );
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100108
Gilles Peskined2d45c12019-05-27 14:53:13 +0200109exit:
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100110 return( key );
111}
112#endif /* MBEDTLS_USE_PSA_CRYPTO */
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200113/* END_HEADER */
114
115/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200116 * depends_on:MBEDTLS_PK_C
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200117 * END_DEPENDENCIES
118 */
119
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100120/* BEGIN_CASE depends_on:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_ECDSA_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED */
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100121void pk_psa_utils( )
122{
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100123 mbedtls_pk_context pk, pk2;
Ronald Cron5425a212020-08-04 14:58:35 +0200124 mbedtls_svc_key_id_t key;
Gilles Peskined2d45c12019-05-27 14:53:13 +0200125 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100126
Manuel Pégourié-Gonnard69baf702018-11-06 09:34:30 +0100127 const char * const name = "Opaque";
Manuel Pégourié-Gonnard0184b3c2018-10-31 10:36:51 +0100128 const size_t bitlen = 256; /* harcoded in genkey() */
129
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100130 mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
131 unsigned char b1[1], b2[1];
132 size_t len;
133 mbedtls_pk_debug_item dbg;
134
Gilles Peskine5386f6b2019-08-01 12:47:40 +0200135 PSA_ASSERT( psa_crypto_init( ) );
Jaeden Amero3ea26872019-02-13 11:30:22 +0000136
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100137 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100138 mbedtls_pk_init( &pk2 );
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100139
Gilles Peskine614faa22019-06-07 15:39:07 +0200140 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
Gilles Peskine69c0ea22019-06-07 15:38:59 +0200141
Ronald Cron5425a212020-08-04 14:58:35 +0200142 TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, MBEDTLS_SVC_KEY_ID_INIT ) ==
Manuel Pégourié-Gonnard920c0632018-10-31 10:57:29 +0100143 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
144
145 mbedtls_pk_free( &pk );
146 mbedtls_pk_init( &pk );
147
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100148 key = pk_psa_genkey();
Ronald Cron5425a212020-08-04 14:58:35 +0200149 if( mbedtls_svc_key_id_is_null( key ) )
Gilles Peskined2d45c12019-05-27 14:53:13 +0200150 goto exit;
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100151
Manuel Pégourié-Gonnard69baf702018-11-06 09:34:30 +0100152 TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, key ) == 0 );
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100153
Manuel Pégourié-Gonnard69baf702018-11-06 09:34:30 +0100154 TEST_ASSERT( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_OPAQUE );
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100155 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
156
Manuel Pégourié-Gonnard0184b3c2018-10-31 10:36:51 +0100157 TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == bitlen );
158 TEST_ASSERT( mbedtls_pk_get_len( &pk ) == bitlen / 8 );
159
Manuel Pégourié-Gonnard920c0632018-10-31 10:57:29 +0100160 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECKEY ) == 1 );
161 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) == 1 );
162 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_RSA ) == 0 );
163
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100164 /* unsupported operations: verify, decrypt, encrypt */
165 TEST_ASSERT( mbedtls_pk_verify( &pk, md_alg,
166 b1, sizeof( b1), b2, sizeof( b2 ) )
167 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
168 TEST_ASSERT( mbedtls_pk_decrypt( &pk, b1, sizeof( b1 ),
169 b2, &len, sizeof( b2 ),
170 NULL, NULL )
171 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
172 TEST_ASSERT( mbedtls_pk_encrypt( &pk, b1, sizeof( b1 ),
173 b2, &len, sizeof( b2 ),
174 NULL, NULL )
175 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
176
177 /* unsupported functions: check_pair, debug */
178 TEST_ASSERT( mbedtls_pk_setup( &pk2,
179 mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
Manuel Pégourié-Gonnard39be1412021-06-15 11:29:26 +0200180 TEST_ASSERT( mbedtls_pk_check_pair( &pk, &pk2,
181 mbedtls_test_rnd_std_rand, NULL )
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100182 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
183 TEST_ASSERT( mbedtls_pk_debug( &pk, &dbg )
184 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
185
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100186 /* test that freeing the context does not destroy the key */
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100187 mbedtls_pk_free( &pk );
Gilles Peskined2d45c12019-05-27 14:53:13 +0200188 TEST_ASSERT( PSA_SUCCESS == psa_get_key_attributes( key, &attributes ) );
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100189 TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key ) );
190
191exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100192 /*
193 * Key attributes may have been returned by psa_get_key_attributes()
194 * thus reset them as required.
195 */
196 psa_reset_key_attributes( &attributes );
197
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100198 mbedtls_pk_free( &pk ); /* redundant except upon error */
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100199 mbedtls_pk_free( &pk2 );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100200 USE_PSA_DONE( );
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100201}
202/* END_CASE */
203
204
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200205/* BEGIN_CASE */
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500206void valid_parameters( )
207{
208 mbedtls_pk_context pk;
209 unsigned char buf[1];
210 size_t len;
211 void *options = NULL;
212
213 mbedtls_pk_init( &pk );
214
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500215 TEST_ASSERT( mbedtls_pk_setup( &pk, NULL ) ==
216 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
217
218 /* In informational functions, we accept NULL where a context pointer
219 * is expected because that's what the library has done forever.
220 * We do not document that NULL is accepted, so we may wish to change
221 * the behavior in a future version. */
222 TEST_ASSERT( mbedtls_pk_get_bitlen( NULL ) == 0 );
223 TEST_ASSERT( mbedtls_pk_get_len( NULL ) == 0 );
224 TEST_ASSERT( mbedtls_pk_can_do( NULL, MBEDTLS_PK_NONE ) == 0 );
225
226 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
227 MBEDTLS_MD_NONE,
228 NULL, 0,
229 buf, &len,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200230 mbedtls_test_rnd_std_rand, NULL,
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500231 NULL ) ==
232 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
233
234 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
235 MBEDTLS_MD_NONE,
236 NULL, 0,
237 buf, &len,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200238 mbedtls_test_rnd_std_rand, NULL,
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500239 NULL ) ==
240 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
241
242 TEST_ASSERT( mbedtls_pk_sign( &pk,
243 MBEDTLS_MD_NONE,
244 NULL, 0,
245 buf, &len,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200246 mbedtls_test_rnd_std_rand, NULL ) ==
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500247 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
248
249 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk,
250 MBEDTLS_MD_NONE,
251 NULL, 0,
252 buf, sizeof( buf ),
253 NULL ) ==
254 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
255
256 TEST_ASSERT( mbedtls_pk_verify( &pk,
257 MBEDTLS_MD_NONE,
258 NULL, 0,
259 buf, sizeof( buf ) ) ==
260 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
261
262 TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
263 &pk,
264 MBEDTLS_MD_NONE,
265 NULL, 0,
266 buf, sizeof( buf ) ) ==
267 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
268
269 TEST_ASSERT( mbedtls_pk_encrypt( &pk,
270 NULL, 0,
271 NULL, &len, 0,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200272 mbedtls_test_rnd_std_rand, NULL ) ==
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500273 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
274
275 TEST_ASSERT( mbedtls_pk_decrypt( &pk,
276 NULL, 0,
277 NULL, &len, 0,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200278 mbedtls_test_rnd_std_rand, NULL ) ==
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500279 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
280
281#if defined(MBEDTLS_PK_PARSE_C)
282 TEST_ASSERT( mbedtls_pk_parse_key( &pk, NULL, 0, NULL, 1 ) ==
283 MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
284
285 TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, NULL, 0 ) ==
286 MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
287#endif /* MBEDTLS_PK_PARSE_C */
288}
289/* END_CASE */
290
291/* BEGIN_CASE depends_on:MBEDTLS_PK_WRITE_C */
292void valid_parameters_pkwrite( data_t *key_data )
293{
294 mbedtls_pk_context pk;
295
296 /* For the write tests to be effective, we need a valid key pair. */
297 mbedtls_pk_init( &pk );
298 TEST_ASSERT( mbedtls_pk_parse_key( &pk,
299 key_data->x, key_data->len,
300 NULL, 0 ) == 0 );
301
302 TEST_ASSERT( mbedtls_pk_write_key_der( &pk, NULL, 0 ) ==
303 MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
304
305 TEST_ASSERT( mbedtls_pk_write_pubkey_der( &pk, NULL, 0 ) ==
306 MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
307
308#if defined(MBEDTLS_PEM_WRITE_C)
309 TEST_ASSERT( mbedtls_pk_write_key_pem( &pk, NULL, 0 ) ==
310 MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
311
312 TEST_ASSERT( mbedtls_pk_write_pubkey_pem( &pk, NULL, 0 ) ==
313 MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
314#endif /* MBEDTLS_PEM_WRITE_C */
315
316exit:
317 mbedtls_pk_free( &pk );
318}
319/* END_CASE */
320
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500321/* BEGIN_CASE */
Gilles Peskinee48fe552019-11-05 16:42:13 +0100322void pk_utils( int type, int parameter, int bitlen, int len, char * name )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200323{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200324 mbedtls_pk_context pk;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200325
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200326 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200327
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200328 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Gilles Peskinee48fe552019-11-05 16:42:13 +0100329 TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200330
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200331 TEST_ASSERT( (int) mbedtls_pk_get_type( &pk ) == type );
332 TEST_ASSERT( mbedtls_pk_can_do( &pk, type ) );
Gilles Peskinee48fe552019-11-05 16:42:13 +0100333 TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == (unsigned) bitlen );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200334 TEST_ASSERT( mbedtls_pk_get_len( &pk ) == (unsigned) len );
335 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200336
Paul Bakkerbd51b262014-07-10 15:26:12 +0200337exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200338 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200339}
340/* END_CASE */
341
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200342/* BEGIN_CASE depends_on:MBEDTLS_PK_PARSE_C:MBEDTLS_FS_IO */
Azim Khanf1aaec92017-05-30 14:23:15 +0100343void mbedtls_pk_check_pair( char * pub_file, char * prv_file, int ret )
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100344{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200345 mbedtls_pk_context pub, prv, alt;
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100346
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200347 mbedtls_pk_init( &pub );
348 mbedtls_pk_init( &prv );
349 mbedtls_pk_init( &alt );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100350
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200351 TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &pub, pub_file ) == 0 );
352 TEST_ASSERT( mbedtls_pk_parse_keyfile( &prv, prv_file, NULL ) == 0 );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100353
Manuel Pégourié-Gonnard39be1412021-06-15 11:29:26 +0200354 TEST_ASSERT( mbedtls_pk_check_pair( &pub, &prv,
355 mbedtls_test_rnd_std_rand, NULL )
356 == ret );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100357
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200358#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
359 if( mbedtls_pk_get_type( &prv ) == MBEDTLS_PK_RSA )
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100360 {
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200361 TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, mbedtls_pk_rsa( prv ),
Hanno Becker6ac972d2017-09-07 10:57:48 +0100362 mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
363 mbedtls_rsa_key_len_func ) == 0 );
Manuel Pégourié-Gonnard39be1412021-06-15 11:29:26 +0200364 TEST_ASSERT( mbedtls_pk_check_pair( &pub, &alt,
365 mbedtls_test_rnd_std_rand, NULL )
366 == ret );
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100367 }
Manuel Pégourié-Gonnard7c13d692014-11-12 00:01:34 +0100368#endif
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100369
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200370 mbedtls_pk_free( &pub );
371 mbedtls_pk_free( &prv );
372 mbedtls_pk_free( &alt );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100373}
374/* END_CASE */
375
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200376/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100377void pk_rsa_verify_test_vec( data_t * message_str, int digest, int mod,
Azim Khand30ca132017-06-09 04:32:58 +0100378 int radix_N, char * input_N, int radix_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100379 char * input_E, data_t * result_str,
Azim Khanf1aaec92017-05-30 14:23:15 +0100380 int result )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200381{
Ron Eldor58e3f692018-11-21 13:44:31 +0200382 unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200383 mbedtls_rsa_context *rsa;
384 mbedtls_pk_context pk;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200385 mbedtls_pk_restart_ctx *rs_ctx = NULL;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200386#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200387 mbedtls_pk_restart_ctx ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200388
389 rs_ctx = &ctx;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200390 mbedtls_pk_restart_init( rs_ctx );
Manuel Pégourié-Gonnard4edb9cb2018-07-02 12:23:23 +0200391 // this setting would ensure restart would happen if ECC was used
392 mbedtls_ecp_set_max_ops( 1 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200393#endif
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200394
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200395 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200396
Ron Eldor58e3f692018-11-21 13:44:31 +0200397 memset( hash_result, 0x00, MBEDTLS_MD_MAX_SIZE );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200398
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200399 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200400 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200401
Paul Bakker42099c32014-01-27 11:45:49 +0100402 rsa->len = mod / 8;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200403 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
404 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200405
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200406
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200407 if( mbedtls_md_info_from_type( digest ) != NULL )
Azim Khand30ca132017-06-09 04:32:58 +0100408 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 +0200409
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200410 TEST_ASSERT( mbedtls_pk_verify( &pk, digest, hash_result, 0,
Azim Khand30ca132017-06-09 04:32:58 +0100411 result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200412
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200413 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, digest, hash_result, 0,
Manuel Pégourié-Gonnard125af942018-09-11 11:08:12 +0200414 result_str->x, mbedtls_pk_get_len( &pk ), rs_ctx ) == result );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200415
Paul Bakkerbd51b262014-07-10 15:26:12 +0200416exit:
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200417#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200418 mbedtls_pk_restart_free( rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200419#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200420 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200421}
422/* END_CASE */
423
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200424/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100425void pk_rsa_verify_ext_test_vec( data_t * message_str, int digest,
Azim Khand30ca132017-06-09 04:32:58 +0100426 int mod, int radix_N, char * input_N,
427 int radix_E, char * input_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100428 data_t * result_str, int pk_type,
Azim Khanf1aaec92017-05-30 14:23:15 +0100429 int mgf1_hash_id, int salt_len, int result )
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200430{
Ron Eldor58e3f692018-11-21 13:44:31 +0200431 unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200432 mbedtls_rsa_context *rsa;
433 mbedtls_pk_context pk;
434 mbedtls_pk_rsassa_pss_options pss_opts;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200435 void *options;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200436 size_t hash_len;
437
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200438 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200439
Ron Eldor58e3f692018-11-21 13:44:31 +0200440 memset( hash_result, 0x00, sizeof( hash_result ) );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200441
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200442 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200443 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200444
445 rsa->len = mod / 8;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200446 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
447 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200448
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200449
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200450 if( digest != MBEDTLS_MD_NONE )
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200451 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200452 TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ),
Azim Khand30ca132017-06-09 04:32:58 +0100453 message_str->x, message_str->len, hash_result ) == 0 );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200454 hash_len = 0;
455 }
456 else
457 {
Azim Khand30ca132017-06-09 04:32:58 +0100458 memcpy( hash_result, message_str->x, message_str->len );
459 hash_len = message_str->len;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200460 }
461
462 if( mgf1_hash_id < 0 )
463 {
464 options = NULL;
465 }
466 else
467 {
468 options = &pss_opts;
469
470 pss_opts.mgf1_hash_id = mgf1_hash_id;
471 pss_opts.expected_salt_len = salt_len;
472 }
473
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200474 TEST_ASSERT( mbedtls_pk_verify_ext( pk_type, options, &pk,
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200475 digest, hash_result, hash_len,
Azim Khand30ca132017-06-09 04:32:58 +0100476 result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200477
Paul Bakkerbd51b262014-07-10 15:26:12 +0200478exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200479 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200480}
481/* END_CASE */
482
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200483/* BEGIN_CASE depends_on:MBEDTLS_ECDSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100484void pk_ec_test_vec( int type, int id, data_t * key, data_t * hash,
485 data_t * sig, int ret )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200486{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200487 mbedtls_pk_context pk;
488 mbedtls_ecp_keypair *eckey;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200489
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200490 mbedtls_pk_init( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100491 USE_PSA_INIT( );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200492
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200493 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200494
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200495 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) );
496 eckey = mbedtls_pk_ec( pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200497
Manuel Pégourié-Gonnarde3a062b2015-05-11 18:46:47 +0200498 TEST_ASSERT( mbedtls_ecp_group_load( &eckey->grp, id ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200499 TEST_ASSERT( mbedtls_ecp_point_read_binary( &eckey->grp, &eckey->Q,
Azim Khand30ca132017-06-09 04:32:58 +0100500 key->x, key->len ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200501
John Durkopd4efa8d2020-09-08 05:58:28 -0700502 // MBEDTLS_MD_NONE is used since it will be ignored.
503 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE,
Azim Khand30ca132017-06-09 04:32:58 +0100504 hash->x, hash->len, sig->x, sig->len ) == ret );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200505
Paul Bakkerbd51b262014-07-10 15:26:12 +0200506exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200507 mbedtls_pk_free( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100508 USE_PSA_DONE( );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200509}
510/* END_CASE */
511
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200512/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECDSA_C:MBEDTLS_ECDSA_DETERMINISTIC */
513void pk_sign_verify_restart( int pk_type, int grp_id, char *d_str,
514 char *QX_str, char *QY_str,
Ronald Cron9ed40732020-06-25 09:03:34 +0200515 int md_alg, char *msg, data_t *sig_check,
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200516 int max_ops, int min_restart, int max_restart )
517{
518 int ret, cnt_restart;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200519 mbedtls_pk_restart_ctx rs_ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200520 mbedtls_pk_context prv, pub;
521 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
522 unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
Ronald Cron9ed40732020-06-25 09:03:34 +0200523 size_t hlen, slen;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200524 const mbedtls_md_info_t *md_info;
525
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200526 mbedtls_pk_restart_init( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200527 mbedtls_pk_init( &prv );
528 mbedtls_pk_init( &pub );
529 memset( hash, 0, sizeof( hash ) );
530 memset( sig, 0, sizeof( sig ) );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200531
532 TEST_ASSERT( mbedtls_pk_setup( &prv, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
533 TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( prv )->grp, grp_id ) == 0 );
534 TEST_ASSERT( mbedtls_mpi_read_string( &mbedtls_pk_ec( prv )->d, 16, d_str ) == 0 );
535
536 TEST_ASSERT( mbedtls_pk_setup( &pub, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
537 TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( pub )->grp, grp_id ) == 0 );
538 TEST_ASSERT( mbedtls_ecp_point_read_string( &mbedtls_pk_ec( pub )->Q, 16, QX_str, QY_str ) == 0 );
539
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200540 md_info = mbedtls_md_info_from_type( md_alg );
541 TEST_ASSERT( md_info != NULL );
542
543 hlen = mbedtls_md_get_size( md_info );
Gilles Peskine84984ae2020-01-21 16:52:08 +0100544 TEST_ASSERT( mbedtls_md( md_info,
545 (const unsigned char *) msg, strlen( msg ),
546 hash ) == 0 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200547
548 mbedtls_ecp_set_max_ops( max_ops );
549
550 slen = sizeof( sig );
551 cnt_restart = 0;
552 do {
553 ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
TRodziewicz0bc39382021-04-30 14:18:06 +0200554 sig, &slen, mbedtls_test_rnd_std_rand,
TRodziewicz8223cce2021-04-30 13:32:15 +0200555 NULL, &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200556 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
557
558 TEST_ASSERT( ret == 0 );
Ronald Cron9ed40732020-06-25 09:03:34 +0200559 TEST_ASSERT( slen == sig_check->len );
560 TEST_ASSERT( memcmp( sig, sig_check->x, slen ) == 0 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200561
562 TEST_ASSERT( cnt_restart >= min_restart );
563 TEST_ASSERT( cnt_restart <= max_restart );
564
565 cnt_restart = 0;
566 do {
567 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
568 hash, hlen, sig, slen, &rs_ctx );
569 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
570
571 TEST_ASSERT( ret == 0 );
572 TEST_ASSERT( cnt_restart >= min_restart );
573 TEST_ASSERT( cnt_restart <= max_restart );
574
575 hash[0]++;
576 do {
577 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
578 hash, hlen, sig, slen, &rs_ctx );
579 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
580 TEST_ASSERT( ret != 0 );
581 hash[0]--;
582
583 sig[0]++;
584 do {
585 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
586 hash, hlen, sig, slen, &rs_ctx );
587 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
588 TEST_ASSERT( ret != 0 );
589 sig[0]--;
590
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200591 /* Do we leak memory when aborting? try verify then sign
592 * This test only makes sense when we actually restart */
593 if( min_restart > 0 )
594 {
595 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
596 hash, hlen, sig, slen, &rs_ctx );
597 TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
598 mbedtls_pk_restart_free( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200599
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200600 slen = sizeof( sig );
601 ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
TRodziewicz0bc39382021-04-30 14:18:06 +0200602 sig, &slen, mbedtls_test_rnd_std_rand,
TRodziewicz8223cce2021-04-30 13:32:15 +0200603 NULL, &rs_ctx );
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200604 TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
605 }
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200606
607exit:
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200608 mbedtls_pk_restart_free( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200609 mbedtls_pk_free( &prv );
610 mbedtls_pk_free( &pub );
611}
612/* END_CASE */
613
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200614/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
Gilles Peskinee48fe552019-11-05 16:42:13 +0100615void pk_sign_verify( int type, int parameter, int sign_ret, int verify_ret )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200616{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200617 mbedtls_pk_context pk;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200618 size_t sig_len;
Gilles Peskineeba088a2019-11-05 16:32:32 +0100619 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
620 unsigned char sig[MBEDTLS_PK_SIGNATURE_MAX_SIZE];
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200621 void *rs_ctx = NULL;
622#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200623 mbedtls_pk_restart_ctx ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200624
625 rs_ctx = &ctx;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200626 mbedtls_pk_restart_init( rs_ctx );
Manuel Pégourié-Gonnard4edb9cb2018-07-02 12:23:23 +0200627 /* This value is large enough that the operation will complete in one run.
628 * See comments at the top of ecp_test_vect_restart in
629 * test_suite_ecp.function for estimates of operation counts. */
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200630 mbedtls_ecp_set_max_ops( 42000 );
631#endif
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200632
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200633 mbedtls_pk_init( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100634 USE_PSA_INIT( );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200635
636 memset( hash, 0x2a, sizeof hash );
637 memset( sig, 0, sizeof sig );
638
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200639 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Gilles Peskinee48fe552019-11-05 16:42:13 +0100640 TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200641
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200642 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_SHA256,
643 hash, sizeof hash, sig, &sig_len,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200644 mbedtls_test_rnd_std_rand, NULL, rs_ctx ) == sign_ret );
Gilles Peskineeba088a2019-11-05 16:32:32 +0100645 if( sign_ret == 0 )
646 TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
647 else
Gilles Peskinef85e4e62019-11-12 11:08:23 +0100648 sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200649
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200650 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200651 hash, sizeof hash, sig, sig_len ) == verify_ret );
652
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200653 if( verify_ret == 0 )
654 {
655 hash[0]++;
656 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
657 hash, sizeof hash, sig, sig_len ) != 0 );
658 hash[0]--;
659
660 sig[0]++;
661 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
662 hash, sizeof hash, sig, sig_len ) != 0 );
663 sig[0]--;
664 }
665
666 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256, hash, sizeof hash,
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200667 sig, &sig_len,
668 mbedtls_test_rnd_std_rand,
669 NULL ) == sign_ret );
Gilles Peskineeba088a2019-11-05 16:32:32 +0100670 if( sign_ret == 0 )
671 TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
672 else
Gilles Peskinef85e4e62019-11-12 11:08:23 +0100673 sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200674
675 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
676 hash, sizeof hash, sig, sig_len, rs_ctx ) == verify_ret );
677
678 if( verify_ret == 0 )
679 {
680 hash[0]++;
681 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
682 hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
683 hash[0]--;
684
685 sig[0]++;
686 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
687 hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
688 sig[0]--;
689 }
690
Paul Bakkerbd51b262014-07-10 15:26:12 +0200691exit:
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200692#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200693 mbedtls_pk_restart_free( rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200694#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200695 mbedtls_pk_free( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100696 USE_PSA_DONE( );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200697}
698/* END_CASE */
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200699
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200700/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100701void pk_rsa_encrypt_test_vec( data_t * message, int mod, int radix_N,
Azim Khand30ca132017-06-09 04:32:58 +0100702 char * input_N, int radix_E, char * input_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100703 data_t * result, int ret )
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200704{
Ron Eldor58e3f692018-11-21 13:44:31 +0200705 unsigned char output[300];
Ronald Cron351f0ee2020-06-10 12:12:18 +0200706 mbedtls_test_rnd_pseudo_info rnd_info;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200707 mbedtls_rsa_context *rsa;
708 mbedtls_pk_context pk;
Azim Khanf1aaec92017-05-30 14:23:15 +0100709 size_t olen;
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200710
Ronald Cron351f0ee2020-06-10 12:12:18 +0200711 memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200712 memset( output, 0, sizeof( output ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200713
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200714
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200715 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200716 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200717 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200718
719 rsa->len = mod / 8;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200720 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
721 TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200722
Azim Khand30ca132017-06-09 04:32:58 +0100723 TEST_ASSERT( mbedtls_pk_encrypt( &pk, message->x, message->len,
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200724 output, &olen, sizeof( output ),
725 mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
Azim Khand30ca132017-06-09 04:32:58 +0100726 TEST_ASSERT( olen == result->len );
727 TEST_ASSERT( memcmp( output, result->x, olen ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200728
Paul Bakkerbd51b262014-07-10 15:26:12 +0200729exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200730 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200731}
732/* END_CASE */
733
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200734/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100735void pk_rsa_decrypt_test_vec( data_t * cipher, int mod, int radix_P,
Azim Khand30ca132017-06-09 04:32:58 +0100736 char * input_P, int radix_Q, char * input_Q,
737 int radix_N, char * input_N, int radix_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100738 char * input_E, data_t * clear, int ret )
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200739{
Ron Eldor58e3f692018-11-21 13:44:31 +0200740 unsigned char output[256];
Ronald Cron351f0ee2020-06-10 12:12:18 +0200741 mbedtls_test_rnd_pseudo_info rnd_info;
Hanno Beckerd71dc152017-08-23 06:32:42 +0100742 mbedtls_mpi N, P, Q, E;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200743 mbedtls_rsa_context *rsa;
744 mbedtls_pk_context pk;
Azim Khanf1aaec92017-05-30 14:23:15 +0100745 size_t olen;
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200746
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200747 mbedtls_pk_init( &pk );
Hanno Beckerd71dc152017-08-23 06:32:42 +0100748 mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
749 mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200750
Ronald Cron351f0ee2020-06-10 12:12:18 +0200751 memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200752
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200753
754 /* init pk-rsa context */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200755 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200756 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200757
758 /* load public key */
Hanno Beckerd71dc152017-08-23 06:32:42 +0100759 TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
760 TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200761
762 /* load private key */
Hanno Beckerd71dc152017-08-23 06:32:42 +0100763 TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
764 TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
765 TEST_ASSERT( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ) == 0 );
766 TEST_ASSERT( mbedtls_rsa_get_len( rsa ) == (size_t) ( mod / 8 ) );
Hanno Becker7f25f852017-10-10 16:56:22 +0100767 TEST_ASSERT( mbedtls_rsa_complete( rsa ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200768
769 /* decryption test */
770 memset( output, 0, sizeof( output ) );
771 olen = 0;
Azim Khand30ca132017-06-09 04:32:58 +0100772 TEST_ASSERT( mbedtls_pk_decrypt( &pk, cipher->x, cipher->len,
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200773 output, &olen, sizeof( output ),
774 mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200775 if( ret == 0 )
776 {
Azim Khand30ca132017-06-09 04:32:58 +0100777 TEST_ASSERT( olen == clear->len );
778 TEST_ASSERT( memcmp( output, clear->x, olen ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200779 }
780
Paul Bakkerbd51b262014-07-10 15:26:12 +0200781exit:
Hanno Beckerd71dc152017-08-23 06:32:42 +0100782 mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
783 mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200784 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200785}
786/* END_CASE */
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200787
788/* BEGIN_CASE */
789void pk_ec_nocrypt( int type )
790{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200791 mbedtls_pk_context pk;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200792 unsigned char output[100];
793 unsigned char input[100];
Ronald Cron351f0ee2020-06-10 12:12:18 +0200794 mbedtls_test_rnd_pseudo_info rnd_info;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200795 size_t olen = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200796 int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200797
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200798 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200799
Ronald Cron351f0ee2020-06-10 12:12:18 +0200800 memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200801 memset( output, 0, sizeof( output ) );
802 memset( input, 0, sizeof( input ) );
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é-Gonnard75c78822013-10-17 12:46:39 +0200805
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200806 TEST_ASSERT( mbedtls_pk_encrypt( &pk, input, sizeof( input ),
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200807 output, &olen, sizeof( output ),
808 mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200809
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200810 TEST_ASSERT( mbedtls_pk_decrypt( &pk, input, sizeof( input ),
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200811 output, &olen, sizeof( output ),
812 mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200813
Paul Bakkerbd51b262014-07-10 15:26:12 +0200814exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200815 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200816}
817/* END_CASE */
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200818
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +0100819/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Andres AG5c79d252017-02-15 10:52:32 +0000820void pk_rsa_overflow( )
821{
822 mbedtls_pk_context pk;
itayzafrir693a1d92018-02-26 12:02:10 +0200823 size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX;
824 unsigned char hash[50], sig[100];
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +0100825
826 if( SIZE_MAX <= UINT_MAX )
827 return;
Andres AG5c79d252017-02-15 10:52:32 +0000828
itayzafrir693a1d92018-02-26 12:02:10 +0200829 memset( hash, 0x2a, sizeof hash );
830 memset( sig, 0, sizeof sig );
Andres AG5c79d252017-02-15 10:52:32 +0000831
832 mbedtls_pk_init( &pk );
833
834 TEST_ASSERT( mbedtls_pk_setup( &pk,
835 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
836
837#if defined(MBEDTLS_PKCS1_V21)
838 TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_RSASSA_PSS, NULL, &pk,
itayzafrir693a1d92018-02-26 12:02:10 +0200839 MBEDTLS_MD_NONE, hash, hash_len, sig, sig_len ) ==
Andres AG5c79d252017-02-15 10:52:32 +0000840 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
841#endif /* MBEDTLS_PKCS1_V21 */
842
itayzafrir693a1d92018-02-26 12:02:10 +0200843 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE, hash, hash_len,
844 sig, sig_len ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres AG5c79d252017-02-15 10:52:32 +0000845
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200846 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, hash, hash_len, sig,
847 &sig_len, mbedtls_test_rnd_std_rand, NULL )
848 == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres AG5c79d252017-02-15 10:52:32 +0000849
850exit:
851 mbedtls_pk_free( &pk );
852}
853/* END_CASE */
854
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200855/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_PK_RSA_ALT_SUPPORT */
Azim Khanf1aaec92017-05-30 14:23:15 +0100856void pk_rsa_alt( )
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200857{
858 /*
859 * An rsa_alt context can only do private operations (decrypt, sign).
860 * Test it against the public operations (encrypt, verify) of a
861 * corresponding rsa context.
862 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200863 mbedtls_rsa_context raw;
864 mbedtls_pk_context rsa, alt;
865 mbedtls_pk_debug_item dbg_items[10];
Ron Eldor58e3f692018-11-21 13:44:31 +0200866 unsigned char hash[50], sig[64];
867 unsigned char msg[50], ciph[64], test[50];
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200868 size_t sig_len, ciph_len, test_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200869 int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200870
Ronald Cronc1905a12021-06-05 11:11:14 +0200871 mbedtls_rsa_init( &raw );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200872 mbedtls_pk_init( &rsa ); mbedtls_pk_init( &alt );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200873
874 memset( hash, 0x2a, sizeof hash );
875 memset( sig, 0, sizeof sig );
876 memset( msg, 0x2a, sizeof msg );
877 memset( ciph, 0, sizeof ciph );
878 memset( test, 0, sizeof test );
879
880 /* Initiliaze PK RSA context with random key */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200881 TEST_ASSERT( mbedtls_pk_setup( &rsa,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200882 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Gilles Peskinee48fe552019-11-05 16:42:13 +0100883 TEST_ASSERT( pk_genkey( &rsa, RSA_KEY_SIZE ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200884
885 /* Extract key to the raw rsa context */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200886 TEST_ASSERT( mbedtls_rsa_copy( &raw, mbedtls_pk_rsa( rsa ) ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200887
888 /* Initialize PK RSA_ALT context */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200889 TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, (void *) &raw,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200890 mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200891
892 /* Test administrative functions */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200893 TEST_ASSERT( mbedtls_pk_can_do( &alt, MBEDTLS_PK_RSA ) );
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +0200894 TEST_ASSERT( mbedtls_pk_get_bitlen( &alt ) == RSA_KEY_SIZE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200895 TEST_ASSERT( mbedtls_pk_get_len( &alt ) == RSA_KEY_LEN );
896 TEST_ASSERT( mbedtls_pk_get_type( &alt ) == MBEDTLS_PK_RSA_ALT );
897 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &alt ), "RSA-alt" ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200898
899 /* Test signature */
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +0100900#if SIZE_MAX > UINT_MAX
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200901 TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, SIZE_MAX, sig,
902 &sig_len, mbedtls_test_rnd_std_rand, NULL )
903 == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +0100904#endif /* SIZE_MAX > UINT_MAX */
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200905 TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, sizeof hash, sig,
906 &sig_len, mbedtls_test_rnd_std_rand, NULL )
907 == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200908 TEST_ASSERT( sig_len == RSA_KEY_LEN );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200909 TEST_ASSERT( mbedtls_pk_verify( &rsa, MBEDTLS_MD_NONE,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200910 hash, sizeof hash, sig, sig_len ) == 0 );
911
912 /* Test decrypt */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200913 TEST_ASSERT( mbedtls_pk_encrypt( &rsa, msg, sizeof msg,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200914 ciph, &ciph_len, sizeof ciph,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200915 mbedtls_test_rnd_std_rand, NULL ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200916 TEST_ASSERT( mbedtls_pk_decrypt( &alt, ciph, ciph_len,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200917 test, &test_len, sizeof test,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200918 mbedtls_test_rnd_std_rand, NULL ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200919 TEST_ASSERT( test_len == sizeof msg );
920 TEST_ASSERT( memcmp( test, msg, test_len ) == 0 );
921
922 /* Test forbidden operations */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200923 TEST_ASSERT( mbedtls_pk_encrypt( &alt, msg, sizeof msg,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200924 ciph, &ciph_len, sizeof ciph,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200925 mbedtls_test_rnd_std_rand, NULL ) == ret );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200926 TEST_ASSERT( mbedtls_pk_verify( &alt, MBEDTLS_MD_NONE,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200927 hash, sizeof hash, sig, sig_len ) == ret );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200928 TEST_ASSERT( mbedtls_pk_debug( &alt, dbg_items ) == ret );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200929
Paul Bakkerbd51b262014-07-10 15:26:12 +0200930exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200931 mbedtls_rsa_free( &raw );
932 mbedtls_pk_free( &rsa ); mbedtls_pk_free( &alt );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +0200933}
934/* END_CASE */
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +0100935
Gilles Peskine33b1c692019-12-19 00:09:47 +0100936/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_ECDSA_C */
937void pk_psa_sign( int grpid_arg,
938 int psa_curve_arg, int expected_bits_arg )
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +0100939{
Gilles Peskine33b1c692019-12-19 00:09:47 +0100940 mbedtls_ecp_group_id grpid = grpid_arg;
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +0100941 mbedtls_pk_context pk;
Gilles Peskine33b1c692019-12-19 00:09:47 +0100942 unsigned char hash[32];
943 unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
944 unsigned char pkey_legacy[200];
945 unsigned char pkey_psa[200];
Hanno Becker56104ea2019-02-01 11:48:19 +0000946 unsigned char *pkey_legacy_start, *pkey_psa_start;
947 size_t sig_len, klen_legacy, klen_psa;
948 int ret;
Ronald Cron5425a212020-08-04 14:58:35 +0200949 mbedtls_svc_key_id_t key_id;
Gilles Peskine85f47c92019-12-18 20:44:15 +0100950 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine33b1c692019-12-19 00:09:47 +0100951 psa_key_type_t expected_type = PSA_KEY_TYPE_ECC_KEY_PAIR( psa_curve_arg );
952 size_t expected_bits = expected_bits_arg;
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +0100953
954 /*
955 * This tests making signatures with a wrapped PSA key:
Hanno Becker56104ea2019-02-01 11:48:19 +0000956 * - generate a fresh ECP legacy PK context
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +0100957 * - wrap it in a PK context and make a signature this way
958 * - extract the public key
959 * - parse it to a PK context and verify the signature this way
960 */
961
Gilles Peskine5386f6b2019-08-01 12:47:40 +0200962 PSA_ASSERT( psa_crypto_init( ) );
963
Hanno Becker56104ea2019-02-01 11:48:19 +0000964 /* Create legacy EC public/private key in PK context. */
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +0100965 mbedtls_pk_init( &pk );
Hanno Becker56104ea2019-02-01 11:48:19 +0000966 TEST_ASSERT( mbedtls_pk_setup( &pk,
967 mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
Gilles Peskine85f47c92019-12-18 20:44:15 +0100968 TEST_ASSERT( mbedtls_ecp_gen_key( grpid,
Hanno Becker56104ea2019-02-01 11:48:19 +0000969 (mbedtls_ecp_keypair*) pk.pk_ctx,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200970 mbedtls_test_rnd_std_rand, NULL ) == 0 );
Hanno Becker56104ea2019-02-01 11:48:19 +0000971
972 /* Export underlying public key for re-importing in a legacy context. */
973 ret = mbedtls_pk_write_pubkey_der( &pk, pkey_legacy,
974 sizeof( pkey_legacy ) );
975 TEST_ASSERT( ret >= 0 );
976 klen_legacy = (size_t) ret;
977 /* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
978 pkey_legacy_start = pkey_legacy + sizeof( pkey_legacy ) - klen_legacy;
979
980 /* Turn PK context into an opaque one. */
Ronald Cron5425a212020-08-04 14:58:35 +0200981 TEST_ASSERT( mbedtls_pk_wrap_as_opaque( &pk, &key_id,
Hanno Becker56104ea2019-02-01 11:48:19 +0000982 PSA_ALG_SHA_256 ) == 0 );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +0100983
Ronald Cron5425a212020-08-04 14:58:35 +0200984 PSA_ASSERT( psa_get_key_attributes( key_id, &attributes ) );
Gilles Peskine33b1c692019-12-19 00:09:47 +0100985 TEST_EQUAL( psa_get_key_type( &attributes ), expected_type );
Gilles Peskine85f47c92019-12-18 20:44:15 +0100986 TEST_EQUAL( psa_get_key_bits( &attributes ), expected_bits );
987 TEST_EQUAL( psa_get_key_lifetime( &attributes ),
988 PSA_KEY_LIFETIME_VOLATILE );
989
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +0100990 memset( hash, 0x2a, sizeof hash );
991 memset( sig, 0, sizeof sig );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +0100992
993 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256,
994 hash, sizeof hash, sig, &sig_len,
995 NULL, NULL ) == 0 );
996
Hanno Becker56104ea2019-02-01 11:48:19 +0000997 /* Export underlying public key for re-importing in a psa context. */
998 ret = mbedtls_pk_write_pubkey_der( &pk, pkey_psa,
999 sizeof( pkey_psa ) );
1000 TEST_ASSERT( ret >= 0 );
1001 klen_psa = (size_t) ret;
1002 /* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
1003 pkey_psa_start = pkey_psa + sizeof( pkey_psa ) - klen_psa;
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001004
Hanno Becker56104ea2019-02-01 11:48:19 +00001005 TEST_ASSERT( klen_psa == klen_legacy );
1006 TEST_ASSERT( memcmp( pkey_psa_start, pkey_legacy_start, klen_psa ) == 0 );
1007
1008 mbedtls_pk_free( &pk );
Ronald Cron5425a212020-08-04 14:58:35 +02001009 TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key_id ) );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001010
1011 mbedtls_pk_init( &pk );
Hanno Becker56104ea2019-02-01 11:48:19 +00001012 TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, pkey_legacy_start,
1013 klen_legacy ) == 0 );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001014 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
1015 hash, sizeof hash, sig, sig_len ) == 0 );
1016
1017exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001018 /*
1019 * Key attributes may have been returned by psa_get_key_attributes()
1020 * thus reset them as required.
1021 */
1022 psa_reset_key_attributes( &attributes );
1023
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001024 mbedtls_pk_free( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +01001025 USE_PSA_DONE( );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001026}
1027/* END_CASE */