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

static EC_KEY *pkcs11_get_ec(PKCS11_KEY *key){	EC_KEY *ec;	int no_params, no_point;	ec = EC_KEY_new();	if (ec == NULL)		return NULL;	/* For OpenSSL req we need at least the	 * EC_KEY_get0_group(ec_key)) to return the group.	 * Continue even if it fails, as the sign operation does not need	 * it if the PKCS#11 module or the hardware can figure this out	 */	no_params = pkcs11_get_params(ec, key);	no_point = pkcs11_get_point_key(ec, key);	if (no_point && key->isPrivate) /* Retry with the public key */		no_point = pkcs11_get_point_key(ec, pkcs11_find_key_from_key(key));	if (no_point && key->isPrivate) /* Retry with the certificate */		no_point = pkcs11_get_point_cert(ec, pkcs11_find_certificate(key));	if (key->isPrivate && EC_KEY_get0_private_key(ec) == NULL) {		BIGNUM *bn = BN_new();		EC_KEY_set_private_key(ec, bn);		BN_free(bn);	}	/* A public keys requires both the params and the point to be present */	if (!key->isPrivate && (no_params || no_point)) {		EC_KEY_free(ec);		return NULL;	}	return ec;}

// Setters for the GOST private key componentsvoid OSSLGOSTPrivateKey::setD(const ByteString& d){	GOSTPrivateKey::setD(d);	EC_KEY* ec = (EC_KEY*) EVP_PKEY_get0((EVP_PKEY*) pkey);	if (ec == NULL)	{		ByteString der = dummyKey;		const unsigned char *p = &der[0];		if (d2i_PrivateKey(NID_id_GostR3410_2001, &pkey, &p, (long) der.size()) == NULL)		{			ERROR_MSG("d2i_PrivateKey failed");			return;		}		ec = (EC_KEY*) EVP_PKEY_get0((EVP_PKEY*) pkey);	}	const BIGNUM* priv = OSSL::byteString2bn(d);	if (EC_KEY_set_private_key(ec, priv) <= 0)	{		ERROR_MSG("EC_KEY_set_private_key failed");		return;	}#ifdef notyet	if (gost2001_compute_public(ec) <= 0)		ERROR_MSG("gost2001_compute_public failed");#endif		}

