Branch data Line data Source code
1 : : /* crypto/x509/x509_att.c */
2 : : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 : : * All rights reserved.
4 : : *
5 : : * This package is an SSL implementation written
6 : : * by Eric Young (eay@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@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@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@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 : :
59 : : #include <stdio.h>
60 : : #include <openssl/stack.h>
61 : : #include "cryptlib.h"
62 : : #include <openssl/asn1.h>
63 : : #include <openssl/objects.h>
64 : : #include <openssl/evp.h>
65 : : #include <openssl/x509.h>
66 : : #include <openssl/x509v3.h>
67 : :
68 : 181 : int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
69 : : {
70 : 181 : return sk_X509_ATTRIBUTE_num(x);
71 : : }
72 : :
73 : 56 : int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
74 : : int lastpos)
75 : : {
76 : : ASN1_OBJECT *obj;
77 : :
78 : 56 : obj=OBJ_nid2obj(nid);
79 [ + - ]: 56 : if (obj == NULL) return(-2);
80 : 56 : return(X509at_get_attr_by_OBJ(x,obj,lastpos));
81 : : }
82 : :
83 : 174 : int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, ASN1_OBJECT *obj,
84 : : int lastpos)
85 : : {
86 : : int n;
87 : : X509_ATTRIBUTE *ex;
88 : :
89 [ + - ]: 174 : if (sk == NULL) return(-1);
90 : 174 : lastpos++;
91 [ + + ]: 174 : if (lastpos < 0)
92 : 59 : lastpos=0;
93 : 174 : n=sk_X509_ATTRIBUTE_num(sk);
94 [ + + ]: 507 : for ( ; lastpos < n; lastpos++)
95 : : {
96 : 393 : ex=sk_X509_ATTRIBUTE_value(sk,lastpos);
97 [ + + ]: 393 : if (OBJ_cmp(ex->object,obj) == 0)
98 : : return(lastpos);
99 : : }
100 : : return(-1);
101 : : }
102 : :
103 : 60 : X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
104 : : {
105 [ + - ][ + - ]: 60 : if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
[ + - ]
106 : : return NULL;
107 : : else
108 : 60 : return sk_X509_ATTRIBUTE_value(x,loc);
109 : : }
110 : :
111 : 0 : X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
112 : : {
113 : : X509_ATTRIBUTE *ret;
114 : :
115 [ # # ][ # # ]: 0 : if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
[ # # ]
116 : : return(NULL);
117 : 0 : ret=sk_X509_ATTRIBUTE_delete(x,loc);
118 : 0 : return(ret);
119 : : }
120 : :
121 : 200 : STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
122 : : X509_ATTRIBUTE *attr)
123 : : {
124 : 200 : X509_ATTRIBUTE *new_attr=NULL;
125 : 200 : STACK_OF(X509_ATTRIBUTE) *sk=NULL;
126 : :
127 [ - + ]: 200 : if (x == NULL)
128 : : {
129 : 0 : X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_PASSED_NULL_PARAMETER);
130 : 0 : goto err2;
131 : : }
132 : :
133 [ - + ]: 200 : if (*x == NULL)
134 : : {
135 [ # # ]: 0 : if ((sk=sk_X509_ATTRIBUTE_new_null()) == NULL)
136 : : goto err;
137 : : }
138 : : else
139 : : sk= *x;
140 : :
141 [ + - ]: 200 : if ((new_attr=X509_ATTRIBUTE_dup(attr)) == NULL)
142 : : goto err2;
143 [ + - ]: 200 : if (!sk_X509_ATTRIBUTE_push(sk,new_attr))
144 : : goto err;
145 [ - + ]: 200 : if (*x == NULL)
146 : 0 : *x=sk;
147 : 200 : return(sk);
148 : : err:
149 : 0 : X509err(X509_F_X509AT_ADD1_ATTR,ERR_R_MALLOC_FAILURE);
150 : : err2:
151 [ # # ]: 0 : if (new_attr != NULL) X509_ATTRIBUTE_free(new_attr);
152 [ # # ]: 0 : if (sk != NULL) sk_X509_ATTRIBUTE_free(sk);
153 : : return(NULL);
154 : : }
155 : :
156 : 0 : STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x,
157 : : const ASN1_OBJECT *obj, int type,
158 : : const unsigned char *bytes, int len)
159 : : {
160 : : X509_ATTRIBUTE *attr;
161 : : STACK_OF(X509_ATTRIBUTE) *ret;
162 : 0 : attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len);
163 [ # # ]: 0 : if(!attr) return 0;
164 : 0 : ret = X509at_add1_attr(x, attr);
165 : 0 : X509_ATTRIBUTE_free(attr);
166 : 0 : return ret;
167 : : }
168 : :
169 : 200 : STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x,
170 : : int nid, int type,
171 : : const unsigned char *bytes, int len)
172 : : {
173 : : X509_ATTRIBUTE *attr;
174 : : STACK_OF(X509_ATTRIBUTE) *ret;
175 : 200 : attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len);
176 [ + - ]: 200 : if(!attr) return 0;
177 : 200 : ret = X509at_add1_attr(x, attr);
178 : 200 : X509_ATTRIBUTE_free(attr);
179 : 200 : return ret;
180 : : }
181 : :
182 : 0 : STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x,
183 : : const char *attrname, int type,
184 : : const unsigned char *bytes, int len)
185 : : {
186 : : X509_ATTRIBUTE *attr;
187 : : STACK_OF(X509_ATTRIBUTE) *ret;
188 : 0 : attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len);
189 [ # # ]: 0 : if(!attr) return 0;
190 : 0 : ret = X509at_add1_attr(x, attr);
191 : 0 : X509_ATTRIBUTE_free(attr);
192 : 0 : return ret;
193 : : }
194 : :
195 : 59 : void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x,
196 : : ASN1_OBJECT *obj, int lastpos, int type)
197 : : {
198 : : int i;
199 : : X509_ATTRIBUTE *at;
200 : 59 : i = X509at_get_attr_by_OBJ(x, obj, lastpos);
201 [ + - ]: 59 : if (i == -1)
202 : : return NULL;
203 [ + - ][ + - ]: 59 : if ((lastpos <= -2) && (X509at_get_attr_by_OBJ(x, obj, i) != -1))
204 : : return NULL;
205 : 59 : at = X509at_get_attr(x, i);
206 [ + - ][ + - ]: 59 : if (lastpos <= -3 && (X509_ATTRIBUTE_count(at) != 1))
207 : : return NULL;
208 : 59 : return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
209 : : }
210 : :
211 : 200 : X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
212 : : int atrtype, const void *data, int len)
213 : : {
214 : : ASN1_OBJECT *obj;
215 : : X509_ATTRIBUTE *ret;
216 : :
217 : 200 : obj=OBJ_nid2obj(nid);
218 [ - + ]: 200 : if (obj == NULL)
219 : : {
220 : 0 : X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_NID,X509_R_UNKNOWN_NID);
221 : 0 : return(NULL);
222 : : }
223 : 200 : ret=X509_ATTRIBUTE_create_by_OBJ(attr,obj,atrtype,data,len);
224 [ - + ]: 200 : if (ret == NULL) ASN1_OBJECT_free(obj);
225 : 200 : return(ret);
226 : : }
227 : :
228 : 200 : X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
229 : : const ASN1_OBJECT *obj, int atrtype, const void *data, int len)
230 : : {
231 : : X509_ATTRIBUTE *ret;
232 : :
233 [ - + ][ # # ]: 200 : if ((attr == NULL) || (*attr == NULL))
234 : : {
235 [ - + ]: 200 : if ((ret=X509_ATTRIBUTE_new()) == NULL)
236 : : {
237 : 0 : X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ,ERR_R_MALLOC_FAILURE);
238 : 0 : return(NULL);
239 : : }
240 : : }
241 : : else
242 : : ret= *attr;
243 : :
244 [ + - ]: 200 : if (!X509_ATTRIBUTE_set1_object(ret,obj))
245 : : goto err;
246 [ + - ]: 200 : if (!X509_ATTRIBUTE_set1_data(ret,atrtype,data,len))
247 : : goto err;
248 : :
249 [ - + ][ # # ]: 200 : if ((attr != NULL) && (*attr == NULL)) *attr=ret;
250 : 200 : return(ret);
251 : : err:
252 [ # # ][ # # ]: 0 : if ((attr == NULL) || (ret != *attr))
253 : 0 : X509_ATTRIBUTE_free(ret);
254 : : return(NULL);
255 : : }
256 : :
257 : 0 : X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
258 : : const char *atrname, int type, const unsigned char *bytes, int len)
259 : : {
260 : : ASN1_OBJECT *obj;
261 : : X509_ATTRIBUTE *nattr;
262 : :
263 : 0 : obj=OBJ_txt2obj(atrname, 0);
264 [ # # ]: 0 : if (obj == NULL)
265 : : {
266 : 0 : X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_TXT,
267 : : X509_R_INVALID_FIELD_NAME);
268 : 0 : ERR_add_error_data(2, "name=", atrname);
269 : 0 : return(NULL);
270 : : }
271 : 0 : nattr = X509_ATTRIBUTE_create_by_OBJ(attr,obj,type,bytes,len);
272 : 0 : ASN1_OBJECT_free(obj);
273 : 0 : return nattr;
274 : : }
275 : :
276 : 200 : int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
277 : : {
278 [ + - ]: 200 : if ((attr == NULL) || (obj == NULL))
279 : : return(0);
280 : 200 : ASN1_OBJECT_free(attr->object);
281 : 200 : attr->object=OBJ_dup(obj);
282 : 200 : return(1);
283 : : }
284 : :
285 : 200 : int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data, int len)
286 : : {
287 : : ASN1_TYPE *ttmp;
288 : 200 : ASN1_STRING *stmp = NULL;
289 : 200 : int atype = 0;
290 [ + - ]: 200 : if (!attr) return 0;
291 [ - + ]: 200 : if(attrtype & MBSTRING_FLAG) {
292 : 0 : stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype,
293 : 0 : OBJ_obj2nid(attr->object));
294 [ # # ]: 0 : if(!stmp) {
295 : 0 : X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_ASN1_LIB);
296 : 0 : return 0;
297 : : }
298 : 0 : atype = stmp->type;
299 [ + + ]: 200 : } else if (len != -1){
300 [ + - ]: 100 : if(!(stmp = ASN1_STRING_type_new(attrtype))) goto err;
301 [ + - ]: 100 : if(!ASN1_STRING_set(stmp, data, len)) goto err;
302 : : atype = attrtype;
303 : : }
304 [ + - ]: 200 : if(!(attr->value.set = sk_ASN1_TYPE_new_null())) goto err;
305 : 200 : attr->single = 0;
306 : : /* This is a bit naughty because the attribute should really have
307 : : * at least one value but some types use and zero length SET and
308 : : * require this.
309 : : */
310 [ + - ]: 200 : if (attrtype == 0)
311 : : return 1;
312 [ + - ]: 200 : if(!(ttmp = ASN1_TYPE_new())) goto err;
313 [ + + ][ + - ]: 200 : if ((len == -1) && !(attrtype & MBSTRING_FLAG))
314 : : {
315 [ + - ]: 100 : if (!ASN1_TYPE_set1(ttmp, attrtype, data))
316 : : goto err;
317 : : }
318 : : else
319 : 100 : ASN1_TYPE_set(ttmp, atype, stmp);
320 [ - + ]: 200 : if(!sk_ASN1_TYPE_push(attr->value.set, ttmp)) goto err;
321 : : return 1;
322 : : err:
323 : 0 : X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_MALLOC_FAILURE);
324 : 0 : return 0;
325 : : }
326 : :
327 : 118 : int X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr)
328 : : {
329 [ + - ]: 118 : if(!attr->single) return sk_ASN1_TYPE_num(attr->value.set);
330 [ # # ]: 0 : if(attr->value.single) return 1;
331 : 0 : return 0;
332 : : }
333 : :
334 : 0 : ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
335 : : {
336 [ # # ]: 0 : if (attr == NULL) return(NULL);
337 : 0 : return(attr->object);
338 : : }
339 : :
340 : 59 : void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx,
341 : : int atrtype, void *data)
342 : : {
343 : : ASN1_TYPE *ttmp;
344 : 59 : ttmp = X509_ATTRIBUTE_get0_type(attr, idx);
345 [ + - ]: 59 : if(!ttmp) return NULL;
346 [ - + ]: 59 : if(atrtype != ASN1_TYPE_get(ttmp)){
347 : 0 : X509err(X509_F_X509_ATTRIBUTE_GET0_DATA, X509_R_WRONG_TYPE);
348 : 0 : return NULL;
349 : : }
350 : 59 : return ttmp->value.ptr;
351 : : }
352 : :
353 : 59 : ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
354 : : {
355 [ + - ]: 59 : if (attr == NULL) return(NULL);
356 [ + - ]: 59 : if(idx >= X509_ATTRIBUTE_count(attr)) return NULL;
357 [ + - ]: 59 : if(!attr->single) return sk_ASN1_TYPE_value(attr->value.set, idx);
358 : 0 : else return attr->value.single;
359 : : }
|
