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

static int do_generate(BIO *bio, char *genstr, char *genconf, BUF_MEM *buf)	{	CONF *cnf = NULL;	int len;	long errline;	unsigned char *p;	ASN1_TYPE *atyp = NULL;	if (genconf)		{		cnf = NCONF_new(NULL);		if (!NCONF_load(cnf, genconf, &errline))			goto conferr;		if (!genstr)			genstr = NCONF_get_string(cnf, "default", "asn1");		if (!genstr)			{			BIO_printf(bio, "Can't find 'asn1' in '%s'/n", genconf);			goto err;			}		}	atyp = ASN1_generate_nconf(genstr, cnf);	NCONF_free(cnf);	if (!atyp)		return -1;	len = i2d_ASN1_TYPE(atyp, NULL);	if (len <= 0)		goto err;	if (!BUF_MEM_grow(buf,len))		goto err;	p=(unsigned char *)buf->data;	i2d_ASN1_TYPE(atyp, &p);	ASN1_TYPE_free(atyp);	return len;	conferr:	if (errline > 0)		BIO_printf(bio, "Error on line %ld of config file '%s'/n",							errline, genconf);	else		BIO_printf(bio, "Error loading config file '%s'/n", genconf);	err:	NCONF_free(cnf);	ASN1_TYPE_free(atyp);	return -1;	}

void X509_ALGOR_free(X509_ALGOR *a)	{	if (a == NULL) return;	ASN1_OBJECT_free(a->algorithm);	ASN1_TYPE_free(a->parameter);	OPENSSL_free(a);	}

static int openssl_xattr_data(lua_State*L){  X509_ATTRIBUTE* attr = CHECK_OBJECT(1, X509_ATTRIBUTE, "openssl.x509_attribute");  if (lua_type(L, 2) == LUA_TSTRING)  {    int attrtype = luaL_checkint(L, 2);    size_t size;    int ret;    const char *data = luaL_checklstring(L, 3, &size);    if (attr->single)      ASN1_TYPE_free((ASN1_TYPE*)attr->value.ptr);    else      sk_ASN1_TYPE_pop_free(attr->value.set, ASN1_TYPE_free);    attr->value.ptr = NULL;    ret = X509_ATTRIBUTE_set1_data(attr, attrtype, data, size);    return openssl_pushresult(L, ret);  }  else  {    int idx = luaL_checkint(L, 2);    int attrtype = luaL_checkint(L, 3);    ASN1_STRING *as = (ASN1_STRING *)X509_ATTRIBUTE_get0_data(attr, idx, attrtype, NULL);    as = ASN1_STRING_dup(as);    PUSH_OBJECT(as, "openssl.asn1_string");    return 1;  }}

int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval)	{	if (!alg)		return 0;	if (ptype != V_ASN1_UNDEF)		{		if (alg->parameter == NULL)			alg->parameter = ASN1_TYPE_new();		if (alg->parameter == NULL)			return 0;		}	if (alg)		{		if (alg->algorithm)			ASN1_OBJECT_free(alg->algorithm);		alg->algorithm = aobj;		}	if (ptype == 0)		return 1;		if (ptype == V_ASN1_UNDEF)		{		if (alg->parameter)			{			ASN1_TYPE_free(alg->parameter);			alg->parameter = NULL;			}		}	else		ASN1_TYPE_set(alg->parameter, ptype, pval);	return 1;	}

void PKCS12_SAFEBAG_free (PKCS12_SAFEBAG *a){	if (a == NULL) return;	switch (OBJ_obj2nid(a->type)) {		case NID_keyBag:			PKCS8_PRIV_KEY_INFO_free (a->value.keybag);		break;		case NID_pkcs8ShroudedKeyBag:			X509_SIG_free (a->value.shkeybag);		break;		case NID_certBag:		case NID_crlBag:		case NID_secretBag:			PKCS12_BAGS_free (a->value.bag);		break;		default:			ASN1_TYPE_free (a->value.other);		break;	}	ASN1_OBJECT_free (a->type);	sk_X509_ATTRIBUTE_pop_free (a->attrib, X509_ATTRIBUTE_free);	OPENSSL_free (a);}

X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value){	X509_ATTRIBUTE *ret = NULL;	ASN1_TYPE *val = NULL;	if ((ret = X509_ATTRIBUTE_new()) == NULL)		return (NULL);	ret->object = OBJ_nid2obj(nid);	ret->single = 0;	if ((ret->value.set = sk_ASN1_TYPE_new_null()) == NULL)		goto err;	if ((val = ASN1_TYPE_new()) == NULL)		goto err;	if (!sk_ASN1_TYPE_push(ret->value.set, val))		goto err;	ASN1_TYPE_set(val, atrtype, value);	return (ret);err:	if (ret != NULL)		X509_ATTRIBUTE_free(ret);	if (val != NULL)		ASN1_TYPE_free(val);	return (NULL);}

void GENERAL_NAME_free(GENERAL_NAME *a){	if (a == NULL) return;	switch(a->type) {		case GEN_X400:		case GEN_EDIPARTY:		ASN1_TYPE_free(a->d.other);		break;		case GEN_OTHERNAME:		OTHERNAME_free(a->d.otherName);		break;		case GEN_EMAIL:		case GEN_DNS:		case GEN_URI:		M_ASN1_IA5STRING_free(a->d.ia5);		break;		case GEN_DIRNAME:		X509_NAME_free(a->d.dirn);		break;		case GEN_IPADD:		M_ASN1_OCTET_STRING_free(a->d.ip);		break;			case GEN_RID:		ASN1_OBJECT_free(a->d.rid);		break;	}	OPENSSL_free (a);}

