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