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

BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms){    return BIO_new_NDEF(out, (ASN1_VALUE *)cms,                        ASN1_ITEM_rptr(CMS_ContentInfo));}

X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)	{	return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);	}

X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)	{	return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);	}

int PKCS5_v2_PBKDF2_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,                             int passlen, ASN1_TYPE *param,                             const EVP_CIPHER *c, const EVP_MD *md, int en_de){    unsigned char *salt, key[EVP_MAX_KEY_LENGTH];    int saltlen, iter;    int rv = 0;    unsigned int keylen = 0;    int prf_nid, hmac_md_nid;    PBKDF2PARAM *kdf = NULL;    const EVP_MD *prfmd;    if (EVP_CIPHER_CTX_cipher(ctx) == NULL) {        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_NO_CIPHER_SET);        goto err;    }    keylen = EVP_CIPHER_CTX_key_length(ctx);    OPENSSL_assert(keylen <= sizeof(key));    /* Decode parameter */    kdf = ASN1_TYPE_unpack_sequence(ASN1_ITEM_rptr(PBKDF2PARAM), param);    if (kdf == NULL) {        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_DECODE_ERROR);        goto err;    }    keylen = EVP_CIPHER_CTX_key_length(ctx);    /* Now check the parameters of the kdf */    if (kdf->keylength && (ASN1_INTEGER_get(kdf->keylength) != (int)keylen)) {        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_KEYLENGTH);        goto err;    }    if (kdf->prf)        prf_nid = OBJ_obj2nid(kdf->prf->algorithm);    else        prf_nid = NID_hmacWithSHA1;    if (!EVP_PBE_find(EVP_PBE_TYPE_PRF, prf_nid, NULL, &hmac_md_nid, 0)) {        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);        goto err;    }    prfmd = EVP_get_digestbynid(hmac_md_nid);    if (prfmd == NULL) {        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_PRF);        goto err;    }    if (kdf->salt->type != V_ASN1_OCTET_STRING) {        EVPerr(EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN, EVP_R_UNSUPPORTED_SALT_TYPE);        goto err;    }    /* it seems that its all OK */    salt = kdf->salt->value.octet_string->data;    saltlen = kdf->salt->value.octet_string->length;    iter = ASN1_INTEGER_get(kdf->iter);    if (!PKCS5_PBKDF2_HMAC(pass, passlen, salt, saltlen, iter, prfmd,                           keylen, key))        goto err;    rv = EVP_CipherInit_ex(ctx, NULL, NULL, key, NULL, en_de); err:    OPENSSL_cleanse(key, keylen);    PBKDF2PARAM_free(kdf);    return rv;}

//.........这里部分代码省略.........						{						PKCS7err(PKCS7_F_PKCS7_DATAFINAL,							ERR_R_MALLOC_FAILURE);						goto err;						}					PKCS7_add_signed_attribute(si,						NID_pkcs9_signingTime,						V_ASN1_UTCTIME,sign_time);					}				/* Add digest */				md_tmp=EVP_MD_CTX_md(&ctx_tmp);				EVP_DigestFinal_ex(&ctx_tmp,md_data,&md_len);				if (!(digest=M_ASN1_OCTET_STRING_new()))					{					PKCS7err(PKCS7_F_PKCS7_DATAFINAL,						ERR_R_MALLOC_FAILURE);					goto err;					}				if (!M_ASN1_OCTET_STRING_set(digest,md_data,								md_len))					{					PKCS7err(PKCS7_F_PKCS7_DATAFINAL,						ERR_R_MALLOC_FAILURE);					goto err;					}				PKCS7_add_signed_attribute(si,					NID_pkcs9_messageDigest,					V_ASN1_OCTET_STRING,digest);				/* Now sign the attributes */				EVP_SignInit_ex(&ctx_tmp,md_tmp,NULL);				alen = ASN1_item_i2d((ASN1_VALUE *)sk,&abuf,							ASN1_ITEM_rptr(PKCS7_ATTR_SIGN));				if(!abuf) goto err;				EVP_SignUpdate(&ctx_tmp,abuf,alen);				OPENSSL_free(abuf);				}#ifndef OPENSSL_NO_DSA			if (si->pkey->type == EVP_PKEY_DSA)				ctx_tmp.digest=EVP_dss1();#endif#ifndef OPENSSL_NO_ECDSA 			if (si->pkey->type == EVP_PKEY_EC) 				ctx_tmp.digest=EVP_ecdsa();#endif			if (!EVP_SignFinal(&ctx_tmp,(unsigned char *)buf->data,				(unsigned int *)&buf->length,si->pkey))				{				PKCS7err(PKCS7_F_PKCS7_DATAFINAL,ERR_R_EVP_LIB);				goto err;				}			if (!ASN1_STRING_set(si->enc_digest,				(unsigned char *)buf->data,buf->length))				{				PKCS7err(PKCS7_F_PKCS7_DATAFINAL,ERR_R_ASN1_LIB);				goto err;				}			}		}	else if (i == NID_pkcs7_digest)		{		unsigned char md_data[EVP_MAX_MD_SIZE];		unsigned int md_len;

