[thirdparty/openssl.git] / crypto / asn1 / a_bytes.c

/* crypto/asn1/a_bytes.c */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 *
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 *
 * 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 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 acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 *
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS 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 AUTHOR OR 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.
 *
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

#include <stdio.h>
#include "cryptlib.h"
#include <openssl/asn1.h>

static int asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c);
/*
 * type is a 'bitmap' of acceptable string types.
 */
ASN1_STRING *d2i_ASN1_type_bytes(ASN1_STRING **a, const unsigned char **pp,
                                 long length, int type)
{
    ASN1_STRING *ret = NULL;
    const unsigned char *p;
    unsigned char *s;
    long len;
    int inf, tag, xclass;
    int i = 0;

    p = *pp;
    inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
    if (inf & 0x80)
        goto err;

    if (tag >= 32) {
        i = ASN1_R_TAG_VALUE_TOO_HIGH;
        goto err;
    }
    if (!(ASN1_tag2bit(tag) & type)) {
        i = ASN1_R_WRONG_TYPE;
        goto err;
    }

    /* If a bit-string, exit early */
    if (tag == V_ASN1_BIT_STRING)
        return (d2i_ASN1_BIT_STRING(a, pp, length));

    if ((a == NULL) || ((*a) == NULL)) {
        if ((ret = ASN1_STRING_new()) == NULL)
            return (NULL);
    } else
        ret = (*a);

    if (len != 0) {
        s = (unsigned char *)OPENSSL_malloc((int)len + 1);
        if (s == NULL) {
            i = ERR_R_MALLOC_FAILURE;
            goto err;
        }
        memcpy(s, p, (int)len);
        s[len] = '\0';
        p += len;
    } else
        s = NULL;

    if (ret->data != NULL)
        OPENSSL_free(ret->data);
    ret->length = (int)len;
    ret->data = s;
    ret->type = tag;
    if (a != NULL)
        (*a) = ret;
    *pp = p;
    return (ret);
 err:
    ASN1err(ASN1_F_D2I_ASN1_TYPE_BYTES, i);
    if ((ret != NULL) && ((a == NULL) || (*a != ret)))
        ASN1_STRING_free(ret);
    return (NULL);
}

int i2d_ASN1_bytes(ASN1_STRING *a, unsigned char **pp, int tag, int xclass)
{
    int ret, r, constructed;
    unsigned char *p;

    if (a == NULL)
        return (0);

    if (tag == V_ASN1_BIT_STRING)
        return (i2d_ASN1_BIT_STRING(a, pp));

    ret = a->length;
    r = ASN1_object_size(0, ret, tag);
    if (pp == NULL)
        return (r);
    p = *pp;

    if ((tag == V_ASN1_SEQUENCE) || (tag == V_ASN1_SET))
        constructed = 1;
    else
        constructed = 0;
    ASN1_put_object(&p, constructed, ret, tag, xclass);
    memcpy(p, a->data, a->length);
    p += a->length;
    *pp = p;
    return (r);
}

ASN1_STRING *d2i_ASN1_bytes(ASN1_STRING **a, const unsigned char **pp,
                            long length, int Ptag, int Pclass)
{
    ASN1_STRING *ret = NULL;
    const unsigned char *p;
    unsigned char *s;
    long len;
    int inf, tag, xclass;
    int i = 0;

    if ((a == NULL) || ((*a) == NULL)) {
        if ((ret = ASN1_STRING_new()) == NULL)
            return (NULL);
    } else
        ret = (*a);

    p = *pp;
    inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
    if (inf & 0x80) {
        i = ASN1_R_BAD_OBJECT_HEADER;
        goto err;
    }

    if (tag != Ptag) {
        i = ASN1_R_WRONG_TAG;
        goto err;
    }

    if (inf & V_ASN1_CONSTRUCTED) {
        ASN1_const_CTX c;

        c.pp = pp;
        c.p = p;
        c.inf = inf;
        c.slen = len;
        c.tag = Ptag;
        c.xclass = Pclass;
        c.max = (length == 0) ? 0 : (p + length);
        if (!asn1_collate_primitive(ret, &c))
            goto err;
        else {
            p = c.p;
        }
    } else {
        if (len != 0) {
            if ((ret->length < len) || (ret->data == NULL)) {
                if (ret->data != NULL)
                    OPENSSL_free(ret->data);
                s = (unsigned char *)OPENSSL_malloc((int)len + 1);
                if (s == NULL) {
                    i = ERR_R_MALLOC_FAILURE;
                    goto err;
                }
            } else
                s = ret->data;
            memcpy(s, p, (int)len);
            s[len] = '\0';
            p += len;
        } else {
            s = NULL;
            if (ret->data != NULL)
                OPENSSL_free(ret->data);
        }

        ret->length = (int)len;
        ret->data = s;
        ret->type = Ptag;
    }

    if (a != NULL)
        (*a) = ret;
    *pp = p;
    return (ret);
 err:
    if ((ret != NULL) && ((a == NULL) || (*a != ret)))
        ASN1_STRING_free(ret);
    ASN1err(ASN1_F_D2I_ASN1_BYTES, i);
    return (NULL);
}

