import UserValidationUtils from "~/utils/app/UserValidationUtils"; import { useActionData, useLoaderData } from "react-router"; import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect } from "react-router"; import { getTranslations } from "~/locale/i18next.server"; import { consumePasswordResetTokenAndUpdatePassword, getUserByEmail } from "~/utils/db/users.db.server"; import { hashPassword } from "~/utils/auth/passwordHasher.server"; import IpAddressServiceServer from "~/modules/ipAddress/services/IpAddressService.server"; import ResetPasswordScreen from "~/modules/users/components/ResetPasswordScreen"; import { createUserSession, getUserInfo, validateCSRFToken } from "~/utils/session.server"; import { loadRequiredWebConfig } from "@hivegrid/config"; import { absoluteAppRootPath } from "~/utils/app/CrossHostUrls"; import { isPasswordResetTokenValid, PASSWORD_RESET_TOKEN_TTL_MS } from "~/services/auth/password-reset-token.server"; import { checkAuthRateLimit } from "~/services/auth/auth-rate-limit.server"; import { beginAlternativeLoginMfa, LOGIN_MFA_CHALLENGE_PATH } from "~/services/auth/alternative-login-mfa.server"; import { AdminFallbackLoginRejected, assertAdminFallbackLoginAllowedForIdentity, isCompletedAdminFallbackLoginResponse, } from "~/services/auth/admin-fallback.server"; import { writeAdminSsoAuditEvent } from "~/modules/admin-sso/audit.server"; import { revokeAllUserSessionsForUser } from "~/services/auth/sessionStore.server"; type LoaderData = { email: string; }; export const loader = async ({ request }: LoaderFunctionArgs) => { const { t } = await getTranslations(request); const url = new URL(request.url); let email = url.searchParams.get("e") ?? ""; if (email) { email = decodeURIComponent(email); } return { title: `${t("account.reset.title")} | ${process.env.APP_NAME}`, email, }; }; type ActionData = { success?: string; error?: string; fields?: { email: string; verifyToken: string; }; }; const translateIpAddressError = (t: (key: string) => string, error: string) => { if (error === "blacklisted") { return t("admin.accounts.ipAddresses.errors.blacklisted"); } if (error === "unauthorized") { return t("admin.accounts.ipAddresses.errors.unauthorized"); } return t("shared.unexpectedError"); }; export const action: ActionFunction = async ({ request }) => { const { t } = await getTranslations(request); await validateCSRFToken(request); const form = await request.formData(); const email = form.get("email")?.toString().toLowerCase().trim() ?? ""; const verifyToken = form.get("verify-token")?.toString() ?? ""; const password = form.get("password")?.toString() ?? ""; const passwordConfirm = form.get("password-confirm")?.toString() ?? ""; const ipError = await IpAddressServiceServer.log(request, { action: "reset", description: email }).catch((e) => e.message); if (ipError) { return Response.json({ error: translateIpAddressError(t, ipError) }, { status: 400 }); } const fields = { email, verifyToken, }; if (!email) { return Response.json({ error: t("account.reset.errors.emailRequired"), fields }, { status: 400 }); } const invalidResetTokenError = t("account.reset.errors.invalidOrExpiredToken"); const rateLimit = await checkAuthRateLimit({ request, action: "reset-password", identifier: email, limit: 5, windowMs: 15 * 60 * 1000, }); if (!rateLimit.allowed) { return Response.json({ error: invalidResetTokenError, fields }, { status: 429, headers: { "Retry-After": String(rateLimit.retryAfterSeconds) } }); } const passwordError = await UserValidationUtils.validatePasswords({ t, password, passwordConfirm, email }); if (passwordError) { return Response.json({ error: passwordError, fields }, { status: 400 }); } const user = await getUserByEmail(email); if (!user) { return Response.json({ error: invalidResetTokenError, fields }, { status: 400 }); } if (!user.verifyToken || !user.verifyTokenCreatedAt || !isPasswordResetTokenValid(user, verifyToken)) { return Response.json({ error: invalidResetTokenError, fields }, { status: 400 }); } try { assertAdminFallbackLoginAllowedForIdentity(user); } catch (error) { if (!(error instanceof AdminFallbackLoginRejected)) { throw error; } await writeAdminSsoAuditEvent({ action: "admin.login.fallback.failure", actorAdminUserId: user.admin?.userId, request, meta: { reason: error.reason, email, method: "password-reset", stage: "primary" }, }); return Response.json({ error: invalidResetTokenError, fields }, { status: 400 }); } const passwordHash = await hashPassword(password); // Revoke before the credential write so a database error can at worst // force another login; it can never leave old authenticated devices alive // after the password has changed. await revokeAllUserSessionsForUser(user.id); const consumed = await consumePasswordResetTokenAndUpdatePassword({ userId: user.id, passwordHash, expectedVerifyToken: user.verifyToken, expectedVerifyTokenCreatedAt: user.verifyTokenCreatedAt, minimumVerifyTokenCreatedAt: new Date(Date.now() - PASSWORD_RESET_TOKEN_TTL_MS), }); if (!consumed) { return Response.json({ error: invalidResetTokenError, fields }, { status: 400 }); } // Event is tenant-owned and must not be used for a tenantless credential // mutation. The user-scoped credential write is already committed here; a // diagnostics write must never turn that reset into an apparent failure. const successRedirect = absoluteAppRootPath(loadRequiredWebConfig().routing); const mfa = await beginAlternativeLoginMfa({ request, userId: user.id, redirectTo: successRedirect, primaryMethod: "password-reset" }); if (mfa.required) { return redirect(LOGIN_MFA_CHALLENGE_PATH, { headers: { "Set-Cookie": mfa.setCookie } }); } const userInfo = await getUserInfo(request); const response = await createUserSession( { ...userInfo, userId: user.id, lng: user.locale ?? userInfo.lng, }, successRedirect, { request, rotate: true } ); if (user.admin && isCompletedAdminFallbackLoginResponse(response)) { await writeAdminSsoAuditEvent({ action: "admin.login.fallback.success", actorAdminUserId: user.admin.userId, request, meta: { email: user.email, severity: "warn", method: "password-reset" }, }); } return response; }; export const meta: MetaFunction = ({ data }) => [{ title: data?.title }]; export default function ResetRoute() { const data = useLoaderData(); const actionData = useActionData(); // D-D0a — Davids "Reset Password" (+ Success/Invalid-States). Token aus URL, action validiert serverseitig. return ; }