@adonis-agora/authkit-server 0.69.0 → 0.70.0

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

@@ -3,6 +3,7 @@ import { accountHome } from '../account_home.js';
 import { getAccountLoginUrl } from '../account_login_url.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { syncAdonisAuthLogin, syncAdonisAuthLogout } from '../adonis_auth_sync.js';
+import { resolveEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
 import { endBridgedIdpSession } from '../idp_session_bridge.js';
 import { attemptPasswordLogin } from '../login_attempt.js';
@@ -60,10 +61,6 @@ export default class AccountSessionController {
         const cfg = service.config;
         const render = cfg.render;
         const { email: rawEmail, password } = ctx.request.only(['email', 'password']);
-        // L6: normaliza o e-mail (trim + lowercase) ANTES de usar — garante que o
-        // lookup, o lockout (keyed por email) e a auditoria usem a forma canônica,
-        // independente do casing/espaços digitados.
-        const email = typeof rawEmail === 'string' ? rawEmail.trim().toLowerCase() : rawEmail;
         const ip = ctx.request.ip?.() ?? null;
         // Lê e valida o return_to do corpo do formulário (hidden input) — nunca confiar sem revalidar.
         const rawReturnTo = ctx.request.input?.('return_to');
@@ -71,8 +68,18 @@ export default class AccountSessionController {
         // Verificação + lockout + auditoria de falha centralizados (sem clientId no console).
         // M1: passa `settings` p/ o lockout (e verified-email/expiração) runtime valerem aqui também.
         const settings = await resolveRuntimeSettings(ctx);
+        // L6: `resolveEmailIdentifier` normaliza (trim + lowercase, a MESMA função do
+        // cadastro e do passo de identificador do login OIDC) e devolve o endereço sob
+        // o qual a conta está gravada — de modo que o lookup, o lockout (keyed por
+        // e-mail) e a auditoria usem a forma canônica, independente do casing/espaços
+        // digitados. A ponte legada faz a conta que nasceu com o endereço mutilado
+        // entrar no console pelo endereço REAL, como no login OIDC. A tela de erro é a
+        // mesma (credencial inválida), ache conta ou não.
+        const { lookupEmail } = await resolveEmailIdentifier(cfg.accountStore, rawEmail, {
+            legacyFallback: cfg.login?.legacyEmailFallback ?? true,
+        });
         const result = await attemptPasswordLogin(cfg, {
-            email,
+            email: lookupEmail,
             password,
             ip,
             logger: ctx.logger,
@@ -106,7 +113,7 @@ export default class AccountSessionController {
         // Opt-in: sincroniza ctx.auth.use(cfg.adonisAuth.guard) com a mesma conta —
         // no-op sem `adonisAuth` configurado ou sem @adonisjs/auth inicializado.
         await syncAdonisAuthLogin(ctx, cfg, acc);
-        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email, ip });
+        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email: acc.email, ip });
         // Redireciona pro destino original (validado), ou cai no accountHome configurado.
         return ctx.response.redirect(returnTo ?? accountHome(cfg));
     }

package/build/src/host/controllers/interaction_controller.d.ts

@@ -7,6 +7,16 @@ export default class AuthInteractionController {
      * POST /auth/interaction/:uid/identifier
      * Step 1: receive email, store in session, redirect to step 2.
      * ENUMERATION-SAFE: always advances regardless of whether the email exists.
+     *
+     * Normaliza o e-mail com a MESMA regra do cadastro (`normalizeEmailIdentifier`:
+     * `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.
      */
     identifier(ctx: HttpContext): Promise<void>;
     /**

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

@@ -4,6 +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 { translate } from '../i18n.js';
 import { assertLoginAllowed, attemptPasswordLogin, isEmailUnverifiedBlock, } from '../login_attempt.js';
 import { magicChannelProp, normalizeLoginChannel } from '../login_channel.js';
@@ -36,11 +37,37 @@ function accountStatusErrorKey(reason) {
             return 'login.password_expired_intro';
     }
 }
+/**
+ * E-mail DIGITADO no passo de identificador, já normalizado (`trim` +
+ * `toLowerCase`). É o que a tela SEMPRE mostra — nunca o endereço gravado —,
+ * 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.
+ */
+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 {
     /**
      * Métodos de login efetivos (com os pins do `cfg.authMethods`) para QUALQUER render do
@@ -161,6 +188,8 @@ 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
@@ -170,7 +199,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, email, runtimeSettingsForMaintenance)
+            ? await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettingsForMaintenance)
             : await this.#loginMethods(ctx, cfg, runtimeSettingsForMaintenance);
         const authMethods = loginMethods.authMethods;
         if (!email) {
@@ -187,7 +216,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(email);
+        const acc = await cfg.accountStore.findByEmail(storeEmail ?? 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.
@@ -215,10 +244,29 @@ export default class AuthInteractionController {
      * POST /auth/interaction/:uid/identifier
      * Step 1: receive email, store in session, redirect to step 2.
      * ENUMERATION-SAFE: always advances regardless of whether the email exists.
+     *
+     * Normaliza o e-mail com a MESMA regra do cadastro (`normalizeEmailIdentifier`:
+     * `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.
      */
     async identifier(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
         const { email } = ctx.request.only(['email']);
-        ctx.session.put(SESSION_KEY, 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);
         return ctx.response.redirect(`/auth/interaction/${ctx.request.param('uid')}`);
     }
     /**
@@ -236,6 +284,8 @@ 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;
@@ -251,13 +301,16 @@ export default class AuthInteractionController {
         // credenciais. Fail-safe: erro/timeout no verify do host PERMITE o fluxo.
         // 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, clientId }))) {
-            const found = await cfg.accountStore.findByEmail(email);
+        if (!(await guardBotProtection(ctx, cfgWithEffectiveBot, 'login', {
+            email: storeEmail,
+            clientId,
+        }))) {
+            const found = await cfg.accountStore.findByEmail(storeEmail);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
             return render(ctx, 'login', {
-                ...(await this.#userScopedLoginMethods(ctx, cfg, email, runtimeSettings)),
+                ...(await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettings)),
                 uid: ctx.request.param('uid'),
                 csrfToken: ctx.request.csrfToken,
                 step: 'password',
@@ -271,9 +324,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, email, runtimeSettings);
+        const userMethodsForLogin = await this.#userScopedLoginMethods(ctx, cfg, storeEmail, runtimeSettings);
         if (!userMethodsForLogin.authMethods.password) {
-            const found = await cfg.accountStore.findByEmail(email);
+            const found = await cfg.accountStore.findByEmail(storeEmail);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
@@ -302,7 +355,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,
+            email: storeEmail,
             password,
             ip,
             clientId,
@@ -326,7 +379,7 @@ export default class AuthInteractionController {
                     botProtection: undefined,
                 });
             }
-            const found = await cfg.accountStore.findByEmail(email);
+            const found = await cfg.accountStore.findByEmail(storeEmail);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
                 : null;
@@ -407,7 +460,7 @@ export default class AuthInteractionController {
                         clientId,
                         trustedDevice: true,
                     });
-                    ctx.session.forget(SESSION_KEY);
+                    forgetLoginEmail(ctx);
                     return;
                 }
             }
@@ -447,7 +500,7 @@ export default class AuthInteractionController {
             }
         }
         await service.interactions.completeLogin(ctx, acc.id, { remember });
-        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email, ip, clientId });
+        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email: acc.email, ip, clientId });
         // single-session: após o completeLogin, revoga sessões que existiam ANTES.
         // A sessão nova foi criada pelo provider no resume — ela NÃO está em prevSessionIds.
         if (sessionPolicy.singleSession && prevSessionIds.size > 0) {
@@ -467,7 +520,7 @@ export default class AuthInteractionController {
             }
         }
         // Clean up the session key after a successful login.
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
     }
     /**
      * POST /auth/interaction/:uid/mfa
@@ -554,7 +607,7 @@ export default class AuthInteractionController {
         await this.maybeTrustDevice(ctx, cfg, accountId);
         // Finaliza a interaction para o accountId pendente.
         ctx.session.forget(MFA_PENDING_KEY);
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
         await notifyLoginSuccess(ctx, cfg, {
             accountId,
             ip,
@@ -675,7 +728,7 @@ export default class AuthInteractionController {
             return pending;
         if (!cfg.passwordless?.passkeyFirst)
             return undefined;
-        const email = ctx.session.get(SESSION_KEY);
+        const email = lookupEmail(ctx);
         if (!email)
             return undefined;
         const acc = await cfg.accountStore.findByEmail(email);
@@ -696,6 +749,9 @@ 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.
@@ -707,7 +763,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, email)
+            ? await this.#userScopedLoginMethods(ctx, cfg, storeEmail)
             : null;
         if (userScopedMethods && !userScopedMethods.authMethods.magicLink) {
             return render(ctx, 'login', {
@@ -722,23 +778,23 @@ export default class AuthInteractionController {
                 magicChannel: 'none',
             });
         }
-        if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && email) {
+        if (cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore) && storeEmail) {
             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(email, uid, {
+                ? await cfg.accountStore.issueMagicLinkWithCode(storeEmail, uid, {
                     digits: cfg.login.otp.digits,
                     ttlMinutes: cfg.login.otp.ttlMinutes,
                 })
-                : await cfg.accountStore.issueMagicLinkToken(email);
+                : await cfg.accountStore.issueMagicLinkToken(storeEmail);
             if (issued) {
                 const code = 'code' in issued ? issued.code : undefined;
                 await cfg.audit?.record({
                     type: 'login.magic_link_sent',
                     accountId: issued.account.id,
-                    email,
+                    email: issued.account.email,
                     ip,
                     clientId,
                 });
@@ -746,18 +802,19 @@ export default class AuthInteractionController {
                     await cfg.audit?.record({
                         type: 'login.otp_sent',
                         accountId: issued.account.id,
-                        email,
+                        email: issued.account.email,
                         ip,
                         clientId,
                     });
                 }
                 const origin = authkitOrigin(cfg);
                 const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
+                const to = issued.account.email;
                 if (cfg.mail?.onMagicLink) {
-                    await cfg.mail.onMagicLink({ email, magicUrl, token: issued.token, code, channel });
+                    await cfg.mail.onMagicLink({ email: to, magicUrl, token: issued.token, code, channel });
                 }
                 else {
-                    await sendMagicLinkEmail(ctx, { email, magicUrl, code, channel });
+                    await sendMagicLinkEmail(ctx, { email: to, magicUrl, code, channel });
                 }
             }
         }
@@ -766,7 +823,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, email)
+                ? await this.#userScopedLoginMethods(ctx, cfg, storeEmail)
                 : await this.#loginMethods(ctx, cfg)),
             uid,
             csrfToken: ctx.request.csrfToken,
@@ -895,7 +952,7 @@ export default class AuthInteractionController {
             clientId: clientId ?? null,
             metadata: { method: 'magic_link' },
         });
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
         await service.interactions.completeLogin(ctx, acc.id, { amr: ['email'] });
     }
     /**
@@ -916,9 +973,11 @@ 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) {
+        if (!otpEnabled || !email || !storeEmail) {
             return ctx.response.redirect(`/auth/interaction/${uid}`);
         }
         const code = String(ctx.request.input('code', '') ?? '').trim();
@@ -926,14 +985,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(email, uid, code, {
+        const result = await cfg.accountStore.verifyLoginCode(storeEmail, 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, email)),
+            ...(await this.#userScopedLoginMethods(ctx, cfg, storeEmail)),
             uid,
             csrfToken: ctx.request.csrfToken,
             step: 'password',
@@ -1008,18 +1067,18 @@ export default class AuthInteractionController {
                 clientId: clientId ?? null,
                 metadata: { method: 'otp' },
             });
-            ctx.session.forget(SESSION_KEY);
+            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, ip, clientId });
+            await cfg.audit?.record({ type: 'login.otp_invalidated', email: storeEmail, ip, clientId });
             return renderOtpError('login.otp_locked');
         }
         if (result.status === 'expired') {
             await cfg.audit?.record({
                 type: 'login.otp_failed',
-                email,
+                email: storeEmail,
                 ip,
                 clientId,
                 metadata: { reason: 'expired' },
@@ -1029,7 +1088,7 @@ export default class AuthInteractionController {
         // 'invalid' (tentativa contabilizada) ou 'no_code'.
         await cfg.audit?.record({
             type: 'login.otp_failed',
-            email,
+            email: storeEmail,
             ip,
             clientId,
             metadata: { reason: result.status },
@@ -1252,7 +1311,7 @@ export default class AuthInteractionController {
         // Passkey OK: opcionalmente confia neste dispositivo (checkbox no challenge).
         await this.maybeTrustDevice(ctx, cfg, accountId);
         ctx.session.forget(MFA_PENDING_KEY);
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
         await notifyLoginSuccess(ctx, cfg, {
             accountId,
             ip,
@@ -1268,7 +1327,7 @@ export default class AuthInteractionController {
      * Clears the stored email and redirects back to step 1.
      */
     async switchIdentifier(ctx) {
-        ctx.session.forget(SESSION_KEY);
+        forgetLoginEmail(ctx);
         return ctx.response.redirect(`/auth/interaction/${ctx.request.param('uid')}`);
     }
     /**

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

@@ -5,6 +5,7 @@ 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';
@@ -118,7 +119,13 @@ export default class AuthRegistrationController {
         }
         const data = await ctx.request.validateUsing(signupValidator);
         const accountStore = cfg.accountStore;
-        const existing = await accountStore.findByEmail(data.email);
+        // 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;
         if (existing) {
             return render(ctx, 'signup', {
                 uid: ctx.request.param('uid'),
@@ -217,7 +224,10 @@ 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).
-        const existing = await accountStore.findByEmail(data.email);
+        // 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;
         if (!existing) {
             const created = await accountStore.create({
                 email: data.email,
@@ -233,15 +243,19 @@ export default class AuthRegistrationController {
             });
         }
         // Emite + envia o magic link (mesma construção do login por magic link).
-        const issued = await accountStore.issueMagicLinkToken(data.email);
+        // 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);
         if (issued) {
             const origin = authkitOrigin(cfg);
             const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
+            const to = issued.account.email;
             if (cfg.mail?.onMagicLink) {
-                await cfg.mail.onMagicLink({ email: data.email, magicUrl, token: issued.token });
+                await cfg.mail.onMagicLink({ email: to, magicUrl, token: issued.token });
             }
             else {
-                await sendMagicLinkEmail(ctx, { email: data.email, magicUrl });
+                await sendMagicLinkEmail(ctx, { email: to, magicUrl });
             }
         }
         // Resposta uniforme: "enviamos um link" (não vaza existência da conta).
@@ -322,21 +336,33 @@ export default class AuthRegistrationController {
         }
         const { email } = await ctx.request.validateUsing(forgotPasswordValidator);
         const accountStore = cfg.accountStore;
-        const result = await accountStore.issuePasswordResetToken(email);
+        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);
+            }
+        }
         if (result) {
             await cfg.audit?.record({
                 type: 'password_reset.issued',
-                email,
+                email: result.account.email,
                 ip: ctx.request.ip?.() ?? null,
             });
             const origin = authkitOrigin(cfg);
             const url = `${origin}/auth/reset-password?token=${result.token}`;
             // Hook do config tem prioridade (override); senão usa o mailer default do host.
+            // O link vai para a caixa postal sob a qual a conta está gravada.
+            const to = result.account.email;
             if (cfg.mail?.onPasswordReset) {
-                await cfg.mail.onPasswordReset({ email, resetUrl: url, token: result.token });
+                await cfg.mail.onPasswordReset({ email: to, resetUrl: url, token: result.token });
             }
             else {
-                await sendPasswordResetEmail(ctx, { email, resetUrl: url });
+                await sendPasswordResetEmail(ctx, { email: to, resetUrl: url });
             }
         }
         return render(ctx, 'forgot', {

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

@@ -1,6 +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 { assertLoginAllowed } from '../login_attempt.js';
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods } from '../runtime_toggles.js';
@@ -54,7 +55,10 @@ export default class AuthSocialController {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const store = cfg.accountStore;
-        const email = profile.email ?? undefined;
+        // Normaliza o e-mail do provider com a MESMA regra do cadastro/login: sem
+        // isto, um provider que devolve o endereço com maiúsculas criava uma conta
+        // que o login (normalizado) não encontrava mais.
+        const email = profile.email ? normalizeEmailIdentifier(profile.email) : undefined;
         // Account linking exige a capacidade de provider-identity (model wired no store).
         // Ausente → não há como ligar a identidade; volta ao login em vez de quebrar.
         if (!supportsProviderIdentity(store)) {
@@ -67,7 +71,12 @@ 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) {
-            const byEmail = await store.findByEmail(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;
             if (byEmail) {
                 await store.linkProviderIdentity({
                     accountId: byEmail.id,

package/build/src/host/email_identifier.d.ts

@@ -0,0 +1,92 @@
+import type { AuthAccount } from '../accounts/account_store.js';
+/**
+ * Normalização ÚNICA e CONSERVADORA do e-mail usado como identidade da conta.
+ *
+ * Faz `trim()` + `toLowerCase()` e MAIS NADA. O endereço que a pessoa digitou é a
+ * identidade dela: a lib NÃO decide que `a.b@gmail.com` e `ab@gmail.com` são a
+ * mesma pessoa, nem descarta o sub-endereço (`+tag`) que ela escolheu usar.
+ *
+ * POR QUE ISTO EXISTE: até a v0.68 o cadastro validava o e-mail com
+ * `.normalizeEmail()` do VineJS (os defaults do validator.js), que para o gmail
+ * REMOVE os pontos e o `+tag` do local part. A conta nascia com um endereço
+ * DIFERENTE do digitado (`davi.carvalho96@gmail.com` → `davicarvalho96@gmail.com`)
+ * enquanto o passo de identificador do login não normalizava NADA e buscava por
+ * igualdade exata — resultado: quem tinha ponto ou `+tag` no gmail ficava
+ * trancado do lado de fora, e, por o login ser à prova de enumeração, sem
+ * nenhuma mensagem de erro. Uma normalização só, usada nos DOIS lados, fecha a
+ * assimetria.
+ *
+ * Use em TODO ponto que grava ou busca a identidade: cadastro (com e sem senha),
+ * "esqueci a senha", troca de e-mail, criação por admin, convite de organização,
+ * import de usuários, cadastro social e o passo de identificador do login.
+ */
+export declare function normalizeEmailIdentifier(raw: unknown): string;
+/**
+ * Réplica da normalização LEGADA — `normalizeEmail()` do validator.js com os
+ * defaults, que é o que o `.normalizeEmail()` do VineJS aplicava no cadastro até
+ * a v0.68. Existe SÓ para reencontrar as contas que nasceram com o endereço
+ * mutilado; nada novo deve ser gravado com ela.
+ *
+ * É uma PONTE TEMPORÁRIA: quando as contas antigas tiverem sido migradas para o
+ * endereço real (ou o suficiente delas), esta função, a opção
+ * `login.legacyEmailFallback` e {@link resolveEmailIdentifier} podem sair.
+ *
+ * Retorna `null` para entradas que o validator.js também recusaria (local part
+ * vazio depois do colapso) ou que não são um endereço com `@`.
+ */
+export declare function legacyNormalizeEmailIdentifier(raw: unknown): string | null;
+/** Só o que {@link resolveEmailIdentifier} precisa do account store. */
+export interface EmailIdentifierLookup {
+    findByEmail(email: string): Promise<AuthAccount | null>;
+}
+export interface ResolvedEmailIdentifier {
+    /** O que a pessoa digitou, normalizado. É o que a tela SEMPRE mostra. */
+    email: string;
+    /**
+     * E-mail sob o qual a conta está GRAVADA — o que deve ir para o store em
+     * qualquer busca/emissão de token. Igual a {@link email} quando a conta foi
+     * achada direto (ou quando não foi achada nenhuma).
+     */
+    lookupEmail: string;
+    /** A conta, quando alguma foi encontrada. */
+    account: AuthAccount | null;
+    /** `true` quando a conta só foi alcançada pela ponte legada. */
+    viaLegacyFallback: boolean;
+}
+/**
+ * Resolve o e-mail digitado na conta correspondente.
+ *
+ * Passe o valor **CRU** (como veio do formulário, do provider ou do arquivo): a
+ * normalização acontece aqui dentro, e a forma crua é uma das candidatas da
+ * ponte. Passar um valor já normalizado apaga essa candidata e reduz o alcance
+ * da ponte às contas gravadas com o endereço mutilado.
+ *
+ * 1. Busca pela forma normalizada NOVA (trim + lowercase) — o caminho de sempre,
+ *    uma única query por igualdade (indexada).
+ * 2. Não achando, e com a ponte ligada (`login.legacyEmailFallback`, default
+ *    `true`), tenta as formas de compatibilidade:
+ *    - o endereço EXATAMENTE como digitado (só com `trim`), para as contas que
+ *      foram gravadas com maiúsculas antes desta normalização existir (import,
+ *      convite, criação por admin, provider social);
+ *    - a {@link legacyNormalizeEmailIdentifier normalização legada}, para as
+ *      contas que nasceram com o endereço mutilado.
+ *    O resultado só é aceito quando as formas de compatibilidade apontam para
+ *    EXATAMENTE UMA conta. Duas contas distintas (ex.: `Davi.C@Gmail.com` criada
+ *    pelo social E `davic@gmail.com` criada pelo cadastro legado) são um empate:
+ *    a lib não adivinha qual é a pessoa e trata como "não achei".
+ *
+ * LIMITE CONHECIDO: a ponte só alcança grafias que dá para derivar do que foi
+ * digitado. Uma conta gravada `Davi@Acme.com` é alcançada por quem digita
+ * `Davi@Acme.com` (a forma crua), mas NÃO por quem digita `davi@acme.com` — aí as
+ * três formas coincidem e só uma busca case-insensitive no store resolveria, o
+ * que exigiria varrer a tabela a cada login com e-mail desconhecido (justamente o
+ * caminho de ataque). Essas contas pedem migração do endereço gravado, não ponte.
+ *
+ * À PROVA DE ENUMERAÇÃO: nunca lança, nunca sinaliza nada para fora — quem chama
+ * segue com `account: null` exatamente como seguia antes. As buscas extras só
+ * acontecem quando as formas de compatibilidade DIFEREM da normalizada (e-mail
+ * digitado em minúsculas e sem ponto/tag → uma query só, como hoje).
+ */
+export declare function resolveEmailIdentifier(store: EmailIdentifierLookup, raw: unknown, options?: {
+    legacyFallback?: boolean;
+}): Promise<ResolvedEmailIdentifier>;