Home | History | Annotate | Download | only in x509
      1 /* crypto/x509/x509_att.c */
      2 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com)
      3  * All rights reserved.
      4  *
      5  * This package is an SSL implementation written
      6  * by Eric Young (eay (at) cryptsoft.com).
      7  * The implementation was written so as to conform with Netscapes SSL.
      8  *
      9  * This library is free for commercial and non-commercial use as long as
     10  * the following conditions are aheared to.  The following conditions
     11  * apply to all code found in this distribution, be it the RC4, RSA,
     12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
     13  * included with this distribution is covered by the same copyright terms
     14  * except that the holder is Tim Hudson (tjh (at) cryptsoft.com).
     15  *
     16  * Copyright remains Eric Young's, and as such any Copyright notices in
     17  * the code are not to be removed.
     18  * If this package is used in a product, Eric Young should be given attribution
     19  * as the author of the parts of the library used.
     20  * This can be in the form of a textual message at program startup or
     21  * in documentation (online or textual) provided with the package.
     22  *
     23  * Redistribution and use in source and binary forms, with or without
     24  * modification, are permitted provided that the following conditions
     25  * are met:
     26  * 1. Redistributions of source code must retain the copyright
     27  *    notice, this list of conditions and the following disclaimer.
     28  * 2. Redistributions in binary form must reproduce the above copyright
     29  *    notice, this list of conditions and the following disclaimer in the
     30  *    documentation and/or other materials provided with the distribution.
     31  * 3. All advertising materials mentioning features or use of this software
     32  *    must display the following acknowledgement:
     33  *    "This product includes cryptographic software written by
     34  *     Eric Young (eay (at) cryptsoft.com)"
     35  *    The word 'cryptographic' can be left out if the rouines from the library
     36  *    being used are not cryptographic related :-).
     37  * 4. If you include any Windows specific code (or a derivative thereof) from
     38  *    the apps directory (application code) you must include an acknowledgement:
     39  *    "This product includes software written by Tim Hudson (tjh (at) cryptsoft.com)"
     40  *
     41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
     42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     51  * SUCH DAMAGE.
     52  *
     53  * The licence and distribution terms for any publically available version or
     54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
     55  * copied and put under another distribution licence
     56  * [including the GNU Public Licence.] */
     57 
     58 #include <openssl/asn1.h>
     59 #include <openssl/err.h>
     60 #include <openssl/evp.h>
     61 #include <openssl/obj.h>
     62 #include <openssl/stack.h>
     63 #include <openssl/x509.h>
     64 
     65 
     66 int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
     67 {
     68 	return sk_X509_ATTRIBUTE_num(x);
     69 }
     70 
     71 int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
     72 			  int lastpos)
     73 {
     74 	const ASN1_OBJECT *obj;
     75 
     76 	obj=OBJ_nid2obj(nid);
     77 	if (obj == NULL) return(-2);
     78 	return(X509at_get_attr_by_OBJ(x,obj,lastpos));
     79 }
     80 
     81 int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, const ASN1_OBJECT *obj,
     82 			  int lastpos)
     83 {
     84 	int n;
     85 	X509_ATTRIBUTE *ex;
     86 
     87 	if (sk == NULL) return(-1);
     88 	lastpos++;
     89 	if (lastpos < 0)
     90 		lastpos=0;
     91 	n=sk_X509_ATTRIBUTE_num(sk);
     92 	for ( ; lastpos < n; lastpos++)
     93 		{
     94 		ex=sk_X509_ATTRIBUTE_value(sk,lastpos);
     95 		if (OBJ_cmp(ex->object,obj) == 0)
     96 			return(lastpos);
     97 		}
     98 	return(-1);
     99 }
    100 
    101 X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
    102 {
    103 	if (x == NULL || loc < 0 || sk_X509_ATTRIBUTE_num(x) <= (size_t) loc)
    104 		return NULL;
    105 	else
    106 		return sk_X509_ATTRIBUTE_value(x,loc);
    107 }
    108 
    109 X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
    110 {
    111 	X509_ATTRIBUTE *ret;
    112 
    113 	if (x == NULL || loc < 0 || sk_X509_ATTRIBUTE_num(x) <= (size_t) loc)
    114 		return(NULL);
    115 	ret=sk_X509_ATTRIBUTE_delete(x,loc);
    116 	return(ret);
    117 }
    118 
    119 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
    120 					 X509_ATTRIBUTE *attr)
    121 {
    122 	X509_ATTRIBUTE *new_attr=NULL;
    123 	STACK_OF(X509_ATTRIBUTE) *sk=NULL;
    124 
    125 	if (x == NULL)
    126 		{
    127 		OPENSSL_PUT_ERROR(X509, ERR_R_PASSED_NULL_PARAMETER);
    128 		goto err2;
    129 		}
    130 
    131 	if (*x == NULL)
    132 		{
    133 		if ((sk=sk_X509_ATTRIBUTE_new_null()) == NULL)
    134 			goto err;
    135 		}
    136 	else
    137 		sk= *x;
    138 
    139 	if ((new_attr=X509_ATTRIBUTE_dup(attr)) == NULL)
    140 		goto err2;
    141 	if (!sk_X509_ATTRIBUTE_push(sk,new_attr))
    142 		goto err;
    143 	if (*x == NULL)
    144 		*x=sk;
    145 	return(sk);
    146 err:
    147 	OPENSSL_PUT_ERROR(X509, ERR_R_MALLOC_FAILURE);
    148 err2:
    149 	if (new_attr != NULL) X509_ATTRIBUTE_free(new_attr);
    150 	if (sk != NULL) sk_X509_ATTRIBUTE_free(sk);
    151 	return(NULL);
    152 }
    153 
    154 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x,
    155 			const ASN1_OBJECT *obj, int type,
    156 			const unsigned char *bytes, int len)
    157 {
    158 	X509_ATTRIBUTE *attr;
    159 	STACK_OF(X509_ATTRIBUTE) *ret;
    160 	attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len);
    161 	if(!attr) return 0;
    162 	ret = X509at_add1_attr(x, attr);
    163 	X509_ATTRIBUTE_free(attr);
    164 	return ret;
    165 }
    166 
    167 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x,
    168 			int nid, int type,
    169 			const unsigned char *bytes, int len)
    170 {
    171 	X509_ATTRIBUTE *attr;
    172 	STACK_OF(X509_ATTRIBUTE) *ret;
    173 	attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len);
    174 	if(!attr) return 0;
    175 	ret = X509at_add1_attr(x, attr);
    176 	X509_ATTRIBUTE_free(attr);
    177 	return ret;
    178 }
    179 
    180 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x,
    181 			const char *attrname, int type,
    182 			const unsigned char *bytes, int len)
    183 {
    184 	X509_ATTRIBUTE *attr;
    185 	STACK_OF(X509_ATTRIBUTE) *ret;
    186 	attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len);
    187 	if(!attr) return 0;
    188 	ret = X509at_add1_attr(x, attr);
    189 	X509_ATTRIBUTE_free(attr);
    190 	return ret;
    191 }
    192 
    193 void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x,
    194 				ASN1_OBJECT *obj, int lastpos, int type)
    195 {
    196 	int i;
    197 	X509_ATTRIBUTE *at;
    198 	i = X509at_get_attr_by_OBJ(x, obj, lastpos);
    199 	if (i == -1)
    200 		return NULL;
    201 	if ((lastpos <= -2) && (X509at_get_attr_by_OBJ(x, obj, i) != -1))
    202 		return NULL;
    203 	at = X509at_get_attr(x, i);
    204 	if (lastpos <= -3 && (X509_ATTRIBUTE_count(at) != 1))
    205 		return NULL;
    206 	return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
    207 }
    208 
    209 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
    210 	     int atrtype, const void *data, int len)
    211 {
    212 	const ASN1_OBJECT *obj;
    213 
    214 	obj=OBJ_nid2obj(nid);
    215 	if (obj == NULL)
    216 		{
    217 		OPENSSL_PUT_ERROR(X509, X509_R_UNKNOWN_NID);
    218 		return(NULL);
    219 		}
    220 	return X509_ATTRIBUTE_create_by_OBJ(attr,obj,atrtype,data,len);
    221 }
    222 
    223 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
    224 	     const ASN1_OBJECT *obj, int atrtype, const void *data, int len)
    225 {
    226 	X509_ATTRIBUTE *ret;
    227 
    228 	if ((attr == NULL) || (*attr == NULL))
    229 		{
    230 		if ((ret=X509_ATTRIBUTE_new()) == NULL)
    231 			{
    232 			OPENSSL_PUT_ERROR(X509, ERR_R_MALLOC_FAILURE);
    233 			return(NULL);
    234 			}
    235 		}
    236 	else
    237 		ret= *attr;
    238 
    239 	if (!X509_ATTRIBUTE_set1_object(ret,obj))
    240 		goto err;
    241 	if (!X509_ATTRIBUTE_set1_data(ret,atrtype,data,len))
    242 		goto err;
    243 
    244 	if ((attr != NULL) && (*attr == NULL)) *attr=ret;
    245 	return(ret);
    246 err:
    247 	if ((attr == NULL) || (ret != *attr))
    248 		X509_ATTRIBUTE_free(ret);
    249 	return(NULL);
    250 }
    251 
    252 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
    253 		const char *atrname, int type, const unsigned char *bytes, int len)
    254 	{
    255 	ASN1_OBJECT *obj;
    256 	X509_ATTRIBUTE *nattr;
    257 
    258 	obj=OBJ_txt2obj(atrname, 0);
    259 	if (obj == NULL)
    260 		{
    261 		OPENSSL_PUT_ERROR(X509, X509_R_INVALID_FIELD_NAME);
    262 		ERR_add_error_data(2, "name=", atrname);
    263 		return(NULL);
    264 		}
    265 	nattr = X509_ATTRIBUTE_create_by_OBJ(attr,obj,type,bytes,len);
    266 	ASN1_OBJECT_free(obj);
    267 	return nattr;
    268 	}
    269 
    270 int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
    271 {
    272 	if ((attr == NULL) || (obj == NULL))
    273 		return(0);
    274 	ASN1_OBJECT_free(attr->object);
    275 	attr->object=OBJ_dup(obj);
    276 	return attr->object != NULL;
    277 }
    278 
    279 int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data, int len)
    280 {
    281 	ASN1_TYPE *ttmp;
    282 	ASN1_STRING *stmp = NULL;
    283 	int atype = 0;
    284 	if (!attr) return 0;
    285 	if(attrtype & MBSTRING_FLAG) {
    286 		stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype,
    287 						OBJ_obj2nid(attr->object));
    288 		if(!stmp) {
    289 			OPENSSL_PUT_ERROR(X509, ERR_R_ASN1_LIB);
    290 			return 0;
    291 		}
    292 		atype = stmp->type;
    293 	} else if (len != -1){
    294 		if(!(stmp = ASN1_STRING_type_new(attrtype))) goto err;
    295 		if(!ASN1_STRING_set(stmp, data, len)) goto err;
    296 		atype = attrtype;
    297 	}
    298 	if(!(attr->value.set = sk_ASN1_TYPE_new_null())) goto err;
    299 	attr->single = 0;
    300 	/* This is a bit naughty because the attribute should really have
    301 	 * at least one value but some types use and zero length SET and
    302 	 * require this.
    303 	 */
    304 	if (attrtype == 0)
    305 		return 1;
    306 	if(!(ttmp = ASN1_TYPE_new())) goto err;
    307 	if ((len == -1) && !(attrtype & MBSTRING_FLAG))
    308 		{
    309 		if (!ASN1_TYPE_set1(ttmp, attrtype, data))
    310 			goto err;
    311 		}
    312 	else
    313 		ASN1_TYPE_set(ttmp, atype, stmp);
    314 	if(!sk_ASN1_TYPE_push(attr->value.set, ttmp)) goto err;
    315 	return 1;
    316 	err:
    317 	OPENSSL_PUT_ERROR(X509, ERR_R_MALLOC_FAILURE);
    318 	return 0;
    319 }
    320 
    321 int X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr)
    322 {
    323 	if(!attr->single) return sk_ASN1_TYPE_num(attr->value.set);
    324 	if(attr->value.single) return 1;
    325 	return 0;
    326 }
    327 
    328 ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
    329 {
    330 	if (attr == NULL) return(NULL);
    331 	return(attr->object);
    332 }
    333 
    334 void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx,
    335 					int atrtype, void *data)
    336 {
    337 	ASN1_TYPE *ttmp;
    338 	ttmp = X509_ATTRIBUTE_get0_type(attr, idx);
    339 	if(!ttmp) return NULL;
    340 	if(atrtype != ASN1_TYPE_get(ttmp)){
    341 		OPENSSL_PUT_ERROR(X509, X509_R_WRONG_TYPE);
    342 		return NULL;
    343 	}
    344 	return ttmp->value.ptr;
    345 }
    346 
    347 ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
    348 {
    349 	if (attr == NULL) return(NULL);
    350 	if(idx >= X509_ATTRIBUTE_count(attr)) return NULL;
    351 	if(!attr->single) return sk_ASN1_TYPE_value(attr->value.set, idx);
    352 	else return attr->value.single;
    353 }
    354