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 44 static int indent_flag = 1; 45 static int inner_flag = 0; 46 47 static unsigned long indefinite_form_loop; 48 static unsigned long indefinite_form_loop_max = 10000; 49 50 static size_t 51 loop (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 291 static int 292 doit (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 315 static int version_flag; 316 static int help_flag; 317 struct 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 }; 323 int num_args = sizeof(args) / sizeof(args[0]); 324 325 static void 326 usage(int code) 327 { 328 arg_printusage(args, num_args, NULL, "dump-file"); 329 exit(code); 330 } 331 332 int 333 main(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