1 /*
2 * Copyright 2019-2024 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 * DSA low level APIs are deprecated for public use, but still ok for
12 * internal use.
13 */
14 #include "internal/deprecated.h"
15
16 #include <string.h>
17
18 #include <openssl/crypto.h>
19 #include <openssl/core_dispatch.h>
20 #include <openssl/core_names.h>
21 #include <openssl/err.h>
22 #include <openssl/dsa.h>
23 #include <openssl/params.h>
24 #include <openssl/evp.h>
25 #include <openssl/proverr.h>
26 #include "internal/nelem.h"
27 #include "internal/sizes.h"
28 #include "internal/cryptlib.h"
29 #include "prov/providercommon.h"
30 #include "prov/implementations.h"
31 #include "prov/provider_ctx.h"
32 #include "prov/securitycheck.h"
33 #include "prov/der_dsa.h"
34 #include "crypto/dsa.h"
35
36 static OSSL_FUNC_signature_newctx_fn dsa_newctx;
37 static OSSL_FUNC_signature_sign_init_fn dsa_sign_init;
38 static OSSL_FUNC_signature_verify_init_fn dsa_verify_init;
39 static OSSL_FUNC_signature_sign_fn dsa_sign;
40 static OSSL_FUNC_signature_sign_message_update_fn dsa_signverify_message_update;
41 static OSSL_FUNC_signature_sign_message_final_fn dsa_sign_message_final;
42 static OSSL_FUNC_signature_verify_fn dsa_verify;
43 static OSSL_FUNC_signature_verify_message_update_fn dsa_signverify_message_update;
44 static OSSL_FUNC_signature_verify_message_final_fn dsa_verify_message_final;
45 static OSSL_FUNC_signature_digest_sign_init_fn dsa_digest_sign_init;
46 static OSSL_FUNC_signature_digest_sign_update_fn dsa_digest_signverify_update;
47 static OSSL_FUNC_signature_digest_sign_final_fn dsa_digest_sign_final;
48 static OSSL_FUNC_signature_digest_verify_init_fn dsa_digest_verify_init;
49 static OSSL_FUNC_signature_digest_verify_update_fn dsa_digest_signverify_update;
50 static OSSL_FUNC_signature_digest_verify_final_fn dsa_digest_verify_final;
51 static OSSL_FUNC_signature_freectx_fn dsa_freectx;
52 static OSSL_FUNC_signature_dupctx_fn dsa_dupctx;
53 static OSSL_FUNC_signature_query_key_types_fn dsa_sigalg_query_key_types;
54 static OSSL_FUNC_signature_get_ctx_params_fn dsa_get_ctx_params;
55 static OSSL_FUNC_signature_gettable_ctx_params_fn dsa_gettable_ctx_params;
56 static OSSL_FUNC_signature_set_ctx_params_fn dsa_set_ctx_params;
57 static OSSL_FUNC_signature_settable_ctx_params_fn dsa_settable_ctx_params;
58 static OSSL_FUNC_signature_get_ctx_md_params_fn dsa_get_ctx_md_params;
59 static OSSL_FUNC_signature_gettable_ctx_md_params_fn dsa_gettable_ctx_md_params;
60 static OSSL_FUNC_signature_set_ctx_md_params_fn dsa_set_ctx_md_params;
61 static OSSL_FUNC_signature_settable_ctx_md_params_fn dsa_settable_ctx_md_params;
62 static OSSL_FUNC_signature_set_ctx_params_fn dsa_sigalg_set_ctx_params;
63 static OSSL_FUNC_signature_settable_ctx_params_fn dsa_sigalg_settable_ctx_params;
64
65 /*
66 * What's passed as an actual key is defined by the KEYMGMT interface.
67 * We happen to know that our KEYMGMT simply passes DSA structures, so
68 * we use that here too.
69 */
70
71 typedef struct {
72 OSSL_LIB_CTX *libctx;
73 char *propq;
74 DSA *dsa;
75 /* |operation| reuses EVP's operation bitfield */
76 int operation;
77
78 /*
79 * Flag to determine if a full sigalg is run (1) or if a composable
80 * signature algorithm is run (0).
81 *
82 * When a full sigalg is run (1), this currently affects the following
83 * other flags, which are to remain untouched after their initialization:
84 *
85 * - flag_allow_md (initialized to 0)
86 */
87 unsigned int flag_sigalg : 1;
88 /*
89 * Flag to determine if the hash function can be changed (1) or not (0)
90 * Because it's dangerous to change during a DigestSign or DigestVerify
91 * operation, this flag is cleared by their Init function, and set again
92 * by their Final function.
93 */
94 unsigned int flag_allow_md : 1;
95
96 /* If this is set to 1 then the generated k is not random */
97 unsigned int nonce_type;
98
99 /* The Algorithm Identifier of the combined signature algorithm */
100 unsigned char aid_buf[OSSL_MAX_ALGORITHM_ID_SIZE];
101 unsigned char *aid;
102 size_t aid_len;
103
104 /* main digest */
105 char mdname[OSSL_MAX_NAME_SIZE];
106 EVP_MD *md;
107 EVP_MD_CTX *mdctx;
108
109 /* Signature, for verification */
110 unsigned char *sig;
111 size_t siglen;
112
113 OSSL_FIPS_IND_DECLARE
114 } PROV_DSA_CTX;
115
dsa_get_md_size(const PROV_DSA_CTX * pdsactx)116 static size_t dsa_get_md_size(const PROV_DSA_CTX *pdsactx)
117 {
118 int md_size;
119
120 if (pdsactx->md != NULL) {
121 md_size = EVP_MD_get_size(pdsactx->md);
122 if (md_size <= 0)
123 return 0;
124 return (size_t)md_size;
125 }
126 return 0;
127 }
128
dsa_newctx(void * provctx,const char * propq)129 static void *dsa_newctx(void *provctx, const char *propq)
130 {
131 PROV_DSA_CTX *pdsactx;
132
133 if (!ossl_prov_is_running())
134 return NULL;
135
136 pdsactx = OPENSSL_zalloc(sizeof(PROV_DSA_CTX));
137 if (pdsactx == NULL)
138 return NULL;
139
140 pdsactx->libctx = PROV_LIBCTX_OF(provctx);
141 pdsactx->flag_allow_md = 1;
142 OSSL_FIPS_IND_INIT(pdsactx)
143 if (propq != NULL && (pdsactx->propq = OPENSSL_strdup(propq)) == NULL) {
144 OPENSSL_free(pdsactx);
145 pdsactx = NULL;
146 }
147 return pdsactx;
148 }
149
dsa_setup_md(PROV_DSA_CTX * ctx,const char * mdname,const char * mdprops,const char * desc)150 static int dsa_setup_md(PROV_DSA_CTX *ctx,
151 const char *mdname, const char *mdprops,
152 const char *desc)
153 {
154 EVP_MD *md = NULL;
155
156 if (mdprops == NULL)
157 mdprops = ctx->propq;
158
159 if (mdname != NULL) {
160 WPACKET pkt;
161 int md_nid;
162 size_t mdname_len = strlen(mdname);
163
164 md = EVP_MD_fetch(ctx->libctx, mdname, mdprops);
165 md_nid = ossl_digest_get_approved_nid(md);
166
167 if (md == NULL || md_nid < 0) {
168 if (md == NULL)
169 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
170 "%s could not be fetched", mdname);
171 if (md_nid == NID_undef)
172 ERR_raise_data(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED,
173 "digest=%s", mdname);
174 if (mdname_len >= sizeof(ctx->mdname))
175 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
176 "%s exceeds name buffer length", mdname);
177 goto err;
178 }
179 /* XOF digests don't work */
180 if (EVP_MD_xof(md)) {
181 ERR_raise(ERR_LIB_PROV, PROV_R_XOF_DIGESTS_NOT_ALLOWED);
182 goto err;
183 }
184 #ifdef FIPS_MODULE
185 {
186 int sha1_allowed
187 = ((ctx->operation
188 & (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_SIGNMSG)) == 0);
189
190 if (!ossl_fips_ind_digest_sign_check(OSSL_FIPS_IND_GET(ctx),
191 OSSL_FIPS_IND_SETTABLE1,
192 ctx->libctx,
193 md_nid, sha1_allowed, desc,
194 ossl_fips_config_signature_digest_check))
195 goto err;
196 }
197 #endif
198
199 if (!ctx->flag_allow_md) {
200 if (ctx->mdname[0] != '\0'
201 && !EVP_MD_is_a(md, ctx->mdname)) {
202 ERR_raise_data(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED,
203 "digest %s != %s", mdname, ctx->mdname);
204 goto err;
205 }
206 EVP_MD_free(md);
207 return 1;
208 }
209
210 EVP_MD_CTX_free(ctx->mdctx);
211 EVP_MD_free(ctx->md);
212
213 /*
214 * We do not care about DER writing errors.
215 * All it really means is that for some reason, there's no
216 * AlgorithmIdentifier to be had, but the operation itself is
217 * still valid, just as long as it's not used to construct
218 * anything that needs an AlgorithmIdentifier.
219 */
220 ctx->aid_len = 0;
221 if (WPACKET_init_der(&pkt, ctx->aid_buf, sizeof(ctx->aid_buf))
222 && ossl_DER_w_algorithmIdentifier_DSA_with_MD(&pkt, -1, ctx->dsa,
223 md_nid)
224 && WPACKET_finish(&pkt)) {
225 WPACKET_get_total_written(&pkt, &ctx->aid_len);
226 ctx->aid = WPACKET_get_curr(&pkt);
227 }
228 WPACKET_cleanup(&pkt);
229
230 ctx->mdctx = NULL;
231 ctx->md = md;
232 OPENSSL_strlcpy(ctx->mdname, mdname, sizeof(ctx->mdname));
233 }
234
235 return 1;
236 err:
237 EVP_MD_free(md);
238 return 0;
239 }
240
241 #ifdef FIPS_MODULE
242
dsa_sign_check_approved(PROV_DSA_CTX * ctx,int signing,const char * desc)243 static int dsa_sign_check_approved(PROV_DSA_CTX *ctx, int signing,
244 const char *desc)
245 {
246 /* DSA Signing is not approved in FIPS 140-3 */
247 if (signing
248 && !OSSL_FIPS_IND_ON_UNAPPROVED(ctx, OSSL_FIPS_IND_SETTABLE2,
249 ctx->libctx, desc, "DSA",
250 ossl_fips_config_dsa_sign_disallowed))
251 return 0;
252 return 1;
253 }
254
dsa_check_key(PROV_DSA_CTX * ctx,int sign,const char * desc)255 static int dsa_check_key(PROV_DSA_CTX *ctx, int sign, const char *desc)
256 {
257 int approved = ossl_dsa_check_key(ctx->dsa, sign);
258
259 if (!approved) {
260 if (!OSSL_FIPS_IND_ON_UNAPPROVED(ctx, OSSL_FIPS_IND_SETTABLE0,
261 ctx->libctx, desc, "DSA Key",
262 ossl_fips_config_signature_digest_check)) {
263 ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
264 return 0;
265 }
266 }
267 return 1;
268 }
269 #endif
270
271 static int
dsa_signverify_init(void * vpdsactx,void * vdsa,OSSL_FUNC_signature_set_ctx_params_fn * set_ctx_params,const OSSL_PARAM params[],int operation,const char * desc)272 dsa_signverify_init(void *vpdsactx, void *vdsa,
273 OSSL_FUNC_signature_set_ctx_params_fn *set_ctx_params,
274 const OSSL_PARAM params[], int operation,
275 const char *desc)
276 {
277 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
278
279 if (!ossl_prov_is_running()
280 || pdsactx == NULL)
281 return 0;
282
283 if (vdsa == NULL && pdsactx->dsa == NULL) {
284 ERR_raise(ERR_LIB_PROV, PROV_R_NO_KEY_SET);
285 return 0;
286 }
287
288 if (vdsa != NULL) {
289 if (!DSA_up_ref(vdsa))
290 return 0;
291 DSA_free(pdsactx->dsa);
292 pdsactx->dsa = vdsa;
293 }
294
295 pdsactx->operation = operation;
296
297 OSSL_FIPS_IND_SET_APPROVED(pdsactx)
298 if (!set_ctx_params(pdsactx, params))
299 return 0;
300 #ifdef FIPS_MODULE
301 {
302 int operation_is_sign
303 = (operation & (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_SIGNMSG)) != 0;
304
305 if (!dsa_sign_check_approved(pdsactx, operation_is_sign, desc))
306 return 0;
307 if (!dsa_check_key(pdsactx, operation_is_sign, desc))
308 return 0;
309 }
310 #endif
311 return 1;
312 }
313
dsa_sign_init(void * vpdsactx,void * vdsa,const OSSL_PARAM params[])314 static int dsa_sign_init(void *vpdsactx, void *vdsa, const OSSL_PARAM params[])
315 {
316 return dsa_signverify_init(vpdsactx, vdsa, dsa_set_ctx_params, params,
317 EVP_PKEY_OP_SIGN, "DSA Sign Init");
318 }
319
320 /*
321 * Sign tbs without digesting it first. This is suitable for "primitive"
322 * signing and signing the digest of a message, i.e. should be used with
323 * implementations of the keytype related algorithms.
324 */
dsa_sign_directly(void * vpdsactx,unsigned char * sig,size_t * siglen,size_t sigsize,const unsigned char * tbs,size_t tbslen)325 static int dsa_sign_directly(void *vpdsactx,
326 unsigned char *sig, size_t *siglen, size_t sigsize,
327 const unsigned char *tbs, size_t tbslen)
328 {
329 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
330 int ret;
331 unsigned int sltmp;
332 size_t dsasize = DSA_size(pdsactx->dsa);
333 size_t mdsize = dsa_get_md_size(pdsactx);
334
335 if (!ossl_prov_is_running())
336 return 0;
337
338 #ifdef FIPS_MODULE
339 if (!dsa_sign_check_approved(pdsactx, 1, "Sign"))
340 return 0;
341 #endif
342
343 if (sig == NULL) {
344 *siglen = dsasize;
345 return 1;
346 }
347
348 if (sigsize < dsasize)
349 return 0;
350
351 if (mdsize != 0 && tbslen != mdsize)
352 return 0;
353
354 ret = ossl_dsa_sign_int(0, tbs, tbslen, sig, &sltmp, pdsactx->dsa,
355 pdsactx->nonce_type, pdsactx->mdname,
356 pdsactx->libctx, pdsactx->propq);
357 if (ret <= 0)
358 return 0;
359
360 *siglen = sltmp;
361 return 1;
362 }
363
dsa_signverify_message_update(void * vpdsactx,const unsigned char * data,size_t datalen)364 static int dsa_signverify_message_update(void *vpdsactx,
365 const unsigned char *data,
366 size_t datalen)
367 {
368 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
369
370 if (pdsactx == NULL)
371 return 0;
372
373 return EVP_DigestUpdate(pdsactx->mdctx, data, datalen);
374 }
375
dsa_sign_message_final(void * vpdsactx,unsigned char * sig,size_t * siglen,size_t sigsize)376 static int dsa_sign_message_final(void *vpdsactx, unsigned char *sig,
377 size_t *siglen, size_t sigsize)
378 {
379 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
380 unsigned char digest[EVP_MAX_MD_SIZE];
381 unsigned int dlen = 0;
382
383 if (!ossl_prov_is_running() || pdsactx == NULL || pdsactx->mdctx == NULL)
384 return 0;
385 /*
386 * If sig is NULL then we're just finding out the sig size. Other fields
387 * are ignored. Defer to dsa_sign.
388 */
389 if (sig != NULL) {
390 /*
391 * When this function is used through dsa_digest_sign_final(),
392 * there is the possibility that some externally provided digests
393 * exceed EVP_MAX_MD_SIZE. We should probably handle that
394 * somehow but that problem is much larger than just in DSA.
395 */
396 if (!EVP_DigestFinal_ex(pdsactx->mdctx, digest, &dlen))
397 return 0;
398 }
399
400 return dsa_sign_directly(vpdsactx, sig, siglen, sigsize, digest, dlen);
401 }
402
403 /*
404 * If signing a message, digest tbs and sign the result.
405 * Otherwise, sign tbs directly.
406 */
dsa_sign(void * vpdsactx,unsigned char * sig,size_t * siglen,size_t sigsize,const unsigned char * tbs,size_t tbslen)407 static int dsa_sign(void *vpdsactx, unsigned char *sig, size_t *siglen,
408 size_t sigsize, const unsigned char *tbs, size_t tbslen)
409 {
410 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
411
412 if (pdsactx->operation == EVP_PKEY_OP_SIGNMSG) {
413 /*
414 * If |sig| is NULL, the caller is only looking for the sig length.
415 * DO NOT update the input in this case.
416 */
417 if (sig == NULL)
418 return dsa_sign_message_final(pdsactx, sig, siglen, sigsize);
419
420 if (dsa_signverify_message_update(pdsactx, tbs, tbslen) <= 0)
421 return 0;
422 return dsa_sign_message_final(pdsactx, sig, siglen, sigsize);
423 }
424 return dsa_sign_directly(pdsactx, sig, siglen, sigsize, tbs, tbslen);
425 }
426
dsa_verify_init(void * vpdsactx,void * vdsa,const OSSL_PARAM params[])427 static int dsa_verify_init(void *vpdsactx, void *vdsa,
428 const OSSL_PARAM params[])
429 {
430 return dsa_signverify_init(vpdsactx, vdsa, dsa_set_ctx_params, params,
431 EVP_PKEY_OP_VERIFY, "DSA Verify Init");
432 }
433
dsa_verify_directly(void * vpdsactx,const unsigned char * sig,size_t siglen,const unsigned char * tbs,size_t tbslen)434 static int dsa_verify_directly(void *vpdsactx,
435 const unsigned char *sig, size_t siglen,
436 const unsigned char *tbs, size_t tbslen)
437 {
438 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
439 size_t mdsize = dsa_get_md_size(pdsactx);
440
441 if (!ossl_prov_is_running() || (mdsize != 0 && tbslen != mdsize))
442 return 0;
443
444 return DSA_verify(0, tbs, tbslen, sig, siglen, pdsactx->dsa);
445 }
446
dsa_verify_set_sig(void * vpdsactx,const unsigned char * sig,size_t siglen)447 static int dsa_verify_set_sig(void *vpdsactx,
448 const unsigned char *sig, size_t siglen)
449 {
450 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
451 OSSL_PARAM params[2];
452
453 params[0] =
454 OSSL_PARAM_construct_octet_string(OSSL_SIGNATURE_PARAM_SIGNATURE,
455 (unsigned char *)sig, siglen);
456 params[1] = OSSL_PARAM_construct_end();
457 return dsa_sigalg_set_ctx_params(pdsactx, params);
458 }
459
dsa_verify_message_final(void * vpdsactx)460 static int dsa_verify_message_final(void *vpdsactx)
461 {
462 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
463 unsigned char digest[EVP_MAX_MD_SIZE];
464 unsigned int dlen = 0;
465
466 if (!ossl_prov_is_running())
467 return 0;
468
469 if (pdsactx == NULL || pdsactx->mdctx == NULL)
470 return 0;
471
472 /*
473 * The digests used here are all known (see dsa_get_md_nid()), so they
474 * should not exceed the internal buffer size of EVP_MAX_MD_SIZE.
475 */
476 if (!EVP_DigestFinal_ex(pdsactx->mdctx, digest, &dlen))
477 return 0;
478
479 return dsa_verify_directly(vpdsactx, pdsactx->sig, pdsactx->siglen,
480 digest, dlen);
481 }
482
483 /*
484 * If verifying a message, digest tbs and verify the result.
485 * Otherwise, verify tbs directly.
486 */
dsa_verify(void * vpdsactx,const unsigned char * sig,size_t siglen,const unsigned char * tbs,size_t tbslen)487 static int dsa_verify(void *vpdsactx,
488 const unsigned char *sig, size_t siglen,
489 const unsigned char *tbs, size_t tbslen)
490 {
491 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
492
493 if (pdsactx->operation == EVP_PKEY_OP_VERIFYMSG) {
494 if (dsa_verify_set_sig(pdsactx, sig, siglen) <= 0)
495 return 0;
496 if (dsa_signverify_message_update(pdsactx, tbs, tbslen) <= 0)
497 return 0;
498 return dsa_verify_message_final(pdsactx);
499 }
500 return dsa_verify_directly(pdsactx, sig, siglen, tbs, tbslen);
501 }
502
503 /* DigestSign/DigestVerify wrappers */
504
dsa_digest_signverify_init(void * vpdsactx,const char * mdname,void * vdsa,const OSSL_PARAM params[],int operation,const char * desc)505 static int dsa_digest_signverify_init(void *vpdsactx, const char *mdname,
506 void *vdsa, const OSSL_PARAM params[],
507 int operation, const char *desc)
508 {
509 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
510
511 if (!ossl_prov_is_running())
512 return 0;
513
514 if (!dsa_signverify_init(vpdsactx, vdsa, dsa_set_ctx_params, params,
515 operation, desc))
516 return 0;
517
518 if (mdname != NULL
519 /* was dsa_setup_md already called in dsa_signverify_init()? */
520 && (mdname[0] == '\0' || OPENSSL_strcasecmp(pdsactx->mdname, mdname) != 0)
521 && !dsa_setup_md(pdsactx, mdname, NULL, desc))
522 return 0;
523
524 pdsactx->flag_allow_md = 0;
525
526 if (pdsactx->mdctx == NULL) {
527 pdsactx->mdctx = EVP_MD_CTX_new();
528 if (pdsactx->mdctx == NULL)
529 goto error;
530 }
531
532 if (!EVP_DigestInit_ex2(pdsactx->mdctx, pdsactx->md, params))
533 goto error;
534
535 return 1;
536
537 error:
538 EVP_MD_CTX_free(pdsactx->mdctx);
539 pdsactx->mdctx = NULL;
540 return 0;
541 }
542
dsa_digest_sign_init(void * vpdsactx,const char * mdname,void * vdsa,const OSSL_PARAM params[])543 static int dsa_digest_sign_init(void *vpdsactx, const char *mdname,
544 void *vdsa, const OSSL_PARAM params[])
545 {
546 return dsa_digest_signverify_init(vpdsactx, mdname, vdsa, params,
547 EVP_PKEY_OP_SIGNMSG,
548 "DSA Digest Sign Init");
549 }
550
dsa_digest_signverify_update(void * vpdsactx,const unsigned char * data,size_t datalen)551 static int dsa_digest_signverify_update(void *vpdsactx, const unsigned char *data,
552 size_t datalen)
553 {
554 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
555
556 if (pdsactx == NULL)
557 return 0;
558 /* Sigalg implementations shouldn't do digest_sign */
559 if (pdsactx->flag_sigalg)
560 return 0;
561
562 return dsa_signverify_message_update(vpdsactx, data, datalen);
563 }
564
dsa_digest_sign_final(void * vpdsactx,unsigned char * sig,size_t * siglen,size_t sigsize)565 static int dsa_digest_sign_final(void *vpdsactx, unsigned char *sig,
566 size_t *siglen, size_t sigsize)
567 {
568 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
569 int ok = 0;
570
571 if (pdsactx == NULL)
572 return 0;
573 /* Sigalg implementations shouldn't do digest_sign */
574 if (pdsactx->flag_sigalg)
575 return 0;
576
577 ok = dsa_sign_message_final(pdsactx, sig, siglen, sigsize);
578
579 pdsactx->flag_allow_md = 1;
580
581 return ok;
582 }
583
dsa_digest_verify_init(void * vpdsactx,const char * mdname,void * vdsa,const OSSL_PARAM params[])584 static int dsa_digest_verify_init(void *vpdsactx, const char *mdname,
585 void *vdsa, const OSSL_PARAM params[])
586 {
587 return dsa_digest_signverify_init(vpdsactx, mdname, vdsa, params,
588 EVP_PKEY_OP_VERIFYMSG,
589 "DSA Digest Verify Init");
590 }
591
dsa_digest_verify_final(void * vpdsactx,const unsigned char * sig,size_t siglen)592 int dsa_digest_verify_final(void *vpdsactx, const unsigned char *sig,
593 size_t siglen)
594 {
595 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
596 int ok = 0;
597
598 if (pdsactx == NULL)
599 return 0;
600 /* Sigalg implementations shouldn't do digest_verify */
601 if (pdsactx->flag_sigalg)
602 return 0;
603
604 if (dsa_verify_set_sig(pdsactx, sig, siglen))
605 ok = dsa_verify_message_final(vpdsactx);
606
607 pdsactx->flag_allow_md = 1;
608
609 return ok;
610 }
611
dsa_freectx(void * vpdsactx)612 static void dsa_freectx(void *vpdsactx)
613 {
614 PROV_DSA_CTX *ctx = (PROV_DSA_CTX *)vpdsactx;
615
616 EVP_MD_CTX_free(ctx->mdctx);
617 EVP_MD_free(ctx->md);
618 OPENSSL_free(ctx->sig);
619 OPENSSL_free(ctx->propq);
620 DSA_free(ctx->dsa);
621 OPENSSL_free(ctx);
622 }
623
dsa_dupctx(void * vpdsactx)624 static void *dsa_dupctx(void *vpdsactx)
625 {
626 PROV_DSA_CTX *srcctx = (PROV_DSA_CTX *)vpdsactx;
627 PROV_DSA_CTX *dstctx;
628
629 if (!ossl_prov_is_running())
630 return NULL;
631
632 dstctx = OPENSSL_zalloc(sizeof(*srcctx));
633 if (dstctx == NULL)
634 return NULL;
635
636 *dstctx = *srcctx;
637 dstctx->dsa = NULL;
638 dstctx->propq = NULL;
639
640 if (srcctx->dsa != NULL && !DSA_up_ref(srcctx->dsa))
641 goto err;
642 dstctx->dsa = srcctx->dsa;
643
644 if (srcctx->md != NULL && !EVP_MD_up_ref(srcctx->md))
645 goto err;
646 dstctx->md = srcctx->md;
647
648 if (srcctx->mdctx != NULL) {
649 dstctx->mdctx = EVP_MD_CTX_new();
650 if (dstctx->mdctx == NULL
651 || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx))
652 goto err;
653 }
654
655 if (srcctx->propq != NULL) {
656 dstctx->propq = OPENSSL_strdup(srcctx->propq);
657 if (dstctx->propq == NULL)
658 goto err;
659 }
660
661 return dstctx;
662 err:
663 dsa_freectx(dstctx);
664 return NULL;
665 }
666
dsa_get_ctx_params(void * vpdsactx,OSSL_PARAM * params)667 static int dsa_get_ctx_params(void *vpdsactx, OSSL_PARAM *params)
668 {
669 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
670 OSSL_PARAM *p;
671
672 if (pdsactx == NULL)
673 return 0;
674
675 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID);
676 if (p != NULL
677 && !OSSL_PARAM_set_octet_string(p, pdsactx->aid, pdsactx->aid_len))
678 return 0;
679
680 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST);
681 if (p != NULL && !OSSL_PARAM_set_utf8_string(p, pdsactx->mdname))
682 return 0;
683
684 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_NONCE_TYPE);
685 if (p != NULL && !OSSL_PARAM_set_uint(p, pdsactx->nonce_type))
686 return 0;
687 if (!OSSL_FIPS_IND_GET_CTX_PARAM(pdsactx, params))
688 return 0;
689
690 return 1;
691 }
692
693 static const OSSL_PARAM known_gettable_ctx_params[] = {
694 OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
695 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
696 OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_NONCE_TYPE, NULL),
697 OSSL_FIPS_IND_GETTABLE_CTX_PARAM()
698 OSSL_PARAM_END
699 };
700
dsa_gettable_ctx_params(ossl_unused void * ctx,ossl_unused void * provctx)701 static const OSSL_PARAM *dsa_gettable_ctx_params(ossl_unused void *ctx,
702 ossl_unused void *provctx)
703 {
704 return known_gettable_ctx_params;
705 }
706
707 /* The common params for dsa_set_ctx_params and dsa_sigalg_set_ctx_params */
dsa_common_set_ctx_params(void * vpdsactx,const OSSL_PARAM params[])708 static int dsa_common_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[])
709 {
710 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
711 const OSSL_PARAM *p;
712
713 if (pdsactx == NULL)
714 return 0;
715 if (params == NULL)
716 return 1;
717
718 if (!OSSL_FIPS_IND_SET_CTX_PARAM(pdsactx, OSSL_FIPS_IND_SETTABLE0, params,
719 OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK))
720 return 0;
721 if (!OSSL_FIPS_IND_SET_CTX_PARAM(pdsactx, OSSL_FIPS_IND_SETTABLE1, params,
722 OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK))
723 return 0;
724 if (!OSSL_FIPS_IND_SET_CTX_PARAM(pdsactx, OSSL_FIPS_IND_SETTABLE2, params,
725 OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK))
726 return 0;
727
728 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_NONCE_TYPE);
729 if (p != NULL
730 && !OSSL_PARAM_get_uint(p, &pdsactx->nonce_type))
731 return 0;
732 return 1;
733 }
734
735 #define DSA_COMMON_SETTABLE_CTX_PARAMS \
736 OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_NONCE_TYPE, NULL), \
737 OSSL_FIPS_IND_SETTABLE_CTX_PARAM(OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK) \
738 OSSL_FIPS_IND_SETTABLE_CTX_PARAM(OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK) \
739 OSSL_FIPS_IND_SETTABLE_CTX_PARAM(OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK) \
740 OSSL_PARAM_END
741
dsa_set_ctx_params(void * vpdsactx,const OSSL_PARAM params[])742 static int dsa_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[])
743 {
744 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
745 const OSSL_PARAM *p;
746 int ret;
747
748 if ((ret = dsa_common_set_ctx_params(pdsactx, params)) <= 0)
749 return ret;
750
751 if (params == NULL)
752 return 1;
753
754 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST);
755 if (p != NULL) {
756 char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname;
757 char mdprops[OSSL_MAX_PROPQUERY_SIZE] = "", *pmdprops = mdprops;
758 const OSSL_PARAM *propsp =
759 OSSL_PARAM_locate_const(params,
760 OSSL_SIGNATURE_PARAM_PROPERTIES);
761
762 if (!OSSL_PARAM_get_utf8_string(p, &pmdname, sizeof(mdname)))
763 return 0;
764 if (propsp != NULL
765 && !OSSL_PARAM_get_utf8_string(propsp, &pmdprops, sizeof(mdprops)))
766 return 0;
767 if (!dsa_setup_md(pdsactx, mdname, mdprops, "DSA Set Ctx"))
768 return 0;
769 }
770 return 1;
771 }
772
773 static const OSSL_PARAM settable_ctx_params[] = {
774 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
775 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PROPERTIES, NULL, 0),
776 DSA_COMMON_SETTABLE_CTX_PARAMS
777 };
778
779 static const OSSL_PARAM settable_ctx_params_no_digest[] = {
780 OSSL_PARAM_END
781 };
782
dsa_settable_ctx_params(void * vpdsactx,ossl_unused void * provctx)783 static const OSSL_PARAM *dsa_settable_ctx_params(void *vpdsactx,
784 ossl_unused void *provctx)
785 {
786 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
787
788 if (pdsactx != NULL && !pdsactx->flag_allow_md)
789 return settable_ctx_params_no_digest;
790 return settable_ctx_params;
791 }
792
dsa_get_ctx_md_params(void * vpdsactx,OSSL_PARAM * params)793 static int dsa_get_ctx_md_params(void *vpdsactx, OSSL_PARAM *params)
794 {
795 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
796
797 if (pdsactx->mdctx == NULL)
798 return 0;
799
800 return EVP_MD_CTX_get_params(pdsactx->mdctx, params);
801 }
802
dsa_gettable_ctx_md_params(void * vpdsactx)803 static const OSSL_PARAM *dsa_gettable_ctx_md_params(void *vpdsactx)
804 {
805 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
806
807 if (pdsactx->md == NULL)
808 return 0;
809
810 return EVP_MD_gettable_ctx_params(pdsactx->md);
811 }
812
dsa_set_ctx_md_params(void * vpdsactx,const OSSL_PARAM params[])813 static int dsa_set_ctx_md_params(void *vpdsactx, const OSSL_PARAM params[])
814 {
815 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
816
817 if (pdsactx->mdctx == NULL)
818 return 0;
819
820 return EVP_MD_CTX_set_params(pdsactx->mdctx, params);
821 }
822
dsa_settable_ctx_md_params(void * vpdsactx)823 static const OSSL_PARAM *dsa_settable_ctx_md_params(void *vpdsactx)
824 {
825 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
826
827 if (pdsactx->md == NULL)
828 return 0;
829
830 return EVP_MD_settable_ctx_params(pdsactx->md);
831 }
832
833 const OSSL_DISPATCH ossl_dsa_signature_functions[] = {
834 { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))dsa_newctx },
835 { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))dsa_sign_init },
836 { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))dsa_sign },
837 { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))dsa_verify_init },
838 { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))dsa_verify },
839 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,
840 (void (*)(void))dsa_digest_sign_init },
841 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE,
842 (void (*)(void))dsa_digest_signverify_update },
843 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL,
844 (void (*)(void))dsa_digest_sign_final },
845 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,
846 (void (*)(void))dsa_digest_verify_init },
847 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE,
848 (void (*)(void))dsa_digest_signverify_update },
849 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL,
850 (void (*)(void))dsa_digest_verify_final },
851 { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))dsa_freectx },
852 { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))dsa_dupctx },
853 { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, (void (*)(void))dsa_get_ctx_params },
854 { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,
855 (void (*)(void))dsa_gettable_ctx_params },
856 { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))dsa_set_ctx_params },
857 { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,
858 (void (*)(void))dsa_settable_ctx_params },
859 { OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS,
860 (void (*)(void))dsa_get_ctx_md_params },
861 { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS,
862 (void (*)(void))dsa_gettable_ctx_md_params },
863 { OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS,
864 (void (*)(void))dsa_set_ctx_md_params },
865 { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS,
866 (void (*)(void))dsa_settable_ctx_md_params },
867 OSSL_DISPATCH_END
868 };
869
870 /* ------------------------------------------------------------------ */
871
872 /*
873 * So called sigalgs (composite DSA+hash) implemented below. They
874 * are pretty much hard coded.
875 */
876
877 static OSSL_FUNC_signature_query_key_types_fn dsa_sigalg_query_key_types;
878 static OSSL_FUNC_signature_settable_ctx_params_fn dsa_sigalg_settable_ctx_params;
879 static OSSL_FUNC_signature_set_ctx_params_fn dsa_sigalg_set_ctx_params;
880
881 /*
882 * dsa_sigalg_signverify_init() is almost like dsa_digest_signverify_init(),
883 * just doesn't allow fetching an MD from whatever the user chooses.
884 */
dsa_sigalg_signverify_init(void * vpdsactx,void * vdsa,OSSL_FUNC_signature_set_ctx_params_fn * set_ctx_params,const OSSL_PARAM params[],const char * mdname,int operation,const char * desc)885 static int dsa_sigalg_signverify_init(void *vpdsactx, void *vdsa,
886 OSSL_FUNC_signature_set_ctx_params_fn *set_ctx_params,
887 const OSSL_PARAM params[],
888 const char *mdname,
889 int operation, const char *desc)
890 {
891 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
892
893 if (!ossl_prov_is_running())
894 return 0;
895
896 if (!dsa_signverify_init(vpdsactx, vdsa, set_ctx_params, params, operation,
897 desc))
898 return 0;
899
900 if (!dsa_setup_md(pdsactx, mdname, NULL, desc))
901 return 0;
902
903 pdsactx->flag_sigalg = 1;
904 pdsactx->flag_allow_md = 0;
905
906 if (pdsactx->mdctx == NULL) {
907 pdsactx->mdctx = EVP_MD_CTX_new();
908 if (pdsactx->mdctx == NULL)
909 goto error;
910 }
911
912 if (!EVP_DigestInit_ex2(pdsactx->mdctx, pdsactx->md, params))
913 goto error;
914
915 return 1;
916
917 error:
918 EVP_MD_CTX_free(pdsactx->mdctx);
919 pdsactx->mdctx = NULL;
920 return 0;
921 }
922
dsa_sigalg_query_key_types(void)923 static const char **dsa_sigalg_query_key_types(void)
924 {
925 static const char *keytypes[] = { "DSA", NULL };
926
927 return keytypes;
928 }
929
930 static const OSSL_PARAM settable_sigalg_ctx_params[] = {
931 OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_SIGNATURE, NULL, 0),
932 DSA_COMMON_SETTABLE_CTX_PARAMS
933 };
934
dsa_sigalg_settable_ctx_params(void * vpdsactx,ossl_unused void * provctx)935 static const OSSL_PARAM *dsa_sigalg_settable_ctx_params(void *vpdsactx,
936 ossl_unused void *provctx)
937 {
938 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
939
940 if (pdsactx != NULL && pdsactx->operation == EVP_PKEY_OP_VERIFYMSG)
941 return settable_sigalg_ctx_params;
942 return NULL;
943 }
944
dsa_sigalg_set_ctx_params(void * vpdsactx,const OSSL_PARAM params[])945 static int dsa_sigalg_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[])
946 {
947 PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
948 const OSSL_PARAM *p;
949 int ret;
950
951 if ((ret = dsa_common_set_ctx_params(pdsactx, params)) <= 0)
952 return ret;
953
954 if (params == NULL)
955 return 1;
956
957 if (pdsactx->operation == EVP_PKEY_OP_VERIFYMSG) {
958 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_SIGNATURE);
959 if (p != NULL) {
960 OPENSSL_free(pdsactx->sig);
961 pdsactx->sig = NULL;
962 pdsactx->siglen = 0;
963 if (!OSSL_PARAM_get_octet_string(p, (void **)&pdsactx->sig,
964 0, &pdsactx->siglen))
965 return 0;
966 }
967 }
968 return 1;
969 }
970
971 #define IMPL_DSA_SIGALG(md, MD) \
972 static OSSL_FUNC_signature_sign_init_fn dsa_##md##_sign_init; \
973 static OSSL_FUNC_signature_sign_message_init_fn \
974 dsa_##md##_sign_message_init; \
975 static OSSL_FUNC_signature_verify_init_fn dsa_##md##_verify_init; \
976 static OSSL_FUNC_signature_verify_message_init_fn \
977 dsa_##md##_verify_message_init; \
978 \
979 static int \
980 dsa_##md##_sign_init(void *vpdsactx, void *vdsa, \
981 const OSSL_PARAM params[]) \
982 { \
983 static const char desc[] = "DSA-" #MD " Sign Init"; \
984 \
985 return dsa_sigalg_signverify_init(vpdsactx, vdsa, \
986 dsa_sigalg_set_ctx_params, \
987 params, #MD, \
988 EVP_PKEY_OP_SIGN, \
989 desc); \
990 } \
991 \
992 static int \
993 dsa_##md##_sign_message_init(void *vpdsactx, void *vdsa, \
994 const OSSL_PARAM params[]) \
995 { \
996 static const char desc[] = "DSA-" #MD " Sign Message Init"; \
997 \
998 return dsa_sigalg_signverify_init(vpdsactx, vdsa, \
999 dsa_sigalg_set_ctx_params, \
1000 params, #MD, \
1001 EVP_PKEY_OP_SIGNMSG, \
1002 desc); \
1003 } \
1004 \
1005 static int \
1006 dsa_##md##_verify_init(void *vpdsactx, void *vdsa, \
1007 const OSSL_PARAM params[]) \
1008 { \
1009 static const char desc[] = "DSA-" #MD " Verify Init"; \
1010 \
1011 return dsa_sigalg_signverify_init(vpdsactx, vdsa, \
1012 dsa_sigalg_set_ctx_params, \
1013 params, #MD, \
1014 EVP_PKEY_OP_VERIFY, \
1015 desc); \
1016 } \
1017 \
1018 static int \
1019 dsa_##md##_verify_message_init(void *vpdsactx, void *vdsa, \
1020 const OSSL_PARAM params[]) \
1021 { \
1022 static const char desc[] = "DSA-" #MD " Verify Message Init"; \
1023 \
1024 return dsa_sigalg_signverify_init(vpdsactx, vdsa, \
1025 dsa_sigalg_set_ctx_params, \
1026 params, #MD, \
1027 EVP_PKEY_OP_VERIFYMSG, \
1028 desc); \
1029 } \
1030 \
1031 const OSSL_DISPATCH ossl_dsa_##md##_signature_functions[] = { \
1032 { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))dsa_newctx }, \
1033 { OSSL_FUNC_SIGNATURE_SIGN_INIT, \
1034 (void (*)(void))dsa_##md##_sign_init }, \
1035 { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))dsa_sign }, \
1036 { OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_INIT, \
1037 (void (*)(void))dsa_##md##_sign_message_init }, \
1038 { OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_UPDATE, \
1039 (void (*)(void))dsa_signverify_message_update }, \
1040 { OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_FINAL, \
1041 (void (*)(void))dsa_sign_message_final }, \
1042 { OSSL_FUNC_SIGNATURE_VERIFY_INIT, \
1043 (void (*)(void))dsa_##md##_verify_init }, \
1044 { OSSL_FUNC_SIGNATURE_VERIFY, \
1045 (void (*)(void))dsa_verify }, \
1046 { OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_INIT, \
1047 (void (*)(void))dsa_##md##_verify_message_init }, \
1048 { OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_UPDATE, \
1049 (void (*)(void))dsa_signverify_message_update }, \
1050 { OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_FINAL, \
1051 (void (*)(void))dsa_verify_message_final }, \
1052 { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))dsa_freectx }, \
1053 { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))dsa_dupctx }, \
1054 { OSSL_FUNC_SIGNATURE_QUERY_KEY_TYPES, \
1055 (void (*)(void))dsa_sigalg_query_key_types }, \
1056 { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, \
1057 (void (*)(void))dsa_get_ctx_params }, \
1058 { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS, \
1059 (void (*)(void))dsa_gettable_ctx_params }, \
1060 { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, \
1061 (void (*)(void))dsa_sigalg_set_ctx_params }, \
1062 { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS, \
1063 (void (*)(void))dsa_sigalg_settable_ctx_params }, \
1064 OSSL_DISPATCH_END \
1065 }
1066
1067 IMPL_DSA_SIGALG(sha1, SHA1);
1068 IMPL_DSA_SIGALG(sha224, SHA2-224);
1069 IMPL_DSA_SIGALG(sha256, SHA2-256);
1070 IMPL_DSA_SIGALG(sha384, SHA2-384);
1071 IMPL_DSA_SIGALG(sha512, SHA2-512);
1072 IMPL_DSA_SIGALG(sha3_224, SHA3-224);
1073 IMPL_DSA_SIGALG(sha3_256, SHA3-256);
1074 IMPL_DSA_SIGALG(sha3_384, SHA3-384);
1075 IMPL_DSA_SIGALG(sha3_512, SHA3-512);
1076
