@adonis-agora/authkit-server 0.34.0

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

@@ -0,0 +1,113 @@
+import '../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { translate } from '../i18n.js';
+import { attemptPasswordLogin } from '../login_attempt.js';
+import { notifyLoginSuccess } from '../login_notify.js';
+import { markSudo } from '../sudo_mode.js';
+import { accountHome } from '../account_home.js';
+import { resolveRuntimeSettings } from '../runtime_settings.js';
+/**
+ * Valida um valor de `return_to` recebido da query-string ou de um campo hidden.
+ *
+ * Regras de segurança (anti open-redirect):
+ *   - Deve ser uma string não-vazia.
+ *   - Deve começar com `/`.
+ *   - NÃO pode começar com `//` (esquema-relativo, ex.: `//evil.com`).
+ *   - NÃO pode conter `://` (URL absoluta com esquema, ex.: `https://evil.com`).
+ *   - NÃO pode conter `\` (backslash). Browsers normalizam `\`→`/`, então
+ *     `/\evil.com` vira `//evil.com` (esquema-relativo) → open-redirect. (L9)
+ *
+ * Retorna o valor validado ou `null` quando inválido/ausente.
+ */
+export function validateReturnTo(value) {
+    if (typeof value !== 'string' || !value)
+        return null;
+    // L9: backslash é tratado como `/` por muitos browsers; `/\evil.com` →
+    // `//evil.com`. Rejeitamos qualquer backslash ANTES das demais checagens
+    // para não deixar passar variantes ofuscadas (`/\`, `\/`, `\\`).
+    if (value.includes('\\'))
+        return null;
+    if (!value.startsWith('/'))
+        return null;
+    if (value.startsWith('//'))
+        return null;
+    if (value.includes('://'))
+        return null;
+    return value;
+}
+export default class AccountSessionController {
+    async show(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        if (ctx.session.get(ACCOUNT_SESSION_KEY)) {
+            return ctx.response.redirect(accountHome(cfg));
+        }
+        // Lê e valida o return_to da query-string — descarta valores inválidos (open-redirect).
+        const rawReturnTo = ctx.request.qs?.()?.return_to ?? ctx.request.input?.('return_to');
+        const returnTo = validateReturnTo(rawReturnTo);
+        return render(ctx, 'account/login', { csrfToken: ctx.request.csrfToken, returnTo });
+    }
+    async login(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        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');
+        const returnTo = validateReturnTo(rawReturnTo);
+        // 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);
+        const result = await attemptPasswordLogin(cfg, {
+            email,
+            password,
+            ip,
+            logger: ctx.logger,
+            settings: settings ?? undefined,
+        });
+        if (!result.ok) {
+            return render(ctx, 'account/login', {
+                csrfToken: ctx.request.csrfToken,
+                returnTo,
+                error: result.locked
+                    ? translate(cfg.messages, 'errors.account_locked', {
+                        seconds: result.retryAfterSec ?? 0,
+                    })
+                    : result.disabled
+                        ? translate(cfg.messages, 'errors.account_disabled')
+                        : translate(cfg.messages, 'errors.invalid_credentials'),
+            });
+        }
+        const acc = result.account;
+        // M5 (session fixation): regenera a sessão IMEDIATAMENTE após autenticar e
+        // ANTES de gravar a chave de conta. A elevação de privilégio (anônimo →
+        // autenticado) DEVE trocar o session id para que um id fixado por um atacante
+        // pré-login deixe de valer. O AdonisJS migra os dados já presentes na sessão
+        // para o novo id, então qualquer estado de pré-login (ex.: MFA-pending) é
+        // preservado — o que muda é só o identificador do cookie.
+        await ctx.session.regenerate();
+        ctx.session.put(ACCOUNT_SESSION_KEY, acc.id);
+        // Login com senha = confirmação de identidade → marca sudo (graça a partir do login).
+        markSudo(ctx);
+        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email, ip });
+        // Redireciona pro destino original (validado), ou cai no accountHome configurado.
+        return ctx.response.redirect(returnTo ?? accountHome(cfg));
+    }
+    async logout(ctx) {
+        // M6: não basta `forget(ACCOUNT_SESSION_KEY)` — sobravam na sessão
+        // `authkit_sudo_at` (sudo), `authkit_last_seen` e qualquer outro estado
+        // sensível, com o session id INALTERADO. Regenerar a sessão troca o id E
+        // descarta todos os dados antigos (sudo/last-seen inclusos), destruindo de
+        // fato a sessão de privilégio. Mantemos o `forget` explícito por garantia
+        // (belt-and-braces) caso o store de sessão não suporte regenerate.
+        ctx.session.forget(ACCOUNT_SESSION_KEY);
+        await ctx.session.regenerate();
+        return ctx.response.redirect('/account/login');
+    }
+}

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

