mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 11:43:20 +00:00
test(native): bound section lookups by table reads instead of elapsed time (#11648)
PE TLS callback and ELF initializer section lookups now assert section-table reads through a counting proxy on the parsed image, and the huge DT_INIT_ARRAYSZ case asserts mapping lookups. The kernel-module shared-name bound is deleted: removing the section-name cache already fails that test on the 16 MiB name budget.
This commit is contained in:
1 parent
e5cf021ca6
commit
8318d28176
3 files changed
+101
-14
No files matched your search
@@ -447,10 +447,10 @@ it("charges many sections sharing one huge __ksymtab name to the entry budget",
|
||||
const bytes = kernelModuleFixture({
|
||||
sharedNameSections: { name, count: 8192 },
|
||||
});
|
||||
const started = performance.now();
|
||||
expect(() => parse(bytes)).toThrow(ArtifactReaderFailure);
|
||||
// The shared name decodes once; per-section decoding exceeds the 16 MiB
|
||||
// section-name budget and refuses this module.
|
||||
const report = parse(bytes, { max_entries: 65_536 });
|
||||
expect(performance.now() - started).toBeLessThan(5_000);
|
||||
const huge = report.ksymtab?.sections.slice(1) ?? [];
|
||||
expect(huge).toHaveLength(8192);
|
||||
expect(
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { describe, expect, it, vi } from "vitest";
|
||||
import { describe, expect, it, onTestFinished, vi } from "vitest";
|
||||
import { deflateSync } from "node:zlib";
|
||||
import { readNativeInitializers } from "./NativeInitializersProvider.js";
|
||||
|
||||
@@ -6,6 +6,7 @@ import { readNativeInitializers } from "./NativeInitializersProvider.js";
|
||||
const mapping = vi.hoisted(() => ({
|
||||
scans: vi.fn(),
|
||||
indexes: vi.fn(),
|
||||
lookups: { count: 0 },
|
||||
}));
|
||||
vi.mock("../../domain/binaryContainer.js", async (importOriginal) => {
|
||||
const actual =
|
||||
@@ -22,10 +23,51 @@ vi.mock("../../domain/binaryContainer.js", async (importOriginal) => {
|
||||
...args: Parameters<typeof actual.createFileMappingIndex>
|
||||
) => {
|
||||
mapping.indexes(...args);
|
||||
return actual.createFileMappingIndex(...args);
|
||||
const index = actual.createFileMappingIndex(...args);
|
||||
return {
|
||||
...index,
|
||||
offset: (...lookup: Parameters<typeof index.offset>) => {
|
||||
mapping.lookups.count++;
|
||||
return index.offset(...lookup);
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
});
|
||||
/** Element reads of every parsed ELF section table, so tests can count section walks. */
|
||||
const sectionReads = vi.hoisted(() => ({ count: 0, budget: Infinity }));
|
||||
vi.mock(
|
||||
"../../domain/native/nativeSectionDirectory.js",
|
||||
async (importOriginal) => {
|
||||
const actual =
|
||||
await importOriginal<
|
||||
typeof import("../../domain/native/nativeSectionDirectory.js")
|
||||
>();
|
||||
return {
|
||||
...actual,
|
||||
readElfDirectoryFromBuffer: (
|
||||
...args: Parameters<typeof actual.readElfDirectoryFromBuffer>
|
||||
) => {
|
||||
const directory = actual.readElfDirectoryFromBuffer(...args);
|
||||
return {
|
||||
...directory,
|
||||
sections: new Proxy(directory.sections, {
|
||||
get(target, key, receiver) {
|
||||
// Past the budget a walk fails at once instead of finishing.
|
||||
if (
|
||||
typeof key === "string" &&
|
||||
/^\d+$/u.test(key) &&
|
||||
++sectionReads.count > sectionReads.budget
|
||||
)
|
||||
throw new Error("Section table read budget exceeded");
|
||||
return Reflect.get(target, key, receiver) as unknown;
|
||||
},
|
||||
}),
|
||||
};
|
||||
},
|
||||
};
|
||||
},
|
||||
);
|
||||
import {
|
||||
elf32RelativeInitializers,
|
||||
elf64PieInitializers,
|
||||
@@ -538,9 +580,13 @@ describe("ELF incomplete inputs", () => {
|
||||
const bytes = elf64PieInitializers();
|
||||
// DT_INIT_ARRAYSZ is the fourth dynamic entry; 2^50 slots is still a safe integer.
|
||||
bytes.writeBigUInt64LE(8n << 50n, 0x300 + 3 * 16 + 8);
|
||||
const started = performance.now();
|
||||
mapping.lookups.count = 0;
|
||||
const report = await read(bytes);
|
||||
expect(performance.now() - started).toBeLessThan(10_000);
|
||||
// Each admitted slot is located once; the rest of the image adds a few
|
||||
// hundred lookups (66194 here). An unclamped slot loop locates every slot.
|
||||
expect(mapping.lookups.count).toBeLessThan(
|
||||
MAX_NATIVE_INITIALIZER_ENTRIES + 1024,
|
||||
);
|
||||
expect(report.status).toBe("incomplete");
|
||||
expect(report.coverage).toMatchObject({
|
||||
status: "partial",
|
||||
@@ -950,10 +996,15 @@ describe("ELF section lookups", () => {
|
||||
bytes.writeBigUInt64LE(BigInt(bytes.length), 64 + 40);
|
||||
bytes.writeBigUInt64LE(BigInt(base.length), 0x300 + 2 * 16 + 8);
|
||||
bytes.writeBigUInt64LE(BigInt(slots * 8), 0x300 + 3 * 16 + 8);
|
||||
const started = performance.now();
|
||||
// Each consumer walks the table once (about 6 x 65535 reads); a
|
||||
// per-lookup walk would read it once per slot.
|
||||
sectionReads.count = 0;
|
||||
sectionReads.budget = 12 * 65535;
|
||||
onTestFinished(() => {
|
||||
sectionReads.budget = Infinity;
|
||||
});
|
||||
const report = await read(bytes);
|
||||
// A per-lookup header walk is about 4e9 comparisons here; the index is a few hundred ms.
|
||||
expect(performance.now() - started).toBeLessThan(10_000);
|
||||
expect(sectionReads.count).toBeLessThanOrEqual(sectionReads.budget);
|
||||
expect(report.coverage.examined_entries).toBe(slots);
|
||||
const slot = report.entries.find((entry) => entry.kind === "init_array");
|
||||
expect(slot).toMatchObject({
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { ArtifactReaderFailure } from "../../resources/ArtifactReader.js";
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { describe, expect, it, onTestFinished, vi } from "vitest";
|
||||
import {
|
||||
inspectPeLoadConfigInputSchema,
|
||||
peLoadConfigSchema,
|
||||
@@ -12,6 +12,37 @@ import {
|
||||
type PeLoadConfigFixtureOptions,
|
||||
} from "./PeLoadConfig.fixture.js";
|
||||
|
||||
/** Element reads of every parsed image's section and mapping tables. */
|
||||
const tableReads = vi.hoisted(() => ({ count: 0, budget: Infinity }));
|
||||
vi.mock("../../domain/native/peImage.js", async (importOriginal) => {
|
||||
const actual =
|
||||
await importOriginal<typeof import("../../domain/native/peImage.js")>();
|
||||
const counted = <T extends object>(table: readonly T[]): readonly T[] =>
|
||||
new Proxy(table, {
|
||||
get(target, key, receiver) {
|
||||
// Past the budget a walk fails at once instead of finishing.
|
||||
if (
|
||||
typeof key === "string" &&
|
||||
/^\d+$/u.test(key) &&
|
||||
++tableReads.count > tableReads.budget
|
||||
)
|
||||
throw new Error("Image table read budget exceeded");
|
||||
return Reflect.get(target, key, receiver) as unknown;
|
||||
},
|
||||
});
|
||||
return {
|
||||
...actual,
|
||||
readPeImage: (bytes: Buffer) => {
|
||||
const image = actual.readPeImage(bytes);
|
||||
return {
|
||||
...image,
|
||||
sections: counted(image.sections),
|
||||
mappings: counted(image.mappings),
|
||||
};
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
const parse = (
|
||||
options: PeLoadConfigFixtureOptions = {},
|
||||
max_callbacks = 64,
|
||||
@@ -177,9 +208,15 @@ it("retains a callback in virtual-only section storage with unknown file offset"
|
||||
).toMatchObject({ rva: 0x2200, file_offset: null, section: ".text" });
|
||||
});
|
||||
|
||||
it("resolves callback sections in bounded time for the largest section table", async () => {
|
||||
it("resolves callback sections without rescanning the largest section table", async () => {
|
||||
const bytes = peManySectionsImage(65535, 4096);
|
||||
const started = performance.now();
|
||||
// Building the section index reads each entry about twice (131071 here); a
|
||||
// per-callback scan would read about 4096 x 65535 entries.
|
||||
tableReads.count = 0;
|
||||
tableReads.budget = 4 * 65535;
|
||||
onTestFinished(() => {
|
||||
tableReads.budget = Infinity;
|
||||
});
|
||||
const report = await parsePeLoadConfig(
|
||||
bytes,
|
||||
{ path: "/sample.exe", sha256: "a".repeat(64), bytes: bytes.length },
|
||||
@@ -188,8 +225,7 @@ it("resolves callback sections in bounded time for the largest section table", a
|
||||
max_callbacks: 4096,
|
||||
}),
|
||||
);
|
||||
// A per-callback scan of every section takes several seconds here.
|
||||
expect(performance.now() - started).toBeLessThan(1_000);
|
||||
expect(tableReads.count).toBeLessThanOrEqual(tableReads.budget);
|
||||
expect(report.tls?.callbacks).toHaveLength(4096);
|
||||
expect(report.tls?.callbacks.every(({ section }) => section === ".v")).toBe(
|
||||
true,
|
||||
|
||||
Reference in new issue
Block a user