summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/x509/x509_att.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/x509/x509_att.c')
-rw-r--r--src/lib/libcrypto/x509/x509_att.c403
1 files changed, 0 insertions, 403 deletions
diff --git a/src/lib/libcrypto/x509/x509_att.c b/src/lib/libcrypto/x509/x509_att.c
deleted file mode 100644
index ab11e79b0a..0000000000
--- a/src/lib/libcrypto/x509/x509_att.c
+++ /dev/null
@@ -1,403 +0,0 @@
1/* $OpenBSD: x509_att.c,v 1.14 2016/03/21 04:05:33 mmcc Exp $ */
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
61#include <openssl/asn1.h>
62#include <openssl/err.h>
63#include <openssl/evp.h>
64#include <openssl/objects.h>
65#include <openssl/stack.h>
66#include <openssl/x509.h>
67#include <openssl/x509v3.h>
68
69int
70X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
71{
72 return sk_X509_ATTRIBUTE_num(x);
73}
74
75int
76X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, int lastpos)
77{
78 ASN1_OBJECT *obj;
79
80 obj = OBJ_nid2obj(nid);
81 if (obj == NULL)
82 return (-2);
83 return (X509at_get_attr_by_OBJ(x, obj, lastpos));
84}
85
86int
87X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, ASN1_OBJECT *obj,
88 int lastpos)
89{
90 int n;
91 X509_ATTRIBUTE *ex;
92
93 if (sk == NULL)
94 return (-1);
95 lastpos++;
96 if (lastpos < 0)
97 lastpos = 0;
98 n = sk_X509_ATTRIBUTE_num(sk);
99 for (; lastpos < n; lastpos++) {
100 ex = sk_X509_ATTRIBUTE_value(sk, lastpos);
101 if (OBJ_cmp(ex->object, obj) == 0)
102 return (lastpos);
103 }
104 return (-1);
105}
106
107X509_ATTRIBUTE *
108X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
109{
110 if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
111 return NULL;
112 else
113 return sk_X509_ATTRIBUTE_value(x, loc);
114}
115
116X509_ATTRIBUTE *
117X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
118{
119 X509_ATTRIBUTE *ret;
120
121 if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
122 return (NULL);
123 ret = sk_X509_ATTRIBUTE_delete(x, loc);
124 return (ret);
125}
126
127STACK_OF(X509_ATTRIBUTE) *
128X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, X509_ATTRIBUTE *attr)
129{
130 X509_ATTRIBUTE *new_attr = NULL;
131 STACK_OF(X509_ATTRIBUTE) *sk = NULL;
132
133 if (x == NULL) {
134 X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_PASSED_NULL_PARAMETER);
135 return (NULL);
136 }
137
138 if (*x == NULL) {
139 if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL)
140 goto err;
141 } else
142 sk = *x;
143
144 if ((new_attr = X509_ATTRIBUTE_dup(attr)) == NULL)
145 goto err2;
146 if (!sk_X509_ATTRIBUTE_push(sk, new_attr))
147 goto err;
148 if (*x == NULL)
149 *x = sk;
150 return (sk);
151
152err:
153 X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_MALLOC_FAILURE);
154err2:
155 if (new_attr != NULL)
156 X509_ATTRIBUTE_free(new_attr);
157 if (sk != NULL && sk != *x)
158 sk_X509_ATTRIBUTE_free(sk);
159 return (NULL);
160}
161
162STACK_OF(X509_ATTRIBUTE) *
163X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj,
164 int type, const unsigned char *bytes, int len)
165{
166 X509_ATTRIBUTE *attr;
167 STACK_OF(X509_ATTRIBUTE) *ret;
168
169 attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len);
170 if (!attr)
171 return 0;
172 ret = X509at_add1_attr(x, attr);
173 X509_ATTRIBUTE_free(attr);
174 return ret;
175}
176
177STACK_OF(X509_ATTRIBUTE) *
178X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, int nid, int type,
179 const unsigned char *bytes, int len)
180{
181 X509_ATTRIBUTE *attr;
182 STACK_OF(X509_ATTRIBUTE) *ret;
183
184 attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len);
185 if (!attr)
186 return 0;
187 ret = X509at_add1_attr(x, attr);
188 X509_ATTRIBUTE_free(attr);
189 return ret;
190}
191
192STACK_OF(X509_ATTRIBUTE) *
193X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, const char *attrname,
194 int type, const unsigned char *bytes, int len)
195{
196 X509_ATTRIBUTE *attr;
197 STACK_OF(X509_ATTRIBUTE) *ret;
198
199 attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len);
200 if (!attr)
201 return 0;
202 ret = X509at_add1_attr(x, attr);
203 X509_ATTRIBUTE_free(attr);
204 return ret;
205}
206
207void *
208X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, ASN1_OBJECT *obj,
209 int lastpos, int type)
210{
211 int i;
212 X509_ATTRIBUTE *at;
213
214 i = X509at_get_attr_by_OBJ(x, obj, lastpos);
215 if (i == -1)
216 return NULL;
217 if ((lastpos <= -2) && (X509at_get_attr_by_OBJ(x, obj, i) != -1))
218 return NULL;
219 at = X509at_get_attr(x, i);
220 if (lastpos <= -3 && (X509_ATTRIBUTE_count(at) != 1))
221 return NULL;
222 return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
223}
224
225X509_ATTRIBUTE *
226X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int atrtype,
227 const void *data, int len)
228{
229 ASN1_OBJECT *obj;
230 X509_ATTRIBUTE *ret;
231
232 obj = OBJ_nid2obj(nid);
233 if (obj == NULL) {
234 X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_NID,
235 X509_R_UNKNOWN_NID);
236 return (NULL);
237 }
238 ret = X509_ATTRIBUTE_create_by_OBJ(attr, obj, atrtype, data, len);
239 if (ret == NULL)
240 ASN1_OBJECT_free(obj);
241 return (ret);
242}
243
244X509_ATTRIBUTE *
245X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, const ASN1_OBJECT *obj,
246 int atrtype, const void *data, int len)
247{
248 X509_ATTRIBUTE *ret;
249
250 if ((attr == NULL) || (*attr == NULL)) {
251 if ((ret = X509_ATTRIBUTE_new()) == NULL) {
252 X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ,
253 ERR_R_MALLOC_FAILURE);
254 return (NULL);
255 }
256 } else
257 ret= *attr;
258
259 if (!X509_ATTRIBUTE_set1_object(ret, obj))
260 goto err;
261 if (!X509_ATTRIBUTE_set1_data(ret, atrtype, data, len))
262 goto err;
263
264 if ((attr != NULL) && (*attr == NULL))
265 *attr = ret;
266 return (ret);
267
268err:
269 if ((attr == NULL) || (ret != *attr))
270 X509_ATTRIBUTE_free(ret);
271 return (NULL);
272}
273
274X509_ATTRIBUTE *
275X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, const char *atrname,
276 int type, const unsigned char *bytes, int len)
277{
278 ASN1_OBJECT *obj;
279 X509_ATTRIBUTE *nattr;
280
281 obj = OBJ_txt2obj(atrname, 0);
282 if (obj == NULL) {
283 X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_TXT,
284 X509_R_INVALID_FIELD_NAME);
285 ERR_asprintf_error_data("name=%s", atrname);
286 return (NULL);
287 }
288 nattr = X509_ATTRIBUTE_create_by_OBJ(attr, obj, type, bytes, len);
289 ASN1_OBJECT_free(obj);
290 return nattr;
291}
292
293int
294X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
295{
296 if ((attr == NULL) || (obj == NULL))
297 return (0);
298 ASN1_OBJECT_free(attr->object);
299 attr->object = OBJ_dup(obj);
300 return attr->object != NULL;
301}
302
303int
304X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data,
305 int len)
306{
307 ASN1_TYPE *ttmp = NULL;
308 ASN1_STRING *stmp = NULL;
309 int atype = 0;
310
311 if (!attr)
312 return 0;
313 if (attrtype & MBSTRING_FLAG) {
314 stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype,
315 OBJ_obj2nid(attr->object));
316 if (!stmp) {
317 X509err(X509_F_X509_ATTRIBUTE_SET1_DATA,
318 ERR_R_ASN1_LIB);
319 return 0;
320 }
321 atype = stmp->type;
322 } else if (len != -1){
323 if (!(stmp = ASN1_STRING_type_new(attrtype)))
324 goto err;
325 if (!ASN1_STRING_set(stmp, data, len))
326 goto err;
327 atype = attrtype;
328 }
329 if (!(attr->value.set = sk_ASN1_TYPE_new_null()))
330 goto err;
331 attr->single = 0;
332 /* This is a bit naughty because the attribute should really have
333 * at least one value but some types use and zero length SET and
334 * require this.
335 */
336 if (attrtype == 0) {
337 ASN1_STRING_free(stmp);
338 return 1;
339 }
340
341 if (!(ttmp = ASN1_TYPE_new()))
342 goto err;
343 if ((len == -1) && !(attrtype & MBSTRING_FLAG)) {
344 if (!ASN1_TYPE_set1(ttmp, attrtype, data))
345 goto err;
346 } else
347 ASN1_TYPE_set(ttmp, atype, stmp);
348 if (!sk_ASN1_TYPE_push(attr->value.set, ttmp))
349 goto err;
350 return 1;
351
352err:
353 ASN1_TYPE_free(ttmp);
354 ASN1_STRING_free(stmp);
355 X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_MALLOC_FAILURE);
356 return 0;
357}
358
359int
360X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr)
361{
362 if (!attr->single)
363 return sk_ASN1_TYPE_num(attr->value.set);
364 if (attr->value.single)
365 return 1;
366 return 0;
367}
368
369ASN1_OBJECT *
370X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
371{
372 if (attr == NULL)
373 return (NULL);
374 return (attr->object);
375}
376
377void *
378X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, void *data)
379{
380 ASN1_TYPE *ttmp;
381
382 ttmp = X509_ATTRIBUTE_get0_type(attr, idx);
383 if (!ttmp)
384 return NULL;
385 if (atrtype != ASN1_TYPE_get(ttmp)){
386 X509err(X509_F_X509_ATTRIBUTE_GET0_DATA, X509_R_WRONG_TYPE);
387 return NULL;
388 }
389 return ttmp->value.ptr;
390}
391
392ASN1_TYPE *
393X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
394{
395 if (attr == NULL)
396 return (NULL);
397 if (idx >= X509_ATTRIBUTE_count(attr))
398 return NULL;
399 if (!attr->single)
400 return sk_ASN1_TYPE_value(attr->value.set, idx);
401 else
402 return attr->value.single;
403}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-05-07 20:40:32 +0000