@@ -0,0 +1,7 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+export default class AccountTokensController {
+    index(ctx: HttpContext): Promise<any>;
+    store(ctx: HttpContext): Promise<unknown>;
+    destroy(ctx: HttpContext): Promise<unknown>;
+}

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

@@ -0,0 +1,67 @@
+import '../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { requireSudo } from '../sudo_mode.js';
+export default class AccountTokensController {
+    async index(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const tokens = await cfg.patStore.listForAccount(userId);
+        const createdToken = ctx.session.flashMessages.get('createdToken');
+        return render(ctx, 'account/tokens', {
+            csrfToken: ctx.request.csrfToken,
+            createdToken: createdToken ?? null,
+            tokens: tokens.map((t) => ({
+                id: t.id,
+                name: t.name,
+                scopes: t.scopes,
+                audience: t.audience,
+                lastUsedAt: t.lastUsedAt,
+                createdAt: t.createdAt,
+            })),
+        });
+    }
+    async store(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        // Sudo mode gate.
+        const sudoSettingsPat = await resolveRuntimeSettings(ctx);
+        const sudoResultPat = await requireSudo(ctx, sudoSettingsPat);
+        if (sudoResultPat !== true)
+            return sudoResultPat;
+        const { name } = ctx.request.only(['name']);
+        const { token, pat } = await cfg.patStore.issue({ accountId: userId, name: name || 'Token' });
+        ctx.session.flash('createdToken', token);
+        await cfg.audit?.record({
+            type: 'pat.issued',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { patId: pat.id, name: pat.name },
+        });
+        return ctx.response.redirect('/account/tokens');
+    }
+    async destroy(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        // Sudo mode gate.
+        const sudoSettingsPatRev = await resolveRuntimeSettings(ctx);
+        const sudoResultPatRev = await requireSudo(ctx, sudoSettingsPatRev);
+        if (sudoResultPatRev !== true)
+            return sudoResultPatRev;
+        const patId = ctx.request.param('id');
+        const revoked = await cfg.patStore.revoke(userId, patId);
+        if (revoked) {
+            await cfg.audit?.record({
+                type: 'pat.revoked',
+                accountId: userId,
+                ip: ctx.request.ip?.() ?? null,
+                metadata: { patId },
+            });
+        }
+        return ctx.response.redirect('/account/tokens');
+    }
+}

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

