apps/x509.c: Fix mem leaks in processing of -next_serial in print loop
[openssl.git] / providers / implementations / keymgmt / rsa_kmgmt.c
1 /*
2  * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * RSA low level APIs are deprecated for public use, but still ok for
12  * internal use.
13  */
14 #include "internal/deprecated.h"
15
16 #include <openssl/core_dispatch.h>
17 #include <openssl/core_names.h>
18 #include <openssl/bn.h>
19 #include <openssl/err.h>
20 #include <openssl/rsa.h>
21 #include <openssl/evp.h>
22 #include "prov/implementations.h"
23 #include "prov/providercommon.h"
24 #include "prov/provider_ctx.h"
25 #include "crypto/rsa.h"
26 #include "crypto/cryptlib.h"
27 #include "internal/param_build_set.h"
28
29 static OSSL_FUNC_keymgmt_new_fn rsa_newdata;
30 static OSSL_FUNC_keymgmt_new_fn rsapss_newdata;
31 static OSSL_FUNC_keymgmt_gen_init_fn rsa_gen_init;
32 static OSSL_FUNC_keymgmt_gen_init_fn rsapss_gen_init;
33 static OSSL_FUNC_keymgmt_gen_set_params_fn rsa_gen_set_params;
34 static OSSL_FUNC_keymgmt_gen_settable_params_fn rsa_gen_settable_params;
35 static OSSL_FUNC_keymgmt_gen_settable_params_fn rsapss_gen_settable_params;
36 static OSSL_FUNC_keymgmt_gen_fn rsa_gen;
37 static OSSL_FUNC_keymgmt_gen_cleanup_fn rsa_gen_cleanup;
38 static OSSL_FUNC_keymgmt_load_fn rsa_load;
39 static OSSL_FUNC_keymgmt_free_fn rsa_freedata;
40 static OSSL_FUNC_keymgmt_get_params_fn rsa_get_params;
41 static OSSL_FUNC_keymgmt_gettable_params_fn rsa_gettable_params;
42 static OSSL_FUNC_keymgmt_has_fn rsa_has;
43 static OSSL_FUNC_keymgmt_match_fn rsa_match;
44 static OSSL_FUNC_keymgmt_validate_fn rsa_validate;
45 static OSSL_FUNC_keymgmt_import_fn rsa_import;
46 static OSSL_FUNC_keymgmt_import_types_fn rsa_import_types;
47 static OSSL_FUNC_keymgmt_export_fn rsa_export;
48 static OSSL_FUNC_keymgmt_export_types_fn rsa_export_types;
49 static OSSL_FUNC_keymgmt_query_operation_name_fn rsa_query_operation_name;
50
51 #define RSA_DEFAULT_MD "SHA256"
52 #define RSA_PSS_DEFAULT_MD OSSL_DIGEST_NAME_SHA1
53 #define RSA_POSSIBLE_SELECTIONS                                        \
54     (OSSL_KEYMGMT_SELECT_KEYPAIR | OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS)
55
56 DEFINE_STACK_OF(BIGNUM)
57 DEFINE_SPECIAL_STACK_OF_CONST(BIGNUM_const, BIGNUM)
58
59 static int pss_params_fromdata(RSA_PSS_PARAMS_30 *pss_params,
60                                const OSSL_PARAM params[], int rsa_type,
61                                OSSL_LIB_CTX *libctx)
62 {
63     if (!ossl_rsa_pss_params_30_fromdata(pss_params, params, libctx))
64         return 0;
65
66     /* If not a PSS type RSA, sending us PSS parameters is wrong */
67     if (rsa_type != RSA_FLAG_TYPE_RSASSAPSS
68         && !ossl_rsa_pss_params_30_is_unrestricted(pss_params))
69         return 0;
70
71     return 1;
72 }
73
74 static void *rsa_newdata(void *provctx)
75 {
76     OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(provctx);
77     RSA *rsa;
78
79     if (!ossl_prov_is_running())
80         return NULL;
81
82     rsa = ossl_rsa_new_with_ctx(libctx);
83     if (rsa != NULL) {
84         RSA_clear_flags(rsa, RSA_FLAG_TYPE_MASK);
85         RSA_set_flags(rsa, RSA_FLAG_TYPE_RSA);
86     }
87     return rsa;
88 }
89
90 static void *rsapss_newdata(void *provctx)
91 {
92     OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(provctx);
93     RSA *rsa;
94
95     if (!ossl_prov_is_running())
96         return NULL;
97
98     rsa = ossl_rsa_new_with_ctx(libctx);
99     if (rsa != NULL) {
100         RSA_clear_flags(rsa, RSA_FLAG_TYPE_MASK);
101         RSA_set_flags(rsa, RSA_FLAG_TYPE_RSASSAPSS);
102     }
103     return rsa;
104 }
105
106 static void rsa_freedata(void *keydata)
107 {
108     RSA_free(keydata);
109 }
110
111 static int rsa_has(const void *keydata, int selection)
112 {
113     const RSA *rsa = keydata;
114     int ok = 0;
115
116     if (rsa != NULL && ossl_prov_is_running()) {
117         if ((selection & RSA_POSSIBLE_SELECTIONS) != 0)
118             ok = 1;
119
120         if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0)
121             /* This will change with OAEP */
122             ok = ok && (RSA_test_flags(rsa, RSA_FLAG_TYPE_RSASSAPSS) != 0);
123         if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
124             ok = ok && (RSA_get0_e(rsa) != NULL);
125         if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
126             ok = ok && (RSA_get0_n(rsa) != NULL);
127         if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
128             ok = ok && (RSA_get0_d(rsa) != NULL);
129     }
130     return ok;
131 }
132
133 static int rsa_match(const void *keydata1, const void *keydata2, int selection)
134 {
135     const RSA *rsa1 = keydata1;
136     const RSA *rsa2 = keydata2;
137     int ok = 1;
138
139     if (!ossl_prov_is_running())
140         return 0;
141
142     /* There is always an |e| */
143     ok = ok && BN_cmp(RSA_get0_e(rsa1), RSA_get0_e(rsa2)) == 0;
144     if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
145         ok = ok && BN_cmp(RSA_get0_n(rsa1), RSA_get0_n(rsa2)) == 0;
146     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
147         ok = ok && BN_cmp(RSA_get0_d(rsa1), RSA_get0_d(rsa2)) == 0;
148     return ok;
149 }
150
151 static int rsa_import(void *keydata, int selection, const OSSL_PARAM params[])
152 {
153     RSA *rsa = keydata;
154     int rsa_type;
155     int ok = 1;
156
157     if (!ossl_prov_is_running() || rsa == NULL)
158         return 0;
159
160     if ((selection & RSA_POSSIBLE_SELECTIONS) == 0)
161         return 0;
162
163     rsa_type = RSA_test_flags(rsa, RSA_FLAG_TYPE_MASK);
164
165     /* TODO(3.0) OAEP should bring on parameters as well */
166
167     if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0)
168         ok = ok && pss_params_fromdata(ossl_rsa_get0_pss_params_30(rsa), params,
169                                        rsa_type, ossl_rsa_get0_libctx(rsa));
170     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
171         ok = ok && ossl_rsa_fromdata(rsa, params);
172
173     return ok;
174 }
175
176 static int rsa_export(void *keydata, int selection,
177                       OSSL_CALLBACK *param_callback, void *cbarg)
178 {
179     RSA *rsa = keydata;
180     const RSA_PSS_PARAMS_30 *pss_params = ossl_rsa_get0_pss_params_30(rsa);
181     OSSL_PARAM_BLD *tmpl;
182     OSSL_PARAM *params = NULL;
183     int ok = 1;
184
185     if (!ossl_prov_is_running() || rsa == NULL)
186         return 0;
187
188     /* TODO(3.0) OAEP should bring on parameters */
189
190     tmpl = OSSL_PARAM_BLD_new();
191     if (tmpl == NULL)
192         return 0;
193
194     if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0)
195         ok = ok && (ossl_rsa_pss_params_30_is_unrestricted(pss_params)
196                     || ossl_rsa_pss_params_30_todata(pss_params, tmpl, NULL));
197     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
198         ok = ok && ossl_rsa_todata(rsa, tmpl, NULL);
199
200     if (!ok
201         || (params = OSSL_PARAM_BLD_to_param(tmpl)) == NULL)
202         goto err;
203
204     ok = param_callback(params, cbarg);
205     OSSL_PARAM_BLD_free_params(params);
206 err:
207     OSSL_PARAM_BLD_free(tmpl);
208     return ok;
209 }
210
211 #ifdef FIPS_MODULE
212 /* In fips mode there are no multi-primes. */
213 # define RSA_KEY_MP_TYPES()                                                    \
214 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR1, NULL, 0),                           \
215 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR2, NULL, 0),                           \
216 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT1, NULL, 0),                         \
217 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT2, NULL, 0),                         \
218 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT1, NULL, 0),
219 #else
220 /*
221  * We allow up to 10 prime factors (starting with p, q).
222  * NOTE: there is only 9 OSSL_PKEY_PARAM_RSA_COEFFICIENT
223  */
224 # define RSA_KEY_MP_TYPES()                                                    \
225 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR1, NULL, 0),                           \
226 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR2, NULL, 0),                           \
227 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR3, NULL, 0),                           \
228 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR4, NULL, 0),                           \
229 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR5, NULL, 0),                           \
230 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR6, NULL, 0),                           \
231 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR7, NULL, 0),                           \
232 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR8, NULL, 0),                           \
233 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR9, NULL, 0),                           \
234 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR10, NULL, 0),                          \
235 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT1, NULL, 0),                         \
236 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT2, NULL, 0),                         \
237 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT3, NULL, 0),                         \
238 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT4, NULL, 0),                         \
239 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT5, NULL, 0),                         \
240 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT6, NULL, 0),                         \
241 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT7, NULL, 0),                         \
242 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT8, NULL, 0),                         \
243 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT9, NULL, 0),                         \
244 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT10, NULL, 0),                        \
245 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT1, NULL, 0),                      \
246 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT2, NULL, 0),                      \
247 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT3, NULL, 0),                      \
248 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT4, NULL, 0),                      \
249 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT5, NULL, 0),                      \
250 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT6, NULL, 0),                      \
251 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT7, NULL, 0),                      \
252 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT8, NULL, 0),                      \
253 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT9, NULL, 0),
254 #endif
255
256 #define RSA_KEY_TYPES()                                                        \
257 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_N, NULL, 0),                                 \
258 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_E, NULL, 0),                                 \
259 OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_D, NULL, 0),                                 \
260 RSA_KEY_MP_TYPES()
261
262 /*
263  * This provider can export everything in an RSA key, so we use the exact
264  * same type description for export as for import.  Other providers might
265  * choose to import full keys, but only export the public parts, and will
266  * therefore have the importkey_types and importkey_types functions return
267  * different arrays.
268  */
269 static const OSSL_PARAM rsa_key_types[] = {
270     RSA_KEY_TYPES()
271     OSSL_PARAM_END
272 };
273 /*
274  * We lied about the amount of factors, exponents and coefficients, the
275  * export and import functions can really deal with an infinite amount
276  * of these numbers.  However, RSA keys with too many primes are futile,
277  * so we at least pretend to have some limits.
278  */
279
280 static const OSSL_PARAM *rsa_imexport_types(int selection)
281 {
282     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
283         return rsa_key_types;
284     return NULL;
285 }
286
287 static const OSSL_PARAM *rsa_import_types(int selection)
288 {
289     return rsa_imexport_types(selection);
290 }
291
292 static const OSSL_PARAM *rsa_export_types(int selection)
293 {
294     return rsa_imexport_types(selection);
295 }
296
297 static int rsa_get_params(void *key, OSSL_PARAM params[])
298 {
299     RSA *rsa = key;
300     const RSA_PSS_PARAMS_30 *pss_params = ossl_rsa_get0_pss_params_30(rsa);
301     int rsa_type = RSA_test_flags(rsa, RSA_FLAG_TYPE_MASK);
302     OSSL_PARAM *p;
303
304     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
305         && !OSSL_PARAM_set_int(p, RSA_bits(rsa)))
306         return 0;
307     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
308         && !OSSL_PARAM_set_int(p, RSA_security_bits(rsa)))
309         return 0;
310     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
311         && !OSSL_PARAM_set_int(p, RSA_size(rsa)))
312         return 0;
313
314     /*
315      * For RSA-PSS keys, we ignore the default digest request
316      * TODO(3.0) with RSA-OAEP keys, this may need to be amended
317      */
318     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_DEFAULT_DIGEST)) != NULL
319         && rsa_type != RSA_FLAG_TYPE_RSASSAPSS) {
320         if (!OSSL_PARAM_set_utf8_string(p, RSA_DEFAULT_MD))
321             return 0;
322     }
323
324     /*
325      * For non-RSA-PSS keys, we ignore the mandatory digest request
326      * TODO(3.0) with RSA-OAEP keys, this may need to be amended
327      */
328     if ((p = OSSL_PARAM_locate(params,
329                                OSSL_PKEY_PARAM_MANDATORY_DIGEST)) != NULL
330         && rsa_type == RSA_FLAG_TYPE_RSASSAPSS
331         && !ossl_rsa_pss_params_30_is_unrestricted(pss_params)) {
332         const char *mdname =
333             ossl_rsa_oaeppss_nid2name(ossl_rsa_pss_params_30_hashalg(pss_params));
334
335         if (mdname == NULL || !OSSL_PARAM_set_utf8_string(p, mdname))
336             return 0;
337     }
338     return (rsa_type != RSA_FLAG_TYPE_RSASSAPSS
339             || ossl_rsa_pss_params_30_todata(pss_params, NULL, params))
340         && ossl_rsa_todata(rsa, NULL, params);
341 }
342
343 static const OSSL_PARAM rsa_params[] = {
344     OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
345     OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
346     OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
347     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_DEFAULT_DIGEST, NULL, 0),
348     RSA_KEY_TYPES()
349     OSSL_PARAM_END
350 };
351
352 static const OSSL_PARAM *rsa_gettable_params(void *provctx)
353 {
354     return rsa_params;
355 }
356
357 static int rsa_validate(const void *keydata, int selection)
358 {
359     const RSA *rsa = keydata;
360     int ok = 0;
361
362     if (!ossl_prov_is_running())
363         return 0;
364
365     if ((selection & RSA_POSSIBLE_SELECTIONS) != 0)
366         ok = 1;
367
368     /* If the whole key is selected, we do a pairwise validation */
369     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR)
370         == OSSL_KEYMGMT_SELECT_KEYPAIR) {
371         ok = ok && ossl_rsa_validate_pairwise(rsa);
372     } else {
373         if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
374             ok = ok && ossl_rsa_validate_private(rsa);
375         if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
376             ok = ok && ossl_rsa_validate_public(rsa);
377     }
378     return ok;
379 }
380
381 struct rsa_gen_ctx {
382     OSSL_LIB_CTX *libctx;
383     const char *propq;
384
385     int rsa_type;
386
387     size_t nbits;
388     BIGNUM *pub_exp;
389     size_t primes;
390
391     /* For PSS */
392     RSA_PSS_PARAMS_30 pss_params;
393
394     /* For generation callback */
395     OSSL_CALLBACK *cb;
396     void *cbarg;
397
398 #if defined(FIPS_MODULE) && !defined(OPENSSL_NO_ACVP_TESTS)
399     /* ACVP test parameters */
400     OSSL_PARAM *acvp_test_params;
401 #endif
402 };
403
404 static int rsa_gencb(int p, int n, BN_GENCB *cb)
405 {
406     struct rsa_gen_ctx *gctx = BN_GENCB_get_arg(cb);
407     OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END };
408
409     params[0] = OSSL_PARAM_construct_int(OSSL_GEN_PARAM_POTENTIAL, &p);
410     params[1] = OSSL_PARAM_construct_int(OSSL_GEN_PARAM_ITERATION, &n);
411     return gctx->cb(params, gctx->cbarg);
412 }
413
414 static void *gen_init(void *provctx, int selection, int rsa_type)
415 {
416     OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(provctx);
417     struct rsa_gen_ctx *gctx = NULL;
418
419     if (!ossl_prov_is_running())
420         return NULL;
421
422     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
423         return NULL;
424
425     if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL) {
426         gctx->libctx = libctx;
427         if ((gctx->pub_exp = BN_new()) == NULL
428             || !BN_set_word(gctx->pub_exp, RSA_F4)) {
429             BN_free(gctx->pub_exp);
430             OPENSSL_free(gctx);
431             gctx = NULL;
432         } else {
433             gctx->nbits = 2048;
434             gctx->primes = RSA_DEFAULT_PRIME_NUM;
435             gctx->rsa_type = rsa_type;
436         }
437     }
438     return gctx;
439 }
440
441 static void *rsa_gen_init(void *provctx, int selection)
442 {
443     return gen_init(provctx, selection, RSA_FLAG_TYPE_RSA);
444 }
445
446 static void *rsapss_gen_init(void *provctx, int selection)
447 {
448     return gen_init(provctx, selection, RSA_FLAG_TYPE_RSASSAPSS);
449 }
450
451 /*
452  * This function is common for all RSA sub-types, to detect possible
453  * misuse, such as PSS parameters being passed when a plain RSA key
454  * is generated.
455  */
456 static int rsa_gen_set_params(void *genctx, const OSSL_PARAM params[])
457 {
458     struct rsa_gen_ctx *gctx = genctx;
459     const OSSL_PARAM *p;
460
461     if ((p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_BITS)) != NULL
462         && !OSSL_PARAM_get_size_t(p, &gctx->nbits))
463         return 0;
464     if ((p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_PRIMES)) != NULL
465         && !OSSL_PARAM_get_size_t(p, &gctx->primes))
466         return 0;
467     if ((p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_E)) != NULL
468         && !OSSL_PARAM_get_BN(p, &gctx->pub_exp))
469         return 0;
470     /* Only attempt to get PSS parameters when generating an RSA-PSS key */
471     if (gctx->rsa_type == RSA_FLAG_TYPE_RSASSAPSS
472         && !pss_params_fromdata(&gctx->pss_params, params, gctx->rsa_type,
473                                 gctx->libctx))
474         return 0;
475 #if defined(FIPS_MODULE) && !defined(OPENSSL_NO_ACVP_TESTS)
476     /* Any ACVP test related parameters are copied into a params[] */
477     if (!rsa_acvp_test_gen_params_new(&gctx->acvp_test_params, params))
478         return 0;
479 #endif
480     return 1;
481 }
482
483 #define rsa_gen_basic                                           \
484     OSSL_PARAM_size_t(OSSL_PKEY_PARAM_RSA_BITS, NULL),          \
485     OSSL_PARAM_size_t(OSSL_PKEY_PARAM_RSA_PRIMES, NULL),        \
486     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_E, NULL, 0)
487
488 /*
489  * The following must be kept in sync with ossl_rsa_pss_params_30_fromdata()
490  * in crypto/rsa/rsa_backend.c
491  */
492 #define rsa_gen_pss                                                     \
493     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_RSA_DIGEST, NULL, 0),        \
494     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_RSA_DIGEST_PROPS, NULL, 0),  \
495     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_RSA_MASKGENFUNC, NULL, 0),   \
496     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_RSA_MGF1_DIGEST, NULL, 0),   \
497     OSSL_PARAM_int(OSSL_PKEY_PARAM_RSA_PSS_SALTLEN, NULL)
498
499 static const OSSL_PARAM *rsa_gen_settable_params(void *provctx)
500 {
501     static OSSL_PARAM settable[] = {
502         rsa_gen_basic,
503         OSSL_PARAM_END
504     };
505
506     return settable;
507 }
508
509 static const OSSL_PARAM *rsapss_gen_settable_params(void *provctx)
510 {
511     static OSSL_PARAM settable[] = {
512         rsa_gen_basic,
513         rsa_gen_pss,
514         OSSL_PARAM_END
515     };
516
517     return settable;
518 }
519
520 static void *rsa_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
521 {
522     struct rsa_gen_ctx *gctx = genctx;
523     RSA *rsa = NULL, *rsa_tmp = NULL;
524     BN_GENCB *gencb = NULL;
525
526     if (!ossl_prov_is_running() || gctx == NULL)
527         return NULL;
528
529     switch (gctx->rsa_type) {
530     case RSA_FLAG_TYPE_RSA:
531         /* For plain RSA keys, PSS parameters must not be set */
532         if (!ossl_rsa_pss_params_30_is_unrestricted(&gctx->pss_params))
533             goto err;
534         break;
535     case RSA_FLAG_TYPE_RSASSAPSS:
536         /*
537          * For plain RSA-PSS keys, PSS parameters may be set but don't have
538          * to, so not check.
539          */
540         break;
541     default:
542         /* Unsupported RSA key sub-type... */
543         return NULL;
544     }
545
546     if ((rsa_tmp = ossl_rsa_new_with_ctx(gctx->libctx)) == NULL)
547         return NULL;
548
549     gctx->cb = osslcb;
550     gctx->cbarg = cbarg;
551     gencb = BN_GENCB_new();
552     if (gencb != NULL)
553         BN_GENCB_set(gencb, rsa_gencb, genctx);
554
555 #if defined(FIPS_MODULE) && !defined(OPENSSL_NO_ACVP_TESTS)
556     if (gctx->acvp_test_params != NULL) {
557         if (!rsa_acvp_test_set_params(rsa_tmp, gctx->acvp_test_params))
558             goto err;
559     }
560 #endif
561
562     if (!RSA_generate_multi_prime_key(rsa_tmp,
563                                       (int)gctx->nbits, (int)gctx->primes,
564                                       gctx->pub_exp, gencb))
565         goto err;
566
567     if (!ossl_rsa_pss_params_30_copy(ossl_rsa_get0_pss_params_30(rsa_tmp),
568                                      &gctx->pss_params))
569         goto err;
570
571     RSA_clear_flags(rsa_tmp, RSA_FLAG_TYPE_MASK);
572     RSA_set_flags(rsa_tmp, gctx->rsa_type);
573
574     rsa = rsa_tmp;
575     rsa_tmp = NULL;
576  err:
577     BN_GENCB_free(gencb);
578     RSA_free(rsa_tmp);
579     return rsa;
580 }
581
582 static void rsa_gen_cleanup(void *genctx)
583 {
584     struct rsa_gen_ctx *gctx = genctx;
585
586     if (gctx == NULL)
587         return;
588 #if defined(FIPS_MODULE) && !defined(OPENSSL_NO_ACVP_TESTS)
589     rsa_acvp_test_gen_params_free(gctx->acvp_test_params);
590     gctx->acvp_test_params = NULL;
591 #endif
592     BN_clear_free(gctx->pub_exp);
593     OPENSSL_free(gctx);
594 }
595
596 void *rsa_load(const void *reference, size_t reference_sz)
597 {
598     RSA *rsa = NULL;
599
600     if (ossl_prov_is_running() && reference_sz == sizeof(rsa)) {
601         /* The contents of the reference is the address to our object */
602         rsa = *(RSA **)reference;
603         /* We grabbed, so we detach it */
604         *(RSA **)reference = NULL;
605         return rsa;
606     }
607     return NULL;
608 }
609
610 /* For any RSA key, we use the "RSA" algorithms regardless of sub-type. */
611 static const char *rsa_query_operation_name(int operation_id)
612 {
613     return "RSA";
614 }
615
616 const OSSL_DISPATCH ossl_rsa_keymgmt_functions[] = {
617     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))rsa_newdata },
618     { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))rsa_gen_init },
619     { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS,
620       (void (*)(void))rsa_gen_set_params },
621     { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
622       (void (*)(void))rsa_gen_settable_params },
623     { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))rsa_gen },
624     { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))rsa_gen_cleanup },
625     { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))rsa_load },
626     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))rsa_freedata },
627     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))rsa_get_params },
628     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))rsa_gettable_params },
629     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))rsa_has },
630     { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))rsa_match },
631     { OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))rsa_validate },
632     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))rsa_import },
633     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))rsa_import_types },
634     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))rsa_export },
635     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))rsa_export_types },
636     { 0, NULL }
637 };
638
639 const OSSL_DISPATCH ossl_rsapss_keymgmt_functions[] = {
640     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))rsapss_newdata },
641     { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))rsapss_gen_init },
642     { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, (void (*)(void))rsa_gen_set_params },
643     { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
644       (void (*)(void))rsapss_gen_settable_params },
645     { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))rsa_gen },
646     { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))rsa_gen_cleanup },
647     { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))rsa_load },
648     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))rsa_freedata },
649     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))rsa_get_params },
650     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))rsa_gettable_params },
651     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))rsa_has },
652     { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))rsa_match },
653     { OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))rsa_validate },
654     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))rsa_import },
655     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))rsa_import_types },
656     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))rsa_export },
657     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))rsa_export_types },
658     { OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME,
659       (void (*)(void))rsa_query_operation_name },
660     { 0, NULL }
661 };