Branch data Line data Source code
1 : : /* crypto/rsa/rsa_pmeth.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 : : #include <openssl/evp.h>
66 : : #include <openssl/x509v3.h>
67 : : #ifndef OPENSSL_NO_CMS
68 : : #include <openssl/cms.h>
69 : : #endif
70 : : #include "evp_locl.h"
71 : : #include "rsa_locl.h"
72 : :
73 : : /* RSA pkey context structure */
74 : :
75 : : typedef struct
76 : : {
77 : : /* Key gen parameters */
78 : : int nbits;
79 : : BIGNUM *pub_exp;
80 : : /* Keygen callback info */
81 : : int gentmp[2];
82 : : /* RSA padding mode */
83 : : int pad_mode;
84 : : /* message digest */
85 : : const EVP_MD *md;
86 : : /* message digest for MGF1 */
87 : : const EVP_MD *mgf1md;
88 : : /* PSS salt length */
89 : : int saltlen;
90 : : /* Temp buffer */
91 : : unsigned char *tbuf;
92 : : /* OAEP label */
93 : : unsigned char *oaep_label;
94 : : size_t oaep_labellen;
95 : : } RSA_PKEY_CTX;
96 : :
97 : 2412 : static int pkey_rsa_init(EVP_PKEY_CTX *ctx)
98 : : {
99 : : RSA_PKEY_CTX *rctx;
100 : 2412 : rctx = OPENSSL_malloc(sizeof(RSA_PKEY_CTX));
101 [ + - ]: 2412 : if (!rctx)
102 : : return 0;
103 : 2412 : rctx->nbits = 1024;
104 : 2412 : rctx->pub_exp = NULL;
105 : 2412 : rctx->pad_mode = RSA_PKCS1_PADDING;
106 : 2412 : rctx->md = NULL;
107 : 2412 : rctx->mgf1md = NULL;
108 : 2412 : rctx->tbuf = NULL;
109 : :
110 : 2412 : rctx->saltlen = -2;
111 : :
112 : 2412 : rctx->oaep_label = NULL;
113 : 2412 : rctx->oaep_labellen = 0;
114 : :
115 : 2412 : ctx->data = rctx;
116 : 2412 : ctx->keygen_info = rctx->gentmp;
117 : 2412 : ctx->keygen_info_count = 2;
118 : :
119 : 2412 : return 1;
120 : : }
121 : :
122 : 939 : static int pkey_rsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
123 : : {
124 : : RSA_PKEY_CTX *dctx, *sctx;
125 [ + - ]: 939 : if (!pkey_rsa_init(dst))
126 : : return 0;
127 : 939 : sctx = src->data;
128 : 939 : dctx = dst->data;
129 : 939 : dctx->nbits = sctx->nbits;
130 [ - + ]: 939 : if (sctx->pub_exp)
131 : : {
132 : 0 : dctx->pub_exp = BN_dup(sctx->pub_exp);
133 [ # # ]: 0 : if (!dctx->pub_exp)
134 : : return 0;
135 : : }
136 : 939 : dctx->pad_mode = sctx->pad_mode;
137 : 939 : dctx->md = sctx->md;
138 : 939 : dctx->mgf1md = sctx->mgf1md;
139 [ - + ]: 939 : if (sctx->oaep_label)
140 : : {
141 [ # # ]: 0 : if (dctx->oaep_label)
142 : 0 : OPENSSL_free(dctx->oaep_label);
143 : 0 : dctx->oaep_label = BUF_memdup(sctx->oaep_label,
144 : : sctx->oaep_labellen);
145 [ # # ]: 0 : if (!dctx->oaep_label)
146 : : return 0;
147 : 0 : dctx->oaep_labellen = sctx->oaep_labellen;
148 : : }
149 : : return 1;
150 : : }
151 : :
152 : 20 : static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk)
153 : : {
154 [ + - ]: 10 : if (ctx->tbuf)
155 : : return 1;
156 : 10 : ctx->tbuf = OPENSSL_malloc(EVP_PKEY_size(pk->pkey));
157 [ + - ]: 10 : if (!ctx->tbuf)
158 : : return 0;
159 : : return 1;
160 : : }
161 : :
162 : 2412 : static void pkey_rsa_cleanup(EVP_PKEY_CTX *ctx)
163 : : {
164 : 2412 : RSA_PKEY_CTX *rctx = ctx->data;
165 [ + - ]: 2412 : if (rctx)
166 : : {
167 [ + + ]: 2412 : if (rctx->pub_exp)
168 : 10 : BN_free(rctx->pub_exp);
169 [ + + ]: 2412 : if (rctx->tbuf)
170 : 10 : OPENSSL_free(rctx->tbuf);
171 [ - + ]: 2412 : if (rctx->oaep_label)
172 : 0 : OPENSSL_free(rctx->oaep_label);
173 : 2412 : OPENSSL_free(rctx);
174 : : }
175 : 2412 : }
176 : :
177 : 232 : static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
178 : : const unsigned char *tbs, size_t tbslen)
179 : : {
180 : : int ret;
181 : 232 : RSA_PKEY_CTX *rctx = ctx->data;
182 : 232 : RSA *rsa = ctx->pkey->pkey.rsa;
183 : :
184 [ + - ]: 232 : if (rctx->md)
185 : : {
186 [ - + ]: 232 : if (tbslen != (size_t)EVP_MD_size(rctx->md))
187 : : {
188 : 0 : RSAerr(RSA_F_PKEY_RSA_SIGN,
189 : : RSA_R_INVALID_DIGEST_LENGTH);
190 : 0 : return -1;
191 : : }
192 : :
193 [ - + ]: 232 : if (EVP_MD_type(rctx->md) == NID_mdc2)
194 : : {
195 : : unsigned int sltmp;
196 [ # # ]: 0 : if (rctx->pad_mode != RSA_PKCS1_PADDING)
197 : 0 : return -1;
198 : 0 : ret = RSA_sign_ASN1_OCTET_STRING(NID_mdc2,
199 : : tbs, tbslen, sig, &sltmp, rsa);
200 : :
201 [ # # ]: 0 : if (ret <= 0)
202 : : return ret;
203 : 0 : ret = sltmp;
204 : : }
205 [ - + ]: 232 : else if (rctx->pad_mode == RSA_X931_PADDING)
206 : : {
207 [ # # ]: 0 : if (!setup_tbuf(rctx, ctx))
208 : : return -1;
209 : 0 : memcpy(rctx->tbuf, tbs, tbslen);
210 : 0 : rctx->tbuf[tbslen] =
211 : 0 : RSA_X931_hash_id(EVP_MD_type(rctx->md));
212 : 0 : ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf,
213 : : sig, rsa, RSA_X931_PADDING);
214 : : }
215 [ + + ]: 232 : else if (rctx->pad_mode == RSA_PKCS1_PADDING)
216 : : {
217 : : unsigned int sltmp;
218 : 229 : ret = RSA_sign(EVP_MD_type(rctx->md),
219 : : tbs, tbslen, sig, &sltmp, rsa);
220 [ - + ]: 229 : if (ret <= 0)
221 : 0 : return ret;
222 : 229 : ret = sltmp;
223 : : }
224 [ + - ]: 3 : else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING)
225 : : {
226 [ + - ]: 3 : if (!setup_tbuf(rctx, ctx))
227 : : return -1;
228 [ + - ]: 3 : if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa,
229 : : rctx->tbuf, tbs,
230 : : rctx->md, rctx->mgf1md,
231 : : rctx->saltlen))
232 : : return -1;
233 : 3 : ret = RSA_private_encrypt(RSA_size(rsa), rctx->tbuf,
234 : : sig, rsa, RSA_NO_PADDING);
235 : : }
236 : : else
237 : : return -1;
238 : : }
239 : : else
240 : 0 : ret = RSA_private_encrypt(tbslen, tbs, sig, ctx->pkey->pkey.rsa,
241 : : rctx->pad_mode);
242 [ + - ]: 232 : if (ret < 0)
243 : : return ret;
244 : 232 : *siglen = ret;
245 : 232 : return 1;
246 : : }
247 : :
248 : :
249 : 0 : static int pkey_rsa_verifyrecover(EVP_PKEY_CTX *ctx,
250 : : unsigned char *rout, size_t *routlen,
251 : : const unsigned char *sig, size_t siglen)
252 : : {
253 : : int ret;
254 : 0 : RSA_PKEY_CTX *rctx = ctx->data;
255 : :
256 [ # # ]: 0 : if (rctx->md)
257 : : {
258 [ # # ]: 0 : if (rctx->pad_mode == RSA_X931_PADDING)
259 : : {
260 [ # # ]: 0 : if (!setup_tbuf(rctx, ctx))
261 : : return -1;
262 : 0 : ret = RSA_public_decrypt(siglen, sig,
263 : 0 : rctx->tbuf, ctx->pkey->pkey.rsa,
264 : : RSA_X931_PADDING);
265 [ # # ]: 0 : if (ret < 1)
266 : : return 0;
267 : 0 : ret--;
268 [ # # ]: 0 : if (rctx->tbuf[ret] !=
269 : 0 : RSA_X931_hash_id(EVP_MD_type(rctx->md)))
270 : : {
271 : 0 : RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
272 : : RSA_R_ALGORITHM_MISMATCH);
273 : 0 : return 0;
274 : : }
275 [ # # ]: 0 : if (ret != EVP_MD_size(rctx->md))
276 : : {
277 : 0 : RSAerr(RSA_F_PKEY_RSA_VERIFYRECOVER,
278 : : RSA_R_INVALID_DIGEST_LENGTH);
279 : 0 : return 0;
280 : : }
281 [ # # ]: 0 : if (rout)
282 : 0 : memcpy(rout, rctx->tbuf, ret);
283 : : }
284 [ # # ]: 0 : else if (rctx->pad_mode == RSA_PKCS1_PADDING)
285 : : {
286 : : size_t sltmp;
287 : 0 : ret = int_rsa_verify(EVP_MD_type(rctx->md),
288 : : NULL, 0, rout, &sltmp,
289 : 0 : sig, siglen, ctx->pkey->pkey.rsa);
290 [ # # ]: 0 : if (ret <= 0)
291 : 0 : return 0;
292 : 0 : ret = sltmp;
293 : : }
294 : : else
295 : : return -1;
296 : : }
297 : : else
298 : 0 : ret = RSA_public_decrypt(siglen, sig, rout, ctx->pkey->pkey.rsa,
299 : : rctx->pad_mode);
300 [ # # ]: 0 : if (ret < 0)
301 : : return ret;
302 : 0 : *routlen = ret;
303 : 0 : return 1;
304 : : }
305 : :
306 : 1070 : static int pkey_rsa_verify(EVP_PKEY_CTX *ctx,
307 : : const unsigned char *sig, size_t siglen,
308 : : const unsigned char *tbs, size_t tbslen)
309 : : {
310 : 1070 : RSA_PKEY_CTX *rctx = ctx->data;
311 : 1070 : RSA *rsa = ctx->pkey->pkey.rsa;
312 : : size_t rslen;
313 [ + - ]: 1070 : if (rctx->md)
314 : : {
315 [ + + ]: 1070 : if (rctx->pad_mode == RSA_PKCS1_PADDING)
316 : 1067 : return RSA_verify(EVP_MD_type(rctx->md), tbs, tbslen,
317 : : sig, siglen, rsa);
318 [ - + ]: 3 : if (rctx->pad_mode == RSA_X931_PADDING)
319 : : {
320 [ # # ]: 0 : if (pkey_rsa_verifyrecover(ctx, NULL, &rslen,
321 : : sig, siglen) <= 0)
322 : : return 0;
323 : : }
324 [ + - ]: 3 : else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING)
325 : : {
326 : : int ret;
327 [ + - ]: 3 : if (!setup_tbuf(rctx, ctx))
328 : : return -1;
329 : 3 : ret = RSA_public_decrypt(siglen, sig, rctx->tbuf,
330 : : rsa, RSA_NO_PADDING);
331 [ + - ]: 3 : if (ret <= 0)
332 : : return 0;
333 : 3 : ret = RSA_verify_PKCS1_PSS_mgf1(rsa, tbs,
334 : : rctx->md, rctx->mgf1md,
335 : 3 : rctx->tbuf, rctx->saltlen);
336 [ + - ]: 3 : if (ret <= 0)
337 : : return 0;
338 : 3 : return 1;
339 : : }
340 : : else
341 : : return -1;
342 : : }
343 : : else
344 : : {
345 [ # # ]: 0 : if (!setup_tbuf(rctx, ctx))
346 : : return -1;
347 : 0 : rslen = RSA_public_decrypt(siglen, sig, rctx->tbuf,
348 : : rsa, rctx->pad_mode);
349 [ # # ]: 0 : if (rslen == 0)
350 : : return 0;
351 : : }
352 : :
353 [ # # ][ # # ]: 0 : if ((rslen != tbslen) || memcmp(tbs, rctx->tbuf, rslen))
354 : : return 0;
355 : :
356 : 0 : return 1;
357 : :
358 : : }
359 : :
360 : 41 : static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx,
361 : : unsigned char *out, size_t *outlen,
362 : : const unsigned char *in, size_t inlen)
363 : : {
364 : : int ret;
365 : 41 : RSA_PKEY_CTX *rctx = ctx->data;
366 [ + + ]: 41 : if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING)
367 : : {
368 : 2 : int klen = RSA_size(ctx->pkey->pkey.rsa);
369 [ + - ]: 2 : if (!setup_tbuf(rctx, ctx))
370 : : return -1;
371 [ + - ]: 2 : if (!RSA_padding_add_PKCS1_OAEP_mgf1(rctx->tbuf, klen,
372 : : in, inlen,
373 : 2 : rctx->oaep_label,
374 : 2 : rctx->oaep_labellen,
375 : : rctx->md, rctx->mgf1md))
376 : : return -1;
377 : 2 : ret = RSA_public_encrypt(klen, rctx->tbuf, out,
378 : 2 : ctx->pkey->pkey.rsa,
379 : : RSA_NO_PADDING);
380 : : }
381 : : else
382 : 39 : ret = RSA_public_encrypt(inlen, in, out, ctx->pkey->pkey.rsa,
383 : : rctx->pad_mode);
384 [ + - ]: 41 : if (ret < 0)
385 : : return ret;
386 : 41 : *outlen = ret;
387 : 41 : return 1;
388 : : }
389 : :
390 : 21 : static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx,
391 : : unsigned char *out, size_t *outlen,
392 : : const unsigned char *in, size_t inlen)
393 : : {
394 : : int ret;
395 : 21 : RSA_PKEY_CTX *rctx = ctx->data;
396 [ + + ]: 21 : if (rctx->pad_mode == RSA_PKCS1_OAEP_PADDING)
397 : : {
398 : : int i;
399 [ + - ]: 2 : if (!setup_tbuf(rctx, ctx))
400 : : return -1;
401 : 2 : ret = RSA_private_decrypt(inlen, in, rctx->tbuf,
402 : 2 : ctx->pkey->pkey.rsa,
403 : : RSA_NO_PADDING);
404 [ + - ]: 2 : if (ret <= 0)
405 : : return ret;
406 [ + - ]: 4 : for (i = 0; i < ret; i++)
407 : : {
408 [ + + ]: 4 : if (rctx->tbuf[i])
409 : : break;
410 : : }
411 : 2 : ret = RSA_padding_check_PKCS1_OAEP_mgf1(out,ret,rctx->tbuf + i,
412 : : ret - i, ret,
413 : 2 : rctx->oaep_label,
414 : 2 : rctx->oaep_labellen,
415 : : rctx->md, rctx->mgf1md);
416 : : }
417 : : else
418 : 19 : ret = RSA_private_decrypt(inlen, in, out, ctx->pkey->pkey.rsa,
419 : : rctx->pad_mode);
420 [ + + ]: 21 : if (ret < 0)
421 : : return ret;
422 : 15 : *outlen = ret;
423 : 15 : return 1;
424 : : }
425 : :
426 : 1411 : static int check_padding_md(const EVP_MD *md, int padding)
427 : : {
428 [ + + ]: 1411 : if (!md)
429 : : return 1;
430 : :
431 [ - + ]: 1407 : if (padding == RSA_NO_PADDING)
432 : : {
433 : 0 : RSAerr(RSA_F_CHECK_PADDING_MD, RSA_R_INVALID_PADDING_MODE);
434 : 0 : return 0;
435 : : }
436 : :
437 [ - + ]: 1407 : if (padding == RSA_X931_PADDING)
438 : : {
439 [ # # ]: 0 : if (RSA_X931_hash_id(EVP_MD_type(md)) == -1)
440 : : {
441 : 0 : RSAerr(RSA_F_CHECK_PADDING_MD,
442 : : RSA_R_INVALID_X931_DIGEST);
443 : 0 : return 0;
444 : : }
445 : : return 1;
446 : : }
447 : :
448 : : return 1;
449 : : }
450 : :
451 : :
452 : 2560 : static int pkey_rsa_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
453 : : {
454 : 2560 : RSA_PKEY_CTX *rctx = ctx->data;
455 [ + + + + : 2560 : switch (type)
- + + + +
+ + - -
+ ]
456 : : {
457 : : case EVP_PKEY_CTRL_RSA_PADDING:
458 [ + - ]: 10 : if ((p1 >= RSA_PKCS1_PADDING) && (p1 <= RSA_PKCS1_PSS_PADDING))
459 : : {
460 [ + - ]: 10 : if (!check_padding_md(rctx->md, p1))
461 : : return 0;
462 [ + + ]: 10 : if (p1 == RSA_PKCS1_PSS_PADDING)
463 : : {
464 [ + - ]: 6 : if (!(ctx->operation &
465 : : (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY)))
466 : : goto bad_pad;
467 [ - + ]: 6 : if (!rctx->md)
468 : 0 : rctx->md = EVP_sha1();
469 : : }
470 [ + + ]: 10 : if (p1 == RSA_PKCS1_OAEP_PADDING)
471 : : {
472 [ + - ]: 4 : if (!(ctx->operation & EVP_PKEY_OP_TYPE_CRYPT))
473 : : goto bad_pad;
474 [ + - ]: 4 : if (!rctx->md)
475 : 4 : rctx->md = EVP_sha1();
476 : : }
477 : 10 : rctx->pad_mode = p1;
478 : 10 : return 1;
479 : : }
480 : : bad_pad:
481 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL,
482 : : RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE);
483 : 0 : return -2;
484 : :
485 : : case EVP_PKEY_CTRL_GET_RSA_PADDING:
486 : 24 : *(int *)p2 = rctx->pad_mode;
487 : 24 : return 1;
488 : :
489 : : case EVP_PKEY_CTRL_RSA_PSS_SALTLEN:
490 : : case EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN:
491 [ - + ]: 6 : if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING)
492 : : {
493 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PSS_SALTLEN);
494 : 0 : return -2;
495 : : }
496 [ + + ]: 6 : if (type == EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN)
497 : 3 : *(int *)p2 = rctx->saltlen;
498 : : else
499 : : {
500 [ + - ]: 3 : if (p1 < -2)
501 : : return -2;
502 : 3 : rctx->saltlen = p1;
503 : : }
504 : : return 1;
505 : :
506 : : case EVP_PKEY_CTRL_RSA_KEYGEN_BITS:
507 [ - + ]: 10 : if (p1 < 256)
508 : : {
509 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_KEYBITS);
510 : 0 : return -2;
511 : : }
512 : 10 : rctx->nbits = p1;
513 : 10 : return 1;
514 : :
515 : : case EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP:
516 [ # # ]: 0 : if (!p2)
517 : : return -2;
518 : 0 : BN_free(rctx->pub_exp);
519 : 0 : rctx->pub_exp = p2;
520 : 0 : return 1;
521 : :
522 : : case EVP_PKEY_CTRL_RSA_OAEP_MD:
523 : : case EVP_PKEY_CTRL_GET_RSA_OAEP_MD:
524 [ - + ]: 5 : if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING)
525 : : {
526 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
527 : 0 : return -2;
528 : : }
529 [ + + ]: 5 : if (type == EVP_PKEY_CTRL_GET_RSA_OAEP_MD)
530 : 2 : *(const EVP_MD **)p2 = rctx->md;
531 : : else
532 : 3 : rctx->md = p2;
533 : : return 1;
534 : :
535 : : case EVP_PKEY_CTRL_MD:
536 [ + - ]: 1401 : if (!check_padding_md(p2, rctx->pad_mode))
537 : : return 0;
538 : 1401 : rctx->md = p2;
539 : 1401 : return 1;
540 : :
541 : : case EVP_PKEY_CTRL_GET_MD:
542 : 6 : *(const EVP_MD **)p2 = rctx->md;
543 : 6 : return 1;
544 : :
545 : : case EVP_PKEY_CTRL_RSA_MGF1_MD:
546 : : case EVP_PKEY_CTRL_GET_RSA_MGF1_MD:
547 [ - + ]: 11 : if (rctx->pad_mode != RSA_PKCS1_PSS_PADDING
548 : 11 : && rctx->pad_mode != RSA_PKCS1_OAEP_PADDING)
549 : : {
550 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_MGF1_MD);
551 : 0 : return -2;
552 : : }
553 [ + + ]: 11 : if (type == EVP_PKEY_CTRL_GET_RSA_MGF1_MD)
554 : : {
555 [ + + ]: 5 : if (rctx->mgf1md)
556 : 1 : *(const EVP_MD **)p2 = rctx->mgf1md;
557 : : else
558 : 4 : *(const EVP_MD **)p2 = rctx->md;
559 : : }
560 : : else
561 : 6 : rctx->mgf1md = p2;
562 : : return 1;
563 : :
564 : : case EVP_PKEY_CTRL_RSA_OAEP_LABEL:
565 [ - + ]: 2 : if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING)
566 : : {
567 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
568 : 0 : return -2;
569 : : }
570 [ - + ]: 2 : if (rctx->oaep_label)
571 : 0 : OPENSSL_free(rctx->oaep_label);
572 [ - + ]: 2 : if (p2 && p1 > 0)
573 : : {
574 : 0 : rctx->oaep_label = p2;
575 : 0 : rctx->oaep_labellen = p1;
576 : : }
577 : : else
578 : : {
579 : 2 : rctx->oaep_label = NULL;
580 : 2 : rctx->oaep_labellen = 0;
581 : : }
582 : : return 1;
583 : :
584 : : case EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL:
585 [ - + ]: 2 : if (rctx->pad_mode != RSA_PKCS1_OAEP_PADDING)
586 : : {
587 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL, RSA_R_INVALID_PADDING_MODE);
588 : 0 : return -2;
589 : : }
590 : 2 : *(unsigned char **)p2 = rctx->oaep_label;
591 : 2 : return rctx->oaep_labellen;
592 : :
593 : : case EVP_PKEY_CTRL_DIGESTINIT:
594 : : case EVP_PKEY_CTRL_PKCS7_ENCRYPT:
595 : : case EVP_PKEY_CTRL_PKCS7_DECRYPT:
596 : : case EVP_PKEY_CTRL_PKCS7_SIGN:
597 : : return 1;
598 : : #ifndef OPENSSL_NO_CMS
599 : : case EVP_PKEY_CTRL_CMS_DECRYPT:
600 : : case EVP_PKEY_CTRL_CMS_ENCRYPT:
601 : : case EVP_PKEY_CTRL_CMS_SIGN:
602 : : return 1;
603 : : #endif
604 : : case EVP_PKEY_CTRL_PEER_KEY:
605 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL,
606 : : RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
607 : 0 : return -2;
608 : :
609 : : default:
610 : 0 : return -2;
611 : :
612 : : }
613 : : }
614 : :
615 : 7 : static int pkey_rsa_ctrl_str(EVP_PKEY_CTX *ctx,
616 : : const char *type, const char *value)
617 : : {
618 [ - + ]: 7 : if (!value)
619 : : {
620 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL_STR, RSA_R_VALUE_MISSING);
621 : 0 : return 0;
622 : : }
623 [ + + ]: 7 : if (!strcmp(type, "rsa_padding_mode"))
624 : : {
625 : : int pm;
626 [ + - ]: 5 : if (!strcmp(value, "pkcs1"))
627 : : pm = RSA_PKCS1_PADDING;
628 [ + - ]: 5 : else if (!strcmp(value, "sslv23"))
629 : : pm = RSA_SSLV23_PADDING;
630 [ + - ]: 5 : else if (!strcmp(value, "none"))
631 : : pm = RSA_NO_PADDING;
632 [ + - ]: 5 : else if (!strcmp(value, "oeap"))
633 : : pm = RSA_PKCS1_OAEP_PADDING;
634 [ + + ]: 5 : else if (!strcmp(value, "oaep"))
635 : : pm = RSA_PKCS1_OAEP_PADDING;
636 [ + - ]: 3 : else if (!strcmp(value, "x931"))
637 : : pm = RSA_X931_PADDING;
638 [ - + ]: 3 : else if (!strcmp(value, "pss"))
639 : : pm = RSA_PKCS1_PSS_PADDING;
640 : : else
641 : : {
642 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL_STR,
643 : : RSA_R_UNKNOWN_PADDING_TYPE);
644 : 0 : return -2;
645 : : }
646 : 5 : return EVP_PKEY_CTX_set_rsa_padding(ctx, pm);
647 : : }
648 : :
649 [ - + ]: 2 : if (!strcmp(type, "rsa_pss_saltlen"))
650 : : {
651 : : int saltlen;
652 : 0 : saltlen = atoi(value);
653 : 0 : return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, saltlen);
654 : : }
655 : :
656 [ - + ]: 2 : if (!strcmp(type, "rsa_keygen_bits"))
657 : : {
658 : : int nbits;
659 : 0 : nbits = atoi(value);
660 : 0 : return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nbits);
661 : : }
662 : :
663 [ - + ]: 2 : if (!strcmp(type, "rsa_keygen_pubexp"))
664 : : {
665 : : int ret;
666 : 0 : BIGNUM *pubexp = NULL;
667 [ # # ]: 0 : if (!BN_asc2bn(&pubexp, value))
668 : : return 0;
669 : 0 : ret = EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp);
670 [ # # ]: 0 : if (ret <= 0)
671 : 0 : BN_free(pubexp);
672 : 0 : return ret;
673 : : }
674 : :
675 [ + + ]: 2 : if (!strcmp(type, "rsa_mgf1_md"))
676 : : {
677 : : const EVP_MD *md;
678 [ - + ]: 1 : if (!(md = EVP_get_digestbyname(value)))
679 : : {
680 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL_STR,
681 : : RSA_R_INVALID_DIGEST);
682 : 0 : return 0;
683 : : }
684 : 1 : return EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md);
685 : : }
686 : :
687 [ + - ]: 1 : if (!strcmp(type, "rsa_oaep_md"))
688 : : {
689 : : const EVP_MD *md;
690 [ - + ]: 1 : if (!(md = EVP_get_digestbyname(value)))
691 : : {
692 : 0 : RSAerr(RSA_F_PKEY_RSA_CTRL_STR,
693 : : RSA_R_INVALID_DIGEST);
694 : 0 : return 0;
695 : : }
696 : 1 : return EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md);
697 : : }
698 [ # # ]: 0 : if (!strcmp(type, "rsa_oaep_label"))
699 : : {
700 : : unsigned char *lab;
701 : : long lablen;
702 : : int ret;
703 : 0 : lab = string_to_hex(value, &lablen);
704 [ # # ]: 0 : if (!lab)
705 : : return 0;
706 : 0 : ret = EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, lab, lablen);
707 [ # # ]: 0 : if (ret <= 0)
708 : 0 : OPENSSL_free(lab);
709 : 0 : return ret;
710 : : }
711 : :
712 : : return -2;
713 : : }
714 : :
715 : 10 : static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
716 : : {
717 : 10 : RSA *rsa = NULL;
718 : 10 : RSA_PKEY_CTX *rctx = ctx->data;
719 : : BN_GENCB *pcb, cb;
720 : : int ret;
721 [ + - ]: 10 : if (!rctx->pub_exp)
722 : : {
723 : 10 : rctx->pub_exp = BN_new();
724 [ + - ][ + - ]: 10 : if (!rctx->pub_exp || !BN_set_word(rctx->pub_exp, RSA_F4))
725 : : return 0;
726 : : }
727 : 10 : rsa = RSA_new();
728 [ + - ]: 10 : if (!rsa)
729 : : return 0;
730 [ + - ]: 10 : if (ctx->pkey_gencb)
731 : : {
732 : 10 : pcb = &cb;
733 : 10 : evp_pkey_set_cb_translate(pcb, ctx);
734 : : }
735 : : else
736 : : pcb = NULL;
737 : 10 : ret = RSA_generate_key_ex(rsa, rctx->nbits, rctx->pub_exp, pcb);
738 [ + - ]: 10 : if (ret > 0)
739 : 10 : EVP_PKEY_assign_RSA(pkey, rsa);
740 : : else
741 : 0 : RSA_free(rsa);
742 : 10 : return ret;
743 : : }
744 : :
745 : : const EVP_PKEY_METHOD rsa_pkey_meth =
746 : : {
747 : : EVP_PKEY_RSA,
748 : : EVP_PKEY_FLAG_AUTOARGLEN,
749 : : pkey_rsa_init,
750 : : pkey_rsa_copy,
751 : : pkey_rsa_cleanup,
752 : :
753 : : 0,0,
754 : :
755 : : 0,
756 : : pkey_rsa_keygen,
757 : :
758 : : 0,
759 : : pkey_rsa_sign,
760 : :
761 : : 0,
762 : : pkey_rsa_verify,
763 : :
764 : : 0,
765 : : pkey_rsa_verifyrecover,
766 : :
767 : :
768 : : 0,0,0,0,
769 : :
770 : : 0,
771 : : pkey_rsa_encrypt,
772 : :
773 : : 0,
774 : : pkey_rsa_decrypt,
775 : :
776 : : 0,0,
777 : :
778 : : pkey_rsa_ctrl,
779 : : pkey_rsa_ctrl_str
780 : :
781 : :
782 : : };
|
