From 23e6e07b280983b2ccdf60deac3c32584af16140 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 4 Sep 2005 02:09:32 +0000 Subject: r10020: Support for malloc / realloc / free in HBIN blocks Initial support for adding keys (still broken though) (This used to be commit ff8d3a27c1b9bb37de39e7d7b974702b2b8c4437) --- source4/lib/registry/common/reg_interface.c | 5 + source4/lib/registry/reg_backend_nt4.c | 340 ++++++++++++++++++++++++++-- source4/lib/registry/regf.idl | 13 +- 3 files changed, 333 insertions(+), 25 deletions(-) (limited to 'source4/lib/registry') diff --git a/source4/lib/registry/common/reg_interface.c b/source4/lib/registry/common/reg_interface.c index 5297b1b3cf..ddd4ecbe93 100644 --- a/source4/lib/registry/common/reg_interface.c +++ b/source4/lib/registry/common/reg_interface.c @@ -409,6 +409,11 @@ WERROR reg_key_add_name(TALLOC_CTX *mem_ctx, struct registry_key *parent, const error = parent->hive->functions->add_key(mem_ctx, parent, name, access_mask, desc, newkey); if(!W_ERROR_IS_OK(error)) return error; + + if (!*newkey) { + DEBUG(0, ("Backend returned WERR_OK, but didn't specify key!\n")); + return WERR_GENERAL_FAILURE; + } (*newkey)->hive = parent->hive; (*newkey)->backend_data = talloc_asprintf(mem_ctx, "%s\\%s", parent->path, name); diff --git a/source4/lib/registry/reg_backend_nt4.c b/source4/lib/registry/reg_backend_nt4.c index b1c0d201f0..46057bcd63 100644 --- a/source4/lib/registry/reg_backend_nt4.c +++ b/source4/lib/registry/reg_backend_nt4.c @@ -20,6 +20,7 @@ #include "includes.h" #include "registry.h" #include "system/filesys.h" +#include "system/time.h" #include "lib/registry/tdr_regf.h" #include "librpc/gen_ndr/ndr_security.h" @@ -32,6 +33,23 @@ struct regf_data { struct hbin_block **hbins; }; +static struct hbin_block *hbin_by_offset (const struct regf_data *data, uint32_t offset, uint32_t *rel_offset) +{ + int i; + + for (i = 0; data->hbins[i]; i++) { + if (offset >= data->hbins[i]->offset_from_first && + offset < data->hbins[i]->offset_from_first+ + data->hbins[i]->offset_to_next) { + if (rel_offset) + *rel_offset = offset - data->hbins[i]->offset_from_first - 0x20; + return data->hbins[i]; + } + } + + return NULL; +} + /* * Validate a regf header * For now, do nothing, but we should check the checksum @@ -49,37 +67,216 @@ static uint32_t regf_hdr_checksum(const uint8_t *buffer) return checksum; } -static DATA_BLOB regf_get_data(const struct regf_data *data, uint32_t offset) +static DATA_BLOB hbin_get_data(const struct regf_data *data, uint32_t offset) { - int i; DATA_BLOB ret; + struct hbin_block *hbin; + uint32_t rel_offset; ret.data = NULL; ret.length = 0; - - for (i = 0; data->hbins[i]; i++) { - if (offset >= data->hbins[i]->offset_from_first && - offset < data->hbins[i]->offset_from_first+ - data->hbins[i]->offset_to_next) - break; - } - if (data->hbins[i] == NULL) { + hbin = hbin_by_offset(data, offset, &rel_offset); + + if (hbin == NULL) { DEBUG(1, ("Can't find HBIN containing 0x%4x\n", offset)); return ret; } - ret.length = IVAL(data->hbins[i]->data, - offset - data->hbins[i]->offset_from_first - 0x20); + ret.length = IVAL(hbin->data, rel_offset); if (ret.length & 0x80000000) { /* absolute value */ ret.length = (ret.length ^ 0xffffffff) + 1; } - ret.data = data->hbins[i]->data + - (offset - data->hbins[i]->offset_from_first - 0x20) + 4; + ret.length -= 4; /* 4 bytes for the length... */ + ret.data = hbin->data + + (offset - hbin->offset_from_first - 0x20) + 4; + + return ret; +} + +/* Allocate some new data */ +static DATA_BLOB hbin_alloc (struct regf_data *data, uint32_t size, uint32_t *offset) +{ + DATA_BLOB ret; + uint32_t rel_offset = -1; /* Relative offset ! */ + struct hbin_block *hbin = NULL; + int i; + + size += 4; /* Need to include uint32 for the length */ + + /* Allocate as a multiple of 8 */ + size = (size + 7) & ~7; + + ret.data = NULL; + ret.length = 0; + + if (size == 0) + return ret; + + for (i = 0; (hbin = data->hbins[i]); i++) { + int j; + uint32_t my_size; + for (j = 0; j < hbin->offset_to_next-0x20; j+= my_size) { + my_size = IVAL(hbin->data, j); + uint32_t header = IVAL(hbin->data, j + 4); + + if (my_size % 8 != 0) { + DEBUG(0, ("Encountered non-aligned block!\n")); + } + + if (my_size & 0x80000000) { /* Used... */ + my_size = (my_size ^ 0xffffffff) + 1; + } else if (my_size == size) { /* exact match */ + rel_offset = j; + break; + } else if (my_size > size) { /* data will remain */ + rel_offset = j; + SIVAL(hbin->data, rel_offset+size, my_size-size); + break; + } + + if (header == 0xffffffff && + hbin->offset_to_next-rel_offset >= size) { + rel_offset = j; + /* Mark new free block size */ + SIVAL(hbin->data, rel_offset+size,hbin->offset_to_next - rel_offset - size - 0x20); + SIVAL(hbin->data, rel_offset+size+0x4, 0xffffffff); + break; + } + + if (header == 0xffffffff) { + break; + } + } + + if (rel_offset != -1) + break; + } + /* No space available in previous hbins, + * allocate new one */ + if (data->hbins[i] == NULL) { + data->hbins = talloc_realloc(data, data->hbins, struct hbin_block *, i+2); + hbin = talloc(data->hbins, struct hbin_block); + data->hbins[i] = hbin; + data->hbins[i+1] = NULL; + + hbin->HBIN_ID = talloc_strdup(hbin, "hbin"); + hbin->offset_from_first = (i == 0?0:data->hbins[i-1]->offset_from_first+data->hbins[i-1]->offset_to_next); + hbin->offset_to_next = 0x1000; + hbin->unknown[0] = 0; + hbin->unknown[0] = 0; + unix_to_nt_time(&hbin->last_change, time(NULL)); + hbin->block_size = hbin->offset_to_next; + hbin->data = talloc_zero_array(hbin, uint8_t, hbin->block_size - 0x20); + + rel_offset = 0x0; + SIVAL(hbin->data, size, hbin->block_size - size - 0x20); + SIVAL(hbin->data, size + 0x4, 0xffffffff); + } + + /* Set size and mark as used */ + SIVAL(hbin->data, rel_offset, size & 0x80000000); + + ret.data = hbin->data + rel_offset + 0x4; /* Skip past length */ + ret.length = size - 0x4; + if (offset) + *offset = hbin->offset_from_first + rel_offset + 0x20; + return ret; } +/* Store a data blob. Return the offset at which it was stored */ +static uint32_t hbin_store (struct regf_data *data, DATA_BLOB blob) +{ + uint32_t ret; + DATA_BLOB dest = hbin_alloc(data, blob.length, &ret); + + memcpy(dest.data, blob.data, blob.length); + + return ret; +} + + +/* Free existing data */ +static void hbin_free (struct regf_data *data, uint32_t offset) +{ + uint32_t size; + uint32_t rel_offset; + struct hbin_block *hbin = hbin_by_offset(data, offset, &rel_offset); + + if (hbin == NULL) + return; + + /* Get original size */ + size = IVAL(hbin->data, rel_offset); + + if (!(size & 0x80000000)) { + DEBUG(1, ("Trying to free already freed block\n")); + return; + } + + /* Mark block as free */ + SIVAL(hbin->data, rel_offset, (size ^ 0xffffffff) + 1); +} + +/* Store a data blob data was already stored, but hsa changed in size + * Will try to save it at the current location if possible, otherwise + * does a free + store */ +static uint32_t hbin_store_resize (struct regf_data *data, uint32_t orig_offset, DATA_BLOB blob) +{ + uint32_t rel_offset; + struct hbin_block *hbin = hbin_by_offset(data, orig_offset, &rel_offset); + uint32_t orig_size; + uint32_t needed_size; + uint32_t possible_size; + int i; + + if (!hbin) + return hbin_store(data, blob); + + /* Get original size */ + orig_size = IVAL(hbin->data, rel_offset); + + /* Fits into current allocated block */ + if (orig_size - 4 >= blob.length) { + memcpy(hbin->data + rel_offset + 0x4, blob.data, blob.length); + return orig_offset; + } + + needed_size = blob.length + 4; /* Add uint32 containing length */ + needed_size = (needed_size + 7) & ~7; /* Align */ + + possible_size = orig_size; + + /* Check if it can be combined with the next few free records */ + for (i = rel_offset; + i < hbin->offset_to_next - 0x20; + i = rel_offset + possible_size) { + uint32_t header; + if (IVAL(hbin->data, i) & 0x80000000) /* Used */ + break; + + header = IVAL(hbin->data, i + 4); + if (header == 0xffffffff) { + possible_size = hbin->offset_to_next - 0x20 - rel_offset; + } else { + possible_size += IVAL(hbin->data, i); + } + + if (possible_size >= blob.length) { + SIVAL(hbin->data, rel_offset, possible_size); + memcpy(hbin->data + rel_offset + 0x4, blob.data, blob.length); + return orig_offset; + } + + if (header == 0xffffffff) + break; + } + + hbin_free(data, orig_offset); + return hbin_store(data, blob); +} static WERROR regf_num_subkeys (struct registry_key *key, uint32_t *count) { @@ -101,7 +298,7 @@ static WERROR regf_num_values (struct registry_key *key, uint32_t *count) static struct registry_key *regf_get_key (TALLOC_CTX *ctx, struct regf_data *regf, uint32_t offset) { - DATA_BLOB data = regf_get_data(regf, offset); + DATA_BLOB data = hbin_get_data(regf, offset); struct tdr_pull *pull; struct registry_key *ret; struct nk_block *nk; @@ -147,7 +344,7 @@ static WERROR regf_get_value (TALLOC_CTX *ctx, struct registry_key *key, int idx if (idx >= nk->num_values) return WERR_NO_MORE_ITEMS; - data = regf_get_data(key->hive->backend_data, nk->values_offset); + data = hbin_get_data(key->hive->backend_data, nk->values_offset); if (!data.data) { DEBUG(0, ("Unable to find value list\n")); return WERR_GENERAL_FAILURE; @@ -159,7 +356,7 @@ static WERROR regf_get_value (TALLOC_CTX *ctx, struct registry_key *key, int idx vk_offset = IVAL(data.data, idx * 4); - data = regf_get_data(key->hive->backend_data, vk_offset); + data = hbin_get_data(key->hive->backend_data, vk_offset); if (!data.data) { DEBUG(0, ("Unable to find value\n")); return WERR_GENERAL_FAILURE; @@ -188,7 +385,7 @@ static WERROR regf_get_value (TALLOC_CTX *ctx, struct registry_key *key, int idx (*ret)->data.data = (uint8_t *)&vk->data_offset; (*ret)->data.length = vk->data_length; } else { - (*ret)->data = regf_get_data(key->hive->backend_data, vk->data_offset); + (*ret)->data = hbin_get_data(key->hive->backend_data, vk->data_offset); } if ((*ret)->data.length < vk->data_length) { @@ -207,7 +404,7 @@ static WERROR regf_get_subkey (TALLOC_CTX *ctx, struct registry_key *key, int id if (idx >= nk->num_subkeys) return WERR_NO_MORE_ITEMS; - data = regf_get_data(key->hive->backend_data, nk->subkeys_offset); + data = hbin_get_data(key->hive->backend_data, nk->subkeys_offset); if (!data.data) { DEBUG(0, ("Unable to find subkey list\n")); return WERR_GENERAL_FAILURE; @@ -259,7 +456,7 @@ static WERROR regf_get_sec_desc(TALLOC_CTX *ctx, struct registry_key *key, struc struct sk_block sk; DATA_BLOB data; - data = regf_get_data(key->hive->backend_data, nk->sk_offset); + data = hbin_get_data(key->hive->backend_data, nk->sk_offset); if (!data.data) { DEBUG(0, ("Unable to find security descriptor\n")); return WERR_GENERAL_FAILURE; @@ -297,6 +494,108 @@ static WERROR regf_get_sec_desc(TALLOC_CTX *ctx, struct registry_key *key, struc return WERR_OK; } +static uint32_t lf_add_entry (struct regf_data *regf, uint32_t list_offset, const char *name, uint32_t key_offset) +{ + uint32_t ret; + struct lf_block lf; + struct tdr_pull *pull = NULL; + struct tdr_push *push; + + /* Add to subkeys list */ + if (list_offset == -1) { /* Need to create subkeys list */ + lf.header = "lf"; + lf.key_count = 0; + lf.hr = NULL; + } else { + DATA_BLOB data; + pull = talloc(regf, struct tdr_pull); + + data = hbin_get_data(regf, list_offset); + if (!data.data) { + DEBUG(0, ("Can't get subkeys list\n")); + talloc_free(pull); + return -1; + } + + if (NT_STATUS_IS_ERR(tdr_pull_lf_block(pull, &lf))) { + DEBUG(0, ("Unable to parse lf list\n")); + talloc_free(pull); + return -1; + } + } + + lf.hr = talloc_realloc(pull, lf.hr, struct hash_record, lf.key_count+1); + lf.hr[lf.key_count].nk_off = key_offset; + lf.hr[lf.key_count].hash = name; + + push = talloc_zero(regf, struct tdr_push); + + if (NT_STATUS_IS_ERR(tdr_push_lf_block(push, &lf))) { + DEBUG(0, ("Error storing lf block\n")); + return -1; + } + + ret = hbin_store_resize (regf, list_offset, push->data); + + talloc_free(push); + talloc_free(pull); + + return ret; +} + +static WERROR regf_add_key (TALLOC_CTX *ctx, struct registry_key *parent, const char *name, uint32_t access_mask, struct security_descriptor *sec_desc, struct registry_key **ret) +{ + struct nk_block *parent_nk = parent->backend_data, nk; + DATA_BLOB data; + struct tdr_push *push; + uint32_t offset; + + nk.header = "nk"; + nk.type = REG_SUB_KEY; + unix_to_nt_time(&nk.last_change, time(NULL)); + nk.uk1 = 0; + nk.parent_offset = 0; /* FIXME */ + nk.num_subkeys = 0; + nk.uk2 = 0; + nk.subkeys_offset = -1; + nk.unknown_offset = -1; + nk.num_values = 0; + nk.sk_offset = 0; + memset(nk.unk3, 0, 5); + nk.clsname_offset = -1; + nk.clsname_length = 0; + nk.key_name = name; + + push = talloc_zero(ctx, struct tdr_push); + if (NT_STATUS_IS_ERR(tdr_push_nk_block(push, &nk))) { + DEBUG(0, ("Error storing 'nk' block\n")); + return WERR_GENERAL_FAILURE; + } + + offset = hbin_store(parent->hive->backend_data, push->data); + + parent_nk->subkeys_offset = lf_add_entry(parent->hive->backend_data, parent_nk->subkeys_offset, name, nk.parent_offset); + + parent_nk->num_subkeys++; + + ZERO_STRUCTP(push); + + if (NT_STATUS_IS_ERR(tdr_push_nk_block(push, parent_nk))) { + DEBUG(0, ("Error storing parent 'nk' block\n")); + return WERR_GENERAL_FAILURE; + } + + data = hbin_get_data(parent->hive->backend_data, nk.parent_offset); + memcpy(data.data, push->data.data, push->data.length); + + talloc_free(push); + + /* FIXME: Set sec desc ! */ + + *ret = regf_get_key(ctx, parent->hive->backend_data, offset); + return WERR_OK; +} + static WERROR nt_open_hive (struct registry_hive *h, struct registry_key **key) { struct regf_data *regf; @@ -389,6 +688,7 @@ static struct hive_operations reg_backend_nt4 = { .get_subkey_by_index = regf_get_subkey, .get_value_by_index = regf_get_value, .key_get_sec_desc = regf_get_sec_desc, + .add_key = regf_add_key, }; NTSTATUS registry_nt4_init(void) diff --git a/source4/lib/registry/regf.idl b/source4/lib/registry/regf.idl index 3b0a66fc54..85a879cc36 100644 --- a/source4/lib/registry/regf.idl +++ b/source4/lib/registry/regf.idl @@ -64,8 +64,11 @@ interface regf uint32 block_size; /* Block size (including the header!) */ uint8 data[offset_to_next-0x20]; /* data is filled with: - uint32 length - uint8_t data[length] + uint32 length; + Negative if in used, positive otherwise + Always a multiple of 8 + uint8_t data[length]; + Free space marker if 0xffffffff */ } hbin_block; @@ -94,7 +97,7 @@ interface regf uint32 sk_offset; uint32 clsname_offset; uint32 unk3[5]; - uint16 name_length; + [value(strlen(key_name))] uint16 name_length; uint16 clsname_length; [charset(DOS)] uint8 key_name[name_length]; } nk_block; @@ -137,7 +140,7 @@ interface regf /* The vk-record consists information to a single value (value key). */ typedef [public,noprint] struct { [charset(DOS)] uint8 header[2]; - uint16 name_length; + [value(strlen(data_name))] uint16 name_length; uint32 data_length; /* If top-bit set, offset contains the data */ uint32 data_offset; uint32 data_type; @@ -148,7 +151,7 @@ interface regf typedef [noprint] struct { uint32 nk_off; - uint8 hash[4]; + [charset(DOS)] uint8 hash[4]; } hash_record; /* -- cgit