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

/* * Copy the serial number from src certificate to dst certificate * and modify it by a random offset. * If reading the serial fails for some reason, generate a new * random serial and store it in the dst certificate. * Using the same serial is not a good idea since some SSL stacks * check for duplicate certificate serials. * Returns 0 on success, -1 on error. */intssl_x509_serial_copyrand(X509 *dstcrt, X509 *srccrt){	ASN1_INTEGER *srcptr, *dstptr;	BIGNUM *bnserial;	unsigned int rand;	int rv;#ifndef PURIFY	rv = ssl_rand(&rand, sizeof(rand));#else /* PURIFY */	rand = 0xF001;	rv = 0;#endif /* PURIFY */	dstptr = X509_get_serialNumber(dstcrt);	srcptr = X509_get_serialNumber(srccrt);	if ((rv == -1) || !dstptr || !srcptr)		return -1;	bnserial = ASN1_INTEGER_to_BN(srcptr, NULL);	if (!bnserial) {		/* random 32-bit serial */		ASN1_INTEGER_set(dstptr, rand);	} else {		/* original serial plus random 32-bit offset */		BN_add_word(bnserial, rand);		BN_to_ASN1_INTEGER(bnserial, dstptr);		BN_free(bnserial);	}	return 0;}

static X509_REVOKED *create_revoked(const BIGNUM* bn, time_t t, int reason){  X509_REVOKED *revoked = X509_REVOKED_new();  ASN1_TIME *tm = ASN1_TIME_new();  ASN1_INTEGER *it =  BN_to_ASN1_INTEGER(bn, NULL);;  ASN1_TIME_set(tm, t);  X509_REVOKED_set_revocationDate(revoked, tm);  X509_REVOKED_set_serialNumber(revoked, it);  {    ASN1_ENUMERATED * e = ASN1_ENUMERATED_new();    X509_EXTENSION * ext = X509_EXTENSION_new();    ASN1_ENUMERATED_set(e, reason);    X509_EXTENSION_set_data(ext, e);    X509_EXTENSION_set_object(ext, OBJ_nid2obj(NID_crl_reason));    X509_REVOKED_add_ext(revoked, ext, 0);    X509_EXTENSION_free(ext);    ASN1_ENUMERATED_free(e);  }  ASN1_TIME_free(tm);  ASN1_INTEGER_free(it);  return revoked;}

static X509_REVOKED *create_revoked(lua_State*L, const BIGNUM* bn, time_t t, int reason){  X509_REVOKED *revoked = X509_REVOKED_new();  ASN1_TIME *tm = ASN1_TIME_new();  ASN1_INTEGER *it =  BN_to_ASN1_INTEGER((BIGNUM*)bn, NULL);;  ASN1_TIME_set(tm, t);  X509_REVOKED_set_revocationDate(revoked, tm);  X509_REVOKED_set_serialNumber(revoked, it);#if OPENSSL_VERSION_NUMBER > 0x10000000L  revoked->reason = reason;#else  {    ASN1_ENUMERATED * e = ASN1_ENUMERATED_new();    X509_EXTENSION * ext = X509_EXTENSION_new();    ASN1_ENUMERATED_set(e, reason);    X509_EXTENSION_set_data(ext, e);    X509_EXTENSION_set_object(ext, OBJ_nid2obj(NID_crl_reason));    X509_REVOKED_add_ext(revoked, ext, 0);    X509_EXTENSION_free(ext);    ASN1_ENUMERATED_free(e);  }#endif  ASN1_TIME_free(tm);  ASN1_INTEGER_free(it);  return revoked;}

a1int &a1int::operator ++ (void){	BIGNUM *bn = ASN1_INTEGER_to_BN(in, NULL);	BN_add(bn, bn, BN_value_one());	BN_to_ASN1_INTEGER(bn, in);	BN_free(bn);	return *this;}

a1int &a1int::setRaw(const unsigned char *data, unsigned len){	BIGNUM *bn = BN_bin2bn(data, len, NULL);	if (!bn)		openssl_error();	BN_to_ASN1_INTEGER(bn, in);	BN_free(bn);	return *this;}

a1int &a1int::setDec(const QString &s){	BIGNUM *bn=0;	if (!BN_dec2bn(&bn,s.toAscii()))		openssl_error();	BN_to_ASN1_INTEGER(bn, in);	BN_free(bn);	return *this;}

static int dsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey){    ASN1_STRING *params = NULL;    ASN1_INTEGER *prkey = NULL;    unsigned char *dp = NULL;    int dplen;    if (!pkey->pkey.dsa || !pkey->pkey.dsa->priv_key)    {        DSAerr(DSA_F_DSA_PRIV_ENCODE,DSA_R_MISSING_PARAMETERS);        goto err;    }    params = ASN1_STRING_new();    if (!params)    {        DSAerr(DSA_F_DSA_PRIV_ENCODE,ERR_R_MALLOC_FAILURE);        goto err;    }    params->length = i2d_DSAparams(pkey->pkey.dsa, &params->data);    if (params->length <= 0)    {        DSAerr(DSA_F_DSA_PRIV_ENCODE,ERR_R_MALLOC_FAILURE);        goto err;    }    params->type = V_ASN1_SEQUENCE;    /* Get private key into integer */    prkey = BN_to_ASN1_INTEGER(pkey->pkey.dsa->priv_key, NULL);    if (!prkey)    {        DSAerr(DSA_F_DSA_PRIV_ENCODE,DSA_R_BN_ERROR);        goto err;    }    dplen = i2d_ASN1_INTEGER(prkey, &dp);    ASN1_INTEGER_free(prkey);    if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_dsa), 0,                         V_ASN1_SEQUENCE, params, dp, dplen))        goto err;    return 1;err:    if (dp != NULL)        OPENSSL_free(dp);    if (params != NULL)        ASN1_STRING_free(params);    if (prkey != NULL)        ASN1_INTEGER_free(prkey);    return 0;}

