1 /*
2 * Copyright 2020-2023 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 * ECDSA 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> /* memcpy */
17 #include <openssl/crypto.h>
18 #include <openssl/core_dispatch.h>
19 #include <openssl/core_names.h>
20 #include <openssl/dsa.h>
21 #include <openssl/params.h>
22 #include <openssl/evp.h>
23 #include <openssl/err.h>
24 #include <openssl/proverr.h>
25 #include "internal/nelem.h"
26 #include "internal/sizes.h"
27 #include "internal/cryptlib.h"
28 #include "internal/deterministic_nonce.h"
29 #include "prov/providercommon.h"
30 #include "prov/implementations.h"
31 #include "prov/provider_ctx.h"
32 #include "prov/securitycheck.h"
33 #include "crypto/ec.h"
34 #include "prov/der_ec.h"
35
36 static OSSL_FUNC_signature_newctx_fn ecdsa_newctx;
37 static OSSL_FUNC_signature_sign_init_fn ecdsa_sign_init;
38 static OSSL_FUNC_signature_verify_init_fn ecdsa_verify_init;
39 static OSSL_FUNC_signature_sign_fn ecdsa_sign;
40 static OSSL_FUNC_signature_verify_fn ecdsa_verify;
41 static OSSL_FUNC_signature_digest_sign_init_fn ecdsa_digest_sign_init;
42 static OSSL_FUNC_signature_digest_sign_update_fn ecdsa_digest_signverify_update;
43 static OSSL_FUNC_signature_digest_sign_final_fn ecdsa_digest_sign_final;
44 static OSSL_FUNC_signature_digest_verify_init_fn ecdsa_digest_verify_init;
45 static OSSL_FUNC_signature_digest_verify_update_fn ecdsa_digest_signverify_update;
46 static OSSL_FUNC_signature_digest_verify_final_fn ecdsa_digest_verify_final;
47 static OSSL_FUNC_signature_freectx_fn ecdsa_freectx;
48 static OSSL_FUNC_signature_dupctx_fn ecdsa_dupctx;
49 static OSSL_FUNC_signature_get_ctx_params_fn ecdsa_get_ctx_params;
50 static OSSL_FUNC_signature_gettable_ctx_params_fn ecdsa_gettable_ctx_params;
51 static OSSL_FUNC_signature_set_ctx_params_fn ecdsa_set_ctx_params;
52 static OSSL_FUNC_signature_settable_ctx_params_fn ecdsa_settable_ctx_params;
53 static OSSL_FUNC_signature_get_ctx_md_params_fn ecdsa_get_ctx_md_params;
54 static OSSL_FUNC_signature_gettable_ctx_md_params_fn ecdsa_gettable_ctx_md_params;
55 static OSSL_FUNC_signature_set_ctx_md_params_fn ecdsa_set_ctx_md_params;
56 static OSSL_FUNC_signature_settable_ctx_md_params_fn ecdsa_settable_ctx_md_params;
57
58 /*
59 * What's passed as an actual key is defined by the KEYMGMT interface.
60 * We happen to know that our KEYMGMT simply passes DSA structures, so
61 * we use that here too.
62 */
63
64 typedef struct {
65 OSSL_LIB_CTX *libctx;
66 char *propq;
67 EC_KEY *ec;
68 char mdname[OSSL_MAX_NAME_SIZE];
69
70 /*
71 * Flag to determine if the hash function can be changed (1) or not (0)
72 * Because it's dangerous to change during a DigestSign or DigestVerify
73 * operation, this flag is cleared by their Init function, and set again
74 * by their Final function.
75 */
76 unsigned int flag_allow_md : 1;
77
78 /* The Algorithm Identifier of the combined signature algorithm */
79 unsigned char aid_buf[OSSL_MAX_ALGORITHM_ID_SIZE];
80 unsigned char *aid;
81 size_t aid_len;
82 size_t mdsize;
83 int operation;
84
85 EVP_MD *md;
86 EVP_MD_CTX *mdctx;
87 /*
88 * Internally used to cache the results of calling the EC group
89 * sign_setup() methods which are then passed to the sign operation.
90 * This is used by CAVS failure tests to terminate a loop if the signature
91 * is not valid.
92 * This could of also been done with a simple flag.
93 */
94 BIGNUM *kinv;
95 BIGNUM *r;
96 #if !defined(OPENSSL_NO_ACVP_TESTS)
97 /*
98 * This indicates that KAT (CAVS) test is running. Externally an app will
99 * override the random callback such that the generated private key and k
100 * are known.
101 * Normal operation will loop to choose a new k if the signature is not
102 * valid - but for this mode of operation it forces a failure instead.
103 */
104 unsigned int kattest;
105 #endif
106 /* If this is set then the generated k is not random */
107 unsigned int nonce_type;
108 } PROV_ECDSA_CTX;
109
ecdsa_newctx(void * provctx,const char * propq)110 static void *ecdsa_newctx(void *provctx, const char *propq)
111 {
112 PROV_ECDSA_CTX *ctx;
113
114 if (!ossl_prov_is_running())
115 return NULL;
116
117 ctx = OPENSSL_zalloc(sizeof(PROV_ECDSA_CTX));
118 if (ctx == NULL)
119 return NULL;
120
121 ctx->flag_allow_md = 1;
122 ctx->libctx = PROV_LIBCTX_OF(provctx);
123 if (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL) {
124 OPENSSL_free(ctx);
125 ctx = NULL;
126 }
127 return ctx;
128 }
129
ecdsa_signverify_init(void * vctx,void * ec,const OSSL_PARAM params[],int operation)130 static int ecdsa_signverify_init(void *vctx, void *ec,
131 const OSSL_PARAM params[], int operation)
132 {
133 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
134
135 if (!ossl_prov_is_running()
136 || ctx == NULL)
137 return 0;
138
139 if (ec == NULL && ctx->ec == NULL) {
140 ERR_raise(ERR_LIB_PROV, PROV_R_NO_KEY_SET);
141 return 0;
142 }
143
144 if (ec != NULL) {
145 if (!ossl_ec_check_key(ctx->libctx, ec, operation == EVP_PKEY_OP_SIGN))
146 return 0;
147 if (!EC_KEY_up_ref(ec))
148 return 0;
149 EC_KEY_free(ctx->ec);
150 ctx->ec = ec;
151 }
152
153 ctx->operation = operation;
154
155 if (!ecdsa_set_ctx_params(ctx, params))
156 return 0;
157
158 return 1;
159 }
160
ecdsa_sign_init(void * vctx,void * ec,const OSSL_PARAM params[])161 static int ecdsa_sign_init(void *vctx, void *ec, const OSSL_PARAM params[])
162 {
163 return ecdsa_signverify_init(vctx, ec, params, EVP_PKEY_OP_SIGN);
164 }
165
ecdsa_verify_init(void * vctx,void * ec,const OSSL_PARAM params[])166 static int ecdsa_verify_init(void *vctx, void *ec, const OSSL_PARAM params[])
167 {
168 return ecdsa_signverify_init(vctx, ec, params, EVP_PKEY_OP_VERIFY);
169 }
170
ecdsa_sign(void * vctx,unsigned char * sig,size_t * siglen,size_t sigsize,const unsigned char * tbs,size_t tbslen)171 static int ecdsa_sign(void *vctx, unsigned char *sig, size_t *siglen,
172 size_t sigsize, const unsigned char *tbs, size_t tbslen)
173 {
174 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
175 int ret;
176 unsigned int sltmp;
177 size_t ecsize = ECDSA_size(ctx->ec);
178
179 if (!ossl_prov_is_running())
180 return 0;
181
182 if (sig == NULL) {
183 *siglen = ecsize;
184 return 1;
185 }
186
187 #if !defined(OPENSSL_NO_ACVP_TESTS)
188 if (ctx->kattest && !ECDSA_sign_setup(ctx->ec, NULL, &ctx->kinv, &ctx->r))
189 return 0;
190 #endif
191
192 if (sigsize < (size_t)ecsize)
193 return 0;
194
195 if (ctx->mdsize != 0 && tbslen != ctx->mdsize)
196 return 0;
197
198 if (ctx->nonce_type != 0) {
199 ret = ossl_ecdsa_deterministic_sign(tbs, tbslen, sig, &sltmp,
200 ctx->ec, ctx->nonce_type,
201 ctx->mdname,
202 ctx->libctx, ctx->propq);
203 } else {
204 ret = ECDSA_sign_ex(0, tbs, tbslen, sig, &sltmp, ctx->kinv, ctx->r,
205 ctx->ec);
206 }
207 if (ret <= 0)
208 return 0;
209
210 *siglen = sltmp;
211 return 1;
212 }
213
ecdsa_verify(void * vctx,const unsigned char * sig,size_t siglen,const unsigned char * tbs,size_t tbslen)214 static int ecdsa_verify(void *vctx, const unsigned char *sig, size_t siglen,
215 const unsigned char *tbs, size_t tbslen)
216 {
217 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
218
219 if (!ossl_prov_is_running() || (ctx->mdsize != 0 && tbslen != ctx->mdsize))
220 return 0;
221
222 return ECDSA_verify(0, tbs, tbslen, sig, siglen, ctx->ec);
223 }
224
ecdsa_setup_md(PROV_ECDSA_CTX * ctx,const char * mdname,const char * mdprops)225 static int ecdsa_setup_md(PROV_ECDSA_CTX *ctx, const char *mdname,
226 const char *mdprops)
227 {
228 EVP_MD *md = NULL;
229 size_t mdname_len;
230 int md_nid, sha1_allowed, md_size;
231 WPACKET pkt;
232
233 if (mdname == NULL)
234 return 1;
235
236 mdname_len = strlen(mdname);
237 if (mdname_len >= sizeof(ctx->mdname)) {
238 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
239 "%s exceeds name buffer length", mdname);
240 return 0;
241 }
242 if (mdprops == NULL)
243 mdprops = ctx->propq;
244 md = EVP_MD_fetch(ctx->libctx, mdname, mdprops);
245 if (md == NULL) {
246 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
247 "%s could not be fetched", mdname);
248 return 0;
249 }
250 md_size = EVP_MD_get_size(md);
251 if (md_size <= 0) {
252 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
253 "%s has invalid md size %d", mdname, md_size);
254 EVP_MD_free(md);
255 return 0;
256 }
257 sha1_allowed = (ctx->operation != EVP_PKEY_OP_SIGN);
258 md_nid = ossl_digest_get_approved_nid_with_sha1(ctx->libctx, md,
259 sha1_allowed);
260 if (md_nid < 0) {
261 ERR_raise_data(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED,
262 "digest=%s", mdname);
263 EVP_MD_free(md);
264 return 0;
265 }
266
267 if (!ctx->flag_allow_md) {
268 if (ctx->mdname[0] != '\0' && !EVP_MD_is_a(md, ctx->mdname)) {
269 ERR_raise_data(ERR_LIB_PROV, PROV_R_DIGEST_NOT_ALLOWED,
270 "digest %s != %s", mdname, ctx->mdname);
271 EVP_MD_free(md);
272 return 0;
273 }
274 EVP_MD_free(md);
275 return 1;
276 }
277
278 EVP_MD_CTX_free(ctx->mdctx);
279 EVP_MD_free(ctx->md);
280
281 ctx->aid_len = 0;
282 if (WPACKET_init_der(&pkt, ctx->aid_buf, sizeof(ctx->aid_buf))
283 && ossl_DER_w_algorithmIdentifier_ECDSA_with_MD(&pkt, -1, ctx->ec,
284 md_nid)
285 && WPACKET_finish(&pkt)) {
286 WPACKET_get_total_written(&pkt, &ctx->aid_len);
287 ctx->aid = WPACKET_get_curr(&pkt);
288 }
289 WPACKET_cleanup(&pkt);
290 ctx->mdctx = NULL;
291 ctx->md = md;
292 ctx->mdsize = (size_t)md_size;
293 OPENSSL_strlcpy(ctx->mdname, mdname, sizeof(ctx->mdname));
294
295 return 1;
296 }
297
ecdsa_digest_signverify_init(void * vctx,const char * mdname,void * ec,const OSSL_PARAM params[],int operation)298 static int ecdsa_digest_signverify_init(void *vctx, const char *mdname,
299 void *ec, const OSSL_PARAM params[],
300 int operation)
301 {
302 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
303
304 if (!ossl_prov_is_running())
305 return 0;
306
307 if (!ecdsa_signverify_init(vctx, ec, params, operation)
308 || !ecdsa_setup_md(ctx, mdname, NULL))
309 return 0;
310
311 ctx->flag_allow_md = 0;
312
313 if (ctx->mdctx == NULL) {
314 ctx->mdctx = EVP_MD_CTX_new();
315 if (ctx->mdctx == NULL)
316 goto error;
317 }
318
319 if (!EVP_DigestInit_ex2(ctx->mdctx, ctx->md, params))
320 goto error;
321 return 1;
322 error:
323 EVP_MD_CTX_free(ctx->mdctx);
324 ctx->mdctx = NULL;
325 return 0;
326 }
327
ecdsa_digest_sign_init(void * vctx,const char * mdname,void * ec,const OSSL_PARAM params[])328 static int ecdsa_digest_sign_init(void *vctx, const char *mdname, void *ec,
329 const OSSL_PARAM params[])
330 {
331 return ecdsa_digest_signverify_init(vctx, mdname, ec, params,
332 EVP_PKEY_OP_SIGN);
333 }
334
ecdsa_digest_verify_init(void * vctx,const char * mdname,void * ec,const OSSL_PARAM params[])335 static int ecdsa_digest_verify_init(void *vctx, const char *mdname, void *ec,
336 const OSSL_PARAM params[])
337 {
338 return ecdsa_digest_signverify_init(vctx, mdname, ec, params,
339 EVP_PKEY_OP_VERIFY);
340 }
341
ecdsa_digest_signverify_update(void * vctx,const unsigned char * data,size_t datalen)342 int ecdsa_digest_signverify_update(void *vctx, const unsigned char *data,
343 size_t datalen)
344 {
345 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
346
347 if (ctx == NULL || ctx->mdctx == NULL)
348 return 0;
349
350 return EVP_DigestUpdate(ctx->mdctx, data, datalen);
351 }
352
ecdsa_digest_sign_final(void * vctx,unsigned char * sig,size_t * siglen,size_t sigsize)353 int ecdsa_digest_sign_final(void *vctx, unsigned char *sig, size_t *siglen,
354 size_t sigsize)
355 {
356 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
357 unsigned char digest[EVP_MAX_MD_SIZE];
358 unsigned int dlen = 0;
359
360 if (!ossl_prov_is_running() || ctx == NULL || ctx->mdctx == NULL)
361 return 0;
362
363 /*
364 * If sig is NULL then we're just finding out the sig size. Other fields
365 * are ignored. Defer to ecdsa_sign.
366 */
367 if (sig != NULL
368 && !EVP_DigestFinal_ex(ctx->mdctx, digest, &dlen))
369 return 0;
370 ctx->flag_allow_md = 1;
371 return ecdsa_sign(vctx, sig, siglen, sigsize, digest, (size_t)dlen);
372 }
373
ecdsa_digest_verify_final(void * vctx,const unsigned char * sig,size_t siglen)374 int ecdsa_digest_verify_final(void *vctx, const unsigned char *sig,
375 size_t siglen)
376 {
377 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
378 unsigned char digest[EVP_MAX_MD_SIZE];
379 unsigned int dlen = 0;
380
381 if (!ossl_prov_is_running() || ctx == NULL || ctx->mdctx == NULL)
382 return 0;
383
384 if (!EVP_DigestFinal_ex(ctx->mdctx, digest, &dlen))
385 return 0;
386 ctx->flag_allow_md = 1;
387 return ecdsa_verify(ctx, sig, siglen, digest, (size_t)dlen);
388 }
389
ecdsa_freectx(void * vctx)390 static void ecdsa_freectx(void *vctx)
391 {
392 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
393
394 OPENSSL_free(ctx->propq);
395 EVP_MD_CTX_free(ctx->mdctx);
396 EVP_MD_free(ctx->md);
397 ctx->propq = NULL;
398 ctx->mdctx = NULL;
399 ctx->md = NULL;
400 ctx->mdsize = 0;
401 EC_KEY_free(ctx->ec);
402 BN_clear_free(ctx->kinv);
403 BN_clear_free(ctx->r);
404 OPENSSL_free(ctx);
405 }
406
ecdsa_dupctx(void * vctx)407 static void *ecdsa_dupctx(void *vctx)
408 {
409 PROV_ECDSA_CTX *srcctx = (PROV_ECDSA_CTX *)vctx;
410 PROV_ECDSA_CTX *dstctx;
411
412 if (!ossl_prov_is_running())
413 return NULL;
414
415 dstctx = OPENSSL_zalloc(sizeof(*srcctx));
416 if (dstctx == NULL)
417 return NULL;
418
419 *dstctx = *srcctx;
420 dstctx->ec = NULL;
421 dstctx->md = NULL;
422 dstctx->mdctx = NULL;
423 dstctx->propq = NULL;
424
425 if (srcctx->ec != NULL && !EC_KEY_up_ref(srcctx->ec))
426 goto err;
427 /* Test KATS should not need to be supported */
428 if (srcctx->kinv != NULL || srcctx->r != NULL)
429 goto err;
430 dstctx->ec = srcctx->ec;
431
432 if (srcctx->md != NULL && !EVP_MD_up_ref(srcctx->md))
433 goto err;
434 dstctx->md = srcctx->md;
435
436 if (srcctx->mdctx != NULL) {
437 dstctx->mdctx = EVP_MD_CTX_new();
438 if (dstctx->mdctx == NULL
439 || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx))
440 goto err;
441 }
442
443 if (srcctx->propq != NULL) {
444 dstctx->propq = OPENSSL_strdup(srcctx->propq);
445 if (dstctx->propq == NULL)
446 goto err;
447 }
448
449 return dstctx;
450 err:
451 ecdsa_freectx(dstctx);
452 return NULL;
453 }
454
ecdsa_get_ctx_params(void * vctx,OSSL_PARAM * params)455 static int ecdsa_get_ctx_params(void *vctx, OSSL_PARAM *params)
456 {
457 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
458 OSSL_PARAM *p;
459
460 if (ctx == NULL)
461 return 0;
462
463 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID);
464 if (p != NULL && !OSSL_PARAM_set_octet_string(p, ctx->aid, ctx->aid_len))
465 return 0;
466
467 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST_SIZE);
468 if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->mdsize))
469 return 0;
470
471 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST);
472 if (p != NULL && !OSSL_PARAM_set_utf8_string(p, ctx->md == NULL
473 ? ctx->mdname
474 : EVP_MD_get0_name(ctx->md)))
475 return 0;
476
477 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_NONCE_TYPE);
478 if (p != NULL && !OSSL_PARAM_set_uint(p, ctx->nonce_type))
479 return 0;
480
481 return 1;
482 }
483
484 static const OSSL_PARAM known_gettable_ctx_params[] = {
485 OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
486 OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
487 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
488 OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_NONCE_TYPE, NULL),
489 OSSL_PARAM_END
490 };
491
ecdsa_gettable_ctx_params(ossl_unused void * vctx,ossl_unused void * provctx)492 static const OSSL_PARAM *ecdsa_gettable_ctx_params(ossl_unused void *vctx,
493 ossl_unused void *provctx)
494 {
495 return known_gettable_ctx_params;
496 }
497
ecdsa_set_ctx_params(void * vctx,const OSSL_PARAM params[])498 static int ecdsa_set_ctx_params(void *vctx, const OSSL_PARAM params[])
499 {
500 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
501 const OSSL_PARAM *p;
502 size_t mdsize = 0;
503
504 if (ctx == NULL)
505 return 0;
506 if (params == NULL)
507 return 1;
508
509 #if !defined(OPENSSL_NO_ACVP_TESTS)
510 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_KAT);
511 if (p != NULL && !OSSL_PARAM_get_uint(p, &ctx->kattest))
512 return 0;
513 #endif
514
515 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST);
516 if (p != NULL) {
517 char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname;
518 char mdprops[OSSL_MAX_PROPQUERY_SIZE] = "", *pmdprops = mdprops;
519 const OSSL_PARAM *propsp =
520 OSSL_PARAM_locate_const(params,
521 OSSL_SIGNATURE_PARAM_PROPERTIES);
522
523 if (!OSSL_PARAM_get_utf8_string(p, &pmdname, sizeof(mdname)))
524 return 0;
525 if (propsp != NULL
526 && !OSSL_PARAM_get_utf8_string(propsp, &pmdprops, sizeof(mdprops)))
527 return 0;
528 if (!ecdsa_setup_md(ctx, mdname, mdprops))
529 return 0;
530 }
531
532 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST_SIZE);
533 if (p != NULL) {
534 if (!OSSL_PARAM_get_size_t(p, &mdsize)
535 || (!ctx->flag_allow_md && mdsize != ctx->mdsize))
536 return 0;
537 ctx->mdsize = mdsize;
538 }
539 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_NONCE_TYPE);
540 if (p != NULL
541 && !OSSL_PARAM_get_uint(p, &ctx->nonce_type))
542 return 0;
543
544 return 1;
545 }
546
547 static const OSSL_PARAM settable_ctx_params[] = {
548 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
549 OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
550 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PROPERTIES, NULL, 0),
551 OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_KAT, NULL),
552 OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_NONCE_TYPE, NULL),
553 OSSL_PARAM_END
554 };
555
556 static const OSSL_PARAM settable_ctx_params_no_digest[] = {
557 OSSL_PARAM_uint(OSSL_SIGNATURE_PARAM_KAT, NULL),
558 OSSL_PARAM_END
559 };
560
ecdsa_settable_ctx_params(void * vctx,ossl_unused void * provctx)561 static const OSSL_PARAM *ecdsa_settable_ctx_params(void *vctx,
562 ossl_unused void *provctx)
563 {
564 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
565
566 if (ctx != NULL && !ctx->flag_allow_md)
567 return settable_ctx_params_no_digest;
568 return settable_ctx_params;
569 }
570
ecdsa_get_ctx_md_params(void * vctx,OSSL_PARAM * params)571 static int ecdsa_get_ctx_md_params(void *vctx, OSSL_PARAM *params)
572 {
573 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
574
575 if (ctx->mdctx == NULL)
576 return 0;
577
578 return EVP_MD_CTX_get_params(ctx->mdctx, params);
579 }
580
ecdsa_gettable_ctx_md_params(void * vctx)581 static const OSSL_PARAM *ecdsa_gettable_ctx_md_params(void *vctx)
582 {
583 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
584
585 if (ctx->md == NULL)
586 return 0;
587
588 return EVP_MD_gettable_ctx_params(ctx->md);
589 }
590
ecdsa_set_ctx_md_params(void * vctx,const OSSL_PARAM params[])591 static int ecdsa_set_ctx_md_params(void *vctx, const OSSL_PARAM params[])
592 {
593 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
594
595 if (ctx->mdctx == NULL)
596 return 0;
597
598 return EVP_MD_CTX_set_params(ctx->mdctx, params);
599 }
600
ecdsa_settable_ctx_md_params(void * vctx)601 static const OSSL_PARAM *ecdsa_settable_ctx_md_params(void *vctx)
602 {
603 PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
604
605 if (ctx->md == NULL)
606 return 0;
607
608 return EVP_MD_settable_ctx_params(ctx->md);
609 }
610
611 const OSSL_DISPATCH ossl_ecdsa_signature_functions[] = {
612 { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))ecdsa_newctx },
613 { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))ecdsa_sign_init },
614 { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))ecdsa_sign },
615 { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))ecdsa_verify_init },
616 { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))ecdsa_verify },
617 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,
618 (void (*)(void))ecdsa_digest_sign_init },
619 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE,
620 (void (*)(void))ecdsa_digest_signverify_update },
621 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL,
622 (void (*)(void))ecdsa_digest_sign_final },
623 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,
624 (void (*)(void))ecdsa_digest_verify_init },
625 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE,
626 (void (*)(void))ecdsa_digest_signverify_update },
627 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL,
628 (void (*)(void))ecdsa_digest_verify_final },
629 { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))ecdsa_freectx },
630 { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))ecdsa_dupctx },
631 { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, (void (*)(void))ecdsa_get_ctx_params },
632 { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,
633 (void (*)(void))ecdsa_gettable_ctx_params },
634 { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))ecdsa_set_ctx_params },
635 { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,
636 (void (*)(void))ecdsa_settable_ctx_params },
637 { OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS,
638 (void (*)(void))ecdsa_get_ctx_md_params },
639 { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS,
640 (void (*)(void))ecdsa_gettable_ctx_md_params },
641 { OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS,
642 (void (*)(void))ecdsa_set_ctx_md_params },
643 { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS,
644 (void (*)(void))ecdsa_settable_ctx_md_params },
645 OSSL_DISPATCH_END
646 };
647