src/third_party/boringssl/src/crypto/asn1/asn1_par.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   2  * All rights reserved.
   3  *
   4  * This package is an SSL implementation written
   5  * by Eric Young (eay@cryptsoft.com).
   6  * The implementation was written so as to conform with Netscapes SSL.
   7  *
   8  * This library is free for commercial and non-commercial use as long as
   9  * the following conditions are aheared to.  The following conditions
  10  * apply to all code found in this distribution, be it the RC4, RSA,
  11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  12  * included with this distribution is covered by the same copyright terms
  13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  14  *
  15  * Copyright remains Eric Young's, and as such any Copyright notices in
  16  * the code are not to be removed.
  17  * If this package is used in a product, Eric Young should be given attribution
  18  * as the author of the parts of the library used.
  19  * This can be in the form of a textual message at program startup or
  20  * in documentation (online or textual) provided with the package.
  21  *
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  25  * 1. Redistributions of source code must retain the copyright
  26  *    notice, this list of conditions and the following disclaimer.
  27  * 2. Redistributions in binary form must reproduce the above copyright
  28  *    notice, this list of conditions and the following disclaimer in the
  29  *    documentation and/or other materials provided with the distribution.
  30  * 3. All advertising materials mentioning features or use of this software
  31  *    must display the following acknowledgement:
  32  *    "This product includes cryptographic software written by
  33  *     Eric Young (eay@cryptsoft.com)"
  34  *    The word 'cryptographic' can be left out if the rouines from the library
  35  *    being used are not cryptographic related :-).
  36  * 4. If you include any Windows specific code (or a derivative thereof) from
  37  *    the apps directory (application code) you must include an acknowledgement:
  38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  *
  52  * The licence and distribution terms for any publically available version or
  53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  54  * copied and put under another distribution licence
  55  * [including the GNU Public Licence.] */
  56
  57 #include <openssl/asn1.h>
  58
  59 #include <openssl/bio.h>
  60 #include <openssl/err.h>
  61 #include <openssl/mem.h>
  62
  63
  64 static int asn1_print_info(BIO *bp, int tag, int xclass,int constructed,
  65         int indent);
  66 static int asn1_parse2(BIO *bp, const unsigned char **pp, long length,
  67         int offset, int depth, int indent, int dump);
  68 static int asn1_print_info(BIO *bp, int tag, int xclass, int constructed,
  69              int indent)
  70         {
  71         static const char fmt[]="%-18s";
  72         char str[128];
  73         const char *p;
  74
  75         if (constructed & V_ASN1_CONSTRUCTED)
  76                 p="cons: ";
  77         else
  78                 p="prim: ";
  79         if (BIO_write(bp,p,6) < 6) goto err;
  80         BIO_indent(bp,indent,128);
  81
  82         p=str;
  83         if ((xclass & V_ASN1_PRIVATE) == V_ASN1_PRIVATE)
  84                 BIO_snprintf(str,sizeof str,"priv [ %d ] ",tag);
  85         else if ((xclass & V_ASN1_CONTEXT_SPECIFIC) == V_ASN1_CONTEXT_SPECIFIC)
  86                 BIO_snprintf(str,sizeof str,"cont [ %d ]",tag);
  87         else if ((xclass & V_ASN1_APPLICATION) == V_ASN1_APPLICATION)
  88                 BIO_snprintf(str,sizeof str,"appl [ %d ]",tag);
  89         else if (tag > 30)
  90                 BIO_snprintf(str,sizeof str,"<ASN1 %d>",tag);
  91         else
  92                 p = ASN1_tag2str(tag);
  93
  94         if (BIO_printf(bp,fmt,p) <= 0)
  95                 goto err;
  96         return(1);
  97 err:
  98         return(0);
  99         }
 100
 101 int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent)
 102         {
 103         return(asn1_parse2(bp,&pp,len,0,0,indent,0));
 104         }
 105
 106 int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent, int dump)
 107         {
 108         return(asn1_parse2(bp,&pp,len,0,0,indent,dump));
 109         }
 110
 111 static int asn1_parse2(BIO *bp, const unsigned char **pp, long length, int offset,
 112              int depth, int indent, int dump)
 113         {
 114         const unsigned char *p,*ep,*tot,*op,*opp;
 115         long len;
 116         int tag,xclass,ret=0;
 117         int nl,hl,j,r;
 118         ASN1_OBJECT *o=NULL;
 119         ASN1_OCTET_STRING *os=NULL;
 120         /* ASN1_BMPSTRING *bmp=NULL;*/
 121         int dump_indent;
 122
 123 #if 0
 124         dump_indent = indent;
 125 #else
 126         dump_indent = 6;        /* Because we know BIO_dump_indent() */
 127 #endif
 128         p= *pp;
 129         tot=p+length;
 130         op=p-1;
 131         while ((p < tot) && (op < p))
 132                 {
 133                 op=p;
 134                 j=ASN1_get_object(&p,&len,&tag,&xclass,length);
 135 #ifdef LINT
 136                 j=j;
 137 #endif
 138                 if (j & 0x80)
 139                         {
 140                         if (BIO_write(bp,"Error in encoding\n",18) <= 0)
 141                                 goto end;
 142                         ret=0;
 143                         goto end;
 144                         }
 145                 hl=(p-op);
 146                 length-=hl;
 147                 /* if j == 0x21 it is a constructed indefinite length object */
 148                 if (BIO_printf(bp,"%5ld:",(long)offset+(long)(op- *pp))
 149                         <= 0) goto end;
 150
 151                 if (j != (V_ASN1_CONSTRUCTED | 1))
 152                         {
 153                         if (BIO_printf(bp,"d=%-2d hl=%ld l=%4ld ",
 154                                 depth,(long)hl,len) <= 0)
 155                                 goto end;
 156                         }
 157                 else
 158                         {
 159                         if (BIO_printf(bp,"d=%-2d hl=%ld l=inf  ",
 160                                 depth,(long)hl) <= 0)
 161                                 goto end;
 162                         }
 163                 if (!asn1_print_info(bp,tag,xclass,j,(indent)?depth:0))
 164                         goto end;
 165                 if (j & V_ASN1_CONSTRUCTED)
 166                         {
 167                         ep=p+len;
 168                         if (BIO_write(bp,"\n",1) <= 0) goto end;
 169                         if (len > length)
 170                                 {
 171                                 BIO_printf(bp,
 172                                         "length is greater than %ld\n",length);
 173                                 ret=0;
 174                                 goto end;
 175                                 }
 176                         if ((j == 0x21) && (len == 0))
 177                                 {
 178                                 for (;;)
 179                                         {
 180                                         r=asn1_parse2(bp,&p,(long)(tot-p),
 181                                                 offset+(p - *pp),depth+1,
 182                                                 indent,dump);
 183                                         if (r == 0) { ret=0; goto end; }
 184                                         if ((r == 2) || (p >= tot)) break;
 185                                         }
 186                                 }
 187                         else
 188                                 while (p < ep)
 189                                         {
 190                                         r=asn1_parse2(bp,&p,(long)len,
 191                                                 offset+(p - *pp),depth+1,
 192                                                 indent,dump);
 193                                         if (r == 0) { ret=0; goto end; }
 194                                         }
 195                         }
 196                 else if (xclass != 0)
 197                         {
 198                         p+=len;
 199                         if (BIO_write(bp,"\n",1) <= 0) goto end;
 200                         }
 201                 else
 202                         {
 203                         nl=0;
 204                         if (    (tag == V_ASN1_PRINTABLESTRING) ||
 205                                 (tag == V_ASN1_T61STRING) ||
 206                                 (tag == V_ASN1_IA5STRING) ||
 207                                 (tag == V_ASN1_VISIBLESTRING) ||
 208                                 (tag == V_ASN1_NUMERICSTRING) ||
 209                                 (tag == V_ASN1_UTF8STRING) ||
 210                                 (tag == V_ASN1_UTCTIME) ||
 211                                 (tag == V_ASN1_GENERALIZEDTIME))
 212                                 {
 213                                 if (BIO_write(bp,":",1) <= 0) goto end;
 214                                 if ((len > 0) &&
 215                                         BIO_write(bp,(const char *)p,(int)len)
 216                                         != (int)len)
 217                                         goto end;
 218                                 }
 219                         else if (tag == V_ASN1_OBJECT)
 220                                 {
 221                                 opp=op;
 222                                 if (d2i_ASN1_OBJECT(&o,&opp,len+hl) != NULL)
 223                                         {
 224                                         if (BIO_write(bp,":",1) <= 0) goto end;
 225                                         i2a_ASN1_OBJECT(bp,o);
 226                                         }
 227                                 else
 228                                         {
 229                                         if (BIO_write(bp,":BAD OBJECT",11) <= 0)
 230                                                 goto end;
 231                                         }
 232                                 }
 233                         else if (tag == V_ASN1_BOOLEAN)
 234                                 {
 235                                 int ii;
 236
 237                                 opp=op;
 238                                 ii=d2i_ASN1_BOOLEAN(NULL,&opp,len+hl);
 239                                 if (ii < 0)
 240                                         {
 241                                         if (BIO_write(bp,"Bad boolean\n",12) <= 0)
 242                                                 goto end;
 243                                         }
 244                                 BIO_printf(bp,":%d",ii);
 245                                 }
 246                         else if (tag == V_ASN1_BMPSTRING)
 247                                 {
 248                                 /* do the BMP thang */
 249                                 }
 250                         else if (tag == V_ASN1_OCTET_STRING)
 251                                 {
 252                                 int i,printable=1;
 253
 254                                 opp=op;
 255                                 os=d2i_ASN1_OCTET_STRING(NULL,&opp,len+hl);
 256                                 if (os != NULL && os->length > 0)
 257                                         {
 258                                         opp = os->data;
 259                                         /* testing whether the octet string is
 260                                          * printable */
 261                                         for (i=0; i<os->length; i++)
 262                                                 {
 263                                                 if ((   (opp[i] < ' ') &&
 264                                                         (opp[i] != '\n') &&
 265                                                         (opp[i] != '\r') &&
 266                                                         (opp[i] != '\t')) ||
 267                                                         (opp[i] > '~'))
 268                                                         {
 269                                                         printable=0;
 270                                                         break;
 271                                                         }
 272                                                 }
 273                                         if (printable)
 274                                         /* printable string */
 275                                                 {
 276                                                 if (BIO_write(bp,":",1) <= 0)
 277                                                         goto end;
 278                                                 if (BIO_write(bp,(const char *)opp,
 279                                                         os->length) <= 0)
 280                                                         goto end;
 281                                                 }
 282                                         else if (!dump)
 283                                         /* not printable => print octet string
 284                                          * as hex dump */
 285                                                 {
 286                                                 if (BIO_write(bp,"[HEX DUMP]:",11) <= 0)
 287                                                         goto end;
 288                                                 for (i=0; i<os->length; i++)
 289                                                         {
 290                                                         if (BIO_printf(bp,"%02X"
 291                                                                 , opp[i]) <= 0)
 292                                                                 goto end;
 293                                                         }
 294                                                 }
 295                                         else
 296                                         /* print the normal dump */
 297                                                 {
 298                                                 if (!nl)
 299                                                         {
 300                                                         if (BIO_write(bp,"\n",1) <= 0)
 301                                                                 goto end;
 302                                                         }
 303                                                 if (!BIO_hexdump(bp, opp,
 304                                                         ((dump == -1 || dump >
 305                                                         os->length)?os->length:dump),
 306                                                         dump_indent))
 307                                                         goto end;
 308                                                 nl=1;
 309                                                 }
 310                                         }
 311                                 if (os != NULL)
 312                                         {
 313                                         M_ASN1_OCTET_STRING_free(os);
 314                                         os=NULL;
 315                                         }
 316                                 }
 317                         else if (tag == V_ASN1_INTEGER)
 318                                 {
 319                                 ASN1_INTEGER *bs;
 320                                 int i;
 321
 322                                 opp=op;
 323                                 bs=d2i_ASN1_INTEGER(NULL,&opp,len+hl);
 324                                 if (bs != NULL)
 325                                         {
 326                                         if (BIO_write(bp,":",1) <= 0) goto end;
 327                                         if (bs->type == V_ASN1_NEG_INTEGER)
 328                                                 if (BIO_write(bp,"-",1) <= 0)
 329                                                         goto end;
 330                                         for (i=0; i<bs->length; i++)
 331                                                 {
 332                                                 if (BIO_printf(bp,"%02X",
 333                                                         bs->data[i]) <= 0)
 334                                                         goto end;
 335                                                 }
 336                                         if (bs->length == 0)
 337                                                 {
 338                                                 if (BIO_write(bp,"00",2) <= 0)
 339                                                         goto end;
 340                                                 }
 341                                         }
 342                                 else
 343                                         {
 344                                         if (BIO_write(bp,"BAD INTEGER",11) <= 0)
 345                                                 goto end;
 346                                         }
 347                                 M_ASN1_INTEGER_free(bs);
 348                                 }
 349                         else if (tag == V_ASN1_ENUMERATED)
 350                                 {
 351                                 ASN1_ENUMERATED *bs;
 352                                 int i;
 353
 354                                 opp=op;
 355                                 bs=d2i_ASN1_ENUMERATED(NULL,&opp,len+hl);
 356                                 if (bs != NULL)
 357                                         {
 358                                         if (BIO_write(bp,":",1) <= 0) goto end;
 359                                         if (bs->type == V_ASN1_NEG_ENUMERATED)
 360                                                 if (BIO_write(bp,"-",1) <= 0)
 361                                                         goto end;
 362                                         for (i=0; i<bs->length; i++)
 363                                                 {
 364                                                 if (BIO_printf(bp,"%02X",
 365                                                         bs->data[i]) <= 0)
 366                                                         goto end;
 367                                                 }
 368                                         if (bs->length == 0)
 369                                                 {
 370                                                 if (BIO_write(bp,"00",2) <= 0)
 371                                                         goto end;
 372                                                 }
 373                                         }
 374                                 else
 375                                         {
 376                                         if (BIO_write(bp,"BAD ENUMERATED",11) <= 0)
 377                                                 goto end;
 378                                         }
 379                                 M_ASN1_ENUMERATED_free(bs);
 380                                 }
 381                         else if (len > 0 && dump)
 382                                 {
 383                                 if (!nl)
 384                                         {
 385                                         if (BIO_write(bp,"\n",1) <= 0)
 386                                                 goto end;
 387                                         }
 388                                 if (!BIO_hexdump(bp,p,
 389                                         ((dump == -1 || dump > len)?len:dump),
 390                                         dump_indent))
 391                                         goto end;
 392                                 nl=1;
 393                                 }
 394
 395                         if (!nl)
 396                                 {
 397                                 if (BIO_write(bp,"\n",1) <= 0) goto end;
 398                                 }
 399                         p+=len;
 400                         if ((tag == V_ASN1_EOC) && (xclass == 0))
 401                                 {
 402                                 ret=2; /* End of sequence */
 403                                 goto end;
 404                                 }
 405                         }
 406                 length-=len;
 407                 }
 408         ret=1;
 409 end:
 410         if (o != NULL) ASN1_OBJECT_free(o);
 411         if (os != NULL) M_ASN1_OCTET_STRING_free(os);
 412         *pp=p;
 413         return(ret);
 414         }
 415
 416 const char *ASN1_tag2str(int tag)
 417 {
 418         static const char * const tag2str[] = {
 419          "EOC", "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING", /* 0-4 */
 420          "NULL", "OBJECT", "OBJECT DESCRIPTOR", "EXTERNAL", "REAL", /* 5-9 */
 421          "ENUMERATED", "<ASN1 11>", "UTF8STRING", "<ASN1 13>",      /* 10-13 */
 422         "<ASN1 14>", "<ASN1 15>", "SEQUENCE", "SET",                /* 15-17 */
 423         "NUMERICSTRING", "PRINTABLESTRING", "T61STRING",            /* 18-20 */
 424         "VIDEOTEXSTRING", "IA5STRING", "UTCTIME","GENERALIZEDTIME", /* 21-24 */
 425         "GRAPHICSTRING", "VISIBLESTRING", "GENERALSTRING",          /* 25-27 */
 426         "UNIVERSALSTRING", "<ASN1 29>", "BMPSTRING"                 /* 28-30 */
 427         };
 428
 429         if((tag == V_ASN1_NEG_INTEGER) || (tag == V_ASN1_NEG_ENUMERATED))
 430                                                         tag &= ~0x100;
 431
 432         if(tag < 0 || tag > 30) return "(unknown)";
 433         return tag2str[tag];
 434 }
 435