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, "entries"},
  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 (!app_load_modules(NULL))
 190         goto end;
 191
 192     if (oidfile != NULL) {
 193         in = bio_open_default(oidfile, 'r', FORMAT_TEXT);
 194         if (in == NULL)
 195             goto end;
 196         OBJ_create_objects(in);
 197         BIO_free(in);
 198     }
 199
 200     if ((in = bio_open_default(infile, 'r', informat)) == NULL)
 201         goto end;
 202
 203     if (derfile && (derout = bio_open_default(derfile, 'w', FORMAT_ASN1)) == NULL)
 204         goto end;
 205
 206     if (strictpem) {
 207         if (PEM_read_bio(in, &name, &header, (unsigned char **)&str, &num) !=
 208             1) {
 209             BIO_printf(bio_err, "Error reading PEM file\n");
 210             ERR_print_errors(bio_err);
 211             goto end;
 212         }
 213     } else {
 214
 215         if ((buf = BUF_MEM_new()) == NULL)
 216             goto end;
 217         if (!BUF_MEM_grow(buf, BUFSIZ * 8))
 218             goto end;           /* Pre-allocate :-) */
 219
 220         if (genstr || genconf) {
 221             num = do_generate(genstr, genconf, buf);
 222             if (num < 0) {
 223                 ERR_print_errors(bio_err);
 224                 goto end;
 225             }
 226         }
 227
 228         else {
 229
 230             if (informat == FORMAT_PEM) {
 231                 BIO *tmp;
 232
 233                 if ((b64 = BIO_new(BIO_f_base64())) == NULL)
 234                     goto end;
 235                 BIO_push(b64, in);
 236                 tmp = in;
 237                 in = b64;
 238                 b64 = tmp;
 239             }
 240
 241             num = 0;
 242             for (;;) {
 243                 if (!BUF_MEM_grow(buf, (int)num + BUFSIZ))
 244                     goto end;
 245                 i = BIO_read(in, &(buf->data[num]), BUFSIZ);
 246                 if (i <= 0)
 247                     break;
 248                 num += i;
 249             }
 250         }
 251         str = buf->data;
 252
 253     }
 254
 255     /* If any structs to parse go through in sequence */
 256
 257     if (sk_OPENSSL_STRING_num(osk)) {
 258         tmpbuf = (unsigned char *)str;
 259         tmplen = num;
 260         for (i = 0; i < sk_OPENSSL_STRING_num(osk); i++) {
 261             ASN1_TYPE *atmp;
 262             int typ;
 263             j = atoi(sk_OPENSSL_STRING_value(osk, i));
 264             if (j == 0) {
 265                 BIO_printf(bio_err, "'%s' is an invalid number\n",
 266                            sk_OPENSSL_STRING_value(osk, i));
 267                 continue;
 268             }
 269             tmpbuf += j;
 270             tmplen -= j;
 271             atmp = at;
 272             ctmpbuf = tmpbuf;
 273             at = d2i_ASN1_TYPE(NULL, &ctmpbuf, tmplen);
 274             ASN1_TYPE_free(atmp);
 275             if (!at) {
 276                 BIO_printf(bio_err, "Error parsing structure\n");
 277                 ERR_print_errors(bio_err);
 278                 goto end;
 279             }
 280             typ = ASN1_TYPE_get(at);
 281             if ((typ == V_ASN1_OBJECT)
 282                 || (typ == V_ASN1_NULL)) {
 283                 BIO_printf(bio_err, "Can't parse %s type\n",
 284                            typ == V_ASN1_NULL ? "NULL" : "OBJECT");
 285                 ERR_print_errors(bio_err);
 286                 goto end;
 287             }
 288             /* hmm... this is a little evil but it works */
 289             tmpbuf = at->value.asn1_string->data;
 290             tmplen = at->value.asn1_string->length;
 291         }
 292         str = (char *)tmpbuf;
 293         num = tmplen;
 294     }
 295
 296     if (offset >= num) {
 297         BIO_printf(bio_err, "Error: offset too large\n");
 298         goto end;
 299     }
 300
 301     num -= offset;
 302
 303     if ((length == 0) || ((long)length > num))
 304         length = (unsigned int)num;
 305     if (derout) {
 306         if (BIO_write(derout, str + offset, length) != (int)length) {
 307             BIO_printf(bio_err, "Error writing output\n");
 308             ERR_print_errors(bio_err);
 309             goto end;
 310         }
 311     }
 312     if (!noout &&
 313         !ASN1_parse_dump(bio_out, (unsigned char *)&(str[offset]), length,
 314                          indent, dump)) {
 315         ERR_print_errors(bio_err);
 316         goto end;
 317     }
 318     ret = 0;
 319  end:
 320     BIO_free(derout);
 321     BIO_free(in);
 322     BIO_free(b64);
 323     if (ret != 0)
 324         ERR_print_errors(bio_err);
 325     BUF_MEM_free(buf);
 326     OPENSSL_free(name);
 327     OPENSSL_free(header);
 328     if (strictpem)
 329         OPENSSL_free(str);
 330     ASN1_TYPE_free(at);
 331     sk_OPENSSL_STRING_free(osk);
 332     OBJ_cleanup();
 333     return (ret);
 334 }
 335
 336 static int do_generate(char *genstr, char *genconf, BUF_MEM *buf)
 337 {
 338     CONF *cnf = NULL;
 339     int len;
 340     unsigned char *p;
 341     ASN1_TYPE *atyp = NULL;
 342
 343     if (genconf) {
 344         if ((cnf = app_load_config(genconf)) == NULL)
 345             goto err;
 346         if (!genstr)
 347             genstr = NCONF_get_string(cnf, "default", "asn1");
 348         if (!genstr) {
 349             BIO_printf(bio_err, "Can't find 'asn1' in '%s'\n", genconf);
 350             goto err;
 351         }
 352     }
 353
 354     atyp = ASN1_generate_nconf(genstr, cnf);
 355     NCONF_free(cnf);
 356     cnf = NULL;
 357
 358     if (!atyp)
 359         return -1;
 360
 361     len = i2d_ASN1_TYPE(atyp, NULL);
 362
 363     if (len <= 0)
 364         goto err;
 365
 366     if (!BUF_MEM_grow(buf, len))
 367         goto err;
 368
 369     p = (unsigned char *)buf->data;
 370
 371     i2d_ASN1_TYPE(atyp, &p);
 372
 373     ASN1_TYPE_free(atyp);
 374     return len;
 375
 376  err:
 377     NCONF_free(cnf);
 378     ASN1_TYPE_free(atyp);
 379     return -1;
 380 }