浅谈程序脱壳后的优化

作者：CCDebuger

写这篇文章的目的是想让大家了解如何利用现有的工具来优化脱壳后的程序。 因为要让脱壳优化过的程序可以用汉化工具正常汉化的话，要求要稍微高一些，我就基于优化后的文件可正常用汉化工具汉化这样的目标来讲解。这篇文章主要是为新手服务的，所以肯定比较罗唆，高手可以略过。
这篇文章中我采用 dwing 的 WinUpack 0.39 final 讲述。采用 WinUpack 来讲解的原因主要是这款壳把 PE 头搞得很让人郁闷，修复其它脱壳后的程序不需要修复 PE 文件头，而修复 WinUpack 却要考虑修复 PE 头的问题，而且这个壳加壳后把原程序的各个区段都合并了，修复的步骤要多一些，这样也方便大家了解的更详细一点。我准备分两部分来讲述，第一部分我采用 WinUpack 0.39 final 来给我自己用 MASM 写的一个示例程序加壳，然后来进行脱壳优化，第二部分直接讲解 WinUpack 0.39 final 中的那个中文版 WinUpackC.exe 的脱壳优化。其实本来直接写 WinUpackC.exe 的脱壳优化就可以了，不过我开始的时候没准备写 WinUpack 主程序的脱壳，写到后来才发现用自己写的示例程序加壳后再谈脱壳后的优化，有点自说自话的感觉，所以临时决定加一个 WinUpack 主程序的脱壳优化。因为文章已经写了一部分了，不想再重新抓图，就搞出两部分了（看见砖头、鸡蛋扔来，我躲！）。

一、示例程序的脱壳优化

1、脱壳

这里的目标程序是我用 MASM 写的一个对话框的简单例子，我采用 WinUpack 的默认选项把原程序 test.exe 加壳，加壳后的程序名为 test1.exe，大小由原来的 6.5K 变为 4.4K。因为 WinUpack 给程序加壳时修改了 PE 头的缘故，普通 OD 可能加载不了用 winUpack 加壳后的程序，所以我们换用看雪兄修改的 OllyICE 载入加壳后的 test1.exe，会出现一个“32 位可执行文件格式错误或未知”的错误对话框，不用管，点确定，又出现一个“无法在内存中分配 XXXXX 字节”的错误对话框，继续点确定，我们停在这里：

00401018 > BE B0114000 MOV ESI,test1.004011B0
0040101D AD LODS DWORD PTR DS:[ESI] ; ESI地址处的值就是OEP
0040101E 50 PUSH EAX

WinUpack 的壳比较好脱，F8 到上面的第二条指令时，ESI 所显示的值就是存放 OEP 的地址。我这里在信息窗口中看到的是以下内容：

DS:[ESI]=[004011B0]=00401000

现在我在反汇编窗口中按 CTR+G 直接来到地址 00401000 处，按 F4，就停在 OEP 处了：

00401000 6A 00 PUSH 0
00401002 E8 79010000 CALL test1.00401180 ; JMP 到 kernel32.GetModuleHandleA
00401007 A3 1C304000 MOV DWORD PTR DS:[40301C],EAX

现在我们用 LordPE 完全转存 test1.exe 的进程，另存为 dumped.exe，现在可以看到这个 dumped.exe 大小有 64K 了。不要关 OD，打开 ImportREC，选择进程 test1.exe，OEP 填入 1000，选“自动查找 IAT”，会有一个“发现一些信息”的对话框，点确定，再点“获取输入表”，现在我们就得到了完整的输入表了。我们先来保存一下树文件，另存为 test_tree.txt。不要关 OD 和 ImportREC，让它们都暂时开在那，先复制一份我们刚才用 LordPE 完全转存出来的 dumped.exe 备份。

2、根据对齐值分析区段中的内容

在开始之前，我们先了解一下对齐的一些概念：文件区块有两种对齐值，一种是磁盘文件中的，另一种是内存中的。PE文件被映射到内存时，区块总是至少以一个页边界为开始，在x86系统中，每个内存页的大小是4K，也就是0x1000字节，所以在x86系统中，PE文件区块的内存对齐值一般等于0x1000，每个区块按0x1000之倍数内存偏移位置开始。另一种是磁盘对齐值，这个实例磁盘对齐值是0x1000，每个区块按0x1000之倍数的文件偏移位置开始。有时为了使磁盘文件更小些，你可以用0x200对齐值。
有了上面的预备知识，我们现在用 LordPE 的 PE 编辑器打开 dumped.exe 来看看：



现在我们点击一下区段按钮，看看各个区段中有什么内容：



因为上面我们已经看到文件块对齐是 1000H，我们就按 1000H 大小的倍数来在16进制编辑器中选择块，分析数据中是否有区段。先在16进制编辑器中查看一下第一个区段：



上图的偏移 2000 是第二个区段开始的地方。有人可能要问你怎么知道这是原来的第二个区段开始处？呵呵，因为我前面看到文件对齐粒度为 1000，所以我在16进制编辑器中主要注意与 1000 的倍数对应的偏移地址。当我翻到偏移地址为 2000 时，在这个地址的上面是由一大片 0 填充的，到这个地址后又开始有数据了，所以我确定偏移 2000 处应该是另一个区段的开始处。如果你在16进制编辑器中看到一大片 0 后突然看见有数据，你再根据文件对齐粒度注意一下数据的开始地址，一般就可以确定是否已到另一个区段了。由16进制窗口中查看到的信息，我们可以确定 WinUpack 把我们原来的区段都合并了，现在我们要把它们分离出来。

3、分离区段

要说明一下，分离区段和下面的一节修正 PE 头在其他脱壳文件的优化中并不是必须的，这里主要针对 WinUpack 的壳。现在关掉 LordPE，用 WinHEX 打开 dumped.exe，ALT+G，填入偏移 1000，转到相应位置，在偏移 1000 处点右键，选择定义选块，输入相应数据后点确定：



在选好的选块上右键选择复制选块->进入新文件，另存为 text.bin：



其实这个偏移 1000H，长度 1000H 的段不保存也无所谓，这里主要是让大家熟悉一下保存的方法。同样，我们把起始偏移为 3000H，大小为 1000H 的那个段也另存为 data.bin。有人可能要问了，你为什么不把起始偏移为 2000H，大小为 1000H 的那个区段也保存下来？呵呵，因为我知道这里是原来的放输入表信息的那个段，现在已经被破坏了，我就不要了。同样，偏移 4000H 以后的段我也不保存了，那里是资源段，因为在修正过程中我可能要用另外的 RVA 地址来重建资源，所以不保存了。现在我们在 WinHEX 中再定义一个选块，从偏移 2000H 直到文件尾，选中后删除这个选块。

4.修正PE头

现在我们还要做一件事，因为 WinUpack 把 PE 头搞得太乱，我们要找个正常的替换一下。这里我选择 XP_SP2 下的记事本，用 WinHEX 打开记事本，从文件开始偏移为 0 的地方选择一个大小为 1000H 的选块，右键选择复制选块->以十六进制数值方式，现在转到我们正在 WinHEX 中编辑的 dumped.exe，定位到文件开始偏移处，右键选择剪贴板数据->写入(从当前位置覆写)，把记事本的文件头粘贴过来。



完成上述工作后保存 dumped.exe，现在文件大小变成 8K 了，用 PETools 的 PE 编辑器来打开这个文件，进行一些修改。先点击文件头按钮：



把区段数由 3 改成 1 后确定，再点击可选头按钮：



改一下上面的镜像基址为 00400000，点击确定。这里可以参考原来备份的 dumped.exe 文件来修改（我前面已经说过要备份原来的那个 dumped.exe 文件用作参考，你不会没备份吧？）。

5、修正及添加区段

现在点击区段按钮，修改一下区段的一些属性。因为前面我们已经把区段改为 1 了，现在打开区段后，只看到一个 .text 区段。在这个区段上右击，选择编辑区段头：



因为我们现在的 .text 段是从偏移 1000H 开始的，大小为 1000H，所以我们要把上面的虚拟偏移和 RAW 偏移都改成 1000，虚拟大小和 RAW 大小也要改成 1000。在弹出的对话框上进行设置：



完成上述修改后点确定，回到区段编辑器中，现在我们要添加一个大小为 1000H 的段，用来存放输入表。这里可能大家也有疑问：你是知道原来的输入表段大小为 1000H，如果你不知道呢？你知道要添加多大的一个区段？其实我这里添加区段的大小是根据 ImportREC 的新建输入表信息中的大小来的：



我们可以在 ImportREC 中看到新建输入表的大小是 18CH，根据区段的对齐粒度 1000H，我这里就选大小为 1000H，已经够用了。这里要留一点余量，有时脱一些壳修复时，余量留的过小则修复的输入表不完全，这时可以从文件中删除这个区段，再按 1000H 的对齐粒度新建一个大一点的区段，重新修复输入表。现在继续我们前面的话题，在区段编辑器中右键点击，选择添加区段菜单项，在弹出的对话框上进行设置：



上面我打了红框的是要修改的地方。PETools 默认添加区段的名称是 .NewSH，为了便于识别这个段是用于存放输入表信息的，我们把名称选为 idata。其他的 RAW 数据及虚拟数据大小我们都填 1000，选择用 0x00 填充区段，现在点确定，一个新区段就添加进来了：



从上图中我们可以看出 .idata 段的虚拟偏移是 13000，这肯定不正确，我们应该保证各个段的虚拟地址都是连续的。以上图为例，.text 段的虚拟偏移是 1000H，虚拟大小是 1000H，这样虚拟偏移 ＋ 虚拟大小 ＝ 1000H ＋ 1000H ＝ 2000H，可知下一个区段的虚拟偏移应该是 2000H。同样道理 RAW 偏移也应该是连续的，虽然有时候我们看到有类似这样的：第一个区段：RAW 偏移：400H，RAW 大小：1D0；第二个区段：RAW 偏移：600H，RAW 大小：1B8，这样看起来好像并不连续啊。因为 400 ＋ 1D0 ＝ 5D0，下一个区段应该从 5D0 开始才对。但如果你用16进制工具打开文件看一下就知道了。这种情况是文件粒度按 200H 对齐，区段中的实际数据没有 200，这里显示的只是实际的数据大小，剩下的按 200H 对齐的部分用 0x00 填充了。所以下一个区段还是按文件对齐粒度设置偏移的。同样，文件对齐粒度是其他数值时也存在这种情况。说了这么多，大家应该也明白了，编辑一下 .idata 的区段头，把虚拟偏移 13000 改成 2000。至于后面那个特征值为什么可以改成 C0000040，我就不多说了，在编辑区段的时候点一下特征值后面那个 ... 按钮，上面应该可以看到详细的说明。

