x509_key all tests passed

include/gmssl/asn1.h

@@ -298,8 +298,13 @@ int asn1_header_to_der(int tag, size_t dlen, uint8_t **out, size_t *outlen);
 
 #define asn1_explicit_header_to_der(i,dlen,out,outlen) asn1_header_to_der(ASN1_TAG_EXPLICIT(i),dlen,out,outlen)
 
+#if 0 // TODO: why nonempty ?
 #define asn1_explicit_to_der(i,d,dlen,out,outlen) asn1_nonempty_type_to_der(ASN1_TAG_EXPLICIT(i),d,dlen,out,outlen)
 #define asn1_explicit_from_der(i,d,dlen,in,inlen) asn1_nonempty_type_from_der(ASN1_TAG_EXPLICIT(i),d,dlen,in,inlen)
+#else
+#define asn1_explicit_to_der(i,d,dlen,out,outlen) asn1_type_to_der(ASN1_TAG_EXPLICIT(i),d,dlen,out,outlen)
+#define asn1_explicit_from_der(i,d,dlen,in,inlen) asn1_type_from_der(ASN1_TAG_EXPLICIT(i),d,dlen,in,inlen)
+#endif
 
 // d,dlen is the V (of TLV) of SEQUENCE OF, SET OF
 int asn1_types_get_count(const uint8_t *d, size_t dlen, int tag, size_t *cnt);

include/gmssl/ec.h

@@ -18,6 +18,8 @@
 #include <gmssl/sm2.h>
 #include <gmssl/oid.h>
 #include <gmssl/asn1.h>
