首页
论坛
课程
招聘
[软件保护] [分享]StarForce3 Unpack
2008-2-15 23:26 48545

[软件保护] [分享]StarForce3 Unpack

2008-2-15 23:26
48545
<0>
------------------------------------
SF3差不多是SF系列中最强的版本,有相当多的强悍ANTI,其中VM修复是最困难的

关于SF3 unpack的文章比较少,仅有的一些文章也很少提到VM修复,只有reload的sf3逆向工具(RLD_SFRT)给出VM的修复方案,不过似乎只是针对SF3早期版本,并不试用SF3.4 3.7等

这篇文章我将描述脱壳一个SF3.4游戏的思路和方法,不是很完美,但确实可以工作,其中VM没有还原成X86代码,只是拼装到dump文件中运行,以下提到SF3,都是指SF3.4,和之后的版本可能有些细节不同

<1>anti-debugger及调试环境的建立
------------------------------------
尝试调试SF3的程序会发现单步和CC都没用,一旦试图中断程序就会蓝屏(BSOD),原因在于SF3修改了IDT,同时HOOK WINDOWS的进程切换,在SF保护的程序中查看IDT,会发现1号和3号中断被替换了,而在其他进程中IDT是正常的

通常调试器总是依赖x86的调试机制,即INT1用于单步和硬件断点,INT3用于软件断点,
softice,trw,windbg这些ring0调试器都是在int1int3 handler里处理调试断点,基于debugAPI的ring3调试器也是间接通过windows的interupter handler来实现调试,因此在SF保护的进程里都无法工作

如果调试器强行把IDT改回去,也会出现问题:
1,SF会检测int1 int3的interupter handler是否被修改,发现修改就BSOD
2,SF通过INT 1指令更新VM并将VM切换到ring0下运行,如果改了SF的int1 handler,VM也没法正确运行了

一个可行的调试方案就是使用不依赖int1 int3的断点,调试器最主要的功能就是让目标程序在某行代码处停下来,记录、修改,并能恢复运行,用int1 int3做断点是因为这是控制转移到debugger的最好的方法,但实际上还有很多控制转移的方法,比如jmp或者int XX,都可以用来做断点。当然,没有INT3完美,因为JMP是5字节,INT XX 2字节,而INT3只有一个字节,但这并不是太大的问题。

用INT XX(2byte)做断点的话,大多数代码都可以正常中断,少数不能的情况比如:
00410070 74 01         je short loaddll.00410073
00410072 50            push eax
00410073 53            push ebx
不能在00410072下断点,因为如果下了断点,而je跳转的话就会出错,但这种情况单步可以运行(单步时能正确预测下条指令)
另一种情况是单步也不能运行:
00410072 50            push eax
00410073 EB FD         jmp short loaddll.00410072
当执行到00410073时不能对00410072下断点
不过这些并不常见,绝大多数的情况都可以中断,只要记住断点是2bytes就行

用INTXX做断点就可以调试SF保护的程序,包括SF和windows的int1 interupter handler也能调试
也可以调试其他很多壳,原则上,只要CR3 GDT IDT还有效,并且没有内存效验,就可以调试
rdtsc的anti也可以对付,只要在中断前保存msr_tsc,中断返回后恢复msr_tsc即可(可惜我的CPU有点问题无法恢复msr...)

<2>除VM之外的部分处理
-----------------------------------
DUMP:
----------
在OEP处DUMP很容易,就我分析的这个程序来说,VC6入口第一个API是GetVersion,在GetVersion处中断,DUMP并修正entrypoint即可
中断不一定非要用调试器,让程序在GetVersion处非法也行,因为SF只改INT1 INT3,没改其他中断,所以在GetVersion入口加条指令读无效内存,或者除零,都可以非法操作断下来,或者甚至还可以加个MessageBox或者直接jmp cur_addr,方法很多,只要让它停下来就行

修复IAT:
----------
importrec修复IAT的原理:
如果壳重定向了IAT中的API thunk,importrec HOOK所有API,然后去call重定向的thunk,如果全部HOOK中发现哪个API被调用说明此thunk就是这个API

SF可以anti importrec,原因:
1,importrec的HOOK通过异常进行,直接导致被SF发现并BSOD,在SF保护的进程里是不能随便异常的
2,importrec HOOK时,壳代码已结束,已经正式转到主程序,对于模拟方式加密IAT无效,因为这时壳早已读取API代码并模拟了
3,HOOK后API识别受到干扰,比如壳加密GetTickCount,在调用GetTickCount前先调用了Sleep来干扰,这时importrec会识别为Sleep

修复的方法:
修改API第一行指令为JMP(解决1),并且要在壳尚未开始加密IAT前就修改并HOOK,这样等壳模拟API的代码时会把JMP的HOOK代码也模拟进去(解决2),然后call IAT中的thunk来探测API,call的时候使用“密码参数”,就是第一个参数为密码值0x12345678,HOOK代码发现以此参数调用就识别IAT并返回,否则就跳到正常API,这样不会被壳干扰到,比如壳调用Sleep干扰GetTickCount,但它用的参数不是0x12345678,忽略(解决3)

这个方法可以自动修复SF所有版本的IAT,也可以修复其他的壳
事实上IAT本来就不可能很好的加密,除非那个加密的IAT是用户DLL。如果是系统DLL,壳最终总要去执行这个API,原则上HOOK总是能搞定问题(这相当于API执行时报告它自己)关键HOOK的时机要比壳早(比如CreateProcess(CREATE_SUSPENDED)后),这样不管壳怎么干扰怎么变形怎么COPY都没用,就是变了形一样还是会报告THUNK&API
那么如果壳不去读取系统DLL中的代码就用自己的代码来模拟API又怎么办?的确,这样的话这个方法就无效了。但这种加密并不会成为问题。因为壳的作者既然有信心用自己的代码来代替API,说明这个API没有操作系统间的移植问题,直接将这些代码COPY到脱壳的文件里就行了,等于没加密,而且这种函数也非常少

段区修复:
----------
SF会申请一些内存,里面包括有当前路径之类的东西,补段区或者用loader载入到脱壳后程序中就行

<3>VM的一般分析
-----------------------------------
SF除了VM之外的部分都没多少难度,主要的困难在于修复VM

