吾爱破解脱壳练习----PEBundle 2.0b5 - 3.0x

小生我怕怕 · 发表于 2008-10-22 09:30

一转眼我们的脱壳练习已经第17期啦，在这其中我相信许多的朋友也学习到了东西
必能脱掉此壳
本期考核主题为：PEBundle 2.0b5 - 3.0x
1.脱壳后的文件大家以千脑形式上传,目的是为了便于隐藏文件和节约论坛空间
2.脱壳后的文件,请大家以脱文附带脱壳后程序打包压缩传于千脑网盘
3.对于回帖过程中千万不要出现灌水,否则BAN了ID
4.对于有优秀脱文或优秀脱壳方法的朋友,给于适当威望奖励
5.鉴于此练习是针对论坛的所有人,请大家踊跃参加,如果不是脱了壳教作业的,请不要顶帖子,方便管理查阅,及时给出评分
6.以下为需要设置威望的格式
7.脱壳一以周期计算,(周期=等于二天)
8.脱壳周期一结束,就开始公布答案让大家能有更充分的学习环境,让不懂脱的朋友去寻找你失误的地方争取早日赶上论坛的积极份子
9.我们要的是脱文,并不是脱壳机去脱的,如果用脱机脱了别拿来,请一定附带上脱文
10.我们讲对每次脱壳练习选择一个最好的脱壳分析过程，方便大家学习，每次脱壳练习结束后会说出楼数，对于被选种的朋友，我们会酌情给予CB或者威望进行奖励
11.由于前段时间我们的练习群开放式验证加入，导致群在短短几天爆满，现在已经清除了所有没有参加练习的朋友，以后只要参加我们一次练习就会收到我们的短消息邀请加入
平时我们都是关闭模式
12.本期看点：积累经验，以不变应万变的处事来对待，在单步跟踪中直接寻找出我们的关键,记住不要一味想着importRCE的等级三或者等级一修复,寻找magic jump才是王道!

公告:
经群内的朋友商议之后见大部分有参与习惯的会员都参加了练习，相信也有很多会员在等着观看答案，所以提前开放第16期练习

紧急通知:
由于昨晚我这里停电导致作业无法发布，在这里深感抱歉

练习一：（结果已经公布）
http://www.52pojie.cn/thread-10496-1-1.html
最佳分析：第10楼unpack

练习二：（结果已经公布）
http://www.52pojie.cn/thread-10607-1-1.html
最佳分析：第9楼lqiulu

练习三：（结果已经公布）
http://www.52pojie.cn/thread-10688-1-1.html
最佳分析：第11楼傻人有傻福

练习四：（结果已经公布）
http://www.52pojie.cn/thread-10850-1-1.html
最佳分析：第11楼维护世界和平

练习五：（结果已经公布）
http://www.52pojie.cn/thread-10990-1-1.html
最佳分析：第3楼维护世界和平

练习六：（结果已经公布）
http://www.52pojie.cn/thread-11112-1-1.html
最佳分析：第12楼ximo

练习七：（结果已经公布）
http://www.52pojie.cn/thread-11244-1-1.html
最佳分析：第14楼傻人有傻福

练习八：(结果已经公布)
http://www.52pojie.cn/thread-11306-1-1.html
最佳分析：第15楼unpack

练习九：(结果已经公布)
http://www.52pojie.cn/thread-11446-1-1.html
最佳分析：第1楼小生我怕怕

练习十：(结果已经公布)
http://www.52pojie.cn/thread-11585-1-1.html
最佳分析：第10楼unpack

练习十一：(结果已经公布)
http://www.52pojie.cn/thread-11747-1-1.html
最佳分析：第9楼unpack

练习十二：(结果已经公布)
http://www.52pojie.cn/thread-11883-1-1.html
最佳分析：第19楼unpack

练习十三：(结果已经公布)
http://www.52pojie.cn/thread-12011-1-1.html
最佳分析：第1楼小生我怕怕

练习十四：(结果已经公布)
http://www.52pojie.cn/thread-12135-1-1.html
最佳分析：第3楼 qiulu

练习十五：(结果已经公布)
http://www.52pojie.cn/thread-12279-1-1.html
最佳分析：第13楼pcfans

练习十六：(结果已经公布)
http://www.52pojie.cn/thread-12362-1-1.html
最佳分析：第18楼unpack

小生我怕怕 · 发表于 2008-10-22 09:32

00471000 > 9C pushfd //OD载入
00471001 60 pushad //单步到这里
00471002 E8 02000000 call UnPackMe.00471009 //在这里执行ESP定律 hr rsp
00471007 33C0 xor eax,eax
00471009 8BC4 mov eax,esp
0047100B 83C0 04 add eax,4
━━━━━━━━━━━━━━━━━━━━━━━━━━
004711A7 9D popfd //我们停在了这里
004711A8 68 9C154500 push UnPackMe.0045159C //单步到这里
004711AD C3 retn //这里返回到我们的OEP
004711AE 0000 add byte ptr ds:[eax],al
004711B0 40 inc eax
━━━━━━━━━━━━━━━━━━━━━━━━━━
0045159C 55 push ebp //运行importRCE检查下IAT
0045159D 8BEC mov ebp,esp //有13个无效指针，我们选中第一个无效双击
0045159F 83C4 F0 add esp,-10 //如下图
004515A2 B8 BC134500 mov eax,UnPackMe.004513BC //选好后，OD从新加载程序
004515A7 E8 8846FBFF call UnPackMe.00405C34
图1：

