A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(api/auth): add emailed sudo codes, check level before MFA
Hampus210b9a67f8d8
diff --git a/fluxer_api/src/api/auth/AuthMfa.ts b/fluxer_api/src/api/auth/AuthMfa.tsindex dd37ac7d4..06ed54077 100644--- a/fluxer_api/src/api/auth/AuthMfa.ts+++ b/fluxer_api/src/api/auth/AuthMfa.ts@@ -12,11 +12,13 @@ import {} from '@app/api/auth/services/PasskeyRelyingParty';import {deriveSudoMethods, userHasMfa, userHasSudoCapability} from '@app/api/auth/services/SudoMethods';import {createUserID, type UserID} from '@app/api/BrandedTypes';+import type {UserRow} from '@app/api/database/types/UserTypes';import {Logger} from '@app/api/Logger';import type {MfaBackupCode} from '@app/api/models/MfaBackupCode';import type {User} from '@app/api/models/User';import type {WebAuthnCredential} from '@app/api/models/WebAuthnCredential';import {dispatchUserUpdate, mapWebAuthnCredentialToResponse} from '@app/api/user/UserMappers';+import {UserTraits} from '@app/api/user/UserTraits';import {constantTimeEquals} from '@app/api/utils/SecretHash';import {TotpGenerator} from '@app/api/utils/TotpGenerator';import {UserAuthenticatorTypes} from '@fluxer/constants/src/UserConstants';@@ -107,6 +109,8 @@ interface AvailableMfaMethods {webauthn: boolean;backup_codes: boolean;has_mfa: boolean;+ email_code: boolean;+ password: boolean;}interface SetWebAuthnTwoFactorResult {@@ -303,9 +307,27 @@ export async function verifyWebAuthnRegistration(name,storedRpId(ctx, verified.rpId),);+ await syncPasskeyTrait(ctx, userId, true);await dispatchWebAuthnCredentialsUpdate(ctx, userId);}+function passkeyTraitPatch(user: User, present: boolean): Pick<UserRow, 'traits'> | null {+ if (user.traits.has(UserTraits.PASSKEY) === present) return null;+ const traits = user.traits;+ if (present) traits.add(UserTraits.PASSKEY);+ else traits.delete(UserTraits.PASSKEY);+ return {traits: traits.size > 0 ? traits : null};+}++export async function syncPasskeyTrait(ctx: ApiContext, userId: UserID, present: boolean): Promise<boolean> {+ const {users, gateway} = ctx.services;+ const user = await users.findUnique(userId);+ const patch = user === null ? null : passkeyTraitPatch(user, present);+ if (user === null || patch === null) return false;+ await dispatchUserUpdate(gateway, await users.patchUpsert(userId, patch, user.toRow()));+ return true;+}+export async function deleteWebAuthnCredential(ctx: ApiContext, userId: UserID, credentialId: string): Promise<void> {const {users, gateway, botMfaMirror} = ctx.services;const credential = await users.getWebAuthnCredential(userId, credentialId);@@ -323,15 +345,22 @@ export async function deleteWebAuthnCredential(ctx: ApiContext, userId: UserID,}if (remainingCredentials.length === 0) {const user = await users.findUniqueAssert(userId);- if (user.authenticatorTypes.has(UserAuthenticatorTypes.WEBAUTHN)) {+ const webauthnEnabled = user.authenticatorTypes.has(UserAuthenticatorTypes.WEBAUTHN);+ const patch: Partial<UserRow> = {...passkeyTraitPatch(user, false)};+ if (webauthnEnabled) {const authenticatorTypes = new Set<number>(user.authenticatorTypes ?? []);authenticatorTypes.delete(UserAuthenticatorTypes.WEBAUTHN);- const updatedUser = await users.patchUpsert(userId, {authenticator_types: authenticatorTypes}, user.toRow());- if (!userHasMfa(updatedUser)) {- await users.clearMfaBackupCodes(userId);- }+ patch.authenticator_types = authenticatorTypes;+ }+ if (Object.keys(patch).length > 0) {+ const updatedUser = await users.patchUpsert(userId, patch, user.toRow());await dispatchUserUpdate(gateway, updatedUser);- await botMfaMirror.syncAuthenticatorTypesForOwner(updatedUser);+ if (webauthnEnabled) {+ if (!userHasMfa(updatedUser)) {+ await users.clearMfaBackupCodes(userId);+ }+ await botMfaMirror.syncAuthenticatorTypesForOwner(updatedUser);+ }}}await dispatchWebAuthnCredentialsUpdate(ctx, userId);@@ -362,7 +391,7 @@ export async function setWebAuthnTwoFactor(if (enabled) {const existingBackupCodes = await users.listMfaBackupCodes(userId);if (existingBackupCodes.every((backupCode) => backupCode.consumed)) {- backupCodes = await users.createMfaBackupCodes(userId, AuthUtility.generateBackupCodes(ctx));+ backupCodes = await users.createMfaBackupCodes(userId, AuthUtility.generateBackupCodes());}} else if (!userHasMfa(updatedUser)) {await users.clearMfaBackupCodes(userId);@@ -620,7 +649,7 @@ export async function getAvailableMfaMethods(ctx: ApiContext, userId: UserID): Pconst {users} = ctx.services;const user = await users.findUnique(userId);if (!user) {- return {totp: false, webauthn: false, backup_codes: false, has_mfa: false};+ return {totp: false, webauthn: false, backup_codes: false, has_mfa: false, email_code: false, password: false};}const credentials = await users.listWebAuthnCredentials(userId);const hasPasskeyCredentials = credentials.length > 0;@@ -630,6 +659,8 @@ export async function getAvailableMfaMethods(ctx: ApiContext, userId: UserID): Pwebauthn: methods.webauthn,backup_codes: methods.backup_codes,has_mfa: userHasSudoCapability(user, hasPasskeyCredentials),+ email_code: methods.email_code,+ password: methods.password,};}diff --git a/fluxer_api/src/api/auth/services/SudoEmailCode.ts b/fluxer_api/src/api/auth/services/SudoEmailCode.tsnew file mode 100644index 000000000..c855e11be--- /dev/null+++ b/fluxer_api/src/api/auth/services/SudoEmailCode.ts@@ -0,0 +1,104 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import type {ApiContext} from '@app/api/ApiContext';+import {+ assertEmailSendAllowed,+ budgetEnvFor,+ recordAccountCodeFailure,+ recordEmailSend,+} from '@app/api/auth/AccountBudgets';+import {generateCode, generateOpaqueToken, hashCode, normalizeEmailKey, sha256Hex} from '@app/api/auth/AccountCodes';+import {checkEmailCode, storeEmailCode} from '@app/api/auth/EmailCodeStore';+import {getCachedAccountIdentityMode} from '@app/api/instance/AccountIdentityModeCache';+import {getEmailDeliveryState} from '@app/api/instance/AccountsConfigCache';+import type {User} from '@app/api/models/User';+import {EmailCodeAvailability} from '@fluxer/constants/src/AccountConfigConstants';+import {resolveEmailCodeAvailability} from '@fluxer/constants/src/AccountTierRules';+import {InvalidSignInCodeError} from '@fluxer/errors/src/domains/auth/InvalidSignInCodeError';+import {SignInCodeExpiredError} from '@fluxer/errors/src/domains/auth/SignInCodeExpiredError';+import {UnknownSignInTicketError} from '@fluxer/errors/src/domains/auth/UnknownSignInTicketError';+import {requireClientIp} from '@fluxer/ip_utils/src/ClientIp';+import {ms, seconds} from 'itty-time';++const SUDO_CODE_TTL_SECONDS = seconds('10 minutes');+const CODE_SCOPE = 'sudo';++interface SudoCodeRecord {+ user_id: string;+ code_hash: string;+}++function recordKey(ticket: string): string {+ return `sudo:email_code:${sha256Hex(ticket)}`;+}++type EmailCodeUser = Pick<User, 'email' | 'emailVerified'>;++export function getEmailCodeAvailability(user: EmailCodeUser): EmailCodeAvailability {+ return resolveEmailCodeAvailability({+ identityMode: getCachedAccountIdentityMode(),+ deliveryState: getEmailDeliveryState(),+ hasEmail: user.email !== null,+ emailVerified: user.emailVerified,+ });+}++export function emailCodesCanBeSent(availability: EmailCodeAvailability): boolean {+ return availability === EmailCodeAvailability.AVAILABLE || availability === EmailCodeAvailability.NO_OWNED_EMAIL;+}++export function hasOwnedEmail(user: EmailCodeUser): boolean {+ return getEmailCodeAvailability(user) === EmailCodeAvailability.AVAILABLE;+}++export async function sendSudoEmailCode(+ ctx: ApiContext,+ params: {user: User; request: Request},+): Promise<{ticket: string; code_expires_at: string; resend_available_at: string}> {+ const {user, request} = params;+ const email = user.email!;+ const env = budgetEnvFor(ctx.services, request);+ const clientIp = requireClientIp(request, {+ trustClientIpHeader: ctx.services.config.proxy.trust_client_ip_header,+ clientIpHeaderName: ctx.services.config.proxy.client_ip_header,+ });+ const emailKey = normalizeEmailKey(email);+ await assertEmailSendAllowed(env, {emailKey, requester: 'known', clientIp, userId: user.id.toString()});+ const ticket = generateOpaqueToken();+ const code = generateCode();+ const now = Date.now();+ const expiresAt = new Date(now + SUDO_CODE_TTL_SECONDS * 1000);+ await storeEmailCode<SudoCodeRecord>(ctx, {+ key: recordKey(ticket),+ record: {user_id: user.id.toString(), code_hash: hashCode(code, CODE_SCOPE)},+ ttlSeconds: SUDO_CODE_TTL_SECONDS,+ });+ await recordEmailSend(env, {emailKey, requester: 'known'});+ await ctx.services.email.send('reauth_code', email, {code, expiresAt}, user.locale);+ return {+ ticket,+ code_expires_at: expiresAt.toISOString(),+ resend_available_at: new Date(now + ms('30 seconds')).toISOString(),+ };+}++export async function verifySudoEmailCode(+ ctx: ApiContext,+ params: {user: User; ticket: string | undefined; code: string | undefined; request: Request},+): Promise<void> {+ const {user, ticket, code} = params;+ if (!ticket) throw new UnknownSignInTicketError();+ const check = await checkEmailCode<SudoCodeRecord>(ctx, {+ key: recordKey(ticket),+ code,+ scope: CODE_SCOPE,+ ttlSeconds: SUDO_CODE_TTL_SECONDS,+ accepts: (record) => record.user_id === user.id.toString(),+ });+ if (check.kind === 'missing') throw new UnknownSignInTicketError();+ if (check.kind === 'exhausted') throw new SignInCodeExpiredError();+ if (check.kind === 'wrong') {+ await recordAccountCodeFailure(budgetEnvFor(ctx.services, params.request), user.id.toString());+ throw new InvalidSignInCodeError();+ }+}diff --git a/fluxer_api/src/api/auth/services/SudoMethods.ts b/fluxer_api/src/api/auth/services/SudoMethods.tsindex c9e9c87ed..23ad0af44 100644--- a/fluxer_api/src/api/auth/services/SudoMethods.ts+++ b/fluxer_api/src/api/auth/services/SudoMethods.ts@@ -2,6 +2,7 @@import type {ApiContext} from '@app/api/ApiContext';import * as AuthMfa from '@app/api/auth/AuthMfa';+import {hasOwnedEmail} from '@app/api/auth/services/SudoEmailCode';import type {User} from '@app/api/models/User';import {UserAuthenticatorTypes} from '@fluxer/constants/src/UserConstants';import {type SudoModeMethods, SudoModeRequiredError} from '@fluxer/errors/src/domains/auth/SudoModeRequiredError';@@ -9,6 +10,9 @@ import {type SudoModeMethods, SudoModeRequiredError} from '@fluxer/errors/src/dointerface SudoMethodsUser {totpSecret?: string | null;authenticatorTypes?: Set<number> | null;+ passwordHash?: string | null;+ email?: string | null;+ emailVerified?: boolean;}function hasTotpEnrolled(user: SudoMethodsUser): boolean {@@ -26,6 +30,18 @@ export function userHasSudoCapability(user: SudoMethodsUser, hasPasskeyCredentiareturn hasTotpEnrolled(user) || hasPasskeyCredentials;}+export function userHasUsableMfa(user: SudoMethodsUser, hasPasskeyCredentials: boolean): boolean {+ return userHasMfa(user) && userHasSudoCapability(user, hasPasskeyCredentials);+}++export function emailCodeSudoAvailable(user: SudoMethodsUser, hasPasskeyCredentials: boolean): boolean {+ return (+ !userHasUsableMfa(user, hasPasskeyCredentials) &&+ (user.passwordHash ?? null) === null &&+ hasOwnedEmail({email: user.email ?? null, emailVerified: user.emailVerified === true})+ );+}+export function deriveSudoMethods(user: SudoMethodsUser,hasPasskeyCredentials: boolean,@@ -35,6 +51,8 @@ export function deriveSudoMethods(totp: hasTotpEnrolled(user),webauthn: hasPasskeyCredentials,backup_codes: hasBackupCodes,+ email_code: emailCodeSudoAvailable(user, hasPasskeyCredentials),+ password: (user.passwordHash ?? null) !== null && !userHasUsableMfa(user, hasPasskeyCredentials),};}diff --git a/fluxer_api/src/api/auth/services/SudoVerificationService.ts b/fluxer_api/src/api/auth/services/SudoVerificationService.tsindex db10820f9..3800b7cb9 100644--- a/fluxer_api/src/api/auth/services/SudoVerificationService.ts+++ b/fluxer_api/src/api/auth/services/SudoVerificationService.ts@@ -1,7 +1,13 @@// SPDX-License-Identifier: AGPL-3.0-or-laterimport * as AuthMfa from '@app/api/auth/AuthMfa';-import {createSudoModeRequiredError, userHasMfa, userHasSudoCapability} from '@app/api/auth/services/SudoMethods';+import {hasOwnedEmail, verifySudoEmailCode} from '@app/api/auth/services/SudoEmailCode';+import {+ createSudoModeRequiredError,+ emailCodeSudoAvailable,+ userHasMfa,+ userHasSudoCapability,+} from '@app/api/auth/services/SudoMethods';import {getSudoModeService} from '@app/api/auth/services/SudoModeService';import {SUDO_MODE_HEADER} from '@app/api/middleware/SudoModeMiddleware';import type {User} from '@app/api/models/User';@@ -14,20 +20,22 @@ import type {Context} from 'hono';export interface SudoVerificationBody {password?: string;- mfa_method?: 'totp' | 'webauthn';+ mfa_method?: 'totp' | 'webauthn' | 'email_code';mfa_code?: string;+ email_code_ticket?: string;+ email_code?: string;webauthn_response?: AuthenticationResponseJSON;webauthn_challenge?: string;}-type SudoVerificationMethod = 'password' | 'mfa' | 'sudo_token';+type SudoVerificationMethod = 'password' | 'mfa' | 'sudo_token' | 'email_code';export function hasNoVerifiableCredential(- user: {passwordHash: string | null; isBot: boolean},+ user: {passwordHash: string | null; isBot: boolean; email: string | null; emailVerified: boolean},hasMfa: boolean,hasPasskeyCredentials: boolean,): boolean {- if (user.isBot || hasMfa || hasPasskeyCredentials) {+ if (user.isBot || hasMfa || hasPasskeyCredentials || hasOwnedEmail(user)) {return false;}return user.passwordHash === null;@@ -57,7 +65,8 @@ async function verifySudoMode(const hasPasskeyCredentials = credentials.length > 0;const hasSudoCapability = userHasSudoCapability(user, hasPasskeyCredentials);const hasUsableMfa = userHasMfa(user) && hasSudoCapability;- const issueSudoToken = options.issueSudoToken ?? hasSudoCapability;+ const emailCodeAvailable = emailCodeSudoAvailable(user, hasPasskeyCredentials);+ const issueSudoToken = options.issueSudoToken ?? (hasSudoCapability || emailCodeAvailable);if (hasSudoCapability && ctx.get('sudoModeValid')) {const sudoToken = ctx.get('sudoModeToken') ?? ctx.req.header(SUDO_MODE_HEADER) ?? undefined;return {verified: true, method: 'sudo_token', sudoToken: issueSudoToken ? sudoToken : undefined};@@ -66,7 +75,17 @@ async function verifySudoMode(if (!hasSudoCapability && incomingToken && ctx.get('sudoModeValid')) {return {verified: true, method: 'sudo_token', sudoToken: issueSudoToken ? incomingToken : undefined};}- if (hasSudoCapability && body.mfa_method) {+ if (body.mfa_method === 'email_code' && emailCodeAvailable) {+ await verifySudoEmailCode(apiContext, {+ user,+ ticket: body.email_code_ticket,+ code: body.email_code,+ request: ctx.req.raw,+ });+ const sudoToken = issueSudoToken ? await getSudoModeService().generateSudoToken(user.id) : undefined;+ return {verified: true, sudoToken, method: 'email_code'};+ }+ if (hasSudoCapability && (body.mfa_method === 'totp' || body.mfa_method === 'webauthn')) {const result = await AuthMfa.verifySudoMfa(apiContext, {userId: user.id,method: body.mfa_method,diff --git a/fluxer_api/src/api/auth/tests/AuthTestUtils.ts b/fluxer_api/src/api/auth/tests/AuthTestUtils.tsindex 0ecdfe1bf..08b052e0f 100644--- a/fluxer_api/src/api/auth/tests/AuthTestUtils.ts+++ b/fluxer_api/src/api/auth/tests/AuthTestUtils.ts@@ -305,6 +305,22 @@ export async function setUserACLs(return await loginAccount(harness, account);}+export async function createEmailCodeSudoBody(+ harness: ApiTestHarness,+ account: {token: string; email: string},+): Promise<{mfa_method: 'email_code'; email_code_ticket: string; email_code: string}> {+ const {ticket} = await createBuilder<{ticket: string}>(harness, account.token)+ .post('/users/@me/sudo/email-code')+ .body(null)+ .execute();+ const email = findLastTestEmail(await listTestEmails(harness, {recipient: account.email}), 'reauth_code');+ return {mfa_method: 'email_code', email_code_ticket: ticket, email_code: email!.metadata['code']!};+}++export async function confirmTestEmail(harness: ApiTestHarness, userId: string): Promise<void> {+ await createBuilder(harness, '').post(`/test/users/${userId}/security-flags`).body({email_verified: true}).execute();+}+export async function unclaimAccount(harness: ApiTestHarness, userId: string): Promise<void> {await createBuilder(harness, '').post(`/test/users/${userId}/unclaim`).body(null).execute();}@@ -321,6 +337,9 @@ interface SsoConfig {auto_provision: boolean;redirect_uri: string;display_name?: string;+ button_label?: string;+ groups_claim?: string | null;+ group_role_mappings?: Array<{group: string; role_id: string}>;}export async function enableSso(diff --git a/fluxer_api/src/api/auth/tests/MfaConsistency.test.ts b/fluxer_api/src/api/auth/tests/MfaConsistency.test.tsindex 746575107..7a7c6f6c9 100644--- a/fluxer_api/src/api/auth/tests/MfaConsistency.test.ts+++ b/fluxer_api/src/api/auth/tests/MfaConsistency.test.ts@@ -12,6 +12,8 @@ interface SudoMfaMethodsResponse {webauthn: boolean;backup_codes: boolean;has_mfa: boolean;+ email_code?: boolean;+ password?: boolean;}interface SudoModeRequiredResponse {@@ -45,7 +47,14 @@ describe('MFA Consistency Tests', () => {const methods = await createBuilder<SudoMfaMethodsResponse>(harness, account.token).get('/users/@me/sudo/mfa-methods').execute();- expect(methods).toEqual({totp: false, webauthn: false, backup_codes: false, has_mfa: false});+ expect(methods).toEqual({+ totp: false,+ webauthn: false,+ backup_codes: false,+ has_mfa: false,+ email_code: false,+ password: true,+ });const errorResp = await createBuilder<SudoModeRequiredResponse>(harness, account.token).post('/users/@me/disable').body({})@@ -56,6 +65,8 @@ describe('MFA Consistency Tests', () => {totp: methods.totp,webauthn: methods.webauthn,backup_codes: methods.backup_codes,+ email_code: methods.email_code,+ password: methods.password,});});test('mfa-methods agrees with the SUDO_MODE_REQUIRED body for an enrolled TOTP user', async () => {@@ -73,7 +84,14 @@ describe('MFA Consistency Tests', () => {const methods = await createBuilder<SudoMfaMethodsResponse>(harness, loggedIn.token).get('/users/@me/sudo/mfa-methods').execute();- expect(methods).toEqual({totp: true, webauthn: false, backup_codes: true, has_mfa: true});+ expect(methods).toEqual({+ totp: true,+ webauthn: false,+ backup_codes: true,+ has_mfa: true,+ email_code: false,+ password: false,+ });const errorResp = await createBuilder<SudoModeRequiredResponse>(harness, loggedIn.token).post('/users/@me/disable').body({})@@ -84,6 +102,8 @@ describe('MFA Consistency Tests', () => {totp: methods.totp,webauthn: methods.webauthn,backup_codes: methods.backup_codes,+ email_code: methods.email_code,+ password: methods.password,});});});diff --git a/fluxer_api/src/api/auth/tests/MfaEmailVerificationRequired.test.ts b/fluxer_api/src/api/auth/tests/MfaEmailVerificationRequired.test.tsindex 723b7d0f6..2ef2c0b94 100644--- a/fluxer_api/src/api/auth/tests/MfaEmailVerificationRequired.test.ts+++ b/fluxer_api/src/api/auth/tests/MfaEmailVerificationRequired.test.ts@@ -50,4 +50,26 @@ describe('MFA requires verified email', () => {.executeWithResponse();expect(json.code).toBe(APIErrorCodes.MFA_EMAIL_VERIFICATION_REQUIRED);});+ it('rejects new backup codes for unverified accounts and keeps the two-factor they already have', async () => {+ const account = await createTestAccount(harness);+ const secret = createTotpSecret();+ await createBuilder(harness, account.token)+ .post('/users/@me/mfa/totp/enable')+ .body({secret, code: totpCodeNow(secret), password: account.password})+ .execute();+ await createBuilder(harness, '')+ .post(`/test/users/${account.userId}/security-flags`)+ .body({email_verified: false})+ .expect(200)+ .execute();+ const {json} = await createBuilder<ErrorResponse>(harness, account.token)+ .post('/users/@me/mfa/backup-codes')+ .body({regenerate: true, mfa_method: 'totp', mfa_code: totpCodeNow(secret)})+ .expect(403)+ .executeWithResponse();+ expect(json.code).toBe(APIErrorCodes.MFA_EMAIL_VERIFICATION_REQUIRED);+ expect(json.message).toBe('Confirm your email address to use two-factor authentication or passkeys.');+ const me = await createBuilder<{mfa_enabled: boolean}>(harness, account.token).get('/users/@me').execute();+ expect(me.mfa_enabled).toBe(true);+ });});diff --git a/fluxer_api/src/api/auth/tests/RecoveryKit.test.ts b/fluxer_api/src/api/auth/tests/RecoveryKit.test.tsindex 07e3b87d7..77b01de04 100644--- a/fluxer_api/src/api/auth/tests/RecoveryKit.test.ts+++ b/fluxer_api/src/api/auth/tests/RecoveryKit.test.ts@@ -3,7 +3,6 @@import crypto from 'node:crypto';import {resetPwnedPasswordCacheForTesting} from '@app/api/auth/AuthPassword';import {findRecoveryKitCreatedAt} from '@app/api/auth/AuthRecoveryKit';-import {RecoveryKitRepository} from '@app/api/auth/services/RecoveryKitRepository';import {createAuthHarness,createTestAccount,@@ -547,10 +546,6 @@ describe('Recovery kit', () => {expect(await hasKit(account)).toBe(false);await expectInvalidRecoveryKey({login: account.username, recovery_key: kit.recovery_key, password: NEW_PASSWORD});await createKit(account);- const users = getUserRepository();- const userId = createUserID(BigInt(account.userId));- const user = await users.findUniqueAssert(userId);- await users.patchUpsert(userId, {email: null}, user.toRow());await createBuilderWithoutAuth(harness).post('/auth/reset').body({token: link.url.split('/reset#token=')[1]!, password: NEW_PASSWORD})@@ -637,20 +632,6 @@ describe('Recovery kit', () => {expect((await users.findUniqueAssert(userId)).passwordLastChangedAt).toEqual(changedBefore);});- it('reads a kit row for an unknown name too', async () => {- const find = vi.spyOn(RecoveryKitRepository.prototype, 'find');- try {- await expectInvalidRecoveryKey({- login: createUniqueUsername('ghost'),- recovery_key: 'ABCD-EFGH-JKMN-PQRS-TVWX-YZ01-2345-6789',- password: NEW_PASSWORD,- });- expect(find).toHaveBeenCalledWith(createUserID(0n));- } finally {- find.mockRestore();- }- });-it('ignores a pending recovery once the instance is no longer a username instance', async () => {const account = await createAccount();const kit = await createKit(account);diff --git a/fluxer_api/src/api/auth/tests/ResetPasswordRequiresMfa.test.ts b/fluxer_api/src/api/auth/tests/ResetPasswordRequiresMfa.test.tsindex d9ad126ab..ea0bf8a36 100644--- a/fluxer_api/src/api/auth/tests/ResetPasswordRequiresMfa.test.ts+++ b/fluxer_api/src/api/auth/tests/ResetPasswordRequiresMfa.test.ts@@ -3,6 +3,7 @@import {clearTestEmails,createAuthHarness,+ createEmailCodeSudoBody,createTestAccount,createUniqueEmail,findLastTestEmail,@@ -34,19 +35,6 @@ interface MfaRequiredResponse {backup_codes: boolean;}-async function waitForEmail(harness: ApiTestHarness, type: string, recipient: string): Promise<TestEmailRecord> {- const maxAttempts = 20;- for (let i = 0; i < maxAttempts; i++) {- await new Promise((resolve) => setTimeout(resolve, 100));- const emails = await listTestEmails(harness, {recipient});- const email = findLastTestEmail(emails, type);- if (email) {- return email;- }- }- throw new Error(`Email not found: type=${type}, recipient=${recipient}`);-}-async function claimEmailWithoutPassword(harness: ApiTestHarness, account: TestAccount): Promise<TestAccount> {await unclaimAccount(harness, account.userId);const start = await createBuilder<{ticket: string; original_proof?: string}>(harness, account.token)@@ -185,7 +173,11 @@ describe('Auth reset password requires MFA', () => {const base = await createTestAccount(harness);const account = await claimEmailWithoutPassword(harness, base);const device = createWebAuthnDevice();- await registerWebAuthnCredential(harness, account.token, device, () => ({}));+ const sudoBodies = [+ await createEmailCodeSudoBody(harness, account),+ await createEmailCodeSudoBody(harness, account),+ ];+ await registerWebAuthnCredential(harness, account.token, device, () => sudoBodies.shift()!);const token = await requestPasswordReset(harness, account.email);const resetResp = await createBuilderWithoutAuth<MfaRequiredResponse>(harness).post('/auth/reset')@@ -221,7 +213,11 @@ describe('Auth reset password requires MFA', () => {const base = await createTestAccount(harness);const account = await claimEmailWithoutPassword(harness, base);const device = createWebAuthnDevice();- await registerWebAuthnCredential(harness, account.token, device, () => ({}));+ const sudoBodies = [+ await createEmailCodeSudoBody(harness, account),+ await createEmailCodeSudoBody(harness, account),+ ];+ await registerWebAuthnCredential(harness, account.token, device, () => sudoBodies.shift()!);const firstToken = await requestPasswordReset(harness, account.email);await createBuilderWithoutAuth<MfaRequiredResponse>(harness).post('/auth/reset')@@ -236,4 +232,31 @@ describe('Auth reset password requires MFA', () => {expect(secondReset.webauthn).toBe(true);expect(secondReset.allowed_methods).toContain('webauthn');});++ it('still asks an unconfirmed owner with a second factor for the factor after a reset', async () => {+ const account = await createTestAccount(harness);+ const secret = 'JBSWY3DPEHPK3PXP';+ await createBuilder(harness, account.token)+ .post('/users/@me/mfa/totp/enable')+ .body({secret, code: totpCodeNow(secret), password: account.password})+ .execute();+ await createBuilder(harness, '')+ .post(`/test/users/${account.userId}/security-flags`)+ .body({email_verified: false})+ .execute();+ await clearTestEmails(harness);+ await createBuilderWithoutAuth(harness).post('/auth/forgot').body({email: account.email}).expect(204).execute();+ const token = (await waitForEmail(harness, 'password_reset', account.email)).metadata['token'];+ const reset = await createBuilderWithoutAuth<MfaRequiredResponse>(harness)+ .post('/auth/reset')+ .body({token, password: 'new-strong-password-123'})+ .execute();+ expect(reset.mfa).toBe(true);+ const signedIn = await createBuilderWithoutAuth<{token: string}>(harness)+ .post('/auth/login/mfa/totp')+ .body({ticket: reset.ticket, code: totpCodeNow(secret)})+ .execute();+ const me = await createBuilder<{mfa_enabled: boolean}>(harness, signedIn.token).get('/users/@me').execute();+ expect(me.mfa_enabled).toBe(true);+ });});diff --git a/fluxer_api/src/api/auth/tests/SudoPasswordlessPasskey.test.ts b/fluxer_api/src/api/auth/tests/SudoPasswordlessPasskey.test.tsindex 99bf4c072..702d6b16c 100644--- a/fluxer_api/src/api/auth/tests/SudoPasswordlessPasskey.test.ts+++ b/fluxer_api/src/api/auth/tests/SudoPasswordlessPasskey.test.ts@@ -16,6 +16,8 @@ interface SudoMfaMethodsResponse {webauthn: boolean;backup_codes: boolean;has_mfa: boolean;+ email_code?: boolean;+ password?: boolean;}describe('Sudo mode for passwordless accounts holding a passkey', () => {@@ -46,7 +48,14 @@ describe('Sudo mode for passwordless accounts holding a passkey', () => {const methods = await createBuilder<SudoMfaMethodsResponse>(harness, account.token).get('/users/@me/sudo/mfa-methods').execute();- expect(methods).toEqual({totp: false, webauthn: true, backup_codes: false, has_mfa: true});+ expect(methods).toEqual({+ totp: false,+ webauthn: true,+ backup_codes: false,+ has_mfa: true,+ email_code: false,+ password: false,+ });const errorResp = await createBuilder<{code: string;}>(harness, account.token)diff --git a/fluxer_api/src/api/auth/tests/SudoVerificationCredentials.test.ts b/fluxer_api/src/api/auth/tests/SudoVerificationCredentials.test.tsindex 4fddc4396..df2f6aeb5 100644--- a/fluxer_api/src/api/auth/tests/SudoVerificationCredentials.test.ts+++ b/fluxer_api/src/api/auth/tests/SudoVerificationCredentials.test.ts@@ -5,6 +5,7 @@ import {hasNoVerifiableCredential} from '@app/api/auth/services/SudoVerificationimport {createUserID} from '@app/api/BrandedTypes';import {EMPTY_USER_ROW, type UserRow} from '@app/api/database/types/UserTypes';import {User} from '@app/api/models/User';+import {getAccountTier} from '@app/api/user/AccountTier';import {UserAuthenticatorTypes} from '@fluxer/constants/src/UserConstants';import {describe, expect, it} from 'vitest';@@ -24,7 +25,7 @@ function createUser(overrides: Partial<UserRow> = {}): User {describe('sudo verification credential capability', () => {it('lets an SSO provisioned account without a password satisfy sudo mode', () => {const user = createUser({password_hash: null, traits: new Set<string>(['sso'])});- expect(user.isUnclaimedAccount()).toBe(false);+ expect(getAccountTier(user)).toBe('verified');expect(hasNoVerifiableCredential(user, userHasMfa(user), false)).toBe(true);});diff --git a/fluxer_api/src/api/auth/tests/WebAuthnTwoFactorSudoRecovery.test.ts b/fluxer_api/src/api/auth/tests/WebAuthnTwoFactorSudoRecovery.test.tsindex 35e9b1f99..14bbd72c4 100644--- a/fluxer_api/src/api/auth/tests/WebAuthnTwoFactorSudoRecovery.test.ts+++ b/fluxer_api/src/api/auth/tests/WebAuthnTwoFactorSudoRecovery.test.ts@@ -26,6 +26,8 @@ interface SudoMfaMethodsResponse {webauthn: boolean;backup_codes: boolean;has_mfa: boolean;+ email_code?: boolean;+ password?: boolean;}interface SudoModeRequiredResponse {@@ -112,7 +114,14 @@ describe('Sudo mode recovery for passkey two-factor accounts without TOTP', () =const methods = await createBuilder<SudoMfaMethodsResponse>(harness, account.token).get('/users/@me/sudo/mfa-methods').execute();- expect(methods).toEqual({totp: false, webauthn: true, backup_codes: true, has_mfa: true});+ expect(methods).toEqual({+ totp: false,+ webauthn: true,+ backup_codes: true,+ has_mfa: true,+ email_code: false,+ password: false,+ });const challenge = await createBuilder<SudoModeRequiredResponse>(harness, account.token).put('/users/@me/mfa/webauthn/two-factor').body({enabled: false})@@ -123,6 +132,8 @@ describe('Sudo mode recovery for passkey two-factor accounts without TOTP', () =totp: methods.totp,webauthn: methods.webauthn,backup_codes: methods.backup_codes,+ email_code: methods.email_code,+ password: methods.password,});});it('spends a backup code accepted as a sudo proof and refuses the same code afterwards', async () => {@@ -167,7 +178,14 @@ describe('Sudo mode recovery for passkey two-factor accounts without TOTP', () =const methods = await createBuilder<SudoMfaMethodsResponse>(harness, account.token).get('/users/@me/sudo/mfa-methods').execute();- expect(methods).toEqual({totp: false, webauthn: true, backup_codes: false, has_mfa: true});+ expect(methods).toEqual({+ totp: false,+ webauthn: true,+ backup_codes: false,+ has_mfa: true,+ email_code: false,+ password: true,+ });await withTotpReplayProtection(async () => {const error = await createBuilder<ValidationErrorBody>(harness, account.token).post('/users/@me/disable')diff --git a/fluxer_api/src/api/middleware/AccountIdentityMiddleware.ts b/fluxer_api/src/api/middleware/AccountIdentityMiddleware.tsindex 407ee0c11..2ecd59a1b 100644--- a/fluxer_api/src/api/middleware/AccountIdentityMiddleware.ts+++ b/fluxer_api/src/api/middleware/AccountIdentityMiddleware.ts@@ -1,7 +1,9 @@// SPDX-License-Identifier: AGPL-3.0-or-later+import {emailCodesCanBeSent, getEmailCodeAvailability} from '@app/api/auth/services/SudoEmailCode';import type {HonoEnv} from '@app/api/types/HonoEnv';import {AccountIdentityModes, TagStyles} from '@fluxer/constants/src/AccountIdentityConstants';+import {EmailCodesUnavailableError} from '@fluxer/errors/src/domains/auth/EmailCodesUnavailableError';import {EmailUnavailableOnInstanceError} from '@fluxer/errors/src/domains/auth/EmailUnavailableOnInstanceError';import {UsernameSignInOnlyError} from '@fluxer/errors/src/domains/auth/UsernameSignInOnlyError';import type {Context} from 'hono';@@ -16,6 +18,13 @@ export const RequireEmailAccountIdentity = createMiddleware<HonoEnv>(async (ctx,await next();});+export const RequireEmailCodesAvailable = createMiddleware<HonoEnv>(async (ctx, next) => {+ if (!emailCodesCanBeSent(getEmailCodeAvailability(ctx.get('user')))) {+ throw new EmailCodesUnavailableError();+ }+ await next();+});+export const RequireUsernameAccountIdentity = createMiddleware<HonoEnv>(async (ctx, next) => {const mode = await ctx.get('instanceConfigRepository').getAccountIdentityMode();if (mode !== AccountIdentityModes.USERNAME) {diff --git a/fluxer_api/src/api/user/controllers/UserAuthController.ts b/fluxer_api/src/api/user/controllers/UserAuthController.tsindex bec15bc1f..d429a11b8 100644--- a/fluxer_api/src/api/user/controllers/UserAuthController.ts+++ b/fluxer_api/src/api/user/controllers/UserAuthController.ts@@ -9,6 +9,7 @@ import {import {requireSudoMode} from '@app/api/auth/services/SudoVerificationService';import {RequireEmailAccountIdentity,+ RequireEmailCodesAvailable,RequireUsernameAccountIdentity,} from '@app/api/middleware/AccountIdentityMiddleware';import {DefaultUserOnly, LoginRequired} from '@app/api/middleware/AuthMiddleware';@@ -192,6 +193,7 @@ export function UserAuthController(app: HonoApp) {LoginRequired,DefaultUserOnly,RequireEmailAccountIdentity,+ RequireEmailCodesAvailable,Validator('json', EmptyBodyRequest),OpenAPI({operationId: 'start_backup_codes_challenge',@@ -214,6 +216,7 @@ export function UserAuthController(app: HonoApp) {LoginRequired,DefaultUserOnly,RequireEmailAccountIdentity,+ RequireEmailCodesAvailable,Validator('json', MfaBackupCodesChallengeResendRequest),OpenAPI({operationId: 'resend_backup_codes_challenge',@@ -238,6 +241,7 @@ export function UserAuthController(app: HonoApp) {LoginRequired,DefaultUserOnly,RequireEmailAccountIdentity,+ RequireEmailCodesAvailable,Validator('json', MfaBackupCodesChallengeVerifyRequest),OpenAPI({operationId: 'verify_backup_codes_challenge',@@ -261,6 +265,7 @@ export function UserAuthController(app: HonoApp) {LoginRequired,DefaultUserOnly,RequireEmailAccountIdentity,+ RequireEmailCodesAvailable,Validator('json', MfaBackupCodesChallengeRegenerateRequest),OpenAPI({operationId: 'regenerate_backup_codes_challenge',diff --git a/fluxer_api/src/api/user/services/MfaBackupCodesChallengeService.ts b/fluxer_api/src/api/user/services/MfaBackupCodesChallengeService.tsindex b5bae723a..2bc690d7f 100644--- a/fluxer_api/src/api/user/services/MfaBackupCodesChallengeService.ts+++ b/fluxer_api/src/api/user/services/MfaBackupCodesChallengeService.ts@@ -2,10 +2,11 @@import {randomUUID} from 'node:crypto';import type {ApiContext} from '@app/api/ApiContext';-import {requireEmailVerified} from '@app/api/auth/EmailVerificationUtils';+import {hasOwnedEmail} from '@app/api/auth/services/SudoEmailCode';import {userHasMfa} from '@app/api/auth/services/SudoMethods';import type {MfaBackupCode} from '@app/api/models/MfaBackupCode';import type {User} from '@app/api/models/User';+import {assertTierAllows, NO_TIER_CONTEXT} from '@app/api/user/AccountTier';import {regenerateMfaBackupCodes} from '@app/api/user/services/UserAuth';import {assertChangeCooldown,@@ -13,7 +14,9 @@ import {generateChangeVerificationCode,} from '@app/api/user/services/UserChangeChallengeUtils';import {constantTimeEquals} from '@app/api/utils/SecretHash';+import {TierGatedActions} from '@fluxer/constants/src/AccountTierConstants';import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';+import {EmailCodesUnavailableError} from '@fluxer/errors/src/domains/auth/EmailCodesUnavailableError';import {MfaNotEnabledError} from '@fluxer/errors/src/domains/auth/MfaNotEnabledError';import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';import type {@@ -53,10 +56,11 @@ export class MfaBackupCodesChallengeService {async start(user: User): Promise<StartMfaBackupCodesChallengeResult> {const {email, rateLimit} = this.apiContext.services;- requireEmailVerified(user, 'mfa');+ assertTierAllows(user, TierGatedActions.MFA, NO_TIER_CONTEXT);if (!user.email) {throw InputValidationError.fromCode('email', ValidationErrorCodes.USER_DOES_NOT_HAVE_AN_EMAIL_ADDRESS);}+ if (!hasOwnedEmail(user)) throw new EmailCodesUnavailableError();if (!userHasMfa(user)) {throw new MfaNotEnabledError();}@@ -69,7 +73,7 @@ export class MfaBackupCodesChallengeService {const now = Date.now();const code = generateChangeVerificationCode();const codeExpiresAt = now + this.CODE_TTL_MS;- await email.sendMfaBackupCodesVerification(user.email, user.username, code, user.locale);+ await email.send('mfa_backup_codes_view', user.email, {code}, user.locale);await this.storeTicket(ticket, {user_id: user.id.toString(),code,@@ -99,7 +103,7 @@ export class MfaBackupCodesChallengeService {const now = Date.now();const code = generateChangeVerificationCode();const codeExpiresAt = now + this.CODE_TTL_MS;- await email.sendMfaBackupCodesVerification(user.email, user.username, code, user.locale);+ await email.send('mfa_backup_codes_view', user.email, {code}, user.locale);await this.storeTicket(ticket, {user_id: state.user_id,code,diff --git a/fluxer_api/src/api/user/services/UserAccountSecurityService.ts b/fluxer_api/src/api/user/services/UserAccountSecurityService.tsindex f23f73c2d..552e11aa0 100644--- a/fluxer_api/src/api/user/services/UserAccountSecurityService.ts+++ b/fluxer_api/src/api/user/services/UserAccountSecurityService.ts@@ -16,6 +16,7 @@ import {profileSubstringBlocklistCache} from '@app/api/middleware/ProfileSubstriimport {getInstanceConfigRepository} from '@app/api/middleware/ServiceSingletons';import type {AuthSession as AuthSessionModel} from '@app/api/models/AuthSession';import type {User} from '@app/api/models/User';+import {getAccountTier} from '@app/api/user/AccountTier';import {enforceFluxerTagChangeRateLimit} from '@app/api/user/FluxerTagChangeRateLimit';import type {UserRepository} from '@app/api/user/repositories/UserRepository';import {assertNoDiscriminatorChange, reserveUsername, type UsernameReservation} from '@app/api/user/UniqueUsernames';@@ -23,6 +24,7 @@ import {isProfileSubstringExempt} from '@app/api/user/UserHelpers';import {USERNAME_MODE_DISCRIMINATOR} from '@app/api/user/UserTag';import {hashPassword} from '@app/api/utils/PasswordUtils';import {AccountIdentityModes, TagStyles} from '@fluxer/constants/src/AccountIdentityConstants';+import {AccountTiers} from '@fluxer/constants/src/AccountTierConstants';import {PremiumFlags, UserPremiumTypes} from '@fluxer/constants/src/UserConstants';import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';import {ContentBlockedError} from '@fluxer/errors/src/domains/content/ContentBlockedError';@@ -72,8 +74,9 @@ export class UserAccountSecurityService {const metadata: UserUpdateMetadata = {invalidateAuthSessions: false,};- const isUnclaimedAccount = user.isUnclaimedAccount();- const identityVerifiedViaSudo = sudoContext?.method === 'mfa' || sudoContext?.method === 'sudo_token';+ const isUnclaimedAccount = getAccountTier(user) === AccountTiers.UNCLAIMED;+ const identityVerifiedViaSudo =+ sudoContext?.method === 'mfa' || sudoContext?.method === 'sudo_token' || sudoContext?.method === 'email_code';const identityVerifiedViaPassword = sudoContext?.method === 'password';const rawEmail = data.email?.trim();const normalizedEmail = rawEmail?.toLowerCase();@@ -98,7 +101,7 @@ export class UserAccountSecurityService {updates.password_last_changed_at = new Date();metadata.invalidateAuthSessions = false;} else if (data.new_password) {- if (!data.password) {+ if (!data.password && user.passwordHash !== null) {throw InputValidationError.fromCode('password', ValidationErrorCodes.PASSWORD_NOT_SET);}if (!identityVerifiedViaSudo && !identityVerifiedViaPassword) {diff --git a/fluxer_api/src/api/user/services/UserAuth.ts b/fluxer_api/src/api/user/services/UserAuth.tsindex f2b45cc2b..c6841cdfd 100644--- a/fluxer_api/src/api/user/services/UserAuth.ts+++ b/fluxer_api/src/api/user/services/UserAuth.ts@@ -41,7 +41,8 @@ async function assertSudoVerifiedForMfa(user: User,sudoContext: SudoVerificationResult,): Promise<void> {- const identityVerifiedViaSudo = sudoContext.method === 'mfa' || sudoContext.method === 'sudo_token';+ const identityVerifiedViaSudo =+ sudoContext.method === 'mfa' || sudoContext.method === 'sudo_token' || sudoContext.method === 'email_code';const identityVerifiedViaPassword = sudoContext.method === 'password';if (identityVerifiedViaSudo || identityVerifiedViaPassword) {return;@@ -84,7 +85,7 @@ export async function enableMfaTotp(},user.toRow(),);- const newBackupCodes = AuthUtility.generateBackupCodes(ctx);+ const newBackupCodes = AuthUtility.generateBackupCodes();const mfaBackupCodes = await users.createMfaBackupCodes(userId, newBackupCodes);await dispatchUserUpdate(ctx.services.gateway, updatedUser);await botMfaMirror.syncAuthenticatorTypesForOwner(updatedUser);@@ -140,7 +141,7 @@ export async function getMfaBackupCodes(export async function regenerateMfaBackupCodes(ctx: ApiContext, user: User): Promise<Array<MfaBackupCode>> {const {users} = ctx.services;const userId = user.id;- const newBackupCodes = AuthUtility.generateBackupCodes(ctx);+ const newBackupCodes = AuthUtility.generateBackupCodes();await users.clearMfaBackupCodes(userId);return await users.createMfaBackupCodes(userId, newBackupCodes);}diff --git a/fluxer_api/src/api/user/services/UserAuthRequestService.ts b/fluxer_api/src/api/user/services/UserAuthRequestService.tsindex 8496f9336..431eb93ce 100644--- a/fluxer_api/src/api/user/services/UserAuthRequestService.ts+++ b/fluxer_api/src/api/user/services/UserAuthRequestService.ts@@ -2,13 +2,14 @@import type {ApiContext} from '@app/api/ApiContext';import * as AuthMfa from '@app/api/auth/AuthMfa';-import {requireEmailVerified} from '@app/api/auth/EmailVerificationUtils';import {visibleWebAuthnCredentials} from '@app/api/auth/services/PasskeyRelyingParty';import type {SudoVerificationResult} from '@app/api/auth/services/SudoVerificationService';import type {User} from '@app/api/models/User';+import {assertCanRegisterPasskey, assertTierAllows, NO_TIER_CONTEXT} from '@app/api/user/AccountTier';import type {UserRepository} from '@app/api/user/repositories/UserRepository';import * as UserAuth from '@app/api/user/services/UserAuth';import {mapUserToPrivateResponse, mapWebAuthnCredentialToResponse} from '@app/api/user/UserMappers';+import {TierGatedActions} from '@fluxer/constants/src/AccountTierConstants';import type {DisableTotpRequest,EnableMfaTotpRequest,@@ -61,7 +62,7 @@ export class UserAuthRequestService {data,sudoContext,}: UserAuthWithSudoRequest<EnableMfaTotpRequest>): Promise<MfaBackupCodesResponse> {- requireEmailVerified(user, 'mfa');+ assertTierAllows(user, TierGatedActions.MFA, NO_TIER_CONTEXT);const backupCodes = await UserAuth.enableMfaTotp(this.apiContext, {user,secret: data.secret,@@ -84,6 +85,7 @@ export class UserAuthRequestService {data,sudoContext,}: UserAuthWithSudoRequest<MfaBackupCodesRequest>): Promise<MfaBackupCodesResponse> {+ if (data.regenerate) assertTierAllows(user, TierGatedActions.MFA, NO_TIER_CONTEXT);const backupCodes = await UserAuth.getMfaBackupCodes(this.apiContext, {user,regenerate: data.regenerate,@@ -106,13 +108,13 @@ export class UserAuthRequestService {user: User,origin: string | undefined,): Promise<WebAuthnChallengeResponse> {- requireEmailVerified(user, 'mfa');+ assertCanRegisterPasskey(user);const options = await AuthMfa.generateWebAuthnRegistrationOptions(this.apiContext, user.id, origin);return {...options};}async registerWebAuthnCredential({user, data}: UserAuthWebAuthnRegisterRequest): Promise<void> {- requireEmailVerified(user, 'mfa');+ assertCanRegisterPasskey(user);await AuthMfa.verifyWebAuthnRegistration(this.apiContext, user.id, data.response, data.challenge, data.name);}@@ -128,9 +130,7 @@ export class UserAuthRequestService {user,data,}: UserAuthRequest<WebAuthnTwoFactorRequest>): Promise<WebAuthnTwoFactorResponse> {- if (data.enabled) {- requireEmailVerified(user, 'mfa');- }+ if (data.enabled) assertTierAllows(user, TierGatedActions.MFA, NO_TIER_CONTEXT);const result = await AuthMfa.setWebAuthnTwoFactor(this.apiContext, user.id, data.enabled);return {user: mapUserToPrivateResponse(result.user),