Coverage Report

Created: 2023-09-25 06:41

/src/openssl111/crypto/asn1/asn1_lib.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 1995-2021 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 <stdio.h>
11
#include <limits.h>
12
#include "internal/cryptlib.h"
13
#include <openssl/asn1.h>
14
#include "asn1_local.h"
15
16
static int asn1_get_length(const unsigned char **pp, int *inf, long *rl,
17
                           long max);
18
static void asn1_put_length(unsigned char **pp, int length);
19
20
static int _asn1_check_infinite_end(const unsigned char **p, long len)
21
0
{
22
    /*
23
     * If there is 0 or 1 byte left, the length check should pick things up
24
     */
25
0
    if (len <= 0)
26
0
        return 1;
27
0
    else if ((len >= 2) && ((*p)[0] == 0) && ((*p)[1] == 0)) {
28
0
        (*p) += 2;
29
0
        return 1;
30
0
    }
31
0
    return 0;
32
0
}
33
34
int ASN1_check_infinite_end(unsigned char **p, long len)
35
0
{
36
0
    return _asn1_check_infinite_end((const unsigned char **)p, len);
37
0
}
38
39
int ASN1_const_check_infinite_end(const unsigned char **p, long len)
40
0
{
41
0
    return _asn1_check_infinite_end(p, len);
42
0
}
43
44
int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
45
                    int *pclass, long omax)
46
11.1M
{
47
11.1M
    int i, ret;
48
11.1M
    long l;
49
11.1M
    const unsigned char *p = *pp;
50
11.1M
    int tag, xclass, inf;
51
11.1M
    long max = omax;
52
53
11.1M
    if (!max)
54
1.69k
        goto err;
55
11.1M
    ret = (*p & V_ASN1_CONSTRUCTED);
56
11.1M
    xclass = (*p & V_ASN1_PRIVATE);
57
11.1M
    i = *p & V_ASN1_PRIMITIVE_TAG;
58
11.1M
    if (i == V_ASN1_PRIMITIVE_TAG) { /* high-tag */
59
32.6k
        p++;
60
32.6k
        if (--max == 0)
61
529
            goto err;
62
32.0k
        l = 0;
63
42.5k
        while (*p & 0x80) {
64
10.9k
            l <<= 7L;
65
10.9k
            l |= *(p++) & 0x7f;
66
10.9k
            if (--max == 0)
67
222
                goto err;
68
10.7k
            if (l > (INT_MAX >> 7L))
69
297
                goto err;
70
10.7k
        }
71
31.5k
        l <<= 7L;
72
31.5k
        l |= *(p++) & 0x7f;
73
31.5k
        tag = (int)l;
74
31.5k
        if (--max == 0)
75
258
            goto err;
76
11.1M
    } else {
77
11.1M
        tag = i;
78
11.1M
        p++;
79
11.1M
        if (--max == 0)
80
2.43k
            goto err;
81
11.1M
    }
82
11.1M
    *ptag = tag;
83
11.1M
    *pclass = xclass;
84
11.1M
    if (!asn1_get_length(&p, &inf, plength, max))
85
2.74k
        goto err;
86
87
11.1M
    if (inf && !(ret & V_ASN1_CONSTRUCTED))
88
581
        goto err;
89
90
11.1M
    if (*plength > (omax - (p - *pp))) {
91
7.23k
        ASN1err(ASN1_F_ASN1_GET_OBJECT, ASN1_R_TOO_LONG);
92
        /*
93
         * Set this so that even if things are not long enough the values are
94
         * set correctly
95
         */
96
7.23k
        ret |= 0x80;
97
7.23k
    }
98
11.1M
    *pp = p;
99
11.1M
    return ret | inf;
100
8.75k
 err:
101
8.75k
    ASN1err(ASN1_F_ASN1_GET_OBJECT, ASN1_R_HEADER_TOO_LONG);
102
8.75k
    return 0x80;
103
11.1M
}
104
105
/*
106
 * Decode a length field.
107
 * The short form is a single byte defining a length 0 - 127.
108
 * The long form is a byte 0 - 127 with the top bit set and this indicates
109
 * the number of following octets that contain the length.  These octets
110
 * are stored most significant digit first.
111
 */
112
static int asn1_get_length(const unsigned char **pp, int *inf, long *rl,
113
                           long max)