6、修正输入表

现在我们的前期工作暂告一个段落，保存好我们的修改退出 PETools，现在轮到 ImportREC 上场了。你的 ImportREC 应该没关吧？我们把添加一个新的节前面的勾去掉，在新建输入表信息中 RVA 填 00002000（就是我们新建的那个 ,idata 段的偏移地址），点击修复转存文件，选择我们刚才修改的 dumped.exe 进行修复，得到 dumped_.exe。

7、修正资源

到这还有两个重要的事别忘了，一个是我们保存的那个数据段（data.bin）要放进程序里来，还有个就是资源还没有。现在我们先把资源弄出来。拿出 dREAMtHEATER 兄的 FixRes，选择我们原来备份的那个 dumped.exe，使用 FixRes 的 Dump 功能，把资源段按我们定义的 RVA Dump 出来：



因为前面还有一个数据段 RVA 是 3000，大小是 1000，所以我们把新建资源段的 RVA 设为 4000。按上面那样设置好后我们就可以点击 Dump Resource 按钮来 Dump 资源了，文件被保存为 rsrc.bin。

8、装配文件

现在进入最后的装配工作了，用 LordPE 的 PE 编辑器打开 dumped_.exe，点击区段按钮，进入区段编辑功能中：



现在我们要把磁盘上的 data.bin 和 rsrc.bin 都添加到程序中来，右键选择从磁盘载入段，按顺序添加 data.bin 和 rsrc.bin，添加好后改一下区段名和标志，最终效果如下：



现在退出区段编辑，点目录按钮，修正一下资源及其他的目录。在这个程序中输入表目录已经不需要我们再改了，我们要改的就是资源目录的 RVA 及大小，把其他没用到的目录 RVA 和 大小清零。我们再用一个 LordPE 的 PE 编辑器打开备份的 dumped.exe 文件来做参考，最终修正效果如下：



9、修正可选头及最终优化

保存以上工作后关掉 LordPE，我们可以看到 dumped_.exe 的图标已经出来了，说明资源已经修复。现在再用 PETools 的 PE 编辑器打开 dumped_.exe（这里换 PETools 的原因是因为 PETools 编辑 PE 头的功能比较强），点击可选头按钮，进入可选头编辑器。现在主要要修改的就是代码基址和数据基址，代码基址一般就是第一个区段（我们这里是 .text 段）的 RVA，所以这里应该填 1000，数据基址一般指除了代码外的部分开始的 RVA，我们这里代码部分 RVA 是 1000，大小是 1000，加起来就知道除了代码外的数据 RVA 是 2000，就是我们第二个段 .idata 的 RVA。修改完这些内容后最后要纠正一下镜像大小，否则程序还是不能运行。最终修改效果如下：



上图中的代码大小和已初始化数据大小改不改都无所谓，我是为了好看点把它改了。一般的代码大小就是指 .text 段的大小，.text 段后面所有段的大小加起来就可以作为已初始化数据大小。全部改完后点镜像大小后面的那个“?”按钮，纠正一下镜像大小，现在就可以保存退出 PETools 了。
到这基本工作已经完成了，修复后的 dumped_.exe 大小为 20K，运行一下，一切正常。不过这里的 20K 大小还和我们原来的 6.5K 有差距，如果手工修改的话我们可以先把文件对齐的粒度设为 200，再用16进制工具打开程序，把按照 200H 倍数对齐的各个区段的多余的全是 0 的部分删掉，再根据保留下来的部分调整一下区段的 RAW 偏移和大小。当然你可以用 PETools 或 LordPE 的重建功能来重建一下程序，也会完成上述功能。不过我们这里是希望能用汉化工具正常汉化的，所以我们不能用 PETools 或 LordPE 的重建功能来重建程序， 因为它们重建的程序虽然可以正常使用，也比较小，但若用来汉化是很容易出错的。这里还是不要手工来调整了，我们直接用一下 PE Optimizer 这个工具来优化程序一下，这个工具优化出来的程序基本上和手工修改的差不多。优化后我们再看一下大小：20K->6.5K，呵呵，和我们原来的程序一样大。

二、 WinUpack 主程序的脱壳及优化

如果文章写到这里收工的话，估计会有人说你自己编个程序，再加个壳来谈脱壳后的优化，你完全可以对照原程序来进行啊。OK，那我们就来个没有对照的，冒着被 dwing 狂扁的危险，我就拿 WinUpack 0.39 final 中的那个中文版 WinUpackC.exe 来开刀。不过 dwing 要来了，大家要掩护我逃跑啊，呵呵。
WinUpackC.exe 脱壳我就不多说了，OEP 是 0040A4BE，直接在 OD 中 CTR+G 转到地址 0040A4BE，F4 运行到这，就可以用 LordPE 完全转存了。我们还是把转存后的文件保存为 dumped.exe。现在不要关 OD，在 ImportREC 中选择 WinUpackC.exe 的进程，输入 OEP：A4BE，选自动查找 IAT，可以得到正确的输入表，大小是 00000B18。保存一下树文件备用。让 OD 和 ImportREC 都开在那，现在我们用 LordPE 的16进制编辑区段功能来观察一下第一个区段中的内容。具体怎么分析原来区段的起始地址我前面已经说过了，此处只谈结果。经分析可知偏移 1000-AFFF应该是代码段，大小为 A000；B000-DFFF 应该是数据段，E000-FFFF 应该是另一个段；功能我不是很清楚 ，可能原来也用于存放输入表信息的。我就把它和前面的 B000-DFFF 一起当成数据段，这样数据段就大小就是10000 － B000 ＝ 5000；10000-11FFF 应该是资源段；12000-12FFF 包含了部分输入表的信息，应该是加壳后搞出来的。不过这个段对我们毫无作用，不作考虑。现在对我们有用的就是偏移 1000-FFFF 的部分，这里有两个区段。根据 ImportREC 中所显示的输入表大小 00000B18 及前面两个段用到的偏移，我们只要在偏移 10000 处添加一个大小为 1000 的段用来存放输入表信息就可以了。因此资源段我们应该让它从 11000 开始。分析完了就可以开工了，先把 dumped.exe 复制一份留作参考，WinHEX 上场，ALT+G 转到偏移 10000 处，从此处开始选择一个直到文件结尾的块，删除。我们还是借用一下 XP_SP2 记事本的文件头，把记事本偏移 0-FFF，大小为 1000 的内容复制过来，覆盖到 dumped.exe 的对应位置。全部完成后保存 dumped.exe。现在由 PETools 上场，用其 PE 编辑器打开 dumped.exe，先把区段数改为 2，再修正一下镜像基址为 00400000，然后转到区段编辑器，根据我们上面分析的两个区段的偏移及大小调整区段的虚拟偏移、大小；RAW 偏移、大小。完成后再新建一个区段用来保存输入表信息，偏移是 10000，大小为 1000，再修改一下特征值，全部完成后效果如图：



现在关掉 PETools，我们开始用 ImportREC 来修正输入表。去掉添加一个新的节前面的勾，在新建输入表信息中填入 RVA：00010000，点修复转存文件，选择我们修改过的 dumped.exe 来修复，完成后我们得到 dumped_.exe。到这就要开始把资源加进去了。 FixRes 上，选我们原来备份的那个 dumped.exe，新建 RVA 为 11000，文件对齐为 200，Dump 资源为 rsrc.bin：



再让 LordPE 上场吧（有人要说了，这么多工具换来换去你也不嫌累？这个...是比较累，本来是打算自己写一个工具来减小工作量的。不过因为太懒，能将就就将就了）。用 LordPE 打开修正过输入表的那个 dumped_.exe，点区段按钮，在区段编辑窗口中右键选择从磁盘载入段，把我们前面 Dump 的那个 rsrc.bin 添加进来。编辑一下区段，最终效果如下：



现在关掉区段编辑，点击目录按钮，再用 LordPE 打开备份的 dumped.exe 进行参考，我们来编辑一下 dumped_.exe 的目录，主要是调整一下资源目录的 RVA 和大小，把其他一些没用到的目录 RVA 和 大小清零。最终效果如下：



完成后退出 LordPE，再用 PETools 打开 dumped_.exe，编辑可选头中的一些内容及调整镜像大小，完成后效果如下：



保存我们所做的工作，退出 PETools，现在 dumped_.exe 文件大小是 72.5K。运行一下 dumped_.exe，呵呵，正常运行了。把 dumped_.exe 复制一份保存为复件 dumped_.exe，用 dumped_.exe 给复件 dumped_.exe 用默认选项加个壳看看， 72.5K->27.3K，原版未脱壳前是 26.6K，看来还是有差距啊。不管了，用 PE Optimizer 来优化一下 dumped_.exe，72.5K->59.5K，收工。
WinUpack 加壳时合并了区段，而一些其他的壳给程序加壳时并没有合并区段，也没有破坏 PE 头，这样脱壳后的程序优化起来要简单一点，可以省掉前面的到脱壳后的第一个段中判断区段及修正 PE 头的步骤，只要把有用的段给保存下来，没用的去掉，选好位置重建输入表和资源，再装配起来就可以了。要想优化后的程序可以用汉化工具汉化的话，一般都要把资源放在最后一个区段，否则容易出错。而对应 DLL 这样的文件修复时要考虑重定位和输出表，重定位可以采用 ReloX 来修复，同样可以指定位置重建。输出表可以采用看雪兄的工具 PeMove 来挪移，同样这个工具也可以挪移重定位表。关于 DLL 这类文件的脱壳后优化我就不讲了，基本方法类似。

羔羊带你走出迷茫，0蛋也能学破解！ ZZ

转自沉默的羔羊