RSA *RSAPrivateKey_dup(RSA *rsa){    return ASN1_item_dup(ASN1_ITEM_rptr(RSAPrivateKey), rsa);}

CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms,                                               int iter, int wrap_nid,                                               int pbe_nid,                                               unsigned char *pass,                                               ossl_ssize_t passlen,                                               const EVP_CIPHER *kekciph){    CMS_RecipientInfo *ri = NULL;    CMS_EnvelopedData *env;    CMS_PasswordRecipientInfo *pwri;    EVP_CIPHER_CTX ctx;    X509_ALGOR *encalg = NULL;    unsigned char iv[EVP_MAX_IV_LENGTH];    int ivlen;    env = cms_get0_enveloped(cms);    if (!env)        return NULL;    if (wrap_nid <= 0)        wrap_nid = NID_id_alg_PWRI_KEK;    if (pbe_nid <= 0)        pbe_nid = NID_id_pbkdf2;    /* Get from enveloped data */    if (kekciph == NULL)        kekciph = env->encryptedContentInfo->cipher;    if (kekciph == NULL) {        CMSerr(CMS_F_CMS_ADD0_RECIPIENT_PASSWORD, CMS_R_NO_CIPHER);        return NULL;    }    if (wrap_nid != NID_id_alg_PWRI_KEK) {        CMSerr(CMS_F_CMS_ADD0_RECIPIENT_PASSWORD,               CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM);        return NULL;    }    /* Setup algorithm identifier for cipher */    encalg = X509_ALGOR_new();    if (encalg == NULL) {        goto merr;    }    EVP_CIPHER_CTX_init(&ctx);    if (EVP_EncryptInit_ex(&ctx, kekciph, NULL, NULL, NULL) <= 0) {        CMSerr(CMS_F_CMS_ADD0_RECIPIENT_PASSWORD, ERR_R_EVP_LIB);        goto err;    }    ivlen = EVP_CIPHER_CTX_iv_length(&ctx);    if (ivlen > 0) {        if (RAND_bytes(iv, ivlen) <= 0)            goto err;        if (EVP_EncryptInit_ex(&ctx, NULL, NULL, NULL, iv) <= 0) {            CMSerr(CMS_F_CMS_ADD0_RECIPIENT_PASSWORD, ERR_R_EVP_LIB);            goto err;        }        encalg->parameter = ASN1_TYPE_new();        if (!encalg->parameter) {            CMSerr(CMS_F_CMS_ADD0_RECIPIENT_PASSWORD, ERR_R_MALLOC_FAILURE);            goto err;        }        if (EVP_CIPHER_param_to_asn1(&ctx, encalg->parameter) <= 0) {            CMSerr(CMS_F_CMS_ADD0_RECIPIENT_PASSWORD,                   CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);            goto err;        }    }    encalg->algorithm = OBJ_nid2obj(EVP_CIPHER_CTX_type(&ctx));    EVP_CIPHER_CTX_cleanup(&ctx);    /* Initialize recipient info */    ri = M_ASN1_new_of(CMS_RecipientInfo);    if (!ri)        goto merr;    ri->d.pwri = M_ASN1_new_of(CMS_PasswordRecipientInfo);    if (!ri->d.pwri)        goto merr;    ri->type = CMS_RECIPINFO_PASS;    pwri = ri->d.pwri;    /* Since this is overwritten, free up empty structure already there */    X509_ALGOR_free(pwri->keyEncryptionAlgorithm);    pwri->keyEncryptionAlgorithm = X509_ALGOR_new();    if (!pwri->keyEncryptionAlgorithm)        goto merr;    pwri->keyEncryptionAlgorithm->algorithm = OBJ_nid2obj(wrap_nid);    pwri->keyEncryptionAlgorithm->parameter = ASN1_TYPE_new();    if (!pwri->keyEncryptionAlgorithm->parameter)        goto merr;    if (!ASN1_item_pack(encalg, ASN1_ITEM_rptr(X509_ALGOR),                        &pwri->keyEncryptionAlgorithm->parameter->                        value.sequence))//.........这里部分代码省略.........

//.........这里部分代码省略.........				    extconf, extsect, sno))					goto end;			} else if (x509req == i) {				EVP_PKEY *pk;				BIO_printf(bio_err, "Getting request Private Key/n");				if (keyfile == NULL) {					BIO_printf(bio_err, "no request key file specified/n");					goto end;				} else {					pk = load_key(bio_err,					    keyfile, keyformat, 0,					    passin, e, "request key");					if (pk == NULL)						goto end;				}				BIO_printf(bio_err, "Generating certificate request/n");				rq = X509_to_X509_REQ(x, pk, digest);				EVP_PKEY_free(pk);				if (rq == NULL) {					ERR_print_errors(bio_err);					goto end;				}				if (!noout) {					X509_REQ_print(out, rq);					PEM_write_bio_X509_REQ(out, rq);				}				noout = 1;			} else if (ocspid == i) {				X509_ocspid_print(out, x);			}		}	}	if (checkend) {		time_t tcheck = time(NULL) + checkoffset;		if (X509_cmp_time(X509_get_notAfter(x), &tcheck) < 0) {			BIO_printf(out, "Certificate will expire/n");			ret = 1;		} else {			BIO_printf(out, "Certificate will not expire/n");			ret = 0;		}		goto end;	}	if (noout) {		ret = 0;		goto end;	}	if (outformat == FORMAT_ASN1)		i = i2d_X509_bio(out, x);	else if (outformat == FORMAT_PEM) {		if (trustout)			i = PEM_write_bio_X509_AUX(out, x);		else			i = PEM_write_bio_X509(out, x);	} else if (outformat == FORMAT_NETSCAPE) {		NETSCAPE_X509 nx;		ASN1_OCTET_STRING hdr;		hdr.data = (unsigned char *) NETSCAPE_CERT_HDR;		hdr.length = strlen(NETSCAPE_CERT_HDR);		nx.header = &hdr;		nx.cert = x;		i = ASN1_item_i2d_bio(ASN1_ITEM_rptr(NETSCAPE_X509), out, &nx);	} else {		BIO_printf(bio_err, "bad output format specified for outfile/n");		goto end;	}	if (!i) {		BIO_printf(bio_err, "unable to write certificate/n");		ERR_print_errors(bio_err);		goto end;	}	ret = 0;end:	OBJ_cleanup();	NCONF_free(extconf);	BIO_free_all(out);	BIO_free_all(STDout);	X509_STORE_free(ctx);	X509_REQ_free(req);	X509_free(x);	X509_free(xca);	EVP_PKEY_free(Upkey);	EVP_PKEY_free(CApkey);	if (sigopts)		sk_OPENSSL_STRING_free(sigopts);	X509_REQ_free(rq);	ASN1_INTEGER_free(sno);	sk_ASN1_OBJECT_pop_free(trust, ASN1_OBJECT_free);	sk_ASN1_OBJECT_pop_free(reject, ASN1_OBJECT_free);	free(passin);	return (ret);}

int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags){    return i2d_ASN1_bio_stream(out, (ASN1_VALUE *)cms, in, flags,                               ASN1_ITEM_rptr(CMS_ContentInfo));}

