自学教程：C++ EC_METHOD_get_field_type函数代码示例

static int ec_get_pubkey(EC_KEY *key, BIGNUM *x, BIGNUM *y){    const EC_POINT *pt;    const EC_GROUP *grp;    const EC_METHOD *meth;    int rv;    BN_CTX *ctx;    ctx = BN_CTX_new();    if (!ctx)        return 0;    grp = EC_KEY_get0_group(key);    pt = EC_KEY_get0_public_key(key);    meth = EC_GROUP_method_of(grp);    if (EC_METHOD_get_field_type(meth) == NID_X9_62_prime_field)        rv = EC_POINT_get_affine_coordinates_GFp(grp, pt, x, y, ctx);    else# ifdef OPENSSL_NO_EC2M    {        fprintf(stderr, "ERROR: GF2m not supported/n");        exit(1);    }# else        rv = EC_POINT_get_affine_coordinates_GF2m(grp, pt, x, y, ctx);# endif    BN_CTX_free(ctx);    return rv;}

int EC_GROUP_get_pentanomial_basis(const EC_GROUP *group, unsigned int *k1,                                   unsigned int *k2, unsigned int *k3){    if (group == NULL)        return 0;    if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=            NID_X9_62_characteristic_two_field            || !((group->poly[0] != 0) && (group->poly[1] != 0)                 && (group->poly[2] != 0) && (group->poly[3] != 0)                 && (group->poly[4] == 0))) {        ECerr(EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS,              ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);        return 0;    }    if (k1)        *k1 = group->poly[3];    if (k2)        *k2 = group->poly[2];    if (k3)        *k3 = group->poly[1];    return 1;}

int EC_GROUP_get_trinomial_basis(const EC_GROUP * group, unsigned int *k){	if (group == NULL)		return 0;	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=	    NID_X9_62_characteristic_two_field	    || !((group->poly[0] != 0) && (group->poly[1] != 0) && (group->poly[2] == 0))) {		ECerr(EC_F_EC_GROUP_GET_TRINOMIAL_BASIS, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);		return 0;	}	if (k)		*k = group->poly[1];	return 1;}

/* For an EC key set TLS ID and required compression based on parameters. */static inttls1_set_ec_id(uint16_t *curve_id, uint8_t *comp_id, EC_KEY *ec){	const EC_GROUP *grp;	const EC_METHOD *meth;	int is_prime = 0;	int nid, id;	if (ec == NULL)		return (0);	/* Determine if it is a prime field. */	if ((grp = EC_KEY_get0_group(ec)) == NULL)		return (0);	if ((meth = EC_GROUP_method_of(grp)) == NULL)		return (0);	if (EC_METHOD_get_field_type(meth) == NID_X9_62_prime_field)		is_prime = 1;	/* Determine curve ID. */	nid = EC_GROUP_get_curve_name(grp);	id = tls1_ec_nid2curve_id(nid);	/* If we have an ID set it, otherwise set arbitrary explicit curve. */	if (id != 0)		*curve_id = id;	else		*curve_id = is_prime ? 0xff01 : 0xff02;	/* Specify the compression identifier. */	if (comp_id != NULL) {		if (EC_KEY_get0_public_key(ec) == NULL)			return (0);		if (EC_KEY_get_conv_form(ec) == POINT_CONVERSION_COMPRESSED) {			*comp_id = is_prime ?			    TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime :			    TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;		} else {			*comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;		}	}	return (1);}

int EC_GROUP_get_basis_type(const EC_GROUP *group){    int i = 0;    if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=            NID_X9_62_characteristic_two_field)        /* everything else is currently not supported */        return 0;    while (group->poly[i] != 0)        i++;    if (i == 4)        return NID_X9_62_ppBasis;    else if (i == 2)        return NID_X9_62_tpBasis;    else        /* everything else is currently not supported */        return 0;}

void Z_Gen(unsigned char *z, unsigned int klen, unsigned char *ID, unsigned char *x, unsigned char *y){	// Tsp 需要	// ZA=H256(ENTLA || IDA || a || b || xG || yG || xA || yA)。	BN_CTX *ctx = NULL;	ctx = BN_CTX_new();	EC_KEY *ec_key = EC_KEY_new_by_curve_name(NID_sm2p256v1);	const EC_GROUP *ec_group = EC_KEY_get0_group(ec_key);	BIGNUM *p = NULL, *a = NULL, *b = NULL, *gen = NULL,		*order = NULL, *cofactor = NULL;	if ((p = BN_new()) == NULL || (a = BN_new()) == NULL ||		(b = BN_new()) == NULL || (order = BN_new()) == NULL ||		(cofactor = BN_new()) == NULL) {			goto err;	}	int is_char_two = 0;	int tmp_nid = EC_METHOD_get_field_type(EC_GROUP_method_of(ec_group));	if (tmp_nid == NID_X9_62_characteristic_two_field)		is_char_two = 1;#ifndef OPENSSL_NO_EC2M	if (is_char_two) {		if (!EC_GROUP_get_curve_GF2m(ec_group, p, a, b, ctx)) {			goto err;		}	} else  /* prime field */#endif	{		if (!EC_GROUP_get_curve_GFp(ec_group, p, a, b, ctx)) {			goto err;		}	}	const EC_POINT *generator = EC_GROUP_get0_generator(ec_group);	unsigned char g[65];	EC_POINT_point2oct(ec_group, generator, POINT_CONVERSION_UNCOMPRESSED, g, ECDH_SIZE, NULL);	sm3_ctx_t ctx2;	sm3_init(&ctx2);	unsigned char entla[2];	entla[0] = (klen / 32);	entla[1] = (klen * 8);	sm3_update(&ctx2, entla, sizeof(entla));	sm3_update(&ctx2, ID, klen);	unsigned char buffer[32];	BN_bn2bin(a, buffer);	sm3_update(&ctx2, buffer, 32);	BN_bn2bin(b, buffer);	sm3_update(&ctx2, buffer, 32);	sm3_update(&ctx2, g + 1, 64);	sm3_update(&ctx2, x, 32);	sm3_update(&ctx2, y, 32);	sm3_final(&ctx2, z);err:	return;}

int main(int argc, char *argv[]) {	void *bb;	BN_CTX *ctx = NULL;	int nid;	BIO *out;	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	const char *text = "NIST Prime-Curve P-192";#ifdef OPENSSL_SYS_WIN32	CRYPTO_malloc_init();#endif	RAND_seed(rnd_seed, sizeof rnd_seed);	out = BIO_new(BIO_s_file());	if (out == NULL)		EXIT(1);	BIO_set_fp(out, stdout, BIO_NOCLOSE);	if ((ctx = BN_CTX_new()) == NULL)		goto err;	nid = NID_X9_62_prime192v1;	//EC_POINT *bb;	EC_KEY *a = NULL;    //EC_KEY is a structure	BIGNUM *x_a = NULL, *y_a = NULL;	char buf[12];	//unsigned char *abuf=NULL,*bbuf=NULL;	int i, alen, blen, aout, bout;	const EC_GROUP *group;	a = EC_KEY_new_by_curve_name(nid);	if (a == NULL)		goto err;	group = EC_KEY_get0_group(a);	if ((x_a = BN_new()) == NULL)		goto err;	//BN_new returns a pointer to the bignum	if ((y_a = BN_new()) == NULL)		goto err;	BIO_puts(out, "Testing key generation with ");	BIO_puts(out, text);	if (!EC_KEY_generate_key(a))		goto err;	printf("/n1 ) generating keys/n");	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group))			== NID_X9_62_prime_field) {		if (!EC_POINT_get_affine_coordinates_GFp(group,				EC_KEY_get0_public_key(a), x_a, y_a, ctx))			goto err;	}	//returns the public key	else {		if (!EC_POINT_get_affine_coordinates_GF2m(group,				EC_KEY_get0_public_key(a), x_a, y_a, ctx))			goto err;	}	BIO_puts(out, "  pri 1=");	BN_print(out, EC_KEY_get0_private_key(a));	BIO_puts(out, "/n  pub 1=");	BN_print(out, x_a);	BIO_puts(out, ",");	BN_print(out, y_a);	BIO_puts(out, "/n");	func(EC_KEY_get0_public_key(a));	err: ERR_print_errors_fp(stderr);	if (x_a)		BN_free(x_a);	if (y_a)		BN_free(y_a);	if (a)		EC_KEY_free(a);	if (ctx)		BN_CTX_free(ctx);	BIO_free(out);	CRYPTO_cleanup_all_ex_data();	ERR_remove_state(0);	CRYPTO_mem_leaks_fp(stderr);	return 0;}

static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in,                            BIGNUM **kinvp, BIGNUM **rp,                            const unsigned char *dgst, int dlen){    BN_CTX *ctx = NULL;    BIGNUM *k = NULL, *r = NULL, *order = NULL, *X = NULL;    EC_POINT *tmp_point = NULL;    const EC_GROUP *group;    int ret = 0;    if (eckey == NULL || (group = EC_KEY_get0_group(eckey)) == NULL) {        ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_PASSED_NULL_PARAMETER);        return 0;    }    if (ctx_in == NULL) {        if ((ctx = BN_CTX_new()) == NULL) {            ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_MALLOC_FAILURE);            return 0;        }    } else        ctx = ctx_in;    k = BN_new();               /* this value is later returned in *kinvp */    r = BN_new();               /* this value is later returned in *rp */    order = BN_new();    X = BN_new();    if (k == NULL || r == NULL || order == NULL || X == NULL) {        ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_MALLOC_FAILURE);        goto err;    }    if ((tmp_point = EC_POINT_new(group)) == NULL) {        ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);        goto err;    }    if (!EC_GROUP_get_order(group, order, ctx)) {        ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);        goto err;    }    do {        /* get random k */        do            if (dgst != NULL) {                if (!BN_generate_dsa_nonce                    (k, order, EC_KEY_get0_private_key(eckey), dgst, dlen,                     ctx)) {                    ECerr(EC_F_ECDSA_SIGN_SETUP,                             EC_R_RANDOM_NUMBER_GENERATION_FAILED);                    goto err;                }            } else {                if (!BN_rand_range(k, order)) {                    ECerr(EC_F_ECDSA_SIGN_SETUP,                             EC_R_RANDOM_NUMBER_GENERATION_FAILED);                    goto err;                }            }        while (BN_is_zero(k));        /*         * We do not want timing information to leak the length of k, so we         * compute G*k using an equivalent scalar of fixed bit-length.         */        if (!BN_add(k, k, order))            goto err;        if (BN_num_bits(k) <= BN_num_bits(order))            if (!BN_add(k, k, order))                goto err;        /* compute r the x-coordinate of generator * k */        if (!EC_POINT_mul(group, tmp_point, k, NULL, NULL, ctx)) {            ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);            goto err;        }        if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) ==            NID_X9_62_prime_field) {            if (!EC_POINT_get_affine_coordinates_GFp                (group, tmp_point, X, NULL, ctx)) {                ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);                goto err;            }        }#ifndef OPENSSL_NO_EC2M        else {                  /* NID_X9_62_characteristic_two_field */            if (!EC_POINT_get_affine_coordinates_GF2m(group,                                                      tmp_point, X, NULL,                                                      ctx)) {                ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);                goto err;            }        }#endif        if (!BN_nnmod(r, X, order, ctx)) {            ECerr(EC_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);            goto err;        }    }//.........这里部分代码省略.........

