Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libcrypto/crypto/../../libssl/src/crypto/asn1/tasn_utl.c	Lines:	75	91	82.4 %
Date:	2016-12-06	Branches:	36	50	72.0 %


/* $OpenBSD: tasn_utl.c,v 1.11 2015/07/25 17:07:17 jsing Exp $ */
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
 * project 2000.
 */
/* ====================================================================
 * Copyright (c) 2000-2004 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).
 *
 */

#include <stddef.h>
#include <string.h>
#include <openssl/asn1.h>
#include <openssl/asn1t.h>
#include <openssl/objects.h>
#include <openssl/err.h>

/* Utility functions for manipulating fields and offsets */

/* Add 'offset' to 'addr' */
#define offset2ptr(addr, offset) (void *)(((char *) addr) + offset)

/* Given an ASN1_ITEM CHOICE type return
 * the selector value
 */

int
asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
	int *sel = offset2ptr(*pval, it->utype);
	return *sel;
}

/* Given an ASN1_ITEM CHOICE type set
 * the selector value, return old value.
 */

int
asn1_set_choice_selector(ASN1_VALUE **pval, int value, const ASN1_ITEM *it)
{
	int *sel, ret;
	sel = offset2ptr(*pval, it->utype);
	ret = *sel;
	*sel = value;
	return ret;
}

/* Do reference counting. The value 'op' decides what to do.
 * if it is +1 then the count is incremented. If op is 0 count is
 * set to 1. If op is -1 count is decremented and the return value
 * is the current refrence count or 0 if no reference count exists.
 */

int
asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it)
{
	const ASN1_AUX *aux;
	int *lck, ret;

	if ((it->itype != ASN1_ITYPE_SEQUENCE) &&
	    (it->itype != ASN1_ITYPE_NDEF_SEQUENCE))
		return 0;
	aux = it->funcs;
	if (!aux || !(aux->flags & ASN1_AFLG_REFCOUNT))
		return 0;
	lck = offset2ptr(*pval, aux->ref_offset);
	if (op == 0) {
		*lck = 1;
		return 1;
	}
	ret = CRYPTO_add(lck, op, aux->ref_lock);
	return ret;
}

static ASN1_ENCODING *
asn1_get_enc_ptr(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
	const ASN1_AUX *aux;

	if (!pval || !*pval)
		return NULL;
	aux = it->funcs;
	if (!aux || !(aux->flags & ASN1_AFLG_ENCODING))
		return NULL;
	return offset2ptr(*pval, aux->enc_offset);
}

void
asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
	ASN1_ENCODING *enc;

	enc = asn1_get_enc_ptr(pval, it);
	if (enc) {
		enc->enc = NULL;
		enc->len = 0;
		enc->modified = 1;
	}
}

void
asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
	ASN1_ENCODING *enc;

	enc = asn1_get_enc_ptr(pval, it);
	if (enc) {
		free(enc->enc);
		enc->enc = NULL;
		enc->len = 0;
		enc->modified = 1;
	}
}

int
asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen,
    const ASN1_ITEM *it)
{
	ASN1_ENCODING *enc;

	enc = asn1_get_enc_ptr(pval, it);
	if (!enc)
		return 1;

	free(enc->enc);
	enc->enc = malloc(inlen);
	if (!enc->enc)
		return 0;
	memcpy(enc->enc, in, inlen);
	enc->len = inlen;
	enc->modified = 0;

	return 1;
}

int
asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval,
    const ASN1_ITEM *it)
{
	ASN1_ENCODING *enc;

	enc = asn1_get_enc_ptr(pval, it);
	if (!enc || enc->modified)
		return 0;
	if (out) {
		memcpy(*out, enc->enc, enc->len);
		*out += enc->len;
	}
	if (len)
		*len = enc->len;
	return 1;
}

/* Given an ASN1_TEMPLATE get a pointer to a field */
ASN1_VALUE **
asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
{
	ASN1_VALUE **pvaltmp;

	if (tt->flags & ASN1_TFLG_COMBINE)
		return pval;
	pvaltmp = offset2ptr(*pval, tt->offset);
	/* NOTE for BOOLEAN types the field is just a plain
 	 * int so we can't return int **, so settle for
	 * (int *).
	 */
	return pvaltmp;
}

/* Handle ANY DEFINED BY template, find the selector, look up
 * the relevant ASN1_TEMPLATE in the table and return it.
 */