━━━━━━━━━━━━━━━━━━━━━━━━━━
00471000 > 9C pushfd //OD从新载入之后
00471001 60 pushad //在命令行输入 d 0045517c
00471002 E8 02000000 call UnPackMe.00471009
00471007 33C0 xor eax,eax
00471009 8BC4 mov eax,esp
━━━━━━━━━━━━━━━━━━━━━━━━━━
00455178 0005589E //我们在这里下硬件访问断点
0045517C 000558B0 //我们在命令行跟随后停在这里，在上面一句下硬件访问断点
00455180 000558C2 //下好断后我们开始单步去寻找我们的IAT加密的地址
00455184 000558D6
00455188 000558EC
0045518C 000558FE
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471000 > 9C pushfd //开始单步F8走
00471001 60 pushad
00471002 E8 02000000 call UnPackMe.00471009 //走到此CALL也一样按F8路过，此时程序运行到下面地址
00471007 33C0 xor eax,eax
00471009 8BC4 mov eax,esp
0047100B 83C0 04 add eax,4
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471E19 85DB test ebx,ebx //程序运行到了这里
00471E1B 74 33 je short UnPackMe.00471E50 //同时我们看下数据窗口
00471E1D 8BC3 mov eax,ebx
00471E1F F7C3 00000080 test ebx,80000000
00471E25 74 08 je short UnPackMe.00471E2F
00471E27 81E3 FFFF0000 and ebx,0FFFF
00471E2D EB 04 jmp short UnPackMe.00471E33
━━━━━━━━━━━━━━━━━━━━━━━━━━
00455168 7C80BDB6 kernel32.lstrlenA
0045516C 7C810111 kernel32.lstrcpynA
00455170 7C801D4F kernel32.LoadLibraryExA
00455174 7C80A415 kernel32.GetThreadLocale //上面的指针已经解密
00455178 0005589E
0045517C 000558B0 //这里就是我们的加密指针
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471E19 85DB test ebx,ebx //F8开始单步走
00471E1B 74 33 je short UnPackMe.00471E50 //现在我们开始寻找我们的IAT加密
00471E1D 8BC3 mov eax,ebx //通常寻找IAT加密我们需要注意寄存器的变化
00471E1F F7C3 00000080 test ebx,80000000
00471E25 74 08 je short UnPackMe.00471E2F
00471E27 81E3 FFFF0000 and ebx,0FFFF
00471E2D EB 04 jmp short UnPackMe.00471E33
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471E47 5A pop edx
00471E48 59 pop ecx
00471E49 85C0 test eax,eax
00471E4B 74 05 je short UnPackMe.00471E52 //到达这里时显示我们的未加密指针的最后一个
00471E4D AB stos dword ptr es:[edi] //我们注意下我们的数据窗口
00471E4E ^ EB C4 jmp short UnPackMe.00471E14 //这里返回后就是我们寻找IAT的大好时机
━━━━━━━━━━━━━━━━━━━━━━━━━━
00455170 7C801D4F kernel32.LoadLibraryExA
00455174 7C80A415 kernel32.GetThreadLocale
00455178 7C801EEE kernel32.GetStartupInfoA //这里就是我们的未加密指针
0045517C 000558B0 //这里就是我们的加密指针
00455180 000558C2
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471E14 8B19 mov ebx,dword ptr ds:[ecx] //通过下面的jmp我们返回到这段
00471E16 83C1 04 add ecx,4 //现在开始寻找我们的加密指针
00471E19 85DB test ebx,ebx
00471E1B 74 33 je short UnPackMe.00471E50
00471E1D 8BC3 mov eax,ebx
00471E1F F7C3 00000080 test ebx,80000000
00471E25 /74 08 je short UnPackMe.00471E2F //这个JE让他跳不用管他
00471E27 |81E3 FFFF0000 and ebx,0FFFF
00471E2D |EB 04 jmp short UnPackMe.00471E33
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471E2F 43 inc ebx
00471E30 43 inc ebx
00471E31 03DA add ebx,edx
00471E33 51 push ecx
00471E34 52 push edx
00471E35 899D C2214000 mov dword ptr ss:[ebp+4021C2],ebx
00471E3B 53 push ebx
00471E3C FFB5 BA214000 push dword ptr ss:[ebp+4021BA] //到达下面CALL时我们留心一下我们的寄存器
00471E42 E8 32010000 call UnPackMe.00471F79 //我们F7跟进一探究竟
00471E47 5A pop edx
00471E48 59 pop ecx
━━━━━━━━━━━━━━━━━━━━━━━━━━
EAX 000558B0
ECX 00455180 UnPackMe.00455180
EDX 00400000 ASCII "MZP"
EBX 004558B2 ASCII "GetProcAddress" //此时我们的IAT保持完整状态
ESP 0012FF88
EBP 0006F000
ESI 00455000 UnPackMe.00455000
EDI 0045517C UnPackMe.0045517C
EIP 00471E42 UnPackMe.00471E42
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471F79 C8 000000 enter 0,0 //一个奇怪的指令没有见过，不管他
00471F7D 55 push ebp //我们单步继续走
00471F7E 56 push esi
00471F7F E8 00000000 call UnPackMe.00471F84
00471F84 5E pop esi
00471F85 81EE 842F4000 sub esi,UnPackMe.00402F84
00471F8B 8B86 B2214000 mov eax,dword ptr ds:[esi+4021B2]
00471F91 3945 08 cmp dword ptr ss:[ebp+8],eax
00471F94 75 1B jnz short UnPackMe.00471FB1 //这个JNZ跳啦，我们让他跳
00471F96 55 push ebp //在让JNZ跳的同时注意我们的寄存器里EBX的指针
00471F97 51 push ecx
00471F98 52 push edx
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471FB1 5E pop esi //上面的JNZ跳到了这里
00471FB2 5D pop ebp //看到下面的IAT是存在的此时心里也平静多啦表示我们还没有被加密
00471FB3 FF75 0C push dword ptr ss:[ebp+C] //继续单步走吧
00471FB6 FF75 08 push dword ptr ss:[ebp+8]
00471FB9 FF15 E9184700 call dword ptr ds:[<&KERNEL32.GetProcAdd>; kernel32.GetProcAddress
00471FBF 85C0 test eax,eax //走到这里时我们的指针显示在eax和ebx
00471FC1 74 25 je short UnPackMe.00471FE8 //这里没有跳我们继续走
00471FC3 51 push ecx
00471FC4 56 push esi
00471FC5 50 push eax
00471FC6 E8 00000000 call UnPackMe.00471FCB
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471FCC 81EE CB2F4000 sub esi,UnPackMe.00402FCB //走到这里时我们的IAT是完整的
00471FD2 8D8E 2B234000 lea ecx,dword ptr ds:[esi+40232B]
00471FD8 50 push eax
00471FD9 51 push ecx
00471FDA E8 97FBFFFF call UnPackMe.00471B76
00471FDF 85C0 test eax,eax //控制下面的跳转
00471FE1 74 02 je short UnPackMe.00471FE5 //这里就是magic jump
00471FE3 59 pop ecx //这里是弹出
00471FE4 50 push eax //这里是把指针压栈
00471FE5 58 pop eax
00471FE6 5E pop esi
00471FE7 59 pop ecx
00471FE8 C9 leave
00471FE9 C2 0800 retn 8 //这里返回信息回去

特征码：59 50 58 5E 59
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471E47 5A pop edx //因为那里没有跳我们返回给我们的信息就是加密指令
00471E48 59 pop ecx
00471E49 85C0 test eax,eax
00471E4B 74 05 je short UnPackMe.00471E52
00471E4D AB stos dword ptr es:[edi] //到达这里时可以看到我们的积存器指针已被加密
00471E4E ^ EB C4 jmp short UnPackMe.00471E14 //这里返回去读取我们其他IAT指针
00471E50 F8 clc //到上面JMP时注意我们的数据窗口
00471E51 C3 retn
━━━━━━━━━━━━━━━━━━━━━━━━━━
00455178 7C801EEE kernel32.GetStartupInfoA
0045517C 00471F79 UnPackMe.00471F79 //这里就是被加密的IAT指针
00455180 000558C2 //这里知道我们的指针加密所在了，从新加载程序
00455184 000558D6
00455188 000558EC
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471000 > 9C pushfd //OD从新加载后
00471001 60 pushad //ctrl+B搜索特征码： 59 50 58 5E 59，记住钩选整个段块
00471002 E8 02000000 call UnPackMe.00471009
00471007 33C0 xor eax,eax
00471009 8BC4 mov eax,esp
0047100B 83C0 04 add eax,4
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471FE1 /74 02 je short UnPackMe.00471FE5 //这里就是magic jump
00471FE3 |59 pop ecx //搜索后我们停在这里，把上面的JE改JMP
00471FE4 |50 push eax //改好jmp后我们F8单步一步
00471FE5 \58 pop eax
00471FE6 5E pop esi
00471FE7 59 pop ecx
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471001 60 pushad //单步一步F8后程序在这里
00471002 E8 02000000 call UnPackMe.00471009 //这里执行ESP定律 hr esp
00471007 33C0 xor eax,eax
00471009 8BC4 mov eax,esp
━━━━━━━━━━━━━━━━━━━━━━━━━━
004711A7 9D popfd //此时程序停在这里
004711A8 68 9C154500 push UnPackMe.0045159C
004711AD C3 retn //这里返回到我们的OEP
004711AE 0000 add byte ptr ds:[eax],al
004711B0 40 inc eax
004711B1 0000 add byte ptr ds:[eax],al
━━━━━━━━━━━━━━━━━━━━━━━━━━
0045159C 55 push ebp //这里就是oep，现在我们用lordPE把程序dump
0045159D 8BEC mov ebp,esp //接着我们在运行我们的importRCE把程序修复
0045159F 83C4 F0 add esp,-10 //修复时没有无效指针
004515A2 B8 BC134500 mov eax,UnPackMe.004513BC
004515A7 E8 8846FBFF call UnPackMe.00405C34
004515AC A1 E02F4500 mov eax,dword ptr ds:[452FE0]
004515B1 8B00 mov eax,dword ptr ds:[eax]
004515B3 E8 F8E5FFFF call UnPackMe.0044FBB0
004515B8 A1 E02F4500 mov eax,dword ptr ds:[452FE0]

补充:
下面是对加密执行CALL的简单分析下
00471B76C8 040000 enter 4,0 //把此处改RETN也可以是我们的magic jump
00471B7A53push ebx//压入EBX
00471B7B57push edi//压入EDI
00471B7C56push esi//压入ESI
00471B7DE8 00000000 call UnPackMe.00471B82
00471B825Bpop ebx
00471B8381EB 822B4000 sub ebx,UnPackMe.00402B82
00471B89C745 FC 0000000>mov dword ptr ss:[ebp-4],0
00471B908B75 08 mov esi,dword ptr ss:[ebp+8]
00471B93833E 00 cmp dword ptr ds:[esi],0//比较ESI是否为0如为0下面JE则跳
00471B96 /74 34 je short UnPackMe.00471BCC//如果ESI为0则跳，如果跳既为我们的magic jump
00471B9856push esi//把ESI指令压栈
00471B998B7E 08 mov edi,dword ptr ds:[esi+8]//把DSI+8的指令传送给EDI
00471B9C03FBadd edi,ebx //EDI+EBX
00471B9E8B76 0C mov esi,dword ptr ds:[esi+C]//把ESI+C的指令传送给ESI
00471BA103F3add esi,ebx //在一次把ESI和EBX相加
00471BA38B45 0C mov eax,dword ptr ss:[ebp+C]
00471BA6833F FF cmp dword ptr ds:[edi],-1
00471BA974 13 je short UnPackMe.00471BBE//判断语句的加密指令
00471BAB8B0Fmov ecx,dword ptr ds:[edi]
00471BAD85C9test ecx,ecx
00471BAF74 05 je short UnPackMe.00471BB6
00471BB1390419cmp dword ptr ds:[ecx+ebx],eax
00471BB474 0E je short UnPackMe.00471BC4
00471BB683C7 04 add edi,4
00471BB983C6 04 add esi,4
00471BBC^ EB E8 jmp short UnPackMe.00471BA6 //循环计算加密
00471BBE5Epop esi
00471BBF83C6 10 add esi,10//把ESI加10计算
00471BC2^ EB CF jmp short UnPackMe.00471B93 //在一次循环计算加密
00471BC48B06mov eax,dword ptr ds:[esi]
00471BC603C3add eax,ebx //把EAX和EBX相加
00471BC88945 FC mov dword ptr ss:[ebp-4],eax//把EAX的指令传送给EBP-4
00471BCB5Epop esi
00471BCC5Epop esi
00471BCD5Fpop edi
00471BCE5Bpop ebx
00471BCF8B45 FC mov eax,dword ptr ss:[ebp-4]
00471BD2C9leave
00471BD3C2 0800 retn 8 //如果上面的 je short UnPackMe.00471BCC跳则返回成功，不跳则返回加密

小生我怕怕 · 发表于 2008-10-22 09:33

我们来说一下单步吧，其实这个壳单步也是几分钟的问题，除了有IAT加密
其实和UPX比他比UPX的步骤还要简单一些
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471000 >9Cpushfd //OD载入
0047100160pushad //我们ctrl+b搜索特征码 59 50 58 5E 59
00471002E8 02000000 call UnPackMe.00471009
0047100733C0xor eax,eax
004710098BC4mov eax,esp
0047100B83C0 04 add eax,4
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471FE1 /74 02 je short UnPackMe.00471FE5 //这里就是我们的magic jump
00471FE3 |59pop ecx//我们搜索到了这里
00471FE4 |50push eax //我们F8单步走一步
00471FE5 \58pop eax
00471FE65Epop esi
━━━━━━━━━━━━━━━━━━━━━━━━━━
0047100160pushad //单步一步F8之后我们来到这里
00471002E8 02000000 call UnPackMe.00471009 //到这个CALL时我们F7跟进
0047100733C0xor eax,eax
004710098BC4mov eax,esp//我们F7之后我们来到了这里
0047100B83C0 04 add eax,4//开始一路F8向前冲
0047100E93xchg eax,ebx
━━━━━━━━━━━━━━━━━━━━━━━━━━
004711A661popad //此时我们来到了这里
004711A79Dpopfd
004711A868 9C154500 push UnPackMe.0045159C
004711ADC3retn //这里返回到我们的OEP
004711AE0000add byte ptr ds:[eax],al
004711B040inc eax
004711B10000add byte ptr ds:[eax],al
━━━━━━━━━━━━━━━━━━━━━━━━━━
0045159C55push ebp //这里就是oep，现在我们用lordPE把程序dump
0045159D8BECmov ebp,esp//接着我们在运行我们的importRCE把程序修复
0045159F83C4 F0 add esp,-10//修复时没有无效指针
004515A2B8 BC134500 mov eax,UnPackMe.004513BC
004515A7E8 8846FBFF call UnPackMe.00405C34
004515ACA1 E02F4500 mov eax,dword ptr ds:[452FE0]
004515B18B00mov eax,dword ptr ds:[eax]
004515B3E8 F8E5FFFF call UnPackMe.0044FBB0
004515B8A1 E02F4500 mov eax,dword ptr ds:[452FE0]

补充:
下面是对加密执行CALL的简单分析下
00471B76C8 040000 enter 4,0 //把此处改RETN也可以是我们的magic jump
00471B7A53push ebx//压入EBX
00471B7B57push edi//压入EDI
00471B7C56push esi//压入ESI
00471B7DE8 00000000 call UnPackMe.00471B82
00471B825Bpop ebx
00471B8381EB 822B4000 sub ebx,UnPackMe.00402B82
00471B89C745 FC 0000000>mov dword ptr ss:[ebp-4],0
00471B908B75 08 mov esi,dword ptr ss:[ebp+8]
00471B93833E 00 cmp dword ptr ds:[esi],0//比较ESI是否为0如为0下面JE则跳
00471B96 /74 34 je short UnPackMe.00471BCC//如果ESI为0则跳，如果跳既为我们的magic jump
00471B9856push esi//把ESI指令压栈
00471B998B7E 08 mov edi,dword ptr ds:[esi+8]//把DSI+8的指令传送给EDI
00471B9C03FBadd edi,ebx //EDI+EBX
00471B9E8B76 0C mov esi,dword ptr ds:[esi+C]//把ESI+C的指令传送给ESI
00471BA103F3add esi,ebx //在一次把ESI和EBX相加
00471BA38B45 0C mov eax,dword ptr ss:[ebp+C]
00471BA6833F FF cmp dword ptr ds:[edi],-1
00471BA974 13 je short UnPackMe.00471BBE//判断语句的加密指令
00471BAB8B0Fmov ecx,dword ptr ds:[edi]
00471BAD85C9test ecx,ecx
00471BAF74 05 je short UnPackMe.00471BB6
00471BB1390419cmp dword ptr ds:[ecx+ebx],eax
00471BB474 0E je short UnPackMe.00471BC4
00471BB683C7 04 add edi,4
00471BB983C6 04 add esi,4
00471BBC^ EB E8 jmp short UnPackMe.00471BA6 //循环计算加密
00471BBE5Epop esi
00471BBF83C6 10 add esi,10//把ESI加10计算
00471BC2^ EB CF jmp short UnPackMe.00471B93 //在一次循环计算加密
00471BC48B06mov eax,dword ptr ds:[esi]
00471BC603C3add eax,ebx //把EAX和EBX相加
00471BC88945 FC mov dword ptr ss:[ebp-4],eax//把EAX的指令传送给EBP-4
00471BCB5Epop esi
00471BCC5Epop esi
00471BCD5Fpop edi
00471BCE5Bpop ebx
00471BCF8B45 FC mov eax,dword ptr ss:[ebp-4]
00471BD2C9leave
00471BD3C2 0800 retn 8 //如果上面的 je short UnPackMe.00471BCC跳则返回成功，不跳则返回加密

小生我怕怕 · 发表于 2008-10-22 09:33

这种方法也是一样，这里我就节省掉寻找IAT的步骤啦
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471000 >9Cpushfd //OD载入
0047100160pushad //我们ctrl+b搜索特征码 59 50 58 5E 59
00471002E8 02000000 call UnPackMe.00471009
0047100733C0xor eax,eax
004710098BC4mov eax,esp
0047100B83C0 04 add eax,4
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471FE1 /74 02 je short UnPackMe.00471FE5 //这里就是我们的magic jump
00471FE3 |59pop ecx//我们搜索到了这里
00471FE4 |50push eax //我们ait+m打开内存镜像
00471FE5 \58pop eax
00471FE65Epop esi
━━━━━━━━━━━━━━━━━━━━━━━━━━
内存映射，项目 20//我们在这里设置F2访问中断
地址=00455000 //紧接着shift+f9运行程序
大小=00003000 (12288.)
物主=UnPackMe 00400000
区段=.idata
类型=Imag 01001002
访问=R
初始访问=RWE
━━━━━━━━━━━━━━━━━━━━━━━━━━
00471DC98B0Emov ecx,dword ptr ds:[esi] //程序停在了这里
00471DCB8B7E 10 mov edi,dword ptr ds:[esi+10]//我们在一次打开内存镜像
00471DCE0BC9or ecx,ecx
00471DD075 02 jnz short UnPackMe.00471DD4
00471DD28BCFmov ecx,edi
━━━━━━━━━━━━━━━━━━━━━━━━━━
内存映射，项目 22//我们在这里设置F2访问中断
地址=00401000 //紧接着shift+f9运行程序
大小=00051000 (331776.)
物主=UnPackMe 00400000
区段=CODE
包含=code
类型=Imag 01001002
访问=R
初始访问=RWE
━━━━━━━━━━━━━━━━━━━━━━━━━━
0045159C55push ebp //这里就是oep，现在我们用lordPE把程序dump
0045159D8BECmov ebp,esp//接着我们在运行我们的importRCE把程序修复
0045159F83C4 F0 add esp,-10//修复时没有无效指针
004515A2B8 BC134500 mov eax,UnPackMe.004513BC
004515A7E8 8846FBFF call UnPackMe.00405C34
004515ACA1 E02F4500 mov eax,dword ptr ds:[452FE0]
004515B18B00mov eax,dword ptr ds:[eax]
004515B3E8 F8E5FFFF call UnPackMe.0044FBB0
004515B8A1 E02F4500 mov eax,dword ptr ds:[452FE0]

补充:
下面是对加密执行CALL的简单分析下
00471B76C8 040000 enter 4,0 //把此处改RETN也可以是我们的magic jump
00471B7A53push ebx//压入EBX
00471B7B57push edi//压入EDI
00471B7C56push esi//压入ESI
00471B7DE8 00000000 call UnPackMe.00471B82
00471B825Bpop ebx
00471B8381EB 822B4000 sub ebx,UnPackMe.00402B82
00471B89C745 FC 0000000>mov dword ptr ss:[ebp-4],0
00471B908B75 08 mov esi,dword ptr ss:[ebp+8]
00471B93833E 00 cmp dword ptr ds:[esi],0//比较ESI是否为0如为0下面JE则跳
00471B96 /74 34 je short UnPackMe.00471BCC//如果ESI为0则跳，如果跳既为我们的magic jump
00471B9856push esi//把ESI指令压栈
00471B998B7E 08 mov edi,dword ptr ds:[esi+8]//把DSI+8的指令传送给EDI
00471B9C03FBadd edi,ebx //EDI+EBX
00471B9E8B76 0C mov esi,dword ptr ds:[esi+C]//把ESI+C的指令传送给ESI
00471BA103F3add esi,ebx //在一次把ESI和EBX相加
00471BA38B45 0C mov eax,dword ptr ss:[ebp+C]
00471BA6833F FF cmp dword ptr ds:[edi],-1
00471BA974 13 je short UnPackMe.00471BBE//判断语句的加密指令
00471BAB8B0Fmov ecx,dword ptr ds:[edi]
00471BAD85C9test ecx,ecx
00471BAF74 05 je short UnPackMe.00471BB6
00471BB1390419cmp dword ptr ds:[ecx+ebx],eax
00471BB474 0E je short UnPackMe.00471BC4
00471BB683C7 04 add edi,4
00471BB983C6 04 add esi,4
00471BBC^ EB E8 jmp short UnPackMe.00471BA6 //循环计算加密
00471BBE5Epop esi
00471BBF83C6 10 add esi,10//把ESI加10计算
00471BC2^ EB CF jmp short UnPackMe.00471B93 //在一次循环计算加密
00471BC48B06mov eax,dword ptr ds:[esi]
00471BC603C3add eax,ebx //把EAX和EBX相加
00471BC88945 FC mov dword ptr ss:[ebp-4],eax//把EAX的指令传送给EBP-4
00471BCB5Epop esi
00471BCC5Epop esi
00471BCD5Fpop edi
00471BCE5Bpop ebx
00471BCF8B45 FC mov eax,dword ptr ss:[ebp-4]
00471BD2C9leave
00471BD3C2 0800 retn 8 //如果上面的 je short UnPackMe.00471BCC跳则返回成功，不跳则返回加密

niliu · 发表于 2008-10-22 10:30

那啥..开头把

00471000 >9CPUSHFD
0047100160PUSHAD
00471002E8 02000000 CALL UnPackMe.00471009/////////////////F7过
0047100733C0XOR EAX,EAX
004710098BC4MOV EAX,ESP
0047100B83C0 04 ADD EAX,4
0047100E93XCHG EAX,EBX
0047100F8BE3MOV ESP,EBX
004710118B5B FC MOV EBX,DWORD PTR DS:[EBX-4]
0047101481EB 07204000 SUB EBX,UnPackMe.00402007; ASCII "FE"
0047101A87DDXCHG EBP,EBX
0047101C01AD BB2F4000 ADD DWORD PTR SS:[EBP+402FBB],EBP
0047102201AD E5304000 ADD DWORD PTR SS:[EBP+4030E5],EBP
0047102801AD 5E304000 ADD DWORD PTR SS:[EBP+40305E],EBP
0047102E01AD 92314000 ADD DWORD PTR SS:[EBP+403192],EBP
0047103401AD 42314000 ADD DWORD PTR SS:[EBP+403142],EBP
0047103A01AD F7314000 ADD DWORD PTR SS:[EBP+4031F7],EBP
0047104001AD 66324000 ADD DWORD PTR SS:[EBP+403266],EBP
0047104601AD 2F324000 ADD DWORD PTR SS:[EBP+40322F],EBP
0047104C01AD FD344000 ADD DWORD PTR SS:[EBP+4034FD],EBP
0047105201AD 52354000 ADD DWORD PTR SS:[EBP+403552],EBP
00471058E8 DF0B0000 CALL UnPackMe.00471C3C
0047105DE8 740E0000 CALL UnPackMe.00471ED6
0047106285C0TEST EAX,EAX
0047106474 15 JE SHORT UnPackMe.0047107B
00471066FFB5 B2214000 PUSH DWORD PTR SS:[EBP+4021B2]
0047106CE8 E5140000 CALL UnPackMe.00472556
004710718985 01384000 MOV DWORD PTR SS:[EBP+403801],EAX
0047107785C0TEST EAX,EAX
0047107975 0E JNZ SHORT UnPackMe.00471089
0047107B8D85 3B234000 LEA EAX,DWORD PTR SS:[EBP+40233B]
00471081C700 00000000 MOV DWORD PTR DS:[EAX],0
00471087EB 3E JMP SHORT UnPackMe.004710C7
004710898D85 5D254000 LEA EAX,DWORD PTR SS:[EBP+40255D]
0047108F8D8D 91254000 LEA ECX,DWORD PTR SS:[EBP+402591]
00471095FFB5 01384000 PUSH DWORD PTR SS:[EBP+403801]
0047109BFFB5 B2214000 PUSH DWORD PTR SS:[EBP+4021B2]
004710A151PUSH ECX
004710A250PUSH EAX
004710A3E8 000A0000 CALL UnPackMe.00471AA8
004710A88D85 25264000 LEA EAX,DWORD PTR SS:[EBP+402625]
004710AE8D8D 89264000 LEA ECX,DWORD PTR SS:[EBP+402689]
004710B4FFB5 01384000 PUSH DWORD PTR SS:[EBP+403801]
004710BAFFB5 B2214000 PUSH DWORD PTR SS:[EBP+4021B2]
004710C051PUSH ECX
004710C150PUSH EAX
004710C2E8 E1090000 CALL UnPackMe.00471AA8
004710C78D85 2B234000 LEA EAX,DWORD PTR SS:[EBP+40232B]
004710CD50PUSH EAX
004710CEE8 030B0000 CALL UnPackMe.00471BD6
004710D3FFB5 B2214000 PUSH DWORD PTR SS:[EBP+4021B2]
004710D9FFB5 F5224000 PUSH DWORD PTR SS:[EBP+4022F5]
004710DFE8 C90C0000 CALL UnPackMe.00471DAD ; 进去有糖吃 //////////一路F8到这 F7进去

00471DAD58POP EAX; UnPackMe.004710E4
00471DAE5EPOP ESI
00471DAF5APOP EDX
00471DB050PUSH EAX
00471DB10BF6OR ESI,ESI
00471DB374 12 JE SHORT UnPackMe.00471DC7
00471DB503F2ADD ESI,EDX
00471DB7E8 0D000000 CALL UnPackMe.00471DC9 ; 那啥。有糖吃. /////// F7进
00471DBC72 0A JB SHORT UnPackMe.00471DC8
00471DBE83C6 14 ADD ESI,14
00471DC1837E 0C 00CMP DWORD PTR DS:[ESI+C],0
00471DC5^ 75 F0 JNZ SHORT UnPackMe.00471DB7
00471DC7F8CLC
00471DC8C3RETN
00471DC98B0EMOV ECX,DWORD PTR DS:[ESI]
00471DCB8B7E 10 MOV EDI,DWORD PTR DS:[ESI+10]
00471DCE0BC9OR ECX,ECX
00471DD075 02 JNZ SHORT UnPackMe.00471DD4
00471DD28BCFMOV ECX,EDI
00471DD403CAADD ECX,EDX
00471DD603FAADD EDI,EDX
00471DD88B46 0C MOV EAX,DWORD PTR DS:[ESI+C]
00471DDB85C0TEST EAX,EAX
00471DDD74 71 JE SHORT UnPackMe.00471E50
00471DDF03C2ADD EAX,EDX
00471DE151PUSH ECX
00471DE252PUSH EDX
00471DE38985 C6214000 MOV DWORD PTR SS:[EBP+4021C6],EAX
00471DE9C785 C2214000 0>MOV DWORD PTR SS:[EBP+4021C2],0
00471DF350PUSH EAX
00471DF4E8 51030000 CALL UnPackMe.0047214A
00471DF985C0TEST EAX,EAX
00471DFB75 0B JNZ SHORT UnPackMe.00471E08
00471DFDFFB5 C6214000 PUSH DWORD PTR SS:[EBP+4021C6]
00471E03E8 6B020000 CALL UnPackMe.00472073
00471E085APOP EDX
00471E0959POP ECX
00471E0A85C0TEST EAX,EAX
00471E0C74 44 JE SHORT UnPackMe.00471E52
00471E0E8985 BA214000 MOV DWORD PTR SS:[EBP+4021BA],EAX
00471E148B19MOV EBX,DWORD PTR DS:[ECX]
00471E1683C1 04 ADD ECX,4
00471E1985DBTEST EBX,EBX
00471E1B74 33 JE SHORT UnPackMe.00471E50
00471E1D8BC3MOV EAX,EBX
00471E1FF7C3 00000080 TEST EBX,80000000
00471E2574 08 JE SHORT UnPackMe.00471E2F
00471E2781E3 FFFF0000 AND EBX,0FFFF
00471E2DEB 04 JMP SHORT UnPackMe.00471E33
00471E2F43INC EBX
00471E3043INC EBX
00471E3103DAADD EBX,EDX
00471E3351PUSH ECX
00471E3452PUSH EDX
00471E35899D C2214000 MOV DWORD PTR SS:[EBP+4021C2],EBX
00471E3B53PUSH EBX
00471E3CFFB5 BA214000 PUSH DWORD PTR SS:[EBP+4021BA]
00471E42E8 32010000 CALL UnPackMe.00471F79 ; 进去有糖吃昂昂.. .//////F7同样淫荡昂..
00471E475APOP EDX
00471E4859POP ECX
00471E4985C0TEST EAX,EAX
00471E4B74 05 JE SHORT UnPackMe.00471E52
00471E4DABSTOS DWORD PTR ES:[EDI]
00471E4E^ EB C4 JMP SHORT UnPackMe.00471E14
00471E50F8CLC
00471E51C3RETN
00471E52F9STC
00471E53C3RETN

IAT处理的重头戏来了..昂..就在下面代码.恩 3种方法处理IAT

00471FB15EPOP ESI; UnPackMe.00470000
00471FB25DPOP EBP
00471FB3FF75 0C PUSH DWORD PTR SS:[EBP+C]
00471FB6FF75 08 PUSH DWORD PTR SS:[EBP+8]
00471FB9FF15 E9184700 CALL DWORD PTR DS:[<&KERNEL32.GetProcAddress>] ; kernel32.GetProcAddress
00471FBF85C0TEST EAX,EAX
00471FC174 25 JE SHORT UnPackMe.00471FE8 ///////////IAT处理方法1: 这改JMP
00471FC351PUSH ECX
00471FC456PUSH ESI
00471FC550PUSH EAX
00471FC6E8 00000000 CALL UnPackMe.00471FCB
00471FCB5EPOP ESI
00471FCC81EE CB2F4000 SUB ESI,UnPackMe.00402FCB
00471FD28D8E 2B234000 LEA ECX,DWORD PTR DS:[ESI+40232B]
00471FD850PUSH EAX
00471FD951PUSH ECX
00471FDAE8 97FBFFFF CALL UnPackMe.00471B76
00471FDF85C0TEST EAX,EAX
00471FE174 02 JE SHORT UnPackMe.00471FE5////////// IAT处理方法2: 这该JMP
00471FE359POP ECX //////////////只有2句下一句加这一句解决方法3:NOP掉这2句.
00471FE450PUSH EAX////// 恩重头戏就这2句代码..这是加密IAT的昂只要过了这2句啥问题都无了.
00471FE558POP EAX
00471FE65EPOP ESI
00471FE759POP ECX
00471FE8C9LEAVE
00471FE9C2 0800 RETN 8 ///// 那啥节约时间一路F8狂奔别在循环里吃糖糖直接下F2断点飞出去

恩 IAT处理了那啥就该找OEP了昂.一路F8淫荡..

004711798D8D E1214000 LEA ECX,DWORD PTR SS:[EBP+4021E1]
0047117F6A 30 PUSH 30
0047118151PUSH ECX
004711828D9D D5214000 LEA EBX,DWORD PTR SS:[EBP+4021D5]
0047118853PUSH EBX
00471189FFB5 BE214000 PUSH DWORD PTR SS:[EBP+4021BE]
0047118FFF95 E9284000 CALL DWORD PTR SS:[EBP+4028E9]
004711958D9D 09234000 LEA EBX,DWORD PTR SS:[EBP+402309]
0047119B53PUSH EBX
0047119C6A 00 PUSH 0
0047119EFFD0CALL EAX
004711A0FFA5 CD284000 JMP DWORD PTR SS:[EBP+4028CD]
004711A661POPAD
004711A79DPOPFD
004711A868 9C154500 PUSH UnPackMe.0045159C
004711ADC3RETN /////////////这里过去就是OEP了这壳昂..除了处理一个IAT外找到OEP的确很简单

0045159C55PUSH EBP////////////OEP昂昂..
0045159D8BECMOV EBP,ESP
0045159F83C4 F0 ADD ESP,-10
004515A2B8 BC134500 MOV EAX,UnPackMe.004513BC
004515A7E8 8846FBFF CALL UnPackMe.00405C34
004515ACA1 E02F4500 MOV EAX,DWORD PTR DS:[452FE0]
004515B18B00MOV EAX,DWORD PTR DS:[EAX]
004515B3E8 F8E5FFFF CALL UnPackMe.0044FBB0
004515B8A1 E02F4500 MOV EAX,DWORD PTR DS:[452FE0]
004515BD8B00MOV EAX,DWORD PTR DS:[EAX]
004515BFBA FC154500 MOV EDX,UnPackMe.004515FC; ASCII "

.52pojie.cn"
004515C4E8 F7E1FFFF CALL UnPackMe.0044F7C0
004515C98B0D C0304500 MOV ECX,DWORD PTR DS:[4530C0]; UnPackMe.00454BD0
004515CFA1 E02F4500 MOV EAX,DWORD PTR DS:[452FE0]
004515D48B00MOV EAX,DWORD PTR DS:[EAX]
004515D68B15 50114500 MOV EDX,DWORD PTR DS:[451150]; UnPackMe.0045119C
004515DCE8 E7E5FFFF CALL UnPackMe.0044FBC8
004515E1A1 E02F4500 MOV EAX,DWORD PTR DS:[452FE0]
004515E68B00MOV EAX,DWORD PTR DS:[EAX]
004515E8E8 5BE6FFFF CALL UnPackMe.0044FC48
004515EDE8 6A27FBFF CALL UnPackMe.00403D5C
004515F20000ADD BYTE PTR DS:[EAX],AL

恩那啥脱壳修复IAT昂没无效函数...恩完了...

tjxiaowu · 发表于 2008-10-22 10:43

OD载入
下BP GetModuleHandleA
F9运行2次
00472196C9LEAVE到了这里
00472197C2 0400 RETN 4
0047219AC8 000000 ENTER 0,0
0047219E56PUSH ESI
0047219F51PUSH ECX

ALT+F9返回取消断点
F8单步

00472196C9LEAVE
00472197C2 0400 RETN 4
0047219AC8 000000 ENTER 0,0
0047219E56PUSH ESI
0047219F51PUSH ECX

00471DF985C0TEST EAX,EAX 到了这里
00471DFB75 0B JNZ SHORT UnPackMe.00471E08
00471DFDFFB5 C6214000 PUSH DWORD PTR SS:[EBP+4021C6]
00471E03E8 6B020000 CALL UnPackMe.00472073

00471DDD /74 71 JE SHORT UnPackMe.00471E50
00471DDF |03C2ADD EAX,EDX
00471DE1 |51PUSH ECX
00471DE2 |52PUSH EDX
00471DE3 |8985 C6214000 MOV DWORD PTR SS:[EBP+4021C6],EAX
00471DE9 |C785 C2214000 0>MOV DWORD PTR SS:[EBP+4021C2],0
00471DF3 |50PUSH EAX
00471DF4 |E8 51030000 CALL UnPackMe.0047214A
00471DF9 |85C0TEST EAX,EAX
00471DFB |75 0B JNZ SHORT UnPackMe.00471E08
00471DFD |FFB5 C6214000 PUSH DWORD PTR SS:[EBP+4021C6]
00471E03 |E8 6B020000 CALL UnPackMe.00472073
00471E08 |5APOP EDX
00471E09 |59POP ECX
00471E0A |85C0TEST EAX,EAX
00471E0C |74 44 JE SHORT UnPackMe.00471E52
00471E0E |8985 BA214000 MOV DWORD PTR SS:[EBP+4021BA],EAX; kernel32.7C800000
00471E14 |8B19MOV EBX,DWORD PTR DS:[ECX]
00471E16 |83C1 04 ADD ECX,4
00471E19 |85DBTEST EBX,EBX
00471E1B |74 33 JE SHORT UnPackMe.00471E50
00471E1D |8BC3MOV EAX,EBX
00471E1F |F7C3 00000080 TEST EBX,80000000
00471E25 |74 08 JE SHORT UnPackMe.00471E2F
00471E27 |81E3 FFFF0000 AND EBX,0FFFF
00471E2D |EB 04 JMP SHORT UnPackMe.00471E33
00471E2F |43INC EBX
00471E30 |43INC EBX
00471E31 |03DAADD EBX,EDX
00471E33 |51PUSH ECX
00471E34 |52PUSH EDX
00471E35 |899D C2214000 MOV DWORD PTR SS:[EBP+4021C2],EBX
00471E3B |53PUSH EBX
00471E3C |FFB5 BA214000 PUSH DWORD PTR SS:[EBP+4021BA]
00471E42 |E8 32010000 CALL UnPackMe.00471F79
00471E47 |5APOP EDX
00471E48 |59POP ECX
00471E49 |85C0TEST EAX,EAX
00471E4B |74 05 JE SHORT UnPackMe.00471E52
00471E4D |ABSTOS DWORD PTR ES:[EDI]
00471E4E^|EB C4 JMP SHORT UnPackMe.00471E14
00471E50 \F8CLC
00471E51C3RETN F4运行到这里

00471DBC /72 0A JB SHORT UnPackMe.00471DC8到了这
00471DBE |83C6 14 ADD ESI,14
00471DC1 |837E 0C 00CMP DWORD PTR DS:[ESI+C],0
00471DC5^|75 F0 JNZ SHORT UnPackMe.00471DB7
00471DC7 |F8CLC
00471DC8 \C3RETNF4

004711A661POPAD
004711A79DPOPFD
004711A868 9C154500 PUSH UnPackMe.0045159C单步到这里呵呵 OEP 进去
004711ADC3RETN

0045159C55PUSH EBPOEP
0045159D8BECMOV EBP,ESP
0045159F83C4 F0 ADD ESP,-10
004515A2B8 BC134500 MOV EAX,UnPackMe.004513BC
004515A7E8 8846FBFF CALL UnPackMe.00405C34

LordPEDUMP
ImportREC修复有几个无效的忘记是找的哪个了进去就有个JNP 还是JL的NOP掉就可以了再其他无效的就删除
搞定
能运行

aisht · 发表于 2008-10-22 10:47

壳不难脱.重点是加密了IAT吧.
壳用ESP就可以搞定.
脱壳就算了.
说一下处理magic jump吧.
既然加密了IAT(一些) 那肯定有加密的跳.那个magic jump吧.
我们修复的时候.选第一个无效指针.(原因,从这里出现加密.所以重点去找他.)
0005517C
OD载入 dd 0045517C (加基址)
我们在 0045517C 的上面两个下硬件断点. (为了更好做没有加密和加密的对比)
F9运行.
貌似硬件停不下来. 那我们就内存断.
00471E4985C0test eax,eax
00471E4B74 05 je short UnPackMe.00471E52
00471E4DABstos dword ptr es:[edi]//; 这里已经是记录IAT了
00471E4E^ EB C4 jmp short UnPackMe.00471E14//; 返回继续处理别的指针.
00471E50F8clc

00471E148B19mov ebx,dword ptr ds:[ecx]//返回后在这里.也就是处理是这里开始的
00471E1683C1 04 add ecx,4 //我们往下跟看看
00471E1985DBtest ebx,ebx
00471E1B74 33 je short UnPackMe.00471E50
00471E3B53push ebx
00471E3CFFB5 BA214000 push dword ptr ss:[ebp+4021BA]
00471E42E8 32010000 call UnPackMe.00471F79//到了这里发现EBX的字符有点想指针了.
00471E475Apop edx //当到了这里.EAX已经是一个完好的指针.
也就是说明上面的CALL是个关键.我们等下进去看看.
00471F79C8 000000 enter 0,0//进入CALL 来到了这里.
00471F7D55push ebp //我们继续往下看看.
00471F7E56push esi
00471F7FE8 00000000 call UnPackMe.00471F84
00471F913945 08 cmp dword ptr ss:[ebp+8],eax
00471F9475 1B jnz short UnPackMe.00471FB1// 记录,这个是跳了的.
00471F9655push ebp// 在知道这个指针没有被加密的情况下.(选择断在加密前的好处)

00471FB3FF75 0C push dword ptr ss:[ebp+C]
00471FB6FF75 08 push dword ptr ss:[ebp+8]
00471FB9FF15 E9184700 call dword ptr ds:[<&KERNEL32.GetProcAdd>; kernel32.GetProcAddress
00471FBF85C0test eax,eax //; EAX中是完好的IAT
00471FC174 25 je short UnPackMe.00471FE8 //; 没有跳
这时注意EAX的变化了. 之前进CALL的时候我们已经看出EAX的值是注定指针有没有被加密.所以特别要注意这个.
往后的CALL我就没跟进了.我只注意了EAX的值当过了一个CALL后有没有改变.显然到了这个被填充为00了.

00471FDAE8 97FBFFFF call UnPackMe.00471B76 // 过了这个CALL, EAX就变00了
00471FDF85C0test eax,eax // 发现这里是对比 EAX.
00471FE174 02/je short UnPackMe.00471FE5 //一个跳?
00471FE359 |pop ecx
00471FE450 |push eax << !!! 注意这里了. push eax=pop eax
00471FE558 \> pop eax // 然而上面的跳会跳过这个.
00471FE65Epop esi
00471FE759pop ecx // 我们又看到.堆栈里面第一个就是存在着我们的指针.
00471FE8C9leave // 那说明,这个跳如果没有实现.那EAX的值就完全不一样了.指针就被抹杀掉.
00471FE9C2 0800 retn 8// 所以.嘿嘿.先跟跟看是不是和我们分析的是一样先.
(毕竟我们现在看的这个并不是会被加密的指针)
事实证明.我们的推论完全是正确的.
既然这样.那我们的 magic jump 算是处理完了吧.nop掉 pop ecx push eax 或者把je 改jmp都可以了
修复.OK..

有点时间.那我们就分析一下把eax变为0的那个CALL ..
毕竟是它决定了下面的 test eax,eax 跳不跳的. 既然分析.级别上就是见CALL进吧.

00471BA6833F FF cmp dword ptr ds:[edi],-1
00471BA9< 74 13 je short 【 00471BBE 】 <<一个跳
00471BAB8B0Fmov ecx,dword ptr ds:[edi]
00471BAD85C9test ecx,ecx
00471BAF< 74 05 je short 【 00471BB6 】 <<另一个跳
00471BB1390419cmp dword ptr ds:[ecx+ebx],eax
00471BB4< 74 0E je short 【 00471BC4 】 <<又一个跳//6.是这个跳跳到那里的.
00471BB683C7 04 add edi,4
00471BB983C6 04 add esi,4
00471BBC^ EB E8 jmp short UnPackMe.00471BA6
00471BBE5Epop esi
00471BBF83C6 10 add esi,10
00471BC2^ EB CF jmp short UnPackMe.00471B93
00471BC48B06mov eax,dword ptr ds:[esi] //5.eax彻底和原来不一样的.到这里注意了上面的3个跳转.因为这个命令的上一个向上的jmp 那只有跳到这里才执行的下去吧.
00471BC603C3add eax,ebx//4.eax被改变了.
00471BC88945 FC mov dword ptr ss:[ebp-4],eax //3.额 ebp-4 的来自本来就是eax哇.
00471BCB5Epop esi
00471BCC5Epop esi
00471BCD5Fpop edi
00471BCE5Bpop ebx
00471BCF8B45 FC mov eax,dword ptr ss:[ebp-4] //2.看来这个ebp-4注定了eax是什么哇.
00471BD2C9leave
00471BD3C2 0800 retn 8 //1.这里就是返回 test eax,eax的地方啦.

那重点我们就开始从这里分析看看了.(逆向,我习惯从下面往上面看起...这个笔记也是这么做的.)
暂时先看吧.动态单步看效果更好.
因为这里肯定是个循环.我就不记录那么详细先.
不过分析写好就可以啦.
当我们单步到上面这段的时候. 我还可以看到EAX的值还是我们的指针.
再看看这段算法.
再00471BB4 没有跳到 00471BC4 之前.
是没有处理eax的 (只有00471BB1拿eax做比较 cmp dword ptr ds:[ecx+ebx],eax)
那关键就是:

00471BC4 mov eax,dword ptr ds:[esi] 这句把 esi 放给 eax
00471BC6 add eax,ebx和这句 ebx加到eax里面..

那..如果我们nop掉这两句..嘿嘿.应该也是可以的吧.
我试试. 哎呀.nop掉这两句的话. test eax,eax就不能跳了.
不过我们的EAX还是保持原样.呵呵.一样可以正常.不加密.
不知道写什么好了.不管了.就这样吧.

123.exe

lqiulu · 发表于 2008-10-22 11:10

fox2006 · 发表于 2008-10-22 11:39

吾爱专题脱壳练习17
--------------------------------------------------------------------------------
【编写程序】：Borland Delphi 6.0 - 7.0
【调试环境】：WinXP、OllyDbg、PEiD、LORDPE、ImportREC
【程序查壳】：PEBundle 2.0b5 - 3.0x -> Jeremy Collake
【脱壳方法】：单步跟踪法
---------------------------------------------------------------------------------
00471000 >9Cpushfd;OD载入到这里,f8单步走
0047100160pushad
00471002E8 02000000 call UnPackMe.00471009 ；这里F7,不然跑飞了，然后一直F8往下走
0047100733C0xor eax,eax
004710098BC4mov eax,esp
0047100B83C0 04 add eax,4
0047100E93xchg eax,ebx

---------------------------------------------------------------------------------
004710F7 /0F83 A9000000 jnb UnPackMe.004711A6 ；一直F8到了这里，一个跳转，F8继续跟进
004710FD |8D9D CA214000 lea ebx,dword ptr ss:[ebp+4021CA]
00471103 |53push ebx
00471104 |FF95 F9284000 call dword ptr ss:[ebp+4028F9]
0047110A |8985 BE214000 mov dword ptr ss:[ebp+4021BE],eax

---------------------------------------------------------------------------------
004711A661popad ；很友好的提示，就要到OEP啦
004711A79Dpopfd
004711A868 9C154500 push UnPackMe.0045159C；程序入口地址压栈
004711ADC3retn；这里就是magic jump，F4到这，F8一次

---------------------------------------------------------------------------------
0045159C55push ebp ;到达OEP，dump+IAT修复（将无效的指针剪切）
0045159D8BECmov ebp,esp
0045159F83C4 F0 add esp,-10
004515A2B8 BC134500 mov eax,UnPackMe.004513BC
004515A7E8 8846FBFF call UnPackMe.00405C34
004515ACA1 E02F4500 mov eax,dword ptr ds:[452FE0]
004515B18B00mov eax,dword ptr ds:[eax]
004515B3E8 F8E5FFFF call UnPackMe.0044FBB0
004515B8A1 E02F4500 mov eax,dword ptr ds:[452FE0]
004515BD8B00mov eax,dword ptr ds:[eax]
004515BFBA FC154500 mov edx,UnPackMe.004515FC; ASCII "

.52pojie.cn"
004515C4E8 F7E1FFFF call UnPackMe.0044F7C0
004515C98B0D C0304500 mov ecx,dword ptr ds:[4530C0]; UnPackMe.00454BD0

---------------------------------------------------------------------------------
脱壳完成。

UnPackMe17.rar

manyfen · 发表于 2008-10-22 11:52

OD载入，停在

00471000 >9Cpushfd//////////停在这里
0047100160pushad
00471002E8 02000000 call00471009/////////在此esp定律
0047100733C0xor eax, eax
004710098BC4mov eax, esp
0047100B83C0 04 add eax, 4
0047100E93xchgeax, ebx
0047100F8BE3mov esp, ebx
004710118B5B FC mov ebx, dword ptr [ebx-4]

esp定律后到
004711A661popad
004711A79Dpopfd
004711A868 9C154500 push0045159C////OEP入栈
004711ADC3retn////返回到OEP
004711AE0000add byte ptr [eax], al
004711B040inc eax
004711B10000add byte ptr [eax], al
004711B38046 00 00add byte ptr [esi], 0
004711B700F8add al, bh
004711B90000add byte ptr [eax], al
004711BB0059 7D add byte ptr [ecx+7D], bl
004711BE0000add byte ptr [eax], al
004711C00000add byte ptr [eax], al
004711C296xchgeax, esi

0045159C55pushebp///////这就是我们的OEP
0045159D8BECmov ebp, esp
0045159F83C4 F0 add esp, -10
004515A2B8 BC134500 mov eax, 004513BC
004515A7E8 8846FBFF call00405C34
004515ACA1 E02F4500 mov eax, dword ptr [452FE0]
004515B18B00mov eax, dword ptr [eax]
004515B3E8 F8E5FFFF call0044FBB0
004515B8A1 E02F4500 mov eax, dword ptr [452FE0]
004515BD8B00mov eax, dword ptr [eax]
004515BFBA FC154500 mov edx, 004515FC; ASCII "

.52pojie.cn"
004515C4E8 F7E1FFFF call0044F7C0
004515C98B0D C0304500 mov ecx, dword ptr [4530C0]; UnPackMe.00454BD0
004515CFA1 E02F4500 mov eax, dword ptr [452FE0]
004515D48B00mov eax, dword ptr [eax]
004515D68B15 50114500 mov edx, dword ptr [451150]; UnPackMe.0045119C
004515DCE8 E7E5FFFF call0044FBC8
004515E1A1 E02F4500 mov eax, dword ptr [452FE0]

ok，dump it。
修复无效指针。可以运行。Borland Delphi 6.0 - 7.0

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

[原创] 吾爱破解脱壳练习----PEBundle 2.0b5 - 3.0x

免费评分