/*
 * We are about to parse 0..n d2i_ASN1_bytes objects, we are to collapse them
 * into the one structure that is then returned
 */
/*
 * There have been a few bug fixes for this function from Paul Keogh
 * <paul.keogh@sse.ie>, many thanks to him
 */
static int asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c)
{
    ASN1_STRING *os = NULL;
    BUF_MEM b;
    int num;

    b.length = 0;
    b.max = 0;
    b.data = NULL;

    if (a == NULL) {
        c->error = ERR_R_PASSED_NULL_PARAMETER;
        goto err;
    }

    num = 0;
    for (;;) {
        if (c->inf & 1) {
            c->eos = ASN1_const_check_infinite_end(&c->p,
                                                   (long)(c->max - c->p));
            if (c->eos)
                break;
        } else {
            if (c->slen <= 0)
                break;
        }

        c->q = c->p;
        if (d2i_ASN1_bytes(&os, &c->p, c->max - c->p, c->tag, c->xclass)
            == NULL) {
            c->error = ERR_R_ASN1_LIB;
            goto err;
        }

        if (!BUF_MEM_grow_clean(&b, num + os->length)) {
            c->error = ERR_R_BUF_LIB;
            goto err;
        }
        memcpy(&(b.data[num]), os->data, os->length);
        if (!(c->inf & 1))
            c->slen -= (c->p - c->q);
        num += os->length;
    }

    if (!asn1_const_Finish(c))
        goto err;

    a->length = num;
    if (a->data != NULL)
        OPENSSL_free(a->data);
    a->data = (unsigned char *)b.data;
    if (os != NULL)
        ASN1_STRING_free(os);
    return (1);
 err:
    ASN1err(ASN1_F_ASN1_COLLATE_PRIMITIVE, c->error);
    if (os != NULL)
        ASN1_STRING_free(os);
    if (b.data != NULL)
        OPENSSL_free(b.data);
    return (0);
}
Commit	Line	Data
d02b48c6	1	/* crypto/asn1/a_bytes.c */
58964a49	2	/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
d02b48c6 RE	3	* All rights reserved.
	4	*
	5	* This package is an SSL implementation written
	6	* by Eric Young (eay@cryptsoft.com).
	7	* The implementation was written so as to conform with Netscapes SSL.
0f113f3e	8	*
d02b48c6 RE	9	* This library is free for commercial and non-commercial use as long as
	10	* the following conditions are aheared to. The following conditions
	11	* apply to all code found in this distribution, be it the RC4, RSA,
	12	* lhash, DES, etc., code; not just the SSL code. The SSL documentation
	13	* included with this distribution is covered by the same copyright terms
	14	* except that the holder is Tim Hudson (tjh@cryptsoft.com).
0f113f3e	15	*
d02b48c6 RE	16	* Copyright remains Eric Young's, and as such any Copyright notices in
	17	* the code are not to be removed.
	18	* If this package is used in a product, Eric Young should be given attribution
	19	* as the author of the parts of the library used.
	20	* This can be in the form of a textual message at program startup or
	21	* in documentation (online or textual) provided with the package.
0f113f3e	22	*
d02b48c6 RE	23	* Redistribution and use in source and binary forms, with or without
	24	* modification, are permitted provided that the following conditions
	25	* are met:
	26	* 1. Redistributions of source code must retain the copyright
	27	* notice, this list of conditions and the following disclaimer.
	28	* 2. Redistributions in binary form must reproduce the above copyright
	29	* notice, this list of conditions and the following disclaimer in the
	30	* documentation and/or other materials provided with the distribution.
	31	* 3. All advertising materials mentioning features or use of this software
	32	* must display the following acknowledgement:
	33	* "This product includes cryptographic software written by
	34	* Eric Young (eay@cryptsoft.com)"
	35	* The word 'cryptographic' can be left out if the rouines from the library
	36	* being used are not cryptographic related :-).
0f113f3e	37	* 4. If you include any Windows specific code (or a derivative thereof) from
d02b48c6 RE	38	* the apps directory (application code) you must include an acknowledgement:
d02b48c6 RE	39	* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
0f113f3e	40	*
d02b48c6 RE	41	* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
	42	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	43	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	44	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	45	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	46	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	47	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	48	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	49	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	50	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	51	* SUCH DAMAGE.
0f113f3e	52	*
d02b48c6 RE	53	* The licence and distribution terms for any publically available version or
	54	* derivative of this code cannot be changed. i.e. this code cannot simply be
	55	* copied and put under another distribution licence
	56	* [including the GNU Public Licence.]
	57	*/
	58
	59	#include <stdio.h>
	60	#include "cryptlib.h"
