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 3 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, see <http://www.gnu.org/licenses/>.
21 #include "../lib/util/asn1.h"
23 /* allocate an asn1 structure */
24 struct asn1_data
*asn1_init(TALLOC_CTX
*mem_ctx
)
26 struct asn1_data
*ret
= talloc_zero(mem_ctx
, struct asn1_data
);
28 DEBUG(0,("asn1_init failed! out of memory\n"));
33 /* free an asn1 structure */
34 void asn1_free(struct asn1_data
*data
)
39 /* write to the ASN1 buffer, advancing the buffer pointer */
40 bool asn1_write(struct asn1_data
*data
, const void *p
, int len
)
42 if (data
->has_error
) return false;
43 if (data
->length
< data
->ofs
+len
) {
45 newp
= talloc_realloc(data
, data
->data
, uint8_t, data
->ofs
+len
);
48 data
->has_error
= true;
52 data
->length
= data
->ofs
+len
;
54 memcpy(data
->data
+ data
->ofs
, p
, len
);
59 /* useful fn for writing a uint8_t */
60 bool asn1_write_uint8(struct asn1_data
*data
, uint8_t v
)
62 return asn1_write(data
, &v
, 1);
65 /* push a tag onto the asn1 data buffer. Used for nested structures */
66 bool asn1_push_tag(struct asn1_data
*data
, uint8_t tag
)
68 struct nesting
*nesting
;
70 asn1_write_uint8(data
, tag
);
71 nesting
= talloc(data
, struct nesting
);
73 data
->has_error
= true;
77 nesting
->start
= data
->ofs
;
78 nesting
->next
= data
->nesting
;
79 data
->nesting
= nesting
;
80 return asn1_write_uint8(data
, 0xff);
84 bool asn1_pop_tag(struct asn1_data
*data
)
86 struct nesting
*nesting
;
89 nesting
= data
->nesting
;
92 data
->has_error
= true;
95 len
= data
->ofs
- (nesting
->start
+1);
96 /* yes, this is ugly. We don't know in advance how many bytes the length
97 of a tag will take, so we assumed 1 byte. If we were wrong then we
98 need to correct our mistake */
100 data
->data
[nesting
->start
] = 0x84;
101 if (!asn1_write_uint8(data
, 0)) return false;
102 if (!asn1_write_uint8(data
, 0)) return false;
103 if (!asn1_write_uint8(data
, 0)) return false;
104 if (!asn1_write_uint8(data
, 0)) return false;
105 memmove(data
->data
+nesting
->start
+5, data
->data
+nesting
->start
+1, len
);
106 data
->data
[nesting
->start
+1] = (len
>>24) & 0xFF;
107 data
->data
[nesting
->start
+2] = (len
>>16) & 0xFF;
108 data
->data
[nesting
->start
+3] = (len
>>8) & 0xFF;
109 data
->data
[nesting
->start
+4] = len
&0xff;
110 } else if (len
> 0xFFFF) {
111 data
->data
[nesting
->start
] = 0x83;
112 if (!asn1_write_uint8(data
, 0)) return false;
113 if (!asn1_write_uint8(data
, 0)) return false;
114 if (!asn1_write_uint8(data
, 0)) return false;
115 memmove(data
->data
+nesting
->start
+4, data
->data
+nesting
->start
+1, len
);
116 data
->data
[nesting
->start
+1] = (len
>>16) & 0xFF;
117 data
->data
[nesting
->start
+2] = (len
>>8) & 0xFF;
118 data
->data
[nesting
->start
+3] = len
&0xff;
119 } else if (len
> 255) {
120 data
->data
[nesting
->start
] = 0x82;
121 if (!asn1_write_uint8(data
, 0)) return false;
122 if (!asn1_write_uint8(data
, 0)) return false;
123 memmove(data
->data
+nesting
->start
+3, data
->data
+nesting
->start
+1, len
);
124 data
->data
[nesting
->start
+1] = len
>>8;
125 data
->data
[nesting
->start
+2] = len
&0xff;
126 } else if (len
> 127) {
127 data
->data
[nesting
->start
] = 0x81;
128 if (!asn1_write_uint8(data
, 0)) return false;
129 memmove(data
->data
+nesting
->start
+2, data
->data
+nesting
->start
+1, len
);
130 data
->data
[nesting
->start
+1] = len
;
132 data
->data
[nesting
->start
] = len
;
135 data
->nesting
= nesting
->next
;
136 talloc_free(nesting
);
140 /* "i" is the one's complement representation, as is the normal result of an
141 * implicit signed->unsigned conversion */
143 static bool push_int_bigendian(struct asn1_data
*data
, unsigned int i
, bool negative
)
145 uint8_t lowest
= i
& 0xFF;
149 if (!push_int_bigendian(data
, i
, negative
))
152 if (data
->nesting
->start
+1 == data
->ofs
) {
154 /* We did not write anything yet, looking at the highest
158 /* Don't write leading 0xff's */
162 if ((lowest
& 0x80) == 0) {
163 /* The only exception for a leading 0xff is if
164 * the highest bit is 0, which would indicate
165 * a positive value */
166 if (!asn1_write_uint8(data
, 0xff))
171 /* The highest bit of a positive integer is 1,
172 * this would indicate a negative number. Push
173 * a 0 to indicate a positive one */
174 if (!asn1_write_uint8(data
, 0))
180 return asn1_write_uint8(data
, lowest
);
183 /* write an Integer without the tag framing. Needed for example for the LDAP
184 * Abandon Operation */
186 bool asn1_write_implicit_Integer(struct asn1_data
*data
, int i
)
189 /* -1 is special as it consists of all-0xff bytes. In
190 push_int_bigendian this is the only case that is not
191 properly handled, as all 0xff bytes would be handled as
192 leading ones to be ignored. */
193 return asn1_write_uint8(data
, 0xff);
195 return push_int_bigendian(data
, i
, i
<0);
200 /* write an integer */
201 bool asn1_write_Integer(struct asn1_data
*data
, int i
)
203 if (!asn1_push_tag(data
, ASN1_INTEGER
)) return false;
204 if (!asn1_write_implicit_Integer(data
, i
)) return false;
205 return asn1_pop_tag(data
);
208 bool ber_write_OID_String(DATA_BLOB
*blob
, const char *OID
)
211 const char *p
= (const char *)OID
;
215 v
= strtoul(p
, &newp
, 10);
216 if (newp
[0] != '.') return false;
219 v2
= strtoul(p
, &newp
, 10);
220 if (newp
[0] != '.') return false;
223 /*the ber representation can't use more space then the string one */
224 *blob
= data_blob(NULL
, strlen(OID
));
225 if (!blob
->data
) return false;
227 blob
->data
[0] = 40*v
+ v2
;
231 v
= strtoul(p
, &newp
, 10);
232 if (newp
[0] == '.') {
234 } else if (newp
[0] == '\0') {
237 data_blob_free(blob
);
240 if (v
>= (1<<28)) blob
->data
[i
++] = (0x80 | ((v
>>28)&0x7f));
241 if (v
>= (1<<21)) blob
->data
[i
++] = (0x80 | ((v
>>21)&0x7f));
242 if (v
>= (1<<14)) blob
->data
[i
++] = (0x80 | ((v
>>14)&0x7f));
243 if (v
>= (1<<7)) blob
->data
[i
++] = (0x80 | ((v
>>7)&0x7f));
244 blob
->data
[i
++] = (v
&0x7f);
252 /* write an object ID to a ASN1 buffer */
253 bool asn1_write_OID(struct asn1_data
*data
, const char *OID
)
257 if (!asn1_push_tag(data
, ASN1_OID
)) return false;
259 if (!ber_write_OID_String(&blob
, OID
)) {
260 data
->has_error
= true;
264 if (!asn1_write(data
, blob
.data
, blob
.length
)) {
265 data
->has_error
= true;
268 data_blob_free(&blob
);
269 return asn1_pop_tag(data
);
272 /* write an octet string */
273 bool asn1_write_OctetString(struct asn1_data
*data
, const void *p
, size_t length
)
275 asn1_push_tag(data
, ASN1_OCTET_STRING
);
276 asn1_write(data
, p
, length
);
278 return !data
->has_error
;
281 /* write a LDAP string */
282 bool asn1_write_LDAPString(struct asn1_data
*data
, const char *s
)
284 asn1_write(data
, s
, strlen(s
));
285 return !data
->has_error
;
288 /* write a LDAP string from a DATA_BLOB */
289 bool asn1_write_DATA_BLOB_LDAPString(struct asn1_data
*data
, const DATA_BLOB
*s
)
291 asn1_write(data
, s
->data
, s
->length
);
292 return !data
->has_error
;
295 /* write a general string */
296 bool asn1_write_GeneralString(struct asn1_data
*data
, const char *s
)
298 asn1_push_tag(data
, ASN1_GENERAL_STRING
);
299 asn1_write_LDAPString(data
, s
);
301 return !data
->has_error
;
304 bool asn1_write_ContextSimple(struct asn1_data
*data
, uint8_t num
, DATA_BLOB
*blob
)
306 asn1_push_tag(data
, ASN1_CONTEXT_SIMPLE(num
));
307 asn1_write(data
, blob
->data
, blob
->length
);
309 return !data
->has_error
;
312 /* write a BOOLEAN */
313 bool asn1_write_BOOLEAN(struct asn1_data
*data
, bool v
)
315 asn1_push_tag(data
, ASN1_BOOLEAN
);
316 asn1_write_uint8(data
, v
? 0xFF : 0);
318 return !data
->has_error
;
321 bool asn1_read_BOOLEAN(struct asn1_data
*data
, bool *v
)
324 asn1_start_tag(data
, ASN1_BOOLEAN
);
325 asn1_read_uint8(data
, &tmp
);
332 return !data
->has_error
;
335 /* write a BOOLEAN in a simple context */
336 bool asn1_write_BOOLEAN_context(struct asn1_data
*data
, bool v
, int context
)
338 asn1_push_tag(data
, ASN1_CONTEXT_SIMPLE(context
));
339 asn1_write_uint8(data
, v
? 0xFF : 0);
341 return !data
->has_error
;
344 bool asn1_read_BOOLEAN_context(struct asn1_data
*data
, bool *v
, int context
)
347 asn1_start_tag(data
, ASN1_CONTEXT_SIMPLE(context
));
348 asn1_read_uint8(data
, &tmp
);
355 return !data
->has_error
;
358 /* check a BOOLEAN */
359 bool asn1_check_BOOLEAN(struct asn1_data
*data
, bool v
)
363 asn1_read_uint8(data
, &b
);
364 if (b
!= ASN1_BOOLEAN
) {
365 data
->has_error
= true;
368 asn1_read_uint8(data
, &b
);
370 data
->has_error
= true;
373 return !data
->has_error
;
377 /* load a struct asn1_data structure with a lump of data, ready to be parsed */
378 bool asn1_load(struct asn1_data
*data
, DATA_BLOB blob
)
381 data
->data
= (uint8_t *)talloc_memdup(data
, blob
.data
, blob
.length
);
383 data
->has_error
= true;
386 data
->length
= blob
.length
;
390 /* Peek into an ASN1 buffer, not advancing the pointer */
391 bool asn1_peek(struct asn1_data
*data
, void *p
, int len
)
396 if (len
< 0 || data
->ofs
+ len
< data
->ofs
|| data
->ofs
+ len
< len
)
399 if (data
->ofs
+ len
> data
->length
) {
400 /* we need to mark the buffer as consumed, so the caller knows
401 this was an out of data error, and not a decode error */
402 data
->ofs
= data
->length
;
406 memcpy(p
, data
->data
+ data
->ofs
, len
);
410 /* read from a ASN1 buffer, advancing the buffer pointer */
411 bool asn1_read(struct asn1_data
*data
, void *p
, int len
)
413 if (!asn1_peek(data
, p
, len
)) {
414 data
->has_error
= true;
422 /* read a uint8_t from a ASN1 buffer */
423 bool asn1_read_uint8(struct asn1_data
*data
, uint8_t *v
)
425 return asn1_read(data
, v
, 1);
428 bool asn1_peek_uint8(struct asn1_data
*data
, uint8_t *v
)
430 return asn1_peek(data
, v
, 1);
433 bool asn1_peek_tag(struct asn1_data
*data
, uint8_t tag
)
437 if (asn1_tag_remaining(data
) <= 0) {
441 if (!asn1_peek_uint8(data
, &b
))
447 /* start reading a nested asn1 structure */
448 bool asn1_start_tag(struct asn1_data
*data
, uint8_t tag
)
451 struct nesting
*nesting
;
453 if (!asn1_read_uint8(data
, &b
))
457 data
->has_error
= true;
460 nesting
= talloc(data
, struct nesting
);
462 data
->has_error
= true;
466 if (!asn1_read_uint8(data
, &b
)) {
472 if (!asn1_read_uint8(data
, &b
))
476 if (!asn1_read_uint8(data
, &b
))
478 nesting
->taglen
= (nesting
->taglen
<< 8) | b
;
484 nesting
->start
= data
->ofs
;
485 nesting
->next
= data
->nesting
;
486 data
->nesting
= nesting
;
487 if (asn1_tag_remaining(data
) == -1) {
490 return !data
->has_error
;
493 /* stop reading a tag */
494 bool asn1_end_tag(struct asn1_data
*data
)
496 struct nesting
*nesting
;
498 /* make sure we read it all */
499 if (asn1_tag_remaining(data
) != 0) {
500 data
->has_error
= true;
504 nesting
= data
->nesting
;
507 data
->has_error
= true;
511 data
->nesting
= nesting
->next
;
512 talloc_free(nesting
);
516 /* work out how many bytes are left in this nested tag */
517 int asn1_tag_remaining(struct asn1_data
*data
)
520 if (data
->has_error
) {
524 if (!data
->nesting
) {
525 data
->has_error
= true;
528 remaining
= data
->nesting
->taglen
- (data
->ofs
- data
->nesting
->start
);
529 if (remaining
> (data
->length
- data
->ofs
)) {
530 data
->has_error
= true;
536 /* read an object ID from a data blob */
537 bool ber_read_OID_String(TALLOC_CTX
*mem_ctx
, DATA_BLOB blob
, const char **OID
)
542 char *tmp_oid
= NULL
;
544 if (blob
.length
< 2) return false;
548 tmp_oid
= talloc_asprintf(mem_ctx
, "%u", b
[0]/40);
549 if (!tmp_oid
) goto nomem
;
550 tmp_oid
= talloc_asprintf_append_buffer(tmp_oid
, ".%u", b
[0]%40);
551 if (!tmp_oid
) goto nomem
;
553 for(i
= 1, v
= 0; i
< blob
.length
; i
++) {
554 v
= (v
<<7) | (b
[i
]&0x7f);
555 if ( ! (b
[i
] & 0x80)) {
556 tmp_oid
= talloc_asprintf_append_buffer(tmp_oid
, ".%u", v
);
559 if (!tmp_oid
) goto nomem
;
563 talloc_free(tmp_oid
);
574 /* read an object ID from a ASN1 buffer */
575 bool asn1_read_OID(struct asn1_data
*data
, TALLOC_CTX
*mem_ctx
, const char **OID
)
580 if (!asn1_start_tag(data
, ASN1_OID
)) return false;
582 len
= asn1_tag_remaining(data
);
584 data
->has_error
= true;
588 blob
= data_blob(NULL
, len
);
590 data
->has_error
= true;
594 asn1_read(data
, blob
.data
, len
);
596 if (data
->has_error
) {
597 data_blob_free(&blob
);
601 if (!ber_read_OID_String(mem_ctx
, blob
, OID
)) {
602 data
->has_error
= true;
603 data_blob_free(&blob
);
607 data_blob_free(&blob
);
611 /* check that the next object ID is correct */
612 bool asn1_check_OID(struct asn1_data
*data
, const char *OID
)
616 if (!asn1_read_OID(data
, data
, &id
)) return false;
618 if (strcmp(id
, OID
) != 0) {
619 talloc_free(discard_const(id
));
620 data
->has_error
= true;
623 talloc_free(discard_const(id
));
627 /* read a LDAPString from a ASN1 buffer */
628 bool asn1_read_LDAPString(struct asn1_data
*data
, TALLOC_CTX
*mem_ctx
, char **s
)
631 len
= asn1_tag_remaining(data
);
633 data
->has_error
= true;
636 *s
= talloc_array(mem_ctx
, char, len
+1);
638 data
->has_error
= true;
641 asn1_read(data
, *s
, len
);
643 return !data
->has_error
;
647 /* read a GeneralString from a ASN1 buffer */
648 bool asn1_read_GeneralString(struct asn1_data
*data
, TALLOC_CTX
*mem_ctx
, char **s
)
650 if (!asn1_start_tag(data
, ASN1_GENERAL_STRING
)) return false;
651 if (!asn1_read_LDAPString(data
, mem_ctx
, s
)) return false;
652 return asn1_end_tag(data
);
656 /* read a octet string blob */
657 bool asn1_read_OctetString(struct asn1_data
*data
, TALLOC_CTX
*mem_ctx
, DATA_BLOB
*blob
)
661 if (!asn1_start_tag(data
, ASN1_OCTET_STRING
)) return false;
662 len
= asn1_tag_remaining(data
);
664 data
->has_error
= true;
667 *blob
= data_blob_talloc(mem_ctx
, NULL
, len
+1);
669 data
->has_error
= true;
672 asn1_read(data
, blob
->data
, len
);
677 if (data
->has_error
) {
678 data_blob_free(blob
);
679 *blob
= data_blob_null
;
685 bool asn1_read_ContextSimple(struct asn1_data
*data
, uint8_t num
, DATA_BLOB
*blob
)
689 if (!asn1_start_tag(data
, ASN1_CONTEXT_SIMPLE(num
))) return false;
690 len
= asn1_tag_remaining(data
);
692 data
->has_error
= true;
695 *blob
= data_blob(NULL
, len
);
696 if ((len
!= 0) && (!blob
->data
)) {
697 data
->has_error
= true;
700 asn1_read(data
, blob
->data
, len
);
702 return !data
->has_error
;
705 /* read an integer without tag*/
706 bool asn1_read_implicit_Integer(struct asn1_data
*data
, int *i
)
711 while (!data
->has_error
&& asn1_tag_remaining(data
)>0) {
712 if (!asn1_read_uint8(data
, &b
)) return false;
715 return !data
->has_error
;
719 /* read an integer */
720 bool asn1_read_Integer(struct asn1_data
*data
, int *i
)
724 if (!asn1_start_tag(data
, ASN1_INTEGER
)) return false;
725 if (!asn1_read_implicit_Integer(data
, i
)) return false;
726 return asn1_end_tag(data
);
729 /* read an integer */
730 bool asn1_read_enumerated(struct asn1_data
*data
, int *v
)
734 if (!asn1_start_tag(data
, ASN1_ENUMERATED
)) return false;
735 while (!data
->has_error
&& asn1_tag_remaining(data
)>0) {
737 asn1_read_uint8(data
, &b
);
740 return asn1_end_tag(data
);
743 /* check a enumerated value is correct */
744 bool asn1_check_enumerated(struct asn1_data
*data
, int v
)
747 if (!asn1_start_tag(data
, ASN1_ENUMERATED
)) return false;
748 asn1_read_uint8(data
, &b
);
752 data
->has_error
= false;
754 return !data
->has_error
;
757 /* write an enumerated value to the stream */
758 bool asn1_write_enumerated(struct asn1_data
*data
, uint8_t v
)
760 if (!asn1_push_tag(data
, ASN1_ENUMERATED
)) return false;
761 asn1_write_uint8(data
, v
);
763 return !data
->has_error
;
767 check if a ASN.1 blob is a full tag
769 NTSTATUS
asn1_full_tag(DATA_BLOB blob
, uint8_t tag
, size_t *packet_size
)
771 struct asn1_data
*asn1
= asn1_init(NULL
);
774 NT_STATUS_HAVE_NO_MEMORY(asn1
);
776 asn1
->data
= blob
.data
;
777 asn1
->length
= blob
.length
;
778 asn1_start_tag(asn1
, tag
);
779 if (asn1
->has_error
) {
781 return STATUS_MORE_ENTRIES
;
783 size
= asn1_tag_remaining(asn1
) + asn1
->ofs
;
787 if (size
> blob
.length
) {
788 return STATUS_MORE_ENTRIES
;