Rename some occurrences of 'library_context' and 'lib_ctx' to 'libctx'
[openssl.git] / crypto / evp / p_lib.c
1 /*
2  * Copyright 1995-2020 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/ec.h>
28 #include <openssl/cmac.h>
29 #include <openssl/engine.h>
30 #include <openssl/params.h>
31 #include <openssl/param_build.h>
32 #include <openssl/encoder.h>
33 #include <openssl/core_names.h>
34
35 #include "crypto/asn1.h"
36 #include "crypto/evp.h"
37 #include "crypto/ecx.h"
38 #include "internal/evp.h"
39 #include "internal/provider.h"
40 #include "evp_local.h"
41
42 #include "crypto/ec.h"
43
44 /* TODO remove this when the EVP_PKEY_is_a() #legacy support hack is removed */
45 #include "e_os.h"                /* strcasecmp on Windows */
46
47 static int pkey_set_type(EVP_PKEY *pkey, ENGINE *e, int type, const char *str,
48                          int len, EVP_KEYMGMT *keymgmt);
49 static void evp_pkey_free_it(EVP_PKEY *key);
50
51 #ifndef FIPS_MODULE
52
53 /* The type of parameters selected in key parameter functions */
54 # define SELECT_PARAMETERS OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS
55
56 int EVP_PKEY_bits(const EVP_PKEY *pkey)
57 {
58     if (pkey != NULL) {
59         if (pkey->ameth == NULL)
60             return pkey->cache.bits;
61         else if (pkey->ameth->pkey_bits)
62             return pkey->ameth->pkey_bits(pkey);
63     }
64     return 0;
65 }
66
67 int EVP_PKEY_security_bits(const EVP_PKEY *pkey)
68 {
69     if (pkey == NULL)
70         return 0;
71     if (pkey->ameth == NULL)
72         return pkey->cache.security_bits;
73     if (pkey->ameth->pkey_security_bits == NULL)
74         return -2;
75     return pkey->ameth->pkey_security_bits(pkey);
76 }
77
78 int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode)
79 {
80 # ifndef OPENSSL_NO_DSA
81     if (pkey->type == EVP_PKEY_DSA) {
82         int ret = pkey->save_parameters;
83
84         if (mode >= 0)
85             pkey->save_parameters = mode;
86         return ret;
87     }
88 # endif
89 # ifndef OPENSSL_NO_EC
90     if (pkey->type == EVP_PKEY_EC) {
91         int ret = pkey->save_parameters;
92
93         if (mode >= 0)
94             pkey->save_parameters = mode;
95         return ret;
96     }
97 # endif
98     return 0;
99 }
100
101 int EVP_PKEY_set_ex_data(EVP_PKEY *key, int idx, void *arg)
102 {
103     return CRYPTO_set_ex_data(&key->ex_data, idx, arg);
104 }
105
106 void *EVP_PKEY_get_ex_data(const EVP_PKEY *key, int idx)
107 {
108     return CRYPTO_get_ex_data(&key->ex_data, idx);
109 }
110
111 int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
112 {
113     /*
114      * TODO: clean up legacy stuff from this function when legacy support
115      * is gone.
116      */
117
118     /*
119      * If |to| is a legacy key and |from| isn't, we must downgrade |from|.
120      * If that fails, this function fails.
121      */
122     if (evp_pkey_is_legacy(to) && evp_pkey_is_provided(from))
123         if (!evp_pkey_downgrade((EVP_PKEY *)from))
124             return 0;
125
126     /*
127      * Make sure |to| is typed.  Content is less important at this early
128      * stage.
129      *
130      * 1.  If |to| is untyped, assign |from|'s key type to it.
131      * 2.  If |to| contains a legacy key, compare its |type| to |from|'s.
132      *     (|from| was already downgraded above)
133      *
134      * If |to| is a provided key, there's nothing more to do here, functions
135      * like evp_keymgmt_util_copy() and evp_pkey_export_to_provider() called
136      * further down help us find out if they are the same or not.
137      */
138     if (evp_pkey_is_blank(to)) {
139         if (evp_pkey_is_legacy(from)) {
140             if (EVP_PKEY_set_type(to, from->type) == 0)
141                 return 0;
142         } else {
143             if (EVP_PKEY_set_type_by_keymgmt(to, from->keymgmt) == 0)
144                 return 0;
145         }
146     } else if (evp_pkey_is_legacy(to)) {
147         if (to->type != from->type) {
148             EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS, EVP_R_DIFFERENT_KEY_TYPES);
149             goto err;
150         }
151     }
152
153     if (EVP_PKEY_missing_parameters(from)) {
154         EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS, EVP_R_MISSING_PARAMETERS);
155         goto err;
156     }
157
158     if (!EVP_PKEY_missing_parameters(to)) {
159         if (EVP_PKEY_parameters_eq(to, from) == 1)
160             return 1;
161         EVPerr(EVP_F_EVP_PKEY_COPY_PARAMETERS, EVP_R_DIFFERENT_PARAMETERS);
162         return 0;
163     }
164
165     /* For purely provided keys, we just call the keymgmt utility */
166     if (to->keymgmt != NULL && from->keymgmt != NULL)
167         return evp_keymgmt_util_copy(to, (EVP_PKEY *)from, SELECT_PARAMETERS);
168
169     /*
170      * If |to| is provided, we know that |from| is legacy at this point.
171      * Try exporting |from| to |to|'s keymgmt, then use evp_keymgmt_copy()
172      * to copy the appropriate data to |to|'s keydata.
173      */
174     if (to->keymgmt != NULL) {
175         EVP_KEYMGMT *to_keymgmt = to->keymgmt;
176         void *from_keydata =
177             evp_pkey_export_to_provider((EVP_PKEY *)from, NULL, &to_keymgmt,
178                                         NULL);
179
180         /*
181          * If we get a NULL, it could be an internal error, or it could be
182          * that there's a key mismatch.  We're pretending the latter...
183          */
184         if (from_keydata == NULL) {
185             ERR_raise(ERR_LIB_EVP, EVP_R_DIFFERENT_KEY_TYPES);
186             return 0;
187         }
188         return evp_keymgmt_copy(to->keymgmt, to->keydata, from_keydata,
189                                 SELECT_PARAMETERS);
190     }
191
192     /* Both keys are legacy */
193     if (from->ameth != NULL && from->ameth->param_copy != NULL)
194         return from->ameth->param_copy(to, from);
195  err:
196     return 0;
197 }
198
199 int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey)
200 {
201     if (pkey != NULL) {
202         if (pkey->keymgmt != NULL)
203             return !evp_keymgmt_util_has((EVP_PKEY *)pkey, SELECT_PARAMETERS);
204         else if (pkey->ameth != NULL && pkey->ameth->param_missing != NULL)
205             return pkey->ameth->param_missing(pkey);
206     }
207     return 0;
208 }
209
210 /*
211  * This function is called for any mixture of keys except pure legacy pair.
212  * TODO When legacy keys are gone, we replace a call to this functions with
213  * a call to evp_keymgmt_util_match().
214  */
215 static int evp_pkey_cmp_any(const EVP_PKEY *a, const EVP_PKEY *b,
216                             int selection)
217 {
218     EVP_KEYMGMT *keymgmt1 = NULL, *keymgmt2 = NULL;
219     void *keydata1 = NULL, *keydata2 = NULL, *tmp_keydata = NULL;
220
221     /* If none of them are provided, this function shouldn't have been called */
222     if (!ossl_assert(evp_pkey_is_provided(a) || evp_pkey_is_provided(b)))
223         return -2;
224
225     /* For purely provided keys, we just call the keymgmt utility */
226     if (evp_pkey_is_provided(a) && evp_pkey_is_provided(b))
227         return evp_keymgmt_util_match((EVP_PKEY *)a, (EVP_PKEY *)b, selection);
228
229     /*
230      * At this point, one of them is provided, the other not.  This allows
231      * us to compare types using legacy NIDs.
232      */
233     if (evp_pkey_is_legacy(a)
234         && !EVP_KEYMGMT_is_a(b->keymgmt, OBJ_nid2sn(a->type)))
235         return -1;               /* not the same key type */
236     if (evp_pkey_is_legacy(b)
237         && !EVP_KEYMGMT_is_a(a->keymgmt, OBJ_nid2sn(b->type)))
238         return -1;               /* not the same key type */
239
240     /*
241      * We've determined that they both are the same keytype, so the next
242      * step is to do a bit of cross export to ensure we have keydata for
243      * both keys in the same keymgmt.
244      */
245     keymgmt1 = a->keymgmt;
246     keydata1 = a->keydata;
247     keymgmt2 = b->keymgmt;
248     keydata2 = b->keydata;
249
250     if (keymgmt2 != NULL && keymgmt2->match != NULL) {
251         tmp_keydata =
252             evp_pkey_export_to_provider((EVP_PKEY *)a, NULL, &keymgmt2, NULL);
253         if (tmp_keydata != NULL) {
254             keymgmt1 = keymgmt2;
255             keydata1 = tmp_keydata;
256         }
257     }
258     if (tmp_keydata == NULL && keymgmt1 != NULL && keymgmt1->match != NULL) {
259         tmp_keydata =
260             evp_pkey_export_to_provider((EVP_PKEY *)b, NULL, &keymgmt1, NULL);
261         if (tmp_keydata != NULL) {
262             keymgmt2 = keymgmt1;
263             keydata2 = tmp_keydata;
264         }
265     }
266
267     /* If we still don't have matching keymgmt implementations, we give up */
268     if (keymgmt1 != keymgmt2)
269         return -2;
270
271     /* If the keymgmt implementations are NULL, the export failed */
272     if (keymgmt1 == NULL)
273         return -2;
274
275     return evp_keymgmt_match(keymgmt1, keydata1, keydata2, selection);
276 }
277
278 int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
279 {
280     return EVP_PKEY_parameters_eq(a, b);
281 }
282
283 int EVP_PKEY_parameters_eq(const EVP_PKEY *a, const EVP_PKEY *b)
284 {
285     /*
286      * TODO: clean up legacy stuff from this function when legacy support
287      * is gone.
288      */
289
290     if (a->keymgmt != NULL || b->keymgmt != NULL)
291         return evp_pkey_cmp_any(a, b, SELECT_PARAMETERS);
292
293     /* All legacy keys */
294     if (a->type != b->type)
295         return -1;
296     if (a->ameth != NULL && a->ameth->param_cmp != NULL)
297         return a->ameth->param_cmp(a, b);
298     return -2;
299 }
300
301 int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
302 {
303     return EVP_PKEY_eq(a, b);
304 }
305
306 int EVP_PKEY_eq(const EVP_PKEY *a, const EVP_PKEY *b)
307 {
308     /*
309      * TODO: clean up legacy stuff from this function when legacy support
310      * is gone.
311      */
312
313     if (a->keymgmt != NULL || b->keymgmt != NULL)
314         return evp_pkey_cmp_any(a, b, (SELECT_PARAMETERS
315                                        | OSSL_KEYMGMT_SELECT_PUBLIC_KEY));
316
317     /* All legacy keys */
318     if (a->type != b->type)
319         return -1;
320
321     if (a->ameth != NULL) {
322         int ret;
323         /* Compare parameters if the algorithm has them */
324         if (a->ameth->param_cmp != NULL) {
325             ret = a->ameth->param_cmp(a, b);
326             if (ret <= 0)
327                 return ret;
328         }
329
330         if (a->ameth->pub_cmp != NULL)
331             return a->ameth->pub_cmp(a, b);
332     }
333
334     return -2;
335 }
336
337
338 static EVP_PKEY *new_raw_key_int(OSSL_LIB_CTX *libctx,
339                                  const char *strtype,
340                                  const char *propq,
341                                  int nidtype,
342                                  ENGINE *e,
343                                  const unsigned char *key,
344                                  size_t len,
345                                  int key_is_priv)
346 {
347     EVP_PKEY *pkey = NULL;
348     EVP_PKEY_CTX *ctx = NULL;
349     const EVP_PKEY_ASN1_METHOD *ameth = NULL;
350     int result = 0;
351
352 # ifndef OPENSSL_NO_ENGINE
353     /* Check if there is an Engine for this type */
354     if (e == NULL) {
355         ENGINE *tmpe = NULL;
356
357         if (strtype != NULL)
358             ameth = EVP_PKEY_asn1_find_str(&tmpe, strtype, -1);
359         else if (nidtype != EVP_PKEY_NONE)
360             ameth = EVP_PKEY_asn1_find(&tmpe, nidtype);
361
362         /* If tmpe is NULL then no engine is claiming to support this type */
363         if (tmpe == NULL)
364             ameth = NULL;
365
366         ENGINE_finish(tmpe);
367     }
368 # endif
369
370     if (e == NULL && ameth == NULL) {
371         /*
372          * No engine is claiming to support this type, so lets see if we have
373          * a provider.
374          */
375         ctx = EVP_PKEY_CTX_new_from_name(libctx,
376                                          strtype != NULL ? strtype
377                                                          : OBJ_nid2sn(nidtype),
378                                          propq);
379         if (ctx == NULL)
380             goto err;
381         /* May fail if no provider available */
382         ERR_set_mark();
383         if (EVP_PKEY_key_fromdata_init(ctx) == 1) {
384             OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
385
386             ERR_clear_last_mark();
387             params[0] = OSSL_PARAM_construct_octet_string(
388                             key_is_priv ? OSSL_PKEY_PARAM_PRIV_KEY
389                                         : OSSL_PKEY_PARAM_PUB_KEY,
390                             (void *)key, len);
391
392             if (EVP_PKEY_fromdata(ctx, &pkey, params) != 1) {
393                 EVPerr(0, EVP_R_KEY_SETUP_FAILED);
394                 goto err;
395             }
396
397             EVP_PKEY_CTX_free(ctx);
398
399             return pkey;
400         }
401         ERR_pop_to_mark();
402         /* else not supported so fallback to legacy */
403     }
404
405     /* Legacy code path */
406
407     pkey = EVP_PKEY_new();
408     if (pkey == NULL) {
409         EVPerr(0, ERR_R_MALLOC_FAILURE);
410         goto err;
411     }
412
413     if (!pkey_set_type(pkey, e, nidtype, strtype, -1, NULL)) {
414         /* EVPerr already called */
415         goto err;
416     }
417
418     if (!ossl_assert(pkey->ameth != NULL))
419         goto err;
420
421     if (key_is_priv) {
422         if (pkey->ameth->set_priv_key == NULL) {
423             EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
424             goto err;
425         }
426
427         if (!pkey->ameth->set_priv_key(pkey, key, len)) {
428             EVPerr(0, EVP_R_KEY_SETUP_FAILED);
429             goto err;
430         }
431     } else {
432         if (pkey->ameth->set_pub_key == NULL) {
433             EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
434             goto err;
435         }
436
437         if (!pkey->ameth->set_pub_key(pkey, key, len)) {
438             EVPerr(0, EVP_R_KEY_SETUP_FAILED);
439             goto err;
440         }
441     }
442
443     result = 1;
444  err:
445     if (!result) {
446         EVP_PKEY_free(pkey);
447         pkey = NULL;
448     }
449     EVP_PKEY_CTX_free(ctx);
450     return pkey;
451 }
452
453 EVP_PKEY *EVP_PKEY_new_raw_private_key_ex(OSSL_LIB_CTX *libctx,
454                                           const char *keytype,
455                                           const char *propq,
456                                           const unsigned char *priv, size_t len)
457 {
458     return new_raw_key_int(libctx, keytype, propq, EVP_PKEY_NONE, NULL, priv,
459                            len, 1);
460 }
461
462 EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e,
463                                        const unsigned char *priv,
464                                        size_t len)
465 {
466     return new_raw_key_int(NULL, NULL, NULL, type, e, priv, len, 1);
467 }
468
469 EVP_PKEY *EVP_PKEY_new_raw_public_key_ex(OSSL_LIB_CTX *libctx,
470                                          const char *keytype, const char *propq,
471                                          const unsigned char *pub, size_t len)
472 {
473     return new_raw_key_int(libctx, keytype, propq, EVP_PKEY_NONE, NULL, pub,
474                            len, 0);
475 }
476
477 EVP_PKEY *EVP_PKEY_new_raw_public_key(int type, ENGINE *e,
478                                       const unsigned char *pub,
479                                       size_t len)
480 {
481     return new_raw_key_int(NULL, NULL, NULL, type, e, pub, len, 0);
482 }
483
484 struct raw_key_details_st
485 {
486     unsigned char **key;
487     size_t *len;
488     int selection;
489 };
490
491 static OSSL_CALLBACK get_raw_key_details;
492 static int get_raw_key_details(const OSSL_PARAM params[], void *arg)
493 {
494     const OSSL_PARAM *p = NULL;
495     struct raw_key_details_st *raw_key = arg;
496
497     if (raw_key->selection == OSSL_KEYMGMT_SELECT_PRIVATE_KEY) {
498         if ((p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY))
499                 != NULL)
500             return OSSL_PARAM_get_octet_string(p, (void **)raw_key->key,
501                                                SIZE_MAX, raw_key->len);
502     } else if (raw_key->selection == OSSL_KEYMGMT_SELECT_PUBLIC_KEY) {
503         if ((p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY))
504                 != NULL)
505             return OSSL_PARAM_get_octet_string(p, (void **)raw_key->key,
506                                                SIZE_MAX, raw_key->len);
507     }
508
509     return 0;
510 }
511
512 int EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey, unsigned char *priv,
513                                  size_t *len)
514 {
515     if (pkey->keymgmt != NULL) {
516         struct raw_key_details_st raw_key;
517
518         raw_key.key = priv == NULL ? NULL : &priv;
519         raw_key.len = len;
520         raw_key.selection = OSSL_KEYMGMT_SELECT_PRIVATE_KEY;
521
522         return evp_keymgmt_util_export(pkey, OSSL_KEYMGMT_SELECT_PRIVATE_KEY,
523                                        get_raw_key_details, &raw_key);
524     }
525
526     if (pkey->ameth == NULL) {
527         EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
528         return 0;
529     }
530
531     if (pkey->ameth->get_priv_key == NULL) {
532         EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
533         return 0;
534     }
535
536     if (!pkey->ameth->get_priv_key(pkey, priv, len)) {
537         EVPerr(0, EVP_R_GET_RAW_KEY_FAILED);
538         return 0;
539     }
540
541     return 1;
542 }
543
544 int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub,
545                                 size_t *len)
546 {
547     if (pkey->keymgmt != NULL) {
548         struct raw_key_details_st raw_key;
549
550         raw_key.key = pub == NULL ? NULL : &pub;
551         raw_key.len = len;
552         raw_key.selection = OSSL_KEYMGMT_SELECT_PUBLIC_KEY;
553
554         return evp_keymgmt_util_export(pkey, OSSL_KEYMGMT_SELECT_PUBLIC_KEY,
555                                        get_raw_key_details, &raw_key);
556     }
557
558     if (pkey->ameth == NULL) {
559         EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
560         return 0;
561     }
562
563      if (pkey->ameth->get_pub_key == NULL) {
564         EVPerr(EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY,
565                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
566         return 0;
567     }
568
569     if (!pkey->ameth->get_pub_key(pkey, pub, len)) {
570         EVPerr(EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY, EVP_R_GET_RAW_KEY_FAILED);
571         return 0;
572     }
573
574     return 1;
575 }
576
577 static EVP_PKEY *new_cmac_key_int(const unsigned char *priv, size_t len,
578                                   const char *cipher_name,
579                                   const EVP_CIPHER *cipher,
580                                   OSSL_LIB_CTX *libctx,
581                                   const char *propq, ENGINE *e)
582 {
583 # ifndef OPENSSL_NO_CMAC
584 #  ifndef OPENSSL_NO_ENGINE
585     const char *engine_id = e != NULL ? ENGINE_get_id(e) : NULL;
586 #  endif
587     OSSL_PARAM params[5], *p = params;
588     EVP_PKEY *pkey = NULL;
589     EVP_PKEY_CTX *ctx;
590
591     if (cipher != NULL)
592         cipher_name = EVP_CIPHER_name(cipher);
593
594     if (cipher_name == NULL) {
595         EVPerr(0, EVP_R_KEY_SETUP_FAILED);
596         return NULL;
597     }
598
599     ctx = EVP_PKEY_CTX_new_from_name(libctx, "CMAC", propq);
600     if (ctx == NULL)
601         goto err;
602
603     if (!EVP_PKEY_key_fromdata_init(ctx)) {
604         EVPerr(0, EVP_R_KEY_SETUP_FAILED);
605         goto err;
606     }
607
608     *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
609                                             (void *)priv, len);
610     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_CIPHER,
611                                             (char *)cipher_name, 0);
612     if (propq != NULL)
613         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_PROPERTIES,
614                                                 (char *)propq, 0);
615 #  ifndef OPENSSL_NO_ENGINE
616     if (engine_id != NULL)
617         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_ENGINE,
618                                                 (char *)engine_id, 0);
619 #  endif
620     *p = OSSL_PARAM_construct_end();
621
622     if (!EVP_PKEY_fromdata(ctx, &pkey, params)) {
623         EVPerr(0, EVP_R_KEY_SETUP_FAILED);
624         goto err;
625     }
626
627  err:
628     EVP_PKEY_CTX_free(ctx);
629
630     return pkey;
631 # else
632     EVPerr(0, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
633     return NULL;
634 # endif
635 }
636
637 EVP_PKEY *EVP_PKEY_new_CMAC_key_ex(const unsigned char *priv, size_t len,
638                                    const char *cipher_name, OSSL_LIB_CTX *libctx,
639                                    const char *propq)
640 {
641     return new_cmac_key_int(priv, len, cipher_name, NULL, libctx, propq, NULL);
642 }
643
644 EVP_PKEY *EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv,
645                                 size_t len, const EVP_CIPHER *cipher)
646 {
647     return new_cmac_key_int(priv, len, NULL, cipher, NULL, NULL, e);
648 }
649
650 int EVP_PKEY_set_type(EVP_PKEY *pkey, int type)
651 {
652     return pkey_set_type(pkey, NULL, type, NULL, -1, NULL);
653 }
654
655 int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len)
656 {
657     return pkey_set_type(pkey, NULL, EVP_PKEY_NONE, str, len, NULL);
658 }
659
660 #ifndef OPENSSL_NO_DEPRECATED_3_0
661 int EVP_PKEY_set_alias_type(EVP_PKEY *pkey, int type)
662 {
663     if (!evp_pkey_is_legacy(pkey)) {
664         const char *name = OBJ_nid2sn(type);
665
666         if (name != NULL && EVP_PKEY_is_a(pkey, name))
667             return 1;
668
669         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_OPERATION);
670         return 0;
671     }
672
673     if (pkey->type == type) {
674         return 1; /* it already is that type */
675     }
676
677     /*
678      * The application is requesting to alias this to a different pkey type,
679      * but not one that resolves to the base type.
680      */
681     if (EVP_PKEY_type(type) != EVP_PKEY_base_id(pkey)) {
682         EVPerr(EVP_F_EVP_PKEY_SET_ALIAS_TYPE, EVP_R_UNSUPPORTED_ALGORITHM);
683         return 0;
684     }
685
686     pkey->type = type;
687     return 1;
688 }
689 #endif
690
691 # ifndef OPENSSL_NO_ENGINE
692 int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e)
693 {
694     if (e != NULL) {
695         if (!ENGINE_init(e)) {
696             EVPerr(EVP_F_EVP_PKEY_SET1_ENGINE, ERR_R_ENGINE_LIB);
697             return 0;
698         }
699         if (ENGINE_get_pkey_meth(e, pkey->type) == NULL) {
700             ENGINE_finish(e);
701             EVPerr(EVP_F_EVP_PKEY_SET1_ENGINE, EVP_R_UNSUPPORTED_ALGORITHM);
702             return 0;
703         }
704     }
705     ENGINE_finish(pkey->pmeth_engine);
706     pkey->pmeth_engine = e;
707     return 1;
708 }
709
710 ENGINE *EVP_PKEY_get0_engine(const EVP_PKEY *pkey)
711 {
712     return pkey->engine;
713 }
714 # endif
715 int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key)
716 {
717     int alias = type;
718
719 #ifndef OPENSSL_NO_EC
720     if ((key != NULL) && (EVP_PKEY_type(type) == EVP_PKEY_EC)) {
721         const EC_GROUP *group = EC_KEY_get0_group(key);
722
723         if (group != NULL && EC_GROUP_get_curve_name(group) == NID_sm2)
724             alias = EVP_PKEY_SM2;
725     }
726 #endif
727
728     if (pkey == NULL || !EVP_PKEY_set_type(pkey, type))
729         return 0;
730     if (!EVP_PKEY_set_alias_type(pkey, alias))
731         return 0;
732     pkey->pkey.ptr = key;
733     return (key != NULL);
734 }
735
736 void *EVP_PKEY_get0(const EVP_PKEY *pkey)
737 {
738     if (pkey == NULL)
739         return NULL;
740     if (!evp_pkey_downgrade((EVP_PKEY *)pkey)) {
741         ERR_raise(ERR_LIB_EVP, EVP_R_INACCESSIBLE_KEY);
742         return NULL;
743     }
744     return pkey->pkey.ptr;
745 }
746
747 const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len)
748 {
749     ASN1_OCTET_STRING *os = NULL;
750     if (pkey->type != EVP_PKEY_HMAC) {
751         EVPerr(EVP_F_EVP_PKEY_GET0_HMAC, EVP_R_EXPECTING_AN_HMAC_KEY);
752         return NULL;
753     }
754     os = EVP_PKEY_get0(pkey);
755     *len = os->length;
756     return os->data;
757 }
758
759 # ifndef OPENSSL_NO_POLY1305
760 const unsigned char *EVP_PKEY_get0_poly1305(const EVP_PKEY *pkey, size_t *len)
761 {
762     ASN1_OCTET_STRING *os = NULL;
763     if (pkey->type != EVP_PKEY_POLY1305) {
764         EVPerr(EVP_F_EVP_PKEY_GET0_POLY1305, EVP_R_EXPECTING_A_POLY1305_KEY);
765         return NULL;
766     }
767     os = EVP_PKEY_get0(pkey);
768     *len = os->length;
769     return os->data;
770 }
771 # endif
772
773 # ifndef OPENSSL_NO_SIPHASH
774 const unsigned char *EVP_PKEY_get0_siphash(const EVP_PKEY *pkey, size_t *len)
775 {
776     ASN1_OCTET_STRING *os = NULL;
777
778     if (pkey->type != EVP_PKEY_SIPHASH) {
779         EVPerr(EVP_F_EVP_PKEY_GET0_SIPHASH, EVP_R_EXPECTING_A_SIPHASH_KEY);
780         return NULL;
781     }
782     os = EVP_PKEY_get0(pkey);
783     *len = os->length;
784     return os->data;
785 }
786 # endif
787
788 # ifndef OPENSSL_NO_RSA
789 int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, RSA *key)
790 {
791     int ret = EVP_PKEY_assign_RSA(pkey, key);
792     if (ret)
793         RSA_up_ref(key);
794     return ret;
795 }
796
797 RSA *EVP_PKEY_get0_RSA(const EVP_PKEY *pkey)
798 {
799     if (!evp_pkey_downgrade((EVP_PKEY *)pkey)) {
800         ERR_raise(ERR_LIB_EVP, EVP_R_INACCESSIBLE_KEY);
801         return NULL;
802     }
803     if (pkey->type != EVP_PKEY_RSA && pkey->type != EVP_PKEY_RSA_PSS) {
804         EVPerr(EVP_F_EVP_PKEY_GET0_RSA, EVP_R_EXPECTING_AN_RSA_KEY);
805         return NULL;
806     }
807     return pkey->pkey.rsa;
808 }
809
810 RSA *EVP_PKEY_get1_RSA(EVP_PKEY *pkey)
811 {
812     RSA *ret = EVP_PKEY_get0_RSA(pkey);
813     if (ret != NULL)
814         RSA_up_ref(ret);
815     return ret;
816 }
817 # endif
818
819 # ifndef OPENSSL_NO_DSA
820 DSA *EVP_PKEY_get0_DSA(const EVP_PKEY *pkey)
821 {
822     if (!evp_pkey_downgrade((EVP_PKEY *)pkey)) {
823         ERR_raise(ERR_LIB_EVP, EVP_R_INACCESSIBLE_KEY);
824         return NULL;
825     }
826     if (pkey->type != EVP_PKEY_DSA) {
827         EVPerr(EVP_F_EVP_PKEY_GET0_DSA, EVP_R_EXPECTING_A_DSA_KEY);
828         return NULL;
829     }
830     return pkey->pkey.dsa;
831 }
832
833 int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, DSA *key)
834 {
835     int ret = EVP_PKEY_assign_DSA(pkey, key);
836     if (ret)
837         DSA_up_ref(key);
838     return ret;
839 }
840 DSA *EVP_PKEY_get1_DSA(EVP_PKEY *pkey)
841 {
842     DSA *ret = EVP_PKEY_get0_DSA(pkey);
843     if (ret != NULL)
844         DSA_up_ref(ret);
845     return ret;
846 }
847 # endif /*  OPENSSL_NO_DSA */
848 #endif /* FIPS_MODULE */
849
850 #ifndef FIPS_MODULE
851 # ifndef OPENSSL_NO_EC
852 int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key)
853 {
854     int ret = EVP_PKEY_assign_EC_KEY(pkey, key);
855     if (ret)
856         EC_KEY_up_ref(key);
857     return ret;
858 }
859
860 EC_KEY *EVP_PKEY_get0_EC_KEY(const EVP_PKEY *pkey)
861 {
862     if (!evp_pkey_downgrade((EVP_PKEY *)pkey)) {
863         ERR_raise(ERR_LIB_EVP, EVP_R_INACCESSIBLE_KEY);
864         return NULL;
865     }
866     if (EVP_PKEY_base_id(pkey) != EVP_PKEY_EC) {
867         EVPerr(EVP_F_EVP_PKEY_GET0_EC_KEY, EVP_R_EXPECTING_A_EC_KEY);
868         return NULL;
869     }
870     return pkey->pkey.ec;
871 }
872
873 EC_KEY *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey)
874 {
875     EC_KEY *ret = EVP_PKEY_get0_EC_KEY(pkey);
876     if (ret != NULL)
877         EC_KEY_up_ref(ret);
878     return ret;
879 }
880
881 static ECX_KEY *evp_pkey_get0_ECX_KEY(const EVP_PKEY *pkey, int type)
882 {
883     if (!evp_pkey_downgrade((EVP_PKEY *)pkey)) {
884         ERR_raise(ERR_LIB_EVP, EVP_R_INACCESSIBLE_KEY);
885         return NULL;
886     }
887     if (EVP_PKEY_base_id(pkey) != type) {
888         ERR_raise(ERR_LIB_EVP, EVP_R_EXPECTING_A_ECX_KEY);
889         return NULL;
890     }
891     return pkey->pkey.ecx;
892 }
893
894 static ECX_KEY *evp_pkey_get1_ECX_KEY(EVP_PKEY *pkey, int type)
895 {
896     ECX_KEY *ret = evp_pkey_get0_ECX_KEY(pkey, type);
897     if (ret != NULL)
898         ecx_key_up_ref(ret);
899     return ret;
900 }
901
902 #  define IMPLEMENT_ECX_VARIANT(NAME)                                   \
903     ECX_KEY *evp_pkey_get1_##NAME(EVP_PKEY *pkey)                       \
904     {                                                                   \
905         return evp_pkey_get1_ECX_KEY(pkey, EVP_PKEY_##NAME);            \
906     }
907 IMPLEMENT_ECX_VARIANT(X25519)
908 IMPLEMENT_ECX_VARIANT(X448)
909 IMPLEMENT_ECX_VARIANT(ED25519)
910 IMPLEMENT_ECX_VARIANT(ED448)
911
912 # endif
913
914 # ifndef OPENSSL_NO_DH
915
916 int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key)
917 {
918     int type = DH_get0_q(key) == NULL ? EVP_PKEY_DH : EVP_PKEY_DHX;
919     int ret = EVP_PKEY_assign(pkey, type, key);
920
921     if (ret)
922         DH_up_ref(key);
923     return ret;
924 }
925
926 DH *EVP_PKEY_get0_DH(const EVP_PKEY *pkey)
927 {
928     if (!evp_pkey_downgrade((EVP_PKEY *)pkey)) {
929         ERR_raise(ERR_LIB_EVP, EVP_R_INACCESSIBLE_KEY);
930         return NULL;
931     }
932     if (pkey->type != EVP_PKEY_DH && pkey->type != EVP_PKEY_DHX) {
933         EVPerr(EVP_F_EVP_PKEY_GET0_DH, EVP_R_EXPECTING_A_DH_KEY);
934         return NULL;
935     }
936     return pkey->pkey.dh;
937 }
938
939 DH *EVP_PKEY_get1_DH(EVP_PKEY *pkey)
940 {
941     DH *ret = EVP_PKEY_get0_DH(pkey);
942     if (ret != NULL)
943         DH_up_ref(ret);
944     return ret;
945 }
946 # endif
947
948 int EVP_PKEY_type(int type)
949 {
950     int ret;
951     const EVP_PKEY_ASN1_METHOD *ameth;
952     ENGINE *e;
953     ameth = EVP_PKEY_asn1_find(&e, type);
954     if (ameth)
955         ret = ameth->pkey_id;
956     else
957         ret = NID_undef;
958 # ifndef OPENSSL_NO_ENGINE
959     ENGINE_finish(e);
960 # endif
961     return ret;
962 }
963
964 int EVP_PKEY_id(const EVP_PKEY *pkey)
965 {
966     return pkey->type;
967 }
968
969 int EVP_PKEY_base_id(const EVP_PKEY *pkey)
970 {
971     return EVP_PKEY_type(pkey->type);
972 }
973
974 #ifndef FIPS_MODULE
975 int evp_pkey_name2type(const char *name)
976 {
977     /*
978      * These hard coded cases are pure hackery to get around the fact
979      * that names in crypto/objects/objects.txt are a mess.  There is
980      * no "EC", and "RSA" leads to the NID for 2.5.8.1.1, an OID that's
981      * fallen out in favor of { pkcs-1 1 }, i.e. 1.2.840.113549.1.1.1,
982      * the NID of which is used for EVP_PKEY_RSA.  Strangely enough,
983      * "DSA" is accurate...  but still, better be safe and hard-code
984      * names that we know.
985      * On a similar topic, EVP_PKEY_type(EVP_PKEY_SM2) will result in
986      * EVP_PKEY_EC, because of aliasing.
987      * TODO Clean this away along with all other #legacy support.
988      */
989     int type = NID_undef;
990
991     if (strcasecmp(name, "RSA") == 0)
992         type = EVP_PKEY_RSA;
993     else if (strcasecmp(name, "RSA-PSS") == 0)
994         type = EVP_PKEY_RSA_PSS;
995     else if (strcasecmp(name, "EC") == 0)
996         type = EVP_PKEY_EC;
997     else if (strcasecmp(name, "ED25519") == 0)
998         type = EVP_PKEY_ED25519;
999     else if (strcasecmp(name, "ED448") == 0)
1000         type = EVP_PKEY_ED448;
1001     else if (strcasecmp(name, "X25519") == 0)
1002         type = EVP_PKEY_X25519;
1003     else if (strcasecmp(name, "X448") == 0)
1004         type = EVP_PKEY_X448;
1005     else if (strcasecmp(name, "SM2") == 0)
1006         type = EVP_PKEY_SM2;
1007     else if (strcasecmp(name, "DH") == 0)
1008         type = EVP_PKEY_DH;
1009     else if (strcasecmp(name, "X9.42 DH") == 0)
1010         type = EVP_PKEY_DHX;
1011     else if (strcasecmp(name, "DSA") == 0)
1012         type = EVP_PKEY_DSA;
1013
1014     if (type == NID_undef)
1015         type = EVP_PKEY_type(OBJ_sn2nid(name));
1016     if (type == NID_undef)
1017         type = EVP_PKEY_type(OBJ_ln2nid(name));
1018
1019     return type;
1020 }
1021 #endif
1022
1023 int EVP_PKEY_is_a(const EVP_PKEY *pkey, const char *name)
1024 {
1025 #ifndef FIPS_MODULE
1026     if (pkey->keymgmt == NULL) {
1027         int type = evp_pkey_name2type(name);
1028
1029         return pkey->type == type;
1030     }
1031 #endif
1032     return EVP_KEYMGMT_is_a(pkey->keymgmt, name);
1033 }
1034
1035 void EVP_PKEY_typenames_do_all(const EVP_PKEY *pkey,
1036                                void (*fn)(const char *name, void *data),
1037                                void *data)
1038 {
1039     if (!evp_pkey_is_typed(pkey))
1040         return;
1041
1042     if (!evp_pkey_is_provided(pkey)) {
1043         const char *name = OBJ_nid2sn(EVP_PKEY_id(pkey));
1044
1045         fn(name, data);
1046         return;
1047     }
1048     EVP_KEYMGMT_names_do_all(pkey->keymgmt, fn, data);
1049 }
1050
1051 int EVP_PKEY_can_sign(const EVP_PKEY *pkey)
1052 {
1053     if (pkey->keymgmt == NULL) {
1054         switch (EVP_PKEY_base_id(pkey)) {
1055         case EVP_PKEY_RSA:
1056             return 1;
1057 #ifndef OPENSSL_NO_DSA
1058         case EVP_PKEY_DSA:
1059             return 1;
1060 #endif
1061 #ifndef OPENSSL_NO_EC
1062         case EVP_PKEY_ED25519:
1063         case EVP_PKEY_ED448:
1064             return 1;
1065         case EVP_PKEY_EC:        /* Including SM2 */
1066             return EC_KEY_can_sign(pkey->pkey.ec);
1067 #endif
1068         default:
1069             break;
1070         }
1071     } else {
1072         const OSSL_PROVIDER *prov = EVP_KEYMGMT_provider(pkey->keymgmt);
1073         OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
1074         const char *supported_sig =
1075             pkey->keymgmt->query_operation_name != NULL
1076             ? pkey->keymgmt->query_operation_name(OSSL_OP_SIGNATURE)
1077             : evp_first_name(prov, pkey->keymgmt->name_id);
1078         EVP_SIGNATURE *signature = NULL;
1079
1080         signature = EVP_SIGNATURE_fetch(libctx, supported_sig, NULL);
1081         if (signature != NULL) {
1082             EVP_SIGNATURE_free(signature);
1083             return 1;
1084         }
1085     }
1086     return 0;
1087 }
1088
1089 #ifndef OPENSSL_NO_EC
1090 /*
1091  * TODO rewrite when we have proper data extraction functions
1092  * Note: an octet pointer would be desirable!
1093  */
1094 static OSSL_CALLBACK get_ec_curve_name_cb;
1095 static int get_ec_curve_name_cb(const OSSL_PARAM params[], void *arg)
1096 {
1097     const OSSL_PARAM *p = NULL;
1098
1099     if ((p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_GROUP_NAME)) != NULL)
1100         return OSSL_PARAM_get_utf8_string(p, arg, 0);
1101
1102     /* If there is no curve name, this is not an EC key */
1103     return 0;
1104 }
1105
1106 int evp_pkey_get_EC_KEY_curve_nid(const EVP_PKEY *pkey)
1107 {
1108     int ret = NID_undef;
1109
1110     if (pkey->keymgmt == NULL) {
1111         if (EVP_PKEY_base_id(pkey) == EVP_PKEY_EC) {
1112             EC_KEY *ec = EVP_PKEY_get0_EC_KEY(pkey);
1113
1114             ret = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
1115         }
1116     } else if (EVP_PKEY_is_a(pkey, "EC") || EVP_PKEY_is_a(pkey, "SM2")) {
1117         char *curve_name = NULL;
1118
1119         ret = evp_keymgmt_util_export(pkey,
1120                                       OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
1121                                       get_ec_curve_name_cb, &curve_name);
1122         if (ret)
1123             ret = ec_curve_name2nid(curve_name);
1124         OPENSSL_free(curve_name);
1125     }
1126
1127     return ret;
1128 }
1129 #endif
1130
1131 static int print_reset_indent(BIO **out, int pop_f_prefix, long saved_indent)
1132 {
1133     BIO_set_indent(*out, saved_indent);
1134     if (pop_f_prefix) {
1135         BIO *next = BIO_pop(*out);
1136
1137         BIO_free(*out);
1138         *out = next;
1139     }
1140     return 1;
1141 }
1142
1143 static int print_set_indent(BIO **out, int *pop_f_prefix, long *saved_indent,
1144                             long indent)
1145 {
1146     *pop_f_prefix = 0;
1147     *saved_indent = 0;
1148     if (indent > 0) {
1149         long i = BIO_get_indent(*out);
1150
1151         *saved_indent =  (i < 0 ? 0 : i);
1152         if (BIO_set_indent(*out, indent) <= 0) {
1153             if ((*out = BIO_push(BIO_new(BIO_f_prefix()), *out)) == NULL)
1154                 return 0;
1155             *pop_f_prefix = 1;
1156         }
1157         if (BIO_set_indent(*out, indent) <= 0) {
1158             print_reset_indent(out, *pop_f_prefix, *saved_indent);
1159             return 0;
1160         }
1161     }
1162     return 1;
1163 }
1164
1165 static int unsup_alg(BIO *out, const EVP_PKEY *pkey, int indent,
1166                      const char *kstr)
1167 {
1168     return BIO_indent(out, indent, 128)
1169         && BIO_printf(out, "%s algorithm \"%s\" unsupported\n",
1170                       kstr, OBJ_nid2ln(pkey->type)) > 0;
1171 }
1172
1173 static int print_pkey(const EVP_PKEY *pkey, BIO *out, int indent,
1174                       int selection /* For provided encoding */,
1175                       OSSL_LIB_CTX *libctx /* For provided encoding */,
1176                       const char *propquery /* For provided encoding */,
1177                       int (*legacy_print)(BIO *out, const EVP_PKEY *pkey,
1178                                           int indent, ASN1_PCTX *pctx),
1179                       ASN1_PCTX *legacy_pctx /* For legacy print */)
1180 {
1181     int pop_f_prefix;
1182     long saved_indent;
1183     OSSL_ENCODER_CTX *ctx = NULL;
1184     int ret = -2;                /* default to unsupported */
1185
1186     if (!print_set_indent(&out, &pop_f_prefix, &saved_indent, indent))
1187         return 0;
1188
1189     ctx = OSSL_ENCODER_CTX_new_by_EVP_PKEY(pkey, "TEXT", selection,
1190                                            libctx, propquery);
1191     if (OSSL_ENCODER_CTX_get_num_encoders(ctx) != 0)
1192         ret = OSSL_ENCODER_to_bio(ctx, out);
1193     OSSL_ENCODER_CTX_free(ctx);
1194
1195     if (ret != -2)
1196         goto end;
1197
1198     /* legacy fallback */
1199     if (legacy_print != NULL)
1200         ret = legacy_print(out, pkey, 0, legacy_pctx);
1201     else
1202         ret = unsup_alg(out, pkey, 0, "Public Key");
1203
1204  end:
1205     print_reset_indent(&out, pop_f_prefix, saved_indent);
1206     return ret;
1207 }
1208
1209 int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
1210                           int indent, ASN1_PCTX *pctx)
1211 {
1212     return print_pkey(pkey, out, indent,
1213                       OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS
1214                       | OSSL_KEYMGMT_SELECT_PUBLIC_KEY,
1215                       NULL, NULL,
1216                       (pkey->ameth != NULL ? pkey->ameth->pub_print : NULL),
1217                       pctx);
1218 }
1219
1220 int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
1221                            int indent, ASN1_PCTX *pctx)
1222 {
1223     return print_pkey(pkey, out, indent,
1224                       OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS
1225                       | OSSL_KEYMGMT_SELECT_KEYPAIR,
1226                       NULL, NULL,
1227                       (pkey->ameth != NULL ? pkey->ameth->priv_print : NULL),
1228                       pctx);
1229 }
1230
1231 int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
1232                           int indent, ASN1_PCTX *pctx)
1233 {
1234     return print_pkey(pkey, out, indent, OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
1235                       NULL, NULL,
1236                       (pkey->ameth != NULL ? pkey->ameth->param_print : NULL),
1237                       pctx);
1238 }
1239
1240 static int legacy_asn1_ctrl_to_param(EVP_PKEY *pkey, int op,
1241                                      int arg1, void *arg2)
1242 {
1243     if (pkey->keymgmt == NULL)
1244         return 0;
1245     switch (op) {
1246     case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
1247         {
1248             char mdname[80] = "";
1249             int rv = EVP_PKEY_get_default_digest_name(pkey, mdname,
1250                                                       sizeof(mdname));
1251
1252             if (rv > 0) {
1253                 int nid;
1254
1255                 nid = OBJ_sn2nid(mdname);
1256                 if (nid == NID_undef)
1257                     nid = OBJ_ln2nid(mdname);
1258                 *(int *)arg2 = nid;
1259             }
1260             return rv;
1261         }
1262     default:
1263         return -2;
1264     }
1265 }
1266
1267 static int evp_pkey_asn1_ctrl(EVP_PKEY *pkey, int op, int arg1, void *arg2)
1268 {
1269     if (pkey->ameth == NULL)
1270         return legacy_asn1_ctrl_to_param(pkey, op, arg1, arg2);
1271     if (pkey->ameth->pkey_ctrl == NULL)
1272         return -2;
1273     return pkey->ameth->pkey_ctrl(pkey, op, arg1, arg2);
1274 }
1275
1276 int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid)
1277 {
1278     return evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_DEFAULT_MD_NID, 0, pnid);
1279 }
1280
1281 int EVP_PKEY_get_default_digest_name(EVP_PKEY *pkey,
1282                                      char *mdname, size_t mdname_sz)
1283 {
1284     if (pkey->ameth == NULL)
1285         return evp_keymgmt_util_get_deflt_digest_name(pkey->keymgmt,
1286                                                       pkey->keydata,
1287                                                       mdname, mdname_sz);
1288
1289     {
1290         int nid = NID_undef;
1291         int rv = EVP_PKEY_get_default_digest_nid(pkey, &nid);
1292         const char *name = rv > 0 ? OBJ_nid2sn(nid) : NULL;
1293
1294         if (rv > 0)
1295             OPENSSL_strlcpy(mdname, name, mdname_sz);
1296         return rv;
1297     }
1298 }
1299
1300 int EVP_PKEY_supports_digest_nid(EVP_PKEY *pkey, int nid)
1301 {
1302     int rv, default_nid;
1303
1304     rv = evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_SUPPORTS_MD_NID, nid, NULL);
1305     if (rv == -2) {
1306         /*
1307          * If there is a mandatory default digest and this isn't it, then
1308          * the answer is 'no'.
1309          */
1310         rv = EVP_PKEY_get_default_digest_nid(pkey, &default_nid);
1311         if (rv == 2)
1312             return (nid == default_nid);
1313         /* zero is an error from EVP_PKEY_get_default_digest_nid() */
1314         if (rv == 0)
1315             return -1;
1316     }
1317     return rv;
1318 }
1319
1320 int EVP_PKEY_set1_tls_encodedpoint(EVP_PKEY *pkey,
1321                                const unsigned char *pt, size_t ptlen)
1322 {
1323     if (pkey->ameth == NULL) {
1324         OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
1325
1326         if (pkey->keymgmt == NULL || pkey->keydata == NULL)
1327             return 0;
1328
1329         params[0] =
1330             OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_TLS_ENCODED_PT,
1331                                               (unsigned char *)pt, ptlen);
1332         return evp_keymgmt_set_params(pkey->keymgmt, pkey->keydata, params);
1333     }
1334
1335     if (ptlen > INT_MAX)
1336         return 0;
1337     if (evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_SET1_TLS_ENCPT, ptlen,
1338                            (void *)pt) <= 0)
1339         return 0;
1340     return 1;
1341 }
1342
1343 size_t EVP_PKEY_get1_tls_encodedpoint(EVP_PKEY *pkey, unsigned char **ppt)
1344 {
1345     int rv;
1346
1347     if (pkey->ameth == NULL) {
1348         OSSL_PARAM params[2] = { OSSL_PARAM_END, OSSL_PARAM_END };
1349
1350         if (pkey->keymgmt == NULL || pkey->keydata == NULL)
1351             return 0;
1352
1353         params[0] =
1354             OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_TLS_ENCODED_PT,
1355                                               NULL, 0);
1356         if (!evp_keymgmt_get_params(pkey->keymgmt, pkey->keydata, params))
1357             return 0;
1358
1359         *ppt = OPENSSL_malloc(params[0].return_size);
1360         if (*ppt == NULL)
1361             return 0;
1362
1363         params[0] =
1364             OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_TLS_ENCODED_PT,
1365                                               *ppt, params[0].return_size);
1366         if (!evp_keymgmt_get_params(pkey->keymgmt, pkey->keydata, params))
1367             return 0;
1368
1369         return params[0].return_size;
1370     }
1371
1372
1373     rv = evp_pkey_asn1_ctrl(pkey, ASN1_PKEY_CTRL_GET1_TLS_ENCPT, 0, ppt);
1374     if (rv <= 0)
1375         return 0;
1376     return rv;
1377 }
1378
1379 #endif /* FIPS_MODULE */
1380
1381 /*- All methods below can also be used in FIPS_MODULE */
1382
1383 /*
1384  * This reset function must be used very carefully, as it literally throws
1385  * away everything in an EVP_PKEY without freeing them, and may cause leaks
1386  * of memory, locks, what have you.
1387  * The only reason we have this is to have the same code for EVP_PKEY_new()
1388  * and evp_pkey_downgrade().
1389  */
1390 static int evp_pkey_reset_unlocked(EVP_PKEY *pk)
1391 {
1392     if (pk == NULL)
1393         return 0;
1394
1395     memset(pk, 0, sizeof(*pk));
1396     pk->type = EVP_PKEY_NONE;
1397     pk->save_type = EVP_PKEY_NONE;
1398     pk->references = 1;
1399     pk->save_parameters = 1;
1400
1401     pk->lock = CRYPTO_THREAD_lock_new();
1402     if (pk->lock == NULL) {
1403         EVPerr(0, ERR_R_MALLOC_FAILURE);
1404         return 0;
1405     }
1406     return 1;
1407 }
1408
1409 EVP_PKEY *EVP_PKEY_new(void)
1410 {
1411     EVP_PKEY *ret = OPENSSL_zalloc(sizeof(*ret));
1412
1413     if (ret == NULL) {
1414         EVPerr(EVP_F_EVP_PKEY_NEW, ERR_R_MALLOC_FAILURE);
1415         return NULL;
1416     }
1417
1418     if (!evp_pkey_reset_unlocked(ret))
1419         goto err;
1420
1421 #ifndef FIPS_MODULE
1422     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_EVP_PKEY, ret, &ret->ex_data)) {
1423         EVPerr(EVP_F_EVP_PKEY_NEW, ERR_R_MALLOC_FAILURE);
1424         goto err;
1425     }
1426 #endif
1427     return ret;
1428
1429  err:
1430     CRYPTO_THREAD_lock_free(ret->lock);
1431     OPENSSL_free(ret);
1432     return NULL;
1433 }
1434
1435 /*
1436  * Setup a public key management method.
1437  *
1438  * For legacy keys, either |type| or |str| is expected to have the type
1439  * information.  In this case, the setup consists of finding an ASN1 method
1440  * and potentially an ENGINE, and setting those fields in |pkey|.
1441  *
1442  * For provider side keys, |keymgmt| is expected to be non-NULL.  In this
1443  * case, the setup consists of setting the |keymgmt| field in |pkey|.
1444  *
1445  * If pkey is NULL just return 1 or 0 if the key management method exists.
1446  */
1447
1448 static int pkey_set_type(EVP_PKEY *pkey, ENGINE *e, int type, const char *str,
1449                          int len, EVP_KEYMGMT *keymgmt)
1450 {
1451 #ifndef FIPS_MODULE
1452     const EVP_PKEY_ASN1_METHOD *ameth = NULL;
1453     ENGINE **eptr = (e == NULL) ? &e :  NULL;
1454 #endif
1455
1456     /*
1457      * The setups can't set both legacy and provider side methods.
1458      * It is forbidden
1459      */
1460     if (!ossl_assert(type == EVP_PKEY_NONE || keymgmt == NULL)
1461         || !ossl_assert(e == NULL || keymgmt == NULL)) {
1462         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
1463         return 0;
1464     }
1465
1466     if (pkey != NULL) {
1467         int free_it = 0;
1468
1469 #ifndef FIPS_MODULE
1470         free_it = free_it || pkey->pkey.ptr != NULL;
1471 #endif
1472         free_it = free_it || pkey->keydata != NULL;
1473         if (free_it)
1474             evp_pkey_free_it(pkey);
1475 #ifndef FIPS_MODULE
1476         /*
1477          * If key type matches and a method exists then this lookup has
1478          * succeeded once so just indicate success.
1479          */
1480         if (pkey->type != EVP_PKEY_NONE
1481             && type == pkey->save_type
1482             && pkey->ameth != NULL)
1483             return 1;
1484 # ifndef OPENSSL_NO_ENGINE
1485         /* If we have ENGINEs release them */
1486         ENGINE_finish(pkey->engine);
1487         pkey->engine = NULL;
1488         ENGINE_finish(pkey->pmeth_engine);
1489         pkey->pmeth_engine = NULL;
1490 # endif
1491 #endif
1492     }
1493 #ifndef FIPS_MODULE
1494     if (str != NULL)
1495         ameth = EVP_PKEY_asn1_find_str(eptr, str, len);
1496     else if (type != EVP_PKEY_NONE)
1497         ameth = EVP_PKEY_asn1_find(eptr, type);
1498 # ifndef OPENSSL_NO_ENGINE
1499     if (pkey == NULL && eptr != NULL)
1500         ENGINE_finish(e);
1501 # endif
1502 #endif
1503
1504
1505     {
1506         int check = 1;
1507
1508 #ifndef FIPS_MODULE
1509         check = check && ameth == NULL;
1510 #endif
1511         check = check && keymgmt == NULL;
1512         if (check) {
1513             EVPerr(EVP_F_PKEY_SET_TYPE, EVP_R_UNSUPPORTED_ALGORITHM);
1514             return 0;
1515         }
1516     }
1517     if (pkey != NULL) {
1518         if (keymgmt != NULL && !EVP_KEYMGMT_up_ref(keymgmt)) {
1519             ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
1520             return 0;
1521         }
1522
1523         pkey->keymgmt = keymgmt;
1524
1525         pkey->save_type = type;
1526         pkey->type = type;
1527
1528 #ifndef FIPS_MODULE
1529         /*
1530          * If the internal "origin" key is provider side, don't save |ameth|.
1531          * The main reason is that |ameth| is one factor to detect that the
1532          * internal "origin" key is a legacy one.
1533          */
1534         if (keymgmt == NULL)
1535             pkey->ameth = ameth;
1536         pkey->engine = e;
1537
1538         /*
1539          * The EVP_PKEY_ASN1_METHOD |pkey_id| retains its legacy key purpose
1540          * for any key type that has a legacy implementation, regardless of
1541          * if the internal key is a legacy or a provider side one.  When
1542          * there is no legacy implementation for the key, the type becomes
1543          * EVP_PKEY_KEYMGMT, which indicates that one should be cautious
1544          * with functions that expect legacy internal keys.
1545          */
1546         if (ameth != NULL)
1547             pkey->type = ameth->pkey_id;
1548         else
1549             pkey->type = EVP_PKEY_KEYMGMT;
1550 #endif
1551     }
1552     return 1;
1553 }
1554
1555 #ifndef FIPS_MODULE
1556 static void find_ameth(const char *name, void *data)
1557 {
1558     const char **str = data;
1559
1560     /*
1561      * The error messages from pkey_set_type() are uninteresting here,
1562      * and misleading.
1563      */
1564     ERR_set_mark();
1565
1566     if (pkey_set_type(NULL, NULL, EVP_PKEY_NONE, name, strlen(name),
1567                       NULL)) {
1568         if (str[0] == NULL)
1569             str[0] = name;
1570         else if (str[1] == NULL)
1571             str[1] = name;
1572     }
1573
1574     ERR_pop_to_mark();
1575 }
1576 #endif
1577
1578 int EVP_PKEY_set_type_by_keymgmt(EVP_PKEY *pkey, EVP_KEYMGMT *keymgmt)
1579 {
1580 #ifndef FIPS_MODULE
1581 # define EVP_PKEY_TYPE_STR str[0]
1582 # define EVP_PKEY_TYPE_STRLEN (str[0] == NULL ? -1 : (int)strlen(str[0]))
1583     /*
1584      * Find at most two strings that have an associated EVP_PKEY_ASN1_METHOD
1585      * Ideally, only one should be found.  If two (or more) are found, the
1586      * match is ambiguous.  This should never happen, but...
1587      */
1588     const char *str[2] = { NULL, NULL };
1589
1590     EVP_KEYMGMT_names_do_all(keymgmt, find_ameth, &str);
1591     if (str[1] != NULL) {
1592         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
1593         return 0;
1594     }
1595 #else
1596 # define EVP_PKEY_TYPE_STR NULL
1597 # define EVP_PKEY_TYPE_STRLEN -1
1598 #endif
1599     return pkey_set_type(pkey, NULL, EVP_PKEY_NONE,
1600                          EVP_PKEY_TYPE_STR, EVP_PKEY_TYPE_STRLEN,
1601                          keymgmt);
1602
1603 #undef EVP_PKEY_TYPE_STR
1604 #undef EVP_PKEY_TYPE_STRLEN
1605 }
1606
1607 int EVP_PKEY_up_ref(EVP_PKEY *pkey)
1608 {
1609     int i;
1610
1611     if (CRYPTO_UP_REF(&pkey->references, &i, pkey->lock) <= 0)
1612         return 0;
1613
1614     REF_PRINT_COUNT("EVP_PKEY", pkey);
1615     REF_ASSERT_ISNT(i < 2);
1616     return ((i > 1) ? 1 : 0);
1617 }
1618
1619 #ifndef FIPS_MODULE
1620 void evp_pkey_free_legacy(EVP_PKEY *x)
1621 {
1622     if (x->ameth != NULL) {
1623         if (x->ameth->pkey_free != NULL)
1624             x->ameth->pkey_free(x);
1625         x->pkey.ptr = NULL;
1626     }
1627 # ifndef OPENSSL_NO_ENGINE
1628     ENGINE_finish(x->engine);
1629     x->engine = NULL;
1630     ENGINE_finish(x->pmeth_engine);
1631     x->pmeth_engine = NULL;
1632 # endif
1633 }
1634 #endif  /* FIPS_MODULE */
1635
1636 static void evp_pkey_free_it(EVP_PKEY *x)
1637 {
1638     /* internal function; x is never NULL */
1639
1640     evp_keymgmt_util_clear_operation_cache(x);
1641 #ifndef FIPS_MODULE
1642     evp_pkey_free_legacy(x);
1643 #endif
1644
1645     if (x->keymgmt != NULL) {
1646         evp_keymgmt_freedata(x->keymgmt, x->keydata);
1647         EVP_KEYMGMT_free(x->keymgmt);
1648         x->keymgmt = NULL;
1649         x->keydata = NULL;
1650     }
1651     x->type = EVP_PKEY_NONE;
1652 }
1653
1654 void EVP_PKEY_free(EVP_PKEY *x)
1655 {
1656     int i;
1657
1658     if (x == NULL)
1659         return;
1660
1661     CRYPTO_DOWN_REF(&x->references, &i, x->lock);
1662     REF_PRINT_COUNT("EVP_PKEY", x);
1663     if (i > 0)
1664         return;
1665     REF_ASSERT_ISNT(i < 0);
1666     evp_pkey_free_it(x);
1667 #ifndef FIPS_MODULE
1668     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EVP_PKEY, x, &x->ex_data);
1669 #endif
1670     CRYPTO_THREAD_lock_free(x->lock);
1671 #ifndef FIPS_MODULE
1672     sk_X509_ATTRIBUTE_pop_free(x->attributes, X509_ATTRIBUTE_free);
1673 #endif
1674     OPENSSL_free(x);
1675 }
1676
1677 int EVP_PKEY_size(const EVP_PKEY *pkey)
1678 {
1679     int size = 0;
1680
1681     if (pkey != NULL) {
1682         size = pkey->cache.size;
1683 #ifndef FIPS_MODULE
1684         if (pkey->ameth != NULL && pkey->ameth->pkey_size != NULL)
1685             size = pkey->ameth->pkey_size(pkey);
1686 #endif
1687     }
1688     return size;
1689 }
1690
1691 void *evp_pkey_export_to_provider(EVP_PKEY *pk, OSSL_LIB_CTX *libctx,
1692                                   EVP_KEYMGMT **keymgmt,
1693                                   const char *propquery)
1694 {
1695     EVP_KEYMGMT *allocated_keymgmt = NULL;
1696     EVP_KEYMGMT *tmp_keymgmt = NULL;
1697     void *keydata = NULL;
1698     int check;
1699
1700     if (pk == NULL)
1701         return NULL;
1702
1703     /* No key data => nothing to export */
1704     check = 1;
1705 #ifndef FIPS_MODULE
1706     check = check && pk->pkey.ptr == NULL;
1707 #endif
1708     check = check && pk->keydata == NULL;
1709     if (check)
1710         return NULL;
1711
1712 #ifndef FIPS_MODULE
1713     if (pk->pkey.ptr != NULL) {
1714         /*
1715          * If the legacy key doesn't have an dirty counter or export function,
1716          * give up
1717          */
1718         if (pk->ameth->dirty_cnt == NULL || pk->ameth->export_to == NULL)
1719             return NULL;
1720     }
1721 #endif
1722
1723     if (keymgmt != NULL) {
1724         tmp_keymgmt = *keymgmt;
1725         *keymgmt = NULL;
1726     }
1727
1728     /*
1729      * If no keymgmt was given or found, get a default keymgmt.  We do so by
1730      * letting EVP_PKEY_CTX_new_from_pkey() do it for us, then we steal it.
1731      */
1732     if (tmp_keymgmt == NULL) {
1733         EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pk, propquery);
1734
1735         tmp_keymgmt = ctx->keymgmt;
1736         ctx->keymgmt = NULL;
1737         EVP_PKEY_CTX_free(ctx);
1738     }
1739
1740     /* If there's still no keymgmt to be had, give up */
1741     if (tmp_keymgmt == NULL)
1742         goto end;
1743
1744 #ifndef FIPS_MODULE
1745     if (pk->pkey.ptr != NULL) {
1746         size_t i = 0;
1747
1748         /*
1749          * If the legacy "origin" hasn't changed since last time, we try
1750          * to find our keymgmt in the operation cache.  If it has changed,
1751          * |i| remains zero, and we will clear the cache further down.
1752          */
1753         if (pk->ameth->dirty_cnt(pk) == pk->dirty_cnt_copy) {
1754             i = evp_keymgmt_util_find_operation_cache_index(pk, tmp_keymgmt);
1755
1756             /*
1757              * If |tmp_keymgmt| is present in the operation cache, it means
1758              * that export doesn't need to be redone.  In that case, we take
1759              * token copies of the cached pointers, to have token success
1760              * values to return.
1761              */
1762             if (i < OSSL_NELEM(pk->operation_cache)
1763                 && pk->operation_cache[i].keymgmt != NULL) {
1764                 keydata = pk->operation_cache[i].keydata;
1765                 goto end;
1766             }
1767         }
1768
1769         /*
1770          * TODO(3.0) Right now, we assume we have ample space.  We will have
1771          * to think about a cache aging scheme, though, if |i| indexes outside
1772          * the array.
1773          */
1774         if (!ossl_assert(i < OSSL_NELEM(pk->operation_cache)))
1775             goto end;
1776
1777         /* Make sure that the keymgmt key type matches the legacy NID */
1778         if (!ossl_assert(EVP_KEYMGMT_is_a(tmp_keymgmt, OBJ_nid2sn(pk->type))))
1779             goto end;
1780
1781         if ((keydata = evp_keymgmt_newdata(tmp_keymgmt)) == NULL)
1782             goto end;
1783
1784         if (!pk->ameth->export_to(pk, keydata, tmp_keymgmt, libctx, propquery)) {
1785             evp_keymgmt_freedata(tmp_keymgmt, keydata);
1786             keydata = NULL;
1787             goto end;
1788         }
1789
1790         /*
1791          * If the dirty counter changed since last time, then clear the
1792          * operation cache.  In that case, we know that |i| is zero.  Just
1793          * in case this is a re-export, we increment then decrement the
1794          * keymgmt reference counter.
1795          */
1796         if (!EVP_KEYMGMT_up_ref(tmp_keymgmt)) { /* refcnt++ */
1797             evp_keymgmt_freedata(tmp_keymgmt, keydata);
1798             keydata = NULL;
1799             goto end;
1800         }
1801         if (pk->ameth->dirty_cnt(pk) != pk->dirty_cnt_copy)
1802             evp_keymgmt_util_clear_operation_cache(pk);
1803         EVP_KEYMGMT_free(tmp_keymgmt); /* refcnt-- */
1804
1805         /* Add the new export to the operation cache */
1806         if (!evp_keymgmt_util_cache_keydata(pk, i, tmp_keymgmt, keydata)) {
1807             evp_keymgmt_freedata(tmp_keymgmt, keydata);
1808             keydata = NULL;
1809             goto end;
1810         }
1811
1812         /* Synchronize the dirty count */
1813         pk->dirty_cnt_copy = pk->ameth->dirty_cnt(pk);
1814         goto end;
1815     }
1816 #endif  /* FIPS_MODULE */
1817
1818     keydata = evp_keymgmt_util_export_to_provider(pk, tmp_keymgmt);
1819
1820  end:
1821     /*
1822      * If nothing was exported, |tmp_keymgmt| might point at a freed
1823      * EVP_KEYMGMT, so we clear it to be safe.  It shouldn't be useful for
1824      * the caller either way in that case.
1825      */
1826     if (keydata == NULL)
1827         tmp_keymgmt = NULL;
1828
1829     if (keymgmt != NULL)
1830         *keymgmt = tmp_keymgmt;
1831
1832     EVP_KEYMGMT_free(allocated_keymgmt);
1833     return keydata;
1834 }
1835
1836 #ifndef FIPS_MODULE
1837 int evp_pkey_copy_downgraded(EVP_PKEY **dest, const EVP_PKEY *src)
1838 {
1839     if (!ossl_assert(dest != NULL))
1840         return 0;
1841
1842     if (evp_pkey_is_assigned(src) && evp_pkey_is_provided(src)) {
1843         EVP_KEYMGMT *keymgmt = src->keymgmt;
1844         void *keydata = src->keydata;
1845         int type = src->type;
1846         const char *keytype = NULL;
1847
1848         keytype = evp_first_name(EVP_KEYMGMT_provider(keymgmt),
1849                                  keymgmt->name_id);
1850
1851         /*
1852          * If the type is EVP_PKEY_NONE, then we have a problem somewhere
1853          * else in our code.  If it's not one of the well known EVP_PKEY_xxx
1854          * values, it should at least be EVP_PKEY_KEYMGMT at this point.
1855          * TODO(3.0) remove this check when we're confident that the rest
1856          * of the code treats this correctly.
1857          */
1858         if (!ossl_assert(type != EVP_PKEY_NONE)) {
1859             ERR_raise_data(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR,
1860                            "keymgmt key type = %s but legacy type = EVP_PKEY_NONE",
1861                            keytype);
1862             return 0;
1863         }
1864
1865         /* Prefer the legacy key type name for error reporting */
1866         if (type != EVP_PKEY_KEYMGMT)
1867             keytype = OBJ_nid2sn(type);
1868
1869         /* Make sure we have a clean slate to copy into */
1870         if (*dest == NULL)
1871             *dest = EVP_PKEY_new();
1872         else
1873             evp_pkey_free_it(*dest);
1874
1875         if (EVP_PKEY_set_type(*dest, type)) {
1876             /* If the key is typed but empty, we're done */
1877             if (keydata == NULL)
1878                 return 1;
1879
1880             if ((*dest)->ameth->import_from == NULL) {
1881                 ERR_raise_data(ERR_LIB_EVP, EVP_R_NO_IMPORT_FUNCTION,
1882                                "key type = %s", keytype);
1883             } else {
1884                 /*
1885                  * We perform the export in the same libctx as the keymgmt
1886                  * that we are using.
1887                  */
1888                 OSSL_LIB_CTX *libctx =
1889                     ossl_provider_libctx(keymgmt->prov);
1890                 EVP_PKEY_CTX *pctx =
1891                     EVP_PKEY_CTX_new_from_pkey(libctx, *dest, NULL);
1892
1893                 if (pctx == NULL)
1894                     ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
1895
1896                 if (pctx != NULL
1897                     && evp_keymgmt_export(keymgmt, keydata,
1898                                           OSSL_KEYMGMT_SELECT_ALL,
1899                                           (*dest)->ameth->import_from,
1900                                           pctx)) {
1901                     /* Synchronize the dirty count */
1902                     (*dest)->dirty_cnt_copy = (*dest)->ameth->dirty_cnt(*dest);
1903
1904                     EVP_PKEY_CTX_free(pctx);
1905                     return 1;
1906                 }
1907                 EVP_PKEY_CTX_free(pctx);
1908             }
1909
1910             ERR_raise_data(ERR_LIB_EVP, EVP_R_KEYMGMT_EXPORT_FAILURE,
1911                            "key type = %s", keytype);
1912         }
1913     }
1914
1915     return 0;
1916 }
1917
1918 int evp_pkey_downgrade(EVP_PKEY *pk)
1919 {
1920     EVP_PKEY tmp_copy;              /* Stack allocated! */
1921     CRYPTO_RWLOCK *tmp_lock = NULL; /* Temporary lock */
1922     int rv = 0;
1923
1924     if (!ossl_assert(pk != NULL))
1925         return 0;
1926
1927     /*
1928      * Throughout this whole function, we must ensure that we lock / unlock
1929      * the exact same lock.  Note that we do pass it around a bit.
1930      */
1931     if (!CRYPTO_THREAD_write_lock(pk->lock))
1932         return 0;
1933
1934     /* If this isn't an assigned provider side key, we're done */
1935     if (!evp_pkey_is_assigned(pk) || !evp_pkey_is_provided(pk)) {
1936         rv = 1;
1937         goto end;
1938     }
1939
1940     /*
1941      * To be able to downgrade, we steal the contents of |pk|, then reset
1942      * it, and finally try to make it a downgraded copy.  If any of that
1943      * fails, we restore the copied contents into |pk|.
1944      */
1945     tmp_copy = *pk;              /* |tmp_copy| now owns THE lock */
1946
1947     if (evp_pkey_reset_unlocked(pk)
1948         && evp_pkey_copy_downgraded(&pk, &tmp_copy)) {
1949         /* Grab the temporary lock to avoid lock leak */
1950         tmp_lock = pk->lock;
1951
1952         /* Restore the common attributes, then empty |tmp_copy| */
1953         pk->references = tmp_copy.references;
1954         pk->lock = tmp_copy.lock; /* |pk| now owns THE lock */
1955         pk->attributes = tmp_copy.attributes;
1956         pk->save_parameters = tmp_copy.save_parameters;
1957         pk->ex_data = tmp_copy.ex_data;
1958
1959         /* Ensure that stuff we've copied won't be freed */
1960         tmp_copy.lock = NULL;
1961         tmp_copy.attributes = NULL;
1962         memset(&tmp_copy.ex_data, 0, sizeof(tmp_copy.ex_data));
1963
1964         /*
1965          * Save the provider side data in the operation cache, so they'll
1966          * find it again.  |pk| is new, so it's safe to assume slot zero
1967          * is free.
1968          * Note that evp_keymgmt_util_cache_keydata() increments keymgmt's
1969          * reference count, so we need to decrement it, or there will be a
1970          * leak.
1971          */
1972         evp_keymgmt_util_cache_keydata(pk, 0, tmp_copy.keymgmt,
1973                                        tmp_copy.keydata);
1974         EVP_KEYMGMT_free(tmp_copy.keymgmt);
1975
1976         /*
1977          * Clear keymgmt and keydata from |tmp_copy|, or they'll get
1978          * inadvertently freed.
1979          */
1980         tmp_copy.keymgmt = NULL;
1981         tmp_copy.keydata = NULL;
1982
1983         evp_pkey_free_it(&tmp_copy);
1984         rv = 1;
1985     } else {
1986         /* Grab the temporary lock to avoid lock leak */
1987         tmp_lock = pk->lock;
1988
1989         /* Restore the original key */
1990         *pk = tmp_copy;          /* |pk| now owns THE lock */
1991     }
1992
1993     /* Free the temporary lock.  It should never be NULL */
1994     CRYPTO_THREAD_lock_free(tmp_lock);
1995
1996  end:
1997     if (!CRYPTO_THREAD_unlock(pk->lock))
1998         return 0;
1999     return rv;
2000 }
2001 #endif  /* FIPS_MODULE */
2002
2003 const OSSL_PARAM *EVP_PKEY_gettable_params(EVP_PKEY *pkey)
2004 {
2005     if (pkey == NULL
2006         || pkey->keymgmt == NULL
2007         || pkey->keydata == NULL)
2008         return 0;
2009     return EVP_KEYMGMT_gettable_params(pkey->keymgmt);
2010 }
2011
2012 int EVP_PKEY_get_bn_param(EVP_PKEY *pkey, const char *key_name, BIGNUM **bn)
2013 {
2014     int ret = 0;
2015     OSSL_PARAM params[2];
2016     unsigned char buffer[2048];
2017     unsigned char *buf = NULL;
2018     size_t buf_sz = 0;
2019
2020     if (pkey == NULL
2021         || pkey->keymgmt == NULL
2022         || pkey->keydata == NULL
2023         || key_name == NULL
2024         || bn == NULL)
2025         return 0;
2026
2027     memset(buffer, 0, sizeof(buffer));
2028     params[0] = OSSL_PARAM_construct_BN(key_name, buffer, sizeof(buffer));
2029     params[1] = OSSL_PARAM_construct_end();
2030     if (!evp_keymgmt_get_params(pkey->keymgmt, pkey->keydata, params)) {
2031         if (!OSSL_PARAM_modified(params) || params[0].return_size == 0)
2032             return 0;
2033         buf_sz = params[0].return_size;
2034         /*
2035          * If it failed because the buffer was too small then allocate the
2036          * required buffer size and retry.
2037          */
2038         buf = OPENSSL_zalloc(buf_sz);
2039         if (buf == NULL)
2040             return 0;
2041         params[0].data = buf;
2042         params[0].data_size = buf_sz;
2043
2044         if (!evp_keymgmt_get_params(pkey->keymgmt, pkey->keydata, params))
2045             goto err;
2046     }
2047     /* Fail if the param was not found */
2048     if (!OSSL_PARAM_modified(params))
2049         goto err;
2050     ret = OSSL_PARAM_get_BN(params, bn);
2051 err:
2052     OPENSSL_free(buf);
2053     return ret;
2054 }
2055
2056 int EVP_PKEY_get_octet_string_param(EVP_PKEY *pkey, const char *key_name,
2057                                     unsigned char *buf, size_t max_buf_sz,
2058                                     size_t *out_sz)
2059 {
2060     OSSL_PARAM params[2];
2061
2062     if (pkey == NULL
2063         || pkey->keymgmt == NULL
2064         || pkey->keydata == NULL
2065         || key_name == NULL)
2066         return 0;
2067
2068     params[0] = OSSL_PARAM_construct_octet_string(key_name, buf, max_buf_sz);
2069     params[1] = OSSL_PARAM_construct_end();
2070     if (!evp_keymgmt_get_params(pkey->keymgmt, pkey->keydata, params)
2071         || !OSSL_PARAM_modified(params))
2072         return 0;
2073     if (out_sz != NULL)
2074         *out_sz = params[0].return_size;
2075     return 1;
2076 }
2077
2078 int EVP_PKEY_get_utf8_string_param(EVP_PKEY *pkey, const char *key_name,
2079                                     char *str, size_t max_buf_sz,
2080                                     size_t *out_sz)
2081 {
2082     OSSL_PARAM params[2];
2083
2084     if (pkey == NULL
2085         || pkey->keymgmt == NULL
2086         || pkey->keydata == NULL
2087         || key_name == NULL)
2088         return 0;
2089
2090     params[0] = OSSL_PARAM_construct_utf8_string(key_name, str, max_buf_sz);
2091     params[1] = OSSL_PARAM_construct_end();
2092     if (!evp_keymgmt_get_params(pkey->keymgmt, pkey->keydata, params)
2093         || !OSSL_PARAM_modified(params))
2094         return 0;
2095     if (out_sz != NULL)
2096         *out_sz = params[0].return_size;
2097     return 1;
2098 }
2099
2100 int EVP_PKEY_get_int_param(EVP_PKEY *pkey, const char *key_name, int *out)
2101 {
2102     OSSL_PARAM params[2];
2103
2104     if (pkey == NULL
2105         || pkey->keymgmt == NULL
2106         || pkey->keydata == NULL
2107         || key_name == NULL)
2108         return 0;
2109
2110     params[0] = OSSL_PARAM_construct_int(key_name, out);
2111     params[1] = OSSL_PARAM_construct_end();
2112     if (!evp_keymgmt_get_params(pkey->keymgmt, pkey->keydata, params)
2113         || !OSSL_PARAM_modified(params))
2114         return 0;
2115     return 1;
2116 }
2117
2118 int EVP_PKEY_get_size_t_param(EVP_PKEY *pkey, const char *key_name, size_t *out)
2119 {
2120     OSSL_PARAM params[2];
2121
2122     if (pkey == NULL
2123         || pkey->keymgmt == NULL
2124         || pkey->keydata == NULL
2125         || key_name == NULL)
2126         return 0;
2127
2128     params[0] = OSSL_PARAM_construct_size_t(key_name, out);
2129     params[1] = OSSL_PARAM_construct_end();
2130     if (!evp_keymgmt_get_params(pkey->keymgmt, pkey->keydata, params)
2131         || !OSSL_PARAM_modified(params))
2132         return 0;
2133     return 1;
2134 }