+#include <gmssl/x509_key.h>
+
 
 #ifdef __cplusplus
 extern "C" {
@@ -50,6 +52,12 @@ ECPrivateKey ::= SEQUENCE {
 	publicKey	[1] EXPLICIT BIT STRING OPTIONAL -- ECPoint
 }
 */
+// ECPrivateKey when key->algor == OID_ec_public_key
+int ec_private_key_to_der(const X509_KEY *key, int encode_params, int encode_pubkey, uint8_t **out, size_t *outlen);
+int ec_private_key_from_der(X509_KEY *key, int opt_curve, const uint8_t **in, size_t *inlen);
+int ec_private_key_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *d, size_t dlen); // from <gmssl/ec.h>
+// X509_KEY lost some information of ECPrivateKey. so no ec_private_key_print_ex(X509_KEY)
+
 
 enum {
 	EC_private_key_version = 1,

include/gmssl/kyber.h

@@ -118,6 +118,9 @@ void kyber_poly_decode1(kyber_poly_t r, const uint8_t in[32]);
 int  kyber_poly_encode1(const kyber_poly_t a, uint8_t out[32]);
 
 
+// kyber-512 : 2 * 384 + 32 = 800
+// kyber-768 : 3 * 384 + 32 = 1184
+// kyber-1024: 4 * 384 + 32 = 1568
 typedef struct {
 	uint8_t t[KYBER_K][384];
 	uint8_t rho[32];

include/gmssl/oid.h

@@ -179,6 +179,7 @@ enum {
 	OID_xmss_hashsig,
 	OID_xmssmt_hashsig,
 	OID_sphincs_hashsig, // OID not defined in RFC, so no oid[]
+	OID_kyber_kem,
 };
 
 // {iso(1) org(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7)}
@@ -198,6 +199,8 @@ enum {
 // {iso(1) member-body(2) us(840) ansi-x962(10045)}
 #define oid_x9_62	1,2,840,10045
 
+// {joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) nistAlgorithms(4)}
+#define oid_nist_algs	2,16,840,1,101,3,4
 
 
 #define oid_at	2,5,4

include/gmssl/sm2.h

@@ -191,6 +191,7 @@ int sm2_sign_update(SM2_SIGN_CTX *ctx, const uint8_t *data, size_t datalen);
 int sm2_sign_finish(SM2_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen);
 int sm2_sign_reset(SM2_SIGN_CTX *ctx);
 int sm2_sign_finish_fixlen(SM2_SIGN_CTX *ctx, size_t siglen, uint8_t *sig);
+// TODO sign_ctx_cleanup!
 
 typedef struct {
 	SM3_CTX sm3_ctx;

include/gmssl/x509_key.h

@@ -19,11 +19,12 @@
 #include <gmssl/oid.h>
 #include <gmssl/asn1.h>
 #include <gmssl/sm2.h>
+#include <gmssl/secp256r1_key.h>
 #include <gmssl/ecdsa.h>
 #include <gmssl/lms.h>
 #include <gmssl/xmss.h>
 #include <gmssl/sphincs.h>
-#include <gmssl/secp256r1_key.h>
+#include <gmssl/kyber.h>
 
 
 #ifdef __cplusplus
@@ -36,28 +37,24 @@ typedef struct {
 	int algor_param;
 	union {
 		SM2_KEY sm2_key;
+		SECP256R1_KEY secp256r1_key;
 		LMS_KEY lms_key;
 		HSS_KEY hss_key;
 		XMSS_KEY xmss_key;
 		XMSSMT_KEY xmssmt_key;
 		SPHINCS_KEY sphincs_key;
-		SECP256R1_KEY secp256r1_key;
+		KYBER_KEY kyber_key;
 	} u;
-	const char *signer_id;
-	size_t signer_idlen;
 } X509_KEY;
 
 int x509_key_set_sm2_key(X509_KEY *x509_key, const SM2_KEY *sm2_key);
+int x509_key_set_secp256r1_key(X509_KEY *x509_key, const SECP256R1_KEY *secp256r1_key);
 int x509_key_set_lms_key(X509_KEY *x509_key, const LMS_KEY *lms_key);
 int x509_key_set_hss_key(X509_KEY *x509_key, const HSS_KEY *hss_key);
 int x509_key_set_xmss_key(X509_KEY *x509_key, const XMSS_KEY *xmss_key);
 int x509_key_set_xmssmt_key(X509_KEY *x509_key, const XMSSMT_KEY *xmssmt_key);
 int x509_key_set_sphincs_key(X509_KEY *x509_key, const SPHINCS_KEY *sphincs_key);
-int x509_key_set_secp256r1_key(X509_KEY *x509_key, const SECP256R1_KEY *secp256r1_key);
+int x509_key_set_kyber_key(X509_KEY *x509_key, const KYBER_KEY *kyber_key);
-
-// hss_key_generate need lms_types[] as input, encode lms_types[] into (int)algor_param
-int x509_algor_param_from_lms_types(int *algor_param, const int *lms_types, size_t num);
-int x509_algor_param_to_lms_types(int algor_param, int lms_types[5], size_t *num);
 
 /*
    algor:			algor_param:
@@ -69,45 +66,61 @@ int x509_algor_param_to_lms_types(int algor_param, int lms_types[5], size_t *num
    OID_xmsssmt_hashsig		xmssmt_type
    OID_sphincs_hashsig		OID_undef
 */
-int x509_key_generate(X509_KEY *key, int algor, int algor_param);
+int x509_key_generate(X509_KEY *key, int algor, const void *param, size_t paramlen);
-int x509_private_key_from_file(X509_KEY *key, int algor, const char *pass, FILE *fp);
 void x509_key_cleanup(X509_KEY *key);
 
-
+/*
-// SM2_PUBLIC_KEY_SIZE = 65
+  x509_public_key_to_bytes() outlen
-// LMS_PUBLIC_KEY_SIZE = 56
+    ecPublicKey: 65
-// HSS_PUBLIC_KEY_SIZE = 60
+    lms-hashsig: 56
-// XMSS_PUBLIC_KEY_SIZE = 68
+    hss-lms-hashsig: 60
-// XMSSMT_PUBLIC_KEY_SIZE = 68
+    xmss-hashsig: 68
-// SPHINCS_PUBLIC_KEY_SIZE = 32
+    xmssmt-hashsig: 68
-// SECP256R1_PUBLIC_KEY_SIZE = 65
+    sphincs-hashsig: 32
-#define X509_PUBLIC_KEY_MAX_SIZE 68
+    kyber-kem: 800/1184/1568 for kyber 512/768/1024
+*/
+#define X509_PUBLIC_KEY_MAX_SIZE 1184
 int x509_public_key_to_bytes(const X509_KEY *key, uint8_t **out, size_t *outlen);
+int x509_public_key_from_bytes(X509_KEY *key, int algor, int algor_param, const uint8_t **in, size_t *inlen);
 int x509_public_key_digest(const X509_KEY *key, uint8_t dgst[32]);
 int x509_public_key_equ(const X509_KEY *key, const X509_KEY *pub);
 int x509_public_key_print(FILE *fp, int fmt, int ind, const char *label, const X509_KEY *key);
-int x509_private_key_print(FILE *fp, int fmt, int ind, const char *label, const X509_KEY *key);
+int x509_private_key_print_ex(FILE *fp, int fmt, int ind, const char *label, const X509_KEY *key);
 
-// X.509 SubjectPublicKeyInfo
+/*
+  X.509 SubjectPublicKeyInfo
+
+  x509_public_key_info_to_der() outlen
+    ecPublicKey: 91
+    lms-hashsig: 79
+    hss-lms-hashsig: 82
+    xmss-hashsig: 87
+    xmssmt-hashsig: 87
+    sphincs-hashsig: 52
+    kyber-kem:
+*/
+#define X509_PUBLIC_KEY_INFO_MAX_SIZE 1280 // for kyber and 91 for others
 int x509_public_key_info_to_der(const X509_KEY *key, uint8_t **out, size_t *outlen);
 int x509_public_key_info_from_der(X509_KEY *key, const uint8_t **in, size_t *inlen);
 int x509_public_key_info_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *d, size_t dlen);
 
+
 // ECPrivateKey when key->algor == OID_ec_public_key
 int ec_private_key_to_der(const X509_KEY *key, int encode_params, int encode_pubkey, uint8_t **out, size_t *outlen);
 int ec_private_key_from_der(X509_KEY *key, int opt_curve, const uint8_t **in, size_t *inlen);
+int ec_private_key_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *d, size_t dlen); // from <gmssl/ec.h>
+// X509_KEY lost some information of ECPrivateKey. so no ec_private_key_print_ex(X509_KEY)
 
-// 没有打印的函数！
 
 // PKCS #8 PrivateKeyInfo
 // PrivateKeyInfo.algor.parameters has the named_curve
 // so omit the optional ECPrivateKey params(named_curve) a nd omit the public_key
-#define X509_ENCODE_EC_PRIVATE_KEY_PARAMS 1
+#define X509_ENCODE_EC_PRIVATE_KEY_PARAMS 0
 #define X509_ENCODE_EC_PRIVATE_KEY_PUBKEY 1
 int x509_private_key_info_to_der(const X509_KEY *key, uint8_t **out, size_t *outlen);
 int x509_private_key_info_from_der(X509_KEY *key, const uint8_t **attrs, size_t *attrslen,
 	const uint8_t **in, size_t *inlen);
-// 没有打印的函数
+// TODO: no x509_private_key_info_print
 
 // PKCS #8 EncryptedPrivateKeyInfo
 #define PKCS8_ENCED_PRIVATE_KEY_INFO_ITER 65536
@@ -117,9 +130,6 @@ int x509_private_key_info_decrypt_from_der(X509_KEY *x509_key,
 	const uint8_t **attrs, size_t *attrs_len,
 	const char *pass, const uint8_t **in, size_t *inlen);
 
-// require stdio
-int x509_private_key_info_encrypt_to_pem(const X509_KEY *key, const char *pass, FILE *fp);
-int x509_private_key_info_decrypt_from_pem(X509_KEY *key, const uint8_t **attrs, size_t *attrslen, const char *pass, FILE *fp);
 
 
 // SM2_SIGNATURE_MAX_SIZE = 72
@@ -147,15 +157,17 @@ typedef struct {
 	union {
 		SM2_SIGN_CTX sm2_sign_ctx;
 		SM2_VERIFY_CTX sm2_verify_ctx;
+		ECDSA_SIGN_CTX ecdsa_sign_ctx;
+		LMS_SIGN_CTX lms_sign_ctx;
 		HSS_SIGN_CTX hss_sign_ctx;
 		XMSS_SIGN_CTX xmss_sign_ctx;
 		XMSSMT_SIGN_CTX xmssmt_sign_ctx;
 		SPHINCS_SIGN_CTX sphincs_sign_ctx;
-		ECDSA_SIGN_CTX ecdsa_sign_ctx;
 	} u;
 	int sign_algor;
 	uint8_t sig[X509_SIGNATURE_MAX_SIZE];
 	size_t siglen;
+	size_t fixed_siglen;
 } X509_SIGN_CTX;
 
 
@@ -176,20 +188,50 @@ int x509_key_get_signature_size(const X509_KEY *key, size_t *siglen);
 //	sm2	SM2_DEFAULT_ID, SM2_DEFAULT_ID_LENGTH
 //		TLS13_SM2_ID, TLS13_SM2_ID_LENGTH
 //	sphincs	optiona_random, 16
+
+
+/*
+  x509_sign_init argumetns
+
+    x509_key->algor:algor_param	    ctx->sign_algor       args         argslen
+    ------------------------------------------------------------------------------------------------
+    OID_ec_public_key:OID_sm2       OID_sm2sign_with_sm3  char *id     idlen
+                                                          NULL         0    use SM2_DEFAULT_ID
+    OID_ec_public_key:OID_secp256r1 OID_ecdsa_with_sha256 NULL         0
+    OID_lms_hashsig:OID_undef       OID_lms_hashsig       NULL         0
+    OID_hss_lms_hashsig:OID_undef   OID_hss_lms_hashsig   NULL         0
+    OID_xmss_hashsig:OID_undef      OID_xmss_hashsig      NULL         0
+    OID_xmssmt_hashsig:OID_undef    OID_xmssmt_hashsig    NULL         0
+    OID_sphincs_hashsig:OID_undef   OID_sphincs_hashsig   u8 rand[16]  16   randomized signature
+                                                          NULL         0    deterministic signature
+*/
 int x509_sign_init(X509_SIGN_CTX *ctx, X509_KEY *key, const void *args, size_t argslen);
+int x509_sign_set_signature_size(X509_SIGN_CTX *ctx, size_t siglen);
 int x509_sign_update(X509_SIGN_CTX *ctx, const uint8_t *data, size_t datalen);
 int x509_sign_finish(X509_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen);
+int x509_sign(X509_SIGN_CTX *ctx, const uint8_t *data, size_t datalen, uint8_t *sig, size_t *siglen);
 int x509_verify_init(X509_SIGN_CTX *ctx, const X509_KEY *key, const void *args, size_t argslen,
 	const uint8_t *sig, size_t siglen);
 int x509_verify_update(X509_SIGN_CTX *ctx, const uint8_t *data, size_t datalen);
 int x509_verify_finish(X509_SIGN_CTX *ctx);
+int x509_verify(X509_SIGN_CTX *ctx, const uint8_t *data, size_t datalen);
 void x509_sign_ctx_cleanup(X509_SIGN_CTX *ctx);
 
-
 // ECDH for key->algor == OID_ec_public_key
 int x509_key_do_exchange(const X509_KEY *key, const X509_KEY *peer_pub, uint8_t *out, size_t *outlen);
 int x509_key_exchange(const X509_KEY *key, const uint8_t *peer_pub, size_t peer_publen, uint8_t *out, size_t *outlen);
 
+// KEM
+#define X509_KEM_CIPHERTEXT_SIZE sizeof(KYBER_CIPHERTEXT)
+int x509_key_encapsulate(const X509_KEY *key, uint8_t *ciphertext, size_t *ciphertext_len, uint8_t secret[32]);
+int x509_key_decapsulate(const X509_KEY *key, const uint8_t *ciphertext, size_t ciphertext_len, uint8_t secret[32]);
+
+
+// require stdio
+int x509_private_key_info_encrypt_to_pem(const X509_KEY *key, const char *pass, FILE *fp);
+int x509_private_key_info_decrypt_from_pem(X509_KEY *key, const uint8_t **attrs, size_t *attrslen, const char *pass, FILE *fp);
+int x509_private_key_from_file(X509_KEY *key, int algor, const char *pass, FILE *fp);
+
 
 #ifdef __cplusplus
 }

include/gmssl/xmss.h

@@ -270,7 +270,9 @@ typedef struct {
 
 int xmss_sign_init(XMSS_SIGN_CTX *ctx, XMSS_KEY *key);
 int xmss_sign_update(XMSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen);
+int xmss_sign_finish_ex(XMSS_SIGN_CTX *ctx, XMSS_SIGNATURE *sig);
 int xmss_sign_finish(XMSS_SIGN_CTX *ctx, uint8_t *sigbuf, size_t *siglen);
+int xmss_verify_init_ex(XMSS_SIGN_CTX *ctx, const XMSS_KEY *key, const XMSS_SIGNATURE *sig);
 int xmss_verify_init(XMSS_SIGN_CTX *ctx, const XMSS_KEY *key, const uint8_t *sigbuf, size_t siglen);
 int xmss_verify_update(XMSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen);
 int xmss_verify_finish(XMSS_SIGN_CTX *ctx);

src/secp256r1.c

@@ -502,23 +502,26 @@ void secp256r1_point_sub(SECP256R1_POINT *R, const SECP256R1_POINT *P, const SEC
 
 void secp256r1_point_mul(SECP256R1_POINT *R, const secp256r1_t k, const SECP256R1_POINT *P)
 {
+	SECP256R1_POINT T;
 	uint32_t bits;
 	int nbits;
 	int i;
 
-	secp256r1_point_set_infinity(R);
+	secp256r1_point_set_infinity(&T);
 
 	for (i = 7; i >= 0; i--) {
 		bits = k[i];
 		nbits = 32;
 		while (nbits-- > 0) {
-			secp256r1_point_dbl(R, R);
+			secp256r1_point_dbl(&T, &T);
 			if (bits & 0x80000000) {
-				secp256r1_point_add(R, R, P);
+				secp256r1_point_add(&T, &T, P);
 			}
 			bits <<= 1;
 		}
 	}
+
+	secp256r1_point_copy(R, &T);
 }
 
 void secp256r1_point_mul_generator(SECP256R1_POINT *R, const secp256r1_t k)

src/sm2_sign.c

@@ -567,8 +567,6 @@ int sm2_sign_finish(SM2_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen)
 
 	sm3_finish(&ctx->sm3_ctx, dgst);
 
-	format_bytes(stderr, 0, 4, "signed dgst", dgst, 32);
-
 	if (ctx->num_pre_comp == 0) {
 		if (sm2_fast_sign_pre_compute(ctx->pre_comp) != 1) {
 			error_print();
@@ -672,8 +670,6 @@ int sm2_verify_finish(SM2_VERIFY_CTX *ctx, const uint8_t *sigbuf, size_t siglen)
 
 	sm3_finish(&ctx->sm3_ctx, dgst);
 
-	format_bytes(stderr, 0, 4, "verify dgst", dgst, 32);
-
 	if (sm2_fast_verify(ctx->public_point_table, dgst, &sig) != 1) {
 		error_print();
 		return -1;

src/sphincs.c

@@ -1418,6 +1418,7 @@ int sphincs_signature_print(FILE *fp, int fmt, int ind, const char *label, const
 	return 1;
 }
 
+// when opt_rand is null, generate a determistic signature (without random)
 int sphincs_sign_init_ex(SPHINCS_SIGN_CTX *ctx, const SPHINCS_KEY *key, const sphincs_hash128_t opt_rand)
 {
 	if (!ctx || !key) {

src/tls12.c

@@ -781,11 +781,10 @@ int tls_send_server_key_exchange(TLS_CONNECT *conn)
 
 	tls_trace("send ServerKeyExchange\n");
 
-
 	if (conn->recordlen == 0) {
+		int curve_oid = tls_named_curve_oid(conn->ecdh_named_curve);
 		// generate server ecdh_key
-		if (x509_key_generate(&conn->ecdh_key,
+		if (x509_key_generate(&conn->ecdh_key, OID_ec_public_key, &curve_oid, sizeof(curve_oid)) != 1) {
-			OID_ec_public_key, tls_named_curve_oid(conn->ecdh_named_curve)) != 1) {
 			error_print();
 			return -1;
 		}
@@ -1371,8 +1370,8 @@ int tls_send_client_key_exchange(TLS_CONNECT *conn)
 	// 因此在接收到服务器的公钥之后，应该保存这个信息
 
 	if (conn->recordlen == 0) {
-		if (x509_key_generate(&conn->ecdh_key,
+		int curve_oid = tls_named_curve_oid(conn->ecdh_named_curve);
-			OID_ec_public_key, tls_named_curve_oid(conn->ecdh_named_curve)) != 1) {
+		if (x509_key_generate(&conn->ecdh_key, OID_ec_public_key, &curve_oid, sizeof(curve_oid)) != 1) {
 			error_print();
 			return -1;
 		}

src/x509_alg.c

@@ -279,10 +279,8 @@ static uint32_t  oid_lms_hashsig[] = { oid_pkcs,9,16,3,17,1 }; // TODO: not offi
 static uint32_t  oid_xmss_hashsig[] = { oid_alg, 34 };
 static uint32_t  oid_xmssmt_hashsig[] = { oid_alg, 35 };
 
-// joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) nistAlgorithms(4)
-#define oid_nist_algs       2,16,840,1,101,3,4
 static uint32_t oid_sphincs_hashsig[] = { oid_nist_algs,3,20 }; // TODO: sphincs+ 128s with sha256, not officially defined
-
+static uint32_t oid_kyber_kem[] = { oid_nist_algs,22,4 };
 
 /*
 from RFC 3447 Public-Key Cryptography Standards (PKCS) #1: RSA Cryptography
@@ -606,6 +604,7 @@ static const ASN1_OID_INFO x509_public_key_algors[] = {
 #ifdef ENABLE_SPHINCS
 	{ OID_sphincs_hashsig, "sphincs-hashsig", oid_sphincs_hashsig, sizeof(oid_sphincs_hashsig)/sizeof(int), 1 },
 #endif
+	{ OID_kyber_kem, "kyber-kem", oid_kyber_kem, sizeof(oid_kyber_kem)/sizeof(int), 1 },
 };
 
 static const int x509_public_key_algors_count =
@@ -631,6 +630,7 @@ int x509_public_key_algor_from_name(const char *name)
 	return info->oid;
 }
 
+// FIXME: add kyber, and use same code for LMS/XMSS/SPHINCS...
 int x509_public_key_algor_to_der(int oid, int curve_or_null, uint8_t **out, size_t *outlen)
 {
 	size_t len = 0;
@@ -714,6 +714,16 @@ int x509_public_key_algor_to_der(int oid, int curve_or_null, uint8_t **out, size
 		}
 		break;
 #endif
+	case OID_kyber_kem:
+		if (asn1_object_identifier_to_der(oid_kyber_kem, sizeof(oid_kyber_kem)/sizeof(int), NULL, &len) != 1
+			|| asn1_null_to_der(NULL, &len) != 1
+			|| asn1_sequence_header_to_der(len, out, outlen) != 1
+			|| asn1_object_identifier_to_der(oid_kyber_kem, sizeof(oid_kyber_kem)/sizeof(int), out, outlen) != 1
+			|| asn1_null_to_der(out, outlen) != 1) {
+			error_print();
+			return -1;
+		}
+		break;
 	default:
 		error_print();
 		return -1;
@@ -772,6 +782,7 @@ int x509_public_key_algor_from_der(int *oid , int *curve_or_null, const uint8_t
 	case OID_xmssmt_hashsig:
 #endif
 	case OID_sphincs_hashsig:
+	case OID_kyber_kem:
 		// for hashsigs, parmaeters is set to empty
 		if ((ret = asn1_null_from_der(&d, &dlen)) < 0
 			|| asn1_length_is_zero(dlen) != 1) {
@@ -779,7 +790,7 @@ int x509_public_key_algor_from_der(int *oid , int *curve_or_null, const uint8_t
 			return -1;
 		}
 		if (ret == 1) {
-			error_print();
+			//error_print();				
 		}
 		*curve_or_null = OID_undef;
 		break;

src/x509_cer.c

@@ -905,6 +905,7 @@ int x509_names_print(FILE *fp, int fmt, int ind, const char *label, const uint8_
 	return 1;
 }
 
+/*
 int x509_public_key_info_print(FILE *fp, int fmt, int ind, const char *label, const uint8_t *d, size_t dlen)
 {
 	const uint8_t *p = d;
@@ -937,6 +938,7 @@ err:
 	error_print();
 	return -1;
 }
+*/
 
 int x509_explicit_exts_to_der(int index, const uint8_t *d, size_t dlen, uint8_t **out, size_t *outlen)
 {
@@ -1119,6 +1121,9 @@ int x509_cert_sign_to_der(
 		error_print();
 		return -1;
 	}
+	if (sign_key->algor == OID_ec_public_key) {
+		siglen = SM2_signature_typical_size;
+	}
 
 	if (x509_tbs_cert_to_der(
 		version,
@@ -1167,9 +1172,18 @@ int x509_cert_sign_to_der(
 			sign_args = SM2_DEFAULT_ID;
 			sign_argslen = SM2_DEFAULT_ID_LENGTH;
 		}
-		if (x509_sign_init(&sign_ctx, sign_key, sign_args, sign_argslen) != 1
+		if (x509_sign_init(&sign_ctx, sign_key, sign_args, sign_argslen) != 1) {
-			|| x509_sign_update(&sign_ctx, tbs, *out - tbs) != 1
+			error_print();
-			|| x509_sign_finish(&sign_ctx, sig, &siglen) != 1) {
+			return -1;
+		}
+		if (sign_key->algor == OID_ec_public_key) {
+			if (x509_sign_set_signature_size(&sign_ctx, siglen) != 1) {
+				gmssl_secure_clear(&sign_ctx, sizeof(sign_ctx));
+				error_print();
+				return -1;
+			}
+		}
+		if (x509_sign(&sign_ctx, tbs, *out - tbs, sig, &siglen) != 1) {
 			gmssl_secure_clear(&sign_ctx, sizeof(sign_ctx));
 			error_print();
 			return -1;

src/x509_crl.c

@@ -1444,6 +1444,9 @@ int x509_crl_sign_to_der(
 		error_print();
 		return -1;
 	}
+	if (sign_key->algor == OID_ec_public_key) {
+		siglen = SM2_signature_typical_size;
+	}
 
 	if (x509_tbs_crl_to_der(version, sig_alg, issuer, issuer_len,
 			this_update, next_update, revoked_certs, revoked_certs_len,
@@ -1472,9 +1475,18 @@ int x509_crl_sign_to_der(
 			sign_args = SM2_DEFAULT_ID;
 			sign_argslen = SM2_DEFAULT_ID_LENGTH;
 		}
-		if (x509_sign_init(&sign_ctx, sign_key, sign_args, sign_argslen) != 1
+		if (x509_sign_init(&sign_ctx, sign_key, sign_args, sign_argslen) != 1) {
-			|| x509_sign_update(&sign_ctx, tbs, *out - tbs) != 1
+			error_print();
-			|| x509_sign_finish(&sign_ctx, sig, &siglen) != 1) {
+			return -1;
+		}
+		if (sign_key->algor == OID_ec_public_key) {
+			if (x509_sign_set_signature_size(&sign_ctx, siglen) != 1) {
+				gmssl_secure_clear(&sign_ctx, sizeof(sign_ctx));
+				error_print();
+				return -1;
+			}
+		}
+		if (x509_sign(&sign_ctx, tbs, *out - tbs, sig, &siglen) != 1) {
 			gmssl_secure_clear(&sign_ctx, sizeof(sign_ctx));
 			error_print();
 			return -1;

src/x509_req.c

@@ -180,6 +180,9 @@ int x509_req_sign_to_der(
 		error_print();
 		return -1;
 	}
+	if (sign_key->algor == OID_ec_public_key) {
+		siglen = SM2_signature_typical_size;
+	}
 
 	if (x509_request_info_to_der(version, subject, subject_len, subject_public_key,
 			attrs, attrs_len, NULL, &len) != 1
@@ -206,9 +209,18 @@ int x509_req_sign_to_der(
 			sign_args = SM2_DEFAULT_ID;
 			sign_argslen = SM2_DEFAULT_ID_LENGTH;
 		}
-		if (x509_sign_init(&sign_ctx, sign_key, sign_args, sign_argslen) != 1
+		if (x509_sign_init(&sign_ctx, sign_key, sign_args, sign_argslen) != 1) {
-			|| x509_sign_update(&sign_ctx, tbs, *out - tbs) != 1
+			error_print();
-			|| x509_sign_finish(&sign_ctx, sig, &siglen) != 1) {
+			return -1;
+		}
+		if (sign_key->algor == OID_ec_public_key) {
+			if (x509_sign_set_signature_size(&sign_ctx, siglen) != 1) {
+				gmssl_secure_clear(&sign_ctx, sizeof(sign_ctx));
+				error_print();
+				return -1;
+			}
+		}
+		if (x509_sign(&sign_ctx, tbs, *out - tbs, sig, &siglen) != 1) {
 			gmssl_secure_clear(&sign_ctx, sizeof(sign_ctx));
 			error_print();
 			return -1;

src/xmss.c

@@ -1204,14 +1204,16 @@ int xmss_sign_init(XMSS_SIGN_CTX *ctx, XMSS_KEY *key)
 	xmss_adrs_set_ots_address(adrs, key->index);
 	xmss_wots_derive_sk(key->secret, key->public_key.seed, adrs, ctx->xmss_sig.wots_sig);
 
+	// xmss_sig.auth_path
+	xmss_build_auth_path(key->tree, height, key->index, ctx->xmss_sig.auth_path);
+
+
 	// update key->index
 	if (xmss_key_update(key) != 1) {
 		error_print();
 		return -1;
 	}
 
-	// xmss_sig.auth_path
-	xmss_build_auth_path(key->tree, height, key->index, ctx->xmss_sig.auth_path);
 
 	// H_msg(M) := HASH256(toByte(2, 32) || r || XMSS_ROOT || toByte(idx_sig, 32) || M)
 	xmss_hash256_init(&ctx->hash256_ctx);
@@ -1235,6 +1237,30 @@ int xmss_sign_update(XMSS_SIGN_CTX *ctx, const uint8_t *data, size_t datalen)
 	return 1;
 }
 
+int xmss_sign_finish_ex(XMSS_SIGN_CTX *ctx, XMSS_SIGNATURE *sig)
+{
+	xmss_adrs_t adrs;
+	xmss_hash256_t dgst;
+
+	if (!ctx || !sig) {
+		error_print();
+		return -1;
+	}
+
+	xmss_hash256_finish(&ctx->hash256_ctx, dgst);
+
+	xmss_adrs_set_layer_address(adrs, 0);
+	xmss_adrs_set_tree_address(adrs, 0);
+	xmss_adrs_set_type(adrs, XMSS_ADRS_TYPE_OTS);
+	xmss_adrs_set_ots_address(adrs, ctx->xmss_sig.index);
+
+	xmss_wots_sign(ctx->xmss_sig.wots_sig, ctx->xmss_public_key.seed, adrs, dgst,
+		ctx->xmss_sig.wots_sig);
+
+	*sig = ctx->xmss_sig;
+	return 1;
+}
+
 // TODO: support output *siglen only
 int xmss_sign_finish(XMSS_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen)
 {
@@ -1365,8 +1391,10 @@ int xmss_verify_finish(XMSS_SIGN_CTX *ctx)
 	xmss_wots_pk_to_root(ctx->xmss_sig.wots_sig, ctx->xmss_public_key.seed, adrs, root);
 
 	// wots_root (index), auth_path => xmss_root
+	/*
 	xmss_adrs_set_type(adrs, XMSS_ADRS_TYPE_HASHTREE);
 	xmss_adrs_set_padding(adrs, 0);
+	xmss_adrs_set_key_and_mask(adrs, 0);
 	for (h = 0; h < height; h++) {
 		int right_child = index & 1;
 		index >>= 1;
@@ -1376,6 +1404,8 @@ int xmss_verify_finish(XMSS_SIGN_CTX *ctx)
 			xmss_tree_hash(ctx->xmss_sig.auth_path[h], root, ctx->xmss_public_key.seed, adrs, root);
 		else	xmss_tree_hash(root, ctx->xmss_sig.auth_path[h], ctx->xmss_public_key.seed, adrs, root);
 	}
+	*/
+	xmss_build_root(root, index, ctx->xmss_public_key.seed, adrs, ctx->xmss_sig.auth_path, height, root);
 
 	if (memcmp(root, ctx->xmss_public_key.root, 32) != 0) {
 		error_print();
@@ -2330,6 +2360,7 @@ int xmssmt_sign_finish_ex(XMSSMT_SIGN_CTX *ctx, XMSSMT_SIGNATURE *sig)
 	return 1;
 }
 
+// TODO: use ctx->xmssmt_sig				
 int xmssmt_sign_finish(XMSSMT_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen)
 {
 	XMSSMT_SIGNATURE signature;
@@ -2345,7 +2376,7 @@ int xmssmt_sign_finish(XMSSMT_SIGN_CTX *ctx, uint8_t *sig, size_t *siglen)
 	}
 
 	*siglen = 0;
-	if (xmssmt_signature_to_bytes(&ctx->xmssmt_sig, ctx->xmssmt_public_key.xmssmt_type, &sig, siglen) != 1) {
+	if (xmssmt_signature_to_bytes(&signature, ctx->xmssmt_public_key.xmssmt_type, &sig, siglen) != 1) {
 		error_print();
 		return -1;
 	}

tests/cmstest.c

@@ -367,6 +367,8 @@ static int test_cms_signer_info_sign(void)
 	const uint8_t *d;
 	size_t dlen;
 
+	int algor = OID_ec_public_key;
+	int algor_param = OID_sm2;
 	X509_KEY x509_key;
 	uint8_t serial_buf[20];
 	uint8_t name[256];
@@ -386,7 +388,7 @@ static int test_cms_signer_info_sign(void)
 	const uint8_t *unauth_attrs;
 	size_t serial_len, issuer_len, auth_attrs_len, unauth_attrs_len;
 
-	if (x509_key_generate(&x509_key, OID_ec_public_key, OID_sm2) != 1
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1
 		|| rand_bytes(serial_buf, sizeof(serial_buf)) != 1
 		|| x509_name_set(name, &namelen, sizeof(name), "CN", "Beijing", "Haidian", "PKU", "CS", "Alice") != 1
 		|| time(&not_before) == -1
@@ -456,13 +458,16 @@ static int test_cms_signer_infos(void)
 	size_t signer_infos_len = 0;
 
 	SM3_CTX sm3_ctx;
+
+	int algor = OID_ec_public_key;
+	int algor_param = OID_sm2;
 	X509_KEY x509_key;
 
 	uint8_t issuer_buf[256];
 	size_t issuer_len;
 	uint8_t serial_buf[20];
 
-	if (x509_key_generate(&x509_key, OID_ec_public_key, OID_sm2) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}
@@ -563,7 +568,7 @@ static int test_cms_signed_data(void)
 	const uint8_t *d;
 	size_t dlen;
 
-	if (x509_key_generate(&x509_key, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}
@@ -683,7 +688,7 @@ static int test_cms_recipient_info(void)
 	uint8_t out[sizeof(in)];
 	size_t outlen;
 
-	if (x509_key_generate(&x509_key, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}
@@ -795,7 +800,7 @@ int test_cms_enveloped_data(void)
 	p = certs;
 	certslen = 0;
 
-	if (x509_key_generate(&x509_key1, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key1, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}
@@ -816,7 +821,7 @@ int test_cms_enveloped_data(void)
 		return -1;
 	}
 
-	if (x509_key_generate(&x509_key2, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key2, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}
@@ -938,7 +943,7 @@ static int test_cms_key_agreement_info(void)
 	size_t idlen;
 
 	p = cert;
-	if (x509_key_generate(&x509_key, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}

tests/sphincstest.c

@@ -639,6 +639,8 @@ static int test_sphincs_sign_update(void)
 	SPHINCS_SIGN_CTX ctx;
 	SPHINCS_SIGNATURE sig;
 	uint8_t msg[100] = { 1,2,3 };
+	uint8_t sigbuf[SPHINCS_SIGNATURE_SIZE];
+	size_t siglen;
 
 	if (sphincs_key_generate(&key) != 1) {
 		error_print();
@@ -678,6 +680,51 @@ static int test_sphincs_sign_update(void)
 	}
 
 
+
+
+
+
+
+
+
+
+	// sign/verify sigbuf
+
+	if (sphincs_sign_init(&ctx, &key) != 1) {
+		error_print();
+		return -1;
+	}
+	if (sphincs_sign_prepare(&ctx, msg, sizeof(msg)) != 1) {
+		error_print();
+		return -1;
+	}
+	if (sphincs_sign_update(&ctx, msg, sizeof(msg)) != 1) {
+		error_print();
+		return -1;
+	}
+	if (sphincs_sign_finish(&ctx, sigbuf, &siglen) != 1) {
+		error_print();
+		return -1;
+	}
+
+	// verify
+
+	if (sphincs_verify_init(&ctx, &key, sigbuf, siglen) != 1) {
+		error_print();
+		return -1;
+	}
+	if (sphincs_verify_update(&ctx, msg, sizeof(msg)) != 1) {
+		error_print();
+		return -1;
+	}
+	if (sphincs_verify_finish(&ctx) != 1) {
+		error_print();
+		return -1;
+	}
+
+
+
+
 	printf("%s() ok\n", __FUNCTION__);
 	return 1;
 }

tests/x509_exttest.c

@@ -787,6 +787,8 @@ static int test_x509_cert_with_exts(void)
 	uint8_t name[256];
 	size_t namelen;
 	time_t not_before, not_after;
+	int algor = OID_ec_public_key;
+	int algor_param = OID_sm2;
 	X509_KEY x509_key;
 	uint8_t uniq_id[32];
 	uint8_t exts[512];
@@ -800,7 +802,7 @@ static int test_x509_cert_with_exts(void)
 	x509_validity_add_days(&not_after, not_before, 365);
 
 
-	if (x509_key_generate(&x509_key, OID_ec_public_key, OID_sm2) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}

tests/x509_keytest.c

@@ -15,99 +15,31 @@
 #include <gmssl/x509.h>
 #include <gmssl/rand.h>
 #include <gmssl/error.h>
+#include <gmssl/x509_alg.h>
 #include <gmssl/x509_key.h>
 
 
+int lms_types[] = {
+	LMS_HASH256_M32_H5,
+	LMS_HASH256_M32_H5,
+	LMS_HASH256_M32_H5,
+};
 
-static int test_x509_algor_param_from_lms_types(void)
+struct {
-{
+	int algor;
-	int lms_types1[] = {
+	int algor_param;
-		LMS_HASH256_M32_H5,
+} tests[] = {
-		LMS_HASH256_M32_H10,
+	{ OID_ec_public_key, OID_sm2 },
-		LMS_HASH256_M32_H15,
+	{ OID_ec_public_key, OID_secp256r1 },
-		LMS_HASH256_M32_H20,
+	{ OID_lms_hashsig, LMS_HASH256_M32_H5 },
-		LMS_HASH256_M32_H25,
+	{ OID_hss_lms_hashsig, OID_undef }, // use lms_types[]
-	};
+	{ OID_xmss_hashsig, XMSS_HASH256_10_256 },
-	int hss_algor_param1 = 624485;
+	{ OID_xmssmt_hashsig, XMSSMT_HASH256_20_4_256 },
-
+	{ OID_sphincs_hashsig, OID_undef },
-	int lms_types2[] = {
+	{ OID_kyber_kem, OID_undef },
-		LMS_HASH256_M32_H5,
+};
-		LMS_HASH256_M32_H5,
-		LMS_HASH256_M32_H5,
-	};
-	int hss_algor_param2 = 1365;
-
-	int algor_param1;
-	int algor_param2;
-	int lms_types[5];
-	size_t num;
-
-	if (x509_algor_param_from_lms_types(&algor_param1, lms_types1, sizeof(lms_types1)/sizeof(lms_types1[0])) != 1) {
-		error_print();
-		return -1;
-	}
-	if (algor_param1 != hss_algor_param1) {
-		format_print(stderr, 0, 4, "hss_algor_param: %d\n", algor_param1);
-		error_print();
-		return -1;
-	}
-	if (x509_algor_param_to_lms_types(algor_param1, lms_types, &num) != 1) {
-		error_print();
-		return -1;
-	}
-	if (num != sizeof(lms_types1)/sizeof(lms_types1[0])) {
-		error_print();
-		return -1;
-	}
-	if (memcmp(lms_types, lms_types1, sizeof(lms_types1)) != 0) {
-		error_print();
-		return -1;
-	}
-
-
-	if (x509_algor_param_from_lms_types(&algor_param2, lms_types2, sizeof(lms_types2)/sizeof(lms_types2[0])) != 1) {
-		error_print();
-		return -1;
-	}
-	if (algor_param2 != hss_algor_param2) {
-		format_print(stderr, 0, 4, "hss_algor_param: %d\n", algor_param2);
-		error_print();
-		return -1;
-	}
-	if (x509_algor_param_to_lms_types(algor_param2, lms_types, &num) != 1) {
-		error_print();
-		return -1;
-	}
-	if (num != sizeof(lms_types2)/sizeof(lms_types2[0])) {
-		error_print();
-		return -1;
-	}
-	if (memcmp(lms_types, lms_types2, sizeof(lms_types2)) != 0) {
-		error_print();
-		return -1;
-	}
-
-	printf("%s() ok\n", __FUNCTION__);
-	return 1;
-}
-
-X509_KEY x509_keys[7];
-
-
-	// 这个也要挪到外面，才能判断某个x509_key的类型
-	struct {
-		int algor;
-		int algor_param;
-	} tests[] = {
-		{ OID_ec_public_key, OID_sm2 },
-		{ OID_ec_public_key, OID_secp256r1 },
-		{ OID_lms_hashsig, LMS_HASH256_M32_H5 },
-		{ OID_hss_lms_hashsig, 1365 },
-		{ OID_xmss_hashsig, XMSS_HASH256_10_256 },
-		{ OID_xmssmt_hashsig, XMSSMT_HASH256_20_4_256 },
-		{ OID_sphincs_hashsig, OID_undef },
-	};
 
+X509_KEY x509_keys[sizeof(tests)/sizeof(tests[0])];
 
 
 static int test_x509_key_generate(void)
@@ -115,15 +47,29 @@ static int test_x509_key_generate(void)
 	size_t i;
 
 	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
-		if (x509_key_generate(&x509_keys[i], tests[i].algor, tests[i].algor_param) != 1) {
+		void *param = NULL;
+		size_t paramlen = 0;
+
+		switch (tests[i].algor) {
+		case OID_hss_lms_hashsig:
+			param = lms_types;
+			paramlen = sizeof(lms_types);
+			break;
+		case OID_sphincs_hashsig:
+		case OID_kyber_kem:
+			param = NULL;
+			paramlen = 0;
+			break;
+		default:
+			param = &tests[i].algor_param;
+			paramlen = sizeof(tests[i].algor_param);
+		}
+		if (x509_key_generate(&x509_keys[i], tests[i].algor, param, paramlen) != 1) {
 			error_print();
 			return -1;
 		}
-
+		//x509_private_key_print(stderr, 0, 4, "private_key", &x509_keys[i]);
-	// 这个也没有实现啊！
+		//x509_public_key_print(stderr, 0, 4, "private_key", &x509_keys[i]);
-	//	x509_private_key_print(stderr, 0, 4, "private_key", &x509_keys[i]);
-		x509_public_key_print(stderr, 0, 4, "private_key", &x509_keys[i]);
-
 	}
 
 	printf("%s() ok\n", __FUNCTION__);
@@ -132,31 +78,26 @@ static int test_x509_key_generate(void)
 
 static int test_x509_public_key_to_bytes(void)
 {
-	int i;
+	X509_KEY key;
-	uint8_t buf[128];
+	uint8_t buf[1568]; // kyber-1024
 	uint8_t *p;
 	size_t len;
-
 	uint8_t dgst[32];
+	int i;
 
-	X509_KEY key;
+	//format_print(stderr, 0, 4, "public_key_to_bytes size\n");
-
+	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
-	for (i = 0; i < 7; i++) {
 		p = buf;
 		len = 0;
 		if (x509_public_key_to_bytes(&x509_keys[i], &p, &len) != 1) {
 			error_print();
 			return -1;
 		}
-		format_print(stderr, 0, 4, "public_key_bytes: %zu\n", len);
+		//format_print(stderr, 0, 4, "%s: %zu\n", x509_public_key_algor_name(tests[i].algor), len);
-
 		if (x509_public_key_digest(&x509_keys[i], dgst) != 1) {
 			error_print();
 			return -1;
 		}
-		format_bytes(stderr, 0, 4, "dgst", dgst, 32);
-
-		// 居然没有public_key_from_bytes
 	}
 
 	printf("%s() ok\n", __FUNCTION__);
@@ -166,27 +107,27 @@ static int test_x509_public_key_to_bytes(void)
 static int test_x509_public_key_info_to_der(void)
 {
 	X509_KEY key;
-	uint8_t buf[50240];
+	uint8_t buf[2048];
 	int i;
 
-	for (i = 0; i < sizeof(x509_keys)/sizeof(x509_keys[0]); i++) {
+	//format_print(stderr, 0, 4, "public_key_info_to_bytes size\n");
+	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
 		const uint8_t *cp = buf;
 		uint8_t *p = buf;
 		size_t len = 0;
 
-		fprintf(stderr, "%d: algor = %d param = %d\n", i, x509_keys[i].algor, x509_keys[i].algor_param);
-
 		if (x509_public_key_info_to_der(&x509_keys[i], &p, &len) != 1) {
 			error_print();
 			return -1;
 		}
-		format_print(stderr, 0, 4, "public_key_der_size: %zu\n", len);
+		//format_print(stderr, 0, 8, "%s: %zu\n", x509_public_key_algor_name(tests[i].algor), len);
 
 		if (x509_public_key_info_from_der(&key, &cp, &len) != 1) {
 			error_print();
 			return -1;
 		}
 		if (len) {
+			fprintf(stderr, "len = %zu\n", len);
 			error_print();
 			return -1;
 		}
@@ -204,21 +145,79 @@ static int test_x509_public_key_info_to_der(void)
 static int test_ec_private_key_to_der(void)
 {
 	X509_KEY key;
-	uint8_t buf[1024];
+	uint8_t buf[512];
 	int i;
 
-	for (i = 0; i < 2; i++) {
+	for (i = 0; i < sizeof(tests)/sizeof(tests[0]) && tests[i].algor == OID_ec_public_key; i++) {
 		const uint8_t *cp = buf;
 		uint8_t *p = buf;
 		size_t len = 0;
-		// 目前底层的asn1功能不支持这两个不编码，需要仔细看看是怎么回事，explicit的编码是如何实现的
+		int encode_params;
-		int encode_params = 1; // X509_ENCODE_EC_PRIVATE_KEY_PARAMS;
+		int encode_pubkey;
-		int encode_pubkey = 1; //X509_ENCODE_EC_PRIVATE_KEY_PUBKEY;
 
+		// test 1
+		encode_params = 0;
+		encode_pubkey = 0;
 		if (ec_private_key_to_der(&x509_keys[i], encode_params, encode_pubkey, &p, &len) != 1) {
 			error_print();
 			return -1;
 		}
+		//format_print(stderr, 0, 0, "ECPrivateKey encode_params = %d, encode_pubkey = %d\n", encode_params, encode_pubkey);
+		//format_bytes(stderr, 0, 0, "ECPrivateKey", buf, len);
+		if (ec_private_key_from_der(&key, tests[i].algor_param, &cp, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		if (x509_public_key_equ(&key, &x509_keys[i]) != 1) {
+			error_print();
+			return -1;
+		}
+
+		// test 2
+		encode_params = 0;
+		encode_pubkey = 1;
+		if (ec_private_key_to_der(&x509_keys[i], encode_params, encode_pubkey, &p, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		//format_print(stderr, 0, 0, "ECPrivateKey encode_params = %d, encode_pubkey = %d\n", encode_params, encode_pubkey);
+		//format_bytes(stderr, 0, 0, "ECPrivateKey", buf, len);
+		if (ec_private_key_from_der(&key, tests[i].algor_param, &cp, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		if (x509_public_key_equ(&key, &x509_keys[i]) != 1) {
+			error_print();
+			return -1;
+		}
+
+		// test 3
+		encode_params = 1;
+		encode_pubkey = 0;
+		if (ec_private_key_to_der(&x509_keys[i], encode_params, encode_pubkey, &p, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		//format_print(stderr, 0, 0, "ECPrivateKey encode_params = %d, encode_pubkey = %d\n", encode_params, encode_pubkey);
+		//format_bytes(stderr, 0, 0, "ECPrivateKey", buf, len);
+		if (ec_private_key_from_der(&key, tests[i].algor_param, &cp, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		if (x509_public_key_equ(&key, &x509_keys[i]) != 1) {
+			error_print();
+			return -1;
+		}
+
+		// test 4
+		encode_params = 1;
+		encode_pubkey = 1;
+		if (ec_private_key_to_der(&x509_keys[i], encode_params, encode_pubkey, &p, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		//format_print(stderr, 0, 0, "ECPrivateKey encode_params = %d, encode_pubkey = %d\n", encode_params, encode_pubkey);
+		//format_bytes(stderr, 0, 0, "ECPrivateKey", buf, len);
 		if (ec_private_key_from_der(&key, tests[i].algor_param, &cp, &len) != 1) {
 			error_print();
 			return -1;
@@ -236,43 +235,36 @@ static int test_ec_private_key_to_der(void)
 static int test_x509_private_key_info_to_der(void)
 {
 	X509_KEY key;
-	uint8_t buf[1024];
+	uint8_t buf[512];
 	int i;
 
-	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
+	for (i = 0; i < sizeof(tests)/sizeof(tests[0]) && tests[i].algor == OID_ec_public_key; i++) {
-		if (tests[i].algor == OID_ec_public_key) {
+		const uint8_t *cp = buf;
-			const uint8_t *cp = buf;
+		uint8_t *p = buf;
-			uint8_t *p = buf;
+		size_t len = 0;
-			size_t len = 0;
+		const uint8_t *attrs;
-			const uint8_t *attrs;
+		size_t attrslen;
-			size_t attrslen;
 
-			if (x509_private_key_info_to_der(&x509_keys[i], &p, &len) != 1) {
+		if (x509_private_key_info_to_der(&x509_keys[i], &p, &len) != 1) {
-				error_print();
+			error_print();
-				return -1;
+			return -1;
-			}
+		}
-			if (x509_private_key_info_from_der(&key, &attrs, &attrslen, &cp, &len) != 1) {
+		if (x509_private_key_info_from_der(&key, &attrs, &attrslen, &cp, &len) != 1) {
-				error_print();
+			error_print();
-				return -1;
+			return -1;
-			}
+		}
-			if (len) {
+		if (len) {
-				error_print();
+			error_print();
-				return -1;
+			return -1;
-			}
+		}
-			if (x509_public_key_equ(&key, &x509_keys[i]) != 1) {
+		if (x509_public_key_equ(&key, &x509_keys[i]) != 1) {
-				error_print();
+			error_print();
-				return -1;
+			return -1;
-			}
 		}
 	}
 
 	printf("%s() ok\n", __FUNCTION__);
 	return 1;
-
-
-
-
-
 }
 
 static int test_x509_private_key_info_encrypt_to_der(void)
@@ -282,30 +274,28 @@ static int test_x509_private_key_info_encrypt_to_der(void)
 	uint8_t buf[1024];
 	int i;
 
-	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
+	for (i = 0; i < sizeof(tests)/sizeof(tests[0]) && tests[i].algor == OID_ec_public_key; i++) {
-		if (tests[i].algor == OID_ec_public_key) {
+		const uint8_t *cp = buf;
-			const uint8_t *cp = buf;
+		uint8_t *p = buf;
-			uint8_t *p = buf;
+		size_t len = 0;
-			size_t len = 0;
+		const uint8_t *attrs;
-			const uint8_t *attrs;
+		size_t attrslen;
-			size_t attrslen;
 
-			if (x509_private_key_info_encrypt_to_der(&x509_keys[i], pass, &p, &len) != 1) {
+		if (x509_private_key_info_encrypt_to_der(&x509_keys[i], pass, &p, &len) != 1) {
-				error_print();
+			error_print();
-				return -1;
+			return -1;
-			}
+		}
-			if (x509_private_key_info_decrypt_from_der(&key, &attrs, &attrslen, pass, &cp, &len) != 1) {
+		if (x509_private_key_info_decrypt_from_der(&key, &attrs, &attrslen, pass, &cp, &len) != 1) {
-				error_print();
+			error_print();
-				return -1;
+			return -1;
-			}
+		}
-			if (len) {
+		if (len) {
-				error_print();
+			error_print();
-				return -1;
+			return -1;
-			}
+		}
-			if (x509_public_key_equ(&key, &x509_keys[i]) != 1) {
+		if (x509_public_key_equ(&key, &x509_keys[i]) != 1) {
-				error_print();
+			error_print();
-				return -1;
+			return -1;
-			}
 		}
 	}
 
@@ -313,7 +303,6 @@ static int test_x509_private_key_info_encrypt_to_der(void)
 	return 1;
 }
 
-
 static int test_x509_private_key_info_encrypt_to_pem(void)
 {
 	const char *pass = "P@ssw0rd";
@@ -323,41 +312,186 @@ static int test_x509_private_key_info_encrypt_to_pem(void)
 	int i;
 
 
+	for (i = 0; i < sizeof(tests)/sizeof(tests[0]) && tests[i].algor == OID_ec_public_key; i++) {
+		const uint8_t *cp = buf;
+		uint8_t *p = buf;
+		size_t len = 0;
+		const uint8_t *attrs;
+		size_t attrslen;
+
+		if (!(fp = fopen("test_x509_private_key_info_encrypt_to_pem.pem", "w"))) {
+			error_print();
+			return -1;
+		}
+		if (x509_private_key_info_encrypt_to_pem(&x509_keys[i], pass, fp) != 1) {
+			error_print();
+			return -1;
+		}
+		fclose(fp);
+
+		if (!(fp = fopen("test_x509_private_key_info_encrypt_to_pem.pem", "r"))) {
+			error_print();
+			return -1;
+		}
+		if (x509_private_key_info_decrypt_from_pem(&key, &attrs, &attrslen, pass, fp) != 1) {
+			error_print();
+			return -1;
+		}
+		fclose(fp);
+		if (len) {
+			error_print();
+			return -1;
+		}
+		if (x509_public_key_equ(&key, &x509_keys[i]) != 1) {
+			error_print();
+			return -1;
+		}
+	}
+
+	printf("%s() ok\n", __FUNCTION__);
+	return 1;
+}
+
+static int test_x509_sign(void)
+{
+	size_t i;
+	X509_SIGN_CTX sign_ctx;
+	void *args = NULL;
+	size_t argslen = 0;
+	uint8_t msg[66];
+	uint8_t sig[40969];
+	size_t siglen;
+
 	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
-		if (tests[i].algor == OID_ec_public_key) {
+		if (tests[i].algor == OID_kyber_kem) {
-			const uint8_t *cp = buf;
+			continue;
-			uint8_t *p = buf;
+		}
-			size_t len = 0;
+		//format_print(stderr, 0, 4, "%s\n", x509_public_key_algor_name(tests[i].algor));
-			const uint8_t *attrs;
+		if (x509_sign_init(&sign_ctx, &x509_keys[i], args, argslen) != 1) {
-			size_t attrslen;
+			error_print();
+			return -1;
+		}
+		if (x509_sign(&sign_ctx, msg, sizeof(msg), sig, &siglen) != 1) {
+			error_print();
+			return -1;
+		}
+		if (x509_verify_init(&sign_ctx, &x509_keys[i], args, argslen, sig, siglen) != 1) {
+			error_print();
+			return -1;
+		}
+		if (x509_verify(&sign_ctx, msg, sizeof(msg)) != 1) {
+			error_print();
+			return -1;
+		}
+	}
 
-			if (!(fp = fopen("test_x509_private_key_info_encrypt_to_pem.pem", "w"))) {
+	printf("%s() ok\n", __FUNCTION__);
-				error_print();
+	return 1;
-				return -1;
+}
-			}
-			if (x509_private_key_info_encrypt_to_pem(&x509_keys[i], pass, fp) != 1) {
-				error_print();
-				return -1;
-			}
-			fclose(fp);
 
-			if (!(fp = fopen("test_x509_private_key_info_encrypt_to_pem.pem", "r"))) {
+static int test_x509_key_exchange(void)
-				error_print();
+{
-				return -1;
+	X509_KEY key;
-			}
+	uint8_t point1[65];
-			if (x509_private_key_info_decrypt_from_pem(&key, &attrs, &attrslen, pass, fp) != 1) {
+	uint8_t point2[65];
-				error_print();
+	uint8_t share1[32];
-				return -1;
+	uint8_t share2[32];
-			}
+	uint8_t *p;
-			fclose(fp);
+	size_t len;
-			if (len) {
+	size_t i;
-				error_print();
+
-				return -1;
+	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
-			}
+		if (tests[i].algor != OID_ec_public_key) {
-			if (x509_public_key_equ(&key, &x509_keys[i]) != 1) {
+			continue;
-				error_print();
+		}
-				return -1;
+		if (x509_key_generate(&key, tests[i].algor, &tests[i].algor_param, sizeof(tests[i].algor_param)) != 1) {
-			}
+			error_print();
+			return -1;
+		}
+
+		// export public key 1
+		p = point1;
+		len = 0;
+		if (x509_public_key_to_bytes(&key, &p, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		if (len != sizeof(point1)) {
+			error_print();
+			return -1;
+		}
+
+		// export public key 2
+		p = point2;
+		len = 0;
+		if (x509_public_key_to_bytes(&x509_keys[i], &p, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		if (len != sizeof(point2)) {
+			error_print();
+			return -1;
+		}
+
+		// key exchange 1
+		if (x509_key_exchange(&key, point2, sizeof(point2), share1, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		if (len != sizeof(share1)) {
+			error_print();
+			return -1;
+		}
+
+		// key exchange 2
+		if (x509_key_exchange(&x509_keys[i], point1, sizeof(point1), share2, &len) != 1) {
+			error_print();
+			return -1;
+		}
+		if (len != sizeof(share2)) {
+			error_print();
+			return -1;
+		}
+
+		// share secrets equal
+		if (memcmp(share1, share2, sizeof(share1)) != 0) {
+			error_print();
+			return -1;
+		}
+	}
+
+	printf("%s() ok\n", __FUNCTION__);
+	return 1;
+}
+
+static int test_x509_kem(void)
+{
+	uint8_t ciphertext[sizeof(KYBER_CIPHERTEXT)];
+	size_t ciphertext_len;
+	uint8_t secret1[32];
+	uint8_t secret2[32];
+	size_t i;
+
+	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
+		if (tests[i].algor != OID_kyber_kem) {
+			continue;
+		}
+
+		if (x509_key_encapsulate(&x509_keys[i], ciphertext, &ciphertext_len, secret1) != 1) {
+			error_print();
+			return -1;
+		}
+		if (ciphertext_len != sizeof(ciphertext)) {
+			error_print();
+			return -1;
+		}
+		if (x509_key_decapsulate(&x509_keys[i], ciphertext, ciphertext_len, secret2) != 1) {
+			error_print();
+			return -1;
+		}
+		if (memcmp(secret1, secret2, 32) != 0) {
+			error_print();
+			return -1;
 		}
 	}
 
@@ -366,42 +500,18 @@ static int test_x509_private_key_info_encrypt_to_pem(void)
 }
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-// 首先某些头文件中的函数并没有实现，很奇怪！
-
-// 然后是某些数据长度（公钥、签名之类）还没有计算具体的值，因此没有办法准备最大的缓冲去
-
-// 应该把密钥生成放到最外面，这样只需要生成一次就可以了
-
-// X509_KEY还不支持Kyber
-
-
-
-
-
-
-
 int main(void)
 {
 	if (test_x509_key_generate() != 1) goto err;
-	if (test_x509_algor_param_from_lms_types() != 1) goto err;
 	if (test_x509_public_key_to_bytes() != 1) goto err;
 	if (test_x509_public_key_info_to_der() != 1) goto err;
 	if (test_ec_private_key_to_der() != 1) goto err;
 	if (test_x509_private_key_info_to_der() != 1) goto err;
 	if (test_x509_private_key_info_encrypt_to_der() != 1) goto err;
 	if (test_x509_private_key_info_encrypt_to_pem() != 1) goto err;
+	if (test_x509_sign() != 1) goto err;
+	if (test_x509_key_exchange() != 1) goto err;
+	if (test_x509_kem() != 1) goto err;
 
 	printf("%s all tests passed!\n", __FILE__);
 	return 0;

tests/x509_reqtest.c

@@ -43,7 +43,7 @@ static int test_x509_request_info(void)
 	X509_KEY pub_key;
 	const uint8_t *attrs;
 
-	if (x509_key_generate(&x509_key, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}
@@ -152,7 +152,7 @@ static int test_x509_req(void)
 	uint8_t *p = req;
 	size_t reqlen = 0;
 
-	if (x509_key_generate(&x509_key, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}

tests/x509test.c

@@ -230,7 +230,7 @@ static int test_x509_public_key_info(void)
 	const uint8_t *d;
 	size_t dlen;
 
-	if (x509_key_generate(&x509_key, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}
@@ -242,7 +242,7 @@ static int test_x509_public_key_info(void)
 	}
 	x509_public_key_info_print(stdout, 0, 4, "PublicKeyInfo", d, dlen);
 
-	if (x509_key_generate(&x509_key, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}
@@ -296,7 +296,7 @@ static int test_x509_tbs_cert(void)
 	x509_validity_add_days(&not_after, not_before, 365);
 	set_x509_name(subject, &subject_len, sizeof(subject));
 
-	if (x509_key_generate(&x509_key, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}
@@ -374,7 +374,7 @@ static int test_x509_cert(void)
 	x509_validity_add_days(&not_after, not_before, 365);
 	set_x509_name(subject, &subject_len, sizeof(subject));
 
-	if (x509_key_generate(&x509_key, algor, algor_param) != 1) {
+	if (x509_key_generate(&x509_key, algor, &algor_param, sizeof(algor_param)) != 1) {
 		error_print();
 		return -1;
 	}

tests/xmsstest.c

@@ -549,12 +549,12 @@ static int test_xmss_sign(void)
 }
 
 
-
+static int test_xmss_sign_update(void)
-static int test_xmss_sign_init(void)
 {
 	uint32_t xmss_type = XMSS_HASH256_10_256;
 	XMSS_KEY key;
 	XMSS_SIGN_CTX sign_ctx;
+	XMSS_SIGNATURE signature;
 	uint8_t sig[XMSS_SIGNATURE_MAX_SIZE];
 	size_t siglen;
 	uint8_t msg[100] = {0};
@@ -573,12 +573,14 @@ static int test_xmss_sign_init(void)
 		error_print();
 		return -1;
 	}
-	if (xmss_sign_finish(&sign_ctx, sig, &siglen) != 1) {
+	if (xmss_sign_finish_ex(&sign_ctx, &signature) != 1) {
 		error_print();
 		return -1;
 	}
+	xmss_signature_print_ex(stderr, (int)xmss_type, 4, "xmss_signature", &signature);
 
-	if (xmss_verify_init(&sign_ctx, &key, sig, siglen) != 1) {
+
+	if (xmss_verify_init_ex(&sign_ctx, &key, &signature) != 1) {
 		error_print();
 		return -1;
 	}
@@ -1057,7 +1059,8 @@ static int test_xmssmt_sign_update(void)
 	XMSSMT_SIGN_CTX ctx;
 	XMSSMT_SIGNATURE sig;
 	uint8_t msg[100] = {0};
-
+	uint8_t sigbuf[sizeof(XMSSMT_SIGNATURE) *2 ];
+	size_t siglen;
 
 	if (xmssmt_key_generate(&key, xmssmt_type) != 1) {
 		error_print();
@@ -1092,6 +1095,44 @@ static int test_xmssmt_sign_update(void)
 		return -1;
 	}
 
+
+	// sigbuf
+
+	if (xmssmt_sign_init(&ctx, &key) != 1) {
+		error_print();
+		return -1;
+	}
+	if (xmssmt_sign_update(&ctx, msg, sizeof(msg)) != 1) {
+		error_print();
+		return -1;
+	}
+	if (xmssmt_sign_finish(&ctx, sigbuf, &siglen) != 1) {
+		error_print();
+		return -1;
+	}
+
+	memset(&ctx, 0, sizeof(ctx));
+	if (xmssmt_verify_init(&ctx, &key, sigbuf, siglen) != 1) {
+		error_print();
+		return -1;
+	}
+	if (xmssmt_verify_update(&ctx, msg, sizeof(msg)) != 1) {
+		error_print();
+		return -1;
+	}
+	if (xmssmt_verify_finish(&ctx) != 1) {
+		error_print();
+		return -1;
+	}
+
+
+
+
+
+
+
+
+
 	printf("%s() ok\n", __FUNCTION__);
 	return 1;
 }
@@ -1114,7 +1155,7 @@ int main(void)
 	//if (test_xmss_private_key_to_bytes() != 1) goto err;
 	if (test_xmss_signature_size() != 1) goto err;
 	if (test_xmss_sign() != 1) goto err;
-	if (test_xmss_sign_init() != 1) goto err;
+	if (test_xmss_sign_update() != 1) goto err;
 	if (test_xmssmt_key_generate() != 1) goto err;
 	if (test_xmssmt_index_to_bytes() != 1) goto err;
 	if (test_xmssmt_signature_to_bytes() != 1) goto err;