Go stream流式文件上传漏洞复现（CVE-2023-XXXXX级Content-Length绕过攻击链）

第一章：Go stream流式文件上传漏洞背景与影响分析

Go语言中基于http.Request.Body的流式文件上传处理模式，常被用于大文件直传、分片合并或实时内容解析等场景。然而，当开发者未对请求体的边界、长度及内容类型进行严格校验时，攻击者可构造恶意HTTP请求绕过常规MIME检测，触发服务端内存耗尽、临时文件写入任意路径，甚至远程代码执行。

常见风险成因包括：

• 忽略Content-Length与实际读取字节数的一致性校验
• 使用io.Copy或ioutil.ReadAll无限制读取未验证的Request.Body
• 依赖multipart.Reader.NextPart()但未设置单Part大小上限
• 将原始*multipart.FileHeader.Filename直接拼接至本地路径（如os.Create("./uploads/" + fh.Filename)），导致路径遍历

以下为存在风险的典型代码片段：

func uploadHandler(w http.ResponseWriter, r *http.Request) {
    r.ParseMultipartForm(32 << 20) // 仅限制form内存，不约束单文件大小
    file, header, _ := r.FormFile("file") // 未校验header.Size或header.Header.Get("Content-Type")
    defer file.Close()

    dst, _ := os.Create("./uploads/" + header.Filename) // 危险：未净化文件名
    io.Copy(dst, file) // 若攻击者上传超大文件，将耗尽磁盘/内存
}

该漏洞的实际影响呈多维度扩散：	影响类型	表现形式	典型后果
服务可用性	持续上传超大流式Body	goroutine阻塞、OOM Killer触发
文件系统安全	../etc/passwd类恶意文件名	敏感配置覆盖或泄露
逻辑越权	上传.so/.dylib并被plugin.Open加载	服务端任意代码执行

修复核心原则是“早校验、严截断、硬隔离”：在ParseMultipartForm前检查Content-Length是否在合理阈值内（如≤100MB）；使用filepath.Clean与白名单扩展名双重过滤文件名；通过io.LimitReader(file, maxFileSize)强制限制单文件读取上限。

第二章：Go HTTP流式处理机制深度解析

2.1 Go net/http 中 Request.Body 的流式读取原理与内存模型

Request.Body 是 io.ReadCloser 接口实例，底层通常为 *http.body，封装了带缓冲的网络字节流（如 *bufio.Reader）与连接生命周期管理。

数据同步机制

Body 读取不预加载全部请求体，而是按需从 TCP 连接缓冲区拉取数据，避免内存暴涨：

// 示例：流式读取并限制单次最大字节数
buf := make([]byte, 4096)
n, err := req.Body.Read(buf) // 阻塞直到有数据或 EOF
// buf[:n] 即本次读取的有效字节；err == io.EOF 表示流结束

Read() 调用触发底层 conn.Read()，经 bufio.Reader 缓冲层中转；若缓冲区为空，则阻塞等待 TCP 数据到达。

内存布局关键点

组件	作用	生命周期
bufio.Reader	提供带缓冲的读取，减少系统调用	与 Request.Body 同寿
net.Conn	底层 TCP 连接句柄	受 http.Server 连接池管理
body.bytes	仅用于小请求体（	一次性使用，读完即丢弃

graph TD
    A[req.Body.Read] --> B{bufio.Reader 缓冲区是否有数据？}
    B -->|是| C[直接拷贝到用户 buf]
    B -->|否| D[调用 conn.Read 填充缓冲区]
    D --> C

2.2 multipart/form-data 解析流程中的边界判定与缓冲策略实践

边界识别的双重校验机制

multipart/form-data 的核心在于 boundary 字符串的精准定位。解析器需同时满足：

• 行首匹配 --{boundary} 或 --{boundary}--
• 行尾为 \r\n（CRLF）且不可被缓冲截断

动态缓冲区管理策略

为避免小块数据导致频繁系统调用，采用三级缓冲：

• 预读缓冲区（4KB）：暂存原始字节流
• 边界探测窗口（128B）：滑动扫描潜在 boundary 起始位置
• 字段载荷缓冲区（按 Content-Length 预分配或动态扩容）

边界判定状态机（mermaid）

