Coverage Report

Created: 2023-06-08 06:41

/src/openssl111/crypto/asn1/tasn_new.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 2000-2018 The OpenSSL Project Authors. All Rights Reserved.
3
 *
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
8
 */
9
10
#include <stddef.h>
11
#include <openssl/asn1.h>
12
#include <openssl/objects.h>
13
#include <openssl/err.h>
14
#include <openssl/asn1t.h>
15
#include <string.h>
16
#include "asn1_local.h"
17
18
static int asn1_item_embed_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
19
                               int embed);
20
static int asn1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
21
                              int embed);
22
static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
23
static int asn1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
24
static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
25
static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
26
27
ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it)
28
68.9k
{
29
68.9k
    ASN1_VALUE *ret = NULL;
30
68.9k
    if (ASN1_item_ex_new(&ret, it) > 0)
31
68.9k
        return ret;
32
0
    return NULL;
33
68.9k
}
34
35
/* Allocate an ASN1 structure */
36
37
int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
38
276k
{
39
276k
    return asn1_item_embed_new(pval, it, 0);
40
276k
}
41
42
int asn1_item_embed_new(ASN1_VALUE **pval, const ASN1_ITEM *it, int embed)
43
890k
{
44
890k
    const ASN1_TEMPLATE *tt = NULL;
45
890k
    const ASN1_EXTERN_FUNCS *ef;
46
890k
    const ASN1_AUX *aux = it->funcs;
47
890k
    ASN1_aux_cb *asn1_cb;
48
890k
    ASN1_VALUE **pseqval;
49
890k
    int i;
50
890k
    if (aux && aux->asn1_cb)
51
69.0k
        asn1_cb = aux->asn1_cb;
52
821k
    else
53
821k
        asn1_cb = 0;
54
55
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
56
    OPENSSL_mem_debug_push(it->sname ? it->sname : "asn1_item_embed_new");
57
#endif
58
59
890k
    switch (it->itype) {
60
61
37.4k
    case ASN1_ITYPE_EXTERN:
62
37.4k
        ef = it->funcs;
63
37.4k
        if (ef && ef->asn1_ex_new) {
64
37.4k
            if (!ef->asn1_ex_new(pval, it))
65
0
                goto memerr;
66
37.4k
        }
67
37.4k
        break;
68
69
382k
    case ASN1_ITYPE_PRIMITIVE:
70
382k
        if (it->templates) {
71
0
            if (!asn1_template_new(pval, it->templates))
72
0
                goto memerr;
73
382k
        } else if (!asn1_primitive_new(pval, it, embed))
74
0
            goto memerr;
75
382k
        break;
76
77
382k
    case ASN1_ITYPE_MSTRING:
78
113k
        if (!asn1_primitive_new(pval, it, embed))
79
0
            goto memerr;
80
113k
        break;
81
82
113k
    case ASN1_ITYPE_CHOICE:
83
25.6k
        if (asn1_cb) {
84
0
            i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
85
0
            if (!i)
86
0
                goto auxerr;
87
0
            if (i == 2) {
88
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
89
                OPENSSL_mem_debug_pop();
90
#endif
91
0
                return 1;
92
0
            }
93
0
        }
94
25.6k
        if (embed) {
95
0
            memset(*pval, 0, it->size);
96
25.6k
        } else {
97
25.6k
            *pval = OPENSSL_zalloc(it->size);
98
25.6k
            if (*pval == NULL)
99
0
                goto memerr;
100
25.6k
        }
101
25.6k
        asn1_set_choice_selector(pval, -1, it);
102
25.6k
        if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
103
0
            goto auxerr2;
104
25.6k
        break;
105
106
25.6k
    case ASN1_ITYPE_NDEF_SEQUENCE:
107
331k
    case ASN1_ITYPE_SEQUENCE:
108
331k
        if (asn1_cb) {
109
62.4k
            i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
110
62.4k
            if (!i)
111
0
                goto auxerr;
112
62.4k
            if (i == 2) {
113
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
114
                OPENSSL_mem_debug_pop();
115
#endif
116
24.9k
                return 1;
117
24.9k
            }
118
62.4k
        }
119
306k
        if (embed) {
120
74.8k
            memset(*pval, 0, it->size);
121
231k
        } else {
122
231k
            *pval = OPENSSL_zalloc(it->size);
123
231k
            if (*pval == NULL)
124
0
                goto memerr;
125
231k
        }
126
        /* 0 : init. lock */
127
306k
        if (asn1_do_lock(pval, 0, it) < 0) {
128
0
            if (!embed) {
129
0
                OPENSSL_free(*pval);
130
0
                *pval = NULL;
131
0
            }
132
0
            goto memerr;
133
0
        }
134
306k
        asn1_enc_init(pval, it);
135
1.18M
        for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) {
136
874k
            pseqval = asn1_get_field_ptr(pval, tt);
137
874k
            if (!asn1_template_new(pseqval, tt))
138
0
                goto memerr2;
139
874k
        }
140
306k
        if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
141
0
            goto auxerr2;
142
306k
        break;
143
890k
    }
