1 files changed, 26 insertions, 139 deletions
diff --git a/src/lib/libcrypto/asn1/a_enum.c b/src/lib/libcrypto/asn1/a_enum.c
index ccf62e5a04..1428d1df7a 100644
--- a/src/lib/libcrypto/asn1/a_enum.c
+++ b/src/lib/libcrypto/asn1/a_enum.c
@@ -71,88 +71,28 @@ ASN1_ENUMERATED *ASN1_ENUMERATED_new(void)
 void ASN1_ENUMERATED_free(ASN1_ENUMERATED *x)
 { M_ASN1_ENUMERATED_free(x); }
-int i2d_ASN1_ENUMERATED(ASN1_ENUMERATED *a, unsigned char **pp)
-        {
-        int pad=0,ret,r,i,t;
-        unsigned char *p,*n,pb=0;
-        if ((a == NULL) || (a->data == NULL)) return(0);
-        t=a->type;
-        if (a->length == 0)
-                ret=1;
-        else
-                {
-                ret=a->length;
-                i=a->data[0];
-                if ((t == V_ASN1_ENUMERATED) && (i > 127)) {
-                        pad=1;
-                        pb=0;
-                } else if(t == V_ASN1_NEG_ENUMERATED) {
-                        if(i>128) {
-                                pad=1;
-                                pb=0xFF;
-                        } else if(i == 128) {
-                                for(i = 1; i < a->length; i++) if(a->data[i]) {
-                                                pad=1;
-                                                pb=0xFF;
-                                                break;
-                                }
-                        }
-                }
-                ret+=pad;
-                }
-        r=ASN1_object_size(0,ret,V_ASN1_ENUMERATED);
-        if (pp == NULL) return(r);
-        p= *pp;
-        ASN1_put_object(&p,0,ret,V_ASN1_ENUMERATED,V_ASN1_UNIVERSAL);
-        if (pad) *(p++)=pb;
-        if (a->length == 0)
-                *(p++)=0;
-        else if (t == V_ASN1_ENUMERATED)
-                {
-                memcpy(p,a->data,(unsigned int)a->length);
-                p+=a->length;
-                }
-        else {
-                /* Begin at the end of the encoding */
-                n=a->data + a->length - 1;
-                p += a->length - 1;
-                i = a->length;
-                /* Copy zeros to destination as long as source is zero */
-                while(!*n) {
-                        *(p--) = 0;
-                        n--;
-                        i--;
-                }
-                /* Complement and increment next octet */
-                *(p--) = ((*(n--)) ^ 0xff) + 1;
-                i--;
-                /* Complement any octets left */
-                for(;i > 0; i--) *(p--) = *(n--) ^ 0xff;
-                p += a->length;
-        }
-        *pp=p;
+int i2d_ASN1_ENUMERATED(ASN1_ENUMERATED *a, unsigned char **pp)
-        return(r);
+{
+        int len, ret;
+        if(!a) return 0;
+        len = i2c_ASN1_INTEGER(a, NULL);        
+        ret=ASN1_object_size(0,len,V_ASN1_ENUMERATED);
+        if(pp) {
+                ASN1_put_object(pp,0,len,V_ASN1_ENUMERATED,V_ASN1_UNIVERSAL);
+                i2c_ASN1_INTEGER(a, pp);        
        }
+        return ret;
+}
 ASN1_ENUMERATED *d2i_ASN1_ENUMERATED(ASN1_ENUMERATED **a, unsigned char **pp,
             long length)
-        {
+{
-        ASN1_ENUMERATED *ret=NULL;
+        unsigned char *p;
-        unsigned char *p,*to,*s;
        long len;
-        int inf,tag,xclass;
        int i;
+        int inf,tag,xclass;
-        if ((a == NULL) || ((*a) == NULL))
+        ASN1_ENUMERATED *ret;
-                {
-                if ((ret=M_ASN1_ENUMERATED_new()) == NULL) return(NULL);
-                ret->type=V_ASN1_ENUMERATED;
-                }
-        else
-                ret=(*a);
        p= *pp;
        inf=ASN1_get_object(&p,&len,&tag,&xclass,length);
@@ -167,70 +107,17 @@ ASN1_ENUMERATED *d2i_ASN1_ENUMERATED(ASN1_ENUMERATED **a, unsigned char **pp,
                i=ASN1_R_EXPECTING_AN_ENUMERATED;
                goto err;
                }
+        ret = c2i_ASN1_INTEGER(a, &p, len);
-        /* We must Malloc stuff, even for 0 bytes otherwise it
+        if(ret) {
-         * signifies a missing NULL parameter. */
+                ret->type = (V_ASN1_NEG & ret->type) | V_ASN1_ENUMERATED;
-        s=(unsigned char *)Malloc((int)len+1);
+                *pp = p;
-        if (s == NULL)
-                {
-                i=ERR_R_MALLOC_FAILURE;
-                goto err;
-                }
-        to=s;
-        if(!len) {
-                /* Strictly speaking this is an illegal ENUMERATED but we
-                 * tolerate it.
-                 */
-                ret->type=V_ASN1_ENUMERATED;
-        } else if (*p & 0x80) /* a negative number */
-                {
-                ret->type=V_ASN1_NEG_ENUMERATED;
-                if ((*p == 0xff) && (len != 1)) {
-                        p++;
-                        len--;
-                }
-                i = len;
-                p += i - 1;
-                to += i - 1;
-                while((!*p) && i) {
-                        *(to--) = 0;
-                        i--;
-                        p--;
-                }
-                if(!i) {
-                        *s = 1;
-                        s[len] = 0;
-                        p += len;
-                        len++;
-                } else {
-                        *(to--) = (*(p--) ^ 0xff) + 1;
-                        i--;
-                        for(;i > 0; i--) *(to--) = *(p--) ^ 0xff;
-                        p += len;
-                }
-        } else {
-                ret->type=V_ASN1_ENUMERATED;
-                if ((*p == 0) && (len != 1))
-                        {
-                        p++;
-                        len--;
-                        }
-                memcpy(s,p,(int)len);
-                p+=len;
        }
+        return ret;
-        if (ret->data != NULL) Free(ret->data);
-        ret->data=s;
-        ret->length=(int)len;
-        if (a != NULL) (*a)=ret;
-        *pp=p;
-        return(ret);
 err:
        ASN1err(ASN1_F_D2I_ASN1_ENUMERATED,i);
-        if ((ret != NULL) && ((a == NULL) || (*a != ret)))
-                M_ASN1_ENUMERATED_free(ret);
        return(NULL);
-        }
+}
 int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
        {
@@ -242,8 +129,8 @@ int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
        if (a->length < (sizeof(long)+1))
                {
                if (a->data != NULL)
-                        Free(a->data);
+                        OPENSSL_free(a->data);
-                if ((a->data=(unsigned char *)Malloc(sizeof(long)+1)) != NULL)
+                if ((a->data=(unsigned char *)OPENSSL_malloc(sizeof(long)+1)) != NULL)
                        memset((char *)a->data,0,sizeof(long)+1);
                }
        if (a->data == NULL)
@@ -318,7 +205,7 @@ ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(BIGNUM *bn, ASN1_ENUMERATED *ai)
        else ret->type=V_ASN1_ENUMERATED;
        j=BN_num_bits(bn);
        len=((j == 0)?0:((j/8)+1));
-        ret->data=(unsigned char *)Malloc(len+4);
+        ret->data=(unsigned char *)OPENSSL_malloc(len+4);
        ret->length=BN_bn2bin(bn,ret->data);
        return(ret);
 err:
@@ -332,6 +219,6 @@ BIGNUM *ASN1_ENUMERATED_to_BN(ASN1_ENUMERATED *ai, BIGNUM *bn)
        if ((ret=BN_bin2bn(ai->data,ai->length,bn)) == NULL)
                ASN1err(ASN1_F_ASN1_ENUMERATED_TO_BN,ASN1_R_BN_LIB);
-        if(ai->type == V_ASN1_NEG_ENUMERATED) bn->neg = 1;
+        else if(ai->type == V_ASN1_NEG_ENUMERATED) ret->neg = 1;
        return(ret);
        }

diff --git a/src/lib/libcrypto/asn1/a_enum.c b/src/lib/libcrypto/asn1/a_enum.c index ccf62e5a04..1428d1df7a 100644 --- a/src/lib/libcrypto/asn1/a_enum.c +++ b/src/lib/libcrypto/asn1/a_enum.c
@@ -71,88 +71,28 @@ ASN1_ENUMERATED *ASN1_ENUMERATED_new(void)
71	void ASN1_ENUMERATED_free(ASN1_ENUMERATED *x)	71	void ASN1_ENUMERATED_free(ASN1_ENUMERATED *x)
72	{ M_ASN1_ENUMERATED_free(x); }	72	{ M_ASN1_ENUMERATED_free(x); }
73		73
74	int i2d_ASN1_ENUMERATED(ASN1_ENUMERATED a, unsigned char *pp)
75	{
76	int pad=0,ret,r,i,t;
77	unsigned char p,n,pb=0;
78
79	if ((a == NULL) \|\| (a->data == NULL)) return(0);
80	t=a->type;
81	if (a->length == 0)
82	ret=1;
83	else
84	{
85	ret=a->length;
86	i=a->data[0];
87	if ((t == V_ASN1_ENUMERATED) && (i > 127)) {
88	pad=1;
89	pb=0;
90	} else if(t == V_ASN1_NEG_ENUMERATED) {
91	if(i>128) {
92	pad=1;
93	pb=0xFF;
94	} else if(i == 128) {
95	for(i = 1; i < a->length; i++) if(a->data[i]) {
96	pad=1;
97	pb=0xFF;
98	break;
99	}
100	}
101	}
102	ret+=pad;
103	}
104	r=ASN1_object_size(0,ret,V_ASN1_ENUMERATED);
105	if (pp == NULL) return(r);
106	p= *pp;
107
108	ASN1_put_object(&p,0,ret,V_ASN1_ENUMERATED,V_ASN1_UNIVERSAL);
109	if (pad) *(p++)=pb;
110	if (a->length == 0)
111	*(p++)=0;
112	else if (t == V_ASN1_ENUMERATED)
113	{
114	memcpy(p,a->data,(unsigned int)a->length);
115	p+=a->length;
116	}
117	else {
118	/* Begin at the end of the encoding */
119	n=a->data + a->length - 1;
120	p += a->length - 1;
121	i = a->length;
122	/* Copy zeros to destination as long as source is zero */
123	while(!*n) {
124	*(p--) = 0;
125	n--;
126	i--;
127	}
128	/* Complement and increment next octet */
129	(p--) = (((n--)) ^ 0xff) + 1;
130	i--;
131	/* Complement any octets left */
132	for(;i > 0; i--) (p--) = (n--) ^ 0xff;
133	p += a->length;
134	}
135		74
136	*pp=p;	75	int i2d_ASN1_ENUMERATED(ASN1_ENUMERATED a, unsigned char *pp)
137	return(r);	76	{
		77	int len, ret;
		78	if(!a) return 0;
		79	len = i2c_ASN1_INTEGER(a, NULL);
		80	ret=ASN1_object_size(0,len,V_ASN1_ENUMERATED);
		81	if(pp) {
		82	ASN1_put_object(pp,0,len,V_ASN1_ENUMERATED,V_ASN1_UNIVERSAL);
		83	i2c_ASN1_INTEGER(a, pp);
138	}	84	}
		85	return ret;
		86	}
139		87
140	ASN1_ENUMERATED d2i_ASN1_ENUMERATED(ASN1_ENUMERATED a, unsigned char *pp,	88	ASN1_ENUMERATED d2i_ASN1_ENUMERATED(ASN1_ENUMERATED a, unsigned char *pp,
141	long length)	89	long length)
142	{	90	{
143	ASN1_ENUMERATED *ret=NULL;	91	unsigned char *p;
144	unsigned char p,to,*s;
145	long len;	92	long len;
146	int inf,tag,xclass;
147	int i;	93	int i;
148		94	int inf,tag,xclass;
149	if ((a == NULL) \|\| ((*a) == NULL))	95	ASN1_ENUMERATED *ret;
150	{
151	if ((ret=M_ASN1_ENUMERATED_new()) == NULL) return(NULL);
152	ret->type=V_ASN1_ENUMERATED;
153	}
154	else
155	ret=(*a);
156		96
157	p= *pp;	97	p= *pp;
158	inf=ASN1_get_object(&p,&len,&tag,&xclass,length);	98	inf=ASN1_get_object(&p,&len,&tag,&xclass,length);
@@ -167,70 +107,17 @@ ASN1_ENUMERATED d2i_ASN1_ENUMERATED(ASN1_ENUMERATED a, unsigned char *pp,
167	i=ASN1_R_EXPECTING_AN_ENUMERATED;	107	i=ASN1_R_EXPECTING_AN_ENUMERATED;
168	goto err;	108	goto err;
169	}	109	}
170		110	ret = c2i_ASN1_INTEGER(a, &p, len);
171	/* We must Malloc stuff, even for 0 bytes otherwise it	111	if(ret) {
172	* signifies a missing NULL parameter. */	112	ret->type = (V_ASN1_NEG & ret->type) \| V_ASN1_ENUMERATED;
173	s=(unsigned char *)Malloc((int)len+1);	113	*pp = p;
174	if (s == NULL)
175	{
176	i=ERR_R_MALLOC_FAILURE;
177	goto err;
178	}
179	to=s;
180	if(!len) {
181	/* Strictly speaking this is an illegal ENUMERATED but we
182	* tolerate it.
183	*/
184	ret->type=V_ASN1_ENUMERATED;
185	} else if (p & 0x80) / a negative number */
186	{
187	ret->type=V_ASN1_NEG_ENUMERATED;
188	if ((*p == 0xff) && (len != 1)) {
189	p++;
190	len--;
191	}
192	i = len;
193	p += i - 1;
194	to += i - 1;
195	while((!*p) && i) {
196	*(to--) = 0;
197	i--;
198	p--;
199	}
200	if(!i) {
201	*s = 1;
202	s[len] = 0;
203	p += len;
204	len++;
205	} else {
206	(to--) = ((p--) ^ 0xff) + 1;
207	i--;
208	for(;i > 0; i--) (to--) = (p--) ^ 0xff;
209	p += len;
210	}
211	} else {
212	ret->type=V_ASN1_ENUMERATED;
213	if ((*p == 0) && (len != 1))
214	{
215	p++;
216	len--;
217	}
218	memcpy(s,p,(int)len);
219	p+=len;
220	}	114	}
221		115	return ret;
222	if (ret->data != NULL) Free(ret->data);
223	ret->data=s;
224	ret->length=(int)len;
225	if (a != NULL) (*a)=ret;
226	*pp=p;
227	return(ret);
228	err:	116	err:
229	ASN1err(ASN1_F_D2I_ASN1_ENUMERATED,i);	117	ASN1err(ASN1_F_D2I_ASN1_ENUMERATED,i);
230	if ((ret != NULL) && ((a == NULL) \|\| (*a != ret)))
231	M_ASN1_ENUMERATED_free(ret);
232	return(NULL);	118	return(NULL);
233	}	119
		120	}