114
11.1M
{
115
11.1M
    const unsigned char *p = *pp;
116
11.1M
    unsigned long ret = 0;
117
11.1M
    int i;
118
119
11.1M
    if (max-- < 1)
120
0
        return 0;
121
11.1M
    if (*p == 0x80) {
122
2.85M
        *inf = 1;
123
2.85M
        p++;
124
8.27M
    } else {
125
8.27M
        *inf = 0;
126
8.27M
        i = *p & 0x7f;
127
8.27M
        if (*p++ & 0x80) {
128
30.7k
            if (max < i + 1)
129
1.98k
                return 0;
130
            /* Skip leading zeroes */
131
30.5k
            while (i > 0 && *p == 0) {
132
1.73k
                p++;
133
1.73k
                i--;
134
1.73k
            }
135
28.8k
            if (i > (int)sizeof(long))
136
469
                return 0;
137
60.7k
            while (i > 0) {
138
32.4k
                ret <<= 8;
139
32.4k
                ret |= *p++;
140
32.4k
                i--;
141
32.4k
            }
142
28.3k
            if (ret > LONG_MAX)
143
288
                return 0;
144
28.3k
        } else
145
8.24M
            ret = i;
146
8.27M
    }
147
11.1M
    *pp = p;
148
11.1M
    *rl = (long)ret;
149
11.1M
    return 1;
150
11.1M
}
151
152
/*
153
 * class 0 is constructed constructed == 2 for indefinite length constructed
154
 */
155
void ASN1_put_object(unsigned char **pp, int constructed, int length, int tag,
156
                     int xclass)
157
5.26M
{
158
5.26M
    unsigned char *p = *pp;
159
5.26M
    int i, ttag;
160
161
5.26M
    i = (constructed) ? V_ASN1_CONSTRUCTED : 0;
162
5.26M
    i |= (xclass & V_ASN1_PRIVATE);
163
5.26M
    if (tag < 31)
164
5.07M
        *(p++) = i | (tag & V_ASN1_PRIMITIVE_TAG);
165
192k
    else {
166
192k
        *(p++) = i | V_ASN1_PRIMITIVE_TAG;
167
576k
        for (i = 0, ttag = tag; ttag > 0; i++)
168
384k
            ttag >>= 7;
169
192k
        ttag = i;
170
576k
        while (i-- > 0) {
171
384k
            p[i] = tag & 0x7f;
172
384k
            if (i != (ttag - 1))
173
192k
                p[i] |= 0x80;
174
384k
            tag >>= 7;
175
384k
        }
176
192k
        p += ttag;
177
192k
    }
178
5.26M
    if (constructed == 2)
179
0
        *(p++) = 0x80;
180
5.26M
    else
181
5.26M
        asn1_put_length(&p, length);
182
5.26M
    *pp = p;
183
5.26M
}
184
185
int ASN1_put_eoc(unsigned char **pp)
186
0
{
187
0
    unsigned char *p = *pp;
188
0
    *p++ = 0;
189
0
    *p++ = 0;
190
0
    *pp = p;
191
0
    return 2;
192
0
}
193
194
static void asn1_put_length(unsigned char **pp, int length)
195
5.26M
{
196
5.26M
    unsigned char *p = *pp;
197
5.26M
    int i, l;
198
5.26M
    if (length <= 127)
199
5.23M
        *(p++) = (unsigned char)length;
200
32.4k
    else {
201
32.4k
        l = length;
202
76.7k
        for (i = 0; l > 0; i++)
203
44.2k
            l >>= 8;
204
32.4k
        *(p++) = i | 0x80;
205
32.4k
        l = i;
206
76.7k
        while (i-- > 0) {
207
44.2k
            p[i] = length & 0xff;
208
44.2k
            length >>= 8;
209
44.2k
        }
210
32.4k
        p += l;
211
32.4k
    }
212
5.26M
    *pp = p;
213
5.26M
}
214
215
int ASN1_object_size(int constructed, int length, int tag)
216
20.1M
{
217
20.1M
    int ret = 1;
218
20.1M
    if (length < 0)
219
0
        return -1;
220
20.1M
    if (tag >= 31) {
221
2.44M
        while (tag > 0) {
222
1.63M
            tag >>= 7;
223
1.63M
            ret++;
224
1.63M
        }
225
815k
    }
226
20.1M
    if (constructed == 2) {
227
0
        ret += 3;
228
20.1M
    } else {
229
20.1M
        ret++;
230
20.1M
        if (length > 127) {
231
91.8k
            int tmplen = length;
232
210k
            while (tmplen > 0) {
233
118k
                tmplen >>= 8;
234
118k
                ret++;
235
118k
            }
236
91.8k
        }
237
20.1M
    }
238
20.1M
    if (ret >= INT_MAX - length)
239
0
        return -1;
240
20.1M
    return ret + length;
241
20.1M
}
242
243
int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str)
244
462k
{
245
462k
    if (str == NULL)
246
0
        return 0;
247
462k
    dst->type = str->type;
248
462k
    if (!ASN1_STRING_set(dst, str->data, str->length))
249
0
        return 0;
250
    /* Copy flags but preserve embed value */
251
462k
    dst->flags &= ASN1_STRING_FLAG_EMBED;
252
462k
    dst->flags |= str->flags & ~ASN1_STRING_FLAG_EMBED;
253
462k
    return 1;
254
462k
}
255
256
ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *str)
257
0
{
258
0
    ASN1_STRING *ret;
259
0
    if (!str)
260
0
        return NULL;
261
0
    ret = ASN1_STRING_new();
262
0
    if (ret == NULL)
263
0
        return NULL;
264
0
    if (!ASN1_STRING_copy(ret, str)) {
265
0
        ASN1_STRING_free(ret);
266
0
        return NULL;
267
0
    }
268
0
    return ret;
269
0
}
270
271
int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len_in)
272
932k
{
273
932k
    unsigned char *c;
274
932k
    const char *data = _data;
275
932k
    size_t len;
276
277
932k
    if (len_in < 0) {
278
0
        if (data == NULL)
279
0
            return 0;
280
0
        len = strlen(data);
281
932k
    } else {
282
932k
        len = (size_t)len_in;
283
932k
    }
284
    /*
285
     * Verify that the length fits within an integer for assignment to
286
     * str->length below.  The additional 1 is subtracted to allow for the
287
     * '\0' terminator even though this isn't strictly necessary.
288
     */
289
932k
    if (len > INT_MAX - 1) {
290
0
        ASN1err(0, ASN1_R_TOO_LARGE);
291
0
        return 0;
292
0
    }
293
932k
    if ((size_t)str->length <= len || str->data == NULL) {
294
932k
        c = str->data;
295
932k
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
296
        /* No NUL terminator in fuzzing builds */
297
932k
        str->data = OPENSSL_realloc(c, len != 0 ? len : 1);
298
#else
299
        str->data = OPENSSL_realloc(c, len + 1);
300
#endif
301
932k
        if (str->data == NULL) {
302
0
            ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);
303
0
            str->data = c;
304
0
            return 0;
305
0
        }
306
932k
    }
