*/
#include "includes.h"
+#include "asn_1.h"
/* free an asn1 structure */
-void asn1_free(ASN1_DATA *data)
+void asn1_free(struct asn1_data *data)
{
talloc_free(data->data);
}
/* write to the ASN1 buffer, advancing the buffer pointer */
-BOOL asn1_write(ASN1_DATA *data, const void *p, int len)
+BOOL asn1_write(struct asn1_data *data, const void *p, int len)
{
if (data->has_error) return False;
if (data->length < data->ofs+len) {
uint8_t *newp;
- newp = talloc_realloc(NULL, data->data, data->ofs+len);
+ newp = talloc_realloc(NULL, data->data, uint8_t, data->ofs+len);
if (!newp) {
asn1_free(data);
data->has_error = True;
}
/* useful fn for writing a uint8_t */
-BOOL asn1_write_uint8(ASN1_DATA *data, uint8_t v)
+BOOL asn1_write_uint8(struct asn1_data *data, uint8_t v)
{
return asn1_write(data, &v, 1);
}
/* push a tag onto the asn1 data buffer. Used for nested structures */
-BOOL asn1_push_tag(ASN1_DATA *data, uint8_t tag)
+BOOL asn1_push_tag(struct asn1_data *data, uint8_t tag)
{
struct nesting *nesting;
asn1_write_uint8(data, tag);
- nesting = talloc_p(NULL, struct nesting);
+ nesting = talloc(NULL, struct nesting);
if (!nesting) {
data->has_error = True;
return False;
}
/* pop a tag */
-BOOL asn1_pop_tag(ASN1_DATA *data)
+BOOL asn1_pop_tag(struct asn1_data *data)
{
struct nesting *nesting;
size_t len;
/* yes, this is ugly. We don't know in advance how many bytes the length
of a tag will take, so we assumed 1 byte. If we were wrong then we
need to correct our mistake */
- if (len > 255) {
+ if (len > 0xFFFF) {
+ data->data[nesting->start] = 0x83;
+ if (!asn1_write_uint8(data, 0)) return False;
+ if (!asn1_write_uint8(data, 0)) return False;
+ if (!asn1_write_uint8(data, 0)) return False;
+ memmove(data->data+nesting->start+4, data->data+nesting->start+1, len);
+ data->data[nesting->start+1] = (len>>16) & 0xFF;
+ data->data[nesting->start+2] = (len>>8) & 0xFF;
+ data->data[nesting->start+3] = len&0xff;
+ } else if (len > 255) {
data->data[nesting->start] = 0x82;
if (!asn1_write_uint8(data, 0)) return False;
if (!asn1_write_uint8(data, 0)) return False;
/* "i" is the one's complement representation, as is the normal result of an
* implicit signed->unsigned conversion */
-static BOOL push_int_bigendian(ASN1_DATA *data, unsigned int i, BOOL negative)
+static BOOL push_int_bigendian(struct asn1_data *data, unsigned int i, BOOL negative)
{
uint8_t lowest = i & 0xFF;
/* write an Integer without the tag framing. Needed for example for the LDAP
* Abandon Operation */
-BOOL asn1_write_implicit_Integer(ASN1_DATA *data, int i)
+BOOL asn1_write_implicit_Integer(struct asn1_data *data, int i)
{
if (i == -1) {
/* -1 is special as it consists of all-0xff bytes. In
/* write an integer */
-BOOL asn1_write_Integer(ASN1_DATA *data, int i)
+BOOL asn1_write_Integer(struct asn1_data *data, int i)
{
if (!asn1_push_tag(data, ASN1_INTEGER)) return False;
if (!asn1_write_implicit_Integer(data, i)) return False;
}
/* write an object ID to a ASN1 buffer */
-BOOL asn1_write_OID(ASN1_DATA *data, const char *OID)
+BOOL asn1_write_OID(struct asn1_data *data, const char *OID)
{
uint_t v, v2;
const char *p = (const char *)OID;
}
/* write an octet string */
-BOOL asn1_write_OctetString(ASN1_DATA *data, const void *p, size_t length)
+BOOL asn1_write_OctetString(struct asn1_data *data, const void *p, size_t length)
{
asn1_push_tag(data, ASN1_OCTET_STRING);
asn1_write(data, p, length);
return !data->has_error;
}
+/* write a LDAP string */
+BOOL asn1_write_LDAPString(struct asn1_data *data, const char *s)
+{
+ asn1_write(data, s, strlen(s));
+ return !data->has_error;
+}
+
/* write a general string */
-BOOL asn1_write_GeneralString(ASN1_DATA *data, const char *s)
+BOOL asn1_write_GeneralString(struct asn1_data *data, const char *s)
{
asn1_push_tag(data, ASN1_GENERAL_STRING);
- asn1_write(data, s, strlen(s));
+ asn1_write_LDAPString(data, s);
asn1_pop_tag(data);
return !data->has_error;
}
-BOOL asn1_write_ContextSimple(ASN1_DATA *data, uint8_t num, DATA_BLOB *blob)
+BOOL asn1_write_ContextSimple(struct asn1_data *data, uint8_t num, DATA_BLOB *blob)
{
asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(num));
asn1_write(data, blob->data, blob->length);
}
/* write a BOOLEAN */
-BOOL asn1_write_BOOLEAN(ASN1_DATA *data, BOOL v)
+BOOL asn1_write_BOOLEAN(struct asn1_data *data, BOOL v)
{
asn1_push_tag(data, ASN1_BOOLEAN);
asn1_write_uint8(data, v ? 0xFF : 0);
return !data->has_error;
}
-BOOL asn1_read_BOOLEAN(ASN1_DATA *data, BOOL *v)
+BOOL asn1_read_BOOLEAN(struct asn1_data *data, BOOL *v)
{
+ uint8_t tmp = 0;
asn1_start_tag(data, ASN1_BOOLEAN);
- asn1_read_uint8(data, (uint8 *)v);
+ asn1_read_uint8(data, &tmp);
+ if (tmp == 0xFF) {
+ *v = True;
+ } else {
+ *v = False;
+ }
asn1_end_tag(data);
return !data->has_error;
}
/* check a BOOLEAN */
-BOOL asn1_check_BOOLEAN(ASN1_DATA *data, BOOL v)
+BOOL asn1_check_BOOLEAN(struct asn1_data *data, BOOL v)
{
uint8_t b = 0;
}
-/* load a ASN1_DATA structure with a lump of data, ready to be parsed */
-BOOL asn1_load(ASN1_DATA *data, DATA_BLOB blob)
+/* load a struct asn1_data structure with a lump of data, ready to be parsed */
+BOOL asn1_load(struct asn1_data *data, DATA_BLOB blob)
{
ZERO_STRUCTP(data);
data->data = talloc_memdup(NULL, blob.data, blob.length);
}
/* Peek into an ASN1 buffer, not advancing the pointer */
-BOOL asn1_peek(ASN1_DATA *data, void *p, int len)
+BOOL asn1_peek(struct asn1_data *data, void *p, int len)
{
if (len < 0 || data->ofs + len < data->ofs || data->ofs + len < len)
return False;
- if (data->ofs + len > data->length)
+ if (data->ofs + len > data->length) {
+ /* we need to mark the buffer as consumed, so the caller knows
+ this was an out of data error, and not a decode error */
+ data->ofs = data->length;
return False;
+ }
memcpy(p, data->data + data->ofs, len);
return True;
}
/* read from a ASN1 buffer, advancing the buffer pointer */
-BOOL asn1_read(ASN1_DATA *data, void *p, int len)
+BOOL asn1_read(struct asn1_data *data, void *p, int len)
{
if (!asn1_peek(data, p, len)) {
data->has_error = True;
}
/* read a uint8_t from a ASN1 buffer */
-BOOL asn1_read_uint8(ASN1_DATA *data, uint8_t *v)
+BOOL asn1_read_uint8(struct asn1_data *data, uint8_t *v)
{
return asn1_read(data, v, 1);
}
-BOOL asn1_peek_uint8(ASN1_DATA *data, uint8_t *v)
+BOOL asn1_peek_uint8(struct asn1_data *data, uint8_t *v)
{
return asn1_peek(data, v, 1);
}
-BOOL asn1_peek_tag(ASN1_DATA *data, uint8_t tag)
+BOOL asn1_peek_tag(struct asn1_data *data, uint8_t tag)
{
uint8_t b;
}
/* start reading a nested asn1 structure */
-BOOL asn1_start_tag(ASN1_DATA *data, uint8_t tag)
+BOOL asn1_start_tag(struct asn1_data *data, uint8_t tag)
{
uint8_t b;
struct nesting *nesting;
data->has_error = True;
return False;
}
- nesting = talloc_p(NULL, struct nesting);
+ nesting = talloc(NULL, struct nesting);
if (!nesting) {
data->has_error = True;
return False;
return !data->has_error;
}
-static BOOL read_one_uint8(int sock, uint8_t *result, ASN1_DATA *data,
- const struct timeval *endtime)
-{
- if (read_data_until(sock, result, 1, endtime) != 1)
- return False;
-
- return asn1_write(data, result, 1);
-}
-
-/* Read a complete ASN sequence (ie LDAP result) from a socket */
-BOOL asn1_read_sequence_until(int sock, ASN1_DATA *data,
- const struct timeval *endtime)
-{
- uint8_t b;
- size_t len;
- char *buf;
-
- ZERO_STRUCTP(data);
-
- if (!read_one_uint8(sock, &b, data, endtime))
- return False;
-
- if (b != 0x30) {
- data->has_error = True;
- return False;
- }
-
- if (!read_one_uint8(sock, &b, data, endtime))
- return False;
-
- if (b & 0x80) {
- int n = b & 0x7f;
- if (!read_one_uint8(sock, &b, data, endtime))
- return False;
- len = b;
- while (n > 1) {
- if (!read_one_uint8(sock, &b, data, endtime))
- return False;
- len = (len<<8) | b;
- n--;
- }
- } else {
- len = b;
- }
-
- buf = talloc(NULL, len);
- if (buf == NULL)
- return False;
-
- if (read_data_until(sock, buf, len, endtime) != len)
- return False;
-
- if (!asn1_write(data, buf, len))
- return False;
-
- talloc_free(buf);
-
- data->ofs = 0;
-
- return True;
-}
-
-/* Get the length to be expected in buf */
-BOOL asn1_object_length(uint8_t *buf, size_t buf_length,
- uint8_t tag, size_t *result)
-{
- ASN1_DATA data;
-
- /* Fake the asn1_load to avoid the memdup, this is just to be able to
- * re-use the length-reading in asn1_start_tag */
- ZERO_STRUCT(data);
- data.data = buf;
- data.length = buf_length;
- if (!asn1_start_tag(&data, tag))
- return False;
- *result = asn1_tag_remaining(&data)+data.ofs;
- /* We can't use asn1_end_tag here, as we did not consume the complete
- * tag, so asn1_end_tag would flag an error and not free nesting */
- talloc_free(data.nesting);
- return True;
-}
/* stop reading a tag */
-BOOL asn1_end_tag(ASN1_DATA *data)
+BOOL asn1_end_tag(struct asn1_data *data)
{
struct nesting *nesting;
}
/* work out how many bytes are left in this nested tag */
-int asn1_tag_remaining(ASN1_DATA *data)
+int asn1_tag_remaining(struct asn1_data *data)
{
if (!data->nesting) {
data->has_error = True;
}
/* read an object ID from a ASN1 buffer */
-BOOL asn1_read_OID(ASN1_DATA *data, char **OID)
+BOOL asn1_read_OID(struct asn1_data *data, const char **OID)
{
uint8_t b;
char *tmp_oid = NULL;
do {
asn1_read_uint8(data, &b);
v = (v<<7) | (b&0x7f);
- } while (!data->has_error && b & 0x80);
+ } while (!data->has_error && (b & 0x80));
tmp_oid = talloc_asprintf_append(tmp_oid, " %u", v);
}
}
/* check that the next object ID is correct */
-BOOL asn1_check_OID(ASN1_DATA *data, const char *OID)
+BOOL asn1_check_OID(struct asn1_data *data, const char *OID)
{
- char *id;
+ const char *id;
if (!asn1_read_OID(data, &id)) return False;
data->has_error = True;
return False;
}
- talloc_free(id);
+ talloc_free(discard_const(id));
return True;
}
-/* read a GeneralString from a ASN1 buffer */
-BOOL asn1_read_GeneralString(ASN1_DATA *data, char **s)
+/* read a LDAPString from a ASN1 buffer */
+BOOL asn1_read_LDAPString(struct asn1_data *data, char **s)
{
int len;
- if (!asn1_start_tag(data, ASN1_GENERAL_STRING)) return False;
len = asn1_tag_remaining(data);
if (len < 0) {
data->has_error = True;
return False;
}
- *s = talloc(NULL, len+1);
+ *s = talloc_size(NULL, len+1);
if (! *s) {
data->has_error = True;
return False;
}
asn1_read(data, *s, len);
(*s)[len] = 0;
- asn1_end_tag(data);
return !data->has_error;
}
+
+/* read a GeneralString from a ASN1 buffer */
+BOOL asn1_read_GeneralString(struct asn1_data *data, char **s)
+{
+ if (!asn1_start_tag(data, ASN1_GENERAL_STRING)) return False;
+ if (!asn1_read_LDAPString(data, s)) return False;
+ return asn1_end_tag(data);
+}
+
+
/* read a octet string blob */
-BOOL asn1_read_OctetString(ASN1_DATA *data, DATA_BLOB *blob)
+BOOL asn1_read_OctetString(struct asn1_data *data, DATA_BLOB *blob)
{
int len;
ZERO_STRUCTP(blob);
data->has_error = True;
return False;
}
- *blob = data_blob(NULL, len);
+ *blob = data_blob(NULL, len+1);
asn1_read(data, blob->data, len);
asn1_end_tag(data);
+ blob->length--;
+ blob->data[len] = 0;
if (data->has_error) {
data_blob_free(blob);
return True;
}
-BOOL asn1_read_ContextSimple(ASN1_DATA *data, uint8_t num, DATA_BLOB *blob)
+BOOL asn1_read_ContextSimple(struct asn1_data *data, uint8_t num, DATA_BLOB *blob)
{
int len;
ZERO_STRUCTP(blob);
}
/* read an interger without tag*/
-BOOL asn1_read_implicit_Integer(ASN1_DATA *data, int *i)
+BOOL asn1_read_implicit_Integer(struct asn1_data *data, int *i)
{
uint8_t b;
*i = 0;
- while (asn1_tag_remaining(data)>0) {
+ while (!data->has_error && asn1_tag_remaining(data)>0) {
if (!asn1_read_uint8(data, &b)) return False;
*i = (*i << 8) + b;
}
}
/* read an interger */
-BOOL asn1_read_Integer(ASN1_DATA *data, int *i)
+BOOL asn1_read_Integer(struct asn1_data *data, int *i)
{
*i = 0;
if (!asn1_start_tag(data, ASN1_INTEGER)) return False;
if (!asn1_read_implicit_Integer(data, i)) return False;
return asn1_end_tag(data);
-
}
/* read an interger */
-BOOL asn1_read_enumerated(ASN1_DATA *data, int *v)
+BOOL asn1_read_enumerated(struct asn1_data *data, int *v)
{
*v = 0;
if (!asn1_start_tag(data, ASN1_ENUMERATED)) return False;
- while (asn1_tag_remaining(data)>0) {
+ while (!data->has_error && asn1_tag_remaining(data)>0) {
uint8_t b;
asn1_read_uint8(data, &b);
*v = (*v << 8) + b;
}
/* check a enumarted value is correct */
-BOOL asn1_check_enumerated(ASN1_DATA *data, int v)
+BOOL asn1_check_enumerated(struct asn1_data *data, int v)
{
uint8_t b;
if (!asn1_start_tag(data, ASN1_ENUMERATED)) return False;
}
/* write an enumarted value to the stream */
-BOOL asn1_write_enumerated(ASN1_DATA *data, uint8_t v)
+BOOL asn1_write_enumerated(struct asn1_data *data, uint8_t v)
{
if (!asn1_push_tag(data, ASN1_ENUMERATED)) return False;
asn1_write_uint8(data, v);