另类DLL加载方法 —— PEAnalyais

本文详细介绍了PE文件解析方法，C++源码示例介绍如何解析PE文件从而打造自己的GetProcAddress，从资源文件中调用dll函数(无需释放文件)

转载：http://blog.csdn.net/wangningyu/article/details/8716586

先看图：

代码如下：

1、测试DLL

[cpp] view plaincopyprint?

1. BOOL __stdcall MsgBox(char *pszText,char *pszTitle)  
2. {  
3.     return ::MessageBoxA(NULL,pszText,pszTitle,MB_OK | MB_ICONINFORMATION);  
4. }  
5.   
6. BOOL APIENTRY DllMain( HMODULE hModule,  
7.                        DWORD  ul_reason_for_call,  
8.                        LPVOID lpReserved  
9.                      )  
10. {  
11.     switch (ul_reason_for_call)  
12.     {  
13.     case DLL_PROCESS_ATTACH:  
14.     case DLL_THREAD_ATTACH:  
15.     case DLL_THREAD_DETACH:  
16.     case DLL_PROCESS_DETACH:  
17.         break;  
18.     }  
19.     return TRUE;  
20. }  

2、测试工程

      XPEAnalyais.h

[cpp] view plaincopyprint?

1. //////////////////////////////////////////////////////////////////////////  
2. // XPEAnalyais.h  
3. // dll loader by Koma  
4. // 感谢C++侦探、201724  
5. // http://blog.csdn.net/wangningyu  
6.   
7. #ifndef PEANALYSIS_H  
8. #define PEANALYSIS_H  
9.   
10. PIMAGE_NT_HEADERS AnalyaisImage(HMODULE hModule);  
11. FARPROC __stdcall MyGetProcAddress(HMODULE hModule,LPCSTR name);  
12. HMODULE LoadLibraryByFile(const char * pszDllPath);  
13. HMODULE LoadLibraryByResource(WORD wResID,char *pszFileType);  
14. DWORD GetPECodeEnd(HMODULE hModule);  
15. DWORD GetPEImageEnd(HMODULE hModule);  
16. DWORD GetPEImageSize(HMODULE hModule);  
17. DWORD GetCodeSize(HMODULE hModule);  
18.   
19. #endif  

      XPEAnalyais.cpp

[cpp] view plaincopyprint?

