开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 系统/网络安全 > 杀毒 > 查看源码
HiddenReg.cpp
资源名称：OurAntiEvilTools.rar　[点击查看]
上传用户：shouhua
上传日期：2014-12-06
资源大小：5685k
文件大小：65k
源码类别：

杀毒

开发平台：

Visual C++

HiddenReg.cpp：源码内容
  1. // HiddenReg.cpp: implementation of the CHiddenReg class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  4. /*****************************************
  5. Author: Petter Nordahl-Hagen
  6. http://home.eunet.no/~pnordahl/ntpasswd/
  7. *****************************************/
  8. //n0bele 修改
  9. #include "stdafx.h"
  10. #include "..AntiEvilTools.h"
  11. #include "HiddenReg.h"
  12. #include <io.h>
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <ctype.h>
  16. #include <fcntl.h>
  17. #include <errno.h>
  18. #include <string.h>
  19. #define DOCORE 0
  20. #ifdef _DEBUG
  21. #undef THIS_FILE
  22. static char THIS_FILE[]=__FILE__;
  23. #define new DEBUG_NEW
  24. #endif
  25. const char ntreg_version[] = "ntreg lib routines, v0.92 040818, (c) Petter N Hagen";
  27. char *val_types[REG_MAX+1] = {
  28. "REG_NONE", "REG_SZ", "REG_EXPAND_SZ", "REG_BINARY", "REG_DWORD",       /* 0 - 4 */
  29. "REG_DWORD_BIG_ENDIAN", "REG_LINK",                                     /* 5 - 6 */
  30. "REG_MULTI_SZ", "REG_RESOUCE_LIST", "REG_FULL_RES_DESC", "REG_RES_REQ", /* 7 - 10 */
  31. };
  32. //////////////////////////////////////////////////////////////////////
  33. // Construction/Destruction
  34. //////////////////////////////////////////////////////////////////////
  36. CHiddenReg::CHiddenReg()
  37. {
  39. }
  41. CHiddenReg::~CHiddenReg()
  42. {
  44. }
  45. /* 工具程序 */
  46. // 复制(倾印)
  47. char *CHiddenReg::str_dup( const char *str )
  49. {
  50.     char *str_new;
  52.     if (!str)
  53.         return 0 ;
  55.     CREATE( str_new, char, strlen(str) + 1 );
  56.     strcpy( str_new, str );
  57.     return str_new;
  58. }
  60. // 提示用户，并得到用户的输入内容。
  61. // 返回值：得到用户输入的内容的长度。
  62. int CHiddenReg::fmyinput(char *prmpt, char *ibuf, int maxlen)
  63. {
  65. printf("%s",prmpt);
  67. fgets(ibuf,maxlen+1,stdin);
  69. ibuf[strlen(ibuf)-1] = 0;
  71. return(strlen(ibuf));
  72. }
  74. // 十六进制显示 
  75. void CHiddenReg::hexprnt(char *s, unsigned char *bytes, int len)
  76. {
  77. int i;
  79. printf("%s",s);
  80. for (i = 0; i < len; i++) {
  81. printf("%02x ",bytes[i]);
  82. }
  83. printf("n");
  84. }
  86. void CHiddenReg::hexdump(char *hbuf, int start, int stop, int ascii)
  87. {
  88. char c;
  89. int diff,i;
  91. while (start < stop ) {
  93. diff = stop - start;
  94. if (diff > 16) diff = 16;
  96. printf(":%05X  ",start);
  98. for (i = 0; i < diff; i++) {
  99. printf("%02X ",(unsigned char)*(hbuf+start+i));
  100. }
  101. if (ascii) {
  102. for (i = diff; i < 16; i++) printf("   ");
  103. for (i = 0; i < diff; i++) {
  104. c = *(hbuf+start+i);
  105. printf("%c", isprint(c) ? c : '.');
  106. }
  107. }
  108. printf("n");
  109. start += 16;
  110. }
  111. }
  113. int CHiddenReg::find_in_buf(char *buf, char *what, int sz, int len, int start)
  114. {
  115. int i;
  117. for (; start < sz; start++) {
  118. for (i = 0; i < len; i++) {
  119. if (*(buf+start+i) != *(what+i)) break;
  120. }
  121. if (i == len) return(start);
  122. }
  123. return(0);
  124. }
  126. int CHiddenReg::get_int( char *array )
  127. {
  128. return ((array[0]&0xff) + ((array[1]<<8)&0xff00) +
  129. ((array[2]<<16)&0xff0000) +
  130. ((array[3]<<24)&0xff000000));
  131. }
  133. void CHiddenReg::cheap_uni2ascii(char *src, char *dest, int l)
  134. {
  136. for (; l > 0; l -=2) {
  137. *dest = *src;
  138. dest++; src +=2;
  139. }
  140. *dest = 0;
  141. }
  143. void CHiddenReg::cheap_ascii2uni(char *src, char *dest, int l)
  144. {
  145. for (; l > 0; l--) 
  146. {
  147. *dest++ = *src++;
  148. *dest++ = 0;
  150. }
  151. }
  153. void CHiddenReg::skipspace(char **c)
  154. {
  155. while( **c == ' ' ) (*c)++;
  156. }
  158. int CHiddenReg::gethex(char **c)
  159. {
  160. int value;
  162. skipspace(c);
  164. if (!(**c)) return(0);
  166. sscanf(*c,"%x",&value);
  168. while( **c != ' ' && (**c)) (*c)++;
  170. return(value);
  171. }
  173. int CHiddenReg::gethexorstr(char **c, char *wb)
  174. {
  175. int l = 0;
  177. skipspace(c);
  179. if ( **c == ''') {
  180. (*c)++;
  181. while ( **c ) {
  182. *(wb++) = *((*c)++);
  183. l++;
  184. }
  185. } else {
  186. do {
  187. *(wb++) = gethex(c);
  188. l++;
  189. skipspace(c);
  190. } while ( **c );
  191. }
  192. return(l);
  193. }
  195. int CHiddenReg::debugit(char *buf, int sz)
  196. {
  199. char inbuf[100],whatbuf[100],*bp;
  201. int dirty=0,to,from,l,i,j,wlen,cofs = 0;
  203. printf("Buffer debugger. '?' for help.n");
  205. while (1) {
  206. l = fmyinput(".",inbuf,90);
  207. bp = inbuf;
  209. skipspace(&bp);
  211. if (l > 0 && *bp) {
  212. switch(*bp) {
  213. case 'd' :
  214. bp++;
  215. if (*bp) {
  216. from = gethex(&bp);
  217. to   = gethex(&bp);
  218. } else {
  219. from = cofs; to = 0;
  220. }
  221. if (to == 0) to = from + 0x100;
  222. if (to > sz) to = sz;
  223. hexdump(buf,from,to,1);
  224. cofs = to;
  225. break;
  226. case 'a' :
  227. bp++;
  228. if (*bp) {
  229. from = gethex(&bp);
  230. to   = gethex(&bp);
  231. } else {
  232. from = cofs; to = 0;
  233. }
  234. if (to == 0) to = from + 0x100;
  235. if (to > sz) to = sz;
  236. hexdump(buf,from,to,0);
  237. cofs = to;
  238. break;
  239. #if 0
  240. case 'k' :
  241. bp++;
  242. if (*bp) {
  243. from = gethex(&bp);
  244. } else {
  245. from = cofs;
  246. }
  247. if (to > sz) to = sz;
  248. parse_block(from,1);
  249. cofs = to;
  250. break;
  251. #endif
  252. #if 0
  253. case 'l' :
  254. bp++;
  255. if (*bp) {
  256. from = gethex(&bp);
  257. } else {
  258. from = cofs;
  259. }
  260. if (to > sz) to = sz;
  261. nk_ls(from+4,0);
  262. cofs = to;
  263. break;
  264. #endif
  265. case 'q':
  266. return(0);
  267. break;
  268. case 's':
  269. if (!dirty) printf("Buffer has not changed, no need to write..n");
  270. return(dirty);
  271. break;
  272. case 'h':
  273. bp++;
  274. if (*bp == 'a') {
  275. from = 0;
  276. to = sz;
  277. bp++;
  278. } else {
  279. from = gethex(&bp);
  280. to   = gethex(&bp);
  281. }
  282. wlen = gethexorstr(&bp,whatbuf);
  283. if (to > sz) to = sz;
  284. printf("from: %x, to: %x, wlen: %dn",from,to,wlen);
  285. for (i = from; i < to; i++) {
  286. for (j = 0; j < wlen; j++) {
  287. if ( *(buf+i+j) != *(whatbuf+j)) break;
  288. }
  289. if (j == wlen) printf("%06x ",i);
  290. }
  291. printf("n");
  292. break;
  293. case ':':
  294. bp++;
  295. if (!*bp) break;
  296. from = gethex(&bp);
  297. wlen = gethexorstr(&bp,whatbuf);
  299. printf("from: %x, wlen: %dn",from,wlen);
  301. memcpy(buf+from,whatbuf,wlen);
  302. dirty = 1;
  303. break;
  304. #if 0
  305. case 'p':
  306. j = 0;
  307. if (*(++bp) != 0) {
  308. from = gethex(&bp);
  309. }
  310. if (*(++bp) != 0) {
  311. j = gethex(&bp);
  312. }
  313. printf("from: %x, rid: %xn",from,j);
  314. seek_n_destroy(from,j,500,0);
  315. break;
  316. #endif
  317. case '?':
  318. printf("d [<from>] [<to>] - dump buffer within rangen");
  319. printf("a [<from>] [<to>] - same as d, but without ascii-part (for cut'n'paste)n");
  320. printf(": <offset> <hexbyte> [<hexbyte> ...] - change bytesn");
  321. printf("h <from> <to> <hexbyte> [<hexbyte> ...] - hunt (search) for bytesn");
  322. printf("ha <hexbyte> [<hexbyte] - Hunt all (whole buffer)n");
  323. printf("s - save & quitn");
  324. printf("q - quit (no save)n");
  325. printf("  instead of <hexbyte> etc. you may give 'string to enter/search a stringn");
  326. break;
  327. default:
  328. printf("?n");
  329. break;
  330.  }
  331.       }
  332.    }
  333. }
  335. void CHiddenReg::parse_nk(struct hive *hdesc, int vofs, int blen)
  336. {
  338. struct nk_key *key;
  339. int i;
  341. printf("== nk at offset %0xn",vofs);
  343. #define D_OFFS(o) ( (int *)&(key->o)-(int *)hdesc->buffer-vofs )
  345. key = (struct nk_key *)(hdesc->buffer + vofs);
  346. printf("%04x   type              = 0x%02x %sn", D_OFFS(type)  , key->type,
  347. (key->type == KEY_ROOT ? "ROOT_KEY" : "") );
  348. printf("%04x   timestamp skippedn", D_OFFS(timestamp) );
  349. printf("%04x   parent key offset = 0x%0lxn", D_OFFS(ofs_parent) ,key->ofs_parent);
  350. printf("%04x   number of subkeys = %ldn", D_OFFS(no_subkeys),key->no_subkeys);
  351. printf("%04x   lf-record offset  = 0x%0lxn",D_OFFS(ofs_lf),key->ofs_lf);
  352. printf("%04x   number of values  = %ldn", D_OFFS(no_values),key->no_values);
  353. printf("%04x   val-list offset   = 0x%0lxn",D_OFFS(ofs_vallist),key->ofs_vallist);
  354. printf("%04x   sk-record offset  = 0x%0lxn",D_OFFS(ofs_sk),key->ofs_sk);
  355. printf("%04x   classname offset  = 0x%0lxn",D_OFFS(ofs_classnam),key->ofs_classnam);
  356. printf("%04x   *unused?*         = 0x%0lxn",D_OFFS(dummy4),key->dummy4);
  357. printf("%04x   name length       = %dn", D_OFFS(len_name),key->len_name);
  358. printf("%04x   classname length  = %dn", D_OFFS(len_classnam),key->len_classnam);
  360. printf("%04x   Key name: <",D_OFFS(keyname) );
  361. for(i = 0; i < key->len_name; i++) putchar(key->keyname[i]);
  362. printf(">n== End of key info.n");
  364. }
  366. void CHiddenReg::parse_vk(struct hive *hdesc, int vofs, int blen)
  367. {
  368. struct vk_key *key;
  369. int i;
  371. printf("== vk at offset %0xn",vofs);
  374. key = (struct vk_key *)(hdesc->buffer + vofs);
  375. printf("%04x   name length       = %d (0x%0x)n", D_OFFS(len_name),
  376. key->len_name, key->len_name  );
  377. printf("%04x   length of data    = %ld (0x%0lx)n", D_OFFS(len_data),
  378. key->len_data, key->len_data  );
  379. printf("%04x   data offset       = 0x%0lxn",D_OFFS(ofs_data),key->ofs_data);
  380. printf("%04x   value type        = 0x%0lx  %sn", D_OFFS(val_type), key->val_type,
  381. (key->val_type <= REG_MAX ? val_types[key->val_type] : "(unknown)") ) ;
  383. printf("%04x   flag              = 0x%0xn",D_OFFS(flag),key->flag);
  384. printf("%04x   *unused?*         = 0x%0xn",D_OFFS(dummy1),key->dummy1);
  386. printf("%04x   Key name: <",D_OFFS(keyname) );
  387. for(i = 0; i < key->len_name; i++) putchar(key->keyname[i]);
  388. printf(">n== End of key info.n");
  390. }
  392. void CHiddenReg::parse_sk(struct hive *hdesc, int vofs, int blen)
  393. {
  394. struct sk_key *key;
  395. /* int i; */
  397. printf("== sk at offset %0xn",vofs);
  399. key = (struct sk_key *)(hdesc->buffer + vofs);
  400. printf("%04x   *unused?*         = %dn"   , D_OFFS(dummy1),     key->dummy1    );
  401. printf("%04x   Offset to prev sk = 0x%0lxn", D_OFFS(ofs_prevsk), key->ofs_prevsk);
  402. printf("%04x   Offset to next sk = 0x%0lxn", D_OFFS(ofs_nextsk), key->ofs_nextsk);
  403. printf("%04x   Usage counter     = %ld (0x%0lx)n", D_OFFS(no_usage),
  404. key->no_usage,key->no_usage);
  405. printf("%04x   Security data len = %ld (0x%0lx)n", D_OFFS(len_sk),
  406. key->len_sk,key->len_sk);
  408. printf("== End of key info.n");
  410. }
  412. void CHiddenReg::parse_lf(struct hive *hdesc, int vofs, int blen)
  413. {
  414. struct lf_key *key;
  415. int i;
  417. printf("== lf at offset %0xn",vofs);
  419. key = (struct lf_key *)(hdesc->buffer + vofs);
  420. printf("%04x   number of keys    = %dn", D_OFFS(no_keys), key->no_keys  );
  422. for(i = 0; i < key->no_keys; i++) {
  423. printf("%04x      %3d   Offset: 0x%0lx  - <%c%c%c%c>n", 
  424. D_OFFS(hash[i].ofs_nk), i,
  425. key->hash[i].ofs_nk,
  426. key->hash[i].name[0],
  427. key->hash[i].name[1],
  428. key->hash[i].name[2],
  429. key->hash[i].name[3] );
  430. }
  432. printf("== End of key info.n");
  434. }
  436. void CHiddenReg::parse_lh(struct hive *hdesc, int vofs, int blen)
  437. {
  438. struct lf_key *key;
  439. int i;
  441. printf("== lh at offset %0xn",vofs);
  443. key = (struct lf_key *)(hdesc->buffer + vofs);
  444. printf("%04x   number of keys    = %dn", D_OFFS(no_keys), key->no_keys  );
  446. for(i = 0; i < key->no_keys; i++) 
  447. {
  448. //    printf("%04x      %3d   Offset: 0x%0lx  - <hash: %08lx>n", 
  449. //    D_OFFS(lh_hash[i].ofs_nk), i,
  450. //    key->lh_hash[i].ofs_nk,
  451. //         key->lh_hash[i].hash );
  452. }
  453. printf("== End of key info.n");
  454. }
  456. void CHiddenReg::parse_li(struct hive *hdesc, int vofs, int blen)
  457. {
  458. struct li_key *key;
  459. int i;
  461. printf("== li at offset %0xn",vofs);
  463. #define D_OFFS(o) ( (int *)&(key->o)-(int *)hdesc->buffer-vofs )
  465. key = (struct li_key *)(hdesc->buffer + vofs);
  466. printf("%04x   number of keys    = %dn", D_OFFS(no_keys), key->no_keys  );
  468. for(i = 0; i < key->no_keys; i++) {
  469. printf("%04x      %3d   Offset: 0x%0lxn", 
  470. D_OFFS(hash[i].ofs_nk), i,
  471. key->hash[i].ofs_nk);
  472. }
  473. printf("== End of key info.n");
  475. }
  477. void CHiddenReg::parse_ri(struct hive *hdesc, int vofs, int blen)
  478. {
  479. struct ri_key *key;
  480. int i;
  482. printf("== ri at offset %0xn",vofs);
  484. #define D_OFFS(o) ( (int *)&(key->o)-(int *)hdesc->buffer-vofs )
  486. key = (struct ri_key *)(hdesc->buffer + vofs);
  487. printf("%04x   number of subindices = %dn", D_OFFS(no_lis), key->no_lis  );
  489. for(i = 0; i < key->no_lis; i++) {
  490. printf("%04x      %3d   Offset: 0x%0lxn", 
  491. D_OFFS(hash[i].ofs_li), i,
  492. key->hash[i].ofs_li);
  493. }
  494. printf("== End of key info.n");
  495. }
  497. void CHiddenReg::bzero(void *s,int n)
  498. {     
  499. memset(s,0,n);
  500. }
  502. int CHiddenReg::strncasecmp(const char *s1, const char *s2, size_t n)
  503. {
  504. return _stricmp(s1,s2);
  505. }
  507. int CHiddenReg::parse_block(struct hive *hdesc, int vofs,int verbose)
  508. {
  509. unsigned short id;
  510. int seglen;
  512. seglen = get_int(hdesc->buffer+vofs);  
  514. if (verbose || seglen == 0) {
  515. printf("** Block at offset %0xn",vofs);
  516. printf("seglen: %d, %u, 0x%0xn",seglen,seglen,seglen);
  517. }
  518. if (seglen == 0) {
  519. printf("Whoops! FATAL! Zero data block size! (not registry or corrupt file?)n");
  520. debugit(hdesc->buffer,hdesc->size);
  521. return(0);
  522. }
  524. if (seglen < 0) {
  525. seglen = -seglen;
  526. hdesc->usetot += seglen;
  527. hdesc->useblk++;
  528. if (verbose) {
  529. printf("USED BLOCK: %d, 0x%0xn",seglen,seglen);
  530. /*      hexdump(hdesc->buffer,vofs,vofs+seglen+4,1); */
  531. }
  532. } else {
  533. hdesc->unusetot += seglen;
  534. hdesc->unuseblk++;
  535. bzero(hdesc->buffer+vofs+4,seglen-4);
  537. if (verbose) {
  538. printf("FREE BLOCK!n"); 
  539. /*      hexdump(hdesc->buffer,vofs,vofs+seglen+4,1); */
  540. }
  541. }
  544. /*  printf("Seglen: 0x%02xn",seglen & 0xff ); */
  546. vofs += 4;
  547. id = (*(hdesc->buffer + vofs)<<8) + *(hdesc->buffer+vofs+1);
  549. if (verbose) {
  550. switch (id) {
  551. case 0x6e6b: /* nk */
  552. parse_nk(hdesc, vofs, seglen);
  553. break;
  554. case 0x766b: /* vk */
  555. parse_vk(hdesc, vofs, seglen);
  556. break;
  557. case 0x6c66: /* lf */
  558. parse_lf(hdesc, vofs, seglen);
  559. break;
  560. case 0x6c68: /* lh */
  561. parse_lh(hdesc, vofs, seglen);
  562. break;
  563. case 0x6c69: /* li */
  564. parse_li(hdesc, vofs, seglen);
  565. break;
  566. case 0x736b: /* sk */
  567. parse_sk(hdesc, vofs, seglen);
  568. break;
  569. case 0x7269: /* ri */
  570. parse_ri(hdesc, vofs, seglen);
  571. break;
  572. default:
  573. printf("value data, or not handeled yet!n");
  574. break;
  575. }
  576. }
  577. return(seglen);
  578. }
  580. int CHiddenReg::find_page_start(struct hive *hdesc, int vofs)
  581. {
  582. int r,prev;
  583. struct hbin_page *h;
  585. /* Again, assume start at 0x1000 */
  587. r = 0x1000;
  588. while (r < hdesc->size) {
  589. prev = r;
  590. h = (struct hbin_page *)(hdesc->buffer + r);
  591. if (h->id != 0x6E696268) return(0);
  592. if (h->ofs_next == 0) {
  593. printf("find_page_start: zero len or ofs_next found in page at 0x%xn",r);
  594. return(0);
  595. }
  596. r += h->ofs_next;
  597. if (r > vofs) return (prev);
  598. }
  599. return(0);
  600. }
  602. #define FB_DEBUG 0
  604. int CHiddenReg::find_free_blk(struct hive *hdesc, int pofs, int size)
  605. {
  606. int vofs = pofs + 0x20;
  607. int seglen;
  608. struct hbin_page *p;
  610. p = (struct hbin_page *)(hdesc->buffer + pofs);
  612. while (vofs-pofs < (p->ofs_next - HBIN_ENDFILL)) {
  614. seglen = get_int(hdesc->buffer+vofs);  
  616. #if FB_DEBUG
  617. printf("** Block at offset %0xn",vofs);
  618. printf("seglen: %d, %u, 0x%0xn",seglen,seglen,seglen);
  619. #endif
  621. if (seglen == 0) {
  622. printf("find_free_blk: FATAL! Zero data block size! (not registry or corrupt file?)n");
  623. debugit(hdesc->buffer,hdesc->size);
  624. return(0);
  625. }
  627. if (seglen < 0) {
  628. seglen = -seglen;
  629. #if FB_DEBUG
  630. printf("USED BLOCK: %d, 0x%0xn",seglen,seglen);
  631. #endif
  632. /*      hexdump(hdesc->buffer,vofs,vofs+seglen+4,1); */
  633. } else {
  634. #if FB_DEBUG
  635. printf("FREE BLOCK!n"); 
  636. #endif
  637. /*      hexdump(hdesc->buffer,vofs,vofs+seglen+4,1); */
  638. if (seglen >= size) {
  639. #if FB_DEBUG
  640. printf("find_free_blk: found size %d block at 0x%xn",seglen,vofs);
  641. #endif
  642. #if 0
  643. if (vofs == 0x19fb8) {
  644. printf("find_free_blk: vofs = %x, seglen = %xn",vofs,seglen);
  645. debugit(hdesc->buffer,hdesc->size);
  646. abort();
  647. }
  648. #endif
  649. return(vofs);
  650. }
  651. }
  652. vofs += seglen;
  653. }
  654. return(0);
  656. }
  658. #undef FB_DEBUG
  660. int CHiddenReg::find_free(struct hive *hdesc, int size)
  661. {
  662. int r,blk;
  663. struct hbin_page *h;
  665. /* Align to 8 byte boundary */
  666. if (size & 7) size += (8 - (size & 7));
  668. /* Again, assume start at 0x1000 */
  670. r = 0x1000;
  671. while (r < hdesc->size) {
  672. h = (struct hbin_page *)(hdesc->buffer + r);
  673. if (h->id != 0x6E696268) return(0);
  674. if (h->ofs_next == 0) {
  675. printf("find_free: zero len or ofs_next found in page at 0x%xn",r);
  676. return(0);
  677. }
  678. blk = find_free_blk(hdesc,r,size);
  679. if (blk) return (blk);
  680. r += h->ofs_next;
  681. }
  682. return(0);
  683. }
  685. int CHiddenReg::alloc_block(struct hive *hdesc, int ofs, int size)
  686. {
  687. int pofs = 0;
  688. int blk = 0;
  689. int trail, trailsize, oldsz;
  691. if (hdesc->state & HMODE_NOALLOC) {
  692. printf("alloc_block: ERROR: Hive %s is in no allocation safe mode,"
  693. "new space not allocated. Operation will fail!n", hdesc->filename);
  694. return(0);
  695. }
  697. size += 4;  /* Add linkage */
  698. if (size & 7) size += (8 - (size & 7));
  700. /* Check current page first */
  701. if (ofs) {
  702. pofs = find_page_start(hdesc,ofs);
  703. blk = find_free_blk(hdesc,pofs,size);
  704. }
  706. /* Then check whole hive */
  707. if (!blk) {
  708. blk = find_free(hdesc,size);
  709. }
  711. if (blk) {  /* Got the space */
  712. oldsz = get_int(hdesc->buffer+blk);
  713. #if 0
  714. printf("Block at         : %xn",blk);
  715. printf("Old block size is: %xn",oldsz);
  716. printf("New block size is: %xn",size);
  717. #endif
  718. trailsize = oldsz - size;
  720. if (trailsize == 4) {
  721. trailsize = 0;
  722. size += 4;
  723. }
  725. #if 1
  726. if (trailsize & 7) { /* Trail must be 8 aligned */
  727. trailsize -= (8 - (trailsize & 7));
  728. size += (8 - (trailsize & 7));
  729. }
  730. if (trailsize == 4) {
  731. trailsize = 0;
  732. size += 4;
  733. }
  734. #endif
  736. #if 0
  737. printf("trail after comp: %xn",trailsize);
  738. printf("size  after comp: %xn",size);
  739. #endif
  741. /* Now change pointers on this to reflect new size */
  742. *(int *)((hdesc->buffer)+blk) = -(size);
  743. /* If the fit was exact (unused block was same size as wee need)
  744. * there is no need for more, else make free block after end
  745. * of newly allocated one */
  747. hdesc->useblk++;
  748. hdesc->unuseblk--;
  749. hdesc->usetot += size;
  750. hdesc->unusetot -= size;
  752. if (trailsize) {
  753. trail = blk + size;
  755. *(int *)((hdesc->buffer)+trail) = (int)trailsize;
  757. hdesc->useblk++;    /* This will keep blockcount */
  758. hdesc->unuseblk--;
  759. hdesc->usetot += 4; /* But account for more linkage bytes */
  760. hdesc->unusetot -= 4;
  762. }  
  763. /* Clear the block data, makes it easier to debug */
  764. bzero( (void *)(hdesc->buffer+blk+4), size-4);
  766. hdesc->state |= HMODE_DIRTY;
  768. return(blk);
  769. } else {
  770. printf("alloc_block: failed to alloc %d bytes, and hive expansion not implemented yet!n",size);
  771. }
  772. return(0);
  773. }
  775. #define FB_DEBUG 1
  777. int CHiddenReg::free_block(struct hive *hdesc, int blk)
  778. {
  779. int pofs,vofs,seglen,prev,next,nextsz,prevsz,size;
  780. struct hbin_page *p;
  782. if (hdesc->state & HMODE_NOALLOC) {
  783. printf("free_block: ERROR: Hive %s is in no allocation safe mode,"
  784. "space not freed. Operation will fail!n", hdesc->filename);
  785. return(0);
  786. }
  788. size = get_int(hdesc->buffer+blk);
  789. if (size >= 0) {
  790. printf("free_block: trying to free already free block!n");
  791. #ifdef DOCORE
  792. printf("blk = %xn",blk);
  793. debugit(hdesc->buffer,hdesc->size);
  794. abort();
  795. #endif
  796. return(0);
  797. }
  798. size = -size;
  800. /* So, we must find start of the block BEFORE us */
  801. pofs = find_page_start(hdesc,blk);
  802. if (!pofs) return(0);
  804. p = (struct hbin_page *)(hdesc->buffer + pofs);
  805. vofs = pofs + 0x20;
  807. prevsz = -32;
  809. if (vofs != blk) {  /* Block is not at start of page? */
  810. while (vofs-pofs < (p->ofs_next - HBIN_ENDFILL) ) {
  812. seglen = get_int(hdesc->buffer+vofs);  
  814. if (seglen == 0) {
  815. printf("free_block: EEEK! Zero data block size! (not registry or corrupt file?)n");
  816. debugit(hdesc->buffer,hdesc->size);
  817. return(0);
  818. }
  820. if (seglen < 0) {
  821. seglen = -seglen;
  822. /*      hexdump(hdesc->buffer,vofs,vofs+seglen+4,1); */
  823. } 
  824. prev = vofs;
  825. vofs += seglen;
  826. if (vofs == blk) break;
  827. }
  829. if (vofs != blk) {
  830. printf("free_block: ran off end of page!?!? Error in chains?n");
  831. #ifdef DOCORE
  832. printf("vofs = %x, pofs = %x, blk = %xn",vofs,pofs,blk);
  833. debugit(hdesc->buffer,hdesc->size);
  834. abort();
  835. #endif
  836. return(0);
  837. }
  839. prevsz = get_int(hdesc->buffer+prev);
  841. }
  843. /* We also need details on next block (unless at end of page) */
  844. next = blk + size;
  846. nextsz = 0;
  847. if (next-pofs < (p->ofs_next - HBIN_ENDFILL) ) nextsz = get_int(hdesc->buffer+next);
  849. #if 0
  850. printf("offset prev : %x , blk: %x , next: %xn",prev,blk,next);
  851. printf("size   prev : %x , blk: %x , next: %xn",prevsz,size,nextsz);
  852. #endif
  854. /* Now check if next block is free, if so merge it with the one to be freed */
  855. if ( nextsz > 0) {
  856. #if 0
  857. printf("Swallow nextn");
  858. #endif
  859. size += nextsz;   /* Swallow it in current block */
  860. hdesc->useblk--;
  861. hdesc->usetot -= 4;
  862. hdesc->unusetot -= 4;
  863. }
  865. /* Now free the block (possibly with ajusted size as above) */
  866. bzero( (void *)(hdesc->buffer+blk), size);
  867. *(int *)((hdesc->buffer)+blk) = (int)size;
  868. hdesc->usetot -= size;
  869. hdesc->unusetot -= size;
  870. hdesc->unuseblk--;
  872. hdesc->state |= HMODE_DIRTY;
  874. /* Check if previous block is also free, if so, merge.. */
  875. if (prevsz > 0) {
  876. #if 0
  877. printf("Swallow prevn");
  878. #endif
  879. hdesc->usetot -= prevsz;
  880. hdesc->unusetot += prevsz;
  881. prevsz += size;
  882. /* And swallow current.. */
  883. bzero( (void *)(hdesc->buffer+prev), prevsz);
  884. *(int *)((hdesc->buffer)+prev) = (int)prevsz;
  885. hdesc->useblk--;
  886. return(prevsz);
  887. }
  888. return(size);
  889. }
  891. int CHiddenReg::ex_next_n(struct hive *hdesc, int nkofs, int *count, int *countri, struct ex_data *sptr)
  892. {
  893. struct nk_key *key, *newnkkey;
  894. int newnkofs;
  895. struct lf_key *lfkey;
  896. struct li_key *likey;
  897. struct ri_key *rikey;
  900. if (!nkofs) return(-1);
  901. key = (struct nk_key *)(hdesc->buffer + nkofs);
  902. if (key->id != 0x6b6e) {
  903. printf("ex_next error: Not a 'nk' node at 0x%0xn",nkofs);
  904. return(-1);
  905. }
  907. #define EXNDEBUG 0
  909. lfkey = (struct lf_key *)(hdesc->buffer + key->ofs_lf + 0x1004);
  910. rikey = (struct ri_key *)(hdesc->buffer + key->ofs_lf + 0x1004);
  912. if (rikey->id == 0x6972) {   /* Is it extended 'ri'-block? */
  913. #if EXNDEBUG
  914. printf("%d , %dn",*countri,*count);
  915. #endif
  916. if (*countri < 0 || *countri >= rikey->no_lis) { /* End of ri's? */
  917. return(0);
  918. }
  919. /* Get the li of lf-struct that's current based on countri */
  920. likey = (struct li_key *)( hdesc->buffer + rikey->hash[*countri].ofs_li + 0x1004 ) ;
  921. if (likey->id == 0x696c) {
  922. newnkofs = likey->hash[*count].ofs_nk + 0x1000;
  923. } else {
  924. lfkey = (struct lf_key *)( hdesc->buffer + rikey->hash[*countri].ofs_li + 0x1004 ) ;
  925. newnkofs = lfkey->hash[*count].ofs_nk + 0x1000;
  926. }
  928. /* Check if current li/lf is exhausted */
  929. #if EXNDEBUG
  930. printf("likey->no_keys = %dn",likey->no_keys);
  931. #endif
  932. if (*count >= likey->no_keys-1) { /* Last legal entry in li list? */
  933. (*countri)++;  /* Bump up ri count so we take next ri entry next time */
  934. (*count) = -1;  /* Reset li traverse counter for next round, not used later here */
  935. }
  936. } else { /* Plain handler */
  937. if (key->no_subkeys <= 0 || *count >= key->no_subkeys) {
  938. return(0);
  939. }
  940. if (lfkey->id == 0x696c) {   /* Is it 3.x 'li' instead? */
  941. likey = (struct li_key *)(hdesc->buffer + key->ofs_lf + 0x1004);
  942. newnkofs = likey->hash[*count].ofs_nk + 0x1000;
  943. } else {
  944. newnkofs = lfkey->hash[*count].ofs_nk + 0x1000;
  945. }
  946. }
  948. sptr->nkoffs = newnkofs;
  949. newnkkey = (struct nk_key *)(hdesc->buffer + newnkofs + 4);
  950. sptr->nk = newnkkey;
  952. if (newnkkey->id != 0x6b6e) {
  953. printf("ex_next: ERROR: not 'nk' node at 0x%0xn",newnkofs);
  955. return(-1);
  956. } else {
  957. if (newnkkey->len_name <= 0) {
  958. printf("ex_next: nk at 0x%0x has no name!n",newnkofs);
  959. } else {
  960. sptr->name = (char *)malloc(newnkkey->len_name+1);
  961. if (!sptr->name) {
  962. printf("FATAL! ex_next: malloc() failed! Out of memory?n");
  963. abort();
  964. }
  965. strncpy(sptr->name,newnkkey->keyname,newnkkey->len_name);
  966. sptr->name[newnkkey->len_name] = 0;
  967. }
  968. } /* if */
  969. (*count)++;
  970. return(1);
  971. /*  return( *count <= key->no_subkeys); */
  972. }
  974. int CHiddenReg::ex_next_v(struct hive *hdesc, int nkofs, int *count, struct vex_data *sptr)
  975. {
  976. struct nk_key *key /* , *newnkkey */ ;
  977. int vkofs,vlistofs;
  978. int *vlistkey;
  979. struct vk_key *vkkey;
  982. if (!nkofs) return(-1);
  983. key = (struct nk_key *)(hdesc->buffer + nkofs);
  984. if (key->id != 0x6b6e) {
  985. printf("ex_next_v error: Not a 'nk' node at 0x%0xn",nkofs);
  986. return(-1);
  987. }
  989. if (key->no_values <= 0 || *count >= key->no_values) {
  990. return(0);
  991. }
  993. vlistofs = key->ofs_vallist + 0x1004;
  994. vlistkey = (int *)(hdesc->buffer + vlistofs);
  996. vkofs = vlistkey[*count] + 0x1004;
  997. vkkey = (struct vk_key *)(hdesc->buffer + vkofs);
  998. if (vkkey->id != 0x6b76) {
  999. printf("ex_next_v: hit non valuekey (vk) node during scan at offs 0x%0xn",vkofs);
  1000. return(-1);
  1001. }
  1003. /*  parse_vk(hdesc, vkofs, 4); */
  1005. sptr->vk = vkkey;
  1006. sptr->vkoffs = vkofs;
  1007. sptr->name = 0;
  1008. sptr->size = (vkkey->len_data & 0x7fffffff);
  1010. if (vkkey->len_name >0) {
  1011. CREATE(sptr->name,char,vkkey->len_name+1);
  1012. memcpy(sptr->name,vkkey->keyname,vkkey->len_name);
  1013. sptr->name[vkkey->len_name] = 0;
  1014. } else {
  1015. sptr->name = str_dup("@");
  1016. }
  1018. sptr->type = vkkey->val_type;
  1019. if (sptr->size) {
  1020. if (vkkey->val_type == REG_DWORD) {
  1021. if (vkkey->len_data & 0x80000000) {
  1022. sptr->val = (int)(vkkey->ofs_data);
  1023. }
  1024. }
  1025. } else if (vkkey->len_data == 0x80000000) { 
  1026. /* Data SIZE is 0, high bit set: special inline case, data is DWORD and in TYPE field!! */
  1027. /* Used a lot in SAM, and maybe in SECURITY I think */
  1028. sptr->val = (int)(vkkey->val_type);
  1029. sptr->size = 4;
  1030. sptr->type = REG_DWORD;
  1031. } else {
  1032. sptr->val = 0;
  1033. sptr->size = 0;
  1034. }
  1036. (*count)++;
  1037. return( *count <= key->no_values );
  1038. }
  1040. int CHiddenReg::get_abs_path(struct hive *hdesc, int nkofs, char *path, int maxlen)
  1041. {
  1042. /* int newnkofs; */
  1043. struct nk_key *key;
  1044. char tmp[ABSPATHLEN+1];
  1046. maxlen = (maxlen < ABSPATHLEN ? maxlen : ABSPATHLEN);
  1048. key = (struct nk_key *)(hdesc->buffer + nkofs);
  1050. if (key->id != 0x6b6e) {
  1051. printf("get_abs_path: Not a 'nk' node!n");
  1052. return(0);
  1053. }
  1055. if (key->type == KEY_ROOT) {   /* We're at the root */
  1056. return(strlen(path));
  1057. }
  1059. strncpy(tmp,path,ABSPATHLEN-1);
  1061. if ( (strlen(path) + key->len_name) >= maxlen-6) {
  1062. _snprintf(path,maxlen,"(...)%s",tmp);
  1063. return(strlen(path));   /* Stop trace when string exhausted */
  1064. }
  1065. *path = '\';
  1066. memcpy(path+1,key->keyname,key->len_name);
  1067. strncpy(path+key->len_name+1,tmp,maxlen);
  1068. return(get_abs_path(hdesc, key->ofs_parent+0x1004, path, maxlen)); /* go back one more */
  1069. }
  1071. int CHiddenReg::vlist_find(struct hive *hdesc, int vlistofs, int numval, char *name)
  1072. {
  1073. struct vk_key *vkkey;
  1074. int i,vkofs;
  1075. long *vlistkey;
  1077. vlistkey = (long *)(hdesc->buffer + vlistofs);
  1079. for (i = 0; i < numval; i++) {
  1080. vkofs = vlistkey[i] + 0x1004;
  1081. vkkey = (struct vk_key *)(hdesc->buffer + vkofs);
  1082. if (vkkey->len_name == 0 && *name == '@') { /* @ is alias for nameless value */
  1083. return(i);
  1084. }
  1085. if (!strncmp(name, vkkey->keyname, strlen(name))) { /* name match? */
  1086. return(i);
  1087. }
  1088. }
  1089. return(-1);
  1090. }
  1092. int CHiddenReg::trav_path(struct hive *hdesc, int vofs, char *path, int type)
  1093. {
  1094. struct nk_key *key, *newnkkey;
  1095. struct lf_key *lfkey;
  1096. struct li_key *likey;
  1097. struct ri_key *rikey;
  1099. long *vlistkey;
  1100. int newnkofs, plen, i, lfofs, vlistofs, adjust, r, ricnt, subs;
  1101. char *buf;
  1102. char part[ABSPATHLEN+1];
  1103. char *partptr;
  1105. if (!hdesc) return(0);
  1106. buf = hdesc->buffer;
  1108. if (*path == '\' && *(path+1) != '\') {      /* Start from root if path starts with  */
  1109. path++;
  1110. vofs = hdesc->rootofs+4;
  1111. }
  1113. key = (struct nk_key *)(buf + vofs);
  1114. /*  printf("check of nk at offset: 0x%0xn",vofs); */
  1116. if (key->id != 0x6b6e) {
  1117. printf("trav_path: Error: Not a 'nk' node!n");
  1118. return(0);
  1119. }
  1121. /* Find  delimiter or end of string, copying to name part buffer as we go,
  1122. rewriting double \s */
  1123. partptr = part;
  1124. for(plen = 0; path[plen] && (path[plen] != '\' || path[plen+1] == '\'); plen++) {
  1125. if (path[plen] == '\' && path[plen+1] == '\') plen++; /* Skip one if double */
  1126. *partptr++ = path[plen];
  1127. }
  1128. *partptr = '';
  1130. /*  printf("Name component: <%s>n",part); */
  1132. adjust = (path[plen] == '\' ) ? 1 : 0;
  1133. /*  printf("Checking for <%s> with len %dn",path,plen); */
  1134. if (!plen) return(vofs-4);     /* Path has no lenght - we're there! */
  1135. if ( (plen == 1) && (*path == '.')) {     /* Handle '.' current dir */
  1136. return(trav_path(hdesc,vofs,path+plen+adjust,type));
  1137. }
  1138. if ( (plen == 2) && !strncmp("..",path,2) ) { /* Get parent key */
  1139. newnkofs = key->ofs_parent + 0x1004;
  1140. /* Return parent (or only root if at the root) */
  1141. return(trav_path(hdesc, (key->type == KEY_ROOT ? vofs : newnkofs), path+plen+adjust, type));
  1142. }
  1144. /* at last name of path, and we want vk, and the nk has values */
  1145. if (!path[plen] && type == 1 && key->no_values) {   
  1146. /*    printf("VK namematch for <%s>n",part); */
  1147. vlistofs = key->ofs_vallist + 0x1004;
  1148. vlistkey = (long *)(buf + vlistofs);
  1149. i = vlist_find(hdesc, vlistofs, key->no_values, part);
  1150. if (i != -1) {
  1151. return(vlistkey[i] + 0x1000);
  1152. }
  1153. }
  1155. if (key->no_subkeys > 0) {    /* If it has subkeys, loop through the hash */
  1156. lfofs = key->ofs_lf + 0x1004;    /* lf (hash) record */
  1157. lfkey = (struct lf_key *)(buf + lfofs);
  1159. if (lfkey->id == 0x6972) { /* ri struct need special parsing */
  1160. /* Prime loop state */
  1162. rikey = (struct ri_key *)lfkey;
  1163. ricnt = rikey->no_lis;
  1164. r = 0;
  1165. likey = (struct li_key *)( hdesc->buffer + rikey->hash[r].ofs_li + 0x1004 ) ;
  1166. subs = likey->no_keys;
  1167. if (likey->id != 0x696c) {  /* Bwah, not li anyway, XP uses lh usually which is actually smarter */
  1168. lfkey = (struct lf_key *)( hdesc->buffer + rikey->hash[r].ofs_li + 0x1004 ) ;
  1169. likey = NULL;
  1170. }
  1171. } else {
  1172. if (lfkey->id == 0x696c) { /* li? */
  1173. likey = (struct li_key *)(buf + lfofs);
  1174. } else {
  1175. likey = NULL;
  1176. }
  1177. ricnt = 0; r = 0; subs = key->no_subkeys;
  1178. }
  1180. do {
  1181. for(i = 0; i < subs; i++) {
  1182. if (likey) newnkofs = likey->hash[i].ofs_nk + 0x1004;
  1183. else newnkofs = lfkey->hash[i].ofs_nk + 0x1004;
  1184. newnkkey = (struct nk_key *)(buf + newnkofs);
  1185. if (newnkkey->id != 0x6b6e) {
  1186. printf("ERROR: not 'nk' node! (strange?)n");
  1187. } else {
  1188. if (newnkkey->len_name <= 0) {
  1189. printf("[No name]n");
  1190. } else {
  1191. if (!strncmp(part,newnkkey->keyname,plen)) {
  1192. /*     printf("Key at 0x%0x matches! recursing!n",newnkofs); */
  1193. return(trav_path(hdesc, newnkofs, path+plen+adjust, type));
  1194. }
  1195. }
  1196. } /* if id OK */
  1197. } /* hash loop */
  1198. r++;
  1199. if (ricnt && r < ricnt) {
  1200. newnkofs = rikey->hash[r].ofs_li;
  1201. likey = (struct li_key *)( hdesc->buffer + newnkofs + 0x1004 ) ;
  1202. subs = likey->no_keys;
  1203. if (likey->id != 0x696c) {  /* Bwah, not li anyway, XP uses lh usually which is actually smarter */
  1204. lfkey = (struct lf_key *)( hdesc->buffer + rikey->hash[r].ofs_li + 0x1004 ) ;
  1205. likey = NULL;
  1206. }
  1207. }
  1208. } while (r < ricnt && ricnt);
  1210. } /* if subkeys */
  1211. /* Not found */
  1212. return(0);
  1213. }
  1215. void CHiddenReg::nk_ls(struct hive *hdesc, char *path, int vofs, int type)
  1216. {
  1217. struct nk_key *key;
  1218. int nkofs;
  1219. struct ex_data ex;
  1220. struct vex_data vex;
  1221. int count = 0, countri = 0;
  1224. nkofs = trav_path(hdesc, vofs, path, 0);
  1225. if(!nkofs) {
  1226. printf("nk_ls: Key <%s> not foundn",path);
  1227. return;
  1228. }
  1229. nkofs += 4;
  1231. key = (struct nk_key *)(hdesc->buffer + nkofs);
  1232. printf("ls of node at offset 0x%0xn",nkofs);
  1234. if (key->id != 0x6b6e) {
  1235. printf("Error: Not a 'nk' node!n");
  1237. debugit(hdesc->buffer,hdesc->size);
  1239. }
  1241. printf("Node has %ld subkeys and %ld values",key->no_subkeys,key->no_values);
  1242. if (key->len_classnam) printf(", and class-data of %d bytes",key->len_classnam);
  1243. printf("n");
  1245. if (key->no_subkeys) {
  1246. printf("offs          key namen");
  1247. while ((ex_next_n(hdesc, nkofs, &count, &countri, &ex) > 0)) {
  1248. printf("[%6x]   %c  <%s>n", ex.nkoffs, (ex.nk->len_classnam)?'*':' ',ex.name);
  1249. FREE(ex.name);
  1250. }
  1251. }
  1252. count = 0;
  1253. if (key->no_values) {
  1254. printf("offs        size      type   value name                    [value if type DWORD]n");
  1255. while ((ex_next_v(hdesc, nkofs, &count, &vex) > 0)) {
  1256. printf("[%6x] %6d  %-16s  <%s>", vex.vkoffs, vex.size,
  1257. (vex.type < REG_MAX ? val_types[vex.type] : "(unknown)"), vex.name);
  1258. if (vex.type == REG_DWORD) printf(" %*d [0x%x]",25-strlen(vex.name),vex.val , vex.val);
  1259. printf("n");
  1260. FREE(vex.name);
  1261. }
  1262. }
  1263. }
  1265. int CHiddenReg::get_val_type(struct hive *hdesc, int vofs, char *path)
  1266. {
  1267. struct vk_key *vkkey;
  1268. int vkofs;
  1270. vkofs = trav_path(hdesc, vofs,path,1);
  1271. if (!vkofs) {
  1272. return -1;
  1273. }
  1274. vkofs +=4;
  1275. vkkey = (struct vk_key *)(hdesc->buffer + vkofs);
  1276. #if 0
  1277. if (vkkey->len_data & 0x80000000) return(REG_DWORD); /* Special case of INLINE storage */
  1278. #endif
  1279. return(vkkey->val_type);
  1280. }
  1282. int CHiddenReg::get_val_len(struct hive *hdesc, int vofs, char *path)
  1283. {
  1284. struct vk_key *vkkey;
  1285. int vkofs;
  1286. int len;
  1288. vkofs = trav_path(hdesc, vofs,path,1);
  1289. if (!vkofs) {
  1290. return -1;
  1291. }
  1292. vkofs +=4;
  1293. vkkey = (struct vk_key *)(hdesc->buffer + vkofs);
  1295. len = vkkey->len_data & 0x7fffffff;
  1297. if ( vkkey->len_data == 0x80000000 ) {  /* Special inline case, return size of 4 (dword) */
  1298. len = 4;
  1299. }
  1301. return(len);
  1302. }
  1304. void *CHiddenReg::get_val_data(struct hive *hdesc, int vofs, char *path, int val_type)
  1305. {
  1306. struct vk_key *vkkey;
  1307. int vkofs;
  1309. vkofs = trav_path(hdesc,vofs,path,1);
  1310. if (!vkofs) {
  1311. return NULL;
  1312. }
  1313. vkofs +=4;
  1314. vkkey = (struct vk_key *)(hdesc->buffer + vkofs);
  1317. if (vkkey->len_data == 0) return NULL;
  1318. if (vkkey->len_data == 0x80000000) {  /* Special inline case (len = 0x80000000) */
  1319. return(&vkkey->val_type); /* Data (4 bytes?) in type field */
  1320. }    
  1322. if (val_type && vkkey->val_type && (vkkey->val_type) != val_type) {
  1323. printf("Value <%s> is not of correct type!n",path);
  1324. return NULL;
  1325. }
  1327. /* Negative len is inline, return ptr to offset-field which in
  1328. * this case contains the data itself
  1329. */
  1330. if (vkkey->len_data & 0x80000000) return(&vkkey->ofs_data);
  1331. /* Normal return, return data pointer */
  1332. return(hdesc->buffer + vkkey->ofs_data + 0x1004);
  1333. }
  1335. struct keyval *CHiddenReg::get_val2buf(struct hive *hdesc, struct keyval *kv,
  1336.    int vofs, char *path, int type )
  1337. {
  1338. int l;
  1339. struct keyval *kr;
  1340. void *keydataptr;
  1342. l = get_val_len(hdesc, vofs, path);
  1343. if (l == -1) return(NULL);  /* error */
  1344. if (kv && (kv->len < l)) return(NULL); /* Check for overflow of supplied buffer */
  1346. keydataptr = get_val_data(hdesc, vofs, path, type);
  1347. /*  if (!keydataptr) return(NULL); error */
  1349. /* Allocate space for data + header, or use supplied buffer */
  1350. if (kv) {
  1351. kr = kv;
  1352. } else {
  1353. //    ALLOC(kr,1,l+sizeof(int)+4);                          修改过
  1354. kr = (keyval *)malloc(1+sizeof(int)+4);
  1355. memset(kr, 0, (1+sizeof(int)+4));
  1356. }
  1358. kr->len = l;
  1359. memcpy(&(kr->data), keydataptr, l);
  1361. return(kr);
  1362. }
  1364. int CHiddenReg::get_dword(struct hive *hdesc, int vofs, char *path)
  1365. {
  1366. struct keyval *v;
  1367. int dword;
  1368. v = get_val2buf(hdesc, NULL, vofs, path, REG_DWORD);
  1369. if (!v) return(-1); /* well... -1 COULD BE THE STORED VALUE TOO */
  1370. dword = (int)v->data;
  1371. FREE(v);
  1372. return(dword);
  1373. }
  1375. int CHiddenReg::fill_block(struct hive *hdesc, int ofs, void *data, int size)
  1376. {
  1377. int blksize;
  1379. blksize = get_int(hdesc->buffer + ofs);
  1380. blksize = -blksize;
  1382. #if 0
  1383. printf("fill_block: ofs = %x - %x, size = %x, blksize = %xn",ofs,ofs+size,size,blksize);
  1384. #endif
  1385. /*  if (blksize < size || ( (ofs & 0xfffff000) != ((ofs+size) & 0xfffff000) )) { */
  1386. if (blksize < size) {
  1387. printf("fill_block: ERROR: block to small for data: ofs = %x, size = %x, blksize = %xn",ofs,size,blksize);
  1388. debugit(hdesc->buffer,hdesc->size);
  1389. abort();
  1390. }
  1392. memcpy(hdesc->buffer + ofs + 4, data, size);
  1393. return(0);
  1394. }
  1396. int CHiddenReg::free_val_data(struct hive *hdesc, int vofs, char *path)
  1397. {
  1398. struct vk_key *vkkey;
  1399. int vkofs, inl;
  1401. vkofs = trav_path(hdesc,vofs,path,1);
  1402. if (!vkofs) {
  1403. return 0;
  1404. }
  1405. vkofs +=4;
  1406. vkkey = (struct vk_key *)(hdesc->buffer + vkofs);
  1407. inl = (vkkey->len_data & 0x80000000);
  1408. if (!inl) {
  1409. free_block(hdesc, vkkey->ofs_data + 0x1000);
  1410. }
  1411. vkkey->len_data = 0;
  1412. vkkey->ofs_data = 0;
  1413. return(vkofs);
  1414. }
  1416. int CHiddenReg::alloc_val_data(struct hive *hdesc, int vofs, char *path, int size)
  1417. {
  1418. struct vk_key *vkkey;
  1419. int vkofs, len;
  1420. int datablk;
  1422. vkofs = trav_path(hdesc,vofs,path,1);
  1423. if (!vkofs) {
  1424. return (0);
  1425. }
  1427. vkofs +=4;
  1428. vkkey = (struct vk_key *)(hdesc->buffer + vkofs);
  1430. /* Allocate space for new data */
  1431. datablk = alloc_block(hdesc, vkofs, size);
  1432. if (!datablk) return(0);
  1434. len = vkkey->len_data & 0x7fffffff;
  1436. /* Then we dealloc if something was there before */
  1437. if (len) free_val_data(hdesc,vofs,path);
  1439. /* Link in new datablock */
  1440. vkkey->ofs_data = datablk - 0x1000;
  1441. vkkey->len_data = size;
  1443. return(datablk + 4);
  1444. }
  1446. struct vk_key *CHiddenReg::add_value(struct hive *hdesc, int nkofs, char *name, int type)
  1447. {
  1448. struct nk_key *nk;
  1449. int oldvlist = 0, newvlist, newvkofs;
  1450. struct vk_key *newvkkey;
  1451. char *blank="";
  1452. if (!name || !*name) return(NULL);
  1453. nk = (struct nk_key *)(hdesc->buffer + nkofs);
  1454. if (nk->id != 0x6b6e) {
  1455. printf("add_value: Key pointer not to 'nk' node!n");
  1456. return(NULL);
  1457. }
  1458. if (trav_path(hdesc, nkofs, name, 1)) {
  1459. printf("add_value: value %s already existsn",name);
  1460. return(NULL);
  1461. }
  1462. if (!strcmp(name,"@")) name = blank;
  1463. if (nk->no_values) oldvlist = nk->ofs_vallist;
  1464. newvlist = alloc_block(hdesc, nkofs, nk->no_values * 4 + 4);
  1465. if (!newvlist) {
  1466. printf("add_value: failed to allocate new value list!n");
  1467. return(NULL);
  1468. }
  1469. if (oldvlist) {   /* Copy old data if any */
  1470. memcpy(hdesc->buffer + newvlist + 4, hdesc->buffer + oldvlist + 0x1004, nk->no_values * 4 + 4);
  1471. }
  1472. /* Allocate value descriptor including its name */
  1473. newvkofs = alloc_block(hdesc, newvlist, sizeof(struct vk_key) + strlen(name));
  1474. if (!newvkofs) {
  1475. printf("add_value: failed to allocate value descriptorn");
  1476. free_block(hdesc, newvlist);
  1477. return(NULL);
  1478. }
  1479. /* Success, now fill in the metadata */
  1480. newvkkey = (struct vk_key *)(hdesc->buffer + newvkofs + 4);
  1481. /* Add pointer in value list */
  1482. *(int *)(hdesc->buffer + newvlist + 4 + (nk->no_values * 4)) = newvkofs - 0x1000;
  1483. /* Fill in vk struct */
  1484. newvkkey->id = 0x6b76;
  1485. newvkkey->len_name = strlen(name);
  1486. if (type == REG_DWORD || type == REG_DWORD_BIG_ENDIAN) {
  1487. newvkkey->len_data = 0x80000004;  /* Prime the DWORD inline stuff */
  1488. } else {
  1489. newvkkey->len_data = 0x00000000;
  1490. }
  1491. newvkkey->ofs_data = 0;
  1492. newvkkey->val_type = type;
  1493. newvkkey->flag     = 1;   /* Don't really know what this is */
  1494. newvkkey->dummy1   = 0;
  1495. strcpy((char *)&newvkkey->keyname, name);  /* And copy name */
  1496. /* Finally update the key and free the old valuelist */
  1497. nk->no_values++;
  1498. nk->ofs_vallist = newvlist - 0x1000;
  1499. if (oldvlist) free_block(hdesc,oldvlist + 0x1000);
  1500. return(newvkkey);
  1501. }
  1503. void CHiddenReg::del_vk(struct hive *hdesc, int vkofs)
  1504. {
  1505. struct vk_key *vk;
  1506. vk = (struct vk_key *)(hdesc->buffer + vkofs);
  1507. if (vk->id != 0x6b76) {
  1508. printf("del_vk: Key pointer not to 'vk' node!n");
  1509. return;
  1510. }
  1511. if ( !(vk->len_data & 0x80000000) && vk->ofs_data)
  1512. {
  1513. free_block(hdesc, vk->ofs_data + 0x1000);
  1514. }
  1515. free_block(hdesc, vkofs - 4);
  1516. }
  1518. void CHiddenReg::del_allvalues(struct hive *hdesc, int nkofs)
  1519. {
  1520. int vlistofs, o, vkofs;
  1521. long *vlistkey;
  1522. struct nk_key *nk;
  1524. nk = (struct nk_key *)(hdesc->buffer + nkofs);
  1525. if (nk->id != 0x6b6e) {
  1526. printf("del_allvalues: Key pointer not to 'nk' node!n");
  1527. return;
  1528. }
  1530. if (!nk->no_values) {
  1531. /*    printf("del_avalues: Key has no values!n"); */
  1532. return;
  1533. }
  1535. vlistofs = nk->ofs_vallist + 0x1004;
  1536. vlistkey = (long *)(hdesc->buffer + vlistofs);
  1538. /* Loop through index and delete all vk's */
  1539. for (o = 0; o < nk->no_values; o++) {
  1540. vkofs = vlistkey[o] + 0x1004;
  1541. del_vk(hdesc, vkofs);
  1542. }
  1544. /* Then zap the index, and update nk */
  1545. free_block(hdesc, vlistofs-4);
  1546. nk->ofs_vallist = -1;
  1547. nk->no_values = 0;
  1548. }
  1550. int CHiddenReg::del_value(struct hive *hdesc, int nkofs, char *name)
  1551. {
  1552. int vlistofs, slot, o, n, vkofs, newlistofs;
  1553. long *vlistkey, *tmplist, *newlistkey;
  1554. struct nk_key *nk;
  1555. char *blank="";
  1557. if (!name || !*name) return(1);
  1559. if (!strcmp(name,"@")) name = blank;
  1561. nk = (struct nk_key *)(hdesc->buffer + nkofs);
  1562. if (nk->id != 0x6b6e) {
  1563. printf("del_value: Key pointer not to 'nk' node!n");
  1564. return(1);
  1565. }
  1567. if (!nk->no_values) {
  1568. printf("del_value: Key has no values!n");
  1569. return(1);
  1570. }
  1572. vlistofs = nk->ofs_vallist + 0x1004;
  1573. vlistkey = (long *)(hdesc->buffer + vlistofs);
  1575. slot = vlist_find(hdesc, vlistofs, nk->no_values, name);
  1577. if (slot == -1) {
  1578. printf("del_value: value %s not found!n",name);
  1579. return(1);
  1580. }
  1582. /* Delete vk and data */
  1583. vkofs = vlistkey[slot] + 0x1004;
  1584. del_vk(hdesc, vkofs);
  1586. /* Copy out old index list */
  1587. CREATE(tmplist,long,nk->no_values);
  1588. memcpy(tmplist, vlistkey, nk->no_values * sizeof(long));
  1590. free_block(hdesc,vlistofs-4);  /* Get rid of old list */
  1592. nk->no_values--;
  1594. if (nk->no_values) {
  1595. newlistofs = alloc_block(hdesc, vlistofs, nk->no_values * sizeof(long));
  1596. if (!newlistofs) {
  1597. printf("del_value: FATAL: Was not able to alloc new index listn");
  1598. abort();
  1599. }
  1600. /* Now copy over, omitting deleted entry */
  1601. newlistkey = (long *)(hdesc->buffer + newlistofs + 4);
  1602. for (n = 0, o = 0; o < nk->no_values+1; o++, n++) {
  1603. if (o == slot) o++;
  1604. newlistkey[n] = tmplist[o];
  1605. }
  1606. nk->ofs_vallist = newlistofs - 0x1000;
  1607. } else {
  1608. nk->ofs_vallist = -1;
  1609. }
  1610. return(0);
  1611. }
  1613. #undef AKDEBUG
  1614. struct nk_key *CHiddenReg::add_key(struct hive *hdesc, int nkofs, char *name)
  1615. {
  1616. int slot, newlfofs = 0, oldlfofs = 0, newliofs = 0;
  1617. int oldliofs = 0;
  1618. int o, n, i, onkofs, newnkofs, cmp;
  1619. int rimax, rislot, riofs, namlen;
  1620. struct ri_key *ri = NULL;
  1621. struct lf_key *newlf = NULL, *oldlf;
  1622. struct li_key *newli = NULL, *oldli;
  1623. struct nk_key *key, *newnk, *onk;
  1624. long hash;
  1625. key = (struct nk_key *)(hdesc->buffer + nkofs);
  1626. if (key->id != 0x6b6e) {
  1627. printf("add_key: current ptr not 'nk'n");
  1628. return(NULL);
  1629. }
  1630. namlen = strlen(name);
  1631. slot = -1;
  1632. if (key->no_subkeys) {   /* It already has subkeys */    
  1633. oldlfofs = key->ofs_lf;
  1634. oldliofs = key->ofs_lf;   
  1635. oldlf = (struct lf_key *)(hdesc->buffer + oldlfofs + 0x1004);
  1636. if (oldlf->id != 0x666c && oldlf->id != 0x686c && oldlf->id != 0x696c && oldlf->id != 0x6972)  {
  1637. printf("add_key: index type not supported: 0x%04xn",oldlf->id);
  1638. return(NULL);
  1639. }
  1640. rimax = 0; ri = NULL; riofs = 0; rislot = -1;
  1641. if (oldlf->id == 0x6972) {  /* Indirect index 'ri', init loop */
  1642. riofs = key->ofs_lf;
  1643. ri = (struct ri_key *)(hdesc->buffer + riofs + 0x1004);
  1644. rimax = ri->no_lis-1;
  1645. #ifdef AKDEBUG
  1646. printf("add_key: entering 'ri' traverse, rimax = %dn",rimax);
  1647. #endif
  1648. oldliofs = ri->hash[rislot+1].ofs_li;
  1649. oldlfofs = ri->hash[rislot+1].ofs_li;
  1650. }
  1651. do {   /* 'ri' loop, at least run once if no 'ri' deep index */
  1653. if (ri) { /* Do next 'ri' slot */
  1654. rislot++;
  1655. oldliofs = ri->hash[rislot].ofs_li;
  1656. oldlfofs = ri->hash[rislot].ofs_li;
  1657. oldli = (struct li_key *)(hdesc->buffer + oldliofs + 0x1004);
  1658. oldlf = (struct lf_key *)(hdesc->buffer + oldlfofs + 0x1004);
  1659. }
  1660. oldli = (struct li_key *)(hdesc->buffer + oldliofs + 0x1004);
  1661. oldlf = (struct lf_key *)(hdesc->buffer + oldlfofs + 0x1004);
  1662. #ifdef AKDEBUG
  1663. printf("add_key: top of ri-loop: rislot = %dn",rislot);
  1664. #endif
  1665. slot = -1;
  1666. if (oldli->id == 0x696c) {  /* li */
  1667. #ifdef AKDEBUG
  1668. printf("add_key: li slot allocaten");
  1669. #endif
  1670. FREE(newli);
  1671. // ALLOC(newli, 8 + 4*oldli->no_keys + 4, 1);          修改过
  1672. newli = (li_key *)malloc(8+4*oldli->no_keys+4);
  1673. memset(newli, 0, (88+4*oldli->no_keys+4));
  1674. newli->no_keys = oldli->no_keys;
  1675. newli->id = oldli->id;
  1677. /* Now copy old, checking where to insert (alphabetically) */
  1678. for (o = 0, n = 0; o < oldli->no_keys; o++,n++) {
  1679. onkofs = oldli->hash[o].ofs_nk;
  1680. onk = (struct nk_key *)(onkofs + hdesc->buffer + 0x1004);
  1681. if (slot == -1) {
  1682. #if 0
  1683. printf("add_key: cmp <%s> with <%s>n",name,onk->keyname);
  1684. #endif
  1685. cmp = strncasecmp(name, onk->keyname, (namlen > onk->len_name) ? namlen : onk->len_name);
  1686. if (!cmp) {
  1687. printf("add_key: key %s already exists!n",name);
  1688. FREE(newli);
  1689. return(NULL);
  1690. }
  1691. if ( cmp < 0) {
  1692. slot = o;
  1693. rimax = rislot; /* Cause end of 'ri' search, too */
  1694. n++;
  1695. #ifdef AKDEBUG
  1696. printf("add_key: li-match: slot = %dn",o);
  1697. #endif
  1698. }
  1699. }
  1700. newli->hash[n].ofs_nk = oldli->hash[o].ofs_nk;
  1701. }
  1702. if (slot == -1) slot = oldli->no_keys;
  1703. } else { /* lf or lh */
  1704. oldlf = (struct lf_key *)(hdesc->buffer + oldlfofs + 0x1004);
  1705. FREE(newlf);
  1706. // ALLOC(newlf, 8 + 8*oldlf->no_keys + 8, 1);         修改过
  1707. newlf = (lf_key*)malloc(8+8*oldlf->no_keys);
  1708. memset(newlf, 0, (8+8*oldlf->no_keys));
  1709. newlf->no_keys = oldlf->no_keys;
  1710. newlf->id = oldlf->id;
  1711. #ifdef AKDEBUG
  1712. printf("add_key: new lf/lh no_keys: %dn",newlf->no_keys);
  1713. #endif
  1715. /* Now copy old, checking where to insert (alphabetically) */
  1716. for (o = 0, n = 0; o < oldlf->no_keys; o++,n++) {
  1717. onkofs = oldlf->hash[o].ofs_nk;
  1718. onk = (struct nk_key *)(onkofs + hdesc->buffer + 0x1004);
  1719. if (slot == -1) {
  1721. #if 0
  1722. printf("add_key: cmp <%s> with <%s>n",name,onk->keyname);
  1723. #endif
  1724. cmp = strncasecmp(name, onk->keyname, (namlen > onk->len_name) ? namlen : onk->len_name);
  1725. if (!cmp) {
  1726. printf("add_key: key %s already exists!n",name);
  1727. FREE(newlf);
  1728. return(NULL);
  1729. }
  1730. if ( cmp < 0) {
  1731. slot = o;
  1732. rimax = rislot;  /* Cause end of 'ri' search, too */
  1733. n++;
  1734. #ifdef AKDEBUG
  1735. printf("add_key: lf-match: slot = %dn",o);
  1736. #endif
  1737. }
  1738. }
  1739. newlf->hash[n].ofs_nk = oldlf->hash[o].ofs_nk;
  1740. newlf->hash[n].name[0] = oldlf->hash[o].name[0];
  1741. newlf->hash[n].name[1] = oldlf->hash[o].name[1];
  1742. newlf->hash[n].name[2] = oldlf->hash[o].name[2];
  1743. newlf->hash[n].name[3] = oldlf->hash[o].name[3];
  1744. }
  1745. if (slot == -1) slot = oldlf->no_keys;
  1746. } /* li else check */
  1747. } while ( (rislot < rimax) );  /* 'ri' wrapper loop */
  1748.   } else { /* Parent was empty, make new index block */
  1749. #ifdef AKDEBUG
  1750.   printf("add_key: new index!n");
  1751. #endif
  1752.   //    ALLOC(newlf, 8 + 8, 1);                           //修改过
  1753.   newlf = (lf_key *)malloc(16);
  1754.   memset(newlf, 0, 16);
  1755.   newlf->no_keys = 1;
  1756.   /* Use ID (lf, lh or li) we fetched from root node, so we use same as rest of hive */
  1757.   newlf->id = hdesc->nkindextype;
  1758.   slot = 0;
  1759.   } /* if has keys before */
  1760.   /* Make and fill in new nk */
  1761.   newnkofs = alloc_block(hdesc, nkofs, sizeof(struct nk_key) + strlen(name));
  1762.   if (!newnkofs) {
  1763.   printf("add_key: unable to allocate space for new key descriptor for %s!n",name);
  1764.   FREE(newlf);
  1765.   FREE(newli);
  1766.   return(NULL);
  1767.   }
  1768.   newnk = (struct nk_key *)(hdesc->buffer + newnkofs + 4);  
  1769.   newnk->id            = 0x6b6e;
  1770.   newnk->type          = KEY_NORMAL;
  1771.   newnk->ofs_parent    = nkofs - 0x1004;
  1772.   newnk->no_subkeys    = 0;
  1773.   newnk->ofs_lf        = 0;
  1774.   newnk->no_values     = 0;
  1775.   newnk->ofs_vallist   = -1;
  1776.   newnk->ofs_sk        = key->ofs_sk; /* Get parents for now. 0 or -1 here crashes XP */
  1777.   newnk->ofs_classnam  = -1;
  1778.   newnk->len_name      = strlen(name);
  1779.   newnk->len_classnam  = 0;
  1780.   strcpy(newnk->keyname, name); 
  1781.   if (newli) {  /* Handle li */
  1782. #if AKDEBUG
  1783.   printf("add_key: li fill at slot: %dn",slot);
  1784. #endif
  1785.   /* And put its offset into parents index list */
  1786.   newli->hash[slot].ofs_nk = newnkofs - 0x1000;
  1787.   newli->no_keys++;    
  1788.   /* Allocate space for our new li list and copy it into reg */
  1789.   newliofs = alloc_block(hdesc, nkofs, 8 + 4*newli->no_keys);
  1790.   if (!newliofs) {
  1791.   printf("add_key: unable to allocate space for new index table for %s!n",name);
  1792.   FREE(newli);
  1793.   free_block(hdesc,newnkofs);
  1794.   return(NULL);
  1795.   }
  1796.   /*    memcpy(hdesc->buffer + newliofs + 4, newli, 8 + 4*newli->no_keys); */
  1797.   fill_block(hdesc, newliofs, newli, 8 + 4*newli->no_keys);
  1798.   } else {  /* lh or lf */
  1799. #ifdef AKDEBUG
  1800.   printf("add_key: lf/lh fill at slot: %d, rislot: %dn",slot,rislot);
  1801. #endif
  1802.   /* And put its offset into parents index list */
  1803.   newlf->hash[slot].ofs_nk = newnkofs - 0x1000;
  1804.   newlf->no_keys++;
  1805.   if (newlf->id == 0x666c) {        /* lf hash */
  1806.   newlf->hash[slot].name[0] = 0;
  1807.   newlf->hash[slot].name[1] = 0;
  1808.   newlf->hash[slot].name[2] = 0;
  1809.   newlf->hash[slot].name[3] = 0;
  1810.   strncpy(newlf->hash[slot].name, name, 4);
  1811.   } else if (newlf->id == 0x686c) {  /* lh. XP uses this. hashes whole name */
  1812.   for (i = 0,hash = 0; i < strlen(name); i++) {
  1813.   hash *= 37;
  1814.   hash += toupper(name[i]);
  1815.   }
  1816.      //   newlf->lh_hash[slot].hash = hash;            //   修改过
  1817.   }   
  1818.   /* Allocate space for our new lf list and copy it into reg */
  1819.   newlfofs = alloc_block(hdesc, nkofs, 8 + 8*newlf->no_keys);
  1820.   if (!newlfofs) {
  1821.   printf("add_key: unable to allocate space for new index table for %s!n",name);
  1822.   FREE(newlf);
  1823.   free_block(hdesc,newnkofs);
  1824.   return(NULL);
  1825.   }
  1826.   /*    memcpy(hdesc->buffer + newlfofs + 4, newlf, 8 + 8*newlf->no_keys); */
  1827.   fill_block(hdesc, newlfofs, newlf, 8 + 8*newlf->no_keys);    
  1828.   } /* li else */
  1829.   /* Update parent, and free old lf list */
  1830.   key->no_subkeys++;
  1831.   if (ri) {  /* ri index */
  1832.   ri->hash[rislot].ofs_li = (newlf ? newlfofs : newliofs) - 0x1000;
  1833.   } else { /* Parent key */
  1834.   key->ofs_lf = (newlf ? newlfofs : newliofs) - 0x1000;
  1835.   }
  1836.   if (newlf && oldlfofs) free_block(hdesc,oldlfofs + 0x1000);
  1837.   if (newli && oldliofs) free_block(hdesc,oldliofs + 0x1000);
  1838.   FREE(newlf);
  1839.   FREE(newli);
  1840.   return(newnk);
  1841. }
  1843. #undef DKDEBUG
  1845. int CHiddenReg::del_key(struct hive *hdesc, int nkofs, char *name)
  1846. {
  1848. int slot = 0, newlfofs = 0, oldlfofs = 0, o, n, onkofs,  delnkofs;
  1849. int oldliofs = 0, no_keys = 0, newriofs = 0;
  1850. int namlen;
  1851. int rimax, riofs, rislot;
  1852. struct ri_key *ri, *newri = NULL;
  1853. struct lf_key *newlf = NULL, *oldlf = NULL;
  1854. struct li_key *newli = NULL, *oldli = NULL;
  1855. struct nk_key *key, *onk, *delnk;
  1856. char fullpath[501];
  1858. key = (struct nk_key *)(hdesc->buffer + nkofs);
  1860. namlen = strlen(name);
  1862. if (key->id != 0x6b6e) {
  1863. printf("add_key: current ptr not nkn");
  1864. return(1);
  1865. }
  1867. slot = -1;
  1868. if (!key->no_subkeys) {
  1869. printf("del_key: key has no subkeys!n");
  1870. return(1);
  1871. }
  1873. oldlfofs = key->ofs_lf;
  1874. oldliofs = key->ofs_lf;
  1876. oldlf = (struct lf_key *)(hdesc->buffer + oldlfofs + 0x1004);
  1877. if (oldlf->id != 0x666c && oldlf->id != 0x686c && oldlf->id != 0x696c && oldlf->id != 0x6972)  {
  1878. printf("del_key: index other than 'lf', 'li' or 'lh' not supported yet. 0x%04xn",oldlf->id);
  1879. return(1);
  1880. }
  1882. rimax = 0; ri = NULL; riofs = 0; rislot = 0;
  1884. if (oldlf->id == 0x6972) {  /* Indirect index 'ri', init loop */
  1885. riofs = key->ofs_lf;
  1886. ri = (struct ri_key *)(hdesc->buffer + riofs + 0x1004);
  1887. rimax = ri->no_lis-1;
  1889. #ifdef DKDEBUG
  1890. printf("del_key: entering 'ri' traverse, rimax = %dn",rimax);
  1891. #endif
  1893. oldliofs = ri->hash[rislot+1].ofs_li;
  1894. oldlfofs = ri->hash[rislot+1].ofs_li;
  1896. }
  1898. do {   /* 'ri' loop, at least run once if no 'ri' deep index */
  1900. if (ri) { /* Do next 'ri' slot */
  1901. rislot++;
  1902. oldliofs = ri->hash[rislot].ofs_li;
  1903. oldlfofs = ri->hash[rislot].ofs_li;
  1904. oldli = (struct li_key *)(hdesc->buffer + oldliofs + 0x1004);
  1905. oldlf = (struct lf_key *)(hdesc->buffer + oldlfofs + 0x1004);
  1906. }
  1908. oldli = (struct li_key *)(hdesc->buffer + oldliofs + 0x1004);
  1909. oldlf = (struct lf_key *)(hdesc->buffer + oldlfofs + 0x1004);
  1911. #ifdef DKDEBUG
  1912. printf("del_key: top of ri-loop: rislot = %dn",rislot);
  1913. #endif
  1914. slot = -1;
  1916. if (oldlf->id == 0x696c) {   /* 'li' handler */
  1917. #ifdef DKDEBUG      
  1918. printf("del_key: li handlern");
  1919. #endif
  1921. FREE(newli);
  1922. //      ALLOC(newli, 8 + 4*oldli->no_keys - 4, 1);           修改过
  1923. newli = (li_key*)malloc(8+4*oldli->no_keys-4);
  1924. memset(newli, 0, 8+4*oldli->no_keys-4);
  1925. newli->no_keys = oldli->no_keys - 1; no_keys = newli->no_keys;
  1926. newli->id = oldli->id;
  1928. /* Now copy old, checking where to delete */
  1929. for (o = 0, n = 0; o < oldli->no_keys; o++,n++) {
  1930. onkofs = oldli->hash[o].ofs_nk;
  1931. onk = (struct nk_key *)(onkofs + hdesc->buffer + 0x1004);
  1932. if (slot == -1 && onk->len_name == namlen && !strncmp(name, onk->keyname, (onk->len_name > namlen) ? onk->len_name : namlen)) {
  1933. slot = o;
  1934. delnkofs = onkofs; delnk = onk;
  1935. rimax = rislot;
  1936. o++;
  1937. }
  1938. newli->hash[n].ofs_nk = oldli->hash[o].ofs_nk;
  1939. }
  1942. } else { /* 'lf' or 'lh' are similar */
  1944. #ifdef DKDEBUG
  1945. printf("del_key: lf or lh handlern");
  1946. #endif
  1947. FREE(newlf);
  1948. //      ALLOC(newlf, 8 + 8*oldlf->no_keys - 8, 1);        修改过
  1949. newlf = (lf_key *)malloc(8+8*oldlf->no_keys-8);
  1950. memset(newlf, 0, 8+8*oldlf->no_keys-8);
  1952. newlf->no_keys = oldlf->no_keys - 1; no_keys = newlf->no_keys;
  1953. newlf->id = oldlf->id;
  1955. /* Now copy old, checking where to delete */
  1956. for (o = 0, n = 0; o < oldlf->no_keys; o++,n++) {
  1957. onkofs = oldlf->hash[o].ofs_nk;
  1958. onk = (struct nk_key *)(onkofs + hdesc->buffer + 0x1004);
  1959. if (slot == -1 && (onk->len_name == namlen) && !strncmp(name, onk->keyname, onk->len_name)) {
  1960. slot = o;
  1961. delnkofs = onkofs; delnk = onk;
  1962. rimax = rislot;
  1963. o++;
  1964. }
  1965. newlf->hash[n].ofs_nk = oldlf->hash[o].ofs_nk;
  1966. newlf->hash[n].name[0] = oldlf->hash[o].name[0];
  1967. newlf->hash[n].name[1] = oldlf->hash[o].name[1];
  1968. newlf->hash[n].name[2] = oldlf->hash[o].name[2];
  1969. newlf->hash[n].name[3] = oldlf->hash[o].name[3];
  1970. }
  1971. } /* else lh or lf */
  1973. } while (rislot < rimax);  /* ri traverse loop */
  1975. if (slot == -1) {
  1976. printf("del_key: subkey %s not found!n",name);
  1977. FREE(newlf);
  1978. FREE(newli);
  1979. return(1);
  1980. }
  1982. #ifdef DKDEBUG
  1983. printf("del_key: key found at slot %dn",slot);
  1984. #endif
  1986. if (delnk->no_values || delnk->no_subkeys) {
  1987. printf("del_key: subkey %s has subkeys or values. Not deleted.n",name);
  1988. FREE(newlf);
  1989. FREE(newli);
  1990. return(1);
  1991. }
  1993. /* Allocate space for our new lf list and copy it into reg */
  1994. if ( no_keys && (newlf || newli) ) {
  1995. newlfofs = alloc_block(hdesc, nkofs, 8 + (newlf ? 8 : 4) * no_keys);
  1996. #ifdef DKDEBUG
  1997. printf("del_key: alloc_block for index returns: %xn",newlfofs);
  1998. #endif
  1999. if (!newlfofs) {
  2000. printf("del_key: WARNING: unable to allocate space for new key descriptor for %s! Not deletedn",name);
  2001. FREE(newlf);
  2002. return(1);
  2003. }
  2005. /*    memcpy(hdesc->buffer + newlfofs + 4,
  2006. ((void *)newlf ? (void *)newlf : (void *)newli), 8 + (newlf ? 8 : 4) * no_keys);
  2007. */
  2008. fill_block(hdesc, newlfofs,
  2009. ((void *)newlf ? (void *)newlf : (void *)newli), 8 + (newlf ? 8 : 4) * no_keys);
  2012. } else {  /* Last deleted, will throw away index */
  2013. newlfofs = 0xfff;  /* We subtract 0x1000 later */
  2014. }
  2016. if (newlfofs < 0xfff) {
  2017. printf("del_key: ERROR: newlfofs = %xn",newlfofs);
  2018. debugit(hdesc->buffer,hdesc->size);
  2019. abort();
  2020. }
  2022. /* Check for CLASS data, if so, deallocate it too */
  2023. if (delnk->len_classnam) {
  2024. free_block(hdesc, delnk->ofs_classnam + 0x1000);
  2025. }
  2026. /* Now it's safe to zap the nk */
  2027. free_block(hdesc, delnkofs + 0x1000);
  2028. /* And the old index list */
  2029. free_block(hdesc, (oldlfofs ? oldlfofs : oldliofs) + 0x1000);
  2031. /* Update parent */
  2032. key->no_subkeys--;
  2034. if (ri) {
  2035. if (newlfofs == 0xfff) {
  2037. *fullpath = 0;
  2038. get_abs_path(hdesc, nkofs, fullpath, 480);
  2040. printf("del_key: need to delete ri-entry! %x - %sn",nkofs,fullpath);
  2042. if (ri->no_lis > 1) {  /* We have subindiceblocks left? */
  2043. /* Delete from array */
  2044. // ALLOC(newri, 8 + 4*ri->no_lis - 4, 1);              修改过
  2045. newri = (ri_key *)malloc(8+4*ri->no_lis-4);
  2046. memset(newri, 0, 8+4*ri->no_lis-4);
  2048. newri->no_lis = ri->no_lis - 1;
  2049. newri->id = ri->id;
  2050. for (o = 0, n = 0; o < ri->no_lis; o++,n++) {
  2051. if (n == rislot) o++;
  2052. newri->hash[n].ofs_li = ri->hash[o].ofs_li;
  2053. }
  2054. newriofs = alloc_block(hdesc, nkofs, 8 + newri->no_lis*4 );
  2055. printf("del_key: alloc_block for ri-block returns: %xn",newriofs);
  2056. if (!newriofs) {
  2057. printf("del_key: WARNING: unable to allocate space for ri-index for %s! Not deletedn",name);
  2058. FREE(newlf);
  2059. FREE(newri);
  2060. return(1);
  2061. }
  2062. fill_block(hdesc, newriofs, newri, 8 + newri->no_lis * 4);
  2063. free_block(hdesc, riofs + 0x1000);
  2064. key->ofs_lf = newriofs - 0x1000;
  2065. FREE(newri);
  2066. } else { /* Last entry in ri was deleted, get rid of it, key is empty */
  2067. printf("del_key: last ri deleted for %xn",nkofs);
  2068. free_block(hdesc, riofs + 0x1000);
  2069. key->ofs_lf = -1;
  2070. }
  2071. } else {
  2072. ri->hash[rislot].ofs_li = newlfofs - 0x1000; 
  2073. }
  2074. } else {
  2075. key->ofs_lf = newlfofs - 0x1000;
  2076. }
  2077. FREE(newlf);
  2078. return(0);
  2079. }
  2081. void CHiddenReg::rdel_keys(struct hive *hdesc, char *path, int vofs)
  2082. {
  2083. struct nk_key *key;
  2084. int nkofs;
  2085. struct ex_data ex;
  2086. int count = 0, countri = 0;
  2089. if (!path || !*path) return;
  2091. nkofs = trav_path(hdesc, vofs, path, 0);
  2093. if(!nkofs) {
  2094. printf("rdel_keys: Key <%s> not foundn",path);
  2095. return;
  2096. }
  2097. nkofs += 4;
  2099. key = (struct nk_key *)(hdesc->buffer + nkofs);
  2100. #if 0
  2101. printf("rdel of node at offset 0x%0xn",nkofs);
  2102. #endif
  2103. if (key->id != 0x6b6e) {
  2104. printf("Error: Not a 'nk' node!n");
  2106. debugit(hdesc->buffer,hdesc->size);
  2108. }
  2110. #if 0
  2111. printf("Node has %ld subkeys and %ld valuesn",key->no_subkeys,key->no_values);
  2112. #endif
  2113. if (key->no_subkeys) {
  2114. while ((ex_next_n(hdesc, nkofs, &count, &countri, &ex) > 0)) {
  2115. #if 0
  2116. printf("%sn",ex.name);
  2117. #endif
  2118. rdel_keys(hdesc, ex.name, nkofs);
  2119. count = 0;
  2120. countri = 0;
  2121. FREE(ex.name);
  2122. }
  2123. }
  2124. del_allvalues(hdesc, nkofs);
  2125. del_key(hdesc, key->ofs_parent+0x1004, path);
  2126. }
  2128. struct keyval *CHiddenReg::get_class(struct hive *hdesc,
  2129.  int curnk, char *path)
  2130. {
  2131. int clen = 0, dofs = 0, nkofs;
  2132. struct nk_key *key;
  2133. struct keyval *data;
  2134. void *classdata;
  2136. if (!path && !curnk) return(NULL);
  2138. nkofs = trav_path(hdesc, curnk, path, 0);
  2140. if(!nkofs) {
  2141. printf("get_class: Key <%s> not foundn",path);
  2142. return(NULL);
  2143. }
  2144. nkofs += 4;
  2145. key = (struct nk_key *)(hdesc->buffer + nkofs);
  2147. clen = key->len_classnam;
  2148. if (!clen) {
  2149. printf("get_class: Key has no class data.n");
  2150. return(NULL);
  2151. }
  2153. dofs = key->ofs_classnam;
  2154. classdata = (void *)(hdesc->buffer + dofs + 0x1004);
  2156. #if 0
  2157. printf("get_class: len_classnam = %dn",clen);
  2158. printf("get_class: ofs_classnam = 0x%xn",dofs);
  2159. #endif
  2161. //  ALLOC(data, sizeof(struct keyval) + clen,1);         修改过
  2162. data = (keyval *)malloc(sizeof(struct keyval)+clen);
  2163. memset(data, 0, sizeof(struct keyval)+clen);
  2165. data->len = clen;
  2166. memcpy(&data->data, classdata, clen);
  2167. return(data);
  2168. }
  2170. int CHiddenReg::put_buf2val(struct hive *hdesc, struct keyval *kv,
  2171. int vofs, char *path, int type )
  2172. {
  2173. int l;
  2174. void *keydataptr;
  2176. if (!kv) return(0);
  2177. l = get_val_len(hdesc, vofs, path);
  2178. if (l == -1) return(0);  /* error */
  2179. if (kv->len != l) {  /* Realloc data block if not same size as existing */
  2180. if (!alloc_val_data(hdesc, vofs, path, kv->len)) {
  2181. printf("put_buf2val: %s : alloc_val_data failed!n",path);
  2182. return(0);
  2183. }
  2184. }
  2186. keydataptr = get_val_data(hdesc, vofs, path, type);
  2187. if (!keydataptr) return(0); /* error */
  2189. memcpy(keydataptr, &kv->data, kv->len);
  2191. hdesc->state |= HMODE_DIRTY;
  2193. return(kv->len);
  2194. }
  2196. int CHiddenReg::put_dword(struct hive *hdesc, int vofs, char *path, int dword)
  2197. {
  2198. struct keyval *kr;
  2199. int r;
  2200. //  ALLOC(kr,1,sizeof(int)+sizeof(int));            修改过
  2201. kr = (keyval *)malloc(sizeof(int)*2);
  2202. memset(kr, 0, sizeof(int)*2);
  2203. // kr = (keyval*)malloc(sizeof(int)*2);
  2204. kr->len = sizeof(int);
  2205. (int)kr->data = dword;
  2206. r = put_buf2val(hdesc, kr, vofs, path, REG_DWORD);
  2207. FREE(kr);
  2208. return(r);
  2209. }
  2211. void CHiddenReg::closeHive(struct hive *hdesc)
  2212. {
  2214. printf("closing hive %sn",hdesc->filename);
  2215. if (hdesc->state & HMODE_OPEN) 
  2216. {
  2217. //   CFile::Close(hdesc->filedesc);
  2218. close(hdesc->filedesc);
  2219. }
  2220. FREE(hdesc->filename);
  2221. FREE(hdesc->buffer);
  2222. FREE(hdesc);
  2223. }
  2225. int CHiddenReg::writeHive(struct hive *hdesc)
  2226. {
  2227. int len;
  2229. if (hdesc->state & HMODE_RO) return(0);
  2230. if ( !(hdesc->state & HMODE_DIRTY)) return(0);
  2232. if ( !(hdesc->state & HMODE_OPEN)) { /* File has been closed */
  2233. if (!(hdesc->filedesc = open(hdesc->filename,O_RDWR))) {
  2234. fprintf(stderr,"writeHive: open(%s) failed: %s, FILE NOT WRITTEN!n",hdesc->filename,strerror(errno));
  2235. return(1);
  2236. }
  2237. hdesc->state |= HMODE_OPEN;
  2238. }  
  2239. /* Seek back to begginning of file (in case it's already open) */
  2240. lseek(hdesc->filedesc, 0, SEEK_SET);
  2242. len = write(hdesc->filedesc, hdesc->buffer, hdesc->size);
  2243. if (len != hdesc->size) {
  2244. fprintf(stderr,"writeHive: write of %s failed: %s.n",hdesc->filename,strerror(errno));
  2245. return(1);
  2246. }
  2248. hdesc->state &= (~HMODE_DIRTY);
  2249. return(0);
  2250. }
  2252. struct hive *CHiddenReg::openHive(char *filename, int mode)
  2253. {
  2255. struct hive *hdesc;
  2256. int fmode,r,vofs;
  2257. //  struct stat sbuf;
  2258. unsigned long pofs;
  2259. /* off_t l; */
  2260. char *c;
  2261. struct hbin_page *p;
  2262. struct regf_header *hdr;
  2263. struct nk_key *nk;
  2264. struct ri_key *rikey;
  2265. int verbose = (mode & HMODE_VERBOSE);
  2266. CREATE(hdesc,struct hive,1);
  2267. hdesc->filename = str_dup(filename);
  2268. hdesc->state = 0;
  2269. hdesc->size = 0;
  2270. hdesc->buffer = NULL;
  2271. if ( (mode & HMODE_RO) ) {
  2272. fmode = O_RDONLY;
  2273. } else {
  2274. fmode = O_RDWR;
  2275. }
  2276. hdesc->filedesc = open(hdesc->filename,fmode);
  2277. if (hdesc->filedesc < 0) {
  2278. fprintf(stderr,"openHive(%s) failed: %s, trying read-onlyn",hdesc->filename,strerror(errno));
  2279. fmode = O_RDONLY;
  2280. mode |= HMODE_RO;
  2281. hdesc->filedesc = open(hdesc->filename,fmode);
  2282. if (hdesc->filedesc < 0) {
  2283. fprintf(stderr,"openHive(%s) in fallback RO-mode failed: %sn",hdesc->filename,strerror(errno));
  2284. closeHive(hdesc);
  2285. return(NULL);
  2286. }
  2287. }
  2288. // if ( fstat(hdesc->filedesc,&sbuf) ) {           //        修改过
  2289. //     perror("stat()");
  2290. //     exit(1);
  2291. //   }
  2292. // hdesc->size = sbuf.st_size;
  2293. // hdesc->state = mode | HMODE_OPEN;
  2294. /*  fprintf(stderr,"hiveOpen(%s) successfuln",hdesc->filename); */ 
  2295. /* Read the whole file */
  2297. //  ALLOC(hdesc->buffer,1,hdesc->size);                修改过
  2298. hdesc->buffer = (char *)malloc(hdesc->size);
  2299. memset(hdesc->buffer, 0, hdesc->size);
  2301. r = read(hdesc->filedesc,hdesc->buffer,hdesc->size);
  2302. if (r < hdesc->size) 
  2303. {
  2304. fprintf(stderr,"Could not read file, got %d bytes while expecting %dn",
  2305. r, hdesc->size);
  2306. closeHive(hdesc);
  2307. return(NULL);
  2308. }
  2309. pofs = 0x1000;
  2310. hdr = (struct regf_header *)hdesc->buffer;
  2311. if (hdr->id != 0x66676572) {
  2312. printf("openHive(%s): File does not seem to be a registry hive!n",filename);
  2313. return(hdesc);
  2314. }
  2315. printf("Hive's name (from header): <");
  2316. for (c = hdr->name; *c && (c < hdr->name + 64); c += 2) putchar(*c);
  2317. hdesc->rootofs = hdr->ofs_rootkey + 0x1000;
  2318. printf(">nROOT KEY at offset: 0x%06x * ",hdesc->rootofs);
  2319. /* Cache the roots subkey index type (li,lf,lh) so we can use the correct
  2320.     * one when creating the first subkey in a key */   
  2321. nk = (struct nk_key *)(hdesc->buffer + hdesc->rootofs + 4);
  2322. if (nk->id == 0x6b6e) {
  2323. rikey = (struct ri_key *)(hdesc->buffer + nk->ofs_lf + 0x1004);
  2324. hdesc->nkindextype = rikey->id;
  2325. if (hdesc->nkindextype == 0x6972) {  /* Gee, big root, must check indirectly */
  2326. printf("load_hive: DEBUG: BIG ROOT!n");
  2327. rikey = (struct ri_key *)(hdesc->buffer + rikey->hash[0].ofs_li + 0x1004);
  2328. hdesc->nkindextype = rikey->id;
  2329. }
  2330. if (hdesc->nkindextype != 0x666c &&
  2331. hdesc->nkindextype != 0x686c &&
  2332. hdesc->nkindextype != 0x696c) {
  2333. hdesc->nkindextype = 0x666c;
  2334. }
  2335. printf("Subkey indexing type is: %04x <%c%c>n",
  2336. hdesc->nkindextype,
  2337. hdesc->nkindextype & 0xff,
  2338. hdesc->nkindextype >> 8);
  2339. } else {
  2340. printf("load_hive: WARNING: ROOT key does not seem to be a key! (not type == nk)n");
  2341. }
  2342. while (pofs < hdesc->size) {
  2343. #ifdef LOAD_DEBUG
  2344. if (verbose) hexdump(hdesc->buffer,pofs,pofs+0x20,1);
  2345. #endif
  2346. p = (struct hbin_page *)(hdesc->buffer + pofs);
  2347. if (p->id != 0x6E696268) {
  2348. printf("Page at 0x%lx is not 'hbin', assuming file contains garbage at end",pofs);
  2349. break;
  2350. }
  2351. hdesc->pages++;
  2352. #ifdef LOAD_DEBUG
  2353. if (verbose) printf("n###### Page at 0x%0lx has size 0x%0lx, next at 0x%0lx ######n",pofs,p->len_page,p->ofs_next);
  2354. #endif
  2355. if (p->ofs_next == 0) {
  2356. #ifdef LOAD_DEBUG
  2357. if (verbose) printf("openhive debug: bailing out.. pagesize zero!n");
  2358. #endif
  2359. return(hdesc);
  2360. }
  2361. #if 0
  2362. if (p->len_page != p->ofs_next) {
  2363. #ifdef LOAD_DEBUG
  2364. if (verbose) printf("openhive debug: len & ofs not same. HASTA!n");
  2365. #endif
  2366. exit(0);
  2367. }
  2368. #endif
  2369. vofs = pofs + 0x20; /* Skip page header */
  2370. #if 1
  2371. while (vofs-pofs < p->ofs_next) {
  2372. vofs += parse_block(hdesc,vofs,verbose);
  2373. }
  2374. #endif
  2375. pofs += p->ofs_next;
  2376. }
  2377. printf("nFile size %d [%x] bytes, containing %d pages (+ 1 headerpage)n",hdesc->size,hdesc->size, hdesc->pages);
  2378. printf("Used for data: %d/%d blocks/bytes, unused: %d/%d blocks/bytes.n",
  2379. hdesc->useblk,hdesc->usetot,hdesc->unuseblk,hdesc->unusetot);
  2380. /* So, let's guess what kind of hive this is, based on keys in its root */
  2381. hdesc->type = HTYPE_UNKNOWN;
  2382. if (trav_path(hdesc, 0, "\SAM", 0)) hdesc->type = HTYPE_SAM;
  2383. else if (trav_path(hdesc, 0, "\ControlSet", 0)) hdesc->type = HTYPE_SYSTEM;
  2384. else if (trav_path(hdesc, 0, "\Policy", 0)) hdesc->type = HTYPE_SECURITY;
  2385. else if (trav_path(hdesc, 0, "\Microsoft", 0)) hdesc->type = HTYPE_SOFTWARE;
  2386. return(hdesc);
  2387. }