Branch data Line data Source code
1 : : /* crypto/rsa/rsa_eay.c */
2 : : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 : : * All rights reserved.
4 : : *
5 : : * This package is an SSL implementation written
6 : : * by Eric Young (eay@cryptsoft.com).
7 : : * The implementation was written so as to conform with Netscapes SSL.
8 : : *
9 : : * This library is free for commercial and non-commercial use as long as
10 : : * the following conditions are aheared to. The following conditions
11 : : * apply to all code found in this distribution, be it the RC4, RSA,
12 : : * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 : : * included with this distribution is covered by the same copyright terms
14 : : * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 : : *
16 : : * Copyright remains Eric Young's, and as such any Copyright notices in
17 : : * the code are not to be removed.
18 : : * If this package is used in a product, Eric Young should be given attribution
19 : : * as the author of the parts of the library used.
20 : : * This can be in the form of a textual message at program startup or
21 : : * in documentation (online or textual) provided with the package.
22 : : *
23 : : * Redistribution and use in source and binary forms, with or without
24 : : * modification, are permitted provided that the following conditions
25 : : * are met:
26 : : * 1. Redistributions of source code must retain the copyright
27 : : * notice, this list of conditions and the following disclaimer.
28 : : * 2. Redistributions in binary form must reproduce the above copyright
29 : : * notice, this list of conditions and the following disclaimer in the
30 : : * documentation and/or other materials provided with the distribution.
31 : : * 3. All advertising materials mentioning features or use of this software
32 : : * must display the following acknowledgement:
33 : : * "This product includes cryptographic software written by
34 : : * Eric Young (eay@cryptsoft.com)"
35 : : * The word 'cryptographic' can be left out if the rouines from the library
36 : : * being used are not cryptographic related :-).
37 : : * 4. If you include any Windows specific code (or a derivative thereof) from
38 : : * the apps directory (application code) you must include an acknowledgement:
39 : : * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 : : *
41 : : * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 : : * SUCH DAMAGE.
52 : : *
53 : : * The licence and distribution terms for any publically available version or
54 : : * derivative of this code cannot be changed. i.e. this code cannot simply be
55 : : * copied and put under another distribution licence
56 : : * [including the GNU Public Licence.]
57 : : */
58 : : /* ====================================================================
59 : : * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
60 : : *
61 : : * Redistribution and use in source and binary forms, with or without
62 : : * modification, are permitted provided that the following conditions
63 : : * are met:
64 : : *
65 : : * 1. Redistributions of source code must retain the above copyright
66 : : * notice, this list of conditions and the following disclaimer.
67 : : *
68 : : * 2. Redistributions in binary form must reproduce the above copyright
69 : : * notice, this list of conditions and the following disclaimer in
70 : : * the documentation and/or other materials provided with the
71 : : * distribution.
72 : : *
73 : : * 3. All advertising materials mentioning features or use of this
74 : : * software must display the following acknowledgment:
75 : : * "This product includes software developed by the OpenSSL Project
76 : : * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77 : : *
78 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 : : * endorse or promote products derived from this software without
80 : : * prior written permission. For written permission, please contact
81 : : * openssl-core@openssl.org.
82 : : *
83 : : * 5. Products derived from this software may not be called "OpenSSL"
84 : : * nor may "OpenSSL" appear in their names without prior written
85 : : * permission of the OpenSSL Project.
86 : : *
87 : : * 6. Redistributions of any form whatsoever must retain the following
88 : : * acknowledgment:
89 : : * "This product includes software developed by the OpenSSL Project
90 : : * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91 : : *
92 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
104 : : * ====================================================================
105 : : *
106 : : * This product includes cryptographic software written by Eric Young
107 : : * (eay@cryptsoft.com). This product includes software written by Tim
108 : : * Hudson (tjh@cryptsoft.com).
109 : : *
110 : : */
111 : :
112 : : #define OPENSSL_FIPSAPI
113 : :
114 : : #include <stdio.h>
115 : : #include "cryptlib.h"
116 : : #include <openssl/bn.h>
117 : : #include <openssl/rsa.h>
118 : : #include <openssl/rand.h>
119 : : #ifdef OPENSSL_FIPS
120 : : #include <openssl/fips.h>
121 : : #endif
122 : :
123 : : #ifndef RSA_NULL
124 : :
125 : : static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
126 : : unsigned char *to, RSA *rsa,int padding);
127 : : static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
128 : : unsigned char *to, RSA *rsa,int padding);
129 : : static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
130 : : unsigned char *to, RSA *rsa,int padding);
131 : : static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
132 : : unsigned char *to, RSA *rsa,int padding);
133 : : static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *i, RSA *rsa, BN_CTX *ctx);
134 : : static int RSA_eay_init(RSA *rsa);
135 : : static int RSA_eay_finish(RSA *rsa);
136 : : static RSA_METHOD rsa_pkcs1_eay_meth={
137 : : "Eric Young's PKCS#1 RSA",
138 : : RSA_eay_public_encrypt,
139 : : RSA_eay_public_decrypt, /* signature verification */
140 : : RSA_eay_private_encrypt, /* signing */
141 : : RSA_eay_private_decrypt,
142 : : RSA_eay_mod_exp,
143 : : BN_mod_exp_mont, /* XXX probably we should not use Montgomery if e == 3 */
144 : : RSA_eay_init,
145 : : RSA_eay_finish,
146 : : RSA_FLAG_FIPS_METHOD, /* flags */
147 : : NULL,
148 : : 0, /* rsa_sign */
149 : : 0, /* rsa_verify */
150 : : NULL /* rsa_keygen */
151 : : };
152 : :
153 : 6219 : const RSA_METHOD *RSA_PKCS1_SSLeay(void)
154 : : {
155 : 6219 : return(&rsa_pkcs1_eay_meth);
156 : : }
157 : :
158 : 528 : static int RSA_eay_public_encrypt(int flen, const unsigned char *from,
159 : : unsigned char *to, RSA *rsa, int padding)
160 : : {
161 : : BIGNUM *f,*ret;
162 : 528 : int i,j,k,num=0,r= -1;
163 : 528 : unsigned char *buf=NULL;
164 : 528 : BN_CTX *ctx=NULL;
165 : :
166 : : #ifdef OPENSSL_FIPS
167 : : if(FIPS_selftest_failed())
168 : : {
169 : : FIPSerr(FIPS_F_RSA_EAY_PUBLIC_ENCRYPT,FIPS_R_FIPS_SELFTEST_FAILED);
170 : : goto err;
171 : : }
172 : :
173 : : if (FIPS_module_mode() && !(rsa->flags & RSA_FLAG_NON_FIPS_ALLOW)
174 : : && (BN_num_bits(rsa->n) < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS))
175 : : {
176 : : RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_KEY_SIZE_TOO_SMALL);
177 : : return -1;
178 : : }
179 : : #endif
180 : :
181 [ - + ]: 528 : if (BN_num_bits(rsa->n) > OPENSSL_RSA_MAX_MODULUS_BITS)
182 : : {
183 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_MODULUS_TOO_LARGE);
184 : 0 : return -1;
185 : : }
186 : :
187 [ - + ]: 528 : if (BN_ucmp(rsa->n, rsa->e) <= 0)
188 : : {
189 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_BAD_E_VALUE);
190 : 0 : return -1;
191 : : }
192 : :
193 : : /* for large moduli, enforce exponent limit */
194 [ - + ]: 528 : if (BN_num_bits(rsa->n) > OPENSSL_RSA_SMALL_MODULUS_BITS)
195 : : {
196 [ # # ]: 0 : if (BN_num_bits(rsa->e) > OPENSSL_RSA_MAX_PUBEXP_BITS)
197 : : {
198 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT, RSA_R_BAD_E_VALUE);
199 : 0 : return -1;
200 : : }
201 : : }
202 : :
203 [ + - ]: 528 : if ((ctx=BN_CTX_new()) == NULL) goto err;
204 : 528 : BN_CTX_start(ctx);
205 : 528 : f = BN_CTX_get(ctx);
206 : 528 : ret = BN_CTX_get(ctx);
207 : 528 : num=BN_num_bytes(rsa->n);
208 : 528 : buf = OPENSSL_malloc(num);
209 [ + - ][ - + ]: 528 : if (!f || !ret || !buf)
210 : : {
211 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,ERR_R_MALLOC_FAILURE);
212 : 0 : goto err;
213 : : }
214 : :
215 [ + + - + : 528 : switch (padding)
- ]
216 : : {
217 : : case RSA_PKCS1_PADDING:
218 : 520 : i=RSA_padding_add_PKCS1_type_2(buf,num,from,flen);
219 : 520 : break;
220 : : #ifndef OPENSSL_NO_SHA
221 : : case RSA_PKCS1_OAEP_PADDING:
222 : 6 : i=RSA_padding_add_PKCS1_OAEP(buf,num,from,flen,NULL,0);
223 : 6 : break;
224 : : #endif
225 : : case RSA_SSLV23_PADDING:
226 : 0 : i=RSA_padding_add_SSLv23(buf,num,from,flen);
227 : 0 : break;
228 : : case RSA_NO_PADDING:
229 : 2 : i=RSA_padding_add_none(buf,num,from,flen);
230 : 2 : break;
231 : : default:
232 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
233 : 0 : goto err;
234 : : }
235 [ + - ]: 528 : if (i <= 0) goto err;
236 : :
237 [ + - ]: 528 : if (BN_bin2bn(buf,num,f) == NULL) goto err;
238 : :
239 [ - + ]: 528 : if (BN_ucmp(f, rsa->n) >= 0)
240 : : {
241 : : /* usually the padding functions would catch this */
242 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
243 : 0 : goto err;
244 : : }
245 : :
246 [ + - ]: 528 : if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
247 [ + - ]: 528 : if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
248 : : goto err;
249 : :
250 [ + - ]: 528 : if (!rsa->meth->bn_mod_exp(ret,f,rsa->e,rsa->n,ctx,
251 : : rsa->_method_mod_n)) goto err;
252 : :
253 : : /* put in leading 0 bytes if the number is less than the
254 : : * length of the modulus */
255 : 528 : j=BN_num_bytes(ret);
256 : 528 : i=BN_bn2bin(ret,&(to[num-j]));
257 [ + + ]: 533 : for (k=0; k<(num-i); k++)
258 : 5 : to[k]=0;
259 : :
260 : : r=num;
261 : : err:
262 [ + - ]: 528 : if (ctx != NULL)
263 : : {
264 : 528 : BN_CTX_end(ctx);
265 : 528 : BN_CTX_free(ctx);
266 : : }
267 [ + - ]: 528 : if (buf != NULL)
268 : : {
269 : 528 : OPENSSL_cleanse(buf,num);
270 : 528 : OPENSSL_free(buf);
271 : : }
272 : 528 : return(r);
273 : : }
274 : :
275 : 1332 : static BN_BLINDING *rsa_get_blinding(RSA *rsa, int *local, BN_CTX *ctx)
276 : : {
277 : : BN_BLINDING *ret;
278 : 1332 : int got_write_lock = 0;
279 : : CRYPTO_THREADID cur;
280 : :
281 : 1332 : CRYPTO_r_lock(CRYPTO_LOCK_RSA);
282 : :
283 [ + + ]: 1332 : if (rsa->blinding == NULL)
284 : : {
285 : 1102 : CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
286 : 1102 : CRYPTO_w_lock(CRYPTO_LOCK_RSA);
287 : 1102 : got_write_lock = 1;
288 : :
289 [ + - ]: 1102 : if (rsa->blinding == NULL)
290 : 1102 : rsa->blinding = RSA_setup_blinding(rsa, ctx);
291 : : }
292 : :
293 : 1332 : ret = rsa->blinding;
294 [ + - ]: 1332 : if (ret == NULL)
295 : : goto err;
296 : :
297 : 1332 : CRYPTO_THREADID_current(&cur);
298 [ + - ]: 1332 : if (!CRYPTO_THREADID_cmp(&cur, BN_BLINDING_thread_id(ret)))
299 : : {
300 : : /* rsa->blinding is ours! */
301 : :
302 : 1332 : *local = 1;
303 : : }
304 : : else
305 : : {
306 : : /* resort to rsa->mt_blinding instead */
307 : :
308 : 0 : *local = 0; /* instructs rsa_blinding_convert(), rsa_blinding_invert()
309 : : * that the BN_BLINDING is shared, meaning that accesses
310 : : * require locks, and that the blinding factor must be
311 : : * stored outside the BN_BLINDING
312 : : */
313 : :
314 [ # # ]: 0 : if (rsa->mt_blinding == NULL)
315 : : {
316 [ # # ]: 0 : if (!got_write_lock)
317 : : {
318 : 0 : CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
319 : 0 : CRYPTO_w_lock(CRYPTO_LOCK_RSA);
320 : 0 : got_write_lock = 1;
321 : : }
322 : :
323 [ # # ]: 0 : if (rsa->mt_blinding == NULL)
324 : 0 : rsa->mt_blinding = RSA_setup_blinding(rsa, ctx);
325 : : }
326 : 0 : ret = rsa->mt_blinding;
327 : : }
328 : :
329 : : err:
330 [ + + ]: 1332 : if (got_write_lock)
331 : 1102 : CRYPTO_w_unlock(CRYPTO_LOCK_RSA);
332 : : else
333 : 230 : CRYPTO_r_unlock(CRYPTO_LOCK_RSA);
334 : 1332 : return ret;
335 : : }
336 : :
337 : 1332 : static int rsa_blinding_convert(BN_BLINDING *b, BIGNUM *f, BIGNUM *unblind,
338 : : BN_CTX *ctx)
339 : : {
340 [ + - ]: 1332 : if (unblind == NULL)
341 : : /* Local blinding: store the unblinding factor
342 : : * in BN_BLINDING. */
343 : 1332 : return BN_BLINDING_convert_ex(f, NULL, b, ctx);
344 : : else
345 : : {
346 : : /* Shared blinding: store the unblinding factor
347 : : * outside BN_BLINDING. */
348 : : int ret;
349 : 0 : CRYPTO_w_lock(CRYPTO_LOCK_RSA_BLINDING);
350 : 0 : ret = BN_BLINDING_convert_ex(f, unblind, b, ctx);
351 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_RSA_BLINDING);
352 : 0 : return ret;
353 : : }
354 : : }
355 : :
356 : 1332 : static int rsa_blinding_invert(BN_BLINDING *b, BIGNUM *f, BIGNUM *unblind,
357 : : BN_CTX *ctx)
358 : : {
359 : : /* For local blinding, unblind is set to NULL, and BN_BLINDING_invert_ex
360 : : * will use the unblinding factor stored in BN_BLINDING.
361 : : * If BN_BLINDING is shared between threads, unblind must be non-null:
362 : : * BN_BLINDING_invert_ex will then use the local unblinding factor,
363 : : * and will only read the modulus from BN_BLINDING.
364 : : * In both cases it's safe to access the blinding without a lock.
365 : : */
366 : 1332 : return BN_BLINDING_invert_ex(f, unblind, b, ctx);
367 : : }
368 : :
369 : : /* signing */
370 : 815 : static int RSA_eay_private_encrypt(int flen, const unsigned char *from,
371 : : unsigned char *to, RSA *rsa, int padding)
372 : : {
373 : : BIGNUM *f, *ret, *res;
374 : 815 : int i,j,k,num=0,r= -1;
375 : 815 : unsigned char *buf=NULL;
376 : 815 : BN_CTX *ctx=NULL;
377 : 815 : int local_blinding = 0;
378 : : /* Used only if the blinding structure is shared. A non-NULL unblind
379 : : * instructs rsa_blinding_convert() and rsa_blinding_invert() to store
380 : : * the unblinding factor outside the blinding structure. */
381 : 815 : BIGNUM *unblind = NULL;
382 : 815 : BN_BLINDING *blinding = NULL;
383 : :
384 : : #ifdef OPENSSL_FIPS
385 : : if(FIPS_selftest_failed())
386 : : {
387 : : FIPSerr(FIPS_F_RSA_EAY_PRIVATE_ENCRYPT,FIPS_R_FIPS_SELFTEST_FAILED);
388 : : goto err;
389 : : }
390 : :
391 : : if (FIPS_module_mode() && !(rsa->flags & RSA_FLAG_NON_FIPS_ALLOW)
392 : : && (BN_num_bits(rsa->n) < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS))
393 : : {
394 : : RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT, RSA_R_KEY_SIZE_TOO_SMALL);
395 : : return -1;
396 : : }
397 : : #endif
398 : :
399 [ + - ]: 815 : if ((ctx=BN_CTX_new()) == NULL) goto err;
400 : 815 : BN_CTX_start(ctx);
401 : 815 : f = BN_CTX_get(ctx);
402 : 815 : ret = BN_CTX_get(ctx);
403 : 815 : num = BN_num_bytes(rsa->n);
404 : 815 : buf = OPENSSL_malloc(num);
405 [ + - ][ - + ]: 815 : if(!f || !ret || !buf)
406 : : {
407 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
408 : 0 : goto err;
409 : : }
410 : :
411 [ + - + - ]: 815 : switch (padding)
412 : : {
413 : : case RSA_PKCS1_PADDING:
414 : 812 : i=RSA_padding_add_PKCS1_type_1(buf,num,from,flen);
415 : 812 : break;
416 : : case RSA_X931_PADDING:
417 : 0 : i=RSA_padding_add_X931(buf,num,from,flen);
418 : 0 : break;
419 : : case RSA_NO_PADDING:
420 : 3 : i=RSA_padding_add_none(buf,num,from,flen);
421 : 3 : break;
422 : : case RSA_SSLV23_PADDING:
423 : : default:
424 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
425 : 0 : goto err;
426 : : }
427 [ + - ]: 815 : if (i <= 0) goto err;
428 : :
429 [ + - ]: 815 : if (BN_bin2bn(buf,num,f) == NULL) goto err;
430 : :
431 [ - + ]: 815 : if (BN_ucmp(f, rsa->n) >= 0)
432 : : {
433 : : /* usually the padding functions would catch this */
434 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
435 : 0 : goto err;
436 : : }
437 : :
438 [ + - ]: 815 : if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
439 : : {
440 : 815 : blinding = rsa_get_blinding(rsa, &local_blinding, ctx);
441 [ - + ]: 815 : if (blinding == NULL)
442 : : {
443 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT, ERR_R_INTERNAL_ERROR);
444 : 0 : goto err;
445 : : }
446 : : }
447 : :
448 [ + - ]: 815 : if (blinding != NULL)
449 : : {
450 [ - + ][ # # ]: 815 : if (!local_blinding && ((unblind = BN_CTX_get(ctx)) == NULL))
451 : : {
452 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
453 : 0 : goto err;
454 : : }
455 [ + - ]: 815 : if (!rsa_blinding_convert(blinding, f, unblind, ctx))
456 : : goto err;
457 : : }
458 : :
459 [ + - ][ + - ]: 815 : if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
460 [ + - ]: 815 : ((rsa->p != NULL) &&
461 [ + - ]: 815 : (rsa->q != NULL) &&
462 [ + - ]: 815 : (rsa->dmp1 != NULL) &&
463 [ + - ]: 815 : (rsa->dmq1 != NULL) &&
464 : 815 : (rsa->iqmp != NULL)) )
465 : : {
466 [ + - ]: 815 : if (!rsa->meth->rsa_mod_exp(ret, f, rsa, ctx)) goto err;
467 : : }
468 : : else
469 : : {
470 : : BIGNUM local_d;
471 : 0 : BIGNUM *d = NULL;
472 : :
473 [ # # ]: 0 : if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
474 : : {
475 : 0 : BN_init(&local_d);
476 : 0 : d = &local_d;
477 : 0 : BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
478 : : }
479 : : else
480 : 0 : d= rsa->d;
481 : :
482 [ # # ]: 0 : if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
483 [ # # ]: 0 : if(!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
484 : : goto err;
485 : :
486 [ # # ]: 0 : if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
487 : : rsa->_method_mod_n)) goto err;
488 : : }
489 : :
490 [ + - ]: 815 : if (blinding)
491 [ + - ]: 815 : if (!rsa_blinding_invert(blinding, ret, unblind, ctx))
492 : : goto err;
493 : :
494 [ - + ]: 815 : if (padding == RSA_X931_PADDING)
495 : : {
496 : 0 : BN_sub(f, rsa->n, ret);
497 [ # # ]: 0 : if (BN_cmp(ret, f) > 0)
498 : : res = f;
499 : : else
500 : 0 : res = ret;
501 : : }
502 : : else
503 : : res = ret;
504 : :
505 : : /* put in leading 0 bytes if the number is less than the
506 : : * length of the modulus */
507 : 815 : j=BN_num_bytes(res);
508 : 815 : i=BN_bn2bin(res,&(to[num-j]));
509 [ + + ]: 821 : for (k=0; k<(num-i); k++)
510 : 6 : to[k]=0;
511 : :
512 : : r=num;
513 : : err:
514 [ + - ]: 815 : if (ctx != NULL)
515 : : {
516 : 815 : BN_CTX_end(ctx);
517 : 815 : BN_CTX_free(ctx);
518 : : }
519 [ + - ]: 815 : if (buf != NULL)
520 : : {
521 : 815 : OPENSSL_cleanse(buf,num);
522 : 815 : OPENSSL_free(buf);
523 : : }
524 : 815 : return(r);
525 : : }
526 : :
527 : 123934 : static int RSA_eay_private_decrypt(int flen, const unsigned char *from,
528 : : unsigned char *to, RSA *rsa, int padding)
529 : : {
530 : : BIGNUM *f, *ret;
531 : 123934 : int j,num=0,r= -1;
532 : : unsigned char *p;
533 : 123934 : unsigned char *buf=NULL;
534 : 123934 : BN_CTX *ctx=NULL;
535 : 123934 : int local_blinding = 0;
536 : : /* Used only if the blinding structure is shared. A non-NULL unblind
537 : : * instructs rsa_blinding_convert() and rsa_blinding_invert() to store
538 : : * the unblinding factor outside the blinding structure. */
539 : 123934 : BIGNUM *unblind = NULL;
540 : 123934 : BN_BLINDING *blinding = NULL;
541 : :
542 : : #ifdef OPENSSL_FIPS
543 : : if(FIPS_selftest_failed())
544 : : {
545 : : FIPSerr(FIPS_F_RSA_EAY_PRIVATE_DECRYPT,FIPS_R_FIPS_SELFTEST_FAILED);
546 : : goto err;
547 : : }
548 : :
549 : : if (FIPS_module_mode() && !(rsa->flags & RSA_FLAG_NON_FIPS_ALLOW)
550 : : && (BN_num_bits(rsa->n) < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS))
551 : : {
552 : : RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT, RSA_R_KEY_SIZE_TOO_SMALL);
553 : : return -1;
554 : : }
555 : : #endif
556 : :
557 [ + - ]: 123934 : if((ctx = BN_CTX_new()) == NULL) goto err;
558 : 123934 : BN_CTX_start(ctx);
559 : 123934 : f = BN_CTX_get(ctx);
560 : 123934 : ret = BN_CTX_get(ctx);
561 : 123934 : num = BN_num_bytes(rsa->n);
562 : 123934 : buf = OPENSSL_malloc(num);
563 [ + - ][ - + ]: 123934 : if(!f || !ret || !buf)
564 : : {
565 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
566 : 0 : goto err;
567 : : }
568 : :
569 : : /* This check was for equality but PGP does evil things
570 : : * and chops off the top '0' bytes */
571 [ - + ]: 123934 : if (flen > num)
572 : : {
573 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
574 : 0 : goto err;
575 : : }
576 : :
577 : : /* make data into a big number */
578 [ + + ]: 123934 : if (BN_bin2bn(from,(int)flen,f) == NULL) goto err;
579 : :
580 [ + + ]: 520 : if (BN_ucmp(f, rsa->n) >= 0)
581 : : {
582 : 3 : RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
583 : 3 : goto err;
584 : : }
585 : :
586 [ + - ]: 517 : if (!(rsa->flags & RSA_FLAG_NO_BLINDING))
587 : : {
588 : 517 : blinding = rsa_get_blinding(rsa, &local_blinding, ctx);
589 [ - + ]: 517 : if (blinding == NULL)
590 : : {
591 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT, ERR_R_INTERNAL_ERROR);
592 : 0 : goto err;
593 : : }
594 : : }
595 : :
596 [ + - ]: 517 : if (blinding != NULL)
597 : : {
598 [ - + ][ # # ]: 517 : if (!local_blinding && ((unblind = BN_CTX_get(ctx)) == NULL))
599 : : {
600 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
601 : 0 : goto err;
602 : : }
603 [ + - ]: 517 : if (!rsa_blinding_convert(blinding, f, unblind, ctx))
604 : : goto err;
605 : : }
606 : :
607 : : /* do the decrypt */
608 [ + - ][ + - ]: 517 : if ( (rsa->flags & RSA_FLAG_EXT_PKEY) ||
609 [ + - ]: 517 : ((rsa->p != NULL) &&
610 [ + - ]: 517 : (rsa->q != NULL) &&
611 [ + - ]: 517 : (rsa->dmp1 != NULL) &&
612 [ + - ]: 517 : (rsa->dmq1 != NULL) &&
613 : 517 : (rsa->iqmp != NULL)) )
614 : : {
615 [ + - ]: 517 : if (!rsa->meth->rsa_mod_exp(ret, f, rsa, ctx)) goto err;
616 : : }
617 : : else
618 : : {
619 : : BIGNUM local_d;
620 : 0 : BIGNUM *d = NULL;
621 : :
622 [ # # ]: 0 : if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
623 : : {
624 : 0 : d = &local_d;
625 : 0 : BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
626 : : }
627 : : else
628 : 0 : d = rsa->d;
629 : :
630 [ # # ]: 0 : if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
631 [ # # ]: 0 : if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
632 : : goto err;
633 [ # # ]: 0 : if (!rsa->meth->bn_mod_exp(ret,f,d,rsa->n,ctx,
634 : : rsa->_method_mod_n))
635 : : goto err;
636 : : }
637 : :
638 [ + - ]: 517 : if (blinding)
639 [ + - ]: 517 : if (!rsa_blinding_invert(blinding, ret, unblind, ctx))
640 : : goto err;
641 : :
642 : 517 : p=buf;
643 : 517 : j=BN_bn2bin(ret,p); /* j is only used with no-padding mode */
644 : :
645 [ + + - + : 517 : switch (padding)
- ]
646 : : {
647 : : case RSA_PKCS1_PADDING:
648 : 497 : r=RSA_padding_check_PKCS1_type_2(to,num,buf,j,num);
649 : 497 : break;
650 : : #ifndef OPENSSL_NO_SHA
651 : : case RSA_PKCS1_OAEP_PADDING:
652 : 18 : r=RSA_padding_check_PKCS1_OAEP(to,num,buf,j,num,NULL,0);
653 : 18 : break;
654 : : #endif
655 : : case RSA_SSLV23_PADDING:
656 : 0 : r=RSA_padding_check_SSLv23(to,num,buf,j,num);
657 : 0 : break;
658 : : case RSA_NO_PADDING:
659 : 2 : r=RSA_padding_check_none(to,num,buf,j,num);
660 : 2 : break;
661 : : default:
662 : 0 : RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
663 : 0 : goto err;
664 : : }
665 [ + + ]: 517 : if (r < 0)
666 : 9 : RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
667 : :
668 : : err:
669 [ + - ]: 123934 : if (ctx != NULL)
670 : : {
671 : 123934 : BN_CTX_end(ctx);
672 : 123934 : BN_CTX_free(ctx);
673 : : }
674 [ + - ]: 123934 : if (buf != NULL)
675 : : {
676 : 123934 : OPENSSL_cleanse(buf,num);
677 : 123934 : OPENSSL_free(buf);
678 : : }
679 : 123934 : return(r);
680 : : }
681 : :
682 : : /* signature verification */
683 : 1653 : static int RSA_eay_public_decrypt(int flen, const unsigned char *from,
684 : : unsigned char *to, RSA *rsa, int padding)
685 : : {
686 : : BIGNUM *f,*ret;
687 : 1653 : int i,num=0,r= -1;
688 : : unsigned char *p;
689 : 1653 : unsigned char *buf=NULL;
690 : 1653 : BN_CTX *ctx=NULL;
691 : :
692 : : #ifdef OPENSSL_FIPS
693 : : if(FIPS_selftest_failed())
694 : : {
695 : : FIPSerr(FIPS_F_RSA_EAY_PUBLIC_DECRYPT,FIPS_R_FIPS_SELFTEST_FAILED);
696 : : goto err;
697 : : }
698 : :
699 : : if (FIPS_module_mode() && !(rsa->flags & RSA_FLAG_NON_FIPS_ALLOW)
700 : : && (BN_num_bits(rsa->n) < OPENSSL_RSA_FIPS_MIN_MODULUS_BITS))
701 : : {
702 : : RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_KEY_SIZE_TOO_SMALL);
703 : : return -1;
704 : : }
705 : : #endif
706 : :
707 [ - + ]: 1653 : if (BN_num_bits(rsa->n) > OPENSSL_RSA_MAX_MODULUS_BITS)
708 : : {
709 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_MODULUS_TOO_LARGE);
710 : 0 : return -1;
711 : : }
712 : :
713 [ - + ]: 1653 : if (BN_ucmp(rsa->n, rsa->e) <= 0)
714 : : {
715 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_BAD_E_VALUE);
716 : 0 : return -1;
717 : : }
718 : :
719 : : /* for large moduli, enforce exponent limit */
720 [ + + ]: 1653 : if (BN_num_bits(rsa->n) > OPENSSL_RSA_SMALL_MODULUS_BITS)
721 : : {
722 [ - + ]: 4 : if (BN_num_bits(rsa->e) > OPENSSL_RSA_MAX_PUBEXP_BITS)
723 : : {
724 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT, RSA_R_BAD_E_VALUE);
725 : 0 : return -1;
726 : : }
727 : : }
728 : :
729 [ + - ]: 1653 : if((ctx = BN_CTX_new()) == NULL) goto err;
730 : 1653 : BN_CTX_start(ctx);
731 : 1653 : f = BN_CTX_get(ctx);
732 : 1653 : ret = BN_CTX_get(ctx);
733 : 1653 : num=BN_num_bytes(rsa->n);
734 : 1653 : buf = OPENSSL_malloc(num);
735 [ + - ][ - + ]: 1653 : if(!f || !ret || !buf)
736 : : {
737 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
738 : 0 : goto err;
739 : : }
740 : :
741 : : /* This check was for equality but PGP does evil things
742 : : * and chops off the top '0' bytes */
743 [ - + ]: 1653 : if (flen > num)
744 : : {
745 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
746 : 0 : goto err;
747 : : }
748 : :
749 [ + - ]: 1653 : if (BN_bin2bn(from,flen,f) == NULL) goto err;
750 : :
751 [ - + ]: 1653 : if (BN_ucmp(f, rsa->n) >= 0)
752 : : {
753 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_TOO_LARGE_FOR_MODULUS);
754 : 0 : goto err;
755 : : }
756 : :
757 [ + - ]: 1653 : if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
758 [ + - ]: 1653 : if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
759 : : goto err;
760 : :
761 [ + - ]: 1653 : if (!rsa->meth->bn_mod_exp(ret,f,rsa->e,rsa->n,ctx,
762 : : rsa->_method_mod_n)) goto err;
763 : :
764 [ - + ][ # # ]: 1653 : if ((padding == RSA_X931_PADDING) && ((ret->d[0] & 0xf) != 12))
765 [ # # ]: 0 : if (!BN_sub(ret, rsa->n, ret)) goto err;
766 : :
767 : 1653 : p=buf;
768 : 1653 : i=BN_bn2bin(ret,p);
769 : :
770 [ + - + - ]: 1653 : switch (padding)
771 : : {
772 : : case RSA_PKCS1_PADDING:
773 : 1650 : r=RSA_padding_check_PKCS1_type_1(to,num,buf,i,num);
774 : 1650 : break;
775 : : case RSA_X931_PADDING:
776 : 0 : r=RSA_padding_check_X931(to,num,buf,i,num);
777 : 0 : break;
778 : : case RSA_NO_PADDING:
779 : 3 : r=RSA_padding_check_none(to,num,buf,i,num);
780 : 3 : break;
781 : : default:
782 : 0 : RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
783 : 0 : goto err;
784 : : }
785 [ + + ]: 1653 : if (r < 0)
786 : 13 : RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
787 : :
788 : : err:
789 [ + - ]: 1653 : if (ctx != NULL)
790 : : {
791 : 1653 : BN_CTX_end(ctx);
792 : 1653 : BN_CTX_free(ctx);
793 : : }
794 [ + - ]: 1653 : if (buf != NULL)
795 : : {
796 : 1653 : OPENSSL_cleanse(buf,num);
797 : 1653 : OPENSSL_free(buf);
798 : : }
799 : 1653 : return(r);
800 : : }
801 : :
802 : 1332 : static int RSA_eay_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
803 : : {
804 : : BIGNUM *r1,*m1,*vrfy;
805 : : BIGNUM local_dmp1,local_dmq1,local_c,local_r1;
806 : : BIGNUM *dmp1,*dmq1,*c,*pr1;
807 : 1332 : int ret=0;
808 : :
809 : 1332 : BN_CTX_start(ctx);
810 : 1332 : r1 = BN_CTX_get(ctx);
811 : 1332 : m1 = BN_CTX_get(ctx);
812 : 1332 : vrfy = BN_CTX_get(ctx);
813 : :
814 : : {
815 : : BIGNUM local_p, local_q;
816 : 1332 : BIGNUM *p = NULL, *q = NULL;
817 : :
818 : : /* Make sure BN_mod_inverse in Montgomery intialization uses the
819 : : * BN_FLG_CONSTTIME flag (unless RSA_FLAG_NO_CONSTTIME is set)
820 : : */
821 [ + + ]: 1332 : if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
822 : : {
823 : 1320 : BN_init(&local_p);
824 : 1320 : p = &local_p;
825 : 1320 : BN_with_flags(p, rsa->p, BN_FLG_CONSTTIME);
826 : :
827 : 1320 : BN_init(&local_q);
828 : 1320 : q = &local_q;
829 : 1320 : BN_with_flags(q, rsa->q, BN_FLG_CONSTTIME);
830 : : }
831 : : else
832 : : {
833 : 12 : p = rsa->p;
834 : 12 : q = rsa->q;
835 : : }
836 : :
837 [ + - ]: 1332 : if (rsa->flags & RSA_FLAG_CACHE_PRIVATE)
838 : : {
839 [ + - ]: 1332 : if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_p, CRYPTO_LOCK_RSA, p, ctx))
840 : : goto err;
841 [ + - ]: 1332 : if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_q, CRYPTO_LOCK_RSA, q, ctx))
842 : : goto err;
843 : : }
844 : : }
845 : :
846 [ + - ]: 1332 : if (rsa->flags & RSA_FLAG_CACHE_PUBLIC)
847 [ + - ]: 1332 : if (!BN_MONT_CTX_set_locked(&rsa->_method_mod_n, CRYPTO_LOCK_RSA, rsa->n, ctx))
848 : : goto err;
849 : :
850 : : /* compute I mod q */
851 [ + + ]: 1332 : if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
852 : : {
853 : 1320 : c = &local_c;
854 : 1320 : BN_with_flags(c, I, BN_FLG_CONSTTIME);
855 [ + - ]: 1320 : if (!BN_mod(r1,c,rsa->q,ctx)) goto err;
856 : : }
857 : : else
858 : : {
859 [ + - ]: 12 : if (!BN_mod(r1,I,rsa->q,ctx)) goto err;
860 : : }
861 : :
862 : : /* compute r1^dmq1 mod q */
863 [ + + ]: 1332 : if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
864 : : {
865 : 1320 : dmq1 = &local_dmq1;
866 : 1320 : BN_with_flags(dmq1, rsa->dmq1, BN_FLG_CONSTTIME);
867 : : }
868 : : else
869 : 12 : dmq1 = rsa->dmq1;
870 [ + - ]: 1332 : if (!rsa->meth->bn_mod_exp(m1,r1,dmq1,rsa->q,ctx,
871 : : rsa->_method_mod_q)) goto err;
872 : :
873 : : /* compute I mod p */
874 [ + + ]: 1332 : if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
875 : : {
876 : 1320 : c = &local_c;
877 : 1320 : BN_with_flags(c, I, BN_FLG_CONSTTIME);
878 [ + - ]: 1320 : if (!BN_mod(r1,c,rsa->p,ctx)) goto err;
879 : : }
880 : : else
881 : : {
882 [ + - ]: 12 : if (!BN_mod(r1,I,rsa->p,ctx)) goto err;
883 : : }
884 : :
885 : : /* compute r1^dmp1 mod p */
886 [ + + ]: 1332 : if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
887 : : {
888 : 1320 : dmp1 = &local_dmp1;
889 : 1320 : BN_with_flags(dmp1, rsa->dmp1, BN_FLG_CONSTTIME);
890 : : }
891 : : else
892 : 12 : dmp1 = rsa->dmp1;
893 [ + - ]: 1332 : if (!rsa->meth->bn_mod_exp(r0,r1,dmp1,rsa->p,ctx,
894 : : rsa->_method_mod_p)) goto err;
895 : :
896 [ + - ]: 1332 : if (!BN_sub(r0,r0,m1)) goto err;
897 : : /* This will help stop the size of r0 increasing, which does
898 : : * affect the multiply if it optimised for a power of 2 size */
899 [ + + ]: 1332 : if (BN_is_negative(r0))
900 [ + - ]: 641 : if (!BN_add(r0,r0,rsa->p)) goto err;
901 : :
902 [ + - ]: 1332 : if (!BN_mul(r1,r0,rsa->iqmp,ctx)) goto err;
903 : :
904 : : /* Turn BN_FLG_CONSTTIME flag on before division operation */
905 [ + + ]: 1332 : if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
906 : : {
907 : 1320 : pr1 = &local_r1;
908 : 1320 : BN_with_flags(pr1, r1, BN_FLG_CONSTTIME);
909 : : }
910 : : else
911 : : pr1 = r1;
912 [ + - ]: 1332 : if (!BN_mod(r0,pr1,rsa->p,ctx)) goto err;
913 : :
914 : : /* If p < q it is occasionally possible for the correction of
915 : : * adding 'p' if r0 is negative above to leave the result still
916 : : * negative. This can break the private key operations: the following
917 : : * second correction should *always* correct this rare occurrence.
918 : : * This will *never* happen with OpenSSL generated keys because
919 : : * they ensure p > q [steve]
920 : : */
921 [ - + ]: 1332 : if (BN_is_negative(r0))
922 [ # # ]: 0 : if (!BN_add(r0,r0,rsa->p)) goto err;
923 [ + - ]: 1332 : if (!BN_mul(r1,r0,rsa->q,ctx)) goto err;
924 [ + - ]: 1332 : if (!BN_add(r0,r1,m1)) goto err;
925 : :
926 [ + - ][ + - ]: 1332 : if (rsa->e && rsa->n)
927 : : {
928 [ + - ]: 1332 : if (!rsa->meth->bn_mod_exp(vrfy,r0,rsa->e,rsa->n,ctx,rsa->_method_mod_n)) goto err;
929 : : /* If 'I' was greater than (or equal to) rsa->n, the operation
930 : : * will be equivalent to using 'I mod n'. However, the result of
931 : : * the verify will *always* be less than 'n' so we don't check
932 : : * for absolute equality, just congruency. */
933 [ + - ]: 1332 : if (!BN_sub(vrfy, vrfy, I)) goto err;
934 [ + - ]: 1332 : if (!BN_mod(vrfy, vrfy, rsa->n, ctx)) goto err;
935 [ - + ]: 1332 : if (BN_is_negative(vrfy))
936 [ # # ]: 0 : if (!BN_add(vrfy, vrfy, rsa->n)) goto err;
937 [ - + ]: 1332 : if (!BN_is_zero(vrfy))
938 : : {
939 : : /* 'I' and 'vrfy' aren't congruent mod n. Don't leak
940 : : * miscalculated CRT output, just do a raw (slower)
941 : : * mod_exp and return that instead. */
942 : :
943 : : BIGNUM local_d;
944 : 0 : BIGNUM *d = NULL;
945 : :
946 [ # # ]: 0 : if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
947 : : {
948 : 0 : d = &local_d;
949 : 0 : BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
950 : : }
951 : : else
952 : 0 : d = rsa->d;
953 [ # # ]: 0 : if (!rsa->meth->bn_mod_exp(r0,I,d,rsa->n,ctx,
954 : : rsa->_method_mod_n)) goto err;
955 : : }
956 : : }
957 : : ret=1;
958 : : err:
959 : 1332 : BN_CTX_end(ctx);
960 : 1332 : return(ret);
961 : : }
962 : :
963 : 4850 : static int RSA_eay_init(RSA *rsa)
964 : : {
965 : : #ifdef OPENSSL_FIPS
966 : : if(FIPS_selftest_failed())
967 : : {
968 : : FIPSerr(FIPS_F_RSA_EAY_INIT,FIPS_R_FIPS_SELFTEST_FAILED);
969 : : return 0;
970 : : }
971 : : #endif
972 : 4850 : rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE;
973 : 4850 : return(1);
974 : : }
975 : :
976 : 4850 : static int RSA_eay_finish(RSA *rsa)
977 : : {
978 [ + + ]: 4850 : if (rsa->_method_mod_n != NULL)
979 : 3210 : BN_MONT_CTX_free(rsa->_method_mod_n);
980 [ + + ]: 4850 : if (rsa->_method_mod_p != NULL)
981 : 1102 : BN_MONT_CTX_free(rsa->_method_mod_p);
982 [ + + ]: 4850 : if (rsa->_method_mod_q != NULL)
983 : 1102 : BN_MONT_CTX_free(rsa->_method_mod_q);
984 : 4850 : return(1);
985 : : }
986 : :
987 : : #endif
|
