@westbayberry/dg 1.3.3 → 2.0.1

package/dist/proxy/ca.js

@@ -0,0 +1,126 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { isIP } from "node:net";
+import forge from "node-forge";
+export function createEphemeralCertificateAuthority(caPath) {
+    const keys = forge.pki.rsa.generateKeyPair({
+        bits: 2048,
+        workers: -1
+    });
+    const cert = forge.pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+    cert.serialNumber = serialNumber();
+    cert.validity.notBefore = new Date(Date.now() - 60_000);
+    cert.validity.notAfter = new Date(Date.now() + 24 * 60 * 60 * 1_000);
+    const attrs = [{
+            name: "commonName",
+            value: "Dependency Guardian per-session proxy CA"
+        }];
+    cert.setSubject(attrs);
+    cert.setIssuer(attrs);
+    cert.setExtensions([
+        {
+            name: "basicConstraints",
+            cA: true,
+            critical: true
+        },
+        {
+            name: "keyUsage",
+            keyCertSign: true,
+            cRLSign: true,
+            critical: true
+        },
+        {
+            name: "subjectKeyIdentifier"
+        }
+    ]);
+    cert.sign(keys.privateKey, forge.md.sha256.create());
+    const caCertPem = forge.pki.certificateToPem(cert);
+    mkdirSync(dirname(caPath), {
+        recursive: true,
+        mode: 0o700
+    });
+    writeFileSync(caPath, caCertPem, {
+        encoding: "utf8",
+        mode: 0o600
+    });
+    const leafs = new Map();
+    return {
+        caCertPem,
+        caPath,
+        leafForHost(host) {
+            const normalized = normalizeHost(host);
+            const existing = leafs.get(normalized);
+            if (existing) {
+                return existing;
+            }
+            const leaf = createLeafCertificate(normalized, cert, keys.privateKey);
+            leafs.set(normalized, leaf);
+            return leaf;
+        }
+    };
+}
+function createLeafCertificate(host, issuerCert, issuerKey) {
+    const keys = forge.pki.rsa.generateKeyPair({
+        bits: 2048,
+        workers: -1
+    });
+    const cert = forge.pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+    cert.serialNumber = serialNumber();
+    cert.validity.notBefore = new Date(Date.now() - 60_000);
+    cert.validity.notAfter = new Date(Date.now() + 24 * 60 * 60 * 1_000);
+    cert.setSubject([{
+            name: "commonName",
+            value: host
+        }]);
+    cert.setIssuer(issuerCert.subject.attributes);
+    cert.setExtensions([
+        {
+            name: "basicConstraints",
+            cA: false,
+            critical: true
+        },
+        {
+            name: "keyUsage",
+            digitalSignature: true,
+            keyEncipherment: true,
+            critical: true
+        },
+        {
+            name: "extKeyUsage",
+            serverAuth: true
+        },
+        {
+            name: "subjectAltName",
+            altNames: subjectAlternativeNames(host)
+        }
+    ]);
+    cert.sign(issuerKey, forge.md.sha256.create());
+    return {
+        certPem: forge.pki.certificateToPem(cert),
+        keyPem: forge.pki.privateKeyToPem(keys.privateKey)
+    };
+}
+function subjectAlternativeNames(host) {
+    const ipVersion = isIP(host);
+    if (ipVersion !== 0) {
+        return [{
+                type: 7,
+                ip: host
+            }];
+    }
+    return [{
+            type: 2,
+            value: host
+        }];
+}
+function normalizeHost(host) {
+    return host.replace(/^\[/, "").replace(/\]$/, "").replace(/\.$/, "").toLowerCase();
+}
+function serialNumber() {
+    const bytes = randomBytes(16);
+    bytes[0] = (bytes[0] ?? 0) & 0x7f;
+    return bytes.toString("hex");
+}

package/dist/proxy/classify-host.js