static int openssl_xattr_data(lua_State*L){  X509_ATTRIBUTE* attr = CHECK_OBJECT(1, X509_ATTRIBUTE, "openssl.x509_attribute");  if (lua_type(L, 2) == LUA_TSTRING)  {    int attrtype = luaL_checkint(L, 2);    size_t size;    int ret;    const char *data = luaL_checklstring(L, 3, &size);#if OPENSSL_VERSION_NUMBER < 0x10100000L    if (X509_ATTRIBUTE_count(attr) == 1)      ASN1_TYPE_free((ASN1_TYPE*)attr->value.ptr);    else      sk_ASN1_TYPE_pop_free(attr->value.set, ASN1_TYPE_free);    attr->value.ptr = NULL;#else#endif    ret = X509_ATTRIBUTE_set1_data(attr, attrtype, data, size);    return openssl_pushresult(L, ret);  }  else  {    int idx = luaL_checkint(L, 2);    int attrtype = luaL_checkint(L, 3);    ASN1_STRING *as = (ASN1_STRING *)X509_ATTRIBUTE_get0_data(attr, idx, attrtype, NULL);    PUSH_ASN1_STRING(L, as);    return 1;  }}

int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,	     EVP_MD *dgst)	{	char is_dsa;	if (pkey->type == EVP_PKEY_DSA) is_dsa = 1;	else is_dsa = 0;	/* We now need to add another PKCS7_SIGNER_INFO entry */	ASN1_INTEGER_set(p7i->version,1);	X509_NAME_set(&p7i->issuer_and_serial->issuer,		X509_get_issuer_name(x509));	/* because ASN1_INTEGER_set is used to set a 'long' we will do	 * things the ugly way. */	M_ASN1_INTEGER_free(p7i->issuer_and_serial->serial);	p7i->issuer_and_serial->serial=		M_ASN1_INTEGER_dup(X509_get_serialNumber(x509));	/* lets keep the pkey around for a while */	CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY);	p7i->pkey=pkey;	/* Set the algorithms */	if (is_dsa) p7i->digest_alg->algorithm=OBJ_nid2obj(NID_sha1);	else			p7i->digest_alg->algorithm=OBJ_nid2obj(EVP_MD_type(dgst));	if (p7i->digest_alg->parameter != NULL)		ASN1_TYPE_free(p7i->digest_alg->parameter);	if ((p7i->digest_alg->parameter=ASN1_TYPE_new()) == NULL)		goto err;	p7i->digest_alg->parameter->type=V_ASN1_NULL;	p7i->digest_enc_alg->algorithm=OBJ_nid2obj(EVP_PKEY_type(pkey->type));	if (p7i->digest_enc_alg->parameter != NULL)		ASN1_TYPE_free(p7i->digest_enc_alg->parameter);	if(is_dsa) p7i->digest_enc_alg->parameter = NULL;	else {		if (!(p7i->digest_enc_alg->parameter=ASN1_TYPE_new()))			goto err;		p7i->digest_enc_alg->parameter->type=V_ASN1_NULL;	}	return(1);err:	return(0);	}

static int do_generate(char *genstr, const char *genconf, BUF_MEM *buf){    CONF *cnf = NULL;    int len;    unsigned char *p;    ASN1_TYPE *atyp = NULL;    if (genconf) {        if ((cnf = app_load_config(genconf)) == NULL)            goto err;        if (!genstr)            genstr = NCONF_get_string(cnf, "default", "asn1");        if (!genstr) {            BIO_printf(bio_err, "Can't find 'asn1' in '%s'/n", genconf);            goto err;        }    }    atyp = ASN1_generate_nconf(genstr, cnf);    NCONF_free(cnf);    cnf = NULL;    if (!atyp)        return -1;    len = i2d_ASN1_TYPE(atyp, NULL);    if (len <= 0)        goto err;    if (!BUF_MEM_grow(buf, len))        goto err;    p = (unsigned char *)buf->data;    i2d_ASN1_TYPE(atyp, &p);    ASN1_TYPE_free(atyp);    return len; err:    NCONF_free(cnf);    ASN1_TYPE_free(atyp);    return -1;}

void PBKDF2PARAM_free (PBKDF2PARAM *a){	if(a==NULL) return;	ASN1_TYPE_free(a->salt);	M_ASN1_INTEGER_free(a->iter);	M_ASN1_INTEGER_free(a->keylength);	X509_ALGOR_free(a->prf);	OPENSSL_free (a);}

X509_ALGOR *PKCS5_pbe_set(int alg, int iter, unsigned char *salt,	     int saltlen){	PBEPARAM *pbe=NULL;	ASN1_OBJECT *al;	X509_ALGOR *algor;	ASN1_TYPE *astype=NULL;	if (!(pbe = PBEPARAM_new ())) {		ASN1err(ASN1_F_PKCS5_PBE_SET,ERR_R_MALLOC_FAILURE);		goto err;	}	if(iter <= 0) iter = PKCS5_DEFAULT_ITER;	if (!ASN1_INTEGER_set(pbe->iter, iter)) {		ASN1err(ASN1_F_PKCS5_PBE_SET,ERR_R_MALLOC_FAILURE);		goto err;	}	if (!saltlen) saltlen = PKCS5_SALT_LEN;	if (!(pbe->salt->data = OPENSSL_malloc (saltlen))) {		ASN1err(ASN1_F_PKCS5_PBE_SET,ERR_R_MALLOC_FAILURE);		goto err;	}	pbe->salt->length = saltlen;	if (salt) memcpy (pbe->salt->data, salt, saltlen);	else if (RAND_pseudo_bytes (pbe->salt->data, saltlen) < 0)		goto err;	if (!(astype = ASN1_TYPE_new())) {		ASN1err(ASN1_F_PKCS5_PBE_SET,ERR_R_MALLOC_FAILURE);		goto err;	}	astype->type = V_ASN1_SEQUENCE;	if(!ASN1_pack_string_of(PBEPARAM, pbe, i2d_PBEPARAM,				&astype->value.sequence)) {		ASN1err(ASN1_F_PKCS5_PBE_SET,ERR_R_MALLOC_FAILURE);		goto err;	}	PBEPARAM_free (pbe);	pbe = NULL;		al = OBJ_nid2obj(alg); /* never need to free al */	if (!(algor = X509_ALGOR_new())) {		ASN1err(ASN1_F_PKCS5_PBE_SET,ERR_R_MALLOC_FAILURE);		goto err;	}	ASN1_OBJECT_free(algor->algorithm);	algor->algorithm = al;	algor->parameter = astype;	return (algor);err:	if (pbe != NULL) PBEPARAM_free(pbe);	if (astype != NULL) ASN1_TYPE_free(astype);	return NULL;}

