Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

refractor(locker):split-download-share-hooks

Aswin Asok2e3a432e80b5
diff --git a/web/apps/locker/src/services/download.ts b/web/apps/locker/src/services/download.ts
new file mode 100644
index 0000000000..8def4e4e7f
--- /dev/null
+++ b/web/apps/locker/src/services/download.ts
@@ -0,0 +1,205 @@
+import { fetchFile } from "ente-base/file-download";
+import { authenticatedRequestHeaders, ensureOk } from "ente-base/http";
+import log from "ente-base/log";
+import { customAPIOrigin } from "ente-base/origins";
+import { createStreamDecryptor, decryptBox } from "ente-locker-wasm";
+import { getEncryptedFileRecord, getLockerCacheSnapshot } from "./remote-cache";
+import { decryptCollectionKey } from "./remote-read";
+
+const DOWNLOAD_URL_REVOKE_DELAY_MS = 30_000;
+
+export const downloadLockerFile = async (
+ fileID: number,
+ fileName: string,
+ onProgress?: (progress: { loaded: number; total?: number }) => void,
+): Promise<void> => {
+ const fileRecord = getEncryptedFileRecord(fileID);
+ if (!fileRecord) {
+ log.error(`Locker download missing file record ${fileID}`);
+ throw new Error(`File ${fileID} not found in cache`);
+ }
+
+ log.info(
+ `Locker download start ${fileID}: hasObject=${fileRecord.hasObject} size=${fileRecord.fileSize ?? "unknown"}`,
+ );
+
+ const cacheSnapshot = getLockerCacheSnapshot();
+ const collectionRecord = cacheSnapshot.collections.get(
+ fileRecord.collectionID,
+ );
+ if (!collectionRecord) {
+ log.error(
+ `Locker download missing collection record ${fileID}: collectionID=${fileRecord.collectionID}`,
+ );
+ throw new Error(
+ `Collection ${fileRecord.collectionID} not found in cache`,
+ );
+ }
+
+ let fileKey: string;
+ try {
+ const collectionKey = await decryptCollectionKey(collectionRecord);
+ fileKey = await decryptBox(
+ {
+ encryptedData: fileRecord.encryptedKey,
+ nonce: fileRecord.keyDecryptionNonce,
+ },
+ collectionKey,
+ );
+ } catch (error) {
+ log.error(
+ `Locker download key preparation failed ${fileID}: collectionID=${fileRecord.collectionID}`,
+ error,
+ );
+ throw error;
+ }
+
+ const customOrigin = await customAPIOrigin();
+ const downloadSource = customOrigin ? "api" : "proxy";
+ let response: Response;
+ try {
+ if (customOrigin) {
+ response = await fetchFile(fileID, "file");
+ } else {
+ response = await fetch(`https://files.ente.com/?fileID=${fileID}`, {
+ headers: await authenticatedRequestHeaders(),
+ });
+ }
+ } catch (error) {
+ log.error(
+ `Locker download request failed ${fileID}: source=${downloadSource}`,
+ error,
+ );
+ throw error;
+ }
+ ensureOk(response);
+ log.info(
+ `Locker download response ${fileID}: source=${downloadSource} status=${response.status} redirected=${response.redirected} contentType=${response.headers.get("Content-Type") ?? "unknown"} contentLength=${response.headers.get("Content-Length") ?? "unknown"}`,
+ );
+
+ const body = response.body;
+ if (!body) {
+ log.error(
+ `Locker download empty response body ${fileID}: source=${downloadSource} status=${response.status}`,
+ );
+ throw new Error("Download response body is empty");
+ }
+
+ const reader = body.getReader();
+ const contentLength =
+ parseInt(response.headers.get("Content-Length") ?? "", 10) || 0;
+ let downloadedBytes = 0;
+
+ onProgress?.({
+ loaded: 0,
+ total: contentLength > 0 ? contentLength : undefined,
+ });
+
+ const streamDecryptor = await createStreamDecryptor(
+ fileRecord.fileDecryptionHeader,
+ fileKey,
+ );
+ let leftoverBytes = new Uint8Array();
+
+ const decryptedStream = new ReadableStream<Uint8Array>({
+ pull: async (controller) => {
+ let didEnqueue = false;
+ try {
+ do {
+ const { done, value } = await reader.read();
+ let data: Uint8Array;
+ if (done) {
+ data = leftoverBytes;
+ } else {
+ downloadedBytes += value.length;
+ onProgress?.({
+ loaded: downloadedBytes,
+ total:
+ contentLength > 0 ? contentLength : undefined,
+ });
+ data = new Uint8Array(
+ leftoverBytes.length + value.length,
+ );
+ data.set(leftoverBytes, 0);
+ data.set(value, leftoverBytes.length);
+ }
+
+ while (data.length >= streamDecryptor.decryptionChunkSize) {
+ const decryptedChunk = streamDecryptor.decryptChunk(
+ data.slice(0, streamDecryptor.decryptionChunkSize),
+ );
+ controller.enqueue(decryptedChunk);
+ didEnqueue = true;
+ data = data.slice(streamDecryptor.decryptionChunkSize);
+ }
+
+ if (done) {
+ if (data.length > 0) {
+ const decryptedChunk =
+ streamDecryptor.decryptChunk(data);
+ controller.enqueue(decryptedChunk);
+ }
+ if (!streamDecryptor.isFinalized()) {
+ throw new Error(
+ "Download stream truncated before final chunk",
+ );
+ }
+ onProgress?.({
+ loaded:
+ contentLength > 0
+ ? contentLength
+ : downloadedBytes,
+ total:
+ contentLength > 0 ? contentLength : undefined,
+ });
+ streamDecryptor.free();
+ controller.close();
+ didEnqueue = true;
+ } else {
+ leftoverBytes = new Uint8Array(data);
+ }
+ } while (!didEnqueue);
+ } catch (error) {
+ log.error(
+ `Locker download stream failed ${fileID}: source=${downloadSource} downloaded=${downloadedBytes} total=${contentLength > 0 ? contentLength : "unknown"} leftover=${leftoverBytes.length}`,
+ error,
+ );
+ streamDecryptor.free();
+ controller.error(error);
+ }
+ },
+ cancel: () => {
+ log.warn(
+ `Locker download stream cancelled ${fileID}: source=${downloadSource} downloaded=${downloadedBytes} total=${contentLength > 0 ? contentLength : "unknown"}`,
+ );
+ streamDecryptor.free();
+ void reader.cancel();
+ },
+ });
+
+ let decryptedData: Blob;
+ try {
+ decryptedData = await new Response(decryptedStream).blob();
+ } catch (error) {
+ log.error(
+ `Locker download blob assembly failed ${fileID}: source=${downloadSource} downloaded=${downloadedBytes} total=${contentLength > 0 ? contentLength : "unknown"}`,
+ error,
+ );
+ throw error;
+ }
+ log.info(
+ `Locker download decrypted ${fileID}: source=${downloadSource} downloaded=${downloadedBytes} blobSize=${decryptedData.size}`,
+ );
+ const url = URL.createObjectURL(decryptedData);
+ const anchor = document.createElement("a");
+ anchor.style.display = "none";
+ anchor.href = url;
+ anchor.download = fileName;
+ document.body.appendChild(anchor);
+ anchor.click();
+ log.info(
+ `Locker download triggered save ${fileID}: source=${downloadSource}`,
+ );
+ setTimeout(() => URL.revokeObjectURL(url), DOWNLOAD_URL_REVOKE_DELAY_MS);
+ anchor.remove();
+};
diff --git a/web/apps/locker/src/services/file-links.ts b/web/apps/locker/src/services/file-links.ts
new file mode 100644
index 0000000000..c81166ba98
--- /dev/null
+++ b/web/apps/locker/src/services/file-links.ts
@@ -0,0 +1,104 @@
+import { authenticatedRequestHeaders, ensureOk } from "ente-base/http";
+import { apiURL } from "ente-base/origins";
+import { openFileLinkSecret, prepareFileLink } from "ente-locker-wasm";
+import { z } from "zod";
+import { ensureAuthenticatedSession } from "./authenticated-session";
+import { getEncryptedFileRecord } from "./remote-cache";
+import { decryptFileKeyForRecord } from "./remote-read";
+
+const RemoteFileShareLink = z.object({
+ linkID: z.union([z.string(), z.number().transform(String)]),
+ url: z.string(),
+ ownerID: z.number(),
+ fileID: z.number(),
+ isDisabled: z.boolean().optional(),
+ validTill: z.number().nullish(),
+ deviceLimit: z.number().nullish(),
+ passwordEnabled: z.boolean(),
+ nonce: z.string().nullish(),
+ memLimit: z.number().nullish(),
+ opsLimit: z.number().nullish(),
+ enableDownload: z.boolean(),
+ createdAt: z.number(),
+ encryptedFileKey: z.string().nullish(),
+ encryptedFileKeyNonce: z.string().nullish(),
+ kdfNonce: z.string().nullish(),
+ kdfMemLimit: z.number().nullish(),
+ kdfOpsLimit: z.number().nullish(),
+ encryptedShareKey: z.string().nullish(),
+});
+
+interface LockerFileShareLink {
+ linkID: string;
+ url: string;
+ fileID?: number;
+ validTill?: number | null;
+ enableDownload?: boolean;
+ passwordEnabled?: boolean;
+}
+
+export const getOrCreateLockerFileShareLink = async (
+ fileID: number,
+): Promise<LockerFileShareLink> => {
+ const fileRecord = getEncryptedFileRecord(fileID);
+ if (!fileRecord) {
+ throw new Error(`File ${fileID} not found in cache`);
+ }
+
+ const fileKey = await decryptFileKeyForRecord(fileRecord);
+ const session = await ensureAuthenticatedSession();
+ const payload = await prepareFileLink(session, fileKey);
+
+ const res = await fetch(await apiURL("/files/share-url"), {
+ method: "POST",
+ headers: {
+ ...(await authenticatedRequestHeaders()),
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({ fileID, app: "locker", ...payload.metadata }),
+ });
+ ensureOk(res);
+
+ const link = RemoteFileShareLink.parse(await res.json());
+ const secret = link.encryptedShareKey
+ ? await openFileLinkSecret(session, link.encryptedShareKey)
+ : payload.secret;
+
+ return {
+ linkID: link.linkID,
+ url: `${link.url}#${secret}`,
+ fileID: link.fileID,
+ validTill: link.validTill,
+ enableDownload: link.enableDownload,
+ passwordEnabled: link.passwordEnabled,
+ };
+};
+
+export const deleteLockerFileShareLink = async (
+ fileID: number,
+ linkID?: string,
+): Promise<void> => {
+ const candidateIDs = [linkID, String(fileID)].filter(
+ (candidate, index, values): candidate is string =>
+ !!candidate && values.indexOf(candidate) === index,
+ );
+
+ let lastError: Error | undefined;
+ for (const candidateID of candidateIDs) {
+ const res = await fetch(
+ await apiURL(`/files/share-url/${candidateID}`),
+ { method: "DELETE", headers: await authenticatedRequestHeaders() },
+ );
+ if (res.ok) {
+ return;
+ }
+ lastError = new Error(
+ `Failed to delete link ${candidateID}: ${res.status} ${res.statusText}`,
+ );
+ if (candidateID !== String(fileID)) {
+ continue;
+ }
+ }
+
+ throw lastError ?? new Error("Failed to delete file share link");
+};
diff --git a/web/apps/locker/src/services/remote-read.ts b/web/apps/locker/src/services/remote-read.ts
index c7e1e886ee..a08d7339d1 100644
--- a/web/apps/locker/src/services/remote-read.ts
+++ b/web/apps/locker/src/services/remote-read.ts
@@ -3,12 +3,10 @@ import type {
LockerCollectionParticipant,
LockerItem,
} from "@/types";
-import { fetchFile } from "ente-base/file-download";
import { authenticatedRequestHeaders, ensureOk } from "ente-base/http";
import log from "ente-base/log";
-import { apiURL, customAPIOrigin } from "ente-base/origins";
+import { apiURL } from "ente-base/origins";
import {
- createStreamDecryptor,
decryptBox,
decryptBoxBytes,
decryptMetadataJSON,
@@ -38,7 +36,6 @@ import {
type EncryptedFileRecord,
type LockerCollectionPayload,
type LockerEncryptedCache,
- getEncryptedFileRecord,
getLockerCacheSnapshot,
replaceLockerCache,
setEncryptedFileRecord,
@@ -161,7 +158,6 @@ interface LockerPersistedState extends LockerHydratedState {
const COLLECTION_PAYLOAD_VERSION = 1;
const collectionTextDecoder = new TextDecoder();
-const DOWNLOAD_URL_REVOKE_DELAY_MS = 30_000;
const describeCryptoError = (error: unknown) =>
error instanceof Error ? error.message : String(error);
@@ -936,199 +932,3 @@ export const fetchLockerTrash = async (): Promise<LockerTrashData> => {
const state = await syncLockerState();
return { items: state.trashItems, lastUpdatedAt: state.trashLastUpdatedAt };
};
-
-export const downloadLockerFile = async (
- fileID: number,
- fileName: string,
- onProgress?: (progress: { loaded: number; total?: number }) => void,
-): Promise<void> => {
- const fileRecord = getEncryptedFileRecord(fileID);
- if (!fileRecord) {
- log.error(`Locker download missing file record ${fileID}`);
- throw new Error(`File ${fileID} not found in cache`);
- }
-
- log.info(
- `Locker download start ${fileID}: hasObject=${fileRecord.hasObject} size=${fileRecord.fileSize ?? "unknown"}`,
- );
-
- const cacheSnapshot = getLockerCacheSnapshot();
- const collectionRecord = cacheSnapshot.collections.get(
- fileRecord.collectionID,
- );
- if (!collectionRecord) {
- log.error(
- `Locker download missing collection record ${fileID}: collectionID=${fileRecord.collectionID}`,
- );
- throw new Error(
- `Collection ${fileRecord.collectionID} not found in cache`,
- );
- }
-
- let fileKey: string;
- try {
- const collectionKey = await decryptCollectionKey(collectionRecord);
- fileKey = await decryptBox(
- {
- encryptedData: fileRecord.encryptedKey,
- nonce: fileRecord.keyDecryptionNonce,
- },
- collectionKey,
- );
- } catch (error) {
- log.error(
- `Locker download key preparation failed ${fileID}: collectionID=${fileRecord.collectionID}`,
- error,
- );
- throw error;
- }
-
- const customOrigin = await customAPIOrigin();
- const downloadSource = customOrigin ? "api" : "proxy";
- let response: Response;
- try {
- if (customOrigin) {
- response = await fetchFile(fileID, "file");
- } else {
- response = await fetch(`https://files.ente.com/?fileID=${fileID}`, {
- headers: await authenticatedRequestHeaders(),
- });
- }
- } catch (error) {
- log.error(
- `Locker download request failed ${fileID}: source=${downloadSource}`,
- error,
- );
- throw error;
- }
- ensureOk(response);
- log.info(
- `Locker download response ${fileID}: source=${downloadSource} status=${response.status} redirected=${response.redirected} contentType=${response.headers.get("Content-Type") ?? "unknown"} contentLength=${response.headers.get("Content-Length") ?? "unknown"}`,
- );
-
- const body = response.body;
- if (!body) {
- log.error(
- `Locker download empty response body ${fileID}: source=${downloadSource} status=${response.status}`,
- );
- throw new Error("Download response body is empty");
- }
-
- const reader = body.getReader();
- const contentLength =
- parseInt(response.headers.get("Content-Length") ?? "", 10) || 0;
- let downloadedBytes = 0;
-
- onProgress?.({
- loaded: 0,
- total: contentLength > 0 ? contentLength : undefined,
- });
-
- const streamDecryptor = await createStreamDecryptor(
- fileRecord.fileDecryptionHeader,
- fileKey,
- );
- let leftoverBytes = new Uint8Array();
-
- const decryptedStream = new ReadableStream<Uint8Array>({
- pull: async (controller) => {
- let didEnqueue = false;
- try {
- do {
- const { done, value } = await reader.read();
- let data: Uint8Array;
- if (done) {
- data = leftoverBytes;
- } else {
- downloadedBytes += value.length;
- onProgress?.({
- loaded: downloadedBytes,
- total:
- contentLength > 0 ? contentLength : undefined,
- });
- data = new Uint8Array(
- leftoverBytes.length + value.length,
- );
- data.set(leftoverBytes, 0);
- data.set(value, leftoverBytes.length);
- }
-
- while (data.length >= streamDecryptor.decryptionChunkSize) {
- const decryptedChunk = streamDecryptor.decryptChunk(
- data.slice(0, streamDecryptor.decryptionChunkSize),
- );
- controller.enqueue(decryptedChunk);
- didEnqueue = true;
- data = data.slice(streamDecryptor.decryptionChunkSize);
- }
-
- if (done) {
- if (data.length > 0) {
- const decryptedChunk =
- streamDecryptor.decryptChunk(data);
- controller.enqueue(decryptedChunk);
- }
- if (!streamDecryptor.isFinalized()) {
- throw new Error(
- "Download stream truncated before final chunk",
- );
- }
- onProgress?.({
- loaded:
- contentLength > 0
- ? contentLength
- : downloadedBytes,
- total:
- contentLength > 0 ? contentLength : undefined,
- });
- streamDecryptor.free();
- controller.close();
- didEnqueue = true;
- } else {
- leftoverBytes = new Uint8Array(data);
- }
- } while (!didEnqueue);
- } catch (error) {
- log.error(
- `Locker download stream failed ${fileID}: source=${downloadSource} downloaded=${downloadedBytes} total=${contentLength > 0 ? contentLength : "unknown"} leftover=${leftoverBytes.length}`,
- error,
- );
- streamDecryptor.free();
- controller.error(error);
- }
- },
- cancel: () => {
- log.warn(
- `Locker download stream cancelled ${fileID}: source=${downloadSource} downloaded=${downloadedBytes} total=${contentLength > 0 ? contentLength : "unknown"}`,
- );
- streamDecryptor.free();
- void reader.cancel();
- },
- });
-
- let decryptedData: Blob;
- try {
- decryptedData = await new Response(decryptedStream).blob();
- } catch (error) {
- log.error(
- `Locker download blob assembly failed ${fileID}: source=${downloadSource} downloaded=${downloadedBytes} total=${contentLength > 0 ? contentLength : "unknown"}`,
- error,
- );
- throw error;
- }
- log.info(
- `Locker download decrypted ${fileID}: source=${downloadSource} downloaded=${downloadedBytes} blobSize=${decryptedData.size}`,
- );
- const url = URL.createObjectURL(decryptedData);
- const anchor = document.createElement("a");
- anchor.style.display = "none";
- anchor.href = url;
- anchor.download = fileName;
- document.body.appendChild(anchor);
- anchor.click();
- log.info(
- `Locker download triggered save ${fileID}: source=${downloadSource}`,
- );
- setTimeout(() => URL.revokeObjectURL(url), DOWNLOAD_URL_REVOKE_DELAY_MS);
- anchor.remove();
-};
diff --git a/web/apps/locker/src/services/remote.ts b/web/apps/locker/src/services/remote.ts
index 298724b156..a84b02d04e 100644
--- a/web/apps/locker/src/services/remote.ts
+++ b/web/apps/locker/src/services/remote.ts
@@ -9,12 +9,8 @@ import {
encryptBlob,
encryptBox,
generateKey,
- openFileLinkSecret,
- prepareFileLink,
stringToB64,
} from "ente-locker-wasm";
-import { z } from "zod";
-import { ensureAuthenticatedSession } from "./authenticated-session";
import {
findCollectionByType,
getCollectionIDsForFile,
@@ -34,8 +30,6 @@ import {
} from "./remote-collections";
import {
decryptCollectionKey,
- decryptFileKeyForRecord,
- downloadLockerFile,
fetchLockerTrash,
loadPersistedLockerState,
syncLockerState,
@@ -53,38 +47,12 @@ export {
export { createCollection, renameCollection } from "./remote-collections";
export { deleteCollection };
-export { downloadLockerFile, loadPersistedLockerState, syncLockerState };
-
-const RemoteFileShareLink = z.object({
- linkID: z.union([z.string(), z.number().transform(String)]),
- url: z.string(),
- ownerID: z.number(),
- fileID: z.number(),
- isDisabled: z.boolean().optional(),
- validTill: z.number().nullish(),
- deviceLimit: z.number().nullish(),
- passwordEnabled: z.boolean(),
- nonce: z.string().nullish(),
- memLimit: z.number().nullish(),
- opsLimit: z.number().nullish(),
- enableDownload: z.boolean(),
- createdAt: z.number(),
- encryptedFileKey: z.string().nullish(),
- encryptedFileKeyNonce: z.string().nullish(),
- kdfNonce: z.string().nullish(),
- kdfMemLimit: z.number().nullish(),
- kdfOpsLimit: z.number().nullish(),
- encryptedShareKey: z.string().nullish(),
-});
-
-interface LockerFileShareLink {
- linkID: string;
- url: string;
- fileID?: number;
- validTill?: number | null;
- enableDownload?: boolean;
- passwordEnabled?: boolean;
-}
+export { downloadLockerFile } from "./download";
+export {
+ deleteLockerFileShareLink,
+ getOrCreateLockerFileShareLink,
+} from "./file-links";
+export { loadPersistedLockerState, syncLockerState };
const infoItemTitle = (
infoType: LockerItemType,
@@ -119,72 +87,6 @@ const resolveCollectionIDsWithUncategorizedFallback = async (
? Array.from(new Set(collectionIDs))
: [(await ensureUncategorizedCollection(masterKey)).id];
-export const getOrCreateLockerFileShareLink = async (
- fileID: number,
-): Promise<LockerFileShareLink> => {
- const fileRecord = getEncryptedFileRecord(fileID);
- if (!fileRecord) {
- throw new Error(`File ${fileID} not found in cache`);
- }
-
- const fileKey = await decryptFileKeyForRecord(fileRecord);
- const session = await ensureAuthenticatedSession();
- const payload = await prepareFileLink(session, fileKey);
-
- const res = await fetch(await apiURL("/files/share-url"), {
- method: "POST",
- headers: {
- ...(await authenticatedRequestHeaders()),
- "Content-Type": "application/json",
- },
- body: JSON.stringify({ fileID, app: "locker", ...payload.metadata }),
- });
- ensureOk(res);
-
- const link = RemoteFileShareLink.parse(await res.json());
- const secret = link.encryptedShareKey
- ? await openFileLinkSecret(session, link.encryptedShareKey)
- : payload.secret;
-
- return {
- linkID: link.linkID,
- url: `${link.url}#${secret}`,
- fileID: link.fileID,
- validTill: link.validTill,
- enableDownload: link.enableDownload,
- passwordEnabled: link.passwordEnabled,
- };
-};
-
-export const deleteLockerFileShareLink = async (
- fileID: number,
- linkID?: string,
-): Promise<void> => {
- const candidateIDs = [linkID, String(fileID)].filter(
- (candidate, index, values): candidate is string =>
- !!candidate && values.indexOf(candidate) === index,
- );
-
- let lastError: Error | undefined;
- for (const candidateID of candidateIDs) {
- const res = await fetch(
- await apiURL(`/files/share-url/${candidateID}`),
- { method: "DELETE", headers: await authenticatedRequestHeaders() },
- );
- if (res.ok) {
- return;
- }
- lastError = new Error(
- `Failed to delete link ${candidateID}: ${res.status} ${res.statusText}`,
- );
- if (candidateID !== String(fileID)) {
- continue;
- }
- }
-
- throw lastError ?? new Error("Failed to delete file share link");
-};
-
export const createInfoItem = async (
collectionIDs: number[],
infoType: LockerItemType,
diff --git a/web/apps/locker/tests/download.test.ts b/web/apps/locker/tests/download.test.ts
new file mode 100644
index 0000000000..938406efd2
--- /dev/null
+++ b/web/apps/locker/tests/download.test.ts
@@ -0,0 +1,205 @@
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import { downloadLockerFile } from "../src/services/download";
+
+const {
+ getRecord,
+ getSnapshot,
+ decryptCollectionKey,
+ decryptBox,
+ createDecryptor,
+ customOrigin,
+ fetchFile,
+} = vi.hoisted(() => ({
+ getRecord: vi.fn(),
+ getSnapshot: vi.fn(),
+ decryptCollectionKey: vi.fn(),
+ decryptBox: vi.fn(),
+ createDecryptor: vi.fn(),
+ customOrigin: vi.fn(),
+ fetchFile: vi.fn(),
+}));
+vi.mock("../src/services/remote-cache", () => ({
+ getEncryptedFileRecord: getRecord,
+ getLockerCacheSnapshot: getSnapshot,
+}));
+vi.mock("../src/services/remote-read", () => ({ decryptCollectionKey }));
+vi.mock("ente-locker-wasm", () => ({
+ decryptBox,
+ createStreamDecryptor: createDecryptor,
+}));
+vi.mock("ente-base/file-download", () => ({ fetchFile }));
+vi.mock("ente-base/origins", () => ({ customAPIOrigin: customOrigin }));
+vi.mock("ente-base/log", () => ({
+ default: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+}));
+vi.mock("ente-base/http", () => ({
+ authenticatedRequestHeaders: () =>
+ Promise.resolve({ Authorization: "test-token" }),
+ ensureOk: (res: Response) => {
+ if (!res.ok) throw new Error(`HTTP ${res.status}`);
+ },
+}));
+const fetchMock = vi.fn<typeof fetch>();
+const createObjectURL = vi.fn<(object: Blob | MediaSource) => string>();
+const revokeObjectURL = vi.fn<(url: string) => void>();
+const anchor = {
+ style: { display: "" },
+ href: "",
+ download: "",
+ click: vi.fn(),
+ remove: vi.fn(),
+};
+const appendChild = vi.fn();
+const decryptChunk = vi.fn((chunk: Uint8Array) => chunk);
+const free = vi.fn();
+const isFinalized = vi.fn(() => true);
+const collection = { id: 2 };
+const streamedResponse = (knownLength = true) =>
+ new Response(
+ new ReadableStream<Uint8Array>({
+ start(controller) {
+ for (const chunk of [[1], [2, 3], [4, 5]])
+ controller.enqueue(new Uint8Array(chunk));
+ controller.close();
+ },
+ }),
+ { headers: knownLength ? { "Content-Length": "5" } : {} },
+ );
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ vi.useFakeTimers();
+ vi.stubGlobal("fetch", fetchMock);
+ vi.stubGlobal("document", {
+ createElement: () => anchor,
+ body: { appendChild },
+ });
+ createObjectURL.mockReturnValue("blob:test");
+ vi.spyOn(URL, "createObjectURL").mockImplementation(createObjectURL);
+ vi.spyOn(URL, "revokeObjectURL").mockImplementation(revokeObjectURL);
+ getRecord.mockReturnValue({
+ id: 42,
+ collectionID: 2,
+ encryptedKey: "wrapped-key",
+ keyDecryptionNonce: "nonce",
+ fileDecryptionHeader: "header",
+ hasObject: true,
+ });
+ getSnapshot.mockReturnValue({ collections: new Map([[2, collection]]) });
+ decryptCollectionKey.mockResolvedValue("collection-key");
+ decryptBox.mockResolvedValue("file-key");
+ decryptChunk.mockImplementation((chunk: Uint8Array) => chunk);
+ isFinalized.mockReturnValue(true);
+ createDecryptor.mockResolvedValue({
+ decryptionChunkSize: 2,
+ decryptChunk,
+ isFinalized,
+ free,
+ });
+ customOrigin.mockResolvedValue(undefined);
+ fetchMock.mockResolvedValue(streamedResponse());
+ fetchFile.mockResolvedValue(streamedResponse());
+});
+afterEach(() => {
+ vi.useRealTimers();
+ vi.restoreAllMocks();
+ vi.unstubAllGlobals();
+});
+
+test.each([true, false])(
+ "streams partial chunks, reports progress and saves the blob (known length: %s)",
+ async (knownLength) => {
+ fetchMock.mockResolvedValue(streamedResponse(knownLength));
+ const progress =
+ vi.fn<(progress: { loaded: number; total?: number }) => void>();
+ await downloadLockerFile(42, "download.bin", progress);
+ expect(fetchMock).toHaveBeenCalledWith(
+ "https://files.ente.com/?fileID=42",
+ { headers: { Authorization: "test-token" } },
+ );
+ expect(fetchFile).not.toHaveBeenCalled();
+ expect(decryptCollectionKey).toHaveBeenCalledWith(collection);
+ expect(decryptBox).toHaveBeenCalledWith(
+ { encryptedData: "wrapped-key", nonce: "nonce" },
+ "collection-key",
+ );
+ expect(createDecryptor).toHaveBeenCalledWith("header", "file-key");
+ expect(
+ decryptChunk.mock.calls.map(([chunk]) => Array.from(chunk)),
+ ).toEqual([[1, 2], [3, 4], [5]]);
+ expect(progress.mock.calls.map(([value]) => value)).toEqual(
+ [0, 1, 3, 5, 5].map((loaded) => ({
+ loaded,
+ total: knownLength ? 5 : undefined,
+ })),
+ );
+ const blob = createObjectURL.mock.calls[0]![0] as Blob;
+ expect(Array.from(new Uint8Array(await blob.arrayBuffer()))).toEqual([
+ 1, 2, 3, 4, 5,
+ ]);
+ expect(anchor.download).toBe("download.bin");
+ expect(anchor.href).toBe("blob:test");
+ expect(appendChild).toHaveBeenCalledWith(anchor);
+ expect(anchor.click).toHaveBeenCalledOnce();
+ expect(anchor.remove).toHaveBeenCalledOnce();
+ expect(free).toHaveBeenCalledOnce();
+ expect(revokeObjectURL).not.toHaveBeenCalled();
+ vi.advanceTimersByTime(30_000);
+ expect(revokeObjectURL).toHaveBeenCalledWith("blob:test");
+ },
+);
+test("uses the configured API download route for custom origins", async () => {
+ customOrigin.mockResolvedValue("https://custom.test");
+ await downloadLockerFile(42, "download.bin");
+ expect(fetchFile).toHaveBeenCalledExactlyOnceWith(42, "file");
+ expect(fetchMock).not.toHaveBeenCalled();
+});
+test.each(["file", "collection"])(
+ "rejects a missing cached %s before downloading",
+ async (missing) => {
+ if (missing === "file") getRecord.mockReturnValue(undefined);
+ else getSnapshot.mockReturnValue({ collections: new Map() });
+ await expect(downloadLockerFile(42, "file")).rejects.toThrow(
+ "not found in cache",
+ );
+ expect(fetchMock).not.toHaveBeenCalled();
+ expect(anchor.click).not.toHaveBeenCalled();
+ },
+);
+test("propagates key decryption failure before starting a request", async () => {
+ decryptBox.mockRejectedValue(new Error("bad key"));
+ await expect(downloadLockerFile(42, "file")).rejects.toThrow("bad key");
+ expect(fetchMock).not.toHaveBeenCalled();
+});
+test.each(["http", "body"])(
+ "rejects invalid download responses: %s",
+ async (reason) => {
+ fetchMock.mockResolvedValue(
+ new Response(null, { status: reason === "http" ? 403 : 200 }),
+ );
+ await expect(downloadLockerFile(42, "file")).rejects.toThrow(
+ reason === "http" ? "HTTP 403" : "Download response body is empty",
+ );
+ expect(createDecryptor).not.toHaveBeenCalled();
+ expect(anchor.click).not.toHaveBeenCalled();
+ },
+);
+test("rejects truncated ciphertext and releases the decryptor without saving", async () => {
+ isFinalized.mockReturnValue(false);
+ await expect(downloadLockerFile(42, "file")).rejects.toThrow(
+ "Download stream truncated before final chunk",
+ );
+ expect(free).toHaveBeenCalledOnce();
+ expect(createObjectURL).not.toHaveBeenCalled();
+ expect(anchor.click).not.toHaveBeenCalled();
+});
+test("propagates chunk decryption errors and releases the decryptor", async () => {
+ decryptChunk.mockImplementation(() => {
+ throw new Error("corrupt chunk");
+ });
+ await expect(downloadLockerFile(42, "file")).rejects.toThrow(
+ "corrupt chunk",
+ );
+ expect(free).toHaveBeenCalledOnce();
+ expect(anchor.click).not.toHaveBeenCalled();
+});
diff --git a/web/apps/locker/tests/file-links.test.ts b/web/apps/locker/tests/file-links.test.ts
new file mode 100644
index 0000000000..b0ef8f684a
--- /dev/null
+++ b/web/apps/locker/tests/file-links.test.ts
@@ -0,0 +1,155 @@
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import {
+ deleteLockerFileShareLink,
+ getOrCreateLockerFileShareLink,
+} from "../src/services/file-links";
+
+const { getRecord, decryptKey, session, prepare, openSecret } = vi.hoisted(
+ () => ({
+ getRecord: vi.fn(),
+ decryptKey: vi.fn(),
+ session: vi.fn(),
+ prepare: vi.fn(),
+ openSecret: vi.fn(),
+ }),
+);
+vi.mock("../src/services/remote-cache", () => ({
+ getEncryptedFileRecord: getRecord,
+}));
+vi.mock("../src/services/remote-read", () => ({
+ decryptFileKeyForRecord: decryptKey,
+}));
+vi.mock("../src/services/authenticated-session", () => ({
+ ensureAuthenticatedSession: session,
+}));
+vi.mock("ente-locker-wasm", () => ({
+ prepareFileLink: prepare,
+ openFileLinkSecret: openSecret,
+}));
+vi.mock("ente-base/http", () => ({
+ authenticatedRequestHeaders: () =>
+ Promise.resolve({ Authorization: "test-token" }),
+ ensureOk: (res: Response) => {
+ if (!res.ok) throw new Error(`HTTP ${res.status}`);
+ },
+}));
+vi.mock("ente-base/origins", () => ({
+ apiURL: (path: string) => `https://api.test${path}`,
+}));
+
+const fetchMock = vi.fn<typeof fetch>();
+const record = { id: 42 };
+const authSession = { id: "session" };
+const responseLink = {
+ linkID: 7,
+ url: "https://share.test/link",
+ ownerID: 1,
+ fileID: 42,
+ passwordEnabled: false,
+ enableDownload: true,
+ createdAt: 1,
+ validTill: null,
+};
+beforeEach(() => {
+ vi.resetAllMocks();
+ vi.stubGlobal("fetch", fetchMock);
+ getRecord.mockReturnValue(record);
+ decryptKey.mockResolvedValue("file-key");
+ session.mockResolvedValue(authSession);
+ prepare.mockResolvedValue({
+ secret: "new-secret",
+ metadata: { encryptedFileKey: "encrypted", nonce: "nonce" },
+ });
+ openSecret.mockResolvedValue("existing-secret");
+ fetchMock.mockResolvedValue(Response.json(responseLink));
+});
+afterEach(() => vi.unstubAllGlobals());
+
+test("creates a link with encrypted metadata and keeps the secret in the URL fragment", async () => {
+ expect(await getOrCreateLockerFileShareLink(42)).toEqual({
+ linkID: "7",
+ url: "https://share.test/link#new-secret",
+ fileID: 42,
+ validTill: null,
+ enableDownload: true,
+ passwordEnabled: false,
+ });
+ expect(decryptKey).toHaveBeenCalledWith(record);
+ expect(prepare).toHaveBeenCalledWith(authSession, "file-key");
+ expect(fetchMock).toHaveBeenCalledWith("https://api.test/files/share-url", {
+ method: "POST",
+ headers: {
+ Authorization: "test-token",
+ "Content-Type": "application/json",
+ },
+ body: JSON.stringify({
+ fileID: 42,
+ app: "locker",
+ encryptedFileKey: "encrypted",
+ nonce: "nonce",
+ }),
+ });
+ expect(openSecret).not.toHaveBeenCalled();
+});
+test("uses the existing encrypted share secret when returned by the server", async () => {
+ fetchMock.mockResolvedValue(
+ Response.json({ ...responseLink, encryptedShareKey: "wrapped-secret" }),
+ );
+ expect((await getOrCreateLockerFileShareLink(42)).url).toBe(
+ "https://share.test/link#existing-secret",
+ );
+ expect(openSecret).toHaveBeenCalledWith(authSession, "wrapped-secret");
+});
+test("missing cached files fail before crypto or network calls", async () => {
+ getRecord.mockReturnValue(undefined);
+ await expect(getOrCreateLockerFileShareLink(42)).rejects.toThrow(
+ "File 42 not found in cache",
+ );
+ expect(prepare).not.toHaveBeenCalled();
+ expect(fetchMock).not.toHaveBeenCalled();
+});
+test("rejects unsuccessful or malformed responses", async () => {
+ fetchMock
+ .mockResolvedValueOnce(new Response(null, { status: 403 }))
+ .mockResolvedValueOnce(Response.json({ linkID: 7 }));
+ await expect(getOrCreateLockerFileShareLink(42)).rejects.toThrow(
+ "HTTP 403",
+ );
+ await expect(getOrCreateLockerFileShareLink(42)).rejects.toThrow();
+ expect(openSecret).not.toHaveBeenCalled();
+});
+test("successful deletion stops after the supplied link ID", async () => {
+ await deleteLockerFileShareLink(42, "link-id");
+ expect(fetchMock).toHaveBeenCalledExactlyOnceWith(
+ "https://api.test/files/share-url/link-id",
+ { method: "DELETE", headers: { Authorization: "test-token" } },
+ );
+});
+test("deletion retries with the file ID after a non-success response", async () => {
+ fetchMock
+ .mockResolvedValueOnce(new Response(null, { status: 404 }))
+ .mockResolvedValueOnce(new Response(null, { status: 204 }));
+ await deleteLockerFileShareLink(42, "link-id");
+ expect(fetchMock.mock.calls.map(([url]) => url)).toEqual([
+ "https://api.test/files/share-url/link-id",
+ "https://api.test/files/share-url/42",
+ ]);
+});
+test.each([undefined, "42"])(
+ "uses the file ID only once when linkID is %s",
+ async (linkID) => {
+ await deleteLockerFileShareLink(42, linkID);
+ expect(fetchMock).toHaveBeenCalledTimes(1);
+ expect(fetchMock.mock.calls[0]![0]).toBe(
+ "https://api.test/files/share-url/42",
+ );
+ },
+);
+test("reports the final deletion failure", async () => {
+ fetchMock.mockResolvedValue(
+ new Response(null, { status: 404, statusText: "Not Found" }),
+ );
+ await expect(deleteLockerFileShareLink(42, "link-id")).rejects.toThrow(
+ "Failed to delete link 42: 404 Not Found",
+ );
+});