/* This implementation is based on the following primitives in the IEEE 1363 standard: *  - ECKAS-DH1 *  - ECSVDP-DH * Finally an optional KDF is applied. */static int ecdh_compute_key(void *out, size_t outlen, const EC_POINT *pub_key,	EC_KEY *ecdh,	void *(*KDF)(const void *in, size_t inlen, void *out, size_t *outlen))	{	BN_CTX *ctx;	EC_POINT *tmp=NULL;	BIGNUM *x=NULL, *y=NULL;	const BIGNUM *priv_key;	const EC_GROUP* group;	int ret= -1;	size_t buflen, len;	unsigned char *buf=NULL;	if (outlen > INT_MAX)		{		ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ERR_R_MALLOC_FAILURE); /* sort of, anyway */		return -1;		}	if ((ctx = BN_CTX_new()) == NULL) goto err;	BN_CTX_start(ctx);	x = BN_CTX_get(ctx);	y = BN_CTX_get(ctx);		priv_key = EC_KEY_get0_private_key(ecdh);	if (priv_key == NULL)		{		ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ECDH_R_NO_PRIVATE_VALUE);		goto err;		}	group = EC_KEY_get0_group(ecdh);	if ((tmp=EC_POINT_new(group)) == NULL)		{		ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ERR_R_MALLOC_FAILURE);		goto err;		}	if (!EC_POINT_mul(group, tmp, NULL, pub_key, priv_key, ctx)) 		{		ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ECDH_R_POINT_ARITHMETIC_FAILURE);		goto err;		}			if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field) 		{		if (!EC_POINT_get_affine_coordinates_GFp(group, tmp, x, y, ctx)) 			{			ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ECDH_R_POINT_ARITHMETIC_FAILURE);			goto err;			}		}#ifndef OPENSSL_NO_EC2M	else		{		if (!EC_POINT_get_affine_coordinates_GF2m(group, tmp, x, y, ctx)) 			{			ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ECDH_R_POINT_ARITHMETIC_FAILURE);			goto err;			}		}#endif	buflen = (EC_GROUP_get_degree(group) + 7)/8;	len = BN_num_bytes(x);	if (len > buflen)		{		ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ERR_R_INTERNAL_ERROR);		goto err;		}	if ((buf = malloc(buflen)) == NULL)		{		ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ERR_R_MALLOC_FAILURE);		goto err;		}		memset(buf, 0, buflen - len);	if (len != (size_t)BN_bn2bin(x, buf + buflen - len))		{		ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ERR_R_BN_LIB);		goto err;		}	if (KDF != 0)		{		if (KDF(buf, buflen, out, &outlen) == NULL)			{			ECDHerr(ECDH_F_ECDH_COMPUTE_KEY,ECDH_R_KDF_FAILED);			goto err;			}		ret = outlen;		}	else		{		/* no KDF, just copy as much as we can *///.........这里部分代码省略.........

static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,		BIGNUM **rp){	BN_CTX   *ctx = NULL;	BIGNUM	 *k = NULL, *r = NULL, *order = NULL, *X = NULL;	EC_POINT *tmp_point=NULL;	const EC_GROUP *group;	int 	 ret = 0;	if (eckey == NULL || (group = EC_KEY_get0_group(eckey)) == NULL)	{		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_PASSED_NULL_PARAMETER);		return 0;	}	if (ctx_in == NULL) 	{		if ((ctx = BN_CTX_new()) == NULL)		{			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_MALLOC_FAILURE);			return 0;		}	}	else		ctx = ctx_in;	k     = BN_new();	/* this value is later returned in *kinvp */	r     = BN_new();	/* this value is later returned in *rp    */	order = BN_new();	X     = BN_new();	if (!k || !r || !order || !X)	{		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_MALLOC_FAILURE);		goto err;	}	if ((tmp_point = EC_POINT_new(group)) == NULL)	{		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);		goto err;	}	if (!EC_GROUP_get_order(group, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);		goto err;	}#ifdef OPENSSL_FIPS	if (!fips_check_ec_prng(eckey))		goto err;#endif		do	{		/* get random k */			do			if (!BN_rand_range(k, order))			{				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,				 ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED);					goto err;			}		while (BN_is_zero(k));#ifdef ECDSA_POINT_MUL_NO_CONSTTIME		/* We do not want timing information to leak the length of k,		 * so we compute G*k using an equivalent scalar of fixed		 * bit-length. */		if (!BN_add(k, k, order)) goto err;		if (BN_num_bits(k) <= BN_num_bits(order))			if (!BN_add(k, k, order)) goto err;#endif /* def(ECDSA_POINT_MUL_NO_CONSTTIME) */		/* compute r the x-coordinate of generator * k */		if (!EC_POINT_mul(group, tmp_point, k, NULL, NULL, ctx))		{			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);			goto err;		}		if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field)		{			if (!EC_POINT_get_affine_coordinates_GFp(group,				tmp_point, X, NULL, ctx))			{				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_EC_LIB);				goto err;			}		}#ifndef OPENSSL_NO_EC2M		else /* NID_X9_62_characteristic_two_field */		{			if (!EC_POINT_get_affine_coordinates_GF2m(group,				tmp_point, X, NULL, ctx))			{				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_EC_LIB);				goto err;			}		}#endif		if (!BN_nnmod(r, X, order, ctx))//.........这里部分代码省略.........

//.........这里部分代码省略.........	ctx = BN_CTX_new();	order = BN_new();	e = BN_new();	t = BN_new();	if (!ctx || !order || !e || !t) {		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_MALLOC_FAILURE);		goto err;	}	if (!EC_GROUP_get_order(ec_group, order, ctx)) {		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);		goto err;	}	/* check r, s in [1, n-1] and r + s != 0 (mod n) */ 	if (BN_is_zero(r) ||		BN_is_negative(r) ||		BN_ucmp(r, order) >= 0 || 		BN_is_zero(s) ||		BN_is_negative(s) || 		BN_ucmp(s, order) >= 0) {			ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_BAD_SIGNATURE);			ret = 0;			goto err;	}	/* check t = r + s != 0 */	if (!BN_mod_add(t, r, s, order, ctx)) {		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	if (BN_is_zero(t)) {		ret = 0;		goto err;	}	/* convert digest to e */	i = BN_num_bits(order);#if 0	if (8 * dgstlen > i) {		dgstlen = (i + 7)/8;	}#endif	if (!BN_bin2bn(rgbHashData, 32, e)) {		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}#if 0	if ((8 * dgstlen > i) && !BN_rshift(e, e, 8 - (i & 0x7))) {		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}#endif	/* compute (x, y) = sG + tP, P is pub_key */	if (!(point = EC_POINT_new(ec_group))) {		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_MALLOC_FAILURE);		goto err;	}	if (!EC_POINT_mul(ec_group, point, s, pub_key, t, ctx)) {		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);		goto err;	}	if (EC_METHOD_get_field_type(EC_GROUP_method_of(ec_group)) == NID_X9_62_prime_field) {		if (!EC_POINT_get_affine_coordinates_GFp(ec_group, point, t, NULL, ctx)) {			ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);			goto err;		}	} else /* NID_X9_62_characteristic_two_field */ { 		if (!EC_POINT_get_affine_coordinates_GF2m(ec_group, point, t, NULL, ctx)) {			ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);			goto err;		}	}	if (!BN_nnmod(t, t, order, ctx)) {		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	/* check (sG + tP).x + e  == sig.r */	if (!BN_mod_add(t, t, e, order, ctx)) {		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	if (BN_ucmp(t, r) == 0) {		ret = SM2_VERIFY_SUCCESS;	} else {		ret = SM2_VERIFY_FAILED;	}err:	if (point) EC_POINT_free(point);	if (order) BN_free(order);	if (e) BN_free(e);	if (t) BN_free(t);	if (ctx) BN_CTX_free(ctx);	return 0;}

