Release Privacy Tools 0.1.0

2026-09-01 02:39:44 +02:00
commit bfd6422149
79 changed files with 13485 additions and 0 deletions
@@ -0,0 +1,207 @@
+// @vitest-environment node
+
+import { unzipSync } from "fflate";
+import { describe, expect, it } from "vitest";
+
+import {
+  buildSanitizationReport,
+  createBatchArchive,
+  createBatchReport,
+  serializeReport,
+  type ImageScanResult,
+  type MetadataFinding,
+} from "../../src/privacy";
+
+const sensitive: MetadataFinding = {
+  id: "gps-1",
+  category: "location",
+  risk: "sensitive",
+  source: "EXIF",
+  label: "GPS Latitude",
+  value: "48.1 N",
+};
+
+describe("sanitization and batch reports", () => {
+  it("marks a complete sensitive-free output verified and records removals", () => {
+    const source = result({ findings: [sensitive] });
+    const output = result({ id: "clean", name: "clean.png", findings: [] });
+    const report = buildSanitizationReport(
+      source,
+      output,
+      "clean.png",
+      "image/png",
+      20,
+      comparison(true),
+    );
+    expect(report.status).toBe("verified");
+    expect(report.removed).toEqual([sensitive]);
+    expect(report.preserved).toEqual([]);
+    expect(report.orientationNormalized).toBe(true);
+    expect(report.disclaimer).toMatch(/not an anonymity guarantee/iu);
+  });
+
+  it("fails a partial or sensitive output re-scan", () => {
+    const source = result({ findings: [sensitive] });
+    const output = result({
+      id: "clean",
+      findings: [sensitive],
+      coverage: {
+        projectScanner: "partial",
+        secondaryScanner: "complete",
+        notes: [],
+      },
+    });
+    const report = buildSanitizationReport(
+      source,
+      output,
+      "clean.png",
+      "image/png",
+      20,
+      comparison(false),
+    );
+    expect(report.status).toBe("failed");
+    expect(report.preserved).toEqual([sensitive]);
+    expect(report.incomplete).not.toEqual([]);
+  });
+
+  it("reports an unknown browser-generated output chunk as a warning", () => {
+    const source = result();
+    const output = result({
+      id: "clean",
+      findings: [
+        {
+          id: "private-1",
+          category: "unknown",
+          risk: "context",
+          source: "PNG",
+          label: "Private chunk deBG",
+          value: "16 bytes",
+        },
+      ],
+      blocks: [{ kind: "deBG", offset: 40, length: 16 }],
+    });
+    const report = buildSanitizationReport(
+      source,
+      output,
+      "clean.png",
+      "image/png",
+      20,
+      comparison(true),
+    );
+    expect(report.status).toBe("warning");
+    expect(report.generated).toHaveLength(1);
+    expect(report.incomplete.join(" ")).toContain("deBG");
+  });
+
+  it("fails a changed decoded sample for lossless PNG", () => {
+    const report = buildSanitizationReport(
+      result(),
+      result({ id: "clean" }),
+      "clean.png",
+      "image/png",
+      20,
+      comparison(false),
+    );
+    expect(report.status).toBe("failed");
+    expect(report.incomplete.join(" ")).toMatch(/pixel sample/iu);
+  });
+
+  it("produces deterministic, safe JSON and a stored batch ZIP", async () => {
+    const source = result({ name: "../private.png", findings: [sensitive] });
+    const output = result({ id: "clean", name: "private.clean.png" });
+    const report = buildSanitizationReport(
+      source,
+      output,
+      "../same.png",
+      "image/png",
+      3,
+      comparison(true),
+    );
+    const assets = [
+      { blob: new Blob([Uint8Array.of(1, 2, 3)]), report },
+      { blob: new Blob([Uint8Array.of(4, 5, 6)]), report },
+    ];
+    const generatedAt = "2026-09-01T00:00:00.000Z";
+    const batch = createBatchReport([source], assets, generatedAt);
+    const json = serializeReport(batch);
+    expect(JSON.parse(json)).toMatchObject({ schemaVersion: 1, generatedAt });
+    expect(json).toContain("report may itself contain sensitive");
+
+    const archive = await createBatchArchive([source], assets, generatedAt);
+    const entries = unzipSync(new Uint8Array(await archive.arrayBuffer()));
+    expect(Object.keys(entries).sort()).toEqual([
+      "images/_same-2.png",
+      "images/_same.png",
+      "privacy-tools-report.json",
+    ]);
+    expect(
+      JSON.parse(
+        new TextDecoder().decode(entries["privacy-tools-report.json"]),
+      ),
+    ).toMatchObject({ schemaVersion: 1, generatedAt });
+  });
+
+  it("bounds archive entry count before reading output blobs", async () => {
+    const source = result();
+    const output = result({ id: "clean" });
+    const report = buildSanitizationReport(
+      source,
+      output,
+      "clean.png",
+      "image/png",
+      1,
+      comparison(true),
+    );
+    const asset = { blob: new Blob([Uint8Array.of(0)]), report };
+    await expect(
+      createBatchArchive(
+        [source],
+        Array.from({ length: 101 }, () => asset),
+      ),
+    ).rejects.toThrow(/Archive image count/iu);
+  });
+});
+
+function comparison(identical: boolean) {
+  return {
+    method: "oriented-256px-sample" as const,
+    sourceDigest: "source-sample",
+    outputDigest: identical ? "source-sample" : "output-sample",
+    identical,
+    note: "test comparison",
+  };
+}
+
+function result(overrides: Partial<ImageScanResult> = {}): ImageScanResult {
+  return {
+    id: "source",
+    name: "source.png",
+    safeName: "source.png",
+    size: 100,
+    lastModified: 0,
+    sha256: "a".repeat(64),
+    identity: {
+      claimedType: "image/png",
+      extension: "png",
+      detectedKind: "png",
+      detectedType: "image/png",
+      typeMatch: "match",
+    },
+    width: 2,
+    height: 1,
+    orientation: 1,
+    animated: false,
+    multiImage: false,
+    deepSupported: true,
+    cleanable: true,
+    findings: [],
+    blocks: [],
+    warnings: [],
+    coverage: {
+      projectScanner: "complete",
+      secondaryScanner: "complete",
+      notes: [],
+    },
+    ...overrides,
+  };
+}