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