crypto/evp/p_lib.c

   1 /*
   2  * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * DSA low level APIs are deprecated for public use, but still ok for
  12  * internal use.
  13  */
  14 #include "internal/deprecated.h"
  15
  16 #include <stdio.h>
  17 #include "internal/cryptlib.h"
  18 #include "internal/refcount.h"
  19 #include <openssl/bn.h>
  20 #include <openssl/err.h>
  21 #include <openssl/objects.h>
  22 #include <openssl/evp.h>
  23 #include <openssl/x509.h>
  24 #include <openssl/rsa.h>
  25 #include <openssl/dsa.h>
  26 #include <openssl/dh.h>
  27 #include <openssl/cmac.h>
  28 #include <openssl/engine.h>
  29 #include <openssl/params.h>
  30 #include <openssl/serializer.h>
  31 #include <openssl/core_names.h>
  32
  33 #include "crypto/asn1.h"
  34 #include "crypto/evp.h"
  35 #include "internal/provider.h"
  36 #include "evp_local.h"
  37
  38 static void evp_pkey_free_it(EVP_PKEY *key);
  39
  40 #ifndef FIPS_MODE
  41
  42 int EVP_PKEY_bits(const EVP_PKEY *pkey)
  43 {
  44     if (pkey != NULL) {
  45         if (pkey->ameth == NULL)
  46             return pkey->cache.bits;
  47         else if (pkey->ameth->pkey_bits)
  48             return pkey->ameth->pkey_bits(pkey);
  49     }
  50     return 0;
  51 }
  52
  53 int EVP_PKEY_security_bits(const EVP_PKEY *pkey)
  54 {
  55     if (pkey == NULL)
  56         return 0;
  57     if (pkey->ameth == NULL)
  58         return pkey->cache.security_bits;
  59     if (pkey->ameth->pkey_security_bits == NULL)
  60         return -2;
  61     return pkey->ameth->pkey_security_bits(pkey);
  62 }
  63
  64 int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode)
  65 {
  66 # ifndef OPENSSL_NO_DSA
  67     if (pkey->type == EVP_PKEY_DSA) {
  68         int ret = pkey->save_parameters;
  69
  70         if (mode >= 0)
  71             pkey->save_parameters = mode;
  72         return ret;
  73     }
  74 # endif
  75 # ifndef OPENSSL_NO_EC
  76     if (pkey->type == EVP_PKEY_EC) {
  77         int ret = pkey->save_parameters;
  78
  79         if (mode >= 0)
  80             pkey->save_parameters = mode;
  81         return ret;
  82     }
  83 # endif
  84     return 0;
  85 }
  86
  87 int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
  88 {
  89     /*
  90      * TODO: clean up legacy stuff from this function when legacy support
  91      * is gone.
  92      */
  93
  94     /*
  95      * Only check that type match this early when both keys are legacy.
  96      * If either of them is provided, we let evp_keymgmt_util_copy()
  97      * do this check, after having exported either of them that isn't
  98      * provided.
  99      */
 100     if (to->keymgmt == NULL && from->keymgmt == NULL) {
 101         if (to->type == EVP_PKEY_NONE) {
 102             if (EVP_PKEY_set_type(to, from->type) == 0)
 103                 return 0;
 104         } else if (to->type != from->type) {
 105             EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS, EVP_R_DIFFERENT_KEY_TYPES);
 106             goto err;
 107         }
 108     }
 109
 110     if (EVP_PKEY_missing_parameters(from)) {
 111         EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS, EVP_R_MISSING_PARAMETERS);
 112         goto err;
 113     }
 114
 115     if (!EVP_PKEY_missing_parameters(to)) {
 116         if (EVP_PKEY_cmp_parameters(to, from) == 1)
 117             return 1;
 118         EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS, EVP_R_DIFFERENT_PARAMETERS);
 119         return 0;
 120     }
 121
 122     /*
 123      * If |from| is provided, we upgrade |to| to be provided as well.
 124      * This drops the legacy key from |to|.
 125      * evp_pkey_upgrade_to_provider() checks if |to| is already provided,
 126      * we don't need to do that here.
 127      *
 128      * TODO(3.0) We should investigate if that's too aggressive and make
 129      * this scenario unsupported instead.
 130      */
 131     if (from->keymgmt != NULL) {
 132         EVP_KEYMGMT *tmp_keymgmt = from->keymgmt;
 133
 134         /*
 135          * The returned pointer is known to be cached, so we don't have to
 136          * save it.  However, if it's NULL, something went wrong and we can't
 137          * copy.
 138          */
 139         if (evp_pkey_upgrade_to_provider(to, NULL,
 140                                          &tmp_keymgmt, NULL) == NULL) {
 141             ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 142             return 0;
 143         }
 144     }
 145
 146     /* For purely provided keys, we just call the keymgmt utility */
 147     if (to->keymgmt != NULL && from->keymgmt != NULL)
 148         return evp_keymgmt_util_copy(to, (EVP_PKEY *)from,
 149                                      OSSL_KEYMGMT_SELECT_ALL_PARAMETERS);
 150
 151     /*
 152      * If |to| is provided, we know that |from| is legacy at this point.
 153      * Try exporting |from| to |to|'s keymgmt, then use evp_keymgmt_copy()
 154      * to copy the appropriate data to |to|'s keydata.
 155      */
 156     if (to->keymgmt != NULL) {
 157         EVP_KEYMGMT *to_keymgmt = to->keymgmt;
 158         void *from_keydata =
 159             evp_pkey_export_to_provider((EVP_PKEY *)from, NULL, &to_keymgmt,
 160                                         NULL);
 161
 162         if (from_keydata == NULL) {
 163             ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 164             return 0;
 165         }
 166         return evp_keymgmt_copy(to->keymgmt, to->keydata, from_keydata,
 167                                 OSSL_KEYMGMT_SELECT_ALL_PARAMETERS);
 168     }
 169
 170     /* Both keys are legacy */
 171     if (from->ameth != NULL && from->ameth->param_copy != NULL)
 172         return from->ameth->param_copy(to, from);
 173  err:
 174     return 0;
 175 }
 176
 177 int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey)
 178 {
 179     if (pkey != NULL) {
 180         if (pkey->keymgmt != NULL)
 181             return !evp_keymgmt_util_has((EVP_PKEY *)pkey,
 182                                          OSSL_KEYMGMT_SELECT_ALL_PARAMETERS);
 183         else if (pkey->ameth != NULL && pkey->ameth->param_missing != NULL)
 184             return pkey->ameth->param_missing(pkey);
 185     }
 186     return 0;
 187 }
 188
 189 /*
 190  * This function is called for any mixture of keys except pure legacy pair.
 191  * TODO When legacy keys are gone, we replace a call to this functions with
 192  * a call to evp_keymgmt_util_match().
 193  */
 194 static int evp_pkey_cmp_any(const EVP_PKEY *a, const EVP_PKEY *b,
 195                             int selection)
 196 {
 197     EVP_KEYMGMT *keymgmt1 = NULL, *keymgmt2 = NULL;
 198     void *keydata1 = NULL, *keydata2 = NULL, *tmp_keydata = NULL;
 199
 200     /* If none of them are provided, this function shouldn't have been called */
 201     if (!ossl_assert(a->keymgmt != NULL || b->keymgmt != NULL))
 202         return -2;
 203
 204     /* For purely provided keys, we just call the keymgmt utility */
 205     if (a->keymgmt != NULL && b->keymgmt != NULL)
 206         return evp_keymgmt_util_match((EVP_PKEY *)a, (EVP_PKEY *)b, selection);
 207
 208     /*
 209      * Here, we know that we have a mixture of legacy and provided keys.
 210      * Try cross export and compare the resulting key data.
 211      */
 212     keymgmt1 = a->keymgmt;
 213     keydata1 = a->keydata;
 214     keymgmt2 = b->keymgmt;
 215     keydata2 = b->keydata;
 216
 217     if ((keymgmt1 == NULL
 218          && !EVP_KEYMGMT_is_a(keymgmt2, OBJ_nid2sn(a->type)))
 219         || (keymgmt2 == NULL
 220             && !EVP_KEYMGMT_is_a(keymgmt1, OBJ_nid2sn(b->type))))
 221         return -1;               /* not the same key type */
 222
 223     if (keymgmt2 != NULL && keymgmt2->match != NULL) {
 224         tmp_keydata =
 225             evp_pkey_export_to_provider((EVP_PKEY *)a, NULL, &keymgmt2, NULL);
 226         if (tmp_keydata != NULL) {
 227             keymgmt1 = keymgmt2;
 228             keydata1 = tmp_keydata;
 229         }
 230     }
 231     if (tmp_keydata == NULL && keymgmt1 != NULL && keymgmt1->match != NULL) {
 232         tmp_keydata =
 233             evp_pkey_export_to_provider((EVP_PKEY *)b, NULL, &keymgmt1, NULL);
 234         if (tmp_keydata != NULL) {
 235             keymgmt2 = keymgmt1;
 236             keydata2 = tmp_keydata;
 237         }
 238     }
 239
 240     /* If we still don't have matching keymgmt implementations, we give up */
 241     if (keymgmt1 != keymgmt2)
 242         return -2;
 243
 244     return evp_keymgmt_match(keymgmt1, keydata1, keydata2, selection);
 245 }
 246
 247 int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
 248 {
 249     /*
 250      * TODO: clean up legacy stuff from this function when legacy support
 251      * is gone.
 252      */
 253
 254     if (a->keymgmt != NULL || b->keymgmt != NULL)
 255         return evp_pkey_cmp_any(a, b, OSSL_KEYMGMT_SELECT_ALL_PARAMETERS);
 256
 257     /* All legacy keys */
 258     if (a->type != b->type)
 259         return -1;
 260     if (a->ameth != NULL && a->ameth->param_cmp != NULL)
 261         return a->ameth->param_cmp(a, b);
 262     return -2;
 263 }
 264
 265 int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
 266 {
 267     /*
 268      * TODO: clean up legacy stuff from this function when legacy support
 269      * is gone.
 270      */
 271
 272     if (a->keymgmt != NULL || b->keymgmt != NULL)
 273         return evp_pkey_cmp_any(a, b,
 274                                 OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
 275                                 | OSSL_KEYMGMT_SELECT_PUBLIC_KEY);
 276
 277     /* All legacy keys */
 278     if (a->type != b->type)
 279         return -1;
 280
 281     if (a->ameth != NULL) {
 282         int ret;
 283         /* Compare parameters if the algorithm has them */
 284         if (a->ameth->param_cmp != NULL) {
 285             ret = a->ameth->param_cmp(a, b);
 286             if (ret <= 0)
 287                 return ret;
 288         }
 289
 290         if (a->ameth->pub_cmp != NULL)
 291             return a->ameth->pub_cmp(a, b);
 292     }
 293
 294     return -2;
 295 }
 296
 297
 298 /*
 299  * Setup a public key ASN1 method and ENGINE from a NID or a string. If pkey
 300  * is NULL just return 1 or 0 if the algorithm exists.
 301  */
 302
 303 static int pkey_set_type(EVP_PKEY *pkey, ENGINE *e, int type, const char *str,
 304                          int len)
 305 {
 306     const EVP_PKEY_ASN1_METHOD *ameth;
 307     ENGINE **eptr = (e == NULL) ? &e :  NULL;
 308
 309     if (pkey) {
 310         if (pkey->pkey.ptr)
 311             evp_pkey_free_it(pkey);
 312         /*
 313          * If key type matches and a method exists then this lookup has
 314          * succeeded once so just indicate success.
 315          */
 316         if ((type == pkey->save_type) && pkey->ameth)
 317             return 1;
 318 # ifndef OPENSSL_NO_ENGINE
 319         /* If we have ENGINEs release them */
 320         ENGINE_finish(pkey->engine);
 321         pkey->engine = NULL;
 322         ENGINE_finish(pkey->pmeth_engine);
 323         pkey->pmeth_engine = NULL;
 324 # endif
 325     }
 326     if (str)
 327         ameth = EVP_PKEY_asn1_find_str(eptr, str, len);
 328     else
 329         ameth = EVP_PKEY_asn1_find(eptr, type);
 330 # ifndef OPENSSL_NO_ENGINE
 331     if (pkey == NULL && eptr != NULL)
 332         ENGINE_finish(e);
 333 # endif
 334     if (ameth == NULL) {
 335         EVPerr(EVP_F_PKEY_SET_TYPE, EVP_R_UNSUPPORTED_ALGORITHM);
 336         return 0;
 337     }
 338     if (pkey) {
 339         pkey->ameth = ameth;
 340         pkey->engine = e;
 341
 342         pkey->type = pkey->ameth->pkey_id;
 343         pkey->save_type = type;
 344     }
 345     return 1;
 346 }
 347
 348 EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e,
 349                                        const unsigned char *priv,
 350                                        size_t len)
 351 {
 352     EVP_PKEY *ret = EVP_PKEY_new();
 353
 354     if (ret == NULL
 355             || !pkey_set_type(ret, e, type, NULL, -1)) {
 356         /* EVPerr already called */
 357         goto err;
 358     }
 359
 360     if (ret->ameth->set_priv_key == NULL) {
 361         EVPerr(EVP_F_EVP_PKEY_NEW_RAW_PRIVATE_KEY,
 362                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 363         goto err;
 364     }
 365
 366     if (!ret->ameth->set_priv_key(ret, priv, len)) {
 367         EVPerr(EVP_F_EVP_PKEY_NEW_RAW_PRIVATE_KEY, EVP_R_KEY_SETUP_FAILED);
 368         goto err;
 369     }
 370
 371     return ret;
 372
 373  err:
 374     EVP_PKEY_free(ret);
 375     return NULL;
 376 }
 377
 378 EVP_PKEY *EVP_PKEY_new_raw_public_key(int type, ENGINE *e,
 379                                       const unsigned char *pub,
 380                                       size_t len)
 381 {
 382     EVP_PKEY *ret = EVP_PKEY_new();
 383
 384     if (ret == NULL
 385             || !pkey_set_type(ret, e, type, NULL, -1)) {
 386         /* EVPerr already called */
 387         goto err;
 388     }
 389
 390     if (ret->ameth->set_pub_key == NULL) {
 391         EVPerr(EVP_F_EVP_PKEY_NEW_RAW_PUBLIC_KEY,
 392                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 393         goto err;
 394     }
 395
 396     if (!ret->ameth->set_pub_key(ret, pub, len)) {
 397         EVPerr(EVP_F_EVP_PKEY_NEW_RAW_PUBLIC_KEY, EVP_R_KEY_SETUP_FAILED);
 398         goto err;
 399     }
 400
 401     return ret;
 402
 403  err:
 404     EVP_PKEY_free(ret);
 405     return NULL;
 406 }
 407
 408 int EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey, unsigned char *priv,
 409                                  size_t *len)
 410 {
 411      if (pkey->ameth->get_priv_key == NULL) {
 412         EVPerr(EVP_F_EVP_PKEY_GET_RAW_PRIVATE_KEY,
 413                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 414         return 0;
 415     }
 416
 417     if (!pkey->ameth->get_priv_key(pkey, priv, len)) {
 418         EVPerr(EVP_F_EVP_PKEY_GET_RAW_PRIVATE_KEY, EVP_R_GET_RAW_KEY_FAILED);
 419         return 0;
 420     }
 421
 422     return 1;
 423 }
 424
 425 int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub,
 426                                 size_t *len)
 427 {
 428      if (pkey->ameth->get_pub_key == NULL) {
 429         EVPerr(EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY,
 430                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 431         return 0;
 432     }
 433
 434     if (!pkey->ameth->get_pub_key(pkey, pub, len)) {
 435         EVPerr(EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY, EVP_R_GET_RAW_KEY_FAILED);
 436         return 0;
 437     }
 438
 439     return 1;
 440 }
 441
 442 EVP_PKEY *EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv,
 443                                 size_t len, const EVP_CIPHER *cipher)
 444 {
 445 # ifndef OPENSSL_NO_CMAC
 446 #  ifndef OPENSSL_NO_ENGINE
 447     const char *engine_id = e != NULL ? ENGINE_get_id(e) : NULL;
 448 #  endif
 449     const char *cipher_name = EVP_CIPHER_name(cipher);
 450     const OSSL_PROVIDER *prov = EVP_CIPHER_provider(cipher);
 451     OPENSSL_CTX *libctx =
 452         prov == NULL ? NULL : ossl_provider_library_context(prov);
 453     EVP_PKEY *ret = EVP_PKEY_new();
 454     EVP_MAC *cmac = EVP_MAC_fetch(libctx, OSSL_MAC_NAME_CMAC, NULL);
 455     EVP_MAC_CTX *cmctx = cmac != NULL ? EVP_MAC_CTX_new(cmac) : NULL;
 456     OSSL_PARAM params[4];
 457     size_t paramsn = 0;
 458
 459     if (ret == NULL
 460             || cmctx == NULL
 461             || !pkey_set_type(ret, e, EVP_PKEY_CMAC, NULL, -1)) {
 462         /* EVPerr already called */
 463         goto err;
 464     }
 465
 466 #  ifndef OPENSSL_NO_ENGINE
 467     if (engine_id != NULL)
 468         params[paramsn++] =
 469             OSSL_PARAM_construct_utf8_string("engine", (char *)engine_id, 0);
 470 #  endif
 471
 472     params[paramsn++] =
 473         OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_CIPHER,
 474                                          (char *)cipher_name, 0);
 475     params[paramsn++] =
 476         OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
 477                                           (char *)priv, len);
 478     params[paramsn] = OSSL_PARAM_construct_end();
 479
 480     if (!EVP_MAC_CTX_set_params(cmctx, params)) {
 481         EVPerr(EVP_F_EVP_PKEY_NEW_CMAC_KEY, EVP_R_KEY_SETUP_FAILED);
 482         goto err;
 483     }
 484
 485     ret->pkey.ptr = cmctx;
 486     return ret;
 487
 488  err:
 489     EVP_PKEY_free(ret);
 490     EVP_MAC_CTX_free(cmctx);
 491     EVP_MAC_free(cmac);
 492     return NULL;
 493 # else
 494     EVPerr(EVP_F_EVP_PKEY_NEW_CMAC_KEY,
 495            EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 496     return NULL;
 497 # endif
 498 }
 499
 500 int EVP_PKEY_set_type(EVP_PKEY *pkey, int type)
 501 {
 502     return pkey_set_type(pkey, NULL, type, NULL, -1);
 503 }
 504
 505 int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len)
 506 {
 507     return pkey_set_type(pkey, NULL, EVP_PKEY_NONE, str, len);
 508 }
 509
 510 int EVP_PKEY_set_alias_type(EVP_PKEY *pkey, int type)
 511 {
 512     if (pkey->type == type) {
 513         return 1; /* it already is that type */
 514     }
 515
 516     /*
 517      * The application is requesting to alias this to a different pkey type,
 518      * but not one that resolves to the base type.
 519      */
 520     if (EVP_PKEY_type(type) != EVP_PKEY_base_id(pkey)) {
 521         EVPerr(EVP_F_EVP_PKEY_SET_ALIAS_TYPE, EVP_R_UNSUPPORTED_ALGORITHM);
 522         return 0;
 523     }
 524
 525     pkey->type = type;
 526     return 1;
 527 }
 528
 529 # ifndef OPENSSL_NO_ENGINE
 530 int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e)
 531 {
 532     if (e != NULL) {
 533         if (!ENGINE_init(e)) {
 534             EVPerr(EVP_F_EVP_PKEY_SET1_ENGINE, ERR_R_ENGINE_LIB);
 535             return 0;
 536         }
 537         if (ENGINE_get_pkey_meth(e, pkey->type) == NULL) {
 538             ENGINE_finish(e);
 539             EVPerr(EVP_F_EVP_PKEY_SET1_ENGINE, EVP_R_UNSUPPORTED_ALGORITHM);
 540             return 0;
 541         }
 542     }
 543     ENGINE_finish(pkey->pmeth_engine);
 544     pkey->pmeth_engine = e;
 545     return 1;
 546 }
 547
 548 ENGINE *EVP_PKEY_get0_engine(const EVP_PKEY *pkey)
 549 {
 550     return pkey->engine;
 551 }
 552 # endif
 553 int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key)
 554 {
 555     int alias = type;
 556
 557 #ifndef OPENSSL_NO_EC
 558     if (EVP_PKEY_type(type) == EVP_PKEY_EC) {
 559         const EC_GROUP *group = EC_KEY_get0_group(key);
 560
 561         if (group != NULL && EC_GROUP_get_curve_name(group) == NID_sm2)
 562             alias = EVP_PKEY_SM2;
 563     }
 564 #endif
 565
 566     if (pkey == NULL || !EVP_PKEY_set_type(pkey, type))
 567         return 0;
 568     if (!EVP_PKEY_set_alias_type(pkey, alias))
 569         return 0;
 570     pkey->pkey.ptr = key;
 571     return (key != NULL);
 572 }
 573
 574 void *EVP_PKEY_get0(const EVP_PKEY *pkey)
 575 {
 576     return pkey->pkey.ptr;
 577 }
 578
 579 const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len)
 580 {
 581     ASN1_OCTET_STRING *os = NULL;
 582     if (pkey->type != EVP_PKEY_HMAC) {
 583         EVPerr(EVP_F_EVP_PKEY_GET0_HMAC, EVP_R_EXPECTING_AN_HMAC_KEY);
 584         return NULL;
 585     }
 586     os = EVP_PKEY_get0(pkey);
 587     *len = os->length;
 588     return os->data;
 589 }
 590
 591 # ifndef OPENSSL_NO_POLY1305
 592 const unsigned char *EVP_PKEY_get0_poly1305(const EVP_PKEY *pkey, size_t *len)
 593 {
 594     ASN1_OCTET_STRING *os = NULL;
 595     if (pkey->type != EVP_PKEY_POLY1305) {
 596         EVPerr(EVP_F_EVP_PKEY_GET0_POLY1305, EVP_R_EXPECTING_A_POLY1305_KEY);
 597         return NULL;
 598     }
 599     os = EVP_PKEY_get0(pkey);
 600     *len = os->length;
 601     return os->data;
 602 }
 603 # endif
 604
 605 # ifndef OPENSSL_NO_SIPHASH
 606 const unsigned char *EVP_PKEY_get0_siphash(const EVP_PKEY *pkey, size_t *len)
 607 {
 608     ASN1_OCTET_STRING *os = NULL;
 609
 610     if (pkey->type != EVP_PKEY_SIPHASH) {
 611         EVPerr(EVP_F_EVP_PKEY_GET0_SIPHASH, EVP_R_EXPECTING_A_SIPHASH_KEY);
 612         return NULL;
 613     }
 614     os = EVP_PKEY_get0(pkey);
 615     *len = os->length;
 616     return os->data;
 617 }
 618 # endif
 619
 620 # ifndef OPENSSL_NO_RSA
 621 int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, RSA *key)
 622 {
 623     int ret = EVP_PKEY_assign_RSA(pkey, key);
 624     if (ret)
 625         RSA_up_ref(key);
 626     return ret;
 627 }
 628
 629 RSA *EVP_PKEY_get0_RSA(const EVP_PKEY *pkey)
 630 {
 631     if (pkey->type != EVP_PKEY_RSA && pkey->type != EVP_PKEY_RSA_PSS) {
 632         EVPerr(EVP_F_EVP_PKEY_GET0_RSA, EVP_R_EXPECTING_AN_RSA_KEY);
 633         return NULL;
 634     }
 635     return pkey->pkey.rsa;
 636 }
 637
 638 RSA *EVP_PKEY_get1_RSA(EVP_PKEY *pkey)
 639 {
 640     RSA *ret = EVP_PKEY_get0_RSA(pkey);
 641     if (ret != NULL)
 642         RSA_up_ref(ret);
 643     return ret;
 644 }
 645 # endif
 646
 647 # ifndef OPENSSL_NO_DSA
 648 int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, DSA *key)
 649 {
 650     int ret = EVP_PKEY_assign_DSA(pkey, key);
 651     if (ret)
 652         DSA_up_ref(key);
 653     return ret;
 654 }
 655
 656 DSA *EVP_PKEY_get0_DSA(const EVP_PKEY *pkey)
 657 {
 658     if (pkey->type != EVP_PKEY_DSA) {
 659         EVPerr(EVP_F_EVP_PKEY_GET0_DSA, EVP_R_EXPECTING_A_DSA_KEY);
 660         return NULL;
 661     }
 662     return pkey->pkey.dsa;
 663 }
 664
 665 DSA *EVP_PKEY_get1_DSA(EVP_PKEY *pkey)
 666 {
 667     DSA *ret = EVP_PKEY_get0_DSA(pkey);
 668     if (ret != NULL)
 669         DSA_up_ref(ret);
 670     return ret;
 671 }
 672 # endif
 673
 674 # ifndef OPENSSL_NO_EC
 675
 676 int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key)
 677 {
 678     int ret = EVP_PKEY_assign_EC_KEY(pkey, key);
 679     if (ret)
 680         EC_KEY_up_ref(key);
 681     return ret;
 682 }
 683
 684 EC_KEY *EVP_PKEY_get0_EC_KEY(const EVP_PKEY *pkey)
 685 {
 686     if (EVP_PKEY_base_id(pkey) != EVP_PKEY_EC) {
 687         EVPerr(EVP_F_EVP_PKEY_GET0_EC_KEY, EVP_R_EXPECTING_A_EC_KEY);
 688         return NULL;
 689     }
 690     return pkey->pkey.ec;
 691 }
 692
 693 EC_KEY *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey)
 694 {
 695     EC_KEY *ret = EVP_PKEY_get0_EC_KEY(pkey);
 696     if (ret != NULL)
 697         EC_KEY_up_ref(ret);
 698     return ret;
 699 }
 700 # endif
 701
 702 # ifndef OPENSSL_NO_DH
 703
 704 int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key)
 705 {
 706     int type = DH_get0_q(key) == NULL ? EVP_PKEY_DH : EVP_PKEY_DHX;
 707     int ret = EVP_PKEY_assign(pkey, type, key);
 708
 709     if (ret)
 710         DH_up_ref(key);
 711     return ret;
 712 }
 713
 714 DH *EVP_PKEY_get0_DH(const EVP_PKEY *pkey)
 715 {
 716     if (pkey->type != EVP_PKEY_DH && pkey->type != EVP_PKEY_DHX) {
 717         EVPerr(EVP_F_EVP_PKEY_GET0_DH, EVP_R_EXPECTING_A_DH_KEY);
 718         return NULL;
 719     }
 720     return pkey->pkey.dh;
 721 }
 722
 723 DH *EVP_PKEY_get1_DH(EVP_PKEY *pkey)
 724 {
 725     DH *ret = EVP_PKEY_get0_DH(pkey);
 726     if (ret != NULL)
 727         DH_up_ref(ret);
 728     return ret;
 729 }
 730 # endif
 731
 732 int EVP_PKEY_type(int type)
 733 {
 734     int ret;
 735     const EVP_PKEY_ASN1_METHOD *ameth;
 736     ENGINE *e;
 737     ameth = EVP_PKEY_asn1_find(&e, type);
 738     if (ameth)
 739         ret = ameth->pkey_id;
 740     else
 741         ret = NID_undef;
 742 # ifndef OPENSSL_NO_ENGINE
 743     ENGINE_finish(e);
 744 # endif
 745     return ret;
 746 }
 747
 748 int EVP_PKEY_id(const EVP_PKEY *pkey)
 749 {
 750     return pkey->type;
 751 }
 752
 753 int EVP_PKEY_base_id(const EVP_PKEY *pkey)
 754 {
 755     return EVP_PKEY_type(pkey->type);
 756 }
 757
 758
 759 static int print_reset_indent(BIO **out, int pop_f_prefix, long saved_indent)
 760 {
 761     BIO_set_indent(*out, saved_indent);
 762     if (pop_f_prefix) {
 763         BIO *next = BIO_pop(*out);
 764
 765         BIO_free(*out);
 766         *out = next;
 767     }
 768     return 1;
 769 }
 770
 771 static int print_set_indent(BIO **out, int *pop_f_prefix, long *saved_indent,
 772                             long indent)
 773 {
 774     *pop_f_prefix = 0;
 775     *saved_indent = 0;
 776     if (indent > 0) {
 777         long i = BIO_get_indent(*out);
 778
 779         *saved_indent =  (i < 0 ? 0 : i);
 780         if (BIO_set_indent(*out, indent) <= 0) {
 781             if ((*out = BIO_push(BIO_new(BIO_f_prefix()), *out)) == NULL)
 782                 return 0;
 783             *pop_f_prefix = 1;
 784         }
 785         if (BIO_set_indent(*out, indent) <= 0) {
 786             print_reset_indent(out, *pop_f_prefix, *saved_indent);
 787             return 0;
 788         }
 789     }
 790     return 1;
 791 }
 792
 793 static int unsup_alg(BIO *out, const EVP_PKEY *pkey, int indent,
 794                      const char *kstr)
 795 {
 796     return BIO_indent(out, indent, 128)
 797         && BIO_printf(out, "%s algorithm \"%s\" unsupported\n",
 798                       kstr, OBJ_nid2ln(pkey->type)) > 0;
 799 }
 800
 801 static int print_pkey(const EVP_PKEY *pkey, BIO *out, int indent,
 802                       const char *propquery /* For provided serialization */,
 803                       int (*legacy_print)(BIO *out, const EVP_PKEY *pkey,
 804                                           int indent, ASN1_PCTX *pctx),
 805                       ASN1_PCTX *legacy_pctx /* For legacy print */)
 806 {
 807     int pop_f_prefix;
 808     long saved_indent;
 809     OSSL_SERIALIZER_CTX *ctx = NULL;
 810     int ret = -2;                /* default to unsupported */
 811
 812     if (!print_set_indent(&out, &pop_f_prefix, &saved_indent, indent))
 813         return 0;
 814
 815     ctx = OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(pkey, propquery);
 816     if (OSSL_SERIALIZER_CTX_get_serializer(ctx) != NULL)
 817         ret = OSSL_SERIALIZER_to_bio(ctx, out);
 818     OSSL_SERIALIZER_CTX_free(ctx);
 819
 820     if (ret != -2)
 821         goto end;
 822
 823     /* legacy fallback */
 824     if (legacy_print != NULL)
 825         ret = legacy_print(out, pkey, 0, legacy_pctx);
 826     else
 827         ret = unsup_alg(out, pkey, 0, "Public Key");
 828
 829  end:
 830     print_reset_indent(&out, pop_f_prefix, saved_indent);
 831     return ret;
 832 }
 833
 834 int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
 835                           int indent, ASN1_PCTX *pctx)
 836 {
 837     return print_pkey(pkey, out, indent, OSSL_SERIALIZER_PUBKEY_TO_TEXT_PQ,
 838                       (pkey->ameth != NULL ? pkey->ameth->pub_print : NULL),
 839                       pctx);
 840 }
 841
 842 int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
 843                            int indent, ASN1_PCTX *pctx)
 844 {
 845     return print_pkey(pkey, out, indent, OSSL_SERIALIZER_PrivateKey_TO_TEXT_PQ,
 846                       (pkey->ameth != NULL ? pkey->ameth->priv_print : NULL),
 847                       pctx);
 848 }
 849
 850 int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
 851                           int indent, ASN1_PCTX *pctx)
 852 {
 853     return print_pkey(pkey, out, indent, OSSL_SERIALIZER_Parameters_TO_TEXT_PQ,
 854                       (pkey->ameth != NULL ? pkey->ameth->param_print : NULL),
 855                       pctx);
 856 }
 857
 858 static int legacy_asn1_ctrl_to_param(EVP_PKEY *pkey, int op,
 859                                      int arg1, void *arg2)
 860 {
 861     if (pkey->keymgmt == NULL)
 862         return 0;
 863     switch (op) {
 864     case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
 865         {
 866             char mdname[80] = "";
 867             int nid;
 868             int rv = EVP_PKEY_get_default_digest_name(pkey, mdname,
 869                                                       sizeof(mdname));
 870
 871             if (rv <= 0)
 872                 return rv;
 873             nid = OBJ_sn2nid(mdname);
 874             if (nid == NID_undef)
 875                 nid = OBJ_ln2nid(mdname);
 876             if (nid == NID_undef)
 877                 return 0;
 878             *(int *)arg2 = nid;
 879             return 1;
 880         }
 881     default:
 882         return -2;
 883     }
 884 }
 885
 886 static int evp_pkey_asn1_ctrl(EVP_PKEY *pkey, int op, int arg1, void *arg2)
 887 {
 888     if (pkey->ameth == NULL)
 889         return legacy_asn1_ctrl_to_param(pkey, op, arg1, arg2);
 890     if (pkey->ameth->pkey_ctrl == NULL)
 891         return -2;
 892     return pkey->ameth->pkey_ctrl(pkey, op, arg1, arg2);
 893 }
 894
 895 int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid)
 896 {
 897     return evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_DEFAULT_MD_NID, 0, pnid);
 898 }
 899
 900 int EVP_PKEY_get_default_digest_name(EVP_PKEY *pkey,
 901                                      char *mdname, size_t mdname_sz)
 902 {
 903     if (pkey->ameth == NULL) {
 904         OSSL_PARAM params[3];
 905         char mddefault[100] = "";
 906         char mdmandatory[100] = "";
 907
 908         params[0] =
 909             OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_DEFAULT_DIGEST,
 910                                              mddefault, sizeof(mddefault));
 911         params[1] =
 912             OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST,
 913                                              mdmandatory,
 914                                              sizeof(mdmandatory));
 915         params[2] = OSSL_PARAM_construct_end();
 916         if (!evp_keymgmt_get_params(pkey->keymgmt, pkey->keydata, params))
 917             return 0;
 918         if (mdmandatory[0] != '\0') {
 919             OPENSSL_strlcpy(mdname, mdmandatory, mdname_sz);
 920             return 2;
 921         }
 922         OPENSSL_strlcpy(mdname, mddefault, mdname_sz);
 923         return 1;
 924     }
 925
 926     {
 927         int nid = NID_undef;
 928         int rv = EVP_PKEY_get_default_digest_nid(pkey, &nid);
 929         const char *name = rv > 0 ? OBJ_nid2sn(nid) : NULL;
 930
 931         if (rv > 0)
 932             OPENSSL_strlcpy(mdname, name, mdname_sz);
 933         return rv;
 934     }
 935 }
 936
 937 int EVP_PKEY_supports_digest_nid(EVP_PKEY *pkey, int nid)
 938 {
 939     int rv, default_nid;
 940
 941     rv = evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_SUPPORTS_MD_NID, nid, NULL);
 942     if (rv == -2) {
 943         /*
 944          * If there is a mandatory default digest and this isn't it, then
 945          * the answer is 'no'.
 946          */
 947         rv = EVP_PKEY_get_default_digest_nid(pkey, &default_nid);
 948         if (rv == 2)
 949             return (nid == default_nid);
 950         /* zero is an error from EVP_PKEY_get_default_digest_nid() */
 951         if (rv == 0)
 952             return -1;
 953     }
 954     return rv;
 955 }
 956
 957 int EVP_PKEY_set1_tls_encodedpoint(EVP_PKEY *pkey,
 958                                const unsigned char *pt, size_t ptlen)
 959 {
 960     if (ptlen > INT_MAX)
 961         return 0;
 962     if (evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_SET1_TLS_ENCPT, ptlen,
 963                            (void *)pt) <= 0)
 964         return 0;
 965     return 1;
 966 }
 967
 968 size_t EVP_PKEY_get1_tls_encodedpoint(EVP_PKEY *pkey, unsigned char **ppt)
 969 {
 970     int rv;
 971     rv = evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_GET1_TLS_ENCPT, 0, ppt);
 972     if (rv <= 0)
 973         return 0;
 974     return rv;
 975 }
 976
 977 #endif /* FIPS_MODE */
 978
 979 /*- All methods below can also be used in FIPS_MODE */
 980
 981 EVP_PKEY *EVP_PKEY_new(void)
 982 {
 983     EVP_PKEY *ret = OPENSSL_zalloc(sizeof(*ret));
 984
 985     if (ret == NULL) {
 986         EVPerr(EVP_F_EVP_PKEY_NEW, ERR_R_MALLOC_FAILURE);
 987         return NULL;
 988     }
 989     ret->type = EVP_PKEY_NONE;
 990     ret->save_type = EVP_PKEY_NONE;
 991     ret->references = 1;
 992     ret->save_parameters = 1;
 993     ret->lock = CRYPTO_THREAD_lock_new();
 994     if (ret->lock == NULL) {
 995         EVPerr(EVP_F_EVP_PKEY_NEW, ERR_R_MALLOC_FAILURE);
 996         OPENSSL_free(ret);
 997         return NULL;
 998     }
 999     return ret;
1000 }
1001
1002 int EVP_PKEY_up_ref(EVP_PKEY *pkey)
1003 {
1004     int i;
1005
1006     if (CRYPTO_UP_REF(&pkey->references, &i, pkey->lock) <= 0)
1007         return 0;
1008
1009     REF_PRINT_COUNT("EVP_PKEY", pkey);
1010     REF_ASSERT_ISNT(i < 2);
1011     return ((i > 1) ? 1 : 0);
1012 }
1013
1014 #ifndef FIPS_MODE
1015 void evp_pkey_free_legacy(EVP_PKEY *x)
1016 {
1017     if (x->ameth != NULL) {
1018         if (x->ameth->pkey_free != NULL)
1019             x->ameth->pkey_free(x);
1020         x->pkey.ptr = NULL;
1021         x->ameth = NULL;
1022     }
1023 # ifndef OPENSSL_NO_ENGINE
1024     ENGINE_finish(x->engine);
1025     x->engine = NULL;
1026     ENGINE_finish(x->pmeth_engine);
1027     x->pmeth_engine = NULL;
1028 # endif
1029     x->type = x->save_type = EVP_PKEY_NONE;
1030 }
1031 #endif  /* FIPS_MODE */
1032
1033 static void evp_pkey_free_it(EVP_PKEY *x)
1034 {
1035     /* internal function; x is never NULL */
1036
1037     evp_keymgmt_util_clear_operation_cache(x);
1038 #ifndef FIPS_MODE
1039     evp_pkey_free_legacy(x);
1040 #endif
1041
1042     if (x->keymgmt != NULL) {
1043         evp_keymgmt_freedata(x->keymgmt, x->keydata);
1044         EVP_KEYMGMT_free(x->keymgmt);
1045         x->keymgmt = NULL;
1046         x->keydata = NULL;
1047     }
1048 }
1049
1050 void EVP_PKEY_free(EVP_PKEY *x)
1051 {
1052     int i;
1053
1054     if (x == NULL)
1055         return;
1056
1057     CRYPTO_DOWN_REF(&x->references, &i, x->lock);
1058     REF_PRINT_COUNT("EVP_PKEY", x);
1059     if (i > 0)
1060         return;
1061     REF_ASSERT_ISNT(i < 0);
1062     evp_pkey_free_it(x);
1063     CRYPTO_THREAD_lock_free(x->lock);
1064 #ifndef FIPS_MODE
1065     sk_X509_ATTRIBUTE_pop_free(x->attributes, X509_ATTRIBUTE_free);
1066 #endif
1067     OPENSSL_free(x);
1068 }
1069
1070 int EVP_PKEY_size(const EVP_PKEY *pkey)
1071 {
1072     int size = 0;
1073
1074     if (pkey != NULL) {
1075         size = pkey->cache.size;
1076 #ifndef FIPS_MODE
1077         if (pkey->ameth != NULL && pkey->ameth->pkey_size != NULL)
1078             size = pkey->ameth->pkey_size(pkey);
1079 #endif
1080     }
1081     return size;
1082 }
1083
1084 void *evp_pkey_export_to_provider(EVP_PKEY *pk, OPENSSL_CTX *libctx,
1085                                   EVP_KEYMGMT **keymgmt,
1086                                   const char *propquery)
1087 {
1088     EVP_KEYMGMT *allocated_keymgmt = NULL;
1089     EVP_KEYMGMT *tmp_keymgmt = NULL;
1090     void *keydata = NULL;
1091     int check;
1092
1093     if (pk == NULL)
1094         return NULL;
1095
1096     /* No key data => nothing to export */
1097     check = 1;
1098 #ifndef FIPS_MODE
1099     check = check && pk->pkey.ptr == NULL;
1100 #endif
1101     check = check && pk->keydata == NULL;
1102     if (check)
1103         return NULL;
1104
1105 #ifndef FIPS_MODE
1106     if (pk->pkey.ptr != NULL) {
1107         /*
1108          * If the legacy key doesn't have an dirty counter or export function,
1109          * give up
1110          */
1111         if (pk->ameth->dirty_cnt == NULL || pk->ameth->export_to == NULL)
1112             return NULL;
1113     }
1114 #endif
1115
1116     if (keymgmt != NULL) {
1117         tmp_keymgmt = *keymgmt;
1118         *keymgmt = NULL;
1119     }
1120
1121     /*
1122      * If no keymgmt was given or found, get a default keymgmt.  We do so by
1123      * letting EVP_PKEY_CTX_new_from_pkey() do it for us, then we steal it.
1124      */
1125     if (tmp_keymgmt == NULL) {
1126         EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pk, propquery);
1127
1128         tmp_keymgmt = ctx->keymgmt;
1129         ctx->keymgmt = NULL;
1130         EVP_PKEY_CTX_free(ctx);
1131     }
1132
1133     /* If there's still no keymgmt to be had, give up */
1134     if (tmp_keymgmt == NULL)
1135         goto end;
1136
1137 #ifndef FIPS_MODE
1138     if (pk->pkey.ptr != NULL) {
1139         size_t i = 0;
1140
1141         /*
1142          * If the legacy "origin" hasn't changed since last time, we try
1143          * to find our keymgmt in the operation cache.  If it has changed,
1144          * |i| remains zero, and we will clear the cache further down.
1145          */
1146         if (pk->ameth->dirty_cnt(pk) == pk->dirty_cnt_copy) {
1147             i = evp_keymgmt_util_find_operation_cache_index(pk, tmp_keymgmt);
1148
1149             /*
1150              * If |tmp_keymgmt| is present in the operation cache, it means
1151              * that export doesn't need to be redone.  In that case, we take
1152              * token copies of the cached pointers, to have token success
1153              * values to return.
1154              */
1155             if (i < OSSL_NELEM(pk->operation_cache)
1156                 && pk->operation_cache[i].keymgmt != NULL) {
1157                 keydata = pk->operation_cache[i].keydata;
1158                 goto end;
1159             }
1160         }
1161
1162         /*
1163          * TODO(3.0) Right now, we assume we have ample space.  We will have
1164          * to think about a cache aging scheme, though, if |i| indexes outside
1165          * the array.
1166          */
1167         if (!ossl_assert(i < OSSL_NELEM(pk->operation_cache)))
1168             goto end;
1169
1170         /* Make sure that the keymgmt key type matches the legacy NID */
1171         if (!ossl_assert(EVP_KEYMGMT_is_a(tmp_keymgmt, OBJ_nid2sn(pk->type))))
1172             goto end;
1173
1174         if ((keydata = evp_keymgmt_newdata(tmp_keymgmt)) == NULL)
1175             goto end;
1176
1177         if (!pk->ameth->export_to(pk, keydata, tmp_keymgmt)) {
1178             evp_keymgmt_freedata(tmp_keymgmt, keydata);
1179             keydata = NULL;
1180             goto end;
1181         }
1182
1183         /*
1184          * If the dirty counter changed since last time, then clear the
1185          * operation cache.  In that case, we know that |i| is zero.  Just
1186          * in case this is a re-export, we increment then decrement the
1187          * keymgmt reference counter.
1188          */
1189         if (!EVP_KEYMGMT_up_ref(tmp_keymgmt)) { /* refcnt++ */
1190             evp_keymgmt_freedata(tmp_keymgmt, keydata);
1191             keydata = NULL;
1192             goto end;
1193         }
1194         if (pk->ameth->dirty_cnt(pk) != pk->dirty_cnt_copy)
1195             evp_keymgmt_util_clear_operation_cache(pk);
1196         EVP_KEYMGMT_free(tmp_keymgmt); /* refcnt-- */
1197
1198         /* Add the new export to the operation cache */
1199         if (!evp_keymgmt_util_cache_keydata(pk, i, tmp_keymgmt, keydata)) {
1200             evp_keymgmt_freedata(tmp_keymgmt, keydata);
1201             keydata = NULL;
1202             goto end;
1203         }
1204
1205         /* Synchronize the dirty count */
1206         pk->dirty_cnt_copy = pk->ameth->dirty_cnt(pk);
1207         goto end;
1208     }
1209 #endif  /* FIPS_MODE */
1210
1211     keydata = evp_keymgmt_util_export_to_provider(pk, tmp_keymgmt);
1212
1213  end:
1214     /*
1215      * If nothing was exported, |tmp_keymgmt| might point at a freed
1216      * EVP_KEYMGMT, so we clear it to be safe.  It shouldn't be useful for
1217      * the caller either way in that case.
1218      */
1219     if (keydata == NULL)
1220         tmp_keymgmt = NULL;
1221
1222     if (keymgmt != NULL)
1223         *keymgmt = tmp_keymgmt;
1224
1225     EVP_KEYMGMT_free(allocated_keymgmt);
1226     return keydata;
1227 }
1228
1229 #ifndef FIPS_MODE
1230 /*
1231  * This differs from exporting in that it releases the legacy key and assigns
1232  * the export keymgmt and keydata to the "origin" provider side key instead
1233  * of the operation cache.
1234  */
1235 void *evp_pkey_upgrade_to_provider(EVP_PKEY *pk, OPENSSL_CTX *libctx,
1236                                    EVP_KEYMGMT **keymgmt,
1237                                    const char *propquery)
1238 {
1239     EVP_KEYMGMT *allocated_keymgmt = NULL;
1240     EVP_KEYMGMT *tmp_keymgmt = NULL;
1241     void *keydata = NULL;
1242
1243     if (pk == NULL)
1244         return NULL;
1245
1246     /*
1247      * If this key is already "upgraded", this function shouldn't have been
1248      * called.
1249      */
1250     if (!ossl_assert(pk->keymgmt == NULL))
1251         return NULL;
1252
1253     if (keymgmt != NULL) {
1254         tmp_keymgmt = *keymgmt;
1255         *keymgmt = NULL;
1256     }
1257
1258     /* If the key isn't a legacy one, bail out, but with proper values */
1259     if (pk->pkey.ptr == NULL) {
1260         tmp_keymgmt = pk->keymgmt;
1261         keydata = pk->keydata;
1262     } else {
1263         /* If the legacy key doesn't have an export function, give up */
1264         if (pk->ameth->export_to == NULL)
1265             return NULL;
1266
1267         /*
1268          * If no keymgmt was given or found, get a default keymgmt.  We do
1269          * so by letting EVP_PKEY_CTX_new_from_pkey() do it for us, then we
1270          * steal it.
1271          */
1272         if (tmp_keymgmt == NULL) {
1273             EVP_PKEY_CTX *ctx =
1274                 EVP_PKEY_CTX_new_from_pkey(libctx, pk, propquery);
1275
1276             tmp_keymgmt = ctx->keymgmt;
1277             ctx->keymgmt = NULL;
1278             EVP_PKEY_CTX_free(ctx);
1279         }
1280
1281         /* If we still don't have a keymgmt, give up */
1282         if (tmp_keymgmt == NULL)
1283             goto end;
1284
1285         /* Make sure that the keymgmt key type matches the legacy NID */
1286         if (!ossl_assert(EVP_KEYMGMT_is_a(tmp_keymgmt, OBJ_nid2sn(pk->type))))
1287             goto end;
1288
1289         if ((keydata = evp_keymgmt_newdata(tmp_keymgmt)) == NULL)
1290             goto end;
1291
1292         if (!pk->ameth->export_to(pk, keydata, tmp_keymgmt)
1293             || !EVP_KEYMGMT_up_ref(tmp_keymgmt)) {
1294             evp_keymgmt_freedata(tmp_keymgmt, keydata);
1295             keydata = NULL;
1296             goto end;
1297         }
1298
1299         /*
1300          * Clear the operation cache, all the legacy data, as well as the
1301          * dirty counters
1302          */
1303         evp_pkey_free_legacy(pk);
1304         pk->dirty_cnt_copy = 0;
1305
1306         evp_keymgmt_util_clear_operation_cache(pk);
1307         pk->keymgmt = tmp_keymgmt;
1308         pk->keydata = keydata;
1309         evp_keymgmt_util_cache_keyinfo(pk);
1310     }
1311
1312  end:
1313     /*
1314      * If nothing was upgraded, |tmp_keymgmt| might point at a freed
1315      * EVP_KEYMGMT, so we clear it to be safe.  It shouldn't be useful for
1316      * the caller either way in that case.
1317      */
1318     if (keydata == NULL)
1319         tmp_keymgmt = NULL;
1320
1321     if (keymgmt != NULL)
1322         *keymgmt = tmp_keymgmt;
1323
1324     EVP_KEYMGMT_free(allocated_keymgmt);
1325     return keydata;
1326 }
1327 #endif  /* FIPS_MODE */