int TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, ASN1_OBJECT *def_policy)
{
if (ctx->default_policy)
ASN1_OBJECT_free(ctx->default_policy);
if (!(ctx->default_policy = OBJ_dup(def_policy)))
goto err;
return 1;
err:
TSerr(TS_F_TS_RESP_CTX_SET_DEF_POLICY, ERR_R_MALLOC_FAILURE);
return 0;
}
int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, ASN1_OBJECT *obj)
{
if ((ne == NULL) || (obj == NULL))
{
X509err(X509_F_X509_NAME_ENTRY_SET_OBJECT,ERR_R_PASSED_NULL_PARAMETER);
return(0);
}
ASN1_OBJECT_free(ne->object);
ne->object=OBJ_dup(obj);
return((ne->object == NULL)?0:1);
}
X509_POLICY_DATA *policy_data_new(POLICYINFO *policy,
const ASN1_OBJECT *cid, int crit)
{
X509_POLICY_DATA *ret;
ASN1_OBJECT *id;
if (!policy && !cid)
return NULL;
if (cid)
{
id = OBJ_dup(cid);
if (!id)
return NULL;
}
else
id = NULL;
ret = (X509_POLICY_DATA *)OPENSSL_malloc(sizeof(X509_POLICY_DATA));
if (!ret)
{
if (id)
ASN1_OBJECT_free(id);
return NULL;
}
ret->expected_policy_set = sk_ASN1_OBJECT_new_null();
if (!ret->expected_policy_set)
{
OPENSSL_free(ret);
if (id)
ASN1_OBJECT_free(id);
return NULL;
}
if (crit)
ret->flags = POLICY_DATA_FLAG_CRITICAL;
else
ret->flags = 0;
if (id)
ret->valid_policy = id;
else
{
ret->valid_policy = policy->policyid;
policy->policyid = NULL;
}
if (policy)
{
ret->qualifier_set = policy->qualifiers;
policy->qualifiers = NULL;
}
else
ret->qualifier_set = NULL;
return ret;
}
/**
* @ingroup proxypolicy
*
* Sets the policy language of the PROXYPOLICY
*
* @param policy the PROXYPOLICY to set the policy language of
* @param policy_language the policy language to set it to
*
* @return 1 on success, 0 on error
*/
int PROXYPOLICY_set_policy_language(
PROXYPOLICY * policy,
ASN1_OBJECT * policy_language)
{
if(policy_language != NULL)
{
ASN1_OBJECT_free(policy->policy_language);
policy->policy_language = OBJ_dup(policy_language);
return 1;
}
return 0;
}
TS_VERIFY_CTX *
TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx)
{
TS_VERIFY_CTX *ret = ctx;
ASN1_OBJECT *policy;
TS_MSG_IMPRINT *imprint;
X509_ALGOR *md_alg;
ASN1_OCTET_STRING *msg;
const ASN1_INTEGER *nonce;
OPENSSL_assert(req != NULL);
if (ret)
TS_VERIFY_CTX_cleanup(ret);
else if (!(ret = TS_VERIFY_CTX_new()))
return NULL;
/* Setting flags. */
ret->flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE);
/* Setting policy. */
if ((policy = TS_REQ_get_policy_id(req)) != NULL) {
if (!(ret->policy = OBJ_dup(policy)))
goto err;
} else
ret->flags &= ~TS_VFY_POLICY;
/* Setting md_alg, imprint and imprint_len. */
imprint = TS_REQ_get_msg_imprint(req);
md_alg = TS_MSG_IMPRINT_get_algo(imprint);
if (!(ret->md_alg = X509_ALGOR_dup(md_alg)))
goto err;
msg = TS_MSG_IMPRINT_get_msg(imprint);
ret->imprint_len = ASN1_STRING_length(msg);
if (!(ret->imprint = malloc(ret->imprint_len)))
goto err;
memcpy(ret->imprint, ASN1_STRING_data(msg), ret->imprint_len);
/* Setting nonce. */
if ((nonce = TS_REQ_get_nonce(req)) != NULL) {
if (!(ret->nonce = ASN1_INTEGER_dup(nonce)))
goto err;
} else
ret->flags &= ~TS_VFY_NONCE;
return ret;
err:
if (ctx)
TS_VERIFY_CTX_cleanup(ctx);
else
TS_VERIFY_CTX_free(ret);
return NULL;
}
static int openssl_xalgor_set(lua_State* L)
{
int ret = 0;
X509_ALGOR* alg = CHECK_OBJECT(1, X509_ALGOR, "openssl.x509_algor");
ASN1_OBJECT* obj = CHECK_OBJECT(2, ASN1_OBJECT, "openssl.asn1_object");
ASN1_STRING* val = lua_isnoneornil(L, 3) ?
NULL : auxiliar_checkgroup(L, "openssl.asn1_group", 3);
obj = OBJ_dup(obj);
val = ASN1_STRING_dup(val);
ret = X509_ALGOR_set0(alg, obj , val->type, val);
return openssl_pushresult(L, ret);
}
int X509_add1_trust_object(X509 *x, ASN1_OBJECT *obj)
{
X509_CERT_AUX *aux;
ASN1_OBJECT *objtmp;
if (!(objtmp = OBJ_dup(obj)))
return 0;
if (!(aux = aux_get(x)))
return 0;
if (!aux->trust && !(aux->trust = sk_ASN1_OBJECT_new_null()))
return 0;
return sk_ASN1_OBJECT_push(aux->trust, objtmp);
}
X509_EXTENSION* Extension::getX509Extension()
{
X509_EXTENSION *ret;
ByteArray data;
ret = X509_EXTENSION_new();
ret->object = OBJ_dup(this->objectIdentifier.getObjectIdentifier());
ret->critical = this->critical?1:0;
ret->value = ASN1_OCTET_STRING_new();
data = this->value;
ASN1_OCTET_STRING_set(ret->value, data.getDataPointer(), this->value.size());
return ret;
}
ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
const char *sn, const char *ln)
{
ASN1_OBJECT o;
o.sn=sn;
o.ln=ln;
o.data=data;
o.nid=nid;
o.length=len;
o.flags=ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
ASN1_OBJECT_FLAG_DYNAMIC_DATA;
return(OBJ_dup(&o));
}
int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid)
{
ASN1_OBJECT **petype, *etype;
petype = cms_get0_econtent_type(cms);
if (!petype)
return 0;
if (!oid)
return 1;
etype = OBJ_dup(oid);
if (!etype)
return 0;
ASN1_OBJECT_free(*petype);
*petype = etype;
return 1;
}
int X509_add1_reject_object(X509 *x, ASN1_OBJECT *obj)
{
X509_CERT_AUX *aux;
ASN1_OBJECT *objtmp;
if (!(objtmp = OBJ_dup(obj)))
return 0;
if (!(aux = aux_get(x)))
goto err;
if (!aux->reject && !(aux->reject = sk_ASN1_OBJECT_new_null()))
goto err;
return sk_ASN1_OBJECT_push(aux->reject, objtmp);
err:
ASN1_OBJECT_free(objtmp);
return 0;
}
int TS_REQ_set_policy_id(TS_REQ *a, ASN1_OBJECT *policy)
{
ASN1_OBJECT *new_policy;
if (a->policy_id == policy)
return 1;
new_policy = OBJ_dup(policy);
if (new_policy == NULL) {
TSerr(TS_F_TS_REQ_SET_POLICY_ID, ERR_R_MALLOC_FAILURE);
return 0;
}
ASN1_OBJECT_free(a->policy_id);
a->policy_id = new_policy;
return 1;
}
int
TS_REQ_set_policy_id(TS_REQ *a, const ASN1_OBJECT *policy)
{
ASN1_OBJECT *new_policy;
if (a->policy_id == policy)
return 1;
new_policy = OBJ_dup(policy);
if (new_policy == NULL) {
TSerror(ERR_R_MALLOC_FAILURE);
return 0;
}
ASN1_OBJECT_free(a->policy_id);
a->policy_id = new_policy;
return 1;
}
static int openssl_xalgor_get(lua_State* L) {
int type;
void* val;
ASN1_OBJECT *obj;
X509_ALGOR* alg = CHECK_OBJECT(1, X509_ALGOR, "openssl.x509_algor");
X509_ALGOR_get0(&obj, &type, &val, alg);
if (obj != NULL)
PUSH_OBJECT(OBJ_dup(obj), "openssl.asn1_object");
else
lua_pushnil(L);
if (type == V_ASN1_UNDEF)
lua_pushnil(L);
else
PUSH_OBJECT(ASN1_STRING_dup(val), "openssl.asn1_string");
return 2;
}
static int openssl_xname_delete_entry(lua_State*L)
{
X509_NAME* xn = CHECK_OBJECT(1, X509_NAME, "openssl.x509_name");
int loc = luaL_checkint(L, 2);
X509_NAME_ENTRY *xe = X509_NAME_delete_entry(xn,loc);
if(xe)
{
ASN1_OBJECT *obj = OBJ_dup(xe->object);
ASN1_STRING *as = ASN1_STRING_dup(xe->value);
PUSH_OBJECT(obj,"openssl.asn1_object");
PUSH_OBJECT(as,"openssl.asn1_string");
X509_NAME_ENTRY_free(xe);
return 2;
}else
lua_pushnil(L);
return 1;
};
int X509_add1_reject_object(X509 *x, ASN1_OBJECT *obj)
{
ASN1_OBJECT *objtmp = OBJ_dup(obj);
if (objtmp == NULL)
goto err;
X509_CERT_AUX *aux = aux_get(x);
if (aux->reject == NULL) {
aux->reject = sk_ASN1_OBJECT_new_null();
if (aux->reject == NULL)
goto err;
}
if (!sk_ASN1_OBJECT_push(aux->reject, objtmp))
goto err;
return 1;
err:
ASN1_OBJECT_free(objtmp);
return 0;
}
int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value)
{
if (!value || (type == V_ASN1_BOOLEAN)) {
void *p = (void *)value;
ASN1_TYPE_set(a, type, p);
} else if (type == V_ASN1_OBJECT) {
ASN1_OBJECT *odup;
odup = OBJ_dup(value);
if (!odup)
return 0;
ASN1_TYPE_set(a, type, odup);
} else {
ASN1_STRING *sdup;
sdup = ASN1_STRING_dup(value);
if (!sdup)
return 0;
ASN1_TYPE_set(a, type, sdup);
}
return 1;
}
int X509_add1_trust_object(X509 *x, ASN1_OBJECT *obj)
{
X509_CERT_AUX *aux;
ASN1_OBJECT *objtmp = NULL;
if (obj) {
objtmp = OBJ_dup(obj);
if (!objtmp)
return 0;
}
if ((aux = aux_get(x)) == NULL)
goto err;
if (aux->trust == NULL
&& (aux->trust = sk_ASN1_OBJECT_new_null()) == NULL)
goto err;
if (!objtmp || sk_ASN1_OBJECT_push(aux->trust, objtmp))
return 1;
err:
ASN1_OBJECT_free(objtmp);
return 0;
}
static int openssl_xext_object(lua_State* L)
{
X509_EXTENSION *x = CHECK_OBJECT(1, X509_EXTENSION, "openssl.x509_extension");
ASN1_OBJECT* obj;
if (lua_isnone(L, 2))
{
obj = X509_EXTENSION_get_object(x);
obj = OBJ_dup(obj);
PUSH_OBJECT(obj, "openssl.asn1_object");
return 1;
}
else
{
int nid = openssl_get_nid(L, 2);
int ret;
obj = OBJ_nid2obj(nid);
ret = X509_EXTENSION_set_object(x, obj);
return openssl_pushresult(L, ret);
}
};
int OBJ_add_object(const ASN1_OBJECT *obj)
{
ASN1_OBJECT *o;
ADDED_OBJ *ao[4]={NULL,NULL,NULL,NULL},*aop;
int i;
if (added == NULL)
if (!init_added()) return(0);
if ((o=OBJ_dup(obj)) == NULL) goto err;
if (!(ao[ADDED_NID]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
if ((o->length != 0) && (obj->data != NULL))
if (!(ao[ADDED_DATA]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
if (o->sn != NULL)
if (!(ao[ADDED_SNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
if (o->ln != NULL)
if (!(ao[ADDED_LNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
for (i=ADDED_DATA; i<=ADDED_NID; i++)
{
if (ao[i] != NULL)
{
ao[i]->type=i;
ao[i]->obj=o;
aop=(ADDED_OBJ *)lh_insert(added,ao[i]);
/* memory leak, buit should not normally matter */
if (aop != NULL)
OPENSSL_free(aop);
}
}
o->flags&= ~(ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
ASN1_OBJECT_FLAG_DYNAMIC_DATA);
return(o->nid);
err2:
OBJerr(OBJ_F_OBJ_ADD_OBJECT,ERR_R_MALLOC_FAILURE);
err:
for (i=ADDED_DATA; i<=ADDED_NID; i++)
if (ao[i] != NULL) OPENSSL_free(ao[i]);
if (o != NULL) OPENSSL_free(o);
return(NID_undef);
}
static int openssl_xattr_object(lua_State*L)
{
X509_ATTRIBUTE* attr = CHECK_OBJECT(1, X509_ATTRIBUTE, "openssl.x509_attribute");
if (lua_isnone(L, 2))
{
ASN1_OBJECT* obj = X509_ATTRIBUTE_get0_object(attr);
obj = OBJ_dup(obj);
PUSH_OBJECT(obj, "openssl.asn1_object");
return 1;
}
else
{
int nid = openssl_get_nid(L, 2);
ASN1_OBJECT* obj;
int ret;
luaL_argcheck(L, nid != NID_undef, 2, "invalid asn1_object identity");
obj = OBJ_nid2obj(nid);
ret = X509_ATTRIBUTE_set1_object(attr, obj);
return openssl_pushresult(L, ret);
}
}
int
X509_add1_trust_object(X509 *x, ASN1_OBJECT *obj)
{
X509_CERT_AUX *aux;
ASN1_OBJECT *objtmp;
int rc;
if (!(objtmp = OBJ_dup(obj)))
return 0;
if (!(aux = aux_get(x)))
goto err;
if (!aux->trust && !(aux->trust = sk_ASN1_OBJECT_new_null()))
goto err;
rc = sk_ASN1_OBJECT_push(aux->trust, objtmp);
if (rc != 0)
return rc;
err:
ASN1_OBJECT_free(objtmp);
return 0;
}