graph TD
    A[Start] --> B{Buffer contains \\r\\n?}
    B -->|Yes| C[Scan for --boundary]
    C --> D{Match full boundary?}
    D -->|Yes| E[Enter HEADER parsing]
    D -->|No| F[Slide window + continue]

关键代码片段（Rust 片段）

// 滑动窗口边界探测逻辑
fn find_boundary(buf: &[u8], boundary: &[u8]) -> Option<usize> {
    let mut i = 0;
    while i + boundary.len() <= buf.len() {
        if &buf[i..i + boundary.len()] == boundary {
            // 确保前导为 CRLF 或起始边界标记
            if i == 0 || buf[i - 1] == b'\n' || buf[i - 2..i] == [b'\r', b'\n'] {
                return Some(i);
            }
        }
        i += 1;
    }
    None
}

逻辑分析：该函数在连续字节流中定位 boundary 起始偏移；参数 buf 为当前缓冲区快照，boundary 为已解析出的分隔字符串（不含 -- 前缀）；返回 Some(pos) 表示可安全切分新 part，否则继续累积输入。

缓冲策略	触发条件	典型大小	风险控制
静态预读	HTTP header 未结束	2KB	防止 header 截断
动态扩容	part body > 64KB	指数增长至 1MB	避免 OOM
零拷贝转发	Content-Transfer-Encoding: binary	直接 mmap	减少内存复制

2.3 Content-Length 头在 Go 标准库中的校验逻辑与绕过触发点

Go 的 net/http 包在 readRequest 阶段对 Content-Length 进行双重校验：先解析头字段，再与实际读取字节数比对。

校验触发路径

• 解析阶段调用 parseContentLength，仅接受非负整数（含 ）；
• 实际读取时通过 body.read() 触发 maxBytesReader 限流器拦截超长体。

绕过关键点

// src/net/http/request.go 片段（简化）
func (r *Request) parseContentLength() {
    s := r.Header.Get("Content-Length")
    n, err := strconv.ParseInt(s, 10, 64) // 允许前导空格、无符号数字
    if err != nil || n < 0 {               // ❗但不拒绝 " 0" 或 "+0"
        r.ContentLength = -1 // 标记为无效，降级为 chunked
    }
}

该逻辑未标准化 trim 和符号处理，导致 " +0" 被解析为 ，而 " 0" 因 ParseInt 自动 trim 成功解析——但若服务端后续依赖 r.ContentLength >= 0 判断是否读体，可能跳过读取，造成请求体残留污染后续连接。

输入值	ParseInt 结果	ContentLength 值	是否触发 body 读取
"0"	0	0	否（空体，跳过）
" 0"	0	0	否
"+0"	0	0	否
"-1"	error	-1	是（chunked fallback）

graph TD
    A[收到 HTTP 请求] --> B{解析 Content-Length 头}
    B --> C["ParseInt(s, 10, 64)"]
    C --> D{err != nil ∥ n < 0?}
    D -->|是| E[r.ContentLength = -1]
    D -->|否| F[r.ContentLength = n]
    F --> G{n == 0?}
    G -->|是| H[跳过 body.Read()]
    G -->|否| I[按指定长度读取]

2.4 Go 1.20+ 中 io.LimitReader 与 http.MaxBytesReader 的安全语义差异实验

核心差异：错误传播时机与 HTTP 协议感知

io.LimitReader 是通用字节流截断器，而 http.MaxBytesReader 是 HTTP 专用限流器——后者在超出限制时立即返回 http.ErrBodyReadAfterClose 并关闭底层连接，防止请求体残留引发的协议级重放或状态混淆。

行为对比实验

// 实验：相同 100B 限制下对恶意超长 POST body 的响应差异
limitR := io.LimitReader(body, 100)
maxR := http.MaxBytesReader(nil, body, 100)

• LimitReader.Read() 在第 101 字节返回 io.EOF，不干预连接生命周期；
• MaxBytesReader.Read() 在第 101 字节返回 http.ErrBodyReadAfterClose，并标记 conn.hijacked = true。

特性	io.LimitReader	http.MaxBytesReader
错误类型	io.EOF	http.ErrBodyReadAfterClose
连接是否强制中断	否	是（触发 conn.close()）
是否记录审计日志	否	是（http: request body too large）

graph TD
    A[HTTP 请求到达] --> B{读取 body}
    B --> C[MaxBytesReader 检查长度]
    C -->|≤ limit| D[正常解析]
    C -->|> limit| E[返回 400 + 关闭 conn]