本帖就是解决新手的疑问，让你走出迷茫，让你知道如何学破解。0基础一样能学的很好。

大牛=10%天分+40%耐心（这是帖子写完成后加的一句，其实你能认真看完这帖子你就够有耐心了）+50%的长期努力。

最近还是看到很多新朋友在问。
1、“新手怎么学破解啊？”（这是标准的伸手党，baidu google其实很好用）
2、“哎呀XX大牛，我什么基础都没有啊我不会汇编，不会C更不会C++还不会…………总之高手会的我都不会，我能学么？”（明确的告诉你，你能！你不和唐僧一样罗嗦的话你一定能。）
3、某白发帖问曰：“XX大牛，这软件你能帮我看看吗？我尝试了N天还是没有搞定，这是软件地www.XXX.com/XXX/XXX.rar 搞定了发到我邮箱里吧，我邮箱是XXXXX@XX.COM。”
结果嘛，我想大家猜的到。不过这牛人次日在投诉区发帖曰：‘这是什么XX斑竹啊，我只是想问问这个软破解的思路。干嘛随便删我帖子还给我扣分！这是什么XX论坛，什么XX斑竹。‘

其实嘛，所有的技术都是从基础开始的，不要去妄想那空中的楼阁，也不要想速成。

在这明确的告诉大家，其实大牛们最讨厌的就是问这些本不该问的问题的人。
因为这些人根本就没有认清现实，没有看到成功背后的一些东西。他们只看到了10%+40%，认为自己也可以凭借这些做到。
偷偷暴下料。其实在去年的时候，小生同鞋，逆流师傅等现在的大牛还都是些小菜哦，现在呢？ 嘿嘿~~


好了，上面叽咕了这么多。也算是考验下大家的耐心吧。嘿嘿。

其实学习的首要条件是兴趣！！兴趣越大你的投入就更多。

我相信下面这个教程足够调起你的兴趣了，看完后你会发现，原来破解其实并没有那么难。

一、 准备好常用破解工具，
1、 查壳工具：PEiD 0.95
2、 脱壳调试：OllyICE　v1.10（俗称OD，可下载一些OD插件保存在程序文件目录下的plugin文件夹中，启动OD时会自动链接插件）
3、 Win32反汇编：WinHex　14.2　（本帖暂用不着）
4、 修复工具：ImportREC V1.6　　（本帖暂用不着）
5、 注册机编写：keymake
够了，初学不宜太多。新手所有的工具在小生工具包里都有（赞下小生同鞋的无私奉献）
二、 壳的概念：关于壳的介绍文章很多，很多初学者还不知道壳是什么，那么你就暂且这样通俗的去理解：壳就是软件的包装外壳。
三、 脱壳：顾名思义，我就不多说了。
四、 调试：用OD调试程序的进程，寻找关键（算法）CALL，修改有关汇编语言达到软件注册或破解的目的。
五、 有人问：我不懂汇编语言和算法怎么办？我告诉你，没关系，首先你必须从简单的、好欺负的软件入手（初学者千万别找年轻的、经常更新的或高版本的软件），否则，你只会以失败而告终。
六、 如果你是第一次学破解，我告诉你一个方法，只要你按如下操作一般都能成功（有的新版本软件除外）：
1、 首先注册软件，查看软件弹出的有关注册失败的信息框的内容。
2、 查壳：有壳脱壳，无壳用OD载入。
3、 手动脱壳基本方法：从OD载入软件程序后弹出是否分析对话框，点“否”，停在程序壳的入口（含有pushad等类似字符）。接下来我们的目的是要寻找第一个popad 。
（1） 首先按F8，接下来或近处便是CALL，此时的CALL或是离这里很近的CALL必须按F7，否则你就掉入陷井，后面遇到CALL一旦掉入也没关系，你先记下来，重新载入程序（按CTRL+F2），再遇到这个时就用F7进入。
（2） 出现往回跳转时，即红色线显示跳转实现，必须在下一行点左鍵，然后按F4步过，灰色为跳转未实现，可不理它照样F8。
（3） 其他全部F8，一路下去必定能找到第一个popad，找到后离此不远必定有一个大的跳转，一旦跳转来到有push ebp字样，说明壳己走完到主程序（OEP），在此用OD插件→ollyDump→Dump debu…→Dump脱壳→保存。
4、 破解：OD载入程序、点文件→打开→点击要破解的软件程序（无壳或己脱壳的）。
5、 鼠标置左上（反汇编）窗口点右鍵，弹出框选项中选择ultra string reference（过激的字符串参考）中的Find 　ASCII。
6、 在弹出的窗口内查找第一步骤的注册信息内容或有关注册成功和注册失败的字符。如果找不到，建议你放弃，另选其他软件，最好是年纪大些的（一般在2005年及以前的）。
7、 找到有关字符后，双击它，回到OD主窗口，在反汇编窗口（左上）中可以看到有关字符，然后就在字符上下附近寻找关键跳转（即跳向注册失败或注册成功处），在该跳转近处必定有一个就是关键CALL。
8、 如果用爆破，就修改关键跳转（jnz改为jz，jz改为jnz等）。
9、 如果是追注册码就在关键CALL这行下断点（按F2或双击鼠标），然后按F9运行后，会弹出软件注册对话框，随意输入注册信息后确定，这时注意观察右上的寄存器窗口会显示出你输入的假码和软件的真码，真码可以注册，而这个CALL可以用来做注册机。
下面，我给大家找来一个简单的软件演示一下实例：
【软件名称】现代汉语词典
【注册方式】确认码+注册码
【破解工具】PEiD 0.95　　　OllyICE　v1.10　　keymake
1、 查壳为ASPack 2.12 -> Alexey Solodovnikov　　见下图


2、 下面开始脱壳，首先用OD载入软件，分析项点“否”。


3、接下来第一步按F8、第2步F7（这里的CALL离入口很近哦）、第3步F8……以下按图中的注释操作，未注释用F7或F4的则，全部用F8。

中间省略…　…一路F8来到这里后，按图注释走，注释栏未注明全部F8


中间省略…　…一路F8来到这里后，按图注释走，注释栏未注明全部F8


中间省略…　…一路F8来到这里后，按图注释走，注释栏未注明全部F8


从上面程序返回直接跳到这里，这就是典型的OEP入口了。


4、用OD插件直接Dump，如下图


5、在弹出对话框中点Dump后命名文件、保存。


生成的文件便是已经脱壳的程序文件了。
接下来可以开始破解了：
1、用OD载入己脱壳的程序文件，程序停在OEP入口（注意看，这里己不是壳的入口了）。鼠标置反汇编窗口中点右鍵，在弹出对话框中按下图选择。


2、双击如图注册失败….字符


3、双击后回到OD主窗口，可以看到注册失败由上方跳转而来，我们顺着红线向上找关键跳转及关键CALL。


4、 找到这里，0051B153跳向注册失败，必是关键跳转了，它上面的CALL一般都是关键CALL（因为是初学我们暂不进入跟踪算法）。
我在此介绍三种简单的破解方式，具体看以下内容及参考图注释操作。
（1） 爆破：在关键跳转处的jnz改为jz或点右鍵→二进制→用nop填充。
（2） 追注册码：在关键CALL处下断点，然后F9运行。
（3） 注册机：利用上面的操作及参考寄存器窗口内容，用keymake（注册机编写器）制作。


（1）爆破：Nop填充图


5、 关键跳转修改后，点右鍵→复制到可执行文件→所有修改→（弹出对话框）点全部复制。


6、在新弹出窗口点右鍵，选择保存文件即可，至此爆破完成，运行软件即可注册成功。


（2）追注册码：
1、 我们在关键CALL处下断点F9运行程序弹出软件，选择注册项并输入注册信息，点确认注册。


2、查看寄存器窗口，这里显示软件的真假码。KKK为我这里输入的码假，在第三行EDX处显示的为真码（注意：这里的真码与输入的确认码对应）。另须说明：当点确认注册后，OD会陆续弹出几个出错的对话框（说明软件有调用函数，既是初学，这里暂不去深究），可以直接点“否”，打开软件输入对应确认码和真码即可注册成功。


（3）注册机制作：这里就不赘述了，看看新手问题1你一定能得到答案。

还有在这里强调下，你真是0蛋的话就必须从简单的、好欺负的软件入手（初学者千万别找年轻的、经常更新的或高版本的软件），否则，你只会以失败而告终。

看完这个教程你如果有兴趣了的话那么你可以去下载小生工具包，在里面有个小生做的记事本，里面有记录天草和黑鹰的新手教程。都是简单易懂的。

学习了基础后你就可以开始你的破解之路了。觉得自己能搞定一般软件了的话，还可以跟随52的练习一起来学习。多挖挖以前的尸贴。

说句心里话，羔羊现在从商了，没时间认真学习。真是好后悔当初没有好好学习。弄的现在一个标准的半吊子，呵呵。52是个有爱心，有上进心，有关心，有热心的大家庭。
在这里你付出的多，得到的就能更多！！！

菜鸟学脱壳基础聚集点（我的葵花宝典） ZZ

个人菜鸟的总结，高手飘过

脱壳总结________________________________________________________________________________________________
一基础、
1、PE文件:
Microsoft设计了一种新的文件格式Portable Executable File Format(可移植的执行体即PE格式)，该格式应用于所有基于Win32的系统：Windows NT、Windows 2000、Win32s及Windows 95/98。

2、基址（ImageBase ）:
是指装入到内存中的EXE或DLL程序的开始地址，它是Win32中的一个重要概念。 在Windows NT中，缺省的值是10000h;对于DLLs，缺省值为400000h。在Windows 95中，10000h不能用来装入32位的执行文件，因为该地址处于所有进程共享的线性地址区d3f2，因此Microsoft将Win32可执行文件的缺省基地址改变为400000h。

3、RVA:
相对虚拟地址（Relative Virual Address），是某个项相对于文件映象地址的偏移。
例如：装载程序将一个文件装入到虚拟地址空间中，从
10000h开始的内存中，如果PE中某个表在映像中的起始地址是10464h,那么该表的RVA就是464h。
d0e9拟地址(RVA)a3bdc6abd2c6地址a3ab基址（ImageBase )

