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

int X509_alias_set1(X509 *x, unsigned char *name, int len){	X509_CERT_AUX *aux;	if(!(aux = aux_get(x))) return 0;	if(!aux->alias && !(aux->alias = ASN1_UTF8STRING_new())) return 0;	return ASN1_STRING_set(aux->alias, name, len);}

intPKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen, unsigned char *salt,    int saltlen, int iter, const EVP_MD *md_type){	unsigned char mac[EVP_MAX_MD_SIZE];	unsigned int maclen;	if (!md_type)		md_type = EVP_sha1();	if (PKCS12_setup_mac(p12, iter, salt, saltlen, md_type) ==	    PKCS12_ERROR) {		PKCS12err(PKCS12_F_PKCS12_SET_MAC, PKCS12_R_MAC_SETUP_ERROR);		return 0;	}	if (!PKCS12_gen_mac(p12, pass, passlen, mac, &maclen)) {		PKCS12err(PKCS12_F_PKCS12_SET_MAC,		    PKCS12_R_MAC_GENERATION_ERROR);		return 0;	}	if (!(ASN1_STRING_set(p12->mac->dinfo->digest, mac, maclen))) {		PKCS12err(PKCS12_F_PKCS12_SET_MAC,		    PKCS12_R_MAC_STRING_SET_ERROR);		return 0;	}	return 1;}

static int pub_encode_gost94(X509_PUBKEY *pub,const EVP_PKEY *pk)	{	ASN1_OBJECT *algobj = NULL;	ASN1_OCTET_STRING *octet = NULL;	void *pval = NULL;	unsigned char *buf=NULL,*databuf,*sptr;	int i,j,data_len,ret=0;	int ptype = V_ASN1_UNDEF;	DSA *dsa = EVP_PKEY_get0((EVP_PKEY *)pk);	algobj = OBJ_nid2obj(EVP_PKEY_base_id(pk));	if (pk->save_parameters) 		{		ASN1_STRING *params = encode_gost_algor_params(pk);		pval = params;		ptype = V_ASN1_SEQUENCE;		}		data_len = BN_num_bytes(dsa->pub_key);	databuf = OPENSSL_malloc(data_len);	BN_bn2bin(dsa->pub_key,databuf);	octet = ASN1_OCTET_STRING_new();	ASN1_STRING_set(octet,NULL,data_len);	sptr = ASN1_STRING_data(octet);	for (i=0,j=data_len-1; i< data_len;i++,j--)		{		sptr[i]=databuf[j];		}	OPENSSL_free(databuf);	ret = i2d_ASN1_OCTET_STRING(octet,&buf);	ASN1_BIT_STRING_free(octet);	if (ret <0)  return 0;	return X509_PUBKEY_set0_param(pub,algobj,ptype,pval,buf,ret);	}

int X509_keyid_set1(X509 *x, unsigned char *id, int len){	X509_CERT_AUX *aux;	if(!(aux = aux_get(x))) return 0;	if(!aux->keyid && !(aux->keyid = ASN1_OCTET_STRING_new())) return 0;	return ASN1_STRING_set(aux->keyid, id, len);}

int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,                             const uint8_t *bytes, int len){    int i;    if ((ne == NULL) || ((bytes == NULL) && (len != 0)))        return (0);    if ((type > 0) && (type & MBSTRING_FLAG))        return ASN1_STRING_set_by_NID(&ne->value, bytes,                                      len, type,                                      OBJ_obj2nid(ne->object)) ?                   1 :                   0;    if (len < 0)        len = strlen((const char *)bytes);    i = ASN1_STRING_set(ne->value, bytes, len);    if (!i)        return (0);    if (type != V_ASN1_UNDEF) {        if (type == V_ASN1_APP_CHOOSE)            ne->value->type = ASN1_PRINTABLE_type(bytes, len);        else            ne->value->type = type;    }    return (1);}

