Changeset 740 for vendor/current/lib/util/asn1.c

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

File:

• vendor/current/lib/util/asn1.c (modified) (11 diffs)

vendor/current/lib/util/asn1.c

@@ -215 +215 @@
 }
 
-bool ber_write_OID_String(DATA_BLOB *blob, const char *OID)
-{
-        uint_t v, v2;
+bool ber_write_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *OID)
+{
+        unsigned int v, v2;
         const char *p = (const char *)OID;
         char *newp;
         int i;
 
+        if (!isdigit(*p)) return false;
         v = strtoul(p, &newp, 10);
         if (newp[0] != '.') return false;
         p = newp + 1;
 
+        if (!isdigit(*p)) return false;
         v2 = strtoul(p, &newp, 10);
         if (newp[0] != '.') return false;
@@ -231 +233 @@
 
         /*the ber representation can't use more space then the string one */
-        *blob = data_blob(NULL, strlen(OID));
+        *blob = data_blob_talloc(mem_ctx, NULL, strlen(OID));
         if (!blob->data) return false;
 
@@ -238 +240 @@
         i = 1;
         while (*p) {
+                if (!isdigit(*p)) return false;
                 v = strtoul(p, &newp, 10);
                 if (newp[0] == '.') {
                         p = newp + 1;
+                        /* check for empty last component */
+                        if (!*p) return false;
                 } else if (newp[0] == '\0') {
                         p = newp;
@@ -259 +264 @@
 }
 
+/**
+ * Serialize partial OID string.
+ * Partial OIDs are in the form:
+ *   1:2.5.6:0x81
+ *   1:2.5.6:0x8182
+ */
+bool ber_write_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *partial_oid)
+{
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+        char *oid = talloc_strdup(tmp_ctx, partial_oid);
+        char *p;
+
+        /* truncate partial part so ber_write_OID_String() works */
+        p = strchr(oid, ':');
+        if (p) {
+                *p = '\0';
+                p++;
+        }
+
+        if (!ber_write_OID_String(mem_ctx, blob, oid)) {
+                talloc_free(tmp_ctx);
+                return false;
+        }
+
+        /* Add partially encoded sub-identifier */
+        if (p) {
+                DATA_BLOB tmp_blob = strhex_to_data_blob(tmp_ctx, p);
+                if (!data_blob_append(mem_ctx, blob, tmp_blob.data,
+                                      tmp_blob.length)) {
+                        talloc_free(tmp_ctx);
+                        return false;
+                }
+        }
+
+        talloc_free(tmp_ctx);
+
+        return true;
+}
+
 /* write an object ID to a ASN1 buffer */
 bool asn1_write_OID(struct asn1_data *data, const char *OID)
@@ -266 +310 @@
         if (!asn1_push_tag(data, ASN1_OID)) return false;
 
-        if (!ber_write_OID_String(&blob, OID)) {
+        if (!ber_write_OID_String(NULL, &blob, OID)) {
                 data->has_error = true;
                 return false;
@@ -453 +497 @@
 
         return (b == tag);
+}
+
+/*
+ * just get the needed size the tag would consume
+ */
+bool asn1_peek_tag_needed_size(struct asn1_data *data, uint8_t tag, size_t *size)
+{
+        off_t start_ofs = data->ofs;
+        uint8_t b;
+        size_t taglen = 0;
+
+        if (data->has_error) {
+                return false;
+        }
+
+        if (!asn1_read_uint8(data, &b)) {
+                data->ofs = start_ofs;
+                data->has_error = false;
+                return false;
+        }
+
+        if (b != tag) {
+                data->ofs = start_ofs;
+                data->has_error = false;
+                return false;
+        }
+
+        if (!asn1_read_uint8(data, &b)) {
+                data->ofs = start_ofs;
+                data->has_error = false;
+                return false;
+        }
+
+        if (b & 0x80) {
+                int n = b & 0x7f;
+                if (!asn1_read_uint8(data, &b)) {
+                        data->ofs = start_ofs;
+                        data->has_error = false;
+                        return false;
+                }
+                if (n > 4) {
+                        /*
+                         * We should not allow more than 4 bytes
+                         * for the encoding of the tag length.
+                         *
+                         * Otherwise we'd overflow the taglen
+                         * variable on 32 bit systems.
+                         */
+                        data->ofs = start_ofs;
+                        data->has_error = false;
+                        return false;
+                }
+                taglen = b;
+                while (n > 1) {
+                        if (!asn1_read_uint8(data, &b)) {
+                                data->ofs = start_ofs;
+                                data->has_error = false;
+                                return false;
+                        }
+                        taglen = (taglen << 8) | b;
+                        n--;
+                }
+        } else {
+                taglen = b;
+        }
+
+        *size = (data->ofs - start_ofs) + taglen;
+
+        data->ofs = start_ofs;
+        data->has_error = false;
+        return true;
 }
 
@@ -544 +659 @@
 }
 
-/* read an object ID from a data blob */
-bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **OID)
+/**
+ * Internal implementation for reading binary OIDs
+ * Reading is done as far in the buffer as valid OID
+ * till buffer ends or not valid sub-identifier is found.
+ */
+static bool _ber_read_OID_String_impl(TALLOC_CTX *mem_ctx, DATA_BLOB blob,
+                                      char **OID, size_t *bytes_eaten)
 {
         int i;
         uint8_t *b;
-        uint_t v;
+        unsigned int v;
         char *tmp_oid = NULL;
 
@@ -560 +680 @@
         tmp_oid = talloc_asprintf_append_buffer(tmp_oid, ".%u",  b[0]%40);
         if (!tmp_oid) goto nomem;
+
+        if (bytes_eaten != NULL) {
+                *bytes_eaten = 0;
+        }
 
         for(i = 1, v = 0; i < blob.length; i++) {
@@ -566 +690 @@
                         tmp_oid = talloc_asprintf_append_buffer(tmp_oid, ".%u",  v);
                         v = 0;
+                        if (bytes_eaten)
+                                *bytes_eaten = i+1;
                 }
                 if (!tmp_oid) goto nomem;
         }
 
