d0de27207a2ede1a756058d73146ba285544d8d9
[openssl.git] / crypto / asn1 / asn1_par.c
1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2  * All rights reserved.
3  *
4  * This package is an SSL implementation written
5  * by Eric Young (eay@cryptsoft.com).
6  * The implementation was written so as to conform with Netscapes SSL.
7  *
8  * This library is free for commercial and non-commercial use as long as
9  * the following conditions are aheared to.  The following conditions
10  * apply to all code found in this distribution, be it the RC4, RSA,
11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12  * included with this distribution is covered by the same copyright terms
13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14  *
15  * Copyright remains Eric Young's, and as such any Copyright notices in
16  * the code are not to be removed.
17  * If this package is used in a product, Eric Young should be given attribution
18  * as the author of the parts of the library used.
19  * This can be in the form of a textual message at program startup or
20  * in documentation (online or textual) provided with the package.
21  *
22  * Redistribution and use in source and binary forms, with or without
23  * modification, are permitted provided that the following conditions
24  * are met:
25  * 1. Redistributions of source code must retain the copyright
26  *    notice, this list of conditions and the following disclaimer.
27  * 2. Redistributions in binary form must reproduce the above copyright
28  *    notice, this list of conditions and the following disclaimer in the
29  *    documentation and/or other materials provided with the distribution.
30  * 3. All advertising materials mentioning features or use of this software
31  *    must display the following acknowledgement:
32  *    "This product includes cryptographic software written by
33  *     Eric Young (eay@cryptsoft.com)"
34  *    The word 'cryptographic' can be left out if the rouines from the library
35  *    being used are not cryptographic related :-).
36  * 4. If you include any Windows specific code (or a derivative thereof) from
37  *    the apps directory (application code) you must include an acknowledgement:
38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50  * SUCH DAMAGE.
51  *
52  * The licence and distribution terms for any publically available version or
53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
54  * copied and put under another distribution licence
55  * [including the GNU Public Licence.]
56  */
57
58 #include <stdio.h>
59 #include "internal/cryptlib.h"
60 #include <openssl/buffer.h>
61 #include <openssl/objects.h>
62 #include <openssl/asn1.h>
63
64 #ifndef ASN1_PARSE_MAXDEPTH
65 #define ASN1_PARSE_MAXDEPTH 128
66 #endif
67
68 static int asn1_print_info(BIO *bp, int tag, int xclass, int constructed,
69                            int indent);
70 static int asn1_parse2(BIO *bp, const unsigned char **pp, long length,
71                        int offset, int depth, int indent, int dump);
72 static int asn1_print_info(BIO *bp, int tag, int xclass, int constructed,
73                            int indent)
74 {
75     static const char fmt[] = "%-18s";
76     char str[128];
77     const char *p;
78
79     if (constructed & V_ASN1_CONSTRUCTED)
80         p = "cons: ";
81     else
82         p = "prim: ";
83     if (BIO_write(bp, p, 6) < 6)
84         goto err;
85     BIO_indent(bp, indent, 128);
86
87     p = str;
88     if ((xclass & V_ASN1_PRIVATE) == V_ASN1_PRIVATE)
89         BIO_snprintf(str, sizeof str, "priv [ %d ] ", tag);
90     else if ((xclass & V_ASN1_CONTEXT_SPECIFIC) == V_ASN1_CONTEXT_SPECIFIC)
91         BIO_snprintf(str, sizeof str, "cont [ %d ]", tag);
92     else if ((xclass & V_ASN1_APPLICATION) == V_ASN1_APPLICATION)
93         BIO_snprintf(str, sizeof str, "appl [ %d ]", tag);
94     else if (tag > 30)
95         BIO_snprintf(str, sizeof str, "<ASN1 %d>", tag);
96     else
97         p = ASN1_tag2str(tag);
98
99     if (BIO_printf(bp, fmt, p) <= 0)
100         goto err;
101     return (1);
102  err:
103     return (0);
104 }
105
106 int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent)
107 {
108     return (asn1_parse2(bp, &pp, len, 0, 0, indent, 0));
109 }
110
111 int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent,
112                     int dump)
113 {
114     return (asn1_parse2(bp, &pp, len, 0, 0, indent, dump));
115 }
116
117 static int asn1_parse2(BIO *bp, const unsigned char **pp, long length,
118                        int offset, int depth, int indent, int dump)
119 {
120     const unsigned char *p, *ep, *tot, *op, *opp;
121     long len;
122     int tag, xclass, ret = 0;
123     int nl, hl, j, r;
124     ASN1_OBJECT *o = NULL;
125     ASN1_OCTET_STRING *os = NULL;
126     /* ASN1_BMPSTRING *bmp=NULL; */
127     int dump_indent, dump_cont = 0;
128
129     if (depth > ASN1_PARSE_MAXDEPTH) {
130             BIO_puts(bp, "BAD RECURSION DEPTH\n");
131             return 0;
132     }
133
134     dump_indent = 6;            /* Because we know BIO_dump_indent() */
135     p = *pp;
136     tot = p + length;
137     op = p - 1;
138     while ((p < tot) && (op < p)) {
139         op = p;
140         j = ASN1_get_object(&p, &len, &tag, &xclass, length);
141         if (j & 0x80) {
142             if (BIO_write(bp, "Error in encoding\n", 18) <= 0)
143                 goto end;
144             ret = 0;
145             goto end;
146         }
147         hl = (p - op);
148         length -= hl;
149         /*
150          * if j == 0x21 it is a constructed indefinite length object
151          */
152         if (BIO_printf(bp, "%5ld:", (long)offset + (long)(op - *pp))
153             <= 0)
154             goto end;
155
156         if (j != (V_ASN1_CONSTRUCTED | 1)) {
157             if (BIO_printf(bp, "d=%-2d hl=%ld l=%4ld ",
158                            depth, (long)hl, len) <= 0)
159                 goto end;
160         } else {
161             if (BIO_printf(bp, "d=%-2d hl=%ld l=inf  ", depth, (long)hl) <= 0)
162                 goto end;
163         }
164         if (!asn1_print_info(bp, tag, xclass, j, (indent) ? depth : 0))
165             goto end;
166         if (j & V_ASN1_CONSTRUCTED) {
167             ep = p + len;
168             if (BIO_write(bp, "\n", 1) <= 0)
169                 goto end;
170             if (len > length) {
171                 BIO_printf(bp, "length is greater than %ld\n", length);
172                 ret = 0;
173                 goto end;
174             }
175             if ((j == 0x21) && (len == 0)) {
176                 for (;;) {
177                     r = asn1_parse2(bp, &p, (long)(tot - p),
178                                     offset + (p - *pp), depth + 1,
179                                     indent, dump);
180                     if (r == 0) {
181                         ret = 0;
182                         goto end;
183                     }
184                     if ((r == 2) || (p >= tot))
185                         break;
186                 }
187             } else
188                 while (p < ep) {
189                     r = asn1_parse2(bp, &p, (long)len,
190                                     offset + (p - *pp), depth + 1,
191                                     indent, dump);
192                     if (r == 0) {
193                         ret = 0;
194                         goto end;
195                     }
196                 }
197         } else if (xclass != 0) {
198             p += len;
199             if (BIO_write(bp, "\n", 1) <= 0)
200                 goto end;
201         } else {
202             nl = 0;
203             if ((tag == V_ASN1_PRINTABLESTRING) ||
204                 (tag == V_ASN1_T61STRING) ||
205                 (tag == V_ASN1_IA5STRING) ||
206                 (tag == V_ASN1_VISIBLESTRING) ||
207                 (tag == V_ASN1_NUMERICSTRING) ||
208                 (tag == V_ASN1_UTF8STRING) ||
209                 (tag == V_ASN1_UTCTIME) || (tag == V_ASN1_GENERALIZEDTIME)) {
210                 if (BIO_write(bp, ":", 1) <= 0)
211                     goto end;
212                 if ((len > 0) && BIO_write(bp, (const char *)p, (int)len)
213                     != (int)len)
214                     goto end;
215             } else if (tag == V_ASN1_OBJECT) {
216                 opp = op;
217                 if (d2i_ASN1_OBJECT(&o, &opp, len + hl) != NULL) {
218                     if (BIO_write(bp, ":", 1) <= 0)
219                         goto end;
220                     i2a_ASN1_OBJECT(bp, o);
221                 } else {
222                     if (BIO_write(bp, ":BAD OBJECT", 11) <= 0)
223                         goto end;
224                     dump_cont = 1;
225                 }
226             } else if (tag == V_ASN1_BOOLEAN) {
227                 if (len != 1) {
228                     if (BIO_puts(bp, "BAD BOOLEAN") <= 0)
229                         goto end;
230                     dump_cont = 1;
231                 }
232                 BIO_printf(bp, ":%u", p[0]);
233             } else if (tag == V_ASN1_BMPSTRING) {
234                 /* do the BMP thang */
235             } else if (tag == V_ASN1_OCTET_STRING) {
236                 int i, printable = 1;
237
238                 opp = op;
239                 os = d2i_ASN1_OCTET_STRING(NULL, &opp, len + hl);
240                 if (os != NULL && os->length > 0) {
241                     opp = os->data;
242                     /*
243                      * testing whether the octet string is printable
244                      */
245                     for (i = 0; i < os->length; i++) {
246                         if (((opp[i] < ' ') &&
247                              (opp[i] != '\n') &&
248                              (opp[i] != '\r') &&
249                              (opp[i] != '\t')) || (opp[i] > '~')) {
250                             printable = 0;
251                             break;
252                         }
253                     }
254                     if (printable)
255                         /* printable string */
256                     {
257                         if (BIO_write(bp, ":", 1) <= 0)
258                             goto end;
259                         if (BIO_write(bp, (const char *)opp, os->length) <= 0)
260                             goto end;
261                     } else if (!dump)
262                         /*
263                          * not printable => print octet string as hex dump
264                          */
265                     {
266                         if (BIO_write(bp, "[HEX DUMP]:", 11) <= 0)
267                             goto end;
268                         for (i = 0; i < os->length; i++) {
269                             if (BIO_printf(bp, "%02X", opp[i]) <= 0)
270                                 goto end;
271                         }
272                     } else
273                         /* print the normal dump */
274                     {
275                         if (!nl) {
276                             if (BIO_write(bp, "\n", 1) <= 0)
277                                 goto end;
278                         }
279                         if (BIO_dump_indent(bp,
280                                             (const char *)opp,
281                                             ((dump == -1 || dump >
282                                               os->
283                                               length) ? os->length : dump),
284                                             dump_indent) <= 0)
285                             goto end;
286                         nl = 1;
287                     }
288                 }
289                 ASN1_OCTET_STRING_free(os);
290                 os = NULL;
291             } else if (tag == V_ASN1_INTEGER) {
292                 ASN1_INTEGER *bs;
293                 int i;
294
295                 opp = op;
296                 bs = d2i_ASN1_INTEGER(NULL, &opp, len + hl);
297                 if (bs != NULL) {
298                     if (BIO_write(bp, ":", 1) <= 0)
299                         goto end;
300                     if (bs->type == V_ASN1_NEG_INTEGER)
301                         if (BIO_write(bp, "-", 1) <= 0)
302                             goto end;
303                     for (i = 0; i < bs->length; i++) {
304                         if (BIO_printf(bp, "%02X", bs->data[i]) <= 0)
305                             goto end;
306                     }
307                     if (bs->length == 0) {
308                         if (BIO_write(bp, "00", 2) <= 0)
309                             goto end;
310                     }
311                 } else {
312                     if (BIO_write(bp, "BAD INTEGER", 11) <= 0)
313                         goto end;
314                     dump_cont = 1;
315                 }
316                 ASN1_INTEGER_free(bs);
317             } else if (tag == V_ASN1_ENUMERATED) {
318                 ASN1_ENUMERATED *bs;
319                 int i;
320
321                 opp = op;
322                 bs = d2i_ASN1_ENUMERATED(NULL, &opp, len + hl);
323                 if (bs != NULL) {
324                     if (BIO_write(bp, ":", 1) <= 0)
325                         goto end;
326                     if (bs->type == V_ASN1_NEG_ENUMERATED)
327                         if (BIO_write(bp, "-", 1) <= 0)
328                             goto end;
329                     for (i = 0; i < bs->length; i++) {
330                         if (BIO_printf(bp, "%02X", bs->data[i]) <= 0)
331                             goto end;
332                     }
333                     if (bs->length == 0) {
334                         if (BIO_write(bp, "00", 2) <= 0)
335                             goto end;
336                     }
337                 } else {
338                     if (BIO_write(bp, "BAD ENUMERATED", 14) <= 0)
339                         goto end;
340                     dump_cont = 1;
341                 }
342                 ASN1_ENUMERATED_free(bs);
343             } else if (len > 0 && dump) {
344                 if (!nl) {
345                     if (BIO_write(bp, "\n", 1) <= 0)
346                         goto end;
347                 }
348                 if (BIO_dump_indent(bp, (const char *)p,
349                                     ((dump == -1 || dump > len) ? len : dump),
350                                     dump_indent) <= 0)
351                     goto end;
352                 nl = 1;
353             }
354             if (dump_cont) {
355                 int i;
356                 const unsigned char *tmp = op + hl;
357                 if (BIO_puts(bp, ":[") <= 0)
358                     goto end;
359                 for (i = 0; i < len; i++) {
360                     if (BIO_printf(bp, "%02X", tmp[i]) <= 0)
361                         goto end;
362                 }
363                 if (BIO_puts(bp, "]") <= 0)
364                     goto end;
365             }
366
367             if (!nl) {
368                 if (BIO_write(bp, "\n", 1) <= 0)
369                     goto end;
370             }
371             p += len;
372             if ((tag == V_ASN1_EOC) && (xclass == 0)) {
373                 ret = 2;        /* End of sequence */
374                 goto end;
375             }
376         }
377         length -= len;
378     }
379     ret = 1;
380  end:
381     ASN1_OBJECT_free(o);
382     ASN1_OCTET_STRING_free(os);
383     *pp = p;
384     return (ret);
385 }
386
387 const char *ASN1_tag2str(int tag)
388 {
389     static const char *const tag2str[] = {
390         /* 0-4 */
391         "EOC", "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING",
392         /* 5-9 */
393         "NULL", "OBJECT", "OBJECT DESCRIPTOR", "EXTERNAL", "REAL",
394         /* 10-13 */
395         "ENUMERATED", "<ASN1 11>", "UTF8STRING", "<ASN1 13>",
396         /* 15-17 */
397         "<ASN1 14>", "<ASN1 15>", "SEQUENCE", "SET",
398         /* 18-20 */
399         "NUMERICSTRING", "PRINTABLESTRING", "T61STRING",
400         /* 21-24 */
401         "VIDEOTEXSTRING", "IA5STRING", "UTCTIME", "GENERALIZEDTIME",
402         /* 25-27 */
403         "GRAPHICSTRING", "VISIBLESTRING", "GENERALSTRING",
404         /* 28-30 */
405         "UNIVERSALSTRING", "<ASN1 29>", "BMPSTRING"
406     };
407
408     if ((tag == V_ASN1_NEG_INTEGER) || (tag == V_ASN1_NEG_ENUMERATED))
409         tag &= ~0x100;
410
411     if (tag < 0 || tag > 30)
412         return "(unknown)";
413     return tag2str[tag];
414 }