chore(ops): signed images, a secret gate before commit, and a monthly restore drill

Published manifests are now cosign-signed keyless with a documented
digest-pinning path, a lefthook pre-commit runs gitleaks over staged
changes, responses opt into a credentialless embedder policy, the
deploy webhook can require a fresh timestamp, and a monthly drill
decrypts and parses the newest offhost backup so a broken key or format
surfaces before an emergency does.
This commit is contained in:
Marc-André Bombeck committed 2026-06-11 00:10:01 +02:00
1 parent 410c62c292
commit ce3b4c70c8
11 files changed
+433 -4

No files matched your search

@@ -330,3 +330,84 @@ describe("GET /api/internal/deploy-webhook (reachability check)", () => {
expect(res.status).toBe(401);
});
});
describe("POST /api/internal/deploy-webhook (timestamp replay protection)", () => {
const ORIGINAL_REQUIRE = process.env.DEPLOY_WEBHOOK_REQUIRE_TIMESTAMP;
afterEach(() => {
if (ORIGINAL_REQUIRE === undefined) {
delete process.env.DEPLOY_WEBHOOK_REQUIRE_TIMESTAMP;
} else {
process.env.DEPLOY_WEBHOOK_REQUIRE_TIMESTAMP = ORIGINAL_REQUIRE;
}
});
function timestamped(ts: string): NextRequest {
return jsonRequest(
{ status: "success" },
{
"x-deploy-webhook-secret": "test-secret",
"x-deploy-webhook-timestamp": ts,
},
);
}
it("accepts a fresh unix-seconds timestamp", async () => {
const res = await POST(timestamped(String(Math.floor(Date.now() / 1000))));
expect(res.status).toBe(200);
});
it("accepts a fresh ISO-8601 timestamp", async () => {
const res = await POST(timestamped(new Date().toISOString()));
expect(res.status).toBe(200);
});
it("rejects a timestamp older than the 5-minute window", async () => {
const stale = Math.floor((Date.now() - 6 * 60 * 1000) / 1000);
const res = await POST(timestamped(String(stale)));
expect(res.status).toBe(401);
expect(auditLog).not.toHaveBeenCalled();
});
it("rejects a timestamp too far in the future (clock-skew bound)", async () => {
const future = Math.floor((Date.now() + 6 * 60 * 1000) / 1000);
const res = await POST(timestamped(String(future)));
expect(res.status).toBe(401);
});
it("rejects an unparseable timestamp value", async () => {
const res = await POST(timestamped("not-a-timestamp"));
expect(res.status).toBe(401);
});
it("accepts a request without the header in tolerant default mode", async () => {
delete process.env.DEPLOY_WEBHOOK_REQUIRE_TIMESTAMP;
const res = await POST(
jsonRequest(
{ status: "success" },
{ "x-deploy-webhook-secret": "test-secret" },
),
);
expect(res.status).toBe(200);
});
it("rejects a request without the header when DEPLOY_WEBHOOK_REQUIRE_TIMESTAMP=true", async () => {
process.env.DEPLOY_WEBHOOK_REQUIRE_TIMESTAMP = "true";
const res = await POST(
jsonRequest(
{ status: "success" },
{ "x-deploy-webhook-secret": "test-secret" },
),
);
expect(res.status).toBe(401);
expect(auditLog).not.toHaveBeenCalled();
});
it("still rejects a stale timestamp before any audit-log write", async () => {
const stale = Math.floor((Date.now() - 10 * 60 * 1000) / 1000);
const res = await POST(timestamped(String(stale)));
expect(res.status).toBe(401);
expect(auditLog).not.toHaveBeenCalled();
expect(dispatchLocalisedNotification).not.toHaveBeenCalled();
});
});
@@ -85,6 +85,58 @@ function normalizePayload(payload: CoolifyDeployPayload): NormalizedEvent {
};
}
/**
* Replay protection (v1.16.4). A captured webhook request carries a
* static shared secret, so without a freshness check it can be replayed
* indefinitely — re-paging admins with stale failure alerts and
* polluting the audit log with forged deploy outcomes.
*
* The sender attaches `X-Deploy-Webhook-Timestamp` (unix seconds or
* ISO-8601). Requests whose timestamp falls outside a ±5-minute window
* are rejected. Two modes:
*
* - Default (tolerant): a request WITHOUT the header passes — Coolify's
* stock notification sender does not attach one, and breaking the
* live integration would cost more than the residual replay window.
* A header that IS present but stale/invalid is always rejected, so
* a replayed capture of a timestamped request never lands.
* - `DEPLOY_WEBHOOK_REQUIRE_TIMESTAMP=true`: the header becomes
* mandatory. For operators whose sender (or reverse proxy) can
* attach the timestamp; closes the replay window completely.
*
* See docs/ops/deploy.md ("Deploy-status webhook") for the operator
* guidance.
*/
const TIMESTAMP_WINDOW_MS = 5 * 60 * 1000;
function parseTimestamp(raw: string): number | null {
// Unix seconds (10 digits covers 2001-2286) or milliseconds.
if (/^\d{10}$/.test(raw)) return Number(raw) * 1000;
if (/^\d{13}$/.test(raw)) return Number(raw);
const iso = Date.parse(raw);
return Number.isFinite(iso) ? iso : null;
}
function checkTimestampFreshness(
request: NextRequest,
now: number = Date.now(),
): { ok: boolean; reason?: string } {
const raw = request.headers.get("x-deploy-webhook-timestamp");
const required =
process.env.DEPLOY_WEBHOOK_REQUIRE_TIMESTAMP === "true" ||
process.env.DEPLOY_WEBHOOK_REQUIRE_TIMESTAMP === "1";
if (raw === null || raw === "") {
if (required) return { ok: false, reason: "timestamp_missing" };
return { ok: true };
}
const ts = parseTimestamp(raw);
if (ts === null) return { ok: false, reason: "timestamp_invalid" };
if (Math.abs(now - ts) > TIMESTAMP_WINDOW_MS) {
return { ok: false, reason: "timestamp_outside_window" };
}
return { ok: true };
}
function hasValidSecret(request: NextRequest): boolean {
const expected = process.env.DEPLOY_WEBHOOK_SECRET;
if (!expected) {
@@ -173,6 +225,17 @@ export const POST = apiHandler(async (request: NextRequest) => {
return NextResponse.json({ status: "unauthorized" }, { status: 401 });
}
// Freshness AFTER the secret check: an unauthenticated caller learns
// nothing about the timestamp policy, and a replayed-but-stale request
// from a captured legitimate call is rejected here.
const freshness = checkTimestampFreshness(request);
if (!freshness.ok) {
annotate({
meta: { deploy_webhook_replay_reason: freshness.reason ?? "unknown" },
});
return NextResponse.json({ status: "stale" }, { status: 401 });
}
getEvent()?.setAuth({ auth_method: "webhook_secret" });
const { data: payload, error: jsonError } =