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

int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key){	int ret = EVP_PKEY_assign_DH(pkey, key);	if(ret)		DH_up_ref(key);	return ret;}

static VALUEossl_dh_initialize_copy(VALUE self, VALUE other){    EVP_PKEY *pkey;    DH *dh, *dh_other;    const BIGNUM *pub, *priv;    GetPKey(self, pkey);    if (EVP_PKEY_base_id(pkey) != EVP_PKEY_NONE)	ossl_raise(eDHError, "DH already initialized");    GetDH(other, dh_other);    dh = DHparams_dup(dh_other);    if (!dh)	ossl_raise(eDHError, "DHparams_dup");    EVP_PKEY_assign_DH(pkey, dh);    DH_get0_key(dh_other, &pub, &priv);    if (pub) {	BIGNUM *pub2 = BN_dup(pub);	BIGNUM *priv2 = BN_dup(priv);	if (!pub2 || priv && !priv2) {	    BN_clear_free(pub2);	    BN_clear_free(priv2);	    ossl_raise(eDHError, "BN_dup");	}	DH_set0_key(dh, pub2, priv2);    }    return self;}

int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key) {    if (EVP_PKEY_assign_DH(pkey, key)) {        DH_up_ref(key);        return 1;    }    return 0;}

static int pkey_dh_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey){    DH *dh = NULL;    DH_PKEY_CTX *dctx = ctx->data;    BN_GENCB *pcb, cb;    int ret;    if (dctx->rfc5114_param) {        switch (dctx->rfc5114_param) {        case 1:            dh = DH_get_1024_160();            break;        case 2:            dh = DH_get_2048_224();            break;        case 3:            dh = DH_get_2048_256();            break;        default:            return -2;        }        EVP_PKEY_assign(pkey, EVP_PKEY_DHX, dh);        return 1;    }    if (ctx->pkey_gencb) {        pcb = &cb;        evp_pkey_set_cb_translate(pcb, ctx);    } else        pcb = NULL;#ifndef OPENSSL_NO_DSA    if (dctx->use_dsa) {        DSA *dsa_dh;        dsa_dh = dsa_dh_generate(dctx, pcb);        if (!dsa_dh)            return 0;        dh = DSA_dup_DH(dsa_dh);        DSA_free(dsa_dh);        if (!dh)            return 0;        EVP_PKEY_assign(pkey, EVP_PKEY_DHX, dh);        return 1;    }#endif    dh = DH_new();    if (!dh)        return 0;    ret = DH_generate_parameters_ex(dh,                                    dctx->prime_len, dctx->generator, pcb);    if (ret)        EVP_PKEY_assign_DH(pkey, dh);    else        DH_free(dh);    return ret;}

static int dh_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)	{	const unsigned char *p, *pm;	int pklen, pmlen;	int ptype;	void *pval;	ASN1_STRING *pstr;	X509_ALGOR *palg;	ASN1_INTEGER *public_key = NULL;	DH *dh = NULL;	if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &palg, pubkey))		return 0;	X509_ALGOR_get0(NULL, &ptype, &pval, palg);	if (ptype != V_ASN1_SEQUENCE)		{		DHerr(DH_F_DH_PUB_DECODE, DH_R_PARAMETER_ENCODING_ERROR);		goto err;		}	pstr = pval;		pm = pstr->data;	pmlen = pstr->length;	if (!(dh = d2i_DHparams(NULL, &pm, pmlen)))		{		DHerr(DH_F_DH_PUB_DECODE, DH_R_DECODE_ERROR);		goto err;		}	if (!(public_key=d2i_ASN1_INTEGER(NULL, &p, pklen)))		{		DHerr(DH_F_DH_PUB_DECODE, DH_R_DECODE_ERROR);		goto err;		}	/* We have parameters now set public key */	if (!(dh->pub_key = ASN1_INTEGER_to_BN(public_key, NULL)))		{		DHerr(DH_F_DH_PUB_DECODE, DH_R_BN_DECODE_ERROR);		goto err;		}	ASN1_INTEGER_free(public_key);	EVP_PKEY_assign_DH(pkey, dh);	return 1;	err:	if (public_key)		ASN1_INTEGER_free(public_key);	if (dh)		DH_free(dh);	return 0;	}

