1/*
2 * Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * 3. Neither the name of the Institute nor the names of its contributors
20 *    may be used to endorse or promote products derived from this software
21 *    without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36#include "der_locl.h"
37#include <com_err.h>
38#include <sys/types.h>
39#include <sys/stat.h>
40#include <getarg.h>
41#include <err.h>
42#include <der.h>
43
44static int indent_flag = 1;
45static int inner_flag = 0;
46
47static unsigned long indefinite_form_loop;
48static unsigned long indefinite_form_loop_max = 10000;
49
50static size_t
51loop (unsigned char *buf, size_t len, int indent)
52{
53    unsigned char *start_buf = buf;
54
55    while (len > 0) {
56	int ret;
57	Der_class class;
58	Der_type type;
59	unsigned int tag;
60	size_t sz;
61	size_t length;
62	size_t loop_length = 0;
63	int end_tag = 0;
64	const char *tagname;
65
66	ret = der_get_tag (buf, len, &class, &type, &tag, &sz);
67	if (ret)
68	    errx (1, "der_get_tag: %s", error_message (ret));
69	if (sz > len)
70	    errx (1, "unreasonable length (%u) > %u",
71		  (unsigned)sz, (unsigned)len);
72	buf += sz;
73	len -= sz;
74	if (indent_flag) {
75	    int i;
76	    for (i = 0; i < indent; ++i)
77		printf (" ");
78	}
79	printf ("%s %s ", der_get_class_name(class), der_get_type_name(type));
80	tagname = der_get_tag_name(tag);
81	if (class == ASN1_C_UNIV && tagname != NULL)
82	    printf ("%s = ", tagname);
83	else
84	    printf ("tag %d = ", tag);
85	ret = der_get_length (buf, len, &length, &sz);
86	if (ret)
87	    errx (1, "der_get_tag: %s", error_message (ret));
88	if (sz > len)
89	    errx (1, "unreasonable tag length (%u) > %u",
90		  (unsigned)sz, (unsigned)len);
91	buf += sz;
92	len -= sz;
93	if (length == ASN1_INDEFINITE) {
94	    if ((class == ASN1_C_UNIV && type == PRIM && tag == UT_OctetString) ||
95		(class == ASN1_C_CONTEXT && type == CONS) ||
96		(class == ASN1_C_UNIV && type == CONS && tag == UT_Sequence) ||
97		(class == ASN1_C_UNIV && type == CONS && tag == UT_Set)) {
98		printf("*INDEFINITE FORM*");
99	    } else {
100		fflush(stdout);
101		errx(1, "indef form used on unsupported object");
102	    }
103	    end_tag = 1;
104	    if (indefinite_form_loop > indefinite_form_loop_max)
105		errx(1, "indefinite form used recursively more then %lu "
106		     "times, aborting", indefinite_form_loop_max);
107	    indefinite_form_loop++;
108	    length = len;
109	} else if (length > len) {
110	    printf("\n");
111	    fflush(stdout);
112	    errx (1, "unreasonable inner length (%u) > %u",
113		  (unsigned)length, (unsigned)len);
114	}
115	if (class == ASN1_C_CONTEXT || class == ASN1_C_APPL) {
116	    printf ("%lu bytes [%u]", (unsigned long)length, tag);
117	    if (type == CONS) {
118		printf("\n");
119		loop_length = loop (buf, length, indent + 2);
120	    } else {
121		printf(" IMPLICIT content\n");
122	    }
123	} else if (class == ASN1_C_UNIV) {
124	    switch (tag) {
125	    case UT_EndOfContent:
126		printf (" INDEFINITE length was %lu\n",
127			(unsigned long)(buf - start_buf));
128		break;
129	    case UT_Set :
130	    case UT_Sequence :
131		printf ("%lu bytes {\n", (unsigned long)length);
132		loop_length = loop (buf, length, indent + 2);
133		if (indent_flag) {
134		    int i;
135		    for (i = 0; i < indent; ++i)
136			printf (" ");
137		    printf ("}\n");
138		} else
139		    printf ("} indent = %d\n", indent / 2);
140		break;
141	    case UT_Integer : {
142		int val;
143
144		if (length <= sizeof(val)) {
145		    ret = der_get_integer (buf, length, &val, NULL);
146		    if (ret)
147			errx (1, "der_get_integer: %s", error_message (ret));
148		    printf ("integer %d\n", val);
149		} else {
150		    heim_integer vali;
151		    char *p;
152
153		    ret = der_get_heim_integer(buf, length, &vali, NULL);
154		    if (ret)
155			errx (1, "der_get_heim_integer: %s",
156			      error_message (ret));
157		    ret = der_print_hex_heim_integer(&vali, &p);
158		    if (ret)
159			errx (1, "der_print_hex_heim_integer: %s",
160			      error_message (ret));
161		    printf ("BIG NUM integer: length %lu %s\n",
162			    (unsigned long)length, p);
163		    free(p);
164		}
165		break;
166	    }
167	    case UT_OctetString : {
168		heim_octet_string str;
169		size_t i;
170
171		ret = der_get_octet_string (buf, length, &str, NULL);
172		if (ret)
173		    errx (1, "der_get_octet_string: %s", error_message (ret));
174		printf ("(length %lu), ", (unsigned long)length);
175
176		if (inner_flag) {
177		    Der_class class;
178		    Der_type type;
179		    unsigned int tag;
180
181		    ret = der_get_tag(str.data, str.length,
182				      &class, &type, &tag, &sz);
183		    if (ret || sz > str.length ||
184			type != CONS || tag != UT_Sequence)
185			goto just_an_octet_string;
186
187		    printf("{\n");
188		    loop (str.data, str.length, indent + 2);
189		    for (i = 0; i < indent; ++i)
190			printf (" ");
191		    printf ("}\n");
192
193		} else {
194		    unsigned char *uc;
195
196		just_an_octet_string:
197		    uc = (unsigned char *)str.data;
198		    for (i = 0; i < min(16,length); ++i)
199			printf ("%02x", uc[i]);
200		    printf ("\n");
201		}
202		free (str.data);
203		break;
204	    }
205	    case UT_IA5String :
206	    case UT_PrintableString : {
207		heim_printable_string str;
208		unsigned char *s;
209		size_t n;
210
211		memset(&str, 0, sizeof(str));
212
213		ret = der_get_printable_string (buf, length, &str, NULL);
214		if (ret)
215		    errx (1, "der_get_general_string: %s",
216			  error_message (ret));
217		s = str.data;
218		printf("\"");
219		for (n = 0; n < str.length; n++) {
220		    if (isprint((int)s[n]))
221			printf ("%c", s[n]);
222		    else
223			printf ("#%02x", s[n]);
224		}
225		printf("\"\n");
226		der_free_printable_string(&str);
227		break;
228	    }
229	    case UT_GeneralizedTime :
230	    case UT_GeneralString :
231	    case UT_VisibleString :
232	    case UT_UTF8String : {
233		heim_general_string str;
234
235		ret = der_get_general_string (buf, length, &str, NULL);
236		if (ret)
237		    errx (1, "der_get_general_string: %s",
238			  error_message (ret));
239		printf ("\"%s\"\n", str);
240		free (str);
241		break;
242	    }
243	    case UT_OID: {
244		heim_oid o;
245		char *p;
246
247		ret = der_get_oid(buf, length, &o, NULL);
248		if (ret)
249		    errx (1, "der_get_oid: %s", error_message (ret));
250		ret = der_print_heim_oid(&o, '.', &p);
251		der_free_oid(&o);
252		if (ret)
253		    errx (1, "der_print_heim_oid: %s", error_message (ret));
254		printf("%s\n", p);
255		free(p);
256
257		break;
258	    }
259	    case UT_Enumerated: {
260		int num;
261
262		ret = der_get_integer (buf, length, &num, NULL);
263		if (ret)
264		    errx (1, "der_get_enum: %s", error_message (ret));
265
266		printf("%u\n", num);
267		break;
268	    }
269	    default :
270		printf ("%lu bytes\n", (unsigned long)length);
271		break;
272	    }
273	}
274	if (end_tag) {
275	    if (loop_length == 0)
276		errx(1, "zero length INDEFINITE data ? indent = %d\n",
277		     indent / 2);
278	    if (loop_length < length)
279		length = loop_length;
280	    if (indefinite_form_loop == 0)
281		errx(1, "internal error in indefinite form loop detection");
282	    indefinite_form_loop--;
283	} else if (loop_length)
284	    errx(1, "internal error for INDEFINITE form");
285	buf += length;
286	len -= length;
287    }
288    return 0;
289}
290
291static int
292doit (const char *filename)
293{
294    int fd = open (filename, O_RDONLY);
295    struct stat sb;
296    unsigned char *buf;
297    size_t len;
298    int ret;
299
300    if(fd < 0)
301	err (1, "opening %s for read", filename);
302    if (fstat (fd, &sb) < 0)
303	err (1, "stat %s", filename);
304    len = sb.st_size;
305    buf = emalloc (len);
306    if (read (fd, buf, len) != len)
307	errx (1, "read failed");
308    close (fd);
309    ret = loop (buf, len, 0);
310    free (buf);
311    return ret;
312}
313
314
315static int version_flag;
316static int help_flag;
317struct getargs args[] = {
318    { "indent", 0, arg_negative_flag, &indent_flag },
319    { "inner", 0, arg_flag, &inner_flag, "try to parse inner structures of OCTET STRING" },
320    { "version", 0, arg_flag, &version_flag },
321    { "help", 0, arg_flag, &help_flag }
322};
323int num_args = sizeof(args) / sizeof(args[0]);
324
325static void
326usage(int code)
327{
328    arg_printusage(args, num_args, NULL, "dump-file");
329    exit(code);
330}
331
332int
333main(int argc, char **argv)
334{
335    int optidx = 0;
336
337    setprogname (argv[0]);
338    initialize_asn1_error_table ();
339    if(getarg(args, num_args, argc, argv, &optidx))
340	usage(1);
341    if(help_flag)
342	usage(0);
343    if(version_flag) {
344	print_version(NULL);
345	exit(0);
346    }
347    argv += optidx;
348    argc -= optidx;
349    if (argc != 1)
350	usage (1);
351    return doit (argv[0]);
352}
353