/* Convert an ASN1_TIME structure to GeneralizedTime */ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t,                                                   ASN1_GENERALIZEDTIME **out){    ASN1_GENERALIZEDTIME *ret = NULL;    char *str;    int newlen;    if (!ASN1_TIME_check(t))        return NULL;    if (out == NULL || *out == NULL) {        if ((ret = ASN1_GENERALIZEDTIME_new()) == NULL)            goto err;    } else        ret = *out;    /* If already GeneralizedTime just copy across */    if (t->type == V_ASN1_GENERALIZEDTIME) {        if (!ASN1_STRING_set(ret, t->data, t->length))            goto err;        goto done;    }    /* grow the string */    if (!ASN1_STRING_set(ret, NULL, t->length + 2))        goto err;    /* ASN1_STRING_set() allocated 'len + 1' bytes. */    newlen = t->length + 2 + 1;    str = (char *)ret->data;    /* Work out the century and prepend */    if (t->data[0] >= '5')        OPENSSL_strlcpy(str, "19", newlen);    else        OPENSSL_strlcpy(str, "20", newlen);    OPENSSL_strlcat(str, (const char *)t->data, newlen); done:   if (out != NULL && *out == NULL)       *out = ret;   return ret; err:    if (out == NULL || *out != ret)        ASN1_GENERALIZEDTIME_free(ret);    return NULL;}

static int pub_encode_gost01(X509_PUBKEY *pub,const EVP_PKEY *pk)	{	ASN1_OBJECT *algobj = NULL;	ASN1_OCTET_STRING *octet = NULL;	void *pval = NULL;	unsigned char *buf=NULL,*databuf,*sptr;	int i,j,data_len,ret=0;	const EC_POINT *pub_key;	BIGNUM *X,*Y,*order;	const EC_KEY *ec = EVP_PKEY_get0((EVP_PKEY *)pk);	int ptype = V_ASN1_UNDEF;	algobj = OBJ_nid2obj(EVP_PKEY_base_id(pk));	if (pk->save_parameters) 		{		ASN1_STRING *params = encode_gost_algor_params(pk);		pval = params;		ptype = V_ASN1_SEQUENCE;		}	order = BN_new();	EC_GROUP_get_order(EC_KEY_get0_group(ec),order,NULL);	pub_key=EC_KEY_get0_public_key(ec);	if (!pub_key) 		{		GOSTerr(GOST_F_PUB_ENCODE_GOST01,			GOST_R_PUBLIC_KEY_UNDEFINED);		return 0;		}		X=BN_new();	Y=BN_new();	EC_POINT_get_affine_coordinates_GFp(EC_KEY_get0_group(ec),		pub_key,X,Y,NULL);	data_len = 2*BN_num_bytes(order);	BN_free(order);	databuf = OPENSSL_malloc(data_len);	memset(databuf,0,data_len);		store_bignum(X,databuf+data_len/2,data_len/2);	store_bignum(Y,databuf,data_len/2);	BN_free(X);	BN_free(Y);	octet = ASN1_OCTET_STRING_new();	ASN1_STRING_set(octet,NULL,data_len);	sptr=ASN1_STRING_data(octet);    for (i=0,j=data_len-1;i<data_len;i++,j--) 		{        sptr[i]=databuf[j];		}    OPENSSL_free(databuf);	ret = i2d_ASN1_OCTET_STRING(octet,&buf);	ASN1_BIT_STRING_free(octet);	if (ret <0)  return 0;	return X509_PUBKEY_set0_param(pub,algobj,ptype,pval,buf,ret);	}

