1 /*
2 * Copyright 2020-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 * ECDSA low level APIs are deprecated for public use, but still ok for
12 * internal use - SM2 implementation uses ECDSA_size() function.
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/sm3.h"
29 #include "prov/implementations.h"
30 #include "prov/providercommon.h"
31 #include "prov/provider_ctx.h"
32 #include "crypto/ec.h"
33 #include "crypto/sm2.h"
34 #include "prov/der_sm2.h"
35
36 static OSSL_FUNC_signature_newctx_fn sm2sig_newctx;
37 static OSSL_FUNC_signature_sign_init_fn sm2sig_signature_init;
38 static OSSL_FUNC_signature_verify_init_fn sm2sig_signature_init;
39 static OSSL_FUNC_signature_sign_fn sm2sig_sign;
40 static OSSL_FUNC_signature_verify_fn sm2sig_verify;
41 static OSSL_FUNC_signature_digest_sign_init_fn sm2sig_digest_signverify_init;
42 static OSSL_FUNC_signature_digest_sign_update_fn sm2sig_digest_signverify_update;
43 static OSSL_FUNC_signature_digest_sign_final_fn sm2sig_digest_sign_final;
44 static OSSL_FUNC_signature_digest_verify_init_fn sm2sig_digest_signverify_init;
45 static OSSL_FUNC_signature_digest_verify_update_fn sm2sig_digest_signverify_update;
46 static OSSL_FUNC_signature_digest_verify_final_fn sm2sig_digest_verify_final;
47 static OSSL_FUNC_signature_freectx_fn sm2sig_freectx;
48 static OSSL_FUNC_signature_dupctx_fn sm2sig_dupctx;
49 static OSSL_FUNC_signature_get_ctx_params_fn sm2sig_get_ctx_params;
50 static OSSL_FUNC_signature_gettable_ctx_params_fn sm2sig_gettable_ctx_params;
51 static OSSL_FUNC_signature_set_ctx_params_fn sm2sig_set_ctx_params;
52 static OSSL_FUNC_signature_settable_ctx_params_fn sm2sig_settable_ctx_params;
53 static OSSL_FUNC_signature_get_ctx_md_params_fn sm2sig_get_ctx_md_params;
54 static OSSL_FUNC_signature_gettable_ctx_md_params_fn sm2sig_gettable_ctx_md_params;
55 static OSSL_FUNC_signature_set_ctx_md_params_fn sm2sig_set_ctx_md_params;
56 static OSSL_FUNC_signature_settable_ctx_md_params_fn sm2sig_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 EC structures, so
61 * we use that here too.
62 */
63 typedef struct {
64 OSSL_LIB_CTX *libctx;
65 char *propq;
66 EC_KEY *ec;
67
68 /*
69 * Flag to determine if the 'z' digest needs to be computed and fed to the
70 * hash function.
71 * This flag should be set on initialization and the computation should
72 * be performed only once, on first update.
73 */
74 unsigned int flag_compute_z_digest : 1;
75
76 char mdname[OSSL_MAX_NAME_SIZE];
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
83 /* main digest */
84 EVP_MD *md;
85 EVP_MD_CTX *mdctx;
86 size_t mdsize;
87
88 /* SM2 ID used for calculating the Z value */
89 unsigned char *id;
90 size_t id_len;
91 } PROV_SM2_CTX;
92
sm2sig_set_mdname(PROV_SM2_CTX * psm2ctx,const char * mdname)93 static int sm2sig_set_mdname(PROV_SM2_CTX *psm2ctx, const char *mdname)
94 {
95 if (psm2ctx->md == NULL) /* We need an SM3 md to compare with */
96 psm2ctx->md = EVP_MD_fetch(psm2ctx->libctx, psm2ctx->mdname,
97 psm2ctx->propq);
98 if (psm2ctx->md == NULL)
99 return 0;
100
101 /* XOF digests don't work */
102 if (EVP_MD_xof(psm2ctx->md)) {
103 ERR_raise(ERR_LIB_PROV, PROV_R_XOF_DIGESTS_NOT_ALLOWED);
104 return 0;
105 }
106
107 if (mdname == NULL)
108 return 1;
109
110 if (strlen(mdname) >= sizeof(psm2ctx->mdname)
111 || !EVP_MD_is_a(psm2ctx->md, mdname)) {
112 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST, "digest=%s",
113 mdname);
114 return 0;
115 }
116
117 OPENSSL_strlcpy(psm2ctx->mdname, mdname, sizeof(psm2ctx->mdname));
118 return 1;
119 }
120
sm2sig_newctx(void * provctx,const char * propq)121 static void *sm2sig_newctx(void *provctx, const char *propq)
122 {
123 PROV_SM2_CTX *ctx = OPENSSL_zalloc(sizeof(PROV_SM2_CTX));
124
125 if (ctx == NULL)
126 return NULL;
127
128 ctx->libctx = PROV_LIBCTX_OF(provctx);
129 if (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL) {
130 OPENSSL_free(ctx);
131 return NULL;
132 }
133 ctx->mdsize = SM3_DIGEST_LENGTH;
134 strcpy(ctx->mdname, OSSL_DIGEST_NAME_SM3);
135 return ctx;
136 }
137
sm2sig_signature_init(void * vpsm2ctx,void * ec,const OSSL_PARAM params[])138 static int sm2sig_signature_init(void *vpsm2ctx, void *ec,
139 const OSSL_PARAM params[])
140 {
141 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
142
143 if (!ossl_prov_is_running()
144 || psm2ctx == NULL)
145 return 0;
146
147 if (ec == NULL && psm2ctx->ec == NULL) {
148 ERR_raise(ERR_LIB_PROV, PROV_R_NO_KEY_SET);
149 return 0;
150 }
151
152 if (ec != NULL) {
153 if (!EC_KEY_up_ref(ec))
154 return 0;
155 EC_KEY_free(psm2ctx->ec);
156 psm2ctx->ec = ec;
157 }
158
159 return sm2sig_set_ctx_params(psm2ctx, params);
160 }
161
sm2sig_sign(void * vpsm2ctx,unsigned char * sig,size_t * siglen,size_t sigsize,const unsigned char * tbs,size_t tbslen)162 static int sm2sig_sign(void *vpsm2ctx, unsigned char *sig, size_t *siglen,
163 size_t sigsize, const unsigned char *tbs, size_t tbslen)
164 {
165 PROV_SM2_CTX *ctx = (PROV_SM2_CTX *)vpsm2ctx;
166 int ret;
167 unsigned int sltmp;
168 /* SM2 uses ECDSA_size as well */
169 size_t ecsize = ECDSA_size(ctx->ec);
170
171 if (sig == NULL) {
172 *siglen = ecsize;
173 return 1;
174 }
175
176 if (sigsize < (size_t)ecsize)
177 return 0;
178
179 if (ctx->mdsize != 0 && tbslen != ctx->mdsize)
180 return 0;
181
182 ret = ossl_sm2_internal_sign(tbs, tbslen, sig, &sltmp, ctx->ec);
183 if (ret <= 0)
184 return 0;
185
186 *siglen = sltmp;
187 return 1;
188 }
189
sm2sig_verify(void * vpsm2ctx,const unsigned char * sig,size_t siglen,const unsigned char * tbs,size_t tbslen)190 static int sm2sig_verify(void *vpsm2ctx, const unsigned char *sig, size_t siglen,
191 const unsigned char *tbs, size_t tbslen)
192 {
193 PROV_SM2_CTX *ctx = (PROV_SM2_CTX *)vpsm2ctx;
194
195 if (ctx->mdsize != 0 && tbslen != ctx->mdsize)
196 return 0;
197
198 return ossl_sm2_internal_verify(tbs, tbslen, sig, siglen, ctx->ec);
199 }
200
free_md(PROV_SM2_CTX * ctx)201 static void free_md(PROV_SM2_CTX *ctx)
202 {
203 EVP_MD_CTX_free(ctx->mdctx);
204 EVP_MD_free(ctx->md);
205 ctx->mdctx = NULL;
206 ctx->md = NULL;
207 }
208
sm2sig_digest_signverify_init(void * vpsm2ctx,const char * mdname,void * ec,const OSSL_PARAM params[])209 static int sm2sig_digest_signverify_init(void *vpsm2ctx, const char *mdname,
210 void *ec, const OSSL_PARAM params[])
211 {
212 PROV_SM2_CTX *ctx = (PROV_SM2_CTX *)vpsm2ctx;
213 int md_nid;
214 WPACKET pkt;
215 int ret = 0;
216
217 if (!sm2sig_signature_init(vpsm2ctx, ec, params)
218 || !sm2sig_set_mdname(ctx, mdname))
219 return ret;
220
221 if (ctx->mdctx == NULL) {
222 ctx->mdctx = EVP_MD_CTX_new();
223 if (ctx->mdctx == NULL)
224 goto error;
225 }
226
227 md_nid = EVP_MD_get_type(ctx->md);
228
229 /*
230 * We do not care about DER writing errors.
231 * All it really means is that for some reason, there's no
232 * AlgorithmIdentifier to be had, but the operation itself is
233 * still valid, just as long as it's not used to construct
234 * anything that needs an AlgorithmIdentifier.
235 */
236 ctx->aid_len = 0;
237 if (WPACKET_init_der(&pkt, ctx->aid_buf, sizeof(ctx->aid_buf))
238 && ossl_DER_w_algorithmIdentifier_SM2_with_MD(&pkt, -1, ctx->ec, md_nid)
239 && WPACKET_finish(&pkt)) {
240 WPACKET_get_total_written(&pkt, &ctx->aid_len);
241 ctx->aid = WPACKET_get_curr(&pkt);
242 }
243 WPACKET_cleanup(&pkt);
244
245 if (!EVP_DigestInit_ex2(ctx->mdctx, ctx->md, params))
246 goto error;
247
248 ctx->flag_compute_z_digest = 1;
249
250 ret = 1;
251
252 error:
253 return ret;
254 }
255
sm2sig_compute_z_digest(PROV_SM2_CTX * ctx)256 static int sm2sig_compute_z_digest(PROV_SM2_CTX *ctx)
257 {
258 uint8_t *z = NULL;
259 int ret = 1;
260
261 if (ctx->flag_compute_z_digest) {
262 /* Only do this once */
263 ctx->flag_compute_z_digest = 0;
264
265 if ((z = OPENSSL_zalloc(ctx->mdsize)) == NULL
266 /* get hashed prefix 'z' of tbs message */
267 || !ossl_sm2_compute_z_digest(z, ctx->md, ctx->id, ctx->id_len,
268 ctx->ec)
269 || !EVP_DigestUpdate(ctx->mdctx, z, ctx->mdsize))
270 ret = 0;
271 OPENSSL_free(z);
272 }
273
274 return ret;
275 }
276
sm2sig_digest_signverify_update(void * vpsm2ctx,const unsigned char * data,size_t datalen)277 int sm2sig_digest_signverify_update(void *vpsm2ctx, const unsigned char *data,
278 size_t datalen)
279 {
280 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
281
282 if (psm2ctx == NULL || psm2ctx->mdctx == NULL)
283 return 0;
284
285 return sm2sig_compute_z_digest(psm2ctx)
286 && EVP_DigestUpdate(psm2ctx->mdctx, data, datalen);
287 }
288
sm2sig_digest_sign_final(void * vpsm2ctx,unsigned char * sig,size_t * siglen,size_t sigsize)289 int sm2sig_digest_sign_final(void *vpsm2ctx, unsigned char *sig, size_t *siglen,
290 size_t sigsize)
291 {
292 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
293 unsigned char digest[EVP_MAX_MD_SIZE];
294 unsigned int dlen = 0;
295
296 if (psm2ctx == NULL || psm2ctx->mdctx == NULL)
297 return 0;
298
299 /*
300 * If sig is NULL then we're just finding out the sig size. Other fields
301 * are ignored. Defer to sm2sig_sign.
302 */
303 if (sig != NULL) {
304 if (!(sm2sig_compute_z_digest(psm2ctx)
305 && EVP_DigestFinal_ex(psm2ctx->mdctx, digest, &dlen)))
306 return 0;
307 }
308
309 return sm2sig_sign(vpsm2ctx, sig, siglen, sigsize, digest, (size_t)dlen);
310 }
311
312
sm2sig_digest_verify_final(void * vpsm2ctx,const unsigned char * sig,size_t siglen)313 int sm2sig_digest_verify_final(void *vpsm2ctx, const unsigned char *sig,
314 size_t siglen)
315 {
316 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
317 unsigned char digest[EVP_MAX_MD_SIZE];
318 unsigned int dlen = 0;
319 int md_size;
320
321 if (psm2ctx == NULL || psm2ctx->mdctx == NULL)
322 return 0;
323
324 md_size = EVP_MD_get_size(psm2ctx->md);
325 if (md_size <= 0 || md_size > (int)sizeof(digest))
326 return 0;
327
328 if (!(sm2sig_compute_z_digest(psm2ctx)
329 && EVP_DigestFinal_ex(psm2ctx->mdctx, digest, &dlen)))
330 return 0;
331
332 return sm2sig_verify(vpsm2ctx, sig, siglen, digest, (size_t)dlen);
333 }
334
sm2sig_freectx(void * vpsm2ctx)335 static void sm2sig_freectx(void *vpsm2ctx)
336 {
337 PROV_SM2_CTX *ctx = (PROV_SM2_CTX *)vpsm2ctx;
338
339 free_md(ctx);
340 EC_KEY_free(ctx->ec);
341 OPENSSL_free(ctx->propq);
342 OPENSSL_free(ctx->id);
343 OPENSSL_free(ctx);
344 }
345
sm2sig_dupctx(void * vpsm2ctx)346 static void *sm2sig_dupctx(void *vpsm2ctx)
347 {
348 PROV_SM2_CTX *srcctx = (PROV_SM2_CTX *)vpsm2ctx;
349 PROV_SM2_CTX *dstctx;
350
351 dstctx = OPENSSL_zalloc(sizeof(*srcctx));
352 if (dstctx == NULL)
353 return NULL;
354
355 *dstctx = *srcctx;
356 dstctx->ec = NULL;
357 dstctx->propq = NULL;
358 dstctx->md = NULL;
359 dstctx->mdctx = NULL;
360 dstctx->id = NULL;
361
362 if (srcctx->ec != NULL && !EC_KEY_up_ref(srcctx->ec))
363 goto err;
364 dstctx->ec = srcctx->ec;
365
366 if (srcctx->propq != NULL) {
367 dstctx->propq = OPENSSL_strdup(srcctx->propq);
368 if (dstctx->propq == NULL)
369 goto err;
370 }
371
372 if (srcctx->md != NULL && !EVP_MD_up_ref(srcctx->md))
373 goto err;
374 dstctx->md = srcctx->md;
375
376 if (srcctx->mdctx != NULL) {
377 dstctx->mdctx = EVP_MD_CTX_new();
378 if (dstctx->mdctx == NULL
379 || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx))
380 goto err;
381 }
382
383 if (srcctx->id != NULL) {
384 dstctx->id = OPENSSL_malloc(srcctx->id_len);
385 if (dstctx->id == NULL)
386 goto err;
387 dstctx->id_len = srcctx->id_len;
388 memcpy(dstctx->id, srcctx->id, srcctx->id_len);
389 }
390
391 return dstctx;
392 err:
393 sm2sig_freectx(dstctx);
394 return NULL;
395 }
396
sm2sig_get_ctx_params(void * vpsm2ctx,OSSL_PARAM * params)397 static int sm2sig_get_ctx_params(void *vpsm2ctx, OSSL_PARAM *params)
398 {
399 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
400 OSSL_PARAM *p;
401
402 if (psm2ctx == NULL)
403 return 0;
404
405 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID);
406 if (p != NULL
407 && !OSSL_PARAM_set_octet_string(p, psm2ctx->aid, psm2ctx->aid_len))
408 return 0;
409
410 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST_SIZE);
411 if (p != NULL && !OSSL_PARAM_set_size_t(p, psm2ctx->mdsize))
412 return 0;
413
414 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST);
415 if (p != NULL && !OSSL_PARAM_set_utf8_string(p, psm2ctx->md == NULL
416 ? psm2ctx->mdname
417 : EVP_MD_get0_name(psm2ctx->md)))
418 return 0;
419
420 return 1;
421 }
422
423 static const OSSL_PARAM known_gettable_ctx_params[] = {
424 OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
425 OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
426 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
427 OSSL_PARAM_END
428 };
429
sm2sig_gettable_ctx_params(ossl_unused void * vpsm2ctx,ossl_unused void * provctx)430 static const OSSL_PARAM *sm2sig_gettable_ctx_params(ossl_unused void *vpsm2ctx,
431 ossl_unused void *provctx)
432 {
433 return known_gettable_ctx_params;
434 }
435
sm2sig_set_ctx_params(void * vpsm2ctx,const OSSL_PARAM params[])436 static int sm2sig_set_ctx_params(void *vpsm2ctx, const OSSL_PARAM params[])
437 {
438 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
439 const OSSL_PARAM *p;
440 size_t mdsize;
441
442 if (psm2ctx == NULL)
443 return 0;
444 if (params == NULL)
445 return 1;
446
447 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_DIST_ID);
448 if (p != NULL) {
449 void *tmp_id = NULL;
450 size_t tmp_idlen = 0;
451
452 /*
453 * If the 'z' digest has already been computed, the ID is set too late
454 */
455 if (!psm2ctx->flag_compute_z_digest)
456 return 0;
457
458 if (p->data_size != 0
459 && !OSSL_PARAM_get_octet_string(p, &tmp_id, 0, &tmp_idlen))
460 return 0;
461 OPENSSL_free(psm2ctx->id);
462 psm2ctx->id = tmp_id;
463 psm2ctx->id_len = tmp_idlen;
464 }
465
466 /*
467 * The following code checks that the size is the same as the SM3 digest
468 * size returning an error otherwise.
469 * If there is ever any different digest algorithm allowed with SM2
470 * this needs to be adjusted accordingly.
471 */
472 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST_SIZE);
473 if (p != NULL && (!OSSL_PARAM_get_size_t(p, &mdsize)
474 || mdsize != psm2ctx->mdsize))
475 return 0;
476
477 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST);
478 if (p != NULL) {
479 char *mdname = NULL;
480
481 if (!OSSL_PARAM_get_utf8_string(p, &mdname, 0))
482 return 0;
483 if (!sm2sig_set_mdname(psm2ctx, mdname)) {
484 OPENSSL_free(mdname);
485 return 0;
486 }
487 OPENSSL_free(mdname);
488 }
489
490 return 1;
491 }
492
493 static const OSSL_PARAM known_settable_ctx_params[] = {
494 OSSL_PARAM_size_t(OSSL_SIGNATURE_PARAM_DIGEST_SIZE, NULL),
495 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
496 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_DIST_ID, NULL, 0),
497 OSSL_PARAM_END
498 };
499
sm2sig_settable_ctx_params(ossl_unused void * vpsm2ctx,ossl_unused void * provctx)500 static const OSSL_PARAM *sm2sig_settable_ctx_params(ossl_unused void *vpsm2ctx,
501 ossl_unused void *provctx)
502 {
503 return known_settable_ctx_params;
504 }
505
sm2sig_get_ctx_md_params(void * vpsm2ctx,OSSL_PARAM * params)506 static int sm2sig_get_ctx_md_params(void *vpsm2ctx, OSSL_PARAM *params)
507 {
508 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
509
510 if (psm2ctx->mdctx == NULL)
511 return 0;
512
513 return EVP_MD_CTX_get_params(psm2ctx->mdctx, params);
514 }
515
sm2sig_gettable_ctx_md_params(void * vpsm2ctx)516 static const OSSL_PARAM *sm2sig_gettable_ctx_md_params(void *vpsm2ctx)
517 {
518 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
519
520 if (psm2ctx->md == NULL)
521 return 0;
522
523 return EVP_MD_gettable_ctx_params(psm2ctx->md);
524 }
525
sm2sig_set_ctx_md_params(void * vpsm2ctx,const OSSL_PARAM params[])526 static int sm2sig_set_ctx_md_params(void *vpsm2ctx, const OSSL_PARAM params[])
527 {
528 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
529
530 if (psm2ctx->mdctx == NULL)
531 return 0;
532
533 return EVP_MD_CTX_set_params(psm2ctx->mdctx, params);
534 }
535
sm2sig_settable_ctx_md_params(void * vpsm2ctx)536 static const OSSL_PARAM *sm2sig_settable_ctx_md_params(void *vpsm2ctx)
537 {
538 PROV_SM2_CTX *psm2ctx = (PROV_SM2_CTX *)vpsm2ctx;
539
540 if (psm2ctx->md == NULL)
541 return 0;
542
543 return EVP_MD_settable_ctx_params(psm2ctx->md);
544 }
545
546 const OSSL_DISPATCH ossl_sm2_signature_functions[] = {
547 { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))sm2sig_newctx },
548 { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))sm2sig_signature_init },
549 { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))sm2sig_sign },
550 { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))sm2sig_signature_init },
551 { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))sm2sig_verify },
552 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,
553 (void (*)(void))sm2sig_digest_signverify_init },
554 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE,
555 (void (*)(void))sm2sig_digest_signverify_update },
556 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL,
557 (void (*)(void))sm2sig_digest_sign_final },
558 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,
559 (void (*)(void))sm2sig_digest_signverify_init },
560 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE,
561 (void (*)(void))sm2sig_digest_signverify_update },
562 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL,
563 (void (*)(void))sm2sig_digest_verify_final },
564 { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))sm2sig_freectx },
565 { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))sm2sig_dupctx },
566 { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, (void (*)(void))sm2sig_get_ctx_params },
567 { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,
568 (void (*)(void))sm2sig_gettable_ctx_params },
569 { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))sm2sig_set_ctx_params },
570 { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,
571 (void (*)(void))sm2sig_settable_ctx_params },
572 { OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS,
573 (void (*)(void))sm2sig_get_ctx_md_params },
574 { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS,
575 (void (*)(void))sm2sig_gettable_ctx_md_params },
576 { OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS,
577 (void (*)(void))sm2sig_set_ctx_md_params },
578 { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS,
579 (void (*)(void))sm2sig_settable_ctx_md_params },
580 OSSL_DISPATCH_END
581 };
582