crypto/asn1/asn1_par.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include "internal/cryptlib.h"
  12 #include <openssl/buffer.h>
  13 #include <openssl/objects.h>
  14 #include <openssl/asn1.h>
  15
  16 #ifndef ASN1_PARSE_MAXDEPTH
  17 #define ASN1_PARSE_MAXDEPTH 128
  18 #endif
  19
  20 static int asn1_print_info(BIO *bp, int tag, int xclass, int constructed,
  21                            int indent);
  22 static int asn1_parse2(BIO *bp, const unsigned char **pp, long length,
  23                        int offset, int depth, int indent, int dump);
  24 static int asn1_print_info(BIO *bp, int tag, int xclass, int constructed,
  25                            int indent)
  26 {
  27     static const char fmt[] = "%-18s";
  28     char str[128];
  29     const char *p;
  30
  31     if (constructed & V_ASN1_CONSTRUCTED)
  32         p = "cons: ";
  33     else
  34         p = "prim: ";
  35     if (BIO_write(bp, p, 6) < 6)
  36         goto err;
  37     BIO_indent(bp, indent, 128);
  38
  39     p = str;
  40     if ((xclass & V_ASN1_PRIVATE) == V_ASN1_PRIVATE)
  41         BIO_snprintf(str, sizeof str, "priv [ %d ] ", tag);
  42     else if ((xclass & V_ASN1_CONTEXT_SPECIFIC) == V_ASN1_CONTEXT_SPECIFIC)
  43         BIO_snprintf(str, sizeof str, "cont [ %d ]", tag);
  44     else if ((xclass & V_ASN1_APPLICATION) == V_ASN1_APPLICATION)
  45         BIO_snprintf(str, sizeof str, "appl [ %d ]", tag);
  46     else if (tag > 30)
  47         BIO_snprintf(str, sizeof str, "<ASN1 %d>", tag);
  48     else
  49         p = ASN1_tag2str(tag);
  50
  51     if (BIO_printf(bp, fmt, p) <= 0)
  52         goto err;
  53     return (1);
  54  err:
  55     return (0);
  56 }
  57
  58 int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent)
  59 {
  60     return (asn1_parse2(bp, &pp, len, 0, 0, indent, 0));
  61 }
  62
  63 int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent,
  64                     int dump)
  65 {
  66     return (asn1_parse2(bp, &pp, len, 0, 0, indent, dump));
  67 }
  68
  69 static int asn1_parse2(BIO *bp, const unsigned char **pp, long length,
  70                        int offset, int depth, int indent, int dump)
  71 {
  72     const unsigned char *p, *ep, *tot, *op, *opp;
  73     long len;
  74     int tag, xclass, ret = 0;
  75     int nl, hl, j, r;
  76     ASN1_OBJECT *o = NULL;
  77     ASN1_OCTET_STRING *os = NULL;
  78     /* ASN1_BMPSTRING *bmp=NULL; */
  79     int dump_indent, dump_cont = 0;
  80
  81     if (depth > ASN1_PARSE_MAXDEPTH) {
  82             BIO_puts(bp, "BAD RECURSION DEPTH\n");
  83             return 0;
  84     }
  85
  86     dump_indent = 6;            /* Because we know BIO_dump_indent() */
  87     p = *pp;
  88     tot = p + length;
  89     while (length > 0) {
  90         op = p;
  91         j = ASN1_get_object(&p, &len, &tag, &xclass, length);
  92         if (j & 0x80) {
  93             if (BIO_write(bp, "Error in encoding\n", 18) <= 0)
  94                 goto end;
  95             ret = 0;
  96             goto end;
  97         }
  98         hl = (p - op);
  99         length -= hl;
 100         /*
 101          * if j == 0x21 it is a constructed indefinite length object
 102          */
 103         if (BIO_printf(bp, "%5ld:", (long)offset + (long)(op - *pp))
 104             <= 0)
 105             goto end;
 106
 107         if (j != (V_ASN1_CONSTRUCTED | 1)) {
 108             if (BIO_printf(bp, "d=%-2d hl=%ld l=%4ld ",
 109                            depth, (long)hl, len) <= 0)
 110                 goto end;
 111         } else {
 112             if (BIO_printf(bp, "d=%-2d hl=%ld l=inf  ", depth, (long)hl) <= 0)
 113                 goto end;
 114         }
 115         if (!asn1_print_info(bp, tag, xclass, j, (indent) ? depth : 0))
 116             goto end;
 117         if (j & V_ASN1_CONSTRUCTED) {
 118             const unsigned char *sp = p;
 119
 120             ep = p + len;
 121             if (BIO_write(bp, "\n", 1) <= 0)
 122                 goto end;
 123             if (len > length) {
 124                 BIO_printf(bp, "length is greater than %ld\n", length);
 125                 ret = 0;
 126                 goto end;
 127             }
 128             if ((j == 0x21) && (len == 0)) {
 129                 for (;;) {
 130                     r = asn1_parse2(bp, &p, (long)(tot - p),
 131                                     offset + (p - *pp), depth + 1,
 132                                     indent, dump);
 133                     if (r == 0) {
 134                         ret = 0;
 135                         goto end;
 136                     }
 137                     if ((r == 2) || (p >= tot)) {
 138                         len = p - sp;
 139                         break;
 140                     }
 141                 }
 142             } else {
 143                 long tmp = len;
 144
 145                 while (p < ep) {
 146                     sp = p;
 147                     r = asn1_parse2(bp, &p, tmp,
 148                                     offset + (p - *pp), depth + 1,
 149                                     indent, dump);
 150                     if (r == 0) {
 151                         ret = 0;
 152                         goto end;
 153                     }
 154                     tmp -= p - sp;
 155                 }
 156             }
 157         } else if (xclass != 0) {
 158             p += len;
 159             if (BIO_write(bp, "\n", 1) <= 0)
 160                 goto end;
 161         } else {
 162             nl = 0;
 163             if ((tag == V_ASN1_PRINTABLESTRING) ||
 164                 (tag == V_ASN1_T61STRING) ||
 165                 (tag == V_ASN1_IA5STRING) ||
 166                 (tag == V_ASN1_VISIBLESTRING) ||
 167                 (tag == V_ASN1_NUMERICSTRING) ||
 168                 (tag == V_ASN1_UTF8STRING) ||
 169                 (tag == V_ASN1_UTCTIME) || (tag == V_ASN1_GENERALIZEDTIME)) {
 170                 if (BIO_write(bp, ":", 1) <= 0)
 171                     goto end;
 172                 if ((len > 0) && BIO_write(bp, (const char *)p, (int)len)
 173                     != (int)len)
 174                     goto end;
 175             } else if (tag == V_ASN1_OBJECT) {
 176                 opp = op;
 177                 if (d2i_ASN1_OBJECT(&o, &opp, len + hl) != NULL) {
 178                     if (BIO_write(bp, ":", 1) <= 0)
 179                         goto end;
 180                     i2a_ASN1_OBJECT(bp, o);
 181                 } else {
 182                     if (BIO_puts(bp, ":BAD OBJECT") <= 0)
 183                         goto end;
 184                     dump_cont = 1;
 185                 }
 186             } else if (tag == V_ASN1_BOOLEAN) {
 187                 if (len != 1) {
 188                     if (BIO_puts(bp, ":BAD BOOLEAN") <= 0)
 189                         goto end;
 190                     dump_cont = 1;
 191                 }
 192                 if (len > 0)
 193                     BIO_printf(bp, ":%u", p[0]);
 194             } else if (tag == V_ASN1_BMPSTRING) {
 195                 /* do the BMP thang */
 196             } else if (tag == V_ASN1_OCTET_STRING) {
 197                 int i, printable = 1;
 198
 199                 opp = op;
 200                 os = d2i_ASN1_OCTET_STRING(NULL, &opp, len + hl);
 201                 if (os != NULL && os->length > 0) {
 202                     opp = os->data;
 203                     /*
 204                      * testing whether the octet string is printable
 205                      */
 206                     for (i = 0; i < os->length; i++) {
 207                         if (((opp[i] < ' ') &&
 208                              (opp[i] != '\n') &&
 209                              (opp[i] != '\r') &&
 210                              (opp[i] != '\t')) || (opp[i] > '~')) {
 211                             printable = 0;
 212                             break;
 213                         }
 214                     }
 215                     if (printable)
 216                         /* printable string */
 217                     {
 218                         if (BIO_write(bp, ":", 1) <= 0)
 219                             goto end;
 220                         if (BIO_write(bp, (const char *)opp, os->length) <= 0)
 221                             goto end;
 222                     } else if (!dump)
 223                         /*
 224                          * not printable => print octet string as hex dump
 225                          */
 226                     {
 227                         if (BIO_write(bp, "[HEX DUMP]:", 11) <= 0)
 228                             goto end;
 229                         for (i = 0; i < os->length; i++) {
 230                             if (BIO_printf(bp, "%02X", opp[i]) <= 0)
 231                                 goto end;
 232                         }
 233                     } else
 234                         /* print the normal dump */
 235                     {
 236                         if (!nl) {
 237                             if (BIO_write(bp, "\n", 1) <= 0)
 238                                 goto end;
 239                         }
 240                         if (BIO_dump_indent(bp,
 241                                             (const char *)opp,
 242                                             ((dump == -1 || dump >
 243                                               os->
 244                                               length) ? os->length : dump),
 245                                             dump_indent) <= 0)
 246                             goto end;
 247                         nl = 1;
 248                     }
 249                 }
 250                 ASN1_OCTET_STRING_free(os);
 251                 os = NULL;
 252             } else if (tag == V_ASN1_INTEGER) {
 253                 ASN1_INTEGER *bs;
 254                 int i;
 255
 256                 opp = op;
 257                 bs = d2i_ASN1_INTEGER(NULL, &opp, len + hl);
 258                 if (bs != NULL) {
 259                     if (BIO_write(bp, ":", 1) <= 0)
 260                         goto end;
 261                     if (bs->type == V_ASN1_NEG_INTEGER)
 262                         if (BIO_write(bp, "-", 1) <= 0)
 263                             goto end;
 264                     for (i = 0; i < bs->length; i++) {
 265                         if (BIO_printf(bp, "%02X", bs->data[i]) <= 0)
 266                             goto end;
 267                     }
 268                     if (bs->length == 0) {
 269                         if (BIO_write(bp, "00", 2) <= 0)
 270                             goto end;
 271                     }
 272                 } else {
 273                     if (BIO_puts(bp, ":BAD INTEGER") <= 0)
 274                         goto end;
 275                     dump_cont = 1;
 276                 }
 277                 ASN1_INTEGER_free(bs);
 278             } else if (tag == V_ASN1_ENUMERATED) {
 279                 ASN1_ENUMERATED *bs;
 280                 int i;
 281
 282                 opp = op;
 283                 bs = d2i_ASN1_ENUMERATED(NULL, &opp, len + hl);
 284                 if (bs != NULL) {
 285                     if (BIO_write(bp, ":", 1) <= 0)
 286                         goto end;
 287                     if (bs->type == V_ASN1_NEG_ENUMERATED)
 288                         if (BIO_write(bp, "-", 1) <= 0)
 289                             goto end;
 290                     for (i = 0; i < bs->length; i++) {
 291                         if (BIO_printf(bp, "%02X", bs->data[i]) <= 0)
 292                             goto end;
 293                     }
 294                     if (bs->length == 0) {
 295                         if (BIO_write(bp, "00", 2) <= 0)
 296                             goto end;
 297                     }
 298                 } else {
 299                     if (BIO_puts(bp, ":BAD ENUMERATED") <= 0)
 300                         goto end;
 301                     dump_cont = 1;
 302                 }
 303                 ASN1_ENUMERATED_free(bs);
 304             } else if (len > 0 && dump) {
 305                 if (!nl) {
 306                     if (BIO_write(bp, "\n", 1) <= 0)
 307                         goto end;
 308                 }
 309                 if (BIO_dump_indent(bp, (const char *)p,
 310                                     ((dump == -1 || dump > len) ? len : dump),
 311                                     dump_indent) <= 0)
 312                     goto end;
 313                 nl = 1;
 314             }
 315             if (dump_cont) {
 316                 int i;
 317                 const unsigned char *tmp = op + hl;
 318                 if (BIO_puts(bp, ":[") <= 0)
 319                     goto end;
 320                 for (i = 0; i < len; i++) {
 321                     if (BIO_printf(bp, "%02X", tmp[i]) <= 0)
 322                         goto end;
 323                 }
 324                 if (BIO_puts(bp, "]") <= 0)
 325                     goto end;
 326             }
 327
 328             if (!nl) {
 329                 if (BIO_write(bp, "\n", 1) <= 0)
 330                     goto end;
 331             }
 332             p += len;
 333             if ((tag == V_ASN1_EOC) && (xclass == 0)) {
 334                 ret = 2;        /* End of sequence */
 335                 goto end;
 336             }
 337         }
 338         length -= len;
 339     }
 340     ret = 1;
 341  end:
 342     ASN1_OBJECT_free(o);
 343     ASN1_OCTET_STRING_free(os);
 344     *pp = p;
 345     return (ret);
 346 }
 347
 348 const char *ASN1_tag2str(int tag)
 349 {
 350     static const char *const tag2str[] = {
 351         /* 0-4 */
 352         "EOC", "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING",
 353         /* 5-9 */
 354         "NULL", "OBJECT", "OBJECT DESCRIPTOR", "EXTERNAL", "REAL",
 355         /* 10-13 */
 356         "ENUMERATED", "<ASN1 11>", "UTF8STRING", "<ASN1 13>",
 357         /* 15-17 */
 358         "<ASN1 14>", "<ASN1 15>", "SEQUENCE", "SET",
 359         /* 18-20 */
 360         "NUMERICSTRING", "PRINTABLESTRING", "T61STRING",
 361         /* 21-24 */
 362         "VIDEOTEXSTRING", "IA5STRING", "UTCTIME", "GENERALIZEDTIME",
 363         /* 25-27 */
 364         "GRAPHICSTRING", "VISIBLESTRING", "GENERALSTRING",
 365         /* 28-30 */
 366         "UNIVERSALSTRING", "<ASN1 29>", "BMPSTRING"
 367     };
 368
 369     if ((tag == V_ASN1_NEG_INTEGER) || (tag == V_ASN1_NEG_ENUMERATED))
 370         tag &= ~0x100;
 371
 372     if (tag < 0 || tag > 30)
 373         return "(unknown)";
 374     return tag2str[tag];
 375 }