// Generate a self-signed certificate, with the public key from the// given key pair. Caller is responsible for freeing the returned object.static X509* MakeCertificate(EVP_PKEY* pkey, const char* common_name) {  LOG(LS_INFO) << "Making certificate for " << common_name;  X509* x509 = NULL;  BIGNUM* serial_number = NULL;  X509_NAME* name = NULL;  if ((x509=X509_new()) == NULL)    goto error;  if (!X509_set_pubkey(x509, pkey))    goto error;  // serial number  // temporary reference to serial number inside x509 struct  ASN1_INTEGER* asn1_serial_number;  if (!(serial_number = BN_new()) ||      !BN_pseudo_rand(serial_number, SERIAL_RAND_BITS, 0, 0) ||      !(asn1_serial_number = X509_get_serialNumber(x509)) ||      !BN_to_ASN1_INTEGER(serial_number, asn1_serial_number))    goto error;  if (!X509_set_version(x509, 0L))  // version 1    goto error;  // There are a lot of possible components for the name entries. In  // our P2P SSL mode however, the certificates are pre-exchanged  // (through the secure XMPP channel), and so the certificate  // identification is arbitrary. It can't be empty, so we set some  // arbitrary common_name. Note that this certificate goes out in  // clear during SSL negotiation, so there may be a privacy issue in  // putting anything recognizable here.  if (!(name = X509_NAME_new()) ||      !X509_NAME_add_entry_by_NID(name, NID_commonName, MBSTRING_UTF8,                                     (unsigned char*)common_name, -1, -1, 0) ||      !X509_set_subject_name(x509, name) ||      !X509_set_issuer_name(x509, name))    goto error;  if (!X509_gmtime_adj(X509_get_notBefore(x509), 0) ||      !X509_gmtime_adj(X509_get_notAfter(x509), CERTIFICATE_LIFETIME))    goto error;  if (!X509_sign(x509, pkey, EVP_sha1()))    goto error;  BN_free(serial_number);  X509_NAME_free(name);  LOG(LS_INFO) << "Returning certificate";  return x509; error:  BN_free(serial_number);  X509_NAME_free(name);  X509_free(x509);  return NULL;}

ASN1_INTEGER *num_to_asn1integer(VALUE obj, ASN1_INTEGER *ai){    BIGNUM *bn = GetBNPtr(obj);    if (!(ai = BN_to_ASN1_INTEGER(bn, ai))) {	ossl_raise(eOSSLError, NULL);    }    return ai;}

