Merge pull request #706 from kaoru0822-kitauji/fix/process-evidence-provider-identity
fix(evidence): admit current process provider identity
This commit is contained in:
@@ -1,17 +1,13 @@
|
||||
import type { JsonValue } from "../domain/jsonValue.js";
|
||||
import { createEvidence } from "../domain/evidence.js";
|
||||
import { PROCESS_PROVIDER } from "../domain/processEvidenceProvider.js";
|
||||
import { jsonValueSchema } from "../domain/jsonValue.js";
|
||||
import type {
|
||||
ProcessCapture,
|
||||
ProcessScenario,
|
||||
} from "../domain/processCapture.js";
|
||||
|
||||
/** Provider identity for controlled process capture evidence. */
|
||||
export const PROCESS_PROVIDER = {
|
||||
id: "rea-process",
|
||||
name: "REA process capture",
|
||||
version: "3",
|
||||
} as const;
|
||||
export { PROCESS_PROVIDER } from "../domain/processEvidenceProvider.js";
|
||||
|
||||
/** Project one process scenario into secret-free Evidence parameters. */
|
||||
const processEvidenceParameters = (
|
||||
|
||||
@@ -4,6 +4,10 @@ import { artifactComparisonResultSchema } from "./artifactComparison.js";
|
||||
import { uniqueSorted } from "./canonicalOrdering.js";
|
||||
import { evidenceSchema, parseEvidence, type Evidence } from "./evidence.js";
|
||||
import { functionComparisonResultSchema } from "./functionComparison.js";
|
||||
import {
|
||||
PROCESS_PROVIDER,
|
||||
isProcessEvidenceProvider,
|
||||
} from "./processEvidenceProvider.js";
|
||||
import {
|
||||
comparisonStatusSchema,
|
||||
deriveProcessComparisonStatus,
|
||||
@@ -86,9 +90,7 @@ type RuntimeStatus = z.infer<typeof processCaptureComparisonSchema>["status"];
|
||||
const EXPECTED_PROVIDERS = {
|
||||
compare_process_captures: {
|
||||
predicates: ["rea.process-comparison"],
|
||||
id: "rea-process",
|
||||
name: "REA deterministic process harness",
|
||||
version: "3",
|
||||
...PROCESS_PROVIDER,
|
||||
},
|
||||
compare_artifacts: {
|
||||
predicates: ["rea.artifact-comparison"],
|
||||
@@ -171,9 +173,11 @@ const parseComparisonEvidence = (input: unknown): Evidence => {
|
||||
const expected = EXPECTED_PROVIDERS[operation];
|
||||
if (
|
||||
!acceptsPredicate(expected.predicates, evidence.predicate_type) ||
|
||||
evidence.provider.id !== expected.id ||
|
||||
evidence.provider.name !== expected.name ||
|
||||
evidence.provider.version !== expected.version ||
|
||||
(operation === "compare_process_captures"
|
||||
? !isProcessEvidenceProvider(evidence.provider)
|
||||
: evidence.provider.id !== expected.id ||
|
||||
evidence.provider.name !== expected.name ||
|
||||
evidence.provider.version !== expected.version) ||
|
||||
evidence.confidence !== "derived" ||
|
||||
evidence.authority !== "analyst-inference" ||
|
||||
evidence.subject !== null
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
import { expect, it } from "vitest";
|
||||
|
||||
import {
|
||||
PROCESS_PROVIDER,
|
||||
isProcessEvidenceProvider,
|
||||
} from "./processEvidenceProvider.js";
|
||||
|
||||
it.each(["REA process capture", "REA deterministic process harness"])(
|
||||
"accepts the exact v3 process provider name %s",
|
||||
(name) => {
|
||||
expect(isProcessEvidenceProvider({ ...PROCESS_PROVIDER, name })).toBe(true);
|
||||
},
|
||||
);
|
||||
|
||||
it.each([
|
||||
{ name: "REA process capture extra" },
|
||||
{ name: "REA deterministic process harness extra" },
|
||||
{ name: "rea process capture" },
|
||||
{ name: "REA Process Capture" },
|
||||
{ name: " REA process capture" },
|
||||
{ name: "REA process capture " },
|
||||
{ name: "REA deterministic process harness " },
|
||||
{ name: "Fixture process provider" },
|
||||
{ id: "fixture-process" },
|
||||
{ version: "2" },
|
||||
{ version: "4" },
|
||||
{ version: null },
|
||||
])("rejects other process identities: %j", (change) => {
|
||||
expect(isProcessEvidenceProvider({ ...PROCESS_PROVIDER, ...change })).toBe(
|
||||
false,
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,17 @@
|
||||
import type { EvidenceProvider } from "./evidence.js";
|
||||
|
||||
/** Canonical provider identity for controlled process capture Evidence. */
|
||||
export const PROCESS_PROVIDER = {
|
||||
id: "rea-process",
|
||||
name: "REA process capture",
|
||||
version: "3",
|
||||
} as const;
|
||||
|
||||
/** Admit current and previously emitted names for the same v3 process provider. */
|
||||
export const isProcessEvidenceProvider = (
|
||||
provider: EvidenceProvider,
|
||||
): boolean =>
|
||||
provider.id === PROCESS_PROVIDER.id &&
|
||||
provider.version === PROCESS_PROVIDER.version &&
|
||||
(provider.name === PROCESS_PROVIDER.name ||
|
||||
provider.name === "REA deterministic process harness");
|
||||
@@ -9,6 +9,10 @@ import { uniqueSorted } from "./canonicalOrdering.js";
|
||||
import { parseEvidence, type Evidence } from "./evidence.js";
|
||||
import { parseEvidenceBundle } from "./evidenceBundle.js";
|
||||
import { functionComparisonResultSchema } from "./functionComparison.js";
|
||||
import {
|
||||
PROCESS_PROVIDER,
|
||||
isProcessEvidenceProvider,
|
||||
} from "./processEvidenceProvider.js";
|
||||
import { functionDossierSchema } from "./hopperValues.js";
|
||||
import {
|
||||
deriveProcessComparisonStatus,
|
||||
@@ -45,8 +49,7 @@ const providers = {
|
||||
behavioral: {
|
||||
operation: "compare_process_captures",
|
||||
predicates: ["rea.process-comparison"],
|
||||
id: "rea-process",
|
||||
name: "REA deterministic process harness",
|
||||
...PROCESS_PROVIDER,
|
||||
},
|
||||
"structural-function": {
|
||||
operation: "compare_functions",
|
||||
@@ -209,9 +212,11 @@ const validateComparisonIdentity = (claim: Claim, evidence: Evidence): void => {
|
||||
if (
|
||||
evidence.operation !== expected.operation ||
|
||||
!acceptsPredicate(expected.predicates, evidence.predicate_type) ||
|
||||
evidence.provider.id !== expected.id ||
|
||||
evidence.provider.name !== expected.name ||
|
||||
evidence.provider.version !== (claim.kind === "behavioral" ? "3" : "1") ||
|
||||
(claim.kind === "behavioral"
|
||||
? !isProcessEvidenceProvider(evidence.provider)
|
||||
: evidence.provider.id !== expected.id ||
|
||||
evidence.provider.name !== expected.name ||
|
||||
evidence.provider.version !== "1") ||
|
||||
evidence.confidence !== "derived" ||
|
||||
evidence.authority !== "analyst-inference" ||
|
||||
evidence.subject !== null
|
||||
|
||||
@@ -7,6 +7,10 @@ import { artifactComparisonResultSchema } from "./artifactComparison.js";
|
||||
import { uniqueSorted } from "./canonicalOrdering.js";
|
||||
import { evidenceSchema, parseEvidence, type Evidence } from "./evidence.js";
|
||||
import { functionComparisonResultSchema } from "./functionComparison.js";
|
||||
import {
|
||||
PROCESS_PROVIDER,
|
||||
isProcessEvidenceProvider,
|
||||
} from "./processEvidenceProvider.js";
|
||||
import type { JsonValue } from "./jsonValue.js";
|
||||
import {
|
||||
comparisonStatusSchema,
|
||||
@@ -151,8 +155,8 @@ const EXPECTED: Readonly<Record<string, ComparisonIdentity>> = {
|
||||
],
|
||||
compare_process_captures: [
|
||||
"rea.process-comparison",
|
||||
"rea-process",
|
||||
"REA deterministic process harness",
|
||||
PROCESS_PROVIDER.id,
|
||||
PROCESS_PROVIDER.name,
|
||||
],
|
||||
};
|
||||
|
||||
@@ -381,10 +385,11 @@ const assertComparisonIdentity = (evidence: Evidence): void => {
|
||||
!(Array.isArray(expected[0])
|
||||
? expected[0].includes(evidence.predicate_type)
|
||||
: evidence.predicate_type === expected[0]) ||
|
||||
evidence.provider.id !== expected[1] ||
|
||||
evidence.provider.name !== expected[2] ||
|
||||
evidence.provider.version !==
|
||||
(evidence.operation === "compare_process_captures" ? "3" : "1") ||
|
||||
(evidence.operation === "compare_process_captures"
|
||||
? !isProcessEvidenceProvider(evidence.provider)
|
||||
: evidence.provider.id !== expected[1] ||
|
||||
evidence.provider.name !== expected[2] ||
|
||||
evidence.provider.version !== "1") ||
|
||||
evidence.confidence !== "derived" ||
|
||||
evidence.authority !== "analyst-inference" ||
|
||||
evidence.subject !== null ||
|
||||
|
||||
@@ -0,0 +1,337 @@
|
||||
import { writeFile } from "node:fs/promises";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
|
||||
import { expect, it, onTestFinished } from "vitest";
|
||||
import { z } from "zod";
|
||||
|
||||
import { compareProcessEvidenceFiles } from "../../../src/application/ProcessCli.js";
|
||||
import { PROCESS_PROVIDER } from "../../../src/application/ProcessEvidence.js";
|
||||
import { FUNCTION_COMPARISON_EXAMPLE } from "../../../src/contracts/functionComparisonExample.js";
|
||||
import {
|
||||
FUNCTION_COMPARISON_EVIDENCE,
|
||||
INVESTIGATION_EXAMPLES,
|
||||
} from "../../../src/contracts/investigationExamples.js";
|
||||
import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "../../../src/contracts/processCaptureExample.js";
|
||||
import { findChangedBehavior } from "../../../src/domain/changedBehavior.js";
|
||||
import {
|
||||
createEvidence,
|
||||
parseEvidence,
|
||||
type Evidence,
|
||||
} from "../../../src/domain/evidence.js";
|
||||
import { createEvidenceBundle } from "../../../src/domain/evidenceBundle.js";
|
||||
import { verifyReconstruction } from "../../../src/domain/reconstructionVerification.js";
|
||||
import { correlateStaticAndRuntime } from "../../../src/domain/staticRuntimeCorrelation.js";
|
||||
import { createServer } from "../../../src/server/createServer.js";
|
||||
import { createTestBinarySession } from "../../fixtures/binarySession.js";
|
||||
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
||||
|
||||
const providerNames = [
|
||||
"REA process capture",
|
||||
"REA deterministic process harness",
|
||||
];
|
||||
|
||||
const captureEvidence = (side: "left" | "right") =>
|
||||
createEvidence(undefined, PROCESS_PROVIDER, {
|
||||
predicateType: "rea.process-capture",
|
||||
operation: "capture_process_scenario",
|
||||
parameters: { side },
|
||||
result: EMPTY_PROCESS_CAPTURE_EXAMPLE,
|
||||
confidence: "observed",
|
||||
authority: "controlled-replay",
|
||||
environment: {
|
||||
id: "fixture-process",
|
||||
platform: "fixture",
|
||||
architecture: "fixture",
|
||||
isolation: "process",
|
||||
},
|
||||
});
|
||||
|
||||
const inlineEvidence = (response: { structuredContent?: unknown }) =>
|
||||
parseEvidence(
|
||||
z.object({ evidence: z.unknown() }).parse(response.structuredContent)
|
||||
.evidence,
|
||||
);
|
||||
|
||||
const connectedComparison = async () => {
|
||||
const session = createTestBinarySession(() => {
|
||||
throw new Error("Process comparison must not launch a provider");
|
||||
});
|
||||
const server = createServer(session, session);
|
||||
const client = new Client({
|
||||
name: "process-evidence-identity",
|
||||
version: "1",
|
||||
});
|
||||
onTestFinished(async () => {
|
||||
await Promise.allSettled([client.close(), server.close(), session.close()]);
|
||||
});
|
||||
const [clientTransport, serverTransport] =
|
||||
InMemoryTransport.createLinkedPair();
|
||||
await server.connect(serverTransport);
|
||||
await client.connect(clientTransport);
|
||||
for (const evidence of [
|
||||
FUNCTION_COMPARISON_EXAMPLE.left,
|
||||
FUNCTION_COMPARISON_EXAMPLE.right,
|
||||
FUNCTION_COMPARISON_EVIDENCE,
|
||||
])
|
||||
expect(session.recordEvidence(evidence).ok).toBe(true);
|
||||
const left = captureEvidence("left");
|
||||
const right = captureEvidence("right");
|
||||
const response = await client.callTool({
|
||||
name: "compare_process_captures",
|
||||
arguments: { left, right },
|
||||
});
|
||||
expect(response.isError, JSON.stringify(response)).not.toBe(true);
|
||||
const comparison = inlineEvidence(response);
|
||||
expect(comparison.provider).toEqual({
|
||||
id: "rea-process",
|
||||
name: "REA process capture",
|
||||
version: "3",
|
||||
});
|
||||
expect(comparison.normalized_result).toMatchObject({ status: "unchanged" });
|
||||
return { session, client, left, right, comparison };
|
||||
};
|
||||
|
||||
const correlationInput = (comparison: Evidence) => {
|
||||
const mapping =
|
||||
INVESTIGATION_EXAMPLES.correlate_static_and_runtime.mappings[0];
|
||||
if (mapping === undefined) throw new Error("Missing correlation mapping");
|
||||
return {
|
||||
static_comparisons: [FUNCTION_COMPARISON_EVIDENCE],
|
||||
runtime_comparisons: [comparison],
|
||||
mappings: [
|
||||
{
|
||||
...mapping,
|
||||
runtime: {
|
||||
...mapping.runtime,
|
||||
comparison_evidence_id: comparison.evidence_id,
|
||||
},
|
||||
},
|
||||
],
|
||||
};
|
||||
};
|
||||
|
||||
const specification = (comparison: Evidence) => ({
|
||||
name: "Terminal compatibility",
|
||||
claims: [
|
||||
{
|
||||
kind: "behavioral",
|
||||
claim_id: "terminal-output",
|
||||
title: "Terminal output remains equivalent",
|
||||
comparison_evidence_id: comparison.evidence_id,
|
||||
dimension: "terminal",
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
const consumerCalls = (comparison: Evidence) => [
|
||||
{
|
||||
name: "find_changed_behavior",
|
||||
arguments: { comparisons: [comparison] },
|
||||
expected: { behavior_status: "observed_unchanged" },
|
||||
},
|
||||
{
|
||||
name: "correlate_static_and_runtime",
|
||||
arguments: correlationInput(comparison),
|
||||
expected: { status: "correlated" },
|
||||
},
|
||||
{
|
||||
name: "verify_reconstruction",
|
||||
arguments: { specification: specification(comparison) },
|
||||
expected: { status: "pass" },
|
||||
},
|
||||
];
|
||||
|
||||
const expectConsumerResults = async (client: Client, comparison: Evidence) => {
|
||||
for (const { expected, ...call } of consumerCalls(comparison)) {
|
||||
const response = await client.callTool(call);
|
||||
expect(
|
||||
response.isError,
|
||||
`${call.name}: ${JSON.stringify(response)}`,
|
||||
).not.toBe(true);
|
||||
expect(inlineEvidence(response).normalized_result).toMatchObject(expected);
|
||||
}
|
||||
};
|
||||
|
||||
it("feeds the exact public CLI/MCP process comparison into all three MCP consumers", async () => {
|
||||
const { client, left, right, comparison } = await connectedComparison();
|
||||
const root = await createTestTempDirectory("rea-process-identity-");
|
||||
const leftPath = join(root, "left.json");
|
||||
const rightPath = join(root, "right.json");
|
||||
await Promise.all([
|
||||
writeFile(leftPath, JSON.stringify(left)),
|
||||
writeFile(rightPath, JSON.stringify(right)),
|
||||
]);
|
||||
const cliComparison = parseEvidence(
|
||||
await compareProcessEvidenceFiles(leftPath, rightPath),
|
||||
);
|
||||
expect(cliComparison).toEqual(comparison);
|
||||
await expectConsumerResults(client, comparison);
|
||||
});
|
||||
|
||||
type IdentityChange = Partial<
|
||||
Pick<
|
||||
Evidence,
|
||||
| "provider"
|
||||
| "predicate_type"
|
||||
| "operation"
|
||||
| "subject"
|
||||
| "confidence"
|
||||
| "authority"
|
||||
>
|
||||
>;
|
||||
|
||||
// Use the public Evidence builder so each admission control has a valid digest.
|
||||
const rehashedComparison = (
|
||||
base: Evidence,
|
||||
change: IdentityChange,
|
||||
): Evidence => {
|
||||
const next = { ...base, ...change };
|
||||
const subject = next.subject;
|
||||
return createEvidence(
|
||||
subject === null
|
||||
? undefined
|
||||
: {
|
||||
path: subject.local_path,
|
||||
sha256: subject.digest.sha256,
|
||||
format: subject.format,
|
||||
...(subject.architecture === null
|
||||
? {}
|
||||
: { architecture: subject.architecture }),
|
||||
},
|
||||
next.provider,
|
||||
{
|
||||
predicateType: next.predicate_type,
|
||||
operation: next.operation,
|
||||
parameters: next.parameters,
|
||||
result: next.normalized_result,
|
||||
rawResult: next.raw_result,
|
||||
confidence: next.confidence,
|
||||
authority: next.authority,
|
||||
environment: next.environment,
|
||||
limitations: next.limitations,
|
||||
locations: next.locations,
|
||||
evidenceLinks: next.evidence_links,
|
||||
},
|
||||
);
|
||||
};
|
||||
|
||||
it.each(providerNames)(
|
||||
"admits the exact v3 provider name %s in every MCP consumer",
|
||||
async (name) => {
|
||||
const { session, client, comparison } = await connectedComparison();
|
||||
const admitted = rehashedComparison(comparison, {
|
||||
provider: { ...comparison.provider, name },
|
||||
});
|
||||
expect(parseEvidence(admitted)).toEqual(admitted);
|
||||
expect(session.recordEvidence(admitted).ok).toBe(true);
|
||||
await expectConsumerResults(client, admitted);
|
||||
},
|
||||
);
|
||||
|
||||
const invalidIdentities: ReadonlyArray<{
|
||||
label: string;
|
||||
change: (base: Evidence) => IdentityChange;
|
||||
}> = [
|
||||
{
|
||||
label: "wrong name",
|
||||
change: ({ provider }) => ({
|
||||
provider: { ...provider, name: `${provider.name} extra` },
|
||||
}),
|
||||
},
|
||||
{
|
||||
label: "wrong id",
|
||||
change: ({ provider }) => ({
|
||||
provider: { ...provider, id: "fixture-process" },
|
||||
}),
|
||||
},
|
||||
{
|
||||
label: "old version",
|
||||
change: ({ provider }) => ({ provider: { ...provider, version: "2" } }),
|
||||
},
|
||||
{
|
||||
label: "future version",
|
||||
change: ({ provider }) => ({ provider: { ...provider, version: "4" } }),
|
||||
},
|
||||
{
|
||||
label: "missing version",
|
||||
change: ({ provider }) => ({ provider: { ...provider, version: null } }),
|
||||
},
|
||||
{
|
||||
label: "wrong predicate",
|
||||
change: () => ({ predicate_type: "fixture.comparison" }),
|
||||
},
|
||||
{
|
||||
label: "wrong operation",
|
||||
change: () => ({ operation: "fixture_comparison" }),
|
||||
},
|
||||
{
|
||||
label: "non-null subject",
|
||||
change: () => ({ subject: FUNCTION_COMPARISON_EXAMPLE.left.subject }),
|
||||
},
|
||||
{ label: "wrong confidence", change: () => ({ confidence: "observed" }) },
|
||||
{
|
||||
label: "wrong authority",
|
||||
change: () => ({ authority: "controlled-replay" }),
|
||||
},
|
||||
];
|
||||
|
||||
for (const name of providerNames)
|
||||
it.each(invalidIdentities)(
|
||||
`rejects independently rehashed $label for ${name} in every MCP consumer`,
|
||||
async ({ change }) => {
|
||||
const { session, client, comparison } = await connectedComparison();
|
||||
const named = rehashedComparison(comparison, {
|
||||
provider: { ...comparison.provider, name },
|
||||
});
|
||||
const invalid = rehashedComparison(named, change(named));
|
||||
expect(invalid.evidence_id).not.toBe(named.evidence_id);
|
||||
expect(parseEvidence(invalid)).toEqual(invalid);
|
||||
expect(session.recordEvidence(invalid).ok).toBe(true);
|
||||
for (const { expected: _expected, ...call } of consumerCalls(invalid)) {
|
||||
const response = await client.callTool(call);
|
||||
expect(response.isError, call.name).toBe(true);
|
||||
expect(response.structuredContent, call.name).toMatchObject({
|
||||
error: { code: "invalid_request" },
|
||||
});
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
it("separately rejects a tampered digest before admission to any consumer or session", async () => {
|
||||
const { session, client, comparison } = await connectedComparison();
|
||||
const tampered = {
|
||||
...comparison,
|
||||
provider: {
|
||||
...comparison.provider,
|
||||
name: "REA deterministic process harness",
|
||||
},
|
||||
};
|
||||
const digestMismatch = /semantic identifier does not match/u;
|
||||
expect(() => parseEvidence(tampered)).toThrow(digestMismatch);
|
||||
expect(() => findChangedBehavior([tampered])).toThrow(digestMismatch);
|
||||
expect(() => correlateStaticAndRuntime(correlationInput(tampered))).toThrow(
|
||||
digestMismatch,
|
||||
);
|
||||
const records = session
|
||||
.exportEvidenceBundle()
|
||||
.records.map((record) =>
|
||||
record.evidence_id === tampered.evidence_id ? tampered : record,
|
||||
);
|
||||
expect(() =>
|
||||
verifyReconstruction(
|
||||
specification(tampered),
|
||||
createEvidenceBundle(records),
|
||||
),
|
||||
).toThrow(digestMismatch);
|
||||
expect(session.recordEvidence(tampered).ok).toBe(false);
|
||||
for (const { expected: _expected, ...call } of consumerCalls(tampered).filter(
|
||||
({ name }) => name !== "verify_reconstruction",
|
||||
)) {
|
||||
const response = await client.callTool(call);
|
||||
expect(response.isError, call.name).toBe(true);
|
||||
expect(response.structuredContent).toMatchObject({
|
||||
error: { code: "invalid_request" },
|
||||
});
|
||||
}
|
||||
});
|
||||
Reference in New Issue
Block a user