void X509_ATTRIBUTE_free(X509_ATTRIBUTE *a){    if (a == NULL) return;    ASN1_OBJECT_free(a->object);    if (a->set)        sk_ASN1_TYPE_pop_free(a->value.set,ASN1_TYPE_free);    else        ASN1_TYPE_free(a->value.single);    OPENSSL_free(a);}

static unsigned char *generic_asn1(char *value, X509V3_CTX *ctx, long *ext_len)	{	ASN1_TYPE *typ;	unsigned char *ext_der = NULL;	typ = ASN1_generate_v3(value, ctx);	if (typ == NULL)		return NULL;	*ext_len = i2d_ASN1_TYPE(typ, &ext_der);	ASN1_TYPE_free(typ);	return ext_der;	}

static voidossl_ASN1_TYPE_free(ASN1_TYPE *a){#if OPENSSL_VERSION_NUMBER < 0x00907000L    if(!a) return;    if(a->type == V_ASN1_BOOLEAN){        OPENSSL_free(a);        return;    }#endif    ASN1_TYPE_free(a);}

int GENERAL_NAME_set0_othername(GENERAL_NAME *gen,                                ASN1_OBJECT *oid, ASN1_TYPE *value){    OTHERNAME *oth;    oth = OTHERNAME_new();    if (oth == NULL)        return 0;    ASN1_TYPE_free(oth->value);    oth->type_id = oid;    oth->value = value;    GENERAL_NAME_set0_value(gen, GEN_OTHERNAME, oth);    return 1;}

void PKCS8_PRIV_KEY_INFO_free (PKCS8_PRIV_KEY_INFO *a){	if (a == NULL) return;	M_ASN1_INTEGER_free (a->version);	X509_ALGOR_free(a->pkeyalg);	/* Clear sensitive data */	if (a->pkey->value.octet_string)		OPENSSL_cleanse(a->pkey->value.octet_string->data,				a->pkey->value.octet_string->length);	ASN1_TYPE_free (a->pkey);	sk_X509_ATTRIBUTE_pop_free (a->attributes, X509_ATTRIBUTE_free);	OPENSSL_free (a);}

X509_ALGOR *d2i_X509_ALGOR(X509_ALGOR **a, unsigned char **pp, long length)	{	M_ASN1_D2I_vars(a,X509_ALGOR *,X509_ALGOR_new);	M_ASN1_D2I_Init();	M_ASN1_D2I_start_sequence();	M_ASN1_D2I_get(ret->algorithm,d2i_ASN1_OBJECT);	if (!M_ASN1_D2I_end_sequence())		{ M_ASN1_D2I_get(ret->parameter,d2i_ASN1_TYPE); }	else		{		ASN1_TYPE_free(ret->parameter);		ret->parameter=NULL;		}	M_ASN1_D2I_Finish(a,X509_ALGOR_free,ASN1_F_D2I_X509_ALGOR);	}

//.........这里部分代码省略.........    }    if (!(ttmp = ASN1_TYPE_new())) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    if (!(ttmp->value.integer =      BN_to_ASN1_INTEGER(pkey->pkey.dsa->pub_key, NULL))) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,EVP_R_ENCODE_ERROR);      goto err;    }    ttmp->type = V_ASN1_INTEGER;    if (!sk_ASN1_TYPE_push(ndsa, ttmp)) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    if (!(ttmp = ASN1_TYPE_new())) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    ttmp->value.integer = prkey;    prkey = NULL;    ttmp->type = V_ASN1_INTEGER;    if (!sk_ASN1_TYPE_push(ndsa, ttmp)) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    ttmp = NULL;    if (!(p8->pkey->value.octet_string = ASN1_OCTET_STRING_new())) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    if (!ASN1_seq_pack_ASN1_TYPE(ndsa, i2d_ASN1_TYPE,           &p8->pkey->value.octet_string->data,           &p8->pkey->value.octet_string->length)) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);    break;    case PKCS8_EMBEDDED_PARAM:    p8->pkeyalg->parameter->type = V_ASN1_NULL;    if (!(ndsa = sk_ASN1_TYPE_new_null())) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    if (!(ttmp = ASN1_TYPE_new())) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    ttmp->value.sequence = params;    params = NULL;    ttmp->type = V_ASN1_SEQUENCE;    if (!sk_ASN1_TYPE_push(ndsa, ttmp)) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    if (!(ttmp = ASN1_TYPE_new())) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    ttmp->value.integer = prkey;    prkey = NULL;    ttmp->type = V_ASN1_INTEGER;    if (!sk_ASN1_TYPE_push(ndsa, ttmp)) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    ttmp = NULL;    if (!(p8->pkey->value.octet_string = ASN1_OCTET_STRING_new())) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    if (!ASN1_seq_pack_ASN1_TYPE(ndsa, i2d_ASN1_TYPE,           &p8->pkey->value.octet_string->data,           &p8->pkey->value.octet_string->length)) {      EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);      goto err;    }    sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);    break;  }  return 1;err:  if (p != NULL) OPENSSL_free(p);  if (params != NULL) ASN1_STRING_free(params);  if (prkey != NULL) M_ASN1_INTEGER_free(prkey);  if (ttmp != NULL) ASN1_TYPE_free(ttmp);  if (ndsa != NULL) sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);  return 0;}

//.........这里部分代码省略.........            num = 0;            for (;;) {                if (!BUF_MEM_grow(buf, (int)num + BUFSIZ))                    goto end;                i = BIO_read(in, &(buf->data[num]), BUFSIZ);                if (i <= 0)                    break;                num += i;            }        }        str = buf->data;    }    /* If any structs to parse go through in sequence */    if (sk_OPENSSL_STRING_num(osk)) {        tmpbuf = (unsigned char *)str;        tmplen = num;        for (i = 0; i < sk_OPENSSL_STRING_num(osk); i++) {            ASN1_TYPE *atmp;            int typ;            j = atoi(sk_OPENSSL_STRING_value(osk, i));            if (j == 0) {                BIO_printf(bio_err, "'%s' is an invalid number/n",                           sk_OPENSSL_STRING_value(osk, i));                continue;            }            tmpbuf += j;            tmplen -= j;            atmp = at;            ctmpbuf = tmpbuf;            at = d2i_ASN1_TYPE(NULL, &ctmpbuf, tmplen);            ASN1_TYPE_free(atmp);            if (!at) {                BIO_printf(bio_err, "Error parsing structure/n");                ERR_print_errors(bio_err);                goto end;            }            typ = ASN1_TYPE_get(at);            if ((typ == V_ASN1_OBJECT)                || (typ == V_ASN1_NULL)) {                BIO_printf(bio_err, "Can't parse %s type/n",                           typ == V_ASN1_NULL ? "NULL" : "OBJECT");                ERR_print_errors(bio_err);                goto end;            }            /* hmm... this is a little evil but it works */            tmpbuf = at->value.asn1_string->data;            tmplen = at->value.asn1_string->length;        }        str = (char *)tmpbuf;        num = tmplen;    }    if (offset >= num) {        BIO_printf(bio_err, "Error: offset too large/n");        goto end;    }    num -= offset;    if ((length == 0) || ((long)length > num))        length = (unsigned int)num;    if (derout) {        if (BIO_write(derout, str + offset, length) != (int)length) {

//.........这里部分代码省略.........        if (penclen <= 0)            goto err;        ASN1_STRING_set0(pubkey, penc, penclen);        pubkey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);        pubkey->flags |= ASN1_STRING_FLAG_BITS_LEFT;        penc = NULL;        X509_ALGOR_set0(talg, OBJ_nid2obj(NID_X9_62_id_ecPublicKey),                        V_ASN1_UNDEF, NULL);    }    /* See if custom paraneters set */    kdf_type = EVP_PKEY_CTX_get_ecdh_kdf_type(pctx);    if (kdf_type <= 0)        goto err;    if (!EVP_PKEY_CTX_get_ecdh_kdf_md(pctx, &kdf_md))        goto err;    ecdh_nid = EVP_PKEY_CTX_get_ecdh_cofactor_mode(pctx);    if (ecdh_nid < 0)        goto err;    else if (ecdh_nid == 0)        ecdh_nid = NID_dh_std_kdf;    else if (ecdh_nid == 1)        ecdh_nid = NID_dh_cofactor_kdf;    if (kdf_type == EVP_PKEY_ECDH_KDF_NONE) {        kdf_type = EVP_PKEY_ECDH_KDF_X9_62;        if (EVP_PKEY_CTX_set_ecdh_kdf_type(pctx, kdf_type) <= 0)            goto err;    } else        /* Uknown KDF */        goto err;    if (kdf_md == NULL) {        /* Fixme later for better MD */        kdf_md = EVP_sha1();        if (EVP_PKEY_CTX_set_ecdh_kdf_md(pctx, kdf_md) <= 0)            goto err;    }    if (!CMS_RecipientInfo_kari_get0_alg(ri, &talg, &ukm))        goto err;    /* Lookup NID for KDF+cofactor+digest */    if (!OBJ_find_sigid_by_algs(&kdf_nid, EVP_MD_type(kdf_md), ecdh_nid))        goto err;    /* Get wrap NID */    ctx = CMS_RecipientInfo_kari_get0_ctx(ri);    wrap_nid = EVP_CIPHER_CTX_type(ctx);    keylen = EVP_CIPHER_CTX_key_length(ctx);    /* Package wrap algorithm in an AlgorithmIdentifier */    wrap_alg = X509_ALGOR_new();    if (!wrap_alg)        goto err;    wrap_alg->algorithm = OBJ_nid2obj(wrap_nid);    wrap_alg->parameter = ASN1_TYPE_new();    if (!wrap_alg->parameter)        goto err;    if (EVP_CIPHER_param_to_asn1(ctx, wrap_alg->parameter) <= 0)        goto err;    if (ASN1_TYPE_get(wrap_alg->parameter) == NID_undef) {        ASN1_TYPE_free(wrap_alg->parameter);        wrap_alg->parameter = NULL;    }    if (EVP_PKEY_CTX_set_ecdh_kdf_outlen(pctx, keylen) <= 0)        goto err;    penclen = CMS_SharedInfo_encode(&penc, wrap_alg, ukm, keylen);    if (!penclen)        goto err;    if (EVP_PKEY_CTX_set0_ecdh_kdf_ukm(pctx, penc, penclen) <= 0)        goto err;    penc = NULL;    /*     * Now need to wrap encoding of wrap AlgorithmIdentifier into parameter     * of another AlgorithmIdentifier.     */    penclen = i2d_X509_ALGOR(wrap_alg, &penc);    if (!penc || !penclen)        goto err;    wrap_str = ASN1_STRING_new();    if (!wrap_str)        goto err;    ASN1_STRING_set0(wrap_str, penc, penclen);    penc = NULL;    X509_ALGOR_set0(talg, OBJ_nid2obj(kdf_nid), V_ASN1_SEQUENCE, wrap_str);    rv = 1; err:    OPENSSL_free(penc);    X509_ALGOR_free(wrap_alg);    return rv;}

int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)	{	X509_PUBKEY *pk=NULL;	X509_ALGOR *a;	ASN1_OBJECT *o;	unsigned char *s,*p = NULL;	int i;	if (x == NULL) return(0);	if ((pk=X509_PUBKEY_new()) == NULL) goto err;	a=pk->algor;	/* set the algorithm id */	if ((o=OBJ_nid2obj(pkey->type)) == NULL) goto err;	ASN1_OBJECT_free(a->algorithm);	a->algorithm=o;	/* Set the parameter list */	if (!pkey->save_parameters || (pkey->type == EVP_PKEY_RSA))		{		if ((a->parameter == NULL) ||			(a->parameter->type != V_ASN1_NULL))			{			ASN1_TYPE_free(a->parameter);			if (!(a->parameter=ASN1_TYPE_new()))				{				X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);				goto err;				}			a->parameter->type=V_ASN1_NULL;			}		}#ifndef OPENSSL_NO_DSA	else if (pkey->type == EVP_PKEY_DSA)		{		unsigned char *pp;		DSA *dsa;				dsa=pkey->pkey.dsa;		dsa->write_params=0;		ASN1_TYPE_free(a->parameter);		if ((i=i2d_DSAparams(dsa,NULL)) <= 0)			goto err;		if (!(p=(unsigned char *)OPENSSL_malloc(i)))			{			X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);			goto err;			}		pp=p;		i2d_DSAparams(dsa,&pp);		if (!(a->parameter=ASN1_TYPE_new()))			{			OPENSSL_free(p);			X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);			goto err;			}		a->parameter->type=V_ASN1_SEQUENCE;		if (!(a->parameter->value.sequence=ASN1_STRING_new()))			{			OPENSSL_free(p);			X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);			goto err;			}		if (!ASN1_STRING_set(a->parameter->value.sequence,p,i))			{			OPENSSL_free(p);			X509err(X509_F_X509_PUBKEY_SET,ERR_R_MALLOC_FAILURE);			goto err;			}		OPENSSL_free(p);		}#endif#ifndef OPENSSL_NO_EC	else if (pkey->type == EVP_PKEY_EC)		{		int nid=0;		unsigned char *pp;		EC_KEY *ec_key;		const EC_GROUP *group;				ec_key = pkey->pkey.ec;		ASN1_TYPE_free(a->parameter);		if ((a->parameter = ASN1_TYPE_new()) == NULL)			{			X509err(X509_F_X509_PUBKEY_SET, ERR_R_ASN1_LIB);			goto err;			}		group = EC_KEY_get0_group(ec_key);		if (EC_GROUP_get_asn1_flag(group)                     && (nid = EC_GROUP_get_curve_name(group)))			{			/* just set the OID */			a->parameter->type = V_ASN1_OBJECT;			a->parameter->value.object = OBJ_nid2obj(nid);			}		else /* explicit parameters */			{//.........这里部分代码省略.........

