@adonis-agora/authkit-server 1.0.0-rc.1 → 1.0.0-rc.11

package/build/src/agents/poppy/resource.js

@@ -1,129 +0,0 @@
-import { getBootedApp } from '../../../services/booted_app.js';
-import { buildPersonalAgentsRuntime, personalAgentsFor } from '../runtime.js';
-/** Símbolo do slot global de autenticação Poppy. */
-export const POPPY_AUTHENTICATE_SLOT = Symbol.for('@adonis-agora/poppy:authenticate');
-/** URL pública da request: atrás de proxy TLS, o esquema segue o do issuer. */
-export function publicRequestUrl(ctx, poppy) {
-    const url = new URL(ctx.request.completeUrl(false));
-    if (new URL(poppy.urls.origin).protocol === 'https:' && url.protocol === 'http:') {
-        url.protocol = 'https:';
-    }
-    return url.toString();
-}
-function requestFromCtx(ctx, poppy) {
-    return {
-        method: ctx.request.method(),
-        url: publicRequestUrl(ctx, poppy),
-        headers: ctx.request.headers(),
-    };
-}
-const NOT_ENABLED = {
-    ok: false,
-    status: 400,
-    error: 'invalid_session',
-    description: 'Poppy is not enabled',
-    wwwAuthenticate: null,
-    headers: {},
-};
-async function verifyWith(poppy, input, options) {
-    const result = await poppy.verifyAccess(input, options);
-    if (!result.ok) {
-        const { ok: _ok, ...rest } = result;
-        return { ok: false, ...rest };
-    }
-    const principal = { ...result.principal };
-    if (poppy.cfg.toActor)
-        principal.actor = await poppy.cfg.toActor(result.principal);
-    return { ok: true, principal };
-}
-async function poppyFromBootedApp() {
-    const app = getBootedApp();
-    const service = await app.container.make('authkit.server');
-    const runtime = await buildPersonalAgentsRuntime(service, () => app.container.make('lucid.db'), { make: (binding) => app.container.make(binding) });
-    return runtime?.poppy ?? null;
-}
-/**
- * Verifica o header `Poppy-Session` de uma request e, se houver, o access token. Aceita o
- * `HttpContext` ou `{ method, url, headers }`.
- *
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — acompanha a spec em desenvolvimento e PODE MUDAR
- *   de forma incompatível fora de majors enquanto ela for draft.
- */
-export async function verifyPoppyRequest(input, options = {}) {
-    if ('request' in input && typeof input.request?.method === 'function') {
-        const ctx = input;
-        const poppy = (await personalAgentsFor(ctx))?.poppy;
-        if (!poppy)
-            return NOT_ENABLED;
-        return verifyWith(poppy, requestFromCtx(ctx, poppy), options);
-    }
-    const poppy = await poppyFromBootedApp();
-    if (!poppy)
-        return NOT_ENABLED;
-    return verifyWith(poppy, input, options);
-}
-/** Escreve a resposta de erro de um {@link PoppyAuthResult} recusado. */
-export function writePoppyAuthError(ctx, result) {
-    if (result.wwwAuthenticate)
-        ctx.response.header('WWW-Authenticate', result.wwwAuthenticate);
-    for (const [k, v] of Object.entries(result.headers))
-        ctx.response.header(k, v);
-    ctx.response.header('Cache-Control', 'no-store');
-    // Erros do access token vão no header, como no OAuth; `invalid_session` vai no corpo (§7).
-    if (result.error !== 'invalid_session')
-        return ctx.response.status(result.status).send('');
-    return ctx.response
-        .status(result.status)
-        .json({ error: result.error, error_description: result.description });
-}
-/** Guardado fora do `HttpContext` (sem augmentation — ver `augmentation_isolation.spec.ts`). */
-const principals = new WeakMap();
-/**
- * O principal Poppy da request — preenchido por {@link poppyAuth}.
- *
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — acompanha a spec em desenvolvimento e PODE MUDAR
- *   de forma incompatível fora de majors enquanto ela for draft.
- */
-export function poppyOf(ctx) {
-    return principals.get(ctx) ?? null;
-}
-/**
- * Middleware das APIs/rotas que usam a Session Poppy.
- *
- * ```ts
- * router.post('/orders/:id/exchanges', [Orders, 'exchange'])
- *   .use(poppyAuth({ scopes: ['orders:write'] }))
- * ```
- *
- * Isente essas rotas do CSRF (são chamadas por agentes, sem navegador).
- *
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — acompanha a spec em desenvolvimento e PODE MUDAR
- *   de forma incompatível fora de majors enquanto ela for draft.
- */
-export function poppyAuth(options = {}) {
-    return async (ctx, next) => {
-        const result = await verifyPoppyRequest(ctx, options);
-        if (!result.ok)
-            return writePoppyAuthError(ctx, result);
-        principals.set(ctx, result.principal);
-        return next();
-    };
-}
-/**
- * Publica o slot global `Symbol.for('@adonis-agora/poppy:authenticate')` (e
- * `Symbol.for('@adonis-agora/poppy:issuer')`). Chamado no boot do provider
- * quando `personalAgents.poppy` está no config.
- *
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — acompanha a spec em desenvolvimento e PODE MUDAR
- *   de forma incompatível fora de majors enquanto ela for draft.
- */
-export function installPoppySlots(issuer) {
-    const slot = globalThis;
-    const authenticate = (request, options) => verifyPoppyRequest({
-        method: request.method,
-        url: request.url,
-        headers: request.headers ?? {},
-    }, options);
-    slot[POPPY_AUTHENTICATE_SLOT] = authenticate;
-    slot[Symbol.for('@adonis-agora/poppy:issuer')] = issuer;
-}