static int dsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey){    DSA *dsa;    int ptype;    unsigned char *penc = NULL;    int penclen;    ASN1_STRING *str = NULL;    ASN1_INTEGER *pubint = NULL;    ASN1_OBJECT *aobj;    dsa = pkey->pkey.dsa;    if (pkey->save_parameters && dsa->p && dsa->q && dsa->g) {        str = ASN1_STRING_new();        if (str == NULL) {            DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);            goto err;        }        str->length = i2d_DSAparams(dsa, &str->data);        if (str->length <= 0) {            DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);            goto err;        }        ptype = V_ASN1_SEQUENCE;    } else        ptype = V_ASN1_UNDEF;    pubint = BN_to_ASN1_INTEGER(dsa->pub_key, NULL);    if (pubint == NULL) {        DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);        goto err;    }    penclen = i2d_ASN1_INTEGER(pubint, &penc);    ASN1_INTEGER_free(pubint);    if (penclen <= 0) {        DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);        goto err;    }    aobj = OBJ_nid2obj(EVP_PKEY_DSA);    if (aobj == NULL)        goto err;    if (X509_PUBKEY_set0_param(pk, aobj, ptype, str, penc, penclen))        return 1; err:    OPENSSL_free(penc);    ASN1_STRING_free(str);    return 0;}

ASN1_INTEGER* getRandomSN(){  ASN1_INTEGER* res = ASN1_INTEGER_new();  BIGNUM *btmp = BN_new();  //64 bits of randomness?  BN_pseudo_rand(btmp, 64, 0, 0);  BN_to_ASN1_INTEGER(btmp, res);  BN_free(btmp);  return res;}

static int dh_pub_encode (X509_PUBKEY * pk, const EVP_PKEY * pkey){    DH *dh;    void *pval = NULL;    int ptype;    unsigned char *penc = NULL;    int penclen;    ASN1_STRING *str;    ASN1_INTEGER *pub_key = NULL;    dh = pkey->pkey.dh;    str = ASN1_STRING_new ();    str->length = i2d_DHparams (dh, &str->data);    if (str->length <= 0)    {        DHerr (DH_F_DH_PUB_ENCODE, ERR_R_MALLOC_FAILURE);        goto err;    }    pval = str;    ptype = V_ASN1_SEQUENCE;    pub_key = BN_to_ASN1_INTEGER (dh->pub_key, NULL);    if (!pub_key)        goto err;    penclen = i2d_ASN1_INTEGER (pub_key, &penc);    ASN1_INTEGER_free (pub_key);    if (penclen <= 0)    {        DHerr (DH_F_DH_PUB_ENCODE, ERR_R_MALLOC_FAILURE);        goto err;    }    if (X509_PUBKEY_set0_param (pk, OBJ_nid2obj (EVP_PKEY_DH), ptype, pval, penc, penclen))        return 1;  err:    if (penc)        OPENSSL_free (penc);    if (pval)        ASN1_STRING_free (pval);    return 0;}

static int dsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey) {  ASN1_STRING *params = NULL;  ASN1_INTEGER *prkey = NULL;  uint8_t *dp = NULL;  int dplen;  if (!pkey->pkey.dsa || !pkey->pkey.dsa->priv_key) {    OPENSSL_PUT_ERROR(EVP, EVP_R_MISSING_PARAMETERS);    goto err;  }  params = ASN1_STRING_new();  if (!params) {    OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE);    goto err;  }  params->length = i2d_DSAparams(pkey->pkey.dsa, &params->data);  if (params->length <= 0) {    OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE);    goto err;  }  params->type = V_ASN1_SEQUENCE;  /* Get private key into integer. */  prkey = BN_to_ASN1_INTEGER(pkey->pkey.dsa->priv_key, NULL);  if (!prkey) {    OPENSSL_PUT_ERROR(EVP, ERR_LIB_BN);    goto err;  }  dplen = i2d_ASN1_INTEGER(prkey, &dp);  ASN1_INTEGER_free(prkey);  prkey = NULL;  if (!PKCS8_pkey_set0(p8, (ASN1_OBJECT *)OBJ_nid2obj(NID_dsa), 0,                       V_ASN1_SEQUENCE, params, dp, dplen)) {    goto err;  }  return 1;err:  OPENSSL_free(dp);  ASN1_STRING_free(params);  ASN1_INTEGER_free(prkey);  return 0;}

