third_party/mbedtls/repo/tests/suites/test_suite_pk.function

   1 /* BEGIN_HEADER */
   2 #include "mbedtls/pk.h"
   3
   4 /* For error codes */
   5 #include "mbedtls/asn1.h"
   6 #include "mbedtls/base64.h"
   7 #include "mbedtls/ecp.h"
   8 #include "mbedtls/rsa.h"
   9
  10 #include <limits.h>
  11 #include <stdint.h>
  12
  13 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len );
  14
  15 #define RSA_KEY_SIZE 512
  16 #define RSA_KEY_LEN   64
  17
  18 static int pk_genkey( mbedtls_pk_context *pk )
  19 {
  20     ((void) pk);
  21
  22 #if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
  23     if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_RSA )
  24         return mbedtls_rsa_gen_key( mbedtls_pk_rsa( *pk ), rnd_std_rand, NULL, RSA_KEY_SIZE, 3 );
  25 #endif
  26 #if defined(MBEDTLS_ECP_C)
  27     if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY ||
  28         mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY_DH ||
  29         mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECDSA )
  30     {
  31         int ret;
  32         if( ( ret = mbedtls_ecp_group_load( &mbedtls_pk_ec( *pk )->grp,
  33                                       MBEDTLS_ECP_DP_SECP192R1 ) ) != 0 )
  34             return( ret );
  35
  36         return mbedtls_ecp_gen_keypair( &mbedtls_pk_ec( *pk )->grp, &mbedtls_pk_ec( *pk )->d,
  37                                 &mbedtls_pk_ec( *pk )->Q, rnd_std_rand, NULL );
  38     }
  39 #endif
  40     return( -1 );
  41 }
  42
  43 #if defined(MBEDTLS_RSA_C)
  44 int mbedtls_rsa_decrypt_func( void *ctx, int mode, size_t *olen,
  45                        const unsigned char *input, unsigned char *output,
  46                        size_t output_max_len )
  47 {
  48     return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx,
  49                                        rnd_std_rand, NULL, mode, olen,
  50                                        input, output, output_max_len ) );
  51 }
  52 int mbedtls_rsa_sign_func( void *ctx,
  53                    int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
  54                    int mode, mbedtls_md_type_t md_alg, unsigned int hashlen,
  55                    const unsigned char *hash, unsigned char *sig )
  56 {
  57     ((void) f_rng);
  58     ((void) p_rng);
  59     return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx, rnd_std_rand, NULL, mode,
  60                             md_alg, hashlen, hash, sig ) );
  61 }
  62 size_t mbedtls_rsa_key_len_func( void *ctx )
  63 {
  64     return( ((const mbedtls_rsa_context *) ctx)->len );
  65 }
  66 #endif /* MBEDTLS_RSA_C */
  67
  68 #if defined(MBEDTLS_USE_PSA_CRYPTO)
  69
  70 #include "mbedtls/psa_util.h"
  71
  72 #define PK_PSA_INVALID_SLOT 0 /* guaranteed invalid */
  73
  74 /*
  75  * Generate a key in a free key slot and return this key slot,
  76  * or PK_PSA_INVALID_SLOT if no slot was available.
  77  * The key uses NIST P-256 and is usable for signing with SHA-256.
  78  */
  79 psa_key_handle_t pk_psa_genkey( void )
  80 {
  81     psa_key_handle_t key;
  82
  83     const int curve = PSA_ECC_CURVE_SECP256R1;
  84     const psa_key_type_t type = PSA_KEY_TYPE_ECC_KEYPAIR(curve);
  85     const size_t bits = 256;
  86     psa_key_policy_t policy;
  87
  88     /* Allocate a key slot */
  89     if( PSA_SUCCESS != psa_allocate_key( &key ) )
  90         return( PK_PSA_INVALID_SLOT );
  91
  92     /* set up policy on key slot */
  93     policy = psa_key_policy_init();
  94     psa_key_policy_set_usage( &policy, PSA_KEY_USAGE_SIGN,
  95                                       PSA_ALG_ECDSA(PSA_ALG_SHA_256) );
  96     if( PSA_SUCCESS != psa_set_key_policy( key, &policy ) )
  97         return( PK_PSA_INVALID_SLOT );
  98
  99     /* generate key */
 100     if( PSA_SUCCESS != psa_generate_key( key, type, bits, NULL, 0 ) )
 101         return( PK_PSA_INVALID_SLOT );
 102
 103     return( key );
 104 }
 105 #endif /* MBEDTLS_USE_PSA_CRYPTO */
 106 /* END_HEADER */
 107
 108 /* BEGIN_DEPENDENCIES
 109  * depends_on:MBEDTLS_PK_C
 110  * END_DEPENDENCIES
 111  */
 112
 113 /* BEGIN_CASE depends_on:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_ECDSA_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED */
 114 void pk_psa_utils(  )
 115 {
 116     mbedtls_pk_context pk, pk2;
 117     psa_key_handle_t key;
 118
 119     const char * const name = "Opaque";
 120     const size_t bitlen = 256; /* harcoded in genkey() */
 121
 122     mbedtls_md_type_t md_alg = MBEDTLS_MD_NONE;
 123     unsigned char b1[1], b2[1];
 124     size_t len;
 125     mbedtls_pk_debug_item dbg;
 126
 127     TEST_ASSERT( psa_crypto_init() == 0 );
 128
 129     mbedtls_pk_init( &pk );
 130     mbedtls_pk_init( &pk2 );
 131
 132     TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, 0 ) ==
 133                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 134
 135     mbedtls_pk_free( &pk );
 136     mbedtls_pk_init( &pk );
 137
 138     key = pk_psa_genkey();
 139     TEST_ASSERT( key != 0 );
 140
 141     TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, key ) == 0 );
 142
 143     TEST_ASSERT( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_OPAQUE );
 144     TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
 145
 146     TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == bitlen );
 147     TEST_ASSERT( mbedtls_pk_get_len( &pk ) == bitlen / 8 );
 148
 149     TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECKEY ) == 1 );
 150     TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) == 1 );
 151     TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_RSA ) == 0 );
 152
 153     /* unsupported operations: verify, decrypt, encrypt */
 154     TEST_ASSERT( mbedtls_pk_verify( &pk, md_alg,
 155                                     b1, sizeof( b1), b2, sizeof( b2 ) )
 156                  == MBEDTLS_ERR_PK_TYPE_MISMATCH );
 157     TEST_ASSERT( mbedtls_pk_decrypt( &pk, b1, sizeof( b1 ),
 158                                      b2, &len, sizeof( b2 ),
 159                                      NULL, NULL )
 160                  == MBEDTLS_ERR_PK_TYPE_MISMATCH );
 161     TEST_ASSERT( mbedtls_pk_encrypt( &pk, b1, sizeof( b1 ),
 162                                      b2, &len, sizeof( b2 ),
 163                                      NULL, NULL )
 164                  == MBEDTLS_ERR_PK_TYPE_MISMATCH );
 165
 166     /* unsupported functions: check_pair, debug */
 167     TEST_ASSERT( mbedtls_pk_setup( &pk2,
 168                  mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
 169     TEST_ASSERT( mbedtls_pk_check_pair( &pk, &pk2 )
 170                  == MBEDTLS_ERR_PK_TYPE_MISMATCH );
 171     TEST_ASSERT( mbedtls_pk_debug( &pk, &dbg )
 172                  == MBEDTLS_ERR_PK_TYPE_MISMATCH );
 173
 174     /* test that freeing the context does not destroy the key */
 175     mbedtls_pk_free( &pk );
 176     TEST_ASSERT( PSA_SUCCESS == psa_get_key_information( key, NULL, NULL ) );
 177     TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key ) );
 178
 179 exit:
 180     mbedtls_pk_free( &pk ); /* redundant except upon error */
 181     mbedtls_pk_free( &pk2 );
 182 }
 183 /* END_CASE */
 184
 185
 186 /* BEGIN_CASE */
 187 void valid_parameters( )
 188 {
 189     mbedtls_pk_context pk;
 190     unsigned char buf[1];
 191     size_t len;
 192     void *options = NULL;
 193
 194     mbedtls_pk_init( &pk );
 195
 196     TEST_VALID_PARAM( mbedtls_pk_free( NULL ) );
 197
 198 #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 199     TEST_VALID_PARAM( mbedtls_pk_restart_free( NULL ) );
 200 #endif
 201
 202     TEST_ASSERT( mbedtls_pk_setup( &pk, NULL ) ==
 203                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 204
 205     /* In informational functions, we accept NULL where a context pointer
 206      * is expected because that's what the library has done forever.
 207      * We do not document that NULL is accepted, so we may wish to change
 208      * the behavior in a future version. */
 209     TEST_ASSERT( mbedtls_pk_get_bitlen( NULL ) == 0 );
 210     TEST_ASSERT( mbedtls_pk_get_len( NULL ) == 0 );
 211     TEST_ASSERT( mbedtls_pk_can_do( NULL, MBEDTLS_PK_NONE ) == 0 );
 212
 213     TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
 214                                               MBEDTLS_MD_NONE,
 215                                               NULL, 0,
 216                                               buf, &len,
 217                                               rnd_std_rand, NULL,
 218                                               NULL ) ==
 219                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 220
 221     TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
 222                                               MBEDTLS_MD_NONE,
 223                                               NULL, 0,
 224                                               buf, &len,
 225                                               rnd_std_rand, NULL,
 226                                               NULL ) ==
 227                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 228
 229     TEST_ASSERT( mbedtls_pk_sign( &pk,
 230                                   MBEDTLS_MD_NONE,
 231                                   NULL, 0,
 232                                   buf, &len,
 233                                   rnd_std_rand, NULL ) ==
 234                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 235
 236     TEST_ASSERT( mbedtls_pk_verify_restartable( &pk,
 237                                                 MBEDTLS_MD_NONE,
 238                                                 NULL, 0,
 239                                                 buf, sizeof( buf ),
 240                                                 NULL ) ==
 241                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 242
 243     TEST_ASSERT( mbedtls_pk_verify( &pk,
 244                                     MBEDTLS_MD_NONE,
 245                                     NULL, 0,
 246                                     buf, sizeof( buf ) ) ==
 247                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 248
 249     TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
 250                                         &pk,
 251                                         MBEDTLS_MD_NONE,
 252                                         NULL, 0,
 253                                         buf, sizeof( buf ) ) ==
 254                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 255
 256     TEST_ASSERT( mbedtls_pk_encrypt( &pk,
 257                                      NULL, 0,
 258                                      NULL, &len, 0,
 259                                      rnd_std_rand, NULL ) ==
 260                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 261
 262     TEST_ASSERT( mbedtls_pk_decrypt( &pk,
 263                                      NULL, 0,
 264                                      NULL, &len, 0,
 265                                      rnd_std_rand, NULL ) ==
 266                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 267
 268 #if defined(MBEDTLS_PK_PARSE_C)
 269     TEST_ASSERT( mbedtls_pk_parse_key( &pk, NULL, 0, NULL, 1 ) ==
 270                  MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
 271
 272     TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, NULL, 0 ) ==
 273                  MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
 274 #endif /* MBEDTLS_PK_PARSE_C */
 275 }
 276 /* END_CASE */
 277
 278 /* BEGIN_CASE depends_on:MBEDTLS_PK_WRITE_C */
 279 void valid_parameters_pkwrite( data_t *key_data )
 280 {
 281     mbedtls_pk_context pk;
 282
 283     /* For the write tests to be effective, we need a valid key pair. */
 284     mbedtls_pk_init( &pk );
 285     TEST_ASSERT( mbedtls_pk_parse_key( &pk,
 286                                        key_data->x, key_data->len,
 287                                        NULL, 0 ) == 0 );
 288
 289     TEST_ASSERT( mbedtls_pk_write_key_der( &pk, NULL, 0 ) ==
 290                  MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
 291
 292     TEST_ASSERT( mbedtls_pk_write_pubkey_der( &pk, NULL, 0 ) ==
 293                  MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
 294
 295 #if defined(MBEDTLS_PEM_WRITE_C)
 296     TEST_ASSERT( mbedtls_pk_write_key_pem( &pk, NULL, 0 ) ==
 297                  MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
 298
 299     TEST_ASSERT( mbedtls_pk_write_pubkey_pem( &pk, NULL, 0 ) ==
 300                  MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
 301 #endif /* MBEDTLS_PEM_WRITE_C */
 302
 303 exit:
 304     mbedtls_pk_free( &pk );
 305 }
 306 /* END_CASE */
 307
 308 /* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
 309 void invalid_parameters( )
 310 {
 311     size_t len;
 312     unsigned char *null_buf = NULL;
 313     unsigned char buf[1];
 314     unsigned char *p = buf;
 315     char str[1] = {0};
 316     mbedtls_pk_context pk;
 317     mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
 318     void *options = buf;
 319
 320     (void) null_buf;
 321     (void) p;
 322     (void) str;
 323
 324     mbedtls_pk_init( &pk );
 325
 326     TEST_INVALID_PARAM( mbedtls_pk_init( NULL ) );
 327
 328 #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 329     TEST_INVALID_PARAM( mbedtls_pk_restart_init( NULL ) );
 330 #endif
 331
 332     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 333                             mbedtls_pk_setup( NULL, NULL ) );
 334
 335 #if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
 336     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 337                             mbedtls_pk_setup_rsa_alt( NULL, buf,
 338                                                       NULL, NULL, NULL ) );
 339 #endif
 340
 341     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 342                             mbedtls_pk_verify_restartable( NULL,
 343                                                            MBEDTLS_MD_NONE,
 344                                                            buf, sizeof( buf ),
 345                                                            buf, sizeof( buf ),
 346                                                            NULL ) );
 347     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 348                             mbedtls_pk_verify_restartable( &pk,
 349                                                            MBEDTLS_MD_NONE,
 350                                                            NULL, sizeof( buf ),
 351                                                            buf, sizeof( buf ),
 352                                                            NULL ) );
 353     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 354                             mbedtls_pk_verify_restartable( &pk,
 355                                                            valid_md,
 356                                                            NULL, 0,
 357                                                            buf, sizeof( buf ),
 358                                                            NULL ) );
 359     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 360                             mbedtls_pk_verify_restartable( &pk,
 361                                                            MBEDTLS_MD_NONE,
 362                                                            buf, sizeof( buf ),
 363                                                            NULL, sizeof( buf ),
 364                                                            NULL ) );
 365
 366     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 367                             mbedtls_pk_verify( NULL,
 368                                                MBEDTLS_MD_NONE,
 369                                                buf, sizeof( buf ),
 370                                                buf, sizeof( buf ) ) );
 371     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 372                             mbedtls_pk_verify( &pk,
 373                                                MBEDTLS_MD_NONE,
 374                                                NULL, sizeof( buf ),
 375                                                buf, sizeof( buf ) ) );
 376     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 377                             mbedtls_pk_verify( &pk,
 378                                                valid_md,
 379                                                NULL, 0,
 380                                                buf, sizeof( buf ) ) );
 381     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 382                             mbedtls_pk_verify( &pk,
 383                                                MBEDTLS_MD_NONE,
 384                                                buf, sizeof( buf ),
 385                                                NULL, sizeof( buf ) ) );
 386
 387     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 388                             mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
 389                                                    NULL,
 390                                                    MBEDTLS_MD_NONE,
 391                                                    buf, sizeof( buf ),
 392                                                    buf, sizeof( buf ) ) );
 393     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 394                             mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
 395                                                    &pk,
 396                                                    MBEDTLS_MD_NONE,
 397                                                    NULL, sizeof( buf ),
 398                                                    buf, sizeof( buf ) ) );
 399     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 400                             mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
 401                                                    &pk,
 402                                                    valid_md,
 403                                                    NULL, 0,
 404                                                    buf, sizeof( buf ) ) );
 405     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 406                             mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
 407                                                    &pk,
 408                                                    MBEDTLS_MD_NONE,
 409                                                    buf, sizeof( buf ),
 410                                                    NULL, sizeof( buf ) ) );
 411
 412     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 413                             mbedtls_pk_sign_restartable( NULL,
 414                                                          MBEDTLS_MD_NONE,
 415                                                          buf, sizeof( buf ),
 416                                                          buf, &len,
 417                                                          rnd_std_rand, NULL,
 418                                                          NULL ) );
 419     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 420                             mbedtls_pk_sign_restartable( &pk,
 421                                                          MBEDTLS_MD_NONE,
 422                                                          NULL, sizeof( buf ),
 423                                                          buf, &len,
 424                                                          rnd_std_rand, NULL,
 425                                                          NULL ) );
 426     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 427                             mbedtls_pk_sign_restartable( &pk,
 428                                                          valid_md,
 429                                                          NULL, 0,
 430                                                          buf, &len,
 431                                                          rnd_std_rand, NULL,
 432                                                          NULL ) );
 433     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 434                             mbedtls_pk_sign_restartable( &pk,
 435                                                          MBEDTLS_MD_NONE,
 436                                                          buf, sizeof( buf ),
 437                                                          NULL, &len,
 438                                                          rnd_std_rand, NULL,
 439                                                          NULL ) );
 440
 441     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 442                             mbedtls_pk_sign( NULL,
 443                                              MBEDTLS_MD_NONE,
 444                                              buf, sizeof( buf ),
 445                                              buf, &len,
 446                                              rnd_std_rand, NULL ) );
 447     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 448                             mbedtls_pk_sign( &pk,
 449                                              MBEDTLS_MD_NONE,
 450                                              NULL, sizeof( buf ),
 451                                              buf, &len,
 452                                              rnd_std_rand, NULL ) );
 453     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 454                             mbedtls_pk_sign( &pk,
 455                                              valid_md,
 456                                              NULL, 0,
 457                                              buf, &len,
 458                                              rnd_std_rand, NULL ) );
 459     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 460                             mbedtls_pk_sign( &pk,
 461                                              MBEDTLS_MD_NONE,
 462                                              buf, sizeof( buf ),
 463                                              NULL, &len,
 464                                              rnd_std_rand, NULL ) );
 465
 466     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 467                             mbedtls_pk_decrypt( NULL,
 468                                                 buf, sizeof( buf ),
 469                                                 buf, &len, sizeof( buf ),
 470                                                 rnd_std_rand, NULL ) );
 471     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 472                             mbedtls_pk_decrypt( &pk,
 473                                                 NULL, sizeof( buf ),
 474                                                 buf, &len, sizeof( buf ),
 475                                                 rnd_std_rand, NULL ) );
 476     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 477                             mbedtls_pk_decrypt( &pk,
 478                                                 buf, sizeof( buf ),
 479                                                 NULL, &len, sizeof( buf ),
 480                                                 rnd_std_rand, NULL ) );
 481     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 482                             mbedtls_pk_decrypt( &pk,
 483                                                 buf, sizeof( buf ),
 484                                                 buf, NULL, sizeof( buf ),
 485                                                 rnd_std_rand, NULL ) );
 486
 487     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 488                             mbedtls_pk_encrypt( NULL,
 489                                                 buf, sizeof( buf ),
 490                                                 buf, &len, sizeof( buf ),
 491                                                 rnd_std_rand, NULL ) );
 492     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 493                             mbedtls_pk_encrypt( &pk,
 494                                                 NULL, sizeof( buf ),
 495                                                 buf, &len, sizeof( buf ),
 496                                                 rnd_std_rand, NULL ) );
 497     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 498                             mbedtls_pk_encrypt( &pk,
 499                                                 buf, sizeof( buf ),
 500                                                 NULL, &len, sizeof( buf ),
 501                                                 rnd_std_rand, NULL ) );
 502     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 503                             mbedtls_pk_encrypt( &pk,
 504                                                 buf, sizeof( buf ),
 505                                                 buf, NULL, sizeof( buf ),
 506                                                 rnd_std_rand, NULL ) );
 507
 508     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 509                             mbedtls_pk_check_pair( NULL, &pk ) );
 510     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 511                             mbedtls_pk_check_pair( &pk, NULL ) );
 512
 513     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 514                             mbedtls_pk_debug( NULL, NULL ) );
 515
 516 #if defined(MBEDTLS_PK_PARSE_C)
 517 #if defined(MBEDTLS_FS_IO)
 518     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 519                             mbedtls_pk_load_file( NULL, &p, &len ) );
 520     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 521                             mbedtls_pk_load_file( str, NULL, &len ) );
 522     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 523                             mbedtls_pk_load_file( str, &p, NULL ) );
 524
 525     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 526                             mbedtls_pk_parse_keyfile( NULL, str, NULL ) );
 527     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 528                             mbedtls_pk_parse_keyfile( &pk, NULL, NULL ) );
 529
 530     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 531                             mbedtls_pk_parse_public_keyfile( NULL, str ) );
 532     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 533                             mbedtls_pk_parse_public_keyfile( &pk, NULL ) );
 534 #endif
 535
 536     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 537                             mbedtls_pk_parse_subpubkey( NULL, buf, &pk ) );
 538     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 539                             mbedtls_pk_parse_subpubkey( &null_buf, buf, &pk ) );
 540     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 541                             mbedtls_pk_parse_subpubkey( &p, NULL, &pk ) );
 542     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 543                             mbedtls_pk_parse_subpubkey( &p, buf, NULL ) );
 544
 545     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 546                             mbedtls_pk_parse_key( NULL,
 547                                                   buf, sizeof( buf ),
 548                                                   buf, sizeof( buf ) ) );
 549     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 550                             mbedtls_pk_parse_key( &pk,
 551                                                   NULL, sizeof( buf ),
 552                                                   buf, sizeof( buf ) ) );
 553
 554     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 555                             mbedtls_pk_parse_public_key( NULL,
 556                                                          buf, sizeof( buf ) ) );
 557     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 558                             mbedtls_pk_parse_public_key( &pk,
 559                                                          NULL, sizeof( buf ) ) );
 560 #endif /* MBEDTLS_PK_PARSE_C */
 561
 562 #if defined(MBEDTLS_PK_WRITE_C)
 563     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 564                             mbedtls_pk_write_pubkey( NULL, p, &pk ) );
 565     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 566                             mbedtls_pk_write_pubkey( &null_buf, p, &pk ) );
 567     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 568                             mbedtls_pk_write_pubkey( &p, NULL, &pk ) );
 569     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 570                             mbedtls_pk_write_pubkey( &p, p, NULL ) );
 571
 572     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 573                             mbedtls_pk_write_pubkey_der( NULL,
 574                                                          buf, sizeof( buf ) ) );
 575     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 576                             mbedtls_pk_write_pubkey_der( &pk,
 577                                                          NULL, sizeof( buf ) ) );
 578
 579     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 580                             mbedtls_pk_write_key_der( NULL,
 581                                                       buf, sizeof( buf ) ) );
 582     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 583                             mbedtls_pk_write_key_der( &pk,
 584                                                       NULL, sizeof( buf ) ) );
 585
 586 #if defined(MBEDTLS_PEM_WRITE_C)
 587     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 588                             mbedtls_pk_write_pubkey_pem( NULL,
 589                                                          buf, sizeof( buf ) ) );
 590     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 591                             mbedtls_pk_write_pubkey_pem( &pk,
 592                                                          NULL, sizeof( buf ) ) );
 593
 594     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 595                             mbedtls_pk_write_key_pem( NULL,
 596                                                       buf, sizeof( buf ) ) );
 597     TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
 598                             mbedtls_pk_write_key_pem( &pk,
 599                                                       NULL, sizeof( buf ) ) );
 600 #endif /* MBEDTLS_PEM_WRITE_C */
 601
 602 #endif /* MBEDTLS_PK_WRITE_C */
 603 }
 604 /* END_CASE */
 605
 606 /* BEGIN_CASE */
 607 void pk_utils( int type, int size, int len, char * name )
 608 {
 609     mbedtls_pk_context pk;
 610
 611     mbedtls_pk_init( &pk );
 612
 613     TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
 614     TEST_ASSERT( pk_genkey( &pk ) == 0 );
 615
 616     TEST_ASSERT( (int) mbedtls_pk_get_type( &pk ) == type );
 617     TEST_ASSERT( mbedtls_pk_can_do( &pk, type ) );
 618     TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == (unsigned) size );
 619     TEST_ASSERT( mbedtls_pk_get_len( &pk ) == (unsigned) len );
 620     TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
 621
 622 exit:
 623     mbedtls_pk_free( &pk );
 624 }
 625 /* END_CASE */
 626
 627 /* BEGIN_CASE depends_on:MBEDTLS_PK_PARSE_C:MBEDTLS_FS_IO */
 628 void mbedtls_pk_check_pair( char * pub_file, char * prv_file, int ret )
 629 {
 630     mbedtls_pk_context pub, prv, alt;
 631
 632     mbedtls_pk_init( &pub );
 633     mbedtls_pk_init( &prv );
 634     mbedtls_pk_init( &alt );
 635
 636     TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &pub, pub_file ) == 0 );
 637     TEST_ASSERT( mbedtls_pk_parse_keyfile( &prv, prv_file, NULL ) == 0 );
 638
 639     TEST_ASSERT( mbedtls_pk_check_pair( &pub, &prv ) == ret );
 640
 641 #if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
 642     if( mbedtls_pk_get_type( &prv ) == MBEDTLS_PK_RSA )
 643     {
 644         TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, mbedtls_pk_rsa( prv ),
 645                      mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
 646                      mbedtls_rsa_key_len_func ) == 0 );
 647         TEST_ASSERT( mbedtls_pk_check_pair( &pub, &alt ) == ret );
 648     }
 649 #endif
 650
 651     mbedtls_pk_free( &pub );
 652     mbedtls_pk_free( &prv );
 653     mbedtls_pk_free( &alt );
 654 }
 655 /* END_CASE */
 656
 657 /* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
 658 void pk_rsa_verify_test_vec( data_t * message_str, int digest, int mod,
 659                              int radix_N, char * input_N, int radix_E,
 660                              char * input_E, data_t * result_str,
 661                              int result )
 662 {
 663     unsigned char hash_result[1000];
 664     mbedtls_rsa_context *rsa;
 665     mbedtls_pk_context pk;
 666     mbedtls_pk_restart_ctx *rs_ctx = NULL;
 667 #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 668     mbedtls_pk_restart_ctx ctx;
 669
 670     rs_ctx = &ctx;
 671     mbedtls_pk_restart_init( rs_ctx );
 672     // this setting would ensure restart would happen if ECC was used
 673     mbedtls_ecp_set_max_ops( 1 );
 674 #endif
 675
 676     mbedtls_pk_init( &pk );
 677
 678     memset( hash_result, 0x00, 1000 );
 679
 680     TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
 681     rsa = mbedtls_pk_rsa( pk );
 682
 683     rsa->len = mod / 8;
 684     TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
 685     TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
 686
 687
 688     if( mbedtls_md_info_from_type( digest ) != NULL )
 689         TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
 690
 691     TEST_ASSERT( mbedtls_pk_verify( &pk, digest, hash_result, 0,
 692                             result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
 693
 694     TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, digest, hash_result, 0,
 695                     result_str->x, mbedtls_pk_get_len( &pk ), rs_ctx ) == result );
 696
 697 exit:
 698 #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 699     mbedtls_pk_restart_free( rs_ctx );
 700 #endif
 701     mbedtls_pk_free( &pk );
 702 }
 703 /* END_CASE */
 704
 705 /* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
 706 void pk_rsa_verify_ext_test_vec( data_t * message_str, int digest,
 707                                  int mod, int radix_N, char * input_N,
 708                                  int radix_E, char * input_E,
 709                                  data_t * result_str, int pk_type,
 710                                  int mgf1_hash_id, int salt_len, int result )
 711 {
 712     unsigned char hash_result[1000];
 713     mbedtls_rsa_context *rsa;
 714     mbedtls_pk_context pk;
 715     mbedtls_pk_rsassa_pss_options pss_opts;
 716     void *options;
 717     size_t hash_len;
 718
 719     mbedtls_pk_init( &pk );
 720
 721     memset( hash_result, 0x00, 1000 );
 722
 723     TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
 724     rsa = mbedtls_pk_rsa( pk );
 725
 726     rsa->len = mod / 8;
 727     TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
 728     TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
 729
 730
 731     if( digest != MBEDTLS_MD_NONE )
 732     {
 733         TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ),
 734                      message_str->x, message_str->len, hash_result ) == 0 );
 735         hash_len = 0;
 736     }
 737     else
 738     {
 739         memcpy( hash_result, message_str->x, message_str->len );
 740         hash_len = message_str->len;
 741     }
 742
 743     if( mgf1_hash_id < 0 )
 744     {
 745         options = NULL;
 746     }
 747     else
 748     {
 749         options = &pss_opts;
 750
 751         pss_opts.mgf1_hash_id = mgf1_hash_id;
 752         pss_opts.expected_salt_len = salt_len;
 753     }
 754
 755     TEST_ASSERT( mbedtls_pk_verify_ext( pk_type, options, &pk,
 756                                 digest, hash_result, hash_len,
 757                                 result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
 758
 759 exit:
 760     mbedtls_pk_free( &pk );
 761 }
 762 /* END_CASE */
 763
 764 /* BEGIN_CASE depends_on:MBEDTLS_ECDSA_C */
 765 void pk_ec_test_vec( int type, int id, data_t * key, data_t * hash,
 766                      data_t * sig, int ret )
 767 {
 768     mbedtls_pk_context pk;
 769     mbedtls_ecp_keypair *eckey;
 770
 771     mbedtls_pk_init( &pk );
 772
 773
 774     TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
 775
 776     TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) );
 777     eckey = mbedtls_pk_ec( pk );
 778
 779     TEST_ASSERT( mbedtls_ecp_group_load( &eckey->grp, id ) == 0 );
 780     TEST_ASSERT( mbedtls_ecp_point_read_binary( &eckey->grp, &eckey->Q,
 781                                         key->x, key->len ) == 0 );
 782
 783     // MBEDTLS_MD_SHA1 is a dummy - it is ignored, but has to be other than MBEDTLS_MD_NONE.
 784     TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA1,
 785                             hash->x, hash->len, sig->x, sig->len ) == ret );
 786
 787 exit:
 788     mbedtls_pk_free( &pk );
 789 }
 790 /* END_CASE */
 791
 792 /* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECDSA_C:MBEDTLS_ECDSA_DETERMINISTIC */
 793 void pk_sign_verify_restart( int pk_type, int grp_id, char *d_str,
 794                               char *QX_str, char *QY_str,
 795                               int md_alg, char *msg, char *sig_str,
 796                               int max_ops, int min_restart, int max_restart )
 797 {
 798     int ret, cnt_restart;
 799     mbedtls_pk_restart_ctx rs_ctx;
 800     mbedtls_pk_context prv, pub;
 801     unsigned char hash[MBEDTLS_MD_MAX_SIZE];
 802     unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
 803     unsigned char sig_check[MBEDTLS_ECDSA_MAX_LEN];
 804     size_t hlen, slen, slen_check;
 805     const mbedtls_md_info_t *md_info;
 806
 807     mbedtls_pk_restart_init( &rs_ctx );
 808     mbedtls_pk_init( &prv );
 809     mbedtls_pk_init( &pub );
 810     memset( hash, 0, sizeof( hash ) );
 811     memset( sig, 0, sizeof( sig ) );
 812     memset( sig_check, 0, sizeof( sig_check ) );
 813
 814     TEST_ASSERT( mbedtls_pk_setup( &prv, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
 815     TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( prv )->grp, grp_id ) == 0 );
 816     TEST_ASSERT( mbedtls_mpi_read_string( &mbedtls_pk_ec( prv )->d, 16, d_str ) == 0 );
 817
 818     TEST_ASSERT( mbedtls_pk_setup( &pub, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
 819     TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( pub )->grp, grp_id ) == 0 );
 820     TEST_ASSERT( mbedtls_ecp_point_read_string( &mbedtls_pk_ec( pub )->Q, 16, QX_str, QY_str ) == 0 );
 821
 822     slen_check = unhexify( sig_check, sig_str );
 823
 824     md_info = mbedtls_md_info_from_type( md_alg );
 825     TEST_ASSERT( md_info != NULL );
 826
 827     hlen = mbedtls_md_get_size( md_info );
 828     mbedtls_md( md_info, (const unsigned char *) msg, strlen( msg ), hash );
 829
 830     mbedtls_ecp_set_max_ops( max_ops );
 831
 832     slen = sizeof( sig );
 833     cnt_restart = 0;
 834     do {
 835         ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
 836                                             sig, &slen, NULL, NULL, &rs_ctx );
 837     } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
 838
 839     TEST_ASSERT( ret == 0 );
 840     TEST_ASSERT( slen == slen_check );
 841     TEST_ASSERT( memcmp( sig, sig_check, slen ) == 0 );
 842
 843     TEST_ASSERT( cnt_restart >= min_restart );
 844     TEST_ASSERT( cnt_restart <= max_restart );
 845
 846     cnt_restart = 0;
 847     do {
 848         ret = mbedtls_pk_verify_restartable( &pub, md_alg,
 849                                  hash, hlen, sig, slen, &rs_ctx );
 850     } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
 851
 852     TEST_ASSERT( ret == 0 );
 853     TEST_ASSERT( cnt_restart >= min_restart );
 854     TEST_ASSERT( cnt_restart <= max_restart );
 855
 856     hash[0]++;
 857     do {
 858         ret = mbedtls_pk_verify_restartable( &pub, md_alg,
 859                                  hash, hlen, sig, slen, &rs_ctx );
 860     } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
 861     TEST_ASSERT( ret != 0 );
 862     hash[0]--;
 863
 864     sig[0]++;
 865     do {
 866         ret = mbedtls_pk_verify_restartable( &pub, md_alg,
 867                                  hash, hlen, sig, slen, &rs_ctx );
 868     } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
 869     TEST_ASSERT( ret != 0 );
 870     sig[0]--;
 871
 872     /* Do we leak memory when aborting? try verify then sign
 873      * This test only makes sense when we actually restart */
 874     if( min_restart > 0 )
 875     {
 876         ret = mbedtls_pk_verify_restartable( &pub, md_alg,
 877                                  hash, hlen, sig, slen, &rs_ctx );
 878         TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
 879         mbedtls_pk_restart_free( &rs_ctx );
 880
 881         slen = sizeof( sig );
 882         ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
 883                                             sig, &slen, NULL, NULL, &rs_ctx );
 884         TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
 885     }
 886
 887 exit:
 888     mbedtls_pk_restart_free( &rs_ctx );
 889     mbedtls_pk_free( &prv );
 890     mbedtls_pk_free( &pub );
 891 }
 892 /* END_CASE */
 893
 894 /* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
 895 void pk_sign_verify( int type, int sign_ret, int verify_ret )
 896 {
 897     mbedtls_pk_context pk;
 898     unsigned char hash[50], sig[5000];
 899     size_t sig_len;
 900     void *rs_ctx = NULL;
 901 #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 902     mbedtls_pk_restart_ctx ctx;
 903
 904     rs_ctx = &ctx;
 905     mbedtls_pk_restart_init( rs_ctx );
 906     /* This value is large enough that the operation will complete in one run.
 907      * See comments at the top of ecp_test_vect_restart in
 908      * test_suite_ecp.function for estimates of operation counts. */
 909     mbedtls_ecp_set_max_ops( 42000 );
 910 #endif
 911
 912     mbedtls_pk_init( &pk );
 913
 914     memset( hash, 0x2a, sizeof hash );
 915     memset( sig, 0, sizeof sig );
 916
 917     TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
 918     TEST_ASSERT( pk_genkey( &pk ) == 0 );
 919
 920     TEST_ASSERT( mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_SHA256,
 921                  hash, sizeof hash, sig, &sig_len,
 922                  rnd_std_rand, NULL, rs_ctx ) == sign_ret );
 923
 924     TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
 925                             hash, sizeof hash, sig, sig_len ) == verify_ret );
 926
 927     if( verify_ret == 0 )
 928     {
 929         hash[0]++;
 930         TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
 931                                 hash, sizeof hash, sig, sig_len ) != 0 );
 932         hash[0]--;
 933
 934         sig[0]++;
 935         TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
 936                                 hash, sizeof hash, sig, sig_len ) != 0 );
 937         sig[0]--;
 938     }
 939
 940     TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256, hash, sizeof hash,
 941                           sig, &sig_len, rnd_std_rand, NULL ) == sign_ret );
 942
 943     TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
 944                  hash, sizeof hash, sig, sig_len, rs_ctx ) == verify_ret );
 945
 946     if( verify_ret == 0 )
 947     {
 948         hash[0]++;
 949         TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
 950                      hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
 951         hash[0]--;
 952
 953         sig[0]++;
 954         TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, MBEDTLS_MD_SHA256,
 955                      hash, sizeof hash, sig, sig_len, rs_ctx ) != 0 );
 956         sig[0]--;
 957     }
 958
 959 exit:
 960 #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
 961     mbedtls_pk_restart_free( rs_ctx );
 962 #endif
 963     mbedtls_pk_free( &pk );
 964 }
 965 /* END_CASE */
 966
 967 /* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
 968 void pk_rsa_encrypt_test_vec( data_t * message, int mod, int radix_N,
 969                               char * input_N, int radix_E, char * input_E,
 970                               data_t * result, int ret )
 971 {
 972     unsigned char output[1000];
 973     rnd_pseudo_info rnd_info;
 974     mbedtls_rsa_context *rsa;
 975     mbedtls_pk_context pk;
 976     size_t olen;
 977
 978     memset( &rnd_info,  0, sizeof( rnd_pseudo_info ) );
 979     memset( output,     0, sizeof( output ) );
 980
 981
 982     mbedtls_pk_init( &pk );
 983     TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
 984     rsa = mbedtls_pk_rsa( pk );
 985
 986     rsa->len = mod / 8;
 987     TEST_ASSERT( mbedtls_mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
 988     TEST_ASSERT( mbedtls_mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
 989
 990     TEST_ASSERT( mbedtls_pk_encrypt( &pk, message->x, message->len,
 991                              output, &olen, sizeof( output ),
 992                              rnd_pseudo_rand, &rnd_info ) == ret );
 993     TEST_ASSERT( olen == result->len );
 994     TEST_ASSERT( memcmp( output, result->x, olen ) == 0 );
 995
 996 exit:
 997     mbedtls_pk_free( &pk );
 998 }
 999 /* END_CASE */