/*! * /brief Create ECDSA private key from key parameters. * /see rsa_create_pkey */static int ecdsa_create_pkey(const knot_key_params_t *params, EVP_PKEY *key){	assert(key);	int curve;	if (params->algorithm == KNOT_DNSSEC_ALG_ECDSAP256SHA256) {		curve = NID_X9_62_prime256v1; // == secp256r1	} else if (params->algorithm == KNOT_DNSSEC_ALG_ECDSAP384SHA384) {		curve = NID_secp384r1;	} else {		return KNOT_DNSSEC_ENOTSUP;	}	EC_KEY *ec_key = EC_KEY_new_by_curve_name(curve);	if (ec_key == NULL)		return KNOT_ENOMEM;	EC_KEY_set_private_key(ec_key, knot_b64_to_bignum(params->private_key));	// EC_KEY_check_key() could be added, but fails without public key	if (!EVP_PKEY_assign_EC_KEY(key, ec_key)) {		EC_KEY_free(ec_key);		return KNOT_DNSSEC_EASSIGN_KEY;	}	return KNOT_EOK;}

static EC_KEY *self_test_ecdsa_key(void) {  static const uint8_t kQx[] = {      0xc8, 0x15, 0x61, 0xec, 0xf2, 0xe5, 0x4e, 0xde, 0xfe, 0x66, 0x17,      0xdb, 0x1c, 0x7a, 0x34, 0xa7, 0x07, 0x44, 0xdd, 0xb2, 0x61, 0xf2,      0x69, 0xb8, 0x3d, 0xac, 0xfc, 0xd2, 0xad, 0xe5, 0xa6, 0x81,  };  static const uint8_t kQy[] = {      0xe0, 0xe2, 0xaf, 0xa3, 0xf9, 0xb6, 0xab, 0xe4, 0xc6, 0x98, 0xef,      0x64, 0x95, 0xf1, 0xbe, 0x49, 0xa3, 0x19, 0x6c, 0x50, 0x56, 0xac,      0xb3, 0x76, 0x3f, 0xe4, 0x50, 0x7e, 0xec, 0x59, 0x6e, 0x88,  };  static const uint8_t kD[] = {      0xc6, 0xc1, 0xaa, 0xda, 0x15, 0xb0, 0x76, 0x61, 0xf8, 0x14, 0x2c,      0x6c, 0xaf, 0x0f, 0xdb, 0x24, 0x1a, 0xff, 0x2e, 0xfe, 0x46, 0xc0,      0x93, 0x8b, 0x74, 0xf2, 0xbc, 0xc5, 0x30, 0x52, 0xb0, 0x77,  };  EC_KEY *ec_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);  BIGNUM *qx = BN_bin2bn(kQx, sizeof(kQx), NULL);  BIGNUM *qy = BN_bin2bn(kQy, sizeof(kQy), NULL);  BIGNUM *d = BN_bin2bn(kD, sizeof(kD), NULL);  if (ec_key == NULL || qx == NULL || qy == NULL || d == NULL ||      !EC_KEY_set_public_key_affine_coordinates(ec_key, qx, qy) ||      !EC_KEY_set_private_key(ec_key, d)) {    EC_KEY_free(ec_key);    ec_key = NULL;  }  BN_free(qx);  BN_free(qy);  BN_free(d);  return ec_key;}

// Setters for the GOST private key componentsvoid OSSLGOSTPrivateKey::setD(const ByteString& inD){	GOSTPrivateKey::setD(inD);	EC_KEY* inEC = (EC_KEY*) EVP_PKEY_get0((EVP_PKEY*) pkey);	if (inEC == NULL)	{		const unsigned char* p = dummyKey;		if (d2i_PrivateKey(NID_id_GostR3410_2001, &pkey, &p, (long) sizeof(dummyKey)) == NULL)		{			ERROR_MSG("d2i_PrivateKey failed");			return;		}		inEC = (EC_KEY*) EVP_PKEY_get0((EVP_PKEY*) pkey);	}	const BIGNUM* priv = OSSL::byteString2bn(inD);	if (EC_KEY_set_private_key(inEC, priv) <= 0)	{		ERROR_MSG("EC_KEY_set_private_key failed");		return;	}	BN_clear_free((BIGNUM*)priv);#ifdef notyet	if (gost2001_compute_public(inEC) <= 0)		ERROR_MSG("gost2001_compute_public failed");#endif}

static int key_regenerate(struct key *k, const BIGNUM *bn) {  const EC_GROUP *grp;  EC_KEY *key = k->key;  EC_POINT *pub_key;  BN_CTX *ctx;  int res;  ASSERT(key);  grp = EC_KEY_get0_group(key);  ctx = BN_CTX_new();  ASSERT(grp);  ASSERT(ctx);  pub_key = EC_POINT_new(grp);  ASSERT(pub_key);  res = EC_POINT_mul(grp, pub_key, bn, NULL, NULL, ctx);  ASSERT(res == 1);  res = EC_KEY_set_private_key(key, bn);  ASSERT(res == 1);  res = EC_KEY_set_public_key(key, pub_key);  ASSERT(res == 1);  EC_POINT_free(pub_key);  BN_CTX_free(ctx);  return EC_KEY_check_key(k->key);}

static EC_KEY *mk_eckey(int nid, const unsigned char *p, size_t plen){    int ok = 0;    EC_KEY *k = NULL;    BIGNUM *priv = NULL;    EC_POINT *pub = NULL;    const EC_GROUP *grp;    k = EC_KEY_new_by_curve_name(nid);    if (!k)        goto err;    priv = BN_bin2bn(p, plen, NULL);    if (!priv)        goto err;    if (!EC_KEY_set_private_key(k, priv))        goto err;    grp = EC_KEY_get0_group(k);    pub = EC_POINT_new(grp);    if (!pub)        goto err;    if (!EC_POINT_mul(grp, pub, priv, NULL, NULL, NULL))        goto err;    if (!EC_KEY_set_public_key(k, pub))        goto err;    ok = 1; err:    if (priv)        BN_clear_free(priv);    if (pub)        EC_POINT_free(pub);    if (ok)        return k;    else if (k)        EC_KEY_free(k);    return NULL;}

static EC_KEY *mk_eckey(int nid, const char *str){    int ok = 0;    EC_KEY *k = NULL;    BIGNUM *priv = NULL;    EC_POINT *pub = NULL;    const EC_GROUP *grp;    k = EC_KEY_new_by_curve_name(nid);    if (!k)        goto err;    if(!BN_hex2bn(&priv, str))        goto err;    if (!priv)        goto err;    if (!EC_KEY_set_private_key(k, priv))        goto err;    grp = EC_KEY_get0_group(k);    pub = EC_POINT_new(grp);    if (!pub)        goto err;    if (!EC_POINT_mul(grp, pub, priv, NULL, NULL, NULL))        goto err;    if (!EC_KEY_set_public_key(k, pub))        goto err;    ok = 1; err:    BN_clear_free(priv);    EC_POINT_free(pub);    if (ok)        return k;    EC_KEY_free(k);    return NULL;}

		// Generate a private key from just the secret parameter		bool EC_KEY_regenerate_key(EC_KEY *eckey, BIGNUM *priv_key)		{			bool success = false;			BN_CTX *ctx = nullptr;			EC_POINT *pub_key = nullptr;			if (!eckey)				return 0;			const EC_GROUP *group = EC_KEY_get0_group(eckey);			ctx = BN_CTX_new();			if (!ctx)				goto error;			pub_key = EC_POINT_new(group);			if (!pub_key)				goto error;			if (!EC_POINT_mul(group, pub_key, priv_key, nullptr, nullptr, ctx))				goto error;			EC_KEY_set_private_key(eckey, priv_key);			EC_KEY_set_public_key(eckey, pub_key);			success = true;		error:			if (pub_key)				EC_POINT_free(pub_key);			if (ctx)				BN_CTX_free(ctx);			return success;		}

static int gost_set_priv_key(EVP_PKEY *pkey,BIGNUM *priv) 	{	switch (EVP_PKEY_base_id(pkey)) 		{		case NID_id_GostR3410_94:		{		DSA *dsa = EVP_PKEY_get0(pkey);		if (!dsa) 			{			dsa = DSA_new();			EVP_PKEY_assign(pkey,EVP_PKEY_base_id(pkey),dsa);			}			dsa->priv_key = BN_dup(priv);		if (!EVP_PKEY_missing_parameters(pkey)) 			gost94_compute_public(dsa);		break;		}			case NID_id_GostR3410_2001:		{		EC_KEY *ec = EVP_PKEY_get0(pkey);		if (!ec) 			{			ec = EC_KEY_new();			EVP_PKEY_assign(pkey,EVP_PKEY_base_id(pkey),ec);			}			if (!EC_KEY_set_private_key(ec,priv)) return 0;		if (!EVP_PKEY_missing_parameters(pkey)) 			gost2001_compute_public(ec);		break;		}		}	return 1;			}

// Generate a private key from just the secret parameterint EC_KEY_regenerate_key(EC_KEY *eckey, BIGNUM *priv_key){    int ok = 0;    BN_CTX *ctx = NULL;    EC_POINT *pub_key = NULL;    if (!eckey) return 0;    const EC_GROUP *group = EC_KEY_get0_group(eckey);    if ((ctx = BN_CTX_new()) == NULL)        goto err;    pub_key = EC_POINT_new(group);    if (pub_key == NULL)        goto err;    if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, ctx))        goto err;    EC_KEY_set_private_key(eckey,priv_key);    EC_KEY_set_public_key(eckey,pub_key);    ok = 1;err:    if (pub_key)        EC_POINT_free(pub_key);    if (ctx != NULL)        BN_CTX_free(ctx);    return(ok);}

/* * * Generates GOST R 34.10-2001 keypair * * */int gost2001_keygen(EC_KEY *ec){    BIGNUM *order = BN_new(), *d = BN_new();    const EC_GROUP *group = EC_KEY_get0_group(ec);    if (!group || !EC_GROUP_get_order(group, order, NULL)) {        GOSTerr(GOST_F_GOST2001_KEYGEN, ERR_R_INTERNAL_ERROR);        BN_free(d);        BN_free(order);        return 0;    }    do {        if (!BN_rand_range(d, order)) {            GOSTerr(GOST_F_GOST2001_KEYGEN,                    GOST_R_RANDOM_NUMBER_GENERATOR_FAILED);            BN_free(d);            BN_free(order);            return 0;        }    }    while (BN_is_zero(d));    if (!EC_KEY_set_private_key(ec, d)) {        GOSTerr(GOST_F_GOST2001_KEYGEN, ERR_R_INTERNAL_ERROR);        BN_free(d);        BN_free(order);        return 0;    }    BN_free(d);    BN_free(order);    return gost2001_compute_public(ec);}

/* Interpret the 256 bits in buf as a private key and return an EC_KEY *. */static EC_KEY *generate_key_from_buffer(const unsigned char buf[32]){    EC_KEY *key;    BIGNUM *bn;    int rc;    key = NULL;    bn = NULL;    key = EC_KEY_new_by_curve_name(EC_GROUP_NID);    if (key == NULL)        goto err;    bn = BN_bin2bn(buf, 32, NULL);    if (bn == NULL)        goto err;    rc = EC_KEY_set_private_key(key, bn);    if (rc != 1)        goto err;    BN_free(bn);    return key;err:    if (key != NULL)        EC_KEY_free(key);    if (bn != NULL)        BN_free(bn);    return NULL;}

// Setters for the EC private key componentsvoid OSSLECPrivateKey::setD(const ByteString& inD){	ECPrivateKey::setD(inD);	BIGNUM* pk = OSSL::byteString2bn(inD);	EC_KEY_set_private_key(eckey, pk);	BN_clear_free(pk);}

static int EC_KEY_generate_key_part(EC_KEY *eckey){  int ok = 0;  BN_CTX  *ctx = NULL;  BIGNUM  *priv_key = NULL, *order = NULL;  EC_POINT *pub_key = NULL;  const EC_GROUP *group;  if (!eckey)  {    return 0;  }  group = EC_KEY_get0_group(eckey);  if ((order = BN_new()) == NULL) goto err;  if ((ctx = BN_CTX_new()) == NULL) goto err;  priv_key = (BIGNUM*)EC_KEY_get0_private_key(eckey);  if (priv_key == NULL)  {    goto err;  }  if (!EC_GROUP_get_order(group, order, ctx))    goto err;  if (BN_is_zero(priv_key))    goto err;  pub_key = (EC_POINT *)EC_KEY_get0_public_key(eckey);  if (pub_key == NULL)  {    pub_key = EC_POINT_new(group);    if (pub_key == NULL)      goto err;  }  if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, ctx))    goto err;  {    EC_POINT_make_affine(EC_KEY_get0_group(eckey),                         (EC_POINT *)EC_KEY_get0_public_key(eckey),                         NULL);  }  EC_KEY_set_private_key(eckey, priv_key);  EC_KEY_set_public_key(eckey, pub_key);  ok = 1;err:  if (order)    BN_free(order);  if (ctx != NULL)    BN_CTX_free(ctx);  return (ok);}

