Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

feat(web): require Turnstile on password-reset emails (#18584)

Max Deichmanna27d317564fa
diff --git a/.env.prod.example b/.env.prod.example
index 030769a727..1bd617af05 100644
--- a/.env.prod.example
+++ b/.env.prod.example
@@ -442,7 +442,8 @@ LANGFUSE_ENABLE_BLOB_STORAGE_FILE_LOG=true
# SENTRY_CSP_REPORT_URI=
-# Cloudflare Turnstile captcha on credentials sign-in and email sign-up.
+# Cloudflare Turnstile captcha on credentials sign-in, email sign-up, and
+# password-reset code emails.
# Setting TURNSTILE_SECRET enables the check; TURNSTILE_HOSTNAMES lists the
# frontend hostnames siteverify must report (comma-separated, no localhost in
# production). NEXT_PUBLIC_TURNSTILE_SITE_KEY is baked in at build time.
diff --git a/web/src/__tests__/server/nextauth-email-callback.servertest.ts b/web/src/__tests__/server/nextauth-email-callback.servertest.ts
index cffdd42253..b2694aaa6b 100644
--- a/web/src/__tests__/server/nextauth-email-callback.servertest.ts
+++ b/web/src/__tests__/server/nextauth-email-callback.servertest.ts
@@ -1,4 +1,4 @@
-import { createHash, randomInt, randomUUID } from "crypto";
+import { createHash, randomBytes, randomInt, randomUUID } from "crypto";
import type { NextApiRequest, NextApiResponse } from "next";
import { createMocks } from "node-mocks-http";
import { describe, expect, it, vi } from "vitest";
@@ -13,16 +13,34 @@ vi.hoisted(() => {
});
import { env } from "@/src/env.mjs";
+import {
+ TURNSTILE_ACTIONS,
+ TURNSTILE_FAILED_MESSAGE,
+} from "@/src/features/auth/constants";
import {
hashPassword,
verifyPassword,
} from "@/src/features/auth-credentials/lib/passwordHash";
+import { verifyTurnstileToken } from "@/src/features/auth/server/verifyTurnstile";
+import type * as VerifyTurnstileModule from "@/src/features/auth/server/verifyTurnstile";
import auth from "@/src/pages/api/auth/[...nextauth]";
import { appRouter } from "@/src/server/api/root";
import { createInnerTRPCContext } from "@/src/server/api/trpc";
import { getAuthOptions } from "@/src/server/auth";
+import { getCookieName } from "@/src/server/utils/cookies";
import { prisma } from "@langfuse/shared/src/db";
+vi.mock(
+ "@/src/features/auth/server/verifyTurnstile",
+ async (importOriginal) => {
+ const actual = await importOriginal<typeof VerifyTurnstileModule>();
+ return {
+ ...actual,
+ verifyTurnstileToken: vi.fn(actual.verifyTurnstileToken),
+ };
+ },
+);
+
const OLD_PASSWORD = "Oldpass1!";
const NEW_PASSWORD = "Newpass1!";
@@ -83,7 +101,10 @@ describe("GET /api/auth/callback/email", () => {
describe("NextAuth signIn callback for the email provider", () => {
it("allows the send request but rejects the consume request", async () => {
const { email } = await createUser({ password: OLD_PASSWORD });
- const authOptions = await getAuthOptions();
+ const authOptions = await getAuthOptions(undefined, {
+ turnstileToken: "reset-token",
+ turnstileRemoteIp: "203.0.113.5",
+ });
const signIn = authOptions.callbacks!.signIn!;
const user = { id: email, email };
const account = {
@@ -95,10 +116,89 @@ describe("NextAuth signIn callback for the email provider", () => {
await expect(
signIn({ user, account, email: { verificationRequest: true } }),
).resolves.toBe(true);
+ expect(verifyTurnstileToken).toHaveBeenCalledWith({
+ token: "reset-token",
+ action: TURNSTILE_ACTIONS.passwordReset,
+ remoteIp: "203.0.113.5",
+ });
+
+ vi.mocked(verifyTurnstileToken).mockClear();
await expect(signIn({ user, account })).resolves.toBe(false);
+ expect(verifyTurnstileToken).not.toHaveBeenCalled();
+ });
+
+ it("rejects the reset-email request when captcha verification fails", async () => {
+ vi.mocked(verifyTurnstileToken).mockResolvedValueOnce(false);
+ const authOptions = await getAuthOptions(undefined, {
+ turnstileToken: "bad-token",
+ });
+ const signIn = authOptions.callbacks!.signIn!;
+
+ await expect(
+ signIn({
+ user: { id: "[email protected]", email: "[email protected]" },
+ account: {
+ provider: "email",
+ type: "email",
+ providerAccountId: "[email protected]",
+ },
+ email: { verificationRequest: true },
+ }),
+ ).rejects.toThrow(TURNSTILE_FAILED_MESSAGE);
});
});
+describe("POST /api/auth/signin/email captcha", () => {
+ it("passes the posted token to Turnstile and does not store a code when it fails", async () => {
+ const { email } = await createUser({ password: OLD_PASSWORD });
+ vi.mocked(verifyTurnstileToken).mockResolvedValueOnce(false);
+ const { csrfToken, cookie } = csrfPair();
+
+ const { req, res } = createMocks<NextApiRequest, NextApiResponse>({
+ method: "POST",
+ headers: {
+ host: "localhost:3000",
+ "x-forwarded-for": "203.0.113.9, 10.0.0.1",
+ },
+ query: { nextauth: ["signin", "email"] },
+ body: {
+ email,
+ csrfToken,
+ callbackUrl: "http://localhost:3000/auth/reset-password",
+ json: "true",
+ turnstileToken: "posted-token",
+ },
+ });
+ req.cookies = {
+ [getCookieName("next-auth.csrf-token")]: cookie,
+ };
+
+ await auth(req, res);
+
+ expect(verifyTurnstileToken).toHaveBeenCalledWith({
+ token: "posted-token",
+ action: TURNSTILE_ACTIONS.passwordReset,
+ remoteIp: "203.0.113.9",
+ });
+ expect(res.statusCode).toBe(200);
+ const url = res._getJSONData().url as string;
+ expect(new URL(url).searchParams.get("error")).toContain(
+ TURNSTILE_FAILED_MESSAGE,
+ );
+ await expect(
+ prisma.verificationToken.findFirst({ where: { identifier: email } }),
+ ).resolves.toBeNull();
+ });
+});
+
+function csrfPair() {
+ const csrfToken = randomBytes(32).toString("hex");
+ const csrfTokenHash = createHash("sha256")
+ .update(`${csrfToken}${process.env.NEXTAUTH_SECRET ?? ""}`)
+ .digest("hex");
+ return { csrfToken, cookie: `${csrfToken}|${csrfTokenHash}` };
+}
+
function uniqueOtp() {
return randomInt(100000, 1000000).toString();
}
diff --git a/web/src/env.mjs b/web/src/env.mjs
index d993262049..75c2fdba82 100644
--- a/web/src/env.mjs
+++ b/web/src/env.mjs
@@ -307,9 +307,10 @@ export const env = createEnv({
// EMAIL
EMAIL_FROM_ADDRESS: z.string().optional(),
SMTP_CONNECTION_URL: z.string().optional(),
- // Cloudflare Turnstile. When the secret is set, credentials sign-in and
- // email sign-up require a valid token whose hostname is in
- // TURNSTILE_HOSTNAMES (comma-separated frontend hostnames).
+ // Cloudflare Turnstile. When the secret is set, credentials sign-in,
+ // email sign-up, and password-reset code emails require a valid token
+ // whose hostname is in TURNSTILE_HOSTNAMES (comma-separated frontend
+ // hostnames).
TURNSTILE_SECRET: z.string().optional(),
TURNSTILE_HOSTNAMES: z.string().optional(),
diff --git a/web/src/features/auth-credentials/components/ResetPasswordButton.clienttest.tsx b/web/src/features/auth-credentials/components/ResetPasswordButton.clienttest.tsx
new file mode 100644
index 0000000000..072f630c69
--- /dev/null
+++ b/web/src/features/auth-credentials/components/ResetPasswordButton.clienttest.tsx
@@ -0,0 +1,169 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { signInMock, envState } = vi.hoisted(() => ({
+ signInMock: vi.fn(),
+ envState: { siteKey: undefined as string | undefined },
+}));
+
+vi.mock("next-auth/react", () => ({
+ signIn: (...args: unknown[]) => signInMock(...args),
+ useSession: () => ({ status: "unauthenticated", data: null }),
+}));
+
+vi.mock("@/src/features/posthog-analytics", () => ({
+ usePostHogClientCapture: () => vi.fn(),
+}));
+
+vi.mock("@/src/env.mjs", () => ({
+ env: {
+ get NEXT_PUBLIC_TURNSTILE_SITE_KEY() {
+ return envState.siteKey;
+ },
+ NEXT_PUBLIC_BASE_PATH: "",
+ },
+}));
+
+vi.mock("@/src/features/auth/components/TurnstileWidget", async () => {
+ const React = await import("react");
+ return {
+ TurnstileWidget: ({
+ action,
+ onTokenChange,
+ ref,
+ }: {
+ action: string;
+ onTokenChange: (token: string | undefined) => void;
+ ref?: React.Ref<{ reset: () => void }>;
+ }) => {
+ React.useImperativeHandle(ref, () => ({
+ reset: () => onTokenChange(undefined),
+ nextToken: () => Promise.resolve(undefined),
+ }));
+ return (
+ <button type="button" onClick={() => onTokenChange("captcha-token")}>
+ Complete captcha {action}
+ </button>
+ );
+ },
+ };
+});
+
+import { RequestResetPasswordEmailButton } from "@/src/features/auth-credentials/components/ResetPasswordButton";
+import {
+ TURNSTILE_ACTIONS,
+ TURNSTILE_FAILED_MESSAGE,
+} from "@/src/features/auth/constants";
+
+describe("RequestResetPasswordEmailButton captcha", () => {
+ beforeEach(() => {
+ signInMock.mockReset();
+ signInMock.mockResolvedValue({ ok: true });
+ envState.siteKey = undefined;
+ });
+
+ it("sends the reset email without a captcha token when Turnstile is off", async () => {
+ render(
+ <RequestResetPasswordEmailButton
+ onEmailSent={vi.fn()}
+ />,
+ );
+
+ fireEvent.click(
+ screen.getByRole("button", { name: "Request password reset" }),
+ );
+
+ await waitFor(() => {
+ expect(signInMock).toHaveBeenCalledWith("email", {
+ email: "[email protected]",
+ callbackUrl: "/auth/reset-password",
+ redirect: false,
+ });
+ });
+ });
+
+ it("holds the reset email until the captcha token is sent", async () => {
+ envState.siteKey = "site-key";
+ const onEmailSent = vi.fn();
+ render(
+ <RequestResetPasswordEmailButton
+ onEmailSent={onEmailSent}
+ />,
+ );
+
+ const submit = screen.getByRole("button", {
+ name: "Request password reset",
+ }) as HTMLButtonElement;
+ expect(submit.disabled).toBe(true);
+ fireEvent.click(submit);
+ expect(signInMock).not.toHaveBeenCalled();
+
+ fireEvent.click(
+ screen.getByRole("button", {
+ name: `Complete captcha ${TURNSTILE_ACTIONS.passwordReset}`,
+ }),
+ );
+ fireEvent.click(
+ screen.getByRole("button", { name: "Request password reset" }),
+ );
+
+ await waitFor(() => {
+ expect(signInMock).toHaveBeenCalledWith("email", {
+ email: "[email protected]",
+ callbackUrl: "/auth/reset-password",
+ redirect: false,
+ turnstileToken: "captcha-token",
+ });
+ });
+ expect(onEmailSent).toHaveBeenCalledOnce();
+
+ await waitFor(() => {
+ expect(submit.disabled).toBe(true);
+ });
+ fireEvent.click(submit);
+ expect(signInMock).toHaveBeenCalledTimes(1);
+
+ fireEvent.click(
+ screen.getByRole("button", {
+ name: `Complete captcha ${TURNSTILE_ACTIONS.passwordReset}`,
+ }),
+ );
+ expect(submit.disabled).toBe(false);
+ });
+
+ it("shows the captcha message when NextAuth prefixes the thrown error", async () => {
+ envState.siteKey = "site-key";
+ signInMock.mockResolvedValue({
+ ok: false,
+ error: `Error: ${TURNSTILE_FAILED_MESSAGE}`,
+ });
+ render(
+ <RequestResetPasswordEmailButton
+ onEmailSent={vi.fn()}
+ />,
+ );
+
+ fireEvent.click(
+ screen.getByRole("button", {
+ name: `Complete captcha ${TURNSTILE_ACTIONS.passwordReset}`,
+ }),
+ );
+ fireEvent.click(
+ screen.getByRole("button", { name: "Request password reset" }),
+ );
+
+ expect(await screen.findByText(TURNSTILE_FAILED_MESSAGE)).toBeTruthy();
+
+ const submit = screen.getByRole("button", {
+ name: "Request password reset",
+ }) as HTMLButtonElement;
+ await waitFor(() => {
+ expect(submit.disabled).toBe(true);
+ });
+ fireEvent.click(submit);
+ expect(signInMock).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/web/src/features/auth-credentials/components/ResetPasswordButton.tsx b/web/src/features/auth-credentials/components/ResetPasswordButton.tsx
index 7e1dea64a6..3cc53fa275 100644
--- a/web/src/features/auth-credentials/components/ResetPasswordButton.tsx
+++ b/web/src/features/auth-credentials/components/ResetPasswordButton.tsx
@@ -1,32 +1,67 @@
import { signIn, useSession } from "next-auth/react";
import { Button } from "@/src/components/ui/button";
-import { useState } from "react";
+import { useEffect, useRef, useState } from "react";
import { z } from "zod";
import { usePostHogClientCapture } from "@/src/features/posthog-analytics";
import { env } from "@/src/env.mjs";
+import {
+ TURNSTILE_ACTIONS,
+ TURNSTILE_FAILED_MESSAGE,
+ type TurnstileAction,
+} from "@/src/features/auth/constants";
+import {
+ TurnstileWidget,
+ type TurnstileWidgetHandle,
+} from "@/src/features/auth/components/TurnstileWidget";
export function RequestResetPasswordEmailButton({
email,
callbackUrl,
onEmailSent,
label,
+ sharedTurnstile,
}: {
email: string;
callbackUrl?: string;
onEmailSent: () => void;
label?: string;
+ // Set when the page already shows a Turnstile widget. This button then
+ // uses that widget instead of mounting a second one.
+ sharedTurnstile?: {
+ token: string | undefined;
+ action: TurnstileAction;
+ onPreparePasswordReset: () => void;
+ onRejectToken: () => void;
+ };
}) {
const [isLoading, setIsLoading] = useState(false);
const [errorMessage, setErrorMessage] = useState<string | null>(null);
+ const [awaitingSharedToken, setAwaitingSharedToken] = useState(false);
+ const sendStarted = useRef(false);
+ const sendResetEmailRef = useRef<
+ (token: string | undefined) => Promise<void>
+ >(async () => {});
const session = useSession();
const capture = usePostHogClientCapture();
const isValidEmail = z.email().safeParse(email).success;
+ const turnstileSiteKey = env.NEXT_PUBLIC_TURNSTILE_SITE_KEY;
+ const [turnstileToken, setTurnstileToken] = useState<string>();
+ const turnstileRef = useRef<TurnstileWidgetHandle>(null);
- const handleResetPassword = async () => {
- if (!isValidEmail) return;
+ const captchaToken = sharedTurnstile?.token ?? turnstileToken;
+ const awaitingPasswordResetToken =
+ awaitingSharedToken ||
+ (sharedTurnstile
+ ? sharedTurnstile.action === TURNSTILE_ACTIONS.passwordReset &&
+ !sharedTurnstile.token
+ : Boolean(turnstileSiteKey) && !turnstileToken);
+
+ async function sendResetEmail(token: string | undefined) {
+ if ((sharedTurnstile || turnstileSiteKey) && !token) return;
capture("auth:reset_password_email_requested");
setIsLoading(true);
setErrorMessage(null);
+ let sent = false;
try {
const targetCallbackUrl = callbackUrl
? `${env.NEXT_PUBLIC_BASE_PATH ?? ""}${callbackUrl}`
@@ -35,31 +70,70 @@ export function RequestResetPasswordEmailButton({
email: email,
callbackUrl: targetCallbackUrl,
redirect: false,
+ ...(token ? { turnstileToken: token } : {}),
});
if (res?.error) {
- setErrorMessage(
- res.error === "AccessDenied"
- ? "This email is not associated with any account."
- : res.error,
- );
+ setErrorMessage(resetEmailSignInError(res.error));
} else if (res?.ok) {
+ sent = true;
onEmailSent();
}
} catch (error) {
console.error("Error sending reset password email:", error);
setErrorMessage("An unexpected error occurred. Please try again.");
} finally {
+ // The token was redeemed (or rejected) by this attempt either way.
+ if (sharedTurnstile) {
+ if (!sent) sharedTurnstile.onRejectToken();
+ } else {
+ turnstileRef.current?.reset();
+ }
setIsLoading(false);
}
+ }
+
+ sendResetEmailRef.current = sendResetEmail;
+
+ useEffect(() => {
+ if (!awaitingSharedToken || !sharedTurnstile?.token) return;
+ if (sharedTurnstile.action !== TURNSTILE_ACTIONS.passwordReset) return;
+ if (sendStarted.current) return;
+ sendStarted.current = true;
+ const token = sharedTurnstile.token;
+ setAwaitingSharedToken(false);
+ sendResetEmailRef.current(token).finally(() => {
+ sendStarted.current = false;
+ });
+ }, [awaitingSharedToken, sharedTurnstile?.action, sharedTurnstile?.token]);
+
+ const handleResetPassword = () => {
+ if (!isValidEmail) return;
+ if (
+ sharedTurnstile &&
+ sharedTurnstile.action !== TURNSTILE_ACTIONS.passwordReset
+ ) {
+ setAwaitingSharedToken(true);
+ sharedTurnstile.onPreparePasswordReset();
+ return;
+ }
+ sendResetEmail(captchaToken);
};
return (
<>
+ {turnstileSiteKey && !sharedTurnstile ? (
+ <TurnstileWidget
+ ref={turnstileRef}
+ siteKey={turnstileSiteKey}
+ action={TURNSTILE_ACTIONS.passwordReset}
+ onTokenChange={setTurnstileToken}
+ />
+ ) : null}
<Button
type="button"
onClick={handleResetPassword}
loading={isLoading}
- disabled={!isValidEmail}
+ disabled={!isValidEmail || awaitingPasswordResetToken}
className="w-full"
>
{label ??
@@ -75,3 +149,15 @@ export function RequestResetPasswordEmailButton({
</>
);
}
+
+// NextAuth's email sign-in catch puts the thrown Error into the query via
+// URLSearchParams, which stringifies it as "Error: <message>".
+function resetEmailSignInError(error: string): string {
+ if (error === "AccessDenied") {
+ return "This email is not associated with any account.";
+ }
+ if (error.includes(TURNSTILE_FAILED_MESSAGE)) {
+ return TURNSTILE_FAILED_MESSAGE;
+ }
+ return error;
+}
diff --git a/web/src/features/auth-credentials/components/ResetPasswordPage.captcha.clienttest.tsx b/web/src/features/auth-credentials/components/ResetPasswordPage.captcha.clienttest.tsx
new file mode 100644
index 0000000000..266173d8f3
--- /dev/null
+++ b/web/src/features/auth-credentials/components/ResetPasswordPage.captcha.clienttest.tsx
@@ -0,0 +1,130 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { signInMock, envState } = vi.hoisted(() => ({
+ signInMock: vi.fn(),
+ envState: { siteKey: "site-key" as string | undefined },
+}));
+
+vi.mock("next-auth/react", () => ({
+ signIn: (...args: unknown[]) => signInMock(...args),
+ useSession: () => ({ status: "unauthenticated", data: null }),
+}));
+
+vi.mock("next/router", () => ({
+ useRouter: () => ({
+ push: vi.fn(),
+ query: {},
+ isReady: true,
+ }),
+}));
+
+vi.mock("@/src/utils/api", () => ({
+ api: {
+ credentials: {
+ resetPassword: {
+ useMutation: () => ({
+ mutateAsync: vi.fn(),
+ isPending: false,
+ }),
+ },
+ },
+ },
+}));
+
+vi.mock("@/src/features/posthog-analytics", () => ({
+ usePostHogClientCapture: () => vi.fn(),
+}));
+
+vi.mock("@/src/features/organizations", () => ({
+ useLangfuseCloudRegion: () => ({
+ isLangfuseCloud: false,
+ region: undefined,
+ }),
+}));
+
+vi.mock("@/src/env.mjs", () => ({
+ env: {
+ get NEXT_PUBLIC_TURNSTILE_SITE_KEY() {
+ return envState.siteKey;
+ },
+ NEXT_PUBLIC_BASE_PATH: "",
+ },
+}));
+
+vi.mock("@/src/features/auth/components/TurnstileWidget", () => ({
+ TurnstileWidget: ({
+ action,
+ onTokenChange,
+ }: {
+ action: string;
+ onTokenChange: (token: string | undefined) => void;
+ }) => (
+ <button type="button" onClick={() => onTokenChange(`${action}-token`)}>
+ Complete captcha {action}
+ </button>
+ ),
+}));
+
+import { ResetPasswordPage } from "@/src/features/auth-credentials/components/ResetPasswordPage";
+import { TURNSTILE_ACTIONS } from "@/src/features/auth/constants";
+
+describe("ResetPasswordPage captcha", () => {
+ beforeEach(() => {
+ signInMock.mockReset();
+ signInMock.mockResolvedValue({ ok: true });
+ envState.siteKey = "site-key";
+ });
+
+ it("shows one captcha on the code form and reuses it to send another code", async () => {
+ render(
+ <ResetPasswordPage
+ passwordResetAvailable
+ initialEmail="[email protected]"
+ intent="setup"
+ />,
+ );
+
+ expect(
+ screen.getAllByRole("button", { name: /Complete captcha/ }),
+ ).toHaveLength(1);
+ expect(
+ screen.getByRole("button", {
+ name: `Complete captcha ${TURNSTILE_ACTIONS.login}`,
+ }),
+ ).toBeTruthy();
+
+ fireEvent.click(screen.getByRole("button", { name: "Send another code" }));
+ expect(signInMock).not.toHaveBeenCalled();
+ expect(
+ screen.getAllByRole("button", { name: /Complete captcha/ }),
+ ).toHaveLength(1);
+
+ const resendCaptcha = screen.getByRole("button", {
+ name: `Complete captcha ${TURNSTILE_ACTIONS.passwordReset}`,
+ });
+ const resend = screen.getByRole("button", {
+ name: "Send another code",
+ }) as HTMLButtonElement;
+ expect(resend.disabled).toBe(true);
+
+ fireEvent.click(resendCaptcha);
+
+ await waitFor(() => {
+ expect(signInMock).toHaveBeenCalledWith("email", {
+ email: "[email protected]",
+ callbackUrl: "/auth/setup-password",
+ redirect: false,
+ turnstileToken: `${TURNSTILE_ACTIONS.passwordReset}-token`,
+ });
+ });
+ expect(
+ screen.getAllByRole("button", { name: /Complete captcha/ }),
+ ).toHaveLength(1);
+ expect(
+ screen.getByRole("button", {
+ name: `Complete captcha ${TURNSTILE_ACTIONS.login}`,
+ }),
+ ).toBeTruthy();
+ });
+});
diff --git a/web/src/features/auth-credentials/components/ResetPasswordPage.clienttest.tsx b/web/src/features/auth-credentials/components/ResetPasswordPage.clienttest.tsx
index a1d2fa20de..ee6000fbcc 100644
--- a/web/src/features/auth-credentials/components/ResetPasswordPage.clienttest.tsx
+++ b/web/src/features/auth-credentials/components/ResetPasswordPage.clienttest.tsx
@@ -6,6 +6,7 @@ import {
waitFor,
} from "@testing-library/react";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type * as EnvModule from "@/src/env.mjs";
const {
mutateAsyncMock,
@@ -60,6 +61,16 @@ vi.mock("@/src/features/organizations/hooks", () => ({
useLangfuseCloudRegion: () => useLangfuseCloudRegionMock(),
}));
+vi.mock("@/src/env.mjs", async () => {
+ const actual = await vi.importActual<typeof EnvModule>("@/src/env.mjs");
+ return {
+ env: {
+ ...actual.env,
+ NEXT_PUBLIC_TURNSTILE_SITE_KEY: undefined,
+ },
+ };
+});
+
vi.mock(
"@/src/features/auth-credentials/components/ResetPasswordButton",
() => ({
diff --git a/web/src/features/auth-credentials/components/ResetPasswordPage.tsx b/web/src/features/auth-credentials/components/ResetPasswordPage.tsx
index fa2dfe9d4f..bb48ab89fe 100644
--- a/web/src/features/auth-credentials/components/ResetPasswordPage.tsx
+++ b/web/src/features/auth-credentials/components/ResetPasswordPage.tsx
@@ -85,6 +85,9 @@ export function ResetPasswordPage({
const effectiveEmail = session.data?.user?.email ?? email;
const turnstileSiteKey = env.NEXT_PUBLIC_TURNSTILE_SITE_KEY;
const [turnstileToken, setTurnstileToken] = useState<string>();
+ const [turnstileAction, setTurnstileAction] = useState<
+ typeof TURNSTILE_ACTIONS.login | typeof TURNSTILE_ACTIONS.passwordReset
+ >(TURNSTILE_ACTIONS.login);
const turnstileRef = useRef<TurnstileWidgetHandle>(null);
const form = useForm({
@@ -300,7 +303,7 @@ export function ResetPasswordPage({
<TurnstileWidget
ref={turnstileRef}
siteKey={turnstileSiteKey}
- action={TURNSTILE_ACTIONS.login}
+ action={turnstileAction}
onTokenChange={setTurnstileToken}
/>
) : null}
@@ -310,7 +313,9 @@ export function ResetPasswordPage({
className="w-full"
disabled={
mutResetPassword.isPending ||
- (Boolean(turnstileSiteKey) && !turnstileToken)
+ (Boolean(turnstileSiteKey) &&
+ (turnstileAction !== TURNSTILE_ACTIONS.login ||
+ !turnstileToken))
}
loading={mutResetPassword.isPending}
>
@@ -320,8 +325,29 @@ export function ResetPasswordPage({
<RequestResetPasswordEmailButton
email={effectiveEmail}
callbackUrl={isSetMode ? setupPasswordPath : undefined}
- onEmailSent={() => setCodeRequested(true)}
+ onEmailSent={() => {
+ setCodeRequested(true);
+ setTurnstileToken(undefined);
+ setTurnstileAction(TURNSTILE_ACTIONS.login);
+ }}
label="Send another code"
+ sharedTurnstile={
+ turnstileSiteKey
+ ? {
+ token: turnstileToken,
+ action: turnstileAction,
+ onPreparePasswordReset: () => {
+ setTurnstileToken(undefined);
+ setTurnstileAction(
+ TURNSTILE_ACTIONS.passwordReset,
+ );
+ },
+ onRejectToken: () => {
+ turnstileRef.current?.reset();
+ },
+ }
+ : undefined
+ }
/>
</>
) : (
diff --git a/web/src/features/auth/SignUpPage.clienttest.tsx b/web/src/features/auth/SignUpPage.clienttest.tsx
new file mode 100644
index 0000000000..6568e8038f
--- /dev/null
+++ b/web/src/features/auth/SignUpPage.clienttest.tsx
@@ -0,0 +1,171 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { signInMock, fetchMock, routerPushMock, envState } = vi.hoisted(() => ({
+ signInMock: vi.fn(),
+ fetchMock: vi.fn(),
+ routerPushMock: vi.fn(),
+ envState: { siteKey: undefined as string | undefined },
+}));
+
+vi.mock("next-auth/react", () => ({
+ signIn: (...args: unknown[]) => signInMock(...args),
+ useSession: () => ({ status: "unauthenticated", data: null }),
+}));
+
+vi.mock("next/router", () => ({
+ useRouter: () => ({
+ push: routerPushMock,
+ query: {},
+ asPath: "/auth/sign-up",
+ isReady: true,
+ }),
+}));
+
+vi.mock("@/src/features/posthog-analytics", () => ({
+ usePostHogClientCapture: () => vi.fn(),
+}));
+
+vi.mock("@/src/env.mjs", () => ({
+ env: {
+ get NEXT_PUBLIC_TURNSTILE_SITE_KEY() {
+ return envState.siteKey;
+ },
+ NEXT_PUBLIC_BASE_PATH: "",
+ },
+}));
+
+vi.mock("@/src/features/auth/components/TurnstileWidget", async () => {
+ const React = await import("react");
+ return {
+ TurnstileWidget: ({
+ action,
+ onTokenChange,
+ ref,
+ }: {
+ action: string;
+ onTokenChange: (token: string | undefined) => void;
+ ref?: React.Ref<{
+ reset: () => void;
+ nextToken: () => Promise<string | undefined>;
+ }>;
+ }) => {
+ React.useImperativeHandle(ref, () => ({
+ reset: () => onTokenChange(undefined),
+ // A new action re-renders the widget and drops the in-flight waiter
+ // before the next challenge callback, matching TurnstileWidget.
+ nextToken: () => Promise.resolve(undefined),
+ }));
+ return (
+ <button type="button" onClick={() => onTokenChange(`${action}-token`)}>
+ Complete captcha {action}
+ </button>
+ );
+ },
+ };
+});
+
+import SignUpPage from "@/src/features/auth/SignUpPage";
+import { FALLBACK_AUTH_PROVIDERS } from "@/src/features/auth/SignInPage";
+import { TURNSTILE_ACTIONS } from "@/src/features/auth/constants";
+
+function renderVerifiedSignup() {
+ render(
+ <SignUpPage
+ authProviders={FALLBACK_AUTH_PROVIDERS}
+ runningOnHuggingFaceSpaces={false}
+ signUpDisabled={false}
+ emailVerificationRequired
+ />,
+ );
+}
+
+async function fillSignupForm() {
+ fireEvent.change(screen.getByPlaceholderText("Jane Doe"), {
+ target: { value: "Jane Doe" },
+ });
+ fireEvent.change(screen.getByPlaceholderText("[email protected]"), {
+ target: { value: "[email protected]" },
+ });
+}
+
+describe("VerifiedSignupFlow captcha", () => {
+ beforeEach(() => {
+ signInMock.mockReset();
+ signInMock.mockResolvedValue({ ok: true, error: null });
+ fetchMock.mockReset();
+ fetchMock.mockResolvedValue({
+ ok: true,
+ json: async () => ({}),
+ });
+ vi.stubGlobal("fetch", fetchMock);
+ routerPushMock.mockReset();
+ envState.siteKey = undefined;
+ });
+
+ it("sends the setup code without a captcha token when Turnstile is off", async () => {
+ renderVerifiedSignup();
+ await fillSignupForm();
+ fireEvent.click(screen.getByRole("button", { name: "Continue" }));
+
+ await waitFor(() => {
+ expect(signInMock).toHaveBeenCalledWith("email", {
+ email: "[email protected]",
+ callbackUrl: "/auth/setup-password",
+ redirect: false,
+ });
+ });
+ expect(fetchMock).toHaveBeenCalledOnce();
+ });
+
+ it("sends the setup code with a fresh password-reset token", async () => {
+ envState.siteKey = "site-key";
+ renderVerifiedSignup();
+ await fillSignupForm();
+
+ const continueButton = screen.getByRole("button", {
+ name: "Continue",
+ }) as HTMLButtonElement;
+ expect(continueButton.disabled).toBe(true);
+
+ fireEvent.click(
+ screen.getByRole("button", {
+ name: `Complete captcha ${TURNSTILE_ACTIONS.signupVerify}`,
+ }),
+ );
+ fireEvent.click(continueButton);
+
+ await waitFor(() => {
+ expect(fetchMock).toHaveBeenCalledOnce();
+ });
+ expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toMatchObject({
+ email: "[email protected]",
+ turnstileToken: `${TURNSTILE_ACTIONS.signupVerify}-token`,
+ });
+ expect(signInMock).not.toHaveBeenCalled();
+ expect(
+ await screen.findByText(
+ "Your account was created. Complete the captcha to receive the verification code.",
+ ),
+ ).toBeTruthy();
+
+ fireEvent.click(
+ screen.getByRole("button", {
+ name: `Complete captcha ${TURNSTILE_ACTIONS.passwordReset}`,
+ }),
+ );
+ fireEvent.click(
+ screen.getByRole("button", { name: "Send verification code" }),
+ );
+
+ await waitFor(() => {
+ expect(signInMock).toHaveBeenCalledWith("email", {
+ email: "[email protected]",
+ callbackUrl: "/auth/setup-password",
+ redirect: false,
+ turnstileToken: `${TURNSTILE_ACTIONS.passwordReset}-token`,
+ });
+ });
+ expect(fetchMock).toHaveBeenCalledOnce();
+ });
+});
diff --git a/web/src/features/auth/SignUpPage.tsx b/web/src/features/auth/SignUpPage.tsx
index b1195476da..49519484cd 100644
--- a/web/src/features/auth/SignUpPage.tsx
+++ b/web/src/features/auth/SignUpPage.tsx
@@ -40,13 +40,18 @@ import {
TurnstileWidget,
type TurnstileWidgetHandle,
} from "@/src/features/auth/components/TurnstileWidget";
-import { TURNSTILE_ACTIONS } from "@/src/features/auth/constants";
+import {
+ TURNSTILE_ACTIONS,
+ TURNSTILE_FAILED_MESSAGE,
+} from "@/src/features/auth/constants";
type NextAuthProvider = NonNullable<Parameters<typeof signIn>[0]>;
const LOGIN_CAPTCHA_WAIT_MS = 20_000;
const ACCOUNT_CREATED_MESSAGE =
"Your account was created. Complete the captcha, then sign in.";
+const VERIFICATION_CODE_PENDING_MESSAGE =
+ "Your account was created. Complete the captcha to receive the verification code.";
function waitForLoginToken(
pending: Promise<string | undefined> | undefined,
@@ -67,6 +72,16 @@ function waitForLoginToken(
});
}
+function verifiedSignupSignInError(error: string): string {
+ if (error === "AccessDenied") {
+ return "Unable to send verification email. Please try again.";
+ }
+ if (error.includes(TURNSTILE_FAILED_MESSAGE)) {
+ return TURNSTILE_FAILED_MESSAGE;
+ }
+ return error;
+}
+
// Schema for the verified signup flow (email + name only, no password)
const signupVerifyFormSchema = z.object({
name: StringNoHTMLNonEmpty.refine((value) => noUrlCheck(value), {
@@ -435,6 +450,14 @@ function VerifiedSignupFlow({
const [formError, setFormError] = useState<string | null>(null);
const turnstileSiteKey = env.NEXT_PUBLIC_TURNSTILE_SITE_KEY;
const [turnstileToken, setTurnstileToken] = useState<string>();
+ // Account creation spends a `signup_verify` token. The setup-code email
+ // is a separate siteverify check, so the widget switches to
+ // `password_reset` once the account exists.
+ const [turnstileAction, setTurnstileAction] = useState<
+ | typeof TURNSTILE_ACTIONS.signupVerify
+ | typeof TURNSTILE_ACTIONS.passwordReset
+ >(TURNSTILE_ACTIONS.signupVerify);
+ const [accountCreated, setAccountCreated] = useState(false);
const turnstileRef = useRef<TurnstileWidgetHandle>(null);
const [lastUsedAuthMethod, setLastUsedAuthMethod] =
useLocalStorage<NextAuthProvider | null>(
@@ -450,13 +473,43 @@ function VerifiedSignupFlow({
},
});
+ async function sendSetupCode(
+ values: z.infer<typeof signupVerifyFormSchema>,
+ passwordResetToken: string | undefined,
+ ) {
+ const signInRes = await signIn("email", {
+ email: values.email,
+ callbackUrl: `${env.NEXT_PUBLIC_BASE_PATH ?? ""}${setupPasswordPath}`,
+ redirect: false,
+ ...(passwordResetToken ? { turnstileToken: passwordResetToken } : {}),
+ });
+
+ if (signInRes?.error) {
+ turnstileRef.current?.reset();
+ setFormError(verifiedSignupSignInError(signInRes.error));
+ return;
+ }
+
+ capture("sign_up:button_click", { provider: "email_verification" });
+ sessionStorage.setItem(
+ PASSWORD_SETUP_EMAIL_STORAGE_KEY,
+ values.email.toLowerCase(),
+ );
+ await router.push(setupPasswordPath);
+ }
+
async function onVerifiedSubmit(
values: z.infer<typeof signupVerifyFormSchema>,
) {
+ let created = accountCreated;
try {
setFormError(null);
- // Call signup-verify to create passwordless user
+ if (created) {
+ await sendSetupCode(values, turnstileToken);
+ return;
+ }
+
const res = await fetch(
`${env.NEXT_PUBLIC_BASE_PATH ?? ""}/api/auth/signup-verify`,
{
@@ -469,39 +522,39 @@ function VerifiedSignupFlow({
}),
},
);
- turnstileRef.current?.reset();
if (!res.ok) {
+ turnstileRef.current?.reset();
const payload = (await res.json()) as { message: string };
setFormError(payload.message);
return;
}
- // Send OTP email via NextAuth email provider
- const signInRes = await signIn("email", {
- email: values.email,
- callbackUrl: `${env.NEXT_PUBLIC_BASE_PATH ?? ""}${setupPasswordPath}`,
- redirect: false,
- });
+ created = true;
+ setAccountCreated(true);
- if (signInRes?.error) {
- setFormError(
- signInRes.error === "AccessDenied"
- ? "Unable to send verification email. Please try again."
- : signInRes.error,
- );
+ // The signup request redeemed its token. The setup-code email needs
+ // a fresh token issued for `password_reset`.
+ let passwordResetToken: string | undefined;
+ if (turnstileSiteKey) {
+ const pendingToken = turnstileRef.current?.nextToken();
+ setTurnstileToken(undefined);
+ setTurnstileAction(TURNSTILE_ACTIONS.passwordReset);
+ passwordResetToken = await waitForLoginToken(pendingToken);
+ }
+ if (turnstileSiteKey && !passwordResetToken) {
+ setFormError(VERIFICATION_CODE_PENDING_MESSAGE);
return;
}
- capture("sign_up:button_click", { provider: "email_verification" });
- sessionStorage.setItem(
- PASSWORD_SETUP_EMAIL_STORAGE_KEY,
- values.email.toLowerCase(),
- );
- await router.push(setupPasswordPath);
+ await sendSetupCode(values, passwordResetToken);
} catch {
turnstileRef.current?.reset();
- setFormError("An error occurred. Please try again.");
+ setFormError(
+ created
+ ? VERIFICATION_CODE_PENDING_MESSAGE
+ : "An error occurred. Please try again.",
+ );
}
}
@@ -547,7 +600,7 @@ function VerifiedSignupFlow({
<TurnstileWidget
ref={turnstileRef}
siteKey={turnstileSiteKey}
- action={TURNSTILE_ACTIONS.signupVerify}
+ action={turnstileAction}
onTokenChange={setTurnstileToken}
/>
)}
@@ -558,7 +611,7 @@ function VerifiedSignupFlow({
disabled={Boolean(turnstileSiteKey) && !turnstileToken}
data-testid="submit-email-password-sign-up-form"
>
- Continue
+ {accountCreated ? "Send verification code" : "Continue"}
</Button>
{formError ? (
<div className="text-destructive text-center text-sm font-bold">
diff --git a/web/src/features/auth/constants.ts b/web/src/features/auth/constants.ts
index 48da98af2e..54c19bb0ad 100644
--- a/web/src/features/auth/constants.ts
+++ b/web/src/features/auth/constants.ts
@@ -20,6 +20,9 @@ export const TURNSTILE_ACTIONS = {
login: "login",
signup: "signup",
signupVerify: "signup_verify",
+ // Password-reset and password-setup both send the code through the
+ // NextAuth email provider.
+ passwordReset: "password_reset",
} as const;
export type TurnstileAction =
diff --git a/web/src/pages/api/auth/[...nextauth].ts b/web/src/pages/api/auth/[...nextauth].ts
index 338099e510..797374cfec 100644
--- a/web/src/pages/api/auth/[...nextauth].ts
+++ b/web/src/pages/api/auth/[...nextauth].ts
@@ -1,5 +1,6 @@
import { getAuthOptions } from "@/src/server/auth";
import { getAdClickIdsFromRequest } from "@/src/features/auth/lib/signupAttribution";
+import { getTurnstileRemoteIp } from "@/src/features/auth/server/verifyTurnstile";
import { getCookieName } from "@/src/server/utils/cookies";
import { isValidCallbackUrl } from "@/src/server/utils/nextAuthCallbackUrl";
import { env } from "@/src/env.mjs";
@@ -169,9 +170,30 @@ export default async function auth(req: NextApiRequest, res: NextApiResponse) {
// Do whatever you want here, before the request is passed down to `NextAuth`
// Pass Google Ads click attribution from first-party cookies so that new
// SSO signups can be attributed to ad clicks (cloud_signup_complete event).
- const authOptions = await getAuthOptions({
- adClickIds: getAdClickIdsFromRequest(req),
- });
+ // Password reset asks NextAuth's email provider for a code. The sign-in
+ // callback verifies this token before that email is sent.
+ //
+ // The Turnstile check itself lives in the `signIn` callback (auth.ts), which
+ // already limits it to the email provider's send request. This flag only
+ // controls when the token and client IP are read from the request body:
+ // for POST /api/auth/signin/email, the one request that consumes them. For
+ // every other request on this route, the request context is undefined and
+ // nothing in the body is inspected or forwarded.
+ const isPasswordResetEmailRequest =
+ req.method === "POST" &&
+ nextAuthAction === "signin" &&
+ nextAuthProvider === "email";
+ const authOptions = await getAuthOptions(
+ {
+ adClickIds: getAdClickIdsFromRequest(req),
+ },
+ isPasswordResetEmailRequest
+ ? {
+ turnstileToken: req.body?.turnstileToken,
+ turnstileRemoteIp: getTurnstileRemoteIp(req.headers),
+ }
+ : undefined,
+ );
// https://github.com/nextauthjs/next-auth/issues/2408#issuecomment-1382629234
// for api routes, we need to call the headers in the api route itself
// disable caching for anything auth related
diff --git a/web/src/server/auth.ts b/web/src/server/auth.ts
index 880bceab41..75dc2a57b1 100644
--- a/web/src/server/auth.ts
+++ b/web/src/server/auth.ts
@@ -729,12 +729,20 @@ const createExtendedPrismaAdapter = (signupAttribution?: {
* @param signupAttribution - per-request marketing attribution (ad-platform
* click ids) attached to the signup analytics event if the request results
* in a new user. Only passed by the NextAuth API route.
+ * @param requestContext - captcha material for this request. The email
+ * sign-in route passes the password-reset token; other callers omit it.
*
* @see https://next-auth.js.org/configuration/options
*/
-export async function getAuthOptions(signupAttribution?: {
- adClickIds?: AdClickIds;
-}): Promise<NextAuthOptions> {
+export async function getAuthOptions(
+ signupAttribution?: {
+ adClickIds?: AdClickIds;
+ },
+ requestContext?: {
+ turnstileToken?: unknown;
+ turnstileRemoteIp?: string;
+ },
+): Promise<NextAuthOptions> {
let dynamicSsoProviders: Provider[] = [];
try {
dynamicSsoProviders = await loadSsoProviders();
@@ -1083,6 +1091,15 @@ export async function getAuthOptions(signupAttribution?: {
return false;
}
+ // Checked before the user lookup so a missing or rejected token
+ // never sends a code, and does not reveal whether the account exists.
+ const turnstileValid = await verifyTurnstileToken({
+ token: requestContext?.turnstileToken,
+ action: TURNSTILE_ACTIONS.passwordReset,
+ remoteIp: requestContext?.turnstileRemoteIp,
+ });
+ if (!turnstileValid) throw new Error(TURNSTILE_FAILED_MESSAGE);
+
// Codes only reset passwords, so there is nothing to send when
// password login is disabled.
if (env.AUTH_DISABLE_USERNAME_PASSWORD === "true") {