Skip to content

armgit / rea

Public Imported from GitHub
0

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

fix(reconstruction): authenticate obligation proof boundaries

morluto7b1e3bda00e4
diff --git a/src/application/ReconstructionObligationAuthority.ts b/src/application/ReconstructionObligationAuthority.ts
index f8c7b0bda..4ebed5f81 100644
--- a/src/application/ReconstructionObligationAuthority.ts
+++ b/src/application/ReconstructionObligationAuthority.ts
@@ -4,6 +4,50 @@ import type { ReconstructionObligation } from "../domain/reconstructionObligatio
type ProofAuthority = ReconstructionObligation["required_fixture_authority"];
type OriginalAuthority =
ReconstructionObligation["required_original_authority"];
+type ProofEvidenceShape = readonly [predicate: string, operation: string];
+
+const proofEvidenceShapes: Readonly<
+ Record<ProofAuthority, readonly ProofEvidenceShape[]>
+> = {
+ unit: [["rea.fixture-verification/v1", "run_fixture_verifier"]],
+ integration: [["rea.fixture-verification/v1", "run_fixture_verifier"]],
+ protocol: [["rea.protocol-observation/v1", "observe_protocol"]],
+ renderer: [
+ ["rea.browser-scenario-capture/v1", "capture_browser_scenario"],
+ ["rea.electron-page-inspection/v1", "inspect_electron_page"],
+ ],
+ "packaged-process": [
+ ["rea.process-capture/v4", "capture_process_scenario"],
+ [
+ "rea.reconstruction-readiness-fixture/v1",
+ "run_reconstruction_readiness_fixture",
+ ],
+ ],
+ "native-abi": [
+ ["rea.managed-native-verification/v1", "verify_managed_native_boundaries"],
+ ],
+ "live-observation": [
+ ["javascript-controlled-replay-observation", "run_controlled_replay"],
+ ["rea.browser-scenario-capture/v1", "capture_browser_scenario"],
+ ["rea.electron-page-inspection/v1", "inspect_electron_page"],
+ ["rea.javascript-runtime-observation/v1", "observe_javascript_runtime"],
+ ["rea.runtime-characterization/v1", "execute_node_characterization"],
+ ],
+ external: [["rea.protocol-observation/v1", "observe_protocol"]],
+};
+
+const proofEvidenceAuthorities: Readonly<
+ Record<ProofAuthority, readonly Evidence["authority"][]>
+> = {
+ unit: ["shipped-artifact", "controlled-replay"],
+ integration: ["controlled-replay"],
+ protocol: ["controlled-replay", "external-service"],
+ renderer: ["controlled-replay", "external-service"],
+ "packaged-process": ["controlled-replay"],
+ "native-abi": ["shipped-artifact", "controlled-replay"],
+ "live-observation": ["controlled-replay", "external-service"],
+ external: ["external-service"],
+};
/** Return whether an actual reconstruction proof is comparable to a requirement. */
export const proofAuthoritySatisfies = (
@@ -46,9 +90,11 @@ export const evidenceAuthoritySupportsProof = (
authority: ProofAuthority,
): boolean =>
evidence.confidence === "observed" &&
- (authority === "external"
- ? evidence.authority === "external-service"
- : ["shipped-artifact", "controlled-replay"].includes(evidence.authority));
+ proofEvidenceAuthorities[authority].includes(evidence.authority) &&
+ proofEvidenceShapes[authority].some(
+ ([predicate, operation]) =>
+ evidence.predicate_type === predicate && evidence.operation === operation,
+ );
/** Check that Evidence observes the original at the required boundary. */
export const evidenceSupportsOriginalAuthority = (
diff --git a/src/application/ReconstructionObligationLedgerEvaluation.ts b/src/application/ReconstructionObligationLedgerEvaluation.ts
index 82035c4d4..384be39cf 100644
--- a/src/application/ReconstructionObligationLedgerEvaluation.ts
+++ b/src/application/ReconstructionObligationLedgerEvaluation.ts
@@ -454,35 +454,31 @@ const applyDependencyDiagnostics = (
obligations: readonly ReconstructionObligation[],
context: EvaluationContext,
): ReconstructionObligation[] => {
- const statuses = new Map(
- obligations.map((obligation) => [
- obligation.obligation_id,
- obligation.status,
- ]),
- );
- return obligations.map((obligation) => {
- const diagnostics = [...obligation.diagnostics];
- for (const dependencyId of obligation.dependency_obligation_ids) {
- if (!context.candidates.has(dependencyId))
- addDiagnostic(
- diagnostics,
- "dependency-missing",
- `Dependency obligation is missing: ${dependencyId}.`,
- );
- else if (statuses.get(dependencyId) !== "verified")
- addDiagnostic(
- diagnostics,
- "dependency-open",
- `Dependency obligation is not verified: ${dependencyId}.`,
- );
- }
- const normalized = uniqueDiagnostics(diagnostics);
- return {
- ...obligation,
- status: dependencyStatus(obligation.status, normalized),
- diagnostics: normalized,
- };
- });
+ let evaluated = [...obligations];
+ for (let pass = 0; pass < obligations.length; pass += 1) {
+ const statuses = new Map(
+ evaluated.map(({ obligation_id: id, status }) => [id, status]),
+ );
+ let changed = false;
+ evaluated = evaluated.map((obligation) => {
+ const diagnostics = [...obligation.diagnostics];
+ for (const dependencyId of obligation.dependency_obligation_ids) {
+ const missing = !context.candidates.has(dependencyId);
+ if (missing || statuses.get(dependencyId) !== "verified")
+ addDiagnostic(
+ diagnostics,
+ missing ? "dependency-missing" : "dependency-open",
+ `Dependency obligation is ${missing ? "missing" : "not verified"}: ${dependencyId}.`,
+ );
+ }
+ const normalized = uniqueDiagnostics(diagnostics);
+ const status = dependencyStatus(obligation.status, normalized);
+ changed ||= status !== obligation.status;
+ return { ...obligation, status, diagnostics: normalized };
+ });
+ if (!changed) break;
+ }
+ return evaluated;
};
const obligationStatus = (
diff --git a/tests/reconstructionObligationLedger.test.ts b/tests/reconstructionObligationLedger.test.ts
index cbcc43333..e269d838c 100644
--- a/tests/reconstructionObligationLedger.test.ts
+++ b/tests/reconstructionObligationLedger.test.ts
@@ -256,13 +256,12 @@ describe("reconstruction obligation ledger", () => {
it("closes only when every required case and verifier has comparable authority", () => {
const capture = processEvidence();
- const proof = proofEvidence("packaged");
- const initial = build(request([capture, proof]));
+ const initial = build(request([capture]));
const obligation = initial.obligations[0];
if (obligation === undefined)
throw new Error("Expected process obligation");
const result = build(
- request([capture, proof], {
+ request([capture], {
manifest: {
schema_version: 1,
bindings: [
@@ -279,7 +278,7 @@ describe("reconstruction obligation ledger", () => {
fixture_id: `packaged.${caseKind}`,
case_kind: caseKind,
authority: "packaged-process",
- evidence_ids: [proof.evidence_id],
+ evidence_ids: [capture.evidence_id],
})),
verifier: {
verifier_id: "verifier.packaged",
@@ -287,7 +286,7 @@ describe("reconstruction obligation ledger", () => {
command: "npm run verify:package -- process",
authority: "packaged-process",
status: "pass",
- result_evidence_id: proof.evidence_id,
+ result_evidence_id: capture.evidence_id,
enumerated_obligation_ids: [obligation.obligation_id],
nondeterminism: {
mode: "partial-order",
@@ -310,6 +309,140 @@ describe("reconstruction obligation ledger", () => {
expect(result.summary.required_open).toBe(0);
});
+ it("does not authenticate packaged-process proof with generic replay evidence", () => {
+ const capture = processEvidence();
+ const proof = proofEvidence("generic-packaged");
+ const initial = build(request([capture, proof]));
+ const obligation = initial.obligations[0];
+ if (obligation === undefined)
+ throw new Error("Expected process obligation");
+ const result = build(
+ request([capture, proof], {
+ manifest: {
+ schema_version: 1,
+ bindings: [
+ {
+ obligation_id: obligation.obligation_id,
+ owner: {
+ module_path: "src/processOwner.ts",
+ symbol: "runProcess",
+ owner_sha256: "5".repeat(64),
+ },
+ parser_type: null,
+ original_cases: originalCases(obligation, capture.evidence_id),
+ fixtures: obligation.required_case_kinds.map((caseKind) => ({
+ fixture_id: `packaged.${caseKind}`,
+ case_kind: caseKind,
+ authority: "packaged-process",
+ evidence_ids: [proof.evidence_id],
+ })),
+ verifier: {
+ verifier_id: "verifier.packaged",
+ claim_id: "claim.process",
+ command: "npm run verify:package -- process",
+ authority: "packaged-process",
+ status: "pass",
+ result_evidence_id: proof.evidence_id,
+ enumerated_obligation_ids: [obligation.obligation_id],
+ nondeterminism: {
+ mode: "partial-order",
+ specification: "Fixture scheduling is partially ordered.",
+ },
+ },
+ },
+ ],
+ contradictions: [],
+ },
+ }),
+ );
+
+ expect(result.obligations[0]?.diagnostics.map(({ code }) => code)).toEqual(
+ expect.arrayContaining([
+ "weak-fixture-authority",
+ "weak-verifier-authority",
+ ]),
+ );
+ });
+
+ it("propagates an open dependency through the full obligation chain", () => {
+ const evidence = createEvidence(
+ undefined,
+ { id: "fixture-chain", name: "Fixture chain", version: "1" },
+ {
+ predicateType: "rea.fixture-verification/v1",
+ operation: "run_fixture_verifier",
+ parameters: {},
+ result: { passed: true },
+ confidence: "observed",
+ authority: "shipped-artifact",
+ },
+ );
+ const ids = ["obl.chain.a", "obl.chain.b", "obl.chain.c"] as const;
+ const reviewed = ids.map((id, index) => ({
+ ...reviewedObligation(id, evidence.evidence_id),
+ dependency_obligation_ids:
+ index === 0 ? [ids[1]] : index === 1 ? [ids[2]] : ["obl.chain.missing"],
+ }));
+ const bindings = reviewed.map((obligation) => ({
+ obligation_id: obligation.obligation_id,
+ owner: {
+ module_path: `src/${obligation.obligation_id}.ts`,
+ symbol: "verify",
+ owner_sha256: "6".repeat(64),
+ },
+ parser_type: null,
+ original_cases: [
+ {
+ kind: "positive" as const,
+ evidence_id: evidence.evidence_id,
+ location: "/fixture/positive",
+ },
+ ],
+ fixtures: [
+ {
+ fixture_id: `fixture.${obligation.obligation_id}`,
+ case_kind: "positive" as const,
+ authority: "unit" as const,
+ evidence_ids: [evidence.evidence_id],
+ },
+ ],
+ verifier: {
+ verifier_id: `verifier.${obligation.obligation_id}`,
+ claim_id: `claim.${obligation.obligation_id}`,
+ command: "npm test -- fixture-chain",
+ authority: "unit" as const,
+ status: "pass" as const,
+ result_evidence_id: evidence.evidence_id,
+ enumerated_obligation_ids: [obligation.obligation_id],
+ nondeterminism: {
+ mode: "total-order" as const,
+ specification: "Fixture execution is ordered.",
+ },
+ },
+ }));
+ const result = build(
+ request([evidence], {
+ reviewed_obligations: reviewed,
+ manifest: { schema_version: 1, bindings, contradictions: [] },
+ }),
+ );
+
+ expect(result.obligations.map(({ status }) => status)).toEqual([
+ "blocked",
+ "blocked",
+ "blocked",
+ ]);
+ expect(
+ result.obligations.map(({ diagnostics }) =>
+ diagnostics.map(({ code }) => code),
+ ),
+ ).toEqual([
+ ["dependency-open"],
+ ["dependency-open"],
+ ["dependency-missing"],
+ ]);
+ });
+
it("fails closed on parser gaps, ambiguous ownership, and contradiction", () => {
const original = createEvidence(
undefined,