1. //////////////////////////////////////////////////////////////////////////  
2. // XPEAnalyais.cpp  
3. // dll loader by Koma  
4. // 感谢C++侦探、201724  
5. // http://blog.csdn.net/wangningyu  
6.   
7. #include "stdafx.h"  
8. #include "XPEAnalyais.h"  
9. #include <stdio.h>  
10. #include <assert.h>  
11.   
12. typedef BOOL (__stdcall * fnDllMain)(HINSTANCE hModule,DWORD dwReason,LPVOID lpvReserved);  
13.   
14. PIMAGE_NT_HEADERS AnalyaisImage(HMODULE hModule)  
15. {  
16.     PBYTE pImage = (PBYTE)hModule;  
17.     PIMAGE_DOS_HEADER pImageDosHeader;  
18.     PIMAGE_NT_HEADERS pImageNtHeader;  
19.     pImageDosHeader = (PIMAGE_DOS_HEADER)pImage;  
20.     if(pImageDosHeader->e_magic==IMAGE_DOS_SIGNATURE)  
21.     {  
22.         pImageNtHeader = (PIMAGE_NT_HEADERS)&pImage[pImageDosHeader->e_lfanew];  
23.         if(pImageNtHeader->Signature==IMAGE_NT_SIGNATURE)  
24.         {  
25.             return pImageNtHeader;  
26.         }  
27.     }  
28.     return NULL;  
29. }  
30.   
31. FARPROC __stdcall MyGetProcAddress(HMODULE hModule,LPCSTR name)  
32. {  
33.     if(!hModule)  
34.     {  
35.         hModule = GetModuleHandle(0);  
36.     }  
37.     PBYTE pDest = (PBYTE)hModule;  
38.     PIMAGE_DOS_HEADER pImageDosDest;  
39.     PIMAGE_NT_HEADERS pImageNtDest;  
40.     PIMAGE_DATA_DIRECTORY pDirectory;  
41.     PIMAGE_EXPORT_DIRECTORY pExport;  
42.     DWORD i, *nameRef;  
43.     WORD *ordinal;  
44.     int idx=-1;  
45.     pImageDosDest = (PIMAGE_DOS_HEADER)pDest;  
46.     pImageNtDest = (PIMAGE_NT_HEADERS)&pDest[pImageDosDest->e_lfanew];  
47.     pDirectory = &pImageNtDest->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];  
48.       
49.     if(pDirectory->Size==0)  
50.         return NULL;  
51.     pExport = (PIMAGE_EXPORT_DIRECTORY)((DWORD)pDest + pDirectory->VirtualAddress);  
52.       
53.     if(pExport->NumberOfNames == 0 || pExport->NumberOfFunctions == 0)  
54.         return NULL;  
55.     ordinal = (WORD *) ((DWORD)pDest + pExport->AddressOfNameOrdinals);  
56.     if((DWORD)(name) < 0x10000)  
57.     {  
58.         if ((DWORD)name >= pExport->NumberOfFunctions+pExport->Base || (DWORD)name < pExport->Base)  
59.             return NULL;  
60.         idx = (DWORD)pDest+((DWORD*)((DWORD)pDest+pExport->AddressOfFunctions))[(DWORD)name-pExport->Base];  
61.     }else  
62.     {  
63.         nameRef = (DWORD *) ((DWORD)pDest + pExport->AddressOfNames);  
64.         for (i=0; i<pExport->NumberOfNames; i++, nameRef++, ordinal++) {  
65.             if (strcmp(name, (const char *) ((DWORD)pDest + (*nameRef))) == 0) {  
66.                 idx = *ordinal;  
67.                 break;  
68.             }  
69.         }  
70.     }  
71.     if (idx == -1) {  
72.         return NULL;  
73.     }  
74.     if ((DWORD)idx > pExport->NumberOfFunctions) {  
75.         return NULL;  
76.     }  
77.     return (FARPROC) ((DWORD)hModule + (*(DWORD *) ((DWORD)hModule + pExport->AddressOfFunctions + (idx*4))));  
78. }  
79. void CopySection(PBYTE pSrc,PBYTE pDest)  
80. {  
81.     unsigned int i,size;  
82.     PIMAGE_DOS_HEADER pImageDosSrc;  
83.     PIMAGE_NT_HEADERS pImageNtSrc;  
84.     PIMAGE_DOS_HEADER pImageDosDest;  
85.     PIMAGE_NT_HEADERS pImageNtDest;  
86.     PIMAGE_SECTION_HEADER pSection;  
87.     pImageDosSrc = (PIMAGE_DOS_HEADER)pSrc;  
88.     pImageNtSrc = (PIMAGE_NT_HEADERS)&pSrc[pImageDosSrc->e_lfanew];  
89.   
90.     pImageDosDest = (PIMAGE_DOS_HEADER)pDest;  
91.     pImageNtDest = (PIMAGE_NT_HEADERS)&pDest[pImageDosDest->e_lfanew];  
92.     pSection = IMAGE_FIRST_SECTION(pImageNtDest);  
93.     for(i=0;i<pImageNtDest->FileHeader.NumberOfSections;i++,pSection++)  
94.     {  
95.         if(pSection->SizeOfRawData == 0)  
96.         {  
97.             size = pImageNtSrc->OptionalHeader.SectionAlignment;  
98.             if(size > 0)  
99.             {  
100.                 pSection->Misc.PhysicalAddress = pSection->VirtualAddress + (DWORD)pDest;  
101.                 memset((PVOID)pSection->Misc.PhysicalAddress,0,size);  
102.             }  
103.             continue;  
104.         }  
105.         pSection->Misc.PhysicalAddress = pSection->VirtualAddress + (DWORD)pDest;  
106.         memcpy((PVOID)pSection->Misc.PhysicalAddress, (PVOID)((DWORD)pSrc + pSection->PointerToRawData), pSection->SizeOfRawData);  
107.     }  
108. }  
109. void GetImportInfo(DWORD imgbase,DWORD impoff)  
110. {  
111.     PIMAGE_IMPORT_DESCRIPTOR pImport = (PIMAGE_IMPORT_DESCRIPTOR)(imgbase+impoff);  
112.     HMODULE hModuleSys;  
113.     DWORD i,p;  
114.     PIMAGE_THUNK_DATA32 pimpthunk;  
115.     PIMAGE_IMPORT_BY_NAME pimpname;  
116.     FARPROC* pimpwrite;  
117.     FARPROC pFunc;  
118.     for(i=0;pImport[i].Characteristics!=0;i++)  
119.     {     
120.         hModuleSys = LoadLibraryA((LPCSTR)(pImport[i].Name + imgbase));  
121.         pimpthunk = (PIMAGE_THUNK_DATA32)(pImport[i].OriginalFirstThunk + imgbase);  
122.         pimpwrite = (FARPROC*)(pImport[i].FirstThunk + imgbase);  
123.         for(p=0;pimpthunk[p].u1.AddressOfData!=0;p++)  
124.         {  
125.             pimpname = (PIMAGE_IMPORT_BY_NAME)((DWORD)pimpthunk[p].u1.AddressOfData+imgbase);  
126.             if(IMAGE_SNAP_BY_ORDINAL32(pimpthunk[p].u1.AddressOfData))  
127.             {  
128.                 pFunc = GetProcAddress(hModuleSys,(LPCSTR)IMAGE_ORDINAL(pimpthunk[p].u1.AddressOfData));  
129.                 pimpwrite[p] = pFunc;  
130.             }else  
131.             {  
132.                 pFunc = GetProcAddress(hModuleSys,(LPCSTR)&pimpname->Name);  
133.                 pimpwrite[p] = pFunc;  
134.             }  
135.         }  
136.     }  
137. }  
138. void LoadImport(PBYTE pSrc,PBYTE pDest)  
139. {  
140.     PIMAGE_DOS_HEADER pImageDosSrc;  
141.     PIMAGE_NT_HEADERS pImageNtSrc;  
142.     PIMAGE_DOS_HEADER pImageDosDest;  
143.     PIMAGE_NT_HEADERS pImageNtDest;   
144.     PIMAGE_DATA_DIRECTORY pDirectory;  
145.     pImageDosSrc = (PIMAGE_DOS_HEADER)pSrc;  
146.     pImageNtSrc = (PIMAGE_NT_HEADERS)&pSrc[pImageDosSrc->e_lfanew];  
147.       
148.     pImageDosDest = (PIMAGE_DOS_HEADER)pDest;  
149.     pImageNtDest = (PIMAGE_NT_HEADERS)&pDest[pImageDosDest->e_lfanew];  
150.   
151.     pDirectory = &pImageNtDest->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];  
152.     if(!pDirectory->VirtualAddress)  
153.         return;  
154.     GetImportInfo((DWORD)pDest,pDirectory->VirtualAddress);  
155. }  
156.   
157. bool check_import(HMODULE hModule)  
158. {  
159.     PBYTE pImage = (PBYTE)hModule;  
160.     PIMAGE_DOS_HEADER pImageDos;  
161.     PIMAGE_NT_HEADERS pImageNT;  
162.     PIMAGE_DATA_DIRECTORY pDataDirectory;  
163.     PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor;  
164.     pImageDos = (PIMAGE_DOS_HEADER)pImage;  
165.     pImageNT = (PIMAGE_NT_HEADERS)&pImage[pImageDos->e_lfanew];  
166.   
167.     pDataDirectory = &pImageNT->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];  
168.     if(!pDataDirectory->VirtualAddress)  
169.         return false;  
170.     pImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)&pImage[pDataDirectory->VirtualAddress];  
171.   
172.     for(int i=0;pImportDescriptor[i].Characteristics!=0;i++)  
173.     {  
174.         HMODULE hCurrentModule = LoadLibraryA((LPCSTR)(&pImage[pImportDescriptor[i].Name]));  
175.         PIMAGE_THUNK_DATA32 pCurrentImportThunk = (PIMAGE_THUNK_DATA32)(&pImage[pImportDescriptor[i].OriginalFirstThunk]);  
176.         FARPROC* pCurrentImportList = (FARPROC*)(&pImage[pImportDescriptor[i].FirstThunk]);  
177.         for(int m_imp=0;pCurrentImportThunk[m_imp].u1.AddressOfData!=0;m_imp++)  
178.         {  
179.             if(IMAGE_SNAP_BY_ORDINAL32(pCurrentImportThunk[m_imp].u1.AddressOfData))  
180.             {  
181.                 if(pCurrentImportList[m_imp] != GetProcAddress(hCurrentModule,(LPCSTR)IMAGE_ORDINAL(pCurrentImportThunk[m_imp].u1.AddressOfData)))  
182.                     return false;  
183.             }else  
184.             {  
185.                 if(pCurrentImportList[m_imp] != GetProcAddress(hCurrentModule,(LPCSTR)&((PIMAGE_IMPORT_BY_NAME)&pImage[pCurrentImportThunk[m_imp].u1.AddressOfData])->Name))  
186.                     return false;  
187.             }  
188.         }  
189.     }  
190.     return true;  
191. }  
192. void FixupResource(PBYTE pDest)  
193. {  
194.     DWORD imagebase;  
195.     PIMAGE_RESOURCE_DIRECTORY pRes;  
196.     PIMAGE_RESOURCE_DIRECTORY_ENTRY pEntry;  
197.     DWORD nEntries;  
198.     DWORD i;  
199.     PIMAGE_RESOURCE_DIRECTORY pRes2;  
200.     PIMAGE_RESOURCE_DIRECTORY_ENTRY pEntry2;  
201.     DWORD nEntries2;  
202.     PIMAGE_RESOURCE_DIR_STRING_U pDirStr;  
203.     PIMAGE_RESOURCE_DIRECTORY pRes3;  
204.     PIMAGE_RESOURCE_DIRECTORY_ENTRY pEntry3;  
205.     DWORD nEntries3;  
206.     DWORD j;  
207.     DWORD k;  
208.     PIMAGE_RESOURCE_DATA_ENTRY pData;  
209.     PIMAGE_DOS_HEADER pImageDosDest;  
210.     PIMAGE_NT_HEADERS pImageNtDest;   
211.       
212.     pImageDosDest = (PIMAGE_DOS_HEADER)pDest;  
213.     pImageNtDest = (PIMAGE_NT_HEADERS)&pDest[pImageDosDest->e_lfanew];  
214.     imagebase = pImageNtDest->OptionalHeader.ImageBase;  
215.     if(!pImageNtDest->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress)  
216.         return;  
217.     pRes = (PIMAGE_RESOURCE_DIRECTORY)(imagebase + pImageNtDest->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);  
218.     nEntries = pRes->NumberOfIdEntries + pRes->NumberOfNamedEntries;  
219.     pEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)pRes + sizeof(IMAGE_RESOURCE_DIRECTORY));  
220.     for (i = 0; i < nEntries; ++i, ++pEntry) {  
221.           
222.         if (IMAGE_RESOURCE_DATA_IS_DIRECTORY & pEntry->OffsetToData) {  
223.             pRes2 = (PIMAGE_RESOURCE_DIRECTORY)((DWORD)pRes  
224.                 + (~IMAGE_RESOURCE_DATA_IS_DIRECTORY & pEntry->OffsetToData));  
225.             nEntries2 = pRes2->NumberOfIdEntries + pRes2->NumberOfNamedEntries;  
226.             pEntry2 = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)pRes2 + sizeof(IMAGE_RESOURCE_DIRECTORY));  
227.   
228.             for (j = 0; j < nEntries2; ++j, ++pEntry2) {  
229.                 if (IMAGE_RESOURCE_NAME_IS_STRING & pEntry2->Name) {  
230.                       
231.                     pDirStr = (PIMAGE_RESOURCE_DIR_STRING_U)((DWORD)pRes  
232.                         + (~IMAGE_RESOURCE_NAME_IS_STRING & pEntry2->Name));  
233.                 }  
234.                 if (IMAGE_RESOURCE_DATA_IS_DIRECTORY & pEntry2->OffsetToData) {  
235.                     pRes3 = (PIMAGE_RESOURCE_DIRECTORY)((DWORD)pRes  
236.                         + (~IMAGE_RESOURCE_DATA_IS_DIRECTORY & pEntry2->OffsetToData));  
237.                     nEntries3 = pRes3->NumberOfIdEntries + pRes3->NumberOfNamedEntries;  
238.                     pEntry3 = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)pRes3 + sizeof(IMAGE_RESOURCE_DIRECTORY));  
239.   
240.                     for (k = 0; k < nEntries3; ++k) {  
241.                         assert(~IMAGE_RESOURCE_DATA_IS_DIRECTORY & pEntry3->OffsetToData);  
242.                           
243.                         pData = (PIMAGE_RESOURCE_DATA_ENTRY)((DWORD)pRes + pEntry3->OffsetToData);  
244.                         pData->OffsetToData += (DWORD)imagebase;  
245.                     }  
246.                 }  
247.             }  
248.               
249.         }  
250.     }  
251. }  
252. PVOID ReadData(IN LPCSTR lpFileName,OUT DWORD* ReadSize)  
253. {  
254.     PBYTE pLibrarySrc;  
255.     HANDLE hFile = CreateFileA(lpFileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);  
256.     if(hFile!=INVALID_HANDLE_VALUE)  
257.     {  
258.         *ReadSize = GetFileSize(hFile,NULL);  
259.         pLibrarySrc = (PBYTE)VirtualAlloc(0,*ReadSize,MEM_COMMIT,PAGE_EXECUTE_READWRITE);  
260.         if(!ReadFile(hFile,pLibrarySrc,*ReadSize,ReadSize,NULL))  
261.         {  
262.             CloseHandle(hFile);  
263.             VirtualFree(pLibrarySrc,*ReadSize,MEM_DECOMMIT);  
264.             return NULL;  
265.         }  
266.         CloseHandle(hFile);  
267.         return (PVOID)pLibrarySrc;  
268.     }  
269.     return NULL;  
270. }  
271. BOOL CheckPEFile(PIMAGE_DOS_HEADER pImageDosDest,PIMAGE_NT_HEADERS* pImageNtDest)  
272. {  
273.     PBYTE pImage = (PBYTE)pImageDosDest;  
274.     if(pImageDosDest->e_magic!=IMAGE_DOS_SIGNATURE)  
275.         return FALSE;  
276.     *pImageNtDest = (PIMAGE_NT_HEADERS)&pImage[pImageDosDest->e_lfanew];  
277.     if((*pImageNtDest)->Signature!=IMAGE_NT_SIGNATURE)  
278.         return FALSE;  
279.     return TRUE;  
280. }  
281. void LoadRelocation(PBYTE pSrc,PBYTE pDest)  
282. {  
283.     PIMAGE_DOS_HEADER pImageDosSrc;  
284.     PIMAGE_NT_HEADERS pImageNtSrc;  
285.     PIMAGE_DOS_HEADER pImageDosDest;  
286.     PIMAGE_NT_HEADERS pImageNtDest;  
287.     PIMAGE_DATA_DIRECTORY pDirectory;  
288.     PIMAGE_BASE_RELOCATION pRelocation;  
289.     DWORD dwOriginAddress;  
290.     DWORD dwBaseDelta;  
291.     PWORD pData;  
292.     int i,size;  
293.     DWORD* dwRelocationPointer;  
294.     int iType;  
295.     pImageDosSrc = (PIMAGE_DOS_HEADER)pSrc;  
296.     pImageNtSrc = (PIMAGE_NT_HEADERS)&pSrc[pImageDosSrc->e_lfanew];  
297.       
298.     pImageDosDest = (PIMAGE_DOS_HEADER)pDest;  
299.     pImageNtDest = (PIMAGE_NT_HEADERS)&pDest[pImageDosDest->e_lfanew];  
300.     pDirectory = (PIMAGE_DATA_DIRECTORY)&pImageNtDest->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];  
301.     if(!pDirectory->VirtualAddress)  
302.         return;  
303.     pRelocation = (PIMAGE_BASE_RELOCATION)(pDirectory->VirtualAddress + (DWORD)pDest);  
304.     dwOriginAddress = pImageNtSrc->OptionalHeader.ImageBase;  
305.     dwBaseDelta = (DWORD)pDest - dwOriginAddress;  
306.     while(pRelocation->VirtualAddress!=0)  
307.     {  
308.         size = (pRelocation->SizeOfBlock-sizeof(IMAGE_DATA_DIRECTORY))/2;  
309.         pData = (PWORD)((DWORD)pRelocation + 8);  
310.         for (i=0;i<size;i++)  
311.         {  
312.             iType = pData[i] >> 12;  
313.             dwRelocationPointer =  (DWORD*)((DWORD)pDest + ((pData[i] & 0x0fff) + pRelocation->VirtualAddress));  
314.             switch(iType)  
315.             {  
316.             case IMAGE_REL_BASED_ABSOLUTE:  
317.                 break;  
318.             case IMAGE_REL_BASED_HIGH:  
319.                 *(PWORD)dwRelocationPointer = (WORD)(((dwBaseDelta + *(PWORD)dwRelocationPointer) >> 16) & 0xFFFF);  
320.                 break;  
321.             case IMAGE_REL_BASED_LOW:  
322.                 *(PWORD)dwRelocationPointer = (WORD)((dwBaseDelta + *(PWORD)dwRelocationPointer) & 0xFFFF);  
323.                 break;  
324.             case IMAGE_REL_BASED_HIGHLOW:  
325.                     *dwRelocationPointer = *dwRelocationPointer + dwBaseDelta;  
326.                     break;  
327.             default:  
328.                 break;  
329.             }  
330.         }  
331.         pRelocation = (PIMAGE_BASE_RELOCATION)((DWORD)pRelocation + pRelocation->SizeOfBlock);         
332.     }  
333. }  
334.   
335. HMODULE LoadLibraryByResource(WORD wResID,char *pszFileType)  
336. {  
337.     DWORD dwReadSize;  
338.     PBYTE pLibrarySrc;  
339.     PBYTE pLibraryDest;  
340.     PIMAGE_DOS_HEADER pImageDosSrc;  
341.     PIMAGE_NT_HEADERS pImageNtSrc;  
342.     PIMAGE_DOS_HEADER pImageDosDest;  
343.     PIMAGE_NT_HEADERS pImageNtDest;  
344.   
345.     HRSRC   hrsc =  FindResourceA(NULL, MAKEINTRESOURCEA(wResID),pszFileType);  
346.     HGLOBAL hG   = LoadResource(NULL, hrsc);  
347.   
348.     dwReadSize   = SizeofResource( NULL,  hrsc);  
349.     pLibrarySrc  = (PBYTE)hG;  
350.     if(pLibrarySrc!=NULL)  
351.     {  
352.         pImageDosSrc = (PIMAGE_DOS_HEADER)pLibrarySrc;  
353.         if(!CheckPEFile(pImageDosSrc,&pImageNtSrc))  
354.             return NULL;  
355.         pLibraryDest = (PBYTE)VirtualAlloc(NULL,pImageNtSrc->OptionalHeader.SizeOfImage,MEM_COMMIT,PAGE_EXECUTE_READWRITE);  
356.   
357.         //copy header  
358.         memcpy(pLibraryDest, pImageDosSrc, pImageDosSrc->e_lfanew + pImageNtSrc->OptionalHeader.SizeOfHeaders);  
359.         pImageDosDest = (PIMAGE_DOS_HEADER)pLibraryDest;  
360.         pImageNtDest = (PIMAGE_NT_HEADERS)&pLibraryDest[pImageDosDest->e_lfanew];  
361.         pImageNtDest->OptionalHeader.ImageBase = (DWORD)pLibraryDest;  
362.   
363.         CopySection(pLibrarySrc,pLibraryDest);  
364.         LoadRelocation(pLibrarySrc,pLibraryDest);  
365.         //FixupResource(pLibraryDest);  
366.         LoadImport(pLibrarySrc,pLibraryDest);  
367.         if(pImageNtDest->OptionalHeader.AddressOfEntryPoint)  
368.             ((fnDllMain)(pImageNtDest->OptionalHeader.AddressOfEntryPoint + (DWORD)pLibraryDest))((HINSTANCE)pLibraryDest,DLL_PROCESS_ATTACH,NULL);  
369.         //pImageDosDest->e_magic = 0;  
370.         //pImageNtDest->Signature = 0;  
371.         return (HMODULE)pLibraryDest;  
372.     }  
373.     return NULL;  
374. }  
375.   
376. HMODULE LoadLibraryByFile(const char * pszDllPath)  
377. {  
378.     DWORD dwReadSize;  
379.     PBYTE pLibrarySrc;  
380.     PBYTE pLibraryDest;  
381.     PIMAGE_DOS_HEADER pImageDosSrc;  
382.     PIMAGE_NT_HEADERS pImageNtSrc;  
383.     PIMAGE_DOS_HEADER pImageDosDest;  
384.     PIMAGE_NT_HEADERS pImageNtDest;  
385.     pLibrarySrc  = (PBYTE)ReadData(pszDllPath,&dwReadSize);  
386.     if(pLibrarySrc!=NULL)  
387.     {  
388.         pImageDosSrc = (PIMAGE_DOS_HEADER)pLibrarySrc;  
389.         if(!CheckPEFile(pImageDosSrc,&pImageNtSrc))  
390.         {  
391.             VirtualFree(pLibrarySrc,dwReadSize,MEM_COMMIT);  
392.             return NULL;  
393.         }  
394.         pLibraryDest = (PBYTE)VirtualAlloc(NULL,pImageNtSrc->OptionalHeader.SizeOfImage,MEM_COMMIT,PAGE_EXECUTE_READWRITE);  
395.         //copy header  
396.         memcpy(pLibraryDest, pImageDosSrc, pImageDosSrc->e_lfanew + pImageNtSrc->OptionalHeader.SizeOfHeaders);  
397.   
398.         pImageDosDest = (PIMAGE_DOS_HEADER)pLibraryDest;  
399.         pImageNtDest = (PIMAGE_NT_HEADERS)&pLibraryDest[pImageDosDest->e_lfanew];  
400.         pImageNtDest->OptionalHeader.ImageBase = (DWORD)pLibraryDest;  
401.   
402.         CopySection(pLibrarySrc,pLibraryDest);  
403.         LoadRelocation(pLibrarySrc,pLibraryDest);  
404.         //FixupResource(pLibraryDest);  
405.         LoadImport(pLibrarySrc,pLibraryDest);  
406.         VirtualFree(pLibrarySrc,dwReadSize,MEM_DECOMMIT);  
407.         if(pImageNtDest->OptionalHeader.AddressOfEntryPoint)  
408.             ((fnDllMain)(pImageNtDest->OptionalHeader.AddressOfEntryPoint + (DWORD)pLibraryDest))((HINSTANCE)pLibraryDest,DLL_PROCESS_ATTACH,NULL);  
409.         //pImageDosDest->e_magic = 0;  
410.         //pImageNtDest->Signature = 0;  
411.         return (HMODULE)pLibraryDest;  
412.     }  
413.     return NULL;  
414. }  
415.   
416.   
417. DWORD GetCodeSize(HMODULE hModule)  
418. {  
419.     PBYTE pInfo = (PBYTE)hModule;  
420.     PIMAGE_DOS_HEADER pImgDos = (PIMAGE_DOS_HEADER)pInfo;  
421.     PIMAGE_NT_HEADERS pImgNt;  
422.     if(pImgDos->e_magic==IMAGE_DOS_SIGNATURE)  
423.     {  
424.         pImgNt = (PIMAGE_NT_HEADERS)&pInfo[pImgDos->e_lfanew];  
425.         if(pImgNt)  
426.         {  
427.             if(pImgNt->Signature==IMAGE_NT_SIGNATURE)  
428.             {  
429.                 return pImgNt->OptionalHeader.SizeOfCode;  
430.             }  
431.         }  
432.     }  
433.     return NULL;  
434. }  
435. DWORD GetPEImageSize(HMODULE hModule)  
436. {  
437.     PBYTE pInfo = (PBYTE)hModule;  
438.     PIMAGE_DOS_HEADER pImgDos = (PIMAGE_DOS_HEADER)pInfo;  
439.     PIMAGE_NT_HEADERS pImgNt;  
440.     if(pImgDos->e_magic==IMAGE_DOS_SIGNATURE)  
441.     {  
442.         pImgNt = (PIMAGE_NT_HEADERS)&pInfo[pImgDos->e_lfanew];  
443.         if(pImgNt)  
444.         {  
445.             if(pImgNt->Signature==IMAGE_NT_SIGNATURE)  
446.             {  
447.                 return pImgNt->OptionalHeader.SizeOfImage;  
448.             }  
449.         }  
450.     }  
451.     return NULL;  
452. }  
453. DWORD GetPEImageEnd(HMODULE hModule)  
454. {  
455.     return ((DWORD)hModule + GetPEImageSize(hModule));  
456. }  
457. DWORD GetPECodeEnd(HMODULE hModule)  
458. {  
459.     return ((DWORD)hModule + GetCodeSize(hModule));  
460. }  

      Main.cpp

[cpp] view plaincopyprint?

1. // 定义函数指针  
2. typedef BOOL (__stdcall *MSGBOX)(char *,char *);  
3.   
4. void Test(HMODULE hModule)  
5. {  
6.     if(hModule)  
7.     {  
8.         MSGBOX pMsgBox = (MSGBOX)MyGetProcAddress(hModule,"MsgBox");  
9.         if(pMsgBox)  
10.         {  
11.             pMsgBox("Hello World","Hi");  
12.         }  
13.         FreeLibrary(hModule);  
14.     }  
15. }  
16.   
17. // 从文件加载获取函数地址  
18. void CPEAnalyaisDlg::OnBnClickedButton1()  
19. {  
20.     Test(LoadLibraryByFile("MsgBox.dll"));  
21. }  
22.   
23. // 从资源文件加载获取函数地址  
24. void CPEAnalyaisDlg::OnBnClickedButton2()  
25. {  
26.     Test(LoadLibraryByResource(IDR_DLL_MSGBOX,"EXE"));  
27. }