providers/implementations/signature/sm2sig.c

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