ima2-gen 3.13.1 → 3.14.0

package/lib/localAccessPolicy.js

@@ -0,0 +1,180 @@
+import { isIP } from "node:net";
+import { posix } from "node:path";
+const MAX_PUBLIC_ORIGINS = 16;
+const MESSAGES = {
+    INVALID_PUBLIC_ORIGINS: "Invalid public origins configuration",
+    LOCAL_HOST_REJECTED: "Request host is not allowed",
+    LOCAL_ORIGIN_REJECTED: "Request origin is not allowed",
+    LOCAL_PATH_REJECTED: "Request path is not allowed",
+    LAN_TOKEN_REQUIRED: "A valid IMA2 LAN token is required",
+    INVALID_LAN_TOKEN: "Invalid LAN token configuration",
+    LAN_SESSION_CAPACITY: "LAN session capacity reached",
+    LAN_SESSION_UNAVAILABLE: "LAN sessions are unavailable",
+    LAN_AUTH_RATE_LIMITED: "Too many LAN authentication attempts",
+    LAN_SESSION_BODY_INVALID: "Expected an empty JSON object",
+    LAN_SESSION_CONTENT_TYPE: "Content type must be application/json",
+};
+export function localAccessError(code, status = 403) {
+    return Object.assign(new Error(MESSAGES[code]), { code, status });
+}
+function parseOrigin(value) {
+    if (typeof value !== "string" || /[\s\\*@?#]/u.test(value) || !/^https?:\/\/[^/]+\/?$/i.test(value))
+        throw new Error();
+    const url = new URL(value);
+    if (!/^https?:\/\//i.test(value) || !["http:", "https:"].includes(url.protocol)
+        || url.username || url.password || !url.hostname || url.pathname !== "/")
+        throw new Error();
+    return url.origin;
+}
+export function parsePublicOrigins(value) {
+    try {
+        if (!Array.isArray(value) || value.length > MAX_PUBLIC_ORIGINS)
+            throw new Error();
+        const origins = [...new Set(value.map(parseOrigin))];
+        if (origins.some((origin, index) => origins.slice(index + 1).some(other => hostMatches(new URL(origin).host, other) || hostMatches(new URL(other).host, origin))))
+            throw new Error();
+        return Object.freeze(origins);
+    }
+    catch {
+        throw localAccessError("INVALID_PUBLIC_ORIGINS", 500);
+    }
+}
+export function isLocalBind(host) {
+    return ["127.0.0.1", "::1", "localhost"].includes(String(host || "").trim().toLowerCase());
+}
+/** rawHeaders is authoritative for duplicates Node may otherwise discard/join. */
+export function singleHeader(req, name, code) {
+    const values = [];
+    for (let i = 0; i < req.rawHeaders.length; i += 2) {
+        if (req.rawHeaders[i]?.toLowerCase() === name)
+            values.push(req.rawHeaders[i + 1] ?? "");
+    }
+    const value = req.headers[name];
+    if (values.length > 1 || Array.isArray(value))
+        throw localAccessError(code, code === "LAN_TOKEN_REQUIRED" ? 401 : 403);
+    return values[0] ?? value;
+}
+function literalHost(address) {
+    const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/i.exec(address);
+    if (mapped)
+        return mapped[1];
+    const hex = /^::ffff:([\da-f]{1,4}):([\da-f]{1,4})$/i.exec(address);
+    if (hex) {
+        const high = parseInt(hex[1], 16), low = parseInt(hex[2], 16);
+        return `${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`;
+    }
+    return isIP(address) === 6 ? `[${address}]` : address;
+}
+function servingOrigins(req, host, publicOrigins) {
+    const origins = new Map();
+    const port = req.socket.localPort;
+    const scheme = req.socket.encrypted ? "https" : "http";
+    const add = (hostname) => {
+        if (!port || !hostname)
+            return;
+        const url = new URL(`${scheme}://${hostname}:${port}`);
+        origins.set(url.host, url.origin);
+    };
+    const address = req.socket.localAddress;
+    if (address && isIP(address))
+        add(literalHost(address));
+    if (isLocalBind(host) || ["0.0.0.0", "::"].includes(host)) {
+        for (const alias of ["localhost", "127.0.0.1", "[::1]"])
+            add(alias);
+    }
+    if (host && !["0.0.0.0", "::"].includes(host))
+        add(literalHost(host));
+    for (const origin of publicOrigins) {
+        for (const [authority, inferred] of origins) {
+            if (hostMatches(authority, origin) || hostMatches(new URL(origin).host, inferred))
+                origins.delete(authority);
+        }
+        origins.set(new URL(origin).host, origin);
+    }
+    return [...origins.values()];
+}
+function hostMatches(host, origin) {
+    const url = new URL(origin);
+    return new URL(`${url.protocol}//${host}`).host === url.host;
+}
+export function createLocalAccessPolicy(config) {
+    const publicOrigins = parsePublicOrigins(config.server.publicOrigins);
+    const host = config.server.host.trim().toLowerCase();
+    return {
+        resolveHost(req) {
+            const hostOnly = Object.create(req);
+            hostOnly.headers = { ...req.headers };
+            delete hostOnly.headers.origin;
+            hostOnly.rawHeaders = req.rawHeaders.flatMap((value, i, all) => i % 2 === 0 && value.toLowerCase() !== "origin" ? [value, all[i + 1]] : []);
+            return this.resolveOrigin(hostOnly);
+        },
+        resolveOrigin(req) {
+            const authority = singleHeader(req, "host", "LOCAL_HOST_REJECTED");
+            if (!authority || !/^(?:\[[\da-fA-F:]+\]|[a-zA-Z0-9.-]+)(?::\d+)?$/.test(authority)) {
+                throw localAccessError("LOCAL_HOST_REJECTED");
+            }
+            let candidates;
+            try {
+                candidates = servingOrigins(req, host, publicOrigins).filter(origin => hostMatches(authority, origin));
+            }
+            catch {
+                throw localAccessError("LOCAL_HOST_REJECTED");
+            }
+            if (!candidates.length)
+                throw localAccessError("LOCAL_HOST_REJECTED");
+            const supplied = singleHeader(req, "origin", "LOCAL_ORIGIN_REJECTED");
+            if (supplied === undefined)
+                return candidates[0];
+            let origin;
+            try {
+                origin = parseOrigin(supplied);
+            }
+            catch {
+                throw localAccessError("LOCAL_ORIGIN_REJECTED");
+            }
+            if (!candidates.includes(origin))
+                throw localAccessError("LOCAL_ORIGIN_REJECTED");
+            return origin;
+        },
+        checkBrowserRequest(req, origin, viaCookie) {
+            const site = singleHeader(req, "sec-fetch-site", "LOCAL_ORIGIN_REJECTED");
+            if (site && site !== "same-origin" && site !== "none")
+                throw localAccessError("LOCAL_ORIGIN_REJECTED");
+            const supplied = singleHeader(req, "origin", "LOCAL_ORIGIN_REJECTED");
+            if (supplied !== undefined) {
+                try {
+                    if (parseOrigin(supplied) !== origin)
+                        throw new Error();
+                }
+                catch {
+                    throw localAccessError("LOCAL_ORIGIN_REJECTED");
+                }
+            }
+            else if (viaCookie && !["GET", "HEAD", "OPTIONS"].includes(req.method)) {
+                throw localAccessError("LOCAL_ORIGIN_REJECTED");
+            }
+        },
+    };
+}
+/** Inspect the original full path even when called under an Express mount. */
+export function protectedRequestPath(req) {
+    const raw = (req.originalUrl || req.url).split("?")[0] || "/";
+    let decoded;
+    try {
+        decoded = decodeURIComponent(raw);
+    }
+    catch {
+        throw localAccessError("LOCAL_PATH_REJECTED", 400);
+    }
+    const path = posix.normalize(decoded.replace(/\\/g, "/")).toLowerCase();
+    // Keep every protected interpretation, including a raw protected path whose
+    // dot segments escape the mount after normalization.
+    const candidates = [raw, decoded, path];
+    const api = candidates.some(candidate => /^\/api(?:\/|$)/i.test(candidate));
+    const media = candidates.some(candidate => /^\/generated(?:\/|$)/i.test(candidate));
+    const canonical = /^\/(api|generated)(?:\/|$)/i.exec(raw);
+    const prefix = canonical?.[0];
+    const alias = (api || media) && (!prefix || path !== decoded.toLowerCase()
+        || /[%\\\0]/.test(raw.slice(0, prefix.length)));
+    return { api, media, alias, path };
+}

package/lib/localLanAccess.js

@@ -0,0 +1,281 @@
+import express from "express";
+import { createHash, timingSafeEqual } from "node:crypto";
+import { createLocalAccessPolicy, isLocalBind, localAccessError, protectedRequestPath, singleHeader } from "./localAccessPolicy.js";
+import { createLanAuthThrottle, createLanSessionStore } from "./lanSessionStore.js";
+const SESSION_PATH = /^\/api\/auth\/lan\/session$/i;
+const CALLBACK_PATH = "/api/mcp/oauth/callback";
+const BOOTSTRAP_BODY_BYTES = 1024;
+const COMPAT_TOKEN_MAX_BYTES = 4096;
+function tokenMatches(value, expected) {
+    if (value === undefined || !expected)
+        return false;
+    const actual = Buffer.from(value), wanted = Buffer.from(expected);
+    return actual.length === wanted.length && timingSafeEqual(actual, wanted);
+}
+function cookieName(origin) {
+    const suffix = createHash("sha256").update(origin).digest("hex").slice(0, 12);
+    return `${origin.startsWith("https:") ? "__Host-" : ""}ima2_lan_${suffix}`;
+}
+function cookieOptions(origin) {
+    return { path: "/", httpOnly: true, sameSite: "strict", secure: origin.startsWith("https:") };
+}
+function readCredentials(req, name, maxBytes) {
+    const header = singleHeader(req, "x-ima2-token", "LAN_TOKEN_REQUIRED");
+    const params = new URLSearchParams((req.originalUrl || req.url).split("?").slice(1).join("?"));
+    const queries = params.getAll("token");
+    const invalidQuery = [...params.keys()].some(key => /^token[\[.]/.test(key));
+    if (queries.length > 1 || invalidQuery)
+        throw localAccessError("LAN_TOKEN_REQUIRED", 401);
+    const query = queries[0];
+    const cookies = name ? req.headers.cookie?.split(";").map(part => part.trim()) ?? [] : [];
+    const matches = cookies.filter(part => part.split("=")[0] === name);
+    if (matches.length > 1)
+        throw localAccessError("LAN_TOKEN_REQUIRED", 401);
+    const cookie = matches[0]?.slice(name.length + 1);
+    for (const value of [header, query, cookie]) {
+        if (value !== undefined && Buffer.byteLength(value) > maxBytes)
+            throw localAccessError("LAN_TOKEN_REQUIRED", 401);
+    }
+    if (cookie !== undefined && !/^[\w-]{43}$/.test(cookie)) {
+        throw localAccessError("LAN_TOKEN_REQUIRED", 401);
+    }
+    return { header, query, cookie, explicit: header ?? query };
+}
+function sendAccessError(res, error) {
+    const safe = error;
+    const known = typeof safe?.code === "string" && typeof safe?.status === "number";
+    if (!res.getHeader("Cache-Control"))
+        res.setHeader("Cache-Control", "no-store");
+    res.status(known ? safe.status : 503).type("application/json").end(JSON.stringify({ error: {
+            code: known ? safe.code : "LAN_SESSION_UNAVAILABLE",
+            message: known ? safe.message : "LAN sessions are unavailable",
+        } }));
+}
+function privateMediaHeaders(res) {
+    res.setHeader("Cache-Control", "private, no-store, max-age=0");
+    res.vary("Cookie");
+    res.vary("X-Ima2-Token");
+    res.setHeader("Referrer-Policy", "no-referrer");
+    res.setHeader("Cross-Origin-Resource-Policy", "same-origin");
+}
+function trackResponse(store, value, res) {
+    const untrack = store.track(value, () => { res.end(); });
+    const cleanup = () => {
+        untrack();
+        res.off("finish", cleanup);
+        res.off("close", cleanup);
+    };
+    res.once("finish", cleanup);
+    res.once("close", cleanup);
+    if (res.writableEnded || res.destroyed)
+        cleanup();
+}
+/** Compatibility-only token guard. Production uses the shared policy instance. */
+export function createLanApiGuard(host, token) {
+    const expected = isLocalBind(host) ? "" : token || "";
+    return (req, res, next) => {
+        try {
+            if (!expected || !/^\/api(?:\/|$)/i.test(req.path))
+                return next();
+            if (req.method === "GET" && req.path.toLowerCase() === CALLBACK_PATH)
+                return next();
+            const credentials = readCredentials(req, "", COMPAT_TOKEN_MAX_BYTES);
+            if (!tokenMatches(credentials.explicit, expected))
+                throw localAccessError("LAN_TOKEN_REQUIRED", 401);
+            next();
+        }
+        catch (error) {
+            sendAccessError(res, error);
+        }
+    };
+}
+class LocalLanAccess {
+    policy;
+    lan;
+    token;
+    bounds;
+    store;
+    throttle;
+    tracked = new WeakSet();
+    sessionState = new WeakMap();
+    constructor(ctx) {
+        this.policy = createLocalAccessPolicy(ctx.config);
+        this.lan = !isLocalBind(ctx.config.server.host);
+        this.token = ctx.config.server.lanToken;
+        this.bounds = ctx.config.security;
+        const { lan, token, bounds } = this;
+        if ((lan && !token) || Buffer.byteLength(token) > bounds.lanTokenMaxBytes)
+            throw localAccessError("INVALID_LAN_TOKEN", 500);
+        this.store = createLanSessionStore({ ttlMs: bounds.lanSessionTtlMs, maxSessions: bounds.lanMaxSessions });
+        this.throttle = createLanAuthThrottle({ windowMs: bounds.lanAuthWindowMs, maxFailures: bounds.lanAuthMaxFailures, maxBuckets: bounds.lanAuthMaxBuckets });
+    }
+    mediaHeaders = (req, res, next) => {
+        // The canonical raw prefix still receives headers when its tail has bad escapes.
+        try {
+            if (this.lan && protectedRequestPath(req).media)
+                privateMediaHeaders(res);
+        }
+        catch {
+            const prefix = (req.originalUrl || req.url).replace(/%([\da-f]{2})/ig, (_match, hex) => String.fromCharCode(parseInt(hex, 16)));
+            if (this.lan && /^\/generated(?:[\/\\]|$)/i.test(prefix))
+                privateMediaHeaders(res);
+        }
+        next();
+    };
+    guard = (req, res, next) => {
+        try {
+            const { policy, lan, bounds } = this;
+            const route = protectedRequestPath(req);
+            if (!route.api && !route.media)
+                return next();
+            if (route.alias)
+                throw localAccessError("LOCAL_PATH_REJECTED", 400);
+            const rawPath = (req.originalUrl || req.url).split("?")[0]?.toLowerCase();
+            if (req.method === "GET" && rawPath === CALLBACK_PATH) {
+                policy.resolveHost(req);
+                return next();
+            }
+            const origin = policy.resolveOrigin(req);
+            const credentials = lan ? readCredentials(req, cookieName(origin), bounds.lanTokenMaxBytes) : null;
+            const viaCookie = !!credentials?.cookie && credentials.explicit === undefined;
+            policy.checkBrowserRequest(req, origin, viaCookie);
+            if (credentials)
+                this.authorize(credentials, origin, res, req.socket.remoteAddress || "unknown");
+            if (!res.writableEnded && !res.destroyed)
+                next();
+        }
+        catch (error) {
+            sendAccessError(res, error);
+        }
+    };
+    checkTokenCooldown(peer, res) {
+        const retry = this.throttle.retryAfter(peer);
+        if (retry) {
+            res.setHeader("Retry-After", String(retry));
+            throw localAccessError("LAN_AUTH_RATE_LIMITED", 429);
+        }
+    }
+    validateToken(value, peer) {
+        if (tokenMatches(value, this.token))
+            return;
+        this.throttle.fail(peer);
+        throw localAccessError("LAN_TOKEN_REQUIRED", 401);
+    }
+    authorize(credentials, origin, res, peer) {
+        const { store, tracked } = this;
+        if (credentials.explicit !== undefined) {
+            this.checkTokenCooldown(peer, res);
+            this.validateToken(credentials.explicit, peer);
+            return;
+        }
+        if (!credentials.cookie || !store.validate(credentials.cookie, origin))
+            throw localAccessError("LAN_TOKEN_REQUIRED", 401);
+        if (!tracked.has(res)) {
+            tracked.add(res);
+            trackResponse(store, credentials.cookie, res);
+        }
+    }
+    sessionCheck(req, res) {
+        const { policy, lan, bounds, throttle } = this;
+        res.setHeader("Cache-Control", "no-store");
+        res.setHeader("Referrer-Policy", "no-referrer");
+        res.setHeader("Content-Security-Policy", "frame-ancestors 'none'");
+        const origin = policy.resolveOrigin(req);
+        policy.checkBrowserRequest(req, origin, false);
+        if (req.method !== "GET" && !singleHeader(req, "origin", "LOCAL_ORIGIN_REJECTED"))
+            throw localAccessError("LOCAL_ORIGIN_REJECTED");
+        const peer = req.socket.remoteAddress || "unknown";
+        if (lan && req.method === "POST")
+            this.checkTokenCooldown(peer, res);
+        let credentials;
+        try {
+            credentials = lan ? readCredentials(req, cookieName(origin), bounds.lanTokenMaxBytes) : { header: undefined, query: undefined, cookie: undefined, explicit: undefined };
+        }
+        catch (error) {
+            if (lan && req.method === "POST")
+                throttle.fail(peer);
+            throw error;
+        }
+        if (lan && req.method === "POST")
+            this.validateToken(credentials.header, peer);
+        if (lan && req.method === "GET" && credentials.explicit !== undefined) {
+            this.checkTokenCooldown(peer, res);
+            this.validateToken(credentials.explicit, peer);
+        }
+        if (lan && req.method === "DELETE" && !credentials.cookie)
+            throw localAccessError("LAN_TOKEN_REQUIRED", 401);
+        return { origin, credentials };
+    }
+    sessionResult(req, res) {
+        const { sessionState, lan, store } = this;
+        const { origin, credentials } = sessionState.get(req);
+        if (req.method === "GET") {
+            const session = credentials.cookie ? store.validate(credentials.cookie, origin) : null;
+            res.json({ mode: lan ? "lan" : "local", authenticated: !lan || credentials.explicit !== undefined || !!session,
+                expiresAt: lan && credentials.explicit === undefined ? session?.expiresAt ?? null : null });
+            return;
+        }
+        if (req.method === "DELETE") {
+            if (lan) {
+                store.revoke(credentials.cookie);
+                res.clearCookie(cookieName(origin), cookieOptions(origin));
+            }
+            res.status(204).end();
+            return;
+        }
+        if (!req.body || Array.isArray(req.body) || typeof req.body !== "object" || Object.keys(req.body).length)
+            throw localAccessError("LAN_SESSION_BODY_INVALID", 400);
+        if (req.aborted || res.destroyed)
+            return;
+        if (lan) {
+            if (credentials.cookie && store.validate(credentials.cookie, origin))
+                store.revoke(credentials.cookie);
+            const session = store.issue(origin);
+            res.once("close", () => { if (!res.writableFinished)
+                store.revoke(session.value); });
+            try {
+                res.cookie(cookieName(origin), session.value, cookieOptions(origin));
+            }
+            catch {
+                store.revoke(session.value);
+                throw localAccessError("LAN_SESSION_UNAVAILABLE", 503);
+            }
+        }
+        res.status(204).end();
+    }
+    registerSessionRoutes(app, budget) {
+        const check = (req, res, next) => {
+            try {
+                if (!["GET", "POST", "DELETE"].includes(req.method))
+                    return next("route");
+                if (protectedRequestPath(req).alias)
+                    throw localAccessError("LOCAL_PATH_REJECTED", 400);
+                this.sessionState.set(req, this.sessionCheck(req, res));
+                next();
+            }
+            catch (error) {
+                sendAccessError(res, error);
+            }
+        };
+        const parser = express.json({ limit: BOOTSTRAP_BODY_BYTES, strict: true, inflate: false });
+        const body = (req, res, next) => {
+            if (req.method !== "POST")
+                return next();
+            if (!req.is("application/json"))
+                return sendAccessError(res, localAccessError("LAN_SESSION_CONTENT_TYPE", 415));
+            parser(req, res, error => error ? sendAccessError(res, localAccessError("LAN_SESSION_BODY_INVALID", 400)) : next());
+        };
+        app.all(SESSION_PATH, check, budget, body, (req, res) => {
+            try {
+                this.sessionResult(req, res);
+            }
+            catch (error) {
+                sendAccessError(res, error);
+            }
+        });
+    }
+    dispose = () => { this.store.dispose(); this.throttle.dispose(); };
+}
+export function createLocalLanAccess(ctx) {
+    return new LocalLanAccess(ctx);
+}

package/lib/logger.js

@@ -48,6 +48,17 @@ function shouldRedactKey(key) {
         lower.includes("base64") ||
         lower.includes("dataurl"));
 }
+function sanitizeLogString(value) {
+    const oneLine = value
+        .replace(/data:image\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi, "data:image/[redacted]")
+        .replace(/\b[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/gi, "[redacted-url]")
+        .replace(/(^|[\s("'<>=,\[{])\/\/[^\s"'<>]+/g, "$1[redacted-url]")
+        .replace(/Bearer\s+[^\s"'<>]+/gi, "Bearer [redacted]")
+        .replace(/([?&][^=\s?&#"'<>]+)=([^&\s"'<>]*)/g, "$1=[redacted]")
+        .replace(/\s+/g, " ")
+        .trim();
+    return oneLine.length > MAX_VALUE_LEN ? `${oneLine.slice(0, MAX_VALUE_LEN)}...` : oneLine;
+}
 function sanitizeValue(value) {
     if (value == null)
         return value;
@@ -59,25 +70,23 @@ function sanitizeValue(value) {
         return `[buffer:${value.length}]`;
     if (typeof value === "object")
         return "[object]";
-    if (typeof value === "string") {
-        const oneLine = value
-            .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]")
-            .replace(/data:image\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi, "data:image/[redacted]")
-            .replace(/\s+/g, " ")
-            .trim();
-        return oneLine.length > MAX_VALUE_LEN ? `${oneLine.slice(0, MAX_VALUE_LEN)}...` : oneLine;
-    }
+    if (typeof value === "string")
+        return sanitizeLogString(value);
     return value;
 }
 export function sanitizeError(err) {
     if (!err)
         return { message: "Unknown error" };
-    const e = err;
+    const e = typeof err === "object"
+        ? err
+        : {};
+    const message = typeof err === "string" ? err
+        : typeof e.message === "string" ? e.message : "Unknown error";
     return {
-        name: e.name || "Error",
-        code: e.code || undefined,
-        status: e.status || undefined,
-        message: sanitizeValue(e.message || "Unknown error"),
+        name: typeof e.name === "string" && e.name ? sanitizeLogString(e.name) : "Error",
+        code: typeof e.code === "string" ? sanitizeLogString(e.code) : undefined,
+        status: typeof e.status === "number" && Number.isFinite(e.status) ? e.status : undefined,
+        message: sanitizeLogString(message),
     };
 }
 export function sanitizeFields(fields = {}) {