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
) {
34 data
->data
= SMB_REALLOC_ARRAY(data
->data
, unsigned char,
37 data
->has_error
= True
;
40 data
->length
= data
->ofs
+len
;
42 memcpy(data
->data
+ data
->ofs
, p
, len
);
47 /* useful fn for writing a uint8 */
48 BOOL
asn1_write_uint8(ASN1_DATA
*data
, uint8 v
)
50 return asn1_write(data
, &v
, 1);
53 /* push a tag onto the asn1 data buffer. Used for nested structures */
54 BOOL
asn1_push_tag(ASN1_DATA
*data
, uint8 tag
)
56 struct nesting
*nesting
;
58 asn1_write_uint8(data
, tag
);
59 nesting
= SMB_MALLOC_P(struct nesting
);
61 data
->has_error
= True
;
65 nesting
->start
= data
->ofs
;
66 nesting
->next
= data
->nesting
;
67 data
->nesting
= nesting
;
68 return asn1_write_uint8(data
, 0xff);
72 BOOL
asn1_pop_tag(ASN1_DATA
*data
)
74 struct nesting
*nesting
;
77 nesting
= data
->nesting
;
80 data
->has_error
= True
;
83 len
= data
->ofs
- (nesting
->start
+1);
84 /* yes, this is ugly. We don't know in advance how many bytes the length
85 of a tag will take, so we assumed 1 byte. If we were wrong then we
86 need to correct our mistake */
88 data
->data
[nesting
->start
] = 0x83;
89 if (!asn1_write_uint8(data
, 0)) return False
;
90 if (!asn1_write_uint8(data
, 0)) return False
;
91 if (!asn1_write_uint8(data
, 0)) return False
;
92 memmove(data
->data
+nesting
->start
+4, data
->data
+nesting
->start
+1, len
);
93 data
->data
[nesting
->start
+1] = (len
>>16) & 0xFF;
94 data
->data
[nesting
->start
+2] = (len
>>8) & 0xFF;
95 data
->data
[nesting
->start
+3] = len
&0xff;
96 } else if (len
> 255) {
97 data
->data
[nesting
->start
] = 0x82;
98 if (!asn1_write_uint8(data
, 0)) return False
;
99 if (!asn1_write_uint8(data
, 0)) return False
;
100 memmove(data
->data
+nesting
->start
+3, data
->data
+nesting
->start
+1, len
);
101 data
->data
[nesting
->start
+1] = len
>>8;
102 data
->data
[nesting
->start
+2] = len
&0xff;
103 } else if (len
> 127) {
104 data
->data
[nesting
->start
] = 0x81;
105 if (!asn1_write_uint8(data
, 0)) return False
;
106 memmove(data
->data
+nesting
->start
+2, data
->data
+nesting
->start
+1, len
);
107 data
->data
[nesting
->start
+1] = len
;
109 data
->data
[nesting
->start
] = len
;
112 data
->nesting
= nesting
->next
;
118 /* write an integer */
119 BOOL
asn1_write_Integer(ASN1_DATA
*data
, int i
)
121 if (!asn1_push_tag(data
, ASN1_INTEGER
)) return False
;
123 asn1_write_uint8(data
, i
);
126 return asn1_pop_tag(data
);
129 /* write an object ID to a ASN1 buffer */
130 BOOL
asn1_write_OID(ASN1_DATA
*data
, const char *OID
)
133 const char *p
= (const char *)OID
;
136 if (!asn1_push_tag(data
, ASN1_OID
))
138 v
= strtol(p
, &newp
, 10);
140 v2
= strtol(p
, &newp
, 10);
142 if (!asn1_write_uint8(data
, 40*v
+ v2
))
146 v
= strtol(p
, &newp
, 10);
148 if (v
>= (1<<28)) asn1_write_uint8(data
, 0x80 | ((v
>>28)&0xff));
149 if (v
>= (1<<21)) asn1_write_uint8(data
, 0x80 | ((v
>>21)&0xff));
150 if (v
>= (1<<14)) asn1_write_uint8(data
, 0x80 | ((v
>>14)&0xff));
151 if (v
>= (1<<7)) asn1_write_uint8(data
, 0x80 | ((v
>>7)&0xff));
152 if (!asn1_write_uint8(data
, v
&0x7f))
155 return asn1_pop_tag(data
);
158 /* write an octet string */
159 BOOL
asn1_write_OctetString(ASN1_DATA
*data
, const void *p
, size_t length
)
161 asn1_push_tag(data
, ASN1_OCTET_STRING
);
162 asn1_write(data
, p
, length
);
164 return !data
->has_error
;
167 /* write a general string */
168 BOOL
asn1_write_GeneralString(ASN1_DATA
*data
, const char *s
)
170 asn1_push_tag(data
, ASN1_GENERAL_STRING
);
171 asn1_write(data
, s
, strlen(s
));
173 return !data
->has_error
;
176 /* write a BOOLEAN */
177 BOOL
asn1_write_BOOLEAN(ASN1_DATA
*data
, BOOL v
)
179 asn1_write_uint8(data
, ASN1_BOOLEAN
);
180 asn1_write_uint8(data
, v
);
181 return !data
->has_error
;
184 /* write a BOOLEAN - hmm, I suspect this one is the correct one, and the
185 above boolean is bogus. Need to check */
186 BOOL
asn1_write_BOOLEAN2(ASN1_DATA
*data
, BOOL v
)
188 asn1_push_tag(data
, ASN1_BOOLEAN
);
189 asn1_write_uint8(data
, v
);
191 return !data
->has_error
;
194 /* check a BOOLEAN */
195 BOOL
asn1_check_BOOLEAN(ASN1_DATA
*data
, BOOL v
)
199 asn1_read_uint8(data
, &b
);
200 if (b
!= ASN1_BOOLEAN
) {
201 data
->has_error
= True
;
204 asn1_read_uint8(data
, &b
);
206 data
->has_error
= True
;
209 return !data
->has_error
;
213 /* load a ASN1_DATA structure with a lump of data, ready to be parsed */
214 BOOL
asn1_load(ASN1_DATA
*data
, DATA_BLOB blob
)
217 data
->data
= (unsigned char *)memdup(blob
.data
, blob
.length
);
219 data
->has_error
= True
;
222 data
->length
= blob
.length
;
226 /* read from a ASN1 buffer, advancing the buffer pointer */
227 BOOL
asn1_read(ASN1_DATA
*data
, void *p
, int len
)
232 if (len
< 0 || data
->ofs
+ len
< data
->ofs
|| data
->ofs
+ len
< len
) {
233 data
->has_error
= True
;
237 if (data
->ofs
+ len
> data
->length
) {
238 data
->has_error
= True
;
241 memcpy(p
, data
->data
+ data
->ofs
, len
);
246 /* read a uint8 from a ASN1 buffer */
247 BOOL
asn1_read_uint8(ASN1_DATA
*data
, uint8
*v
)
249 return asn1_read(data
, v
, 1);
252 /* start reading a nested asn1 structure */
253 BOOL
asn1_start_tag(ASN1_DATA
*data
, uint8 tag
)
256 struct nesting
*nesting
;
258 if (!asn1_read_uint8(data
, &b
))
262 data
->has_error
= True
;
265 nesting
= SMB_MALLOC_P(struct nesting
);
267 data
->has_error
= True
;
271 if (!asn1_read_uint8(data
, &b
)) {
278 if (!asn1_read_uint8(data
, &b
)) {
284 if (!asn1_read_uint8(data
, &b
)) {
288 nesting
->taglen
= (nesting
->taglen
<< 8) | b
;
294 nesting
->start
= data
->ofs
;
295 nesting
->next
= data
->nesting
;
296 data
->nesting
= nesting
;
297 return !data
->has_error
;
301 /* stop reading a tag */
302 BOOL
asn1_end_tag(ASN1_DATA
*data
)
304 struct nesting
*nesting
;
306 /* make sure we read it all */
307 if (asn1_tag_remaining(data
) != 0) {
308 data
->has_error
= True
;
312 nesting
= data
->nesting
;
315 data
->has_error
= True
;
319 data
->nesting
= nesting
->next
;
324 /* work out how many bytes are left in this nested tag */
325 int asn1_tag_remaining(ASN1_DATA
*data
)
330 if (!data
->nesting
) {
331 data
->has_error
= True
;
334 return data
->nesting
->taglen
- (data
->ofs
- data
->nesting
->start
);
337 /* read an object ID from a ASN1 buffer */
338 BOOL
asn1_read_OID(ASN1_DATA
*data
, char **OID
)
346 if (!asn1_start_tag(data
, ASN1_OID
)) {
349 asn1_read_uint8(data
, &b
);
352 fstr_sprintf(el
, "%u", b
/40);
353 pstrcat(oid_str
, el
);
354 fstr_sprintf(el
, " %u", b
%40);
355 pstrcat(oid_str
, el
);
357 while (asn1_tag_remaining(data
) > 0) {
360 asn1_read_uint8(data
, &b
);
361 v
= (v
<<7) | (b
&0x7f);
362 } while (!data
->has_error
&& b
& 0x80);
363 fstr_sprintf(el
, " %u", v
);
364 pstrcat(oid_str
, el
);
369 if (!data
->has_error
) {
370 *OID
= SMB_STRDUP(oid_str
);
373 return !data
->has_error
;
376 /* check that the next object ID is correct */
377 BOOL
asn1_check_OID(ASN1_DATA
*data
, const char *OID
)
381 if (!asn1_read_OID(data
, &id
)) {
385 if (strcmp(id
, OID
) != 0) {
386 data
->has_error
= True
;
393 /* read a GeneralString from a ASN1 buffer */
394 BOOL
asn1_read_GeneralString(ASN1_DATA
*data
, char **s
)
401 if (!asn1_start_tag(data
, ASN1_GENERAL_STRING
)) {
404 len
= asn1_tag_remaining(data
);
406 data
->has_error
= True
;
409 str
= SMB_MALLOC_ARRAY(char, len
+1);
411 data
->has_error
= True
;
414 asn1_read(data
, str
, len
);
418 if (!data
->has_error
) {
421 return !data
->has_error
;
424 /* read a octet string blob */
425 BOOL
asn1_read_OctetString(ASN1_DATA
*data
, DATA_BLOB
*blob
)
429 if (!asn1_start_tag(data
, ASN1_OCTET_STRING
)) return False
;
430 len
= asn1_tag_remaining(data
);
432 data
->has_error
= True
;
435 *blob
= data_blob(NULL
, len
);
436 asn1_read(data
, blob
->data
, len
);
438 return !data
->has_error
;
441 /* read an interger */
442 BOOL
asn1_read_Integer(ASN1_DATA
*data
, int *i
)
447 if (!asn1_start_tag(data
, ASN1_INTEGER
)) return False
;
448 while (asn1_tag_remaining(data
)>0) {
449 asn1_read_uint8(data
, &b
);
452 return asn1_end_tag(data
);
456 /* check a enumarted value is correct */
457 BOOL
asn1_check_enumerated(ASN1_DATA
*data
, int v
)
460 if (!asn1_start_tag(data
, ASN1_ENUMERATED
)) return False
;
461 asn1_read_uint8(data
, &b
);
465 data
->has_error
= False
;
467 return !data
->has_error
;
470 /* write an enumarted value to the stream */
471 BOOL
asn1_write_enumerated(ASN1_DATA
*data
, uint8 v
)
473 if (!asn1_push_tag(data
, ASN1_ENUMERATED
)) return False
;
474 asn1_write_uint8(data
, v
);
476 return !data
->has_error
;