@loucompanion/forge-bridge 0.1.3-dev.fbe15023cdfe → 0.1.4-dev.1ff37038366e

package/dist/session/session-redaction.js

@@ -1,23 +1,448 @@
-import { redactSecrets } from "../shared/redaction/redaction.js";
+import { redactText, shouldRedactJsonProperty } from "../shared/redaction/redaction.js";
+import { TextDecoder } from "node:util";
 const integrityProtectedEventDataTypes = new Set(["sandbox_started"]);
+const structuralSecretMessage = "runner result structural metadata contains protected secret material and cannot be redacted without changing protocol identity.";
+const sidecarSecretMessage = "runner result sidecar contains protected secret material and cannot be redacted without invalidating integrity metadata.";
+const artifactJsonMessage = "runner result artifact JSON is invalid or exceeds safe inspection limits; transport was rejected.";
+const artifactJsonKeySecretMessage = "runner result artifact JSON property name contains protected secret material and cannot be redacted without changing protocol identity.";
+const artifactJsonPrimitiveSecretMessage = "runner result artifact JSON primitive contains protected secret material and cannot be redacted without changing protocol identity.";
+const maximumIntegrityJsonBytes = 8 * 1024 * 1024;
+const maximumIntegrityJsonDepth = 128;
+const maximumIntegrityJsonTokens = 262_144;
 export function redactRunnerDispatchEvent(event, exactSecrets = []) {
-    if (!event.data || !integrityProtectedEventDataTypes.has(event.eventType)) {
-        return redactSecrets(event, exactSecrets);
+    assertStructuralFieldsDoNotContainSecrets([
+        event.role,
+        event.kind,
+        event.eventType,
+        event.wait?.kind,
+        event.wait?.scope,
+        event.wait?.wakeCondition,
+        event.wait?.contractOrigin,
+        ...(event.wait?.resourceKeys ?? []),
+    ], exactSecrets);
+    if (event.data !== undefined
+        && event.data !== null
+        && integrityProtectedEventDataTypes.has(event.eventType)) {
+        // Integrity-protected data cannot be rewritten because the runtime lease repeats the
+        // dispatch fence. Check the complete serialized payload so current and future resource
+        // identity fields cannot carry pending secret material across this boundary.
+        assertSerializedJsonDoesNotContainSecrets(event.data, exactSecrets, structuralSecretMessage);
     }
     // sandbox_started data is runner-authored protocol metadata. Its runtime
     // lease repeats the dispatch fence so the API can validate ownership. The
     // transcript redactor treats any serialized `*Token` field as a secret and
     // must not rewrite that identity before transport or result persistence.
-    const { data, ...transcript } = event;
     return {
-        ...redactSecrets(transcript, exactSecrets),
-        data,
+        ...event,
+        content: redactContent(event.content, exactSecrets),
+        ...(event.wait === undefined
+            ? {}
+            : { wait: event.wait === null ? null : redactWait(event.wait, exactSecrets) }),
+        ...(event.data === undefined || event.data === null
+            ? {}
+            : {
+                data: integrityProtectedEventDataTypes.has(event.eventType)
+                    ? event.data
+                    : redactContent(event.data, exactSecrets),
+            }),
+    };
+}
+function redactWait(wait, exactSecrets) {
+    return {
+        ...wait,
+        ...(wait.blockerTitle === undefined || wait.blockerTitle === null
+            ? {}
+            : { blockerTitle: redactContent(wait.blockerTitle, exactSecrets).slice(0, 500) }),
     };
 }
 export function redactRunOnceResultPacket(result, exactSecrets = []) {
-    const { events, ...payload } = result;
+    assertStructuralFieldsDoNotContainSecrets([result.resultCommitSha, result.publishedCommitSha], exactSecrets);
+    return {
+        ...result,
+        summary: redactContent(result.summary, exactSecrets),
+        ...(result.failure !== undefined
+            ? { failure: result.failure === null ? null : redactFailure(result.failure, exactSecrets) }
+            : {}),
+        ...(result.spec !== undefined
+            ? { spec: result.spec === null ? null : redactSpec(result.spec, exactSecrets) }
+            : {}),
+        ...(result.artifact !== undefined
+            ? { artifact: result.artifact === null ? null : redactArtifact(result.artifact, exactSecrets) }
+            : {}),
+        ...(result.artifacts !== undefined
+            ? {
+                artifacts: result.artifacts === null
+                    ? null
+                    : result.artifacts.map(item => redactArtifact(item, exactSecrets)),
+            }
+            : {}),
+        events: result.events.map(event => redactRunnerDispatchEvent(event, exactSecrets)),
+    };
+}
+function redactFailure(failure, exactSecrets) {
+    assertStructuralFieldsDoNotContainSecrets([failure.code, ...failure.causalChain.map(cause => cause.code)], exactSecrets);
     return {
-        ...redactSecrets(payload, exactSecrets),
-        events: events.map(event => redactRunnerDispatchEvent(event, exactSecrets)),
+        ...failure,
+        message: redactContent(failure.message, exactSecrets),
+        causalChain: failure.causalChain.map(cause => ({
+            ...cause,
+            message: redactContent(cause.message, exactSecrets),
+        })),
     };
 }
+function redactSpec(spec, exactSecrets) {
+    assertStructuralFieldsDoNotContainSecrets([spec.repoPath, spec.path, spec.producedBy, spec.status], exactSecrets);
+    return { ...spec, body: redactContent(spec.body, exactSecrets) };
+}
+function redactArtifact(artifact, exactSecrets) {
+    assertStructuralFieldsDoNotContainSecrets([artifact.repoPath, artifact.path, artifact.producedBy, artifact.status, artifact.phase], exactSecrets);
+    assertSidecarsDoNotContainSecrets(artifact.sidecars, exactSecrets);
+    return {
+        ...artifact,
+        verdictJson: redactArtifactJson(artifact.verdictJson, exactSecrets),
+        ...(artifact.planJson === undefined || artifact.planJson === null
+            ? {}
+            : { planJson: redactArtifactJson(artifact.planJson, exactSecrets) }),
+        ...(artifact.evidenceJson === undefined || artifact.evidenceJson === null
+            ? {}
+            : { evidenceJson: redactArtifactJson(artifact.evidenceJson, exactSecrets) }),
+        ...(artifact.findingsJson === undefined || artifact.findingsJson === null
+            ? {}
+            : { findingsJson: redactArtifactJson(artifact.findingsJson, exactSecrets) }),
+        ...(artifact.implementationPlanJson === undefined || artifact.implementationPlanJson === null
+            ? {}
+            : { implementationPlanJson: redactArtifactJson(artifact.implementationPlanJson, exactSecrets) }),
+        ...(artifact.qaPlanJson === undefined || artifact.qaPlanJson === null
+            ? {}
+            : { qaPlanJson: redactArtifactJson(artifact.qaPlanJson, exactSecrets) }),
+        report: redactContent(artifact.report, exactSecrets),
+        // These bytes already passed the QA path/hash/size checks. The generic
+        // redactor strips contentBase64 fields and must not corrupt the payload.
+        ...(artifact.sidecars !== undefined ? { sidecars: artifact.sidecars } : {}),
+    };
+}
+function redactArtifactJson(value, exactSecrets) {
+    // Validate the original before redaction. Replacing an invalid value must never
+    // turn a malformed evidence bundle into an apparently valid QA artifact.
+    inspectJsonStringTokens(value, [], artifactJsonMessage);
+    const chunks = [];
+    let unchangedStart = 0;
+    let index = 0;
+    const replace = (start, end, replacement) => {
+        if (value.slice(start, end) === replacement)
+            return;
+        chunks.push(value.slice(unchangedStart, start), replacement);
+        unchangedStart = end;
+    };
+    while (index < value.length) {
+        if (value.charCodeAt(index) !== 0x22) {
+            const code = value.charCodeAt(index);
+            if (isJsonWhitespace(code) || isJsonPunctuation(code)) {
+                index += 1;
+            }
+            else {
+                const end = jsonValueEnd(value, index);
+                // Numeric credentials and other exact primitive matches are still secrets.
+                // Fail closed instead of silently changing evidence types to strings.
+                assertJsonStringDoesNotContainSecrets(value.slice(index, end), exactSecrets, artifactJsonPrimitiveSecretMessage);
+                index = end;
+            }
+            continue;
+        }
+        const token = decodeJsonStringToken(value, index, artifactJsonMessage);
+        const afterToken = skipJsonWhitespace(value, token.nextIndex);
+        if (value.charCodeAt(afterToken) === 0x3a) {
+            assertJsonStringDoesNotContainSecrets(token.decoded, exactSecrets, artifactJsonKeySecretMessage);
+            if (redactText(token.decoded, exactSecrets) !== token.decoded)
+                throw new Error(artifactJsonKeySecretMessage);
+            if (shouldRedactJsonProperty(token.decoded)) {
+                const valueStart = skipJsonWhitespace(value, afterToken + 1);
+                const valueEnd = jsonValueEnd(value, valueStart);
+                if (value[valueStart] !== '"'
+                    || decodeJsonStringToken(value, valueStart, artifactJsonMessage).decoded !== "[REDACTED]") {
+                    replace(valueStart, valueEnd, '"[REDACTED]"');
+                }
+                index = valueEnd;
+                continue;
+            }
+        }
+        else {
+            const redacted = redactText(token.decoded, exactSecrets);
+            if (redacted !== token.decoded)
+                replace(index, token.nextIndex, JSON.stringify(redacted));
+        }
+        index = token.nextIndex;
+    }
+    if (chunks.length === 0)
+        return value;
+    chunks.push(value.slice(unchangedStart));
+    const redacted = chunks.join("");
+    // Retain the same bounded contract even when a short exact secret expands into
+    // a longer redaction marker. No raw JSON regex or parse/stringify round-trip:
+    // untouched escapes, whitespace, duplicate properties and numeric text survive.
+    inspectJsonStringTokens(redacted, [], artifactJsonMessage);
+    return redacted;
+}
+function skipJsonWhitespace(value, start) {
+    let index = start;
+    while (index < value.length && isJsonWhitespace(value.charCodeAt(index)))
+        index += 1;
+    return index;
+}
+// Called only after bounded JSON validation. Locate a credential property's whole
+// value (including objects/arrays) without decoding or rewriting adjacent data.
+function jsonValueEnd(value, start) {
+    if (value.charCodeAt(start) === 0x22) {
+        return decodeJsonStringToken(value, start, artifactJsonMessage).nextIndex;
+    }
+    if (value[start] === "{" || value[start] === "[") {
+        let depth = 0;
+        for (let index = start; index < value.length; index += 1) {
+            if (value[index] === '"') {
+                index = decodeJsonStringToken(value, index, artifactJsonMessage).nextIndex - 1;
+            }
+            else if (value[index] === "{" || value[index] === "[") {
+                depth += 1;
+            }
+            else if (value[index] === "}" || value[index] === "]") {
+                depth -= 1;
+                if (depth === 0)
+                    return index + 1;
+            }
+        }
+        throw new Error(artifactJsonMessage);
+    }
+    let index = start;
+    while (index < value.length
+        && !isJsonWhitespace(value.charCodeAt(index))
+        && value[index] !== "," && value[index] !== "}" && value[index] !== "]")
+        index += 1;
+    return index;
+}
+function redactContent(value, exactSecrets) {
+    return typeof value === "string" ? redactText(value, exactSecrets) : value;
+}
+function assertStructuralFieldsDoNotContainSecrets(fields, exactSecrets) {
+    for (const field of fields) {
+        if (field === undefined || field === null)
+            continue;
+        for (const secret of exactSecrets) {
+            if (secret.length > 0 && field.includes(secret)) {
+                throw new Error(structuralSecretMessage);
+            }
+        }
+    }
+}
+function assertSidecarsDoNotContainSecrets(sidecars, exactSecrets) {
+    if (!sidecars || exactSecrets.length === 0)
+        return;
+    for (const sidecar of sidecars) {
+        const decoded = Buffer.from(sidecar.contentBase64, "base64");
+        for (const secret of exactSecrets) {
+            if (secret.length === 0)
+                continue;
+            if (sidecar.path.includes(secret)
+                || sidecar.contentBase64.includes(secret)
+                || sidecar.contentHash.includes(secret)
+                || decoded.indexOf(Buffer.from(secret, "utf8")) >= 0) {
+                throw new Error(sidecarSecretMessage);
+            }
+        }
+        assertSidecarJsonDoesNotContainSecrets(decoded, sidecar.path, exactSecrets, sidecarSecretMessage);
+    }
+}
+function assertSerializedJsonDoesNotContainSecrets(value, exactSecrets, errorMessage) {
+    if (exactSecrets.length === 0)
+        return;
+    assertJsonStringDoesNotContainSecrets(value, exactSecrets, errorMessage);
+    inspectJsonStringTokens(value, exactSecrets, errorMessage);
+}
+function assertSidecarJsonDoesNotContainSecrets(value, path, exactSecrets, errorMessage) {
+    let decoded;
+    try {
+        decoded = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(value);
+    }
+    catch {
+        if (path.toLowerCase().endsWith(".json"))
+            throw new Error(errorMessage);
+        return;
+    }
+    if (!looksLikeJson(decoded, path))
+        return;
+    const hasUtf8Bom = value.length >= 3
+        && value[0] === 0xef
+        && value[1] === 0xbb
+        && value[2] === 0xbf;
+    if (hasUtf8Bom)
+        throw new Error(errorMessage);
+    inspectJsonStringTokens(decoded, exactSecrets, errorMessage);
+}
+function inspectJsonStringTokens(value, exactSecrets, errorMessage) {
+    if (Buffer.byteLength(value, "utf8") > maximumIntegrityJsonBytes) {
+        throw new Error(errorMessage);
+    }
+    const containers = [];
+    let index = 0;
+    let tokenCount = 0;
+    const countToken = () => {
+        tokenCount += 1;
+        if (tokenCount > maximumIntegrityJsonTokens)
+            throw new Error(errorMessage);
+    };
+    while (index < value.length) {
+        const code = value.charCodeAt(index);
+        if (code === 0x22) {
+            countToken();
+            const token = decodeJsonStringToken(value, index, errorMessage);
+            assertJsonStringDoesNotContainSecrets(token.decoded, exactSecrets, errorMessage);
+            index = token.nextIndex;
+            continue;
+        }
+        if (code === 0x7b || code === 0x5b) {
+            countToken();
+            containers.push(code);
+            if (containers.length > maximumIntegrityJsonDepth)
+                throw new Error(errorMessage);
+            index += 1;
+            continue;
+        }
+        if (code === 0x7d || code === 0x5d) {
+            countToken();
+            const expected = code === 0x7d ? 0x7b : 0x5b;
+            if (containers.pop() !== expected)
+                throw new Error(errorMessage);
+            index += 1;
+            continue;
+        }
+        if (code === 0x2c || code === 0x3a) {
+            index += 1;
+            continue;
+        }
+        if (isJsonWhitespace(code)) {
+            index += 1;
+            continue;
+        }
+        countToken();
+        do {
+            index += 1;
+        } while (index < value.length
+            && !isJsonWhitespace(value.charCodeAt(index))
+            && !isJsonPunctuation(value.charCodeAt(index)));
+    }
+    if (containers.length !== 0)
+        throw new Error(errorMessage);
+    try {
+        JSON.parse(value);
+    }
+    catch {
+        throw new Error(errorMessage);
+    }
+}
+function decodeJsonStringToken(value, openingQuoteIndex, errorMessage) {
+    const chunks = [];
+    let segmentStart = openingQuoteIndex + 1;
+    let index = segmentStart;
+    while (index < value.length) {
+        const code = value.charCodeAt(index);
+        if (code === 0x22) {
+            chunks.push(value.slice(segmentStart, index));
+            const decoded = chunks.join("");
+            if (!isWellFormedUnicode(decoded))
+                throw new Error(errorMessage);
+            return { decoded, nextIndex: index + 1 };
+        }
+        if (code < 0x20)
+            throw new Error(errorMessage);
+        if (code !== 0x5c) {
+            index += 1;
+            continue;
+        }
+        chunks.push(value.slice(segmentStart, index));
+        index += 1;
+        if (index >= value.length)
+            throw new Error(errorMessage);
+        const escaped = value[index];
+        switch (escaped) {
+            case "\"":
+                chunks.push("\"");
+                index += 1;
+                break;
+            case "\\":
+                chunks.push("\\");
+                index += 1;
+                break;
+            case "/":
+                chunks.push("/");
+                index += 1;
+                break;
+            case "b":
+                chunks.push("\b");
+                index += 1;
+                break;
+            case "f":
+                chunks.push("\f");
+                index += 1;
+                break;
+            case "n":
+                chunks.push("\n");
+                index += 1;
+                break;
+            case "r":
+                chunks.push("\r");
+                index += 1;
+                break;
+            case "t":
+                chunks.push("\t");
+                index += 1;
+                break;
+            case "u": {
+                const hex = value.slice(index + 1, index + 5);
+                if (!/^[0-9a-fA-F]{4}$/u.test(hex))
+                    throw new Error(errorMessage);
+                chunks.push(String.fromCharCode(Number.parseInt(hex, 16)));
+                index += 5;
+                break;
+            }
+            default: throw new Error(errorMessage);
+        }
+        segmentStart = index;
+    }
+    throw new Error(errorMessage);
+}
+function isWellFormedUnicode(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            if (index + 1 >= value.length)
+                return false;
+            const next = value.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                return false;
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+function looksLikeJson(value, path) {
+    if (path.toLowerCase().endsWith(".json"))
+        return true;
+    const candidate = value.trimStart().replace(/^\uFEFF/u, "").trimStart();
+    return candidate.startsWith("{") || candidate.startsWith("[") || candidate.startsWith("\"");
+}
+function isJsonWhitespace(code) {
+    return code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d;
+}
+function isJsonPunctuation(code) {
+    return code === 0x7b || code === 0x7d || code === 0x5b || code === 0x5d
+        || code === 0x2c || code === 0x3a || code === 0x22;
+}
+function assertJsonStringDoesNotContainSecrets(value, exactSecrets, errorMessage) {
+    for (const secret of exactSecrets) {
+        if (secret.length > 0 && value.includes(secret)) {
+            throw new Error(errorMessage);
+        }
+    }
+}