Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
import { expect, it } from "vitest";
import { inspectManagedMembersBytes } from "./ManagedMemberInspector.js";
import {
buildManagedPeFixture,
managedPeFixtureTarget,
} from "./ManagedPe.fixture.js";
import { buildManagedMemberCapacityFixture } from "../../tests/fixtures/managedMemberCapacity.js";
import { readManagedPeLayout } from "./ManagedPeReader.js";
import {
metadataRowOffset,
readManagedMetadataLayout,
} from "./ManagedMetadataLayout.js";
it("retains admitted type names, member counts and artifact identity", () => {
const bytes = buildManagedMemberCapacityFixture();
const result = inspectManagedMembersBytes(
bytes,
managedPeFixtureTarget(bytes),
);
expect(result.coverage.state).toBe("partial");
expect(result.coverage.issues).toContainEqual(
expect.objectContaining({
code: "resource-limit",
scope: "metadata.representation",
offset: expect.any(Number),
}),
);
expect(result.types).toHaveLength(3);
expect(
result.types.find((type) => type.full_name === "Fixture.Program"),
).toMatchObject({
method_list: { count: 1 },
field_list: { count: 1 },
name_sha256: expect.any(String),
});
expect(result.module).toMatchObject({ mvid: expect.any(String) });
expect(result.identity_scope.requires_mvid).toBe(result.module?.mvid);
expect(result.metadata.table_row_counts).toMatchObject({
TypeDef: 3,
MethodDef: 1,
});
expect(result.metadata.version).not.toBeNull();
expect(result.methods).toEqual([]);
expect(result.fields).toEqual([]);
expect(result.member_refs).toEqual([]);
expect(result.call_edges).toEqual([]);
expect(result.field_accesses).toEqual([]);
expect(result.user_strings).toBeNull();
expect(result.exported_types).toBeNull();
expect(result.signature_resolution).toBeNull();
expect(result.limitations.join(" ")).toContain("not examined to completion");
});
it("lets a caller select an inventoried empty type without decoding the oversized body", () => {
const bytes = buildManagedMemberCapacityFixture();
const target = managedPeFixtureTarget(bytes);
const inventory = inspectManagedMembersBytes(bytes, target);
const empty = inventory.types.find((type) => type.method_list.count === 0);
expect(empty).toBeDefined();
const result = inspectManagedMembersBytes(bytes, target, {
typeNames: [empty!.full_name],
});
expect(result.coverage).toEqual({ state: "complete", issues: [] });
expect(result.types).toHaveLength(1);
expect(result.types[0]?.token).toBe(empty?.token);
expect(result.methods).toEqual([]);
});
it("preserves explicit type selection when its selected body exhausts capacity", () => {
const bytes = buildManagedMemberCapacityFixture();
const result = inspectManagedMembersBytes(
bytes,
managedPeFixtureTarget(bytes),
{
typeNames: ["Fixture.Program", "Missing.Type"],
},
);
expect(result.coverage.state).toBe("partial");
expect(result.types.map((type) => type.full_name)).toEqual([
"Fixture.Program",
]);
expect(result.selection).toEqual({
type_names: ["Fixture.Program", "Missing.Type"],
unmatched_type_names: ["Missing.Type"],
});
});
it("retains types when a field signature exceeds the decoding bound", () => {
const bytes = buildManagedPeFixture({
fieldSignature: Buffer.alloc(270_001, 0x06),
});
const result = inspectManagedMembersBytes(
bytes,
managedPeFixtureTarget(bytes),
);
expect(result.coverage.state).toBe("partial");
expect(result.types[0]?.full_name).toBe("Fixture.Program");
expect(result.coverage.issues).toContainEqual(
expect.objectContaining({ code: "resource-limit" }),
);
expect(result.fields).toEqual([]);
});
it("keeps metadata admission failures unavailable rather than inventing an inventory", () => {
const bytes = buildManagedPeFixture({ corruptMetadataSignature: true });
const result = inspectManagedMembersBytes(
bytes,
managedPeFixtureTarget(bytes),
);
expect(result.coverage.state).toBe("unavailable");
expect(result.types).toEqual([]);
expect(result.metadata.status).toBe("malformed");
});
it("retains a large type inventory without relaxing the member budget", () => {
const bytes = buildManagedMemberCapacityFixture({
additionalEmptyTypes: 2_041,
});
const result = inspectManagedMembersBytes(
bytes,
managedPeFixtureTarget(bytes),
);
expect(result.coverage.state).toBe("partial");
expect(result.types).toHaveLength(2_042);
expect(result.types.at(-1)?.full_name).toBe("Fixture.Program");
expect(result.types.every((type) => type.name_sha256 !== null)).toBe(true);
expect(result.methods).toEqual([]);
});
it("does not recover an inventory whose names already exceed capacity", () => {
const bytes = buildManagedPeFixture({
typeName: "T".repeat(12 * 1024 * 1024),
});
const result = inspectManagedMembersBytes(
bytes,
managedPeFixtureTarget(bytes),
);
expect(result.coverage.state).toBe("unavailable");
expect(result.coverage.issues).toContainEqual(
expect.objectContaining({ code: "resource-limit" }),
);
expect(result.types).toEqual([]);
});
it("keeps malformed type facts alongside the later capacity diagnostic", () => {
const bytes = buildManagedMemberCapacityFixture({ extendsRaw: 0xffff });
const result = inspectManagedMembersBytes(
bytes,
managedPeFixtureTarget(bytes),
);
expect(result.coverage.state).toBe("partial");
expect(result.types).toHaveLength(3);
expect(result.types.every((type) => type.extends_token === null)).toBe(true);
expect(result.coverage.issues).toContainEqual(
expect.objectContaining({ code: "invalid-row" }),
);
expect(result.coverage.issues.at(-1)).toMatchObject({
code: "resource-limit",
});
});
it("does not repair cyclic nesting into a definite nominal identity", () => {
const bytes = buildManagedMemberCapacityFixture({
additionalEmptyTypes: 1,
nestedTypes: [
[1, 2],
[2, 1],
],
});
const result = inspectManagedMembersBytes(
bytes,
managedPeFixtureTarget(bytes),
);
expect(result.coverage.state).toBe("partial");
expect(result.types).toHaveLength(2);
expect(result.types.every((type) => type.name_sha256 === null)).toBe(true);
expect(result.types.map((type) => type.enclosing_type_token)).toEqual([
"0x02000002",
"0x02000001",
]);
});
it("does not turn an unreadable requested type name into observed absence during recovery", () => {
const bytes = buildManagedMemberCapacityFixture();
const pe = readManagedPeLayout(bytes);
if (pe.cli === null) throw new Error("Expected CLI fixture");
const layout = readManagedMetadataLayout(
bytes,
pe.rvaToOffset(pe.cli.metadata.rva, pe.cli.metadata.size, "cli.metadata"),
pe.cli.metadata.size,
);
expect(layout.stringIndexSize).toBe(2);
bytes.writeUInt16LE(0xffff, metadataRowOffset(layout, 2, 1) + 4);
const result = inspectManagedMembersBytes(
bytes,
managedPeFixtureTarget(bytes),
{
typeNames: ["Fixture.Program", "Fixture.Empty0"],
},
);
expect(result.coverage.state).toBe("partial");
expect(result.selection?.unmatched_type_names).toEqual(["Fixture.Empty0"]);
expect(result.types.map((type) => type.full_name)).toEqual([
"Fixture.Program",
]);
expect(result.limitations.join(" ")).toContain("absence is not observed");
});