Line data Source code
1 : /* tasn_new.c */
2 : /*
3 : * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
4 : * 2000.
5 : */
6 : /* ====================================================================
7 : * Copyright (c) 2000-2004 The OpenSSL Project. All rights reserved.
8 : *
9 : * Redistribution and use in source and binary forms, with or without
10 : * modification, are permitted provided that the following conditions
11 : * are met:
12 : *
13 : * 1. Redistributions of source code must retain the above copyright
14 : * notice, this list of conditions and the following disclaimer.
15 : *
16 : * 2. Redistributions in binary form must reproduce the above copyright
17 : * notice, this list of conditions and the following disclaimer in
18 : * the documentation and/or other materials provided with the
19 : * distribution.
20 : *
21 : * 3. All advertising materials mentioning features or use of this
22 : * software must display the following acknowledgment:
23 : * "This product includes software developed by the OpenSSL Project
24 : * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25 : *
26 : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27 : * endorse or promote products derived from this software without
28 : * prior written permission. For written permission, please contact
29 : * licensing@OpenSSL.org.
30 : *
31 : * 5. Products derived from this software may not be called "OpenSSL"
32 : * nor may "OpenSSL" appear in their names without prior written
33 : * permission of the OpenSSL Project.
34 : *
35 : * 6. Redistributions of any form whatsoever must retain the following
36 : * acknowledgment:
37 : * "This product includes software developed by the OpenSSL Project
38 : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39 : *
40 : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41 : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43 : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
44 : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46 : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47 : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49 : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50 : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51 : * OF THE POSSIBILITY OF SUCH DAMAGE.
52 : * ====================================================================
53 : *
54 : * This product includes cryptographic software written by Eric Young
55 : * (eay@cryptsoft.com). This product includes software written by Tim
56 : * Hudson (tjh@cryptsoft.com).
57 : *
58 : */
59 :
60 : #include <stddef.h>
61 : #include <openssl/asn1.h>
62 : #include <openssl/objects.h>
63 : #include <openssl/err.h>
64 : #include <openssl/asn1t.h>
65 : #include <string.h>
66 :
67 : static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
68 : int combine);
69 : static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
70 : static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
71 : static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
72 :
73 20492 : ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it)
74 : {
75 20492 : ASN1_VALUE *ret = NULL;
76 20492 : if (ASN1_item_ex_new(&ret, it) > 0)
77 20492 : return ret;
78 : return NULL;
79 : }
80 :
81 : /* Allocate an ASN1 structure */
82 :
83 29204 : int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
84 : {
85 49696 : return asn1_item_ex_combine_new(pval, it, 0);
86 : }
87 :
88 145119 : static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
89 : int combine)
90 : {
91 : const ASN1_TEMPLATE *tt = NULL;
92 : const ASN1_COMPAT_FUNCS *cf;
93 : const ASN1_EXTERN_FUNCS *ef;
94 145119 : const ASN1_AUX *aux = it->funcs;
95 : ASN1_aux_cb *asn1_cb;
96 : ASN1_VALUE **pseqval;
97 : int i;
98 145119 : if (aux && aux->asn1_cb)
99 4963 : asn1_cb = aux->asn1_cb;
100 : else
101 : asn1_cb = 0;
102 :
103 : #ifdef CRYPTO_MDEBUG
104 : if (it->sname)
105 : CRYPTO_push_info(it->sname);
106 : #endif
107 :
108 145119 : switch (it->itype) {
109 :
110 : case ASN1_ITYPE_EXTERN:
111 : ef = it->funcs;
112 3362 : if (ef && ef->asn1_ex_new) {
113 3362 : if (!ef->asn1_ex_new(pval, it))
114 : goto memerr;
115 : }
116 : break;
117 :
118 : case ASN1_ITYPE_COMPAT:
119 : cf = it->funcs;
120 0 : if (cf && cf->asn1_new) {
121 0 : *pval = cf->asn1_new();
122 0 : if (!*pval)
123 : goto memerr;
124 : }
125 : break;
126 :
127 : case ASN1_ITYPE_PRIMITIVE:
128 54272 : if (it->templates) {
129 0 : if (!ASN1_template_new(pval, it->templates))
130 : goto memerr;
131 54272 : } else if (!ASN1_primitive_new(pval, it))
132 : goto memerr;
133 : break;
134 :
135 : case ASN1_ITYPE_MSTRING:
136 32746 : if (!ASN1_primitive_new(pval, it))
137 : goto memerr;
138 : break;
139 :
140 : case ASN1_ITYPE_CHOICE:
141 6040 : if (asn1_cb) {
142 0 : i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
143 0 : if (!i)
144 : goto auxerr;
145 0 : if (i == 2) {
146 : #ifdef CRYPTO_MDEBUG
147 : if (it->sname)
148 : CRYPTO_pop_info();
149 : #endif
150 : return 1;
151 : }
152 : }
153 6040 : if (!combine) {
154 6040 : *pval = OPENSSL_malloc(it->size);
155 6040 : if (!*pval)
156 : goto memerr;
157 6040 : memset(*pval, 0, it->size);
158 : }
159 6040 : asn1_set_choice_selector(pval, -1, it);
160 6040 : if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
161 : goto auxerr;
162 : break;
163 :
164 : case ASN1_ITYPE_NDEF_SEQUENCE:
165 : case ASN1_ITYPE_SEQUENCE:
166 48699 : if (asn1_cb) {
167 4963 : i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
168 4963 : if (!i)
169 : goto auxerr;
170 4963 : if (i == 2) {
171 : #ifdef CRYPTO_MDEBUG
172 : if (it->sname)
173 : CRYPTO_pop_info();
174 : #endif
175 : return 1;
176 : }
177 : }
178 47110 : if (!combine) {
179 47110 : *pval = OPENSSL_malloc(it->size);
180 47110 : if (!*pval)
181 : goto memerr;
182 47110 : memset(*pval, 0, it->size);
183 47110 : asn1_do_lock(pval, 0, it);
184 47110 : asn1_enc_init(pval, it);
185 : }
186 160221 : for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) {
187 113111 : pseqval = asn1_get_field_ptr(pval, tt);
188 113111 : if (!ASN1_template_new(pseqval, tt))
189 : goto memerr;
190 : }
191 47110 : if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
192 : goto auxerr;
193 : break;
194 : }
195 : #ifdef CRYPTO_MDEBUG
196 : if (it->sname)
197 : CRYPTO_pop_info();
198 : #endif
199 : return 1;
200 :
201 : memerr:
202 0 : ASN1err(ASN1_F_ASN1_ITEM_EX_COMBINE_NEW, ERR_R_MALLOC_FAILURE);
203 : #ifdef CRYPTO_MDEBUG
204 : if (it->sname)
205 : CRYPTO_pop_info();
206 : #endif
207 0 : return 0;
208 :
209 : auxerr:
210 0 : ASN1err(ASN1_F_ASN1_ITEM_EX_COMBINE_NEW, ASN1_R_AUX_ERROR);
211 0 : ASN1_item_ex_free(pval, it);
212 : #ifdef CRYPTO_MDEBUG
213 : if (it->sname)
214 : CRYPTO_pop_info();
215 : #endif
216 0 : return 0;
217 :
218 : }
219 :
220 15995 : static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
221 : {
222 : const ASN1_EXTERN_FUNCS *ef;
223 :
224 15995 : switch (it->itype) {
225 :
226 : case ASN1_ITYPE_EXTERN:
227 0 : ef = it->funcs;
228 0 : if (ef && ef->asn1_ex_clear)
229 0 : ef->asn1_ex_clear(pval, it);
230 : else
231 0 : *pval = NULL;
232 : break;
233 :
234 : case ASN1_ITYPE_PRIMITIVE:
235 15995 : if (it->templates)
236 0 : asn1_template_clear(pval, it->templates);
237 : else
238 15995 : asn1_primitive_clear(pval, it);
239 : break;
240 :
241 : case ASN1_ITYPE_MSTRING:
242 0 : asn1_primitive_clear(pval, it);
243 0 : break;
244 :
245 : case ASN1_ITYPE_COMPAT:
246 : case ASN1_ITYPE_CHOICE:
247 : case ASN1_ITYPE_SEQUENCE:
248 : case ASN1_ITYPE_NDEF_SEQUENCE:
249 0 : *pval = NULL;
250 0 : break;
251 : }
252 15995 : }
253 :
254 113111 : int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
255 : {
256 113111 : const ASN1_ITEM *it = ASN1_ITEM_ptr(tt->item);
257 : int ret;
258 113111 : if (tt->flags & ASN1_TFLG_OPTIONAL) {
259 : asn1_template_clear(pval, tt);
260 : return 1;
261 : }
262 : /* If ANY DEFINED BY nothing to do */
263 :
264 95423 : if (tt->flags & ASN1_TFLG_ADB_MASK) {
265 0 : *pval = NULL;
266 0 : return 1;
267 : }
268 : #ifdef CRYPTO_MDEBUG
269 : if (tt->field_name)
270 : CRYPTO_push_info(tt->field_name);
271 : #endif
272 : /* If SET OF or SEQUENCE OF, its a STACK */
273 95423 : if (tt->flags & ASN1_TFLG_SK_MASK) {
274 : STACK_OF(ASN1_VALUE) *skval;
275 0 : skval = sk_ASN1_VALUE_new_null();
276 0 : if (!skval) {
277 0 : ASN1err(ASN1_F_ASN1_TEMPLATE_NEW, ERR_R_MALLOC_FAILURE);
278 : ret = 0;
279 0 : goto done;
280 : }
281 0 : *pval = (ASN1_VALUE *)skval;
282 : ret = 1;
283 0 : goto done;
284 : }
285 : /* Otherwise pass it back to the item routine */
286 95423 : ret = asn1_item_ex_combine_new(pval, it, tt->flags & ASN1_TFLG_COMBINE);
287 : done:
288 : #ifdef CRYPTO_MDEBUG
289 : if (it->sname)
290 : CRYPTO_pop_info();
291 : #endif
292 95423 : return ret;
293 : }
294 :
295 0 : static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
296 : {
297 : /* If ADB or STACK just NULL the field */
298 17688 : if (tt->flags & (ASN1_TFLG_ADB_MASK | ASN1_TFLG_SK_MASK))
299 1693 : *pval = NULL;
300 : else
301 15995 : asn1_item_clear(pval, ASN1_ITEM_ptr(tt->item));
302 0 : }
303 :
304 : /*
305 : * NB: could probably combine most of the real XXX_new() behaviour and junk
306 : * all the old functions.
307 : */
308 :
309 87018 : int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
310 : {
311 : ASN1_TYPE *typ;
312 : ASN1_STRING *str;
313 : int utype;
314 :
315 87018 : if (!it)
316 : return 0;
317 :
318 87018 : if (it->funcs) {
319 : const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;
320 0 : if (pf->prim_new)
321 0 : return pf->prim_new(pval, it);
322 : }
323 :
324 87018 : if (it->itype == ASN1_ITYPE_MSTRING)
325 : utype = -1;
326 : else
327 54272 : utype = it->utype;
328 87018 : switch (utype) {
329 : case V_ASN1_OBJECT:
330 38922 : *pval = (ASN1_VALUE *)OBJ_nid2obj(NID_undef);
331 38922 : return 1;
332 :
333 : case V_ASN1_BOOLEAN:
334 0 : *(ASN1_BOOLEAN *)pval = it->size;
335 0 : return 1;
336 :
337 : case V_ASN1_NULL:
338 0 : *pval = (ASN1_VALUE *)1;
339 0 : return 1;
340 :
341 : case V_ASN1_ANY:
342 5812 : typ = OPENSSL_malloc(sizeof(ASN1_TYPE));
343 5812 : if (!typ)
344 : return 0;
345 5812 : typ->value.ptr = NULL;
346 5812 : typ->type = -1;
347 5812 : *pval = (ASN1_VALUE *)typ;
348 5812 : break;
349 :
350 : default:
351 42284 : str = ASN1_STRING_type_new(utype);
352 42284 : if (it->itype == ASN1_ITYPE_MSTRING && str)
353 32746 : str->flags |= ASN1_STRING_FLAG_MSTRING;
354 42284 : *pval = (ASN1_VALUE *)str;
355 42284 : break;
356 : }
357 48096 : if (*pval)
358 : return 1;
359 0 : return 0;
360 : }
361 :
362 15995 : static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
363 : {
364 : int utype;
365 15995 : if (it && it->funcs) {
366 : const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;
367 0 : if (pf->prim_clear)
368 0 : pf->prim_clear(pval, it);
369 : else
370 0 : *pval = NULL;
371 15995 : return;
372 : }
373 15995 : if (!it || (it->itype == ASN1_ITYPE_MSTRING))
374 : utype = -1;
375 : else
376 15995 : utype = it->utype;
377 15995 : if (utype == V_ASN1_BOOLEAN)
378 4445 : *(ASN1_BOOLEAN *)pval = it->size;
379 : else
380 11550 : *pval = NULL;
381 : }
|
