From c227bf0421cfed14a0fcf404b1ca93c6f1450507 Mon Sep 17 00:00:00 2001 From: Thomas Durieux <5577568+tdurieux@users.noreply.github.com> Date: Sat, 14 Nov 2026 12:55:17 +0000 Subject: [PATCH] fix: isolate streamer headers and reject download redirects --- src/core/AnonymizedFile.ts | 20 +++---- src/core/response-stream.ts | 11 ++-- src/core/streamer-cache-probe.ts | 6 ++- src/core/streamer-response.ts | 12 +++++ test/streamer-redirect-security.test.js | 70 +++++++++++++++++++++++++ 5 files changed, 105 insertions(+), 14 deletions(-) create mode 100644 src/core/streamer-response.ts create mode 100644 test/streamer-redirect-security.test.js diff --git a/src/core/AnonymizedFile.ts b/src/core/AnonymizedFile.ts index 2c96be7..1d5cc3c 100644 --- a/src/core/AnonymizedFile.ts +++ b/src/core/AnonymizedFile.ts @@ -1,3 +1,4 @@ +import { rejectStreamerRedirects } from "./streamer-response"; import { isResponseCancellation } from "./response-cancellation"; import { canReadCachedRepository } from "./cached-repository-access"; import { probeStreamerCache } from "./streamer-cache-probe"; @@ -412,7 +413,8 @@ export default class AnonymizedFile { } // use the streamer service - const content = got.stream(join(config.STREAMER_ENTRYPOINT, "api"), { + const content = rejectStreamerRedirects(got.stream(join(config.STREAMER_ENTRYPOINT, "api"), { + followRedirect: false, method: "POST", headers: requestHeaders(), json: { @@ -429,7 +431,7 @@ export default class AnonymizedFile { size: await this.size(), anonymizerOptions: anonymizer.opt, }, - }); + })); content.on("error", err => { const { error } = streamerErrorToAnonymous(err, { repoId: this.repository.repoId, filePath: this.anonymizedPath }); void notifyOwnerAccessProblem(this.repository.owner.id, error, { kind: "repository", id: String(this.repository.model._id) }); @@ -504,17 +506,17 @@ export default class AnonymizedFile { } catch (error) { cached.stream.destroy(); throw error; } } if (res.destroyed || res.writableEnded) { cached?.stream.destroy(); headersDone(); resolve(); return; } - const resStream = cached?.stream || got.stream(url, { + const resStream = cached?.stream || rejectStreamerRedirects(got.stream(url, { + followRedirect: false, method: "POST", headers, decompress: false, json: { ...payload, token: await githubTokenForStreamer(await this.repository.getToken(), this.repository.model.source.repositoryName) }, - }); + })); // Forward Content-Type from the streamer's upstream response. - // got.stream(...).pipe(res) forwards body bytes only — without - // this, the parent response has no Content-Type and the browser - // guesses (text renders as download, images as octet-stream). - const forwardHeaders = (upstream: { headers: Record }) => { + // streamResponse isolates the body from Got's implicit header forwarding. + // Only approved content headers may reach the public response. + const forwardHeaders = (upstream: { statusCode?: number; headers: Record }) => { headersDone(); - if (res.headersSent) return; + if (res.headersSent || (upstream.statusCode !== undefined && upstream.statusCode !== 200)) return; for (const header of ["content-encoding", "content-length", "vary", "accept-ranges"]) { const value = upstream.headers[header]; if (typeof value === "string") res.setHeader(header, value); diff --git a/src/core/response-stream.ts b/src/core/response-stream.ts index 75bb18c..470317b 100644 --- a/src/core/response-stream.ts +++ b/src/core/response-stream.ts @@ -1,15 +1,20 @@ -import { Readable, Writable } from "stream"; +import { PassThrough, Readable, Writable } from "stream"; /** Cancel upstream on every response terminal event, including a pre-header close. */ export function streamResponse(source: Readable, response: Writable, onError: (error: Error) => void): Promise { return new Promise((resolve, reject) => { + // Got copies every upstream header/status when piped to ServerResponse. + // A plain stream keeps response policy with the caller's explicit allowlist. + const body = new PassThrough(); const cleanup = () => { response.removeListener("close", done); response.removeListener("finish", done); response.removeListener("error", failed); source.removeListener("error", upstreamFailed); - source.unpipe(response); + source.unpipe(body); + body.unpipe(response); + body.destroy(); source.destroy(); }; const done = () => { cleanup(); resolve(); }; @@ -22,6 +27,6 @@ export function streamResponse(source: Readable, response: Writable, if (response.destroyed || response.writableEnded) done(); else if (source.errored) upstreamFailed(source.errored); else if (source.destroyed || source.readableEnded) upstreamFailed(new Error("upstream_stream_closed")); - else source.pipe(response); + else { body.pipe(response); source.pipe(body); } }); } diff --git a/src/core/streamer-cache-probe.ts b/src/core/streamer-cache-probe.ts index eb2d1d1..7eafb2c 100644 --- a/src/core/streamer-cache-probe.ts +++ b/src/core/streamer-cache-probe.ts @@ -1,9 +1,10 @@ +import { rejectStreamerRedirects } from "./streamer-response"; import got, { Response } from "got"; /** Wait only for headers; the body remains a backpressured stream. */ export async function probeStreamerCache(url: string, json: Record, headers: Record, signal?: AbortSignal) { - const stream = got.stream(url, { method: "POST", json: { ...json, token: "", cacheOnly: true }, - headers, timeout: { response: 15000 }, decompress: false }); + const stream = rejectStreamerRedirects(got.stream(url, { followRedirect: false, method: "POST", json: { ...json, token: "", cacheOnly: true }, + headers, timeout: { response: 15000 }, decompress: false })); const responseReady = new Promise((resolve, reject) => { stream.once("response", resolve); stream.once("error", reject); @@ -14,6 +15,7 @@ export async function probeStreamerCache(url: string, json: Record(stream: T): T { + stream.on("response", (response: { statusCode: number }) => { + if (response.statusCode >= 300 && response.statusCode < 400) { + stream.destroy(new AnonymousError("streamer_upstream_error", { httpStatus: 502 })); + } + }); + return stream; +} diff --git a/test/streamer-redirect-security.test.js b/test/streamer-redirect-security.test.js new file mode 100644 index 0000000..f4875c7 --- /dev/null +++ b/test/streamer-redirect-security.test.js @@ -0,0 +1,70 @@ +const { expect } = require("chai"); +const http = require("node:http"); +const got = require("got"); +require("ts-node/register/transpile-only"); +const { streamResponse } = require("../src/core/response-stream"); +const { rejectStreamerRedirects } = require("../src/core/streamer-response"); +const { probeStreamerCache } = require("../src/core/streamer-cache-probe"); + +describe("streamer response isolation", function () { + const servers = []; + async function serve(handler) { + const server = http.createServer(handler); + servers.push(server); + await new Promise(resolve => server.listen(0, "127.0.0.1", resolve)); + return `http://127.0.0.1:${server.address().port}`; + } + afterEach(async () => { + await Promise.all(servers.splice(0).map(server => new Promise(resolve => { + server.close(resolve); + server.closeAllConnections(); + }))); + }); + + it("does not let Got copy identity-bearing upstream headers or status", async () => { + const upstream = await serve((_req, res) => { + res.writeHead(201, { + Location: "https://github.com/private-owner/private-repository", + Refresh: "0; url=https://github.com/private-owner/private-repository", + "Content-Location": "/private-owner/private-repository", + Link: "; rel=canonical", + "Set-Cookie": "owner=private-owner", + "Content-Disposition": "attachment; filename=private-owner.zip", + }); + res.end("anonymized content"); + }); + const proxy = await serve((_req, res) => { + res.setHeader("Content-Type", "text/plain"); + void streamResponse(got.stream(upstream), res, () => res.end("error")); + }); + const result = await got(proxy); + expect(result.statusCode).to.equal(200); + expect(result.body).to.equal("anonymized content"); + for (const header of ["location", "refresh", "content-location", "link", "set-cookie", "content-disposition"]) { + expect(result.headers).not.to.have.property(header); + } + }); + + for (const status of [301, 302, 303, 307, 308]) { + it(`rejects ${status} without forwarding its body or contacting the destination`, async () => { + let contacted = 0; + const target = await serve((_req, res) => { contacted++; res.end("private-owner"); }); + const upstream = await serve((_req, res) => { + res.writeHead(status, { Location: target + "/private-owner/private-repository" }); + res.end("private-owner/private-repository"); + }); + const proxy = await serve((_req, res) => { + const source = rejectStreamerRedirects(got.stream(upstream, { followRedirect: false })); + void streamResponse(source, res, () => { res.statusCode = 502; res.end("upstream_error"); }); + }); + const result = await got(proxy, { throwHttpErrors: false, retry: 0 }); + expect(result.statusCode).to.equal(502); + expect(result.body).to.equal("upstream_error"); + expect(result.headers).not.to.have.property("location"); + let failure; + try { await probeStreamerCache(upstream, {}, {}); } catch (error) { failure = error; } + expect(failure).to.be.instanceOf(Error); + expect(contacted).to.equal(0); + }); + } +});