手脱RLProtect 0.74 beta全保护

小生我怕怕 · 发表于 2008-11-30 21:14

【文章标题】: 手脱RLProtect 0.74 beta全保护
【文章作者】: 小生我怕怕
【作者主页】: www.52pojie.cn
【作者QQ号】: 4586631
【软件名称】: win98记事本
【软件大小】: 64.0 KB
【下载地址】: 附件里下载
【加壳方式】: 全保护
【保护方式】: RLP v0.74
【编写语言】: VC++
【使用工具】: 自我修改版OD，lordPE,importRCE
【操作平台】: windows xp
【作者声明】: 只是感兴趣，没有其他目的。失误之处敬请诸位大侠赐教!
--------------------------------------------------------------------------------
【详细过程】
  004010CC >  68 00D04000    push NotePad_.0040D000                      //载入OD，在载入时会有错误提示，不用管确定就好
  004010D1 E8 01000000    call NotePad_.004010D7                      //这样一看非常象是ASProtect的入口
  004010D6 C3             retn                                        //这里我先说一个快捷的方法，迟些我会在单步写一份脱文
  004010D7 C3             retn                                        //在命令行下断：bp GetModuleHandleA+5
  004010D8 0D 57B770C8    or eax,C870B757                            //这里加5是为了防止程序对断点的检测
  004010DD 2997 83AABFA6 sub dword ptr ds:[edi+A6BFAA83],edx       //shift+f9运行4次之后返回
  004010E3 FE             ???                                     ; 未知命令
  ━━━━━━━寄存器窗口━━━━━━━━━━━
  EAX 7C80B6A1 kernel32.GetModuleHandleA                                  //当寄存器显示我们断点时返回
  ECX 00900000                                                          //ait+f9返回到用户代码
  EDX 0040E5A0 ASCII "SHELL32.dll"
  EBX 00004000
  ESP 0012F7F8
  EBP 0012F7F8
  ESI 18F39831
  EDI 0040E5F0 ASCII "ShellExecuteA"
  EIP 7C80B6A6 kernel32.7C80B6A6
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D742 /EB 04          jmp short NotePad_.0040D748                //比较复杂的代码，全部是花指令加anti
  0040D744  ^|EB EB          jmp short NotePad_.0040D731                //所以我这里就只复制部分关键代码给大家做个演示
  0040D746 |04 EB          add al,0EB                                  //一路F8小心的走吧
  0040D748  ^\EB FB          jmp short NotePad_.0040D745
  0040D74A  ^ EB EB          jmp short NotePad_.0040D737
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D750 8B5D 3E       mov ebx,dword ptr ss:[ebp+3E]             //这里取我们的特殊函数放入EBX
  0040D753 EB 03          jmp short NotePad_.0040D758
  0040D755 CC             int3
  0040D756 EB 02          jmp short NotePad_.0040D75A
  0040D758  ^ EB FC          jmp short NotePad_.0040D756
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D78D 5A             pop edx                                     //这里读取我们的SHELL32.dll模块
  0040D78E F7C2 00000080 test edx,80000000                         //通常会在下面就开始读取到我们的IAT指针
  0040D794 74 0A          je short NotePad_.0040D7A0
  0040D796 5A             pop edx
  0040D797 EB 03          jmp short NotePad_.0040D79C
  0040D799 CC             int3
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D79E /EB 0E          jmp short NotePad_.0040D7AE
  0040D7A0 |47             inc edi                                     //这里逐位读取我们在EDI的指针
  0040D7A1 |803F 00       cmp byte ptr ds:[edi],0                   //这里比较EDI的指针还有多少位
  0040D7A4 |EB 03          jmp short NotePad_.0040D7A9
  0040D7A6 |CC             int3
  0040D7A7 /EB 02          jmp short NotePad_.0040D7AB
  0040D7A9  ^|EB FC          jmp short NotePad_.0040D7A7
  0040D7AB  ^\75 F3          jnz short NotePad_.0040D7A0                //上面如果读取完，这里的JNZ就不跳，向下走
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7AD 47             inc edi                               ; NotePad_.0040E5FD
  0040D7AE F3:          prefix rep:                               //单步到达这里
  0040D7AF 8038 CC       cmp byte ptr ds:[eax],0CC                   //这里检测我们API第一字节是否为CC，用来进行效验的
  0040D7B2 75 04          jnz short NotePad_.0040D7B8
  0040D7B4 33DB          xor ebx,ebx
  0040D7B6 33C0          xor eax,eax
  0040D7B8 8B1F          mov ebx,dword ptr ds:[edi]
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7B8 8B1F          mov ebx,dword ptr ds:[edi]                //把EDI的指针放入EBX
  0040D7BA 59             pop ecx                                     //我们在这里大家可以留意下汇编窗口下面的信息窗口。如下
  0040D7BB 50             push eax
  0040D7BC EB 04          jmp short NotePad_.0040D7C2
  ━━━━━━━信息窗口━━━━━━━━━━
  ds:[0040E5FE]=004063F0 (NotePad_.004063F0)                            //这里把我们的起始地址的计算，计算得出004063f0
  ebx=7C80ADA0 (kernel32.GetProcAddress)                                  //而这句就是通过特殊函数构造一个指针
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7BB 50             push eax                               ; SHELL32.ShellExecuteA
  0040D7BC EB 04          jmp short NotePad_.0040D7C2                //把EAX里的指针进行压栈
  0040D7BE  ^ EB EB          jmp short NotePad_.0040D7AB                //继续F8单步向下走
  0040D7C0 04 EB          add al,0EB
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7CA 33C0          xor eax,eax       ; SHELL32.ShellExecuteA  //这里清空我们在EAX里的指针，准备加密传送，所以这里要NOP掉
  0040D7CC EB 03          jmp short NotePad_.0040D7D1                //把上面的xor改NOP后我们在向下走几步
  0040D7CE CC             int3
  0040D7CF EB 02          jmp short NotePad_.0040D7D3
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7D3 F3:          prefix rep:                                  //当走到这里时停住我们的脚本，虽然这里是一个假跳转，但是一样会读取到我们下面的MOV
  0040D7D4 890B          mov dword ptr ds:[ebx],ecx                   //而这里把我们ECX里的垃圾传入EBX也就是传入我们当前IAT的起始地址
  0040D7D6 EB 04          jmp short NotePad_.0040D7DC                //这里我们需要把上面一句改为mov dword ptr ds:[ebx],eax
  0040D7D8  ^ EB EB          jmp short NotePad_.0040D7C5                //等于把我们的EAX的指针放入到我们的IAT的起始地址里
  0040D7DA 04 EB          add al,0EB                                  //具体为什么这样修改请看下面的寄存器窗口
  ━━━━━━━━寄存器窗口━━━━━━━━━━━━
  EAX 7D6111C0 SHELL32.ShellExecuteA                                     //我们的指针没有被清空完整存在EAX
  ECX 00900000                                                             //ECX里的是垃圾语句
  EDX 0040E5A0 ASCII "SHELL32.dll"
  EBX 004063F0 NotePad_.004063F0                                           //而EBX里存放的是我们IAT的起始地址
  ESP 0012F808
  EBP 0040D000 NotePad_.0040D000
  ESI 18F39831
  EDI 0040E5FE NotePad_.0040E5FE
  EIP 0040D7D3 NotePad_.0040D7D3
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7D6 /EB 04          jmp short NotePad_.0040D7DC                //当我们单步一步到达这里时，会发现我们的IAT已经出现在我们的数据窗口
  0040D7D8  ^|EB EB          jmp short NotePad_.0040D7C5                //现在开始我们需要单步小心的走啦，因为指令比较多，而且大部分是花，所以对分析就造成影响啦
  0040D7DA |04 EB          add al,0EB
  0040D7DC  ^\EB FB          jmp short NotePad_.0040D7D9
  0040D7DE  ^ EB EB          jmp short NotePad_.0040D7CB
  ━━━━━━━━数据窗口━━━━━━━━━━━
  004063F0  7D6111C0  SHELL32.ShellExecuteA                               //我们的第一处IAT指针已经进来啦
  004063F4  00000000                                                    //继续单步F8走吧
  004063F8  00000000
  004063FC  00000000
  00406400  00000000
  00406404  00000000
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D874 8B0B          mov ecx,dword ptr ds:[ebx]  ; SHELL32.ShellExecuteA //我们把这句NOP掉，因为他会处理掉我们的IAT
  0040D876 EB 04          jmp short NotePad_.0040D87C             //注意上面的这句，他是把我们的IAT地址传送到垃圾语句里进行加密
  0040D878 FFEB          jmp far ebx                            ; 非法使用寄存器
  0040D87A CC             int3                                     //具体为什么这样改请看下面的寄存器分析
  0040D87B  ^ EB EB          jmp short NotePad_.0040D868
  ━━━━━━━━寄存器窗口━━━━━━━━━━━━━
  EAX 7D6111C0 SHELL32.ShellExecuteA                               //我们的IAT依然存在我们的EAX
  ECX 0090000D                                                    //这里是垃圾语句
  EDX 0040E5A0 ASCII "SHELL32.dll"
  EBX 004063F0 NotePad_.004063F0                                  //EBX是我们的IAT的起始地址
  ESP 0012F808
  EBP 0040D000 NotePad_.0040D000
  ESI C79CC188
  EDI 0040E5FE NotePad_.0040E5FE
  EIP 0040D874 NotePad_.0040D874
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D8AB  ^\EB FC          jmp short NotePad_.0040D8A9
  0040D8AD 803F 01       cmp byte ptr ds:[edi],1                //这里会进行一个判断，判断我们的IAT是否处理完毕
  0040D8B0  ^ 0F85 74FEFFFF jnz NotePad_.0040D72A                   //这样看来我们的IAT已经处理完全啦
  0040D8B6 42             inc edx                               //我们F4运行到这行，呵呵，我们的IAT出来啦
  0040D8B7 EB 03          jmp short NotePad_.0040D8BC
  0040D8B9 CC             int3
  0040D8BA EB 02          jmp short NotePad_.0040D8BE
  0040D8BC  ^ EB FC          jmp short NotePad_.0040D8BA
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  004063F0  7D6111C0  SHELL32.ShellExecuteA                         //呵呵我们的IAT地址
  004063F4  7D5FB21E  SHELL32.DragAcceptFiles                         //继续F8向前走吧
  004063F8  7D632E22  SHELL32.ShellAboutA
  004063FC  7D6897EE  SHELL32.SHGetSpecialFolderPathA
  00406400  7D647BA9  SHELL32.DragQueryFileA
  00406404  7D647B98  SHELL32.DragFinish
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D8DB  ^\0F85 49FEFFFF jnz NotePad_.0040D72A                   //呵呵上面还有两句判断，判断IAT是否处理完
  0040D8E1 EB 04          jmp short NotePad_.0040D8E7             //当我们跳到这里时，我们的IAT就已经全部恢复啦
  0040D8E3  ^ EB EB          jmp short NotePad_.0040D8D0             //放心走吧
  0040D8E5 04 EB          add al,0EB
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D969 F3:          prefix rep:                            //呵呵，见鬼的anti
  0040D96A F1             int1                                  //我们注意下我们的堆栈窗口
  0040D96B F3:64:       prefix rep:
  0040D96D EB 04          jmp short NotePad_.0040D973
  0040D96F  ^ EB EB          jmp short NotePad_.0040D95C
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0012F804 7C9237BF  指向下一个 SEH 记录的指针                   //我们ctrl+g搜索0040d992
  0012F808 0040D992  SE处理程序                                  //注意这个SE句柄
  0012F80C 0012F8F0
  0012F810 0012FBD0
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D992 BD 00D04000    mov ebp,NotePad_.0040D000             //我们搜索到了这里，我们F2下断，shift+f9运行程序
  0040D997 F3:64:       prefix rep:                            //程序停下后我们继续F8单步向下走
  0040D999 8F05 00000000 pop dword ptr ds:[0]                   //其实所有这样的语句在这个壳里都是一个异常
  0040D99F 8BF5          mov esi,ebp
  0040D9A1 EB 03          jmp short NotePad_.0040D9A6
  0040D9A3  ^ EB EB          jmp short NotePad_.0040D990
  0040D9A5  ^ EB F3          jmp short NotePad_.0040D99A
  ━━━━━━Solen code的开始━━━━━
  0040D9C4 55             push ebp                               //这里是第一句被抽取的OEP
  0040D9C5 EB 03          jmp short NotePad_.0040D9CA
  0040D9C7  ^ EB EB          jmp short NotePad_.0040D9B4
  0040D9C9  ^ EB EB          jmp short NotePad_.0040D9B6
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D9D3 8BEC          mov ebp,esp                            //这里是我们的第二句被抽取的OEP
  0040D9D5 EB 03          jmp short NotePad_.0040D9DA
  0040D9D7  ^ EB EB          jmp short NotePad_.0040D9C4
  0040D9D9  ^ EB EB          jmp short NotePad_.0040D9C6
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D9E3 83EC 44       sub esp,44                            //这里是我们的第三句被抽取的OEP
  0040D9E6 EB 03          jmp short NotePad_.0040D9EB
  0040D9E8  ^ EB EB          jmp short NotePad_.0040D9D5
  0040D9EA  ^ EB EB          jmp short NotePad_.0040D9D7
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D9F4 56             push esi                               //这里是我们的第四句被抽取的OEP
  0040D9F5 EB 03          jmp short NotePad_.0040D9FA
  0040D9F7  ^ EB EB          jmp short NotePad_.0040D9E4
  0040D9F9  ^ EB EB          jmp short NotePad_.0040D9E6
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA03 FF15 E0634000 call dword ptr ds:[4063E0] ; kernel32.GetCommandLineA  //这里是我们的第五句被抽取的OEP
  0040DA09 EB 03          jmp short NotePad_.0040DA0E
  0040DA0B  ^ EB EB          jmp short NotePad_.0040D9F8
  0040DA0D  ^ EB EB          jmp short NotePad_.0040D9FA
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA17 8BF0          mov esi,eax                            //这里是我们的第六句被抽取的OEP
  0040DA19 EB 03          jmp short NotePad_.0040DA1E
  0040DA1B  ^ EB EB          jmp short NotePad_.0040DA08
  0040DA1D  ^ EB EB          jmp short NotePad_.0040DA0A
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA27 8A00          mov al,byte ptr ds:[eax]                //这里是我们的第七句被抽取的OEP
  0040DA29 EB 03          jmp short NotePad_.0040DA2E
  0040DA2B  ^ EB EB          jmp short NotePad_.0040DA18
  0040DA2D  ^ EB EB          jmp short NotePad_.0040DA1A
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA37 3C 22          cmp al,22                               //这里是我们的第八句被抽取的OEP
  0040DA39 EB 03          jmp short NotePad_.0040DA3E
  0040DA3B  ^ EB EB          jmp short NotePad_.0040DA28
  0040DA3D  ^ EB EB          jmp short NotePad_.0040DA2A
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA47  ^\FF25 7CD04000 jmp dword ptr ds:[40D07C]             ; NotePad_.<模块入口点>
  0040DA4D 0000          add byte ptr ds:[eax],al                //上面跳向我们OEP
  0040DA4F 0000          add byte ptr ds:[eax],al                //为什么这样判断，大家可以看一下反汇编窗口下面的信息窗口
  0040DA51 0000          add byte ptr ds:[eax],al
  ━━━━━━━信息窗口━━━━━━━━━━━━━
  ds:[0040D07C]=004010CC (NotePad_.<模块入口点>)                      //这里的0040D07C等于004010CC呵呵，脱壳留心点会发现奥妙
  ━━━━━━━整合的OEP━━━━━━━━━
  push ebp                                                             //这里是我们被抽取的全部OEP
  mov ebp,esp
  sub esp,44
  push esi
  call dword ptr ds:[4063E0]
  mov esi,eax
  mov al,byte ptr ds:[eax]
  cmp al,22
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  004010CC >  90             nop                                     //这里就是我们的OEP
  004010CD 90             nop                                     //开始补我们的OEP吧
  004010CE 90             nop
  004010CF 90             nop
  004010D0 90             nop
  004010D1 90             nop
  004010D2 90             nop
  004010D3 90             nop
  004010D4 90             nop
  004010D5 90             nop
  004010D6 90             nop
  004010D7 90             nop
  004010D8 90             nop
  004010D9 90             nop
  004010DA 90             nop
  004010DB 90             nop
  004010DC 90             nop
  004010DD 90             nop
  004010DE 90             nop
  004010DF 75 13          jnz short NotePad_.004010F4
  004010E1 46             inc esi
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  004010CC >  55             push ebp                               //修补好的OEP
  004010CD 8BEC          mov ebp,esp                            //我们运行我们的lordPE把程序dump
  004010CF 83EC 44       sub esp,44                               //在运行我们的importRCE修复下程序
  004010D2 56             push esi                               //呵呵成功脱壳并运行
  004010D3 FF15 E0634000 call dword ptr ds:[4063E0]             ; kernel32.GetCommandLineA
  004010D9 8BF0          mov esi,eax
  004010DB 8A00          mov al,byte ptr ds:[eax]
  004010DD 3C 22          cmp al,22
  004010DF 75 13          jnz short NotePad_.004010F4
  004010E1 46             inc esi
  004010E2 8A06          mov al,byte ptr ds:[esi]
  004010E4 84C0          test al,al

