Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
import { parseOpenStep } from "plist";
import { decodeXmlPropertyList } from "./propertyListXml.js";
import {
createPlistNumberCollector,
type PlistNumberLiterals,
} from "./apple/plistNumbers.js";
import { UnknownPlistScalar } from "./apple/unknownPlistScalar.js";
import {
MAX_PLIST_DEPTH,
plistNestingLimitMessage,
} from "./apple/plistValue.js";
/** The dictionary key REA results cannot carry: validation strips it. */
const PROTOTYPE_KEY = "__proto__";
/** A decoded plist without `__proto__` entries, and how many were omitted. */
export interface PropertyListWithoutPrototypeKeys {
readonly value: unknown;
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.`;
/** Remove own `__proto__` entries, such as JSON.parse creates, and count them. */
export const omitPrototypeKeys = (
value: unknown,
): PropertyListWithoutPrototypeKeys => {
let omitted = 0;
const strip = (item: unknown): unknown => {
if (Array.isArray(item)) return item.map(strip);
if (
item === null ||
typeof item !== "object" ||
item instanceof Date ||
item instanceof Uint8Array ||
item instanceof UnknownPlistScalar
)
return item;
return Object.fromEntries(
Object.entries(item).flatMap(([name, entry]) => {
if (name !== PROTOTYPE_KEY) return [[name, strip(entry)]];
omitted += 1;
return [];
}),
);
};
const stripped = strip(value);
return { value: stripped, omittedPrototypeKeys: omitted };
};
/**
* 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): ParsedPropertyList => {
// Preserve the pinned decoder's existing OpenStep autodetection, also used
// by app Info.plist resolution.
const first = text[skipOpenStepTrivia(text, 0)];
if (first === "{" || first === "(") {
// The pinned decoder assigns a `__proto__` key to the object prototype, so
// the entry is gone before the decoded value can be counted. Count keys in
// the source instead; the rebuild still drops any prototype it replaced.
const prototypeKeys = scanOpenStep(text);
return {
value: omitPrototypeKeys(parseOpenStep(text)).value,
numberLiterals: createPlistNumberCollector().result(true),
omittedPrototypeKeys: prototypeKeys,
};
}
const decoded = decodeXmlPropertyList(text);
return {
...omitPrototypeKeys(decoded.value),
numberLiterals: decoded.numberLiterals,
};
};
interface OpenStepContainer {
end: string;
next: "key" | "equals" | "value" | "separator" | "after-value";
/** Source offset of a container that is itself a dictionary key. */
keyStart?: number;
}
/** Consume only the punctuation expected between the pinned decoder's values. */
const consumeOpenStepSeparator = (
parent: OpenStepContainer | undefined,
character: string,
): "consumed" | "invalid" | "none" => {
if (parent?.next === "after-value") {
parent.next = "key";
return character === ";" ? "consumed" : "none";
}
if (parent?.next !== "equals" && parent?.next !== "separator") return "none";
if (character !== (parent.next === "equals" ? "=" : ",")) return "invalid";
parent.next = "value";
return "consumed";
};
/** An array may close after a comma; a dictionary still needs its assigned value. */
const admitsOpenStepCloser = (
parent: OpenStepContainer | undefined,
character: string,
): boolean =>
parent?.end === character &&
parent.next !== "equals" &&
!(parent.end === "}" && parent.next === "value");
/**
* Bound OpenStep value nesting before the pinned decoder recursively reads it,
* and count the dictionary keys that decode to `__proto__`.
*/
const scanOpenStep = (text: string): number => {
let prototypeKeys = 0;
const containers: OpenStepContainer[] = [];
const completeValue = (): void => {
const parent = containers.at(-1);
if (parent !== undefined)
parent.next =
parent.next === "key"
? "equals"
: parent.end === "}"
? "after-value"
: "separator";
};
const assertDepth = (): void => {
if (containers.length > MAX_PLIST_DEPTH)
throw new RangeError(plistNestingLimitMessage());
};
let cursor = 0;
while (cursor < text.length) {
const afterTrivia = skipOpenStepTrivia(text, cursor);
if (afterTrivia !== cursor) {
cursor = afterTrivia;
continue;
}
const character = text[cursor] ?? "";
const parent = containers.at(-1);
// Stop at the first impossible token: only the pinned decoder owns syntax
// diagnostics. A later deep suffix cannot change that failure into a limit.
if (character === "}" || character === ")") {
if (!admitsOpenStepCloser(parent, character)) return prototypeKeys;
const closed = containers.pop();
if (
closed?.keyStart !== undefined &&
isOpenStepPrototypeKey(text.slice(closed.keyStart, cursor + 1))
)
prototypeKeys += 1;
// parseOpenStep returns the first root value without reading trailing text.
if (containers.length === 0) return prototypeKeys;
completeValue();
cursor += 1;
continue;
}
const separator = consumeOpenStepSeparator(parent, character);
if (separator === "invalid") return prototypeKeys;
if (separator === "consumed") {
cursor += 1;
continue;
}
if (character === "{" || character === "(") {
assertDepth();
containers.push({
end: character === "{" ? "}" : ")",
next: character === "{" ? "key" : "value",
// A compound key is coerced to a string, e.g. `(__proto__)`.
...(parent?.next === "key" ? { keyStart: cursor } : {}),
});
cursor += 1;
continue;
}
const end = skipOpenStepScalar(text, cursor);
if (end === cursor) return prototypeKeys;
if (parent?.next === "key") {
if (isOpenStepPrototypeKey(text.slice(cursor, end))) prototypeKeys += 1;
} else assertDepth();
cursor = end;
completeValue();
}
return prototypeKeys;
};
/**
* Whether one OpenStep key, scalar or compound, becomes the property name
* `__proto__` when the decoder assigns `obj[key]`. Plain strings compare
* directly; any other key is decoded by the pinned decoder itself and
* coerced to a property name the same way that assignment does.
*/
const isOpenStepPrototypeKey = (token: string): boolean => {
if (!/^["({<]/u.test(token)) return token === PROTOTYPE_KEY;
if (token.startsWith('"') && !token.includes("\\"))
return token === `"${PROTOTYPE_KEY}"`;
try {
return String(parseOpenStep(token)) === PROTOTYPE_KEY;
} catch {
// An unterminated token is the decoder's syntax error to report.
return false;
}
};
/** Skip grammar trivia without interpreting delimiter examples inside comments. */
const skipOpenStepTrivia = (text: string, cursor: number): number => {
while (cursor < text.length) {
if (/\s/u.test(text[cursor] ?? "")) {
cursor += 1;
continue;
}
if (!text.startsWith("//", cursor) && !text.startsWith("/*", cursor)) break;
const line = text[cursor + 1] === "/";
const end = text.indexOf(line ? "\n" : "*/", cursor + 2);
cursor = end === -1 ? text.length : end + (line ? 1 : 2);
}
return cursor;
};
/** Read the extent of one opaque scalar; the pinned decoder still owns its value. */
const skipOpenStepScalar = (text: string, start: number): number => {
let cursor = start;
const character = text[cursor];
if (character === '"') {
cursor += 1;
while (cursor < text.length) {
const next = text[cursor];
cursor += next === "\\" ? 2 : 1;
if (next === '"') break;
}
} else if (character === "<") {
const end = text.indexOf(">", cursor + 1);
cursor = end === -1 ? text.length : end + 1;
} else {
// Match the pinned OpenStep decoder's unquoted-string alphabet. Other
// syntax remains for the decoder to reject; preflight only owns depth.
while (
cursor < text.length &&
/[a-zA-Z0-9._/$:-]/u.test(text[cursor] ?? "")
)
cursor += 1;
}
return cursor;
};