blob: 7587d6cf2bd1c452615217defbea36920d3321af [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
Dave Rodgman017a1992022-03-31 14:07:01 +010015 * unconditionally (https://github.com/Mbed-TLS/mbedtls/issues/2023). */
Gilles Peskine33b1c692019-12-19 00:09:47 +010016#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/*
Neil Armstrong0cd78dd2022-03-15 14:20:20 +010091 * Generate an ECC 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 */
Neil Armstrong0cd78dd2022-03-15 14:20:20 +010095mbedtls_svc_key_id_t pk_psa_genkey_ecc( 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}
Neil Armstrong0cd78dd2022-03-15 14:20:20 +0100112
113/*
114 * Generate an RSA key using PSA and return the key identifier of that key,
115 * or 0 if the key generation failed.
116 */
117mbedtls_svc_key_id_t pk_psa_genkey_rsa( void )
118{
119 mbedtls_svc_key_id_t key;
120 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
121 const psa_key_type_t type = PSA_KEY_TYPE_RSA_KEY_PAIR;
Neil Armstrongcb874032022-04-08 15:14:40 +0200122 const size_t bits = 1024;
Neil Armstrong0cd78dd2022-03-15 14:20:20 +0100123
124 psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
125 psa_set_key_algorithm( &attributes, PSA_ALG_RSA_PKCS1V15_SIGN_RAW );
126 psa_set_key_type( &attributes, type );
127 psa_set_key_bits( &attributes, bits );
128 PSA_ASSERT( psa_generate_key( &attributes, &key ) );
129
130exit:
131 return( key );
132}
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100133#endif /* MBEDTLS_USE_PSA_CRYPTO */
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200134/* END_HEADER */
135
136/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200137 * depends_on:MBEDTLS_PK_C
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200138 * END_DEPENDENCIES
139 */
140
Neil Armstrong0cd78dd2022-03-15 14:20:20 +0100141/* BEGIN_CASE depends_on:MBEDTLS_USE_PSA_CRYPTO */
142void pk_psa_utils( int key_is_rsa )
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100143{
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100144 mbedtls_pk_context pk, pk2;
Ronald Cron5425a212020-08-04 14:58:35 +0200145 mbedtls_svc_key_id_t key;
Gilles Peskined2d45c12019-05-27 14:53:13 +0200146 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100147
Manuel Pégourié-Gonnard69baf702018-11-06 09:34:30 +0100148 const char * const name = "Opaque";
Neil Armstrongcb874032022-04-08 15:14:40 +0200149 size_t bitlen;
Manuel Pégourié-Gonnard0184b3c2018-10-31 10:36:51 +0100150
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100151 mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
152 unsigned char b1[1], b2[1];
153 size_t len;
154 mbedtls_pk_debug_item dbg;
155
Gilles Peskine5386f6b2019-08-01 12:47:40 +0200156 PSA_ASSERT( psa_crypto_init( ) );
Jaeden Amero3ea26872019-02-13 11:30:22 +0000157
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100158 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100159 mbedtls_pk_init( &pk2 );
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100160
Gilles Peskine614faa22019-06-07 15:39:07 +0200161 TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
Gilles Peskine69c0ea22019-06-07 15:38:59 +0200162
Ronald Cron5425a212020-08-04 14:58:35 +0200163 TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, MBEDTLS_SVC_KEY_ID_INIT ) ==
Manuel Pégourié-Gonnard920c0632018-10-31 10:57:29 +0100164 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
165
166 mbedtls_pk_free( &pk );
167 mbedtls_pk_init( &pk );
168
Neil Armstrong0cd78dd2022-03-15 14:20:20 +0100169 if( key_is_rsa )
Neil Armstrongcb874032022-04-08 15:14:40 +0200170 {
Andrzej Kurek5c65c572022-04-13 14:28:52 -0400171 bitlen = 1024; /* hardcoded in genkey() */
Neil Armstrong0cd78dd2022-03-15 14:20:20 +0100172 key = pk_psa_genkey_rsa();
Neil Armstrongcb874032022-04-08 15:14:40 +0200173 }
Neil Armstrong0cd78dd2022-03-15 14:20:20 +0100174 else
Neil Armstrongcb874032022-04-08 15:14:40 +0200175 {
Andrzej Kurek5c65c572022-04-13 14:28:52 -0400176 bitlen = 256; /* hardcoded in genkey() */
Neil Armstrong0cd78dd2022-03-15 14:20:20 +0100177 key = pk_psa_genkey_ecc();
Neil Armstrongcb874032022-04-08 15:14:40 +0200178 }
Ronald Cron5425a212020-08-04 14:58:35 +0200179 if( mbedtls_svc_key_id_is_null( key ) )
Gilles Peskined2d45c12019-05-27 14:53:13 +0200180 goto exit;
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100181
Manuel Pégourié-Gonnard69baf702018-11-06 09:34:30 +0100182 TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, key ) == 0 );
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100183
Manuel Pégourié-Gonnard69baf702018-11-06 09:34:30 +0100184 TEST_ASSERT( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_OPAQUE );
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100185 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
186
Manuel Pégourié-Gonnard0184b3c2018-10-31 10:36:51 +0100187 TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == bitlen );
188 TEST_ASSERT( mbedtls_pk_get_len( &pk ) == bitlen / 8 );
189
Neil Armstrong0cd78dd2022-03-15 14:20:20 +0100190 if( key_is_rsa )
191 {
192 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECKEY ) == 0 );
193 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) == 0 );
194 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_RSA ) == 1 );
195 }
196 else
197 {
198 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECKEY ) == 1 );
199 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) == 1 );
200 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_RSA ) == 0 );
201 }
Manuel Pégourié-Gonnard920c0632018-10-31 10:57:29 +0100202
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100203 /* unsupported operations: verify, decrypt, encrypt */
204 TEST_ASSERT( mbedtls_pk_verify( &pk, md_alg,
205 b1, sizeof( b1), b2, sizeof( b2 ) )
206 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
Neil Armstrongb32ae722022-04-22 15:02:47 +0200207 if( key_is_rsa == 0 )
208 {
209 TEST_ASSERT( mbedtls_pk_decrypt( &pk, b1, sizeof( b1 ),
210 b2, &len, sizeof( b2 ),
211 NULL, NULL )
212 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
213 }
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100214 TEST_ASSERT( mbedtls_pk_encrypt( &pk, b1, sizeof( b1 ),
215 b2, &len, sizeof( b2 ),
216 NULL, NULL )
217 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
218
219 /* unsupported functions: check_pair, debug */
Neil Armstrong0cd78dd2022-03-15 14:20:20 +0100220 if( key_is_rsa )
221 TEST_ASSERT( mbedtls_pk_setup( &pk2,
222 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
223 else
224 TEST_ASSERT( mbedtls_pk_setup( &pk2,
225 mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
Manuel Pégourié-Gonnard39be1412021-06-15 11:29:26 +0200226 TEST_ASSERT( mbedtls_pk_check_pair( &pk, &pk2,
227 mbedtls_test_rnd_std_rand, NULL )
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100228 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
229 TEST_ASSERT( mbedtls_pk_debug( &pk, &dbg )
230 == MBEDTLS_ERR_PK_TYPE_MISMATCH );
231
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100232 /* test that freeing the context does not destroy the key */
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100233 mbedtls_pk_free( &pk );
Gilles Peskined2d45c12019-05-27 14:53:13 +0200234 TEST_ASSERT( PSA_SUCCESS == psa_get_key_attributes( key, &attributes ) );
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100235 TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key ) );
236
237exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +0100238 /*
239 * Key attributes may have been returned by psa_get_key_attributes()
240 * thus reset them as required.
241 */
242 psa_reset_key_attributes( &attributes );
243
Manuel Pégourié-Gonnard01a12c42018-10-31 10:28:01 +0100244 mbedtls_pk_free( &pk ); /* redundant except upon error */
Manuel Pégourié-Gonnardd97390e2018-10-31 11:14:36 +0100245 mbedtls_pk_free( &pk2 );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100246 USE_PSA_DONE( );
Manuel Pégourié-Gonnard7b5fe042018-10-31 09:57:45 +0100247}
248/* END_CASE */
249
250
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200251/* BEGIN_CASE */
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500252void valid_parameters( )
253{
254 mbedtls_pk_context pk;
255 unsigned char buf[1];
256 size_t len;
257 void *options = NULL;
258
259 mbedtls_pk_init( &pk );
260
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500261 TEST_ASSERT( mbedtls_pk_setup( &pk, NULL ) ==
262 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
263
264 /* In informational functions, we accept NULL where a context pointer
265 * is expected because that's what the library has done forever.
266 * We do not document that NULL is accepted, so we may wish to change
267 * the behavior in a future version. */
268 TEST_ASSERT( mbedtls_pk_get_bitlen( NULL ) == 0 );
269 TEST_ASSERT( mbedtls_pk_get_len( NULL ) == 0 );
270 TEST_ASSERT( mbedtls_pk_can_do( NULL, MBEDTLS_PK_NONE ) == 0 );
271
272 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
273 MBEDTLS_MD_NONE,
274 NULL, 0,
Gilles Peskinef00f1522021-06-22 00:09:00 +0200275 buf, sizeof( buf ), &len,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200276 mbedtls_test_rnd_std_rand, NULL,
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500277 NULL ) ==
278 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
279
280 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
281 MBEDTLS_MD_NONE,
282 NULL, 0,
Gilles Peskinef00f1522021-06-22 00:09:00 +0200283 buf, sizeof( buf ), &len,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200284 mbedtls_test_rnd_std_rand, NULL,
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500285 NULL ) ==
286 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
287
288 TEST_ASSERT( mbedtls_pk_sign( &pk,
289 MBEDTLS_MD_NONE,
290 NULL, 0,
Gilles Peskinef00f1522021-06-22 00:09:00 +0200291 buf, sizeof( buf ), &len,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200292 mbedtls_test_rnd_std_rand, NULL ) ==
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500293 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
294
295 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk,
296 MBEDTLS_MD_NONE,
297 NULL, 0,
298 buf, sizeof( buf ),
299 NULL ) ==
300 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
301
302 TEST_ASSERT( mbedtls_pk_verify( &pk,
303 MBEDTLS_MD_NONE,
304 NULL, 0,
305 buf, sizeof( buf ) ) ==
306 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
307
308 TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
309 &pk,
310 MBEDTLS_MD_NONE,
311 NULL, 0,
312 buf, sizeof( buf ) ) ==
313 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
314
315 TEST_ASSERT( mbedtls_pk_encrypt( &pk,
316 NULL, 0,
317 NULL, &len, 0,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200318 mbedtls_test_rnd_std_rand, NULL ) ==
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500319 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
320
321 TEST_ASSERT( mbedtls_pk_decrypt( &pk,
322 NULL, 0,
323 NULL, &len, 0,
Ronald Cron351f0ee2020-06-10 12:12:18 +0200324 mbedtls_test_rnd_std_rand, NULL ) ==
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500325 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
326
327#if defined(MBEDTLS_PK_PARSE_C)
Manuel Pégourié-Gonnard84dea012021-06-15 11:29:26 +0200328 TEST_ASSERT( mbedtls_pk_parse_key( &pk, NULL, 0, NULL, 1,
329 mbedtls_test_rnd_std_rand, NULL ) ==
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500330 MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
331
332 TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, NULL, 0 ) ==
333 MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
334#endif /* MBEDTLS_PK_PARSE_C */
335}
336/* END_CASE */
337
338/* BEGIN_CASE depends_on:MBEDTLS_PK_WRITE_C */
339void valid_parameters_pkwrite( data_t *key_data )
340{
341 mbedtls_pk_context pk;
342
343 /* For the write tests to be effective, we need a valid key pair. */
344 mbedtls_pk_init( &pk );
345 TEST_ASSERT( mbedtls_pk_parse_key( &pk,
Manuel Pégourié-Gonnard84dea012021-06-15 11:29:26 +0200346 key_data->x, key_data->len, NULL, 0,
347 mbedtls_test_rnd_std_rand, NULL ) == 0 );
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500348
349 TEST_ASSERT( mbedtls_pk_write_key_der( &pk, NULL, 0 ) ==
350 MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
351
352 TEST_ASSERT( mbedtls_pk_write_pubkey_der( &pk, NULL, 0 ) ==
353 MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
354
355#if defined(MBEDTLS_PEM_WRITE_C)
356 TEST_ASSERT( mbedtls_pk_write_key_pem( &pk, NULL, 0 ) ==
357 MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
358
359 TEST_ASSERT( mbedtls_pk_write_pubkey_pem( &pk, NULL, 0 ) ==
360 MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
361#endif /* MBEDTLS_PEM_WRITE_C */
362
363exit:
364 mbedtls_pk_free( &pk );
365}
366/* END_CASE */
367
Andrzej Kurekc470b6b2019-01-31 08:20:20 -0500368/* BEGIN_CASE */
Gilles Peskinee48fe552019-11-05 16:42:13 +0100369void pk_utils( int type, int parameter, int bitlen, int len, char * name )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200370{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200371 mbedtls_pk_context pk;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200372
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200373 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200374
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200375 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Gilles Peskinee48fe552019-11-05 16:42:13 +0100376 TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200377
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200378 TEST_ASSERT( (int) mbedtls_pk_get_type( &pk ) == type );
379 TEST_ASSERT( mbedtls_pk_can_do( &pk, type ) );
Gilles Peskinee48fe552019-11-05 16:42:13 +0100380 TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == (unsigned) bitlen );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200381 TEST_ASSERT( mbedtls_pk_get_len( &pk ) == (unsigned) len );
382 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200383
Paul Bakkerbd51b262014-07-10 15:26:12 +0200384exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200385 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200386}
387/* END_CASE */
388
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200389/* BEGIN_CASE depends_on:MBEDTLS_PK_PARSE_C:MBEDTLS_FS_IO */
Azim Khanf1aaec92017-05-30 14:23:15 +0100390void mbedtls_pk_check_pair( char * pub_file, char * prv_file, int ret )
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100391{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200392 mbedtls_pk_context pub, prv, alt;
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100393
Neil Armstrong56d51272022-02-22 15:29:05 +0100394 USE_PSA_INIT();
395
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200396 mbedtls_pk_init( &pub );
397 mbedtls_pk_init( &prv );
398 mbedtls_pk_init( &alt );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100399
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200400 TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &pub, pub_file ) == 0 );
Manuel Pégourié-Gonnard84dea012021-06-15 11:29:26 +0200401 TEST_ASSERT( mbedtls_pk_parse_keyfile( &prv, prv_file, NULL,
402 mbedtls_test_rnd_std_rand, NULL )
403 == 0 );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100404
Manuel Pégourié-Gonnard39be1412021-06-15 11:29:26 +0200405 TEST_ASSERT( mbedtls_pk_check_pair( &pub, &prv,
406 mbedtls_test_rnd_std_rand, NULL )
407 == ret );
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100408
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200409#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
410 if( mbedtls_pk_get_type( &prv ) == MBEDTLS_PK_RSA )
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100411 {
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200412 TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, mbedtls_pk_rsa( prv ),
Hanno Becker6ac972d2017-09-07 10:57:48 +0100413 mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
414 mbedtls_rsa_key_len_func ) == 0 );
Manuel Pégourié-Gonnard39be1412021-06-15 11:29:26 +0200415 TEST_ASSERT( mbedtls_pk_check_pair( &pub, &alt,
416 mbedtls_test_rnd_std_rand, NULL )
417 == ret );
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100418 }
Manuel Pégourié-Gonnard7c13d692014-11-12 00:01:34 +0100419#endif
Manuel Pégourié-Gonnarda1efcb02014-11-08 17:08:08 +0100420
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200421 mbedtls_pk_free( &pub );
422 mbedtls_pk_free( &prv );
423 mbedtls_pk_free( &alt );
Neil Armstrong56d51272022-02-22 15:29:05 +0100424 USE_PSA_DONE();
Manuel Pégourié-Gonnard70bdadf2014-11-06 16:51:20 +0100425}
426/* END_CASE */
427
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200428/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100429void pk_rsa_verify_test_vec( data_t * message_str, int digest, int mod,
Azim Khand30ca132017-06-09 04:32:58 +0100430 int radix_N, char * input_N, int radix_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100431 char * input_E, data_t * result_str,
Azim Khanf1aaec92017-05-30 14:23:15 +0100432 int result )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200433{
Ron Eldor58e3f692018-11-21 13:44:31 +0200434 unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200435 mbedtls_rsa_context *rsa;
436 mbedtls_pk_context pk;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200437 mbedtls_pk_restart_ctx *rs_ctx = NULL;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200438#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200439 mbedtls_pk_restart_ctx ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200440
441 rs_ctx = &ctx;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200442 mbedtls_pk_restart_init( rs_ctx );
Manuel Pégourié-Gonnard4edb9cb2018-07-02 12:23:23 +0200443 // this setting would ensure restart would happen if ECC was used
444 mbedtls_ecp_set_max_ops( 1 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200445#endif
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200446
Neil Armstrong56d51272022-02-22 15:29:05 +0100447 USE_PSA_INIT();
448
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200449 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200450
Ron Eldor58e3f692018-11-21 13:44:31 +0200451 memset( hash_result, 0x00, MBEDTLS_MD_MAX_SIZE );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200452
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200453 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200454 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200455
Paul Bakker42099c32014-01-27 11:45:49 +0100456 rsa->len = mod / 8;
Gilles Peskine20edee72021-06-10 23:18:39 +0200457 TEST_ASSERT( mbedtls_test_read_mpi( &rsa->N, radix_N, input_N ) == 0 );
458 TEST_ASSERT( mbedtls_test_read_mpi( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200459
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200460
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200461 if( mbedtls_md_info_from_type( digest ) != NULL )
Azim Khand30ca132017-06-09 04:32:58 +0100462 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 +0200463
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200464 TEST_ASSERT( mbedtls_pk_verify( &pk, digest, hash_result, 0,
Azim Khand30ca132017-06-09 04:32:58 +0100465 result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200466
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200467 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, digest, hash_result, 0,
Manuel Pégourié-Gonnard125af942018-09-11 11:08:12 +0200468 result_str->x, mbedtls_pk_get_len( &pk ), rs_ctx ) == result );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200469
Paul Bakkerbd51b262014-07-10 15:26:12 +0200470exit:
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200471#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200472 mbedtls_pk_restart_free( rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200473#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200474 mbedtls_pk_free( &pk );
Neil Armstrong56d51272022-02-22 15:29:05 +0100475 USE_PSA_DONE();
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200476}
477/* END_CASE */
478
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200479/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100480void pk_rsa_verify_ext_test_vec( data_t * message_str, int digest,
Azim Khand30ca132017-06-09 04:32:58 +0100481 int mod, int radix_N, char * input_N,
482 int radix_E, char * input_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100483 data_t * result_str, int pk_type,
Andrzej Kurek8666df62022-02-15 08:23:02 -0500484 int mgf1_hash_id, int salt_len, int sig_len,
485 int result )
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200486{
Ron Eldor58e3f692018-11-21 13:44:31 +0200487 unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200488 mbedtls_rsa_context *rsa;
489 mbedtls_pk_context pk;
490 mbedtls_pk_rsassa_pss_options pss_opts;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200491 void *options;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200492 size_t hash_len;
Neil Armstrong655725a2022-04-15 12:00:16 +0200493 int ret;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200494
Andrzej Kurek853ad7b2022-02-15 07:13:03 -0500495 USE_PSA_INIT( );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200496 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200497
Ron Eldor58e3f692018-11-21 13:44:31 +0200498 memset( hash_result, 0x00, sizeof( hash_result ) );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200499
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200500 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200501 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200502
503 rsa->len = mod / 8;
Gilles Peskine20edee72021-06-10 23:18:39 +0200504 TEST_ASSERT( mbedtls_test_read_mpi( &rsa->N, radix_N, input_N ) == 0 );
505 TEST_ASSERT( mbedtls_test_read_mpi( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200506
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200507
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200508 if( digest != MBEDTLS_MD_NONE )
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200509 {
Gilles Peskine6e3187b2021-06-22 18:39:53 +0200510 const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( digest );
511 TEST_ASSERT( mbedtls_md( md_info, message_str->x, message_str->len,
512 hash_result ) == 0 );
513 hash_len = mbedtls_md_get_size( md_info );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200514 }
515 else
516 {
Azim Khand30ca132017-06-09 04:32:58 +0100517 memcpy( hash_result, message_str->x, message_str->len );
518 hash_len = message_str->len;
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200519 }
520
521 if( mgf1_hash_id < 0 )
522 {
523 options = NULL;
524 }
525 else
526 {
527 options = &pss_opts;
528
529 pss_opts.mgf1_hash_id = mgf1_hash_id;
530 pss_opts.expected_salt_len = salt_len;
531 }
532
Neil Armstrong655725a2022-04-15 12:00:16 +0200533 ret = mbedtls_pk_verify_ext( pk_type, options, &pk,
534 digest, hash_result, hash_len,
535 result_str->x, sig_len );
536
Neil Armstrong655725a2022-04-15 12:00:16 +0200537#if defined(MBEDTLS_USE_PSA_CRYPTO)
Neil Armstrong6e6967f2022-04-22 11:32:18 +0200538 if( result == MBEDTLS_ERR_RSA_INVALID_PADDING )
539 {
Neil Armstrong1c9eb722022-04-25 14:38:18 +0200540 /* Mbed TLS distinguishes "invalid padding" from "valid padding but
Neil Armstrong6e6967f2022-04-22 11:32:18 +0200541 * the rest of the signature is invalid". This has little use in
542 * practice and PSA doesn't report this distinction.
543 * In this case, PSA returns PSA_ERROR_INVALID_SIGNATURE translated
Neil Armstrong1c9eb722022-04-25 14:38:18 +0200544 * to MBEDTLS_ERR_RSA_VERIFY_FAILED.
545 * However, currently `mbedtls_pk_verify_ext()` may use either the
546 * PSA or the Mbed TLS API, depending on the PSS options used.
547 * So, it may return either INVALID_PADDING or INVALID_SIGNATURE.
Neil Armstrong6e6967f2022-04-22 11:32:18 +0200548 */
549 TEST_ASSERT( ret == result || ret == MBEDTLS_ERR_RSA_VERIFY_FAILED );
550 }
Neil Armstrong655725a2022-04-15 12:00:16 +0200551 else
552#endif
Neil Armstrong6e6967f2022-04-22 11:32:18 +0200553 {
554 TEST_EQUAL( ret, result );
555 }
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200556
Paul Bakkerbd51b262014-07-10 15:26:12 +0200557exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200558 mbedtls_pk_free( &pk );
Andrzej Kurek853ad7b2022-02-15 07:13:03 -0500559 USE_PSA_DONE( );
Manuel Pégourié-Gonnard20422e92014-06-05 13:41:44 +0200560}
561/* END_CASE */
562
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200563/* BEGIN_CASE depends_on:MBEDTLS_ECDSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100564void pk_ec_test_vec( int type, int id, data_t * key, data_t * hash,
565 data_t * sig, int ret )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200566{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200567 mbedtls_pk_context pk;
568 mbedtls_ecp_keypair *eckey;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200569
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200570 mbedtls_pk_init( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100571 USE_PSA_INIT( );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200572
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200573 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200574
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200575 TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) );
576 eckey = mbedtls_pk_ec( pk );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200577
Manuel Pégourié-Gonnarde3a062b2015-05-11 18:46:47 +0200578 TEST_ASSERT( mbedtls_ecp_group_load( &eckey->grp, id ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200579 TEST_ASSERT( mbedtls_ecp_point_read_binary( &eckey->grp, &eckey->Q,
Azim Khand30ca132017-06-09 04:32:58 +0100580 key->x, key->len ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200581
John Durkopd4efa8d2020-09-08 05:58:28 -0700582 // MBEDTLS_MD_NONE is used since it will be ignored.
583 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE,
Azim Khand30ca132017-06-09 04:32:58 +0100584 hash->x, hash->len, sig->x, sig->len ) == ret );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200585
Paul Bakkerbd51b262014-07-10 15:26:12 +0200586exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200587 mbedtls_pk_free( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100588 USE_PSA_DONE( );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200589}
590/* END_CASE */
591
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200592/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECDSA_C:MBEDTLS_ECDSA_DETERMINISTIC */
593void pk_sign_verify_restart( int pk_type, int grp_id, char *d_str,
594 char *QX_str, char *QY_str,
Ronald Cron9ed40732020-06-25 09:03:34 +0200595 int md_alg, char *msg, data_t *sig_check,
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200596 int max_ops, int min_restart, int max_restart )
597{
598 int ret, cnt_restart;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200599 mbedtls_pk_restart_ctx rs_ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200600 mbedtls_pk_context prv, pub;
601 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
602 unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
Ronald Cron9ed40732020-06-25 09:03:34 +0200603 size_t hlen, slen;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200604 const mbedtls_md_info_t *md_info;
605
Neil Armstrong56d51272022-02-22 15:29:05 +0100606 USE_PSA_INIT();
607
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200608 mbedtls_pk_restart_init( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200609 mbedtls_pk_init( &prv );
610 mbedtls_pk_init( &pub );
611 memset( hash, 0, sizeof( hash ) );
612 memset( sig, 0, sizeof( sig ) );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200613
614 TEST_ASSERT( mbedtls_pk_setup( &prv, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
615 TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( prv )->grp, grp_id ) == 0 );
Gilles Peskine20edee72021-06-10 23:18:39 +0200616 TEST_ASSERT( mbedtls_test_read_mpi( &mbedtls_pk_ec( prv )->d, 16, d_str ) == 0 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200617
618 TEST_ASSERT( mbedtls_pk_setup( &pub, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
619 TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( pub )->grp, grp_id ) == 0 );
620 TEST_ASSERT( mbedtls_ecp_point_read_string( &mbedtls_pk_ec( pub )->Q, 16, QX_str, QY_str ) == 0 );
621
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200622 md_info = mbedtls_md_info_from_type( md_alg );
623 TEST_ASSERT( md_info != NULL );
624
625 hlen = mbedtls_md_get_size( md_info );
Gilles Peskine84984ae2020-01-21 16:52:08 +0100626 TEST_ASSERT( mbedtls_md( md_info,
627 (const unsigned char *) msg, strlen( msg ),
628 hash ) == 0 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200629
630 mbedtls_ecp_set_max_ops( max_ops );
631
632 slen = sizeof( sig );
633 cnt_restart = 0;
634 do {
635 ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
Gilles Peskinef00f1522021-06-22 00:09:00 +0200636 sig, sizeof( sig ), &slen,
637 mbedtls_test_rnd_std_rand, NULL,
638 &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200639 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
640
641 TEST_ASSERT( ret == 0 );
Ronald Cron9ed40732020-06-25 09:03:34 +0200642 TEST_ASSERT( slen == sig_check->len );
643 TEST_ASSERT( memcmp( sig, sig_check->x, slen ) == 0 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200644
645 TEST_ASSERT( cnt_restart >= min_restart );
646 TEST_ASSERT( cnt_restart <= max_restart );
647
648 cnt_restart = 0;
649 do {
650 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
651 hash, hlen, sig, slen, &rs_ctx );
652 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
653
654 TEST_ASSERT( ret == 0 );
655 TEST_ASSERT( cnt_restart >= min_restart );
656 TEST_ASSERT( cnt_restart <= max_restart );
657
658 hash[0]++;
659 do {
660 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
661 hash, hlen, sig, slen, &rs_ctx );
662 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
663 TEST_ASSERT( ret != 0 );
664 hash[0]--;
665
666 sig[0]++;
667 do {
668 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
669 hash, hlen, sig, slen, &rs_ctx );
670 } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
671 TEST_ASSERT( ret != 0 );
672 sig[0]--;
673
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200674 /* Do we leak memory when aborting? try verify then sign
675 * This test only makes sense when we actually restart */
676 if( min_restart > 0 )
677 {
678 ret = mbedtls_pk_verify_restartable( &pub, md_alg,
679 hash, hlen, sig, slen, &rs_ctx );
680 TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
681 mbedtls_pk_restart_free( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200682
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200683 slen = sizeof( sig );
684 ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
Gilles Peskinef00f1522021-06-22 00:09:00 +0200685 sig, sizeof sig, &slen,
686 mbedtls_test_rnd_std_rand, NULL,
687 &rs_ctx );
Manuel Pégourié-Gonnard46ba7f32017-08-28 12:20:39 +0200688 TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
689 }
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200690
691exit:
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200692 mbedtls_pk_restart_free( &rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200693 mbedtls_pk_free( &prv );
694 mbedtls_pk_free( &pub );
Neil Armstrong56d51272022-02-22 15:29:05 +0100695 USE_PSA_DONE();
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200696}
697/* END_CASE */
698
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200699/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
Gilles Peskinee48fe552019-11-05 16:42:13 +0100700void pk_sign_verify( int type, int parameter, int sign_ret, int verify_ret )
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200701{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200702 mbedtls_pk_context pk;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200703 size_t sig_len;
Gilles Peskine6e3187b2021-06-22 18:39:53 +0200704 unsigned char hash[32]; // Hard-coded for SHA256
705 size_t hash_len = sizeof( hash );
Gilles Peskineeba088a2019-11-05 16:32:32 +0100706 unsigned char sig[MBEDTLS_PK_SIGNATURE_MAX_SIZE];
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200707 void *rs_ctx = NULL;
708#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200709 mbedtls_pk_restart_ctx ctx;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200710
711 rs_ctx = &ctx;
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200712 mbedtls_pk_restart_init( rs_ctx );
Manuel Pégourié-Gonnard4edb9cb2018-07-02 12:23:23 +0200713 /* This value is large enough that the operation will complete in one run.
714 * See comments at the top of ecp_test_vect_restart in
715 * test_suite_ecp.function for estimates of operation counts. */
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200716 mbedtls_ecp_set_max_ops( 42000 );
717#endif
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200718
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200719 mbedtls_pk_init( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100720 USE_PSA_INIT( );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200721
722 memset( hash, 0x2a, sizeof hash );
723 memset( sig, 0, sizeof sig );
724
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200725 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Gilles Peskinee48fe552019-11-05 16:42:13 +0100726 TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200727
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200728 TEST_ASSERT( mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_SHA256,
Gilles Peskinef00f1522021-06-22 00:09:00 +0200729 hash, hash_len,
730 sig, sizeof sig, &sig_len,
731 mbedtls_test_rnd_std_rand, NULL,
732 rs_ctx ) == sign_ret );
Gilles Peskineeba088a2019-11-05 16:32:32 +0100733 if( sign_ret == 0 )
734 TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
735 else
Gilles Peskinef85e4e62019-11-12 11:08:23 +0100736 sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200737
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200738 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
Gilles Peskine6e3187b2021-06-22 18:39:53 +0200739 hash, hash_len, sig, sig_len ) == verify_ret );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200740
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200741 if( verify_ret == 0 )
742 {
743 hash[0]++;
744 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
Gilles Peskine6e3187b2021-06-22 18:39:53 +0200745 hash, hash_len, sig, sig_len ) != 0 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200746 hash[0]--;
747
748 sig[0]++;
749 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
Gilles Peskine6e3187b2021-06-22 18:39:53 +0200750 hash, hash_len, sig, sig_len ) != 0 );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200751 sig[0]--;
752 }
753
Gilles Peskine6e3187b2021-06-22 18:39:53 +0200754 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256, hash, hash_len,
Gilles Peskinef00f1522021-06-22 00:09:00 +0200755 sig, sizeof sig, &sig_len,
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200756 mbedtls_test_rnd_std_rand,
757 NULL ) == sign_ret );
Gilles Peskineeba088a2019-11-05 16:32:32 +0100758 if( sign_ret == 0 )
759 TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
760 else
Gilles Peskinef85e4e62019-11-12 11:08:23 +0100761 sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200762
763 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
Gilles Peskine6e3187b2021-06-22 18:39:53 +0200764 hash, hash_len, sig, sig_len, rs_ctx ) == verify_ret );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200765
766 if( verify_ret == 0 )
767 {
768 hash[0]++;
769 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
770 hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
771 hash[0]--;
772
773 sig[0]++;
774 TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
775 hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
776 sig[0]--;
777 }
778
Paul Bakkerbd51b262014-07-10 15:26:12 +0200779exit:
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200780#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +0200781 mbedtls_pk_restart_free( rs_ctx );
Manuel Pégourié-Gonnardc4ee9ac2017-05-08 10:09:36 +0200782#endif
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200783 mbedtls_pk_free( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +0100784 USE_PSA_DONE( );
Manuel Pégourié-Gonnardb0a467f2013-09-21 12:31:05 +0200785}
786/* END_CASE */
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200787
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200788/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Neil Armstronge0df42c2022-02-22 14:26:49 +0100789void pk_rsa_encrypt_decrypt_test( data_t * message, int mod, int radix_P,
790 char * input_P, int radix_Q, char * input_Q,
791 int radix_N, char * input_N, int radix_E,
792 char * input_E, int ret )
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200793{
Neil Armstronge0df42c2022-02-22 14:26:49 +0100794 unsigned char output[300], result[300];
Ronald Cron351f0ee2020-06-10 12:12:18 +0200795 mbedtls_test_rnd_pseudo_info rnd_info;
Neil Armstronge0df42c2022-02-22 14:26:49 +0100796 mbedtls_mpi N, P, Q, E;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200797 mbedtls_rsa_context *rsa;
798 mbedtls_pk_context pk;
Neil Armstronge0df42c2022-02-22 14:26:49 +0100799 size_t olen, rlen;
800
801 mbedtls_pk_init( &pk );
Paul Elliottff59a342022-03-31 17:14:13 +0100802 mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
803 mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200804
Ronald Cron351f0ee2020-06-10 12:12:18 +0200805 memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200806 memset( output, 0, sizeof( output ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200807
Neil Armstronge0df42c2022-02-22 14:26:49 +0100808 USE_PSA_INIT( );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200809
Neil Armstronge0df42c2022-02-22 14:26:49 +0100810 /* encryption test */
811
812 /* init pk-rsa context */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200813 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200814 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200815
Neil Armstronge0df42c2022-02-22 14:26:49 +0100816 /* load public key */
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200817 rsa->len = mod / 8;
Gilles Peskine20edee72021-06-10 23:18:39 +0200818 TEST_ASSERT( mbedtls_test_read_mpi( &rsa->N, radix_N, input_N ) == 0 );
819 TEST_ASSERT( mbedtls_test_read_mpi( &rsa->E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200820
Azim Khand30ca132017-06-09 04:32:58 +0100821 TEST_ASSERT( mbedtls_pk_encrypt( &pk, message->x, message->len,
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200822 output, &olen, sizeof( output ),
823 mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
Neil Armstronge0df42c2022-02-22 14:26:49 +0100824
825 /* decryption test */
826 mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
827 mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
828
829 /* init pk-rsa context */
830 mbedtls_pk_free( &pk );
Neil Armstrongc921bfd2022-03-03 14:35:38 +0100831 TEST_ASSERT( mbedtls_pk_setup( &pk,
832 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Neil Armstronge0df42c2022-02-22 14:26:49 +0100833 rsa = mbedtls_pk_rsa( pk );
834
835 /* load public key */
836 TEST_ASSERT( mbedtls_test_read_mpi( &N, radix_N, input_N ) == 0 );
837 TEST_ASSERT( mbedtls_test_read_mpi( &E, radix_E, input_E ) == 0 );
838
839 /* load private key */
840 TEST_ASSERT( mbedtls_test_read_mpi( &P, radix_P, input_P ) == 0 );
841 TEST_ASSERT( mbedtls_test_read_mpi( &Q, radix_Q, input_Q ) == 0 );
842 TEST_ASSERT( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ) == 0 );
843 TEST_ASSERT( mbedtls_rsa_get_len( rsa ) == (size_t) ( mod / 8 ) );
844 TEST_ASSERT( mbedtls_rsa_complete( rsa ) == 0 );
845
846 memset( result, 0, sizeof( result ) );
847 rlen = 0;
848 TEST_ASSERT( mbedtls_pk_decrypt( &pk, output, olen,
849 result, &rlen, sizeof( result ),
850 mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
851 if( ret == 0 )
852 {
853 TEST_ASSERT( rlen == message->len );
854 TEST_ASSERT( memcmp( result, message->x, rlen ) == 0 );
855 }
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200856
Paul Bakkerbd51b262014-07-10 15:26:12 +0200857exit:
Neil Armstronge0df42c2022-02-22 14:26:49 +0100858 mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
859 mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200860 mbedtls_pk_free( &pk );
Neil Armstronge0df42c2022-02-22 14:26:49 +0100861 USE_PSA_DONE( );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200862}
863/* END_CASE */
864
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200865/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Azim Khan5fcca462018-06-29 11:05:32 +0100866void pk_rsa_decrypt_test_vec( data_t * cipher, int mod, int radix_P,
Azim Khand30ca132017-06-09 04:32:58 +0100867 char * input_P, int radix_Q, char * input_Q,
868 int radix_N, char * input_N, int radix_E,
Azim Khan5fcca462018-06-29 11:05:32 +0100869 char * input_E, data_t * clear, int ret )
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200870{
Ron Eldor58e3f692018-11-21 13:44:31 +0200871 unsigned char output[256];
Ronald Cron351f0ee2020-06-10 12:12:18 +0200872 mbedtls_test_rnd_pseudo_info rnd_info;
Hanno Beckerd71dc152017-08-23 06:32:42 +0100873 mbedtls_mpi N, P, Q, E;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200874 mbedtls_rsa_context *rsa;
875 mbedtls_pk_context pk;
Azim Khanf1aaec92017-05-30 14:23:15 +0100876 size_t olen;
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200877
Neil Armstrong502da112022-02-09 15:33:15 +0100878 USE_PSA_INIT( );
879
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200880 mbedtls_pk_init( &pk );
Hanno Beckerd71dc152017-08-23 06:32:42 +0100881 mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
882 mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200883
Ronald Cron351f0ee2020-06-10 12:12:18 +0200884 memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200885
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200886
887 /* init pk-rsa context */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +0200888 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200889 rsa = mbedtls_pk_rsa( pk );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200890
891 /* load public key */
Gilles Peskine20edee72021-06-10 23:18:39 +0200892 TEST_ASSERT( mbedtls_test_read_mpi( &N, radix_N, input_N ) == 0 );
893 TEST_ASSERT( mbedtls_test_read_mpi( &E, radix_E, input_E ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200894
895 /* load private key */
Gilles Peskine20edee72021-06-10 23:18:39 +0200896 TEST_ASSERT( mbedtls_test_read_mpi( &P, radix_P, input_P ) == 0 );
897 TEST_ASSERT( mbedtls_test_read_mpi( &Q, radix_Q, input_Q ) == 0 );
Hanno Beckerd71dc152017-08-23 06:32:42 +0100898 TEST_ASSERT( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ) == 0 );
899 TEST_ASSERT( mbedtls_rsa_get_len( rsa ) == (size_t) ( mod / 8 ) );
Hanno Becker7f25f852017-10-10 16:56:22 +0100900 TEST_ASSERT( mbedtls_rsa_complete( rsa ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200901
902 /* decryption test */
903 memset( output, 0, sizeof( output ) );
904 olen = 0;
Azim Khand30ca132017-06-09 04:32:58 +0100905 TEST_ASSERT( mbedtls_pk_decrypt( &pk, cipher->x, cipher->len,
Ronald Cron6c5bd7f2020-06-10 14:08:26 +0200906 output, &olen, sizeof( output ),
907 mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200908 if( ret == 0 )
909 {
Azim Khand30ca132017-06-09 04:32:58 +0100910 TEST_ASSERT( olen == clear->len );
911 TEST_ASSERT( memcmp( output, clear->x, olen ) == 0 );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200912 }
913
Paul Bakkerbd51b262014-07-10 15:26:12 +0200914exit:
Hanno Beckerd71dc152017-08-23 06:32:42 +0100915 mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
916 mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200917 mbedtls_pk_free( &pk );
Neil Armstrong502da112022-02-09 15:33:15 +0100918 USE_PSA_DONE( );
Manuel Pégourié-Gonnard67d45832013-10-17 12:34:16 +0200919}
920/* END_CASE */
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200921
Neil Armstrongb32ae722022-04-22 15:02:47 +0200922/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_USE_PSA_CRYPTO */
923void pk_wrap_rsa_decrypt_test_vec( data_t * cipher, int mod, int radix_P,
924 char * input_P, int radix_Q, char * input_Q,
925 int radix_N, char * input_N, int radix_E,
926 char * input_E, data_t * clear, int ret )
927{
928 unsigned char output[256];
929 mbedtls_test_rnd_pseudo_info rnd_info;
930 mbedtls_mpi N, P, Q, E;
931 mbedtls_rsa_context *rsa;
932 mbedtls_pk_context pk;
933 mbedtls_svc_key_id_t key_id;
934 size_t olen;
935
936 USE_PSA_INIT( );
937
938 mbedtls_pk_init( &pk );
939 mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
940 mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
941
942 memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
943
944 /* init pk-rsa context */
945 TEST_EQUAL( mbedtls_pk_setup( &pk,
946 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ), 0 );
947 rsa = mbedtls_pk_rsa( pk );
948
949 /* load public key */
950 TEST_EQUAL( mbedtls_test_read_mpi( &N, radix_N, input_N ), 0 );
951 TEST_EQUAL( mbedtls_test_read_mpi( &E, radix_E, input_E ), 0 );
952
953 /* load private key */
954 TEST_EQUAL( mbedtls_test_read_mpi( &P, radix_P, input_P ), 0 );
955 TEST_EQUAL( mbedtls_test_read_mpi( &Q, radix_Q, input_Q ), 0 );
956 TEST_EQUAL( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ), 0 );
957 TEST_EQUAL( mbedtls_rsa_get_len( rsa ), (size_t) ( mod / 8 ) );
958 TEST_EQUAL( mbedtls_rsa_complete( rsa ), 0 );
959
960 /* Turn PK context into an opaque one. */
961 TEST_EQUAL( mbedtls_pk_wrap_as_opaque( &pk, &key_id,
962 PSA_ALG_RSA_PKCS1V15_CRYPT,
963 PSA_KEY_USAGE_DECRYPT,
964 PSA_ALG_NONE ), 0 );
965
966 /* decryption test */
967 memset( output, 0, sizeof( output ) );
968 olen = 0;
969 TEST_EQUAL( mbedtls_pk_decrypt( &pk, cipher->x, cipher->len,
970 output, &olen, sizeof( output ),
971 mbedtls_test_rnd_pseudo_rand, &rnd_info ), ret );
972 if( ret == 0 )
973 {
974 TEST_EQUAL( olen, clear->len );
975 TEST_EQUAL( memcmp( output, clear->x, olen ), 0 );
976 }
977
Neil Armstrong814562a2022-05-11 09:29:57 +0200978 TEST_EQUAL( PSA_SUCCESS, psa_destroy_key( key_id ) );
Neil Armstrongb32ae722022-04-22 15:02:47 +0200979
980exit:
981 mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
982 mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
983 mbedtls_pk_free( &pk );
984 USE_PSA_DONE( );
985}
986/* END_CASE */
987
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200988/* BEGIN_CASE */
989void pk_ec_nocrypt( int type )
990{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200991 mbedtls_pk_context pk;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200992 unsigned char output[100];
993 unsigned char input[100];
Ronald Cron351f0ee2020-06-10 12:12:18 +0200994 mbedtls_test_rnd_pseudo_info rnd_info;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200995 size_t olen = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200996 int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200997
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200998 mbedtls_pk_init( &pk );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +0200999
Ronald Cron351f0ee2020-06-10 12:12:18 +02001000 memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +02001001 memset( output, 0, sizeof( output ) );
1002 memset( input, 0, sizeof( input ) );
1003
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +02001004 TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +02001005
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001006 TEST_ASSERT( mbedtls_pk_encrypt( &pk, input, sizeof( input ),
Ronald Cron6c5bd7f2020-06-10 14:08:26 +02001007 output, &olen, sizeof( output ),
1008 mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +02001009
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001010 TEST_ASSERT( mbedtls_pk_decrypt( &pk, input, sizeof( input ),
Ronald Cron6c5bd7f2020-06-10 14:08:26 +02001011 output, &olen, sizeof( output ),
1012 mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +02001013
Paul Bakkerbd51b262014-07-10 15:26:12 +02001014exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001015 mbedtls_pk_free( &pk );
Manuel Pégourié-Gonnard75c78822013-10-17 12:46:39 +02001016}
1017/* END_CASE */
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001018
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +01001019/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
Andres AG5c79d252017-02-15 10:52:32 +00001020void pk_rsa_overflow( )
1021{
1022 mbedtls_pk_context pk;
itayzafrir693a1d92018-02-26 12:02:10 +02001023 size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX;
1024 unsigned char hash[50], sig[100];
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +01001025
1026 if( SIZE_MAX <= UINT_MAX )
1027 return;
Andres AG5c79d252017-02-15 10:52:32 +00001028
itayzafrir693a1d92018-02-26 12:02:10 +02001029 memset( hash, 0x2a, sizeof hash );
1030 memset( sig, 0, sizeof sig );
Andres AG5c79d252017-02-15 10:52:32 +00001031
1032 mbedtls_pk_init( &pk );
1033
1034 TEST_ASSERT( mbedtls_pk_setup( &pk,
1035 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
1036
1037#if defined(MBEDTLS_PKCS1_V21)
1038 TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_RSASSA_PSS, NULL, &pk,
itayzafrir693a1d92018-02-26 12:02:10 +02001039 MBEDTLS_MD_NONE, hash, hash_len, sig, sig_len ) ==
Andres AG5c79d252017-02-15 10:52:32 +00001040 MBEDTLS_ERR_PK_BAD_INPUT_DATA );
1041#endif /* MBEDTLS_PKCS1_V21 */
1042
itayzafrir693a1d92018-02-26 12:02:10 +02001043 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE, hash, hash_len,
1044 sig, sig_len ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres AG5c79d252017-02-15 10:52:32 +00001045
Gilles Peskinef00f1522021-06-22 00:09:00 +02001046 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, hash, hash_len,
1047 sig, sizeof sig, &sig_len,
1048 mbedtls_test_rnd_std_rand, NULL )
Ronald Cron6c5bd7f2020-06-10 14:08:26 +02001049 == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres AG5c79d252017-02-15 10:52:32 +00001050
1051exit:
1052 mbedtls_pk_free( &pk );
1053}
1054/* END_CASE */
1055
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001056/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_PK_RSA_ALT_SUPPORT */
Azim Khanf1aaec92017-05-30 14:23:15 +01001057void pk_rsa_alt( )
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001058{
1059 /*
1060 * An rsa_alt context can only do private operations (decrypt, sign).
1061 * Test it against the public operations (encrypt, verify) of a
1062 * corresponding rsa context.
1063 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001064 mbedtls_rsa_context raw;
1065 mbedtls_pk_context rsa, alt;
1066 mbedtls_pk_debug_item dbg_items[10];
Ron Eldor58e3f692018-11-21 13:44:31 +02001067 unsigned char hash[50], sig[64];
1068 unsigned char msg[50], ciph[64], test[50];
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001069 size_t sig_len, ciph_len, test_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001070 int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001071
Neil Armstrong445d2192022-02-10 15:25:29 +01001072 USE_PSA_INIT( );
1073
Ronald Cronc1905a12021-06-05 11:11:14 +02001074 mbedtls_rsa_init( &raw );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001075 mbedtls_pk_init( &rsa ); mbedtls_pk_init( &alt );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001076
1077 memset( hash, 0x2a, sizeof hash );
1078 memset( sig, 0, sizeof sig );
1079 memset( msg, 0x2a, sizeof msg );
1080 memset( ciph, 0, sizeof ciph );
1081 memset( test, 0, sizeof test );
1082
Shaun Case8b0ecbc2021-12-20 21:14:10 -08001083 /* Initialize PK RSA context with random key */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +02001084 TEST_ASSERT( mbedtls_pk_setup( &rsa,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001085 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
Gilles Peskinee48fe552019-11-05 16:42:13 +01001086 TEST_ASSERT( pk_genkey( &rsa, RSA_KEY_SIZE ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001087
1088 /* Extract key to the raw rsa context */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001089 TEST_ASSERT( mbedtls_rsa_copy( &raw, mbedtls_pk_rsa( rsa ) ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001090
1091 /* Initialize PK RSA_ALT context */
Manuel Pégourié-Gonnardd9e6a3a2015-05-14 19:41:36 +02001092 TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, (void *) &raw,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001093 mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001094
1095 /* Test administrative functions */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001096 TEST_ASSERT( mbedtls_pk_can_do( &alt, MBEDTLS_PK_RSA ) );
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +02001097 TEST_ASSERT( mbedtls_pk_get_bitlen( &alt ) == RSA_KEY_SIZE );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001098 TEST_ASSERT( mbedtls_pk_get_len( &alt ) == RSA_KEY_LEN );
1099 TEST_ASSERT( mbedtls_pk_get_type( &alt ) == MBEDTLS_PK_RSA_ALT );
1100 TEST_ASSERT( strcmp( mbedtls_pk_get_name( &alt ), "RSA-alt" ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001101
1102 /* Test signature */
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +01001103#if SIZE_MAX > UINT_MAX
Gilles Peskinef00f1522021-06-22 00:09:00 +02001104 TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, SIZE_MAX,
1105 sig, sizeof sig, &sig_len,
1106 mbedtls_test_rnd_std_rand, NULL )
Ronald Cron6c5bd7f2020-06-10 14:08:26 +02001107 == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
Andres Amaya Garcia7ea67272017-05-08 11:15:49 +01001108#endif /* SIZE_MAX > UINT_MAX */
Gilles Peskinef00f1522021-06-22 00:09:00 +02001109 TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, sizeof hash,
1110 sig, sizeof sig, &sig_len,
1111 mbedtls_test_rnd_std_rand, NULL )
Ronald Cron6c5bd7f2020-06-10 14:08:26 +02001112 == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001113 TEST_ASSERT( sig_len == RSA_KEY_LEN );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001114 TEST_ASSERT( mbedtls_pk_verify( &rsa, MBEDTLS_MD_NONE,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001115 hash, sizeof hash, sig, sig_len ) == 0 );
1116
1117 /* Test decrypt */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001118 TEST_ASSERT( mbedtls_pk_encrypt( &rsa, msg, sizeof msg,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001119 ciph, &ciph_len, sizeof ciph,
Ronald Cron351f0ee2020-06-10 12:12:18 +02001120 mbedtls_test_rnd_std_rand, NULL ) == 0 );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001121 TEST_ASSERT( mbedtls_pk_decrypt( &alt, ciph, ciph_len,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001122 test, &test_len, sizeof test,
Ronald Cron351f0ee2020-06-10 12:12:18 +02001123 mbedtls_test_rnd_std_rand, NULL ) == 0 );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001124 TEST_ASSERT( test_len == sizeof msg );
1125 TEST_ASSERT( memcmp( test, msg, test_len ) == 0 );
1126
1127 /* Test forbidden operations */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001128 TEST_ASSERT( mbedtls_pk_encrypt( &alt, msg, sizeof msg,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001129 ciph, &ciph_len, sizeof ciph,
Ronald Cron351f0ee2020-06-10 12:12:18 +02001130 mbedtls_test_rnd_std_rand, NULL ) == ret );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001131 TEST_ASSERT( mbedtls_pk_verify( &alt, MBEDTLS_MD_NONE,
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001132 hash, sizeof hash, sig, sig_len ) == ret );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001133 TEST_ASSERT( mbedtls_pk_debug( &alt, dbg_items ) == ret );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001134
Paul Bakkerbd51b262014-07-10 15:26:12 +02001135exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001136 mbedtls_rsa_free( &raw );
1137 mbedtls_pk_free( &rsa ); mbedtls_pk_free( &alt );
Neil Armstrong445d2192022-02-10 15:25:29 +01001138 USE_PSA_DONE( );
Manuel Pégourié-Gonnard01488752014-04-03 22:09:18 +02001139}
1140/* END_CASE */
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001141
Neil Armstrong67fc0362022-03-15 14:48:52 +01001142/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_USE_PSA_CRYPTO */
Neil Armstrong5b87ebb2022-03-15 14:35:26 +01001143void pk_psa_sign( int parameter_arg,
1144 int psa_type_arg, int expected_bits_arg )
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001145{
1146 mbedtls_pk_context pk;
Gilles Peskine33b1c692019-12-19 00:09:47 +01001147 unsigned char hash[32];
Neil Armstrong67fc0362022-03-15 14:48:52 +01001148 unsigned char sig[MBEDTLS_PK_SIGNATURE_MAX_SIZE];
Gilles Peskine33b1c692019-12-19 00:09:47 +01001149 unsigned char pkey_legacy[200];
1150 unsigned char pkey_psa[200];
Hanno Becker56104ea2019-02-01 11:48:19 +00001151 unsigned char *pkey_legacy_start, *pkey_psa_start;
Neil Armstrong95974972022-04-22 13:57:44 +02001152 psa_algorithm_t alg_psa;
Hanno Becker56104ea2019-02-01 11:48:19 +00001153 size_t sig_len, klen_legacy, klen_psa;
1154 int ret;
Ronald Cron5425a212020-08-04 14:58:35 +02001155 mbedtls_svc_key_id_t key_id;
Gilles Peskine85f47c92019-12-18 20:44:15 +01001156 psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
Neil Armstrong5b87ebb2022-03-15 14:35:26 +01001157 psa_key_type_t expected_type = psa_type_arg;
Gilles Peskine33b1c692019-12-19 00:09:47 +01001158 size_t expected_bits = expected_bits_arg;
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001159
1160 /*
1161 * This tests making signatures with a wrapped PSA key:
Neil Armstrong67fc0362022-03-15 14:48:52 +01001162 * - generate a fresh ECP/RSA legacy PK context
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001163 * - wrap it in a PK context and make a signature this way
1164 * - extract the public key
1165 * - parse it to a PK context and verify the signature this way
1166 */
1167
Gilles Peskine5386f6b2019-08-01 12:47:40 +02001168 PSA_ASSERT( psa_crypto_init( ) );
1169
Neil Armstrong67fc0362022-03-15 14:48:52 +01001170#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
1171 if( PSA_KEY_TYPE_IS_RSA( psa_type_arg ) )
1172 {
1173 /* Create legacy RSA public/private key in PK context. */
1174 mbedtls_pk_init( &pk );
1175 TEST_ASSERT( mbedtls_pk_setup( &pk,
1176 mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
1177 TEST_ASSERT( mbedtls_rsa_gen_key( mbedtls_pk_rsa( pk ),
1178 mbedtls_test_rnd_std_rand, NULL,
1179 parameter_arg, 3 ) == 0 );
Neil Armstrong95974972022-04-22 13:57:44 +02001180 alg_psa = PSA_ALG_RSA_PKCS1V15_SIGN( PSA_ALG_SHA_256 );
Neil Armstrong67fc0362022-03-15 14:48:52 +01001181 }
1182 else
1183#endif /* MBEDTLS_RSA_C && MBEDTLS_GENPRIME */
1184#if defined(MBEDTLS_ECDSA_C)
1185 if( PSA_KEY_TYPE_IS_ECC_KEY_PAIR( psa_type_arg ) )
1186 {
1187 mbedtls_ecp_group_id grpid = parameter_arg;
1188
1189 /* Create legacy EC public/private key in PK context. */
1190 mbedtls_pk_init( &pk );
1191 TEST_ASSERT( mbedtls_pk_setup( &pk,
1192 mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
1193 TEST_ASSERT( mbedtls_ecp_gen_key( grpid,
1194 (mbedtls_ecp_keypair*) pk.pk_ctx,
1195 mbedtls_test_rnd_std_rand, NULL ) == 0 );
Neil Armstrong95974972022-04-22 13:57:44 +02001196 alg_psa = PSA_ALG_ECDSA( PSA_ALG_SHA_256 );
Neil Armstrong67fc0362022-03-15 14:48:52 +01001197 }
1198 else
1199#endif /* MBEDTLS_ECDSA_C */
1200 {
1201 (void) parameter_arg;
1202 TEST_ASSUME( ! "Opaque PK key not supported in this configuration" );
1203 }
Hanno Becker56104ea2019-02-01 11:48:19 +00001204
1205 /* Export underlying public key for re-importing in a legacy context. */
1206 ret = mbedtls_pk_write_pubkey_der( &pk, pkey_legacy,
1207 sizeof( pkey_legacy ) );
1208 TEST_ASSERT( ret >= 0 );
1209 klen_legacy = (size_t) ret;
1210 /* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
1211 pkey_legacy_start = pkey_legacy + sizeof( pkey_legacy ) - klen_legacy;
1212
1213 /* Turn PK context into an opaque one. */
Neil Armstrong95974972022-04-22 13:57:44 +02001214 TEST_ASSERT( mbedtls_pk_wrap_as_opaque( &pk, &key_id, alg_psa,
1215 PSA_KEY_USAGE_SIGN_HASH,
1216 PSA_ALG_NONE ) == 0 );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001217
Ronald Cron5425a212020-08-04 14:58:35 +02001218 PSA_ASSERT( psa_get_key_attributes( key_id, &attributes ) );
Gilles Peskine33b1c692019-12-19 00:09:47 +01001219 TEST_EQUAL( psa_get_key_type( &attributes ), expected_type );
Gilles Peskine85f47c92019-12-18 20:44:15 +01001220 TEST_EQUAL( psa_get_key_bits( &attributes ), expected_bits );
1221 TEST_EQUAL( psa_get_key_lifetime( &attributes ),
1222 PSA_KEY_LIFETIME_VOLATILE );
1223
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001224 memset( hash, 0x2a, sizeof hash );
1225 memset( sig, 0, sizeof sig );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001226
1227 TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256,
Gilles Peskinef00f1522021-06-22 00:09:00 +02001228 hash, sizeof hash, sig, sizeof sig, &sig_len,
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001229 NULL, NULL ) == 0 );
1230
Hanno Becker56104ea2019-02-01 11:48:19 +00001231 /* Export underlying public key for re-importing in a psa context. */
1232 ret = mbedtls_pk_write_pubkey_der( &pk, pkey_psa,
1233 sizeof( pkey_psa ) );
1234 TEST_ASSERT( ret >= 0 );
1235 klen_psa = (size_t) ret;
1236 /* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
1237 pkey_psa_start = pkey_psa + sizeof( pkey_psa ) - klen_psa;
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001238
Hanno Becker56104ea2019-02-01 11:48:19 +00001239 TEST_ASSERT( klen_psa == klen_legacy );
1240 TEST_ASSERT( memcmp( pkey_psa_start, pkey_legacy_start, klen_psa ) == 0 );
1241
1242 mbedtls_pk_free( &pk );
Ronald Cron5425a212020-08-04 14:58:35 +02001243 TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key_id ) );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001244
1245 mbedtls_pk_init( &pk );
Hanno Becker56104ea2019-02-01 11:48:19 +00001246 TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, pkey_legacy_start,
1247 klen_legacy ) == 0 );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001248 TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
1249 hash, sizeof hash, sig, sig_len ) == 0 );
1250
1251exit:
Ronald Cron3a4f0e32020-11-19 17:55:23 +01001252 /*
1253 * Key attributes may have been returned by psa_get_key_attributes()
1254 * thus reset them as required.
1255 */
1256 psa_reset_key_attributes( &attributes );
1257
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001258 mbedtls_pk_free( &pk );
Gilles Peskine9de97e22021-02-02 21:00:11 +01001259 USE_PSA_DONE( );
Manuel Pégourié-Gonnard36867712018-10-31 16:22:49 +01001260}
1261/* END_CASE */
Jerry Yu1f45b672022-03-12 19:24:50 +08001262
Jerry Yu5512ad92022-03-22 14:34:56 +08001263/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_C:MBEDTLS_GENPRIME */
Jerry Yu1f45b672022-03-12 19:24:50 +08001264void pk_psa_sign_ext( int pk_type, int parameter, int key_pk_type, int md_alg )
1265{
Jerry Yuf8aa9a42022-03-23 20:40:28 +08001266 /* See the description of pk_genkey() for the description of the `parameter` argument. */
Jerry Yu1f45b672022-03-12 19:24:50 +08001267 mbedtls_pk_context pk;
1268 size_t sig_len;
1269 unsigned char sig[MBEDTLS_PK_SIGNATURE_MAX_SIZE];
1270 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
Jerry Yue2c88252022-03-22 21:18:52 +08001271 const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( md_alg );
1272 size_t hash_len = mbedtls_md_get_size( md_info );
Jerry Yub3bfe9f2022-03-22 13:20:39 +08001273 void const *options = NULL;
Jerry Yub3bfe9f2022-03-22 13:20:39 +08001274 mbedtls_pk_rsassa_pss_options rsassa_pss_options;
Jerry Yub3bfe9f2022-03-22 13:20:39 +08001275 memset( hash, 0x2a, sizeof( hash ) );
1276 memset( sig, 0, sizeof( sig ) );
Jerry Yu1f45b672022-03-12 19:24:50 +08001277
1278 mbedtls_pk_init( &pk );
Jerry Yu5a0afc82022-03-22 12:47:28 +08001279 PSA_INIT();
Jerry Yu1f45b672022-03-12 19:24:50 +08001280
Jerry Yub3bfe9f2022-03-22 13:20:39 +08001281 TEST_ASSERT( mbedtls_pk_setup( &pk,
1282 mbedtls_pk_info_from_type( pk_type ) ) == 0 );
Jerry Yu1f45b672022-03-12 19:24:50 +08001283
1284 TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
1285
1286 TEST_ASSERT( mbedtls_pk_sign_ext( key_pk_type, &pk, md_alg, hash, hash_len,
Jerry Yub3bfe9f2022-03-22 13:20:39 +08001287 sig, sizeof( sig ), &sig_len,
Jerry Yu1f45b672022-03-12 19:24:50 +08001288 mbedtls_test_rnd_std_rand, NULL ) == 0 );
Jerry Yucef3f332022-03-22 23:00:13 +08001289
Jerry Yub3bfe9f2022-03-22 13:20:39 +08001290 if( key_pk_type == MBEDTLS_PK_RSASSA_PSS )
1291 {
Jerry Yub3bfe9f2022-03-22 13:20:39 +08001292 rsassa_pss_options.mgf1_hash_id = md_alg;
1293 TEST_ASSERT( md_info != NULL );
1294 rsassa_pss_options.expected_salt_len = mbedtls_md_get_size( md_info );
1295 options = (const void*) &rsassa_pss_options;
1296 }
Jerry Yub3bfe9f2022-03-22 13:20:39 +08001297 TEST_ASSERT( mbedtls_pk_verify_ext( key_pk_type, options, &pk, md_alg,
Jerry Yue2c88252022-03-22 21:18:52 +08001298 hash, hash_len, sig, sig_len ) == 0 );
Jerry Yu1f45b672022-03-12 19:24:50 +08001299exit:
Jerry Yu5a0afc82022-03-22 12:47:28 +08001300 PSA_DONE( );
Jerry Yu1f45b672022-03-12 19:24:50 +08001301 mbedtls_pk_free( &pk );
Jerry Yu1f45b672022-03-12 19:24:50 +08001302}
1303/* END_CASE */
1304
Neil Armstrong999930e2022-04-12 15:12:43 +02001305/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_GENPRIME:MBEDTLS_USE_PSA_CRYPTO */
1306void pk_psa_wrap_sign_ext( int pk_type, int parameter, int key_pk_type, int md_alg )
1307{
1308 /* See the description of mbedtls_rsa_gen_key() for the description of the `parameter` argument. */
1309 mbedtls_pk_context pk;
1310 size_t sig_len, pkey_len;
1311 mbedtls_svc_key_id_t key_id;
1312 unsigned char sig[MBEDTLS_PK_SIGNATURE_MAX_SIZE];
Neil Armstrong843795a2022-04-21 12:23:28 +02001313 unsigned char pkey[PSA_EXPORT_PUBLIC_KEY_MAX_SIZE];
Neil Armstrong999930e2022-04-12 15:12:43 +02001314 unsigned char *pkey_start;
1315 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
1316 psa_algorithm_t psa_md_alg = mbedtls_psa_translate_md( md_alg );
Neil Armstrong95974972022-04-22 13:57:44 +02001317 psa_algorithm_t psa_alg;
Neil Armstrong999930e2022-04-12 15:12:43 +02001318 size_t hash_len = PSA_HASH_LENGTH( psa_md_alg );
1319 const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( md_alg );
1320 void const *options = NULL;
1321 mbedtls_pk_rsassa_pss_options rsassa_pss_options;
1322 int ret;
1323
1324 mbedtls_pk_init( &pk );
1325 PSA_INIT();
1326
1327 /* Create legacy RSA public/private key in PK context. */
1328 mbedtls_pk_init( &pk );
1329 TEST_EQUAL( mbedtls_pk_setup( &pk,
1330 mbedtls_pk_info_from_type( pk_type ) ), 0 );
1331 TEST_EQUAL( mbedtls_rsa_gen_key( mbedtls_pk_rsa( pk ),
1332 mbedtls_test_rnd_std_rand, NULL,
1333 parameter, 3 ), 0 );
1334
1335 /* Export underlying public key for re-importing in a legacy context. */
1336 ret = mbedtls_pk_write_pubkey_der( &pk, pkey, sizeof( pkey ) );
1337 TEST_ASSERT( ret >= 0 );
1338
1339 pkey_len = (size_t) ret;
1340 /* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
1341 pkey_start = pkey + sizeof( pkey ) - pkey_len;
1342
Neil Armstrong95974972022-04-22 13:57:44 +02001343 if( key_pk_type == MBEDTLS_PK_RSA )
1344 psa_alg = PSA_ALG_RSA_PKCS1V15_SIGN( psa_md_alg );
1345 else if( key_pk_type == MBEDTLS_PK_RSASSA_PSS )
1346 psa_alg = PSA_ALG_RSA_PSS( psa_md_alg );
1347 else
1348 TEST_ASSUME( ! "PK key type not supported in this configuration" );
1349
Neil Armstrong999930e2022-04-12 15:12:43 +02001350 /* Turn PK context into an opaque one. */
Neil Armstrong95974972022-04-22 13:57:44 +02001351 TEST_EQUAL( mbedtls_pk_wrap_as_opaque( &pk, &key_id, psa_alg,
1352 PSA_KEY_USAGE_SIGN_HASH,
1353 PSA_ALG_NONE ), 0 );
Neil Armstrong999930e2022-04-12 15:12:43 +02001354
1355 memset( hash, 0x2a, sizeof( hash ) );
1356 memset( sig, 0, sizeof( sig ) );
1357
1358 TEST_EQUAL( mbedtls_pk_sign_ext( key_pk_type, &pk, md_alg, hash, hash_len,
1359 sig, sizeof( sig ), &sig_len,
1360 mbedtls_test_rnd_std_rand, NULL ), 0 );
1361
1362 mbedtls_pk_free( &pk );
1363 TEST_EQUAL( PSA_SUCCESS, psa_destroy_key( key_id ) );
1364
1365 mbedtls_pk_init( &pk );
1366 TEST_EQUAL( mbedtls_pk_parse_public_key( &pk, pkey_start, pkey_len ), 0 );
1367
1368 if( key_pk_type == MBEDTLS_PK_RSASSA_PSS )
1369 {
1370 rsassa_pss_options.mgf1_hash_id = md_alg;
1371 TEST_ASSERT( md_info != NULL );
1372 rsassa_pss_options.expected_salt_len = mbedtls_md_get_size( md_info );
1373 options = (const void*) &rsassa_pss_options;
1374 }
1375 TEST_EQUAL( mbedtls_pk_verify_ext( key_pk_type, options, &pk, md_alg,
1376 hash, hash_len, sig, sig_len ), 0 );
1377
1378exit:
1379 mbedtls_pk_free( &pk );
1380 PSA_DONE( );
1381}
1382/* END_CASE */