apps/asn1pars.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
  58 /*
  59  * A nice addition from Dr Stephen Henson <steve@openssl.org> to add the
  60  * -strparse option which parses nested binary structures
  61  */
  62
  63 #include <stdio.h>
  64 #include <stdlib.h>
  65 #include <string.h>
  66 #include "apps.h"
  67 #include <openssl/err.h>
  68 #include <openssl/evp.h>
  69 #include <openssl/x509.h>
  70 #include <openssl/pem.h>
  71
  72 typedef enum OPTION_choice {
  73     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
  74     OPT_INFORM, OPT_IN, OPT_OUT, OPT_INDENT, OPT_NOOUT,
  75     OPT_OID, OPT_OFFSET, OPT_LENGTH, OPT_DUMP, OPT_DLIMIT,
  76     OPT_STRPARSE, OPT_GENSTR, OPT_GENCONF, OPT_STRICTPEM
  77 } OPTION_CHOICE;
  78
  79 OPTIONS asn1parse_options[] = {
  80     {"help", OPT_HELP, '-', "Display this summary"},
  81     {"inform", OPT_INFORM, 'F', "input format - one of DER PEM"},
  82     {"in", OPT_IN, '<', "input file"},
  83     {"out", OPT_OUT, '>', "output file (output format is always DER)"},
  84     {"i", OPT_INDENT, 0, "indents the output"},
  85     {"noout", OPT_NOOUT, 0, "don't produce any output"},
  86     {"offset", OPT_OFFSET, 'p', "offset into file"},
  87     {"length", OPT_LENGTH, 'p', "length of section in file"},
  88     {"oid", OPT_OID, '<', "file of extra oid definitions"},
  89     {"dump", OPT_DUMP, 0, "unknown data in hex form"},
  90     {"dlimit", OPT_DLIMIT, 'p',
  91      "dump the first arg bytes of unknown data in hex form"},
  92     {"strparse", OPT_STRPARSE, 's',
  93      "offset; a series of these can be used to 'dig'"},
  94     {OPT_MORE_STR, 0, 0, "into multiple ASN1 blob wrappings"},
  95     {"genstr", OPT_GENSTR, 's', "string to generate ASN1 structure from"},
  96     {"genconf", OPT_GENCONF, 's', "file to generate ASN1 structure from"},
  97     {OPT_MORE_STR, 0, 0, "(-inform  will be ignored)"},
  98     {"strictpem", OPT_STRICTPEM, 0,
  99      "do not attempt base64 decode outside PEM markers"},
 100     {NULL}
 101 };
 102
 103 static int do_generate(char *genstr, char *genconf, BUF_MEM *buf);
 104
 105 int asn1parse_main(int argc, char **argv)
 106 {
 107     ASN1_TYPE *at = NULL;
 108     BIO *in = NULL, *b64 = NULL, *derout = NULL;
 109     BUF_MEM *buf = NULL;
 110     STACK_OF(OPENSSL_STRING) *osk = NULL;
 111     char *genstr = NULL, *genconf = NULL;
 112     char *infile = NULL, *str = NULL, *oidfile = NULL, *derfile = NULL;
 113     char *name = NULL, *header = NULL, *prog;
 114     const unsigned char *ctmpbuf;
 115     int indent = 0, noout = 0, dump = 0, strictpem = 0, informat = FORMAT_PEM;
 116     int offset = 0, ret = 1, i, j;
 117     long num, tmplen;
 118     unsigned char *tmpbuf;
 119     unsigned int length = 0;
 120     OPTION_CHOICE o;
 121
 122     prog = opt_init(argc, argv, asn1parse_options);
 123
 124     if ((osk = sk_OPENSSL_STRING_new_null()) == NULL) {
 125         BIO_printf(bio_err, "%s: Memory allocation failure\n", prog);
 126         goto end;
 127     }
 128
 129     while ((o = opt_next()) != OPT_EOF) {
 130         switch (o) {
 131         case OPT_EOF:
 132         case OPT_ERR:
 133  opthelp:
 134             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
 135             goto end;
 136         case OPT_HELP:
 137             opt_help(asn1parse_options);
 138             ret = 0;
 139             goto end;
 140         case OPT_INFORM:
 141             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat))
 142                 goto opthelp;
 143             break;
 144         case OPT_IN:
 145             infile = opt_arg();
 146             break;
 147         case OPT_OUT:
 148             derfile = opt_arg();
 149             break;
 150         case OPT_INDENT:
 151             indent = 1;
 152             break;
 153         case OPT_NOOUT:
 154             noout = 1;
 155             break;
 156         case OPT_OID:
 157             oidfile = opt_arg();
 158             break;
 159         case OPT_OFFSET:
 160             offset = strtol(opt_arg(), NULL, 0);
 161             break;
 162         case OPT_LENGTH:
 163             length = atoi(opt_arg());
 164             break;
 165         case OPT_DUMP:
 166             dump = -1;
 167             break;
 168         case OPT_DLIMIT:
 169             dump = atoi(opt_arg());
 170             break;
 171         case OPT_STRPARSE:
 172             sk_OPENSSL_STRING_push(osk, opt_arg());
 173             break;
 174         case OPT_GENSTR:
 175             genstr = opt_arg();
 176             break;
 177         case OPT_GENCONF:
 178             genconf = opt_arg();
 179             break;
 180         case OPT_STRICTPEM:
 181             strictpem = 1;
 182             informat = FORMAT_PEM;
 183             break;
 184         }
 185     }
 186     argc = opt_num_rest();
 187     argv = opt_rest();
 188
 189     if (oidfile != NULL) {
 190         in = bio_open_default(oidfile, 'r', FORMAT_TEXT);
 191         if (in == NULL)
 192             goto end;
 193         OBJ_create_objects(in);
 194         BIO_free(in);
 195     }
 196
 197     if ((in = bio_open_default(infile, 'r', informat)) == NULL)
 198         goto end;
 199
 200     if (derfile && (derout = bio_open_default(derfile, 'w', FORMAT_ASN1)) == NULL)
 201         goto end;
 202
 203     if (strictpem) {
 204         if (PEM_read_bio(in, &name, &header, (unsigned char **)&str, &num) !=
 205             1) {
 206             BIO_printf(bio_err, "Error reading PEM file\n");
 207             ERR_print_errors(bio_err);
 208             goto end;
 209         }
 210     } else {
 211
 212         if ((buf = BUF_MEM_new()) == NULL)
 213             goto end;
 214         if (!BUF_MEM_grow(buf, BUFSIZ * 8))
 215             goto end;           /* Pre-allocate :-) */
 216
 217         if (genstr || genconf) {
 218             num = do_generate(genstr, genconf, buf);
 219             if (num < 0) {
 220                 ERR_print_errors(bio_err);
 221                 goto end;
 222             }
 223         }
 224
 225         else {
 226
 227             if (informat == FORMAT_PEM) {
 228                 BIO *tmp;
 229
 230                 if ((b64 = BIO_new(BIO_f_base64())) == NULL)
 231                     goto end;
 232                 BIO_push(b64, in);
 233                 tmp = in;
 234                 in = b64;
 235                 b64 = tmp;
 236             }
 237
 238             num = 0;
 239             for (;;) {
 240                 if (!BUF_MEM_grow(buf, (int)num + BUFSIZ))
 241                     goto end;
 242                 i = BIO_read(in, &(buf->data[num]), BUFSIZ);
 243                 if (i <= 0)
 244                     break;
 245                 num += i;
 246             }
 247         }
 248         str = buf->data;
 249
 250     }
 251
 252     /* If any structs to parse go through in sequence */
 253
 254     if (sk_OPENSSL_STRING_num(osk)) {
 255         tmpbuf = (unsigned char *)str;
 256         tmplen = num;
 257         for (i = 0; i < sk_OPENSSL_STRING_num(osk); i++) {
 258             ASN1_TYPE *atmp;
 259             int typ;
 260             j = atoi(sk_OPENSSL_STRING_value(osk, i));
 261             if (j == 0) {
 262                 BIO_printf(bio_err, "'%s' is an invalid number\n",
 263                            sk_OPENSSL_STRING_value(osk, i));
 264                 continue;
 265             }
 266             tmpbuf += j;
 267             tmplen -= j;
 268             atmp = at;
 269             ctmpbuf = tmpbuf;
 270             at = d2i_ASN1_TYPE(NULL, &ctmpbuf, tmplen);
 271             ASN1_TYPE_free(atmp);
 272             if (!at) {
 273                 BIO_printf(bio_err, "Error parsing structure\n");
 274                 ERR_print_errors(bio_err);
 275                 goto end;
 276             }
 277             typ = ASN1_TYPE_get(at);
 278             if ((typ == V_ASN1_OBJECT)
 279                 || (typ == V_ASN1_BOOLEAN)
 280                 || (typ == V_ASN1_NULL)) {
 281                 BIO_printf(bio_err, "Can't parse %s type\n", ASN1_tag2str(typ));
 282                 ERR_print_errors(bio_err);
 283                 goto end;
 284             }
 285             /* hmm... this is a little evil but it works */
 286             tmpbuf = at->value.asn1_string->data;
 287             tmplen = at->value.asn1_string->length;
 288         }
 289         str = (char *)tmpbuf;
 290         num = tmplen;
 291     }
 292
 293     if (offset >= num) {
 294         BIO_printf(bio_err, "Error: offset too large\n");
 295         goto end;
 296     }
 297
 298     num -= offset;
 299
 300     if ((length == 0) || ((long)length > num))
 301         length = (unsigned int)num;
 302     if (derout) {
 303         if (BIO_write(derout, str + offset, length) != (int)length) {
 304             BIO_printf(bio_err, "Error writing output\n");
 305             ERR_print_errors(bio_err);
 306             goto end;
 307         }
 308     }
 309     if (!noout &&
 310         !ASN1_parse_dump(bio_out, (unsigned char *)&(str[offset]), length,
 311                          indent, dump)) {
 312         ERR_print_errors(bio_err);
 313         goto end;
 314     }
 315     ret = 0;
 316  end:
 317     BIO_free(derout);
 318     BIO_free(in);
 319     BIO_free(b64);
 320     if (ret != 0)
 321         ERR_print_errors(bio_err);
 322     BUF_MEM_free(buf);
 323     OPENSSL_free(name);
 324     OPENSSL_free(header);
 325     if (strictpem)
 326         OPENSSL_free(str);
 327     ASN1_TYPE_free(at);
 328     sk_OPENSSL_STRING_free(osk);
 329     OBJ_cleanup();
 330     return (ret);
 331 }
 332
 333 static int do_generate(char *genstr, char *genconf, BUF_MEM *buf)
 334 {
 335     CONF *cnf = NULL;
 336     int len;
 337     unsigned char *p;
 338     ASN1_TYPE *atyp = NULL;
 339
 340     if (genconf) {
 341         if ((cnf = app_load_config(genconf)) == NULL)
 342             goto err;
 343         if (!genstr)
 344             genstr = NCONF_get_string(cnf, "default", "asn1");
 345         if (!genstr) {
 346             BIO_printf(bio_err, "Can't find 'asn1' in '%s'\n", genconf);
 347             goto err;
 348         }
 349     }
 350
 351     atyp = ASN1_generate_nconf(genstr, cnf);
 352     NCONF_free(cnf);
 353     cnf = NULL;
 354
 355     if (!atyp)
 356         return -1;
 357
 358     len = i2d_ASN1_TYPE(atyp, NULL);
 359
 360     if (len <= 0)
 361         goto err;
 362
 363     if (!BUF_MEM_grow(buf, len))
 364         goto err;
 365
 366     p = (unsigned char *)buf->data;
 367
 368     i2d_ASN1_TYPE(atyp, &p);
 369
 370     ASN1_TYPE_free(atyp);
 371     return len;
 372
 373  err:
 374     NCONF_free(cnf);
 375     ASN1_TYPE_free(atyp);
 376     return -1;
 377 }