SF调用VM时代码类似于:
004221E2->E8 03FFFFFF   CALL 004220EA
004221E7  59            POP ECX                 
004221E8  C3            RETN         
->
004220EA  - E9 6B222C03     jmp 036E435A
->
036E435A    68 C2A9F03C     push 3CF0A9C2 //VM的ID,SF通过这个来识别是哪次VM调用
036E435F  - E9 9C4CBFFE     jmp 022D9000 //进入VM

VM入口:
022D9000   /EB 14           jmp short 022D9016
...
022D9016   \60              pushad
022D9017    9C              pushfd //保存当前状态
022D9018    FC              cld
022D9019    E8 00000000     call 022D901E
022D901E    5E              pop esi
...
022D9077    015F 1C         add dword ptr ds:[edi+1C],ebx
022D907A    03CB            add ecx,ebx
022D907C    FFE1            jmp ecx
-->
027264CC    0FBA6F 24 02    bts dword ptr ds:[edi+24],2
027264D1    8B0F            mov ecx,dword ptr ds:[edi]
...
0272653C    895F 14         mov dword ptr ds:[edi+14],ebx
0272653F    8B5F 20         mov ebx,dword ptr ds:[edi+20]
02726542    FFE3            jmp ebx

到了jmp ebx处VM REM就设置好了,可以开始正式运行VM OPCODE,jmp ebx跳转到OPCODE的第一个“解释器”,每个解释器运行时首先读取opcode并解密,然后执行一些操作,最后跳到下一个解释器

在整个运行过程中EDI指向VM REM
VM REM前几个DWORD的意义如下:
EDI-->
-----------------
0013E1B0    0013E5B0    022D9000    00000026
rem_start   rem_end     vm_base     des_base
00000031    00336E94    00000000    0234D788
src_base    vm_ip                   intprter_tbl
02306550    000000C4    00000202    002DBAE0
A           B           vm_eflags   C
-----------------
des_base的作用是,OPCODE中的目标寄存器索引总是和des_base相加后再索引。
src_base类似,和OPCODE中源寄存器相加
vm_ip是OPCODE buffer的offset,和vm_base相加后是线性内存地址
intprter_tbl是伪指令解释器入口offset表,此表中有500个offset,下文中把此值(0-499)称为解释器的id
ABC意义不大清楚
A好象保存一个临时解释器入口
B和解密下一个解释器id有关,1byte
C保存一个临时vm_ip,跳转时使用

下面举一些解释器的例子

VM入口第一个解释器
head:
02306550    8B47 08         mov eax,dword ptr ds:[edi+8] //eax=vm_base
02306553    0347 14         add eax,dword ptr ds:[edi+14] //eax=vm_base+vm_ip
02306556    8B08            mov ecx,dword ptr ds:[eax] //从opcode buffer取一个dword
02306558    8B50 04         mov edx,dword ptr ds:[eax+4] //取第2个dword
0230655B    8347 14 08      add dword ptr ds:[edi+14],8 //这个opcode的长度是8bytes
0230655F    51              push ecx
02306560    8BC1            mov eax,ecx
02306562    C1E0 07         shl eax,7
02306565    C1E8 1D         shr eax,1D
02306568    8BD9            mov ebx,ecx
0230656A    C1E3 02         shl ebx,2
0230656D    C1EB 1B         shr ebx,1B
02306570    8BCA            mov ecx,edx
02306572    C1E1 04         shl ecx,4
02306575    C1E9 1B         shr ecx,1B //此处eax,ecx,ebx=opcode中的某些位
02306578    0BC0            or eax,eax //从这里开始根据eax,ecx来解密B,由ecx索引B中的某一bit位
0230657A    74 20           je short 0230659C
0230657C    83F8 01         cmp eax,1
0230657F    74 21           je short 023065A2
02306581    83F8 02         cmp eax,2
02306584    74 22           je short 023065A8
02306586    83F8 03         cmp eax,3
02306589    74 23           je short 023065AE
0230658B    83F8 04         cmp eax,4
0230658E    74 23           je short 023065B3
02306590    83F8 05         cmp eax,5
02306593    74 23           je short 023065B8
02306595    83F8 06         cmp eax,6
02306598    74 28           je short 023065C2
0230659A    EB 30           jmp short 023065CC
0230659C    0FAB4F 24       bts dword ptr ds:[edi+24],ecx //eax=0, B.bit[ecx]=1
023065A0    EB 2A           jmp short 023065CC
023065A2    0FB34F 24       btr dword ptr ds:[edi+24],ecx //eax=1, B.bit[ecx]=0
023065A6    EB 24           jmp short 023065CC
023065A8    0FBB4F 24       btc dword ptr ds:[edi+24],ecx //eax=2, B.bit[ecx]=~B.bit[ecx]
023065AC    EB 1E           jmp short 023065CC
023065AE    D247 24         rol byte ptr ds:[edi+24],cl //eax=3, left rotate B
023065B1    EB 19           jmp short 023065CC
023065B3    D24F 24         ror byte ptr ds:[edi+24],cl //eax=4, right rotate B
023065B6    EB 14           jmp short 023065CC
023065B8    C1E1 05         shl ecx,5
023065BB    0BD9            or ebx,ecx
023065BD    895F 0C         mov dword ptr ds:[edi+C],ebx // eax=5, 更新des_base
023065C0    EB 0A           jmp short 023065CC
023065C2    C1E1 05         shl ecx,5
023065C5    0BD9            or ebx,ecx
023065C7    895F 10         mov dword ptr ds:[edi+10],ebx // eax=5, 更新src_base
023065CA    EB 00           jmp short 023065CC
023065CC    59              pop ecx
body:
023065CD    8B1F            mov ebx,dword ptr ds:[edi] //此处开始执行opcode操作
023065CF    8BF2            mov esi,edx
023065D1    C1E6 09         shl esi,9
023065D4    C1EE 18         shr esi,18 // 源操作数寄存器索引
023065D7    0377 10         add esi,dword ptr ds:[edi+10] //和src_base相加
023065DA    81E6 FF000000   and esi,0FF
023065E0    8B34B3          mov esi,dword ptr ds:[ebx+esi*4] // 取src_reg值,ebx=rem_start
023065E3    8BC1            mov eax,ecx
023065E5    C1E0 15         shl eax,15
023065E8    C1E8 18         shr eax,18 // 目标操作数寄存器索引
023065EB    0347 0C         add eax,dword ptr ds:[edi+C] //和des_base相加
023065EE    25 FF000000     and eax,0FF
023065F3    893483          mov dword ptr ds:[ebx+eax*4],esi //des_reg=src_reg
tail:
023065F6    8BF1            mov esi,ecx //到此处opcode操作执行完毕,开始运算下一个解释器id
023065F8    C1E6 0A         shl esi,0A
023065FB    C1EE 17         shr esi,17
023065FE    8BC2            mov eax,edx
02306600    C1E0 11         shl eax,11
02306603    C1E8 17         shr eax,17
02306606    2347 24         and eax,dword ptr ds:[edi+24]
02306609    33F0            xor esi,eax // xor后esi=下一个解释器id
0230660B    8B47 1C         mov eax,dword ptr ds:[edi+1C] // eax=intprter_tbl
0230660E    8B34B0          mov esi,dword ptr ds:[eax+esi*4] // esi=下一个解释器offset
02306611    0377 08         add esi,dword ptr ds:[edi+8] // esi=下一个解释器入口地址
02306614    FFE6            jmp esi

