fix(producer): accept browser requests only under loopback, IP or listed host names (#7798)

* fix(producer): accept browser requests only under loopback, IP or listed host names

The standalone render server now refuses a browser request (one carrying Origin or
Sec-Fetch-Site) whose Host or Origin names anything other than an IP address,
localhost, a *.localhost name, or a host listed in the new allowedHosts option or
the comma-separated PRODUCER_ALLOWED_HOSTS variable. A same-origin verdict from
Sec-Fetch-Site no longer lets an unlisted name through. Requests without those
headers (curl, server-to-server) behave as before, and the bind address is
unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(producer): trim host-check comments to the package comment budget

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
James Russo
2026-11-15 02:49:56 +00:00
committed by GitHub
co-authored by Claude Opus 5.5
parent 2de5c027fa
commit 03e6a1a180
4 changed files with 153 additions and 7 deletions
+7
View File
@@ -188,6 +188,13 @@ import { startServer } from "@hyperframes/producer";
await startServer({ port: 8080 });
```
A browser request (one that carries an `Origin` or `Sec-Fetch-Site` header) is accepted
only under an IP address, `localhost` or a `*.localhost` name, so a page that points its
own domain at the server cannot start renders or lint. If browsers reach the server
through a proxy name, list that name in `allowedHosts` or in the comma-separated
`PRODUCER_ALLOWED_HOSTS` variable. Requests without those headers, such as curl or
another service, are unaffected.
For larger workloads, the `@hyperframes/producer/distributed` entry exposes the
three rendering activities—`plan`, `renderChunk`, and `assemble`. Your
orchestrator remains responsible for dispatch, retries, storage, and networking.
+7
View File
@@ -38,6 +38,13 @@ await startServer({ port: 8080 });
// POST /render or /render/stream with projectDir, html, or previewUrl (public HTTPS only) and render options
```
A browser request (one that carries an `Origin` or `Sec-Fetch-Site` header) is accepted
only under an IP address, `localhost` or a `*.localhost` name, so a page that points its
own domain at the server cannot start renders or lint. If browsers reach the server
through a proxy name, list that name in `allowedHosts` or in the comma-separated
`PRODUCER_ALLOWED_HOSTS` variable. Requests without those headers, such as curl or
another service, are unaffected.
Both HTTP routes accept optional `pageMotionBlur: "off"` to disable authored page
motion blur. Omit it to preserve the composition's behavior. Other explicit values
are rejected before a render starts. This is separate from engine sub-frame
@@ -22,10 +22,10 @@ vi.mock("./services/renderOrchestrator.js", () => {
};
});
import { createProducerApp } from "./server.js";
import { createProducerApp, type HandlerOptions } from "./server.js";
function postRender(headers: Record<string, string>) {
return createProducerApp().request("http://localhost:9847/render", {
function postRender(headers: Record<string, string>, options: HandlerOptions = {}) {
return createProducerApp(options).request("http://localhost:9847/render", {
method: "POST",
headers: { host: "localhost:9847", ...headers },
body: JSON.stringify({ html: "<html><body></body></html>" }),
@@ -58,12 +58,88 @@ describe("createProducerApp: cross-origin browser requests", () => {
it.each([
["no Origin (curl, server-to-server)", {}],
["a same-origin page", { origin: "http://localhost:9847" }],
[
"a same-origin page behind a proxy that rewrites Host",
{ origin: "https://render.example.com", "sec-fetch-site": "same-origin" },
],
])("renders for %s", async (_label, headers) => {
const res = await postRender({ "content-type": "application/json", ...headers });
expect(res.status).toBe(200);
});
it("renders for a same-origin page behind a proxy that rewrites Host once its name is allowed", async () => {
const headers = {
"content-type": "application/json",
origin: "https://render.example.com",
"sec-fetch-site": "same-origin",
};
expect((await postRender(headers)).status).toBe(403);
expect((await postRender(headers, { allowedHosts: ["render.example.com"] })).status).toBe(200);
});
});
describe("createProducerApp: browser requests under a rebound host name", () => {
const rebound = { host: "attacker.example:9847", origin: "http://attacker.example:9847" };
function request(path: string, headers: Record<string, string>, options: HandlerOptions = {}) {
const method = path === "/render" ? "POST" : "GET";
return createProducerApp(options).request(`http://localhost:9847${path}`, {
method,
headers: { "content-type": "application/json", ...headers },
body: method === "POST" ? JSON.stringify({ html: "<html><body></body></html>" }) : undefined,
});
}
it.each([
["with Sec-Fetch-Site: same-origin", { ...rebound, "sec-fetch-site": "same-origin" }],
["without Sec-Fetch-Site", rebound],
])("refuses a render %s and starts nothing", async (_label, headers) => {
const before = started.count;
const res = await request("/render", headers);
expect(res.status).toBe(403);
expect(started.count).toBe(before);
});
it("refuses an output download and a queue read the same way", async () => {
const headers = { ...rebound, "sec-fetch-site": "same-origin" };
expect((await request("/outputs/some-token", headers)).status).toBe(403);
expect((await request("/render/queue", headers)).status).toBe(403);
});
it("refuses a page whose own origin is a rebindable name even when Host is loopback", async () => {
const res = await request("/render", {
host: "localhost:9847",
origin: "http://attacker.example:9847",
"sec-fetch-site": "same-origin",
});
expect(res.status).toBe(403);
});
it.each([
["127.0.0.1", "127.0.0.1:9847"],
["a LAN address", "192.168.1.20:9847"],
["IPv6 loopback", "[::1]:9847"],
["a *.localhost name", "studio.localhost:9847"],
])("serves a same-origin page on %s", async (_label, host) => {
const res = await request("/render", {
host,
origin: `http://${host}`,
"sec-fetch-site": "same-origin",
});
expect(res.status).toBe(200);
});
it("serves a listed name, from options or PRODUCER_ALLOWED_HOSTS, matched without port or case", async () => {
const headers = { ...rebound, "sec-fetch-site": "same-origin" };
expect((await request("/render", headers, { allowedHosts: ["Attacker.Example"] })).status).toBe(
200,
);
vi.stubEnv("PRODUCER_ALLOWED_HOSTS", " other.example , attacker.example:443");
try {
expect((await request("/render", headers)).status).toBe(200);
} finally {
vi.unstubAllEnvs();
}
});
it("leaves non-browser callers alone whatever Host they send", async () => {
const res = await request("/render", { host: "producer.internal:9847" });
expect(res.status).toBe(200);
});
});
+56
View File
@@ -25,6 +25,7 @@ import {
import { resolve, dirname, join } from "node:path";
import { tmpdir } from "node:os";
import { parseArgs } from "node:util";
import { isIP } from "node:net";
import crypto from "node:crypto";
import { Hono, type Context } from "hono";
import { streamSSE } from "hono/streaming";
@@ -76,6 +77,8 @@ export interface HandlerOptions {
artifactTtlMs?: number;
/** Max renders that execute simultaneously. Queued requests wait FIFO. Default: 2. */
maxConcurrentRenders?: number;
/** Extra browser-facing host names (e.g. a proxy's); merged with PRODUCER_ALLOWED_HOSTS. */
allowedHosts?: readonly string[];
}
export interface ServerOptions extends HandlerOptions {
@@ -1033,12 +1036,65 @@ function isCrossOriginBrowserRequest(c: Context): boolean {
}
}
function hostnameOf(host: string): string | null {
try {
return new URL(`http://${host}`).hostname.toLowerCase();
} catch {
return null;
}
}
/** A rebound page arrives under its own DNS name; IP literals and localhost can't be rebound. */
function isAllowedBrowserHostname(hostname: string | null, allowed: ReadonlySet<string>): boolean {
if (!hostname) return false;
if (hostname === "localhost" || hostname.endsWith(".localhost")) return true;
if (isIP(hostname.replace(/^\[|\]$/g, "")) !== 0) return true;
return allowed.has(hostname);
}
function allowedHostnames(options: HandlerOptions): Set<string> {
const fromEnv = (process.env.PRODUCER_ALLOWED_HOSTS ?? "").split(",");
const names = new Set<string>();
for (const entry of [...(options.allowedHosts ?? []), ...fromEnv]) {
const hostname = entry.trim() ? hostnameOf(entry.trim()) : null;
if (hostname) names.add(hostname);
}
return names;
}
/** Header-less callers (curl, services) pass; a page's POST always carries Origin. */
function isDisallowedBrowserHost(c: Context, allowed: ReadonlySet<string>): boolean {
const origin = c.req.header("origin");
if (!origin && !c.req.header("sec-fetch-site")) return false;
if (!isAllowedBrowserHostname(hostnameOf(c.req.header("host") ?? ""), allowed)) return true;
if (!origin) return false;
try {
return !isAllowedBrowserHostname(new URL(origin).hostname.toLowerCase(), allowed);
} catch {
return true;
}
}
/**
* Create a Hono app with clean public routes for OSS use.
*/
export function createProducerApp(options: HandlerOptions = {}): Hono {
const app = new Hono();
const handlers = createRenderHandlers(options);
const allowed = allowedHostnames(options);
app.use("*", async (c, next) => {
if (isDisallowedBrowserHost(c, allowed)) {
return c.json(
{
success: false,
error: "Host not allowed. Add it to allowedHosts or PRODUCER_ALLOWED_HOSTS.",
},
403,
);
}
await next();
});
app.post("*", async (c, next) => {
if (isCrossOriginBrowserRequest(c)) {