/* Convert an ASN1_TIME structure to GeneralizedTime */ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(ASN1_TIME *t,                                                   ASN1_GENERALIZEDTIME **out){    ASN1_GENERALIZEDTIME *ret;    char *str;    int newlen;    if (!ASN1_TIME_check(t))        return NULL;    if (!out || !*out) {        if (!(ret = ASN1_GENERALIZEDTIME_new()))            return NULL;        if (out)            *out = ret;    } else        ret = *out;    /* If already GeneralizedTime just copy across */    if (t->type == V_ASN1_GENERALIZEDTIME) {        if (!ASN1_STRING_set(ret, t->data, t->length))            return NULL;        return ret;    }    /* grow the string */    if (!ASN1_STRING_set(ret, NULL, t->length + 2))        return NULL;    /* ASN1_STRING_set() allocated 'len + 1' bytes. */    newlen = t->length + 2 + 1;    str = (char *)ret->data;    /* Work out the century and prepend */    if (t->data[0] >= '5')        BUF_strlcpy(str, "19", newlen);    else        BUF_strlcpy(str, "20", newlen);    BUF_strlcat(str, (char *)t->data, newlen);    return ret;}

static ASN1_STRING*obj_to_asn1str(VALUE obj){    ASN1_STRING *str;    StringValue(obj);    if(!(str = ASN1_STRING_new()))	ossl_raise(eASN1Error, NULL);    ASN1_STRING_set(str, RSTRING_PTR(obj), RSTRING_LEN(obj));    return str;}

int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,				const unsigned char *salt, int saltlen)	{	PBEPARAM *pbe=NULL;	ASN1_STRING *pbe_str=NULL;	unsigned char *sstr;	pbe = PBEPARAM_new();	if (!pbe)		{		ASN1err(ASN1_F_PKCS5_PBE_SET0_ALGOR,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_SET0_ALGOR,ERR_R_MALLOC_FAILURE);		goto err;		}	if (!saltlen)		saltlen = PKCS5_SALT_LEN;	if (!ASN1_STRING_set(pbe->salt, NULL, saltlen))		{		ASN1err(ASN1_F_PKCS5_PBE_SET0_ALGOR,ERR_R_MALLOC_FAILURE);		goto err;		}	sstr = ASN1_STRING_data(pbe->salt);	if (salt)		TINYCLR_SSL_MEMCPY(sstr, salt, saltlen);	else if (RAND_pseudo_bytes(sstr, saltlen) < 0)		goto err;	if(!ASN1_item_pack(pbe, ASN1_ITEM_rptr(PBEPARAM), &pbe_str))		{		ASN1err(ASN1_F_PKCS5_PBE_SET0_ALGOR,ERR_R_MALLOC_FAILURE);		goto err;		}	PBEPARAM_free(pbe);	pbe = NULL;	if (X509_ALGOR_set0(algor, OBJ_nid2obj(alg), V_ASN1_SEQUENCE, pbe_str))		return 1;err:	if (pbe != NULL)		PBEPARAM_free(pbe);	if (pbe_str != NULL)		ASN1_STRING_free(pbe_str);	return 0;	}

int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,				const unsigned char *salt, int saltlen)	{	PBEPARAM *pbe=NULL;	ASN1_STRING *pbe_str=NULL;	unsigned char *sstr;	pbe = PBEPARAM_new();	if (!pbe)		{		OPENSSL_PUT_ERROR(PKCS8, PKCS5_pbe_set0_algor, ERR_R_MALLOC_FAILURE);		goto err;		}	if(iter <= 0)		iter = PKCS5_DEFAULT_ITERATIONS;	if (!ASN1_INTEGER_set(pbe->iter, iter))		{		OPENSSL_PUT_ERROR(PKCS8, PKCS5_pbe_set0_algor, ERR_R_MALLOC_FAILURE);		goto err;		}	if (!saltlen)		saltlen = PKCS5_SALT_LEN;	if (!ASN1_STRING_set(pbe->salt, NULL, saltlen))		{		OPENSSL_PUT_ERROR(PKCS8, PKCS5_pbe_set0_algor, ERR_R_MALLOC_FAILURE);		goto err;		}	sstr = ASN1_STRING_data(pbe->salt);	if (salt)		memcpy(sstr, salt, saltlen);	else if (!RAND_bytes(sstr, saltlen))		goto err;	if(!ASN1_item_pack(pbe, ASN1_ITEM_rptr(PBEPARAM), &pbe_str))		{		OPENSSL_PUT_ERROR(PKCS8, PKCS5_pbe_set0_algor, ERR_R_MALLOC_FAILURE);		goto err;		}	PBEPARAM_free(pbe);	pbe = NULL;	if (X509_ALGOR_set0(algor, OBJ_nid2obj(alg), V_ASN1_SEQUENCE, pbe_str))		return 1;err:	if (pbe != NULL)		PBEPARAM_free(pbe);	if (pbe_str != NULL)		ASN1_STRING_free(pbe_str);	return 0;	}

