第17课 esp脱壳法
(完整版)常见几种脱壳方法
----------------<小A分>----------------一、概论壳出于程序作者想对程序资源压缩、注册保护的目的，把壳分为压缩壳和加密壳(强壳)两种"UPX" "ASPCAK" "TELOCK" "PELITE" "NSPACK(北斗)" ... "ARMADILLO" "ASPROTECT" "ACPROTECT" "EPE(王)" "SVKP" ...顾名思义，压缩壳只是为了减小程序体积对资源进行压缩，加密壳是程序输入表等等进行加密保护。
当然加密壳的保护能力要强得多！-----------<小A分割线>-------------二、工具的认识OllyDBG ring3 shell层级别的动态编译工具、PEid、ImportREC、LordPE、softIce ring0级别调试工具-------------<小A分割>-------------------三、常见手动脱壳方法预备知识1.PUSHAD （入栈/压栈）代表程序的入口点,2.POPAD （弹栈/出栈）代表程序的出口点，与PUSHAD想对应，一般找到这个OEP就在附近3.OEP：程序的入口点，软件加壳就是隐藏了OEP（或者用了假的OEP/FOEP），只要我们找到程序真正的OEP，就可以立刻脱壳。
------------<小A分割线>--------------------方法一：单步跟踪法1.用OD载入，点“不分析代码！”2.单步向下跟踪F8，实现向下的跳。
也就是说向上的跳不让其实现！（通过F4）3.遇到程序往回跳的（包括循环），我们在下一句代码处按F4（或者右健单击代码，选择断点——>运行到所选）4.绿色线条表示跳转没实现，不用理会，红色线条表示跳转已经实现！5.如果刚载入程序，在附近就有一个CALL的，我们就F7跟进去，不然程序很容易跑飞，这样很快就能到程序的OEP6.在跟踪的时候，如果运行到某个CALL程序就运行的，就在这个CALL中F7进入7.一般有很大的跳转（大跨段），比如 jmp XXXXXX 或者 JE XXXXXX 或者有RETN 的一般很快就会到程序的OEP。
壳的基本脱法
7：去掉断点，按F8慢慢向下走
8：到达程序的OEP，脱壳
最后一种方法
方法六：懒人脱壳法 （由于这种脱壳方法速度比较慢，这里我就不再演示了，大家跟着下面的步骤就可以找到oep了）
1、用od载入软件
2、点击选项——调试选项——SFX
第七节 手脱 PEDiminisher ；Dxpack 0.86 ；32lite 0.03a ；PEtite 2.2 这几种壳的简单方法
脱PEDiminisher ；Dxpack 0.86 ；这两种壳的时候，直接用之前讲到的ESP定律，即可完美脱壳。命令：【hr ESP地址】
最关键的地方到了：用 LordPE 这个软件自带的重建 PE 修复功能；重建PE头，重建后，即可运行！
第三节 手脱 UPX 壳的捷径
用我们已开始提到的”关键提示“。
具体操作：OD载入程序后，直接Ctrl+F，输入 POPAD ;点确定后来到这个命令所在的位置。按F2，在这个地方下断；再按F9（运行）；停止后，按F2取消刚才下的断点。再F8单步！
push 0 //在 retn 0C 的下面
retn //在这个地方按 F2（下断） ；F9（运行）
停止后按 一下 F8（单步）；再按一下 F7（跟进） 观看这看不懂？没关系，要是我，我也看不懂，所以我早有准备；详细步骤，如下（这是某程序的一部分）：
第二节 手脱wwpack 的壳
这个壳跟上面说的 EZIP 1.0 的壳一样，OD脱壳 ImportREC 进行修复程序还是无法运行。所以还是要用 LordPE 进行脱壳工作。
具体步骤 ： 从 LordPE 列表中选中目标程序的进程→点”鼠标右键“ 选择”完整脱壳“。最后用 ImportREC 进行修复 。发现还是不能运行！
脱壳方法总结
脱壳方法总结1. 引言在软件开发和逆向分析领域，脱壳（Unpacking）是指将一个已经被加密或保护的可执行文件还原到其原始状态的过程。
通过脱壳，分析人员可以获取被加密或保护的文件的源代码、算法、关键函数等信息，从而进行后续的逆向工程分析。
本文将总结几种常见的脱壳方法，并介绍它们的原理和使用场景。
2. 静态脱壳方法静态脱壳方法是指在不运行程序的情况下，通过对加密或保护的文件进行静态分析，还原出原始的可执行文件。
2.1. 字节码分析字节码分析是通过对加密或保护的文件进行二进制分析，识别出不同的加密算法或保护机制，从而还原出原始文件。
常见的字节码分析工具有IDA Pro、Radare2等。
2.1.1. IDA ProIDA Pro是一款功能强大的反汇编工具，可以用于对二进制文件进行逆向分析。
通过加载被加密或保护的文件，IDA Pro可以在图形界面下显示程序的反汇编代码。
通过对代码进行分析，可以识别出不同的加密算法或保护机制，从而编写相应的解密脚本。
2.1.2. Radare2Radare2是另一款强大的反汇编工具，它以命令行形式提供了一系列功能，可以对二进制文件进行静态分析。
通过使用Radare2的命令，可以查看程序的反汇编代码，识别出加密或保护机制，并编写相应的解密脚本。
2.2. 调试器调试器是一种用于运行和调试程序的工具，通过对加密或保护的文件进行动态分析，可以观察程序的行为，从而还原出原始文件。
常见的调试器有OllyDbg、GDB等。
2.2.1. OllyDbgOllyDbg是一款运行在Windows平台上的调试器，它可以用于对可执行文件进行动态分析。
通过加载被加密或保护的文件，OllyDbg可以以汇编代码的形式显示程序的执行过程。
通过逐步执行程序，并观察寄存器、堆栈等信息的变化，可以找到解密过程中使用的关键函数和算法。
2.2.2. GDBGDB是一款开源的调试器，可以运行在多种平台上，如Linux、macOS等。
压缩壳和低强度加密壳的脱壳小结及简易脱壳法
Microsoft Visual C++ 6.0 ：55 8B EC 6A
Microsoft Visual C++ 6.0 [Overlay] E语言：55 8B EC 6A
OEP内存断点法具体操作步骤如下：
1、PEiD侦测壳的种类和OEP（壳的种类未知也可以的，但OEP必须要能够侦测到）
2、ollydbg载入目标程序，停在壳的入口
3、数据窗口Ctrl+G，填入PEiD侦测到OEP,确定
4、在数据窗口OEP处设置内存访问断点，F9运行
5、观察内存数据窗口OEP处数据变化
三、OEP内存断点万能脱壳法的简化变形
了解了OEP内存断点万能脱壳法脱壳机理以后，对于一些压缩壳这种方法还可以进行简化，对于压缩壳OEP处的代码在未解压前是不会被执行的，只有在解压完全之后才会被执行，（加密壳不一定是这样的，因为在OEP处的代码可能被壳的代码替换，是有可能被执行到的，执行的目的是解密原程序。）基于这样的理解，我们可以直接在在数据窗口OEP处设置硬件执行断点，当OEP处代码被执行时进行中断，而这时也正好是我们脱壳的最佳时机。
cmp $RESULT,400000
jb message
cmp $RESULT,400000
ja bT, "x"
run
bphwc $RESULT
jmp end
message:
msg "OEP VA Is False! Please Enter True OEP VA!"
Author: sxssl
普通壳的脱壳方法和脱壳技巧
普通壳的脱壳方法和脱壳技巧脱壳是指将一个已经打包的可执行文件（通常是二进制文件）恢复为原始的、可以读取和修改的形式。
这在软件逆向工程、安全审计和病毒分析等领域都是非常常见的操作。
下面我将为你介绍普通壳的脱壳方法和脱壳技巧。
一、普通壳的脱壳方法1.静态脱壳静态脱壳是指对目标文件进行分析，找到壳的解密和载入代码，然后将其解密出来，恢复原始的可执行文件。
- 调试器脱壳：使用调试器（如OllyDbg、IDA Pro等）来单步执行目标程序，找到壳的解密代码，并通过调试器的内存分析功能来寻找待解密的数据。
一旦找到解密的算法和密钥，就可以将目标文件完全解密出来。
- 静态分析脱壳：通过静态分析工具（如IDA Pro、Hopper等）来逆向目标文件，找到壳的解密算法和密钥，然后将其解密出来。
2.动态脱壳动态脱壳是指在目标程序运行时，通过对程序的运行过程进行监控和分析，找到壳的解密和载入代码，并将其解密出来，恢复原始的可执行文件。
-API钩取脱壳：通过使用一个DLL注入到目标程序的地址空间中，然后使用API钩子来监控API函数的调用，找到壳解密代码的入口点。
一旦找到壳解密代码的起始地址，就可以通过调试器执行目标程序，并在合适的时机将解密出来的代码或数据导出。
- 内存转储脱壳：通过在目标程序的执行过程中，使用内存转储工具（如winhex、ollydump等）将目标程序的内存转储出来，然后使用静态脱壳的方法对内存转储文件进行分析。
二、普通壳的脱壳技巧1.加载器分析在进行脱壳之前，首先要分析目标文件中的加载器。
加载器是壳程序的一部分，用于解压和载入真正的可执行文件。
通过分析加载器，可以确定载入代码和解密算法的位置，并推导出解密算法的密钥。
2.寻找壳代码的入口点在进行脱壳时，需要找到壳代码的入口点，即壳程序开始执行的位置。
可以通过调试器或者静态分析工具来寻找入口点，并标记下来以备后续使用。
3.内存和断点设置通过内存和断点设置，在目标程序运行过程中定位到关键的内存位置。
脱壳找OEP7种基本方法
脱壳找OEP7种基本方法七种找OEP的方法OD手动脱壳的7种法则方法一：单步跟踪法1.用OD载入，点“不分析代码！”2.单步向下跟踪F8，实现向下的跳。
也就是说向上的跳不让其实现！（通过F4）3.遇到程序往回跳的（包括循环），我们在下一句代码处按F4（或者右健单击代码，选择断点——>运行到所选）4.绿色线条表示跳转没实现，不用理会，红色线条表示跳转已经实现！5.如果刚载入程序，在附近就有一个CALL的，我们就F7跟进去，不然程序很容易跑飞，这样很快就能到程序的OEP6.在跟踪的时候，如果运行到某个CALL程序就运行的，就在这个CALL中F7进入7.一般有很大的跳转（大跨段），比如jmp XXXXXX 或者JE XXXXXX 或者有RETN 的一般很快就会到程序的OEP。
PS:在有些壳无法向下跟踪的时候，我们可以在附近找到没有实现的大跳转，右键-->“跟随”,然后F2下断，Shift+F9运行停在“跟随”的位置，再取消断点，继续F8单步跟踪。
一般情况下可以轻松到达OEP！方法二：ESP定律法ESP定理脱壳（ESP在OD的寄存器中，我们只要在命令行下ESP的硬件访问断点，就会一下来到程序的OEP了！）1.开始就点F8，注意观察OD右上角的寄存器中ESP有没突变成红色。
（这只是一般情况下，更确切的说我们选择的ESP值是关键句之后的第一个ESP值）2.在命令行下：dd XXXXXXXX(指在当前代码中的ESP地址，或者是hr XXXXXXXX)，按回车！3.选中下断的地址，断点--->硬件访--->WORD断点。
4.按一下F9运行程序，直接来到了跳转处，按下F8，到达程序OEP。
方法三：内存镜像法1：用OD打开软件！2：点击选项——调试选项——异常，把里面的忽略全部√上！CTRL+F2重载下程序！3：按ALT+M,打开内存镜象，找到程序的第一个.rsrc.按F2下断点，然后按SHIFT+F9运行到断点，接着再按ALT+M,打开内存镜象，找到程序的第一个.rsrc.上面的.CODE（也就是00401000处），按F2下断点！然后按SHIFT+F9（或者是在没异常情况下按F9），直接到达程序OEP！方法四：一步到达OEP1.开始按Ctrl+F,输入：popad（只适合少数壳，包括UPX，ASPACK壳），然后按下F2，F9运行到此处2.来到大跳转处，点下F8，到达OEP！方法五：最后一次异常法1：用OD打开软件2：点击选项——调试选项——异常，把里面的√全部去掉！CTRL+F2重载下程序3：一开始程序就是一个跳转，在这里我们按SHIFT+F9，直到程序运行，记下从开始按SHIFT+F9到程序运行的次数m！4：CTRL+F2重载程序，按SHIFT+F9（这次按的次数为程序运行的次数m-1次）5：在OD的右下角我们看见有一个"SE句柄"，这时我们按CTRL+G，输入SE句柄前的地址！6：按F2下断点！然后按SHIFT+F9来到断点处！7：去掉断点，按F8慢慢向下走！8：到达程序的OEP！方法六：模拟跟踪法1：先试运行，跟踪一下程序，看有没有SEH暗桩之类2：ALT+M打开内存镜像，找到（包含=SFX,imports,relocations）内存镜像，项目30地址=0054B000大小=00002000 (8192.)Owner=check 00400000区段=.aspack包含=SFX,imports,relocations类型=Imag 01001002访问=R初始访问=RWE3：地址为0054B000，如是我们在命令行输入tc eip<0054B000,回车，正在跟踪ing。
脱壳技术
脱壳技术在一些计算机软件里有一段专门负责保护软件不被非法修改或反编译的程序。
它们一般都是先于程序运行，拿到控制权，然后完成它们保护软件的任务。
就像动植物的壳一般都是在身体外面一样理所当然（但后来也出现了所谓的“壳中带籽”的壳）。
由于这段程序和自然界的壳在功能上有很多相同的地方，基于命名的规则，大家就把这样的程序称为“壳”了。
就像计算机病毒和自然界的病毒一样，其实都是命名上的方法罢了。
从功能上抽象，软件的壳和自然界中的壳相差无几。
无非是保护、隐蔽壳内的东西。
而从技术的角度出发，壳是一段执行于原始程序前的代码。
原始程序的代码在加壳的过程中可能被压缩、加密……。
当加壳后的文件执行时，壳－这段代码先于原始程序运行，他把压缩、加密后的代码还原成原始程序代码，然后再把执行权交还给原始代码。
软件的壳分为加密壳、压缩壳、伪装壳、多层壳等类，目的都是为了隐藏程序真正的OEP（入口点，防止被破解）。
关于“壳”以及相关软件的发展历史请参阅吴先生的《一切从“壳”开始》。
（一）壳的概念作者编好软件后，编译成exe可执行文件。
1.有一些版权信息需要保护起来，不想让别人随便改动，如作者的姓名，即为了保护软件不被破解，通常都是采用加壳来进行保护。
2.需要把程序搞的小一点，从而方便使用。
于是，需要用到一些软件，它们能将exe可执行文件压缩， 3.在黑客界给木马等软件加壳脱壳以躲避杀毒软件。
实现上述功能，这些软件称为加壳软件。
（二）加壳软件最常见的加壳软件ASPACK ，UPX，PEcompact 不常用的加壳软件WWPACK32；PE-PACK ；PETITE NEOLITE（三）侦测壳和软件所用编写语言的软件，因为脱壳之前要查他的壳的类型。
1.侦测壳的软件fileinfo.exe 简称fi.exe（侦测壳的能力极强） 2.侦测壳和软件所用编写语言的软件language.exe（两个功能合为一体，很棒）推荐language2000中文版（专门检测加壳类型） 3.软件常用编写语言Delphi，VisualBasic（VB）---最难破，VisualC（VC）（四）脱壳软件。
手动脱壳简简单单
手动脱壳简简单单在我们进行逆向分析的时候，通常会遇到有些文件被加密处理过，也就是我们通常所说的被加了壳，这时他的内部结构都已经改变，我们想要继续分析是很麻烦的，所以我们需要把它从壳中分离出来，也就是我们常说的脱壳。
现在越来越多的软件都使用了加壳的保护方法，所以脱壳是我们在逆向分析过程中很主要的步骤，掌握它至关重要壳是最早出现的一种专业加密软件。
不同的壳的侧重点也不同，有的侧重于压缩，有的侧重于加密，所以出现了压缩壳和加密壳。
压缩壳的特点是减小软件的体积，我们常见的有：UPX，ASPack，PECompack等。
加密壳的则侧重于加密，保护强度较大，常见的有：ASProtect，Armadillo，Themida等。
第一步寻找OEP★OEP（Original Entry Point）：程序的原入口点，就是壳程序在完成了对原程序的还原后，开始跳转到刚还原的程序执行，此时的地址就是入口点的值。
1 单步跟踪首先，我们运行peid, 将我们要检测的程序拖到上面,可以看到它是用aspack加的壳，如图1。
我们运行OD，点击菜单栏中的“文件”→“打开”，把我们需要脱壳的文件加载进来，接着就会弹出一个对话框“模块……你仍要继续分析吗”，如图2，我们选择“否”（不管什么方法脱壳都要按“否”），程序就会停以下的代码处：01013001 > 90 nop01013002 60 pushad01013003 E8 03000000 call 0101300B01013008 - E9 EB045D45 jmp 465E34F80101300D 55 push ebp0101300E C3 retn0101300F E8 01000000 call 0101301501013014 EB 5D jmp short 01013073我们按F8来跟踪一下，当到了call 0101300B这里的时候，记事本自己打开了，我们按Ctrl+F2重新载入文件，再来跟踪，当我们再次遇到call 0101300B这一句的时候我们按F7跟进，代码会来到这里：0101300B 5D pop ebp0101300C 45 inc ebp0101300D 55 push ebp0101300E C3 retn我们继续F8来跟踪，当到了retn一句时，程序返回了，停在了call的下面一句jmp465E34F8上，跳转以后代码来到了下面的这一句call 01013015，继续F8，如果遇到程序往回跳，那么我们就在下一句代码处按F4，这样跟踪一段时间以后，我们会看到这样的代码：010133BB 68 9D730001 push 0100739D010133C0 C3 retn再F8一下我们的程序就返回了了这里：0100739D 6A 70 push 700100739F 68 98180001 push 01001898010073A4 E8 BF010000 call 01007568到这里，我们就已经到达OEP，单步跟踪法测试成功。
脱壳教程_精品文档
脱壳教程标题：脱壳教程引言：脱壳是指将软件或应用程序的包装层（也称为保护壳或加密层）移除，以便对其进行更深入的分析、修改或逆向工程。
脱壳过程可以帮助软件开发人员或安全研究人员理解程序的内部运行机制，发现其中的漏洞或者进行优化改进。
本文将介绍脱壳过程的基本原理和几种常见的脱壳工具以及其使用方法。
一、脱壳的基本原理脱壳的基本原理是通过破解或绕过软件的保护机制来移除保护壳。
保护机制通常包括各种检测和防御技术，如代码混淆、加壳、逆向工程等。
常见的保护壳有UPX、ASProtect、Enigma等。
脱壳的过程涉及对程序进行调试、分析和修改。
二、脱壳工具介绍及使用方法1. OllyDbgOllyDbg是一款著名的逆向工程和调试工具，也是脱壳过程中经常使用的工具之一。
它具有强大的调试和反汇编功能，可以帮助分析程序的执行流程、内存变化等。
使用OllyDbg进行脱壳时，首先需要加载待脱壳的程序，然后设置断点，跟踪程序执行，找到关键的保护机制的位置，最终移除保护壳。
2. IDA ProIDA Pro是一款功能强大的反汇编和逆向工程工具。
它可以将程序转换为易读的汇编代码，并提供强大的导航和分析功能。
脱壳时可以使用IDA Pro来分析和修改程序的内存和代码。
它可以帮助找到程序的入口点、解密过程等，从而移除保护壳。
3. x64dbgx64dbg是一款开源的调试器工具，适用于32位和64位的Windows系统。
它具有用户友好的界面和丰富的调试功能，并支持脱壳过程中的动态调试和反调试技术。
使用x64dbg进行脱壳时，可以跟踪程序的执行流程、查看内存变化，找到关键代码并进行修改。
三、脱壳过程示例以某款加壳的软件为例，介绍基本的脱壳过程。
1. 加载待脱壳的程序到脱壳工具中，并设置断点。
2. 运行程序，在断点处停下来，观察程序的状态和执行流程。
3. 跟踪程序的执行，查找关键的保护机制位置，例如解密函数、保护壳的入口等。
4. 分析并修改程序的内存和代码，移除保护壳。
大智慧主程序脱壳全记录(图文)第1集
大智慧主程序脱壳全记录（图文）第四集今天用大智慧主程序为例进行脱壳操作一、ESP定律手脱法第一步，查壳，“ASPack 2.12 -> Alexey Solodovnikov”第二步，启动OD，加载主程序，来到下图画面所示地址。
进入“选项”－“调试选项”－“异常”，全部钩选（可做也可不做。
普通压缩壳Od调试时候没有异常，加密壳全部有反跟踪代码，会有许多SEH陷阱使OD调试时产生异常。
）用F8进行单步跟踪，在右边窗口寄存器（FUP）中的“ESP”突现“0012FFA4”时停下，用鼠标点选该句，打开右键菜单，如下图所示操作。
（或在左下角“命令”栏中输入“DD 0012FFA4”回车）点选左下角“0012FFA4”语句，打开菜单，选择“断点”－“硬件访问”－“Word”，F9运行如下图所示，在F8单步跟踪，实现大跳转用鼠标右键打开菜单，选择“用OllyDump脱壳调试进程”点击“脱壳”按钮，进行存盘，记住OEP地址为“2F68B5”（在进行输入表修复时要用到的地址）千万记住：要删除先前设置的“断点”，否则，原版主程序运行时会出现异常（按下图所示操作）“调试”－“硬件断点”――――――“删除”＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝重新载入已脱壳的主程序，可以阅读程序流程（下图）第三步，检验。
启动已脱壳的主程序，如果正常，则不需要修复输入表，否则，还得用前面的方法进行修复操作二、内存镜像法第一步，查壳，“ASPack 2.12 -> Alexey Solodovnikov”（略）第二步，启动OD，加载主程序，来到下图画面所示地址“CTRL+M”调出“Memory Map”,选择“。
rsrc”，用鼠标右键菜单“设置访问中断F2”，F9运行来到下图地址，在“Memory Map”中选择“。
text”，同样用鼠标右键菜单“设置访问中断F2”，F9运行程序停在这里，那就是真正的入口点用鼠标右键打开菜单，选择“用OllyDump脱壳调试进程”点击“脱壳”按钮，进行存盘，记住OEP地址为“2F68B5”（在进行输入表修复时要用到的地址）其余操作同上。
脱壳教程
破解预备知识一、机械码,又称机器码.ultraedit打开,编辑exe文件时你会看到许许多多的由0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F组成的数码,这些数码就是机器码.修改程序时必须通过修改机器码来修改exe文件.二、需要熟练掌握的全部汇编知识(只有这么多)不大容易理解,可先强行背住,混个脸儿熟,以后慢慢的就理解了cmp a,b 比较a与bmov a,b 把b的值送给aret 返回主程序nop 无作用,英文“no operation”的简写，意思是“do nothing”(机器码90)***机器码的含义参看上面(解释:ultraedit打开编辑exe文件时你看到90,等同于汇编语句nop)call 调用子程序je 或jz 若相等则跳(机器码74 或0F84)jne或jnz 若不相等则跳(机器码75或0F85)jmp 无条件跳(机器码EB)jb 若小于则跳ja 若大于则跳jg 若大于则跳jge 若大于等于则跳jl 若小于则跳jle 若小于等于则跳pop 出栈push 压栈三、常见修改(机器码)74=>75 74=>90 74=>EB75=>74 75=>90 75=>EBjnz->nop75->90(相应的机器码修改)jnz -> jmp75 -> EB(相应的机器码修改)jnz -> jz75->74 (正常) 0F 85 -> 0F 84(特殊情况下,有时,相应的机器码修改)四、两种不同情况的不同修改方法1.修改为jmpje(jne,jz,jnz) =>jmp相应的机器码EB （出错信息向上找到的第一个跳转）jmp的作用是绝对跳，无条件跳，从而跳过下面的出错信息xxxxxxxxxxxx 出错信息，例如：注册码不对，sorry,未注册版不能...，"Function Not A vaible in Demo" 或"Command Not A vaible" 或"Can't save in Shareware/Demo"等（我们希望把它跳过，不让它出现）xxxxxxxxxxxx 正确路线所在2.修改为nopje(jne,jz,jnz) =>nop相应的机器码90 （正确信息向上找到的第一个跳转）nop的作用是抹掉这个跳转，使这个跳转无效，失去作用，从而使程序顺利来到紧跟其后的正确信息处xxxxxxxxxxxx 正确信息，例如：注册成功，谢谢您的支持等（我们希望它不被跳过，让它出现，程序一定要顺利来到这里）xxxxxxxxxxxx 出错信息（我们希望不要跳到这里，不让它出现）五、爆破无敌口诀背会此口诀，天下无敌，以后慢慢琢磨，仔细体会，收益多多。
ESP定律
(图文详解)ESP定律脱壳+修复默认分类 2009-05-13 10:13 阅读211 评论0 字号：大中小ASPack 2.12 -> Alexey Solodovnikov一个压缩壳，今天我们用ESP定律脱壳，使用LoadPE来保存Dump脱壳后文件，并用IR（ImportREC）来修复脱壳文件。
005AD001 > 60 pushad ; OD载入后来到这里005AD002 E8 03000000 call 005AD00A ; 我们F8一次来到该CALL，此时我们看寄存器窗口的ESP地址005AD007 - E9 EB045D45 jmp 45B7D4F7005AD00C 55 push ebp005AD00D C3 retn我们使用ESP定律脱壳,见图文说明:005AD3B0 /75 08 jnz short 005AD3BA ; F9一次后来到这里005AD3B2 |B8 01000000 mov eax, 1005AD3B7 |C2 0C00 retn 0C005AD3BA \68 181C5000 push 00501C18005AD3BF C3 retn ; 退出这个retn后就来到OEP处00501C18 55 push ebp ; 程序的OEP 使用LoadPE保存文件IR修复看我操作00501C19 8BEC mov ebp, esp00501C1B 83C4 F0 add esp, -1000501C1E 53 push ebx00501C1F B8 00185000 mov eax, 0050180000501C24 E8 1F4CF0FF call 00406848然后我们使用LoadPE脱壳,看我操作:使用IR修复:第一步：我们选择我们调试的原程序第二步：我们在OEP处填入数据此时我们看下OD中的OEP地址OEP=00501C18-00400000=00101C18所以我们在此填入OEP=00101C18然后点自动搜索IAT 点确定第三步：我们选择获取输入表看上方的输入表数据都为真无需修复所以我们点修复抓取文件--即我们使用LoadPE脱壳的文件我们运行修复好的文件,OK,可以运行,再用PEiD查壳:Borland Delphi 6.0 - 7.。
脱壳方法
手脱AHpack 0.1 -> FEUERRADER
建议不要单步跟踪 使用ESP定律能更快到达OEP SFX方法也可以 不过效率就 呵呵~
/*
Script written by VolX
Script : Aspr2.XX_unpacker
版本 : v1.0SC
日期 : 15-Jan-2007
调试环境 : OllyDbg 1.1, ODBGScript 1.47, WINXP, WIN2000
调试选项 : 设置 OllyDbg 忽略所有异常选项
看EP区段 显示 .!ep
突然发现peid 查壳很一般了 越来越不能相信它了
下面是我的脱壳手记:
用OD载入:
程序入口: 看壳的入口,好像是!EP(EXE Pack)1.4的,就暂且相信它吧
004B3000 > F8 clc
004B3001 57 push edi
004B301A 0BDB or ebx, ebx
004B301C 40 inc eax
004B301D 48 dec eax
004B301E 84D2 test dl, dl
软件名:锐速简历通
开始以为一次ESP定律就可以解决了,一看,OD断下来的时候和刚加载的一样,我马上想到是不是自己操作失误了?本来还想自嘲一下说老马失蹄,但是查看断点,这个软件唯一有点意思的地方是作者使用了两次一样的壳(不知道为什么,老觉得软件作者很会开玩笑),所以再使用一次ESP定律直接到达OEP dump 之后直接能使用 不用import修复
压缩壳脱法
压缩壳脱法:------------------方法一:单步跟踪法------------------介绍:这是最通用的方法,对于未知壳,基本都用这种方法,这种方法过程比较麻烦,要一步一步的跟踪分析,要有一定的耐心.1.用OD载入,选"不分析代码"2.单步向下跟踪按F8，实现向下的跳.不让程序往回跳.3.遇到程序往回跳的（包括循环），我们在下一句代码处按F4（或者右健单击代码，选择断点——>运行到所选）4.如果刚载入程序，在附近就有一个CALL的，我们就F7跟进去，不然程序很容易运行.5.在跟踪的时候，如果运行到某个CALL程序就运行的，就在这个CALL中F7进入.6.一般遇到很大的跳转（跨段跳），比如 jmp XXXXXX 或 JE XXXXXX 或有RETN的一般很快就会到程序的OEP。
-----------------方法二:ESP定律法-----------------介绍: 这种方法可以脱大部的压缩壳和少数加密壳,操作起来比较简单,脱壳速度也相对比较快.1.开始就点F8向下走，注意观察OD右上角的寄存器中ESP有没突现（变成红色）2.在命令行下：dd XXXXXXXX(指在当前代码中的ESP地址，或者hrXXXXXXXX)，按回车！3.选中下断的地址，断点--->硬件访--->WORD断点。
4.按一下F9运行程序，直接来到了跳转处，按下F8向下走，就到达程序OEP。
-----------------方法三:内存镜像法-----------------介绍:也是一种比较好用的脱壳方法,大部分的压缩壳和加密壳用内存镜像法能快速脱掉.非常实用.1.用OD打开,设置选项——调试选项——异常,忽略所有异常(也就是把里面的忽略全部√上),然后CTRL+F2重载下程序！2.按ALT+M,打开内存镜象，找到程序的第一个.rsrc.按F2下断点，然后按SHIFT+F9运行到断点.3.接着再按ALT+M,打开内存镜象，找到程序的第一个.rsrc.上面的.CODE，按F2下断点！然后按SHIFT+F9，直接到达程序OEP！----------------方法四:一步到OEP----------------介绍:这是一种巧方法,脱壳速度最快,前提是要知道这个壳的特征,利用这种壳的共性快速找到程序的OEP.这种方法只用于少数壳.1.开始按Ctrl+F,输入：popad,然后按下F2下断，按F9运行到此处.2.很快来到大跳转,按F8向下走,来到OEP.----------------------方法五:最后一次异常法:----------------------介绍:这种方法一般用于加密壳,这是脱加密壳的一种通用方法.第一步:用OD打开程序,点击选项——调试选项——异常，把里面的√全部去掉！CTRL+F2重载下程序.第二步:接着我们按SHIFT+F9,直到程序运行,记下从开始按SHIFT+F9到程序运行的次数n.第三步:重载程序,再按SHIFT+F9,这次按的次数为上次让程序运行时的次数的n-1次.第四步:此时观察OD的右下角有一个"SE 句柄",这时我们按CTRL+G，输入SE 句柄前的地址！来到这个地址.第五步:在这里,按F2下断点！然后按SHIFT+F9来到断点处！第六步:这时候我们已经跳过了所有异常,然后去掉断点，按F8慢慢向下跟踪很快就到达OEP 了.----------------------模拟跟踪法----------------------1.运行程序，确定是否有暗桩。
脱壳知识——精选推荐
脱壳知识什么是壳因为许多软件为了保护⾃⼰的软件不被和修改，通常会加壳，代码加密，增加破解的难度，从⽽达到保护软件的⽬的。
⾸先⼤家应该先明⽩“壳”的概念。
在⾃然界中，我想⼤家对壳这东西应该都不会陌⽣了，植物⽤它来保护种⼦，动物⽤它来保护⾝体等等。
同样，在⼀些计算机软件⾥也有⼀段专门负责保护软件不被⾮法修改或反编译的程序。
它们⼀般都是先于程序运⾏，拿到控制权，然后完成它们保护软件的任务。
举个例⼦，核桃⼤家都知道吧，想要吃到⾥⾯的⾁，就必须得先打开核桃外⾯那⼀层坚硬的壳，同样，外⾯想要看到⼀个程序的内部逻辑代码，就要脱掉外⾯的⼀层壳。
程序作者在编好软件后，编译成exe可执⾏⽂件。
有⼀些版权信息需要保护起来，不想让别⼈随便改动，如作者的姓名，即为了保护软件不被破解，通常都是采⽤加壳来进⾏保护。
需要把程序搞的⼩⼀点，缩⼩程序的体积，减少内存容量，从⽽⽅便使⽤。
于是，需要⽤到⼀些软件，它们能将exe可执⾏⽂件压缩，在⿊客界给⽊马等软件加壳以躲避杀毒软件。
实现上述功能，这些称为加壳。
⾃然有加壳就会有脱壳。
为什么要脱壳脱壳是为了能够学习⼀个软件的程序设计逻辑，达到我们想要的⽬的。
如果不脱壳，我们就不能够了解软件的逻辑，也就⽆法得到源代码，也就⽆法破解⼀个软件，也就不会有这篇⽂章了。
我们拿到⼀个软件想要了解它的编程逻辑，那么我们就需要对它进⾏反汇编，当然有壳，也必须先脱壳（有些软件也可以不脱壳破解）。
如果我们需要对⼀个病毒或者⽊马进⾏分析，也是需要脱壳的，如果病毒⽊马不加壳，早被杀毒软件杀掉了。
⼀些常见的壳1、aspack壳2.caspr2、upx壳3、PEcompact壳等等...我们要脱壳，就需要⽤到⼀些汇编的指令，这是必须的，如果不懂汇编指令的话，那么就⽆法进⾏软件的脱壳了。
下⾯我就来介绍破解需要的⼀些主要的汇编指令⼀、数据传输指令───────────────────────────────────────它们在存贮器和寄存器、寄存器和输⼊输出端⼝之间传送数据.1. 通⽤数据传送指令.MOV 传送字或字节.MOVSX 先符号扩展,再传送.MOVZX 先零扩展,再传送.PUSH 把字压⼊堆栈.POP 把字弹出堆栈.PUSHA 把AX,CX,DX,BX,SP,BP,SI,DI依次压⼊堆栈.POPA 把DI,SI,BP,SP,BX,DX,CX,AX依次弹出堆栈.PUSHAD 把EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI依次压⼊堆栈.POPAD 把EDI,ESI,EBP,ESP,EBX,EDX,ECX,EAX依次弹出堆栈.BSWAP 交换32位寄存器⾥字节的顺序XCHG 交换字或字节.( ⾄少有⼀个操作数为寄存器,段寄存器不可作为操作数)CMPXCHG ⽐较并交换操作数.( 第⼆个操作数必须为累加器AL/AX/EAX )XADD 先交换再累加.( 结果在第⼀个操作数⾥ )XLAT 字节查表转换.── BX 指向⼀张 256 字节的表的起点, AL 为表的索引值 (0-255,即0-FFH); 返回 AL 为查表结果. ( [BX+AL]->AL )2. 输⼊输出端⼝传送指令.IN I/O端⼝输⼊. ( 语法: IN 累加器, {端⼝号│DX} )OUT I/O端⼝输出. ( 语法: OUT {端⼝号│DX},累加器 )输⼊输出端⼝由⽴即⽅式指定时, 其范围是 0-255; 由寄存器 DX 指定时,其范围是 0-65535.3. ⽬的地址传送指令.LEA 装⼊有效地址.例: LEA DX,string ;把偏移地址存到DX.LDS 传送⽬标指针,把指针内容装⼊DS.例: LDS SI,string ;把段地址:偏移地址存到DS:SI.LES 传送⽬标指针,把指针内容装⼊ES.例: LES DI,string ;把段地址:偏移地址存到ES:DI.LFS 传送⽬标指针,把指针内容装⼊FS.例: LFS DI,string ;把段地址:偏移地址存到FS:DI.LGS 传送⽬标指针,把指针内容装⼊GS.例: LGS DI,string ;把段地址:偏移地址存到GS:DI.LSS 传送⽬标指针,把指针内容装⼊SS.例: LSS DI,string ;把段地址:偏移地址存到SS:DI.4. 标志传送指令.LAHF 标志寄存器传送,把标志装⼊AH.SAHF 标志寄存器传送,把AH内容装⼊标志寄存器.PUSHF 标志⼊栈.POPF 标志出栈.PUSHD 32位标志⼊栈.POPD 32位标志出栈.⼆、算术运算指令───────────────────────────────────────ADD 加法.ADC 带进位加法.INC 加 1.AAA 加法的ASCII码调整.DAA 加法的⼗进制调整.SUB 减法.SBB 带借位减法.DEC 减 1.NEC 求反(以 0 减之).CMP ⽐较.(两操作数作减法,仅修改标志位,不回送结果).AAS 减法的ASCII码调整.DAS 减法的⼗进制调整.MUL ⽆符号乘法.IMUL 整数乘法.以上两条,结果回送AH和AL(字节运算),或DX和AX(字运算),AAM 乘法的ASCII码调整.DIV ⽆符号除法.IDIV 整数除法.以上两条,结果回送:商回送AL,余数回送AH, (字节运算);或商回送AX,余数回送DX, (字运算).AAD 除法的ASCII码调整.CBW 字节转换为字. (把AL中字节的符号扩展到AH中去)CWD 字转换为双字. (把AX中的字的符号扩展到DX中去)CWDE 字转换为双字. (把AX中的字符号扩展到EAX中去)CDQ 双字扩展. (把EAX中的字的符号扩展到EDX中去)三、逻辑运算指令───────────────────────────────────────AND 与运算.OR 或运算.XOR 异或运算.NOT 取反.TEST 测试.(两操作数作与运算,仅修改标志位,不回送结果).SHL 逻辑左移.SAL 算术左移.(=SHL)SHR 逻辑右移.SAR 算术右移.(=SHR)ROL 循环左移.ROR 循环右移.RCL 通过进位的循环左移.RCR 通过进位的循环右移.以上⼋种移位指令,其移位次数可达255次.移位⼀次时, 可直接⽤操作码. 如 SHL AX,1.移位>1次时, 则由寄存器CL给出移位次数.如 MOV CL,04SHL AX,CL四、串指令─────────────────────────────────────── DS:SI 源串段寄存器 :源串变址.ES:DI ⽬标串段寄存器:⽬标串变址.CX 重复次数计数器.AL/AX 扫描值.D标志 0表⽰重复操作中SI和DI应⾃动增量; 1表⽰应⾃动减量. Z标志⽤来控制扫描或⽐较操作的结束.MOVS 串传送.( MOVSB 传送字符. MOVSW 传送字. MOVSD 传送双字. ) CMPS 串⽐较.( CMPSB ⽐较字符. CMPSW ⽐较字. )SCAS 串扫描.把AL或AX的内容与⽬标串作⽐较,⽐较结果反映在标志位.LODS 装⼊串.把源串中的元素(字或字节)逐⼀装⼊AL或AX中.( LODSB 传送字符. LODSW 传送字. LODSD 传送双字. )STOS 保存串.是LODS的逆过程.REP 当CX/ECX<>0时重复.REPE/REPZ 当ZF=1或⽐较结果相等,且CX/ECX<>0时重复.REPNE/REPNZ 当ZF=0或⽐较结果不相等,且CX/ECX<>0时重复.REPC 当CF=1且CX/ECX<>0时重复.REPNC 当CF=0且CX/ECX<>0时重复.五、程序转移指令─────────────────────────────────────── 1>⽆条件转移指令 (长转移)JMP ⽆条件转移指令CALL 过程调⽤RET/RETF过程返回.2>条件转移指令 (短转移,-128到+127的距离内)( 当且仅当(SF XOR OF)=1时,OP1<OP2 )JA/JNBE 不⼩于或不等于时转移.JAE/JNB ⼤于或等于转移.JB/JNAE ⼩于转移.JBE/JNA ⼩于或等于转移.以上四条,测试⽆符号整数运算的结果(标志C和Z).JG/JNLE ⼤于转移.JGE/JNL ⼤于或等于转移.JL/JNGE ⼩于转移.JLE/JNG ⼩于或等于转移.以上四条,测试带符号整数运算的结果(标志S,O和Z).JE/JZ 等于转移.JNE/JNZ 不等于时转移.JC 有进位时转移.JNC ⽆进位时转移.JNO 不溢出时转移.JNP/JPO 奇偶性为奇数时转移.JNS 符号位为 "0" 时转移.JO 溢出转移.JP/JPE 奇偶性为偶数时转移.JS 符号位为 "1" 时转移.3>循环控制指令(短转移)LOOP CX不为零时循环.LOOPE/LOOPZ CX不为零且标志Z=1时循环.LOOPNE/LOOPNZ CX不为零且标志Z=0时循环.JCXZ CX为零时转移.JECXZ ECX为零时转移.4>中断指令INT 中断指令INTO 溢出中断IRET 中断返回5>处理器控制指令HLT 处理器暂停, 直到出现中断或复位信号才继续.WAIT 当芯⽚引线TEST为⾼电平时使CPU进⼊等待状态.ESC 转换到外处理器.LOCK 封锁总线.NOP 空操作.STC 置进位标志位.CLC 清进位标志位.CMC 进位标志取反.STD 置⽅向标志位.CLD 清⽅向标志位.STI 置中断允许位.CLI 清中断允许位.其实上⾯我们⽤到的也就主要有⼀些赋值指令和⼀些跳转指令⽽已，⼤部分我们⽬前是⽤不到的。
(完整版)常见几种脱壳方法(可编辑修改word版)
----------------<小 A 分>----------------一、概论壳出于程序作者想对程序资源压缩、注册保护的目的，把壳分为压缩壳和加密壳(强壳)两种"UPX" "ASPCAK" "TELOCK" "PELITE" "NSPACK(北斗)" ... "ARMADILLO" "ASPROTECT" "ACPROTECT" "EPE(王)" "SVKP" ...顾名思义，压缩壳只是为了减小程序体积对资源进行压缩，加密壳是程序输入表等等进行加密保护。
当然加密壳的保护能力要强得多！-----------<小 A 分割线>-------------二、工具的认识OllyDBG ring3 shell 层级别的动态编译工具、PEid、ImportREC、LordPE、softIce ring0 级别调试工具-------------<小 A 分割>-------------------三、常见手动脱壳方法预备知识1.P USHAD （入栈/压栈）代表程序的入口点,2.P OPAD （弹栈/出栈）代表程序的出口点，与 PUSHAD 想对应，一般找到这个OEP 就在附近3.O EP：程序的入口点，软件加壳就是隐藏了 OEP（或者用了假的 OEP/FOEP），只要我们找到程序真正的 OEP，就可以立刻脱壳。
------------<小 A 分割线>--------------------方法一：单步跟踪法1.用OD 载入，点“不分析代码！”2.单步向下跟踪 F8，实现向下的跳。
也就是说向上的跳不让其实现！（通过F4）3.遇到程序往回跳的（包括循环），我们在下一句代码处按 F4（或者右健单击代码，选择断点——>运行到所选）4.绿色线条表示跳转没实现，不用理会，红色线条表示跳转已经实现！5.如果刚载入程序，在附近就有一个 CALL 的，我们就 F7 跟进去，不然程序很容易跑飞，这样很快就能到程序的 OEP6.在跟踪的时候，如果运行到某个 CALL 程序就运行的，就在这个 CALL 中F7 进入7.一般有很大的跳转（大跨段），比如 jmp XXXXXX 或者 JE XXXXXX 或者有RETN 的一般很快就会到程序的 OEP。
半仙算命主程序脱壳全记录(图文)
半仙算命主程序脱壳全记录（图文）第一种方法：“ESP定律”和“M”内存查找“CODE”一、查壳：是―――“PECompact 2.x - Jeremy Collake”二、启动“OD”载入主程序―――F8下，发现“寄存器（FPU）”中突显“ESP 0012FFC0”，可进行“ESP定律”―――点选“跟随到数据窗口”－“断点”－“硬件访问”－“Word”，F9 运行―――到达下图地址，进入“调试”菜单，删除硬件访问断点，点“M”进入“Memory map”找到“CODE”下断―――到达下图地址，F8下，到达“C3 RETN”自动跳转―――发现“寄存器（FPU）”中突显“ESP 0012FBF0”，可再进行一次“ESP定律”（同上)―――到达下图地址，取消ESP断点，F8下―――到达“－FFE0 JMP EAX”跳转出口―――跳转后到达OEP真正入口―――可以进行DUMP 存盘操作―――入口地址自动修正为“0017407C”―――下图是已脱壳的主程序源码三、启动已脱壳的主程序，不能启动，那么要修复输入表（略）四、检验五、优化减肥，在检验。
OK第二种方法：连续多次“ESP定律”直接到达“OEP”真正入口―――记住：1、要在“调试选项”中忽略所以异常；2、“ESP”设置“硬件访问－WORD”，F9运行到达新的地址后，首先必须“删除”ESP所设置的断点。
―――第一次使用“ESP定律”的地址－“0012FFC0”―――到达新地址后，首先“删除”上一次的断点，接着第二次使用“ESP定律”，地址－“0012FC4C”―――到达新地址后，首先“删除”上一次的断点，接着第三次使用“ESP定律”，地址－“0012FC50”―――到达新地址后，首先“删除”上一次的断点，接着第四次使用“ESP定律”，地址－“0012FFC0”―――F9运行后，看到如下代码段时，说明已经到达OEP入口跳转――――――――――――――――――――――――――――――――――――――――――――――――――006D8AA2 - FFE0 JMP EAX ; 到达OEP入口跳转F8下006D8AA4 7C 40 JL SHORT ssbx.006D8AE6006D8AA6 57 PUSH EDI006D8AA7 00C8 ADD AL,CL―――其余操作同前所叙学习随笔：“PECompact 2.x - Jeremy Collake”这种壳有点古怪，手动单步跟踪还没有一次成功，经常是跟着跟着就晕菜了，或者是跟飞了。
浅谈脱壳方法（转）
浅谈脱壳方法（转）写给新手 - 浅谈脱壳方法2008-03-13 10:57:18| 分类：破解相关 | 标签： |字号大中小订阅目标：轻轻松松学开车 6.6地址：最近看到一些新手常问查壳工具查不出是什么壳,末知壳如何脱...我这里就简单的用一个示例程序谈谈脱壳方法. 算是给新手打打气.一般这种没有公开的壳不会太猛(除了hying, vcasm, jingulong等这些圈内人的壳哈), 大多是自己土制的壳, 有的还伪装一下, 致使查壳工具查不出或查出什么Aspack, UPX的壳. 碰到这种壳不用太怕, 认真跟踪分析一下一般都没多大问题.一般加壳后的程序运行时大多是用各种方法AntiDebugger, 其中夹杂很多花指令和垃圾指令, 然后解码,又是一堆AntiDebugger, 可能又解码, 恢复IAT, 又是一堆AntiDebugger...最后再跳到程序真正的OEP处, 对付这种壳一般的方法是先找到OEP, 再修复IAT在壳跳到OEP的时候一般是个跨段跳转, 跳转方法有很多, 如JMP XXXXXXXX, JMP [XXXXXXXX], JE [XXXXXXXX],PUSH XXXXXXXX RET, CALL XXXXXXXXX, CALL [XXXXXXXX], CALL EAX...还有的是在SEH中直接指定EIP等等, 找到这个跳转地址, 然后在相应地址上设上断点, F9运行, 就到达OEP处了, 此时就是最好的Dump时机修复IAT一般用ImportREC, 填写好OEP的RVA, 先点IATAutoSearch, 再点GetImport, 如果找到的API全部有效就可以点Fix Dump了, 如果有无效的就需要修复, 先点Show Invalid, 再对这些无效的API点右键, 共有3个修复级别, 分别是Disasm,HOOK, Trap Flag, 可以一个一个试, 全部API有效或只有一两个API无效时就可以点Fix Dump了, 如果修复不了就只有用手工修复了.手工修复IAT的方法是, 一般壳在运行的时候会恢复IAT或破坏IAT, 你可以在恢复IAT后或破坏IAT之前DUMP出完好的IAT, 再用16进制编辑器, 把完整的IAT复制到Dump出来的文件中, 多做做练习就不难了还是看看目标程序"轻轻松松学开车 6.6", 用PEiD查一下, ASPack 2.12 -> Alexey Solodovnikov用OD载入, 提示入口点在代码外部(以后别再问如何判断程序是否加壳了, 用OD载入如果有这个提示就表示程序是加了壳的), 点确定, 问是否分析, 点否, 来到入口处006AF001 D> 60 pushad ; 壳代码入口006AF002 E8 03000000 call DrvStudy.006AF00A ; 有花指令, F7跟进006AF007 - E9 EB045D45 jmp 45C7F4F7006AF00C 55 push ebp006AF00D C3 retn006AF00E E8 01000000 call DrvStudy.006AF014006AF013 EB 5D jmp short DrvStudy.006AF072在006AF002处call DrvStudy.006AF00A, 代码中没有006AF00A, 是因为花指令让OD错误的分析了代码, 用F7跟进就能来到006AF00A处, 像这种近距离的Call, 其实是变形的Jmp, 都要用F7跟进, 如果F8跳过的话可以会碰到里面的陷阱006AF00A 5D pop ebp ; DrvStudy.006AF007, 跳到这里006AF00B 45 inc ebp ; ebp + 1006AF00C 55 push ebp ; 变形跳转到ebp的地址处006AF00D C3 retn来到006AF008 /EB 04 jmp short DrvStudy.006AF00E ; 来到这里006AF00A |5D pop ebp006AF00B |45 inc ebp ; ebp + 1006AF00C |55 push ebp ; 变形跳转到ebp的地址处006AF00D |C3 retn006AF00E \E8 01000000 call DrvStudy.006AF014 ; 变形跳转, F7跟进006AF014 5D pop ebp006AF015 BB EDFFFFFF mov ebx,-13006AF01A 03DD add ebx,ebp006AF01C 81EB 00F02A00 sub ebx,2AF000 ; 代码重定位006AF022 83BD 22040000 00 cmp dword ptr ss:[ebp+422],0 ; 变量ebp+422是存放的基址006AF029 899D 22040000 mov dword ptr ss:[ebp+422],ebx 006AF02F /0F85 65030000 jnz DrvStudy.006AF39A ; 这里不跳006AF035 |8D85 2E040000 lea eax,dword ptr ss:[ebp+42E] ; "kernel32.dll"006AF03B |50 push eax ; 参数入栈006AF03C |FF95 4D0F0000 call dword ptr ss:[ebp+F4D] ; kernel32.GetModuleHandleA006AF042 |8985 26040000 mov dword ptr ss:[ebp+426],eax ; kernel32.dll的句柄存入ebp+426处006AF048 8BF8 mov edi,eax ; kernel32.77E40000006AF04A 8D5D 5E lea ebx,dword ptr ss:[ebp+5E] ; "VirtualAlloc"006AF04D 53 push ebx006AF04E 50 push eax ; Kernel32.dll句柄006AF04F FF95 490F0000 call dword ptr ss:[ebp+F49] ; GetProcAddress006AF055 8985 4D050000 mov dword ptr ss:[ebp+54D],eax ;把VirtualAlloc的函数地址存入ebp+54D处006AF05B 8D5D 6B lea ebx,dword ptr ss:[ebp+6B] ; "VirtualFree"006AF05E 53 push ebx006AF05F 57 push edi ; Kernel32.dll句柄入栈006AF060 FF95 490F0000 call dword ptr ss:[ebp+F49] ; GetProcAddress006AF066 8985 51050000 mov dword ptr ss:[ebp+551],eax ; 把VirtualFree的函数地址存入ebp+511处006AF06C 8D45 77 lea eax,dword ptr ss:[ebp+77] ; 跳转地址载入eax006AF06F FFE0 jmp eax ; 跳到eax指向的地方006AF08A 8B9D 31050000 mov ebx,dword ptr ss:[ebp+531] ; 来到这里, ebx=0006AF090 0BDB or ebx,ebx006AF092 /74 0A je short DrvStudy.006AF09E ; ebx==0,跳006AF094 |8B03 mov eax,dword ptr ds:[ebx]006AF096 |8785 35050000 xchg dword ptr ss:[ebp+535],eax 006AF09C |8903 mov dword ptr ds:[ebx],eax006AF09E \8DB5 69050000 lea esi,dword ptr ss:[ebp+569] ; 跳到这里, esi指向一标志006AF0A4 833E 00 cmp dword ptr ds:[esi],0006AF0A7 /0F84 21010000 je DrvStudy.006AF1CE ; 不为0, 不跳006AF0AD 6A 04 push 4006AF0AF 68 00100000 push 1000006AF0B4 68 00180000 push 1800006AF0B9 6A 00 push 0006AF0BB FF95 4D050000 call dword ptr ss:[ebp+54D] ; 分配内存C语言描述为VirtualAlloc(NULL, 0x1800, MEM_COMMIT, PAGE_READWRITE);006AF0C7 8B46 04 mov eax,dword ptr ds:[esi+4]006AF0CA 05 0E010000 add eax,10E006AF0CF 6A 04 push 4006AF0D1 68 00100000 push 1000006AF0D6 50 push eax006AF0D7 6A 00 push 0006AF0D9 FF95 4D050000 call dword ptr ss:[ebp+54D] ; 再次分配内存, eax为所需内存大小006AF0DF 8985 52010000 mov dword ptr ss:[ebp+152],eax ; 分配的第2块内存锯柄存入ebp+152处006AF0E5 56 push esi006AF0E6 8B1E mov ebx,dword ptr ds:[esi]006AF0E8 039D 22040000 add ebx,dword ptr ss:[ebp+422] 006AF0EE FFB5 56010000 push dword ptr ss:[ebp+156] ; 0x401000006AF0F4 FF76 04 push dword ptr ds:[esi+4]006AF0F7 50 push eax006AF0F8 53 push ebx006AF0F9 E8 6E050000 call DrvStudy.006AF66C ; 解压代码006AF0FE B3 01 mov bl,1006AF100 80FB 00 cmp bl,0006AF103 75 5E jnz short DrvStudy.006AF163006AF105 FE85 EC000000 inc byte ptr ss:[ebp+EC]006AF10B 8B3E mov edi,dword ptr ds:[esi]006AF10D 03BD 22040000 add edi,dword ptr ss:[ebp+422] 006AF113 FF37 push dword ptr ds:[edi] ; 保护0x401000处的代码006AF115 C607 C3 mov byte ptr ds:[edi],0C3 ; 把0x401000处的代码改为RET006AF118 FFD7 call edi ; 垃圾调用006AF11A 8F07 pop dword ptr ds:[edi] ; 恢复0x401000处的代码F8单步到下面一点点, 来到006AF12D 0BC9 or ecx,ecx006AF12F 74 2E je short DrvStudy.006AF15F006AF131 78 2C js short DrvStudy.006AF15F006AF133 AC lods byte ptr ds:[esi]006AF134 3C E8 cmp al,0E8006AF136 74 0A je short DrvStudy.006AF142006AF138 EB 00 jmp short DrvStudy.006AF13A006AF13A 3C E9 cmp al,0E9006AF13C 74 04 je short DrvStudy.006AF142006AF13E 43 inc ebx006AF13F 49 dec ecx006AF140 ^ EB EB jmp short DrvStudy.006AF12D006AF142 8B06 mov eax,dword ptr ds:[esi] ; 在这里设置一个断点这里找opcode为e8或e9的地方, F9运行后断下, ebx=1FE, eax=[esi]的内容, 紧接着会比较esi指向的地方006AF144 /EB 00 jmp short DrvStudy.006AF146006AF146 \803E 36 cmp byte ptr ds:[esi],36 ; 比较第2个字节的opcode是否为36006AF149 ^ 75 F3 jnz short DrvStudy.006AF13E ; 是就不跳, 这里为36不会跳006AF14B 24 00 and al,0006AF14D C1C0 18 rol eax,18 ; 解码006AF150 2BC3 sub eax,ebx ; 解码006AF152 8906 mov dword ptr ds:[esi],eax ; 解码后的代码存入esi指向的地方006AF154 83C3 05 add ebx,5006AF157 83C6 04 add esi,4006AF15A 83E9 05 sub ecx,5006AF15D ^ EB CE jmp short DrvStudy.006AF12D ; 向上跳可以判断出上面的这段代码是解码的, C30000处的代码会解码, 在006AF15D的下一个指令设好断点, F9运行, 断下006AF15F 5B pop ebx ; 断下, 解码完毕006AF160 5E pop esi006AF161 59 pop ecx006AF162 58 pop eax006AF163 EB 08 jmp short DrvStudy.006AF16D ; 跳006AF16D 8BC8 mov ecx,eax ; 来到这里006AF16F 8B3E mov edi,dword ptr ds:[esi] ; 代码段偏移006AF171 03BD 22040000 add edi,dword ptr ss:[ebp+422] ; 基地址+偏移, 指向代码段006AF177 8BB5 52010000 mov esi,dword ptr ss:[ebp+152] ; 解码后的正确代码地址006AF17D C1F9 02 sar ecx,2006AF180 F3:A5 rep movs dword ptr es:[edi],dword >; 填充正确的代码006AF182 8BC8 mov ecx,eax006AF184 83E1 03 and ecx,3006AF187 F3:A4 rep movs byte ptr es:[edi],byte pt>; 填充正确的代码006AF189 5E pop esi006AF18A 68 00800000 push 8000006AF18F 6A 00 push 0006AF191 FFB5 52010000 push dword ptr ss:[ebp+152]006AF197 FF95 51050000 call dword ptr ss:[ebp+551] ; VirtualFree006AF19D 83C6 08 add esi,8006AF1A0 833E 00 cmp dword ptr ds:[esi],0 ; 解码完成?没完成就跳006AF1A3 ^ 0F85 1EFFFFFF jnz DrvStudy.006AF0C7 ; 又跳到上面因此可以确定这一大段006AF0C7 - 006AF1A3都是解码的代码, 在006AF1A3处的下1条指令设置一个断点, F9运行, 断下006AF1A9 68 00800000 push 8000 ; 断下006AF1AE 6A 00 push 0006AF1B0 FFB5 56010000 push dword ptr ss:[ebp+156]006AF1B6 FF95 51050000 call dword ptr ss:[ebp+551] ; VirtualFree释放内存了006AF1BC 8B9D 31050000 mov ebx,dword ptr ss:[ebp+531] ; ebx=0006AF1C2 0BDB or ebx,ebx006AF1C4 74 08 je short DrvStudy.006AF1CE ; ebx==0,跳006AF1C6 8B03 mov eax,dword ptr ds:[ebx]006AF1C8 8785 35050000 xchg dword ptr ss:[ebp+535],eax 006AF1CE 8B95 22040000 mov edx,dword ptr ss:[ebp+422] ; 跳到这里, ebx=0x400000, 基地址006AF1D4 8B85 2D050000 mov eax,dword ptr ss:[ebp+52D] ; eax=0x400000006AF1DA 2BD0 sub edx,eax006AF1DC 74 79 je short DrvStudy.006AF257 ; ecx==0, 跳下面就是恢复IAT了006AF257 8B95 22040000 mov edx,dword ptr ss:[ebp+422] ; 跳到这里, edx=0x400000, 基地址006AF25D 8BB5 41050000 mov esi,dword ptr ss:[ebp+541] ; esi=0006AF263 0BF6 or esi,esi006AF265 74 11 je short DrvStudy.006AF278 ; esi==0, 跳006AF267 03F2 add esi,edx006AF269 AD lods dword ptr ds:[esi]006AF26A 0BC0 or eax,eax006AF26C 74 0A je short DrvStudy.006AF278006AF26E 03C2 add eax,edx006AF270 8BF8 mov edi,eax006AF272 66:AD lods word ptr ds:[esi]006AF274 66:AB stos word ptr es:[edi]006AF276 ^ EB F1 jmp short DrvStudy.006AF269006AF278 BE 00001E00 mov esi,1E0000 ; 跳到这里, esi=1e0000006AF27D 8B95 22040000 mov edx,dword ptr ss:[ebp+422] ; edx=基地址006AF283 03F2 add esi,edx ; esi=51e0000006AF285 8B46 0C mov eax,dword ptr ds:[esi+C] ; 指向下一个dll文件名的RVA006AF288 85C0 test eax,eax ; 不为空就不跳006AF28A 0F84 0A010000 je DrvStudy.006AF39A006AF290 03C2 add eax,edx ; 得到下一个dll文件名006AF292 8BD8 mov ebx,eax006AF294 50 push eax006AF295 FF95 4D0F0000 call dword ptr ss:[ebp+F4D] ; 取kernel32.dll的句柄006AF29B 85C0 test eax,eax ; 成功, 跳006AF29D 75 07 jnz short DrvStudy.006AF2A6006AF29F 53 push ebx006AF2A0 FF95 510F0000 call dword ptr ss:[ebp+F51]006AF2A6 8985 45050000 mov dword ptr ss:[ebp+545],eax ; 跳到这里, kernel32.dll句柄存入ebp+545006AF2AC C785 49050000 00000000 mov dword ptr ss:[ebp+549],0 ; [ebp+549]=0006AF2B6 8B95 22040000 mov edx,dword ptr ss:[ebp+422] ; edx=基地址006AF2BC 8B06 mov eax,dword ptr ds:[esi] ; eax=0006AF2BE 85C0 test eax,eax006AF2C0 75 03 jnz short DrvStudy.006AF2C5 ; eax==0, 不跳006AF2C2 8B46 10 mov eax,dword ptr ds:[esi+10] ; IAT的FirThunk基地址006AF2C5 03C2 add eax,edx006AF2C7 0385 49050000 add eax,dword ptr ss:[ebp+549] ; 指向下1个API006AF2CD 8B18 mov ebx,dword ptr ds:[eax]006AF2CF 8B7E 10 mov edi,dword ptr ds:[esi+10]006AF2D2 03FA add edi,edx006AF2D4 03BD 49050000 add edi,dword ptr ss:[ebp+549] 006AF2DA 85DB test ebx,ebx006AF2DC 0F84 A2000000 je DrvStudy.006AF384006AF2E2 F7C3 00000080 test ebx,80000000006AF2E8 75 04 jnz short DrvStudy.006AF2EE006AF2EA 03DA add ebx,edx006AF2EC 43 inc ebx ; 取函数名006AF2ED 43 inc ebx ; 取函数名006AF2EE 53 push ebx006AF2EF 81E3 FFFFFF7F and ebx,7FFFFFFF006AF2F5 53 push ebx ; 函数名入栈006AF2F6 FFB5 45050000 push dword ptr ss:[ebp+545] ;kernel32.dll句柄入栈006AF2FC FF95 490F0000 call dword ptr ss:[ebp+F49] ; GetProcAddress006AF302 85C0 test eax,eax006AF304 5B pop ebx006AF305 75 6F jnz short DrvStudy.006AF376 ; 跳取API函数地址成功后跳到下面的地方006AF376 8907 mov dword ptr ds:[edi],eax ; API地址存入edi 指向地址006AF378 8385 49050000 04 add dword ptr ss:[ebp+549],4 ; 取下一个API006AF37F ^ E9 32FFFFFF jmp DrvStudy.006AF2B6 ; 跳006AF384 8906 mov dword ptr ds:[esi],eax006AF386 8946 0C mov dword ptr ds:[esi+C],eax006AF389 8946 10 mov dword ptr ds:[esi+10],eax006AF38C 83C6 14 add esi,14006AF38F 8B95 22040000 mov edx,dword ptr ss:[ebp+422] 006AF395 ^ E9 EBFEFFFF jmp DrvStudy.006AF285 ; 跳去恢复下个导入dll中的函数这个大循环完成后IAT就恢复完成了...这个IAT是没有被破坏的, 根据一般经验, 壳在运行时都会有这么一个大循环来恢复IAT, 有的是破坏, 因此当在你一个循环中碰到GetModuleHandleA, LoadLibraryA, GetProcAddress, 时就要小心了, 记下它, 有可能ImportRec找不回API函数的时候, 需要手工修复IAT时就要用到它循环完后,来到这里006AF39A B8 08CF1C00 mov eax,1CCF08 ; OEP的RVA006AF39F 50 push eax006AF3A0 0385 22040000 add eax,dword ptr ss:[ebp+422] ; OEP值006AF3A6 59 pop ecx006AF3A7 0BC9 or ecx,ecx006AF3A9 8985 A8030000 mov dword ptr ss:[ebp+3A8],eax ; 修改[ebp+3A8]处的代码006AF3AF 61 popad006AF3B0 75 08 jnz short DrvStudy.006AF3BA ; 跳006AF3B2 B8 01000000 mov eax,1006AF3B7 C2 0C00 retn 0C006AF3BA 68 08CF5C00 push DrvStudy.005CCF08 ; 变形跳转006AF3BF C3 retn ; ^_^ 飞向光明之颠这里就是典型的Delphi程序的OEP处代码005CCF08 55 push ebp ; 停在这里005CCF09 8BEC mov ebp,esp005CCF0B 83C4 F0 add esp,-10005CCF0E 53 push ebx005CCF0F B8 80CA5C00 mov eax,DrvStudy.005CCA80005CCF14 E8 B3A7E3FF call DrvStudy.004076CC现在就可在005CCF08处Dump程序了, 用OD的OllyDump插件, Dump出程序, 启动ImportREC, 填入OEP的RVA值先点IATAutoSearch, 再点GetImport, 找到的API全部有效, 点Fix Dump, 修复IAT指针运行程序, 提示系统数据错误, 这是因为程序有自校验, 发现自己被脱壳后拒绝运行, 去除程序的自校验我就不说了...用爆破的方法就能搞定...【总结】本文讲述了脱壳的一般方法, 新手面对末知壳先不要怕, 自己试着跟踪分析一下, 多做练习才会有进步。
kkrunchy脱壳笔记
这里脱的是一个kkrunchy的壳：
首先把程序扔到OllyIce里面可以看到：
然后这里尝试使用ESP定理：即在ESP第一次改变时，对ESP的地址设置硬件双字访问断点，然后SHIFT+F9执行，程序停住后，重新分析该模块，然后单步向下看：
然后单步下去走，跳过一些向后的循环，或者往下拉一下，可以看到一个大跳的位置，即magic jump位置：
然后Ctrl+G查看00401700，发现代码还没有被写入：
所以删除其他断点，然后下硬件执行断点，再次SHIFT+F9，可以发现代码以及被恢复：
这时候用LoadPE dump程序，再用ImportREC修复dump程序的OEP，OEP 的信息通过OD自带的dump功能查询或者直接填11700，发现没有损坏的函数指针，直接修复dump文件即可：
然后可以得到脱壳后的dump程序：。
第17课 esp脱壳法
第17课esp脱壳法
〔例1〕脱壳UnPackMe_EZIP1.0.exe
载入后，按2次F8，看到esp变红，发生了变化，由12FFC4变为12FFC0，如图：
鼠标点住esp，在数据窗口跟随，如图：
在数据窗口中，点选两个数，鼠标右键下硬件访问断点→Word（或点选四个数，鼠标右键下硬件访问断点→Dword）：
点按钮运行程序，被断
命令行口输入hd，回车。
弹出“硬件断点”窗口，删除硬件断点
F8走一下，来到oep
用ollydump插件dump即可，注意不要勾选“重建输入表”。
如图：
与上一课的相对比，可以发现这种方法速度极快，可以秒杀。
〔例2〕脱壳crackme.UPX$hit-0.0.1.exe
载入后，按4下F8，向上跳，小循环，鼠标点住下一行按F4，如图：
继续几下F8，向上跳，小循环，鼠标点住下一行按F4，如图：
看到pushad，比较敏感，ESP的值变红，发生变化
鼠标点住esp，在数据窗口跟随，如图：
在数据窗口中，点选两个数，鼠标右键下硬件访问断点→Word（或点选四个数，鼠标右键下硬件访问断点→Dword）：
点按钮运行程序，被断
命令行口输入hd，回车。
弹出“硬件断点”窗口，删除硬件断点
F8走一下，来到oep
用ollydump插件用默认设置dump即可。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第17课esp脱壳法
〔例1〕脱壳UnPackMe_EZIP1.0.exe
载入后，按2次F8，看到esp变红，发生了变化，由12FFC4变为12FFC0，如图：
鼠标点住esp，在数据窗口跟随，如图：
在数据窗口中，点选两个数，鼠标右键下硬件访问断点→Word（或点选四个数，鼠标右键下硬件访问断点→Dword）：
点按钮运行程序，被断
命令行口输入hd，回车。
弹出“硬件断点”窗口，删除硬件断点
F8走一下，来到oep
用ollydump插件dump即可，注意不要勾选“重建输入表”。
如图：
与上一课的相对比，可以发现这种方法速度极快，可以秒杀。
〔例2〕脱壳crackme.UPX$hit-0.0.1.exe
载入后，按4下F8，向上跳，小循环，鼠标点住下一行按F4，如图：
继续几下F8，向上跳，小循环，鼠标点住下一行按F4，如图：
看到pushad，比较敏感，ESP的值变红，发生变化
鼠标点住esp，在数据窗口跟随，如图：
在数据窗口中，点选两个数，鼠标右键下硬件访问断点→Word（或点选四个数，鼠标右键下硬件访问断点→Dword）：
点按钮运行程序，被断
命令行口输入hd，回车。
弹出“硬件断点”窗口，删除硬件断点
F8走一下，来到oep
用ollydump插件用默认设置dump即可。