int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x,                                             BIGNUM *y){    BN_CTX *ctx = NULL;    BIGNUM *tx, *ty;    EC_POINT *point = NULL;    int ok = 0;#ifndef OPENSSL_NO_EC2M    int tmp_nid, is_char_two = 0;#endif    if (key == NULL || key->group == NULL || x == NULL || y == NULL) {        ECerr(EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,              ERR_R_PASSED_NULL_PARAMETER);        return 0;    }    ctx = BN_CTX_new();    if (ctx == NULL)        return 0;    BN_CTX_start(ctx);    point = EC_POINT_new(key->group);    if (point == NULL)        goto err;    tx = BN_CTX_get(ctx);    ty = BN_CTX_get(ctx);    if (ty == NULL)        goto err;#ifndef OPENSSL_NO_EC2M    tmp_nid = EC_METHOD_get_field_type(EC_GROUP_method_of(key->group));    if (tmp_nid == NID_X9_62_characteristic_two_field)        is_char_two = 1;    if (is_char_two) {        if (!EC_POINT_set_affine_coordinates_GF2m(key->group, point,                                                  x, y, ctx))            goto err;        if (!EC_POINT_get_affine_coordinates_GF2m(key->group, point,                                                  tx, ty, ctx))            goto err;    } else#endif    {        if (!EC_POINT_set_affine_coordinates_GFp(key->group, point,                                                 x, y, ctx))            goto err;        if (!EC_POINT_get_affine_coordinates_GFp(key->group, point,                                                 tx, ty, ctx))            goto err;    }    /*     * Check if retrieved coordinates match originals and are less than field     * order: if not values are out of range.     */    if (BN_cmp(x, tx) || BN_cmp(y, ty)        || (BN_cmp(x, key->group->field) >= 0)        || (BN_cmp(y, key->group->field) >= 0)) {        ECerr(EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,              EC_R_COORDINATES_OUT_OF_RANGE);        goto err;    }    if (!EC_KEY_set_public_key(key, point))        goto err;    if (EC_KEY_check_key(key) == 0)        goto err;    ok = 1; err:    BN_CTX_end(ctx);    BN_CTX_free(ctx);    EC_POINT_free(point);    return ok;}

int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx)	{	int    r = 0;	BIGNUM *a1, *a2, *a3, *b1, *b2, *b3;	BN_CTX *ctx_new = NULL;	/* compare the field types*/	if (EC_METHOD_get_field_type(EC_GROUP_method_of(a)) !=	    EC_METHOD_get_field_type(EC_GROUP_method_of(b)))		return 1;	/* compare the curve name (if present) */	if (EC_GROUP_get_curve_name(a) && EC_GROUP_get_curve_name(b) &&	    EC_GROUP_get_curve_name(a) == EC_GROUP_get_curve_name(b))		return 0;	if (!ctx)		ctx_new = ctx = BN_CTX_new();	if (!ctx)		return -1;		BN_CTX_start(ctx);	a1 = BN_CTX_get(ctx);	a2 = BN_CTX_get(ctx);	a3 = BN_CTX_get(ctx);	b1 = BN_CTX_get(ctx);	b2 = BN_CTX_get(ctx);	b3 = BN_CTX_get(ctx);	if (!b3)		{		BN_CTX_end(ctx);		if (ctx_new)			BN_CTX_free(ctx);		return -1;		}	/* XXX This approach assumes that the external representation	 * of curves over the same field type is the same.	 */	if (!a->meth->group_get_curve(a, a1, a2, a3, ctx) ||	    !b->meth->group_get_curve(b, b1, b2, b3, ctx))		r = 1;	if (r || BN_cmp(a1, b1) || BN_cmp(a2, b2) || BN_cmp(a3, b3))		r = 1;	/* XXX EC_POINT_cmp() assumes that the methods are equal */	if (r || EC_POINT_cmp(a, EC_GROUP_get0_generator(a),	    EC_GROUP_get0_generator(b), ctx))		r = 1;	if (!r)		{		/* compare the order and cofactor */		if (!EC_GROUP_get_order(a, a1, ctx) ||		    !EC_GROUP_get_order(b, b1, ctx) ||		    !EC_GROUP_get_cofactor(a, a2, ctx) ||		    !EC_GROUP_get_cofactor(b, b2, ctx))			{			BN_CTX_end(ctx);			if (ctx_new)				BN_CTX_free(ctx);			return -1;			}		if (BN_cmp(a1, b1) || BN_cmp(a2, b2))			r = 1;		}	BN_CTX_end(ctx);	if (ctx_new)		BN_CTX_free(ctx);	return r;	}

int SM2_do_decrypt(const EVP_MD *md, const SM2CiphertextValue *cv,	unsigned char *out, size_t *outlen, EC_KEY *ec_key){	int ret = 0;	const EC_GROUP *group;	const BIGNUM *pri_key;	KDF_FUNC kdf;	EC_POINT *point = NULL;	EC_POINT *tmp_point = NULL;	BIGNUM *n = NULL;	BIGNUM *h = NULL;	BN_CTX *bn_ctx = NULL;	EVP_MD_CTX *md_ctx = NULL;	unsigned char buf[(OPENSSL_ECC_MAX_FIELD_BITS + 7)/4 + 1];	unsigned char mac[EVP_MAX_MD_SIZE];	unsigned int maclen = sizeof(mac);	int nbytes, len, i;	/* check arguments */	if (!md || !cv || !outlen || !ec_key) {		SM2err(SM2_F_SM2_DO_DECRYPT, ERR_R_PASSED_NULL_PARAMETER);		return 0;	}	if (!(kdf = KDF_get_x9_63(md))) {		SM2err(SM2_F_SM2_DO_DECRYPT, SM2_R_INVALID_DIGEST_ALGOR);		return 0;	}	if (!cv->xCoordinate || !cv->yCoordinate || !cv->hash || !cv->ciphertext) {		SM2err(SM2_F_SM2_DO_DECRYPT, SM2_R_INVALID_CIPHERTEXT);		return 0;	}	if (cv->hash->length != EVP_MD_size(md)) {		SM2err(SM2_F_SM2_DO_DECRYPT, SM2_R_INVALID_CIPHERTEXT);		return 0;	}	if (cv->ciphertext->length < SM2_MIN_PLAINTEXT_LENGTH		|| cv->ciphertext->length > SM2_MAX_PLAINTEXT_LENGTH) {		SM2err(SM2_F_SM2_DO_DECRYPT, SM2_R_INVALID_CIPHERTEXT);		return 0;	}	if (!(group = EC_KEY_get0_group(ec_key))		|| !(pri_key = EC_KEY_get0_private_key(ec_key))) {		SM2err(SM2_F_SM2_DO_DECRYPT, SM2_R_INVALID_EC_KEY);		return 0;	}	if (!out) {		*outlen = cv->ciphertext->length;		return 1;	}	if (*outlen < cv->ciphertext->length) {		SM2err(SM2_F_SM2_DO_DECRYPT, SM2_R_BUFFER_TOO_SMALL);		return 0;	}	/* malloc */	point = EC_POINT_new(group);	tmp_point = EC_POINT_new(group);	n = BN_new();	h = BN_new();	bn_ctx = BN_CTX_new();	md_ctx = EVP_MD_CTX_new();	if (!point || !n || !h || !bn_ctx || !md_ctx) {		SM2err(SM2_F_SM2_DO_DECRYPT, ERR_R_MALLOC_FAILURE);		goto end;	}	/* init ec domain parameters */	if (!EC_GROUP_get_order(group, n, bn_ctx)) {		SM2err(SM2_F_SM2_DO_DECRYPT, ERR_R_EC_LIB);		goto end;	}	if (!EC_GROUP_get_cofactor(group, h, bn_ctx)) {		SM2err(SM2_F_SM2_DO_DECRYPT, ERR_R_EC_LIB);		goto end;	}	nbytes = (EC_GROUP_get_degree(group) + 7) / 8;	/* get x/yCoordinates as C1 = (x1, y1) */	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field) {		if (!EC_POINT_set_affine_coordinates_GFp(group, point,			cv->xCoordinate, cv->yCoordinate, bn_ctx)) {			SM2err(SM2_F_SM2_DO_DECRYPT, SM2_R_INVALID_CIPHERTEXT);			goto end;		}	} else {		if (!EC_POINT_set_affine_coordinates_GF2m(group, point,			cv->xCoordinate, cv->yCoordinate, bn_ctx)) {			SM2err(SM2_F_SM2_DO_DECRYPT, SM2_R_INVALID_CIPHERTEXT);			goto end;		}	}//.........这里部分代码省略.........