ASN1_TYPE *ASN1_generate_v3(char *str, X509V3_CTX *cnf)	{	ASN1_TYPE *ret;	tag_exp_arg asn1_tags;	tag_exp_type *etmp;	int i, len;	unsigned char *orig_der = NULL, *new_der = NULL;	const unsigned char *cpy_start;	unsigned char *p;	const unsigned char *cp;	int cpy_len;	long hdr_len;	int hdr_constructed = 0, hdr_tag, hdr_class;	int r;	asn1_tags.imp_tag = -1;	asn1_tags.imp_class = -1;	asn1_tags.format = ASN1_GEN_FORMAT_ASCII;	asn1_tags.exp_count = 0;	if (CONF_parse_list(str, ',', 1, asn1_cb, &asn1_tags) != 0)		return NULL;	if ((asn1_tags.utype == V_ASN1_SEQUENCE) || (asn1_tags.utype == V_ASN1_SET))		{		if (!cnf)			{			ASN1err(ASN1_F_ASN1_GENERATE_V3, ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG);			return NULL;			}		ret = asn1_multi(asn1_tags.utype, asn1_tags.str, cnf);		}	else		ret = asn1_str2type(asn1_tags.str, asn1_tags.format, asn1_tags.utype);	if (!ret)		return NULL;	/* If no tagging return base type */	if ((asn1_tags.imp_tag == -1) && (asn1_tags.exp_count == 0))		return ret;	/* Generate the encoding */	cpy_len = i2d_ASN1_TYPE(ret, &orig_der);	ASN1_TYPE_free(ret);	ret = NULL;	/* Set point to start copying for modified encoding */	cpy_start = orig_der;	/* Do we need IMPLICIT tagging? */	if (asn1_tags.imp_tag != -1)		{		/* If IMPLICIT we will replace the underlying tag */		/* Skip existing tag+len */		r = ASN1_get_object(&cpy_start, &hdr_len, &hdr_tag, &hdr_class, cpy_len);		if (r & 0x80)			goto err;		/* Update copy length */		cpy_len -= (int)(cpy_start - orig_der);		/* For IMPLICIT tagging the length should match the		 * original length and constructed flag should be		 * consistent.		 */		if (r & 0x1)			{			/* Indefinite length constructed */			hdr_constructed = 2;			hdr_len = 0;			}		else			/* Just retain constructed flag */			hdr_constructed = r & V_ASN1_CONSTRUCTED;		/* Work out new length with IMPLICIT tag: ignore constructed		 * because it will mess up if indefinite length		 */		len = ASN1_object_size(0, hdr_len, asn1_tags.imp_tag);		}	else		len = cpy_len;	/* Work out length in any EXPLICIT, starting from end */	for(i = 0, etmp = asn1_tags.exp_list + asn1_tags.exp_count - 1; i < asn1_tags.exp_count; i++, etmp--)		{		/* Content length: number of content octets + any padding */		len += etmp->exp_pad;		etmp->exp_len = len;		/* Total object length: length including new header */		len = ASN1_object_size(0, len, etmp->exp_tag);		}	/* Allocate buffer for new encoding */	new_der = OPENSSL_malloc(len);	/* Generate tagged encoding */	p = new_der;//.........这里部分代码省略.........

int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1, X509_ALGOR *algor2,              ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey,              const EVP_MD *type){    EVP_MD_CTX ctx;    unsigned char *p, *buf_in = NULL, *buf_out = NULL;    int i, inl = 0, outl = 0, outll = 0;    X509_ALGOR *a;    EVP_MD_CTX_init(&ctx);    for (i = 0; i < 2; i++) {        if (i == 0)            a = algor1;        else            a = algor2;        if (a == NULL)            continue;        if (type->pkey_type == NID_dsaWithSHA1) {            /*             * special case: RFC 2459 tells us to omit 'parameters' with             * id-dsa-with-sha1             */            ASN1_TYPE_free(a->parameter);            a->parameter = NULL;        } else if ((a->parameter == NULL) ||                   (a->parameter->type != V_ASN1_NULL)) {            ASN1_TYPE_free(a->parameter);            if ((a->parameter = ASN1_TYPE_new()) == NULL)                goto err;            a->parameter->type = V_ASN1_NULL;        }        ASN1_OBJECT_free(a->algorithm);        a->algorithm = OBJ_nid2obj(type->pkey_type);        if (a->algorithm == NULL) {            ASN1err(ASN1_F_ASN1_SIGN, ASN1_R_UNKNOWN_OBJECT_TYPE);            goto err;        }        if (a->algorithm->length == 0) {            ASN1err(ASN1_F_ASN1_SIGN,                    ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD);            goto err;        }    }    inl = i2d(data, NULL);    buf_in = (unsigned char *)OPENSSL_malloc((unsigned int)inl);    outll = outl = EVP_PKEY_size(pkey);    buf_out = (unsigned char *)OPENSSL_malloc((unsigned int)outl);    if ((buf_in == NULL) || (buf_out == NULL)) {        outl = 0;        ASN1err(ASN1_F_ASN1_SIGN, ERR_R_MALLOC_FAILURE);        goto err;    }    p = buf_in;    i2d(data, &p);    if (!EVP_SignInit_ex(&ctx, type, NULL)        || !EVP_SignUpdate(&ctx, (unsigned char *)buf_in, inl)        || !EVP_SignFinal(&ctx, (unsigned char *)buf_out,                          (unsigned int *)&outl, pkey)) {        outl = 0;        ASN1err(ASN1_F_ASN1_SIGN, ERR_R_EVP_LIB);        goto err;    }    if (signature->data != NULL)        OPENSSL_free(signature->data);    signature->data = buf_out;    buf_out = NULL;    signature->length = outl;    /*     * In the interests of compatibility, I'll make sure that the bit string     * has a 'not-used bits' value of 0     */    signature->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);    signature->flags |= ASN1_STRING_FLAG_BITS_LEFT; err:    EVP_MD_CTX_cleanup(&ctx);    if (buf_in != NULL) {        OPENSSL_cleanse((char *)buf_in, (unsigned int)inl);        OPENSSL_free(buf_in);    }    if (buf_out != NULL) {        OPENSSL_cleanse((char *)buf_out, outll);        OPENSSL_free(buf_out);    }    return (outl);}

