GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: lib/libcrypto/crypto/../../libssl/src/crypto/asn1/asn1_lib.c Lines: 131 237 55.3 %
Date: 2016-12-06 Branches: 53 138 38.4 %

Line Branch Exec Source
1
/* $OpenBSD: asn1_lib.c,v 1.37 2016/03/06 18:05:00 beck 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 <limits.h>
60
#include <stdio.h>
61
#include <string.h>
62
63
#include <openssl/asn1.h>
64
#include <openssl/err.h>
65
66
static int asn1_get_length(const unsigned char **pp, int *inf, long *rl, int max);
67
static void asn1_put_length(unsigned char **pp, int length);
68
69
static int
70
_asn1_check_infinite_end(const unsigned char **p, long len)
71
{
72
	/* If there is 0 or 1 byte left, the length check should pick
73
	 * things up */
74
	if (len <= 0)
75
		return (1);
76
	else if ((len >= 2) && ((*p)[0] == 0) && ((*p)[1] == 0)) {
77
		(*p) += 2;
78
		return (1);
79
	}
80
	return (0);
81
}
82
83
int
84
ASN1_check_infinite_end(unsigned char **p, long len)
85
{
86
	return _asn1_check_infinite_end((const unsigned char **)p, len);
87
}
88
89
int
90
ASN1_const_check_infinite_end(const unsigned char **p, long len)
91
{
92
	return _asn1_check_infinite_end(p, len);
93
}
94
95
int
96
ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
97
    int *pclass, long omax)
98
12961
{
99
	int i, ret;
100
	long l;
101
12961
	const unsigned char *p= *pp;
102
	int tag, xclass, inf;
103
12961
	long max = omax;
104
105
12961
	if (!max)
106
		goto err;
107
12961
	ret = (*p & V_ASN1_CONSTRUCTED);
108
12961
	xclass = (*p & V_ASN1_PRIVATE);
109
12961
	i= *p & V_ASN1_PRIMITIVE_TAG;
110
12961
	if (i == V_ASN1_PRIMITIVE_TAG) {		/* high-tag */
111
		p++;
112
		if (--max == 0)
113
			goto err;
114
		l = 0;
115
		while (*p & 0x80) {
116
			l <<= 7L;
117
			l |= *(p++) & 0x7f;
118
			if (--max == 0)
119
				goto err;
120
			if (l > (INT_MAX >> 7L))
121
				goto err;
122
		}
123
		l <<= 7L;
124
		l |= *(p++) & 0x7f;
125
		tag = (int)l;
126
		if (--max == 0)
127
			goto err;
128
	} else {
129
12961
		tag = i;
130
12961
		p++;
131
12961
		if (--max == 0)
132
			goto err;
133
	}
134
12961
	*ptag = tag;
135
12961
	*pclass = xclass;
136
12961
	if (!asn1_get_length(&p, &inf, plength, (int)max))
137
		goto err;
138
139

12961
	if (inf && !(ret & V_ASN1_CONSTRUCTED))
140
		goto err;
141
142
12961
	if (*plength > (omax - (p - *pp))) {
143
76
		ASN1err(ASN1_F_ASN1_GET_OBJECT, ASN1_R_TOO_LONG);
144
		/* Set this so that even if things are not long enough
145
		 * the values are set correctly */
146
76
		ret |= 0x80;
147
	}
148
12961
	*pp = p;
149
12961
	return (ret | inf);
150
151
err:
152
	ASN1err(ASN1_F_ASN1_GET_OBJECT, ASN1_R_HEADER_TOO_LONG);
153
	return (0x80);
154
}
155
156
static int
157
asn1_get_length(const unsigned char **pp, int *inf, long *rl, int max)
158
12961
{
159
12961
	const unsigned char *p= *pp;
160
12961
	unsigned long ret = 0;
161
	unsigned int i;
162
163
12961
	if (max-- < 1)
164
		return (0);
165
12961
	if (*p == 0x80) {
166
		*inf = 1;
167
		ret = 0;
168
		p++;
169
	} else {
170
12961
		*inf = 0;
171
12961
		i= *p & 0x7f;
172
12961
		if (*(p++) & 0x80) {
173
1168
			if (max < (int)i)
174
				return (0);
175
			/* skip leading zeroes */
176

1168
			while (i && *p == 0) {
177
				p++;
178
				i--;
179
			}
180
1168
			if (i > sizeof(long))
181
				return 0;
182
3134
			while (i-- > 0) {
183
1966
				ret <<= 8L;
184
1966
				ret |= *(p++);
185
			}
186
		} else
187
11793
			ret = i;
188
	}
189
12961
	if (ret > LONG_MAX)
190
		return 0;
191
12961
	*pp = p;
192
12961
	*rl = (long)ret;
193
12961
	return (1);
194
}
195
196
/* class 0 is constructed
197
 * constructed == 2 for indefinite length constructed */
