Don't free ret->data if malloc fails.
[openssl.git] / crypto / asn1 / a_bytes.c
1 /* crypto/asn1/a_bytes.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 "cryptlib.h"
61 #include <openssl/asn1.h>
62
63 static int asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c);
64 /*
65  * type is a 'bitmap' of acceptable string types.
66  */
67 ASN1_STRING *d2i_ASN1_type_bytes(ASN1_STRING **a, const unsigned char **pp,
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;
76
77     p = *pp;
78     inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
79     if (inf & 0x80)
80         goto err;
81
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     }
90
91     /* If a bit-string, exit early */
92     if (tag == V_ASN1_BIT_STRING)
93         return (d2i_ASN1_BIT_STRING(a, pp, length));
94
95     if ((a == NULL) || ((*a) == NULL)) {
96         if ((ret = ASN1_STRING_new()) == NULL)
97             return (NULL);
98     } else
99         ret = (*a);
100
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;
112
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 }
128
129 int i2d_ASN1_bytes(ASN1_STRING *a, unsigned char **pp, int tag, int xclass)
130 {
131     int ret, r, constructed;
132     unsigned char *p;
133
134     if (a == NULL)
135         return (0);
136
137     if (tag == V_ASN1_BIT_STRING)
138         return (i2d_ASN1_BIT_STRING(a, pp));
139
140     ret = a->length;
141     r = ASN1_object_size(0, ret, tag);
142     if (pp == NULL)
143         return (r);
144     p = *pp;
145
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 }
156
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;
166
167     if ((a == NULL) || ((*a) == NULL)) {
168         if ((ret = ASN1_STRING_new()) == NULL)
169             return (NULL);
170     } else
171         ret = (*a);
172
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     }
179
180     if (tag != Ptag) {
181         i = ASN1_R_WRONG_TAG;
182         goto err;
183     }
184
185     if (inf & V_ASN1_CONSTRUCTED) {
186         ASN1_const_CTX c;
187
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                 s = (unsigned char *)OPENSSL_malloc((int)len + 1);
204                 if (s == NULL) {
205                     i = ERR_R_MALLOC_FAILURE;
206                     goto err;
207                 }
208                 if (ret->data != NULL)
209                     OPENSSL_free(ret->data);
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         }
220
221         ret->length = (int)len;
222         ret->data = s;
223         ret->type = Ptag;
224     }
225
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 }
236
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  */
245 static int asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c)
246 {
247     ASN1_STRING *os = NULL;
248     BUF_MEM b;
249     int num;
250
251     b.length = 0;
252     b.max = 0;
253     b.data = NULL;
254
255     if (a == NULL) {
256         c->error = ERR_R_PASSED_NULL_PARAMETER;
257         goto err;
258     }
259
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         }
271
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         }
278
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     }
288
289     if (!asn1_const_Finish(c))
290         goto err;
291
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 }