2.5 基于 httptest.Server 的可控流式请求构造与响应时序观测

httptest.Server 不仅可模拟 HTTP 服务，更能精确控制响应写入节奏，实现流式传输与毫秒级时序观测。

流式响应构造示例

srv := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/event-stream")
    w.WriteHeader(200)
    flusher, _ := w.(http.Flusher)
    for i := 0; i < 3; i++ {
        fmt.Fprintf(w, "data: message %d\n\n", i)
        flusher.Flush() // 强制刷新，暴露真实写入时序
        time.Sleep(100 * time.Millisecond) // 精确控制间隔
    }
}))
srv.Start()

NewUnstartedServer 允许手动启停以捕获启动瞬间；Flush() 触发底层 TCP 包发送，使客户端能按预期时间点接收分块数据；time.Sleep 实现微秒/毫秒粒度的响应节拍控制。

时序观测关键维度

维度	工具/方法	用途
连接建立延迟	http.Transport.DialContext	捕获 TCP 握手耗时
首字节时间	http.Response.TLS.HandshakeComplete	精确到 TLS 完成时刻
分块到达间隔	客户端 bufio.Scanner + time.Now()	逐行打点，构建响应时间序列

请求流控逻辑

graph TD
    A[Client发起长连接] --> B[Server写入chunk-0]
    B --> C[Flush → OS缓冲区]
    C --> D[TCP栈发送]
    D --> E[Client recv → 记录t1]
    E --> F[Server写入chunk-1]
    F --> G[Flush]
    G --> H[Client recv → 记录t2]

第三章：CVE-2023-XXXXX 攻击链建模与关键路径验证

3.1 Content-Length 绕过触发条件的静态代码审计（net/http + mime/multipart）

核心触发路径

net/http 在 ServeHTTP 中依赖 Content-Length 或 Transfer-Encoding 判断请求体边界；若两者缺失或矛盾，multipart.Reader 可能回退至 io.LimitReader 的隐式截断逻辑。

关键代码片段

// src/net/http/request.go:1205（Go 1.22）
if r.ContentLength == 0 || r.ContentLength == -1 {
    r.Body = http.MaxBytesReader(r.Body, r.Body, maxBodySize)
}

→ maxBodySize 默认为 10MB，但 mime/multipart.NewReader(r.Body, boundary) 不校验 Content-Length 与实际流长度一致性，导致解析器在读取完声明长度后仍尝试继续读取——若底层 r.Body 未正确 EOF，将触发二次解析或 panic。

触发条件归纳

• 请求头中 Content-Length 被恶意设为较小值（如 1024）
• 实际 multipart body 远超该值且含多个 part
• boundary 解析未受长度约束，持续消费后续字节

条件类型	是否必需	说明
Content-Length 存在且偏小	是	触发 LimitReader 截断
multipart/form-data 格式	是	启用 mime/multipart 解析
boundary 字符串可被复用	否	影响绕过深度，非必要条件

3.2 分块传输混淆与双 Content-Length 头注入的实操复现

分块传输编码（Chunked Transfer Encoding）与 Content-Length 头存在协议层互斥性，但部分代理或后端未严格校验，导致可构造歧义请求。

混淆请求构造要点

• 发送 Transfer-Encoding: chunked 同时携带两个 Content-Length 头
• 第一个 Content-Length 被前端解析，第二个被后端采纳，造成长度预期错位

POST /api/echo HTTP/1.1
Host: target.com
Content-Length: 42
Content-Length: 0
Transfer-Encoding: chunked

7
hello\r\n
0\r\n\r\n

逻辑分析：首行 Content-Length: 42 可能被 WAF 或 CDN 截断为 42 字节；第二行 Content-Length: 0 被后端 Tomcat/Nginx（配置不当）优先读取，导致忽略后续 chunked 数据，使 hello 绕过长度校验进入业务逻辑。参数 7 为 chunk size（十六进制），\r\n 为分隔符，0\r\n\r\n 表示结束。

常见中间件响应差异

中间件	优先解析头	是否触发歧义
Nginx (默认)	Content-Length	否（拒绝双头）
Apache 2.4	后出现的 Content-Length	是
Envoy v1.25	Transfer-Encoding	是（若开启宽松解析）

