@adonis-agora/authkit-server 0.87.0 → 0.88.0

package/build/host/views/signup.edge

@@ -66,6 +66,22 @@
           {{ t('signup.have_account') }}
         </a>
       </form>
+
+        {{-- Código do mesmo e-mail: conclui o cadastro neste navegador. --}}
+        @if(magicLinkSent && otpEnabled)
+          <form method="POST" action="/auth/interaction/{{ uid }}/otp-verify" class="mt-4">
+            <input type="hidden" name="_csrf" value="{{ csrfToken }}">
+            <input type="hidden" name="channel" value="code">
+            <label for="otp-code" class="block text-sm font-medium text-gray-700">{{ t('login.otp_label') }}</label>
+            <input id="otp-code" name="code" type="text" inputmode="numeric" autocomplete="one-time-code"
+              pattern="[0-9]*" placeholder="{{ t('login.otp_placeholder') }}"
+              class="mt-2 w-full rounded-lg border border-gray-300 px-3 py-2.5 text-center text-lg tracking-[0.4em] font-mono">
+            <button type="submit"
+              class="mt-4 w-full rounded-lg bg-gray-900 py-2.5 text-sm font-semibold text-white transition hover:opacity-90">
+              {{ t('login.otp_submit') }}
+            </button>
+          </form>
+        @end
     @end
   </div>
 </body></html>

package/build/src/define_config.d.ts

@@ -76,8 +76,8 @@ export interface MailHooks {
         magicUrl: string;
         token: string;
         /**
-         * Código OTP de login, presente APENAS quando `login.otp.enabled` está
-         * ligado. O host pode montar o próprio e-mail com link E código. Ausente no
+         * Código OTP, de login ou de cadastro (`kind: 'signup'`), presente APENAS quando
+         * `login.otp.enabled` está ligado. O host pode montar o próprio e-mail com link E código. Ausente no
          * fluxo só-magic-link (back-compat).
          */
         code?: string;
@@ -90,7 +90,7 @@ export interface MailHooks {
         channel?: 'code' | 'link';
         /**
          * `'signup'`: link de confirmação do cadastro passwordless (a conta é criada
-         * ao abri-lo). Ausente = login por magic link. O host pode trocar o texto do
+         * ao abri-lo, ou ao confirmar o `code`). Ausente = login por magic link. O host pode trocar o texto do
          * e-mail ("confirme seu cadastro"); ignorar o campo continua funcionando.
          */
         kind?: 'signup';
@@ -523,7 +523,9 @@ export interface PasswordlessConfigInput {
      * senha) e envia um link de confirmação (`onMagicLink` com `kind: 'signup'`).
      * A conta só é criada quando o dono do e-mail abre o link: nasce com o e-mail
      * verificado e uma senha aleatória inutilizável, e o login segue pelo magic
-     * link. E-mail que já tem conta recebe um magic link de login. Default: false.
+     * link. E-mail que já tem conta recebe um magic link de login. Com `login.otp`
+     * ligado, os dois casos também levam um código para concluir no mesmo navegador.
+     * Default: false.
      * Exige que o accountStore implemente {@link MagicLinkCapability} e o serviço de
      * encryption do app (APP_KEY), que assina o link; sem a capacidade o cadastro
      * passwordless fica indisponível e o fluxo de senha segue valendo.

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/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/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';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.87.0",
+  "version": "0.88.0",
   "description": "AdonisJS OIDC/OAuth2 provider (Identity Provider) toolkit: ejectable auth server with sessions, rate-limiting, MFA/TOTP, audit log, federated logout and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",