68b268ecb77202dbb7ef5763c26ecb25f9e90a15
[openssl.git] / crypto / rsa / rsa_ameth.c
1 /* crypto/rsa/rsa_ameth.c */
2 /*
3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
4  * 2006.
5  */
6 /* ====================================================================
7  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in
18  *    the documentation and/or other materials provided with the
19  *    distribution.
20  *
21  * 3. All advertising materials mentioning features or use of this
22  *    software must display the following acknowledgment:
23  *    "This product includes software developed by the OpenSSL Project
24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25  *
26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27  *    endorse or promote products derived from this software without
28  *    prior written permission. For written permission, please contact
29  *    licensing@OpenSSL.org.
30  *
31  * 5. Products derived from this software may not be called "OpenSSL"
32  *    nor may "OpenSSL" appear in their names without prior written
33  *    permission of the OpenSSL Project.
34  *
35  * 6. Redistributions of any form whatsoever must retain the following
36  *    acknowledgment:
37  *    "This product includes software developed by the OpenSSL Project
38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51  * OF THE POSSIBILITY OF SUCH DAMAGE.
52  * ====================================================================
53  *
54  * This product includes cryptographic software written by Eric Young
55  * (eay@cryptsoft.com).  This product includes software written by Tim
56  * Hudson (tjh@cryptsoft.com).
57  *
58  */
59
60 #include <stdio.h>
61 #include "internal/cryptlib.h"
62 #include <openssl/asn1t.h>
63 #include <openssl/x509.h>
64 #include <openssl/rsa.h>
65 #include <openssl/bn.h>
66 #ifndef OPENSSL_NO_CMS
67 # include <openssl/cms.h>
68 #endif
69 #include "internal/asn1_int.h"
70
71 #ifndef OPENSSL_NO_CMS
72 static int rsa_cms_sign(CMS_SignerInfo *si);
73 static int rsa_cms_verify(CMS_SignerInfo *si);
74 static int rsa_cms_decrypt(CMS_RecipientInfo *ri);
75 static int rsa_cms_encrypt(CMS_RecipientInfo *ri);
76 #endif
77
78 static int rsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
79 {
80     unsigned char *penc = NULL;
81     int penclen;
82     penclen = i2d_RSAPublicKey(pkey->pkey.rsa, &penc);
83     if (penclen <= 0)
84         return 0;
85     if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_RSA),
86                                V_ASN1_NULL, NULL, penc, penclen))
87         return 1;
88
89     OPENSSL_free(penc);
90     return 0;
91 }
92
93 static int rsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
94 {
95     const unsigned char *p;
96     int pklen;
97     RSA *rsa = NULL;
98
99     if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, NULL, pubkey))
100         return 0;
101     if ((rsa = d2i_RSAPublicKey(NULL, &p, pklen)) == NULL) {
102         RSAerr(RSA_F_RSA_PUB_DECODE, ERR_R_RSA_LIB);
103         return 0;
104     }
105     EVP_PKEY_assign_RSA(pkey, rsa);
106     return 1;
107 }
108
109 static int rsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
110 {
111     if (BN_cmp(b->pkey.rsa->n, a->pkey.rsa->n) != 0
112         || BN_cmp(b->pkey.rsa->e, a->pkey.rsa->e) != 0)
113         return 0;
114     return 1;
115 }
116
117 static int old_rsa_priv_decode(EVP_PKEY *pkey,
118                                const unsigned char **pder, int derlen)
119 {
120     RSA *rsa;
121
122     if ((rsa = d2i_RSAPrivateKey(NULL, pder, derlen)) == NULL) {
123         RSAerr(RSA_F_OLD_RSA_PRIV_DECODE, ERR_R_RSA_LIB);
124         return 0;
125     }
126     EVP_PKEY_assign_RSA(pkey, rsa);
127     return 1;
128 }
129
130 static int old_rsa_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
131 {
132     return i2d_RSAPrivateKey(pkey->pkey.rsa, pder);
133 }
134
135 static int rsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
136 {
137     unsigned char *rk = NULL;
138     int rklen;
139     rklen = i2d_RSAPrivateKey(pkey->pkey.rsa, &rk);
140
141     if (rklen <= 0) {
142         RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
143         return 0;
144     }
145
146     if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_rsaEncryption), 0,
147                          V_ASN1_NULL, NULL, rk, rklen)) {
148         RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
149         return 0;
150     }
151
152     return 1;
153 }
154
155 static int rsa_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
156 {
157     const unsigned char *p;
158     int pklen;
159     if (!PKCS8_pkey_get0(NULL, &p, &pklen, NULL, p8))
160         return 0;
161     return old_rsa_priv_decode(pkey, &p, pklen);
162 }
163
164 static int int_rsa_size(const EVP_PKEY *pkey)
165 {
166     return RSA_size(pkey->pkey.rsa);
167 }
168
169 static int rsa_bits(const EVP_PKEY *pkey)
170 {
171     return BN_num_bits(pkey->pkey.rsa->n);
172 }
173
174 static int rsa_security_bits(const EVP_PKEY *pkey)
175 {
176     return RSA_security_bits(pkey->pkey.rsa);
177 }
178
179 static void int_rsa_free(EVP_PKEY *pkey)
180 {
181     RSA_free(pkey->pkey.rsa);
182 }
183
184 static void update_buflen(const BIGNUM *b, size_t *pbuflen)
185 {
186     size_t i;
187     if (!b)
188         return;
189     if (*pbuflen < (i = (size_t)BN_num_bytes(b)))
190         *pbuflen = i;
191 }
192
193 static int do_rsa_print(BIO *bp, const RSA *x, int off, int priv)
194 {
195     char *str;
196     const char *s;
197     unsigned char *m = NULL;
198     int ret = 0, mod_len = 0;
199     size_t buf_len = 0;
200
201     update_buflen(x->n, &buf_len);
202     update_buflen(x->e, &buf_len);
203
204     if (priv) {
205         update_buflen(x->d, &buf_len);
206         update_buflen(x->p, &buf_len);
207         update_buflen(x->q, &buf_len);
208         update_buflen(x->dmp1, &buf_len);
209         update_buflen(x->dmq1, &buf_len);
210         update_buflen(x->iqmp, &buf_len);
211     }
212
213     m = OPENSSL_malloc(buf_len + 10);
214     if (m == NULL) {
215         RSAerr(RSA_F_DO_RSA_PRINT, ERR_R_MALLOC_FAILURE);
216         goto err;
217     }
218
219     if (x->n != NULL)
220         mod_len = BN_num_bits(x->n);
221
222     if (!BIO_indent(bp, off, 128))
223         goto err;
224
225     if (priv && x->d) {
226         if (BIO_printf(bp, "Private-Key: (%d bit)\n", mod_len)
227             <= 0)
228             goto err;
229         str = "modulus:";
230         s = "publicExponent:";
231     } else {
232         if (BIO_printf(bp, "Public-Key: (%d bit)\n", mod_len)
233             <= 0)
234             goto err;
235         str = "Modulus:";
236         s = "Exponent:";
237     }
238     if (!ASN1_bn_print(bp, str, x->n, m, off))
239         goto err;
240     if (!ASN1_bn_print(bp, s, x->e, m, off))
241         goto err;
242     if (priv) {
243         if (!ASN1_bn_print(bp, "privateExponent:", x->d, m, off))
244             goto err;
245         if (!ASN1_bn_print(bp, "prime1:", x->p, m, off))
246             goto err;
247         if (!ASN1_bn_print(bp, "prime2:", x->q, m, off))
248             goto err;
249         if (!ASN1_bn_print(bp, "exponent1:", x->dmp1, m, off))
250             goto err;
251         if (!ASN1_bn_print(bp, "exponent2:", x->dmq1, m, off))
252             goto err;
253         if (!ASN1_bn_print(bp, "coefficient:", x->iqmp, m, off))
254             goto err;
255     }
256     ret = 1;
257  err:
258     OPENSSL_free(m);
259     return (ret);
260 }
261
262 static int rsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
263                          ASN1_PCTX *ctx)
264 {
265     return do_rsa_print(bp, pkey->pkey.rsa, indent, 0);
266 }
267
268 static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
269                           ASN1_PCTX *ctx)
270 {
271     return do_rsa_print(bp, pkey->pkey.rsa, indent, 1);
272 }
273
274 /* Given an MGF1 Algorithm ID decode to an Algorithm Identifier */
275 static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg)
276 {
277     if (alg == NULL)
278         return NULL;
279     if (OBJ_obj2nid(alg->algorithm) != NID_mgf1)
280         return NULL;
281     return ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(X509_ALGOR),
282                                      alg->parameter);
283 }
284
285 static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
286                                       X509_ALGOR **pmaskHash)
287 {
288     RSA_PSS_PARAMS *pss;
289
290     *pmaskHash = NULL;
291
292     pss = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(RSA_PSS_PARAMS),
293                                     alg->parameter);
294
295     if (!pss)
296         return NULL;
297
298     *pmaskHash = rsa_mgf1_decode(pss->maskGenAlgorithm);
299
300     return pss;
301 }
302
303 static int rsa_pss_param_print(BIO *bp, RSA_PSS_PARAMS *pss,
304                                X509_ALGOR *maskHash, int indent)
305 {
306     int rv = 0;
307     if (!pss) {
308         if (BIO_puts(bp, " (INVALID PSS PARAMETERS)\n") <= 0)
309             return 0;
310         return 1;
311     }
312     if (BIO_puts(bp, "\n") <= 0)
313         goto err;
314     if (!BIO_indent(bp, indent, 128))
315         goto err;
316     if (BIO_puts(bp, "Hash Algorithm: ") <= 0)
317         goto err;
318
319     if (pss->hashAlgorithm) {
320         if (i2a_ASN1_OBJECT(bp, pss->hashAlgorithm->algorithm) <= 0)
321             goto err;
322     } else if (BIO_puts(bp, "sha1 (default)") <= 0)
323         goto err;
324
325     if (BIO_puts(bp, "\n") <= 0)
326         goto err;
327
328     if (!BIO_indent(bp, indent, 128))
329         goto err;
330
331     if (BIO_puts(bp, "Mask Algorithm: ") <= 0)
332         goto err;
333     if (pss->maskGenAlgorithm) {
334         if (i2a_ASN1_OBJECT(bp, pss->maskGenAlgorithm->algorithm) <= 0)
335             goto err;
336         if (BIO_puts(bp, " with ") <= 0)
337             goto err;
338         if (maskHash) {
339             if (i2a_ASN1_OBJECT(bp, maskHash->algorithm) <= 0)
340                 goto err;
341         } else if (BIO_puts(bp, "INVALID") <= 0)
342             goto err;
343     } else if (BIO_puts(bp, "mgf1 with sha1 (default)") <= 0)
344         goto err;
345     BIO_puts(bp, "\n");
346
347     if (!BIO_indent(bp, indent, 128))
348         goto err;
349     if (BIO_puts(bp, "Salt Length: 0x") <= 0)
350         goto err;
351     if (pss->saltLength) {
352         if (i2a_ASN1_INTEGER(bp, pss->saltLength) <= 0)
353             goto err;
354     } else if (BIO_puts(bp, "14 (default)") <= 0)
355         goto err;
356     BIO_puts(bp, "\n");
357
358     if (!BIO_indent(bp, indent, 128))
359         goto err;
360     if (BIO_puts(bp, "Trailer Field: 0x") <= 0)
361         goto err;
362     if (pss->trailerField) {
363         if (i2a_ASN1_INTEGER(bp, pss->trailerField) <= 0)
364             goto err;
365     } else if (BIO_puts(bp, "BC (default)") <= 0)
366         goto err;
367     BIO_puts(bp, "\n");
368
369     rv = 1;
370
371  err:
372     return rv;
373
374 }
375
376 static int rsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
377                          const ASN1_STRING *sig, int indent, ASN1_PCTX *pctx)
378 {
379     if (OBJ_obj2nid(sigalg->algorithm) == NID_rsassaPss) {
380         int rv;
381         RSA_PSS_PARAMS *pss;
382         X509_ALGOR *maskHash;
383         pss = rsa_pss_decode(sigalg, &maskHash);
384         rv = rsa_pss_param_print(bp, pss, maskHash, indent);
385         RSA_PSS_PARAMS_free(pss);
386         X509_ALGOR_free(maskHash);
387         if (!rv)
388             return 0;
389     } else if (!sig && BIO_puts(bp, "\n") <= 0)
390         return 0;
391     if (sig)
392         return X509_signature_dump(bp, sig, indent);
393     return 1;
394 }
395
396 static int rsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
397 {
398     X509_ALGOR *alg = NULL;
399     switch (op) {
400
401     case ASN1_PKEY_CTRL_PKCS7_SIGN:
402         if (arg1 == 0)
403             PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, NULL, &alg);
404         break;
405
406     case ASN1_PKEY_CTRL_PKCS7_ENCRYPT:
407         if (arg1 == 0)
408             PKCS7_RECIP_INFO_get0_alg(arg2, &alg);
409         break;
410 #ifndef OPENSSL_NO_CMS
411     case ASN1_PKEY_CTRL_CMS_SIGN:
412         if (arg1 == 0)
413             return rsa_cms_sign(arg2);
414         else if (arg1 == 1)
415             return rsa_cms_verify(arg2);
416         break;
417
418     case ASN1_PKEY_CTRL_CMS_ENVELOPE:
419         if (arg1 == 0)
420             return rsa_cms_encrypt(arg2);
421         else if (arg1 == 1)
422             return rsa_cms_decrypt(arg2);
423         break;
424
425     case ASN1_PKEY_CTRL_CMS_RI_TYPE:
426         *(int *)arg2 = CMS_RECIPINFO_TRANS;
427         return 1;
428 #endif
429
430     case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
431         *(int *)arg2 = NID_sha256;
432         return 1;
433
434     default:
435         return -2;
436
437     }
438
439     if (alg)
440         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
441
442     return 1;
443
444 }
445
446 /* allocate and set algorithm ID from EVP_MD, default SHA1 */
447 static int rsa_md_to_algor(X509_ALGOR **palg, const EVP_MD *md)
448 {
449     if (EVP_MD_type(md) == NID_sha1)
450         return 1;
451     *palg = X509_ALGOR_new();
452     if (*palg == NULL)
453         return 0;
454     X509_ALGOR_set_md(*palg, md);
455     return 1;
456 }
457
458 /* Allocate and set MGF1 algorithm ID from EVP_MD */
459 static int rsa_md_to_mgf1(X509_ALGOR **palg, const EVP_MD *mgf1md)
460 {
461     X509_ALGOR *algtmp = NULL;
462     ASN1_STRING *stmp = NULL;
463     *palg = NULL;
464     if (EVP_MD_type(mgf1md) == NID_sha1)
465         return 1;
466     /* need to embed algorithm ID inside another */
467     if (!rsa_md_to_algor(&algtmp, mgf1md))
468         goto err;
469     if (!ASN1_item_pack(algtmp, ASN1_ITEM_rptr(X509_ALGOR), &stmp))
470          goto err;
471     *palg = X509_ALGOR_new();
472     if (*palg == NULL)
473         goto err;
474     X509_ALGOR_set0(*palg, OBJ_nid2obj(NID_mgf1), V_ASN1_SEQUENCE, stmp);
475     stmp = NULL;
476  err:
477     ASN1_STRING_free(stmp);
478     X509_ALGOR_free(algtmp);
479     if (*palg)
480         return 1;
481     return 0;
482 }
483
484 /* convert algorithm ID to EVP_MD, default SHA1 */
485 static const EVP_MD *rsa_algor_to_md(X509_ALGOR *alg)
486 {
487     const EVP_MD *md;
488     if (!alg)
489         return EVP_sha1();
490     md = EVP_get_digestbyobj(alg->algorithm);
491     if (md == NULL)
492         RSAerr(RSA_F_RSA_ALGOR_TO_MD, RSA_R_UNKNOWN_DIGEST);
493     return md;
494 }
495
496 /* convert MGF1 algorithm ID to EVP_MD, default SHA1 */
497 static const EVP_MD *rsa_mgf1_to_md(X509_ALGOR *alg, X509_ALGOR *maskHash)
498 {
499     const EVP_MD *md;
500     if (!alg)
501         return EVP_sha1();
502     /* Check mask and lookup mask hash algorithm */
503     if (OBJ_obj2nid(alg->algorithm) != NID_mgf1) {
504         RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_ALGORITHM);
505         return NULL;
506     }
507     if (!maskHash) {
508         RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNSUPPORTED_MASK_PARAMETER);
509         return NULL;
510     }
511     md = EVP_get_digestbyobj(maskHash->algorithm);
512     if (md == NULL) {
513         RSAerr(RSA_F_RSA_MGF1_TO_MD, RSA_R_UNKNOWN_MASK_DIGEST);
514         return NULL;
515     }
516     return md;
517 }
518
519 /*
520  * Convert EVP_PKEY_CTX is PSS mode into corresponding algorithm parameter,
521  * suitable for setting an AlgorithmIdentifier.
522  */
523
524 static ASN1_STRING *rsa_ctx_to_pss(EVP_PKEY_CTX *pkctx)
525 {
526     const EVP_MD *sigmd, *mgf1md;
527     RSA_PSS_PARAMS *pss = NULL;
528     ASN1_STRING *os = NULL;
529     EVP_PKEY *pk = EVP_PKEY_CTX_get0_pkey(pkctx);
530     int saltlen, rv = 0;
531     if (EVP_PKEY_CTX_get_signature_md(pkctx, &sigmd) <= 0)
532         goto err;
533     if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
534         goto err;
535     if (!EVP_PKEY_CTX_get_rsa_pss_saltlen(pkctx, &saltlen))
536         goto err;
537     if (saltlen == -1)
538         saltlen = EVP_MD_size(sigmd);
539     else if (saltlen == -2) {
540         saltlen = EVP_PKEY_size(pk) - EVP_MD_size(sigmd) - 2;
541         if (((EVP_PKEY_bits(pk) - 1) & 0x7) == 0)
542             saltlen--;
543     }
544     pss = RSA_PSS_PARAMS_new();
545     if (pss == NULL)
546         goto err;
547     if (saltlen != 20) {
548         pss->saltLength = ASN1_INTEGER_new();
549         if (pss->saltLength == NULL)
550             goto err;
551         if (!ASN1_INTEGER_set(pss->saltLength, saltlen))
552             goto err;
553     }
554     if (!rsa_md_to_algor(&pss->hashAlgorithm, sigmd))
555         goto err;
556     if (!rsa_md_to_mgf1(&pss->maskGenAlgorithm, mgf1md))
557         goto err;
558     /* Finally create string with pss parameter encoding. */
559     if (!ASN1_item_pack(pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), &os))
560          goto err;
561     rv = 1;
562  err:
563     RSA_PSS_PARAMS_free(pss);
564     if (rv)
565         return os;
566     ASN1_STRING_free(os);
567     return NULL;
568 }
569
570 /*
571  * From PSS AlgorithmIdentifier set public key parameters. If pkey isn't NULL
572  * then the EVP_MD_CTX is setup and initalised. If it is NULL parameters are
573  * passed to pkctx instead.
574  */
575
576 static int rsa_pss_to_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pkctx,
577                           X509_ALGOR *sigalg, EVP_PKEY *pkey)
578 {
579     int rv = -1;
580     int saltlen;
581     const EVP_MD *mgf1md = NULL, *md = NULL;
582     RSA_PSS_PARAMS *pss;
583     X509_ALGOR *maskHash;
584     /* Sanity check: make sure it is PSS */
585     if (OBJ_obj2nid(sigalg->algorithm) != NID_rsassaPss) {
586         RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
587         return -1;
588     }
589     /* Decode PSS parameters */
590     pss = rsa_pss_decode(sigalg, &maskHash);
591
592     if (pss == NULL) {
593         RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_PSS_PARAMETERS);
594         goto err;
595     }
596     mgf1md = rsa_mgf1_to_md(pss->maskGenAlgorithm, maskHash);
597     if (!mgf1md)
598         goto err;
599     md = rsa_algor_to_md(pss->hashAlgorithm);
600     if (!md)
601         goto err;
602
603     if (pss->saltLength) {
604         saltlen = ASN1_INTEGER_get(pss->saltLength);
605
606         /*
607          * Could perform more salt length sanity checks but the main RSA
608          * routines will trap other invalid values anyway.
609          */
610         if (saltlen < 0) {
611             RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_SALT_LENGTH);
612             goto err;
613         }
614     } else
615         saltlen = 20;
616
617     /*
618      * low-level routines support only trailer field 0xbc (value 1) and
619      * PKCS#1 says we should reject any other value anyway.
620      */
621     if (pss->trailerField && ASN1_INTEGER_get(pss->trailerField) != 1) {
622         RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_INVALID_TRAILER);
623         goto err;
624     }
625
626     /* We have all parameters now set up context */
627
628     if (pkey) {
629         if (!EVP_DigestVerifyInit(ctx, &pkctx, md, NULL, pkey))
630             goto err;
631     } else {
632         const EVP_MD *checkmd;
633         if (EVP_PKEY_CTX_get_signature_md(pkctx, &checkmd) <= 0)
634             goto err;
635         if (EVP_MD_type(md) != EVP_MD_type(checkmd)) {
636             RSAerr(RSA_F_RSA_PSS_TO_CTX, RSA_R_DIGEST_DOES_NOT_MATCH);
637             goto err;
638         }
639     }
640
641     if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_PSS_PADDING) <= 0)
642         goto err;
643
644     if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkctx, saltlen) <= 0)
645         goto err;
646
647     if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
648         goto err;
649     /* Carry on */
650     rv = 1;
651
652  err:
653     RSA_PSS_PARAMS_free(pss);
654     X509_ALGOR_free(maskHash);
655     return rv;
656 }
657
658 #ifndef OPENSSL_NO_CMS
659 static int rsa_cms_verify(CMS_SignerInfo *si)
660 {
661     int nid, nid2;
662     X509_ALGOR *alg;
663     EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
664     CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
665     nid = OBJ_obj2nid(alg->algorithm);
666     if (nid == NID_rsaEncryption)
667         return 1;
668     if (nid == NID_rsassaPss)
669         return rsa_pss_to_ctx(NULL, pkctx, alg, NULL);
670     /* Workaround for some implementation that use a signature OID */
671     if (OBJ_find_sigid_algs(nid, NULL, &nid2)) {
672         if (nid2 == NID_rsaEncryption)
673             return 1;
674     }
675     return 0;
676 }
677 #endif
678
679 /*
680  * Customised RSA item verification routine. This is called when a signature
681  * is encountered requiring special handling. We currently only handle PSS.
682  */
683
684 static int rsa_item_verify(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
685                            X509_ALGOR *sigalg, ASN1_BIT_STRING *sig,
686                            EVP_PKEY *pkey)
687 {
688     /* Sanity check: make sure it is PSS */
689     if (OBJ_obj2nid(sigalg->algorithm) != NID_rsassaPss) {
690         RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
691         return -1;
692     }
693     if (rsa_pss_to_ctx(ctx, NULL, sigalg, pkey) > 0) {
694         /* Carry on */
695         return 2;
696     }
697     return -1;
698 }
699
700 #ifndef OPENSSL_NO_CMS
701 static int rsa_cms_sign(CMS_SignerInfo *si)
702 {
703     int pad_mode = RSA_PKCS1_PADDING;
704     X509_ALGOR *alg;
705     EVP_PKEY_CTX *pkctx = CMS_SignerInfo_get0_pkey_ctx(si);
706     ASN1_STRING *os = NULL;
707     CMS_SignerInfo_get0_algs(si, NULL, NULL, NULL, &alg);
708     if (pkctx) {
709         if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
710             return 0;
711     }
712     if (pad_mode == RSA_PKCS1_PADDING) {
713         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
714         return 1;
715     }
716     /* We don't support it */
717     if (pad_mode != RSA_PKCS1_PSS_PADDING)
718         return 0;
719     os = rsa_ctx_to_pss(pkctx);
720     if (!os)
721         return 0;
722     X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsassaPss), V_ASN1_SEQUENCE, os);
723     return 1;
724 }
725 #endif
726
727 static int rsa_item_sign(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
728                          X509_ALGOR *alg1, X509_ALGOR *alg2,
729                          ASN1_BIT_STRING *sig)
730 {
731     int pad_mode;
732     EVP_PKEY_CTX *pkctx = EVP_MD_CTX_pkey_ctx(ctx);
733     if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
734         return 0;
735     if (pad_mode == RSA_PKCS1_PADDING)
736         return 2;
737     if (pad_mode == RSA_PKCS1_PSS_PADDING) {
738         ASN1_STRING *os1 = NULL;
739         os1 = rsa_ctx_to_pss(pkctx);
740         if (!os1)
741             return 0;
742         /* Duplicate parameters if we have to */
743         if (alg2) {
744             ASN1_STRING *os2 = ASN1_STRING_dup(os1);
745             if (!os2) {
746                 ASN1_STRING_free(os1);
747                 return 0;
748             }
749             X509_ALGOR_set0(alg2, OBJ_nid2obj(NID_rsassaPss),
750                             V_ASN1_SEQUENCE, os2);
751         }
752         X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_rsassaPss),
753                         V_ASN1_SEQUENCE, os1);
754         return 3;
755     }
756     return 2;
757 }
758
759 #ifndef OPENSSL_NO_CMS
760 static RSA_OAEP_PARAMS *rsa_oaep_decode(const X509_ALGOR *alg,
761                                         X509_ALGOR **pmaskHash)
762 {
763     RSA_OAEP_PARAMS *pss;
764
765     *pmaskHash = NULL;
766
767     pss = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(RSA_OAEP_PARAMS),
768                                     alg->parameter);
769
770     if (!pss)
771         return NULL;
772
773     *pmaskHash = rsa_mgf1_decode(pss->maskGenFunc);
774
775     return pss;
776 }
777
778 static int rsa_cms_decrypt(CMS_RecipientInfo *ri)
779 {
780     EVP_PKEY_CTX *pkctx;
781     X509_ALGOR *cmsalg;
782     int nid;
783     int rv = -1;
784     unsigned char *label = NULL;
785     int labellen = 0;
786     const EVP_MD *mgf1md = NULL, *md = NULL;
787     RSA_OAEP_PARAMS *oaep;
788     X509_ALGOR *maskHash;
789     pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
790     if (!pkctx)
791         return 0;
792     if (!CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &cmsalg))
793         return -1;
794     nid = OBJ_obj2nid(cmsalg->algorithm);
795     if (nid == NID_rsaEncryption)
796         return 1;
797     if (nid != NID_rsaesOaep) {
798         RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_ENCRYPTION_TYPE);
799         return -1;
800     }
801     /* Decode OAEP parameters */
802     oaep = rsa_oaep_decode(cmsalg, &maskHash);
803
804     if (oaep == NULL) {
805         RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_OAEP_PARAMETERS);
806         goto err;
807     }
808
809     mgf1md = rsa_mgf1_to_md(oaep->maskGenFunc, maskHash);
810     if (!mgf1md)
811         goto err;
812     md = rsa_algor_to_md(oaep->hashFunc);
813     if (!md)
814         goto err;
815
816     if (oaep->pSourceFunc) {
817         X509_ALGOR *plab = oaep->pSourceFunc;
818         if (OBJ_obj2nid(plab->algorithm) != NID_pSpecified) {
819             RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_UNSUPPORTED_LABEL_SOURCE);
820             goto err;
821         }
822         if (plab->parameter->type != V_ASN1_OCTET_STRING) {
823             RSAerr(RSA_F_RSA_CMS_DECRYPT, RSA_R_INVALID_LABEL);
824             goto err;
825         }
826
827         label = plab->parameter->value.octet_string->data;
828         /* Stop label being freed when OAEP parameters are freed */
829         plab->parameter->value.octet_string->data = NULL;
830         labellen = plab->parameter->value.octet_string->length;
831     }
832
833     if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_OAEP_PADDING) <= 0)
834         goto err;
835     if (EVP_PKEY_CTX_set_rsa_oaep_md(pkctx, md) <= 0)
836         goto err;
837     if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
838         goto err;
839     if (EVP_PKEY_CTX_set0_rsa_oaep_label(pkctx, label, labellen) <= 0)
840         goto err;
841     /* Carry on */
842     rv = 1;
843
844  err:
845     RSA_OAEP_PARAMS_free(oaep);
846     X509_ALGOR_free(maskHash);
847     return rv;
848 }
849
850 static int rsa_cms_encrypt(CMS_RecipientInfo *ri)
851 {
852     const EVP_MD *md, *mgf1md;
853     RSA_OAEP_PARAMS *oaep = NULL;
854     ASN1_STRING *os = NULL;
855     X509_ALGOR *alg;
856     EVP_PKEY_CTX *pkctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
857     int pad_mode = RSA_PKCS1_PADDING, rv = 0, labellen;
858     unsigned char *label;
859     CMS_RecipientInfo_ktri_get0_algs(ri, NULL, NULL, &alg);
860     if (pkctx) {
861         if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
862             return 0;
863     }
864     if (pad_mode == RSA_PKCS1_PADDING) {
865         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
866         return 1;
867     }
868     /* Not supported */
869     if (pad_mode != RSA_PKCS1_OAEP_PADDING)
870         return 0;
871     if (EVP_PKEY_CTX_get_rsa_oaep_md(pkctx, &md) <= 0)
872         goto err;
873     if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
874         goto err;
875     labellen = EVP_PKEY_CTX_get0_rsa_oaep_label(pkctx, &label);
876     if (labellen < 0)
877         goto err;
878     oaep = RSA_OAEP_PARAMS_new();
879     if (oaep == NULL)
880         goto err;
881     if (!rsa_md_to_algor(&oaep->hashFunc, md))
882         goto err;
883     if (!rsa_md_to_mgf1(&oaep->maskGenFunc, mgf1md))
884         goto err;
885     if (labellen > 0) {
886         ASN1_OCTET_STRING *los = ASN1_OCTET_STRING_new();
887         oaep->pSourceFunc = X509_ALGOR_new();
888         if (oaep->pSourceFunc == NULL)
889             goto err;
890         if (los == NULL)
891             goto err;
892         if (!ASN1_OCTET_STRING_set(los, label, labellen)) {
893             ASN1_OCTET_STRING_free(los);
894             goto err;
895         }
896         X509_ALGOR_set0(oaep->pSourceFunc, OBJ_nid2obj(NID_pSpecified),
897                         V_ASN1_OCTET_STRING, los);
898     }
899     /* create string with pss parameter encoding. */
900     if (!ASN1_item_pack(oaep, ASN1_ITEM_rptr(RSA_OAEP_PARAMS), &os))
901          goto err;
902     X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaesOaep), V_ASN1_SEQUENCE, os);
903     os = NULL;
904     rv = 1;
905  err:
906     RSA_OAEP_PARAMS_free(oaep);
907     ASN1_STRING_free(os);
908     return rv;
909 }
910 #endif
911
912 const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[] = {
913     {
914      EVP_PKEY_RSA,
915      EVP_PKEY_RSA,
916      ASN1_PKEY_SIGPARAM_NULL,
917
918      "RSA",
919      "OpenSSL RSA method",
920
921      rsa_pub_decode,
922      rsa_pub_encode,
923      rsa_pub_cmp,
924      rsa_pub_print,
925
926      rsa_priv_decode,
927      rsa_priv_encode,
928      rsa_priv_print,
929
930      int_rsa_size,
931      rsa_bits,
932      rsa_security_bits,
933
934      0, 0, 0, 0, 0, 0,
935
936      rsa_sig_print,
937      int_rsa_free,
938      rsa_pkey_ctrl,
939      old_rsa_priv_decode,
940      old_rsa_priv_encode,
941      rsa_item_verify,
942      rsa_item_sign},
943
944     {
945      EVP_PKEY_RSA2,
946      EVP_PKEY_RSA,
947      ASN1_PKEY_ALIAS}
948 };