144
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
145
    OPENSSL_mem_debug_pop();
146
#endif
147
865k
    return 1;
148
149
0
 memerr2:
150
0
    asn1_item_embed_free(pval, it, embed);
151
0
 memerr:
152
0
    ASN1err(ASN1_F_ASN1_ITEM_EMBED_NEW, ERR_R_MALLOC_FAILURE);
153
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
154
    OPENSSL_mem_debug_pop();
155
#endif
156
0
    return 0;
157
158
0
 auxerr2:
159
0
    asn1_item_embed_free(pval, it, embed);
160
0
 auxerr:
161
0
    ASN1err(ASN1_F_ASN1_ITEM_EMBED_NEW, ASN1_R_AUX_ERROR);
162
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
163
    OPENSSL_mem_debug_pop();
164
#endif
165
0
    return 0;
166
167
0
}
168
169
static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
170
241k
{
171
241k
    const ASN1_EXTERN_FUNCS *ef;
172
173
241k
    switch (it->itype) {
174
175
0
    case ASN1_ITYPE_EXTERN:
176
0
        ef = it->funcs;
177
0
        if (ef && ef->asn1_ex_clear)
178
0
            ef->asn1_ex_clear(pval, it);
179
0
        else
180
0
            *pval = NULL;
181
0
        break;
182
183
234k
    case ASN1_ITYPE_PRIMITIVE:
184
234k
        if (it->templates)
185
0
            asn1_template_clear(pval, it->templates);
186
234k
        else
187
234k
            asn1_primitive_clear(pval, it);
188
234k
        break;
189
190
0
    case ASN1_ITYPE_MSTRING:
191
0
        asn1_primitive_clear(pval, it);
192
0
        break;
193
194
6.24k
    case ASN1_ITYPE_CHOICE:
195
6.46k
    case ASN1_ITYPE_SEQUENCE:
196
6.46k
    case ASN1_ITYPE_NDEF_SEQUENCE:
197
6.46k
        *pval = NULL;
198
6.46k
        break;
199
241k
    }
200
241k
}
201
202
static int asn1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
203
874k
{
204
874k
    const ASN1_ITEM *it = ASN1_ITEM_ptr(tt->item);
205
874k
    int embed = tt->flags & ASN1_TFLG_EMBED;
206
874k
    ASN1_VALUE *tval;
207
874k
    int ret;
208
874k
    if (embed) {
209
195k
        tval = (ASN1_VALUE *)pval;
210
195k
        pval = &tval;
211
195k
    }
212
874k
    if (tt->flags & ASN1_TFLG_OPTIONAL) {
213
260k
        asn1_template_clear(pval, tt);
214
260k
        return 1;
215
260k
    }
216
    /* If ANY DEFINED BY nothing to do */
217
218
614k
    if (tt->flags & ASN1_TFLG_ADB_MASK) {
219
0
        *pval = NULL;
220
0
        return 1;
221
0
    }
222
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
223
    OPENSSL_mem_debug_push(tt->field_name
224
            ? tt->field_name : "asn1_template_new");
225
#endif
226
    /* If SET OF or SEQUENCE OF, its a STACK */
227
614k
    if (tt->flags & ASN1_TFLG_SK_MASK) {
228
0
        STACK_OF(ASN1_VALUE) *skval;
229
0
        skval = sk_ASN1_VALUE_new_null();
230
0
        if (!skval) {
231
0
            ASN1err(ASN1_F_ASN1_TEMPLATE_NEW, ERR_R_MALLOC_FAILURE);
232
0
            ret = 0;
233
0
            goto done;
234
0
        }
235
0
        *pval = (ASN1_VALUE *)skval;
236
0
        ret = 1;
237
0
        goto done;
238
0
    }
239
    /* Otherwise pass it back to the item routine */
240
614k
    ret = asn1_item_embed_new(pval, it, embed);
241
614k
 done:
242
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
243
    OPENSSL_mem_debug_pop();
244
#endif
245
614k
    return ret;
246
614k
}
247
248
static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
249
260k
{
250
    /* If ADB or STACK just NULL the field */
251
260k
    if (tt->flags & (ASN1_TFLG_ADB_MASK | ASN1_TFLG_SK_MASK))
252
18.7k
        *pval = NULL;
253
241k
    else
254
241k
        asn1_item_clear(pval, ASN1_ITEM_ptr(tt->item));
255
260k
}
256
257
/*
258
 * NB: could probably combine most of the real XXX_new() behaviour and junk
259
 * all the old functions.
260
 */
