fix(native): bound metadata projection and compact Mach-O bind runs

Validation: integrated changes passed formatting, typecheck, lint, resolved module-boundary verification and git diff --check. Tests and real-provider workflows were not run.
This commit is contained in:
morluto
2026-10-11 00:03:19 +08:00
parent 0f0d6e4d43
commit 5d0a883605
3 changed files with 130 additions and 34 deletions
+21 -12
View File
@@ -1,13 +1,16 @@
import { createHash } from "node:crypto";
import { open } from "node:fs/promises";
import { constants } from "node:fs";
import {
objcSwiftMetadataSchema,
nativeDispatchMetadataResultSchema,
type ObjcSwiftMetadata,
} from "../domain/native/objcSwiftMetadata.js";
import type { BinaryTarget } from "../domain/binaryTargetTypes.js";
import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
import {
AnalysisCancelledError,
AnalysisResourceConstraintError,
} from "../domain/analysisErrorCore.js";
import { openRegularFile } from "../filesystem/RegularFile.js";
import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
import { pushDispatchCoverage } from "./AppleDispatchCoverage.js";
import { parsePointerFixups } from "./AppleMachoFixups.js";
@@ -173,19 +176,25 @@ export const inspectAppleDispatchMetadata = async (
) => {
if (target.kind !== "executable" || target.format !== "mach-o")
throw new TypeError("Apple dispatch metadata requires a Mach-O target");
const handle = await open(
target.path,
constants.O_RDONLY | constants.O_NOFOLLOW,
);
const maximumBytes = 64 * 1024 * 1024;
const capacityError = () =>
new AnalysisResourceConstraintError(
"inspect_native_dispatch_metadata",
"memory",
"Apple static metadata input exceeds its 64 MiB snapshot budget",
{ input_bytes: maximumBytes },
);
const handle = await openRegularFile(target.path, {
symlinks: "reject",
signal,
});
try {
const before = await handle.stat();
if (!before.isFile() || before.size > 64 * 1024 * 1024)
throw new RangeError(
"Apple metadata target must be a regular file no larger than 64 MiB",
);
if (before.size > maximumBytes) throw capacityError();
if (signal?.aborted)
throw new AnalysisCancelledError("inspect_native_dispatch_metadata");
const bytes = await handle.readFile({ signal });
const bytes = await readBoundedFileBytes(handle, maximumBytes, signal);
if (bytes === undefined) throw capacityError();
const digest = createHash("sha256").update(bytes).digest("hex");
if (digest !== target.sha256)
throw new EvidenceIntegrityError(
+70 -13
View File
@@ -69,6 +69,13 @@ interface Import {
readonly addend: bigint;
}
interface BindRun {
readonly start: bigint;
count: bigint;
readonly stride: bigint;
readonly binding: Import;
}
/** Library ordinal to install name; 0 and negative ordinals are special lookups. */
const libraryName = (
ordinal: number,
@@ -307,6 +314,7 @@ const sleb = (bytes: Buffer, cursor: { at: number }, end: number): bigint => {
/** Registers of the `LC_DYLD_INFO` bind state machine. */
interface BindState {
ordinal: number;
segmentIndex: number;
symbol: string;
weak: boolean;
addend: bigint;
@@ -351,6 +359,7 @@ const setBindRegister = (
const segment = image.segments[immediate];
if (segment === undefined)
throw new RangeError("Bind segment index is out of range");
state.segmentIndex = immediate;
state.address = segment.address + uleb(bytes, cursor, end);
return true;
}
@@ -368,7 +377,7 @@ const setBindRegister = (
const readBindStream = (
image: FixupImage,
range: FixupCommands["binds"][number],
binds: Map<bigint, Import>,
binds: BindRun[],
): void => {
const { bytes } = image;
const end = range.offset + range.size;
@@ -377,13 +386,27 @@ const readBindStream = (
const cursor = { at: range.offset };
const state: BindState = {
ordinal: 0,
segmentIndex: -1,
symbol: "",
weak: false,
addend: 0n,
address: 0n,
};
const bind = (skip: bigint): void => {
binds.set(state.address, {
const preflightRun = (count: bigint, skip: bigint): void => {
if (count === 0n) return;
const segment = image.segments[state.segmentIndex];
if (segment === undefined)
throw new RangeError("Bind location has no selected segment");
const stride = 8n + skip;
const end = state.address + (count - 1n) * stride + 8n;
if (state.address < segment.address || end > segment.address + segment.size)
throw new RangeError("Bind expansion leaves its file-backed segment");
};
const bind = (count: bigint, skip: bigint): void => {
if (count === 0n) return;
preflightRun(count, skip);
const stride = 8n + skip;
const binding: Import = {
symbol: state.symbol,
library:
range.stream === "weak"
@@ -391,8 +414,22 @@ const readBindStream = (
: libraryName(state.ordinal, image.dylibs),
weak: state.weak,
addend: state.addend,
});
state.address += 8n + skip;
};
const previous = binds.at(-1);
if (
previous !== undefined &&
previous.stride === stride &&
previous.start + previous.count * stride === state.address &&
previous.binding.symbol === binding.symbol &&
previous.binding.library === binding.library &&
previous.binding.weak === binding.weak &&
previous.binding.addend === binding.addend
) {
previous.count += count;
} else {
binds.push({ start: state.address, count, stride, binding });
}
state.address += count * stride;
};
while (cursor.at < end) {
const byte = bytes[cursor.at++] ?? 0;
@@ -403,18 +440,22 @@ const readBindStream = (
if (range.stream !== "lazy") return;
break;
case 0x90:
bind(0n);
bind(1n, 0n);
break;
case 0xa0:
bind(uleb(bytes, cursor, end));
bind(1n, uleb(bytes, cursor, end));
break;
case 0xb0:
bind(BigInt(byte & 0x0f) * 8n);
bind(1n, BigInt(byte & 0x0f) * 8n);
break;
case 0xc0: {
if (range.stream === "lazy")
throw new RangeError(
"Lazy bind streams do not support repeated bind opcodes",
);
const count = uleb(bytes, cursor, end);
const skip = uleb(bytes, cursor, end);
for (let index = 0n; index < count; index++) bind(skip);
bind(count, skip);
break;
}
default:
@@ -451,7 +492,7 @@ export const parsePointerFixups = (
unreadRebaseBytes,
decode: (_address, raw) => ({ kind: "rebase", target: raw }),
};
const binds = new Map<bigint, Import>();
const binds: BindRun[] = [];
const failures: string[] = [];
for (const stream of commands.binds)
try {
@@ -471,10 +512,26 @@ export const parsePointerFixups = (
examined: commands.binds.length,
unreadRebaseBytes,
decode(address, raw) {
const bound = binds.get(address);
return bound === undefined
let match: BindRun | undefined;
for (const run of binds) {
const { start, count, stride } = run;
const distance = address - start;
if (
distance >= 0n &&
distance % stride === 0n &&
distance / stride < count
) {
if (match !== undefined)
return {
kind: "unsupported",
reason: `Ambiguous bind records target pointer location 0x${address.toString(16)}`,
};
match = run;
}
}
return match === undefined
? { kind: "rebase", target: raw }
: { kind: "bind", ...bound };
: { kind: "bind", ...match.binding };
},
};
};
+39 -9
View File
@@ -1,6 +1,7 @@
import { createHash } from "node:crypto";
import { setImmediate } from "node:timers/promises";
import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
import { jsonParts } from "../../domain/jsonSerialization.js";
import type {
InspectPeResourcesInput,
PeResourceIdentity,
@@ -20,6 +21,15 @@ const METADATA_BYTES = 8 * 1024 * 1024;
const limit = (message: string): never => {
throw new ArtifactReaderFailure("limit", message);
};
/** Count bytes through the canonical bounded JSON writer. */
const jsonBytes = (value: unknown, maximum: number): number => {
let size = 0;
for (const part of jsonParts(value)) {
size += Buffer.byteLength(part, "utf8");
if (size > maximum) return size;
}
return size;
};
const identityKey = (id: PeResourceIdentity): string =>
id.kind === "id" ? `id:${String(id.id)}` : `name:${id.utf16le_hex}`;
@@ -38,13 +48,27 @@ export const parsePeResources = async (
const names = new Map<number, PeResourceIdentity>();
let examined = 0;
let metadataBytes = 0;
const account = (value: unknown): void => {
metadataBytes += Buffer.byteLength(JSON.stringify(value));
if (metadataBytes > METADATA_BYTES)
const ensureCapacity = (projectedBytes: number): void => {
if (metadataBytes + projectedBytes > METADATA_BYTES)
limit(
"PE resource metadata exceeds the 8 MiB complete-result allocation budget.",
);
};
const accountBytes = (projectedBytes: number): void => {
ensureCapacity(projectedBytes);
metadataBytes += projectedBytes;
};
const account = (value: unknown): void => {
// Rows are retained in arrays; reserve a separator along with each row.
accountBytes(jsonBytes(value, METADATA_BYTES - metadataBytes - 1) + 1);
};
const reserveDecodedName = (utf16Units: number): void => {
// A JSON string can need six ASCII bytes per UTF-16 code unit (for example,
// a control character encoded as `\\u0000`). The original spelling and
// its hex form are both retained in the result.
const projectedBytes = 10 * utf16Units + 256;
ensureCapacity(projectedBytes);
};
const root = layout.size === 0 ? 0 : layout.map(layout.rva, layout.size);
const relative = (at: number, length: number): number => {
if (at > layout.size - length || at < 0)
@@ -70,7 +94,9 @@ export const parsePeResources = async (
if (previous !== undefined) return previous;
if (at % 2 !== 0) peFailure("Unaligned PE resource name.");
const start = relative(at, 2);
const length = bytes.readUInt16LE(start) * 2;
const utf16Units = bytes.readUInt16LE(start);
reserveDecodedName(utf16Units);
const length = utf16Units * 2;
relative(at, 2 + length);
const raw = bytes.subarray(start + 2, start + 2 + length);
const value: PeResourceIdentity = {
@@ -80,7 +106,6 @@ export const parsePeResources = async (
location: recordRange(start, 2 + length, "name"),
};
names.set(at, value);
account(value);
return value;
};
const visit = async (
@@ -110,8 +135,8 @@ export const parsePeResources = async (
named_entries: named,
id_entries: ids,
};
directories.push(directory);
account(directory);
directories.push(directory);
const keys = new Set<string>();
const nested = new Set([...ancestors, at]);
for (let index = 0; index < count; index++) {
@@ -168,8 +193,8 @@ export const parsePeResources = async (
sha256: "0".repeat(64),
},
};
resources.push(resource);
account(resource);
resources.push(resource);
}
}
};
@@ -197,7 +222,7 @@ export const parsePeResources = async (
}
resource.payload.sha256 = digest;
}
const iconGroups = readIconGroups(bytes, resources, account);
const iconGroups = readIconGroups(bytes, resources, account, ensureCapacity);
const report: PeResources = {
artifact,
format: layout.format,
@@ -225,7 +250,7 @@ export const parsePeResources = async (
],
};
signal?.throwIfAborted();
if (Buffer.byteLength(JSON.stringify(report)) > METADATA_BYTES)
if (jsonBytes(report, METADATA_BYTES) > METADATA_BYTES)
limit("PE resource result exceeds the 8 MiB allocation budget.");
return report;
};
@@ -252,6 +277,7 @@ const readIconGroups = (
bytes: Buffer,
resources: PeResources["resources"],
account: (value: unknown) => void,
ensureCapacity: (projectedBytes: number) => void,
): PeResources["icon_groups"] => {
const imagesById = new Map<number, PeResources["resources"]>();
for (const resource of resources) {
@@ -289,6 +315,9 @@ const readIconGroups = (
(resource) =>
identityKey(resource.language) === identityKey(group.language),
);
// Indices are uint32 values and each needs at most ten decimal digits
// plus a comma. Check the expanded candidate list before allocating it.
ensureCapacity(302 + candidates.length * 11);
const declaredBytes = bytes.readUInt32LE(at + 8);
const image = {
location: { offset: at, bytes: 14 },
@@ -310,6 +339,7 @@ const readIconGroups = (
account(image);
images.push(image);
}
account({ resource_index: group.index, images: [] });
return { resource_index: group.index, images };
});
};