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

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_GROUP_method_of(group)->group_set_curve !=        ec_GF2m_simple_group_set_curve || !((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_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;}

EC_KEY *EC_KEY_copy(EC_KEY * dest, const EC_KEY * src){	EC_EXTRA_DATA *d;	if (dest == NULL || src == NULL) {		ECerr(EC_F_EC_KEY_COPY, ERR_R_PASSED_NULL_PARAMETER);		return NULL;	}	/* copy the parameters */	if (src->group) {		const EC_METHOD *meth = EC_GROUP_method_of(src->group);		/* clear the old group */		EC_GROUP_free(dest->group);		dest->group = EC_GROUP_new(meth);		if (dest->group == NULL)			return NULL;		if (!EC_GROUP_copy(dest->group, src->group))			return NULL;	}	/* copy the public key */	if (src->pub_key && src->group) {		EC_POINT_free(dest->pub_key);		dest->pub_key = EC_POINT_new(src->group);		if (dest->pub_key == NULL)			return NULL;		if (!EC_POINT_copy(dest->pub_key, src->pub_key))			return NULL;	}	/* copy the private key */	if (src->priv_key) {		if (dest->priv_key == NULL) {			dest->priv_key = BN_new();			if (dest->priv_key == NULL)				return NULL;		}		if (!BN_copy(dest->priv_key, src->priv_key))			return NULL;	}	/* copy method/extra data */	EC_EX_DATA_free_all_data(&dest->method_data);	for (d = src->method_data; d != NULL; d = d->next) {		void *t = d->dup_func(d->data);		if (t == NULL)			return 0;		if (!EC_EX_DATA_set_data(&dest->method_data, t, d->dup_func,		    d->free_func, d->clear_free_func))			return 0;	}	/* copy the rest */	dest->enc_flag = src->enc_flag;	dest->conv_form = src->conv_form;	dest->version = src->version;	dest->flags = src->flags;	return dest;}

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_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;}

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) //.........这里部分代码省略.........

//.........这里部分代码省略.........		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;}

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,//.........这里部分代码省略.........

