1*de0e0e4dSAntonio Huete Jimenez /* $OpenBSD: a_strex.c,v 1.31 2021/12/25 12:11:57 jsing Exp $ */
2f5b1c8a1SJohn Marino /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3f5b1c8a1SJohn Marino * project 2000.
4f5b1c8a1SJohn Marino */
5f5b1c8a1SJohn Marino /* ====================================================================
6f5b1c8a1SJohn Marino * Copyright (c) 2000 The OpenSSL Project. All rights reserved.
7f5b1c8a1SJohn Marino *
8f5b1c8a1SJohn Marino * Redistribution and use in source and binary forms, with or without
9f5b1c8a1SJohn Marino * modification, are permitted provided that the following conditions
10f5b1c8a1SJohn Marino * are met:
11f5b1c8a1SJohn Marino *
12f5b1c8a1SJohn Marino * 1. Redistributions of source code must retain the above copyright
13f5b1c8a1SJohn Marino * notice, this list of conditions and the following disclaimer.
14f5b1c8a1SJohn Marino *
15f5b1c8a1SJohn Marino * 2. Redistributions in binary form must reproduce the above copyright
16f5b1c8a1SJohn Marino * notice, this list of conditions and the following disclaimer in
17f5b1c8a1SJohn Marino * the documentation and/or other materials provided with the
18f5b1c8a1SJohn Marino * distribution.
19f5b1c8a1SJohn Marino *
20f5b1c8a1SJohn Marino * 3. All advertising materials mentioning features or use of this
21f5b1c8a1SJohn Marino * software must display the following acknowledgment:
22f5b1c8a1SJohn Marino * "This product includes software developed by the OpenSSL Project
23f5b1c8a1SJohn Marino * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24f5b1c8a1SJohn Marino *
25f5b1c8a1SJohn Marino * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26f5b1c8a1SJohn Marino * endorse or promote products derived from this software without
27f5b1c8a1SJohn Marino * prior written permission. For written permission, please contact
28f5b1c8a1SJohn Marino * licensing@OpenSSL.org.
29f5b1c8a1SJohn Marino *
30f5b1c8a1SJohn Marino * 5. Products derived from this software may not be called "OpenSSL"
31f5b1c8a1SJohn Marino * nor may "OpenSSL" appear in their names without prior written
32f5b1c8a1SJohn Marino * permission of the OpenSSL Project.
33f5b1c8a1SJohn Marino *
34f5b1c8a1SJohn Marino * 6. Redistributions of any form whatsoever must retain the following
35f5b1c8a1SJohn Marino * acknowledgment:
36f5b1c8a1SJohn Marino * "This product includes software developed by the OpenSSL Project
37f5b1c8a1SJohn Marino * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38f5b1c8a1SJohn Marino *
39f5b1c8a1SJohn Marino * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40f5b1c8a1SJohn Marino * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41f5b1c8a1SJohn Marino * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42f5b1c8a1SJohn Marino * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43f5b1c8a1SJohn Marino * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44f5b1c8a1SJohn Marino * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45f5b1c8a1SJohn Marino * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46f5b1c8a1SJohn Marino * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47f5b1c8a1SJohn Marino * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48f5b1c8a1SJohn Marino * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49f5b1c8a1SJohn Marino * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50f5b1c8a1SJohn Marino * OF THE POSSIBILITY OF SUCH DAMAGE.
51f5b1c8a1SJohn Marino * ====================================================================
52f5b1c8a1SJohn Marino *
53f5b1c8a1SJohn Marino * This product includes cryptographic software written by Eric Young
54f5b1c8a1SJohn Marino * (eay@cryptsoft.com). This product includes software written by Tim
55f5b1c8a1SJohn Marino * Hudson (tjh@cryptsoft.com).
56f5b1c8a1SJohn Marino *
57f5b1c8a1SJohn Marino */
58f5b1c8a1SJohn Marino
59f5b1c8a1SJohn Marino #include <stdio.h>
60f5b1c8a1SJohn Marino #include <string.h>
61f5b1c8a1SJohn Marino
62f5b1c8a1SJohn Marino #include <openssl/asn1.h>
63f5b1c8a1SJohn Marino #include <openssl/crypto.h>
64f5b1c8a1SJohn Marino #include <openssl/x509.h>
65f5b1c8a1SJohn Marino
66f5b1c8a1SJohn Marino #include "asn1_locl.h"
67f5b1c8a1SJohn Marino
68f5b1c8a1SJohn Marino #include "charmap.h"
69f5b1c8a1SJohn Marino
70f5b1c8a1SJohn Marino /* ASN1_STRING_print_ex() and X509_NAME_print_ex().
71f5b1c8a1SJohn Marino * Enhanced string and name printing routines handling
72f5b1c8a1SJohn Marino * multibyte characters, RFC2253 and a host of other
73f5b1c8a1SJohn Marino * options.
74f5b1c8a1SJohn Marino */
75f5b1c8a1SJohn Marino
76f5b1c8a1SJohn Marino #define CHARTYPE_BS_ESC (ASN1_STRFLGS_ESC_2253 | CHARTYPE_FIRST_ESC_2253 | CHARTYPE_LAST_ESC_2253)
77f5b1c8a1SJohn Marino
78f5b1c8a1SJohn Marino #define ESC_FLAGS (ASN1_STRFLGS_ESC_2253 | \
79f5b1c8a1SJohn Marino ASN1_STRFLGS_ESC_QUOTE | \
80f5b1c8a1SJohn Marino ASN1_STRFLGS_ESC_CTRL | \
81f5b1c8a1SJohn Marino ASN1_STRFLGS_ESC_MSB)
82f5b1c8a1SJohn Marino
83f5b1c8a1SJohn Marino
84f5b1c8a1SJohn Marino /* Three IO functions for sending data to memory, a BIO and
85f5b1c8a1SJohn Marino * and a FILE pointer.
86f5b1c8a1SJohn Marino */
87f5b1c8a1SJohn Marino static int
send_bio_chars(void * arg,const void * buf,int len)88f5b1c8a1SJohn Marino send_bio_chars(void *arg, const void *buf, int len)
89f5b1c8a1SJohn Marino {
90f5b1c8a1SJohn Marino if (!arg)
91f5b1c8a1SJohn Marino return 1;
92f5b1c8a1SJohn Marino if (BIO_write(arg, buf, len) != len)
93f5b1c8a1SJohn Marino return 0;
94f5b1c8a1SJohn Marino return 1;
95f5b1c8a1SJohn Marino }
96f5b1c8a1SJohn Marino
97f5b1c8a1SJohn Marino static int
send_fp_chars(void * arg,const void * buf,int len)98f5b1c8a1SJohn Marino send_fp_chars(void *arg, const void *buf, int len)
99f5b1c8a1SJohn Marino {
100f5b1c8a1SJohn Marino if (!arg)
101f5b1c8a1SJohn Marino return 1;
102f5b1c8a1SJohn Marino if (fwrite(buf, 1, (size_t)len, arg) != (size_t)len)
103f5b1c8a1SJohn Marino return 0;
104f5b1c8a1SJohn Marino return 1;
105f5b1c8a1SJohn Marino }
106f5b1c8a1SJohn Marino
107f5b1c8a1SJohn Marino typedef int char_io(void *arg, const void *buf, int len);
108f5b1c8a1SJohn Marino
109f5b1c8a1SJohn Marino /* This function handles display of
110f5b1c8a1SJohn Marino * strings, one character at a time.
111f5b1c8a1SJohn Marino * It is passed an unsigned long for each
112f5b1c8a1SJohn Marino * character because it could come from 2 or even
113f5b1c8a1SJohn Marino * 4 byte forms.
114f5b1c8a1SJohn Marino */
115f5b1c8a1SJohn Marino
116f5b1c8a1SJohn Marino static int
do_esc_char(unsigned long c,unsigned char flags,char * do_quotes,char_io * io_ch,void * arg)117f5b1c8a1SJohn Marino do_esc_char(unsigned long c, unsigned char flags, char *do_quotes,
118f5b1c8a1SJohn Marino char_io *io_ch, void *arg)
119f5b1c8a1SJohn Marino {
120f5b1c8a1SJohn Marino unsigned char chflgs, chtmp;
121f5b1c8a1SJohn Marino char tmphex[sizeof(long) * 2 + 3];
122f5b1c8a1SJohn Marino
123f5b1c8a1SJohn Marino if (c > 0xffffffffL)
124f5b1c8a1SJohn Marino return -1;
125f5b1c8a1SJohn Marino if (c > 0xffff) {
126f5b1c8a1SJohn Marino snprintf(tmphex, sizeof tmphex, "\\W%08lX", c);
127f5b1c8a1SJohn Marino if (!io_ch(arg, tmphex, 10))
128f5b1c8a1SJohn Marino return -1;
129f5b1c8a1SJohn Marino return 10;
130f5b1c8a1SJohn Marino }
131f5b1c8a1SJohn Marino if (c > 0xff) {
132f5b1c8a1SJohn Marino snprintf(tmphex, sizeof tmphex, "\\U%04lX", c);
133f5b1c8a1SJohn Marino if (!io_ch(arg, tmphex, 6))
134f5b1c8a1SJohn Marino return -1;
135f5b1c8a1SJohn Marino return 6;
136f5b1c8a1SJohn Marino }
137f5b1c8a1SJohn Marino chtmp = (unsigned char)c;
138f5b1c8a1SJohn Marino if (chtmp > 0x7f)
139f5b1c8a1SJohn Marino chflgs = flags & ASN1_STRFLGS_ESC_MSB;
140f5b1c8a1SJohn Marino else
141f5b1c8a1SJohn Marino chflgs = char_type[chtmp] & flags;
142f5b1c8a1SJohn Marino if (chflgs & CHARTYPE_BS_ESC) {
143f5b1c8a1SJohn Marino /* If we don't escape with quotes, signal we need quotes */
144f5b1c8a1SJohn Marino if (chflgs & ASN1_STRFLGS_ESC_QUOTE) {
145f5b1c8a1SJohn Marino if (do_quotes)
146f5b1c8a1SJohn Marino *do_quotes = 1;
147f5b1c8a1SJohn Marino if (!io_ch(arg, &chtmp, 1))
148f5b1c8a1SJohn Marino return -1;
149f5b1c8a1SJohn Marino return 1;
150f5b1c8a1SJohn Marino }
151f5b1c8a1SJohn Marino if (!io_ch(arg, "\\", 1))
152f5b1c8a1SJohn Marino return -1;
153f5b1c8a1SJohn Marino if (!io_ch(arg, &chtmp, 1))
154f5b1c8a1SJohn Marino return -1;
155f5b1c8a1SJohn Marino return 2;
156f5b1c8a1SJohn Marino }
157f5b1c8a1SJohn Marino if (chflgs & (ASN1_STRFLGS_ESC_CTRL|ASN1_STRFLGS_ESC_MSB)) {
158f5b1c8a1SJohn Marino snprintf(tmphex, sizeof tmphex, "\\%02X", chtmp);
159f5b1c8a1SJohn Marino if (!io_ch(arg, tmphex, 3))
160f5b1c8a1SJohn Marino return -1;
161f5b1c8a1SJohn Marino return 3;
162f5b1c8a1SJohn Marino }
163f5b1c8a1SJohn Marino /* If we get this far and do any escaping at all must escape
164f5b1c8a1SJohn Marino * the escape character itself: backslash.
165f5b1c8a1SJohn Marino */
166f5b1c8a1SJohn Marino if (chtmp == '\\' && flags & ESC_FLAGS) {
167f5b1c8a1SJohn Marino if (!io_ch(arg, "\\\\", 2))
168f5b1c8a1SJohn Marino return -1;
169f5b1c8a1SJohn Marino return 2;
170f5b1c8a1SJohn Marino }
171f5b1c8a1SJohn Marino if (!io_ch(arg, &chtmp, 1))
172f5b1c8a1SJohn Marino return -1;
173f5b1c8a1SJohn Marino return 1;
174f5b1c8a1SJohn Marino }
175f5b1c8a1SJohn Marino
176f5b1c8a1SJohn Marino #define BUF_TYPE_WIDTH_MASK 0x7
177f5b1c8a1SJohn Marino #define BUF_TYPE_CONVUTF8 0x8
178f5b1c8a1SJohn Marino
179f5b1c8a1SJohn Marino /* This function sends each character in a buffer to
180f5b1c8a1SJohn Marino * do_esc_char(). It interprets the content formats
181f5b1c8a1SJohn Marino * and converts to or from UTF8 as appropriate.
182f5b1c8a1SJohn Marino */
183f5b1c8a1SJohn Marino
184f5b1c8a1SJohn Marino static int
do_buf(unsigned char * buf,int buflen,int type,unsigned char flags,char * quotes,char_io * io_ch,void * arg)185f5b1c8a1SJohn Marino do_buf(unsigned char *buf, int buflen, int type, unsigned char flags,
186f5b1c8a1SJohn Marino char *quotes, char_io *io_ch, void *arg)
187f5b1c8a1SJohn Marino {
188f5b1c8a1SJohn Marino int i, outlen, len;
189f5b1c8a1SJohn Marino unsigned char orflags, *p, *q;
190f5b1c8a1SJohn Marino unsigned long c;
191f5b1c8a1SJohn Marino
192f5b1c8a1SJohn Marino p = buf;
193f5b1c8a1SJohn Marino q = buf + buflen;
194f5b1c8a1SJohn Marino outlen = 0;
195f5b1c8a1SJohn Marino while (p != q) {
196f5b1c8a1SJohn Marino if (p == buf && flags & ASN1_STRFLGS_ESC_2253)
197f5b1c8a1SJohn Marino orflags = CHARTYPE_FIRST_ESC_2253;
198f5b1c8a1SJohn Marino else
199f5b1c8a1SJohn Marino orflags = 0;
200f5b1c8a1SJohn Marino switch (type & BUF_TYPE_WIDTH_MASK) {
201f5b1c8a1SJohn Marino case 4:
202f5b1c8a1SJohn Marino c = ((unsigned long)*p++) << 24;
203f5b1c8a1SJohn Marino c |= ((unsigned long)*p++) << 16;
204f5b1c8a1SJohn Marino c |= ((unsigned long)*p++) << 8;
205f5b1c8a1SJohn Marino c |= *p++;
206f5b1c8a1SJohn Marino if (c > UNICODE_MAX || UNICODE_IS_SURROGATE(c))
207f5b1c8a1SJohn Marino return -1;
208f5b1c8a1SJohn Marino break;
209f5b1c8a1SJohn Marino
210f5b1c8a1SJohn Marino case 2:
211f5b1c8a1SJohn Marino c = ((unsigned long)*p++) << 8;
212f5b1c8a1SJohn Marino c |= *p++;
213f5b1c8a1SJohn Marino if (UNICODE_IS_SURROGATE(c))
214f5b1c8a1SJohn Marino return -1;
215f5b1c8a1SJohn Marino break;
216f5b1c8a1SJohn Marino
217f5b1c8a1SJohn Marino case 1:
218f5b1c8a1SJohn Marino c = *p++;
219f5b1c8a1SJohn Marino break;
220f5b1c8a1SJohn Marino
221f5b1c8a1SJohn Marino case 0:
222f5b1c8a1SJohn Marino i = UTF8_getc(p, q - p, &c);
223f5b1c8a1SJohn Marino if (i < 0)
224f5b1c8a1SJohn Marino return -1; /* Invalid UTF8String */
225f5b1c8a1SJohn Marino p += i;
226f5b1c8a1SJohn Marino break;
227f5b1c8a1SJohn Marino default:
228f5b1c8a1SJohn Marino return -1; /* invalid width */
229f5b1c8a1SJohn Marino }
230f5b1c8a1SJohn Marino if (p == q && flags & ASN1_STRFLGS_ESC_2253)
231f5b1c8a1SJohn Marino orflags = CHARTYPE_LAST_ESC_2253;
232f5b1c8a1SJohn Marino if (type & BUF_TYPE_CONVUTF8) {
233f5b1c8a1SJohn Marino unsigned char utfbuf[6];
234f5b1c8a1SJohn Marino int utflen;
235f5b1c8a1SJohn Marino
236f5b1c8a1SJohn Marino utflen = UTF8_putc(utfbuf, sizeof utfbuf, c);
237f5b1c8a1SJohn Marino if (utflen < 0)
238f5b1c8a1SJohn Marino return -1;
239f5b1c8a1SJohn Marino for (i = 0; i < utflen; i++) {
240f5b1c8a1SJohn Marino /* We don't need to worry about setting orflags correctly
241f5b1c8a1SJohn Marino * because if utflen==1 its value will be correct anyway
242f5b1c8a1SJohn Marino * otherwise each character will be > 0x7f and so the
243f5b1c8a1SJohn Marino * character will never be escaped on first and last.
244f5b1c8a1SJohn Marino */
245f5b1c8a1SJohn Marino len = do_esc_char(utfbuf[i],
246f5b1c8a1SJohn Marino (unsigned char)(flags | orflags), quotes,
247f5b1c8a1SJohn Marino io_ch, arg);
248f5b1c8a1SJohn Marino if (len < 0)
249f5b1c8a1SJohn Marino return -1;
250f5b1c8a1SJohn Marino outlen += len;
251f5b1c8a1SJohn Marino }
252f5b1c8a1SJohn Marino } else {
253f5b1c8a1SJohn Marino len = do_esc_char(c, (unsigned char)(flags | orflags),
254f5b1c8a1SJohn Marino quotes, io_ch, arg);
255f5b1c8a1SJohn Marino if (len < 0)
256f5b1c8a1SJohn Marino return -1;
257f5b1c8a1SJohn Marino outlen += len;
258f5b1c8a1SJohn Marino }
259f5b1c8a1SJohn Marino }
260f5b1c8a1SJohn Marino return outlen;
261f5b1c8a1SJohn Marino }
262f5b1c8a1SJohn Marino
263f5b1c8a1SJohn Marino /* This function hex dumps a buffer of characters */
264f5b1c8a1SJohn Marino
265f5b1c8a1SJohn Marino static int
do_hex_dump(char_io * io_ch,void * arg,unsigned char * buf,int buflen)266f5b1c8a1SJohn Marino do_hex_dump(char_io *io_ch, void *arg, unsigned char *buf, int buflen)
267f5b1c8a1SJohn Marino {
268f5b1c8a1SJohn Marino static const char hexdig[] = "0123456789ABCDEF";
269f5b1c8a1SJohn Marino unsigned char *p, *q;
270f5b1c8a1SJohn Marino char hextmp[2];
271f5b1c8a1SJohn Marino if (arg) {
272f5b1c8a1SJohn Marino p = buf;
273f5b1c8a1SJohn Marino q = buf + buflen;
274f5b1c8a1SJohn Marino while (p != q) {
275f5b1c8a1SJohn Marino hextmp[0] = hexdig[*p >> 4];
276f5b1c8a1SJohn Marino hextmp[1] = hexdig[*p & 0xf];
277f5b1c8a1SJohn Marino if (!io_ch(arg, hextmp, 2))
278f5b1c8a1SJohn Marino return -1;
279f5b1c8a1SJohn Marino p++;
280f5b1c8a1SJohn Marino }
281f5b1c8a1SJohn Marino }
282f5b1c8a1SJohn Marino return buflen << 1;
283f5b1c8a1SJohn Marino }
284f5b1c8a1SJohn Marino
285f5b1c8a1SJohn Marino /* "dump" a string. This is done when the type is unknown,
286f5b1c8a1SJohn Marino * or the flags request it. We can either dump the content
287f5b1c8a1SJohn Marino * octets or the entire DER encoding. This uses the RFC2253
288f5b1c8a1SJohn Marino * #01234 format.
289f5b1c8a1SJohn Marino */
290f5b1c8a1SJohn Marino
291f5b1c8a1SJohn Marino static int
do_dump(unsigned long lflags,char_io * io_ch,void * arg,const ASN1_STRING * str)29272c33676SMaxim Ag do_dump(unsigned long lflags, char_io *io_ch, void *arg, const ASN1_STRING *str)
293f5b1c8a1SJohn Marino {
294f5b1c8a1SJohn Marino /* Placing the ASN1_STRING in a temp ASN1_TYPE allows
295f5b1c8a1SJohn Marino * the DER encoding to readily obtained
296f5b1c8a1SJohn Marino */
297f5b1c8a1SJohn Marino ASN1_TYPE t;
298f5b1c8a1SJohn Marino unsigned char *der_buf, *p;
299f5b1c8a1SJohn Marino int outlen, der_len;
300f5b1c8a1SJohn Marino
301f5b1c8a1SJohn Marino if (!io_ch(arg, "#", 1))
302f5b1c8a1SJohn Marino return -1;
303f5b1c8a1SJohn Marino /* If we don't dump DER encoding just dump content octets */
304f5b1c8a1SJohn Marino if (!(lflags & ASN1_STRFLGS_DUMP_DER)) {
305f5b1c8a1SJohn Marino outlen = do_hex_dump(io_ch, arg, str->data, str->length);
306f5b1c8a1SJohn Marino if (outlen < 0)
307f5b1c8a1SJohn Marino return -1;
308f5b1c8a1SJohn Marino return outlen + 1;
309f5b1c8a1SJohn Marino }
310f5b1c8a1SJohn Marino t.type = str->type;
311f5b1c8a1SJohn Marino t.value.ptr = (char *)str;
312f5b1c8a1SJohn Marino der_len = i2d_ASN1_TYPE(&t, NULL);
313f5b1c8a1SJohn Marino der_buf = malloc(der_len);
314f5b1c8a1SJohn Marino if (!der_buf)
315f5b1c8a1SJohn Marino return -1;
316f5b1c8a1SJohn Marino p = der_buf;
317f5b1c8a1SJohn Marino i2d_ASN1_TYPE(&t, &p);
318f5b1c8a1SJohn Marino outlen = do_hex_dump(io_ch, arg, der_buf, der_len);
319f5b1c8a1SJohn Marino free(der_buf);
320f5b1c8a1SJohn Marino if (outlen < 0)
321f5b1c8a1SJohn Marino return -1;
322f5b1c8a1SJohn Marino return outlen + 1;
323f5b1c8a1SJohn Marino }
324f5b1c8a1SJohn Marino
325f5b1c8a1SJohn Marino /* This is the main function, print out an
326f5b1c8a1SJohn Marino * ASN1_STRING taking note of various escape
327f5b1c8a1SJohn Marino * and display options. Returns number of
328f5b1c8a1SJohn Marino * characters written or -1 if an error
329f5b1c8a1SJohn Marino * occurred.
330f5b1c8a1SJohn Marino */
331f5b1c8a1SJohn Marino
332f5b1c8a1SJohn Marino static int
do_print_ex(char_io * io_ch,void * arg,unsigned long lflags,const ASN1_STRING * str)33372c33676SMaxim Ag do_print_ex(char_io *io_ch, void *arg, unsigned long lflags,
33472c33676SMaxim Ag const ASN1_STRING *str)
335f5b1c8a1SJohn Marino {
336f5b1c8a1SJohn Marino int outlen, len;
337f5b1c8a1SJohn Marino int type;
338f5b1c8a1SJohn Marino char quotes;
339f5b1c8a1SJohn Marino unsigned char flags;
340f5b1c8a1SJohn Marino
341f5b1c8a1SJohn Marino quotes = 0;
342f5b1c8a1SJohn Marino /* Keep a copy of escape flags */
343f5b1c8a1SJohn Marino flags = (unsigned char)(lflags & ESC_FLAGS);
344f5b1c8a1SJohn Marino type = str->type;
345f5b1c8a1SJohn Marino outlen = 0;
346f5b1c8a1SJohn Marino
347f5b1c8a1SJohn Marino if (lflags & ASN1_STRFLGS_SHOW_TYPE) {
348f5b1c8a1SJohn Marino const char *tagname;
349f5b1c8a1SJohn Marino tagname = ASN1_tag2str(type);
350f5b1c8a1SJohn Marino outlen += strlen(tagname);
351f5b1c8a1SJohn Marino if (!io_ch(arg, tagname, outlen) || !io_ch(arg, ":", 1))
352f5b1c8a1SJohn Marino return -1;
353f5b1c8a1SJohn Marino outlen++;
354f5b1c8a1SJohn Marino }
355f5b1c8a1SJohn Marino
356f5b1c8a1SJohn Marino /* Decide what to do with type, either dump content or display it */
357f5b1c8a1SJohn Marino
358*de0e0e4dSAntonio Huete Jimenez if (lflags & ASN1_STRFLGS_DUMP_ALL) {
359*de0e0e4dSAntonio Huete Jimenez /* Dump everything. */
360f5b1c8a1SJohn Marino type = -1;
361*de0e0e4dSAntonio Huete Jimenez } else if (lflags & ASN1_STRFLGS_IGNORE_TYPE) {
362*de0e0e4dSAntonio Huete Jimenez /* Ignore the string type. */
363f5b1c8a1SJohn Marino type = 1;
364*de0e0e4dSAntonio Huete Jimenez } else {
365*de0e0e4dSAntonio Huete Jimenez /* Else determine width based on type. */
366*de0e0e4dSAntonio Huete Jimenez type = asn1_tag2charwidth(type);
367*de0e0e4dSAntonio Huete Jimenez if (type == -1 && !(lflags & ASN1_STRFLGS_DUMP_UNKNOWN))
368f5b1c8a1SJohn Marino type = 1;
369f5b1c8a1SJohn Marino }
370f5b1c8a1SJohn Marino
371f5b1c8a1SJohn Marino if (type == -1) {
372f5b1c8a1SJohn Marino len = do_dump(lflags, io_ch, arg, str);
373f5b1c8a1SJohn Marino if (len < 0)
374f5b1c8a1SJohn Marino return -1;
375f5b1c8a1SJohn Marino outlen += len;
376f5b1c8a1SJohn Marino return outlen;
377f5b1c8a1SJohn Marino }
378f5b1c8a1SJohn Marino
379f5b1c8a1SJohn Marino if (lflags & ASN1_STRFLGS_UTF8_CONVERT) {
380f5b1c8a1SJohn Marino /* Note: if string is UTF8 and we want
381f5b1c8a1SJohn Marino * to convert to UTF8 then we just interpret
382f5b1c8a1SJohn Marino * it as 1 byte per character to avoid converting
383f5b1c8a1SJohn Marino * twice.
384f5b1c8a1SJohn Marino */
385f5b1c8a1SJohn Marino if (!type)
386f5b1c8a1SJohn Marino type = 1;
387f5b1c8a1SJohn Marino else
388f5b1c8a1SJohn Marino type |= BUF_TYPE_CONVUTF8;
389f5b1c8a1SJohn Marino }
390f5b1c8a1SJohn Marino
391f5b1c8a1SJohn Marino len = do_buf(str->data, str->length, type, flags, "es, io_ch, NULL);
392f5b1c8a1SJohn Marino if (len < 0)
393f5b1c8a1SJohn Marino return -1;
394f5b1c8a1SJohn Marino outlen += len;
395f5b1c8a1SJohn Marino if (quotes)
396f5b1c8a1SJohn Marino outlen += 2;
397f5b1c8a1SJohn Marino if (!arg)
398f5b1c8a1SJohn Marino return outlen;
399f5b1c8a1SJohn Marino if (quotes && !io_ch(arg, "\"", 1))
400f5b1c8a1SJohn Marino return -1;
401f5b1c8a1SJohn Marino if (do_buf(str->data, str->length, type, flags, NULL, io_ch, arg) < 0)
402f5b1c8a1SJohn Marino return -1;
403f5b1c8a1SJohn Marino if (quotes && !io_ch(arg, "\"", 1))
404f5b1c8a1SJohn Marino return -1;
405f5b1c8a1SJohn Marino return outlen;
406f5b1c8a1SJohn Marino }
407f5b1c8a1SJohn Marino
408f5b1c8a1SJohn Marino /* Used for line indenting: print 'indent' spaces */
409f5b1c8a1SJohn Marino
410f5b1c8a1SJohn Marino static int
do_indent(char_io * io_ch,void * arg,int indent)411f5b1c8a1SJohn Marino do_indent(char_io *io_ch, void *arg, int indent)
412f5b1c8a1SJohn Marino {
413f5b1c8a1SJohn Marino int i;
414f5b1c8a1SJohn Marino for (i = 0; i < indent; i++)
415f5b1c8a1SJohn Marino if (!io_ch(arg, " ", 1))
416f5b1c8a1SJohn Marino return 0;
417f5b1c8a1SJohn Marino return 1;
418f5b1c8a1SJohn Marino }
419f5b1c8a1SJohn Marino
420f5b1c8a1SJohn Marino #define FN_WIDTH_LN 25
421f5b1c8a1SJohn Marino #define FN_WIDTH_SN 10
422f5b1c8a1SJohn Marino
423f5b1c8a1SJohn Marino static int
do_name_ex(char_io * io_ch,void * arg,const X509_NAME * n,int indent,unsigned long flags)42472c33676SMaxim Ag do_name_ex(char_io *io_ch, void *arg, const X509_NAME *n, int indent,
425f5b1c8a1SJohn Marino unsigned long flags)
426f5b1c8a1SJohn Marino {
427f5b1c8a1SJohn Marino int i, prev = -1, orflags, cnt;
428f5b1c8a1SJohn Marino int fn_opt, fn_nid;
429f5b1c8a1SJohn Marino ASN1_OBJECT *fn;
430f5b1c8a1SJohn Marino ASN1_STRING *val;
431f5b1c8a1SJohn Marino X509_NAME_ENTRY *ent;
432f5b1c8a1SJohn Marino char objtmp[80];
433f5b1c8a1SJohn Marino const char *objbuf;
434f5b1c8a1SJohn Marino int outlen, len;
435f5b1c8a1SJohn Marino char *sep_dn, *sep_mv, *sep_eq;
436f5b1c8a1SJohn Marino int sep_dn_len, sep_mv_len, sep_eq_len;
437f5b1c8a1SJohn Marino
438f5b1c8a1SJohn Marino if (indent < 0)
439f5b1c8a1SJohn Marino indent = 0;
440f5b1c8a1SJohn Marino outlen = indent;
441f5b1c8a1SJohn Marino if (!do_indent(io_ch, arg, indent))
442f5b1c8a1SJohn Marino return -1;
443f5b1c8a1SJohn Marino
444f5b1c8a1SJohn Marino switch (flags & XN_FLAG_SEP_MASK) {
445f5b1c8a1SJohn Marino case XN_FLAG_SEP_MULTILINE:
446f5b1c8a1SJohn Marino sep_dn = "\n";
447f5b1c8a1SJohn Marino sep_dn_len = 1;
448f5b1c8a1SJohn Marino sep_mv = " + ";
449f5b1c8a1SJohn Marino sep_mv_len = 3;
450f5b1c8a1SJohn Marino break;
451f5b1c8a1SJohn Marino
452f5b1c8a1SJohn Marino case XN_FLAG_SEP_COMMA_PLUS:
453f5b1c8a1SJohn Marino sep_dn = ",";
454f5b1c8a1SJohn Marino sep_dn_len = 1;
455f5b1c8a1SJohn Marino sep_mv = "+";
456f5b1c8a1SJohn Marino sep_mv_len = 1;
457f5b1c8a1SJohn Marino indent = 0;
458f5b1c8a1SJohn Marino break;
459f5b1c8a1SJohn Marino
460f5b1c8a1SJohn Marino case XN_FLAG_SEP_CPLUS_SPC:
461f5b1c8a1SJohn Marino sep_dn = ", ";
462f5b1c8a1SJohn Marino sep_dn_len = 2;
463f5b1c8a1SJohn Marino sep_mv = " + ";
464f5b1c8a1SJohn Marino sep_mv_len = 3;
465f5b1c8a1SJohn Marino indent = 0;
466f5b1c8a1SJohn Marino break;
467f5b1c8a1SJohn Marino
468f5b1c8a1SJohn Marino case XN_FLAG_SEP_SPLUS_SPC:
469f5b1c8a1SJohn Marino sep_dn = "; ";
470f5b1c8a1SJohn Marino sep_dn_len = 2;
471f5b1c8a1SJohn Marino sep_mv = " + ";
472f5b1c8a1SJohn Marino sep_mv_len = 3;
473f5b1c8a1SJohn Marino indent = 0;
474f5b1c8a1SJohn Marino break;
475f5b1c8a1SJohn Marino
476f5b1c8a1SJohn Marino default:
477f5b1c8a1SJohn Marino return -1;
478f5b1c8a1SJohn Marino }
479f5b1c8a1SJohn Marino
480f5b1c8a1SJohn Marino if (flags & XN_FLAG_SPC_EQ) {
481f5b1c8a1SJohn Marino sep_eq = " = ";
482f5b1c8a1SJohn Marino sep_eq_len = 3;
483f5b1c8a1SJohn Marino } else {
484f5b1c8a1SJohn Marino sep_eq = "=";
485f5b1c8a1SJohn Marino sep_eq_len = 1;
486f5b1c8a1SJohn Marino }
487f5b1c8a1SJohn Marino
488f5b1c8a1SJohn Marino fn_opt = flags & XN_FLAG_FN_MASK;
489f5b1c8a1SJohn Marino
490f5b1c8a1SJohn Marino cnt = X509_NAME_entry_count(n);
491f5b1c8a1SJohn Marino for (i = 0; i < cnt; i++) {
492f5b1c8a1SJohn Marino if (flags & XN_FLAG_DN_REV)
493f5b1c8a1SJohn Marino ent = X509_NAME_get_entry(n, cnt - i - 1);
494f5b1c8a1SJohn Marino else
495f5b1c8a1SJohn Marino ent = X509_NAME_get_entry(n, i);
496f5b1c8a1SJohn Marino if (prev != -1) {
497*de0e0e4dSAntonio Huete Jimenez if (prev == X509_NAME_ENTRY_set(ent)) {
498f5b1c8a1SJohn Marino if (!io_ch(arg, sep_mv, sep_mv_len))
499f5b1c8a1SJohn Marino return -1;
500f5b1c8a1SJohn Marino outlen += sep_mv_len;
501f5b1c8a1SJohn Marino } else {
502f5b1c8a1SJohn Marino if (!io_ch(arg, sep_dn, sep_dn_len))
503f5b1c8a1SJohn Marino return -1;
504f5b1c8a1SJohn Marino outlen += sep_dn_len;
505f5b1c8a1SJohn Marino if (!do_indent(io_ch, arg, indent))
506f5b1c8a1SJohn Marino return -1;
507f5b1c8a1SJohn Marino outlen += indent;
508f5b1c8a1SJohn Marino }
509f5b1c8a1SJohn Marino }
510*de0e0e4dSAntonio Huete Jimenez prev = X509_NAME_ENTRY_set(ent);
511f5b1c8a1SJohn Marino fn = X509_NAME_ENTRY_get_object(ent);
512f5b1c8a1SJohn Marino val = X509_NAME_ENTRY_get_data(ent);
513f5b1c8a1SJohn Marino fn_nid = OBJ_obj2nid(fn);
514f5b1c8a1SJohn Marino if (fn_opt != XN_FLAG_FN_NONE) {
515f5b1c8a1SJohn Marino int objlen, fld_len;
516f5b1c8a1SJohn Marino if ((fn_opt == XN_FLAG_FN_OID) ||
517f5b1c8a1SJohn Marino (fn_nid == NID_undef)) {
518f5b1c8a1SJohn Marino OBJ_obj2txt(objtmp, sizeof objtmp, fn, 1);
519f5b1c8a1SJohn Marino fld_len = 0; /* XXX: what should this be? */
520f5b1c8a1SJohn Marino objbuf = objtmp;
521f5b1c8a1SJohn Marino } else {
522f5b1c8a1SJohn Marino if (fn_opt == XN_FLAG_FN_SN) {
523f5b1c8a1SJohn Marino fld_len = FN_WIDTH_SN;
524f5b1c8a1SJohn Marino objbuf = OBJ_nid2sn(fn_nid);
525f5b1c8a1SJohn Marino } else if (fn_opt == XN_FLAG_FN_LN) {
526f5b1c8a1SJohn Marino fld_len = FN_WIDTH_LN;
527f5b1c8a1SJohn Marino objbuf = OBJ_nid2ln(fn_nid);
528f5b1c8a1SJohn Marino } else {
529f5b1c8a1SJohn Marino fld_len = 0; /* XXX: what should this be? */
530f5b1c8a1SJohn Marino objbuf = "";
531f5b1c8a1SJohn Marino }
532f5b1c8a1SJohn Marino }
533f5b1c8a1SJohn Marino objlen = strlen(objbuf);
534f5b1c8a1SJohn Marino if (!io_ch(arg, objbuf, objlen))
535f5b1c8a1SJohn Marino return -1;
536f5b1c8a1SJohn Marino if ((objlen < fld_len) && (flags & XN_FLAG_FN_ALIGN)) {
537f5b1c8a1SJohn Marino if (!do_indent(io_ch, arg, fld_len - objlen))
538f5b1c8a1SJohn Marino return -1;
539f5b1c8a1SJohn Marino outlen += fld_len - objlen;
540f5b1c8a1SJohn Marino }
541f5b1c8a1SJohn Marino if (!io_ch(arg, sep_eq, sep_eq_len))
542f5b1c8a1SJohn Marino return -1;
543f5b1c8a1SJohn Marino outlen += objlen + sep_eq_len;
544f5b1c8a1SJohn Marino }
545f5b1c8a1SJohn Marino /* If the field name is unknown then fix up the DER dump
546f5b1c8a1SJohn Marino * flag. We might want to limit this further so it will
547f5b1c8a1SJohn Marino * DER dump on anything other than a few 'standard' fields.
548f5b1c8a1SJohn Marino */
549f5b1c8a1SJohn Marino if ((fn_nid == NID_undef) &&
550f5b1c8a1SJohn Marino (flags & XN_FLAG_DUMP_UNKNOWN_FIELDS))
551f5b1c8a1SJohn Marino orflags = ASN1_STRFLGS_DUMP_ALL;
552f5b1c8a1SJohn Marino else
553f5b1c8a1SJohn Marino orflags = 0;
554f5b1c8a1SJohn Marino
555f5b1c8a1SJohn Marino len = do_print_ex(io_ch, arg, flags | orflags, val);
556f5b1c8a1SJohn Marino if (len < 0)
557f5b1c8a1SJohn Marino return -1;
558f5b1c8a1SJohn Marino outlen += len;
559f5b1c8a1SJohn Marino }
560f5b1c8a1SJohn Marino return outlen;
561f5b1c8a1SJohn Marino }
562f5b1c8a1SJohn Marino
563f5b1c8a1SJohn Marino /* Wrappers round the main functions */
564f5b1c8a1SJohn Marino
565f5b1c8a1SJohn Marino int
X509_NAME_print_ex(BIO * out,const X509_NAME * nm,int indent,unsigned long flags)56672c33676SMaxim Ag X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent,
56772c33676SMaxim Ag unsigned long flags)
568f5b1c8a1SJohn Marino {
569f5b1c8a1SJohn Marino if (flags == XN_FLAG_COMPAT)
570f5b1c8a1SJohn Marino return X509_NAME_print(out, nm, indent);
571f5b1c8a1SJohn Marino return do_name_ex(send_bio_chars, out, nm, indent, flags);
572f5b1c8a1SJohn Marino }
573f5b1c8a1SJohn Marino
574f5b1c8a1SJohn Marino int
X509_NAME_print_ex_fp(FILE * fp,const X509_NAME * nm,int indent,unsigned long flags)57572c33676SMaxim Ag X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
57672c33676SMaxim Ag unsigned long flags)
577f5b1c8a1SJohn Marino {
578f5b1c8a1SJohn Marino if (flags == XN_FLAG_COMPAT) {
579f5b1c8a1SJohn Marino BIO *btmp;
580f5b1c8a1SJohn Marino int ret;
581f5b1c8a1SJohn Marino btmp = BIO_new_fp(fp, BIO_NOCLOSE);
582f5b1c8a1SJohn Marino if (!btmp)
583f5b1c8a1SJohn Marino return -1;
584f5b1c8a1SJohn Marino ret = X509_NAME_print(btmp, nm, indent);
585f5b1c8a1SJohn Marino BIO_free(btmp);
586f5b1c8a1SJohn Marino return ret;
587f5b1c8a1SJohn Marino }
588f5b1c8a1SJohn Marino return do_name_ex(send_fp_chars, fp, nm, indent, flags);
589f5b1c8a1SJohn Marino }
590f5b1c8a1SJohn Marino
591f5b1c8a1SJohn Marino int
ASN1_STRING_print_ex(BIO * out,const ASN1_STRING * str,unsigned long flags)59272c33676SMaxim Ag ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags)
593f5b1c8a1SJohn Marino {
594f5b1c8a1SJohn Marino return do_print_ex(send_bio_chars, out, flags, str);
595f5b1c8a1SJohn Marino }
596f5b1c8a1SJohn Marino
597f5b1c8a1SJohn Marino int
ASN1_STRING_print_ex_fp(FILE * fp,const ASN1_STRING * str,unsigned long flags)59872c33676SMaxim Ag ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags)
599f5b1c8a1SJohn Marino {
600f5b1c8a1SJohn Marino return do_print_ex(send_fp_chars, fp, flags, str);
601f5b1c8a1SJohn Marino }
602