const ASN1_TEMPLATE *
asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int nullerr)
{
	const ASN1_ADB *adb;
	const ASN1_ADB_TABLE *atbl;
	long selector;
	ASN1_VALUE **sfld;
	int i;

	if (!(tt->flags & ASN1_TFLG_ADB_MASK))
		return tt;

	/* Else ANY DEFINED BY ... get the table */
	adb = (const ASN1_ADB *)tt->item;

	/* Get the selector field */
	sfld = offset2ptr(*pval, adb->offset);

	/* Check if NULL */
	if (!sfld) {
		if (!adb->null_tt)
			goto err;
		return adb->null_tt;
	}

	/* Convert type to a long:
	 * NB: don't check for NID_undef here because it
	 * might be a legitimate value in the table
	 */
	if (tt->flags & ASN1_TFLG_ADB_OID)
		selector = OBJ_obj2nid((ASN1_OBJECT *)*sfld);
	else
		selector = ASN1_INTEGER_get((ASN1_INTEGER *)*sfld);

	/* Try to find matching entry in table
	 * Maybe should check application types first to
	 * allow application override? Might also be useful
	 * to have a flag which indicates table is sorted and
	 * we can do a binary search. For now stick to a
	 * linear search.
	 */

	for (atbl = adb->tbl, i = 0; i < adb->tblcount; i++, atbl++)
		if (atbl->value == selector)
			return &atbl->tt;

	/* FIXME: need to search application table too */

	/* No match, return default type */
	if (!adb->default_tt)
		goto err;
	return adb->default_tt;

err:
	/* FIXME: should log the value or OID of unsupported type */
	if (nullerr)
		ASN1err(ASN1_F_ASN1_DO_ADB,
		    ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE);
	return NULL;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: tasn_utl.c,v 1.11 2015/07/25 17:07:17 jsing Exp $ */
2			/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3			* project 2000.
4			*/
5			/* ====================================================================
6			* Copyright (c) 2000-2004 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
13			* notice, this list of conditions and the following disclaimer.
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
59			#include <stddef.h>
60			#include <string.h>
61			#include <openssl/asn1.h>
62			#include <openssl/asn1t.h>
63			#include <openssl/objects.h>
64			#include <openssl/err.h>
65
66			/* Utility functions for manipulating fields and offsets */
67
68			/* Add 'offset' to 'addr' */
69			#define offset2ptr(addr, offset) (void )(((char ) addr) + offset)
70
71			/* Given an ASN1_ITEM CHOICE type return
72			* the selector value
73			*/
74
75			int
76			asn1_get_choice_selector(ASN1_VALUE *pval, const ASN1_ITEM it)
77		172	{
78		172	int sel = offset2ptr(pval, it->utype);
79		172	return *sel;
80			}
81
82			/* Given an ASN1_ITEM CHOICE type set
83			* the selector value, return old value.
84			*/
85
86			int
87			asn1_set_choice_selector(ASN1_VALUE *pval, int value, const ASN1_ITEM it)
88		84	{
89			int *sel, ret;
90		84	sel = offset2ptr(*pval, it->utype);
91		84	ret = *sel;
92		84	*sel = value;
93		84	return ret;
94			}
95
96			/* Do reference counting. The value 'op' decides what to do.
97			* if it is +1 then the count is incremented. If op is 0 count is
98			* set to 1. If op is -1 count is decremented and the return value
99			* is the current refrence count or 0 if no reference count exists.
100			*/
101
102			int
103			asn1_do_lock(ASN1_VALUE *pval, int op, const ASN1_ITEM it)
104		7383	{
105			const ASN1_AUX *aux;
106			int *lck, ret;
107
108	✗✓	7383	if ((it->itype != ASN1_ITYPE_SEQUENCE) &&
109			(it->itype != ASN1_ITYPE_NDEF_SEQUENCE))
110			return 0;
111		7383	aux = it->funcs;
112	✓✓✓✓	7383	if (!aux \|\| !(aux->flags & ASN1_AFLG_REFCOUNT))
113		7048	return 0;
114		335	lck = offset2ptr(*pval, aux->ref_offset);
115	✓✓	335	if (op == 0) {
116		161	*lck = 1;
117		161	return 1;
118			}
119		174	ret = CRYPTO_add(lck, op, aux->ref_lock);
120		174	return ret;
121			}
122
123			static ASN1_ENCODING *
124			asn1_get_enc_ptr(ASN1_VALUE *pval, const ASN1_ITEM it)
125		16353	{
126			const ASN1_AUX *aux;
127
128	✓✗✗✓	16353	if (!pval \|\| !*pval)
129			return NULL;
130		16353	aux = it->funcs;
131	✓✓✓✓	16353	if (!aux \|\| !(aux->flags & ASN1_AFLG_ENCODING))
132		15976	return NULL;
133		377	return offset2ptr(*pval, aux->enc_offset);
134			}
135
136			void
137			asn1_enc_init(ASN1_VALUE *pval, const ASN1_ITEM it)
138		5153	{
139			ASN1_ENCODING *enc;
140
141		5153	enc = asn1_get_enc_ptr(pval, it);
142	✓✓	5153	if (enc) {
143		161	enc->enc = NULL;
144		161	enc->len = 0;
145		161	enc->modified = 1;
146			}
147		5153	}
148
149			void
150			asn1_enc_free(ASN1_VALUE *pval, const ASN1_ITEM it)
151		2056	{
152			ASN1_ENCODING *enc;
153
154		2056	enc = asn1_get_enc_ptr(pval, it);
155	✗✓	2056	if (enc) {
156			free(enc->enc);
157			enc->enc = NULL;
158			enc->len = 0;
159			enc->modified = 1;
160			}
161		2056	}
162
163			int
164			asn1_enc_save(ASN1_VALUE *pval, const unsigned char in, int inlen,
165			const ASN1_ITEM *it)
166		3601	{
167			ASN1_ENCODING *enc;
168
169		3601	enc = asn1_get_enc_ptr(pval, it);
170	✓✓	3601	if (!enc)
171		3440	return 1;
172
173		161	free(enc->enc);
174		161	enc->enc = malloc(inlen);
175	✗✓	161	if (!enc->enc)
176			return 0;
177		161	memcpy(enc->enc, in, inlen);
178		161	enc->len = inlen;
179		161	enc->modified = 0;
180
181		161	return 1;
182			}
183
184			int
185			asn1_enc_restore(int len, unsigned char out, ASN1_VALUE *pval,
186			const ASN1_ITEM *it)
187		5543	{
188			ASN1_ENCODING *enc;
189
190		5543	enc = asn1_get_enc_ptr(pval, it);
191	✓✓✗✓	5543	if (!enc \|\| enc->modified)
192		5488	return 0;
193	✓✓	55	if (out) {
194		16	memcpy(*out, enc->enc, enc->len);
195		16	*out += enc->len;
196			}
197	✓✗	55	if (len)
198		55	*len = enc->len;
199		55	return 1;
200			}
201
202			/* Given an ASN1_TEMPLATE get a pointer to a field */
203			ASN1_VALUE **
204			asn1_get_field_ptr(ASN1_VALUE *pval, const ASN1_TEMPLATE tt)
205		41532	{
206			ASN1_VALUE **pvaltmp;
207
208	✓✓	41532	if (tt->flags & ASN1_TFLG_COMBINE)
209		168	return pval;
210		41364	pvaltmp = offset2ptr(*pval, tt->offset);
211			/* NOTE for BOOLEAN types the field is just a plain
212			* int so we can't return int **, so settle for
213			* (int *).
214			*/
215		41364	return pvaltmp;
216			}
217
218			/* Handle ANY DEFINED BY template, find the selector, look up
219			* the relevant ASN1_TEMPLATE in the table and return it.
220			*/
221
222			const ASN1_TEMPLATE *
223			asn1_do_adb(ASN1_VALUE *pval, const ASN1_TEMPLATE tt, int nullerr)
224		28864	{
225			const ASN1_ADB *adb;
226			const ASN1_ADB_TABLE *atbl;
227			long selector;
228			ASN1_VALUE **sfld;
229			int i;
230
231	✓✓	28864	if (!(tt->flags & ASN1_TFLG_ADB_MASK))
232		28825	return tt;
233
234			/* Else ANY DEFINED BY ... get the table */
235		39	adb = (const ASN1_ADB *)tt->item;
236
237			/* Get the selector field */
238		39	sfld = offset2ptr(*pval, adb->offset);
239
240			/* Check if NULL */
241	✗✓	39	if (!sfld) {
242			if (!adb->null_tt)
243			goto err;
244			return adb->null_tt;
245			}
246
247			/* Convert type to a long:
248			* NB: don't check for NID_undef here because it
249			* might be a legitimate value in the table
250			*/
251	✓✗	39	if (tt->flags & ASN1_TFLG_ADB_OID)
252		39	selector = OBJ_obj2nid((ASN1_OBJECT )sfld);
253			else
254			selector = ASN1_INTEGER_get((ASN1_INTEGER )sfld);
255
256			/* Try to find matching entry in table
257			* Maybe should check application types first to
258			* allow application override? Might also be useful
259			* to have a flag which indicates table is sorted and
260			* we can do a binary search. For now stick to a
261			* linear search.
262			*/
263
264	✓✓	101	for (atbl = adb->tbl, i = 0; i < adb->tblcount; i++, atbl++)
265	✓✓	94	if (atbl->value == selector)
266		32	return &atbl->tt;
267
268			/* FIXME: need to search application table too */
269
270			/* No match, return default type */
271	✗✓	7	if (!adb->default_tt)
272			goto err;
273		7	return adb->default_tt;
274
275			err:
276			/* FIXME: should log the value or OID of unsupported type */
277			if (nullerr)
278			ASN1err(ASN1_F_ASN1_DO_ADB,
279			ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE);
280			return NULL;
281			}