@dudousxd/adonis-authkit-server 0.1.1 → 0.3.0

package/build/src/accounts/lucid_store/shared.d.ts

@@ -0,0 +1,48 @@
+import { generateAuthenticationOptions, generateRegistrationOptions, verifyAuthenticationResponse, verifyRegistrationResponse } from '@simplewebauthn/server';
+import type { AuthAccount } from '../account_store.js';
+/**
+ * Encripta/decripta um valor (ex.: o segredo TOTP) em repouso. Mantém a lib
+ * desacoplada do serviço de encryption do app — qualquer implementação que
+ * faça round-trip serve (em prod, normalmente o `@adonisjs/core/services/encryption`).
+ * `decrypt` retorna `null` se o valor foi adulterado/é inválido.
+ */
+export interface AccountSecretEncrypter {
+    encrypt(value: string): string;
+    decrypt(value: string): string | null;
+}
+/**
+ * Funções das cerimônias WebAuthn. Espelham a assinatura do `@simplewebauthn/server`
+ * (subconjunto usado). Injetáveis via {@link LucidAccountStoreOptions.webauthnCeremonies}
+ * para testes.
+ */
+export interface WebauthnCeremonies {
+    generateRegistrationOptions: typeof generateRegistrationOptions;
+    verifyRegistrationResponse: typeof verifyRegistrationResponse;
+    generateAuthenticationOptions: typeof generateAuthenticationOptions;
+    verifyAuthenticationResponse: typeof verifyAuthenticationResponse;
+}
+/** RP (Relying Party) do WebAuthn usado nas cerimônias. */
+export interface ResolvedRp {
+    rpName: string;
+    rpId: string;
+    origin: string | string[];
+}
+/**
+ * Contexto compartilhado pelos builders de capacidade. Carrega o model principal,
+ * os helpers de segredo e (quando configurados) os models/parametros das capacidades.
+ */
+export interface LucidStoreContext {
+    Model: any;
+    mfaIssuer: string;
+    recoveryCodeCount: number;
+    /** Encripta o segredo antes de persistir (no-op sem encrypter). */
+    sealSecret(secret: string): string;
+    /** Decripta o segredo armazenado; null em falha/adulteração (no-op sem encrypter). */
+    openSecret(stored: string | null | undefined): string | null;
+    toAccount(row: any): AuthAccount;
+}
+export declare const sha256: (value: string) => string;
+/** Recovery code legível: 10 chars hex em duas metades (ex.: a1b2c-3d4e5). */
+export declare function generateRecoveryCode(): string;
+/** Comparação de hashes hex resistente a timing. */
+export declare function hashesEqual(a: string, b: string): boolean;

package/build/src/accounts/lucid_store/shared.js

@@ -0,0 +1,15 @@
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+export const sha256 = (value) => createHash('sha256').update(value).digest('hex');
+/** Recovery code legível: 10 chars hex em duas metades (ex.: a1b2c-3d4e5). */
+export function generateRecoveryCode() {
+    const raw = randomBytes(5).toString('hex');
+    return `${raw.slice(0, 5)}-${raw.slice(5, 10)}`;
+}
+/** Comparação de hashes hex resistente a timing. */
+export function hashesEqual(a, b) {
+    const ba = Buffer.from(a);
+    const bb = Buffer.from(b);
+    if (ba.length !== bb.length)
+        return false;
+    return timingSafeEqual(ba, bb);
+}

package/build/src/accounts/lucid_store/webauthn.d.ts

@@ -0,0 +1,8 @@
+import type { WebauthnCapability } from '../account_store.js';
+import type { LucidStoreContext, ResolvedRp, WebauthnCeremonies } from './shared.js';
+/**
+ * Capacidade de passkeys / WebAuthn (2º fator alternativo ao TOTP). Só é montada
+ * quando o `webauthnCredentialModel` é fornecido — ausente, a capacidade inteira
+ * fica ABSENTE do store (a UI esconde a seção de passkeys).
+ */
+export declare function buildWebauthn(ctx: LucidStoreContext, Credential: any, webauthn: ResolvedRp, ceremonies: WebauthnCeremonies): WebauthnCapability;