198
void
199
ASN1_put_object(unsigned char **pp, int constructed, int length, int tag,
200
    int xclass)
201
7579
{
202
7579
	unsigned char *p= *pp;
203
	int i, ttag;
204
205
7579
	i = (constructed) ? V_ASN1_CONSTRUCTED : 0;
206
7579
	i |= (xclass & V_ASN1_PRIVATE);
207
7579
	if (tag < 31)
208
7579
		*(p++) = i | (tag & V_ASN1_PRIMITIVE_TAG);
209
	else {
210
		*(p++) = i | V_ASN1_PRIMITIVE_TAG;
211
		for(i = 0, ttag = tag; ttag > 0; i++)
212
			ttag >>= 7;
213
		ttag = i;
214
		while (i-- > 0) {
215
			p[i] = tag & 0x7f;
216
			if (i != (ttag - 1))
217
				p[i] |= 0x80;
218
			tag >>= 7;
219
		}
220
		p += ttag;
221
	}
222
7579
	if (constructed == 2)
223
		*(p++) = 0x80;
224
	else
225
7579
		asn1_put_length(&p, length);
226
7579
	*pp = p;
227
7579
}
228
229
int
230
ASN1_put_eoc(unsigned char **pp)
231
{
232
	unsigned char *p = *pp;
233
234
	*p++ = 0;
235
	*p++ = 0;
236
	*pp = p;
237
	return 2;
238
}
239
240
static void
241
asn1_put_length(unsigned char **pp, int length)
242
7579
{
243
7579
	unsigned char *p= *pp;
244
245
	int i, l;
246
7579
	if (length <= 127)
247
7455
		*(p++) = (unsigned char)length;
248
	else {
249
124
		l = length;
250
300
		for (i = 0; l > 0; i++)
251
176
			l >>= 8;
252
124
		*(p++) = i | 0x80;
253
124
		l = i;
254
424
		while (i-- > 0) {
255
176
			p[i] = length & 0xff;
256
176
			length >>= 8;
257
		}
258
124
		p += l;
259
	}
260
7579
	*pp = p;
261
7579
}
262
263
int
264
ASN1_object_size(int constructed, int length, int tag)
265
23542
{
266
	int ret;
267
268
23542
	ret = length;
269
23542
	ret++;
270
23542
	if (tag >= 31) {
271
		while (tag > 0) {
272
			tag >>= 7;
273
			ret++;
274
		}
275
	}
276
23542
	if (constructed == 2)
277
		return ret + 3;
278
23542
	ret++;
279
23542
	if (length > 127) {
280
990
		while (length > 0) {
281
604
			length >>= 8;
282
604
			ret++;
283
		}
284
	}
285
23542
	return (ret);
286
}
287
288
static int
289
_asn1_Finish(ASN1_const_CTX *c)
290
{
291
	if ((c->inf == (1|V_ASN1_CONSTRUCTED)) && (!c->eos)) {
292
		if (!ASN1_const_check_infinite_end(&c->p, c->slen)) {
293
			c->error = ERR_R_MISSING_ASN1_EOS;
294
			return (0);
295
		}
296
	}
297
	if (((c->slen != 0) && !(c->inf & 1)) ||
298
	    ((c->slen < 0) && (c->inf & 1))) {
299
		c->error = ERR_R_ASN1_LENGTH_MISMATCH;
300
		return (0);
301
	}
302
	return (1);
303
}
304
305
int
306
asn1_Finish(ASN1_CTX *c)
307
{
308
	return _asn1_Finish((ASN1_const_CTX *)c);
309
}
310
311
int
312
asn1_const_Finish(ASN1_const_CTX *c)
313
{
314
	return _asn1_Finish(c);
315
}
316
317
int
318
asn1_GetSequence(ASN1_const_CTX *c, long *length)
319
{
320
	const unsigned char *q;
321
322
	q = c->p;
323
	c->inf = ASN1_get_object(&(c->p), &(c->slen), &(c->tag), &(c->xclass),
324
	    *length);
325
	if (c->inf & 0x80) {
326
		c->error = ERR_R_BAD_GET_ASN1_OBJECT_CALL;
327
		return (0);
328
	}
329
	if (c->tag != V_ASN1_SEQUENCE) {
330
		c->error = ERR_R_EXPECTING_AN_ASN1_SEQUENCE;
331
		return (0);
332
	}
333
	(*length) -= (c->p - q);
334
	if (c->max && (*length < 0)) {
335
		c->error = ERR_R_ASN1_LENGTH_MISMATCH;
336
		return (0);
337
	}
338
	if (c->inf == (1|V_ASN1_CONSTRUCTED))
339
		c->slen= *length+ *(c->pp) - c->p;
340
	c->eos = 0;
341
	return (1);
342
}
343
344
int
345
ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str)
346
13
{
347
13
	if (str == NULL)
348
		return 0;
349
13
	dst->type = str->type;
350
13
	if (!ASN1_STRING_set(dst, str->data, str->length))
351
		return 0;
352
13
	dst->flags = str->flags;
353
13
	return 1;
354
}
355
356
ASN1_STRING *
357
ASN1_STRING_dup(const ASN1_STRING *str)
358
13
{
359
	ASN1_STRING *ret;
360
361
13
	if (!str)
362
		return NULL;
363
13
	ret = ASN1_STRING_new();
364
13
	if (!ret)
365
		return NULL;
366
13
	if (!ASN1_STRING_copy(ret, str)) {
367
		ASN1_STRING_free(ret);
368
		return NULL;
369
	}
370
13
	return ret;
371
}
372
373
int
374
ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)
375
2477
{
376
2477
	const char *data = _data;
377
378
2477
	if (len < 0) {
379
		if (data == NULL)
380
			return (0);
381
		else
382
			len = strlen(data);
383
	}
384

2477
	if ((str->length < len) || (str->data == NULL)) {
385
		unsigned char *tmp;
386
2471
		tmp = realloc(str->data, len + 1);
387
2471
		if (tmp == NULL) {
388
			ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);
389
			return (0);
390
		}
391
2471
		str->data = tmp;
392
	}