显然这个解释器作用就是mov des_reg,src_reg

其他的解释器基本上head tail部分都差不多,只是shl shr所取的位不同,body部分执行各种操作

VM调用有两种,一种仅仅只是拦截一下程序(hook vm),比如:
00545D21    E8 194FF3FF     call fixVM.0047AC3F
-->
0047AC3F  - E9 12982603     jmp 036E4456
-->
036E4456    68 7937E3D3     push D3E33779
036E445B  - E9 A04BBFFE     jmp 022D9000

在运行过一次以后发现036E4456变为:
036E4456    68 7937E3D3     push D3E33779
036E445B  - E9 A04BBFFE     jmp 038C01B0
-->
038C01B0->8D6424 04                 LEA ESP,[ESP+4]            <---- disasm address
038C01B4  E9 395EC8FC               JMP 00545FF2
因此VM仅是HOOK了一下,这种情况很好修复,把call fixVM.0047AC3F改成call 00545FF2就行了

另一种VM则是虚拟执行X86代码(emulate vm),这种是真正难修复的,下面介绍这种VM的修复方法

<4>emulate VM修复
-----------------------------------
第一个emulate vm出现在:
0040C7CC  FF7424 04                 PUSH DWORD PTR [ESP+4]  
0040C7D0  51                        PUSH ECX               
0040C7D1->E8 C2FFFFFF               CALL 0040C798
0040C7D6  59                        POP ECX                 
0040C7D7  59                        POP ECX                 
-->
0040C798  - E9 E57A2D03     jmp 036E4282
-->
036E4282    68 9E172296     push 9622179E
036E4287  - E9 744DBFFE     jmp 022D9000

CALL 0040C798之前的CPU状态为:
flag=00000246
edi=00000003 esi=009779F0 ebp=00000000 esp=0013F8A8
ebx=00000001 edx=000001F5 ecx=00C10CC0 eax=0013F8DC

通常的思路当然是把VM整个的用loader载入到脱壳后的文件中运行,这样做的话,会发现异常出现:
023EF508     B1 05               mov cl,5
023EF50A     D247 24             rol byte ptr ds:[edi+24],cl
023EF50D     CD 01               int 1  // 异常
023EF50F     C647 0C AD          mov byte ptr ds:[edi+C],0AD
023EF513     8B9F 90010000       mov ebx,dword ptr ds:[edi+190]

跟踪IDT中SF的int1 handler:

int1 handler=F0BD7D28
seg000:F0BD7D28                 jmp     short loc_F0BD7D2E
seg000:F0BD7D28 ; ---------------------------------------------------------------------------
seg000:F0BD7D2A                 dd 1E3BEh
seg000:F0BD7D2E ; ---------------------------------------------------------------------------
seg000:F0BD7D2E
seg000:F0BD7D2E loc_F0BD7D2E:                           ; CODE XREF: seg000:F0BD7D28j
seg000:F0BD7D2E                 push    0               ; flag=00000203
seg000:F0BD7D2E                                         ; edi=03300000 esi=02307268 ebp=00000020 esp=0013F91C
seg000:F0BD7D2E                                         ; ebx=0000000B edx=001D4E01 ecx=B202CE05 eax=03300000
seg000:F0BD7D30                 mov     word ptr [esp+2], 0
seg000:F0BD7D37                 mov     ebp, esp        
seg000:F0BD7D39                 cld
seg000:F0BD7D3A                 mov     ecx, [esp+8]    ; outer_cs
seg000:F0BD7D3E                 test    ecx, 11b        ; RPL==0 ?
seg000:F0BD7D44                 jz      loc_F0BD7E33
seg000:F0BD7D4A                 xor     eax, eax
seg000:F0BD7D4C                 mov     dr7, eax        ; clean dr7
seg000:F0BD7D4F                 mov     ecx, [esp+4]    ; outer_eip
.......
seg000:F0BD7DA0                 push    eax             ; ---->SEH handler
seg000:F0BD7DA1                 push    large dword ptr fs:0
seg000:F0BD7DA8                 mov     large fs:0, esp ; set SEH
seg000:F0BD7DAF
seg000:F0BD7DAF loc_F0BD7DAF:                           ; CODE XREF: seg000:F0BD7D98j
seg000:F0BD7DAF                 sti
seg000:F0BD7DB0                 lea     eax, [ebp+16]   ; eax=outer_esp
seg000:F0BD7DB3                 mov     [edi+84h], eax
seg000:F0BD7DB9                 mov     [edi+88h], esp
seg000:F0BD7DBF                 sub     esp, 20h
seg000:F0BD7DC2                 mov     eax, edi
seg000:F0BD7DC4                 mov     esi, [edi+84h]  ; esi=outer_esp
seg000:F0BD7DCA                 mov     esi, [esi]
seg000:F0BD7DCC                 mov     edi, esp        ; new VM rem
seg000:F0BD7DCE                 push    ecx
seg000:F0BD7DCF                 mov     ecx, 8
seg000:F0BD7DD4                 rep movsd               ; copy mem from outerstack to new VM rem
seg000:F0BD7DD6                 pop     ecx
seg000:F0BD7DD7                 mov     edi, eax
seg000:F0BD7DD9                 jmp     ecx             ;ecx=outer_eip

