Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/services/auth/session-handoff.server.ts
T

193 lines
6.5 KiB
TypeScript

import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
import { MemoryAdapter, type SharedStore } from "@hivegrid/shared-store";
import { redirect } from "react-router";
import { getSharedStore } from "~/shared-store.server";
import { absolutePublicAppPath } from "~/utils/app/CrossHostUrls";
import { safeSessionRedirectTarget } from "~/utils/app/SessionRedirectSafety.server";
import { getHostRoutingContext, getRequestRoutingHost } from "~/utils/app/HostRouting.server";
import { createUserSession, type UserSession } from "~/utils/session.server";
import { loadRequiredWebConfig } from "@hivegrid/config";
export const SESSION_HANDOFF_TTL_SECONDS = 60;
export const SESSION_HANDOFF_PATH = "/auth/session-handoff";
const CONSUME_SCRIPT = `
local value = redis.call('GET', KEYS[1])
if value then
redis.call('DEL', KEYS[1])
end
return value
`;
MemoryAdapter.registerScript(CONSUME_SCRIPT, async (adapter, keys) => {
const key = keys[0];
if (!key) return null;
const value = await adapter.get(key);
if (value !== null) await adapter.del(key);
return value;
});
type SessionHandoffPayload = {
createdAt: number;
userAgentHash: string;
redirectTo: string;
session: UserSession;
};
let storeFactory: () => SharedStore = () => getSharedStore();
let memoryConsumeQueue: Promise<void> = Promise.resolve();
function codeKey(code: string) {
return `auth:session-handoff:${createHash("sha256").update(code).digest("hex")}`;
}
function signPayload(code: string, payload: string) {
return createHmac("sha256", code).update(payload).digest("base64url");
}
function safeSignatureMatch(actual: string, expected: string) {
const actualBytes = Buffer.from(actual);
const expectedBytes = Buffer.from(expected);
return actualBytes.length === expectedBytes.length && timingSafeEqual(actualBytes, expectedBytes);
}
function userAgentHash(request: Request) {
return createHash("sha256")
.update(request.headers.get("user-agent") ?? "")
.digest("hex");
}
function transferableSession(session: UserSession): UserSession {
return {
userId: session.userId,
lightOrDarkMode: session.lightOrDarkMode,
lng: session.lng,
// The destination host receives a fresh CSRF token from its root loader;
// never carry the admin-host token across the trust boundary.
csrf: undefined,
cookies: session.cookies,
metrics: session.metrics,
impersonatingFromUserId: session.impersonatingFromUserId,
impersonatingFromAdminUserId: session.impersonatingFromAdminUserId,
impersonatingFromAdminEmail: session.impersonatingFromAdminEmail,
impersonatingStartedAt: session.impersonatingStartedAt,
theme: session.theme,
passwordPolicyOutdated: session.passwordPolicyOutdated,
};
}
export async function createSessionHandoffRedirect({
request,
session,
redirectTo,
}: {
request: Request;
session: UserSession;
redirectTo: string;
}): Promise<Response> {
const routing = loadRequiredWebConfig().routing;
const safeRedirectTo = safeSessionRedirectTarget(redirectTo, routing);
const appOrigin = new URL(`${routing.protocol}://${routing.webAppHost}`).origin;
if (!safeRedirectTo.startsWith(`${appOrigin}/`)) {
throw new Error("Session handoff requires a canonical app-host redirect target");
}
const code = randomBytes(32).toString("base64url");
const payload: SessionHandoffPayload = {
createdAt: Date.now(),
userAgentHash: userAgentHash(request),
redirectTo: safeRedirectTo,
session: transferableSession(session),
};
const serializedPayload = JSON.stringify(payload);
const stored = await storeFactory().set(codeKey(code), JSON.stringify({ payload: serializedPayload, signature: signPayload(code, serializedPayload) }), {
ttlSeconds: SESSION_HANDOFF_TTL_SECONDS,
nx: true,
});
if (!stored) {
throw new Error("Could not reserve one-time session handoff code");
}
const target = new URL(absolutePublicAppPath(routing, SESSION_HANDOFF_PATH));
target.searchParams.set("code", code);
return redirect(target.toString(), {
headers: {
"Cache-Control": "no-store",
"Referrer-Policy": "no-referrer",
},
});
}
export async function consumeSessionHandoff(request: Request, code: string | null | undefined): Promise<Response | null> {
if (!code || !/^[A-Za-z0-9_-]{43}$/.test(code)) {
return null;
}
const routing = loadRequiredWebConfig().routing;
const requestUrl = new URL(request.url);
if (getHostRoutingContext(getRequestRoutingHost(request, requestUrl, routing), routing) !== "app") {
return null;
}
const store = storeFactory();
const consume = () => store.adapter.eval(CONSUME_SCRIPT, [store.key(codeKey(code))], []);
let raw: unknown;
if (store.adapter instanceof MemoryAdapter) {
// Redis runs the Lua script atomically. Serialize the development/test
// adapter too so concurrent consumers observe the same single-use rule.
const queued = memoryConsumeQueue.then(consume);
memoryConsumeQueue = queued.then(
() => undefined,
() => undefined
);
raw = await queued;
} else {
raw = await consume();
}
if (typeof raw !== "string") {
return null;
}
let payload: SessionHandoffPayload;
try {
const envelope = JSON.parse(raw) as { payload?: unknown; signature?: unknown };
if (
typeof envelope.payload !== "string" ||
typeof envelope.signature !== "string" ||
!safeSignatureMatch(envelope.signature, signPayload(code, envelope.payload))
) {
return null;
}
payload = JSON.parse(envelope.payload) as SessionHandoffPayload;
} catch {
return null;
}
const ageMs = Date.now() - payload.createdAt;
if (
!Number.isFinite(payload.createdAt) ||
ageMs < 0 ||
ageMs >= SESSION_HANDOFF_TTL_SECONDS * 1000 ||
payload.userAgentHash !== userAgentHash(request) ||
typeof payload.redirectTo !== "string" ||
!payload.session ||
typeof payload.session.userId !== "string"
) {
return null;
}
const response = await createUserSession(payload.session, payload.redirectTo, { request, rotate: true });
const headers = new Headers(response.headers);
headers.set("Cache-Control", "no-store");
headers.set("Referrer-Policy", "no-referrer");
return new Response(response.body, { status: response.status, headers });
}
export function __setSessionHandoffStoreForTests(store: SharedStore): void {
storeFactory = () => store;
}
export function __resetSessionHandoffStoreForTests(): void {
storeFactory = () => getSharedStore();
memoryConsumeQueue = Promise.resolve();
}