int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si,								X509 *x509)	{	ASN1_OCTET_STRING *os;	EVP_MD_CTX mdc_tmp,*mdc;	int ret=0,i;	int md_type;	STACK_OF(X509_ATTRIBUTE) *sk;	BIO *btmp;	EVP_PKEY *pkey;	EVP_MD_CTX_init(&mdc_tmp);	if (!PKCS7_type_is_signed(p7) && 				!PKCS7_type_is_signedAndEnveloped(p7)) {		PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY,						PKCS7_R_WRONG_PKCS7_TYPE);		goto err;	}	md_type=OBJ_obj2nid(si->digest_alg->algorithm);	btmp=bio;	for (;;)		{		if ((btmp == NULL) ||			((btmp=BIO_find_type(btmp,BIO_TYPE_MD)) == NULL))			{			PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY,					PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST);			goto err;			}		BIO_get_md_ctx(btmp,&mdc);		if (mdc == NULL)			{			PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY,							ERR_R_INTERNAL_ERROR);			goto err;			}		if (EVP_MD_CTX_type(mdc) == md_type)			break;		/* Workaround for some broken clients that put the signature		 * OID instead of the digest OID in digest_alg->algorithm		 */		if (EVP_MD_pkey_type(EVP_MD_CTX_md(mdc)) == md_type)			break;		btmp=BIO_next(btmp);		}	/* mdc is the digest ctx that we want, unless there are attributes,	 * in which case the digest is the signed attributes */	EVP_MD_CTX_copy_ex(&mdc_tmp,mdc);	sk=si->auth_attr;	if ((sk != NULL) && (sk_X509_ATTRIBUTE_num(sk) != 0))		{		unsigned char md_dat[EVP_MAX_MD_SIZE], *abuf = NULL;                unsigned int md_len, alen;		ASN1_OCTET_STRING *message_digest;		EVP_DigestFinal_ex(&mdc_tmp,md_dat,&md_len);		message_digest=PKCS7_digest_from_attributes(sk);		if (!message_digest)			{			PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY,					PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST);			goto err;			}		if ((message_digest->length != (int)md_len) ||			(memcmp(message_digest->data,md_dat,md_len)))			{#if 0{int ii;for (ii=0; ii<message_digest->length; ii++)	printf("%02X",message_digest->data[ii]); printf(" sent/n");for (ii=0; ii<md_len; ii++) printf("%02X",md_dat[ii]); printf(" calc/n");}#endif			PKCS7err(PKCS7_F_PKCS7_SIGNATUREVERIFY,							PKCS7_R_DIGEST_FAILURE);			ret= -1;			goto err;			}		EVP_VerifyInit_ex(&mdc_tmp,EVP_get_digestbynid(md_type), NULL);		alen = ASN1_item_i2d((ASN1_VALUE *)sk, &abuf,						ASN1_ITEM_rptr(PKCS7_ATTR_VERIFY));		EVP_VerifyUpdate(&mdc_tmp, abuf, alen);		OPENSSL_free(abuf);		}	os=si->enc_digest;	pkey = X509_get_pubkey(x509);	if (!pkey)		{		ret = -1;		goto err;//.........这里部分代码省略.........

int i2d_X509_bio(BIO *bp, X509 *x509)	{	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509), bp, x509);	}