static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,		BIGNUM **rp){	BN_CTX   *ctx = NULL;	BIGNUM	 *k = NULL, *r = NULL, *order = NULL, *X = NULL;	EC_POINT *tmp_point=NULL;	const EC_GROUP *group;	int 	 ret = 0;	if (eckey == NULL || (group = EC_KEY_get0_group(eckey)) == NULL)	{		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_PASSED_NULL_PARAMETER);		return 0;	}	if (ctx_in == NULL) 	{		if ((ctx = BN_CTX_new()) == NULL)		{			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_MALLOC_FAILURE);			return 0;		}	}	else		ctx = ctx_in;	k     = BN_new();	/* this value is later returned in *kinvp */	r     = BN_new();	/* this value is later returned in *rp    */	order = BN_new();	X     = BN_new();	if (!k || !r || !order || !X)	{		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_MALLOC_FAILURE);		goto err;	}	if ((tmp_point = EC_POINT_new(group)) == NULL)	{		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);		goto err;	}	if (!EC_GROUP_get_order(group, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);		goto err;	}		do	{		/* get random k */			do			if (!BN_rand_range(k, order))			{				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,				 ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED);					goto err;			}		while (BN_is_zero(k));		/* compute r the x-coordinate of generator * k */		if (!EC_POINT_mul(group, tmp_point, k, NULL, NULL, ctx))		{			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);			goto err;		}		if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field)		{			if (!EC_POINT_get_affine_coordinates_GFp(group,				tmp_point, X, NULL, ctx))			{				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_EC_LIB);				goto err;			}		}		else /* NID_X9_62_characteristic_two_field */		{			if (!EC_POINT_get_affine_coordinates_GF2m(group,				tmp_point, X, NULL, ctx))			{				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_EC_LIB);				goto err;			}		}		if (!BN_nnmod(r, X, order, ctx))		{			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);			goto err;		}	}	while (BN_is_zero(r));	/* compute the inverse of k */	if (!BN_mod_inverse(k, k, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);		goto err;		}	/* clear old values if necessary */	if (*rp != NULL)		BN_clear_free(*rp);	if (*kinvp != NULL) //.........这里部分代码省略.........

//.........这里部分代码省略.........    if (text) {        if (!ECPKParameters_print(out, group, 0))            goto end;    }    if (check) {        if (group == NULL)            BIO_printf(bio_err, "no elliptic curve parameters/n");        BIO_printf(bio_err, "checking elliptic curve parameters: ");        if (!EC_GROUP_check(group, NULL)) {            BIO_printf(bio_err, "failed/n");            ERR_print_errors(bio_err);        } else            BIO_printf(bio_err, "ok/n");    }    if (C) {        size_t buf_len = 0, tmp_len = 0;        const EC_POINT *point;        int is_prime, len = 0;        const EC_METHOD *meth = EC_GROUP_method_of(group);        if ((ec_p = BN_new()) == NULL                || (ec_a = BN_new()) == NULL                || (ec_b = BN_new()) == NULL                || (ec_gen = BN_new()) == NULL                || (ec_order = BN_new()) == NULL                || (ec_cofactor = BN_new()) == NULL) {            perror("Can't allocate BN");            goto end;        }        is_prime = (EC_METHOD_get_field_type(meth) == NID_X9_62_prime_field);        if (!is_prime) {            BIO_printf(bio_err, "Can only handle X9.62 prime fields/n");            goto end;        }        if (!EC_GROUP_get_curve_GFp(group, ec_p, ec_a, ec_b, NULL))            goto end;        if ((point = EC_GROUP_get0_generator(group)) == NULL)            goto end;        if (!EC_POINT_point2bn(group, point,                               EC_GROUP_get_point_conversion_form(group),                               ec_gen, NULL))            goto end;        if (!EC_GROUP_get_order(group, ec_order, NULL))            goto end;        if (!EC_GROUP_get_cofactor(group, ec_cofactor, NULL))            goto end;        if (!ec_p || !ec_a || !ec_b || !ec_gen || !ec_order || !ec_cofactor)            goto end;        len = BN_num_bits(ec_order);        if ((tmp_len = (size_t)BN_num_bytes(ec_p)) > buf_len)            buf_len = tmp_len;        if ((tmp_len = (size_t)BN_num_bytes(ec_a)) > buf_len)            buf_len = tmp_len;        if ((tmp_len = (size_t)BN_num_bytes(ec_b)) > buf_len)            buf_len = tmp_len;        if ((tmp_len = (size_t)BN_num_bytes(ec_gen)) > buf_len)            buf_len = tmp_len;

