along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "includes.h"
-#include "lib/registry/hive.h"
#include "system/filesys.h"
#include "system/time.h"
#include "lib/registry/tdr_regf.h"
#include "librpc/gen_ndr/ndr_security.h"
#include "librpc/gen_ndr/winreg.h"
-#include "param/param.h"
+#include "lib/registry/registry.h"
+#include "libcli/security/security.h"
+
static struct hive_operations reg_backend_regf;
int fd;
struct hbin_block **hbins;
struct regf_hdr *header;
- struct smb_iconv_convenience *iconv_convenience;
};
static WERROR regf_save_hbin(struct regf_data *data);
static struct hbin_block *hbin_by_offset(const struct regf_data *data,
uint32_t offset, uint32_t *rel_offset)
{
- int i;
+ unsigned int i;
for (i = 0; data->hbins[i]; i++) {
if (offset >= data->hbins[i]->offset_from_first &&
static uint32_t regf_hdr_checksum(const uint8_t *buffer)
{
uint32_t checksum = 0, x;
- int i;
+ unsigned int i;
for (i = 0; i < 0x01FB; i+= 4) {
x = IVAL(buffer, i);
static bool hbin_get_tdr(struct regf_data *regf, uint32_t offset,
TALLOC_CTX *ctx, tdr_pull_fn_t pull_fn, void *p)
{
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
pull->data = hbin_get(regf, offset);
if (!pull->data.data) {
DATA_BLOB ret;
uint32_t rel_offset = -1; /* Relative offset ! */
struct hbin_block *hbin = NULL;
- int i;
+ unsigned int i;
*offset = 0;
memcpy(dest.data, blob.data, blob.length);
+ /* Make sure that we have no tailing garbage in the block */
+ if (dest.length > blob.length) {
+ memset(dest.data + blob.length, 0, dest.length - blob.length);
+ }
+
return ret;
}
static uint32_t hbin_store_tdr(struct regf_data *data,
tdr_push_fn_t push_fn, void *p)
{
- struct tdr_push *push = tdr_push_init(data, data->iconv_convenience);
+ struct tdr_push *push = tdr_push_init(data);
uint32_t ret;
if (NT_STATUS_IS_ERR(push_fn(push, p))) {
int32_t orig_size;
int32_t needed_size;
int32_t possible_size;
- int i;
+ unsigned int i;
SMB_ASSERT(orig_offset > 0);
tdr_push_fn_t push_fn,
uint32_t orig_offset, void *p)
{
- struct tdr_push *push = tdr_push_init(regf, regf->iconv_convenience);
+ struct tdr_push *push = tdr_push_init(regf);
uint32_t ret;
if (NT_STATUS_IS_ERR(push_fn(push, p))) {
*classname = talloc_strndup(mem_ctx,
(char*)data.data,
private_data->nk->clsname_length);
+ W_ERROR_HAVE_NO_MEMORY(*classname);
} else
*classname = NULL;
}
static WERROR regf_get_value(TALLOC_CTX *ctx, struct hive_key *key,
- int idx, const char **name,
+ uint32_t idx, const char **name,
uint32_t *data_type, DATA_BLOB *data)
{
const struct regf_key_data *private_data =
}
/* FIXME: name character set ?*/
- if (name != NULL)
+ if (name != NULL) {
*name = talloc_strndup(ctx, vk->data_name, vk->name_length);
+ W_ERROR_HAVE_NO_MEMORY(*name);
+ }
if (data_type != NULL)
*data_type = vk->data_type;
if (vk->data_length & 0x80000000) {
- vk->data_length &=~0x80000000;
- data->data = (uint8_t *)&vk->data_offset;
- data->length = vk->data_length;
+ /* this is data of type "REG_DWORD" or "REG_DWORD_BIG_ENDIAN" */
+ data->data = talloc_size(ctx, sizeof(uint32_t));
+ W_ERROR_HAVE_NO_MEMORY(data->data);
+ SIVAL(data->data, 0, vk->data_offset);
+ data->length = sizeof(uint32_t);
} else {
*data = hbin_get(regf, vk->data_offset);
}
struct hive_key *key, const char *name,
uint32_t *type, DATA_BLOB *data)
{
- int i;
+ unsigned int i;
const char *vname;
WERROR error;
if (!strncmp((char *)data.data, "li", 2)) {
struct li_block li;
- struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(private_data->hive);
DEBUG(10, ("Subkeys in LI list\n"));
pull->data = data;
} else if (!strncmp((char *)data.data, "lf", 2)) {
struct lf_block lf;
- struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(private_data->hive);
DEBUG(10, ("Subkeys in LF list\n"));
pull->data = data;
key_off = lf.hr[idx].nk_offset;
} else if (!strncmp((char *)data.data, "lh", 2)) {
struct lh_block lh;
- struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(private_data->hive);
DEBUG(10, ("Subkeys in LH list\n"));
pull->data = data;
key_off = lh.hr[idx].nk_offset;
} else if (!strncmp((char *)data.data, "ri", 2)) {
struct ri_block ri;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i;
uint16_t sublist_count = 0;
*classname = talloc_strndup(ctx,
(char*)db.data,
ret->nk->clsname_length);
+ W_ERROR_HAVE_NO_MEMORY(*classname);
} else
*classname = NULL;
}
return WERR_GENERAL_FAILURE;
}
- pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ pull = tdr_pull_init(ctx);
pull->data = subkey_data;
if (!strncmp((char *)data.data, "li", 2)) {
struct li_block li;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i;
DEBUG(10, ("Subkeys in LI list\n"));
return WERR_BADFILE;
} else if (!strncmp((char *)data.data, "lf", 2)) {
struct lf_block lf;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i;
DEBUG(10, ("Subkeys in LF list\n"));
return WERR_BADFILE;
} else if (!strncmp((char *)data.data, "lh", 2)) {
struct lh_block lh;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i;
uint32_t hash;
return WERR_BADFILE;
} else if (!strncmp((char *)data.data, "ri", 2)) {
struct ri_block ri;
- struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(ctx);
uint16_t i, j;
DEBUG(10, ("Subkeys in RI list\n"));
(tdr_pull_fn_t) tdr_pull_nk_block, &root);
/* Push the security descriptor to a blob */
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf, NULL,
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf,
sec_desc, (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
DEBUG(0, ("Unable to push security descriptor\n"));
return WERR_GENERAL_FAILURE;
data.data = sk.sec_desc;
data.length = sk.rec_size;
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_pull_struct_blob(&data, ctx, NULL, *sd,
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_pull_struct_blob(&data, ctx, *sd,
(ndr_pull_flags_fn_t)ndr_pull_security_descriptor))) {
DEBUG(0, ("Error parsing security descriptor\n"));
return WERR_GENERAL_FAILURE;
}
if (!strncmp((char *)data.data, "li", 2)) {
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
struct li_block li;
pull->data = data;
talloc_free(li.nk_offset);
} else if (!strncmp((char *)data.data, "lf", 2)) {
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
struct lf_block lf;
pull->data = data;
talloc_free(lf.hr);
} else if (!strncmp((char *)data.data, "lh", 2)) {
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
struct lh_block lh;
pull->data = data;
if (strncmp((char *)data.data, "li", 2) == 0) {
struct li_block li;
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
uint16_t i;
bool found_offset = false;
list_offset, &li);
} else if (strncmp((char *)data.data, "lf", 2) == 0) {
struct lf_block lf;
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
uint16_t i;
bool found_offset = false;
list_offset, &lf);
} else if (strncmp((char *)data.data, "lh", 2) == 0) {
struct lh_block lh;
- struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+ struct tdr_pull *pull = tdr_pull_init(regf);
uint16_t i;
bool found_offset = false;
return WERR_OK;
}
-static WERROR regf_del_value (struct hive_key *key, const char *name)
+static WERROR regf_del_value(TALLOC_CTX *mem_ctx, struct hive_key *key,
+ const char *name)
{
struct regf_key_data *private_data = (struct regf_key_data *)key;
struct regf_data *regf = private_data->hive;
uint32_t vk_offset;
bool found_offset = false;
DATA_BLOB values;
- uint32_t i;
+ unsigned int i;
if (nk->values_offset == -1) {
return WERR_BADFILE;
}
-static WERROR regf_del_key(const struct hive_key *parent, const char *name)
+static WERROR regf_del_key(TALLOC_CTX *mem_ctx, const struct hive_key *parent,
+ const char *name)
{
const struct regf_key_data *private_data =
(const struct regf_key_data *)parent;
if (key->nk->subkeys_offset != -1) {
char *sk_name;
struct hive_key *sk = (struct hive_key *)key;
- int i = key->nk->num_subkeys;
+ unsigned int i = key->nk->num_subkeys;
while (i--) {
/* Get subkey information. */
error = regf_get_subkey_by_index(parent_nk, sk, 0,
}
/* Delete subkey. */
- error = regf_del_key(sk, sk_name);
+ error = regf_del_key(NULL, sk, sk_name);
if (!W_ERROR_IS_OK(error)) {
DEBUG(0, ("Can't delete key '%s'.\n", sk_name));
return error;
char *val_name;
struct hive_key *sk = (struct hive_key *)key;
DATA_BLOB data;
- int i = key->nk->num_values;
+ unsigned int i = key->nk->num_values;
while (i--) {
/* Get value information. */
error = regf_get_value(parent_nk, sk, 0,
}
/* Delete value. */
- error = regf_del_value(sk, val_name);
+ error = regf_del_value(NULL, sk, val_name);
if (!W_ERROR_IS_OK(error)) {
DEBUG(0, ("Can't delete value '%s'.\n", val_name));
return error;
if (!hbin_get_tdr(regf, regf->header->data_offset, root,
(tdr_pull_fn_t)tdr_pull_nk_block, root)) {
- DEBUG(0, ("Unable to find HBIN data for offset %d\n", offset));
+ DEBUG(0, ("Unable to find HBIN data for offset %d\n",
+ regf->header->data_offset));
return WERR_GENERAL_FAILURE;
}
nk.sk_offset = root->sk_offset;
break;
}
}
- /* Free data, if any */
- if (!(vk.data_length & 0x80000000)) {
- hbin_free(regf, vk.data_offset);
- }
}
+
+ /* If it's new, create the vk struct, if it's old, free the old data. */
if (old_vk_offset == -1) {
vk.header = "vk";
vk.name_length = strlen(name);
vk.data_name = NULL;
vk.flag = 0;
}
+ } else {
+ /* Free data, if any */
+ if (!(vk.data_length & 0x80000000)) {
+ hbin_free(regf, vk.data_offset);
+ }
}
+
/* Set the type and data */
vk.data_length = data.length;
vk.data_type = type;
- if (type == REG_DWORD) {
+ if ((type == REG_DWORD) || (type == REG_DWORD_BIG_ENDIAN)) {
+ if (vk.data_length != sizeof(uint32_t)) {
+ DEBUG(0, ("DWORD or DWORD_BIG_ENDIAN value with size other than 4 byte!\n"));
+ return WERR_NOT_SUPPORTED;
+ }
vk.data_length |= 0x80000000;
- vk.data_offset = *(uint32_t *)data.data;
+ vk.data_offset = IVAL(data.data, 0);
} else {
/* Store data somewhere */
vk.data_offset = hbin_store(regf, data);
static WERROR regf_save_hbin(struct regf_data *regf)
{
- struct tdr_push *push = tdr_push_init(regf, regf->iconv_convenience);
- int i;
+ struct tdr_push *push = tdr_push_init(regf);
+ unsigned int i;
W_ERROR_HAVE_NO_MEMORY(push);
regf->header->chksum = regf_hdr_checksum(push->data.data);
talloc_free(push);
- if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, regf->iconv_convenience,
+ if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
(tdr_push_fn_t)tdr_push_regf_hdr,
regf->header))) {
DEBUG(0, ("Error writing registry file header\n"));
}
for (i = 0; regf->hbins[i]; i++) {
- if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, regf->iconv_convenience,
+ if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
(tdr_push_fn_t)tdr_push_hbin_block,
regf->hbins[i]))) {
DEBUG(0, ("Error writing HBIN block\n"));
return WERR_OK;
}
-WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx, const char *location,
+WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
+ const char *location,
int minor_version, struct hive_key **key)
{
struct regf_data *regf;
struct regf_hdr *regf_hdr;
- int i;
struct nk_block nk;
+ struct sk_block sk;
WERROR error;
+ DATA_BLOB data;
+ struct security_descriptor *sd;
+ uint32_t sk_offset;
regf = (struct regf_data *)talloc_zero(NULL, struct regf_data);
- regf->iconv_convenience = lp_iconv_convenience(global_loadparm);
-
W_ERROR_HAVE_NO_MEMORY(regf);
DEBUG(5, ("Attempting to create registry file\n"));
regf_hdr->version.minor = minor_version;
regf_hdr->last_block = 0x1000; /* Block size */
regf_hdr->description = talloc_strdup(regf_hdr,
- "registry created by Samba 4");
+ "Registry created by Samba 4");
W_ERROR_HAVE_NO_MEMORY(regf_hdr->description);
regf_hdr->chksum = 0;
regf->header = regf_hdr;
- i = 0;
/* Create all hbin blocks */
regf->hbins = talloc_array(regf, struct hbin_block *, 1);
W_ERROR_HAVE_NO_MEMORY(regf->hbins);
regf->hbins[0] = NULL;
- regf_hdr->data_offset = -1; /* FIXME */
-
nk.header = "nk";
nk.type = REG_SUB_KEY;
unix_to_nt_time(&nk.last_change, time(NULL));
nk.num_values = 0;
nk.values_offset = -1;
memset(nk.unk3, 0, 5);
- nk.clsname_offset = -1; /* FIXME: fill in */
+ nk.clsname_offset = -1;
nk.clsname_length = 0;
- nk.key_name = "";
+ nk.sk_offset = 0x80;
+ nk.key_name = "SambaRootKey";
+
+ /*
+ * It should be noted that changing the key_name to something shorter
+ * creates a shorter nk block, which makes the position of the sk block
+ * change. All Windows registries I've seen have the sk at 0x80.
+ * I therefore recommend that our regf files share that offset -- Wilco
+ */
+
+ /* Create a security descriptor. */
+ sd = security_descriptor_dacl_create(regf,
+ 0,
+ NULL, NULL,
+ SID_NT_AUTHENTICATED_USERS,
+ SEC_ACE_TYPE_ACCESS_ALLOWED,
+ SEC_GENERIC_ALL,
+ SEC_ACE_FLAG_OBJECT_INHERIT,
+ NULL);
+
+ /* Push the security descriptor to a blob */
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf,
+ sd, (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
+ DEBUG(0, ("Unable to push security descriptor\n"));
+ return WERR_GENERAL_FAILURE;
+ }
- nk.sk_offset = -1; /* FIXME: fill in */
+ ZERO_STRUCT(sk);
+ sk.header = "sk";
+ sk.prev_offset = 0x80;
+ sk.next_offset = 0x80;
+ sk.ref_cnt = 1;
+ sk.rec_size = data.length;
+ sk.sec_desc = data.data;
/* Store the new nk key */
regf->header->data_offset = hbin_store_tdr(regf,
(tdr_push_fn_t)tdr_push_nk_block,
&nk);
+ /* Store the sk block */
+ sk_offset = hbin_store_tdr(regf,
+ (tdr_push_fn_t) tdr_push_sk_block,
+ &sk);
+ if (sk_offset != 0x80) {
+ DEBUG(0, ("Error storing sk block, should be at 0x80, stored at 0x%x\n", nk.sk_offset));
+ return WERR_GENERAL_FAILURE;
+ }
+
*key = (struct hive_key *)regf_get_key(parent_ctx, regf,
regf->header->data_offset);
- /* We can drop our own reference now that *key will have created one */
- talloc_free(regf);
-
error = regf_save_hbin(regf);
if (!W_ERROR_IS_OK(error)) {
return error;
}
+
+ /* We can drop our own reference now that *key will have created one */
+ talloc_unlink(NULL, regf);
return WERR_OK;
}
WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx, const char *location,
- struct loadparm_context *lp_ctx, struct hive_key **key)
+ struct hive_key **key)
{
struct regf_data *regf;
struct regf_hdr *regf_hdr;
struct tdr_pull *pull;
- int i;
-
- regf = (struct regf_data *)talloc_zero(NULL, struct regf_data);
+ unsigned int i;
- regf->iconv_convenience = lp_iconv_convenience(lp_ctx);
+ regf = (struct regf_data *)talloc_zero(parent_ctx, struct regf_data);
W_ERROR_HAVE_NO_MEMORY(regf);
return WERR_GENERAL_FAILURE;
}
- pull = tdr_pull_init(regf, regf->iconv_convenience);
+ pull = tdr_pull_init(regf);
- pull->data.data = (uint8_t*)fd_load(regf->fd, &pull->data.length, regf);
+ pull->data.data = (uint8_t*)fd_load(regf->fd, &pull->data.length, 0, regf);
if (pull->data.data == NULL) {
DEBUG(0, ("Error reading data\n"));
regf->header->data_offset);
/* We can drop our own reference now that *key will have created one */
- talloc_free(regf);
+ talloc_unlink(parent_ctx, regf);
return WERR_OK;
}
git.samba.org / bbaumbach / samba-autobuild / .git / blobdiff