显然int 1的作用是复制VM前8个dword到ring0 stack,然后返回INT 1的下一行,此后VM运行在ring0下
注意F0BD7DAF sti这一行,INT 1中断时IF自动清除,禁中断,此处开中断是必须的
因为之后VM仍然在用户空间中运行,本来这样不安全,分页内存可能PAGE FAULT,但因为开了中断,此后代码等于在IRQL=PASSIVE_LEVEL运行,因此可以正常访问内存,此外还可以保证正常线程切换

运行一些代码后VM跳回SF驱动:
022E4D57     035F 0C             add ebx,dword ptr ds:[edi+C]
022E4D5A     81E3 FF000000       and ebx,0FF
022E4D60   - FF2498              jmp dword ptr ds:[eax+ebx*4]   ---> F1085BFC

seg000:F6A4DBFC                 jmp     short loc_F6A4DC02
seg000:F6A4DBFC ; ---------------------------------------------------------------------------
seg000:F6A4DBFE                 dd 0FFFDA4EAh           ; =-25B16
seg000:F6A4DC02 ; ---------------------------------------------------------------------------
seg000:F6A4DC02
seg000:F6A4DC02 loc_F6A4DC02:                           ; CODE XREF: seg000:F6A4DBFCj
seg000:F6A4DC02                 pop     ebx             ; 栈顶第一个值
seg000:F6A4DC03                 mov     eax, [edi+88h]
seg000:F6A4DC09                 sub     eax, 20h ; ' '
seg000:F6A4DC0C                 sub     eax, esp
seg000:F6A4DC0E                 mov     ecx, [edi+84h]
seg000:F6A4DC14                 sub     [ecx], eax
seg000:F6A4DC16                 mov     eax, [edi+88h]
seg000:F6A4DC1C                 sub     eax, esp
seg000:F6A4DC1E                 shr     eax, 2
seg000:F6A4DC21                 mov     edx, edi
seg000:F6A4DC23                 mov     esi, esp
seg000:F6A4DC25                 mov     edi, [ecx]
seg000:F6A4DC27                 mov     ecx, eax
seg000:F6A4DC29                 rep movsd            // copy VM rem back
seg000:F6A4DC2B                 mov     edi, edx
seg000:F6A4DC2D                 mov     esp, [edi+88h]
....
seg000:F6A4DC50                 mov     eax, 7FFh
seg000:F6A4DC55                 mov     dr7, eax //恢复dr7
....
seg000:F6A4DC7B                 add     esp, 4
seg000:F6A4DC7E                 mov     [esp], ebx // ebx=返回驱动前栈顶第一个值
seg000:F6A4DC81                 iret

IRET执行后INT1中断才返回,此后VM运行于ring3
除了INT 1指令,SF还直接设置dr0-dr3来触发INT1中断,所以清dr7、恢复dr7是必须的

一个可能的修复VM的方法就是,模拟INT 1和IRET,在ring3执行以上两段代码,但实际发现行不通
VM在ring0下执行很多操作,比如,读cs,读页表,读IDT,读cr4,rdstc效验,内存检查,甚至调用驱动中的函数(估计是检查光驱),要全部模拟掉几乎是不可能的,因而要想办法绕开ring0的操作

为了获得对VM执行流程大概的了解,可以HOOK intprter_tbl,截取并记录每个opcode的id
HOOK只要注入个DLL到SF进程,替换intprter_tbl就行了,很幸运,SF没有check intprter_tbl

例:
记录文件:
opcode trace log:
[0]183
[1]333
[2]452
[3]165
...
[37760]444  *
[37761]014  *
[37762]048  *
...
[69235]230
[69236]448
[69237]235
[69238]398
log end

[]中是数目,后面是解释器id(opcode id),*的地方表示运行于ring0
因为VM可能运行于ring0,HOOK时除了记录流程外,不能有其他代码

简单看一下,VM执行了60000多个opcode,反复进入ring0 160多次
很显然这69238个opcode不可能都是emulate x86code,很多肯定都是各种ANTI、解密之类
那么如果找到emulate x86开始的地方?想象一下VM开始模拟X86代码时会发生什么?
再看看VM入口代码:
022D9000   /EB 14           jmp short 022D9016
...
022D9016   \60              pushad
022D9017    9C              pushfd
很容易想到开始emulate x86时,VM肯定要恢复eflags和8个register!
于是方案就是,在pushfd后修改栈中的eflags(magic eflags),同时对每个opcode记录vm_eflags
然后在记录文件中搜索magic eflags,看什么地方出现

例:magic eflags=FF000246,因为eflags最高字节是reserved的,即使这个值被popf,也不会对程序运行产生什么影响
记录文件中第一个dword是vm_eflags
opcode trace log:
[0]183 00000202  
[1]333 00000202  
[2]452 00000202  
...
[46087]408 00000246  
[46088]323 00000246  
[46089]090 FF000246  
[46090]374 FF000246  
[46091]041 FF000246  
...
[69221]230 00000246
[69222]448 00000246
[69224]398 00000246
log end

第46089个opcode时magic eflags出现了!很明显前面都是各种ANTI,这里才开始正式emulate x86code

修改程序,在magic eflags时输出VM REM:

00 00 43 03 00 04 43 03 00 90 39 02 55 00 00 00
D4 00 00 00 A0 74 60 00 00 00 00 00 88 D7 40 02
B8 EF B4 03 7A 00 00 00 46 02 00 FF CC 9C 0E 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 D8 FD DB B1 58 FD DB B1 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
DC F8 13 00 C0 0C C1 00 F5 01 00 00 01 00 00 00
vm_eax      vm_ecx      vm_edx      vm_ebx
A4 F8 13 00 00 00 00 00 F0 79 97 00 03 00 00 00
vm_esp      vm_ebp      vm_esi      vm_edi
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 46 02 00 FF

和调用VM之前的CPU状态对比一下,发现vmrem+A0开始是8个通用寄存器,已标记在上面