@@ -0,0 +1,26 @@
+const DEFAULT_MITM_PATTERNS = [
+    "registry.npmjs.org",
+    "*.npmjs.org",
+    "registry.yarnpkg.com",
+    "pypi.org",
+    "files.pythonhosted.org",
+    "crates.io",
+    "static.crates.io",
+    "index.crates.io"
+];
+export function shouldMitmHost(host, env) {
+    const normalized = normalizeHost(host);
+    const configured = (env.DG_PROXY_MITM_HOSTS ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
+    return [...DEFAULT_MITM_PATTERNS, ...configured].some((pattern) => hostMatchesPattern(normalized, pattern));
+}
+function hostMatchesPattern(host, pattern) {
+    const normalized = normalizeHost(pattern);
+    if (normalized.startsWith("*.")) {
+        const suffix = normalized.slice(1);
+        return host.endsWith(suffix) && host.length > suffix.length;
+    }
+    return host === normalized;
+}
+function normalizeHost(host) {
+    return host.replace(/^\[/, "").replace(/\]$/, "").replace(/\.$/, "").toLowerCase();
+}

package/dist/proxy/enforcement.js

@@ -0,0 +1,102 @@
+import { recordAuditEvent } from "../audit/events.js";
+import { loadUserConfig } from "../config/settings.js";
+import { applyForceOverride, evaluatePackagePolicy, resolveEffectivePolicy } from "../policy/evaluate.js";
+export function parseForceOverrideRequest(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.force !== true) {
+            return undefined;
+        }
+        return { force: true };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function enforceProtectedInstall(request) {
+    const userConfig = request.userConfig ?? loadUserConfig(request.env);
+    const policy = resolveEffectivePolicy({ userConfig });
+    const proxyVerdict = request.proxyVerdict ?? failClosedVerdict(request.classification);
+    const packageName = proxyVerdict.packageName ?? derivePackageName(request.classification);
+    const evaluation = evaluatePackagePolicy({
+        verdict: proxyVerdict.verdict,
+        packageName,
+        policy
+    });
+    const baseDecision = withOptionalDecisionFields({
+        action: evaluation.action,
+        cause: proxyVerdict.cause ?? causeFromVerdict(proxyVerdict.verdict, evaluation.action),
+        packageName,
+        policyMode: policy.mode,
+        reason: proxyVerdict.reason ?? evaluation.reason
+    }, proxyVerdict);
+    if (baseDecision.action !== "block") {
+        return baseDecision;
+    }
+    const force = applyForceOverride({
+        packageName,
+        currentAction: "block",
+        force: request.forceOverride?.force ?? false,
+        policy,
+        ...(request.now ? { now: request.now } : {})
+    }, request.env);
+    if (force.allowed) {
+        return {
+            ...baseDecision,
+            action: "warn",
+            reason: `force override allowed: ${force.reason}`,
+            forceOverride: {
+                allowed: true,
+                reason: force.reason
+            }
+        };
+    }
+    recordAuditEvent({
+        type: "install.blocked",
+        packageName,
+        reason: baseDecision.reason,
+        policyMode: policy.mode,
+        createdAt: (request.now ?? new Date()).toISOString()
+    }, request.env);
+    if (!request.forceOverride?.force) {
+        return baseDecision;
+    }
+    return {
+        ...baseDecision,
+        forceOverride: {
+            allowed: false,
+            reason: force.reason
+        }
+    };
+}
+function failClosedVerdict(classification) {
+    return {
+        verdict: "block",
+        packageName: derivePackageName(classification),
+        cause: "proxy-setup-failure",
+        reason: "per-invocation proxy enforcement is not available, so protected installs fail closed"
+    };
+}
+function derivePackageName(classification) {
+    const spec = classification.args.find((arg) => !arg.startsWith("-") && arg !== classification.action);
+    return spec ?? `${classification.manager}:${classification.action || "install"}`;
+}
+function causeFromVerdict(verdict, action) {
+    if (verdict === "pass" && action === "pass") {
+        return "pass";
+    }
+    if (action === "warn") {
+        return "warn";
+    }
+    return "policy";
+}
+function withOptionalDecisionFields(decision, verdict) {
+    return {
+        ...decision,
+        ...(verdict.dashboardUrl ? { dashboardUrl: verdict.dashboardUrl } : {}),
+        ...(verdict.unauthenticated ? { unauthenticated: true } : {})
+    };
+}

package/dist/proxy/metadata-map.js

@@ -0,0 +1,336 @@
+import { createHash } from "node:crypto";
+export function extractRegistryMetadataIdentities(metadataUrl, response) {
+    // PyPI Simple index (PEP 503 HTML or PEP 691 JSON) — the pip/uv/pipx flow.
+    if (isPypiSimpleIndexUrl(metadataUrl)) {
+        return extractPypiSimpleIdentities(metadataUrl, response);
+    }
+    if (!looksLikeJson(response.headers["content-type"])) {
+        return [];
+    }
+    const parsed = parseJson(response.body);
+    if (!isRecord(parsed)) {
+        return [];
+    }
+    return [
+        ...extractNpmIdentities(metadataUrl, parsed),
+        ...extractPypiIdentities(metadataUrl, parsed)
+    ];
+}
+// A registry INDEX/metadata request (not an artifact download). These must be
+// passed through untouched — never verified as a package — so e.g. pip's
+// `pypi.org/simple/<pkg>/` index is not mistaken for a package named "simple".
+// PEP 658 `.metadata` sidecars are dist-info metadata pip fetches for dependency
+// resolution; the actual wheel/sdist download is what gets verified. npm reserves
+// the `/-/` path prefix for registry API endpoints (security/advisories, audits,
+// `-/v1/search`) which npm hits during install — those are never package tarballs
+// (tarballs live at `/<pkg>/-/<file>.tgz`, where `/-/` is not at the path start).
+export function isRegistryIndexRequest(url) {
+    return (isPypiSimpleIndexUrl(url) ||
+        /\/pypi\/[^/]+\/json\/?$/i.test(url.pathname) ||
+        /\.metadata$/i.test(url.pathname) ||
+        /^\/-\//.test(url.pathname));
+}
+function isPypiSimpleIndexUrl(url) {
+    return /^\/simple(\/|$)/i.test(url.pathname);
+}
+function extractPypiSimpleIdentities(metadataUrl, response) {
+    const entries = [];
+    if (looksLikeJson(response.headers["content-type"])) {
+        const parsed = parseJson(response.body);
+        const files = isRecord(parsed) && Array.isArray(parsed.files) ? parsed.files : [];
+        for (const file of files) {
+            if (isRecord(file) && typeof file.url === "string" && file.url.length > 0) {
+                entries.push(typeof file.filename === "string" && file.filename.length > 0
+                    ? { href: file.url, filename: file.filename }
+                    : { href: file.url });
+            }
+        }
+    }
+    else {
+        const html = response.body.toString("utf8");
+        const linkRe = /<a\b[^>]*\bhref\s*=\s*["']([^"']+)["']/gi;
+        let match;
+        while ((match = linkRe.exec(html)) !== null) {
+            if (match[1]) {
+                entries.push({ href: match[1] });
+            }
+        }
+    }
+    const identities = [];
+    for (const entry of entries) {
+        let absolute;
+        try {
+            absolute = new URL(entry.href, metadataUrl);
+        }
+        catch {
+            continue;
+        }
+        const file = entry.filename ?? decodeURIComponent(absolute.pathname.split("/").filter(Boolean).at(-1) ?? "");
+        const parsed = parsePypiArtifactFilename(file);
+        if (!parsed) {
+            continue;
+        }
+        identities.push({
+            ecosystem: "pypi",
+            name: parsed.name,
+            version: parsed.version,
+            registryHost: absolute.hostname,
+            tarballUrl: artifactUrlKey(absolute),
+            sourceKind: "registry-metadata"
+        });
+    }
+    return identities;
+}
+// Parse a PyPI wheel (PEP 427) or sdist filename into {name, version}. Wheel and
+// sdist names/versions never contain "-" (it is escaped to "_"), so a wheel is a
+// clean dash-split and an sdist is name + a digit-leading version.
+function parsePypiArtifactFilename(file) {
+    if (/\.whl$/i.test(file)) {
+        const parts = file.replace(/\.whl$/i, "").split("-");
+        if (parts.length >= 5 && parts[0] && parts[1]) {
+            return { name: normalizePypiName(parts[0]), version: parts[1] };
+        }
+        return null;
+    }
+    const sdistExt = /\.(?:tar\.gz|tgz|zip|tar\.bz2|tar\.xz)$/i.exec(file);
+    if (sdistExt) {
+        const stem = file.slice(0, file.length - sdistExt[0].length);
+        const match = /^(.+)-(\d[A-Za-z0-9._!+]*)$/.exec(stem);
+        if (match && match[1] && match[2]) {
+            return { name: normalizePypiName(match[1]), version: match[2] };
+        }
+    }
+    return null;
+}
+function normalizePypiName(name) {
+    return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+export function resolveArtifactIdentity(artifactUrl, identities, classification) {
+    const key = artifactUrlKey(artifactUrl);
+    const matches = identities.filter((identity) => artifactUrlKey(identity.tarballUrl) === key);
+    const unique = dedupeIdentities(matches);
+    if (unique.length === 1) {
+        const identity = unique[0];
+        if (!identity) {
+            throw new Error("artifact identity resolution was empty");
+        }
+        return {
+            kind: "resolved",
+            identity
+        };
+    }
+    if (unique.length > 1) {
+        const first = unique[0];
+        if (!first) {
+            throw new Error("artifact identity ambiguity was empty");
+        }
+        return {
+            kind: "ambiguous",
+            packageName: artifactDisplayName(first),
+            reason: `ambiguous artifact identity for ${redactedUrl(artifactUrl)} from registry metadata`
+        };
+    }
+    return {
+        kind: "resolved",
+        identity: fallbackIdentity(artifactUrl, classification)
+    };
+}
+export function artifactDisplayName(identity) {
+    return `${identity.ecosystem}:${identity.name}@${identity.version}`;
+}
+export function artifactUrlHash(url) {
+    return createHash("sha256").update(artifactUrlKey(url)).digest("hex");
+}
+export function artifactUrlKey(value) {
+    const url = typeof value === "string" ? new URL(value) : new URL(value.toString());
+    url.username = "";
+    url.password = "";
+    url.hash = "";
+    return url.toString();
+}
+function extractNpmIdentities(metadataUrl, parsed) {
+    const packageName = typeof parsed.name === "string" ? parsed.name : packageNameFromNpmMetadataPath(metadataUrl);
+    const versions = isRecord(parsed.versions) ? parsed.versions : {};
+    const identities = [];
+    for (const [version, rawVersion] of Object.entries(versions)) {
+        if (!isRecord(rawVersion) || typeof version !== "string") {
+            continue;
+        }
+        const dist = isRecord(rawVersion.dist) ? rawVersion.dist : {};
+        if (typeof dist.tarball !== "string" || dist.tarball.length === 0) {
+            continue;
+        }
+        identities.push({
+            ecosystem: "npm",
+            name: packageName,
+            version,
+            registryHost: metadataUrl.hostname,
+            tarballUrl: artifactUrlKey(new URL(dist.tarball, metadataUrl)),
+            sourceKind: "registry-metadata"
+        });
+    }
+    return identities;
+}
+function extractPypiIdentities(metadataUrl, parsed) {
+    const info = isRecord(parsed.info) ? parsed.info : {};
+    const packageName = typeof info.name === "string" && info.name.length > 0
+        ? info.name
+        : packageNameFromPypiMetadataPath(metadataUrl);
+    const releases = isRecord(parsed.releases) ? parsed.releases : {};
+    const identities = [];
+    for (const [version, rawFiles] of Object.entries(releases)) {
+        if (!Array.isArray(rawFiles)) {
+            continue;
+        }
+        for (const rawFile of rawFiles) {
+            if (!isRecord(rawFile) || typeof rawFile.url !== "string" || rawFile.url.length === 0) {
+                continue;
+            }
+            identities.push({
+                ecosystem: "pypi",
+                name: packageName,
+                version,
+                registryHost: metadataUrl.hostname,
+                tarballUrl: artifactUrlKey(new URL(rawFile.url, metadataUrl)),
+                sourceKind: "registry-metadata"
+            });
+        }
+    }
+    return identities;
+}
+function fallbackIdentity(artifactUrl, classification) {
+    const ecosystem = ecosystemForManager(classification.manager);
+    const parsed = ecosystem === "pypi"
+        ? parsePypiArtifactFilename(decodeURIComponent(artifactUrl.pathname.split("/").filter(Boolean).at(-1) ?? "")) ?? parsePackageVersionFromUrl(artifactUrl)
+        : parsePackageVersionFromUrl(artifactUrl);
+    const requested = requestedIdentityFromArgs(classification, parsed.name);
+    return {
+        ecosystem,
+        name: requested?.name ?? parsed.name,
+        version: requested?.version ?? parsed.version,
+        registryHost: artifactUrl.hostname,
+        tarballUrl: artifactUrlKey(artifactUrl),
+        sourceKind: "url-fallback"
+    };
+}
+function parsePackageVersionFromUrl(artifactUrl) {
+    const parts = artifactUrl.pathname.split("/").filter(Boolean).map((part) => decodeURIComponent(part));
+    const file = parts.at(-1) ?? artifactUrl.hostname;
+    const npmPackage = npmPackageFromTarballPath(parts);
+    const packageName = npmPackage ?? parts.at(-2) ?? file.replace(/\.(?:tgz|tar\.gz|zip|whl)$/i, "");
+    const filePackageName = packageName.split("/").at(-1) ?? packageName;
+    const escaped = filePackageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const versionMatch = new RegExp(`${escaped}[-_]v?([^/]+?)\\.(?:tgz|tar\\.gz|zip|whl)$`, "i").exec(file);
+    return {
+        name: packageName || artifactUrl.hostname,
+        version: versionMatch?.[1] ?? "unknown"
+    };
+}
+function npmPackageFromTarballPath(parts) {
+    const marker = parts.indexOf("-");
+    if (marker <= 0) {
+        return undefined;
+    }
+    const beforeMarker = parts.slice(0, marker);
+    const name = beforeMarker.at(-1);
+    const scope = beforeMarker.at(-2);
+    if (!name) {
+        return undefined;
+    }
+    if (scope?.startsWith("@")) {
+        return `${scope}/${name}`;
+    }
+    return name;
+}
+function requestedIdentityFromArgs(classification, parsedName) {
+    if (classification.ecosystem !== "javascript") {
+        return undefined;
+    }
+    const specs = classification.args
+        .filter((arg) => !arg.startsWith("-") && arg !== classification.action)
+        .map(parseNpmPackageSpec)
+        .filter((spec) => spec !== undefined);
+    if (specs.length !== 1) {
+        return undefined;
+    }
+    const [spec] = specs;
+    if (!spec || spec.name !== parsedName) {
+        return undefined;
+    }
+    return spec;
+}
+function parseNpmPackageSpec(spec) {
+    if (spec.length === 0 || spec === "." || spec.startsWith("file:") || /^https?:\/\//.test(spec)) {
+        return undefined;
+    }
+    const withoutAlias = spec.includes("@npm:") ? spec.slice(spec.indexOf("@npm:") + 5) : spec;
+    const versionSeparator = withoutAlias.lastIndexOf("@");
+    if (versionSeparator <= 0) {
+        return undefined;
+    }
+    const name = withoutAlias.slice(0, versionSeparator);
+    const version = withoutAlias.slice(versionSeparator + 1);
+    if (!name || !version || name === version || /[*xX]|\|\||[<>=~^]/.test(version)) {
+        return undefined;
+    }
+    return { name, version };
+}
+function packageNameFromNpmMetadataPath(metadataUrl) {
+    const parts = metadataUrl.pathname.split("/").filter(Boolean).map((part) => decodeURIComponent(part));
+    if (parts[0]?.startsWith("@") && parts[1]) {
+        return `${parts[0]}/${parts[1]}`;
+    }
+    return parts[0] ?? metadataUrl.hostname;
+}
+function packageNameFromPypiMetadataPath(metadataUrl) {
+    const parts = metadataUrl.pathname.split("/").filter(Boolean).map((part) => decodeURIComponent(part));
+    const projectIndex = parts.findIndex((part) => part.toLowerCase() === "pypi");
+    return parts[projectIndex + 1] ?? parts[0] ?? metadataUrl.hostname;
+}
+function ecosystemForManager(manager) {
+    if (manager === "npm" || manager === "npx" || manager === "pnpm" || manager === "pnpx" || manager === "yarn") {
+        return "npm";
+    }
+    if (manager === "pip" || manager === "pipx" || manager === "uv" || manager === "uvx") {
+        return "pypi";
+    }
+    if (manager === "cargo") {
+        return "cargo";
+    }
+    return "unknown";
+}
+function dedupeIdentities(identities) {
+    const seen = new Set();
+    const unique = [];
+    for (const identity of identities) {
+        const key = `${identity.ecosystem}\0${identity.name}\0${identity.version}\0${identity.registryHost}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            unique.push(identity);
+        }
+    }
+    return unique;
+}
+function redactedUrl(url) {
+    const copy = new URL(url.toString());
+    if (copy.username || copy.password) {
+        copy.username = "<redacted>";
+        copy.password = "";
+    }
+    return copy.toString();
+}
+function looksLikeJson(value) {
+    const header = Array.isArray(value) ? value.join(",") : String(value ?? "");
+    return /\bjson\b/i.test(header);
+}
+function parseJson(body) {
+    try {
+        return JSON.parse(body.toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}