/src/openssl/crypto/x509v3/v3_prn.c

Source (jump to first uncovered line)
/* v3_prn.c */
/*
 * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
 * 1999.
 */
/* ====================================================================
 * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */
/* X509 v3 extension utilities */

#include <stdio.h>
#include "cryptlib.h"
#include <openssl/conf.h>
#include <openssl/x509v3.h>

/* Extension printing routines */

static int unknown_ext_print(BIO *out, X509_EXTENSION *ext,
                             unsigned long flag, int indent, int supported);

/* Print out a name+value stack */

void X509V3_EXT_val_prn(BIO *out, STACK_OF(CONF_VALUE) *val, int indent,
                        int ml)
{
    int i;
    CONF_VALUE *nval;
    if (!val)
        return;
    if (!ml || !sk_CONF_VALUE_num(val)) {
        BIO_printf(out, "%*s", indent, "");
        if (!sk_CONF_VALUE_num(val))
            BIO_puts(out, "<EMPTY>\n");
    }
    for (i = 0; i < sk_CONF_VALUE_num(val); i++) {
        if (ml)
            BIO_printf(out, "%*s", indent, "");
        else if (i > 0)
            BIO_printf(out, ", ");
        nval = sk_CONF_VALUE_value(val, i);
        if (!nval->name)
            BIO_puts(out, nval->value);
        else if (!nval->value)
            BIO_puts(out, nval->name);
#ifndef CHARSET_EBCDIC
        else
            BIO_printf(out, "%s:%s", nval->name, nval->value);
#else
        else {
            int len;
            char *tmp;
            len = strlen(nval->value) + 1;
            tmp = OPENSSL_malloc(len);
            if (tmp) {
                ascii2ebcdic(tmp, nval->value, len);
                BIO_printf(out, "%s:%s", nval->name, tmp);
                OPENSSL_free(tmp);
            }
        }
#endif
        if (ml)
            BIO_puts(out, "\n");
    }
}

/* Main routine: print out a general extension */

int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, unsigned long flag,
                     int indent)
{
    void *ext_str = NULL;
    char *value = NULL;
    const unsigned char *p;
    const X509V3_EXT_METHOD *method;
    STACK_OF(CONF_VALUE) *nval = NULL;
    int ok = 1;

    if (!(method = X509V3_EXT_get(ext)))
        return unknown_ext_print(out, ext, flag, indent, 0);
    p = ext->value->data;
    if (method->it)
        ext_str =
            ASN1_item_d2i(NULL, &p, ext->value->length,
                          ASN1_ITEM_ptr(method->it));
    else
        ext_str = method->d2i(NULL, &p, ext->value->length);

    if (!ext_str)
        return unknown_ext_print(out, ext, flag, indent, 1);

    if (method->i2s) {
        if (!(value = method->i2s(method, ext_str))) {
            ok = 0;
            goto err;
        }
#ifndef CHARSET_EBCDIC
        BIO_printf(out, "%*s%s", indent, "", value);
#else
        {
            int len;
            char *tmp;
            len = strlen(value) + 1;
            tmp = OPENSSL_malloc(len);
            if (tmp) {
                ascii2ebcdic(tmp, value, len);
                BIO_printf(out, "%*s%s", indent, "", tmp);
                OPENSSL_free(tmp);
            }
        }
#endif
    } else if (method->i2v) {
        if (!(nval = method->i2v(method, ext_str, NULL))) {
            ok = 0;
            goto err;
        }
        X509V3_EXT_val_prn(out, nval, indent,
                           method->ext_flags & X509V3_EXT_MULTILINE);
    } else if (method->i2r) {
        if (!method->i2r(method, ext_str, out, indent))
            ok = 0;
    } else
        ok = 0;

 err:
    sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
    if (value)
        OPENSSL_free(value);
    if (method->it)
        ASN1_item_free(ext_str, ASN1_ITEM_ptr(method->it));
    else
        method->ext_free(ext_str);
    return ok;
}

