fix(managed): bind graph facts to their source Evidence

This commit is contained in:
morluto
2026-10-10 00:35:17 +08:00
parent b112d44a39
commit cc7b5af077
4 changed files with 309 additions and 124 deletions
+17 -6
View File
@@ -151,8 +151,8 @@ export const projectManagedApplicationGraph = (
};
const artifactNode = addArtifactNode(state);
addArtifactIdentityNodes(state, artifactNode, parsed);
const memberCounts = addMemberNodes(state, artifactNode, parsed);
const boundaryCounts = addBoundaryNodes(state, artifactNode, parsed);
addMemberNodes(state, artifactNode, parsed);
addBoundaryNodes(state, artifactNode, parsed);
const omissions = omittedCounts(parsed);
const limitations = projectionLimitations(parsed, omissions);
const graph = createJavaScriptApplicationGraph({
@@ -175,10 +175,16 @@ export const projectManagedApplicationGraph = (
summary: {
graph_nodes: graph.nodes.length,
graph_edges: graph.edges.length,
assemblies: parsed.artifact?.result.assembly === null ? 0 : 1,
modules: parsed.artifact?.result.module === null ? 0 : 1,
...memberCounts,
...boundaryCounts,
assemblies: countNodes(graph.nodes, "managed-assembly"),
modules: countNodes(graph.nodes, "managed-module"),
types: countNodes(graph.nodes, "managed-type"),
methods: countNodes(graph.nodes, "managed-method"),
fields: countNodes(graph.nodes, "managed-field"),
pinvoke_imports: countNodes(graph.nodes, "managed-pinvoke-import"),
native_implementations: countNodes(
graph.nodes,
"managed-native-implementation",
),
},
graph,
coverage: managedGraphResultCoverage(omissions),
@@ -191,6 +197,11 @@ export const projectManagedApplicationGraph = (
});
};
const countNodes = (
nodes: readonly ApplicationNode[],
kind: ApplicationNode["kind"],
): number => nodes.filter((node) => node.kind === kind).length;
const parseManagedInputs = (
input: ProjectManagedApplicationGraphInput,
): ParsedManagedGraphInput => ({
@@ -1,11 +0,0 @@
import type { ParsedManagedGraphInput } from "./managedApplicationGraph.js";
/** Derive module coverage from the best available managed evidence source. */
export const moduleCoverageState = (
parsed: ParsedManagedGraphInput,
): "complete" | "partial" | "unavailable" =>
parsed.artifact !== null && parsed.artifact.result.module !== null
? parsed.artifact.result.coverage.state
: parsed.members !== null && parsed.members.result.module !== null
? parsed.members.result.coverage.state
: (parsed.boundaries?.result.coverage.state ?? "complete");
@@ -6,7 +6,9 @@ import {
import type { ApplicationGraphEvidence } from "../javascript/javascriptApplicationEvidenceSchemas.js";
import type { ApplicationNode } from "../javascript/javascriptApplicationGraphSchemas.js";
import { managedSourceCoverage } from "./managedApplicationGraphCoverage.js";
import type { Evidence } from "../evidence.js";
import {
type ManagedArtifactInspection,
type ManagedMemberInspection,
type ManagedNativeBoundaryInspection,
} from "./managedArtifact.js";
@@ -14,7 +16,6 @@ import type {
GraphBuildState,
ParsedManagedGraphInput,
} from "./managedApplicationGraph.js";
import { moduleCoverageState } from "./managedApplicationGraphNodeCoverage.js";
type ManagedMethod = ManagedMemberInspection["methods"][number];
type ManagedField = ManagedMemberInspection["fields"][number];
type ManagedType = ManagedMemberInspection["types"][number];
@@ -44,7 +45,7 @@ export const addArtifactNode = (state: GraphBuildState): ApplicationNode => {
format: "pe",
source: "managed-application-graph",
},
evidence: managedEvidence(state, "project-managed-artifact"),
evidence: projectedManagedEvidence(state, "project-managed-artifact"),
},
],
});
@@ -58,47 +59,48 @@ export const addArtifactIdentityNodes = (
artifactNode: ApplicationNode,
parsed: ParsedManagedGraphInput,
): void => {
const artifact = parsed.artifact?.result;
const artifactCoverage = managedSourceCoverage(
parsed.artifact?.result.coverage.state ?? "complete",
);
if (artifact?.assembly !== undefined && artifact.assembly !== null) {
const artifactInput = parsed.artifact;
if (artifactInput !== null && artifactInput.result.assembly !== null) {
const assemblyFacts = artifactInput.result.assembly;
const artifactEvidence = sourceManagedEvidence(
state,
artifactInput.evidence,
artifactInput.result.coverage.state,
);
const assembly = createJavaScriptApplicationNode({
kind: "managed-assembly",
identity: artifactLocalIdentity(
state.artifactSha256,
"managed-assembly",
artifact.assembly.token,
assemblyFacts.token,
),
observations: [
{
label: artifact.assembly.name,
label: assemblyFacts.name,
properties: {
name: artifact.assembly.name,
version: artifact.assembly.version,
culture: artifact.assembly.culture,
public_key_kind: artifact.assembly.public_key.kind,
name: assemblyFacts.name,
version: assemblyFacts.version,
culture: assemblyFacts.culture,
public_key_kind: assemblyFacts.public_key.kind,
},
evidence: managedEvidence(
state,
"inspect_managed_artifact",
artifactCoverage,
),
evidence: artifactEvidence,
},
],
});
state.nodes.push(assembly);
addContainsEdge(state, artifactNode, assembly, {
kind: "declares-managed-assembly",
coverage: artifactCoverage,
coverage: artifactEvidence.coverage,
});
}
const module =
artifact?.module ??
parsed.members?.result.module ??
parsed.boundaries?.result.module;
if (module !== undefined && module !== null) {
const moduleCoverage = managedSourceCoverage(moduleCoverageState(parsed));
const moduleSource = selectModuleSource(parsed);
if (moduleSource !== null) {
const { module } = moduleSource;
const moduleEvidence = sourceManagedEvidence(
state,
moduleSource.evidence,
moduleSource.coverageState,
);
const moduleNode = createJavaScriptApplicationNode({
kind: "managed-module",
identity: artifactLocalIdentity(
@@ -115,36 +117,68 @@ export const addArtifactIdentityNodes = (
generation: module.generation,
token: module.token,
},
evidence: managedEvidence(
state,
"inspect_managed_artifact",
moduleCoverage,
),
evidence: moduleEvidence,
},
],
});
state.nodes.push(moduleNode);
addContainsEdge(state, artifactNode, moduleNode, {
kind: "declares-managed-module",
coverage: moduleCoverage,
coverage: moduleEvidence.coverage,
});
}
};
interface ManagedModuleSource {
readonly module: NonNullable<ManagedArtifactInspection["module"]>;
readonly evidence: Evidence;
readonly coverageState: ManagedArtifactInspection["coverage"]["state"];
}
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;
};
/** Add managed type, method, and field nodes from member evidence. */
export const addMemberNodes = (
state: GraphBuildState,
artifactNode: ApplicationNode,
parsed: ParsedManagedGraphInput,
) => {
const members = parsed.members?.result;
if (members === undefined) return { types: 0, methods: 0, fields: 0 };
): void => {
const memberInput = parsed.members;
if (memberInput === null) return;
const members = memberInput.result;
const { types, methods, fields } = members;
const typeCoverage = managedSourceCoverage(members.coverage.state);
const methodCoverage = managedSourceCoverage(members.coverage.state);
const fieldCoverage = managedSourceCoverage(members.coverage.state);
const sourceEvidence = sourceManagedEvidence(
state,
memberInput.evidence,
members.coverage.state,
);
for (const type of types) {
const node = typeNode(state, type, typeCoverage);
const node = typeNode(state, type, sourceEvidence);
state.nodes.push(node);
state.typeNodes.set(type.token, node);
addContainsEdge(state, artifactNode, node, {
@@ -153,7 +187,7 @@ export const addMemberNodes = (
});
}
for (const method of methods) {
const node = methodNode(state, method, methodCoverage);
const node = methodNode(state, method, sourceEvidence);
state.nodes.push(node);
state.methodNodes.set(method.token, node);
const owner =
@@ -166,7 +200,7 @@ export const addMemberNodes = (
});
}
for (const field of fields) {
const node = fieldNode(state, field, fieldCoverage);
const node = fieldNode(state, field, sourceEvidence);
state.nodes.push(node);
state.fieldNodes.set(field.token, node);
const owner =
@@ -178,18 +212,13 @@ export const addMemberNodes = (
coverage: fieldCoverage,
});
}
return {
types: types.length,
methods: methods.length,
fields: fields.length,
};
};
/** Build a managed type application node. */
const typeNode = (
state: GraphBuildState,
type: ManagedType,
coverage: ApplicationGraphEvidence["coverage"],
evidence: ApplicationGraphEvidence,
): ApplicationNode =>
createJavaScriptApplicationNode({
kind: "managed-type",
@@ -209,7 +238,7 @@ const typeNode = (
flags: type.flags,
extends_token: type.extends_token,
},
evidence: managedEvidence(state, "inspect_managed_members", coverage),
evidence,
},
],
});
@@ -218,7 +247,7 @@ const typeNode = (
const methodNode = (
state: GraphBuildState,
method: ManagedMethod,
coverage: ApplicationGraphEvidence["coverage"],
evidence: ApplicationGraphEvidence,
): ApplicationNode =>
createJavaScriptApplicationNode({
kind: "managed-method",
@@ -245,7 +274,7 @@ const methodNode = (
normalized_il_sha256: method.body.normalized_il_sha256,
il_size: method.body.il_size,
},
evidence: managedEvidence(state, "inspect_managed_members", coverage),
evidence,
},
],
});
@@ -254,7 +283,7 @@ const methodNode = (
const fieldNode = (
state: GraphBuildState,
field: ManagedField,
coverage: ApplicationGraphEvidence["coverage"],
evidence: ApplicationGraphEvidence,
): ApplicationNode =>
createJavaScriptApplicationNode({
kind: "managed-field",
@@ -278,7 +307,7 @@ const fieldNode = (
signature_sha256: field.signature.raw_sha256,
signature_status: field.signature.parse_status,
},
evidence: managedEvidence(state, "inspect_managed_members", coverage),
evidence,
},
],
});
@@ -288,23 +317,33 @@ export const addBoundaryNodes = (
state: GraphBuildState,
artifactNode: ApplicationNode,
parsed: ParsedManagedGraphInput,
) => {
const boundaries = parsed.boundaries?.result;
if (boundaries === undefined)
return { pinvoke_imports: 0, native_implementations: 0 };
): void => {
const boundaryInput = parsed.boundaries;
if (boundaryInput === null) return;
const boundaries = boundaryInput.result;
const { pinvoke_imports: pinvokes, native_implementations: implementations } =
boundaries;
const pinvokeCoverage = managedSourceCoverage(boundaries.coverage.state);
const implementationCoverage = managedSourceCoverage(
boundaries.coverage.state,
);
const sourceEvidence = sourceManagedEvidence(
state,
boundaryInput.evidence,
boundaries.coverage.state,
);
for (const pinvoke of pinvokes) {
const node = pinvokeNode(state, pinvoke, pinvokeCoverage);
const node = pinvokeNode(state, pinvoke, sourceEvidence);
state.nodes.push(node);
const owner =
const method =
pinvoke.member_token === null
? artifactNode
: (state.methodNodes.get(pinvoke.member_token) ?? artifactNode);
? undefined
: state.methodNodes.get(pinvoke.member_token);
const memberEvidence =
method === undefined || parsed.members === null
? undefined
: parsed.members.evidence;
const owner = method ?? artifactNode;
state.edges.push(
createJavaScriptApplicationEdge({
source_node_id: owner.node_id,
@@ -315,10 +354,11 @@ export const addBoundaryNodes = (
import_name: pinvoke.import_name,
import_scope_name: pinvoke.import_scope_name,
},
evidence: managedEvidence(
evidence: pinvokeAssociationEvidence(
state,
"inspect_managed_native_boundaries",
boundaryInput.evidence,
pinvokeCoverage,
memberEvidence,
),
}),
);
@@ -327,7 +367,7 @@ export const addBoundaryNodes = (
const node = nativeImplementationNode(
state,
implementation,
implementationCoverage,
sourceEvidence,
);
state.nodes.push(node);
const owner = state.methodNodes.get(implementation.token) ?? artifactNode;
@@ -336,17 +376,13 @@ export const addBoundaryNodes = (
coverage: implementationCoverage,
});
}
return {
pinvoke_imports: pinvokes.length,
native_implementations: implementations.length,
};
};
/** Build a managed P/Invoke import application node. */
const pinvokeNode = (
state: GraphBuildState,
pinvoke: PinvokeImport,
coverage: ApplicationGraphEvidence["coverage"],
evidence: ApplicationGraphEvidence,
): ApplicationNode =>
createJavaScriptApplicationNode({
kind: "managed-pinvoke-import",
@@ -368,11 +404,7 @@ const pinvokeNode = (
call_convention: pinvoke.call_convention,
verification: pinvoke.verification,
},
evidence: managedEvidence(
state,
"inspect_managed_native_boundaries",
coverage,
),
evidence,
},
],
});
@@ -381,7 +413,7 @@ const pinvokeNode = (
const nativeImplementationNode = (
state: GraphBuildState,
implementation: NativeImplementation,
coverage: ApplicationGraphEvidence["coverage"],
evidence: ApplicationGraphEvidence,
): ApplicationNode =>
createJavaScriptApplicationNode({
kind: "managed-native-implementation",
@@ -403,11 +435,7 @@ const nativeImplementationNode = (
boundary_kind: implementation.boundary_kind,
body_interpretation: implementation.body_interpretation,
},
evidence: managedEvidence(
state,
"inspect_managed_native_boundaries",
coverage,
),
evidence,
},
],
});
@@ -425,7 +453,7 @@ const addContainsEdge = (
target_node_id: target.node_id,
relation: "contains",
properties: { kind: options.kind },
evidence: managedEvidence(
evidence: projectedManagedEvidence(
state,
"project-managed-contains",
options.coverage,
@@ -448,12 +476,43 @@ const artifactLocalIdentity = (
});
/** Build managed static-analysis evidence for a graph observation. */
const managedEvidence = (
const sourceManagedEvidence = (
state: GraphBuildState,
source: Evidence,
coverageState: ManagedArtifactInspection["coverage"]["state"],
): ApplicationGraphEvidence =>
createManagedEvidence(
state,
source.operation,
managedSourceCoverage(coverageState),
[source.evidence_id],
);
const projectedManagedEvidence = (
state: GraphBuildState,
operation: string,
coverage: ApplicationGraphEvidence["coverage"] = managedSourceCoverage(
"complete",
),
): ApplicationGraphEvidence =>
createManagedEvidence(state, operation, coverage, state.evidenceLinks);
const pinvokeAssociationEvidence = (
state: GraphBuildState,
boundaryEvidence: Evidence,
coverage: ApplicationGraphEvidence["coverage"],
memberEvidence: Evidence | undefined,
): ApplicationGraphEvidence =>
createManagedEvidence(state, boundaryEvidence.operation, coverage, [
boundaryEvidence.evidence_id,
...(memberEvidence === undefined ? [] : [memberEvidence.evidence_id]),
]);
const createManagedEvidence = (
state: GraphBuildState,
operation: string,
coverage: ApplicationGraphEvidence["coverage"],
evidenceIds: readonly string[],
): ApplicationGraphEvidence => ({
authority: "managed-static-analysis",
state: "observed",
@@ -483,7 +542,7 @@ const managedEvidence = (
: [
"The source managed Evidence slice is incomplete; unreturned or unavailable items remain unobserved.",
],
evidence_ids: state.evidenceLinks,
evidence_ids: [...evidenceIds],
});
/** Sanitize an artifact path into a managed graph location. */