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     op = p - 1;
  90     while ((p < tot) && (op < p)) {
  91         op = p;
  92         j = ASN1_get_object(&p, &len, &tag, &xclass, length);
  93         if (j & 0x80) {
  94             if (BIO_write(bp, "Error in encoding\n", 18) <= 0)
  95                 goto end;
  96             ret = 0;
  97             goto end;
  98         }
  99         hl = (p - op);
 100         length -= hl;
 101         /*
 102          * if j == 0x21 it is a constructed indefinite length object
 103          */
 104         if (BIO_printf(bp, "%5ld:", (long)offset + (long)(op - *pp))
 105             <= 0)
 106             goto end;
 107
 108         if (j != (V_ASN1_CONSTRUCTED | 1)) {
 109             if (BIO_printf(bp, "d=%-2d hl=%ld l=%4ld ",
 110                            depth, (long)hl, len) <= 0)
 111                 goto end;
 112         } else {
 113             if (BIO_printf(bp, "d=%-2d hl=%ld l=inf  ", depth, (long)hl) <= 0)
 114                 goto end;
 115         }
 116         if (!asn1_print_info(bp, tag, xclass, j, (indent) ? depth : 0))
 117             goto end;
 118         if (j & V_ASN1_CONSTRUCTED) {
 119             const unsigned char *sp = p;
 120
 121             ep = p + len;
 122             if (BIO_write(bp, "\n", 1) <= 0)
 123                 goto end;
 124             if (len > length) {
 125                 BIO_printf(bp, "length is greater than %ld\n", length);
 126                 ret = 0;
 127                 goto end;
 128             }
 129             if ((j == 0x21) && (len == 0)) {
 130                 for (;;) {
 131                     r = asn1_parse2(bp, &p, (long)(tot - p),
 132                                     offset + (p - *pp), depth + 1,
 133                                     indent, dump);
 134                     if (r == 0) {
 135                         ret = 0;
 136                         goto end;
 137                     }
 138                     if ((r == 2) || (p >= tot)) {
 139                         len = p - sp;
 140                         break;
 141                     }
 142                 }
 143             } else {
 144                 long tmp = len;
 145
 146                 while (p < ep) {
 147                     sp = p;
 148                     r = asn1_parse2(bp, &p, tmp,
 149                                     offset + (p - *pp), depth + 1,
 150                                     indent, dump);
 151                     if (r == 0) {
 152                         ret = 0;
 153                         goto end;
 154                     }
 155                     tmp -= p - sp;
 156                 }
 157             }
 158         } else if (xclass != 0) {
 159             p += len;
 160             if (BIO_write(bp, "\n", 1) <= 0)
 161                 goto end;
 162         } else {
 163             nl = 0;
 164             if ((tag == V_ASN1_PRINTABLESTRING) ||
 165                 (tag == V_ASN1_T61STRING) ||
 166                 (tag == V_ASN1_IA5STRING) ||
 167                 (tag == V_ASN1_VISIBLESTRING) ||
 168                 (tag == V_ASN1_NUMERICSTRING) ||
 169                 (tag == V_ASN1_UTF8STRING) ||
 170                 (tag == V_ASN1_UTCTIME) || (tag == V_ASN1_GENERALIZEDTIME)) {
 171                 if (BIO_write(bp, ":", 1) <= 0)
 172                     goto end;
 173                 if ((len > 0) && BIO_write(bp, (const char *)p, (int)len)
 174                     != (int)len)
 175                     goto end;
 176             } else if (tag == V_ASN1_OBJECT) {
 177                 opp = op;
 178                 if (d2i_ASN1_OBJECT(&o, &opp, len + hl) != NULL) {
 179                     if (BIO_write(bp, ":", 1) <= 0)
 180                         goto end;
 181                     i2a_ASN1_OBJECT(bp, o);
 182                 } else {
 183                     if (BIO_puts(bp, ":BAD OBJECT") <= 0)
 184                         goto end;
 185                     dump_cont = 1;
 186                 }
 187             } else if (tag == V_ASN1_BOOLEAN) {
 188                 if (len != 1) {
 189                     if (BIO_puts(bp, ":BAD BOOLEAN") <= 0)
 190                         goto end;
 191                     dump_cont = 1;
 192                 }
 193                 if (len > 0)
 194                     BIO_printf(bp, ":%u", p[0]);
 195             } else if (tag == V_ASN1_BMPSTRING) {
 196                 /* do the BMP thang */
 197             } else if (tag == V_ASN1_OCTET_STRING) {
 198                 int i, printable = 1;
 199
 200                 opp = op;
 201                 os = d2i_ASN1_OCTET_STRING(NULL, &opp, len + hl);
 202                 if (os != NULL && os->length > 0) {
 203                     opp = os->data;
 204                     /*
 205                      * testing whether the octet string is printable
 206                      */
 207                     for (i = 0; i < os->length; i++) {
 208                         if (((opp[i] < ' ') &&
 209                              (opp[i] != '\n') &&
 210                              (opp[i] != '\r') &&
 211                              (opp[i] != '\t')) || (opp[i] > '~')) {
 212                             printable = 0;
 213                             break;
 214                         }
 215                     }
 216                     if (printable)
 217                         /* printable string */
 218                     {
 219                         if (BIO_write(bp, ":", 1) <= 0)
 220                             goto end;
 221                         if (BIO_write(bp, (const char *)opp, os->length) <= 0)
 222                             goto end;
 223                     } else if (!dump)
 224                         /*
 225                          * not printable => print octet string as hex dump
 226                          */
 227                     {
 228                         if (BIO_write(bp, "[HEX DUMP]:", 11) <= 0)
 229                             goto end;
 230                         for (i = 0; i < os->length; i++) {
 231                             if (BIO_printf(bp, "%02X", opp[i]) <= 0)
 232                                 goto end;
 233                         }
 234                     } else
 235                         /* print the normal dump */
 236                     {
 237                         if (!nl) {
 238                             if (BIO_write(bp, "\n", 1) <= 0)
 239                                 goto end;
 240                         }
 241                         if (BIO_dump_indent(bp,
 242                                             (const char *)opp,
 243                                             ((dump == -1 || dump >
 244                                               os->
 245                                               length) ? os->length : dump),
 246                                             dump_indent) <= 0)
 247                             goto end;
 248                         nl = 1;
 249                     }
 250                 }
 251                 ASN1_OCTET_STRING_free(os);
 252                 os = NULL;
 253             } else if (tag == V_ASN1_INTEGER) {
 254                 ASN1_INTEGER *bs;
 255                 int i;
 256
 257                 opp = op;
 258                 bs = d2i_ASN1_INTEGER(NULL, &opp, len + hl);
 259                 if (bs != NULL) {
 260                     if (BIO_write(bp, ":", 1) <= 0)
 261                         goto end;
 262                     if (bs->type == V_ASN1_NEG_INTEGER)
 263                         if (BIO_write(bp, "-", 1) <= 0)
 264                             goto end;
 265                     for (i = 0; i < bs->length; i++) {
 266                         if (BIO_printf(bp, "%02X", bs->data[i]) <= 0)
 267                             goto end;
 268                     }
 269                     if (bs->length == 0) {
 270                         if (BIO_write(bp, "00", 2) <= 0)
 271                             goto end;
 272                     }
 273                 } else {
 274                     if (BIO_puts(bp, ":BAD INTEGER") <= 0)
 275                         goto end;
 276                     dump_cont = 1;
 277                 }
 278                 ASN1_INTEGER_free(bs);
 279             } else if (tag == V_ASN1_ENUMERATED) {
 280                 ASN1_ENUMERATED *bs;
 281                 int i;
 282
 283                 opp = op;
 284                 bs = d2i_ASN1_ENUMERATED(NULL, &opp, len + hl);
 285                 if (bs != NULL) {
 286                     if (BIO_write(bp, ":", 1) <= 0)
 287                         goto end;
 288                     if (bs->type == V_ASN1_NEG_ENUMERATED)
 289                         if (BIO_write(bp, "-", 1) <= 0)
 290                             goto end;
 291                     for (i = 0; i < bs->length; i++) {
 292                         if (BIO_printf(bp, "%02X", bs->data[i]) <= 0)
 293                             goto end;
 294                     }
 295                     if (bs->length == 0) {
 296                         if (BIO_write(bp, "00", 2) <= 0)
 297                             goto end;
 298                     }
 299                 } else {
 300                     if (BIO_puts(bp, ":BAD ENUMERATED") <= 0)
 301                         goto end;
 302                     dump_cont = 1;
 303                 }
 304                 ASN1_ENUMERATED_free(bs);
 305             } else if (len > 0 && dump) {
 306                 if (!nl) {
 307                     if (BIO_write(bp, "\n", 1) <= 0)
 308                         goto end;
 309                 }
 310                 if (BIO_dump_indent(bp, (const char *)p,
 311                                     ((dump == -1 || dump > len) ? len : dump),
 312                                     dump_indent) <= 0)
 313                     goto end;
 314                 nl = 1;
 315             }
 316             if (dump_cont) {
 317                 int i;
 318                 const unsigned char *tmp = op + hl;
 319                 if (BIO_puts(bp, ":[") <= 0)
 320                     goto end;
 321                 for (i = 0; i < len; i++) {
 322                     if (BIO_printf(bp, "%02X", tmp[i]) <= 0)
 323                         goto end;
 324                 }
 325                 if (BIO_puts(bp, "]") <= 0)
 326                     goto end;
 327             }
 328
 329             if (!nl) {
 330                 if (BIO_write(bp, "\n", 1) <= 0)
 331                     goto end;
 332             }
 333             p += len;
 334             if ((tag == V_ASN1_EOC) && (xclass == 0)) {
 335                 ret = 2;        /* End of sequence */
 336                 goto end;
 337             }
 338         }
 339         length -= len;
 340     }
 341     ret = 1;
 342  end:
 343     ASN1_OBJECT_free(o);
 344     ASN1_OCTET_STRING_free(os);
 345     *pp = p;
 346     return (ret);
 347 }
 348
 349 const char *ASN1_tag2str(int tag)
 350 {
 351     static const char *const tag2str[] = {
 352         /* 0-4 */
 353         "EOC", "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING",
 354         /* 5-9 */
 355         "NULL", "OBJECT", "OBJECT DESCRIPTOR", "EXTERNAL", "REAL",
 356         /* 10-13 */
 357         "ENUMERATED", "<ASN1 11>", "UTF8STRING", "<ASN1 13>",
 358         /* 15-17 */
 359         "<ASN1 14>", "<ASN1 15>", "SEQUENCE", "SET",
 360         /* 18-20 */
 361         "NUMERICSTRING", "PRINTABLESTRING", "T61STRING",
 362         /* 21-24 */
 363         "VIDEOTEXSTRING", "IA5STRING", "UTCTIME", "GENERALIZEDTIME",
 364         /* 25-27 */
 365         "GRAPHICSTRING", "VISIBLESTRING", "GENERALSTRING",
 366         /* 28-30 */
 367         "UNIVERSALSTRING", "<ASN1 29>", "BMPSTRING"
 368     };
 369
 370     if ((tag == V_ASN1_NEG_INTEGER) || (tag == V_ASN1_NEG_ENUMERATED))
 371         tag &= ~0x100;
 372
 373     if (tag < 0 || tag > 30)
 374         return "(unknown)";
 375     return tag2str[tag];
 376 }