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