--------------------------------------------------------------------------------
【经验总结】
anti之多，检测之多，异常之多，麻烦之多，一个字累
但是对于这样的壳，更多的是需要大家精力集中，注意一些是完全可以绕过的
大家只要用心去玩一个壳，会发现他比算法更来得好玩！

--------------------------------------------------------------------------------
【版权声明】: 本文原创于小生我怕怕, 转载请注明作者并保持文章的完整, 谢谢!

                                                   2008年11月30日 21:08:50

[ 本帖最后由小生我怕怕于 2008-11-30 21:29 编辑 ]

小生我怕怕 · 发表于 2008-11-30 21:16

004010CC >  68 00D04000     push NotePad_.0040D000                       //载入OD，在载入时会有错误提示，不用管确定就好
004010D1    E8 01000000     call NotePad_.004010D7                       //这样一看非常象是ASProtect的入口
004010D6    C3              retn                                         //好我们单步开工吧
004010D7    C3              retn                                         //先一路F7单步向下走
004010D8    0D 57B770C8     or eax,C870B757                              
004010DD    2997 83AABFA6   sub dword ptr ds:[edi+A6BFAA83],edx          
004010E3    FE              ???                                      ; 未知命令
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D0CC    60              pushad                                       //呵呵一路F7到了这里
0040D0CD    8BDD            mov ebx,ebp                                  //我们继续一路F8向下走吧
0040D0CF    E8 00000000     call NotePad_.0040D0D4
0040D0D4    5D              pop ebp
0040D0D5    95              xchg eax,ebp
0040D0D6    32C0            xor al,al
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D0FD    40              inc eax
0040D0FE    49              dec ecx
0040D0FF  ^ 75 F8           jnz short NotePad_.0040D0F9                 //这个JNZ是一个解码的指令
0040D101    64:8B86 3D30000>mov eax,dword ptr fs:[esi+303D]             //我们F4在这一行把他打断吧
0040D108    0FB9            ???                                      ; 未知命令
0040D10A    FF4B 89         dec dword ptr ds:[ebx-77]
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D159    C1C3 07         rol ebx,7
0040D15C    42              inc edx
0040D15D    49              dec ecx
0040D15E  ^ 75 E3           jnz short NotePad_.0040D143                 //这个JNZ是一个解码的指令
0040D160    5D              pop ebp                                     //我们F4在这一行把他打断吧
0040D161    89D5            mov ebp,edx
0040D163    16              push ss
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D170    F3:             prefix rep:                                 //可怕的开始，接二连三的anti，我们小心点走吧
0040D171    40              inc eax                                     //F8单步小心的走
0040D172    EB 03           jmp short NotePad_.0040D177
0040D174    CC              int3
0040D175    EB 02           jmp short NotePad_.0040D179
0040D177  ^ EB FC           jmp short NotePad_.0040D175
0040D179    66:81F9 61C3    cmp cx,0C361
0040D17E    EB 03           jmp short NotePad_.0040D183
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D181   /EB 02           jmp short NotePad_.0040D185
0040D183  ^|EB FC           jmp short NotePad_.0040D181
0040D185  ^\75 E7           jnz short NotePad_.0040D16E                 //这里向上跳，也是解码指令
0040D187    40              inc eax                                     //我们F4在这行打断
0040D188    2BC5            sub eax,ebp
0040D18A    8985 84000000   mov dword ptr ss:[ebp+84],eax
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D19E    8B08            mov ecx,dword ptr ds:[eax]
0040D1A0    40              inc eax
0040D1A1    F3:             prefix rep:
0040D1A2    81F9 44332211   cmp ecx,11223344
0040D1A8  ^ 75 ED           jnz short NotePad_.0040D197                 //这里向上跳，也是解码指令
0040D1AA    83C0 03         add eax,3                                   //我们F4在这行打断
0040D1AD    2BC5            sub eax,ebp
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D1CA  ^\EB FC           jmp short NotePad_.0040D1C8
0040D1CC  ^ 75 EE           jnz short NotePad_.0040D1BC                 //这里向上跳，也是解码指令
0040D1CE    83C0 03         add eax,3                                   //我们F4在这行打断
0040D1D1    2BC5            sub eax,ebp
0040D1D3    8985 8C000000   mov dword ptr ss:[ebp+8C],eax
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D1F9   /EB 02           jmp short NotePad_.0040D1FD
0040D1FB  ^|EB FC           jmp short NotePad_.0040D1F9
0040D1FD  ^\75 E1           jnz short NotePad_.0040D1E0                 //这里向上跳，也是解码指令
0040D1FF    83C0 03         add eax,3                                   //我们F4在这行打断
0040D202    2BC5            sub eax,ebp                                 //接下来指令比较混乱，我也就直接复制关键啦
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D2A9    64:8925 0000000>mov dword ptr fs:[0],esp                    
0040D2B0    F3:             prefix rep:                                 //这里是anti
0040D2B1    F1              int1                                        //我们注意一下我们的堆栈窗口
0040D2B2    F3:64:          prefix rep:
━━━━━━━━堆栈窗口━━━━━━━━━━━
0012FF9C   0012FFE0  指向下一个 SEH 记录的指针
0012FFA0   0040D2D9  SE处理程序                                         //我们ctrl+G搜索0040d2d9
0012FFA4   7C930738  ntdll.7C930738
0012FFA8   FFFFFFFF
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D2D9    BD 00D04000     mov ebp,NotePad_.0040D000                   //F2下断，shift+f9运行程序
0040D2DE    F3:             prefix rep:
0040D2DF    EB 03           jmp short NotePad_.0040D2E4
0040D2E1  ^ EB EB           jmp short NotePad_.0040D2CE
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D2E5    8F05 00000000   pop dword ptr ds:[0]
0040D2EB    8BF5            mov esi,ebp
0040D2ED    E8 2D120000     call NotePad_.0040E51F                     //这个CALL我们F7跟进
0040D2F2    C745 7C 01BBC96>mov dword ptr ss:[ebp+7C],67C9BB01
0040D2F9    33C0            xor eax,eax
━━━━━━━━━━CALL内内容━━━━━━━━━━━
0040E51F    60              pushad                                     //好我们一路F8开跑吧
0040E520    8BBD 94000000   mov edi,dword ptr ss:[ebp+94]
0040E526    03FD            add edi,ebp
0040E528    8B5D 3A         mov ebx,dword ptr ss:[ebp+3A]
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040E551    803E CC         cmp byte ptr ds:[esi],0CC                  //这里检测我们的第一字节是否为CC，进行效验
0040E554    74 1A           je short NotePad_.0040E570 
0040E556    6A 00           push 0
0040E558    68 80000000     push 80
0040E55D    6A 03           push 3
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040E56E   /74 09           je short NotePad_.0040E579      
0040E570   |896D 7C         mov dword ptr ss:[ebp+7C],ebp               //这句会检测OD
0040E573   |8BA5 B0000000   mov esp,dword ptr ss:[ebp+B0]               //这里也会
0040E579   \4D              dec ebp                                     //我们把这两句NOP掉，当然如果你的OD调试力强，也可以不改
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D37E    F3:             prefix rep:                                 //这个假跳转，会把我们送入下面的CALL
0040D37F    E8 44090000     call NotePad_.0040DCC8                      //我们单步F8就会跟进这个CALL里
0040D384    EB 03           jmp short NotePad_.0040D389
0040D386  ^ EB EB           jmp short NotePad_.0040D373
━━━━━━━━━━CALL内内容━━━━━━━━━━━
0040DCC8    60              pushad                                     //好我们一路F8开跑吧
0040DCC9    E8 00000000     call NotePad_.0040DCCE
0040DCCE    5D              pop ebp
0040DCCF    EB 23           jmp short NotePad_.0040DCF4
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040DD14    85C0            test eax,eax
0040DD16    74 09           je short NotePad_.0040DD21                  //把JE改JMP跳过检测
0040DD18    896E 7C         mov dword ptr ds:[esi+7C],ebp               //或者把这里NOP掉
0040DD1B    8BA6 B0000000   mov esp,dword ptr ds:[esi+B0]               //把这里NOP掉
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D3FB    64:8925 0000000>mov dword ptr fs:[0],esp                    //在一次碰上了anti，同样注意我们的堆栈窗口
0040D402    F3:             prefix rep:
0040D403    F1              int1
0040D404    F3:64:          prefix rep:
━━━━━━━━堆栈窗口━━━━━━━━━━━
0012FBC8   7C9237BF  指向下一个 SEH 记录的指针
0012FBCC   0040D42B  SE处理程序                                         //我们ctrl+g搜索0040d42b
0012FBD0   0012FCB4
0012FBD4   0012FF9C
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D42B    BD 00D04000     mov ebp,NotePad_.0040D000                   //我们f2下断,shift+f9运行程序
0040D430    F3:64:          prefix rep:                                 //程序停下后我们继续F8单步向下走
0040D432    8F05 00000000   pop dword ptr ds:[0]
0040D438    8BF5            mov esi,ebp
0040D43A    EB 03           jmp short NotePad_.0040D43F
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D56F    F3:             prefix rep:                                //当走到这里时我们放慢我们的脚步
0040D570    55              push ebp                                   //我们F8单步慢慢的走
0040D571    B9 EC354000     mov ecx,NotePad_.004035EC
0040D576    81E9 41304000   sub ecx,NotePad_.00403041
0040D57C    03CD            add ecx,ebp
━━━━━━━━━堆栈窗口━━━━━━━━━━━━
0040D5A7    33C0            xor eax,eax      ; NotePad_.0040E355        //当我们走到这里时我们的SE句柄在次出现在我们的堆栈窗口
0040D5A9    8700            xchg dword ptr ds:[eax],eax                 //这里是一个anti
0040D5AB    64:8F05 0000000>pop dword ptr fs:[0]
0040D5B2    83C4 04         add esp,4
━━━━━━━━━━━━━━━━━━━━━━━━━━
0012F7F0   7C9237BF  指向下一个 SEH 记录的指针                          
0012F7F4   0040E34D  SE处理程序                                         //我们ctrl+g搜索0040e34d
0012F7F8   0040D000  NotePad_.0040D000
0012F7FC   0012F8E0
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040E34D    E8 00000000     call NotePad_.0040E352                      //我们来到这里，继续小心点走
0040E352    5E              pop esi                                     //我们F8单步小心向下走
0040E353    EB 0C           jmp short NotePad_.0040E361
0040E355    AB              stos dword ptr es:[edi]
0040E356    D5 40           aad 40
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040E36A    8B1E            mov ebx,dword ptr ds:[esi]                  //当我们走这里时注意我们下面的地址0040D5AB
0040E36C    8998 B8000000   mov dword ptr ds:[eax+B8],ebx            ; NotePad_.0040D5AB
0040E372    8BCB            mov ecx,ebx                                 //如果我们这里不选择跳过的话就会直接通过结尾的retn反回到系统里去
0040E374    83C6 04         add esi,4                                   //我们ctrl+G搜索0040D5AB
0040E377    8B1E            mov ebx,dword ptr ds:[esi]
0040E379    8998 C4000000   mov dword ptr ds:[eax+C4],ebx
0040E37F    83C6 04         add esi,4
0040E382    8B1E            mov ebx,dword ptr ds:[esi]
0040E384    8998 B4000000   mov dword ptr ds:[eax+B4],ebx
0040E38A    8378 04 00      cmp dword ptr ds:[eax+4],0
0040E38E    75 19           jnz short NotePad_.0040E3A9
0040E390    8378 08 00      cmp dword ptr ds:[eax+8],0
0040E394    75 13           jnz short NotePad_.0040E3A9
0040E396    8378 0C 00      cmp dword ptr ds:[eax+C],0
0040E39A    75 0D           jnz short NotePad_.0040E3A9
0040E39C    8378 10 00      cmp dword ptr ds:[eax+10],0
0040E3A0    75 07           jnz short NotePad_.0040E3A9
0040E3A2    B8 00000000     mov eax,0
0040E3A7    C9              leave
0040E3A8    C3              retn                                       //这里直接就跑向系统
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D5AB    64:8F05 0000000>pop dword ptr fs:[0]                     ; ntdll.7C9237BF  //我们在这里f2下断，shift+f9运行到所选
0040D5B2    83C4 04         add esp,4                                  //继续F8单步小心的走
0040D5B5    5D              pop ebp
0040D5B6    B8 41304000     mov eax,NotePad_.00403041
0040D5BB    BA F7354000     mov edx,NotePad_.004035F7
0040D5C0    2BD0            sub edx,eax
0040D5C2    8BC2            mov eax,edx
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D5CA    03EA            add ebp,edx
0040D5CC    50              push eax
0040D5CD    0F31            rdtsc                                     //这里是一个anti但是不用管他我们继续向下走
0040D5CF    59              pop ecx
0040D5D0    91              xchg eax,ecx
0040D5D1    60              pushad
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D5DB    C645 17 90      mov byte ptr ss:[ebp+17],90              //走到这里时需要注意一下啦
0040D5DF    C645 18 CC      mov byte ptr ss:[ebp+18],0CC             //这里是CC效验
0040D5E3    CC              int3                                     //这里是anti
0040D5E4    8B6424 08       mov esp,dword ptr ss:[esp+8]             //当我们走int3处时，我们可以选择在这行F2下断或者shift+f9
0040D5E8    64:8F05 0000000>pop dword ptr fs:[0]                     //当然大家也可以注意到达int3时的堆栈窗口
0040D5EF    83C4 04         add esp,4
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D5F9    C645 4B 0F      mov byte ptr ss:[ebp+4B],0F
0040D5FD    C645 4C 31      mov byte ptr ss:[ebp+4C],31
0040D601    90              nop                                     //这两句NOP会受到上面的两句MOV的影响进行变化，但是不用怕，我们单步走就是
0040D602    90              nop
0040D603    C645 4B 90      mov byte ptr ss:[ebp+4B],90
0040D607    C645 4C CC      mov byte ptr ss:[ebp+4C],0CC            //这里继续CC效验检测
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D611    3D 00009000     cmp eax,900000                          //单步到达这里时需要注意啦
0040D616    76 03           jbe short NotePad_.0040D61B             //这里改JBE改JMP，否则执行下面的ANTI
0040D618    C1C5 08         rol ebp,8                               //这里是一句anti，当然我们也可以把他NOP掉
0040D61B    F3:             prefix rep:
0040D61C    EB 04           jmp short NotePad_.0040D622
━━━━━━━━━━━━━━━━━━━━━━━━━━
0040D6D6   /76 02           jbe short NotePad_.0040D6DA             //这里改JBE改JMP，否则执行下面的ANTI
0040D6D8   |33E9            xor ebp,ecx                             //这里也是一个anti,我们可以把他NOP掉
0040D6DA   \8BF5            mov esi,ebp                             //接下来就是接上我们上面的脱文的IAT处理到修复OEP部分啦
0040D6DC    E8 77070000     call NotePad_.0040DE58
━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D742   /EB 04           jmp short NotePad_.0040D748                  //比较复杂的代码，全部是花指令加anti
  0040D744  ^|EB EB           jmp short NotePad_.0040D731                  //所以我这里就只复制部分关键代码给大家做个演示
  0040D746   |04 EB           add al,0EB                                   //一路F8小心的走吧
  0040D748  ^\EB FB           jmp short NotePad_.0040D745
  0040D74A  ^ EB EB           jmp short NotePad_.0040D737
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D750    8B5D 3E         mov ebx,dword ptr ss:[ebp+3E]                //这里取我们的特殊函数放入EBX
  0040D753    EB 03           jmp short NotePad_.0040D758
  0040D755    CC              int3
  0040D756    EB 02           jmp short NotePad_.0040D75A
  0040D758  ^ EB FC           jmp short NotePad_.0040D756
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D78D    5A              pop edx                                      //这里读取我们的SHELL32.dll模块
  0040D78E    F7C2 00000080   test edx,80000000                            //通常会在下面就开始读取到我们的IAT指针
  0040D794    74 0A           je short NotePad_.0040D7A0
  0040D796    5A              pop edx
  0040D797    EB 03           jmp short NotePad_.0040D79C
  0040D799    CC              int3
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D79E   /EB 0E           jmp short NotePad_.0040D7AE
  0040D7A0   |47              inc edi                                      //这里逐位读取我们在EDI的指针
  0040D7A1   |803F 00         cmp byte ptr ds:[edi],0                      //这里比较EDI的指针还有多少位
  0040D7A4   |EB 03           jmp short NotePad_.0040D7A9
  0040D7A6   |CC              int3
  0040D7A7   /EB 02           jmp short NotePad_.0040D7AB
  0040D7A9  ^|EB FC           jmp short NotePad_.0040D7A7
  0040D7AB  ^\75 F3           jnz short NotePad_.0040D7A0                  //上面如果读取完，这里的JNZ就不跳，向下走
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7AD    47              inc edi                                  ; NotePad_.0040E5FD
  0040D7AE    F3:             prefix rep:                                  //单步到达这里
  0040D7AF    8038 CC         cmp byte ptr ds:[eax],0CC                    //这里检测我们API第一字节是否为CC，用来进行效验的
  0040D7B2    75 04           jnz short NotePad_.0040D7B8
  0040D7B4    33DB            xor ebx,ebx
  0040D7B6    33C0            xor eax,eax
  0040D7B8    8B1F            mov ebx,dword ptr ds:[edi]
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7B8    8B1F            mov ebx,dword ptr ds:[edi]                   //把EDI的指针放入EBX
  0040D7BA    59              pop ecx                                      //我们在这里大家可以留意下汇编窗口下面的信息窗口。如下
  0040D7BB    50              push eax
  0040D7BC    EB 04           jmp short NotePad_.0040D7C2
  ━━━━━━━信息窗口━━━━━━━━━━
  ds:[0040E5FE]=004063F0 (NotePad_.004063F0)                               //这里把我们的起始地址的计算，计算得出004063f0
  ebx=7C80ADA0 (kernel32.GetProcAddress)                                   //而这句就是通过特殊函数构造一个指针
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7BB    50              push eax                                 ; SHELL32.ShellExecuteA
  0040D7BC    EB 04           jmp short NotePad_.0040D7C2                  //把EAX里的指针进行压栈
  0040D7BE  ^ EB EB           jmp short NotePad_.0040D7AB                  //继续F8单步向下走
  0040D7C0    04 EB           add al,0EB
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7CA    33C0            xor eax,eax          ; SHELL32.ShellExecuteA  //这里清空我们在EAX里的指针，准备加密传送，所以这里要NOP掉
  0040D7CC    EB 03           jmp short NotePad_.0040D7D1                   //把上面的xor改NOP后我们在向下走几步
  0040D7CE    CC              int3
  0040D7CF    EB 02           jmp short NotePad_.0040D7D3
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7D3    F3:             prefix rep:                                   //当走到这里时停住我们的脚本，虽然这里是一个假跳转，但是一样会读取到我们下面的MOV
  0040D7D4    890B            mov dword ptr ds:[ebx],ecx                    //而这里把我们ECX里的垃圾传入EBX也就是传入我们当前IAT的起始地址
  0040D7D6    EB 04           jmp short NotePad_.0040D7DC                   //这里我们需要把上面一句改为mov dword ptr ds:[ebx],eax
  0040D7D8  ^ EB EB           jmp short NotePad_.0040D7C5                   //等于把我们的EAX的指针放入到我们的IAT的起始地址里
  0040D7DA    04 EB           add al,0EB                                    //具体为什么这样修改请看下面的寄存器窗口
  ━━━━━━━━寄存器窗口━━━━━━━━━━━━
  EAX 7D6111C0 SHELL32.ShellExecuteA                                        //我们的指针没有被清空完整存在EAX
  ECX 00900000                                                              //ECX里的是垃圾语句
  EDX 0040E5A0 ASCII "SHELL32.dll" 
  EBX 004063F0 NotePad_.004063F0                                            //而EBX里存放的是我们IAT的起始地址
  ESP 0012F808
  EBP 0040D000 NotePad_.0040D000
  ESI 18F39831
  EDI 0040E5FE NotePad_.0040E5FE
  EIP 0040D7D3 NotePad_.0040D7D3
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D7D6   /EB 04           jmp short NotePad_.0040D7DC                   //当我们单步一步到达这里时，会发现我们的IAT已经出现在我们的数据窗口
  0040D7D8  ^|EB EB           jmp short NotePad_.0040D7C5                   //现在开始我们需要单步小心的走啦，因为指令比较多，而且大部分是花，所以对分析就造成影响啦
  0040D7DA   |04 EB           add al,0EB
  0040D7DC  ^\EB FB           jmp short NotePad_.0040D7D9
  0040D7DE  ^ EB EB           jmp short NotePad_.0040D7CB
  ━━━━━━━━数据窗口━━━━━━━━━━━
  004063F0  7D6111C0  SHELL32.ShellExecuteA                                //我们的第一处IAT指针已经进来啦
  004063F4  00000000                                                       //继续单步F8走吧
  004063F8  00000000
  004063FC  00000000
  00406400  00000000
  00406404  00000000
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D874    8B0B            mov ecx,dword ptr ds:[ebx]  ; SHELL32.ShellExecuteA    //我们把这句NOP掉，因为他会处理掉我们的IAT
  0040D876    EB 04           jmp short NotePad_.0040D87C               //注意上面的这句，他是把我们的IAT地址传送到垃圾语句里进行加密
  0040D878    FFEB            jmp far ebx                              ; 非法使用寄存器
  0040D87A    CC              int3                                      //具体为什么这样改请看下面的寄存器分析
  0040D87B  ^ EB EB           jmp short NotePad_.0040D868
  ━━━━━━━━寄存器窗口━━━━━━━━━━━━━
  EAX 7D6111C0 SHELL32.ShellExecuteA                                //我们的IAT依然存在我们的EAX
  ECX 0090000D                                                      //这里是垃圾语句
  EDX 0040E5A0 ASCII "SHELL32.dll"
  EBX 004063F0 NotePad_.004063F0                                    //EBX是我们的IAT的起始地址
  ESP 0012F808                                                      
  EBP 0040D000 NotePad_.0040D000
  ESI C79CC188
  EDI 0040E5FE NotePad_.0040E5FE
  EIP 0040D874 NotePad_.0040D874
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D8AB  ^\EB FC           jmp short NotePad_.0040D8A9
  0040D8AD    803F 01         cmp byte ptr ds:[edi],1                  //这里会进行一个判断，判断我们的IAT是否处理完毕
  0040D8B0  ^ 0F85 74FEFFFF   jnz NotePad_.0040D72A                    //这样看来我们的IAT已经处理完全啦
  0040D8B6    42              inc edx                                  //我们F4运行到这行，呵呵，我们的IAT出来啦
  0040D8B7    EB 03           jmp short NotePad_.0040D8BC
  0040D8B9    CC              int3
  0040D8BA    EB 02           jmp short NotePad_.0040D8BE
  0040D8BC  ^ EB FC           jmp short NotePad_.0040D8BA
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  004063F0  7D6111C0  SHELL32.ShellExecuteA                            //呵呵我们的IAT地址
  004063F4  7D5FB21E  SHELL32.DragAcceptFiles                          //继续F8向前走吧
  004063F8  7D632E22  SHELL32.ShellAboutA
  004063FC  7D6897EE  SHELL32.SHGetSpecialFolderPathA
  00406400  7D647BA9  SHELL32.DragQueryFileA
  00406404  7D647B98  SHELL32.DragFinish
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D8DB  ^\0F85 49FEFFFF   jnz NotePad_.0040D72A                    //呵呵上面还有两句判断，判断IAT是否处理完
  0040D8E1    EB 04           jmp short NotePad_.0040D8E7              //当我们跳到这里时，我们的IAT就已经全部恢复啦
  0040D8E3  ^ EB EB           jmp short NotePad_.0040D8D0              //放心走吧
  0040D8E5    04 EB           add al,0EB
  ━━━━━━━━━━━━━━━━━━━━━━━━━━          
  0040D969    F3:             prefix rep:                              //呵呵，见鬼的anti
  0040D96A    F1              int1                                     //我们注意下我们的堆栈窗口
  0040D96B    F3:64:          prefix rep:
  0040D96D    EB 04           jmp short NotePad_.0040D973
  0040D96F  ^ EB EB           jmp short NotePad_.0040D95C
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0012F804   7C9237BF  指向下一个 SEH 记录的指针                      //我们ctrl+g搜索0040d992
  0012F808   0040D992  SE处理程序                                     //注意这个SE句柄
  0012F80C   0012F8F0
  0012F810   0012FBD0
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D992    BD 00D04000     mov ebp,NotePad_.0040D000               //我们搜索到了这里，我们F2下断，shift+f9运行程序
  0040D997    F3:64:          prefix rep:                             //程序停下后我们继续F8单步向下走
  0040D999    8F05 00000000   pop dword ptr ds:[0]                    //其实所有这样的语句在这个壳里都是一个异常
  0040D99F    8BF5            mov esi,ebp
  0040D9A1    EB 03           jmp short NotePad_.0040D9A6
  0040D9A3  ^ EB EB           jmp short NotePad_.0040D990
  0040D9A5  ^ EB F3           jmp short NotePad_.0040D99A
  ━━━━━━Solen code的开始━━━━━
  0040D9C4    55              push ebp                                //这里是第一句被抽取的OEP
  0040D9C5    EB 03           jmp short NotePad_.0040D9CA
  0040D9C7  ^ EB EB           jmp short NotePad_.0040D9B4
  0040D9C9  ^ EB EB           jmp short NotePad_.0040D9B6
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D9D3    8BEC            mov ebp,esp                             //这里是我们的第二句被抽取的OEP
  0040D9D5    EB 03           jmp short NotePad_.0040D9DA
  0040D9D7  ^ EB EB           jmp short NotePad_.0040D9C4
  0040D9D9  ^ EB EB           jmp short NotePad_.0040D9C6
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D9E3    83EC 44         sub esp,44                              //这里是我们的第三句被抽取的OEP
  0040D9E6    EB 03           jmp short NotePad_.0040D9EB
  0040D9E8  ^ EB EB           jmp short NotePad_.0040D9D5
  0040D9EA  ^ EB EB           jmp short NotePad_.0040D9D7
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040D9F4    56              push esi                                //这里是我们的第四句被抽取的OEP
  0040D9F5    EB 03           jmp short NotePad_.0040D9FA
  0040D9F7  ^ EB EB           jmp short NotePad_.0040D9E4
  0040D9F9  ^ EB EB           jmp short NotePad_.0040D9E6
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA03    FF15 E0634000   call dword ptr ds:[4063E0] ; kernel32.GetCommandLineA  //这里是我们的第五句被抽取的OEP
  0040DA09    EB 03           jmp short NotePad_.0040DA0E            
  0040DA0B  ^ EB EB           jmp short NotePad_.0040D9F8
  0040DA0D  ^ EB EB           jmp short NotePad_.0040D9FA
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA17    8BF0            mov esi,eax                              //这里是我们的第六句被抽取的OEP
  0040DA19    EB 03           jmp short NotePad_.0040DA1E
  0040DA1B  ^ EB EB           jmp short NotePad_.0040DA08
  0040DA1D  ^ EB EB           jmp short NotePad_.0040DA0A
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA27    8A00            mov al,byte ptr ds:[eax]                   //这里是我们的第七句被抽取的OEP
  0040DA29    EB 03           jmp short NotePad_.0040DA2E
  0040DA2B  ^ EB EB           jmp short NotePad_.0040DA18
  0040DA2D  ^ EB EB           jmp short NotePad_.0040DA1A
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA37    3C 22           cmp al,22                                  //这里是我们的第八句被抽取的OEP
  0040DA39    EB 03           jmp short NotePad_.0040DA3E
  0040DA3B  ^ EB EB           jmp short NotePad_.0040DA28
  0040DA3D  ^ EB EB           jmp short NotePad_.0040DA2A
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  0040DA47  ^\FF25 7CD04000   jmp dword ptr ds:[40D07C]                ; NotePad_.<模块入口点>
  0040DA4D    0000            add byte ptr ds:[eax],al                   //上面跳向我们OEP
  0040DA4F    0000            add byte ptr ds:[eax],al                   //为什么这样判断，大家可以看一下反汇编窗口下面的信息窗口
  0040DA51    0000            add byte ptr ds:[eax],al
  ━━━━━━━信息窗口━━━━━━━━━━━━━
  ds:[0040D07C]=004010CC (NotePad_.<模块入口点>)                         //这里的0040D07C等于004010CC呵呵，脱壳留心点会发现奥妙
  ━━━━━━━整合的OEP━━━━━━━━━
  push ebp                                                               //这里是我们被抽取的全部OEP
  mov ebp,esp                                                            
  sub esp,44
  push esi
  call dword ptr ds:[4063E0]
  mov esi,eax
  mov al,byte ptr ds:[eax]
  cmp al,22 
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  004010CC >  90              nop                                       //这里就是我们的OEP
  004010CD    90              nop                                       //开始补我们的OEP吧
  004010CE    90              nop
  004010CF    90              nop
  004010D0    90              nop
  004010D1    90              nop
  004010D2    90              nop
  004010D3    90              nop
  004010D4    90              nop
  004010D5    90              nop
  004010D6    90              nop
  004010D7    90              nop
  004010D8    90              nop
  004010D9    90              nop
  004010DA    90              nop
  004010DB    90              nop
  004010DC    90              nop
  004010DD    90              nop
  004010DE    90              nop
  004010DF    75 13           jnz short NotePad_.004010F4
  004010E1    46              inc esi
  ━━━━━━━━━━━━━━━━━━━━━━━━━━
  004010CC >  55              push ebp                                  //修补好的OEP
  004010CD    8BEC            mov ebp,esp                               //我们运行我们的lordPE把程序dump
  004010CF    83EC 44         sub esp,44                                //在运行我们的importRCE修复下程序
  004010D2    56              push esi                                  //呵呵成功脱壳并运行
  004010D3    FF15 E0634000   call dword ptr ds:[4063E0]               ; kernel32.GetCommandLineA
  004010D9    8BF0            mov esi,eax
  004010DB    8A00            mov al,byte ptr ds:[eax]
  004010DD    3C 22           cmp al,22
  004010DF    75 13           jnz short NotePad_.004010F4
  004010E1    46              inc esi
  004010E2    8A06            mov al,byte ptr ds:[esi]
  004010E4    84C0            test al,al

[ 本帖最后由小生我怕怕于 2008-11-30 22:32 编辑 ]

ximo · 发表于 2008-11-30 21:17

学习加膜拜

marvell · 发表于 2008-11-30 22:09

看不懂....= = 支持原创.............. 只有按脱文重做次的份了:'(

qifeon · 发表于 2008-11-30 22:42

很好很强大。

熊猫 · 发表于 2008-11-30 23:19

完全看不懂

janyou · 发表于 2008-11-30 23:27

收藏，仔细学习学习

dlzc · 发表于 2008-11-30 23:53

学习了..等碰到这种壳时再研究了..好难的壳啊....

wiliiwin · 发表于 2008-11-30 23:54

很好的文章很强大的文章哈哈

open5858 · 发表于 2008-12-1 01:04

小生大的文章每篇都分係的相當清楚
真強大，膜拜學習

帐号		自动登录	找回密码
密码			注册[Register]

[原创] 手脱RLProtect 0.74 beta全保护

免费评分

单步的过程