1 /* $OpenBSD: rsa_lib.c,v 1.43 2022/06/27 12:30:28 tb Exp $ */
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 #include <stdio.h>
60
61 #include <openssl/opensslconf.h>
62
63 #include <openssl/bn.h>
64 #include <openssl/crypto.h>
65 #include <openssl/err.h>
66 #include <openssl/evp.h>
67 #include <openssl/lhash.h>
68 #include <openssl/rsa.h>
69
70 #include "evp_locl.h"
71 #include "rsa_locl.h"
72
73 #ifndef OPENSSL_NO_ENGINE
74 #include <openssl/engine.h>
75 #endif
76
77 static const RSA_METHOD *default_RSA_meth = NULL;
78
79 RSA *
RSA_new(void)80 RSA_new(void)
81 {
82 RSA *r = RSA_new_method(NULL);
83
84 return r;
85 }
86
87 void
RSA_set_default_method(const RSA_METHOD * meth)88 RSA_set_default_method(const RSA_METHOD *meth)
89 {
90 default_RSA_meth = meth;
91 }
92
93 const RSA_METHOD *
RSA_get_default_method(void)94 RSA_get_default_method(void)
95 {
96 if (default_RSA_meth == NULL)
97 default_RSA_meth = RSA_PKCS1_SSLeay();
98
99 return default_RSA_meth;
100 }
101
102 const RSA_METHOD *
RSA_get_method(const RSA * rsa)103 RSA_get_method(const RSA *rsa)
104 {
105 return rsa->meth;
106 }
107
108 int
RSA_set_method(RSA * rsa,const RSA_METHOD * meth)109 RSA_set_method(RSA *rsa, const RSA_METHOD *meth)
110 {
111 /*
112 * NB: The caller is specifically setting a method, so it's not up to us
113 * to deal with which ENGINE it comes from.
114 */
115 const RSA_METHOD *mtmp;
116
117 mtmp = rsa->meth;
118 if (mtmp->finish)
119 mtmp->finish(rsa);
120 #ifndef OPENSSL_NO_ENGINE
121 ENGINE_finish(rsa->engine);
122 rsa->engine = NULL;
123 #endif
124 rsa->meth = meth;
125 if (meth->init)
126 meth->init(rsa);
127 return 1;
128 }
129
130 RSA *
RSA_new_method(ENGINE * engine)131 RSA_new_method(ENGINE *engine)
132 {
133 RSA *ret;
134
135 if ((ret = calloc(1, sizeof(RSA))) == NULL) {
136 RSAerror(ERR_R_MALLOC_FAILURE);
137 return NULL;
138 }
139
140 ret->meth = RSA_get_default_method();
141
142 #ifndef OPENSSL_NO_ENGINE
143 if (engine != NULL) {
144 if (!ENGINE_init(engine)) {
145 RSAerror(ERR_R_ENGINE_LIB);
146 goto err;
147 }
148 ret->engine = engine;
149 } else {
150 ret->engine = ENGINE_get_default_RSA();
151 }
152
153 if (ret->engine != NULL) {
154 if ((ret->meth = ENGINE_get_RSA(ret->engine)) == NULL) {
155 RSAerror(ERR_R_ENGINE_LIB);
156 goto err;
157 }
158 }
159 #endif
160
161 ret->references = 1;
162 ret->flags = ret->meth->flags & ~RSA_FLAG_NON_FIPS_ALLOW;
163
164 if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_RSA, ret, &ret->ex_data))
165 goto err;
166
167 if (ret->meth->init != NULL && !ret->meth->init(ret)) {
168 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_RSA, ret, &ret->ex_data);
169 goto err;
170 }
171
172 return ret;
173
174 err:
175 #ifndef OPENSSL_NO_ENGINE
176 ENGINE_finish(ret->engine);
177 #endif
178 free(ret);
179
180 return NULL;
181 }
182
183 void
RSA_free(RSA * r)184 RSA_free(RSA *r)
185 {
186 int i;
187
188 if (r == NULL)
189 return;
190
191 i = CRYPTO_add(&r->references, -1, CRYPTO_LOCK_RSA);
192 if (i > 0)
193 return;
194
195 if (r->meth->finish)
196 r->meth->finish(r);
197 #ifndef OPENSSL_NO_ENGINE
198 ENGINE_finish(r->engine);
199 #endif
200
201 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_RSA, r, &r->ex_data);
202
203 BN_clear_free(r->n);
204 BN_clear_free(r->e);
205 BN_clear_free(r->d);
206 BN_clear_free(r->p);
207 BN_clear_free(r->q);
208 BN_clear_free(r->dmp1);
209 BN_clear_free(r->dmq1);
210 BN_clear_free(r->iqmp);
211 BN_BLINDING_free(r->blinding);
212 BN_BLINDING_free(r->mt_blinding);
213 RSA_PSS_PARAMS_free(r->pss);
214 free(r);
215 }
216
217 int
RSA_up_ref(RSA * r)218 RSA_up_ref(RSA *r)
219 {
220 int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_RSA);
221 return i > 1 ? 1 : 0;
222 }
223
224 int
RSA_get_ex_new_index(long argl,void * argp,CRYPTO_EX_new * new_func,CRYPTO_EX_dup * dup_func,CRYPTO_EX_free * free_func)225 RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
226 CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
227 {
228 return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, argl, argp,
229 new_func, dup_func, free_func);
230 }
231
232 int
RSA_set_ex_data(RSA * r,int idx,void * arg)233 RSA_set_ex_data(RSA *r, int idx, void *arg)
234 {
235 return CRYPTO_set_ex_data(&r->ex_data, idx, arg);
236 }
237
238 void *
RSA_get_ex_data(const RSA * r,int idx)239 RSA_get_ex_data(const RSA *r, int idx)
240 {
241 return CRYPTO_get_ex_data(&r->ex_data, idx);
242 }
243
244 int
RSA_security_bits(const RSA * rsa)245 RSA_security_bits(const RSA *rsa)
246 {
247 return BN_security_bits(RSA_bits(rsa), -1);
248 }
249
250 void
RSA_get0_key(const RSA * r,const BIGNUM ** n,const BIGNUM ** e,const BIGNUM ** d)251 RSA_get0_key(const RSA *r, const BIGNUM **n, const BIGNUM **e, const BIGNUM **d)
252 {
253 if (n != NULL)
254 *n = r->n;
255 if (e != NULL)
256 *e = r->e;
257 if (d != NULL)
258 *d = r->d;
259 }
260
261 int
RSA_set0_key(RSA * r,BIGNUM * n,BIGNUM * e,BIGNUM * d)262 RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d)
263 {
264 if ((r->n == NULL && n == NULL) || (r->e == NULL && e == NULL))
265 return 0;
266
267 if (n != NULL) {
268 BN_free(r->n);
269 r->n = n;
270 }
271 if (e != NULL) {
272 BN_free(r->e);
273 r->e = e;
274 }
275 if (d != NULL) {
276 BN_free(r->d);
277 r->d = d;
278 }
279
280 return 1;
281 }
282
283 void
RSA_get0_crt_params(const RSA * r,const BIGNUM ** dmp1,const BIGNUM ** dmq1,const BIGNUM ** iqmp)284 RSA_get0_crt_params(const RSA *r, const BIGNUM **dmp1, const BIGNUM **dmq1,
285 const BIGNUM **iqmp)
286 {
287 if (dmp1 != NULL)
288 *dmp1 = r->dmp1;
289 if (dmq1 != NULL)
290 *dmq1 = r->dmq1;
291 if (iqmp != NULL)
292 *iqmp = r->iqmp;
293 }
294
295 int
RSA_set0_crt_params(RSA * r,BIGNUM * dmp1,BIGNUM * dmq1,BIGNUM * iqmp)296 RSA_set0_crt_params(RSA *r, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp)
297 {
298 if ((r->dmp1 == NULL && dmp1 == NULL) ||
299 (r->dmq1 == NULL && dmq1 == NULL) ||
300 (r->iqmp == NULL && iqmp == NULL))
301 return 0;
302
303 if (dmp1 != NULL) {
304 BN_free(r->dmp1);
305 r->dmp1 = dmp1;
306 }
307 if (dmq1 != NULL) {
308 BN_free(r->dmq1);
309 r->dmq1 = dmq1;
310 }
311 if (iqmp != NULL) {
312 BN_free(r->iqmp);
313 r->iqmp = iqmp;
314 }
315
316 return 1;
317 }
318
319 void
RSA_get0_factors(const RSA * r,const BIGNUM ** p,const BIGNUM ** q)320 RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q)
321 {
322 if (p != NULL)
323 *p = r->p;
324 if (q != NULL)
325 *q = r->q;
326 }
327
328 int
RSA_set0_factors(RSA * r,BIGNUM * p,BIGNUM * q)329 RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q)
330 {
331 if ((r->p == NULL && p == NULL) || (r->q == NULL && q == NULL))
332 return 0;
333
334 if (p != NULL) {
335 BN_free(r->p);
336 r->p = p;
337 }
338 if (q != NULL) {
339 BN_free(r->q);
340 r->q = q;
341 }
342
343 return 1;
344 }
345
346 const BIGNUM *
RSA_get0_n(const RSA * r)347 RSA_get0_n(const RSA *r)
348 {
349 return r->n;
350 }
351
352 const BIGNUM *
RSA_get0_e(const RSA * r)353 RSA_get0_e(const RSA *r)
354 {
355 return r->e;
356 }
357
358 const BIGNUM *
RSA_get0_d(const RSA * r)359 RSA_get0_d(const RSA *r)
360 {
361 return r->d;
362 }
363
364 const BIGNUM *
RSA_get0_p(const RSA * r)365 RSA_get0_p(const RSA *r)
366 {
367 return r->p;
368 }
369
370 const BIGNUM *
RSA_get0_q(const RSA * r)371 RSA_get0_q(const RSA *r)
372 {
373 return r->q;
374 }
375
376 const BIGNUM *
RSA_get0_dmp1(const RSA * r)377 RSA_get0_dmp1(const RSA *r)
378 {
379 return r->dmp1;
380 }
381
382 const BIGNUM *
RSA_get0_dmq1(const RSA * r)383 RSA_get0_dmq1(const RSA *r)
384 {
385 return r->dmq1;
386 }
387
388 const BIGNUM *
RSA_get0_iqmp(const RSA * r)389 RSA_get0_iqmp(const RSA *r)
390 {
391 return r->iqmp;
392 }
393
394 const RSA_PSS_PARAMS *
RSA_get0_pss_params(const RSA * r)395 RSA_get0_pss_params(const RSA *r)
396 {
397 return r->pss;
398 }
399
400 void
RSA_clear_flags(RSA * r,int flags)401 RSA_clear_flags(RSA *r, int flags)
402 {
403 r->flags &= ~flags;
404 }
405
406 int
RSA_test_flags(const RSA * r,int flags)407 RSA_test_flags(const RSA *r, int flags)
408 {
409 return r->flags & flags;
410 }
411
412 void
RSA_set_flags(RSA * r,int flags)413 RSA_set_flags(RSA *r, int flags)
414 {
415 r->flags |= flags;
416 }
417
418 int
RSA_pkey_ctx_ctrl(EVP_PKEY_CTX * ctx,int optype,int cmd,int p1,void * p2)419 RSA_pkey_ctx_ctrl(EVP_PKEY_CTX *ctx, int optype, int cmd, int p1, void *p2)
420 {
421 /* Return an error if the key type is not RSA or RSA-PSS. */
422 if (ctx != NULL && ctx->pmeth != NULL &&
423 ctx->pmeth->pkey_id != EVP_PKEY_RSA &&
424 ctx->pmeth->pkey_id != EVP_PKEY_RSA_PSS)
425 return -1;
426
427 return EVP_PKEY_CTX_ctrl(ctx, -1, optype, cmd, p1, p2);
428 }
429