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

int test_builtin(BIO *out){    EC_builtin_curve *curves = NULL;    size_t crv_len = 0, n = 0;    EC_KEY *eckey = NULL, *wrong_eckey = NULL;    EC_GROUP *group;    ECDSA_SIG *ecdsa_sig = NULL;    unsigned char digest[20], wrong_digest[20];    unsigned char *signature = NULL;    const unsigned char *sig_ptr;    unsigned char *sig_ptr2;    unsigned char *raw_buf = NULL;    unsigned int sig_len, degree, r_len, s_len, bn_len, buf_len;    int nid, ret = 0;    /* fill digest values with some random data */    if (!RAND_pseudo_bytes(digest, 20) ||            !RAND_pseudo_bytes(wrong_digest, 20)) {        BIO_printf(out, "ERROR: unable to get random data/n");        goto builtin_err;    }    /*     * create and verify a ecdsa signature with every availble curve (with )     */    BIO_printf(out, "/ntesting ECDSA_sign() and ECDSA_verify() "               "with some internal curves:/n");    /* get a list of all internal curves */    crv_len = EC_get_builtin_curves(NULL, 0);    curves = OPENSSL_malloc(sizeof(EC_builtin_curve) * crv_len);    if (curves == NULL) {        BIO_printf(out, "malloc error/n");        goto builtin_err;    }    if (!EC_get_builtin_curves(curves, crv_len)) {        BIO_printf(out, "unable to get internal curves/n");        goto builtin_err;    }    /* now create and verify a signature for every curve */    for (n = 0; n < crv_len; n++) {        unsigned char dirt, offset;        nid = curves[n].nid;        if (nid == NID_ipsec4)            continue;        /* create new ecdsa key (== EC_KEY) */        if ((eckey = EC_KEY_new()) == NULL)            goto builtin_err;        group = EC_GROUP_new_by_curve_name(nid);        if (group == NULL)            goto builtin_err;        if (EC_KEY_set_group(eckey, group) == 0)            goto builtin_err;        EC_GROUP_free(group);        degree = EC_GROUP_get_degree(EC_KEY_get0_group(eckey));        if (degree < 160)            /* drop the curve */        {            EC_KEY_free(eckey);            eckey = NULL;            continue;        }        BIO_printf(out, "%s: ", OBJ_nid2sn(nid));        /* create key */        if (!EC_KEY_generate_key(eckey)) {            BIO_printf(out, " failed/n");            goto builtin_err;        }        /* create second key */        if ((wrong_eckey = EC_KEY_new()) == NULL)            goto builtin_err;        group = EC_GROUP_new_by_curve_name(nid);        if (group == NULL)            goto builtin_err;        if (EC_KEY_set_group(wrong_eckey, group) == 0)            goto builtin_err;        EC_GROUP_free(group);        if (!EC_KEY_generate_key(wrong_eckey)) {            BIO_printf(out, " failed/n");            goto builtin_err;        }        BIO_printf(out, ".");        (void)BIO_flush(out);        /* check key */        if (!EC_KEY_check_key(eckey)) {            BIO_printf(out, " failed/n");            goto builtin_err;        }        BIO_printf(out, ".");        (void)BIO_flush(out);        /* create signature */        sig_len = ECDSA_size(eckey);        if ((signature = OPENSSL_malloc(sig_len)) == NULL)            goto builtin_err;//.........这里部分代码省略.........

static isc_result_topensslecdsa_generate(dst_key_t *key, int unused, void (*callback)(int)) {	isc_result_t ret;	EVP_PKEY *pkey;	EC_KEY *eckey = NULL;	int group_nid;	REQUIRE(key->key_alg == DST_ALG_ECDSA256 ||		key->key_alg == DST_ALG_ECDSA384);	UNUSED(unused);	UNUSED(callback);	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));	if (EC_KEY_generate_key(eckey) != 1)		DST_RET (dst__openssl_toresult(DST_R_OPENSSLFAILURE));	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);	return (ret);}

static int pkey_ec_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey){    EC_KEY *ec = NULL;    EC_PKEY_CTX *dctx = ctx->data;    if (ctx->pkey == NULL && dctx->gen_group == NULL) {        ECerr(EC_F_PKEY_EC_KEYGEN, EC_R_NO_PARAMETERS_SET);        return 0;    }    ec = EC_KEY_new();    if (!ec)        return 0;    EVP_PKEY_assign_EC_KEY(pkey, ec);    if (ctx->pkey) {        /* Note: if error return, pkey is freed by parent routine */        if (!EVP_PKEY_copy_parameters(pkey, ctx->pkey))            return 0;    } else {        if (!EC_KEY_set_group(ec, dctx->gen_group))            return 0;    }    return EC_KEY_generate_key(pkey->pkey.ec);}

soter_status_t soter_ec_gen_key(EVP_PKEY_CTX *pkey_ctx){  EVP_PKEY *pkey;  EC_KEY *ec;  if (!pkey_ctx){    return SOTER_INVALID_PARAMETER;  }  pkey = EVP_PKEY_CTX_get0_pkey(pkey_ctx);  if (!pkey){    return SOTER_INVALID_PARAMETER;  }  if (EVP_PKEY_EC != EVP_PKEY_id(pkey)){    return SOTER_INVALID_PARAMETER;  }  ec = EVP_PKEY_get0(pkey);  if (NULL == ec){    return SOTER_INVALID_PARAMETER;  }  if (1 == EC_KEY_generate_key(ec)){    return SOTER_SUCCESS;  }  return SOTER_FAIL;}

soter_status_t soter_asym_ka_gen_key(soter_asym_ka_t* asym_ka_ctx){	EVP_PKEY *pkey;	EC_KEY *ec;	if (!asym_ka_ctx)	{		return SOTER_INVALID_PARAMETER;	}	pkey = EVP_PKEY_CTX_get0_pkey(asym_ka_ctx->pkey_ctx);	if (!pkey)	{		return SOTER_INVALID_PARAMETER;	}	if (EVP_PKEY_EC != EVP_PKEY_id(pkey))	{		return SOTER_INVALID_PARAMETER;	}	ec = EVP_PKEY_get0_EC_KEY(pkey);	if (NULL == ec)	{		return SOTER_INVALID_PARAMETER;	}	if (1 == EC_KEY_generate_key(ec))	{		return SOTER_SUCCESS;	}	else	{		return SOTER_FAIL;	}}

static void test_ecdsa_sign(void){    EVP_PKEY *pkey;    { /* create pkey */        EC_KEY *eckey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);        EC_KEY_generate_key(eckey);        pkey = EVP_PKEY_new();        EVP_PKEY_set1_EC_KEY(pkey, eckey);        EC_KEY_free(eckey);    }    const char *message = "hello world";    ptls_buffer_t sigbuf;    uint8_t sigbuf_small[1024];    ptls_buffer_init(&sigbuf, sigbuf_small, sizeof(sigbuf_small));    ok(do_sign(pkey, &sigbuf, ptls_iovec_init(message, strlen(message)), EVP_sha256()) == 0);    EVP_PKEY_up_ref(pkey);    ok(verify_sign(pkey, ptls_iovec_init(message, strlen(message)), ptls_iovec_init(sigbuf.base, sigbuf.off)) == 0);    ptls_buffer_dispose(&sigbuf);    EVP_PKEY_free(pkey);}

