]>
Commit | Line | Data |
---|---|---|
b1322259 | 1 | /* |
1f5e0f92 | 2 | * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved. |
b38f9f66 | 3 | * |
b1322259 RS |
4 | * Licensed under the OpenSSL license (the "License"). You may not use |
5 | * this file except in compliance with the License. You can obtain a copy | |
6 | * in the file LICENSE in the source distribution or at | |
7 | * https://www.openssl.org/source/license.html | |
b38f9f66 DSH |
8 | */ |
9 | ||
10 | #include <stdio.h> | |
b39fc560 | 11 | #include "internal/cryptlib.h" |
1f5e0f92 | 12 | #include <openssl/safestack.h> |
b38f9f66 DSH |
13 | #include <openssl/asn1.h> |
14 | #include <openssl/objects.h> | |
15 | #include <openssl/evp.h> | |
16 | #include <openssl/x509.h> | |
17 | #include <openssl/x509v3.h> | |
9b0a4531 | 18 | #include "x509_lcl.h" |
b38f9f66 | 19 | |
77b47b90 | 20 | int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x) |
b38f9f66 | 21 | { |
0f113f3e | 22 | return sk_X509_ATTRIBUTE_num(x); |
b38f9f66 DSH |
23 | } |
24 | ||
77b47b90 | 25 | int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, |
0f113f3e | 26 | int lastpos) |
b38f9f66 | 27 | { |
c47ba4e9 | 28 | const ASN1_OBJECT *obj = OBJ_nid2obj(nid); |
b38f9f66 | 29 | |
0f113f3e MC |
30 | if (obj == NULL) |
31 | return (-2); | |
32 | return (X509at_get_attr_by_OBJ(x, obj, lastpos)); | |
b38f9f66 DSH |
33 | } |
34 | ||
0f113f3e | 35 | int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, |
c47ba4e9 | 36 | const ASN1_OBJECT *obj, int lastpos) |
b38f9f66 | 37 | { |
0f113f3e MC |
38 | int n; |
39 | X509_ATTRIBUTE *ex; | |
b38f9f66 | 40 | |
0f113f3e MC |
41 | if (sk == NULL) |
42 | return (-1); | |
43 | lastpos++; | |
44 | if (lastpos < 0) | |
45 | lastpos = 0; | |
46 | n = sk_X509_ATTRIBUTE_num(sk); | |
47 | for (; lastpos < n; lastpos++) { | |
48 | ex = sk_X509_ATTRIBUTE_value(sk, lastpos); | |
49 | if (OBJ_cmp(ex->object, obj) == 0) | |
50 | return (lastpos); | |
51 | } | |
52 | return (-1); | |
b38f9f66 DSH |
53 | } |
54 | ||
77b47b90 | 55 | X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc) |
b38f9f66 | 56 | { |
0f113f3e MC |
57 | if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0) |
58 | return NULL; | |
d2a56999 F |
59 | |
60 | return sk_X509_ATTRIBUTE_value(x, loc); | |
b38f9f66 DSH |
61 | } |
62 | ||
77b47b90 | 63 | X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc) |
b38f9f66 | 64 | { |
0f113f3e | 65 | X509_ATTRIBUTE *ret; |
b38f9f66 | 66 | |
0f113f3e MC |
67 | if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0) |
68 | return (NULL); | |
69 | ret = sk_X509_ATTRIBUTE_delete(x, loc); | |
70 | return (ret); | |
b38f9f66 DSH |
71 | } |
72 | ||
c7cb16a8 | 73 | STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, |
0f113f3e | 74 | X509_ATTRIBUTE *attr) |
b38f9f66 | 75 | { |
0f113f3e MC |
76 | X509_ATTRIBUTE *new_attr = NULL; |
77 | STACK_OF(X509_ATTRIBUTE) *sk = NULL; | |
b38f9f66 | 78 | |
0f113f3e MC |
79 | if (x == NULL) { |
80 | X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_PASSED_NULL_PARAMETER); | |
81 | goto err2; | |
82 | } | |
c755c5fd | 83 | |
0f113f3e MC |
84 | if (*x == NULL) { |
85 | if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL) | |
86 | goto err; | |
87 | } else | |
88 | sk = *x; | |
b38f9f66 | 89 | |
0f113f3e MC |
90 | if ((new_attr = X509_ATTRIBUTE_dup(attr)) == NULL) |
91 | goto err2; | |
92 | if (!sk_X509_ATTRIBUTE_push(sk, new_attr)) | |
93 | goto err; | |
94 | if (*x == NULL) | |
95 | *x = sk; | |
96 | return (sk); | |
97 | err: | |
98 | X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_MALLOC_FAILURE); | |
99 | err2: | |
222561fe RS |
100 | X509_ATTRIBUTE_free(new_attr); |
101 | sk_X509_ATTRIBUTE_free(sk); | |
0f113f3e | 102 | return (NULL); |
b38f9f66 DSH |
103 | } |
104 | ||
0f113f3e MC |
105 | STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) |
106 | **x, const ASN1_OBJECT *obj, | |
107 | int type, | |
108 | const unsigned char *bytes, | |
109 | int len) | |
77b47b90 | 110 | { |
0f113f3e MC |
111 | X509_ATTRIBUTE *attr; |
112 | STACK_OF(X509_ATTRIBUTE) *ret; | |
113 | attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len); | |
114 | if (!attr) | |
115 | return 0; | |
116 | ret = X509at_add1_attr(x, attr); | |
117 | X509_ATTRIBUTE_free(attr); | |
118 | return ret; | |
77b47b90 DSH |
119 | } |
120 | ||
0f113f3e MC |
121 | STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) |
122 | **x, int nid, int type, | |
123 | const unsigned char *bytes, | |
124 | int len) | |
77b47b90 | 125 | { |
0f113f3e MC |
126 | X509_ATTRIBUTE *attr; |
127 | STACK_OF(X509_ATTRIBUTE) *ret; | |
128 | attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len); | |
129 | if (!attr) | |
130 | return 0; | |
131 | ret = X509at_add1_attr(x, attr); | |
132 | X509_ATTRIBUTE_free(attr); | |
133 | return ret; | |
77b47b90 DSH |
134 | } |
135 | ||
0f113f3e MC |
136 | STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) |
137 | **x, const char *attrname, | |
138 | int type, | |
139 | const unsigned char *bytes, | |
140 | int len) | |
77b47b90 | 141 | { |
0f113f3e MC |
142 | X509_ATTRIBUTE *attr; |
143 | STACK_OF(X509_ATTRIBUTE) *ret; | |
144 | attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len); | |
145 | if (!attr) | |
146 | return 0; | |
147 | ret = X509at_add1_attr(x, attr); | |
148 | X509_ATTRIBUTE_free(attr); | |
149 | return ret; | |
77b47b90 DSH |
150 | } |
151 | ||
4d318c79 | 152 | void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, |
c47ba4e9 | 153 | const ASN1_OBJECT *obj, int lastpos, int type) |
4d318c79 | 154 | { |
0f113f3e MC |
155 | int i; |
156 | X509_ATTRIBUTE *at; | |
157 | i = X509at_get_attr_by_OBJ(x, obj, lastpos); | |
158 | if (i == -1) | |
159 | return NULL; | |
160 | if ((lastpos <= -2) && (X509at_get_attr_by_OBJ(x, obj, i) != -1)) | |
161 | return NULL; | |
162 | at = X509at_get_attr(x, i); | |
163 | if (lastpos <= -3 && (X509_ATTRIBUTE_count(at) != 1)) | |
164 | return NULL; | |
165 | return X509_ATTRIBUTE_get0_data(at, 0, type, NULL); | |
4d318c79 DSH |
166 | } |
167 | ||
b38f9f66 | 168 | X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, |
0f113f3e MC |
169 | int atrtype, const void *data, |
170 | int len) | |
b38f9f66 | 171 | { |
0f113f3e MC |
172 | ASN1_OBJECT *obj; |
173 | X509_ATTRIBUTE *ret; | |
b38f9f66 | 174 | |
0f113f3e MC |
175 | obj = OBJ_nid2obj(nid); |
176 | if (obj == NULL) { | |
177 | X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_NID, X509_R_UNKNOWN_NID); | |
178 | return (NULL); | |
179 | } | |
180 | ret = X509_ATTRIBUTE_create_by_OBJ(attr, obj, atrtype, data, len); | |
181 | if (ret == NULL) | |
182 | ASN1_OBJECT_free(obj); | |
183 | return (ret); | |
b38f9f66 DSH |
184 | } |
185 | ||
186 | X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, | |
0f113f3e MC |
187 | const ASN1_OBJECT *obj, |
188 | int atrtype, const void *data, | |
189 | int len) | |
b38f9f66 | 190 | { |
0f113f3e | 191 | X509_ATTRIBUTE *ret; |
b38f9f66 | 192 | |
0f113f3e MC |
193 | if ((attr == NULL) || (*attr == NULL)) { |
194 | if ((ret = X509_ATTRIBUTE_new()) == NULL) { | |
195 | X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ, | |
196 | ERR_R_MALLOC_FAILURE); | |
197 | return (NULL); | |
198 | } | |
199 | } else | |
200 | ret = *attr; | |
b38f9f66 | 201 | |
0f113f3e MC |
202 | if (!X509_ATTRIBUTE_set1_object(ret, obj)) |
203 | goto err; | |
204 | if (!X509_ATTRIBUTE_set1_data(ret, atrtype, data, len)) | |
205 | goto err; | |
8528128b | 206 | |
0f113f3e MC |
207 | if ((attr != NULL) && (*attr == NULL)) |
208 | *attr = ret; | |
209 | return (ret); | |
210 | err: | |
211 | if ((attr == NULL) || (ret != *attr)) | |
212 | X509_ATTRIBUTE_free(ret); | |
213 | return (NULL); | |
b38f9f66 DSH |
214 | } |
215 | ||
77b47b90 | 216 | X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, |
0f113f3e MC |
217 | const char *atrname, int type, |
218 | const unsigned char *bytes, | |
219 | int len) | |
220 | { | |
221 | ASN1_OBJECT *obj; | |
222 | X509_ATTRIBUTE *nattr; | |
77b47b90 | 223 | |
0f113f3e MC |
224 | obj = OBJ_txt2obj(atrname, 0); |
225 | if (obj == NULL) { | |
226 | X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_TXT, | |
227 | X509_R_INVALID_FIELD_NAME); | |
228 | ERR_add_error_data(2, "name=", atrname); | |
229 | return (NULL); | |
230 | } | |
231 | nattr = X509_ATTRIBUTE_create_by_OBJ(attr, obj, type, bytes, len); | |
232 | ASN1_OBJECT_free(obj); | |
233 | return nattr; | |
234 | } | |
77b47b90 | 235 | |
f2a253e0 | 236 | int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj) |
b38f9f66 | 237 | { |
0f113f3e MC |
238 | if ((attr == NULL) || (obj == NULL)) |
239 | return (0); | |
240 | ASN1_OBJECT_free(attr->object); | |
241 | attr->object = OBJ_dup(obj); | |
4e0e4d29 | 242 | return attr->object != NULL; |
b38f9f66 DSH |
243 | } |
244 | ||
0f113f3e MC |
245 | int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, |
246 | const void *data, int len) | |
b38f9f66 | 247 | { |
5000a6d1 | 248 | ASN1_TYPE *ttmp = NULL; |
0f113f3e MC |
249 | ASN1_STRING *stmp = NULL; |
250 | int atype = 0; | |
251 | if (!attr) | |
252 | return 0; | |
253 | if (attrtype & MBSTRING_FLAG) { | |
254 | stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype, | |
255 | OBJ_obj2nid(attr->object)); | |
256 | if (!stmp) { | |
257 | X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_ASN1_LIB); | |
258 | return 0; | |
259 | } | |
260 | atype = stmp->type; | |
261 | } else if (len != -1) { | |
75ebbd9a | 262 | if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL) |
0f113f3e MC |
263 | goto err; |
264 | if (!ASN1_STRING_set(stmp, data, len)) | |
265 | goto err; | |
266 | atype = attrtype; | |
267 | } | |
0f113f3e MC |
268 | /* |
269 | * This is a bit naughty because the attribute should really have at | |
270 | * least one value but some types use and zero length SET and require | |
271 | * this. | |
272 | */ | |
5000a6d1 MC |
273 | if (attrtype == 0) { |
274 | ASN1_STRING_free(stmp); | |
0f113f3e | 275 | return 1; |
5000a6d1 | 276 | } |
75ebbd9a | 277 | if ((ttmp = ASN1_TYPE_new()) == NULL) |
0f113f3e MC |
278 | goto err; |
279 | if ((len == -1) && !(attrtype & MBSTRING_FLAG)) { | |
280 | if (!ASN1_TYPE_set1(ttmp, attrtype, data)) | |
281 | goto err; | |
5000a6d1 | 282 | } else { |
0f113f3e | 283 | ASN1_TYPE_set(ttmp, atype, stmp); |
5000a6d1 MC |
284 | stmp = NULL; |
285 | } | |
e20b5727 | 286 | if (!sk_ASN1_TYPE_push(attr->set, ttmp)) |
0f113f3e MC |
287 | goto err; |
288 | return 1; | |
289 | err: | |
290 | X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_MALLOC_FAILURE); | |
5000a6d1 MC |
291 | ASN1_TYPE_free(ttmp); |
292 | ASN1_STRING_free(stmp); | |
0f113f3e | 293 | return 0; |
b38f9f66 DSH |
294 | } |
295 | ||
333ed02c | 296 | int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr) |
b38f9f66 | 297 | { |
e20b5727 DSH |
298 | if (attr == NULL) |
299 | return 0; | |
300 | return sk_ASN1_TYPE_num(attr->set); | |
b38f9f66 DSH |
301 | } |
302 | ||
c7cb16a8 | 303 | ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr) |
b38f9f66 | 304 | { |
0f113f3e MC |
305 | if (attr == NULL) |
306 | return (NULL); | |
307 | return (attr->object); | |
b38f9f66 DSH |
308 | } |
309 | ||
c7cb16a8 | 310 | void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, |
0f113f3e | 311 | int atrtype, void *data) |
b38f9f66 | 312 | { |
0f113f3e MC |
313 | ASN1_TYPE *ttmp; |
314 | ttmp = X509_ATTRIBUTE_get0_type(attr, idx); | |
315 | if (!ttmp) | |
316 | return NULL; | |
317 | if (atrtype != ASN1_TYPE_get(ttmp)) { | |
318 | X509err(X509_F_X509_ATTRIBUTE_GET0_DATA, X509_R_WRONG_TYPE); | |
319 | return NULL; | |
320 | } | |
321 | return ttmp->value.ptr; | |
b38f9f66 DSH |
322 | } |
323 | ||
c7cb16a8 | 324 | ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx) |
b38f9f66 | 325 | { |
0f113f3e | 326 | if (attr == NULL) |
0f113f3e | 327 | return NULL; |
e20b5727 | 328 | return sk_ASN1_TYPE_value(attr->set, idx); |
b38f9f66 | 329 | } |