From 29a3f3c8ddfb3ee4bd76112609be161f205a1e09 Mon Sep 17 00:00:00 2001 From: ShuaixinHuang <1836656514@qq.com> Date: Thu, 19 Nov 2026 23:32:03 +0800 Subject: [PATCH] fix(artifacts): preserve ASAR unpacked companion path identity (#11749) * fix(artifacts): preserve ASAR unpacked path identity * test(artifacts): use the current ASAR resource entry * test(artifacts): assert ASAR unavailable content facts --------- Co-authored-by: ShuaixinHuang <197200901+ShuaixinHuang@users.noreply.github.com> --- src/artifacts/AsarArtifactReader.ts | 9 ++ .../asarUnpackedPathIdentity.test.ts | 96 +++++++++++++++++++ 2 files changed, 105 insertions(+) create mode 100644 tests/boundary/filesystem/asarUnpackedPathIdentity.test.ts diff --git a/src/artifacts/AsarArtifactReader.ts b/src/artifacts/AsarArtifactReader.ts index 17d248a14a..c52fa58637 100644 --- a/src/artifacts/AsarArtifactReader.ts +++ b/src/artifacts/AsarArtifactReader.ts @@ -1,4 +1,5 @@ import { appendCallerPath } from "../filesystem/callerPath.js"; +import { localPathStringSchema } from "../domain/localPath.js"; import type { AsarHeaderAdmission } from "../config/asarHeaderAdmission.js"; import { artifactIntegrityDetails } from "../domain/artifactIntegrity.js"; import { constants, createWriteStream, type Stats } from "node:fs"; @@ -497,6 +498,14 @@ export class AsarArtifactReader implements ArtifactReader { entry: ArtifactEntry, signal?: AbortSignal, ): Promise { + // Header names retain UTF-16 identity; filesystem encoding may replace + // unpaired surrogates and select a different companion. Packed members + // need no filesystem name and remain readable under their original names. + if (!localPathStringSchema.safeParse(entry.adapterKey).success) + throw new ArtifactEntryContentUnavailable( + `ASAR unpacked member path cannot be represented without replacement: ${JSON.stringify(entry.path)}`, + "ASAR unpacked member path cannot be represented without replacement on the local filesystem; companion bytes were not read and no content hash or child artifact was produced.", + ); const unpackedRoot = `${this.options.selectedPath ?? this.path}.unpacked`; let handle: SharedAsarFileHandle | undefined; try { diff --git a/tests/boundary/filesystem/asarUnpackedPathIdentity.test.ts b/tests/boundary/filesystem/asarUnpackedPathIdentity.test.ts new file mode 100644 index 0000000000..4114c27457 --- /dev/null +++ b/tests/boundary/filesystem/asarUnpackedPathIdentity.test.ts @@ -0,0 +1,96 @@ +import { createHash } from "node:crypto"; +import { mkdir, writeFile } from "node:fs/promises"; +import { join } from "node:path"; +import { expect, it } from "vitest"; +import { AsarArtifactReader } from "../../../src/artifacts/AsarArtifactReader.js"; +import { + ArtifactEntryContentUnavailable, + type ArtifactEntry, +} from "../../../src/resources/index.js"; +import { inventoryArtifact } from "../../fixtures/artifactInventory.js"; +import { asarHeaderBytes } from "../../fixtures/asarHeader.js"; +import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js"; + +it.each([ + "\ud800.js", + "\udc00.js", + "dir\ud800/member.js", + "dir\udc00/member.js", +])("does not read a replacement-character companion for %j", async (name) => { + const root = await createTestTempDirectory("rea-asar-unpacked-identity-"); + const archive = join(root, "app.asar"); + const packed = Buffer.from("exact packed member"); + const companion = Buffer.from("different filesystem identity"); + const replacement = name.replace(/[\ud800-\udfff]/gu, "\ufffd"); + let member: object = { size: companion.length, unpacked: true }; + for (const part of name.split("/").reverse()) + member = { files: { [part]: member } }; + const files = (member as { files: Record }).files; + let replacementMember: object = { size: companion.length, unpacked: true }; + for (const part of replacement.split("/").reverse()) + replacementMember = { files: { [part]: replacementMember } }; + Object.assign(files, (replacementMember as { files: object }).files); + files.packed = { + files: { [name.split("/").at(-1)!]: { size: packed.length, offset: "0" } }, + }; + files["🐍.js"] = { size: companion.length, unpacked: true }; + await writeFile( + archive, + Buffer.concat([asarHeaderBytes(JSON.stringify({ files })), packed]), + ); + await mkdir( + join(`${archive}.unpacked`, ...replacement.split("/").slice(0, -1)), + { recursive: true }, + ); + await writeFile(join(`${archive}.unpacked`, replacement), companion); + await writeFile(join(`${archive}.unpacked`, "🐍.js"), companion); + const reader = new AsarArtifactReader(archive); + try { + const entries: ArtifactEntry[] = []; + for await (const entry of reader.entries()) entries.push(entry); + const malformed = entries.find((entry) => entry.path === name)!; + expect(malformed.unpacked).toBe(true); + await expect(reader.open(malformed)).rejects.toBeInstanceOf( + ArtifactEntryContentUnavailable, + ); + const packedEntry = entries.find( + (entry) => entry.path.startsWith("packed/") && entry.kind === "file", + )!; + const read = async (entry: typeof packedEntry) => { + const chunks: Buffer[] = []; + for await (const chunk of await reader.open(entry)) + chunks.push(Buffer.from(chunk as Uint8Array)); + return Buffer.concat(chunks); + }; + expect((await read(packedEntry)).equals(packed)).toBe(true); + expect( + (await read(entries.find((entry) => entry.path === replacement)!)).equals( + companion, + ), + ).toBe(true); + expect( + (await read(entries.find((entry) => entry.path === "🐍.js")!)).equals( + companion, + ), + ).toBe(true); + } finally { + await reader.close(); + } + const inventory = await inventoryArtifact(archive); + const occurrence = inventory.occurrences.find( + (entry) => entry.logical_path === name, + )!; + expect(occurrence).toMatchObject({ hash_status: "unavailable" }); + expect(occurrence.artifact_id).toBeNull(); + expect(occurrence.limitations.length).toBeGreaterThan(0); + const packedOccurrence = inventory.occurrences.find( + (entry) => + entry.logical_path.startsWith("packed/") && + entry.hash_status === "verified", + )!; + expect( + inventory.nodes.find( + (node) => node.artifact_id === packedOccurrence.artifact_id, + )?.sha256, + ).toBe(createHash("sha256").update(packed).digest("hex")); +});