4、Entry Point:
入口点，就是程序在完成了对原程序的还原后，开始跳转到刚还原程序执行，此时的地址就是入口点的值

5、SEH技术:
　　结构化异常处理（StructuredExceptionHandling，SEH）是Windows操作系统处理程序错误或异常的技术。SEH是Windows操作系统的一种系统机制，与特定的程序设计语言无关。外壳程序里大量地使用了SEH，如果不了解SEH，将会使你跟踪十分困难。由于Ollydbg　对SEH处理异常灵活，因此脱壳用Ollydbg会大大提高效率。

6、给自己穿件衣服……壳?:
所谓加壳，是一种通过一系列数学运算，将可执行程序文件或动态链接库文件的编码进行改变（目前还有一些加壳软件可以压缩、加密驱动程序），以达到缩小文件体积或加密程序编码的目的。
　　当被加壳的程序运行时，外壳程序先被执行，然后由这个外壳程序负责将用户原有的程序在内存中解压缩，并把控制权交还给脱壳后的真正程序，这就是我们找OEP的原因了。一切操作自动完成，用户不知道也无需知道壳程序是如何运行的。一般情况下，加壳程序和未加壳程序的运行结果是一样的。由于这段程序和自然界的壳在功能上有很多相同的地方，基于命名的规则，就把这样的程序称为“壳”了。
（PS：壳是指在一个程序的外面加上另外一段代码，保护里面的代码不被非法修改或者反编译。）

7、查壳:
原理是利用查特征串搜索来完成识别工作的。各种开发语言都有固定的启动代码部分，利用这点就可识别出是何种语言编编译的。同样，不同的壳也有其特征码，利用这点就可识别是被何种壳所加密。PEiD提供了一个扩展接口文件userdb.txt，用户可以自定义一些特征码，这样就可识别出新的文件类型，当然有些外壳程序为了欺骗PEiD等文件识别软件，会伪造启动代码部分，例如将入口代码改成编程语言程序入口处类似代码，即可达到欺骗目的。所以，文件识别工具所给出的结果只是个参考，文件是否被加壳处理过，还得跟踪分析程序代码才可得知。对于菜鸟我们可以看EP区段或者看PEID的扩展信息看有没有壳~。
(PS:查壳和木马病毒查杀差不多|其实是十万八千里|)

8、没有绝对的安全……脱壳:
脱壳主要有两种方法：硬脱壳和动态脱壳。
第一种，是硬脱壳，这是指找出加壳软件的加壳算法，写出逆向算法，就像压缩和解压缩一样。由于现在的壳有加密、变形、虚拟环境等等特点，每次加壳生成的代码都不一样。硬脱壳对此无能为力，
第二种，是动态脱壳。加壳的程序运行时必须还原成原始形态，就是加壳程序运行后必须进行解压到程序的文件头。所以我们可以用OD跟踪到OEP的原因。这个时候我们就可以抓取（Dump）内存中的镜像，再重构成标准的执行文件。这样我们就脱壳了。
(PS:现在的加密壳更复杂一点，需要我们考虑的东西就更多了。)

二经验、
外壳初始化的现场环境（各寄存器值）与原程序的现场环境是相同的。加壳程序初始化时保存各寄存器的值，外壳执行完毕，会恢复各寄存器内容。其代码形式一般如下：
PUSHFD　　　　;将标志寄存器入栈保存　　
PUSHAD　　　　;pusheax,ecx,edx,ebx,esp,ebp,esi,edi

　　 ……　　　　　;外壳代码部分
　　
POPAD　　　　　;popedi,esi,ebp,esp,ebx,edx,ecx,eax　
POPFD　　　　　;恢复标志寄存器
　　
JMPOEP　　　　; 跨段转移指令到OEP

OEP:……　　　　　;解压后的程序原代码

（PS:建议大家学一点PE结构知识）

1、常见脱壳知识：
pushfd╲
（入栈）代表程序的入口点的数据
pushad╱

popad╲
（出栈）代表程序的出口点的数据或者是PUSH PUSHAD这样
popfd╱

或者
PUSHAD （压栈） 代表程序入口点

POPAD （出栈） 代表程序出口点

出现出栈后一般经过RETN或者JMP等指令，发生跨断跳跃一般就到了OEP了(*^__^*) 嘻嘻……

2、找OEP:
程序的入口点，软件加壳就是隐藏了OEP（或者用了假的OEP），只要我们找到程序真正的OEP，就可以立刻脱壳。当然也有其他的，如 je OEP等等，一般都是段之间的大跳转，OD的反汇编窗口里都是同一个段的内容，所以更好区别是否是段间跳转。 找OEP时注意两点。
1单步往前走，不要回头。
2观察。注意poshad、poshfd,popad、popfd等，和外壳代码处对应，注意地址发生大的变化。单步跟踪什 么时候F8走，F7,F4步过？这里我说说关于F8(Step Over)和F7(Step in)的一般方法，粗跟的时候一般都是常用F8走，但是有些call是变形的Jmp，此时就需要F7代过，区别是否是变形Jmp的一个简单方法是比较call的目标地址和当前地址，如果两者离的很近，一般就是变形Jmp了，用F7走。对于Call的距离很远，可以放心用F8步过，如果你再用F7步过，只是浪费时间而已。F8步过对压缩壳用的很多，F7步过加密壳用的很多，如果用F8一不小心就跑飞（程序运行），跟踪失败。
(PS:OEP是OriginalEntryPoint缩写，即程序加壳前的真正的入口点)

3、加密壳VS压缩壳:
加壳软件按照其加壳目的和作用，可分为两类：
1、是压缩（Packers）;
2、是保护（Protectors）;
压缩这类壳主要目的是减小程序体积，如ASPacK、UPX和PECompact等。另一类是保护程序，用上了各种反跟踪技术保护程序不被调试、脱壳等，其加壳后的体积大小不是其考虑的主要因素，如ASProtect、Armadillo、EXECryptor等。随着加壳技术的发展，这两类软件之间的界线越来越模糊，很多加壳软件除具有较强的压缩性能，同时也有了较强的保护性能。
如何分辨加密壳压缩缩壳，通用特点，Od载入时有入口警告或询问是压缩程序吗？普通压缩壳Od调试时候没有异常加密壳全部有反跟踪代码，会有许多SEH陷阱使OD调试时产生异常。所以调试的时候需要注意！

4、加密壳找OEP
对于加密壳，我的方法一般是用最后一次异常法~
OD载入，钩掉所有异常（不忽略任何异常，除了忽略在KERNEL32 中的内存访问异常打勾。有时由于异常过多可以适当忽略一些异常），运行，数着用了多少次Shift+F9程序运行，显然最后一次异常后，程序会从壳跳到OEP开始执行，这就是我们寻找OEP的一个关键，如果程序Shift+F9后直接退出，很明显加密壳检测调试器，最简单的应付方法就是用插件隐藏。
单步异常是防止我们一步步跟踪程序，即F8,F7，F4等，Int3中断是检测调试器用的，仅在Win9x系统中有效，2000/XP就会出现断点异常,其它的异常主要是干扰调试。这一系列的异常虽然干扰我们调试，但也给我们指明了一条通路，就是Shift+F9略过所有异常，然后找到最后一处异常，再它的恢复异常处下断点，跟踪到脱壳入口点。确定从所有SEH异常中走出来，如果前面有大量循环，逐段解压。
当然你也可以用另一个好东西--Trace,在Command里来个tc eip<42b000 style="word-wrap: break-word; line-height: normal; ">


三方法、
一般的压缩壳，如Aspack等都有专用的脱壳机　。而加密壳（如ASProtect,Armadillo）一般很少有脱壳机，必须手工脱壳。手工脱壳一般情况是分三步：
一是查找程序的真正入口点（OEP）；
二是抓取内存映像文件；
三是输入表重建。（当然现在的加密壳复杂些，要考虑更多的东西）


常见的脱壳七方法(天草)
方法1：单步跟踪法

1.用OD载入，点"不分析代码！"
2.单步向下跟踪F8，实现向下的跳。也就是说向上的跳不让其实现！（通过F4）
3.遇到程序往回跳的（包括循环），我们在下一句代码处按F4（或者右健单击代码，选择断点-->运行到所选）
4.绿色线条表示跳转没实现，不用理会，红色线条表示跳转已经实现！
5.如果刚载入程序，在附近就有一个CALL的，我们就F7跟进去，不然程序很容易跑飞，这样很快就能到程序的OEP
6.在跟踪的时候，如果运行到某个CALL程序就运行的，就在这个CALL中F7进入
7.一般有很大的跳转（大跨段），比如 jmp XXXXXX 或者 JE XXXXXX 或者有RETN的一般很快就会到程序的OEP。

Btw:在有些壳无法向下跟踪的时候，我们可以在附近找到没有实现的大跳转，右键-->"跟随",然后F2下断，Shift+F9运行停在"跟随"的位置，再取消断点，继续F8单步跟踪。一般情况下可以轻松到达OEP！

方法2：ESP定律法

ESP定理脱壳（ESP在OD的寄存器中，我们只要在命令行下ESP的硬件访问断点，就会一下来到程序的OEP了！）
1.开始就点F8，注意观察OD右上角的寄存器中ESP有没突现（变成红色）。（这只是一般情况下，更确切的说我们选择的ESP值是关键句之后的第一个ESP值）
2.在命令行下：dd XXXXXXXX(指在当前代码中的ESP地址，或者是hr XXXXXXXX)，按回车！
3.选中下断的地址，断点--->硬件访--->WORD断点。
4.按一下F9运行程序，直接来到了跳转处，按下F8，到达程序OEP。

方法3：内存镜像法

1：用OD打开软件！
2：点击选项--调试选项--异常，把里面的忽略全部√上！CTRL+F2重载下程序！
3：按ALT+M,打开内存镜象，找到程序的第一个.rsrc.按F2下断点，然后按SHIFT+F9运行到断点，接着再按ALT+M,打开内存镜象，找到程序的第一个.rsrc.上面的.CODE（也就是00401000处），按F2下断点！然后按SHIFT+F9（或者是在没异常情况下按F9），直接到达程序OEP！


