Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(ghidra): report unapplied PE CodeView PDB limitation (#2283)
Tufail Akram729ca2ab6ae0
diff --git a/src/application/BinaryTargetResolver.ts b/src/application/BinaryTargetResolver.tsindex b07364adf..348454e72 100644--- a/src/application/BinaryTargetResolver.ts+++ b/src/application/BinaryTargetResolver.ts@@ -40,10 +40,14 @@ import {} from "../domain/zipPackageFormat.js";import {+ parseCodeViewData,parseExecutableHeader,parsePeRecord,+ peDebugDirectoryEntry,+ peRvaToFileOffset,type ExecutableMetadata,} from "../domain/binaryTarget.js";+import type { PeCodeViewRecord } from "../domain/binaryTargetTypes.js";/** Options for resolving a local binary target and its stable identity. */export interface BinaryTargetResolverOptions {@@ -549,10 +553,98 @@ const readPeMetadata = async (return err(`unsupported ${windowsHeader.signature} executable in MZ image`);const optionalHeaderSize = fileHeader.readUInt16LE(20);if (optionalHeaderSize > 4096) return err("invalid PE optional header size");+ const numberOfSections = fileHeader.readUInt16LE(6);const record = Buffer.alloc(24 + optionalHeaderSize);const recordRead = await handle.read(record, 0, record.length, offset);throwIfTargetResolutionCancelled(signal);- return recordRead.bytesRead === record.length- ? parsePeRecord(record)- : err("invalid or truncated PE header");+ if (recordRead.bytesRead !== record.length)+ return err("invalid or truncated PE header");+ const codeView = await readPeCodeView(+ handle,+ offset,+ numberOfSections,+ record.subarray(24),+ optionalHeaderSize,+ signal,+ );+ return parsePeRecord(record, codeView);+};++const readPeCodeView = async (+ handle: FileHandle,+ peOffset: number,+ numberOfSections: number,+ optionalHeader: Buffer,+ optionalHeaderSize: number,+ signal?: AbortSignal,+): Promise<PeCodeViewRecord | undefined> => {+ throwIfTargetResolutionCancelled(signal);+ const debugDir = peDebugDirectoryEntry(optionalHeader);+ if (debugDir === undefined || numberOfSections > 96) return undefined;+ const sectionTableOffset = peOffset + 24 + optionalHeaderSize;+ const sectionTableSize = numberOfSections * 40;+ const sectionTable = Buffer.alloc(sectionTableSize);+ const sectionRead = await handle.read(+ sectionTable,+ 0,+ sectionTableSize,+ sectionTableOffset,+ );+ throwIfTargetResolutionCancelled(signal);+ if (sectionRead.bytesRead !== sectionTableSize) return undefined;+ const debugFileOffset = peRvaToFileOffset(+ debugDir.debugRva,+ sectionTable,+ numberOfSections,+ debugDir.sizeOfHeaders,+ Math.min(debugDir.debugSize, 4096),+ );+ if (debugFileOffset === undefined) return undefined;+ const maxDebugSize = Math.min(debugDir.debugSize, 4096);+ const debugDirectoryBuffer = Buffer.alloc(maxDebugSize);+ const debugDirRead = await handle.read(+ debugDirectoryBuffer,+ 0,+ maxDebugSize,+ debugFileOffset,+ );+ throwIfTargetResolutionCancelled(signal);+ const numEntries = Math.floor(debugDirRead.bytesRead / 28);+ for (let j = 0; j < numEntries; j++) {+ const entryOffset = j * 28;+ const type = debugDirectoryBuffer.readUInt32LE(entryOffset + 12);+ if (type !== 2) continue; // IMAGE_DEBUG_TYPE_CODEVIEW+ const sizeOfData = debugDirectoryBuffer.readUInt32LE(entryOffset + 16);+ let pointerToRawData = debugDirectoryBuffer.readUInt32LE(entryOffset + 24);+ if (pointerToRawData === 0) {+ const addressOfRawData = debugDirectoryBuffer.readUInt32LE(+ entryOffset + 20,+ );+ const mapped = peRvaToFileOffset(+ addressOfRawData,+ sectionTable,+ numberOfSections,+ debugDir.sizeOfHeaders,+ Math.min(sizeOfData, 4096),+ );+ if (mapped === undefined) continue;+ pointerToRawData = mapped;+ }+ if (sizeOfData < 16) continue;+ const maxCodeViewRead = Math.min(sizeOfData, 4096);+ const codeViewBuffer = Buffer.alloc(maxCodeViewRead);+ const codeViewRead = await handle.read(+ codeViewBuffer,+ 0,+ maxCodeViewRead,+ pointerToRawData,+ );+ throwIfTargetResolutionCancelled(signal);+ const parsed = parseCodeViewData(+ codeViewBuffer.subarray(0, codeViewRead.bytesRead),+ sizeOfData,+ );+ if (parsed !== undefined) return parsed;+ }+ return undefined;};diff --git a/src/domain/binaryTarget.fixture.ts b/src/domain/binaryTarget.fixture.tsindex 7d8a0a7f9..345a3f24c 100644--- a/src/domain/binaryTarget.fixture.ts+++ b/src/domain/binaryTarget.fixture.ts@@ -58,20 +58,67 @@ export const fat = (return bytes;};-/** Build a bounded PE image with optional managed metadata. */+export interface PeCodeViewFixture {+ readonly type?: "RSDS" | "NB10";+ readonly guid?: string;+ readonly age?: number;+ readonly pdbPath?: string;+}++/** Build a bounded PE image with optional managed metadata or CodeView debug data. */export const pe = (machine: number,offset = 64,characteristics = 0x0002,managed = false,+ codeView?: PeCodeViewFixture,): Buffer => {const optionalHeaderSize =machine === 0x014c || machine === 0x01c0 ? 224 : 240;- const bytes = Buffer.alloc(Math.max(512, offset + 24 + optionalHeaderSize));+ const sectionTableOffset = offset + 24 + optionalHeaderSize;+ const sectionCount = codeView !== undefined ? 1 : 0;+ const rawDataOffset = 512;++ let codeViewData: Buffer | undefined;+ if (codeView !== undefined) {+ const type = codeView.type ?? "RSDS";+ const pdbPath = codeView.pdbPath ?? "app.pdb";+ const age = codeView.age ?? 1;+ const pathBuf = Buffer.from(`${pdbPath}\0`, "utf8");+ if (type === "RSDS") {+ codeViewData = Buffer.alloc(24 + pathBuf.length);+ codeViewData.write("RSDS", 0, "ascii");+ const guid = codeView.guid ?? "01234567-89ab-cdef-0123-456789abcdef";+ const parts = guid.split("-");+ if (parts.length === 5) {+ codeViewData.writeUInt32LE(parseInt(parts[0]!, 16), 4);+ codeViewData.writeUInt16LE(parseInt(parts[1]!, 16), 8);+ codeViewData.writeUInt16LE(parseInt(parts[2]!, 16), 10);+ Buffer.from(parts[3]!, "hex").copy(codeViewData, 12);+ Buffer.from(parts[4]!, "hex").copy(codeViewData, 14);+ }+ codeViewData.writeUInt32LE(age, 20);+ pathBuf.copy(codeViewData, 24);+ } else {+ codeViewData = Buffer.alloc(16 + pathBuf.length);+ codeViewData.write("NB10", 0, "ascii");+ codeViewData.writeUInt32LE(0, 4);+ codeViewData.writeUInt32LE(0, 8);+ codeViewData.writeUInt32LE(age, 12);+ pathBuf.copy(codeViewData, 16);+ }+ }++ const minSize =+ codeViewData !== undefined+ ? rawDataOffset + 28 + codeViewData.length + 32+ : Math.max(512, offset + 24 + optionalHeaderSize);+ const bytes = Buffer.alloc(minSize);bytes.write("MZ", 0, "ascii");bytes.writeUInt32LE(offset, 0x3c);bytes.write("PE\0\0", offset, "binary");bytes.writeUInt16LE(machine, offset + 4);+ bytes.writeUInt16LE(sectionCount, offset + 6);bytes.writeUInt16LE(optionalHeaderSize, offset + 20);bytes.writeUInt16LE(characteristics, offset + 22);const optionalHeader = offset + 24;@@ -83,6 +130,29 @@ export const pe = (bytes.writeUInt32LE(0x2000, optionalHeader + directoryOffset + 14 * 8);bytes.writeUInt32LE(72, optionalHeader + directoryOffset + 14 * 8 + 4);}+ if (codeViewData !== undefined) {+ const debugDirRva = 0x1000;+ const debugDirSize = 28;+ bytes.writeUInt32LE(debugDirRva, optionalHeader + directoryOffset + 6 * 8);+ bytes.writeUInt32LE(+ debugDirSize,+ optionalHeader + directoryOffset + 6 * 8 + 4,+ );++ bytes.write(".rdata\0\0", sectionTableOffset, "ascii");+ bytes.writeUInt32LE(0x1000, sectionTableOffset + 8);+ bytes.writeUInt32LE(0x1000, sectionTableOffset + 12);+ bytes.writeUInt32LE(512, sectionTableOffset + 16);+ bytes.writeUInt32LE(rawDataOffset, sectionTableOffset + 20);+ bytes.writeUInt32LE(0x40000040, sectionTableOffset + 36);++ bytes.writeUInt32LE(2, rawDataOffset + 12);+ bytes.writeUInt32LE(codeViewData.length, rawDataOffset + 16);+ bytes.writeUInt32LE(debugDirRva + 28, rawDataOffset + 20);+ bytes.writeUInt32LE(rawDataOffset + 28, rawDataOffset + 24);++ codeViewData.copy(bytes, rawDataOffset + 28);+ }return bytes;};diff --git a/src/domain/binaryTarget.ts b/src/domain/binaryTarget.tsindex 94828ee6e..4e668e460 100644--- a/src/domain/binaryTarget.ts+++ b/src/domain/binaryTarget.ts@@ -3,6 +3,7 @@ import type {ElfFamilyMetadata,HeaderArchitecture,MipsElfMetadata,+ PeCodeViewRecord,RiscvElfMetadata,UniversalMachOSlice,} from "./binaryTargetTypes.js";@@ -50,6 +51,7 @@ export type ExecutableMetadata =| "shared-library"| "non-executable";readonly managed: boolean;+ readonly codeView?: PeCodeViewRecord;};/**@@ -257,7 +259,8 @@ const parseMz = ();if (windowsHeader.signature !== "PE")return err("invalid or truncated Windows executable header in MZ image");- return parsePeRecord(bytes.subarray(offset));+ const codeView = parsePeCodeViewFromBuffer(bytes, offset);+ return parsePeRecord(bytes.subarray(offset), codeView);}const parsed = parseDosMzHeader(bytes, fileSize, signatureAtOffset);return parsed.ok@@ -272,6 +275,7 @@ const parseMz = (/** Parse a bounded PE signature, COFF record, and optional header without I/O. */export const parsePeRecord = (record: Buffer,+ codeView: PeCodeViewRecord | undefined,): Result<ExecutableMetadata, string> => {if (record.length < 24 ||@@ -305,9 +309,176 @@ export const parsePeRecord = (? "application": "shared-library",managed: managed.value,+ ...(codeView !== undefined ? { codeView } : {}),});};+/** Parse CodeView record data (RSDS or NB10) from raw data bytes. */+export const parseCodeViewData = (+ buffer: Buffer,+ sizeOfData: number,+): PeCodeViewRecord | undefined => {+ if (sizeOfData < 16 || buffer.length < 16) return undefined;+ const magic = buffer.subarray(0, 4).toString("binary");+ const pathOffset = magic === "RSDS" ? 24 : magic === "NB10" ? 16 : undefined;+ if (+ pathOffset === undefined ||+ sizeOfData <= pathOffset ||+ buffer.length <= pathOffset+ )+ return undefined;+ const end = buffer.indexOf(0, pathOffset);+ if (end <= pathOffset || end >= sizeOfData) return undefined;+ const pdbPath = buffer.toString("utf8", pathOffset, end);+ const pdbFileName = pdbPath.split(/[/\\]/u).pop() ?? pdbPath;+ if (magic === "RSDS" && sizeOfData >= 24 && buffer.length >= 24) {+ const part1 = buffer.readUInt32LE(4).toString(16).padStart(8, "0");+ const part2 = buffer.readUInt16LE(8).toString(16).padStart(4, "0");+ const part3 = buffer.readUInt16LE(10).toString(16).padStart(4, "0");+ const part4 = buffer.subarray(12, 14).toString("hex");+ const part5 = buffer.subarray(14, 20).toString("hex");+ const guid = `${part1}-${part2}-${part3}-${part4}-${part5}`;+ const age = buffer.readUInt32LE(20);+ return { pdbPath, pdbFileName, guid, age };+ }+ if (magic === "NB10") {+ const age = buffer.readUInt32LE(12);+ return { pdbPath, pdbFileName, guid: null, age };+ }+ return undefined;+};++/** Locate the debug directory RVA and size from a PE optional header. */+export const peDebugDirectoryEntry = (+ optionalHeader: Buffer,+):+ | {+ readonly debugRva: number;+ readonly debugSize: number;+ readonly sizeOfHeaders: number;+ }+ | undefined => {+ if (optionalHeader.length < 2) return undefined;+ const magic = optionalHeader.readUInt16LE(0);+ if (magic !== 0x10b && magic !== 0x20b) return undefined;+ const directoryOffset = magic === 0x20b ? 112 : 96;+ const directoryCountOffset = directoryOffset - 4;+ if (optionalHeader.length < directoryCountOffset + 4) return undefined;+ const directoryCount = optionalHeader.readUInt32LE(directoryCountOffset);+ if (directoryCount <= 6) return undefined;+ const debugEntryOffset = directoryOffset + 6 * 8;+ if (optionalHeader.length < debugEntryOffset + 8) return undefined;+ const debugRva = optionalHeader.readUInt32LE(debugEntryOffset);+ const debugSize = optionalHeader.readUInt32LE(debugEntryOffset + 4);+ if (debugRva === 0 || debugSize < 28) return undefined;+ return {+ debugRva,+ debugSize,+ sizeOfHeaders: optionalHeader.readUInt32LE(60),+ };+};++/** Translate an RVA to an absolute file offset using the PE section table. */+export const peRvaToFileOffset = (+ rva: number,+ sectionTable: Buffer,+ numberOfSections: number,+ sizeOfHeaders: number,+ size = 1,+): number | undefined => {+ if (rva < sizeOfHeaders && size <= sizeOfHeaders - rva) return rva;+ for (let i = 0; i < numberOfSections; i++) {+ const offset = i * 40;+ if (sectionTable.length < offset + 40) break;+ const virtualAddress = sectionTable.readUInt32LE(offset + 12);+ const sizeOfRawData = sectionTable.readUInt32LE(offset + 16);+ const pointerToRawData = sectionTable.readUInt32LE(offset + 20);+ if (+ pointerToRawData > 0 &&+ rva >= virtualAddress &&+ rva - virtualAddress < sizeOfRawData &&+ size <= sizeOfRawData - (rva - virtualAddress)+ ) {+ return pointerToRawData + (rva - virtualAddress);+ }+ }+ return undefined;+};++/** Parse CodeView metadata from a bounded in-memory PE image buffer. */+export const parsePeCodeViewFromBuffer = (+ fileBytes: Buffer,+ peOffset: number,+): PeCodeViewRecord | undefined => {+ if (fileBytes.length < peOffset + 24) return undefined;+ const numberOfSections = fileBytes.readUInt16LE(peOffset + 6);+ const optionalHeaderSize = fileBytes.readUInt16LE(peOffset + 20);+ if (+ optionalHeaderSize > 4096 ||+ fileBytes.length < peOffset + 24 + optionalHeaderSize+ )+ return undefined;+ const optionalHeader = fileBytes.subarray(+ peOffset + 24,+ peOffset + 24 + optionalHeaderSize,+ );+ const debugDir = peDebugDirectoryEntry(optionalHeader);+ if (debugDir === undefined) return undefined;+ const sectionTableOffset = peOffset + 24 + optionalHeaderSize;+ const sectionTableSize = numberOfSections * 40;+ if (fileBytes.length < sectionTableOffset + sectionTableSize)+ return undefined;+ const sectionTable = fileBytes.subarray(+ sectionTableOffset,+ sectionTableOffset + sectionTableSize,+ );+ const debugFileOffset = peRvaToFileOffset(+ debugDir.debugRva,+ sectionTable,+ numberOfSections,+ debugDir.sizeOfHeaders,+ Math.min(debugDir.debugSize, 4096),+ );+ if (debugFileOffset === undefined || fileBytes.length < debugFileOffset + 28)+ return undefined;+ const maxDebugBytes = Math.min(+ debugDir.debugSize,+ fileBytes.length - debugFileOffset,+ );+ const numEntries = Math.floor(maxDebugBytes / 28);+ for (let j = 0; j < numEntries; j++) {+ const entryOffset = debugFileOffset + j * 28;+ const type = fileBytes.readUInt32LE(entryOffset + 12);+ if (type !== 2) continue; // IMAGE_DEBUG_TYPE_CODEVIEW+ const sizeOfData = fileBytes.readUInt32LE(entryOffset + 16);+ let pointerToRawData = fileBytes.readUInt32LE(entryOffset + 24);+ if (pointerToRawData === 0) {+ const addressOfRawData = fileBytes.readUInt32LE(entryOffset + 20);+ const mapped = peRvaToFileOffset(+ addressOfRawData,+ sectionTable,+ numberOfSections,+ debugDir.sizeOfHeaders,+ Math.min(sizeOfData, 4096),+ );+ if (mapped === undefined) continue;+ pointerToRawData = mapped;+ }+ if (+ sizeOfData < 16 ||+ fileBytes.length < pointerToRawData + Math.min(sizeOfData, 24)+ )+ continue;+ const codeViewData = fileBytes.subarray(+ pointerToRawData,+ Math.min(fileBytes.length, pointerToRawData + sizeOfData),+ );+ const parsed = parseCodeViewData(codeViewData, sizeOfData);+ if (parsed !== undefined) return parsed;+ }+ return undefined;+};+const peManagedStatus = (optionalHeader: Buffer,architecture: BinaryArchitecture,diff --git a/src/domain/binaryTargetTypes.ts b/src/domain/binaryTargetTypes.tsindex 99ad8487f..8c16612bc 100644--- a/src/domain/binaryTargetTypes.ts+++ b/src/domain/binaryTargetTypes.ts@@ -24,6 +24,14 @@ export interface ElfFamilyMetadata {readonly flags: number;}+/** Referenced CodeView debug symbols from a PE debug directory. */+export interface PeCodeViewRecord {+ readonly pdbPath: string;+ readonly pdbFileName: string;+ readonly guid: string | null;+ readonly age: number;+}+/** Families whose parsed target variant carries `ElfFamilyMetadata`. */export const ELF_METADATA_ARCHITECTURES = ["mips",@@ -170,6 +178,8 @@ export type BinaryTarget =| "non-executable";/** Whether the PE declares a non-empty CLI header data-directory entry. */readonly managed: boolean;+ /** Referenced CodeView debug symbols from the PE debug directory, if present. */+ readonly codeView?: PeCodeViewRecord;})| (BinaryTargetIdentity &NonExecutableMetadata & {diff --git a/src/ghidra/GhidraPeProfile.test.ts b/src/ghidra/GhidraPeProfile.test.tsnew file mode 100644index 000000000..561aad701--- /dev/null+++ b/src/ghidra/GhidraPeProfile.test.ts@@ -0,0 +1,95 @@+import { describe, expect, it } from "vitest";+import type { BinaryTarget } from "../domain/binaryTargetTypes.js";+import { ghidraPeCodeViewLimitations } from "./GhidraPeProfile.js";++describe("ghidraPeCodeViewLimitations", () => {+ it("returns empty limitations for non-PE targets", () => {+ const elfTarget: BinaryTarget = {+ path: "/test/file",+ sha256: "abc",+ kind: "executable",+ format: "elf",+ architecture: "x86_64",+ availableArchitectures: ["x86_64"],+ };+ expect(ghidraPeCodeViewLimitations(elfTarget)).toEqual([]);+ });++ it("does not claim CodeView symbols were unapplied when the session loaded a PDB", () => {+ const peTarget: BinaryTarget = {+ path: "/test/file.exe",+ sha256: "abc",+ kind: "executable",+ architecture: "x86_64",+ availableArchitectures: ["x86_64"],+ executableRole: "application",+ managed: false,+ format: "pe",+ codeView: {+ pdbPath: "C:\\symbols.pdb",+ pdbFileName: "symbols.pdb",+ guid: "12345678-1234-1234-1234-123456789abc",+ age: 1,+ },+ };+ expect(ghidraPeCodeViewLimitations(peTarget, true)).toEqual([]);+ });++ it("returns empty limitations for PE target without codeView", () => {+ const peTarget: BinaryTarget = {+ path: "/test/file.exe",+ sha256: "def",+ kind: "executable",+ format: "pe",+ architecture: "x86_64",+ availableArchitectures: ["x86_64"],+ executableRole: "application",+ managed: false,+ };+ expect(ghidraPeCodeViewLimitations(peTarget)).toEqual([]);+ });++ it("returns limitation with GUID and age for RSDS CodeView records", () => {+ const peTarget: BinaryTarget = {+ path: "/test/file.exe",+ sha256: "def",+ kind: "executable",+ format: "pe",+ architecture: "x86_64",+ availableArchitectures: ["x86_64"],+ executableRole: "application",+ managed: false,+ codeView: {+ pdbPath: "C:\\build\\app.pdb",+ pdbFileName: "app.pdb",+ guid: "01234567-89ab-cdef-0123-456789abcdef",+ age: 1,+ },+ };+ expect(ghidraPeCodeViewLimitations(peTarget)).toEqual([+ 'The target references debug symbols "app.pdb" (GUID 01234567-89ab-cdef-0123-456789abcdef, age 1) that were not applied; procedure names are analysis-generated.',+ ]);+ });++ it("returns limitation without GUID for NB10 CodeView records", () => {+ const peTarget: BinaryTarget = {+ path: "/test/file.exe",+ sha256: "def",+ kind: "executable",+ format: "pe",+ architecture: "x86",+ availableArchitectures: ["x86"],+ executableRole: "application",+ managed: false,+ codeView: {+ pdbPath: "D:\\test\\legacy.pdb",+ pdbFileName: "legacy.pdb",+ guid: null,+ age: 2,+ },+ };+ expect(ghidraPeCodeViewLimitations(peTarget)).toEqual([+ 'The target references debug symbols "legacy.pdb" (age 2) that were not applied; procedure names are analysis-generated.',+ ]);+ });+});diff --git a/src/ghidra/GhidraPeProfile.ts b/src/ghidra/GhidraPeProfile.tsnew file mode 100644index 000000000..217b3256f--- /dev/null+++ b/src/ghidra/GhidraPeProfile.ts@@ -0,0 +1,24 @@+import type { BinaryTarget } from "../domain/binaryTargetTypes.js";++/**+ * Report unapplied PE companion PDB symbols when CodeView debug information is present.+ *+ * Ghidra does not automatically locate or apply sidecar PDBs in REA's isolated+ * runtime directories without companion admission. When the PE target header+ * references debug symbols, surface this limitation so callers understand that+ * procedure names remain analysis-generated.+ */+export const ghidraPeCodeViewLimitations = (+ target: BinaryTarget,+ pdbLoaded = false,+): readonly string[] => {+ if (target.format !== "pe" || target.codeView === undefined || pdbLoaded) {+ return [];+ }+ const { pdbFileName, guid, age } = target.codeView;+ return [+ guid !== null+ ? `The target references debug symbols "${pdbFileName}" (GUID ${guid}, age ${age}) that were not applied; procedure names are analysis-generated.`+ : `The target references debug symbols "${pdbFileName}" (age ${age}) that were not applied; procedure names are analysis-generated.`,+ ];+};diff --git a/src/ghidra/GhidraProvider.behavior.test.ts b/src/ghidra/GhidraProvider.behavior.test.tsindex ccdfd96f7..b485f6ab3 100644--- a/src/ghidra/GhidraProvider.behavior.test.ts+++ b/src/ghidra/GhidraProvider.behavior.test.ts@@ -822,6 +822,39 @@ describe("Ghidra result projection", () => {});});+describe("Ghidra PE CodeView debug symbol limitations", () => {+ it("projects unapplied companion PDB limitation for PE target with CodeView record", async () => {+ const ghidra = provider(installationHost(), () => ({+ start: () => Promise.resolve(ok(sessionInfo())),+ callTool: () => Promise.resolve(ok(null)),+ close: () => Promise.resolve(ok(null)),+ }));+ const target = {+ ...peTarget("x86_64"),+ codeView: {+ pdbPath: "C:\\projects\\app\\build\\test.pdb",+ pdbFileName: "test.pdb",+ guid: "01234567-89ab-cdef-0123-456789abcdef",+ age: 1,+ },+ };+ const profile = await ghidra.resolveAnalysisProfile(target);+ if (!profile.ok || profile.value.profile === null)+ throw new Error("expected PE profile");+ const client = ghidra.createClient(target, profile.value.profile);+ const health = await client.execute("health", {});+ expect(health).toMatchObject({+ ok: true,+ value: {+ limitations: expect.arrayContaining([+ 'The target references debug symbols "test.pdb" (GUID 01234567-89ab-cdef-0123-456789abcdef, age 1) that were not applied; procedure names are analysis-generated.',+ ]),+ },+ });+ await client.close();+ });+});+describe("Ghidra relationship coverage", () => {it("marks the full direct call-reference response complete while keeping static caveats", async () => {const ghidra = provider(installationHost(), () => ({diff --git a/src/ghidra/GhidraProviderClient.ts b/src/ghidra/GhidraProviderClient.tsindex 25838453e..9db1b0c5f 100644--- a/src/ghidra/GhidraProviderClient.ts+++ b/src/ghidra/GhidraProviderClient.ts@@ -68,6 +68,7 @@ import {isGhidraMipsSoftFloatTarget,} from "./GhidraMipsProfile.js";import { ghidraRiscvLimitations } from "./GhidraRiscvProfile.js";+import { ghidraPeCodeViewLimitations } from "./GhidraPeProfile.js";import { unverifiedGhidraBuildLimitation } from "./GhidraInstallationPolicy.js";import { GhidraHeadlessLauncher } from "./GhidraLauncher.js";import { attestGhidraNativeLoadImage } from "./GhidraLoadImageAttest.js";@@ -530,6 +531,7 @@ export const createGhidraProviderClient = (input: {// Replaced by the reported outcome once the session handshake is checked.const seedLimitations: string[] = [...ghidraSeedLimitations(seeds)];const pdbLimitations: string[] = [];+ let pdbLoaded = false;// Replaced by the reported storage outcome once the handshake is checked.const softFloatLimitations: string[] = [...ghidraMipsSoftFloatLimitations(softFloat),@@ -654,12 +656,14 @@ export const createGhidraProviderClient = (input: {operation: AnalysisOperation,info: GhidraSessionInfo,): Promise<AnalysisError | undefined> => {- if (target.format === "pe")+ if (target.format === "pe") {+ pdbLoaded = info.pdb?.loaded === true;pdbLimitations.splice(0,pdbLimitations.length,...ghidraPdbLimitations(info.pdb),);+ }const softFloatReason = ghidraMipsSoftFloatFailure(softFloat,info.mips_soft_float_storage,@@ -712,6 +716,7 @@ export const createGhidraProviderClient = (input: {...ghidraExtensionLimitations(extensions),...seedLimitations,...pdbLimitations,+ ...ghidraPeCodeViewLimitations(target, pdbLoaded),...(releaseLimitation === undefined ? [] : [releaseLimitation]),];const nativeAotOwner =diff --git a/tests/boundary/filesystem/binaryTarget.test.ts b/tests/boundary/filesystem/binaryTarget.test.tsindex e56055069..eb5977a54 100644--- a/tests/boundary/filesystem/binaryTarget.test.ts+++ b/tests/boundary/filesystem/binaryTarget.test.ts@@ -26,6 +26,7 @@ import {thinMach,} from "../../../src/domain/binaryTarget.fixture.js";import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";+import { parseExecutableHeader } from "../../../src/domain/binaryTarget.js";import { createEvidence, parseEvidence } from "../../../src/domain/evidence.js";import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";@@ -424,6 +425,65 @@ describe("binary target I/O: explicit kinds and executable headers", () => {});});+ it("extracts CodeView RSDS debug metadata from a PE target", async () => {+ const directory = await createTestTempDirectory("rea-target-");+ const path = join(directory, "symbols.exe");+ await writeFile(+ path,+ pe(0x8664, 64, 0x0002, false, {+ type: "RSDS",+ pdbPath: "C:\\build\\test.pdb",+ guid: "12345678-abcd-ef01-2345-6789abcdef01",+ age: 3,+ }),+ );+ const result = await parseBinaryTarget(path, {+ cwd: directory,+ hostArchitecture: "x64",+ });+ expect(result.ok).toBe(true);+ if (!result.ok) throw result.error;+ expect(result.value).toMatchObject({+ format: "pe",+ architecture: "x86_64",+ codeView: {+ pdbPath: "C:\\build\\test.pdb",+ pdbFileName: "test.pdb",+ guid: "12345678-abcd-ef01-2345-6789abcdef01",+ age: 3,+ },+ });+ });++ it("extracts CodeView NB10 debug metadata from a PE target", async () => {+ const directory = await createTestTempDirectory("rea-target-");+ const path = join(directory, "legacy.exe");+ await writeFile(+ path,+ pe(0x014c, 64, 0x0002, false, {+ type: "NB10",+ pdbPath: "D:\\old\\legacy.pdb",+ age: 1,+ }),+ );+ const result = await parseBinaryTarget(path, {+ cwd: directory,+ hostArchitecture: "ia32",+ });+ expect(result.ok).toBe(true);+ if (!result.ok) throw result.error;+ expect(result.value).toMatchObject({+ format: "pe",+ architecture: "x86",+ codeView: {+ pdbPath: "D:\\old\\legacy.pdb",+ pdbFileName: "legacy.pdb",+ guid: null,+ age: 1,+ },+ });+ });+it("refuses a truncated Mach-O header before any provider sees it", async () => {const directory = await createTestTempDirectory("rea-target-");const path = join(directory, "truncated");@@ -884,3 +944,43 @@ it.each([});},);++describe("binary target I/O: PE CodeView header ranges", () => {+ it.each(["RSDS", "NB10"] as const)(+ "reads bounded %s header debug records and rejects unfinished names",+ async (type) => {+ const directory = await createTestTempDirectory("rea-target-");+ const path = join(directory, "header-symbols.exe");+ const bytes = pe(0x8664, 64, 0x0002, false, {+ type,+ pdbPath: "header.pdb",+ });+ const optionalHeader = 64 + 24;+ bytes.writeUInt32LE(512, optionalHeader + 60);+ bytes.copy(bytes, 384, 512);+ bytes.writeUInt32LE(384, optionalHeader + 112 + 6 * 8);+ bytes.writeUInt32LE(412, 384 + 20);+ bytes.writeUInt32LE(0, 384 + 24);+ for (const complete of [true, false]) {+ if (!complete) {+ const dataSize = bytes.readUInt32LE(384 + 16);+ bytes[412 + dataSize - 1] = 0x61;+ }+ await writeFile(path, bytes);+ const resolved = await parseBinaryTarget(path, {+ hostArchitecture: "x64",+ });+ const buffered = parseExecutableHeader(bytes, "x64");+ if (!resolved.ok) throw resolved.error;+ if (!buffered.ok) throw new Error(buffered.error);+ for (const value of [resolved.value, buffered.value]) {+ if (complete)+ expect(value).toMatchObject({+ codeView: { pdbPath: "header.pdb" },+ });+ else expect(value).not.toHaveProperty("codeView");+ }+ }+ },+ );+});