• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2  * All rights reserved.
3  *
4  * This package is an SSL implementation written
5  * by Eric Young (eay@cryptsoft.com).
6  * The implementation was written so as to conform with Netscapes SSL.
7  *
8  * This library is free for commercial and non-commercial use as long as
9  * the following conditions are aheared to.  The following conditions
10  * apply to all code found in this distribution, be it the RC4, RSA,
11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12  * included with this distribution is covered by the same copyright terms
13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14  *
15  * Copyright remains Eric Young's, and as such any Copyright notices in
16  * the code are not to be removed.
17  * If this package is used in a product, Eric Young should be given attribution
18  * as the author of the parts of the library used.
19  * This can be in the form of a textual message at program startup or
20  * in documentation (online or textual) provided with the package.
21  *
22  * Redistribution and use in source and binary forms, with or without
23  * modification, are permitted provided that the following conditions
24  * are met:
25  * 1. Redistributions of source code must retain the copyright
26  *    notice, this list of conditions and the following disclaimer.
27  * 2. Redistributions in binary form must reproduce the above copyright
28  *    notice, this list of conditions and the following disclaimer in the
29  *    documentation and/or other materials provided with the distribution.
30  * 3. All advertising materials mentioning features or use of this software
31  *    must display the following acknowledgement:
32  *    "This product includes cryptographic software written by
33  *     Eric Young (eay@cryptsoft.com)"
34  *    The word 'cryptographic' can be left out if the rouines from the library
35  *    being used are not cryptographic related :-).
36  * 4. If you include any Windows specific code (or a derivative thereof) from
37  *    the apps directory (application code) you must include an acknowledgement:
38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50  * SUCH DAMAGE.
51  *
52  * The licence and distribution terms for any publically available version or
53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
54  * copied and put under another distribution licence
55  * [including the GNU Public Licence.] */
56 
57 #include <openssl/asn1.h>
58 
59 #include <limits.h>
60 #include <string.h>
61 
62 #include <openssl/err.h>
63 #include <openssl/mem.h>
64 #include <openssl/obj.h>
65 
66 #include "../internal.h"
67 
68 
i2d_ASN1_OBJECT(ASN1_OBJECT * a,unsigned char ** pp)69 int i2d_ASN1_OBJECT(ASN1_OBJECT *a, unsigned char **pp)
70 {
71     unsigned char *p, *allocated = NULL;
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 || objsize == -1)
79         return objsize;
80 
81     if (*pp == NULL) {
82         if ((p = allocated = OPENSSL_malloc(objsize)) == NULL) {
83             OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
84             return 0;
85         }
86     } else {
87         p = *pp;
88     }
89 
90     ASN1_put_object(&p, 0, a->length, V_ASN1_OBJECT, V_ASN1_UNIVERSAL);
91     OPENSSL_memcpy(p, a->data, a->length);
92 
93     /*
94      * If a new buffer was allocated, just return it back.
95      * If not, return the incremented buffer pointer.
96      */
97     *pp = allocated != NULL ? allocated : p + a->length;
98     return objsize;
99 }
100 
i2t_ASN1_OBJECT(char * buf,int buf_len,ASN1_OBJECT * a)101 int i2t_ASN1_OBJECT(char *buf, int buf_len, ASN1_OBJECT *a)
102 {
103     return OBJ_obj2txt(buf, buf_len, a, 0);
104 }
105 
i2a_ASN1_OBJECT(BIO * bp,ASN1_OBJECT * a)106 int i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a)
107 {
108     char buf[80], *p = buf;
109     int i;
110 
111     if ((a == NULL) || (a->data == NULL))
112         return (BIO_write(bp, "NULL", 4));
113     i = i2t_ASN1_OBJECT(buf, sizeof buf, a);
114     if (i > (int)(sizeof(buf) - 1)) {
115         p = OPENSSL_malloc(i + 1);
116         if (!p)
117             return -1;
118         i2t_ASN1_OBJECT(p, i + 1, a);
119     }
120     if (i <= 0)
121         return BIO_write(bp, "<INVALID>", 9);
122     BIO_write(bp, p, i);
123     if (p != buf)
124         OPENSSL_free(p);
125     return (i);
126 }
127 
d2i_ASN1_OBJECT(ASN1_OBJECT ** a,const unsigned char ** pp,long length)128 ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
129                              long length)
130 {
131     const unsigned char *p;
132     long len;
133     int tag, xclass;
134     int inf, i;
135     ASN1_OBJECT *ret = NULL;
136     p = *pp;
137     inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
138     if (inf & 0x80) {
139         i = ASN1_R_BAD_OBJECT_HEADER;
140         goto err;
141     }
142 
143     if (tag != V_ASN1_OBJECT) {
144         i = ASN1_R_EXPECTING_AN_OBJECT;
145         goto err;
146     }
147     ret = c2i_ASN1_OBJECT(a, &p, len);
148     if (ret)
149         *pp = p;
150     return ret;
151  err:
152     OPENSSL_PUT_ERROR(ASN1, i);
153     return (NULL);
154 }
155 
c2i_ASN1_OBJECT(ASN1_OBJECT ** a,const unsigned char ** pp,long len)156 ASN1_OBJECT *c2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
157                              long len)
158 {
159     ASN1_OBJECT *ret = NULL;
160     const unsigned char *p;
161     unsigned char *data;
162     int i, length;
163 
164     /*
165      * Sanity check OID encoding. Need at least one content octet. MSB must
166      * be clear in the last octet. can't have leading 0x80 in subidentifiers,
167      * see: X.690 8.19.2
168      */
169     if (len <= 0 || len > INT_MAX || pp == NULL || (p = *pp) == NULL ||
170         p[len - 1] & 0x80) {
171         OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_OBJECT_ENCODING);
172         return NULL;
173     }
174     /* Now 0 < len <= INT_MAX, so the cast is safe. */
175     length = (int)len;
176     for (i = 0; i < length; i++, p++) {
177         if (*p == 0x80 && (!i || !(p[-1] & 0x80))) {
178             OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_OBJECT_ENCODING);
179             return NULL;
180         }
181     }
182 
183     /*
184      * only the ASN1_OBJECTs from the 'table' will have values for ->sn or
185      * ->ln
186      */
187     if ((a == NULL) || ((*a) == NULL) ||
188         !((*a)->flags & ASN1_OBJECT_FLAG_DYNAMIC)) {
189         if ((ret = ASN1_OBJECT_new()) == NULL)
190             return (NULL);
191     } else
192         ret = (*a);
193 
194     p = *pp;
195     /* detach data from object */
196     data = (unsigned char *)ret->data;
197     ret->data = NULL;
198     /* once detached we can change it */
199     if ((data == NULL) || (ret->length < length)) {
200         ret->length = 0;
201         if (data != NULL)
202             OPENSSL_free(data);
203         data = (unsigned char *)OPENSSL_malloc(length);
204         if (data == NULL) {
205             i = ERR_R_MALLOC_FAILURE;
206             goto err;
207         }
208         ret->flags |= ASN1_OBJECT_FLAG_DYNAMIC_DATA;
209     }
210     OPENSSL_memcpy(data, p, length);
211     /* reattach data to object, after which it remains const */
212     ret->data = data;
213     ret->length = length;
214     ret->sn = NULL;
215     ret->ln = NULL;
216     /* ret->flags=ASN1_OBJECT_FLAG_DYNAMIC; we know it is dynamic */
217     p += length;
218 
219     if (a != NULL)
220         (*a) = ret;
221     *pp = p;
222     return (ret);
223  err:
224     OPENSSL_PUT_ERROR(ASN1, i);
225     if ((ret != NULL) && ((a == NULL) || (*a != ret)))
226         ASN1_OBJECT_free(ret);
227     return (NULL);
228 }
229 
ASN1_OBJECT_new(void)230 ASN1_OBJECT *ASN1_OBJECT_new(void)
231 {
232     ASN1_OBJECT *ret;
233 
234     ret = (ASN1_OBJECT *)OPENSSL_malloc(sizeof(ASN1_OBJECT));
235     if (ret == NULL) {
236         OPENSSL_PUT_ERROR(ASN1, ERR_R_MALLOC_FAILURE);
237         return (NULL);
238     }
239     ret->length = 0;
240     ret->data = NULL;
241     ret->nid = 0;
242     ret->sn = NULL;
243     ret->ln = NULL;
244     ret->flags = ASN1_OBJECT_FLAG_DYNAMIC;
245     return (ret);
246 }
247 
ASN1_OBJECT_free(ASN1_OBJECT * a)248 void ASN1_OBJECT_free(ASN1_OBJECT *a)
249 {
250     if (a == NULL)
251         return;
252     if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS) {
253 #ifndef CONST_STRICT            /* disable purely for compile-time strict
254                                  * const checking. Doing this on a "real"
255                                  * compile will cause memory leaks */
256         if (a->sn != NULL)
257             OPENSSL_free((void *)a->sn);
258         if (a->ln != NULL)
259             OPENSSL_free((void *)a->ln);
260 #endif
261         a->sn = a->ln = NULL;
262     }
263     if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA) {
264         if (a->data != NULL)
265             OPENSSL_free((void *)a->data);
266         a->data = NULL;
267         a->length = 0;
268     }
269     if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC)
270         OPENSSL_free(a);
271 }
272 
ASN1_OBJECT_create(int nid,unsigned char * data,int len,const char * sn,const char * ln)273 ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
274                                 const char *sn, const char *ln)
275 {
276     ASN1_OBJECT o;
277 
278     o.sn = sn;
279     o.ln = ln;
280     o.data = data;
281     o.nid = nid;
282     o.length = len;
283     o.flags = ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
284         ASN1_OBJECT_FLAG_DYNAMIC_DATA;
285     return (OBJ_dup(&o));
286 }
287