reconcile: fold in the outstanding hardening and data-integrity fixes

Merge the eight reviewed audit fixes that were cut a week ago and never
landed. Main has moved on since, so each fix was re-checked against the
current tree and each of the five conflicts resolved by understanding
both sides.

Kept, still open on main:
- Proxy early exits now carry the transport security header subset via a
  shared helper. Reconciled with main's /api/health worker-only carve-out.
- Batch measurement ingest bounds the entry instant so a future-dated row
  can no longer win "latest reading" or poison the rollup buckets.
- Web Push dials through the pinned safeFetch dispatcher with
  requirePublicHost, closing the last user-controlled-host egress.
- Mood bulk upsert and its tag/factor links run in one transaction, so a
  rejected rating rolls the mood row back instead of leaving a tagless row.
- Full backup carries NutrientIntakeDay with its unit and source. Folded
  into main's portable-export / disaster-recovery split.
- Live daily-series fallback restores the min/max spread band the tiered
  read already emitted.
- Coach stream aborts its in-flight reader on unmount and resets send state
  on a conversation switch.
- Manual water writes share the day-bound helper, nutrient add clamps after
  the increment, and the thiamin cap drops to a real supplement ceiling.
- Compliance point window widens symmetrically instead of wrapping overnight.
- Oura, Polar and Fitbit token helpers classify an empty or non-JSON 2xx
  body as a handled transient error.
- WebAuthn relying-party fallback to localhost is gated to development.
- Chart-token strip list is derived from the allowlist and pinned by a test.
- Regression tests pin the snapshot-cache tenant key, the GlitchTip
  path-secret redaction and the Withings credentials delete.

Superseded by main, tests re-pointed at the current shape:
- The intake CSV import was rewritten on main to run through a background
  job with a single-active-job admission gate. The future-date bound is
  re-applied at request validation and the per-user limiter is kept for
  parity with the bulk twin; the old synchronous-write test is replaced.
This commit is contained in:
Marc-André Bombeck committed 2026-07-23 17:15:21 +02:00
commit b1e36d9fb0
51 files changed
+2066 -228

No files matched your search

@@ -0,0 +1,76 @@
/**
* 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, vi } from "vitest";
import {
getConfiguredOrigins,
getExpectedOrigin,
getRpId,
} from "../webauthn-rp";
function setEnv(env: {
nodeEnv?: string;
appUrl?: string;
publicAppUrl?: string;
}) {
vi.unstubAllEnvs();
if (env.nodeEnv !== undefined) vi.stubEnv("NODE_ENV", env.nodeEnv);
vi.stubEnv("APP_URL", env.appUrl ?? "");
vi.stubEnv("NEXT_PUBLIC_APP_URL", env.publicAppUrl ?? "");
}
beforeEach(() => {
setEnv({});
});
afterEach(() => {
vi.unstubAllEnvs();
});
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 {