[thirdparty/openssl.git] / crypto / x509v3 / 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 "internal/cryptlib.h"
#include <openssl/conf.h>
#include <openssl/x509v3.h>

/* Extension printing routines */

static int unknown_ext_print(BIO *out, const unsigned char *ext, int extlen,
                             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 != NULL) {
                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;
    ASN1_OCTET_STRING *extoct;
    const unsigned char *p;
    int extlen;
    const X509V3_EXT_METHOD *method;
    STACK_OF(CONF_VALUE) *nval = NULL;
    int ok = 1;

    extoct = X509_EXTENSION_get_data(ext);
    p = ASN1_STRING_data(extoct);
    extlen = ASN1_STRING_length(extoct);

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

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

    if (method->i2s) {
        if ((value = method->i2s(method, ext_str)) == NULL) {
            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 != NULL) {
                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)) == 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);
    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, "");
            ASN1_STRING_print(bp, X509_EXTENSION_get_data(ex));
        }
        if (BIO_write(bp, "\n", 1) <= 0)
            return 0;
    }
    return 1;
}

static int unknown_ext_print(BIO *out, const unsigned char *ext, int extlen,
                             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, extlen, indent, -1);
    case X509V3_EXT_DUMP_UNKNOWN:
        return BIO_dump_indent(out, (char *)ext, extlen, indent);

    default:
        return 1;
    }
}

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