The Open Source DocuSign Alternative.
TypeScript digital-signaturedocument-signingdocusign-alternativee-signatureesignesignaturenext-authnextjsopen-sourcepades-standardpdfpdf-signpdf-signaturepostgresqlprismaself-hostedsigningtypescript
fix: improve action auth flow for passwordless users (#3358)
Lucas Smith6a99b40cba6b
diff --git a/apps/remix/app/components/forms/2fa/two-factor-code-dialog.tsx b/apps/remix/app/components/forms/2fa/two-factor-code-dialog.tsxnew file mode 100644index 000000000..79767f58f--- /dev/null+++ b/apps/remix/app/components/forms/2fa/two-factor-code-dialog.tsx@@ -0,0 +1,158 @@+import { Button } from '@documenso/ui/primitives/button';+import {+ Dialog,+ DialogContent,+ DialogDescription,+ DialogFooter,+ DialogHeader,+ DialogTitle,+} from '@documenso/ui/primitives/dialog';+import { FormControl, FormField, FormItem, FormLabel, FormMessage } from '@documenso/ui/primitives/form/form';+import { Input } from '@documenso/ui/primitives/input';+import { PinInput, PinInputGroup, PinInputSlot } from '@documenso/ui/primitives/pin-input';+import { Trans } from '@lingui/react/macro';+import type React from 'react';+import { useState } from 'react';+import { type FieldValues, type Path, useFormContext } from 'react-hook-form';+import { z } from 'zod';++/**+ * Schema for forms that accept a two factor code. Compose with `.extend()` or `.merge()`.+ */+export const ZTwoFactorCodeFieldSchema = z.object({+ totpCode: z.string().trim().optional(),+ backupCode: z.string().trim().optional(),+});++export type TTwoFactorCodeFieldSchema = z.infer<typeof ZTwoFactorCodeFieldSchema>;++export const hasTwoFactorCode = (data: TTwoFactorCodeFieldSchema) => !!data.totpCode || !!data.backupCode;++type TwoFactorMethod = 'totp' | 'backup';++export type TwoFactorCodeDialogProps = {+ open: boolean;+ onOpenChange: (open: boolean) => void;+ isSubmitting?: boolean;+ submitLabel: React.ReactNode;++ /**+ * Called when the user submits the code. Typically the parent form's submit handler.+ */+ onSubmit: () => void;+};++/**+ * Collects a TOTP or backup code on top of an existing form, mirroring the+ * sign in and disable 2FA dialogs.+ *+ * Must be rendered inside a `<Form>` whose values include `totpCode` and `backupCode`.+ */+export const TwoFactorCodeDialog = <T extends FieldValues & TTwoFactorCodeFieldSchema>({+ open,+ onOpenChange,+ isSubmitting,+ submitLabel,+ onSubmit,+}: TwoFactorCodeDialogProps) => {+ const form = useFormContext<T>();++ const [method, setMethod] = useState<TwoFactorMethod>('totp');++ const totpCodeName = 'totpCode' as Path<T>;+ const backupCodeName = 'backupCode' as Path<T>;++ const onToggleMethod = () => {+ form.resetField(totpCodeName);+ form.resetField(backupCodeName);++ setMethod((current) => (current === 'totp' ? 'backup' : 'totp'));+ };++ const handleOpenChange = (value: boolean) => {+ if (isSubmitting) {+ return;+ }++ if (!value) {+ form.resetField(totpCodeName);+ form.resetField(backupCodeName);+ setMethod('totp');+ }++ onOpenChange(value);+ };++ return (+ <Dialog open={open} onOpenChange={handleOpenChange}>+ <DialogContent>+ <DialogHeader>+ <DialogTitle>+ <Trans>Two-Factor Authentication</Trans>+ </DialogTitle>++ <DialogDescription>+ {method === 'totp' ? (+ <Trans>Enter the code from your authenticator app to continue.</Trans>+ ) : (+ <Trans>Enter one of your backup codes to continue.</Trans>+ )}+ </DialogDescription>+ </DialogHeader>++ <fieldset disabled={isSubmitting}>+ {method === 'totp' && (+ <FormField+ control={form.control}+ name={totpCodeName}+ render={({ field }) => (+ <FormItem>+ <FormControl>+ <PinInput {...field} value={field.value ?? ''} maxLength={6} autoFocus>+ {Array(6)+ .fill(null)+ .map((_, i) => (+ <PinInputGroup key={i}>+ <PinInputSlot index={i} />+ </PinInputGroup>+ ))}+ </PinInput>+ </FormControl>+ <FormMessage />+ </FormItem>+ )}+ />+ )}++ {method === 'backup' && (+ <FormField+ control={form.control}+ name={backupCodeName}+ render={({ field }) => (+ <FormItem>+ <FormLabel>+ <Trans>Backup Code</Trans>+ </FormLabel>+ <FormControl>+ <Input type="text" autoComplete="off" autoFocus {...field} value={field.value ?? ''} />+ </FormControl>+ <FormMessage />+ </FormItem>+ )}+ />+ )}++ <DialogFooter className="mt-4">+ <Button type="button" variant="secondary" onClick={onToggleMethod}>+ {method === 'totp' ? <Trans>Use Backup Code</Trans> : <Trans>Use Authenticator</Trans>}+ </Button>++ <Button type="button" loading={isSubmitting} onClick={onSubmit}>+ {submitLabel}+ </Button>+ </DialogFooter>+ </fieldset>+ </DialogContent>+ </Dialog>+ );+};diff --git a/apps/remix/app/components/forms/password-setup-request-button.tsx b/apps/remix/app/components/forms/password-setup-request-button.tsxnew file mode 100644index 000000000..bac09f11d--- /dev/null+++ b/apps/remix/app/components/forms/password-setup-request-button.tsx@@ -0,0 +1,53 @@+import { usePasswordSetupRequest } from '@documenso/lib/client-only/hooks/use-password-setup-request';+import { useSession } from '@documenso/lib/client-only/providers/session';+import { Button } from '@documenso/ui/primitives/button';+import { useToast } from '@documenso/ui/primitives/use-toast';+import { msg } from '@lingui/core/macro';+import { useLingui } from '@lingui/react';+import { Trans } from '@lingui/react/macro';+import { CheckIcon } from 'lucide-react';+import { match } from 'ts-pattern';++/**+ * Compact "send me a setup link" button that reports via toast, for settings+ * cards where the surrounding layout provides the explanation.+ */+export const PasswordSetupRequestButton = () => {+ const { _ } = useLingui();+ const { toast } = useToast();+ const { user } = useSession();++ const { requestSetupLink, isPending, isSuccess } = usePasswordSetupRequest({+ onSuccess: () => {+ toast({+ title: _(msg`Check your email`),+ description: _(msg`We've sent a link to ${user.email}. Follow it to set your password.`),+ duration: 5000,+ });+ },+ onError: (errorCode) => {+ toast({+ title: _(msg`An error occurred`),+ description: match(errorCode)+ .with('SIGNIN_DISABLED', () => _(msg`Password sign in is disabled for this instance.`))+ .otherwise(() => _(msg`We were unable to send the email. Please try again later.`)),+ variant: 'destructive',+ });+ },+ });++ if (isSuccess) {+ return (+ <Button variant="outline" className="flex-shrink-0 bg-background" disabled>+ <CheckIcon className="mr-2 h-4 w-4" />+ <Trans>Link sent</Trans>+ </Button>+ );+ }++ return (+ <Button variant="outline" className="flex-shrink-0 bg-background" loading={isPending} onClick={requestSetupLink}>+ <Trans>Send setup link</Trans>+ </Button>+ );+};diff --git a/apps/remix/app/components/forms/password-setup-request.tsx b/apps/remix/app/components/forms/password-setup-request.tsxnew file mode 100644index 000000000..35cfcaf80--- /dev/null+++ b/apps/remix/app/components/forms/password-setup-request.tsx@@ -0,0 +1,61 @@+import { usePasswordSetupRequest } from '@documenso/lib/client-only/hooks/use-password-setup-request';+import { useSession } from '@documenso/lib/client-only/providers/session';+import { Alert, AlertDescription, AlertTitle } from '@documenso/ui/primitives/alert';+import { Button } from '@documenso/ui/primitives/button';+import { msg } from '@lingui/core/macro';+import { useLingui } from '@lingui/react';+import { Trans } from '@lingui/react/macro';+import { match } from 'ts-pattern';++export type PasswordSetupRequestProps = {+ className?: string;+};++/**+ * Inline "send me a setup link" control with its own sent/error states, for+ * contexts like dialogs where a toast would be missed.+ */+export const PasswordSetupRequest = ({ className }: PasswordSetupRequestProps) => {+ const { _ } = useLingui();+ const { user } = useSession();++ const { requestSetupLink, isPending, isSuccess, errorCode } = usePasswordSetupRequest();++ if (isSuccess) {+ return (+ <Alert className={className} variant="neutral">+ <AlertTitle>+ <Trans>Check your email</Trans>+ </AlertTitle>+ <AlertDescription>+ <Trans>+ We've sent a link to {user.email}. Follow it to set your password, then sign in again to continue.+ </Trans>+ </AlertDescription>+ </Alert>+ );+ }++ return (+ <div className={className}>+ {errorCode && (+ <Alert className="mb-4" variant="destructive">+ <AlertTitle>+ <Trans>An error occurred</Trans>+ </AlertTitle>+ <AlertDescription>+ {match(errorCode)+ .with('SIGNIN_DISABLED', () =>+ _(msg`Password sign in is disabled for this instance. Please contact support.`),+ )+ .otherwise(() => _(msg`We were unable to send the email. Please try again or contact support.`))}+ </AlertDescription>+ </Alert>+ )}++ <Button type="button" loading={isPending} onClick={requestSetupLink}>+ <Trans>Send setup link</Trans>+ </Button>+ </div>+ );+};diff --git a/apps/remix/app/components/forms/password.tsx b/apps/remix/app/components/forms/password.tsxindex d04f84131..65ba8c8c0 100644--- a/apps/remix/app/components/forms/password.tsx+++ b/apps/remix/app/components/forms/password.tsx@@ -1,6 +1,6 @@import { authClient } from '@documenso/auth/client';import type { SessionUser } from '@documenso/auth/server/lib/session/session';-import { AppError } from '@documenso/lib/errors/app-error';+import { AppError, AppErrorCode } from '@documenso/lib/errors/app-error';import { ZCurrentPasswordSchema, ZPasswordSchema } from '@documenso/trpc/server/auth-router/schema';import { cn } from '@documenso/ui/lib/utils';import { Button } from '@documenso/ui/primitives/button';@@ -11,20 +11,21 @@ import { zodResolver } from '@hookform/resolvers/zod';import { msg } from '@lingui/core/macro';import { useLingui } from '@lingui/react';import { Trans } from '@lingui/react/macro';+import { useState } from 'react';import { useForm } from 'react-hook-form';import { match } from 'ts-pattern';-import { z } from 'zod';--export const ZPasswordFormSchema = z- .object({- currentPassword: ZCurrentPasswordSchema,- password: ZPasswordSchema,- repeatedPassword: ZPasswordSchema,- })- .refine((data) => data.password === data.repeatedPassword, {- message: 'Passwords do not match',- path: ['repeatedPassword'],- });+import type { z } from 'zod';++import { hasTwoFactorCode, TwoFactorCodeDialog, ZTwoFactorCodeFieldSchema } from './2fa/two-factor-code-dialog';++export const ZPasswordFormSchema = ZTwoFactorCodeFieldSchema.extend({+ currentPassword: ZCurrentPasswordSchema,+ password: ZPasswordSchema,+ repeatedPassword: ZPasswordSchema,+}).refine((data) => data.password === data.repeatedPassword, {+ message: 'Passwords do not match',+ path: ['repeatedPassword'],+});export type TPasswordFormSchema = z.infer<typeof ZPasswordFormSchema>;@@ -33,29 +34,51 @@ export type PasswordFormProps = {user: SessionUser;};-export const PasswordForm = ({ className }: PasswordFormProps) => {+export const PasswordForm = ({ className, user }: PasswordFormProps) => {const { _ } = useLingui();const { toast } = useToast();+ const [isTwoFactorDialogOpen, setIsTwoFactorDialogOpen] = useState(false);+const form = useForm<TPasswordFormSchema>({values: {currentPassword: '',password: '',repeatedPassword: '',+ totpCode: '',+ backupCode: '',},resolver: zodResolver(ZPasswordFormSchema),});const isSubmitting = form.formState.isSubmitting;- const onFormSubmit = async ({ currentPassword, password }: TPasswordFormSchema) => {+ const onFormSubmit = async (values: TPasswordFormSchema) => {+ const { currentPassword, password, totpCode, backupCode } = values;++ // Collect the 2FA code in a dialog once the password fields are valid.+ if (user.twoFactorEnabled && !hasTwoFactorCode(values)) {+ if (isTwoFactorDialogOpen) {+ const message = _(msg`A code is required`);++ form.setError('totpCode', { message });+ form.setError('backupCode', { message });+ }++ setIsTwoFactorDialogOpen(true);+ return;+ }+try {await authClient.emailPassword.updatePassword({currentPassword,password,+ totpCode: totpCode || undefined,+ backupCode: backupCode || undefined,});form.reset();+ setIsTwoFactorDialogOpen(false);toast({title: _(msg`Password updated`),@@ -66,9 +89,14 @@ export const PasswordForm = ({ className }: PasswordFormProps) => {const error = AppError.parseError(err);const errorMessage = match(error.code)- .with('NO_PASSWORD', () => msg`User has no password.`)- .with('INCORRECT_PASSWORD', () => msg`Current password is incorrect.`)- .with('SAME_PASSWORD', () => msg`Your new password cannot be the same as your old password.`)+ .with(AppErrorCode.NO_PASSWORD, () => msg`User has no password.`)+ .with(AppErrorCode.INCORRECT_PASSWORD, () => msg`Current password is incorrect.`)+ .with(AppErrorCode.SAME_PASSWORD, () => msg`Your new password cannot be the same as your old password.`)+ .with(+ AppErrorCode.INCORRECT_TWO_FACTOR_CODE,+ AppErrorCode.TWO_FACTOR_MISSING_CREDENTIALS,+ () => msg`The two factor code you provided is invalid. Please try again.`,+ ).otherwise(() => msg`We encountered an unknown error while attempting to update your password. Please try again later.`,);@@ -83,7 +111,12 @@ export const PasswordForm = ({ className }: PasswordFormProps) => {return (<Form {...form}>- <form className={cn('flex w-full flex-col gap-y-4', className)} onSubmit={form.handleSubmit(onFormSubmit)}>+ {/* method="post" so a pre-hydration native submit can't leak passwords into the URL. */}+ <form+ method="post"+ className={cn('flex w-full flex-col gap-y-4', className)}+ onSubmit={form.handleSubmit(onFormSubmit)}+ ><fieldset className="flex w-full flex-col gap-y-4" disabled={isSubmitting}><FormFieldcontrol={form.control}@@ -140,6 +173,14 @@ export const PasswordForm = ({ className }: PasswordFormProps) => {</Button></div></form>++ <TwoFactorCodeDialog<TPasswordFormSchema>+ open={isTwoFactorDialogOpen}+ onOpenChange={setIsTwoFactorDialogOpen}+ isSubmitting={isSubmitting}+ submitLabel={<Trans>Update password</Trans>}+ onSubmit={form.handleSubmit(onFormSubmit)}+ /></Form>);};diff --git a/apps/remix/app/components/general/document-signing/document-signing-auth-password.tsx b/apps/remix/app/components/general/document-signing/document-signing-auth-password.tsxindex 2d1b51747..1d2806fda 100644--- a/apps/remix/app/components/general/document-signing/document-signing-auth-password.tsx+++ b/apps/remix/app/components/general/document-signing/document-signing-auth-password.tsx@@ -1,5 +1,7 @@import { AppError } from '@documenso/lib/errors/app-error';import { DocumentAuth, type TRecipientActionAuth } from '@documenso/lib/types/document-auth';+import { UserAuthMethod } from '@documenso/lib/types/user-auth-method';+import { trpc } from '@documenso/trpc/react';import { Alert, AlertDescription, AlertTitle } from '@documenso/ui/primitives/alert';import { Button } from '@documenso/ui/primitives/button';import { DialogFooter } from '@documenso/ui/primitives/dialog';@@ -7,11 +9,13 @@ import { Form, FormControl, FormField, FormItem, FormLabel, FormMessage } from 'import { Input } from '@documenso/ui/primitives/input';import { zodResolver } from '@hookform/resolvers/zod';import { Trans, useLingui } from '@lingui/react/macro';+import { Loader2Icon } from 'lucide-react';import { useEffect, useState } from 'react';import { useForm } from 'react-hook-form';import { z } from 'zod';import { useRequiredDocumentSigningAuthContext } from './document-signing-auth-provider';+import { DocumentSigningAuthSetPassword } from './document-signing-auth-set-password';export type DocumentSigningAuthPasswordProps = {open: boolean;@@ -35,8 +39,12 @@ export const DocumentSigningAuthPassword = ({}: DocumentSigningAuthPasswordProps) => {const { t } = useLingui();- const { recipient, isCurrentlyAuthenticating, setIsCurrentlyAuthenticating } =- useRequiredDocumentSigningAuthContext();+ const { user, isCurrentlyAuthenticating, setIsCurrentlyAuthenticating } = useRequiredDocumentSigningAuthContext();++ // Fetched on demand since this is only needed once the user opts for password auth.+ const { data: authMethodsData, isPending: isAuthMethodsPending } = trpc.auth.getAuthMethods.useQuery(undefined, {+ enabled: !!user,+ });const form = useForm<TPasswordAuthFormSchema>({resolver: zodResolver(ZPasswordAuthFormSchema),@@ -47,6 +55,10 @@ export const DocumentSigningAuthPassword = ({const [formErrorCode, setFormErrorCode] = useState<string | null>(null);+ // If the query fails we fall through to the regular password form rather than blocking.+ const isPasswordSetupRequired =+ !!user && !!authMethodsData && !authMethodsData.authMethods.includes(UserAuthMethod.PASSWORD);+const onFormSubmit = async ({ password }: TPasswordAuthFormSchema) => {try {setIsCurrentlyAuthenticating(true);@@ -64,8 +76,6 @@ export const DocumentSigningAuthPassword = ({const error = AppError.parseError(err);setFormErrorCode(error.code);-- // Todo: Alert.}};@@ -79,9 +89,22 @@ export const DocumentSigningAuthPassword = ({// eslint-disable-next-line react-hooks/exhaustive-deps}, [open]);+ if (user && isAuthMethodsPending) {+ return (+ <div className="flex items-center justify-center py-8">+ <Loader2Icon className="h-6 w-6 animate-spin text-muted-foreground" />+ </div>+ );+ }++ if (isPasswordSetupRequired) {+ return <DocumentSigningAuthSetPassword onOpenChange={onOpenChange} />;+ }+return (<Form {...form}>- <form onSubmit={form.handleSubmit(onFormSubmit)}>+ {/* method="post" so a pre-hydration native submit can't leak the password into the URL. */}+ <form method="post" onSubmit={form.handleSubmit(onFormSubmit)}><fieldset disabled={isCurrentlyAuthenticating}><div className="space-y-4">{formErrorCode && (diff --git a/apps/remix/app/components/general/document-signing/document-signing-auth-set-password.tsx b/apps/remix/app/components/general/document-signing/document-signing-auth-set-password.tsxnew file mode 100644index 000000000..b827c1cbf--- /dev/null+++ b/apps/remix/app/components/general/document-signing/document-signing-auth-set-password.tsx@@ -0,0 +1,63 @@+import { isSigninEnabledForProvider } from '@documenso/lib/constants/auth';+import { Alert, AlertDescription, AlertTitle } from '@documenso/ui/primitives/alert';+import { Button } from '@documenso/ui/primitives/button';+import { DialogFooter } from '@documenso/ui/primitives/dialog';+import { Trans } from '@lingui/react/macro';++import { PasswordSetupRequest } from '~/components/forms/password-setup-request';++export type DocumentSigningAuthSetPasswordProps = {+ onOpenChange: (value: boolean) => void;+};++/**+ * Shown in place of the password reauth form when the signed in user has no+ * password (e.g. they signed up via OAuth or a passkey).+ *+ * Password based action auth is meant to prove more than possession of a session,+ * so rather than letting the session set a password inline we send the user the+ * verified reset link and ask them to come back.+ */+export const DocumentSigningAuthSetPassword = ({ onOpenChange }: DocumentSigningAuthSetPasswordProps) => {+ const isEmailPasswordSigninEnabled = isSigninEnabledForProvider('email');++ return (+ <div className="space-y-4">+ {isEmailPasswordSigninEnabled ? (+ <>+ <Alert variant="neutral">+ <AlertTitle>+ <Trans>No password set</Trans>+ </AlertTitle>+ <AlertDescription>+ <Trans>+ Signing this field requires a password, but your account does not have one. We can email you a link to+ set one. Once done, sign in again and return to this document to continue.+ </Trans>+ </AlertDescription>+ </Alert>++ <PasswordSetupRequest />+ </>+ ) : (+ <Alert variant="warning">+ <AlertTitle>+ <Trans>Password authentication unavailable</Trans>+ </AlertTitle>+ <AlertDescription>+ <Trans>+ Your account does not have a password and password sign in is disabled for this instance. Please contact+ the document sender to use a different authentication method.+ </Trans>+ </AlertDescription>+ </Alert>+ )}++ <DialogFooter>+ <Button type="button" variant="secondary" onClick={() => onOpenChange(false)}>+ <Trans>Close</Trans>+ </Button>+ </DialogFooter>+ </div>+ );+};diff --git a/apps/remix/app/routes/_authenticated+/settings+/security._index.tsx b/apps/remix/app/routes/_authenticated+/settings+/security._index.tsxindex d3a84c848..95844c027 100644--- a/apps/remix/app/routes/_authenticated+/settings+/security._index.tsx+++ b/apps/remix/app/routes/_authenticated+/settings+/security._index.tsx@@ -1,6 +1,8 @@import { getSession } from '@documenso/auth/server/lib/utils/get-session';import { useSession } from '@documenso/lib/client-only/providers/session';-import { prisma } from '@documenso/prisma';+import { isSigninEnabledForProvider } from '@documenso/lib/constants/auth';+import { getUserAuthMethods } from '@documenso/lib/server-only/user/get-user-auth-methods';+import { UserAuthMethod } from '@documenso/lib/types/user-auth-method';import { Alert, AlertDescription, AlertTitle } from '@documenso/ui/primitives/alert';import { Button } from '@documenso/ui/primitives/button';import { msg } from '@lingui/core/macro';@@ -12,6 +14,7 @@ import { DisableAuthenticatorAppDialog } from '~/components/forms/2fa/disable-auimport { EnableAuthenticatorAppDialog } from '~/components/forms/2fa/enable-authenticator-app-dialog';import { ViewRecoveryCodesDialog } from '~/components/forms/2fa/view-recovery-codes-dialog';import { PasswordForm } from '~/components/forms/password';+import { PasswordSetupRequestButton } from '~/components/forms/password-setup-request-button';import { SettingsHeader } from '~/components/general/settings-header';import { appMetaTags } from '~/utils/meta';@@ -24,33 +27,10 @@ export function meta() {export async function loader({ request }: Route.LoaderArgs) {const { user } = await getSession(request);- // Todo: Use providers instead after RR7 migration.- // const accounts = await prisma.account.findMany({- // where: {- // userId: user.id,- // },- // select: {- // provider: true,- // },- // });-- // const providers = accounts.map((account) => account.provider);- // let hasEmailPasswordAccount = providers.includes('DOCUMENSO');-- const hasEmailPasswordAccount: boolean = await prisma.user- .count({- where: {- id: user.id,- password: {- not: null,- },- },- })- .then((value) => value > 0);+ const authMethods = await getUserAuthMethods({ userId: user.id });return {- // providers,- hasEmailPasswordAccount,+ hasEmailPasswordAccount: authMethods.includes(UserAuthMethod.PASSWORD),};}@@ -60,14 +40,36 @@ export default function SettingsSecurity({ loaderData }: Route.ComponentProps) {const { _ } = useLingui();const { user } = useSession();+ const isEmailPasswordSigninEnabled = isSigninEnabledForProvider('email');+return (<div><SettingsHeadertitle={_(msg`Security`)}subtitle={_(msg`Here you can manage your password and security settings.`)}/>+{hasEmailPasswordAccount && <PasswordForm user={user} />}+ {!hasEmailPasswordAccount && isEmailPasswordSigninEnabled && (+ <Alert className="flex flex-col justify-between p-6 sm:flex-row sm:items-center" variant="neutral">+ <div className="mb-4 sm:mb-0">+ <AlertTitle>+ <Trans>Set a password</Trans>+ </AlertTitle>++ <AlertDescription className="mr-4">+ <Trans>+ Your account has no password. Add one to sign in with your email and to sign documents that require it.+ We'll email you a link.+ </Trans>+ </AlertDescription>+ </div>++ <PasswordSetupRequestButton />+ </Alert>+ )}+<Alert className="mt-6 flex flex-col justify-between p-6 sm:flex-row sm:items-center" variant="neutral"><div className="mb-4 sm:mb-0"><AlertTitle>diff --git a/packages/app-tests/e2e/document-auth/action-auth-password.spec.ts b/packages/app-tests/e2e/document-auth/action-auth-password.spec.tsnew file mode 100644index 000000000..bb49fb91f--- /dev/null+++ b/packages/app-tests/e2e/document-auth/action-auth-password.spec.ts@@ -0,0 +1,193 @@+import { createDocumentAuthOptions } from '@documenso/lib/utils/document-auth';+import { prisma } from '@documenso/prisma';+import { seedPendingDocumentWithFullFields } from '@documenso/prisma/seed/documents';+import { seedUser } from '@documenso/prisma/seed/users';+import { expect, test } from '@playwright/test';+import { FieldType } from '@prisma/client';++import { apiSignin } from '../fixtures/authentication';+import { waitForHydration } from '../fixtures/hydration';+import { signSignaturePad } from '../fixtures/signature';++test.describe.configure({ mode: 'parallel', timeout: 60000 });++const SEEDED_PASSWORD = 'password';+const NEW_PASSWORD = 'Test123!';++/**+ * Seed a document requiring PASSWORD action auth for a recipient with an account,+ * and sign the recipient in on the signing page.+ *+ * Action auth is gated behind the cfr21 claim flag at write time only, so seeding+ * the auth options directly bypasses the gate the same way action-auth.spec.ts does.+ */+const seedPasswordActionAuthDocument = async () => {+ const { user: owner, team } = await seedUser();+ const { user: recipient } = await seedUser();++ const { recipients } = await seedPendingDocumentWithFullFields({+ owner,+ teamId: team.id,+ recipients: [recipient],+ updateDocumentOptions: {+ authOptions: createDocumentAuthOptions({+ globalAccessAuth: [],+ globalActionAuth: ['PASSWORD'],+ }),+ },+ fields: [FieldType.SIGNATURE],+ });++ const { token, fields } = recipients[0];++ const signatureField = fields.find((field) => field.type === FieldType.SIGNATURE);++ if (!signatureField) {+ throw new Error('Expected a signature field to be seeded');+ }++ return {+ recipient,+ signUrl: `/sign/${token}`,+ signatureField,+ };+};++test('[DOCUMENT_AUTH]: passwordless user is sent a setup link and can sign after setting a password', async ({+ page,+}) => {+ const { recipient, signUrl, signatureField } = await seedPasswordActionAuthDocument();++ await apiSignin({+ page,+ email: recipient.email,+ password: SEEDED_PASSWORD,+ redirectPath: signUrl,+ });++ // Simulate an OAuth / passkey only account by removing the password after sign in.+ await prisma.user.update({+ where: { id: recipient.id },+ data: { password: null },+ });++ await expect(page.getByRole('heading', { name: 'Sign Document' })).toBeVisible();++ await signSignaturePad(page);++ await page.locator(`#field-${signatureField.id}`).getByRole('button').click();++ await expect(page.getByText('Reauthentication is required to sign this field')).toBeVisible();+ await expect(page.getByText('No password set')).toBeVisible();++ // A bare session must not be able to set a password inline; it gets emailed a link instead.+ await expect(page.getByLabel('New password')).not.toBeVisible();++ await page.getByRole('button', { name: 'Send setup link' }).click();+ await expect(page.getByText('Check your email')).toBeVisible();++ const resetToken = await prisma.passwordResetToken.findFirstOrThrow({+ where: { userId: recipient.id },+ });++ // Complete the emailed flow, which also invalidates all sessions.+ await page.goto(`/reset-password/${resetToken.token}`);++ // Filling controlled inputs before hydration gets reset by React.+ await waitForHydration(page, 'input[name="password"]');++ await page.getByLabel('Password', { exact: true }).fill(NEW_PASSWORD);+ await page.getByLabel('Repeat Password').fill(NEW_PASSWORD);+ await page.getByRole('button', { name: 'Reset Password' }).click();+ await expect(page.locator('body')).toContainText('Your password has been updated successfully.');++ // Come back with the new password and the normal reauth form should now work.+ await apiSignin({+ page,+ email: recipient.email,+ password: NEW_PASSWORD,+ redirectPath: signUrl,+ });++ await expect(page.getByRole('heading', { name: 'Sign Document' })).toBeVisible();++ await signSignaturePad(page);++ await page.locator(`#field-${signatureField.id}`).getByRole('button').click();++ const dialog = page.getByRole('dialog');++ await expect(dialog.getByText('No password set')).not.toBeVisible();++ await dialog.getByLabel('Password').fill(NEW_PASSWORD);+ await dialog.getByRole('button', { name: 'Sign' }).click();++ await expect(page.locator(`#field-${signatureField.id}`)).toHaveAttribute('data-inserted', 'true');+});++test('[DOCUMENT_AUTH]: user with a password sees the normal password reauth form', async ({ page }) => {+ const { recipient, signUrl, signatureField } = await seedPasswordActionAuthDocument();++ await apiSignin({+ page,+ email: recipient.email,+ password: SEEDED_PASSWORD,+ redirectPath: signUrl,+ });++ await expect(page.getByRole('heading', { name: 'Sign Document' })).toBeVisible();++ await signSignaturePad(page);++ await page.locator(`#field-${signatureField.id}`).getByRole('button').click();++ await expect(page.getByText('Reauthentication is required to sign this field')).toBeVisible();+ await expect(page.getByText('No password set')).not.toBeVisible();++ const dialog = page.getByRole('dialog');++ // Wrong password is rejected.+ await dialog.getByLabel('Password').fill('wrong-password');+ await dialog.getByRole('button', { name: 'Sign' }).click();+ await expect(dialog.getByText('Unauthorized')).toBeVisible();++ // Correct password signs the field.+ await dialog.getByLabel('Password').fill(SEEDED_PASSWORD);+ await dialog.getByRole('button', { name: 'Sign' }).click();++ await expect(page.locator(`#field-${signatureField.id}`)).toHaveAttribute('data-inserted', 'true');+});++test('[DOCUMENT_AUTH]: passwordless user can request a setup link from security settings', async ({ page }) => {+ const { user } = await seedUser();++ await apiSignin({+ page,+ email: user.email,+ password: SEEDED_PASSWORD,+ redirectPath: '/settings/profile',+ });++ await prisma.user.update({+ where: { id: user.id },+ data: { password: null },+ });++ await page.goto('/settings/security');++ await expect(page.getByRole('heading', { name: 'Set a password' })).toBeVisible();+ await expect(page.getByLabel('Current password')).not.toBeVisible();+ await expect(page.getByLabel('New password')).not.toBeVisible();++ // Clicking before hydration is a no-op, so retry until the sent state appears.+ await expect(async () => {+ await page.getByRole('button', { name: 'Send setup link' }).click();+ await expect(page.getByRole('button', { name: 'Link sent' })).toBeVisible({ timeout: 2_000 });+ }).toPass({ timeout: 15_000 });++ const resetToken = await prisma.passwordResetToken.findFirst({+ where: { userId: user.id },+ });++ expect(resetToken).not.toBeNull();+});diff --git a/packages/app-tests/e2e/fixtures/hydration.ts b/packages/app-tests/e2e/fixtures/hydration.tsnew file mode 100644index 000000000..97ef8feb8--- /dev/null+++ b/packages/app-tests/e2e/fixtures/hydration.ts@@ -0,0 +1,27 @@+import type { Page } from '@playwright/test';++/**+ * Wait for React to hydrate the element matching the given selector.+ *+ * Filling controlled inputs before hydration is racy since React resets them+ * to their default values once it takes over the DOM. React attaches internal+ * fiber keys to DOM nodes during hydration, so their presence is a reliable+ * signal that the element is interactive.+ */+export const waitForHydration = async (page: Page, selector: string, timeout = 15_000) => {+ await page.waitForSelector(selector, { timeout });++ await page.waitForFunction(+ (sel) => {+ const element = document.querySelector(sel);++ if (!element) {+ return false;+ }++ return Object.keys(element).some((key) => key.startsWith('__reactFiber'));+ },+ selector,+ { timeout },+ );+};diff --git a/packages/app-tests/e2e/user/password-two-factor.spec.ts b/packages/app-tests/e2e/user/password-two-factor.spec.tsnew file mode 100644index 000000000..8c19adc8a--- /dev/null+++ b/packages/app-tests/e2e/user/password-two-factor.spec.ts@@ -0,0 +1,105 @@+import { DOCUMENSO_ENCRYPTION_KEY } from '@documenso/lib/constants/crypto';+import { enableTwoFactorAuthentication } from '@documenso/lib/server-only/2fa/enable-2fa';+import { setupTwoFactorAuthentication } from '@documenso/lib/server-only/2fa/setup-2fa';+import { symmetricDecrypt } from '@documenso/lib/universal/crypto';+import { prisma } from '@documenso/prisma';+import { seedUser } from '@documenso/prisma/seed/users';+import { expect, test } from '@playwright/test';+import { base32 } from '@scure/base';+import { generateHOTP } from 'oslo/otp';++import { apiSignin } from '../fixtures/authentication';+import { waitForHydration } from '../fixtures/hydration';++test.describe.configure({ mode: 'parallel', timeout: 60000 });++/**+ * Derive the current TOTP for a user the same way `verifyTwoFactorAuthenticationToken` does.+ */+const getCurrentTotpCode = async (userId: number) => {+ const user = await prisma.user.findUniqueOrThrow({ where: { id: userId } });++ if (!DOCUMENSO_ENCRYPTION_KEY || !user.twoFactorSecret) {+ throw new Error('Expected encryption key and 2FA secret');+ }++ const secret = Buffer.from(symmetricDecrypt({ key: DOCUMENSO_ENCRYPTION_KEY, data: user.twoFactorSecret })).toString(+ 'utf-8',+ );++ return await generateHOTP(base32.decode(secret), Math.floor(Date.now() / 30_000));+};++test('[USER] password update requires a 2FA code when 2FA is enabled', async ({ page }) => {+ const oldPassword = 'password';+ const newPassword = 'Test123!';++ const { user } = await seedUser({ password: oldPassword });++ // Sign in before enabling 2FA since apiSignin does not send a code.+ await apiSignin({ page, email: user.email, password: oldPassword, redirectPath: '/settings/profile' });++ await setupTwoFactorAuthentication({ user });++ const userWithSecret = await prisma.user.findUniqueOrThrow({ where: { id: user.id } });++ await enableTwoFactorAuthentication({ user: userWithSecret, code: await getCurrentTotpCode(user.id) });++ await page.goto('/settings/security');+ await waitForHydration(page, 'input[name="currentPassword"]');++ await page.getByLabel('Current password').fill(oldPassword);+ await page.getByLabel('New password').fill(newPassword);+ await page.getByLabel('Repeat password').fill(newPassword);+ await page.getByRole('button', { name: 'Update password' }).click();++ const dialog = page.getByRole('dialog');++ await expect(dialog.getByText('Two-Factor Authentication')).toBeVisible();++ // Empty code is caught client-side.+ await dialog.getByRole('button', { name: 'Update password' }).click();+ await expect(dialog.getByText('A code is required')).toBeVisible();++ const codeInput = dialog.locator('input').first();++ // Wrong code is rejected server-side and the dialog stays open.+ await codeInput.fill('000000');+ await dialog.getByRole('button', { name: 'Update password' }).click();+ await expect(page.locator('body')).toContainText('The two factor code you provided is invalid');+ await expect(dialog).toBeVisible();++ // Correct code updates the password.+ await codeInput.fill('');+ await codeInput.fill(await getCurrentTotpCode(user.id));+ await dialog.getByRole('button', { name: 'Update password' }).click();+ await expect(page.locator('body')).toContainText('Password updated');+ await expect(dialog).not.toBeVisible();++ const updatedUser = await prisma.user.findUniqueOrThrow({ where: { id: user.id } });++ expect(updatedUser.password).not.toBe(userWithSecret.password);+});++test('[USER] password update API rejects a missing 2FA code when 2FA is enabled', async ({ page }) => {+ const { user } = await seedUser();++ await apiSignin({ page, email: user.email, redirectPath: '/settings/profile' });++ await setupTwoFactorAuthentication({ user });++ const userWithSecret = await prisma.user.findUniqueOrThrow({ where: { id: user.id } });++ await enableTwoFactorAuthentication({ user: userWithSecret, code: await getCurrentTotpCode(user.id) });++ const response = await page.request.post('/api/auth/email-password/update-password', {+ data: { currentPassword: 'password', password: 'Test123!' },+ });++ expect(response.status()).toBe(400);+ expect(await response.json()).toMatchObject({ code: 'TWO_FACTOR_MISSING_CREDENTIALS' });++ const unchangedUser = await prisma.user.findUniqueOrThrow({ where: { id: user.id } });++ expect(unchangedUser.password).toBe(userWithSecret.password);+});diff --git a/packages/auth/server/routes/email-password.ts b/packages/auth/server/routes/email-password.tsindex 8d890b81a..50df2a137 100644--- a/packages/auth/server/routes/email-password.ts+++ b/packages/auth/server/routes/email-password.ts@@ -21,6 +21,7 @@ import {resendVerifyEmailRateLimit,resetPasswordRateLimit,signupRateLimit,+ updatePasswordRateLimit,verifyEmailRateLimit,} from '@documenso/lib/server-only/rate-limit/rate-limits';import { getEmailBlocklistDomains } from '@documenso/lib/server-only/site-settings/get-email-blocklist-domains';@@ -248,7 +249,7 @@ export const emailPasswordRoute = new Hono<HonoAuthContext>()* Update password endpoint.*/.post('/update-password', sValidator('json', ZUpdatePasswordSchema), async (c) => {- const { password, currentPassword } = c.req.valid('json');+ const { password, currentPassword, totpCode, backupCode } = c.req.valid('json');const requestMetadata = c.get('requestMetadata');if (!isSigninEnabledForProvider('email')) {@@ -259,10 +260,25 @@ export const emailPasswordRoute = new Hono<HonoAuthContext>()const { session, user } = await getSession(c);+ const updateLimitResult = await updatePasswordRateLimit.check({+ ip: requestMetadata.ipAddress ?? 'unknown',+ identifier: String(user.id),+ });++ const updateLimited = rateLimitResponse(c, updateLimitResult);++ if (updateLimited) {+ throw new HTTPException(429, {+ res: updateLimited,+ });+ }+await updatePassword({userId: user.id,password,currentPassword,+ totpCode,+ backupCode,requestMetadata,});diff --git a/packages/auth/server/types/email-password.ts b/packages/auth/server/types/email-password.tsindex 5303d326c..dcdeeac06 100644--- a/packages/auth/server/types/email-password.ts+++ b/packages/auth/server/types/email-password.ts@@ -70,6 +70,8 @@ export type TResendVerifyEmailSchema = z.infer<typeof ZResendVerifyEmailSchema>;export const ZUpdatePasswordSchema = z.object({currentPassword: ZCurrentPasswordSchema,password: ZPasswordSchema,+ totpCode: z.string().trim().optional(),+ backupCode: z.string().trim().optional(),});export type TUpdatePasswordSchema = z.infer<typeof ZUpdatePasswordSchema>;diff --git a/packages/email/templates/reset-password.tsx b/packages/email/templates/reset-password.tsxindex 19c5979a3..ce7669023 100644--- a/packages/email/templates/reset-password.tsx+++ b/packages/email/templates/reset-password.tsx@@ -1,3 +1,4 @@+import type { TPasswordChangeSource } from '@documenso/lib/jobs/definitions/emails/send-password-reset-success-email';import { msg } from '@lingui/core/macro';import { useLingui } from '@lingui/react';import { Trans } from '@lingui/react/macro';@@ -8,16 +9,19 @@ import { TemplateFooter } from '../template-components/template-footer';import type { TemplateResetPasswordProps } from '../template-components/template-reset-password';import { TemplateResetPassword } from '../template-components/template-reset-password';-export type ResetPasswordTemplateProps = Partial<TemplateResetPasswordProps>;+export type ResetPasswordTemplateProps = Partial<TemplateResetPasswordProps> & {+ source?: TPasswordChangeSource;+};export const ResetPasswordTemplate = ({userName = 'Lucas Smith',userEmail = '[email protected]',assetBaseUrl = 'http://localhost:3002',+ source = 'RESET',}: ResetPasswordTemplateProps) => {const { _ } = useLingui();- const previewText = msg`Password Reset Successful`;+ const previewText = source === 'RESET' ? msg`Password Reset Successful` : msg`Your password was changed`;return (<Html>@@ -46,18 +50,37 @@ export const ResetPasswordTemplate = ({</Trans></Text>- <Text className="mt-2 text-base text-muted-foreground">- <Trans>We've changed your password as you asked. You can now sign in with your new password.</Trans>- </Text>- <Text className="mt-2 text-base text-muted-foreground">- <Trans>- Didn't request a password change? We are here to help you secure your account, just{' '}- <Link className="font-normal text-primary" href="mailto:[email protected]">- contact us- </Link>- .- </Trans>- </Text>+ {source === 'RESET' ? (+ <>+ <Text className="mt-2 text-base text-muted-foreground">+ <Trans>We've changed your password as you asked. You can now sign in with your new password.</Trans>+ </Text>+ <Text className="mt-2 text-base text-muted-foreground">+ <Trans>+ Didn't request a password change? We are here to help you secure your account, just{' '}+ <Link className="font-normal text-primary" href="mailto:[email protected]">+ contact us+ </Link>+ .+ </Trans>+ </Text>+ </>+ ) : (+ <>+ <Text className="mt-2 text-base text-muted-foreground">+ <Trans>Your password was just changed from your account security settings.</Trans>+ </Text>+ <Text className="mt-2 text-base text-muted-foreground">+ <Trans>+ If this was you, no action is needed. If it wasn't, reset your password immediately and{' '}+ <Link className="font-normal text-primary" href="mailto:[email protected]">+ contact us+ </Link>+ .+ </Trans>+ </Text>+ </>+ )}</Section></Container>diff --git a/packages/lib/client-only/hooks/use-password-setup-request.ts b/packages/lib/client-only/hooks/use-password-setup-request.tsnew file mode 100644index 000000000..fd0e0ce47--- /dev/null+++ b/packages/lib/client-only/hooks/use-password-setup-request.ts@@ -0,0 +1,31 @@+import { authClient } from '@documenso/auth/client';+import { useMutation } from '@tanstack/react-query';++import { AppError } from '../../errors/app-error';+import { useSession } from '../providers/session';++export type UsePasswordSetupRequestOptions = {+ onSuccess?: () => void;+ onError?: (errorCode: string) => void;+};++/**+ * Sends the signed in user the standard password reset email so they can set a+ * password via a verified link, rather than letting a bare session mint one.+ */+export const usePasswordSetupRequest = ({ onSuccess, onError }: UsePasswordSetupRequestOptions = {}) => {+ const { user } = useSession();++ const { mutate, isPending, isSuccess, error } = useMutation({+ mutationFn: async () => authClient.emailPassword.forgotPassword({ email: user.email }),+ onSuccess,+ onError: (err) => onError?.(AppError.parseError(err).code),+ });++ return {+ requestSetupLink: () => mutate(),+ isPending,+ isSuccess,+ errorCode: error ? AppError.parseError(error).code : null,+ };+};diff --git a/packages/lib/errors/app-error.ts b/packages/lib/errors/app-error.tsindex 79d5235b2..108998eb2 100644--- a/packages/lib/errors/app-error.ts+++ b/packages/lib/errors/app-error.ts@@ -23,6 +23,13 @@ export enum AppErrorCode {SCHEMA_FAILED = 'SCHEMA_FAILED',TOO_MANY_REQUESTS = 'TOO_MANY_REQUESTS',TWO_FACTOR_AUTH_FAILED = 'TWO_FACTOR_AUTH_FAILED',+ TWO_FACTOR_SETUP_REQUIRED = 'TWO_FACTOR_SETUP_REQUIRED',+ TWO_FACTOR_MISSING_SECRET = 'TWO_FACTOR_MISSING_SECRET',+ TWO_FACTOR_MISSING_CREDENTIALS = 'TWO_FACTOR_MISSING_CREDENTIALS',+ INCORRECT_TWO_FACTOR_CODE = 'INCORRECT_TWO_FACTOR_CODE',+ NO_PASSWORD = 'NO_PASSWORD',+ INCORRECT_PASSWORD = 'INCORRECT_PASSWORD',+ SAME_PASSWORD = 'SAME_PASSWORD',WEBHOOK_INVALID_REQUEST = 'WEBHOOK_INVALID_REQUEST',ENVELOPE_DRAFT = 'ENVELOPE_DRAFT',ENVELOPE_COMPLETED = 'ENVELOPE_COMPLETED',diff --git a/packages/lib/jobs/definitions/emails/send-password-reset-success-email.handler.ts b/packages/lib/jobs/definitions/emails/send-password-reset-success-email.handler.tsindex 45b841c4c..3339128f0 100644--- a/packages/lib/jobs/definitions/emails/send-password-reset-success-email.handler.ts+++ b/packages/lib/jobs/definitions/emails/send-password-reset-success-email.handler.ts@@ -4,5 +4,6 @@ import type { TSendPasswordResetSuccessEmailJobDefinition } from './send-passworexport const run = async ({ payload }: { payload: TSendPasswordResetSuccessEmailJobDefinition }) => {await sendResetPassword({userId: payload.userId,+ source: payload.source ?? 'RESET',});};diff --git a/packages/lib/jobs/definitions/emails/send-password-reset-success-email.ts b/packages/lib/jobs/definitions/emails/send-password-reset-success-email.tsindex d73246bb6..34b57a273 100644--- a/packages/lib/jobs/definitions/emails/send-password-reset-success-email.ts+++ b/packages/lib/jobs/definitions/emails/send-password-reset-success-email.ts@@ -4,8 +4,20 @@ import type { JobDefinition } from '../../client/_internal/job';const SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION_ID = 'send.password.reset.success.email';+/**+ * How the password came to be changed, so the email can say so.+ *+ * - RESET: via the emailed reset link, unauthenticated.+ * - UPDATE: via account settings, while signed in.+ */+export const ZPasswordChangeSourceSchema = z.enum(['RESET', 'UPDATE']);++export type TPasswordChangeSource = z.infer<typeof ZPasswordChangeSourceSchema>;+const SEND_PASSWORD_RESET_SUCCESS_EMAIL_JOB_DEFINITION_SCHEMA = z.object({userId: z.number(),+ // Optional so jobs queued before this field existed still run; treated as RESET.+ source: ZPasswordChangeSourceSchema.optional(),});export type TSendPasswordResetSuccessEmailJobDefinition = z.infer<diff --git a/packages/lib/server-only/2fa/disable-2fa.ts b/packages/lib/server-only/2fa/disable-2fa.tsindex ebbeab5a7..d670eacff 100644--- a/packages/lib/server-only/2fa/disable-2fa.ts+++ b/packages/lib/server-only/2fa/disable-2fa.ts@@ -32,7 +32,7 @@ export const disableTwoFactorAuthentication = async ({}if (!isValid) {- throw new AppError('INCORRECT_TWO_FACTOR_CODE');+ throw new AppError(AppErrorCode.INCORRECT_TWO_FACTOR_CODE);}await prisma.$transaction(async (tx) => {diff --git a/packages/lib/server-only/2fa/enable-2fa.ts b/packages/lib/server-only/2fa/enable-2fa.tsindex 4d6a86f1f..04da04af1 100644--- a/packages/lib/server-only/2fa/enable-2fa.ts+++ b/packages/lib/server-only/2fa/enable-2fa.ts@@ -1,7 +1,7 @@import { prisma } from '@documenso/prisma';import { type User, UserSecurityAuditLogType } from '@prisma/client';-import { AppError } from '../../errors/app-error';+import { AppError, AppErrorCode } from '../../errors/app-error';import type { RequestMetadata } from '../../universal/extract-request-metadata';import { getBackupCodes } from './get-backup-code';import { verifyTwoFactorAuthenticationToken } from './verify-2fa-token';@@ -22,13 +22,13 @@ export const enableTwoFactorAuthentication = async ({}if (!user.twoFactorSecret) {- throw new AppError('TWO_FACTOR_SETUP_REQUIRED');+ throw new AppError(AppErrorCode.TWO_FACTOR_SETUP_REQUIRED);}const isValidToken = await verifyTwoFactorAuthenticationToken({ user, totpCode: code });if (!isValidToken) {- throw new AppError('INCORRECT_TWO_FACTOR_CODE');+ throw new AppError(AppErrorCode.INCORRECT_TWO_FACTOR_CODE);}let recoveryCodes: string[] = [];diff --git a/packages/lib/server-only/2fa/validate-2fa.ts b/packages/lib/server-only/2fa/validate-2fa.tsindex 64a99adcc..e04623def 100644--- a/packages/lib/server-only/2fa/validate-2fa.ts+++ b/packages/lib/server-only/2fa/validate-2fa.ts@@ -1,6 +1,6 @@import type { User } from '@prisma/client';-import { AppError } from '../../errors/app-error';+import { AppError, AppErrorCode } from '../../errors/app-error';import { verifyTwoFactorAuthenticationToken } from './verify-2fa-token';import { verifyBackupCode } from './verify-backup-code';@@ -16,11 +16,11 @@ export const validateTwoFactorAuthentication = async ({user,}: ValidateTwoFactorAuthenticationOptions) => {if (!user.twoFactorEnabled) {- throw new AppError('TWO_FACTOR_SETUP_REQUIRED');+ throw new AppError(AppErrorCode.TWO_FACTOR_SETUP_REQUIRED);}if (!user.twoFactorSecret) {- throw new AppError('TWO_FACTOR_MISSING_SECRET');+ throw new AppError(AppErrorCode.TWO_FACTOR_MISSING_SECRET);}if (totpCode) {@@ -31,5 +31,5 @@ export const validateTwoFactorAuthentication = async ({return verifyBackupCode({ user, backupCode });}- throw new AppError('TWO_FACTOR_MISSING_CREDENTIALS');+ throw new AppError(AppErrorCode.TWO_FACTOR_MISSING_CREDENTIALS);};diff --git a/packages/lib/server-only/2fa/view-backup-codes.ts b/packages/lib/server-only/2fa/view-backup-codes.tsindex 9ed75bde4..b693f7282 100644--- a/packages/lib/server-only/2fa/view-backup-codes.ts+++ b/packages/lib/server-only/2fa/view-backup-codes.ts@@ -1,6 +1,6 @@import type { User } from '@prisma/client';-import { AppError } from '../../errors/app-error';+import { AppError, AppErrorCode } from '../../errors/app-error';import { getBackupCodes } from './get-backup-code';import { validateTwoFactorAuthentication } from './validate-2fa';@@ -17,7 +17,7 @@ export const viewBackupCodes = async ({ token, user }: ViewBackupCodesOptions) =}if (!isValid) {- throw new AppError('INCORRECT_TWO_FACTOR_CODE');+ throw new AppError(AppErrorCode.INCORRECT_TWO_FACTOR_CODE);}const backupCodes = getBackupCodes({ user });diff --git a/packages/lib/server-only/auth/send-reset-password.ts b/packages/lib/server-only/auth/send-reset-password.tsindex 3c4957d31..e87537f3f 100644--- a/packages/lib/server-only/auth/send-reset-password.ts+++ b/packages/lib/server-only/auth/send-reset-password.ts@@ -1,17 +1,22 @@import { mailer } from '@documenso/email/mailer';import { ResetPasswordTemplate } from '@documenso/email/templates/reset-password';import { prisma } from '@documenso/prisma';+import { msg } from '@lingui/core/macro';import { createElement } from 'react';+import { match } from 'ts-pattern';+import { getI18nInstance } from '../../client-only/providers/i18n-server';import { NEXT_PUBLIC_WEBAPP_URL } from '../../constants/app';+import type { TPasswordChangeSource } from '../../jobs/definitions/emails/send-password-reset-success-email';import { env } from '../../utils/env';import { renderEmailWithI18N } from '../../utils/render-email-with-i18n';export interface SendResetPasswordOptions {userId: number;+ source: TPasswordChangeSource;}-export const sendResetPassword = async ({ userId }: SendResetPasswordOptions) => {+export const sendResetPassword = async ({ userId, source }: SendResetPasswordOptions) => {const user = await prisma.user.findFirstOrThrow({where: {id: userId,@@ -24,6 +29,7 @@ export const sendResetPassword = async ({ userId }: SendResetPasswordOptions) =>assetBaseUrl,userEmail: user.email,userName: user.name || '',+ source,});const [html, text] = await Promise.all([@@ -31,6 +37,13 @@ export const sendResetPassword = async ({ userId }: SendResetPasswordOptions) =>renderEmailWithI18N(template, { plainText: true }),]);+ const i18n = await getI18nInstance();++ const subject = match(source)+ .with('RESET', () => i18n._(msg`Password Reset Success!`))+ .with('UPDATE', () => i18n._(msg`Your password was changed`))+ .exhaustive();+return await mailer.sendMail({to: {address: user.email,@@ -40,7 +53,7 @@ export const sendResetPassword = async ({ userId }: SendResetPasswordOptions) =>name: env('NEXT_PRIVATE_SMTP_FROM_NAME') || 'Documenso',address: env('NEXT_PRIVATE_SMTP_FROM_ADDRESS') || '[email protected]',},- subject: 'Password Reset Success!',+ subject,html,text,});diff --git a/packages/lib/server-only/rate-limit/rate-limits.ts b/packages/lib/server-only/rate-limit/rate-limits.tsindex 5dfa47450..1d59e5501 100644--- a/packages/lib/server-only/rate-limit/rate-limits.ts+++ b/packages/lib/server-only/rate-limit/rate-limits.ts@@ -66,6 +66,18 @@ export const linkOrgAccountRateLimit = createRateLimit({window: '1h',});+// ---- Auth (Tier 3 - Authenticated, verifies secrets) ----++/**+ * Bounds guessing of the current password and 2FA code via the update password endpoint.+ */+export const updatePasswordRateLimit = createRateLimit({+ action: 'auth.update-password',+ max: 5,+ globalMax: 20,+ window: '15m',+});+export const reportSenderRateLimit = createRateLimit({action: 'recipient.report-sender',max: 1,diff --git a/packages/lib/server-only/user/get-user-auth-methods.ts b/packages/lib/server-only/user/get-user-auth-methods.tsnew file mode 100644index 000000000..447f9c6ac--- /dev/null+++ b/packages/lib/server-only/user/get-user-auth-methods.ts@@ -0,0 +1,39 @@+import { prisma } from '@documenso/prisma';++import type { TUserAuthMethod } from '../../types/user-auth-method';+import { deriveUserAuthMethods } from '../../utils/user-auth-methods';++export type GetUserAuthMethodsOptions = {+ userId: number;+};++/**+ * Get the distinct sign in methods available to a user, such as password,+ * passkey or linked OAuth providers.+ */+export const getUserAuthMethods = async ({ userId }: GetUserAuthMethodsOptions): Promise<TUserAuthMethod[]> => {+ const user = await prisma.user.findFirstOrThrow({+ where: {+ id: userId,+ },+ select: {+ password: true,+ accounts: {+ select: {+ provider: true,+ },+ },+ _count: {+ select: {+ passkeys: true,+ },+ },+ },+ });++ return deriveUserAuthMethods({+ hasPassword: user.password !== null,+ passkeyCount: user._count.passkeys,+ accountProviders: user.accounts.map((account) => account.provider),+ });+};diff --git a/packages/lib/server-only/user/reset-password.ts b/packages/lib/server-only/user/reset-password.tsindex f4d52c015..ddf3b9b76 100644--- a/packages/lib/server-only/user/reset-password.ts+++ b/packages/lib/server-only/user/reset-password.ts@@ -47,7 +47,7 @@ export const resetPassword = async ({ token, password, requestMetadata }: ResetPconst isSamePassword = await compare(password, foundToken.user.password || '');if (isSamePassword) {- throw new AppError('SAME_PASSWORD');+ throw new AppError(AppErrorCode.SAME_PASSWORD);}const hashedPassword = await hash(password, SALT_ROUNDS);@@ -82,6 +82,7 @@ export const resetPassword = async ({ token, password, requestMetadata }: ResetPname: 'send.password.reset.success.email',payload: {userId: foundToken.userId,+ source: 'RESET',},});diff --git a/packages/lib/server-only/user/update-password.ts b/packages/lib/server-only/user/update-password.tsindex a0c31dcf4..547e2e025 100644--- a/packages/lib/server-only/user/update-password.ts+++ b/packages/lib/server-only/user/update-password.ts@@ -4,41 +4,77 @@ import { prisma } from '@documenso/prisma';import { compare, hash } from '@node-rs/bcrypt';import { UserSecurityAuditLogType } from '@prisma/client';-import { AppError } from '../../errors/app-error';+import { AppError, AppErrorCode } from '../../errors/app-error';+import { jobsClient } from '../../jobs/client';+import { validateTwoFactorAuthentication } from '../2fa/validate-2fa';export type UpdatePasswordOptions = {userId: number;password: string;currentPassword: string;+ totpCode?: string;+ backupCode?: string;requestMetadata?: RequestMetadata;};-export const updatePassword = async ({ userId, password, currentPassword, requestMetadata }: UpdatePasswordOptions) => {- // Existence check+/**+ * Update the password for a user who already has one.+ *+ * Requires the current password, and a valid TOTP or backup code if the user+ * has two factor authentication enabled.+ */+export const updatePassword = async ({+ userId,+ password,+ currentPassword,+ totpCode,+ backupCode,+ requestMetadata,+}: UpdatePasswordOptions) => {const user = await prisma.user.findFirstOrThrow({where: {id: userId,},+ select: {+ id: true,+ email: true,+ password: true,+ twoFactorEnabled: true,+ twoFactorSecret: true,+ twoFactorBackupCodes: true,+ },});if (!user.password) {- throw new AppError('NO_PASSWORD');+ throw new AppError(AppErrorCode.NO_PASSWORD);}const isCurrentPasswordValid = await compare(currentPassword, user.password);if (!isCurrentPasswordValid) {- throw new AppError('INCORRECT_PASSWORD');+ throw new AppError(AppErrorCode.INCORRECT_PASSWORD);+ }++ if (user.twoFactorEnabled) {+ if (!totpCode && !backupCode) {+ throw new AppError(AppErrorCode.TWO_FACTOR_MISSING_CREDENTIALS, { statusCode: 400 });+ }++ const isTwoFactorValid = await validateTwoFactorAuthentication({ user, totpCode, backupCode });++ if (!isTwoFactorValid) {+ throw new AppError(AppErrorCode.INCORRECT_TWO_FACTOR_CODE, { statusCode: 401 });+ }}// Compare the new password with the old passwordconst isSamePassword = await compare(password, user.password);if (isSamePassword) {- throw new AppError('SAME_PASSWORD');+ throw new AppError(AppErrorCode.SAME_PASSWORD);}const hashedNewPassword = await hash(password, SALT_ROUNDS);- return await prisma.$transaction(async (tx) => {+ const updatedUser = await prisma.$transaction(async (tx) => {await tx.userSecurityAuditLog.create({data: {userId,@@ -63,4 +99,15 @@ export const updatePassword = async ({ userId, password, currentPassword, reques},});});++ // Notify the user so a change made from a hijacked session does not go unnoticed.+ await jobsClient.triggerJob({+ name: 'send.password.reset.success.email',+ payload: {+ userId,+ source: 'UPDATE',+ },+ });++ return updatedUser;};diff --git a/packages/lib/types/user-auth-method.ts b/packages/lib/types/user-auth-method.tsnew file mode 100644index 000000000..9f70fa3c7--- /dev/null+++ b/packages/lib/types/user-auth-method.ts@@ -0,0 +1,17 @@+import { z } from 'zod';++/**+ * The methods a user can use to sign in to their account.+ */+export const UserAuthMethod = {+ PASSWORD: 'PASSWORD',+ PASSKEY: 'PASSKEY',+ GOOGLE: 'GOOGLE',+ MICROSOFT: 'MICROSOFT',+ OIDC: 'OIDC',+ ORGANISATION_SSO: 'ORGANISATION_SSO',+} as const;++export const ZUserAuthMethodSchema = z.nativeEnum(UserAuthMethod);++export type TUserAuthMethod = z.infer<typeof ZUserAuthMethodSchema>;diff --git a/packages/lib/utils/user-auth-methods.test.ts b/packages/lib/utils/user-auth-methods.test.tsnew file mode 100644index 000000000..522fc8bf2--- /dev/null+++ b/packages/lib/utils/user-auth-methods.test.ts@@ -0,0 +1,52 @@+import { describe, expect, it } from 'vitest';++import { UserAuthMethod } from '../types/user-auth-method';+import { deriveUserAuthMethods } from './user-auth-methods';++describe('deriveUserAuthMethods', () => {+ it('returns an empty list when the user has no sign in methods', () => {+ expect(deriveUserAuthMethods({ hasPassword: false, passkeyCount: 0, accountProviders: [] })).toEqual([]);+ });++ it('includes PASSWORD when the user has a password', () => {+ expect(deriveUserAuthMethods({ hasPassword: true, passkeyCount: 0, accountProviders: [] })).toEqual([+ UserAuthMethod.PASSWORD,+ ]);+ });++ it('includes PASSKEY when the user has at least one passkey', () => {+ expect(deriveUserAuthMethods({ hasPassword: false, passkeyCount: 2, accountProviders: [] })).toEqual([+ UserAuthMethod.PASSKEY,+ ]);+ });++ it('maps built in OAuth providers to their auth method', () => {+ expect(+ deriveUserAuthMethods({+ hasPassword: false,+ passkeyCount: 0,+ accountProviders: ['google', 'microsoft', 'oidc'],+ }),+ ).toEqual([UserAuthMethod.GOOGLE, UserAuthMethod.MICROSOFT, UserAuthMethod.OIDC]);+ });++ it('treats unknown providers as organisation SSO', () => {+ expect(+ deriveUserAuthMethods({+ hasPassword: false,+ passkeyCount: 0,+ accountProviders: ['org_abc123'],+ }),+ ).toEqual([UserAuthMethod.ORGANISATION_SSO]);+ });++ it('deduplicates repeated providers', () => {+ expect(+ deriveUserAuthMethods({+ hasPassword: true,+ passkeyCount: 0,+ accountProviders: ['google', 'google', 'org_a', 'org_b'],+ }),+ ).toEqual([UserAuthMethod.PASSWORD, UserAuthMethod.GOOGLE, UserAuthMethod.ORGANISATION_SSO]);+ });+});diff --git a/packages/lib/utils/user-auth-methods.ts b/packages/lib/utils/user-auth-methods.tsnew file mode 100644index 000000000..c9960b4f5--- /dev/null+++ b/packages/lib/utils/user-auth-methods.ts@@ -0,0 +1,53 @@+import { type TUserAuthMethod, UserAuthMethod } from '../types/user-auth-method';++type DeriveUserAuthMethodsOptions = {+ /**+ * Whether the user has a password hash stored.+ */+ hasPassword: boolean;++ /**+ * The number of passkeys registered to the user.+ */+ passkeyCount: number;++ /**+ * The `provider` values of the user's linked `Account` rows.+ */+ accountProviders: string[];+};++const OAUTH_PROVIDER_AUTH_METHODS: Record<string, TUserAuthMethod> = {+ google: UserAuthMethod.GOOGLE,+ microsoft: UserAuthMethod.MICROSOFT,+ oidc: UserAuthMethod.OIDC,+};++/**+ * Derive the distinct set of sign in methods available to a user.+ *+ * Any `Account.provider` value that is not one of the built in OAuth providers+ * is treated as an organisation authentication portal, since those accounts use+ * the organisation ID as the provider.+ */+export const deriveUserAuthMethods = ({+ hasPassword,+ passkeyCount,+ accountProviders,+}: DeriveUserAuthMethodsOptions): TUserAuthMethod[] => {+ const authMethods = new Set<TUserAuthMethod>();++ if (hasPassword) {+ authMethods.add(UserAuthMethod.PASSWORD);+ }++ if (passkeyCount > 0) {+ authMethods.add(UserAuthMethod.PASSKEY);+ }++ for (const provider of accountProviders) {+ authMethods.add(OAUTH_PROVIDER_AUTH_METHODS[provider] ?? UserAuthMethod.ORGANISATION_SSO);+ }++ return Array.from(authMethods);+};diff --git a/packages/trpc/server/auth-router/get-auth-methods.ts b/packages/trpc/server/auth-router/get-auth-methods.tsnew file mode 100644index 000000000..bf018d8b7--- /dev/null+++ b/packages/trpc/server/auth-router/get-auth-methods.ts@@ -0,0 +1,19 @@+import { getUserAuthMethods } from '@documenso/lib/server-only/user/get-user-auth-methods';++import { authenticatedProcedure } from '../trpc';+import { ZGetAuthMethodsResponseSchema } from './get-auth-methods.types';++/**+ * Get the sign in methods available to the current user.+ */+export const getAuthMethodsRoute = authenticatedProcedure+ .output(ZGetAuthMethodsResponseSchema)+ .query(async ({ ctx }) => {+ const authMethods = await getUserAuthMethods({+ userId: ctx.user.id,+ });++ return {+ authMethods,+ };+ });diff --git a/packages/trpc/server/auth-router/get-auth-methods.types.ts b/packages/trpc/server/auth-router/get-auth-methods.types.tsnew file mode 100644index 000000000..18a324c82--- /dev/null+++ b/packages/trpc/server/auth-router/get-auth-methods.types.ts@@ -0,0 +1,8 @@+import { ZUserAuthMethodSchema } from '@documenso/lib/types/user-auth-method';+import { z } from 'zod';++export const ZGetAuthMethodsResponseSchema = z.object({+ authMethods: z.array(ZUserAuthMethodSchema),+});++export type TGetAuthMethodsResponse = z.infer<typeof ZGetAuthMethodsResponseSchema>;diff --git a/packages/trpc/server/auth-router/router.ts b/packages/trpc/server/auth-router/router.tsindex 5fc4b2c99..3ea834507 100644--- a/packages/trpc/server/auth-router/router.ts+++ b/packages/trpc/server/auth-router/router.ts@@ -5,9 +5,11 @@ import { createPasskeyRegistrationOptionsRoute } from './create-passkey-registraimport { createPasskeySigninOptionsRoute } from './create-passkey-signin-options';import { deletePasskeyRoute } from './delete-passkey';import { findPasskeysRoute } from './find-passkeys';+import { getAuthMethodsRoute } from './get-auth-methods';import { updatePasskeyRoute } from './update-passkey';export const authRouter = router({+ getAuthMethods: getAuthMethodsRoute,passkey: router({create: createPasskeyRoute,createAuthenticationOptions: createPasskeyAuthenticationOptionsRoute,