diff --git a/src/artifacts/ReleaseExposureReader.test.ts b/src/artifacts/ReleaseExposureReader.test.ts index 5b3dc4cd68..f0331a1738 100644 --- a/src/artifacts/ReleaseExposureReader.test.ts +++ b/src/artifacts/ReleaseExposureReader.test.ts @@ -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) => { diff --git a/src/artifacts/ReleaseExposureReader.ts b/src/artifacts/ReleaseExposureReader.ts index babc86ac2b..a5fefea550 100644 --- a/src/artifacts/ReleaseExposureReader.ts +++ b/src/artifacts/ReleaseExposureReader.ts @@ -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, - 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 = ( diff --git a/src/domain/binaryTarget.ts b/src/domain/binaryTarget.ts index a584728d49..f98ea98d97 100644 --- a/src/domain/binaryTarget.ts +++ b/src/domain/binaryTarget.ts @@ -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, diff --git a/tests/acceptance/applications/javascriptIndirectLoaderOwners.test.ts b/tests/acceptance/applications/javascriptIndirectLoaderOwners.test.ts index e96ee76262..efb532c991 100644 --- a/tests/acceptance/applications/javascriptIndirectLoaderOwners.test.ts +++ b/tests/acceptance/applications/javascriptIndirectLoaderOwners.test.ts @@ -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, }, {