@adonis-agora/authkit-server 0.68.2 → 0.68.4

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

@@ -16,16 +16,22 @@ export declare function encodeActiveOrgCookie(info: ActiveOrgInfo): string;
  */
 export declare function decodeActiveOrgCookie(value: string | null | undefined): ActiveOrgInfo | null;
 /**
- * Lê a org ativa de um contexto Koa (oidc-provider). O oidc-provider usa o Keygrip
- * das `cookieKeys` para assinar os cookies — lemos via `ctx.cookies.get(name, { signed: false })`
- * (o oidc-provider não assina cookies da aplicação; apenas verifica os seus). A
- * validação de assinatura para este cookie de aplicação é feita no controller AdonisJS
- * ao gravar (via `ctx.response.cookie` com `signed: true`). Aqui fazemos best-effort:
- * se o valor estiver presente e parseable, usamos; caso contrário retorna null.
+ * Lê a org ativa de um contexto Koa (oidc-provider).
  *
- * NOTA: o oidc-provider ctx.cookies.get() nunca lança — retorna null se ausente.
+ * O cookie NÃO pode ser lido como "cru": num app Adonis com assinatura de cookie
+ * ligada ele chega como `s:<b64>.<hmac>` e precisa ser verificado. Passamos
+ * `appKey` e verificamos a assinatura — sem ela o valor é recusado.
+ *
+ * Por que existe: `loadExistingGrant` roda no authorize (request do browser, com o
+ * cookie) e é quem reconcilia o Grant reaproveitado depois que o usuário troca de
+ * organização. O consent também grava a org, mas ele só roda UMA vez por grant —
+ * sem esta leitura, quem ativa a org depois do primeiro login nunca recebe a claim.
+ *
+ * NOTA: `ctx.cookies.get()` nunca lança — retorna null se ausente.
  */
-export declare function readActiveOrgFromKoaCtx(koaCtx: any): ActiveOrgInfo | null;
+export declare function readActiveOrgFromKoaCtx(koaCtx: any, opts?: {
+    appKey?: string;
+}): ActiveOrgInfo | null;
 /**
  * Normaliza um valor potencialmente vindo de um payload PERSISTIDO (o `activeOrg`
  * do Grant) para `ActiveOrgInfo`. Retorna null quando a forma não bate — nunca
@@ -37,9 +43,11 @@ export declare function normalizeActiveOrg(value: unknown): ActiveOrgInfo | null
  * AdonisJS usado pelas `InteractionActions`).
  *
  * No consent a request É do browser, então o cookie está presente — ao contrário
- * do mint do id_token no `/token` (server-a-servidor, sem cookies). O cookie é
- * gravado UNSIGNED por `account_orgs_controller.activate` e lido aqui via
- * `request.cookie` (o MESMO caminho das leituras do console/account API), com
- * fallback para o caminho Koa caso o contexto recebido seja um ctx Koa.
+ * do mint do id_token no `/token` (server-a-servidor, sem cookies). Aqui o
+ * `request.cookie` do AdonisJS já desassina o cookie (quando o host assina), então
+ * o valor chega em texto; `appKey` cobre o fallback Koa, caso o ctx recebido seja
+ * um ctx Koa e não o HttpContext.
  */
-export declare function readActiveOrgFromHostCtx(ctx: unknown): ActiveOrgInfo | null;
+export declare function readActiveOrgFromHostCtx(ctx: unknown, opts?: {
+    appKey?: string;
+}): ActiveOrgInfo | null;

package/build/src/host/active_org_cookie.js

@@ -1,3 +1,4 @@
+import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
 /** Nome do cookie da org ativa. HttpOnly, SameSite=Lax, Secure em prod. */
 export const ACTIVE_ORG_COOKIE = 'authkit_active_org';
 /** TTL máximo do cookie da org ativa (30 dias em segundos). */
@@ -27,40 +28,90 @@ export function decodeActiveOrgCookie(value) {
     return { orgId, orgSlug, orgRole };
 }
 /**
- * Parseia um valor de cookie possivelmente URL-encoded.
+ * Desfaz o envelope de cookie ASSINADO do AdonisJS: `s:<base64url>.<hmac>`.
+ *
+ * O host grava o cookie via `ctx.response.cookie`, e o AdonisJS assina com o
+ * `MessageVerifier` (`@boringnode/encryption`): HMAC-SHA256 sobre o base64url do
+ * payload, com a chave derivada de `sha256(appKey)`, e `purpose` = NOME do cookie.
+ * O `message` do payload é o valor.
  *
- * O jar Koa do oidc-provider (`cookies`) devolve o valor COMO ESTÁ no header — sem
- * URL-decode. Como o host grava o cookie via `response.cookie` (que serializa com
- * `encodeURIComponent`, transformando os TABs em `%09`), é preciso tentar decodificar.
- * Tentamos o valor cru primeiro (hosts que gravem sem encode) e o decodificado depois.
+ * Verificamos a assinatura — não basta decodificar. Este cookie decide a claim de
+ * organização, então aceitar um valor não assinado deixaria qualquer usuário trocar
+ * de tenant forjando o cookie. Sem `appKey` não há como verificar: devolve null.
  */
