update pmeth/ameth

apps/pkeyutl.c

@@ -336,7 +336,6 @@ int pkeyutl_main(int argc, char **argv)
         BIO_write(out, buf_out, buf_outlen);
 
  end:
-/*
     EVP_PKEY_CTX_free(ctx);
     release_engine(e);
     BIO_free(in);
@@ -346,7 +345,6 @@ int pkeyutl_main(int argc, char **argv)
     OPENSSL_free(sig);
     sk_OPENSSL_STRING_free(pkeyopts);
     NCONF_free(conf);
-*/
     return ret;
 }
 

crypto/evp/pmeth_lib.c

@@ -47,7 +47,14 @@ static const EVP_PKEY_METHOD *standard_methods[] = {
 #ifndef OPENSSL_NO_EC
     &ecx25519_pkey_meth,
 #endif
-    &hkdf_pkey_meth
+    &hkdf_pkey_meth,
+#ifndef OPENSSL_NO_SM9
+    &sm9_pkey_meth,
+    &sm9_master_pkey_meth,
+#endif
+#ifndef OPENSSL_NO_PAILLIER
+    &paillier_pkey_meth,
+#endif
 };
 
 DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,

crypto/gmapi/gmapi_skf_ec.c

@@ -620,7 +620,7 @@ int i2d_ECCCIPHERBLOB(ECCCIPHERBLOB *a, unsigned char **pp)
 		return 0;
 	}
 
-	ret = i2d_SM2CiphertextValue(cv, pp));
+	ret = i2d_SM2CiphertextValue(cv, pp);
 	SM2CiphertextValue_free(cv);
 	return ret;
 }

crypto/include/internal/evp_int.h

@@ -84,6 +84,13 @@ extern const EVP_PKEY_METHOD hmac_pkey_meth;
 extern const EVP_PKEY_METHOD rsa_pkey_meth;
 extern const EVP_PKEY_METHOD tls1_prf_pkey_meth;
 extern const EVP_PKEY_METHOD hkdf_pkey_meth;
+#ifndef OPENSSL_NO_SM9
+extern const EVP_PKEY_METHOD sm9_pkey_meth;
+extern const EVP_PKEY_METHOD sm9_master_pkey_meth;
+#endif
+#ifndef OPENSSL_NO_PAILLIER
+extern const EVP_PKEY_METHOD paillier_pkey_meth;
+#endif
 
 struct evp_md_st {
     int type;

crypto/paillier/build.info

@@ -1,2 +1,3 @@
 LIBS=../../libcrypto
-SOURCE[../../libcrypto]=pai_lib.c pai_err.c pai_asn1.c pai_ameth.c
+SOURCE[../../libcrypto]=pai_lib.c pai_err.c pai_asn1.c pai_ameth.c \
+	pai_pmeth.c

crypto/paillier/pai_ameth.c

@@ -225,31 +225,32 @@ static int old_paillier_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
 }
 
 const EVP_PKEY_ASN1_METHOD paillier_asn1_meth = {
-	EVP_PKEY_PAILLIER,
+	EVP_PKEY_PAILLIER,		/* pkey_id */
-	EVP_PKEY_PAILLIER,
+	EVP_PKEY_PAILLIER,		/* pkey_base_id */
-	0, //FIXME
+	0,				/* pkey_flags */
-
+	"PAILLIER",			/* pem_str */
-	"PAILLIER",
+	"GmSSL Paillier algorithm",	/* info */
-	"OpenSSL PAILLIER algorithm",
+	paillier_pub_decode,		/* pub_decode */
-
+	paillier_pub_encode,		/* pub_encode */
-	paillier_pub_decode,
+	paillier_pub_cmp,		/* pub_cmp */
-	paillier_pub_encode,
+	paillier_pub_print,		/* pub_print */
-	paillier_pub_cmp,
+	paillier_priv_decode,		/* priv_decode */
-	paillier_pub_print,
+	paillier_priv_encode,		/* priv_encode */
-
+	paillier_priv_print,		/* priv_print */
-	paillier_priv_decode,
+	int_paillier_size,		/* pkey_size */
-	paillier_priv_encode,
+	paillier_bits,			/* pkey_bits */
-	paillier_priv_print,
+	paillier_security_bits,		/* pkey_security_bits */
-
+	NULL,				/* param_decode */
-	int_paillier_size,
+	NULL,				/* param_encode */
-	paillier_bits,
+	NULL,				/* param_missing */
-	paillier_security_bits,
+	NULL,				/* param_copy */
-
+	NULL,				/* param_cmp */
-	0, 0, 0, 0, 0, 0,
+	NULL,				/* param_print */
-	0,
+	NULL,				/* sig_print */
-
+	int_paillier_free,		/* pkey_free */
-	int_paillier_free,
+	paillier_pkey_ctrl,		/* pkey_ctrl */
-	paillier_pkey_ctrl,
+	old_paillier_priv_decode,	/* old_priv_decode */
-	old_paillier_priv_decode,
+	old_paillier_priv_encode,	/* old_priv_encode */
-	old_paillier_priv_encode
+	NULL,				/* item_verify */
+	NULL,				/* item_sign */
 };

crypto/paillier/pai_err.c

@@ -32,8 +32,12 @@ static ERR_STRING_DATA PAILLIER_str_functs[] = {
     {ERR_FUNC(PAILLIER_F_PAILLIER_PRIV_DECODE), "paillier_priv_decode"},
     {ERR_FUNC(PAILLIER_F_PAILLIER_PRIV_ENCODE), "paillier_priv_encode"},
     {ERR_FUNC(PAILLIER_F_PAILLIER_PUB_DECODE), "paillier_pub_decode"},
+    {ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_CTRL), "pkey_paillier_ctrl"},
+    {ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_CTRL_STR), "pkey_paillier_ctrl_str"},
     {ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_DECRYPT), "pkey_paillier_decrypt"},
     {ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_ENCRYPT), "pkey_paillier_encrypt"},
+    {ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_INIT), "pkey_paillier_init"},
+    {ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_KEYGEN), "pkey_paillier_keygen"},
     {0, NULL}
 };
 
@@ -42,8 +46,10 @@ static ERR_STRING_DATA PAILLIER_str_reasons[] = {
     {ERR_REASON(PAILLIER_R_DECODE_ERROR), "decode error"},
     {ERR_REASON(PAILLIER_R_GENERATE_PRIME_FAILED), "generate prime failed"},
     {ERR_REASON(PAILLIER_R_INVALID_PLAINTEXT), "invalid plaintext"},
+    {ERR_REASON(PAILLIER_R_KEY_SIZE_TOO_SMALL), "key size too small"},
     {ERR_REASON(PAILLIER_R_MALLOC_FAILED), "malloc failed"},
     {ERR_REASON(PAILLIER_R_NOT_IMPLEMENTED), "not implemented"},
+    {ERR_REASON(PAILLIER_R_VALUE_MISSING), "value missing"},
     {0, NULL}
 };
 

crypto/paillier/pai_lcl.h

@@ -67,4 +67,3 @@ struct paillier_st {
 };
 
 #endif
-

crypto/paillier/pai_lib.c

@@ -81,7 +81,7 @@ void PAILLIER_free(PAILLIER *key)
 
 int PAILLIER_size(const PAILLIER *key)
 {
-	return BN_num_bits(key->n)/8;
+	return (BN_num_bits(key->n) * 2)/8;
 }
 
 int PAILLIER_security_bits(const PAILLIER *key)
@@ -100,57 +100,60 @@ int PAILLIER_generate_key(PAILLIER *key, int bits)
 	q = BN_new();
 	bn_ctx = BN_CTX_new();
 
-	if (!key->n) key->n = BN_new();
+	if (!key->n)
-	if (!key->lambda) key->lambda = BN_new();
+		key->n = BN_new();
-	if (!key->n_squared) key->n_squared = BN_new();
+	if (!key->lambda)
-	if (!key->n_plusone) key->n_plusone = BN_new();
+		key->lambda = BN_new();
-	if (!key->x) key->x = BN_new();
+	if (!key->n_squared)
+		key->n_squared = BN_new();
+	if (!key->n_plusone)
+		key->n_plusone = BN_new();
+	if (!key->x)
+		key->x = BN_new();
+
 	if (!p || !q || !bn_ctx || !key->n || !key->lambda ||
 		!key->n_squared || !key->n_plusone || !key->x) {
+		PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY, ERR_R_MALLOC_FAILURE);
 		goto end;
 	}
 
 	key->bits = bits;
 
 	do {
-		if (!BN_generate_prime_ex(p, bits, 0, NULL, NULL, NULL)) {
+		if (!BN_generate_prime_ex(p, bits/2, 0, NULL, NULL, NULL)) {
 			PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY,
 				PAILLIER_R_GENERATE_PRIME_FAILED);
 			goto end;
 		}
 
-		if (!BN_generate_prime_ex(q, bits, 0, NULL, NULL, NULL)) {
+		if (!BN_generate_prime_ex(q, bits/2, 0, NULL, NULL, NULL)) {
 			PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY,
 				PAILLIER_R_GENERATE_PRIME_FAILED);
 			goto end;
 		}
 
-		if (!BN_mul(key->n, p, q, bn_ctx)) {
+		if (!BN_mul(key->n, p, q, bn_ctx)
+			|| !BN_sub_word(p, 1)
+			|| !BN_sub_word(q, 1)
+			/* lambda = (p - 1)*(q - 1) */
+			|| !BN_mul(key->lambda, p, q, bn_ctx)
+			/* n_squared = n^2 */
+			|| !BN_sqr(key->n_squared, key->n, bn_ctx)
+			/* n_plusone = n + 1 */
+			|| !BN_copy(key->n_plusone, key->n)
+			|| !BN_add_word(key->n_plusone, 1)
+#if 0
+			/* x = (((g^lambda mod n^2) - 1)/n)^-1 mod n */
+			|| !BN_mod_exp(key->x, key->n_plusone, key->lambda, key->n_squared, bn_ctx)
+			|| !BN_sub_word(key->x, 1)
+			|| !BN_div(key->x, key->x, key->n)
+			|| !BN_mod_inverse(key->x, key->x, key->n, bn_ctx)
+#endif
+			) {
 			PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY, ERR_R_BN_LIB);
 			goto end;
 		}
 
-		if (!BN_sub_word(p, 1)) {
-			goto end;
-		}
-		if (!BN_sub_word(q, 1)) {
-			goto end;
-		}
-		if (!BN_mul(key->lambda, p, q, bn_ctx)) {
-			goto end;
-		}
-
-		BN_sqr(key->n_squared, key->n, bn_ctx);
-		BN_copy(key->n_plusone, key->n);
-		BN_add_word(key->n_plusone, 1);
-
-		/*
-		BN_mod_exp(key->x, key->n_plusone, key->lambda, key->n_squared, bn_ctx);
-		BN_sub_word(key->x, 1);
-		BN_div(key->x, key->x, key->n);
-		BN_mod_inverse(key->x, key->x, key->n, bn_ctx);
-		*/
-
 	} while (0);
 
 	ret = 1;
@@ -173,6 +176,9 @@ int PAILLIER_encrypt(BIGNUM *c, const BIGNUM *m, PAILLIER *pub_key)
 	BIGNUM *r = NULL;
 	BN_CTX *bn_ctx = NULL;
 
+
+fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
+
 	if (BN_cmp(m, pub_key->n) >= 0) {
 		PAILLIERerr(PAILLIER_F_PAILLIER_ENCRYPT, PAILLIER_R_INVALID_PLAINTEXT);
 		goto end;
@@ -249,22 +255,54 @@ int PAILLIER_decrypt(BIGNUM *m, const BIGNUM *c, PAILLIER *key)
 		PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
 		goto end;
 	}
