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(managed): enforce module identity before joining token facts
morlutob582b6ecb438
diff --git a/src/domain/managed/managedApplicationGraph.ts b/src/domain/managed/managedApplicationGraph.tsindex f99ebb47c..3e4ffea37 100644--- a/src/domain/managed/managedApplicationGraph.ts+++ b/src/domain/managed/managedApplicationGraph.ts@@ -134,6 +134,7 @@ export const projectManagedApplicationGraph = (const parsed = parseManagedInputs(input);const artifactIdentity = chooseArtifact(parsed);assertSameArtifact(parsed, artifactIdentity.sha256);+ assertConsistentModuleIdentity(parsed);const evidenceLinks = [parsed.artifact?.evidence.evidence_id,parsed.members?.evidence.evidence_id,@@ -258,6 +259,52 @@ const assertSameArtifact = ();};+/** Reject contradictory known module identities while leaving null fields unknown. */+const assertConsistentModuleIdentity = (+ parsed: ParsedManagedGraphInput,+): void => {+ const mvidClaims = [+ parsed.artifact?.result.module?.mvid,+ parsed.members?.result.module?.mvid,+ parsed.members?.result.identity_scope.requires_mvid,+ parsed.boundaries?.result.module?.mvid,+ parsed.boundaries?.result.identity_scope.requires_mvid,+ ]+ .filter((mvid): mvid is string => mvid !== undefined && mvid !== null)+ .map((mvid) => mvid.toLowerCase());+ if (new Set(mvidClaims).size > 1)+ throw new TypeError(+ "Managed graph inputs report conflicting known module MVIDs or token scopes",+ );++ const modules = [+ parsed.artifact?.result.module,+ parsed.members?.result.module,+ parsed.boundaries?.result.module,+ ].filter(+ (module): module is NonNullable<ManagedArtifactInspection["module"]> =>+ module !== undefined && module !== null,+ );+ for (const field of ["name", "generation", "token", "row_offset"] as const) {+ const values = new Set(modules.map((module) => module[field]));+ if (values.size > 1)+ throw new TypeError(+ `Managed graph inputs report conflicting module ${field} values`,+ );+ }+ for (const field of ["enc_id", "enc_base_id"] as const) {+ const values = new Set(+ modules+ .map((module) => module[field]?.toLowerCase())+ .filter((value): value is string => value !== undefined),+ );+ if (values.size > 1)+ throw new TypeError(+ `Managed graph inputs report conflicting module ${field} values`,+ );+ }+};+const omittedCounts = (parsed: ParsedManagedGraphInput) =>assessManagedGraphOmissions({artifact: parsed.artifact?.result ?? null,@@ -288,4 +335,9 @@ const projectionLimitations = (...(omissions.partialInput? ["At least one supplied managed Evidence record has partial coverage."]: []),+ ...(omissions.unscopedTokenRelationships+ ? [+ "Managed boundary tokens were not linked to member nodes because matching module MVID scope was not established.",+ ]+ : []),];diff --git a/src/domain/managed/managedApplicationGraphCoverage.ts b/src/domain/managed/managedApplicationGraphCoverage.tsindex ebdc79c6a..dc15a6462 100644--- a/src/domain/managed/managedApplicationGraphCoverage.ts+++ b/src/domain/managed/managedApplicationGraphCoverage.ts@@ -4,6 +4,7 @@ import type {ManagedMemberInspection,ManagedNativeBoundaryInspection,} from "./managedArtifact.js";+import { managedTokenScopesMatch } from "./managedInspectionEvidence.js";type ManagedCoverageState = "complete" | "partial" | "unavailable";@@ -17,6 +18,7 @@ export interface ManagedGraphCoverageSources {/** Whether any supplied source has incomplete coverage. */export interface ManagedGraphProjectionOmissions {readonly partialInput: boolean;+ readonly unscopedTokenRelationships: boolean;}const completeCoverage = (): ApplicationGraphEvidence["coverage"] => ({@@ -43,6 +45,17 @@ export const managedSourceCoverage = (export const assessManagedGraphOmissions = (sources: ManagedGraphCoverageSources,): ManagedGraphProjectionOmissions => ({+ unscopedTokenRelationships:+ sources.members !== null &&+ sources.boundaries !== null &&+ (sources.boundaries.pinvoke_imports.some(+ ({ member_token }) => member_token !== null,+ ) ||+ sources.boundaries.native_implementations.length > 0) &&+ !managedTokenScopesMatch(+ sources.members.identity_scope.requires_mvid,+ sources.boundaries.identity_scope.requires_mvid,+ ),partialInput: [sources.members?.coverage.state,sources.boundaries?.coverage.state,@@ -54,7 +67,7 @@ export const assessManagedGraphOmissions = (export const managedGraphEvidenceCoverage = (omissions: ManagedGraphProjectionOmissions,): ApplicationGraphEvidence["coverage"] =>- omissions.partialInput+ omissions.partialInput || omissions.unscopedTokenRelationships? {status: "partial",truncated: false,@@ -67,7 +80,8 @@ export const managedGraphEvidenceCoverage = (export const managedGraphResultCoverage = (omissions: ManagedGraphProjectionOmissions,) => ({- status: omissions.partialInput- ? ("partial" as const)- : ("complete-within-inputs" as const),+ status:+ omissions.partialInput || omissions.unscopedTokenRelationships+ ? ("partial" as const)+ : ("complete-within-inputs" as const),});diff --git a/src/domain/managed/managedApplicationGraphNodes.ts b/src/domain/managed/managedApplicationGraphNodes.tsindex cd631d018..ff186cecc 100644--- a/src/domain/managed/managedApplicationGraphNodes.ts+++ b/src/domain/managed/managedApplicationGraphNodes.ts@@ -7,6 +7,7 @@ import type { ApplicationGraphEvidence } from "../javascript/javascriptApplicatiimport type { ApplicationNode } from "../javascript/javascriptApplicationGraphSchemas.js";import { managedSourceCoverage } from "./managedApplicationGraphCoverage.js";import type { Evidence } from "../evidence.js";+import { managedTokenScopesMatch } from "./managedInspectionEvidence.js";import {type ManagedArtifactInspection,type ManagedMemberInspection,@@ -106,7 +107,7 @@ export const addArtifactIdentityNodes = (identity: artifactLocalIdentity(state.artifactSha256,"managed-module",- module.mvid ?? module.token,+ module.mvid?.toLowerCase() ?? module.token,),observations: [{@@ -138,25 +139,32 @@ interface ManagedModuleSource {const selectModuleSource = (parsed: ParsedManagedGraphInput,): ManagedModuleSource | null => {- if (parsed.artifact?.result.module != null)- return {- module: parsed.artifact.result.module,- evidence: parsed.artifact.evidence,- coverageState: parsed.artifact.result.coverage.state,- };- if (parsed.members?.result.module != null)- return {- module: parsed.members.result.module,- evidence: parsed.members.evidence,- coverageState: parsed.members.result.coverage.state,- };- if (parsed.boundaries?.result.module != null)- return {- module: parsed.boundaries.result.module,- evidence: parsed.boundaries.evidence,- coverageState: parsed.boundaries.result.coverage.state,- };- return null;+ const sources = [+ parsed.artifact?.result.module == null+ ? null+ : {+ module: parsed.artifact.result.module,+ evidence: parsed.artifact.evidence,+ coverageState: parsed.artifact.result.coverage.state,+ },+ parsed.members?.result.module == null+ ? null+ : {+ module: parsed.members.result.module,+ evidence: parsed.members.evidence,+ coverageState: parsed.members.result.coverage.state,+ },+ parsed.boundaries?.result.module == null+ ? null+ : {+ module: parsed.boundaries.result.module,+ evidence: parsed.boundaries.evidence,+ coverageState: parsed.boundaries.result.coverage.state,+ },+ ].filter((source): source is ManagedModuleSource => source !== null);+ return (+ sources.find(({ module }) => module.mvid !== null) ?? sources[0] ?? null+ );};/** Add managed type, method, and field nodes from member evidence. */@@ -332,11 +340,17 @@ export const addBoundaryNodes = (boundaryInput.evidence,boundaries.coverage.state,);+ const canJoinMemberTokens =+ parsed.members !== null &&+ managedTokenScopesMatch(+ parsed.members.result.identity_scope.requires_mvid,+ boundaries.identity_scope.requires_mvid,+ );for (const pinvoke of pinvokes) {const node = pinvokeNode(state, pinvoke, sourceEvidence);state.nodes.push(node);const method =- pinvoke.member_token === null+ pinvoke.member_token === null || !canJoinMemberTokens? undefined: state.methodNodes.get(pinvoke.member_token);const memberEvidence =@@ -370,7 +384,10 @@ export const addBoundaryNodes = (sourceEvidence,);state.nodes.push(node);- const owner = state.methodNodes.get(implementation.token) ?? artifactNode;+ const owner =+ (canJoinMemberTokens+ ? state.methodNodes.get(implementation.token)+ : undefined) ?? artifactNode;addContainsEdge(state, owner, node, {kind: "declares-managed-native-implementation",coverage: implementationCoverage,diff --git a/src/domain/managed/managedInspectionEvidence.ts b/src/domain/managed/managedInspectionEvidence.tsindex 3bd35ea7b..fa4712b5d 100644--- a/src/domain/managed/managedInspectionEvidence.ts+++ b/src/domain/managed/managedInspectionEvidence.ts@@ -1,12 +1,28 @@import { parseEvidence, type Evidence } from "../evidence.js";import type { z } from "zod";+/** Build-local metadata tokens join only under a known, matching module MVID. */+export const managedTokenScopesMatch = (+ leftMvid: string | null,+ rightMvid: string | null,+): boolean =>+ leftMvid !== null &&+ rightMvid !== null &&+ leftMvid.toLowerCase() === rightMvid.toLowerCase();+/*** Parse managed inspection Evidence and bind its artifact to any available subject.* A null subject remains valid and means there is no digest to cross-check.*/export const parseManagedInspectionEvidence = <- Result extends { readonly artifact: { readonly sha256: string } },+ Result extends {+ readonly artifact: { readonly sha256: string };+ readonly identity_scope?: {+ readonly requires_artifact_sha256: string;+ readonly requires_mvid: string | null;+ };+ readonly module?: { readonly mvid: string | null } | null;+ },>(rawEvidence: unknown,operation: string,@@ -22,5 +38,20 @@ export const parseManagedInspectionEvidence = <throw new TypeError(`Managed Evidence ${operation} (${evidence.evidence_id}) subject SHA-256 ${subjectSha256} does not match normalized artifact SHA-256 ${artifactSha256}`,);+ const scope = result.identity_scope;+ if (scope !== undefined && scope.requires_artifact_sha256 !== artifactSha256)+ throw new TypeError(+ `Managed Evidence ${operation} (${evidence.evidence_id}) token scope SHA-256 ${scope.requires_artifact_sha256} does not match normalized artifact SHA-256 ${artifactSha256}`,+ );+ if (+ scope?.requires_mvid !== undefined &&+ scope.requires_mvid !== null &&+ result.module?.mvid !== undefined &&+ result.module.mvid !== null &&+ scope.requires_mvid.toLowerCase() !== result.module.mvid.toLowerCase()+ )+ throw new TypeError(+ `Managed Evidence ${operation} (${evidence.evidence_id}) token scope MVID ${scope.requires_mvid} does not match module MVID ${result.module.mvid}`,+ );return { evidence, result };};diff --git a/tests/composition/analysis-sessions/managedApplicationGraph.test.ts b/tests/composition/analysis-sessions/managedApplicationGraph.test.tsindex e96efb442..915545a69 100644--- a/tests/composition/analysis-sessions/managedApplicationGraph.test.ts+++ b/tests/composition/analysis-sessions/managedApplicationGraph.test.ts@@ -8,6 +8,10 @@ import { MANAGED_STATIC_PROVIDER } from "../../../src/application/InvestigationPimport { createEvidence, parseEvidence } from "../../../src/domain/evidence.js";import { parseJavaScriptApplicationGraph } from "../../../src/domain/javascript/javascriptApplicationGraph.js";import { managedApplicationGraphResultSchema } from "../../../src/domain/managed/managedApplicationGraph.js";+import {+ managedMemberInspectionSchema,+ managedNativeBoundaryInspectionSchema,+} from "../../../src/domain/managed/managedArtifact.js";import { inspectManagedArtifactBytes } from "../../../src/dotnet/ManagedArtifactInspector.js";import { inspectManagedMembersBytes } from "../../../src/dotnet/ManagedMemberInspector.js";import { inspectManagedNativeBoundariesBytes } from "../../../src/dotnet/ManagedNativeBoundaryInspector.js";@@ -299,6 +303,282 @@ describe("managed application graph identity facts", () => {});});+it("normalizes MVID casing for node identity while preserving observed values", () => {+ const { memberEvidence, boundaryEvidence } = createManagedInteropEvidence();+ const members = managedMemberInspectionSchema.parse(+ parseEvidence(memberEvidence).normalized_result,+ );+ if (members.module === null)+ throw new Error("Expected fixture module identity");+ const uppercaseMvid = members.module.mvid?.toUpperCase();+ if (uppercaseMvid === undefined || uppercaseMvid === null)+ throw new Error("Expected fixture module MVID");+ const uppercaseMembers = createEvidence(undefined, MANAGED_STATIC_PROVIDER, {+ operation: "inspect_managed_members",+ parameters: {},+ result: {+ ...members,+ module: {+ ...members.module,+ mvid: uppercaseMvid,+ enc_id: null,+ enc_base_id: null,+ },+ identity_scope: {+ ...members.identity_scope,+ requires_mvid: uppercaseMvid,+ },+ },+ rawResult: null,+ limitations: members.limitations,+ });+ const baseline = projectManagedApplicationGraphEvidence({+ managed_members: memberEvidence,+ managed_native_boundaries: boundaryEvidence,+ });+ const uppercase = projectManagedApplicationGraphEvidence({+ managed_members: uppercaseMembers,+ managed_native_boundaries: boundaryEvidence,+ });+ if (!baseline.ok) throw baseline.error;+ if (!uppercase.ok) throw uppercase.error;+ const baselineResult = managedApplicationGraphResultSchema.parse(+ parseEvidence(baseline.value).normalized_result,+ );+ const uppercaseResult = managedApplicationGraphResultSchema.parse(+ parseEvidence(uppercase.value).normalized_result,+ );+ const baselineModule = parseJavaScriptApplicationGraph(+ baselineResult.graph,+ ).nodes.find(({ kind }) => kind === "managed-module");+ const uppercaseGraph = parseJavaScriptApplicationGraph(uppercaseResult.graph);+ const uppercaseModule = uppercaseGraph.nodes.find(+ ({ kind }) => kind === "managed-module",+ );+ expect(uppercaseGraph.edges).toContainEqual(+ expect.objectContaining({+ relation: "imports",+ source_node_id: uppercaseGraph.nodes.find(+ ({ kind }) => kind === "managed-method",+ )?.node_id,+ }),+ );+ expect(uppercaseModule?.node_id).toBe(baselineModule?.node_id);+ expect(uppercaseModule?.observations[0]?.properties.mvid).toBe(uppercaseMvid);+});++describe("managed application graph module identity consistency", () => {+ it("rejects contradictory known module MVIDs across same-artifact inputs", () => {+ const { artifactEvidence, memberEvidence, boundaryEvidence } =+ createManagedInteropEvidence();+ const boundaries = managedNativeBoundaryInspectionSchema.parse(+ parseEvidence(boundaryEvidence).normalized_result,+ );+ const conflictingMvid = "ffffffff-ffff-ffff-ffff-ffffffffffff";+ const conflictingBoundaries = createEvidence(+ undefined,+ MANAGED_STATIC_PROVIDER,+ {+ operation: "inspect_managed_native_boundaries",+ parameters: {},+ result: {+ ...boundaries,+ module:+ boundaries.module === null+ ? null+ : { ...boundaries.module, mvid: conflictingMvid },+ identity_scope: {+ ...boundaries.identity_scope,+ requires_mvid: conflictingMvid,+ },+ },+ rawResult: null,+ limitations: boundaries.limitations,+ },+ );++ const projected = projectManagedApplicationGraphEvidence({+ managed_artifact: artifactEvidence,+ managed_members: memberEvidence,+ managed_native_boundaries: conflictingBoundaries,+ });+ expect(projected.ok).toBe(false);+ if (projected.ok) throw new Error("conflicting MVIDs were accepted");+ expect(JSON.stringify(projected.error)).toContain(+ "conflicting known module MVIDs or token scopes",+ );+ });++ it("rejects contradictory known module declaration fields", () => {+ const { artifactEvidence, memberEvidence } = createManagedInteropEvidence();+ const members = managedMemberInspectionSchema.parse(+ parseEvidence(memberEvidence).normalized_result,+ );+ if (members.module === null)+ throw new Error("Expected fixture module identity");+ const conflictingMembers = createEvidence(+ undefined,+ MANAGED_STATIC_PROVIDER,+ {+ operation: "inspect_managed_members",+ parameters: {},+ result: {+ ...members,+ module: {+ ...members.module,+ generation: members.module.generation + 1,+ },+ },+ rawResult: null,+ limitations: members.limitations,+ },+ );++ const projected = projectManagedApplicationGraphEvidence({+ managed_artifact: artifactEvidence,+ managed_members: conflictingMembers,+ });+ expect(projected.ok).toBe(false);+ if (projected.ok)+ throw new Error("conflicting module declaration was accepted");+ expect(JSON.stringify(projected.error)).toContain(+ "conflicting module generation values",+ );+ });+});++describe("managed application graph token scope", () => {+ it("checks declared token artifact and MVID scopes without a subject digest", () => {+ const { memberEvidence } = createManagedInteropEvidence();+ const members = managedMemberInspectionSchema.parse(+ parseEvidence(memberEvidence).normalized_result,+ );+ const wrongMvidValue = "ffffffff-ffff-ffff-ffff-ffffffffffff";+ const wrongMvidEvidence = createEvidence(+ undefined,+ MANAGED_STATIC_PROVIDER,+ {+ operation: "inspect_managed_members",+ parameters: {},+ result: {+ ...members,+ identity_scope: {+ ...members.identity_scope,+ requires_mvid: wrongMvidValue,+ },+ },+ rawResult: null,+ limitations: members.limitations,+ },+ );+ const wrongArtifactEvidence = createEvidence(+ undefined,+ MANAGED_STATIC_PROVIDER,+ {+ operation: "inspect_managed_members",+ parameters: {},+ result: {+ ...members,+ identity_scope: {+ ...members.identity_scope,+ requires_artifact_sha256: "b".repeat(64),+ },+ },+ rawResult: null,+ limitations: members.limitations,+ },+ );++ const wrongMvidResult = projectManagedApplicationGraphEvidence({+ managed_members: wrongMvidEvidence,+ });+ expect(wrongMvidResult.ok).toBe(false);+ if (wrongMvidResult.ok)+ throw new Error("mismatched token MVID was accepted");+ expect(JSON.stringify(wrongMvidResult.error)).toContain("token scope MVID");++ const wrongArtifact = projectManagedApplicationGraphEvidence({+ managed_members: wrongArtifactEvidence,+ });+ expect(wrongArtifact.ok).toBe(false);+ if (wrongArtifact.ok)+ throw new Error("mismatched token artifact digest was accepted");+ expect(JSON.stringify(wrongArtifact.error)).toContain(+ "token scope SHA-256",+ );+ });+});++describe("unknown managed application graph token scope", () => {+ it("keeps absent MVID scope unknown and marks cross-source token joins partial", () => {+ const { memberEvidence, boundaryEvidence } = createManagedInteropEvidence();+ const members = managedMemberInspectionSchema.parse(+ parseEvidence(memberEvidence).normalized_result,+ );+ const boundaries = managedNativeBoundaryInspectionSchema.parse(+ parseEvidence(boundaryEvidence).normalized_result,+ );+ const unknownMembers = createEvidence(undefined, MANAGED_STATIC_PROVIDER, {+ operation: "inspect_managed_members",+ parameters: {},+ result: {+ ...members,+ module:+ members.module === null+ ? null+ : {+ ...members.module,+ mvid: null,+ enc_id: null,+ enc_base_id: null,+ },+ identity_scope: { ...members.identity_scope, requires_mvid: null },+ },+ rawResult: null,+ limitations: members.limitations,+ });++ const projected = projectManagedApplicationGraphEvidence({+ managed_members: unknownMembers,+ managed_native_boundaries: boundaryEvidence,+ });+ if (!projected.ok) throw projected.error;+ const result = managedApplicationGraphResultSchema.parse(+ parseEvidence(projected.value).normalized_result,+ );+ const graph = parseJavaScriptApplicationGraph(result.graph);+ expect(result.summary.modules).toBe(1);+ expect(result.coverage.status).toBe("partial");+ expect(result.limitations).toContain(+ "Managed boundary tokens were not linked to member nodes because matching module MVID scope was not established.",+ );+ const moduleObservation = graph.nodes.find(+ ({ kind }) => kind === "managed-module",+ )?.observations[0];+ expect(moduleObservation?.properties.mvid).toBe(boundaries.module?.mvid);+ expect(moduleObservation?.evidence.extractor.operation).toBe(+ "inspect_managed_native_boundaries",+ );+ const method = graph.nodes.find(+ ({ kind, observations }) =>+ kind === "managed-method" &&+ observations[0]?.label === "Fixture.Program.Main",+ );+ expect(method).toBeDefined();+ const importEdge = graph.edges.find(+ ({ relation, target_node_id }) =>+ relation === "imports" &&+ graph.nodes.find(({ node_id }) => node_id === target_node_id)?.kind ===+ "managed-pinvoke-import",+ );+ expect(importEdge).toBeDefined();+ expect(+ graph.nodes.find(({ node_id }) => node_id === importEdge?.source_node_id)+ ?.kind,+ ).toBe("artifact");+ });+});+describe("managed application graph coverage", () => {it("preserves partial parser coverage in graph and per-fact coverage", () => {const bytes = buildManagedPeFixture();