174 lines
5.9 KiB
TypeScript
174 lines
5.9 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
|
|
import { createEvidence } from "../domain/evidence.js";
|
|
import { createEvidenceBundle } from "../domain/evidenceBundle.js";
|
|
import { emptyUnverifiedProcessCapture } from "../domain/process/processCapture.fixture.js";
|
|
import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
|
|
import {
|
|
digestProcessCommitment,
|
|
parseProcessScenario,
|
|
processComparisonContract,
|
|
processScenarioCommitment,
|
|
} from "../domain/process/processScenario.js";
|
|
import {
|
|
APPLICATION_GRAPH_DIGESTS,
|
|
artifactEvidence,
|
|
buildSyntheticJavaScriptApplicationGraph,
|
|
completeCoverage,
|
|
} from "../domain/javascript/javascriptApplicationGraph.fixture.js";
|
|
import {
|
|
createJavaScriptApplicationGraph,
|
|
createJavaScriptApplicationNode,
|
|
} from "../domain/javascript/javascriptApplicationGraph.js";
|
|
import { jsonValueSchema } from "../domain/jsonValue.js";
|
|
import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
|
|
import { createProcessCaptureEvidence } from "./process/ProcessEvidence.js";
|
|
import { deriveReconstructionObligationCandidates } from "./ReconstructionObligationCandidates.js";
|
|
|
|
const applicationWithUnknowns = (keys: readonly string[]) => {
|
|
const source = createEvidence(
|
|
undefined,
|
|
{ id: "fixture-source", name: "Fixture source", version: "1" },
|
|
{
|
|
operation: "inspect_fixture_source",
|
|
parameters: {},
|
|
result: {},
|
|
confidence: "observed",
|
|
authority: "shipped-artifact",
|
|
},
|
|
);
|
|
const base = buildSyntheticJavaScriptApplicationGraph();
|
|
const unknownNodes = keys.map((key) =>
|
|
createJavaScriptApplicationNode({
|
|
kind: "unknown",
|
|
identity: {
|
|
strategy: "artifact-local-key",
|
|
stability: "artifact-version",
|
|
artifact_sha256: APPLICATION_GRAPH_DIGESTS.asar,
|
|
namespace: "fixture",
|
|
key,
|
|
},
|
|
observations: [
|
|
{
|
|
label: "Unclassified application boundary",
|
|
properties: {},
|
|
evidence: artifactEvidence(
|
|
APPLICATION_GRAPH_DIGESTS.asar,
|
|
"unclassified.js",
|
|
),
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
const graph = createJavaScriptApplicationGraph({
|
|
schema: "JavaScriptApplicationGraph",
|
|
root_node_ids: base.root_node_ids,
|
|
nodes: [...base.nodes, ...unknownNodes],
|
|
edges: base.edges,
|
|
coverage: completeCoverage,
|
|
limitations: base.limitations,
|
|
});
|
|
const application = createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
|
|
predicateType: "rea.managed-application-graph",
|
|
operation: "project_managed_application_graph",
|
|
parameters: {},
|
|
result: jsonValueSchema.parse({
|
|
projection_id: `magp_${"a".repeat(64)}`,
|
|
root_artifact_sha256: APPLICATION_GRAPH_DIGESTS.asar,
|
|
source_evidence: {
|
|
managed_artifact_evidence_id: source.evidence_id,
|
|
managed_members_evidence_id: null,
|
|
managed_native_boundaries_evidence_id: null,
|
|
},
|
|
summary: {
|
|
graph_nodes: graph.nodes.length,
|
|
graph_edges: graph.edges.length,
|
|
assemblies: 0,
|
|
modules: 0,
|
|
types: 0,
|
|
methods: 0,
|
|
fields: 0,
|
|
pinvoke_imports: 0,
|
|
native_implementations: 0,
|
|
},
|
|
graph,
|
|
coverage: { status: "complete-within-inputs" },
|
|
evidence_links: [source.evidence_id],
|
|
limitations: [],
|
|
}),
|
|
confidence: "inferred",
|
|
authority: "analyst-inference",
|
|
evidenceLinks: [source.evidence_id],
|
|
});
|
|
return {
|
|
graph,
|
|
unknownNodes,
|
|
generated: deriveReconstructionObligationCandidates(
|
|
createEvidenceBundle([source, application]),
|
|
[],
|
|
),
|
|
};
|
|
};
|
|
|
|
const unknownLimitation = (graphId: string, nodeId: string): string =>
|
|
`Application graph ${graphId} contains unresolved node ${nodeId}; reconstruction obligations remain unknown.`;
|
|
|
|
describe("reconstruction obligation candidates", () => {
|
|
it("preserves unresolved application nodes as deterministic limitations", () => {
|
|
const { graph, unknownNodes, generated } = applicationWithUnknowns([
|
|
"unclassified-first",
|
|
"unclassified-second",
|
|
]);
|
|
|
|
expect(generated.candidates.length).toBeGreaterThan(0);
|
|
expect([...generated.limitations].sort()).toEqual(
|
|
unknownNodes
|
|
.map((node) => unknownLimitation(graph.graph_id, node.node_id))
|
|
.sort(),
|
|
);
|
|
for (const node of unknownNodes)
|
|
expect(
|
|
generated.candidates.some(
|
|
({ target }) => target.application_node_id === node.node_id,
|
|
),
|
|
).toBe(false);
|
|
});
|
|
|
|
it("does not bind an unknown process image to a packaged artifact obligation", () => {
|
|
const scenario = parseProcessScenario({
|
|
executable: "/path/whose-launch-identity-is-unknown",
|
|
});
|
|
const base = emptyUnverifiedProcessCapture();
|
|
const scenarioProjection = processScenarioCommitment(scenario);
|
|
const comparisonContract = processComparisonContract(scenario);
|
|
const capture = parseProcessCapture({
|
|
...base,
|
|
normalization: scenario.normalization,
|
|
manifest: {
|
|
...base.manifest,
|
|
scenario: scenarioProjection,
|
|
comparison_contract: comparisonContract,
|
|
full_scenario_sha256: digestProcessCommitment(scenarioProjection),
|
|
comparison_contract_sha256: digestProcessCommitment(comparisonContract),
|
|
selected_executable_sha256: null,
|
|
executable_sha256: null,
|
|
executable_identity: {
|
|
state: "unknown",
|
|
reason: "Selected executable could not be inspected.",
|
|
},
|
|
normalization_sha256: digestProcessCommitment(scenario.normalization),
|
|
},
|
|
});
|
|
const evidence = createProcessCaptureEvidence(scenario, capture);
|
|
const generated = deriveReconstructionObligationCandidates(
|
|
createEvidenceBundle([evidence]),
|
|
[],
|
|
);
|
|
|
|
expect(generated.candidates).toEqual([]);
|
|
expect(generated.limitations).toContain(
|
|
`Process capture ${evidence.evidence_id} has no validated executable artifact identity; packaged-process lifecycle obligation was not bound to an artifact.`,
|
|
);
|
|
});
|
|
});
|