192 lines
6.4 KiB
TypeScript
192 lines
6.4 KiB
TypeScript
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<Response> {
|
|
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<string, unknown>);
|
|
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<ReturnType<typeof bindPreparedAuthentikAdminIdentity>>;
|
|
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;
|
|
}
|