Skip to content

armgit / ente

Public Imported from GitHub
0

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

Move Locker file link crypto to Rust

Manav Rathie424c790399e
diff --git a/.github/workflows/mobile-lint.yml b/.github/workflows/mobile-lint.yml
index 0380be67b3..26e2c6cccb 100644
--- a/.github/workflows/mobile-lint.yml
+++ b/.github/workflows/mobile-lint.yml
@@ -13,6 +13,7 @@ on:
- "rust/crates/contacts/**"
- "rust/crates/core/**"
- "rust/crates/image/**"
+ - "rust/crates/locker/**"
- "rust/crates/ml/**"
- "rust/crates/photos/**"
workflow_dispatch:
diff --git a/.github/workflows/web-lint.yml b/.github/workflows/web-lint.yml
index ff3d2e31b3..0ad93bdc67 100644
--- a/.github/workflows/web-lint.yml
+++ b/.github/workflows/web-lint.yml
@@ -9,6 +9,7 @@ on:
- "rust/crates/collections/**"
- "rust/crates/contacts/**"
- "rust/crates/core/**"
+ - "rust/crates/locker/**"
- "rust/crates/paste/**"
- "rust/crates/space/**"
- "rust/Cargo.lock"
diff --git a/mobile/apps/locker/flutter_rust_bridge.yaml b/mobile/apps/locker/flutter_rust_bridge.yaml
index 61ae1d0e29..1231152999 100644
--- a/mobile/apps/locker/flutter_rust_bridge.yaml
+++ b/mobile/apps/locker/flutter_rust_bridge.yaml
@@ -1,5 +1,5 @@
rust_input: crate::api, ente-frb-lib
-rust_features: ["ente-frb-lib/contacts,ente-frb-lib/legacy"]
+rust_features: ["ente-frb-lib/contacts,ente-frb-lib/legacy,ente-frb-lib/locker"]
rust_root: ../../../rust/bindings/frb/locker/
dart_output: lib/src/rust
dart_entrypoint_class_name: EnteLockerRust
diff --git a/mobile/apps/locker/lib/services/files/links/links_service.dart b/mobile/apps/locker/lib/services/files/links/links_service.dart
index 6c4c7a883b..f84917c7a8 100644
--- a/mobile/apps/locker/lib/services/files/links/links_service.dart
+++ b/mobile/apps/locker/lib/services/files/links/links_service.dart
@@ -1,14 +1,9 @@
-import "dart:convert";
-import "dart:math";
-import "dart:typed_data";
-
-import "package:ente_crypto_api/ente_crypto_api.dart";
+import "package:locker/services/authenticated_session.dart";
import "package:locker/services/collections/collections_service.dart";
-import "package:locker/services/configuration.dart";
import "package:locker/services/files/links/links_client.dart";
import "package:locker/services/files/links/models/shareable_link.dart";
import "package:locker/services/files/sync/models/file.dart";
-import "package:logging/logging.dart";
+import "package:locker/src/rust/third_party/ente_frb_lib/locker.dart";
class LinksService {
LinksService._();
@@ -16,7 +11,6 @@ class LinksService {
static final LinksService instance = LinksService._();
late final LinksClient _client;
- final Logger _logger = Logger("LinksService");
Future<void> init() async {
_client = LinksClient.instance;
@@ -24,13 +18,30 @@ class LinksService {
Future<ShareableLink> getOrCreateLink(EnteFile file) async {
final fileKey = await CollectionService.instance.getFileKey(file);
- final secretPayload = await _prepareLinkSecret(fileKey);
+ final session = authenticatedSession();
+ final secretPayload = await prepareFileLink(
+ session: session,
+ fileKey: fileKey,
+ );
final link = await _client.getOrCreateLink(
file.uploadedFileID!,
- metadata: secretPayload.metadata(),
+ metadata: {
+ 'encryptedFileKey': secretPayload.encryptedFileKey,
+ 'encryptedFileKeyNonce': secretPayload.encryptedFileKeyNonce,
+ 'kdfNonce': secretPayload.kdfNonce,
+ 'kdfMemLimit': secretPayload.kdfMemLimit,
+ 'kdfOpsLimit': secretPayload.kdfOpsLimit,
+ 'encryptedShareKey': secretPayload.encryptedShareKey,
+ },
);
- final fragmentSecret = await _resolveFragmentSecret(link, secretPayload);
+ final encryptedShareKey = link.encryptedShareKey;
+ final fragmentSecret = encryptedShareKey == null
+ ? secretPayload.fragment
+ : await openFileLinkSecret(
+ session: session,
+ encryptedShareKey: encryptedShareKey,
+ );
link.fullURL = "${link.url}#$fragmentSecret";
return link;
}
@@ -38,119 +49,4 @@ class LinksService {
Future<void> deleteLink(int fileID) async {
await _client.deleteLink(fileID);
}
-
- Future<_LinkSecretPayload> _prepareLinkSecret(Uint8List fileKey) async {
- try {
- final secret = _generateBase62Secret(12);
- final secretBytes = Uint8List.fromList(utf8.encode(secret));
- final secretBase64 = CryptoUtil.bin2base64(secretBytes);
-
- final kdfSalt = CryptoUtil.getSaltToDeriveKey();
- final derivedKey = await CryptoUtil.deriveInteractiveKey(
- Uint8List.fromList(utf8.encode(secret)),
- kdfSalt,
- );
- final encryptedKey = CryptoUtil.encryptSync(fileKey, derivedKey.key);
-
- final keyAttributes = Configuration.instance.getKeyAttributes();
- final userPublicKey = keyAttributes?.publicKey;
- if (userPublicKey == null) {
- throw StateError(
- "Public key unavailable while generating share secret",
- );
- }
- final encryptedShareKeyBytes = CryptoUtil.sealSync(
- Uint8List.fromList(utf8.encode(secretBase64)),
- CryptoUtil.base642bin(userPublicKey),
- );
-
- return _LinkSecretPayload(
- secret: secret,
- encryptedFileKey: CryptoUtil.bin2base64(encryptedKey.encryptedData!),
- encryptedFileKeyNonce: CryptoUtil.bin2base64(encryptedKey.nonce!),
- kdfNonce: CryptoUtil.bin2base64(kdfSalt),
- kdfMemLimit: derivedKey.memLimit,
- kdfOpsLimit: derivedKey.opsLimit,
- encryptedShareKey: CryptoUtil.bin2base64(encryptedShareKeyBytes),
- );
- } catch (e, s) {
- _logger.severe("Failed to prepare link secret", e, s);
- rethrow;
- }
- }
-
- Future<String> _resolveFragmentSecret(
- ShareableLink link,
- _LinkSecretPayload payload,
- ) async {
- final encryptedShareKey = link.encryptedShareKey;
- if (encryptedShareKey == null) {
- return payload.secret;
- }
-
- final keyAttributes = Configuration.instance.getKeyAttributes();
- final secretKey = Configuration.instance.getSecretKey();
- if (keyAttributes == null || secretKey == null) {
- _logger.severe(
- "Missing key material to decrypt share secret for existing link",
- );
- throw StateError("Unable to decrypt share secret");
- }
-
- try {
- final decryptedBytes = CryptoUtil.openSealSync(
- CryptoUtil.base642bin(encryptedShareKey),
- CryptoUtil.base642bin(keyAttributes.publicKey),
- secretKey,
- );
- final secretBase64 = utf8.decode(decryptedBytes);
- final secret = utf8.decode(CryptoUtil.base642bin(secretBase64));
- return secret;
- } catch (e, s) {
- _logger.severe("Failed to decrypt share secret", e, s);
- throw StateError("Unable to decrypt share secret");
- }
- }
-
- String _generateBase62Secret(int length) {
- const charset =
- "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
- final random = Random.secure();
- final buffer = StringBuffer();
- for (var i = 0; i < length; i++) {
- buffer.write(charset[random.nextInt(charset.length)]);
- }
- return buffer.toString();
- }
-}
-
-class _LinkSecretPayload {
- _LinkSecretPayload({
- required this.secret,
- required this.encryptedFileKey,
- required this.encryptedFileKeyNonce,
- required this.kdfNonce,
- required this.kdfMemLimit,
- required this.kdfOpsLimit,
- required this.encryptedShareKey,
- });
-
- final String secret;
- final String encryptedFileKey;
- final String encryptedFileKeyNonce;
- final String kdfNonce;
- final int kdfMemLimit;
- final int kdfOpsLimit;
- final String encryptedShareKey;
-
- Map<String, dynamic> metadata() {
- return {
- 'encryptedFileKey': encryptedFileKey,
- 'encryptedFileKeyNonce': encryptedFileKeyNonce,
- 'kdfNonce': kdfNonce,
- 'kdfMemLimit': kdfMemLimit,
- 'kdfOpsLimit': kdfOpsLimit,
- 'encryptedShareKey': encryptedShareKey,
- };
- }
}
diff --git a/mobile/apps/locker/lib/utils/file_actions.dart b/mobile/apps/locker/lib/utils/file_actions.dart
index e696ebb479..a9f5870904 100644
--- a/mobile/apps/locker/lib/utils/file_actions.dart
+++ b/mobile/apps/locker/lib/utils/file_actions.dart
@@ -263,7 +263,8 @@ class FileActions {
file,
);
}
- } catch (e) {
+ } catch (e, stackTrace) {
+ _logger.severe("Failed to create file link", e, stackTrace);
await dialog.hide();
if (context.mounted) {
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 0c70758838..20606f6df2 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -2567,6 +2567,7 @@ dependencies = [
"ente-contacts",
"ente-core",
"ente-legacy",
+ "ente-locker",
"flutter_rust_bridge",
]
@@ -2644,6 +2645,14 @@ dependencies = [
"zip 8.6.0",
]
+[[package]]
+name = "ente-locker"
+version = "0.0.0"
+dependencies = [
+ "ente-core",
+ "thiserror 2.0.18",
+]
+
[[package]]
name = "ente-locker-frb"
version = "0.0.0"
@@ -2873,6 +2882,7 @@ dependencies = [
"ente-collections",
"ente-contacts",
"ente-core",
+ "ente-locker",
"js-sys",
"log",
"md-5 0.11.0",
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index a9244de706..9d83c3ac6e 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -34,6 +34,7 @@ members = [
"crates/legacy",
"crates/location",
"crates/location-dataset",
+ "crates/locker",
"crates/ml",
"crates/paste",
"crates/photos",
@@ -60,6 +61,7 @@ ente-frb-log = { path = "bindings/frb/log" }
ente-image = { path = "crates/image" }
ente-legacy = { path = "crates/legacy" }
ente-location = { path = "crates/location" }
+ente-locker = { path = "crates/locker" }
ente-ml = { path = "crates/ml" }
ente-paste = { path = "crates/paste" }
ente-photos = { path = "crates/photos" }
diff --git a/rust/bindings/frb/lib/Cargo.toml b/rust/bindings/frb/lib/Cargo.toml
index 2f0a2e2ac5..f68f68fdd1 100644
--- a/rust/bindings/frb/lib/Cargo.toml
+++ b/rust/bindings/frb/lib/Cargo.toml
@@ -5,11 +5,13 @@ edition.workspace = true
[features]
contacts = ["dep:ente-contacts"]
legacy = ["dep:ente-legacy"]
+locker = ["dep:ente-locker"]
[dependencies]
ente-contacts = { workspace = true, optional = true }
ente-core.workspace = true
ente-legacy = { workspace = true, optional = true }
+ente-locker = { workspace = true, optional = true }
flutter_rust_bridge.workspace = true
[lints]
diff --git a/rust/bindings/frb/lib/src/lib.rs b/rust/bindings/frb/lib/src/lib.rs
index f5b6507ae1..a22f07adb4 100644
--- a/rust/bindings/frb/lib/src/lib.rs
+++ b/rust/bindings/frb/lib/src/lib.rs
@@ -2,4 +2,6 @@
pub mod contacts;
#[cfg(feature = "legacy")]
pub mod legacy;
+#[cfg(feature = "locker")]
+pub mod locker;
pub mod session;
diff --git a/rust/bindings/frb/lib/src/locker.rs b/rust/bindings/frb/lib/src/locker.rs
new file mode 100644
index 0000000000..9fb7d93b92
--- /dev/null
+++ b/rust/bindings/frb/lib/src/locker.rs
@@ -0,0 +1,53 @@
+use ente_core::crypto::Key;
+use flutter_rust_bridge::frb;
+
+use crate::session::Session;
+
+#[frb(non_opaque)]
+pub enum LockerError {
+ Other { message: String },
+}
+
+impl From<ente_locker::Error> for LockerError {
+ fn from(error: ente_locker::Error) -> Self {
+ Self::Other {
+ message: ente_core::error::chain(&error),
+ }
+ }
+}
+
+#[frb(non_opaque)]
+pub struct PreparedFileLink {
+ pub fragment: String,
+ pub encrypted_file_key: String,
+ pub encrypted_file_key_nonce: String,
+ pub kdf_nonce: String,
+ pub kdf_mem_limit: u32,
+ pub kdf_ops_limit: u32,
+ pub encrypted_share_key: String,
+}
+
+pub fn prepare_file_link(
+ session: &Session,
+ file_key: Vec<u8>,
+) -> Result<PreparedFileLink, LockerError> {
+ let file_key = Key::try_from_slice(&file_key).map_err(ente_locker::Error::from)?;
+ let (fragment, payload) = ente_locker::prepare_file_link_payload(&file_key)?;
+ let encrypted_share_key = ente_locker::seal_file_link_secret(session.as_ref(), &fragment)?;
+ Ok(PreparedFileLink {
+ fragment,
+ encrypted_file_key: payload.encrypted_file_key,
+ encrypted_file_key_nonce: payload.encrypted_file_key_nonce,
+ kdf_nonce: payload.kdf_nonce,
+ kdf_mem_limit: payload.kdf_mem_limit,
+ kdf_ops_limit: payload.kdf_ops_limit,
+ encrypted_share_key,
+ })
+}
+
+pub fn open_file_link_secret(
+ session: &Session,
+ encrypted_share_key: String,
+) -> Result<String, LockerError> {
+ ente_locker::open_file_link_secret(session.as_ref(), &encrypted_share_key).map_err(Into::into)
+}
diff --git a/rust/bindings/frb/locker/Cargo.toml b/rust/bindings/frb/locker/Cargo.toml
index 44a8321ad2..17bf23b1aa 100644
--- a/rust/bindings/frb/locker/Cargo.toml
+++ b/rust/bindings/frb/locker/Cargo.toml
@@ -9,7 +9,7 @@ crate-type = ["cdylib", "staticlib"]
ente-accounts.workspace = true
ente-assets.workspace = true
ente-core.workspace = true
-ente-frb-lib = { workspace = true, features = ["contacts", "legacy"] }
+ente-frb-lib = { workspace = true, features = ["contacts", "legacy", "locker"] }
ente-frb-log.workspace = true
ente-legacy.workspace = true
ente-ml.workspace = true
diff --git a/rust/bindings/wasm/lib/Cargo.toml b/rust/bindings/wasm/lib/Cargo.toml
index 9400ce4bee..d5bfcacc81 100644
--- a/rust/bindings/wasm/lib/Cargo.toml
+++ b/rust/bindings/wasm/lib/Cargo.toml
@@ -13,6 +13,7 @@ contacts = [
crypto = []
crypto-file = ["crypto", "dep:md-5"]
crypto-seal = ["crypto"]
+locker = ["session", "dep:ente-locker"]
prelogin = ["accounts", "crypto"]
session = ["dep:serde", "dep:serde-wasm-bindgen", "dep:tsify"]
@@ -21,6 +22,7 @@ ente-accounts = { workspace = true, optional = true }
ente-collections = { workspace = true, optional = true }
ente-contacts = { workspace = true, optional = true }
ente-core.workspace = true
+ente-locker = { workspace = true, optional = true }
js-sys.workspace = true
log.workspace = true
md-5 = { workspace = true, optional = true }
diff --git a/rust/bindings/wasm/lib/src/collections.rs b/rust/bindings/wasm/lib/src/collections.rs
index 16bdb4c748..e233f8d5a5 100644
--- a/rust/bindings/wasm/lib/src/collections.rs
+++ b/rust/bindings/wasm/lib/src/collections.rs
@@ -2,24 +2,6 @@ use wasm_bindgen::prelude::*;
use crate::session::Session;
-#[wasm_bindgen(js_name = collectionsOpenKey)]
-pub fn open_key(
- session: &Session,
- owner_id: i64,
- encrypted_key: &str,
- key_decryption_nonce: Option<String>,
-) -> Result<String, Error> {
- Ok(ente_core::b64::encode(
- ente_collections::open_collection_key(
- session.inner(),
- owner_id,
- encrypted_key,
- key_decryption_nonce.as_deref(),
- )?
- .as_bytes(),
- ))
-}
-
#[derive(Debug, thiserror::Error)]
#[error(transparent)]
pub struct Error(#[from] ente_collections::Error);
@@ -43,3 +25,21 @@ impl From<Error> for JsValue {
js_error.into()
}
}
+
+#[wasm_bindgen(js_name = collectionsOpenKey)]
+pub fn open_key(
+ session: &Session,
+ owner_id: i64,
+ encrypted_key: &str,
+ key_decryption_nonce: Option<String>,
+) -> Result<String, Error> {
+ Ok(ente_core::b64::encode(
+ ente_collections::open_collection_key(
+ session.inner(),
+ owner_id,
+ encrypted_key,
+ key_decryption_nonce.as_deref(),
+ )?
+ .as_bytes(),
+ ))
+}
diff --git a/rust/bindings/wasm/lib/src/lib.rs b/rust/bindings/wasm/lib/src/lib.rs
index ea70cf49ff..d3fc7b7a2a 100644
--- a/rust/bindings/wasm/lib/src/lib.rs
+++ b/rust/bindings/wasm/lib/src/lib.rs
@@ -6,6 +6,8 @@ pub mod collections;
pub mod contacts;
#[cfg(feature = "crypto")]
pub mod crypto;
+#[cfg(feature = "locker")]
+pub mod locker;
mod logging;
#[cfg(feature = "prelogin")]
mod prelogin;
diff --git a/rust/bindings/wasm/lib/src/locker.rs b/rust/bindings/wasm/lib/src/locker.rs
new file mode 100644
index 0000000000..b9f7f0911e
--- /dev/null
+++ b/rust/bindings/wasm/lib/src/locker.rs
@@ -0,0 +1,75 @@
+use ente_core::{b64, crypto::Key};
+use wasm_bindgen::prelude::*;
+
+use crate::session::Session;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+ #[error(transparent)]
+ Decode(#[from] b64::DecodeError),
+ #[error(transparent)]
+ Crypto(#[from] ente_core::crypto::Error),
+ #[error(transparent)]
+ Locker(#[from] ente_locker::Error),
+}
+
+impl Error {
+ fn message(&self) -> String {
+ ente_core::error::chain(self)
+ }
+}
+
+impl From<Error> for JsValue {
+ fn from(error: Error) -> Self {
+ js_sys::Error::new(&error.message()).into()
+ }
+}
+
+#[wasm_bindgen(getter_with_clone)]
+pub struct PreparedFileLinkPayload {
+ #[wasm_bindgen(readonly)]
+ pub fragment: String,
+ #[wasm_bindgen(readonly, js_name = encryptedFileKey)]
+ pub encrypted_file_key: String,
+ #[wasm_bindgen(readonly, js_name = encryptedFileKeyNonce)]
+ pub encrypted_file_key_nonce: String,
+ #[wasm_bindgen(readonly, js_name = kdfNonce)]
+ pub kdf_nonce: String,
+ #[wasm_bindgen(readonly, js_name = kdfMemLimit)]
+ pub kdf_mem_limit: u32,
+ #[wasm_bindgen(readonly, js_name = kdfOpsLimit)]
+ pub kdf_ops_limit: u32,
+}
+
+#[wasm_bindgen(js_name = lockerPrepareFileLinkPayload)]
+pub fn prepare_file_link_payload(file_key_b64: &str) -> Result<PreparedFileLinkPayload, Error> {
+ let file_key = Key::try_from_slice(&b64::decode(file_key_b64)?)?;
+ let (fragment, payload) = ente_locker::prepare_file_link_payload(&file_key)?;
+ Ok(PreparedFileLinkPayload {
+ fragment,
+ encrypted_file_key: payload.encrypted_file_key,
+ encrypted_file_key_nonce: payload.encrypted_file_key_nonce,
+ kdf_nonce: payload.kdf_nonce,
+ kdf_mem_limit: payload.kdf_mem_limit,
+ kdf_ops_limit: payload.kdf_ops_limit,
+ })
+}
+
+#[wasm_bindgen(js_name = lockerSealFileLinkSecret)]
+pub fn seal_file_link_secret(session: &Session, fragment: &str) -> Result<String, Error> {
+ Ok(ente_locker::seal_file_link_secret(
+ session.inner(),
+ fragment,
+ )?)
+}
+
+#[wasm_bindgen(js_name = lockerOpenFileLinkSecret)]
+pub fn open_file_link_secret(
+ session: &Session,
+ encrypted_share_key: &str,
+) -> Result<String, Error> {
+ Ok(ente_locker::open_file_link_secret(
+ session.inner(),
+ encrypted_share_key,
+ )?)
+}
diff --git a/rust/bindings/wasm/lib/src/session.rs b/rust/bindings/wasm/lib/src/session.rs
index c4f3ac8246..b4c62bc1fb 100644
--- a/rust/bindings/wasm/lib/src/session.rs
+++ b/rust/bindings/wasm/lib/src/session.rs
@@ -9,6 +9,38 @@ use serde::Deserialize;
use tsify::{Ts, Tsify};
use wasm_bindgen::prelude::*;
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+ #[error(transparent)]
+ Input(#[from] tsify::Error),
+ #[error(transparent)]
+ Http(#[from] ente_core::http::Error),
+ #[error(transparent)]
+ Decode(#[from] b64::DecodeError),
+ #[error(transparent)]
+ Crypto(#[from] crypto::Error),
+}
+
+impl Error {
+ fn name(&self) -> Option<&'static str> {
+ None
+ }
+
+ fn message(&self) -> String {
+ ente_core::error::chain(self)
+ }
+}
+
+impl From<Error> for JsValue {
+ fn from(error: Error) -> Self {
+ let js_error = js_sys::Error::new(&error.message());
+ if let Some(name) = error.name() {
+ js_error.set_name(name);
+ }
+ js_error.into()
+ }
+}
+
#[derive(Deserialize, Tsify)]
#[serde(rename_all = "camelCase")]
pub struct SessionKeyAttributes {
@@ -84,35 +116,3 @@ impl Session {
self.0.api.set_auth(Some(Auth::User(auth_token)));
}
}
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
- #[error(transparent)]
- Input(#[from] tsify::Error),
- #[error(transparent)]
- Http(#[from] ente_core::http::Error),
- #[error(transparent)]
- Decode(#[from] b64::DecodeError),
- #[error(transparent)]
- Crypto(#[from] crypto::Error),
-}
-
-impl Error {
- fn name(&self) -> Option<&'static str> {
- None
- }
-
- fn message(&self) -> String {
- ente_core::error::chain(self)
- }
-}
-
-impl From<Error> for JsValue {
- fn from(error: Error) -> Self {
- let js_error = js_sys::Error::new(&error.message());
- if let Some(name) = error.name() {
- js_error.set_name(name);
- }
- js_error.into()
- }
-}
diff --git a/rust/bindings/wasm/locker/Cargo.toml b/rust/bindings/wasm/locker/Cargo.toml
index 9ccd8d1b06..087d0867ff 100644
--- a/rust/bindings/wasm/locker/Cargo.toml
+++ b/rust/bindings/wasm/locker/Cargo.toml
@@ -6,7 +6,7 @@ edition.workspace = true
crate-type = ["cdylib"]
[dependencies]
-ente-wasm-lib = { workspace = true, features = ["accounts", "collections", "contacts", "crypto-file", "crypto-seal"] }
+ente-wasm-lib = { workspace = true, features = ["collections", "contacts", "crypto-file", "crypto-seal", "locker"] }
[lints]
workspace = true
diff --git a/rust/crates/locker/Cargo.toml b/rust/crates/locker/Cargo.toml
new file mode 100644
index 0000000000..98c5090d1c
--- /dev/null
+++ b/rust/crates/locker/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "ente-locker"
+edition.workspace = true
+
+[dependencies]
+ente-core.workspace = true
+thiserror.workspace = true
+
+[lints]
+workspace = true
diff --git a/rust/crates/locker/src/lib.rs b/rust/crates/locker/src/lib.rs
new file mode 100644
index 0000000000..fd557cb19f
--- /dev/null
+++ b/rust/crates/locker/src/lib.rs
@@ -0,0 +1,138 @@
+use std::string::FromUtf8Error;
+
+use ente_core::{
+ Session, b64,
+ crypto::{self, Key, argon, sealed, secretbox},
+};
+
+const FRAGMENT_LENGTH: usize = 12;
+const FRAGMENT_ALPHABET: &[u8] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const MAX_UNBIASED_BYTE: u8 = (256 - 256 % FRAGMENT_ALPHABET.len()) as u8;
+
+pub struct FileLinkPayload {
+ pub encrypted_file_key: String,
+ pub encrypted_file_key_nonce: String,
+ pub kdf_nonce: String,
+ pub kdf_mem_limit: u32,
+ pub kdf_ops_limit: u32,
+}
+
+pub fn prepare_file_link_payload(file_key: &Key) -> Result<(String, FileLinkPayload)> {
+ let fragment = generate_fragment();
+ let derived = argon::derive_interactive_key(&fragment)?;
+ let encrypted = secretbox::encrypt(file_key.as_bytes(), &derived.key);
+ let payload = FileLinkPayload {
+ encrypted_file_key: b64::encode(&encrypted.encrypted_data),
+ encrypted_file_key_nonce: b64::encode(encrypted.nonce.as_bytes()),
+ kdf_nonce: b64::encode(derived.salt.as_bytes()),
+ kdf_mem_limit: derived.params.mem_limit,
+ kdf_ops_limit: derived.params.ops_limit,
+ };
+ Ok((fragment, payload))
+}
+
+pub fn seal_file_link_secret(session: &Session, fragment: &str) -> Result<String> {
+ let encoded = b64::encode(fragment.as_bytes());
+ let encrypted = sealed::seal(encoded.as_bytes(), &session.secret_key.public_key())?;
+ Ok(b64::encode(&encrypted))
+}
+
+pub fn open_file_link_secret(session: &Session, encrypted_share_key: &str) -> Result<String> {
+ let encrypted = b64::decode(encrypted_share_key)?;
+ let encoded = sealed::open(
+ &encrypted,
+ &session.secret_key.public_key(),
+ &session.secret_key,
+ )?;
+ let encoded = String::from_utf8(encoded)?;
+ Ok(String::from_utf8(b64::decode(&encoded)?)?)
+}
+
+fn generate_fragment() -> String {
+ let mut fragment = String::with_capacity(FRAGMENT_LENGTH);
+ while fragment.len() < FRAGMENT_LENGTH {
+ for byte in crypto::random_bytes(FRAGMENT_LENGTH - fragment.len()) {
+ if byte < MAX_UNBIASED_BYTE {
+ fragment.push(FRAGMENT_ALPHABET[(byte as usize) % FRAGMENT_ALPHABET.len()] as char);
+ }
+ }
+ }
+ fragment
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+ #[error(transparent)]
+ Decode(#[from] b64::DecodeError),
+ #[error(transparent)]
+ Crypto(#[from] crypto::Error),
+ #[error(transparent)]
+ Utf8(#[from] FromUtf8Error),
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use ente_core::{
+ crypto::{Nonce, Salt, SecretKey},
+ http::ApiConfig,
+ };
+
+ #[test]
+ fn prepares_and_opens_file_link_secrets() {
+ let session = Session::new(
+ ApiConfig {
+ origin: "http://localhost".into(),
+ client_package: None,
+ client_version: None,
+ user_agent: None,
+ auth: None,
+ },
+ 1,
+ Key::generate(),
+ SecretKey::generate(),
+ )
+ .unwrap();
+ let file_key = Key::generate();
+
+ let (fragment, payload) = prepare_file_link_payload(&file_key).unwrap();
+ assert_eq!(fragment.len(), FRAGMENT_LENGTH);
+ assert!(fragment.bytes().all(|byte| byte.is_ascii_alphanumeric()));
+
+ let derived = argon::derive_key(
+ &fragment,
+ &Salt::try_from_slice(&b64::decode(&payload.kdf_nonce).unwrap()).unwrap(),
+ argon::Params {
+ mem_limit: payload.kdf_mem_limit,
+ ops_limit: payload.kdf_ops_limit,
+ },
+ )
+ .unwrap();
+ let opened_file_key = secretbox::decrypt(
+ &b64::decode(&payload.encrypted_file_key).unwrap(),
+ &Nonce::try_from_slice(&b64::decode(&payload.encrypted_file_key_nonce).unwrap())
+ .unwrap(),
+ &derived,
+ )
+ .unwrap();
+ assert_eq!(opened_file_key, file_key.as_bytes());
+
+ let encrypted_share_key = seal_file_link_secret(&session, &fragment).unwrap();
+ let sealed_plaintext = sealed::open(
+ &b64::decode(&encrypted_share_key).unwrap(),
+ &session.secret_key.public_key(),
+ &session.secret_key,
+ )
+ .unwrap();
+ assert_eq!(
+ sealed_plaintext,
+ b64::encode(fragment.as_bytes()).as_bytes()
+ );
+ assert_eq!(
+ open_file_link_secret(&session, &encrypted_share_key).unwrap(),
+ fragment,
+ );
+ }
+}
diff --git a/web/apps/locker/src/services/account-keys.ts b/web/apps/locker/src/services/account-keys.ts
index 518fe4ba51..a2da3b763f 100644
--- a/web/apps/locker/src/services/account-keys.ts
+++ b/web/apps/locker/src/services/account-keys.ts
@@ -1,7 +1,4 @@
import { masterKeyFromSession as readMasterKeyFromSession } from "ente-accounts/services/session-storage";
-import { ensureUserKeyPair as readUserKeyPair } from "ente-accounts/services/user";
import { decryptBox } from "ente-locker-wasm";
export const masterKeyFromSession = () => readMasterKeyFromSession(decryptBox);
-
-export const ensureUserKeyPair = () => readUserKeyPair(decryptBox);
diff --git a/web/apps/locker/src/services/remote.ts b/web/apps/locker/src/services/remote.ts
index 742dcaa3cc..0b9fcbe4c6 100644
--- a/web/apps/locker/src/services/remote.ts
+++ b/web/apps/locker/src/services/remote.ts
@@ -9,19 +9,17 @@ import { authenticatedRequestHeaders, ensureOk } from "ente-base/http";
import log from "ente-base/log";
import { apiURL } from "ente-base/origins";
import {
- b64ToBytes,
- boxSeal,
- boxSealOpen,
decryptBox,
decryptMetadataJSON,
- deriveInteractiveKey,
encryptBlob,
encryptBox,
generateKey,
+ openFileLinkSecret,
+ prepareFileLink,
stringToB64,
} from "ente-locker-wasm";
import { z } from "zod";
-import { ensureUserKeyPair } from "./account-keys";
+import { ensureAuthenticatedSession } from "./authenticated-session";
import {
clearLockerCache,
findCollectionByType,
@@ -72,8 +70,6 @@ export {
syncLockerState,
};
-const utf8Decoder = new TextDecoder();
-
const RemoteFileShareLink = z.object({
linkID: z.union([z.string(), z.number().transform(String)]),
url: z.string(),
@@ -113,66 +109,6 @@ export interface LockerFileShareLinkSummary {
passwordEnabled: boolean;
}
-const decodeUTF8B64 = (b64: string) => utf8Decoder.decode(b64ToBytes(b64));
-
-const generateBase62Secret = (length: number) => {
- const charset =
- "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
- const charsetLength = charset.length;
- const maxUnbiasedValue = 256 - (256 % charsetLength);
- let secret = "";
-
- while (secret.length < length) {
- const randomValues = crypto.getRandomValues(
- new Uint8Array(length - secret.length),
- );
- for (const value of randomValues) {
- if (value >= maxUnbiasedValue) continue;
- secret += charset[value % charsetLength]!;
- }
- }
-
- return secret;
-};
-
-const prepareFileLinkSecretPayload = async (fileKey: string) => {
- const secret = generateBase62Secret(12);
- const secretB64 = stringToB64(secret);
- const derivedKey = await deriveInteractiveKey(secret);
- const encryptedFileKey = await encryptBox(fileKey, derivedKey.key);
- const keyPair = await ensureUserKeyPair();
- const encryptedShareKey = await boxSeal(
- stringToB64(secretB64),
- keyPair.publicKey,
- );
-
- return {
- secret,
- metadata: {
- encryptedFileKey: encryptedFileKey.encryptedData,
- encryptedFileKeyNonce: encryptedFileKey.nonce,
- kdfNonce: derivedKey.salt,
- kdfMemLimit: derivedKey.memLimit,
- kdfOpsLimit: derivedKey.opsLimit,
- encryptedShareKey,
- },
- };
-};
-
-const resolveFileLinkSecret = async (
- link: z.infer<typeof RemoteFileShareLink>,
- generatedSecret: string,
-) => {
- if (!link.encryptedShareKey) {
- return generatedSecret;
- }
-
- const decryptedSecretB64 = decodeUTF8B64(
- await boxSealOpen(link.encryptedShareKey, await ensureUserKeyPair()),
- );
- return decodeUTF8B64(decryptedSecretB64);
-};
-
const infoItemTitle = (
infoType: LockerItemType,
infoData: Record<string, unknown>,
@@ -222,7 +158,8 @@ export const getOrCreateLockerFileShareLink = async (
}
const fileKey = await decryptFileKeyForRecord(fileRecord);
- const payload = await prepareFileLinkSecretPayload(fileKey);
+ const session = await ensureAuthenticatedSession();
+ const payload = await prepareFileLink(session, fileKey);
const res = await fetch(await apiURL("/files/share-url"), {
method: "POST",
@@ -235,7 +172,9 @@ export const getOrCreateLockerFileShareLink = async (
ensureOk(res);
const link = RemoteFileShareLink.parse(await res.json());
- const secret = await resolveFileLinkSecret(link, payload.secret);
+ const secret = link.encryptedShareKey
+ ? await openFileLinkSecret(session, link.encryptedShareKey)
+ : payload.secret;
return {
linkID: link.linkID,
diff --git a/web/packages/accounts/services/user.ts b/web/packages/accounts/services/user.ts
index 32d6e8aaeb..9afb76e6c5 100644
--- a/web/packages/accounts/services/user.ts
+++ b/web/packages/accounts/services/user.ts
@@ -17,10 +17,6 @@ import {
toB64URLSafe,
} from "ente-accounts/services/crypto";
import { ensureMasterKeyFromSession } from "ente-accounts/services/prelogin-session";
-import {
- ensureMasterKeyFromSession as readMasterKeyFromSession,
- type DecryptBox,
-} from "ente-accounts/services/session-storage";
import {
generateSRPSetupAttributes,
getAndSaveSRPAttributes,
@@ -103,23 +99,6 @@ export const RemoteKeyAttributes = z.object({
export const ensureSavedKeyAttributes = (): KeyAttributes =>
ensureExpectedLoggedInValue(savedKeyAttributes());
-export interface UserKeyPair {
- publicKey: string;
- privateKey: string;
-}
-
-export const ensureUserKeyPair = async (
- decrypt: DecryptBox,
-): Promise<UserKeyPair> => {
- const { encryptedSecretKey, secretKeyDecryptionNonce, publicKey } =
- ensureSavedKeyAttributes();
- const privateKey = await decrypt(
- { encryptedData: encryptedSecretKey, nonce: secretKeyDecryptionNonce },
- await readMasterKeyFromSession(decrypt),
- );
- return { publicKey, privateKey };
-};
-
export const getPublicKey = async (email: string) => {
const res = await fetch(await apiURL("/users/public-key", { email }), {
headers: await authenticatedRequestHeaders(),
diff --git a/web/packages/wasm/locker/file-link.worker.ts b/web/packages/wasm/locker/file-link.worker.ts
new file mode 100644
index 0000000000..04842868e0
--- /dev/null
+++ b/web/packages/wasm/locker/file-link.worker.ts
@@ -0,0 +1,21 @@
+import { expose } from "comlink";
+import { readAndFree } from "ente-utils/wasm";
+
+export class FileLinkWorker {
+ async prepareFileLinkPayload(fileKeyB64: string) {
+ const wasm = await import("./pkg/ente_locker_wasm");
+ return readAndFree(
+ wasm.lockerPrepareFileLinkPayload(fileKeyB64),
+ (payload) => ({
+ fragment: payload.fragment,
+ encryptedFileKey: payload.encryptedFileKey,
+ encryptedFileKeyNonce: payload.encryptedFileKeyNonce,
+ kdfNonce: payload.kdfNonce,
+ kdfMemLimit: payload.kdfMemLimit,
+ kdfOpsLimit: payload.kdfOpsLimit,
+ }),
+ );
+ }
+}
+
+expose(FileLinkWorker);
diff --git a/web/packages/wasm/locker/index.ts b/web/packages/wasm/locker/index.ts
index a29404e287..26eff879bf 100644
--- a/web/packages/wasm/locker/index.ts
+++ b/web/packages/wasm/locker/index.ts
@@ -1,6 +1,6 @@
import { wrap } from "comlink";
import { readAndFree } from "ente-utils/wasm";
-import type { KDFWorker } from "./kdf.worker";
+import type { FileLinkWorker } from "./file-link.worker";
import type {
OpenSessionInput,
Session,
@@ -65,22 +65,37 @@ interface EncryptedBox {
nonce: BytesOrB64;
}
-interface KeyPair {
- publicKey: string;
- privateKey: string;
-}
-
-export const deriveInteractiveKey = async (password: string) => {
- const worker = new Worker(new URL("kdf.worker.ts", import.meta.url));
+export const prepareFileLink = async (session: Session, fileKeyB64: string) => {
+ const worker = new Worker(new URL("file-link.worker.ts", import.meta.url));
try {
- const RemoteWorker = wrap<typeof KDFWorker>(worker);
+ const RemoteWorker = wrap<typeof FileLinkWorker>(worker);
const remote = await new RemoteWorker();
- return await remote.deriveInteractiveKey(password);
+ const payload = await remote.prepareFileLinkPayload(fileKeyB64);
+ const encryptedShareKey = (await wasm()).lockerSealFileLinkSecret(
+ session,
+ payload.fragment,
+ );
+ return {
+ secret: payload.fragment,
+ metadata: {
+ encryptedFileKey: payload.encryptedFileKey,
+ encryptedFileKeyNonce: payload.encryptedFileKeyNonce,
+ kdfNonce: payload.kdfNonce,
+ kdfMemLimit: payload.kdfMemLimit,
+ kdfOpsLimit: payload.kdfOpsLimit,
+ encryptedShareKey,
+ },
+ };
} finally {
worker.terminate();
}
};
+export const openFileLinkSecret = async (
+ session: Session,
+ encryptedShareKey: string,
+) => (await wasm()).lockerOpenFileLinkSecret(session, encryptedShareKey);
+
export const generateKey = async () => (await wasm()).cryptoGenerateKey();
export const encryptBox = async (dataB64: string, keyB64: string) =>
@@ -144,16 +159,6 @@ export const boxSeal = async (
publicKeyB64: string,
): Promise<string> => (await wasm()).cryptoBoxSeal(dataB64, publicKeyB64);
-export const boxSealOpen = async (
- encryptedData: string,
- keyPair: KeyPair,
-): Promise<string> =>
- (await wasm()).cryptoBoxSealOpen(
- encryptedData,
- keyPair.publicKey,
- keyPair.privateKey,
- );
-
export const md5Base64 = async (data: Uint8Array) =>
(await wasm()).cryptoMd5Base64(data);
diff --git a/web/packages/wasm/locker/kdf.worker.ts b/web/packages/wasm/locker/kdf.worker.ts
deleted file mode 100644
index c767ce4095..0000000000
--- a/web/packages/wasm/locker/kdf.worker.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { expose } from "comlink";
-import { readAndFree } from "ente-utils/wasm";
-
-export class KDFWorker {
- async deriveInteractiveKey(password: string) {
- const wasm = await import("./pkg/ente_locker_wasm");
- return readAndFree(
- wasm.authGenerateInteractiveKek(password),
- (key) => ({
- key: key.key,
- salt: key.salt,
- opsLimit: key.opsLimit,
- memLimit: key.memLimit,
- }),
- );
- }
-}
-
-expose(KDFWorker);