static EP_STATgenerate_ec_key(EP_CRYPTO_KEY *key, const char *curve){	if (curve == NULL)		curve = ep_adm_getstrparam("libep.crypto.key.ec.curve",				"sect283r1");	int nid = OBJ_txt2nid(curve);	if (nid == NID_undef)	{		_ep_crypto_error("unknown EC curve name %s", curve);		goto fail0;	}	EC_KEY *eckey = EC_KEY_new_by_curve_name(nid);	if (eckey == NULL)	{		_ep_crypto_error("cannot create EC key");		goto fail0;	}	if (!EC_KEY_generate_key(eckey))	{		_ep_crypto_error("cannot generate EC key");		goto fail1;	}	if (EVP_PKEY_assign_EC_KEY(key, eckey) != 1)	{		_ep_crypto_error("cannot assign EC key");		goto fail1;	}	return EP_STAT_OK;fail1:	EC_KEY_free(eckey);fail0:	return EP_STAT_CRYPTO_KEYCREATE;}

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 intinput_kex_ecdh_init(int type, u_int32_t seq, struct ssh *ssh){	struct kex *kex = ssh->kex;	EC_POINT *client_public;	EC_KEY *server_key = NULL;	const EC_GROUP *group;	const EC_POINT *public_key;	BIGNUM *shared_secret = NULL;	struct sshkey *server_host_private, *server_host_public;	u_char *server_host_key_blob = NULL, *signature = NULL;	u_char *kbuf = NULL;	u_char hash[SSH_DIGEST_MAX_LENGTH];	size_t slen, sbloblen;	size_t klen = 0, hashlen;	int r;	if ((server_key = EC_KEY_new_by_curve_name(kex->ec_nid)) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	if (EC_KEY_generate_key(server_key) != 1) {		r = SSH_ERR_LIBCRYPTO_ERROR;		goto out;	}	group = EC_KEY_get0_group(server_key);#ifdef DEBUG_KEXECDH	fputs("server private key:/n", stderr);	sshkey_dump_ec_key(server_key);#endif	if (kex->load_host_public_key == NULL ||	    kex->load_host_private_key == NULL) {		r = SSH_ERR_INVALID_ARGUMENT;		goto out;	}	server_host_public = kex->load_host_public_key(kex->hostkey_type,	    kex->hostkey_nid, ssh);	server_host_private = kex->load_host_private_key(kex->hostkey_type,	    kex->hostkey_nid, ssh);	if (server_host_public == NULL) {		r = SSH_ERR_NO_HOSTKEY_LOADED;		goto out;	}	if ((client_public = EC_POINT_new(group)) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	if ((r = sshpkt_get_ec(ssh, client_public, group)) != 0 ||	    (r = sshpkt_get_end(ssh)) != 0)		goto out;#ifdef DEBUG_KEXECDH	fputs("client public key:/n", stderr);	sshkey_dump_ec_point(group, client_public);#endif	if (sshkey_ec_validate_public(group, client_public) != 0) {		sshpkt_disconnect(ssh, "invalid client public key");		r = SSH_ERR_MESSAGE_INCOMPLETE;		goto out;	}	/* Calculate shared_secret */	klen = (EC_GROUP_get_degree(group) + 7) / 8;	if ((kbuf = malloc(klen)) == NULL ||	    (shared_secret = BN_new()) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	if (ECDH_compute_key(kbuf, klen, client_public,	    server_key, NULL) != (int)klen ||	    BN_bin2bn(kbuf, klen, shared_secret) == NULL) {		r = SSH_ERR_LIBCRYPTO_ERROR;		goto out;	}#ifdef DEBUG_KEXECDH	dump_digest("shared secret", kbuf, klen);#endif	/* calc H */	if ((r = sshkey_to_blob(server_host_public, &server_host_key_blob,	    &sbloblen)) != 0)		goto out;	hashlen = sizeof(hash);	if ((r = kex_ecdh_hash(	    kex->hash_alg,	    group,	    kex->client_version_string,	    kex->server_version_string,	    sshbuf_ptr(kex->peer), sshbuf_len(kex->peer),	    sshbuf_ptr(kex->my), sshbuf_len(kex->my),	    server_host_key_blob, sbloblen,	    client_public,	    EC_KEY_get0_public_key(server_key),	    shared_secret,	    hash, &hashlen)) != 0)		goto out;	/* save session id := H *///.........这里部分代码省略.........

static krb5_error_codegenerate_dh_keyblock(krb5_context context,		     pk_client_params *client_params,                     krb5_enctype enctype){    unsigned char *dh_gen_key = NULL;    krb5_keyblock key;    krb5_error_code ret;    size_t dh_gen_keylen, size;    memset(&key, 0, sizeof(key));    if (client_params->keyex == USE_DH) {	if (client_params->u.dh.public_key == NULL) {	    ret = KRB5KRB_ERR_GENERIC;	    krb5_set_error_message(context, ret, "public_key");	    goto out;	}	if (!DH_generate_key(client_params->u.dh.key)) {	    ret = KRB5KRB_ERR_GENERIC;	    krb5_set_error_message(context, ret, 				   "Can't generate Diffie-Hellman keys");	    goto out;	}	dh_gen_keylen = DH_size(client_params->u.dh.key);	size = BN_num_bytes(client_params->u.dh.key->p);	if (size < dh_gen_keylen)	    size = dh_gen_keylen;	dh_gen_key = malloc(size);	if (dh_gen_key == NULL) {	    ret = ENOMEM;	    krb5_set_error_message(context, ret, "malloc: out of memory");	    goto out;	}	memset(dh_gen_key, 0, size - dh_gen_keylen);	dh_gen_keylen = DH_compute_key(dh_gen_key + (size - dh_gen_keylen),				       client_params->u.dh.public_key,				       client_params->u.dh.key);	if (dh_gen_keylen == -1) {	    ret = KRB5KRB_ERR_GENERIC;	    krb5_set_error_message(context, ret,				   "Can't compute Diffie-Hellman key");	    goto out;	}	ret = 0;#ifdef HAVE_OPENSSL    } else if (client_params->keyex == USE_ECDH) {	if (client_params->u.ecdh.public_key == NULL) {	    ret = KRB5KRB_ERR_GENERIC;	    krb5_set_error_message(context, ret, "public_key");	    goto out;	}	client_params->u.ecdh.key = EC_KEY_new();	if (client_params->u.ecdh.key == NULL) {	    ret = ENOMEM;	    goto out;	}	EC_KEY_set_group(client_params->u.ecdh.key,			 EC_KEY_get0_group(client_params->u.ecdh.public_key));	if (EC_KEY_generate_key(client_params->u.ecdh.key) != 1) {	    ret = ENOMEM;	    goto out;	}	size = (EC_GROUP_get_degree(EC_KEY_get0_group(client_params->u.ecdh.key)) + 7) / 8;	dh_gen_key = malloc(size);	if (dh_gen_key == NULL) {	    ret = ENOMEM;	    krb5_set_error_message(context, ret,				   N_("malloc: out of memory", ""));	    goto out;	}	dh_gen_keylen = ECDH_compute_key(dh_gen_key, size, 					 EC_KEY_get0_public_key(client_params->u.ecdh.public_key),					 client_params->u.ecdh.key, NULL);#endif /* HAVE_OPENSSL */    } else {	ret = KRB5KRB_ERR_GENERIC;	krb5_set_error_message(context, ret, 			       "Diffie-Hellman not selected keys");	goto out;    }    ret = _krb5_pk_octetstring2key(context,				   enctype,				   dh_gen_key, dh_gen_keylen,				   NULL, NULL,				   &client_params->reply_key); out://.........这里部分代码省略.........

static int test_builtin(void){    EC_builtin_curve *curves = NULL;    size_t crv_len = 0, n = 0;    EC_KEY *eckey = NULL, *wrong_eckey = NULL;    EC_GROUP *group;    ECDSA_SIG *ecdsa_sig = NULL, *modified_sig = NULL;    unsigned char digest[20], wrong_digest[20];    unsigned char *signature = NULL;    const unsigned char *sig_ptr;    unsigned char *sig_ptr2;    unsigned char *raw_buf = NULL;    const BIGNUM *sig_r, *sig_s;    BIGNUM *modified_r = NULL, *modified_s = NULL;    BIGNUM *unmodified_r = NULL, *unmodified_s = NULL;    unsigned int sig_len, degree, r_len, s_len, bn_len, buf_len;    int nid, ret = 0;    /* fill digest values with some random data */    if (!TEST_true(RAND_bytes(digest, 20))            || !TEST_true(RAND_bytes(wrong_digest, 20)))        goto builtin_err;    /* create and verify a ecdsa signature with every available curve */    /* get a list of all internal curves */    crv_len = EC_get_builtin_curves(NULL, 0);    if (!TEST_ptr(curves = OPENSSL_malloc(sizeof(*curves) * crv_len))            || !TEST_true(EC_get_builtin_curves(curves, crv_len)))        goto builtin_err;    /* now create and verify a signature for every curve */    for (n = 0; n < crv_len; n++) {        unsigned char dirt, offset;        nid = curves[n].nid;        if (nid == NID_ipsec4 || nid == NID_X25519)            continue;        /* create new ecdsa key (== EC_KEY) */        if (!TEST_ptr(eckey = EC_KEY_new())                || !TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))                || !TEST_true(EC_KEY_set_group(eckey, group)))            goto builtin_err;        EC_GROUP_free(group);        degree = EC_GROUP_get_degree(EC_KEY_get0_group(eckey));        if (degree < 160) {            /* drop the curve */            EC_KEY_free(eckey);            eckey = NULL;            continue;        }        TEST_info("testing %s", OBJ_nid2sn(nid));        /* create key */        if (!TEST_true(EC_KEY_generate_key(eckey)))            goto builtin_err;        /* create second key */        if (!TEST_ptr(wrong_eckey = EC_KEY_new())                || !TEST_ptr(group = EC_GROUP_new_by_curve_name(nid))                || !TEST_true(EC_KEY_set_group(wrong_eckey, group)))            goto builtin_err;        EC_GROUP_free(group);        if (!TEST_true(EC_KEY_generate_key(wrong_eckey)))            goto builtin_err;        /* check key */        if (!TEST_true(EC_KEY_check_key(eckey)))            goto builtin_err;        /* create signature */        sig_len = ECDSA_size(eckey);        if (!TEST_ptr(signature = OPENSSL_malloc(sig_len))                || !TEST_true(ECDSA_sign(0, digest, 20, signature, &sig_len,                                         eckey)))            goto builtin_err;        /* verify signature */        if (!TEST_int_eq(ECDSA_verify(0, digest, 20, signature, sig_len,                                      eckey), 1))            goto builtin_err;        /* verify signature with the wrong key */        if (!TEST_int_ne(ECDSA_verify(0, digest, 20, signature, sig_len,                                      wrong_eckey), 1))            goto builtin_err;        /* wrong digest */        if (!TEST_int_ne(ECDSA_verify(0, wrong_digest, 20, signature,                                      sig_len, eckey), 1))            goto builtin_err;        /* wrong length */        if (!TEST_int_ne(ECDSA_verify(0, digest, 20, signature,                                      sig_len - 1, eckey), 1))            goto builtin_err;        /*         * Modify a single byte of the signature: to ensure we don't garble         * the ASN1 structure, we read the raw signature and modify a byte in         * one of the bignums directly.         *///.........这里部分代码省略.........

voidkexecdh_client(Kex *kex){	EC_KEY *client_key;	EC_POINT *server_public;	const EC_GROUP *group;	BIGNUM *shared_secret;	Key *server_host_key;	u_char *server_host_key_blob = NULL, *signature = NULL;	u_char *kbuf, *hash;	u_int klen, slen, sbloblen, hashlen;	if ((client_key = EC_KEY_new_by_curve_name(kex->ec_nid)) == NULL)		fatal("%s: EC_KEY_new_by_curve_name failed", __func__);	if (EC_KEY_generate_key(client_key) != 1)		fatal("%s: EC_KEY_generate_key failed", __func__);	group = EC_KEY_get0_group(client_key);	packet_start(SSH2_MSG_KEX_ECDH_INIT);	packet_put_ecpoint(group, EC_KEY_get0_public_key(client_key));	packet_send();	debug("sending SSH2_MSG_KEX_ECDH_INIT");#ifdef DEBUG_KEXECDH	fputs("client private key:/n", stderr);	key_dump_ec_key(client_key);#endif	debug("expecting SSH2_MSG_KEX_ECDH_REPLY");	packet_read_expect(SSH2_MSG_KEX_ECDH_REPLY);	/* hostkey */	server_host_key_blob = packet_get_string(&sbloblen);	server_host_key = key_from_blob(server_host_key_blob, sbloblen);	if (server_host_key == NULL)		fatal("cannot decode server_host_key_blob");	if (server_host_key->type != kex->hostkey_type)		fatal("type mismatch for decoded server_host_key_blob");	if (kex->verify_host_key == NULL)		fatal("cannot verify server_host_key");	if (kex->verify_host_key(server_host_key) == -1)		fatal("server_host_key verification failed");	/* Q_S, server public key */	if ((server_public = EC_POINT_new(group)) == NULL)		fatal("%s: EC_POINT_new failed", __func__);	packet_get_ecpoint(group, server_public);	if (key_ec_validate_public(group, server_public) != 0)		fatal("%s: invalid server public key", __func__);#ifdef DEBUG_KEXECDH	fputs("server public key:/n", stderr);	key_dump_ec_point(group, server_public);#endif	/* signed H */	signature = packet_get_string(&slen);	packet_check_eom();	klen = (EC_GROUP_get_degree(group) + 7) / 8;	kbuf = xmalloc(klen);	if (ECDH_compute_key(kbuf, klen, server_public,	    client_key, NULL) != (int)klen)		fatal("%s: ECDH_compute_key failed", __func__);#ifdef DEBUG_KEXECDH	dump_digest("shared secret", kbuf, klen);#endif	if ((shared_secret = BN_new()) == NULL)		fatal("%s: BN_new failed", __func__);	if (BN_bin2bn(kbuf, klen, shared_secret) == NULL)		fatal("%s: BN_bin2bn failed", __func__);	memset(kbuf, 0, klen);	free(kbuf);	/* calc and verify H */	kex_ecdh_hash(	    kex->evp_md,	    group,	    kex->client_version_string,	    kex->server_version_string,	    buffer_ptr(&kex->my), buffer_len(&kex->my),	    buffer_ptr(&kex->peer), buffer_len(&kex->peer),	    server_host_key_blob, sbloblen,	    EC_KEY_get0_public_key(client_key),	    server_public,	    shared_secret,	    &hash, &hashlen	);	free(server_host_key_blob);	EC_POINT_clear_free(server_public);	EC_KEY_free(client_key);	if (key_verify(server_host_key, signature, slen, hash, hashlen) != 1)		fatal("key_verify failed for server_host_key");	key_free(server_host_key);	free(signature);	/* save session id *///.........这里部分代码省略.........

extern "C" int32_t CryptoNative_EcKeyGenerateKey(EC_KEY* eckey){    return EC_KEY_generate_key(eckey);}

/* some tests from the X9.62 draft */int x9_62_test_internal(BIO *out, int nid, const char *r_in, const char *s_in){    int ret = 0;    const char message[] = "abc";    unsigned char digest[20];    unsigned int dgst_len = 0;    EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();    EC_KEY *key = NULL;    ECDSA_SIG *signature = NULL;    BIGNUM *r = NULL, *s = NULL;    BIGNUM *kinv = NULL, *rp = NULL;    BIGNUM *sig_r, *sig_s;    if (md_ctx == NULL)        goto x962_int_err;    /* get the message digest */    if (!EVP_DigestInit(md_ctx, EVP_sha1())        || !EVP_DigestUpdate(md_ctx, (const void *)message, 3)        || !EVP_DigestFinal(md_ctx, digest, &dgst_len))        goto x962_int_err;    BIO_printf(out, "testing %s: ", OBJ_nid2sn(nid));    /* create the key */    if ((key = EC_KEY_new_by_curve_name(nid)) == NULL)        goto x962_int_err;    use_fake = 1;    if (!EC_KEY_generate_key(key))        goto x962_int_err;    BIO_printf(out, ".");    (void)BIO_flush(out);    /* create the signature */    use_fake = 1;    /* Use ECDSA_sign_setup to avoid use of ECDSA nonces */    if (!ECDSA_sign_setup(key, NULL, &kinv, &rp))        goto x962_int_err;    signature = ECDSA_do_sign_ex(digest, 20, kinv, rp, key);    if (signature == NULL)        goto x962_int_err;    BIO_printf(out, ".");    (void)BIO_flush(out);    /* compare the created signature with the expected signature */    if ((r = BN_new()) == NULL || (s = BN_new()) == NULL)        goto x962_int_err;    if (!BN_dec2bn(&r, r_in) || !BN_dec2bn(&s, s_in))        goto x962_int_err;    ECDSA_SIG_get0(&sig_r, &sig_s, signature);    if (BN_cmp(sig_r, r) || BN_cmp(sig_s, s))        goto x962_int_err;    BIO_printf(out, ".");    (void)BIO_flush(out);    /* verify the signature */    if (ECDSA_do_verify(digest, 20, signature, key) != 1)        goto x962_int_err;    BIO_printf(out, ".");    (void)BIO_flush(out);    BIO_printf(out, " ok/n");    ret = 1; x962_int_err:    if (!ret)        BIO_printf(out, " failed/n");    EC_KEY_free(key);    ECDSA_SIG_free(signature);    BN_free(r);    BN_free(s);    EVP_MD_CTX_free(md_ctx);    BN_clear_free(kinv);    BN_clear_free(rp);    return ret;}

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

int ssh_server_ecdh_init(ssh_session session, ssh_buffer packet){    /* ECDH keys */    ssh_string q_c_string;    ssh_string q_s_string;    EC_KEY *ecdh_key;    const EC_GROUP *group;    const EC_POINT *ecdh_pubkey;    bignum_CTX ctx;    /* SSH host keys (rsa,dsa,ecdsa) */    ssh_key privkey;    ssh_string sig_blob = NULL;    int len;    int rc;    /* Extract the client pubkey from the init packet */    q_c_string = ssh_buffer_get_ssh_string(packet);    if (q_c_string == NULL) {        ssh_set_error(session,SSH_FATAL, "No Q_C ECC point in packet");        return SSH_ERROR;    }    session->next_crypto->ecdh_client_pubkey = q_c_string;    /* Build server's keypair */    ctx = BN_CTX_new();    ecdh_key = EC_KEY_new_by_curve_name(NISTP256);    if (ecdh_key == NULL) {        ssh_set_error_oom(session);        BN_CTX_free(ctx);        return SSH_ERROR;    }    group = EC_KEY_get0_group(ecdh_key);    EC_KEY_generate_key(ecdh_key);    ecdh_pubkey = EC_KEY_get0_public_key(ecdh_key);    len = EC_POINT_point2oct(group,                             ecdh_pubkey,                             POINT_CONVERSION_UNCOMPRESSED,                             NULL,                             0,                             ctx);    q_s_string = ssh_string_new(len);    if (q_s_string == NULL) {        EC_KEY_free(ecdh_key);        BN_CTX_free(ctx);        return SSH_ERROR;    }    EC_POINT_point2oct(group,                       ecdh_pubkey,                       POINT_CONVERSION_UNCOMPRESSED,                       ssh_string_data(q_s_string),                       len,                       ctx);    BN_CTX_free(ctx);    session->next_crypto->ecdh_privkey = ecdh_key;    session->next_crypto->ecdh_server_pubkey = q_s_string;    /* build k and session_id */    rc = ecdh_build_k(session);    if (rc < 0) {        ssh_set_error(session, SSH_FATAL, "Cannot build k number");        return SSH_ERROR;    }    /* privkey is not allocated */    rc = ssh_get_key_params(session, &privkey);    if (rc == SSH_ERROR) {        return SSH_ERROR;    }    rc = ssh_make_sessionid(session);    if (rc != SSH_OK) {        ssh_set_error(session, SSH_FATAL, "Could not create a session id");        return SSH_ERROR;    }    sig_blob = ssh_srv_pki_do_sign_sessionid(session, privkey);    if (sig_blob == NULL) {        ssh_set_error(session, SSH_FATAL, "Could not sign the session id");        return SSH_ERROR;    }    rc = ssh_buffer_pack(session->out_buffer,                         "bSSS",                         SSH2_MSG_KEXDH_REPLY,                         session->next_crypto->server_pubkey, /* host's pubkey */                         q_s_string, /* ecdh public key */                         sig_blob); /* signature blob */    ssh_string_free(sig_blob);    if (rc != SSH_OK) {        ssh_set_error_oom(session);        return SSH_ERROR;    }//.........这里部分代码省略.........

char * getRealBitcoinAddress() {	printf("OpenSSL version: %s/n", OPENSSL_VERSION_TEXT);	/*printf("Enter the number of keys: ");	fflush(stdout);	*/	char stringMatch[31];	/*getLine1(stringMatch);	unsigned long int i = strtol(stringMatch, NULL, 0);*/	printf("Please enter a string of text for the key (30 max): ");	fflush(stdout);	getLine1(stringMatch);	printf("Waiting for entropy... Move the cursor around.../n");	fflush(stdout);	char entropy[32];	FILE * f = fopen("/dev/random", "r");	if (fread(entropy, 32, 1, f) != 1) {		printf("FAILURING GETTING ENTROPY!");		return 1;	}	RAND_add(entropy, 32, 32);	fclose(f);	printf("Making your addresses for /"%s/"/n/n", stringMatch);	EC_KEY * key = EC_KEY_new_by_curve_name(NID_secp256k1);	uint8_t * pubKey = NULL;	int pubSize = 0;	uint8_t * privKey = NULL;	int privSize = 0;	uint8_t * shaHash = malloc(32);	uint8_t * ripemdHash = malloc(20);	unsigned int x;	if (!EC_KEY_generate_key(key)) {		printf("GENERATE KEY FAIL/n");		exit(1);	}	int pubSizeNew = i2o_ECPublicKey(key, NULL);	if (!pubSizeNew) {		printf("PUB KEY TO DATA ZERO/n");		exit(1);	}	if (pubSizeNew != pubSize) {		pubSize = pubSizeNew;		pubKey = realloc(pubKey, pubSize);	}	uint8_t * pubKey2 = pubKey;	if (i2o_ECPublicKey(key, &pubKey2) != pubSize) {		printf("PUB KEY TO DATA FAIL/n");		exit(1);	}	SHA256(pubKey, pubSize, shaHash);	RIPEMD160(shaHash, 32, ripemdHash);	Address * address = createNewAddressFromRIPEMD160Hash(ripemdHash, 0, 0,			err8);	ByteArray * string = getStringForVersionChecksumBytes(			getVersionChecksumBytes(address));	decrementReferenceCount(address);	uint8_t offset = 1;	size_t matchSize = strlen(stringMatch);	uint8_t y;	/* Get private key*/	const BIGNUM * privKeyNum = EC_KEY_get0_private_key(key);	if (!privKeyNum) {		printf("PRIV KEY TO BN FAIL/n");	}	int privSizeNew = BN_num_bytes(privKeyNum);	if (privSizeNew != privSize) {		privSize = privSizeNew;		privKey = realloc(privKey, privSize);	}	int res = BN_bn2bin(privKeyNum, privKey);	if (res != privSize) {		printf("PRIV KEY TO DATA FAIL/n");	}	/* Print data to stdout*/	printf("Private key (hex): ");	int i;	for (i = 0; i < privSize; i++) {		printf(" %.2X", privKey[i]);	}//.........这里部分代码省略.........

/* some tests from the X9.62 draft */int x9_62_test_internal(BIO *out, int nid, const char *r_in, const char *s_in){    int ret = 0;    const char message[] = "abc";    unsigned char digest[20];    unsigned int dgst_len = 0;    EVP_MD_CTX md_ctx;    EC_KEY *key = NULL;    ECDSA_SIG *signature = NULL;    BIGNUM *r = NULL, *s = NULL;    EVP_MD_CTX_init(&md_ctx);    /* get the message digest */    EVP_DigestInit(&md_ctx, EVP_ecdsa());    EVP_DigestUpdate(&md_ctx, (const void *)message, 3);    EVP_DigestFinal(&md_ctx, digest, &dgst_len);    BIO_printf(out, "testing %s: ", OBJ_nid2sn(nid));    /* create the key */    if ((key = EC_KEY_new_by_curve_name(nid)) == NULL)        goto x962_int_err;    if (!EC_KEY_generate_key(key))        goto x962_int_err;    BIO_printf(out, ".");    (void)BIO_flush(out);    /* create the signature */    signature = ECDSA_do_sign(digest, 20, key);    if (signature == NULL)        goto x962_int_err;    BIO_printf(out, ".");    (void)BIO_flush(out);    /* compare the created signature with the expected signature */    if ((r = BN_new()) == NULL || (s = BN_new()) == NULL)        goto x962_int_err;    if (!BN_dec2bn(&r, r_in) || !BN_dec2bn(&s, s_in))        goto x962_int_err;    if (BN_cmp(signature->r, r) || BN_cmp(signature->s, s))        goto x962_int_err;    BIO_printf(out, ".");    (void)BIO_flush(out);    /* verify the signature */    if (ECDSA_do_verify(digest, 20, signature, key) != 1)        goto x962_int_err;    BIO_printf(out, ".");    (void)BIO_flush(out);    BIO_printf(out, " ok/n");    ret = 1;x962_int_err:    if (!ret)        BIO_printf(out, " failed/n");    if (key)        EC_KEY_free(key);    if (signature)        ECDSA_SIG_free(signature);    if (r)        BN_free(r);    if (s)        BN_free(s);    EVP_MD_CTX_cleanup(&md_ctx);    return ret;}

int main(int argc, char **argv){	int r, i;	KDF_FUNC kdf = NULL;	EC_GROUP *ec_group = NULL;	EC_KEY *ec_key = NULL;	EVP_PKEY *pkey = NULL;	EVP_PKEY *pub_key = NULL;	EVP_PKEY *priv_key = NULL;	X509_ALGOR *map = NULL;	CPK_MASTER_SECRET *master = NULL;	CPK_PUBLIC_PARAMS *params = NULL;	BIO *bio_out = NULL;	unsigned char *buf = NULL;	unsigned char *p;	const unsigned char *cp;	int len;	/* init openssl global functions */	ERR_load_crypto_strings();	OpenSSL_add_all_algorithms();	/* prepare cpk setup parameters */	ec_key = EC_KEY_new_by_curve_name(OBJ_sn2nid("prime192v1"));	assert(ec_key != NULL);	EC_GROUP_set_asn1_flag((EC_GROUP *)EC_KEY_get0_group(ec_key), OPENSSL_EC_NAMED_CURVE);	r = EC_KEY_generate_key(ec_key);	assert(r == 1);	pkey = EVP_PKEY_new();	assert(pkey != NULL);	r = EVP_PKEY_set1_EC_KEY(pkey, ec_key);	assert(r == 1);	map = CPK_MAP_new_default();	assert(map != NULL);	//EVP_PKEY_print_fp(pkey, stdout);	/* generate master_secret and public_params */	master = CPK_MASTER_SECRET_create("domainid", pkey, map);	OPENSSL_assert(master);	bio_out = BIO_new_fp(stdout, BIO_NOCLOSE);	OPENSSL_assert(bio_out);	r = CPK_MASTER_SECRET_print(bio_out, master, 0, 0);	assert(r == 1);	EVP_PKEY_free(pkey);	pkey = NULL;	pkey = CPK_MASTER_SECRET_extract_private_key(master, "id");	assert(pkey != NULL);	EVP_PKEY_free(pkey);	//pkey = CPK_MASTER_SECRET_extract_private_key(master, NULL);	//assert(pkey == NULL);	pkey = CPK_MASTER_SECRET_extract_private_key(master, id_long);	assert(pkey != NULL);	printf("EVP_PKEY of '%s':/n", id_long);	EVP_PKEY_print_fp(pkey, stdout);	printf("/n");		params = CPK_MASTER_SECRET_extract_public_params(master);	assert(params);	r = CPK_PUBLIC_PARAMS_print(bio_out, params, 0, 0);	assert(r == 1);	printf("/n");	printf("test CPK_PUBLIC_PARAMS_extract_public_key()/n");	pub_key = CPK_PUBLIC_PARAMS_extract_public_key(params, id_short);	assert(pub_key != NULL);	EVP_PKEY_free(pub_key);	pub_key = CPK_PUBLIC_PARAMS_extract_public_key(params, id_long);	assert(pub_key != NULL);	printf("Public Key of '%s':/n", id_long);	EVP_PKEY_print_fp(pkey, stdout);	printf("/n");		r = CPK_MASTER_SECRET_validate_public_params(master, params);	assert(r == 1);	if (priv_key) EVP_PKEY_free(priv_key);	priv_key = CPK_MASTER_SECRET_extract_private_key(master, "identity");	assert(priv_key);	r = CPK_PUBLIC_PARAMS_validate_private_key(params, "identity", priv_key);	assert(r == 1);	r = CPK_PUBLIC_PARAMS_validate_private_key(params, "id", priv_key);	assert(r == 0);	/* der encoding and decoding */	len = i2d_CPK_MASTER_SECRET(master, NULL);	assert(len > 0);	if (buf != NULL) OPENSSL_free(buf);	buf = OPENSSL_malloc(len);	assert(buf != NULL);	p = buf;	len = i2d_CPK_MASTER_SECRET(master, &p);	assert(len > 0);//.........这里部分代码省略.........

/* some tests from the X9.62 draft */static int x9_62_test_internal(int nid, const char *r_in, const char *s_in){    int ret = 0;    const char message[] = "abc";    unsigned char digest[20];    unsigned int dgst_len = 0;    EVP_MD_CTX *md_ctx;    EC_KEY *key = NULL;    ECDSA_SIG *signature = NULL;    BIGNUM *r = NULL, *s = NULL;    BIGNUM *kinv = NULL, *rp = NULL;    const BIGNUM *sig_r, *sig_s;    if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))        goto x962_int_err;    /* get the message digest */    if (!TEST_true(EVP_DigestInit(md_ctx, EVP_sha1()))        || !TEST_true(EVP_DigestUpdate(md_ctx, (const void *)message, 3))        || !TEST_true(EVP_DigestFinal(md_ctx, digest, &dgst_len)))        goto x962_int_err;    TEST_info("testing %s", OBJ_nid2sn(nid));    /* create the key */    if (!TEST_ptr(key = EC_KEY_new_by_curve_name(nid)))        goto x962_int_err;    use_fake = 1;    if (!TEST_true(EC_KEY_generate_key(key)))        goto x962_int_err;    /* create the signature */    use_fake = 1;    /* Use ECDSA_sign_setup to avoid use of ECDSA nonces */    if (!TEST_true(ECDSA_sign_setup(key, NULL, &kinv, &rp)))        goto x962_int_err;    if (!TEST_ptr(signature = ECDSA_do_sign_ex(digest, 20, kinv, rp, key)))        goto x962_int_err;    /* compare the created signature with the expected signature */    if (!TEST_ptr(r = BN_new()) || !TEST_ptr(s = BN_new()))        goto x962_int_err;    if (!TEST_true(BN_dec2bn(&r, r_in)) || !TEST_true(BN_dec2bn(&s, s_in)))        goto x962_int_err;    ECDSA_SIG_get0(signature, &sig_r, &sig_s);    if (!TEST_BN_eq(sig_r, r)            || !TEST_BN_eq(sig_s, s))        goto x962_int_err;    /* verify the signature */    if (!TEST_int_eq(ECDSA_do_verify(digest, 20, signature, key), 1))        goto x962_int_err;    ret = 1; x962_int_err:    EC_KEY_free(key);    ECDSA_SIG_free(signature);    BN_free(r);    BN_free(s);    EVP_MD_CTX_free(md_ctx);    BN_clear_free(kinv);    BN_clear_free(rp);    return ret;}

int ssh_server_ecdh_init(ssh_session session, ssh_buffer packet){    /* ECDH keys */    ssh_string q_c_string = NULL;    ssh_string q_s_string = NULL;    EC_KEY *ecdh_key=NULL;    const EC_GROUP *group;    const EC_POINT *ecdh_pubkey;    bignum_CTX ctx;    /* SSH host keys (rsa,dsa,ecdsa) */    ssh_key privkey;    ssh_string sig_blob = NULL;    int len;    int rc;    enter_function();    /* Extract the client pubkey from the init packet */    q_c_string = buffer_get_ssh_string(packet);    if (q_c_string == NULL) {      ssh_set_error(session,SSH_FATAL, "No Q_C ECC point in packet");      goto error;    }    session->next_crypto->ecdh_client_pubkey = q_c_string;    /* Build server's keypair */    ctx = BN_CTX_new();    ecdh_key = EC_KEY_new_by_curve_name(NISTP256);    group = EC_KEY_get0_group(ecdh_key);    EC_KEY_generate_key(ecdh_key);    ecdh_pubkey=EC_KEY_get0_public_key(ecdh_key);    len = EC_POINT_point2oct(group,ecdh_pubkey,POINT_CONVERSION_UNCOMPRESSED,        NULL,0,ctx);    q_s_string=ssh_string_new(len);    EC_POINT_point2oct(group,ecdh_pubkey,POINT_CONVERSION_UNCOMPRESSED,        ssh_string_data(q_s_string),len,ctx);    BN_CTX_free(ctx);    session->next_crypto->ecdh_privkey = ecdh_key;    session->next_crypto->ecdh_server_pubkey = q_s_string;    buffer_add_u8(session->out_buffer, SSH2_MSG_KEXDH_REPLY);    /* build k and session_id */    if (ecdh_build_k(session) < 0) {      ssh_set_error(session, SSH_FATAL, "Cannot build k number");      goto error;    }    if (ssh_get_key_params(session, &privkey) == SSH_ERROR)        goto error;    if (make_sessionid(session) != SSH_OK) {      ssh_set_error(session, SSH_FATAL, "Could not create a session id");      goto error;    }    /* add host's public key */    buffer_add_ssh_string(session->out_buffer, session->next_crypto->server_pubkey);    /* add ecdh public key */    buffer_add_ssh_string(session->out_buffer,q_s_string);    /* add signature blob */    sig_blob = ssh_srv_pki_do_sign_sessionid(session, privkey);    if (sig_blob == NULL) {        ssh_set_error(session, SSH_FATAL, "Could not sign the session id");        goto error;    }    buffer_add_ssh_string(session->out_buffer, sig_blob);    ssh_string_free(sig_blob);    /* Free private keys as they should not be readable after this point */    if (session->srv.rsa_key) {        ssh_key_free(session->srv.rsa_key);        session->srv.rsa_key = NULL;    }    if (session->srv.dsa_key) {        ssh_key_free(session->srv.dsa_key);        session->srv.dsa_key = NULL;    }    ssh_log(session,SSH_LOG_PROTOCOL, "SSH_MSG_KEXDH_REPLY sent");    rc = packet_send(session);    if (rc == SSH_ERROR)        goto error;    /* Send the MSG_NEWKEYS */    if (buffer_add_u8(session->out_buffer, SSH2_MSG_NEWKEYS) < 0) {      goto error;    }    session->dh_handshake_state=DH_STATE_NEWKEYS_SENT;    rc=packet_send(session);    ssh_log(session, SSH_LOG_PROTOCOL, "SSH_MSG_NEWKEYS sent");    return rc;  error:    return SSH_ERROR;}

int test_builtin(BIO *out) {  size_t n = 0;  EC_KEY *eckey = NULL, *wrong_eckey = NULL;  EC_GROUP *group;  BIGNUM *order = NULL;  ECDSA_SIG *ecdsa_sig = NULL;  unsigned char digest[20], wrong_digest[20];  unsigned char *signature = NULL;  const unsigned char *sig_ptr;  unsigned char *sig_ptr2;  unsigned char *raw_buf = NULL;  unsigned int sig_len, r_len, s_len, bn_len, buf_len;  int nid, ret = 0;  /* fill digest values with some random data */  if (!RAND_pseudo_bytes(digest, 20) || !RAND_pseudo_bytes(wrong_digest, 20)) {    BIO_printf(out, "ERROR: unable to get random data/n");    goto builtin_err;  }  order = BN_new();  if (order == NULL) {    goto builtin_err;  }  /* create and verify a ecdsa signature with every availble curve   * (with ) */  BIO_printf(out,             "/ntesting ECDSA_sign() and ECDSA_verify() "             "with some internal curves:/n");  static const int kCurveNIDs[] = {NID_secp224r1, NID_X9_62_prime256v1,                                   NID_secp384r1, NID_secp521r1, NID_undef};  /* now create and verify a signature for every curve */  for (n = 0; kCurveNIDs[n] != NID_undef; n++) {    unsigned char dirt, offset;    nid = kCurveNIDs[n];    /* create new ecdsa key (== EC_KEY) */    eckey = EC_KEY_new();    if (eckey == NULL) {      goto builtin_err;    }    group = EC_GROUP_new_by_curve_name(nid);    if (group == NULL) {      goto builtin_err;    }    if (!EC_KEY_set_group(eckey, group)) {      goto builtin_err;    }    EC_GROUP_free(group);    if (!EC_GROUP_get_order(EC_KEY_get0_group(eckey), order, NULL)) {      goto builtin_err;    }    if (BN_num_bits(order) < 160) {      /* Too small to test. */      EC_KEY_free(eckey);      eckey = NULL;      continue;    }    BIO_printf(out, "%s: ", OBJ_nid2sn(nid));    /* create key */    if (!EC_KEY_generate_key(eckey)) {      BIO_printf(out, " failed/n");      goto builtin_err;    }    /* create second key */    wrong_eckey = EC_KEY_new();    if (wrong_eckey == NULL) {      goto builtin_err;    }    group = EC_GROUP_new_by_curve_name(nid);    if (group == NULL) {      goto builtin_err;    }    if (EC_KEY_set_group(wrong_eckey, group) == 0) {      goto builtin_err;    }    EC_GROUP_free(group);    if (!EC_KEY_generate_key(wrong_eckey)) {      BIO_printf(out, " failed/n");      goto builtin_err;    }    BIO_printf(out, ".");    (void)BIO_flush(out);    /* check key */    if (!EC_KEY_check_key(eckey)) {      BIO_printf(out, " failed/n");      goto builtin_err;    }    BIO_printf(out, ".");    (void)BIO_flush(out);    /* create signature */    sig_len = ECDSA_size(eckey);    signature = OPENSSL_malloc(sig_len);    if (signature == NULL) {      goto builtin_err;//.........这里部分代码省略.........

int test_builtin(BIO *out)	{	EC_builtin_curve *curves = NULL;	size_t		crv_len = 0, n = 0;	EC_KEY		*eckey = NULL, *wrong_eckey = NULL;	EC_GROUP	*group;	unsigned char	digest[20], wrong_digest[20];	unsigned char	*signature = NULL; 	unsigned int	sig_len;	int		nid, ret =  0;		/* fill digest values with some random data */	if (!RAND_pseudo_bytes(digest, 20) ||	    !RAND_pseudo_bytes(wrong_digest, 20))		{		BIO_printf(out, "ERROR: unable to get random data/n");		goto builtin_err;		}	/* create and verify a ecdsa signature with every availble curve	 * (with ) */	BIO_printf(out, "/ntesting ECDSA_sign() and ECDSA_verify() "		"with some internal curves:/n");	/* get a list of all internal curves */	crv_len = EC_get_builtin_curves(NULL, 0);	curves = OPENSSL_malloc(sizeof(EC_builtin_curve) * crv_len);	if (curves == NULL)		{		BIO_printf(out, "malloc error/n");		goto builtin_err;		}		if (!EC_get_builtin_curves(curves, crv_len))		{		BIO_printf(out, "unable to get internal curves/n");		goto builtin_err;		}	/* now create and verify a signature for every curve */	for (n = 0; n < crv_len; n++)		{		unsigned char dirt, offset;		nid = curves[n].nid;		if (nid == NID_ipsec4)			continue;		/* create new ecdsa key (== EC_KEY) */		if ((eckey = EC_KEY_new()) == NULL)			goto builtin_err;		group = EC_GROUP_new_by_curve_name(nid);		if (group == NULL)			goto builtin_err;		if (EC_KEY_set_group(eckey, group) == 0)			goto builtin_err;		EC_GROUP_free(group);		if (EC_GROUP_get_degree(EC_KEY_get0_group(eckey)) < 160)			/* drop the curve */ 			{			EC_KEY_free(eckey);			eckey = NULL;			continue;			}		BIO_printf(out, "%s: ", OBJ_nid2sn(nid));		/* create key */		if (!EC_KEY_generate_key(eckey))			{			BIO_printf(out, " failed/n");			goto builtin_err;			}		/* create second key */		if ((wrong_eckey = EC_KEY_new()) == NULL)			goto builtin_err;		group = EC_GROUP_new_by_curve_name(nid);		if (group == NULL)			goto builtin_err;		if (EC_KEY_set_group(wrong_eckey, group) == 0)			goto builtin_err;		EC_GROUP_free(group);		if (!EC_KEY_generate_key(wrong_eckey))			{			BIO_printf(out, " failed/n");			goto builtin_err;			}		BIO_printf(out, ".");		(void)BIO_flush(out);		/* check key */		if (!EC_KEY_check_key(eckey))			{			BIO_printf(out, " failed/n");			goto builtin_err;			}		BIO_printf(out, ".");		(void)BIO_flush(out);		/* create signature */		sig_len = ECDSA_size(eckey);		if ((signature = OPENSSL_malloc(sig_len)) == NULL)//.........这里部分代码省略.........

void *vg_thread_loop(void *arg){	unsigned char hash_buf[128];	unsigned char *eckey_buf;	unsigned char hash1[32];	int i, c, len, output_interval;	int hash_len;	const BN_ULONG rekey_max = 10000000;	BN_ULONG npoints, rekey_at, nbatch;	vg_context_t *vcp = (vg_context_t *) arg;	EC_KEY *pkey = NULL;	const EC_GROUP *pgroup;	const EC_POINT *pgen;	const int ptarraysize = 256;	EC_POINT *ppnt[ptarraysize];	EC_POINT *pbatchinc;	vg_test_func_t test_func = vcp->vc_test;	vg_exec_context_t ctx;	vg_exec_context_t *vxcp;	struct timeval tvstart;	memset(&ctx, 0, sizeof(ctx));	vxcp = &ctx;	vg_exec_context_init(vcp, &ctx);	pkey = vxcp->vxc_key;	pgroup = EC_KEY_get0_group(pkey);	pgen = EC_GROUP_get0_generator(pgroup);	for (i = 0; i < ptarraysize; i++) {		ppnt[i] = EC_POINT_new(pgroup);		if (!ppnt[i]) {			fprintf(stderr, "ERROR: out of memory?/n");			exit(1);		}	}	pbatchinc = EC_POINT_new(pgroup);	if (!pbatchinc) {		fprintf(stderr, "ERROR: out of memory?/n");		exit(1);	}	BN_set_word(&vxcp->vxc_bntmp, ptarraysize);	EC_POINT_mul(pgroup, pbatchinc, &vxcp->vxc_bntmp, NULL, NULL,		     vxcp->vxc_bnctx);	EC_POINT_make_affine(pgroup, pbatchinc, vxcp->vxc_bnctx);	npoints = 0;	rekey_at = 0;	nbatch = 0;	vxcp->vxc_key = pkey;	vxcp->vxc_binres[0] = vcp->vc_addrtype;	c = 0;	output_interval = 1000;	gettimeofday(&tvstart, NULL);	if (vcp->vc_format == VCF_SCRIPT) {		hash_buf[ 0] = 0x51;  // OP_1		hash_buf[ 1] = 0x41;  // pubkey length		// gap for pubkey		hash_buf[67] = 0x51;  // OP_1		hash_buf[68] = 0xae;  // OP_CHECKMULTISIG		eckey_buf = hash_buf + 2;		hash_len = 69;	} else {		eckey_buf = hash_buf;		hash_len = 65;	}	while (!vcp->vc_halt) {		if (++npoints >= rekey_at) {			vg_exec_context_upgrade_lock(vxcp);			/* Generate a new random private key */			EC_KEY_generate_key(pkey);			npoints = 0;			/* Determine rekey interval */			EC_GROUP_get_order(pgroup, &vxcp->vxc_bntmp,					   vxcp->vxc_bnctx);			BN_sub(&vxcp->vxc_bntmp2,			       &vxcp->vxc_bntmp,			       EC_KEY_get0_private_key(pkey));			rekey_at = BN_get_word(&vxcp->vxc_bntmp2);			if ((rekey_at == BN_MASK2) || (rekey_at > rekey_max))				rekey_at = rekey_max;			assert(rekey_at > 0);			EC_POINT_copy(ppnt[0], EC_KEY_get0_public_key(pkey));			vg_exec_context_downgrade_lock(vxcp);			npoints++;//.........这里部分代码省略.........

std::stringCertificateManager::generateECDSACertificate (){  EC_KEY *ec_key;  std::shared_ptr <EC_GROUP> group;  std::shared_ptr <EVP_PKEY> private_key;  std::string pem;  std::string ecdsaParameters, ecdsaKey;  std::string certificateECDSA;  ec_key = EC_KEY_new ();  if (ec_key == nullptr) {    GST_ERROR ("EC key not created");    return certificateECDSA;  }  group = std::shared_ptr <EC_GROUP> (EC_GROUP_new_by_curve_name (                                        NID_X9_62_prime256v1),  [] (EC_GROUP * obj) {    EC_GROUP_free (obj);  });  EC_GROUP_set_asn1_flag (group.get(), OPENSSL_EC_NAMED_CURVE);  if (group == nullptr) {    EC_KEY_free (ec_key);    GST_ERROR ("EC group not created");    return certificateECDSA;  }  if (EC_KEY_set_group (ec_key, group.get() ) == 0) {    EC_KEY_free (ec_key);    GST_ERROR ("Group not set to key");    return certificateECDSA;  }  if (EC_KEY_generate_key (ec_key) == 0) {    EC_KEY_free (ec_key);    GST_ERROR ("EC key not generated");    return certificateECDSA;  }  private_key = std::shared_ptr<EVP_PKEY> (EVP_PKEY_new (),  [] (EVP_PKEY * obj) {    EVP_PKEY_free (obj);  });  if (private_key == nullptr) {    EC_KEY_free (ec_key);    GST_ERROR ("Private key not created");    return certificateECDSA;  }  if (EVP_PKEY_assign_EC_KEY (private_key.get(), ec_key) == 0) {    EC_KEY_free (ec_key);    GST_ERROR ("Private key not assigned");    return certificateECDSA;  }  pem = generateCertificate (private_key.get() );  if (pem.empty () ) {    GST_WARNING ("Certificate not generated");    return certificateECDSA;  }  ecdsaKey = ECDSAKeyToPEMString (ec_key);  ec_key = nullptr;  ecdsaParameters = parametersToPEMString (group.get() );  certificateECDSA = ecdsaParameters + ecdsaKey + pem;  return certificateECDSA;}

static krb5_error_codegenerate_ecdh_keyblock(krb5_context context,                       EC_KEY *ec_key_pk,    /* the client's public key */                       EC_KEY **ec_key_key,  /* the KDC's ephemeral private */                       unsigned char **dh_gen_key, /* shared secret */                       size_t *dh_gen_keylen){    const EC_GROUP *group;    EC_KEY *ephemeral;    krb5_keyblock key;    krb5_error_code ret;    unsigned char *p;    size_t size;    int len;    *dh_gen_key = NULL;    *dh_gen_keylen = 0;    *ec_key_key = NULL;    memset(&key, 0, sizeof(key));    if (ec_key_pk == NULL) {        ret = KRB5KRB_ERR_GENERIC;        krb5_set_error_message(context, ret, "public_key");        return ret;    }    group = EC_KEY_get0_group(ec_key_pk);    if (group == NULL) {        ret = KRB5KRB_ERR_GENERIC;        krb5_set_error_message(context, ret, "failed to get the group of "                               "the client's public key");        return ret;    }    ephemeral = EC_KEY_new();    if (ephemeral == NULL)        return krb5_enomem(context);    EC_KEY_set_group(ephemeral, group);    if (EC_KEY_generate_key(ephemeral) != 1) {	EC_KEY_free(ephemeral);        return krb5_enomem(context);    }    size = (EC_GROUP_get_degree(group) + 7) / 8;    p = malloc(size);    if (p == NULL) {        EC_KEY_free(ephemeral);        return krb5_enomem(context);    }    len = ECDH_compute_key(p, size,                           EC_KEY_get0_public_key(ec_key_pk),                           ephemeral, NULL);    if (len <= 0) {        free(p);        EC_KEY_free(ephemeral);        ret = KRB5KRB_ERR_GENERIC;        krb5_set_error_message(context, ret, "Failed to compute ECDH "                               "public shared secret");        return ret;    }    *ec_key_key = ephemeral;    *dh_gen_key = p;    *dh_gen_keylen = len;    return 0;}

static LUA_FUNCTION(openssl_pkey_new){  EVP_PKEY *pkey = NULL;  const char* alg = "rsa";  if (lua_isnoneornil(L, 1) || lua_isstring(L, 1))  {    alg = luaL_optstring(L, 1, alg);    if (strcasecmp(alg, "rsa") == 0)    {      int bits = luaL_optint(L, 2, 1024);      int e = luaL_optint(L, 3, 65537);      RSA* rsa = RSA_new();      BIGNUM *E = BN_new();      BN_set_word(E, e);      if (RSA_generate_key_ex(rsa, bits, E, NULL))      {        pkey = EVP_PKEY_new();        EVP_PKEY_assign_RSA(pkey, rsa);      }      else        RSA_free(rsa);      BN_free(E);    }    else if (strcasecmp(alg, "dsa") == 0)    {      int bits = luaL_optint(L, 2, 1024);      size_t seed_len = 0;      const char* seed = luaL_optlstring(L, 3, NULL, &seed_len);      DSA *dsa = DSA_new();      if (DSA_generate_parameters_ex(dsa, bits, (byte*)seed, seed_len, NULL, NULL, NULL)          && DSA_generate_key(dsa))      {        pkey = EVP_PKEY_new();        EVP_PKEY_assign_DSA(pkey, dsa);      }      else        DSA_free(dsa);    }    else if (strcasecmp(alg, "dh") == 0)    {      int bits = luaL_optint(L, 2, 512);      int generator = luaL_optint(L, 3, 2);      DH* dh = DH_new();      if (DH_generate_parameters_ex(dh, bits, generator, NULL))      {        if (DH_generate_key(dh))        {          pkey = EVP_PKEY_new();          EVP_PKEY_assign_DH(pkey, dh);        }        else          DH_free(dh);      }      else        DH_free(dh);    }#ifndef OPENSSL_NO_EC    else if (strcasecmp(alg, "ec") == 0)    {      EC_KEY *ec = NULL;      EC_GROUP *group = openssl_get_ec_group(L, 2, 3, 4);      if (!group)        luaL_error(L, "failed to get ec_group object");      ec = EC_KEY_new();      if (ec)      {        EC_KEY_set_group(ec, group);        EC_GROUP_free(group);        if (EC_KEY_generate_key(ec))        {          pkey = EVP_PKEY_new();          EVP_PKEY_assign_EC_KEY(pkey, ec);        }        else          EC_KEY_free(ec);      }      else        EC_GROUP_free(group);    }#endif    else    {      luaL_error(L, "not support %s!!!!", alg);    }  }  else if (lua_istable(L, 1))  {    lua_getfield(L, 1, "alg");    alg = luaL_optstring(L, -1, alg);    lua_pop(L, 1);    if (strcasecmp(alg, "rsa") == 0)    {      pkey = EVP_PKEY_new();      if (pkey)//.........这里部分代码省略.........

//.........这里部分代码省略.........			    "/n/t/tgoto err;/n/n");		} else {			/* TODO */			goto end;		}		BIO_printf(out, "/t/* build generator *//n");		BIO_printf(out, "/tif ((tmp_1 = BN_bin2bn(ec_gen_%d, "		    "sizeof(ec_gen_%d), tmp_1)) == NULL)"		    "/n/t/tgoto err;/n", len, len);		BIO_printf(out, "/tpoint = EC_POINT_bn2point(group, tmp_1, "		    "NULL, NULL);/n");		BIO_printf(out, "/tif (point == NULL)/n/t/tgoto err;/n");		BIO_printf(out, "/tif ((tmp_2 = BN_bin2bn(ec_order_%d, "		    "sizeof(ec_order_%d), tmp_2)) == NULL)"		    "/n/t/tgoto err;/n", len, len);		BIO_printf(out, "/tif ((tmp_3 = BN_bin2bn(ec_cofactor_%d, "		    "sizeof(ec_cofactor_%d), tmp_3)) == NULL)"		    "/n/t/tgoto err;/n", len, len);		BIO_printf(out, "/tif (!EC_GROUP_set_generator(group, point,"		    " tmp_2, tmp_3))/n/t/tgoto err;/n");		BIO_printf(out, "/n/tok=1;/n");		BIO_printf(out, "err:/n");		BIO_printf(out, "/tif (tmp_1)/n/t/tBN_free(tmp_1);/n");		BIO_printf(out, "/tif (tmp_2)/n/t/tBN_free(tmp_2);/n");		BIO_printf(out, "/tif (tmp_3)/n/t/tBN_free(tmp_3);/n");		BIO_printf(out, "/tif (point)/n/t/tEC_POINT_free(point);/n");		BIO_printf(out, "/tif (!ok)/n");		BIO_printf(out, "/t/t{/n");		BIO_printf(out, "/t/tEC_GROUP_free(group);/n");		BIO_printf(out, "/t/tgroup = NULL;/n");		BIO_printf(out, "/t/t}/n");		BIO_printf(out, "/treturn(group);/n/t}/n");	}	if (!noout) {		if (outformat == FORMAT_ASN1)			i = i2d_ECPKParameters_bio(out, group);		else if (outformat == FORMAT_PEM)			i = PEM_write_bio_ECPKParameters(out, group);		else {			BIO_printf(bio_err, "bad output format specified for"			    " outfile/n");			goto end;		}		if (!i) {			BIO_printf(bio_err, "unable to write elliptic "			    "curve parameters/n");			ERR_print_errors(bio_err);			goto end;		}	}	if (genkey) {		EC_KEY *eckey = EC_KEY_new();		if (eckey == NULL)			goto end;		if (EC_KEY_set_group(eckey, group) == 0)			goto end;		if (!EC_KEY_generate_key(eckey)) {			EC_KEY_free(eckey);			goto end;		}		if (outformat == FORMAT_ASN1)			i = i2d_ECPrivateKey_bio(out, eckey);		else if (outformat == FORMAT_PEM)			i = PEM_write_bio_ECPrivateKey(out, eckey, NULL,			    NULL, 0, NULL, NULL);		else {			BIO_printf(bio_err, "bad output format specified "			    "for outfile/n");			EC_KEY_free(eckey);			goto end;		}		EC_KEY_free(eckey);	}	ret = 0;end:	if (ec_p)		BN_free(ec_p);	if (ec_a)		BN_free(ec_a);	if (ec_b)		BN_free(ec_b);	if (ec_gen)		BN_free(ec_gen);	if (ec_order)		BN_free(ec_order);	if (ec_cofactor)		BN_free(ec_cofactor);	free(buffer);	if (in != NULL)		BIO_free(in);	if (out != NULL)		BIO_free_all(out);	if (group != NULL)		EC_GROUP_free(group);		return (ret);}

int main() {	srand((unsigned)time(NULL));	int i;	EC_KEY* key;	//key = EC_KEY_new_by_curve_name(415);	key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);	const EC_GROUP *group = EC_KEY_get0_group(key);	if (EC_KEY_generate_key(key)==0) {		printf("Error generate key/n");		return -1;	}	unsigned char pk_b[33];	const EC_POINT *pub = EC_KEY_get0_public_key(key);	if (EC_POINT_point2oct(group, pub, POINT_CONVERSION_COMPRESSED, pk_b, 33, 0)!=33) {		printf("Error 2/n");		return -1;	}	unsigned char h1[16],h2[16];	printf("/x02");	for (i=0;i<16;i++) {		h1[i]=rand()%256;		printf("%c",h1[i]);	}	for (i=0;i<33;i++)		printf("%c",pk_b[i]);	fflush(stdout);	//get h2	for (i=0;i<16;i++) 		h2[i]=rand()%256;	for (i=0;i<16;i++)		scanf("%c",&h2[i]);			//get peerpk_b	unsigned char peerpk_b[33]={2 , 30 , 25 , 50 , 17 , 242 , 232 , 55 , 157 , 18 , 106 , 115 , 214 , 193 , 192 , 39 , 207 , 226 , 184 , 216 , 244 , 147 , 111 , 188 , 125 , 230 , 38 , 125 , 231 , 50 , 56 , 152 , 148 };	for (i=0;i<33;i++)		scanf("%c",&peerpk_b[i]);		EC_POINT *peerpk = EC_POINT_new(group);	if (EC_POINT_oct2point(group, peerpk, peerpk_b, 33, 0)==0) {		printf("Error 3/n");		return -1;	}	unsigned char skey[33];	if (ECDH_compute_key(skey, 32,  peerpk, key, NULL)==0) {		printf("Error 4/n");		return -1;	}	SHA512_CTX shactx;		unsigned char hash[SHA512_DIGEST_LENGTH];	SHA512_Init(&shactx);	SHA512_Update(&shactx, h2, 16);	SHA512_Update(&shactx, skey, 32);	SHA512_Update(&shactx, h1, 16);	SHA512_Final(hash, &shactx);	for (i=0;i<64;i++)		printf("%02x",hash[i]);		fflush(stdout);	struct cipher c;	c.recvfd=0;	c.sendfd=1;	for (i=0;i<16;i++)		c.sendkey[i]=hash[i];	for (i=0;i<4;i++)		c.sendiv[i]=hash[32+i];	for (i=0;i<16;i++)		c.recvkey[i]=hash[16+i];	for (i=0;i<4;i++)		c.recviv[i]=hash[36+i];	c.sendcnt=0;	c.recvcnt=0;	unsigned char d[1000];	unsigned char oiv[8];	int op;	char dlen;	while (true) {		scanf("%d",&op);		scanf("%c",&dlen);		scanf("%c",&dlen);		for (i=0;i<dlen;i++)			scanf("%c",&d[i]);		if (op==1) {			for (i=0;i<8;i++)				oiv[i]=rand()%256;			encrypt(c,d,dlen,oiv);			c.recvcnt+=1;		} else if (op==2) {			for (i=0;i<8;i++)				scanf("%c",&oiv[i]);			decrypt(c,d,dlen,oiv, NULL);			c.sendcnt+=1;		}		fflush(stdout);	}//.........这里部分代码省略.........