Continue standardising malloc style for libcrypto
[openssl.git] / crypto / asn1 / a_object.c
1 /* crypto/asn1/a_object.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 "internal/cryptlib.h"
62 #include <openssl/buffer.h>
63 #include <openssl/asn1.h>
64 #include <openssl/objects.h>
65 #include <openssl/bn.h>
66 #include "internal/asn1_int.h"
67 #include "asn1_locl.h"
68
69 int i2d_ASN1_OBJECT(ASN1_OBJECT *a, unsigned char **pp)
70 {
71     unsigned char *p;
72     int objsize;
73
74     if ((a == NULL) || (a->data == NULL))
75         return (0);
76
77     objsize = ASN1_object_size(0, a->length, V_ASN1_OBJECT);
78     if (pp == NULL)
79         return objsize;
80
81     p = *pp;
82     ASN1_put_object(&p, 0, a->length, V_ASN1_OBJECT, V_ASN1_UNIVERSAL);
83     memcpy(p, a->data, a->length);
84     p += a->length;
85
86     *pp = p;
87     return (objsize);
88 }
89
90 int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num)
91 {
92     int i, first, len = 0, c, use_bn;
93     char ftmp[24], *tmp = ftmp;
94     int tmpsize = sizeof ftmp;
95     const char *p;
96     unsigned long l;
97     BIGNUM *bl = NULL;
98
99     if (num == 0)
100         return (0);
101     else if (num == -1)
102         num = strlen(buf);
103
104     p = buf;
105     c = *(p++);
106     num--;
107     if ((c >= '0') && (c <= '2')) {
108         first = c - '0';
109     } else {
110         ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_FIRST_NUM_TOO_LARGE);
111         goto err;
112     }
113
114     if (num <= 0) {
115         ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_MISSING_SECOND_NUMBER);
116         goto err;
117     }
118     c = *(p++);
119     num--;
120     for (;;) {
121         if (num <= 0)
122             break;
123         if ((c != '.') && (c != ' ')) {
124             ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_INVALID_SEPARATOR);
125             goto err;
126         }
127         l = 0;
128         use_bn = 0;
129         for (;;) {
130             if (num <= 0)
131                 break;
132             num--;
133             c = *(p++);
134             if ((c == ' ') || (c == '.'))
135                 break;
136             if ((c < '0') || (c > '9')) {
137                 ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_INVALID_DIGIT);
138                 goto err;
139             }
140             if (!use_bn && l >= ((ULONG_MAX - 80) / 10L)) {
141                 use_bn = 1;
142                 if (bl == NULL)
143                     bl = BN_new();
144                 if (bl == NULL || !BN_set_word(bl, l))
145                     goto err;
146             }
147             if (use_bn) {
148                 if (!BN_mul_word(bl, 10L)
149                     || !BN_add_word(bl, c - '0'))
150                     goto err;
151             } else
152                 l = l * 10L + (long)(c - '0');
153         }
154         if (len == 0) {
155             if ((first < 2) && (l >= 40)) {
156                 ASN1err(ASN1_F_A2D_ASN1_OBJECT,
157                         ASN1_R_SECOND_NUMBER_TOO_LARGE);
158                 goto err;
159             }
160             if (use_bn) {
161                 if (!BN_add_word(bl, first * 40))
162                     goto err;
163             } else
164                 l += (long)first *40;
165         }
166         i = 0;
167         if (use_bn) {
168             int blsize;
169             blsize = BN_num_bits(bl);
170             blsize = (blsize + 6) / 7;
171             if (blsize > tmpsize) {
172                 if (tmp != ftmp)
173                     OPENSSL_free(tmp);
174                 tmpsize = blsize + 32;
175                 tmp = OPENSSL_malloc(tmpsize);
176                 if (tmp == NULL)
177                     goto err;
178             }
179             while (blsize--)
180                 tmp[i++] = (unsigned char)BN_div_word(bl, 0x80L);
181         } else {
182
183             for (;;) {
184                 tmp[i++] = (unsigned char)l & 0x7f;
185                 l >>= 7L;
186                 if (l == 0L)
187                     break;
188             }
189
190         }
191         if (out != NULL) {
192             if (len + i > olen) {
193                 ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_BUFFER_TOO_SMALL);
194                 goto err;
195             }
196             while (--i > 0)
197                 out[len++] = tmp[i] | 0x80;
198             out[len++] = tmp[0];
199         } else
200             len += i;
201     }
202     if (tmp != ftmp)
203         OPENSSL_free(tmp);
204     BN_free(bl);
205     return (len);
206  err:
207     if (tmp != ftmp)
208         OPENSSL_free(tmp);
209     BN_free(bl);
210     return (0);
211 }
212
213 int i2t_ASN1_OBJECT(char *buf, int buf_len, ASN1_OBJECT *a)
214 {
215     return OBJ_obj2txt(buf, buf_len, a, 0);
216 }
217
218 int i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a)
219 {
220     char buf[80], *p = buf;
221     int i;
222
223     if ((a == NULL) || (a->data == NULL))
224         return (BIO_write(bp, "NULL", 4));
225     i = i2t_ASN1_OBJECT(buf, sizeof buf, a);
226     if (i > (int)(sizeof(buf) - 1)) {
227         p = OPENSSL_malloc(i + 1);
228         if (p == NULL)
229             return -1;
230         i2t_ASN1_OBJECT(p, i + 1, a);
231     }
232     if (i <= 0) {
233         i = BIO_write(bp, "<INVALID>", 9);
234         i += BIO_dump(bp, (const char *)a->data, a->length);
235         return i;
236     }
237     BIO_write(bp, p, i);
238     if (p != buf)
239         OPENSSL_free(p);
240     return (i);
241 }
242
243 ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
244                              long length)
245 {
246     const unsigned char *p;
247     long len;
248     int tag, xclass;
249     int inf, i;
250     ASN1_OBJECT *ret = NULL;
251     p = *pp;
252     inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
253     if (inf & 0x80) {
254         i = ASN1_R_BAD_OBJECT_HEADER;
255         goto err;
256     }
257
258     if (tag != V_ASN1_OBJECT) {
259         i = ASN1_R_EXPECTING_AN_OBJECT;
260         goto err;
261     }
262     ret = c2i_ASN1_OBJECT(a, &p, len);
263     if (ret)
264         *pp = p;
265     return ret;
266  err:
267     ASN1err(ASN1_F_D2I_ASN1_OBJECT, i);
268     return (NULL);
269 }
270
271 ASN1_OBJECT *c2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
272                              long len)
273 {
274     ASN1_OBJECT *ret = NULL, tobj;
275     const unsigned char *p;
276     unsigned char *data;
277     int i, length;
278
279     /*
280      * Sanity check OID encoding. Need at least one content octet. MSB must
281      * be clear in the last octet. can't have leading 0x80 in subidentifiers,
282      * see: X.690 8.19.2
283      */
284     if (len <= 0 || len > INT_MAX || pp == NULL || (p = *pp) == NULL ||
285         p[len - 1] & 0x80) {
286         ASN1err(ASN1_F_C2I_ASN1_OBJECT, ASN1_R_INVALID_OBJECT_ENCODING);
287         return NULL;
288     }
289     /* Now 0 < len <= INT_MAX, so the cast is safe. */
290     length = (int)len;
291     /*
292      * Try to lookup OID in table: these are all valid encodings so if we get
293      * a match we know the OID is valid.
294      */
295     tobj.nid = NID_undef;
296     tobj.data = p;
297     tobj.length = length;
298     tobj.flags = 0;
299     i = OBJ_obj2nid(&tobj);
300     if (i != NID_undef) {
301         /*
302          * Return shared registered OID object: this improves efficiency
303          * because we don't have to return a dynamically allocated OID
304          * and NID lookups can use the cached value.
305          */
306         ret = OBJ_nid2obj(i);
307         if (a) {
308             ASN1_OBJECT_free(*a);
309             *a = ret;
310         }
311         *pp += len;
312         return ret;
313     }
314     for (i = 0; i < length; i++, p++) {
315         if (*p == 0x80 && (!i || !(p[-1] & 0x80))) {
316             ASN1err(ASN1_F_C2I_ASN1_OBJECT, ASN1_R_INVALID_OBJECT_ENCODING);
317             return NULL;
318         }
319     }
320
321     /*
322      * only the ASN1_OBJECTs from the 'table' will have values for ->sn or
323      * ->ln
324      */
325     if ((a == NULL) || ((*a) == NULL) ||
326         !((*a)->flags & ASN1_OBJECT_FLAG_DYNAMIC)) {
327         if ((ret = ASN1_OBJECT_new()) == NULL)
328             return (NULL);
329     } else
330         ret = (*a);
331
332     p = *pp;
333     /* detach data from object */
334     data = (unsigned char *)ret->data;
335     ret->data = NULL;
336     /* once detached we can change it */
337     if ((data == NULL) || (ret->length < length)) {
338         ret->length = 0;
339         OPENSSL_free(data);
340         data = OPENSSL_malloc(length);
341         if (data == NULL) {
342             i = ERR_R_MALLOC_FAILURE;
343             goto err;
344         }
345         ret->flags |= ASN1_OBJECT_FLAG_DYNAMIC_DATA;
346     }
347     memcpy(data, p, length);
348     /* reattach data to object, after which it remains const */
349     ret->data = data;
350     ret->length = length;
351     ret->sn = NULL;
352     ret->ln = NULL;
353     /* ret->flags=ASN1_OBJECT_FLAG_DYNAMIC; we know it is dynamic */
354     p += length;
355
356     if (a != NULL)
357         (*a) = ret;
358     *pp = p;
359     return (ret);
360  err:
361     ASN1err(ASN1_F_C2I_ASN1_OBJECT, i);
362     if ((a == NULL) || (*a != ret))
363         ASN1_OBJECT_free(ret);
364     return (NULL);
365 }
366
367 ASN1_OBJECT *ASN1_OBJECT_new(void)
368 {
369     ASN1_OBJECT *ret;
370
371     ret = OPENSSL_zalloc(sizeof(*ret));
372     if (ret == NULL) {
373         ASN1err(ASN1_F_ASN1_OBJECT_NEW, ERR_R_MALLOC_FAILURE);
374         return (NULL);
375     }
376     ret->flags = ASN1_OBJECT_FLAG_DYNAMIC;
377     return (ret);
378 }
379
380 void ASN1_OBJECT_free(ASN1_OBJECT *a)
381 {
382     if (a == NULL)
383         return;
384     if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS) {
385 #ifndef CONST_STRICT            /* disable purely for compile-time strict
386                                  * const checking. Doing this on a "real"
387                                  * compile will cause memory leaks */
388         OPENSSL_free((void*)a->sn);
389         OPENSSL_free((void*)a->ln);
390 #endif
391         a->sn = a->ln = NULL;
392     }
393     if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA) {
394         OPENSSL_free((void*)a->data);
395         a->data = NULL;
396         a->length = 0;
397     }
398     if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC)
399         OPENSSL_free(a);
400 }
401
402 ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
403                                 const char *sn, const char *ln)
404 {
405     ASN1_OBJECT o;
406
407     o.sn = sn;
408     o.ln = ln;
409     o.data = data;
410     o.nid = nid;
411     o.length = len;
412     o.flags = ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
413         ASN1_OBJECT_FLAG_DYNAMIC_DATA;
414     return (OBJ_dup(&o));
415 }