static ASN1_STRING*obj_to_asn1derstr(VALUE obj){    ASN1_STRING *a1str;    VALUE str;    str = ossl_to_der(obj);    if(!(a1str = ASN1_STRING_new()))	ossl_raise(eASN1Error, NULL);    ASN1_STRING_set(a1str, RSTRING_PTR(str), RSTRING_LEN(str));    return a1str;}

ASN1_TIME *asn1_time_from_tm(ASN1_TIME *s, struct tm *ts, int type){    char* p;    ASN1_TIME *tmps = NULL;    const size_t len = 20;    if (type == V_ASN1_UNDEF) {        if (is_utc(ts->tm_year))            type = V_ASN1_UTCTIME;        else            type = V_ASN1_GENERALIZEDTIME;    } else if (type == V_ASN1_UTCTIME) {        if (!is_utc(ts->tm_year))            goto err;    } else if (type != V_ASN1_GENERALIZEDTIME) {        goto err;    }    if (s == NULL)        tmps = ASN1_STRING_new();    else        tmps = s;    if (tmps == NULL)        return NULL;    if (!ASN1_STRING_set(tmps, NULL, len))        goto err;    tmps->type = type;    p = (char*)tmps->data;    if (type == V_ASN1_GENERALIZEDTIME)        tmps->length = BIO_snprintf(p, len, "%04d%02d%02d%02d%02d%02dZ",                                    ts->tm_year + 1900, ts->tm_mon + 1,                                    ts->tm_mday, ts->tm_hour, ts->tm_min,                                    ts->tm_sec);    else        tmps->length = BIO_snprintf(p, len, "%02d%02d%02d%02d%02d%02dZ",                                    ts->tm_year % 100, ts->tm_mon + 1,                                    ts->tm_mday, ts->tm_hour, ts->tm_min,                                    ts->tm_sec);#ifdef CHARSET_EBCDIC_not    ebcdic2ascii(tmps->data, tmps->data, tmps->length);#endif    return tmps; err:    if (tmps != s)        ASN1_STRING_free(tmps);    return NULL;}

static int set_altname(X509 *crt, ...)	{	int ret = 0;	GENERAL_NAMES *gens = NULL;	GENERAL_NAME *gen = NULL;	ASN1_IA5STRING *ia5 = NULL;	va_list ap;	va_start(ap, crt);	gens = sk_GENERAL_NAME_new_null();	if (gens == NULL)		goto out;	while (1) {		int type;		const char *name;		type = va_arg(ap, int);		if (type == 0)			break;		name = va_arg(ap, const char *);		gen = GENERAL_NAME_new();		if (gen == NULL)			goto out;		ia5 = ASN1_IA5STRING_new();		if (ia5 == NULL)			goto out;		if (!ASN1_STRING_set(ia5, name, -1))			goto out;		switch (type)			{			case GEN_EMAIL:			case GEN_DNS:				GENERAL_NAME_set0_value(gen, type, ia5);				ia5 = NULL;				break;			default:				abort();			}		sk_GENERAL_NAME_push(gens, gen);		gen = NULL;	}	if (!X509_add1_ext_i2d(crt, NID_subject_alt_name, gens, 0, 0))		goto out;	ret = 1; out:	ASN1_IA5STRING_free(ia5);	GENERAL_NAME_free(gen);	GENERAL_NAMES_free(gens);	va_end(ap);	return ret;	}

/* * call-seq: *    spki.challenge = str => string * * === Parameters * * +str+ - the challenge string to be set for this instance * * Sets the challenge to be associated with the SPKI. May be used by the * server, e.g. to prevent replay. */static VALUEossl_spki_set_challenge(VALUE self, VALUE str){    NETSCAPE_SPKI *spki;    StringValue(str);    GetSPKI(self, spki);    if (!ASN1_STRING_set(spki->spkac->challenge, RSTRING_PTR(str),			 RSTRING_LENINT(str))) {	ossl_raise(eSPKIError, NULL);    }    return str;}

intASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len){	ASN1_STRING *os;	if ((os = M_ASN1_OCTET_STRING_new()) == NULL)		return (0);	if (!ASN1_STRING_set(os, data, len)) {		M_ASN1_OCTET_STRING_free(os);		return (0);	}	ASN1_TYPE_set(a, V_ASN1_OCTET_STRING, os);	return (1);}

