Use zip.js's parsed symlink fact for inventory and open refusal. Treat an unmatched Godot trailer as an unconfirmed candidate while preserving failures for confirmed malformed packs. Report entropy path-resolution failures at the selected-input boundary. Separate Go header discovery from inline string extents in ELF and Mach-O, and apply the aggregate content allowance after validating real source ranges. Normalize binary plist UID widths through the existing scalar-copy owner, budget exact clone growth, preserve source identity, and refuse inexact UIDs. Validation: 389 distinct tests passed, one Linux /proc test skipped on Darwin; build, typecheck/lint, docs, single-thread formatting, and discovery (2142 files) passed. CLI/MCP Go fixtures and public ZIP/Godot/keyed-archive workflows ran. Real producer prevalence and external provider execution were not established. Repeated ordinary keyed-archive CLI inventory facts and estimated reply tokens were equal before/after. Warm median elapsed was 0.5166s / 0.5177s; no speed claim. Fixes #6751 Fixes #6763 Fixes #6754 Fixes #6767 Fixes #6762 Fixes #6779
562 lines
19 KiB
TypeScript
562 lines
19 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
import { open, stat, rename, symlink, writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { expect, it, vi } from "vitest";
|
|
import { createTestTempDirectory } from "../../../tests/fixtures/temporaryDirectory.js";
|
|
import { byteEntropySchema } from "../../domain/native/byteEntropy.js";
|
|
import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
|
|
import {
|
|
ByteEntropyService,
|
|
MAX_BYTE_ENTROPY_BLOCKS,
|
|
} from "./ByteEntropyService.js";
|
|
|
|
it("keeps whole-file identity and entropy while selecting unaligned blocks and a partial tail", async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-");
|
|
const path = join(root, "bytes");
|
|
const bytes = Buffer.from(Array.from({ length: 1024 }, (_, i) => i % 256));
|
|
await writeFile(path, bytes);
|
|
const result = await new ByteEntropyService().inspect({
|
|
path,
|
|
offset: 3,
|
|
length: 513,
|
|
block_size: 256,
|
|
});
|
|
if (!result.ok) throw result.error;
|
|
const report = byteEntropySchema.parse(result.value.normalized_result);
|
|
expect(report.blocks).toEqual([
|
|
{ offset: 3, length: 256, entropy: 8 },
|
|
{ offset: 259, length: 256, entropy: 8 },
|
|
{ offset: 515, length: 1, entropy: 0 },
|
|
]);
|
|
expect(report.file_entropy).toBe(8);
|
|
expect(report.artifact).toEqual({
|
|
path,
|
|
bytes: 1024,
|
|
sha256: createHash("sha256").update(bytes).digest("hex"),
|
|
});
|
|
expect(result.value.subject?.digest.sha256).toBe(report.artifact.sha256);
|
|
expect(result.value.confidence).toBe("observed");
|
|
});
|
|
|
|
it("rejects missing files, non-files and windows beyond EOF, but accepts empty windows", async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-input-");
|
|
const path = join(root, "empty");
|
|
await writeFile(path, "");
|
|
const service = new ByteEntropyService();
|
|
for (const input of [
|
|
{ path: join(root, "missing") },
|
|
{ path: root },
|
|
{ path, offset: 1 },
|
|
{ path, length: 1 },
|
|
{ path: "relative" },
|
|
]) {
|
|
const result = await service.inspect(input);
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "AnalysisInputError" },
|
|
});
|
|
}
|
|
const result = await service.inspect({ path });
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value.normalized_result).toMatchObject({
|
|
blocks: [],
|
|
runs: [],
|
|
file_entropy: 0,
|
|
window: { offset: 0, length: 0 },
|
|
});
|
|
expect(
|
|
byteEntropySchema.parse(result.value.normalized_result).limitations,
|
|
).toContainEqual(expect.stringContaining("reports a size of 0"));
|
|
});
|
|
|
|
it.skipIf(process.platform !== "linux" && process.platform !== "darwin")(
|
|
"projects real path-resolution failures as actionable input errors",
|
|
async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-path-resolution-");
|
|
const loop = join(root, "loop");
|
|
await symlink("loop", loop);
|
|
const overlong = join(root, "x".repeat(256));
|
|
const cases = [
|
|
[loop, "ELOOP"],
|
|
[overlong, "ENAMETOOLONG"],
|
|
] as const;
|
|
const service = new ByteEntropyService();
|
|
try {
|
|
for (const [path, code] of cases) {
|
|
let observedCode: unknown;
|
|
try {
|
|
await stat(path);
|
|
} catch (cause: unknown) {
|
|
observedCode =
|
|
cause instanceof Error && "code" in cause ? cause.code : undefined;
|
|
}
|
|
expect(observedCode).toBe(code);
|
|
|
|
const result = await service.inspect({ path });
|
|
if (result.ok) throw new Error(`Expected ${code} path failure`);
|
|
expect(result.error).toMatchObject({
|
|
_tag: "AnalysisInputError",
|
|
cause: { code },
|
|
issues: [
|
|
{
|
|
path: ["path"],
|
|
reason: "invalid_value",
|
|
},
|
|
],
|
|
});
|
|
const projected = projectAnalysisError(result.error);
|
|
expect(projected).toMatchObject({
|
|
code: "invalid_request",
|
|
recovery: {
|
|
kind: "inspect_input_contract",
|
|
operation: "inspect_byte_entropy",
|
|
},
|
|
details: {
|
|
operation: "inspect_byte_entropy",
|
|
issues: [
|
|
{
|
|
path: ["path"],
|
|
reason: "invalid_value",
|
|
message: expect.stringContaining(code),
|
|
},
|
|
],
|
|
},
|
|
});
|
|
expect(JSON.stringify(projected.details)).toContain(path);
|
|
}
|
|
} finally {
|
|
await service.close();
|
|
}
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
[{ offset: 2048 }, "offset"],
|
|
[{ offset: 2048, length: 0 }, "offset"],
|
|
[{ offset: 512, length: 1024 }, "length"],
|
|
])("names the selector that puts %o past EOF", async (window, field) => {
|
|
const root = await createTestTempDirectory("rea-entropy-window-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(1024));
|
|
const result = await new ByteEntropyService().inspect({ path, ...window });
|
|
if (result.ok) throw new Error("Expected an out-of-file window to fail");
|
|
expect(projectAnalysisError(result.error)).toMatchObject({
|
|
code: "invalid_request",
|
|
details: { issues: [{ path: [field], reason: "invalid_value" }] },
|
|
});
|
|
});
|
|
|
|
it.skipIf(process.platform !== "linux")(
|
|
"marks a generated /proc file that reports size 0 as not shown empty",
|
|
async () => {
|
|
const result = await new ByteEntropyService().inspect({
|
|
path: "/proc/version",
|
|
});
|
|
if (!result.ok) throw result.error;
|
|
const report = byteEntropySchema.parse(result.value.normalized_result);
|
|
expect(report.artifact.bytes).toBe(0);
|
|
expect(report.limitations).toContainEqual(
|
|
expect.stringContaining("Linux /proc entries"),
|
|
);
|
|
},
|
|
);
|
|
|
|
it("adds no zero-size limitation to a file with content", async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-nonempty-");
|
|
const path = join(root, "one");
|
|
await writeFile(path, "x");
|
|
const result = await new ByteEntropyService().inspect({ path });
|
|
if (!result.ok) throw result.error;
|
|
expect(
|
|
byteEntropySchema
|
|
.parse(result.value.normalized_result)
|
|
.limitations.join(" "),
|
|
).not.toContain("reports a size of 0");
|
|
});
|
|
|
|
it("honors cancellation before and during streaming", async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-cancel-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(1024 * 1024));
|
|
const service = new ByteEntropyService();
|
|
const reason = { request: "opaque cancellation" };
|
|
const before = await service.inspect(
|
|
{ path },
|
|
{ signal: AbortSignal.abort(reason) },
|
|
);
|
|
if (before.ok) throw new Error("Expected cancellation before admission");
|
|
expect(before.error.cause).toBe(reason);
|
|
expect(before.error.partialObservation).toBeUndefined();
|
|
const controller = new AbortController();
|
|
let reads = 0;
|
|
const streaming = new ByteEntropyService({
|
|
stat,
|
|
open: async (...args) => {
|
|
const file = await open(...args);
|
|
const read = file.read.bind(file);
|
|
vi.spyOn(file, "read").mockImplementation(async (...readArgs) => {
|
|
const result = await read(...readArgs);
|
|
reads += 1;
|
|
controller.abort(reason);
|
|
return result;
|
|
});
|
|
return file;
|
|
},
|
|
});
|
|
const pending = streaming.inspect(
|
|
{ path, block_size: 256 },
|
|
{ signal: controller.signal },
|
|
);
|
|
const during = await pending;
|
|
if (during.ok) throw new Error("Expected cancellation during read");
|
|
expect(during.error).toMatchObject({ _tag: "AnalysisCancelledError" });
|
|
expect(during.error.cause).toBe(reason);
|
|
expect(during.error.partialObservation).toBeUndefined();
|
|
expect(reads).toBe(1);
|
|
});
|
|
|
|
it("maps cancellation during open to the cancelled algebra with its original cause", async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-open-cancel-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(512));
|
|
const controller = new AbortController();
|
|
const reason = new Error("cancelled while opening");
|
|
const service = new ByteEntropyService({
|
|
stat,
|
|
open: async (...args) => {
|
|
const file = await open(...args);
|
|
controller.abort(reason);
|
|
return file;
|
|
},
|
|
});
|
|
|
|
const result = await service.inspect(
|
|
{ path, block_size: 256 },
|
|
{ signal: controller.signal },
|
|
);
|
|
|
|
if (result.ok) throw new Error("Expected cancellation during open");
|
|
expect(result.error).toMatchObject({ _tag: "AnalysisCancelledError" });
|
|
expect(result.error.cause).toBe(reason);
|
|
expect(projectAnalysisError(result.error)).toMatchObject({
|
|
code: "cancelled",
|
|
});
|
|
await service.close();
|
|
});
|
|
|
|
it.each([false, true])(
|
|
"retains completed Evidence when final close is cancelled (close fails: %s)",
|
|
async (closeFails) => {
|
|
const root = await createTestTempDirectory("rea-entropy-finalizer-cancel-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(512));
|
|
const controller = new AbortController();
|
|
const reason = new Error("cancelled during close");
|
|
const closeFailure = new Error("injected close failure");
|
|
let failClose = closeFails;
|
|
let closes = 0;
|
|
const service = new ByteEntropyService({
|
|
stat,
|
|
open: async (...args) => {
|
|
const file = await open(...args);
|
|
const close = file.close.bind(file);
|
|
vi.spyOn(file, "close").mockImplementation(async () => {
|
|
closes += 1;
|
|
controller.abort(reason);
|
|
if (failClose) throw closeFailure;
|
|
await close();
|
|
});
|
|
return file;
|
|
},
|
|
});
|
|
|
|
const result = await service.inspect(
|
|
{ path, block_size: 256 },
|
|
{ signal: controller.signal },
|
|
);
|
|
|
|
if (result.ok) throw new Error("Expected cancellation during finalization");
|
|
expect(result.error).toMatchObject({
|
|
_tag: "AnalysisCancelledError",
|
|
cleanupIncomplete: closeFails,
|
|
});
|
|
expect(result.error.cause).toBe(reason);
|
|
const evidence = result.error.partialObservation;
|
|
expect(evidence).toMatchObject({
|
|
operation: "inspect_byte_entropy",
|
|
confidence: "observed",
|
|
normalized_result: {
|
|
artifact: {
|
|
path,
|
|
bytes: 512,
|
|
sha256: createHash("sha256").update(Buffer.alloc(512)).digest("hex"),
|
|
},
|
|
window: { offset: 0, length: 512 },
|
|
file_entropy: 0,
|
|
blocks: [
|
|
{ offset: 0, length: 256, entropy: 0 },
|
|
{ offset: 256, length: 256, entropy: 0 },
|
|
],
|
|
},
|
|
});
|
|
expect(closes).toBe(1);
|
|
if (closeFails) {
|
|
expect(result.error.secondaryFailures).toMatchObject([
|
|
{ _tag: "AnalysisOutputError", cleanupIncomplete: true },
|
|
]);
|
|
expect(projectAnalysisError(result.error)).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
retryable: false,
|
|
details: { cleanup: "incomplete", execution_failure: "cancelled" },
|
|
});
|
|
} else {
|
|
expect(result.error.secondaryFailures).toEqual([]);
|
|
expect(projectAnalysisError(result.error)).toMatchObject({
|
|
code: "cancelled",
|
|
});
|
|
}
|
|
failClose = false;
|
|
await service.close();
|
|
expect(result.error.cleanupIncomplete).toBe(false);
|
|
expect(result.error.partialObservation).toBe(evidence);
|
|
expect(closes).toBe(closeFails ? 2 : 1);
|
|
},
|
|
);
|
|
|
|
it("reports a changed artifact when its parent directory moves during streaming", async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-moved-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(512));
|
|
let moved = false;
|
|
const service = new ByteEntropyService({
|
|
stat,
|
|
open: async (...args) => {
|
|
const file = await open(...args);
|
|
const read = file.read.bind(file);
|
|
vi.spyOn(file, "read").mockImplementation(async (...readArgs) => {
|
|
const result = await read(...readArgs);
|
|
if (!moved) {
|
|
moved = true;
|
|
await rename(root, `${root}-moved`);
|
|
}
|
|
return result;
|
|
});
|
|
return file;
|
|
},
|
|
});
|
|
try {
|
|
expect(await service.inspect({ path, block_size: 256 })).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "AnalysisArtifactChangedError" },
|
|
});
|
|
} finally {
|
|
if (moved) await rename(`${root}-moved`, root);
|
|
}
|
|
});
|
|
|
|
it("refuses a block series above the output-row limit before scanning", async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-block-limit-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(MAX_BYTE_ENTROPY_BLOCKS * 256 + 1));
|
|
let reads = 0;
|
|
const service = new ByteEntropyService({
|
|
stat,
|
|
open: async (...args) => {
|
|
const file = await open(...args);
|
|
vi.spyOn(file, "read").mockImplementation(async () => {
|
|
reads += 1;
|
|
return { bytesRead: 0, buffer: Buffer.alloc(0) };
|
|
});
|
|
return file;
|
|
},
|
|
});
|
|
|
|
const result = await service.inspect({ path, block_size: 256 });
|
|
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: {
|
|
_tag: "AnalysisResourceConstraintError",
|
|
resource: "capacity",
|
|
reportedLimits: {
|
|
max_blocks: MAX_BYTE_ENTROPY_BLOCKS,
|
|
requested_blocks: MAX_BYTE_ENTROPY_BLOCKS + 1,
|
|
},
|
|
},
|
|
});
|
|
if (result.ok) throw new Error("Expected a capacity refusal");
|
|
expect(projectAnalysisError(result.error)).toMatchObject({
|
|
code: "resource_constraint",
|
|
retryable: false,
|
|
remediation: {
|
|
action: expect.stringMatching(/shorter window|increase block_size/i),
|
|
},
|
|
});
|
|
expect(reads).toBe(0);
|
|
await service.close();
|
|
});
|
|
|
|
it("retains a failed descriptor close and retries it before opening another file", async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-close-retry-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(512));
|
|
let failClose = true;
|
|
let opens = 0;
|
|
const service = new ByteEntropyService({
|
|
stat,
|
|
open: async (...args) => {
|
|
opens += 1;
|
|
const file = await open(...args);
|
|
const close = file.close.bind(file);
|
|
vi.spyOn(file, "close").mockImplementation(async () => {
|
|
if (failClose) throw new Error("injected close failure");
|
|
await close();
|
|
});
|
|
return file;
|
|
},
|
|
});
|
|
|
|
const first = await service.inspect({ path, block_size: 256 });
|
|
if (first.ok) throw new Error("Expected the first close to fail");
|
|
expect(first.error).toMatchObject({
|
|
_tag: "AnalysisOutputError",
|
|
cleanupIncomplete: true,
|
|
});
|
|
const observation = first.error.partialObservation;
|
|
expect(observation).toMatchObject({
|
|
operation: "inspect_byte_entropy",
|
|
normalized_result: { artifact: { path, bytes: 512 }, file_entropy: 0 },
|
|
});
|
|
expect(opens).toBe(1);
|
|
|
|
const retryDenied = await service.inspect({ path, block_size: 256 });
|
|
expect(retryDenied).toMatchObject({
|
|
ok: false,
|
|
error: { _tag: "AnalysisOutputError", cleanupIncomplete: true },
|
|
});
|
|
expect(opens).toBe(1);
|
|
|
|
failClose = false;
|
|
const recovered = await service.inspect({ path, block_size: 256 });
|
|
expect(recovered.ok).toBe(true);
|
|
expect(first.error.cleanupIncomplete).toBe(false);
|
|
expect(first.error.partialObservation).toBe(observation);
|
|
expect(opens).toBe(2);
|
|
await service.close();
|
|
});
|
|
|
|
it("preserves a primary read failure through failed close and resolves it on retry", async () => {
|
|
const root = await createTestTempDirectory("rea-entropy-primary-close-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(512));
|
|
const readFailure = new Error("injected read failure");
|
|
let failClose = true;
|
|
let failRead = true;
|
|
const service = new ByteEntropyService({
|
|
stat,
|
|
open: async (...args) => {
|
|
const file = await open(...args);
|
|
const read = file.read.bind(file);
|
|
const close = file.close.bind(file);
|
|
vi.spyOn(file, "read").mockImplementation(async (...readArgs) => {
|
|
if (failRead) throw readFailure;
|
|
return await read(...readArgs);
|
|
});
|
|
vi.spyOn(file, "close").mockImplementation(async () => {
|
|
if (failClose) throw new Error("injected close failure");
|
|
await close();
|
|
});
|
|
return file;
|
|
},
|
|
});
|
|
|
|
const first = await service.inspect({ path, block_size: 256 });
|
|
if (first.ok) throw new Error("Expected the read and close to fail");
|
|
expect(first.error).toMatchObject({
|
|
cleanupIncomplete: true,
|
|
cleanupPrimary: { _tag: "AnalysisOutputError" },
|
|
});
|
|
expect(first.error.cleanupPrimary?.cause).toBe(readFailure);
|
|
expect(first.error.cause).toBeDefined();
|
|
|
|
failClose = false;
|
|
failRead = false;
|
|
const recovered = await service.inspect({ path, block_size: 256 });
|
|
expect(recovered.ok).toBe(true);
|
|
expect(first.error.cleanupIncomplete).toBe(false);
|
|
await service.close();
|
|
});
|
|
|
|
it.each(["stat", "open"] as const)(
|
|
"preserves %s access failure when the signal aborts before rejection is consumed",
|
|
async (stage) => {
|
|
const root = await createTestTempDirectory("rea-entropy-physical-failure-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(512));
|
|
const controller = new AbortController();
|
|
const failure = Object.assign(new Error("access denied"), {
|
|
code: "EACCES",
|
|
});
|
|
const reject = async () => {
|
|
controller.abort({ request: "late cancellation" });
|
|
throw failure;
|
|
};
|
|
const service = new ByteEntropyService({
|
|
stat: stage === "stat" ? reject : stat,
|
|
open: stage === "open" ? reject : open,
|
|
});
|
|
const result = await service.inspect(
|
|
{ path },
|
|
{ signal: controller.signal },
|
|
);
|
|
if (result.ok) throw new Error("Expected access failure");
|
|
expect(result.error).toMatchObject({ _tag: "AnalysisAccessDeniedError" });
|
|
expect(result.error.cause).toBe(failure);
|
|
expect(result.error.partialObservation).toBeUndefined();
|
|
await service.close();
|
|
},
|
|
);
|
|
|
|
it.each([false, true])(
|
|
"preserves read access failure through late cancellation (close fails: %s)",
|
|
async (closeFails) => {
|
|
const root = await createTestTempDirectory("rea-entropy-read-access-");
|
|
const path = join(root, "bytes");
|
|
await writeFile(path, Buffer.alloc(512));
|
|
const controller = new AbortController();
|
|
const failure = Object.assign(new Error("read access denied"), {
|
|
code: "EACCES",
|
|
});
|
|
let failClose = closeFails;
|
|
const service = new ByteEntropyService({
|
|
stat,
|
|
open: async (...args) => {
|
|
const file = await open(...args);
|
|
const close = file.close.bind(file);
|
|
vi.spyOn(file, "read").mockImplementation(async () => {
|
|
controller.abort({ request: "late cancellation" });
|
|
throw failure;
|
|
});
|
|
vi.spyOn(file, "close").mockImplementation(async () => {
|
|
if (failClose) throw new Error("close denied");
|
|
await close();
|
|
});
|
|
return file;
|
|
},
|
|
});
|
|
const result = await service.inspect(
|
|
{ path },
|
|
{ signal: controller.signal },
|
|
);
|
|
if (result.ok) throw new Error("Expected read failure");
|
|
const primary = result.error.cleanupPrimary ?? result.error;
|
|
expect(primary).toMatchObject({ _tag: "AnalysisAccessDeniedError" });
|
|
expect(primary.cause).toBe(failure);
|
|
expect(result.error.cleanupIncomplete).toBe(closeFails);
|
|
expect(result.error.partialObservation).toBeUndefined();
|
|
failClose = false;
|
|
await service.close();
|
|
expect(result.error.cleanupIncomplete).toBe(false);
|
|
},
|
|
);
|