int X509V3_extensions_print(BIO *bp, char *title,
                            STACK_OF(X509_EXTENSION) *exts,
                            unsigned long flag, int indent)
{
    int i, j;

    if (sk_X509_EXTENSION_num(exts) <= 0)
        return 1;

    if (title) {
        BIO_printf(bp, "%*s%s:\n", indent, "", title);
        indent += 4;
    }

    for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
        ASN1_OBJECT *obj;
        X509_EXTENSION *ex;
        ex = sk_X509_EXTENSION_value(exts, i);
        if (indent && BIO_printf(bp, "%*s", indent, "") <= 0)
            return 0;
        obj = X509_EXTENSION_get_object(ex);
        i2a_ASN1_OBJECT(bp, obj);
        j = X509_EXTENSION_get_critical(ex);
        if (BIO_printf(bp, ": %s\n", j ? "critical" : "") <= 0)
            return 0;
        if (!X509V3_EXT_print(bp, ex, flag, indent + 4)) {
            BIO_printf(bp, "%*s", indent + 4, "");
            M_ASN1_OCTET_STRING_print(bp, ex->value);
        }
        if (BIO_write(bp, "\n", 1) <= 0)
            return 0;
    }
    return 1;
}

static int unknown_ext_print(BIO *out, X509_EXTENSION *ext,
                             unsigned long flag, int indent, int supported)
{
    switch (flag & X509V3_EXT_UNKNOWN_MASK) {

    case X509V3_EXT_DEFAULT:
        return 0;

    case X509V3_EXT_ERROR_UNKNOWN:
        if (supported)
            BIO_printf(out, "%*s<Parse Error>", indent, "");
        else
            BIO_printf(out, "%*s<Not Supported>", indent, "");
        return 1;

    case X509V3_EXT_PARSE_UNKNOWN:
        return ASN1_parse_dump(out,
                               ext->value->data, ext->value->length, indent,
                               -1);
    case X509V3_EXT_DUMP_UNKNOWN:
        return BIO_dump_indent(out, (char *)ext->value->data,
                               ext->value->length, indent);

    default:
        return 1;
    }
}

#ifndef OPENSSL_NO_FP_API
int X509V3_EXT_print_fp(FILE *fp, X509_EXTENSION *ext, int flag, int indent)
{
    BIO *bio_tmp;
    int ret;
    if (!(bio_tmp = BIO_new_fp(fp, BIO_NOCLOSE)))
        return 0;
    ret = X509V3_EXT_print(bio_tmp, ext, flag, indent);
    BIO_free(bio_tmp);
    return ret;
}
#endif

Coverage Report

Created: 2022-11-30 06:20

