Files
rea/src/application/apple/DyldSharedCacheService.ts
T
Kaoru0822andClaude Opus 5.5 858aa9fd7d fix(apple): hash the dyld cache through the handle its header was read from
main_file_sha256 now comes from the main cache file's open handle, so a path
replaced during inspection cannot attach another file's digest to the parsed
header and image list.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-07 13:35:58 +00:00

176 lines
5.7 KiB
TypeScript

import { resolve } from "node:path";
import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
import { DyldSharedCache } from "../../artifacts/apple/DyldSharedCacheReader.js";
import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
import type { AnalysisError } from "../../domain/analysisErrorBase.js";
import { ArtifactOperationError } from "../../domain/artifactOperationError.js";
import {
DYLD_SHARED_CACHE_LIMITATIONS,
dyldSharedCacheResultSchema,
inspectDyldSharedCacheInputSchema,
type DyldSharedCacheResult,
type InspectedCacheImage,
} from "../../domain/apple/dyldSharedCache.js";
import { createEvidence, type Evidence } from "../../domain/evidence.js";
import { jsonValueSchema } from "../../domain/jsonValue.js";
import { err, ok, type Result } from "../../domain/result.js";
import { APPLE_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
const OPERATION = "inspect_dyld_shared_cache" as const;
/** Read one requested image through the cache, keeping absence explicit. */
const inspectImage = async (
cache: DyldSharedCache,
path: string,
): Promise<InspectedCacheImage> => {
const image = cache.find(path);
const base = { path, reason: null, slices: [] };
if (image === undefined)
return { ...base, status: "absent", address: null, file: null };
const address = `0x${image.address.toString(16)}`;
const read = await cache.imageFacts(path);
if (read === undefined)
return {
...base,
status: "unmapped",
address,
file: null,
reason: "The image address lies in no readable cache mapping.",
};
const { facts, file } = read;
if (facts.status === "parsed")
return {
...base,
status: "parsed",
address,
file,
slices: [...facts.slices],
};
return {
...base,
status: facts.status === "not-mach-o" ? "malformed" : facts.status,
address,
file,
reason:
facts.status === "not-mach-o"
? "The cached image is not a Mach-O image."
: facts.reason,
};
};
const failure = (cause: unknown): AnalysisError => {
if (cause instanceof ArtifactReaderFailure)
return new ArtifactOperationError(
OPERATION,
cause.reason,
undefined,
cause.message,
);
if (cause instanceof Error && "code" in cause) {
if (cause.code === "ENOENT" || cause.code === "ENOTDIR")
return new ArtifactOperationError(
OPERATION,
"path",
undefined,
"The cache file does not exist.",
);
if (cause.code === "EACCES" || cause.code === "EPERM")
return new ArtifactOperationError(
OPERATION,
"unavailable",
undefined,
"The cache file is not readable.",
);
}
if (cause instanceof Error && cause.name === "AbortError")
return new ArtifactOperationError(OPERATION, "cancelled");
return new ArtifactOperationError(OPERATION, "io");
};
/** Inspect a dyld shared cache file set selected by path. */
export const inspectDyldSharedCache = async (
rawInput: unknown,
signal?: AbortSignal,
): Promise<Result<DyldSharedCacheResult, AnalysisError>> => {
const parsed = inspectDyldSharedCacheInputSchema.safeParse(rawInput);
if (!parsed.success)
return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
const cachePath = resolve(parsed.data.cache_path);
let cache: DyldSharedCache | undefined;
try {
cache = await DyldSharedCache.open(cachePath, signal);
const inspected: InspectedCacheImage[] = [];
for (const path of parsed.data.images ?? []) {
signal?.throwIfAborted();
inspected.push(await inspectImage(cache, path));
}
const unreadable = cache.header.subcaches
.filter(({ status }) => status !== "present")
.map(({ suffix }) => suffix);
return ok(
dyldSharedCacheResultSchema.parse({
cache_path: cachePath,
// The header and image list were read through this same handle.
main_file_sha256: await cache.mainSha256(signal),
...cache.header,
images_total: cache.images.length,
images: cache.images.map(({ path, address }) => ({
path,
address: `0x${address.toString(16)}`,
})),
inspected_images: inspected,
coverage: {
status: unreadable.length === 0 ? "complete" : "partial",
unreadable_subcaches: unreadable,
},
limitations: [
...DYLD_SHARED_CACHE_LIMITATIONS,
...(unreadable.length === 0
? []
: [
`Subcaches ${unreadable.join(", ")} are missing or do not match the main cache UUID; images mapped there are unmapped.`,
]),
],
}),
);
} catch (cause: unknown) {
return err(failure(cause));
} finally {
await cache?.close();
}
};
/** Inspect a dyld shared cache and wrap the observation as Evidence. */
export const inspectDyldSharedCacheEvidence = async (
rawInput: unknown,
signal?: AbortSignal,
): Promise<Result<Evidence, AnalysisError>> => {
const inspected = await inspectDyldSharedCache(rawInput, signal);
if (!inspected.ok) return inspected;
const result = inspected.value;
return ok(
createEvidence(
{
path: result.cache_path,
sha256: result.main_file_sha256,
format: "file",
},
APPLE_APPLICATION_PROVIDER,
{
operation: OPERATION,
parameters: {
cache_path: result.cache_path,
images: result.inspected_images.map(({ path }) => path),
},
result: jsonValueSchema.parse(result),
rawResult: null,
confidence: "observed",
authority: "shipped-artifact",
environment: null,
limitations: result.limitations,
},
),
);
};