Skip to content

armgit / rea

Public Imported from GitHub
0

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

3.0 KB
Raw Blame
import type { AnalysisError } from "../../domain/analysisErrorBase.js";
import { createEvidence, type Evidence } from "../../domain/evidence.js";
import {
  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 } from "../workflowInputError.js";

const OPERATION = "import_managed_reconstruction" as const;

/** Validate the request envelope and authenticate its managed Evidence source once. */
export const resolveManagedReconstructionEvidenceInput = (
  rawInput: unknown,
): Result<ResolvedManagedReconstructionImport, AnalysisError> => {
  const parsed = managedReconstructionImportRequestSchema.safeParse(rawInput);
  if (!parsed.success)
    return err(requestInputError(OPERATION, parsed.error, rawInput));
  return resolveManagedReconstructionImport(parsed.data);
};

/** 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> => {
  const resolved = resolveManagedReconstructionEvidenceInput(rawInput);
  if (!resolved.ok) return resolved;
  return importManagedReconstructionEvidenceResolved(resolved.value);
};

const createManagedReconstructionEvidence = (
  input: ManagedReconstructionImportRequest,
  result: ManagedReconstructionImportResult,
): Evidence =>
  createEvidence(
    {
      path: result.static_observation.artifact_path,
      sha256: result.static_observation.artifact_sha256,
      format: "pe",
    },
    MANAGED_WORKFLOW_PROVIDER,
    {
      predicateType: "rea.managed-reconstruction-import",
      operation: OPERATION,
      parameters: {
        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: input.notes,
      },
      result,
      rawResult: null,
      confidence: "inferred",
      authority: "analyst-inference",
      environment: null,
      limitations: result.limitations,
      locations: [
        {
          kind: "artifact-path",
          path: result.static_observation.artifact_path,
        },
      ],
      evidenceLinks: result.evidence_links,
    },
  );