graph TD
    A[客户端发送双CL+chunked] --> B{前端设备}
    B -->|取首个CL=42| C[截断/限流]
    B -->|后端取第二个CL=0| D[跳过body解析]
    D --> E[chunked payload被后端HTTP解析器执行]

3.3 流式上传过程中文件落地前的内存驻留劫持技术验证

在 multipart/form-data 解析阶段，文件流尚未写入磁盘，仍驻留在 HttpServletRequest 的缓冲区或临时 InputStream 中，此时可通过 Servlet Filter 或 Spring ContentCachingRequestWrapper 劫持原始字节流。

内存驻留点定位

• Apache Commons FileUpload：FileItemStream.openStream() 返回 DeferredFileOutputStream 的内存缓冲区
• Spring Boot 3.x：StandardMultipartHttpServletRequest 默认使用 MemoryThreshold（默认0）触发内存缓存

关键劫持代码示例

// 获取未落盘的原始流（绕过 MultipartFile 封装）
InputStream raw = request.getInputStream(); // 非缓冲流，需一次读取
byte[] buffer = new byte[8192];
int len;
ByteArrayOutputStream captured = new ByteArrayOutputStream();
while ((len = raw.read(buffer)) != -1) {
    captured.write(buffer, 0, len); // 实时捕获全部上传内容
}

逻辑分析：request.getInputStream() 直接访问容器底层 InputBuffer，避免 MultipartResolver 的自动磁盘转储。buffer 大小需匹配 Tomcat maxSwallowSize（默认2MB），防止截断；captured 即为完整内存驻留镜像。

技术路径	是否可劫持内存流	触发条件
HttpServletRequest.getInputStream()	✅ 是	任意 multipart 请求
MultipartFile.getBytes()	❌ 否（已落盘）	fileSizeThreshold > 0

graph TD
    A[客户端POST multipart] --> B{Servlet容器解析}
    B --> C[内存缓冲区<br>（< threshold）]
    B --> D[临时磁盘文件<br>（≥ threshold）]
    C --> E[劫持成功：raw.getInputStream()]
    D --> F[劫持失败：仅能读取已写入文件]

第四章：漏洞利用工程化与防御加固实践

4.1 构建可复现的 PoC：go-fuzz 驱动的畸形 multipart 边界变异器

为精准触发 net/http 中 multipart 解析器的边界条件漏洞，需生成高度可控的畸形 boundary 字符串。go-fuzz 提供覆盖率引导的变异能力，但原生不理解 multipart 协议语义，因此需定制 Consumer 函数注入协议感知逻辑。

核心变异策略

• 优先变异 boundary 值中的控制字符（\r, \n, \0, \t）
• 插入非 ASCII Unicode 分隔符（如 —, ・, ︳）干扰解析状态机
• 强制构造超长 boundary（>2048 字节）触发缓冲区处理异常

fuzz.go 片段示例

func Fuzz(data []byte) int {
    // 注入合法 multipart 头 + 可控 boundary 变异体
    payload := fmt.Sprintf(
        "POST /upload HTTP/1.1\r\n"+
            "Content-Type: multipart/form-data; boundary=%s\r\n\r\n"+
            "--%s\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\nDATA\r\n--%s--",
        string(data), string(data), string(data),
    )
    req, _ := http.ReadRequest(bufio.NewReader(strings.NewReader(payload)))
    parseMultipart(req.Body) // 目标解析函数
    return 1
}

逻辑分析：data 直接作为 boundary 值嵌入三处——起始分隔符、字段分隔符、结束分隔符。go-fuzz 将对 data 进行字节级变异，而 parseMultipart 的 panic 将被捕获为 crash；关键参数 string(data) 避免空字符串导致语法错误，确保变异始终落在协议有效域内。

常见触发边界模式

变异类型	示例值	触发缺陷位置
换行注入	abc\r\n--def	mime/multipart 状态机跳转
空字节截断	abc\x00def	bytes.Index 返回 -1 未检查
超长混淆	A...A（2050×）	bufio.Scanner 缓冲溢出

graph TD
    A[go-fuzz 启动] --> B[生成随机字节切片]
    B --> C{是否含控制字符？}
    C -->|是| D[提升变异权重]
    C -->|否| E[插入 \r\n\0 概率+30%]
    D --> F[构造 multipart payload]
    E --> F
    F --> G[调用 parseMultipart]
    G --> H{panic？}
    H -->|是| I[保存 crash 输入]