static ASN1_OCTET_STRING *s2i_skey_id(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *str){	ASN1_OCTET_STRING *oct;	ASN1_BIT_STRING *pk;	unsigned char pkey_dig[EVP_MAX_MD_SIZE];	unsigned int diglen;	if (strcmp(str, "hash"))		return s2i_ASN1_OCTET_STRING(method, ctx, str);	if (!(oct = ASN1_OCTET_STRING_new())) {		X509V3error(ERR_R_MALLOC_FAILURE);		return NULL;	}	if (ctx && (ctx->flags == CTX_TEST))		return oct;	if (!ctx || (!ctx->subject_req && !ctx->subject_cert)) {		X509V3error(X509V3_R_NO_PUBLIC_KEY);		goto err;	}	if (ctx->subject_req)		pk = ctx->subject_req->req_info->pubkey->public_key;	else		pk = ctx->subject_cert->cert_info->key->public_key;	if (!pk) {		X509V3error(X509V3_R_NO_PUBLIC_KEY);		goto err;	}	if (!EVP_Digest(pk->data, pk->length, pkey_dig, &diglen,	    EVP_sha1(), NULL))		goto err;	if (!ASN1_STRING_set(oct, pkey_dig, diglen)) {		X509V3error(ERR_R_MALLOC_FAILURE);		goto err;	}	return oct;err:	ASN1_OCTET_STRING_free(oct);	return NULL;}

int X509_alias_set1(X509 *x, unsigned char *name, int len){	X509_CERT_AUX *aux;	if (!name)		{		if (!x || !x->aux || !x->aux->alias)			return 1;		ASN1_UTF8STRING_free(x->aux->alias);		x->aux->alias = NULL;		return 1;		}	if(!(aux = aux_get(x))) return 0;	if(!aux->alias && !(aux->alias = ASN1_UTF8STRING_new())) return 0;	return ASN1_STRING_set(aux->alias, name, len);}

int X509_keyid_set1(X509 *x, unsigned char *id, int len){	X509_CERT_AUX *aux;	if (!id)		{		if (!x || !x->aux || !x->aux->keyid)			return 1;		ASN1_OCTET_STRING_free(x->aux->keyid);		x->aux->keyid = NULL;		return 1;		}	if(!(aux = aux_get(x))) return 0;	if(!aux->keyid && !(aux->keyid = ASN1_OCTET_STRING_new())) return 0;	return ASN1_STRING_set(aux->keyid, id, len);}

