lib/asn1/asn1_print.c

   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 RCSID("$Id$");
  45
  46 static int indent_flag = 1;
  47
  48 static unsigned long indefinite_form_loop;
  49 static unsigned long indefinite_form_loop_max = 10000;
  50
  51 static size_t
  52 loop (unsigned char *buf, size_t len, int indent)
  53 {
  54     unsigned char *start_buf = buf;
  55
  56     while (len > 0) {
  57         int ret;
  58         Der_class class;
  59         Der_type type;
  60         unsigned int tag;
  61         size_t sz;
  62         size_t length;
  63         size_t loop_length = 0;
  64         int end_tag = 0;
  65         const char *tagname;
  66
  67         ret = der_get_tag (buf, len, &class, &type, &tag, &sz);
  68         if (ret)
  69             errx (1, "der_get_tag: %s", error_message (ret));
  70         if (sz > len)
  71             errx (1, "unreasonable length (%u) > %u",
  72                   (unsigned)sz, (unsigned)len);
  73         buf += sz;
  74         len -= sz;
  75         if (indent_flag) {
  76             int i;
  77             for (i = 0; i < indent; ++i)
  78                 printf (" ");
  79         }
  80         printf ("%s %s ", der_get_class_name(class), der_get_type_name(type));
  81         tagname = der_get_tag_name(tag);
  82         if (class == ASN1_C_UNIV && tagname != NULL)
  83             printf ("%s = ", tagname);
  84         else
  85             printf ("tag %d = ", tag);
  86         ret = der_get_length (buf, len, &length, &sz);
  87         if (ret)
  88             errx (1, "der_get_tag: %s", error_message (ret));
  89         if (sz > len)
  90             errx (1, "unreasonable tag length (%u) > %u",
  91                   (unsigned)sz, (unsigned)len);
  92         buf += sz;
  93         len -= sz;
  94         if (length == ASN1_INDEFINITE) {
  95             if ((class == ASN1_C_UNIV && type == PRIM && tag == UT_OctetString) ||
  96                 (class == ASN1_C_CONTEXT && type == CONS) ||
  97                 (class == ASN1_C_UNIV && type == CONS && tag == UT_Sequence) ||
  98                 (class == ASN1_C_UNIV && type == CONS && tag == UT_Set)) {
  99                 printf("*INDEFINITE FORM*");
 100             } else {
 101                 fflush(stdout);
 102                 errx(1, "indef form used on unsupported object");
 103             }
 104             end_tag = 1;
 105             if (indefinite_form_loop > indefinite_form_loop_max)
 106                 errx(1, "indefinite form used recursively more then %lu "
 107                      "times, aborting", indefinite_form_loop_max);
 108             indefinite_form_loop++;
 109             length = len;
 110         } else if (length > len) {
 111             printf("\n");
 112             fflush(stdout);
 113             errx (1, "unreasonable inner length (%u) > %u",
 114                   (unsigned)length, (unsigned)len);
 115         }
 116         if (class == ASN1_C_CONTEXT || class == ASN1_C_APPL) {
 117             printf ("%lu bytes [%u]", (unsigned long)length, tag);
 118             if (type == CONS) {
 119                 printf("\n");
 120                 loop_length = loop (buf, length, indent + 2);
 121             } else {
 122                 printf(" IMPLICIT content\n");
 123             }
 124         } else if (class == ASN1_C_UNIV) {
 125             switch (tag) {
 126             case UT_EndOfContent:
 127                 printf (" INDEFINITE length was %lu\n",
 128                         (unsigned long)(buf - start_buf));
 129                 break;
 130             case UT_Set :
 131             case UT_Sequence :
 132                 printf ("%lu bytes {\n", (unsigned long)length);
 133                 loop_length = loop (buf, length, indent + 2);
 134                 if (indent_flag) {
 135                     int i;
 136                     for (i = 0; i < indent; ++i)
 137                         printf (" ");
 138                     printf ("}\n");
 139                 } else
 140                     printf ("} indent = %d\n", indent / 2);
 141                 break;
 142             case UT_Integer : {
 143                 int val;
 144
 145                 if (length <= sizeof(val)) {
 146                     ret = der_get_integer (buf, length, &val, NULL);
 147                     if (ret)
 148                         errx (1, "der_get_integer: %s", error_message (ret));
 149                     printf ("integer %d\n", val);
 150                 } else {
 151                     heim_integer vali;
 152                     char *p;
 153
 154                     ret = der_get_heim_integer(buf, length, &vali, NULL);
 155                     if (ret)
 156                         errx (1, "der_get_heim_integer: %s",
 157                               error_message (ret));
 158                     ret = der_print_hex_heim_integer(&vali, &p);
 159                     if (ret)
 160                         errx (1, "der_print_hex_heim_integer: %s",
 161                               error_message (ret));
 162                     printf ("BIG NUM integer: length %lu %s\n",
 163                             (unsigned long)length, p);
 164                     free(p);
 165                 }
 166                 break;
 167             }
 168             case UT_OctetString : {
 169                 heim_octet_string str;
 170                 int i;
 171                 unsigned char *uc;
 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                 uc = (unsigned char *)str.data;
 178                 for (i = 0; i < min(16,length); ++i)
 179                     printf ("%02x", uc[i]);
 180                 printf ("\n");
 181                 free (str.data);
 182                 break;
 183             }
 184             case UT_GeneralizedTime :
 185             case UT_GeneralString :
 186             case UT_PrintableString :
 187             case UT_VisibleString :
 188             case UT_IA5String :
 189             case UT_UTF8String : {
 190                 heim_general_string str;
 191
 192                 ret = der_get_general_string (buf, length, &str, NULL);
 193                 if (ret)
 194                     errx (1, "der_get_general_string: %s",
 195                           error_message (ret));
 196                 printf ("\"%s\"\n", str);
 197                 free (str);
 198                 break;
 199             }
 200             case UT_OID: {
 201                 heim_oid o;
 202                 char *p;
 203
 204                 ret = der_get_oid(buf, length, &o, NULL);
 205                 if (ret)
 206                     errx (1, "der_get_oid: %s", error_message (ret));
 207                 ret = der_print_heim_oid(&o, '.', &p);
 208                 der_free_oid(&o);
 209                 if (ret)
 210                     errx (1, "der_print_heim_oid: %s", error_message (ret));
 211                 printf("%s\n", p);
 212                 free(p);
 213
 214                 break;
 215             }
 216             case UT_Enumerated: {
 217                 int num;
 218
 219                 ret = der_get_integer (buf, length, &num, NULL);
 220                 if (ret)
 221                     errx (1, "der_get_enum: %s", error_message (ret));
 222
 223                 printf("%u\n", num);
 224                 break;
 225             }
 226             default :
 227                 printf ("%lu bytes\n", (unsigned long)length);
 228                 break;
 229             }
 230         }
 231         if (end_tag) {
 232             if (loop_length == 0)
 233                 errx(1, "zero length INDEFINITE data ? indent = %d\n",
 234                      indent / 2);
 235             if (loop_length < length)
 236                 length = loop_length;
 237             if (indefinite_form_loop == 0)
 238                 errx(1, "internal error in indefinite form loop detection");
 239             indefinite_form_loop--;
 240         } else if (loop_length)
 241             errx(1, "internal error for INDEFINITE form");
 242         buf += length;
 243         len -= length;
 244     }
 245     return 0;
 246 }
 247
 248 static int
 249 doit (const char *filename)
 250 {
 251     int fd = open (filename, O_RDONLY);
 252     struct stat sb;
 253     unsigned char *buf;
 254     size_t len;
 255     int ret;
 256
 257     if(fd < 0)
 258         err (1, "opening %s for read", filename);
 259     if (fstat (fd, &sb) < 0)
 260         err (1, "stat %s", filename);
 261     len = sb.st_size;
 262     buf = emalloc (len);
 263     if (read (fd, buf, len) != len)
 264         errx (1, "read failed");
 265     close (fd);
 266     ret = loop (buf, len, 0);
 267     free (buf);
 268     return ret;
 269 }
 270
 271
 272 static int version_flag;
 273 static int help_flag;
 274 struct getargs args[] = {
 275     { "indent", 0, arg_negative_flag, &indent_flag },
 276     { "version", 0, arg_flag, &version_flag },
 277     { "help", 0, arg_flag, &help_flag }
 278 };
 279 int num_args = sizeof(args) / sizeof(args[0]);
 280
 281 static void
 282 usage(int code)
 283 {
 284     arg_printusage(args, num_args, NULL, "dump-file");
 285     exit(code);
 286 }
 287
 288 int
 289 main(int argc, char **argv)
 290 {
 291     int optidx = 0;
 292
 293     setprogname (argv[0]);
 294     initialize_asn1_error_table ();
 295     if(getarg(args, num_args, argc, argv, &optidx))
 296         usage(1);
 297     if(help_flag)
 298         usage(0);
 299     if(version_flag) {
 300         print_version(NULL);
 301         exit(0);
 302     }
 303     argv += optidx;
 304     argc -= optidx;
 305     if (argc != 1)
 306         usage (1);
 307     return doit (argv[0]);
 308 }