CONTINUATION Flood 头部洪泛防御实战配置

CONTINUATION Flood 是一种只用一个 TCP 连接就能把 Web 服务器 CPU 和内存吃光的 HTTP/2 层攻击。它不发完一个完整请求,而是在 HEADERS 帧之后持续追加 CONTINUATION 帧,让服务端一直等不到 END_HEADERS,从而把连接级并发限制和请求限流全部绕开。本文给出 Nginx 侧的配置加固、日志识别方法与可复现的自建验证脚本。

适用场景

  • 站点已开启 HTTP/2,但只配了 limit_req 这类基于请求的限流,连接层的异常占用没有兜底。
  • 遇到「带宽不高、QPS 不高,但 CPU 打满、worker 进程卡死、连接数持续上涨」的疑似攻击,常规 CC 分析找不到高频 IP。
  • 做安全基线核查时,需要确认 large_client_header_buffers、keepalive_requests 这类参数没有被为了「兼容性」放大到危险值。
  • 反向代理层(Nginx / Envoy / Apache)对外提供 HTTPS,后端业务本身无法感知协议层攻击。

前置条件

  • Nginx 1.18 及以上,建议 1.25.1 以上(该版本起 http2 从 listen 参数改为独立指令)。
  • 已开启 HTTP/2,例如 listen 443 ssl; 加 http2 on;。
  • 能读取 access.log 与 error.log,日志格式中包含 $server_protocol、$request_length、$request_time 三个变量。
  • 一台可自由发起连接的测试机,用于跑验证脚本;脚本只对自有环境使用。
  • 改动前备份当前配置,Nginx 支持 nginx -t 校验后 reload 生效,无需中断连接。

原理说明

HTTP/2 的请求头不是一个帧能装下的。协议把头部块拆成 HEADERS 帧加上若干 CONTINUATION 帧,接收端必须把这些帧拼回完整的头部块才能解析请求。RFC 9113 规定 CONTINUATION 帧必须紧跟在同一流的 HEADERS 之后,中间不允许插入其他类型的帧,但并没有规定一个头部块最多能携带多少 CONTINUATION 帧。

这个空白就是攻击面。攻击者建立一条 TLS 连接,发送 HEADERS 帧但不置 END_HEADERS 标志,随后不断追加 CONTINUATION 帧,服务端就会陷入三种消耗:

  • 请求永远不完整:Nginx 的请求计数不增加,limit_req 的令牌桶不被消耗,按请求数做的 CC 防护看不到异常。
  • 内存被单流撑大:每个半开流都要缓冲整个头部块,多条连接叠加后内存线性上涨。
  • CPU 被 HPACK 解码吃满:每个 CONTINUATION 帧都要做一次头部解码,单核即可跑满,多 worker 场景下表现为整机负载飙升。

公开披露中,Apache httpd 受影响最重(CVE-2024-27316,2.4.59 修复),Go 标准库 net/http 同样受影响(CVE-2023-45288)。Nginx 因为对单个请求头有 large_client_header_buffers 的硬上限,超过上限直接返回 431 并关闭连接,危害相对可控;但如果站点为了兼容某些超长 Cookie 把这个值调到 64k 甚至更大,缓冲窗口就被放大,同样会被拖垮。

操作步骤

第一步:确认当前 HTTP/2 状态与编译参数

nginx -V 2>&1 | tr ' ' '\n' | grep -i http_v2
grep -rn "http2" /etc/nginx/nginx.conf /etc/nginx/conf.d/

输出里有 http_v2_module 说明编译进来了。注意版本分界:1.25.1 之前写 listen 443 ssl http2;,之后必须写 listen 443 ssl; 加 http2 on;,混用会直接报 invalid parameter “http2″。

第二步:给头部块设置硬上限

http {
    # 单个请求头的总上限,默认 4 8k,不要为了"兼容"调成 64k
    large_client_header_buffers 4 8k;
    client_header_buffer_size 1k;
    client_header_timeout 10s;

    # 1.25.1 之前的版本还需显式限制 HPACK 解码后的字段长度
    # http2_max_field_size 4k;
    # http2_max_header_size 16k;

    # 单连接并发流上限,1.25.1+ 默认 128,公开站点可压到 32
    http2_max_concurrent_streams 32;

    # 连接寿命上限,避免攻击者长期霸占同一条 h2 连接
    keepalive_requests 200;
    keepalive_timeout 30s;
}

large_client_header_buffers 是这条攻击链上最关键的一道闸:一旦累计头部超过 32k,Nginx 立即返回 431 并断开,不做无上限缓冲。keepalive_requests 则强制长连接定期回收,让攻击者必须反复重建 TLS 握手,成本抬高一个量级。

第三步:连接层限流兜底

http {
    limit_conn_zone $binary_remote_addr zone=conn_perip:10m;
    limit_req_zone  $binary_remote_addr zone=req_perip:10m rate=20r/s;

    server {
        listen 443 ssl;
        http2 on;
        server_name example.com;

        limit_conn conn_perip 20;
        limit_conn_status 429;
        limit_conn_log_level warn;

        location / {
            limit_req zone=req_perip burst=40 nodelay;
            limit_req_status 429;
            proxy_pass http://backend;
        }
    }
}

limit_conn 按单 IP 并发连接数封顶,是唯一对「未完成请求」也生效的限流手段;limit_req 只统计已完成的请求,对本类攻击无效。两者必须同时开,只开 limit_req 等于没防。若前面还有 CDN 或高防,$binary_remote_addr 拿到的是回源节点 IP,需要先用 real_ip 模块还原真实客户端地址,否则限流会把整个节点封掉。