PKCS8_PRIV_KEY_INFO *PKCS8_decrypt(X509_SIG *p8, const char *pass, int passlen){	return PKCS12_item_decrypt_d2i(p8->algor, ASN1_ITEM_rptr(PKCS8_PRIV_KEY_INFO), pass,					passlen, p8->digest, 1);}

int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)	{	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);	}

static int def_crl_verify(X509_CRL *crl, EVP_PKEY *r)	{	return(ASN1_item_verify(ASN1_ITEM_rptr(X509_CRL_INFO),		crl->sig_alg, crl->signature,crl->crl,r));	}

int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)	{	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);	}

int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)	{	x->crl->enc.modified = 1;	return(ASN1_item_sign(ASN1_ITEM_rptr(X509_CRL_INFO),x->crl->sig_alg,		x->sig_alg, x->signature, x->crl,pkey,md));	}

int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7)	{	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(PKCS7), fp, p7);	}

int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)	{	return(ASN1_item_sign(ASN1_ITEM_rptr(NETSCAPE_SPKAC), x->sig_algor,NULL,		x->signature, x->spkac,pkey,md));	}

int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7)	{	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(PKCS7), bp, p7);	}

int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)	{	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);	}

int i2d_X509_fp(FILE *fp, X509 *x509)	{	return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509), fp, x509);	}

int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)	{	return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);	}

int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms){    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(CMS_ContentInfo), bp, cms);}