那么emulate是什么时候结束的?同样可以用magic eflags的方法
修改HOOK,使之显示[n]id vm_eflags vm_ip esp
虽然每次调用VM执行的opcode数目不完全相同,但最后的终止vm_ip是确定的:
[68638]398 00000246 003808B4 0013E1B4   
log end

修改HOOK,在vm_ip=003808B4处弹个MessageBox,根据intprter_tbl[398]+vm_base算出最后一个解释器地址
发现这是一个跳转opcode
...
0230347D    8B07            mov eax,dword ptr ds:[edi]
0230347F    8BD9            mov ebx,ecx
02303481    C1EB 1C         shr ebx,1C
02303484    8BEA            mov ebp,edx
02303486    C1E5 1C         shl ebp,1C
02303489    C1ED 18         shr ebp,18
0230348C    0BDD            or ebx,ebp
0230348E    035F 0C         add ebx,dword ptr ds:[edi+C]
02303491    81E3 FF000000   and ebx,0FF
02303497    FF2498          jmp dword ptr ds:[eax+ebx*4] // jmp des_reg
-->
VM exit
0239A830->8B87 D0020000             MOV EAX,[EDI+2D0]
0239A836  03E0                      ADD ESP,EAX      
0239A838  9D                        POPFD            
0239A839  61                        POPAD            
0239A83A  C3                        RETN              //此后0040C7D6返回 VM结束

修改HOOK,在emulate start后对每个opcode检测vm_eflags,如果高10位(都是reserved的)为0,则在高10位写入一个计数值:
DWORD eflags=vm_rem->eflags;
BYTE id=eflags>>24;
if(id==0)
{
        DWORD eflags_mask=magic_eflags_id;
        eflags_mask=eflags_mask<<22;
        vm_rem->eflags=vm_rem->eflags | eflags_mask;
        magic_eflags_id++;
        if(magic_eflags_id==256*4)magic_eflags_id=1;
}

然后在0239A830的VM exit代码处下断点
0239A838  9D   POPFD
看popfd前的栈中eflags,发现eflags=04400246,044就是计数值,在记录文件中搜索此值,发现
[46231]374 00400246 006074A8 0013F8A4   //emu start
[46487]230 04400246 005FB088 0013F8A0   //emu end
整个VM运行过程中只有这200多个opcode是真正emulate x86code的

修改HOOK,在emulate开始处记录VMREM状态,然后修复EXE,调用VM时载入此VMREM,更新vm_eflags和8个寄存器字段,然后从id=374的解释器开始执行,这时执行的就是emulate x86的代码!绕开了之前所有的anti!

继续运行下去发现在到达emu end前居然还有int 1进入ring0
修改HOOK,在emu start和emu end之间输出详细的VM状态,包括eflags和8个register,可以发现在进入ring0前记录如下:

n    id  vm_eflag vm_ip    esp        vm_eax   vm_ecx   vm_edx   vm_ebx   vm_esp   vm_ebp   vm_esi   vm_edi
[2878]374 24400246 008B8018 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2879]476 24400246 008B8024 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2880]172 24400246 008B8030 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2881]222 24400246 0035F648 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2882]476 24400246 0035F650 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2883]098 24400246 0035F65C 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2884]201 24400246 0035F664 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2885]054 24400246 0035F670 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2886]043 24400246 0035F678 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2887]332 24400246 0035F684 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2888]020 24400246 0035F68C 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2889]083 24400246 0035F698 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2890]248 24400246 0035F6A0 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2891]263 24400246 0035F6AC 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2892]173 24400246 0035F6B4 0013F6D4   00000000 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2893]185 24400246 0035F6C0 0013F6D4   00000000 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2894]444 24400246 0035F6C8 0013F6D4   00000000 00000000 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2895]407 24400246 0035F6D4 0013F6D4   00000000 00000000 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2896]393 24400246 0035F6DC 0013F6D4   00000000 00000000 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2897]068 24400246 0035F6E8 0013F6D4   00000000 00000000 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2898]165 24400246 0035F6F0 0013F6D4   00000000 00000000 00000000 00000000 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2899]495 24400246 0035F6FC 0013F6D4   00000000 00000000 00000000 00000000 0013F6D4 0013F898 00C27CC4 00C4DE1E
[2900]230 24400246 0035F704 0013F6D4   00000000 00000000 00000000 00000000 00000000 0013F898 00C27CC4 00C4DE1E
[2901]263 24400246 0035F710 0013F6D4   00000000 00000000 00000000 00000000 00000000 0013F898 00C27CC4 00C4DE1E
[2902]058 24400246 0035F718 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00C27CC4 00C4DE1E
[2903]312 24400246 0035F724 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00C27CC4 00C4DE1E
[2904]139 24400246 0035F72C 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00C4DE1E
[2905]157 24400246 0035F738 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00C4DE1E
[2906]393 24400246 0035F740 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[2907]062 24400246 0035F74C 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[2908]165 24400246 0035F754 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[2909]312 24400246 0035F760 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000

这里清除了8个register,然后往下翻记录,发现经历几个ring0后来到

[3868]472 2D400206 003ECED8 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[3869]189 2D400206 003ECEE0 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[3870]226 2D400206 003ECEEC 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[3871]058 2D400206 003ECEF4 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[3872]495 2D400206 003ECF00 0013F6D4   00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[3873]230 2D400206 003ECF08 0013F6D4   00C27CC4 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[3874]103 2D400206 003ECF14 0013F6D4   00C27CC4 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[3875]393 2D400206 003ECF1C 0013F6D4   00C27CC4 00000000 00000000 00C4D9A8 00000000 00000000 00000000 00000000
[3876]103 2D400206 003ECF28 0013F6D4   00C27CC4 00000000 00000000 00C4D9A8 00000000 00000000 00000000 00000000
[3877]146 2D400206 003ECF30 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 00000000 00000000 00000000 00000000
[3878]185 2D400206 003ECF3C 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 00000000 00000000 00000000 00000000
[3879]139 2D400206 003ECF44 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 00000000 00000000 00000000 00000000
[3880]302 2D400206 003ECF50 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 00000000 00000000 00000000 00000000
[3881]356 2D400206 003ECF58 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 00000000 00000000 00C27CC4 00000000
[3882]302 2D400206 003ECF64 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 00000000 00000000 00C27CC4 00000000
[3883]173 2D400206 003ECF6C 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 00000000 00000000 00C27CC4 00C4DE1E
[3884]062 2D400206 003ECF78 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 00000000 00000000 00C27CC4 00C4DE1E
[3885]146 2D400206 003ECF80 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 00000000 00C27CC4 00C4DE1E
[3886]062 2D400206 003ECF8C 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 00000000 00C27CC4 00C4DE1E
[3887]093 2D400206 003ECF94 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[3888]236 2D400206 003ECFA0 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[3889]048 2D400206 003ECFA8 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[3890]333 2D400206 003ECFB0 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E
[3891]408 2D400206 003ECFB8 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E

