先讲个真事。有个做文件转换服务的团队,接口上线三个月风平浪静,直到某个同事"顺手"加了个功能:支持客户端上传 .gz 压缩包自动解压。改完当天压测跑通,第二天凌晨三点被叫起来——不是被业务流量打爆的,是被一个 42 KB 的请求打爆的。
42 KB 的请求体,gzip 压缩比 3000:1,解压之后 126 MB。而这个 126 MB 全进了内存缓冲区,连业务逻辑都没走到,进程先 OOM 了。攻击成本:一次 POST,2 分钱流量费。
这就是 zip bomb(压缩炸弹)。听起来像 90 年代的病毒名,其实它是所有在线服务迟早要挨的一拳——除非你在读 body 之前就知道该在哪儿踩刹车。
先搞清楚:为什么 gzip 能放大一万倍
压缩的本质是让"重复的东西只存一遍"。deflate 的窗口只有 32 KB,所以单层 gzip 的极限压缩比大约是 1032:1——也就是说 1 MB 压缩数据理论上能撑出 1 GB。听着已经够吓人了?
但真正的恐怖在于嵌套。
# 造一个双层炸弹(这玩意儿一点都不难)
python3 -c "
import gzip, io
data = b'\x00' * 100 * 1024 * 1024 # 100MB 全零
b1 = gzip.compress(data)
b2 = gzip.compress(b1)
open('/tmp/bomb.gz','wb').write(b2)
"
ls -lh /tmp/bomb.gz # 看着就人畜无害
攻击者发给你的是 b2。你的第一层解压产出 b1,而你的代码如果"贴心"地写了"如果是 gzip 就再解一层",那就完蛋了。
更骚的操作是
Content-Encoding拼接:有些实现允许Content-Encoding: gzip, gzip,还有更老的"gzip of gzip"文件头伪装技巧。防御代码如果只判断"开头是不是 0x1f 0x8b",基本等于没防。
坑一:把 Content-Length 当成"解压后的大小"
这是最常见的致命错误。很多人写校验时想:限制大小嘛,看 Content-Length 不就行了。
问题在于 Content-Length 描述的是压缩体的大小,跟解压后的体积没有任何关系。你限制 10 MB,等于允许 10 GB 的解压输出。更骚的是 Content-Length 还可以干脆不写,用 chunked 编码边发边压——很多网关会直接放行。
// ❌ 看起来很安全,实际是个筛子
if r.ContentLength > 10*1024*1024 {
return errors.New("too large")
}
正确的姿势是限制解压后的字节数,而且必须用流式的方式限制,让炸弹在读到第 8 MB 的时候就被掐断,而不是先读完再判断。
坑二:先 read 全部,再检查长度
另一类写法是"先全读进内存,再看 len 超没超"。这个逻辑等价于"先让炸弹在房间里炸完,再检查损失"。攻击者只需要并发几个请求就能把内存打穿。
坑三:中间层把限制悄悄解除了
你的应用限了 10 MB,但上游 Nginx 配了 client_max_body_size 0(不限制),或者网关在做解压后转发(比如某些 API 网关的"透明解压"功能),限流就形同虚设。防线必须建在读取 body 的那一刻,不能指望上游。
硬核部分:怎么写一个扛得住的解压读取器
Go 里最容易犯错的写法是直接 io.ReadAll(gzipReader)。正确做法是用 io.LimitedReader 包一层,并且读完之后多读一个字节验证是否触顶——这是判断"刚好等于上限"和"超了"的关键技巧。
const MaxDecompressed = 32 << 20 // 32MB 解压上限
func readCapped(r io.Reader, max int64) ([]byte, error) {
var br bytes.Buffer
lr := &io.LimitedReader{R: r, N: max + 1} // 多留 1 字节做探测
if _, err := io.Copy(&br, lr); err != nil {
return nil, err
}
if lr.N <= 0 {
return nil, fmt.Errorf("decompressed body exceeds %d bytes", max)
}
return br.Bytes(), nil
}
// 使用:外层限压缩体大小,内层限解压大小
func handleUpload(r *http.Request) error {
var src io.Reader = io.LimitReader(r.Body, 1<<20) // 压缩后最多 1MB
if strings.Contains(r.Header.Get("Content-Encoding"), "gzip") {
gz, err := gzip.NewReader(src)
if err != nil {
return err
}
defer gz.Close()
return process(gz) // process 内部必须用上面的 capped reader
}
return process(src)
}
Python 侧同样有坑。标准库 gzip.open(...).read() 是惰性的,这点还行;但很多人会写 len(gzip.decompress(data)) 去做校验——这一步已经把炸弹全放出来了,等于白防。
# ✅ Python:边解边算,用 ReadError 截断
import gzip, zlib
MAX = 32 * 1024 * 1024
def safe_decompress(data: bytes) -> bytes:
d = zlib.decompressobj(16 + zlib.MAX_WBITS)
out = bytearray()
try:
for chunk in iter(lambda: d.decompress(data, 1024 * 256), b""):
out += chunk
if len(out) > MAX:
raise ValueError("gzip bomb detected")
except zlib.error:
pass
return bytes(out)
Node 生态更乱。zlib.gunzipSync 是同步全量解压,直接把炸弹塞进事件循环的堆里;Express 的 body-parser 虽然有 limit,但那个 limit 管的是压缩体,解压后的体积还得自己兜。建议直接在中间件层拦截。
// Express 中间件:解压后也要有上限
const zlib = require('zlib');
function gzipGuard(req, res, next) {
const enc = (req.headers['content-encoding'] || '').toLowerCase();
if (!enc.includes('gzip')) return next();
const chunks = [];
let size = 0;
const gunzip = zlib.createGunzip();
gunzip.on('data', (c) => {
size += c.length;
if (size > 32 * 1024 * 1024) {
gunzip.destroy(new Error('gzip bomb'));
return;
}
chunks.push(c);
});
gunzip.on('error', (e) => res.status(413).send(e.message));
gunzip.on('end', () => {
req.body = Buffer.concat(chunks);
next();
});
req.pipe(gunzip);
}
别忘了配额:解压比本身就是信号
光有绝对上限不够。业务上传一个 200 MB 的视频是合法的,但你收到一个 200 MB、压缩后只有 300 KB 的请求,这东西八成不是正常流量。业界常见做法是同时限制压缩比:
ratio := float64(decompressedSize) / float64(compressedSize)
if ratio > 100 && decompressedSize > 1<<20 {
// 正常的 JSON/CSV 压缩比也就 5~20,超过 100 基本是异常
return errSuspiciousCompression
}
这个阈值别设太死——高度结构化的数据(比如全是重复字段的日志、稀疏矩阵)压缩比天然很高。我的经验值是先看绝对量,再看比值:小请求(<1 MB)不看比值只拦总量,大请求同时看比值。
架构层:让炸弹根本走不到你的机器
代码层的防线是最后一道,前面还能加两道:
- 边缘层:Nginx 的
client_max_body_size限制请求体,同时关掉gunzip相关模块(Nginx 默认不会自动解压,但如果你开了http_gzip_static或某些安全产品的自动解压,要确认)。 - 网关层:把解压上限和压缩比作为网关的通用策略,而不是每个业务方自己实现一遍。安全事故的根因永远是"某个新人没看文档"。
- 隔离层:真正需要处理大文件的服务,单独拆出去跑在限制内存的容器里,被打爆了也炸不到主链路。
# Nginx:限制原始请求体(注意这是压缩后的大小)
client_max_body_size 1m;
client_body_buffer_size 64k;
# 解压后的大小上限靠应用层做,Nginx 层管不到
# 所以:Nginx 挡粗粒度,应用挡精确值
说说我的观点
我去年review过一个团队的后端代码,满仓库搜 gunzip,搜出来三处,两处是 io.ReadAll。当时我以为要吵一架,结果对方回了一句"我们网关限了 1MB 就够了"。
问题是:网关限的是压缩体。1 MB 的压缩体可以撑出 1 GB 的解压体,网关限一万次也没用。
这就是我想说的核心观点:安全边界必须建立在"资源真正消耗的那个量"上。你限制的是字节数、还是解压后的字节数、还是 CPU 时间?限制错了维度,后面所有的努力都是自我感动。
同样的道理适用于很多场景:限制的是请求数还是并发数?是文件大小还是解压比?是队列长度还是队列里的对象大小?凡是"输入量"和"资源消耗量"不等价的地方,就是攻击面的缝。
至于防御的成本——说实话一点都不高。核心就三行:流式解压 + LimitedReader + 压缩比告警。半小时的活,能省掉一次凌晨三点的电话。
如果要我再补一句:别忘了限制"解压层数"。只解一层是最省事的做法;如果业务真的需要嵌套压缩(比如 tar.gz.gz),那就显式声明允许几层,并且逐层单独限额,而不是让库自己去猜。
炸弹的本质不是压缩比高,而是"无限的指数空间"。你的防御,本质上就是给指数画一条线。
一句话总结:限制压缩体大小是防身,限制解压后大小才是防弹。永远在流里限,永远别在内存里算账。