fix(proxy,auth,insights): close three drift gaps the audits left open

The proxy's seven early exits — worker-only 503, two legacy 301s, the demo-mode
403, and the login / onboarding / MFA redirects — returned before the security
header block, so they carried no HSTS, no framing refusal and no nosniff. Factor
the transport subset into a helper and apply it on every exit. The per-route CSP
stays where it is; it is nonce-bound and only meaningful for a response with a
body.

The WebAuthn relying-party candidate list always carried http://localhost:3000,
including in production. The signed rpIdHash still pinned the real domain, so
this was never a reachable bypass, but a configured production origin has no
reason to carry it. Gate the fallback on development, keeping it when nothing is
configured so getRpId() still resolves.

ORPHAN_ENUMS was a hand-maintained literal that drifted every time
ALLOWED_CHART_TOKENS grew — eighteen allowlisted metrics had no strip entry, so
a model writing 'Your PHQ9_SCORE is elevated' leaked the raw enum into rendered
prose. Derive it from the allowlist and pin the coupling with a test.
This commit is contained in:
Marc-André Bombeck committed 2026-07-19 13:31:29 +02:00
1 parent f5889affb7
commit 8ead442d44
6 files changed
+365 -93

No files matched your search

@@ -0,0 +1,88 @@
/**
* Relying-party origin resolution.
*
* The localhost fallback used to sit in the candidate list unconditionally, so
* a production deployment with a real `APP_URL` still accepted an assertion
* whose `clientDataJSON.origin` was `http://localhost:3000`. The signed
* `rpIdHash` pinned the real domain either way, so this never was a reachable
* bypass — but a configured production origin has no reason to carry it, and an
* unpinned second layer is exactly what regresses unnoticed.
*/
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import {
getConfiguredOrigins,
getExpectedOrigin,
getRpId,
} from "../webauthn-rp";
const ORIGINAL = {
NODE_ENV: process.env.NODE_ENV,
APP_URL: process.env.APP_URL,
NEXT_PUBLIC_APP_URL: process.env.NEXT_PUBLIC_APP_URL,
};
function setEnv(env: {
nodeEnv?: string;
appUrl?: string;
publicAppUrl?: string;
}) {
if (env.nodeEnv === undefined) delete process.env.NODE_ENV;
else process.env.NODE_ENV = env.nodeEnv;
if (env.appUrl === undefined) delete process.env.APP_URL;
else process.env.APP_URL = env.appUrl;
if (env.publicAppUrl === undefined) delete process.env.NEXT_PUBLIC_APP_URL;
else process.env.NEXT_PUBLIC_APP_URL = env.publicAppUrl;
}
beforeEach(() => {
setEnv({});
});
afterEach(() => {
setEnv({
nodeEnv: ORIGINAL.NODE_ENV,
appUrl: ORIGINAL.APP_URL,
publicAppUrl: ORIGINAL.NEXT_PUBLIC_APP_URL,
});
});
describe("getConfiguredOrigins", () => {
it("drops the localhost fallback in production once an app URL is configured", () => {
setEnv({ nodeEnv: "production", appUrl: "https://health.example" });
const origins = getConfiguredOrigins();
expect(origins).toEqual(["https://health.example"]);
expect(origins).not.toContain("http://localhost:3000");
});
it("drops it in production when only the public build-time URL is set", () => {
setEnv({ nodeEnv: "production", publicAppUrl: "https://health.example" });
expect(getConfiguredOrigins()).not.toContain("http://localhost:3000");
});
it("keeps the localhost fallback outside production", () => {
setEnv({ nodeEnv: "development", appUrl: "https://health.example" });
expect(getConfiguredOrigins()).toContain("http://localhost:3000");
});
it("keeps it in production when nothing is configured, so getRpId still resolves", () => {
setEnv({ nodeEnv: "production" });
expect(getConfiguredOrigins()).toEqual(["http://localhost:3000"]);
expect(getRpId()).toBe("localhost");
});
it("still pins the RP id to the configured domain in production", () => {
setEnv({ nodeEnv: "production", appUrl: "https://health.example" });
expect(getRpId()).toBe("health.example");
expect(getExpectedOrigin()).toBe("https://health.example");
});
it("de-duplicates when both URL vars carry the same origin", () => {
setEnv({
nodeEnv: "production",
appUrl: "https://health.example",
publicAppUrl: "https://health.example/",
});
expect(getConfiguredOrigins()).toEqual(["https://health.example"]);
});
});
+17 -5
View File
@@ -10,20 +10,32 @@
* build-time URL, then a localhost fallback for dev. A multi-origin deployment
* (rare for a single-tenant self-host, but supported) passes the whole set to
* SimpleWebAuthn's `expectedOrigin`.
*
* The localhost fallback is gated: it is offered in development, and in
* production ONLY when neither app URL is configured — otherwise a production
* deployment accepted an assertion whose `clientDataJSON.origin` was
* `http://localhost:3000`. The signed `rpIdHash` still pins the real domain via
* `getRpId()`, so this was defence-in-depth rather than a live bypass, but a
* configured production origin has no reason to carry localhost at all. The
* unconfigured case keeps the fallback so `getRpId()` still resolves instead of
* throwing on an empty candidate list.
*/
/** Human-readable relying-party name shown by the authenticator UI. */
export const RP_NAME = "HealthLog";
export function getConfiguredOrigins(): string[] {
const candidates = [
process.env.APP_URL,
process.env.NEXT_PUBLIC_APP_URL,
"http://localhost:3000",
]
const configured = [process.env.APP_URL, process.env.NEXT_PUBLIC_APP_URL]
.map((value) => value?.trim())
.filter((value): value is string => Boolean(value));
const allowLocalhost =
process.env.NODE_ENV !== "production" || configured.length === 0;
const candidates = allowLocalhost
? [...configured, "http://localhost:3000"]
: configured;
const validOrigins = candidates
.map((value) => {
try {