Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(apple): read LC_LAZY_LOAD_DYLIB_INFO dependency payloads (#5650)
morluto23196daa1102
diff --git a/docs/apple-application-analysis.md b/docs/apple-application-analysis.mdindex b0a3cdeec..8425877e6 100644--- a/docs/apple-application-analysis.md+++ b/docs/apple-application-analysis.md@@ -180,8 +180,21 @@ rea trace-dylib-resolution MyApp.app --root Contents/MacOS/MyApp --architectureLoad commands are parsed in TypeScript from Mach-O and FAT headers, includingthe `dylib_use_command` encoding newer linkers emit for flags such as delayed-initialization. Nothing is executed and no Apple tool is required, so the tool-also works off macOS.+initialization, and `LC_LAZY_LOAD_DYLIB_INFO` (`0x3a`). That command stores its+install name in a linkedit payload rather than in the load command itself.+Its flag and chain-start image offsets must lie in the slice VM range, which+is dyld's one-page floor extended by every segment except `__LINKEDIT`,+measured from the `__TEXT` vmaddr. Payload strings must start after the 24-byte+header. The load-path NUL must occur before the payload's final byte, matching+dyld's scan. Distinct payload bytes and payload-range lookups stay within the 16 MiB+limit, and a file range already read is reused. String scanning and UTF-8+checks count every reference, including repeats and overlaps, and stop at that+same aggregate. A slice retains at most 1024 of these commands; further copies are+unsupported instead of becoming one traced edge each. Symbol references,+including repeats, stop at 65536 per slice. A larger table is unsupported+instead of caching one string per offset.+Nothing is executed and no Apple tool is required, so the tool also works off+macOS.Resolution follows dyld:@@ -222,8 +235,12 @@ cache rather than on disk, so REA does not check them against the host.`findings` are derived, not observed:- `required-load-unresolved`, `weak-load-unresolved`, and `lazy-load-unresolved`.- `LC_LAZY_LOAD_DYLIB` dependencies are resolved but not traversed, because dyld- loads them on first use; an unresolved one is not a launch failure.+ `LC_LAZY_LOAD_DYLIB` and `LC_LAZY_LOAD_DYLIB_INFO` dependencies are resolved+ but not traversed, because dyld loads them on first use; an unresolved one is+ not a launch failure. `LC_LAZY_LOAD_DYLIB_INFO` has no compatibility version,+ so those fields are null. Its may-be-missing flag is reported as `weak`, and+ an unresolved dependency with that flag is not a first-use failure: dyld+ continues if the image is absent.- `earlier-rpath-candidate-absent`: a compatible Mach-O placed at an earliermodeled search path could take precedence, subject to unmodeled search inputsand code-signing library validation. These findings do not establish whichdiff --git a/scripts/verify/apple/macos-dylib-e2e.mjs b/scripts/verify/apple/macos-dylib-e2e.mjsindex eacd06e9f..d9538c4cc 100644--- a/scripts/verify/apple/macos-dylib-e2e.mjs+++ b/scripts/verify/apple/macos-dylib-e2e.mjs@@ -140,8 +140,12 @@ const verifyParserConformance = async (app, trace) => {join(app, image.path),slice.architecture,);+ // otool -l prints LC_LAZY_LOAD_DYLIB_INFO without its linkedit install+ // name, so this comparison cannot expect that edge. The structural+ // reader tests own the payload.const edges = trace.edges.filter(- ({ loader, architecture, root }) =>+ ({ loader, architecture, root, command }) =>+ command !== "LC_LAZY_LOAD_DYLIB_INFO" &&loader === image.path &&architecture === slice.architecture &&root ===diff --git a/src/artifacts/apple/MachoImage.fixture.ts b/src/artifacts/apple/MachoImage.fixture.tsindex e965da22a..c7e0c5ade 100644--- a/src/artifacts/apple/MachoImage.fixture.ts+++ b/src/artifacts/apple/MachoImage.fixture.ts@@ -130,6 +130,130 @@ export const machoImage = (options: {return bytes;};+/**+ * Little-endian `LC_LAZY_LOAD_DYLIB_INFO` (0x3a) payload.+ * The 24-byte header is load-path offset, flag image offset, flags,+ * pointer format, chain-start image offset, symbol count, and the+ * symbol-offset array offset. Strings are NUL-terminated and the payload+ * is padded to 8 bytes, matching a one-symbol `@rpath/libl.dylib` payload+ * of 56 bytes.+ */+export const lazyLoadDylibInfoPayload = (options: {+ readonly path: string;+ readonly symbols?: readonly string[];+ readonly flags?: number;+ readonly flagImageOffset?: number;+ readonly chainStartImageOffset?: number;+}): Uint8Array => {+ const symbols = options.symbols ?? [];+ const headerSize = 24;+ const pathBytes = encoder.encode(options.path);+ const symbolBytes = symbols.map((symbol) => encoder.encode(symbol));+ const symbolArrayOffset = headerSize;+ const pathOffset = symbolArrayOffset + symbols.length * 4;+ let cursor = pathOffset + pathBytes.length + 1;+ const symbolOffsets = symbolBytes.map((bytes) => {+ const offset = cursor;+ cursor += bytes.length + 1;+ return offset;+ });+ const payload = new Uint8Array(Math.ceil(cursor / 8) * 8);+ const view = new DataView(payload.buffer);+ view.setUint32(0, pathOffset, true);+ view.setUint32(4, options.flagImageOffset ?? 0, true);+ view.setUint16(8, options.flags ?? 0, true);+ view.setUint32(12, options.chainStartImageOffset ?? 0, true);+ view.setUint32(16, symbols.length, true);+ view.setUint32(20, symbolArrayOffset, true);+ symbolOffsets.forEach((offset, index) =>+ view.setUint32(symbolArrayOffset + index * 4, offset, true),+ );+ payload.set(pathBytes, pathOffset);+ symbolBytes.forEach((bytes, index) => {+ const offset = symbolOffsets[index];+ if (offset !== undefined) payload.set(bytes, offset);+ });+ return payload;+};++/**+ * Place one `LC_LAZY_LOAD_DYLIB_INFO` command among the other commands and+ * append its payload after the image. `dataoff` is relative to this slice.+ */+/** `LC_SEGMENT` or `LC_SEGMENT_64` with a name and VM range, and no sections. */+export const segmentCommand = (options: {+ readonly name: string;+ readonly vmaddr: bigint;+ readonly vmsize: bigint;+ readonly wide?: boolean;+}): Uint8Array => {+ const wide = options.wide ?? true;+ const bytes = new Uint8Array(wide ? 72 : 56);+ const view = new DataView(bytes.buffer);+ view.setUint32(0, wide ? 0x19 : 0x1, true);+ view.setUint32(4, bytes.length, true);+ bytes.set(encoder.encode(options.name).subarray(0, 16), 8);+ if (wide) {+ view.setBigUint64(24, options.vmaddr, true);+ view.setBigUint64(32, options.vmsize, true);+ } else {+ view.setUint32(24, Number(options.vmaddr), true);+ view.setUint32(28, Number(options.vmsize), true);+ }+ return bytes;+};++/** 16-byte `LC_LAZY_LOAD_DYLIB_INFO` pointing at a slice-relative payload. */+export const lazyLoadDylibInfoCommand = (+ dataOffset: number,+ dataSize: number,+): Uint8Array => {+ const bytes = new Uint8Array(16);+ const view = new DataView(bytes.buffer);+ view.setUint32(0, 0x3a, true);+ view.setUint32(4, bytes.length, true);+ view.setUint32(8, dataOffset, true);+ view.setUint32(12, dataSize, true);+ return bytes;+};++export const machoImageWithLazyLoadDylibInfo = (options: {+ readonly path: string;+ readonly symbols?: readonly string[];+ readonly flags?: number;+ readonly flagImageOffset?: number;+ readonly chainStartImageOffset?: number;+ readonly cpu?: { readonly type: number; readonly subtype: number };+ readonly fileType?: number;+ readonly wide?: boolean;+ readonly commandsBefore?: readonly Uint8Array[];+ readonly commandsAfter?: readonly Uint8Array[];+}): Uint8Array => {+ const payload = lazyLoadDylibInfoPayload(options);+ const command = new Uint8Array(16);+ const commandView = new DataView(command.buffer);+ commandView.setUint32(0, 0x3a, true);+ commandView.setUint32(4, command.length, true);+ const wide = options.wide ?? true;+ const commandsBefore = options.commandsBefore ?? [];+ const image = machoImage({+ ...(options.cpu === undefined ? {} : { cpu: options.cpu }),+ ...(options.fileType === undefined ? {} : { fileType: options.fileType }),+ wide,+ commands: [...commandsBefore, command, ...(options.commandsAfter ?? [])],+ });+ const out = new Uint8Array(image.length + payload.length);+ out.set(image);+ out.set(payload, image.length);+ const headerSize = wide ? 32 : 28;+ const commandAt =+ headerSize + commandsBefore.reduce((total, item) => total + item.length, 0);+ const view = new DataView(out.buffer);+ view.setUint32(commandAt + 8, image.length, true);+ view.setUint32(commandAt + 12, payload.length, true);+ return out;+};+/** Thin Mach-O with one unknown command, for width and command-size regressions. */export const machoImageWithUnknownCommand = (wide: boolean,diff --git a/src/artifacts/apple/MachoLoadCommandReader.test.ts b/src/artifacts/apple/MachoLoadCommandReader.test.tsindex f360dfecd..fdd9a7981 100644--- a/src/artifacts/apple/MachoLoadCommandReader.test.ts+++ b/src/artifacts/apple/MachoLoadCommandReader.test.ts@@ -1,5 +1,5 @@import { createHash } from "node:crypto";-import { mkdir, writeFile } from "node:fs/promises";+import { mkdir, rename, writeFile } from "node:fs/promises";import { join } from "node:path";import { describe, expect, it } from "vitest";@@ -14,12 +14,18 @@ import {dylibCommand,dylibUseCommand,fatImage,+ lazyLoadDylibInfoCommand,+ lazyLoadDylibInfoPayload,machoImage,+ machoImageWithLazyLoadDylibInfo,+ segmentCommand,readerOf,rpathCommand,versionMinCommand,} from "./MachoImage.fixture.js";import {+ MAX_LAZY_INFO_DEPENDENCIES,+ MAX_LAZY_INFO_SYMBOL_REFERENCES,MAX_LOAD_COMMAND_BYTES,hasMachoMagic,readMachoImage,@@ -353,6 +359,650 @@ describe("Mach-O load command reader: decodes thin-image load commands", () => {});});+describe("LC_LAZY_LOAD_DYLIB_INFO payload", () => {+ it("reads install names from the linkedit payload in load-command order", async () => {+ const payload = lazyLoadDylibInfoPayload({+ path: "@rpath/libl.dylib",+ symbols: ["_lf"],+ });+ expect(payload).toHaveLength(56);+ const image = machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ symbols: ["_lf"],+ commandsBefore: [+ dylibCommand(LC.LOAD_DYLIB, "/usr/lib/libSystem.B.dylib"),+ ],+ commandsAfter: [dylibCommand(LC.LOAD_DYLIB, "@rpath/libafter.dylib")],+ });+ const facts = await read(image);+ if (facts.status !== "parsed")+ throw new Error(+ facts.status === "not-mach-o" ? facts.status : facts.reason,+ );+ expect(+ facts.slices[0]?.dependencies.map(+ ({ command, install_name: name, encoding, weak, current_version }) => ({+ command,+ name,+ encoding,+ weak,+ current_version,+ }),+ ),+ ).toEqual([+ {+ command: "LC_LOAD_DYLIB",+ name: "/usr/lib/libSystem.B.dylib",+ encoding: "dylib_command",+ weak: false,+ current_version: "1.0.0",+ },+ {+ command: "LC_LAZY_LOAD_DYLIB_INFO",+ name: "@rpath/libl.dylib",+ encoding: "lazy_load_dylib_info",+ weak: false,+ current_version: null,+ },+ {+ command: "LC_LOAD_DYLIB",+ name: "@rpath/libafter.dylib",+ encoding: "dylib_command",+ weak: false,+ current_version: "1.0.0",+ },+ ]);+ const weak = await read(+ machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ flags: 0x1,+ }),+ );+ if (weak.status !== "parsed")+ throw new Error(weak.status === "not-mach-o" ? weak.status : weak.reason);+ expect(weak.slices[0]?.dependencies[0]).toMatchObject({ weak: true });+ const universal = await read(+ fatImage([+ {+ cpu: CPU.arm64,+ bytes: machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ symbols: ["_lf"],+ }),+ },+ ]),+ );+ if (universal.status !== "parsed")+ throw new Error(+ universal.status === "not-mach-o" ? universal.status : universal.reason,+ );+ expect(universal.slices[0]?.dependencies[0]?.install_name).toBe(+ "@rpath/libl.dylib",+ );+ });++ it("rejects a lazy-info payload that is truncated, mis-pointed, or has unknown flags", async () => {+ const outside = machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ });+ const view = new DataView(outside.buffer);+ const commandAt = 32;+ view.setUint32(commandAt + 8, outside.length, true);+ expect((await read(outside)).status).toBe("malformed");++ const badPayload = lazyLoadDylibInfoPayload({+ path: "@rpath/libl.dylib",+ });+ const badPath = machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ });+ const payloadAt = badPath.length - badPayload.length;+ new DataView(badPath.buffer).setUint32(payloadAt, badPath.length, true);+ expect(await read(badPath)).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("load path"),+ });++ const unknownFlags = machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ flags: 0x2,+ });+ expect(await read(unknownFlags)).toMatchObject({+ status: "unsupported",+ reason: expect.stringContaining("unrecognized bits"),+ });+ });+});++describe("LC_LAZY_LOAD_DYLIB_INFO image offsets", () => {+ it("rejects flag and chain-start offsets outside the slice VM range", async () => {+ const beyondPage = await read(+ machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ flagImageOffset: 0x4001,+ }),+ );+ expect(beyondPage).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("flag image offset 0x4001"),+ });+ const beyondChain = await read(+ machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ chainStartImageOffset: 0x4001,+ }),+ );+ expect(beyondChain).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("chain start image offset 0x4001"),+ });+ const onPage = await read(+ machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ flagImageOffset: 0x4000,+ chainStartImageOffset: 0x4000,+ }),+ );+ expect(onPage.status).toBe("parsed");+ });++ it("measures the VM range from __TEXT and ignores __LINKEDIT", async () => {+ const text = segmentCommand({+ name: "__TEXT",+ vmaddr: 0x100000000n,+ vmsize: 0x8000n,+ });+ const inside = await read(+ machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ flagImageOffset: 0x8000,+ commandsBefore: [text],+ }),+ );+ expect(inside.status).toBe("parsed");+ const outside = await read(+ machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ chainStartImageOffset: 0x8001,+ commandsBefore: [text],+ }),+ );+ expect(outside).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("slice VM range 0x8000"),+ });+ const linkedit = await read(+ machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ flagImageOffset: 0x4001,+ commandsBefore: [+ segmentCommand({+ name: "__LINKEDIT",+ vmaddr: 0n,+ vmsize: 0x100000n,+ }),+ ],+ }),+ );+ expect(linkedit.status).toBe("malformed");+ });++ it("keeps a short segment parseable until a lazy-info command needs its VM range", async () => {+ const short = new Uint8Array(16);+ const view = new DataView(short.buffer);+ view.setUint32(0, 0x19, true);+ view.setUint32(4, short.length, true);+ expect((await read(machoImage({ commands: [short] }))).status).toBe(+ "parsed",+ );+ const withLazy = await read(+ machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ commandsBefore: [short],+ }),+ );+ expect(withLazy).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("slice VM range"),+ });+ });+});++describe("LC_LAZY_LOAD_DYLIB_INFO payload budget", () => {+ it("reads one shared payload range once", async () => {+ const payload = lazyLoadDylibInfoPayload({+ path: "@rpath/libl.dylib",+ symbols: ["_lf"],+ });+ const dataOffset = 32 + 16 + 16 + 16;+ const image = machoImage({+ commands: [+ lazyLoadDylibInfoCommand(dataOffset, payload.length),+ lazyLoadDylibInfoCommand(dataOffset, payload.length),+ ],+ });+ const bytes = new Uint8Array(image.length + payload.length);+ bytes.set(image);+ bytes.set(payload, image.length);+ let payloadReads = 0;+ const facts = await readMachoImage(async (offset, length) => {+ if (offset === image.length && length === payload.length)+ payloadReads += 1;+ return bytes.subarray(offset, offset + length);+ }, bytes.length);+ expect(payloadReads).toBe(1);+ expect(facts).toMatchObject({+ status: "parsed",+ slices: [+ {+ dependencies: [+ { install_name: "@rpath/libl.dylib" },+ { install_name: "@rpath/libl.dylib" },+ ],+ },+ ],+ });+ });++ it("refuses distinct lazy-info payloads whose combined size exceeds the aggregate limit", async () => {+ const payload = lazyLoadDylibInfoPayload({ path: "@rpath/libl.dylib" });+ const dataOffset = 32 + 16 + 32;+ const image = machoImage({+ commands: [+ lazyLoadDylibInfoCommand(dataOffset, payload.length),+ lazyLoadDylibInfoCommand(0, MAX_LOAD_COMMAND_BYTES),+ ],+ });+ const bytes = new Uint8Array(MAX_LOAD_COMMAND_BYTES);+ bytes.set(image);+ bytes.set(payload, image.length);+ expect(await read(bytes)).toMatchObject({+ status: "unsupported",+ reason: expect.stringContaining("aggregate limit"),+ });+ });++ it("does not reread a payload range contained in an earlier read", async () => {+ const payload = lazyLoadDylibInfoPayload({+ path: "@rpath/libl.dylib",+ symbols: ["_lf"],+ });+ const image = machoImage({+ commands: [+ lazyLoadDylibInfoCommand(0, payload.length + 8),+ lazyLoadDylibInfoCommand(0, payload.length),+ ],+ });+ const bytes = new Uint8Array(image.length + payload.length + 8);+ bytes.set(image);+ bytes.set(payload, image.length);+ const view = new DataView(bytes.buffer);+ view.setUint32(32 + 8, image.length, true);+ view.setUint32(48 + 8, image.length, true);+ let payloadReads = 0;+ const facts = await readMachoImage(async (offset, length) => {+ if (offset === image.length) payloadReads += 1;+ return bytes.subarray(offset, offset + length);+ }, bytes.length);+ expect(payloadReads).toBe(1);+ expect(facts).toMatchObject({+ status: "parsed",+ slices: [+ {+ dependencies: [+ { install_name: "@rpath/libl.dylib" },+ { install_name: "@rpath/libl.dylib" },+ ],+ },+ ],+ });+ });++ it("parses distinct non-nested lazy-info payloads under the dependency limit", async () => {+ const count = 8;+ const payloadSize = 26;+ const payload = new Uint8Array(payloadSize);+ new DataView(payload.buffer).setUint32(0, 24, true);+ new DataView(payload.buffer).setUint32(20, 24, true);+ const dataOffset = 32 + 16 + count * 16;+ const commands = Array.from({ length: count }, (_, index) =>+ lazyLoadDylibInfoCommand(dataOffset + index * payloadSize, payloadSize),+ );+ const image = machoImage({ commands });+ const bytes = new Uint8Array(image.length + count * payloadSize);+ bytes.set(image);+ for (let index = 0; index < count; index += 1)+ bytes.set(payload, image.length + index * payloadSize);+ const facts = await read(bytes);+ if (facts.status !== "parsed")+ throw new Error(+ facts.status === "not-mach-o" ? facts.status : facts.reason,+ );+ expect(facts.slices[0]?.dependencies).toHaveLength(count);+ });+});++describe("LC_LAZY_LOAD_DYLIB_INFO dependency limit", () => {+ it("retains one result per command until the dependency limit", async () => {+ const payload = lazyLoadDylibInfoPayload({ path: "@rpath/libl.dylib" });+ const imageFor = (count: number) => {+ const dataOffset = 32 + 16 + count * 16;+ const image = machoImage({+ commands: Array.from({ length: count }, () =>+ lazyLoadDylibInfoCommand(dataOffset, payload.length),+ ),+ });+ const bytes = new Uint8Array(image.length + payload.length);+ bytes.set(image);+ bytes.set(payload, image.length);+ return bytes;+ };+ const atLimit = await read(imageFor(MAX_LAZY_INFO_DEPENDENCIES));+ if (atLimit.status !== "parsed")+ throw new Error(+ atLimit.status === "not-mach-o" ? atLimit.status : atLimit.reason,+ );+ expect(atLimit.slices[0]?.dependencies).toHaveLength(+ MAX_LAZY_INFO_DEPENDENCIES,+ );+ expect(await read(imageFor(MAX_LAZY_INFO_DEPENDENCIES + 1))).toMatchObject({+ status: "unsupported",+ reason: expect.stringContaining("dependency limit"),+ });+ });+});++describe("LC_LAZY_LOAD_DYLIB_INFO string bounds", () => {+ it("does not reuse a cached path that extends past a shorter payload", async () => {+ const payload = new Uint8Array(48);+ const view = new DataView(payload.buffer);+ const path = new TextEncoder().encode("@rpath/libl.dylib");+ view.setUint32(0, 24, true);+ view.setUint32(20, 24, true);+ payload.set(path, 24);+ const image = machoImage({+ commands: [+ lazyLoadDylibInfoCommand(0, payload.length),+ lazyLoadDylibInfoCommand(0, 24),+ ],+ });+ const bytes = new Uint8Array(image.length + payload.length);+ bytes.set(image);+ bytes.set(payload, image.length);+ const patched = new DataView(bytes.buffer);+ patched.setUint32(32 + 8, image.length, true);+ patched.setUint32(48 + 8, image.length, true);+ expect(await read(bytes)).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("outside the payload"),+ });+ const truncated = machoImage({+ commands: [+ lazyLoadDylibInfoCommand(0, payload.length),+ lazyLoadDylibInfoCommand(0, 40),+ ],+ });+ const truncatedBytes = new Uint8Array(truncated.length + payload.length);+ truncatedBytes.set(truncated);+ truncatedBytes.set(payload, truncated.length);+ const truncatedView = new DataView(truncatedBytes.buffer);+ truncatedView.setUint32(32 + 8, truncated.length, true);+ truncatedView.setUint32(48 + 8, truncated.length, true);+ expect(await read(truncatedBytes)).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("unterminated"),+ });+ });++ it("rejects a load path taken from the payload header", async () => {+ const payload = new Uint8Array(24);+ const view = new DataView(payload.buffer);+ view.setUint32(0, 4, true);+ view.setUint32(20, 24, true);+ const image = machoImage({+ commands: [lazyLoadDylibInfoCommand(0, payload.length)],+ });+ const bytes = new Uint8Array(image.length + payload.length);+ bytes.set(image);+ bytes.set(payload, image.length);+ new DataView(bytes.buffer).setUint32(32 + 8, image.length, true);+ expect(await read(bytes)).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("inside the payload header"),+ });+ const symbolPayload = lazyLoadDylibInfoPayload({+ path: "@rpath/libl.dylib",+ symbols: ["_lf"],+ });+ new DataView(symbolPayload.buffer).setUint32(24, 4, true);+ const symbolImage = machoImage({+ commands: [lazyLoadDylibInfoCommand(0, symbolPayload.length)],+ });+ const symbolBytes = new Uint8Array(+ symbolImage.length + symbolPayload.length,+ );+ symbolBytes.set(symbolImage);+ symbolBytes.set(symbolPayload, symbolImage.length);+ new DataView(symbolBytes.buffer).setUint32(+ 32 + 8,+ symbolImage.length,+ true,+ );+ expect(await read(symbolBytes)).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("symbol 0"),+ });+ });++ it("charges repeated and overlapping symbol scans against the string budget", async () => {+ const path = new TextEncoder().encode("@rpath/libl.dylib");+ const stringBytes = 64 * 1024;+ const imageFor = (symbolCount: number, step: number) => {+ const pathOffset = 24 + symbolCount * 4;+ const stringOffset = pathOffset + path.length + 1;+ const payload = new Uint8Array(stringOffset + stringBytes + 1);+ const view = new DataView(payload.buffer);+ view.setUint32(0, pathOffset, true);+ view.setUint32(16, symbolCount, true);+ view.setUint32(20, 24, true);+ payload.set(path, pathOffset);+ payload.fill(0x61, stringOffset, stringOffset + stringBytes);+ for (let symbol = 0; symbol < symbolCount; symbol += 1)+ view.setUint32(+ 24 + symbol * 4,+ stringOffset + (step === 0 ? 0 : symbol % 8),+ true,+ );+ const image = machoImage({+ commands: [lazyLoadDylibInfoCommand(0, payload.length)],+ });+ const bytes = new Uint8Array(image.length + payload.length);+ bytes.set(image);+ bytes.set(payload, image.length);+ new DataView(bytes.buffer).setUint32(32 + 8, image.length, true);+ return bytes;+ };+ expect(imageFor(2, 0).length).toBeLessThan(MAX_LOAD_COMMAND_BYTES);+ expect(await read(imageFor(2, 0))).toMatchObject({+ status: "parsed",+ slices: [{ dependencies: [{ install_name: "@rpath/libl.dylib" }] }],+ });+ const over = Math.floor(MAX_LOAD_COMMAND_BYTES / (stringBytes + 1)) + 2;+ expect(await read(imageFor(over, 0))).toMatchObject({+ status: "unsupported",+ reason: expect.stringContaining("string validation"),+ });+ expect(await read(imageFor(over, 1))).toMatchObject({+ status: "unsupported",+ reason: expect.stringContaining("string validation"),+ });+ });+});++const lazyInfoPayloadWithSymbolCount = (+ symbolCount: number,+ pathText: string,+): Uint8Array => {+ const path = new TextEncoder().encode(pathText);+ const pathOffset = 24 + symbolCount * 4;+ // One byte after the path NUL, because a load-path terminator in the+ // payload's final byte is unterminated.+ const payload = new Uint8Array(pathOffset + path.length + 2);+ const view = new DataView(payload.buffer);+ view.setUint32(0, pathOffset, true);+ view.setUint32(16, symbolCount, true);+ view.setUint32(20, 24, true);+ payload.set(path, pathOffset);+ const emptySymbol = pathOffset + path.length;+ for (let symbol = 0; symbol < symbolCount; symbol += 1)+ view.setUint32(24 + symbol * 4, emptySymbol, true);+ return payload;+};++const imageWithLazyPayload = (payload: Uint8Array): Uint8Array => {+ const image = machoImage({+ commands: [lazyLoadDylibInfoCommand(0, payload.length)],+ });+ const bytes = new Uint8Array(image.length + payload.length);+ bytes.set(image);+ bytes.set(payload, image.length);+ const view = new DataView(bytes.buffer);+ view.setUint32(32 + 8, image.length, true);+ view.setUint32(32 + 12, payload.length, true);+ return bytes;+};++describe("LC_LAZY_LOAD_DYLIB_INFO symbol cardinality", () => {+ it("stops before caching one string for every symbol offset", async () => {+ const atLimit = lazyInfoPayloadWithSymbolCount(+ MAX_LAZY_INFO_SYMBOL_REFERENCES,+ "@rpath/libl.dylib",+ );+ expect(await read(imageWithLazyPayload(atLimit))).toMatchObject({+ status: "parsed",+ slices: [{ dependencies: [{ install_name: "@rpath/libl.dylib" }] }],+ });+ const overLimit = lazyInfoPayloadWithSymbolCount(+ MAX_LAZY_INFO_SYMBOL_REFERENCES + 1,+ "@rpath/libl.dylib",+ );+ expect(await read(imageWithLazyPayload(overLimit))).toMatchObject({+ status: "unsupported",+ reason: expect.stringContaining("65536-reference limit"),+ });+ });++ it("counts symbol references across distinct lazy-info payloads", async () => {+ const first = lazyInfoPayloadWithSymbolCount(+ MAX_LAZY_INFO_SYMBOL_REFERENCES,+ "@rpath/libl.dylib",+ );+ const second = lazyInfoPayloadWithSymbolCount(1, "@rpath/libm.dylib");+ const image = machoImage({+ commands: [+ lazyLoadDylibInfoCommand(0, first.length),+ lazyLoadDylibInfoCommand(0, second.length),+ ],+ });+ const bytes = new Uint8Array(image.length + first.length + second.length);+ bytes.set(image);+ bytes.set(first, image.length);+ bytes.set(second, image.length + first.length);+ const view = new DataView(bytes.buffer);+ view.setUint32(32 + 8, image.length, true);+ view.setUint32(32 + 12, first.length, true);+ view.setUint32(48 + 8, image.length + first.length, true);+ view.setUint32(48 + 12, second.length, true);+ expect(await read(bytes)).toMatchObject({+ status: "unsupported",+ reason: expect.stringContaining("65536-reference limit"),+ });+ });+});++describe("LC_LAZY_LOAD_DYLIB_INFO path terminator", () => {+ it("rejects a load path whose NUL is the payload's final byte", async () => {+ const payload = new Uint8Array(27);+ const view = new DataView(payload.buffer);+ view.setUint32(0, 24, true);+ view.setUint32(20, 24, true);+ payload[24] = 0x61;+ const imageFor = (size: number) => {+ const image = machoImage({+ commands: [lazyLoadDylibInfoCommand(0, size)],+ });+ const bytes = new Uint8Array(image.length + payload.length);+ bytes.set(image);+ bytes.set(payload, image.length);+ new DataView(bytes.buffer).setUint32(32 + 8, image.length, true);+ new DataView(bytes.buffer).setUint32(32 + 12, size, true);+ return bytes;+ };+ expect((await read(imageFor(payload.length))).status).toBe("parsed");+ expect(await read(imageFor(26))).toMatchObject({+ status: "malformed",+ reason: expect.stringContaining("unterminated"),+ });+ });+});++describe("LC_LAZY_LOAD_DYLIB_INFO resolution", () => {+ it("reports the lazy edge and does not treat an absent image as a launch failure", async () => {+ const root = await createTestTempDirectory("rea-lazy-info-");+ const executablePath = "lazy";+ const dylibPath = "lib/libl.dylib";+ const executable = machoImageWithLazyLoadDylibInfo({+ path: "@rpath/libl.dylib",+ symbols: ["_lf"],+ commandsBefore: [+ buildVersionCommand(1),+ rpathCommand("@executable_path/lib"),+ dylibCommand(LC.LOAD_DYLIB, "/usr/lib/libSystem.B.dylib"),+ ],+ });+ const dylib = machoImage({+ fileType: FILE_TYPE.dylib,+ commands: [+ buildVersionCommand(1),+ dylibCommand(LC.ID_DYLIB, "@rpath/libl.dylib"),+ dylibCommand(LC.LOAD_DYLIB, "@rpath/libdeep.dylib"),+ ],+ });+ await mkdir(join(root, "lib"));+ await writeFile(join(root, executablePath), executable);+ await writeFile(join(root, dylibPath), dylib);+ const trace = () =>+ traceDylibResolution({+ rootPath: root,+ targetPath: join(root, executablePath),+ targetSha256: createHash("sha256").update(executable).digest("hex"),+ enumerateRoots: false,+ parameters: { roots: [executablePath] },+ });+ const present = await trace();+ expect(present.coverage.status).toBe("complete");+ expect(present.edges.map(({ install_name: name }) => name)).toEqual([+ "/usr/lib/libSystem.B.dylib",+ "@rpath/libl.dylib",+ ]);+ expect(present.edges[1]).toMatchObject({+ command: "LC_LAZY_LOAD_DYLIB_INFO",+ encoding: "lazy_load_dylib_info",+ current_version: null,+ compatibility_version: null,+ resolution: { status: "resolved", image: dylibPath },+ });+ expect(present.findings).toEqual([]);+ await rename(join(root, dylibPath), `${join(root, dylibPath)}.moved`);+ const absent = await trace();+ expect(absent.coverage.status).toBe("complete");+ expect(absent.findings.map(({ kind }) => kind)).toEqual([+ "lazy-load-unresolved",+ ]);+ expect(absent.edges[1]?.resolution.status).toBe("unresolved");+ });+});+describe("Mach-O load command reader: reads and validates universal binary slices", () => {it("reads every slice of FAT and FAT_64 containers in either byte order", async () => {for (const [wide, littleEndian] of [diff --git a/src/artifacts/apple/MachoLoadCommandReader.ts b/src/artifacts/apple/MachoLoadCommandReader.tsindex 5c67bd2af..0e22cd4d2 100644--- a/src/artifacts/apple/MachoLoadCommandReader.ts+++ b/src/artifacts/apple/MachoLoadCommandReader.ts@@ -18,6 +18,18 @@ export type ReadAt = (offset: number, length: number) => Promise<Uint8Array>;/** Load commands larger than this are refused instead of buffered. */export const MAX_LOAD_COMMAND_BYTES = 16 * 1024 * 1024;+/**+ * Identical `LC_LAZY_LOAD_DYLIB_INFO` commands are 16 bytes, so the load-command+ * byte cap alone would retain about a million dependency results. Stop before+ * those results are kept or traced.+ */+export const MAX_LAZY_INFO_DEPENDENCIES = 1024;+/**+ * Symbol names are validated and then discarded. Distinct one-byte strings+ * stay under the 16 MiB byte budgets while retaining one cache entry per+ * offset, so stop before that map and those decodes grow.+ */+export const MAX_LAZY_INFO_SYMBOL_REFERENCES = 64 * 1024;const MH_MAGIC = 0xfeedface;const MH_MAGIC_64 = 0xfeedfacf;const MH_CIGAM = 0xcefaedfe;@@ -27,11 +39,14 @@ const FAT_MAGIC_64 = 0xcafebabf;const FAT_CIGAM = 0xbebafeca;const FAT_CIGAM_64 = 0xbfbafeca;+const LC_SEGMENT = 0x1;+const LC_SEGMENT_64 = 0x19;const LC_ID_DYLIB = 0xd;const LC_LOAD_DYLIB = 0xc;const LC_LOAD_WEAK_DYLIB = 0x80000018;const LC_REEXPORT_DYLIB = 0x8000001f;const LC_LAZY_LOAD_DYLIB = 0x20;+const LC_LAZY_LOAD_DYLIB_INFO = 0x3a;const LC_LOAD_UPWARD_DYLIB = 0x80000023;const LC_RPATH = 0x8000001c;const LC_DYLD_ENVIRONMENT = 0x27;@@ -85,6 +100,14 @@ const legacyVersionMinPlatform = (/** `mach-o/loader.h` `dylib_use_command`: `nameoff == 28` and this marker. */const DYLIB_USE_MARKER = 0x1a741800;+const LAZY_INFO_HEADER_BYTES = 24;+/** ld64 may-be-missing bit: the lazy image is allowed to be absent. */+const LAZY_INFO_MAY_BE_MISSING = 0x1;+/**+ * dyld's linkedit image-offset checks start at one page, then grow to the+ * runtime end of every segment except `__LINKEDIT`.+ */+const LAZY_INFO_MIN_VM_OFFSET = 0x4000n;const DYLIB_USE_WEAK_LINK = 0x1;const DYLIB_USE_REEXPORT = 0x2;const DYLIB_USE_UPWARD = 0x4;@@ -293,7 +316,7 @@ const readSlice = async (commandBytes,"load commands",);- const slice = decodeCommands(commands, {+ const decoded = decodeCommands(commands, {wide,cpuType: identity.cpuType,cpuSubtype: identity.cpuSubtype,@@ -305,6 +328,15 @@ const readSlice = async (fatCpuSubtype: fat?.fatCpuSubtype ?? null,fatAlignmentExponent: fat?.alignmentExponent ?? null,});+ const slice = decoded.slice;+ await appendDependencies(+ slice,+ decoded.dependencies,+ readAt,+ base,+ length,+ decoded.maxVmOffset,+ );const distinctPlatforms = [...new Set(slice.platforms)];slice.platform =distinctPlatforms.length === 1 ? (distinctPlatforms[0] ?? null) : null;@@ -334,7 +366,14 @@ const decodeCommands = (readonly fatCpuSubtype: number | null;readonly fatAlignmentExponent: number | null;},-): MachoSlice => {+): {+ readonly slice: MachoSlice;+ readonly dependencies: readonly (+ | { readonly kind: "parsed"; readonly value: MachoDependency }+ | LazyLoadDylibInfoCommand+ )[];+ readonly maxVmOffset: bigint;+} => {const view = viewOf(bytes);const slice: MachoSlice = {architecture: architectureName(header.cpuType, header.cpuSubtype),@@ -355,6 +394,14 @@ const decodeCommands = (dyld_environment: [],code_signature_present: false,};+ const dependencies: Array<+ | { readonly kind: "parsed"; readonly value: MachoDependency }+ | LazyLoadDylibInfoCommand+ > = [];+ const segments: SegmentSpan[] = [];+ let unreadableSegment: number | undefined;+ let lazyInfo = false;+ let lazyInfoCount = 0;let offset = 0;for (let index = 0; index < header.commandCount; index++) {if (offset + 8 > bytes.byteLength)@@ -374,7 +421,22 @@ const decodeCommands = (`load command ${index} at offset ${offset} has invalid cmdsize ${size}`,);const body = bytes.subarray(offset, offset + size);- decodeCommand(command, body, index, slice);+ if (command === LC_SEGMENT || command === LC_SEGMENT_64) {+ const span = readSegmentSpan(body, command === LC_SEGMENT_64);+ if (span === undefined) unreadableSegment ??= index;+ else segments.push(span);+ }+ if (command === LC_LAZY_LOAD_DYLIB_INFO) {+ lazyInfoCount += 1;+ if (lazyInfoCount > MAX_LAZY_INFO_DEPENDENCIES)+ throw new MachoFormatIssue(+ "unsupported",+ `LC_LAZY_LOAD_DYLIB_INFO commands exceed the ${MAX_LAZY_INFO_DEPENDENCIES}-dependency limit`,+ );+ lazyInfo = true;+ }+ const decoded = decodeCommand(command, body, index, slice);+ if (decoded !== undefined) dependencies.push(decoded);offset += size;}if (offset !== bytes.byteLength)@@ -382,7 +444,150 @@ const decodeCommands = ("malformed",`load commands declare ${header.commandCount} commands but sizeofcmds holds ${bytes.byteLength} bytes`,);- return slice;+ if (lazyInfo && unreadableSegment !== undefined)+ throw new MachoFormatIssue(+ "malformed",+ `load command ${unreadableSegment} is too short to establish the slice VM range for LC_LAZY_LOAD_DYLIB_INFO`,+ );+ return { slice, dependencies, maxVmOffset: maximumVmOffset(segments) };+};++interface LazyLoadDylibInfoCommand {+ readonly kind: "lazy-info";+ readonly index: number;+ readonly dataOffset: number;+ readonly dataSize: number;+}++interface SegmentSpan {+ readonly name: string;+ readonly vmaddr: bigint;+ readonly vmsize: bigint;+}++/** Runtime end of the mapped image, excluding `__LINKEDIT`, floored at one page. */+const maximumVmOffset = (segments: readonly SegmentSpan[]): bigint => {+ let textVmAddr = 0n;+ for (const segment of segments) {+ if (segment.name === "__TEXT") {+ textVmAddr = segment.vmaddr;+ break;+ }+ }+ let max = LAZY_INFO_MIN_VM_OFFSET;+ for (const segment of segments) {+ if (segment.name === "__LINKEDIT") continue;+ const end = segment.vmaddr - textVmAddr + segment.vmsize;+ if (end > max) max = end;+ }+ return max;+};++const readSegmentSpan = (+ body: Uint8Array,+ wide: boolean,+): SegmentSpan | undefined => {+ if (body.byteLength < (wide ? 72 : 56)) return undefined;+ const view = viewOf(body);+ const nameBytes = body.subarray(8, 24);+ const end = nameBytes.indexOf(0);+ return {+ name: new TextDecoder("utf-8", { fatal: false }).decode(+ end < 0 ? nameBytes : nameBytes.subarray(0, end),+ ),+ vmaddr: wide+ ? view.getBigUint64(24, true)+ : BigInt(view.getUint32(24, true)),+ vmsize: wide+ ? view.getBigUint64(32, true)+ : BigInt(view.getUint32(28, true)),+ };+};++interface CachedLazyString {+ readonly text: string;+ /** Absolute file offset of the terminating NUL. */+ readonly end: number;+}++interface LazyPayloadWork {+ readonly dependencies: Map<string, MachoDependency>;+ readonly reads: { fileOffset: number; bytes: Uint8Array }[];+ readonly strings: Map<number, CachedLazyString>;+ payloadBytes: number;+ /** Scanned string bytes. Repeats and overlaps each count in full. */+ stringBytes: number;+ /** Symbol-string references. Repeats each count. */+ symbolReferences: number;+ rangeChecks: number;+}++const containedPayload = (+ reads: readonly { fileOffset: number; bytes: Uint8Array }[],+ fileOffset: number,+ size: number,+ work: LazyPayloadWork,+): Uint8Array | undefined => {+ for (const read of reads) {+ work.rangeChecks += 1;+ if (work.rangeChecks > MAX_LOAD_COMMAND_BYTES)+ throw new MachoFormatIssue(+ "unsupported",+ `LC_LAZY_LOAD_DYLIB_INFO payload range lookup exceeds the ${MAX_LOAD_COMMAND_BYTES}-check limit`,+ );+ const start = fileOffset - read.fileOffset;+ if (+ start >= 0 &&+ Number.isSafeInteger(start) &&+ start + size <= read.bytes.byteLength+ )+ return read.bytes.subarray(start, start + size);+ }+ return undefined;+};++const appendDependencies = async (+ slice: MachoSlice,+ dependencies: readonly (+ | { readonly kind: "parsed"; readonly value: MachoDependency }+ | LazyLoadDylibInfoCommand+ )[],+ readAt: ReadAt,+ base: number,+ length: number,+ maxVmOffset: bigint,+): Promise<void> => {+ const work: LazyPayloadWork = {+ dependencies: new Map(),+ reads: [],+ strings: new Map(),+ payloadBytes: 0,+ stringBytes: 0,+ symbolReferences: 0,+ rangeChecks: 0,+ };+ for (const dependency of dependencies) {+ if (dependency.kind === "parsed") {+ slice.dependencies.push(dependency.value);+ continue;+ }+ const key = `${dependency.dataOffset}:${dependency.dataSize}`;+ const cached = work.dependencies.get(key);+ if (cached !== undefined) {+ slice.dependencies.push(cached);+ continue;+ }+ const value = await readLazyLoadDylibInfo(+ readAt,+ base,+ length,+ dependency,+ maxVmOffset,+ work,+ );+ work.dependencies.set(key, value);+ slice.dependencies.push(value);+ }};const decodeCommand = (@@ -390,7 +595,10 @@ const decodeCommand = (body: Uint8Array,index: number,slice: MachoSlice,-): void => {+):+ | { readonly kind: "parsed"; readonly value: MachoDependency }+ | LazyLoadDylibInfoCommand+ | undefined => {if (command === LC_ID_DYLIB) {slice.install_name = commandString(body, 24, index);return;@@ -440,9 +648,270 @@ const decodeCommand = (slice.platforms.push(legacyPlatform);return;}+ if (command === LC_LAZY_LOAD_DYLIB_INFO)+ return decodeLazyLoadDylibInfoCommand(body, index);const name = DEPENDENCY_COMMANDS.get(command);if (name !== undefined)- slice.dependencies.push(decodeDependency(name, body, index));+ return { kind: "parsed", value: decodeDependency(name, body, index) };+ return undefined;+};++/**+ * `LC_LAZY_LOAD_DYLIB_INFO` is a linkedit-data command. The install name is+ * not in the command; it is a NUL-terminated string in the payload.+ */+const decodeLazyLoadDylibInfoCommand = (+ body: Uint8Array,+ index: number,+): LazyLoadDylibInfoCommand => {+ if (body.byteLength < 16)+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} is too short for LC_LAZY_LOAD_DYLIB_INFO`,+ );+ const view = viewOf(body);+ const dataOffset = view.getUint32(8, true);+ const dataSize = view.getUint32(12, true);+ if (dataSize < LAZY_INFO_HEADER_BYTES)+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO payload is shorter than its 24-byte header`,+ );+ if (dataSize > MAX_LOAD_COMMAND_BYTES)+ throw new MachoFormatIssue(+ "unsupported",+ `LC_LAZY_LOAD_DYLIB_INFO payload occupies ${dataSize} bytes, above the ${MAX_LOAD_COMMAND_BYTES}-byte limit`,+ );+ return { kind: "lazy-info", index, dataOffset, dataSize };+};++const readLazyPayloadBytes = async (+ readAt: ReadAt,+ fileOffset: number,+ size: number,+ index: number,+ work: LazyPayloadWork,+): Promise<Uint8Array> => {+ const covered = containedPayload(work.reads, fileOffset, size, work);+ if (covered !== undefined) return covered;+ work.payloadBytes += size;+ if (work.payloadBytes > MAX_LOAD_COMMAND_BYTES)+ throw new MachoFormatIssue(+ "unsupported",+ `LC_LAZY_LOAD_DYLIB_INFO payloads occupy ${work.payloadBytes} bytes, above the ${MAX_LOAD_COMMAND_BYTES}-byte aggregate limit`,+ );+ const payload = await readExact(+ readAt,+ fileOffset,+ size,+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO payload`,+ );+ work.reads.push({ fileOffset, bytes: payload });+ return payload;+};++const readLazyLoadDylibInfo = async (+ readAt: ReadAt,+ base: number,+ length: number,+ command: LazyLoadDylibInfoCommand,+ maxVmOffset: bigint,+ work: LazyPayloadWork,+): Promise<MachoDependency> => {+ if (+ command.dataOffset > length ||+ command.dataSize > length - command.dataOffset+ )+ throw new MachoFormatIssue(+ "malformed",+ `load command ${command.index} LC_LAZY_LOAD_DYLIB_INFO payload extends beyond the Mach-O slice`,+ );+ const fileOffset = base + command.dataOffset;+ if (!Number.isSafeInteger(fileOffset))+ throw new MachoFormatIssue(+ "malformed",+ `load command ${command.index} LC_LAZY_LOAD_DYLIB_INFO payload offset is not a safe integer`,+ );+ const payload = await readLazyPayloadBytes(+ readAt,+ fileOffset,+ command.dataSize,+ command.index,+ work,+ );+ return decodeLazyLoadDylibInfoPayload(+ payload,+ command.index,+ fileOffset,+ maxVmOffset,+ work,+ );+};++const decodeLazyLoadDylibInfoPayload = (+ payload: Uint8Array,+ index: number,+ fileOffset: number,+ maxVmOffset: bigint,+ work: LazyPayloadWork,+): MachoDependency => {+ const view = viewOf(payload);+ const pathOffset = view.getUint32(0, true);+ const flagImageOffset = view.getUint32(4, true);+ const flags = view.getUint16(8, true);+ const chainStartImageOffset = view.getUint32(12, true);+ const symbolCount = view.getUint32(16, true);+ const symbolArrayOffset = view.getUint32(20, true);+ if (BigInt(flagImageOffset) > maxVmOffset)+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO flag image offset 0x${flagImageOffset.toString(16)} is beyond the slice VM range 0x${maxVmOffset.toString(16)}`,+ );+ if (BigInt(chainStartImageOffset) > maxVmOffset)+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO chain start image offset 0x${chainStartImageOffset.toString(16)} is beyond the slice VM range 0x${maxVmOffset.toString(16)}`,+ );+ if ((flags & ~LAZY_INFO_MAY_BE_MISSING) !== 0)+ throw new MachoFormatIssue(+ "unsupported",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO flags 0x${flags.toString(16)} include unrecognized bits`,+ );+ if (+ symbolArrayOffset > payload.byteLength ||+ symbolCount > (payload.byteLength - symbolArrayOffset) / 4+ )+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO symbol table extends beyond the payload`,+ );+ const installName = payloadString(+ payload,+ pathOffset,+ fileOffset,+ index,+ "load path",+ work,+ true,+ );+ const symbolReferences = work.symbolReferences + symbolCount;+ if (symbolReferences > MAX_LAZY_INFO_SYMBOL_REFERENCES)+ throw new MachoFormatIssue(+ "unsupported",+ `LC_LAZY_LOAD_DYLIB_INFO symbol validation exceeds the ${MAX_LAZY_INFO_SYMBOL_REFERENCES}-reference limit`,+ );+ work.symbolReferences = symbolReferences;+ for (let symbol = 0; symbol < symbolCount; symbol += 1) {+ const offset = view.getUint32(symbolArrayOffset + symbol * 4, true);+ payloadString(+ payload,+ offset,+ fileOffset,+ index,+ `symbol ${symbol}`,+ work,+ false,+ );+ }+ return {+ command: "LC_LAZY_LOAD_DYLIB_INFO",+ encoding: "lazy_load_dylib_info",+ install_name: installName,+ weak: (flags & LAZY_INFO_MAY_BE_MISSING) !== 0,+ upward: false,+ reexport: false,+ delayed_init: false,+ current_version: null,+ compatibility_version: null,+ };+};++const chargeLazyString = (work: LazyPayloadWork, examined: number): void => {+ const occupied = work.stringBytes + examined;+ if (occupied > MAX_LOAD_COMMAND_BYTES)+ throw new MachoFormatIssue(+ "unsupported",+ `LC_LAZY_LOAD_DYLIB_INFO string validation occupies ${occupied} bytes, above the ${MAX_LOAD_COMMAND_BYTES}-byte limit`,+ );+ work.stringBytes = occupied;+};++/**+ * NUL-terminated UTF-8 string after the fixed payload header.+ * dyld's load-path scan stops before the payload's final byte, so a NUL+ * in that byte does not terminate the path.+ */+const payloadString = (+ payload: Uint8Array,+ offset: number,+ fileOffset: number,+ index: number,+ label: string,+ work: LazyPayloadWork,+ excludeFinalByte: boolean,+): string => {+ if (offset < LAZY_INFO_HEADER_BYTES)+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO ${label} offset ${offset} is inside the payload header`,+ );+ if (offset >= payload.byteLength)+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO ${label} offset ${offset} is outside the payload`,+ );+ const absolute = Number.isSafeInteger(fileOffset + offset)+ ? fileOffset + offset+ : undefined;+ const cached =+ absolute === undefined ? undefined : work.strings.get(absolute);+ const terminatorLimit = excludeFinalByte+ ? payload.byteLength - 1+ : payload.byteLength;+ if (cached !== undefined && absolute !== undefined) {+ const end = cached.end - fileOffset;+ if (end < offset || end >= terminatorLimit)+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO ${label} is unterminated`,+ );+ chargeLazyString(work, cached.end - absolute + 1);+ return cached.text;+ }+ if (offset >= terminatorLimit)+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO ${label} is unterminated`,+ );+ const remaining = MAX_LOAD_COMMAND_BYTES - work.stringBytes;+ const windowEnd = Math.min(terminatorLimit, offset + remaining);+ const end = payload.subarray(0, windowEnd).indexOf(0, offset);+ if (end < 0) {+ if (windowEnd < terminatorLimit)+ throw new MachoFormatIssue(+ "unsupported",+ `LC_LAZY_LOAD_DYLIB_INFO string validation occupies ${work.stringBytes + (windowEnd - offset) + 1} bytes, above the ${MAX_LOAD_COMMAND_BYTES}-byte limit`,+ );+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO ${label} is unterminated`,+ );+ }+ chargeLazyString(work, end - offset + 1);+ let text: string;+ try {+ text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(+ payload.subarray(offset, end),+ );+ } catch {+ throw new MachoFormatIssue(+ "malformed",+ `load command ${index} LC_LAZY_LOAD_DYLIB_INFO ${label} is not UTF-8`,+ );+ }+ if (absolute !== undefined && Number.isSafeInteger(fileOffset + end))+ work.strings.set(absolute, { text, end: fileOffset + end });+ return text;};const decodeDependency = (diff --git a/src/contracts/artifactToolContracts.ts b/src/contracts/artifactToolContracts.tsindex 23657b7d7..afb8a10de 100644--- a/src/contracts/artifactToolContracts.ts+++ b/src/contracts/artifactToolContracts.ts@@ -115,7 +115,7 @@ export const ARTIFACT_TOOL_CONTRACTS = [),artifact("trace_dylib_resolution",- "Trace how dyld would resolve each Mach-O dylib load for the active Mach-O, or for every executable in the active .app bundle (the main app, XPC services, extensions, login items, helpers). Expands @executable_path, @loader_path, and @rpath through each process's LC_RPATH stack in dependents-first load order, and reports every candidate path with its outcome, the resolved image and digest, weak, re-export, and upward flags, and derived findings such as unresolved required loads or absent earlier @rpath candidates. Pure header parsing: nothing is executed, and absolute or system paths outside the analyzed root stay undetermined. Select roots or one architecture to narrow large bundles.",+ "Trace how dyld would resolve each Mach-O dylib load for the active Mach-O, or for every executable in the active .app bundle (the main app, XPC services, extensions, login items, helpers). Expands @executable_path, @loader_path, and @rpath through each process's LC_RPATH stack in dependents-first load order, and reports every candidate path with its outcome, the resolved image and digest, weak, re-export, upward, and lazy-load flags, including LC_LAZY_LOAD_DYLIB_INFO linkedit payloads, and derived findings such as unresolved required loads or absent earlier @rpath candidates. Pure header parsing: nothing is executed, and absolute or system paths outside the analyzed root stay undetermined. Select roots or one architecture to narrow large bundles.",dylibResolutionInputSchema,),] as const satisfies readonly ToolContract[];diff --git a/src/domain/apple/dylibResolution.test.ts b/src/domain/apple/dylibResolution.test.tsindex 88a9e379f..f1c44572b 100644--- a/src/domain/apple/dylibResolution.test.ts+++ b/src/domain/apple/dylibResolution.test.ts@@ -840,6 +840,93 @@ describe("lazily loaded dependencies", () => {"lazy-load-unresolved",]);});++ it("resolves LC_LAZY_LOAD_DYLIB_INFO without traversing it", async () => {+ const trace = await traceDylibLoading(+ memoryView({+ [MAIN]: executable({+ rpaths: ["@executable_path/../Frameworks"],+ dependencies: [+ dependency("@rpath/libinfo.dylib", {+ command: "LC_LAZY_LOAD_DYLIB_INFO",+ encoding: "lazy_load_dylib_info",+ weak: true,+ current_version: null,+ compatibility_version: null,+ }),+ dependency("@rpath/libmissing.dylib", {+ command: "LC_LAZY_LOAD_DYLIB_INFO",+ encoding: "lazy_load_dylib_info",+ current_version: null,+ compatibility_version: null,+ }),+ ],+ }),+ "Contents/Frameworks/libinfo.dylib": parsed(+ slice({ dependencies: [dependency("@rpath/libdeep.dylib")] }),+ ),+ }),+ { roots: [MAIN] },+ );+ expect(trace.edges.map(({ install_name: name }) => name)).toEqual([+ "@rpath/libinfo.dylib",+ "@rpath/libmissing.dylib",+ ]);+ expect(trace.edges[0]).toMatchObject({+ command: "LC_LAZY_LOAD_DYLIB_INFO",+ encoding: "lazy_load_dylib_info",+ weak: true,+ current_version: null,+ compatibility_version: null,+ resolution: {+ status: "resolved",+ image: "Contents/Frameworks/libinfo.dylib",+ },+ });+ expect(trace.coverage.status).toBe("complete");+ expect(trace.findings.map(({ kind }) => kind)).toEqual([+ "lazy-load-unresolved",+ ]);+ expect(trace.findings[0]?.explanation).toContain(+ "which would fail unless the image is supplied elsewhere",+ );+ });++ it("treats a missing may-be-missing lazy image as optional", async () => {+ const trace = await traceDylibLoading(+ memoryView({+ [MAIN]: executable({+ rpaths: ["@executable_path/../Frameworks"],+ dependencies: [+ dependency("@rpath/liboptional.dylib", {+ command: "LC_LAZY_LOAD_DYLIB_INFO",+ encoding: "lazy_load_dylib_info",+ weak: true,+ current_version: null,+ compatibility_version: null,+ }),+ dependency("@rpath/libweaklazy.dylib", {+ command: "LC_LAZY_LOAD_DYLIB",+ weak: true,+ }),+ ],+ }),+ }),+ { roots: [MAIN] },+ );+ expect(trace.findings).toMatchObject([+ {+ kind: "lazy-load-unresolved",+ explanation:+ "No candidate for lazily loaded weak dependency @rpath/liboptional.dylib exists in the analyzed root; dyld loads it on first use and continues if it is absent.",+ },+ {+ kind: "lazy-load-unresolved",+ explanation:+ "No candidate for lazily loaded weak dependency @rpath/libweaklazy.dylib exists in the analyzed root; dyld loads it on first use and continues if it is absent.",+ },+ ]);+ });});describe("conditional loads", () => {diff --git a/src/domain/apple/dylibResolution.ts b/src/domain/apple/dylibResolution.tsindex 630fdd694..7e4697639 100644--- a/src/domain/apple/dylibResolution.ts+++ b/src/domain/apple/dylibResolution.ts@@ -17,6 +17,7 @@ import {import {DYLIB_RESOLUTION_LIMITATIONS,deriveFindings,+ isLazyLoadCommand,type TracedRootSlice,} from "./dylibResolutionFindings.js";@@ -46,19 +47,28 @@ const dependencyCommandSchema = z.enum(["LC_LOAD_WEAK_DYLIB","LC_REEXPORT_DYLIB","LC_LAZY_LOAD_DYLIB",+ "LC_LAZY_LOAD_DYLIB_INFO","LC_LOAD_UPWARD_DYLIB",]);const dependencySchema = z.strictObject({command: dependencyCommandSchema,- encoding: z.enum(["dylib_command", "dylib_use_command"]),+ encoding: z.enum([+ "dylib_command",+ "dylib_use_command",+ "lazy_load_dylib_info",+ ]),install_name: z.string(),weak: z.boolean(),upward: z.boolean(),reexport: z.boolean(),delayed_init: z.boolean(),- current_version: z.string(),- compatibility_version: z.string(),+ /**+ * Null for `lazy_load_dylib_info`: that payload has no version fields.+ * Classic dylib commands still carry both versions.+ */+ current_version: z.string().nullable(),+ compatibility_version: z.string().nullable(),});/** Observed dylib-loading facts of one Mach-O slice. */@@ -528,8 +538,8 @@ const traceProcess = async (for (const dependency of current.slice.dependencies) {const edge = await resolveDependency(dependency, loader, context);edges.push(edge);- // dyld loads LC_LAZY_LOAD_DYLIB images on first use, not at launch.- if (dependency.command === "LC_LAZY_LOAD_DYLIB") continue;+ // dyld loads lazy images on first use, not at launch.+ if (isLazyLoadCommand(dependency.command)) continue;const image = edge.resolution.image;if (image === null || context.loaded.has(image)) continue;const facts = context.images.get(image);diff --git a/src/domain/apple/dylibResolutionFindings.ts b/src/domain/apple/dylibResolutionFindings.tsindex eac488143..7783ab91d 100644--- a/src/domain/apple/dylibResolutionFindings.ts+++ b/src/domain/apple/dylibResolutionFindings.ts@@ -1,9 +1,16 @@import type {DylibEdge as Edge,DylibFinding as Finding,+ MachoDependency,MachoSlice,} from "./dylibResolution.js";+/** Both lazy encodings load on first use and are not process-launch dependencies. */+export const isLazyLoadCommand = (+ command: MachoDependency["command"],+): boolean =>+ command === "LC_LAZY_LOAD_DYLIB" || command === "LC_LAZY_LOAD_DYLIB_INFO";+/** One traced process root with the exact slice it was traced from. */export interface TracedRootSlice {readonly image: string;@@ -62,16 +69,17 @@ const unresolvedFinding = (edge: Edge, index: number): Finding => {image: edge.loader,basis: "derived",} as const;- const missing = `No candidate for ${edge.command === "LC_LAZY_LOAD_DYLIB" ? "lazily loaded " : edge.weak ? "weak dependency " : ""}${edge.install_name} exists in the analyzed root`;+ const lazy = isLazyLoadCommand(edge.command);+ const missing = `No candidate for ${dependencyPhrase(edge, lazy)} exists in the analyzed root`;// Below a conditional fallback, every consequence applies only if it loads.const when = edge.loader_conditional? `. ${edge.loader} loads only conditionally; if it loads, `: "; ";- if (edge.command === "LC_LAZY_LOAD_DYLIB")+ if (lazy)return {...base,kind: "lazy-load-unresolved",- explanation: `${missing}${when}dyld loads it on first use, which would fail unless the image is supplied elsewhere.`,+ explanation: `${missing}${when}${lazyConsequence(edge.weak)}`,};return edge.weak? {@@ -86,8 +94,26 @@ const unresolvedFinding = (edge: Edge, index: number): Finding => {};};+/** Name the dependency the way the finding's consequence treats it. */+const dependencyPhrase = (edge: Edge, lazy: boolean): string => {+ if (lazy && edge.weak)+ return `lazily loaded weak dependency ${edge.install_name}`;+ if (lazy) return `lazily loaded ${edge.install_name}`;+ if (edge.weak) return `weak dependency ${edge.install_name}`;+ return edge.install_name;+};++/**+ * A may-be-missing lazy image is optional. Every other lazy image fails+ * when first use cannot find it.+ */+const lazyConsequence = (weak: boolean): string =>+ weak+ ? "dyld loads it on first use and continues if it is absent."+ : "dyld loads it on first use, which would fail unless the image is supplied elsewhere.";+export const DYLIB_RESOLUTION_LIMITATIONS = [- "LC_LAZY_LOAD_DYLIB dependencies are resolved but not traversed, because dyld loads them only on first use.",+ "LC_LAZY_LOAD_DYLIB and LC_LAZY_LOAD_DYLIB_INFO 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.","Absolute install names and rpaths are outside the analyzed root and are not evaluated, including /System and /usr/lib libraries that the dyld shared cache usually provides.","Leaf and relative install names depend on dyld fallback paths, DYLD_* variables, and the working directory; they are undetermined.",diff --git a/src/native/NativeMachoInspection.test.ts b/src/native/NativeMachoInspection.test.tsindex 0a31b24e4..32c9222a3 100644--- a/src/native/NativeMachoInspection.test.ts+++ b/src/native/NativeMachoInspection.test.ts@@ -178,6 +178,59 @@ describe("Mach-O inspection container format", () => {if (!result.ok) throw result.error;expect(result.value.result).toMatchObject({ format: expected });});++ it("does not call a lazy-info payload dependency exhaustive", async () => {+ const runner = new NativeFixtureRunner({+ lipo: "Non-fat file: /fixture/app is architecture: arm64\n",+ "otool:-h": withOtoolMachHeader(+ [+ "Load command 0",+ " cmd LC_LOAD_DYLIB",+ " cmdsize 56",+ " name /usr/lib/libSystem.B.dylib (offset 24)",+ " time stamp 2 Thu Jan 1 00:00:02 1970",+ " current version 1.0.0",+ "compatibility version 1.0.0",+ "Load command 1",+ " cmd LC_LAZY_LOAD_DYLIB_INFO",+ " cmdsize 16",+ " dataoff 49304",+ " datasize 56",+ ].join("\n"),+ ),+ });+ const result = await inspectNativeMacho({+ target: nativeMachoTarget("/fixture/app"),+ run: (tool, args) => runner.run(tool, args),+ invocation: (captured) => ({+ tool: captured.tool,+ command: [captured.executable, ...captured.arguments],+ tool_version: captured.toolVersion,+ version_reason: captured.versionReason,+ executable_sha256: captured.executableSha256,+ exit: { code: captured.exitCode, signal: captured.signal },+ stdout_bytes: captured.stdoutBytes,+ stderr_bytes: captured.stderrBytes,+ }),+ });+ if (!result.ok) throw result.error;+ expect(result.value.result).toMatchObject({+ load_commands: {+ items: [{ kind: "LC_LOAD_DYLIB" }, { kind: "LC_LAZY_LOAD_DYLIB_INFO" }],+ },+ dependencies: {+ exhaustive: false,+ total: null,+ items: [+ {+ path: "/usr/lib/libSystem.B.dylib",+ kind: "LC_LOAD_DYLIB",+ },+ ],+ limitations: [expect.stringContaining("1 LC_LAZY_LOAD_DYLIB_INFO")],+ },+ });+ });});describe("Mach-O UUID reconciliation", () => {diff --git a/src/native/NativeMachoInspection.ts b/src/native/NativeMachoInspection.tsindex 1151342d7..6cccf0bfa 100644--- a/src/native/NativeMachoInspection.ts+++ b/src/native/NativeMachoInspection.ts@@ -324,7 +324,11 @@ const normalizeMacho = (architectures: covered(architectures, true),build_metadata: covered(load.builds, true),load_commands: covered(load.commands, true),- dependencies: covered(load.dependencies, true),+ dependencies: covered(+ load.dependencies,+ load.omittedDependencyCommands.length === 0,+ dependencyPayloadLimitations(load.omittedDependencyCommands),+ ),imports: covered(imports, false, ["dyld_info textual imports may omit chained or toolchain-unsupported metadata.",...(missingImportsUuid ? [missingUuidLimitation("imports")] : []),@@ -405,6 +409,21 @@ const parseNmExports = (output: string) =>source: "nm",}));+const dependencyPayloadLimitations = (+ commands: readonly string[],+): string[] => {+ if (commands.length === 0) return [];+ const counts = new Map<string, number>();+ for (const command of commands)+ counts.set(command, (counts.get(command) ?? 0) + 1);+ const described = [...counts].map(+ ([command, count]) => `${count} ${command}`,+ );+ return [+ `Dependency inventory omits ${described.join(", ")} because otool -l does not print that command's linkedit install name. trace_dylib_resolution reads the payload.`,+ ];+};+const covered = <Value>(items: readonly Value[],exhaustive: boolean,diff --git a/src/native/parsers/otool.ts b/src/native/parsers/otool.tsindex bf135bf9d..6da69d6a0 100644--- a/src/native/parsers/otool.ts+++ b/src/native/parsers/otool.ts@@ -41,6 +41,7 @@ interface ParsedLoadCommands {}>;uuid: string | null;readonly flags: Set<string>;+ readonly omittedDependencyCommands: string[];}const DYLIB_COMMANDS = new Set([@@ -51,6 +52,11 @@ const DYLIB_COMMANDS = new Set(["LC_LAZY_LOAD_DYLIB","LC_LOAD_UPWARD_DYLIB",]);+/**+ * Dependency commands whose install name is not in the otool command text.+ * `LC_LAZY_LOAD_DYLIB_INFO` stores it in a linkedit payload.+ */+const PAYLOAD_DEPENDENCY_COMMANDS = new Set(["LC_LAZY_LOAD_DYLIB_INFO"]);const DYLIB_FIELDS = ["cmd",@@ -142,6 +148,7 @@ export const parseOtoolLoadCommands = (raw: string) => {commands: state.commands,segments: state.segments,dependencies: state.dependencies,+ omittedDependencyCommands: state.omittedDependencyCommands,entrypoints: state.entrypoints,builds: state.builds,};@@ -265,6 +272,7 @@ const createLoadCommandState = (builds: [],uuid: null,flags: new Set(headerFlags ?? []),+ omittedDependencyCommands: [],});const parseLoadCommand = (block: string, state: ParsedLoadCommands): void => {@@ -290,6 +298,8 @@ const parseLoadCommand = (block: string, state: ParsedLoadCommands): void => {collectEntrypoint(kind, fields, state);collectBuild(kind, block, fields, state);collectDependency(kind, fields, state);+ if (PAYLOAD_DEPENDENCY_COMMANDS.has(kind))+ state.omittedDependencyCommands.push(kind);collectSegment(kind, block, fields, state);};