-        if (v != 0) {
-                talloc_free(tmp_oid);
-                return false;
-        }
-
         *OID = tmp_oid;
         return true;
 
-nomem:  
+nomem:
         return false;
 }
 
+/* read an object ID from a data blob */
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, char **OID)
+{
+        size_t bytes_eaten;
+
+        if (!_ber_read_OID_String_impl(mem_ctx, blob, OID, &bytes_eaten))
+                return false;
+
+        return (bytes_eaten == blob.length);
+}
+
+/**
+ * Deserialize partial OID string.
+ * Partial OIDs are in the form:
+ *   1:2.5.6:0x81
+ *   1:2.5.6:0x8182
+ */
+bool ber_read_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob,
+                                 char **partial_oid)
+{
+        size_t bytes_left;
+        size_t bytes_eaten;
+        char *identifier = NULL;
+        char *tmp_oid = NULL;
+
+        if (!_ber_read_OID_String_impl(mem_ctx, blob, &tmp_oid, &bytes_eaten))
+                return false;
+
+        if (bytes_eaten < blob.length) {
+                bytes_left = blob.length - bytes_eaten;
+                identifier = hex_encode_talloc(mem_ctx, &blob.data[bytes_eaten], bytes_left);
+                if (!identifier)        goto nomem;
+
+                *partial_oid = talloc_asprintf_append_buffer(tmp_oid, ":0x%s", identifier);
+                if (!*partial_oid)      goto nomem;
+                TALLOC_FREE(identifier);
+        } else {
+                *partial_oid = tmp_oid;
+        }
+
+        return true;
+
+nomem:
+        TALLOC_FREE(identifier);
+        TALLOC_FREE(tmp_oid);
+        return false;
+}
+
 /* read an object ID from a ASN1 buffer */
-bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, const char **OID)
+bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **OID)
 {
         DATA_BLOB blob;
@@ -622 +791 @@
 bool asn1_check_OID(struct asn1_data *data, const char *OID)
 {
-        const char *id;
+        char *id;
 
         if (!asn1_read_OID(data, data, &id)) return false;
 
         if (strcmp(id, OID) != 0) {
-                talloc_free(discard_const(id));
-                data->has_error = true;
-                return false;
-        }
-        talloc_free(discard_const(id));
+                talloc_free(id);
+                data->has_error = true;
+                return false;
+        }
+        talloc_free(id);
         return true;
 }
@@ -865 +1034 @@
         if (size > blob.length) {
                 return STATUS_MORE_ENTRIES;
-        }               
+        }
 
         *packet_size = size;
         return NT_STATUS_OK;
 }
+
+NTSTATUS asn1_peek_full_tag(DATA_BLOB blob, uint8_t tag, size_t *packet_size)
+{
+        struct asn1_data asn1;
+        size_t size;
+        bool ok;
+
+        ZERO_STRUCT(asn1);
+        asn1.data = blob.data;
+        asn1.length = blob.length;
+
+        ok = asn1_peek_tag_needed_size(&asn1, tag, &size);
+        if (!ok) {
+                return NT_STATUS_INVALID_BUFFER_SIZE;
+        }
+
+        if (size > blob.length) {
+                *packet_size = size;
+                return STATUS_MORE_ENTRIES;
+        }               
+
+        *packet_size = size;
+        return NT_STATUS_OK;
+}