Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(artifacts): reject Windows stream paths before extraction

morluto573598c63246
diff --git a/src/artifacts/SafeOutputTree.ts b/src/artifacts/SafeOutputTree.ts
index a20afb7f9..4bb4cfe1a 100644
--- a/src/artifacts/SafeOutputTree.ts
+++ b/src/artifacts/SafeOutputTree.ts
@@ -191,7 +191,7 @@ export class SafeOutputTree {
"format",
`Invalid expected extraction size for ${relativePath}`,
);
- const path = normalizeArtifactPath(relativePath);
+ const path = normalizeDestinationPath(relativePath, this.platform);
this.#registry.add(path, "file");
const lineage = await this.#prepareParent(path);
const parent = lineage.at(-1);
@@ -569,6 +569,19 @@ const writeAll = async (
}
};
+const normalizeDestinationPath = (
+ relativePath: string,
+ platform: NodeJS.Platform,
+): string => {
+ const path = normalizeArtifactPath(relativePath);
+ if (platform === "win32" && path.includes(":"))
+ throw new ArtifactReaderFailure(
+ "path",
+ `Windows destination cannot materialize artifact path as a regular file: ${path}; ':' denotes alternate data stream syntax.`,
+ );
+ return path;
+};
+
const abortIfNeeded = (signal?: AbortSignal): void => {
if (signal?.aborted === true)
throw new ArtifactReaderFailure(
diff --git a/src/domain/analysisErrorPresentation.ts b/src/domain/analysisErrorPresentation.ts
index b7f4629dd..3153cfd84 100644
--- a/src/domain/analysisErrorPresentation.ts
+++ b/src/domain/analysisErrorPresentation.ts
@@ -345,7 +345,11 @@ const artifactMessage = ({
return "Artifact operation was cancelled. Start it again when ready.";
if (reason === "limit")
return "Artifact is too large to process safely. Narrow the requested path or use a smaller artifact.";
- if (reason === "path") return artifactPathMessage(detail);
+ if (reason === "path")
+ return (
+ detail ??
+ "Artifact contains a conflicting internal path. Inspect the reported path before retrying."
+ );
if (reason === "unavailable" && details?.unpacked === true)
return `ASAR unpacked companion bytes are unavailable for ${details.logicalPath}. Select the archive in place with its .unpacked directory beside it, then retry.`;
if (reason === "unavailable")
@@ -361,23 +365,6 @@ const artifactMessage = ({
return "Artifact could not be read or written. Check file access and try again.";
};
-const artifactPathMessage = (detail: string | undefined): string => {
- // Kept in step with DESTINATION_CASE_COLLISION_PREFIX. Domain does not import
- // the artifact adapter that produces the detail.
- if (
- detail !== undefined &&
- detail.startsWith("Destination filesystem cannot store both ")
- )
- return detail;
- if (
- detail !== undefined &&
- (detail.startsWith("Artifact path is absolute or unsafe:") ||
- detail.startsWith("Artifact path is not normalized:"))
- )
- return "Artifact contains an unsafe internal path. Inspect the reported path and correct the artifact before retrying.";
- return "Artifact contains a conflicting internal path. Inspect the reported path before retrying.";
-};
-
const evidenceFileMessage = ({
operation,
reason,
diff --git a/tests/boundary/filesystem/safeOutputTree.test.ts b/tests/boundary/filesystem/safeOutputTree.test.ts
index 0f9976522..f67704456 100644
--- a/tests/boundary/filesystem/safeOutputTree.test.ts
+++ b/tests/boundary/filesystem/safeOutputTree.test.ts
@@ -456,3 +456,37 @@ describe("safe artifact output tree", () => {
);
});
});
+
+describe("safe artifact output Windows stream paths", () => {
+ it.each([
+ "hello.txt:hidden",
+ "nested/hello.txt::$DATA",
+ "folder:stream/file.txt",
+ ])("refuses Windows stream syntax before creating %s", async (path) => {
+ const parent = await createTestTempDirectory("rea-safe-output-stream-");
+ const output = join(parent, "published");
+ const tree = await SafeOutputTree.create(output, "win32");
+ const bytes = Buffer.from("regular file content");
+ const source = Readable.from(bytes);
+ try {
+ await expect(
+ tree.write(path, source, {
+ sha256: createHash("sha256").update(bytes).digest("hex"),
+ bytes: bytes.byteLength,
+ }),
+ ).rejects.toMatchObject({
+ reason: "path",
+ message: `Windows destination cannot materialize artifact path as a regular file: ${path}; ':' denotes alternate data stream syntax.`,
+ });
+ expect(source.destroyed).toBe(true);
+ expect(await readdir(output)).toEqual([]);
+ } finally {
+ expect(await tree.rollback()).toEqual({
+ status: "complete",
+ residualPaths: [],
+ });
+ }
+ await expect(access(output)).rejects.toMatchObject({ code: "ENOENT" });
+ expect(await readdir(parent)).toEqual([]);
+ });
+});
diff --git a/tests/boundary/providers/native/artifactProvider.archiveSafety.test.ts b/tests/boundary/providers/native/artifactProvider.archiveSafety.test.ts
index 8e8ff883e..e0978e379 100644
--- a/tests/boundary/providers/native/artifactProvider.archiveSafety.test.ts
+++ b/tests/boundary/providers/native/artifactProvider.archiveSafety.test.ts
@@ -183,6 +183,54 @@ it("extracts case-distinct names only when the destination can preserve them", a
expect(await readFile(join(output, "Main.js"), "utf8")).toBe("upper");
expect(await readFile(join(output, "main.js"), "utf8")).toBe("lower");
});
+
+it("preserves colon names in inventory and refuses Windows stream materialization", async () => {
+ const root = await createTestTempDirectory("rea-artifact-stream-");
+ const path = join(root, "fixture.zip");
+ const writer = new ZipWriter(new Uint8ArrayWriter());
+ await writer.add("0-ordinary.txt", new TextReader("ordinary content"));
+ await writer.add("hello.txt:hidden", new TextReader("secret payload"));
+ await writeFile(path, await writer.close());
+ const parsed = await parseBinaryTarget(path);
+ if (!parsed.ok) throw parsed.error;
+ const result = await inventory(parsed.value);
+ expect(result.occurrences.map(({ logical_path }) => logical_path)).toContain(
+ "hello.txt:hidden",
+ );
+
+ const output = join(root, "output");
+ const extracted = await new ArtifactProvider(process.env)
+ .createClient(parsed.value)
+ .execute(
+ "extract_artifact",
+ artifactExtractionExecutionSchema.parse({ output_root: output }),
+ );
+ if (process.platform === "win32") {
+ if (extracted.ok) throw new Error("expected a Windows stream path refusal");
+ const detail =
+ "Windows destination cannot materialize artifact path as a regular file: hello.txt:hidden; ':' denotes alternate data stream syntax.";
+ expect(projectAnalysisError(extracted.error)).toMatchObject({
+ message: detail,
+ details: { operation: "extract_artifact", reason: "path", detail },
+ });
+ await expect(lstat(output)).rejects.toMatchObject({ code: "ENOENT" });
+ await expect(
+ readFile(join(output, "hello.txt:hidden")),
+ ).rejects.toMatchObject({ code: "ENOENT" });
+ return;
+ }
+ if (!extracted.ok) throw extracted.error;
+ expect(await readFile(join(output, "0-ordinary.txt"), "utf8")).toBe(
+ "ordinary content",
+ );
+ expect(await readFile(join(output, "hello.txt:hidden"), "utf8")).toBe(
+ "secret payload",
+ );
+ await expect(lstat(join(output, "hello.txt"))).rejects.toMatchObject({
+ code: "ENOENT",
+ });
+});
+
const inventory = async (targetValue: BinaryTarget) => {
const result = await new ArtifactProvider(process.env)
.createClient(targetValue)
diff --git a/tests/boundary/providers/native/artifactProvider.failureDetail.test.ts b/tests/boundary/providers/native/artifactProvider.failureDetail.test.ts
index e2b2fd385..e500d2c0c 100644
--- a/tests/boundary/providers/native/artifactProvider.failureDetail.test.ts
+++ b/tests/boundary/providers/native/artifactProvider.failureDetail.test.ts
@@ -53,8 +53,7 @@ it("reports an unsafe path as a hostile artifact path", async () => {
if (result.ok) throw new Error("expected the path constraint to fail");
expect(projectAnalysisError(result.error)).toMatchObject({
code: "artifact_operation_failed",
- message:
- "Artifact contains an unsafe internal path. Inspect the reported path and correct the artifact before retrying.",
+ message: 'Artifact path is absolute or unsafe: "a\\\\b.js"',
details: {
operation: "inventory_artifact",
reason: "path",
@@ -75,4 +74,11 @@ it("returns a destination case collision as the user-facing path message", () =>
message: detail,
details: { reason: "path", detail },
});
+
+ expect(
+ projectAnalysisError(new ArtifactOperationError("extract_artifact", "path"))
+ .message,
+ ).toBe(
+ "Artifact contains a conflicting internal path. Inspect the reported path before retrying.",
+ );
});