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