393
2477
	str->length = len;
394
2477
	if (data != NULL) {
395
2477
		memmove(str->data, data, len);
396
	}
397
2477
	str->data[str->length]='\0';
398
2477
	return (1);
399
}
400
401
void
402
ASN1_STRING_set0(ASN1_STRING *str, void *data, int len)
403
5
{
404
5
	if (str->data != NULL)
405
		explicit_bzero(str->data, str->length);
406
5
	free(str->data);
407
5
	str->data = data;
408
5
	str->length = len;
409
5
}
410
411
ASN1_STRING *
412
ASN1_STRING_new(void)
413
15
{
414
15
	return (ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
415
}
416
417
ASN1_STRING *
418
ASN1_STRING_type_new(int type)
419
4501
{
420
	ASN1_STRING *ret;
421
422
4501
	ret = malloc(sizeof(ASN1_STRING));
423
4501
	if (ret == NULL) {
424
		ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);
425
		return (NULL);
426
	}
427
4501
	ret->length = 0;
428
4501
	ret->type = type;
429
4501
	ret->data = NULL;
430
4501
	ret->flags = 0;
431
4501
	return (ret);
432
}
433
434
void
435
ASN1_STRING_free(ASN1_STRING *a)
436
1561
{
437
1561
	if (a == NULL)
438
		return;
439

1561
	if (a->data != NULL && !(a->flags & ASN1_STRING_FLAG_NDEF)) {
440
1471
		explicit_bzero(a->data, a->length);
441
1471
		free(a->data);
442
	}
443
1561
	free(a);
444
}
445
446
int
447
ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b)
448
16
{
449
	int i;
450
451
16
	i = (a->length - b->length);
452
16
	if (i == 0) {
453
16
		i = memcmp(a->data, b->data, a->length);
454
16
		if (i == 0)
455
16
			return (a->type - b->type);
456
		else
457
			return (i);
458
	} else
459
		return (i);
460
}
461
462
void
463
asn1_add_error(const unsigned char *address, int offset)
464
{
465
	ERR_asprintf_error_data("offset=%d", offset);
466
}
467
468
int
469
ASN1_STRING_length(const ASN1_STRING *x)
470
1
{
471
1
	return (x->length);
472
}
473
474
void
475
ASN1_STRING_length_set(ASN1_STRING *x, int len)
476
{
477
	x->length = len;
478
}
479
480
int
481
ASN1_STRING_type(ASN1_STRING *x)
482
{
483
	return (x->type);
484
}
485
486
unsigned char *
487
ASN1_STRING_data(ASN1_STRING *x)
488
1
{
489
1
	return (x->data);
490
}