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