9d6b1ce6	61	#include <openssl/asn1.h>
d02b48c6	62
875a644a	63	static int asn1_collate_primitive(ASN1_STRING a, ASN1_const_CTX c);
0f113f3e MC	64	/*
0f113f3e MC	65	* type is a 'bitmap' of acceptable string types.
d02b48c6	66	*/
875a644a	67	ASN1_STRING d2i_ASN1_type_bytes(ASN1_STRING a, const unsigned char *pp,
0f113f3e MC	68	long length, int type)
	69	{
	70	ASN1_STRING *ret = NULL;
	71	const unsigned char *p;
	72	unsigned char *s;
	73	long len;
	74	int inf, tag, xclass;
	75	int i = 0;
d02b48c6	76
0f113f3e MC	77	p = *pp;
	78	inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
	79	if (inf & 0x80)
	80	goto err;
d02b48c6	81
0f113f3e MC	82	if (tag >= 32) {
	83	i = ASN1_R_TAG_VALUE_TOO_HIGH;
	84	goto err;
	85	}
	86	if (!(ASN1_tag2bit(tag) & type)) {
	87	i = ASN1_R_WRONG_TYPE;
	88	goto err;
	89	}
58964a49	90
0f113f3e MC	91	/* If a bit-string, exit early */
	92	if (tag == V_ASN1_BIT_STRING)
	93	return (d2i_ASN1_BIT_STRING(a, pp, length));
58964a49	94
0f113f3e MC	95	if ((a == NULL) \|\| ((*a) == NULL)) {
	96	if ((ret = ASN1_STRING_new()) == NULL)
	97	return (NULL);
	98	} else
	99	ret = (*a);
58964a49	100
0f113f3e MC	101	if (len != 0) {
	102	s = (unsigned char *)OPENSSL_malloc((int)len + 1);
	103	if (s == NULL) {
	104	i = ERR_R_MALLOC_FAILURE;
	105	goto err;
	106	}
	107	memcpy(s, p, (int)len);
	108	s[len] = '\0';
	109	p += len;
	110	} else
	111	s = NULL;
d02b48c6	112
0f113f3e MC	113	if (ret->data != NULL)
	114	OPENSSL_free(ret->data);
	115	ret->length = (int)len;
	116	ret->data = s;
	117	ret->type = tag;
	118	if (a != NULL)
	119	(*a) = ret;
	120	*pp = p;
	121	return (ret);
	122	err:
	123	ASN1err(ASN1_F_D2I_ASN1_TYPE_BYTES, i);
	124	if ((ret != NULL) && ((a == NULL) \|\| (*a != ret)))
	125	ASN1_STRING_free(ret);
	126	return (NULL);
	127	}
d02b48c6	128
6b691a5c	129	int i2d_ASN1_bytes(ASN1_STRING a, unsigned char *pp, int tag, int xclass)
0f113f3e MC	130	{
	131	int ret, r, constructed;
	132	unsigned char *p;
d02b48c6	133
0f113f3e MC	134	if (a == NULL)
0f113f3e MC	135	return (0);
58964a49	136
0f113f3e MC	137	if (tag == V_ASN1_BIT_STRING)
0f113f3e MC	138	return (i2d_ASN1_BIT_STRING(a, pp));
d02b48c6	139
0f113f3e MC	140	ret = a->length;
	141	r = ASN1_object_size(0, ret, tag);
	142	if (pp == NULL)
	143	return (r);
	144	p = *pp;
d02b48c6	145
0f113f3e MC	146	if ((tag == V_ASN1_SEQUENCE) \|\| (tag == V_ASN1_SET))
	147	constructed = 1;
	148	else
	149	constructed = 0;
	150	ASN1_put_object(&p, constructed, ret, tag, xclass);
	151	memcpy(p, a->data, a->length);
	152	p += a->length;
	153	*pp = p;
	154	return (r);
	155	}