261
262
static int asn1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
263
                              int embed)
264
495k
{
265
495k
    ASN1_TYPE *typ;
266
495k
    ASN1_STRING *str;
267
495k
    int utype;
268
269
495k
    if (!it)
270
0
        return 0;
271
272
495k
    if (it->funcs) {
273
6.68k
        const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;
274
6.68k
        if (embed) {
275
6.68k
            if (pf->prim_clear) {
276
6.68k
                pf->prim_clear(pval, it);
277
6.68k
                return 1;
278
6.68k
            }
279
6.68k
        } else if (pf->prim_new) {
280
0
            return pf->prim_new(pval, it);
281
0
        }
282
6.68k
    }
283
284
488k
    if (it->itype == ASN1_ITYPE_MSTRING)
285
113k
        utype = -1;
286
375k
    else
287
375k
        utype = it->utype;
288
488k
    switch (utype) {
289
206k
    case V_ASN1_OBJECT:
290
206k
        *pval = (ASN1_VALUE *)OBJ_nid2obj(NID_undef);
291
206k
        return 1;
292
293
0
    case V_ASN1_BOOLEAN:
294
0
        *(ASN1_BOOLEAN *)pval = it->size;
295
0
        return 1;
296
297
0
    case V_ASN1_NULL:
298
0
        *pval = (ASN1_VALUE *)1;
299
0
        return 1;
300
301
31.2k
    case V_ASN1_ANY:
302
31.2k
        if ((typ = OPENSSL_malloc(sizeof(*typ))) == NULL) {
303
0
            ASN1err(ASN1_F_ASN1_PRIMITIVE_NEW, ERR_R_MALLOC_FAILURE);
304
0
            return 0;
305
0
        }
306
31.2k
        typ->value.ptr = NULL;
307
31.2k
        typ->type = -1;
308
31.2k
        *pval = (ASN1_VALUE *)typ;
309
31.2k
        break;
310
311
251k
    default:
312
251k
        if (embed) {
313
112k
            str = *(ASN1_STRING **)pval;
314
112k
            memset(str, 0, sizeof(*str));
315
112k
            str->type = utype;
316
112k
            str->flags = ASN1_STRING_FLAG_EMBED;
317
138k
        } else {
318
138k
            str = ASN1_STRING_type_new(utype);
319
138k
            *pval = (ASN1_VALUE *)str;
320
138k
        }
321
251k
        if (it->itype == ASN1_ITYPE_MSTRING && str)
322
113k
            str->flags |= ASN1_STRING_FLAG_MSTRING;
323
251k
        break;
324
488k
    }
325
282k
    if (*pval)
326
282k
        return 1;
327
0
    return 0;
328
282k
}
329
330
static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
331
234k
{
332
234k
    int utype;
333
234k
    if (it && it->funcs) {
334
1.76k
        const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;
335
1.76k
        if (pf->prim_clear)
336
1.76k
            pf->prim_clear(pval, it);
337
0
        else
338
0
            *pval = NULL;
339
1.76k
        return;
340
1.76k
    }
341
233k
    if (!it || (it->itype == ASN1_ITYPE_MSTRING))
342
0
        utype = -1;
343
233k
    else
344
233k
        utype = it->utype;
345
233k
    if (utype == V_ASN1_BOOLEAN)
346
93.6k
        *(ASN1_BOOLEAN *)pval = it->size;
347
139k
    else
348
139k
        *pval = NULL;
349
233k
}