98c369d97f4037be02bc7e2b4803bc169494a58b
[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                                OPENSSL_CTX *libctx)
62 {
63     if (!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         && !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     OPENSSL_CTX *libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
77     RSA *rsa;
78
79     if (!ossl_prov_is_running())
80         return NULL;
81
82     rsa = 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     OPENSSL_CTX *libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
93     RSA *rsa;
94
95     if (!ossl_prov_is_running())
96         return NULL;
97
98     rsa = 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(void *keydata, int selection)
112 {
113     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(rsa_get0_pss_params_30(rsa), params,
169                                        rsa_type, rsa_get0_libctx(rsa));
170     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
171         ok = ok && 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 = 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 && (rsa_pss_params_30_is_unrestricted(pss_params)
196                     || rsa_pss_params_30_todata(pss_params, tmpl, NULL));
197     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0)
198         ok = ok && 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 = 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         const char *mdname = RSA_PSS_DEFAULT_MD;
332
333         if (!rsa_pss_params_30_is_unrestricted(pss_params)) {
334             mdname =
335                 rsa_oaeppss_nid2name(rsa_pss_params_30_hashalg(pss_params));
336
337             if (mdname == NULL || !OSSL_PARAM_set_utf8_string(p, mdname))
338                 return 0;
339         }
340     }
341     return (rsa_type != RSA_FLAG_TYPE_RSASSAPSS
342             || rsa_pss_params_30_todata(pss_params, NULL, params))
343         && rsa_todata(rsa, NULL, params);
344 }
345
346 static const OSSL_PARAM rsa_params[] = {
347     OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
348     OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
349     OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
350     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_DEFAULT_DIGEST, NULL, 0),
351     RSA_KEY_TYPES()
352     OSSL_PARAM_END
353 };
354
355 static const OSSL_PARAM *rsa_gettable_params(void *provctx)
356 {
357     return rsa_params;
358 }
359
360 static int rsa_validate(void *keydata, int selection)
361 {
362     RSA *rsa = keydata;
363     int ok = 0;
364
365     if (!ossl_prov_is_running())
366         return 0;
367
368     if ((selection & RSA_POSSIBLE_SELECTIONS) != 0)
369         ok = 1;
370
371     /* If the whole key is selected, we do a pairwise validation */
372     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR)
373         == OSSL_KEYMGMT_SELECT_KEYPAIR) {
374         ok = ok && rsa_validate_pairwise(rsa);
375     } else {
376         if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
377             ok = ok && rsa_validate_private(rsa);
378         if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
379             ok = ok && rsa_validate_public(rsa);
380     }
381     return ok;
382 }
383
384 struct rsa_gen_ctx {
385     OPENSSL_CTX *libctx;
386     const char *propq;
387
388     int rsa_type;
389
390     size_t nbits;
391     BIGNUM *pub_exp;
392     size_t primes;
393
394     /* For PSS */
395     RSA_PSS_PARAMS_30 pss_params;
396
397     /* For generation callback */
398     OSSL_CALLBACK *cb;
399     void *cbarg;
400
401 #if defined(FIPS_MODULE) && !defined(OPENSSL_NO_ACVP_TESTS)
402     /* ACVP test parameters */
403     OSSL_PARAM *acvp_test_params;
404 #endif
405 };
406
407 static int rsa_gencb(int p, int n, BN_GENCB *cb)
408 {
409     struct rsa_gen_ctx *gctx = BN_GENCB_get_arg(cb);
410     OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END };
411
412     params[0] = OSSL_PARAM_construct_int(OSSL_GEN_PARAM_POTENTIAL, &p);
413     params[1] = OSSL_PARAM_construct_int(OSSL_GEN_PARAM_ITERATION, &n);
414     return gctx->cb(params, gctx->cbarg);
415 }
416
417 static void *gen_init(void *provctx, int selection, int rsa_type)
418 {
419     OPENSSL_CTX *libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
420     struct rsa_gen_ctx *gctx = NULL;
421
422     if (!ossl_prov_is_running())
423         return NULL;
424
425     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
426         return NULL;
427
428     if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL) {
429         gctx->libctx = libctx;
430         if ((gctx->pub_exp = BN_new()) == NULL
431             || !BN_set_word(gctx->pub_exp, RSA_F4)) {
432             BN_free(gctx->pub_exp);
433             OPENSSL_free(gctx);
434             gctx = NULL;
435         } else {
436             gctx->nbits = 2048;
437             gctx->primes = RSA_DEFAULT_PRIME_NUM;
438             gctx->rsa_type = rsa_type;
439         }
440     }
441     return gctx;
442 }
443
444 static void *rsa_gen_init(void *provctx, int selection)
445 {
446     return gen_init(provctx, selection, RSA_FLAG_TYPE_RSA);
447 }
448
449 static void *rsapss_gen_init(void *provctx, int selection)
450 {
451     return gen_init(provctx, selection, RSA_FLAG_TYPE_RSASSAPSS);
452 }
453
454 /*
455  * This function is common for all RSA sub-types, to detect possible
456  * misuse, such as PSS parameters being passed when a plain RSA key
457  * is generated.
458  */
459 static int rsa_gen_set_params(void *genctx, const OSSL_PARAM params[])
460 {
461     struct rsa_gen_ctx *gctx = genctx;
462     const OSSL_PARAM *p;
463
464     if ((p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_BITS)) != NULL
465         && !OSSL_PARAM_get_size_t(p, &gctx->nbits))
466         return 0;
467     if ((p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_PRIMES)) != NULL
468         && !OSSL_PARAM_get_size_t(p, &gctx->primes))
469         return 0;
470     if ((p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_RSA_E)) != NULL
471         && !OSSL_PARAM_get_BN(p, &gctx->pub_exp))
472         return 0;
473     /* Only attempt to get PSS parameters when generating an RSA-PSS key */
474     if (gctx->rsa_type == RSA_FLAG_TYPE_RSASSAPSS
475         && !pss_params_fromdata(&gctx->pss_params, params, gctx->rsa_type,
476                                 gctx->libctx))
477         return 0;
478 #if defined(FIPS_MODULE) && !defined(OPENSSL_NO_ACVP_TESTS)
479     /* Any ACVP test related parameters are copied into a params[] */
480     if (!rsa_acvp_test_gen_params_new(&gctx->acvp_test_params, params))
481         return 0;
482 #endif
483     return 1;
484 }
485
486 #define rsa_gen_basic                                           \
487     OSSL_PARAM_size_t(OSSL_PKEY_PARAM_RSA_BITS, NULL),          \
488     OSSL_PARAM_size_t(OSSL_PKEY_PARAM_RSA_PRIMES, NULL),        \
489     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_E, NULL, 0)
490
491 /*
492  * The following must be kept in sync with rsa_pss_params_30_fromdata()
493  * in crypto/rsa/rsa_backend.c
494  */
495 #define rsa_gen_pss                                                     \
496     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_RSA_DIGEST, NULL, 0),        \
497     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_RSA_DIGEST_PROPS, NULL, 0),  \
498     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_RSA_MASKGENFUNC, NULL, 0),   \
499     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_RSA_MGF1_DIGEST, NULL, 0),   \
500     OSSL_PARAM_int(OSSL_PKEY_PARAM_RSA_PSS_SALTLEN, NULL)
501
502 static const OSSL_PARAM *rsa_gen_settable_params(void *provctx)
503 {
504     static OSSL_PARAM settable[] = {
505         rsa_gen_basic,
506         OSSL_PARAM_END
507     };
508
509     return settable;
510 }
511
512 static const OSSL_PARAM *rsapss_gen_settable_params(void *provctx)
513 {
514     static OSSL_PARAM settable[] = {
515         rsa_gen_basic,
516         rsa_gen_pss,
517         OSSL_PARAM_END
518     };
519
520     return settable;
521 }
522
523 static void *rsa_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
524 {
525     struct rsa_gen_ctx *gctx = genctx;
526     RSA *rsa = NULL, *rsa_tmp = NULL;
527     BN_GENCB *gencb = NULL;
528
529     if (!ossl_prov_is_running() || gctx == NULL)
530         return NULL;
531
532     switch (gctx->rsa_type) {
533     case RSA_FLAG_TYPE_RSA:
534         /* For plain RSA keys, PSS parameters must not be set */
535         if (!rsa_pss_params_30_is_unrestricted(&gctx->pss_params))
536             goto err;
537         break;
538     case RSA_FLAG_TYPE_RSASSAPSS:
539         /*
540          * For plain RSA-PSS keys, PSS parameters may be set but don't have
541          * to, so not check.
542          */
543         break;
544     default:
545         /* Unsupported RSA key sub-type... */
546         return NULL;
547     }
548
549     if ((rsa_tmp = rsa_new_with_ctx(gctx->libctx)) == NULL)
550         return NULL;
551
552     gctx->cb = osslcb;
553     gctx->cbarg = cbarg;
554     gencb = BN_GENCB_new();
555     if (gencb != NULL)
556         BN_GENCB_set(gencb, rsa_gencb, genctx);
557
558 #if defined(FIPS_MODULE) && !defined(OPENSSL_NO_ACVP_TESTS)
559     if (gctx->acvp_test_params != NULL) {
560         if (!rsa_acvp_test_set_params(rsa_tmp, gctx->acvp_test_params))
561             goto err;
562     }
563 #endif
564
565     if (!RSA_generate_multi_prime_key(rsa_tmp,
566                                       (int)gctx->nbits, (int)gctx->primes,
567                                       gctx->pub_exp, gencb))
568         goto err;
569
570     if (!rsa_pss_params_30_copy(rsa_get0_pss_params_30(rsa_tmp),
571                                 &gctx->pss_params))
572         goto err;
573
574     RSA_clear_flags(rsa_tmp, RSA_FLAG_TYPE_MASK);
575     RSA_set_flags(rsa_tmp, gctx->rsa_type);
576
577     rsa = rsa_tmp;
578     rsa_tmp = NULL;
579  err:
580     BN_GENCB_free(gencb);
581     RSA_free(rsa_tmp);
582     return rsa;
583 }
584
585 static void rsa_gen_cleanup(void *genctx)
586 {
587     struct rsa_gen_ctx *gctx = genctx;
588
589     if (gctx == NULL)
590         return;
591 #if defined(FIPS_MODULE) && !defined(OPENSSL_NO_ACVP_TESTS)
592     rsa_acvp_test_gen_params_free(gctx->acvp_test_params);
593     gctx->acvp_test_params = NULL;
594 #endif
595     BN_clear_free(gctx->pub_exp);
596     OPENSSL_free(gctx);
597 }
598
599 void *rsa_load(const void *reference, size_t reference_sz)
600 {
601     RSA *rsa = NULL;
602
603     if (ossl_prov_is_running() && reference_sz == sizeof(rsa)) {
604         /* The contents of the reference is the address to our object */
605         rsa = *(RSA **)reference;
606         /* We grabbed, so we detach it */
607         *(RSA **)reference = NULL;
608         return rsa;
609     }
610     return NULL;
611 }
612
613 /* For any RSA key, we use the "RSA" algorithms regardless of sub-type. */
614 static const char *rsa_query_operation_name(int operation_id)
615 {
616     return "RSA";
617 }
618
619 const OSSL_DISPATCH ossl_rsa_keymgmt_functions[] = {
620     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))rsa_newdata },
621     { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))rsa_gen_init },
622     { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS,
623       (void (*)(void))rsa_gen_set_params },
624     { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
625       (void (*)(void))rsa_gen_settable_params },
626     { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))rsa_gen },
627     { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))rsa_gen_cleanup },
628     { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))rsa_load },
629     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))rsa_freedata },
630     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))rsa_get_params },
631     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))rsa_gettable_params },
632     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))rsa_has },
633     { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))rsa_match },
634     { OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))rsa_validate },
635     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))rsa_import },
636     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))rsa_import_types },
637     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))rsa_export },
638     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))rsa_export_types },
639     { 0, NULL }
640 };
641
642 const OSSL_DISPATCH ossl_rsapss_keymgmt_functions[] = {
643     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))rsapss_newdata },
644     { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))rsapss_gen_init },
645     { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, (void (*)(void))rsa_gen_set_params },
646     { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
647       (void (*)(void))rsapss_gen_settable_params },
648     { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))rsa_gen },
649     { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))rsa_gen_cleanup },
650     { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))rsa_load },
651     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))rsa_freedata },
652     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))rsa_get_params },
653     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))rsa_gettable_params },
654     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))rsa_has },
655     { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))rsa_match },
656     { OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))rsa_validate },
657     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))rsa_import },
658     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))rsa_import_types },
659     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))rsa_export },
660     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))rsa_export_types },
661     { OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME,
662       (void (*)(void))rsa_query_operation_name },
663     { 0, NULL }
664 };