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 /* write a BIT STRING */
209 bool asn1_write_BitString(struct asn1_data
*data
, const void *p
, size_t length
, uint8_t padding
)
211 if (!asn1_push_tag(data
, ASN1_BIT_STRING
)) return false;
212 if (!asn1_write_uint8(data
, padding
)) return false;
213 if (!asn1_write(data
, p
, length
)) return false;
214 return asn1_pop_tag(data
);
217 bool ber_write_OID_String(DATA_BLOB
*blob
, const char *OID
)
220 const char *p
= (const char *)OID
;
224 v
= strtoul(p
, &newp
, 10);
225 if (newp
[0] != '.') return false;
228 v2
= strtoul(p
, &newp
, 10);
229 if (newp
[0] != '.') return false;
232 /*the ber representation can't use more space then the string one */
233 *blob
= data_blob(NULL
, strlen(OID
));
234 if (!blob
->data
) return false;
236 blob
->data
[0] = 40*v
+ v2
;
240 v
= strtoul(p
, &newp
, 10);
241 if (newp
[0] == '.') {
243 } else if (newp
[0] == '\0') {
246 data_blob_free(blob
);
249 if (v
>= (1<<28)) blob
->data
[i
++] = (0x80 | ((v
>>28)&0x7f));
250 if (v
>= (1<<21)) blob
->data
[i
++] = (0x80 | ((v
>>21)&0x7f));
251 if (v
>= (1<<14)) blob
->data
[i
++] = (0x80 | ((v
>>14)&0x7f));
252 if (v
>= (1<<7)) blob
->data
[i
++] = (0x80 | ((v
>>7)&0x7f));
253 blob
->data
[i
++] = (v
&0x7f);
261 /* write an object ID to a ASN1 buffer */
262 bool asn1_write_OID(struct asn1_data
*data
, const char *OID
)
266 if (!asn1_push_tag(data
, ASN1_OID
)) return false;
268 if (!ber_write_OID_String(&blob
, OID
)) {
269 data
->has_error
= true;
273 if (!asn1_write(data
, blob
.data
, blob
.length
)) {
274 data_blob_free(&blob
);
275 data
->has_error
= true;
278 data_blob_free(&blob
);
279 return asn1_pop_tag(data
);
282 /* write an octet string */
283 bool asn1_write_OctetString(struct asn1_data
*data
, const void *p
, size_t length
)
285 asn1_push_tag(data
, ASN1_OCTET_STRING
);
286 asn1_write(data
, p
, length
);
288 return !data
->has_error
;
291 /* write a LDAP string */
292 bool asn1_write_LDAPString(struct asn1_data
*data
, const char *s
)
294 asn1_write(data
, s
, strlen(s
));
295 return !data
->has_error
;
298 /* write a LDAP string from a DATA_BLOB */
299 bool asn1_write_DATA_BLOB_LDAPString(struct asn1_data
*data
, const DATA_BLOB
*s
)
301 asn1_write(data
, s
->data
, s
->length
);
302 return !data
->has_error
;
305 /* write a general string */
306 bool asn1_write_GeneralString(struct asn1_data
*data
, const char *s
)
308 asn1_push_tag(data
, ASN1_GENERAL_STRING
);
309 asn1_write_LDAPString(data
, s
);
311 return !data
->has_error
;
314 bool asn1_write_ContextSimple(struct asn1_data
*data
, uint8_t num
, DATA_BLOB
*blob
)
316 asn1_push_tag(data
, ASN1_CONTEXT_SIMPLE(num
));
317 asn1_write(data
, blob
->data
, blob
->length
);
319 return !data
->has_error
;
322 /* write a BOOLEAN */
323 bool asn1_write_BOOLEAN(struct asn1_data
*data
, bool v
)
325 asn1_push_tag(data
, ASN1_BOOLEAN
);
326 asn1_write_uint8(data
, v
? 0xFF : 0);
328 return !data
->has_error
;
331 bool asn1_read_BOOLEAN(struct asn1_data
*data
, bool *v
)
334 asn1_start_tag(data
, ASN1_BOOLEAN
);
335 asn1_read_uint8(data
, &tmp
);
342 return !data
->has_error
;
345 /* write a BOOLEAN in a simple context */
346 bool asn1_write_BOOLEAN_context(struct asn1_data
*data
, bool v
, int context
)
348 asn1_push_tag(data
, ASN1_CONTEXT_SIMPLE(context
));
349 asn1_write_uint8(data
, v
? 0xFF : 0);
351 return !data
->has_error
;
354 bool asn1_read_BOOLEAN_context(struct asn1_data
*data
, bool *v
, int context
)
357 asn1_start_tag(data
, ASN1_CONTEXT_SIMPLE(context
));
358 asn1_read_uint8(data
, &tmp
);
365 return !data
->has_error
;
368 /* check a BOOLEAN */
369 bool asn1_check_BOOLEAN(struct asn1_data
*data
, bool v
)
373 asn1_read_uint8(data
, &b
);
374 if (b
!= ASN1_BOOLEAN
) {
375 data
->has_error
= true;
378 asn1_read_uint8(data
, &b
);
380 data
->has_error
= true;
383 return !data
->has_error
;
387 /* load a struct asn1_data structure with a lump of data, ready to be parsed */
388 bool asn1_load(struct asn1_data
*data
, DATA_BLOB blob
)
391 data
->data
= (uint8_t *)talloc_memdup(data
, blob
.data
, blob
.length
);
393 data
->has_error
= true;
396 data
->length
= blob
.length
;
400 /* Peek into an ASN1 buffer, not advancing the pointer */
401 bool asn1_peek(struct asn1_data
*data
, void *p
, int len
)
406 if (len
< 0 || data
->ofs
+ len
< data
->ofs
|| data
->ofs
+ len
< len
)
409 if (data
->ofs
+ len
> data
->length
) {
410 /* we need to mark the buffer as consumed, so the caller knows
411 this was an out of data error, and not a decode error */
412 data
->ofs
= data
->length
;
416 memcpy(p
, data
->data
+ data
->ofs
, len
);
420 /* read from a ASN1 buffer, advancing the buffer pointer */
421 bool asn1_read(struct asn1_data
*data
, void *p
, int len
)
423 if (!asn1_peek(data
, p
, len
)) {
424 data
->has_error
= true;
432 /* read a uint8_t from a ASN1 buffer */
433 bool asn1_read_uint8(struct asn1_data
*data
, uint8_t *v
)
435 return asn1_read(data
, v
, 1);
438 bool asn1_peek_uint8(struct asn1_data
*data
, uint8_t *v
)
440 return asn1_peek(data
, v
, 1);
443 bool asn1_peek_tag(struct asn1_data
*data
, uint8_t tag
)
447 if (asn1_tag_remaining(data
) <= 0) {
451 if (!asn1_peek_uint8(data
, &b
))
457 /* start reading a nested asn1 structure */
458 bool asn1_start_tag(struct asn1_data
*data
, uint8_t tag
)
461 struct nesting
*nesting
;
463 if (!asn1_read_uint8(data
, &b
))
467 data
->has_error
= true;
470 nesting
= talloc(data
, struct nesting
);
472 data
->has_error
= true;
476 if (!asn1_read_uint8(data
, &b
)) {
482 if (!asn1_read_uint8(data
, &b
))
486 if (!asn1_read_uint8(data
, &b
))
488 nesting
->taglen
= (nesting
->taglen
<< 8) | b
;
494 nesting
->start
= data
->ofs
;
495 nesting
->next
= data
->nesting
;
496 data
->nesting
= nesting
;
497 if (asn1_tag_remaining(data
) == -1) {
500 return !data
->has_error
;
503 /* stop reading a tag */
504 bool asn1_end_tag(struct asn1_data
*data
)
506 struct nesting
*nesting
;
508 /* make sure we read it all */
509 if (asn1_tag_remaining(data
) != 0) {
510 data
->has_error
= true;
514 nesting
= data
->nesting
;
517 data
->has_error
= true;
521 data
->nesting
= nesting
->next
;
522 talloc_free(nesting
);
526 /* work out how many bytes are left in this nested tag */
527 int asn1_tag_remaining(struct asn1_data
*data
)
530 if (data
->has_error
) {
534 if (!data
->nesting
) {
535 data
->has_error
= true;
538 remaining
= data
->nesting
->taglen
- (data
->ofs
- data
->nesting
->start
);
539 if (remaining
> (data
->length
- data
->ofs
)) {
540 data
->has_error
= true;
546 /* read an object ID from a data blob */
547 bool ber_read_OID_String(TALLOC_CTX
*mem_ctx
, DATA_BLOB blob
, const char **OID
)
552 char *tmp_oid
= NULL
;
554 if (blob
.length
< 2) return false;
558 tmp_oid
= talloc_asprintf(mem_ctx
, "%u", b
[0]/40);
559 if (!tmp_oid
) goto nomem
;
560 tmp_oid
= talloc_asprintf_append_buffer(tmp_oid
, ".%u", b
[0]%40);
561 if (!tmp_oid
) goto nomem
;
563 for(i
= 1, v
= 0; i
< blob
.length
; i
++) {
564 v
= (v
<<7) | (b
[i
]&0x7f);
565 if ( ! (b
[i
] & 0x80)) {
566 tmp_oid
= talloc_asprintf_append_buffer(tmp_oid
, ".%u", v
);
569 if (!tmp_oid
) goto nomem
;
573 talloc_free(tmp_oid
);
584 /* read an object ID from a ASN1 buffer */
585 bool asn1_read_OID(struct asn1_data
*data
, TALLOC_CTX
*mem_ctx
, const char **OID
)
590 if (!asn1_start_tag(data
, ASN1_OID
)) return false;
592 len
= asn1_tag_remaining(data
);
594 data
->has_error
= true;
598 blob
= data_blob(NULL
, len
);
600 data
->has_error
= true;
604 asn1_read(data
, blob
.data
, len
);
606 if (data
->has_error
) {
607 data_blob_free(&blob
);
611 if (!ber_read_OID_String(mem_ctx
, blob
, OID
)) {
612 data
->has_error
= true;
613 data_blob_free(&blob
);
617 data_blob_free(&blob
);
621 /* check that the next object ID is correct */
622 bool asn1_check_OID(struct asn1_data
*data
, const char *OID
)
626 if (!asn1_read_OID(data
, data
, &id
)) return false;
628 if (strcmp(id
, OID
) != 0) {
629 talloc_free(discard_const(id
));
630 data
->has_error
= true;
633 talloc_free(discard_const(id
));
637 /* read a LDAPString from a ASN1 buffer */
638 bool asn1_read_LDAPString(struct asn1_data
*data
, TALLOC_CTX
*mem_ctx
, char **s
)
641 len
= asn1_tag_remaining(data
);
643 data
->has_error
= true;
646 *s
= talloc_array(mem_ctx
, char, len
+1);
648 data
->has_error
= true;
651 asn1_read(data
, *s
, len
);
653 return !data
->has_error
;
657 /* read a GeneralString from a ASN1 buffer */
658 bool asn1_read_GeneralString(struct asn1_data
*data
, TALLOC_CTX
*mem_ctx
, char **s
)
660 if (!asn1_start_tag(data
, ASN1_GENERAL_STRING
)) return false;
661 if (!asn1_read_LDAPString(data
, mem_ctx
, s
)) return false;
662 return asn1_end_tag(data
);
666 /* read a octet string blob */
667 bool asn1_read_OctetString(struct asn1_data
*data
, TALLOC_CTX
*mem_ctx
, DATA_BLOB
*blob
)
671 if (!asn1_start_tag(data
, ASN1_OCTET_STRING
)) return false;
672 len
= asn1_tag_remaining(data
);
674 data
->has_error
= true;
677 *blob
= data_blob_talloc(mem_ctx
, NULL
, len
+1);
679 data
->has_error
= true;
682 asn1_read(data
, blob
->data
, len
);
687 if (data
->has_error
) {
688 data_blob_free(blob
);
689 *blob
= data_blob_null
;
695 bool asn1_read_ContextSimple(struct asn1_data
*data
, uint8_t num
, DATA_BLOB
*blob
)
699 if (!asn1_start_tag(data
, ASN1_CONTEXT_SIMPLE(num
))) return false;
700 len
= asn1_tag_remaining(data
);
702 data
->has_error
= true;
705 *blob
= data_blob(NULL
, len
);
706 if ((len
!= 0) && (!blob
->data
)) {
707 data
->has_error
= true;
710 asn1_read(data
, blob
->data
, len
);
712 return !data
->has_error
;
715 /* read an integer without tag*/
716 bool asn1_read_implicit_Integer(struct asn1_data
*data
, int *i
)
721 while (!data
->has_error
&& asn1_tag_remaining(data
)>0) {
722 if (!asn1_read_uint8(data
, &b
)) return false;
725 return !data
->has_error
;
729 /* read an integer */
730 bool asn1_read_Integer(struct asn1_data
*data
, int *i
)
734 if (!asn1_start_tag(data
, ASN1_INTEGER
)) return false;
735 if (!asn1_read_implicit_Integer(data
, i
)) return false;
736 return asn1_end_tag(data
);
739 /* read a BIT STRING */
740 bool asn1_read_BitString(struct asn1_data
*data
, TALLOC_CTX
*mem_ctx
, DATA_BLOB
*blob
, uint8_t *padding
)
744 if (!asn1_start_tag(data
, ASN1_BIT_STRING
)) return false;
745 len
= asn1_tag_remaining(data
);
747 data
->has_error
= true;
750 if (!asn1_read_uint8(data
, padding
)) return false;
752 *blob
= data_blob_talloc(mem_ctx
, NULL
, len
);
754 data
->has_error
= true;
757 if (asn1_read(data
, blob
->data
, len
- 1)) {
763 if (data
->has_error
) {
764 data_blob_free(blob
);
765 *blob
= data_blob_null
;
772 /* read an integer */
773 bool asn1_read_enumerated(struct asn1_data
*data
, int *v
)
777 if (!asn1_start_tag(data
, ASN1_ENUMERATED
)) return false;
778 while (!data
->has_error
&& asn1_tag_remaining(data
)>0) {
780 asn1_read_uint8(data
, &b
);
783 return asn1_end_tag(data
);
786 /* check a enumerated value is correct */
787 bool asn1_check_enumerated(struct asn1_data
*data
, int v
)
790 if (!asn1_start_tag(data
, ASN1_ENUMERATED
)) return false;
791 asn1_read_uint8(data
, &b
);
795 data
->has_error
= false;
797 return !data
->has_error
;
800 /* write an enumerated value to the stream */
801 bool asn1_write_enumerated(struct asn1_data
*data
, uint8_t v
)
803 if (!asn1_push_tag(data
, ASN1_ENUMERATED
)) return false;
804 asn1_write_uint8(data
, v
);
806 return !data
->has_error
;
810 Get us the data just written without copying
812 bool asn1_blob(const struct asn1_data
*asn1
, DATA_BLOB
*blob
)
814 if (asn1
->has_error
) {
817 if (asn1
->nesting
!= NULL
) {
820 blob
->data
= asn1
->data
;
821 blob
->length
= asn1
->length
;
826 Fill in an asn1 struct without making a copy
828 void asn1_load_nocopy(struct asn1_data
*data
, uint8_t *buf
, size_t len
)
836 check if a ASN.1 blob is a full tag
838 NTSTATUS
asn1_full_tag(DATA_BLOB blob
, uint8_t tag
, size_t *packet_size
)
840 struct asn1_data
*asn1
= asn1_init(NULL
);
843 NT_STATUS_HAVE_NO_MEMORY(asn1
);
845 asn1
->data
= blob
.data
;
846 asn1
->length
= blob
.length
;
847 asn1_start_tag(asn1
, tag
);
848 if (asn1
->has_error
) {
850 return STATUS_MORE_ENTRIES
;
852 size
= asn1_tag_remaining(asn1
) + asn1
->ofs
;
856 if (size
> blob
.length
) {
857 return STATUS_MORE_ENTRIES
;