int FIPS_selftest_ecdsa()	{	EC_KEY *ec = NULL;	BIGNUM *x = NULL, *y = NULL, *d = NULL;	EVP_PKEY pk;	int rv = 0;	size_t i;	for (i = 0; i < sizeof(test_ec_data)/sizeof(EC_SELFTEST_DATA); i++)		{		EC_SELFTEST_DATA *ecd = test_ec_data + i;		x = BN_bin2bn(ecd->x, ecd->xlen, x);		y = BN_bin2bn(ecd->y, ecd->ylen, y);		d = BN_bin2bn(ecd->d, ecd->dlen, d);		if (!x || !y || !d)			goto err;		ec = EC_KEY_new_by_curve_name(ecd->curve);		if (!ec)			goto err;		if (!EC_KEY_set_public_key_affine_coordinates(ec, x, y))			goto err;		if (!EC_KEY_set_private_key(ec, d))			goto err;		pk.type = EVP_PKEY_EC;		pk.pkey.ec = ec;		if (!fips_pkey_signature_test(FIPS_TEST_SIGNATURE, &pk, NULL, 0,						NULL, 0, EVP_sha512(), 0,						ecd->name))			goto err;		EC_KEY_free(ec);		ec = NULL;		}	rv = 1;	err:	if (x)		BN_clear_free(x);	if (y)		BN_clear_free(y);	if (d)		BN_clear_free(d);	if (ec)		EC_KEY_free(ec);	return rv;	}