到了此处8个register又恢复,而中间的过程中8reg都是0

于是,可以这么处理,在清8register前中断,将vmrem修改为恢复8register后的状态
运行程序,发现这个VM调用居然顺利运行结束了,那么emulate end之后的ring0为什么没触发呢?
跟踪修复后的VM发现,最后一个opcode跳转之后来到:

03664754    58              pop eax
03664755    5B              pop ebx
03664756    897B 3C         mov dword ptr ds:[ebx+3C],edi
03664759    8943 68         mov dword ptr ds:[ebx+68],eax
0366475C    61              popad
0366475D    9D              popfd
0366475E    8D6424 04       lea esp,dword ptr ss:[esp+4]
03664762    FF6424 FC       jmp dword ptr ss:[esp-4] //0040C7D6 返回

对比SF运行时的VM,发现这段代码也会被执行,但jmp dword ptr ss:[esp-4]跳回了VM,原来栈中保存的return address被修改了!
由此可以推测SF在emu start后返回ring0修改了return address

另外也可以直接patch opcode,使之绕过ring0部分
这里清理8reg前发生了一次vm_ip切换,分析切换附近的opcode
[2879]476 24400246 008B8024 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E//mov reg_2C,35F648
[2880]172 24400246 008B8030 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E//mov vm_ip,reg_2C
[2881]222 24400246 0035F648 0013F6D4   00C27CC4 0000000E 00000000 00C4D9A8 0013F6D4 0013F898 00C27CC4 00C4DE1E

VM切换vm_ip时总是用类似这样的代码:
008B8024 mov reg_2C,35F648
008B8030 mov vm_ip,reg_2C
8B8024这个opcode是3个dword(8B8030-8B8024=C),第3个dword就是常数35F648
修改这个dword,改为ring0处理后的vm_ip,同时前面2个dword和运算下一个解释器id相关的位也要修改,使下一个解释器id正确
这样修复后可以直接运行不用再中断了,更完美些

这么处理后这个call就算是正常运行了,再修复掉几个hook vm后可以进入游戏菜单界面
再修复掉3个emulate vm(和上面的大同小异)和N个hook vm后可以进入游戏了,玩了5分钟,没什么问题,但点其他菜单还有vm,搞不动了,投降,脱壳结束

<5>VM的反编译
-----------------------------------
像上面这样修复,虽然不是很完美,但可以工作,虽然VM仍在运行不过并不会太影响效率(那300个emulate opcode和全部60000个opcode比只是九牛一毛而已)。
后来尝试了下反编译VM的opcode,太麻烦,弄了一点搞不动了
以下的描述和脱壳无关,仅是个示例,弄了点开头,不是完整的解决方法

500个解释器基本结构都是head+body+tail,对每个解释器用一个struct描述

struct VM_OP_DEF
{
        int id;  // zero based, 0-499
        int op_len;
        DWORD p_eax;
        DWORD p_ebx;
        DWORD p_ecx;
        DWORD src;//+[edi+10]
        DWORD des;//+[edi+C]
        char*cmd;
        DWORD p_ebp;
        DWORD ext;
};

#define MAKEDWORD(a,b,c,d) (DWORD(a)<<24 | DWORD(b)<<16 | DWORD(c)<<8 | DWORD(d))
#define OP(type,n_dword,left,right) (MAKEDWORD(type,n_dword,left,right))
#define D1(left,right) (OP(1,1,left,right))
#define D2(left,right) (OP(1,2,left,right))
#define D3(left,right) (OP(1,3,left,right))

VM_OP_DEF vm_op_def[]=
{
//       eax          ebx          ecx                      +10 src      +C des
{256,8,         D1(0x7,0x1D),D1(0x2,0x1B),D2(0x4,0x1B)         ,D2(0x9,0x18),D1(0x15,0x18),        "mov @d,@s"                ,0,0},
{183,8,         D1(0x8,0x1D),D2(0x4,0x1B),D2(0x1B,0x1B)        ,D1(0x0,0x18),D1(0xD,0x18),        "or @d,@s"                ,0,0},
{333,8,         D1(0x13,0x1D),D2(0x9,0x1B),D2(0x4,0x1B)        ,D1(0x18,0x18),D2(0xE,0x18),        "mov @d,@s"                ,0,0},
{452,8,         D1(0x2,0x1D),D2(0x9,0x1B),D2(0x4,0x1B)                ,D1(0x10,0x18),D2(0xE,0x18),        "mov @d,@s"                ,0,0},
{165,12, D1(0x15,0x1D),D1(0x1B,0x1B),D1(0,0x1E)                ,D1(0x18,0x1D),D2(0x4,0x18),        "mov#s @d,=3"        ,P2(1,0x1D,0x1B),0},
...
};

这些D1,D2里记录对vm_ip buffer中的dword的位,对应于解释器中的shl/shr
char*cmd表示这个指令,@d表示操作数是des+des_base寄存器,#s表示这是个条件指令,=3表示第3个dword的常数值
然后写个函数根据这个表来反编译(就像OD反编译原代码那样)

问题是这样要分析500个解释器,相当麻烦,如果只算emulate x86部分使用的解释器大概100多个,很多都是功能相同只是shl/shr不同
我想不出更好的方法来解决shl/shr的麻烦,reload的工具包反编译opcode的代码在sf3.dll中,可惜没原代码,IDA里看了下似乎没有shl/shr的麻烦,不知道是他们有什么办法解决还是以前的版本里没这东西,估计也许可以自动搜索并分析shl/shr