d02b48c6	156
0f113f3e MC	157	ASN1_STRING d2i_ASN1_bytes(ASN1_STRING a, const unsigned char *pp,
	158	long length, int Ptag, int Pclass)
	159	{
	160	ASN1_STRING *ret = NULL;
	161	const unsigned char *p;
	162	unsigned char *s;
	163	long len;
	164	int inf, tag, xclass;
	165	int i = 0;
d02b48c6	166
0f113f3e MC	167	if ((a == NULL) \|\| ((*a) == NULL)) {
	168	if ((ret = ASN1_STRING_new()) == NULL)
	169	return (NULL);
	170	} else
	171	ret = (*a);
d02b48c6	172
0f113f3e MC	173	p = *pp;
	174	inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
	175	if (inf & 0x80) {
	176	i = ASN1_R_BAD_OBJECT_HEADER;
	177	goto err;
	178	}
d02b48c6	179
0f113f3e MC	180	if (tag != Ptag) {
	181	i = ASN1_R_WRONG_TAG;
	182	goto err;
	183	}
d02b48c6	184
0f113f3e MC	185	if (inf & V_ASN1_CONSTRUCTED) {
0f113f3e MC	186	ASN1_const_CTX c;
d02b48c6	187
0f113f3e MC	188	c.pp = pp;
	189	c.p = p;
	190	c.inf = inf;
	191	c.slen = len;
	192	c.tag = Ptag;
	193	c.xclass = Pclass;
	194	c.max = (length == 0) ? 0 : (p + length);
	195	if (!asn1_collate_primitive(ret, &c))
	196	goto err;
	197	else {
	198	p = c.p;
	199	}
	200	} else {
	201	if (len != 0) {
	202	if ((ret->length < len) \|\| (ret->data == NULL)) {
	203	if (ret->data != NULL)
	204	OPENSSL_free(ret->data);
	205	s = (unsigned char *)OPENSSL_malloc((int)len + 1);
	206	if (s == NULL) {
	207	i = ERR_R_MALLOC_FAILURE;
	208	goto err;
	209	}
	210	} else
	211	s = ret->data;
	212	memcpy(s, p, (int)len);
	213	s[len] = '\0';
	214	p += len;
	215	} else {
	216	s = NULL;
	217	if (ret->data != NULL)
	218	OPENSSL_free(ret->data);
	219	}
d02b48c6	220
0f113f3e MC	221	ret->length = (int)len;
	222	ret->data = s;
	223	ret->type = Ptag;
	224	}
d02b48c6	225
0f113f3e MC	226	if (a != NULL)
	227	(*a) = ret;
	228	*pp = p;
	229	return (ret);
	230	err:
	231	if ((ret != NULL) && ((a == NULL) \|\| (*a != ret)))
	232	ASN1_STRING_free(ret);
	233	ASN1err(ASN1_F_D2I_ASN1_BYTES, i);
	234	return (NULL);
	235	}
d02b48c6	236
0f113f3e MC	237	/*
	238	* We are about to parse 0..n d2i_ASN1_bytes objects, we are to collapse them
	239	* into the one structure that is then returned
	240	*/
	241	/*
	242	* There have been a few bug fixes for this function from Paul Keogh
	243	* <paul.keogh@sse.ie>, many thanks to him
	244	*/
875a644a	245	static int asn1_collate_primitive(ASN1_STRING a, ASN1_const_CTX c)
0f113f3e MC	246	{
	247	ASN1_STRING *os = NULL;
	248	BUF_MEM b;
	249	int num;
d02b48c6	250
0f113f3e MC	251	b.length = 0;
	252	b.max = 0;
	253	b.data = NULL;
d02b48c6	254
0f113f3e MC	255	if (a == NULL) {
	256	c->error = ERR_R_PASSED_NULL_PARAMETER;
	257	goto err;
	258	}
d02b48c6	259
0f113f3e MC	260	num = 0;
	261	for (;;) {
	262	if (c->inf & 1) {
	263	c->eos = ASN1_const_check_infinite_end(&c->p,
	264	(long)(c->max - c->p));
	265	if (c->eos)
	266	break;
	267	} else {
	268	if (c->slen <= 0)
	269	break;
	270	}
d02b48c6	271
0f113f3e MC	272	c->q = c->p;
	273	if (d2i_ASN1_bytes(&os, &c->p, c->max - c->p, c->tag, c->xclass)
	274	== NULL) {
	275	c->error = ERR_R_ASN1_LIB;
	276	goto err;
	277	}
d02b48c6	278
0f113f3e MC	279	if (!BUF_MEM_grow_clean(&b, num + os->length)) {
	280	c->error = ERR_R_BUF_LIB;
	281	goto err;
	282	}
	283	memcpy(&(b.data[num]), os->data, os->length);
	284	if (!(c->inf & 1))
	285	c->slen -= (c->p - c->q);
	286	num += os->length;
	287	}
d02b48c6	288
0f113f3e MC	289	if (!asn1_const_Finish(c))
0f113f3e MC	290	goto err;
d02b48c6	291
0f113f3e MC	292	a->length = num;
	293	if (a->data != NULL)
	294	OPENSSL_free(a->data);
	295	a->data = (unsigned char *)b.data;
	296	if (os != NULL)
	297	ASN1_STRING_free(os);
	298	return (1);
	299	err:
	300	ASN1err(ASN1_F_ASN1_COLLATE_PRIMITIVE, c->error);
	301	if (os != NULL)
	302	ASN1_STRING_free(os);
	303	if (b.data != NULL)
	304	OPENSSL_free(b.data);
	305	return (0);
	306	}