HiddenReg.h
上传用户:shouhua
上传日期:2014-12-06
资源大小:5685k
文件大小:15k
源码类别:

杀毒

开发平台:

Visual C++

  1. // HiddenReg.h: interface for the CHiddenReg class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  4. #if !defined(AFX_HIDDENREG_H__86CD74ED_FBED_443E_BF64_2D1769DF3529__INCLUDED_)
  5. #define AFX_HIDDENREG_H__86CD74ED_FBED_443E_BF64_2D1769DF3529__INCLUDED_
  6. #if _MSC_VER > 1000
  7. #pragma once
  8. #endif // _MSC_VER > 1000
  9. #ifndef _INCLUDE_NTREG_H
  10. #define _INCLUDE_NTREG_H 1
  11. #define SZ_MAX     4096       /* Max unicode strlen before we truncate */
  12. #define KEY_ROOT   0x2c         /* Type ID of ROOT key node */
  13. #define KEY_NORMAL 0x20       /* Normal nk key */
  14. #define ABSPATHLEN 2048
  15. #define REG_NONE                    0  /* No value type */
  16. #define REG_SZ                      1  /* Unicode nul terminated string */
  17. #define REG_EXPAND_SZ               2  /* Unicode nul terminated string + env */
  18. #define REG_BINARY                  3  /* Free form binary */
  19. #define REG_DWORD                   4  /* 32-bit number */
  20. #define REG_DWORD_BIG_ENDIAN        5  /* 32-bit number */
  21. #define REG_LINK                    6  /* Symbolic Link (unicode) */
  22. #define REG_MULTI_SZ                7  /* Multiple Unicode strings */
  23. #define REG_RESOURCE_LIST           8  /* Resource list in the resource map */
  24. #define REG_FULL_RESOURCE_DESCRIPTOR 9 /* Resource list in the hardware description */
  25. #define REG_RESOURCE_REQUIREMENTS_LIST 10
  26. #define REG_MAX 10
  27. struct regf_header {
  28.   long id;            /* 0x00000000 D-Word ID: ASCII-"regf" = 0x66676572 */
  29.   long unknown1;      /* 0x00000004 D-Word ???? */
  30.   long unknown2;      /* 0x00000008 D-Word ???? Always the same value as at 0x00000004  */
  31.   char timestamp[8];  /* 0x0000000C Q-Word last modify date in WinNT date-format */
  32.   long unknown3;      /* 0x00000014 D-Word 1 */
  33.   long unknown4;      /* 0x00000018 D-Word 3 - probably version #. 2 in NT3.51 */
  34.   long unknown5;      /* 0x0000001C D-Word 0 */
  35.   long unknown6;      /* 0x00000020 D-Word 1 */
  36.   long ofs_rootkey;   /* 0x00000024 D-Word Offset of 1st key record */
  37.   long filesize;      /* 0x00000028 D-Word Size of the data-blocks (Filesize-4kb) */
  38.   long unknown7;      /* 0x0000002C D-Word 1 */
  39.   char name[0x1fc-0x2c];   /* Seems like the hive's name is buried here, max len unknown */
  40.   long checksum;      /* 0x000001FC D-Word Sum of all D-Words from 0x00000000 to 0x000001FB */
  41. };
  42. /* The page header, I don't know if the 14 "dummy" bytes has a meaning,
  43.  * they seem to be mostly NULLS
  44.  */
  45. struct  hbin_page {
  46.   long id;          /* 0x0000 D-Word ID: ASCII-"hbin" = 0x6E696268  */
  47.   long ofs_from1;   /* 0x0004 D-Word Offset from the 1st hbin-Block */
  48.   long ofs_next;    /* 0x0008 D-Word Offset to the next hbin-Block (from THIS ONE)  */
  49.   char dummy1[14];
  50.   long len_page;    /* 0x001C D-Word Block-size??? Don't look like it,
  51.                                         I only use the next-offset in this program  */
  52.   char data[1];     /* 0x0020   First data block starts here           */
  53. };
  54. /* Minimum block size utilized at end of block
  55.  * seem to be either 8 or 16, less than this
  56.  * is only filled with garbage. (usually 0xB2 0xB2 ..)
  57.  */
  58. #define HBIN_ENDFILL 0
  59. /* Security descriptor. I know how it's linked, but don't know
  60.    how the real security data is constructed, it may as well
  61.    be like the higher level security structs defined by MS in its
  62.    includes & NT docs. Currently, I have no use for it.
  63.    Note that keys sharing the exact same security settings will
  64.    most likely point to the same security descriptor, thus
  65.    saving space and making it fast to make objects inherit settings
  66.    (is inheritance supported? they speak of security inheritance as a "new"
  67.     feature in the filesystem on NT5, even though I think it was
  68.     also supported by the lower levels in the earlier versions)
  69. */
  70. struct sk_key {
  71.   short id;          /* 0x0000 Word ID: ASCII-"sk" = 0x6B73        */
  72.   short dummy1;      /* 0x0002 Word Unused                         */
  73.   long  ofs_prevsk;  /* 0x0004 D-Word Offset of previous "sk"-Record */
  74.   long  ofs_nextsk;  /* 0x0008 D-Word Offset of next "sk"-Record     */
  75.   long  no_usage;    /* 0x000C D-Word usage-counter                  */
  76.   long  len_sk;      /* 0x0010 D-Word Size of "sk"-record in bytes   */
  77.   char  data[4];     /* Security data up to len_sk bytes               */
  78. };
  79. /* This is the subkeylist/hash structure. NT4.0+.
  80.  * ID + count, then count number of offset/4byte "hash". (not true hash)
  81.  * Probably changed from the 3.x version to make it faster to
  82.  * traverse the registry if you're looking for a specific name
  83.  * (saves lookups in 'nk's that have the first 4 name chars different)
  84.  */
  85. struct lf_key {
  86.   short id;         /* 0x0000 Word ID: ASCII-"lf" = 0x666C or "lh" = 0x686c */
  87.   short no_keys;    /* 0x0002 Word number of keys          */
  88.                     /* 0x0004 ???? Hash-Records            */
  89.   
  90.  union {
  91.     struct lf_hash {
  92.       long ofs_nk;    /* 0x0000 D-Word Offset of corresponding "nk"-Record  */
  93.       char name[4];   /* 0x0004 D-Word ASCII: the first 4 characters of the key-name,  */
  94.     } hash[1];
  95.       /* WinXP uses a more real hash instead (base 37 of uppercase name chars)  */
  96.       /*  padded with 0's. Case sensitiv!                         */
  97.     struct lh_hash {
  98.       long ofs_nk;    /* 0x0000 D-Word Offset of corresponding "nk"-Record  */
  99.       long hash;      /* 0x0004 D-Word ASCII: the first 4 characters of the key-name,  */
  100.     } lh_hash[1];
  101.   };
  102. };
  103. /* 3.x version of the above, contains only offset table, NOT
  104.  * any start of names "hash". Thus needs 'nk' lookups for searches.
  105.  */
  106. struct li_key {
  107.   short id;         /* 0x0000 Word ID: ASCII-"li" = 0x696C */
  108.   short no_keys;    /* 0x0002 Word number of keys          */
  109.                     /* 0x0004 ???? Hash-Records            */
  110.   struct li_hash {
  111.     long ofs_nk;    /* 0x0000 D-Word Offset of corresponding "nk"-Record  */
  112.   } hash[1];
  113. };
  114. /* This is a list of pointers to struct li_key, ie
  115.  * an extention record if many li's.
  116.  * This happens in NT4&5 when the lf hashlist grows larger
  117.  * than about 400-500 entries/subkeys??, then the nk_key->ofs_lf points to this
  118.  * instead of directly to an lf.
  119.  * The sub-indices this points to seems to be li (yes!) in NT4 and 2k.
  120.  * In XP and newer they point to lh which is more efficient.
  121.  * Likely to happen in HKLMSoftwareclasses (file extention list) and
  122.  * in SAM when many users.
  123.  */
  124. struct ri_key {
  125.   short id;         /* 0x0000 Word ID: ASCII-"ri" = 0x6972 */
  126.   short no_lis;    /* 0x0002 Word number of pointers to li */
  127.                     /* 0x0004 ???? Hash-Records            */
  128.   struct ri_hash {
  129.       long ofs_li;    /* 0x0000 D-Word Offset of corresponding "li"-Record  */
  130.   } hash[1];
  131. };
  132. /* This is the value descriptor.
  133.  * If the sign bit (31st bit) in the length field is set, the value is
  134.  * stored inline this struct, and not in a seperate data chunk -
  135.  * the data then seems to be in the type field, and maybe also
  136.  * in the flag and dummy1 field if -len > 4 bytes
  137.  * If the name size == 0, then the struct is probably cut short right
  138.  * after the val_type or flag.
  139.  * The flag meaning is rather unknown.
  140.  */
  141. struct vk_key {
  142.                     /* Offset Size Contents                 */
  143.   short id;         /* 0x0000 Word ID: ASCII-"vk" = 0x6B76  */
  144.   short len_name;   /* 0x0002 Word name length              */
  145.   long  len_data;   /* 0x0004 D-Word length of the data       */
  146.   long  ofs_data;   /* 0x0008 D-Word Offset of Data           */
  147.   long  val_type;   /* 0x000C D-Word Type of value            */
  148.   short flag;       /* 0x0010 Word Flag                     */
  149.   short dummy1;     /* 0x0012 Word Unused (data-trash)      */
  150.   char  keyname[1]; /* 0x0014 ???? Name                     */
  151. };
  152. /* This is the key node (ie directory) descriptor, can contain subkeys and/or values.
  153.  * Note that for values, the count is stored here, but for subkeys
  154.  * there's a count both here and in the offset-table (lf or li struct).
  155.  * What happens if these mismatch is not known.
  156.  * What's the classname thingy? Can't remember seeing that used in
  157.  * anything I've looked at.
  158.  */
  159. struct nk_key {
  160.                         /* Offset Size Contents */
  161.   short id;             /*  0x0000 Word ID: ASCII-"nk" = 0x6B6E                */
  162.   short type;           /*  0x0002 Word for the root-key: 0x2C, otherwise 0x20 */
  163.   char  timestamp[12];  /*  0x0004 Q-Word write-date/time in windows nt notation */
  164.   long  ofs_parent;     /*  0x0010 D-Word Offset of Owner/Parent key             */
  165.   long  no_subkeys;     /*  0x0014 D-Word number of sub-Keys                     */
  166.   char  dummy1[4];
  167.   long  ofs_lf;         /*  0x001C D-Word Offset of the sub-key lf-Records       */
  168.   char  dummy2[4];
  169.   long  no_values;      /*  0x0024 D-Word number of values                       */
  170.   long  ofs_vallist;    /*  0x0028 D-Word Offset of the Value-List               */
  171.   long  ofs_sk;         /*  0x002C D-Word Offset of the sk-Record                */
  172.   long  ofs_classnam;   /*  0x0030 D-Word Offset of the Class-Name               */
  173.   char  dummy3[16];
  174.   long  dummy4;         /*  0x0044 D-Word Unused (data-trash)                    */
  175.   short len_name;       /*  0x0048 Word name-length                            */
  176.   short len_classnam;   /*  0x004A Word class-name length                      */
  177.   char  keyname[1];     /*  0x004C ???? key-name                               */
  178. };
  179. /*********************************************************************************/
  180. /* Structure defines for my routines */
  181. struct ex_data {
  182.   int nkoffs;
  183.   struct nk_key *nk;
  184.   char *name;
  185. };
  186. struct vex_data {
  187.   int vkoffs;
  188.   struct vk_key *vk;
  189.   int type;       /* Value type REG_??? */
  190.   int size;       /* Values size (normalized, inline accounted for) */
  191.   int val;        /* Actual value itself if type==REG_DWORD */
  192.   char *name;
  193. };
  194. struct keyval {
  195.   int len;      /* Length of databuffer */
  196.   int data;    /* Data. Goes on for length of value */
  197. };
  198. struct keyvala {
  199.   int len;      /* Length of databuffer */
  200.   int data[1];    /* Data. Goes on for length of value */
  201. };
  202. #define HMODE_RW        0
  203. #define HMODE_RO        0x1
  204. #define HMODE_OPEN      0x2
  205. #define HMODE_DIRTY     0x4
  206. #define HMODE_NOALLOC   0x8
  207. #define HMODE_VERBOSE 0x1000
  208. /* Suggested type of hive loaded, guessed by library, but not used by it */
  209. #define HTYPE_UNKNOWN   0
  210. #define HTYPE_SAM       1
  211. #define HTYPE_SYSTEM    2
  212. #define HTYPE_SECURITY  3
  213. #define HTYPE_SOFTWARE  4
  214. /* Hive definition, allocated by openHive(), dealloc by closeHive()
  215.  * contains state data, must be passed in all functions
  216.  */
  217. struct hive {
  218.   char *filename;        /* Hives filename */
  219.   int  filedesc;         /* File descriptor (only valid if state == OPEN) */
  220.   int  state;            /* Current state of hive */
  221.   int  type;             /* Suggested type of hive. NOTE: Library will guess when
  222.     it loads it, but application may change it if needed */
  223.   int  pages;            /* Number of pages, total */
  224.   int  useblk;           /* Total # of used blocks */
  225.   int  unuseblk;         /* Total # of unused blocks */
  226.   int  usetot;           /* total # of bytes in useblk */
  227.   int  unusetot;         /* total # of bytes in unuseblk */
  228.   int  size;             /* Hives size (filesise) in bytes */
  229.   int  rootofs;          /* Offset of root-node */
  230.   short nkindextype;     /* Subkey-indextype the root key uses */
  231.   char *buffer;          /* Files raw contents */
  232. };
  233. /***************************************************/
  234. /* Various nice macros */
  235. #define CREATE(result, type, number)
  236.     { 
  237.         if (!((result) = (type *) calloc ((number), sizeof(type)))) { 
  238.             perror("malloc failure"); 
  239.             abort() ; 
  240.        } 
  241.     }
  242. #define ALLOC(result, size, number)
  243.     { 
  244.         if (!((result) =  (void *)calloc ((number), (size)))) { 
  245.             perror("malloc failure"); 
  246.             abort() ; 
  247.        } 
  248.     }
  249. #define FREE(p) { if (p) { free(p); (p) = 0; } }
  250. #endif
  251. class CHiddenReg  
  252. {
  253. public:
  254. CHiddenReg();
  255. char *str_dup( const char *str );
  256. int fmyinput(char *prmpt, char *ibuf, int maxlen);
  257. void hexprnt(char *s, unsigned char *bytes, int len);
  258. void hexdump(char *hbuf, int start, int stop, int ascii);
  259. int find_in_buf(char *buf, char *what, int sz, int len, int start);
  260. int get_int( char *array );
  261. void cheap_uni2ascii(char *src, char *dest, int l);
  262. void cheap_ascii2uni(char *src, char *dest, int l);
  263. void skipspace(char **c);
  264. int gethex(char **c);
  265. int gethexorstr(char **c, char *wb);
  266. int debugit(char *buf, int sz);
  267. int ex_next_v(struct hive *hdesc, int nkofs, int *count, struct vex_data *sptr);
  268. int get_abs_path(struct hive *hdesc, int nkofs, char *path, int maxlen);
  269. int trav_path(struct hive *hdesc, int vofs, char *path, int type);
  270. int get_val_type(struct hive *hdesc, int vofs, char *path);
  271. int get_val_len(struct hive *hdesc, int vofs, char *path);
  272. void *get_val_data(struct hive *hdesc, int vofs, char *path, int val_type);
  273. struct keyval *get_val2buf(struct hive *hdesc, struct keyval *kv,int vofs, char *path, int type );
  274. int get_dword(struct hive *hdesc, int vofs, char *path);
  275. int put_buf2val(struct hive *hdesc, struct keyval *kv,int vofs, char *path, int type );
  276. int put_dword(struct hive *hdesc, int vofs, char *path, int dword);
  277. void closeHive(struct hive *hdesc);
  278. int writeHive(struct hive *hdesc);
  279. struct hive *openHive(char *filename, int mode);
  280. void parse_nk(struct hive *hdesc, int vofs, int blen);
  281. void parse_vk(struct hive *hdesc, int vofs, int blen);
  282. void parse_sk(struct hive *hdesc, int vofs, int blen);
  283. void parse_lf(struct hive *hdesc, int vofs, int blen);
  284. void parse_lh(struct hive *hdesc, int vofs, int blen);
  285. void parse_li(struct hive *hdesc, int vofs, int blen);
  286. void parse_ri(struct hive *hdesc, int vofs, int blen);
  287. void bzero(void *s,int n);
  288. int strncasecmp(const char *s1, const char *s2, size_t n);
  289. int parse_block(struct hive *hdesc, int vofs,int verbose);
  290. int find_page_start(struct hive *hdesc, int vofs);
  291. int find_free_blk(struct hive *hdesc, int pofs, int size);
  292. int find_free(struct hive *hdesc, int size);
  293. int alloc_block(struct hive *hdesc, int ofs, int size);
  294. int free_block(struct hive *hdesc, int blk);
  295. int ex_next_n(struct hive *hdesc, int nkofs, int *count, int *countri, struct ex_data *sptr);
  296. void nk_ls(struct hive *hdesc, char *path, int vofs, int type);
  297. int fill_block(struct hive *hdesc, int ofs, void *data, int size);
  298. int free_val_data(struct hive *hdesc, int vofs, char *path);
  299. void del_vk(struct hive *hdesc, int vkofs);
  300. int alloc_val_data(struct hive *hdesc, int vofs, char *path, int size);
  301. int vlist_find(struct hive *hdesc, int vlistofs, int numval, char *name);
  302. struct vk_key *add_value(struct hive *hdesc, int nkofs, char *name, int type);
  303. void del_allvalues(struct hive *hdesc, int nkofs);
  304. int del_value(struct hive *hdesc, int nkofs, char *name);
  305. struct nk_key *add_key(struct hive *hdesc, int nkofs, char *name);
  306. int del_key(struct hive *hdesc, int nkofs, char *name);
  307. void rdel_keys(struct hive *hdesc, char *path, int nkofs);
  308. struct keyval *get_class(struct hive *hdesc, int curnk, char *path);
  309. virtual ~CHiddenReg();
  310. };
  311. #endif // !defined(AFX_HIDDENREG_H__86CD74ED_FBED_443E_BF64_2D1769DF3529__INCLUDED_)