第 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 --version
gzip-member-drift-lab/
├── member_layout.py
├── codec_probe.py
├── bytecode_probe.py
├── http_service.py
├── request_probe.py
└── evidence_report.py

member_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"&note=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 就足以改变请求的实际含义。

资料来源