4.2 利用 go tool trace 分析异常流读取导致的 goroutine 阻塞与资源耗尽

当 HTTP handler 中未设置 ReadTimeout 且持续接收不完整请求体时，net/http 底层会阻塞在 conn.read()，引发 goroutine 泄漏。

触发场景复现

func handler(w http.ResponseWriter, r *http.Request) {
    // ❌ 危险：无边界读取，客户端中断连接后 goroutine 永久阻塞
    io.Copy(io.Discard, r.Body) // 实际中可能为 json.Decoder.Decode()
}

io.Copy 内部调用 r.Body.Read()，若 TCP 连接半关闭或数据流异常中断，read 系统调用将无限等待（默认无超时），goroutine 状态为 IO wait 并持续占用栈内存。

trace 关键指标识别

事件类型	trace 中表现	含义
Goroutine blocked	blocking on chan receive	误判；实际应关注 network poller
Syscall	长时间 read syscall	真实阻塞点

资源耗尽链路

graph TD
    A[客户端发送不完整 POST] --> B[server read() 阻塞]
    B --> C[goroutine 状态：IO wait]
    C --> D[堆积数百 goroutine]
    D --> E[内存增长 + GOMAXPROCS 竞争加剧]

4.3 基于中间件的流式上传安全网关：Content-Length 一致性校验与 early-reject 实现

在高并发文件上传场景中，攻击者常伪造 Content-Length 头部以触发缓冲区溢出或绕过大小限制。安全网关需在请求体读取前完成一致性校验。

核心校验策略

• 解析 Transfer-Encoding: chunked 与 Content-Length 的互斥性
• 对非分块请求，立即比对头部声明值与实际可读字节数（通过 req.socket.bytesRead 预估）
• 发现偏差 > 1024 字节时触发 early-reject

early-reject 实现（Node.js 中间件片段）

app.use((req, res, next) => {
  if (req.method !== 'POST' || !req.headers['content-length']) return next();
  const declared = parseInt(req.headers['content-length'], 10);
  // 在 socket data 事件首次触发前校验（利用 req.socket.readableFlowing === null）
  req.socket.once('data', (chunk) => {
    const actual = req.socket.bytesRead;
    if (Math.abs(actual - declared) > 1024) {
      res.writeHead(400, { 'Connection': 'close' });
      res.end('Content-Length mismatch');
      req.destroy(); // 彻底中断连接，防止后续数据注入
      return;
    }
  });
  next();
});

该逻辑在 TCP 层数据抵达瞬间拦截异常请求，避免应用层解析开销。req.destroy() 确保内核连接立即释放，而非等待超时。

校验决策矩阵

场景	declared	bytesRead	动作
正常上传	5242880	5242880	放行
头部篡改	1048576	5242880	early-reject
分块传输	—	—	跳过校验

graph TD
  A[接收 HTTP 请求] --> B{存在 Content-Length？}
  B -->|否| C[检查 Transfer-Encoding]
  B -->|是| D[注册 socket.data 监听]
  D --> E[首次 data 到达]
  E --> F[计算 bytesRead 与 declared 差值]
  F -->|>1024| G[400 + close]
  F -->|≤1024| H[继续管道处理]

4.4 使用 io.MultiReader + io.TeeReader 实现带审计日志的透明流代理层

在构建可观察的流式代理时，io.TeeReader 负责将读取内容实时镜像到审计日志（如 io.Writer），而 io.MultiReader 支持按序拼接多个源流，实现请求头/体/尾的分段审计与动态注入。

核心组合逻辑

// 构建审计感知的读取器链：原始流 → 日志镜像 → 多源聚合
auditWriter := newAuditLogger() // 实现 io.Writer，记录时间戳、长度、前128字节摘要
tee := io.TeeReader(src, auditWriter)
proxyReader := io.MultiReader(
    headerInjector(), // 注入审计元数据头
    tee,              // 主体流 + 同步写入日志
    footerAppender(), // 追加校验尾
)

io.TeeReader(r, w) 在每次 Read(p) 时先调用 w.Write(p[:n])，再返回 n；io.MultiReader(rs...) 按顺序消费每个 io.Reader，任一返回 io.EOF 即切换至下一个。

审计能力对比表