+
+/*
+printf("m      = %s\n", BN_bn2hex(m));
+printf("c      = %s\n", BN_bn2hex(c));
+printf("lambda = %s\n", BN_bn2hex(key->lambda));
+printf("n^2    = %s\n", BN_bn2hex(key->n_squared));
+*/
+
+	if (!key->n_squared) {
+		if (!(key->n_squared = BN_new())) {
+			PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_MALLOC_FAILURE);
+			goto end;
+		}
+		if (!BN_sqr(key->n_squared, key->n, bn_ctx)) {
+			PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
+			goto end;
+		}
+	}
+
+
+
+fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
+
 	if (!BN_mod_exp(m, c, key->lambda, key->n_squared, bn_ctx)) {
 		PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
 		goto end;
 	}
+
+fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
 	if (!BN_sub_word(m, 1)) {
 		PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
 		goto end;
 	}
+
+fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
 	if (!BN_div(m, NULL, m, key->n, bn_ctx)) {
 		PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
 		goto end;
 	}
+
+fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
 	if (!BN_mod_mul(m, m, key->x, key->n, bn_ctx)) {
 		PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
 		goto end;
 	}
+
+printf("m = %s\n", BN_bn2hex(m));
+
 	ret = 1;
 end:
 	BN_CTX_free(bn_ctx);

crypto/paillier/pai_pmeth.c

@@ -49,37 +49,76 @@
 
 #include <stdio.h>
 #include <openssl/evp.h>
+#include <openssl/err.h>
 #include <openssl/paillier.h>
 #include "internal/evp_int.h"
+#include "pai_lcl.h"
 
 typedef struct {
-	int flags;
+	int bits;
 } PAILLIER_PKEY_CTX;
 
 static int pkey_paillier_init(EVP_PKEY_CTX *ctx)
 {
+	PAILLIER_PKEY_CTX *dctx;
+	if (!(dctx = OPENSSL_zalloc(sizeof(*dctx)))) {
+		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_INIT, ERR_R_MALLOC_FAILURE);
+		return 0;
+	}
+	dctx->bits = 4096;
+	(void)EVP_PKEY_CTX_set_data(ctx, dctx);
 	return 1;
 }
 
 static int pkey_paillier_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
 {
+	PAILLIER_PKEY_CTX *dctx;
+	PAILLIER_PKEY_CTX *sctx;
+	if (!pkey_paillier_init(dst))
+		return 0;
+	dctx = EVP_PKEY_CTX_get_data(dst);
+	sctx = EVP_PKEY_CTX_get_data(src);
+	OPENSSL_assert(sctx);
+	*dctx = *sctx;
 	return 1;
 }
 
 static void pkey_paillier_cleanup(EVP_PKEY_CTX *ctx)
 {
+	PAILLIER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	if (dctx) {
+		OPENSSL_free(dctx);
+	}
+}
+
+static int pkey_paillier_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
+{
+	PAILLIER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	PAILLIER *pai = NULL;
+	if (!(pai = PAILLIER_new())) {
+		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_KEYGEN, ERR_R_MALLOC_FAILURE);
+		return 0;
+	}
+	if (!EVP_PKEY_assign_PAILLIER(pkey, pai)) {
+		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_KEYGEN, ERR_R_EVP_LIB);
+		PAILLIER_free(pai);
+		return 0;
+	}
+	if (!PAILLIER_generate_key(EVP_PKEY_get0_PAILLIER(pkey), dctx->bits)) {
+		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_KEYGEN, ERR_R_PAILLIER_LIB);
+		return 0;
+	}
+	return 1;
 }
 
 static int pkey_paillier_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
 	const unsigned char *in, size_t inlen)
 {
 	int ret = 0;
-	PAILLIER *key = ctx->pkey->pkey.paillier;
+	PAILLIER *key = EVP_PKEY_get0_PAILLIER(EVP_PKEY_CTX_get0_pkey(ctx));
 	BIGNUM *m = NULL;
 	BIGNUM *c = NULL;
 
-	//FIXME: check inlen
-
 	if (!out) {
 		*outlen = PAILLIER_size(key);
 		return 1;
@@ -92,20 +131,21 @@ static int pkey_paillier_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *
 		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_ENCRYPT, ERR_R_MALLOC_FAILURE);
 		goto end;
 	}
-
 	if (!BN_bin2bn(in, (int)inlen, m)) {
 		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_ENCRYPT, ERR_R_BN_LIB);
 		goto end;
 	}
 	if (!PAILLIER_encrypt(c, m, key)) {
+		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_ENCRYPT, ERR_R_PAILLIER_LIB);
 		goto end;
 	}
 
+	/* the ciphertext has no prefix zeros */
 	*outlen = BN_bn2bin(c, out);
 	ret = 1;
 
 end:
-	BN_free(m);
+	BN_clear_free(m);
 	BN_free(c);
 	return ret;
 }
@@ -114,7 +154,7 @@ static int pkey_paillier_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *
 	const unsigned char *in, size_t inlen)
 {
 	int ret = 0;
-	PAILLIER *key = ctx->pkey->pkey.paillier;
+	PAILLIER *key = EVP_PKEY_get0_PAILLIER(EVP_PKEY_CTX_get0_pkey(ctx));
 	BIGNUM *m = NULL;
 	BIGNUM *c = NULL;
 
@@ -130,15 +170,16 @@ static int pkey_paillier_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *
 		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_DECRYPT, ERR_R_MALLOC_FAILURE);
 		goto end;
 	}
-
 	if (!BN_bin2bn(in, (int)inlen, c)) {
 		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_DECRYPT, ERR_R_BN_LIB);
 		goto end;
 	}
 	if (!PAILLIER_decrypt(m, c, key)) {
+		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_DECRYPT, ERR_R_PAILLIER_LIB);
 		goto end;
 	}
 
+	/* the plaintext has no prefix zeros */
 	*outlen = BN_bn2bin(m, out);
 	ret = 1;
 end:
@@ -149,43 +190,61 @@ end:
 
 static int pkey_paillier_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 {
-	return 0;
+	PAILLIER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	switch (type) {
+	case EVP_PKEY_CTRL_PAILLIER_KEYGEN_BITS:
+		if (p1 < PAILLIER_MIN_KEY_BITS) {
+			PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_CTRL, PAILLIER_R_KEY_SIZE_TOO_SMALL);
+			return -2;
+		}
+		dctx->bits = p1;
+		return 1;
+	}
+	return -2;
 }
 
-static int pkey_paillier_ctrl_str(EVP_PKEY_CTX *ctx,
+static int pkey_paillier_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value)
-                            const char *type, const char *value)
 {
-	return 0;
+	if (!value) {
+		PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_CTRL_STR, PAILLIER_R_VALUE_MISSING);
+		return 0;
+	}
+	if (!strcmp(type, "bits")) {
+		int nbits = atoi(value);
+		return EVP_PKEY_CTX_set_paillier_keygen_bits(ctx, nbits);
+	}
+	return -2;
 }
 
 #define EVP_PKEY_PAILLIER NID_paillier
 
 
