@dudousxd/adonis-authkit-server 0.2.0 → 0.4.0

package/build/src/keys/keystore.d.ts

@@ -0,0 +1,43 @@
+import type { SigningAlg } from './jwks_manager.js';
+/**
+ * Keystore JSON em arquivo para o modo `jwks: { source: 'managed', store }`.
+ *
+ * O modo `managed` "puro" gera UMA chave efêmera por boot (em
+ * {@link generateJwks}) — não persiste, então rotacionar não faz sentido: a cada
+ * restart o kid muda e tokens antigos param de validar. Para suportar rotação de
+ * verdade, este keystore persiste o JWKS PRIVADO em um arquivo. A rotação gera
+ * um novo par (novo kid) e mantém as N chaves mais recentes; o JWKS público
+ * servido inclui todas (as antigas continuam validando), e a PRIMEIRA chave do
+ * array é a de assinatura corrente (o oidc-provider assina com a primeira chave
+ * compatível).
+ */
+/** Estrutura persistida: JWKS privado (chaves com `d`). */
+export interface PersistedKeystore {
+    keys: Record<string, any>[];
+}
+/** Gera uma chave de assinatura privada como JWK (com use/alg/kid). */
+export declare function generateSigningJwk(alg: SigningAlg): Promise<Record<string, any>>;
+/** Lê o keystore do arquivo, ou null se não existir/for inválido. */
+export declare function readKeystore(path: string): PersistedKeystore | null;
+/** Escreve o keystore no arquivo (cria o diretório se preciso). */
+export declare function writeKeystore(path: string, store: PersistedKeystore): void;
+/**
+ * Garante que o keystore exista: se ausente, cria com uma chave nova e persiste.
+ * Retorna o keystore (privado).
+ */
+export declare function ensureKeystore(path: string, alg: SigningAlg): Promise<PersistedKeystore>;
+/**
+ * Rotaciona o keystore: gera uma chave nova, coloca-a NA FRENTE (vira a chave de
+ * assinatura corrente) e mantém apenas as `keep` mais recentes (default 2) para
+ * que tokens assinados com a chave anterior continuem validando. Persiste e
+ * retorna o keystore atualizado.
+ */
+export declare function rotateKeystore(path: string, alg: SigningAlg, keep?: number): Promise<{
+    store: PersistedKeystore;
+    newKid: string;
+    retiredKids: string[];
+}>;
+/** Deriva o JWKS PÚBLICO (sem `d` e demais campos privados) a partir do privado. */
+export declare function toPublicJwks(store: PersistedKeystore): {
+    keys: Record<string, any>[];
+};

package/build/src/keys/keystore.js

@@ -0,0 +1,74 @@
+import { generateKeyPair, exportJWK } from 'jose';
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** Gera uma chave de assinatura privada como JWK (com use/alg/kid). */
+export async function generateSigningJwk(alg) {
+    const { privateKey } = await generateKeyPair(alg, { extractable: true });
+    const jwk = (await exportJWK(privateKey));
+    jwk.use = 'sig';
+    jwk.alg = alg;
+    jwk.kid = randomUUID();
+    return jwk;
+}
+/** Lê o keystore do arquivo, ou null se não existir/for inválido. */
+export function readKeystore(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (parsed && Array.isArray(parsed.keys))
+            return parsed;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Escreve o keystore no arquivo (cria o diretório se preciso). */
+export function writeKeystore(path, store) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(store, null, 2) + '\n', { mode: 0o600 });
+}
+/**
+ * Garante que o keystore exista: se ausente, cria com uma chave nova e persiste.
+ * Retorna o keystore (privado).
+ */
+export async function ensureKeystore(path, alg) {
+    const existing = readKeystore(path);
+    if (existing && existing.keys.length > 0)
+        return existing;
+    const store = { keys: [await generateSigningJwk(alg)] };
+    writeKeystore(path, store);
+    return store;
+}
+/**
+ * Rotaciona o keystore: gera uma chave nova, coloca-a NA FRENTE (vira a chave de
+ * assinatura corrente) e mantém apenas as `keep` mais recentes (default 2) para
+ * que tokens assinados com a chave anterior continuem validando. Persiste e
+ * retorna o keystore atualizado.
+ */
+export async function rotateKeystore(path, alg, keep = 2) {
+    const current = readKeystore(path) ?? { keys: [] };
+    const fresh = await generateSigningJwk(alg);
+    const next = [fresh, ...current.keys];
+    const kept = next.slice(0, Math.max(1, keep));
+    const retiredKids = next.slice(Math.max(1, keep)).map((k) => k.kid);
+    const store = { keys: kept };
+    writeKeystore(path, store);
+    return { store, newKid: fresh.kid, retiredKids };
+}
+/** Deriva o JWKS PÚBLICO (sem `d` e demais campos privados) a partir do privado. */
+export function toPublicJwks(store) {
+    const PRIVATE_FIELDS = ['d', 'p', 'q', 'dp', 'dq', 'qi'];
+    return {
+        keys: store.keys.map((jwk) => {
+            const pub = {};
+            for (const [k, v] of Object.entries(jwk)) {
+                if (!PRIVATE_FIELDS.includes(k))
+                    pub[k] = v;
+            }
+            return pub;
+        }),
+    };
+}