这样反编译出来的代码仍然不是x86代码,而是用几个opcode来模拟一个x86代码
比如,类似这样的代码:
mov reg_320,FFFFFFFC
add vm_esp,reg320
push vm_edi
模拟的是push edi

<6>一些启示
-----------------------------------

关于anti-debugger:
-----------
SF在SF4及之后的版本中放弃了INT1 INT3,基本上没什么强悍的ANTI,OD就可以调试,VM也可以直接loader,难度直线下降,据说这么做是为了提高兼容性
其实我到觉得放弃这些ANTI很可惜,理想的ANTI应该这样,不仅替换INT1 INT3,甚至可以把CR3、IDT、GDT整个的替换掉!建立一个虚拟环境,在虚拟环境中执行代码!
VMWare的驱动进入VMM(vitual machine monitor)就是这样:
seg000:F8BC0010                 push    eax
seg000:F8BC0011                 mov     eax, [esp+oldinfo]
seg000:F8BC0015                 sgdt    qword ptr [eax+0]
seg000:F8BC0019                 sidt    qword ptr [eax+10h]
seg000:F8BC001D                 mov     [eax+4Ch], edx
seg000:F8BC0020                 mov     edx, cr3
seg000:F8BC0023                 mov     [eax+38h], edx
seg000:F8BC0026                 pop     dword ptr [eax+44h]
seg000:F8BC0029                 mov     [eax+50h], ebx
seg000:F8BC002C                 mov     [eax+48h], ecx
seg000:F8BC002F                 mov     [eax+5Ch], esi
seg000:F8BC0032                 mov     [eax+60h], edi
seg000:F8BC0035                 mov     [eax+58h], ebp
seg000:F8BC0038                 mov     [eax+54h], esp
seg000:F8BC003B                 mov     word ptr [eax+70h], ds
seg000:F8BC003E                 mov     word ptr [eax+6Ch], ss
seg000:F8BC0041                 mov     word ptr [eax+64h], es
seg000:F8BC0044                 mov     edx, [esp+0]    ; ret
seg000:F8BC0048                 mov     [eax+3Ch], edx
seg000:F8BC004B                 mov     eax, [esp-4+newinfo]
seg000:F8BC004F                 lgdt    qword ptr [eax+0]
seg000:F8BC0053                 mov     edx, [eax+38h]
seg000:F8BC0056                 mov     ecx, [eax+70h]
seg000:F8BC0059                 mov     eax, [esp-4+arg_C]
seg000:F8BC005D                 mov     cr3, edx
seg000:F8BC0060                 mov     ds, cx
seg000:F8BC0062                 ltr     word ptr [eax+18h]
seg000:F8BC0066                 mov     ss, word ptr [eax+6Ch]
seg000:F8BC0069                 mov     es, word ptr [eax+64h]
seg000:F8BC006C                 lidt    qword ptr [eax+10h]
seg000:F8BC0070                 mov     ebx, [eax+50h]
seg000:F8BC0073                 mov     ecx, [eax+48h]
seg000:F8BC0076                 mov     edx, [eax+4Ch]
seg000:F8BC0079                 mov     esi, [eax+5Ch]
seg000:F8BC007C                 mov     edi, [eax+60h]
seg000:F8BC007F                 mov     ebp, [eax+58h]
seg000:F8BC0082                 mov     esp, [eax+54h]
seg000:F8BC0085                 mov     eax, [eax+44h]
seg000:F8BC0088                 retf    0Ch

在lgdt qword ptr [eax+0]之后完全没有办法调试,哪怕用jmp或者intxx做断点也无法跨越虚拟与真实之间的界限
要是壳在这样的虚拟环境下解密,运行VM,难度可想而知
那么这样是否会降低兼容性或者被杀毒软件kill掉呢?实际上也不会有这些问题
什么GDT IDT CR3这些机制都是从386就有的,只要设计良好完全可以做到兼容,我们运行VMWare也几乎不会出现BSOD
只要虚拟运行前建立虚拟环境,运行结束后还原,杀毒软件也不会发难(也没机会发难)

不过intel vt技术出来后,估计离虚拟硬件调试器也不远了,那样的话即使如此也是没法anti的....

关于VM:
-----------
VM一方面要隐藏代码,一方面要防止load,总的来说应该是离x86体系越远越好,离x86越远越难以被分析
SF的VM基本还是很接近x86的,有诸如vm_eflags,vm_eax这样的东西,分析它只是时间问题
事实上我觉得从已经编译的EXE开始加壳是不可能离x86太远的,因为VM最终要归结到模拟x86指令,而如果要反汇编x86指令抽象出背后的逻辑又是非常困难的
可能的更好的方法也许是在编译级加壳,这个级别可以直接获得程序的逻辑,从而可能设计出实现这些逻辑的远离x86的VM
甚至可以在神经网络中实现逻辑,这个连冯诺依曼体系都远离了,更难分析

<-1>
-----------------------------------
SF3.4这东西我从06年末开始分析,断断续续弄到现在才终于搞定了,中间学会了不少东西,当初连ring0为何物还未清楚...
感谢forgot jojo lovezero machoman和其他很多朋友的帮助

DonQuixote[CCG][iPB]
Email:DonQuixote@mail.nankai.edu.cn
2008/2/16

[看雪官方培训] Unicorn Trace还原Ollvm算法!《安卓高级研修班》2021年秋季班火热招生!!