-const EVP_PKEY_METHOD paillier_pmeth = {
+const EVP_PKEY_METHOD paillier_pkey_meth = {
-	EVP_PKEY_PAILLIER,
+	EVP_PKEY_PAILLIER,	/* pkey_id */
-	0,
+	0,			/* flags */
-	pkey_paillier_init,
+	pkey_paillier_init,	/* init */
-	pkey_paillier_copy,
+	pkey_paillier_copy,	/* copy */
-	pkey_paillier_cleanup,
+	pkey_paillier_cleanup,	/* cleanup */
-
+	NULL,			/* paramgen_init */
-	0, 0,
+	NULL,			/* paramgen */
-
+	NULL,			/* keygen_init */
-	0,
+	pkey_paillier_keygen,	/* keygen */
-	pkey_paillier_keygen,
+	NULL,			/* sign_init */
-
+	NULL,			/* sign */
-	0, 0,
+	NULL,			/* verify_init */
-	0, 0,
+	NULL,			/* verify */
-	0, 0,
+	NULL,			/* verify_recover_init */
-	0, 0, 0, 0,
+	NULL,			/* verify_recover */
-
+	NULL,			/* signctx_init */
-	0,
+	NULL,			/* signctx */
-	pkey_paillier_encrypt,
+	NULL,			/* verifyctx_init */
-	0,
+	NULL,			/* verifyctx */
-	pkey_paillier_decrypt,
+	NULL,			/* encrypt_init */
-
+	pkey_paillier_encrypt,	/* encrypt */
-	0, 0,
+	NULL,			/* decrypt_init */
-
+	pkey_paillier_decrypt,	/* decrypt */
-	pkey_paillier_ctrl,
+	NULL,			/* derive_init */
-	pkey_paillier_ctrl_str
+	NULL,			/* derive */
+	pkey_paillier_ctrl,	/* ctrl */
+	pkey_paillier_ctrl_str	/* ctrl_str */
 };
-

crypto/skf/skf_meth.c

@@ -128,7 +128,6 @@ SKF_METHOD *SKF_METHOD_load_library(const char *so_path)
 	SKF_METHOD_BIND_FUNCTION(ECCExportSessionKey);
 	SKF_METHOD_BIND_FUNCTION(ExtECCEncrypt);
 	SKF_METHOD_BIND_FUNCTION(ExtECCDecrypt);
-	SKF_METHOD_BIND_FUNCTION(ECCDecrypt);
 	SKF_METHOD_BIND_FUNCTION(ExtECCSign);
 	SKF_METHOD_BIND_FUNCTION(ExtECCVerify);
 	SKF_METHOD_BIND_FUNCTION(GenerateAgreementDataWithECC);
@@ -154,6 +153,11 @@ SKF_METHOD *SKF_METHOD_load_library(const char *so_path)
 	SKF_METHOD_BIND_FUNCTION(MacFinal);
 	SKF_METHOD_BIND_FUNCTION(CloseHandle);
 
+#ifdef SKF_SUPPORT_ECCDECRYPT
+	/* wisectech usb-key support ECCDecrypt */
+	SKF_METHOD_BIND_FUNCTION(ECCDecrypt);
+#endif
+
 	ret = skf;
 	skf = NULL;
 

crypto/sm9/build.info

@@ -1,4 +1,4 @@
 LIBS=../../libcrypto
 SOURCE[../../libcrypto]=sm9_lib.c sm9_err.c sm9_asn1.c sm9_params.c \
 	sm9_setup.c sm9_keygen.c sm9_sign.c sm9_enc.c sm9_exch.c sm9_rate.c \
-	sm9_ameth.c
+	sm9_pmeth.c sm9_ameth.c

crypto/sm9/sm9_ameth.c

@@ -68,10 +68,6 @@ static int sm9_params_encode(X509_PUBKEY *pubkey, const EVP_PKEY *pkey)
 	if ((penclen = i2d_SM9PublicParameters(pkey->pkey.sm9_master, &penc)) <= 0) {
 		return 0;
 	}
-	printf("penclen = %d\n", penclen);
-	printf("penc == NULL: %d\n", penc == NULL);
-	printf("%lu\n", OBJ_nid2obj(EVP_PKEY_SM9_MASTER));
-
 	OPENSSL_assert(pubkey);
 
 	if (X509_PUBKEY_set0_param(pubkey, OBJ_nid2obj(EVP_PKEY_SM9_MASTER),
@@ -152,7 +148,6 @@ static int sm9_master_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
 {
 	unsigned char *rk = NULL;
 	int rklen;
-fprintf(stderr, "%s %d: %s\n", __FILE__, __LINE__, __FUNCTION__);
 
 	if ((rklen = i2d_SM9MasterSecret(pkey->pkey.sm9_master, &rk)) <= 0) {
 		SM9err(SM9_F_SM9_MASTER_ENCODE, ERR_R_MALLOC_FAILURE);
@@ -207,7 +202,6 @@ static int old_sm9_master_decode(EVP_PKEY *pkey,
 
 static int old_sm9_master_encode(const EVP_PKEY *pkey, unsigned char **pder)
 {
-fprintf(stderr, "%s %d: %s\n", __FILE__, __LINE__, __FUNCTION__);
 	return i2d_SM9MasterSecret(pkey->pkey.sm9_master, pder);
 }
 
@@ -216,7 +210,7 @@ const EVP_PKEY_ASN1_METHOD sm9_master_asn1_meth = {
 	EVP_PKEY_SM9_MASTER,	/* pkey_base_id */
 	0,			/* pkey_flags */
 	"SM9 MASTER",		/* pem_str */
-	"GmSSL SM9 algorithm",	/* info */
+	"GmSSL SM9 system algorithm", /* info */
 	sm9_params_decode,	/* pub_decode */
 	sm9_params_encode,	/* pub_encode */
 	sm9_params_cmp,		/* pub_cmp */
@@ -242,7 +236,6 @@ const EVP_PKEY_ASN1_METHOD sm9_master_asn1_meth = {
 	NULL,			/* item_sign */
 };
 
-
 static int sm9_pub_encode(X509_PUBKEY *pubkey, const EVP_PKEY *pkey)
 {
 	unsigned char *penc = NULL;
@@ -332,11 +325,6 @@ static int sm9_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
 	unsigned char *rk = NULL;
 	int rklen;
 
-/*
-fprintf(stderr, "%s %d: %s\n", __FILE__, __LINE__, __FUNCTION__);
-fprintf(stderr, "%s %s: %d\n", __FILE__, __LINE__, pkey->pkey.sm9->privatePoint != NULL);
-*/
-
 	if ((rklen = i2d_SM9PrivateKey(pkey->pkey.sm9, &rk)) <= 0) {
 		SM9err(SM9_F_SM9_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
 		return 0;
@@ -375,7 +363,6 @@ static int old_sm9_priv_decode(EVP_PKEY *pkey,
 
 static int old_sm9_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
 {
-fprintf(stderr, "%s %d: %s\n", __FILE__, __LINE__, __FUNCTION__);
 	return i2d_SM9PrivateKey(pkey->pkey.sm9, pder);
 }
 

crypto/sm9/sm9_err.c

@@ -21,22 +21,26 @@
 static ERR_STRING_DATA SM9_str_functs[] = {
     {ERR_FUNC(SM9_F_OLD_SM9_MASTER_DECODE), "old_sm9_master_decode"},
     {ERR_FUNC(SM9_F_OLD_SM9_PRIV_DECODE), "old_sm9_priv_decode"},
-    {ERR_FUNC(SM9_F_SM9CIPHERTEXT_CHECK), "SM9Ciphertext_check"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_COPY), "pkey_sm9_copy"},
-    {ERR_FUNC(SM9_F_SM9ENCPARAMETERS_DECRYPT), "SM9EncParameters_decrypt"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_CTRL), "pkey_sm9_ctrl"},
-    {ERR_FUNC(SM9_F_SM9ENCPARAMETERS_ENCRYPT), "SM9EncParameters_encrypt"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_CTRL_STR), "pkey_sm9_ctrl_str"},
-    {ERR_FUNC(SM9_F_SM9ENCPARAMETERS_GENERATE_MAC),
+    {ERR_FUNC(SM9_F_PKEY_SM9_DECRYPT), "pkey_sm9_decrypt"},
-     "SM9EncParameters_generate_mac"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_ENCRYPT), "pkey_sm9_encrypt"},
-    {ERR_FUNC(SM9_F_SM9ENCPARAMETERS_GET_KEY_LENGTH),
+    {ERR_FUNC(SM9_F_PKEY_SM9_INIT), "pkey_sm9_init"},
-     "SM9EncParameters_get_key_length"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_KEYGEN), "pkey_sm9_keygen"},
-    {ERR_FUNC(SM9_F_SM9PUBLICPARAMETERS_GET_POINT_SIZE),
+    {ERR_FUNC(SM9_F_PKEY_SM9_MASTER_COPY), "pkey_sm9_master_copy"},
-     "SM9PublicParameters_get_point_size"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_MASTER_CTRL), "pkey_sm9_master_ctrl"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_MASTER_CTRL_STR), "pkey_sm9_master_ctrl_str"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_MASTER_ENCRYPT), "pkey_sm9_master_encrypt"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_MASTER_INIT), "pkey_sm9_master_init"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_MASTER_KEYGEN), "pkey_sm9_master_keygen"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_MASTER_VERIFY), "pkey_sm9_master_verify"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_SIGN), "pkey_sm9_sign"},
+    {ERR_FUNC(SM9_F_PKEY_SM9_VERIFY), "pkey_sm9_verify"},
     {ERR_FUNC(SM9_F_SM9_COMPUTE_SHARE_KEY_A), "SM9_compute_share_key_A"},
     {ERR_FUNC(SM9_F_SM9_COMPUTE_SHARE_KEY_B), "SM9_compute_share_key_B"},
     {ERR_FUNC(SM9_F_SM9_DECRYPT), "SM9_decrypt"},
-    {ERR_FUNC(SM9_F_SM9_DO_DECRYPT), "SM9_do_decrypt"},
-    {ERR_FUNC(SM9_F_SM9_DO_ENCRYPT), "SM9_do_encrypt"},
     {ERR_FUNC(SM9_F_SM9_ENCRYPT), "SM9_encrypt"},
-    {ERR_FUNC(SM9_F_SM9_EXTRACT_PRIVATE_KEY), "SM9_extract_private_key"},
     {ERR_FUNC(SM9_F_SM9_EXTRACT_PUBLIC_PARAMETERS),
      "SM9_extract_public_parameters"},
     {ERR_FUNC(SM9_F_SM9_GENERATE_KEY_EXCHANGE), "SM9_generate_key_exchange"},
@@ -64,38 +68,36 @@ static ERR_STRING_DATA SM9_str_functs[] = {
 };
 
 static ERR_STRING_DATA SM9_str_reasons[] = {
-    {ERR_REASON(SM9_R_BUFFER_TOO_SMALL), "buffer too small"},
     {ERR_REASON(SM9_R_DECODE_ERROR), "decode error"},
     {ERR_REASON(SM9_R_DIGEST_FAILURE), "digest failure"},
     {ERR_REASON(SM9_R_EC_LIB), "ec lib"},
     {ERR_REASON(SM9_R_EXTENSION_FIELD_ERROR), "extension field error"},
-    {ERR_REASON(SM9_R_GENERATE_MAC_FAILURE), "generate mac failure"},
+    {ERR_REASON(SM9_R_IDENTITY_REQUIRED), "identity required"},
-    {ERR_REASON(SM9_R_HASH_FAILURE), "hash failure"},
+    {ERR_REASON(SM9_R_ID_OR_MASTER_SECRET_REQUIRED),
-    {ERR_REASON(SM9_R_INVALID_CIPHERTEXT), "invalid ciphertext"},
+     "id or master secret required"},
     {ERR_REASON(SM9_R_INVALID_DIGEST_TYPE), "invalid digest type"},
-    {ERR_REASON(SM9_R_INVALID_ENCPARAMETERS), "invalid encparameters"},
+    {ERR_REASON(SM9_R_INVALID_ENCRYPT_SCHEME), "invalid encrypt scheme"},
     {ERR_REASON(SM9_R_INVALID_HASH1), "invalid hash1"},
     {ERR_REASON(SM9_R_INVALID_HASH2_DIGEST), "invalid hash2 digest"},
     {ERR_REASON(SM9_R_INVALID_ID), "invalid id"},
-    {ERR_REASON(SM9_R_INVALID_ID_LENGTH), "invalid id length"},
-    {ERR_REASON(SM9_R_INVALID_INPUT), "invalid input"},
     {ERR_REASON(SM9_R_INVALID_KEM_KEY_LENGTH), "invalid kem key length"},
     {ERR_REASON(SM9_R_INVALID_KEY_AGREEMENT_CHECKSUM),
      "invalid key agreement checksum"},
-    {ERR_REASON(SM9_R_INVALID_KEY_LENGTH), "invalid key length"},
+    {ERR_REASON(SM9_R_INVALID_KEY_USAGE), "invalid key usage"},
-    {ERR_REASON(SM9_R_INVALID_MD), "invalid md"},
+    {ERR_REASON(SM9_R_INVALID_PAIRING), "invalid pairing"},
     {ERR_REASON(SM9_R_INVALID_PAIRING_TYPE), "invalid pairing type"},
-    {ERR_REASON(SM9_R_INVALID_PARAMETER), "invalid parameter"},
     {ERR_REASON(SM9_R_INVALID_POINTPPUB), "invalid pointppub"},
     {ERR_REASON(SM9_R_INVALID_PRIVATE_POINT), "invalid private point"},
     {ERR_REASON(SM9_R_INVALID_SCHEME), "invalid scheme"},
     {ERR_REASON(SM9_R_INVALID_SIGNATURE), "invalid signature"},
     {ERR_REASON(SM9_R_INVALID_SIGNATURE_FORMAT), "invalid signature format"},
-    {ERR_REASON(SM9_R_INVALID_TYPE1CURVE), "invalid type1curve"},
+    {ERR_REASON(SM9_R_INVALID_SIGN_MD), "invalid sign md"},
-    {ERR_REASON(SM9_R_KDF_FAILURE), "kdf failure"},
+    {ERR_REASON(SM9_R_INVALID_SIGN_SCHEME), "invalid sign scheme"},
+    {ERR_REASON(SM9_R_INVALID_SM9_SCHEME), "invalid sm9 scheme"},
     {ERR_REASON(SM9_R_NO_MASTER_SECRET), "no master secret"},
     {ERR_REASON(SM9_R_PAIRING_ERROR), "pairing error"},
     {ERR_REASON(SM9_R_RATE_PAIRING_ERROR), "rate pairing error"},
+    {ERR_REASON(SM9_R_SIGNER_ID_REQUIRED), "signer id required"},
     {ERR_REASON(SM9_R_TWIST_CURVE_ERROR), "twist curve error"},
     {ERR_REASON(SM9_R_VERIFY_FAILURE), "verify failure"},
     {ERR_REASON(SM9_R_ZERO_ID), "zero id"},

crypto/sm9/sm9_lcl.h

@@ -181,6 +181,11 @@ void point_cleanup(point_t *P);
 
 int rate_pairing(fp12_t r, const point_t *Q, const EC_POINT *P, BN_CTX *ctx);
 
+int sm9_check_pairing(int nid);
+int sm9_check_scheme(int nid);
+int sm9_check_hash1(int nid);
+int sm9_check_encrypt_scheme(int nid);
+int sm9_check_sign_scheme(int nid);
 
 #ifdef __cplusplus
 }

crypto/sm9/sm9_lib.c

@@ -173,3 +173,28 @@ int SM9_KEY_up_ref(SM9_KEY *sk)
 	REF_ASSERT_ISNT(i < 2);
 	return ((i > 1) ? 1 : 0);
 }
+
+int sm9_check_pairing(int nid)
+{
+	return 1;
+}
+
+int sm9_check_scheme(int nid)
+{
+	return 1;
+}
+
+int sm9_check_hash1(int nid)
+{
+	return 1;
+}
+
+int sm9_check_encrypt_scheme(int nid)
+{
+	return 1;
+}
+
+int sm9_check_sign_scheme(int nid)
+{
+	return 1;
+}

crypto/sm9/sm9_pmeth.c

