mirror of
https://github.com/samba-team/samba.git
synced 2024-12-23 17:34:34 +03:00
6a359944f1
Signed-off-by: Andreas Schneider <asn@samba.org> Reviewed-by: Joseph Sutton <josephsutton@catalyst.net.nz>
234 lines
6.8 KiB
C
234 lines
6.8 KiB
C
/*
|
|
* Unix SMB/CIFS implementation.
|
|
* Windows NT registry I/O library
|
|
* Copyright (c) Gerald (Jerry) Carter 2005
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/************************************************************
|
|
* Most of this information was obtained from
|
|
* http://www.wednesday.demon.co.uk/dosreg.html
|
|
* Thanks Nigel!
|
|
***********************************************************/
|
|
|
|
#include "registry/reg_parse_prs.h"
|
|
#include "registry/reg_objects.h"
|
|
|
|
#ifndef _REGFIO_H
|
|
#define _REGFIO_H
|
|
|
|
struct regsubkey_ctr;
|
|
|
|
/* Macros */
|
|
|
|
#define REGF_BLOCKSIZE 0x1000
|
|
#define REGF_ALLOC_BLOCK 0x1000
|
|
|
|
/* header sizes for various records */
|
|
|
|
#define REGF_HDR_SIZE 4
|
|
#define HBIN_HDR_SIZE 4
|
|
#define HBIN_HEADER_REC_SIZE 0x24
|
|
#define REC_HDR_SIZE 2
|
|
|
|
#define REGF_OFFSET_NONE 0xffffffff
|
|
|
|
/* Flags for the vk records */
|
|
|
|
#define VK_FLAG_NAME_PRESENT 0x0001
|
|
#define VK_DATA_IN_OFFSET 0x80000000
|
|
|
|
/* NK record macros */
|
|
|
|
#define NK_TYPE_LINKKEY 0x0010
|
|
#define NK_TYPE_NORMALKEY 0x0020
|
|
#define NK_TYPE_ROOTKEY 0x002c
|
|
|
|
#define HBIN_STORE_REF(x, y) { x->hbin = y; y->ref_count++ };
|
|
#define HBIN_REMOVE_REF(x, y) { x->hbin = NULL; y->ref_count-- /* if the count == 0; we can clean up */ };
|
|
|
|
|
|
/* HBIN block */
|
|
struct regf_hbin;
|
|
typedef struct regf_hbin {
|
|
struct regf_hbin *prev, *next;
|
|
uint32_t file_off; /* my offset in the registry file */
|
|
uint32_t free_off; /* offset to free space within the hbin record */
|
|
uint32_t free_size; /* amount of data left in the block */
|
|
int ref_count; /* how many active records are pointing to this block (not used currently) */
|
|
|
|
char header[HBIN_HDR_SIZE]; /* "hbin" */
|
|
uint32_t first_hbin_off; /* offset from first hbin block */
|
|
uint32_t block_size; /* block size of this blockually a multiple of 4096Kb) */
|
|
|
|
prs_struct ps; /* data */
|
|
|
|
bool dirty; /* has this hbin block been modified? */
|
|
} REGF_HBIN;
|
|
|
|
/* ??? List -- list of key offsets and hashed names for consistency */
|
|
|
|
typedef struct {
|
|
uint32_t nk_off;
|
|
uint8_t keycheck[sizeof(uint32_t)];
|
|
char *fullname;
|
|
} REGF_HASH_REC;
|
|
|
|
typedef struct {
|
|
REGF_HBIN *hbin; /* pointer to HBIN record (in memory) containing this nk record */
|
|
uint32_t hbin_off; /* offset from beginning of this hbin block */
|
|
uint32_t rec_size; /* ((start_offset - end_offset) & 0xfffffff8) */
|
|
|
|
char header[REC_HDR_SIZE];
|
|
uint16_t num_keys;
|
|
REGF_HASH_REC *hashes;
|
|
} REGF_LF_REC;
|
|
|
|
/* Key Value */
|
|
|
|
typedef struct {
|
|
REGF_HBIN *hbin; /* pointer to HBIN record (in memory) containing this nk record */
|
|
uint32_t hbin_off; /* offset from beginning of this hbin block */
|
|
uint32_t rec_size; /* ((start_offset - end_offset) & 0xfffffff8) */
|
|
uint32_t rec_off; /* offset stored in the value list */
|
|
|
|
char header[REC_HDR_SIZE];
|
|
char *valuename;
|
|
uint32_t data_size;
|
|
uint32_t data_off;
|
|
uint8_t *data;
|
|
uint32_t type;
|
|
uint16_t flag;
|
|
} REGF_VK_REC;
|
|
|
|
|
|
/* Key Security */
|
|
struct _regf_sk_rec;
|
|
|
|
typedef struct _regf_sk_rec {
|
|
struct _regf_sk_rec *next, *prev;
|
|
REGF_HBIN *hbin; /* pointer to HBIN record (in memory) containing this nk record */
|
|
uint32_t hbin_off; /* offset from beginning of this hbin block */
|
|
uint32_t rec_size; /* ((start_offset - end_offset) & 0xfffffff8) */
|
|
|
|
uint32_t sk_off; /* offset parsed from NK record used as a key
|
|
to lookup reference to this SK record */
|
|
|
|
char header[REC_HDR_SIZE];
|
|
uint32_t prev_sk_off;
|
|
uint32_t next_sk_off;
|
|
uint32_t ref_count;
|
|
uint32_t size;
|
|
struct security_descriptor *sec_desc;
|
|
} REGF_SK_REC;
|
|
|
|
/* Key Name */
|
|
|
|
typedef struct {
|
|
REGF_HBIN *hbin; /* pointer to HBIN record (in memory) containing this nk record */
|
|
uint32_t hbin_off; /* offset from beginning of this hbin block */
|
|
uint32_t subkey_index; /* index to next subkey record to return */
|
|
uint32_t rec_size; /* ((start_offset - end_offset) & 0xfffffff8) */
|
|
|
|
/* header information */
|
|
|
|
char header[REC_HDR_SIZE];
|
|
uint16_t key_type;
|
|
NTTIME mtime;
|
|
uint32_t parent_off; /* back pointer in registry hive */
|
|
uint32_t classname_off;
|
|
char *classname;
|
|
char *keyname;
|
|
|
|
/* max lengths */
|
|
|
|
uint32_t max_bytes_subkeyname; /* max subkey name * 2 */
|
|
uint32_t max_bytes_subkeyclassname; /* max subkey classname length (as if) */
|
|
uint32_t max_bytes_valuename; /* max valuename * 2 */
|
|
uint32_t max_bytes_value; /* max value data size */
|
|
|
|
/* unknowns */
|
|
|
|
uint32_t unk_index; /* nigel says run time index ? */
|
|
|
|
/* children */
|
|
|
|
uint32_t num_subkeys;
|
|
uint32_t subkeys_off; /* hash records that point to NK records */
|
|
uint32_t num_values;
|
|
uint32_t values_off; /* value lists which point to VK records */
|
|
uint32_t sk_off; /* offset to SK record */
|
|
|
|
/* link in the other records here */
|
|
|
|
REGF_LF_REC subkeys;
|
|
REGF_VK_REC *values;
|
|
REGF_SK_REC *sec_desc;
|
|
|
|
} REGF_NK_REC;
|
|
|
|
/* REGF block */
|
|
|
|
typedef struct {
|
|
/* run time information */
|
|
|
|
int fd; /* file descriptor */
|
|
int open_flags; /* flags passed to the open() call */
|
|
TALLOC_CTX *mem_ctx; /* memory context for run-time file access information */
|
|
REGF_HBIN *block_list; /* list of open hbin blocks */
|
|
|
|
/* file format information */
|
|
|
|
char header[REGF_HDR_SIZE]; /* "regf" */
|
|
uint32_t data_offset; /* offset to record in the first (or any?) hbin block */
|
|
uint32_t last_block; /* offset to last hbin block in file */
|
|
uint32_t checksum; /* XOR of bytes 0x0000 - 0x01FB */
|
|
NTTIME mtime;
|
|
|
|
REGF_SK_REC *sec_desc_list; /* list of security descriptors referenced by NK records */
|
|
|
|
/* Ignore checksums in input data. Used by fuzzing code to allow more
|
|
* coverage without having to calculate a valid checksum. The checksums
|
|
* are merely to detect data corruption and don't provide a security
|
|
* value.
|
|
*/
|
|
bool ignore_checksums;
|
|
|
|
/* unknowns used to simply writing */
|
|
|
|
uint32_t unknown1;
|
|
uint32_t unknown2;
|
|
uint32_t unknown3;
|
|
uint32_t unknown4;
|
|
uint32_t unknown5;
|
|
uint32_t unknown6;
|
|
|
|
} REGF_FILE;
|
|
|
|
/* Function Declarations */
|
|
|
|
REGF_FILE* regfio_open( const char *filename, int flags, int mode );
|
|
int regfio_close( REGF_FILE *r );
|
|
|
|
REGF_NK_REC* regfio_rootkey( REGF_FILE *file );
|
|
REGF_NK_REC* regfio_fetch_subkey( REGF_FILE *file, REGF_NK_REC *nk );
|
|
REGF_NK_REC* regfio_write_key ( REGF_FILE *file, const char *name,
|
|
struct regval_ctr *values, struct regsubkey_ctr *subkeys,
|
|
struct security_descriptor *sec_desc, REGF_NK_REC *parent );
|
|
|
|
|
|
#endif /* _REGFIO_H */
|
|
|