收藏
点赞0
打赏
分享
最新回复 (66)
雪    币: 943
活跃值: 活跃值 (5587)
能力值: (RANK:350 )
在线值:
发帖
回帖
粉丝
kanxue 活跃值 8 2008-2-15 23:48
2
0
早就听说DonQuixote在SF3上很有研究,这篇文章先保存下来,感谢分享!
雪    币: 110
活跃值: 活跃值 (16)
能力值: ( LV12,RANK:330 )
在线值:
发帖
回帖
粉丝
DonQuixote 活跃值 8 2008-2-15 23:54
3
0
呵呵,8精华,谢谢
雪    币: 60
活跃值: 活跃值 (73)
能力值: ( LV9,RANK:3410 )
在线值:
发帖
回帖
粉丝
fly 活跃值 85 2008-2-16 20:49
4
0
强        悍
雪    币: 217
活跃值: 活跃值 (17)
能力值: ( LV13,RANK:530 )
在线值:
发帖
回帖
粉丝
foxabu 活跃值 13 2008-2-16 23:21
5
0
学习 + 膜拜 + 顶 + .......
雪    币: 166
活跃值: 活跃值 (169)
能力值: ( LV9,RANK:170 )
在线值:
发帖
回帖
粉丝
nig 活跃值 4 2008-2-17 11:16
6
0
牛,太牛了,2年磨一剑,终有所成,PF,PF.
雪    币: 240
活跃值: 活跃值 (12)
能力值: ( LV9,RANK:170 )
在线值:
发帖
回帖
粉丝
skylly 活跃值 4 2008-2-17 13:21
7
0
楼主真有耐心,
雪    币: 202
活跃值: 活跃值 (10)
能力值: ( LV9,RANK:1170 )
在线值:
发帖
回帖
粉丝
bxm 活跃值 29 2008-2-17 18:01
8
0
太有才了!!!!!
雪    币: 217
活跃值: 活跃值 (28)
能力值: ( LV9,RANK:1210 )
在线值:
发帖
回帖
粉丝
softworm 活跃值 30 2008-2-17 20:10
9
0
仰慕一下大牛
雪    币: 1940
能力值: (RANK:410 )
在线值:
发帖
回帖
粉丝
小虾 活跃值 10 2008-2-17 23:16
10
0
很好,很强大。
雪    币: 200
能力值: (RANK:650 )
在线值:
发帖
回帖
粉丝
shoooo 活跃值 16 2008-2-18 12:53
11
0
现在很少用这个ID, 进来膜拜了
雪    币: 943
活跃值: 活跃值 (5587)
能力值: (RANK:350 )
在线值:
发帖
回帖
粉丝
kanxue 活跃值 8 2008-2-18 16:33
12
0
DonQuixote说这文章己被公开,经其本人同意,这帖就从论坛会员区移出来。
雪    币: 9347
活跃值: 活跃值 (1538)
能力值: ( LV15,RANK:1960 )
在线值:
发帖
回帖
粉丝
ccfer 活跃值 15 2008-2-18 16:47
13
0
强悍的intxx debugger
雪    币: 110
活跃值: 活跃值 (16)
能力值: ( LV12,RANK:330 )
在线值:
发帖
回帖
粉丝
DonQuixote 活跃值 8 2008-2-18 16:52
14
0
楼上是谁的马甲
(不方便说的话,PM告诉我 )
雪    币: 1294
活跃值: 活跃值 (56)
能力值: ( LV9,RANK:490 )
在线值:
发帖
回帖
粉丝
yijun8354 活跃值 12 2008-2-18 17:29
15
0
厉害,看不太懂,先收藏了~~~
雪    币: 3
活跃值: 活跃值 (15)
能力值: ( LV9,RANK:330 )
在线值:
发帖
回帖
粉丝
theOcrat 活跃值 8 2008-2-18 18:02
16
0
强烈膜拜...
雪    币: 270
活跃值: 活跃值 (12)
能力值: ( LV5,RANK:60 )
在线值:
发帖
回帖
粉丝
WR-911 活跃值 1 2008-2-18 18:48
17
0
强,确实是强!这几年强人辈出呀!
雪    币: 9347
活跃值: 活跃值 (1538)
能力值: ( LV15,RANK:1960 )
在线值:
发帖
回帖
粉丝
ccfer 活跃值 15 2008-2-18 21:53
18
0
难道是要把debugger发给我吗?
雪    币: 1795
活跃值: 活跃值 (661)
能力值: (RANK:770 )
在线值:
发帖
回帖
粉丝
海风月影 活跃值 18 2008-2-18 22:21
19
0
赶紧去猜ccfer的密码
雪    币: 204
活跃值: 活跃值 (10)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
guangxin 活跃值 2008-2-18 23:29
20
0
横强,学习!
雪    币: 100
活跃值: 活跃值 (39)
能力值: ( LV5,RANK:60 )
在线值:
发帖
回帖
粉丝
NWMonster 活跃值 1 2008-2-19 09:44
21
0
好难,好精华,继续学习。
雪    币: 538
活跃值: 活跃值 (16)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
Saver 活跃值 2008-2-19 13:43
22
0
太强了。。。
雪    币: 308
活跃值: 活跃值 (55)
能力值: ( LV12,RANK:470 )
在线值:
发帖
回帖
粉丝
zhuwg 活跃值 11 2008-2-19 16:17
23
0
跟着膜拜1下超级大牛
雪    币: 200
活跃值: 活跃值 (10)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
SomeTouche 活跃值 2008-2-19 23:07
24
0
其实我到觉得放弃这些ANTI很可惜,理想的ANTI应该这样,不仅替换INT1 INT3,甚至可以把CR3、IDT、GDT整个的替换掉!建立一个虚拟环境
,在虚拟环境中执行代码!

VM一方面要隐藏代码,一方面要防止load,总的来说应该是离x86体系越远越好,离x86越远越难以被分析
SF的VM基本还是很接近x86的,有诸如vm_eflags,vm_eax这样的东西,分析它只是时间问题
事实上我觉得从已经编译的EXE开始加壳是不可能离x86太远的,因为VM最终要归结到模拟x86指令,而如果要反汇编x86指令抽象出背后的逻辑
又是非常困难的
可能的更好的方法也许是在编译级加壳,这个级别可以直接获得程序的逻辑,从而可能设计出实现这些逻辑的远离x86的VM
甚至可以在神经网络中实现逻辑,这个连冯诺依曼体系都远离了,更难分析

不要教坏好人.简单说VM的虚拟解释技术导致了运行速度的直线下降.另外,那些换来换去的表实在是让人头疼.
即便脱离了冯诺依曼体系的计算机技术也会有它相应的破解技术的.或许LZ所说,3环下的加密也要有自己的强度,细胞状态机,神经加密算法离我们还有多远呢?
我们的目标是:有什么样的木头就有什么样的蛀虫~我啃~
雪    币: 5536
活跃值: 活跃值 (51)
能力值: (RANK:1060 )
在线值:
发帖
回帖
粉丝
forgot 活跃值 26 2008-2-21 02:01
25
0
楼上在说什么,太深奥了
游客
登录 | 注册 方可回帖
返回