/* Convert an ASN1_TIME structure to GeneralizedTime */static ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime_internal(ASN1_TIME *t, ASN1_GENERALIZEDTIME **out){	ASN1_GENERALIZEDTIME *ret;	char *str;	int newlen;	int i;	if (!ASN1_TIME_check(t))		return NULL;	ret = *out;	/* If already GeneralizedTime just copy across */	if (t->type == V_ASN1_GENERALIZEDTIME) {		if (!ASN1_STRING_set(ret, t->data, t->length))			return NULL;		return ret;	}	/* grow the string */	if (!ASN1_STRING_set(ret, NULL, t->length + 2))		return NULL;	/* ASN1_STRING_set() allocated 'len + 1' bytes. */	newlen = t->length + 2 + 1;	str = (char *)ret->data;	/* XXX ASN1_TIME is not Y2050 compatible */	i = snprintf(str, newlen, "%s%s", (t->data[0] >= '5') ? "19" : "20",	    (char *) t->data);	if (i == -1 || i >= newlen) {		M_ASN1_GENERALIZEDTIME_free(ret);		*out = NULL;		return NULL;	}	return ret;}

intPKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,    const unsigned char *salt, int saltlen){	PBEPARAM *pbe = NULL;	ASN1_STRING *pbe_str = NULL;	unsigned char *sstr;	pbe = PBEPARAM_new();	if (!pbe) {		ASN1error(ERR_R_MALLOC_FAILURE);		goto err;	}	if (iter <= 0)		iter = PKCS5_DEFAULT_ITER;	if (!ASN1_INTEGER_set(pbe->iter, iter)) {		ASN1error(ERR_R_MALLOC_FAILURE);		goto err;	}	if (!saltlen)		saltlen = PKCS5_SALT_LEN;	if (!ASN1_STRING_set(pbe->salt, NULL, saltlen)) {		ASN1error(ERR_R_MALLOC_FAILURE);		goto err;	}	sstr = ASN1_STRING_data(pbe->salt);	if (salt)		memcpy(sstr, salt, saltlen);	else		arc4random_buf(sstr, saltlen);	if (!ASN1_item_pack(pbe, &PBEPARAM_it, &pbe_str)) {		ASN1error(ERR_R_MALLOC_FAILURE);		goto err;	}	PBEPARAM_free(pbe);	pbe = NULL;	if (X509_ALGOR_set0(algor, OBJ_nid2obj(alg), V_ASN1_SEQUENCE, pbe_str))		return 1;err:	if (pbe != NULL)		PBEPARAM_free(pbe);	ASN1_STRING_free(pbe_str);	return 0;}

ASN1_TIME* DateTime::getUTCTime() const throw(BigIntegerException){	ASN1_TIME *ret;	DateVal date;	stringstream stream;	string tmp;	string utc;		date = DateTime::getDate(this->seconds);		stream.setf(ios_base::right);	stream.fill('0');		stream.width(2); //define um tamanho minimo de 2 chars	stream << date.year;	stream >> tmp;		//pega apenas os dois numeros mais a direita	if(tmp.size() > 2)	{		tmp = tmp.substr(tmp.size() - 2);	}	stream.clear();	stream.str("");		stream << tmp;	stream.width(2);	stream << (date.mon + 1);		stream.width(2);	stream << date.dayOfMonth;	stream.width(2);	stream << date.hour;	stream.width(2);	stream << date.min;	stream.width(2);	stream << date.sec;	stream.width(1);	stream << "Z";	utc = stream.str();		ret = M_ASN1_UTCTIME_new();		//pode retornar 1 no caso de falha de alocacao de memoria	ASN1_STRING_set(ret, utc.c_str(), utc.size());	return ret;}

int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str){    ASN1_UTCTIME t;    t.type = V_ASN1_UTCTIME;    t.length = strlen(str);    t.data = (unsigned char *)str;    if (ASN1_UTCTIME_check(&t)) {        if (s != NULL) {            if (!ASN1_STRING_set((ASN1_STRING *)s, str, t.length))                return 0;            s->type = V_ASN1_UTCTIME;        }        return (1);    } else        return (0);}