@@ -0,0 +1,510 @@
+/* ====================================================================
+ * Copyright (c) 2015 - 2018 The GmSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the GmSSL Project.
+ *    (http://gmssl.org/)"
+ *
+ * 4. The name "GmSSL Project" must not be used to endorse or promote
+ *    products derived from this software without prior written
+ *    permission. For written permission, please contact
+ *    guanzhi1980@gmail.com.
+ *
+ * 5. Products derived from this software may not be called "GmSSL"
+ *    nor may "GmSSL" appear in their names without prior written
+ *    permission of the GmSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the GmSSL Project
+ *    (http://gmssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE GmSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ */
+
+#include <stdio.h>
+#include <openssl/sm9.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
+#include <openssl/asn1t.h>
+#include <openssl/objects.h>
+#include "internal/cryptlib.h"
+#include "internal/asn1_int.h"
+#include "internal/evp_int.h"
+#include "sm9_lcl.h"
+
+typedef struct {
+	int pairing; /* NID_sm9bn256v1 */
+	int scheme; /* NID_sm9[sign|encrypt|keyagreement] */
+	int hash1; /* NID_sm9hash1_with_[sm3|sha256] */
+	int sign_scheme; /* NID_sm9sign_with_[sm3|sha256] */
+	int encrypt_scheme; /*NID_sm9encrypt */
+	char *id;
+} SM9_MASTER_PKEY_CTX;
+
+static int pkey_sm9_master_init(EVP_PKEY_CTX *ctx)
+{
+	SM9_MASTER_PKEY_CTX *dctx;
+	if (!(dctx = OPENSSL_zalloc(sizeof(*dctx)))) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_INIT, ERR_R_MALLOC_FAILURE);
+		return 0;
+	}
+
+	dctx->pairing = NID_sm9bn256v1;
+	dctx->scheme = NID_sm9encrypt;
+	dctx->hash1 = NID_sm9hash1_with_sm3;
+	dctx->sign_scheme = NID_sm3;
+	dctx->encrypt_scheme = NID_sm9encrypt_with_sm3_xor;
+	dctx->id = NULL;
+
+	ctx->data = dctx;
+	return 1;
+}
+
+static int pkey_sm9_master_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
+{
+	SM9_MASTER_PKEY_CTX *dctx, *sctx;
+	if (!pkey_sm9_master_init(dst))
+		return 0;
+	sctx = src->data;
+	dctx = dst->data;
+	*dctx = *sctx;
+	if (!(dctx->id = OPENSSL_strdup(sctx->id))) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_COPY, ERR_R_MALLOC_FAILURE);
+		return 0;
+	}
+	return 1;
+}
+
+static void pkey_sm9_master_cleanup(EVP_PKEY_CTX *ctx)
+{
+	SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	if (dctx) {
+		OPENSSL_free(dctx->id);
+		OPENSSL_free(dctx);
+	}
+}
+
+static int pkey_sm9_master_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
+{
+	SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	SM9_MASTER_KEY *sm9_master;
+
+	if (!(sm9_master = SM9_generate_master_secret(dctx->pairing,
+		dctx->scheme, dctx->hash1))) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_KEYGEN, ERR_R_SM9_LIB);
+		return 0;
+	}
+	if (!EVP_PKEY_assign_SM9_MASTER(pkey, sm9_master)) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_KEYGEN, ERR_R_EVP_LIB);
+		SM9_MASTER_KEY_free(sm9_master);
+		return 0;
+	}
+	return 1;
+}
+
+static int pkey_sm9_master_verify(EVP_PKEY_CTX *ctx,
+	const unsigned char *sig, size_t siglen,
+	const unsigned char *tbs, size_t tbslen)
+{
+	int ret;
+	SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	SM9_MASTER_KEY *sm9_master = EVP_PKEY_get0_SM9_MASTER(
+		EVP_PKEY_CTX_get0_pkey(ctx));
+
+	if (OBJ_obj2nid(sm9_master->scheme) != NID_sm9sign) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_VERIFY, SM9_R_INVALID_KEY_USAGE);
+		return 0;
+	}
+	if (!dctx->id) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_VERIFY, SM9_R_SIGNER_ID_REQUIRED);
+		return 0;
+	}
+
+	if ((ret = SM9_verify(dctx->sign_scheme, tbs, tbslen, sig, siglen,
+		sm9_master, dctx->id, strlen(dctx->id))) < 0) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_VERIFY, ERR_R_SM9_LIB);
+	}
+	return ret;
+}
+
+static int pkey_sm9_master_encrypt(EVP_PKEY_CTX *ctx,
+	unsigned char *out, size_t *outlen,
+	const unsigned char *in, size_t inlen)
+{
+	SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	SM9_MASTER_KEY *sm9_master = EVP_PKEY_get0_SM9_MASTER(
+		EVP_PKEY_CTX_get0_pkey(ctx));
+
+	if (OBJ_obj2nid(sm9_master->scheme) != NID_sm9encrypt) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_ENCRYPT, SM9_R_INVALID_KEY_USAGE);
+		return 0;
+	}
+
+	if (!dctx->id) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_ENCRYPT, SM9_R_IDENTITY_REQUIRED);
+		return 0;
+	}
+
+	if (!SM9_encrypt(dctx->encrypt_scheme, in, inlen, out, outlen,
+		sm9_master, dctx->id, strlen(dctx->id))) {
+		SM9err(SM9_F_PKEY_SM9_MASTER_ENCRYPT, ERR_R_SM9_LIB);
+		return 0;
+	}
+
+	return 1;
+}
+
+static int pkey_sm9_master_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
+{
+	SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	SM9_MASTER_KEY *sm9_master = EVP_PKEY_get0_SM9_MASTER(
+		EVP_PKEY_CTX_get0_pkey(ctx));
+
+	return -2;
+}
+
+static int pkey_sm9_master_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
+{
+	SM9_MASTER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+
+	switch (type) {
+	case EVP_PKEY_CTRL_SM9_PAIRING:
+		if (p1 == -2)
+			return dctx->pairing;
+		if (!sm9_check_pairing(p1)) {
+		}
+		dctx->pairing = p1;
+		return 1;
+
+	case EVP_PKEY_CTRL_SM9_SCHEME:
+		if (p1 == -2)
+			return dctx->scheme;
+		if (!sm9_check_scheme(p1)) {
+			SM9err(SM9_F_PKEY_SM9_MASTER_CTRL, SM9_R_INVALID_SCHEME);
+			return 0;
+		}
+		dctx->scheme = p1;
+		return 1;
+
+	case EVP_PKEY_CTRL_SM9_HASH1:
+		if (p1 == -2)
+			return dctx->hash1;
+		if (!sm9_check_hash1(p1)) {
+			SM9err(SM9_F_PKEY_SM9_MASTER_CTRL, SM9_R_INVALID_HASH1);
+			return 0;
+		}
+		dctx->hash1 = p1;
+		return 1;
+
+	case EVP_PKEY_CTRL_SM9_ID:
+		if (!p2 || !strlen((char *)p2) || strlen((char *)p2) > SM9_MAX_ID_LENGTH) {
+			SM9err(SM9_F_PKEY_SM9_MASTER_CTRL, SM9_R_INVALID_ID);
+			return 0;
+		} else {
+			char *id = NULL;
+			if (!(id = OPENSSL_strdup((char *)p2))) {
+				SM9err(SM9_F_PKEY_SM9_MASTER_CTRL, ERR_R_MALLOC_FAILURE);
+			}
+			if (dctx->id) {
+				OPENSSL_free(dctx->id);
+			}
+			dctx->id = id;
+		}
+		return 1;
+
+	case EVP_PKEY_CTRL_GET_SM9_ID:
+		*(const char **)p2 = dctx->id;
+		return 1;
+	}
+
+	return -2;
+}
+
+static int pkey_sm9_master_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value)
+{
+	if (!strcmp(type, "pairing")) {
+		int nid = OBJ_txt2nid(value);
+		if (!sm9_check_pairing(nid)) {
+			SM9err(SM9_F_PKEY_SM9_MASTER_CTRL_STR, SM9_R_INVALID_PAIRING);
+			return 0;
+		}
+		return EVP_PKEY_CTX_set_sm9_pairing(ctx, nid);
+
+	} else if (!strcmp(type, "scheme")) {
+		int nid = OBJ_txt2nid(value);
+		if (!sm9_check_scheme(nid)) {
+			SM9err(SM9_F_PKEY_SM9_MASTER_CTRL_STR, SM9_R_INVALID_SM9_SCHEME);
+			return 0;
+		}
+		return EVP_PKEY_CTX_set_sm9_scheme(ctx, nid);
+
+	} else if (!strcmp(type, "hash1")) {
+		int nid = OBJ_txt2nid(value);
+		if (!sm9_check_hash1(nid)) {
+			SM9err(SM9_F_PKEY_SM9_MASTER_CTRL_STR, SM9_R_INVALID_SM9_SCHEME);
+			return 0;
+		}
+		return EVP_PKEY_CTX_set_sm9_hash1(ctx, nid);
+
+	} else if (!strcmp(type, "id")) {
+		return EVP_PKEY_CTX_set_sm9_id(ctx, value);
+	}
+
+	return -2;
+}
+
+const EVP_PKEY_METHOD sm9_master_pkey_meth = {
+	EVP_PKEY_SM9_MASTER,	/* pkey_id */
+	0,			/* flags */
+	pkey_sm9_master_init,	/* init */
+	pkey_sm9_master_copy,	/* copy */
+	pkey_sm9_master_cleanup,/* cleanup */
+	NULL,			/* paramgen_init */
+	NULL,			/* paramgen */
+	NULL,			/* keygen_init */
+	pkey_sm9_master_keygen,	/* keygen */
+	NULL,			/* sign_init */
+	NULL,			/* sign */
+	NULL,			/* verify_init */
+	pkey_sm9_master_verify,	/* verify */
+	NULL,			/* verify_recover_init */
+	NULL,			/* verify_recover */
+	NULL,			/* signctx_init */
+	NULL,			/* signctx */
+	NULL,			/* verifyctx_init */
+	NULL,			/* verifyctx */
+	NULL,			/* encrypt_init */
+	pkey_sm9_master_encrypt,/* encrypt */
+	NULL,			/* decrypt_init */
+	NULL,			/* decrypt */
+	NULL,			/* derive_init */
+	pkey_sm9_master_derive,	/* derive */
+	pkey_sm9_master_ctrl,	/* ctrl */
+	pkey_sm9_master_ctrl_str,/* ctrl_str */
+};
+
+typedef struct {
+	int sign_scheme;
+	int encrypt_scheme;
+	char *id;
+} SM9_PKEY_CTX;
+
+static int pkey_sm9_init(EVP_PKEY_CTX *ctx)
+{
+	SM9_PKEY_CTX *dctx;
+	if (!(dctx = OPENSSL_zalloc(sizeof(*dctx)))) {
+		SM9err(SM9_F_PKEY_SM9_INIT, ERR_R_MALLOC_FAILURE);
+		return 0;
+	}
+	dctx->sign_scheme = NID_sm3; // FIXME: some like NID_sm9sign_sm3 			
+	dctx->encrypt_scheme = NID_sm9encrypt_with_sm3_xor;
+	dctx->id = NULL;
+	OPENSSL_assert(EVP_PKEY_CTX_get_data(ctx) == NULL);
+	(void)EVP_PKEY_CTX_set_data(ctx, dctx);
+	return 1;
+}
+
+static int pkey_sm9_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
+{
+	SM9_PKEY_CTX *dctx, *sctx;
+	if (!pkey_sm9_init(dst)) {
+		SM9err(SM9_F_PKEY_SM9_COPY, ERR_R_SM9_LIB);
+		return 0;
+	}
+	sctx = EVP_PKEY_CTX_get_data(src);
+	dctx = EVP_PKEY_CTX_get_data(dst);
+	*dctx = *sctx;
+	if (!(dctx->id = OPENSSL_strdup(sctx->id))) {
+		return 0;
+	}
+	return 1;
+}
+
+static void pkey_sm9_cleanup(EVP_PKEY_CTX *ctx)
+{
+	SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	if (dctx) {
+		OPENSSL_free(dctx->id);
+		OPENSSL_free(dctx);
+	}
+}
+
+static int pkey_sm9_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
+{
+	/*
+	SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	SM9_KEY *sm9;
+	if (!dctx->master_secret || !dctx->id) {
+		SM9err(SM9_F_PKEY_SM9_KEYGEN, SM9_R_ID_OR_MASTER_SECRET_REQUIRED);
+		return 0;
+	}
+	if (!(sm9 = SM9_extract_private_key(dctx->master,
+		dctx->id, strlen(dctx->id)))) {
+		SM9err(SM9_F_PKEY_SM9_KEYGEN, ERR_R_SM9_LIB);
+		return 0;
+	}
+	if (EVP_PKEY_assign_SM9(pkey, sm9) <= 0) {
+		SM9err(SM9_F_PKEY_SM9_KEYGEN, ERR_R_EVP_LIB);
+		SM9_KEY_free(sm9);
+		return 0;
+	}
+	*/
+	return 1;
+}
+
+static int pkey_sm9_sign(EVP_PKEY_CTX *ctx,
+	unsigned char *sig, size_t *siglen,
+	const unsigned char *tbs, size_t tbslen)
+{
+	SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	SM9_KEY *sm9 = EVP_PKEY_get0_SM9(EVP_PKEY_CTX_get0_pkey(ctx));
+	if (!SM9_sign(dctx->sign_scheme, tbs, tbslen, sig, siglen, sm9)) {
+		SM9err(SM9_F_PKEY_SM9_SIGN, ERR_R_SM9_LIB);
+		return 0;
+	}
+	return 1;
+}
+
+static int pkey_sm9_decrypt(EVP_PKEY_CTX *ctx,
+	unsigned char *out, size_t *outlen,
+	const unsigned char *in, size_t inlen)
+{
+	SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+	SM9_KEY *sm9 = EVP_PKEY_get0_SM9(EVP_PKEY_CTX_get0_pkey(ctx));
+	if (!SM9_decrypt(dctx->encrypt_scheme, in, inlen,
+		out, outlen, sm9)) {
+		SM9err(SM9_F_PKEY_SM9_DECRYPT, ERR_R_SM9_LIB);
+		return 0;
+	}
+	return 1;
+}
+
+static int pkey_sm9_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
+{
+	return -2;
+}
+
+static int pkey_sm9_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
+{
+	SM9_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
+
+	switch (type) {
+	case EVP_PKEY_CTRL_SM9_SIGN_SCHEME:
+		if (p1 == -2)
+			return dctx->sign_scheme;
+		if (!sm9_check_sign_scheme(p1)) {
+			SM9err(SM9_F_PKEY_SM9_CTRL, SM9_R_INVALID_SIGN_SCHEME);
+			return 0;
+		}
+		dctx->sign_scheme = p1;
+		return 1;
+
+	case EVP_PKEY_CTRL_SM9_ENCRYPT_SCHEME:
+		if (p1 == -2)
+			return dctx->encrypt_scheme;
+		if (!sm9_check_encrypt_scheme(p1)) {
+			SM9err(SM9_F_PKEY_SM9_CTRL, SM9_R_INVALID_ENCRYPT_SCHEME);
+			return 0;
+		}
+		dctx->encrypt_scheme = p1;
+		return 1;
+
+	case EVP_PKEY_CTRL_SM9_ID:
+		if (!p2 || !strlen((char *)p2) || strlen((char *)p2) > SM9_MAX_ID_LENGTH) {
+			return 0;
+		} else {
+		}
+		return 1;
+
+	case EVP_PKEY_CTRL_GET_SM9_ID:
+		*(const char **)p2 = dctx->id;
+		return 1;
+
+	default:
+		return -2;
+	}
+
+	return -2;
+}
+
+static int pkey_sm9_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value)
+{
+	if (!strcmp(type, "sign_scheme")) {
+		int nid = OBJ_txt2nid(value);
+		if (!sm9_check_sign_scheme(nid)) {
+			SM9err(SM9_F_PKEY_SM9_CTRL_STR, SM9_R_INVALID_SIGN_MD);
+			return 0;
+		}
+		return EVP_PKEY_CTX_set_sm9_sign_scheme(ctx, nid);
+
+	} else if (!strcmp(type, "encrypt_scheme")) {
+		int nid = OBJ_txt2nid(value);
+		if (!sm9_check_encrypt_scheme(nid)) {
+			SM9err(SM9_F_PKEY_SM9_CTRL_STR, SM9_R_INVALID_ENCRYPT_SCHEME);
+			return 0;
+		}
+		return EVP_PKEY_CTX_set_sm9_encrypt_scheme(ctx, nid);
+
+	} else if (!strcmp(type, "id")) {
+		return EVP_PKEY_CTX_set_sm9_id(ctx, value);
+	}
+
+	return -2;
+}
+
+const EVP_PKEY_METHOD sm9_pkey_meth = {
+	EVP_PKEY_SM9,		/* pkey_id */
+	0,			/* flags */
+	pkey_sm9_init,		/* init */
+	pkey_sm9_copy,		/* copy */
+	pkey_sm9_cleanup,	/* cleanup */
+	NULL,			/* paramgen_init */
+	NULL,			/* paramgen */
+	NULL,			/* keygen_init */
+	pkey_sm9_keygen,	/* keygen */
+	NULL,			/* sign_init */
+	pkey_sm9_sign,		/* sign */
+	NULL, 			/* verify_init */
+	NULL,			/* verify */
+	NULL,			/* verify_recover_init */
+	NULL,			/* verify_recover */
+	NULL,			/* signctx_init */
+	NULL,			/* signctx */
+	NULL,			/* verifyctx_init */
+	NULL,			/* verifyctx */
+	NULL,			/* encrypt_init */
+	NULL,			/* encrypt */
+	NULL,			/* decrypt_init */
+	pkey_sm9_decrypt,	/* decrypt */
+	NULL,			/* derive_init */
+	pkey_sm9_derive,	/* derive */
+	pkey_sm9_ctrl,		/* ctrl */
+	pkey_sm9_ctrl_str,	/* ctrl_str */
+};