static int dh_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey){    ASN1_STRING *params = NULL;    ASN1_INTEGER *prkey = NULL;    unsigned char *dp = NULL;    int dplen;    params = ASN1_STRING_new();    if (!params) {        DHerr(DH_F_DH_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);        goto err;    }    params->length = i2d_dhp(pkey, pkey->pkey.dh, &params->data);    if (params->length <= 0) {        DHerr(DH_F_DH_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);        goto err;    }    params->type = V_ASN1_SEQUENCE;    /* Get private key into integer */    prkey = BN_to_ASN1_INTEGER(pkey->pkey.dh->priv_key, NULL);    if (!prkey) {        DHerr(DH_F_DH_PRIV_ENCODE, DH_R_BN_ERROR);        goto err;    }    dplen = i2d_ASN1_INTEGER(prkey, &dp);    ASN1_STRING_clear_free(prkey);    prkey = NULL;    if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(pkey->ameth->pkey_id), 0,                         V_ASN1_SEQUENCE, params, dp, dplen))        goto err;    return 1; err:    if (dp != NULL)        OPENSSL_free(dp);    if (params != NULL)        ASN1_STRING_free(params);    if (prkey != NULL)        ASN1_STRING_clear_free(prkey);    return 0;}

static X509 *gen_cert(EVP_PKEY* pkey, const char *common, int days) {  X509 *x509 = NULL;  BIGNUM *serial_number = NULL;  X509_NAME *name = NULL;  if ((x509 = X509_new()) == NULL)    return NULL;  if (!X509_set_pubkey(x509, pkey))    return NULL;  ASN1_INTEGER* asn1_serial_number;  if ((serial_number = BN_new()) == NULL ||      !BN_pseudo_rand(serial_number, 64, 0, 0) ||      (asn1_serial_number = X509_get_serialNumber(x509)) == NULL ||      !BN_to_ASN1_INTEGER(serial_number, asn1_serial_number))    goto cert_err;  if (!X509_set_version(x509, 0L)) // version 1    goto cert_err;  if ((name = X509_NAME_new()) == NULL ||      !X509_NAME_add_entry_by_NID(          name, NID_commonName, MBSTRING_UTF8,          (unsigned char*)common, -1, -1, 0) ||      !X509_set_subject_name(x509, name) ||      !X509_set_issuer_name(x509, name))    goto cert_err;  if (!X509_gmtime_adj(X509_get_notBefore(x509), 0) ||      !X509_gmtime_adj(X509_get_notAfter(x509), days * 24 * 3600))    goto cert_err;  if (!X509_sign(x509, pkey, EVP_sha1()))    goto cert_err;  if (0) {cert_err:      X509_free(x509);    x509 = NULL;  }  BN_free(serial_number);  X509_NAME_free(name);  return x509;}

static gbooleanSetCertSerialNumber(X509 *cert)                  // IN{   BIGNUM *btmp = NULL;   ASN1_INTEGER *sno;   gboolean ret = FALSE;   gchar *err = NULL;   sno = ASN1_INTEGER_new();   if (!sno) {      Error("Failed to allocate an ASN1 integer./n");      goto exit;   }   btmp = BN_new();   if (!btmp) {      Error("Failed to allocate a BIGNUM structure./n");      goto exit;   }   if (!BN_rand(btmp, 64, 0, 0)) {      Error("Failed to generate random number: %s./n",            GetSSLError(&err));      goto exit;   }   if (!BN_to_ASN1_INTEGER(btmp, sno)) {      Error("Failed to convert from BIGNUM to ASN1_INTEGER: %s./n",            GetSSLError(&err));      goto exit;   }   if (!X509_set_serialNumber(cert, sno)) {      Error("Failed to set the certificate serial number: %s./n",            GetSSLError(&err));      goto exit;   }   ret = TRUE;exit:   BN_free(btmp);   ASN1_INTEGER_free(sno);   g_free(err);   return ret;}

/* ----------------------------------------------------------------------*/static int priv_encode_gost(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk){    ASN1_OBJECT *algobj = OBJ_nid2obj(EVP_PKEY_base_id(pk));    ASN1_STRING *params = encode_gost_algor_params(pk);    unsigned char *priv_buf = NULL;    int priv_len;    ASN1_INTEGER *asn1key = NULL;    if (!params) {        return 0;    }    asn1key = BN_to_ASN1_INTEGER(gost_get0_priv_key(pk), NULL);    priv_len = i2d_ASN1_INTEGER(asn1key, &priv_buf);    ASN1_INTEGER_free(asn1key);    return PKCS8_pkey_set0(p8, algobj, 0, V_ASN1_SEQUENCE, params,                           priv_buf, priv_len);}

static int bign_asn1_params2fieldid(BIGN_FIELDID* field, 	const bign_params* params){	int ok = 0;	BIGNUM* p = NULL;	octet rev[64];	// 
C++ BN_usub函数代码示例
C++ BN_sub_word函数代码示例