Skip to content

armgit / ente

Public Imported from GitHub
0

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

perf(accounts-rs):run-argon2-kdf-off-main-thread

Aswin Asokc0467840782a
diff --git a/web/package-lock.json b/web/package-lock.json
index 7989bf9d2a..238d2a3148 100644
--- a/web/package-lock.json
+++ b/web/package-lock.json
@@ -11204,6 +11204,7 @@
"name": "ente-accounts-rs",
"version": "0.0.0",
"dependencies": {
+ "comlink": "4.4.2",
"ente-base": "*",
"ente-wasm": "*",
"react": "19.2.7",
diff --git a/web/packages/accounts-rs/package.json b/web/packages/accounts-rs/package.json
index 4190c396c9..69e4745474 100644
--- a/web/packages/accounts-rs/package.json
+++ b/web/packages/accounts-rs/package.json
@@ -3,6 +3,7 @@
"version": "0.0.0",
"private": true,
"dependencies": {
+ "comlink": "4.4.2",
"ente-base": "*",
"ente-wasm": "*",
"react": "19.2.7",
diff --git a/web/packages/accounts-rs/services/crypto.ts b/web/packages/accounts-rs/services/crypto.ts
index 2fafc96afc..0c459dcdc3 100644
--- a/web/packages/accounts-rs/services/crypto.ts
+++ b/web/packages/accounts-rs/services/crypto.ts
@@ -1,7 +1,13 @@
+import type { Remote } from "comlink";
+import { inWorker } from "ente-base/env";
+import { ComlinkWorker } from "ente-base/worker/comlink-worker";
import { loadCryptoReadyEnteWasm } from "ente-wasm/load";
+import * as kdf from "./kdf";
+import type { DerivedKey } from "./kdf";
+import type { KDFWorker } from "./kdf.worker";
-export const deriveKeyInsufficientMemoryErrorMessage =
- "Failed to derive key (insufficient memory)";
+export { deriveKeyInsufficientMemoryErrorMessage } from "./kdf";
+export type { DerivedKey } from "./kdf";
export interface EncryptedBox {
encryptedData: string;
@@ -13,20 +19,6 @@ export interface KeyPair {
privateKey: string;
}
-export interface DerivedKey {
- key: string;
- salt: string;
- opsLimit: number;
- memLimit: number;
-}
-
-interface WasmDerivedKey {
- key: string;
- salt: string;
- ops_limit: number;
- mem_limit: number;
-}
-
interface WasmGeneratedSRPSetup {
srp_salt: string;
srp_verifier: string;
@@ -59,65 +51,56 @@ export const fromB64URLSafeNoPadding = async (b64String: string) => {
return fromB64(normalized);
};
-const normalizeDerivedKeyError = (error: unknown): Error => {
- const code =
- typeof error === "object" && error && "code" in error
- ? String(error.code)
- : undefined;
- if (error instanceof Error) {
- if (
- code === "insufficient_memory" ||
- error.message.includes("insufficient memory") ||
- error.message.includes("KeyDerivationFailed") ||
- error.message.includes("key_derivation_failed")
- ) {
- return new Error(deriveKeyInsufficientMemoryErrorMessage);
+let _kdfWorker: ComlinkWorker<typeof KDFWorker> | undefined;
+
+const createKDFWorker = () =>
+ new ComlinkWorker<typeof KDFWorker>(
+ "kdf",
+ new Worker(new URL("kdf.worker.ts", import.meta.url)),
+ );
+
+const withKDFWorker = async <T>(
+ callback: (worker: Remote<KDFWorker>) => Promise<T>,
+): Promise<T> => {
+ const worker = (_kdfWorker ??= createKDFWorker());
+ try {
+ return await callback(await worker.remote);
+ } catch (error) {
+ // Discard any failed worker so later calls start fresh; termination also
+ // reclaims a wasm heap grown by a failed Argon2 allocation.
+ if (_kdfWorker === worker) {
+ _kdfWorker = undefined;
+ worker.terminate();
}
- return error;
+ throw error;
}
- return new Error(deriveKeyInsufficientMemoryErrorMessage);
};
-export const deriveKey = async (
+export const deriveKey = (
password: string,
saltB64: string,
opsLimit: number,
memLimit: number,
-) => {
- const wasm = await loadCryptoReadyEnteWasm();
- return wasm.auth_derive_kek(password, saltB64, memLimit, opsLimit);
-};
-
-const normalizeDerivedKey = (result: WasmDerivedKey): DerivedKey => ({
- key: result.key,
- salt: result.salt,
- opsLimit: result.ops_limit,
- memLimit: result.mem_limit,
-});
-
-export const deriveSensitiveKey = async (
+): Promise<string> =>
+ inWorker()
+ ? kdf.deriveKey(password, saltB64, opsLimit, memLimit)
+ : withKDFWorker((worker) =>
+ worker.deriveKey(password, saltB64, opsLimit, memLimit),
+ );
+
+export const deriveSensitiveKey = (
password: string,
-): Promise<DerivedKey> => {
- const wasm = await loadCryptoReadyEnteWasm();
- try {
- return normalizeDerivedKey(wasm.auth_generate_sensitive_kek(password));
- } catch (error) {
- throw normalizeDerivedKeyError(error);
- }
-};
+): Promise<DerivedKey> =>
+ inWorker()
+ ? kdf.deriveSensitiveKey(password)
+ : withKDFWorker((worker) => worker.deriveSensitiveKey(password));
-export const deriveInteractiveKey = async (
+export const deriveInteractiveKey = (
password: string,
-): Promise<DerivedKey> => {
- const wasm = await loadCryptoReadyEnteWasm();
- try {
- return normalizeDerivedKey(
- wasm.auth_generate_interactive_kek(password),
- );
- } catch (error) {
- throw normalizeDerivedKeyError(error);
- }
-};
+): Promise<DerivedKey> =>
+ inWorker()
+ ? kdf.deriveInteractiveKey(password)
+ : withKDFWorker((worker) => worker.deriveInteractiveKey(password));
export const generateKey = async (): Promise<string> => {
const wasm = await loadCryptoReadyEnteWasm();
diff --git a/web/packages/accounts-rs/services/kdf.ts b/web/packages/accounts-rs/services/kdf.ts
new file mode 100644
index 0000000000..54edfa588a
--- /dev/null
+++ b/web/packages/accounts-rs/services/kdf.ts
@@ -0,0 +1,92 @@
+import { loadCryptoReadyEnteWasm } from "ente-wasm/load";
+
+export const deriveKeyInsufficientMemoryErrorMessage =
+ "Failed to derive key (insufficient memory)";
+
+export interface DerivedKey {
+ key: string;
+ salt: string;
+ opsLimit: number;
+ memLimit: number;
+}
+
+interface WasmDerivedKey {
+ key: string;
+ salt: string;
+ ops_limit: number;
+ mem_limit: number;
+}
+
+export const normalizeDerivedKeyError = (error: unknown): Error => {
+ const code =
+ typeof error === "object" && error && "code" in error
+ ? String(error.code)
+ : undefined;
+ if (error instanceof Error) {
+ if (
+ code === "insufficient_memory" ||
+ error.message.includes("insufficient memory") ||
+ error.message.includes("KeyDerivationFailed") ||
+ error.message.includes("key_derivation_failed")
+ ) {
+ return new Error(deriveKeyInsufficientMemoryErrorMessage);
+ }
+ return error;
+ }
+ return new Error(deriveKeyInsufficientMemoryErrorMessage);
+};
+
+// wasm-bindgen errors are not Errors and cannot cross Comlink's structured clone.
+const toPlainError = (error: unknown): Error => {
+ if (error instanceof Error) return error;
+ const message =
+ typeof error === "object" && error && "message" in error
+ ? error.message
+ : error;
+ return new Error(String(message));
+};
+
+export const deriveKey = async (
+ password: string,
+ saltB64: string,
+ opsLimit: number,
+ memLimit: number,
+) => {
+ try {
+ const wasm = await loadCryptoReadyEnteWasm();
+ return wasm.auth_derive_kek(password, saltB64, memLimit, opsLimit);
+ } catch (error) {
+ throw toPlainError(error);
+ }
+};
+
+const normalizeDerivedKey = (result: WasmDerivedKey): DerivedKey => ({
+ key: result.key,
+ salt: result.salt,
+ opsLimit: result.ops_limit,
+ memLimit: result.mem_limit,
+});
+
+export const deriveSensitiveKey = async (
+ password: string,
+): Promise<DerivedKey> => {
+ const wasm = await loadCryptoReadyEnteWasm();
+ try {
+ return normalizeDerivedKey(wasm.auth_generate_sensitive_kek(password));
+ } catch (error) {
+ throw normalizeDerivedKeyError(error);
+ }
+};
+
+export const deriveInteractiveKey = async (
+ password: string,
+): Promise<DerivedKey> => {
+ const wasm = await loadCryptoReadyEnteWasm();
+ try {
+ return normalizeDerivedKey(
+ wasm.auth_generate_interactive_kek(password),
+ );
+ } catch (error) {
+ throw normalizeDerivedKeyError(error);
+ }
+};
diff --git a/web/packages/accounts-rs/services/kdf.worker.ts b/web/packages/accounts-rs/services/kdf.worker.ts
new file mode 100644
index 0000000000..df29d08b1b
--- /dev/null
+++ b/web/packages/accounts-rs/services/kdf.worker.ts
@@ -0,0 +1,13 @@
+import { expose } from "comlink";
+import { logUnhandledErrorsAndRejectionsInWorker } from "ente-base/log-web";
+import * as kdf from "./kdf";
+
+export class KDFWorker {
+ deriveKey = kdf.deriveKey;
+ deriveSensitiveKey = kdf.deriveSensitiveKey;
+ deriveInteractiveKey = kdf.deriveInteractiveKey;
+}
+
+expose(KDFWorker);
+
+logUnhandledErrorsAndRejectionsInWorker();