crypto/sm9/sm9_sign.c

@@ -61,6 +61,17 @@ int SM9_signature_size(SM9PublicParameters *mpk)
 	return 105;
 }
 
+SM9Signature *SM9_do_sign(const unsigned char *dgst, int dgstlen, SM9_KEY *sm9)
+{
+	return NULL;
+}
+
+int SM9_do_verify(const unsigned char *dgst, int dgstlen,
+	const SM9Signature *sig, SM9_KEY *sm9)
+{
+	return -1;
+}
+
 int SM9_SignInit(EVP_MD_CTX *ctx, const EVP_MD *md, ENGINE *eng)
 {
 	unsigned char prefix[1] = {0x02};

include/openssl/paillier.h

@@ -59,6 +59,9 @@
 #include <openssl/bn.h>
 #include <openssl/asn1.h>
 
+
+#define PAILLIER_MIN_KEY_BITS 2048
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -72,7 +75,7 @@ void PAILLIER_free(PAILLIER *key);
 int PAILLIER_size(const PAILLIER *key);
 int PAILLIER_security_bits(const PAILLIER *key);
 
-int PAILLIER_generate_key(PAILLIER *key, int bits);
+int PAILLIER_generate_key(PAILLIER *key, int bits/* as RSA N */);
 int PAILLIER_check_key(PAILLIER *key);
 int PAILLIER_encrypt(BIGNUM *out, const BIGNUM *in, PAILLIER *key);
 int PAILLIER_decrypt(BIGNUM *out, const BIGNUM *in, PAILLIER *key);
@@ -84,6 +87,19 @@ int PAILLIER_up_ref(PAILLIER *key);
 DECLARE_ASN1_ENCODE_FUNCTIONS_const(PAILLIER, PaillierPrivateKey)
 DECLARE_ASN1_ENCODE_FUNCTIONS_const(PAILLIER, PaillierPublicKey)
 
+
+# define EVP_PKEY_CTRL_PAILLIER_KEYGEN_BITS	(EVP_PKEY_ALG_CTRL + 1)
+
+# define EVP_PKEY_CTX_set_paillier_keygen_bits(ctx, nbits) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_PAILLIER, \
+		EVP_PKEY_OP_KEYGEN, \
+		EVP_PKEY_CTRL_PAILLIER_KEYGEN_BITS, nbits, NULL)
+
+# define EVP_PKEY_CTX_get_paillier_keygen_bits(ctx) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_PAILLIER, \
+		EVP_PKEY_OP_KEYGEN, \
+		EVP_PKEY_CTRL_PAILLIER_KEYGEN_BITS, -2, NULL)
+
 /* BEGIN ERROR CODES */
 /*
  * The following lines are auto generated by the script mkerr.pl. Any changes
@@ -106,16 +122,22 @@ int ERR_load_PAILLIER_strings(void);
 # define PAILLIER_F_PAILLIER_PRIV_DECODE                  111
 # define PAILLIER_F_PAILLIER_PRIV_ENCODE                  112
 # define PAILLIER_F_PAILLIER_PUB_DECODE                   107
+# define PAILLIER_F_PKEY_PAILLIER_CTRL                    113
+# define PAILLIER_F_PKEY_PAILLIER_CTRL_STR                114
 # define PAILLIER_F_PKEY_PAILLIER_DECRYPT                 108
 # define PAILLIER_F_PKEY_PAILLIER_ENCRYPT                 109
+# define PAILLIER_F_PKEY_PAILLIER_INIT                    115
+# define PAILLIER_F_PKEY_PAILLIER_KEYGEN                  116
 
 /* Reason codes. */
 # define PAILLIER_R_BUFFER_TOO_SMALL                      104
 # define PAILLIER_R_DECODE_ERROR                          105
 # define PAILLIER_R_GENERATE_PRIME_FAILED                 100
 # define PAILLIER_R_INVALID_PLAINTEXT                     101
+# define PAILLIER_R_KEY_SIZE_TOO_SMALL                    106
 # define PAILLIER_R_MALLOC_FAILED                         102
 # define PAILLIER_R_NOT_IMPLEMENTED                       103
+# define PAILLIER_R_VALUE_MISSING                         107
 
 #  ifdef  __cplusplus
 }

include/openssl/skf.h

@@ -155,44 +155,56 @@ typedef struct Struct_FILEATTRIBUTE {
 } FILEATTRIBUTE, *PFILEATTRIBUTE;
 #pragma pack()
 
+/* 7.1.2 */
 ULONG DEVAPI SKF_WaitForDevEvent(
 	LPSTR szDevName,
 	ULONG *pulDevNameLen,
 	ULONG *pulEvent);
 
+/* 7.1.3 */
 ULONG DEVAPI SKF_CancelWaitForDevEvent(
 	void);
 