int cms_DigestedData_do_final(CMS_ContentInfo *cms, BIO *chain, int verify)	{	EVP_MD_CTX mctx;	unsigned char md[EVP_MAX_MD_SIZE];	unsigned int mdlen;	int r = 0;	CMS_DigestedData *dd;	EVP_MD_CTX_init(&mctx);	dd = cms->d.digestedData;	if (!cms_DigestAlgorithm_find_ctx(&mctx, chain, dd->digestAlgorithm))		goto err;	if (EVP_DigestFinal_ex(&mctx, md, &mdlen) <= 0)		goto err;	if (verify)		{		if (mdlen != (unsigned int)dd->digest->length)			{			CMSerr(CMS_F_CMS_DIGESTEDDATA_DO_FINAL,				CMS_R_MESSAGEDIGEST_WRONG_LENGTH);			goto err;			}		if (TINYCLR_SSL_MEMCMP(md, dd->digest->data, mdlen))			CMSerr(CMS_F_CMS_DIGESTEDDATA_DO_FINAL,				CMS_R_VERIFICATION_FAILURE);		else			r = 1;		}	else		{		if (!ASN1_STRING_set(dd->digest, md, mdlen))			goto err;		r = 1;		}	err:	EVP_MD_CTX_cleanup(&mctx);	return r;	}

int GTPublicationsFile_getKeyHashByIndex(		const GTPublicationsFile *publications_file,		unsigned int key_hash_index, char **key_hash){	int res = GT_UNKNOWN_ERROR;	GTPublicationsFile_KeyHashCell *cell;	GTPublishedData *published_data = NULL;	if (publications_file == NULL ||			key_hash_index >= publications_file->number_of_key_hashes ||			key_hash == NULL) {		res = GT_INVALID_ARGUMENT;		goto cleanup;	}	cell = publications_file->key_hash_cells + key_hash_index;	published_data = GTPublishedData_new();	if (published_data == NULL) {		res = GT_OUT_OF_MEMORY;		goto cleanup;	}	if (!GT_uint64ToASN1Integer(				published_data->publicationIdentifier,				cell->key_publication_time)) {		res = GT_OUT_OF_MEMORY;		goto cleanup;	}	if (!ASN1_STRING_set(				published_data->publicationImprint,				publications_file->data + cell->key_hash_imprint_offset,				cell->key_hash_imprint_size)) {		res = GT_OUT_OF_MEMORY;		goto cleanup;	}	res = GT_publishedDataToBase32(published_data, key_hash);cleanup:	GTPublishedData_free(published_data);	return res;}

void *targets_s2i(UNUSED(struct v3_ext_method *method), UNUSED(struct v3_ext_ctx *ctx), char *data){  char *pos;  char *list = strdup(data);  char *back = list;  AC_TARGETS *a = AC_TARGETS_new();  int attlist;  do {    pos = strchr(list, ',');    if (pos)      *pos = '/0';    {      GENERAL_NAME *g = GENERAL_NAME_new();      ASN1_IA5STRING *tmpr = ASN1_IA5STRING_new();      AC_TARGET *targ = AC_TARGET_new();      if (!g || !tmpr || !targ) {        GENERAL_NAME_free(g);        ASN1_IA5STRING_free(tmpr);        AC_TARGET_free(targ);        goto err;      }      ASN1_STRING_set(tmpr, list, strlen(list));      g->type = GEN_URI;      g->d.ia5 = tmpr;      targ->name = g;      sk_AC_TARGET_push(a->targets, targ);      attlist++;    }    if (pos)      list = ++pos;  } while (pos);  free(back);  return a; err:  free(back);  AC_TARGETS_free(a);  return NULL;    }