方法4：一步到达OEP

1.开始按Ctrl+F,输入：popad（只适合少数壳，包括UPX，ASPACK壳），然后按下F2，F9运行到此处
2.来到大跳转处，点下F8，到达OEP！

方法5：最后一次异常法

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！

方法6：模拟跟踪法
1：先试运行，跟踪一下程序，看有没有SEH暗桩之类（运行出现错误就是有SEH暗桩）
2：ALT+M打开内存镜像，找到（包含=SFX,imports,relocations）

内存镜像，项目 30
地址= 0054B000
大小=00002000 (8192.)
Owner=check 00400000
区段=.aspack
包含=SFX,imports,relocations
类d0cd=Imag 01001002
访问=R
初始访问=RWE
3：地址为0054B000，如是我们在命令行输入tc eip<0054b000,回车，正在跟踪ing。。
Btw:大家在使用这个方法的时候，要理解他是要在怎么样的情况下才可以使用

方法7："SFX"法

1：设置OD，忽略所有异常，也就是说异常选项卡里面都打上勾
2：切换到SFX选项卡，选择"字节模式跟踪实际入口（速度非常慢）"，确定。
3：重载程序（如果跳出是否"压缩代码？"选择"否"，OD直接到达OEP）

Btw:这种方法不要滥用得好，锻炼能力为妙。


去自校验_________________________________________________________________________________________________

————————
PS:忘记是哪位大牛的东西了O(∩_∩)O~
————————
去自校验法
校验一般类型：多为比较文件大小，可将程序用十六进制编辑工具未脱壳得原程序加大体积会不会不能运行，或者将脱壳了的程序重新加个壳看能不能运行。还有比较程序名字的也常见（不过这个没有强度可以忽略）。
去校验一般方法：下好相应的断点，然后开两个od比较调试。
常用断点~
BP GetVersion
BP GetCommandLineA
BP GetStartupInfoA
BP GetModuleHandleA
BP CreateFileA→对付vb程序
BP SetFilePointer→对付delphi
BP GetFileSize→对付对delphi
BP CreateFile→开两个OD比较（中断后都Alt+F9返回）
BP CreateFileA→开两个OD比较（中断后都Alt+F9返回）
BP ExitProcess→程序退出回溯找到关键断点

vb程序
1、下rtcFileLen、rtcFileLength断点
2、P-code编译的vb程序用WKTVBDE调试


一、
一般说来，对软件脱壳是不会改变原软件的运行机制的。它只是将加密的IAT地址还原成装载前的API函数名字串的地址，并以明码方式显示。脱壳是否成功的标志是软件运行前图标与脱壳前一致、运行时windows并未发出"……，初始化失败……"的警告，那么脱壳大体是成功的。若出现初始化失败警告，则百分之百是IID表或IAT表搞错了。

二、
用OD加载时出现"异常"或直接运行时，windows弹出"发送错误报告"消息。
原因：
（1）OEP入口地址错误；
（2）在手动脱壳时"张冠李戴"，把某函数的地址写到了另一个函数的地址上去了。

三、
软件一运行就退出
1．原因：
（1）如果脱壳前软件能（直接）运行，脱壳后软件一闪而过，说明软件有"文件校验"。软件脱壳前后的最大变化是文件尺寸变化，那么软件的"校验和"一定要发生变化，当它发现"校验和"变了时，知道了你对软件"动了手脚"，它就毫不犹豫地退出了。若这时你想找到"文件校验"的位置，无异于大海捞针！
（2）如果脱壳后能直接运行，但用OD加载时就退出或有无法跳过的异常，则是有"反跟踪"部件。（这和脱不脱壳没有关系）反跟踪不是本文今天讨论的内容，只是附带说一声。

2．对策：
在一个软件中去找出它的"文件检验"代码在什么地方，同样得用"思想"，和破案也差不多。别急，先看看它是什么语言编写的。若是用"VC++"或"Delphi"编写的，则脱壳后的软件对于使用者，则基本上没有秘密可言。唯一的是它们的"call"嵌套太深，要进行底层的跟踪，很容易跟丢。举个例子，说明跟踪方法。
有个商业软件，脱壳前可以运行，脱壳后就不能运行了。它是用"VC++"编写的。

3．破解思路：
用"VC++"或"Delphi"来编写软件，有它快捷方便的一面。但是，因为它不能直接对内存进行操作，所以灵活性受到很大影响。例如，它就不能对运行中的内存文件进行"校验和"检验，若非要检验，除非在VC编程中嵌入ASM代码，但这样一来，地址的起点和终点难于确定，且给调试带来麻烦。一个变通的办法是：打开同一文件的一个"副本"，检验它"副本"的"校验和"也可以达到对自身检验的目的。这样一来，软件的秘密也就暴露无遗了，用OD来查看(已经脱壳的)软件怎样打开另一个文件，那实在是"再容易"不过的事情了！

4．具体操作：
（1）用OD打开要跟踪的软件，右键打开搜索"所有模块间的调用"，在所有"CreateFile"和"ReadFile"的调用地址上设断点。
（2）运行OD，按"F9"，中断在一个CreateFile上：

CreateFile中断：（该函数的返回值是被打开文件的句柄）
……………………………………………………………………
0013E708 0013E90C |FileName = "E:\\xxxx\\New_xxxxxxx.exe"
0013E70C 80000000 |Access = GENERIC_READ
0013E710 00000003 |ShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE
0013E714 00000000 |pSecurity = NULL
0013E718 00000003 |Mode = OPEN_EXISTING
0013E71C 00000080 |Attributes = NORMAL
0013E720 00000000 \\hTemplateFile = NULL
……………………………………………………………………
以上是堆帐中的显示，其中，FileName = "E:\\xxxx\\New_xxxxxxx.exe"是将要打开的文件。若不是正在运行中的同名文件，则继续按"F9"。其余的参数是打开方式，不重要。

监视CreateFile中断的另一个收获是知道了该软件在硬盘上写入了哪些文件，比如注册表中、系统文件夹中等（我最讨厌那些在硬盘中乱写文件的软件）。更重要的是，若软件有"反跟踪"代码，那么"CreateFile"或"FindWindow"等API函数调用时，它明码显示的文件名或窗口名是某个"调试软件"，就表明它在"反跟踪"，若发现了它们，相应的"反-反跟踪"措施也应该不是太困难的事。当然，高明的作者用VC也会让你伤透脑筋。
当FileName="正在运行的文件名时"， 再按"F9"来到ReadFile的中断上：

ReadFile中断：
…………………………………………………………
0013E708 000001C0 |hFile = 000001C0
0013E70C 0013EA10 |Buffer = 0013EA10
0013E710 00001000 |BytesToRead = 1000 (4096.)
0013E714 0013E71C |pBytesRead = 0013E71C
0013E718 00000000 \\pOverlapped = NULL
0013E71C 00000000
0013E720 00001000
0013E724 004C5CD7
0013E728 0000016F ；调用次数记录
…………………………………………………………
其中，hFile = 000001C0是打开的文件句柄，Buffer = 0013EA10是保存读入数据的地址，BytesToRead = 1000 (4096.)是读入的字节数，其余的不重要。
由于一个软件，不可能只有1000h字节，一次不能读完，所以ReadFile要调用多次，调用的次数总可以在某个寄存器中或堆帐中找到，这里（0013E728 ：0000016F）就是递减的调用次数。每调用一次，后面的程序就将这1000h字节累加一次，稍加跟踪就到了"校验和"代码处：

（3）文件"校验和"代码：
……………………………………
004E0164 . 8D85 E0EFFFFF lea eax,dword ptr ss:[ebp-1020] ；eax=读入字节存放地址
004E016A > 33C9 xor ecx,ecx
004E016C . 8A08 mov cl,byte ptr ds:[eax]
004E016E . 014D EC add dword ptr ss:[ebp-14],ecx ；[ebp-14]=累加值
004E0171 . 40 inc eax
004E0172 . 4A dec edx ；1000h字节的计数
004E0173 .^ 75 F5 jnz short 004E016A
004E0175 > 4B dec ebx ；调用次数计数
004E0176 .^ 75 C6 jnz short 004E013E
004E0178 > 836D EC 7B sub dword ptr ss:[ebp-14],7B ；累加完成后的修正
004E017C . 8D85 48EDFFFF lea eax,dword ptr ss:[ebp-12B8]
004E0182 . E8 B564F2FF call 0040663C
………………………………………
累加结果存放在[ebp-14]=0013FA1C中。
不停地按"F9"，并b9db查（0013E728 ：0000016F）中的值，当它变为1时，就单步跟踪，"比较转跳"代码就近在咫尺了。

（4）"比较转跳"代码：
………………………………………
004E0182 . E8 B564F2FF call 0040663C ；这就是前面的最后一行
004E0187 . E8 E826F2FF call 00402874 ；释放一些内存等善后（VC特有）
004E018C . 837D F4 00 cmp dword ptr ss:[ebp-C],0
004E0190 . 75 22 jnz short 004E01B4
004E0192 . 8B45 E4 mov eax,dword ptr ss:[ebp-1C] ；取0013FA14的检验值
004E0195 . 3B45 EC cmp eax,dword ptr ss:[ebp-14] ；和累加值比较
004E0198 75 13 jnz short 004E01AD ；最关键的(非0)转跳
004E019A . BB 01000000 mov ebx,1
004E019F . 8B45 FC mov eax,dword ptr ss:[ebp-4]
004E01A2 . FE80 10450100 inc byte ptr ds:[eax+14510]
004E01A8 . E9 96000000 jmp 004E0243
004E01AD > 33DB xor ebx,ebx
004E01AF . E9 8F000000 jmp 004E0243

5．修改代码：
到了现在，文件检验和转跳都清楚了，修改就变得十分简单，只需将：(用16进制编辑器)
……………………………………………………………………
004E0198 75 13 jnz short 004E01AD ；改为：90 90 nop ,nop
…………………………………………………………………………
存盘，大功告成了。怎么样？一个大海捞针的工作变得谨然有序。运行一切正常。

破解一般步骤多方法总结

一，常见判断有壳方法知识总结
1.PEID查壳
2.载入OD是否有提示代码被压缩
3.根据程序入口代码
4.看是否可以查得到明码字符串
5.资源编辑工具看是否可以改资源