-ULONG DEVAPI SKF_EnumDev(BOOL bPresent,
+/* 7.1.4 */
+ULONG DEVAPI SKF_EnumDev(
+	BOOL bPresent,
 	LPSTR szNameList,
 	ULONG *pulSize);
 
+/* 7.1.5 */
 ULONG DEVAPI SKF_ConnectDev(
 	LPSTR szName,
 	DEVHANDLE *phDev);
 
+/* 7.1.6 */
 ULONG DEVAPI SKF_DisConnectDev(
 	DEVHANDLE hDev);
 
+/* 7.1.7 */
 ULONG DEVAPI SKF_GetDevState(
 	LPSTR szDevName,
 	ULONG *pulDevState);
 
+/* 7.1.8 */
 ULONG DEVAPI SKF_SetLabel(
 	DEVHANDLE hDev,
 	LPSTR szLabel);
 
+/* 7.1.9 */
 ULONG DEVAPI SKF_GetDevInfo(
 	DEVHANDLE hDev,
 	DEVINFO *pDevInfo);
 
+/* 7.1.10 */
 ULONG DEVAPI SKF_LockDev(
 	DEVHANDLE hDev,
 	ULONG ulTimeOut);
 
+/* 7.1.11 */
 ULONG DEVAPI SKF_UnlockDev(
 	DEVHANDLE hDev);
 
+/* 7.1.12 */
 ULONG DEVAPI SKF_Transmit(
 	DEVHANDLE hDev,
 	BYTE *pbCommand,
@@ -200,16 +212,19 @@ ULONG DEVAPI SKF_Transmit(
 	BYTE *pbData,
 	ULONG *pulDataLen);
 
+/* 7.2.2 */
 ULONG DEVAPI SKF_ChangeDevAuthKey(
 	DEVHANDLE hDev,
 	BYTE *pbKeyValue,
 	ULONG ulKeyLen);
 
+/* 7.2.3 */
 ULONG DEVAPI SKF_DevAuth(
 	DEVHANDLE hDev,
 	BYTE *pbAuthData,
 	ULONG ulLen);
 
+/* 7.2.4 */
 ULONG DEVAPI SKF_ChangePIN(
 	HAPPLICATION hApplication,
 	ULONG ulPINType,
@@ -217,6 +232,7 @@ ULONG DEVAPI SKF_ChangePIN(
 	LPSTR szNewPin,
 	ULONG *pulRetryCount);
 
+/* 7.2.5 */
 LONG DEVAPI SKF_GetPINInfo(
 	HAPPLICATION hApplication,
 	ULONG ulPINType,
@@ -224,21 +240,25 @@ LONG DEVAPI SKF_GetPINInfo(
 	ULONG *pulRemainRetryCount,
 	BOOL *pbDefaultPin);
 
+/* 7.2.6 */
 ULONG DEVAPI SKF_VerifyPIN(
 	HAPPLICATION hApplication,
 	ULONG ulPINType,
 	LPSTR szPIN,
 	ULONG *pulRetryCount);
 
+/* 7.2.7 */
 ULONG DEVAPI SKF_UnblockPIN(
 	HAPPLICATION hApplication,
 	LPSTR szAdminPIN,
 	LPSTR szNewUserPIN,
 	ULONG *pulRetryCount);
 
+/* 7.2.8 */
 ULONG DEVAPI SKF_ClearSecureState(
 	HAPPLICATION hApplication);
 
+/* 7.3.2 */
 ULONG DEVAPI SKF_CreateApplication(
 	DEVHANDLE hDev,
 	LPSTR szAppName,
@@ -249,22 +269,28 @@ ULONG DEVAPI SKF_CreateApplication(
 	DWORD dwCreateFileRights,
 	HAPPLICATION *phApplication);
 
-ULONG DEVAPI SKF_EnumApplication(DEVHANDLE hDev,
+/* 7.3.3 */
+ULONG DEVAPI SKF_EnumApplication(
+	DEVHANDLE hDev,
 	LPSTR szAppName,
 	ULONG *pulSize);
 
+/* 7.3.4 */
 ULONG DEVAPI SKF_DeleteApplication(
 	DEVHANDLE hDev,
 	LPSTR szAppName);
 
+/* 7.3.5 */
 ULONG DEVAPI SKF_OpenApplication(
 	DEVHANDLE hDev,
 	LPSTR szAppName,
 	HAPPLICATION *phApplication);
 
+/* 7.3.6 */
 ULONG DEVAPI SKF_CloseApplication(
 	HAPPLICATION hApplication);
 
+/* 7.4.2 */
 ULONG DEVAPI SKF_CreateFile(
 	HAPPLICATION hApplication,
 	LPSTR szFileName,
@@ -272,20 +298,24 @@ ULONG DEVAPI SKF_CreateFile(
 	ULONG ulReadRights,
 	ULONG ulWriteRights);
 
+/* 7.4.3 */
 ULONG DEVAPI SKF_DeleteFile(
 	HAPPLICATION hApplication,
 	LPSTR szFileName);
 
+/* 7.4.4 */
 ULONG DEVAPI SKF_EnumFiles(
 	HAPPLICATION hApplication,
 	LPSTR szFileList,
 	ULONG *pulSize);
 
+/* 7.4.5 */
 ULONG DEVAPI SKF_GetFileInfo(
 	HAPPLICATION hApplication,
 	LPSTR szFileName,
 	FILEATTRIBUTE *pFileInfo);
 
+/* 7.4.6 */
 ULONG DEVAPI SKF_ReadFile(
 	HAPPLICATION hApplication,
 	LPSTR szFileName,
@@ -294,6 +324,7 @@ ULONG DEVAPI SKF_ReadFile(
 	BYTE *pbOutData,
 	ULONG *pulOutLen);
 
+/* 7.4.7 */
 ULONG DEVAPI SKF_WriteFile(
 	HAPPLICATION hApplication,
 	LPSTR szFileName,
@@ -301,65 +332,71 @@ ULONG DEVAPI SKF_WriteFile(
 	BYTE *pbData,
 	ULONG ulSize);
 
+/* 7.5.2 */
 ULONG DEVAPI SKF_CreateContainer(
 	HAPPLICATION hApplication,
 	LPSTR szContainerName,
 	HCONTAINER *phContainer);
 
+/* 7.5.3 */
 ULONG DEVAPI SKF_DeleteContainer(
 	HAPPLICATION hApplication,
 	LPSTR szContainerName);
 
-ULONG DEVAPI SKF_EnumContainer(
+/* 7.5.4 */
-	HAPPLICATION hApplication,
-	LPSTR szContainerName,
-	ULONG *pulSize);
-
 ULONG DEVAPI SKF_OpenContainer(
 	HAPPLICATION hApplication,
 	LPSTR szContainerName,
 	HCONTAINER *phContainer);
 
+/* 7.5.5 */
 ULONG DEVAPI SKF_CloseContainer(
 	HCONTAINER hContainer);
 
+/* 7.5.6 */
+ULONG DEVAPI SKF_EnumContainer(
+	HAPPLICATION hApplication,
+	LPSTR szContainerName,
+	ULONG *pulSize);
+
+/* 7.5.7 */
 ULONG DEVAPI SKF_GetContainerType(
 	HCONTAINER hContainer,
 	ULONG *pulContainerType);
 
+/* 7.5.8 */
 ULONG DEVAPI SKF_ImportCertificate(
 	HCONTAINER hContainer,
 	BOOL bExportSignKey,
 	BYTE *pbCert,
 	ULONG ulCertLen);
 
+/* 7.5.9 */
 ULONG DEVAPI SKF_ExportCertificate(
 	HCONTAINER hContainer,
 	BOOL bSignFlag,
 	BYTE *pbCert,
 	ULONG *pulCertLen);
 
-ULONG DEVAPI SKF_ExportPublicKey(
+/* 7.6.2 */
-	HCONTAINER hContainer,
-	BOOL bSignFlag,
-	BYTE *pbBlob,
-	ULONG *pulBlobLen);
-
 ULONG DEVAPI SKF_GenRandom(
 	DEVHANDLE hDev,
 	BYTE *pbRandom,
 	ULONG ulRandomLen);
 
-ULONG DEVAPI SKF_GenRSAKeyPair(
+/* 7.6.3 */
-	HCONTAINER hContainer,
-	ULONG ulBitsLen,
-	RSAPUBLICKEYBLOB *pBlob);
-
 ULONG DEVAPI SKF_GenExtRSAKey(
 	DEVHANDLE hDev,
 	ULONG ulBitsLen,
 	RSAPRIVATEKEYBLOB *pBlob);
 
+/* 7.6.4 */
+ULONG DEVAPI SKF_GenRSAKeyPair(
+	HCONTAINER hContainer,
+	ULONG ulBitsLen,
+	RSAPUBLICKEYBLOB *pBlob);
+
+/* 7.6.5 */
 ULONG DEVAPI SKF_ImportRSAKeyPair(
 	HCONTAINER hContainer,
 	ULONG ulSymAlgId,
@@ -368,6 +405,7 @@ ULONG DEVAPI SKF_ImportRSAKeyPair(
 	BYTE *pbEncryptedData,
 	ULONG ulEncryptedDataLen);
 
+/* 7.6.6 */
 ULONG DEVAPI SKF_RSASignData(
 	HCONTAINER hContainer,
 	BYTE *pbData,
@@ -375,6 +413,7 @@ ULONG DEVAPI SKF_RSASignData(
 	BYTE *pbSignature,
 	ULONG *pulSignLen);
 
+/* 7.6.7 */
 ULONG DEVAPI SKF_RSAVerify(
 	DEVHANDLE hDev,
 	RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
@@ -383,6 +422,7 @@ ULONG DEVAPI SKF_RSAVerify(
 	BYTE *pbSignature,
 	ULONG ulSignLen);
 
+/* 7.6.8 */
 ULONG DEVAPI SKF_RSAExportSessionKey(
 	HCONTAINER hContainer,
 	ULONG ulAlgId,
@@ -391,6 +431,7 @@ ULONG DEVAPI SKF_RSAExportSessionKey(
 	ULONG *pulDataLen,
 	HANDLE *phSessionKey);
 
+/* 7.6.9 */
 ULONG DEVAPI SKF_ExtRSAPubKeyOperation(
 	DEVHANDLE hDev,
 	RSAPUBLICKEYBLOB *pRSAPubKeyBlob,
@@ -399,6 +440,7 @@ ULONG DEVAPI SKF_ExtRSAPubKeyOperation(
 	BYTE *pbOutput,
 	ULONG *pulOutputLen);
 
+/* 7.6.10 */
 ULONG DEVAPI SKF_ExtRSAPriKeyOperation(
 	DEVHANDLE hDev,
 	RSAPRIVATEKEYBLOB *pRSAPriKeyBlob,
@@ -407,28 +449,32 @@ ULONG DEVAPI SKF_ExtRSAPriKeyOperation(
 	BYTE *pbOutput,
 	ULONG *pulOutputLen);
 
+/* 7.6.11 */
 ULONG DEVAPI SKF_GenECCKeyPair(
 	HCONTAINER hContainer,
 	ULONG ulAlgId,
 	ECCPUBLICKEYBLOB *pBlob);
 
+/* 7.6.12 */
 ULONG DEVAPI SKF_ImportECCKeyPair(
 	HCONTAINER hContainer,
 	ENVELOPEDKEYBLOB *pEnvelopedKeyBlob);
 
+/* 7.6.13 */
 ULONG DEVAPI SKF_ECCSignData(
 	HCONTAINER hContainer,
 	BYTE *pbDigest,
 	ULONG ulDigestLen,
 	ECCSIGNATUREBLOB *pSignature);
 
-/* Extension */
+/* Extension */				
 ULONG DEVAPI SKF_ECCDecrypt(
 	HCONTAINER hContainer,
 	ECCCIPHERBLOB *pCipherBlob,
 	BYTE *pbPlainText,
 	ULONG *pulPlainTextLen);
 
+/* 7.6.14 */
 ULONG DEVAPI SKF_ECCVerify(
 	DEVHANDLE hDev,
 	ECCPUBLICKEYBLOB *pECCPubKeyBlob,
@@ -436,6 +482,7 @@ ULONG DEVAPI SKF_ECCVerify(
 	ULONG ulDataLen,
 	ECCSIGNATUREBLOB *pSignature);
 
+/* 7.6.15 */
 ULONG DEVAPI SKF_ECCExportSessionKey(
 	HCONTAINER hContainer,
 	ULONG ulAlgId,
@@ -443,6 +490,7 @@ ULONG DEVAPI SKF_ECCExportSessionKey(
 	ECCCIPHERBLOB *pData,
 	HANDLE *phSessionKey);
 
+/* 7.6.16 */
 ULONG DEVAPI SKF_ExtECCEncrypt(
 	DEVHANDLE hDev,
 	ECCPUBLICKEYBLOB *pECCPubKeyBlob,
@@ -450,6 +498,7 @@ ULONG DEVAPI SKF_ExtECCEncrypt(
 	ULONG ulPlainTextLen,
 	ECCCIPHERBLOB *pCipherText);
 
+/* 7.6.17 */
 ULONG DEVAPI SKF_ExtECCDecrypt(
 	DEVHANDLE hDev,
 	ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
@@ -457,6 +506,7 @@ ULONG DEVAPI SKF_ExtECCDecrypt(
 	BYTE *pbPlainText,
 	ULONG *pulPlainTextLen);
 
+/* 7.6.18 */
 ULONG DEVAPI SKF_ExtECCSign(
 	DEVHANDLE hDev,
 	ECCPRIVATEKEYBLOB *pECCPriKeyBlob,
@@ -464,6 +514,7 @@ ULONG DEVAPI SKF_ExtECCSign(
 	ULONG ulDataLen,
 	ECCSIGNATUREBLOB *pSignature);
 
+/* 7.6.19 */
 ULONG DEVAPI SKF_ExtECCVerify(
 	DEVHANDLE hDev,
 	ECCPUBLICKEYBLOB *pECCPubKeyBlob,
@@ -471,6 +522,7 @@ ULONG DEVAPI SKF_ExtECCVerify(
 	ULONG ulDataLen,
 	ECCSIGNATUREBLOB *pSignature);
 
+/* 7.6.20 */
 ULONG DEVAPI SKF_GenerateAgreementDataWithECC(
 	HCONTAINER hContainer,
 	ULONG ulAlgId,
@@ -479,6 +531,7 @@ ULONG DEVAPI SKF_GenerateAgreementDataWithECC(
 	ULONG ulIDLen,
 	HANDLE *phAgreementHandle);
 
+/* 7.6.21 */
 ULONG DEVAPI SKF_GenerateAgreementDataAndKeyWithECC(
 	HANDLE hContainer,
 	ULONG ulAlgId,
@@ -491,6 +544,7 @@ ULONG DEVAPI SKF_GenerateAgreementDataAndKeyWithECC(
 	ULONG ulSponsorIDLen,
 	HANDLE *phKeyHandle);
 
+/* 7.6.22 */
 ULONG DEVAPI SKF_GenerateKeyWithECC(
 	HANDLE hAgreementHandle,
 	ECCPUBLICKEYBLOB *pECCPubKeyBlob,
@@ -499,6 +553,14 @@ ULONG DEVAPI SKF_GenerateKeyWithECC(
 	ULONG ulIDLen,
 	HANDLE *phKeyHandle);
 
+/* 7.6.23 */
+ULONG DEVAPI SKF_ExportPublicKey(
+	HCONTAINER hContainer,
+	BOOL bSignFlag,
+	BYTE *pbBlob,
+	ULONG *pulBlobLen);
+
+/* 7.6.24 */
 ULONG DEVAPI SKF_ImportSessionKey(
 	HCONTAINER hContainer,
 	ULONG ulAlgId,
@@ -506,16 +568,19 @@ ULONG DEVAPI SKF_ImportSessionKey(
 	ULONG ulWrapedLen,
 	HANDLE *phKey);
 
+/* 7.6.25 */
 ULONG DEVAPI SKF_SetSymmKey(
 	DEVHANDLE hDev,
 	BYTE *pbKey,
 	ULONG ulAlgID,
 	HANDLE *phKey);
 
+/* 7.6.26 */
 ULONG DEVAPI SKF_EncryptInit(
 	HANDLE hKey,
 	BLOCKCIPHERPARAM EncryptParam);
 
+/* 7.6.27 */
 ULONG DEVAPI SKF_Encrypt(
 	HANDLE hKey,
 	BYTE *pbData,
@@ -523,6 +588,7 @@ ULONG DEVAPI SKF_Encrypt(
 	BYTE *pbEncryptedData,
 	ULONG *pulEncryptedLen);
 
+/* 7.6.28 */
 ULONG DEVAPI SKF_EncryptUpdate(
 	HANDLE hKey,
 	BYTE *pbData,
@@ -530,15 +596,18 @@ ULONG DEVAPI SKF_EncryptUpdate(
 	BYTE *pbEncryptedData,
 	ULONG *pulEncryptedLen);
 
+/* 7.6.29 */
 ULONG DEVAPI SKF_EncryptFinal(
 	HANDLE hKey,
 	BYTE *pbEncryptedData,
 	ULONG *pulEncryptedDataLen);
 
+/* 7.6.30 */
 ULONG DEVAPI SKF_DecryptInit(
 	HANDLE hKey,
 	BLOCKCIPHERPARAM DecryptParam);
 
+/* 7.6.31 */
 ULONG DEVAPI SKF_Decrypt(
 	HANDLE hKey,
 	BYTE *pbEncryptedData,
@@ -546,6 +615,7 @@ ULONG DEVAPI SKF_Decrypt(
 	BYTE *pbData,
 	ULONG *pulDataLen);
 
+/* 7.6.32 */
 ULONG DEVAPI SKF_DecryptUpdate(
 	HANDLE hKey,
 	BYTE *pbEncryptedData,
@@ -553,11 +623,13 @@ ULONG DEVAPI SKF_DecryptUpdate(
 	BYTE *pbData,
 	ULONG *pulDataLen);
 
+/* 7.6.33 */
 ULONG DEVAPI SKF_DecryptFinal(
 	HANDLE hKey,
 	BYTE *pbDecryptedData,
 	ULONG *pulDecryptedDataLen);
 
+/* 7.6.34 */
 ULONG DEVAPI SKF_DigestInit(
 	DEVHANDLE hDev,
 	ULONG ulAlgID,
@@ -566,6 +638,7 @@ ULONG DEVAPI SKF_DigestInit(
 	ULONG ulIDLen,
 	HANDLE *phHash);
 
+/* 7.6.35 */
 ULONG DEVAPI SKF_Digest(
 	HANDLE hHash,
 	BYTE *pbData,
@@ -573,21 +646,25 @@ ULONG DEVAPI SKF_Digest(
 	BYTE *pbHashData,
 	ULONG *pulHashLen);
 
+/* 7.6.36 */
 ULONG DEVAPI SKF_DigestUpdate(
 	HANDLE hHash,
 	BYTE *pbData,
 	ULONG ulDataLen);
 
+/* 7.6.37 */
 ULONG DEVAPI SKF_DigestFinal(
 	HANDLE hHash,
 	BYTE *pHashData,
 	ULONG *pulHashLen);
 
+/* 7.6.38 */
 ULONG DEVAPI SKF_MacInit(
 	HANDLE hKey,
 	BLOCKCIPHERPARAM *pMacParam,
 	HANDLE *phMac);
 
+/* 7.6.39 */
 ULONG DEVAPI SKF_Mac(
 	HANDLE hMac,
 	BYTE *pbData,
@@ -595,16 +672,19 @@ ULONG DEVAPI SKF_Mac(
 	BYTE *pbMacData,
 	ULONG *pulMacLen);
 
+/* 7.6.40 */
 ULONG DEVAPI SKF_MacUpdate(
 	HANDLE hMac,
 	BYTE *pbData,
 	ULONG ulDataLen);
 
+/* 7.6.41 */
 ULONG DEVAPI SKF_MacFinal(
 	HANDLE hMac,
 	BYTE *pbMacData,
 	ULONG *pulMacDataLen);
 
+/* 7.6.42 */
 ULONG DEVAPI SKF_CloseHandle(
 	HANDLE hHandle);
 

include/openssl/sm9.h

@@ -106,6 +106,10 @@ int SM9PublicKey_get_gmtls_encoded(SM9PublicParameters *mpk,
 
 int SM9_signature_size(SM9PublicParameters *mpk);
 
+SM9Signature *SM9_do_sign(const unsigned char *dgst, int dgstlen, SM9_KEY *sm9);
+int SM9_do_verify(const unsigned char *dgst, int dgstlen,
+	const SM9Signature *sig, SM9_KEY *sm9);
+
 int SM9_sign(int type,
 	const unsigned char *data, size_t datalen,
 	unsigned char *sig, size_t *siglen,
@@ -174,18 +178,15 @@ int SM9_compute_share_key_B(int type,
 
 
 #ifndef OPENSSL_NO_STDIO
-
 SM9MasterSecret *d2i_SM9MasterSecret_fp(FILE *fp, SM9MasterSecret **pp);
 SM9PublicParameters *d2i_SM9PublicParameters_fp(FILE *fp, SM9PublicParameters **pp);
 SM9PrivateKey *d2i_SM9PrivateKey_fp(FILE *fp, SM9PrivateKey **pp);
-SM9PublicKey *d2i_SM9PublicKey_fp(FILE *fp, SM9PublicKey **pp);
 SM9Signature *d2i_SM9Signature_fp(FILE *fp, SM9Signature **pp);
 SM9Ciphertext *d2i_SM9Ciphertext_fp(FILE *fp, SM9Ciphertext **pp);
 
 int i2d_SM9MasterSecret_fp(FILE *fp, SM9MasterSecret *a);
-int i2d_PublicParameters_fp(FILE *fp, SM9PublicParameters *a);
+int i2d_SM9PublicParameters_fp(FILE *fp, SM9PublicParameters *a);
 int i2d_SM9PrivateKey_fp(FILE *fp, SM9PrivateKey *a);
-int i2d_SM9PublicKey_fp(FILE *fp, SM9PublicKey *a);
 int i2d_SM9Signature_fp(FILE *fp, SM9Signature *a);
 int i2d_SM9Ciphertext_fp(FILE *fp, SM9Ciphertext *a);
 #endif
@@ -209,7 +210,72 @@ DECLARE_ASN1_FUNCTIONS(SM9Ciphertext)
 #define SM9PublicKey_new() SM9_KEY_new()
 #define SM9PublicKey_free(a) SM9_KEY_free(a)
 
+# define EVP_PKEY_CTRL_SM9_PAIRING		(EVP_PKEY_ALG_CTRL + 1)
+# define EVP_PKEY_CTRL_SM9_SCHEME		(EVP_PKEY_ALG_CTRL + 2)
+# define EVP_PKEY_CTRL_SM9_HASH1		(EVP_PKEY_ALG_CTRL + 3)
+# define EVP_PKEY_CTRL_SM9_SIGN_SCHEME		(EVP_PKEY_ALG_CTRL + 4)
+# define EVP_PKEY_CTRL_SM9_ENCRYPT_SCHEME	(EVP_PKEY_ALG_CTRL + 5)
+# define EVP_PKEY_CTRL_SM9_ID			(EVP_PKEY_ALG_CTRL + 6)
+# define EVP_PKEY_CTRL_GET_SM9_ID		(EVP_PKEY_ALG_CTRL + 7)
 
+# define EVP_PKEY_CTX_set_sm9_pairing(ctx, nid) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_KEYGEN, \
+		EVP_PKEY_CTRL_SM9_PAIRING, nid, NULL)
+
+# define EVP_PKEY_CTX_get_sm9_pairing(ctx) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_KEYGEN, \
+		EVP_PKEY_CTRL_SM9_PAIRING, -2, NULL)
+
+# define EVP_PKEY_CTX_set_sm9_scheme(ctx, nid) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_KEYGEN, \
+		EVP_PKEY_CTRL_SM9_SCHEME, nid, NULL)
+
+# define EVP_PKEY_CTX_get_sm9_scheme(ctx) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_KEYGEN, \
+		EVP_PKEY_CTRL_SM9_SCHEME, -2, NULL)
+
+# define EVP_PKEY_CTX_set_sm9_hash1(ctx, nid) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_KEYGEN, EVP_PKEY_CTRL_SM9_HASH1, nid, NULL)
+
+# define EVP_PKEY_CTX_get_sm9_hash1(ctx) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_KEYGEN, EVP_PKEY_CTRL_SM9_HASH1, -2, NULL)
+
+# define EVP_PKEY_CTX_set_sm9_encrypt_scheme(ctx, nid) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_ENCRYPT, \
+		EVP_PKEY_CTRL_SM9_ENCRYPT_SCHEME, nid, NULL)
+
+# define EVP_PKEY_CTX_set_sm9_decrypt_scheme(ctx, nid) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9, \
+		EVP_PKEY_OP_DECRYPT|EVP_PKEY_OP_ENCRYPT, \
+		EVP_PKEY_CTRL_SM9_ENCRYPT_SCHEME, nid, NULL)
+
+# define EVP_PKEY_CTX_set_sm9_sign_scheme(ctx, nid) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9, \
+		EVP_PKEY_OP_SIGN|EVP_PKEY_OP_SIGNCTX| \
+		EVP_PKEY_OP_VERIFY|EVP_PKEY_OP_VERIFYCTX, \
+		EVP_PKEY_CTRL_SM9_SIGN_SCHEME, nid, NULL)
+
+# define EVP_PKEY_CTX_set_sm9_verify_scheme(ctx, nid) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_VERIFY|EVP_PKEY_OP_VERIFYCTX, \
+		EVP_PKEY_CTRL_SM9_SIGN_SCHEME, nid, NULL)
+
+# define EVP_PKEY_CTX_set_sm9_id(ctx, id) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_KEYGEN, \
+		EVP_PKEY_CTRL_SM9_ID, 0, (void *)id)
+
+# define EVP_PKEY_CTX_get_sm9_id(ctx, pid) \
+	EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_SM9_MASTER, \
+		EVP_PKEY_OP_KEYGEN, \
+		EVP_PKEY_CTRL_GET_SM9_ID, 0, (void *)pid)
 
 /* BEGIN ERROR CODES */
 /*
@@ -222,77 +288,81 @@ int ERR_load_SM9_strings(void);
 /* Error codes for the SM9 functions. */
 
 /* Function codes. */
-# define SM9_F_OLD_SM9_MASTER_DECODE                      124
+# define SM9_F_OLD_SM9_MASTER_DECODE                      100
-# define SM9_F_OLD_SM9_PRIV_DECODE                        125
+# define SM9_F_OLD_SM9_PRIV_DECODE                        101
-# define SM9_F_SM9CIPHERTEXT_CHECK                        100
+# define SM9_F_PKEY_SM9_COPY                              102
-# define SM9_F_SM9ENCPARAMETERS_DECRYPT                   101
+# define SM9_F_PKEY_SM9_CTRL                              103
-# define SM9_F_SM9ENCPARAMETERS_ENCRYPT                   102
+# define SM9_F_PKEY_SM9_CTRL_STR                          104
-# define SM9_F_SM9ENCPARAMETERS_GENERATE_MAC              103
+# define SM9_F_PKEY_SM9_DECRYPT                           105
-# define SM9_F_SM9ENCPARAMETERS_GET_KEY_LENGTH            104
+# define SM9_F_PKEY_SM9_ENCRYPT                           106
-# define SM9_F_SM9PUBLICPARAMETERS_GET_POINT_SIZE         105
+# define SM9_F_PKEY_SM9_INIT                              107
-# define SM9_F_SM9_COMPUTE_SHARE_KEY_A                    122
+# define SM9_F_PKEY_SM9_KEYGEN                            108
-# define SM9_F_SM9_COMPUTE_SHARE_KEY_B                    123
+# define SM9_F_PKEY_SM9_MASTER_COPY                       109
-# define SM9_F_SM9_DECRYPT                                106
+# define SM9_F_PKEY_SM9_MASTER_CTRL                       110
-# define SM9_F_SM9_DO_DECRYPT                             107
+# define SM9_F_PKEY_SM9_MASTER_CTRL_STR                   111
-# define SM9_F_SM9_DO_ENCRYPT                             108
+# define SM9_F_PKEY_SM9_MASTER_ENCRYPT                    112
-# define SM9_F_SM9_ENCRYPT                                109
+# define SM9_F_PKEY_SM9_MASTER_INIT                       113
-# define SM9_F_SM9_EXTRACT_PRIVATE_KEY                    110
+# define SM9_F_PKEY_SM9_MASTER_KEYGEN                     114
-# define SM9_F_SM9_EXTRACT_PUBLIC_PARAMETERS              111
+# define SM9_F_PKEY_SM9_MASTER_VERIFY                     115
-# define SM9_F_SM9_GENERATE_KEY_EXCHANGE                  121
+# define SM9_F_PKEY_SM9_SIGN                              116
-# define SM9_F_SM9_GENERATE_MASTER_SECRET                 112
+# define SM9_F_PKEY_SM9_VERIFY                            117
-# define SM9_F_SM9_KEY_NEW                                132
+# define SM9_F_SM9_COMPUTE_SHARE_KEY_A                    118
+# define SM9_F_SM9_COMPUTE_SHARE_KEY_B                    119
+# define SM9_F_SM9_DECRYPT                                120
+# define SM9_F_SM9_ENCRYPT                                121
+# define SM9_F_SM9_EXTRACT_PUBLIC_PARAMETERS              122
+# define SM9_F_SM9_GENERATE_KEY_EXCHANGE                  123
+# define SM9_F_SM9_GENERATE_MASTER_SECRET                 124
+# define SM9_F_SM9_KEY_NEW                                125
 # define SM9_F_SM9_MASTER_DECODE                          126
 # define SM9_F_SM9_MASTER_ENCODE                          127
-# define SM9_F_SM9_MASTER_KEY_EXTRACT_KEY                 134
+# define SM9_F_SM9_MASTER_KEY_EXTRACT_KEY                 128
-# define SM9_F_SM9_MASTER_KEY_NEW                         133
+# define SM9_F_SM9_MASTER_KEY_NEW                         129
-# define SM9_F_SM9_PARAMS_DECODE                          128
+# define SM9_F_SM9_PARAMS_DECODE                          130
-# define SM9_F_SM9_PRIV_DECODE                            129
+# define SM9_F_SM9_PRIV_DECODE                            131
-# define SM9_F_SM9_PRIV_ENCODE                            130
+# define SM9_F_SM9_PRIV_ENCODE                            132
-# define SM9_F_SM9_PUB_DECODE                             131
+# define SM9_F_SM9_PUB_DECODE                             133
-# define SM9_F_SM9_SIGN                                   119
+# define SM9_F_SM9_SIGN                                   134
-# define SM9_F_SM9_SIGNFINAL                              115
+# define SM9_F_SM9_SIGNFINAL                              135
-# define SM9_F_SM9_SIGNINIT                               116
+# define SM9_F_SM9_SIGNINIT                               136
-# define SM9_F_SM9_UNWRAP_KEY                             113
+# define SM9_F_SM9_UNWRAP_KEY                             137
-# define SM9_F_SM9_VERIFY                                 120
+# define SM9_F_SM9_VERIFY                                 138
-# define SM9_F_SM9_VERIFYFINAL                            117
+# define SM9_F_SM9_VERIFYFINAL                            139
-# define SM9_F_SM9_VERIFYINIT                             118
+# define SM9_F_SM9_VERIFYINIT                             140
-# define SM9_F_SM9_WRAP_KEY                               114
+# define SM9_F_SM9_WRAP_KEY                               141
 
 /* Reason codes. */
-# define SM9_R_BUFFER_TOO_SMALL                           100
+# define SM9_R_DECODE_ERROR                               100
-# define SM9_R_DECODE_ERROR                               132
+# define SM9_R_DIGEST_FAILURE                             101
-# define SM9_R_DIGEST_FAILURE                             119
+# define SM9_R_EC_LIB                                     102
-# define SM9_R_EC_LIB                                     101
+# define SM9_R_EXTENSION_FIELD_ERROR                      103
-# define SM9_R_EXTENSION_FIELD_ERROR                      120
+# define SM9_R_IDENTITY_REQUIRED                          104
-# define SM9_R_GENERATE_MAC_FAILURE                       102
+# define SM9_R_ID_OR_MASTER_SECRET_REQUIRED               105
-# define SM9_R_HASH_FAILURE                               103
+# define SM9_R_INVALID_DIGEST_TYPE                        106
-# define SM9_R_INVALID_CIPHERTEXT                         104
+# define SM9_R_INVALID_ENCRYPT_SCHEME                     107
-# define SM9_R_INVALID_DIGEST_TYPE                        130
+# define SM9_R_INVALID_HASH1                              108
-# define SM9_R_INVALID_ENCPARAMETERS                      105
+# define SM9_R_INVALID_HASH2_DIGEST                       109
-# define SM9_R_INVALID_HASH1                              106
+# define SM9_R_INVALID_ID                                 110
-# define SM9_R_INVALID_HASH2_DIGEST                       126
+# define SM9_R_INVALID_KEM_KEY_LENGTH                     111
-# define SM9_R_INVALID_ID                                 107
+# define SM9_R_INVALID_KEY_AGREEMENT_CHECKSUM             112
-# define SM9_R_INVALID_ID_LENGTH                          108
+# define SM9_R_INVALID_KEY_USAGE                          113
-# define SM9_R_INVALID_INPUT                              109
+# define SM9_R_INVALID_PAIRING                            114
-# define SM9_R_INVALID_KEM_KEY_LENGTH                     128
+# define SM9_R_INVALID_PAIRING_TYPE                       115
-# define SM9_R_INVALID_KEY_AGREEMENT_CHECKSUM             131
+# define SM9_R_INVALID_POINTPPUB                          116
-# define SM9_R_INVALID_KEY_LENGTH                         110
+# define SM9_R_INVALID_PRIVATE_POINT                      117
-# define SM9_R_INVALID_MD                                 111
+# define SM9_R_INVALID_SCHEME                             118
-# define SM9_R_INVALID_PAIRING_TYPE                       112
+# define SM9_R_INVALID_SIGNATURE                          119
-# define SM9_R_INVALID_PARAMETER                          113
+# define SM9_R_INVALID_SIGNATURE_FORMAT                   120
-# define SM9_R_INVALID_POINTPPUB                          121
+# define SM9_R_INVALID_SIGN_MD                            121
-# define SM9_R_INVALID_PRIVATE_POINT                      122
+# define SM9_R_INVALID_SIGN_SCHEME                        122
-# define SM9_R_INVALID_SCHEME                             114
+# define SM9_R_INVALID_SM9_SCHEME                         123
-# define SM9_R_INVALID_SIGNATURE                          123
+# define SM9_R_NO_MASTER_SECRET                           124
-# define SM9_R_INVALID_SIGNATURE_FORMAT                   127
+# define SM9_R_PAIRING_ERROR                              125
-# define SM9_R_INVALID_TYPE1CURVE                         115
+# define SM9_R_RATE_PAIRING_ERROR                         126
-# define SM9_R_KDF_FAILURE                                116
+# define SM9_R_SIGNER_ID_REQUIRED                         127
-# define SM9_R_NO_MASTER_SECRET                           133
+# define SM9_R_TWIST_CURVE_ERROR                          128
-# define SM9_R_PAIRING_ERROR                              124
+# define SM9_R_VERIFY_FAILURE                             129
-# define SM9_R_RATE_PAIRING_ERROR                         129
+# define SM9_R_ZERO_ID                                    130
-# define SM9_R_TWIST_CURVE_ERROR                          117
-# define SM9_R_VERIFY_FAILURE                             125
-# define SM9_R_ZERO_ID                                    118
 
 #  ifdef  __cplusplus
 }