1 /* crypto/asn1/asn1_lib.c */
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 #include <limits.h>
61 #include "cryptlib.h"
62 #include <openssl/asn1.h>
63 #include <openssl/asn1_mac.h>
64
65 static int asn1_get_length(const unsigned char **pp, int *inf, long *rl,
66 int max);
67 static void asn1_put_length(unsigned char **pp, int length);
68 const char ASN1_version[] = "ASN.1" OPENSSL_VERSION_PTEXT;
69
_asn1_check_infinite_end(const unsigned char ** p,long len)70 static int _asn1_check_infinite_end(const unsigned char **p, long len)
71 {
72 /*
73 * If there is 0 or 1 byte left, the length check should pick things up
74 */
75 if (len <= 0)
76 return (1);
77 else if ((len >= 2) && ((*p)[0] == 0) && ((*p)[1] == 0)) {
78 (*p) += 2;
79 return (1);
80 }
81 return (0);
82 }
83
ASN1_check_infinite_end(unsigned char ** p,long len)84 int ASN1_check_infinite_end(unsigned char **p, long len)
85 {
86 return _asn1_check_infinite_end((const unsigned char **)p, len);
87 }
88
ASN1_const_check_infinite_end(const unsigned char ** p,long len)89 int ASN1_const_check_infinite_end(const unsigned char **p, long len)
90 {
91 return _asn1_check_infinite_end(p, len);
92 }
93
ASN1_get_object(const unsigned char ** pp,long * plength,int * ptag,int * pclass,long omax)94 int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
95 int *pclass, long omax)
96 {
97 int i, ret;
98 long l;
99 const unsigned char *p = *pp;
100 int tag, xclass, inf;
101 long max = omax;
102
103 if (!max)
104 goto err;
105 ret = (*p & V_ASN1_CONSTRUCTED);
106 xclass = (*p & V_ASN1_PRIVATE);
107 i = *p & V_ASN1_PRIMITIVE_TAG;
108 if (i == V_ASN1_PRIMITIVE_TAG) { /* high-tag */
109 p++;
110 if (--max == 0)
111 goto err;
112 l = 0;
113 while (*p & 0x80) {
114 l <<= 7L;
115 l |= *(p++) & 0x7f;
116 if (--max == 0)
117 goto err;
118 if (l > (INT_MAX >> 7L))
119 goto err;
120 }
121 l <<= 7L;
122 l |= *(p++) & 0x7f;
123 tag = (int)l;
124 if (--max == 0)
125 goto err;
126 } else {
127 tag = i;
128 p++;
129 if (--max == 0)
130 goto err;
131 }
132 *ptag = tag;
133 *pclass = xclass;
134 if (!asn1_get_length(&p, &inf, plength, (int)max))
135 goto err;
136
137 if (inf && !(ret & V_ASN1_CONSTRUCTED))
138 goto err;
139
140 #if 0
141 fprintf(stderr, "p=%d + *plength=%ld > omax=%ld + *pp=%d (%d > %d)\n",
142 (int)p, *plength, omax, (int)*pp, (int)(p + *plength),
143 (int)(omax + *pp));
144
145 #endif
146 if (*plength > (omax - (p - *pp))) {
147 ASN1err(ASN1_F_ASN1_GET_OBJECT, ASN1_R_TOO_LONG);
148 /*
149 * Set this so that even if things are not long enough the values are
150 * set correctly
151 */
152 ret |= 0x80;
153 }
154 *pp = p;
155 return (ret | inf);
156 err:
157 ASN1err(ASN1_F_ASN1_GET_OBJECT, ASN1_R_HEADER_TOO_LONG);
158 return (0x80);
159 }
160
asn1_get_length(const unsigned char ** pp,int * inf,long * rl,int max)161 static int asn1_get_length(const unsigned char **pp, int *inf, long *rl,
162 int max)
163 {
164 const unsigned char *p = *pp;
165 unsigned long ret = 0;
166 unsigned int i;
167
168 if (max-- < 1)
169 return (0);
170 if (*p == 0x80) {
171 *inf = 1;
172 ret = 0;
173 p++;
174 } else {
175 *inf = 0;
176 i = *p & 0x7f;
177 if (*(p++) & 0x80) {
178 if (i > sizeof(long))
179 return 0;
180 if (max-- == 0)
181 return (0);
182 while (i-- > 0) {
183 ret <<= 8L;
184 ret |= *(p++);
185 if (max-- == 0)
186 return (0);
187 }
188 } else
189 ret = i;
190 }
191 if (ret > LONG_MAX)
192 return 0;
193 *pp = p;
194 *rl = (long)ret;
195 return (1);
196 }
197
198 /*
199 * class 0 is constructed constructed == 2 for indefinite length constructed
200 */
ASN1_put_object(unsigned char ** pp,int constructed,int length,int tag,int xclass)201 void ASN1_put_object(unsigned char **pp, int constructed, int length, int tag,
202 int xclass)
203 {
204 unsigned char *p = *pp;
205 int i, ttag;
206
207 i = (constructed) ? V_ASN1_CONSTRUCTED : 0;
208 i |= (xclass & V_ASN1_PRIVATE);
209 if (tag < 31)
210 *(p++) = i | (tag & V_ASN1_PRIMITIVE_TAG);
211 else {
212 *(p++) = i | V_ASN1_PRIMITIVE_TAG;
213 for (i = 0, ttag = tag; ttag > 0; i++)
214 ttag >>= 7;
215 ttag = i;
216 while (i-- > 0) {
217 p[i] = tag & 0x7f;
218 if (i != (ttag - 1))
219 p[i] |= 0x80;
220 tag >>= 7;
221 }
222 p += ttag;
223 }
224 if (constructed == 2)
225 *(p++) = 0x80;
226 else
227 asn1_put_length(&p, length);
228 *pp = p;
229 }
230
ASN1_put_eoc(unsigned char ** pp)231 int ASN1_put_eoc(unsigned char **pp)
232 {
233 unsigned char *p = *pp;
234 *p++ = 0;
235 *p++ = 0;
236 *pp = p;
237 return 2;
238 }
239
asn1_put_length(unsigned char ** pp,int length)240 static void asn1_put_length(unsigned char **pp, int length)
241 {
242 unsigned char *p = *pp;
243 int i, l;
244 if (length <= 127)
245 *(p++) = (unsigned char)length;
246 else {
247 l = length;
248 for (i = 0; l > 0; i++)
249 l >>= 8;
250 *(p++) = i | 0x80;
251 l = i;
252 while (i-- > 0) {
253 p[i] = length & 0xff;
254 length >>= 8;
255 }
256 p += l;
257 }
258 *pp = p;
259 }
260
ASN1_object_size(int constructed,int length,int tag)261 int ASN1_object_size(int constructed, int length, int tag)
262 {
263 int ret;
264
265 ret = length;
266 ret++;
267 if (tag >= 31) {
268 while (tag > 0) {
269 tag >>= 7;
270 ret++;
271 }
272 }
273 if (constructed == 2)
274 return ret + 3;
275 ret++;
276 if (length > 127) {
277 while (length > 0) {
278 length >>= 8;
279 ret++;
280 }
281 }
282 return (ret);
283 }
284
_asn1_Finish(ASN1_const_CTX * c)285 static int _asn1_Finish(ASN1_const_CTX *c)
286 {
287 if ((c->inf == (1 | V_ASN1_CONSTRUCTED)) && (!c->eos)) {
288 if (!ASN1_const_check_infinite_end(&c->p, c->slen)) {
289 c->error = ERR_R_MISSING_ASN1_EOS;
290 return (0);
291 }
292 }
293 if (((c->slen != 0) && !(c->inf & 1)) || ((c->slen < 0) && (c->inf & 1))) {
294 c->error = ERR_R_ASN1_LENGTH_MISMATCH;
295 return (0);
296 }
297 return (1);
298 }
299
asn1_Finish(ASN1_CTX * c)300 int asn1_Finish(ASN1_CTX *c)
301 {
302 return _asn1_Finish((ASN1_const_CTX *)c);
303 }
304
asn1_const_Finish(ASN1_const_CTX * c)305 int asn1_const_Finish(ASN1_const_CTX *c)
306 {
307 return _asn1_Finish(c);
308 }
309
asn1_GetSequence(ASN1_const_CTX * c,long * length)310 int asn1_GetSequence(ASN1_const_CTX *c, long *length)
311 {
312 const unsigned char *q;
313
314 q = c->p;
315 c->inf = ASN1_get_object(&(c->p), &(c->slen), &(c->tag), &(c->xclass),
316 *length);
317 if (c->inf & 0x80) {
318 c->error = ERR_R_BAD_GET_ASN1_OBJECT_CALL;
319 return (0);
320 }
321 if (c->tag != V_ASN1_SEQUENCE) {
322 c->error = ERR_R_EXPECTING_AN_ASN1_SEQUENCE;
323 return (0);
324 }
325 (*length) -= (c->p - q);
326 if (c->max && (*length < 0)) {
327 c->error = ERR_R_ASN1_LENGTH_MISMATCH;
328 return (0);
329 }
330 if (c->inf == (1 | V_ASN1_CONSTRUCTED))
331 c->slen = *length + *(c->pp) - c->p;
332 c->eos = 0;
333 return (1);
334 }
335
ASN1_STRING_copy(ASN1_STRING * dst,const ASN1_STRING * str)336 int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str)
337 {
338 if (str == NULL)
339 return 0;
340 dst->type = str->type;
341 if (!ASN1_STRING_set(dst, str->data, str->length))
342 return 0;
343 dst->flags = str->flags;
344 return 1;
345 }
346
ASN1_STRING_dup(const ASN1_STRING * str)347 ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *str)
348 {
349 ASN1_STRING *ret;
350 if (!str)
351 return NULL;
352 ret = ASN1_STRING_new();
353 if (!ret)
354 return NULL;
355 if (!ASN1_STRING_copy(ret, str)) {
356 ASN1_STRING_free(ret);
357 return NULL;
358 }
359 return ret;
360 }
361
ASN1_STRING_set(ASN1_STRING * str,const void * _data,int len)362 int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)
363 {
364 unsigned char *c;
365 const char *data = _data;
366
367 if (len < 0) {
368 if (data == NULL)
369 return (0);
370 else
371 len = strlen(data);
372 }
373 if ((str->length < len) || (str->data == NULL)) {
374 c = str->data;
375 if (c == NULL)
376 str->data = OPENSSL_malloc(len + 1);
377 else
378 str->data = OPENSSL_realloc(c, len + 1);
379
380 if (str->data == NULL) {
381 ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);
382 str->data = c;
383 return (0);
384 }
385 }
386 str->length = len;
387 if (data != NULL) {
388 memcpy(str->data, data, len);
389 /* an allowance for strings :-) */
390 str->data[len] = '\0';
391 }
392 return (1);
393 }
394
ASN1_STRING_set0(ASN1_STRING * str,void * data,int len)395 void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len)
396 {
397 if (str->data)
398 OPENSSL_free(str->data);
399 str->data = data;
400 str->length = len;
401 }
402
ASN1_STRING_new(void)403 ASN1_STRING *ASN1_STRING_new(void)
404 {
405 return (ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
406 }
407
ASN1_STRING_type_new(int type)408 ASN1_STRING *ASN1_STRING_type_new(int type)
409 {
410 ASN1_STRING *ret;
411
412 ret = (ASN1_STRING *)OPENSSL_malloc(sizeof(ASN1_STRING));
413 if (ret == NULL) {
414 ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);
415 return (NULL);
416 }
417 ret->length = 0;
418 ret->type = type;
419 ret->data = NULL;
420 ret->flags = 0;
421 return (ret);
422 }
423
ASN1_STRING_free(ASN1_STRING * a)424 void ASN1_STRING_free(ASN1_STRING *a)
425 {
426 if (a == NULL)
427 return;
428 if (a->data && !(a->flags & ASN1_STRING_FLAG_NDEF))
429 OPENSSL_free(a->data);
430 OPENSSL_free(a);
431 }
432
ASN1_STRING_clear_free(ASN1_STRING * a)433 void ASN1_STRING_clear_free(ASN1_STRING *a)
434 {
435 if (a && a->data && !(a->flags & ASN1_STRING_FLAG_NDEF))
436 OPENSSL_cleanse(a->data, a->length);
437 ASN1_STRING_free(a);
438 }
439
ASN1_STRING_cmp(const ASN1_STRING * a,const ASN1_STRING * b)440 int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b)
441 {
442 int i;
443
444 i = (a->length - b->length);
445 if (i == 0) {
446 i = memcmp(a->data, b->data, a->length);
447 if (i == 0)
448 return (a->type - b->type);
449 else
450 return (i);
451 } else
452 return (i);
453 }
454
asn1_add_error(const unsigned char * address,int offset)455 void asn1_add_error(const unsigned char *address, int offset)
456 {
457 char buf1[DECIMAL_SIZE(address) + 1], buf2[DECIMAL_SIZE(offset) + 1];
458
459 BIO_snprintf(buf1, sizeof buf1, "%lu", (unsigned long)address);
460 BIO_snprintf(buf2, sizeof buf2, "%d", offset);
461 ERR_add_error_data(4, "address=", buf1, " offset=", buf2);
462 }
463
ASN1_STRING_length(const ASN1_STRING * x)464 int ASN1_STRING_length(const ASN1_STRING *x)
465 {
466 return M_ASN1_STRING_length(x);
467 }
468
ASN1_STRING_length_set(ASN1_STRING * x,int len)469 void ASN1_STRING_length_set(ASN1_STRING *x, int len)
470 {
471 M_ASN1_STRING_length_set(x, len);
472 return;
473 }
474
ASN1_STRING_type(ASN1_STRING * x)475 int ASN1_STRING_type(ASN1_STRING *x)
476 {
477 return M_ASN1_STRING_type(x);
478 }
479
ASN1_STRING_data(ASN1_STRING * x)480 unsigned char *ASN1_STRING_data(ASN1_STRING *x)
481 {
482 return M_ASN1_STRING_data(x);
483 }
484