//.........这里部分代码省略.........        CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,               CMS_R_CIPHER_INITIALISATION_ERROR);        goto err;    }    if (enc) {        int ivlen;        calg->algorithm = OBJ_nid2obj(EVP_CIPHER_CTX_type(ctx));        /* Generate a random IV if we need one */        ivlen = EVP_CIPHER_CTX_iv_length(ctx);        if (ivlen > 0) {            if (RAND_bytes(iv, ivlen) <= 0)                goto err;            piv = iv;        }    } else if (EVP_CIPHER_asn1_to_param(ctx, calg->parameter) <= 0) {        CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,               CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);        goto err;    }    tkeylen = EVP_CIPHER_CTX_key_length(ctx);    /* Generate random session key */    if (!enc || !ec->key) {        tkey = OPENSSL_malloc(tkeylen);        if (tkey == NULL) {            CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);            goto err;        }        if (EVP_CIPHER_CTX_rand_key(ctx, tkey) <= 0)            goto err;    }    if (!ec->key) {        ec->key = tkey;        ec->keylen = tkeylen;        tkey = NULL;        if (enc)            keep_key = 1;        else            ERR_clear_error();    }    if (ec->keylen != tkeylen) {        /* If necessary set key length */        if (EVP_CIPHER_CTX_set_key_length(ctx, ec->keylen) <= 0) {            /*             * Only reveal failure if debugging so we don't leak information             * which may be useful in MMA.             */            if (enc || ec->debug) {                CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,                       CMS_R_INVALID_KEY_LENGTH);                goto err;            } else {                /* Use random key */                OPENSSL_clear_free(ec->key, ec->keylen);                ec->key = tkey;                ec->keylen = tkeylen;                tkey = NULL;                ERR_clear_error();            }        }    }    if (EVP_CipherInit_ex(ctx, NULL, NULL, ec->key, piv, enc) <= 0) {        CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,               CMS_R_CIPHER_INITIALISATION_ERROR);        goto err;    }    if (enc) {        calg->parameter = ASN1_TYPE_new();        if (calg->parameter == NULL) {            CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);            goto err;        }        if (EVP_CIPHER_param_to_asn1(ctx, calg->parameter) <= 0) {            CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,                   CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);            goto err;        }        /* If parameter type not set omit parameter */        if (calg->parameter->type == V_ASN1_UNDEF) {            ASN1_TYPE_free(calg->parameter);            calg->parameter = NULL;        }    }    ok = 1; err:    if (!keep_key || !ok) {        OPENSSL_clear_free(ec->key, ec->keylen);        ec->key = NULL;    }    OPENSSL_clear_free(tkey, tkeylen);    if (ok)        return b;    BIO_free(b);    return NULL;}