Line	Count	Source (jump to first uncovered line)
1		/* v3_prn.c */
2		/*
3		* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
4		* 1999.
5		*/
6		/* ====================================================================
7		* Copyright (c) 1999 The OpenSSL Project. All rights reserved.
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		*
13		* 1. Redistributions of source code must retain the above copyright
14		* notice, this list of conditions and the following disclaimer.
15		*
16		* 2. Redistributions in binary form must reproduce the above copyright
17		* notice, this list of conditions and the following disclaimer in
18		* the documentation and/or other materials provided with the
19		* distribution.
20		*
21		* 3. All advertising materials mentioning features or use of this
22		* software must display the following acknowledgment:
23		* "This product includes software developed by the OpenSSL Project
24		* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25		*
26		* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27		* endorse or promote products derived from this software without
28		* prior written permission. For written permission, please contact
29		* licensing@OpenSSL.org.
30		*
31		* 5. Products derived from this software may not be called "OpenSSL"
32		* nor may "OpenSSL" appear in their names without prior written
33		* permission of the OpenSSL Project.
34		*
35		* 6. Redistributions of any form whatsoever must retain the following
36		* acknowledgment:
37		* "This product includes software developed by the OpenSSL Project
38		* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39		*
40		* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41		* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43		* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
44		* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46		* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47		* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49		* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51		* OF THE POSSIBILITY OF SUCH DAMAGE.
52		* ====================================================================
53		*
54		* This product includes cryptographic software written by Eric Young
55		* (eay@cryptsoft.com). This product includes software written by Tim
56		* Hudson (tjh@cryptsoft.com).
57		*
58		*/
59		/* X509 v3 extension utilities */
60
61		#include <stdio.h>
62		#include "cryptlib.h"
63		#include <openssl/conf.h>
64		#include <openssl/x509v3.h>
65
66		/* Extension printing routines */
67
68		static int unknown_ext_print(BIO out, X509_EXTENSION ext,
69		unsigned long flag, int indent, int supported);
70
71		/* Print out a name+value stack */
72
73		void X509V3_EXT_val_prn(BIO out, STACK_OF(CONF_VALUE) val, int indent,
74		int ml)
75	0	{
76	0	int i;
77	0	CONF_VALUE *nval;
78	0	if (!val)
79	0	return;
80	0	if (!ml \|\| !sk_CONF_VALUE_num(val)) {
81	0	BIO_printf(out, "%*s", indent, "");
82	0	if (!sk_CONF_VALUE_num(val))
83	0	BIO_puts(out, "<EMPTY>\n");
84	0	}
85	0	for (i = 0; i < sk_CONF_VALUE_num(val); i++) {
86	0	if (ml)
87	0	BIO_printf(out, "%*s", indent, "");
88	0	else if (i > 0)
89	0	BIO_printf(out, ", ");
90	0	nval = sk_CONF_VALUE_value(val, i);
91	0	if (!nval->name)
92	0	BIO_puts(out, nval->value);
93	0	else if (!nval->value)
94	0	BIO_puts(out, nval->name);
95	0	#ifndef CHARSET_EBCDIC
96	0	else
97	0	BIO_printf(out, "%s:%s", nval->name, nval->value);
98		#else
99		else {
100		int len;
101		char *tmp;
102		len = strlen(nval->value) + 1;
103		tmp = OPENSSL_malloc(len);
104		if (tmp) {
105		ascii2ebcdic(tmp, nval->value, len);
106		BIO_printf(out, "%s:%s", nval->name, tmp);
107		OPENSSL_free(tmp);
108		}
109		}
110		#endif
111	0	if (ml)
112	0	BIO_puts(out, "\n");
113	0	}
114	0	}
115
116		/* Main routine: print out a general extension */
117
118		int X509V3_EXT_print(BIO out, X509_EXTENSION ext, unsigned long flag,
119		int indent)
120	0	{
121	0	void *ext_str = NULL;
122	0	char *value = NULL;
123	0	const unsigned char *p;
124	0	const X509V3_EXT_METHOD *method;
125	0	STACK_OF(CONF_VALUE) *nval = NULL;
126	0	int ok = 1;
127
128	0	if (!(method = X509V3_EXT_get(ext)))
129	0	return unknown_ext_print(out, ext, flag, indent, 0);
130	0	p = ext->value->data;
131	0	if (method->it)
132	0	ext_str =
133	0	ASN1_item_d2i(NULL, &p, ext->value->length,
134	0	ASN1_ITEM_ptr(method->it));
135	0	else
136	0	ext_str = method->d2i(NULL, &p, ext->value->length);
137
138	0	if (!ext_str)
139	0	return unknown_ext_print(out, ext, flag, indent, 1);
140
141	0	if (method->i2s) {
142	0	if (!(value = method->i2s(method, ext_str))) {
143	0	ok = 0;
144	0	goto err;
145	0	}
146	0	#ifndef CHARSET_EBCDIC
147	0	BIO_printf(out, "%*s%s", indent, "", value);
148		#else
149		{
150		int len;
151		char *tmp;
152		len = strlen(value) + 1;
153		tmp = OPENSSL_malloc(len);
154		if (tmp) {
155		ascii2ebcdic(tmp, value, len);
156		BIO_printf(out, "%*s%s", indent, "", tmp);
157		OPENSSL_free(tmp);
158		}
159		}
160		#endif
161	0	} else if (method->i2v) {
162	0	if (!(nval = method->i2v(method, ext_str, NULL))) {
163	0	ok = 0;
164	0	goto err;
165	0	}
166	0	X509V3_EXT_val_prn(out, nval, indent,
167	0	method->ext_flags & X509V3_EXT_MULTILINE);
168	0	} else if (method->i2r) {
169	0	if (!method->i2r(method, ext_str, out, indent))
170	0	ok = 0;
171	0	} else
172	0	ok = 0;
173
174	0	err:
175	0	sk_CONF_VALUE_pop_free(nval, X509V3_conf_free);
176	0	if (value)
177	0	OPENSSL_free(value);
178	0	if (method->it)
179	0	ASN1_item_free(ext_str, ASN1_ITEM_ptr(method->it));
180	0	else
181	0	method->ext_free(ext_str);
182	0	return ok;
183	0	}
184
185		int X509V3_extensions_print(BIO bp, char title,
186		STACK_OF(X509_EXTENSION) *exts,
187		unsigned long flag, int indent)
188	0	{
189	0	int i, j;
190
191	0	if (sk_X509_EXTENSION_num(exts) <= 0)
192	0	return 1;
193
194	0	if (title) {
195	0	BIO_printf(bp, "%*s%s:\n", indent, "", title);
196	0	indent += 4;
197	0	}
198
199	0	for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
200	0	ASN1_OBJECT *obj;
201	0	X509_EXTENSION *ex;
202	0	ex = sk_X509_EXTENSION_value(exts, i);
203	0	if (indent && BIO_printf(bp, "%*s", indent, "") <= 0)
204	0	return 0;
205	0	obj = X509_EXTENSION_get_object(ex);
206	0	i2a_ASN1_OBJECT(bp, obj);
207	0	j = X509_EXTENSION_get_critical(ex);
208	0	if (BIO_printf(bp, ": %s\n", j ? "critical" : "") <= 0)
209	0	return 0;
210	0	if (!X509V3_EXT_print(bp, ex, flag, indent + 4)) {
211	0	BIO_printf(bp, "%*s", indent + 4, "");
212	0	M_ASN1_OCTET_STRING_print(bp, ex->value);
213	0	}
214	0	if (BIO_write(bp, "\n", 1) <= 0)
215	0	return 0;
216	0	}
217	0	return 1;
218	0	}
219
220		static int unknown_ext_print(BIO out, X509_EXTENSION ext,
221		unsigned long flag, int indent, int supported)
222	0	{
223	0	switch (flag & X509V3_EXT_UNKNOWN_MASK) {
224
225	0	case X509V3_EXT_DEFAULT:
226	0	return 0;
227
228	0	case X509V3_EXT_ERROR_UNKNOWN:
229	0	if (supported)
230	0	BIO_printf(out, "%*s<Parse Error>", indent, "");
231	0	else
232	0	BIO_printf(out, "%*s<Not Supported>", indent, "");
233	0	return 1;
234
235	0	case X509V3_EXT_PARSE_UNKNOWN:
236	0	return ASN1_parse_dump(out,
237	0	ext->value->data, ext->value->length, indent,
238	0	-1);
239	0	case X509V3_EXT_DUMP_UNKNOWN:
240	0	return BIO_dump_indent(out, (char *)ext->value->data,
241	0	ext->value->length, indent);
242
243	0	default:
244	0	return 1;
245	0	}
246	0	}
247
248		#ifndef OPENSSL_NO_FP_API
249		int X509V3_EXT_print_fp(FILE fp, X509_EXTENSION ext, int flag, int indent)
250	0	{
251	0	BIO *bio_tmp;
252	0	int ret;
253	0	if (!(bio_tmp = BIO_new_fp(fp, BIO_NOCLOSE)))
254	0	return 0;
255	0	ret = X509V3_EXT_print(bio_tmp, ext, flag, indent);
256	0	BIO_free(bio_tmp);
257	0	return ret;
258	0	}
259		#endif