mirror of
https://github.com/morluto/rea.git
synced 2026-11-19 21:23:45 +00:00
* feat(rust): read cargo-auditable dependencies from WebAssembly modules cargo-auditable embeds the same zlib-compressed `.dep-v0` JSON in a WebAssembly custom section for wasm32 targets, but inspect_rust_binary rejected every module as an unsupported target because only ELF, PE and thin Mach-O containers were recognized. Walk the section framing of version 1 core modules to locate the `.dep-v0` custom-section payload and the data section, where rustc keeps its constant /rustc/<hash>/ paths. Rust lookups now read one format-neutral layout, so native and WebAssembly images share a single dependency-section owner. WebAssembly declares no container word size, so `bits` is null for that format only; the Evidence subject format is `file`, as for inspect_wasm_artifact. Truncated sections, invalid LEB128 sizes, custom-section names that run past their section or are not UTF-8, duplicate `.dep-v0` sections and a second data section are malformed. Components, such as wasm32-wasip2 output, embed core modules and are refused as unsupported, like universal Mach-O containers, rather than inspected through one selected module. * fix(rust): bound the WebAssembly section walk The WebAssembly reader visited every section synchronously, and the format sets no section count. A 256 MiB input of three-byte custom sections with empty names walked about 89 million sections and held the event loop for about 7.4 seconds, delaying cancellation and other MCP requests; empty type sections took about 1.9 seconds. Refuse a module with more than 65,536 sections with a typed cpu resource constraint that reports maximum_wasm_sections, as the Go header search reports its work budget. Producer output holds a few dozen sections, and the same inputs are now refused within tens of milliseconds. * fix(rust): accept WebAssembly Evidence in retained dependency views Retained Rust views compared the parent subject with a Mach-O-only format mapping, so WebAssembly Evidence, whose subject format is file, was refused as a different artifact. The report domain now owns the subject format next to the architecture mapping, and the service and the view both use it. The real CLI/MCP view workflow now also covers a WebAssembly module. * fix(rust): name the WebAssembly section-walk allowance in recovery Fixed-allowance recovery mapped every Rust resource other than capacity and transport to the parser allowance, so the section-walk refusal said host memory does not raise it. Each Rust resource now maps to its own allowance, and the cpu bound is a fixed work allowance. The MCP error contract test checks that the refusal is not retryable and names that allowance. * fix(rust): require WebAssembly container facts in reports The report schema tied a null word size to WebAssembly, but it accepted a wasm report that named a native architecture or big-endian byte order, and a native report that named the wasm architecture. Retained views parse imported Evidence with this schema, so such a contradictory report was accepted. The architecture is now wasm exactly when the container is WebAssembly, and a WebAssembly report must be little-endian. * docs(rust): record the WebAssembly dependency-metadata feature Feature work now carries a spec, plan and task list under docs/specs. This adds that record for reading cargo-auditable metadata from WebAssembly core modules and indexes it. The record states that it was written during review and lists the verification that remains open. * fix(rust): bind section names to containers and share the LEB128 reader The report schema accepted a dependency section name that does not belong to the report's container, such as a WebAssembly report naming the Mach-O section. rustDependencySectionName now owns that name for the reader and the schema, which refuses a mismatch for every container. The WebAssembly reader decoded section sizes with its own loop. It now uses the shared readLeb128, and an integer cut off by the end of the file is truncated rather than malformed. * fix(rust): classify a cut-off WebAssembly integer by its boundary The reader called an unfinished LEB128 integer truncated whenever its limit equalled the file length. A name length cut off inside the final section was therefore truncated, and the same bytes followed by another section were malformed. Each caller now states whether the file or the enclosing section bounds the integer. * fix(rust): report a duplicate WebAssembly dependency section first The section walk kept two .dep-v0 matches but walked on, so a module with two dependency sections and more than 65,536 sections after them was refused for the section bound instead of the duplicate it had already established. The walk now ends at the second match. * test(rust): assert WebAssembly container facts instead of limitation prose The CLI acceptance test matched an English limitation sentence. It now checks format, architecture, bits and byte order on the parsed report. * fix(rust): state container word size as 32 | 64 | null Output contract: inspect_rust_binary bits, including the summary view, is 32 | 64 | null. Null is valid only for WebAssembly and is not a number. ELF, PE and Mach-O reports stay 32 or 64. The schema description, guide, feature record and skill state that, and CLI renderers keep null instead of substituting a word size. --------- Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Cursor Agent <cursoragent@cursor.com>
619 lines
19 KiB
TypeScript
619 lines
19 KiB
TypeScript
import { expect, it } from "vitest";
|
|
import { fat } from "../../../src/domain/binaryTarget.fixture.js";
|
|
import {
|
|
createRustImage,
|
|
createRustImageWithGoSection,
|
|
createRustHashOverflowImage,
|
|
createRustWasmModule,
|
|
createWasmSectionFlood,
|
|
compressRustElfSectionNames,
|
|
rustElfSectionNameFixture,
|
|
RUSTC_HASH,
|
|
rustDependencyPayload,
|
|
WASM_MODULE_HEADER,
|
|
wasmCustomSection,
|
|
wasmSection,
|
|
} from "../../fixtures/rust/image.js";
|
|
import { readRustBinaryImage } from "../../../src/rust/RustBinaryImage.js";
|
|
import { readBinaryContainer } from "../../../src/domain/native/readBinaryContainer.js";
|
|
import { readGoBinaryImage } from "../../../src/go/GoBinaryImage.js";
|
|
import { ParseFailureError } from "../../../src/domain/parseFailure.js";
|
|
|
|
const packages = [
|
|
{
|
|
name: "itoa",
|
|
version: "1.0.18",
|
|
source: "crates.io",
|
|
kind: null,
|
|
dependencies: [],
|
|
features: null,
|
|
root: false,
|
|
},
|
|
{
|
|
name: "sample",
|
|
version: "0.1.0",
|
|
source: "local",
|
|
kind: null,
|
|
dependencies: [0],
|
|
features: null,
|
|
root: true,
|
|
},
|
|
];
|
|
|
|
it.each([
|
|
["named", ".rodata"],
|
|
["empty", ""],
|
|
["unavailable", null],
|
|
] as const)(
|
|
"retains read-only ELF section bytes with a %s name",
|
|
(name, expectedName) => {
|
|
const bytes = rustElfSectionNameFixture(name);
|
|
const container = readBinaryContainer(bytes);
|
|
expect(container.load_regions?.every(({ write }) => write)).toBe(true);
|
|
expect(container.sections).toContainEqual(
|
|
expect.objectContaining({
|
|
format: "elf",
|
|
name: expectedName,
|
|
offset: 2048,
|
|
read_only: true,
|
|
file_backed: true,
|
|
}),
|
|
);
|
|
expect(readRustBinaryImage(bytes).rustc_commit?.hashes).toEqual([
|
|
{ hash: RUSTC_HASH, file_offset: 2048 },
|
|
]);
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
["writable", 1, 3n],
|
|
["executable", 1, 6n],
|
|
["unallocated", 1, 0n],
|
|
["NOBITS", 8, 2n],
|
|
["NULL", 0, 2n],
|
|
] as const)(
|
|
"does not scan unnamed ELF %s sections for compiler paths",
|
|
(_kind, type, flags) => {
|
|
const bytes = rustElfSectionNameFixture("empty");
|
|
bytes.writeUInt32LE(type, 384 + 4);
|
|
bytes.writeBigUInt64LE(flags, 384 + 8);
|
|
expect(readBinaryContainer(bytes).sections).not.toContainEqual(
|
|
expect.objectContaining({ offset: 2048, read_only: true }),
|
|
);
|
|
expect(readRustBinaryImage(bytes).rustc_commit).toBeNull();
|
|
},
|
|
);
|
|
|
|
it("does not scan an unnamed ELF section whose declared range leaves the file", () => {
|
|
const bytes = rustElfSectionNameFixture("empty");
|
|
// The compiler path still exists at 2048, but its declared section no longer fits.
|
|
bytes.writeBigUInt64LE(BigInt(bytes.length), 384 + 32);
|
|
expect(readBinaryContainer(bytes).sections).not.toContainEqual(
|
|
expect.objectContaining({ read_only: true }),
|
|
);
|
|
expect(readRustBinaryImage(bytes).rustc_commit).toBeNull();
|
|
});
|
|
|
|
it.each(["elf", "pe"] as const)(
|
|
"reads a .dep-v0 section and an inferred rustc hash from %s",
|
|
(format) => {
|
|
const image = readRustBinaryImage(createRustImage({ format }));
|
|
expect(image.format).toBe(format);
|
|
expect(image.auditable_metadata).toMatchObject({
|
|
section_name: ".dep-v0",
|
|
file_offset: 1024,
|
|
section_bytes: rustDependencyPayload().length,
|
|
format_version: 1,
|
|
root_package_index: 1,
|
|
packages,
|
|
dependency_edges: [{ from_index: 1, to_index: 0 }],
|
|
});
|
|
expect(image.rustc_commit).toEqual({
|
|
evidence_kind: "inferred",
|
|
hashes: [{ hash: RUSTC_HASH, file_offset: 2048 }],
|
|
});
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
["\\", [{ hash: RUSTC_HASH, file_offset: 2048 }]],
|
|
["-", undefined],
|
|
] as const)(
|
|
"reads a rustc hash followed by %s only when it is a path separator",
|
|
(separator, hashes) => {
|
|
// Windows builds store /rustc/<hash>\library\...; the fixture path is at 2048.
|
|
const bytes = createRustImage({ format: "pe" });
|
|
bytes.write(
|
|
separator,
|
|
2048 + "/rustc/".length + RUSTC_HASH.length,
|
|
"latin1",
|
|
);
|
|
expect(readRustBinaryImage(bytes).rustc_commit?.hashes).toEqual(hashes);
|
|
},
|
|
);
|
|
|
|
it("reads a Mach-O __DATA,.dep-v0 section", () => {
|
|
const image = readRustBinaryImage(createRustImage({ format: "macho" }));
|
|
expect(image).toMatchObject({
|
|
format: "macho",
|
|
architecture: "arm64",
|
|
auditable_metadata: {
|
|
section_name: "__DATA,.dep-v0",
|
|
file_offset: 1024,
|
|
root_package_index: 1,
|
|
packages,
|
|
},
|
|
rustc_commit: {
|
|
evidence_kind: "inferred",
|
|
hashes: [{ hash: RUSTC_HASH, file_offset: 2048 }],
|
|
},
|
|
});
|
|
});
|
|
|
|
it("reads a .dep-v0 custom section and a data-section rustc hash from a WebAssembly module", () => {
|
|
const bytes = createRustWasmModule();
|
|
expect(readRustBinaryImage(bytes)).toEqual({
|
|
format: "wasm",
|
|
architecture: "wasm",
|
|
bits: null,
|
|
byte_order: "little",
|
|
auditable_metadata: expect.objectContaining({
|
|
section_name: ".dep-v0",
|
|
file_offset: bytes.indexOf(rustDependencyPayload()),
|
|
section_bytes: rustDependencyPayload().length,
|
|
format_version: 1,
|
|
root_package_index: 1,
|
|
packages,
|
|
dependency_edges: [{ from_index: 1, to_index: 0 }],
|
|
}),
|
|
rustc_commit: {
|
|
evidence_kind: "inferred",
|
|
hashes: [{ hash: RUSTC_HASH, file_offset: bytes.indexOf("/rustc/") }],
|
|
},
|
|
});
|
|
});
|
|
|
|
it("returns null metadata for a WebAssembly module without .dep-v0", () => {
|
|
const bytes = createRustWasmModule({ omitSection: true });
|
|
const image = readRustBinaryImage(bytes);
|
|
expect(image).toMatchObject({ format: "wasm", bits: null });
|
|
expect(image.auditable_metadata).toBeNull();
|
|
expect(image.rustc_commit?.hashes).toEqual([
|
|
{ hash: RUSTC_HASH, file_offset: bytes.indexOf("/rustc/") },
|
|
]);
|
|
});
|
|
|
|
it.each([
|
|
[
|
|
"a component",
|
|
Buffer.from("0061736d0d000100", "hex"),
|
|
{ kind: "unsupported", format: "wasm", offset: 6, field: "layer" },
|
|
],
|
|
[
|
|
"a pre-release core module",
|
|
Buffer.from("0061736d0d000000", "hex"),
|
|
{ kind: "unsupported", format: "wasm", offset: 4, field: "version" },
|
|
],
|
|
[
|
|
"a truncated header",
|
|
WASM_MODULE_HEADER.subarray(0, 6),
|
|
{ kind: "truncated", format: "wasm", offset: 0 },
|
|
],
|
|
[
|
|
"a section past the end of the file",
|
|
Buffer.concat([WASM_MODULE_HEADER, Buffer.from([0x01, 0x05, 0x00])]),
|
|
{ kind: "truncated", format: "wasm", offset: 8, field: "section" },
|
|
],
|
|
[
|
|
"a section size cut off by the end of the file",
|
|
Buffer.concat([WASM_MODULE_HEADER, Buffer.from([0x00, 0x80])]),
|
|
{ kind: "truncated", format: "wasm", offset: 9, field: "section size" },
|
|
],
|
|
[
|
|
"a custom name length cut off by its section",
|
|
Buffer.concat([
|
|
WASM_MODULE_HEADER,
|
|
wasmSection(0, Buffer.from([0x80])),
|
|
wasmSection(1, Buffer.from([0x00])),
|
|
]),
|
|
{
|
|
kind: "malformed",
|
|
format: "wasm",
|
|
offset: 10,
|
|
field: "custom section name length",
|
|
},
|
|
],
|
|
[
|
|
"a custom name length cut off by the final section",
|
|
Buffer.concat([WASM_MODULE_HEADER, wasmSection(0, Buffer.from([0x80]))]),
|
|
{
|
|
kind: "malformed",
|
|
format: "wasm",
|
|
offset: 10,
|
|
field: "custom section name length",
|
|
},
|
|
],
|
|
[
|
|
"a section size over 32 bits",
|
|
Buffer.concat([
|
|
WASM_MODULE_HEADER,
|
|
Buffer.from([0x00, 0xff, 0xff, 0xff, 0xff, 0x1f]),
|
|
]),
|
|
{ kind: "malformed", format: "wasm", offset: 9, field: "section size" },
|
|
],
|
|
[
|
|
"a custom name past its section",
|
|
Buffer.concat([
|
|
WASM_MODULE_HEADER,
|
|
wasmSection(0, Buffer.from([0x05, 0x61])),
|
|
]),
|
|
{
|
|
kind: "malformed",
|
|
format: "wasm",
|
|
offset: 10,
|
|
field: "custom section name",
|
|
},
|
|
],
|
|
[
|
|
"a non-UTF-8 custom section name",
|
|
Buffer.concat([
|
|
WASM_MODULE_HEADER,
|
|
wasmCustomSection(Buffer.from([0xff]), Buffer.alloc(0)),
|
|
]),
|
|
{
|
|
kind: "malformed",
|
|
format: "wasm",
|
|
offset: 11,
|
|
field: "custom section name",
|
|
},
|
|
],
|
|
[
|
|
"a duplicate .dep-v0 custom section",
|
|
createRustWasmModule({
|
|
sections: [wasmCustomSection(".dep-v0", rustDependencyPayload())],
|
|
}),
|
|
{ kind: "malformed", format: "rust-auditable" },
|
|
],
|
|
[
|
|
"a second data section",
|
|
createRustWasmModule({ sections: [wasmSection(11, Buffer.from([0]))] }),
|
|
{ kind: "malformed", format: "wasm", field: "data section" },
|
|
],
|
|
] as const)("refuses WebAssembly with %s", (_name, bytes, failure) => {
|
|
expect(() => readRustBinaryImage(bytes)).toThrow(
|
|
expect.objectContaining({
|
|
failure: expect.objectContaining(failure),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("reports a duplicate .dep-v0 section ahead of the section bound that follows it", () => {
|
|
const bytes = createRustWasmModule({
|
|
sections: [
|
|
wasmCustomSection(".dep-v0", rustDependencyPayload()),
|
|
createWasmSectionFlood(65_537).subarray(WASM_MODULE_HEADER.length),
|
|
],
|
|
});
|
|
expect(() => readRustBinaryImage(bytes)).toThrow(
|
|
expect.objectContaining({
|
|
failure: expect.objectContaining({
|
|
kind: "malformed",
|
|
format: "rust-auditable",
|
|
}),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("bounds the synchronous WebAssembly section walk", () => {
|
|
expect(
|
|
readRustBinaryImage(createWasmSectionFlood(65_536)).auditable_metadata,
|
|
).toBeNull();
|
|
expect(() => readRustBinaryImage(createWasmSectionFlood(65_537))).toThrow(
|
|
expect.objectContaining({
|
|
failure: expect.objectContaining({
|
|
kind: "limit",
|
|
format: "wasm",
|
|
limit: { name: "max_wasm_sections", maximum: 65_536 },
|
|
}),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("preserves the arm64_32 Mach-O CPU family when dependency metadata is absent", () => {
|
|
const bytes = createRustImage({
|
|
format: "macho",
|
|
omitSection: true,
|
|
includeRustc: false,
|
|
});
|
|
bytes.writeUInt32LE(0x0200000c, 4);
|
|
|
|
expect(readRustBinaryImage(bytes)).toMatchObject({
|
|
format: "macho",
|
|
architecture: "arm64_32",
|
|
bits: 64,
|
|
auditable_metadata: null,
|
|
rustc_commit: null,
|
|
});
|
|
});
|
|
|
|
it("uses the shared ELF classifier for Rust image architecture", () => {
|
|
const bytes = createRustImage({
|
|
format: "elf",
|
|
omitSection: true,
|
|
includeRustc: true,
|
|
});
|
|
bytes.writeUInt16LE(164, 18); // ELF EM_HEXAGON.
|
|
expect(readRustBinaryImage(bytes)).toMatchObject({
|
|
format: "elf",
|
|
architecture: "hexagon",
|
|
auditable_metadata: null,
|
|
});
|
|
});
|
|
|
|
it("ignores PE file-alignment padding after the dependency content", () => {
|
|
const bytes = createRustImage({ format: "pe", includeRustc: false });
|
|
const payloadBytes = rustDependencyPayload().length;
|
|
const entry = 264;
|
|
expect(bytes.readUInt32LE(entry + 8)).toBe(payloadBytes);
|
|
bytes.writeUInt32LE(512, entry + 16);
|
|
const image = readRustBinaryImage(bytes);
|
|
expect(image.auditable_metadata).toMatchObject({
|
|
section_name: ".dep-v0",
|
|
section_bytes: payloadBytes,
|
|
packages,
|
|
});
|
|
});
|
|
|
|
it("recognizes zero-virtual-size PE raw padding without accepting payload junk", () => {
|
|
const payloadBytes = rustDependencyPayload().length;
|
|
const entry = 264;
|
|
const bytes = createRustImage({ format: "pe", includeRustc: false });
|
|
bytes.writeUInt32LE(0, entry + 8);
|
|
bytes.writeUInt32LE(512, entry + 16);
|
|
bytes.writeUInt32LE(512, 188); // Optional-header FileAlignment.
|
|
expect(readRustBinaryImage(bytes).auditable_metadata).toMatchObject({
|
|
section_bytes: 512,
|
|
compressed_bytes: payloadBytes,
|
|
packages,
|
|
});
|
|
|
|
const payloadOffset = bytes.readUInt32LE(entry + 20);
|
|
const nonzeroSuffix = Buffer.from(bytes);
|
|
nonzeroSuffix[payloadOffset + payloadBytes] = 1;
|
|
expect(() => readRustBinaryImage(nonzeroSuffix)).toThrow(
|
|
/bytes after the zlib stream/u,
|
|
);
|
|
|
|
const truncated = Buffer.from(bytes);
|
|
truncated[payloadOffset + payloadBytes - 1] =
|
|
truncated[payloadOffset + payloadBytes - 1]! ^ 0xff;
|
|
expect(() => readRustBinaryImage(truncated)).toThrow(/complete zlib stream/u);
|
|
|
|
const nonzeroVirtualSize = Buffer.from(bytes);
|
|
nonzeroVirtualSize.writeUInt32LE(payloadBytes + 1, entry + 8);
|
|
expect(() => readRustBinaryImage(nonzeroVirtualSize)).toThrow(
|
|
/bytes after the zlib stream/u,
|
|
);
|
|
|
|
const unknownAlignment = Buffer.from(bytes);
|
|
unknownAlignment.writeUInt32LE(0, 188);
|
|
expect(() => readRustBinaryImage(unknownAlignment)).toThrow(
|
|
/bytes after the zlib stream/u,
|
|
);
|
|
});
|
|
|
|
it("returns null metadata when the dependency section is absent", () => {
|
|
const image = readRustBinaryImage(
|
|
createRustImage({ format: "elf", omitSection: true }),
|
|
);
|
|
expect(image.auditable_metadata).toBeNull();
|
|
expect(image.rustc_commit?.hashes).toEqual([
|
|
{ hash: RUSTC_HASH, file_offset: 2048 },
|
|
]);
|
|
});
|
|
|
|
it.each([1, 2])(
|
|
"reads dependency metadata through ELF section-name compression %i",
|
|
(compressionType) => {
|
|
const image = readRustBinaryImage(
|
|
compressRustElfSectionNames(
|
|
createRustImage({ format: "elf" }),
|
|
compressionType,
|
|
),
|
|
);
|
|
expect(image.auditable_metadata).toMatchObject({
|
|
section_name: ".dep-v0",
|
|
file_offset: 1024,
|
|
packages,
|
|
dependency_edges: [{ from_index: 1, to_index: 0 }],
|
|
});
|
|
},
|
|
);
|
|
|
|
it("keeps dependency presence unknown for unsupported ELF name compression", () => {
|
|
const image = readRustBinaryImage(
|
|
compressRustElfSectionNames(createRustImage({ format: "elf" }), 3),
|
|
);
|
|
expect(image.auditable_metadata).toBeNull();
|
|
expect(image.section_names_limitation).toMatch(
|
|
/compression type 3 is unsupported/u,
|
|
);
|
|
expect(image.rustc_commit?.hashes).toEqual([
|
|
{ hash: RUSTC_HASH, file_offset: 2048 },
|
|
]);
|
|
});
|
|
|
|
it("keeps dependency presence unknown when its ELF name offset is unreadable", () => {
|
|
const bytes = createRustImage({ format: "elf" });
|
|
bytes.writeUInt32LE(0xffff, 384);
|
|
|
|
const image = readRustBinaryImage(bytes);
|
|
expect(image.auditable_metadata).toBeNull();
|
|
expect(image.section_names_limitation).toMatch(/outside its string table/u);
|
|
expect(image.rustc_commit?.hashes).toEqual([
|
|
{ hash: RUSTC_HASH, file_offset: 2048 },
|
|
]);
|
|
});
|
|
|
|
it("finds rustc paths in read-only ELF load data without section headers", () => {
|
|
const bytes = createRustImage({
|
|
format: "elf",
|
|
omitSection: true,
|
|
includeRustc: true,
|
|
});
|
|
bytes.writeBigUInt64LE(0n, 40);
|
|
bytes.writeUInt16LE(0, 60);
|
|
bytes.writeUInt16LE(0, 62);
|
|
bytes.writeUInt32LE(4, 132); // PF_R, no write or execute permission.
|
|
|
|
expect(readRustBinaryImage(bytes)).toMatchObject({
|
|
auditable_metadata: null,
|
|
rustc_commit: {
|
|
evidence_kind: "inferred",
|
|
hashes: [{ hash: RUSTC_HASH, file_offset: 2048 }],
|
|
},
|
|
});
|
|
|
|
bytes.writeUInt32LE(6, 132); // PF_R | PF_W is not read-only data.
|
|
expect(readRustBinaryImage(bytes).rustc_commit).toBeNull();
|
|
});
|
|
|
|
it("refuses a universal Mach-O container", () => {
|
|
expect(() => readRustBinaryImage(fat([0x0100000c]))).toThrow(
|
|
ParseFailureError,
|
|
);
|
|
expect(() => readRustBinaryImage(fat([0x0100000c]))).toThrow(/thin slice/);
|
|
});
|
|
|
|
it("keeps the container's truncated failure and its facts unchanged", () => {
|
|
const bytes = createRustImage({ format: "elf" });
|
|
// The fixture's first program header is at byte 128; p_filesz and
|
|
// p_memsz are at +32 and +40.
|
|
bytes.writeBigUInt64LE(BigInt(bytes.length) * 2n, 128 + 32);
|
|
bytes.writeBigUInt64LE(BigInt(bytes.length) * 2n, 128 + 40);
|
|
const thrown = (read: () => unknown): unknown => {
|
|
try {
|
|
read();
|
|
} catch (cause: unknown) {
|
|
return cause;
|
|
}
|
|
throw new Error("expected a container failure");
|
|
};
|
|
const container = thrown(() => readBinaryContainer(bytes));
|
|
const rust = thrown(() => readRustBinaryImage(bytes));
|
|
expect(rust).toBeInstanceOf(ParseFailureError);
|
|
expect((rust as ParseFailureError).failure).toEqual(
|
|
(container as ParseFailureError).failure,
|
|
);
|
|
expect((rust as ParseFailureError).failure).toMatchObject({
|
|
kind: "truncated",
|
|
format: "elf",
|
|
offset: expect.any(Number),
|
|
field: expect.any(String),
|
|
});
|
|
});
|
|
|
|
it("does not read SHT_NOBITS dependency sections as stored bytes", () => {
|
|
const bytes = createRustImage({ format: "elf" });
|
|
// The fixture writes the .dep-v0 section header at byte 384.
|
|
bytes.writeUInt32LE(8, 384 + 4);
|
|
let metadata: unknown;
|
|
try {
|
|
metadata = readRustBinaryImage(bytes).auditable_metadata;
|
|
} catch (cause: unknown) {
|
|
expect(cause).toBeInstanceOf(ParseFailureError);
|
|
return;
|
|
}
|
|
expect(metadata).toBeNull();
|
|
});
|
|
|
|
it("reads a rustc path from a read-only ELF section whose name exceeds 64 bytes", () => {
|
|
const bytes = createRustImage({ format: "elf", omitSection: true });
|
|
// omitSection places the rustc section header at 384 and shstrtab at 320.
|
|
const nameOffset = bytes.readUInt32LE(384);
|
|
const tableOffset = Number(bytes.readBigUInt64LE(320 + 24));
|
|
const longName = Buffer.concat([Buffer.alloc(65, 0x61), Buffer.from([0])]);
|
|
longName.copy(bytes, tableOffset + nameOffset);
|
|
bytes.writeBigUInt64LE(BigInt(nameOffset + longName.length), 320 + 32);
|
|
const image = readRustBinaryImage(bytes);
|
|
expect(image.auditable_metadata).toBeNull();
|
|
expect(image.rustc_commit).toEqual({
|
|
evidence_kind: "inferred",
|
|
hashes: [{ hash: RUSTC_HASH, file_offset: 2048 }],
|
|
});
|
|
});
|
|
|
|
it("retains dependency facts when compiler paths exceed the selected prefix", () => {
|
|
const bytes = createRustHashOverflowImage();
|
|
const partial = readRustBinaryImage(bytes);
|
|
expect(partial.auditable_metadata?.packages.map(({ name }) => name)).toEqual([
|
|
"itoa",
|
|
"sample",
|
|
]);
|
|
expect(partial.rustc_commit?.hashes).toHaveLength(64);
|
|
expect(partial.rustc_commit?.coverage).toEqual({
|
|
status: "partial",
|
|
reason: "max_rustc_hashes",
|
|
effective_limit: 64,
|
|
limit: {
|
|
control_kind: "parameter",
|
|
parameter: "max_rustc_hashes",
|
|
effective_value: 64,
|
|
unit: "count",
|
|
minimum: 1,
|
|
maximum: Number.MAX_SAFE_INTEGER,
|
|
default_value: 64,
|
|
applies_at: "next_call",
|
|
},
|
|
});
|
|
const recovered = readRustBinaryImage(bytes, 65);
|
|
expect(recovered.rustc_commit?.hashes).toHaveLength(65);
|
|
expect(recovered.rustc_commit).not.toHaveProperty("coverage");
|
|
expect(recovered.auditable_metadata).toEqual(partial.auditable_metadata);
|
|
});
|
|
|
|
it.each([
|
|
["elf", "compressed"],
|
|
["elf", "unmapped"],
|
|
["elf", "zero-fill"],
|
|
["elf", "duplicate"],
|
|
["elf", "out-of-file"],
|
|
["elf", "zero-address"],
|
|
["macho", "unmapped"],
|
|
["macho", "zero-fill"],
|
|
["macho", "duplicate"],
|
|
["macho", "out-of-file"],
|
|
] as const)(
|
|
"retains Rust evidence beside an unrelated %s %s Go section",
|
|
(format, fault) => {
|
|
const bytes = createRustImageWithGoSection(format, fault);
|
|
const control = Buffer.from(bytes);
|
|
const sectionOffset = format === "elf" ? 768 + 11 : 408;
|
|
const sectionName = Buffer.from(
|
|
(format === "elf" ? ".other\0" : "__other\0").padEnd(
|
|
format === "elf" ? 13 : 16,
|
|
"\0",
|
|
),
|
|
"ascii",
|
|
);
|
|
if (format === "elf") {
|
|
const nameOffset = Number(bytes.readBigUInt64LE(320 + 32));
|
|
sectionName.copy(control, 768 + nameOffset);
|
|
} else {
|
|
sectionName.copy(control, sectionOffset);
|
|
}
|
|
expect(readBinaryContainer(bytes).load_regions).toEqual(
|
|
readBinaryContainer(control).load_regions,
|
|
);
|
|
expect(() => readGoBinaryImage(bytes)).toThrow(/build-info|mapped/i);
|
|
expect(readRustBinaryImage(bytes)).toMatchObject({
|
|
format,
|
|
auditable_metadata: { file_offset: 1024, packages },
|
|
rustc_commit: {
|
|
evidence_kind: "inferred",
|
|
hashes: [{ hash: RUSTC_HASH, file_offset: 2048 }],
|
|
},
|
|
});
|
|
},
|
|
);
|