/*- * 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 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))//.........这里部分代码省略.........

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;	}

EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src){    if (dest == NULL || src == NULL) {        ECerr(EC_F_EC_KEY_COPY, ERR_R_PASSED_NULL_PARAMETER);        return NULL;    }    if (src->meth != dest->meth) {        if (dest->meth->finish != NULL)            dest->meth->finish(dest);        if (dest->group && dest->group->meth->keyfinish)            dest->group->meth->keyfinish(dest);#ifndef OPENSSL_NO_ENGINE        if (ENGINE_finish(dest->engine) == 0)            return 0;        dest->engine = NULL;#endif    }    /* copy the parameters */    if (src->group != NULL) {        const EC_METHOD *meth = EC_GROUP_method_of(src->group);        /* clear the old group */        EC_GROUP_free(dest->group);        dest->group = EC_GROUP_new(meth);        if (dest->group == NULL)            return NULL;        if (!EC_GROUP_copy(dest->group, src->group))            return NULL;        /*  copy the public key */        if (src->pub_key != NULL) {            EC_POINT_free(dest->pub_key);            dest->pub_key = EC_POINT_new(src->group);            if (dest->pub_key == NULL)                return NULL;            if (!EC_POINT_copy(dest->pub_key, src->pub_key))                return NULL;        }        /* copy the private key */        if (src->priv_key != NULL) {            if (dest->priv_key == NULL) {                dest->priv_key = BN_new();                if (dest->priv_key == NULL)                    return NULL;            }            if (!BN_copy(dest->priv_key, src->priv_key))                return NULL;            if (src->group->meth->keycopy                && src->group->meth->keycopy(dest, src) == 0)                return NULL;        }    }    /* copy the rest */    dest->enc_flag = src->enc_flag;    dest->conv_form = src->conv_form;    dest->version = src->version;    dest->flags = src->flags;    if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_EC_KEY,                            &dest->ex_data, &src->ex_data))        return NULL;    if (src->meth != dest->meth) {#ifndef OPENSSL_NO_ENGINE        if (src->engine != NULL && ENGINE_init(src->engine) == 0)            return NULL;        dest->engine = src->engine;#endif        dest->meth = src->meth;    }    if (src->meth->copy != NULL && src->meth->copy(dest, src) == 0)        return NULL;    return dest;}

/* * 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))//.........这里部分代码省略.........

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;}

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 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_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);//.........这里部分代码省略.........

//.........这里部分代码省略.........    }    if (new_form)        EC_GROUP_set_point_conversion_form(group, form);    if (new_asn1_flag)        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("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)

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);//.........这里部分代码省略.........

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;}

void char2_field_tests()	{		BN_CTX *ctx = NULL;	BIGNUM *p, *a, *b;	EC_GROUP *group;	EC_GROUP *C2_K163 = NULL, *C2_K233 = NULL, *C2_K283 = NULL, *C2_K409 = NULL, *C2_K571 = NULL;	EC_GROUP *C2_B163 = NULL, *C2_B233 = NULL, *C2_B283 = NULL, *C2_B409 = NULL, *C2_B571 = NULL;	EC_POINT *P, *Q, *R;	BIGNUM *x, *y, *z, *cof;	unsigned char buf[100];	size_t i, len;	int k;	#if 1 /* optional */	ctx = BN_CTX_new();	if (!ctx) ABORT;#endif	p = BN_new();	a = BN_new();	b = BN_new();	if (!p || !a || !b) ABORT;	if (!BN_hex2bn(&p, "13")) ABORT;	if (!BN_hex2bn(&a, "3")) ABORT;	if (!BN_hex2bn(&b, "1")) ABORT;		group = EC_GROUP_new(EC_GF2m_simple_method()); /* applications should use EC_GROUP_new_curve_GF2m	                                                * so that the library gets to choose the EC_METHOD */	if (!group) ABORT;	if (!EC_GROUP_set_curve_GF2m(group, p, a, b, ctx)) ABORT;	{		EC_GROUP *tmp;		tmp = EC_GROUP_new(EC_GROUP_method_of(group));		if (!tmp) ABORT;		if (!EC_GROUP_copy(tmp, group)) ABORT;		EC_GROUP_free(group);		group = tmp;	}		if (!EC_GROUP_get_curve_GF2m(group, p, a, b, ctx)) ABORT;	fprintf(stdout, "Curve defined by Weierstrass equation/n     y^2 + x*y = x^3 + a*x^2 + b  (mod 0x");	BN_print_fp(stdout, p);	fprintf(stdout, ")/n     a = 0x");	BN_print_fp(stdout, a);	fprintf(stdout, "/n     b = 0x");	BN_print_fp(stdout, b);	fprintf(stdout, "/n(0x... means binary polynomial)/n");	P = EC_POINT_new(group);	Q = EC_POINT_new(group);	R = EC_POINT_new(group);	if (!P || !Q || !R) ABORT;		if (!EC_POINT_set_to_infinity(group, P)) ABORT;	if (!EC_POINT_is_at_infinity(group, P)) ABORT;	buf[0] = 0;	if (!EC_POINT_oct2point(group, Q, buf, 1, ctx)) ABORT;	if (!EC_POINT_add(group, P, P, Q, ctx)) ABORT;	if (!EC_POINT_is_at_infinity(group, P)) ABORT;	x = BN_new();	y = BN_new();	z = BN_new();	cof = BN_new();	if (!x || !y || !z || !cof) ABORT;	if (!BN_hex2bn(&x, "6")) ABORT;/* Change test based on whether binary point compression is enabled or not. */#ifdef OPENSSL_EC_BIN_PT_COMP	if (!EC_POINT_set_compressed_coordinates_GF2m(group, Q, x, 1, ctx)) ABORT;#else	if (!BN_hex2bn(&y, "8")) ABORT;	if (!EC_POINT_set_affine_coordinates_GF2m(group, Q, x, y, ctx)) ABORT;#endif	if (!EC_POINT_is_on_curve(group, Q, ctx))		{/* Change test based on whether binary point compression is enabled or not. */#ifdef OPENSSL_EC_BIN_PT_COMP		if (!EC_POINT_get_affine_coordinates_GF2m(group, Q, x, y, ctx)) ABORT;#endif		fprintf(stderr, "Point is not on curve: x = 0x");		BN_print_fp(stderr, x);		fprintf(stderr, ", y = 0x");		BN_print_fp(stderr, y);		fprintf(stderr, "/n");		ABORT;		}	fprintf(stdout, "A cyclic subgroup:/n");	k = 100;	do		{		if (k-- == 0) ABORT;		if (EC_POINT_is_at_infinity(group, P))//.........这里部分代码省略.........

//.........这里部分代码省略.........		BIO_printf(bio_err,		    "unable to load elliptic curve parameters/n");		ERR_print_errors(bio_err);		goto end;	}	if (new_form)		EC_GROUP_set_point_conversion_form(group, form);	if (new_asn1_flag)		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 ||

/* 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_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,//.........这里部分代码省略.........

	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 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;        }    }//.........这里部分代码省略.........

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;}