RSA: Do not set NULL OAEP labels
[openssl.git] / crypto / rsa / rsa_ameth.c
1 /*
2  * Copyright 2006-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  * RSA 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 <openssl/asn1t.h>
19 #include <openssl/x509.h>
20 #include <openssl/bn.h>
21 #include <openssl/cms.h>
22 #include <openssl/core_names.h>
23 #include <openssl/param_build.h>
24 #include "crypto/asn1.h"
25 #include "crypto/evp.h"
26 #include "crypto/rsa.h"
27 #include "rsa_local.h"
28
29 #ifndef OPENSSL_NO_CMS
30 static int rsa_cms_sign(CMS_SignerInfo *si);
31 static int rsa_cms_verify(CMS_SignerInfo *si);
32 static int rsa_cms_decrypt(CMS_RecipientInfo *ri);
33 static int rsa_cms_encrypt(CMS_RecipientInfo *ri);
34 #endif
35
36 static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg);
37
38 /* Set any parameters associated with pkey */
39 static int rsa_param_encode(const EVP_PKEY *pkey,
40                             ASN1_STRING **pstr, int *pstrtype)
41 {
42     const RSA *rsa = pkey->pkey.rsa;
43
44     *pstr = NULL;
45     /* If RSA it's just NULL type */
46     if (RSA_test_flags(rsa, RSA_FLAG_TYPE_MASK) != RSA_FLAG_TYPE_RSASSAPSS) {
47         *pstrtype = V_ASN1_NULL;
48         return 1;
49     }
50     /* If no PSS parameters we omit parameters entirely */
51     if (rsa->pss == NULL) {
52         *pstrtype = V_ASN1_UNDEF;
53         return 1;
54     }
55     /* Encode PSS parameters */
56     if (ASN1_item_pack(rsa->pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), pstr) == NULL)
57         return 0;
58
59     *pstrtype = V_ASN1_SEQUENCE;
60     return 1;
61 }
62 /* Decode any parameters and set them in RSA structure */
63 static int rsa_param_decode(RSA *rsa, const X509_ALGOR *alg)
64 {
65     const ASN1_OBJECT *algoid;
66     const void *algp;
67     int algptype;
68
69     X509_ALGOR_get0(&algoid, &algptype, &algp, alg);
70     if (OBJ_obj2nid(algoid) != EVP_PKEY_RSA_PSS)
71         return 1;
72     if (algptype == V_ASN1_UNDEF)
73         return 1;
74     if (algptype != V_ASN1_SEQUENCE) {
75         RSAerr(RSA_F_RSA_PARAM_DECODE, RSA_R_INVALID_PSS_PARAMETERS);
76         return 0;
77     }
78     rsa->pss = rsa_pss_decode(alg);
79     if (rsa->pss == NULL)
80         return 0;
81     return 1;
82 }
83
84 static int rsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
85 {
86     unsigned char *penc = NULL;
87     int penclen;
88     ASN1_STRING *str;
89     int strtype;
90
91     if (!rsa_param_encode(pkey, &str, &strtype))
92         return 0;
93     penclen = i2d_RSAPublicKey(pkey->pkey.rsa, &penc);
94     if (penclen <= 0)
95         return 0;
96     if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(pkey->ameth->pkey_id),
97                                strtype, str, penc, penclen))
98         return 1;
99
100     OPENSSL_free(penc);
101     return 0;
102 }
103
104 static int rsa_pub_decode(EVP_PKEY *pkey, const X509_PUBKEY *pubkey)
105 {
106     const unsigned char *p;
107     int pklen;
108     X509_ALGOR *alg;
109     RSA *rsa = NULL;
110
111     if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &alg, pubkey))
112         return 0;
113     if ((rsa = d2i_RSAPublicKey(NULL, &p, pklen)) == NULL) {
114         RSAerr(RSA_F_RSA_PUB_DECODE, ERR_R_RSA_LIB);
115         return 0;
116     }
117     if (!rsa_param_decode(rsa, alg)) {
118         RSA_free(rsa);
119         return 0;
120     }
121     if (!EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, rsa)) {
122         RSA_free(rsa);
123         return 0;
124     }
125     return 1;
126 }
127
128 static int rsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
129 {
130     if (BN_cmp(b->pkey.rsa->n, a->pkey.rsa->n) != 0
131         || BN_cmp(b->pkey.rsa->e, a->pkey.rsa->e) != 0)
132         return 0;
133     return 1;
134 }
135
136 static int old_rsa_priv_decode(EVP_PKEY *pkey,
137                                const unsigned char **pder, int derlen)
138 {
139     RSA *rsa;
140
141     if ((rsa = d2i_RSAPrivateKey(NULL, pder, derlen)) == NULL) {
142         RSAerr(RSA_F_OLD_RSA_PRIV_DECODE, ERR_R_RSA_LIB);
143         return 0;
144     }
145     EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, rsa);
146     return 1;
147 }
148
149 static int old_rsa_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
150 {
151     return i2d_RSAPrivateKey(pkey->pkey.rsa, pder);
152 }
153
154 static int rsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
155 {
156     unsigned char *rk = NULL;
157     int rklen;
158     ASN1_STRING *str;
159     int strtype;
160
161     if (!rsa_param_encode(pkey, &str, &strtype))
162         return 0;
163     rklen = i2d_RSAPrivateKey(pkey->pkey.rsa, &rk);
164
165     if (rklen <= 0) {
166         RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
167         ASN1_STRING_free(str);
168         return 0;
169     }
170
171     if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(pkey->ameth->pkey_id), 0,
172                          strtype, str, rk, rklen)) {
173         RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
174         ASN1_STRING_free(str);
175         return 0;
176     }
177
178     return 1;
179 }
180
181 static int rsa_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8)
182 {
183     const unsigned char *p;
184     RSA *rsa;
185     int pklen;
186     const X509_ALGOR *alg;
187
188     if (!PKCS8_pkey_get0(NULL, &p, &pklen, &alg, p8))
189         return 0;
190     rsa = d2i_RSAPrivateKey(NULL, &p, pklen);
191     if (rsa == NULL) {
192         RSAerr(RSA_F_RSA_PRIV_DECODE, ERR_R_RSA_LIB);
193         return 0;
194     }
195     if (!rsa_param_decode(rsa, alg)) {
196         RSA_free(rsa);
197         return 0;
198     }
199
200     RSA_clear_flags(rsa, RSA_FLAG_TYPE_MASK);
201     switch (pkey->ameth->pkey_id) {
202     case EVP_PKEY_RSA:
203         RSA_set_flags(rsa, RSA_FLAG_TYPE_RSA);
204         break;
205     case EVP_PKEY_RSA_PSS:
206         RSA_set_flags(rsa, RSA_FLAG_TYPE_RSASSAPSS);
207         break;
208     default:
209         /* Leave the type bits zero */
210         break;
211     }
212
213     EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, rsa);
214     return 1;
215 }
216
217 static int int_rsa_size(const EVP_PKEY *pkey)
218 {
219     return RSA_size(pkey->pkey.rsa);
220 }
221
222 static int rsa_bits(const EVP_PKEY *pkey)
223 {
224     return BN_num_bits(pkey->pkey.rsa->n);
225 }
226
227 static int rsa_security_bits(const EVP_PKEY *pkey)
228 {
229     return RSA_security_bits(pkey->pkey.rsa);
230 }
231
232 static void int_rsa_free(EVP_PKEY *pkey)
233 {
234     RSA_free(pkey->pkey.rsa);
235 }
236
237 static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
238 {
239     if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
240         return NULL;
241     return ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(X509_ALGOR),
242                                      alg->parameter);
243 }
244
245 static int rsa_pss_param_print(BIO *bp, int pss_key, RSA_PSS_PARAMS *pss,
246                                int indent)
247 {
248     int rv = 0;
249     X509_ALGOR *maskHash = NULL;
250
251     if (!BIO_indent(bp, indent, 128))
252         goto err;
253     if (pss_key) {
254         if (pss == NULL) {
255             if (BIO_puts(bp, "No PSS parameter restrictions\n") <= 0)
256                 return 0;
257             return 1;
258         } else {
259             if (BIO_puts(bp, "PSS parameter restrictions:") <= 0)
260                 return 0;
261         }
262     } else if (pss == NULL) {
263         if (BIO_puts(bp,"(INVALID PSS PARAMETERS)\n") <= 0)
264             return 0;
265         return 1;
266     }
267     if (BIO_puts(bp, "\n") <= 0)
268         goto err;
269     if (pss_key)
270         indent += 2;
271     if (!BIO_indent(bp, indent, 128))
272         goto err;
273     if (BIO_puts(bp, "Hash Algorithm: ") <= 0)
274         goto err;
275
276     if (pss->hashAlgorithm) {
277         if (i2a_ASN1_OBJECT(bp, pss->hashAlgorithm->algorithm) <= 0)
278             goto err;
279     } else if (BIO_puts(bp, "sha1 (default)") <= 0) {
280         goto err;
281     }
282
283     if (BIO_puts(bp, "\n") <= 0)
284         goto err;
285
286     if (!BIO_indent(bp, indent, 128))
287         goto err;
288
289     if (BIO_puts(bp, "Mask Algorithm: ") <= 0)
290         goto err;
291     if (pss->maskGenAlgorithm) {
292         if (i2a_ASN1_OBJECT(bp, pss->maskGenAlgorithm->algorithm) <= 0)
293             goto err;
294         if (BIO_puts(bp, " with ") <= 0)
295             goto err;
296         maskHash = rsa_mgf1_decode(pss->maskGenAlgorithm);
297         if (maskHash != NULL) {
298             if (i2a_ASN1_OBJECT(bp, maskHash->algorithm) <= 0)
299                 goto err;
300         } else if (BIO_puts(bp, "INVALID") <= 0) {
301             goto err;
302         }
303     } else if (BIO_puts(bp, "mgf1 with sha1 (default)") <= 0) {
304         goto err;
305     }
306     BIO_puts(bp, "\n");
307
308     if (!BIO_indent(bp, indent, 128))
309         goto err;
310     if (BIO_printf(bp, "%s Salt Length: 0x", pss_key ? "Minimum" : "") <= 0)
311         goto err;
312     if (pss->saltLength) {
313         if (i2a_ASN1_INTEGER(bp, pss->saltLength) <= 0)
314             goto err;
315     } else if (BIO_puts(bp, "14 (default)") <= 0) {
316         goto err;
317     }
318     BIO_puts(bp, "\n");
319
320     if (!BIO_indent(bp, indent, 128))
321         goto err;
322     if (BIO_puts(bp, "Trailer Field: 0x") <= 0)
323         goto err;
324     if (pss->trailerField) {
325         if (i2a_ASN1_INTEGER(bp, pss->trailerField) <= 0)
326             goto err;
327     } else if (BIO_puts(bp, "BC (default)") <= 0) {
328         goto err;
329     }
330     BIO_puts(bp, "\n");
331
332     rv = 1;
333
334  err:
335     X509_ALGOR_free(maskHash);
336     return rv;
337
338 }
339
340 static int pkey_rsa_print(BIO *bp, const EVP_PKEY *pkey, int off, int priv)
341 {
342     const RSA *x = pkey->pkey.rsa;
343     char *str;
344     const char *s;
345     int ret = 0, mod_len = 0, ex_primes;
346
347     if (x->n != NULL)
348         mod_len = BN_num_bits(x->n);
349     ex_primes = sk_RSA_PRIME_INFO_num(x->prime_infos);
350
351     if (!BIO_indent(bp, off, 128))
352         goto err;
353
354     if (BIO_printf(bp, "%s ", pkey_is_pss(pkey) ?  "RSA-PSS" : "RSA") <= 0)
355         goto err;
356
357     if (priv && x->d) {
358         if (BIO_printf(bp, "Private-Key: (%d bit, %d primes)\n",
359                        mod_len, ex_primes <= 0 ? 2 : ex_primes + 2) <= 0)
360             goto err;
361         str = "modulus:";
362         s = "publicExponent:";
363     } else {
364         if (BIO_printf(bp, "Public-Key: (%d bit)\n", mod_len) <= 0)
365             goto err;
366         str = "Modulus:";
367         s = "Exponent:";
368     }
369     if (!ASN1_bn_print(bp, str, x->n, NULL, off))
370         goto err;
371     if (!ASN1_bn_print(bp, s, x->e, NULL, off))
372         goto err;
373     if (priv) {
374         int i;
375
376         if (!ASN1_bn_print(bp, "privateExponent:", x->d, NULL, off))
377             goto err;
378         if (!ASN1_bn_print(bp, "prime1:", x->p, NULL, off))
379             goto err;
380         if (!ASN1_bn_print(bp, "prime2:", x->q, NULL, off))
381             goto err;
382         if (!ASN1_bn_print(bp, "exponent1:", x->dmp1, NULL, off))
383             goto err;
384         if (!ASN1_bn_print(bp, "exponent2:", x->dmq1, NULL, off))
385             goto err;
386         if (!ASN1_bn_print(bp, "coefficient:", x->iqmp, NULL, off))
387             goto err;
388         for (i = 0; i < sk_RSA_PRIME_INFO_num(x->prime_infos); i++) {
389             /* print multi-prime info */
390             BIGNUM *bn = NULL;
391             RSA_PRIME_INFO *pinfo;
392             int j;
393
394             pinfo = sk_RSA_PRIME_INFO_value(x->prime_infos, i);
395             for (j = 0; j < 3; j++) {
396                 if (!BIO_indent(bp, off, 128))
397                     goto err;
398                 switch (j) {
399                 case 0:
400                     if (BIO_printf(bp, "prime%d:", i + 3) <= 0)
401                         goto err;
402                     bn = pinfo->r;
403                     break;
404                 case 1:
405                     if (BIO_printf(bp, "exponent%d:", i + 3) <= 0)
406                         goto err;
407                     bn = pinfo->d;
408                     break;
409                 case 2:
410                     if (BIO_printf(bp, "coefficient%d:", i + 3) <= 0)
411                         goto err;
412                     bn = pinfo->t;
413                     break;
414                 default:
415                     break;
416                 }
417                 if (!ASN1_bn_print(bp, "", bn, NULL, off))
418                     goto err;
419             }
420         }
421     }
422     if (pkey_is_pss(pkey) && !rsa_pss_param_print(bp, 1, x->pss, off))
423         goto err;
424     ret = 1;
425  err:
426     return ret;
427 }
428
429 static int rsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
430                          ASN1_PCTX *ctx)
431 {
432     return pkey_rsa_print(bp, pkey, indent, 0);
433 }
434
435 static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
436                           ASN1_PCTX *ctx)
437 {
438     return pkey_rsa_print(bp, pkey, indent, 1);
439 }
440
441 static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg)
442 {
443     RSA_PSS_PARAMS *pss;
444
445     pss = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(RSA_PSS_PARAMS),
446                                     alg->parameter);
447
448     if (pss == NULL)
449         return NULL;
450
451     if (pss->maskGenAlgorithm != NULL) {
452         pss->maskHash = rsa_mgf1_decode(pss->maskGenAlgorithm);
453         if (pss->maskHash == NULL) {
454             RSA_PSS_PARAMS_free(pss);
455             return NULL;
456         }
457     }
458
459     return pss;
460 }
461
462 static int rsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
463                          const ASN1_STRING *sig, int indent, ASN1_PCTX *pctx)
464 {
465     if (OBJ_obj2nid(sigalg->algorithm) == EVP_PKEY_RSA_PSS) {
466         int rv;
467         RSA_PSS_PARAMS *pss = rsa_pss_decode(sigalg);
468
469         rv = rsa_pss_param_print(bp, 0, pss, indent);
470         RSA_PSS_PARAMS_free(pss);
471         if (!rv)
472             return 0;
473     } else if (BIO_puts(bp, "\n") <= 0) {
474         return 0;
475     }
476     if (sig)
477         return X509_signature_dump(bp, sig, indent);
478     return 1;
479 }
480
481 static int rsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
482 {
483     X509_ALGOR *alg = NULL;
484     const EVP_MD *md;
485     const EVP_MD *mgf1md;
486     int min_saltlen;
487
488     switch (op) {
489
490     case ASN1_PKEY_CTRL_PKCS7_SIGN:
491         if (arg1 == 0)
492             PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, NULL, &alg);
493         break;
494
495     case ASN1_PKEY_CTRL_PKCS7_ENCRYPT:
496         if (pkey_is_pss(pkey))
497             return -2;
498         if (arg1 == 0)
499             PKCS7_RECIP_INFO_get0_alg(arg2, &alg);
500         break;
501 #ifndef OPENSSL_NO_CMS
502     case ASN1_PKEY_CTRL_CMS_SIGN:
503         if (arg1 == 0)
504             return rsa_cms_sign(arg2);
505         else if (arg1 == 1)
506             return rsa_cms_verify(arg2);
507         break;
508
509     case ASN1_PKEY_CTRL_CMS_ENVELOPE:
510         if (pkey_is_pss(pkey))
511             return -2;
512         if (arg1 == 0)
513             return rsa_cms_encrypt(arg2);
514         else if (arg1 == 1)
515             return rsa_cms_decrypt(arg2);
516         break;
517
518     case ASN1_PKEY_CTRL_CMS_RI_TYPE:
519         if (pkey_is_pss(pkey))
520             return -2;
521         *(int *)arg2 = CMS_RECIPINFO_TRANS;
522         return 1;
523 #endif
524
525     case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
526         if (pkey->pkey.rsa->pss != NULL) {
527             if (!rsa_pss_get_param(pkey->pkey.rsa->pss, &md, &mgf1md,
528                                    &min_saltlen)) {
529                 RSAerr(0, ERR_R_INTERNAL_ERROR);
530                 return 0;
531             }
532             *(int *)arg2 = EVP_MD_type(md);
533             /* Return of 2 indicates this MD is mandatory */
534             return 2;
535         }
536         *(int *)arg2 = NID_sha256;
537         return 1;
538
539     default:
540         return -2;
541
542     }
543
544     if (alg)
545         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
546
547     return 1;
548
549 }
550
551 /* allocate and set algorithm ID from EVP_MD, default SHA1 */
552 static int rsa_md_to_algor(X509_ALGOR **palg, const EVP_MD *md)
553 {
554     if (md == NULL || EVP_MD_type(md) == NID_sha1)
555         return 1;
556     *palg = X509_ALGOR_new();
557     if (*palg == NULL)
558         return 0;
559     X509_ALGOR_set_md(*palg, md);
560     return 1;
561 }
562
563 /* Allocate and set MGF1 algorithm ID from EVP_MD */
564 static int rsa_md_to_mgf1(X509_ALGOR **palg, const EVP_MD *mgf1md)
565 {
566     X509_ALGOR *algtmp = NULL;
567     ASN1_STRING *stmp = NULL;
568
569     *palg = NULL;
570     if (mgf1md == NULL || EVP_MD_type(mgf1md) == NID_sha1)
571         return 1;
572     /* need to embed algorithm ID inside another */
573     if (!rsa_md_to_algor(&algtmp, mgf1md))
574         goto err;
575     if (ASN1_item_pack(algtmp, ASN1_ITEM_rptr(X509_ALGOR), &stmp) == NULL)
576          goto err;
577     *palg = X509_ALGOR_new();
578     if (*palg == NULL)
579         goto err;
580     X509_ALGOR_set0(*palg, OBJ_nid2obj(NID_mgf1), V_ASN1_SEQUENCE, stmp);
581     stmp = NULL;
582  err:
583     ASN1_STRING_free(stmp);
584     X509_ALGOR_free(algtmp);
585     if (*palg)
586         return 1;
587     return 0;
588 }
589
590 /* convert algorithm ID to EVP_MD, default SHA1 */
591 static const EVP_MD *rsa_algor_to_md(X509_ALGOR *alg)
592 {
593     const EVP_MD *md;
594
595     if (!alg)
596         return EVP_sha1();
597     md = EVP_get_digestbyobj(alg->algorithm);
598     if (md == NULL)
599         RSAerr(RSA_F_RSA_ALGOR_TO_MD, RSA_R_UNKNOWN_DIGEST);
600     return md;
601 }
602
603 /*
604  * Convert EVP_PKEY_CTX in PSS mode into corresponding algorithm parameter,
605  * suitable for setting an AlgorithmIdentifier.
606  */
607
608 static RSA_PSS_PARAMS *rsa_ctx_to_pss(EVP_PKEY_CTX *pkctx)
609 {
610     const EVP_MD *sigmd, *mgf1md;
611     EVP_PKEY *pk = EVP_PKEY_CTX_get0_pkey(pkctx);
612     RSA *rsa = EVP_PKEY_get0_RSA(pk);
613     int saltlen;
614
615     if (EVP_PKEY_CTX_get_signature_md(pkctx, &sigmd) <= 0)
616         return NULL;
617     if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
618         return NULL;
619     if (!EVP_PKEY_CTX_get_rsa_pss_saltlen(pkctx, &saltlen))
620         return NULL;
621     if (saltlen == -1) {
622         saltlen = EVP_MD_size(sigmd);
623     } else if (saltlen == -2 || saltlen == -3) {
624         saltlen = RSA_size(rsa) - EVP_MD_size(sigmd) - 2;
625         if ((EVP_PKEY_bits(pk) & 0x7) == 1)
626             saltlen--;
627         if (saltlen < 0)
628             return NULL;
629     }
630
631     return rsa_pss_params_create(sigmd, mgf1md, saltlen);
632 }
633
634 RSA_PSS_PARAMS *rsa_pss_params_create(const EVP_MD *sigmd,
635                                       const EVP_MD *mgf1md, int saltlen)
636 {
637     RSA_PSS_PARAMS *pss = RSA_PSS_PARAMS_new();
638
639     if (pss == NULL)
640         goto err;
641     if (saltlen != 20) {
642         pss->saltLength = ASN1_INTEGER_new();
643         if (pss->saltLength == NULL)
644             goto err;
645         if (!ASN1_INTEGER_set(pss->saltLength, saltlen))
646             goto err;
647     }
648     if (!rsa_md_to_algor(&pss->hashAlgorithm, sigmd))
649         goto err;
650     if (mgf1md == NULL)
651         mgf1md = sigmd;
652     if (!rsa_md_to_mgf1(&pss->maskGenAlgorithm, mgf1md))
653         goto err;
654     if (!rsa_md_to_algor(&pss->maskHash, mgf1md))
655         goto err;
656     return pss;
657  err:
658     RSA_PSS_PARAMS_free(pss);
659     return NULL;
660 }
661
662 static ASN1_STRING *rsa_ctx_to_pss_string(EVP_PKEY_CTX *pkctx)
663 {
664     RSA_PSS_PARAMS *pss = rsa_ctx_to_pss(pkctx);
665     ASN1_STRING *os;
666
667     if (pss == NULL)
668         return NULL;
669
670     os = ASN1_item_pack(pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), NULL);
671     RSA_PSS_PARAMS_free(pss);
672     return os;
673 }
674
675 /*
676  * From PSS AlgorithmIdentifier set public key parameters. If pkey isn't NULL
677  * then the EVP_MD_CTX is setup and initialised. If it is NULL parameters are
678  * passed to pkctx instead.
679  */
680
681 static int rsa_pss_to_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pkctx,
682                           X509_ALGOR *sigalg, EVP_PKEY *pkey)
683 {
684     int rv = -1;
685     int saltlen;
686     const EVP_MD *mgf1md = NULL, *md = NULL;
687     RSA_PSS_PARAMS *pss;
688
689     /* Sanity check: make sure it is PSS */
690     if (OBJ_obj2nid(sigalg->algorithm) != EVP_PKEY_RSA_PSS) {
691         RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
692         return -1;
693     }
694     /* Decode PSS parameters */
695     pss = rsa_pss_decode(sigalg);
696
697     if (!rsa_pss_get_param(pss, &md, &mgf1md, &saltlen)) {
698         RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_PSS_PARAMETERS);
699         goto err;
700     }
701
702     /* We have all parameters now set up context */
703     if (pkey) {
704         if (!EVP_DigestVerifyInit(ctx, &pkctx, md, NULL, pkey))
705             goto err;
706     } else {
707         const EVP_MD *checkmd;
708         if (EVP_PKEY_CTX_get_signature_md(pkctx, &checkmd) <= 0)
709             goto err;
710         if (EVP_MD_type(md) != EVP_MD_type(checkmd)) {
711             RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_DIGEST_DOES_NOT_MATCH);
712             goto err;
713         }
714     }
715
716     if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_PSS_PADDING) <= 0)
717         goto err;
718
719     if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkctx, saltlen) <= 0)
720         goto err;
721
722     if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
723         goto err;
724     /* Carry on */
725     rv = 1;
726
727  err:
728     RSA_PSS_PARAMS_free(pss);
729     return rv;
730 }
731
732 int rsa_pss_get_param(const RSA_PSS_PARAMS *pss, const EVP_MD **pmd,
733                       const EVP_MD **pmgf1md, int *psaltlen)
734 {
735     if (pss == NULL)
736         return 0;
737     *pmd = rsa_algor_to_md(pss->hashAlgorithm);
738     if (*pmd == NULL)
739         return 0;
740     *pmgf1md = rsa_algor_to_md(pss->maskHash);
741     if (*pmgf1md == NULL)
742         return 0;
743     if (pss->saltLength) {
744         *psaltlen = ASN1_INTEGER_get(pss->saltLength);
745         if (*psaltlen < 0) {
746             RSAerr(RSA_F_RSA_PSS_GET_PARAM, RSA_R_INVALID_SALT_LENGTH);
747             return 0;
748         }
749     } else {
750         *psaltlen = 20;
751     }
752
753     /*
754      * low-level routines support only trailer field 0xbc (value 1) and
755      * PKCS#1 says we should reject any other value anyway.
756      */
757     if (pss->trailerField && ASN1_INTEGER_get(pss->trailerField) != 1) {
758         RSAerr(RSA_F_RSA_PSS_GET_PARAM, RSA_R_INVALID_TRAILER);
759         return 0;
760     }
761
762     return 1;
763 }
764
765 #ifndef OPENSSL_NO_CMS
766 static int rsa_cms_verify(CMS_SignerInfo *si)
767 {
768     int nid, nid2;
769     X509_ALGOR *alg;
770     EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
771
772     CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
773     nid = OBJ_obj2nid(alg->algorithm);
774     if (nid == EVP_PKEY_RSA_PSS)
775         return rsa_pss_to_ctx(NULL, pkctx, alg, NULL);
776     /* Only PSS allowed for PSS keys */
777     if (pkey_ctx_is_pss(pkctx)) {
778         RSAerr(RSA_F_RSA_CMS_VERIFY, RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
779         return 0;
780     }
781     if (nid == NID_rsaEncryption)
782         return 1;
783     /* Workaround for some implementation that use a signature OID */
784     if (OBJ_find_sigid_algs(nid, NULL, &nid2)) {
785         if (nid2 == NID_rsaEncryption)
786             return 1;
787     }
788     return 0;
789 }
790 #endif
791
792 /*
793  * Customised RSA item verification routine. This is called when a signature
794  * is encountered requiring special handling. We currently only handle PSS.
795  */
796
797 static int rsa_item_verify(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
798                            X509_ALGOR *sigalg, ASN1_BIT_STRING *sig,
799                            EVP_PKEY *pkey)
800 {
801     /* Sanity check: make sure it is PSS */
802     if (OBJ_obj2nid(sigalg->algorithm) != EVP_PKEY_RSA_PSS) {
803         RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
804         return -1;
805     }
806     if (rsa_pss_to_ctx(ctx, NULL, sigalg, pkey) > 0) {
807         /* Carry on */
808         return 2;
809     }
810     return -1;
811 }
812
813 #ifndef OPENSSL_NO_CMS
814 static int rsa_cms_sign(CMS_SignerInfo *si)
815 {
816     int pad_mode = RSA_PKCS1_PADDING;
817     X509_ALGOR *alg;
818     EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
819     ASN1_STRING *os = NULL;
820
821     CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
822     if (pkctx) {
823         if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
824             return 0;
825     }
826     if (pad_mode == RSA_PKCS1_PADDING) {
827         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
828         return 1;
829     }
830     /* We don't support it */
831     if (pad_mode != RSA_PKCS1_PSS_PADDING)
832         return 0;
833     os = rsa_ctx_to_pss_string(pkctx);
834     if (!os)
835         return 0;
836     X509_ALGOR_set0(alg, OBJ_nid2obj(EVP_PKEY_RSA_PSS), V_ASN1_SEQUENCE, os);
837     return 1;
838 }
839 #endif
840
841 static int rsa_item_sign(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
842                          X509_ALGOR *alg1, X509_ALGOR *alg2,
843                          ASN1_BIT_STRING *sig)
844 {
845     int pad_mode;
846     EVP_PKEY_CTX *pkctx = EVP_MD_CTX_pkey_ctx(ctx);
847
848     if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
849         return 0;
850     if (pad_mode == RSA_PKCS1_PADDING)
851         return 2;
852     if (pad_mode == RSA_PKCS1_PSS_PADDING) {
853         ASN1_STRING *os1 = NULL;
854         os1 = rsa_ctx_to_pss_string(pkctx);
855         if (!os1)
856             return 0;
857         /* Duplicate parameters if we have to */
858         if (alg2) {
859             ASN1_STRING *os2 = ASN1_STRING_dup(os1);
860             if (!os2) {
861                 ASN1_STRING_free(os1);
862                 return 0;
863             }
864             X509_ALGOR_set0(alg2, OBJ_nid2obj(EVP_PKEY_RSA_PSS),
865                             V_ASN1_SEQUENCE, os2);
866         }
867         X509_ALGOR_set0(alg1, OBJ_nid2obj(EVP_PKEY_RSA_PSS),
868                         V_ASN1_SEQUENCE, os1);
869         return 3;
870     }
871     return 2;
872 }
873
874 static int rsa_sig_info_set(X509_SIG_INFO *siginf, const X509_ALGOR *sigalg,
875                             const ASN1_STRING *sig)
876 {
877     int rv = 0;
878     int mdnid, saltlen;
879     uint32_t flags;
880     const EVP_MD *mgf1md = NULL, *md = NULL;
881     RSA_PSS_PARAMS *pss;
882     int secbits;
883
884     /* Sanity check: make sure it is PSS */
885     if (OBJ_obj2nid(sigalg->algorithm) != EVP_PKEY_RSA_PSS)
886         return 0;
887     /* Decode PSS parameters */
888     pss = rsa_pss_decode(sigalg);
889     if (!rsa_pss_get_param(pss, &md, &mgf1md, &saltlen))
890         goto err;
891     mdnid = EVP_MD_type(md);
892     /*
893      * For TLS need SHA256, SHA384 or SHA512, digest and MGF1 digest must
894      * match and salt length must equal digest size
895      */
896     if ((mdnid == NID_sha256 || mdnid == NID_sha384 || mdnid == NID_sha512)
897             && mdnid == EVP_MD_type(mgf1md) && saltlen == EVP_MD_size(md))
898         flags = X509_SIG_INFO_TLS;
899     else
900         flags = 0;
901     /* Note: security bits half number of digest bits */
902     secbits = EVP_MD_size(md) * 4;
903     /*
904      * SHA1 and MD5 are known to be broken. Reduce security bits so that
905      * they're no longer accepted at security level 1. The real values don't
906      * really matter as long as they're lower than 80, which is our security
907      * level 1.
908      * https://eprint.iacr.org/2020/014 puts a chosen-prefix attack for SHA1 at
909      * 2^63.4
910      * https://documents.epfl.ch/users/l/le/lenstra/public/papers/lat.pdf
911      * puts a chosen-prefix attack for MD5 at 2^39.
912      */
913     if (mdnid == NID_sha1)
914         secbits = 64;
915     else if (mdnid == NID_md5_sha1)
916         secbits = 68;
917     else if (mdnid == NID_md5)
918         secbits = 39;
919     X509_SIG_INFO_set(siginf, mdnid, EVP_PKEY_RSA_PSS, secbits,
920                       flags);
921     rv = 1;
922     err:
923     RSA_PSS_PARAMS_free(pss);
924     return rv;
925 }
926
927 #ifndef OPENSSL_NO_CMS
928 static RSA_OAEP_PARAMS *rsa_oaep_decode(const X509_ALGOR *alg)
929 {
930     RSA_OAEP_PARAMS *oaep;
931
932     oaep = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(RSA_OAEP_PARAMS),
933                                      alg->parameter);
934
935     if (oaep == NULL)
936         return NULL;
937
938     if (oaep->maskGenFunc != NULL) {
939         oaep->maskHash = rsa_mgf1_decode(oaep->maskGenFunc);
940         if (oaep->maskHash == NULL) {
941             RSA_OAEP_PARAMS_free(oaep);
942             return NULL;
943         }
944     }
945     return oaep;
946 }
947
948 static int rsa_cms_decrypt(CMS_RecipientInfo *ri)
949 {
950     EVP_PKEY_CTX *pkctx;
951     X509_ALGOR *cmsalg;
952     int nid;
953     int rv = -1;
954     unsigned char *label = NULL;
955     int labellen = 0;
956     const EVP_MD *mgf1md = NULL, *md = NULL;
957     RSA_OAEP_PARAMS *oaep;
958
959     pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
960     if (pkctx == NULL)
961         return 0;
962     if (!CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &cmsalg))
963         return -1;
964     nid = OBJ_obj2nid(cmsalg->algorithm);
965     if (nid == NID_rsaEncryption)
966         return 1;
967     if (nid != NID_rsaesOaep) {
968         RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_ENCRYPTION_TYPE);
969         return -1;
970     }
971     /* Decode OAEP parameters */
972     oaep = rsa_oaep_decode(cmsalg);
973
974     if (oaep == NULL) {
975         RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_OAEP_PARAMETERS);
976         goto err;
977     }
978
979     mgf1md = rsa_algor_to_md(oaep->maskHash);
980     if (mgf1md == NULL)
981         goto err;
982     md = rsa_algor_to_md(oaep->hashFunc);
983     if (md == NULL)
984         goto err;
985
986     if (oaep->pSourceFunc != NULL) {
987         X509_ALGOR *plab = oaep->pSourceFunc;
988
989         if (OBJ_obj2nid(plab->algorithm) != NID_pSpecified) {
990             RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_LABEL_SOURCE);
991             goto err;
992         }
993         if (plab->parameter->type != V_ASN1_OCTET_STRING) {
994             RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_LABEL);
995             goto err;
996         }
997
998         label = plab->parameter->value.octet_string->data;
999         /* Stop label being freed when OAEP parameters are freed */
1000         plab->parameter->value.octet_string->data = NULL;
1001         labellen = plab->parameter->value.octet_string->length;
1002     }
1003
1004     if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_OAEP_PADDING) <= 0)
1005         goto err;
1006     if (EVP_PKEY_CTX_set_rsa_oaep_md(pkctx, md) <= 0)
1007         goto err;
1008     if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
1009         goto err;
1010     if (label != NULL
1011             && EVP_PKEY_CTX_set0_rsa_oaep_label(pkctx, label, labellen) <= 0)
1012         goto err;
1013     /* Carry on */
1014     rv = 1;
1015
1016  err:
1017     RSA_OAEP_PARAMS_free(oaep);
1018     return rv;
1019 }
1020
1021 static int rsa_cms_encrypt(CMS_RecipientInfo *ri)
1022 {
1023     const EVP_MD *md, *mgf1md;
1024     RSA_OAEP_PARAMS *oaep = NULL;
1025     ASN1_STRING *os = NULL;
1026     X509_ALGOR *alg;
1027     EVP_PKEY_CTX *pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
1028     int pad_mode = RSA_PKCS1_PADDING, rv = 0, labellen;
1029     unsigned char *label;
1030
1031     if (CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &alg) <= 0)
1032         return 0;
1033     if (pkctx) {
1034         if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
1035             return 0;
1036     }
1037     if (pad_mode == RSA_PKCS1_PADDING) {
1038         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
1039         return 1;
1040     }
1041     /* Not supported */
1042     if (pad_mode != RSA_PKCS1_OAEP_PADDING)
1043         return 0;
1044     if (EVP_PKEY_CTX_get_rsa_oaep_md(pkctx, &md) <= 0)
1045         goto err;
1046     if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
1047         goto err;
1048     labellen = EVP_PKEY_CTX_get0_rsa_oaep_label(pkctx, &label);
1049     if (labellen < 0)
1050         goto err;
1051     oaep = RSA_OAEP_PARAMS_new();
1052     if (oaep == NULL)
1053         goto err;
1054     if (!rsa_md_to_algor(&oaep->hashFunc, md))
1055         goto err;
1056     if (!rsa_md_to_mgf1(&oaep->maskGenFunc, mgf1md))
1057         goto err;
1058     if (labellen > 0) {
1059         ASN1_OCTET_STRING *los;
1060         oaep->pSourceFunc = X509_ALGOR_new();
1061         if (oaep->pSourceFunc == NULL)
1062             goto err;
1063         los = ASN1_OCTET_STRING_new();
1064         if (los == NULL)
1065             goto err;
1066         if (!ASN1_OCTET_STRING_set(los, label, labellen)) {
1067             ASN1_OCTET_STRING_free(los);
1068             goto err;
1069         }
1070         X509_ALGOR_set0(oaep->pSourceFunc, OBJ_nid2obj(NID_pSpecified),
1071                         V_ASN1_OCTET_STRING, los);
1072     }
1073     /* create string with pss parameter encoding. */
1074     if (!ASN1_item_pack(oaep, ASN1_ITEM_rptr(RSA_OAEP_PARAMS), &os))
1075          goto err;
1076     X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaesOaep), V_ASN1_SEQUENCE, os);
1077     os = NULL;
1078     rv = 1;
1079  err:
1080     RSA_OAEP_PARAMS_free(oaep);
1081     ASN1_STRING_free(os);
1082     return rv;
1083 }
1084 #endif
1085
1086 static int rsa_pkey_check(const EVP_PKEY *pkey)
1087 {
1088     return RSA_check_key_ex(pkey->pkey.rsa, NULL);
1089 }
1090
1091 static size_t rsa_pkey_dirty_cnt(const EVP_PKEY *pkey)
1092 {
1093     return pkey->pkey.rsa->dirty_cnt;
1094 }
1095
1096 /*
1097  * For the moment, we trust the call path, where keys going through
1098  * rsa_pkey_export_to() match a KEYMGMT for the "RSA" keytype, while
1099  * keys going through rsa_pss_pkey_export_to() match a KEYMGMT for the
1100  * "RSA-PSS" keytype.
1101  * TODO(3.0) Investigate whether we should simply continue to trust the
1102  * call path, or if we should strengthen this function by checking that
1103  * |rsa_type| matches the RSA key subtype.  The latter requires ensuring
1104  * that the type flag for the RSA key is properly set by other functions
1105  * in this file.
1106  */
1107 static int rsa_int_export_to(const EVP_PKEY *from, int rsa_type,
1108                              void *to_keydata, EVP_KEYMGMT *to_keymgmt,
1109                              OPENSSL_CTX *libctx, const char *propq)
1110 {
1111     RSA *rsa = from->pkey.rsa;
1112     OSSL_PARAM_BLD *tmpl = OSSL_PARAM_BLD_new();
1113     OSSL_PARAM *params = NULL;
1114     int selection = 0;
1115     int rv = 0;
1116
1117     if (tmpl == NULL)
1118         return 0;
1119     /*
1120      * If the RSA method is foreign, then we can't be sure of anything, and
1121      * can therefore not export or pretend to export.
1122      */
1123     if (RSA_get_method(rsa) != RSA_PKCS1_OpenSSL())
1124         goto err;
1125
1126     /* Public parameters must always be present */
1127     if (RSA_get0_n(rsa) == NULL || RSA_get0_e(rsa) == NULL)
1128         goto err;
1129
1130     if (!rsa_todata(rsa, tmpl, NULL))
1131         goto err;
1132
1133     selection |= OSSL_KEYMGMT_SELECT_PUBLIC_KEY;
1134     if (RSA_get0_d(rsa) != NULL)
1135         selection |= OSSL_KEYMGMT_SELECT_PRIVATE_KEY;
1136
1137     if (rsa->pss != NULL) {
1138         const EVP_MD *md = NULL, *mgf1md = NULL;
1139         int md_nid, mgf1md_nid, saltlen;
1140         RSA_PSS_PARAMS_30 pss_params;
1141
1142         if (!rsa_pss_get_param(rsa->pss, &md, &mgf1md, &saltlen))
1143             goto err;
1144         md_nid = EVP_MD_type(md);
1145         mgf1md_nid = EVP_MD_type(mgf1md);
1146         if (!rsa_pss_params_30_set_defaults(&pss_params)
1147             || !rsa_pss_params_30_set_hashalg(&pss_params, md_nid)
1148             || !rsa_pss_params_30_set_maskgenhashalg(&pss_params, mgf1md_nid)
1149             || !rsa_pss_params_30_set_saltlen(&pss_params, saltlen)
1150             || !rsa_pss_params_30_todata(&pss_params, propq, tmpl, NULL))
1151             goto err;
1152         selection |= OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS;
1153     }
1154
1155     if ((params = OSSL_PARAM_BLD_to_param(tmpl)) == NULL)
1156         goto err;
1157
1158     /* We export, the provider imports */
1159     rv = evp_keymgmt_import(to_keymgmt, to_keydata, selection, params);
1160
1161  err:
1162     OSSL_PARAM_BLD_free_params(params);
1163     OSSL_PARAM_BLD_free(tmpl);
1164     return rv;
1165 }
1166
1167 static int rsa_int_import_from(const OSSL_PARAM params[], void *vpctx,
1168                                int rsa_type)
1169 {
1170     EVP_PKEY_CTX *pctx = vpctx;
1171     EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(pctx);
1172     RSA *rsa = rsa_new_with_ctx(pctx->libctx);
1173     RSA_PSS_PARAMS_30 rsa_pss_params = { 0, };
1174     int ok = 0;
1175
1176     if (rsa == NULL) {
1177         ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
1178         return 0;
1179     }
1180
1181     RSA_clear_flags(rsa, RSA_FLAG_TYPE_MASK);
1182     RSA_set_flags(rsa, rsa_type);
1183
1184     if (!rsa_pss_params_30_fromdata(&rsa_pss_params, params, pctx->libctx))
1185         goto err;
1186
1187     switch (rsa_type) {
1188     case RSA_FLAG_TYPE_RSA:
1189         /*
1190          * Were PSS parameters filled in?
1191          * In that case, something's wrong
1192          */
1193         if (!rsa_pss_params_30_is_unrestricted(&rsa_pss_params))
1194             goto err;
1195         break;
1196     case RSA_FLAG_TYPE_RSASSAPSS:
1197         /*
1198          * Were PSS parameters filled in?  In that case, create the old
1199          * RSA_PSS_PARAMS structure.  Otherwise, this is an unrestricted key.
1200          */
1201         if (!rsa_pss_params_30_is_unrestricted(&rsa_pss_params)) {
1202             /* Create the older RSA_PSS_PARAMS from RSA_PSS_PARAMS_30 data */
1203             int mdnid = rsa_pss_params_30_hashalg(&rsa_pss_params);
1204             int mgf1mdnid = rsa_pss_params_30_maskgenhashalg(&rsa_pss_params);
1205             int saltlen = rsa_pss_params_30_saltlen(&rsa_pss_params);
1206             const EVP_MD *md = EVP_get_digestbynid(mdnid);
1207             const EVP_MD *mgf1md = EVP_get_digestbynid(mgf1mdnid);
1208
1209             if ((rsa->pss = rsa_pss_params_create(md, mgf1md, saltlen)) == NULL)
1210                 goto err;
1211         }
1212         break;
1213     default:
1214         /* RSA key sub-types we don't know how to handle yet */
1215         goto err;
1216     }
1217
1218     if (!rsa_fromdata(rsa, params))
1219         goto err;
1220
1221     switch (rsa_type) {
1222     case RSA_FLAG_TYPE_RSA:
1223         ok = EVP_PKEY_assign_RSA(pkey, rsa);
1224         break;
1225     case RSA_FLAG_TYPE_RSASSAPSS:
1226         ok = EVP_PKEY_assign(pkey, EVP_PKEY_RSA_PSS, rsa);
1227         break;
1228     }
1229
1230  err:
1231     if (!ok)
1232         RSA_free(rsa);
1233     return ok;
1234 }
1235
1236 static int rsa_pkey_export_to(const EVP_PKEY *from, void *to_keydata,
1237                               EVP_KEYMGMT *to_keymgmt, OPENSSL_CTX *libctx,
1238                               const char *propq)
1239 {
1240     return rsa_int_export_to(from, RSA_FLAG_TYPE_RSA, to_keydata,
1241                              to_keymgmt, libctx, propq);
1242 }
1243
1244 static int rsa_pss_pkey_export_to(const EVP_PKEY *from, void *to_keydata,
1245                                   EVP_KEYMGMT *to_keymgmt, OPENSSL_CTX *libctx,
1246                                   const char *propq)
1247 {
1248     return rsa_int_export_to(from, RSA_FLAG_TYPE_RSASSAPSS, to_keydata,
1249                              to_keymgmt, libctx, propq);
1250 }
1251
1252 static int rsa_pkey_import_from(const OSSL_PARAM params[], void *vpctx)
1253 {
1254     return rsa_int_import_from(params, vpctx, RSA_FLAG_TYPE_RSA);
1255 }
1256
1257 static int rsa_pss_pkey_import_from(const OSSL_PARAM params[], void *vpctx)
1258 {
1259     return rsa_int_import_from(params, vpctx, RSA_FLAG_TYPE_RSASSAPSS);
1260 }
1261
1262 const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[2] = {
1263     {
1264      EVP_PKEY_RSA,
1265      EVP_PKEY_RSA,
1266      ASN1_PKEY_SIGPARAM_NULL,
1267
1268      "RSA",
1269      "OpenSSL RSA method",
1270
1271      rsa_pub_decode,
1272      rsa_pub_encode,
1273      rsa_pub_cmp,
1274      rsa_pub_print,
1275
1276      rsa_priv_decode,
1277      rsa_priv_encode,
1278      rsa_priv_print,
1279
1280      int_rsa_size,
1281      rsa_bits,
1282      rsa_security_bits,
1283
1284      0, 0, 0, 0, 0, 0,
1285
1286      rsa_sig_print,
1287      int_rsa_free,
1288      rsa_pkey_ctrl,
1289      old_rsa_priv_decode,
1290      old_rsa_priv_encode,
1291      rsa_item_verify,
1292      rsa_item_sign,
1293      rsa_sig_info_set,
1294      rsa_pkey_check,
1295
1296      0, 0,
1297      0, 0, 0, 0,
1298
1299      rsa_pkey_dirty_cnt,
1300      rsa_pkey_export_to,
1301      rsa_pkey_import_from
1302     },
1303
1304     {
1305      EVP_PKEY_RSA2,
1306      EVP_PKEY_RSA,
1307      ASN1_PKEY_ALIAS}
1308 };
1309
1310 const EVP_PKEY_ASN1_METHOD rsa_pss_asn1_meth = {
1311      EVP_PKEY_RSA_PSS,
1312      EVP_PKEY_RSA_PSS,
1313      ASN1_PKEY_SIGPARAM_NULL,
1314
1315      "RSA-PSS",
1316      "OpenSSL RSA-PSS method",
1317
1318      rsa_pub_decode,
1319      rsa_pub_encode,
1320      rsa_pub_cmp,
1321      rsa_pub_print,
1322
1323      rsa_priv_decode,
1324      rsa_priv_encode,
1325      rsa_priv_print,
1326
1327      int_rsa_size,
1328      rsa_bits,
1329      rsa_security_bits,
1330
1331      0, 0, 0, 0, 0, 0,
1332
1333      rsa_sig_print,
1334      int_rsa_free,
1335      rsa_pkey_ctrl,
1336      0, 0,
1337      rsa_item_verify,
1338      rsa_item_sign,
1339      0,
1340      rsa_pkey_check,
1341
1342      0, 0,
1343      0, 0, 0, 0,
1344
1345      rsa_pkey_dirty_cnt,
1346      rsa_pss_pkey_export_to,
1347      rsa_pss_pkey_import_from
1348 };