Skip to content

armgit / rea

Public Imported from GitHub
0

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

fix(apple): budget Interface Builder decoding and projection

morlutodbcf8c33915d
diff --git a/docs/native-investigation.md b/docs/native-investigation.md
index e385ef9e5..e9b0f1b0f 100644
--- a/docs/native-investigation.md
+++ b/docs/native-investigation.md
@@ -48,7 +48,16 @@ complete observation.
BOM and rejects malformed byte sequences, unsupported encoding declarations,
and declarations that disagree with the detected encoding. It never substitutes
UTF-8 for a declared encoding it cannot process. Archive and evidence digests
- still identify the original serialized bytes.
+ still identify the original serialized bytes. Interface Builder decoding
+ limits aggregate input archives to 32 MiB.
+ Before decoding, it also bounds the serialized structure: expanded binary
+ plist references, NIB table records, XML elements and text, plus their
+ projected representations must fit the 256 MiB aggregate decode budget.
+ This is a format-derived representation estimate, not a process-wide heap
+ ceiling.
+ Archives beyond either aggregate budget are omitted with their paths and an
+ explicitly partial `archive_decode` facet; previously decoded documents and
+ their identities remain available.
- `inspect_native_dispatch_metadata` /
`rea inspect-native-dispatch-metadata <app-or-binary>` prefers a validated macOS Mach-O byte reader. It decodes
64-bit little-endian Objective-C class/metaclass records, superclass pointers,
diff --git a/src/artifacts/apple/InterfaceBuilderAnalysis.ts b/src/artifacts/apple/InterfaceBuilderAnalysis.ts
index a61da0f71..00b19fe15 100644
--- a/src/artifacts/apple/InterfaceBuilderAnalysis.ts
+++ b/src/artifacts/apple/InterfaceBuilderAnalysis.ts
@@ -8,6 +8,11 @@ import {
parseXmlPropertyList,
} from "../../domain/propertyListKeys.js";
import { decodeNibArchive, type NibArchiveDocument } from "./NibArchive.js";
+import {
+ estimatePropertyListDecodeBytes,
+ InterfaceBuilderDecodeBudget,
+ InterfaceBuilderDecodeBudgetExceeded,
+} from "./InterfaceBuilderDecodeBudget.js";
import type { ArtifactEntry } from "../ArtifactReader.js";
import {
buildInterfaceBuilderAnalysis,
@@ -23,7 +28,9 @@ import { jsonValueSchema, type JsonValue } from "../../domain/jsonValue.js";
import { decodeXmlPlistText } from "./XmlPropertyListText.js";
-const MAX_DOCUMENT_BYTES = 64 * 1024 * 1024;
+const MAX_AGGREGATE_INPUT_BYTES = 32 * 1024 * 1024;
+const MAX_AGGREGATE_DECODE_BYTES = 256 * 1024 * 1024;
+const MAX_REPORTED_OMITTED_ARCHIVES = 64;
/** Decode compiled Interface Builder archives from a local app bundle. */
export const analyzeInterfaceBuilderBundle = async (input: {
@@ -36,28 +43,84 @@ export const analyzeInterfaceBuilderBundle = async (input: {
const reader = new DirectoryArtifactReader(input.bundlePath);
const documents: InterfaceBuilderDocumentInput[] = [];
const invalid: string[] = [];
+ const omittedArchives: Array<{ path: string; reason: string }> = [];
+ let unreportedOmittedArchives = 0;
const incompleteHierarchies = new Map<string, number>();
const prototypeKeyOmissions = new Map<string, number>();
let omitted = 0;
let attempted = 0;
+ let candidates = 0;
+ let aggregateInputBytes = 0;
+ const decodeBudget = new InterfaceBuilderDecodeBudget(
+ MAX_AGGREGATE_DECODE_BYTES,
+ );
+ const recordOmittedArchive = (path: string, reason: string): void => {
+ if (omittedArchives.length < MAX_REPORTED_OMITTED_ARCHIVES)
+ omittedArchives.push({ path, reason });
+ else unreportedOmittedArchives += 1;
+ };
try {
for await (const entry of reader.entries(input.signal)) {
if (entry.kind !== "file" || !isInterfaceBuilderArchive(entry.path))
continue;
- if (attempted >= limits.max_documents) {
+ candidates += 1;
+ if (candidates > limits.max_documents) {
omitted += 1;
+ recordOmittedArchive(entry.path, "max_documents");
continue;
}
- attempted += 1;
try {
- const bytes = await readEntry(reader, entry, input.signal);
- const nib =
- bytes.subarray(0, 10).toString("ascii") === "NIBArchive"
- ? projectNibArchive(decodeNibArchive(bytes))
- : null;
+ const remainingInputBytes =
+ MAX_AGGREGATE_INPUT_BYTES - aggregateInputBytes;
+ if (
+ entry.declaredSize !== null &&
+ entry.declaredSize > remainingInputBytes
+ ) {
+ omitted += 1;
+ recordOmittedArchive(entry.path, "aggregate_decode_budget_exhausted");
+ continue;
+ }
+ attempted += 1;
+ const bytes = await readEntry(
+ reader,
+ entry,
+ input.signal,
+ remainingInputBytes,
+ );
+ aggregateInputBytes += bytes.length;
+ const isNibArchive =
+ bytes.subarray(0, 10).toString("ascii") === "NIBArchive";
+ let nib: ReturnType<typeof projectNibArchive> | null = null;
+ let xmlText: string | undefined;
+ if (isNibArchive) {
+ const documentBudget = new InterfaceBuilderDecodeBudget(
+ decodeBudget.remainingBytes,
+ );
+ nib = projectNibArchive(
+ decodeNibArchive(bytes, documentBudget),
+ documentBudget,
+ limits.max_objects,
+ );
+ decodeBudget.reserve(
+ documentBudget.usedBytes,
+ "NIBArchive representation exceeds the aggregate Interface Builder decode budget",
+ );
+ } else {
+ if (bytes.subarray(0, 8).toString("ascii") !== "bplist00")
+ xmlText = decodeXmlPlistText(bytes);
+ const decodedReservation = estimatePropertyListDecodeBytes(
+ bytes,
+ decodeBudget.remainingBytes,
+ xmlText,
+ );
+ decodeBudget.reserve(
+ decodedReservation,
+ "plist representation exceeds the aggregate Interface Builder decode budget",
+ );
+ }
const { value: raw, omittedPrototypeKeys } =
nib === null
- ? decodePlist(bytes)
+ ? decodePlist(bytes, xmlText)
: { value: nib.raw, omittedPrototypeKeys: 0 };
if (nib !== null && nib.omitted > 0)
incompleteHierarchies.set(entry.path, nib.omitted);
@@ -74,6 +137,11 @@ export const analyzeInterfaceBuilderBundle = async (input: {
});
} catch (cause: unknown) {
if (input.signal?.aborted === true) throw cause;
+ if (cause instanceof InterfaceBuilderDecodeBudgetExceeded) {
+ omitted += 1;
+ recordOmittedArchive(entry.path, cause.reason);
+ continue;
+ }
invalid.push(
`${entry.path}: ${cause instanceof Error ? cause.message : "archive decode failed"}`,
);
@@ -92,6 +160,8 @@ export const analyzeInterfaceBuilderBundle = async (input: {
incompleteHierarchies,
prototypeKeyOmissions,
invalid,
+ omittedArchives,
+ unreportedOmittedArchives,
attempted,
omitted,
});
@@ -103,13 +173,23 @@ const finalizeHierarchyCoverage = (
incompleteHierarchies: ReadonlyMap<string, number>;
prototypeKeyOmissions: ReadonlyMap<string, number>;
invalid: readonly string[];
+ omittedArchives: readonly { path: string; reason: string }[];
+ unreportedOmittedArchives: number;
attempted: number;
omitted: number;
},
) => {
- const { incompleteHierarchies, prototypeKeyOmissions, invalid } = counts;
+ const {
+ incompleteHierarchies,
+ prototypeKeyOmissions,
+ invalid,
+ omittedArchives,
+ unreportedOmittedArchives,
+ } = counts;
const archiveDecodePartial =
- invalid.length > 0 || prototypeKeyOmissions.size > 0;
+ invalid.length > 0 ||
+ prototypeKeyOmissions.size > 0 ||
+ omittedArchives.length > 0;
return {
...result,
documents: result.documents.map((document) => ({
@@ -139,12 +219,19 @@ const finalizeHierarchyCoverage = (
status: archiveDecodePartial
? ("partial" as const)
: ("complete" as const),
- reason:
- invalid.length > 0
- ? "one_or_more_archives_invalid"
- : prototypeKeyOmissions.size > 0
- ? "dictionary_entries_omitted"
- : null,
+ reason: omittedArchives.some(
+ ({ reason }) => reason === "aggregate_decode_budget_exhausted",
+ )
+ ? "aggregate_decode_budget_exhausted"
+ : omittedArchives.some(({ reason }) => reason === "max_documents")
+ ? "document_limit_reached"
+ : omittedArchives.length > 0
+ ? "archive_decode_budget_exhausted"
+ : invalid.length > 0
+ ? "one_or_more_archives_invalid"
+ : prototypeKeyOmissions.size > 0
+ ? "dictionary_entries_omitted"
+ : null,
examined: counts.attempted,
omitted: counts.omitted,
},
@@ -171,13 +258,70 @@ const finalizeHierarchyCoverage = (
...[...prototypeKeyOmissions].map(
([path, count]) => `${path}: ${omittedPrototypeKeysLimitation(count)}`,
),
+ ...omittedArchives.map(
+ ({ path, reason }) =>
+ `${path}: omitted because ${reason.replaceAll("_", " ")}.`,
+ ),
+ ...(unreportedOmittedArchives === 0
+ ? []
+ : [
+ `${unreportedOmittedArchives} additional omitted archive path(s) and their reasons were not retained; reporting is bounded to ${MAX_REPORTED_OMITTED_ARCHIVES} paths.`,
+ ]),
],
};
};
/** Project decoded NIB records into the same bounded graph input as ibtool. */
-const projectNibArchive = (archive: NibArchiveDocument) => {
+const projectNibArchive = (
+ archive: NibArchiveDocument,
+ budget: InterfaceBuilderDecodeBudget,
+ maxHierarchyNodes: number,
+) => {
const byId = new Map(archive.objects.map((object) => [object.id, object]));
+ const decodedStrings = new Map<number, string | null>();
+ const decodedString = (
+ objectId: number,
+ object: NibArchiveDocument["objects"][number],
+ ): string | null => {
+ if (decodedStrings.has(objectId))
+ return decodedStrings.get(objectId) ?? null;
+ const data = object.values["NS.bytes"];
+ if (typeof data !== "object" || data === null || Array.isArray(data)) {
+ decodedStrings.set(objectId, null);
+ return null;
+ }
+ const encoded = data.$nib_data_base64;
+ if (typeof encoded !== "string") {
+ decodedStrings.set(objectId, null);
+ return null;
+ }
+ budget.reserve(
+ 64 + encoded.length * 2,
+ "NIBArchive string projection exceeds the aggregate Interface Builder decode budget",
+ );
+ const value = Buffer.from(encoded, "base64").toString("utf8");
+ decodedStrings.set(objectId, value);
+ return value;
+ };
+ const reserveStringOccurrence = (value: string | null): string | null => {
+ if (value !== null)
+ budget.reserve(
+ 64 + value.length * 6,
+ "NIBArchive repeated string projection exceeds the aggregate Interface Builder decode budget",
+ );
+ return value;
+ };
+ let projectedFields = 0;
+ for (const object of archive.objects)
+ projectedFields += Object.keys(object.values).length;
+ budget.reserve(
+ archive.objects.length * 128 + projectedFields * 128,
+ "NIBArchive graph projection exceeds the aggregate Interface Builder decode budget",
+ );
+ budget.reserve(
+ archive.classes.length * 96,
+ "NIBArchive class projection exceeds the aggregate Interface Builder decode budget",
+ );
const dereference = (value: JsonValue | undefined): JsonValue | undefined => {
if (typeof value !== "object" || value === null || Array.isArray(value))
return value;
@@ -186,12 +330,8 @@ const projectNibArchive = (archive: NibArchiveDocument) => {
const target = byId.get(ref);
if (target === undefined) return undefined;
if (target.class_name.replace(/\0+$/u, "") === "NSString") {
- const data = target.values["NS.bytes"];
- if (typeof data === "object" && data !== null && !Array.isArray(data)) {
- const encoded = data.$nib_data_base64;
- if (typeof encoded === "string")
- return Buffer.from(encoded, "base64").toString("utf8");
- }
+ const string = decodedString(ref, target);
+ if (string !== null) return reserveStringOccurrence(string);
}
return { objectID: String(ref) };
};
@@ -201,14 +341,8 @@ const projectNibArchive = (archive: NibArchiveDocument) => {
const ref = value.$nib_object_ref;
if (typeof ref !== "number") return null;
const target = byId.get(ref);
- const data = target?.values["NS.bytes"];
if (target?.class_name.replace(/\0+$/u, "") !== "NSString") return null;
- if (typeof data !== "object" || data === null || Array.isArray(data))
- return null;
- const encoded = data.$nib_data_base64;
- return typeof encoded === "string"
- ? Buffer.from(encoded, "base64").toString("utf8")
- : null;
+ return reserveStringOccurrence(decodedString(ref, target));
};
const runtimeClass = (objectId: number): string | null => {
const object = byId.get(objectId);
@@ -300,6 +434,7 @@ const projectNibArchive = (archive: NibArchiveDocument) => {
});
}
let hierarchyOmitted = 0;
+ let hierarchyNodeCount = 0;
const hierarchyFor = (
objectId: number,
seen: Set<number>,
@@ -309,11 +444,20 @@ const projectNibArchive = (archive: NibArchiveDocument) => {
hierarchyOmitted += 1;
return null;
}
+ if (hierarchyNodeCount >= maxHierarchyNodes) {
+ hierarchyOmitted += 1;
+ return null;
+ }
+ if (!budget.tryReserve(128)) {
+ hierarchyOmitted += 1;
+ return null;
+ }
const object = byId.get(objectId);
if (object === undefined) {
hierarchyOmitted += 1;
return null;
}
+ hierarchyNodeCount += 1;
const nextSeen = new Set(seen).add(objectId);
const children: NibHierarchyNode[] = [];
for (const [key, value] of Object.entries(object.values)) {
@@ -352,8 +496,15 @@ const projectNibArchive = (archive: NibArchiveDocument) => {
const viewHierarchy = projectNibViewHierarchy(
archive.objects,
new Set(Object.keys(objects).map(Number)),
+ () => budget.tryReserve(128),
+ maxHierarchyNodes,
+ );
+ const merged = mergeNibHierarchies(
+ hierarchy,
+ viewHierarchy.hierarchy ?? [],
+ () => budget.tryReserve(96),
+ maxHierarchyNodes,
);
- const merged = mergeNibHierarchies(hierarchy, viewHierarchy.hierarchy ?? []);
return {
omitted: viewHierarchy.omitted + hierarchyOmitted + merged.omitted,
raw: jsonValueSchema.parse({
@@ -376,10 +527,12 @@ const readEntry = async (
reader: DirectoryArtifactReader,
entry: ArtifactEntry,
signal?: AbortSignal,
+ maxInputBytes = MAX_AGGREGATE_INPUT_BYTES,
): Promise<Buffer> => {
- if (entry.declaredSize !== null && entry.declaredSize > MAX_DOCUMENT_BYTES)
- throw new RangeError(
- "archive exceeds the 64 MiB per-document decode limit",
+ if (entry.declaredSize !== null && entry.declaredSize > maxInputBytes)
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "archive exceeds the aggregate Interface Builder decode budget",
);
const stream = await reader.open(entry, signal);
const chunks: Buffer[] = [];
@@ -389,10 +542,11 @@ const readEntry = async (
? chunk
: Buffer.from(chunk as Uint8Array);
length += bytes.length;
- if (length > MAX_DOCUMENT_BYTES) {
+ if (length > maxInputBytes) {
stream.destroy();
- throw new RangeError(
- "archive exceeded the 64 MiB per-document decode limit",
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "archive exceeded the aggregate Interface Builder decode budget",
);
}
chunks.push(bytes);
@@ -403,10 +557,11 @@ const readEntry = async (
/** Project decoded plist data and dates while retaining omitted-key coverage. */
const decodePlist = (
bytes: Buffer,
+ xmlText?: string,
): { readonly value: JsonValue; readonly omittedPrototypeKeys: number } => {
const { value, omittedPrototypeKeys } =
bytes.subarray(0, 8).toString("ascii") === "bplist00"
? { value: parseBinary(bytes), omittedPrototypeKeys: 0 }
- : parseXmlPropertyList(decodeXmlPlistText(bytes));
+ : parseXmlPropertyList(xmlText ?? decodeXmlPlistText(bytes));
return { value: projectPlistValue(value).value, omittedPrototypeKeys };
};
diff --git a/src/artifacts/apple/InterfaceBuilderDecodeBudget.ts b/src/artifacts/apple/InterfaceBuilderDecodeBudget.ts
new file mode 100644
index 000000000..6ec1c82f1
--- /dev/null
+++ b/src/artifacts/apple/InterfaceBuilderDecodeBudget.ts
@@ -0,0 +1,250 @@
+import { decodeXmlPlistText } from "./XmlPropertyListText.js";
+
+/** Reason reported when an archive would exceed the shared decoding budget. */
+export type InterfaceBuilderBudgetReason = "aggregate_decode_budget_exhausted";
+
+/** A named resource-limit failure that keeps budget exhaustion out of decode errors. */
+export class InterfaceBuilderDecodeBudgetExceeded extends Error {
+ constructor(
+ readonly reason: InterfaceBuilderBudgetReason,
+ message: string,
+ ) {
+ super(message);
+ this.name = "InterfaceBuilderDecodeBudgetExceeded";
+ }
+}
+
+/** Shared byte budget for decoder records and projected archive data. */
+export class InterfaceBuilderDecodeBudget {
+ readonly #initialBytes: number;
+ #remainingBytes: number;
+
+ constructor(maxBytes: number) {
+ this.#initialBytes = maxBytes;
+ this.#remainingBytes = maxBytes;
+ }
+
+ /** Representation bytes still available for the current inspection. */
+ get remainingBytes(): number {
+ return this.#remainingBytes;
+ }
+
+ /** Representation bytes reserved so far. */
+ get usedBytes(): number {
+ return this.#initialBytes - this.#remainingBytes;
+ }
+
+ /** Reserve representation bytes before allocation, or report exhaustion. */
+ reserve(bytes: number, message: string): void {
+ if (
+ !Number.isSafeInteger(bytes) ||
+ bytes < 0 ||
+ bytes > this.#remainingBytes
+ )
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ message,
+ );
+ this.#remainingBytes -= bytes;
+ }
+
+ /** Reserve bytes for an optional projection without throwing on exhaustion. */
+ tryReserve(bytes: number): boolean {
+ if (
+ !Number.isSafeInteger(bytes) ||
+ bytes < 0 ||
+ bytes > this.#remainingBytes
+ )
+ return false;
+ this.#remainingBytes -= bytes;
+ return true;
+ }
+}
+
+/** Preflight the representation created by the pinned plist decoder. */
+export const estimatePropertyListDecodeBytes = (
+ bytes: Buffer,
+ maxBytes: number,
+ xmlText?: string,
+): number => {
+ const estimate =
+ bytes.subarray(0, 8).toString("ascii") === "bplist00"
+ ? estimateBinaryPlistExpansion(bytes, maxBytes)
+ : estimateXmlPlistExpansion(bytes, maxBytes, xmlText);
+ if (estimate > maxBytes)
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "plist representation exceeds the aggregate Interface Builder decode budget",
+ );
+ return estimate;
+};
+
+const estimateXmlPlistExpansion = (
+ bytes: Buffer,
+ maxBytes: number,
+ xmlText?: string,
+): number => {
+ const xml = xmlText ?? decodeXmlPlistText(bytes);
+ if (/<!DOCTYPE\b[^>]*\[/iu.test(xml))
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "XML plist internal entity expansion exceeds the aggregate Interface Builder decode budget",
+ );
+ const elementPattern =
+ /<!--[^]*?-->|<!\[CDATA\[[^]*?\]\]>|<!DOCTYPE[^>]*>|<\?[^]*?\?>|<\/?[A-Za-z][^>]*>/giu;
+ const decodedSourceBytes = xml.length * 2;
+ let elementCount = 0;
+ let xmlDepth = 0;
+ for (const match of xml.matchAll(elementPattern)) {
+ const token = match[0] ?? "";
+ if (
+ token.startsWith("<!--") ||
+ token.startsWith("<![CDATA[") ||
+ token.startsWith("<!DOCTYPE") ||
+ token.startsWith("<?")
+ )
+ continue;
+ elementCount += 1;
+ if (token.startsWith("</")) xmlDepth -= 1;
+ else if (!token.endsWith("/>")) {
+ xmlDepth += 1;
+ if (xmlDepth > 128)
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "XML plist nesting exceeds the aggregate Interface Builder decode budget",
+ );
+ }
+ if (decodedSourceBytes * 2 + elementCount * 128 > maxBytes)
+ return maxBytes + 1;
+ }
+ return decodedSourceBytes * 2 + elementCount * 128;
+};
+
+/** Count every expanded binary-plist reference before calling plist.parseBinary. */
+const estimateBinaryPlistExpansion = (
+ bytes: Buffer,
+ maxBytes: number,
+): number => {
+ if (bytes.length < 40)
+ throw new TypeError("binary plist trailer is truncated");
+ const trailer = bytes.length - 32;
+ const offsetSize = bytes[trailer + 6] ?? 0;
+ const referenceSize = bytes[trailer + 7] ?? 0;
+ if (
+ ![1, 2, 4, 8].includes(offsetSize) ||
+ ![1, 2, 4, 8].includes(referenceSize)
+ )
+ throw new TypeError("binary plist trailer integer sizes are invalid");
+ const readInteger = (offset: number, size: number): number => {
+ if (offset < 0 || size < 1 || offset + size > bytes.length) return -1;
+ let value = 0;
+ for (let index = 0; index < size; index += 1)
+ value = value * 256 + (bytes[offset + index] ?? 0);
+ return Number.isSafeInteger(value) ? value : -1;
+ };
+ const objectCount = readInteger(trailer + 8, 8);
+ const topObject = readInteger(trailer + 16, 8);
+ const offsetTable = readInteger(trailer + 24, 8);
+ if (
+ objectCount < 1 ||
+ topObject < 0 ||
+ topObject >= objectCount ||
+ offsetTable < 8 ||
+ offsetTable + objectCount * offsetSize > trailer
+ )
+ throw new TypeError("binary plist trailer or object table is invalid");
+ let estimate = bytes.length * 2 + objectCount * 16;
+ if (estimate > maxBytes)
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "binary plist object table exceeds the aggregate Interface Builder decode budget",
+ );
+
+ const active = new Set<number>();
+ const pending: Array<{ object: number; depth: number; exit: boolean }> = [
+ { object: topObject, depth: 0, exit: false },
+ ];
+ let pendingObjectCount = 1;
+ while (pending.length > 0) {
+ const entry = pending.pop();
+ if (entry === undefined) break;
+ if (entry.exit) {
+ active.delete(entry.object);
+ continue;
+ }
+ pendingObjectCount -= 1;
+ if (entry.depth > 128)
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "binary plist nesting exceeds the aggregate Interface Builder decode budget",
+ );
+ if (active.has(entry.object))
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "binary plist reference cycle exceeds the aggregate Interface Builder decode budget",
+ );
+ estimate += 96;
+ if (estimate > maxBytes)
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "binary plist reference expansion exceeds the aggregate Interface Builder decode budget",
+ );
+ const offset = readInteger(
+ offsetTable + entry.object * offsetSize,
+ offsetSize,
+ );
+ if (offset < 8 || offset >= offsetTable)
+ throw new TypeError("binary plist object offset is invalid");
+ const marker = bytes[offset] ?? 0;
+ const type = marker >> 4;
+ let size = marker & 0x0f;
+ let cursor = offset + 1;
+ if (size === 0x0f && type !== 0 && type !== 8) {
+ const extMarker = bytes[cursor] ?? 0;
+ if (extMarker >> 4 !== 1 || (extMarker & 0x0f) > 3)
+ throw new TypeError("binary plist extended object size is invalid");
+ cursor += 1;
+ const integerSize = 1 << (extMarker & 0x0f);
+ size = readInteger(cursor, integerSize);
+ cursor += integerSize;
+ if (size < 0 || cursor > offsetTable)
+ throw new TypeError("binary plist extended object size is invalid");
+ }
+ if (type === 4 || type === 5 || type === 6) {
+ const byteLength = type === 6 ? size * 2 : size;
+ if (cursor + byteLength > offsetTable)
+ throw new TypeError("binary plist scalar object is truncated");
+ estimate += type === 4 ? Math.ceil((size * 4) / 3) : byteLength * 2;
+ if (estimate > maxBytes)
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "binary plist scalar expansion exceeds the aggregate Interface Builder decode budget",
+ );
+ continue;
+ }
+ if (type !== 10 && type !== 13) continue;
+ const childCount = type === 13 ? size * 2 : size;
+ const refsEnd = cursor + childCount * referenceSize;
+ if (!Number.isSafeInteger(refsEnd) || refsEnd > offsetTable)
+ throw new TypeError("binary plist reference table is truncated");
+ const availableNodes = Math.floor((maxBytes - estimate) / 96);
+ if (childCount > availableNodes - pendingObjectCount)
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "binary plist reference expansion exceeds the aggregate Interface Builder decode budget",
+ );
+ active.add(entry.object);
+ pending.push({ object: entry.object, depth: entry.depth, exit: true });
+ for (let index = childCount - 1; index >= 0; index -= 1) {
+ const reference = readInteger(
+ cursor + index * referenceSize,
+ referenceSize,
+ );
+ if (reference < 0 || reference >= objectCount)
+ throw new TypeError("binary plist reference is invalid");
+ pending.push({ object: reference, depth: entry.depth + 1, exit: false });
+ }
+ pendingObjectCount += childCount;
+ }
+ return estimate;
+};
diff --git a/src/artifacts/apple/NibArchive.test.ts b/src/artifacts/apple/NibArchive.test.ts
index a77121785..10579d011 100644
--- a/src/artifacts/apple/NibArchive.test.ts
+++ b/src/artifacts/apple/NibArchive.test.ts
@@ -2,6 +2,38 @@ import { describe, expect, it } from "vitest";
import { decodeNibArchive } from "./NibArchive.js";
import { encodeNibArchiveFixture as encodeArchive } from "./NibArchive.fixture.js";
+import { InterfaceBuilderDecodeBudgetExceeded } from "./InterfaceBuilderDecodeBudget.js";
+
+const archiveWithOverlappingObjectRanges = (objectCount: number): Buffer => {
+ const objectRecords = Buffer.alloc(objectCount * 3);
+ for (let index = 0; index < objectCount; index += 1)
+ objectRecords.set([0x80, 0x80, 0x81], index * 3);
+ const keys = Buffer.from([0x81, 0x78]);
+ const values = Buffer.from([0x80, 10, 0, 0, 0, 0]);
+ const className = Buffer.from("NSObject");
+ const classes = Buffer.concat([
+ Buffer.from([className.length]),
+ Buffer.from([0x80]),
+ className,
+ ]);
+ const objectsOffset = 50;
+ const keysOffset = objectsOffset + objectRecords.length;
+ const valuesOffset = keysOffset + keys.length;
+ const classesOffset = valuesOffset + values.length;
+ const header = Buffer.alloc(50);
+ header.write("NIBArchive", 0, "ascii");
+ header.writeUInt32LE(1, 10);
+ header.writeUInt32LE(10, 14);
+ header.writeUInt32LE(objectCount, 18);
+ header.writeUInt32LE(objectsOffset, 22);
+ header.writeUInt32LE(1, 26);
+ header.writeUInt32LE(keysOffset, 30);
+ header.writeUInt32LE(1, 34);
+ header.writeUInt32LE(valuesOffset, 38);
+ header.writeUInt32LE(1, 42);
+ header.writeUInt32LE(classesOffset, 46);
+ return Buffer.concat([header, objectRecords, keys, values, classes]);
+};
describe("NIBArchive decoder", () => {
it("decodes bounded object, key, class, and reference tables", () => {
@@ -45,4 +77,19 @@ describe("NIBArchive decoder", () => {
/object reference/u,
);
});
+
+ it("budgets overlapping object value ranges before materializing their fields", () => {
+ const archive = archiveWithOverlappingObjectRanges(700_000);
+ let thrown: unknown;
+ try {
+ decodeNibArchive(archive);
+ } catch (cause: unknown) {
+ thrown = cause;
+ }
+ expect(thrown).toBeInstanceOf(InterfaceBuilderDecodeBudgetExceeded);
+ expect(thrown).toHaveProperty(
+ "message",
+ expect.stringMatching(/projected field ranges/u),
+ );
+ });
});
diff --git a/src/artifacts/apple/NibArchive.ts b/src/artifacts/apple/NibArchive.ts
index c383922d1..8ed48b765 100644
--- a/src/artifacts/apple/NibArchive.ts
+++ b/src/artifacts/apple/NibArchive.ts
@@ -1,8 +1,12 @@
import type { JsonValue } from "../../domain/jsonValue.js";
import { TextDecoder } from "node:util";
+import {
+ InterfaceBuilderDecodeBudget,
+ InterfaceBuilderDecodeBudgetExceeded,
+} from "./InterfaceBuilderDecodeBudget.js";
const MAGIC = Buffer.from("NIBArchive", "ascii");
-const MAX_RECORDS = 1_000_000;
+const DEFAULT_DECODE_BUDGET_BYTES = 128 * 1024 * 1024;
interface NibObjectRecord {
readonly class_index: number;
@@ -31,7 +35,10 @@ export interface NibArchiveDocument {
}
/** Decode Apple's length-prefixed NIBArchive representation without loading UI classes. */
-export const decodeNibArchive = (bytes: Buffer): NibArchiveDocument => {
+export const decodeNibArchive = (
+ bytes: Buffer,
+ budget = new InterfaceBuilderDecodeBudget(DEFAULT_DECODE_BUDGET_BYTES),
+): NibArchiveDocument => {
if (bytes.length < 50 || !bytes.subarray(0, MAGIC.length).equals(MAGIC))
throw new TypeError("NIBArchive magic or header is invalid");
@@ -57,6 +64,19 @@ export const decodeNibArchive = (bytes: Buffer): NibArchiveDocument => {
valuesOffset,
classesOffset,
]);
+ const projectedFieldCount = preflightProjectedFieldCount(
+ bytes,
+ objectsOffset,
+ keysOffset,
+ objectCount,
+ valueCount,
+ classCount,
+ budget.remainingBytes,
+ );
+ budget.reserve(
+ objectCount * 96 + projectedFieldCount * 96,
+ "NIBArchive object and projected field counts exceed the aggregate Interface Builder decode budget",
+ );
const objectRecords = parseObjects(
bytes,
objectsOffset,
@@ -65,8 +85,21 @@ export const decodeNibArchive = (bytes: Buffer): NibArchiveDocument => {
valueCount,
classCount,
);
- const keys = parseStrings(bytes, keysOffset, valuesOffset, keyCount, "key");
- const classes = parseClasses(bytes, classesOffset, bytes.length, classCount);
+ const keys = parseStrings(
+ bytes,
+ keysOffset,
+ valuesOffset,
+ keyCount,
+ "key",
+ budget,
+ );
+ const classes = parseClasses(
+ bytes,
+ classesOffset,
+ bytes.length,
+ classCount,
+ budget,
+ );
const neededValues = valueIndexes(objectRecords, valueCount);
const values = parseValues(
bytes,
@@ -75,6 +108,7 @@ export const decodeNibArchive = (bytes: Buffer): NibArchiveDocument => {
valueCount,
keyCount,
neededValues,
+ budget,
);
for (const { value } of values.values()) {
if (
@@ -158,18 +192,64 @@ const parseObjects = (
return output;
};
+const preflightProjectedFieldCount = (
+ bytes: Buffer,
+ start: number,
+ end: number,
+ objectCount: number,
+ valueCount: number,
+ classCount: number,
+ maxBytes: number,
+): number => {
+ if (objectCount * 96 > maxBytes)
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "NIBArchive object count exceeds the aggregate Interface Builder decode budget",
+ );
+ const cursor = { offset: start };
+ let projectedFields = 0;
+ for (let index = 0; index < objectCount; index += 1) {
+ const classIndex = readVarint(bytes, cursor, end);
+ const valueStart = readVarint(bytes, cursor, end);
+ const fieldCount = readVarint(bytes, cursor, end);
+ if (
+ classIndex >= classCount ||
+ valueStart > valueCount ||
+ fieldCount > valueCount - valueStart
+ )
+ throw new TypeError(
+ `NIBArchive object ${index} references an invalid table range`,
+ );
+ projectedFields += fieldCount;
+ if (
+ !Number.isSafeInteger(projectedFields) ||
+ projectedFields * 96 > maxBytes - objectCount * 96
+ )
+ throw new InterfaceBuilderDecodeBudgetExceeded(
+ "aggregate_decode_budget_exhausted",
+ "NIBArchive projected field ranges exceed the aggregate Interface Builder decode budget",
+ );
+ }
+ return projectedFields;
+};
+
const parseStrings = (
bytes: Buffer,
start: number,
end: number,
count: number,
label: string,
+ budget: InterfaceBuilderDecodeBudget,
): string[] => {
const cursor = { offset: start };
const output: string[] = [];
for (let index = 0; index < count; index += 1) {
const length = readVarint(bytes, cursor, end);
const next = checkedEnd(cursor.offset, length, end, `${label} ${index}`);
+ budget.reserve(
+ 32 + length * 2,
+ `NIBArchive ${label} strings exceed the aggregate Interface Builder decode budget`,
+ );
const value = decodeUtf8(bytes, cursor.offset, next, `${label} ${index}`);
cursor.offset = next;
output.push(value);
@@ -182,6 +262,7 @@ const parseClasses = (
start: number,
end: number,
count: number,
+ budget: InterfaceBuilderDecodeBudget,
): string[] => {
const cursor = { offset: start };
const output: string[] = [];
@@ -200,6 +281,10 @@ const parseClasses = (
);
cursor.offset += extraCount * 4;
const next = checkedEnd(cursor.offset, length, end, `class ${index}`);
+ budget.reserve(
+ 32 + length * 2,
+ "NIBArchive class names exceed the aggregate Interface Builder decode budget",
+ );
const name = decodeUtf8(
bytes,
cursor.offset,
@@ -219,6 +304,7 @@ const parseValues = (
count: number,
keyCount: number,
needed: ReadonlySet<number>,
+ budget: InterfaceBuilderDecodeBudget,
): Map<number, NibValueRecord> => {
const cursor = { offset: start };
const output = new Map<number, NibValueRecord>();
@@ -230,8 +316,16 @@ const parseValues = (
);
ensureRange(cursor.offset, 1, end, `value ${index} type`);
const type = bytes[cursor.offset++] ?? -1;
- const value = readValue(bytes, cursor, end, type, index);
- if (needed.has(index)) output.set(index, { key_index: keyIndex, value });
+ if (!needed.has(index)) {
+ skipValue(bytes, cursor, end, type, index);
+ continue;
+ }
+ budget.reserve(
+ 64,
+ "NIBArchive decoded values exceed the aggregate Interface Builder decode budget",
+ );
+ const value = readValue(bytes, cursor, end, type, index, budget);
+ output.set(index, { key_index: keyIndex, value });
}
if (cursor.offset > end)
throw new TypeError("NIBArchive value table overlaps the next table");
@@ -244,6 +338,7 @@ const readValue = (
end: number,
type: number,
index: number,
+ budget: InterfaceBuilderDecodeBudget,
): JsonValue => {
switch (type) {
case 0:
@@ -299,6 +394,10 @@ const readValue = (
end,
`value ${index} data`,
);
+ budget.reserve(
+ 32 + Math.ceil((length * 4) / 3),
+ `NIBArchive data value ${index} exceeds the aggregate Interface Builder decode budget`,
+ );
const encoded = bytes.subarray(cursor.offset, next).toString("base64");
cursor.offset = next;
return { $nib_data_base64: encoded };
@@ -319,6 +418,57 @@ const readValue = (
}
};
+const skipValue = (
+ bytes: Buffer,
+ cursor: { offset: number },
+ end: number,
+ type: number,
+ index: number,
+): void => {
+ switch (type) {
+ case 0:
+ ensureRange(cursor.offset, 1, end, `value ${index}`);
+ cursor.offset += 1;
+ return;
+ case 1:
+ ensureRange(cursor.offset, 2, end, `value ${index}`);
+ cursor.offset += 2;
+ return;
+ case 2:
+ case 10:
+ ensureRange(cursor.offset, 4, end, `value ${index}`);
+ cursor.offset += 4;
+ return;
+ case 3:
+ case 7:
+ ensureRange(cursor.offset, 8, end, `value ${index}`);
+ cursor.offset += 8;
+ return;
+ case 6:
+ ensureRange(cursor.offset, 4, end, `value ${index}`);
+ cursor.offset += 4;
+ return;
+ case 4:
+ case 5:
+ case 9:
+ return;
+ case 8: {
+ const length = readVarint(bytes, cursor, end);
+ cursor.offset = checkedEnd(
+ cursor.offset,
+ length,
+ end,
+ `value ${index} data`,
+ );
+ return;
+ }
+ default:
+ throw new TypeError(
+ `NIBArchive value ${index} has unsupported type ${type}`,
+ );
+ }
+};
+
const valueIndexes = (
objects: readonly NibObjectRecord[],
total: number,
@@ -340,8 +490,8 @@ const valueIndexes = (
const readCount = (bytes: Buffer, offset: number, label: string): number => {
const count = readU32(bytes, offset);
- if (count > MAX_RECORDS)
- throw new TypeError(`NIBArchive ${label} count exceeds the decoder bound`);
+ if (count > bytes.length)
+ throw new TypeError(`NIBArchive ${label} count exceeds the archive length`);
return count;
};
diff --git a/src/artifacts/apple/NibViewHierarchy.ts b/src/artifacts/apple/NibViewHierarchy.ts
index 61c669e53..0d5aef0f6 100644
--- a/src/artifacts/apple/NibViewHierarchy.ts
+++ b/src/artifacts/apple/NibViewHierarchy.ts
@@ -10,6 +10,8 @@ export type NibHierarchyNode = {
export const projectNibViewHierarchy = (
objects: NibArchiveDocument["objects"],
retainedIds: ReadonlySet<number>,
+ reserveNode: () => boolean = () => true,
+ maxNodes = 20_000,
) => {
const { parents, involved, invalid } = collectNibParents(
objects,
@@ -32,7 +34,12 @@ export const projectNibViewHierarchy = (
while (pending.length > 0) {
const item = pending.pop();
if (item === undefined) break;
- if (visited.has(item.id) || item.depth > 128 || visited.size >= 20_000)
+ if (
+ visited.has(item.id) ||
+ item.depth > 128 ||
+ visited.size >= maxNodes ||
+ !reserveNode()
+ )
continue;
visited.add(item.id);
const node: NibHierarchyNode = { objectID: String(item.id), children: [] };
@@ -50,6 +57,8 @@ export const projectNibViewHierarchy = (
export const mergeNibHierarchies = (
legacy: NibHierarchyNode[],
recovered: NibHierarchyNode[],
+ reserveNode: () => boolean = () => true,
+ maxNodes = 20_000,
) => {
const existing = new Map<string, NibHierarchyNode>();
const owners = new Map<string, NibHierarchyNode[]>();
@@ -84,6 +93,10 @@ export const mergeNibHierarchies = (
if (entry === undefined) break;
let target = existing.get(entry.node.objectID);
if (target === undefined) {
+ if (existing.size >= maxNodes || !reserveNode()) {
+ omitted += 1;
+ continue;
+ }
target = { objectID: entry.node.objectID, children: [] };
existing.set(target.objectID, target);
entry.output.push(target);
diff --git a/tests/boundary/filesystem/interfaceBuilderBundle.test.ts b/tests/boundary/filesystem/interfaceBuilderBundle.test.ts
index 7caca996c..42d7b10a3 100644
--- a/tests/boundary/filesystem/interfaceBuilderBundle.test.ts
+++ b/tests/boundary/filesystem/interfaceBuilderBundle.test.ts
@@ -75,6 +75,27 @@ const keyedArchiveHierarchy = (
});
};
+const binaryPlistWithRepeatedReferences = (depth: number): Buffer => {
+ const encodedObjects = [Buffer.from([0x51, 0x78])];
+ for (let index = 1; index <= depth; index += 1)
+ encodedObjects.push(Buffer.from([0xa2, index - 1, index - 1]));
+ const header = Buffer.from("bplist00", "ascii");
+ const offsets: number[] = [];
+ let offset = header.length;
+ for (const object of encodedObjects) {
+ offsets.push(offset);
+ offset += object.length;
+ }
+ const offsetTable = Buffer.from(offsets);
+ const trailer = Buffer.alloc(32);
+ trailer[6] = 1;
+ trailer[7] = 1;
+ trailer.writeBigUInt64BE(BigInt(encodedObjects.length), 8);
+ trailer.writeBigUInt64BE(BigInt(depth), 16);
+ trailer.writeBigUInt64BE(BigInt(offset), 24);
+ return Buffer.concat([header, ...encodedObjects, offsetTable, trailer]);
+};
+
describe("compiled Interface Builder bundle reader", () => {
it("reads nib plist archives and reports provenance", async () => {
const root = await createTestTempDirectory("rea-ib-test-");
@@ -381,6 +402,173 @@ describe("flat Interface Builder plist values", () => {
});
});
+describe("bounded Interface Builder archive decoding", () => {
+ it("marks repeated NIB hierarchy references partial at the caller object limit", async () => {
+ const root = await createTestTempDirectory("rea-ib-repeated-hierarchy-");
+ const bundle = join(root, "Example.app");
+ await mkdir(bundle, { recursive: true });
+ const depth = 8;
+ const objects = [
+ { classIndex: 0, values: { NSRoot: { ref: 1 } } },
+ ...Array.from({ length: depth + 1 }, (_, index) => {
+ const viewId = 1 + index * 2;
+ return [
+ {
+ classIndex: 1,
+ values: index === depth ? {} : { subviews: { ref: viewId + 1 } },
+ },
+ ...(index === depth
+ ? []
+ : [
+ {
+ classIndex: 2,
+ values: {
+ first: { ref: viewId + 2 },
+ second: { ref: viewId + 2 },
+ },
+ },
+ ]),
+ ];
+ }).flat(),
+ ];
+ await writeFile(
+ join(bundle, "RepeatedHierarchy.nib"),
+ encodeNibArchiveFixture({
+ classes: ["NSIBObjectData", "UIView", "NSArray"],
+ objects,
+ }),
+ );
+
+ const result = await analyzeInterfaceBuilderBundle({
+ bundlePath: bundle,
+ targetSha256: "f".repeat(64),
+ limits: { max_objects: 16 },
+ });
+
+ expect(result.documents[0]?.hierarchy_complete).toBe(false);
+ expect(result.graph.coverage).toContainEqual(
+ expect.objectContaining({
+ facet: "hierarchy:RepeatedHierarchy.nib",
+ status: "partial",
+ reason: "serialized_view_hierarchy_incomplete",
+ }),
+ );
+ });
+
+ it("rejects a binary plist expansion before recursively materializing repeated references", async () => {
+ const root = await createTestTempDirectory("rea-ib-expansion-test-");
+ const bundle = join(root, "Example.app");
+ await mkdir(bundle, { recursive: true });
+ await writeFile(
+ join(bundle, "RepeatedReferences.nib"),
+ binaryPlistWithRepeatedReferences(32),
+ );
+
+ const result = await analyzeInterfaceBuilderBundle({
+ bundlePath: bundle,
+ targetSha256: "f".repeat(64),
+ });
+
+ expect(result.documents).toEqual([]);
+ expect(result.graph.coverage).toContainEqual(
+ expect.objectContaining({
+ facet: "archive_decode",
+ status: "partial",
+ reason: "aggregate_decode_budget_exhausted",
+ examined: 1,
+ omitted: 1,
+ }),
+ );
+ expect(result.limitations).toContain(
+ "RepeatedReferences.nib: omitted because aggregate decode budget exhausted.",
+ );
+ });
+
+ it("budgets repeated large NSString projections before retaining each field", async () => {
+ const root = await createTestTempDirectory("rea-ib-repeated-string-test-");
+ const bundle = join(root, "Example.app");
+ await mkdir(bundle, { recursive: true });
+ const largeString = "x".repeat(1024 * 1024);
+ const references = Object.fromEntries(
+ Array.from({ length: 50 }, (_, index) => [`title${index}`, { ref: 1 }]),
+ );
+ await writeFile(
+ join(bundle, "RepeatedString.nib"),
+ encodeNibArchiveFixture({
+ classes: ["UIView", "NSString"],
+ objects: [
+ { classIndex: 0, values: references },
+ { classIndex: 1, values: { "NS.bytes": largeString } },
+ ],
+ }),
+ );
+
+ const result = await analyzeInterfaceBuilderBundle({
+ bundlePath: bundle,
+ targetSha256: "f".repeat(64),
+ });
+
+ expect(result.documents).toEqual([]);
+ expect(result.graph.coverage).toContainEqual(
+ expect.objectContaining({
+ facet: "archive_decode",
+ status: "partial",
+ reason: "aggregate_decode_budget_exhausted",
+ examined: 1,
+ omitted: 1,
+ }),
+ );
+ expect(result.limitations).toContain(
+ "RepeatedString.nib: omitted because aggregate decode budget exhausted.",
+ );
+ });
+});
+
+describe("aggregate Interface Builder archive retention budget", () => {
+ it("keeps earlier documents when the aggregate decode reservation is exhausted", async () => {
+ const root = await createTestTempDirectory("rea-ib-budget-test-");
+ const bundle = join(root, "Example.app");
+ const resources = join(bundle, "Contents", "Resources");
+ await mkdir(resources, { recursive: true });
+ const padding = `<!--${"x".repeat(1024)}-->`.repeat(11 * 1024);
+ const valid = (name: string, body = "") =>
+ `<?xml version="1.0"?><plist version="1.0"><dict><key>document</key><string>${name}</string>${body}</dict></plist>`;
+ // XML data expands to a Uint8Array and then to a base64 JSON projection;
+ // this first valid document exercises expansion beyond the source bytes.
+ const expandedData = Buffer.alloc(1024 * 1024, 7).toString("base64");
+ await writeFile(
+ join(resources, "A.nib"),
+ valid("A", `<key>payload</key><data>${expandedData}</data>`),
+ );
+ await writeFile(join(resources, "B.nib"), valid("B", padding));
+ await writeFile(join(resources, "C.nib"), valid("C", padding));
+ await writeFile(join(resources, "D.nib"), valid("D", padding));
+
+ const result = await analyzeInterfaceBuilderBundle({
+ bundlePath: bundle,
+ targetSha256: "e".repeat(64),
+ });
+
+ expect(result.documents.map(({ relative_path }) => relative_path)).toEqual([
+ "Contents/Resources/A.nib",
+ "Contents/Resources/B.nib",
+ "Contents/Resources/C.nib",
+ ]);
+ expect(result.graph.coverage).toContainEqual(
+ expect.objectContaining({
+ facet: "archive_decode",
+ status: "partial",
+ reason: "aggregate_decode_budget_exhausted",
+ examined: 3,
+ omitted: 1,
+ }),
+ );
+ expect(result.limitations).toContain(
+ "Contents/Resources/D.nib: omitted because aggregate decode budget exhausted.",
+ );
+ });
+});
+
describe("bounded Interface Builder archive decoding", () => {
it("counts malformed archives against the document limit", async () => {
const root = await createTestTempDirectory("rea-ib-test-");