234		121
235	int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)	122	int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
236	{	123	{
@@ -242,8 +129,8 @@ int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
242	if (a->length < (sizeof(long)+1))	129	if (a->length < (sizeof(long)+1))
243	{	130	{
244	if (a->data != NULL)	131	if (a->data != NULL)
245	Free(a->data);	132	OPENSSL_free(a->data);
246	if ((a->data=(unsigned char *)Malloc(sizeof(long)+1)) != NULL)	133	if ((a->data=(unsigned char *)OPENSSL_malloc(sizeof(long)+1)) != NULL)
247	memset((char *)a->data,0,sizeof(long)+1);	134	memset((char *)a->data,0,sizeof(long)+1);
248	}	135	}
249	if (a->data == NULL)	136	if (a->data == NULL)
@@ -318,7 +205,7 @@ ASN1_ENUMERATED BN_to_ASN1_ENUMERATED(BIGNUM bn, ASN1_ENUMERATED *ai)
318	else ret->type=V_ASN1_ENUMERATED;	205	else ret->type=V_ASN1_ENUMERATED;
319	j=BN_num_bits(bn);	206	j=BN_num_bits(bn);
320	len=((j == 0)?0:((j/8)+1));	207	len=((j == 0)?0:((j/8)+1));
321	ret->data=(unsigned char *)Malloc(len+4);	208	ret->data=(unsigned char *)OPENSSL_malloc(len+4);
322	ret->length=BN_bn2bin(bn,ret->data);	209	ret->length=BN_bn2bin(bn,ret->data);
323	return(ret);	210	return(ret);
324	err:	211	err:
@@ -332,6 +219,6 @@ BIGNUM ASN1_ENUMERATED_to_BN(ASN1_ENUMERATED ai, BIGNUM *bn)
332		219
333	if ((ret=BN_bin2bn(ai->data,ai->length,bn)) == NULL)	220	if ((ret=BN_bin2bn(ai->data,ai->length,bn)) == NULL)
334	ASN1err(ASN1_F_ASN1_ENUMERATED_TO_BN,ASN1_R_BN_LIB);	221	ASN1err(ASN1_F_ASN1_ENUMERATED_TO_BN,ASN1_R_BN_LIB);
335	if(ai->type == V_ASN1_NEG_ENUMERATED) bn->neg = 1;	222	else if(ai->type == V_ASN1_NEG_ENUMERATED) ret->neg = 1;
336	return(ret);	223	return(ret);
337	}	224	}