/* * NIST SP800-56A co-factor ECDH tests. * KATs taken from NIST documents with parameters: * * - (QCAVSx,QCAVSy) is the public key for CAVS. * - dIUT is the private key for IUT. * - (QIUTx,QIUTy) is the public key for IUT. * - ZIUT is the shared secret KAT. * * CAVS: Cryptographic Algorithm Validation System * IUT: Implementation Under Test * * This function tests two things: * * 1. dIUT * G = (QIUTx,QIUTy) *    i.e. public key for IUT computes correctly. * 2. x-coord of cofactor * dIUT * (QCAVSx,QCAVSy) = ZIUT *    i.e. co-factor ECDH key computes correctly. * * returns zero on failure or unsupported curve. One otherwise. */static int ecdh_cavs_kat(BIO *out, const ecdh_cavs_kat_t *kat){    int rv = 0, is_char_two = 0;    EC_KEY *key1 = NULL;    EC_POINT *pub = NULL;    const EC_GROUP *group = NULL;    BIGNUM *bnz = NULL, *x = NULL, *y = NULL;    unsigned char *Ztmp = NULL, *Z = NULL;    size_t Ztmplen, Zlen;    BIO_puts(out, "Testing ECC CDH Primitive SP800-56A with ");    BIO_puts(out, OBJ_nid2sn(kat->nid));    /* dIUT is IUT's private key */    if ((key1 = mk_eckey(kat->nid, kat->dIUT)) == NULL)        goto err;    /* these are cofactor ECDH KATs */    EC_KEY_set_flags(key1, EC_FLAG_COFACTOR_ECDH);    if ((group = EC_KEY_get0_group(key1)) == NULL)        goto err;    if ((pub = EC_POINT_new(group)) == NULL)        goto err;    if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_characteristic_two_field)        is_char_two = 1;    /* (QIUTx, QIUTy) is IUT's public key */    if(!BN_hex2bn(&x, kat->QIUTx))        goto err;    if(!BN_hex2bn(&y, kat->QIUTy))        goto err;    if (is_char_two) {#ifdef OPENSSL_NO_EC2M        goto err;#else        if (!EC_POINT_set_affine_coordinates_GF2m(group, pub, x, y, NULL))            goto err;#endif    }    else {        if (!EC_POINT_set_affine_coordinates_GFp(group, pub, x, y, NULL))            goto err;    }    /* dIUT * G = (QIUTx, QIUTy) should hold */    if (EC_POINT_cmp(group, EC_KEY_get0_public_key(key1), pub, NULL))        goto err;    /* (QCAVSx, QCAVSy) is CAVS's public key */    if(!BN_hex2bn(&x, kat->QCAVSx))        goto err;    if(!BN_hex2bn(&y, kat->QCAVSy))        goto err;    if (is_char_two) {#ifdef OPENSSL_NO_EC2M        goto err;#else        if (!EC_POINT_set_affine_coordinates_GF2m(group, pub, x, y, NULL))            goto err;#endif    }    else {        if (!EC_POINT_set_affine_coordinates_GFp(group, pub, x, y, NULL))            goto err;    }    /* ZIUT is the shared secret */    if(!BN_hex2bn(&bnz, kat->ZIUT))        goto err;    Ztmplen = (EC_GROUP_get_degree(EC_KEY_get0_group(key1)) + 7) / 8;    Zlen = BN_num_bytes(bnz);    if (Zlen > Ztmplen)        goto err;    if((Ztmp = OPENSSL_zalloc(Ztmplen)) == NULL)        goto err;    if((Z = OPENSSL_zalloc(Ztmplen)) == NULL)        goto err;    if(!BN_bn2binpad(bnz, Z, Ztmplen))        goto err;    if (!ECDH_compute_key(Ztmp, Ztmplen, pub, key1, 0))//.........这里部分代码省略.........

	return NULL;#endif}int main(void) {	unsigned char *abuf = NULL;	//const EC_POINT *public_key;	int i, alen, aout, jj = 0;	int sockfd, new_fd;  // listen on sock_fd, new connection on new_fd	struct sockaddr_in my_addr;    // my address information	struct sockaddr_in their_addr; // connector's address information	socklen_t sin_size;	int yes = 1, numbytes;	char buf[MAXDATASIZE];	/*//////////////////////////////////////////////////////////////Generating Keys/////////////////////////////////////*/	BN_CTX *ctx = NULL;	int nid;	BIO *out;	CRYPTO_malloc_debug_init();	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);	const char *text = "NIST Prime-Curve P-192";#ifdef OPENSSL_SYS_WIN32	CRYPTO_malloc_init();#endif	RAND_seed(rnd_seed, sizeof rnd_seed);	out = BIO_new(BIO_s_file());	if (out == NULL)		EXIT(1);	BIO_set_fp(out, stdout, BIO_NOCLOSE);	if ((ctx = BN_CTX_new()) == NULL)		goto err;	nid = NID_X9_62_prime192v1;	EC_KEY *a = NULL;    //EC_KEY is a structure	BIGNUM *x_a = NULL, *y_a = NULL;	const BIGNUM *BIG = NULL;	char *buff;	//unsigned char *abuf=NULL,*bbuf=NULL;	const EC_GROUP *group;	a = EC_KEY_new_by_curve_name(nid);	if (a == NULL)		goto err;	group = EC_KEY_get0_group(a);	//	aa=EC_POINT_new(group);	if ((x_a = BN_new()) == NULL)		goto err;	//BN_new returns a pointer to the bignum	if ((y_a = BN_new()) == NULL)		goto err;	//	if ((BIG=BN_new()) == NULL) goto err;	BIO_puts(out, "Testing key generation with ");	BIO_puts(out, text);	if (!EC_KEY_generate_key(a))		goto err;	printf("/n1 ) generating keys/n");	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group))			== NID_X9_62_prime_field) {		if (!EC_POINT_get_affine_coordinates_GFp(group,				EC_KEY_get0_public_key(a), x_a, y_a, ctx))			goto err;	}	//returns the public key	else {		if (!EC_POINT_get_affine_coordinates_GF2m(group,				EC_KEY_get0_public_key(a), x_a, y_a, ctx))			goto err;	}	BIO_puts(out, "  pri 1=");	BN_print(out, EC_KEY_get0_private_key(a));	BIO_puts(out, "/n  pub 1=");	BN_print(out, x_a);	BIO_puts(out, ",");	BN_print(out, y_a);	BIO_puts(out, "/n");	/*	 printf("importnt work/n");	 //BN_print(out,x_a);	 buff=BN_bn2dec(x_a);	 printf("%s/n",buff);	 BN_dec2bn(&(x_a),buff);	 printf("%s/n",buff);	 BN_print(out,x_a);	 */	/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*///.........这里部分代码省略.........

static int test_ecdh_curve(int nid, const char *text, BN_CTX *ctx, BIO *out) {	printf("in ecdh test/n");	EC_KEY *a = NULL;    //EC_KEY is a structure	EC_KEY *b = NULL;	BIGNUM *x_a = NULL, *y_a = NULL, *x_b = NULL, *y_b = NULL;	char buf[12];	unsigned char *abuf = NULL, *bbuf = NULL;	int i, alen, blen, aout, bout, ret = 0;	const EC_GROUP *group;	a = EC_KEY_new_by_curve_name(nid);// creates a new key according to the curve specified//it fills in the EC_KEY structure // use function called EC_KEY *EC_KEY_new(void)//also use a function called EC_GROUP_new_by_curve_name() creates a EC_GROUP structure specified by a curve name (in form of a NID) */// the group returned is set in the EC_KEY structure.	b = EC_KEY_new_by_curve_name(nid);	if (a == NULL || b == NULL)		goto err;	group = EC_KEY_get0_group(a); //returns the EC_GROUP structure created by the EC_KEY structure//EC_GROUP structure is present in the EC_KEY structure.	if ((x_a = BN_new()) == NULL)		goto err;	//BN_new returns a pointer to the bignum	if ((y_a = BN_new()) == NULL)		goto err;	if ((x_b = BN_new()) == NULL)		goto err;	if ((y_b = BN_new()) == NULL)		goto err;	BIO_puts(out, "Testing key generation with ");	BIO_puts(out, text);#ifdef NOISY	printf ("noisy");	BIO_puts(out,"/n");	BIO_puts(out,"/n");	BIO_puts(out,"/n");#else	BIO_flush(out);#endif//public key number one is created here	if (!EC_KEY_generate_key(a))		goto err;	//pass the filled EC_KEY structure and it will create a public or private ec key.//it places the key in a->priv_key a->pub_key   /// PUBLIC AND PVT KEYS ARE GENERATED BY THE SCALAR MULTIPLICATION	printf("/n1 ) generating keys/n");	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group))			== NID_X9_62_prime_field) {		if (!EC_POINT_get_affine_coordinates_GFp(group,				EC_KEY_get0_public_key(a), x_a, y_a, ctx))			goto err;	}	//returns the public key	else {		if (!EC_POINT_get_affine_coordinates_GF2m(group,				EC_KEY_get0_public_key(a), x_a, y_a, ctx))			goto err;	}	//BN_print_fp(stdout, a->pub_key);	printf("private key is : ");	BN_print_fp(stdout, EC_KEY_get0_private_key(a));	printf("/nAffine cordinates x:");	BN_print_fp(stdout, x_a);	printf("/nAffine cordinates y:");	BN_print_fp(stdout, y_a);	printf(			"/n2 ) generated keys , generated affine points x and y , and also determided the primse brinary case/n");#ifdef NOISY	printf("no generation");	BIO_puts(out,"  pri 1=");	BN_print(out,a->priv_key);	BIO_puts(out,"/n  pub 1=");	BN_print(out,x_a);	BIO_puts(out,",");	BN_print(out,y_a);	BIO_puts(out,"/n");#else	BIO_printf(out, " .");	BIO_flush(out);#endif//public key number two is created here	if (!EC_KEY_generate_key(b))		goto err;	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group))			== NID_X9_62_prime_field) {		if (!EC_POINT_get_affine_coordinates_GFp(group,//.........这里部分代码省略.........

//.........这里部分代码省略.........		ECerr(EC_F_SM2_DO_ENCRYPT, EC_R_ERROR);		goto end;	}	nbytes = (EC_GROUP_get_degree(group) + 7) / 8;	/* check [h]P_B != O */	if (!EC_POINT_mul(group, share_point, NULL, pub_key, h, bn_ctx)) {		SM2err(SM2_F_SM2_DO_ENCRYPT, ERR_R_EC_LIB);		goto end;	}	if (EC_POINT_is_at_infinity(group, share_point)) {		SM2err(SM2_F_SM2_DO_ENCRYPT, SM2_R_INVALID_PUBLIC_KEY);		goto end;	}	do	{		size_t size;		/* rand k in [1, n-1] */		do {			BN_rand_range(k, n);		} while (BN_is_zero(k));		/* compute ephem_point [k]G = (x1, y1) */		if (!EC_POINT_mul(group, ephem_point, k, NULL, NULL, bn_ctx)) {			SM2err(SM2_F_SM2_DO_ENCRYPT, ERR_R_EC_LIB);			goto end;		}		/* compute ECDH share_point [k]P_B = (x2, y2) */		if (!EC_POINT_mul(group, share_point, NULL, pub_key, k, bn_ctx)) {			SM2err(SM2_F_SM2_DO_ENCRYPT, ERR_R_EC_LIB);			goto end;		}		/* compute t = KDF(x2 || y2, klen) */		if (!(len = EC_POINT_point2oct(group, share_point,			POINT_CONVERSION_UNCOMPRESSED, buf, sizeof(buf), bn_ctx))) {			SM2err(SM2_F_SM2_DO_ENCRYPT, ERR_R_EC_LIB);			goto end;		}		size = cv->ciphertext->length;		kdf(buf + 1, len - 1, cv->ciphertext->data, &size);		if (size != inlen) {			SM2err(SM2_F_SM2_DO_ENCRYPT, SM2_R_KDF_FAILURE);			goto end;		}		/* ASN1_OCTET_STRING_is_zero in asn1.h and a_octet.c */	} while (ASN1_OCTET_STRING_is_zero(cv->ciphertext));	/* set x/yCoordinates as (x1, y1) */	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field) {		if (!EC_POINT_get_affine_coordinates_GFp(group, ephem_point,			cv->xCoordinate, cv->yCoordinate, bn_ctx)) {			SM2err(SM2_F_SM2_DO_ENCRYPT, ERR_R_EC_LIB);			goto end;		}	} else {		if (!EC_POINT_get_affine_coordinates_GF2m(group, ephem_point,			cv->xCoordinate, cv->yCoordinate, bn_ctx)) {			SM2err(SM2_F_SM2_DO_ENCRYPT, ERR_R_EC_LIB);			goto end;		}	}	/* ciphertext = t xor in */	for (i = 0; i < inlen; i++) {		cv->ciphertext->data[i] ^= in[i];	}	/* generate hash = Hash(x2 || M || y2) */	hashlen = cv->hash->length;	if (!EVP_DigestInit_ex(md_ctx, md, NULL)		|| !EVP_DigestUpdate(md_ctx, buf + 1, nbytes)		|| !EVP_DigestUpdate(md_ctx, in, inlen)		|| !EVP_DigestUpdate(md_ctx, buf + 1 + nbytes, nbytes)		|| !EVP_DigestFinal_ex(md_ctx, cv->hash->data, &hashlen)) {		SM2err(SM2_F_SM2_DO_ENCRYPT, ERR_R_EVP_LIB);		goto end;	}	ret = cv;	cv = NULL;end:	SM2CiphertextValue_free(cv);	EC_POINT_free(share_point);	EC_POINT_free(ephem_point);	BN_free(n);	BN_free(h);	BN_clear_free(k);	BN_CTX_free(bn_ctx);	EVP_MD_CTX_free(md_ctx);	return ret;}

//.........这里部分代码省略.........		goto err;	}		if (!EC_GROUP_get_order(group, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);		goto err;	}	if (8 * dgst_len > BN_num_bits(order))	{		/* XXX		 * 		 * Should provide for optional hash truncation:		 * Keep the BN_num_bits(order) leftmost bits of dgst		 * (see March 2006 FIPS 186-3 draft, which has a few		 * confusing errors in this part though)		 */		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY,			ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);		ret = 0;		goto err;	}	if (BN_is_zero(sig->r)          || BN_is_negative(sig->r) || 	    BN_ucmp(sig->r, order) >= 0 || BN_is_zero(sig->s)  ||	    BN_is_negative(sig->s)      || BN_ucmp(sig->s, order) >= 0)	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_BAD_SIGNATURE);		ret = 0;	/* signature is invalid */		goto err;	}	/* calculate tmp1 = inv(S) mod order */	if (!BN_mod_inverse(u2, sig->s, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	/* digest -> m */	if (!BN_bin2bn(dgst, dgst_len, m))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	/* u1 = m * tmp mod order */	if (!BN_mod_mul(u1, m, u2, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	/* u2 = r * w mod q */	if (!BN_mod_mul(u2, sig->r, u2, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	if ((point = EC_POINT_new(group)) == NULL)	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_MALLOC_FAILURE);		goto err;	}	if (!EC_POINT_mul(group, point, u1, pub_key, u2, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);		goto err;	}	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field)	{		if (!EC_POINT_get_affine_coordinates_GFp(group,			point, X, NULL, ctx))		{			ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);			goto err;		}	}	else /* NID_X9_62_characteristic_two_field */	{		if (!EC_POINT_get_affine_coordinates_GF2m(group,			point, X, NULL, ctx))		{			ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);			goto err;		}	}		if (!BN_nnmod(u1, X, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	/*  if the signature is correct u1 is equal to sig->r */	ret = (BN_ucmp(u1, sig->r) == 0);err:	BN_CTX_end(ctx);	BN_CTX_free(ctx);	if (point)		EC_POINT_free(point);	return ret;}

/*- * This implementation is based on the following primitives in the IEEE 1363 standard: *  - ECKAS-DH1 *  - ECSVDP-DH */int ecdh_simple_compute_key(unsigned char **pout, size_t *poutlen,                            const EC_POINT *pub_key, const EC_KEY *ecdh){    BN_CTX *ctx;    EC_POINT *tmp = NULL;    BIGNUM *x = NULL, *y = NULL;    const BIGNUM *priv_key;    const EC_GROUP *group;    int ret = 0;    size_t buflen, len;    unsigned char *buf = NULL;    if ((ctx = BN_CTX_new()) == NULL)        goto err;    BN_CTX_start(ctx);    x = BN_CTX_get(ctx);    y = BN_CTX_get(ctx);    priv_key = EC_KEY_get0_private_key(ecdh);    if (priv_key == NULL) {        ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, EC_R_NO_PRIVATE_VALUE);        goto err;    }    group = EC_KEY_get0_group(ecdh);    if (EC_KEY_get_flags(ecdh) & EC_FLAG_COFACTOR_ECDH) {        if (!EC_GROUP_get_cofactor(group, x, NULL) ||            !BN_mul(x, x, priv_key, ctx)) {            ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_MALLOC_FAILURE);            goto err;        }        priv_key = x;    }    if ((tmp = EC_POINT_new(group)) == NULL) {        ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_MALLOC_FAILURE);        goto err;    }    if (!EC_POINT_mul(group, tmp, NULL, pub_key, priv_key, ctx)) {        ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, EC_R_POINT_ARITHMETIC_FAILURE);        goto err;    }    if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) ==        NID_X9_62_prime_field) {        if (!EC_POINT_get_affine_coordinates_GFp(group, tmp, x, y, ctx)) {            ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, EC_R_POINT_ARITHMETIC_FAILURE);            goto err;        }    }#ifndef OPENSSL_NO_EC2M    else {        if (!EC_POINT_get_affine_coordinates_GF2m(group, tmp, x, y, ctx)) {            ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, EC_R_POINT_ARITHMETIC_FAILURE);            goto err;        }    }#endif    buflen = (EC_GROUP_get_degree(group) + 7) / 8;    len = BN_num_bytes(x);    if (len > buflen) {        ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_INTERNAL_ERROR);        goto err;    }    if ((buf = OPENSSL_malloc(buflen)) == NULL) {        ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_MALLOC_FAILURE);        goto err;    }    memset(buf, 0, buflen - len);    if (len != (size_t)BN_bn2bin(x, buf + buflen - len)) {        ECerr(EC_F_ECDH_SIMPLE_COMPUTE_KEY, ERR_R_BN_LIB);        goto err;    }    *pout = buf;    *poutlen = buflen;    buf = NULL;    ret = 1; err:    EC_POINT_free(tmp);    if (ctx)        BN_CTX_end(ctx);    BN_CTX_free(ctx);    OPENSSL_free(buf);    return ret;}