package/build/src/agents/poppy/safe_fetch.d.ts

@@ -1,48 +0,0 @@
-/**
- * `fetch` de documentos JSON de terceiros à prova de SSRF.
- *
- * O `client_id` de um agente Poppy é uma URL que QUALQUER um escolhe — buscá-la
- * sem cuidado faria deste app um proxy para a rede interna. Regras:
- *  - só `https:`; sem credenciais na URL; porta qualquer;
- *  - o IP é conferido NA CONEXÃO (o `lookup` do socket), não num DNS separado —
- *    sem janela para DNS rebinding; loopback, privados, link-local, CGNAT,
- *    multicast, reservados e os equivalentes IPv6 são recusados;
- *  - IP literal na URL passa pela mesma regra;
- *  - sem redirects (o `client_id` tem de ser exatamente a URL buscada);
- *  - teto de tempo e de bytes.
- */
-import { type LookupAddress } from 'node:dns';
-export declare class SafeFetchError extends Error {
-    constructor(message: string);
-}
-export interface FetchedJson {
-    status: number;
-    body: unknown;
-    /** `max-age` do `Cache-Control`, em segundos, quando há. */
-    maxAge: number | null;
-}
-/** Busca um JSON (GET). Lança {@link SafeFetchError} em qualquer recusa. */
-export type JsonFetcher = (url: string) => Promise<FetchedJson>;
-export type LookupFn = (hostname: string, options: {
-    all: true;
-}, callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void) => void;
-export interface SafeFetchOptions {
-    timeoutMs?: number;
-    maxBytes?: number;
-    /** Resolução de nomes — injetável nos testes. Default: `dns.lookup`. */
-    lookup?: LookupFn;
-}
-/** `true` quando o IP não pode ser alvo de uma busca de saída. */
-export declare function isBlockedAddress(ip: string): boolean;
-/**
- * Busca `url` e devolve o JSON. Só HTTPS, sem redirect, IP público conferido na
- * conexão, `timeoutMs` (default 5 s) e `maxBytes` (default 64 KiB).
- */
-export declare function safeFetchJson(url: string, options?: SafeFetchOptions): Promise<FetchedJson>;
-/**
- * SÓ DEV/TESTE (`personalAgents.poppy.allowInsecureClientIds`): busca um JSON por
- * `http:` ou `https:` SEM a guarda de SSRF — loopback e rede privada liberados,
- * para um agente local (`http://localhost:7777/agent.json`). Mantém sem redirect,
- * teto de tempo e de bytes. Nunca use em produção (a config recusa).
- */
-export declare function insecureDevFetchJson(url: string, options?: Omit<SafeFetchOptions, 'lookup'>): Promise<FetchedJson>;

