Decode MZ and Windows signature bytes without ASCII high-bit masking. Move malformed signature cases into the shared Go diagnostics fixtures so provider, compiled CLI, and MCP workflows cover NE, LE, LX, and PE lookalikes; remove the superseded provider-only cases. Validation: runtime build, check:ci, and focused DOS/Go/target/CLI/MCP tests. Windows-only reference-import cases await CI.
266 lines
8.2 KiB
TypeScript
266 lines
8.2 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
|
|
import { dosMz, pe } from "./binaryTarget.fixture.js";
|
|
import { parseExecutableHeader } from "./binaryTarget.js";
|
|
import { observeMzWindowsHeader, parseDosMzHeader } from "./dosMz.js";
|
|
|
|
describe("DOS MZ load-module validation", () => {
|
|
it("separates initialized module and appended overlay bytes", () => {
|
|
const image = dosMz(480);
|
|
const bytes = Buffer.concat([image, Buffer.from("overlay")]);
|
|
expect(parseDosMzHeader(bytes)).toEqual({
|
|
ok: true,
|
|
value: {
|
|
headerBytes: 32,
|
|
imageBytes: 512,
|
|
moduleBytes: 480,
|
|
overlayBytes: 7,
|
|
relocationCount: 0,
|
|
relocationTableOffset: 28,
|
|
entrySegment: 0,
|
|
entryOffset: 0,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("accepts relocation records overlapping the Windows new-header field", () => {
|
|
const bytes = Buffer.alloc(224);
|
|
dosMz().copy(bytes, 0, 0, 28);
|
|
bytes.writeUInt16LE(bytes.length, 2);
|
|
bytes.writeUInt16LE(6, 8);
|
|
bytes.writeUInt16LE(2, 6);
|
|
bytes.writeUInt16LE(62, 24);
|
|
bytes.writeUInt16LE(1, 62);
|
|
bytes.writeUInt16LE(8, 66);
|
|
expect(bytes.readUInt32LE(60)).toBe(65536);
|
|
expect(observeMzWindowsHeader(bytes)).toEqual({ state: "absent" });
|
|
expect(parseExecutableHeader(bytes, "x64")).toMatchObject({
|
|
ok: true,
|
|
value: { format: "dos-mz" },
|
|
});
|
|
expect(parseDosMzHeader(bytes)).toMatchObject({
|
|
ok: true,
|
|
value: { headerBytes: 96, relocationCount: 2, moduleBytes: 128 },
|
|
});
|
|
});
|
|
|
|
it("uses the actual file length rather than the bounded prefix length", () => {
|
|
const bytes = dosMz(8192);
|
|
expect(parseDosMzHeader(bytes.subarray(0, 64), bytes.length).ok).toBe(true);
|
|
expect(parseDosMzHeader(bytes.subarray(0, 64))).toMatchObject({
|
|
ok: false,
|
|
error: "truncated DOS MZ load module",
|
|
});
|
|
});
|
|
|
|
it("keeps a partial DOS prefix unknown until the Windows pointer is examined", () => {
|
|
const bytes = dosMz(64);
|
|
|
|
expect(observeMzWindowsHeader(bytes.subarray(0, 32), bytes.length)).toEqual(
|
|
{
|
|
state: "header-needed",
|
|
},
|
|
);
|
|
expect(
|
|
parseExecutableHeader(bytes.subarray(0, 32), "x64", bytes.length),
|
|
).toMatchObject({ ok: false });
|
|
expect(observeMzWindowsHeader(bytes.subarray(0, 32))).toEqual({
|
|
state: "absent",
|
|
});
|
|
});
|
|
|
|
it("parses a tiny known-length DOS module without requiring an impossible pointer", () => {
|
|
const bytes = Buffer.alloc(33);
|
|
bytes.write("MZ", 0, "ascii");
|
|
bytes.writeUInt16LE(bytes.length, 2);
|
|
bytes.writeUInt16LE(1, 4);
|
|
bytes.writeUInt16LE(2, 8);
|
|
bytes.writeUInt16LE(28, 24);
|
|
bytes[32] = 0xc3;
|
|
|
|
expect(observeMzWindowsHeader(bytes.subarray(0, 28), bytes.length)).toEqual(
|
|
{
|
|
state: "absent",
|
|
},
|
|
);
|
|
expect(
|
|
parseExecutableHeader(bytes.subarray(0, 28), "x64", bytes.length),
|
|
).toMatchObject({
|
|
ok: true,
|
|
value: { format: "dos-mz", architecture: "x86" },
|
|
});
|
|
});
|
|
|
|
it("preserves PE classification when low relocation records do not overlap e_lfanew", () => {
|
|
const bytes = pe(0x8664);
|
|
bytes.writeUInt16LE(4, 8);
|
|
bytes.writeUInt16LE(1, 6);
|
|
bytes.writeUInt16LE(28, 24);
|
|
expect(observeMzWindowsHeader(bytes)).toEqual({
|
|
state: "declared",
|
|
offset: 64,
|
|
signature: "PE",
|
|
});
|
|
expect(parseExecutableHeader(bytes, "x64")).toMatchObject({
|
|
ok: true,
|
|
value: { format: "pe", architecture: "x86_64" },
|
|
});
|
|
expect(parseDosMzHeader(bytes).ok).toBe(false);
|
|
});
|
|
|
|
it.each([
|
|
["page count", (bytes: Buffer) => bytes.writeUInt16LE(0, 4)],
|
|
["final-page size", (bytes: Buffer) => bytes.writeUInt16LE(512, 2)],
|
|
["header size", (bytes: Buffer) => bytes.writeUInt16LE(1, 8)],
|
|
["entry point", (bytes: Buffer) => bytes.writeUInt16LE(128, 20)],
|
|
[
|
|
"relocation-table bounds",
|
|
(bytes: Buffer) => {
|
|
bytes.writeUInt16LE(2, 6);
|
|
},
|
|
],
|
|
[
|
|
"relocation target",
|
|
(bytes: Buffer) => {
|
|
bytes.writeUInt16LE(1, 6);
|
|
bytes.writeUInt16LE(127, 28);
|
|
},
|
|
],
|
|
] as const)("rejects invalid %s", (_name, damage) => {
|
|
const bytes = dosMz();
|
|
damage(bytes);
|
|
expect(parseDosMzHeader(bytes).ok).toBe(false);
|
|
});
|
|
|
|
it("rejects a truncated relocation table even when the file size is known", () => {
|
|
const bytes = dosMz();
|
|
bytes.writeUInt16LE(1, 6);
|
|
expect(parseDosMzHeader(bytes.subarray(0, 30), bytes.length)).toMatchObject(
|
|
{
|
|
ok: false,
|
|
error: "truncated DOS MZ relocation table",
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("MZ Windows header observations", () => {
|
|
it.each(["NE", "LE", "LX"])(
|
|
"distinguishes unsupported %s from DOS",
|
|
(signature) => {
|
|
const bytes = pe(0x8664);
|
|
bytes.writeUInt16LE(4, 8);
|
|
bytes.writeUInt16LE(64, 24);
|
|
bytes.write(signature, 64, "ascii");
|
|
expect(parseExecutableHeader(bytes, "x64")).toEqual({
|
|
ok: false,
|
|
error: `unsupported ${signature} executable in MZ image`,
|
|
});
|
|
},
|
|
);
|
|
|
|
it("keeps a short-header nonzero module value as DOS without a signature", () => {
|
|
const bytes = dosMz(64);
|
|
bytes.writeUInt32LE(bytes.length, 60);
|
|
|
|
expect(observeMzWindowsHeader(bytes)).toEqual({ state: "absent" });
|
|
expect(parseExecutableHeader(bytes, "x64")).toMatchObject({
|
|
ok: true,
|
|
value: { format: "dos-mz", architecture: "x86" },
|
|
});
|
|
});
|
|
|
|
it.each(["PEZZ", "NE", "LE", "LX", "PE"])(
|
|
"keeps a non-Windows %s signature candidate as DOS",
|
|
(signature) => {
|
|
const bytes = dosMz(64);
|
|
const offset = 32;
|
|
bytes.writeUInt32LE(offset, 60);
|
|
const candidate = Buffer.from(
|
|
[...Buffer.from(signature)].map((byte) =>
|
|
signature === "PEZZ" ? byte : byte | 0x80,
|
|
),
|
|
);
|
|
bytes.set(candidate, offset);
|
|
|
|
expect(observeMzWindowsHeader(bytes)).toEqual({ state: "absent" });
|
|
expect(parseExecutableHeader(bytes, "x64")).toMatchObject({
|
|
ok: true,
|
|
value: { format: "dos-mz", architecture: "x86" },
|
|
});
|
|
},
|
|
);
|
|
|
|
it("accepts a short-header candidate only when it points at a Windows signature", () => {
|
|
const stub = dosMz(64);
|
|
const offset = stub.length;
|
|
stub.writeUInt32LE(offset, 60);
|
|
const record = pe(0x8664).subarray(64);
|
|
const bytes = Buffer.concat([stub, record]);
|
|
|
|
expect(observeMzWindowsHeader(bytes)).toMatchObject({
|
|
state: "declared",
|
|
offset,
|
|
signature: "PE",
|
|
});
|
|
expect(parseExecutableHeader(bytes, "x64")).toMatchObject({
|
|
ok: true,
|
|
value: { format: "pe", architecture: "x86_64" },
|
|
});
|
|
});
|
|
|
|
it.each(["NE", "LE", "LX"])(
|
|
"recognizes short-header %s signatures as Windows declarations",
|
|
(signature) => {
|
|
const stub = dosMz(64);
|
|
const offset = stub.length;
|
|
stub.writeUInt32LE(offset, 60);
|
|
const bytes = Buffer.concat([stub, Buffer.alloc(24)]);
|
|
bytes.write(signature, offset, "ascii");
|
|
|
|
expect(observeMzWindowsHeader(bytes)).toMatchObject({
|
|
state: "declared",
|
|
offset,
|
|
signature,
|
|
});
|
|
expect(parseExecutableHeader(bytes, "x64")).toEqual({
|
|
ok: false,
|
|
error: `unsupported ${signature} executable in MZ image`,
|
|
});
|
|
},
|
|
);
|
|
|
|
it("requests the signature when a short-header candidate is outside its prefix", () => {
|
|
const offset = 8192;
|
|
const bytes = dosMz(64);
|
|
bytes.writeUInt32LE(offset, 60);
|
|
const prefix = Buffer.alloc(4096);
|
|
bytes.copy(prefix);
|
|
|
|
expect(observeMzWindowsHeader(prefix, offset + 512)).toEqual({
|
|
state: "signature-needed",
|
|
offset,
|
|
});
|
|
expect(
|
|
observeMzWindowsHeader(
|
|
prefix,
|
|
offset + 512,
|
|
Buffer.from("PE\0\0", "binary"),
|
|
),
|
|
).toEqual({ state: "declared", offset, signature: "PE" });
|
|
});
|
|
|
|
it("does not fall back to DOS when a Windows declaration is damaged", () => {
|
|
const bytes = Buffer.alloc(256);
|
|
dosMz().copy(bytes, 0, 0, 28);
|
|
bytes.writeUInt16LE(256, 2);
|
|
bytes.writeUInt16LE(4, 8);
|
|
bytes.writeUInt16LE(64, 24);
|
|
bytes.writeUInt32LE(192, 60);
|
|
expect(parseDosMzHeader(bytes).ok).toBe(false);
|
|
expect(parseExecutableHeader(bytes, "x64")).toMatchObject({ ok: false });
|
|
bytes.writeUInt32LE(0xfffffff0, 60);
|
|
expect(parseExecutableHeader(bytes, "x64")).toMatchObject({ ok: false });
|
|
});
|
|
});
|