static int test_ecdh_curve(int nid, const char *text, BN_CTX *ctx, BIO *out){    EC_KEY *a = NULL;    EC_KEY *b = NULL;    BIGNUM *x_a = NULL, *y_a = NULL, *x_b = NULL, *y_b = NULL;    char buf[12];    unsigned char *abuf = NULL, *bbuf = NULL;    int i, alen, blen, aout, bout, ret = 0;    const EC_GROUP *group;    a = EC_KEY_new_by_curve_name(nid);    b = EC_KEY_new_by_curve_name(nid);    if (a == NULL || b == NULL)        goto err;    group = EC_KEY_get0_group(a);    if ((x_a = BN_new()) == NULL)        goto err;    if ((y_a = BN_new()) == NULL)        goto err;    if ((x_b = BN_new()) == NULL)        goto err;    if ((y_b = BN_new()) == NULL)        goto err;    BIO_puts(out, "Testing key generation with ");    BIO_puts(out, text);# ifdef NOISY    BIO_puts(out, "/n");# else    (void)BIO_flush(out);# endif    if (!EC_KEY_generate_key(a))        goto err;    if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) ==        NID_X9_62_prime_field) {        if (!EC_POINT_get_affine_coordinates_GFp            (group, EC_KEY_get0_public_key(a), x_a, y_a, ctx))            goto err;    }# ifndef OPENSSL_NO_EC2M    else {        if (!EC_POINT_get_affine_coordinates_GF2m(group,                                                  EC_KEY_get0_public_key(a),                                                  x_a, y_a, ctx))            goto err;    }# endif# ifdef NOISY    BIO_puts(out, "  pri 1=");    BN_print(out, a->priv_key);    BIO_puts(out, "/n  pub 1=");    BN_print(out, x_a);    BIO_puts(out, ",");    BN_print(out, y_a);    BIO_puts(out, "/n");# else    BIO_printf(out, " .");    (void)BIO_flush(out);# endif    if (!EC_KEY_generate_key(b))        goto err;    if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) ==        NID_X9_62_prime_field) {        if (!EC_POINT_get_affine_coordinates_GFp            (group, EC_KEY_get0_public_key(b), x_b, y_b, ctx))            goto err;    }# ifndef OPENSSL_NO_EC2M    else {        if (!EC_POINT_get_affine_coordinates_GF2m(group,                                                  EC_KEY_get0_public_key(b),                                                  x_b, y_b, ctx))            goto err;    }# endif# ifdef NOISY    BIO_puts(out, "  pri 2=");    BN_print(out, b->priv_key);    BIO_puts(out, "/n  pub 2=");    BN_print(out, x_b);    BIO_puts(out, ",");    BN_print(out, y_b);    BIO_puts(out, "/n");# else    BIO_printf(out, ".");    (void)BIO_flush(out);# endif    alen = KDF1_SHA1_len;    abuf = (unsigned char *)OPENSSL_malloc(alen);    aout =        ECDH_compute_key(abuf, alen, EC_KEY_get0_public_key(b), a, KDF1_SHA1);//.........这里部分代码省略.........

static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,                            BIGNUM **rp){    BN_CTX *ctx = NULL;    BIGNUM *k = NULL, *r = NULL, *order = NULL, *X = NULL;    EC_POINT *tmp_point = NULL;    const EC_GROUP *group;    int ret = 0;    int order_bits;    if (eckey == NULL || (group = EC_KEY_get0_group(eckey)) == NULL) {        ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_PASSED_NULL_PARAMETER);        return 0;    }    if (ctx_in == NULL) {        if ((ctx = BN_CTX_new()) == NULL) {            ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_MALLOC_FAILURE);            return 0;        }    } else        ctx = ctx_in;    k = BN_new();               /* this value is later returned in *kinvp */    r = BN_new();               /* this value is later returned in *rp */    order = BN_new();    X = BN_new();    if (!k || !r || !order || !X) {        ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_MALLOC_FAILURE);        goto err;    }    if ((tmp_point = EC_POINT_new(group)) == NULL) {        ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);        goto err;    }    if (!EC_GROUP_get_order(group, order, ctx)) {        ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);        goto err;    }    /* Preallocate space */    order_bits = BN_num_bits(order);    if (!BN_set_bit(k, order_bits)        || !BN_set_bit(r, order_bits)        || !BN_set_bit(X, order_bits))        goto err;    do {        /* get random k */        do            if (!BN_rand_range(k, order)) {                ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,                         ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED);                goto err;            }        while (BN_is_zero(k)) ;        /*         * We do not want timing information to leak the length of k, so we         * compute G*k using an equivalent scalar of fixed bit-length.         *         * We unconditionally perform both of these additions to prevent a         * small timing information leakage.  We then choose the sum that is         * one bit longer than the order.  This guarantees the code         * path used in the constant time implementations elsewhere.         *         * TODO: revisit the BN_copy aiming for a memory access agnostic         * conditional copy.         */        if (!BN_add(r, k, order)            || !BN_add(X, r, order)            || !BN_copy(k, BN_num_bits(r) > order_bits ? r : X))            goto err;        /* compute r the x-coordinate of generator * k */        if (!EC_POINT_mul(group, tmp_point, k, NULL, NULL, ctx)) {            ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);            goto err;        }        if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) ==            NID_X9_62_prime_field) {            if (!EC_POINT_get_affine_coordinates_GFp                (group, tmp_point, X, NULL, ctx)) {                ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);                goto err;            }        }#ifndef OPENSSL_NO_EC2M        else {                  /* NID_X9_62_characteristic_two_field */            if (!EC_POINT_get_affine_coordinates_GF2m(group,                                                      tmp_point, X, NULL,                                                      ctx)) {                ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);                goto err;            }        }#endif        if (!BN_nnmod(r, X, order, ctx)) {            ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);//.........这里部分代码省略.........