307
932k
    str->length = len;
308
932k
    if (data != NULL) {
309
799k
        memcpy(str->data, data, len);
310
799k
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
311
        /* Set the unused byte to something non NUL and printable. */
312
799k
        if (len == 0)
313
185k
            str->data[len] = '~';
314
#else
315
        /*
316
         * Add a NUL terminator. This should not be necessary - but we add it as
317
         * a safety precaution
318
         */
319
        str->data[len] = '\0';
320
#endif
321
799k
    }
322
932k
    return 1;
323
932k
}
324
325
void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len)
326
0
{
327
0
    OPENSSL_free(str->data);
328
0
    str->data = data;
329
0
    str->length = len;
330
0
}
331
332
ASN1_STRING *ASN1_STRING_new(void)
333
0
{
334
0
    return ASN1_STRING_type_new(V_ASN1_OCTET_STRING);
335
0
}
336
337
ASN1_STRING *ASN1_STRING_type_new(int type)
338
2.28M
{
339
2.28M
    ASN1_STRING *ret;
340
341
2.28M
    ret = OPENSSL_zalloc(sizeof(*ret));
342
2.28M
    if (ret == NULL) {
343
0
        ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);
344
0
        return NULL;
345
0
    }
346
2.28M
    ret->type = type;
347
2.28M
    return ret;
348
2.28M
}
349
350
void asn1_string_embed_free(ASN1_STRING *a, int embed)
351
2.41M
{
352
2.41M
    if (a == NULL)
353
0
        return;
354
2.41M
    if (!(a->flags & ASN1_STRING_FLAG_NDEF))
355
2.41M
        OPENSSL_free(a->data);
356
2.41M
    if (embed == 0)
357
2.28M
        OPENSSL_free(a);
358
2.41M
}
359
360
void ASN1_STRING_free(ASN1_STRING *a)
361
53.4k
{
362
53.4k
    if (a == NULL)
363
35.4k
        return;
364
18.0k
    asn1_string_embed_free(a, a->flags & ASN1_STRING_FLAG_EMBED);
365
18.0k
}
366
367
void ASN1_STRING_clear_free(ASN1_STRING *a)
368
0
{
369
0
    if (a == NULL)
370
0
        return;
371
0
    if (a->data && !(a->flags & ASN1_STRING_FLAG_NDEF))
372
0
        OPENSSL_cleanse(a->data, a->length);
373
0
    ASN1_STRING_free(a);
374
0
}
375
376
int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b)
377
0
{
378
0
    int i;
379
380
0
    i = (a->length - b->length);
381
0
    if (i == 0) {
382
0
        if (a->length != 0)
383
0
            i = memcmp(a->data, b->data, a->length);
384
0
        if (i == 0)
385
0
            return a->type - b->type;
386
0
        else
387
0
            return i;
388
0
    } else
389
0
        return i;
390
0
}
391
392
int ASN1_STRING_length(const ASN1_STRING *x)
393
108k
{
394
108k
    return x->length;
395
108k
}
396
397
void ASN1_STRING_length_set(ASN1_STRING *x, int len)
398
0
{
399
0
    x->length = len;
400
0
}
401
402
int ASN1_STRING_type(const ASN1_STRING *x)
403
0
{
404
0
    return x->type;
405
0
}
406
407
const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x)
408
112k
{
409
112k
    return x->data;
410
112k
}
411
412
# if OPENSSL_API_COMPAT < 0x10100000L
413
unsigned char *ASN1_STRING_data(ASN1_STRING *x)
414
0
{
415
0
    return x->data;
416
0
}
417
#endif