fix asn1parse -inform
[openssl.git] / 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");
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")) == NULL)
201         goto end;
202
203     if (derfile && (derout = bio_open_default(derfile, "wb")) == 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 }