Import OpenSSL 1.0.1q.
[dragonfly.git] / crypto / openssl / 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 "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 "asn1_locl.h"
70
71 static int rsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
72 {
73     unsigned char *penc = NULL;
74     int penclen;
75     penclen = i2d_RSAPublicKey(pkey->pkey.rsa, &penc);
76     if (penclen <= 0)
77         return 0;
78     if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_RSA),
79                                V_ASN1_NULL, NULL, penc, penclen))
80         return 1;
81
82     OPENSSL_free(penc);
83     return 0;
84 }
85
86 static int rsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
87 {
88     const unsigned char *p;
89     int pklen;
90     RSA *rsa = NULL;
91     if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, NULL, pubkey))
92         return 0;
93     if (!(rsa = d2i_RSAPublicKey(NULL, &p, pklen))) {
94         RSAerr(RSA_F_RSA_PUB_DECODE, ERR_R_RSA_LIB);
95         return 0;
96     }
97     EVP_PKEY_assign_RSA(pkey, rsa);
98     return 1;
99 }
100
101 static int rsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
102 {
103     if (BN_cmp(b->pkey.rsa->n, a->pkey.rsa->n) != 0
104         || BN_cmp(b->pkey.rsa->e, a->pkey.rsa->e) != 0)
105         return 0;
106     return 1;
107 }
108
109 static int old_rsa_priv_decode(EVP_PKEY *pkey,
110                                const unsigned char **pder, int derlen)
111 {
112     RSA *rsa;
113     if (!(rsa = d2i_RSAPrivateKey(NULL, pder, derlen))) {
114         RSAerr(RSA_F_OLD_RSA_PRIV_DECODE, ERR_R_RSA_LIB);
115         return 0;
116     }
117     EVP_PKEY_assign_RSA(pkey, rsa);
118     return 1;
119 }
120
121 static int old_rsa_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
122 {
123     return i2d_RSAPrivateKey(pkey->pkey.rsa, pder);
124 }
125
126 static int rsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
127 {
128     unsigned char *rk = NULL;
129     int rklen;
130     rklen = i2d_RSAPrivateKey(pkey->pkey.rsa, &rk);
131
132     if (rklen <= 0) {
133         RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
134         return 0;
135     }
136
137     if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_rsaEncryption), 0,
138                          V_ASN1_NULL, NULL, rk, rklen)) {
139         RSAerr(RSA_F_RSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
140         return 0;
141     }
142
143     return 1;
144 }
145
146 static int rsa_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
147 {
148     const unsigned char *p;
149     int pklen;
150     if (!PKCS8_pkey_get0(NULL, &p, &pklen, NULL, p8))
151         return 0;
152     return old_rsa_priv_decode(pkey, &p, pklen);
153 }
154
155 static int int_rsa_size(const EVP_PKEY *pkey)
156 {
157     return RSA_size(pkey->pkey.rsa);
158 }
159
160 static int rsa_bits(const EVP_PKEY *pkey)
161 {
162     return BN_num_bits(pkey->pkey.rsa->n);
163 }
164
165 static void int_rsa_free(EVP_PKEY *pkey)
166 {
167     RSA_free(pkey->pkey.rsa);
168 }
169
170 static void update_buflen(const BIGNUM *b, size_t *pbuflen)
171 {
172     size_t i;
173     if (!b)
174         return;
175     if (*pbuflen < (i = (size_t)BN_num_bytes(b)))
176         *pbuflen = i;
177 }
178
179 static int do_rsa_print(BIO *bp, const RSA *x, int off, int priv)
180 {
181     char *str;
182     const char *s;
183     unsigned char *m = NULL;
184     int ret = 0, mod_len = 0;
185     size_t buf_len = 0;
186
187     update_buflen(x->n, &buf_len);
188     update_buflen(x->e, &buf_len);
189
190     if (priv) {
191         update_buflen(x->d, &buf_len);
192         update_buflen(x->p, &buf_len);
193         update_buflen(x->q, &buf_len);
194         update_buflen(x->dmp1, &buf_len);
195         update_buflen(x->dmq1, &buf_len);
196         update_buflen(x->iqmp, &buf_len);
197     }
198
199     m = (unsigned char *)OPENSSL_malloc(buf_len + 10);
200     if (m == NULL) {
201         RSAerr(RSA_F_DO_RSA_PRINT, ERR_R_MALLOC_FAILURE);
202         goto err;
203     }
204
205     if (x->n != NULL)
206         mod_len = BN_num_bits(x->n);
207
208     if (!BIO_indent(bp, off, 128))
209         goto err;
210
211     if (priv && x->d) {
212         if (BIO_printf(bp, "Private-Key: (%d bit)\n", mod_len)
213             <= 0)
214             goto err;
215         str = "modulus:";
216         s = "publicExponent:";
217     } else {
218         if (BIO_printf(bp, "Public-Key: (%d bit)\n", mod_len)
219             <= 0)
220             goto err;
221         str = "Modulus:";
222         s = "Exponent:";
223     }
224     if (!ASN1_bn_print(bp, str, x->n, m, off))
225         goto err;
226     if (!ASN1_bn_print(bp, s, x->e, m, off))
227         goto err;
228     if (priv) {
229         if (!ASN1_bn_print(bp, "privateExponent:", x->d, m, off))
230             goto err;
231         if (!ASN1_bn_print(bp, "prime1:", x->p, m, off))
232             goto err;
233         if (!ASN1_bn_print(bp, "prime2:", x->q, m, off))
234             goto err;
235         if (!ASN1_bn_print(bp, "exponent1:", x->dmp1, m, off))
236             goto err;
237         if (!ASN1_bn_print(bp, "exponent2:", x->dmq1, m, off))
238             goto err;
239         if (!ASN1_bn_print(bp, "coefficient:", x->iqmp, m, off))
240             goto err;
241     }
242     ret = 1;
243  err:
244     if (m != NULL)
245         OPENSSL_free(m);
246     return (ret);
247 }
248
249 static int rsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
250                          ASN1_PCTX *ctx)
251 {
252     return do_rsa_print(bp, pkey->pkey.rsa, indent, 0);
253 }
254
255 static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
256                           ASN1_PCTX *ctx)
257 {
258     return do_rsa_print(bp, pkey->pkey.rsa, indent, 1);
259 }
260
261 static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
262                                       X509_ALGOR **pmaskHash)
263 {
264     const unsigned char *p;
265     int plen;
266     RSA_PSS_PARAMS *pss;
267
268     *pmaskHash = NULL;
269
270     if (!alg->parameter || alg->parameter->type != V_ASN1_SEQUENCE)
271         return NULL;
272     p = alg->parameter->value.sequence->data;
273     plen = alg->parameter->value.sequence->length;
274     pss = d2i_RSA_PSS_PARAMS(NULL, &p, plen);
275
276     if (!pss)
277         return NULL;
278
279     if (pss->maskGenAlgorithm) {
280         ASN1_TYPE *param = pss->maskGenAlgorithm->parameter;
281         if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) == NID_mgf1
282             && param && param->type == V_ASN1_SEQUENCE) {
283             p = param->value.sequence->data;
284             plen = param->value.sequence->length;
285             *pmaskHash = d2i_X509_ALGOR(NULL, &p, plen);
286         }
287     }
288
289     return pss;
290 }
291
292 static int rsa_pss_param_print(BIO *bp, RSA_PSS_PARAMS *pss,
293                                X509_ALGOR *maskHash, int indent)
294 {
295     int rv = 0;
296     if (!pss) {
297         if (BIO_puts(bp, " (INVALID PSS PARAMETERS)\n") <= 0)
298             return 0;
299         return 1;
300     }
301     if (BIO_puts(bp, "\n") <= 0)
302         goto err;
303     if (!BIO_indent(bp, indent, 128))
304         goto err;
305     if (BIO_puts(bp, "Hash Algorithm: ") <= 0)
306         goto err;
307
308     if (pss->hashAlgorithm) {
309         if (i2a_ASN1_OBJECT(bp, pss->hashAlgorithm->algorithm) <= 0)
310             goto err;
311     } else if (BIO_puts(bp, "sha1 (default)") <= 0)
312         goto err;
313
314     if (BIO_puts(bp, "\n") <= 0)
315         goto err;
316
317     if (!BIO_indent(bp, indent, 128))
318         goto err;
319
320     if (BIO_puts(bp, "Mask Algorithm: ") <= 0)
321         goto err;
322     if (pss->maskGenAlgorithm) {
323         if (i2a_ASN1_OBJECT(bp, pss->maskGenAlgorithm->algorithm) <= 0)
324             goto err;
325         if (BIO_puts(bp, " with ") <= 0)
326             goto err;
327         if (maskHash) {
328             if (i2a_ASN1_OBJECT(bp, maskHash->algorithm) <= 0)
329                 goto err;
330         } else if (BIO_puts(bp, "INVALID") <= 0)
331             goto err;
332     } else if (BIO_puts(bp, "mgf1 with sha1 (default)") <= 0)
333         goto err;
334     BIO_puts(bp, "\n");
335
336     if (!BIO_indent(bp, indent, 128))
337         goto err;
338     if (BIO_puts(bp, "Salt Length: 0x") <= 0)
339         goto err;
340     if (pss->saltLength) {
341         if (i2a_ASN1_INTEGER(bp, pss->saltLength) <= 0)
342             goto err;
343     } else if (BIO_puts(bp, "14 (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, "Trailer Field: 0x") <= 0)
350         goto err;
351     if (pss->trailerField) {
352         if (i2a_ASN1_INTEGER(bp, pss->trailerField) <= 0)
353             goto err;
354     } else if (BIO_puts(bp, "BC (default)") <= 0)
355         goto err;
356     BIO_puts(bp, "\n");
357
358     rv = 1;
359
360  err:
361     return rv;
362
363 }
364
365 static int rsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
366                          const ASN1_STRING *sig, int indent, ASN1_PCTX *pctx)
367 {
368     if (OBJ_obj2nid(sigalg->algorithm) == NID_rsassaPss) {
369         int rv;
370         RSA_PSS_PARAMS *pss;
371         X509_ALGOR *maskHash;
372         pss = rsa_pss_decode(sigalg, &maskHash);
373         rv = rsa_pss_param_print(bp, pss, maskHash, indent);
374         if (pss)
375             RSA_PSS_PARAMS_free(pss);
376         if (maskHash)
377             X509_ALGOR_free(maskHash);
378         if (!rv)
379             return 0;
380     } else if (!sig && BIO_puts(bp, "\n") <= 0)
381         return 0;
382     if (sig)
383         return X509_signature_dump(bp, sig, indent);
384     return 1;
385 }
386
387 static int rsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
388 {
389     X509_ALGOR *alg = NULL;
390     switch (op) {
391
392     case ASN1_PKEY_CTRL_PKCS7_SIGN:
393         if (arg1 == 0)
394             PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, NULL, &alg);
395         break;
396
397     case ASN1_PKEY_CTRL_PKCS7_ENCRYPT:
398         if (arg1 == 0)
399             PKCS7_RECIP_INFO_get0_alg(arg2, &alg);
400         break;
401 #ifndef OPENSSL_NO_CMS
402     case ASN1_PKEY_CTRL_CMS_SIGN:
403         if (arg1 == 0)
404             CMS_SignerInfo_get0_algs(arg2, NULL, NULL, NULL, &alg);
405         break;
406
407     case ASN1_PKEY_CTRL_CMS_ENVELOPE:
408         if (arg1 == 0)
409             CMS_RecipientInfo_ktri_get0_algs(arg2, NULL, NULL, &alg);
410         break;
411 #endif
412
413     case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
414         *(int *)arg2 = NID_sha1;
415         return 1;
416
417     default:
418         return -2;
419
420     }
421
422     if (alg)
423         X509_ALGOR_set0(alg, OBJ_nid2obj(NID_rsaEncryption), V_ASN1_NULL, 0);
424
425     return 1;
426
427 }
428
429 /*
430  * Customised RSA item verification routine. This is called when a signature
431  * is encountered requiring special handling. We currently only handle PSS.
432  */
433
434 static int rsa_item_verify(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
435                            X509_ALGOR *sigalg, ASN1_BIT_STRING *sig,
436                            EVP_PKEY *pkey)
437 {
438     int rv = -1;
439     int saltlen;
440     const EVP_MD *mgf1md = NULL, *md = NULL;
441     RSA_PSS_PARAMS *pss;
442     X509_ALGOR *maskHash;
443     EVP_PKEY_CTX *pkctx;
444     /* Sanity check: make sure it is PSS */
445     if (OBJ_obj2nid(sigalg->algorithm) != NID_rsassaPss) {
446         RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
447         return -1;
448     }
449     /* Decode PSS parameters */
450     pss = rsa_pss_decode(sigalg, &maskHash);
451
452     if (pss == NULL) {
453         RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_INVALID_PSS_PARAMETERS);
454         goto err;
455     }
456     /* Check mask and lookup mask hash algorithm */
457     if (pss->maskGenAlgorithm) {
458         if (OBJ_obj2nid(pss->maskGenAlgorithm->algorithm) != NID_mgf1) {
459             RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNSUPPORTED_MASK_ALGORITHM);
460             goto err;
461         }
462         if (!maskHash) {
463             RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNSUPPORTED_MASK_PARAMETER);
464             goto err;
465         }
466         mgf1md = EVP_get_digestbyobj(maskHash->algorithm);
467         if (mgf1md == NULL) {
468             RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNKNOWN_MASK_DIGEST);
469             goto err;
470         }
471     } else
472         mgf1md = EVP_sha1();
473
474     if (pss->hashAlgorithm) {
475         md = EVP_get_digestbyobj(pss->hashAlgorithm->algorithm);
476         if (md == NULL) {
477             RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_UNKNOWN_PSS_DIGEST);
478             goto err;
479         }
480     } else
481         md = EVP_sha1();
482
483     if (pss->saltLength) {
484         saltlen = ASN1_INTEGER_get(pss->saltLength);
485
486         /*
487          * Could perform more salt length sanity checks but the main RSA
488          * routines will trap other invalid values anyway.
489          */
490         if (saltlen < 0) {
491             RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_INVALID_SALT_LENGTH);
492             goto err;
493         }
494     } else
495         saltlen = 20;
496
497     /*
498      * low-level routines support only trailer field 0xbc (value 1) and
499      * PKCS#1 says we should reject any other value anyway.
500      */
501     if (pss->trailerField && ASN1_INTEGER_get(pss->trailerField) != 1) {
502         RSAerr(RSA_F_RSA_ITEM_VERIFY, RSA_R_INVALID_TRAILER);
503         goto err;
504     }
505
506     /* We have all parameters now set up context */
507
508     if (!EVP_DigestVerifyInit(ctx, &pkctx, md, NULL, pkey))
509         goto err;
510
511     if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_PSS_PADDING) <= 0)
512         goto err;
513
514     if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkctx, saltlen) <= 0)
515         goto err;
516
517     if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
518         goto err;
519     /* Carry on */
520     rv = 2;
521
522  err:
523     RSA_PSS_PARAMS_free(pss);
524     if (maskHash)
525         X509_ALGOR_free(maskHash);
526     return rv;
527 }
528
529 static int rsa_item_sign(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
530                          X509_ALGOR *alg1, X509_ALGOR *alg2,
531                          ASN1_BIT_STRING *sig)
532 {
533     int pad_mode;
534     EVP_PKEY_CTX *pkctx = ctx->pctx;
535     if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
536         return 0;
537     if (pad_mode == RSA_PKCS1_PADDING)
538         return 2;
539     if (pad_mode == RSA_PKCS1_PSS_PADDING) {
540         const EVP_MD *sigmd, *mgf1md;
541         RSA_PSS_PARAMS *pss = NULL;
542         X509_ALGOR *mgf1alg = NULL;
543         ASN1_STRING *os1 = NULL, *os2 = NULL;
544         EVP_PKEY *pk = EVP_PKEY_CTX_get0_pkey(pkctx);
545         int saltlen, rv = 0;
546         sigmd = EVP_MD_CTX_md(ctx);
547         if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
548             goto err;
549         if (!EVP_PKEY_CTX_get_rsa_pss_saltlen(pkctx, &saltlen))
550             goto err;
551         if (saltlen == -1)
552             saltlen = EVP_MD_size(sigmd);
553         else if (saltlen == -2) {
554             saltlen = EVP_PKEY_size(pk) - EVP_MD_size(sigmd) - 2;
555             if (((EVP_PKEY_bits(pk) - 1) & 0x7) == 0)
556                 saltlen--;
557         }
558         pss = RSA_PSS_PARAMS_new();
559         if (!pss)
560             goto err;
561         if (saltlen != 20) {
562             pss->saltLength = ASN1_INTEGER_new();
563             if (!pss->saltLength)
564                 goto err;
565             if (!ASN1_INTEGER_set(pss->saltLength, saltlen))
566                 goto err;
567         }
568         if (EVP_MD_type(sigmd) != NID_sha1) {
569             pss->hashAlgorithm = X509_ALGOR_new();
570             if (!pss->hashAlgorithm)
571                 goto err;
572             X509_ALGOR_set_md(pss->hashAlgorithm, sigmd);
573         }
574         if (EVP_MD_type(mgf1md) != NID_sha1) {
575             ASN1_STRING *stmp = NULL;
576             /* need to embed algorithm ID inside another */
577             mgf1alg = X509_ALGOR_new();
578             X509_ALGOR_set_md(mgf1alg, mgf1md);
579             if (!ASN1_item_pack(mgf1alg, ASN1_ITEM_rptr(X509_ALGOR), &stmp))
580                  goto err;
581             pss->maskGenAlgorithm = X509_ALGOR_new();
582             if (!pss->maskGenAlgorithm)
583                 goto err;
584             X509_ALGOR_set0(pss->maskGenAlgorithm,
585                             OBJ_nid2obj(NID_mgf1), V_ASN1_SEQUENCE, stmp);
586         }
587         /* Finally create string with pss parameter encoding. */
588         if (!ASN1_item_pack(pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), &os1))
589              goto err;
590         if (alg2) {
591             os2 = ASN1_STRING_dup(os1);
592             if (!os2)
593                 goto err;
594             X509_ALGOR_set0(alg2, OBJ_nid2obj(NID_rsassaPss),
595                             V_ASN1_SEQUENCE, os2);
596         }
597         X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_rsassaPss),
598                         V_ASN1_SEQUENCE, os1);
599         os1 = os2 = NULL;
600         rv = 3;
601  err:
602         if (mgf1alg)
603             X509_ALGOR_free(mgf1alg);
604         if (pss)
605             RSA_PSS_PARAMS_free(pss);
606         if (os1)
607             ASN1_STRING_free(os1);
608         return rv;
609
610     }
611     return 2;
612 }
613
614 const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[] = {
615     {
616      EVP_PKEY_RSA,
617      EVP_PKEY_RSA,
618      ASN1_PKEY_SIGPARAM_NULL,
619
620      "RSA",
621      "OpenSSL RSA method",
622
623      rsa_pub_decode,
624      rsa_pub_encode,
625      rsa_pub_cmp,
626      rsa_pub_print,
627
628      rsa_priv_decode,
629      rsa_priv_encode,
630      rsa_priv_print,
631
632      int_rsa_size,
633      rsa_bits,
634
635      0, 0, 0, 0, 0, 0,
636
637      rsa_sig_print,
638      int_rsa_free,
639      rsa_pkey_ctrl,
640      old_rsa_priv_decode,
641      old_rsa_priv_encode,
642      rsa_item_verify,
643      rsa_item_sign},
644
645     {
646      EVP_PKEY_RSA2,
647      EVP_PKEY_RSA,
648      ASN1_PKEY_ALIAS}
649 };