@adonis-agora/authkit-server 0.70.0 → 0.72.0

package/build/src/host/controllers/interaction_controller.js

@@ -4,7 +4,7 @@ import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
 import { brandFor, isFirstParty } from '../branding.js';
 import { sendMagicLinkEmail, sendOtpUnlockEmail } from '../default_mailer.js';
-import { resolveEmailIdentifier } from '../email_identifier.js';
+import { normalizeEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
 import { assertLoginAllowed, attemptPasswordLogin, isEmailUnverifiedBlock, } from '../login_attempt.js';
 import { magicChannelProp, normalizeLoginChannel } from '../login_channel.js';
@@ -43,30 +43,19 @@ function accountStatusErrorKey(reason) {
  * para que a canonicalização não vire um oráculo de "esta conta existe".
  */
 const SESSION_KEY = 'authkit_login_email';
-/**
- * E-mail sob o qual a conta está GRAVADA, quando a ponte de compatibilidade
- * precisou de uma forma diferente da digitada ({@link resolveEmailIdentifier}).
- * É o e-mail que vai para o account store em TODA busca/emissão de token.
- * Ausente = igual ao digitado.
- */
-const SESSION_LOOKUP_KEY = 'authkit_login_email_lookup';
 /** accountId aguardando o 2º fator depois da senha verificada. */
 const MFA_PENDING_KEY = 'authkit_mfa_pending';
 /** Desafio WebAuthn pendente (autenticação) guardado entre begin/finish no login. */
 const PASSKEY_AUTH_CHALLENGE_KEY = 'authkit_passkey_auth_challenge';
 /**
- * E-mail para BUSCAR a conta no store. Cai no e-mail digitado quando não há
- * forma de compatibilidade gravada — inclusive nas sessões que já estavam
- * abertas antes deste deploy.
+ * Esquece o e-mail do login.
+ *
+ * Helper de UMA linha de propósito: os fluxos que encerram o passo de login
+ * (sucesso, "usar outro e-mail", expiração) chamam ISTO em vez de `forget` da
+ * chave crua, para que nenhum caminho deixe o e-mail pendurado na sessão.
  */
-function lookupEmail(ctx) {
-    return (ctx.session.get(SESSION_LOOKUP_KEY) ??
-        ctx.session.get(SESSION_KEY));
-}
-/** Esquece o e-mail do login (digitado + forma de busca) de uma vez só. */
 function forgetLoginEmail(ctx) {
     ctx.session.forget(SESSION_KEY);
-    ctx.session.forget(SESSION_LOOKUP_KEY);
 }
 export default class AuthInteractionController {
     /**
@@ -188,8 +177,6 @@ export default class AuthInteractionController {
             });
         }
         const email = ctx.session.get(SESSION_KEY);
-        // O que a tela mostra é `email` (o digitado); o que busca a conta é este.
-        const storeEmail = lookupEmail(ctx);
         // Métodos de login efetivos (magic link, OTP, social) — account-independent
         // neste ponto (passkey-first depende da conta, resolvido no step 2). Reusa o
         // helper compartilhado por TODOS os renders do passo login, para que
@@ -199,7 +186,7 @@ export default class AuthInteractionController {
         // Com email na sessão (passo 2+), aplica a preferência POR USUÁRIO — os
         // métodos que o dono da conta desligou não aparecem nem aqui nem nos POSTs.
         const loginMethods = email
-            ? await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettingsForMaintenance)
+            ? await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettingsForMaintenance)
             : await this.#loginMethods(ctx, cfg, runtimeSettingsForMaintenance);
         const authMethods = loginMethods.authMethods;
         if (!email) {
@@ -216,7 +203,7 @@ export default class AuthInteractionController {
             });
         }
         // Step 2: password — look up user for personalisation (enumeration-safe: always show step 2)
-        const acc = await cfg.accountStore.findByEmail(storeEmail ?? email);
+        const acc = await cfg.accountStore.findByEmail(email);
         const account = acc ? { fullName: acc.name ?? null, globalRoles: acc.globalRoles ?? [] } : null;
         // Passwordless: magic link disponível vem do helper (`loginMethods`).
         // Passkey-first disponível se ligado, o store suporta, a conta tem passkeys E auth_methods permite.
@@ -249,24 +236,17 @@ export default class AuthInteractionController {
      * `trim` + `toLowerCase`) — antes disto o valor cru ia para a sessão e a busca
      * no store era por igualdade exata, então nem `Davi@x.com` achava `davi@x.com`.
      *
-     * A resolução acontece AQUI (uma vez, onde o valor digitado ainda existe) e
-     * não a cada request do passo 2. Guarda DUAS coisas: o digitado (o que a tela
-     * mostra) e, se a ponte de compatibilidade precisou de outra forma, o endereço
-     * sob o qual a conta está gravada (o que vai para o store). A resposta continua
-     * sendo o mesmo redirect incondicional, ache conta ou não.
+     * À PROVA DE ENUMERAÇÃO: o passo NÃO toca no account store — só normaliza e
+     * guarda. A resposta é o MESMO redirect incondicional, exista a conta ou não,
+     * e não há busca alguma aqui para diferenciar os dois casos nem no tempo de
+     * resposta. Quem decide se a conta existe é o passo 2, que renderiza a mesma
+     * tela nos dois casos.
      */
     async identifier(ctx) {
-        const service = await ctx.containerResolver.make('authkit.server');
-        const cfg = service.config;
         const { email } = ctx.request.only(['email']);
-        const resolved = await resolveEmailIdentifier(cfg.accountStore, email, {
-            legacyFallback: cfg.login?.legacyEmailFallback ?? true,
-        });
-        ctx.session.put(SESSION_KEY, resolved.email);
-        if (resolved.viaLegacyFallback)
-            ctx.session.put(SESSION_LOOKUP_KEY, resolved.lookupEmail);
-        else
-            ctx.session.forget(SESSION_LOOKUP_KEY);
+        // `request.only` não valida tipo (`email[]=x` chega array): a normalização
+        // devolve string vazia para não-string, e o passo segue com o redirect.
+        ctx.session.put(SESSION_KEY, normalizeEmailIdentifier(email));
         return ctx.response.redirect(`/auth/interaction/${ctx.request.param('uid')}`);
     }
     /**
@@ -284,8 +264,6 @@ export default class AuthInteractionController {
             // Session expired or tampered — send back to step 1
             return ctx.response.redirect(`/auth/interaction/${ctx.request.param('uid')}`);
         }
-        // `email` é o digitado (o que a tela mostra); `storeEmail` é o que busca a conta.
-        const storeEmail = lookupEmail(ctx) ?? email;
         const { password } = ctx.request.only(['password']);
         const ip = ctx.request.ip?.() ?? null;
         const clientId = details.params.client_id ?? null;
@@ -302,15 +280,15 @@ export default class AuthInteractionController {
         // We use a cfg-compatible object: pass effectiveBotLogin merged into cfg.
         const cfgWithEffectiveBot = effectiveBotLogin !== cfg.botProtection ? { ...cfg, botProtection: effectiveBotLogin } : cfg;
         if (!(await guardBotProtection(ctx, cfgWithEffectiveBot, 'login', {
-            email: storeEmail,
+            email,
             clientId,
         }))) {
-            const found = await cfg.accountStore.findByEmail(storeEmail);
+            const found = await cfg.accountStore.findByEmail(email);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
             return render(ctx, 'login', {
-                ...(await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettings)),
+                ...(await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettings)),
                 uid: ctx.request.param('uid'),
                 csrfToken: ctx.request.csrfToken,
                 step: 'password',
@@ -324,9 +302,9 @@ export default class AuthInteractionController {
         // Preferência por usuário: senha desligada para ESTA conta → recusa ANTES de
         // verificar credenciais (mesma tela/erro de credencial inválida — não vaza
         // se a conta existe nem qual preferência está gravada).
-        const userMethodsForLogin = await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettings);
+        const userMethodsForLogin = await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettings);
         if (!userMethodsForLogin.authMethods.password) {
-            const found = await cfg.accountStore.findByEmail(storeEmail);
+            const found = await cfg.accountStore.findByEmail(email);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
@@ -355,7 +333,7 @@ export default class AuthInteractionController {
         // ainda. A sequência verificação + lockout + auditoria de falha é centralizada
         // em attemptPasswordLogin; a renderização (lookup p/ personalização) fica aqui.
         const result = await attemptPasswordLogin(cfg, {
-            email: storeEmail,
+            email,
             password,
             ip,
             clientId,
@@ -379,7 +357,7 @@ export default class AuthInteractionController {
                     botProtection: undefined,
                 });
             }
-            const found = await cfg.accountStore.findByEmail(storeEmail);
+            const found = await cfg.accountStore.findByEmail(email);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
@@ -427,55 +405,24 @@ export default class AuthInteractionController {
             }
             // Admin: prossegue normalmente (sem bloqueio).
         }
-        // Step-up auth (acr_values): o client pode EXIGIR MFA nesta requisição
-        // solicitando o `mfaAcr` em acr_values, mesmo que a conta tenha MFA opcional.
-        const mfaRequired = this.acrRequiresMfa(cfg, details);
-        // MFA gate: força o 2º fator se a conta tem TOTP ativo OU se o client exige MFA
-        // via acr. Não finaliza a interaction agora — guarda o accountId pendente.
-        const mfa = (await cfg.accountStore.getMfaState?.(acc.id)) ?? { enabled: false };
-        if (mfa.enabled || mfaRequired) {
-            if (mfaRequired && !mfa.enabled) {
-                // Client exige MFA mas a conta não tem MFA enrolado: bloqueia este login
-                // com a instrução de configurar MFA no console (não há 2º fator a desafiar).
-                return render(ctx, 'mfa-challenge', {
-                    uid: ctx.request.param('uid'),
-                    csrfToken: ctx.request.csrfToken,
-                    brand,
-                    passkeyAvailable: false,
-                    error: translate(cfg.messages, 'mfa_challenge.required_no_enrollment'),
-                    noEnrollment: true,
-                });
-            }
-            // Trusted device: se o mecanismo está ligado, a conta JÁ tem MFA enrolado e
-            // o request NÃO é um step-up (que sempre força o MFA), um cookie de confiança
-            // válido para ESTA conta pula o 2º fator. amr fica `['pwd']` (sem acr de MFA).
-            if (cfg.trustedDevices.enabled && mfa.enabled && !mfaRequired) {
-                const trusted = await this.checkTrustedDevice(ctx, acc.id, mfa.enabledAt ?? null);
-                if (trusted) {
-                    await service.interactions.completeLogin(ctx, acc.id, { amr: ['pwd'] });
-                    await notifyLoginSuccess(ctx, cfg, {
-                        accountId: acc.id,
-                        email,
-                        ip,
-                        clientId,
-                        trustedDevice: true,
-                    });
-                    forgetLoginEmail(ctx);
-                    return;
-                }
-            }
-            ctx.session.put(MFA_PENDING_KEY, acc.id);
-            // Passkey disponível como alternativa ao TOTP se o store suporta E a conta
-            // tem ao menos uma credencial registrada.
-            const passkeyAvailable = await this.hasPasskeys(cfg, acc.id);
-            return render(ctx, 'mfa-challenge', {
-                uid: ctx.request.param('uid'),
-                csrfToken: ctx.request.csrfToken,
-                brand,
-                passkeyAvailable,
-                trustedDevicesEnabled: cfg.trustedDevices.enabled,
-                trustedDeviceDays: cfg.trustedDevices.days,
+        // Gate do 2º fator — a MESMA regra dos três caminhos de login (ver
+        // `secondFactorGate`). Quando desafia, não finaliza a interaction: guarda o
+        // accountId pendente e devolve a tela.
+        const gate = await this.secondFactorGate(ctx, cfg, acc.id, details);
+        if (gate.kind === 'challenge')
+            return gate.response;
+        if (gate.kind === 'trusted') {
+            // Dispositivo confiável: pula o 2º fator. amr fica `['pwd']` (sem acr de MFA).
+            await service.interactions.completeLogin(ctx, acc.id, { amr: ['pwd'] });
+            await notifyLoginSuccess(ctx, cfg, {
+                accountId: acc.id,
+                email,
+                ip,
+                clientId,
+                trustedDevice: true,
             });
+            forgetLoginEmail(ctx);
+            return;
         }
         // Sem MFA: finaliza a interaction (escreve o 303 de volta para o client).
         // Resolve session_policy para remember-me e single-session.
@@ -553,6 +500,7 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'errors.otp_locked'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
                 otpLocked: true,
@@ -586,6 +534,7 @@ export default class AuthInteractionController {
                     error: translate(cfg.messages, 'errors.otp_locked'),
                     brand,
                     passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                    totpAvailable: await this.hasTotp(cfg, accountId),
                     trustedDevicesEnabled: cfg.trustedDevices.enabled,
                     trustedDeviceDays: cfg.trustedDevices.days,
                     otpLocked: true,
@@ -597,6 +546,7 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'errors.invalid_code'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
             });
@@ -641,6 +591,84 @@ export default class AuthInteractionController {
             return undefined;
         return { acr: cfg.stepUp.mfaAcr, amr: ['mfa', method] };
     }
+    /**
+     * Gate do segundo fator, compartilhado pelos caminhos de login: senha, link
+     * mágico, código por e-mail e troca forçada de senha. Antes disto só o login
+     * por senha passava pelo MFA — link e código completavam a interaction direto,
+     * então uma conta com TOTP ou passkey entrava apresentando só o e-mail e o
+     * segundo fator virava enfeite.
+     *
+     * A pergunta que o gate responde é "existe um fator que esta pessoa consegue
+     * apresentar AGORA?", e não `mfa.enabled` — que liga ao registrar uma passkey
+     * e não desliga ao remover a última. Fator utilizável = TOTP confirmado
+     * (`mfa.totp`) OU ao menos uma passkey registrada. Pela regra antiga, quem
+     * registrava uma passkey e depois a removia ficava preso num desafio TOTP que
+     * não tinha como responder.
+     *
+     *  - sem fator e sem step-up → `none`, o login segue;
+     *  - step-up (acr) exigindo MFA numa conta sem fator → `challenge` com a
+     *    instrução de enrolar (não há o que desafiar);
+     *  - fator presente, trusted-device válido e sem step-up → `trusted`; quem
+     *    chamou decide como finalizar, porque o amr muda conforme o caminho;
+     *  - caso geral → `challenge`, com o accountId em `MFA_PENDING_KEY`.
+     */
+    async secondFactorGate(ctx, cfg, accountId, details) {
+        const mfaRequired = this.acrRequiresMfa(cfg, details);
+        const mfa = (await cfg.accountStore.getMfaState?.(accountId)) ?? { enabled: false };
+        // Passkey disponível como alternativa ao TOTP se o store suporta E a conta
+        // tem ao menos uma credencial registrada.
+        const passkeyAvailable = await this.hasPasskeys(cfg, accountId);
+        // Store que não reporta `totp` (a chave é opcional) cai no `enabled` — o
+        // comportamento antigo. Nunca o contrário: assumir "sem TOTP" por omissão
+        // deixaria de desafiar quem tem o fator.
+        const totpAvailable = mfa.totp ?? !!mfa.enabled;
+        const hasFactor = passkeyAvailable || totpAvailable;
+        if (!hasFactor && !mfaRequired)
+            return { kind: 'none' };
+        const render = cfg.render;
+        const brand = brandFor(cfg.branding, details.params.client_id, details.params.audience);
+        const uid = ctx.request.param('uid');
+        if (!hasFactor) {
+            return {
+                kind: 'challenge',
+                response: await render(ctx, 'mfa-challenge', {
+                    uid,
+                    csrfToken: ctx.request.csrfToken,
+                    brand,
+                    passkeyAvailable: false,
+                    error: translate(cfg.messages, 'mfa_challenge.required_no_enrollment'),
+                    noEnrollment: true,
+                }),
+            };
+        }
+        if (cfg.trustedDevices.enabled && !mfaRequired) {
+            const trusted = await this.checkTrustedDevice(ctx, accountId, mfa.enabledAt ?? null);
+            if (trusted)
+                return { kind: 'trusted' };
+        }
+        ctx.session.put(MFA_PENDING_KEY, accountId);
+        return {
+            kind: 'challenge',
+            response: await render(ctx, 'mfa-challenge', {
+                uid,
+                csrfToken: ctx.request.csrfToken,
+                brand,
+                passkeyAvailable,
+                totpAvailable,
+                trustedDevicesEnabled: cfg.trustedDevices.enabled,
+                trustedDeviceDays: cfg.trustedDevices.days,
+            }),
+        };
+    }
+    /**
+     * true se a conta tem um app autenticador CONFIRMADO. Stores que não reportam
+     * `totp` (a chave é opcional em {@link MfaCapability}) caem no `enabled`, o
+     * comportamento antigo.
+     */
+    async hasTotp(cfg, accountId) {
+        const mfa = (await cfg.accountStore.getMfaState?.(accountId)) ?? { enabled: false };
+        return mfa.totp ?? !!mfa.enabled;
+    }
     /** true se o store suporta passkeys E a conta tem ao menos uma registrada. */
     async hasPasskeys(cfg, accountId) {
         if (!supportsPasskeys(cfg.accountStore))
@@ -728,7 +756,7 @@ export default class AuthInteractionController {
             return pending;
         if (!cfg.passwordless?.passkeyFirst)
             return undefined;
-        const email = lookupEmail(ctx);
+        const email = ctx.session.get(SESSION_KEY);
         if (!email)
             return undefined;
         const acc = await cfg.accountStore.findByEmail(email);
@@ -749,9 +777,6 @@ export default class AuthInteractionController {
         const details = await service.interactions.details(ctx);
         const brand = brandFor(cfg.branding, details.params.client_id, details.params.audience);
         const email = ctx.session.get(SESSION_KEY);
-        // `email` é o digitado (o que a tela mostra); `storeEmail` emite e ENDEREÇA o
-        // magic link — precisa ser a caixa postal sob a qual a conta está gravada.
-        const storeEmail = lookupEmail(ctx);
         const uid = ctx.request.param('uid');
         // Login por OTP: liga o campo de código na tela "link enviado" quando a config
         // está ligada E o store suporta a capacidade.
@@ -763,7 +788,7 @@ export default class AuthInteractionController {
         // Preferência por usuário: magic link desligado para ESTA conta → não emite
         // token (resposta uniforme "enviado", sem vazar a preferência).
         const userScopedMethods = email && cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore)
-            ? await this.#userScopedLoginMethods(ctx, cfg, storeEmail)
+            ? await this.#userScopedLoginMethods(ctx, cfg, email)
             : null;
         if (userScopedMethods && !userScopedMethods.authMethods.magicLink) {
             return render(ctx, 'login', {
@@ -778,17 +803,17 @@ export default class AuthInteractionController {
                 magicChannel: 'none',
             });
         }
-        if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && storeEmail) {
+        if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && email) {
             const ip = ctx.request.ip?.() ?? null;
             const clientId = details.params.client_id ?? null;
             // Com OTP ligado, emite link E código no MESMO disparo (issueMagicLinkWithCode);
             // senão, o magic link puro de sempre.
             const issued = otpEnabled
-                ? await cfg.accountStore.issueMagicLinkWithCode(storeEmail, uid, {
+                ? await cfg.accountStore.issueMagicLinkWithCode(email, uid, {
                     digits: cfg.login.otp.digits,
                     ttlMinutes: cfg.login.otp.ttlMinutes,
                 })
-                : await cfg.accountStore.issueMagicLinkToken(storeEmail);
+                : await cfg.accountStore.issueMagicLinkToken(email);
             if (issued) {
                 const code = 'code' in issued ? issued.code : undefined;
                 await cfg.audit?.record({
@@ -823,7 +848,7 @@ export default class AuthInteractionController {
         // local usado acima para decidir a emissão) — não re-declarado aqui.
         return render(ctx, 'login', {
             ...(email
-                ? await this.#userScopedLoginMethods(ctx, cfg, storeEmail)
+                ? await this.#userScopedLoginMethods(ctx, cfg, email)
                 : await this.#loginMethods(ctx, cfg)),
             uid,
             csrfToken: ctx.request.csrfToken,
@@ -945,12 +970,21 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, accountStatusErrorKey(magicLinkStatusGate.reason)),
             });
         }
+        // Conta com segundo fator não termina o login só com o e-mail.
+        const magicGate = await this.secondFactorGate(ctx, cfg, acc.id, await service.interactions.details(ctx));
+        if (magicGate.kind === 'challenge')
+            return magicGate.response;
         await notifyLoginSuccess(ctx, cfg, {
             accountId: acc.id,
             email: acc.email,
             ip,
             clientId: clientId ?? null,
             metadata: { method: 'magic_link' },
+            // `trusted` = o gate já validou o cookie de confiança nesta request; dizer
+            // isso aqui poupa `notifyLoginSuccess` de reler o mesmo cookie para decidir
+            // se é dispositivo novo. O amr continua `['email']`: o fator primário foi o
+            // e-mail, a confiança só dispensou o segundo.
+            trustedDevice: magicGate.kind === 'trusted',
         });
         forgetLoginEmail(ctx);
         await service.interactions.completeLogin(ctx, acc.id, { amr: ['email'] });
@@ -973,11 +1007,9 @@ export default class AuthInteractionController {
         const ip = ctx.request.ip?.() ?? null;
         const clientId = (await service.interactions.details(ctx)).params.client_id;
         const email = ctx.session.get(SESSION_KEY);
-        // `email` é o digitado (o que a tela mostra); `storeEmail` verifica o código.
-        const storeEmail = lookupEmail(ctx);
         // Guardas: OTP desligado, store sem suporte ou sem e-mail na sessão → volta ao login.
         const otpEnabled = cfg.login.otp.enabled && supportsOtpLogin(cfg.accountStore);
-        if (!otpEnabled || !email || !storeEmail) {
+        if (!otpEnabled || !email) {
             return ctx.response.redirect(`/auth/interaction/${uid}`);
         }
         const code = String(ctx.request.input('code', '') ?? '').trim();
@@ -985,14 +1017,14 @@ export default class AuthInteractionController {
         // Mantém a sub-view do seletor no re-render de erro (o form de código pode
         // POSTar `channel=code`). Ausente = both (histórico).
         const channel = normalizeLoginChannel(ctx.request.input('channel'));
-        const result = await cfg.accountStore.verifyLoginCode(storeEmail, uid, code, {
+        const result = await cfg.accountStore.verifyLoginCode(email, uid, code, {
             maxAttempts: cfg.login.otp.maxAttempts,
         });
         // Re-render da tela "link enviado" com o campo de código + erro localizado.
         // `otpEnabled` vem do spread (scoped — OTP é extensão do magic link, e a
         // preferência do usuário que desligou magic link já foi barrada acima).
         const renderOtpError = async (messageKey) => render(ctx, 'login', {
-            ...(await this.#userScopedLoginMethods(ctx, cfg, storeEmail)),
+            ...(await this.#userScopedLoginMethods(ctx, cfg, email)),
             uid,
             csrfToken: ctx.request.csrfToken,
             step: 'password',
@@ -1060,25 +1092,30 @@ export default class AuthInteractionController {
                 ip,
                 clientId,
             });
+            // Conta com segundo fator não termina o login só com o código do e-mail.
+            const otpGate = await this.secondFactorGate(ctx, cfg, result.account.id, await service.interactions.details(ctx));
+            if (otpGate.kind === 'challenge')
+                return otpGate.response;
             await notifyLoginSuccess(ctx, cfg, {
                 accountId: result.account.id,
                 email: result.account.email,
                 ip,
                 clientId: clientId ?? null,
                 metadata: { method: 'otp' },
+                trustedDevice: otpGate.kind === 'trusted',
             });
             forgetLoginEmail(ctx);
             return service.interactions.completeLogin(ctx, result.account.id, { amr: ['email'] });
         }
         if (result.status === 'locked') {
             // 5ª falha (ou já travado): código invalidado, o LINK continua válido.
-            await cfg.audit?.record({ type: 'login.otp_invalidated', email: storeEmail, ip, clientId });
+            await cfg.audit?.record({ type: 'login.otp_invalidated', email, ip, clientId });
             return renderOtpError('login.otp_locked');
         }
         if (result.status === 'expired') {
             await cfg.audit?.record({
                 type: 'login.otp_failed',
-                email: storeEmail,
+                email,
                 ip,
                 clientId,
                 metadata: { reason: 'expired' },
@@ -1088,7 +1125,7 @@ export default class AuthInteractionController {
         // 'invalid' (tentativa contabilizada) ou 'no_code'.
         await cfg.audit?.record({
             type: 'login.otp_failed',
-            email: storeEmail,
+            email,
             ip,
             clientId,
             metadata: { reason: result.status },
@@ -1252,6 +1289,7 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'mfa_challenge.passkey_error'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
             });
@@ -1274,6 +1312,7 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'errors.email_unverified'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
             });
@@ -1304,6 +1343,7 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, accountStatusErrorKey(passkeyStatusGate.reason)),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
             });
@@ -1400,20 +1440,10 @@ export default class AuthInteractionController {
         });
         // Senha trocada: limpa o step e finaliza o login.
         ctx.session.forget(PASSWORD_EXPIRED_KEY);
-        // Verifica se precisa de MFA mesmo após a troca.
-        const mfa = (await cfg.accountStore.getMfaState?.(accountId)) ?? { enabled: false };
-        if (mfa.enabled) {
-            ctx.session.put(MFA_PENDING_KEY, accountId);
-            const passkeyAvailable = await this.hasPasskeys(cfg, accountId);
-            return render(ctx, 'mfa-challenge', {
-                uid: ctx.request.param('uid'),
-                csrfToken: ctx.request.csrfToken,
-                brand,
-                passkeyAvailable,
-                trustedDevicesEnabled: cfg.trustedDevices.enabled,
-                trustedDeviceDays: cfg.trustedDevices.days,
-            });
-        }
+        // Verifica se precisa de MFA mesmo após a troca — mesma regra do resto.
+        const expiredGate = await this.secondFactorGate(ctx, cfg, accountId, details);
+        if (expiredGate.kind === 'challenge')
+            return expiredGate.response;
         await service.interactions.completeLogin(ctx, accountId);
         const account = await cfg.accountStore.findById(accountId);
         await notifyLoginSuccess(ctx, cfg, {

package/build/src/host/controllers/registration_controller.js

@@ -5,7 +5,6 @@ import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
 import { brandFor } from '../branding.js';
 import { sendEmailVerificationEmail, sendMagicLinkEmail, sendPasswordResetEmail, } from '../default_mailer.js';
-import { resolveEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
 import { authkitOrigin } from '../origin.js';
 import { RuntimeSettings, resolveRuntimeSettings } from '../runtime_settings.js';
@@ -119,13 +118,9 @@ export default class AuthRegistrationController {
         }
         const data = await ctx.request.validateUsing(signupValidator);
         const accountStore = cfg.accountStore;
-        // Duplicado: além do endereço normalizado, enxerga a conta que o cadastro
-        // antigo gravou mutilada — senão a mesma pessoa ganharia uma SEGUNDA conta.
-        // Usa o valor CRU do formulário (o validator já normalizou `data.email`, e a
-        // ponte precisa da grafia original entre as candidatas).
-        const existing = (await resolveEmailIdentifier(accountStore, ctx.request.input('email'), {
-            legacyFallback: cfg.login?.legacyEmailFallback ?? true,
-        })).account;
+        // Duplicado pela MESMA forma que o login busca (`data.email` já saiu
+        // normalizado do validator).
+        const existing = await accountStore.findByEmail(data.email);
         if (existing) {
             return render(ctx, 'signup', {
                 uid: ctx.request.param('uid'),
@@ -224,10 +219,7 @@ export default class AuthRegistrationController {
         const data = await ctx.request.validateUsing(passwordlessSignupValidator);
         // Cria a conta se ainda não existe. Senha random inutilizável: o login é 100%
         // passwordless (mesmo precedente das contas criadas por identidade social).
-        // Valor CRU do formulário pelo mesmo motivo do cadastro com senha.
-        const existing = (await resolveEmailIdentifier(accountStore, ctx.request.input('email'), {
-            legacyFallback: cfg.login?.legacyEmailFallback ?? true,
-        })).account;
+        const existing = await accountStore.findByEmail(data.email);
         if (!existing) {
             const created = await accountStore.create({
                 email: data.email,
@@ -243,10 +235,9 @@ export default class AuthRegistrationController {
             });
         }
         // Emite + envia o magic link (mesma construção do login por magic link).
-        // Conta já existente entra pelo endereço sob o qual está GRAVADA (pode ser a
-        // forma mutilada pelo cadastro antigo); conta nova, pelo endereço digitado.
-        const issueFor = existing?.email ?? data.email;
-        const issued = await accountStore.issueMagicLinkToken(issueFor);
+        // `data.email` já é a forma normalizada — a mesma sob a qual a conta foi
+        // encontrada acima ou acabou de ser criada.
+        const issued = await accountStore.issueMagicLinkToken(data.email);
         if (issued) {
             const origin = authkitOrigin(cfg);
             const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
@@ -336,17 +327,10 @@ export default class AuthRegistrationController {
         }
         const { email } = await ctx.request.validateUsing(forgotPasswordValidator);
         const accountStore = cfg.accountStore;
-        let result = await accountStore.issuePasswordResetToken(email);
-        // Ponte legada: quem teve o endereço mutilado pelo cadastro antigo precisa
-        // conseguir resetar a senha digitando o endereço REAL. Só entra quando o
-        // endereço normalizado não achou nada — o caminho feliz segue com UMA
-        // chamada só. Resposta uniforme (a tela abaixo é a mesma, ache ou não).
-        if (!result && (cfg.login?.legacyEmailFallback ?? true)) {
-            const resolved = await resolveEmailIdentifier(accountStore, ctx.request.input('email'));
-            if (resolved.viaLegacyFallback) {
-                result = await accountStore.issuePasswordResetToken(resolved.lookupEmail);
-            }
-        }
+        // `email` já saiu normalizado do validator (a MESMA normalização do
+        // cadastro e do login). Resposta uniforme: a tela abaixo é a mesma, ache
+        // conta ou não.
+        const result = await accountStore.issuePasswordResetToken(email);
         if (result) {
             await cfg.audit?.record({
                 type: 'password_reset.issued',

package/build/src/host/controllers/social_controller.js

@@ -1,7 +1,7 @@
 import '../augmentations.js';
 import { randomUUID } from 'node:crypto';
 import { supportsLoginMethodsPreference, supportsMagicLink, supportsPasskeys, supportsProviderIdentity, } from '../../accounts/account_store.js';
-import { normalizeEmailIdentifier, resolveEmailIdentifier } from '../email_identifier.js';
+import { normalizeEmailIdentifier } from '../email_identifier.js';
 import { assertLoginAllowed } from '../login_attempt.js';
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods } from '../runtime_toggles.js';
@@ -71,12 +71,10 @@ export default class AuthSocialController {
         //  3. Senão → cria conta nova e liga a identidade.
         let user = await store.findByProviderIdentity(provider, profile.id);
         if (!user && email) {
-            // Ponte legada: sem ela, quem tem a conta gravada com o endereço mutilado
-            // pelo cadastro antigo ganharia uma SEGUNDA conta ao "Continuar com o
-            // Google" em vez de ligar a identidade à conta que já tem.
-            const byEmail = (await resolveEmailIdentifier(store, profile.email, {
-                legacyFallback: cfg.login?.legacyEmailFallback ?? true,
-            })).account;
+            // Busca pela MESMA forma normalizada que o login usa. Uma conta gravada
+            // com outra grafia não é encontrada aqui e a pessoa ganharia uma SEGUNDA
+            // conta — por isso `authkit:users:normalize-emails` é passo de upgrade.
+            const byEmail = await store.findByEmail(email);
             if (byEmail) {
                 await store.linkProviderIdentity({
                     accountId: byEmail.id,