package/build/src/provider/build_provider.js

@@ -1,4 +1,5 @@
 import * as oidc from 'oidc-provider';
+import { createDeviceSources } from './device_sources.js';
 export function buildProvider(config, options) {
     const cookieKeys = config.cookieKeys.length ? config.cookieKeys : [options.appKey];
     // OIDC Dynamic Client Registration (RFC 7591/7592). Só montamos as chaves de feature
@@ -16,6 +17,22 @@ export function buildProvider(config, options) {
             ...(dynReg.management ? { registrationManagement: { enabled: true } } : {}),
         }
         : {};
+    // Device Authorization Grant (RFC 8628). Quando ligado, montamos a feature com
+    // as três sources de UI i18n-izadas (entrada/confirmação/sucesso do user-code).
+    const deviceFlowFeatures = config.deviceFlow.enabled
+        ? { deviceFlow: { enabled: true, ...createDeviceSources(config.messages) } }
+        : {};
+    // DPoP (RFC 9449). A chave EXATA do oidc-provider v9 é `dPoP`.
+    const dpopFeatures = config.dpop.enabled ? { dPoP: { enabled: true } } : {};
+    // PAR (RFC 9126).
+    const parFeatures = config.par.enabled
+        ? {
+            pushedAuthorizationRequests: {
+                enabled: true,
+                requirePushedAuthorizationRequests: config.par.requirePushedAuthorizationRequests,
+            },
+        }
+        : {};
     const provider = new oidc.Provider(config.issuer, {
         adapter: config.AdapterClass,
         clients: config.clients.map((c) => ({
@@ -79,7 +96,13 @@ export function buildProvider(config, options) {
             revocation: { enabled: true },
             introspection: { enabled: true },
             ...registrationFeatures,
+            ...deviceFlowFeatures,
+            ...dpopFeatures,
+            ...parFeatures,
         },
+        // Step-up auth (acr_values): anuncia os acr suportados para que clients possam
+        // solicitá-los. A exigência efetiva do 2º fator acontece na interaction de login.
+        acrValues: config.stepUp.acrValues,
         ttl: {
             AccessToken: config.ttl.accessToken,
             RefreshToken: config.ttl.refreshToken,

package/build/src/provider/device_sources.d.ts

@@ -0,0 +1,6 @@
+import { type AuthMessages } from '../host/i18n.js';
+export declare function createDeviceSources(messages: AuthMessages): {
+    userCodeInputSource(_ctx: any, form: string, _out: any, err: any): Promise<void>;
+    userCodeConfirmSource(_ctx: any, form: string, _client: any, _deviceInfo: any, userCode: string): Promise<void>;
+    successSource(_ctx: any): Promise<void>;
+};

package/build/src/provider/device_sources.js

@@ -0,0 +1,65 @@
+import { translate } from '../host/i18n.js';
+/**
+ * Fontes (sources) de renderização do Device Authorization Grant (RFC 8628).
+ *
+ * O oidc-provider chama estas funções com o KOA ctx (não o HttpContext do Adonis),
+ * então elas NÃO têm acesso ao renderer Inertia/Edge do host. Emitimos HTML
+ * auto-contido e i18n-izado (mesmo idioma das demais telas), o que também silencia
+ * os avisos `shouldChange` dos defaults da lib. As três telas:
+ *  - userCodeInputSource: entrada do user-code (`/device`)
+ *  - userCodeConfirmSource: confirmação após o code casar
+ *  - successSource: tela final pós-aprovação
+ */
+function esc(value) {
+    return String(value ?? '')
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+const STYLE = `
+  body{font-family:system-ui,-apple-system,Segoe UI,Roboto,sans-serif;background:#f5f5f7;margin:0;padding:48px 16px;color:#1d1d1f}
+  .card{max-width:340px;margin:0 auto;background:#fff;border-radius:14px;padding:32px;box-shadow:0 1px 4px rgba(0,0,0,.08)}
+  h1{font-size:1.4rem;font-weight:600;margin:0 0 12px;text-align:center}
+  p{font-size:.95rem;line-height:1.5;text-align:center;color:#444}
+  p.red{color:#c0392b}
+  code{display:block;font-size:1.6rem;letter-spacing:.15em;text-align:center;margin:16px 0;font-weight:600}
+  input[type=text]{width:100%;box-sizing:border-box;height:46px;font-size:1rem;text-align:center;text-transform:uppercase;border:1px solid #d2d2d7;border-radius:10px;padding:0 12px;margin-bottom:14px}
+  button{width:100%;height:44px;font-size:.95rem;font-weight:600;color:#fff;background:#0071e3;border:0;border-radius:10px;cursor:pointer}
+  button:hover{background:#0077ed}
+  .abort{margin-top:12px;background:none;color:#666;font-weight:400}
+  .abort:hover{background:none;text-decoration:underline}
+`;
+function page(title, inner) {
+    return `<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${esc(title)}</title><style>${STYLE}</style></head><body><div class="card">${inner}</div></body></html>`;
+}
+export function createDeviceSources(messages) {
+    const t = (key, params) => translate(messages, key, params);
+    return {
+        async userCodeInputSource(_ctx, form, _out, err) {
+            const ctx = _ctx;
+            let msg;
+            if (err && (err.userCode || err.name === 'NoCodeError')) {
+                msg = `<p class="red">${esc(t('device.input.error_invalid'))}</p>`;
+            }
+            else if (err && err.name === 'AbortedError') {
+                msg = `<p class="red">${esc(t('device.input.error_aborted'))}</p>`;
+            }
+            else if (err) {
+                msg = `<p class="red">${esc(t('device.input.error_generic'))}</p>`;
+            }
+            else {
+                msg = `<p>${esc(t('device.input.intro'))}</p>`;
+            }
+            ctx.body = page(t('device.input.title'), `<h1>${esc(t('device.input.title'))}</h1>${msg}${form}<button type="submit" form="op.deviceInputForm">${esc(t('device.input.submit'))}</button>`);
+        },
+        async userCodeConfirmSource(_ctx, form, _client, _deviceInfo, userCode) {
+            const ctx = _ctx;
+            ctx.body = page(t('device.confirm.title'), `<h1>${esc(t('device.confirm.title'))}</h1><p>${esc(t('device.confirm.body'))}</p><code>${esc(userCode)}</code>${form}<button autofocus type="submit" form="op.deviceConfirmForm">${esc(t('device.confirm.submit'))}</button><button class="abort" type="submit" form="op.deviceConfirmForm" value="yes" name="abort">${esc(t('device.confirm.abort'))}</button>`);
+        },
+        async successSource(_ctx) {
+            const ctx = _ctx;
+            ctx.body = page(t('device.success.title'), `<h1>${esc(t('device.success.title'))}</h1><p>${esc(t('device.success.body'))}</p>`);
+        },
+    };
+}

package/build/src/provider/interaction_actions.d.ts

@@ -4,6 +4,11 @@ export interface InteractionDeps {
         id: string;
     } | null>;
 }
+/** Detalhes opcionais de login (step-up auth): acr alcançado + amr (métodos). */
+export interface CompleteLoginExtra {
+    acr?: string;
+    amr?: string[];
+}
 export interface InteractionActions {
     details(ctx: HttpContext): Promise<any>;
     login(ctx: HttpContext, input: {
@@ -12,7 +17,7 @@ export interface InteractionActions {
     }): Promise<{
         ok: boolean;
     }>;
-    completeLogin(ctx: HttpContext, accountId: string): Promise<{
+    completeLogin(ctx: HttpContext, accountId: string, extra?: CompleteLoginExtra): Promise<{
         ok: boolean;
     }>;
     consent(ctx: HttpContext): Promise<unknown>;

package/build/src/provider/interaction_actions.js

@@ -14,8 +14,15 @@ export function createInteractionActions(provider, deps) {
             await provider.interactionFinished(ctx.request.request, ctx.response.response, { login: { accountId: account.id } }, { mergeWithLastSubmission: false });
             return { ok: true };
         },
-        async completeLogin(ctx, accountId) {
-            await provider.interactionFinished(ctx.request.request, ctx.response.response, { login: { accountId } }, { mergeWithLastSubmission: false });
+        async completeLogin(ctx, accountId, extra) {
+            // acr/amr (RFC 8176): quando um step-up de MFA foi efetivamente cumprido,
+            // passamos o acr alcançado + os métodos (amr) para que o id_token os carregue.
+            const login = { accountId };
+            if (extra?.acr)
+                login.acr = extra.acr;
+            if (extra?.amr && extra.amr.length)
+                login.amr = extra.amr;
+            await provider.interactionFinished(ctx.request.request, ctx.response.response, { login }, { mergeWithLastSubmission: false });
             return { ok: true };
         },
         async consent(ctx) {

package/build/src/provider/oidc_service.d.ts

@@ -12,6 +12,21 @@ export declare class OidcService {
     readonly interactions: InteractionActions;
     get config(): ResolvedServerConfig;
     constructor(config: ResolvedServerConfig, appKey: string, recorder?: MetricsRecorder);
+    /**
+     * Invalida o cache de clients DINÂMICOS do oidc-provider (a `dynamicClients`
+     * QuickLRU em `instance(provider)`). DEVE ser chamado após qualquer escrita
+     * (create/update/delete) no model `Client` via adapter, pelo console admin.
+     *
+     * NOTA sobre o porquê: o oidc-provider v9 cacheia clients carregados do adapter
+     * numa LRU CUJA CHAVE É O HASH (sha256) DO PAYLOAD persistido — não o client_id.
+     * Por isso uma alteração de metadata já é "auto-invalidante": `Client.find` relê o
+     * adapter, hasheia o payload NOVO, dá cache-miss e reconstrói o client. Mesmo assim
+     * limpamos a LRU explicitamente para (a) tornar o efeito imediato e determinístico
+     * (sem depender de pressão de LRU para expulsar a entrada antiga, agora inalcançável)
+     * e (b) liberar a entrada órfã na hora. É o caminho de invalidação suportado: a LRU
+     * é um detalhe interno acessível via o helper `weak_cache` do próprio provider.
+     */
+    evictDynamicClientCache(): Promise<void>;
     /** Verifica client_id + client_secret contra os clients da config (p/ endpoints custom como introspecção de PAT). */
     verifyClientCredentials(clientId: string, clientSecret: string): boolean;
 }

package/build/src/provider/oidc_service.js

@@ -72,6 +72,33 @@ export class OidcService {
         }
         this.interactions = createInteractionActions(this.provider, { verifyCredentials: config.verifyCredentials });
     }
+    /**
+     * Invalida o cache de clients DINÂMICOS do oidc-provider (a `dynamicClients`
+     * QuickLRU em `instance(provider)`). DEVE ser chamado após qualquer escrita
+     * (create/update/delete) no model `Client` via adapter, pelo console admin.
+     *
+     * NOTA sobre o porquê: o oidc-provider v9 cacheia clients carregados do adapter
+     * numa LRU CUJA CHAVE É O HASH (sha256) DO PAYLOAD persistido — não o client_id.
+     * Por isso uma alteração de metadata já é "auto-invalidante": `Client.find` relê o
+     * adapter, hasheia o payload NOVO, dá cache-miss e reconstrói o client. Mesmo assim
+     * limpamos a LRU explicitamente para (a) tornar o efeito imediato e determinístico
+     * (sem depender de pressão de LRU para expulsar a entrada antiga, agora inalcançável)
+     * e (b) liberar a entrada órfã na hora. É o caminho de invalidação suportado: a LRU
+     * é um detalhe interno acessível via o helper `weak_cache` do próprio provider.
+     */
+    async evictDynamicClientCache() {
+        try {
+            const wc = await import('oidc-provider/lib/helpers/weak_cache.js');
+            const get = wc.default ?? wc.get;
+            const int = get(this.provider);
+            int?.dynamicClients?.clear?.();
+        }
+        catch {
+            // Estrutura interna mudou numa versão futura do oidc-provider: a invalidação por
+            // hash-de-conteúdo (acima) continua garantindo correção; só perdemos a expulsão
+            // imediata da entrada órfã. Best-effort — não propaga erro pro caminho da request.
+        }
+    }
     /** Verifica client_id + client_secret contra os clients da config (p/ endpoints custom como introspecção de PAT). */
     verifyClientCredentials(clientId, clientSecret) {
         const client = this.#clients.find((c) => c.clientId === clientId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dudousxd/adonis-authkit-server",
-  "version": "0.2.0",
+  "version": "0.4.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",
@@ -76,7 +76,7 @@
     "oidc-provider": "^9.8.4",
     "otplib": "^12.0.1",
     "qrcode": "^1.5.4",
-    "@dudousxd/adonis-authkit-core": "0.1.0"
+    "@dudousxd/adonis-authkit-core": "0.2.0"
   },
   "devDependencies": {
     "@adonisjs/ally": "6.3.0",