package/build/src/accounts/lucid_store/webauthn.js

@@ -0,0 +1,135 @@
+import { DateTime } from 'luxon';
+/**
+ * Capacidade de passkeys / WebAuthn (2º fator alternativo ao TOTP). Só é montada
+ * quando o `webauthnCredentialModel` é fornecido — ausente, a capacidade inteira
+ * fica ABSENTE do store (a UI esconde a seção de passkeys).
+ */
+export function buildWebauthn(ctx, Credential, webauthn, ceremonies) {
+    const { Model } = ctx;
+    return {
+        async generatePasskeyRegistrationOptions(accountId) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return null;
+            const existing = await Credential.query().where('accountId', accountId);
+            const options = await ceremonies.generateRegistrationOptions({
+                rpName: webauthn.rpName,
+                rpID: webauthn.rpId,
+                userName: row.email,
+                userDisplayName: row.fullName ?? row.email,
+                // Não pede attestation (privacidade); confia na verificação local.
+                attestationType: 'none',
+                // Evita registrar a mesma credencial duas vezes.
+                excludeCredentials: existing.map((c) => ({
+                    id: c.id,
+                    transports: (c.transports ?? undefined),
+                })),
+                authenticatorSelection: { residentKey: 'preferred', userVerification: 'preferred' },
+            });
+            return {
+                options: options,
+                challenge: options.challenge,
+            };
+        },
+        async verifyPasskeyRegistration(accountId, response, expectedChallenge) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return false;
+            let verification;
+            try {
+                verification = await ceremonies.verifyRegistrationResponse({
+                    response: response,
+                    expectedChallenge,
+                    expectedOrigin: webauthn.origin,
+                    expectedRPID: webauthn.rpId,
+                });
+            }
+            catch {
+                return false;
+            }
+            if (!verification.verified || !verification.registrationInfo)
+                return false;
+            const { credential } = verification.registrationInfo;
+            // publicKey vem como Uint8Array → armazenamos como base64url (texto).
+            const publicKey = Buffer.from(credential.publicKey).toString('base64url');
+            await Credential.create({
+                id: credential.id,
+                accountId,
+                publicKey,
+                counter: credential.counter,
+                transports: credential.transports ?? null,
+                label: null,
+            });
+            // Registrar uma passkey também habilita o MFA (2º fator presente).
+            if (!row.mfaEnabledAt) {
+                row.mfaEnabledAt = DateTime.now();
+                await row.save();
+            }
+            return true;
+        },
+        async generatePasskeyAuthenticationOptions(accountId) {
+            const creds = await Credential.query().where('accountId', accountId);
+            if (creds.length === 0)
+                return null;
+            const options = await ceremonies.generateAuthenticationOptions({
+                rpID: webauthn.rpId,
+                allowCredentials: creds.map((c) => ({
+                    id: c.id,
+                    transports: (c.transports ?? undefined),
+                })),
+                userVerification: 'preferred',
+            });
+            return {
+                options: options,
+                challenge: options.challenge,
+            };
+        },
+        async verifyPasskeyAuthentication(accountId, response, expectedChallenge) {
+            const resp = response;
+            // O credential id vem na resposta (base64url) → acha a credencial da conta.
+            const cred = await Credential.query()
+                .where('accountId', accountId)
+                .where('id', resp?.id ?? '')
+                .first();
+            if (!cred)
+                return false;
+            let verification;
+            try {
+                verification = await ceremonies.verifyAuthenticationResponse({
+                    response: resp,
+                    expectedChallenge,
+                    expectedOrigin: webauthn.origin,
+                    expectedRPID: webauthn.rpId,
+                    credential: {
+                        id: cred.id,
+                        publicKey: new Uint8Array(Buffer.from(cred.publicKey, 'base64url')),
+                        counter: cred.counter,
+                        transports: (cred.transports ?? undefined),
+                    },
+                });
+            }
+            catch {
+                return false;
+            }
+            if (!verification.verified)
+                return false;
+            // Atualiza o signature counter (anti-replay).
+            cred.counter = verification.authenticationInfo.newCounter;
+            await cred.save();
+            return true;
+        },
+        async listPasskeys(accountId) {
+            const creds = await Credential.query()
+                .where('accountId', accountId)
+                .orderBy('createdAt', 'asc');
+            return creds.map((c) => ({
+                id: c.id,
+                label: c.label ?? undefined,
+                createdAt: c.createdAt?.toISO?.() ?? String(c.createdAt ?? ''),
+            }));
+        },
+        async removePasskey(accountId, credentialId) {
+            await Credential.query().where('accountId', accountId).where('id', credentialId).delete();
+        },
+    };
+}

