Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

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.ts
index 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): P
const {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): P
webauthn: 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.ts
new file mode 100644
index 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.ts
index 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/do
interface 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, hasPasskeyCredentia
return 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.ts
index 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-later
import * 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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/SudoVerification
import {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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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/ProfileSubstri
import {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.ts
index 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.ts
index 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),