rea-agents 4.1.0 → 5.0.0

package/dist/dotnet/ManagedNativeBoundaryHelpers.js

@@ -1,4 +1,4 @@
-import { managedNativeBoundaryInspectionSchema, } from "../domain/managedArtifact.js";
+import { managedNativeBoundaryInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import {} from "./ManagedMetadataLayout.js";
 import { metadataRowCursor, metadataCodedToken, metadataToken, readMetadataString, } from "./ManagedMetadataHeaps.js";
 import { managedTableRowCounts } from "./ManagedMetadataInventory.js";
@@ -217,17 +217,19 @@ const boundaryKind = (pinvokeDeclared, codeType, managedKind) => {
         return "unmanaged-method";
     return "mixed-or-unknown";
 };
+/** CLI header facets of a PE without an admitted CLI header. */
+export const NO_CLI_NATIVE = {
+    il_only: false,
+    requires_32bit: false,
+    strong_name_signed: false,
+    native_entry_point: false,
+    ready_to_run_signature: false,
+    managed_native_header_rva: 0,
+    managed_native_header_size: 0,
+};
 export const cliNative = (pe) => {
     if (pe.cli === null)
-        return {
-            il_only: false,
-            requires_32bit: false,
-            strong_name_signed: false,
-            native_entry_point: false,
-            ready_to_run_signature: false,
-            managed_native_header_rva: 0,
-            managed_native_header_size: 0,
-        };
+        return NO_CLI_NATIVE;
     return {
         il_only: (pe.cli.flags & 0x0000_0001) !== 0,
         requires_32bit: (pe.cli.flags & 0x0000_0002) !== 0,
@@ -238,6 +240,14 @@ export const cliNative = (pe) => {
         managed_native_header_size: pe.cli.managedNativeHeader.size,
     };
 };
+/** Summarize declaration counts with the native facets of the CLI header. */
+export const nativeBoundarySummary = (native, counts) => ({
+    ...counts,
+    ready_to_run: native.ready_to_run_signature,
+    mixed_mode_or_native_header: native.managed_native_header_rva !== 0 ||
+        native.managed_native_header_size !== 0 ||
+        native.native_entry_point,
+});
 export const buildNativeBoundaryInspection = ({ target, bytes, layout, inventory, moduleRefs, imports, implementations, native, issues, }) => managedNativeBoundaryInspectionSchema.parse({
     artifact: {
         path: target.path,
@@ -260,15 +270,11 @@ export const buildNativeBoundaryInspection = ({ target, bytes, layout, inventory
     module_refs: moduleRefs,
     pinvoke_imports: imports,
     native_implementations: implementations,
-    summary: {
+    summary: nativeBoundarySummary(native, {
         module_ref_count: moduleRefs.length,
         pinvoke_import_count: imports.length,
         native_implementation_count: implementations.length,
-        ready_to_run: native.ready_to_run_signature,
-        mixed_mode_or_native_header: native.managed_native_header_rva !== 0 ||
-            native.managed_native_header_size !== 0 ||
-            native.native_entry_point,
-    },
+    }),
     coverage: {
         state: issues.length === 0 ? "complete" : "partial",
         issues,

package/dist/dotnet/ManagedNativeBoundaryInspector.js

@@ -1,54 +1,55 @@
-import { managedNativeBoundaryInspectionSchema, } from "../domain/managedArtifact.js";
+import { managedNativeBoundaryInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
 import { readManagedPeLayout, } from "./ManagedPeReader.js";
 import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
-import { buildNativeBoundaryInspection, cliNative, nativeImplementations, parseFields, parseImplMaps, parseMethods, parseModuleRefs, } from "./ManagedNativeBoundaryHelpers.js";
-const emptyInspection = (target, bytes, classification, issues = []) => managedNativeBoundaryInspectionSchema.parse({
-    artifact: {
-        path: target.path,
-        sha256: target.sha256,
-        byte_length: bytes.length,
-        format: "pe",
-    },
-    module: null,
-    metadata: {
-        status: classification === "malformed" || classification === "not-available"
-            ? "malformed"
-            : "absent",
-        version: null,
-        table_row_counts: {},
-    },
-    identity_scope: {
-        token_identity: "build-local",
-        requires_artifact_sha256: target.sha256,
-        requires_mvid: null,
-    },
-    cli_native: {
-        il_only: false,
-        requires_32bit: false,
-        strong_name_signed: false,
-        native_entry_point: false,
-        ready_to_run_signature: false,
-        managed_native_header_rva: 0,
-        managed_native_header_size: 0,
-    },
-    module_refs: [],
-    pinvoke_imports: [],
-    native_implementations: [],
-    summary: {
-        module_ref_count: 0,
-        pinvoke_import_count: 0,
-        native_implementation_count: 0,
-        ready_to_run: false,
-        mixed_mode_or_native_header: false,
-    },
-    coverage: { state: classification, issues },
-    limitations: [
-        "No CLI data was admitted; native boundary declarations are unavailable.",
-        "Static inspection does not load or execute target code, so native export resolution is not performed.",
-    ],
-});
+import { buildNativeBoundaryInspection, cliNative, NO_CLI_NATIVE, nativeBoundarySummary, nativeImplementations, parseFields, parseImplMaps, parseMethods, parseModuleRefs, } from "./ManagedNativeBoundaryHelpers.js";
+/**
+ * Report a PE whose CLI metadata is absent or cannot be admitted. `native`
+ * holds the CLI header facts when the header itself was admitted; otherwise
+ * the header is absent (`not-managed`) or unreadable (`malformed`).
+ */
+const emptyInspection = (target, bytes, classification, { native = null, issues = [], } = {}) => {
+    const header = native ?? NO_CLI_NATIVE;
+    return managedNativeBoundaryInspectionSchema.parse({
+        artifact: {
+            path: target.path,
+            sha256: target.sha256,
+            byte_length: bytes.length,
+            format: "pe",
+        },
+        module: null,
+        metadata: {
+            status: classification === "malformed" ? "malformed" : "absent",
+            version: null,
+            table_row_counts: {},
+        },
+        identity_scope: {
+            token_identity: "build-local",
+            requires_artifact_sha256: target.sha256,
+            requires_mvid: null,
+        },
+        cli_native: header,
+        module_refs: [],
+        pinvoke_imports: [],
+        native_implementations: [],
+        summary: nativeBoundarySummary(header, {
+            module_ref_count: 0,
+            pinvoke_import_count: 0,
+            native_implementation_count: 0,
+        }),
+        coverage: { state: "unavailable", issues },
+        limitations: [
+            "No CLI metadata was admitted; native boundary declarations are unavailable.",
+            ...(native === null && classification === "malformed"
+                ? [
+                    "The CLI header was not admitted, so cli_native and the summary's ready_to_run and mixed_mode_or_native_header values are defaults, not observations.",
+                ]
+                : []),
+            "Static inspection does not load or execute target code, so native export resolution is not performed.",
+        ],
+    });
+};
 const readBoundaryInventory = (bytes, pe, cli) => {
     const metadataOffset = pe.rvaToOffset(cli.metadata.rva, cli.metadata.size, "cli.metadata");
     const layout = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size);
@@ -68,10 +69,12 @@ export const inspectManagedNativeBoundariesBytes = (bytes, target) => {
     catch (cause) {
         if (!(cause instanceof ManagedReaderFailure))
             throw cause;
-        return emptyInspection(target, bytes, "malformed", [cause.issue]);
+        return emptyInspection(target, bytes, "malformed", {
+            issues: [cause.issue],
+        });
     }
     if (pe.cli === null)
-        return emptyInspection(target, bytes, pe.cliDirectoryPresent ? "malformed" : "not-managed", pe.cliIssue === null ? [] : [pe.cliIssue]);
+        return emptyInspection(target, bytes, pe.cliDirectoryPresent ? "malformed" : "not-managed", { issues: pe.cliIssue === null ? [] : [pe.cliIssue] });
     let layout;
     let inventory;
     try {
@@ -80,7 +83,10 @@ export const inspectManagedNativeBoundariesBytes = (bytes, target) => {
     catch (cause) {
         if (!(cause instanceof ManagedReaderFailure))
             throw cause;
-        return emptyInspection(target, bytes, "malformed", [cause.issue]);
+        return emptyInspection(target, bytes, "malformed", {
+            native: cliNative(pe),
+            issues: [cause.issue],
+        });
     }
     const heapExtent = Math.max(layout.strings.size, layout.blob.size);
     const moduleRefs = parseModuleRefs(bytes, layout, heapExtent);

package/dist/dotnet/ManagedStaticProvider.js

@@ -2,8 +2,8 @@ import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
-import { MANAGED_STATIC_PROVIDER } from "../application/InvestigationProviders.js";
-import { MANAGED_TOOL_CONTRACTS, managedArtifactInputSchema, managedMemberInputSchema, managedNativeBoundaryInputSchema, } from "../contracts/managedToolContracts.js";
+import { MANAGED_STATIC_PROVIDER_IDENTITY as IDENTITY, managedStaticCapabilities, } from "./ManagedStaticProviderMetadata.js";
+import { MANAGED_TOOL_CONTRACTS, managedArtifactInputSchema, managedMemberInputSchema, managedNativeBoundaryInputSchema, } from "../contracts/managed/managedToolContracts.js";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../domain/analysisErrorCore.js";
 import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
@@ -11,25 +11,9 @@ import { err, ok } from "../domain/result.js";
 import { inspectManagedArtifactBytes } from "./ManagedArtifactInspector.js";
 import { inspectManagedMembersBytes } from "./ManagedMemberInspector.js";
 import { inspectManagedNativeBoundariesBytes } from "./ManagedNativeBoundaryInspector.js";
-const IDENTITY = Object.freeze(MANAGED_STATIC_PROVIDER);
 /** Execution-free managed PE/CLI auxiliary provider. */
 export class ManagedStaticProvider {
-    #capabilities = Object.freeze(MANAGED_TOOL_CONTRACTS.map((contract) => Object.freeze({
-        provider: IDENTITY,
-        operation: contract.name,
-        available: true,
-        reason: null,
-        effects: Object.freeze({
-            mutatesArtifact: false,
-            launchesProcess: false,
-            mayShowUi: false,
-            mayAccessNetwork: false,
-            mayWriteFilesystem: false,
-            changesPermissions: false,
-            requiresRoot: false,
-        }),
-        limitations: limitationsFor(contract.name),
-    })));
+    #capabilities = managedStaticCapabilities();
     identity() {
         return IDENTITY;
     }
@@ -108,20 +92,6 @@ const hashManagedSource = async (path, signal) => {
     return { byteLength, sha256: digest.digest("hex") };
 };
 const isManagedOperation = (operation) => MANAGED_TOOL_CONTRACTS.some(({ name }) => name === operation);
-const limitationsFor = (operation) => Object.freeze(operation === "inspect_managed_artifact"
-    ? [
-        "This capability inventories PE/CLI identity only; inspect_managed_members admits metadata members, signatures, and CIL anchors.",
-        "It never loads the target assembly, resolves dependencies through a CLR, decompiles C#, or executes target code.",
-    ]
-    : operation === "inspect_managed_native_boundaries"
-        ? [
-            "This capability inventories managed declarations for native boundaries only; native exports, thunks, and addresses require separate native-provider evidence.",
-            "It never loads the target assembly, resolves dependencies through a CLR, decompiles C#, or executes target code.",
-        ]
-        : [
-            "This capability decodes PE/CLI metadata members, signatures, and file-backed method bodies; decompiled C# reconstruction and cross-build member comparison are separate operations.",
-            "It never loads the target assembly, resolves dependencies through a CLR, decompiles C#, or executes target code.",
-        ]);
 const inspectManagedOperation = (operation, parameters, bytes, target) => {
     if (operation === "inspect_managed_artifact") {
         managedArtifactInputSchema.parse(parameters);

package/dist/dotnet/ManagedStaticProviderMetadata.js

@@ -0,0 +1,36 @@
+import { MANAGED_STATIC_PROVIDER } from "../application/InvestigationProviders.js";
+import { MANAGED_TOOL_CONTRACTS, } from "../contracts/managed/managedToolContracts.js";
+/** Identity of execution-free managed metadata observations. */
+export const MANAGED_STATIC_PROVIDER_IDENTITY = Object.freeze(MANAGED_STATIC_PROVIDER);
+const IDENTITY = MANAGED_STATIC_PROVIDER_IDENTITY;
+/** Declare managed metadata coverage without opening or loading an assembly. */
+export const managedStaticCapabilities = () => Object.freeze(MANAGED_TOOL_CONTRACTS.map((contract) => Object.freeze({
+    provider: IDENTITY,
+    operation: contract.name,
+    available: true,
+    reason: null,
+    effects: Object.freeze({
+        mutatesArtifact: false,
+        launchesProcess: false,
+        mayShowUi: false,
+        mayAccessNetwork: false,
+        mayWriteFilesystem: false,
+        changesPermissions: false,
+        requiresRoot: false,
+    }),
+    limitations: limitationsFor(contract.name),
+})));
+const limitationsFor = (operation) => Object.freeze(operation === "inspect_managed_artifact"
+    ? [
+        "This capability inventories PE/CLI identity only; inspect_managed_members admits metadata members, signatures, and CIL anchors.",
+        "It never loads the target assembly, resolves dependencies through a CLR, decompiles C#, or executes target code.",
+    ]
+    : operation === "inspect_managed_native_boundaries"
+        ? [
+            "This capability inventories managed declarations for native boundaries only; native exports, thunks, and addresses require separate native-provider evidence.",
+            "It never loads the target assembly, resolves dependencies through a CLR, decompiles C#, or executes target code.",
+        ]
+        : [
+            "This capability decodes PE/CLI metadata members, signatures, and file-backed method bodies; decompiled C# reconstruction and cross-build member comparison are separate operations.",
+            "It never loads the target assembly, resolves dependencies through a CLR, decompiles C#, or executes target code.",
+        ]);

package/dist/evaluation/CodexAgentEval.js

@@ -1,3 +1,4 @@
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const record = (value) => isRecord(value) ? value : undefined;
 const textValue = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
@@ -9,7 +10,7 @@ const canonicalValue = (value) => {
     if (object === undefined)
         return value;
     return Object.fromEntries(Object.entries(object)
-        .sort(([left], [right]) => left.localeCompare(right))
+        .sort(([left], [right]) => compareUnicodeCodePoints(left, right))
         .map(([key, child]) => [key, canonicalValue(child)]));
 };
 const evidenceIdsFrom = (value) => {

package/dist/firmware/FirmwareProvider.js

@@ -1,7 +1,7 @@
 import { join, isAbsolute } from "node:path";
 import { z } from "zod";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
-import { firmwareResultSchemas, } from "../domain/firmwareAnalysis.js";
+import { firmwareResultSchemas, } from "../domain/firmware/firmwareAnalysis.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
@@ -9,7 +9,8 @@ import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { err, ok } from "../domain/result.js";
 import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
 import { publishFirmwareExtraction } from "./FirmwarePublication.js";
-import { FIRMWARE_LIMITS, FIRMWARE_RELEASES, BINWALK_PROVIDER_IDENTITY, UNBLOB_PROVIDER_IDENTITY, } from "./FirmwareRelease.js";
+import { FIRMWARE_LIMITS, BINWALK_PROVIDER_IDENTITY, UNBLOB_PROVIDER_IDENTITY, } from "./FirmwareRelease.js";
+import { admitFirmwareVersion } from "./FirmwareVersion.js";
 import { resolveFirmwareCommand, runFirmwareCommand, readFirmwareCommandReport, } from "./FirmwareCommand.js";
 import { inventoryFirmwareOutput, snapshotFirmware } from "./FirmwareFiles.js";
 import { normalizeBinwalkReport, normalizeUnblobReport, } from "./FirmwareReports.js";
@@ -94,15 +95,14 @@ export class FirmwareProvider {
             });
             const versionRun = await run(["--version"]);
             const version = versionRun.stdout.text.trim();
-            const expected = FIRMWARE_RELEASES[engineName].version;
-            if (versionRun.stdout.bytes > 1024 ||
-                (engineName === "binwalk"
-                    ? version !== `binwalk ${expected}`
-                    : version !== expected))
-                throw new AnalysisCapabilityUnavailableError(engineName, request.operation, `Unsupported tool version ${version}; this adapter is verified against ${expected}`);
+            if (versionRun.stdout.bytes > 1024)
+                throw new AnalysisCapabilityUnavailableError(engineName, request.operation, `Tool version banner is ${String(versionRun.stdout.bytes)} bytes; expected a short ${engineName} version line.`);
+            const admitted = admitFirmwareVersion(engineName, version);
+            if (admitted.status === "unsupported" || admitted.status === "unresolved")
+                throw new AnalysisCapabilityUnavailableError(engineName, request.operation, admitted.message);
             const engine = {
                 name: engineName,
-                version: expected,
+                version: admitted.version,
                 executable_path: command.command,
                 executable_sha256: command.sha256,
                 source_revision: null,
@@ -189,12 +189,18 @@ export class FirmwareProvider {
                 });
                 raw = { report, execution: processRun, version_execution: versionRun };
             }
-            outcome = ok(createAnalysisExecution(result, engineName === "binwalk"
+            const catalog = engineName === "binwalk"
                 ? BINWALK_PROVIDER_IDENTITY
-                : UNBLOB_PROVIDER_IDENTITY, {
+                : UNBLOB_PROVIDER_IDENTITY;
+            outcome = ok(createAnalysisExecution(result, { ...catalog, version: admitted.version }, {
                 subject: target.subject,
                 rawResult: raw,
-                limitations,
+                limitations: [
+                    ...limitations,
+                    ...(admitted.status === "compatible"
+                        ? [admitted.limitation]
+                        : []),
+                ],
                 locations: [
                     {
                         kind: "file-offset-range",

package/dist/firmware/FirmwarePublication.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { SafeOutputTree } from "../artifacts/SafeOutputTree.js";
 import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
 import { ProviderCleanupError } from "../domain/providerCleanupError.js";
-import { firmwareResultSchemas } from "../domain/firmwareAnalysis.js";
+import { firmwareResultSchemas } from "../domain/firmware/firmwareAnalysis.js";
 import { hashFirmwareFile } from "./FirmwareFiles.js";
 /** Publish verified regular files, preserving links as metadata and rolling back failed writes. */
 export const publishFirmwareExtraction = async (context) => {

package/dist/firmware/FirmwareRelease.js

@@ -11,7 +11,7 @@ export const FIRMWARE_RELEASES = {
         repository: "https://github.com/onekey-sec/unblob",
     },
 };
-/** Catalog identities; Evidence uses the version observed from the executed tool. */
+/** Catalog identity for the verified Binwalk release. Evidence replaces version with the observed banner. */
 export const BINWALK_PROVIDER_IDENTITY = {
     id: "binwalk",
     name: "Binwalk",

package/dist/firmware/FirmwareReports.js

@@ -38,6 +38,13 @@ const stat = z.object({
     is_link: z.boolean(),
     link_target: z.string().nullable(),
 });
+const multiFile = z.object({
+    id: z.string(),
+    handler_name: z.string(),
+    name: z.string(),
+    paths: z.array(z.string()),
+    extraction_reports: z.array(jsonValueSchema),
+});
 const hashes = z.object({ sha256: digestSchema });
 const region = z.object({
     id: z.string(),
@@ -159,6 +166,11 @@ export const normalizeUnblobReport = (raw, context) => {
                         : null,
                 });
             }
+            if (item.__typename__ === "MultiFileReport") {
+                const parsed = multiFile.parse(item);
+                if (parsed.extraction_reports.length > 0)
+                    diagnostics.push({ input_path: path, report: item });
+            }
         }
     }
     const recordsByPath = new Map(records.map((record) => [record.task.path, record.task]));

package/dist/firmware/FirmwareVersion.js

@@ -0,0 +1,80 @@
+import { FIRMWARE_RELEASES } from "./FirmwareRelease.js";
+const TOKEN = /^(\d+)\.(\d+)\.(\d+)([-+][0-9A-Za-z.-]+)?$/u;
+const parseToken = (token) => {
+    const match = TOKEN.exec(token);
+    if (match === null)
+        return undefined;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    if (![major, minor, patch].every((part) => Number.isSafeInteger(part)))
+        return undefined;
+    const suffix = match[4] ?? "";
+    return { major, minor, patch, suffix, token };
+};
+const verifiedRelease = (engine) => {
+    const parsed = parseToken(FIRMWARE_RELEASES[engine].version);
+    if (parsed === undefined || parsed.suffix !== "")
+        throw new Error(`FIRMWARE_RELEASES.${engine}.version is not a release number`);
+    return parsed;
+};
+/** Caller-facing engine name. */
+export const firmwareEngineLabel = (engine) => {
+    switch (engine) {
+        case "binwalk":
+            return "Binwalk";
+        case "unblob":
+            return "Unblob";
+        default: {
+            const unreachable = engine;
+            return unreachable;
+        }
+    }
+};
+/** Release line accepted for one engine, such as `Binwalk 3.1.x`. */
+export const firmwareReleaseLine = (engine) => {
+    const verified = verifiedRelease(engine);
+    return `${firmwareEngineLabel(engine)} ${String(verified.major)}.${String(verified.minor)}.x`;
+};
+/**
+ * Classify a `--version` banner against the audited release line.
+ * Binwalk prints `binwalk <version>`; Unblob prints the version alone.
+ */
+export const admitFirmwareVersion = (engine, banner) => {
+    const token = versionToken(engine, banner);
+    const parsed = token === undefined ? undefined : parseToken(token);
+    const verified = verifiedRelease(engine);
+    const accepted = `accepted releases are ${firmwareReleaseLine(engine)} (verified with ${verified.token})`;
+    if (parsed === undefined)
+        return {
+            status: "unresolved",
+            message: `Unsupported tool version ${banner.length === 0 ? "missing" : banner}; ${accepted}.`,
+        };
+    if (parsed.major !== verified.major || parsed.minor !== verified.minor)
+        return {
+            status: "unsupported",
+            message: `Unsupported tool version ${banner}; ${accepted}.`,
+        };
+    if (parsed.token === verified.token)
+        return { status: "verified", version: parsed.token };
+    const line = `${String(verified.major)}.${String(verified.minor)}.x`;
+    return {
+        status: "compatible",
+        version: parsed.token,
+        limitation: `This session uses ${firmwareEngineLabel(engine)} ${parsed.token}. The report parser is verified against ${verified.token}; other ${line} builds are accepted and the observed version is reported.`,
+    };
+};
+const versionToken = (engine, banner) => {
+    switch (engine) {
+        case "binwalk":
+            return banner.startsWith("binwalk ")
+                ? banner.slice("binwalk ".length)
+                : undefined;
+        case "unblob":
+            return banner;
+        default: {
+            const unreachable = engine;
+            return unreachable;
+        }
+    }
+};