Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(managed): own source validation and reuse parsed evidence

morluto277513525424
diff --git a/src/application/managed/ManagedApplicationGraphService.ts b/src/application/managed/ManagedApplicationGraphService.ts
index c1a2c8f8c..9c8a542b3 100644
--- a/src/application/managed/ManagedApplicationGraphService.ts
+++ b/src/application/managed/ManagedApplicationGraphService.ts
@@ -1,26 +1,18 @@
-import { z } from "zod";
-
-import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
import type { AnalysisError } from "../../domain/analysisErrorBase.js";
import {
createEvidence,
type Evidence,
type EvidenceSubjectTarget,
} from "../../domain/evidence.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
import {
- managedApplicationGraphResultSchema,
- projectManagedApplicationGraph,
- projectManagedApplicationGraphInputSchema,
+ projectManagedGraph,
+ readManagedGraphProjection,
type ManagedApplicationGraphResult,
- type ProjectManagedApplicationGraphInput,
+ type ManagedGraphProjection,
+ type ParsedManagedGraphInput,
} from "../../domain/managed/managedApplicationGraph.js";
-import { err, ok, type Result } from "../../domain/result.js";
+import { ok, type Result } from "../../domain/result.js";
import { MANAGED_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
-import {
- requestInputError,
- workflowInputError,
-} from "../workflowInputError.js";
const OPERATION = "project_managed_application_graph" as const;
@@ -28,40 +20,35 @@ const OPERATION = "project_managed_application_graph" as const;
export const projectManagedApplicationGraphEvidence = (
rawInput: unknown,
): Result<Evidence, AnalysisError> => {
- const parsed = projectManagedApplicationGraphInputSchema.safeParse(rawInput);
- if (!parsed.success)
- return err(requestInputError(OPERATION, parsed.error, rawInput));
- try {
- const result = projectManagedApplicationGraph(parsed.data);
- return ok(createManagedApplicationGraphEvidence(parsed.data, result));
- } catch (cause: unknown) {
- return err(
- cause instanceof TypeError || cause instanceof z.ZodError
- ? workflowInputError(OPERATION, cause)
- : new AnalysisProtocolError(
- "Managed application graph projection produced an invalid result",
- { cause },
- ),
- );
- }
+ const request = readManagedGraphProjection(rawInput);
+ if (!request.ok) return request;
+ return ok(projectManagedGraphEvidence(request.value));
};
+/** Project the workflow owner's authenticated, identity-checked source facts. */
+export const projectManagedGraphEvidence = (
+ request: ManagedGraphProjection,
+): Evidence =>
+ createManagedApplicationGraphEvidence(
+ request.sources,
+ projectManagedGraph(request),
+ );
+
const createManagedApplicationGraphEvidence = (
- input: ProjectManagedApplicationGraphInput,
+ input: ParsedManagedGraphInput,
result: ManagedApplicationGraphResult,
): Evidence =>
createEvidence(subjectTarget(input), MANAGED_WORKFLOW_PROVIDER, {
predicateType: "rea.managed-application-graph",
operation: OPERATION,
parameters: {
- managed_artifact_evidence_id: input.managed_artifact?.evidence_id ?? null,
- managed_members_evidence_id: input.managed_members?.evidence_id ?? null,
+ managed_artifact_evidence_id:
+ input.artifact?.evidence.evidence_id ?? null,
+ managed_members_evidence_id: input.members?.evidence.evidence_id ?? null,
managed_native_boundaries_evidence_id:
- input.managed_native_boundaries?.evidence_id ?? null,
+ input.boundaries?.evidence.evidence_id ?? null,
},
- result: jsonValueSchema.parse(
- managedApplicationGraphResultSchema.parse(result),
- ),
+ result,
rawResult: null,
confidence: "inferred",
authority: "analyst-inference",
@@ -71,12 +58,12 @@ const createManagedApplicationGraphEvidence = (
});
const subjectTarget = (
- input: ProjectManagedApplicationGraphInput,
+ input: ParsedManagedGraphInput,
): EvidenceSubjectTarget | undefined => {
const subject =
- input.managed_artifact?.subject ??
- input.managed_members?.subject ??
- input.managed_native_boundaries?.subject;
+ input.artifact?.evidence.subject ??
+ input.members?.evidence.subject ??
+ input.boundaries?.evidence.subject;
if (subject === undefined || subject === null || subject.format !== "pe")
return undefined;
return {
diff --git a/src/application/managed/ManagedMemberComparisonService.ts b/src/application/managed/ManagedMemberComparisonService.ts
index 04fae187f..f3f9273fc 100644
--- a/src/application/managed/ManagedMemberComparisonService.ts
+++ b/src/application/managed/ManagedMemberComparisonService.ts
@@ -2,17 +2,18 @@ import { z } from "zod";
import {
compareManagedMembers,
- managedMemberComparisonResultSchema,
- type CompareManagedMembersInput,
+ type ManagedMemberComparisonResult,
} from "../../domain/managed/managedMemberComparison.js";
-import { parseManagedMemberEvidence } from "../../domain/managed/managedMemberComparisonMatch.js";
+import { readManagedMemberEvidence } from "../../domain/managed/managedMemberComparisonMatch.js";
import type { BinaryTarget } from "../../domain/binaryTargetTypes.js";
import type { ArtifactResourceScope } from "../../artifacts/ArtifactResourceScope.js";
-import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
+import {
+ AnalysisInputError,
+ AnalysisOutputError,
+} from "../../domain/analysisErrorCore.js";
import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
import { AnalysisError } from "../../domain/analysisErrorBase.js";
import { createEvidence, type Evidence } from "../../domain/evidence.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
import {
classifyBinaryTargetFilesystemFailure,
parseBinaryTarget,
@@ -24,24 +25,61 @@ import {
MANAGED_STATIC_PROVIDER,
MANAGED_WORKFLOW_PROVIDER,
} from "../InvestigationProviders.js";
-import { workflowInputError } from "../workflowInputError.js";
+import { requestInputError } from "../workflowInputError.js";
+
+const managedMemberComparisonRequestSchema = z.strictObject({
+ left: z.unknown(),
+ right: z.unknown(),
+});
-/** Compare managed members from input parsed by a trusted adapter. */
-export const compareManagedMembersEvidenceValidated = (
- input: CompareManagedMembersInput,
-): Result<Evidence, AnalysisError> => {
+export interface ManagedMemberComparisonExecution {
+ readonly evidence: Evidence;
+ readonly summary: ManagedMemberComparisonResult["summary"];
+ readonly sources: readonly [Evidence, Evidence];
+}
+
+/** Authenticate both source records, then compare their parsed observations. */
+export const executeManagedMemberComparison = (
+ input: unknown,
+): Result<ManagedMemberComparisonExecution, AnalysisError> => {
const operation = "compare_managed_members";
- try {
- const left = parseManagedMemberEvidence(input.left);
- const right = parseManagedMemberEvidence(input.right);
- const result = compareManagedMembers(
- { evidenceId: left.evidenceId, result: left.result },
- { evidenceId: right.evidenceId, result: right.result },
+ const request = managedMemberComparisonRequestSchema.safeParse(input);
+ if (!request.success)
+ return err(requestInputError(operation, request.error, input));
+ const left = readManagedMemberEvidence(request.data.left, "left");
+ if (!left.ok) return left;
+ const right = readManagedMemberEvidence(request.data.right, "right");
+ if (!right.ok) return right;
+ if (left.value.evidence.evidence_id === right.value.evidence.evidence_id)
+ return err(
+ new AnalysisInputError(operation, undefined, [
+ {
+ path: ["right"],
+ reason: "invalid_value",
+ message: "Managed member Evidence must be distinct",
+ },
+ ]),
);
- return ok(createManagedMemberComparisonEvidence(input, result));
- } catch (cause: unknown) {
- return workflowFailure(operation, cause);
- }
+ const result = compareManagedMembers(
+ {
+ evidenceId: left.value.evidence.evidence_id,
+ result: left.value.result,
+ },
+ {
+ evidenceId: right.value.evidence.evidence_id,
+ result: right.value.result,
+ },
+ );
+ const evidence = createManagedMemberComparisonEvidence(
+ left.value.evidence,
+ right.value.evidence,
+ result,
+ );
+ return ok({
+ evidence,
+ summary: result.summary,
+ sources: [left.value.evidence, right.value.evidence],
+ });
};
interface ManagedMemberComparisonPathDependencies {
@@ -100,7 +138,7 @@ export const compareManagedMemberPaths = async (
const evidence = createEvidence(target, MANAGED_STATIC_PROVIDER, {
operation: "inspect_managed_members",
parameters: {},
- result: jsonValueSchema.parse(inspection),
+ result: inspection,
rawResult: null,
limitations: inspection.limitations,
locations: [{ kind: "artifact-path", path: selectedPath }],
@@ -122,30 +160,34 @@ export const compareManagedMemberPaths = async (
);
return ok(
createManagedMemberComparisonEvidence(
- {
- left: left.evidence,
- right: right.evidence,
- },
+ left.evidence,
+ right.evidence,
result,
{ leftPath: input.leftPath, rightPath: input.rightPath },
),
);
} catch (cause: unknown) {
- return workflowFailure(operation, cause, partialEvidence);
+ const failure = asOutputFailure(operation, cause);
+ return err(
+ partialEvidence === undefined
+ ? failure
+ : failure.retainPartialObservation(partialEvidence),
+ );
}
};
const createManagedMemberComparisonEvidence = (
- parameters: Pick<CompareManagedMembersInput, "left" | "right">,
- result: z.infer<typeof managedMemberComparisonResultSchema>,
+ left: Evidence,
+ right: Evidence,
+ result: ManagedMemberComparisonResult,
sourcePaths?: { readonly leftPath: string; readonly rightPath: string },
): Evidence =>
createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
predicateType: "rea.managed-member-comparison",
operation: "compare_managed_members",
parameters: {
- left_evidence_id: parameters.left.evidence_id,
- right_evidence_id: parameters.right.evidence_id,
+ left_evidence_id: left.evidence_id,
+ right_evidence_id: right.evidence_id,
...(sourcePaths === undefined
? {}
: {
@@ -153,7 +195,7 @@ const createManagedMemberComparisonEvidence = (
right_path: sourcePaths.rightPath,
}),
},
- result: jsonValueSchema.parse(result),
+ result,
rawResult: null,
confidence: "inferred",
authority: "analyst-inference",
@@ -169,23 +211,11 @@ const createManagedMemberComparisonEvidence = (
evidenceLinks: result.evidence_links,
});
-const workflowFailure = (
- operation: string,
- cause: unknown,
- partialEvidence?: Evidence,
-): Result<never, AnalysisError> => {
- const failure =
- cause instanceof AnalysisError
- ? cause
- : cause instanceof z.ZodError || cause instanceof TypeError
- ? workflowInputError(operation, cause)
- : new AnalysisProtocolError(
- "Managed member comparison produced an invalid result",
- { cause },
- );
- return err(
- partialEvidence === undefined
- ? failure
- : failure.retainPartialObservation(partialEvidence),
- );
-};
+const asOutputFailure = (operation: string, cause: unknown): AnalysisError =>
+ cause instanceof AnalysisError
+ ? cause
+ : new AnalysisOutputError(
+ operation,
+ "Managed member comparison produced invalid output",
+ { cause },
+ );
diff --git a/src/application/managed/ManagedNativeVerificationService.ts b/src/application/managed/ManagedNativeVerificationService.ts
index 09929198e..0ef84e43c 100644
--- a/src/application/managed/ManagedNativeVerificationService.ts
+++ b/src/application/managed/ManagedNativeVerificationService.ts
@@ -1,60 +1,67 @@
-import { z } from "zod";
-
-import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
import type { AnalysisError } from "../../domain/analysisErrorBase.js";
import { createEvidence, type Evidence } from "../../domain/evidence.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { ok, type Result } from "../../domain/result.js";
+import { verifyManagedNativeVerificationSource } from "../../domain/managed/managedNativeVerification.js";
import {
- managedNativeVerificationInputSchema,
- type ManagedNativeVerificationInput,
- type ManagedNativeVerificationResult,
-} from "../../domain/managed/managedNativeVerificationSchemas.js";
-import { err, ok, type Result } from "../../domain/result.js";
+ readManagedNativeVerificationSource,
+ type ManagedNativeVerificationSource,
+} from "../../domain/managed/managedNativeVerificationSource.js";
+import type { ManagedNativeVerificationResult } from "../../domain/managed/managedNativeVerificationSchemas.js";
import { MANAGED_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
-import {
- requestInputError,
- workflowInputError,
-} from "../workflowInputError.js";
-import { verifyManagedNativeBoundaries } from "../../domain/managed/managedNativeVerification.js";
const OPERATION = "verify_managed_native_boundaries" as const;
-/** Verify managed/native boundary declarations against native Evidence. */
+export interface ManagedNativeVerificationExecution {
+ readonly evidence: Evidence;
+ readonly summary: ManagedNativeVerificationResult["summary"];
+ readonly sourceEvidence: readonly Evidence[];
+}
+
+/** Resolve untrusted source Evidence, then execute over the trusted parsed source. */
+export const executeManagedNativeBoundaries = (
+ rawInput: unknown,
+): Result<ManagedNativeVerificationExecution, AnalysisError> => {
+ const source = readManagedNativeVerificationSource(rawInput);
+ if (!source.ok) return source;
+ const result = verifyManagedNativeVerificationSource(source.value);
+ const evidence = createManagedNativeVerificationEvidence(
+ source.value,
+ result,
+ );
+ return ok({
+ evidence,
+ summary: result.summary,
+ sourceEvidence: [
+ source.value.managedEvidence,
+ ...source.value.nativeObservations.map(
+ ({ evidence: observation }) => observation,
+ ),
+ ],
+ });
+};
+
+/** Return only derived Evidence for callers that do not need source observations. */
export const verifyManagedNativeBoundariesEvidence = (
rawInput: unknown,
): Result<Evidence, AnalysisError> => {
- const parsed = managedNativeVerificationInputSchema.safeParse(rawInput);
- if (!parsed.success)
- return err(requestInputError(OPERATION, parsed.error, rawInput));
- try {
- const result = verifyManagedNativeBoundaries(parsed.data);
- return ok(createManagedNativeVerificationEvidence(parsed.data, result));
- } catch (cause: unknown) {
- return err(
- cause instanceof TypeError || cause instanceof z.ZodError
- ? workflowInputError(OPERATION, cause)
- : new AnalysisProtocolError(
- "Managed/native verification produced an invalid result",
- { cause },
- ),
- );
- }
+ const execution = executeManagedNativeBoundaries(rawInput);
+ return execution.ok ? ok(execution.value.evidence) : execution;
};
const createManagedNativeVerificationEvidence = (
- input: ManagedNativeVerificationInput,
+ source: ManagedNativeVerificationSource,
result: ManagedNativeVerificationResult,
): Evidence =>
createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
predicateType: "rea.managed-native-verification",
operation: OPERATION,
parameters: {
- managed_boundaries_evidence_id: input.managed_boundaries.evidence_id,
- native_evidence_ids: jsonValueSchema.parse(
- input.native_observations.map(({ evidence_id: id }) => id),
+ managed_boundaries_evidence_id: source.managedEvidence.evidence_id,
+ native_evidence_ids: source.nativeObservations.map(
+ ({ evidence }) => evidence.evidence_id,
),
},
- result: jsonValueSchema.parse(result),
+ result,
rawResult: null,
confidence: "inferred",
authority: "analyst-inference",
diff --git a/src/application/managed/ManagedReconstructionService.test.ts b/src/application/managed/ManagedReconstructionService.test.ts
index 793951ae9..1d75633e7 100644
--- a/src/application/managed/ManagedReconstructionService.test.ts
+++ b/src/application/managed/ManagedReconstructionService.test.ts
@@ -56,21 +56,36 @@ describe("managed decompiler reconstruction import", () => {
},
],
}),
- ).toThrow(/text hash mismatch/u);
+ ).toThrow(AnalysisInputError);
});
it("rejects stale method locks", () => {
- expect(() =>
- importManagedReconstruction({
- ...exampleInput(),
- methods: [
+ const staleInput = {
+ ...exampleInput(),
+ methods: [
+ {
+ ...exampleMethod(),
+ normalized_il_sha256: "6".repeat(64),
+ },
+ ],
+ };
+ expect(() => importManagedReconstruction(staleInput)).toThrow(
+ AnalysisInputError,
+ );
+
+ const result = importManagedReconstructionEvidence(staleInput);
+ expect(result.ok).toBe(false);
+ if (!result.ok)
+ expect(result.error).toMatchObject({
+ _tag: "AnalysisInputError",
+ issues: [
{
- ...exampleMethod(),
- normalized_il_sha256: "6".repeat(64),
+ path: ["methods", 0],
+ reason: "invalid_value",
+ message: expect.stringMatching(/does not match/u),
},
],
- }),
- ).toThrow(/does not match/u);
+ });
});
it("rejects static Evidence with a token MVID but no module identity", () => {
@@ -146,7 +161,7 @@ describe("managed decompiler reconstruction import", () => {
},
],
}),
- ).toThrow(/does not match/u);
+ ).toThrow(AnalysisInputError);
});
});
@@ -182,7 +197,7 @@ describe("managed reconstruction input diagnostics", () => {
_tag: "AnalysisInputError",
issues: [
{
- path: [],
+ path: ["methods", 0, "reconstruction", "text_sha256"],
reason: "invalid_value",
message: expect.stringMatching(/text hash mismatch/u),
},
@@ -209,18 +224,9 @@ describe("managed reconstruction input diagnostics", () => {
});
expect(result.ok).toBe(false);
if (result.ok) return;
- expect(result.error).toMatchObject({ _tag: "AnalysisInputError" });
- const issues =
- result.error instanceof AnalysisInputError ? result.error.issues : [];
- expect(issues.length).toBeGreaterThan(0);
- expect(issues.every(({ path }) => path.length === 0)).toBe(true);
- expect(issues).toContainEqual(
- expect.objectContaining({
- reason: "invalid_value",
- message: expect.stringContaining(
- "nested value failed validation at artifact",
- ),
- }),
- );
+ expect(result.error).toMatchObject({
+ _tag: "EvidenceIntegrityError",
+ message: expect.stringContaining("artifact"),
+ });
});
});
diff --git a/src/application/managed/ManagedReconstructionService.ts b/src/application/managed/ManagedReconstructionService.ts
index 3ac088319..beb58d4bc 100644
--- a/src/application/managed/ManagedReconstructionService.ts
+++ b/src/application/managed/ManagedReconstructionService.ts
@@ -1,55 +1,48 @@
-import { z } from "zod";
-
-import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
import type { AnalysisError } from "../../domain/analysisErrorBase.js";
import { createEvidence, type Evidence } from "../../domain/evidence.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
import {
- importManagedReconstruction,
- managedReconstructionImportInputSchema,
- type ManagedReconstructionImportInput,
+ executeManagedReconstructionImport,
+ managedReconstructionImportRequestSchema,
+ resolveManagedReconstructionImport,
+ type ManagedReconstructionImportRequest,
type ManagedReconstructionImportResult,
+ type ResolvedManagedReconstructionImport,
} from "../../domain/managed/managedReconstruction.js";
import { err, ok, type Result } from "../../domain/result.js";
import { MANAGED_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
-import {
- requestInputError,
- workflowInputError,
-} from "../workflowInputError.js";
+import { requestInputError } from "../workflowInputError.js";
const OPERATION = "import_managed_reconstruction" as const;
-/** Authenticate and import managed decompiler reconstruction as Evidence. */
-export const importManagedReconstructionEvidence = (
+/** Validate the request envelope and authenticate its managed Evidence source once. */
+export const resolveManagedReconstructionEvidenceInput = (
rawInput: unknown,
-): Result<Evidence, AnalysisError> => {
- const parsed = managedReconstructionImportInputSchema.safeParse(rawInput);
+): Result<ResolvedManagedReconstructionImport, AnalysisError> => {
+ const parsed = managedReconstructionImportRequestSchema.safeParse(rawInput);
if (!parsed.success)
return err(requestInputError(OPERATION, parsed.error, rawInput));
- return importManagedReconstructionEvidenceValidated(parsed.data);
+ return resolveManagedReconstructionImport(parsed.data);
};
-/** Import reconstruction from input parsed by a trusted adapter. */
-export const importManagedReconstructionEvidenceValidated = (
- input: ManagedReconstructionImportInput,
+/** Execute from the source facts returned by the resolver. */
+export const importManagedReconstructionEvidenceResolved = (
+ resolved: ResolvedManagedReconstructionImport,
+): Result<Evidence, AnalysisError> => {
+ const result = executeManagedReconstructionImport(resolved);
+ return ok(createManagedReconstructionEvidence(resolved.request, result));
+};
+
+/** Validate the raw request envelope, then authenticate and import its source. */
+export const importManagedReconstructionEvidence = (
+ rawInput: unknown,
): Result<Evidence, AnalysisError> => {
- try {
- const result = importManagedReconstruction(input);
- return ok(createManagedReconstructionEvidence(input, result));
- } catch (cause: unknown) {
- return err(
- cause instanceof TypeError || cause instanceof z.ZodError
- ? workflowInputError(OPERATION, cause)
- : new AnalysisProtocolError(
- "Managed reconstruction import produced an invalid result",
- { cause },
- ),
- );
- }
+ const resolved = resolveManagedReconstructionEvidenceInput(rawInput);
+ if (!resolved.ok) return resolved;
+ return importManagedReconstructionEvidenceResolved(resolved.value);
};
const createManagedReconstructionEvidence = (
- input: ManagedReconstructionImportInput,
+ input: ManagedReconstructionImportRequest,
result: ManagedReconstructionImportResult,
): Evidence =>
createEvidence(
@@ -63,20 +56,18 @@ const createManagedReconstructionEvidence = (
predicateType: "rea.managed-reconstruction-import",
operation: OPERATION,
parameters: {
- static_members_evidence_id: input.static_members.evidence_id,
- decompiler: jsonValueSchema.parse(result.decompiler),
- method_locks: jsonValueSchema.parse(
- input.methods.map(
- ({ token, signature_sha256, normalized_il_sha256 }) => ({
- token,
- signature_sha256,
- normalized_il_sha256,
- }),
- ),
+ static_members_evidence_id: result.static_observation.evidence_id,
+ decompiler: result.decompiler,
+ method_locks: input.methods.map(
+ ({ token, signature_sha256, normalized_il_sha256 }) => ({
+ token,
+ signature_sha256,
+ normalized_il_sha256,
+ }),
),
- notes: jsonValueSchema.parse(input.notes),
+ notes: input.notes,
},
- result: jsonValueSchema.parse(result),
+ result,
rawResult: null,
confidence: "inferred",
authority: "analyst-inference",
diff --git a/src/contracts/managed/managedWorkflowToolContracts.ts b/src/contracts/managed/managedWorkflowToolContracts.ts
index d5c194396..9124b2c42 100644
--- a/src/contracts/managed/managedWorkflowToolContracts.ts
+++ b/src/contracts/managed/managedWorkflowToolContracts.ts
@@ -15,12 +15,6 @@ import {
import { toolContractMetadata } from "../toolEffects.js";
import { requireOutputSchema } from "../toolOutputSchemaPrimitives.js";
-/** Inline Evidence input for importing reconstruction. */
-export const managedReconstructionReferenceInputSchema =
- managedReconstructionImportInputSchema.extend({
- static_members: evidenceSchema,
- });
-
const managedApplicationGraphReferenceShape = z.strictObject({
managed_artifact: evidenceSchema.optional(),
managed_members: evidenceSchema.optional(),
@@ -121,7 +115,7 @@ export const MANAGED_WORKFLOW_TOOL_CONTRACTS = [
description:
"Import decompiler-produced managed reconstruction against authenticated inspect_managed_members Evidence. The workflow locks each method to artifact SHA-256, MVID, metadata token, signature hash, and the limited decoded-IL tuple hash, records the decompiler identity and options, and marks C# or pseudocode as analyst inference rather than canonical byte observation.",
kind: "application",
- inputSchema: managedReconstructionReferenceInputSchema,
+ inputSchema: managedReconstructionImportInputSchema,
outputSchema: reconstructionOutputSchema,
examples: [
{
diff --git a/src/domain/managed/managedApplicationGraph.ts b/src/domain/managed/managedApplicationGraph.ts
index de0147d1b..36c655790 100644
--- a/src/domain/managed/managedApplicationGraph.ts
+++ b/src/domain/managed/managedApplicationGraph.ts
@@ -1,6 +1,6 @@
import { z } from "zod";
-import { evidenceSchema, type Evidence } from "../evidence.js";
+import type { Evidence } from "../evidence.js";
import {
createJavaScriptApplicationGraph,
javascriptApplicationGraphSchema,
@@ -36,17 +36,21 @@ import {
} from "./managedApplicationGraphRelations.js";
import { digestSchema } from "../digests.js";
import { prefixedDigestSchema } from "../digests.js";
-import { parseManagedInspectionEvidence } from "./managedInspectionEvidence.js";
+import { readManagedInspectionEvidence } from "./managedInspectionEvidence.js";
+import { AnalysisInputError } from "../analysisErrorCore.js";
+import type { EvidenceIntegrityError } from "../evidenceErrors.js";
+import { analysisInputErrorFromIssues } from "../inputIssueProjection.js";
+import { err, ok, type Result } from "../result.js";
const evidenceIdSchema = prefixedDigestSchema("ev");
const textSchema = z.string().min(1);
/** Authenticated managed Evidence records projected into the application graph. */
-export const projectManagedApplicationGraphInputSchema = z
+const managedGraphRequestSchema = z
.strictObject({
- managed_artifact: evidenceSchema.optional(),
- managed_members: evidenceSchema.optional(),
- managed_native_boundaries: evidenceSchema.optional(),
+ managed_artifact: z.unknown().optional(),
+ managed_members: z.unknown().optional(),
+ managed_native_boundaries: z.unknown().optional(),
})
.superRefine((input, context) => {
if (
@@ -105,9 +109,6 @@ export const managedApplicationGraphResultSchema = z.strictObject({
limitations: z.array(textSchema),
});
-export type ProjectManagedApplicationGraphInput = z.infer<
- typeof projectManagedApplicationGraphInputSchema
->;
export type ManagedApplicationGraphResult = z.infer<
typeof managedApplicationGraphResultSchema
>;
@@ -138,14 +139,16 @@ export interface GraphBuildState {
readonly fieldNodes: Map<string, ApplicationNode>;
}
-/** Project authenticated managed Evidence records into the application graph. */
-export const projectManagedApplicationGraph = (
- input: ProjectManagedApplicationGraphInput,
+export interface ManagedGraphProjection {
+ readonly sources: ParsedManagedGraphInput;
+ readonly artifact: { readonly sha256: string; readonly path: string };
+}
+
+/** Build from authenticated sources whose shared identity has been established. */
+export const projectManagedGraph = (
+ request: ManagedGraphProjection,
): ManagedApplicationGraphResult => {
- const parsed = parseManagedInputs(input);
- const artifactIdentity = chooseArtifact(parsed);
- assertSameArtifact(parsed, artifactIdentity.sha256);
- assertConsistentModuleIdentity(parsed);
+ const { sources: parsed, artifact: artifactIdentity } = request;
const evidenceLinks = [
parsed.artifact?.evidence.evidence_id,
parsed.members?.evidence.evidence_id,
@@ -232,34 +235,71 @@ const countEdges = (
relation: ApplicationEdge["relation"],
): number => edges.filter((edge) => edge.relation === relation).length;
-const parseManagedInputs = (
- input: ProjectManagedApplicationGraphInput,
-): ParsedManagedGraphInput => ({
- artifact:
- input.managed_artifact === undefined
- ? null
- : parseManagedInspectionEvidence(
- input.managed_artifact,
+/** Authenticate each source once, then establish the shared projection identity. */
+export const readManagedGraphProjection = (
+ input: unknown,
+): Result<
+ ManagedGraphProjection,
+ AnalysisInputError | EvidenceIntegrityError
+> => {
+ const frame = managedGraphRequestSchema.safeParse(input);
+ if (!frame.success)
+ return err(
+ analysisInputErrorFromIssues(OPERATION, frame.error.issues, input, {
+ cause: frame.error,
+ }),
+ );
+ const { managed_artifact, managed_members, managed_native_boundaries } =
+ frame.data;
+ const artifact =
+ managed_artifact === undefined
+ ? ok(null)
+ : readManagedInspectionEvidence(
+ managed_artifact,
"inspect_managed_artifact",
managedArtifactInspectionSchema,
- ),
- members:
- input.managed_members === undefined
- ? null
- : parseManagedInspectionEvidence(
- input.managed_members,
+ { operation: OPERATION, path: ["managed_artifact"] },
+ );
+ if (!artifact.ok) return artifact;
+ const members =
+ managed_members === undefined
+ ? ok(null)
+ : readManagedInspectionEvidence(
+ managed_members,
"inspect_managed_members",
managedMemberInspectionSchema,
- ),
- boundaries:
- input.managed_native_boundaries === undefined
- ? null
- : parseManagedInspectionEvidence(
- input.managed_native_boundaries,
+ { operation: OPERATION, path: ["managed_members"] },
+ );
+ if (!members.ok) return members;
+ const boundaries =
+ managed_native_boundaries === undefined
+ ? ok(null)
+ : readManagedInspectionEvidence(
+ managed_native_boundaries,
"inspect_managed_native_boundaries",
managedNativeBoundaryInspectionSchema,
- ),
-});
+ { operation: OPERATION, path: ["managed_native_boundaries"] },
+ );
+ if (!boundaries.ok) return boundaries;
+ const sources = {
+ artifact: artifact.value,
+ members: members.value,
+ boundaries: boundaries.value,
+ };
+ const identity = chooseArtifact(sources);
+ const mismatch =
+ artifactMismatch(sources, identity.sha256) ??
+ moduleIdentityMismatch(sources);
+ if (mismatch !== null)
+ return err(
+ new AnalysisInputError(OPERATION, { userMessage: mismatch }, [
+ { path: [], reason: "invalid_value", message: mismatch },
+ ]),
+ );
+ return ok({ sources, artifact: identity });
+};
+
+const OPERATION = "project_managed_application_graph";
const chooseArtifact = (
parsed: ParsedManagedGraphInput,
@@ -269,29 +309,28 @@ const chooseArtifact = (
parsed.members?.result ??
parsed.boundaries?.result;
if (result === undefined)
- throw new TypeError("Managed graph projection requires managed Evidence");
+ throw new Error("Validated managed graph projection has no source");
return { sha256: result.artifact.sha256, path: result.artifact.path };
};
-const assertSameArtifact = (
+const artifactMismatch = (
parsed: ParsedManagedGraphInput,
sha256Value: string,
-): void => {
+): string | null => {
for (const result of [
parsed.artifact?.result,
parsed.members?.result,
parsed.boundaries?.result,
])
if (result !== undefined && result.artifact.sha256 !== sha256Value)
- throw new TypeError(
- "Managed graph projection inputs must describe the same artifact SHA-256",
- );
+ return "Managed graph projection inputs must describe the same artifact SHA-256";
+ return null;
};
/** Reject contradictory known module identities while leaving null fields unknown. */
-const assertConsistentModuleIdentity = (
+const moduleIdentityMismatch = (
parsed: ParsedManagedGraphInput,
-): void => {
+): string | null => {
const mvidClaims = [
parsed.artifact?.result.module?.mvid,
parsed.members?.result.module?.mvid,
@@ -302,9 +341,7 @@ const assertConsistentModuleIdentity = (
.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",
- );
+ return "Managed graph inputs report conflicting known module MVIDs or token scopes";
const modules = [
parsed.artifact?.result.module,
@@ -317,9 +354,7 @@ const assertConsistentModuleIdentity = (
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`,
- );
+ return `Managed graph inputs report conflicting module ${field} values`;
}
for (const field of ["enc_id", "enc_base_id"] as const) {
const values = new Set(
@@ -328,10 +363,9 @@ const assertConsistentModuleIdentity = (
.filter((value): value is string => value !== undefined),
);
if (values.size > 1)
- throw new TypeError(
- `Managed graph inputs report conflicting module ${field} values`,
- );
+ return `Managed graph inputs report conflicting module ${field} values`;
}
+ return null;
};
const projectionLimitations = (
diff --git a/src/domain/managed/managedInspectionEvidence.ts b/src/domain/managed/managedInspectionEvidence.ts
index 84b64ca25..4eb7837e8 100644
--- a/src/domain/managed/managedInspectionEvidence.ts
+++ b/src/domain/managed/managedInspectionEvidence.ts
@@ -1,4 +1,8 @@
-import { parseEvidence, type Evidence } from "../evidence.js";
+import type { Evidence } from "../evidence.js";
+import { AnalysisInputError } from "../analysisErrorCore.js";
+import { EvidenceIntegrityError } from "../evidenceErrors.js";
+import { readEvidence, readEvidencePayload } from "../evidenceValidation.js";
+import { err, ok, type Result } from "../result.js";
import type { z } from "zod";
/** Build-local metadata tokens join only under a known, matching module MVID. */
@@ -11,11 +15,11 @@ export const managedTokenScopesMatch = (
leftMvid.toLowerCase() === rightMvid.toLowerCase();
/**
- * Parse managed inspection Evidence and bind its artifact to any available subject.
+ * Authenticate 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 {
+export const readManagedInspectionEvidence = <
+ Payload extends {
readonly artifact: { readonly sha256: string };
readonly identity_scope?: {
readonly requires_artifact_sha256: string;
@@ -26,22 +30,46 @@ export const parseManagedInspectionEvidence = <
>(
rawEvidence: unknown,
operation: string,
- schema: z.ZodType<Result>,
-): { readonly evidence: Evidence; readonly result: Result } => {
- const evidence = parseEvidence(rawEvidence);
- if (evidence.operation !== operation)
- throw new TypeError(`Evidence operation is not ${operation}`);
- const result = schema.parse(evidence.normalized_result);
+ schema: z.ZodType<Payload>,
+ selection: {
+ readonly operation: string;
+ readonly path: readonly (string | number)[];
+ },
+): Result<
+ { readonly evidence: Evidence; readonly result: Payload },
+ AnalysisInputError | EvidenceIntegrityError
+> => {
+ const record = readEvidence(rawEvidence);
+ if (!record.ok) return record;
+ const evidence = record.value;
+ if (
+ evidence.operation !== operation ||
+ evidence.predicate_type !== "rea.analysis"
+ ) {
+ const message = `Expected rea.analysis ${operation} Evidence, received ${evidence.predicate_type} ${evidence.operation}`;
+ return err(
+ new AnalysisInputError(selection.operation, { userMessage: message }, [
+ { path: selection.path, reason: "invalid_value", message },
+ ]),
+ );
+ }
+ const payload = readEvidencePayload(schema, evidence.normalized_result);
+ if (!payload.ok) return payload;
+ const result = payload.value;
const artifactSha256 = result.artifact.sha256;
const subjectSha256 = evidence.subject?.digest.sha256;
if (subjectSha256 !== undefined && artifactSha256 !== subjectSha256)
- throw new TypeError(
- `Managed Evidence ${operation} (${evidence.evidence_id}) subject SHA-256 ${subjectSha256} does not match normalized artifact SHA-256 ${artifactSha256}`,
+ return err(
+ integrityFailure(
+ `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}`,
+ return err(
+ integrityFailure(
+ `Managed Evidence ${operation} (${evidence.evidence_id}) token scope SHA-256 ${scope.requires_artifact_sha256} does not match normalized artifact SHA-256 ${artifactSha256}`,
+ ),
);
const moduleMvid = result.module?.mvid ?? null;
const scopedMvid = scope?.requires_mvid;
@@ -49,8 +77,13 @@ export const parseManagedInspectionEvidence = <
scopedMvid !== undefined &&
scopedMvid?.toLowerCase() !== moduleMvid?.toLowerCase()
)
- throw new TypeError(
- `Managed Evidence ${operation} (${evidence.evidence_id}) token scope MVID ${String(scopedMvid)} does not match module MVID ${String(moduleMvid)}`,
+ return err(
+ integrityFailure(
+ `Managed Evidence ${operation} (${evidence.evidence_id}) token scope MVID ${String(scopedMvid)} does not match module MVID ${String(moduleMvid)}`,
+ ),
);
- return { evidence, result };
+ return ok({ evidence, result });
};
+
+const integrityFailure = (message: string): EvidenceIntegrityError =>
+ new EvidenceIntegrityError(message, { userMessage: message });
diff --git a/src/domain/managed/managedMemberComparison.ts b/src/domain/managed/managedMemberComparison.ts
index 9ffd5f260..1dbe8dff2 100644
--- a/src/domain/managed/managedMemberComparison.ts
+++ b/src/domain/managed/managedMemberComparison.ts
@@ -202,9 +202,6 @@ export const managedMemberComparisonResultSchema = z.strictObject({
limitations: z.array(boundedTextSchema),
});
-export type CompareManagedMembersInput = z.infer<
- typeof compareManagedMembersInputSchema
->;
export type ManagedMemberComparisonResult = z.infer<
typeof managedMemberComparisonResultSchema
>;
diff --git a/src/domain/managed/managedMemberComparisonMatch.ts b/src/domain/managed/managedMemberComparisonMatch.ts
index 1ad3d5e99..3690a3a56 100644
--- a/src/domain/managed/managedMemberComparisonMatch.ts
+++ b/src/domain/managed/managedMemberComparisonMatch.ts
@@ -3,7 +3,7 @@ import {
managedMemberInspectionSchema,
type ManagedMemberInspection,
} from "./managedArtifact.js";
-import { parseManagedInspectionEvidence } from "./managedInspectionEvidence.js";
+import { readManagedInspectionEvidence } from "./managedInspectionEvidence.js";
import type {
ManagedMemberComparisonResult,
ManagedMemberComparisonSide,
@@ -577,19 +577,13 @@ export const keyMembers = (
};
};
-export const parseManagedMemberEvidence = (
+export const readManagedMemberEvidence = (
evidence: unknown,
-): {
- readonly evidenceId: string;
- readonly result: ManagedMemberInspection;
-} => {
- const parsed = parseManagedInspectionEvidence(
+ path: "left" | "right",
+) =>
+ readManagedInspectionEvidence(
evidence,
"inspect_managed_members",
managedMemberInspectionSchema,
+ { operation: "compare_managed_members", path: [path] },
);
- return {
- evidenceId: parsed.evidence.evidence_id,
- result: parsed.result,
- };
-};
diff --git a/src/domain/managed/managedNativeVerification.ts b/src/domain/managed/managedNativeVerification.ts
index 85c968b13..4516aad5a 100644
--- a/src/domain/managed/managedNativeVerification.ts
+++ b/src/domain/managed/managedNativeVerification.ts
@@ -1,10 +1,4 @@
import { digestCanonicalValue } from "../canonicalDigest.js";
-import type { Evidence } from "../evidence.js";
-import {
- managedNativeBoundaryInspectionSchema,
- type ManagedNativeBoundaryInspection,
-} from "./managedArtifact.js";
-import { parseManagedInspectionEvidence } from "./managedInspectionEvidence.js";
import {
managedNativeVerificationResultSchema,
type ManagedNativeVerificationInput,
@@ -15,42 +9,35 @@ import {
collectNativeSymbols,
verifyPinvoke,
} from "./managedNativeVerificationMatch.js";
+import {
+ readManagedNativeVerificationSource,
+ type ManagedNativeVerificationSource,
+} from "./managedNativeVerificationSource.js";
-const parseManagedBoundary = (
- input: ManagedNativeVerificationInput,
-): {
- readonly evidence: Evidence;
- readonly result: ManagedNativeBoundaryInspection;
-} =>
- parseManagedInspectionEvidence(
- input.managed_boundaries,
- "inspect_managed_native_boundaries",
- managedNativeBoundaryInspectionSchema,
- );
-
-/** Verify managed P/Invoke declarations against authenticated native Evidence. */
-export const verifyManagedNativeBoundaries = (
- input: ManagedNativeVerificationInput,
+/** Pure verification over authenticated, parsed source facts. */
+export const verifyManagedNativeVerificationSource = (
+ source: ManagedNativeVerificationSource,
): ManagedNativeVerificationResult => {
- const { evidence: managedEvidence, result: managed } =
- parseManagedBoundary(input);
- const native = collectNativeSymbols(input.native_observations);
- const verifiedPinvokes = managed.pinvoke_imports.map((item) =>
- verifyPinvoke({
- item,
- managedEvidenceId: managedEvidence.evidence_id,
- native,
- }),
- );
- const pinvokeImports = verifiedPinvokes.map(
- ({ verification }) => verification,
- );
+ const { managedEvidence, managed, nativeObservations } = source;
+ const native = collectNativeSymbols(nativeObservations);
+ const pinvokeImports = managed.pinvoke_imports
+ .map((item) =>
+ verifyPinvoke({
+ item,
+ managedEvidenceId: managedEvidence.evidence_id,
+ native,
+ }),
+ )
+ .map(({ verification }) => verification);
const withoutId = buildVerificationResult({
managedEvidence,
managed,
native,
pinvokeImports,
- input,
+ nativeObservationCount: nativeObservations.length,
+ nativeEvidenceIds: nativeObservations.map(
+ ({ evidence }) => evidence.evidence_id,
+ ),
});
return managedNativeVerificationResultSchema.parse({
...withoutId,
@@ -60,3 +47,12 @@ export const verifyManagedNativeBoundaries = (
)}`,
});
};
+
+/** Raw domain API retained for CLI and existing callers. */
+export const verifyManagedNativeBoundaries = (
+ input: ManagedNativeVerificationInput,
+): ManagedNativeVerificationResult => {
+ const source = readManagedNativeVerificationSource(input);
+ if (!source.ok) throw source.error;
+ return verifyManagedNativeVerificationSource(source.value);
+};
diff --git a/src/domain/managed/managedNativeVerificationMatch.ts b/src/domain/managed/managedNativeVerificationMatch.ts
index 1b9754c40..a48dff102 100644
--- a/src/domain/managed/managedNativeVerificationMatch.ts
+++ b/src/domain/managed/managedNativeVerificationMatch.ts
@@ -1,16 +1,13 @@
import { basename } from "node:path";
-import { parseEvidence } from "../evidence.js";
import { digestCanonicalValue } from "../canonicalDigest.js";
-import { functionDossierSchema } from "../hopperValues.js";
-import { inspectMachoSchema } from "../native/nativeInspection.js";
+import type { Evidence } from "../evidence.js";
+import type { ManagedNativeObservationFacts } from "./managedNativeVerificationSource.js";
import type { ManagedNativeBoundaryInspection } from "./managedArtifact.js";
-import {
- pinvokeVerificationSchema,
- type ManagedNativeVerificationInput,
- type ManagedNativeVerificationResult,
- type NativeSymbol,
- type PinvokeVerification,
+import type {
+ ManagedNativeVerificationResult,
+ NativeSymbol,
+ PinvokeVerification,
} from "./managedNativeVerificationSchemas.js";
type PinvokeImport = ManagedNativeBoundaryInspection["pinvoke_imports"][number];
@@ -18,57 +15,8 @@ type VerifiedPinvoke = {
readonly verification: PinvokeVerification;
};
-const moduleName = (
- evidence: ReturnType<typeof parseEvidence>,
-): string | null => evidence.subject?.name ?? null;
-
-const modulePath = (
- evidence: ReturnType<typeof parseEvidence>,
-): string | null => evidence.subject?.local_path ?? null;
-
-const symbolsForEvidence = (
- evidence: ReturnType<typeof parseEvidence>,
-): {
- readonly supported: boolean;
- readonly symbols: readonly NativeSymbol[];
-} => {
- if (evidence.operation === "inspect_macho") {
- const result = inspectMachoSchema.parse(evidence.normalized_result);
- return {
- supported: true,
- symbols: result.exports.items.map((symbol) => ({
- evidence_id: evidence.evidence_id,
- operation: evidence.operation,
- name: symbol.name,
- address: symbol.address,
- module_name: moduleName(evidence),
- module_path: modulePath(evidence),
- source: "macho-export" as const,
- })),
- };
- }
- if (evidence.operation === "analyze_function") {
- const dossier = functionDossierSchema.parse(evidence.normalized_result);
- return {
- supported: true,
- symbols: [
- {
- evidence_id: evidence.evidence_id,
- operation: evidence.operation,
- name: dossier.procedure.name,
- address: dossier.procedure.address,
- module_name: moduleName(evidence),
- module_path: modulePath(evidence),
- source: "function-dossier" as const,
- },
- ],
- };
- }
- return { supported: false, symbols: [] };
-};
-
export const collectNativeSymbols = (
- observations: readonly ManagedNativeVerificationInput["native_observations"][number][],
+ observations: readonly ManagedNativeObservationFacts[],
): {
readonly symbols: readonly NativeSymbol[];
readonly accepted: number;
@@ -77,14 +25,12 @@ export const collectNativeSymbols = (
const symbols: NativeSymbol[] = [];
let accepted = 0;
let unsupported = 0;
- for (const raw of observations) {
- const evidence = parseEvidence(raw);
- const extracted = symbolsForEvidence(evidence);
- if (!extracted.supported) {
+ for (const observation of observations) {
+ if (!observation.supported) {
unsupported += 1;
} else {
accepted += 1;
- symbols.push(...extracted.symbols);
+ symbols.push(...observation.symbols);
}
}
return { symbols, accepted, unsupported };
@@ -261,7 +207,7 @@ const matchPinvoke = (
const pinvokeLimitations = (
match: PinvokeMatch,
managed: PinvokeImport,
-): readonly string[] => [
+): string[] => [
...(managed.import_scope_name === null ||
managed.import_scope_name.trim().length === 0
? ["Managed declaration does not name an import scope/module."]
@@ -296,6 +242,11 @@ interface VerifyPinvokeContext {
};
}
+type PinvokeVerificationContext = Pick<
+ PinvokeVerification,
+ "item_id" | "managed" | "evidence_links" | "limitations"
+>;
+
export const verifyPinvoke = ({
item,
managedEvidenceId,
@@ -314,26 +265,26 @@ export const verifyPinvoke = ({
};
const selection = matchPinvoke(item, native.symbols, native.accepted);
const limitations = pinvokeLimitations(selection.match, item);
- return {
- verification: pinvokeVerificationSchema.parse({
- item_id: `mnv_pinvoke_${digestCanonicalValue(
- {
- managedEvidenceId,
- token: item.token,
- importName: item.import_name,
- importScope: item.import_scope_name,
- candidates: selection.match.candidates,
- },
- "Managed/native verification",
- )}`,
- managed,
- ...selection.match,
- evidence_links: [
+ const context: PinvokeVerificationContext = {
+ item_id: `mnv_pinvoke_${digestCanonicalValue(
+ {
managedEvidenceId,
- ...new Set(selection.match.candidates.map(({ evidence_id: id }) => id)),
- ],
- limitations,
- }),
+ token: item.token,
+ importName: item.import_name,
+ importScope: item.import_scope_name,
+ candidates: selection.match.candidates,
+ },
+ "Managed/native verification",
+ )}`,
+ managed,
+ evidence_links: [
+ managedEvidenceId,
+ ...new Set(selection.match.candidates.map(({ evidence_id: id }) => id)),
+ ],
+ limitations,
+ };
+ return {
+ verification: { ...context, ...selection.match },
};
};
@@ -350,7 +301,7 @@ const countStatuses = (
});
interface VerificationResultInput {
- readonly managedEvidence: ReturnType<typeof parseEvidence>;
+ readonly managedEvidence: Evidence;
readonly managed: ManagedNativeBoundaryInspection;
readonly native: {
readonly symbols: readonly NativeSymbol[];
@@ -358,7 +309,8 @@ interface VerificationResultInput {
readonly unsupported: number;
};
readonly pinvokeImports: readonly PinvokeVerification[];
- readonly input: ManagedNativeVerificationInput;
+ readonly nativeObservationCount: number;
+ readonly nativeEvidenceIds: readonly string[];
}
export const buildVerificationResult = ({
@@ -366,7 +318,8 @@ export const buildVerificationResult = ({
managed,
native,
pinvokeImports,
- input,
+ nativeObservationCount,
+ nativeEvidenceIds,
}: VerificationResultInput): Omit<
ManagedNativeVerificationResult,
"verification_id"
@@ -398,7 +351,7 @@ export const buildVerificationResult = ({
coverage_state: managed.coverage.state,
},
native_observations: {
- total: input.native_observations.length,
+ total: nativeObservationCount,
accepted: native.accepted,
unsupported: native.unsupported,
symbols: native.symbols.length,
@@ -414,10 +367,7 @@ export const buildVerificationResult = ({
"Managed metadata tokens and RVAs are not translated to native provider addresses by this workflow; C++/CLI, ReadyToRun, and native-body mappings require explicit provider-supported bridge evidence.",
},
coverage,
- evidence_links: [
- managedEvidence.evidence_id,
- ...input.native_observations.map(({ evidence_id: id }) => id),
- ],
+ evidence_links: [managedEvidence.evidence_id, ...nativeEvidenceIds],
limitations: [
"P/Invoke verification checks declared import names against supplied native export or function-name Evidence only.",
"A matching native symbol verifies that a candidate export/function was observed; it does not prove CLR binding, marshaling behavior, call reachability, or runtime loading.",
diff --git a/src/domain/managed/managedNativeVerificationSource.ts b/src/domain/managed/managedNativeVerificationSource.ts
new file mode 100644
index 000000000..b47d55f23
--- /dev/null
+++ b/src/domain/managed/managedNativeVerificationSource.ts
@@ -0,0 +1,144 @@
+import { z } from "zod";
+
+import type { Evidence } from "../evidence.js";
+import { AnalysisInputError } from "../analysisErrorCore.js";
+import type { AnalysisError } from "../analysisErrorBase.js";
+import { EvidenceIntegrityError } from "../evidenceErrors.js";
+import { analysisInputErrorFromIssues } from "../inputIssueProjection.js";
+import { readEvidence, readEvidencePayload } from "../evidenceValidation.js";
+import { err, ok, type Result } from "../result.js";
+import { functionDossierSchema } from "../hopperValues.js";
+import { inspectMachoSchema } from "../native/nativeInspection.js";
+import {
+ managedNativeBoundaryInspectionSchema,
+ type ManagedNativeBoundaryInspection,
+} from "./managedArtifact.js";
+import { readManagedInspectionEvidence } from "./managedInspectionEvidence.js";
+import type { NativeSymbol } from "./managedNativeVerificationSchemas.js";
+
+const OPERATION = "verify_managed_native_boundaries" as const;
+const MANAGED_OPERATION = "inspect_managed_native_boundaries" as const;
+
+const requestFrameSchema = z.strictObject({
+ managed_boundaries: z.unknown(),
+ native_observations: z.array(z.unknown()).min(1),
+});
+
+export interface ManagedNativeVerificationSource {
+ readonly managedEvidence: Evidence;
+ readonly managed: ManagedNativeBoundaryInspection;
+ readonly nativeObservations: readonly ManagedNativeObservationFacts[];
+}
+
+export interface ManagedNativeObservationFacts {
+ readonly evidence: Evidence;
+ readonly symbols: readonly NativeSymbol[];
+ readonly supported: boolean;
+}
+
+const inputFailure = (
+ path: readonly (string | number)[],
+ message: string,
+): AnalysisInputError =>
+ new AnalysisInputError(OPERATION, { userMessage: message }, [
+ { path, reason: "invalid_value", message },
+ ]);
+
+const readNativeObservation = (
+ raw: unknown,
+): Result<
+ ManagedNativeVerificationSource["nativeObservations"][number],
+ AnalysisInputError | EvidenceIntegrityError
+> => {
+ const read = readEvidence(raw);
+ if (!read.ok) return read;
+ const evidence = read.value;
+ if (evidence.operation === "inspect_macho") {
+ const payload = readEvidencePayload(
+ inspectMachoSchema,
+ evidence.normalized_result,
+ );
+ if (!payload.ok) return payload;
+ return ok({
+ evidence,
+ supported: true,
+ symbols: payload.value.exports.items.map((symbol) => ({
+ evidence_id: evidence.evidence_id,
+ operation: evidence.operation,
+ name: symbol.name,
+ address: symbol.address,
+ module_name: evidence.subject?.name ?? null,
+ module_path: evidence.subject?.local_path ?? null,
+ source: "macho-export" as const,
+ })),
+ });
+ }
+ if (evidence.operation === "analyze_function") {
+ const payload = readEvidencePayload(
+ functionDossierSchema,
+ evidence.normalized_result,
+ );
+ if (!payload.ok) return payload;
+ return ok({
+ evidence,
+ supported: true,
+ symbols: [
+ {
+ evidence_id: evidence.evidence_id,
+ operation: evidence.operation,
+ name: payload.value.procedure.name,
+ address: payload.value.procedure.address,
+ module_name: evidence.subject?.name ?? null,
+ module_path: evidence.subject?.local_path ?? null,
+ source: "function-dossier" as const,
+ },
+ ],
+ });
+ }
+ return ok({ evidence, supported: false, symbols: [] });
+};
+
+/** Authenticate and parse source Evidence once, retaining it for session recording. */
+export const readManagedNativeVerificationSource = (
+ rawInput: unknown,
+): Result<ManagedNativeVerificationSource, AnalysisError> => {
+ const frame = requestFrameSchema.safeParse(rawInput);
+ if (!frame.success)
+ return err(
+ analysisInputErrorFromIssues(OPERATION, frame.error.issues, rawInput, {
+ cause: frame.error,
+ }),
+ );
+ const managed = readManagedInspectionEvidence(
+ frame.data.managed_boundaries,
+ MANAGED_OPERATION,
+ managedNativeBoundaryInspectionSchema,
+ { operation: OPERATION, path: ["managed_boundaries"] },
+ );
+ if (!managed.ok) return managed;
+
+ const nativeObservations: ManagedNativeVerificationSource["nativeObservations"][number][] =
+ [];
+ const ids = new Set([managed.value.evidence.evidence_id]);
+ for (const [index, raw] of frame.data.native_observations.entries()) {
+ const native = readNativeObservation(raw);
+ if (!native.ok) return native;
+ const id = native.value.evidence.evidence_id;
+ if (ids.has(id))
+ return err(
+ inputFailure(
+ ["native_observations", index],
+ id === managed.value.evidence.evidence_id
+ ? "Native observation Evidence must be distinct from managed boundary Evidence"
+ : "Native observation Evidence IDs must be unique",
+ ),
+ );
+ ids.add(id);
+ nativeObservations.push(native.value);
+ }
+ return ok({
+ managedEvidence: managed.value.evidence,
+ managed: managed.value.result,
+ nativeObservations,
+ });
+};
diff --git a/src/domain/managed/managedReconstruction.ts b/src/domain/managed/managedReconstruction.ts
index 5a3a0a307..35690625e 100644
--- a/src/domain/managed/managedReconstruction.ts
+++ b/src/domain/managed/managedReconstruction.ts
@@ -11,7 +11,10 @@ import {
} from "./managedArtifact.js";
import { digestCanonicalValue } from "../canonicalDigest.js";
import { digestSchema, prefixedDigestSchema } from "../digests.js";
-import { parseManagedInspectionEvidence } from "./managedInspectionEvidence.js";
+import { readManagedInspectionEvidence } from "./managedInspectionEvidence.js";
+import { AnalysisInputError } from "../analysisErrorCore.js";
+import { EvidenceIntegrityError } from "../evidenceErrors.js";
+import { err, ok, type Result } from "../result.js";
const evidenceIdSchema = prefixedDigestSchema("ev");
const textSchema = z.string().min(1);
@@ -43,11 +46,22 @@ type ManagedReconstructionMethodInput = z.infer<
typeof managedReconstructionMethodInputSchema
>;
-export const managedReconstructionImportInputSchema = z.strictObject({
- static_members: evidenceSchema,
+const managedReconstructionImportRequestShape = {
+ static_members: z.unknown(),
decompiler: decompilerSchema,
methods: z.array(managedReconstructionMethodInputSchema).min(1),
notes: z.array(textSchema).default([]),
+};
+
+/** Request envelope parsed before interpreting the nested Evidence source. */
+export const managedReconstructionImportRequestSchema = z.strictObject(
+ managedReconstructionImportRequestShape,
+);
+
+/** Public reconstruction request with the complete source Evidence contract. */
+export const managedReconstructionImportInputSchema = z.strictObject({
+ ...managedReconstructionImportRequestShape,
+ static_members: evidenceSchema,
});
const importedMethodSchema = z.strictObject({
@@ -109,6 +123,9 @@ export const managedReconstructionImportResultSchema = z.strictObject({
export type ManagedReconstructionImportInput = z.infer<
typeof managedReconstructionImportInputSchema
>;
+export type ManagedReconstructionImportRequest = z.infer<
+ typeof managedReconstructionImportRequestSchema
+>;
export type ManagedReconstructionImportResult = z.infer<
typeof managedReconstructionImportResultSchema
>;
@@ -138,19 +155,6 @@ const findObservedMethod = (
item.body.normalized_il_sha256 === candidate.normalized_il_sha256,
);
-const verifyTextSha256 = (
- candidate: ManagedReconstructionMethodInput,
- textSha256: string,
-): void => {
- if (
- candidate.reconstruction.text_sha256 !== undefined &&
- candidate.reconstruction.text_sha256 !== textSha256
- )
- throw new TypeError(
- `Reconstruction text hash mismatch for ${candidate.token}`,
- );
-};
-
const buildImportedMethod = (
observed: Member,
candidate: ManagedReconstructionMethodInput,
@@ -233,7 +237,7 @@ const RECONSTRUCTION_LIMITATIONS = [
];
const buildReconstructionWithoutId = (
- input: ManagedReconstructionImportInput,
+ input: ManagedReconstructionImportRequest,
staticEvidence: Evidence,
members: ManagedMemberInspection,
methods: readonly ImportedMethod[],
@@ -249,31 +253,74 @@ const buildReconstructionWithoutId = (
limitations: RECONSTRUCTION_LIMITATIONS,
});
-/** Authenticate decompiler reconstruction against static IL Evidence. */
-export const importManagedReconstruction = (
- input: ManagedReconstructionImportInput,
-): ManagedReconstructionImportResult => {
- const { evidence: staticEvidence, result: members } =
- parseManagedInspectionEvidence(
- input.static_members,
- "inspect_managed_members",
- managedMemberInspectionSchema,
- );
- const methods = input.methods.map((candidate) => {
- const observed = findObservedMethod(members, candidate);
- if (observed === undefined)
- throw new TypeError(
- `Reconstruction method lock ${candidate.token} does not match a static managed member observation`,
+export interface ResolvedManagedReconstructionImport {
+ readonly request: ManagedReconstructionImportRequest;
+ readonly staticEvidence: Evidence;
+ readonly members: ManagedMemberInspection;
+ readonly methods: readonly ImportedMethod[];
+}
+
+/** Parse the managed member facts once, then validate every caller lock at its request path. */
+export const resolveManagedReconstructionImport = (
+ input: ManagedReconstructionImportRequest,
+): Result<
+ ResolvedManagedReconstructionImport,
+ AnalysisInputError | EvidenceIntegrityError
+> => {
+ const source = readManagedInspectionEvidence(
+ input.static_members,
+ "inspect_managed_members",
+ managedMemberInspectionSchema,
+ { operation: "import_managed_reconstruction", path: ["static_members"] },
+ );
+ if (!source.ok) return source;
+
+ const methods: ImportedMethod[] = [];
+ for (const [index, candidate] of input.methods.entries()) {
+ const observed = findObservedMethod(source.value.result, candidate);
+ if (observed === undefined) {
+ const message = `Reconstruction method lock ${candidate.token} does not match a static managed member observation`;
+ return err(
+ new AnalysisInputError("import_managed_reconstruction", {}, [
+ { path: ["methods", index], reason: "invalid_value", message },
+ ]),
);
+ }
const textSha256 = sha256Text(candidate.reconstruction.text);
- verifyTextSha256(candidate, textSha256);
- return buildImportedMethod(observed, candidate, textSha256);
+ if (
+ candidate.reconstruction.text_sha256 !== undefined &&
+ candidate.reconstruction.text_sha256 !== textSha256
+ ) {
+ const message = `Reconstruction text hash mismatch for ${candidate.token}`;
+ return err(
+ new AnalysisInputError("import_managed_reconstruction", {}, [
+ {
+ path: ["methods", index, "reconstruction", "text_sha256"],
+ reason: "invalid_value",
+ message,
+ },
+ ]),
+ );
+ }
+ methods.push(buildImportedMethod(observed, candidate, textSha256));
+ }
+ return ok({
+ request: input,
+ staticEvidence: source.value.evidence,
+ members: source.value.result,
+ methods,
});
+};
+
+/** Build the import solely from facts authenticated and validated by the resolver. */
+export const executeManagedReconstructionImport = (
+ resolved: ResolvedManagedReconstructionImport,
+): ManagedReconstructionImportResult => {
const withoutId = buildReconstructionWithoutId(
- input,
- staticEvidence,
- members,
- methods,
+ resolved.request,
+ resolved.staticEvidence,
+ resolved.members,
+ resolved.methods,
);
return managedReconstructionImportResultSchema.parse({
...withoutId,
@@ -283,3 +330,12 @@ export const importManagedReconstruction = (
)}`,
});
};
+
+/** Authenticate decompiler reconstruction against static IL Evidence. */
+export const importManagedReconstruction = (
+ input: ManagedReconstructionImportInput,
+): ManagedReconstructionImportResult => {
+ const resolved = resolveManagedReconstructionImport(input);
+ if (!resolved.ok) throw resolved.error;
+ return executeManagedReconstructionImport(resolved.value);
+};
diff --git a/src/evaluation/AgentEvaluationFixtures.ts b/src/evaluation/AgentEvaluationFixtures.ts
index 83b22db41..2a1e65bfe 100644
--- a/src/evaluation/AgentEvaluationFixtures.ts
+++ b/src/evaluation/AgentEvaluationFixtures.ts
@@ -19,7 +19,7 @@ import {
} from "../domain/managed/managedArtifact.js";
import {
managedTokenScopesMatch,
- parseManagedInspectionEvidence,
+ readManagedInspectionEvidence,
} from "../domain/managed/managedInspectionEvidence.js";
import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
import type {
@@ -416,11 +416,14 @@ const parserClaims = (
};
const managedMembers = ({ evidence }: FixtureClaimContext) => {
- const { result } = parseManagedInspectionEvidence(
+ const parsed = readManagedInspectionEvidence(
evidence,
"inspect_managed_members",
managedMemberInspectionSchema,
+ { operation: "agent_evaluation", path: ["evidence"] },
);
+ if (!parsed.ok) throw parsed.error;
+ const { result } = parsed.value;
if (
result.coverage.state !== "complete" ||
result.metadata.status !== "complete" ||
@@ -484,11 +487,14 @@ const managedClaims = (
evidence.subject.digest.sha256 === source.subject.sha256,
);
if (artifacts.length !== 1) return undefined;
- const { result: artifact } = parseManagedInspectionEvidence(
+ const parsedArtifact = readManagedInspectionEvidence(
artifacts[0],
"inspect_managed_artifact",
managedArtifactInspectionSchema,
+ { operation: "agent_evaluation", path: ["deliveredEvidence"] },
);
+ if (!parsedArtifact.ok) throw parsedArtifact.error;
+ const { result: artifact } = parsedArtifact.value;
if (
artifact.coverage.state !== "complete" ||
artifact.metadata.status !== "complete" ||
diff --git a/src/server/registerManagedWorkflowTools/compareManagedMembers.ts b/src/server/registerManagedWorkflowTools/compareManagedMembers.ts
index 90251146b..70370cc43 100644
--- a/src/server/registerManagedWorkflowTools/compareManagedMembers.ts
+++ b/src/server/registerManagedWorkflowTools/compareManagedMembers.ts
@@ -3,12 +3,10 @@ import type { EvidenceMcpServer } from "../EvidenceMcpServer.js";
import { runAdmittedToolOperation } from "../admittedToolOperation.js";
import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { compareManagedMembersEvidenceValidated } from "../../application/managed/ManagedMemberComparisonService.js";
-import { managedMemberComparisonResultSchema } from "../../domain/managed/managedMemberComparison.js";
+import { executeManagedMemberComparison } from "../../application/managed/ManagedMemberComparisonService.js";
import { logToolExecution } from "../toolLogging.js";
import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
import { managedWorkflowContract } from "./contract.js";
-import { resolveManagedEvidence } from "./evidence.js";
import type { ManagedWorkflowToolRegistration } from "./types.js";
const compareContract = managedWorkflowContract("compare_managed_members");
@@ -28,41 +26,23 @@ export const registerCompareManagedMembers = (
compareContract.name,
context.mcpReq.signal,
async () => {
- const leftResolved = resolveManagedEvidence(input.left);
- const rightResolved = resolveManagedEvidence(input.right);
- if (!leftResolved.ok)
- return server.delivery.toCallToolResult(
- leftResolved,
- compareContract,
- );
- if (!rightResolved.ok)
- return server.delivery.toCallToolResult(
- rightResolved,
- compareContract,
- );
- const left = leftResolved.value;
- const right = rightResolved.value;
- const parsed = { left, right };
const result = await logToolExecution(
options.logger,
compareContract.name,
- () =>
- Promise.resolve(compareManagedMembersEvidenceValidated(parsed)),
+ () => Promise.resolve(executeManagedMemberComparison(input)),
);
if (!result.ok)
return server.delivery.toCallToolResult(result, compareContract);
const recorded = recordSessionEvidenceSources(
options.recordEvidence,
- [parsed.left, parsed.right],
+ result.value.sources,
);
if (!recorded.ok)
return server.delivery.toCallToolResult(recorded, compareContract);
- const comparison = managedMemberComparisonResultSchema.parse(
- result.value.normalized_result,
- );
- const unknown = comparison.summary.unknown > 0;
+ const comparison = result.value.summary;
+ const unknown = comparison.unknown > 0;
const unknownInput = unknown
- ? workflowUnknownInput(result.value.evidence_id, {
+ ? workflowUnknownInput(result.value.evidence.evidence_id, {
question:
"Which managed members remain unmatched or ambiguous across these versions?",
severity: "medium",
@@ -82,15 +62,15 @@ export const registerCompareManagedMembers = (
: undefined;
const output =
unknownInput === undefined
- ? options.recordEvidence?.(result.value)
+ ? options.recordEvidence?.(result.value.evidence)
: unknownInput.ok
? options.recordEvidenceWithUnknown?.(
- result.value,
+ result.value.evidence,
unknownInput.value,
)
: unknownInput;
return server.delivery.toEvidenceToolResult(
- result.value,
+ result.value.evidence,
compareContract,
output,
);
diff --git a/src/server/registerManagedWorkflowTools/evidence.ts b/src/server/registerManagedWorkflowTools/evidence.ts
deleted file mode 100644
index 761f345eb..000000000
--- a/src/server/registerManagedWorkflowTools/evidence.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import type { Evidence } from "../../domain/evidence.js";
-import { parseEvidence } from "../../domain/evidence.js";
-import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
-import type { Result } from "../../domain/result.js";
-import { err, ok } from "../../domain/result.js";
-
-/** Authenticate one caller-supplied record and preserve Evidence errors. */
-const parseEvidenceRecord = (
- rawEvidence: Evidence,
-): Result<Evidence, EvidenceIntegrityError> => {
- try {
- return ok(parseEvidence(rawEvidence));
- } catch (cause: unknown) {
- return err(
- new EvidenceIntegrityError(
- cause instanceof Error ? cause.message : "Invalid Evidence",
- ),
- );
- }
-};
-
-const parseEvidenceRecords = (
- rawEvidence: readonly Evidence[],
-): Result<Evidence[], EvidenceIntegrityError> => {
- const evidence: Evidence[] = [];
- for (const rawRecord of rawEvidence) {
- const record = parseEvidenceRecord(rawRecord);
- if (!record.ok) return err(record.error);
- evidence.push(record.value);
- }
- return ok(evidence);
-};
-
-const resolveExpectedEvidence = (
- rawEvidence: Evidence,
- expectedOperation: string,
-): Result<Evidence, EvidenceIntegrityError> => {
- const evidence = parseEvidenceRecord(rawEvidence);
- if (!evidence.ok) return evidence;
- if (
- evidence.value.operation !== expectedOperation ||
- evidence.value.predicate_type !== "rea.analysis"
- )
- return err(
- new EvidenceIntegrityError(
- `Expected ${expectedOperation} Evidence, received ${evidence.value.operation}`,
- ),
- );
- return evidence;
-};
-
-export const resolveManagedEvidence = (
- evidence: Evidence,
-): Result<Evidence, EvidenceIntegrityError> =>
- resolveExpectedEvidence(evidence, "inspect_managed_members");
-
-export const resolveManagedArtifactEvidence = (
- evidence: Evidence,
-): Result<Evidence, EvidenceIntegrityError> =>
- resolveExpectedEvidence(evidence, "inspect_managed_artifact");
-
-export const resolveManagedBoundaryEvidence = (
- evidence: Evidence,
-): Result<Evidence, EvidenceIntegrityError> =>
- resolveExpectedEvidence(evidence, "inspect_managed_native_boundaries");
-
-/**
- * Authenticate native observations without an operation allowlist: the domain
- * counts authentic operations it cannot read symbols from as unsupported.
- */
-export const resolveNativeEvidence = (
- evidence: readonly Evidence[],
-): Result<Evidence[], EvidenceIntegrityError> => parseEvidenceRecords(evidence);
-
-export const sourceEvidence = (input: {
- readonly managed_artifact?: Evidence | undefined;
- readonly managed_members?: Evidence | undefined;
- readonly managed_native_boundaries?: Evidence | undefined;
-}): Evidence[] =>
- [
- input.managed_artifact,
- input.managed_members,
- input.managed_native_boundaries,
- ].filter((evidence): evidence is Evidence => evidence !== undefined);
diff --git a/src/server/registerManagedWorkflowTools/importManagedReconstruction.ts b/src/server/registerManagedWorkflowTools/importManagedReconstruction.ts
index 48a694ccc..150277d2e 100644
--- a/src/server/registerManagedWorkflowTools/importManagedReconstruction.ts
+++ b/src/server/registerManagedWorkflowTools/importManagedReconstruction.ts
@@ -1,11 +1,13 @@
import type { EvidenceMcpServer } from "../EvidenceMcpServer.js";
import { runAdmittedToolOperation } from "../admittedToolOperation.js";
-import { importManagedReconstructionEvidenceValidated } from "../../application/managed/ManagedReconstructionService.js";
+import {
+ importManagedReconstructionEvidenceResolved,
+ resolveManagedReconstructionEvidenceInput,
+} from "../../application/managed/ManagedReconstructionService.js";
import { logToolExecution } from "../toolLogging.js";
import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
import { managedWorkflowContract } from "./contract.js";
-import { resolveManagedEvidence } from "./evidence.js";
import type { ManagedWorkflowToolRegistration } from "./types.js";
const reconstructionContract = managedWorkflowContract(
@@ -27,20 +29,18 @@ export const registerImportManagedReconstruction = (
reconstructionContract.name,
context.mcpReq.signal,
async () => {
- const resolved = resolveManagedEvidence(input.static_members);
+ const resolved = resolveManagedReconstructionEvidenceInput(input);
if (!resolved.ok)
return server.delivery.toCallToolResult(
resolved,
reconstructionContract,
);
- const staticMembers = resolved.value;
- const parsed = { ...input, static_members: staticMembers };
const result = await logToolExecution(
options.logger,
reconstructionContract.name,
() =>
Promise.resolve(
- importManagedReconstructionEvidenceValidated(parsed),
+ importManagedReconstructionEvidenceResolved(resolved.value),
),
);
if (!result.ok)
@@ -49,7 +49,7 @@ export const registerImportManagedReconstruction = (
reconstructionContract,
);
const recordedSource = options.recordEvidence?.(
- parsed.static_members,
+ resolved.value.staticEvidence,
);
if (recordedSource !== undefined && !recordedSource.ok)
return server.delivery.toCallToolResult(
diff --git a/src/server/registerManagedWorkflowTools/projectManagedApplicationGraph.ts b/src/server/registerManagedWorkflowTools/projectManagedApplicationGraph.ts
index 478f08d87..a34d3d9bb 100644
--- a/src/server/registerManagedWorkflowTools/projectManagedApplicationGraph.ts
+++ b/src/server/registerManagedWorkflowTools/projectManagedApplicationGraph.ts
@@ -2,16 +2,13 @@ import type { EvidenceMcpServer } from "../EvidenceMcpServer.js";
import { runAdmittedToolOperation } from "../admittedToolOperation.js";
import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { projectManagedApplicationGraphEvidence } from "../../application/managed/ManagedApplicationGraphService.js";
+import { projectManagedGraphEvidence } from "../../application/managed/ManagedApplicationGraphService.js";
+import { readManagedGraphProjection } from "../../domain/managed/managedApplicationGraph.js";
+import type { Evidence } from "../../domain/evidence.js";
+import { ok } from "../../domain/result.js";
import { logToolExecution } from "../toolLogging.js";
import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
import { managedWorkflowContract } from "./contract.js";
-import {
- resolveManagedArtifactEvidence,
- resolveManagedBoundaryEvidence,
- resolveManagedEvidence,
- sourceEvidence,
-} from "./evidence.js";
import type { ManagedWorkflowToolRegistration } from "./types.js";
const graphContract = managedWorkflowContract(
@@ -33,49 +30,24 @@ export const registerProjectManagedApplicationGraph = (
graphContract.name,
context.mcpReq.signal,
async () => {
- const managedArtifact =
- input.managed_artifact === undefined
- ? undefined
- : resolveManagedArtifactEvidence(input.managed_artifact);
- if (managedArtifact !== undefined && !managedArtifact.ok)
- return server.delivery.toCallToolResult(
- managedArtifact,
- graphContract,
- );
- const managedMembers =
- input.managed_members === undefined
- ? undefined
- : resolveManagedEvidence(input.managed_members);
- if (managedMembers !== undefined && !managedMembers.ok)
- return server.delivery.toCallToolResult(
- managedMembers,
- graphContract,
- );
- const managedBoundaries =
- input.managed_native_boundaries === undefined
- ? undefined
- : resolveManagedBoundaryEvidence(input.managed_native_boundaries);
- if (managedBoundaries !== undefined && !managedBoundaries.ok)
- return server.delivery.toCallToolResult(
- managedBoundaries,
- graphContract,
- );
- const parsed = {
- managed_artifact: managedArtifact?.value,
- managed_members: managedMembers?.value,
- managed_native_boundaries: managedBoundaries?.value,
- };
+ const request = readManagedGraphProjection(input);
+ if (!request.ok)
+ return server.delivery.toCallToolResult(request, graphContract);
const result = await logToolExecution(
options.logger,
graphContract.name,
() =>
- Promise.resolve(projectManagedApplicationGraphEvidence(parsed)),
+ Promise.resolve(ok(projectManagedGraphEvidence(request.value))),
);
if (!result.ok)
return server.delivery.toCallToolResult(result, graphContract);
const recordedSources = recordSessionEvidenceSources(
options.recordEvidence,
- sourceEvidence(parsed),
+ [
+ request.value.sources.artifact?.evidence,
+ request.value.sources.members?.evidence,
+ request.value.sources.boundaries?.evidence,
+ ].filter((source): source is Evidence => source !== undefined),
);
if (!recordedSources.ok)
return server.delivery.toCallToolResult(
diff --git a/src/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.ts b/src/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.ts
index c51f5f0a0..ceee07073 100644
--- a/src/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.ts
+++ b/src/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.ts
@@ -3,15 +3,10 @@ import type { EvidenceMcpServer } from "../EvidenceMcpServer.js";
import { runAdmittedToolOperation } from "../admittedToolOperation.js";
import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { verifyManagedNativeBoundariesEvidence } from "../../application/managed/ManagedNativeVerificationService.js";
-import { managedNativeVerificationResultSchema } from "../../domain/managed/managedNativeVerificationSchemas.js";
+import { executeManagedNativeBoundaries } from "../../application/managed/ManagedNativeVerificationService.js";
import { logToolExecution } from "../toolLogging.js";
import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
import { managedWorkflowContract } from "./contract.js";
-import {
- resolveManagedBoundaryEvidence,
- resolveNativeEvidence,
-} from "./evidence.js";
import type { ManagedWorkflowToolRegistration } from "./types.js";
const nativeVerificationContract = managedWorkflowContract(
@@ -33,57 +28,33 @@ export const registerVerifyManagedNativeBoundaries = (
nativeVerificationContract.name,
context.mcpReq.signal,
async () => {
- const managedBoundaries = resolveManagedBoundaryEvidence(
- input.managed_boundaries,
- );
- if (!managedBoundaries.ok)
- return server.delivery.toCallToolResult(
- managedBoundaries,
- nativeVerificationContract,
- );
- const nativeObservations = resolveNativeEvidence(
- input.native_observations,
- );
- if (!nativeObservations.ok)
- return server.delivery.toCallToolResult(
- nativeObservations,
- nativeVerificationContract,
- );
- const managedBoundary = managedBoundaries.value;
- const parsed = {
- ...input,
- managed_boundaries: managedBoundary,
- native_observations: nativeObservations.value,
- };
const result = await logToolExecution(
options.logger,
nativeVerificationContract.name,
- () =>
- Promise.resolve(verifyManagedNativeBoundariesEvidence(parsed)),
+ () => Promise.resolve(executeManagedNativeBoundaries(input)),
);
if (!result.ok)
return server.delivery.toCallToolResult(
result,
nativeVerificationContract,
);
+ const execution = result.value;
const recordedSources = recordSessionEvidenceSources(
options.recordEvidence,
- [parsed.managed_boundaries, ...parsed.native_observations],
+ execution.sourceEvidence,
);
if (!recordedSources.ok)
return server.delivery.toCallToolResult(
recordedSources,
nativeVerificationContract,
);
- const verification = managedNativeVerificationResultSchema.parse(
- result.value.normalized_result,
- );
+ const summary = execution.summary;
const unknown =
- verification.summary.unresolved > 0 ||
- verification.summary.contradicted > 0 ||
- verification.summary.native_body_unresolved > 0;
+ summary.unresolved > 0 ||
+ summary.contradicted > 0 ||
+ summary.native_body_unresolved > 0;
const unknownInput = unknown
- ? workflowUnknownInput(result.value.evidence_id, {
+ ? workflowUnknownInput(execution.evidence.evidence_id, {
question:
"Which managed/native boundaries remain unresolved or contradicted by the supplied native Evidence?",
severity: "medium",
@@ -108,15 +79,15 @@ export const registerVerifyManagedNativeBoundaries = (
: undefined;
const output =
unknownInput === undefined
- ? options.recordEvidence?.(result.value)
+ ? options.recordEvidence?.(execution.evidence)
: unknownInput.ok
? options.recordEvidenceWithUnknown?.(
- result.value,
+ execution.evidence,
unknownInput.value,
)
: unknownInput;
return server.delivery.toEvidenceToolResult(
- result.value,
+ execution.evidence,
nativeVerificationContract,
output,
);
diff --git a/tests/boundary/mcp/managedMcp.test.ts b/tests/boundary/mcp/managedMcp.test.ts
index fb082fb72..6328dd162 100644
--- a/tests/boundary/mcp/managedMcp.test.ts
+++ b/tests/boundary/mcp/managedMcp.test.ts
@@ -263,7 +263,12 @@ const verifyManagedCatalogAndNativeWorkflow = async (
},
});
expect(parseMcpToolError(wrong)).toMatchObject({
- error: { code: "evidence_integrity_mismatch" },
+ error: {
+ code: "invalid_request",
+ details: {
+ issues: [expect.objectContaining({ path: ["managed_boundaries"] })],
+ },
+ },
});
};
diff --git a/tests/boundary/mcp/managedNativeVerificationAdapters.test.ts b/tests/boundary/mcp/managedNativeVerificationAdapters.test.ts
index c3e7dc6f2..7fb58195e 100644
--- a/tests/boundary/mcp/managedNativeVerificationAdapters.test.ts
+++ b/tests/boundary/mcp/managedNativeVerificationAdapters.test.ts
@@ -38,6 +38,7 @@ const signatureEvidence = () =>
},
{ id: "native", name: "Native", version: "simulated" },
{
+ predicateType: "rea.native-signature",
operation: "inspect_signature",
parameters: {},
result: { signed: true },
diff --git a/tests/boundary/providers/managed/managedMemberComparison.test.ts b/tests/boundary/providers/managed/managedMemberComparison.test.ts
index ed3430731..cafda31f5 100644
--- a/tests/boundary/providers/managed/managedMemberComparison.test.ts
+++ b/tests/boundary/providers/managed/managedMemberComparison.test.ts
@@ -8,12 +8,12 @@ import { ArtifactResourceScope } from "../../../../src/artifacts/ArtifactResourc
import { OwnedFileHandle } from "../../../../src/filesystem/OwnedFileHandle.js";
import {
- compareManagedMembersEvidenceValidated,
+ executeManagedMemberComparison,
compareManagedMemberPaths,
} from "../../../../src/application/managed/ManagedMemberComparisonService.js";
import { parseBinaryTarget } from "../../../../src/application/BinaryTargetResolver.js";
import { managedMemberComparisonResultSchema } from "../../../../src/domain/managed/managedMemberComparison.js";
-import { parseManagedMemberEvidence } from "../../../../src/domain/managed/managedMemberComparisonMatch.js";
+import { readManagedMemberEvidence } from "../../../../src/domain/managed/managedMemberComparisonMatch.js";
import { createEvidence } from "../../../../src/domain/evidence.js";
import { projectAnalysisError } from "../../../../src/domain/analysisErrorProjection.js";
import { jsonValueSchema } from "../../../../src/domain/jsonValue.js";
@@ -112,7 +112,7 @@ const compare = (
authority: "shipped-artifact",
},
);
- const result = compareManagedMembersEvidenceValidated(
+ const result = executeManagedMemberComparison(
compareManagedMembersInputSchema.parse({
left: observe(left, edit.left),
right: observe(right, edit.right),
@@ -120,9 +120,36 @@ const compare = (
);
if (!result.ok) throw result.error;
return managedMemberComparisonResultSchema.parse(
- result.value.normalized_result,
+ result.value.evidence.normalized_result,
);
};
+
+describe("managed member comparison request envelope", () => {
+ it("rejects missing and extra fields before reading source Evidence", () => {
+ const missing = executeManagedMemberComparison({ left: null });
+ expect(missing).toMatchObject({
+ ok: false,
+ error: {
+ _tag: "AnalysisInputError",
+ issues: [{ path: ["right"], reason: "missing_argument" }],
+ },
+ });
+
+ const extra = executeManagedMemberComparison({
+ left: null,
+ right: null,
+ ignored: true,
+ });
+ expect(extra).toMatchObject({
+ ok: false,
+ error: {
+ _tag: "AnalysisInputError",
+ issues: [{ path: ["ignored"], reason: "unknown_argument" }],
+ },
+ });
+ });
+});
+
const withCilDigests =
(byToken: Readonly<Record<string, string>>) => (inspection: Inspection) => ({
...inspection,
@@ -468,15 +495,27 @@ describe("managed member comparison subject identity", () => {
},
);
- expect(() => parseManagedMemberEvidence(mismatched)).toThrow(
- `Managed Evidence inspect_managed_members (${mismatched.evidence_id}) subject SHA-256 ${target.sha256} does not match normalized artifact SHA-256 ${otherDigest}`,
+ const rejected = readManagedMemberEvidence(mismatched, "left");
+ expect(rejected).toMatchObject({
+ ok: false,
+ error: { _tag: "EvidenceIntegrityError" },
+ });
+ if (!rejected.ok)
+ expect(rejected.error.message).toContain(
+ `Managed Evidence inspect_managed_members (${mismatched.evidence_id}) subject SHA-256 ${target.sha256} does not match normalized artifact SHA-256 ${otherDigest}`,
+ );
+ const parsedAligned = readManagedMemberEvidence(aligned, "left");
+ const parsedWithoutSubject = readManagedMemberEvidence(
+ unavailableSubject,
+ "right",
);
- expect(parseManagedMemberEvidence(aligned).result.artifact.sha256).toBe(
+ if (!parsedAligned.ok) throw parsedAligned.error;
+ if (!parsedWithoutSubject.ok) throw parsedWithoutSubject.error;
+ expect(parsedAligned.value.result.artifact.sha256).toBe(target.sha256);
+ expect(parsedAligned.value.evidence.evidence_id).toBe(aligned.evidence_id);
+ expect(parsedWithoutSubject.value.result.artifact.sha256).toBe(
target.sha256,
);
- expect(
- parseManagedMemberEvidence(unavailableSubject).result.artifact.sha256,
- ).toBe(target.sha256);
});
});
@@ -507,11 +546,12 @@ describe("managed member comparison path workflow", () => {
left: observe(0xff, "/tmp/partial-left.dll"),
right: observe(0xfe, "/tmp/partial-right.dll"),
});
- const result = compareManagedMembersEvidenceValidated(input);
+ const result = executeManagedMemberComparison(input);
if (!result.ok) throw result.error;
const comparison = managedMemberComparisonResultSchema.parse(
- result.value.normalized_result,
+ result.value.evidence.normalized_result,
);
+ expect(result.value.summary).toEqual(comparison.summary);
expect(comparison.coverage.status).toBe("partial");
expect(comparison.matching.structural_method_shape).toBe(0);
expect(comparison.methods).toHaveLength(2);
diff --git a/tests/process-global/derivedOperationFailures.test.ts b/tests/process-global/derivedOperationFailures.test.ts
index 9e0c59794..7457569b9 100644
--- a/tests/process-global/derivedOperationFailures.test.ts
+++ b/tests/process-global/derivedOperationFailures.test.ts
@@ -1,3 +1,6 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
import { InMemoryTransport, Client } from "@modelcontextprotocol/client";
import { afterEach, describe, expect, it, vi } from "vitest";
import { z } from "zod";
@@ -12,6 +15,21 @@ import { createServer } from "../../src/server/createServer.js";
import { createTestBinarySession } from "../fixtures/binarySession.js";
import { parseMcpToolError } from "../fixtures/mcpToolError.js";
+import {
+ MANAGED_APPLICATION_GRAPH_EXAMPLE,
+ MANAGED_MEMBER_COMPARISON_EXAMPLE,
+ MANAGED_NATIVE_VERIFICATION_EXAMPLE,
+ MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE,
+} from "../../src/contracts/managed/managedWorkflowExamples.js";
+import { managedApplicationGraphResultSchema } from "../../src/domain/managed/managedApplicationGraph.js";
+import { managedMemberComparisonResultSchema } from "../../src/domain/managed/managedMemberComparison.js";
+import { managedNativeVerificationResultSchema } from "../../src/domain/managed/managedNativeVerificationSchemas.js";
+import { managedReconstructionImportResultSchema } from "../../src/domain/managed/managedReconstruction.js";
+
+import { compareManagedMemberPaths } from "../../src/application/managed/ManagedMemberComparisonService.js";
+import { buildManagedPeFixture } from "../../src/dotnet/ManagedPe.fixture.js";
+import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
+
const unexpectedResultFailures = [
["TypeError", () => new TypeError("injected result parser TypeError")],
["Error", () => new Error("injected result parser Error")],
@@ -243,3 +261,158 @@ describe("derived operation failures through the public SDK", () => {
},
);
});
+
+const managedWorkflows = [
+ {
+ name: "project_managed_application_graph",
+ input: MANAGED_APPLICATION_GRAPH_EXAMPLE,
+ result: managedApplicationGraphResultSchema,
+ sourceField: "managed_members",
+ source: MANAGED_APPLICATION_GRAPH_EXAMPLE.managed_members,
+ },
+ {
+ name: "compare_managed_members",
+ input: MANAGED_MEMBER_COMPARISON_EXAMPLE,
+ result: managedMemberComparisonResultSchema,
+ sourceField: "left",
+ source: MANAGED_MEMBER_COMPARISON_EXAMPLE.left,
+ },
+ {
+ name: "verify_managed_native_boundaries",
+ input: MANAGED_NATIVE_VERIFICATION_EXAMPLE,
+ result: managedNativeVerificationResultSchema,
+ sourceField: "managed_boundaries",
+ source: MANAGED_NATIVE_VERIFICATION_EXAMPLE.managed_boundaries,
+ },
+ {
+ name: "import_managed_reconstruction",
+ input: MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE,
+ result: managedReconstructionImportResultSchema,
+ sourceField: "static_members",
+ source: MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE.static_members,
+ },
+] as const;
+
+describe.each(managedWorkflows)(
+ "$name failure ownership through the public SDK",
+ (workflow) => {
+ afterEach(() => vi.restoreAllMocks());
+
+ it("rejects an authentic source with the wrong operation at its selection", async () => {
+ await withSdk(async ({ client, session }) => {
+ const response = await client.callTool({
+ name: workflow.name,
+ arguments: {
+ ...workflow.input,
+ [workflow.sourceField]: FUNCTION_COMPARISON_EXAMPLE.left,
+ },
+ });
+ expect(parseMcpToolError(response).error).toMatchObject({
+ code: "invalid_request",
+ details: {
+ issues: [expect.objectContaining({ path: [workflow.sourceField] })],
+ },
+ });
+ expect(session.exportEvidenceBundle().records).toEqual([]);
+ });
+ });
+
+ it("rejects a malformed authenticated source payload as Evidence integrity", async () => {
+ await withSdk(async ({ client, session }) => {
+ const source = createEvidence(undefined, workflow.source.provider, {
+ operation: workflow.source.operation,
+ parameters: {},
+ result: { malformed: true },
+ });
+ const response = await client.callTool({
+ name: workflow.name,
+ arguments: { ...workflow.input, [workflow.sourceField]: source },
+ });
+ expect(parseMcpToolError(response).error.code).toBe(
+ "evidence_integrity_mismatch",
+ );
+ expect(session.exportEvidenceBundle().records).toEqual([]);
+ });
+ });
+
+ it("rejects a tampered source before recording any Evidence", async () => {
+ await withSdk(async ({ client, session }) => {
+ const response = await client.callTool({
+ name: workflow.name,
+ arguments: {
+ ...workflow.input,
+ [workflow.sourceField]: {
+ ...workflow.source,
+ normalized_result: { tampered: true },
+ },
+ },
+ });
+ expect(parseMcpToolError(response).error.code).toBe(
+ "evidence_integrity_mismatch",
+ );
+ expect(session.exportEvidenceBundle().records).toEqual([]);
+ });
+ });
+
+ it.each(unexpectedResultFailures)(
+ "preserves an unexpected %s from its generated output",
+ async (_label, createFailure) => {
+ await withSdk(async ({ client, session }) => {
+ const failure = createFailure();
+ vi.spyOn(workflow.result, "parse").mockImplementation(() => {
+ throw failure;
+ });
+ const response = await client.callTool({
+ name: workflow.name,
+ arguments: workflow.input,
+ });
+ expect(response).toMatchObject({
+ isError: true,
+ content: [{ type: "text", text: failure.message }],
+ });
+ expect(response.structuredContent).toBeUndefined();
+ expect(session.exportEvidenceBundle().records).toEqual([]);
+ });
+ },
+ );
+ },
+);
+
+describe("managed comparison output failure with completed source reads", () => {
+ afterEach(() => vi.restoreAllMocks());
+
+ it("retains the left source and output failure cause after reading real artifacts", async () => {
+ const root = await createTestTempDirectory("rea-managed-output-failure-");
+ const leftPath = join(root, "left.dll");
+ const rightPath = join(root, "right.dll");
+ await writeFile(leftPath, buildManagedPeFixture());
+ await writeFile(
+ rightPath,
+ buildManagedPeFixture({ methodName: "Changed" }),
+ );
+ const parsed = z.string().safeParse(1);
+ if (parsed.success) throw new Error("Expected invalid output");
+ const failure = parsed.error;
+ vi.spyOn(managedMemberComparisonResultSchema, "parse").mockImplementation(
+ () => {
+ throw failure;
+ },
+ );
+
+ const result = await compareManagedMemberPaths({ leftPath, rightPath });
+
+ expect(result.ok).toBe(false);
+ if (result.ok) return;
+ expect(result.error.cause).toBe(failure);
+ expect(result.error).toMatchObject({
+ _tag: "AnalysisOutputError",
+ partialObservation: {
+ operation: "inspect_managed_members",
+ subject: { local_path: leftPath },
+ normalized_result: {
+ methods: [expect.objectContaining({ token: "0x06000001" })],
+ },
+ },
+ });
+ });
+});