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