static isc_result_topensslecdsa_parse(dst_key_t *key, isc_lex_t *lexer, dst_key_t *pub) {	dst_private_t priv;	isc_result_t ret;	EVP_PKEY *pkey;	EC_KEY *eckey = NULL;	BIGNUM *privkey;	int group_nid;	isc_mem_t *mctx = key->mctx;	REQUIRE(key->key_alg == DST_ALG_ECDSA256 ||		key->key_alg == DST_ALG_ECDSA384);	if (key->key_alg == DST_ALG_ECDSA256)		group_nid = NID_X9_62_prime256v1;	else		group_nid = NID_secp384r1;	eckey = EC_KEY_new_by_curve_name(group_nid);	if (eckey == NULL)		return (dst__openssl_toresult(DST_R_OPENSSLFAILURE));	/* read private key file */	ret = dst__privstruct_parse(key, DST_ALG_ECDSA256, lexer, mctx, &priv);	if (ret != ISC_R_SUCCESS)		goto err;	privkey = BN_bin2bn(priv.elements[0].data,			    priv.elements[0].length, NULL);	if (privkey == NULL)		DST_RET(ISC_R_NOMEMORY);	if (!EC_KEY_set_private_key(eckey, privkey))		DST_RET(ISC_R_NOMEMORY);	if (ecdsa_check(eckey, pub) != ISC_R_SUCCESS)		DST_RET(DST_R_INVALIDPRIVATEKEY);	dst__privstruct_free(&priv, mctx);	memset(&priv, 0, sizeof(priv));	pkey = EVP_PKEY_new();	if (pkey == NULL)		DST_RET (ISC_R_NOMEMORY);	if (!EVP_PKEY_set1_EC_KEY(pkey, eckey)) {		EVP_PKEY_free(pkey);		DST_RET (ISC_R_FAILURE);	}	key->keydata.pkey = pkey;	ret = ISC_R_SUCCESS; err:	if (eckey != NULL)		EC_KEY_free(eckey);	dst__privstruct_free(&priv, mctx);	memset(&priv, 0, sizeof(priv));	return (ret);}