-function parseActiveOrgCookieValue(raw) {
-    if (typeof raw !== 'string')
+function unsignAdonisCookie(signedRaw, appKey, purpose) {
+    if (!signedRaw.startsWith('s:'))
+        return null;
+    const [encoded, hash] = signedRaw.slice(2).split('.');
+    if (!encoded || !hash)
+        return null;
+    const key = createHash('sha256').update(appKey).digest();
+    const expected = createHmac('sha256', key).update(encoded).digest('base64url');
+    const a = Buffer.from(expected);
+    const b = Buffer.from(hash);
+    if (a.length !== b.length || !timingSafeEqual(a, b))
         return null;
-    const direct = decodeActiveOrgCookie(raw);
-    if (direct)
-        return direct;
     try {
-        return decodeActiveOrgCookie(decodeURIComponent(raw));
+        const payload = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
+        if (payload?.purpose !== purpose)
+            return null;
+        return typeof payload.message === 'string' ? payload.message : null;
     }
     catch {
         return null;
     }
 }
 /**
- * Lê a org ativa de um contexto Koa (oidc-provider). O oidc-provider usa o Keygrip
- * das `cookieKeys` para assinar os cookies — lemos via `ctx.cookies.get(name, { signed: false })`
- * (o oidc-provider não assina cookies da aplicação; apenas verifica os seus). A
- * validação de assinatura para este cookie de aplicação é feita no controller AdonisJS
- * ao gravar (via `ctx.response.cookie` com `signed: true`). Aqui fazemos best-effort:
- * se o valor estiver presente e parseable, usamos; caso contrário retorna null.
+ * Parseia um valor de cookie possivelmente URL-encoded.
+ *
+ * Aceita três formas, nesta ordem:
+ * 1. **Assinado pelo Adonis** (`s:<b64>.<hmac>`), quando `appKey` é conhecida —
+ *    verificado com `unsignAdonisCookie`. É a forma real quando o host grava via
+ *    `ctx.response.cookie` num app com assinatura de cookie ligada.
+ * 2. Valor cru (hosts que gravem sem encode e sem assinatura).
+ */
+function parseActiveOrgCookieValue(raw, appKey) {
+    if (typeof raw !== 'string' || !raw)
+        return null;
+    // O jar Koa devolve o valor COMO ESTÁ no header, sem URL-decode — e o browser
+    // reenvia o cookie exatamente como o host o escreveu, isto é `s%3A<b64>.<hmac>`
+    // quando ele é assinado. Normalizar ANTES de decidir o formato é obrigatório:
+    // checar `startsWith('s:')` no valor cru nunca casaria.
+    let value = raw;
+    try {
+        const decoded = decodeURIComponent(raw);
+        if (decoded)
+            value = decoded;
+    }
+    catch {
+        // não era URL-encoded; segue com o cru
+    }
+    if (value.startsWith('s:')) {
+        if (!appKey)
+            return null;
+        const unsigned = unsignAdonisCookie(value, appKey, ACTIVE_ORG_COOKIE);
+        return unsigned ? decodeActiveOrgCookie(unsigned) : null;
+    }
+    return decodeActiveOrgCookie(value);
+}
+/**
+ * Lê a org ativa de um contexto Koa (oidc-provider).
+ *
+ * O cookie NÃO pode ser lido como "cru": num app Adonis com assinatura de cookie
+ * ligada ele chega como `s:<b64>.<hmac>` e precisa ser verificado. Passamos
+ * `appKey` e verificamos a assinatura — sem ela o valor é recusado.
+ *
+ * Por que existe: `loadExistingGrant` roda no authorize (request do browser, com o
+ * cookie) e é quem reconcilia o Grant reaproveitado depois que o usuário troca de
+ * organização. O consent também grava a org, mas ele só roda UMA vez por grant —
+ * sem esta leitura, quem ativa a org depois do primeiro login nunca recebe a claim.
  *
- * NOTA: o oidc-provider ctx.cookies.get() nunca lança — retorna null se ausente.
+ * NOTA: `ctx.cookies.get()` nunca lança — retorna null se ausente.
  */
-export function readActiveOrgFromKoaCtx(koaCtx) {
+export function readActiveOrgFromKoaCtx(koaCtx, opts) {
     try {
         const raw = koaCtx?.cookies?.get?.(ACTIVE_ORG_COOKIE, { signed: false });
-        return parseActiveOrgCookieValue(raw);
+        return parseActiveOrgCookieValue(raw, opts?.appKey);
     }
     catch {
         return null;
@@ -90,20 +141,20 @@ export function normalizeActiveOrg(value) {
  * AdonisJS usado pelas `InteractionActions`).
  *
  * No consent a request É do browser, então o cookie está presente — ao contrário
- * do mint do id_token no `/token` (server-a-servidor, sem cookies). O cookie é
- * gravado UNSIGNED por `account_orgs_controller.activate` e lido aqui via
- * `request.cookie` (o MESMO caminho das leituras do console/account API), com
- * fallback para o caminho Koa caso o contexto recebido seja um ctx Koa.
+ * do mint do id_token no `/token` (server-a-servidor, sem cookies). Aqui o
+ * `request.cookie` do AdonisJS já desassina o cookie (quando o host assina), então
+ * o valor chega em texto; `appKey` cobre o fallback Koa, caso o ctx recebido seja
+ * um ctx Koa e não o HttpContext.
  */
-export function readActiveOrgFromHostCtx(ctx) {
+export function readActiveOrgFromHostCtx(ctx, opts) {
     try {
         const raw = ctx?.request?.cookie?.(ACTIVE_ORG_COOKIE);
-        const parsed = parseActiveOrgCookieValue(raw);
+        const parsed = parseActiveOrgCookieValue(raw, opts?.appKey);
         if (parsed)
             return parsed;
     }
     catch {
         // contexto sem `request.cookie` — tenta o caminho Koa abaixo
     }
-    return readActiveOrgFromKoaCtx(ctx);
+    return readActiveOrgFromKoaCtx(ctx, opts);
 }

package/build/src/provider/build_provider.js

@@ -133,7 +133,13 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
             const grant = await ctx.oidc.provider.Grant.find(grantId);
             if (!grant)
                 return undefined;
-            const activeOrg = readActiveOrgFromKoaCtx(ctx);
+            // `appKey` é obrigatória aqui: o host grava o cookie de org via
+            // `ctx.response.cookie` e o Adonis o ASSINA (`s:<b64>.<hmac>`). Sem a chave
+            // não há como verificar a assinatura e o valor é recusado — foi assim que a
+            // org deixou de chegar ao token quando o usuário ativava a org DEPOIS do
+            // primeiro login (o consent só roda uma vez por grant; quem reconcilia é
+            // este hook, e ele roda no ctx Koa).
+            const activeOrg = readActiveOrgFromKoaCtx(ctx, { appKey: options.appKey });
             const current = normalizeActiveOrg(grant.activeOrg);
             const changed = (activeOrg?.orgId ?? null) !== (current?.orgId ?? null) ||
                 (activeOrg?.orgSlug ?? null) !== (current?.orgSlug ?? null) ||

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

@@ -3,6 +3,12 @@ export interface InteractionDeps {
     verifyCredentials?: (email: string, password: string) => Promise<{
         id: string;
     } | null>;
+    /**
+     * Chave do app, usada para VERIFICAR o cookie de org ativa quando o ctx recebido
+     * é um Koa ctx (o caminho Adonis já desassina sozinho). Sem ela, um cookie
+     * assinado é recusado — e a org não entra no Grant.
+     */
+    appKey?: string;
 }
 /** Detalhes opcionais de login (step-up auth): acr alcançado + amr (métodos). */
 export interface CompleteLoginExtra {

package/build/src/provider/interaction_actions.js

@@ -56,7 +56,7 @@ export function createInteractionActions(provider, deps) {
             // disponível AQUI — ao contrário do mint do id_token no /token, que é
             // server-a-servidor e não carrega os cookies do usuário. Persistimos a org
             // no Grant para que o fluxo authorization code volte a emitir org_*.
-            const activeOrg = readActiveOrgFromHostCtx(ctx);
+            const activeOrg = readActiveOrgFromHostCtx(ctx, { appKey: deps.appKey });
             const grant = new provider.Grant({
                 accountId: details.session.accountId,
                 clientId: details.params.client_id,

package/build/src/provider/oidc_service.js

@@ -190,6 +190,7 @@ export class OidcService {
         }
         const interactions = createInteractionActions(provider, {
             verifyCredentials: config.verifyCredentials,
+            appKey: this.#appKey,
         });
         // Atribuição atômica no final: um throw antes deste ponto não corrompe o estado.
         this.#provider = provider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.68.2",
+  "version": "0.68.4",
   "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",