diff --git a/src/domain/managed/managedApplicationGraph.ts b/src/domain/managed/managedApplicationGraph.ts index 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 => + 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.ts index 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.ts index cd631d018..ff186cecc 100644 --- a/src/domain/managed/managedApplicationGraphNodes.ts +++ b/src/domain/managed/managedApplicationGraphNodes.ts @@ -7,6 +7,7 @@ import type { ApplicationGraphEvidence } from "../javascript/javascriptApplicati import 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.ts index 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.ts index 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/InvestigationP import { 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();