//.........这里部分代码省略.........		EC_GROUP_set_asn1_flag(group, asn1_flag);	if (no_seed) {		EC_GROUP_set_seed(group, NULL, 0);	}	if (text) {		if (!ECPKParameters_print(out, group, 0))			goto end;	}	if (check) {		if (group == NULL)			BIO_printf(bio_err, "no elliptic curve parameters/n");		BIO_printf(bio_err, "checking elliptic curve parameters: ");		if (!EC_GROUP_check(group, NULL)) {			BIO_printf(bio_err, "failed/n");			ERR_print_errors(bio_err);		} else			BIO_printf(bio_err, "ok/n");	}	if (C) {		size_t buf_len = 0, tmp_len = 0;		const EC_POINT *point;		int is_prime, len = 0;		const EC_METHOD *meth = EC_GROUP_method_of(group);		if ((ec_p = BN_new()) == NULL || (ec_a = BN_new()) == NULL ||		    (ec_b = BN_new()) == NULL || (ec_gen = BN_new()) == NULL ||		    (ec_order = BN_new()) == NULL ||		    (ec_cofactor = BN_new()) == NULL) {			perror("malloc");			goto end;		}		is_prime = (EC_METHOD_get_field_type(meth) ==		    NID_X9_62_prime_field);		if (is_prime) {			if (!EC_GROUP_get_curve_GFp(group, ec_p, ec_a,				ec_b, NULL))				goto end;		} else {			/* TODO */			goto end;		}		if ((point = EC_GROUP_get0_generator(group)) == NULL)			goto end;		if (!EC_POINT_point2bn(group, point,			EC_GROUP_get_point_conversion_form(group), ec_gen,			NULL))			goto end;		if (!EC_GROUP_get_order(group, ec_order, NULL))			goto end;		if (!EC_GROUP_get_cofactor(group, ec_cofactor, NULL))			goto end;		if (!ec_p || !ec_a || !ec_b || !ec_gen ||		    !ec_order || !ec_cofactor)			goto end;		len = BN_num_bits(ec_order);		if ((tmp_len = (size_t) BN_num_bytes(ec_p)) > buf_len)			buf_len = tmp_len;		if ((tmp_len = (size_t) BN_num_bytes(ec_a)) > buf_len)			buf_len = tmp_len;