@@ -0,0 +1,125 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+export default class AuthInteractionController {
+    show(ctx: HttpContext): Promise<any>;
+    /**
+     * 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.
+     */
+    identifier(ctx: HttpContext): Promise<void>;
+    /**
+     * POST /auth/interaction/:uid/login
+     * Step 2: password submit. Reads email from session (never from form).
+     */
+    login(ctx: HttpContext): Promise<any>;
+    /**
+     * POST /auth/interaction/:uid/mfa
+     * 2º fator: lê o accountId pendente da sessão e aceita um código TOTP (`code`)
+     * OU um recovery code (`recoveryCode`). Em caso de sucesso finaliza a interaction.
+     */
+    mfaVerify(ctx: HttpContext): Promise<any>;
+    /**
+     * true se o authorize request exige MFA via acr_values (contém o mfaAcr da
+     * config de step-up). `acr_values` é a string separada por espaços padrão OIDC.
+     */
+    private acrRequiresMfa;
+    /**
+     * Monta o acr/amr do step-up quando o client solicitou o mfaAcr e um 2º fator
+     * foi verificado. `method` é o método do segundo fator (totp/recovery/webauthn).
+     * Retorna `undefined` quando não há step-up — completeLogin usa o default.
+     */
+    private stepUpExtra;
+    /** true se o store suporta passkeys E a conta tem ao menos uma registrada. */
+    private hasPasskeys;
+    /**
+     * Lê o cookie de dispositivo confiável (encriptado, appKey-backed) e valida que
+     * pertence a `accountId`, não expirou e é posterior ao último (re)enrollment de
+     * MFA. Step-up NÃO chama isto (força sempre o MFA). Best-effort: qualquer erro de
+     * leitura → não confiável.
+     */
+    private checkTrustedDevice;
+    /**
+     * Se o checkbox "confiar neste dispositivo" foi marcado E o mecanismo está ligado,
+     * grava o cookie encriptado de confiança para a conta (skip MFA por N dias).
+     */
+    private maybeTrustDevice;
+    /**
+     * Emite o e-mail de desbloqueio OTP quando o fator fica travado.
+     * Best-effort, fail-safe: nunca lança na request.
+     */
+    private sendOtpUnlockEmailIfAble;
+    /**
+     * accountId para uma cerimônia de passkey no login. Prioriza o accountId pendente
+     * do MFA (passkey como 2º fator). Quando ausente e o passkey-first está ligado,
+     * resolve a conta pelo e-mail guardado na sessão (passkey ANTES da senha) — só se
+     * a conta existe E tem ao menos uma passkey.
+     */
+    private resolvePasskeyAccountId;
+    /**
+     * POST /auth/interaction/:uid/magic
+     * Magic link: lê o e-mail da sessão (passwordless.magicLink ligado), emite um
+     * token de uso único e dispara o e-mail. SEMPRE renderiza "link enviado",
+     * independentemente de a conta existir (anti-enumeração). Throttled como o login.
+     */
+    magicLinkRequest(ctx: HttpContext): Promise<any>;
+    /**
+     * GET /auth/interaction/:uid/magic?token=...
+     * Consome o magic link. Em sucesso finaliza o login (amr `['email']`). Token
+     * inválido/expirado volta ao início do login.
+     */
+    magicLinkConsume(ctx: HttpContext): Promise<any>;
+    /**
+     * POST /auth/interaction/:uid/passkey/options
+     *
+     * Gera as opções de autenticação por passkey. Suporta dois modos:
+     *
+     * 1. **Modo normal** (MFA gate ou passkey-first com e-mail na sessão):
+     *    resolve o `accountId` e gera opções com `allowCredentials` restrito às
+     *    credenciais da conta (comportamento original).
+     *
+     * 2. **Modo discoverable** (WebAuthn autofill / conditional mediation):
+     *    chamado sem accountId resolvível (tela de identifier sem e-mail ainda).
+     *    Neste caso, delega a `generatePasskeyAuthenticationOptions` com accountId
+     *    especial `'__discoverable__'` — o store deve retornar opções com
+     *    `allowCredentials: []` (deixa o browser apresentar TODAS as passkeys
+     *    disponíveis). Quando o store não suporta este modo, devolve 400 com
+     *    `discoverable: false` (o JS de autofill trata silenciosamente).
+     *
+     * Guarda o challenge na sessão e devolve as opções JSON.
+     */
+    passkeyOptions(ctx: HttpContext): Promise<any>;
+    /**
+     * POST /auth/interaction/:uid/passkey/verify
+     * Verifica a resposta de autenticação por passkey contra o challenge guardado;
+     * em caso de sucesso FINALIZA a interaction (303 de volta ao client — alternativa
+     * ao código TOTP). É um POST de página inteira (form), não fetch: o browser
+     * submete o JSON da assertion no campo `response` e segue o redirect normalmente.
+     */
+    passkeyVerify(ctx: HttpContext): Promise<any>;
+    /**
+     * GET /auth/interaction/:uid/switch
+     * Clears the stored email and redirects back to step 1.
+     */
+    switchIdentifier(ctx: HttpContext): Promise<void>;
+    /**
+     * POST /auth/interaction/:uid/password-expired
+     *
+     * Step de troca obrigatória quando a senha expirou. A senha VELHA já foi
+     * verificada em `login` — aqui a conta está no step `password_expired` da
+     * sessão. O usuário informa a nova senha (+ confirmação) e o controller:
+     *   1. Valida política de senha.
+     *   2. Atualiza a senha via `changePassword` (que toca `passwordChangedAt`).
+     *   3. Finaliza a interaction normalmente.
+     *
+     * Capability-probed: sem `changePassword` → redireciona para o login.
+     */
+    changeExpiredPassword(ctx: HttpContext): Promise<any>;
+    consent(ctx: HttpContext): Promise<void>;
+    /**
+     * GET /auth/otp-unlock/:token
+     * Consome o token de desbloqueio OTP enviado por e-mail. Valida (hash + TTL),
+     * zera o contador/lock, audita `otp.unlocked` e redireciona ao login com mensagem.
+     */
+    otpUnlock(ctx: HttpContext): Promise<any>;
+}