第四步:高风险场景直接降级到 HTTP/1.1

server {
    listen 443 ssl;
    server_name example.com;
    # 不写 http2 on; 即只用 HTTP/1.1
    # 代价:失去多路复用,前端并发静态资源会退化,需自行评估
}

如果业务对 HTTP/2 没有强依赖,这是最彻底的做法,攻击面直接消失。也可以评估 HTTP/3,但要清楚 QUIC 的头部压缩侧同样存在放大类问题,不是开了就安全。

第五步:自建环境验证服务端上限

下面的脚本手工构造 HEADERS 帧(不置 END_HEADERS)加连续 CONTINUATION 帧,用来确认服务端是否会在缓冲区满时断开连接而不是无限缓冲。仅在自有测试环境执行。

import socket, struct, sys

HOST, PORT = "127.0.0.1", 443
CONT_FRAMES = 2000
PAD = b"A" * 100

def frame(ftype, flags, sid, payload=b""):
    return struct.pack(">I", len(payload))[1:] + bytes([ftype, flags]) \
           + struct.pack(">I", sid) + payload

def lit(name, value):
    # HPACK:literal header field without indexing,新名字(首字节 0x00)
    return bytes([0x00, len(name)]) + name + bytes([len(value)]) + value

s = socket.create_connection((HOST, PORT), timeout=10)
s.sendall(b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")          # 连接前言
s.sendall(frame(0x4, 0x0, 0, b""))                      # SETTINGS
s.sendall(frame(0x1, 0x0, 1, lit(b":method", b"GET")))  # HEADERS,头块未结束
for i in range(CONT_FRAMES):
    s.sendall(frame(0x9, 0x0, 1, lit(b"x-pad", PAD)))   # CONTINUATION
s.settimeout(3)
try:
    print("recv:", s.recv(256))
except socket.timeout:
    print("server still buffering, no response")

预期结果:加固后的 Nginx 在头部累计超过 32k 后主动断开或返回 431,脚本在 recv 阶段拿到数据或直接读到空;把 large_client_header_buffers 放到 16 64k 再跑一次作为对照,能明显看到服务端「继续吃帧」的时间变长,这就是缓冲区被放大的代价。

配置验证

先确认配置语法与生效:

nginx -t
nginx -s reload
curl -sI --http2 https://example.com/ -o /dev/null -w "%{http_version}\n"

再让日志能看见协议层异常。在 http 段加入带协议变量的日志格式:

log_format proto '$remote_addr [$time_local] "$request" $status '
                  'proto=$server_protocol req_len=$request_length rt=$request_time';
access_log /var/log/nginx/access.log proto;

统计 400 与 431 的来源 IP,这两类状态码是头部超限与协议错误的直接信号:

awk '$0 ~ / 400 | 431 / {print $1}' /var/log/nginx/access.log \
  | sort | uniq -c | sort -rn | head -20

# 观察 443 的并发连接数与 worker CPU
ss -ant state established '( sport = :443 )' | wc -l
top -b -n1 | grep nginx

判定标准:加固后同样的攻击流量下,431 数量上升、并发连接数回落、worker CPU 不再随攻击流量线性上涨,说明缓冲区上限与连接限流都已生效。

常见问题

Q1:我已经配了 limit_req,为什么还是被打满?

因为 limit_req 的令牌桶只在请求完整解析后才扣减。CONTINUATION Flood 从始至终不产生一个完整请求,令牌桶一直是满的,防护形同虚设。这类攻击只能用连接维度的手段拦:limit_conn、large_client_header_buffers 上限、keepalive_requests 寿命,以及防火墙层的单 IP 并发连接数限制。

Q2:直接关掉 HTTP/2 是不是最省事?

技术上最彻底,但要算业务账。HTTP/2 关闭后,浏览器对同域并发连接数回落到 6 个左右,图片站、多静态资源的页面首屏会变慢,移动端弱网下差距更明显。折中方案是保留 HTTP/2 但把 http2_max_concurrent_streams 压到 32、keepalive_requests 降到 200,配合 limit_conn 20,既能撑住正常业务,也把单连接的资源占用封了顶。

Q3:Nginx 会不会像 Apache 那样被打挂?

默认配置下很难。Nginx 对单请求头有 4×8k 的硬上限,超限直接 431 断开,不会像早期 Apache 那样持续累积。真正的风险来自两处人为改动:一是为了兼容超长 Cookie 把 large_client_header_buffers 调到 16 64k;二是完全没有连接数上限,攻击者用几万条连接各占一点缓冲,总量仍然能把内存吃穿。只要这两点守住,Nginx 的抗性是可用的。

Q4:日志里全是 400,怎么和正常的 TLS 握手失败区分?

看两个字段。正常的握手失败不会产生 access.log 记录(连接没到 HTTP 层),只有 error.log 里出现 SSL_do_handshake 相关报错;而 CONTINUATION Flood 一定会在 access.log 留下带 proto=HTTP/2.0 的 400/431 记录,且 req_len 异常小、rt 异常短。两者一对就能分开。

总结

CONTINUATION Flood 的本质是「协议允许的合法行为被用来做资源消耗」,所以它天然绕开所有基于请求计数的防护。防守要点只有三条:把 large_client_header_buffers 的上限守住,不要为了兼容性放大;用 limit_conn 在连接维度封顶;用 keepalive_requests 压缩连接寿命。三条都配上之后,同样的攻击流量会从「打满 CPU」退化成「一堆 431 日志」,处置成本回到可接受区间。最后提醒一句:改完参数一定要用验证脚本在测试环境跑一遍,确认是断开而不是继续缓冲,否则等于把配置写进了文件却没生效。