2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 2001
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 /* free an asn1 structure */
24 void asn1_free(ASN1_DATA *data)
26 SAFE_FREE(data->data);
29 /* write to the ASN1 buffer, advancing the buffer pointer */
30 BOOL asn1_write(ASN1_DATA *data, const void *p, int len)
32 if (data->has_error) return False;
33 if (data->length < data->ofs+len) {
35 newp = SMB_REALLOC(data->data, data->ofs+len);
37 SAFE_FREE(data->data);
38 data->has_error = True;
42 data->length = data->ofs+len;
44 memcpy(data->data + data->ofs, p, len);
49 /* useful fn for writing a uint8 */
50 BOOL asn1_write_uint8(ASN1_DATA *data, uint8 v)
52 return asn1_write(data, &v, 1);
55 /* push a tag onto the asn1 data buffer. Used for nested structures */
56 BOOL asn1_push_tag(ASN1_DATA *data, uint8 tag)
58 struct nesting *nesting;
60 asn1_write_uint8(data, tag);
61 nesting = SMB_MALLOC_P(struct nesting);
63 data->has_error = True;
67 nesting->start = data->ofs;
68 nesting->next = data->nesting;
69 data->nesting = nesting;
70 return asn1_write_uint8(data, 0xff);
74 BOOL asn1_pop_tag(ASN1_DATA *data)
76 struct nesting *nesting;
79 nesting = data->nesting;
82 data->has_error = True;
85 len = data->ofs - (nesting->start+1);
86 /* yes, this is ugly. We don't know in advance how many bytes the length
87 of a tag will take, so we assumed 1 byte. If we were wrong then we
88 need to correct our mistake */
90 data->data[nesting->start] = 0x83;
91 if (!asn1_write_uint8(data, 0)) return False;
92 if (!asn1_write_uint8(data, 0)) return False;
93 if (!asn1_write_uint8(data, 0)) return False;
94 memmove(data->data+nesting->start+4, data->data+nesting->start+1, len);
95 data->data[nesting->start+1] = (len>>16) & 0xFF;
96 data->data[nesting->start+2] = (len>>8) & 0xFF;
97 data->data[nesting->start+3] = len&0xff;
98 } else if (len > 255) {
99 data->data[nesting->start] = 0x82;
100 if (!asn1_write_uint8(data, 0)) return False;
101 if (!asn1_write_uint8(data, 0)) return False;
102 memmove(data->data+nesting->start+3, data->data+nesting->start+1, len);
103 data->data[nesting->start+1] = len>>8;
104 data->data[nesting->start+2] = len&0xff;
105 } else if (len > 127) {
106 data->data[nesting->start] = 0x81;
107 if (!asn1_write_uint8(data, 0)) return False;
108 memmove(data->data+nesting->start+2, data->data+nesting->start+1, len);
109 data->data[nesting->start+1] = len;
111 data->data[nesting->start] = len;
114 data->nesting = nesting->next;
120 /* write an integer */
121 BOOL asn1_write_Integer(ASN1_DATA *data, int i)
123 if (!asn1_push_tag(data, ASN1_INTEGER)) return False;
125 asn1_write_uint8(data, i);
128 return asn1_pop_tag(data);
131 /* write an object ID to a ASN1 buffer */
132 BOOL asn1_write_OID(ASN1_DATA *data, const char *OID)
135 const char *p = (const char *)OID;
138 if (!asn1_push_tag(data, ASN1_OID))
140 v = strtol(p, &newp, 10);
142 v2 = strtol(p, &newp, 10);
144 if (!asn1_write_uint8(data, 40*v + v2))
148 v = strtol(p, &newp, 10);
150 if (v >= (1<<28)) asn1_write_uint8(data, 0x80 | ((v>>28)&0xff));
151 if (v >= (1<<21)) asn1_write_uint8(data, 0x80 | ((v>>21)&0xff));
152 if (v >= (1<<14)) asn1_write_uint8(data, 0x80 | ((v>>14)&0xff));
153 if (v >= (1<<7)) asn1_write_uint8(data, 0x80 | ((v>>7)&0xff));
154 if (!asn1_write_uint8(data, v&0x7f))
157 return asn1_pop_tag(data);
160 /* write an octet string */
161 BOOL asn1_write_OctetString(ASN1_DATA *data, const void *p, size_t length)
163 asn1_push_tag(data, ASN1_OCTET_STRING);
164 asn1_write(data, p, length);
166 return !data->has_error;
169 /* write a general string */
170 BOOL asn1_write_GeneralString(ASN1_DATA *data, const char *s)
172 asn1_push_tag(data, ASN1_GENERAL_STRING);
173 asn1_write(data, s, strlen(s));
175 return !data->has_error;
178 /* write a BOOLEAN */
179 BOOL asn1_write_BOOLEAN(ASN1_DATA *data, BOOL v)
181 asn1_write_uint8(data, ASN1_BOOLEAN);
182 asn1_write_uint8(data, v);
183 return !data->has_error;
186 /* write a BOOLEAN - hmm, I suspect this one is the correct one, and the
187 above boolean is bogus. Need to check */
188 BOOL asn1_write_BOOLEAN2(ASN1_DATA *data, BOOL v)
190 asn1_push_tag(data, ASN1_BOOLEAN);
191 asn1_write_uint8(data, v);
193 return !data->has_error;
196 /* check a BOOLEAN */
197 BOOL asn1_check_BOOLEAN(ASN1_DATA *data, BOOL v)
201 asn1_read_uint8(data, &b);
202 if (b != ASN1_BOOLEAN) {
203 data->has_error = True;
206 asn1_read_uint8(data, &b);
208 data->has_error = True;
211 return !data->has_error;
215 /* load a ASN1_DATA structure with a lump of data, ready to be parsed */
216 BOOL asn1_load(ASN1_DATA *data, DATA_BLOB blob)
219 data->data = memdup(blob.data, blob.length);
221 data->has_error = True;
224 data->length = blob.length;
228 /* read from a ASN1 buffer, advancing the buffer pointer */
229 BOOL asn1_read(ASN1_DATA *data, void *p, int len)
234 if (len < 0 || data->ofs + len < data->ofs || data->ofs + len < len) {
235 data->has_error = True;
239 if (data->ofs + len > data->length) {
240 data->has_error = True;
243 memcpy(p, data->data + data->ofs, len);
248 /* read a uint8 from a ASN1 buffer */
249 BOOL asn1_read_uint8(ASN1_DATA *data, uint8 *v)
251 return asn1_read(data, v, 1);
254 /* start reading a nested asn1 structure */
255 BOOL asn1_start_tag(ASN1_DATA *data, uint8 tag)
258 struct nesting *nesting;
260 if (!asn1_read_uint8(data, &b))
264 data->has_error = True;
267 nesting = SMB_MALLOC_P(struct nesting);
269 data->has_error = True;
273 if (!asn1_read_uint8(data, &b)) {
279 if (!asn1_read_uint8(data, &b))
283 if (!asn1_read_uint8(data, &b))
285 nesting->taglen = (nesting->taglen << 8) | b;
291 nesting->start = data->ofs;
292 nesting->next = data->nesting;
293 data->nesting = nesting;
294 return !data->has_error;
298 /* stop reading a tag */
299 BOOL asn1_end_tag(ASN1_DATA *data)
301 struct nesting *nesting;
303 /* make sure we read it all */
304 if (asn1_tag_remaining(data) != 0) {
305 data->has_error = True;
309 nesting = data->nesting;
312 data->has_error = True;
316 data->nesting = nesting->next;
321 /* work out how many bytes are left in this nested tag */
322 int asn1_tag_remaining(ASN1_DATA *data)
327 if (!data->nesting) {
328 data->has_error = True;
331 return data->nesting->taglen - (data->ofs - data->nesting->start);
334 /* read an object ID from a ASN1 buffer */
335 BOOL asn1_read_OID(ASN1_DATA *data, char **OID)
341 if (!asn1_start_tag(data, ASN1_OID)) return False;
342 asn1_read_uint8(data, &b);
345 fstr_sprintf(el, "%u", b/40);
346 pstrcat(oid_str, el);
347 fstr_sprintf(el, " %u", b%40);
348 pstrcat(oid_str, el);
350 while (asn1_tag_remaining(data) > 0) {
353 asn1_read_uint8(data, &b);
354 v = (v<<7) | (b&0x7f);
355 } while (!data->has_error && b & 0x80);
356 fstr_sprintf(el, " %u", v);
357 pstrcat(oid_str, el);
362 *OID = SMB_STRDUP(oid_str);
364 return !data->has_error;
367 /* check that the next object ID is correct */
368 BOOL asn1_check_OID(ASN1_DATA *data, const char *OID)
372 if (!asn1_read_OID(data, &id)) return False;
374 if (strcmp(id, OID) != 0) {
375 data->has_error = True;
382 /* read a GeneralString from a ASN1 buffer */
383 BOOL asn1_read_GeneralString(ASN1_DATA *data, char **s)
386 if (!asn1_start_tag(data, ASN1_GENERAL_STRING)) return False;
387 len = asn1_tag_remaining(data);
389 data->has_error = True;
392 *s = SMB_MALLOC(len+1);
394 data->has_error = True;
397 asn1_read(data, *s, len);
400 return !data->has_error;
403 /* read a octet string blob */
404 BOOL asn1_read_OctetString(ASN1_DATA *data, DATA_BLOB *blob)
408 if (!asn1_start_tag(data, ASN1_OCTET_STRING)) return False;
409 len = asn1_tag_remaining(data);
411 data->has_error = True;
414 *blob = data_blob(NULL, len);
415 asn1_read(data, blob->data, len);
417 return !data->has_error;
420 /* read an interger */
421 BOOL asn1_read_Integer(ASN1_DATA *data, int *i)
426 if (!asn1_start_tag(data, ASN1_INTEGER)) return False;
427 while (asn1_tag_remaining(data)>0) {
428 asn1_read_uint8(data, &b);
431 return asn1_end_tag(data);
435 /* check a enumarted value is correct */
436 BOOL asn1_check_enumerated(ASN1_DATA *data, int v)
439 if (!asn1_start_tag(data, ASN1_ENUMERATED)) return False;
440 asn1_read_uint8(data, &b);
444 data->has_error = False;
446 return !data->has_error;
449 /* write an enumarted value to the stream */
450 BOOL asn1_write_enumerated(ASN1_DATA *data, uint8 v)
452 if (!asn1_push_tag(data, ASN1_ENUMERATED)) return False;
453 asn1_write_uint8(data, v);
455 return !data->has_error;