static int cellToPublishedData(		const GTPublicationsFile *publications_file,		const GTPublicationsFile_Cell *cell,		GTPublishedData **published_data){	int retval = GT_UNKNOWN_ERROR;	GTPublishedData *tmp_published_data = NULL;	assert(publications_file != NULL);	assert(cell != NULL);	assert(published_data != NULL);	tmp_published_data = GTPublishedData_new();	if (tmp_published_data == NULL) {		retval = GT_OUT_OF_MEMORY;		goto cleanup;	}	if (!GT_uint64ToASN1Integer(				tmp_published_data->publicationIdentifier,				cell->publication_identifier)) {		retval = GT_OUT_OF_MEMORY;		goto cleanup;	}	if (!ASN1_STRING_set(				tmp_published_data->publicationImprint,				publications_file->data + cell->publication_imprint_offset,				cell->publication_imprint_size)) {		retval = GT_OUT_OF_MEMORY;		goto cleanup;	}	*published_data = tmp_published_data;	tmp_published_data = NULL;	retval = GT_OK;cleanup:	GTPublishedData_free(tmp_published_data);	return retval;}

static ASN1_IA5STRING *s2i_ASN1_IA5STRING(X509V3_EXT_METHOD *method,	     X509V3_CTX *ctx, char *str){	ASN1_IA5STRING *ia5;	if(!str) {		OPENSSL_PUT_ERROR(X509V3, s2i_ASN1_IA5STRING, X509V3_R_INVALID_NULL_ARGUMENT);		return NULL;	}	if(!(ia5 = M_ASN1_IA5STRING_new())) goto err;	if(!ASN1_STRING_set((ASN1_STRING *)ia5, (unsigned char*)str,			    strlen(str))) {		M_ASN1_IA5STRING_free(ia5);		goto err;	}	return ia5;	err:	OPENSSL_PUT_ERROR(X509V3, s2i_ASN1_IA5STRING, ERR_R_MALLOC_FAILURE);	return NULL;}

intASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, unsigned char *data,    int len){	int n, size;	ASN1_OCTET_STRING os, *osp;	ASN1_INTEGER in;	unsigned char *p;	unsigned char buf[32]; /* when they have 256bit longs,				* I'll be in trouble */	in.data = buf;	in.length = 32;	os.data = data;	os.type = V_ASN1_OCTET_STRING;	os.length = len;	ASN1_INTEGER_set(&in, num);	n = i2d_ASN1_INTEGER(&in, NULL);	n += M_i2d_ASN1_OCTET_STRING(&os, NULL);	size = ASN1_object_size(1, n, V_ASN1_SEQUENCE);	if ((osp = ASN1_STRING_new()) == NULL)		return (0);	/* Grow the 'string' */	if (!ASN1_STRING_set(osp, NULL, size)) {		ASN1_STRING_free(osp);		return (0);	}	M_ASN1_STRING_length_set(osp, size);	p = M_ASN1_STRING_data(osp);	ASN1_put_object(&p, 1,n, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL);	i2d_ASN1_INTEGER(&in, &p);	M_i2d_ASN1_OCTET_STRING(&os, &p);	ASN1_TYPE_set(a, V_ASN1_SEQUENCE, osp);	return (1);}

static ASN1_IA5STRING *s2i_ASN1_IA5STRING(X509V3_EXT_METHOD *method,	     X509V3_CTX *ctx, char *str){	ASN1_IA5STRING *ia5;	if(!str) {		X509V3err(X509V3_F_S2I_ASN1_IA5STRING,X509V3_R_INVALID_NULL_ARGUMENT);		return NULL;	}	if(!(ia5 = M_ASN1_IA5STRING_new())) goto err;	if(!ASN1_STRING_set((ASN1_STRING *)ia5, (unsigned char*)str,			    strlen(str))) {		M_ASN1_IA5STRING_free(ia5);		goto err;	}#ifdef CHARSET_EBCDIC        ebcdic2ascii(ia5->data, ia5->data, ia5->length);#endif /*CHARSET_EBCDIC*/	return ia5;	err:	X509V3err(X509V3_F_S2I_ASN1_IA5STRING,ERR_R_MALLOC_FAILURE);	return NULL;}