1 /*
2 * Copyright 2000-2021 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (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 <stddef.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/asn1.h>
13 #include <openssl/asn1t.h>
14 #include <openssl/objects.h>
15 #include <openssl/buffer.h>
16 #include <openssl/err.h>
17 #include <openssl/x509v3.h>
18 #include "crypto/asn1.h"
19 #include "asn1_local.h"
20
21 /*
22 * Print routines.
23 */
24
25 /* ASN1_PCTX routines */
26
27 static ASN1_PCTX default_pctx = {
28 ASN1_PCTX_FLAGS_SHOW_ABSENT, /* flags */
29 0, /* nm_flags */
30 0, /* cert_flags */
31 0, /* oid_flags */
32 0 /* str_flags */
33 };
34
ASN1_PCTX_new(void)35 ASN1_PCTX *ASN1_PCTX_new(void)
36 {
37 ASN1_PCTX *ret;
38
39 ret = OPENSSL_zalloc(sizeof(*ret));
40 if (ret == NULL)
41 return NULL;
42 return ret;
43 }
44
ASN1_PCTX_free(ASN1_PCTX * p)45 void ASN1_PCTX_free(ASN1_PCTX *p)
46 {
47 OPENSSL_free(p);
48 }
49
ASN1_PCTX_get_flags(const ASN1_PCTX * p)50 unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p)
51 {
52 return p->flags;
53 }
54
ASN1_PCTX_set_flags(ASN1_PCTX * p,unsigned long flags)55 void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags)
56 {
57 p->flags = flags;
58 }
59
ASN1_PCTX_get_nm_flags(const ASN1_PCTX * p)60 unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p)
61 {
62 return p->nm_flags;
63 }
64
ASN1_PCTX_set_nm_flags(ASN1_PCTX * p,unsigned long flags)65 void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags)
66 {
67 p->nm_flags = flags;
68 }
69
ASN1_PCTX_get_cert_flags(const ASN1_PCTX * p)70 unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p)
71 {
72 return p->cert_flags;
73 }
74
ASN1_PCTX_set_cert_flags(ASN1_PCTX * p,unsigned long flags)75 void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags)
76 {
77 p->cert_flags = flags;
78 }
79
ASN1_PCTX_get_oid_flags(const ASN1_PCTX * p)80 unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p)
81 {
82 return p->oid_flags;
83 }
84
ASN1_PCTX_set_oid_flags(ASN1_PCTX * p,unsigned long flags)85 void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags)
86 {
87 p->oid_flags = flags;
88 }
89
ASN1_PCTX_get_str_flags(const ASN1_PCTX * p)90 unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p)
91 {
92 return p->str_flags;
93 }
94
ASN1_PCTX_set_str_flags(ASN1_PCTX * p,unsigned long flags)95 void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags)
96 {
97 p->str_flags = flags;
98 }
99
100 /* Main print routines */
101
102 static int asn1_item_print_ctx(BIO *out, const ASN1_VALUE **fld, int indent,
103 const ASN1_ITEM *it,
104 const char *fname, const char *sname,
105 int nohdr, const ASN1_PCTX *pctx);
106
107 static int asn1_template_print_ctx(BIO *out, const ASN1_VALUE **fld, int indent,
108 const ASN1_TEMPLATE *tt, const ASN1_PCTX *pctx);
109
110 static int asn1_primitive_print(BIO *out, const ASN1_VALUE **fld,
111 const ASN1_ITEM *it, int indent,
112 const char *fname, const char *sname,
113 const ASN1_PCTX *pctx);
114
115 static int asn1_print_fsname(BIO *out, int indent,
116 const char *fname, const char *sname,
117 const ASN1_PCTX *pctx);
118
ASN1_item_print(BIO * out,const ASN1_VALUE * ifld,int indent,const ASN1_ITEM * it,const ASN1_PCTX * pctx)119 int ASN1_item_print(BIO *out, const ASN1_VALUE *ifld, int indent,
120 const ASN1_ITEM *it, const ASN1_PCTX *pctx)
121 {
122 const char *sname;
123 if (pctx == NULL)
124 pctx = &default_pctx;
125 if (pctx->flags & ASN1_PCTX_FLAGS_NO_STRUCT_NAME)
126 sname = NULL;
127 else
128 sname = it->sname;
129 return asn1_item_print_ctx(out, &ifld, indent, it, NULL, sname, 0, pctx);
130 }
131
asn1_item_print_ctx(BIO * out,const ASN1_VALUE ** fld,int indent,const ASN1_ITEM * it,const char * fname,const char * sname,int nohdr,const ASN1_PCTX * pctx)132 static int asn1_item_print_ctx(BIO *out, const ASN1_VALUE **fld, int indent,
133 const ASN1_ITEM *it,
134 const char *fname, const char *sname,
135 int nohdr, const ASN1_PCTX *pctx)
136 {
137 const ASN1_TEMPLATE *tt;
138 const ASN1_EXTERN_FUNCS *ef;
139 const ASN1_VALUE **tmpfld;
140 const ASN1_AUX *aux = it->funcs;
141 ASN1_aux_const_cb *asn1_cb = NULL;
142 ASN1_PRINT_ARG parg;
143 int i;
144 if (aux != NULL) {
145 parg.out = out;
146 parg.indent = indent;
147 parg.pctx = pctx;
148 asn1_cb = ((aux->flags & ASN1_AFLG_CONST_CB) != 0) ? aux->asn1_const_cb
149 : (ASN1_aux_const_cb *)aux->asn1_cb; /* backward compatibility */
150 }
151
152 if (((it->itype != ASN1_ITYPE_PRIMITIVE)
153 || (it->utype != V_ASN1_BOOLEAN)) && *fld == NULL) {
154 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_ABSENT) {
155 if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
156 return 0;
157 if (BIO_puts(out, "<ABSENT>\n") <= 0)
158 return 0;
159 }
160 return 1;
161 }
162
163 switch (it->itype) {
164 case ASN1_ITYPE_PRIMITIVE:
165 if (it->templates) {
166 if (!asn1_template_print_ctx(out, fld, indent,
167 it->templates, pctx))
168 return 0;
169 break;
170 }
171 /* fall through */
172 case ASN1_ITYPE_MSTRING:
173 if (!asn1_primitive_print(out, fld, it, indent, fname, sname, pctx))
174 return 0;
175 break;
176
177 case ASN1_ITYPE_EXTERN:
178 if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
179 return 0;
180 /* Use new style print routine if possible */
181 ef = it->funcs;
182 if (ef && ef->asn1_ex_print) {
183 i = ef->asn1_ex_print(out, fld, indent, "", pctx);
184 if (!i)
185 return 0;
186 if ((i == 2) && (BIO_puts(out, "\n") <= 0))
187 return 0;
188 return 1;
189 } else if (sname &&
190 BIO_printf(out, ":EXTERNAL TYPE %s\n", sname) <= 0)
191 return 0;
192 break;
193
194 case ASN1_ITYPE_CHOICE:
195 /* CHOICE type, get selector */
196 i = ossl_asn1_get_choice_selector_const(fld, it);
197 /* This should never happen... */
198 if ((i < 0) || (i >= it->tcount)) {
199 if (BIO_printf(out, "ERROR: selector [%d] invalid\n", i) <= 0)
200 return 0;
201 return 1;
202 }
203 tt = it->templates + i;
204 tmpfld = ossl_asn1_get_const_field_ptr(fld, tt);
205 if (!asn1_template_print_ctx(out, tmpfld, indent, tt, pctx))
206 return 0;
207 break;
208
209 case ASN1_ITYPE_SEQUENCE:
210 case ASN1_ITYPE_NDEF_SEQUENCE:
211 if (!nohdr && !asn1_print_fsname(out, indent, fname, sname, pctx))
212 return 0;
213 if (fname || sname) {
214 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) {
215 if (BIO_puts(out, " {\n") <= 0)
216 return 0;
217 } else {
218 if (BIO_puts(out, "\n") <= 0)
219 return 0;
220 }
221 }
222
223 if (asn1_cb) {
224 i = asn1_cb(ASN1_OP_PRINT_PRE, fld, it, &parg);
225 if (i == 0)
226 return 0;
227 if (i == 2)
228 return 1;
229 }
230
231 /* Print each field entry */
232 for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) {
233 const ASN1_TEMPLATE *seqtt;
234 seqtt = ossl_asn1_do_adb(*fld, tt, 1);
235 if (!seqtt)
236 return 0;
237 tmpfld = ossl_asn1_get_const_field_ptr(fld, seqtt);
238 if (!asn1_template_print_ctx(out, tmpfld,
239 indent + 2, seqtt, pctx))
240 return 0;
241 }
242 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) {
243 if (BIO_printf(out, "%*s}\n", indent, "") < 0)
244 return 0;
245 }
246
247 if (asn1_cb) {
248 i = asn1_cb(ASN1_OP_PRINT_POST, fld, it, &parg);
249 if (i == 0)
250 return 0;
251 }
252 break;
253
254 default:
255 BIO_printf(out, "Unprocessed type %d\n", it->itype);
256 return 0;
257 }
258
259 return 1;
260 }
261
asn1_template_print_ctx(BIO * out,const ASN1_VALUE ** fld,int indent,const ASN1_TEMPLATE * tt,const ASN1_PCTX * pctx)262 static int asn1_template_print_ctx(BIO *out, const ASN1_VALUE **fld, int indent,
263 const ASN1_TEMPLATE *tt, const ASN1_PCTX *pctx)
264 {
265 int i, flags;
266 const char *sname, *fname;
267 const ASN1_VALUE *tfld;
268 flags = tt->flags;
269 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME)
270 sname = ASN1_ITEM_ptr(tt->item)->sname;
271 else
272 sname = NULL;
273 if (pctx->flags & ASN1_PCTX_FLAGS_NO_FIELD_NAME)
274 fname = NULL;
275 else
276 fname = tt->field_name;
277
278 /*
279 * If field is embedded then fld needs fixing so it is a pointer to
280 * a pointer to a field.
281 */
282 if (flags & ASN1_TFLG_EMBED) {
283 tfld = (const ASN1_VALUE *)fld;
284 fld = &tfld;
285 }
286
287 if (flags & ASN1_TFLG_SK_MASK) {
288 char *tname;
289 const ASN1_VALUE *skitem;
290 STACK_OF(const_ASN1_VALUE) *stack;
291
292 /* SET OF, SEQUENCE OF */
293 if (fname) {
294 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SSOF) {
295 if (flags & ASN1_TFLG_SET_OF)
296 tname = "SET";
297 else
298 tname = "SEQUENCE";
299 if (BIO_printf(out, "%*s%s OF %s {\n",
300 indent, "", tname, tt->field_name) <= 0)
301 return 0;
302 } else if (BIO_printf(out, "%*s%s:\n", indent, "", fname) <= 0)
303 return 0;
304 }
305 stack = (STACK_OF(const_ASN1_VALUE) *)*fld;
306 for (i = 0; i < sk_const_ASN1_VALUE_num(stack); i++) {
307 if ((i > 0) && (BIO_puts(out, "\n") <= 0))
308 return 0;
309
310 skitem = sk_const_ASN1_VALUE_value(stack, i);
311 if (!asn1_item_print_ctx(out, &skitem, indent + 2,
312 ASN1_ITEM_ptr(tt->item), NULL, NULL, 1,
313 pctx))
314 return 0;
315 }
316 if (i == 0 && BIO_printf(out, "%*s<%s>\n", indent + 2, "",
317 stack == NULL ? "ABSENT" : "EMPTY") <= 0)
318 return 0;
319 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) {
320 if (BIO_printf(out, "%*s}\n", indent, "") <= 0)
321 return 0;
322 }
323 return 1;
324 }
325 return asn1_item_print_ctx(out, fld, indent, ASN1_ITEM_ptr(tt->item),
326 fname, sname, 0, pctx);
327 }
328
asn1_print_fsname(BIO * out,int indent,const char * fname,const char * sname,const ASN1_PCTX * pctx)329 static int asn1_print_fsname(BIO *out, int indent,
330 const char *fname, const char *sname,
331 const ASN1_PCTX *pctx)
332 {
333 static const char spaces[] = " ";
334 static const int nspaces = sizeof(spaces) - 1;
335
336 while (indent > nspaces) {
337 if (BIO_write(out, spaces, nspaces) != nspaces)
338 return 0;
339 indent -= nspaces;
340 }
341 if (BIO_write(out, spaces, indent) != indent)
342 return 0;
343 if (pctx->flags & ASN1_PCTX_FLAGS_NO_STRUCT_NAME)
344 sname = NULL;
345 if (pctx->flags & ASN1_PCTX_FLAGS_NO_FIELD_NAME)
346 fname = NULL;
347 if (!sname && !fname)
348 return 1;
349 if (fname) {
350 if (BIO_puts(out, fname) <= 0)
351 return 0;
352 }
353 if (sname) {
354 if (fname) {
355 if (BIO_printf(out, " (%s)", sname) <= 0)
356 return 0;
357 } else {
358 if (BIO_puts(out, sname) <= 0)
359 return 0;
360 }
361 }
362 if (BIO_write(out, ": ", 2) != 2)
363 return 0;
364 return 1;
365 }
366
asn1_print_boolean(BIO * out,int boolval)367 static int asn1_print_boolean(BIO *out, int boolval)
368 {
369 const char *str;
370 switch (boolval) {
371 case -1:
372 str = "BOOL ABSENT";
373 break;
374
375 case 0:
376 str = "FALSE";
377 break;
378
379 default:
380 str = "TRUE";
381 break;
382
383 }
384
385 if (BIO_puts(out, str) <= 0)
386 return 0;
387 return 1;
388
389 }
390
asn1_print_integer(BIO * out,const ASN1_INTEGER * str)391 static int asn1_print_integer(BIO *out, const ASN1_INTEGER *str)
392 {
393 char *s;
394 int ret = 1;
395 s = i2s_ASN1_INTEGER(NULL, str);
396 if (s == NULL)
397 return 0;
398 if (BIO_puts(out, s) <= 0)
399 ret = 0;
400 OPENSSL_free(s);
401 return ret;
402 }
403
asn1_print_oid(BIO * out,const ASN1_OBJECT * oid)404 static int asn1_print_oid(BIO *out, const ASN1_OBJECT *oid)
405 {
406 char objbuf[80];
407 const char *ln;
408 ln = OBJ_nid2ln(OBJ_obj2nid(oid));
409 if (!ln)
410 ln = "";
411 OBJ_obj2txt(objbuf, sizeof(objbuf), oid, 1);
412 if (BIO_printf(out, "%s (%s)", ln, objbuf) <= 0)
413 return 0;
414 return 1;
415 }
416
asn1_print_obstring(BIO * out,const ASN1_STRING * str,int indent)417 static int asn1_print_obstring(BIO *out, const ASN1_STRING *str, int indent)
418 {
419 if (str->type == V_ASN1_BIT_STRING) {
420 if (BIO_printf(out, " (%ld unused bits)\n", str->flags & 0x7) <= 0)
421 return 0;
422 } else if (BIO_puts(out, "\n") <= 0)
423 return 0;
424 if ((str->length > 0)
425 && BIO_dump_indent(out, (const char *)str->data, str->length,
426 indent + 2) <= 0)
427 return 0;
428 return 1;
429 }
430
asn1_primitive_print(BIO * out,const ASN1_VALUE ** fld,const ASN1_ITEM * it,int indent,const char * fname,const char * sname,const ASN1_PCTX * pctx)431 static int asn1_primitive_print(BIO *out, const ASN1_VALUE **fld,
432 const ASN1_ITEM *it, int indent,
433 const char *fname, const char *sname,
434 const ASN1_PCTX *pctx)
435 {
436 long utype;
437 ASN1_STRING *str;
438 int ret = 1, needlf = 1;
439 const char *pname;
440 const ASN1_PRIMITIVE_FUNCS *pf;
441 pf = it->funcs;
442 if (!asn1_print_fsname(out, indent, fname, sname, pctx))
443 return 0;
444 if (pf && pf->prim_print)
445 return pf->prim_print(out, fld, it, indent, pctx);
446 if (it->itype == ASN1_ITYPE_MSTRING) {
447 str = (ASN1_STRING *)*fld;
448 utype = str->type & ~V_ASN1_NEG;
449 } else {
450 utype = it->utype;
451 if (utype == V_ASN1_BOOLEAN)
452 str = NULL;
453 else
454 str = (ASN1_STRING *)*fld;
455 }
456 if (utype == V_ASN1_ANY) {
457 const ASN1_TYPE *atype = (const ASN1_TYPE *)*fld;
458 utype = atype->type;
459 fld = (const ASN1_VALUE **)&atype->value.asn1_value; /* actually is const */
460 str = (ASN1_STRING *)*fld;
461 if (pctx->flags & ASN1_PCTX_FLAGS_NO_ANY_TYPE)
462 pname = NULL;
463 else
464 pname = ASN1_tag2str(utype);
465 } else {
466 if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_TYPE)
467 pname = ASN1_tag2str(utype);
468 else
469 pname = NULL;
470 }
471
472 if (utype == V_ASN1_NULL) {
473 if (BIO_puts(out, "NULL\n") <= 0)
474 return 0;
475 return 1;
476 }
477
478 if (pname) {
479 if (BIO_puts(out, pname) <= 0)
480 return 0;
481 if (BIO_puts(out, ":") <= 0)
482 return 0;
483 }
484
485 switch (utype) {
486 case V_ASN1_BOOLEAN:
487 {
488 int boolval = *(int *)fld;
489 if (boolval == -1)
490 boolval = it->size;
491 ret = asn1_print_boolean(out, boolval);
492 }
493 break;
494
495 case V_ASN1_INTEGER:
496 case V_ASN1_ENUMERATED:
497 ret = asn1_print_integer(out, str);
498 break;
499
500 case V_ASN1_UTCTIME:
501 ret = ASN1_UTCTIME_print(out, str);
502 break;
503
504 case V_ASN1_GENERALIZEDTIME:
505 ret = ASN1_GENERALIZEDTIME_print(out, str);
506 break;
507
508 case V_ASN1_OBJECT:
509 ret = asn1_print_oid(out, (const ASN1_OBJECT *)*fld);
510 break;
511
512 case V_ASN1_OCTET_STRING:
513 case V_ASN1_BIT_STRING:
514 ret = asn1_print_obstring(out, str, indent);
515 needlf = 0;
516 break;
517
518 case V_ASN1_SEQUENCE:
519 case V_ASN1_SET:
520 case V_ASN1_OTHER:
521 if (BIO_puts(out, "\n") <= 0)
522 return 0;
523 if (ASN1_parse_dump(out, str->data, str->length, indent, 0) <= 0)
524 ret = 0;
525 needlf = 0;
526 break;
527
528 default:
529 ret = ASN1_STRING_print_ex(out, str, pctx->str_flags);
530
531 }
532 if (!ret)
533 return 0;
534 if (needlf && BIO_puts(out, "\n") <= 0)
535 return 0;
536 return 1;
537 }
538