static int dh_priv_decode (EVP_PKEY * pkey, PKCS8_PRIV_KEY_INFO * p8){    const unsigned char *p, *pm;    int pklen, pmlen;    int ptype;    void *pval;    ASN1_STRING *pstr;    X509_ALGOR *palg;    ASN1_INTEGER *privkey = NULL;    DH *dh = NULL;    if (!PKCS8_pkey_get0 (NULL, &p, &pklen, &palg, p8))        return 0;    X509_ALGOR_get0 (NULL, &ptype, &pval, palg);    if (ptype != V_ASN1_SEQUENCE)        goto decerr;    if (!(privkey = d2i_ASN1_INTEGER (NULL, &p, pklen)))        goto decerr;    pstr = pval;    pm = pstr->data;    pmlen = pstr->length;    if (!(dh = d2i_DHparams (NULL, &pm, pmlen)))        goto decerr;    /* We have parameters now set private key */    if (!(dh->priv_key = ASN1_INTEGER_to_BN (privkey, NULL)))    {        DHerr (DH_F_DH_PRIV_DECODE, DH_R_BN_ERROR);        goto dherr;    }    /* Calculate public key */    if (!DH_generate_key (dh))        goto dherr;    EVP_PKEY_assign_DH (pkey, dh);    ASN1_INTEGER_free (privkey);    return 1;  decerr:    DHerr (DH_F_DH_PRIV_DECODE, EVP_R_DECODE_ERROR);  dherr:    DH_free (dh);    return 0;}

static EP_STATgenerate_dh_key(EP_CRYPTO_KEY *key, ...){	DH *dhkey = DH_generate_key(keylen, XXX);	if (dhkey == NULL)		return _ep_crypto_error("cannot generate DH key");	if (EVP_PKEY_assign_DH(key, dhkey) != 1)		return _ep_crypto_error("cannot save DH key");}

static int dh_param_decode(EVP_PKEY *pkey,					const unsigned char **pder, int derlen)	{	DH *dh;	if (!(dh = d2i_DHparams(NULL, pder, derlen)))		{		DHerr(DH_F_DH_PARAM_DECODE, ERR_R_DH_LIB);		return 0;		}	EVP_PKEY_assign_DH(pkey, dh);	return 1;	}

/* * Public */static VALUEdh_instance(VALUE klass, DH *dh){    EVP_PKEY *pkey;    VALUE obj;    if (!dh) {	return Qfalse;    }    if (!(pkey = EVP_PKEY_new())) {	return Qfalse;    }    if (!EVP_PKEY_assign_DH(pkey, dh)) {	EVP_PKEY_free(pkey);	return Qfalse;    }    WrapPKey(klass, obj, pkey);    return obj;}

/* *  call-seq: *     DH.new([size [, generator] | string]) -> dh * * Either generates a DH instance from scratch or by reading already existing * DH parameters from +string+. Note that when reading a DH instance from * data that was encoded from a DH instance by using DH#to_pem or DH#to_der * the result will *not* contain a public/private key pair yet. This needs to * be generated using DH#generate_key! first. * * === Parameters * * +size+ is an integer representing the desired key size. Keys smaller than 1024 bits should be considered insecure. * * +generator+ is a small number > 1, typically 2 or 5. * * +string+ contains the DER or PEM encoded key. * * === Examples *  DH.new # -> dh *  DH.new(1024) # -> dh *  DH.new(1024, 5) # -> dh *  #Reading DH parameters *  dh = DH.new(File.read('parameters.pem')) # -> dh, but no public/private key yet *  dh.generate_key! # -> dh with public and private key */static VALUEossl_dh_initialize(int argc, VALUE *argv, VALUE self){    EVP_PKEY *pkey;    DH *dh;    int g = 2;    BIO *in;    VALUE arg, gen;    GetPKey(self, pkey);    if(RB_SCAN_ARGS_02(argc, argv, "02", &arg, &gen) == 0) {      dh = DH_new();    }    else if (FIXNUM_P(arg)) {	if (!NIL_P(gen)) {	    g = NUM2INT(gen);	}	if (!(dh = dh_generate(FIX2INT(arg), g))) {	    ossl_raise(eDHError, NULL);	}    }    else {	arg = ossl_to_der_if_possible(arg);	in = ossl_obj2bio(arg);	dh = PEM_read_bio_DHparams(in, NULL, NULL, NULL);	if (!dh){	    OSSL_BIO_reset(in);	    dh = d2i_DHparams_bio(in, NULL);	}	BIO_free(in);	if (!dh) {	    ossl_raise(eDHError, NULL);	}    }    if (!EVP_PKEY_assign_DH(pkey, dh)) {	DH_free(dh);	ossl_raise(eDHError, NULL);    }    return self;}

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

int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key){	int ret = EVP_PKEY_assign_DH(pkey, key);	if(ret) CRYPTO_add(&key->references, 1, CRYPTO_LOCK_DH);	return ret;}