1 /*
2 * Copyright 2024-2025 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 #include <openssl/core_dispatch.h>
11 #include <openssl/core_names.h>
12 #include <openssl/param_build.h>
13 #include <openssl/self_test.h>
14 #include <openssl/proverr.h>
15 #include "crypto/slh_dsa.h"
16 #include "internal/fips.h"
17 #include "internal/param_build_set.h"
18 #include "prov/implementations.h"
19 #include "prov/providercommon.h"
20 #include "prov/provider_ctx.h"
21
22 #ifdef FIPS_MODULE
23 static int slh_dsa_fips140_pairwise_test(const SLH_DSA_KEY *key,
24 SLH_DSA_HASH_CTX *ctx);
25 #endif /* FIPS_MODULE */
26
27 static OSSL_FUNC_keymgmt_free_fn slh_dsa_free_key;
28 static OSSL_FUNC_keymgmt_has_fn slh_dsa_has;
29 static OSSL_FUNC_keymgmt_match_fn slh_dsa_match;
30 static OSSL_FUNC_keymgmt_import_fn slh_dsa_import;
31 static OSSL_FUNC_keymgmt_export_fn slh_dsa_export;
32 static OSSL_FUNC_keymgmt_import_types_fn slh_dsa_imexport_types;
33 static OSSL_FUNC_keymgmt_export_types_fn slh_dsa_imexport_types;
34 static OSSL_FUNC_keymgmt_load_fn slh_dsa_load;
35 static OSSL_FUNC_keymgmt_get_params_fn slh_dsa_get_params;
36 static OSSL_FUNC_keymgmt_gettable_params_fn slh_dsa_gettable_params;
37 static OSSL_FUNC_keymgmt_validate_fn slh_dsa_validate;
38 static OSSL_FUNC_keymgmt_gen_init_fn slh_dsa_gen_init;
39 static OSSL_FUNC_keymgmt_gen_cleanup_fn slh_dsa_gen_cleanup;
40 static OSSL_FUNC_keymgmt_gen_set_params_fn slh_dsa_gen_set_params;
41 static OSSL_FUNC_keymgmt_gen_settable_params_fn slh_dsa_gen_settable_params;
42 static OSSL_FUNC_keymgmt_dup_fn slh_dsa_dup_key;
43
44 #define SLH_DSA_POSSIBLE_SELECTIONS (OSSL_KEYMGMT_SELECT_KEYPAIR)
45
46 struct slh_dsa_gen_ctx {
47 SLH_DSA_HASH_CTX *ctx;
48 OSSL_LIB_CTX *libctx;
49 char *propq;
50 uint8_t entropy[SLH_DSA_MAX_N * 3];
51 size_t entropy_len;
52 };
53
slh_dsa_new_key(void * provctx,const char * alg)54 static void *slh_dsa_new_key(void *provctx, const char *alg)
55 {
56 if (!ossl_prov_is_running())
57 return 0;
58
59 return ossl_slh_dsa_key_new(PROV_LIBCTX_OF(provctx), NULL, alg);
60 }
61
slh_dsa_free_key(void * keydata)62 static void slh_dsa_free_key(void *keydata)
63 {
64 ossl_slh_dsa_key_free((SLH_DSA_KEY *)keydata);
65 }
66
slh_dsa_dup_key(const void * keydata_from,int selection)67 static void *slh_dsa_dup_key(const void *keydata_from, int selection)
68 {
69 if (ossl_prov_is_running())
70 return ossl_slh_dsa_key_dup(keydata_from, selection);
71 return NULL;
72 }
73
slh_dsa_has(const void * keydata,int selection)74 static int slh_dsa_has(const void *keydata, int selection)
75 {
76 const SLH_DSA_KEY *key = keydata;
77
78 if (!ossl_prov_is_running() || key == NULL)
79 return 0;
80 if ((selection & SLH_DSA_POSSIBLE_SELECTIONS) == 0)
81 return 1; /* the selection is not missing */
82
83 return ossl_slh_dsa_key_has(key, selection);
84 }
85
slh_dsa_match(const void * keydata1,const void * keydata2,int selection)86 static int slh_dsa_match(const void *keydata1, const void *keydata2, int selection)
87 {
88 const SLH_DSA_KEY *key1 = keydata1;
89 const SLH_DSA_KEY *key2 = keydata2;
90
91 if (!ossl_prov_is_running())
92 return 0;
93 if (key1 == NULL || key2 == NULL)
94 return 0;
95 return ossl_slh_dsa_key_equal(key1, key2, selection);
96 }
97
slh_dsa_validate(const void * key_data,int selection,int check_type)98 static int slh_dsa_validate(const void *key_data, int selection, int check_type)
99 {
100 const SLH_DSA_KEY *key = key_data;
101
102 if (!slh_dsa_has(key, selection))
103 return 0;
104
105 if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == OSSL_KEYMGMT_SELECT_KEYPAIR)
106 return ossl_slh_dsa_key_pairwise_check(key);
107 return 1;
108 }
109
slh_dsa_import(void * keydata,int selection,const OSSL_PARAM params[])110 static int slh_dsa_import(void *keydata, int selection, const OSSL_PARAM params[])
111 {
112 SLH_DSA_KEY *key = keydata;
113 int include_priv;
114
115 if (!ossl_prov_is_running() || key == NULL)
116 return 0;
117
118 if ((selection & SLH_DSA_POSSIBLE_SELECTIONS) == 0)
119 return 0;
120
121 include_priv = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);
122 return ossl_slh_dsa_key_fromdata(key, params, include_priv);
123 }
124
125 #define SLH_DSA_IMEXPORTABLE_PARAMETERS \
126 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0), \
127 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0)
128
129 static const OSSL_PARAM slh_dsa_key_types[] = {
130 SLH_DSA_IMEXPORTABLE_PARAMETERS,
131 OSSL_PARAM_END
132 };
slh_dsa_imexport_types(int selection)133 static const OSSL_PARAM *slh_dsa_imexport_types(int selection)
134 {
135 if ((selection & SLH_DSA_POSSIBLE_SELECTIONS) == 0)
136 return NULL;
137 return slh_dsa_key_types;
138 }
139
140 static const OSSL_PARAM slh_dsa_params[] = {
141 OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
142 OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
143 OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
144 OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
145 SLH_DSA_IMEXPORTABLE_PARAMETERS,
146 OSSL_PARAM_END
147 };
slh_dsa_gettable_params(void * provctx)148 static const OSSL_PARAM *slh_dsa_gettable_params(void *provctx)
149 {
150 return slh_dsa_params;
151 }
152
key_to_params(SLH_DSA_KEY * key,OSSL_PARAM_BLD * tmpl,int selection)153 static int key_to_params(SLH_DSA_KEY *key, OSSL_PARAM_BLD *tmpl,
154 int selection)
155 {
156 /* Error if there is no key or public key */
157 if (key == NULL || ossl_slh_dsa_key_get_pub(key) == NULL)
158 return 0;
159
160 if (((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
161 && ossl_slh_dsa_key_get_priv(key) != NULL)
162 if (ossl_param_build_set_octet_string(tmpl, NULL,
163 OSSL_PKEY_PARAM_PRIV_KEY,
164 ossl_slh_dsa_key_get_priv(key),
165 ossl_slh_dsa_key_get_priv_len(key))
166 != 1)
167 return 0;
168
169 if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) == 0)
170 return 1;
171
172 return ossl_param_build_set_octet_string(tmpl, NULL,
173 OSSL_PKEY_PARAM_PUB_KEY,
174 ossl_slh_dsa_key_get_pub(key),
175 ossl_slh_dsa_key_get_pub_len(key));
176 }
177
slh_dsa_get_params(void * keydata,OSSL_PARAM params[])178 static int slh_dsa_get_params(void *keydata, OSSL_PARAM params[])
179 {
180 SLH_DSA_KEY *key = keydata;
181 OSSL_PARAM *p;
182 const uint8_t *pub, *priv;
183
184 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
185 && !OSSL_PARAM_set_int(p, 8 * ossl_slh_dsa_key_get_pub_len(key)))
186 return 0;
187 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
188 && !OSSL_PARAM_set_int(p, 8 * ossl_slh_dsa_key_get_n(key)))
189 return 0;
190 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
191 && !OSSL_PARAM_set_int(p, ossl_slh_dsa_key_get_sig_len(key)))
192 return 0;
193
194 priv = ossl_slh_dsa_key_get_priv(key);
195 if (priv != NULL) {
196 p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PRIV_KEY);
197 /* Note: ossl_slh_dsa_key_get_priv_len() includes the public key */
198 if (p != NULL
199 && !OSSL_PARAM_set_octet_string(p, priv,
200 ossl_slh_dsa_key_get_priv_len(key)))
201 return 0;
202 }
203 pub = ossl_slh_dsa_key_get_pub(key);
204 if (pub != NULL) {
205 p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY);
206 if (p != NULL
207 && !OSSL_PARAM_set_octet_string(p, pub,
208 ossl_slh_dsa_key_get_pub_len(key)))
209 return 0;
210 }
211 /*
212 * This allows apps to use an empty digest, so that the old API
213 * for digest signing can be used.
214 */
215 p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MANDATORY_DIGEST);
216 if (p != NULL && !OSSL_PARAM_set_utf8_string(p, ""))
217 return 0;
218 return 1;
219 }
220
slh_dsa_export(void * keydata,int selection,OSSL_CALLBACK * param_cb,void * cbarg)221 static int slh_dsa_export(void *keydata, int selection, OSSL_CALLBACK *param_cb,
222 void *cbarg)
223 {
224 SLH_DSA_KEY *key = keydata;
225 OSSL_PARAM_BLD *tmpl;
226 OSSL_PARAM *params = NULL;
227 int ret = 0;
228
229 if (!ossl_prov_is_running() || key == NULL)
230 return 0;
231
232 if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
233 return 0;
234
235 tmpl = OSSL_PARAM_BLD_new();
236 if (tmpl == NULL)
237 return 0;
238
239 if (!key_to_params(key, tmpl, selection))
240 goto err;
241
242 params = OSSL_PARAM_BLD_to_param(tmpl);
243 if (params == NULL)
244 goto err;
245
246 ret = param_cb(params, cbarg);
247 OSSL_PARAM_free(params);
248 err:
249 OSSL_PARAM_BLD_free(tmpl);
250 return ret;
251 }
252
slh_dsa_load(const void * reference,size_t reference_sz)253 static void *slh_dsa_load(const void *reference, size_t reference_sz)
254 {
255 SLH_DSA_KEY *key = NULL;
256
257 if (ossl_prov_is_running() && reference_sz == sizeof(key)) {
258 /* The contents of the reference is the address to our object */
259 key = *(SLH_DSA_KEY **)reference;
260 /* We grabbed, so we detach it */
261 *(SLH_DSA_KEY **)reference = NULL;
262 return key;
263 }
264 return NULL;
265 }
266
slh_dsa_gen_init(void * provctx,int selection,const OSSL_PARAM params[])267 static void *slh_dsa_gen_init(void *provctx, int selection,
268 const OSSL_PARAM params[])
269 {
270 OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(provctx);
271 struct slh_dsa_gen_ctx *gctx = NULL;
272
273 if (!ossl_prov_is_running())
274 return NULL;
275
276 if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL) {
277 gctx->libctx = libctx;
278 if (!slh_dsa_gen_set_params(gctx, params)) {
279 OPENSSL_free(gctx);
280 gctx = NULL;
281 }
282 }
283 return gctx;
284 }
285
286 #ifdef FIPS_MODULE
287 /*
288 * Refer to FIPS 140-3 IG 10.3.A Additional Comment 1
289 * Perform a pairwise test for SLH_DSA by signing and verifying a signature.
290 */
slh_dsa_fips140_pairwise_test(const SLH_DSA_KEY * key,SLH_DSA_HASH_CTX * ctx)291 static int slh_dsa_fips140_pairwise_test(const SLH_DSA_KEY *key,
292 SLH_DSA_HASH_CTX *ctx)
293 {
294 int ret = 0;
295 OSSL_SELF_TEST *st = NULL;
296 OSSL_CALLBACK *cb = NULL;
297 void *cb_arg = NULL;
298 uint8_t msg[16] = { 0 };
299 size_t msg_len = sizeof(msg);
300 uint8_t *sig = NULL;
301 size_t sig_len;
302 OSSL_LIB_CTX *lib_ctx;
303 int alloc_ctx = 0;
304
305 /* During self test, it is a waste to do this test */
306 if (ossl_fips_self_testing())
307 return 1;
308
309 if (ctx == NULL) {
310 ctx = ossl_slh_dsa_hash_ctx_new(key);
311 if (ctx == NULL)
312 return 0;
313 alloc_ctx = 1;
314 }
315 lib_ctx = ossl_slh_dsa_key_get0_libctx(key);
316
317 OSSL_SELF_TEST_get_callback(lib_ctx, &cb, &cb_arg);
318 st = OSSL_SELF_TEST_new(cb, cb_arg);
319 if (st == NULL)
320 goto err;
321
322 OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_PCT,
323 OSSL_SELF_TEST_DESC_PCT_SLH_DSA);
324
325 sig_len = ossl_slh_dsa_key_get_sig_len(key);
326 sig = OPENSSL_malloc(sig_len);
327 if (sig == NULL)
328 goto err;
329
330 if (ossl_slh_dsa_sign(ctx, msg, msg_len, NULL, 0, NULL, 0,
331 sig, &sig_len, sig_len)
332 != 1)
333 goto err;
334
335 OSSL_SELF_TEST_oncorrupt_byte(st, sig);
336
337 if (ossl_slh_dsa_verify(ctx, msg, msg_len, NULL, 0, 0, sig, sig_len) != 1)
338 goto err;
339
340 ret = 1;
341 err:
342 if (alloc_ctx)
343 ossl_slh_dsa_hash_ctx_free(ctx);
344 OPENSSL_free(sig);
345 OSSL_SELF_TEST_onend(st, ret);
346 OSSL_SELF_TEST_free(st);
347 return ret;
348 }
349 #endif /* FIPS_MODULE */
350
slh_dsa_gen(void * genctx,const char * alg)351 static void *slh_dsa_gen(void *genctx, const char *alg)
352 {
353 struct slh_dsa_gen_ctx *gctx = genctx;
354 SLH_DSA_KEY *key = NULL;
355 SLH_DSA_HASH_CTX *ctx = NULL;
356
357 if (!ossl_prov_is_running())
358 return NULL;
359 key = ossl_slh_dsa_key_new(gctx->libctx, gctx->propq, alg);
360 if (key == NULL)
361 return NULL;
362 ctx = ossl_slh_dsa_hash_ctx_new(key);
363 if (ctx == NULL)
364 goto err;
365 if (!ossl_slh_dsa_generate_key(ctx, key, gctx->libctx,
366 gctx->entropy, gctx->entropy_len))
367 goto err;
368 #ifdef FIPS_MODULE
369 if (!slh_dsa_fips140_pairwise_test(key, ctx)) {
370 ossl_set_error_state(OSSL_SELF_TEST_TYPE_PCT);
371 goto err;
372 }
373 #endif /* FIPS_MODULE */
374 ossl_slh_dsa_hash_ctx_free(ctx);
375 return key;
376 err:
377 ossl_slh_dsa_hash_ctx_free(ctx);
378 ossl_slh_dsa_key_free(key);
379 return NULL;
380 }
381
slh_dsa_gen_set_params(void * genctx,const OSSL_PARAM params[])382 static int slh_dsa_gen_set_params(void *genctx, const OSSL_PARAM params[])
383 {
384 struct slh_dsa_gen_ctx *gctx = genctx;
385 const OSSL_PARAM *p;
386
387 if (gctx == NULL)
388 return 0;
389
390 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_SLH_DSA_SEED);
391 if (p != NULL) {
392 void *vp = gctx->entropy;
393 size_t len = sizeof(gctx->entropy);
394
395 if (!OSSL_PARAM_get_octet_string(p, &vp, len, &(gctx->entropy_len))) {
396 gctx->entropy_len = 0;
397 return 0;
398 }
399 }
400
401 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PROPERTIES);
402 if (p != NULL) {
403 if (p->data_type != OSSL_PARAM_UTF8_STRING)
404 return 0;
405 OPENSSL_free(gctx->propq);
406 gctx->propq = OPENSSL_strdup(p->data);
407 if (gctx->propq == NULL)
408 return 0;
409 }
410 return 1;
411 }
412
slh_dsa_gen_settable_params(ossl_unused void * genctx,ossl_unused void * provctx)413 static const OSSL_PARAM *slh_dsa_gen_settable_params(ossl_unused void *genctx,
414 ossl_unused void *provctx)
415 {
416 static OSSL_PARAM settable[] = {
417 OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
418 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_SLH_DSA_SEED, NULL, 0),
419 OSSL_PARAM_END
420 };
421 return settable;
422 }
423
slh_dsa_gen_cleanup(void * genctx)424 static void slh_dsa_gen_cleanup(void *genctx)
425 {
426 struct slh_dsa_gen_ctx *gctx = genctx;
427
428 if (gctx == NULL)
429 return;
430
431 OPENSSL_cleanse(gctx->entropy, gctx->entropy_len);
432 OPENSSL_free(gctx->propq);
433 OPENSSL_free(gctx);
434 }
435
436 #define MAKE_KEYMGMT_FUNCTIONS(alg, fn) \
437 static OSSL_FUNC_keymgmt_new_fn slh_dsa_##fn##_new_key; \
438 static OSSL_FUNC_keymgmt_gen_fn slh_dsa_##fn##_gen; \
439 static void *slh_dsa_##fn##_new_key(void *provctx) \
440 { \
441 return slh_dsa_new_key(provctx, alg); \
442 } \
443 static void *slh_dsa_##fn##_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg) \
444 { \
445 return slh_dsa_gen(genctx, alg); \
446 } \
447 const OSSL_DISPATCH ossl_slh_dsa_##fn##_keymgmt_functions[] = { \
448 { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))slh_dsa_##fn##_new_key }, \
449 { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))slh_dsa_free_key }, \
450 { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))slh_dsa_dup_key }, \
451 { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))slh_dsa_has }, \
452 { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))slh_dsa_match }, \
453 { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))slh_dsa_import }, \
454 { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))slh_dsa_imexport_types }, \
455 { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))slh_dsa_export }, \
456 { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))slh_dsa_imexport_types }, \
457 { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))slh_dsa_load }, \
458 { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*)(void))slh_dsa_get_params }, \
459 { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*)(void))slh_dsa_gettable_params }, \
460 { OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))slh_dsa_validate }, \
461 { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))slh_dsa_gen_init }, \
462 { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))slh_dsa_##fn##_gen }, \
463 { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))slh_dsa_gen_cleanup }, \
464 { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, \
465 (void (*)(void))slh_dsa_gen_set_params }, \
466 { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS, \
467 (void (*)(void))slh_dsa_gen_settable_params }, \
468 OSSL_DISPATCH_END \
469 }
470
471 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-128s", sha2_128s);
472 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-128f", sha2_128f);
473 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-192s", sha2_192s);
474 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-192f", sha2_192f);
475 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-256s", sha2_256s);
476 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-256f", sha2_256f);
477 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-128s", shake_128s);
478 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-128f", shake_128f);
479 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-192s", shake_192s);
480 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-192f", shake_192f);
481 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-256s", shake_256s);
482 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-256f", shake_256f);
483