package/build/src/agents/poppy/safe_fetch.js

@@ -1,262 +0,0 @@
-/**
- * `fetch` de documentos JSON de terceiros à prova de SSRF.
- *
- * O `client_id` de um agente Poppy é uma URL que QUALQUER um escolhe — buscá-la
- * sem cuidado faria deste app um proxy para a rede interna. Regras:
- *  - só `https:`; sem credenciais na URL; porta qualquer;
- *  - o IP é conferido NA CONEXÃO (o `lookup` do socket), não num DNS separado —
- *    sem janela para DNS rebinding; loopback, privados, link-local, CGNAT,
- *    multicast, reservados e os equivalentes IPv6 são recusados;
- *  - IP literal na URL passa pela mesma regra;
- *  - sem redirects (o `client_id` tem de ser exatamente a URL buscada);
- *  - teto de tempo e de bytes.
- */
-import { lookup as dnsLookup } from 'node:dns';
-import { request as httpsRequest } from 'node:https';
-import { isIP } from 'node:net';
-export class SafeFetchError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'SafeFetchError';
-    }
-}
-function ipv4ToInt(ip) {
-    return ip.split('.').reduce((acc, part) => (acc << 8) + Number(part), 0) >>> 0;
-}
-function inV4(ip, cidr) {
-    const [base, bits] = cidr.split('/');
-    const mask = Number(bits) === 0 ? 0 : (~0 << (32 - Number(bits))) >>> 0;
-    return (ip & mask) === (ipv4ToInt(base) & mask);
-}
-const BLOCKED_V4 = [
-    '0.0.0.0/8',
-    '10.0.0.0/8',
-    '100.64.0.0/10',
-    '127.0.0.0/8',
-    '169.254.0.0/16',
-    '172.16.0.0/12',
-    '192.0.0.0/24',
-    '192.0.2.0/24',
-    '192.88.99.0/24',
-    '192.168.0.0/16',
-    '198.18.0.0/15',
-    '198.51.100.0/24',
-    '203.0.113.0/24',
-    '224.0.0.0/4',
-    '240.0.0.0/4',
-];
-/** Expande um IPv6 em 8 grupos de 16 bits. */
-function ipv6Groups(ip) {
-    let addr = ip.toLowerCase().split('%')[0];
-    // Sufixo IPv4 (::ffff:1.2.3.4).
-    const v4 = /(\d+\.\d+\.\d+\.\d+)$/.exec(addr);
-    if (v4) {
-        const n = ipv4ToInt(v4[1]);
-        addr = `${addr.slice(0, -v4[1].length)}${(n >>> 16).toString(16)}:${(n & 0xffff).toString(16)}`;
-    }
-    const [head, tail] = addr.split('::');
-    const h = head ? head.split(':') : [];
-    const t = tail !== undefined ? (tail ? tail.split(':') : []) : [];
-    const fill = addr.includes('::') ? 8 - h.length - t.length : 0;
-    const groups = [...h, ...Array(fill).fill('0'), ...t].map((g) => Number.parseInt(g || '0', 16));
-    return groups.length === 8 && groups.every((g) => g >= 0 && g <= 0xffff) ? groups : null;
-}
-/** `true` quando o IP não pode ser alvo de uma busca de saída. */
-export function isBlockedAddress(ip) {
-    const family = isIP(ip);
-    if (family === 4) {
-        const n = ipv4ToInt(ip);
-        return BLOCKED_V4.some((cidr) => inV4(n, cidr));
-    }
-    if (family !== 6)
-        return true;
-    const g = ipv6Groups(ip);
-    if (!g)
-        return true;
-    if (g.every((x) => x === 0))
-        return true; // ::
-    if (g.slice(0, 7).every((x) => x === 0) && g[7] === 1)
-        return true; // ::1
-    // IPv4-translated (::ffff:0:a.b.c.d) e NAT64 (64:ff9b::a.b.c.d) também chegam a um IPv4.
-    const translated = g.slice(0, 4).every((x) => x === 0) && g[4] === 0xffff && g[5] === 0;
-    const nat64 = g[0] === 0x64 && g[1] === 0xff9b && g.slice(2, 6).every((x) => x === 0);
-    if (translated || nat64) {
-        return isBlockedAddress(`${g[6] >> 8}.${g[6] & 255}.${g[7] >> 8}.${g[7] & 255}`);
-    }
-    // IPv4-mapped (::ffff:a.b.c.d) e IPv4-compatible: decide pelo IPv4.
-    if (g.slice(0, 5).every((x) => x === 0) && (g[5] === 0xffff || g[5] === 0)) {
-        const v4 = `${g[6] >> 8}.${g[6] & 255}.${g[7] >> 8}.${g[7] & 255}`;
-        return isBlockedAddress(v4);
-    }
-    if ((g[0] & 0xfe00) === 0xfc00)
-        return true; // fc00::/7 (ULA)
-    if ((g[0] & 0xffc0) === 0xfe80)
-        return true; // fe80::/10 (link-local)
-    if ((g[0] & 0xffc0) === 0xfec0)
-        return true; // fec0::/10 (site-local)
-    if ((g[0] & 0xff00) === 0xff00)
-        return true; // ff00::/8 (multicast)
-    if (g[0] === 0x2001 && g[1] === 0x0db8)
-        return true; // 2001:db8::/32 (doc)
-    if (g[0] === 0x64 && g[1] === 0xff9b)
-        return true; // 64:ff9b::/96 (NAT64)
-    if (g[0] === 0x2002) {
-        // 6to4: o IPv4 embutido.
-        return isBlockedAddress(`${g[1] >> 8}.${g[1] & 255}.${g[2] >> 8}.${g[2] & 255}`);
-    }
-    return false;
-}
-function parseMaxAge(header) {
-    const value = Array.isArray(header) ? header.join(',') : header;
-    if (!value)
-        return null;
-    if (/\bno-store\b|\bno-cache\b/i.test(value))
-        return 0;
-    const match = /\bmax-age=(\d+)/i.exec(value);
-    return match ? Number(match[1]) : null;
-}
-/**
- * Busca `url` e devolve o JSON. Só HTTPS, sem redirect, IP público conferido na
- * conexão, `timeoutMs` (default 5 s) e `maxBytes` (default 64 KiB).
- */
-export function safeFetchJson(url, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 5000;
-    const maxBytes = options.maxBytes ?? 64 * 1024;
-    const resolve = options.lookup ?? dnsLookup;
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        return Promise.reject(new SafeFetchError('invalid URL'));
-    }
-    if (parsed.protocol !== 'https:')
-        return Promise.reject(new SafeFetchError('only https URLs'));
-    if (parsed.username || parsed.password) {
-        return Promise.reject(new SafeFetchError('credentials in URL'));
-    }
-    const host = parsed.hostname.replace(/^\[|\]$/g, '');
-    if (isIP(host) && isBlockedAddress(host)) {
-        return Promise.reject(new SafeFetchError('blocked address'));
-    }
-    // `lookup` do socket: resolve e recusa se QUALQUER endereço for interno.
-    const guardedLookup = (hostname, opts, callback) => {
-        resolve(hostname, { all: true }, (err, addresses) => {
-            if (err)
-                return callback(err);
-            const list = addresses ?? [];
-            if (list.length === 0)
-                return callback(new SafeFetchError('no address'));
-            if (list.some((a) => isBlockedAddress(a.address))) {
-                return callback(new SafeFetchError('blocked address'));
-            }
-            if (opts?.all)
-                return callback(null, list);
-            return callback(null, list[0].address, list[0].family);
-        });
-    };
-    return new Promise((done, reject) => {
-        let settled = false;
-        const finish = (fn) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            fn();
-        };
-        const req = httpsRequest(parsed, {
-            method: 'GET',
-            headers: { accept: 'application/json', 'user-agent': 'authkit-poppy/0.3' },
-            lookup: guardedLookup,
-            // IP literal: o `lookup` não roda — já conferido acima.
-        }, (res) => {
-            const status = res.statusCode ?? 0;
-            if (status >= 300 && status < 400) {
-                res.resume();
-                return finish(() => reject(new SafeFetchError('redirects are not followed')));
-            }
-            const chunks = [];
-            let size = 0;
-            res.on('data', (chunk) => {
-                size += chunk.length;
-                if (size > maxBytes) {
-                    req.destroy();
-                    finish(() => reject(new SafeFetchError('response too large')));
-                    return;
-                }
-                chunks.push(chunk);
-            });
-            res.on('end', () => finish(() => {
-                if (status !== 200)
-                    return reject(new SafeFetchError(`HTTP ${status}`));
-                try {
-                    done({
-                        status,
-                        body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
-                        maxAge: parseMaxAge(res.headers['cache-control']),
-                    });
-                }
-                catch {
-                    reject(new SafeFetchError('invalid JSON'));
-                }
-            }));
-            res.on('error', (e) => finish(() => reject(new SafeFetchError(e.message))));
-        });
-        const timer = setTimeout(() => {
-            req.destroy();
-            finish(() => reject(new SafeFetchError('timeout')));
-        }, timeoutMs);
-        req.on('error', (e) => finish(() => reject(e instanceof SafeFetchError ? e : new SafeFetchError(e.message))));
-        req.end();
-    });
-}
-/**
- * SÓ DEV/TESTE (`personalAgents.poppy.allowInsecureClientIds`): busca um JSON por
- * `http:` ou `https:` SEM a guarda de SSRF — loopback e rede privada liberados,
- * para um agente local (`http://localhost:7777/agent.json`). Mantém sem redirect,
- * teto de tempo e de bytes. Nunca use em produção (a config recusa).
- */
-export async function insecureDevFetchJson(url, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 5000;
-    const maxBytes = options.maxBytes ?? 64 * 1024;
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        throw new SafeFetchError('invalid URL');
-    }
-    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
-        throw new SafeFetchError('only http(s) URLs');
-    }
-    if (parsed.username || parsed.password)
-        throw new SafeFetchError('credentials in URL');
-    let res;
-    try {
-        res = await fetch(parsed, {
-            redirect: 'manual',
-            headers: { accept: 'application/json', 'user-agent': 'authkit-poppy/0.3 (insecure-dev)' },
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-    }
-    catch (error) {
-        throw new SafeFetchError(error.name === 'TimeoutError' ? 'timeout' : 'unreachable');
-    }
-    if (res.status >= 300 && res.status < 400)
-        throw new SafeFetchError('redirects are not followed');
-    const buf = Buffer.from(await res.arrayBuffer());
-    if (buf.length > maxBytes)
-        throw new SafeFetchError('response too large');
-    if (res.status !== 200)
-        throw new SafeFetchError(`HTTP ${res.status}`);
-    try {
-        return {
-            status: res.status,
-            body: JSON.parse(buf.toString('utf8')),
-            maxAge: parseMaxAge(res.headers.get('cache-control') ?? undefined),
-        };
-    }
-    catch {
-        throw new SafeFetchError('invalid JSON');
-    }
-}