static int eckey_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey){  EC_KEY    *ec_key;  const EC_GROUP  *group;  unsigned char  *p, *pp;  int     nid, i, ret = 0;  unsigned int    tmp_flags, old_flags;  ec_key = pkey->pkey.ec;  if (ec_key == NULL || (group = EC_KEY_get0_group(ec_key)) == NULL)   {    EVPerr(EVP_F_ECKEY_PKEY2PKCS8, EVP_R_MISSING_PARAMETERS);    return 0;  }  /* set the ec parameters OID */  if (p8->pkeyalg->algorithm)    ASN1_OBJECT_free(p8->pkeyalg->algorithm);  p8->pkeyalg->algorithm = OBJ_nid2obj(NID_X9_62_id_ecPublicKey);  /* set the ec parameters */  if (p8->pkeyalg->parameter)  {    ASN1_TYPE_free(p8->pkeyalg->parameter);    p8->pkeyalg->parameter = NULL;  }  if ((p8->pkeyalg->parameter = ASN1_TYPE_new()) == NULL)  {    EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);    return 0;  }    if (EC_GROUP_get_asn1_flag(group)                     && (nid = EC_GROUP_get_curve_name(group)))  {    /* we have a 'named curve' => just set the OID */    p8->pkeyalg->parameter->type = V_ASN1_OBJECT;    p8->pkeyalg->parameter->value.object = OBJ_nid2obj(nid);  }  else  /* explicit parameters */  {    if ((i = i2d_ECParameters(ec_key, NULL)) == 0)    {      EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_EC_LIB);      return 0;    }    if ((p = (unsigned char *) OPENSSL_malloc(i)) == NULL)    {      EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);      return 0;    }      pp = p;    if (!i2d_ECParameters(ec_key, &pp))    {      EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_EC_LIB);      OPENSSL_free(p);      return 0;    }    p8->pkeyalg->parameter->type = V_ASN1_SEQUENCE;    if ((p8->pkeyalg->parameter->value.sequence       = ASN1_STRING_new()) == NULL)    {      EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_ASN1_LIB);      OPENSSL_free(p);      return 0;    }    ASN1_STRING_set(p8->pkeyalg->parameter->value.sequence, p, i);    OPENSSL_free(p);  }  /* set the private key */  /* do not include the parameters in the SEC1 private key   * see PKCS#11 12.11 */  old_flags = EC_KEY_get_enc_flags(pkey->pkey.ec);  tmp_flags = old_flags | EC_PKEY_NO_PARAMETERS;  EC_KEY_set_enc_flags(pkey->pkey.ec, tmp_flags);  i = i2d_ECPrivateKey(pkey->pkey.ec, NULL);  if (!i)  {    EC_KEY_set_enc_flags(pkey->pkey.ec, old_flags);    EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_EC_LIB);    return 0;  }  p = (unsigned char *) OPENSSL_malloc(i);  if (!p)  {    EC_KEY_set_enc_flags(pkey->pkey.ec, old_flags);    EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);    return 0;  }  pp = p;  if (!i2d_ECPrivateKey(pkey->pkey.ec, &pp))  {    EC_KEY_set_enc_flags(pkey->pkey.ec, old_flags);    EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_EC_LIB);    OPENSSL_free(p);//.........这里部分代码省略.........

