mirror of
https://github.com/morluto/rea.git
synced 2026-11-18 20:53:00 +00:00
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:
1 parent
ad82b61641
commit
31aaec6b4f
4 files changed
+213
-73
No files matched your search
@@ -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) => {
|
||||
|
||||
@@ -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
@@ -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,
|
||||
},
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user