int ECPKParameters_print(BIO * bp, const EC_GROUP * x, int off){	unsigned char *buffer = NULL;	size_t buf_len = 0, i;	int ret = 0, reason = ERR_R_BIO_LIB;	BN_CTX *ctx = NULL;	const EC_POINT *point = NULL;	BIGNUM *p = NULL, *a = NULL, *b = NULL, *gen = NULL, *order = NULL,	*cofactor = NULL;	const unsigned char *seed;	size_t seed_len = 0;	const char *nname;	static const char *gen_compressed = "Generator (compressed):";	static const char *gen_uncompressed = "Generator (uncompressed):";	static const char *gen_hybrid = "Generator (hybrid):";	if (!x) {		reason = ERR_R_PASSED_NULL_PARAMETER;		goto err;	}	ctx = BN_CTX_new();	if (ctx == NULL) {		reason = ERR_R_MALLOC_FAILURE;		goto err;	}	if (EC_GROUP_get_asn1_flag(x)) {		/* the curve parameter are given by an asn1 OID */		int nid;		if (!BIO_indent(bp, off, 128))			goto err;		nid = EC_GROUP_get_curve_name(x);		if (nid == 0)			goto err;		if (BIO_printf(bp, "ASN1 OID: %s", OBJ_nid2sn(nid)) <= 0)			goto err;		if (BIO_printf(bp, "/n") <= 0)			goto err;		nname = EC_curve_nid2nist(nid);		if (nname) {			if (!BIO_indent(bp, off, 128))				goto err;			if (BIO_printf(bp, "NIST CURVE: %s/n", nname) <= 0)				goto err;		}	} else {		/* explicit parameters */		int is_char_two = 0;		point_conversion_form_t form;		int tmp_nid = EC_METHOD_get_field_type(EC_GROUP_method_of(x));		if (tmp_nid == NID_X9_62_characteristic_two_field)			is_char_two = 1;		if ((p = BN_new()) == NULL || (a = BN_new()) == NULL ||		    (b = BN_new()) == NULL || (order = BN_new()) == NULL ||		    (cofactor = BN_new()) == NULL) {			reason = ERR_R_MALLOC_FAILURE;			goto err;		}#ifndef OPENSSL_NO_EC2M		if (is_char_two) {			if (!EC_GROUP_get_curve_GF2m(x, p, a, b, ctx)) {				reason = ERR_R_EC_LIB;				goto err;			}		} else		/* prime field */#endif		{			if (!EC_GROUP_get_curve_GFp(x, p, a, b, ctx)) {				reason = ERR_R_EC_LIB;				goto err;			}		}		if ((point = EC_GROUP_get0_generator(x)) == NULL) {			reason = ERR_R_EC_LIB;			goto err;		}		if (!EC_GROUP_get_order(x, order, NULL) ||		    !EC_GROUP_get_cofactor(x, cofactor, NULL)) {			reason = ERR_R_EC_LIB;			goto err;		}		form = EC_GROUP_get_point_conversion_form(x);		if ((gen = EC_POINT_point2bn(x, point,			    form, NULL, ctx)) == NULL) {			reason = ERR_R_EC_LIB;			goto err;		}		buf_len = (size_t) BN_num_bytes(p);		if (buf_len < (i = (size_t) BN_num_bytes(a)))			buf_len = i;		if (buf_len < (i = (size_t) BN_num_bytes(b)))//.........这里部分代码省略.........

static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len,		const ECDSA_SIG *sig, EC_KEY *eckey){	int ret = -1, i;	BN_CTX   *ctx;	BIGNUM   *order, *u1, *u2, *m, *X;	EC_POINT *point = NULL;	const EC_GROUP *group;	const EC_POINT *pub_key;	/* check input values */	if (eckey == NULL || (group = EC_KEY_get0_group(eckey)) == NULL ||	    (pub_key = EC_KEY_get0_public_key(eckey)) == NULL || sig == NULL)	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_MISSING_PARAMETERS);		return -1;	}	ctx = BN_CTX_new();	if (!ctx)	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_MALLOC_FAILURE);		return -1;	}	BN_CTX_start(ctx);	order = BN_CTX_get(ctx);		u1    = BN_CTX_get(ctx);	u2    = BN_CTX_get(ctx);	m     = BN_CTX_get(ctx);	X     = BN_CTX_get(ctx);	if (!X)	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}		if (!EC_GROUP_get_order(group, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);		goto err;	}	if (BN_is_zero(sig->r)          || BN_is_negative(sig->r) || 	    BN_ucmp(sig->r, order) >= 0 || BN_is_zero(sig->s)  ||	    BN_is_negative(sig->s)      || BN_ucmp(sig->s, order) >= 0)	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_BAD_SIGNATURE);		ret = 0;	/* signature is invalid */		goto err;	}	/* calculate tmp1 = inv(S) mod order */	if (!BN_mod_inverse(u2, sig->s, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	/* digest -> m */	i = BN_num_bits(order);	/* Need to truncate digest if it is too long: first truncate whole	 * bytes.	 */	if (8 * dgst_len > i)		dgst_len = (i + 7)/8;	if (!BN_bin2bn(dgst, dgst_len, m))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	/* If still too long truncate remaining bits with a shift */	if ((8 * dgst_len > i) && !BN_rshift(m, m, 8 - (i & 0x7)))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	/* u1 = m * tmp mod order */	if (!BN_mod_mul(u1, m, u2, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	/* u2 = r * w mod q */	if (!BN_mod_mul(u2, sig->r, u2, order, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);		goto err;	}	if ((point = EC_POINT_new(group)) == NULL)	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_MALLOC_FAILURE);		goto err;	}	if (!EC_POINT_mul(group, point, u1, pub_key, u2, ctx))	{		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);		goto err;	}	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field)	{		if (!EC_POINT_get_affine_coordinates_GFp(group,//.........这里部分代码省略.........

builtin_curves::builtin_curves(){	int i, num_curves = EC_get_builtin_curves(NULL, 0);	EC_builtin_curve *curves = (EC_builtin_curve*)OPENSSL_malloc(		(int)(sizeof(EC_builtin_curve) *num_curves));	check_oom(curves);	BIGNUM *order = BN_new();	check_oom(order);	EC_get_builtin_curves(curves, num_curves);	for (i=0; i< num_curves; i++) {		size_t j;		int flag = 0, nid = curves[i].nid;		unsigned long type = 0;		for (j=0; j<ARRAY_SIZE(x962_curve_nids); j++) {			if (x962_curve_nids[j] == nid) {				flag = CURVE_X962;				break;			}		}		if (!flag) {			for (j=0; j<ARRAY_SIZE(other_curve_nids); j++) {				if (other_curve_nids[j] == nid) {					flag = CURVE_OTHER;					break;				}			}		}		if (!flag)			continue;		EC_GROUP *group = EC_GROUP_new_by_curve_name(nid);		EC_GROUP_get_order(group, order, NULL);		switch (EC_METHOD_get_field_type(EC_GROUP_method_of(group))) {		case NID_X9_62_prime_field:			type = CKF_EC_F_P;			break;		case NID_X9_62_characteristic_two_field:			type = CKF_EC_F_2M;			break;		default:			continue;		}#undef PRINT_KNOWN_CURVES#ifdef PRINT_KNOWN_CURVES		fprintf(stderr, "%50s %27s %20s %s/n",			curves[i].comment, OBJ_nid2sn(nid),			CCHAR(OBJ_obj2QString(OBJ_nid2obj(nid), 1)),			type == CKF_EC_F_P ? "Fp" : "F2m");#endif		append(builtin_curve(nid, QString(curves[i].comment),			BN_num_bits(order), flag, type));                EC_GROUP_free(group);	}	BN_free(order);}

int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx){    int r = 0;    BIGNUM *a1, *a2, *a3, *b1, *b2, *b3;    BN_CTX *ctx_new = NULL;    /* compare the field types */    if (EC_METHOD_get_field_type(EC_GROUP_method_of(a)) !=        EC_METHOD_get_field_type(EC_GROUP_method_of(b)))        return 1;    /* compare the curve name (if present in both) */    if (EC_GROUP_get_curve_name(a) && EC_GROUP_get_curve_name(b) &&        EC_GROUP_get_curve_name(a) != EC_GROUP_get_curve_name(b))        return 1;    if (a->meth->flags & EC_FLAGS_CUSTOM_CURVE)        return 0;    if (ctx == NULL)        ctx_new = ctx = BN_CTX_new();    if (ctx == NULL)        return -1;    BN_CTX_start(ctx);    a1 = BN_CTX_get(ctx);    a2 = BN_CTX_get(ctx);    a3 = BN_CTX_get(ctx);    b1 = BN_CTX_get(ctx);    b2 = BN_CTX_get(ctx);    b3 = BN_CTX_get(ctx);    if (b3 == NULL) {        BN_CTX_end(ctx);        BN_CTX_free(ctx_new);        return -1;    }    /*     * XXX This approach assumes that the external representation of curves     * over the same field type is the same.     */    if (!a->meth->group_get_curve(a, a1, a2, a3, ctx) ||        !b->meth->group_get_curve(b, b1, b2, b3, ctx))        r = 1;    if (r || BN_cmp(a1, b1) || BN_cmp(a2, b2) || BN_cmp(a3, b3))        r = 1;    /* XXX EC_POINT_cmp() assumes that the methods are equal */    if (r || EC_POINT_cmp(a, EC_GROUP_get0_generator(a),                          EC_GROUP_get0_generator(b), ctx))        r = 1;    if (!r) {        const BIGNUM *ao, *bo, *ac, *bc;        /* compare the order and cofactor */        ao = EC_GROUP_get0_order(a);        bo = EC_GROUP_get0_order(b);        ac = EC_GROUP_get0_cofactor(a);        bc = EC_GROUP_get0_cofactor(b);        if (ao == NULL || bo == NULL) {            BN_CTX_end(ctx);            BN_CTX_free(ctx_new);            return -1;        }        if (BN_cmp(ao, bo) || BN_cmp(ac, bc))            r = 1;    }    BN_CTX_end(ctx);    BN_CTX_free(ctx_new);    return r;}

/* k in [1, n-1], (x, y) = kG */static int sm2_sign_setup(EC_KEY *ec_key, BN_CTX *ctx_in, BIGNUM **kp, BIGNUM **xp){	int ret = 0;	const EC_GROUP *ec_group;	BN_CTX *ctx = NULL;	BIGNUM *k = NULL;	BIGNUM *x = NULL;	BIGNUM *order = NULL;	EC_POINT *point = NULL;	if (ec_key == NULL || (ec_group = EC_KEY_get0_group(ec_key)) == NULL) {		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_PASSED_NULL_PARAMETER);		return 0;	}	if (ctx_in == NULL)  {		if ((ctx = BN_CTX_new()) == NULL) {			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_MALLOC_FAILURE);			return 0;		}	}	else {		ctx = ctx_in;	}	k = BN_new();		x = BN_new();	order = BN_new();	if (!k || !x || !order) {		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_MALLOC_FAILURE);		goto err;	}	if (!EC_GROUP_get_order(ec_group, order, ctx)) {		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);		goto err;	}	if ((point = EC_POINT_new(ec_group)) == NULL) {		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);		goto err;	}	do {		/* get random k */			do {			if (!BN_rand_range(k, order)) {				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,					ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED);					goto err;			}		} while (BN_is_zero(k));		/* compute r the x-coordinate of generator * k */		if (!EC_POINT_mul(ec_group, point, k, NULL, NULL, ctx)) {			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);			goto err;		}		if (EC_METHOD_get_field_type(EC_GROUP_method_of(ec_group)) == NID_X9_62_prime_field) {			if (!EC_POINT_get_affine_coordinates_GFp(ec_group, point, x, NULL, ctx)) {				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_EC_LIB);				goto err;			}		} else /* NID_X9_62_characteristic_two_field */ {			if (!EC_POINT_get_affine_coordinates_GF2m(ec_group, point, x, NULL, ctx)) {				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_EC_LIB);				goto err;			}		}		//FIXME: do we need this?		if (!BN_nnmod(x, x, order, ctx)) {			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);			goto err;		}	} while (BN_is_zero(x));	/* clear old values if necessary */	if (*kp != NULL)		BN_clear_free(*kp);	if (*xp != NULL)		BN_clear_free(*xp);	/* save the pre-computed values  */	*kp = k;	*xp = x;	ret = 1;err:	if (!ret) {		if (k) BN_clear_free(k);		if (x) BN_clear_free(x);	}	if (ctx_in == NULL) BN_CTX_free(ctx);	if (order) BN_free(order);	if (point) EC_POINT_free(point);//.........这里部分代码省略.........