Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/reset.tsx
T

171 lines
6.8 KiB
TypeScript

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<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function ResetRoute() {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
// D-D0a — Davids "Reset Password" (+ Success/Invalid-States). Token aus URL, action validiert serverseitig.
return <ResetPasswordScreen data={data} actionData={actionData} />;
}