static int dh_cms_encrypt(CMS_RecipientInfo *ri){    EVP_PKEY_CTX *pctx;    EVP_PKEY *pkey;    EVP_CIPHER_CTX *ctx;    int keylen;    X509_ALGOR *talg, *wrap_alg = NULL;    ASN1_OBJECT *aoid;    ASN1_BIT_STRING *pubkey;    ASN1_STRING *wrap_str;    ASN1_OCTET_STRING *ukm;    unsigned char *penc = NULL, *dukm = NULL;    int penclen;    size_t dukmlen = 0;    int rv = 0;    int kdf_type, wrap_nid;    const EVP_MD *kdf_md;    pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);    if (!pctx)        return 0;    /* Get ephemeral key */    pkey = EVP_PKEY_CTX_get0_pkey(pctx);    if (!CMS_RecipientInfo_kari_get0_orig_id(ri, &talg, &pubkey,                                             NULL, NULL, NULL))        goto err;    X509_ALGOR_get0(&aoid, NULL, NULL, talg);    /* Is everything uninitialised? */    if (aoid == OBJ_nid2obj(NID_undef)) {        ASN1_INTEGER *pubk;        pubk = BN_to_ASN1_INTEGER(pkey->pkey.dh->pub_key, NULL);        if (!pubk)            goto err;        /* Set the key */        penclen = i2d_ASN1_INTEGER(pubk, &penc);        ASN1_INTEGER_free(pubk);        if (penclen <= 0)            goto err;        ASN1_STRING_set0(pubkey, penc, penclen);        pubkey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);        pubkey->flags |= ASN1_STRING_FLAG_BITS_LEFT;        penc = NULL;        X509_ALGOR_set0(talg, OBJ_nid2obj(NID_dhpublicnumber),                        V_ASN1_UNDEF, NULL);    }    /* See if custom paraneters set */    kdf_type = EVP_PKEY_CTX_get_dh_kdf_type(pctx);    if (kdf_type <= 0)        goto err;    if (!EVP_PKEY_CTX_get_dh_kdf_md(pctx, &kdf_md))        goto err;    if (kdf_type == EVP_PKEY_DH_KDF_NONE) {        kdf_type = EVP_PKEY_DH_KDF_X9_42;        if (EVP_PKEY_CTX_set_dh_kdf_type(pctx, kdf_type) <= 0)            goto err;    } else if (kdf_type != EVP_PKEY_DH_KDF_X9_42)        /* Unknown KDF */        goto err;    if (kdf_md == NULL) {        /* Only SHA1 supported */        kdf_md = EVP_sha1();        if (EVP_PKEY_CTX_set_dh_kdf_md(pctx, kdf_md) <= 0)            goto err;    } else if (EVP_MD_type(kdf_md) != NID_sha1)        /* Unsupported digest */        goto err;    if (!CMS_RecipientInfo_kari_get0_alg(ri, &talg, &ukm))        goto err;    /* Get wrap NID */    ctx = CMS_RecipientInfo_kari_get0_ctx(ri);    wrap_nid = EVP_CIPHER_CTX_type(ctx);    if (EVP_PKEY_CTX_set0_dh_kdf_oid(pctx, OBJ_nid2obj(wrap_nid)) <= 0)        goto err;    keylen = EVP_CIPHER_CTX_key_length(ctx);    /* Package wrap algorithm in an AlgorithmIdentifier */    wrap_alg = X509_ALGOR_new();    if (!wrap_alg)        goto err;    wrap_alg->algorithm = OBJ_nid2obj(wrap_nid);    wrap_alg->parameter = ASN1_TYPE_new();    if (!wrap_alg->parameter)        goto err;    if (EVP_CIPHER_param_to_asn1(ctx, wrap_alg->parameter) <= 0)        goto err;    if (ASN1_TYPE_get(wrap_alg->parameter) == NID_undef) {        ASN1_TYPE_free(wrap_alg->parameter);        wrap_alg->parameter = NULL;    }    if (EVP_PKEY_CTX_set_dh_kdf_outlen(pctx, keylen) <= 0)        goto err;    if (ukm) {//.........这里部分代码省略.........

static ASN1_TYPE *asn1_multi(int utype, const char *section, X509V3_CTX *cnf)	{	ASN1_TYPE *ret = NULL, *typ = NULL;	STACK_OF(ASN1_TYPE) *sk = NULL;	STACK_OF(CONF_VALUE) *sect = NULL;	unsigned char *der = NULL, *p;	int derlen;	int i, is_set;	sk = sk_ASN1_TYPE_new_null();	if (section)		{		if (!cnf)			goto bad;		sect = X509V3_get_section(cnf, (char *)section);		if (!sect)			goto bad;		for (i = 0; i < sk_CONF_VALUE_num(sect); i++)			{			typ = ASN1_generate_v3(sk_CONF_VALUE_value(sect, i)->value, cnf);			if (!typ)				goto bad;			sk_ASN1_TYPE_push(sk, typ);			typ = NULL;			}		}	/* Now we has a STACK of the components, convert to the correct form */	if (utype == V_ASN1_SET)		is_set = 1;	else		is_set = 0;	derlen = i2d_ASN1_SET_OF_ASN1_TYPE(sk, NULL, i2d_ASN1_TYPE, utype,					   V_ASN1_UNIVERSAL, is_set);	der = OPENSSL_malloc(derlen);	p = der;	i2d_ASN1_SET_OF_ASN1_TYPE(sk, &p, i2d_ASN1_TYPE, utype,				  V_ASN1_UNIVERSAL, is_set);	if (!(ret = ASN1_TYPE_new()))		goto bad;	if (!(ret->value.asn1_string = ASN1_STRING_type_new(utype)))		goto bad;	ret->type = utype;	ret->value.asn1_string->data = der;	ret->value.asn1_string->length = derlen;	der = NULL;	bad:	if (der)		OPENSSL_free(der);	if (sk)		sk_ASN1_TYPE_pop_free(sk, ASN1_TYPE_free);	if (typ)		ASN1_TYPE_free(typ);	if (sect)		X509V3_section_free(cnf, sect);	return ret;	}

//.........这里部分代码省略.........			goto end;			}		}	if (derfile) {		if(!(derout = BIO_new_file(derfile, "wb"))) {			BIO_printf(bio_err,"problems opening %s/n",derfile);			ERR_print_errors(bio_err);			goto end;		}	}	if ((buf=BUF_MEM_new()) == NULL) goto end;	if (!BUF_MEM_grow(buf,BUFSIZ*8)) goto end; /* Pre-allocate :-) */	if (informat == FORMAT_PEM)		{		BIO *tmp;		if ((b64=BIO_new(BIO_f_base64())) == NULL)			goto end;		BIO_push(b64,in);		tmp=in;		in=b64;		b64=tmp;		}	num=0;	for (;;)		{		if (!BUF_MEM_grow(buf,(int)num+BUFSIZ)) goto end;		i=BIO_read(in,&(buf->data[num]),BUFSIZ);		if (i <= 0) break;		num+=i;		}	str=buf->data;	/* If any structs to parse go through in sequence */	if (sk_num(osk))		{		tmpbuf=(unsigned char *)str;		tmplen=num;		for (i=0; i<sk_num(osk); i++)			{			ASN1_TYPE *atmp;			j=atoi(sk_value(osk,i));			if (j == 0)				{				BIO_printf(bio_err,"'%s' is an invalid number/n",sk_value(osk,i));				continue;				}			tmpbuf+=j;			tmplen-=j;			atmp = at;			at = d2i_ASN1_TYPE(NULL,&tmpbuf,tmplen);			ASN1_TYPE_free(atmp);			if(!at)				{				BIO_printf(bio_err,"Error parsing structure/n");				ERR_print_errors(bio_err);				goto end;				}			/* hmm... this is a little evil but it works */			tmpbuf=at->value.asn1_string->data;			tmplen=at->value.asn1_string->length;			}		str=(char *)tmpbuf;		num=tmplen;		}	if (length == 0) length=(unsigned int)num;	if(derout) {		if(BIO_write(derout, str + offset, length) != (int)length) {			BIO_printf(bio_err, "Error writing output/n");			ERR_print_errors(bio_err);			goto end;		}	}	if (!noout &&	    !ASN1_parse_dump(out,(unsigned char *)&(str[offset]),length,		    indent,dump))		{		ERR_print_errors(bio_err);		goto end;		}	ret=0;end:	BIO_free(derout);	if (in != NULL) BIO_free(in);	if (out != NULL) BIO_free_all(out);	if (b64 != NULL) BIO_free(b64);	if (ret != 0)		ERR_print_errors(bio_err);	if (buf != NULL) BUF_MEM_free(buf);	if (at != NULL) ASN1_TYPE_free(at);	if (osk != NULL) sk_free(osk);	OBJ_cleanup();	OPENSSL_EXIT(ret);	}