Merge branch 'feat/dylib-resolution' into feat/dyld-shared-cache
Carry conditional-load propagation, parsed-image digest binding, and segment-wise root resolution into the shared-cache trace. Also: - Make cache compatibility directional: an arm64e cache serves arm64 processes and an x86_64h cache serves x86_64 ones, not the reverse. - Require the complete 24-byte LC_BUILD_VERSION with its declared tool records, and the 16-byte LC_VERSION_MIN_* command, before recording a platform. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -96,9 +96,11 @@ The components also list:
|
||||
|
||||
Symlinks are reported by path in `symlinks`. Their targets are not inventoried,
|
||||
so a versioned framework is described through its real `Versions/<version>/`
|
||||
directories rather than `Versions/Current`. When a framework has zero or several
|
||||
`Versions/*/Resources/Info.plist` files, its `info_plist_path` is `null` and a
|
||||
limitation explains why.
|
||||
directories rather than `Versions/Current`. A framework's `info_plist_path` is
|
||||
`null`, with a limitation explaining why, when it has more than one real
|
||||
`Versions/<version>/` directory (even if only one of them holds a plist,
|
||||
because `Versions/Current` decides which one applies) or when its single
|
||||
version directory has no `Resources/Info.plist`.
|
||||
|
||||
AppleDouble sidecar files (`._*` and `__MACOSX/`) are inventory facts, but they
|
||||
describe neighbouring files. They are excluded from roots, bundle roles, and the
|
||||
@@ -162,6 +164,11 @@ graded architectures, so an `x86_64h` process also loads `x86_64`. The edge's `r
|
||||
| `undetermined` | No candidate resolves inside the root, and some candidate lies outside it or depends on the environment. |
|
||||
| `shared-cache` | An absolute install path, or an `@rpath` candidate outside the root, was found in the dyld shared cache passed as `shared_cache` (CLI `--shared-cache`). dyld loads the cached image, so later in-root candidates are unused. |
|
||||
|
||||
A `conditional` image is still traced, because it is the image the analyzed
|
||||
root supplies. Every edge below it has `loader_conditional: true`, and a
|
||||
request that reuses it by install name is `conditional` too. Findings on those
|
||||
edges say that they apply only if the conditional image loads.
|
||||
|
||||
Absolute install names such as `/usr/lib/libSystem.B.dylib` are
|
||||
`outside-target`. On macOS 11 and later most of them live in the dyld shared
|
||||
cache rather than on disk, so REA does not check them against the host.
|
||||
|
||||
@@ -46,9 +46,20 @@ explicit limitation; architecture inventory locations remain available.
|
||||
vtable descriptors. Records include exact virtual addresses/file offsets and
|
||||
artifact evidence. Vtable indexes are metadata word offsets; witness indexes
|
||||
start after the conformance header. Names unavailable in metadata remain null.
|
||||
Chained fixups, external bindings, authenticated pointers, categories,
|
||||
properties, generic/resilient/async/coroutine tables and inherited overrides
|
||||
have explicit unsupported or partial coverage. Other providers retain the
|
||||
Pointers are decoded through the image's fixups:
|
||||
- `LC_DYLD_CHAINED_FIXUPS` rebases and binds, including the authenticated
|
||||
arm64e formats;
|
||||
- legacy `LC_DYLD_INFO` bind opcodes.
|
||||
|
||||
So an external superclass resolves from its `_OBJC_CLASS_$_` bind (for
|
||||
example `NSObject`). The `pointer_fixups` coverage facet names the mechanism.
|
||||
Class properties, with parsed attributes, and `__objc_catlist` categories are
|
||||
also decoded. Categories record the extended class, local or external, plus
|
||||
their methods, protocols and properties; category methods appear as
|
||||
implementations with a `category`. Swift field-offset globals that are only
|
||||
initialized at runtime stay unresolved. Generic, resilient, async and
|
||||
coroutine tables, and inherited overrides, have explicit unsupported or
|
||||
partial coverage. Other providers retain the
|
||||
existing symbol-based inventory with its narrower coverage.
|
||||
|
||||
## Native instruction, call and type primitives
|
||||
@@ -172,8 +183,10 @@ GUI authority, and REA never falls back automatically to Hopper.
|
||||
instruction/call facts, value dependencies and process/project cleanup.
|
||||
- `npm run verify:ghidra:aarch64-jump-table`: optimized ELF and byte/halfword
|
||||
relative tables, plus ARM64 Mach-O on an ARM64 macOS host.
|
||||
- `npm run verify:apple-dispatch`: source-built Objective-C protocols/classes and
|
||||
Swift conformances/vtables, repeated after stripping local symbols.
|
||||
- `npm run verify:apple-dispatch`: source-built Objective-C protocols, classes,
|
||||
properties and categories, and Swift conformances and vtables. Each is linked
|
||||
with legacy `LC_DYLD_INFO` and with chained fixups (and as arm64e on Apple
|
||||
silicon), then repeated after stripping local symbols.
|
||||
- `npm run verify:native-ui`: one source-owned fixture window, successful
|
||||
selected-window capture and actions, changed-target rejection, and cleanup.
|
||||
Missing OS permissions fail this lane.
|
||||
|
||||
@@ -677,9 +677,9 @@
|
||||
"mcp_prompts": 6
|
||||
},
|
||||
"digests": {
|
||||
"tools_sha256": "696d7cd44d8b2be6a8f03c11760de2bec5fc0cd5170d2dfe697076ab025ceea7",
|
||||
"tools_sha256": "04a31ae4dfeec74b4b5ab47db0b81e7e2c423a8e0f4222ac47a2c25769d01d02",
|
||||
"prompts_sha256": "ef2de8814390b340623c32001610aa2709d90bed51537b6e562ab3abf144ab4d",
|
||||
"combined_sha256": "f8946c1a0c1084e431e313a8c2b3585ff0838bd8e6c0d33ac924d1cc00410e0a",
|
||||
"combined_sha256": "1feec963472a4018075b8c47bd2356ae9bc2340f9c1de0beabad202db5f3e7b8",
|
||||
"providers_sha256": "14d933c5926c106e8cde60a37747e9758313fbfd651485ec96733bc608476255"
|
||||
}
|
||||
}
|
||||
|
||||
+18
-11
@@ -478,17 +478,24 @@ that explicit lane, not the routine iteration requirement.
|
||||
|
||||
## Apple native metadata and UI
|
||||
|
||||
`npm run verify:apple-dispatch` compiles Objective-C class/protocol and Swift
|
||||
conformance/vtable fixtures, inspects their bytes and repeats after stripping
|
||||
local symbols. It requires macOS and the host Xcode toolchain; targets are not
|
||||
executed. `npm run verify:native-ui` launches exactly one source-owned fixture
|
||||
window and requires successful selected-window capture and selected actions.
|
||||
An OS permission denial fails the positive lane. `npm run verify:native-ui:permissions`
|
||||
allows a host-permission-boundary-only result and explicitly reports
|
||||
`positive_e2e: false`; it must not be reported as capture/action proof.
|
||||
Both commands reject a changed executable digest and clean up the fixture
|
||||
process and helper. These lanes require an interactive macOS desktop. See [native investigation](native-investigation.md)
|
||||
for the exact ABI, authority, graph and observation boundaries.
|
||||
`npm run verify:apple-dispatch` compiles the Objective-C fixture (classes,
|
||||
protocols, a property and an `NSString` category) and the Swift
|
||||
conformance/vtable fixture.
|
||||
|
||||
- Each fixture is linked with legacy `LC_DYLD_INFO` binds and with chained
|
||||
fixups; on Apple silicon the ObjC fixture is also built as arm64e, which uses
|
||||
authenticated pointers.
|
||||
- The lane inspects the bytes and repeats after stripping local symbols.
|
||||
- It requires the bound `NSObject` superclass, the external category, and the
|
||||
matching `pointer_fixups` coverage. It requires macOS and the host Xcode toolchain; targets are not
|
||||
executed. `npm run verify:native-ui` launches exactly one source-owned fixture
|
||||
window and requires successful selected-window capture and selected actions.
|
||||
An OS permission denial fails the positive lane. `npm run verify:native-ui:permissions`
|
||||
allows a host-permission-boundary-only result and explicitly reports
|
||||
`positive_e2e: false`; it must not be reported as capture/action proof.
|
||||
Both commands reject a changed executable digest and clean up the fixture
|
||||
process and helper. These lanes require an interactive macOS desktop. See [native investigation](native-investigation.md)
|
||||
for the exact ABI, authority, graph and observation boundaries.
|
||||
|
||||
### Firmware adapters
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"manifest_id": "ecm_f3faddc5e13549c680547c8b551770be1525f2a5f2915be1c5e8a90647d208ad",
|
||||
"manifest_id": "ecm_fcd895d63b83b40e834c50fdb203b5ab216ccc4b5a65a439f05135e73a7241af",
|
||||
"verifier": {
|
||||
"id": "rea-managed-conformance",
|
||||
"version": "1"
|
||||
@@ -13,7 +13,7 @@
|
||||
"skill_digests": [
|
||||
{
|
||||
"skill_id": "reverse-engineer-anything",
|
||||
"sha256": "cd79389c3dba83ac47ef9b819c4658626567aa049a150989d973e066c61a59c4"
|
||||
"sha256": "17dbeef39e49e3955765b07c11ba29988f44720b5e8a83b37b678c2b39fc9e47"
|
||||
}
|
||||
],
|
||||
"claims": [
|
||||
|
||||
+181
-109
@@ -12,118 +12,190 @@ if (process.platform !== "darwin")
|
||||
"Apple dispatch verification requires macOS with a host Objective-C compiler and Foundation SDK",
|
||||
);
|
||||
const exec = promisify(execFile);
|
||||
const source = (name) =>
|
||||
fileURLToPath(
|
||||
new URL(`../tests/conformance/native/${name}`, import.meta.url),
|
||||
);
|
||||
|
||||
/** Both link modes: legacy LC_DYLD_INFO binds and the default chained fixups. */
|
||||
const LINK_MODES = [
|
||||
{
|
||||
mode: "dyld-info",
|
||||
flags: ["-Wl,-no_fixup_chains"],
|
||||
fixups: "LC_DYLD_INFO bind opcodes",
|
||||
swift: true,
|
||||
},
|
||||
{ mode: "chained", flags: [], fixups: "chained fixups:", swift: true },
|
||||
// arm64e uses authenticated chained pointers (DYLD_CHAINED_PTR_ARM64E_*).
|
||||
...(process.arch === "arm64"
|
||||
? [
|
||||
{
|
||||
mode: "chained-arm64e",
|
||||
flags: ["-arch", "arm64e"],
|
||||
fixups: "chained fixups: DYLD_CHAINED_PTR_ARM64E",
|
||||
swift: false,
|
||||
},
|
||||
]
|
||||
: []),
|
||||
];
|
||||
|
||||
const fixupCoverage = (metadata) =>
|
||||
metadata.coverage.find(({ facet }) => facet === "pointer_fixups");
|
||||
|
||||
const inspect = async (path) => {
|
||||
const target = await parseBinaryTarget(path);
|
||||
if (!target.ok) throw target.error;
|
||||
return {
|
||||
target: target.value,
|
||||
metadata: (await inspectAppleDispatchMetadata(target.value, 5000)).result,
|
||||
};
|
||||
};
|
||||
|
||||
const checkObjc = (metadata, mode) => {
|
||||
const fixture = metadata.objc_classes.find(
|
||||
({ name, is_meta_class: meta }) => name === "ReaDispatchFixture" && !meta,
|
||||
);
|
||||
const category = metadata.objc_categories.find(
|
||||
({ name }) => name === "ReaDispatchAdditions",
|
||||
);
|
||||
const objcCoverage = metadata.coverage.find(
|
||||
({ facet }) => facet === "objc_class_method_ivar_metadata",
|
||||
);
|
||||
if (
|
||||
!metadata.objc_dispatch_implementations.some(
|
||||
(item) =>
|
||||
item.class_name === "ReaDispatchFixture" &&
|
||||
item.selector === "performAction:" &&
|
||||
item.implementation_address !== null,
|
||||
) ||
|
||||
!metadata.objc_dispatch_implementations.some(
|
||||
(item) =>
|
||||
item.selector === "fixtureVersion" && item.method_type === "class",
|
||||
) ||
|
||||
!metadata.objc_ivars.some(
|
||||
(item) => item.name === "state" && item.offset !== null,
|
||||
) ||
|
||||
!metadata.objc_protocol_records.some(
|
||||
(protocol) =>
|
||||
protocol.name === "ReaDispatchProtocol" &&
|
||||
protocol.methods.some(
|
||||
(method) => method.selector === "performAction:",
|
||||
) &&
|
||||
protocol.optional_methods.some(
|
||||
(method) => method.selector === "optionalFixtureValue",
|
||||
),
|
||||
) ||
|
||||
// The superclass lives in libobjc, so it comes from a bind fixup.
|
||||
fixture?.super_class !== "NSObject" ||
|
||||
fixture.decode.status !== "decoded" ||
|
||||
!fixture.properties.some(
|
||||
(property) =>
|
||||
property.name === "fixtureName" &&
|
||||
property.type_encoding === '@"NSString"' &&
|
||||
property.attributes.some(({ name }) => name === "C"),
|
||||
) ||
|
||||
category?.class_name !== "NSString" ||
|
||||
category.class_source !== "external" ||
|
||||
!category.instance_methods.includes("reaFixtureLength") ||
|
||||
!metadata.objc_dispatch_implementations.some(
|
||||
(item) =>
|
||||
item.class_name === "NSString" &&
|
||||
item.category === "ReaDispatchAdditions" &&
|
||||
item.selector === "reaFixtureLength",
|
||||
) ||
|
||||
objcCoverage?.status !== "complete" ||
|
||||
fixupCoverage(metadata)?.reason?.startsWith(mode.fixups) !== true
|
||||
)
|
||||
throw new Error(
|
||||
`Apple metadata fixture drifted (${mode.mode}): ${JSON.stringify(metadata)}`,
|
||||
);
|
||||
};
|
||||
|
||||
const checkSwift = (metadata, mode) => {
|
||||
if (
|
||||
!metadata.swift_dispatch_slots.some(
|
||||
(slot) =>
|
||||
slot.table_kind === "class_vtable" &&
|
||||
slot.owner === "ReaVtableFixture" &&
|
||||
slot.decode.status === "decoded",
|
||||
)
|
||||
)
|
||||
throw new Error(
|
||||
`Swift class vtable fixture unavailable (${mode.mode}): ${JSON.stringify(metadata.coverage)}`,
|
||||
);
|
||||
if (
|
||||
!metadata.swift_conformances.some(
|
||||
(item) =>
|
||||
item.type_name === "ReaWitnessFixture" &&
|
||||
item.protocol_name === "ReaWitnessFixtureProtocol",
|
||||
) ||
|
||||
!metadata.swift_dispatch_slots.some(
|
||||
(item) =>
|
||||
item.owner === "ReaWitnessFixture: ReaWitnessFixtureProtocol" &&
|
||||
item.implementation_address !== null,
|
||||
) ||
|
||||
fixupCoverage(metadata)?.reason?.startsWith(mode.fixups) !== true
|
||||
)
|
||||
throw new Error(
|
||||
`Swift metadata fixture drifted (${mode.mode}): ${JSON.stringify(metadata)}`,
|
||||
);
|
||||
};
|
||||
|
||||
const root = await mkdtemp(join(tmpdir(), "rea-dispatch-"));
|
||||
try {
|
||||
const targetPath = join(root, "fixture");
|
||||
await exec("/usr/bin/xcrun", [
|
||||
"clang",
|
||||
"-O2",
|
||||
"-framework",
|
||||
"Foundation",
|
||||
"-Wl,-no_fixup_chains",
|
||||
fileURLToPath(
|
||||
new URL("../tests/conformance/native/dispatch.m", import.meta.url),
|
||||
),
|
||||
"-o",
|
||||
targetPath,
|
||||
]);
|
||||
const results = [];
|
||||
for (const variant of ["symbols", "stripped"]) {
|
||||
if (variant === "stripped")
|
||||
await exec("/usr/bin/strip", ["-x", targetPath]);
|
||||
const target = await parseBinaryTarget(targetPath);
|
||||
if (!target.ok) throw target.error;
|
||||
const observation = await inspectAppleDispatchMetadata(target.value, 5000);
|
||||
const metadata = observation.result;
|
||||
if (
|
||||
!metadata.objc_dispatch_implementations.some(
|
||||
(item) =>
|
||||
item.class_name === "ReaDispatchFixture" &&
|
||||
item.selector === "performAction:" &&
|
||||
item.implementation_address !== null,
|
||||
) ||
|
||||
!metadata.objc_dispatch_implementations.some(
|
||||
(item) =>
|
||||
item.selector === "fixtureVersion" && item.method_type === "class",
|
||||
) ||
|
||||
!metadata.objc_ivars.some(
|
||||
(item) => item.name === "state" && item.offset !== null,
|
||||
) ||
|
||||
!metadata.objc_protocol_records.some(
|
||||
(protocol) =>
|
||||
protocol.name === "ReaDispatchProtocol" &&
|
||||
protocol.methods.some(
|
||||
(method) => method.selector === "performAction:",
|
||||
) &&
|
||||
protocol.optional_methods.some(
|
||||
(method) => method.selector === "optionalFixtureValue",
|
||||
),
|
||||
)
|
||||
)
|
||||
throw new Error(
|
||||
`Apple metadata fixture drifted: ${JSON.stringify(observation)}`,
|
||||
);
|
||||
results.push({
|
||||
variant,
|
||||
target_sha256: target.value.sha256,
|
||||
implementations: metadata.objc_dispatch_implementations.length,
|
||||
ivars: metadata.objc_ivars.length,
|
||||
coverage: metadata.coverage,
|
||||
});
|
||||
}
|
||||
const swiftPath = join(root, "libReaWitnessFixture.dylib");
|
||||
await exec("/usr/bin/xcrun", [
|
||||
"swiftc",
|
||||
"-emit-library",
|
||||
"-O",
|
||||
"-Xlinker",
|
||||
"-no_fixup_chains",
|
||||
fileURLToPath(
|
||||
new URL("../tests/conformance/native/dispatch.swift", import.meta.url),
|
||||
),
|
||||
"-o",
|
||||
swiftPath,
|
||||
]);
|
||||
for (const variant of ["swift-symbols", "swift-stripped"]) {
|
||||
if (variant === "swift-stripped")
|
||||
await exec("/usr/bin/strip", ["-x", swiftPath]);
|
||||
const target = await parseBinaryTarget(swiftPath);
|
||||
if (!target.ok) throw target.error;
|
||||
const observation = await inspectAppleDispatchMetadata(target.value, 5000);
|
||||
const metadata = observation.result;
|
||||
if (
|
||||
!metadata.swift_dispatch_slots.some(
|
||||
(slot) =>
|
||||
slot.table_kind === "class_vtable" &&
|
||||
slot.owner === "ReaVtableFixture" &&
|
||||
slot.decode.status === "decoded",
|
||||
)
|
||||
)
|
||||
throw new Error(
|
||||
`Swift class vtable fixture unavailable: ${JSON.stringify(metadata.coverage)}`,
|
||||
);
|
||||
if (
|
||||
!metadata.swift_conformances.some(
|
||||
(item) =>
|
||||
item.type_name === "ReaWitnessFixture" &&
|
||||
item.protocol_name === "ReaWitnessFixtureProtocol",
|
||||
) ||
|
||||
!metadata.swift_dispatch_slots.some(
|
||||
(item) =>
|
||||
item.owner === "ReaWitnessFixture: ReaWitnessFixtureProtocol" &&
|
||||
item.implementation_address !== null,
|
||||
)
|
||||
)
|
||||
throw new Error(
|
||||
`Swift metadata fixture drifted: ${JSON.stringify(observation)}`,
|
||||
);
|
||||
results.push({
|
||||
variant,
|
||||
target_sha256: target.value.sha256,
|
||||
conformances: metadata.swift_conformances.length,
|
||||
slots: metadata.swift_dispatch_slots.length,
|
||||
coverage: metadata.coverage,
|
||||
});
|
||||
for (const mode of LINK_MODES) {
|
||||
const objcPath = join(root, `fixture-${mode.mode}`);
|
||||
await exec("/usr/bin/xcrun", [
|
||||
"clang",
|
||||
"-O2",
|
||||
"-framework",
|
||||
"Foundation",
|
||||
...mode.flags,
|
||||
source("dispatch.m"),
|
||||
"-o",
|
||||
objcPath,
|
||||
]);
|
||||
for (const variant of ["symbols", "stripped"]) {
|
||||
if (variant === "stripped")
|
||||
await exec("/usr/bin/strip", ["-x", objcPath]);
|
||||
const { target, metadata } = await inspect(objcPath);
|
||||
checkObjc(metadata, mode);
|
||||
results.push({
|
||||
variant: `objc-${mode.mode}-${variant}`,
|
||||
target_sha256: target.sha256,
|
||||
classes: metadata.objc_classes.length,
|
||||
categories: metadata.objc_categories.length,
|
||||
implementations: metadata.objc_dispatch_implementations.length,
|
||||
fixups: fixupCoverage(metadata)?.reason,
|
||||
});
|
||||
}
|
||||
if (!mode.swift) continue;
|
||||
const swiftPath = join(root, `libReaWitnessFixture-${mode.mode}.dylib`);
|
||||
await exec("/usr/bin/xcrun", [
|
||||
"swiftc",
|
||||
"-emit-library",
|
||||
"-O",
|
||||
...mode.flags
|
||||
.map((flag) => flag.replace(/^-Wl,/u, "-Xlinker\0"))
|
||||
.flatMap((flag) => flag.split("\0")),
|
||||
source("dispatch.swift"),
|
||||
"-o",
|
||||
swiftPath,
|
||||
]);
|
||||
for (const variant of ["symbols", "stripped"]) {
|
||||
if (variant === "stripped")
|
||||
await exec("/usr/bin/strip", ["-x", swiftPath]);
|
||||
const { target, metadata } = await inspect(swiftPath);
|
||||
checkSwift(metadata, mode);
|
||||
results.push({
|
||||
variant: `swift-${mode.mode}-${variant}`,
|
||||
target_sha256: target.sha256,
|
||||
conformances: metadata.swift_conformances.length,
|
||||
slots: metadata.swift_dispatch_slots.length,
|
||||
fixups: fixupCoverage(metadata)?.reason,
|
||||
});
|
||||
}
|
||||
}
|
||||
process.stdout.write(
|
||||
`${JSON.stringify({ ok: true, target_executed: false, fixtures: results })}\n`,
|
||||
|
||||
@@ -4,7 +4,7 @@ description: Reverse engineer native, managed, Electron/JavaScript, packaged, fi
|
||||
metadata:
|
||||
version: "29"
|
||||
tool_count: 133
|
||||
catalog_digest: "f8946c1a0c1084e431e313a8c2b3585ff0838bd8e6c0d33ac924d1cc00410e0a"
|
||||
catalog_digest: "1feec963472a4018075b8c47bd2356ae9bc2340f9c1de0beabad202db5f3e7b8"
|
||||
---
|
||||
|
||||
# REA
|
||||
|
||||
@@ -3,6 +3,7 @@ import { constants } from "node:fs";
|
||||
import { lstat, open, readlink, realpath } from "node:fs/promises";
|
||||
import { join, relative, resolve, sep } from "node:path";
|
||||
|
||||
import { resolveTreePath } from "../domain/dyldPaths.js";
|
||||
import {
|
||||
dylibResolutionInputSchema,
|
||||
dylibResolutionResultSchema,
|
||||
@@ -20,10 +21,14 @@ import { hasMachoMagic, readMachoImage } from "./MachoLoadCommandReader.js";
|
||||
|
||||
const HASH_CHUNK_BYTES = 1024 * 1024;
|
||||
|
||||
/** Device, inode, size and change times of the file whose bytes were parsed. */
|
||||
type FileIdentity = string;
|
||||
|
||||
/** Lazily probed, symlink-preserving view of one analyzed directory. */
|
||||
class FilesystemTreeView implements DylibTreeView {
|
||||
readonly #entries = new Map<string, Promise<DylibTreeEntry | undefined>>();
|
||||
readonly #images = new Map<string, Promise<MachoImageFacts>>();
|
||||
readonly #identities = new Map<string, FileIdentity>();
|
||||
|
||||
constructor(
|
||||
private readonly root: string,
|
||||
@@ -41,11 +46,21 @@ class FilesystemTreeView implements DylibTreeView {
|
||||
image(path: string): Promise<MachoImageFacts> {
|
||||
const cached = this.#images.get(path);
|
||||
if (cached !== undefined) return cached;
|
||||
const pending = readImage(join(this.root, path), this.signal);
|
||||
const pending = readImage(join(this.root, path), this.signal).then(
|
||||
({ facts, identity }) => {
|
||||
this.#identities.set(path, identity);
|
||||
return facts;
|
||||
},
|
||||
);
|
||||
this.#images.set(path, pending);
|
||||
return pending;
|
||||
}
|
||||
|
||||
/** Identity of the file whose header bytes `image()` parsed. */
|
||||
identity(path: string): FileIdentity | undefined {
|
||||
return this.#identities.get(path);
|
||||
}
|
||||
|
||||
async #readEntry(path: string): Promise<DylibTreeEntry | undefined> {
|
||||
cancelled(this.signal);
|
||||
const absolute = join(this.root, path);
|
||||
@@ -85,13 +100,13 @@ export const traceDylibResolution = async (options: {
|
||||
let cache: DyldSharedCache | undefined;
|
||||
try {
|
||||
cache = await openSharedCache(parsed.data.shared_cache, options.signal);
|
||||
const { roots, unclassified } =
|
||||
const { roots: requested, unclassified } =
|
||||
parsed.data.roots !== undefined
|
||||
? { roots: parsed.data.roots, unclassified: [] }
|
||||
: options.enumerateRoots
|
||||
? await executableRoots(root, view, options.signal)
|
||||
: { roots: [target], unclassified: [] };
|
||||
await requireMachoRoots(view, roots);
|
||||
const roots = await requireMachoRoots(view, requested);
|
||||
const trace = await traceDylibLoading(view, {
|
||||
roots,
|
||||
unclassified,
|
||||
@@ -101,12 +116,24 @@ export const traceDylibResolution = async (options: {
|
||||
...(cache === undefined ? {} : { sharedCache: sharedCacheView(cache) }),
|
||||
...(options.signal === undefined ? {} : { signal: options.signal }),
|
||||
});
|
||||
// Each digest must describe the same file whose headers were parsed.
|
||||
const digests = new Map<string, string>();
|
||||
for (const { path } of trace.images)
|
||||
digests.set(path, await fileSha256(join(root, path), options.signal));
|
||||
digests.set(
|
||||
path,
|
||||
await fileSha256(join(root, path), {
|
||||
path,
|
||||
expected: view.identity(path),
|
||||
...(options.signal === undefined ? {} : { signal: options.signal }),
|
||||
}),
|
||||
);
|
||||
const targetDigest =
|
||||
digests.get(target) ??
|
||||
(await fileSha256(join(root, target), options.signal));
|
||||
(await fileSha256(join(root, target), {
|
||||
path: target,
|
||||
expected: undefined,
|
||||
...(options.signal === undefined ? {} : { signal: options.signal }),
|
||||
}));
|
||||
if (targetDigest !== options.targetSha256)
|
||||
throw new ArtifactReaderFailure(
|
||||
"integrity",
|
||||
@@ -215,23 +242,35 @@ const executableRoots = async (
|
||||
const compare = (left: string, right: string): number =>
|
||||
left < right ? -1 : left > right ? 1 : 0;
|
||||
|
||||
/**
|
||||
* Resolve each root segment by segment, as dependency candidates are, so a
|
||||
* symlink in an intermediate directory cannot lead outside the analyzed root.
|
||||
*/
|
||||
const requireMachoRoots = async (
|
||||
view: FilesystemTreeView,
|
||||
roots: readonly string[],
|
||||
): Promise<void> => {
|
||||
): Promise<string[]> => {
|
||||
const resolved: string[] = [];
|
||||
for (const path of roots) {
|
||||
const entry = await view.entry(path);
|
||||
if (entry?.kind !== "file")
|
||||
const lookup = await resolveTreePath(view, path);
|
||||
if (lookup.kind === "escapes")
|
||||
throw new ArtifactReaderFailure(
|
||||
"path",
|
||||
`Root ${path} resolves outside the analyzed root`,
|
||||
);
|
||||
if (lookup.kind !== "file")
|
||||
throw new ArtifactReaderFailure(
|
||||
"path",
|
||||
`Root ${path} is not a regular file in the analyzed root`,
|
||||
);
|
||||
if ((await view.image(path)).status === "not-mach-o")
|
||||
if ((await view.image(lookup.path)).status === "not-mach-o")
|
||||
throw new ArtifactReaderFailure(
|
||||
"format",
|
||||
`Root ${path} is not a Mach-O image`,
|
||||
);
|
||||
if (!resolved.includes(lookup.path)) resolved.push(lookup.path);
|
||||
}
|
||||
return resolved;
|
||||
};
|
||||
|
||||
const startsWithMachoMagic = async (path: string): Promise<boolean> => {
|
||||
@@ -245,15 +284,34 @@ const startsWithMachoMagic = async (path: string): Promise<boolean> => {
|
||||
}
|
||||
};
|
||||
|
||||
const identityOf = (metadata: {
|
||||
readonly dev: bigint;
|
||||
readonly ino: bigint;
|
||||
readonly size: bigint;
|
||||
readonly mtimeNs: bigint;
|
||||
readonly ctimeNs: bigint;
|
||||
}): FileIdentity =>
|
||||
[
|
||||
metadata.dev,
|
||||
metadata.ino,
|
||||
metadata.size,
|
||||
metadata.mtimeNs,
|
||||
metadata.ctimeNs,
|
||||
].join(":");
|
||||
|
||||
const readImage = async (
|
||||
path: string,
|
||||
signal?: AbortSignal,
|
||||
): Promise<MachoImageFacts> => {
|
||||
): Promise<{
|
||||
readonly facts: MachoImageFacts;
|
||||
readonly identity: FileIdentity;
|
||||
}> => {
|
||||
cancelled(signal);
|
||||
const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
|
||||
try {
|
||||
const { size } = await handle.stat();
|
||||
return await readMachoImage(async (offset, length) => {
|
||||
const metadata = await handle.stat({ bigint: true });
|
||||
const size = Number(metadata.size);
|
||||
const facts = await readMachoImage(async (offset, length) => {
|
||||
cancelled(signal);
|
||||
const buffer = new Uint8Array(
|
||||
Math.max(0, Math.min(length, size - offset)),
|
||||
@@ -261,17 +319,38 @@ const readImage = async (
|
||||
const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset);
|
||||
return buffer.subarray(0, bytesRead);
|
||||
}, size);
|
||||
return { facts, identity: identityOf(metadata) };
|
||||
} finally {
|
||||
await handle.close();
|
||||
}
|
||||
};
|
||||
|
||||
/** Hash a file, failing if it is not the file (or the version) that was parsed. */
|
||||
const fileSha256 = async (
|
||||
path: string,
|
||||
signal?: AbortSignal,
|
||||
absolute: string,
|
||||
options: {
|
||||
readonly path: string;
|
||||
readonly expected: FileIdentity | undefined;
|
||||
readonly signal?: AbortSignal;
|
||||
},
|
||||
): Promise<string> => {
|
||||
const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
|
||||
const { signal } = options;
|
||||
const handle = await open(
|
||||
absolute,
|
||||
constants.O_RDONLY | constants.O_NOFOLLOW,
|
||||
);
|
||||
const unchanged = async (): Promise<void> => {
|
||||
if (
|
||||
options.expected !== undefined &&
|
||||
identityOf(await handle.stat({ bigint: true })) !== options.expected
|
||||
)
|
||||
throw new ArtifactReaderFailure(
|
||||
"integrity",
|
||||
`${options.path} changed while its dyld load commands were traced`,
|
||||
);
|
||||
};
|
||||
try {
|
||||
await unchanged();
|
||||
const hash = createHash("sha256");
|
||||
const buffer = new Uint8Array(HASH_CHUNK_BYTES);
|
||||
for (;;) {
|
||||
@@ -280,6 +359,7 @@ const fileSha256 = async (
|
||||
if (bytesRead === 0) break;
|
||||
hash.update(buffer.subarray(0, bytesRead));
|
||||
}
|
||||
await unchanged();
|
||||
return hash.digest("hex");
|
||||
} finally {
|
||||
await handle.close();
|
||||
|
||||
@@ -186,13 +186,16 @@ describe("Mach-O load command reader inputs", () => {
|
||||
{ id: 2, name: "ios" },
|
||||
{ id: 99, name: null },
|
||||
]);
|
||||
const short = new Uint8Array(8);
|
||||
new DataView(short.buffer).setUint32(0, LC.BUILD_VERSION, true);
|
||||
new DataView(short.buffer).setUint32(4, 8, true);
|
||||
expect(await read(machoImage({ commands: [short] }))).toEqual({
|
||||
status: "malformed",
|
||||
reason: "load command 0 is too short for a platform version",
|
||||
});
|
||||
// A 16-byte LC_BUILD_VERSION, and one that declares a tool it lacks.
|
||||
const truncated = buildVersionCommand(1).slice(0, 16);
|
||||
new DataView(truncated.buffer).setUint32(4, 16, true);
|
||||
const missingTool = buildVersionCommand(1);
|
||||
new DataView(missingTool.buffer).setUint32(20, 1, true);
|
||||
for (const command of [truncated, missingTool])
|
||||
expect(await read(machoImage({ commands: [command] }))).toEqual({
|
||||
status: "malformed",
|
||||
reason: "load command 0 is too short for a platform version",
|
||||
});
|
||||
});
|
||||
|
||||
it("names 32-bit and non-Mach-O inputs without guessing", async () => {
|
||||
@@ -240,9 +243,10 @@ describe("Mach-O load command reader failures", () => {
|
||||
});
|
||||
|
||||
it("requires 8-byte command alignment in 64-bit images", async () => {
|
||||
// A command the reader does not decode; only its size is checked.
|
||||
const command = new Uint8Array(12);
|
||||
const view = new DataView(command.buffer);
|
||||
view.setUint32(0, LC.CODE_SIGNATURE, true);
|
||||
view.setUint32(0, 0x7f000001, true);
|
||||
view.setUint32(4, 12, true);
|
||||
expect(await read(machoImage({ commands: [command] }))).toMatchObject({
|
||||
status: "malformed",
|
||||
@@ -286,6 +290,11 @@ describe("Mach-O load command reader failures", () => {
|
||||
status: "malformed",
|
||||
reason: "load command 0 is too short to hold a string offset",
|
||||
});
|
||||
view.setUint32(0, LC.CODE_SIGNATURE, true);
|
||||
expect(await read(machoImage({ commands: [short] }))).toMatchObject({
|
||||
status: "malformed",
|
||||
reason: "load command 0 is too short for LC_CODE_SIGNATURE",
|
||||
});
|
||||
});
|
||||
|
||||
it("rejects strings that are unterminated, misplaced or not UTF-8", async () => {
|
||||
|
||||
@@ -289,12 +289,26 @@ const decodeCommand = (
|
||||
return;
|
||||
}
|
||||
if (command === LC_CODE_SIGNATURE) {
|
||||
// linkedit_data_command: cmd, cmdsize, dataoff, datasize.
|
||||
if (body.byteLength < 16)
|
||||
throw new MachoFormatIssue(
|
||||
"malformed",
|
||||
`load command ${index} is too short for LC_CODE_SIGNATURE`,
|
||||
);
|
||||
slice.code_signature_present = true;
|
||||
return;
|
||||
}
|
||||
const implied = VERSION_MIN_PLATFORMS.get(command);
|
||||
if (command === LC_BUILD_VERSION || implied !== undefined) {
|
||||
if (body.byteLength < 12)
|
||||
// version_min_command is 16 bytes; build_version_command is 24 bytes
|
||||
// followed by ntools 8-byte build_tool_version records.
|
||||
const required =
|
||||
implied !== undefined
|
||||
? 16
|
||||
: body.byteLength < 24
|
||||
? 24
|
||||
: 24 + viewOf(body).getUint32(20, true) * 8;
|
||||
if (body.byteLength < required)
|
||||
throw new MachoFormatIssue(
|
||||
"malformed",
|
||||
`load command ${index} is too short for a platform version`,
|
||||
|
||||
@@ -309,6 +309,29 @@ describe("Apple bundle layouts and containers", () => {
|
||||
expect(
|
||||
result.bundles.find(({ path }) => path === framework)?.info_plist_path,
|
||||
).toBeNull();
|
||||
// Files beside the only real version are not versions.
|
||||
const withFiles = project(
|
||||
inventoryEvidence("zip", "Fixture.zip", [
|
||||
macho("Fixture.app/Contents/MacOS/Fixture"),
|
||||
{ path: `${framework}/Versions/A/Resources/Info.plist` },
|
||||
{ path: `${framework}/Versions/.DS_Store` },
|
||||
{ path: `${framework}/Versions/Current`, kind: "symlink" },
|
||||
]),
|
||||
);
|
||||
expect(
|
||||
withFiles.bundles.find(({ path }) => path === framework)?.info_plist_path,
|
||||
).toBe(`${framework}/Versions/A/Resources/Info.plist`);
|
||||
// Only A has a plist, but Versions/Current may select B.
|
||||
const onlyA = project(
|
||||
inventoryEvidence("zip", "Fixture.zip", [
|
||||
macho("Fixture.app/Contents/MacOS/Fixture"),
|
||||
{ path: `${framework}/Versions/A/Resources/Info.plist` },
|
||||
macho(`${framework}/Versions/B/Core`),
|
||||
]),
|
||||
);
|
||||
expect(
|
||||
onlyA.bundles.find(({ path }) => path === framework)?.info_plist_path,
|
||||
).toBeNull();
|
||||
expect(result.limitations).toContainEqual(
|
||||
expect.stringContaining("Versions/Current selects is unknown"),
|
||||
);
|
||||
@@ -438,3 +461,37 @@ describe("macOS application scope", () => {
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Apple application bridge candidates", () => {
|
||||
it("pairs scripts and native code only within one application root", () => {
|
||||
const result = project(
|
||||
inventoryEvidence("zip", "Suite.zip", [
|
||||
macho("First.app/Contents/MacOS/First"),
|
||||
{
|
||||
path: "First.app/Contents/Resources/first.js",
|
||||
format: "javascript-bundle",
|
||||
},
|
||||
macho("Second.app/Contents/MacOS/Second"),
|
||||
{
|
||||
path: "Second.app/Contents/Resources/second.js",
|
||||
format: "javascript-bundle",
|
||||
},
|
||||
]),
|
||||
);
|
||||
expect(result.application_roots).toEqual(["First.app", "Second.app"]);
|
||||
expect(
|
||||
result.bridge_candidates.map(
|
||||
({ source_path: source, native_path: target }) => [source, target],
|
||||
),
|
||||
).toEqual([
|
||||
[
|
||||
"First.app/Contents/Resources/first.js",
|
||||
"First.app/Contents/MacOS/First",
|
||||
],
|
||||
[
|
||||
"Second.app/Contents/Resources/second.js",
|
||||
"Second.app/Contents/MacOS/Second",
|
||||
],
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -149,6 +149,7 @@ export const projectAppleApplication = (
|
||||
...classified.executables,
|
||||
...classified.native_libraries,
|
||||
]),
|
||||
roots,
|
||||
);
|
||||
const uninventoriedImage =
|
||||
rootFormat === "dmg" && inventory.occurrences.length === 1;
|
||||
@@ -305,18 +306,27 @@ const identifyRuntimeFamilies = (all: readonly Component[]) => {
|
||||
return [...families].sort(compare);
|
||||
};
|
||||
|
||||
/** Pair scripts and native code only within the same application root. */
|
||||
const identifyBridgeCandidates = (
|
||||
scripts: readonly Component[],
|
||||
native: readonly Component[],
|
||||
) => ({
|
||||
candidates: scripts.flatMap((script) =>
|
||||
native.map((item) => ({
|
||||
source_path: script.path,
|
||||
native_path: item.path,
|
||||
basis: bridgeBasis(item.path),
|
||||
})),
|
||||
),
|
||||
});
|
||||
roots: readonly string[],
|
||||
) => {
|
||||
const owner = (path: string): string | null =>
|
||||
roots.find((root) => isWithin(path, root)) ?? null;
|
||||
return {
|
||||
candidates: scripts.flatMap((script) => {
|
||||
const root = owner(script.path);
|
||||
return native
|
||||
.filter(({ path }) => owner(path) === root)
|
||||
.map((item) => ({
|
||||
source_path: script.path,
|
||||
native_path: item.path,
|
||||
basis: bridgeBasis(item.path),
|
||||
}));
|
||||
}),
|
||||
};
|
||||
};
|
||||
|
||||
const bridgeBasis = (
|
||||
path: string,
|
||||
@@ -360,7 +370,7 @@ const projectionLimitations = (facts: {
|
||||
layout === "versioned-framework" && plist === null,
|
||||
)
|
||||
? [
|
||||
"A versioned framework has zero or several Versions/*/Resources/Info.plist files; the one Versions/Current selects is unknown because symlink targets are not inventoried.",
|
||||
"A versioned framework has several version directories or no Versions/*/Resources/Info.plist; the Info.plist that Versions/Current selects is unknown because symlink targets are not inventoried.",
|
||||
]
|
||||
: []),
|
||||
...(facts.symlinks
|
||||
|
||||
@@ -141,14 +141,18 @@ export const detectBundles = (
|
||||
interface Tree {
|
||||
readonly children: ReadonlyMap<string, ReadonlySet<string>>;
|
||||
readonly files: ReadonlyMap<string, Component>;
|
||||
/** Paths observed as directories, or implied by a deeper path. */
|
||||
readonly directories: ReadonlySet<string>;
|
||||
}
|
||||
|
||||
const indexTree = (entries: readonly Entry[]): Tree => {
|
||||
const children = new Map<string, Set<string>>();
|
||||
const files = new Map<string, Component>();
|
||||
const directories = new Set<string>();
|
||||
for (const { path, kind, component } of entries) {
|
||||
if (isSidecar(path)) continue;
|
||||
if (kind === "file" && component !== undefined) files.set(path, component);
|
||||
if (kind === "directory") directories.add(path);
|
||||
const segments = path.split("/");
|
||||
let parent = "";
|
||||
for (const segment of segments) {
|
||||
@@ -156,9 +160,10 @@ const indexTree = (entries: readonly Entry[]): Tree => {
|
||||
names.add(segment);
|
||||
children.set(parent, names);
|
||||
parent = joinPath(parent, segment);
|
||||
if (parent !== path) directories.add(parent);
|
||||
}
|
||||
}
|
||||
return { children, files };
|
||||
return { children, files, directories };
|
||||
};
|
||||
|
||||
const joinPath = (directory: string, name: string): string =>
|
||||
@@ -223,9 +228,12 @@ const contentDirectories = (
|
||||
if (layout === "macos-deep") return [joinPath(directory, "Contents")];
|
||||
if (layout === "shallow") return [directory];
|
||||
const versions = joinPath(directory, "Versions");
|
||||
// Only real version directories count: Current is a symlink, and files
|
||||
// such as .DS_Store are not versions.
|
||||
return [...(tree.children.get(versions) ?? [])]
|
||||
.filter((version) => version !== "Current")
|
||||
.map((version) => joinPath(versions, version))
|
||||
.filter((version) => tree.directories.has(version))
|
||||
.sort(compare);
|
||||
};
|
||||
|
||||
@@ -234,7 +242,11 @@ const infoPlistPath = (
|
||||
layout: Bundle["layout"],
|
||||
tree: Tree,
|
||||
): string | null => {
|
||||
const candidates = contentDirectories(bundle, layout, tree)
|
||||
const directories = contentDirectories(bundle, layout, tree);
|
||||
// With several real versions, Versions/Current (a symlink outside the
|
||||
// inventory) decides which plist applies, so the plist stays unknown.
|
||||
if (directories.length !== 1) return null;
|
||||
const candidates = directories
|
||||
.map((directory) =>
|
||||
joinPath(
|
||||
directory,
|
||||
|
||||
@@ -109,10 +109,12 @@ export const compatibleSlice = (
|
||||
return undefined;
|
||||
};
|
||||
|
||||
/** A cache serves processes of its CPU family: arm64e also serves arm64. */
|
||||
/**
|
||||
* Whether a cache serves a process architecture. Compatibility is directional:
|
||||
* an arm64e cache also serves arm64 processes and an x86_64h cache also serves
|
||||
* x86_64 ones, but a generic cache lacks the arm64e or x86_64h ABI.
|
||||
*/
|
||||
export const cacheServes = (cache: string, process: string): boolean =>
|
||||
cache === process ||
|
||||
(cache.startsWith("arm64") &&
|
||||
process.startsWith("arm64") &&
|
||||
process !== "arm64_32") ||
|
||||
(cache.startsWith("x86_64") && process.startsWith("x86_64"));
|
||||
(cache === "arm64e" && process === "arm64") ||
|
||||
(cache === "x86_64h" && process === "x86_64");
|
||||
|
||||
@@ -647,6 +647,17 @@ describe("shared cache applicability", () => {
|
||||
"The supplied shared cache was not used for Contents/MacOS/Old (arm64): the process records no LC_BUILD_VERSION or LC_VERSION_MIN platform. Its absolute paths stay outside-target.",
|
||||
]),
|
||||
);
|
||||
const generic = await traceDylibLoading(
|
||||
memoryView({
|
||||
[MAIN]: executable({
|
||||
architecture: "arm64e",
|
||||
dependencies: [dependency("/usr/lib/libSystem.B.dylib")],
|
||||
}),
|
||||
}),
|
||||
{ roots: [MAIN], sharedCache: cache({ architecture: "arm64" }) },
|
||||
);
|
||||
// A generic arm64 cache lacks the arm64e ABI.
|
||||
expect(generic.edges[0]?.candidates[0]?.outcome).toBe("outside-target");
|
||||
const unknownPlatform = await traceDylibLoading(
|
||||
memoryView({
|
||||
[MAIN]: executable({
|
||||
@@ -727,3 +738,48 @@ describe("lazily loaded dependencies", () => {
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("conditional loads", () => {
|
||||
it("carries a conditional fallback's uncertainty to its dependents and reuses", async () => {
|
||||
const VENDOR = "Contents/Frameworks/libvendor.dylib";
|
||||
const OTHER = "Contents/Frameworks/libother.dylib";
|
||||
const trace = await traceDylibLoading(
|
||||
memoryView({
|
||||
[MAIN]: executable({
|
||||
rpaths: ["/opt/vendor/lib", "@executable_path/../Frameworks"],
|
||||
dependencies: [
|
||||
dependency("@rpath/libvendor.dylib"),
|
||||
dependency("@executable_path/../Frameworks/libother.dylib"),
|
||||
],
|
||||
}),
|
||||
[VENDOR]: parsed(
|
||||
slice({
|
||||
install_name: "@rpath/libvendor.dylib",
|
||||
dependencies: [dependency("@loader_path/libgone.dylib")],
|
||||
}),
|
||||
),
|
||||
[OTHER]: parsed(
|
||||
slice({ dependencies: [dependency("@rpath/libvendor.dylib")] }),
|
||||
),
|
||||
}),
|
||||
{ roots: [MAIN] },
|
||||
);
|
||||
expect(edgeFor(trace, MAIN, "@rpath/libvendor.dylib")).toMatchObject({
|
||||
resolution: { status: "conditional", image: VENDOR },
|
||||
loader_conditional: false,
|
||||
});
|
||||
expect(edgeFor(trace, VENDOR, "@loader_path/libgone.dylib")).toMatchObject({
|
||||
resolution: { status: "unresolved" },
|
||||
loader_conditional: true,
|
||||
});
|
||||
expect(edgeFor(trace, OTHER, "@rpath/libvendor.dylib")).toMatchObject({
|
||||
candidates: [{ source: "already-loaded" }],
|
||||
resolution: { status: "conditional", image: VENDOR },
|
||||
loader_conditional: false,
|
||||
});
|
||||
expect(
|
||||
trace.findings.find(({ kind }) => kind === "required-load-unresolved")
|
||||
?.explanation,
|
||||
).toContain(`${VENDOR} loads only conditionally`);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -48,6 +48,8 @@ interface LoadedImage {
|
||||
readonly slice: MachoSlice;
|
||||
/** Images from the process root to this image; the rpath stack, outermost first. */
|
||||
readonly chain: readonly string[];
|
||||
/** Some edge on the chain was conditional: an unknown earlier candidate may load instead. */
|
||||
readonly conditional: boolean;
|
||||
}
|
||||
|
||||
interface ProcessContext {
|
||||
@@ -199,7 +201,8 @@ const resolveDependency = async (
|
||||
loader: string,
|
||||
context: ProcessContext,
|
||||
): Promise<Edge> => {
|
||||
const chain = context.loaded.get(loader)?.chain ?? [loader];
|
||||
const current = context.loaded.get(loader);
|
||||
const chain = current?.chain ?? [loader];
|
||||
const loaded = context.byInstallName.get(dependency.install_name);
|
||||
const candidates: Candidate[] = [];
|
||||
if (loaded !== undefined)
|
||||
@@ -222,7 +225,14 @@ const resolveDependency = async (
|
||||
)
|
||||
break;
|
||||
}
|
||||
const resolved = resolution(candidates);
|
||||
const searched = resolution(candidates);
|
||||
// Reusing an image that itself loads only conditionally is conditional too.
|
||||
const resolved: Edge["resolution"] =
|
||||
loaded !== undefined &&
|
||||
context.loaded.get(loaded)?.conditional === true &&
|
||||
searched.status === "resolved"
|
||||
? { ...searched, status: "conditional" }
|
||||
: searched;
|
||||
const image =
|
||||
resolved.image === null ? undefined : context.images.get(resolved.image);
|
||||
const slice =
|
||||
@@ -241,6 +251,7 @@ const resolveDependency = async (
|
||||
slice === undefined || slice.install_name === null
|
||||
? null
|
||||
: slice.install_name === dependency.install_name,
|
||||
loader_conditional: current?.conditional ?? false,
|
||||
};
|
||||
};
|
||||
|
||||
@@ -254,7 +265,11 @@ const traceProcess = async (
|
||||
signal?: AbortSignal,
|
||||
): Promise<Edge[]> => {
|
||||
const edges: Edge[] = [];
|
||||
context.loaded.set(context.root, { slice: rootSlice, chain: [context.root] });
|
||||
context.loaded.set(context.root, {
|
||||
slice: rootSlice,
|
||||
chain: [context.root],
|
||||
conditional: false,
|
||||
});
|
||||
if (rootSlice.install_name !== null)
|
||||
context.byInstallName.set(rootSlice.install_name, context.root);
|
||||
const pending = [context.root];
|
||||
@@ -277,7 +292,13 @@ const traceProcess = async (
|
||||
? compatibleSlice(facts.slices, context.architecture)
|
||||
: undefined;
|
||||
if (slice === undefined) continue;
|
||||
context.loaded.set(image, { slice, chain: [...current.chain, image] });
|
||||
context.loaded.set(image, {
|
||||
slice,
|
||||
chain: [...current.chain, image],
|
||||
// dyld may load an unknown earlier candidate instead of this fallback.
|
||||
conditional:
|
||||
current.conditional || edge.resolution.status === "conditional",
|
||||
});
|
||||
if (
|
||||
slice.install_name !== null &&
|
||||
!context.byInstallName.has(slice.install_name)
|
||||
|
||||
@@ -76,7 +76,9 @@ const unresolvedFinding = (edge: Edge, index: number): Finding => {
|
||||
: {
|
||||
...base,
|
||||
kind: "required-load-unresolved",
|
||||
explanation: `No candidate for ${edge.install_name} exists in the analyzed root; dyld would fail to launch ${edge.root} (${edge.architecture}) unless the image is supplied elsewhere.`,
|
||||
explanation: edge.loader_conditional
|
||||
? `No candidate for ${edge.install_name} exists in the analyzed root. ${edge.loader} loads only conditionally; if it loads, dyld would fail to launch ${edge.root} (${edge.architecture}) unless the image is supplied elsewhere.`
|
||||
: `No candidate for ${edge.install_name} exists in the analyzed root; dyld would fail to launch ${edge.root} (${edge.architecture}) unless the image is supplied elsewhere.`,
|
||||
};
|
||||
};
|
||||
|
||||
@@ -84,7 +86,7 @@ export const DYLIB_RESOLUTION_LIMITATIONS = [
|
||||
"LC_LAZY_LOAD_DYLIB dependencies are resolved but not traversed, because dyld loads them only on first use.",
|
||||
"Slices are matched by dyld's graded architectures (an x86_64h process also loads x86_64). arm64e processes that disable pointer authentication can also load arm64 slices; that fallback is not modeled.",
|
||||
"Leaf and relative install names depend on dyld fallback paths, DYLD_* variables, and the working directory; they are undetermined.",
|
||||
"Load order follows dyld's dependents-first traversal in load-command order. An image reached through several chains is resolved once per process, with the rpath stack of the first chain; a later request whose install name matches an already loaded image reuses it.",
|
||||
"Load order follows dyld's dependents-first traversal in load-command order. An image reached through several chains is resolved once per process, with the rpath stack and conditionality of the first chain; a later request whose install name matches an already loaded image reuses it.",
|
||||
"@loader_path uses each image's symlink-resolved path within the analyzed root.",
|
||||
"Code-signing checks that can reject a found image, such as library validation and the hardened runtime, are not evaluated.",
|
||||
"Dylib compatibility versions are not compared. Apple's linker documentation describes a load-time rejection when an image's compatibility version is older than the loader requires, but dyld on macOS 26 was observed to load such an image.",
|
||||
|
||||
@@ -130,6 +130,11 @@ const edgeSchema = z.strictObject({
|
||||
image: z.string().nullable(),
|
||||
}),
|
||||
install_name_matches: z.boolean().nullable(),
|
||||
/**
|
||||
* The loader was reached through a conditional edge, so it might not load;
|
||||
* this edge describes what happens only if it does.
|
||||
*/
|
||||
loader_conditional: z.boolean(),
|
||||
});
|
||||
|
||||
const findingSchema = z.strictObject({
|
||||
|
||||
@@ -149,6 +149,31 @@ describe("JavaScript semantic analysis: dataflow 1", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("JavaScript semantic call result flows", () => {
|
||||
it("links only directly assigned scalar call results", () => {
|
||||
const ir = analyzeJavaScriptSemantics(`
|
||||
function run() {
|
||||
const direct = produce();
|
||||
const { field } = unpack();
|
||||
const nested = outer(inner());
|
||||
return direct;
|
||||
}
|
||||
`);
|
||||
const bindingNames = new Map(
|
||||
ir.bindings.map(({ bindingId, name }) => [bindingId, name]),
|
||||
);
|
||||
|
||||
expect(
|
||||
ir.callResultFlows.map(({ bindingId }) => bindingNames.get(bindingId)),
|
||||
).toEqual(["direct", "nested"]);
|
||||
expect(ir.callSites).toHaveLength(4);
|
||||
expect(ir.callResultFlows.map(({ callSiteId }) => callSiteId)).toEqual([
|
||||
ir.callSites[0]?.callSiteId,
|
||||
ir.callSites[2]?.callSiteId,
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("JavaScript semantic analysis: read-modify-write", () => {
|
||||
it.each(["+= 1", "++", "--", "||= 1", "&&= 1", "??= 1"])(
|
||||
"retains the property read in a read-modify-write operation: %s",
|
||||
|
||||
@@ -183,9 +183,7 @@ const collectCallResultFlow = (
|
||||
context.ancestors,
|
||||
context.state,
|
||||
).filter(({ projectionPath }) => projectionPath.length === 0)) {
|
||||
const binding = [...context.state.bindingsById.values()].find(
|
||||
({ bindingId }) => bindingId === assigned.bindingId,
|
||||
);
|
||||
const binding = context.state.bindingsById.get(assigned.bindingId);
|
||||
if (binding === undefined) continue;
|
||||
const identifierRange = range(assigned.identifier);
|
||||
const definition = binding.definitions.find(
|
||||
|
||||
@@ -51,3 +51,16 @@ it("preserves source-tree enter/exit order and detached ancestor snapshots", ()
|
||||
],
|
||||
]);
|
||||
});
|
||||
|
||||
it("skips sparse child slots without disturbing sibling visit order", () => {
|
||||
const parsed = parseJavaScriptSource("const values = [first, , second];");
|
||||
if (parsed === null)
|
||||
throw new TypeError("Expected a parsed JavaScript fixture");
|
||||
const identifiers: string[] = [];
|
||||
traverseJavaScriptAst(parsed.program, {
|
||||
enter: (node) => {
|
||||
if (t.isIdentifier(node)) identifiers.push(node.name);
|
||||
},
|
||||
});
|
||||
expect(identifiers).toEqual(["values", "first", "second"]);
|
||||
});
|
||||
|
||||
@@ -51,11 +51,19 @@ interface TraversalFrame {
|
||||
}
|
||||
|
||||
const childNodes = (node: t.Node): t.Node[] => {
|
||||
const keys: readonly string[] = t.VISITOR_KEYS[node.type] ?? [];
|
||||
return keys.flatMap((key) => {
|
||||
const keys = t.VISITOR_KEYS[node.type];
|
||||
if (keys === undefined) return [];
|
||||
const children: t.Node[] = [];
|
||||
for (const key of keys) {
|
||||
const value: unknown = Reflect.get(node, key);
|
||||
if (t.isNode(value)) return [value];
|
||||
if (!Array.isArray(value)) return [];
|
||||
return value.filter((item): item is t.Node => t.isNode(item));
|
||||
});
|
||||
if (t.isNode(value)) {
|
||||
children.push(value);
|
||||
continue;
|
||||
}
|
||||
if (!Array.isArray(value)) continue;
|
||||
for (const item of value) {
|
||||
if (t.isNode(item)) children.push(item);
|
||||
}
|
||||
}
|
||||
return children;
|
||||
};
|
||||
|
||||
@@ -166,6 +166,7 @@ describe("Interface Builder dispatch joins", () => {
|
||||
const joined = joinInterfaceBuilderDispatch(ui.graph, {
|
||||
objc_classes: [],
|
||||
objc_protocols: [],
|
||||
objc_categories: [],
|
||||
swift_decls: [],
|
||||
objc_ivars: [],
|
||||
objc_protocol_records: [],
|
||||
@@ -227,6 +228,7 @@ describe("Interface Builder dispatch joins", () => {
|
||||
const metadata = {
|
||||
objc_classes: [],
|
||||
objc_protocols: [],
|
||||
objc_categories: [],
|
||||
swift_decls: [],
|
||||
objc_ivars: [],
|
||||
objc_protocol_records: [],
|
||||
@@ -304,6 +306,7 @@ describe("placeholder dispatch joins", () => {
|
||||
const joined = joinInterfaceBuilderDispatch(ui.graph, {
|
||||
objc_classes: [],
|
||||
objc_protocols: [],
|
||||
objc_categories: [],
|
||||
swift_decls: [],
|
||||
objc_ivars: [],
|
||||
objc_protocol_records: [],
|
||||
|
||||
@@ -156,6 +156,8 @@ export const objcDispatchImplementationSchema = z.strictObject({
|
||||
selector: z.string().min(1),
|
||||
method_type: z.enum(["instance", "class"]),
|
||||
implementation_address: z.string().nullable(),
|
||||
/** Category that adds this method, when it is not defined by the class itself. */
|
||||
category: z.string().nullable().optional(),
|
||||
location: nativeMetadataLocationSchema,
|
||||
decode: nativeMetadataDecodeSchema,
|
||||
evidence: z.array(nativeMetadataEvidenceSchema).min(1),
|
||||
@@ -164,6 +166,21 @@ export type ObjcDispatchImplementation = z.infer<
|
||||
typeof objcDispatchImplementationSchema
|
||||
>;
|
||||
|
||||
/** Objective-C category: methods, protocols and properties added to a class. */
|
||||
export const objcCategorySchema = z.strictObject({
|
||||
name: z.string().min(1),
|
||||
/** Extended class; external classes come from the category's bind symbol. */
|
||||
class_name: z.string().min(1).nullable(),
|
||||
class_source: z.enum(["local", "external", "unresolved"]),
|
||||
instance_methods: z.array(z.string()),
|
||||
class_methods: z.array(z.string()),
|
||||
protocols: z.array(z.string()),
|
||||
properties: z.array(objcPropertySchema),
|
||||
location: nativeMetadataLocationSchema,
|
||||
decode: nativeMetadataDecodeSchema,
|
||||
evidence: z.array(nativeMetadataEvidenceSchema).min(1),
|
||||
});
|
||||
|
||||
/** Swift protocol conformance and its associated witness-table location. */
|
||||
export const swiftConformanceSchema = z.strictObject({
|
||||
type_name: z.string().min(1),
|
||||
@@ -279,6 +296,7 @@ export type DbSaveResult = z.infer<typeof dbSaveResultSchema>;
|
||||
export const objcSwiftMetadataSchema = z.strictObject({
|
||||
objc_classes: z.array(objcClassSchema).default([]),
|
||||
objc_protocols: z.array(objcProtocolSchema).default([]),
|
||||
objc_categories: z.array(objcCategorySchema).default([]),
|
||||
swift_decls: z.array(swiftDeclSchema).default([]),
|
||||
objc_ivars: z.array(objcIvarSchema).default([]),
|
||||
objc_protocol_records: z.array(objcProtocolRecordSchema).default([]),
|
||||
|
||||
File diff suppressed because one or more lines are too long
@@ -151,6 +151,9 @@ describe("source-map layout admission", () => {
|
||||
expect(() => trace({ ...leaf, mappings })).toThrow();
|
||||
},
|
||||
);
|
||||
it("validates regular-map source indexes after reusing its decoded rows", () => {
|
||||
expect(() => trace({ ...leaf, mappings: "ACAA" })).toThrow(/index/u);
|
||||
});
|
||||
it("rejects huge indexed offsets before upstream row allocation", () => {
|
||||
expect(() =>
|
||||
trace({
|
||||
|
||||
@@ -81,10 +81,12 @@ const decodeValidatedMap = (
|
||||
inspected: ReturnType<typeof inspectSourceMap>,
|
||||
url: string,
|
||||
) => {
|
||||
let regularRows: ReturnType<typeof decodedMappings> | undefined;
|
||||
for (const leaf of inspected.leaves) {
|
||||
const decoded = decodedMappings(
|
||||
new TraceMap(JSON.stringify(leaf.map), url),
|
||||
);
|
||||
if (inspected.format === "regular") regularRows = decoded;
|
||||
for (const [line, row] of decoded.entries())
|
||||
for (const segment of row) {
|
||||
if (
|
||||
@@ -112,7 +114,7 @@ const decodeValidatedMap = (
|
||||
}
|
||||
}
|
||||
const map = new AnyMap(inspected.jsonText, url);
|
||||
const rows = decodedMappings(map);
|
||||
const rows = regularRows ?? decodedMappings(map);
|
||||
for (const row of rows)
|
||||
for (const segment of row) {
|
||||
if (
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
import type { ObjcSwiftMetadata } from "../domain/objcSwiftMetadata.js";
|
||||
import type { PointerFixups } from "./AppleMachoFixups.js";
|
||||
|
||||
const describeFixups = (fixups: PointerFixups): string => {
|
||||
if (fixups.kind === "chained")
|
||||
return `chained fixups: ${fixups.formats.join(", ") || "no fixup segments"}`;
|
||||
return fixups.kind === "dyld-info"
|
||||
? "LC_DYLD_INFO bind opcodes"
|
||||
: "no fixup load commands";
|
||||
};
|
||||
|
||||
/** Append the per-facet coverage of one Apple dispatch metadata decode. */
|
||||
export const pushDispatchCoverage = (input: {
|
||||
readonly result: ObjcSwiftMetadata;
|
||||
readonly failures: readonly string[];
|
||||
readonly examined: number;
|
||||
readonly categoriesExamined: number;
|
||||
readonly truncated: boolean;
|
||||
readonly fixups: PointerFixups;
|
||||
}): void => {
|
||||
const { result, failures, examined, categoriesExamined, truncated, fixups } =
|
||||
input;
|
||||
result.coverage.push({
|
||||
facet: "objc_class_method_ivar_metadata",
|
||||
status: failures.length > 0 || truncated ? "partial" : "complete",
|
||||
reason:
|
||||
[...failures, ...(truncated ? ["max_records_reached"] : [])].join("; ") ||
|
||||
null,
|
||||
examined,
|
||||
decoded: result.objc_classes.length,
|
||||
});
|
||||
result.coverage.push({
|
||||
facet: "binary_relative_pointers",
|
||||
status:
|
||||
truncated ||
|
||||
result.relative_pointers.some((item) => item.decode.status !== "decoded")
|
||||
? "partial"
|
||||
: "complete",
|
||||
reason: truncated
|
||||
? "max_records_reached"
|
||||
: result.relative_pointers.some(
|
||||
(item) => item.decode.status !== "decoded",
|
||||
)
|
||||
? "relative_pointer_targets_unresolved"
|
||||
: null,
|
||||
examined: result.relative_pointers.length,
|
||||
decoded: result.relative_pointers.filter(
|
||||
(item) => item.decode.status === "decoded",
|
||||
).length,
|
||||
});
|
||||
const categoryFailures = failures.filter((failure) =>
|
||||
/^(?:Properties of|Category at)/u.test(failure),
|
||||
);
|
||||
result.coverage.push({
|
||||
facet: "objc_properties_categories",
|
||||
status:
|
||||
categoryFailures.length > 0 ||
|
||||
result.objc_categories.some(({ decode }) => decode.status !== "decoded")
|
||||
? "partial"
|
||||
: "complete",
|
||||
reason: categoryFailures.join("; ") || null,
|
||||
examined: categoriesExamined,
|
||||
decoded: result.objc_categories.filter(
|
||||
({ decode }) => decode.status === "decoded",
|
||||
).length,
|
||||
});
|
||||
result.coverage.push({
|
||||
facet: "pointer_fixups",
|
||||
status: fixups.failures.length > 0 ? "partial" : "complete",
|
||||
reason: [describeFixups(fixups), ...fixups.failures].join("; "),
|
||||
examined: 0,
|
||||
decoded: 0,
|
||||
});
|
||||
result.coverage.push({
|
||||
facet: "swift_generic_resilient_witnesses_overrides_async_coroutines",
|
||||
status: "unsupported",
|
||||
reason:
|
||||
"This reader admits simple Swift conformance/static witness records and non-generic, non-resilient class vtables; generic/resilient tables and other Swift metadata families are not decoded",
|
||||
examined: 0,
|
||||
decoded: 0,
|
||||
});
|
||||
};
|
||||
@@ -9,6 +9,8 @@ import {
|
||||
import type { BinaryTarget } from "../domain/binaryTarget.js";
|
||||
import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
|
||||
import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
|
||||
import { pushDispatchCoverage } from "./AppleDispatchCoverage.js";
|
||||
import { parsePointerFixups } from "./AppleMachoFixups.js";
|
||||
import { parseMachoLayout } from "./AppleMachoSelection.js";
|
||||
import { decodeObjcDispatchFacets } from "./AppleObjcDispatchFacets.js";
|
||||
import {
|
||||
@@ -25,10 +27,26 @@ export const decodeAppleDispatchMetadata = (
|
||||
provenance: { path: string; sha256: string },
|
||||
architecture = "arm64",
|
||||
): ObjcSwiftMetadata => {
|
||||
const { segments, sections, offset } = parseMachoLayout(bytes, architecture);
|
||||
const layout = parseMachoLayout(bytes, architecture);
|
||||
const { segments, sections, offset } = layout;
|
||||
const fixups = parsePointerFixups(
|
||||
bytes,
|
||||
layout.fixups,
|
||||
segments,
|
||||
layout.baseAddress,
|
||||
);
|
||||
const u32 = (address: bigint) => bytes.readUInt32LE(offset(address, 4));
|
||||
const pointer = (address: bigint) =>
|
||||
bytes.readBigUInt64LE(offset(address, 8));
|
||||
const decodePointer = (address: bigint) =>
|
||||
fixups.decode(address, bytes.readBigUInt64LE(offset(address, 8)));
|
||||
/** Rebased target of a pointer; a bind to another image reads as 0. */
|
||||
const pointer = (address: bigint) => {
|
||||
const decodedPointer = decodePointer(address);
|
||||
return decodedPointer.kind === "rebase" ? decodedPointer.target : 0n;
|
||||
};
|
||||
const bound = (address: bigint) => {
|
||||
const decodedPointer = decodePointer(address);
|
||||
return decodedPointer.kind === "bind" ? decodedPointer : undefined;
|
||||
};
|
||||
const location = (address: bigint) => ({
|
||||
address: `0x${address.toString(16)}`,
|
||||
file_offset: offset(address),
|
||||
@@ -73,13 +91,15 @@ export const decodeAppleDispatchMetadata = (
|
||||
const readers = {
|
||||
u32,
|
||||
i32: (address: bigint) => bytes.readInt32LE(offset(address, 4)),
|
||||
u64: (address: bigint) => bytes.readBigUInt64LE(offset(address, 8)),
|
||||
pointer,
|
||||
bound,
|
||||
string,
|
||||
location,
|
||||
evidence,
|
||||
offset,
|
||||
};
|
||||
const { failures, examined } = decodeObjcDispatchFacets({
|
||||
const { failures, examined, categoriesExamined } = decodeObjcDispatchFacets({
|
||||
bytes,
|
||||
sections,
|
||||
segments,
|
||||
@@ -130,47 +150,14 @@ export const decodeAppleDispatchMetadata = (
|
||||
),
|
||||
},
|
||||
});
|
||||
result.coverage.push({
|
||||
facet: "objc_class_method_ivar_metadata",
|
||||
status: failures.length > 0 || budget.truncated ? "partial" : "complete",
|
||||
reason:
|
||||
[...failures, ...(budget.truncated ? ["max_records_reached"] : [])].join(
|
||||
"; ",
|
||||
) || null,
|
||||
pushDispatchCoverage({
|
||||
result,
|
||||
failures,
|
||||
examined,
|
||||
decoded: result.objc_classes.length,
|
||||
categoriesExamined,
|
||||
truncated: budget.truncated,
|
||||
fixups,
|
||||
});
|
||||
result.coverage.push({
|
||||
facet: "binary_relative_pointers",
|
||||
status:
|
||||
budget.truncated ||
|
||||
result.relative_pointers.some((item) => item.decode.status !== "decoded")
|
||||
? "partial"
|
||||
: "complete",
|
||||
reason: budget.truncated
|
||||
? "max_records_reached"
|
||||
: result.relative_pointers.some(
|
||||
(item) => item.decode.status !== "decoded",
|
||||
)
|
||||
? "relative_pointer_targets_unresolved"
|
||||
: null,
|
||||
examined: result.relative_pointers.length,
|
||||
decoded: result.relative_pointers.filter(
|
||||
(item) => item.decode.status === "decoded",
|
||||
).length,
|
||||
});
|
||||
for (const facet of [
|
||||
"objc_properties_categories",
|
||||
"swift_generic_resilient_witnesses_overrides_async_coroutines",
|
||||
])
|
||||
result.coverage.push({
|
||||
facet,
|
||||
status: "unsupported",
|
||||
reason:
|
||||
"This reader admits validated 64-bit Objective-C class/ivar/method lists and simple Swift conformance/static witness records; chained fixups, generic/resilient tables and other metadata families are not decoded",
|
||||
examined: 0,
|
||||
decoded: 0,
|
||||
});
|
||||
return objcSwiftMetadataSchema.parse(result);
|
||||
};
|
||||
|
||||
|
||||
@@ -0,0 +1,275 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
import {
|
||||
decodeChainedPointer,
|
||||
parsePointerFixups,
|
||||
} from "./AppleMachoFixups.js";
|
||||
import { parsePropertyAttributes } from "./AppleObjcProperties.js";
|
||||
import type { Segment } from "./AppleMachoSelection.js";
|
||||
|
||||
const BASE = 0x100000000n;
|
||||
const IMPORTS = [
|
||||
{
|
||||
symbol: "_OBJC_CLASS_$_NSObject",
|
||||
library: "/usr/lib/libobjc.A.dylib",
|
||||
weak: false,
|
||||
addend: 0n,
|
||||
},
|
||||
{
|
||||
symbol: "_free",
|
||||
library: "/usr/lib/libSystem.B.dylib",
|
||||
weak: true,
|
||||
addend: 4n,
|
||||
},
|
||||
];
|
||||
|
||||
const field = (value: bigint, from: number): bigint => value << BigInt(from);
|
||||
|
||||
describe("chained pointer decoding", () => {
|
||||
it("decodes DYLD_CHAINED_PTR_64 and _64_OFFSET rebases and binds", () => {
|
||||
const rebase = 0x4000n | field(0x80n, 36) | field(3n, 51);
|
||||
expect(decodeChainedPointer(BASE + 0x4000n, 2, BASE, IMPORTS)).toEqual({
|
||||
kind: "rebase",
|
||||
target: BASE + 0x4000n,
|
||||
});
|
||||
expect(decodeChainedPointer(rebase, 6, BASE, IMPORTS)).toEqual({
|
||||
kind: "rebase",
|
||||
target: (0x80n << 56n) + BASE + 0x4000n,
|
||||
});
|
||||
const bind = 1n | field(2n, 24) | field(1n, 63);
|
||||
expect(decodeChainedPointer(bind, 6, BASE, IMPORTS)).toEqual({
|
||||
kind: "bind",
|
||||
symbol: "_free",
|
||||
library: "/usr/lib/libSystem.B.dylib",
|
||||
weak: true,
|
||||
addend: 6n,
|
||||
});
|
||||
});
|
||||
|
||||
it("decodes arm64e plain, authenticated and 24-bit binds", () => {
|
||||
expect(decodeChainedPointer(0x8000n, 9, BASE, IMPORTS)).toEqual({
|
||||
kind: "rebase",
|
||||
target: BASE + 0x8000n,
|
||||
});
|
||||
expect(decodeChainedPointer(BASE + 0x8000n, 1, BASE, IMPORTS)).toEqual({
|
||||
kind: "rebase",
|
||||
target: BASE + 0x8000n,
|
||||
});
|
||||
const authRebase = 0x8000n | field(0x1234n, 32) | field(1n, 63);
|
||||
expect(decodeChainedPointer(authRebase, 1, BASE, IMPORTS)).toEqual({
|
||||
kind: "rebase",
|
||||
target: BASE + 0x8000n,
|
||||
});
|
||||
const authBind = 0n | field(1n, 62) | field(1n, 63);
|
||||
expect(decodeChainedPointer(authBind, 9, BASE, IMPORTS)).toMatchObject({
|
||||
kind: "bind",
|
||||
symbol: "_OBJC_CLASS_$_NSObject",
|
||||
addend: 0n,
|
||||
});
|
||||
const bind24 = 1n | field(0x7ffffn, 32) | field(1n, 62);
|
||||
expect(decodeChainedPointer(bind24, 12, BASE, IMPORTS)).toMatchObject({
|
||||
kind: "bind",
|
||||
symbol: "_free",
|
||||
addend: 3n,
|
||||
});
|
||||
expect(() =>
|
||||
decodeChainedPointer(field(1n, 62) | 9n, 9, BASE, IMPORTS),
|
||||
).toThrow("Chained bind ordinal 9 has no import");
|
||||
expect(() => decodeChainedPointer(1n, 3, BASE, IMPORTS)).toThrow(
|
||||
"Unsupported chained pointer format 3",
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
/** Build `LC_DYLD_CHAINED_FIXUPS` data with one fixup segment and the given imports. */
|
||||
const chainedData = (format: 1 | 2 | 3): Buffer => {
|
||||
const symbols = Buffer.from("\0_OBJC_CLASS_$_NSObject\0_free\0");
|
||||
const importSize = format === 3 ? 16 : format === 2 ? 8 : 4;
|
||||
const imports = Buffer.alloc(importSize * 2);
|
||||
const entry = (
|
||||
index: number,
|
||||
{
|
||||
ordinal,
|
||||
weak,
|
||||
nameOffset,
|
||||
addend,
|
||||
}: {
|
||||
ordinal: number;
|
||||
weak: boolean;
|
||||
nameOffset: number;
|
||||
addend: number;
|
||||
},
|
||||
) => {
|
||||
const at = index * importSize;
|
||||
if (format === 3) {
|
||||
imports.writeBigUInt64LE(
|
||||
BigInt(ordinal & 0xffff) |
|
||||
(BigInt(weak ? 1 : 0) << 16n) |
|
||||
(BigInt(nameOffset) << 32n),
|
||||
at,
|
||||
);
|
||||
imports.writeBigInt64LE(BigInt(addend), at + 8);
|
||||
} else {
|
||||
imports.writeUInt32LE(
|
||||
((nameOffset << 9) | ((weak ? 1 : 0) << 8) | (ordinal & 0xff)) >>> 0,
|
||||
at,
|
||||
);
|
||||
if (format === 2) imports.writeInt32LE(addend, at + 4);
|
||||
}
|
||||
};
|
||||
entry(0, { ordinal: 1, weak: false, nameOffset: 1, addend: 0 });
|
||||
entry(1, { ordinal: 2, weak: true, nameOffset: 24, addend: 7 });
|
||||
// starts_in_image: two segments, only the second has fixups.
|
||||
const starts = Buffer.alloc(12 + 24);
|
||||
starts.writeUInt32LE(2, 0);
|
||||
starts.writeUInt32LE(0, 4);
|
||||
starts.writeUInt32LE(12, 8);
|
||||
starts.writeUInt32LE(24, 12);
|
||||
starts.writeUInt16LE(0x4000, 16);
|
||||
starts.writeUInt16LE(6, 18);
|
||||
const header = Buffer.alloc(28);
|
||||
header.writeUInt32LE(0, 0);
|
||||
header.writeUInt32LE(28, 4);
|
||||
header.writeUInt32LE(28 + starts.length, 8);
|
||||
header.writeUInt32LE(28 + starts.length + imports.length, 12);
|
||||
header.writeUInt32LE(2, 16);
|
||||
header.writeUInt32LE(format, 20);
|
||||
header.writeUInt32LE(0, 24);
|
||||
return Buffer.concat([header, starts, imports, symbols]);
|
||||
};
|
||||
|
||||
const SEGMENTS: Segment[] = [
|
||||
{ address: BASE, size: 0x4000n, offset: 0, executable: true },
|
||||
{ address: BASE + 0x4000n, size: 0x4000n, offset: 0x4000, executable: false },
|
||||
];
|
||||
|
||||
describe("pointer fixup tables", () => {
|
||||
for (const format of [1, 2, 3] as const)
|
||||
it(`reads chained import format ${format}`, () => {
|
||||
const data = chainedData(format);
|
||||
const fixups = parsePointerFixups(
|
||||
data,
|
||||
{
|
||||
chained: { offset: 0, size: data.length },
|
||||
binds: [],
|
||||
dylibs: ["/usr/lib/libobjc.A.dylib", "/usr/lib/libSystem.B.dylib"],
|
||||
},
|
||||
SEGMENTS,
|
||||
BASE,
|
||||
);
|
||||
expect(fixups).toMatchObject({
|
||||
kind: "chained",
|
||||
formats: ["DYLD_CHAINED_PTR_64_OFFSET"],
|
||||
});
|
||||
expect(fixups.decode(BASE + 0x4008n, 1n | field(1n, 63))).toMatchObject({
|
||||
kind: "bind",
|
||||
symbol: "_free",
|
||||
library: "/usr/lib/libSystem.B.dylib",
|
||||
weak: true,
|
||||
addend: format === 1 ? 0n : 7n,
|
||||
});
|
||||
// Pointers outside fixup segments are stored plainly.
|
||||
expect(fixups.decode(BASE + 0x10n, 0x1234n)).toEqual({
|
||||
kind: "rebase",
|
||||
target: 0x1234n,
|
||||
});
|
||||
});
|
||||
|
||||
it("interprets legacy bind, weak-bind and lazy-bind opcodes", () => {
|
||||
const opcodes = Buffer.from([
|
||||
0x11, // SET_DYLIB_ORDINAL_IMM 1
|
||||
0x40,
|
||||
...Buffer.from("_OBJC_CLASS_$_NSObject\0"),
|
||||
0x51, // SET_TYPE_IMM pointer
|
||||
0x71,
|
||||
0x08, // SET_SEGMENT_AND_OFFSET segment 1 + 8
|
||||
0x90, // DO_BIND
|
||||
0xc0,
|
||||
0x02,
|
||||
0x08, // DO_BIND_ULEB_TIMES_SKIPPING_ULEB 2 times, skip 8
|
||||
0x00,
|
||||
]);
|
||||
const lazy = Buffer.from([
|
||||
0x71,
|
||||
0x30,
|
||||
0x12,
|
||||
0x40,
|
||||
...Buffer.from("_free\0"),
|
||||
0x90,
|
||||
0x00,
|
||||
0x71,
|
||||
0x38,
|
||||
0x12,
|
||||
0x40,
|
||||
...Buffer.from("_malloc\0"),
|
||||
0x90,
|
||||
0x00,
|
||||
]);
|
||||
const data = Buffer.concat([opcodes, lazy]);
|
||||
const fixups = parsePointerFixups(
|
||||
data,
|
||||
{
|
||||
chained: null,
|
||||
binds: [
|
||||
{ offset: 0, size: opcodes.length, stream: "bind" },
|
||||
{ offset: opcodes.length, size: lazy.length, stream: "lazy" },
|
||||
],
|
||||
dylibs: ["/usr/lib/libobjc.A.dylib", "/usr/lib/libSystem.B.dylib"],
|
||||
},
|
||||
SEGMENTS,
|
||||
BASE,
|
||||
);
|
||||
expect(fixups.kind).toBe("dyld-info");
|
||||
expect(fixups.failures).toEqual([]);
|
||||
for (const offset of [0x08n, 0x10n, 0x20n])
|
||||
expect(fixups.decode(BASE + 0x4000n + offset, 0n)).toMatchObject({
|
||||
kind: "bind",
|
||||
symbol: "_OBJC_CLASS_$_NSObject",
|
||||
library: "/usr/lib/libobjc.A.dylib",
|
||||
});
|
||||
expect(fixups.decode(BASE + 0x4038n, 0n)).toMatchObject({
|
||||
symbol: "_malloc",
|
||||
library: "/usr/lib/libSystem.B.dylib",
|
||||
});
|
||||
expect(fixups.decode(BASE + 0x4018n, 0x99n)).toEqual({
|
||||
kind: "rebase",
|
||||
target: 0x99n,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Objective-C property attributes", () => {
|
||||
it("parses type, ownership, accessors and quoted class names", () => {
|
||||
expect(
|
||||
parsePropertyAttributes(
|
||||
"title",
|
||||
'T@"NSString<NSCopying, NSSecureCoding>",C,N,GcustomTitle,V_title',
|
||||
),
|
||||
).toEqual({
|
||||
name: "title",
|
||||
type_encoding: '@"NSString<NSCopying, NSSecureCoding>"',
|
||||
attributes: [
|
||||
expect.objectContaining({
|
||||
name: "T",
|
||||
value: '@"NSString<NSCopying, NSSecureCoding>"',
|
||||
}),
|
||||
expect.objectContaining({ name: "C", is_copy: true }),
|
||||
expect.objectContaining({ name: "N" }),
|
||||
expect.objectContaining({ name: "G", value: "customTitle" }),
|
||||
expect.objectContaining({ name: "V", value: "_title" }),
|
||||
],
|
||||
is_readonly: false,
|
||||
getter: "customTitle",
|
||||
setter: null,
|
||||
});
|
||||
expect(parsePropertyAttributes("count", "Tq,R,N")).toMatchObject({
|
||||
type_encoding: "q",
|
||||
is_readonly: true,
|
||||
});
|
||||
expect(
|
||||
parsePropertyAttributes("delegate", "T@,W,N,V_delegate").attributes[1],
|
||||
).toMatchObject({
|
||||
is_weak: true,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,414 @@
|
||||
import type { Segment } from "./AppleMachoSelection.js";
|
||||
|
||||
/** Where a Mach-O stores pointer fixups, from its load commands. */
|
||||
export interface FixupCommands {
|
||||
/** Absolute file range of `LC_DYLD_CHAINED_FIXUPS` data. */
|
||||
readonly chained: { readonly offset: number; readonly size: number } | null;
|
||||
/** Absolute file ranges of `LC_DYLD_INFO(_ONLY)` bind streams. */
|
||||
readonly binds: readonly {
|
||||
readonly offset: number;
|
||||
readonly size: number;
|
||||
readonly stream: "bind" | "weak" | "lazy";
|
||||
}[];
|
||||
/** Install names of dependent dylibs, in library-ordinal order. */
|
||||
readonly dylibs: readonly string[];
|
||||
}
|
||||
|
||||
/** One decoded pointer: a rebase to an in-image address or a bind to a symbol. */
|
||||
export type DecodedPointer =
|
||||
| { readonly kind: "rebase"; readonly target: bigint }
|
||||
| {
|
||||
readonly kind: "bind";
|
||||
readonly symbol: string;
|
||||
readonly library: string | null;
|
||||
readonly weak: boolean;
|
||||
readonly addend: bigint;
|
||||
};
|
||||
|
||||
/** Pointer decoding for one Mach-O slice. */
|
||||
export interface PointerFixups {
|
||||
readonly kind: "chained" | "dyld-info" | "none";
|
||||
/** Chained pointer formats in use, such as `DYLD_CHAINED_PTR_64_OFFSET`. */
|
||||
readonly formats: readonly string[];
|
||||
readonly failures: readonly string[];
|
||||
/** Decode the pointer stored at `address` whose raw 64-bit value is `raw`. */
|
||||
decode(address: bigint, raw: bigint): DecodedPointer;
|
||||
}
|
||||
|
||||
const POINTER_FORMATS: Readonly<Record<number, string>> = {
|
||||
1: "DYLD_CHAINED_PTR_ARM64E",
|
||||
2: "DYLD_CHAINED_PTR_64",
|
||||
6: "DYLD_CHAINED_PTR_64_OFFSET",
|
||||
9: "DYLD_CHAINED_PTR_ARM64E_USERLAND",
|
||||
12: "DYLD_CHAINED_PTR_ARM64E_USERLAND24",
|
||||
};
|
||||
|
||||
const bits = (value: bigint, from: number, width: number): bigint =>
|
||||
(value >> BigInt(from)) & ((1n << BigInt(width)) - 1n);
|
||||
|
||||
const signed = (value: bigint, width: number): bigint =>
|
||||
value >= 1n << BigInt(width - 1) ? value - (1n << BigInt(width)) : value;
|
||||
|
||||
interface Import {
|
||||
readonly symbol: string;
|
||||
readonly library: string | null;
|
||||
readonly weak: boolean;
|
||||
readonly addend: bigint;
|
||||
}
|
||||
|
||||
/** Library ordinal to install name; 0 and negative ordinals are special lookups. */
|
||||
const libraryName = (
|
||||
ordinal: number,
|
||||
dylibs: readonly string[],
|
||||
): string | null => {
|
||||
if (ordinal > 0) return dylibs[ordinal - 1] ?? null;
|
||||
return null;
|
||||
};
|
||||
|
||||
const cString = (bytes: Buffer, offset: number, end: number): string => {
|
||||
const stop = bytes.indexOf(0, offset);
|
||||
if (offset < 0 || offset >= end || stop < 0 || stop >= end)
|
||||
throw new RangeError("Fixup symbol name is outside the symbol pool");
|
||||
return bytes.toString("utf8", offset, stop);
|
||||
};
|
||||
|
||||
const readImports = (
|
||||
data: {
|
||||
readonly bytes: Buffer;
|
||||
readonly base: number;
|
||||
readonly end: number;
|
||||
readonly dylibs: readonly string[];
|
||||
},
|
||||
header: {
|
||||
readonly offset: number;
|
||||
readonly count: number;
|
||||
readonly format: number;
|
||||
readonly symbols: number;
|
||||
},
|
||||
): Import[] => {
|
||||
const { bytes, base, end, dylibs } = data;
|
||||
const size = header.format === 3 ? 16 : header.format === 2 ? 8 : 4;
|
||||
if (header.format < 1 || header.format > 3)
|
||||
throw new RangeError(`Unsupported chained import format ${header.format}`);
|
||||
if (base + header.offset + header.count * size > end)
|
||||
throw new RangeError("Chained import table exceeds the fixup data");
|
||||
return Array.from({ length: header.count }, (_, index) => {
|
||||
const at = base + header.offset + index * size;
|
||||
if (header.format === 3) {
|
||||
const word = bytes.readBigUInt64LE(at);
|
||||
const ordinal = Number(signed(bits(word, 0, 16), 16));
|
||||
return {
|
||||
symbol: cString(
|
||||
bytes,
|
||||
base + header.symbols + Number(bits(word, 32, 32)),
|
||||
end,
|
||||
),
|
||||
library: libraryName(ordinal, dylibs),
|
||||
weak: bits(word, 16, 1) === 1n,
|
||||
addend: bytes.readBigInt64LE(at + 8),
|
||||
};
|
||||
}
|
||||
const word = bytes.readUInt32LE(at);
|
||||
const ordinal = Number(signed(BigInt(word & 0xff), 8));
|
||||
return {
|
||||
symbol: cString(bytes, base + header.symbols + (word >>> 9), end),
|
||||
library: libraryName(ordinal, dylibs),
|
||||
weak: ((word >>> 8) & 1) === 1,
|
||||
addend: header.format === 2 ? BigInt(bytes.readInt32LE(at + 4)) : 0n,
|
||||
};
|
||||
});
|
||||
};
|
||||
|
||||
/** Decode one raw chained pointer for its segment's pointer format. */
|
||||
export const decodeChainedPointer = (
|
||||
raw: bigint,
|
||||
format: number,
|
||||
baseAddress: bigint,
|
||||
imports: readonly Import[],
|
||||
): DecodedPointer => {
|
||||
const bind = (ordinal: bigint, addend: bigint): DecodedPointer => {
|
||||
const target = imports[Number(ordinal)];
|
||||
if (target === undefined)
|
||||
throw new RangeError(`Chained bind ordinal ${ordinal} has no import`);
|
||||
return { kind: "bind", ...target, addend: target.addend + addend };
|
||||
};
|
||||
if (format === 2 || format === 6) {
|
||||
if (bits(raw, 63, 1) === 1n)
|
||||
return bind(bits(raw, 0, 24), bits(raw, 24, 8));
|
||||
const target = bits(raw, 0, 36) | (bits(raw, 36, 8) << 56n);
|
||||
return {
|
||||
kind: "rebase",
|
||||
target: format === 6 ? target + baseAddress : target,
|
||||
};
|
||||
}
|
||||
if (format === 1 || format === 9 || format === 12) {
|
||||
const auth = bits(raw, 63, 1) === 1n;
|
||||
if (bits(raw, 62, 1) === 1n)
|
||||
return bind(
|
||||
bits(raw, 0, format === 12 ? 24 : 16),
|
||||
auth ? 0n : signed(bits(raw, 32, 19), 19),
|
||||
);
|
||||
if (auth) return { kind: "rebase", target: bits(raw, 0, 32) + baseAddress };
|
||||
const target = bits(raw, 0, 43) | (bits(raw, 43, 8) << 56n);
|
||||
return {
|
||||
kind: "rebase",
|
||||
target: format === 1 ? target : target + baseAddress,
|
||||
};
|
||||
}
|
||||
throw new RangeError(`Unsupported chained pointer format ${format}`);
|
||||
};
|
||||
|
||||
/** The slice bytes and load-command facts that fixup decoding reads. */
|
||||
interface FixupImage {
|
||||
readonly bytes: Buffer;
|
||||
readonly segments: readonly Segment[];
|
||||
readonly dylibs: readonly string[];
|
||||
readonly baseAddress: bigint;
|
||||
}
|
||||
|
||||
const chainedFixups = (
|
||||
image: FixupImage,
|
||||
range: { readonly offset: number; readonly size: number },
|
||||
): PointerFixups => {
|
||||
const { bytes, segments, dylibs, baseAddress } = image;
|
||||
const base = range.offset;
|
||||
const end = range.offset + range.size;
|
||||
if (range.size < 28 || end > bytes.length)
|
||||
throw new RangeError("Chained fixup header exceeds the target");
|
||||
const startsOffset = bytes.readUInt32LE(base + 4);
|
||||
const imports = readImports(
|
||||
{ bytes, base, end, dylibs },
|
||||
{
|
||||
offset: bytes.readUInt32LE(base + 8),
|
||||
symbols: bytes.readUInt32LE(base + 12),
|
||||
count: bytes.readUInt32LE(base + 16),
|
||||
format: bytes.readUInt32LE(base + 20),
|
||||
},
|
||||
);
|
||||
if (bytes.readUInt32LE(base + 24) !== 0)
|
||||
throw new RangeError(
|
||||
"Compressed chained-fixup symbol names are not supported",
|
||||
);
|
||||
const starts = base + startsOffset;
|
||||
const segmentCount = bytes.readUInt32LE(starts);
|
||||
const ranges: {
|
||||
readonly from: bigint;
|
||||
readonly to: bigint;
|
||||
readonly format: number;
|
||||
}[] = [];
|
||||
for (let index = 0; index < segmentCount; index++) {
|
||||
const infoOffset = bytes.readUInt32LE(starts + 4 + index * 4);
|
||||
if (infoOffset === 0) continue;
|
||||
const segment = segments[index];
|
||||
if (segment === undefined || starts + infoOffset + 22 > end)
|
||||
throw new RangeError("Chained fixup segment table is out of range");
|
||||
ranges.push({
|
||||
from: segment.address,
|
||||
to: segment.address + segment.size,
|
||||
format: bytes.readUInt16LE(starts + infoOffset + 6),
|
||||
});
|
||||
}
|
||||
const formats = [
|
||||
...new Set(
|
||||
ranges.map(({ format }) => POINTER_FORMATS[format] ?? `format-${format}`),
|
||||
),
|
||||
];
|
||||
return {
|
||||
kind: "chained",
|
||||
formats,
|
||||
failures: [],
|
||||
decode(address, raw) {
|
||||
const segment = ranges.find(
|
||||
({ from, to }) => address >= from && address < to,
|
||||
);
|
||||
// Pointers outside fixup segments, such as in __TEXT, are stored plainly.
|
||||
if (segment === undefined) return { kind: "rebase", target: raw };
|
||||
if (raw === 0n) return { kind: "rebase", target: 0n };
|
||||
return decodeChainedPointer(raw, segment.format, baseAddress, imports);
|
||||
},
|
||||
};
|
||||
};
|
||||
|
||||
const uleb = (bytes: Buffer, cursor: { at: number }, end: number): bigint => {
|
||||
let value = 0n;
|
||||
let shift = 0n;
|
||||
for (;;) {
|
||||
if (cursor.at >= end) throw new RangeError("Truncated bind opcode operand");
|
||||
const byte = bytes[cursor.at++] ?? 0;
|
||||
value |= BigInt(byte & 0x7f) << shift;
|
||||
shift += 7n;
|
||||
if ((byte & 0x80) === 0) return value;
|
||||
if (shift > 63n) throw new RangeError("Oversized bind opcode operand");
|
||||
}
|
||||
};
|
||||
|
||||
const sleb = (bytes: Buffer, cursor: { at: number }, end: number): bigint => {
|
||||
let value = 0n;
|
||||
let shift = 0n;
|
||||
let byte = 0;
|
||||
do {
|
||||
if (cursor.at >= end) throw new RangeError("Truncated bind opcode operand");
|
||||
byte = bytes[cursor.at++] ?? 0;
|
||||
value |= BigInt(byte & 0x7f) << shift;
|
||||
shift += 7n;
|
||||
} while ((byte & 0x80) !== 0 && shift <= 63n);
|
||||
return (byte & 0x40) !== 0 ? value - (1n << shift) : value;
|
||||
};
|
||||
|
||||
/** Registers of the `LC_DYLD_INFO` bind state machine. */
|
||||
interface BindState {
|
||||
ordinal: number;
|
||||
symbol: string;
|
||||
weak: boolean;
|
||||
addend: bigint;
|
||||
address: bigint;
|
||||
}
|
||||
|
||||
/** Apply a bind opcode that sets a register; false when the opcode is not one. */
|
||||
const setBindRegister = (
|
||||
image: FixupImage,
|
||||
stream: { readonly cursor: { at: number }; readonly end: number },
|
||||
state: BindState,
|
||||
byte: number,
|
||||
): boolean => {
|
||||
const { bytes } = image;
|
||||
const { cursor, end } = stream;
|
||||
const immediate = byte & 0x0f;
|
||||
switch (byte & 0xf0) {
|
||||
case 0x10:
|
||||
state.ordinal = immediate;
|
||||
return true;
|
||||
case 0x20:
|
||||
state.ordinal = Number(uleb(bytes, cursor, end));
|
||||
return true;
|
||||
case 0x30:
|
||||
state.ordinal = immediate === 0 ? 0 : immediate - 16;
|
||||
return true;
|
||||
case 0x40: {
|
||||
const stop = bytes.indexOf(0, cursor.at);
|
||||
if (stop < 0 || stop >= end)
|
||||
throw new RangeError("Unterminated bind symbol");
|
||||
state.symbol = bytes.toString("utf8", cursor.at, stop);
|
||||
state.weak = (immediate & 0x1) !== 0;
|
||||
cursor.at = stop + 1;
|
||||
return true;
|
||||
}
|
||||
case 0x50:
|
||||
return true;
|
||||
case 0x60:
|
||||
state.addend = sleb(bytes, cursor, end);
|
||||
return true;
|
||||
case 0x70: {
|
||||
const segment = image.segments[immediate];
|
||||
if (segment === undefined)
|
||||
throw new RangeError("Bind segment index is out of range");
|
||||
state.address = segment.address + uleb(bytes, cursor, end);
|
||||
return true;
|
||||
}
|
||||
case 0x80:
|
||||
// ULEB deltas wrap at 64 bits to encode negative steps.
|
||||
state.address =
|
||||
(state.address + uleb(bytes, cursor, end)) & 0xffffffffffffffffn;
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
/** Interpret one `LC_DYLD_INFO` bind opcode stream into address -> import. */
|
||||
const readBindStream = (
|
||||
image: FixupImage,
|
||||
range: FixupCommands["binds"][number],
|
||||
binds: Map<bigint, Import>,
|
||||
): void => {
|
||||
const { bytes } = image;
|
||||
const end = range.offset + range.size;
|
||||
if (end > bytes.length)
|
||||
throw new RangeError("Bind opcodes exceed the target");
|
||||
const cursor = { at: range.offset };
|
||||
const state: BindState = {
|
||||
ordinal: 0,
|
||||
symbol: "",
|
||||
weak: false,
|
||||
addend: 0n,
|
||||
address: 0n,
|
||||
};
|
||||
const bind = (skip: bigint): void => {
|
||||
binds.set(state.address, {
|
||||
symbol: state.symbol,
|
||||
library:
|
||||
range.stream === "weak"
|
||||
? null
|
||||
: libraryName(state.ordinal, image.dylibs),
|
||||
weak: state.weak,
|
||||
addend: state.addend,
|
||||
});
|
||||
state.address += 8n + skip;
|
||||
};
|
||||
while (cursor.at < end) {
|
||||
const byte = bytes[cursor.at++] ?? 0;
|
||||
if (setBindRegister(image, { cursor, end }, state, byte)) continue;
|
||||
switch (byte & 0xf0) {
|
||||
case 0x00:
|
||||
// DONE separates lazy-bind entries; other streams end here.
|
||||
if (range.stream !== "lazy") return;
|
||||
break;
|
||||
case 0x90:
|
||||
bind(0n);
|
||||
break;
|
||||
case 0xa0:
|
||||
bind(uleb(bytes, cursor, end));
|
||||
break;
|
||||
case 0xb0:
|
||||
bind(BigInt(byte & 0x0f) * 8n);
|
||||
break;
|
||||
case 0xc0: {
|
||||
const count = uleb(bytes, cursor, end);
|
||||
const skip = uleb(bytes, cursor, end);
|
||||
for (let index = 0n; index < count; index++) bind(skip);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
throw new RangeError(`Unsupported bind opcode 0x${byte.toString(16)}`);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/** Build pointer decoding for one slice from its fixup load commands. */
|
||||
export const parsePointerFixups = (
|
||||
bytes: Buffer,
|
||||
commands: FixupCommands,
|
||||
segments: readonly Segment[],
|
||||
baseAddress: bigint,
|
||||
): PointerFixups => {
|
||||
const image = { bytes, segments, dylibs: commands.dylibs, baseAddress };
|
||||
if (commands.chained !== null) return chainedFixups(image, commands.chained);
|
||||
if (commands.binds.length === 0)
|
||||
return {
|
||||
kind: "none",
|
||||
formats: [],
|
||||
failures: [],
|
||||
decode: (_address, raw) => ({ kind: "rebase", target: raw }),
|
||||
};
|
||||
const binds = new Map<bigint, Import>();
|
||||
const failures: string[] = [];
|
||||
for (const stream of commands.binds)
|
||||
try {
|
||||
readBindStream(image, stream, binds);
|
||||
} catch (cause: unknown) {
|
||||
failures.push(
|
||||
`${stream.stream} bind opcodes: ${cause instanceof Error ? cause.message : String(cause)}`,
|
||||
);
|
||||
}
|
||||
return {
|
||||
kind: "dyld-info",
|
||||
formats: [],
|
||||
failures,
|
||||
decode(address, raw) {
|
||||
const bound = binds.get(address);
|
||||
return bound === undefined
|
||||
? { kind: "rebase", target: raw }
|
||||
: { kind: "bind", ...bound };
|
||||
},
|
||||
};
|
||||
};
|
||||
@@ -1,3 +1,5 @@
|
||||
import type { FixupCommands } from "./AppleMachoFixups.js";
|
||||
|
||||
/** One mapped Mach-O segment with file-backed VA range. */
|
||||
export interface Segment {
|
||||
address: bigint;
|
||||
@@ -23,6 +25,10 @@ export interface MachoSlice {
|
||||
export interface MachoLayout {
|
||||
segments: Segment[];
|
||||
sections: Section[];
|
||||
/** Fixup load commands and dependent dylibs of the selected slice. */
|
||||
fixups: FixupCommands;
|
||||
/** VM address of the segment that maps file offset 0 (the preferred load address). */
|
||||
baseAddress: bigint;
|
||||
/** Map a virtual address range onto a file offset within the selected slice. */
|
||||
offset(address: bigint, size?: number): number;
|
||||
}
|
||||
@@ -112,48 +118,31 @@ export const parseMachoLayout = (
|
||||
const commandEnd = slice + 32 + bytes.readUInt32LE(slice + 20);
|
||||
if (commands > 4096 || commandEnd > sliceEnd)
|
||||
throw new RangeError("Malformed Mach-O command bounds");
|
||||
const segments: Segment[] = [];
|
||||
const sections: Section[] = [];
|
||||
const state: LayoutState = {
|
||||
slice,
|
||||
sliceEnd,
|
||||
segments: [],
|
||||
sections: [],
|
||||
dylibs: [],
|
||||
binds: [],
|
||||
chained: null,
|
||||
baseAddress: undefined,
|
||||
};
|
||||
let cursor = slice + 32;
|
||||
for (let index = 0; index < commands; index++) {
|
||||
if (cursor + 8 > commandEnd) throw new RangeError("Truncated load command");
|
||||
const kind = bytes.readUInt32LE(cursor),
|
||||
size = bytes.readUInt32LE(cursor + 4);
|
||||
if (size < 8 || cursor + size > commandEnd)
|
||||
const command = {
|
||||
cursor,
|
||||
kind: bytes.readUInt32LE(cursor),
|
||||
size: bytes.readUInt32LE(cursor + 4),
|
||||
};
|
||||
if (command.size < 8 || cursor + command.size > commandEnd)
|
||||
throw new RangeError("Invalid load command size");
|
||||
if (kind === 0x19) {
|
||||
if (size < 72) throw new RangeError("Truncated segment command");
|
||||
const address = bytes.readBigUInt64LE(cursor + 24),
|
||||
fileSize = bytes.readBigUInt64LE(cursor + 48),
|
||||
fileOffset = bytes.readBigUInt64LE(cursor + 40);
|
||||
if (fileOffset + fileSize > BigInt(sliceEnd - slice))
|
||||
throw new RangeError("Segment file range exceeds target bytes");
|
||||
segments.push({
|
||||
address,
|
||||
size: fileSize,
|
||||
offset: slice + Number(fileOffset),
|
||||
executable: (bytes.readUInt32LE(cursor + 60) & 4) !== 0,
|
||||
});
|
||||
const count = bytes.readUInt32LE(cursor + 64);
|
||||
if (72 + count * 80 > size)
|
||||
throw new RangeError("Truncated section table");
|
||||
for (let section = 0; section < count; section++) {
|
||||
const position = cursor + 72 + section * 80;
|
||||
const sectionSize = bytes.readBigUInt64LE(position + 40);
|
||||
if (sectionSize > BigInt(Number.MAX_SAFE_INTEGER))
|
||||
throw new RangeError("Section size exceeds exact numeric range");
|
||||
sections.push({
|
||||
name: bytes
|
||||
.subarray(position, position + 16)
|
||||
.toString("ascii")
|
||||
.replace(/\0.*$/u, ""),
|
||||
address: bytes.readBigUInt64LE(position + 32),
|
||||
size: Number(sectionSize),
|
||||
});
|
||||
}
|
||||
}
|
||||
cursor += size;
|
||||
if (command.kind === 0x19) collectSegment(bytes, command, state);
|
||||
else collectFixupCommand(bytes, command, state);
|
||||
cursor += command.size;
|
||||
}
|
||||
const { segments, sections, chained, binds, dylibs } = state;
|
||||
const offset = (address: bigint, size = 1): number => {
|
||||
const matches = segments.filter(
|
||||
(segment) =>
|
||||
@@ -168,5 +157,109 @@ export const parseMachoLayout = (
|
||||
if (segment === undefined) throw new RangeError("Missing metadata segment");
|
||||
return segment.offset + Number(address - segment.address);
|
||||
};
|
||||
return { segments, sections, offset };
|
||||
return {
|
||||
segments,
|
||||
sections,
|
||||
offset,
|
||||
fixups: { chained, binds, dylibs },
|
||||
baseAddress: state.baseAddress ?? 0n,
|
||||
};
|
||||
};
|
||||
|
||||
/** Load commands and fixup ranges collected while walking one slice. */
|
||||
interface LayoutState {
|
||||
readonly slice: number;
|
||||
readonly sliceEnd: number;
|
||||
readonly segments: Segment[];
|
||||
readonly sections: Section[];
|
||||
readonly dylibs: string[];
|
||||
readonly binds: FixupCommands["binds"][number][];
|
||||
chained: FixupCommands["chained"];
|
||||
baseAddress: bigint | undefined;
|
||||
}
|
||||
|
||||
/** One load command header inside the selected slice. */
|
||||
interface LoadCommand {
|
||||
readonly cursor: number;
|
||||
readonly kind: number;
|
||||
readonly size: number;
|
||||
}
|
||||
|
||||
/** Record an `LC_SEGMENT_64` and its section table. */
|
||||
const collectSegment = (
|
||||
bytes: Buffer,
|
||||
{ cursor, size }: LoadCommand,
|
||||
state: LayoutState,
|
||||
): void => {
|
||||
if (size < 72) throw new RangeError("Truncated segment command");
|
||||
const address = bytes.readBigUInt64LE(cursor + 24),
|
||||
fileSize = bytes.readBigUInt64LE(cursor + 48),
|
||||
fileOffset = bytes.readBigUInt64LE(cursor + 40);
|
||||
if (fileOffset + fileSize > BigInt(state.sliceEnd - state.slice))
|
||||
throw new RangeError("Segment file range exceeds target bytes");
|
||||
state.segments.push({
|
||||
address,
|
||||
size: fileSize,
|
||||
offset: state.slice + Number(fileOffset),
|
||||
executable: (bytes.readUInt32LE(cursor + 60) & 4) !== 0,
|
||||
});
|
||||
if (fileOffset === 0n && fileSize > 0n) state.baseAddress ??= address;
|
||||
const count = bytes.readUInt32LE(cursor + 64);
|
||||
if (72 + count * 80 > size) throw new RangeError("Truncated section table");
|
||||
for (let section = 0; section < count; section++) {
|
||||
const position = cursor + 72 + section * 80;
|
||||
const sectionSize = bytes.readBigUInt64LE(position + 40);
|
||||
if (sectionSize > BigInt(Number.MAX_SAFE_INTEGER))
|
||||
throw new RangeError("Section size exceeds exact numeric range");
|
||||
state.sections.push({
|
||||
name: bytes
|
||||
.subarray(position, position + 16)
|
||||
.toString("ascii")
|
||||
.replace(/\0.*$/u, ""),
|
||||
address: bytes.readBigUInt64LE(position + 32),
|
||||
size: Number(sectionSize),
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
const LC_DYLD_INFO = 0x22;
|
||||
const LC_DYLD_INFO_ONLY = 0x80000022;
|
||||
const LC_DYLD_CHAINED_FIXUPS = 0x80000034;
|
||||
const DYLIB_COMMANDS: readonly number[] = [
|
||||
0xc, 0x80000018, 0x8000001f, 0x20, 0x80000023,
|
||||
];
|
||||
|
||||
/** Record fixup data ranges and dylib install names from one load command. */
|
||||
const collectFixupCommand = (
|
||||
bytes: Buffer,
|
||||
{ cursor, kind, size }: LoadCommand,
|
||||
state: LayoutState,
|
||||
): void => {
|
||||
const range = (at: number): { offset: number; size: number } => {
|
||||
const offset = state.slice + bytes.readUInt32LE(at);
|
||||
const length = bytes.readUInt32LE(at + 4);
|
||||
if (offset + length > state.sliceEnd)
|
||||
throw new RangeError("Fixup data exceeds the Mach-O slice");
|
||||
return { offset, size: length };
|
||||
};
|
||||
if (kind === LC_DYLD_CHAINED_FIXUPS && size >= 16)
|
||||
state.chained = range(cursor + 8);
|
||||
else if ((kind === LC_DYLD_INFO || kind === LC_DYLD_INFO_ONLY) && size >= 48)
|
||||
for (const [at, stream] of [
|
||||
[cursor + 16, "bind"],
|
||||
[cursor + 24, "weak"],
|
||||
[cursor + 32, "lazy"],
|
||||
] as const) {
|
||||
const bound = range(at);
|
||||
if (bound.size > 0) state.binds.push({ ...bound, stream });
|
||||
}
|
||||
else if (DYLIB_COMMANDS.includes(kind) && size >= 24) {
|
||||
const nameOffset = bytes.readUInt32LE(cursor + 8);
|
||||
const end = bytes.indexOf(0, cursor + nameOffset);
|
||||
state.dylibs.push(
|
||||
nameOffset >= size || end < 0 || end > cursor + size
|
||||
? ""
|
||||
: bytes.toString("utf8", cursor + nameOffset, end),
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
@@ -0,0 +1,99 @@
|
||||
import type { ObjcSwiftMetadata } from "../domain/objcSwiftMetadata.js";
|
||||
import type { Section } from "./AppleMachoSelection.js";
|
||||
import type { ObjcDispatchReaders } from "./AppleObjcDispatchFacets.js";
|
||||
import { readObjcPropertiesOf } from "./AppleObjcProperties.js";
|
||||
|
||||
const CLASS_SYMBOL = /^_OBJC_(?:META)?CLASS_\$_(.+)$/u;
|
||||
|
||||
/** External class name from a bound `_OBJC_CLASS_$_Name` symbol. */
|
||||
export const boundClassName = (
|
||||
read: Pick<ObjcDispatchReaders, "bound">,
|
||||
field: bigint,
|
||||
): string | undefined => {
|
||||
const bound = read.bound(field);
|
||||
return bound === undefined ? undefined : CLASS_SYMBOL.exec(bound.symbol)?.[1];
|
||||
};
|
||||
|
||||
/**
|
||||
* Decode `__objc_catlist` `category_t` records:
|
||||
* name, cls, instanceMethods, classMethods, protocols, instanceProperties.
|
||||
*/
|
||||
export const decodeObjcCategories = (input: {
|
||||
readonly sections: readonly Section[];
|
||||
readonly read: ObjcDispatchReaders;
|
||||
readonly result: ObjcSwiftMetadata;
|
||||
readonly failures: string[];
|
||||
readonly admit: () => boolean;
|
||||
/** Decode a method list into implementations attributed to the category. */
|
||||
readonly methods: (
|
||||
list: bigint,
|
||||
className: string,
|
||||
methodType: "instance" | "class",
|
||||
category: string,
|
||||
) => string[];
|
||||
readonly protocols: (list: bigint) => string[];
|
||||
/** Name of a class defined in this image, from its class_ro_t. */
|
||||
readonly localClassName: (address: bigint) => string;
|
||||
}): number => {
|
||||
const { read, result, failures } = input;
|
||||
let examined = 0;
|
||||
for (const section of input.sections.filter(
|
||||
({ name }) => name === "__objc_catlist",
|
||||
)) {
|
||||
if (section.size % 8 !== 0)
|
||||
throw new RangeError("Misaligned Objective-C category list");
|
||||
for (let index = 0; index < section.size / 8; index++) {
|
||||
if (!input.admit()) break;
|
||||
examined++;
|
||||
const field = section.address + BigInt(index * 8);
|
||||
try {
|
||||
const category = read.pointer(field);
|
||||
const name = read.string(read.pointer(category));
|
||||
const external = boundClassName(read, category + 8n);
|
||||
const local = read.pointer(category + 8n);
|
||||
const className =
|
||||
external ?? (local === 0n ? null : input.localClassName(local));
|
||||
const owner = className ?? `(${name})`;
|
||||
result.objc_categories.push({
|
||||
name,
|
||||
class_name: className,
|
||||
class_source:
|
||||
external !== undefined
|
||||
? "external"
|
||||
: className === null
|
||||
? "unresolved"
|
||||
: "local",
|
||||
instance_methods: input.methods(
|
||||
read.pointer(category + 16n),
|
||||
owner,
|
||||
"instance",
|
||||
name,
|
||||
),
|
||||
class_methods: input.methods(
|
||||
read.pointer(category + 24n),
|
||||
owner,
|
||||
"class",
|
||||
name,
|
||||
),
|
||||
protocols: input.protocols(read.pointer(category + 32n)),
|
||||
properties: readObjcPropertiesOf(read, read.pointer(category + 40n), {
|
||||
owner: `category ${name}`,
|
||||
admit: input.admit,
|
||||
failures,
|
||||
}),
|
||||
location: read.location(category),
|
||||
decode:
|
||||
className === null
|
||||
? { status: "partial", reason: "category_class_unresolved" }
|
||||
: { status: "decoded", reason: null },
|
||||
evidence: read.evidence(category, "Objective-C category_t record"),
|
||||
});
|
||||
} catch (cause: unknown) {
|
||||
failures.push(
|
||||
`Category at ${`0x${field.toString(16)}`}: ${cause instanceof Error ? cause.message : String(cause)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
return examined;
|
||||
};
|
||||
@@ -1,5 +1,7 @@
|
||||
import type { ObjcSwiftMetadata } from "../domain/objcSwiftMetadata.js";
|
||||
import type { Segment, Section } from "./AppleMachoSelection.js";
|
||||
import { boundClassName, decodeObjcCategories } from "./AppleObjcCategories.js";
|
||||
import { readObjcPropertiesOf } from "./AppleObjcProperties.js";
|
||||
import { createObjcProtocolReader } from "./AppleObjcProtocols.js";
|
||||
import type {
|
||||
BinaryMetadataEvidence,
|
||||
@@ -10,8 +12,14 @@ import type {
|
||||
/** Byte readers shared by Objective-C class/method/ivar decode facets. */
|
||||
export interface ObjcDispatchReaders {
|
||||
u32(address: bigint): number;
|
||||
/** Plain 64-bit data, never a fixup. */
|
||||
u64(address: bigint): bigint;
|
||||
i32(address: bigint): number;
|
||||
pointer(address: bigint): bigint;
|
||||
/** The symbol a pointer at `address` is bound to, when it is a bind fixup. */
|
||||
bound(
|
||||
address: bigint,
|
||||
): { readonly symbol: string; readonly library: string | null } | undefined;
|
||||
string(address: bigint): string;
|
||||
location(address: bigint): ResolvedMetadataLocation;
|
||||
evidence(address: bigint, description: string): BinaryMetadataEvidence;
|
||||
@@ -21,6 +29,36 @@ export interface ObjcDispatchReaders {
|
||||
const hex = (value: bigint) => `0x${value.toString(16)}`;
|
||||
const decoded = { status: "decoded" as const, reason: null };
|
||||
|
||||
/** Name of a class defined in this image, from its class_ro_t. */
|
||||
const localClassName = (read: ObjcDispatchReaders, address: bigint): string =>
|
||||
read.string(read.pointer((read.pointer(address + 32n) & ~7n) + 24n));
|
||||
|
||||
/**
|
||||
* Resolve a class's superclass: a bind to `_OBJC_CLASS_$_Name` names a class
|
||||
* in another image; otherwise the pointer is a class_t in this image.
|
||||
*/
|
||||
const resolveSuperclass = (
|
||||
read: ObjcDispatchReaders,
|
||||
address: bigint,
|
||||
className: string,
|
||||
failures: string[],
|
||||
): { name: string | null; address: string | null } => {
|
||||
const external = boundClassName(read, address + 8n);
|
||||
if (external !== undefined) return { name: external, address: null };
|
||||
const superclass = read.pointer(address + 8n);
|
||||
if (superclass === 0n) return { name: null, address: null };
|
||||
try {
|
||||
return { name: localClassName(read, superclass), address: hex(superclass) };
|
||||
} catch (cause: unknown) {
|
||||
// Superclass resolution failure is recorded; the cause adds no identity.
|
||||
void cause;
|
||||
failures.push(
|
||||
`Superclass pointer ${hex(superclass)} of ${className} requires unsupported binding/fixup resolution`,
|
||||
);
|
||||
return { name: null, address: hex(superclass) };
|
||||
}
|
||||
};
|
||||
|
||||
/** Decode Objective-C protocol lists, classlists, methods, and ivars into `result`. */
|
||||
export const decodeObjcDispatchFacets = (input: {
|
||||
bytes: Buffer;
|
||||
@@ -29,7 +67,7 @@ export const decodeObjcDispatchFacets = (input: {
|
||||
readers: ObjcDispatchReaders;
|
||||
budget: DispatchRecordBudget;
|
||||
result: ObjcSwiftMetadata;
|
||||
}): { failures: string[]; examined: number } => {
|
||||
}): { failures: string[]; examined: number; categoriesExamined: number } => {
|
||||
const { bytes, sections, segments, readers: read, budget, result } = input;
|
||||
const failures: string[] = [];
|
||||
let examined = 0;
|
||||
@@ -37,8 +75,10 @@ export const decodeObjcDispatchFacets = (input: {
|
||||
list: bigint,
|
||||
className: string,
|
||||
methodType: "instance" | "class",
|
||||
) => {
|
||||
if (list === 0n) return;
|
||||
category?: string,
|
||||
): string[] => {
|
||||
const selectors: string[] = [];
|
||||
if (list === 0n) return selectors;
|
||||
const flags = read.u32(list),
|
||||
count = read.u32(list + 4n),
|
||||
relative = (flags & 0x80000000) !== 0;
|
||||
@@ -103,10 +143,13 @@ export const decodeObjcDispatchFacets = (input: {
|
||||
// best-effort cleanup: external/chained pointers remain unresolved.
|
||||
void cause;
|
||||
}
|
||||
const selector = read.string(selectorAddress);
|
||||
selectors.push(selector);
|
||||
result.objc_dispatch_implementations.push({
|
||||
class_name: className,
|
||||
selector: read.string(selectorAddress),
|
||||
selector,
|
||||
method_type: methodType,
|
||||
...(category === undefined ? {} : { category }),
|
||||
implementation_address: implementationLocation?.address ?? null,
|
||||
location: read.location(entry),
|
||||
decode:
|
||||
@@ -124,6 +167,7 @@ export const decodeObjcDispatchFacets = (input: {
|
||||
),
|
||||
});
|
||||
}
|
||||
return selectors;
|
||||
};
|
||||
const protocolReader = createObjcProtocolReader({
|
||||
readers: {
|
||||
@@ -134,6 +178,7 @@ export const decodeObjcDispatchFacets = (input: {
|
||||
evidence: read.evidence,
|
||||
admit: () => budget.admit(),
|
||||
i32: read.i32,
|
||||
u64: read.u64,
|
||||
},
|
||||
result,
|
||||
failures,
|
||||
@@ -157,23 +202,9 @@ export const decodeObjcDispatchFacets = (input: {
|
||||
visited.add(hex(address));
|
||||
const ro = read.pointer(address + 32n) & ~7n;
|
||||
const name = read.string(read.pointer(ro + 24n));
|
||||
const superclass = read.pointer(address + 8n);
|
||||
const root = (read.u32(ro) & 2) !== 0;
|
||||
let superclassName: string | null = null;
|
||||
if (superclass !== 0n) {
|
||||
try {
|
||||
superclassName = read.string(
|
||||
read.pointer((read.pointer(superclass + 32n) & ~7n) + 24n),
|
||||
);
|
||||
} catch (cause: unknown) {
|
||||
// Superclass resolution failure is recorded; the cause adds no identity.
|
||||
void cause;
|
||||
failures.push(
|
||||
`Superclass pointer ${hex(superclass)} of ${name} requires unsupported binding/fixup resolution`,
|
||||
);
|
||||
}
|
||||
}
|
||||
if (superclass === 0n && !root)
|
||||
const superclass = resolveSuperclass(read, address, name, failures);
|
||||
if (superclass.name === null && superclass.address === null && !root)
|
||||
failures.push(
|
||||
`Superclass of ${name} requires external binding resolution`,
|
||||
);
|
||||
@@ -220,7 +251,7 @@ export const decodeObjcDispatchFacets = (input: {
|
||||
methods(read.pointer(ro + 32n), name, meta ? "class" : "instance");
|
||||
result.objc_classes.push({
|
||||
name,
|
||||
super_class: superclassName,
|
||||
super_class: superclass.name,
|
||||
is_meta_class: meta,
|
||||
is_root_class: root,
|
||||
methods: result.objc_dispatch_implementations
|
||||
@@ -241,15 +272,19 @@ export const decodeObjcDispatchFacets = (input: {
|
||||
is_required: false,
|
||||
is_optional: false,
|
||||
})),
|
||||
properties: [],
|
||||
properties: readObjcPropertiesOf(read, read.pointer(ro + 64n), {
|
||||
owner: name,
|
||||
admit: () => budget.admit(),
|
||||
failures,
|
||||
}),
|
||||
protocols: protocolReader.list(read.pointer(ro + 40n)),
|
||||
ivar_count: ivarCount,
|
||||
instance_size: read.u32(ro + 8n),
|
||||
location: read.location(address),
|
||||
superclass_address: superclass === 0n ? null : hex(superclass),
|
||||
superclass_address: superclass.address,
|
||||
metaclass_address: meta ? null : hex(read.pointer(address)),
|
||||
decode:
|
||||
superclassName === null && !root
|
||||
superclass.name === null && !root
|
||||
? { status: "partial", reason: "superclass_binding_unresolved" }
|
||||
: decoded,
|
||||
evidence: read.evidence(
|
||||
@@ -288,5 +323,15 @@ export const decodeObjcDispatchFacets = (input: {
|
||||
}
|
||||
}
|
||||
}
|
||||
return { failures, examined };
|
||||
const categoriesExamined = decodeObjcCategories({
|
||||
sections,
|
||||
read,
|
||||
result,
|
||||
failures,
|
||||
admit: () => budget.admit(),
|
||||
methods,
|
||||
protocols: (list) => protocolReader.list(list),
|
||||
localClassName: (address) => localClassName(read, address),
|
||||
});
|
||||
return { failures, examined, categoriesExamined };
|
||||
};
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
import type { z } from "zod";
|
||||
|
||||
import type { objcPropertySchema } from "../domain/objcSwiftMetadata.js";
|
||||
|
||||
type ObjcProperty = z.infer<typeof objcPropertySchema>;
|
||||
|
||||
/** Byte readers needed to decode an Objective-C `property_list_t`. */
|
||||
export interface ObjcPropertyReaders {
|
||||
u32(address: bigint): number;
|
||||
pointer(address: bigint): bigint;
|
||||
string(address: bigint): string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an `@property` attribute string such as `T@"NSString",C,N,V_name`.
|
||||
* Each comma-separated token is one attribute; `T` is the type encoding.
|
||||
*/
|
||||
export const parsePropertyAttributes = (
|
||||
name: string,
|
||||
attributes: string,
|
||||
): ObjcProperty => {
|
||||
const tokens = attributes.length === 0 ? [] : splitAttributes(attributes);
|
||||
const value = (code: string): string | null =>
|
||||
tokens.find((token) => token.startsWith(code))?.slice(1) ?? null;
|
||||
return {
|
||||
name,
|
||||
type_encoding: value("T"),
|
||||
attributes: tokens.map((token) => ({
|
||||
name: token.slice(0, 1),
|
||||
value: token.slice(1),
|
||||
is_weak: token === "W",
|
||||
is_atomic: false,
|
||||
is_copy: token === "C",
|
||||
is_strong: token === "&",
|
||||
})),
|
||||
is_readonly: tokens.includes("R"),
|
||||
getter: value("G"),
|
||||
setter: value("S"),
|
||||
};
|
||||
};
|
||||
|
||||
/** Split on commas that are outside a quoted class name in the type encoding. */
|
||||
const splitAttributes = (attributes: string): string[] => {
|
||||
const tokens: string[] = [];
|
||||
let current = "";
|
||||
let quoted = false;
|
||||
for (const character of attributes) {
|
||||
if (character === '"') quoted = !quoted;
|
||||
if (character === "," && !quoted) {
|
||||
tokens.push(current);
|
||||
current = "";
|
||||
} else current += character;
|
||||
}
|
||||
tokens.push(current);
|
||||
return tokens.filter((token) => token.length > 0);
|
||||
};
|
||||
|
||||
/** Decode `property_list_t { entsize_and_flags, count, property_t[] }`. */
|
||||
export const readObjcPropertyList = (
|
||||
read: ObjcPropertyReaders,
|
||||
list: bigint,
|
||||
admit: () => boolean,
|
||||
): ObjcProperty[] => {
|
||||
if (list === 0n) return [];
|
||||
const entrySize = read.u32(list) & ~3;
|
||||
const count = read.u32(list + 4n);
|
||||
if (entrySize !== 16)
|
||||
throw new TypeError(
|
||||
`Unsupported Objective-C property entry size ${entrySize}`,
|
||||
);
|
||||
const properties: ObjcProperty[] = [];
|
||||
for (let index = 0; index < count; index++) {
|
||||
if (!admit()) break;
|
||||
const entry = list + 8n + BigInt(index * entrySize);
|
||||
properties.push(
|
||||
parsePropertyAttributes(
|
||||
read.string(read.pointer(entry)),
|
||||
read.string(read.pointer(entry + 8n)),
|
||||
),
|
||||
);
|
||||
}
|
||||
return properties;
|
||||
};
|
||||
|
||||
/** Decode a property list, recording a failure for `owner` instead of throwing. */
|
||||
export const readObjcPropertiesOf = (
|
||||
read: ObjcPropertyReaders,
|
||||
list: bigint,
|
||||
context: {
|
||||
readonly owner: string;
|
||||
readonly admit: () => boolean;
|
||||
readonly failures: string[];
|
||||
},
|
||||
): ObjcProperty[] => {
|
||||
try {
|
||||
return readObjcPropertyList(read, list, context.admit);
|
||||
} catch (cause: unknown) {
|
||||
context.failures.push(
|
||||
`Properties of ${context.owner}: ${cause instanceof Error ? cause.message : String(cause)}`,
|
||||
);
|
||||
return [];
|
||||
}
|
||||
};
|
||||
@@ -6,7 +6,12 @@ export const createObjcProtocolReader = (input: {
|
||||
readers: Pick<
|
||||
SwiftMetadataReaders,
|
||||
"u32" | "string" | "location" | "evidence" | "admit"
|
||||
> & { pointer(address: bigint): bigint; i32(address: bigint): number };
|
||||
> & {
|
||||
pointer(address: bigint): bigint;
|
||||
/** Plain 64-bit data, never a fixup. */
|
||||
u64(address: bigint): bigint;
|
||||
i32(address: bigint): number;
|
||||
};
|
||||
result: ObjcSwiftMetadata;
|
||||
failures: string[];
|
||||
}) => {
|
||||
@@ -15,7 +20,8 @@ export const createObjcProtocolReader = (input: {
|
||||
const name = (address: bigint) => read.string(read.pointer(address + 8n));
|
||||
const list = (address: bigint): string[] => {
|
||||
if (address === 0n) return [];
|
||||
const count = read.pointer(address);
|
||||
// `count` is plain uintptr_t data, not a pointer fixup.
|
||||
const count = read.u64(address);
|
||||
if (count > 20000n)
|
||||
throw new RangeError("Protocol list exceeds 20000 entries");
|
||||
const names: string[] = [];
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { chmod, mkdir, writeFile } from "node:fs/promises";
|
||||
import { chmod, mkdir, symlink, writeFile } from "node:fs/promises";
|
||||
import { dirname, join } from "node:path";
|
||||
|
||||
import { describe, expect } from "vitest";
|
||||
@@ -129,7 +129,15 @@ describe("trace-dylib-resolution CLI", () => {
|
||||
(narrowed.json as { normalized_result: { roots: unknown } })
|
||||
.normalized_result.roots,
|
||||
).toEqual([{ image: "Contents/MacOS/App", architecture: "arm64" }]);
|
||||
for (const root of ["../outside", "Contents/Info.plist"]) {
|
||||
// A root below a symlinked directory that points outside the bundle.
|
||||
const outside = await createTestTempDirectory("rea-dylib-outside-");
|
||||
await writeFiles(outside, { Tool: machoImage({}) });
|
||||
await symlink(outside, join(app, "Contents/Linked"));
|
||||
for (const root of [
|
||||
"../outside",
|
||||
"Contents/Info.plist",
|
||||
"Contents/Linked/Tool",
|
||||
]) {
|
||||
const rejected = await cli.run({
|
||||
arguments: ["trace-dylib-resolution", app, "--root", root, "--json"],
|
||||
environment: ENVIRONMENT,
|
||||
|
||||
@@ -9,6 +9,7 @@
|
||||
@interface ReaDispatchFixture : NSObject <ReaDispatchProtocol> {
|
||||
int state;
|
||||
}
|
||||
@property(nonatomic, copy) NSString *fixtureName;
|
||||
- (void)performAction:(id)sender;
|
||||
+ (int)fixtureVersion;
|
||||
@end
|
||||
@@ -16,4 +17,11 @@
|
||||
- (void)performAction:(id)sender { state += sender == nil ? 1 : 2; }
|
||||
+ (int)fixtureVersion { return 1; }
|
||||
@end
|
||||
|
||||
@interface NSString (ReaDispatchAdditions)
|
||||
- (NSUInteger)reaFixtureLength;
|
||||
@end
|
||||
@implementation NSString (ReaDispatchAdditions)
|
||||
- (NSUInteger)reaFixtureLength { return self.length; }
|
||||
@end
|
||||
int main(void) { return 0; }
|
||||
|
||||
Reference in New Issue
Block a user