特性	纯 TeeReader	MultiReader + TeeReader 组合
多源有序拼接	❌	✅
请求头/体/尾分离审计	❌	✅
零拷贝日志镜像	✅	✅

graph TD
    A[Client Read] --> B[TeeReader]
    B --> C[Upstream Body]
    B --> D[AuditWriter]
    E[Header Injector] --> F[MultiReader]
    B --> F
    G[Footer Appender] --> F
    F --> H[Proxy Response]

第五章：从流式上传漏洞看 Go Web 安全演进趋势

流式上传的典型脆弱实现

许多基于 net/http 的 Go 服务直接使用 r.Body 进行无缓冲读取，例如：

func uploadHandler(w http.ResponseWriter, r *http.Request) {
    defer r.Body.Close()
    buf := make([]byte, 1024*1024)
    for {
        n, err := r.Body.Read(buf)
        if n > 0 {
            processChunk(buf[:n]) // 未校验 Content-Length，也未设超时
        }
        if err == io.EOF {
            break
        }
    }
}

该代码缺失三重防护：未限制总上传大小、未设置读取超时、未校验 Content-Length 头是否与实际一致，极易被构造超长恶意流触发 OOM 或 DoS。

CVE-2023-37892：multipart.MaxMemory 误用导致内存绕过

Go 标准库 mime/multipart 自 1.20 起引入 MaxMemory 参数，但大量项目错误地将其设为 或 math.MaxInt64，导致所有上传数据被加载至内存。真实案例中，某金融后台 API 因配置 parser.ParseForm(0)，攻击者发送 2GB 分块 multipart 请求（含伪造 Content-Length: 2147483647），成功耗尽 16GB 容器内存并触发 Kubernetes OOMKilled。

风险配置	实际影响	推荐值
MaxMemory = 0	全部 body 内存缓存	32 << 20（32MB）
ParseMultipartForm(0)	禁用内存限制	time.Second * 30 + 32 << 20
未调用 r.MultipartReader()	触发隐式 ParseMultipartForm	显式调用并设限

防御方案的工程落地路径

现代 Go Web 框架已内建防御层。以 Gin 为例，需显式启用：

r := gin.Default()
r.MaxMultipartMemory = 32 << 20 // 强制内存上限
r.Use(func(c *gin.Context) {
    if c.Request.ContentLength > 100<<20 { // 预检头长度
        c.AbortWithStatusJSON(http.StatusRequestEntityTooLarge, gin.H{"error": "file too large"})
        return
    }
    c.Next()
})

同时配合中间件进行流式校验：解析 multipart/form-data boundary 后，对每个 Part 调用 part.Size 并累计，一旦超过阈值立即关闭连接。

安全演进的关键拐点

早期 Go Web 项目依赖开发者手动实现边界控制；1.19 版本起，http.MaxBytesReader 成为标准防护手段；1.21 新增 http.Request.WithContext 的上下文传播增强，使超时可穿透至底层 io.Reader；而 2024 年社区主流实践已转向 io.LimitReader + context.WithTimeout 双重封装：

flowchart LR
A[Client Upload] --> B{http.MaxBytesReader}
B --> C[context.WithTimeout]
C --> D[io.LimitReader]
D --> E[Custom Validation]
E --> F[Safe Chunk Processing]

生产环境检测清单

• 所有 http.Handler 必须在 ServeHTTP 开头注入 http.MaxBytesReader
• multipart.Reader 初始化前必须校验 Content-Length 和 Content-Type 头一致性
• 使用 pprof 监控 /debug/pprof/heap 中 multipart.Part 对象数量突增
• CI/CD 流水线集成 go-vulncheck 扫描 net/http 和 mime/multipart 版本兼容性
• 对接 WAF 时禁用 multipart 自动解析，交由 Go 应用层统一管控

历史漏洞复现验证方法

构建最小 PoC 需三步：首先用 Python 生成超长分块请求：

import requests
boundary = "----WebKitFormBoundaryabc123"
headers = {"Content-Type": f"multipart/form-data; boundary={boundary}"}
data = f"--{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"poc.bin\"\r\n\r\n" + "A" * 50000000 + "\r\n--" + boundary + "--\r\n"
requests.post("http://target/upload", headers=headers, data=data)

随后通过 kubectl top pod 观察内存增长速率，结合 strace -p $(pgrep -f 'your-app') -e trace=read,write 确认未受控的 read() 系统调用持续发生。