Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(plist): own XML values and numeric facts in one decoder
morluto7aa4b98c9829
diff --git a/docs/native-investigation.md b/docs/native-investigation.mdindex b9b010ed8..432f68efd 100644--- a/docs/native-investigation.md+++ b/docs/native-investigation.md@@ -587,6 +587,10 @@ digests identify the original serialized bytes.## Keyed archive integer precisionThe archive reader observes XML number element types and binary number markers.+XML values and their number facts are interpreted together from the validated+DOM. Hexadecimal `<integer>` text, including an optional sign, retains its value;+`<real>` text and CDATA segments are combined without inferring text from nested+elements. The XML path does not serialize or reparse character references.Integers beyond the exact range of a JSON number are reported with the originaldecimal text as `{ "$plist_type": "integer", "decimal": "<exact digits>" }` whenthat source value can be associated unambiguously. Integral real values remaindiff --git a/src/artifacts/apple/InterfaceBuilderAnalysis.ts b/src/artifacts/apple/InterfaceBuilderAnalysis.tsindex 86e8941c9..d48fba88d 100644--- a/src/artifacts/apple/InterfaceBuilderAnalysis.ts+++ b/src/artifacts/apple/InterfaceBuilderAnalysis.ts@@ -39,7 +39,6 @@ import { decodeXmlPlistText } from "../../domain/propertyListXmlText.js";import {decodeBinaryPlistNumbers,scanBinaryPlistNumberLiterals,- xmlPlistNumberLiterals,} from "./PlistNumberLiterals.js";import type { PlistNumberLiterals } from "../../domain/apple/plistNumbers.js";import {@@ -753,12 +752,13 @@ const decodePlist = (const binaryNumberMetadata = binary? scanBinaryPlistNumberLiterals(bytes): undefined;- const { value, omittedPrototypeKeys } = binary+ const { value, omittedPrototypeKeys, numberLiterals } = binary? {value: parseBinary(decodeBinaryPlistNumbers(bytes, binaryNumberMetadata!),),omittedPrototypeKeys: binaryPrototypeKeyObserved ? null : 0,+ numberLiterals: binaryNumberMetadata!.literals,}: parseXmlWithinDecodeBudget(xmlText ?? decodeXmlPlistText(bytes));const projected = projectPlistValue(value);@@ -766,8 +766,6 @@ const decodePlist = (value: projected.value,omittedPrototypeKeys,unknownDateCount: projected.unknownDateCount,- numberLiterals: binary- ? binaryNumberMetadata!.literals- : xmlPlistNumberLiterals(xmlText ?? decodeXmlPlistText(bytes)),+ numberLiterals,};};diff --git a/src/artifacts/apple/KeyedArchiveReader.ts b/src/artifacts/apple/KeyedArchiveReader.tsindex e2340f3ad..b7b0d109b 100644--- a/src/artifacts/apple/KeyedArchiveReader.ts+++ b/src/artifacts/apple/KeyedArchiveReader.ts@@ -11,7 +11,6 @@ import { createPlistNumberProjection } from "../../domain/apple/plistNumbers.js"import {decodeBinaryPlistNumbers,scanBinaryPlistNumberLiterals,- xmlPlistNumberLiterals,} from "./PlistNumberLiterals.js";import {omittedPrototypeKeysLimitation,@@ -77,6 +76,7 @@ export const decodeKeyedArchiveBytes = (value: parseBinary(decodeBinaryPlistNumbers(bytes, binaryNumberMetadata!),),+ numberLiterals: binaryNumberMetadata!.literals,omittedPrototypeKeys: binaryExpansion.binaryPrototypeKeyObserved? null: 0,@@ -86,11 +86,7 @@ export const decodeKeyedArchiveBytes = (parsed.value,selection,);- const numbers = createPlistNumberProjection(- binary- ? binaryNumberMetadata!.literals- : xmlPlistNumberLiterals(xmlText ?? ""),- );+ const numbers = createPlistNumberProjection(parsed.numberLiterals);// Classify the serialized graph before projecting values to typed decimals.// Numeric IDs, node kinds, references and pagination retain their original meaning.const roots = Object.fromEntries(diff --git a/src/artifacts/apple/PlistNumberLiterals.ts b/src/artifacts/apple/PlistNumberLiterals.tsindex b5293a0e0..12b55ecb9 100644--- a/src/artifacts/apple/PlistNumberLiterals.ts+++ b/src/artifacts/apple/PlistNumberLiterals.ts@@ -1,125 +1,9 @@-import type { PlistNumberLiterals } from "../../domain/apple/plistNumbers.js";-import { decodeXmlText } from "../../domain/propertyListKeys.js";+import {+ createPlistNumberCollector,+ type PlistNumberLiterals,+} from "../../domain/apple/plistNumbers.js";import { hasBinaryPlistSignature } from "../../domain/apple/appleArchiveFormat.js";-const collector = () => {- const integers = new Map<number, Set<string>>();- const reals = new Set<number>();- let unsafeIntegerLiterals = 0;- let incompleteMetadata = false;- return {- integer: (literal: string) => {- if (!/^[+-]?\d+$/u.test(literal)) {- incompleteMetadata = true;- return;- }- const exact = BigInt(literal);- if (- exact >= BigInt(Number.MIN_SAFE_INTEGER) &&- exact <= BigInt(Number.MAX_SAFE_INTEGER)- )- return;- unsafeIntegerLiterals += 1;- const rounded = Number(exact);- integers.set(- rounded,- (integers.get(rounded) ?? new Set()).add(exact.toString()),- );- },- real: (value: number) => {- reals.add(value);- },- markIncomplete: () => {- incompleteMetadata = true;- },- result: (incomplete = false): PlistNumberLiterals => ({- incomplete: incomplete || incompleteMetadata,- integers,- reals,- unsafeIntegerLiterals,- }),- };-};-// Consume quoted tag attributes and opaque comment/CDATA tokens whole.-const XML_TOKEN =- /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<(?:[^>"']|"[^"]*"|'[^']*')*>/gu;-const OPAQUE_ELEMENTS = new Set(["string", "key", "data", "date"]);--/** Observe plist number element types without interpreting strings or class code. */-export const xmlPlistNumberLiterals = (xml: string): PlistNumberLiterals => {- const output = collector();- const elements: string[] = [];- let number:- | {- kind: "integer" | "real";- text: string;- depth: number;- plainText: boolean;- }- | undefined;- let cursor = 0;- for (const match of xml.matchAll(XML_TOKEN)) {- const index = match.index;- if (number !== undefined) number.text += xml.slice(cursor, index);- const token = match[0];- cursor = index + token.length;- if (token.startsWith("<!--") || token.startsWith("<![CDATA[")) {- if (number !== undefined) {- number.plainText = false;- output.markIncomplete();- }- continue;- }- const tag = /^<\s*(\/?)\s*([\w:-]+)/u.exec(token);- if (tag === null) {- if (number !== undefined) {- number.plainText = false;- output.markIncomplete();- }- continue;- }- const closing = tag[1] === "/";- const name = tag[2];- if (name === undefined) continue;- if (closing) {- if (- number !== undefined &&- number.kind === name &&- number.depth === elements.length- ) {- if (number.plainText) {- const text = decodeXmlText(number.text).trim();- if (number.kind === "integer") output.integer(text);- else output.real(Number.parseFloat(text));- }- number = undefined;- }- elements.pop();- continue;- }- // The pinned decoder reads only the first child for integers and only text- // nodes for reals. Mixed content cannot establish an exact association.- if (number !== undefined) {- number.plainText = false;- output.markIncomplete();- }- if (/\/\s*>$/u.test(token)) continue;- if (- number === undefined &&- (name === "integer" || name === "real") &&- !elements.some((parent) => OPAQUE_ELEMENTS.has(parent))- )- number = {- kind: name,- text: "",- depth: elements.length + 1,- plainText: true,- };- elements.push(name);- }- return output.result();-};-export interface BinaryPlistNumberMetadata {readonly literals: PlistNumberLiterals;/** 16-byte integers the pinned plist decoder cannot decode correctly. */@@ -179,7 +63,7 @@ const binaryObjectEnd = (export const scanBinaryPlistNumberLiterals = (bytes: Buffer,): BinaryPlistNumberMetadata => {- const output = collector();+ const output = createPlistNumberCollector();const wideIntegers: { offset: number; value: bigint }[] = [];if (bytes.length < 40 || !hasBinaryPlistSignature(bytes))return { literals: output.result(true), wideIntegers };@@ -236,14 +120,13 @@ export const scanBinaryPlistNumberLiterals = (const width = 2 ** (marker & 0xf);if (offset + 1 + width > offsetTable)return { literals: output.result(true), wideIntegers };- if (type === 1 && width === 8)- output.integer(view.getBigInt64(offset + 1).toString());+ if (type === 1 && width === 8) output.integer(view.getBigInt64(offset + 1));else if (type === 1 && width === 16) {const value = BigInt.asIntN(128,(view.getBigUint64(offset + 1) << 64n) | view.getBigUint64(offset + 9),);- output.integer(value.toString());+ output.integer(value);wideIntegers.push({ offset, value });} else if (type === 1 && width > 4)return { literals: output.result(true), wideIntegers };diff --git a/src/domain/apple/plistNumbers.ts b/src/domain/apple/plistNumbers.tsindex de44af79e..04ca01af2 100644--- a/src/domain/apple/plistNumbers.ts+++ b/src/domain/apple/plistNumbers.ts@@ -1,15 +1,63 @@import type { JsonValue } from "../jsonValue.js";+/** Exact decimal or signed hexadecimal XML integer text. */+export const parsePlistIntegerLiteral = (text: string): bigint | undefined => {+ const match = /^([+-]?)(?:0[xX]([\da-fA-F]+)|(\d+))$/u.exec(text.trim());+ if (match === null) return undefined;+ const magnitude = BigInt(+ match[2] === undefined ? match[3]! : `0x${match[2]}`,+ );+ return match[1] === "-" ? -magnitude : magnitude;+};+/** Source element types needed to distinguish large integers from integral reals. */export interface PlistNumberLiterals {readonly integers: ReadonlyMap<number, ReadonlySet<string>>;readonly reals: ReadonlySet<number>;/** Integer literals in the original serialized plist, not decoded graph slots. */readonly unsafeIntegerLiterals: number;- /** Supplemental byte metadata was not completely observable. */+ /** Source numeric facts could not all be established. */readonly incomplete: boolean;}+export const incompletePlistNumberLimitation =+ "Property-list number metadata could not be completely observed; decoded numbers may lose integer precision and exact integer/real association is unavailable.";++/** Collect facts at the decoder boundary before integer values are rounded. */+export const createPlistNumberCollector = () => {+ const integers = new Map<number, Set<string>>();+ const reals = new Set<number>();+ let unsafeIntegerLiterals = 0;+ let incompleteMetadata = false;+ return {+ integer: (exact: bigint) => {+ if (+ exact >= BigInt(Number.MIN_SAFE_INTEGER) &&+ exact <= BigInt(Number.MAX_SAFE_INTEGER)+ )+ return;+ unsafeIntegerLiterals++;+ const rounded = Number(exact);+ integers.set(+ rounded,+ (integers.get(rounded) ?? new Set()).add(exact.toString()),+ );+ },+ real: (value: number) => {+ reals.add(value);+ },+ markIncomplete: () => {+ incompleteMetadata = true;+ },+ result: (incomplete = false): PlistNumberLiterals => ({+ integers,+ reals,+ unsafeIntegerLiterals,+ incomplete: incomplete || incompleteMetadata,+ }),+ };+};+/** Preserve unambiguous exact integers; disclose rounded or unclassified numbers. */export const createPlistNumberProjection = (literals: PlistNumberLiterals) => {let exactIntegerCount = 0;@@ -66,11 +114,7 @@ export const createPlistNumberProjection = (literals: PlistNumberLiterals) => {return {project: map,limitations: () => [- ...(literals.incomplete- ? [- "Original archive number metadata could not be completely observed; decoded numbers may lose integer precision and exact integer/real association is unavailable.",- ]- : []),+ ...(literals.incomplete ? [incompletePlistNumberLimitation] : []),...(literals.unsafeIntegerLiterals === 0? []: [diff --git a/src/domain/apple/plistValue.test.ts b/src/domain/apple/plistValue.test.tsindex dadada73f..e8ff89cc7 100644--- a/src/domain/apple/plistValue.test.ts+++ b/src/domain/apple/plistValue.test.ts@@ -86,3 +86,20 @@ it("rejects accessors, proxies, holes and symbol keys without invoking user codeexpect(() => projectPlistValue(value)).toThrow(TypeError);expect(accessed).toBe(0);});++it("keeps retained integer scalars distinct from lookalike dictionaries", () => {+ const decimal = `1${"0".repeat(400)}`;+ const observed: object[] = [];+ const projected = projectPlistValue(+ [BigInt(decimal), { $plist_type: "integer", decimal }],+ (value) => observed.push(value),+ );+ expect(projected.unknownRealCount).toBe(0);+ expect(projected.unknownDateCount).toBe(0);+ expect(Array.isArray(projected.value)).toBe(true);+ if (!Array.isArray(projected.value)) throw new Error("Expected array");+ expect(projected.value[0]).toEqual(projected.value[1]);+ expect(observed).toHaveLength(1);+ expect(observed[0]).toBe(projected.value[0]);+ expect(observed[0]).not.toBe(projected.value[1]);+});diff --git a/src/domain/apple/plistValue.ts b/src/domain/apple/plistValue.tsindex 41138e868..1131d8bd7 100644--- a/src/domain/apple/plistValue.ts+++ b/src/domain/apple/plistValue.ts@@ -24,7 +24,7 @@ export const unknownDateLimitation = (count: number): string =>`${String(count)} date value(s) are reported as { "$plist_type": "date", "iso8601": null } because the decoder could not represent them, such as XML dates with years beyond 9999 or negative years, or dates outside the JavaScript date range.`;/**- * Project a decoded plist into JSON. Data and dates become explicit+ * Project a decoded plist into JSON. Data, dates and retained big integers become explicit* `$plist_type` objects; a non-finite real becomes an explicit unknown* because the XML decoder reports NaN and ±infinity alike.*/@@ -64,6 +64,8 @@ export const projectPlistValue = (unknownRealCount += 1;return scalar({ $plist_type: "real", value: null });}+ if (typeof item === "bigint")+ return scalar({ $plist_type: "integer", decimal: item.toString() });if (Array.isArray(item)) {const result: JsonValue[] = [];for (let index = 0; index < item.length; index++) {diff --git a/src/domain/propertyListKeys.test.ts b/src/domain/propertyListKeys.test.tsindex 259204a22..c8898b859 100644--- a/src/domain/propertyListKeys.test.ts+++ b/src/domain/propertyListKeys.test.ts@@ -4,7 +4,7 @@ import { parse } from "plist";import {decodeXmlText,omitPrototypeKeys,- parseXmlPropertyList,+ parseXmlPropertyList as parseWithNumbers,} from "./propertyListKeys.js";it("preserves unknown named entities that collide with object prototype properties", () => {@@ -16,6 +16,13 @@ it("preserves unknown named entities that collide with object prototype properti);});+// Existing key/omission controls assert those facts exactly; numeric facts+// have separate source-type and ambiguity controls below.+const parseXmlPropertyList = (text: string) => {+ const { numberLiterals: _numbers, ...parsed } = parseWithNumbers(text);+ return parsed;+};+const plist = (body: string) =>`<?xml version="1.0" encoding="UTF-8"?><plist version="1.0">${body}</plist>`;diff --git a/src/domain/propertyListKeys.ts b/src/domain/propertyListKeys.tsindex 12e3e7dba..24804ea8a 100644--- a/src/domain/propertyListKeys.ts+++ b/src/domain/propertyListKeys.ts@@ -1,5 +1,11 @@import { normalizeLineEndings, type Document, type Node } from "@xmldom/xmldom";-import { parse, parseOpenStep } from "plist";+import { parseOpenStep } from "plist";++import { decodeXmlPropertyList } from "./propertyListXml.js";+import {+ createPlistNumberCollector,+ type PlistNumberLiterals,+} from "./apple/plistNumbers.js";import { MAX_PLIST_DEPTH } from "./apple/plistValue.js";import { parseXmlDocument } from "./xmlDocument.js";@@ -13,15 +19,20 @@ export interface PropertyListWithoutPrototypeKeys {readonly omittedPrototypeKeys: number;}+/** Value and numeric facts decoded together; OpenStep numeric facts remain unknown. */+export interface ParsedPropertyList extends PropertyListWithoutPrototypeKeys {+ readonly numberLiterals: PlistNumberLiterals;+}+/** Limitation for results whose source plist held `__proto__` entries. */export const omittedPrototypeKeysLimitation = (count: number | null): string =>count === null? "Dictionary entries keyed __proto__ were omitted because REA results cannot represent that key.": `${String(count)} dictionary ${count === 1 ? "entry" : "entries"} keyed __proto__ ${count === 1 ? "was" : "were"} omitted because REA results cannot represent that key.`;-const projectDictionaryKeys = (+/** Remove own `__proto__` entries, such as JSON.parse creates, and count them. */+export const omitPrototypeKeys = (value: unknown,- projectName: (name: string) => string | undefined,): PropertyListWithoutPrototypeKeys => {let omitted = 0;const strip = (item: unknown): unknown => {@@ -35,8 +46,7 @@ const projectDictionaryKeys = (return item;return Object.fromEntries(Object.entries(item).flatMap(([name, entry]) => {- const projected = projectName(name);- if (projected !== undefined) return [[projected, strip(entry)]];+ if (name !== PROTOTYPE_KEY) return [[name, strip(entry)]];omitted += 1;return [];}),@@ -46,14 +56,6 @@ const projectDictionaryKeys = (return { value: stripped, omittedPrototypeKeys: omitted };};-/** Remove own `__proto__` entries, such as JSON.parse creates, and count them. */-export const omitPrototypeKeys = (- value: unknown,-): PropertyListWithoutPrototypeKeys =>- projectDictionaryKeys(value, (name) =>- name === PROTOTYPE_KEY ? undefined : name,- );-const XML_ENTITIES: Readonly<Record<string, string>> = {amp: "&",apos: "'",@@ -86,14 +88,12 @@ export const decodeXmlText = (text: string): string =>);/**- * Decode complete XML character-data keys before the pinned value decoder.+ * Decode one validated XML DOM into values and numeric source facts.* Entries keyed `__proto__` are omitted and counted at the same boundary.*/-export const parseXmlPropertyList = (- text: string,-): PropertyListWithoutPrototypeKeys => {+export const parseXmlPropertyList = (text: string): ParsedPropertyList => {// Preserve the pinned decoder's existing OpenStep autodetection, also used- // by app Info.plist resolution. Only XML needs key normalization.+ // by app Info.plist resolution.const first = text.trimStart()[0];if (first === "{" || first === "(") {// The pinned decoder assigns a `__proto__` key to the object prototype, so@@ -101,16 +101,17 @@ export const parseXmlPropertyList = (// the source instead; the rebuild still drops any prototype it replaced.const prototypeKeys = scanOpenStep(text);return {- value: omitPrototypeKeys(parse(text)).value,+ value: omitPrototypeKeys(parseOpenStep(text)).value,+ numberLiterals: createPlistNumberCollector().result(true),omittedPrototypeKeys: prototypeKeys,};}// Normalize only the literal line endings the pinned decoder normalizes.- // Preserve character references in the source: serializing a DOM would turn- // e.g. an encoded carriage return into a literal newline on the second parse.+ // Decode this DOM directly so character references are never reserialized+ // into literal line endings and normalized a second time.const normalized = normalizeLineEndings(text);- // Validate before plist's recovering XML decoder can turn malformed source- // into observed values. Reuse the validated DOM for depth and key ownership.+ // Strict syntax owns well-formedness before value interpretation. Reuse the+ // same DOM for depth, keys, values and number facts.const parsed = parseXmlDocument(normalized, {doctype: "allow",lineEndings: "preserve",@@ -118,11 +119,11 @@ export const parseXmlPropertyList = (if (!parsed.ok) throw parsed.error;const document = parsed.value;assertXmlPlistDepthWithinLimit(document);- const { substituted, names } = normalizeXmlKeys(normalized, document);- return projectDictionaryKeys(parse(substituted), (name) => {- const decoded = names.get(name) ?? name;- return decoded === PROTOTYPE_KEY ? undefined : decoded;- });+ const decoded = decodeXmlPropertyList(document);+ return {+ ...omitPrototypeKeys(decoded.value),+ numberLiterals: decoded.numberLiterals,+ };};interface OpenStepContainer {@@ -286,12 +287,12 @@ const skipOpenStepScalar = (text: string, start: number): number => {return cursor;};-/** Elements whose children the pinned plist value decoder visits recursively. */+/** Elements whose children the plist value decoder visits recursively. */const PLIST_CONTAINER_ELEMENTS = new Set(["plist", "dict", "array"]);/*** Reject XML plists nested deeper than the projection supports before any- * recursive value pass runs. `plist` and the prototype-key traversal recurse once+ * recursive value pass runs. Value decoding and prototype omission recurse once* per nesting level, so a deeply nested document exhausts the call stack* before the projection limit can report the resource bound. The failure* matches `projectPlistValue` so callers classify it as a limit failure.@@ -325,90 +326,3 @@ const assertXmlPlistDepthWithinLimit = (document: Document): void => {pending.push({ node: node.firstChild, depth: depth + 1 });}};--/** The validated DOM owns key identities; aliases bypass first-child-only decoding. */-const normalizeXmlKeys = (text: string, document: Document) => {- const keys = Array.from(document.getElementsByTagName("key"))- // The decoder also accepts <key> as a scalar outside dictionaries. Such- // values have no dictionary-name restoration boundary and must not alias.- .filter((key) => key.parentNode?.nodeName === "dict")- .map((key) => {- const first = key.firstChild;- // Nested elements are unsupported key markup. Retain the pinned decoder's- // interpretation instead of treating descendant element text as key data.- const characterDataOnly = !Array.from(key.childNodes).some(- (child) => child.nodeType === child.ELEMENT_NODE,- );- return {- node: first ?? key,- empty: first === null,- name: characterDataOnly- ? (key.textContent ?? "")- : first === null- ? ""- : String(first.nodeValue),- firstName: first?.nodeValue ?? "",- };- });- const occupied = new Set(- keys.flatMap(({ name, firstName }) => [name, firstName]),- );- const aliases = new Map<string, string>();- const names = new Map<string, string>();- for (const { name, firstName } of keys) {- if ((name !== PROTOTYPE_KEY && name === firstName) || aliases.has(name))- continue;- let alias = `__rea_plist_key_${String(aliases.size)}__`;- while (occupied.has(alias)) alias = `_${alias}`;- occupied.add(alias);- aliases.set(name, alias);- names.set(alias, name);- }- // Alias every occurrence of a corrected name, including plain spellings,- // so the decoder retains its last-value-wins behavior for duplicate keys.- const replacements = keys.filter(({ name }) => aliases.has(name));- if (replacements.length === 0) return { substituted: text, names };-- // xmldom uses one-based locators in document order. Scan forward only to- // needed lines instead of retaining an offset for every source newline.- let line = 1;- let lineStart = 0;- const parts: string[] = [];- let cursor = 0;- for (const { node, name, empty } of replacements) {- const nodeLine = node?.lineNumber;- const column = node?.columnNumber;- if (nodeLine === undefined || column === undefined)- throw new TypeError("XML plist key has no source location");- while (line < nodeLine) {- const newline = text.indexOf("\n", lineStart);- if (newline === -1)- throw new TypeError("XML plist key has an invalid source location");- lineStart = newline + 1;- line += 1;- }- const offset = lineStart + column - 1;- const marker = `<![CDATA[${aliases.get(name)}]]>`;- parts.push(text.slice(cursor, offset));- if (empty) {- // Empty keys have no child locator. Replace only their opening tag,- // consuming quoted attributes whole, and expand self-closing spellings.- const opening = /^<(?:[^>"']|"[^"]*"|'[^']*')*>/u.exec(- text.slice(offset),- )?.[0];- if (opening === undefined)- throw new TypeError("XML plist key has an invalid opening tag");- parts.push(- /\/\s*>$/u.test(opening)- ? `${opening.replace(/\/\s*>$/u, ">")}${marker}</key>`- : `${opening}${marker}`,- );- cursor = offset + opening.length;- } else {- parts.push(marker);- cursor = offset;- }- }- parts.push(text.slice(cursor));- return { substituted: parts.join(""), names };-};diff --git a/src/domain/propertyListXml.test.ts b/src/domain/propertyListXml.test.tsnew file mode 100644index 000000000..631fead7d--- /dev/null+++ b/src/domain/propertyListXml.test.ts@@ -0,0 +1,70 @@+import { expect, it } from "vitest";++import { parseXmlPropertyList } from "./propertyListKeys.js";++it.each([+ ["0x2A", 42],+ ["0X2a", 42],+ ["+0x2A", 42],+ ["-0x2A", -42],+ ["0x2A", 42],+ ["\n0x2A\n", 42],+ ["42", 42],+])(+ "decodes exact integer text %s at the shared boundary",+ (literal, expected) => {+ const parsed = parseXmlPropertyList(+ `<plist><integer>${literal}</integer></plist>`,+ );+ expect(parsed.value).toBe(expected);+ expect(parsed.numberLiterals.incomplete).toBe(false);+ expect(parsed.numberLiterals.unsafeIntegerLiterals).toBe(0);+ },+);++it("collects source integers and CDATA reals before rounding and duplicate assignment", () => {+ const parsed = parseXmlPropertyList(+ "<plist><dict><key>a</key><integer>0x20000000000001</integer><key>a</key><integer>9007199254740992</integer><key>b</key><real>9007199254<![CDATA[740992]]></real></dict></plist>",+ );+ expect(parsed.value).toEqual({ a: 9007199254740992, b: 9007199254740992 });+ expect(parsed.numberLiterals.integers.get(9007199254740992)).toEqual(+ new Set(["9007199254740993", "9007199254740992"]),+ );+ expect(parsed.numberLiterals.reals).toEqual(new Set([9007199254740992]));+ expect(parsed.numberLiterals.unsafeIntegerLiterals).toBe(2);+ expect(parsed.numberLiterals.incomplete).toBe(false);+});++it("does not invent numeric facts from ignored scalar markup", () => {+ const parsed = parseXmlPropertyList(+ "<plist><array><string>text<integer>9007199254740993</integer></string><dict><key><real>9007199254740992</real></key><integer>7</integer></dict></array></plist>",+ );+ expect(parsed.value).toEqual(["text", { null: 7 }]);+ expect(parsed.numberLiterals.integers.size).toBe(0);+ expect(parsed.numberLiterals.reals.size).toBe(0);+ expect(parsed.numberLiterals.incomplete).toBe(false);+});++it("retains partial numeric values with explicit incomplete metadata for unsupported markup", () => {+ const parsed = parseXmlPropertyList(+ "<plist><array><integer>0x2A<!-- unsupported --></integer><real>1<string>ignored</string>.25</real></array></plist>",+ );+ expect(parsed.value).toEqual([0, 1.25]);+ expect(parsed.numberLiterals.incomplete).toBe(true);+});++it("interprets failures in omitted entries before reporting partial evidence", () => {+ expect(() =>+ parseXmlPropertyList(+ "<plist><dict><key>__proto__</key><unsupported/></dict></plist>",+ ),+ ).toThrow("Invalid PLIST tag");+});++it("retains native decoder null and nested-envelope behavior", () => {+ expect(+ parseXmlPropertyList(+ "<plist><array><null/><dict><key>value</key><null/></dict><plist><null/></plist></array></plist>",+ ).value,+ ).toEqual([{ value: null }, [null]]);+});diff --git a/src/domain/propertyListXml.ts b/src/domain/propertyListXml.tsnew file mode 100644index 000000000..696f917ab--- /dev/null+++ b/src/domain/propertyListXml.ts@@ -0,0 +1,140 @@+import type { Document, Node } from "@xmldom/xmldom";++import {+ createPlistNumberCollector,+ parsePlistIntegerLiteral,+} from "./apple/plistNumbers.js";++/** Interpret an already validated, depth-bounded DOM, owning values and number facts together. */+export const decodeXmlPropertyList = (document: Document) => {+ const root = document.documentElement;+ if (root?.nodeName !== "plist")+ throw new TypeError("malformed document. First element should be <plist>");+ const numbers = createPlistNumberCollector();+ const requireContent = (node: Node): Node => {+ if (node.firstChild === null)+ throw new TypeError(`Cannot parse "" as ${node.nodeName}`);+ return node.firstChild;+ };+ const textNode = (node: Node) => node.nodeType === node.TEXT_NODE;+ const characterNode = (node: Node) =>+ textNode(node) || node.nodeType === node.CDATA_SECTION_NODE;+ const content = (node: Node, accepts: (child: Node) => boolean) => {+ let text = "";+ let complete = true;+ for (+ let child = node.firstChild;+ child !== null;+ child = child.nextSibling+ ) {+ if (accepts(child)) text += child.nodeValue ?? "";+ else complete = false;+ }+ return { text, complete };+ };+ const dictionaryKey = (node: Node): string => {+ for (let child = node.firstChild; child !== null; child = child.nextSibling)+ if (child.nodeType === child.ELEMENT_NODE)+ return String(node.firstChild?.nodeValue ?? null);+ return content(node, characterNode).text;+ };+ const members = function* (node: Node) {+ for (let child = node.firstChild; child !== null; child = child.nextSibling)+ if (+ child.nodeType !== child.TEXT_NODE &&+ child.nodeType !== child.CDATA_SECTION_NODE &&+ child.nodeType !== child.COMMENT_NODE+ )+ yield child;+ };+ const decode = (node: Node): unknown => {+ switch (node.nodeName) {+ case "plist":+ return Array.from(members(node), decode);+ case "array": {+ const values: unknown[] = [];+ for (const member of members(node)) {+ const value = decode(member);+ if (value !== null) values.push(value);+ }+ return values;+ }+ case "dict": {+ const entries: [string, unknown][] = [];+ let key: string | undefined;+ for (const child of members(node)) {+ if (key === undefined) {+ if (child.nodeName !== "key")+ throw new TypeError("Missing key while parsing <dict/>");+ key = dictionaryKey(child);+ } else {+ if (child.nodeName === "key")+ throw new TypeError(+ "Unexpected <key> while parsing <dict/>. Keys and values must alternate.",+ );+ entries.push([key, decode(child)]);+ key = undefined;+ }+ }+ if (key !== undefined) entries.push([key, ""]);+ // Define own properties safely, including __proto__; the caller owns omission accounting.+ return Object.fromEntries(entries);+ }+ case "key": {+ // The pinned decoder also accepted key elements as scalars. Keep their+ // first-child interpretation separate from dictionary key identities.+ const value = node.firstChild === null ? "" : node.firstChild.nodeValue;+ if (value === "__proto__")+ throw new TypeError("__proto__ is not a scalar plist key");+ return value;+ }+ case "string":+ return content(node, characterNode).text;+ case "integer": {+ const first = requireContent(node);+ const literal = content(node, textNode);+ const exact = literal.complete+ ? parsePlistIntegerLiteral(literal.text)+ : undefined;+ if (exact === undefined) {+ numbers.markIncomplete();+ return Number.parseInt(first.nodeValue ?? "", 10);+ }+ numbers.integer(exact);+ const decoded = Number(exact);+ // Keep a finite integer's identity when it cannot fit even a Number+ // approximation; otherwise it would be mislabeled as a non-finite real.+ return Number.isFinite(decoded) ? decoded : exact;+ }+ case "real": {+ requireContent(node);+ const literal = content(node, characterNode);+ const value = Number.parseFloat(literal.text);+ if (literal.complete) numbers.real(value);+ else numbers.markIncomplete();+ return value;+ }+ case "data": {+ const binary = atob(content(node, textNode).text.replace(/\s+/gu, ""));+ return Uint8Array.from(binary, (character) => character.charCodeAt(0));+ }+ case "date": {+ const value = requireContent(node).nodeValue;+ return new Date(value === null ? 0 : value);+ }+ case "null":+ return null;+ case "true":+ return true;+ case "false":+ return false;+ default:+ throw new TypeError(`Invalid PLIST tag ${node.nodeName}`);+ }+ };+ const values = Array.from(members(root), decode);+ return {+ value: values.length === 1 ? values[0] : values,+ numberLiterals: numbers.result(),+ };+};diff --git a/src/native/parsers/plist.test.ts b/src/native/parsers/plist.test.tsindex 8d6be612d..1ad64bc63 100644--- a/src/native/parsers/plist.test.ts+++ b/src/native/parsers/plist.test.ts@@ -20,6 +20,24 @@ it("retains complete segmented XML keys in native plist fallback evidence", () =);});+it("does not relabel integral CDATA reals as integers in native JSON or XML evidence", () => {+ const xml =+ "<plist><dict><key>integer</key><integer>9007199254740992</integer><key>real</key><real>9007199254<![CDATA[740992]]></real></dict></plist>";+ for (const parsed of [+ parsePlistJson('{"integer":9007199254740992,"real":9007199254740992}', xml),+ parsePlistXml(xml),+ ]) {+ if (!parsed.ok) throw parsed.error;+ expect(parsed.value.value).toEqual({+ integer: 9007199254740992,+ real: 9007199254740992,+ });+ expect(parsed.value.limitations).toContainEqual(+ expect.stringContaining("2 number(s)"),+ );+ }+});+it("keeps exact decimal text for JSON integers that XML shows are integers", () => {const parsed = parsePlistJson('{"Max":18446744073709551615,"Min":-9223372036854775808,"Near":9007199254740993,"Edge":9007199254740992,"Safe":9007199254740991,"Real":1e21,"Ratio":0.5}',diff --git a/src/native/parsers/plist.ts b/src/native/parsers/plist.tsindex a3b6c4fa5..5fb0fecab 100644--- a/src/native/parsers/plist.ts+++ b/src/native/parsers/plist.ts@@ -14,6 +14,11 @@ import {} from "../../domain/propertyListKeys.js";import { err, ok, type Result } from "../../domain/result.js";+import {+ incompletePlistNumberLimitation,+ type PlistNumberLiterals,+} from "../../domain/apple/plistNumbers.js";+const plistObject = z.record(z.string(), z.unknown());/** Stable bundle metadata projected from one plist value. */@@ -87,14 +92,15 @@ export const parsePlistJson = (output: string,xmlConversion?: string,): Result<ParsedPlist, AnalysisOutputError> => {- const literals =- xmlConversion === undefined ? undefined : xmlNumberLiterals(xmlConversion);+ let literals: PlistNumberLiterals | undefined;let exactIntegerCount = 0;let ambiguousNumberCount = 0;const classify = (item: number, digits: string): unknown => {const exact = BigInt(digits).toString();- const integer = literals?.integers.get(item)?.has(exact) === true;- const real = literals?.reals.has(item) === true;+ const integer =+ literals?.incomplete === false &&+ literals.integers.get(item)?.has(exact) === true;+ const real = literals?.incomplete === false && literals.reals.has(item);if (integer && !real) {exactIntegerCount += 1;return { $plist_type: "integer", decimal: digits };@@ -106,6 +112,10 @@ export const parsePlistJson = (};let decoded: ReturnType<typeof omitPrototypeKeys>;try {+ literals =+ xmlConversion === undefined+ ? undefined+ : parseXmlPropertyList(xmlConversion).numberLiterals;decoded = omitPrototypeKeys(decodePlistJson(output, classify));} catch (cause: unknown) {return err(@@ -121,6 +131,9 @@ export const parsePlistJson = (value,bundle: projectPlistBundle(value),limitations: [+ ...(literals?.incomplete === true+ ? [incompletePlistNumberLimitation]+ : []),...numberLimitations(exactIntegerCount, ambiguousNumberCount),...prototypeKeyLimitations(decoded.omittedPrototypeKeys),],@@ -136,9 +149,11 @@ export const parsePlistXml = (): Result<ParsedPlist, AnalysisOutputError> => {let projected: ProjectedPlistValue;let omittedPrototypeKeys: number;+ let literals: PlistNumberLiterals;try {const decoded = parseXmlPropertyList(output);omittedPrototypeKeys = decoded.omittedPrototypeKeys;+ literals = decoded.numberLiterals;projected = projectPlistValue(decoded.value);} catch (cause: unknown) {return err(@@ -151,7 +166,6 @@ export const parsePlistXml = (}// The XML decoder turns <integer> and <real> into numbers before REA sees// them, rounding integers beyond the exact range.- const literals = xmlNumberLiterals(output);let exactIntegerCount = 0;let ambiguousNumberCount = 0;const value = mapJsonNumbers(projected.value, (item) => {@@ -159,6 +173,7 @@ export const parsePlistXml = (if (decimals === undefined) return item;const [decimal] = decimals;if (+ literals.incomplete ||decimals.size !== 1 ||decimal === undefined ||literals.reals.has(item)@@ -182,41 +197,13 @@ export const parsePlistXml = (...(projected.unknownDateCount === 0? []: [unknownDateLimitation(projected.unknownDateCount)]),+ ...(literals.incomplete ? [incompletePlistNumberLimitation] : []),...numberLimitations(exactIntegerCount, ambiguousNumberCount),...prototypeKeyLimitations(omittedPrototypeKeys),],});};-/** `<integer>` and `<real>` element literals in plutil's XML conversion. */-interface XmlNumberLiterals {- /** Exact integer literals beyond the safe range, keyed by decoded number. */- readonly integers: ReadonlyMap<number, ReadonlySet<string>>;- readonly reals: ReadonlySet<number>;-}--// plutil escapes "<" in keys and strings, so these element literals can be-// read from the XML text.-const xmlNumberLiterals = (xml: string): XmlNumberLiterals => {- const integers = new Map<number, Set<string>>();- for (const [, decimal = ""] of xml.matchAll(- /<integer>\s*([+-]?\d+)\s*<\/integer>/gu,- )) {- const rounded = Number(decimal);- if (Number.isSafeInteger(rounded)) continue;- integers.set(- rounded,- (integers.get(rounded) ?? new Set()).add(BigInt(decimal).toString()),- );- }- const reals = new Set(- [...xml.matchAll(/<real>([^<]*)<\/real>/gu)].map(([, text = ""]) =>- Number.parseFloat(text),- ),- );- return { integers, reals };-};-const prototypeKeyLimitations = (count: number): string[] =>count === 0 ? [] : [omittedPrototypeKeysLimitation(count)];diff --git a/tests/acceptance/applications/interfaceBuilderPlistNumbers.test.ts b/tests/acceptance/applications/interfaceBuilderPlistNumbers.test.tsindex 3c7049e3b..b8e839597 100644--- a/tests/acceptance/applications/interfaceBuilderPlistNumbers.test.ts+++ b/tests/acceptance/applications/interfaceBuilderPlistNumbers.test.ts@@ -17,6 +17,8 @@ const scenarios = ["integer collision","integer-real collision","real",+ "CDATA real",+ "hexadecimal","mixed XML","segmented keys",] as const;@@ -66,9 +68,13 @@ cliTest.for(scenarios)("<string>__INTEGER__</string>",scenario === "real"? "<real>9007199254740992</real>"- : scenario === "mixed XML"- ? "<integer>9007199254740992<!-- split -->3</integer>"- : "<integer>9007199254740993</integer>",+ : scenario === "CDATA real"+ ? "<real>9007199254<![CDATA[740992]]></real>"+ : scenario === "hexadecimal"+ ? "<integer>0x20000000000001</integer>"+ : scenario === "mixed XML"+ ? "<integer>9007199254740992<!-- split -->3</integer>"+ : "<integer>9007199254740993</integer>",).replace("<string>__OTHER__</string>",@@ -122,6 +128,7 @@ cliTest.for(scenarios)(large:scenario === "XML" ||scenario === "binary" ||+ scenario === "hexadecimal" ||scenario === "segmented keys"? { $plist_type: "integer", decimal: "9007199254740993" }: 9007199254740992,@@ -142,12 +149,13 @@ cliTest.for(scenarios)(if (scenario === "XML" ||scenario === "binary" ||+ scenario === "hexadecimal" ||scenario === "segmented keys")expect(result.limitations).toContainEqual(expect.stringContaining("1 unambiguous integer value"),);- else if (scenario !== "real")+ else if (scenario !== "real" && scenario !== "CDATA real")expect(result.limitations).toContainEqual(expect.stringContaining("integer precision loss remains possible"),);diff --git a/tests/acceptance/applications/keyedArchiveXmlNumbers.test.ts b/tests/acceptance/applications/keyedArchiveXmlNumbers.test.tsnew file mode 100644index 000000000..c53ffa252--- /dev/null+++ b/tests/acceptance/applications/keyedArchiveXmlNumbers.test.ts@@ -0,0 +1,113 @@+import { createHash } from "node:crypto";+import { readFile, writeFile } from "node:fs/promises";+import { join } from "node:path";++import { build } from "plist";+import { expect } from "vitest";++import { keyedArchiveResultSchema } from "../../../src/domain/apple/keyedArchive.js";+import { parseEvidence } from "../../../src/domain/evidence.js";+import { connectLocalToolsMcp } from "../../fixtures/localToolsMcp.js";+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";+import { cliTest } from "../../support/cli/cliFixture.js";++cliTest.for([+ { name: "plain real", element: "<real>1.25</real>", expected: 1.25 },+ {+ name: "mixed real",+ element: "<real>1<![CDATA[.25]]></real>",+ expected: 1.25,+ },+ {+ name: "CDATA real",+ element: "<real><![CDATA[1.25]]></real>",+ expected: 1.25,+ },+ { name: "hexadecimal", element: "<integer>0x2A</integer>", expected: 42 },+ {+ name: "unsafe hexadecimal",+ element: "<integer>0x20000000000001</integer>",+ expected: { $plist_type: "integer", decimal: "9007199254740993" },+ },+ {+ name: "integer beyond finite Number range",+ element: `<integer>1${"0".repeat(400)}</integer>`,+ expected: { $plist_type: "integer", decimal: `1${"0".repeat(400)}` },+ },+])(+ "preserves $name XML numbers through CLI and MCP",+ async (scenario, { cli }) => {+ const root = await createTestTempDirectory("rea-keyed-xml-numbers-");+ const bytes = Buffer.from(+ build({+ $archiver: "NSKeyedArchiver",+ $version: 100000,+ $objects: ["$null", "__VALUE__"],+ $top: { root: { CF$UID: 1 } },+ }).replace("<string>__VALUE__</string>", scenario.element),+ );+ const path = join(root, "archive.plist");+ await writeFile(path, bytes);+ const { call } = await connectLocalToolsMcp({+ HOME: root,+ USERPROFILE: root,+ });+ const output = await cli.run({+ arguments: [+ "inspect-keyed-archive",+ path,+ "--root",+ "root",+ "--offset",+ "1",+ "--limit",+ "1",+ "--json",+ ],+ environment: { HOME: root, USERPROFILE: root, REA_LOG_LEVEL: "silent" },+ });+ expect(output.exitCode, output.stderr).toBe(0);+ const result = keyedArchiveResultSchema.parse(+ parseEvidence(output.json).normalized_result,+ );+ expect((await call("open_binary", { path })).isError).not.toBe(true);+ const mcp = await call("inspect_keyed_archive", {+ root: "root",+ offset: 1,+ limit: 1,+ });+ expect(mcp.isError, JSON.stringify(mcp)).not.toBe(true);+ expect(+ keyedArchiveResultSchema.parse(+ parseEvidence(mcp.structuredContent).normalized_result,+ ),+ ).toEqual(result);+ expect(result.archive_sha256).toBe(+ createHash("sha256").update(bytes).digest("hex"),+ );+ expect(result.objects).toEqual([+ {+ id: 1,+ kind: "scalar",+ class_id: null,+ class_name: null,+ status: "observed",+ value: scenario.expected,+ },+ ]);+ expect(result.references).toEqual([+ expect.objectContaining({+ source: null,+ path: ["root"],+ target: 1,+ status: "resolved",+ }),+ ]);+ expect(+ result.limitations.some((note) =>+ /non-finite|completely observed/u.test(note),+ ),+ ).toBe(false);+ expect(await readFile(path)).toEqual(bytes);+ },+);diff --git a/tests/boundary/filesystem/keyedArchiveScalarIdentity.test.ts b/tests/boundary/filesystem/keyedArchiveScalarIdentity.test.tsindex 47756552f..1f1ba969a 100644--- a/tests/boundary/filesystem/keyedArchiveScalarIdentity.test.ts+++ b/tests/boundary/filesystem/keyedArchiveScalarIdentity.test.ts@@ -9,7 +9,12 @@ import { parseEvidence } from "../../../src/domain/evidence.js";import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";import { cliTest } from "../../support/cli/cliFixture.js";-const cases = ["unsafe-integer", "integral-real"] as const;+const cases = [+ "unsafe-integer",+ "integral-real",+ "hexadecimal-integer",+ "unsafe-hexadecimal-integer",+] as const;const fixture = async (kind: (typeof cases)[number]) => {const root = await createTestTempDirectory("rea-integer-scalar-");const xml = build({@@ -21,7 +26,11 @@ const fixture = async (kind: (typeof cases)[number]) => {"<string>__VALUE__</string>",kind === "unsafe-integer"? "<integer>9007199254740993</integer>"- : "<real>9007199254740992</real>",+ : kind === "hexadecimal-integer"+ ? "<integer>0x2A</integer>"+ : kind === "unsafe-hexadecimal-integer"+ ? "<integer>0x20000000000001</integer>"+ : "<real>9007199254740992</real>",);const bytes = Buffer.from(xml);const path = join(root, "archive.plist");@@ -65,8 +74,22 @@ const verify = (expect(result.truncated).toBe(false);const value = result.objects.find(({ id }) => id === 1)?.value;expect(value).toBeDefined();+ const precisionNote = result.limitations.some(+ (note) =>+ /integer|number/iu.test(note) &&+ /precision|exact range|rounded|completely observed/iu.test(note),+ );if (kind === "integral-real") expect(value).toBe(9007199254740992);- else {+ else if (kind === "hexadecimal-integer") {+ // Apple's parser reads 0x2A as 42; the literal is classified, not unknown.+ expect(value).toBe(42);+ expect(precisionNote).toBe(false);+ } else if (kind === "unsafe-hexadecimal-integer") {+ expect(value).toEqual({+ $plist_type: "integer",+ decimal: "9007199254740993",+ });+ } else {const exact =typeof value === "object" &&value !== null &&diff --git a/tests/fixtures/keyedArchiveNumberMetadata.ts b/tests/fixtures/keyedArchiveNumberMetadata.tsindex f63b86fb0..9369692c9 100644--- a/tests/fixtures/keyedArchiveNumberMetadata.ts+++ b/tests/fixtures/keyedArchiveNumberMetadata.ts@@ -14,8 +14,6 @@ const ROUNDED = 9007199254740992;/** Accepted decoder representations whose supplemental metadata needs care. */export const mixedArchiveNumberElements = [- "<real>9007199254740992<![CDATA[0]]></real>",- "<real><![CDATA[1]]>9007199254740992</real>","<integer>9007199254740992<!-- split -->3</integer>","<integer>9007199254740992<![CDATA[3]]></integer>","<integer><![CDATA[9007199254740992]]>3</integer>",@@ -27,6 +25,23 @@ export const mixedArchiveNumberElements = [/** Ordinary dictionaries and malformed numeric references at the same boundary. */export const archiveNumberMetadataCases = [+ ...[+ {+ element: "<real>9007199254740992<![CDATA[0]]></real>",+ value: 90071992547409920,+ },+ {+ element: "<real><![CDATA[1]]>9007199254740992</real>",+ value: Number("19007199254740992"),+ },+ ].map(({ element, value }) => ({+ name: element,+ source: { first: "__INTEGER__", other: "__OTHER__" },+ element,+ expected: { first: EXACT_INTEGER, other: value },+ incomplete: false,+ malformedReference: false,+ })),...mixedArchiveNumberElements.map((element) => ({name: element,source: { first: "__INTEGER__", other: "__OTHER__" },