二，常见判断与解决附加数据知识总结
1.PEID查壳时显示[overlay]，95%的情况下是有附加数据，但是有个别程序没有附加数据，PEID可能误报，此时你可以在脱壳后先试运行程序，如果能运行说明就没有附加数据；
2.脱壳后的文件明显比脱壳前的文件小，且经修复无法运行——>十之八九是附加数据在搞鬼！
3.脱壳后运行提示“Invalid data in the file.”说明有附加数据。

修复方法
1.工具overlay修复
2.进制工具打开复制数据修复
三，常见自校检解决办法知识总结
1.双开OD法（如果软件有防多开窗口的限制，需要先解决这个问题。（不推荐 因为这样学不到东西）
2.跟踪退出函数。一般都是调用ExitProcess、PostQuitMessage
3.利用PEID的插件KANAL V2.90 。找到密码学算法和核心 CRC或者MD5实现磁盘文件校验或者内存映像校验关键的地方
四，常见自校检解决办法知识总结
1.校检日期
2.校检大小
3.校检旁文件

校检自身大小的软件一般方法
我们看一下未脱壳文件的大小为：10752字节转16进制为2A00，再看看脱壳后的文件大小30208字节，即7600，关键是如何找到对自身大小进行对比的语句，
1.W32Dasm上场。用W32Dasm载入脱壳文件，我们只要搜索00002A00即可。更改代码002A00为脱壳后的大小007600即可。（太多局限）
2.对于VB检测自身大小的软件我们还可以跟踪FileLen函数，因为VB一般都用FileLen检测自身的大小，用OD载入脱壳文件下断BP rtcFileLen，F9后断下，ALT+F9返回。
五，常见工具暴破方法知识总结找不到跳转，狂返回到主程序代码段内 在判关键跳转
1.跳过错误 相反与JMP。
2.不跳成功 相反与NOP。
3.改比较。
4.改比较中其中一个返回直.
六，常见去NAG窗方法知识总结
1.下调用窗口函数法
2.堆栈F12调用法
3.改跳转法（如果是注册才取消的NAG窗）
思路：不让NAG窗口运行就行```

七，常见工具追明码方法知识总结
1.OD追码法
找到关键CALL 直接下INT段点 然后运行到这 直接看堆栈上下或寄存器的直
关键CALL上面的PUSH POP LEA等传输数据等````
2.WinHex追码法
步骤:
1.启动需要破解软件
2.输入用户名和注册码,然后按确定
3.弹出一个对话框(切记,不要按确定!!!!!!!!)
4.启动WinHex
5.选择Ram编辑器
6.打开你所要破的软件的Ram的主要内存(基本上是最下面那个+)
7.搜索注册码
8.如果第一次没搜到按F3搜索下一个
9.然后就可以发现注册码

3.TRW2000追注册码的通法
1.将程式的注册对话框打开,输入你的姓名和任意的注册码(推荐用987654321)
2.按Ctrl+N呼叫出TRW2000,然后下中断(一般用bpx hmemcpy),回车,键入g,回车
3.返回注册界面,按下注册窗中的"确定"按钮.
4.如果被TRW拦到,说明刚才打的中断发挥作用了,可以继续工作.如果出现的是"注册失败"的对话框,说明TRW的中断没有作用,只有重复第二步,换个中断试试.(中断设置,看雪教程很详细,不重复)
5.键入bc*,回车,键入pmodule,回车,猛按F12键,等到出现"注册失败"的画面时,记下刚才按F12键的按数
6.第二次重复第一步至第四步,这次按(第五步记下的按数减去１)下的按数,停下来.
7.开始按F10键单独追寻,找到关键Call和关键跳转,在这个关键Call处d eax d edx,,多看看,有时就会看到注册码,出现在TRW的右上方
8.如果没找到,当然要按F8键进去关键Call观察了,继续追踪可疑Call和可疑跳转

注意:如果搜到最后还是没搜到,可以采取以下的方法,再试.(如果真找不到,就只能用其它软件了)
对于没有弹出对话框的软件似乎这方法没用!!!!
1.如果用注册码没搜到,就用搜用户名
2.有些软件对于中文用户名不支持,因此就使用英文用户名
3.有些软件对于注册码又长度要求,因此就使用比原先的注册码较长或较短的注册码
4.建议输入的注册码为987654321,因为如果是123456789会与机器中的一些数字重复

八，常见跳出与填加的网页解决知识总结
现在我们同时再找那个跳出的网页.
我们在堆线出现的真码处右键 -- 按在数据窗口中跟随
看到啦数据窗口出现很多你要改的字串了

除便改吧, 不用客气
先向上找 看到004F5040的网页地址吗..就是要找它

我们先不要急..再向上找004F4418 这个地址才是我们要找的真正修改地址

怎样改啦 :
先再打开多一个OD 在命令栏里打上 dd 004F4418 > ENTER >
再指着地址改为 HEX HEX/ASCLL(8位)
在004F4418 > 1A 处改为 00 就成功了


添加弹网页

006CE000 > 6A 01 push 1
006CE002 6A 00 push 0
006CE004 6A 00 push 0
006CE006 68 00E16C00 push dumped_.006CE100 ; ASCII "http://Blog.ShowHmily.Cn"
006CE00B 68 19E16C00 push dumped_.006CE119 ; ASCII "open"
006CE010 6A 00 push 0
006CE012 E8 C92EF47C call ShellExecuteA

具体怎么用，你只要让这段代码运行就可以了，可以让这段代码运行完再跳转到OEP也可以~
-------------------------------------------------------------------------------------------------------------------
本文原创于小黑冰, 转载请注明作者并保持文章的完整, 谢谢!

详解如何写OD脚本,献给初学者的

详解OD脚本的写法

大家都知道，好多壳，尤其是一些常见的比较简单的壳，一般都有相应的脱壳脚本，方便我们进行脱壳。但是，如果壳稍微有点变异呢？那么，一些脱壳脚本就无能为力了。所以，好多人都想学习自己写脚本，至少能读懂脚本，这种读脚本的能力也是相当有必要的。鉴于写脚本的教程不是很多，于是，今天抽空给大家写个详细点的教程。当然只是抛砖引玉，毕竟，本人也是菜鸟，写脚本的能力实在有限。

我首先用一个最最简单的ASPack壳为例子，来进行讲解！

我们先来脱一下这个壳吧：

方法一：

00430001 >60pushad //入口点，F8
00430002E8 03000000 call QQ个性网.0043000A //到这后，用ESP定律，下硬件访问断点
00430007- E9 EB045D45 jmp 45A004F7
0043000C55push ebp
0043000DC3retn
0043000EE8 01000000 call QQ个性网.00430014
00430013EB 5D jmp short QQ个性网.00430072
00430015BB EDFFFFFF mov ebx,-13
0043001A03DDadd ebx,ebp
0043001C81EB 00000300 sub ebx,30000
0043002283BD 22040000 0>cmp dword ptr ss:[ebp+422],0
00430029899D 22040000 mov dword ptr ss:[ebp+422],ebx
0043002F0F85 65030000 jnz QQ个性网.0043039A
004300358D85 2E040000 lea eax,dword ptr ss:[ebp+42E]



下完硬件断点后，F9运行，来到这

004303B0 /75 08 jnz short QQ个性网.004303BA //来到这。接着F8
004303B2 |B8 01000000 mov eax,1
004303B7 |C2 0C00 retn 0C
004303BA \68 D4124000 push QQ个性网.004012D4; //来到这，接着F8
004303BFC3retn//到这，接着F8
004303C08B85 26040000 mov eax,dword ptr ss:[ebp+426]
004303C68D8D 3B040000 lea ecx,dword ptr ss:[ebp+43B]
004303CC51push ecx
004303CD50push eax
004303CEFF95 490F0000 call dword ptr ss:[ebp+F49]

OK，这就来到OEP了！

004012D468 54474000 push QQ个性网.00404754; 这里就是OEP了！
004012D9E8 F0FFFFFF call QQ个性网.004012CE; jmp 到
004012DE0000add byte ptr ds:[eax],al
004012E00000add byte ptr ds:[eax],al
004012E20000add byte ptr ds:[eax],al
004012E43000xor byte ptr ds:[eax],al
004012E60000add byte ptr ds:[eax],al
004012E848dec eax
004012E90000add byte ptr ds:[eax],al
004012EB0000add byte ptr ds:[eax],al

好的，我们来总结一下吧：

1、单步F8
2、记录ESP的地址
3、在ESP的地址处，下硬件访问断点
4、接着运行
5、删除硬件断点
6、单步走3次
7、就来到OEP了！

有了这个流程，我们就可以开始写脱壳脚本了，可以这么写：
---------------------------------------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////////////////////////////
/// ASPack 2.12 -> Alexey Solodovnikov脱壳脚本///
/// by 徐超(ximo) QQ:178911980///
/// http://www.54soft.com.cn///
///http://www.52pojie.net///
//////
/// 2008.7.25 ///
///////////////////////////////////////////////////////////////////////////////////////////////////////

var addr//定义一个变量addr
sto //单步，也就是F8
mov addr,esp //把此处ESP的地址给变量addr
bphws addr,"r"//下硬件读取断点，也就是硬件访问断点
run//运行，也就是F9
BPHWC addr //取消断点
sto //单步，也就是F8，第1次
sto //单步，也就是F8，第2次
sto //单步，也就是F8，第3次
cmt eip,"这里就是OEP！"//在EIP处，也就是现在OD停留了位置加注释
MSG "感谢使用此脚本，现在可以脱壳了"//加个对话框，给出一些提示信息
ret//结束脚本

---------------------------------------------------------------------------------------------------------

OK，脚本就这么写完了，相信大家都应该明白了吧。下面接着来方法二！

方法二：

由于是ASPack的壳，所以，我们直接来查找关键代码"popad"，写就是"61"

004303AF61popad//查找到这里，在这里下断，为了防止检测，直接下硬件断点，中断后就F8走吧
004303B075 08 jnz short QQ个性网.004303BA//继续F8
004303B2B8 01000000 mov eax,1
004303B7C2 0C00 retn 0C
004303BA68 00000000 push 0 //F8
004303BFC3retn //F8
004303C08B85 26040000 mov eax,dword ptr ss:[ebp+426]
004303C68D8D 3B040000 lea ecx,dword ptr ss:[ebp+43B]

OK，又来到OEP了！

004012D468 54474000 push QQ个性网.00404754; 这里就是OEP了！
004012D9E8 F0FFFFFF call QQ个性网.004012CE; jmp 到
004012DE0000add byte ptr ds:[eax],al
004012E00000add byte ptr ds:[eax],al
004012E20000add byte ptr ds:[eax],al
004012E43000xor byte ptr ds:[eax],al
004012E60000add byte ptr ds:[eax],al
004012E848dec eax
004012E90000add byte ptr ds:[eax],al
004012EB0000add byte ptr ds:[eax],al

好，我们接着来总结一下：

1、查找16进制数"61"，写就是"popad"
2、返回一个查找到的地址
3、在查找到的地方下断点
4、运行
5、取消断点
6、单步4次
7、来到OEP了


有了这个流程，我们又可以来写个简单的脚本了，脚本如下：

---------------------------------------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////////////////////////////
/// ASPack 2.12 -> Alexey Solodovnikov脱壳脚本 ///
/// by 徐超(ximo) QQ:178911980 ///
/// http://www.54soft.com.cn ///
///http://www.52pojie.net ///
//////
/// 2008.7.25 ///
//////////////////////////////////////////////////////////////////////////////////////////////////////

findop eip, #61# //查找"61"，也就是"popad"
bphws $RESULT, "x" //返回查找到的地址，下硬件执行断点
run //运行
bphwc $RESULT //取消断点
sto//单步，也就是F8，第1次
sto//单步，也就是F8，第2次
sto //单步，也就是F8，第3次
sto//单步，也就是F8，第4次
cmt eip,"这里就是OEP！"//在EIP处，也就是现在OD停留了位置加注释
MSG "感谢使用此脚本，现在可以脱壳了"//加个对话框，给出一些提示信息
ret //结束脚本

---------------------------------------------------------------------------------------------------------

OK，用方法二写的脚本同样完成了！

对比一下，显然方法二比方法一效率更高，更为通用点！

对ASPack分析后，相信大家对写脚本已经有个大概的了解了吧！

好，我们接着来分析下FSG2.0的脚本的写法

通过前面的一些跟踪，我们可以找到如下的关键处：

004001C550push eax
004001C6FF53 10 call dword ptr ds:[ebx+10]
004001C995xchg eax,ebp
004001CA8B07mov eax,dword ptr ds:[edi]
004001CC40inc eax
004001CD^ 78 F3 js short qqspirit.004001C2
004001CF75 03 jnz short qqspirit.004001D4
004001D1- FF63 0C jmp dword ptr ds:[ebx+C] //这里，就跳向OEP了！我们F8
004001D450push eax

来到OEP！

0040A86D55push ebp //OEP
0040A86E8BECmov ebp,esp
0040A8706A FF push -1
0040A87268 78794200 push qqspirit.00427978
0040A87768 F4E14000 push qqspirit.0040E1F4
0040A87C64:A1 00000000mov eax,dword ptr fs:[0]
0040A88250push eax
0040A88364:8925 0000000>mov dword ptr fs:[0],esp
0040A88A83EC 58 sub esp,58
0040A88D53push ebx
0040A88E56push esi
0040A88F57push edi
0040A8908965 E8 mov dword ptr ss:[ebp-18],esp
0040A893FF15 10524200 call dword ptr ds:[425210] ; kernel32.GetVersion
0040A89933D2xor edx,edx
0040A89B8AD4mov dl,ah


我们再来总结一下：

1、查找特征码"FF630C"
2、保险起见，下硬件执行断点
3、取消断点
4、单步F8
5、到达OEP

有了上面的总结，又可以来写个简单的脚本了：

---------------------------------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////////////////////
/// FSG 2.0 -> bart/xt查找OEP脚本///
/// by 徐超(ximo) QQ:178911980 ///
/// http://www.54soft.com.cn ///
///http://www.52pojie.net ///
//////
/// 2008.7.25 ///
////////////////////////////////////////////////////////////////////////////////////////////////

findop eip, #FF630C#//查找特征码"FF630C"
bphws $RESULT, "x" //在查找到的地址处，下硬件执行断点
run //运行
bphwc $RESULT //取消断点
sto//单步F8
cmt eip,"这里就是OEP！"//在EIP处，也就是现在OD停留了位置加注释
MSG "感谢使用此脚本，现在可以脱壳了"//加个对话框，给出一些提示信息
ret //结束脚本

---------------------------------------------------------------------------------------------------------

哈哈，脚本到此就结束了，下面的内容就自己脱壳修复了！

通过上面的讲解，大家也都发现了，其实写脚本并不是想象中的难吧！

大家也可以自己尝试着去写UPX啊，北斗啊等一些常见壳的脚本，来练习练手。

当然，这些都是一些很简单的壳的脚本，至于一些强壳，就得大家好好下点工夫了

附件中，带有教程中试炼壳的程序，以及常用的脚本代码大全。

祝大家玩的开心。作者徐超，转载请注名出处！

脱壳经验谈~(推荐新手多看看)

学破解时间也不长了，也学了一些脱壳的技术，过程中感触颇深。这里给大家分享一下，也算是给脱壳新手的一个指导。

菜鸟心得，高手飘过~ 当然你要看，我也不反对~~

关于工具

关于OD
所谓工欲善其事，必先利其器。要想学习脱壳的话，有几种不同的OD是很重要。因为有时在调试一些强壳的时候，有些改造过的OD可以躲过壳的深层检查，再配合一些OD插件就可以完全让壳检测不到调试器的存在了。这里推荐几款比较好的OD：
1，fly改造的OD。可以调试大多数壳，但是由于不能使用phanom 1.3版的插件，导致在调试某些强壳（如Aspr 2.x）的时候会被检测到。
2，ImmunityDebugger.这款OD可以比较顺利的调试Aspr等其他强壳。国内也有了汉化版。只是界面背景是黑色的，我实在不习惯这种界面，喜欢的人可以试试。
关于其他的工具
1，LordPE。推荐大家在Dump程序的时候使用这个工具。或许大家在脱简单的压缩壳时习惯使用OD的脱壳插件来抓取内存镜像，但是如果大家有调试穿山甲等强壳的经验就会知道，如果用OD插件抓取内存镜像就会出现OD被卡死的状态，这或许是OD插件的Bug，也可能是壳的反Dump方式，反正会影响到我们正常的脱壳。所以这里推荐使用LordPE来抓取镜像文件。而且在需要补区段的时候，用LordPE可以很方便的进行区域抓取。此外，作为一款PE编辑器，LordPE也是很优秀的。相比之下，PEtools就有点儿差了，对于PE文件有些操作会导致文件损坏，不知道为什么。大家还是用LordPE吧。
2，ImportReconstruction。这是一款专业级的输入表重建工具。由于它支持插件扩展，可以大大提高对于加密壳的脱壳成功率。但是请大家不要过于依赖这款软件，学会手动修复输入表是很必要的。在ImportREC不能修复的时候，我们只能靠手动修复。手动修复一方面可以练习调试技术，另一方面可以让我们更加深入的去了解PE文件的工作方式。

关于脱壳方法
相信大家都像我一样看过一些脱文，在里面告诉我们下这个API断点，然后走多少步，再怎么样怎么样就可以到OEP了。反正具体为什么这么操作，作者都只字不提。当我看到这些脱文的时候，基本上是一头雾水。加上我这个人比较倔强，对于我不懂的方法是不会接受的，所以那段时间，脱壳的水平基本上止步不前。实践是最好的老师，自己亲手调试了些壳以后就明白为什么了。当时我有个这样的顾虑，就是“我真的能调试这些壳，那可是前辈们干的事儿啊”，但是真正调试后才发现其实并没有那么难的。当我第一次手脱了一个Aspr 1.23RC1的时候，真的好兴奋，那种感觉就像一个初出茅庐的小贼利用自己学过的书本上的技能到**局偷出了一根**局长的头发，虽然没有值得炫耀的，但是对于自信心却是很大的鼓励。所以加密壳没有好怕的，你只要想办法躲过壳的所有检验，然后乖乖的走到OEP就可以了！至于如何躲过这些检验，那就要你在调试中不断积累经验，以及借助别人的经验了。
所谓授之以鱼，不如授之以渔。学习脱壳还是理解方法，才能真正学会。
所以我对于那些脱文的态度是这样的：
1，对于所谓的方法先置之不理，自己手动调试一遍，了解壳的流程（一般来说，当你调试到OEP的时候，这个壳你应该调试了10遍以上了）。
2，当遇到实在过不去的检验的时候再看脱文，了解它是怎么过去的。这样印象深刻一些。并在下次遇到这样状况的时候能自己解决。
3，当自己完全脱掉这个壳后，再看下脱文，这个时候你应该就可以明白为什么下那些API断点了。下次就可以不用这样手脱了，照着脱文给的快捷方法脱壳就可以了。这个时候对于出现和脱文上不同的情况，我想你应该也会处理了。
再说说如何调试壳呢。
1，首先要选择并配置好OD，尤其对于强壳一定要这么做。配置OD包括异常设置，删除int3断点（因为有些壳会检测Int3断点的），OD的标题隐藏等。当这些都设置好，要在OD中运行一次，确保你要脱壳的程序能在当前的OD中顺利的运行（对于有些带驱动的壳可以不这么做，因为必须在没有驱动的条件下才能调试。），这样可以在调试时省去不少躲避调试器检查的时间。（当然有些壳还是要在调试中躲避检查的。）
2，个人认为，基本的调试方法有：单步法，最后一次异常法。这两种方法在逻辑上都是比较好理解的。在调试的过程中要配合内存断点，硬件断点，Int3断点以及F4来简化调试过程。如可以用F4来跳出循环；硬件断点可以用来记录调试进度，当程序不小心跑飞的时候，可以在相应的位置下硬件执行断点，重新来过后就可以直接到达跑飞的位置了；灵活运用内存断点可以使得调试变得很容易，也是提高调试技巧的一种方法。
当你可以熟练的运用这些方法的时候，任何的壳都可以搞定了，任何一个加壳的程序就像躺在床上的**，等着你脱了~ ^-^

关于OEP的到达
我们脱壳的目的就是为了到达OEP，但是如果判断是不是到达了OEP了呢？前辈们告诉我们一个方法，注意跨段跳转或转移。这确实是唯一判断标准。但是很多的教程中都把这句话误解为了：“注意大的跳转”，使得很多新手都被搞的云里雾里的，看到大跳转就兴奋。
首先澄清一个误解，什么叫做“跨段转移或跳转”？这里面所谓的段指的是一个区段，是指被分割成一段段的内存。跨段跳转顾名思义，是指EIP指针从一个区段跳到了另一个区段。而不是所谓的大的跳转。如果EIP所在的区段很大，段内跳转也可以很大，这里所谓大的跳转本身就是一个很模糊的概念。
其次，并不是出现跨段跳跃就是要到OEP了。一般加密壳在解码的时候会在内存中申请空间，并在那里实行解码。一般来说是壳会申请很多段这样的空间，然后在解码的时候从这个段跳到那个段。这些段就是我们在调试的时候在目标程序区段后面的那些没有名字的区段部分。所以说在这些段里面的跳跃一般不会到OEP的。
再次，那么你会说了，那到底怎么判断呢？大多数壳把程序解码后会跳到目标程序的code段的进行执行。那么方法就出现了，在调试的时候可以先看下code段的地址范围，如果在调试过程中出现了跳跃到这个地址范围内存的跳转或转移的话，那么十有**就是要去OEP了！
此外，对于OEP的判断可以通过不同语言编译的程序入口点特征来判断，当然这完全就是经验的问题，需要大家不断的积累。就像天草说的，记住入口特征这句话我都说了八百遍了。
不过，这里有个小技巧，就是通过查看资源类型来大致判断。因为壳很少资源列表进行处理，所以如果查看资源，发现存在RCData的话，就可以认为程序应该Delphi或者BC++的；如果资源中有对话框，菜单等资源，而且资源名称都比较规则的话（这主要是为了区分VB以及E语言），就可以判断是MS VC++的了；如果在程序安装目录中发现*.fnr等类型的文件话，基本可以认定是E语言的了（现在E语言的程序越来越多了）；如果在程序的末尾发现附加数据的很多的话（一般要大小的数量级在KB以上），那应该也是E语言的（这个时候大家应该明白为什么E语言程序查壳的时候为什么显示的时候Microsoft VC++[OVERLAY]了吧）。

关于学习方法
这应该是老生常谈了。学习方法因人而异，没有必要强调某种方法，方法的目的只有一个，就是掌握你学到的东西东西并与以前的知识融汇贯通。论语中的那句话“温故而知新”，确实很有道理。当你学到一些东西后，回过头来看以前学的东西，你会发很多新的东西，可以加深对某些知识点的理解。这点是没有任何方法可以替代的。这里推荐两种方法：
1，录像。把你的脱壳学习过程录像，当你忘记的时候，回忆起来也会很快的。
2，做好笔记。OD有个很好的插件Godup可以在调试的过程中做好记录。从某种程度上讲，记录是你调试过这个壳唯一证据。

关于到OEP的一些特征代码
现在的壳变聪明了，很少再使用Jump **X这样的方式来到OEP了。下面介绍几种流行的方法。
1，push 寄存器或者地址
retn
这种方法是利用retn来实现远跳转的，原理同call子程序的后返回的
原理一样，即通过push一个值到堆栈顶，然后用retn指令即可返回到堆栈顶指向的地址。
2，mov dword ptr[**]，**X
jnz **XX
retn
push 0 这个地址是上面的mov指令动态填写的
retn
这样的条转在ASPac和ASprotect中使用过。
3，mov 寄存器，**X
call 寄存器
这个在穿山甲的壳中可以看到。
4，还有使用Leave指令进行跳转的，大家也可以注意下。
5，使用SEH。后面会提到。

关于SEH
SEH，Structure Exceptions Handle，结构化异常处理，是加密壳程序经常使用的桥段。主要用这种方法来实现非正常跳转（可能还有其他作用，我现在只理解到这里）。对于SEH的具体技术细节我也搞不明白，也不用管它，OD给了我们一个很好用的功能，就是在堆栈会显示SE句柄。这是什么意思呢？你只要知道当出现异常后，系统处理完异常就会跳到这里来继续执行。 那么我们可以通过在这个地方下好断点，然后Shift+F9，就可以继续调试了！

关于自校检
现在带有脱壳自检验的程序还是很多的。自校验类型大致分为以下几个类型。
1，CreateFile型。这种自检验一般都会调用CreatFileA（W）函数来对于自身。然后
通过GetFileSize获取文件大小，因为一般脱壳后文件大小会变，通过比较文件的大小来检测是否被脱壳。
通过SetFilePointer来设置文件指针，然后通过ReadFile读取文件中的一些数据，来判断是否被脱壳（一般来说读取的时候附加数据）
2,内存型。这种自检一般是对程序在内存中镜像进行CRC，MD5等检验，如果不相等则认为已脱壳或被修改。
3，脚本语言型。脚本编程语言指的是像autoit，autohotkey等语言。这种语言编译出来的程序一般都是天生带壳的，而且自校验是对附加数据进行多次细致的检查，如果不弄清楚检验过程，即使更改跳转也不能让程序正常运行。有机会大家可以试试。
4，壳校检型。这种校验是在主程序中插入一些跳到壳地址中的代码，并返回一些无关紧要的数据或做无关紧要的操作。如果程序被脱壳了，这些代码执行的时候就会出现异常。
还有一些其他类型，但是现在还有总结出比较好的说法，以后再补充。
相应的处理方法。
1，直接对API下断，基本就可以到达解密点。
2，用PEID插件可以查看算法的所在位置，就可以到达解密点了。
3，没有别的方法，运用API断点耐心调试吧
4，在OD运行程序，出现异常后，在堆栈中找到返回的位置，nop掉相应的指令即可。

关于脱壳脚本
脚本应该是前辈没有留给我们最好的财富了，有了这些东西，我们可以在不了解任何脱壳细节的情况下脱掉壳。但是如果想学脱壳技术的话，那么请把它当作你的老师。因为脚本中包含着你遇到问题的所有答案~ 而且当你了解了以后，还可以自己改进脚本的功能。借用达朗贝尔的一句话：多读读高斯，他是我们每个人的老师~

关于花指令
可能有些新手看到壳那些乱七八糟的指令会发怵的，这些都是壳为了阻止调试者所设的花指令，或许你不知道这些指令怎么执行，但是壳是是知道的，它不可能去执行一坨不能执行的指令的，有些指令是动态解码的，有些是花指令。你在调试的时候只要看着当前指令F8（7）就可以了，不用管别的。再借用达朗贝尔的一句话（怎么又是他？）:前进吧，你会有信心的！

关于心态
调试壳是需要很大耐心的，就像破解一样！ 所以如果你已经下好决心的话，那么请同时做好心里准备！

最后送大家一句话，关键是要对她有爱~ 只有真正对这个东西感兴趣，你才能真正学到东西！

Begging For A Way Back Into Love!!!
本文转自看雪学院BY HyperChem

OllyDbg使用经验小结 ZZ

[原创作者:vical,转帖请保留完整]
　　上次在一Cracker BBS即兴写了一个多钟头,那知提交的时候它说俺验证码错,让俺的Crack界处女作付诸东流,F! 原先写的都忘了,这回就再写过一篇吧.
　　OD是win32下公认的骨灰级调试器,它虽工作在Ring3下功能没有Softice和trw强,但在方便\易用\智能之处却远超这两个Ring0调试器直逼IDA.如果能多利用它提供的特色功能,使用起来就会更轻松舒畅,俺用OD不是很长时间,就把那么一点点的使用经验写上来,错误总是不可避免的,只作个抛砖的作用,把大家的玉引出来.也算是对QQ群上常问OD怎么用的朋友作点交待了.
　　1.快速定位功能.
　　 在代码窗口按"*"号可定位到当前EIP所在的反汇编语句处,按"-"号可转到上一次聚焦的语句上,按"+"号转到下一个聚焦语句上,在跳转\CALL\RET语句处按回车可跳到目标代码处,前提是当时OD能计算得到跳转的目标地址.而"+"号和"-"号可以连续按.在堆栈窗口也是如此.不同的是此时"*"号跳到ESP所指堆栈位置.
　　2.命名
　　 在反汇编语句或内存窗口点选再按分号可输入名字,虽没IDA的结构处理功能但还是不能小看其作用,我习惯上给有多处调用或跳转的报错和注册成功代码段起名,给输入的用户名\序列号起名,这样做好再看反汇编结果,结构就清晰明白得多了.
　　3.显示相对地址
　　 在反汇编窗口\内存窗口\堆栈窗口显示地址的地方双击试试,会发现它显示"==>"号,上下的地方就显示相对于这一句的地址例如$+0F\$-4等,这在堆栈应用得比较多:定位到EBP,双击地址,此时就能很容易地看出局部参数的位置啦.再不怕local.1\local.2等难找难算的标号了.
　　4.附加功能
　　 此项功能可以躲开很多Anti-debug的软件,俺习惯上先运行目标软件,故意让它报错.再打开OD附加,用F12暂停,ALT+F9返回到用户模块,转到报错窗口按确定,会中断在OD中,一般上都是MessageBox报错的下一行.CTRL+A分析.再看它的跳转来源.如果在前面ALT+F9返回不了用户代码的话,可以在此时看堆栈找出调用结构,直接跳到用户模块也行.
　　5.条件中断
　　 如果碰到某一个CALL ebx之类语句所在段总是被调用,但又只想跟其中一个的话,可以在此句按Shift+F2写入ebx==0ff之类的条件表达式来下中断.此功能在MessageBox和TranslateMessage时特别有用,前者是判断显示信息的第一个字节,用后者时要先获得按纽的ID再用eax==ID下断.具体怎么使用自己试一试吧.
　　暂时先写这么多,想到什么再完善.