1000
1001 /* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
1002 void pk_rsa_decrypt_test_vec( data_t * cipher, int mod, int radix_P,
1003                               char * input_P, int radix_Q, char * input_Q,
1004                               int radix_N, char * input_N, int radix_E,
1005                               char * input_E, data_t * clear, int ret )
1006 {
1007     unsigned char output[1000];
1008     rnd_pseudo_info rnd_info;
1009     mbedtls_mpi N, P, Q, E;
1010     mbedtls_rsa_context *rsa;
1011     mbedtls_pk_context pk;
1012     size_t olen;
1013
1014     mbedtls_pk_init( &pk );
1015     mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
1016     mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
1017
1018     memset( &rnd_info,  0, sizeof( rnd_pseudo_info ) );
1019
1020
1021     /* init pk-rsa context */
1022     TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
1023     rsa = mbedtls_pk_rsa( pk );
1024
1025     /* load public key */
1026     TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
1027     TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
1028
1029     /* load private key */
1030     TEST_ASSERT( mbedtls_mpi_read_string( &P, radix_P, input_P ) == 0 );
1031     TEST_ASSERT( mbedtls_mpi_read_string( &Q, radix_Q, input_Q ) == 0 );
1032     TEST_ASSERT( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ) == 0 );
1033     TEST_ASSERT( mbedtls_rsa_get_len( rsa ) == (size_t) ( mod / 8 ) );
1034     TEST_ASSERT( mbedtls_rsa_complete( rsa ) == 0 );
1035
1036     /* decryption test */
1037     memset( output, 0, sizeof( output ) );
1038     olen = 0;
1039     TEST_ASSERT( mbedtls_pk_decrypt( &pk, cipher->x, cipher->len,
1040                              output, &olen, sizeof( output ),
1041                              rnd_pseudo_rand, &rnd_info ) == ret );
1042     if( ret == 0 )
1043     {
1044         TEST_ASSERT( olen == clear->len );
1045         TEST_ASSERT( memcmp( output, clear->x, olen ) == 0 );
1046     }
1047
1048 exit:
1049     mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
1050     mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
1051     mbedtls_pk_free( &pk );
1052 }
1053 /* END_CASE */
1054
1055 /* BEGIN_CASE */
1056 void pk_ec_nocrypt( int type )
1057 {
1058     mbedtls_pk_context pk;
1059     unsigned char output[100];
1060     unsigned char input[100];
1061     rnd_pseudo_info rnd_info;
1062     size_t olen = 0;
1063     int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
1064
1065     mbedtls_pk_init( &pk );
1066
1067     memset( &rnd_info,  0, sizeof( rnd_pseudo_info ) );
1068     memset( output,     0, sizeof( output ) );
1069     memset( input,      0, sizeof( input ) );
1070
1071     TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
1072
1073     TEST_ASSERT( mbedtls_pk_encrypt( &pk, input, sizeof( input ),
1074                              output, &olen, sizeof( output ),
1075                              rnd_pseudo_rand, &rnd_info ) == ret );
1076
1077     TEST_ASSERT( mbedtls_pk_decrypt( &pk, input, sizeof( input ),
1078                              output, &olen, sizeof( output ),
1079                              rnd_pseudo_rand, &rnd_info ) == ret );
1080
1081 exit:
1082     mbedtls_pk_free( &pk );
1083 }
1084 /* END_CASE */
1085
1086 /* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
1087 void pk_rsa_overflow( )
1088 {
1089     mbedtls_pk_context pk;
1090     size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX;
1091     unsigned char hash[50], sig[100];
1092
1093     if( SIZE_MAX <= UINT_MAX )
1094         return;
1095
1096     memset( hash, 0x2a, sizeof hash );
1097     memset( sig, 0, sizeof sig );
1098
1099     mbedtls_pk_init( &pk );
1100
1101     TEST_ASSERT( mbedtls_pk_setup( &pk,
1102                  mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
1103
1104 #if defined(MBEDTLS_PKCS1_V21)
1105     TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_RSASSA_PSS, NULL, &pk,
1106                     MBEDTLS_MD_NONE, hash, hash_len, sig, sig_len ) ==
1107                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
1108 #endif /* MBEDTLS_PKCS1_V21 */
1109
1110     TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE, hash, hash_len,
1111                     sig, sig_len ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
1112
1113     TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, hash, hash_len, sig, &sig_len,
1114                     rnd_std_rand, NULL ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
1115
1116 exit:
1117     mbedtls_pk_free( &pk );
1118 }
1119 /* END_CASE */
1120
1121 /* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_PK_RSA_ALT_SUPPORT */
1122 void pk_rsa_alt(  )
1123 {
1124     /*
1125      * An rsa_alt context can only do private operations (decrypt, sign).
1126      * Test it against the public operations (encrypt, verify) of a
1127      * corresponding rsa context.
1128      */
1129     mbedtls_rsa_context raw;
1130     mbedtls_pk_context rsa, alt;
1131     mbedtls_pk_debug_item dbg_items[10];
1132     unsigned char hash[50], sig[1000];
1133     unsigned char msg[50], ciph[1000], test[1000];
1134     size_t sig_len, ciph_len, test_len;
1135     int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
1136
1137     mbedtls_rsa_init( &raw, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE );
1138     mbedtls_pk_init( &rsa ); mbedtls_pk_init( &alt );
1139
1140     memset( hash, 0x2a, sizeof hash );
1141     memset( sig, 0, sizeof sig );
1142     memset( msg, 0x2a, sizeof msg );
1143     memset( ciph, 0, sizeof ciph );
1144     memset( test, 0, sizeof test );
1145
1146     /* Initiliaze PK RSA context with random key */
1147     TEST_ASSERT( mbedtls_pk_setup( &rsa,
1148                               mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
1149     TEST_ASSERT( pk_genkey( &rsa ) == 0 );
1150
1151     /* Extract key to the raw rsa context */
1152     TEST_ASSERT( mbedtls_rsa_copy( &raw, mbedtls_pk_rsa( rsa ) ) == 0 );
1153
1154     /* Initialize PK RSA_ALT context */
1155     TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, (void *) &raw,
1156                  mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func ) == 0 );
1157
1158     /* Test administrative functions */
1159     TEST_ASSERT( mbedtls_pk_can_do( &alt, MBEDTLS_PK_RSA ) );
1160     TEST_ASSERT( mbedtls_pk_get_bitlen( &alt ) == RSA_KEY_SIZE );
1161     TEST_ASSERT( mbedtls_pk_get_len( &alt ) == RSA_KEY_LEN );
1162     TEST_ASSERT( mbedtls_pk_get_type( &alt ) == MBEDTLS_PK_RSA_ALT );
1163     TEST_ASSERT( strcmp( mbedtls_pk_get_name( &alt ), "RSA-alt" ) == 0 );
1164
1165     /* Test signature */
1166 #if SIZE_MAX > UINT_MAX
1167     TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, SIZE_MAX,
1168                                   sig, &sig_len, rnd_std_rand, NULL ) ==
1169                  MBEDTLS_ERR_PK_BAD_INPUT_DATA );
1170 #endif /* SIZE_MAX > UINT_MAX */
1171     TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, sizeof hash,
1172                                   sig, &sig_len, rnd_std_rand, NULL ) == 0 );
1173     TEST_ASSERT( sig_len == RSA_KEY_LEN );
1174     TEST_ASSERT( mbedtls_pk_verify( &rsa, MBEDTLS_MD_NONE,
1175                             hash, sizeof hash, sig, sig_len ) == 0 );
1176
1177     /* Test decrypt */
1178     TEST_ASSERT( mbedtls_pk_encrypt( &rsa, msg, sizeof msg,
1179                              ciph, &ciph_len, sizeof ciph,
1180                              rnd_std_rand, NULL ) == 0 );
1181     TEST_ASSERT( mbedtls_pk_decrypt( &alt, ciph, ciph_len,
1182                              test, &test_len, sizeof test,
1183                              rnd_std_rand, NULL ) == 0 );
1184     TEST_ASSERT( test_len == sizeof msg );
1185     TEST_ASSERT( memcmp( test, msg, test_len ) == 0 );
1186
1187     /* Test forbidden operations */
1188     TEST_ASSERT( mbedtls_pk_encrypt( &alt, msg, sizeof msg,
1189                              ciph, &ciph_len, sizeof ciph,
1190                              rnd_std_rand, NULL ) == ret );
1191     TEST_ASSERT( mbedtls_pk_verify( &alt, MBEDTLS_MD_NONE,
1192                             hash, sizeof hash, sig, sig_len ) == ret );
1193     TEST_ASSERT( mbedtls_pk_debug( &alt, dbg_items ) == ret );
1194
1195 exit:
1196     mbedtls_rsa_free( &raw );
1197     mbedtls_pk_free( &rsa ); mbedtls_pk_free( &alt );
1198 }
1199 /* END_CASE */
1200
1201 /* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_ECDSA_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED */
1202 void pk_psa_sign(  )
1203 {
1204     mbedtls_pk_context pk;
1205     unsigned char hash[50], sig[100], pkey_legacy[100], pkey_psa[100];
1206     unsigned char *pkey_legacy_start, *pkey_psa_start;
1207     size_t sig_len, klen_legacy, klen_psa;
1208     int ret;
1209     psa_key_handle_t handle;
1210
1211     /*
1212      * This tests making signatures with a wrapped PSA key:
1213      * - generate a fresh ECP legacy PK context
1214      * - wrap it in a PK context and make a signature this way
1215      * - extract the public key
1216      * - parse it to a PK context and verify the signature this way
1217      */
1218
1219     /* Create legacy EC public/private key in PK context. */
1220     mbedtls_pk_init( &pk );
1221     TEST_ASSERT( mbedtls_pk_setup( &pk,
1222                       mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
1223     TEST_ASSERT( mbedtls_ecp_gen_key( MBEDTLS_ECP_DP_SECP256R1,
1224                                       (mbedtls_ecp_keypair*) pk.pk_ctx,
1225                                       rnd_std_rand, NULL ) == 0 );
1226
1227     /* Export underlying public key for re-importing in a legacy context. */
1228     ret = mbedtls_pk_write_pubkey_der( &pk, pkey_legacy,
1229                                        sizeof( pkey_legacy ) );
1230     TEST_ASSERT( ret >= 0 );
1231     klen_legacy = (size_t) ret;
1232     /* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
1233     pkey_legacy_start = pkey_legacy + sizeof( pkey_legacy ) - klen_legacy;
1234
1235     /* Turn PK context into an opaque one. */
1236     TEST_ASSERT( psa_allocate_key( &handle ) == PSA_SUCCESS );
1237     TEST_ASSERT( mbedtls_pk_wrap_as_opaque( &pk, &handle,
1238                                             PSA_ALG_SHA_256 ) == 0 );
1239
1240     memset( hash, 0x2a, sizeof hash );
1241     memset( sig, 0, sizeof sig );
1242
1243     TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256,
1244                  hash, sizeof hash, sig, &sig_len,
1245                  NULL, NULL ) == 0 );
1246
1247     /* Export underlying public key for re-importing in a psa context. */
1248     ret = mbedtls_pk_write_pubkey_der( &pk, pkey_psa,
1249                                        sizeof( pkey_psa ) );
1250     TEST_ASSERT( ret >= 0 );
1251     klen_psa = (size_t) ret;
1252     /* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
1253     pkey_psa_start = pkey_psa + sizeof( pkey_psa ) - klen_psa;
1254
1255     TEST_ASSERT( klen_psa == klen_legacy );
1256     TEST_ASSERT( memcmp( pkey_psa_start, pkey_legacy_start, klen_psa ) == 0 );
1257
1258     mbedtls_pk_free( &pk );
1259     TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( handle ) );
1260
1261     mbedtls_pk_init( &pk );
1262     TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, pkey_legacy_start,
1263                                               klen_legacy ) == 0 );
1264     TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
1265                             hash, sizeof hash, sig, sig_len ) == 0 );
1266
1267 exit:
1268     mbedtls_pk_free( &pk );
1269 }
1270 /* END_CASE */