1 /* crypto/asn1/asn1_lib.c */

     2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

     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.

     8  * 

     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).

    15  * 

    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.

    22  * 

    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 :-).

    37  * 4. If you include any Windows specific code (or a derivative thereof) from 

    38  *    the apps directory (application code) you must include an acknowledgement:

    39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

    40  * 

    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.

    52  * 

    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 <limits.h>

    61 #include "cryptlib.h"

    62 #include <openssl/asn1.h>

    63 #include <openssl/asn1_mac.h>

    64 

    65 static int asn1_get_length(const unsigned char **pp,int *inf,long *rl,int max);

    66 static void asn1_put_length(unsigned char **pp, int length);

    67 const char ASN1_version[]="ASN.1" OPENSSL_VERSION_PTEXT;

    68 

    69 static int _asn1_check_infinite_end(const unsigned char **p, long len)

    70 	{

    71 	/* If there is 0 or 1 byte left, the length check should pick

    72 	 * things up */

    73 	if (len <= 0)

    74 		return(1);

    75 	else if ((len >= 2) && ((*p)[0] == 0) && ((*p)[1] == 0))

    76 		{

    77 		(*p)+=2;

    78 		return(1);

    79 		}

    80 	return(0);

    81 	}

    82 

    83 EXPORT_C int ASN1_check_infinite_end(unsigned char **p, long len)

    84 	{

    85 	return _asn1_check_infinite_end((const unsigned char **)p, len);

    86 	}

    87 

    88 EXPORT_C int ASN1_const_check_infinite_end(const unsigned char **p, long len)

    89 	{

    90 	return _asn1_check_infinite_end(p, len);

    91 	}

    92 

    93 

    94 EXPORT_C int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,

    95 	int *pclass, long omax)

    96 	{

    97 	int i,ret;

    98 	long l;

    99 	const unsigned char *p= *pp;

   100 	int tag,xclass,inf;

   101 	long max=omax;

   102 

   103 	if (!max) goto err;

   104 	ret=(*p&V_ASN1_CONSTRUCTED);

   105 	xclass=(*p&V_ASN1_PRIVATE);

   106 	i= *p&V_ASN1_PRIMITIVE_TAG;

   107 	if (i == V_ASN1_PRIMITIVE_TAG)

   108 		{		/* high-tag */

   109 		p++;

   110 		if (--max == 0) goto err;

   111 		l=0;

   112 		while (*p&0x80)

   113 			{

   114 			l<<=7L;

   115 			l|= *(p++)&0x7f;

   116 			if (--max == 0) goto err;

   117 			if (l > (INT_MAX >> 7L)) goto err;

   118 			}

   119 		l<<=7L;

   120 		l|= *(p++)&0x7f;

   121 		tag=(int)l;

   122 		if (--max == 0) goto err;

   123 		}

   124 	else

   125 		{ 

   126 		tag=i;

   127 		p++;

   128 		if (--max == 0) goto err;

   129 		}

   130 	*ptag=tag;

   131 	*pclass=xclass;

   132 	if (!asn1_get_length(&p,&inf,plength,(int)max)) goto err;

   133 

   134 #if 0

   135 	fprintf(stderr,"p=%d + *plength=%ld > omax=%ld + *pp=%d  (%d > %d)\n", 

   136 		(int)p,*plength,omax,(int)*pp,(int)(p+ *plength),

   137 		(int)(omax+ *pp));

   138 

   139 #endif

   140 	if (*plength > (omax - (p - *pp)))

   141 		{

   142 		ASN1err(ASN1_F_ASN1_GET_OBJECT,ASN1_R_TOO_LONG);

   143 		/* Set this so that even if things are not long enough

   144 		 * the values are set correctly */

   145 		ret|=0x80;

   146 		}

   147 	*pp=p;

   148 	return(ret|inf);

   149 err:

   150 	ASN1err(ASN1_F_ASN1_GET_OBJECT,ASN1_R_HEADER_TOO_LONG);

   151 	return(0x80);

   152 	}

   153 

   154 static int asn1_get_length(const unsigned char **pp, int *inf, long *rl, int max)

   155 	{

   156 	const unsigned char *p= *pp;

   157 	unsigned long ret=0;

   158 	unsigned int i;

   159 

   160 	if (max-- < 1) return(0);

   161 	if (*p == 0x80)

   162 		{

   163 		*inf=1;

   164 		ret=0;

   165 		p++;

   166 		}

   167 	else

   168 		{

   169 		*inf=0;

   170 		i= *p&0x7f;

   171 		if (*(p++) & 0x80)

   172 			{

   173 			if (i > sizeof(long))

   174 				return 0;

   175 			if (max-- == 0) return(0);

   176 			while (i-- > 0)

   177 				{

   178 				ret<<=8L;

   179 				ret|= *(p++);

   180 				if (max-- == 0) return(0);

   181 				}

   182 			}

   183 		else

   184 			ret=i;

   185 		}

   186 	if (ret > LONG_MAX)

   187 		return 0;

   188 	*pp=p;

   189 	*rl=(long)ret;

   190 	return(1);

   191 	}

   192 

   193 /* class 0 is constructed

   194  * constructed == 2 for indefinite length constructed */

   195 EXPORT_C void ASN1_put_object(unsigned char **pp, int constructed, int length, int tag,

   196 	     int xclass)

   197 	{

   198 	unsigned char *p= *pp;

   199 	int i, ttag;

   200 

   201 	i=(constructed)?V_ASN1_CONSTRUCTED:0;

   202 	i|=(xclass&V_ASN1_PRIVATE);

   203 	if (tag < 31)

   204 		*(p++)=i|(tag&V_ASN1_PRIMITIVE_TAG);

   205 	else

   206 		{

   207 		*(p++)=i|V_ASN1_PRIMITIVE_TAG;

   208 		for(i = 0, ttag = tag; ttag > 0; i++) ttag >>=7;

   209 		ttag = i;

   210 		while(i-- > 0)

   211 			{

   212 			p[i] = tag & 0x7f;

   213 			if(i != (ttag - 1)) p[i] |= 0x80;

   214 			tag >>= 7;

   215 			}

   216 		p += ttag;

   217 		}

   218 	if (constructed == 2)

   219 		*(p++)=0x80;

   220 	else

   221 		asn1_put_length(&p,length);

   222 	*pp=p;

   223 	}

   224 

   225 EXPORT_C int ASN1_put_eoc(unsigned char **pp)

   226 	{

   227 	unsigned char *p = *pp;

   228 	*p++ = 0;

   229 	*p++ = 0;

   230 	*pp = p;

   231 	return 2;

   232 	}

   233 

   234 static void asn1_put_length(unsigned char **pp, int length)

   235 	{

   236 	unsigned char *p= *pp;

   237 	int i,l;

   238 	if (length <= 127)

   239 		*(p++)=(unsigned char)length;

   240 	else

   241 		{

   242 		l=length;

   243 		for (i=0; l > 0; i++)

   244 			l>>=8;

   245 		*(p++)=i|0x80;

   246 		l=i;

   247 		while (i-- > 0)

   248 			{

   249 			p[i]=length&0xff;

   250 			length>>=8;

   251 			}

   252 		p+=l;

   253 		}

   254 	*pp=p;

   255 	}

   256 

   257 EXPORT_C int ASN1_object_size(int constructed, int length, int tag)

   258 	{

   259 	int ret;

   260 

   261 	ret=length;

   262 	ret++;

   263 	if (tag >= 31)

   264 		{

   265 		while (tag > 0)

   266 			{

   267 			tag>>=7;

   268 			ret++;

   269 			}

   270 		}

   271 	if (constructed == 2)

   272 		return ret + 3;

   273 	ret++;

   274 	if (length > 127)

   275 		{

   276 		while (length > 0)

   277 			{

   278 			length>>=8;

   279 			ret++;

   280 			}

   281 		}

   282 	return(ret);

   283 	}

   284 

   285 static int _asn1_Finish(ASN1_const_CTX *c)

   286 	{

   287 	if ((c->inf == (1|V_ASN1_CONSTRUCTED)) && (!c->eos))

   288 		{

   289 		if (!ASN1_const_check_infinite_end(&c->p,c->slen))

   290 			{

   291 			c->error=ERR_R_MISSING_ASN1_EOS;

   292 			return(0);

   293 			}

   294 		}

   295 	if (	((c->slen != 0) && !(c->inf & 1)) ||

   296 		((c->slen < 0) && (c->inf & 1)))

   297 		{

   298 		c->error=ERR_R_ASN1_LENGTH_MISMATCH;

   299 		return(0);

   300 		}

   301 	return(1);

   302 	}

   303 

   304 EXPORT_C int asn1_Finish(ASN1_CTX *c)

   305 	{

   306 	return _asn1_Finish((ASN1_const_CTX *)c);

   307 	}

   308 

   309 EXPORT_C int asn1_const_Finish(ASN1_const_CTX *c)

   310 	{

   311 	return _asn1_Finish(c);

   312 	}

   313 

   314 EXPORT_C int asn1_GetSequence(ASN1_const_CTX *c, long *length)

   315 	{

   316 	const unsigned char *q;

   317 

   318 	q=c->p;

   319 	c->inf=ASN1_get_object(&(c->p),&(c->slen),&(c->tag),&(c->xclass),

   320 		*length);

   321 	if (c->inf & 0x80)

   322 		{

   323 		c->error=ERR_R_BAD_GET_ASN1_OBJECT_CALL;

   324 		return(0);

   325 		}

   326 	if (c->tag != V_ASN1_SEQUENCE)

   327 		{

   328 		c->error=ERR_R_EXPECTING_AN_ASN1_SEQUENCE;

   329 		return(0);

   330 		}

   331 	(*length)-=(c->p-q);

   332 	if (c->max && (*length < 0))

   333 		{

   334 		c->error=ERR_R_ASN1_LENGTH_MISMATCH;

   335 		return(0);

   336 		}

   337 	if (c->inf == (1|V_ASN1_CONSTRUCTED))

   338 		c->slen= *length+ *(c->pp)-c->p;

   339 	c->eos=0;

   340 	return(1);

   341 	}

   342 

   343 EXPORT_C ASN1_STRING *ASN1_STRING_dup(ASN1_STRING *str)

   344 	{

   345 	ASN1_STRING *ret;

   346 

   347 	if (str == NULL) return(NULL);

   348 	if ((ret=ASN1_STRING_type_new(str->type)) == NULL)

   349 		return(NULL);

   350 	if (!ASN1_STRING_set(ret,str->data,str->length))

   351 		{

   352 		ASN1_STRING_free(ret);

   353 		return(NULL);

   354 		}

   355 	ret->flags = str->flags;

   356 	return(ret);

   357 	}

   358 

   359 EXPORT_C int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)

   360 	{

   361 	unsigned char *c;

   362 	const char *data=_data;

   363 

   364 	if (len < 0)

   365 		{

   366 		if (data == NULL)

   367 			return(0);

   368 		else

   369 			len=strlen(data);

   370 		}

   371 	if ((str->length < len) || (str->data == NULL))

   372 		{

   373 		c=str->data;

   374 		if (c == NULL)

   375 			str->data=OPENSSL_malloc(len+1);

   376 		else

   377 			str->data=OPENSSL_realloc(c,len+1);

   378 

   379 		if (str->data == NULL)

   380 			{

   381 			ASN1err(ASN1_F_ASN1_STRING_SET,ERR_R_MALLOC_FAILURE);

   382 			str->data=c;

   383 			return(0);

   384 			}

   385 		}

   386 	str->length=len;

   387 	if (data != NULL)

   388 		{

   389 		memcpy(str->data,data,len);

   390 		/* an allowance for strings :-) */

   391 		str->data[len]='\0';

   392 		}

   393 	return(1);

   394 	}

   395 

   396 EXPORT_C ASN1_STRING *ASN1_STRING_new(void)

   397 	{

   398 	return(ASN1_STRING_type_new(V_ASN1_OCTET_STRING));

   399 	}

   400 

   401 

   402 EXPORT_C ASN1_STRING *ASN1_STRING_type_new(int type)

   403 	{

   404 	ASN1_STRING *ret;

   405 

   406 	ret=(ASN1_STRING *)OPENSSL_malloc(sizeof(ASN1_STRING));

   407 	if (ret == NULL)

   408 		{

   409 		ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW,ERR_R_MALLOC_FAILURE);

   410 		return(NULL);

   411 		}

   412 	ret->length=0;

   413 	ret->type=type;

   414 	ret->data=NULL;

   415 	ret->flags=0;

   416 	return(ret);

   417 	}

   418 

   419 EXPORT_C void ASN1_STRING_free(ASN1_STRING *a)

   420 	{

   421 	if (a == NULL) return;

   422 	if (a->data != NULL) OPENSSL_free(a->data);

   423 	OPENSSL_free(a);

   424 	}

   425 

   426 EXPORT_C int ASN1_STRING_cmp(ASN1_STRING *a, ASN1_STRING *b)

   427 	{

   428 	int i;

   429 

   430 	i=(a->length-b->length);

   431 	if (i == 0)

   432 		{

   433 		i=memcmp(a->data,b->data,a->length);

   434 		if (i == 0)

   435 			return(a->type-b->type);

   436 		else

   437 			return(i);

   438 		}

   439 	else

   440 		return(i);

   441 	}

   442 

   443 EXPORT_C void asn1_add_error(const unsigned char *address, int offset)

   444 	{

   445 	char buf1[DECIMAL_SIZE(address)+1],buf2[DECIMAL_SIZE(offset)+1];

   446 

   447 	BIO_snprintf(buf1,sizeof buf1,"%lu",(unsigned long)address);

   448 	BIO_snprintf(buf2,sizeof buf2,"%d",offset);

   449 	ERR_add_error_data(4,"address=",buf1," offset=",buf2);

   450 	}

   451 

   452 EXPORT_C int ASN1_STRING_length(ASN1_STRING *x)

   453 { return M_ASN1_STRING_length(x); }

   454 

   455 EXPORT_C void ASN1_STRING_length_set(ASN1_STRING *x, int len)

   456 { M_ASN1_STRING_length_set(x, len); return; }

   457 

   458 EXPORT_C int ASN1_STRING_type(ASN1_STRING *x)

   459 { return M_ASN1_STRING_type(x); }

   460 

   461 EXPORT_C unsigned char * ASN1_STRING_data(ASN1_STRING *x)

   462 { return M_ASN1_STRING_data(x); }