@adonis-agora/authkit-server 0.86.0 → 0.88.0

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

@@ -18,6 +18,7 @@ import { authkitOrigin } from '../origin.js';
 import { createOtpLockout, generateOtpUnlockToken, rawToDbOtpUnlockToken, resolveEffectiveOtpLockout, } from '../otp_lockout.js';
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods, resolveEffectiveMaintenanceMode, resolveEffectiveRegistration, resolveEffectiveSessionPolicy, } from '../runtime_toggles.js';
+import { LOGIN_EMAIL_SESSION_KEY, pendingSignupCode, verifySignupCode } from '../signup_code.js';
 import { SOCIAL_PENDING_KEY, SOCIAL_PENDING_TTL_MS, } from '../social_pending.js';
 import { buildTrustedDevicePayload, isTrustedDeviceValid, TRUSTED_DEVICE_COOKIE, } from '../trusted_device.js';
 import { normalizeUserLoginMethods, resolveEffectiveUserLoginMethods, } from '../user_login_methods.js';
@@ -58,7 +59,7 @@ function accountStatusErrorKey(reason) {
  * `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';
+const SESSION_KEY = LOGIN_EMAIL_SESSION_KEY;
 /** accountId aguardando o 2º fator depois da senha verificada. */
 const MFA_PENDING_KEY = 'authkit_mfa_pending';
 /**
@@ -1397,13 +1398,11 @@ export default class AuthInteractionController {
             return ctx.response.redirect(`/auth/interaction/${uid}`);
         }
         const code = String(ctx.request.input('code', '') ?? '').trim();
+        const pendingSignup = pendingSignupCode(ctx, uid, email);
         const brand = brandFor(cfg.branding, clientId ?? undefined, undefined);
         // 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, {
-            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).
@@ -1419,6 +1418,35 @@ export default class AuthInteractionController {
             magicChannel: magicChannelProp(channel),
             otpError: translate(cfg.messages, messageKey),
         });
+        // Cadastro sem conta ainda: o código certo leva ao mesmo link de confirmação do e-mail.
+        if (pendingSignup) {
+            const signupResult = verifySignupCode(ctx, pendingSignup, code, cfg.login.otp.maxAttempts);
+            if (signupResult === 'ok') {
+                forgetLoginEmail(ctx);
+                const confirmUrl = `/auth/interaction/${uid}/signup/confirm?token=${encodeURIComponent(pendingSignup.token)}`;
+                return ctx.response.redirect().status(303).toPath(confirmUrl);
+            }
+            const signupAudit = {
+                email,
+                ip,
+                clientId,
+                metadata: { stage: 'signup', reason: signupResult },
+            };
+            if (signupResult === 'locked') {
+                await cfg.audit?.record({ type: 'login.otp_invalidated', ...signupAudit });
+            }
+            else {
+                await cfg.audit?.record({ type: 'login.otp_failed', ...signupAudit });
+            }
+            return renderOtpError(signupResult === 'locked'
+                ? 'login.otp_locked'
+                : signupResult === 'expired'
+                    ? 'login.otp_expired'
+                    : 'login.otp_invalid');
+        }
+        const result = await cfg.accountStore.verifyLoginCode(email, uid, code, {
+            maxAttempts: cfg.login.otp.maxAttempts,
+        });
         if (result.status === 'ok') {
             // E-mail não verificado (LGPD): mesmo com código válido, não materializa a
             // sessão se a política exige verificação. Espelha o magicLinkConsume.

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

@@ -2,8 +2,8 @@ import '../augmentations.js';
 import type { HttpContext } from '@adonisjs/core/http';
 /**
  * Telas do usuário no Poppy: o consentimento do Direct Sign-In (o
- * `authorization_endpoint`, §4.5) e a do Device Sign-In (o `verification_uri`,
- * §4.6). Montadas atrás do `accountGuard`: sem sessão, o usuário passa pelo login
+ * `authorization_endpoint`, §4.2) e a do Device Sign-In (o `verification_uri`,
+ * §4.3). Montadas atrás do `accountGuard`: sem sessão, o usuário passa pelo login
  * DESTE app e volta. Abrir o link nunca aprova sozinho — a aprovação é um POST
  * com CSRF. Recusadas durante impersonation.
  */

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

@@ -14,8 +14,8 @@ function chosenScopes(ctx) {
 }
 /**
  * Telas do usuário no Poppy: o consentimento do Direct Sign-In (o
- * `authorization_endpoint`, §4.5) e a do Device Sign-In (o `verification_uri`,
- * §4.6). Montadas atrás do `accountGuard`: sem sessão, o usuário passa pelo login
+ * `authorization_endpoint`, §4.2) e a do Device Sign-In (o `verification_uri`,
+ * §4.3). Montadas atrás do `accountGuard`: sem sessão, o usuário passa pelo login
  * DESTE app e volta. Abrir o link nunca aprova sozinho — a aprovação é um POST
  * com CSRF. Recusadas durante impersonation.
  */

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

@@ -1,25 +1,33 @@
 import type { HttpContext } from '@adonisjs/core/http';
 /**
- * Endpoints server-to-server do Poppy (§3, §4): descoberta, metadata RFC 8414,
- * token, revogação, device authorization, Mediated Sign-In e a sessão de
- * navegador (§5). Todos isentos de CSRF — ver `authkitCsrfExceptions`.
+ * Endpoints do Poppy (§3, §4, §6): descoberta, protected resource metadata, metadata RFC 8414,
+ * token, revogação, device authorization e a entrada do navegador na Session. Os POSTs são isentos
+ * de CSRF — ver `authkitCsrfExceptions`.
  */
 export default class PoppyController {
-    /** `GET /.well-known/poppy.json` — só no domínio da empresa (ignorando `www.`). */
+    /** `GET /.well-known/poppy.json` — só no domínio da empresa; `www.` redireciona para ele. */
     discovery(ctx: HttpContext): Promise<void>;
-    /** `GET /.well-known/oauth-authorization-server{prefix}` (RFC 8414 + `poppy_domains`). */
+    /** `GET /.well-known/oauth-protected-resource` do domínio (§3.2, RFC 9728). */
+    protectedResource(ctx: HttpContext): Promise<void>;
+    /** `GET /.well-known/oauth-authorization-server{prefix}` (RFC 8414 + `protected_resources`). */
     metadata(ctx: HttpContext): Promise<void>;
     token(ctx: HttpContext): Promise<void>;
     deviceAuthorization(ctx: HttpContext): Promise<void>;
     /** RFC 7009: 200 também para token desconhecido. */
     revoke(ctx: HttpContext): Promise<void>;
-    /** `POST auth.mediated.endpoint` (§4.7) — com o Session Token (DPoP). */
-    mediatedStart(ctx: HttpContext): Promise<void>;
-    /** `POST {mediated}/{sign_in_id}` (§4.7). */
-    mediatedCode(ctx: HttpContext): Promise<void>;
     /**
-     * `POST web.browser_session_endpoint` (§5): asserção no corpo → cookie do app
-     * para a Session e 303 para `return_to`; qualquer falha → 400, sem cookie.
+     * `GET web.browser_session_endpoint` (§6, passo 1): a página com o código de uso único e o cookie
+     * que o prende a este navegador. Não mexe em Session nem nos outros cookies.
+     */
+    browserSessionPage(ctx: HttpContext): Promise<void>;
+    /**
+     * `POST {browser_session_endpoint}/authorize` (§6, passo 2): o agente autoriza o código, com o
+     * header da Session e, se logado, o access token. 204; código inválido → 400 `invalid_request`.
+     */
+    browserSessionAuthorize(ctx: HttpContext): Promise<void>;
+    /**
+     * `POST web.browser_session_endpoint` (§6, passo 3): o navegador submete o código → cookie do app
+     * para a Session, limpa o cookie do passo 1 e redireciona para o site; falha → página de erro.
      */
     browserSession(ctx: HttpContext): Promise<void>;
 }

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

@@ -1,5 +1,5 @@
 import { PoppyError } from '../../agents/poppy/errors.js';
-import { publicRequestUrl, writePoppyAuthError } from '../../agents/poppy/resource.js';
+import { publicRequestUrl, writePoppyAuthError, } from '../../agents/poppy/resource.js';
 import { loginPoppyBrowser } from '../../agents/poppy/web_session.js';
 import { personalAgentsFor } from '../../agents/runtime.js';
 function noStore(ctx) {
@@ -15,6 +15,9 @@ function oauthError(ctx, error) {
     noStore(ctx);
     for (const [k, v] of Object.entries(error.headers))
         ctx.response.header(k, v);
+    // Limite de taxa: 429 com `Retry-After`, sem corpo próprio (§5.6).
+    if (error.status === 429)
+        return ctx.response.status(429).send('');
     if (error.code === 'invalid_dpop_proof' || error.code === 'use_dpop_nonce') {
         ctx.response.header('WWW-Authenticate', `DPoP error="${error.code}"`);
     }
@@ -31,25 +34,43 @@ function form(ctx) {
     return ctx.request.all();
 }
 /**
- * Endpoints server-to-server do Poppy (§3, §4): descoberta, metadata RFC 8414,
- * token, revogação, device authorization, Mediated Sign-In e a sessão de
- * navegador (§5). Todos isentos de CSRF — ver `authkitCsrfExceptions`.
+ * Endpoints do Poppy (§3, §4, §6): descoberta, protected resource metadata, metadata RFC 8414,
+ * token, revogação, device authorization e a entrada do navegador na Session. Os POSTs são isentos
+ * de CSRF — ver `authkitCsrfExceptions`.
  */
 export default class PoppyController {
-    /** `GET /.well-known/poppy.json` — só no domínio da empresa (ignorando `www.`). */
+    /** `GET /.well-known/poppy.json` — só no domínio da empresa; `www.` redireciona para ele. */
     async discovery(ctx) {
         const poppy = await poppyOr404(ctx);
         if (!poppy)
             return;
         // `host()` mantém a porta (dev em `localhost:3333`): o `browser_session_endpoint` sai dele.
-        const doc = poppy.discoveryDocument(ctx.request.host() ?? ctx.request.hostname() ?? '');
+        const host = ctx.request.host() ?? ctx.request.hostname() ?? '';
+        const redirect = poppy.discoveryRedirect(host);
+        if (redirect) {
+            ctx.response.header('Location', redirect);
+            return ctx.response.status(308).send('');
+        }
+        const doc = poppy.discoveryDocument(host);
         if (!doc)
             return ctx.response.notFound();
         ctx.response.header('Access-Control-Allow-Origin', '*');
         ctx.response.header('Cache-Control', 'public, max-age=300');
         return ctx.response.json(doc);
     }
-    /** `GET /.well-known/oauth-authorization-server{prefix}` (RFC 8414 + `poppy_domains`). */
+    /** `GET /.well-known/oauth-protected-resource` do domínio (§3.2, RFC 9728). */
+    async protectedResource(ctx) {
+        const poppy = await poppyOr404(ctx);
+        if (!poppy)
+            return;
+        const doc = poppy.protectedResourceMetadata(ctx.request.host() ?? ctx.request.hostname() ?? '');
+        if (!doc)
+            return ctx.response.notFound();
+        ctx.response.header('Access-Control-Allow-Origin', '*');
+        ctx.response.header('Cache-Control', 'public, max-age=300');
+        return ctx.response.json(doc);
+    }
+    /** `GET /.well-known/oauth-authorization-server{prefix}` (RFC 8414 + `protected_resources`). */
     async metadata(ctx) {
         const poppy = await poppyOr404(ctx);
         if (!poppy)
@@ -64,7 +85,7 @@ export default class PoppyController {
             return;
         withNonce(ctx, poppy);
         try {
-            const body = await poppy.token(form(ctx), ctx.request.header('dpop'));
+            const body = await poppy.token(form(ctx), ctx.request.header('dpop'), ctx);
             noStore(ctx);
             return ctx.response.json(body);
         }
@@ -105,89 +126,93 @@ export default class PoppyController {
             throw error;
         }
     }
-    /** `POST auth.mediated.endpoint` (§4.7) — com o Session Token (DPoP). */
-    async mediatedStart(ctx) {
+    /**
+     * `GET web.browser_session_endpoint` (§6, passo 1): a página com o código de uso único e o cookie
+     * que o prende a este navegador. Não mexe em Session nem nos outros cookies.
+     */
+    async browserSessionPage(ctx) {
         const poppy = await poppyOr404(ctx);
-        if (!poppy?.cfg.signIn.mediated)
+        if (!poppy?.cfg.web?.browserSession)
             return poppy ? ctx.response.notFound() : undefined;
-        const auth = await poppy.verifyAccess({
-            method: ctx.request.method(),
-            url: publicRequestUrl(ctx, poppy),
-            headers: ctx.request.headers(),
-        });
-        if (!auth.ok) {
-            const { ok: _ok, ...rest } = auth;
-            return writePoppyAuthError(ctx, { ok: false, ...rest });
-        }
-        try {
-            const body = await poppy.mediatedStart(auth.principal, auth.jkt, ctx.request.body(), ctx);
-            noStore(ctx);
-            return ctx.response.json(body);
-        }
-        catch (error) {
-            if (error instanceof PoppyError)
-                return oauthError(ctx, error);
-            throw error;
-        }
+        const { code, cookie, maxAge } = await poppy.startBrowserJoin();
+        const name = joinCookieName(poppy);
+        ctx.response.append('Set-Cookie', `${name}=${cookie}; Path=/; Max-Age=${maxAge}; ${cookieSecure(poppy)}HttpOnly; SameSite=Strict`);
+        browserHeaders(ctx);
+        // `code` só tem caracteres base64url; o `action` é o path do próprio endpoint.
+        const action = new URL(poppy.urls.browserSession).pathname;
+        return ctx.response
+            .status(200)
+            .send(`<!doctype html><html><head><meta charset="utf-8"><title>Connecting</title></head><body><form method="post" action="${action}"><input type="hidden" name="code" value="${code}"><button>Continue</button></form></body></html>`);
     }
-    /** `POST {mediated}/{sign_in_id}` (§4.7). */
-    async mediatedCode(ctx) {
+    /**
+     * `POST {browser_session_endpoint}/authorize` (§6, passo 2): o agente autoriza o código, com o
+     * header da Session e, se logado, o access token. 204; código inválido → 400 `invalid_request`.
+     */
+    async browserSessionAuthorize(ctx) {
         const poppy = await poppyOr404(ctx);
-        if (!poppy?.cfg.signIn.mediated)
+        if (!poppy?.cfg.web?.browserSession)
             return poppy ? ctx.response.notFound() : undefined;
-        const auth = await poppy.verifyAccess({
-            method: ctx.request.method(),
-            url: publicRequestUrl(ctx, poppy),
-            headers: ctx.request.headers(),
-        });
-        if (!auth.ok) {
-            const { ok: _ok, ...rest } = auth;
-            return writePoppyAuthError(ctx, { ok: false, ...rest });
-        }
+        noStore(ctx);
         try {
-            const body = await poppy.mediatedCode(auth.principal, auth.jkt, String(ctx.request.param('id') ?? ''), ctx.request.body());
-            noStore(ctx);
-            if (!body) {
-                return ctx.response
-                    .status(404)
-                    .json({ error: 'invalid_request', error_description: 'Unknown sign_in_id' });
-            }
-            return ctx.response.json(body);
+            const result = await poppy.authorizeBrowserJoin({
+                method: ctx.request.method(),
+                url: publicRequestUrl(ctx, poppy),
+                headers: ctx.request.headers(),
+            }, ctx.request.body()?.code);
+            if (!result.ok)
+                return writePoppyAuthError(ctx, result);
+            return ctx.response.status(204).send('');
         }
         catch (error) {
-            if (error instanceof PoppyError)
-                return oauthError(ctx, error);
+            if (error instanceof PoppyError) {
+                return ctx.response.status(400).json({ error: 'invalid_request' });
+            }
             throw error;
         }
     }
     /**
-     * `POST web.browser_session_endpoint` (§5): asserção no corpo → cookie do app
-     * para a Session e 303 para `return_to`; qualquer falha → 400, sem cookie.
+     * `POST web.browser_session_endpoint` (§6, passo 3): o navegador submete o código → cookie do app
+     * para a Session, limpa o cookie do passo 1 e redireciona para o site; falha → página de erro.
      */
     async browserSession(ctx) {
         const poppy = await poppyOr404(ctx);
         if (!poppy?.cfg.web?.browserSession)
             return poppy ? ctx.response.notFound() : undefined;
-        noStore(ctx);
-        // A asserção vai NO CORPO, nunca na URL (§5).
-        if (ctx.request.qs().assertion !== undefined)
+        browserHeaders(ctx);
+        const name = joinCookieName(poppy);
+        const result = await poppy.completeBrowserJoin(ctx.request.input('code'), readCookie(ctx.request.header('cookie'), name));
+        if (!result)
             return badBrowserRequest(ctx);
-        let result;
-        try {
-            result = await poppy.verifyBrowserAssertion(ctx.request.input('assertion'), new URL(publicRequestUrl(ctx, poppy)).origin);
-        }
-        catch (error) {
-            if (error instanceof PoppyError)
-                return badBrowserRequest(ctx);
-            throw error;
-        }
         await loginPoppyBrowser(ctx, result);
-        ctx.response.header('Location', result.returnTo);
+        ctx.response.append('Set-Cookie', `${name}=; Path=/; Max-Age=0; ${cookieSecure(poppy)}HttpOnly; SameSite=Strict`);
+        ctx.response.header('Location', poppy.cfg.web.redirectTo);
         return ctx.response.status(303).send('');
     }
 }
-function badBrowserRequest(ctx) {
+/** `__Host-` exige `Secure`; em dev com o issuer em http o cookie sai sem os dois. */
+function joinCookieName(poppy) {
+    return new URL(poppy.urls.origin).protocol === 'https:' ? '__Host-poppy_join' : 'poppy_join';
+}
+function cookieSecure(poppy) {
+    return new URL(poppy.urls.origin).protocol === 'https:' ? 'Secure; ' : '';
+}
+function readCookie(header, name) {
+    for (const part of (header ?? '').split(';')) {
+        const eq = part.indexOf('=');
+        if (eq > 0 && part.slice(0, eq).trim() === name)
+            return part.slice(eq + 1).trim();
+    }
+    return undefined;
+}
+/** Sem cache, sem moldura e sem referência da página que abriu (§6, passo 1). */
+function browserHeaders(ctx) {
+    noStore(ctx);
     ctx.response.header('Content-Type', 'text/html; charset=utf-8');
+    ctx.response.header('Content-Security-Policy', "frame-ancestors 'none'");
+    ctx.response.header('Cross-Origin-Opener-Policy', 'same-origin');
+    ctx.response.header('Referrer-Policy', 'no-referrer');
+}
+function badBrowserRequest(ctx) {
     return ctx.response
         .status(400)
         .send('<!doctype html><html><head><meta charset="utf-8"><title>Bad request</title></head><body><h1>Invalid browser session request</h1></body></html>');

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

@@ -1,6 +1,6 @@
 import '../augmentations.js';
 import { randomBytes } from 'node:crypto';
-import { supportsAccountDeletion, supportsMagicLink } from '../../accounts/account_store.js';
+import { supportsAccountDeletion, supportsMagicLink, supportsOtpLogin, } from '../../accounts/account_store.js';
 import { PasswordPolicyError } from '../../password/password_manager.js';
 import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
@@ -12,6 +12,7 @@ import { authkitOrigin } from '../origin.js';
 import { RuntimeSettings, resolveRuntimeSettings } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods, resolveEffectiveMaintenanceMode, resolveEffectiveRegistration, } from '../runtime_toggles.js';
 import { dispatchSecurityNotice } from '../security_notice_service.js';
+import { LOGIN_EMAIL_SESSION_KEY, SIGNUP_CODE_SESSION_KEY, startSignupCode, } from '../signup_code.js';
 import { issueSignupToken, readSignupToken } from '../signup_token.js';
 import { forgotPasswordValidator, passwordlessSignupValidator, resetPasswordValidator, signupValidator, } from '../validators.js';
 /**
@@ -221,7 +222,8 @@ export default class AuthRegistrationController {
      * Cadastro passwordless: valida e-mail + nome e envia um link. Conta existente
      * recebe um magic link de login; e-mail novo recebe o link de confirmação do
      * cadastro (`signupConfirm`), e só então a conta é criada. Sempre responde
-     * "link enviado" (anti-enumeração), exista a conta ou não.
+     * "link enviado" (anti-enumeração), exista a conta ou não. Com `login.otp` ligado,
+     * os dois casos também levam um código de digitar (`otpVerify`).
      */
     async #passwordlessSignup(ctx, deps) {
         const { cfg, brand } = deps;
@@ -230,19 +232,30 @@ export default class AuthRegistrationController {
         const uid = ctx.request.param('uid');
         const data = await ctx.request.validateUsing(passwordlessSignupValidator);
         const origin = authkitOrigin(cfg);
+        // Com OTP ligado, o e-mail leva também um código, para concluir neste navegador.
+        const otpEnabled = cfg.login?.otp?.enabled === true && supportsOtpLogin(accountStore);
         const existing = await accountStore.findByEmail(data.email);
+        ctx.session.forget(SIGNUP_CODE_SESSION_KEY);
+        if (otpEnabled)
+            ctx.session.put(LOGIN_EMAIL_SESSION_KEY, data.email);
         if (existing) {
             // Conta já existe: o "cadastro" vira um login por magic link.
             // `data.email` já é a forma normalizada, a mesma do login.
-            const issued = await accountStore.issueMagicLinkToken(data.email);
+            const issued = otpEnabled
+                ? await accountStore.issueMagicLinkWithCode(data.email, uid, {
+                    digits: cfg.login.otp.digits,
+                    ttlMinutes: cfg.login.otp.ttlMinutes,
+                })
+                : await accountStore.issueMagicLinkToken(data.email);
             if (issued) {
+                const code = 'code' in issued ? issued.code : undefined;
                 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: to, magicUrl, token: issued.token });
+                    await cfg.mail.onMagicLink({ email: to, magicUrl, token: issued.token, code });
                 }
                 else {
-                    await sendMagicLinkEmail(ctx, { email: to, magicUrl });
+                    await sendMagicLinkEmail(ctx, { email: to, magicUrl, code });
                 }
             }
         }
@@ -253,11 +266,20 @@ export default class AuthRegistrationController {
             // e-mail de outra pessoa não cria nada.
             const token = await issueSignupToken({ email: data.email, fullName: data.fullName ?? null });
             const magicUrl = `${origin}/auth/interaction/${uid}/signup/confirm?token=${encodeURIComponent(token)}`;
+            const code = otpEnabled
+                ? startSignupCode(ctx, {
+                    uid,
+                    email: data.email,
+                    token,
+                    digits: cfg.login.otp.digits,
+                    ttlMinutes: cfg.login.otp.ttlMinutes,
+                })
+                : undefined;
             if (cfg.mail?.onMagicLink) {
-                await cfg.mail.onMagicLink({ email: data.email, magicUrl, token, kind: 'signup' });
+                await cfg.mail.onMagicLink({ email: data.email, magicUrl, token, code, kind: 'signup' });
             }
             else {
-                await sendMagicLinkEmail(ctx, { email: data.email, magicUrl });
+                await sendMagicLinkEmail(ctx, { email: data.email, magicUrl, code });
             }
         }
         // Resposta uniforme: "enviamos um link" (não vaza existência da conta).
@@ -266,6 +288,7 @@ export default class AuthRegistrationController {
             csrfToken: ctx.request.csrfToken,
             brand,
             magicLinkSent: true,
+            otpEnabled,
         });
     }
     /**

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

@@ -11,10 +11,8 @@ export interface AuthkitCsrfOptions {
      */
     personalAgentsPrefix?: string | false;
     /**
-     * Prefixo do Poppy: isenta token/revoke/device authorization, o Mediated
-     * Sign-In e a sessão de navegador (POST cross-site autenticado pela asserção).
-     * Default: o do config. As telas `{prefix}/oauth/authorize` e `{prefix}/device`
-     * continuam protegidas. `false` desliga.
+     * Prefixo do Poppy: isenta token/revoke/device authorization e a entrada do navegador
+     * (o código com o cookie `SameSite=Strict` é o que protege, §6).
      */
     poppyPrefix?: string | false;
 }

package/build/src/host/csrf.js

@@ -44,9 +44,8 @@ export function authkitCsrfExceptions(url, options = {}) {
         (path === `${poppyPrefix}/oauth/token` ||
             path === `${poppyPrefix}/oauth/revoke` ||
             path === `${poppyPrefix}/oauth/device` ||
-            path === `${poppyPrefix}/sign-in` ||
-            path.startsWith(`${poppyPrefix}/sign-in/`) ||
-            path === `${poppyPrefix}/browser-session`);
+            path === `${poppyPrefix}/browser-session` ||
+            path === `${poppyPrefix}/browser-session/authorize`);
     return (url.includes(mountPath) ||
         url.includes('/authkit/pat') ||
         (backchannel !== null && url === backchannel) ||

package/build/src/host/register_auth_host.js

@@ -573,6 +573,9 @@ export function registerAuthHost(router, opts = {}) {
         // Nomes explícitos: o Router nomeia pela dupla controller.método, e as duas URLs da metadata
         // (RFC 8414 na raiz e debaixo do issuer) usam o mesmo — "poppy.metadata already exists" no boot.
         router.get('/.well-known/poppy.json', [C.poppy, 'discovery']).as('authkit.poppy.discovery');
+        router
+            .get('/.well-known/oauth-protected-resource', [C.poppy, 'protectedResource'])
+            .as('authkit.poppy.protected_resource');
         router
             .get(`/.well-known/oauth-authorization-server${poppyPrefix}`, [C.poppy, 'metadata'])
             .as('authkit.poppy.metadata');
@@ -584,14 +587,16 @@ export function registerAuthHost(router, opts = {}) {
         router
             .post(`${poppyPrefix}/oauth/device`, [C.poppy, 'deviceAuthorization'])
             .as('authkit.poppy.device_authorization');
-        // Credenciais e códigos de uso único: throttle por IP (§4.7 exige rate limit).
-        withLogin(router.post(`${poppyPrefix}/sign-in`, [C.poppy, 'mediatedStart']).as('authkit.poppy.sign_in'));
-        withOtpLogin(router
-            .post(`${poppyPrefix}/sign-in/:id`, [C.poppy, 'mediatedCode'])
-            .as('authkit.poppy.sign_in_code'));
+        // A página grava um pedido sem autenticação: throttle por IP.
+        withLogin(router
+            .get(`${poppyPrefix}/browser-session`, [C.poppy, 'browserSessionPage'])
+            .as('authkit.poppy.browser_session_page'));
         router
             .post(`${poppyPrefix}/browser-session`, [C.poppy, 'browserSession'])
             .as('authkit.poppy.browser_session');
+        router
+            .post(`${poppyPrefix}/browser-session/authorize`, [C.poppy, 'browserSessionAuthorize'])
+            .as('authkit.poppy.browser_session_authorize');
         router
             .group(() => {
             router

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

@@ -0,0 +1,41 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Código digitado do cadastro passwordless.
+ *
+ * Quem abre o link do e-mail noutro navegador termina logado longe de onde começou (um convite
+ * aberto dentro do WhatsApp, por exemplo). Com o código, a pessoa conclui no mesmo navegador e na
+ * mesma interaction. A conta ainda não existe, então não há slot no store: o pendente fica na sessão
+ * deste navegador, e o código correto só libera o mesmo link de confirmação que foi por e-mail.
+ *
+ * As tentativas ficam na sessão. Num driver de cookie dá para repetir um cookie antigo e zerá-las,
+ * e o limite que sobra é o throttle da rota `otp-verify`.
+ */
+export declare const SIGNUP_CODE_SESSION_KEY = "authkit_signup_code";
+/** Onde o login guarda o e-mail da interaction: é o que o `otp-verify` lê. */
+export declare const LOGIN_EMAIL_SESSION_KEY = "authkit_login_email";
+export interface PendingSignupCode {
+    uid: string;
+    email: string;
+    /** O token do link de confirmação (já cifrado). */
+    token: string;
+    codeHash: string;
+    /** Epoch em ms. */
+    expiresAt: number;
+    attempts: number;
+}
+export type SignupCodeResult = 'ok' | 'invalid' | 'expired' | 'locked';
+/** Gera o código e o guarda na sessão, presos à interaction e ao token. Devolve o código. */
+export declare function startSignupCode(ctx: HttpContext, input: {
+    uid: string;
+    email: string;
+    token: string;
+    digits: number;
+    ttlMinutes: number;
+}): string;
+/**
+ * O cadastro pendente desta interaction. Se a pessoa voltou e digitou outro e-mail no login, o
+ * e-mail da sessão muda e o código que vale é o do login.
+ */
+export declare function pendingSignupCode(ctx: HttpContext, uid: string, sessionEmail: string | undefined): PendingSignupCode | null;
+/** Confere o código e conta a tentativa. Ao travar, nem o código certo entra; o link continua. */
+export declare function verifySignupCode(ctx: HttpContext, pending: PendingSignupCode, code: string, maxAttempts: number): SignupCodeResult;

package/build/src/host/signup_code.js

@@ -0,0 +1,56 @@
+import { createHash, randomInt, timingSafeEqual } from 'node:crypto';
+/**
+ * Código digitado do cadastro passwordless.
+ *
+ * Quem abre o link do e-mail noutro navegador termina logado longe de onde começou (um convite
+ * aberto dentro do WhatsApp, por exemplo). Com o código, a pessoa conclui no mesmo navegador e na
+ * mesma interaction. A conta ainda não existe, então não há slot no store: o pendente fica na sessão
+ * deste navegador, e o código correto só libera o mesmo link de confirmação que foi por e-mail.
+ *
+ * As tentativas ficam na sessão. Num driver de cookie dá para repetir um cookie antigo e zerá-las,
+ * e o limite que sobra é o throttle da rota `otp-verify`.
+ */
+export const SIGNUP_CODE_SESSION_KEY = 'authkit_signup_code';
+/** Onde o login guarda o e-mail da interaction: é o que o `otp-verify` lê. */
+export const LOGIN_EMAIL_SESSION_KEY = 'authkit_login_email';
+function hashCode(uid, token, code) {
+    return createHash('sha256').update(`${uid}\u0000${token}\u0000${code}`).digest('hex');
+}
+/** Gera o código e o guarda na sessão, presos à interaction e ao token. Devolve o código. */
+export function startSignupCode(ctx, input) {
+    const code = String(randomInt(0, 10 ** input.digits)).padStart(input.digits, '0');
+    const pending = {
+        uid: input.uid,
+        email: input.email,
+        token: input.token,
+        codeHash: hashCode(input.uid, input.token, code),
+        expiresAt: Date.now() + input.ttlMinutes * 60_000,
+        attempts: 0,
+    };
+    ctx.session.put(SIGNUP_CODE_SESSION_KEY, pending);
+    return code;
+}
+/**
+ * O cadastro pendente desta interaction. Se a pessoa voltou e digitou outro e-mail no login, o
+ * e-mail da sessão muda e o código que vale é o do login.
+ */
+export function pendingSignupCode(ctx, uid, sessionEmail) {
+    const pending = ctx.session.get(SIGNUP_CODE_SESSION_KEY);
+    return pending?.uid === uid && pending.email === sessionEmail ? pending : null;
+}
+/** Confere o código e conta a tentativa. Ao travar, nem o código certo entra; o link continua. */
+export function verifySignupCode(ctx, pending, code, maxAttempts) {
+    if (pending.attempts >= maxAttempts)
+        return 'locked';
+    if (Date.now() >= pending.expiresAt)
+        return 'expired';
+    const expected = Buffer.from(pending.codeHash);
+    const given = Buffer.from(hashCode(pending.uid, pending.token, code));
+    if (expected.length === given.length && timingSafeEqual(expected, given)) {
+        ctx.session.forget(SIGNUP_CODE_SESSION_KEY);
+        return 'ok';
+    }
+    const attempts = pending.attempts + 1;
+    ctx.session.put(SIGNUP_CODE_SESSION_KEY, { ...pending, attempts });
+    return attempts >= maxAttempts ? 'locked' : 'invalid';
+}