fix: restore PE release scanning and CommonJS test coverage (#12083)

* fix(artifacts): preserve unresolved PE debug coverage

* test(javascript): use valid CommonJS loader shadowing
This commit is contained in:
morluto authored and GitHub committed 2026-11-18 12:54:53 -05:00
1 parent ad82b61641
commit 31aaec6b4f
4 files changed
+213 -73

No files matched your search

+73 -8
View File
@@ -32,7 +32,6 @@ import { binaryPlistObjectTable } from "../../tests/fixtures/binaryPlistObjectTa
import { javaClassFile } from "../../tests/fixtures/javaClassFile.js";
import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";
import { universalMacho } from "../../tests/fixtures/universalMacho.js";
import { windowsNativeArtifactFixture } from "../../tests/fixtures/windowsNativeArtifact.js";
import {
ArtifactReaderFailure,
type ArtifactEntry,
@@ -207,6 +206,30 @@ const ignoreText = (): void => undefined;
// Keep the marker separate so Vite does not treat fixture text as this file's source map.
const INLINE_MAP_PREFIX = "# sourceMappingURL=data:application/json;base64,";
it.each([80, 200])(
"keeps a PE header truncated at %s bytes unclassified with PDB coverage unresolved",
async (length) => {
const root = await createTestTempDirectory(
"rea-release-exposure-truncated-header-",
);
const path = join(root, "app.exe");
const bytes = pe(0x8664, 64, 0x0002, false, { pdbPath: "app.pdb" });
await writeFile(path, bytes.subarray(0, length));
for (const input of [root, path]) {
const scanned = await inspect(input);
expect(scanned.native_images).toEqual([]);
expect(scanned.pdb).toMatchObject({
examined: 0,
failed: 1,
paths: [],
});
expect(scanned.limitations).toContain(
`Could not decode the PE header in ${path} to inspect debug records.`,
);
}
},
);
describe("ReleaseExposureReader review regressions", () => {
it("keeps inline CSS source-map coverage unknown in files and packages", async () => {
const root = await createTestTempDirectory("rea-release-exposure-css-");
@@ -254,8 +277,8 @@ describe("ReleaseExposureReader review regressions", () => {
},
);
it.each([80, 200, 520, 550])(
"preserves CodeView parsing truncated at %s bytes as unresolved",
it.each([520, 550])(
"preserves CodeView data truncated at %s bytes as unresolved",
async (length) => {
const root = await createTestTempDirectory(
"rea-release-exposure-truncated-",
@@ -265,7 +288,10 @@ describe("ReleaseExposureReader review regressions", () => {
});
await writeFile(join(root, "app.exe"), bytes.subarray(0, length));
const scanned = await inspect(root);
expect(scanned.pdb).toMatchObject({ failed: 1, paths: [] });
expect(scanned.native_images).toMatchObject([
{ path: join(root, "app.exe"), format: "pe" },
]);
expect(scanned.pdb).toMatchObject({ examined: 1, failed: 1, paths: [] });
},
);
@@ -432,11 +458,11 @@ describe("ReleaseExposureReader", () => {
const elf = Buffer.alloc(300 * 1024);
writeMinimalElfHeader(elf);
await writeFile(join(root, "app.elf"), elf);
const pe = Buffer.concat([
windowsNativeArtifactFixture().bytes,
const peImage = Buffer.concat([
pe(0x8664, 64, 0x0002, false, { pdbPath: "app.pdb" }),
Buffer.alloc(300 * 1024),
]);
await writeFile(join(root, "app.exe"), pe);
await writeFile(join(root, "app.exe"), peImage);
const calls: string[] = [];
const real = stableRead.impl;
stableRead.impl = async (...args) => {
@@ -451,7 +477,14 @@ describe("ReleaseExposureReader", () => {
(image) => image.format === "elf" && image.path.endsWith("app.elf"),
),
).toBe(true);
expect(scanned.pdb.examined).toBeGreaterThanOrEqual(1);
expect(scanned.native_images).toContainEqual(
expect.objectContaining({ path: join(root, "app.exe"), format: "pe" }),
);
expect(scanned.pdb).toMatchObject({
examined: 1,
failed: 0,
paths: ["app.pdb"],
});
expect(calls.some((path) => path.endsWith("app.elf"))).toBe(false);
expect(calls.some((path) => path.endsWith("app.exe"))).toBe(true);
} finally {
@@ -1949,6 +1982,38 @@ describe("ReleaseExposureReader unread packaged maps", () => {
});
describe("ReleaseExposureReader undecided PE members", () => {
it("keeps a malformed complete member separate from an unexamined header", async () => {
const root = await createTestTempDirectory("rea-release-exposure-pe-");
const bytes = pe(0x8664, 64, 0x0002, false, { pdbPath: "app.pdb" });
const image = Buffer.concat([bytes, Buffer.alloc(2 * 1024 * 1024)]);
// The complete optional header lies in the probe, but its magic is invalid.
image.writeUInt16LE(0, 64 + 24);
await writeFile(
join(root, "app.exe"),
cArchiveExecutable({
carrier: "pe",
layout: "2.1",
pythonVersion: 310,
members: [
{
name: "malformed.bin",
typeCode: "x",
compress: false,
payload: image,
},
],
}),
);
const scanned = await inspect(root);
expect(scanned.pdb).toMatchObject({ examined: 1, failed: 1, paths: [] });
expect(scanned.omitted).not.toContainEqual(
expect.objectContaining({ subject: PACKAGED_NATIVE_IMAGES }),
);
expect(scanned.limitations.join("\n")).toContain(
"malformed.bin to inspect debug records.",
);
});
it.each(["payload.map", "payload.bin", "payload.json"])(
"keeps a large PE member named %s with a late header undecided",
async (name) => {
+101 -46
View File
@@ -71,14 +71,20 @@ import {
readFatContainerHeader,
readMachoHeaderPrefixFacts,
} from "../domain/apple/machoContainer.js";
import { inspectPeCodeViewFromBuffer } from "../domain/binaryTarget.js";
import {
inspectPeCodeViewFromBuffer,
parsePeRecordStructure,
} from "../domain/binaryTarget.js";
import { hasBinaryPlistSignature } from "../domain/apple/appleArchiveFormat.js";
import { logicalPathNfc } from "../domain/artifactIdentity.js";
import type {
ArtifactAdmissionLimit,
ArtifactIntegrityCheck,
} from "../domain/artifactOperationError.js";
import { observeMzWindowsHeader } from "../domain/dosMz.js";
import {
mzWindowsHeaderLayoutLimitation,
observeMzWindowsHeader,
} from "../domain/dosMz.js";
import { evidenceSubjectFormatSchema } from "../domain/evidenceSubject.js";
import { byteOrderMarkEncoding } from "../domain/textByteOrderMark.js";
import { fixedAllowanceOptions } from "../domain/fixedAllowanceRemediation.js";
@@ -1108,6 +1114,13 @@ const examineSelectedFile = async (
state.nativeDigests.set(input.path, input.sha256);
}
if (nativeFormat === "pe") readPdb(state, bytes, input.path);
else if (
nativeFormat === null &&
peHeaderState(bytes, bytes.length) === "malformed"
) {
noteUnresolvedPe(state, input.path, "malformed");
return;
}
await examineMember(state, input, {
logical: basename(input.path),
// A selected package executable keeps its native carrier here, so its
@@ -1160,13 +1173,11 @@ const examineMember = async (
readable = await examineTextMember(state, member, context);
else if (packageFormat !== null)
readable = await examinePackagedBinary(state, member, context);
else
await examineProbedText(
state,
member,
await member.read(MAX_RELEASE_EXPOSURE_MEMBER_PROBE_BYTES),
context,
);
else {
const probe = await member.read(MAX_RELEASE_EXPOSURE_MEMBER_PROBE_BYTES);
noteUnresolvedPeRead(state, member, probe);
await examineProbedText(state, member, probe, context);
}
if (packageFormat === null) return;
if (!readable) {
state.unreadable += 1;
@@ -1301,13 +1312,13 @@ const examineMapMember = async (
// A package member whose PE header is undecided may be native, so its `MZ`
// prefix is no evidence of a linker map.
if (
header !== null &&
read !== null &&
member.packageFormat !== null &&
!member.kindStated &&
noteUndecidedPe(state, member, header)
noteUnresolvedPeRead(state, member, read.loaded)
) {
// Bytes read in full are still text, so their credential markers count.
if (read?.loaded.kind === "bytes")
if (read.loaded.kind === "bytes")
scanText(
state,
member,
@@ -1604,16 +1615,13 @@ const examineTextMember = async (
noteNestedPackage(state, "asar", member.location);
return true;
}
// A package member's name is not its format. One kept only as a prefix may
// have its PE signature past that prefix, so it stays undecided, as on the
// map route; text read in full has no later bytes to decide it.
if (
loaded.kind === "over_allowance" &&
loaded.prefix !== null &&
member.packageFormat !== null &&
!member.kindStated
)
noteUndecidedPe(state, member, loaded.prefix);
if (member.packageFormat !== null && !member.kindStated) {
const pe = peHeaderOfRead(member, loaded);
// A complete text read beginning with MZ is not a PE claim without a
// signature. A complete malformed PE still leaves debug records unknown.
if (loaded.kind === "over_allowance" || pe === "malformed")
noteUnresolvedPe(state, member.location, pe, true);
}
return examineLoadedText(
state,
scriptRoleOfRead(member, loaded),
@@ -2363,8 +2371,7 @@ const examinePackagedBinary = async (
header,
probe.kind === "bytes" ? header.length : member.declaredSize,
));
if (native === null && header !== null)
noteUndecidedPe(state, member, header);
if (native === null) noteUnresolvedPeRead(state, member, probe);
if (
native === null &&
header !== null &&
@@ -2392,30 +2399,75 @@ const examinePackagedBinary = async (
return image.kind !== "unread";
};
/**
* An `MZ` header whose PE signature lies past the bytes read may be native, so
* the image stays unexamined by the on-disk readers, and it may carry a
* package that nothing here can clear. Returns whether the header was undecided.
*/
/** An `MZ` header whose PE signature lies past the bytes read, so it may be native. */
const isUndecidedPeHeader = (header: Buffer): boolean => {
if (header.toString("latin1", 0, 2) !== "MZ") return false;
const windows = observeMzWindowsHeader(header);
return (
type PeHeaderState = "other" | "unexamined" | "malformed" | "pe";
/** Judge a PE header by the same structural parser as inventory. */
const peHeaderState = (bytes: Buffer, size: number | null): PeHeaderState => {
if (bytes.toString("latin1", 0, 2) !== "MZ") return "other";
const windows = observeMzWindowsHeader(bytes, size ?? bytes.length);
if (windows.state === "declared" && windows.signature === "PE") {
if (mzWindowsHeaderLayoutLimitation(windows) !== undefined)
return "malformed";
const record = parsePeRecordStructure(bytes.subarray(windows.offset));
if (record.ok) return "pe";
return record.error.kind === "incomplete" &&
(size === null || windows.offset + record.error.requiredBytes <= size)
? "unexamined"
: "malformed";
}
if (
windows.state === "signature-needed" ||
(windows.state === "candidate" && windows.signature === "unobserved")
);
)
return "unexamined";
return "other";
};
const noteUndecidedPe = (
const peHeaderOfRead = (
member: MemberView,
loaded: MemberRead,
): PeHeaderState => {
const header = headerOfRead(loaded);
return header === null
? "other"
: peHeaderState(
header,
loaded.kind === "bytes" ? header.length : member.declaredSize,
);
};
const noteUnresolvedPeRead = (
state: ScanState,
member: Pick<MemberView, "location">,
header: Buffer,
member: MemberView,
loaded: MemberRead,
): boolean =>
noteUnresolvedPe(
state,
member.location,
peHeaderOfRead(member, loaded),
member.packageFormat !== null,
);
const noteUnresolvedPe = (
state: ScanState,
location: string,
header: PeHeaderState,
packaged = false,
): boolean => {
if (!isUndecidedPeHeader(header)) return false;
state.packagedNative += 1;
notePeNotExamined(state, member.location);
noteUnexaminedPackage(state);
if (header === "malformed") {
state.pdbFailed += 1;
pushLimitation(
state,
`Could not decode the PE header in ${location} to inspect debug records.`,
);
return true;
}
if (header !== "unexamined") return false;
notePeNotExamined(state, location);
if (packaged) {
state.packagedNative += 1;
noteUnexaminedPackage(state);
}
return true;
};
@@ -3385,9 +3437,14 @@ const classifySiblingMap = async (
if (prefix !== null && hasNodeShebang(prefix)) return;
// An undecided PE header may be native, so it is no linker-map evidence,
// nor is a shebang whose program an unresolved variable names.
const pe =
prefix === null
? "other"
: peHeaderState(prefix, loaded.kind === "bytes" ? prefix.length : null);
if (
prefix === null ||
isUndecidedPeHeader(prefix) ||
pe === "unexamined" ||
pe === "malformed" ||
mayHaveSourceMapPrefix(prefix) ||
nodeShebang(prefix) === undefined
)
@@ -3564,9 +3621,7 @@ const sniffNativeFormat = (
if (readMachoHeaderPrefixFacts(bytes).format !== null) return "mach-o";
const universal = sniffFatFormat(bytes, size);
if (universal !== null) return universal;
const windows = observeMzWindowsHeader(bytes);
if (windows.state === "declared" && windows.signature === "PE") return "pe";
return null;
return peHeaderState(bytes, size) === "pe" ? "pe" : null;
};
const targetKind = (
+38 -18
View File
@@ -608,27 +608,47 @@ export const parsePeRecordStructure = (
readonly characteristics: number;
readonly optionalHeader: Buffer;
},
string
| {
readonly kind: "incomplete";
readonly requiredBytes: number;
readonly message: string;
}
| { readonly kind: "malformed"; readonly message: string }
> => {
if (
record.length < PE_RECORD_HEADER_BYTES ||
record.toString("binary", 0, 4) !== "PE\u0000\u0000"
)
return err("invalid or truncated PE header");
if (record.length < PE_RECORD_HEADER_BYTES)
return err({
kind: "incomplete",
requiredBytes: PE_RECORD_HEADER_BYTES,
message: "invalid or truncated PE header",
});
if (record.toString("binary", 0, 4) !== "PE\u0000\u0000")
return err({
kind: "malformed",
message: "invalid or truncated PE header",
});
const coff = readPeCoffHeader(record.subarray(4, PE_RECORD_HEADER_BYTES));
if (!coff.ok) return err("invalid or truncated PE header");
if (!coff.ok)
return err({
kind: "malformed",
message: "invalid or truncated PE header",
});
const { machine, optionalHeaderSize, characteristics } = coff.value;
if (
optionalHeaderSize > MAX_PE_OPTIONAL_HEADER_BYTES ||
record.length < PE_RECORD_HEADER_BYTES + optionalHeaderSize
)
return err("invalid or truncated PE optional header");
const optionalHeader = record.subarray(
PE_RECORD_HEADER_BYTES,
PE_RECORD_HEADER_BYTES + optionalHeaderSize,
);
if (optionalHeaderSize > MAX_PE_OPTIONAL_HEADER_BYTES)
return err({
kind: "malformed",
message: "invalid or truncated PE optional header",
});
const declaredEnd = PE_RECORD_HEADER_BYTES + optionalHeaderSize;
if (record.length < declaredEnd)
return err({
kind: "incomplete",
requiredBytes: declaredEnd,
message: "invalid or truncated PE optional header",
});
const optionalHeader = record.subarray(PE_RECORD_HEADER_BYTES, declaredEnd);
const parsed = readPeOptionalHeaderStructure(optionalHeader);
if (!parsed.ok) return err(parsed.error.message);
if (!parsed.ok)
return err({ kind: "malformed", message: parsed.error.message });
return ok({ machine, characteristics, optionalHeader });
};
@@ -644,7 +664,7 @@ export const parsePeRecordFacts = (
string
> => {
const structure = parsePeRecordStructure(record);
if (!structure.ok) return err(structure.error);
if (!structure.ok) return err(structure.error.message);
const {
machine: machineType,
characteristics,
@@ -308,7 +308,7 @@ const cases = [
},
{
name: "local main module receiver",
load: 'const require={main:{require(){}}};require.main.require("../shared/window.cjs");',
load: '{const require={main:{require(){}}};require.main.require("../shared/window.cjs");}',
possible: false,
},
{