package/build/src/adapters/adapter_contract.d.ts

@@ -6,6 +6,11 @@ export interface OidcPayload {
     uid?: string;
     consumed?: unknown;
 }
+/** Um client OIDC enumerado do adapter (id + payload de metadata persistido). */
+export interface EnumeratedClient {
+    clientId: string;
+    payload: Record<string, unknown>;
+}
 /** Contrato que o oidc-provider espera de um adapter (um por model). */
 export interface OidcAdapter {
     upsert(id: string, payload: OidcPayload, expiresIn: number): Promise<void>;
@@ -15,4 +20,11 @@ export interface OidcAdapter {
     consume(id: string): Promise<void>;
     destroy(id: string): Promise<void>;
     revokeByGrantId(grantId: string): Promise<void>;
+    /**
+     * Enumera os artefatos do model deste adapter — usado SÓ para o model `Client`
+     * pelo console admin, para listar clients persistidos (registro dinâmico/CRUD).
+     * Capacidade OPCIONAL (estilo `AuditSink.list`): adapters que não conseguem
+     * enumerar de forma barata omitem o método e a UI degrada graciosamente.
+     */
+    listClients?(): Promise<EnumeratedClient[]>;
 }

package/build/src/adapters/database_adapter.d.ts

@@ -1,5 +1,5 @@
 import type { Database } from '@adonisjs/lucid/database';
-import type { OidcAdapter, OidcPayload } from './adapter_contract.js';
+import type { EnumeratedClient, OidcAdapter, OidcPayload } from './adapter_contract.js';
 export declare class DatabaseAdapter implements OidcAdapter {
     #private;
     private name;
@@ -12,4 +12,11 @@ export declare class DatabaseAdapter implements OidcAdapter {
     consume(id: string): Promise<void>;
     destroy(id: string): Promise<void>;
     revokeByGrantId(grantId: string): Promise<void>;
+    /**
+     * Enumera os clients persistidos (registro dinâmico ou CRUD do console admin).
+     * Filtra por `model_name = this.name` (sempre 'Client' aqui) e descarta linhas
+     * expiradas — clients são persistidos sem TTL (`expires_at` NULL), então isso
+     * só é uma rede de segurança caso algum dia algo grave o model com expiração.
+     */
+    listClients(): Promise<EnumeratedClient[]>;
 }

package/build/src/adapters/database_adapter.js

@@ -60,4 +60,21 @@ export class DatabaseAdapter {
     async revokeByGrantId(grantId) {
         await this.db.query().from(TABLE).where('grant_id', grantId).delete();
     }
+    /**
+     * Enumera os clients persistidos (registro dinâmico ou CRUD do console admin).
+     * Filtra por `model_name = this.name` (sempre 'Client' aqui) e descarta linhas
+     * expiradas — clients são persistidos sem TTL (`expires_at` NULL), então isso
+     * só é uma rede de segurança caso algum dia algo grave o model com expiração.
+     */
+    async listClients() {
+        const rows = await this.#query().orderBy('id', 'asc');
+        const now = Date.now();
+        const result = [];
+        for (const row of rows) {
+            if (row.expires_at && new Date(row.expires_at).getTime() <= now)
+                continue;
+            result.push({ clientId: row.id, payload: JSON.parse(row.payload) });
+        }
+        return result;
+    }
 }

package/build/src/adapters/redis_adapter.d.ts

@@ -1,5 +1,5 @@
 import type { Redis } from 'ioredis';
-import type { OidcAdapter, OidcPayload } from './adapter_contract.js';
+import type { EnumeratedClient, OidcAdapter, OidcPayload } from './adapter_contract.js';
 export declare class RedisAdapter implements OidcAdapter {
     #private;
     private name;
@@ -13,4 +13,11 @@ export declare class RedisAdapter implements OidcAdapter {
     consume(id: string): Promise<void>;
     destroy(id: string): Promise<void>;
     revokeByGrantId(grantId: string): Promise<void>;
+    /**
+     * Enumera os clients persistidos via SCAN sobre o prefixo de chave do model
+     * (`<prefix>:Client:*`). É limpo porque cada artefato é uma chave única já
+     * namespaceada por `prefix` + `name`; SCAN é não-bloqueante (cursor) ao
+     * contrário de KEYS. Usado apenas pelo console admin (model 'Client').
+     */
+    listClients(): Promise<EnumeratedClient[]>;
 }

package/build/src/adapters/redis_adapter.js

@@ -92,4 +92,30 @@ export class RedisAdapter {
         multi.del(gk);
         await multi.exec();
     }
+    /**
+     * Enumera os clients persistidos via SCAN sobre o prefixo de chave do model
+     * (`<prefix>:Client:*`). É limpo porque cada artefato é uma chave única já
+     * namespaceada por `prefix` + `name`; SCAN é não-bloqueante (cursor) ao
+     * contrário de KEYS. Usado apenas pelo console admin (model 'Client').
+     */
+    async listClients() {
+        const prefix = `${this.prefix}:${this.name}:`;
+        const result = [];
+        let cursor = '0';
+        do {
+            const [next, keys] = await this.redis.scan(cursor, 'MATCH', `${prefix}*`, 'COUNT', 100);
+            cursor = next;
+            for (const key of keys) {
+                const data = await this.redis.get(key);
+                if (!data)
+                    continue;
+                result.push({
+                    clientId: key.slice(prefix.length),
+                    payload: JSON.parse(data),
+                });
+            }
+        } while (cursor !== '0');
+        result.sort((a, b) => a.clientId.localeCompare(b.clientId));
+        return result;
+    }
 }

package/build/src/audit/audit_sink.d.ts

@@ -1,7 +1,7 @@
 /**
  * Tipos de eventos de auditoria relevantes para segurança emitidos pelo IdP.
  */
-export type AuditEventType = 'login.success' | 'login.failure' | 'signup' | 'password_reset.issued' | 'password_reset.consumed' | 'pat.issued' | 'pat.revoked' | 'pat.used' | 'impersonation' | 'mfa.enabled' | 'mfa.disabled' | 'account.locked' | 'passkey.registered' | 'passkey.removed' | 'email_verification.issued' | 'email_verification.consumed';
+export type AuditEventType = 'login.success' | 'login.failure' | 'signup' | 'password_reset.issued' | 'password_reset.consumed' | 'pat.issued' | 'pat.revoked' | 'pat.used' | 'impersonation' | 'mfa.enabled' | 'mfa.disabled' | 'account.locked' | 'passkey.registered' | 'passkey.removed' | 'email_verification.issued' | 'email_verification.consumed' | 'client.created' | 'client.updated' | 'client.deleted';
 /**
  * Evento de auditoria a registrar. O timestamp é definido pelo sink (não aqui).
  */

package/build/src/define_config.d.ts

@@ -117,6 +117,12 @@ export interface ResolvedDynamicRegistrationConfig {
     initialAccessToken?: string;
     management: boolean;
 }
+/**
+ * Resolve a config de registro dinâmico e VALIDA invariantes em tempo de resolução.
+ * O Registration Management (RFC 7592) só faz sentido com o registro habilitado
+ * (RFC 7591) — `management: true` com `enabled: false` é um erro de configuração.
+ */
+export declare function resolveDynamicRegistration(input?: DynamicRegistrationConfigInput): ResolvedDynamicRegistrationConfig;
 /**
  * Console admin opt-in do IdP (B6). Quando habilitado, monta o grupo `/admin/*`
  * (dashboard, usuários/papéis, clients, audit) atrás de um guard que exige sessão

package/build/src/define_config.js

@@ -26,6 +26,25 @@ export function resolveLockout(input) {
         store: input?.store,
     };
 }
+/**
+ * Resolve a config de registro dinâmico e VALIDA invariantes em tempo de resolução.
+ * O Registration Management (RFC 7592) só faz sentido com o registro habilitado
+ * (RFC 7591) — `management: true` com `enabled: false` é um erro de configuração.
+ */
+export function resolveDynamicRegistration(input) {
+    const enabled = input?.enabled ?? false;
+    const management = input?.management ?? false;
+    if (management && !enabled) {
+        throw new Error('authkit: dynamicRegistration.management (RFC 7592) requer ' +
+            'dynamicRegistration.enabled: true (RFC 7591). Habilite o registro dinâmico ' +
+            'ou desligue o management.');
+    }
+    return {
+        enabled,
+        initialAccessToken: input?.initialAccessToken,
+        management,
+    };
+}
 export function resolveAdmin(input) {
     return {
         enabled: input?.enabled ?? false,
@@ -102,11 +121,7 @@ export function defineConfig(config) {
             audit: config.audit,
             mfaIssuer: config.mfaIssuer ?? 'AuthKit',
             webauthn: resolveWebauthn(config.issuer, config.mfaIssuer ?? 'AuthKit', config.webauthn),
-            dynamicRegistration: {
-                enabled: config.dynamicRegistration?.enabled ?? false,
-                initialAccessToken: config.dynamicRegistration?.initialAccessToken,
-                management: config.dynamicRegistration?.management ?? false,
-            },
+            dynamicRegistration: resolveDynamicRegistration(config.dynamicRegistration),
             admin: resolveAdmin(config.admin),
             messages: resolveMessages(config.i18n),
             locale: config.i18n?.locale ?? 'pt-BR',

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

@@ -0,0 +1,65 @@
+import type { OidcService } from '../provider/oidc_service.js';
+/** Métodos de autenticação no token endpoint suportados pelo formulário admin. */
+export type TokenEndpointAuthMethod = 'client_secret_basic' | 'client_secret_post' | 'none';
+/** Entrada normalizada de um client gerenciável (vinda do formulário admin). */
+export interface ClientInput {
+    clientId?: string;
+    redirectUris: string[];
+    postLogoutRedirectUris: string[];
+    grantTypes: string[];
+    tokenEndpointAuthMethod: TokenEndpointAuthMethod;
+}
+/** Client persistido, apresentado ao console admin. */
+export interface AdminClient {
+    clientId: string;
+    confidential: boolean;
+    grants: string[];
+    redirectUris: string[];
+    postLogoutRedirectUris: string[];
+    tokenEndpointAuthMethod: string;
+}
+/** Resultado de uma criação: o client + o secret em claro (mostrado UMA vez). */
+export interface CreatedClient {
+    clientId: string;
+    /** undefined para public clients (sem secret). */
+    clientSecret?: string;
+}
+/**
+ * Serviço de CRUD de clients OIDC persistidos no adapter (model `Client`),
+ * usado pelo console admin. Encapsula:
+ *   - a montagem do payload NA FORMA EXATA que o oidc-provider espera (snake_case,
+ *     igual ao que o registro dinâmico — RFC 7591 — grava);
+ *   - a invalidação do cache de clients dinâmicos do provider após cada escrita
+ *     (ver {@link OidcService.evictDynamicClientCache});
+ *   - a enumeração via a capacidade opcional `listClients` do adapter.
+ */
+export declare class AdminClientsService {
+    #private;
+    private oidc;
+    constructor(oidc: OidcService);
+    /** Indica se o adapter suporta enumeração (capacidade opcional). */
+    get canList(): boolean;
+    /** Lista os clients persistidos (vazio quando o adapter não enumera; cheque canList). */
+    list(): Promise<AdminClient[]>;
+    /** Lê um client persistido pelo client_id (undefined quando não existe). */
+    find(clientId: string): Promise<AdminClient | undefined>;
+    /**
+     * Cria um client. Gera client_id quando não informado; gera client_secret
+     * para clients confidenciais (auth method != 'none'). Retorna o secret em
+     * claro UMA vez (não é recuperável depois — o payload guarda o mesmo valor).
+     */
+    create(input: ClientInput): Promise<CreatedClient>;
+    /**
+     * Atualiza metadata editável (redirect/post-logout URIs, grants, auth method)
+     * PRESERVANDO o client_secret existente. Lança se o client não existe.
+     */
+    update(clientId: string, input: ClientInput): Promise<void>;
+    /**
+     * Regenera o client_secret de um client confidencial, preservando o resto da
+     * metadata. Retorna o novo secret em claro (mostrado UMA vez). Lança se o
+     * client não existe ou é public (auth method 'none').
+     */
+    regenerateSecret(clientId: string): Promise<string>;
+    /** Remove um client persistido e invalida o cache. */
+    delete(clientId: string): Promise<void>;
+}

package/build/src/host/admin_clients_service.js

@@ -0,0 +1,136 @@
+import { randomBytes } from 'node:crypto';
+/** Métodos públicos (sem segredo) — espelham os "non-secret" do oidc-provider. */
+const PUBLIC_AUTH_METHODS = new Set(['none']);
+/** Gera um identificador opaco no estilo do oidc-provider (~43 chars base64url). */
+function randomId() {
+    return randomBytes(32).toString('base64url');
+}
+/**
+ * Serviço de CRUD de clients OIDC persistidos no adapter (model `Client`),
+ * usado pelo console admin. Encapsula:
+ *   - a montagem do payload NA FORMA EXATA que o oidc-provider espera (snake_case,
+ *     igual ao que o registro dinâmico — RFC 7591 — grava);
+ *   - a invalidação do cache de clients dinâmicos do provider após cada escrita
+ *     (ver {@link OidcService.evictDynamicClientCache});
+ *   - a enumeração via a capacidade opcional `listClients` do adapter.
+ */
+export class AdminClientsService {
+    oidc;
+    #adapter;
+    constructor(oidc) {
+        this.oidc = oidc;
+        // O AdapterClass é o MESMO que o provider usa; instanciamos o model 'Client'
+        // para ler/gravar os mesmos artefatos que o oidc-provider persiste.
+        this.#adapter = new oidc.config.AdapterClass('Client');
+    }
+    /** Indica se o adapter suporta enumeração (capacidade opcional). */
+    get canList() {
+        return typeof this.#adapter.listClients === 'function';
+    }
+    /** Lista os clients persistidos (vazio quando o adapter não enumera; cheque canList). */
+    async list() {
+        if (!this.#adapter.listClients)
+            return [];
+        const rows = await this.#adapter.listClients();
+        return rows.map((r) => this.#present(r));
+    }
+    /** Lê um client persistido pelo client_id (undefined quando não existe). */
+    async find(clientId) {
+        const payload = await this.#adapter.find(clientId);
+        if (!payload)
+            return undefined;
+        return this.#present({ clientId, payload: payload });
+    }
+    /**
+     * Cria um client. Gera client_id quando não informado; gera client_secret
+     * para clients confidenciais (auth method != 'none'). Retorna o secret em
+     * claro UMA vez (não é recuperável depois — o payload guarda o mesmo valor).
+     */
+    async create(input) {
+        const clientId = (input.clientId ?? '').trim() || randomId();
+        const confidential = !PUBLIC_AUTH_METHODS.has(input.tokenEndpointAuthMethod);
+        const clientSecret = confidential ? randomId() : undefined;
+        const payload = this.#buildPayload(clientId, input, clientSecret);
+        // expiresIn 0 => sem TTL (clients são permanentes, como no registro dinâmico).
+        await this.#adapter.upsert(clientId, payload, 0);
+        await this.oidc.evictDynamicClientCache();
+        return { clientId, clientSecret };
+    }
+    /**
+     * Atualiza metadata editável (redirect/post-logout URIs, grants, auth method)
+     * PRESERVANDO o client_secret existente. Lança se o client não existe.
+     */
+    async update(clientId, input) {
+        const existing = await this.#adapter.find(clientId);
+        if (!existing)
+            throw new Error(`client ${clientId} não encontrado`);
+        const previousSecret = existing.client_secret;
+        const confidential = !PUBLIC_AUTH_METHODS.has(input.tokenEndpointAuthMethod);
+        // Mantém o secret atual se continua confidencial; se virou public, remove-o.
+        const clientSecret = confidential ? (previousSecret ?? randomId()) : undefined;
+        const payload = this.#buildPayload(clientId, input, clientSecret);
+        await this.#adapter.upsert(clientId, payload, 0);
+        await this.oidc.evictDynamicClientCache();
+    }
+    /**
+     * Regenera o client_secret de um client confidencial, preservando o resto da
+     * metadata. Retorna o novo secret em claro (mostrado UMA vez). Lança se o
+     * client não existe ou é public (auth method 'none').
+     */
+    async regenerateSecret(clientId) {
+        const existing = await this.#adapter.find(clientId);
+        if (!existing)
+            throw new Error(`client ${clientId} não encontrado`);
+        const authMethod = existing.token_endpoint_auth_method ?? 'client_secret_basic';
+        if (PUBLIC_AUTH_METHODS.has(authMethod)) {
+            throw new Error(`client ${clientId} é public — não possui secret`);
+        }
+        const clientSecret = randomId();
+        const payload = { ...existing, client_secret: clientSecret };
+        await this.#adapter.upsert(clientId, payload, 0);
+        await this.oidc.evictDynamicClientCache();
+        return clientSecret;
+    }
+    /** Remove um client persistido e invalida o cache. */
+    async delete(clientId) {
+        await this.#adapter.destroy(clientId);
+        await this.oidc.evictDynamicClientCache();
+    }
+    /**
+     * Monta o payload na forma snake_case que o oidc-provider espera/persiste —
+     * verificada contra o que o registro dinâmico (RFC 7591) grava. As chaves de
+     * metadata não enviadas (subject_type, id_token_signed_response_alg, etc.) são
+     * preenchidas pelo Schema do provider ao construir o Client em `find`.
+     */
+    #buildPayload(clientId, input, clientSecret) {
+        const grantTypes = input.grantTypes.length
+            ? input.grantTypes
+            : ['authorization_code', 'refresh_token'];
+        // response_types: 'code' quando o fluxo de authorization_code está presente.
+        const responseTypes = grantTypes.includes('authorization_code') ? ['code'] : [];
+        const payload = {
+            client_id: clientId,
+            redirect_uris: input.redirectUris,
+            post_logout_redirect_uris: input.postLogoutRedirectUris,
+            grant_types: grantTypes,
+            response_types: responseTypes,
+            token_endpoint_auth_method: input.tokenEndpointAuthMethod,
+        };
+        if (clientSecret)
+            payload.client_secret = clientSecret;
+        return payload;
+    }
+    /** Projeta um payload persistido para a forma exibida no console admin. */
+    #present(row) {
+        const p = row.payload;
+        const authMethod = p.token_endpoint_auth_method ?? 'client_secret_basic';
+        return {
+            clientId: row.clientId,
+            confidential: !!p.client_secret,
+            grants: p.grant_types ?? ['authorization_code', 'refresh_token'],
+            redirectUris: p.redirect_uris ?? [],
+            postLogoutRedirectUris: p.post_logout_redirect_uris ?? [],
+            tokenEndpointAuthMethod: authMethod,
+        };
+    }
+}

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

@@ -2,6 +2,7 @@ import '../augmentations.js';
 import QRCode from 'qrcode';
 import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
 import { translate } from '../i18n.js';
+import { supportsPasskeys } from '../../accounts/account_store.js';
 /** Desafio WebAuthn pendente (registro) guardado na sessão entre begin/finish. */
 const PASSKEY_REG_CHALLENGE_KEY = 'authkit_passkey_reg_challenge';
 /**
@@ -18,7 +19,7 @@ export default class AccountMfaController {
         const state = (await cfg.accountStore.getMfaState?.(userId)) ?? { enabled: false };
         const recoveryCodes = ctx.session.flashMessages.get('recoveryCodes');
         // Passkeys disponíveis quando o store as suporta (model de credenciais wired).
-        const passkeysSupported = typeof cfg.accountStore.listPasskeys === 'function';
+        const passkeysSupported = supportsPasskeys(cfg.accountStore);
         const passkeys = passkeysSupported ? await cfg.accountStore.listPasskeys(userId) : [];
         return render(ctx, 'account/mfa', {
             csrfToken: ctx.request.csrfToken,

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

@@ -1,7 +1,7 @@
 import '../augmentations.js';
 import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
 import { translate } from '../i18n.js';
-import { createAccountLockout } from '../account_lockout.js';
+import { attemptPasswordLogin } from '../login_attempt.js';
 export default class AccountSessionController {
     async show(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
@@ -18,27 +18,19 @@ export default class AccountSessionController {
         const render = cfg.render;
         const { email, password } = ctx.request.only(['email', 'password']);
         const ip = ctx.request.ip?.() ?? null;
-        const lockout = createAccountLockout(cfg.lockout);
-        // Bloqueio progressivo: se a conta está travada, nem verifica a senha.
-        const lock = await lockout.isLocked(email);
-        if (lock.locked) {
+        // Verificação + lockout + auditoria de falha centralizados (sem clientId no console).
+        const result = await attemptPasswordLogin(cfg, { email, password, ip });
+        if (!result.ok) {
             return render(ctx, 'account/login', {
                 csrfToken: ctx.request.csrfToken,
-                error: translate(cfg.messages, 'errors.account_locked', {
-                    seconds: lock.retryAfterSec ?? 0,
-                }),
+                error: result.locked
+                    ? translate(cfg.messages, 'errors.account_locked', {
+                        seconds: result.retryAfterSec ?? 0,
+                    })
+                    : translate(cfg.messages, 'errors.invalid_credentials'),
             });
         }
-        const acc = await cfg.accountStore.verifyCredentials(email, password);
-        if (!acc) {
-            await cfg.audit?.record({ type: 'login.failure', email, ip });
-            await lockout.recordFailure(email, { sink: cfg.audit, ip });
-            return render(ctx, 'account/login', {
-                csrfToken: ctx.request.csrfToken,
-                error: translate(cfg.messages, 'errors.invalid_credentials'),
-            });
-        }
-        await lockout.clearFailures(email);
+        const acc = result.account;
         ctx.session.put(ACCOUNT_SESSION_KEY, acc.id);
         await cfg.audit?.record({ type: 'login.success', accountId: acc.id, email, ip });
         return ctx.response.redirect('/account/tokens');