uint8_t CBKeySign(uint8_t * privKey, uint8_t * hash, uint8_t * signature){	EC_KEY * key = EC_KEY_new_by_curve_name(NID_secp256k1);	BIGNUM * bn = BN_bin2bn(privKey, 32, NULL);	EC_KEY_set_private_key(key, bn);	unsigned int sigSize;	ECDSA_sign(0, hash, 32, signature, &sigSize, key);	// Free key and BIGNUM	EC_KEY_free(key);	BN_free(bn);	return sigSize;}

openssl::Key BackendOpenSsl::internal_private_key(const ecdsa256::PrivateKey& generic) const{    openssl::Key key(NID_X9_62_prime256v1);    openssl::BigNumber prv(generic.key);    EC_KEY_set_private_key(key, prv);    // OpenSSL requires public key, so we recreate it from private key    openssl::BigNumberContext ctx;    const EC_GROUP* group = EC_KEY_get0_group(key);    openssl::Point pub(group);    openssl::check(EC_POINT_mul(group, pub, prv, nullptr, nullptr, ctx));    EC_KEY_set_public_key(key, pub);    openssl::check(EC_KEY_check_key(key));    return key;}

/* * * Generates GOST R 34.10-2001 * or GOST R 34.10-2012 keypair * */int gost_ec_keygen(EC_KEY *ec){    BIGNUM *order = NULL, *d = NULL;    const EC_GROUP *group = (ec) ? EC_KEY_get0_group(ec) : NULL;    int ok = 0;    if (!group) {        GOSTerr(GOST_F_GOST_EC_KEYGEN, ERR_R_INTERNAL_ERROR);        return 0;    }    order = BN_new();    d = BN_new();    if (!order || !d) {        GOSTerr(GOST_F_GOST_EC_KEYGEN, ERR_R_MALLOC_FAILURE);        goto end;    }    if (!EC_GROUP_get_order(group, order, NULL)) {        GOSTerr(GOST_F_GOST_EC_KEYGEN, ERR_R_INTERNAL_ERROR);        goto end;    }    do {        if (!BN_rand_range(d, order)) {            GOSTerr(GOST_F_GOST_EC_KEYGEN, GOST_R_RNG_ERROR);            goto end;        }    }    while (BN_is_zero(d));    if (!EC_KEY_set_private_key(ec, d)) {        GOSTerr(GOST_F_GOST_EC_KEYGEN, ERR_R_INTERNAL_ERROR);        goto end;    }    ok = 1; end:    if (d)        BN_free(d);    if (order)        BN_free(order);    return (ok) ? gost_ec_compute_public(ec) : 0;}

Handle<ScopedEVP_PKEY> JwkEc::To(int &key_type) {	LOG_FUNC();	LOG_INFO("Check key_type");	if (!(key_type == NODESSL_KT_PRIVATE || key_type == NODESSL_KT_PUBLIC)) {		THROW_ERROR("Wrong value of key_type");	}	LOG_INFO("import EC from JWK");	ScopedEC_KEY ec_key(EC_KEY_new());	LOG_INFO("set public key");	ScopedEC_GROUP group(EC_GROUP_new_by_curve_name(this->crv));	if (group.isEmpty()) {		THROW_OPENSSL("EC_GROUP_new_by_curve_name");	}	EC_KEY_set_group(ec_key.Get(), group.Get());	ScopedBIGNUM x(BN_dup(this->x.Get()));	ScopedBIGNUM y(BN_dup(this->y.Get()));	if (EC_KEY_set_public_key_affine_coordinates(ec_key.Get(), x.Get(), y.Get()) != 1) {		THROW_OPENSSL("EC_KEY_set_public_key_affine_coordinates");	}	x.unref();	y.unref();	if (key_type == NODESSL_KT_PRIVATE) {		LOG_INFO("set private key");		ScopedBIGNUM d(BN_dup(this->d.Get()));		if (EC_KEY_set_private_key(ec_key.Get(), d.Get()) != 1) {			THROW_OPENSSL("EC_KEY_set_private_key");		}		d.unref();	}	LOG_INFO("set internal key");	Handle<ScopedEVP_PKEY> new_key(new ScopedEVP_PKEY(EVP_PKEY_new()));	EVP_PKEY_assign_EC_KEY(new_key->Get(), ec_key.Get());	ec_key.unref();		return new_key;}

int VNEcdsa_ORG_LoadPrivKey( VNAsymCryptCtx_t * ctx,	const struct vn_iovec * hexPubKey, const struct vn_iovec * hexPrivKey ){	BIGNUM tmp;	VNEcdsa_ORG_Ctx_t * orgCtx = VN_CONTAINER_OF( ctx, VNEcdsa_ORG_Ctx_t, mCtx );	assert( VN_TYPE_VNEcdsaSign_ORG == ctx->mType );	BN_init( &tmp );	VNEcdsa_ORG_LoadPubKey( ctx, hexPubKey );	VN_BN_load_hex( hexPrivKey, &tmp );	EC_KEY_set_private_key( orgCtx->mEcKey, &tmp );	BN_free( &tmp );	return 0;}

SEXP R_ecdsa_key_build(SEXP x, SEXP y, SEXP d, SEXP nist){#ifndef OPENSSL_NO_EC  int nid = my_nist2nid(CHAR(STRING_ELT(nist, 0)));  bail(nid);  EC_KEY *key = EC_KEY_new_by_curve_name(nid);  EC_KEY_set_asn1_flag(key, OPENSSL_EC_NAMED_CURVE);  if(!EC_KEY_set_public_key_affine_coordinates(key, new_bignum_from_r(x), new_bignum_from_r(y)))    error("Failed to construct EC key. Perhaps invalid point or curve.");  EC_KEY_set_private_key(key, new_bignum_from_r(d));  unsigned char *buf = NULL;  int len = i2d_ECPrivateKey(key, &buf);  bail(len);  EC_KEY_free(key);  SEXP res = allocVector(RAWSXP, len);  memcpy(RAW(res), buf, len);  OPENSSL_free(buf);  return res;#else //OPENSSL_NO_EC  Rf_error("OpenSSL has been configured without EC support");#endif //OPENSSL_NO_EC}

/* *  call-seq: *     key.private_key = openssl_bn * *  See the OpenSSL documentation for EC_KEY_set_private_key() */static VALUE ossl_ec_key_set_private_key(VALUE self, VALUE private_key){    EC_KEY *ec;    BIGNUM *bn = NULL;    Require_EC_KEY(self, ec);    if (!NIL_P(private_key))        bn = GetBNPtr(private_key);    switch (EC_KEY_set_private_key(ec, bn)) {    case 1:        break;    case 0:        if (bn == NULL)            break;    default:        ossl_raise(eECError, "EC_KEY_set_private_key");    }    return private_key;}

static int gost_set_priv_key(EVP_PKEY *pkey, BIGNUM *priv){    switch (EVP_PKEY_base_id(pkey)) {    case NID_id_GostR3410_2012_512:    case NID_id_GostR3410_2012_256:    case NID_id_GostR3410_2001:        {            EC_KEY *ec = EVP_PKEY_get0(pkey);            if (!ec) {                ec = EC_KEY_new();                EVP_PKEY_assign(pkey, EVP_PKEY_base_id(pkey), ec);            }            if (!EC_KEY_set_private_key(ec, priv))                return 0;            if (!EVP_PKEY_missing_parameters(pkey))                gost_ec_compute_public(ec);            break;        }    default:        return 0;    }    return 1;}

Key *key_private_deserialize(buffer_t *blob){	int success = 0;	char *type_name = NULL;	Key *k = NULL;	unsigned int pklen, sklen;	int type;	type_name = buffer_get_string_msg(blob, NULL);	if (type_name == NULL)		goto error;	type = get_keytype_from_name(type_name);	k = key_new_private(type);	switch (type) {		case KEY_RSA:			buffer_get_bignum2_msg(blob, k->rsa->n);			buffer_get_bignum2_msg(blob, k->rsa->e);			buffer_get_bignum2_msg(blob, k->rsa->d);			buffer_get_bignum2_msg(blob, k->rsa->iqmp);			buffer_get_bignum2_msg(blob, k->rsa->p);			buffer_get_bignum2_msg(blob, k->rsa->q);			/* Generate additional parameters */			rsa_generate_additional_parameters(k->rsa);			break;		case KEY_DSA:			buffer_get_bignum2_msg(blob, k->dsa->p);			buffer_get_bignum2_msg(blob, k->dsa->q);			buffer_get_bignum2_msg(blob, k->dsa->g);			buffer_get_bignum2_msg(blob, k->dsa->pub_key);			buffer_get_bignum2_msg(blob, k->dsa->priv_key);			break;		case KEY_ECDSA256:		case KEY_ECDSA384:		case KEY_ECDSA521:			{			int success = 0;			unsigned int nid;			char *curve = NULL;			ssh_keytype skt;			BIGNUM *exponent = NULL;			EC_POINT *q = NULL;			nid = keytype_to_cipher_nid(type);			curve = buffer_get_string_msg(blob, NULL);			skt = key_curve_name_to_keytype(curve);			if (nid != keytype_to_cipher_nid(skt))				goto ecdsa_error;			k->ecdsa = EC_KEY_new_by_curve_name(nid);			if (k->ecdsa == NULL)				goto ecdsa_error;			q = EC_POINT_new(EC_KEY_get0_group(k->ecdsa));			if (q == NULL)				goto ecdsa_error;			if ((exponent = BN_new()) == NULL)				goto ecdsa_error;			buffer_get_ecpoint_msg(blob,				EC_KEY_get0_group(k->ecdsa), q);			buffer_get_bignum2_msg(blob, exponent);			if (EC_KEY_set_public_key(k->ecdsa, q) != 1)				goto ecdsa_error;			if (EC_KEY_set_private_key(k->ecdsa, exponent) != 1)				goto ecdsa_error;			if (key_ec_validate_public(EC_KEY_get0_group(k->ecdsa),				EC_KEY_get0_public_key(k->ecdsa)) != 0)				goto ecdsa_error;			if (key_ec_validate_private(k->ecdsa) != 0)				goto ecdsa_error;			success = 1;ecdsa_error:			free(curve);			if (exponent)				BN_clear_free(exponent);			if (q)				EC_POINT_free(q);			if (success == 0)				goto error;			}			break;		case KEY_ED25519:			k->ed25519_pk = buffer_get_string_msg(blob, &pklen);			k->ed25519_sk = buffer_get_string_msg(blob, &sklen);			if (pklen != ED25519_PK_SZ) 				goto error;			if (sklen != ED25519_SK_SZ)				goto error;			break;		default:			goto error;//.........这里部分代码省略.........

BitcoinResult Bitcoin_MakePublicKeyFromPrivateKey(	struct BitcoinPublicKey *public_key,	const struct BitcoinPrivateKey *private_key){	BN_CTX *ctx = NULL;	EC_KEY *key = NULL;	EC_POINT *ec_public = NULL;	unsigned char *public_key_ptr = public_key->data;	BIGNUM *private_key_bn;	const EC_GROUP *group = NULL;	int size, size2;	unsigned compression = private_key->public_key_compression;	size_t expected_public_key_size = 0;	enum BitcoinPublicKeyCompression public_key_compression;	switch (compression) {		case BITCOIN_PUBLIC_KEY_COMPRESSED :		case BITCOIN_PUBLIC_KEY_UNCOMPRESSED :			break;		default :			applog(APPLOG_ERROR, __func__,				"public key compression is not specified, please set using"				" --public-key-compression compressed/uncompressed"			);			EC_KEY_free(key);			return BITCOIN_ERROR_PRIVATE_KEY_INVALID_FORMAT;			break;	}	key = EC_KEY_new_by_curve_name_NID_secp256k1();	if (!key) {		applog(APPLOG_ERROR, __func__,			"EC_KEY_new_by_curve_name failed: %s",			ERR_error_string(ERR_get_error(), NULL)		);		return BITCOIN_ERROR_LIBRARY_FAILURE;	}	group = EC_KEY_get0_group(key);	if (!group) {		applog(APPLOG_ERROR, __func__,			"EC_KEY_get0_group failed: %s",			ERR_error_string(ERR_get_error(), NULL)		);		EC_KEY_free(key);		return BITCOIN_ERROR_LIBRARY_FAILURE;	}	private_key_bn = BN_new();	BN_bin2bn(private_key->data, BITCOIN_PRIVATE_KEY_SIZE, private_key_bn);	ec_public = EC_POINT_new(group);	ctx = BN_CTX_new();	if (!ctx) {		applog(APPLOG_ERROR, __func__,			"BN_CTX_new failed: %s",			ERR_error_string(ERR_get_error(), NULL)		);		EC_KEY_free(key);		return BITCOIN_ERROR_LIBRARY_FAILURE;	}	if (!EC_POINT_mul(group, ec_public, private_key_bn, NULL, NULL, ctx)) {		applog(APPLOG_ERROR, __func__,			"EC_POINT_mul failed: %s",			ERR_error_string(ERR_get_error(), NULL)		);		EC_KEY_free(key);		return BITCOIN_ERROR_LIBRARY_FAILURE;	}	EC_KEY_set_private_key(key, private_key_bn);	EC_KEY_set_public_key(key, ec_public);	if (compression == BITCOIN_PUBLIC_KEY_COMPRESSED) {		EC_KEY_set_conv_form(key, POINT_CONVERSION_COMPRESSED);		expected_public_key_size = BITCOIN_PUBLIC_KEY_COMPRESSED_SIZE;		public_key_compression = BITCOIN_PUBLIC_KEY_COMPRESSED;	} else {		EC_KEY_set_conv_form(key, POINT_CONVERSION_UNCOMPRESSED);		expected_public_key_size = BITCOIN_PUBLIC_KEY_UNCOMPRESSED_SIZE;		public_key_compression = BITCOIN_PUBLIC_KEY_UNCOMPRESSED;	}	size = i2o_ECPublicKey(key, NULL);	if (size != expected_public_key_size) {		fprintf(stderr, "%s: invalid public key size (%u), should be %u/n",			__func__,			(unsigned)size,			(unsigned)expected_public_key_size		);		BN_free(private_key_bn);		EC_KEY_free(key);		return BITCOIN_ERROR_PUBLIC_KEY_INVALID_FORMAT;	}	size2 = i2o_ECPublicKey(key, &public_key_ptr);	if (size2 != expected_public_key_size) {//.........这里部分代码省略.........

void  SM2PKE_test3(){	/* test3 params */	const char *p = "8542D69E4C044F18E8B92435BF6FF7DE457283915C45517D722EDB8B08F1DFC3";	const char *a = "787968B4FA32C3FD2417842E73BBFEFF2F3C848B6831D7E0EC65228B3937E498";	const char *b = "63E4C6D3B23B0C849CF84241484BFE48F61D59A5B16BA06E6E12D1DA27C5249A";	const char *xG = "421DEBD61B62EAB6746434EBC3CC315E32220B3BADD50BDC4C4E6C147FEDD43D";	const char *yG = "0680512BCBB42C07D47349D2153B70C4E5D7FDFCBFA36EA1A85841B9E46E09A2";	const char *n = "8542D69E4C044F18E8B92435BF6FF7DD297720630485628D5AE74EE7C32E79B7";	const char *dB = "1649AB77A00637BD5E2EFE283FBF353534AA7F7CB89463F208DDBC2920BB0DA0";	const char *xB = "435B39CCA8F3B508C1488AFC67BE491A0F7BA07E581A0E4849A5CF70628A7E0A";	const char *yB = "75DDBA78F15FEECB4C7895E2C1CDF5FE01DEBB2CDBADF45399CCF77BBA076A42";		BIGNUM *bn_p = BN_new();	BN_hex2bn(&bn_p, p);	BIGNUM *bn_a = BN_new();	BN_hex2bn(&bn_a, a);	BIGNUM *bn_b = BN_new();	BN_hex2bn(&bn_b, b);	BIGNUM *bn_xG = BN_new();	BN_hex2bn(&bn_xG, xG);	BIGNUM *bn_yG = BN_new();	BN_hex2bn(&bn_yG, yG);	BIGNUM *bn_n = BN_new();	BN_hex2bn(&bn_n, n);	BIGNUM *bn_dB = BN_new();	BN_hex2bn(&bn_dB, dB);	BIGNUM *bn_xB = BN_new();	BN_hex2bn(&bn_xB, xB);	BIGNUM *bn_yB = BN_new();	BN_hex2bn(&bn_yB, yB);		BN_CTX *bn_ctx = BN_CTX_new();	EC_GROUP *ec_group = EC_GROUP_new(EC_GFp_mont_method());	EC_GROUP_set_curve_GFp(ec_group, bn_p, bn_a, bn_b, bn_ctx);	EC_POINT *G = EC_POINT_new(ec_group);	EC_POINT_set_affine_coordinates_GFp(ec_group, G, bn_xG, bn_yG, bn_ctx);	BIGNUM *bn_h = BN_new();	/* cofactor h = #E(Fp) / n */	BN_div(bn_h, NULL, bn_p, bn_n, bn_ctx);	EC_GROUP_set_generator(ec_group, G, bn_n, bn_h);		EC_POINT *PB = EC_POINT_new(ec_group);	EC_POINT_set_affine_coordinates_GFp(ec_group, PB, bn_xB, bn_yB, bn_ctx);	EC_KEY *ec_key_B = EC_KEY_new();	EC_KEY_set_group(ec_key_B, ec_group);	EC_KEY_set_private_key(ec_key_B, bn_dB);	EC_KEY_set_public_key(ec_key_B, PB);		BN_free(bn_p);	BN_free(bn_a);	BN_free(bn_b);	BN_free(bn_n);	BN_free(bn_xG);	BN_free(bn_yG);	BN_free(bn_dB);	BN_free(bn_xB);	BN_free(bn_yB);	BN_free(bn_h);	BN_CTX_free(bn_ctx);	EC_POINT_free(G);	EC_POINT_free(PB);	EC_GROUP_free(ec_group);	char *M = "encryption standard";	char *ctest = "04245C26FB68B1DDDDB12C4B6BF9F2B6D5FE60A383B0D18D1C4144ABF17F6252"	"E776CB9264C2A7E88E52B19903FDC47378F605E36811F5C07423A24B84400F01"	"B8650053A89B41C418B0C3AAD00D886C002864679C3D7360C30156FAB7C80A02"	"76712DA9D8094A634B766D3A285E07480653426D";	BIGNUM *ct = BN_new();	BN_hex2bn(&ct, ctest);	unsigned char ct2bin[116];	BN_bn2bin(ct, ct2bin);	BN_free(ct);	int mlen = strlen(M);	int c1len = PRIME_SIZE / 8 * 2 + 1;	int clen = c1len + mlen + HASH_V / 8;		unsigned char *C = malloc(sizeof(unsigned char) * clen);	sm2_pke_encrypt(C, M, mlen, ec_key_B);		if (memcmp(C, ct2bin, clen) == 0)		printf("sm2_pke_encrypt passed./n");	else 		printf("sm2_pke_encrypt failed./n");	free(C);		int m1len = clen - c1len - HASH_V / 8;	unsigned char *M1bin = malloc(sizeof(unsigned char) * m1len);	sm2_pke_decrypt((char *)ct2bin, M1bin, m1len, ec_key_B);		if (memcmp(M1bin, M, m1len) == 0)		printf("sm2_pke_decrypt passed./n");	else 		printf("sm2_pke_decrypt failed./n");	free(M1bin);	EC_KEY_free(ec_key_B);}