Skip to content

armgit / rea

Public Imported from GitHub
0

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

5.8 KB
Raw Blame
import { expect, it } from "vitest";

import { inspectAnalysisView } from "../analysisView/AnalysisViewService.js";
import { ARTIFACT_COMPARISON_EXAMPLE } from "../../contracts/artifactComparisonExample.js";
import { artifactInventorySummaryViewResultSchema } from "../../domain/analysisView/analysisView.js";
import {
  createEvidence,
  parseEvidence,
  type Evidence,
} from "../../domain/evidence.js";
import {
  EvidenceIntegrityError,
  EvidenceReferenceError,
} from "../../domain/evidenceErrors.js";
import { resolveArtifactComparisonEvidence } from "./ArtifactComparisonEvidence.js";

const artifactSummary = async () => {
  const parent = ARTIFACT_COMPARISON_EXAMPLE.left;
  const summary = await inspectAnalysisView(
    {
      source: { kind: "inline", evidence: parent },
      view: { kind: "summary" },
    },
    (evidenceId) => (evidenceId === parent.evidence_id ? parent : undefined),
  );
  if (!summary.ok) throw summary.error;
  return { parent, summary: summary.value };
};

const recreateSummary = (
  summary: Evidence,
  normalizedResult: Evidence["normalized_result"],
  parameters: Evidence["parameters"] = summary.parameters,
): Evidence => {
  if (summary.subject === null)
    throw new Error("artifact summary fixture must identify its subject");
  return createEvidence(
    {
      path: summary.subject.local_path,
      sha256: summary.subject.digest.sha256,
      format: summary.subject.format,
      ...(summary.subject.architecture === null
        ? {}
        : { architecture: summary.subject.architecture }),
    },
    summary.provider,
    {
      predicateType: summary.predicate_type,
      operation: summary.operation,
      parameters,
      result: normalizedResult,
      ...(summary.analysis_profile === null
        ? {}
        : { analysisProfile: summary.analysis_profile }),
      rawResult: summary.raw_result,
      confidence: summary.confidence,
      authority: summary.authority,
      environment: summary.environment,
      limitations: summary.limitations,
      ...(summary.relationship_coverage === null
        ? {}
        : { relationshipCoverage: summary.relationship_coverage }),
      locations: summary.locations,
      evidenceLinks: summary.evidence_links,
    },
  );
};

it("reports a missing retained parent instead of treating summary facts as inventory", async () => {
  const { summary } = await artifactSummary();
  const resolved = resolveArtifactComparisonEvidence(summary, undefined);
  expect(resolved.ok).toBe(false);
  if (!resolved.ok) {
    expect(resolved.error).toBeInstanceOf(EvidenceReferenceError);
    expect(resolved.error).toMatchObject({ reason: "missing" });
  }
});

it("uses retained Evidence resolution to reject a mismatched parent identity", async () => {
  const { summary } = await artifactSummary();
  const otherParent = ARTIFACT_COMPARISON_EXAMPLE.right;
  const resolved = resolveArtifactComparisonEvidence(
    summary,
    () => otherParent,
  );
  expect(resolved.ok).toBe(false);
  if (!resolved.ok) {
    expect(resolved.error).toBeInstanceOf(EvidenceReferenceError);
    expect(resolved.error).toMatchObject({ reason: "identity_mismatch" });
  }
});

it("rejects a summary that declares the wrong parent operation", async () => {
  const { parent, summary } = await artifactSummary();
  const summaryResult = artifactInventorySummaryViewResultSchema.parse(
    summary.normalized_result,
  );
  const normalizedResult = {
    ...summaryResult,
    parent_operation: "inspect_artifact",
  };
  const forged = recreateSummary(summary, normalizedResult);
  const resolved = resolveArtifactComparisonEvidence(forged, (evidenceId) =>
    evidenceId === parent.evidence_id ? parent : undefined,
  );
  expect(resolved.ok).toBe(false);
  if (!resolved.ok)
    expect(resolved.error).toBeInstanceOf(EvidenceIntegrityError);
});

it("rejects summary parameters that do not identify the projected parent", async () => {
  const { parent, summary } = await artifactSummary();
  const forged = recreateSummary(summary, summary.normalized_result, {
    ...summary.parameters,
    parent_evidence_id: `ev_${"f".repeat(64)}`,
  });
  const resolved = resolveArtifactComparisonEvidence(forged, (evidenceId) =>
    evidenceId === parent.evidence_id ? parent : undefined,
  );
  expect(resolved.ok).toBe(false);
  if (!resolved.ok)
    expect(resolved.error).toBeInstanceOf(EvidenceIntegrityError);
});

it("rejects summary facts that do not reproject from the complete parent", async () => {
  const { parent, summary } = await artifactSummary();
  const summaryResult = artifactInventorySummaryViewResultSchema.parse(
    summary.normalized_result,
  );
  const normalizedResult = {
    ...summaryResult,
    summary: {
      ...summaryResult.summary,
      available_counts: {
        ...summaryResult.summary.available_counts,
        nodes: summaryResult.summary.available_counts.nodes + 1,
      },
    },
  };
  const forged = recreateSummary(summary, normalizedResult);
  const resolved = resolveArtifactComparisonEvidence(forged, (evidenceId) =>
    evidenceId === parent.evidence_id ? parent : undefined,
  );
  expect(resolved.ok).toBe(false);
  if (!resolved.ok)
    expect(resolved.error).toBeInstanceOf(EvidenceIntegrityError);
});

it("accepts display-only subject changes excluded from Evidence identity", async () => {
  const { parent, summary } = await artifactSummary();
  if (summary.subject === null)
    throw new Error("artifact summary fixture must identify its subject");
  const displayOnly = parseEvidence({
    ...summary,
    subject: {
      ...summary.subject,
      name: "renamed.app",
      local_path: "/display-only/renamed.app",
    },
  });
  const resolved = resolveArtifactComparisonEvidence(
    displayOnly,
    (evidenceId) => (evidenceId === parent.evidence_id ? parent : undefined),
  );
  expect(resolved).toEqual({ ok: true, value: parent });
});