perf(artifacts): stream ASAR members without full buffering (#962)

* fix(artifacts): stream ASAR members without full buffering

* fix(artifacts): close unopened ASAR member streams

* fix(artifacts): preserve unpacked ASAR mismatch digests

* fix(artifacts): preserve ASAR read failures

* fix(artifacts): retain unpacked ASAR stat failures

* fix(artifacts): validate ASAR entry producer identity
This commit is contained in:
morluto
2026-10-07 23:57:05 +08:00
committed by GitHub
parent 58381eefa2
commit abd7a5ed09
4 changed files with 873 additions and 33 deletions
+269 -32
View File
@@ -1,17 +1,19 @@
import { createReadStream } from "node:fs";
import { sep } from "node:path";
import { constants, createReadStream, type Stats } from "node:fs";
import { lstat, open, realpath, type FileHandle } from "node:fs/promises";
import { isAbsolute, join, relative, sep } from "node:path";
import { Readable } from "node:stream";
import { extractFile, listPackage, statFile, uncache } from "@electron/asar";
import { getRawHeader, listPackage, statFile, uncache } from "@electron/asar";
import {
ArtifactReaderFailure,
type ArtifactEntry,
type ArtifactReader,
} from "./ArtifactReader.js";
import { closeAsarHandle, readValidatedAsarEntry } from "./AsarEntryStream.js";
/**
* Official Electron ASAR adapter. Individual files remain caller-bounded.
* Official Electron ASAR adapter with range-streamed member reads.
*
* An entry marked `unpacked` is metadata, not an integrity exemption: Electron
* stores its bytes beside the archive in `<archive>.unpacked`, and callers must
@@ -19,17 +21,33 @@ import {
*/
export class AsarArtifactReader implements ArtifactReader {
readonly format = "asar" as const;
#archiveSize: number | undefined;
#headerSize: number | undefined;
readonly #entries = new Map<string, AsarEntryState>();
constructor(private readonly path: string) {}
constructor(
private readonly path: string,
private readonly openUnpackedFile: OpenAsarUnpackedFile = open,
) {}
async *entries(signal?: AbortSignal): AsyncIterable<ArtifactEntry> {
let paths: string[];
try {
// ASAR caches headers by path even after the archive has been replaced.
this.#resetArchiveState();
this.#entries.clear();
uncache(this.path);
paths = listPackage(this.path, { isPack: false }).sort((left, right) =>
left.localeCompare(right, "en"),
);
this.#headerSize = getRawHeader(this.path).headerSize;
const archiveMetadata = await lstat(this.path);
if (!archiveMetadata.isFile() || archiveMetadata.isSymbolicLink())
throw new ArtifactReaderFailure(
"format",
"ASAR container is not a regular file",
);
this.#archiveSize = archiveMetadata.size;
} catch (cause: unknown) {
throw asarFailure(this.path, "inventory", cause);
}
@@ -56,7 +74,7 @@ export class AsarArtifactReader implements ArtifactReader {
: "link" in metadata
? "symlink"
: "file";
yield {
const entry: ArtifactEntry = {
path,
kind,
declaredSize: "size" in metadata ? metadata.size : null,
@@ -74,42 +92,121 @@ export class AsarArtifactReader implements ArtifactReader {
limitations:
kind === "symlink"
? ["ASAR symlink target was not followed or disclosed."]
: [
"Official ASAR extraction buffers each individually bounded file.",
],
: [],
adapterKey: providerPath,
};
if (kind === "file" && isAsarFileMetadata(metadata))
this.#entries.set(providerPath, {
metadata,
entry: copyArtifactEntry(entry),
});
yield entry;
}
}
open(entry: ArtifactEntry, signal?: AbortSignal): Promise<Readable> {
async open(entry: ArtifactEntry, signal?: AbortSignal): Promise<Readable> {
abortIfNeeded(signal);
if (entry.kind !== "file")
return Promise.reject(
new ArtifactReaderFailure("format", "ASAR entry is not a regular file"),
const state = this.#entries.get(entry.adapterKey);
if (state === undefined && entry.kind !== "file")
throw new ArtifactReaderFailure(
"format",
"ASAR entry is not a regular file",
);
if (state === undefined)
throw new ArtifactReaderFailure(
"integrity",
`ASAR entry was not produced by this reader: ${entry.path}`,
);
if (!sameArtifactEntry(entry, state.entry))
throw new ArtifactReaderFailure(
"integrity",
`ASAR entry metadata changed since inventory: ${state.entry.path}`,
);
const { metadata } = state;
const producedEntry = state.entry;
if (producedEntry.unpacked) {
const handle = await this.#openUnpackedEntry(producedEntry);
try {
const observed = await handle.stat();
abortIfNeeded(signal);
if (!observed.isFile())
throw new ArtifactReaderFailure(
"path",
`ASAR unpacked entry is not a regular file: ${producedEntry.path}`,
);
} catch (cause: unknown) {
await handle.close().catch(() => undefined);
throw asarFailure(this.path, `read ${producedEntry.path}`, cause);
}
const source = handle.createReadStream({
start: 0,
autoClose: true,
});
return readValidatedAsarEntry(
source,
undefined,
producedEntry.path,
this.path,
signal,
);
}
const archiveSize = this.#archiveSize;
const headerSize = this.#headerSize;
const offset =
metadata.offset === undefined
? undefined
: parseArchiveOffset(metadata.offset);
const start =
offset === undefined || headerSize === undefined
? undefined
: 8 + headerSize + offset;
if (
archiveSize === undefined ||
start === undefined ||
!Number.isSafeInteger(start) ||
metadata.size < 0 ||
!Number.isSafeInteger(metadata.size) ||
start > archiveSize ||
metadata.size > archiveSize - start
)
throw new ArtifactReaderFailure(
"format",
`ASAR entry range is outside its container: ${producedEntry.path}`,
);
let handle: FileHandle | undefined;
try {
return Promise.resolve(
Readable.from(extractFile(this.path, entry.adapterKey, false)),
const openedHandle = await open(
this.path,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
);
handle = openedHandle;
const observed = await openedHandle.stat();
abortIfNeeded(signal);
if (!observed.isFile() || observed.size !== archiveSize)
throw new ArtifactReaderFailure(
"integrity",
`ASAR container changed before read: ${producedEntry.path}`,
);
if (metadata.size === 0) {
await closeAsarHandle(() => openedHandle.close(), signal);
handle = undefined;
return Readable.from([]);
}
const source = openedHandle.createReadStream({
start,
end: start + metadata.size - 1,
autoClose: true,
});
return readValidatedAsarEntry(
source,
metadata.size,
producedEntry.path,
this.path,
signal,
);
} catch (cause: unknown) {
if (entry.unpacked && isMissingFile(cause))
return Promise.reject(
new ArtifactReaderFailure(
"unavailable",
`ASAR unpacked entry bytes are unavailable: ${entry.path}`,
{ cause },
{
logicalPath: entry.path,
declaredSha256: entry.declaredSha256,
calculatedSha256: null,
unpacked: true,
},
),
);
return Promise.reject(
asarFailure(this.path, `read ${entry.path}`, cause),
);
await handle?.close().catch(() => undefined);
throw asarFailure(this.path, `read ${producedEntry.path}`, cause);
}
}
@@ -121,14 +218,154 @@ export class AsarArtifactReader implements ArtifactReader {
close(): Promise<void> {
uncache(this.path);
this.#resetArchiveState();
this.#entries.clear();
return Promise.resolve();
}
provenance(): readonly [] {
return [];
}
async #openUnpackedEntry(entry: ArtifactEntry): Promise<UnpackedFileHandle> {
const unpackedRoot = `${this.path}.unpacked`;
try {
const rootMetadata = await lstat(unpackedRoot);
if (!rootMetadata.isDirectory() || rootMetadata.isSymbolicLink())
throw new ArtifactReaderFailure(
"path",
"ASAR unpacked companion is not a regular directory",
);
const canonicalRoot = await realpath(unpackedRoot);
const candidate = join(unpackedRoot, entry.adapterKey);
const canonical = await realpath(candidate);
const relativePath = relative(canonicalRoot, canonical);
if (
relativePath === ".." ||
relativePath.startsWith(`..${sep}`) ||
isAbsolute(relativePath)
)
throw new ArtifactReaderFailure(
"path",
`ASAR unpacked entry escaped its companion directory: ${entry.path}`,
);
const pathMetadata = await lstat(candidate);
if (!pathMetadata.isFile() || pathMetadata.isSymbolicLink())
throw new ArtifactReaderFailure(
"path",
`ASAR unpacked entry is not a regular file: ${entry.path}`,
);
const handle = await this.openUnpackedFile(
canonical,
constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK,
);
const openedMetadata = await handle
.stat()
.catch(async (cause: unknown) => {
await handle.close().catch(() => undefined);
throw cause;
});
if (
!openedMetadata.isFile() ||
openedMetadata.dev !== pathMetadata.dev ||
openedMetadata.ino !== pathMetadata.ino
) {
await handle.close();
throw new ArtifactReaderFailure(
"integrity",
`ASAR unpacked entry changed before read: ${entry.path}`,
{},
{
logicalPath: entry.path,
declaredSha256: entry.declaredSha256,
calculatedSha256: null,
unpacked: true,
},
);
}
return handle;
} catch (cause: unknown) {
if (cause instanceof ArtifactReaderFailure) throw cause;
if (entry.unpacked && isMissingFile(cause))
throw new ArtifactReaderFailure(
"unavailable",
`ASAR unpacked entry bytes are unavailable: ${entry.path}`,
{ cause },
{
logicalPath: entry.path,
declaredSha256: entry.declaredSha256,
calculatedSha256: null,
unpacked: true,
},
);
throw asarFailure(this.path, `read ${entry.path}`, cause);
}
}
#resetArchiveState(): void {
this.#archiveSize = undefined;
this.#headerSize = undefined;
}
}
type AsarFileMetadata = Extract<ReturnType<typeof statFile>, { size: number }>;
type AsarEntryState = {
readonly metadata: AsarFileMetadata;
readonly entry: ArtifactEntry;
};
type UnpackedFileHandle = {
stat(): Promise<Stats>;
close(): Promise<void>;
createReadStream: FileHandle["createReadStream"];
};
type OpenAsarUnpackedFile = (
path: string,
flags: number,
) => Promise<UnpackedFileHandle>;
const copyArtifactEntry = (entry: ArtifactEntry): ArtifactEntry => ({
...entry,
limitations: [...entry.limitations],
...(entry.sourceIdentity === undefined
? {}
: { sourceIdentity: { ...entry.sourceIdentity } }),
});
const sameArtifactEntry = (
entry: ArtifactEntry,
produced: ArtifactEntry,
): boolean =>
entry.path === produced.path &&
entry.kind === produced.kind &&
entry.declaredSize === produced.declaredSize &&
entry.compressedSize === produced.compressedSize &&
entry.executable === produced.executable &&
entry.encrypted === produced.encrypted &&
entry.byteOffset === produced.byteOffset &&
entry.declaredSha256 === produced.declaredSha256 &&
entry.unpacked === produced.unpacked &&
entry.adapterKey === produced.adapterKey &&
entry.limitations.length === produced.limitations.length &&
entry.limitations.every(
(limitation, index) => limitation === produced.limitations[index],
) &&
entry.sourceIdentity?.device === produced.sourceIdentity?.device &&
entry.sourceIdentity?.inode === produced.sourceIdentity?.inode;
const isAsarFileMetadata = (
metadata: ReturnType<typeof statFile>,
): metadata is AsarFileMetadata =>
"size" in metadata &&
typeof metadata.size === "number" &&
!("files" in metadata) &&
!("link" in metadata);
const parseArchiveOffset = (value: string): number | undefined => {
if (!/^(?:0|[1-9][0-9]*)$/u.test(value)) return undefined;
const offset = Number(value);
return Number.isSafeInteger(offset) ? offset : undefined;
};
const abortIfNeeded = (signal?: AbortSignal): void => {
if (signal?.aborted === true)
throw new ArtifactReaderFailure("cancelled", "ASAR operation cancelled");
+111
View File
@@ -0,0 +1,111 @@
import { Readable } from "node:stream";
import { ArtifactReaderFailure } from "./ArtifactReader.js";
/** Close an ASAR file handle before honoring cancellation of an empty member. */
export const closeAsarHandle = async (
close: () => Promise<void>,
signal?: AbortSignal,
): Promise<void> => {
await close();
abortIfNeeded(signal);
};
/** Validate and contextualize bytes read from one ASAR member source. */
export const readValidatedAsarEntry = (
source: Readable,
expectedBytes: number | undefined,
entryPath: string,
archivePath: string,
signal?: AbortSignal,
): Readable => {
const output = Readable.from(
(async function* () {
let observedBytes = 0;
const iterator = source[Symbol.asyncIterator]();
try {
while (true) {
abortIfNeeded(signal);
const next = await iterator.next();
if (next.done) break;
const chunk: unknown = next.value;
if (!Buffer.isBuffer(chunk) && !(chunk instanceof Uint8Array))
throw new ArtifactReaderFailure(
"format",
`ASAR entry did not return bytes: ${entryPath}`,
);
observedBytes += Buffer.isBuffer(chunk)
? chunk.length
: chunk.byteLength;
if (expectedBytes !== undefined && observedBytes > expectedBytes)
throw new ArtifactReaderFailure(
"integrity",
`ASAR entry exceeded its declared size: ${entryPath}`,
);
yield chunk;
}
if (expectedBytes !== undefined && observedBytes !== expectedBytes)
throw new ArtifactReaderFailure(
"integrity",
`ASAR entry size disagrees with its header: ${entryPath}`,
);
} catch (cause: unknown) {
throw asarFailure(archivePath, `read ${entryPath}`, cause);
} finally {
try {
await iterator.return?.();
} catch {
// Preserve the read failure; source destruction below owns cleanup.
}
if (!source.destroyed) source.destroy();
}
})(),
);
const closeSource = (): void => {
signal?.removeEventListener("abort", onAbort);
if (!source.destroyed) source.destroy();
};
const onAbort = (): void => {
closeSource();
output.destroy(
new ArtifactReaderFailure("cancelled", "ASAR operation cancelled"),
);
};
output.once("close", closeSource);
signal?.addEventListener("abort", onAbort, { once: true });
if (signal?.aborted === true) onAbort();
return output;
};
const abortIfNeeded = (signal?: AbortSignal): void => {
if (signal?.aborted === true)
throw new ArtifactReaderFailure("cancelled", "ASAR operation cancelled");
};
const asarFailure = (
path: string,
operation: string,
cause: unknown,
): ArtifactReaderFailure => {
if (cause instanceof ArtifactReaderFailure) return cause;
if (isFilesystemFailure(cause))
return new ArtifactReaderFailure(
"io",
`Could not ${operation} ASAR at ${path}: ${cause.message}`,
{ cause },
);
return new ArtifactReaderFailure(
"format",
`Malformed ASAR during ${operation}: ${path}`,
{ cause },
);
};
const isFilesystemFailure = (
cause: unknown,
): cause is NodeJS.ErrnoException & Error =>
cause instanceof Error &&
"errno" in cause &&
typeof cause.errno === "number" &&
"syscall" in cause &&
typeof cause.syscall === "string";
@@ -0,0 +1,474 @@
import { createHash } from "node:crypto";
import { fstatSync, type Stats } from "node:fs";
import {
open as openFile,
lstat,
mkdir,
rm,
readdir,
writeFile,
truncate,
} from "node:fs/promises";
import { join } from "node:path";
import { Readable } from "node:stream";
import { buffer } from "node:stream/consumers";
import { createPackageWithOptions } from "@electron/asar";
import { describe, expect, it } from "vitest";
import { scanArtifactInventory } from "../../../src/application/ArtifactInventory.js";
import { AsarArtifactReader } from "../../../src/artifacts/AsarArtifactReader.js";
import {
closeAsarHandle,
readValidatedAsarEntry,
} from "../../../src/artifacts/AsarEntryStream.js";
import { hashReadable } from "../../../src/artifacts/ArtifactHash.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
const memberBytes = 64 * 1024 * 1024;
const expectedSha256 = (): string => {
const hash = createHash("sha256");
const zeros = Buffer.alloc(64 * 1024);
for (let written = 0; written < memberBytes; written += zeros.length)
hash.update(zeros);
return hash.digest("hex");
};
const descriptorDirectory =
process.platform === "darwin" ? "/dev/fd" : "/proc/self/fd";
const matchingDescriptorCount = async (identity: Stats): Promise<number> => {
const descriptors = await readdir(descriptorDirectory);
return descriptors.filter((descriptor) => {
if (!/^\d+$/u.test(descriptor)) return false;
try {
const observed = fstatSync(Number(descriptor));
return observed.dev === identity.dev && observed.ino === identity.ino;
} catch {
return false;
}
}).length;
};
const waitForNoMatchingDescriptor = async (identity: Stats): Promise<void> => {
for (let attempt = 0; attempt < 100; attempt += 1) {
if ((await matchingDescriptorCount(identity)) === 0) return;
await new Promise((resolve) => setTimeout(resolve, 10));
}
expect(await matchingDescriptorCount(identity)).toBe(0);
};
describe("ASAR entry streaming", () => {
it.skipIf(process.platform === "win32")(
"closes a packed member handle when its unopened output stream is destroyed",
async () => {
const root = await createTestTempDirectory(
"rea-asar-destroy-before-read-",
);
const source = join(root, "source");
const archive = join(root, "fixture.asar");
await mkdir(source);
await writeFile(join(source, "small.js"), "module.exports = 1;\n");
await createPackageWithOptions(source, archive, {});
const identity = await lstat(archive);
const probe = await openFile(archive, "r");
expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0);
await probe.close();
await waitForNoMatchingDescriptor(identity);
const reader = new AsarArtifactReader(archive);
try {
const entries = [];
for await (const entry of reader.entries()) {
entries.push(entry);
}
const entry = entries.find(({ path }) => path === "small.js");
if (entry === undefined) throw new Error("Expected packed ASAR member");
expect(await matchingDescriptorCount(identity)).toBe(0);
const output = await reader.open(entry);
expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0);
const closed = new Promise<void>((resolve) =>
output.once("close", resolve),
);
output.destroy();
await closed;
await waitForNoMatchingDescriptor(identity);
} finally {
await reader.close();
}
},
);
it.skipIf(process.platform === "win32")(
"closes a packed member handle when cancellation arrives during open",
async () => {
const root = await createTestTempDirectory("rea-asar-abort-during-stat-");
const source = join(root, "source");
const archive = join(root, "fixture.asar");
await mkdir(source);
await writeFile(join(source, "small.js"), "module.exports = 1;\n");
await createPackageWithOptions(source, archive, {});
const identity = await lstat(archive);
const reader = new AsarArtifactReader(archive);
try {
const entries = [];
for await (const entry of reader.entries()) entries.push(entry);
const entry = entries.find(({ path }) => path === "small.js");
if (entry === undefined) throw new Error("Expected packed ASAR member");
const controller = new AbortController();
const opening = reader.open(entry, controller.signal);
controller.abort();
await expect(opening).rejects.toMatchObject({ reason: "cancelled" });
await waitForNoMatchingDescriptor(identity);
} finally {
await reader.close();
}
},
);
it("classifies a missing packed member container as an I/O failure", async () => {
const root = await createTestTempDirectory("rea-asar-missing-member-");
const source = join(root, "source");
const archive = join(root, "fixture.asar");
await mkdir(source);
await writeFile(join(source, "small.js"), "module.exports = 1;\n");
await createPackageWithOptions(source, archive, {});
const reader = new AsarArtifactReader(archive);
try {
const entries = [];
for await (const entry of reader.entries()) entries.push(entry);
const entry = entries.find(({ path }) => path === "small.js");
if (entry === undefined) throw new Error("Expected packed ASAR member");
await rm(archive);
await expect(reader.open(entry)).rejects.toMatchObject({
reason: "io",
cause: { code: "ENOENT" },
});
} finally {
await reader.close();
}
});
});
describe("ASAR entry producer identity", () => {
it.each([false, true] as const)(
"rejects a copied entry with a changed unpacked flag for unpacked=%s",
async (unpacked) => {
const root = await createTestTempDirectory("rea-asar-entry-identity-");
const source = join(root, "source");
const archive = join(root, "fixture.asar");
await mkdir(source);
await writeFile(join(source, "small.js"), "module.exports = 1;\n");
await createPackageWithOptions(
source,
archive,
unpacked ? { unpack: "small.js" } : {},
);
const selectedPath = unpacked
? join(`${archive}.unpacked`, "small.js")
: archive;
const identity = await lstat(selectedPath);
const reader = new AsarArtifactReader(archive);
try {
const entries = [];
for await (const entry of reader.entries()) entries.push(entry);
const entry = entries.find(({ path }) => path === "small.js");
if (entry === undefined) throw new Error("Expected ASAR file entry");
expect(entry.unpacked).toBe(unpacked);
expect(await matchingDescriptorCount(identity)).toBe(0);
if (entry.declaredSize === null)
throw new Error("Expected ASAR file size metadata");
for (const changedEntry of [
{ ...entry, unpacked: !entry.unpacked },
{ ...entry, path: `stale/${entry.path}` },
{ ...entry, declaredSize: entry.declaredSize + 1 },
])
await expect(reader.open(changedEntry)).rejects.toMatchObject({
name: "ArtifactReaderFailure",
reason: "integrity",
message: expect.stringContaining(
`ASAR entry metadata changed since inventory: ${entry.path}`,
),
});
await waitForNoMatchingDescriptor(identity);
} finally {
await reader.close();
}
},
);
it.each([
["packed to unpacked", false],
["unpacked to packed", true],
] as const)(
"rejects a retained %s entry after a new entries pass",
async (_transition, wasUnpacked) => {
const root = await createTestTempDirectory("rea-asar-entry-refresh-");
const source = join(root, "source");
const archive = join(root, "fixture.asar");
const memberContents = "module.exports = 1;\n";
await mkdir(source);
await writeFile(join(source, "small.js"), memberContents);
const reader = new AsarArtifactReader(archive);
try {
await createPackageWithOptions(
source,
archive,
wasUnpacked ? { unpack: "small.js" } : {},
);
const firstEntries = [];
for await (const entry of reader.entries()) firstEntries.push(entry);
const retained = firstEntries.find(({ path }) => path === "small.js");
if (retained === undefined)
throw new Error("Expected first ASAR file entry");
const copiedRetained = {
...retained,
limitations: [...retained.limitations],
};
await createPackageWithOptions(
source,
archive,
wasUnpacked ? {} : { unpack: "small.js" },
);
const currentEntries = [];
for await (const entry of reader.entries()) currentEntries.push(entry);
const current = currentEntries.find(({ path }) => path === "small.js");
if (current === undefined)
throw new Error("Expected refreshed ASAR file entry");
expect(current.unpacked).toBe(!wasUnpacked);
await expect(reader.open(copiedRetained)).rejects.toMatchObject({
name: "ArtifactReaderFailure",
reason: "integrity",
message: expect.stringContaining(
"ASAR entry metadata changed since inventory",
),
});
expect((await buffer(await reader.open(current))).toString()).toBe(
memberContents,
);
} finally {
await reader.close();
}
},
);
});
describe("ASAR read failures", () => {
it.skipIf(process.platform === "win32")(
"checks cancellation after closing an empty member handle",
async () => {
const root = await createTestTempDirectory("rea-asar-empty-close-");
const archive = join(root, "container.asar");
await writeFile(archive, "container bytes");
const identity = await lstat(archive);
const handle = await openFile(archive, "r");
try {
expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0);
const controller = new AbortController();
await expect(
closeAsarHandle(async () => {
await handle.close();
controller.abort();
}, controller.signal),
).rejects.toMatchObject({ reason: "cancelled" });
await waitForNoMatchingDescriptor(identity);
} finally {
await handle.close().catch(() => undefined);
}
},
);
it.skipIf(process.platform === "win32")(
"closes the opened unpacked file and retains ASAR context when handle stat fails",
async () => {
const root = await createTestTempDirectory("rea-asar-unpacked-stat-");
const source = join(root, "source");
const archive = join(root, "fixture.asar");
await mkdir(source);
await writeFile(join(source, "small.js"), "module.exports = 1;\n");
await createPackageWithOptions(source, archive, { unpack: "small.js" });
const unpackedPath = join(`${archive}.unpacked`, "small.js");
const identity = await lstat(unpackedPath);
const ioError = Object.assign(new Error("device stat failed"), {
code: "EIO",
errno: -5,
syscall: "fstat",
});
let closeCount = 0;
const reader = new AsarArtifactReader(archive, async (path, flags) => {
const handle = await openFile(path, flags);
expect(await matchingDescriptorCount(identity)).toBeGreaterThan(0);
let statCount = 0;
return {
async stat() {
statCount += 1;
if (statCount === 2) throw ioError;
return handle.stat();
},
async close() {
closeCount += 1;
await handle.close();
},
createReadStream: (options) => handle.createReadStream(options),
};
});
try {
const entries = [];
for await (const entry of reader.entries()) entries.push(entry);
const entry = entries.find(({ path }) => path === "small.js");
if (entry === undefined)
throw new Error("Expected unpacked ASAR member");
await expect(reader.open(entry)).rejects.toMatchObject({
name: "ArtifactReaderFailure",
reason: "io",
message: expect.stringContaining(
`Could not read ${entry.path} ASAR at ${archive}: device stat failed`,
),
cause: { code: "EIO", errno: -5, syscall: "fstat" },
});
expect(closeCount).toBe(1);
await waitForNoMatchingDescriptor(identity);
} finally {
await reader.close();
}
},
);
it.each(["missing", "replaced"] as const)(
"validates the container before returning a zero-length member when it is %s",
async (change) => {
const root = await createTestTempDirectory("rea-asar-empty-member-");
const source = join(root, "source");
const archive = join(root, "fixture.asar");
await mkdir(source);
await writeFile(join(source, "empty.js"), "");
await createPackageWithOptions(source, archive, {});
const reader = new AsarArtifactReader(archive);
try {
const entries = [];
for await (const entry of reader.entries()) entries.push(entry);
const entry = entries.find(({ path }) => path === "empty.js");
if (entry === undefined) throw new Error("Expected empty ASAR member");
if (change === "missing") await rm(archive);
else await writeFile(archive, "replacement container");
await expect(reader.open(entry)).rejects.toMatchObject(
change === "missing"
? { reason: "io", cause: { code: "ENOENT" } }
: { reason: "integrity" },
);
} finally {
await reader.close();
}
},
);
it("preserves filesystem errors raised while consuming a member stream", async () => {
const ioError = Object.assign(new Error("device read failed"), {
code: "EIO",
errno: -5,
syscall: "read",
});
const source = Readable.from(
(async function* () {
yield Buffer.from("partial");
throw ioError;
})(),
);
const output = readValidatedAsarEntry(
source,
undefined,
"nested/member.bin",
"/tmp/source.asar",
);
await expect(async () => {
for await (const _chunk of output) {
// Consume through the source failure.
}
}).rejects.toMatchObject({
name: "ArtifactReaderFailure",
reason: "io",
message: expect.stringContaining(
"Could not read nested/member.bin ASAR at /tmp/source.asar",
),
cause: { code: "EIO", errno: -5, syscall: "read" },
});
});
});
describe("ASAR entry streaming", () => {
it("reports the observed digest when an unpacked member changes size", async () => {
const root = await createTestTempDirectory(
"rea-asar-unpacked-size-change-",
);
const source = join(root, "source");
const archive = join(root, "fixture.asar");
const original = join(source, "small.js");
const changed = "changed();\n";
await mkdir(source);
await writeFile(original, "module.exports = 1;\n");
await createPackageWithOptions(source, archive, { unpack: "small.js" });
await writeFile(join(`${archive}.unpacked`, "small.js"), changed);
await expect(scanArtifactInventory(archive)).rejects.toMatchObject({
reason: "integrity",
details: {
logicalPath: "small.js",
calculatedSha256: createHash("sha256").update(changed).digest("hex"),
unpacked: true,
},
});
});
it.each([
["packed", {}],
["unpacked", { unpack: "large.bin" }],
] as const)(
"opens a %s member without allocating its full contents",
async (_kind, options) => {
const root = await createTestTempDirectory("rea-asar-streaming-");
const source = join(root, "source");
const archive = join(root, "fixture.asar");
const member = join(source, "large.bin");
await mkdir(source);
await writeFile(member, Buffer.alloc(0));
await truncate(member, memberBytes);
await createPackageWithOptions(source, archive, options);
const reader = new AsarArtifactReader(archive);
try {
const entries = [];
for await (const entry of reader.entries()) entries.push(entry);
const entry = entries.find(({ path }) => path === "large.bin");
if (entry === undefined) throw new Error("Expected large ASAR member");
const before = process.memoryUsage().arrayBuffers;
const stream = await reader.open(entry);
const afterOpen = process.memoryUsage().arrayBuffers;
const observed = await hashReadable(stream);
const allocation = afterOpen - before;
expect(allocation).toBeLessThan(memberBytes / 2);
expect(observed).toMatchObject({
sha256: expectedSha256(),
bytes: memberBytes,
});
} finally {
await reader.close();
}
},
120_000,
);
});
@@ -1,4 +1,4 @@
import { mkdir, rm, writeFile } from "node:fs/promises";
import { lstat, mkdir, rm, writeFile } from "node:fs/promises";
import { join } from "node:path";
import { createPackage } from "@electron/asar";
@@ -86,6 +86,24 @@ describe("JavaScript artifact ingestion content identities", () => {
}
});
it("rejects a same-size ASAR replacement against the inventoried root digest", async () => {
const { source, archive } = await fixture();
const snapshot = await scanArtifactInventory(archive);
const original = await lstat(archive);
await writeFile(join(source, "main.js"), "module.exports = 43;\n");
await createPackage(source, archive);
expect((await lstat(archive)).size).toBe(original.size);
const reader = new AsarArtifactReader(archive);
try {
await expect(
readJavaScriptArtifactFiles(reader, snapshot),
).rejects.toMatchObject({ reason: "integrity" });
} finally {
await reader.close();
}
});
it("preserves typed cancellation when the direct ASAR filesystem stream aborts", async () => {
const { archive } = await fixture();
const snapshot = await scanArtifactInventory(archive);