import type { LoaderFunctionArgs } from "react-router"; import { redirect } from "react-router"; import { loadRequiredWebConfig } from "@hivegrid/config"; import { AdminIdentityNotPreparedError, bindPreparedAuthentikAdminIdentity, } from "@hivegrid/db/admin-sso.server"; import { runWithRlsContext } from "@hivegrid/db/rls-context.server"; import { absoluteAdminPath } from "~/utils/app/CrossHostUrls"; import { db } from "~/utils/db.server"; import { createUserSession, getUserInfo } from "~/utils/session.server"; import { AdminSsoConfigError, consumeAdminSsoChallenge, extractAdminSsoClaims, getAdminSsoClient, readAdminSsoEnv, } from "~/modules/admin-sso"; import { hasAllowedAdminGroup } from "~/modules/admin-sso/claims.server"; import { writeAdminSsoAuditEvent } from "~/modules/admin-sso/audit.server"; import { serializeIdTokenCookie } from "~/modules/admin-sso/logout.server"; function failRedirect(reason: string): never { throw redirect(`/login?error=${encodeURIComponent(reason)}`); } function sanitizeReturnTo(value: string | undefined): string | undefined { if (!value || !value.startsWith("/") || value.startsWith("//") || value.includes("\\")) return undefined; if (/%(?:2f|5c|00|0a|0d)/i.test(value) || /[\x00-\x1f\x7f]/u.test(value)) return undefined; return value; } function isAdminIdentityNotPrepared(error: unknown): boolean { return ( error instanceof AdminIdentityNotPreparedError || (typeof error === "object" && error !== null && "code" in error && error.code === "ADMIN_IDENTITY_NOT_PREPARED") ); } export async function loader({ request }: LoaderFunctionArgs): Promise { const url = new URL(request.url); let env; let client; try { env = readAdminSsoEnv(); client = await getAdminSsoClient(env); } catch (error) { await writeAdminSsoAuditEvent({ action: "admin.login.sso.failure", request, meta: { stage: "init", reason: error instanceof AdminSsoConfigError ? error.code : "unknown" }, }); return failRedirect("sso_unavailable"); } const consumed = consumeAdminSsoChallenge(request); if (!consumed.ok) { await writeAdminSsoAuditEvent({ action: "admin.login.sso.failure", request, meta: { stage: "consume-challenge", reason: consumed.reason }, }); return failRedirect("sso_state_invalid"); } let tokenSet; try { tokenSet = await client.callback(env.redirectUri, client.callbackParams(url.toString()), { state: consumed.payload.state, nonce: consumed.payload.nonce, code_verifier: consumed.payload.codeVerifier, }); } catch (error) { await writeAdminSsoAuditEvent({ action: "admin.login.sso.failure", request, meta: { stage: "token-exchange", error: error instanceof Error ? error.name : "Error" }, }); return failRedirect("sso_token_exchange_failed"); } const claimResult = extractAdminSsoClaims(tokenSet.claims() as Record); if (!claimResult.ok) { await writeAdminSsoAuditEvent({ action: "admin.login.sso.failure", request, meta: { stage: "claims", reason: claimResult.reason }, }); return failRedirect(`sso_${claimResult.reason.replace(/-/g, "_")}`); } const claims = claimResult.claims; if (!hasAllowedAdminGroup(claims.groups)) { await writeAdminSsoAuditEvent({ action: "admin.login.sso.failure", request, ssoSubjectId: claims.subject, meta: { stage: "authorization", reason: "forbidden-group", groups: claims.groups }, }); return failRedirect("sso_forbidden_group"); } if (!claims.authenticationMethods.includes("mfa")) { await writeAdminSsoAuditEvent({ action: "admin.login.sso.failure", request, ssoSubjectId: claims.subject, meta: { stage: "mfa-assurance", reason: "authentik-mfa-required" }, }); return failRedirect("sso_mfa_required"); } let boundIdentity: Awaited>; try { boundIdentity = await bindPreparedAuthentikAdminIdentity({ subject: claims.subject, email: claims.email, emailVerified: claims.emailVerified, groups: claims.groups, firstName: claims.name.trim().split(/\s+/u)[0] ?? claims.email, lastName: claims.name.trim().split(/\s+/u).slice(1).join(" "), loginAt: new Date(), }); } catch (error) { const identityNotPrepared = isAdminIdentityNotPrepared(error); await writeAdminSsoAuditEvent({ action: "admin.login.sso.failure", request, ssoSubjectId: claims.subject, meta: { stage: "identity-binding", reason: identityNotPrepared ? "admin-not-prepared" : "binding-failed", error: error instanceof Error ? error.name : "Error", }, }); return failRedirect(identityNotPrepared ? "sso_admin_not_prepared" : "sso_binding_failed"); } const adminUser = await runWithRlsContext({ userId: boundIdentity.adminUserId }, () => db.adminUser.findUnique({ where: { id: boundIdentity.adminUserId }, select: { id: true, email: true, locale: true }, }) ); if (!adminUser) return failRedirect("sso_session_failed"); const routing = loadRequiredWebConfig().routing; const redirectTarget = sanitizeReturnTo(consumed.payload.returnTo) ?? absoluteAdminPath(routing, "dashboard"); const userInfo = await getUserInfo(request); const mfaAssuredAt = new Date(); const sessionResponse = await createUserSession( { ...userInfo, userId: adminUser.id, lng: adminUser.locale ?? userInfo.lng, }, redirectTarget, { request, rotate: true, adminAuthenticationMethods: claims.authenticationMethods, adminMfaAssuredAt: mfaAssuredAt, } ); await runWithRlsContext({ userId: adminUser.id }, () => writeAdminSsoAuditEvent({ action: "admin.login.sso.success", actorAdminUserId: adminUser.id, ssoSubjectId: claims.subject, request, meta: { groups: claims.groups, newSubjectBinding: boundIdentity.newSubjectBinding, authentikMfaVerified: true, }, }) ); const headers = new Headers(sessionResponse.headers); headers.append("Set-Cookie", consumed.clearCookie); if (tokenSet.id_token) headers.append("Set-Cookie", serializeIdTokenCookie(tokenSet.id_token)); return new Response(sessionResponse.body, { status: sessionResponse.status, headers }); } export default function AuthAdminCallback() { return null; }