Skip to content

armgit / ente

Public Imported from GitHub
0

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

Add focused Ensu WASM bindings

Manav Rathifb732d66e420
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index e9ec103ab0..d262e99f1b 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -2351,6 +2351,7 @@ dependencies = [
"ente-assets",
"ente-core",
"ente-ensu",
+ "ente-ensu-crypto",
"keyring",
"libc",
"log",
@@ -2509,6 +2510,7 @@ version = "0.0.0"
dependencies = [
"ente-assets",
"ente-core",
+ "ente-ensu-crypto",
"ente-image",
"llama-cpp-2",
"memmap2",
@@ -2530,6 +2532,16 @@ dependencies = [
"zstd",
]
+[[package]]
+name = "ente-ensu-crypto"
+version = "0.0.0"
+dependencies = [
+ "ente-core",
+ "hkdf 0.13.0",
+ "sha2 0.11.0",
+ "thiserror 2.0.18",
+]
+
[[package]]
name = "ente-ensu-uniffi"
version = "0.0.0"
@@ -2542,6 +2554,16 @@ dependencies = [
"uuid",
]
+[[package]]
+name = "ente-ensu-wasm"
+version = "0.0.0"
+dependencies = [
+ "ente-ensu-crypto",
+ "ente-wasm-log",
+ "js-sys",
+ "wasm-bindgen",
+]
+
[[package]]
name = "ente-frb-log"
version = "0.0.0"
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 194bcc04dd..6dc2e4545c 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -13,6 +13,7 @@ members = [
"bindings/uniffi/log",
"bindings/wasm/cast",
"bindings/wasm/core",
+ "bindings/wasm/ensu",
"bindings/wasm/log",
"bindings/wasm/paste",
"bindings/wasm/space",
@@ -22,6 +23,7 @@ members = [
"crates/contacts",
"crates/core",
"crates/ensu",
+ "crates/ensu-crypto",
"crates/image",
"crates/ml",
"crates/paste",
@@ -37,6 +39,7 @@ ente-cast = { path = "crates/cast" }
ente-contacts = { path = "crates/contacts" }
ente-core = { path = "crates/core" }
ente-ensu = { path = "crates/ensu" }
+ente-ensu-crypto = { path = "crates/ensu-crypto" }
ente-frb-log = { path = "bindings/frb/log" }
ente-image = { path = "crates/image" }
ente-ml = { path = "crates/ml" }
@@ -48,6 +51,7 @@ ente-uniffi-log = { path = "bindings/uniffi/log" }
ente-wasm-log = { path = "bindings/wasm/log" }
flutter_rust_bridge = "=2.12.0"
flutter_rust_bridge_codegen = "=2.12.0"
+hkdf = "0.13.0"
js-sys = "0.3.102"
log = "0.4.29"
md-5 = "0.11.0"
diff --git a/rust/apps/ensu/src-tauri/Cargo.toml b/rust/apps/ensu/src-tauri/Cargo.toml
index fa3d7b8f7d..cff1278706 100644
--- a/rust/apps/ensu/src-tauri/Cargo.toml
+++ b/rust/apps/ensu/src-tauri/Cargo.toml
@@ -10,6 +10,7 @@ tauri-build = { version = "2.6.2", features = [] }
ente-assets.workspace = true
ente-core.workspace = true
ente-ensu.workspace = true
+ente-ensu-crypto.workspace = true
keyring = { version = "3", default-features = false, features = ["apple-native", "windows-native", "linux-native-sync-persistent", "crypto-rust"] }
log.workspace = true
serde.workspace = true
diff --git a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs b/rust/apps/ensu/src-tauri/src/commands/chat_db.rs
index fd9a4e3c51..7c27f94734 100644
--- a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs
+++ b/rust/apps/ensu/src-tauri/src/commands/chat_db.rs
@@ -399,7 +399,8 @@ pub async fn chat_db_open(
let root = app_data_dir(&app)?;
let path = chat_db_path(&app)?;
let attachments = attachments_dir_path(&app)?;
- let key = b64::decode(&input.key_b64).map_err(ApiError::from)?;
+ let key = b64::decode(&input.key_b64)
+ .map_err(|error| ApiError::new("base64_decode", error.to_string()))?;
let recovery_keys = input
.recovery_keys_b64
.iter()
diff --git a/rust/apps/ensu/src-tauri/src/commands/crypto.rs b/rust/apps/ensu/src-tauri/src/commands/crypto.rs
index 843671b792..1392b48bb6 100644
--- a/rust/apps/ensu/src-tauri/src/commands/crypto.rs
+++ b/rust/apps/ensu/src-tauri/src/commands/crypto.rs
@@ -1,92 +1,97 @@
-use ente_core::b64;
-use ente_core::crypto;
use serde::{Deserialize, Serialize};
use crate::commands::common::ApiError;
-impl From<crypto::Error> for ApiError {
- fn from(e: crypto::Error) -> Self {
- use crypto::Error as E;
-
- let code = match &e {
- E::InvalidKeyLength { .. } => "invalid_key_length",
- E::InvalidNonceLength { .. } => "invalid_nonce_length",
- E::InvalidSaltLength { .. } => "invalid_salt_length",
- E::InvalidHeaderLength { .. } => "invalid_header_length",
- E::CiphertextTooShort { .. } => "ciphertext_too_short",
- E::InvalidKeyDerivationParams(_) => "invalid_kdf_params",
- E::KeyDerivationFailed => "key_derivation_failed",
- E::EncryptionFailed => "encryption_failed",
- E::DecryptionFailed => "decryption_failed",
- E::StreamInitFailed => "stream_init_failed",
- E::StreamPushFailed => "stream_push_failed",
- E::StreamPullFailed => "stream_pull_failed",
- E::StreamTruncated => "stream_truncated",
- E::StreamTrailingData => "stream_trailing_data",
- E::SealedBoxOpenFailed => "sealed_box_open_failed",
- E::InvalidPublicKey => "invalid_public_key",
- E::Json(_) => "json",
- E::Argon2(_) => "argon2",
- E::Aead => "aead",
- E::ArrayConversion => "array_conversion",
- E::Io(_) => "io",
- };
-
- ApiError::new(code, e.to_string())
- }
-}
-
-impl From<b64::DecodeError> for ApiError {
- fn from(e: b64::DecodeError) -> Self {
- ApiError::new("base64_decode", e.to_string())
+impl From<ente_ensu_crypto::Error> for ApiError {
+ fn from(error: ente_ensu_crypto::Error) -> Self {
+ ApiError::new(error.code(), error.to_string())
}
}
#[derive(Serialize)]
-pub struct EncryptedBlob {
+#[serde(rename_all = "camelCase")]
+pub struct EncryptedChatPayload {
encrypted_data: String,
- decryption_header: String,
+ header: String,
+}
+
+impl From<ente_ensu_crypto::EncryptedChatPayload> for EncryptedChatPayload {
+ fn from(payload: ente_ensu_crypto::EncryptedChatPayload) -> Self {
+ Self {
+ encrypted_data: payload.encrypted_data,
+ header: payload.header,
+ }
+ }
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
-pub struct CryptoBlobInput {
- data_b64: String,
+pub struct PayloadEncryptInput {
+ value: String,
key_b64: String,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
-pub struct CryptoBlobDecryptInput {
+pub struct PayloadDecryptInput {
encrypted_data_b64: String,
header_b64: String,
key_b64: String,
}
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FieldInput {
+ value: String,
+ key_b64: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AttachmentInput {
+ data_b64: String,
+ key_b64: String,
+ session_uuid: String,
+}
+
+#[tauri::command]
+pub fn chat_crypto_generate_key() -> String {
+ ente_ensu_crypto::generate_chat_key()
+}
+
+#[tauri::command]
+pub fn chat_crypto_encrypt_payload(
+ input: PayloadEncryptInput,
+) -> Result<EncryptedChatPayload, ApiError> {
+ ente_ensu_crypto::encrypt_payload(&input.value, &input.key_b64)
+ .map(Into::into)
+ .map_err(Into::into)
+}
+
+#[tauri::command]
+pub fn chat_crypto_decrypt_payload(input: PayloadDecryptInput) -> Result<String, ApiError> {
+ ente_ensu_crypto::decrypt_payload(&input.encrypted_data_b64, &input.header_b64, &input.key_b64)
+ .map_err(Into::into)
+}
+
+#[tauri::command]
+pub fn chat_crypto_encrypt_field(input: FieldInput) -> Result<String, ApiError> {
+ ente_ensu_crypto::encrypt_field_b64(&input.value, &input.key_b64).map_err(Into::into)
+}
+
#[tauri::command]
-pub fn crypto_generate_key() -> String {
- b64::encode(crypto::Key::generate().as_bytes())
+pub fn chat_crypto_decrypt_field(input: FieldInput) -> Result<String, ApiError> {
+ ente_ensu_crypto::decrypt_field_b64(&input.value, &input.key_b64).map_err(Into::into)
}
#[tauri::command]
-pub fn crypto_encrypt_blob(input: CryptoBlobInput) -> Result<EncryptedBlob, ApiError> {
- let data = b64::decode(&input.data_b64).map_err(ApiError::from)?;
- let key = b64::decode(&input.key_b64).map_err(ApiError::from)?;
- let key = crypto::Key::try_from_slice(&key).map_err(ApiError::from)?;
- let out = crypto::blob::encrypt(&data, &key).map_err(ApiError::from)?;
- Ok(EncryptedBlob {
- encrypted_data: b64::encode(&out.encrypted_data),
- decryption_header: b64::encode(out.decryption_header.as_bytes()),
- })
+pub fn chat_crypto_encrypt_attachment(input: AttachmentInput) -> Result<String, ApiError> {
+ ente_ensu_crypto::encrypt_attachment_b64(&input.data_b64, &input.key_b64, &input.session_uuid)
+ .map_err(Into::into)
}
#[tauri::command]
-pub fn crypto_decrypt_blob(input: CryptoBlobDecryptInput) -> Result<String, ApiError> {
- let ciphertext = b64::decode(&input.encrypted_data_b64).map_err(ApiError::from)?;
- let header = b64::decode(&input.header_b64).map_err(ApiError::from)?;
- let key = b64::decode(&input.key_b64).map_err(ApiError::from)?;
- let header = crypto::Header::try_from_slice(&header).map_err(ApiError::from)?;
- let key = crypto::Key::try_from_slice(&key).map_err(ApiError::from)?;
- let plaintext = crypto::blob::decrypt(&ciphertext, &header, &key).map_err(ApiError::from)?;
- Ok(b64::encode(&plaintext))
+pub fn chat_crypto_decrypt_attachment(input: AttachmentInput) -> Result<String, ApiError> {
+ ente_ensu_crypto::decrypt_attachment_b64(&input.data_b64, &input.key_b64, &input.session_uuid)
+ .map_err(Into::into)
}
diff --git a/rust/apps/ensu/src-tauri/src/main.rs b/rust/apps/ensu/src-tauri/src/main.rs
index 7baef9b403..ac037e0e85 100644
--- a/rust/apps/ensu/src-tauri/src/main.rs
+++ b/rust/apps/ensu/src-tauri/src/main.rs
@@ -35,9 +35,13 @@ fn main() {
Ok(())
})
.invoke_handler(tauri::generate_handler![
- commands::crypto::crypto_generate_key,
- commands::crypto::crypto_encrypt_blob,
- commands::crypto::crypto_decrypt_blob,
+ commands::crypto::chat_crypto_generate_key,
+ commands::crypto::chat_crypto_encrypt_payload,
+ commands::crypto::chat_crypto_decrypt_payload,
+ commands::crypto::chat_crypto_encrypt_field,
+ commands::crypto::chat_crypto_decrypt_field,
+ commands::crypto::chat_crypto_encrypt_attachment,
+ commands::crypto::chat_crypto_decrypt_attachment,
commands::secure_storage::secure_storage_get,
commands::secure_storage::secure_storage_set,
commands::secure_storage::secure_storage_delete,
diff --git a/rust/bindings/wasm/ensu/Cargo.toml b/rust/bindings/wasm/ensu/Cargo.toml
new file mode 100644
index 0000000000..e8096ef359
--- /dev/null
+++ b/rust/bindings/wasm/ensu/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "ente-ensu-wasm"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+ente-ensu-crypto.workspace = true
+ente-wasm-log.workspace = true
+js-sys.workspace = true
+wasm-bindgen.workspace = true
diff --git a/rust/bindings/wasm/ensu/src/lib.rs b/rust/bindings/wasm/ensu/src/lib.rs
new file mode 100644
index 0000000000..a4255b9260
--- /dev/null
+++ b/rust/bindings/wasm/ensu/src/lib.rs
@@ -0,0 +1,83 @@
+use ente_wasm_log as _;
+use wasm_bindgen::prelude::*;
+
+pub struct WasmError(ente_ensu_crypto::Error);
+
+impl From<ente_ensu_crypto::Error> for WasmError {
+ fn from(error: ente_ensu_crypto::Error) -> Self {
+ Self(error)
+ }
+}
+
+impl From<WasmError> for JsValue {
+ fn from(error: WasmError) -> Self {
+ let js_error = js_sys::Error::new(&error.0.to_string());
+ js_error.set_name(error.0.code());
+ js_error.into()
+ }
+}
+
+#[wasm_bindgen]
+pub struct EncryptedChatPayload(ente_ensu_crypto::EncryptedChatPayload);
+
+#[wasm_bindgen]
+impl EncryptedChatPayload {
+ #[wasm_bindgen(getter, js_name = encryptedData)]
+ pub fn encrypted_data(&self) -> String {
+ self.0.encrypted_data.clone()
+ }
+
+ #[wasm_bindgen(getter)]
+ pub fn header(&self) -> String {
+ self.0.header.clone()
+ }
+}
+
+#[wasm_bindgen(js_name = generateChatKey)]
+pub fn generate_chat_key() -> String {
+ ente_ensu_crypto::generate_chat_key()
+}
+
+#[wasm_bindgen(js_name = encryptChatPayload)]
+pub fn encrypt_chat_payload(value: &str, key_b64: &str) -> Result<EncryptedChatPayload, WasmError> {
+ ente_ensu_crypto::encrypt_payload(value, key_b64)
+ .map(EncryptedChatPayload)
+ .map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = decryptChatPayload)]
+pub fn decrypt_chat_payload(
+ encrypted_data_b64: &str,
+ header_b64: &str,
+ key_b64: &str,
+) -> Result<String, WasmError> {
+ ente_ensu_crypto::decrypt_payload(encrypted_data_b64, header_b64, key_b64).map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = encryptChatField)]
+pub fn encrypt_chat_field(value: &str, key_b64: &str) -> Result<String, WasmError> {
+ ente_ensu_crypto::encrypt_field_b64(value, key_b64).map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = decryptChatField)]
+pub fn decrypt_chat_field(value: &str, key_b64: &str) -> Result<String, WasmError> {
+ ente_ensu_crypto::decrypt_field_b64(value, key_b64).map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = encryptChatAttachment)]
+pub fn encrypt_chat_attachment(
+ data: &[u8],
+ key_b64: &str,
+ session_uuid: &str,
+) -> Result<Vec<u8>, WasmError> {
+ ente_ensu_crypto::encrypt_attachment(data, key_b64, session_uuid).map_err(Into::into)
+}
+
+#[wasm_bindgen(js_name = decryptChatAttachment)]
+pub fn decrypt_chat_attachment(
+ data: &[u8],
+ key_b64: &str,
+ session_uuid: &str,
+) -> Result<Vec<u8>, WasmError> {
+ ente_ensu_crypto::decrypt_attachment(data, key_b64, session_uuid).map_err(Into::into)
+}
diff --git a/rust/crates/ensu-crypto/Cargo.toml b/rust/crates/ensu-crypto/Cargo.toml
new file mode 100644
index 0000000000..6575cc9075
--- /dev/null
+++ b/rust/crates/ensu-crypto/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "ente-ensu-crypto"
+edition = "2024"
+
+[dependencies]
+ente-core.workspace = true
+hkdf.workspace = true
+sha2.workspace = true
+thiserror.workspace = true
diff --git a/rust/crates/ensu-crypto/src/lib.rs b/rust/crates/ensu-crypto/src/lib.rs
new file mode 100644
index 0000000000..2e11c36061
--- /dev/null
+++ b/rust/crates/ensu-crypto/src/lib.rs
@@ -0,0 +1,226 @@
+use ente_core::{
+ b64,
+ crypto::{self, Header, Key, blob},
+};
+use hkdf::Hkdf;
+use sha2::Sha256;
+use thiserror::Error;
+
+const ATTACHMENT_KEY_INFO: &[u8] = b"llmchat_attachment_v1";
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, Error)]
+pub enum Error {
+ #[error("invalid blob length: expected at least {minimum} bytes, got {actual}")]
+ InvalidBlobLength { minimum: usize, actual: usize },
+
+ #[error("invalid encrypted field format")]
+ InvalidEncryptedField,
+
+ #[error(transparent)]
+ Crypto(#[from] crypto::Error),
+
+ #[error(transparent)]
+ Base64Decode(#[from] b64::DecodeError),
+
+ #[error(transparent)]
+ Utf8(#[from] std::string::FromUtf8Error),
+}
+
+impl Error {
+ pub fn code(&self) -> &'static str {
+ match self {
+ Self::InvalidBlobLength { .. } => "invalid_blob_length",
+ Self::InvalidEncryptedField => "invalid_encrypted_field",
+ Self::Crypto(error) => error.code(),
+ Self::Base64Decode(_) => "base64_decode",
+ Self::Utf8(_) => "invalid_utf8",
+ }
+ }
+}
+
+pub struct EncryptedChatPayload {
+ pub encrypted_data: String,
+ pub header: String,
+}
+
+pub fn generate_chat_key() -> String {
+ b64::encode(Key::generate().as_bytes())
+}
+
+pub fn encrypt_payload(value: &str, key_b64: &str) -> Result<EncryptedChatPayload> {
+ let encrypted = blob::encrypt(value.as_bytes(), &key_from_b64(key_b64)?)?;
+ Ok(EncryptedChatPayload {
+ encrypted_data: b64::encode(&encrypted.encrypted_data),
+ header: b64::encode(encrypted.decryption_header.as_bytes()),
+ })
+}
+
+pub fn decrypt_payload(
+ encrypted_data_b64: &str,
+ header_b64: &str,
+ key_b64: &str,
+) -> Result<String> {
+ let encrypted_data = b64::decode(encrypted_data_b64)?;
+ let header = b64::decode(header_b64)?;
+ let plaintext = blob::decrypt(
+ &encrypted_data,
+ &Header::try_from_slice(&header)?,
+ &key_from_b64(key_b64)?,
+ )?;
+ Ok(String::from_utf8(plaintext)?)
+}
+
+pub fn encrypt_field_b64(value: &str, key_b64: &str) -> Result<String> {
+ encrypt_json_field(value, &b64::decode(key_b64)?)
+}
+
+pub fn decrypt_field_b64(value: &str, key_b64: &str) -> Result<String> {
+ decrypt_json_field(value, &b64::decode(key_b64)?)
+}
+
+pub fn encrypt_attachment(data: &[u8], chat_key_b64: &str, session_uuid: &str) -> Result<Vec<u8>> {
+ encrypt_blob(data, attachment_key(chat_key_b64, session_uuid)?.as_bytes())
+}
+
+pub fn decrypt_attachment(data: &[u8], chat_key_b64: &str, session_uuid: &str) -> Result<Vec<u8>> {
+ decrypt_blob(data, attachment_key(chat_key_b64, session_uuid)?.as_bytes())
+}
+
+pub fn encrypt_attachment_b64(
+ data_b64: &str,
+ chat_key_b64: &str,
+ session_uuid: &str,
+) -> Result<String> {
+ Ok(b64::encode(&encrypt_attachment(
+ &b64::decode(data_b64)?,
+ chat_key_b64,
+ session_uuid,
+ )?))
+}
+
+pub fn decrypt_attachment_b64(
+ data_b64: &str,
+ chat_key_b64: &str,
+ session_uuid: &str,
+) -> Result<String> {
+ Ok(b64::encode(&decrypt_attachment(
+ &b64::decode(data_b64)?,
+ chat_key_b64,
+ session_uuid,
+ )?))
+}
+
+pub fn encrypt_blob(plaintext: &[u8], key: &[u8]) -> Result<Vec<u8>> {
+ Ok(blob::encrypt_combined(
+ plaintext,
+ &Key::try_from_slice(key)?,
+ )?)
+}
+
+pub fn decrypt_blob(data: &[u8], key: &[u8]) -> Result<Vec<u8>> {
+ if data.len() < Header::BYTES {
+ return Err(Error::InvalidBlobLength {
+ minimum: Header::BYTES,
+ actual: data.len(),
+ });
+ }
+ let (header, ciphertext) = data.split_at(Header::BYTES);
+ Ok(blob::decrypt(
+ ciphertext,
+ &Header::try_from_slice(header)?,
+ &Key::try_from_slice(key)?,
+ )?)
+}
+
+pub fn encrypt_string(value: &str, key: &[u8]) -> Result<Vec<u8>> {
+ encrypt_blob(value.as_bytes(), key)
+}
+
+pub fn decrypt_string(data: &[u8], key: &[u8]) -> Result<String> {
+ Ok(String::from_utf8(decrypt_blob(data, key)?)?)
+}
+
+pub fn encrypt_json_field(value: &str, key: &[u8]) -> Result<String> {
+ let encrypted = blob::encrypt(value.as_bytes(), &Key::try_from_slice(key)?)?;
+ let ciphertext_b64 = b64::encode(&encrypted.encrypted_data);
+ let header_b64 = b64::encode(encrypted.decryption_header.as_bytes());
+ Ok(format!("enc:v1:{ciphertext_b64}:{header_b64}"))
+}
+
+pub fn decrypt_json_field(value: &str, key: &[u8]) -> Result<String> {
+ let mut parts = value.split(':');
+ if parts.next() != Some("enc") || parts.next() != Some("v1") {
+ return Err(Error::InvalidEncryptedField);
+ }
+ let ciphertext = parts.next().ok_or(Error::InvalidEncryptedField)?;
+ let header = parts.next().ok_or(Error::InvalidEncryptedField)?;
+ if parts.next().is_some() {
+ return Err(Error::InvalidEncryptedField);
+ }
+ let ciphertext = b64::decode(ciphertext)?;
+ let header = b64::decode(header)?;
+ let header = Header::try_from_slice(&header).map_err(|_| Error::InvalidEncryptedField)?;
+ let plaintext = blob::decrypt(&ciphertext, &header, &Key::try_from_slice(key)?)?;
+ Ok(String::from_utf8(plaintext)?)
+}
+
+fn key_from_b64(value: &str) -> Result<Key> {
+ Ok(Key::try_from_slice(&b64::decode(value)?)?)
+}
+
+fn attachment_key(chat_key_b64: &str, session_uuid: &str) -> Result<Key> {
+ let chat_key = b64::decode(chat_key_b64)?;
+ let mut key = [0; 32];
+ Hkdf::<Sha256>::new(Some(session_uuid.as_bytes()), &chat_key)
+ .expand(ATTACHMENT_KEY_INFO, &mut key)
+ .map_err(|_| crypto::Error::KeyDerivationFailed)?;
+ Ok(Key::try_from_slice(&key)?)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn payload_roundtrip() {
+ let key = generate_chat_key();
+ let encrypted = encrypt_payload(r#"{"text":"hello"}"#, &key).unwrap();
+ assert_eq!(
+ decrypt_payload(&encrypted.encrypted_data, &encrypted.header, &key).unwrap(),
+ r#"{"text":"hello"}"#
+ );
+ }
+
+ #[test]
+ fn field_roundtrip() {
+ let key = generate_chat_key();
+ let encrypted = encrypt_field_b64("file-name.png", &key).unwrap();
+ assert!(encrypted.starts_with("enc:v1:"));
+ assert_eq!(
+ decrypt_field_b64(&encrypted, &key).unwrap(),
+ "file-name.png"
+ );
+ }
+
+ #[test]
+ fn attachment_roundtrip() {
+ let key = generate_chat_key();
+ let encrypted = encrypt_attachment(b"attachment", &key, "session-id").unwrap();
+ assert_eq!(
+ decrypt_attachment(&encrypted, &key, "session-id").unwrap(),
+ b"attachment"
+ );
+ }
+
+ #[test]
+ fn attachment_key_matches_web_crypto() {
+ let key = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=";
+ let derived = attachment_key(key, "session-id").unwrap();
+ assert_eq!(
+ b64::encode(derived.as_bytes()),
+ "zUVLxgcjyPjOhZIESIXtjOaA8z9L7BCVIBG2wkar5NI="
+ );
+ }
+}
diff --git a/rust/crates/ensu/Cargo.toml b/rust/crates/ensu/Cargo.toml
index 431ebb51d1..beb23708bd 100644
--- a/rust/crates/ensu/Cargo.toml
+++ b/rust/crates/ensu/Cargo.toml
@@ -5,6 +5,7 @@ edition = "2024"
[dependencies]
ente-assets.workspace = true
ente-core.workspace = true
+ente-ensu-crypto.workspace = true
ente-image.workspace = true
memmap2 = "0.9.9"
regex = { version = "1", optional = true }
diff --git a/rust/crates/ensu/src/db/crypto.rs b/rust/crates/ensu/src/db/crypto.rs
index 4dd6feba4f..f8ccd0f5f9 100644
--- a/rust/crates/ensu/src/db/crypto.rs
+++ b/rust/crates/ensu/src/db/crypto.rs
@@ -1,67 +1,33 @@
-use ente_core::b64;
-use ente_core::crypto::{Header, Key, blob};
-
-use crate::db::{Error, Result};
+use crate::db::Result;
pub fn encrypt_blob(plaintext: &[u8], key: &[u8]) -> Result<Vec<u8>> {
- Ok(blob::encrypt_combined(
- plaintext,
- &Key::try_from_slice(key)?,
- )?)
+ ente_ensu_crypto::encrypt_blob(plaintext, key).map_err(Into::into)
}
pub fn decrypt_blob(data: &[u8], key: &[u8]) -> Result<Vec<u8>> {
- if data.len() < Header::BYTES {
- return Err(Error::InvalidBlobLength {
- minimum: Header::BYTES,
- actual: data.len(),
- });
- }
- let (header, ciphertext) = data.split_at(Header::BYTES);
- Ok(blob::decrypt(
- ciphertext,
- &Header::try_from_slice(header)?,
- &Key::try_from_slice(key)?,
- )?)
+ ente_ensu_crypto::decrypt_blob(data, key).map_err(Into::into)
}
pub fn encrypt_string(value: &str, key: &[u8]) -> Result<Vec<u8>> {
- encrypt_blob(value.as_bytes(), key)
+ ente_ensu_crypto::encrypt_string(value, key).map_err(Into::into)
}
pub fn decrypt_string(data: &[u8], key: &[u8]) -> Result<String> {
- let plaintext = decrypt_blob(data, key)?;
- Ok(String::from_utf8(plaintext)?)
+ ente_ensu_crypto::decrypt_string(data, key).map_err(Into::into)
}
pub fn encrypt_json_field(value: &str, key: &[u8]) -> Result<String> {
- let encrypted = blob::encrypt(value.as_bytes(), &Key::try_from_slice(key)?)?;
- let ciphertext_b64 = b64::encode(&encrypted.encrypted_data);
- let header_b64 = b64::encode(encrypted.decryption_header.as_bytes());
- Ok(format!("enc:v1:{ciphertext_b64}:{header_b64}"))
+ ente_ensu_crypto::encrypt_json_field(value, key).map_err(Into::into)
}
pub fn decrypt_json_field(value: &str, key: &[u8]) -> Result<String> {
- let mut parts = value.split(':');
- let prefix = parts.next();
- let version = parts.next();
- let ciphertext_b64 = parts.next();
- let header_b64 = parts.next();
- if prefix != Some("enc") || version != Some("v1") || parts.next().is_some() {
- return Err(Error::InvalidEncryptedField);
- }
- let ciphertext_b64 = ciphertext_b64.ok_or(Error::InvalidEncryptedField)?;
- let header_b64 = header_b64.ok_or(Error::InvalidEncryptedField)?;
- let ciphertext = b64::decode(ciphertext_b64)?;
- let header = b64::decode(header_b64)?;
- let header = Header::try_from_slice(&header).map_err(|_| Error::InvalidEncryptedField)?;
- let plaintext = blob::decrypt(&ciphertext, &header, &Key::try_from_slice(key)?)?;
- Ok(String::from_utf8(plaintext)?)
+ ente_ensu_crypto::decrypt_json_field(value, key).map_err(Into::into)
}
#[cfg(test)]
mod tests {
use super::*;
+ use ente_core::crypto::Key;
#[test]
fn blob_roundtrip() {
diff --git a/rust/crates/ensu/src/db/error.rs b/rust/crates/ensu/src/db/error.rs
index a9d6134f65..6b1c16f059 100644
--- a/rust/crates/ensu/src/db/error.rs
+++ b/rust/crates/ensu/src/db/error.rs
@@ -59,6 +59,20 @@ pub enum Error {
Migration(String),
}
+impl From<ente_ensu_crypto::Error> for Error {
+ fn from(error: ente_ensu_crypto::Error) -> Self {
+ use ente_ensu_crypto::Error as E;
+
+ match error {
+ E::InvalidBlobLength { minimum, actual } => Self::InvalidBlobLength { minimum, actual },
+ E::InvalidEncryptedField => Self::InvalidEncryptedField,
+ E::Crypto(error) => Self::Crypto(error),
+ E::Base64Decode(error) => Self::Base64Decode(error),
+ E::Utf8(error) => Self::Utf8(error),
+ }
+ }
+}
+
#[cfg(feature = "sqlite")]
impl From<rusqlite::Error> for Error {
fn from(err: rusqlite::Error) -> Self {
diff --git a/web/apps/ensu/package.json b/web/apps/ensu/package.json
index 734712717e..54d5c3c1dc 100644
--- a/web/apps/ensu/package.json
+++ b/web/apps/ensu/package.json
@@ -14,7 +14,7 @@
"@tauri-apps/plugin-updater": "2.10.1",
"@wllama/wllama": "2.4.0",
"ente-base": "*",
- "ente-core-wasm": "*",
+ "ente-ensu-wasm": "*",
"idb": "8.0.3",
"katex": "0.17.0",
"react-markdown": "10.1.0",
diff --git a/web/apps/ensu/src/services/base64.ts b/web/apps/ensu/src/services/base64.ts
index f670f000f3..bee7ed4c2f 100644
--- a/web/apps/ensu/src/services/base64.ts
+++ b/web/apps/ensu/src/services/base64.ts
@@ -18,9 +18,3 @@ export const base64ToBytes = (b64: string): Uint8Array<ArrayBuffer> => {
}
return bytes;
};
-
-export const utf8ToBase64 = (s: string): string =>
- bytesToBase64(new TextEncoder().encode(s));
-
-export const base64ToUtf8 = (b64: string): string =>
- new TextDecoder().decode(base64ToBytes(b64));
diff --git a/web/apps/ensu/src/services/chat/attachments.ts b/web/apps/ensu/src/services/chat/attachments.ts
index 438e50bb6a..704f402690 100644
--- a/web/apps/ensu/src/services/chat/attachments.ts
+++ b/web/apps/ensu/src/services/chat/attachments.ts
@@ -1,77 +1,15 @@
-import { base64ToBytes, bytesToBase64 } from "../base64";
-import { enteWasm } from "../wasm";
-
-const ATTACHMENT_KEY_INFO = "llmchat_attachment_v1";
-const BLOB_HEADER_BYTES = 24;
-
-const ensureCryptoSubtle = () => {
- if (typeof crypto === "undefined") {
- throw new Error("WebCrypto not available for attachment encryption");
- }
- return crypto.subtle;
-};
-
-export const deriveAttachmentKeyB64 = async (
- chatKeyB64: string,
- sessionUuid: string,
-): Promise<string> => {
- const subtle = ensureCryptoSubtle();
- const keyBytes = base64ToBytes(chatKeyB64);
- const salt = new TextEncoder().encode(sessionUuid);
- const info = new TextEncoder().encode(ATTACHMENT_KEY_INFO);
-
- const key = await subtle.importKey("raw", keyBytes, "HKDF", false, [
- "deriveBits",
- ]);
- const bits = await subtle.deriveBits(
- { name: "HKDF", hash: "SHA-256", salt, info },
- key,
- 256,
- );
-
- return bytesToBase64(new Uint8Array(bits));
-};
+import { ensuCrypto } from "../wasm";
export const encryptAttachmentBytes = async (
bytes: Uint8Array,
chatKeyB64: string,
sessionUuid: string,
-): Promise<Uint8Array<ArrayBuffer>> => {
- const wasm = await enteWasm();
- const derivedKeyB64 = await deriveAttachmentKeyB64(chatKeyB64, sessionUuid);
- const plaintextB64 = bytesToBase64(bytes);
- const encrypted = await wasm.crypto_encrypt_blob(
- plaintextB64,
- derivedKeyB64,
- );
-
- const headerBytes = base64ToBytes(encrypted.decryption_header);
- const cipherBytes = base64ToBytes(encrypted.encrypted_data);
- const combined = new Uint8Array(headerBytes.length + cipherBytes.length);
- combined.set(headerBytes, 0);
- combined.set(cipherBytes, headerBytes.length);
- return combined;
-};
+): Promise<Uint8Array<ArrayBuffer>> =>
+ (await ensuCrypto()).encryptAttachment(bytes, chatKeyB64, sessionUuid);
export const decryptAttachmentBytes = async (
encrypted: Uint8Array,
chatKeyB64: string,
sessionUuid: string,
-): Promise<Uint8Array<ArrayBuffer>> => {
- if (encrypted.length < BLOB_HEADER_BYTES) {
- throw new Error("Invalid attachment blob length");
- }
-
- const wasm = await enteWasm();
- const derivedKeyB64 = await deriveAttachmentKeyB64(chatKeyB64, sessionUuid);
-
- const headerBytes = encrypted.slice(0, BLOB_HEADER_BYTES);
- const cipherBytes = encrypted.slice(BLOB_HEADER_BYTES);
-
- const plaintextB64 = await wasm.crypto_decrypt_blob(
- bytesToBase64(cipherBytes),
- bytesToBase64(headerBytes),
- derivedKeyB64,
- );
- return base64ToBytes(plaintextB64);
-};
+): Promise<Uint8Array<ArrayBuffer>> =>
+ (await ensuCrypto()).decryptAttachment(encrypted, chatKeyB64, sessionUuid);
diff --git a/web/apps/ensu/src/services/chat/chatKey.ts b/web/apps/ensu/src/services/chat/chatKey.ts
index d4890c7599..2dfa608d80 100644
--- a/web/apps/ensu/src/services/chat/chatKey.ts
+++ b/web/apps/ensu/src/services/chat/chatKey.ts
@@ -1,6 +1,6 @@
import { isTauriRuntime } from "@/services/tauri-runtime";
import { secureStorageGet, secureStorageSet } from "../secure-storage";
-import { enteWasm } from "../wasm";
+import { ensuCrypto } from "../wasm";
import {
hasRetiredLocalChatStore,
promoteLocalChatKey,
@@ -68,7 +68,7 @@ export const getOrCreateLocalChatKey = async () => {
throw new Error("Existing chat data has no encryption key");
}
- const chatKey = await (await enteWasm()).crypto_generate_key();
+ const chatKey = await (await ensuCrypto()).generateKey();
await persistLocalKey(chatKey);
return chatKey;
};
diff --git a/web/apps/ensu/src/services/chat/crypto.ts b/web/apps/ensu/src/services/chat/crypto.ts
index 425848ff4d..e3041d8f32 100644
--- a/web/apps/ensu/src/services/chat/crypto.ts
+++ b/web/apps/ensu/src/services/chat/crypto.ts
@@ -1,71 +1,29 @@
-import { base64ToUtf8, utf8ToBase64 } from "../base64";
-import { enteWasm } from "../wasm";
+import { ensuCrypto, type EncryptedChatPayload } from "../wasm";
-export interface EncryptedChatPayload {
- encryptedData: string;
- header: string;
-}
-
-const CHAT_FIELD_PREFIX = "enc:v1";
+export type { EncryptedChatPayload } from "../wasm";
export const encryptChatPayload = async (
payload: unknown,
chatKeyB64: string,
-): Promise<EncryptedChatPayload> => {
- const wasm = await enteWasm();
-
- const plaintextB64 = utf8ToBase64(JSON.stringify(payload));
- const encrypted = await wasm.crypto_encrypt_blob(plaintextB64, chatKeyB64);
-
- return {
- encryptedData: encrypted.encrypted_data,
- header: encrypted.decryption_header,
- };
-};
+): Promise<EncryptedChatPayload> =>
+ (await ensuCrypto()).encryptPayload(JSON.stringify(payload), chatKeyB64);
export const decryptChatPayload = async (
{ encryptedData, header }: EncryptedChatPayload,
chatKeyB64: string,
-): Promise<unknown> => {
- const wasm = await enteWasm();
-
- const plaintextB64 = await wasm.crypto_decrypt_blob(
- encryptedData,
- header,
- chatKeyB64,
+): Promise<unknown> =>
+ JSON.parse(
+ await (
+ await ensuCrypto()
+ ).decryptPayload(encryptedData, header, chatKeyB64),
);
- return JSON.parse(base64ToUtf8(plaintextB64));
-};
export const encryptChatField = async (
value: string,
chatKeyB64: string,
-): Promise<string> => {
- const wasm = await enteWasm();
-
- const plaintextB64 = utf8ToBase64(value);
- const encrypted = await wasm.crypto_encrypt_blob(plaintextB64, chatKeyB64);
- return `${CHAT_FIELD_PREFIX}:${encrypted.encrypted_data}:${encrypted.decryption_header}`;
-};
+): Promise<string> => (await ensuCrypto()).encryptField(value, chatKeyB64);
export const decryptChatField = async (
value: string,
chatKeyB64: string,
-): Promise<string> => {
- const [prefix, version, ciphertext, header] = value.split(":");
- if (
- `${prefix}:${version}` !== CHAT_FIELD_PREFIX ||
- !ciphertext ||
- !header
- ) {
- throw new Error("Invalid encrypted field format");
- }
-
- const wasm = await enteWasm();
- const plaintextB64 = await wasm.crypto_decrypt_blob(
- ciphertext,
- header,
- chatKeyB64,
- );
- return base64ToUtf8(plaintextB64);
-};
+): Promise<string> => (await ensuCrypto()).decryptField(value, chatKeyB64);
diff --git a/web/apps/ensu/src/services/wasm.ts b/web/apps/ensu/src/services/wasm.ts
index f788909682..d1c2cbf2d0 100644
--- a/web/apps/ensu/src/services/wasm.ts
+++ b/web/apps/ensu/src/services/wasm.ts
@@ -1,38 +1,75 @@
+import { base64ToBytes, bytesToBase64 } from "@/services/base64";
import { isTauriRuntime } from "@/services/tauri-runtime";
-export type EnteWasmModule = typeof import("ente-core-wasm");
+type EnsuWasmModule = typeof import("ente-ensu-wasm");
-export interface EncryptedBlob {
- encrypted_data: string;
- decryption_header: string;
+export interface EncryptedChatPayload {
+ encryptedData: string;
+ header: string;
}
-export interface EnteCryptoAdapter {
- crypto_generate_key(): Promise<string>;
- crypto_encrypt_blob(
- dataB64: string,
+export interface EnsuCrypto {
+ generateKey(): Promise<string>;
+ encryptPayload(
+ value: string,
keyB64: string,
- ): Promise<EncryptedBlob>;
- crypto_decrypt_blob(
+ ): Promise<EncryptedChatPayload>;
+ decryptPayload(
encryptedDataB64: string,
headerB64: string,
keyB64: string,
): Promise<string>;
+ encryptField(value: string, keyB64: string): Promise<string>;
+ decryptField(value: string, keyB64: string): Promise<string>;
+ encryptAttachment(
+ data: Uint8Array,
+ keyB64: string,
+ sessionUuid: string,
+ ): Promise<Uint8Array<ArrayBuffer>>;
+ decryptAttachment(
+ data: Uint8Array,
+ keyB64: string,
+ sessionUuid: string,
+ ): Promise<Uint8Array<ArrayBuffer>>;
}
-const createWasmAdapter = (wasm: EnteWasmModule): EnteCryptoAdapter => {
- return {
- crypto_generate_key: () => Promise.resolve(wasm.crypto_generate_key()),
- crypto_encrypt_blob: (dataB64, keyB64) =>
- Promise.resolve(wasm.crypto_encrypt_blob(dataB64, keyB64)),
- crypto_decrypt_blob: (encryptedDataB64, headerB64, keyB64) =>
- Promise.resolve(
- wasm.crypto_decrypt_blob(encryptedDataB64, headerB64, keyB64),
- ),
- };
+const encryptedChatPayloadValue = (
+ payload: ReturnType<EnsuWasmModule["encryptChatPayload"]>,
+) => {
+ try {
+ return { encryptedData: payload.encryptedData, header: payload.header };
+ } finally {
+ payload.free();
+ }
};
-const createTauriAdapter = async (): Promise<EnteCryptoAdapter> => {
+const wasmBytes = (bytes: Uint8Array) => bytes as Uint8Array<ArrayBuffer>;
+
+const createWasmClient = (wasm: EnsuWasmModule): EnsuCrypto => ({
+ generateKey: () => Promise.resolve(wasm.generateChatKey()),
+ encryptPayload: (value, keyB64) =>
+ Promise.resolve(
+ encryptedChatPayloadValue(wasm.encryptChatPayload(value, keyB64)),
+ ),
+ decryptPayload: (encryptedDataB64, headerB64, keyB64) =>
+ Promise.resolve(
+ wasm.decryptChatPayload(encryptedDataB64, headerB64, keyB64),
+ ),
+ encryptField: (value, keyB64) =>
+ Promise.resolve(wasm.encryptChatField(value, keyB64)),
+ decryptField: (value, keyB64) =>
+ Promise.resolve(wasm.decryptChatField(value, keyB64)),
+ encryptAttachment: (data, keyB64, sessionUuid) =>
+ Promise.resolve(
+ wasmBytes(wasm.encryptChatAttachment(data, keyB64, sessionUuid)),
+ ),
+ decryptAttachment: (data, keyB64, sessionUuid) =>
+ Promise.resolve(
+ wasmBytes(wasm.decryptChatAttachment(data, keyB64, sessionUuid)),
+ ),
+});
+
+const createTauriClient = async (): Promise<EnsuCrypto> => {
const { invoke } = (await import("@tauri-apps/api/core")) as {
invoke: <T>(
command: string,
@@ -108,28 +145,49 @@ const createTauriAdapter = async (): Promise<EnteCryptoAdapter> => {
};
return {
- crypto_generate_key: () => invokeOrThrow<string>("crypto_generate_key"),
- crypto_encrypt_blob: (dataB64, keyB64) =>
- invokeOrThrow<EncryptedBlob>("crypto_encrypt_blob", {
- input: { dataB64, keyB64 },
+ generateKey: () => invokeOrThrow<string>("chat_crypto_generate_key"),
+ encryptPayload: (value, keyB64) =>
+ invokeOrThrow<EncryptedChatPayload>("chat_crypto_encrypt_payload", {
+ input: { value, keyB64 },
}),
- crypto_decrypt_blob: (encryptedDataB64, headerB64, keyB64) =>
- invokeOrThrow<string>("crypto_decrypt_blob", {
+ decryptPayload: (encryptedDataB64, headerB64, keyB64) =>
+ invokeOrThrow<string>("chat_crypto_decrypt_payload", {
input: { encryptedDataB64, headerB64, keyB64 },
}),
+ encryptField: (value, keyB64) =>
+ invokeOrThrow<string>("chat_crypto_encrypt_field", {
+ input: { value, keyB64 },
+ }),
+ decryptField: (value, keyB64) =>
+ invokeOrThrow<string>("chat_crypto_decrypt_field", {
+ input: { value, keyB64 },
+ }),
+ encryptAttachment: async (data, keyB64, sessionUuid) =>
+ base64ToBytes(
+ await invokeOrThrow<string>("chat_crypto_encrypt_attachment", {
+ input: {
+ dataB64: bytesToBase64(data),
+ keyB64,
+ sessionUuid,
+ },
+ }),
+ ),
+ decryptAttachment: async (data, keyB64, sessionUuid) =>
+ base64ToBytes(
+ await invokeOrThrow<string>("chat_crypto_decrypt_attachment", {
+ input: {
+ dataB64: bytesToBase64(data),
+ keyB64,
+ sessionUuid,
+ },
+ }),
+ ),
};
};
-let _wasmPromise: Promise<EnteCryptoAdapter> | undefined;
+let client: Promise<EnsuCrypto> | undefined;
-export const enteWasm = async (): Promise<EnteCryptoAdapter> => {
- _wasmPromise ??= (async () => {
- if (isTauriRuntime()) {
- return createTauriAdapter();
- }
- const wasm = await import("ente-core-wasm");
- return createWasmAdapter(wasm);
- })();
-
- return _wasmPromise;
-};
+export const ensuCrypto = () =>
+ (client ??= isTauriRuntime()
+ ? createTauriClient()
+ : import("ente-ensu-wasm").then(createWasmClient));
diff --git a/web/package-lock.json b/web/package-lock.json
index efb6e84e8f..0d5db5ea75 100644
--- a/web/package-lock.json
+++ b/web/package-lock.json
@@ -178,7 +178,7 @@
"@tauri-apps/plugin-updater": "2.10.1",
"@wllama/wllama": "2.4.0",
"ente-base": "*",
- "ente-core-wasm": "*",
+ "ente-ensu-wasm": "*",
"idb": "8.0.3",
"katex": "0.17.0",
"react-markdown": "10.1.0",
@@ -4741,6 +4741,10 @@
"resolved": "packages/wasm/core",
"link": true
},
+ "node_modules/ente-ensu-wasm": {
+ "resolved": "packages/wasm/ensu",
+ "link": true
+ },
"node_modules/ente-gallery": {
"resolved": "packages/gallery",
"link": true
@@ -11336,6 +11340,14 @@
"wasm-pack": "0.15.0"
}
},
+ "packages/wasm/ensu": {
+ "name": "ente-ensu-wasm",
+ "version": "0.0.0",
+ "devDependencies": {
+ "ente-build-config": "*",
+ "wasm-pack": "0.15.0"
+ }
+ },
"packages/wasm/paste": {
"name": "ente-paste-wasm",
"version": "0.0.0",
diff --git a/web/package.json b/web/package.json
index 29e5c9def1..f706eb5f8d 100644
--- a/web/package.json
+++ b/web/package.json
@@ -16,7 +16,8 @@
"build:cast-wasm": "npm run build --workspace ente-cast-wasm",
"build:core-wasm": "npm run build --workspace ente-core-wasm",
"build:embed": "npm run build:core-wasm && npm exec --workspace embed -- next build --webpack",
- "build:ensu": "npm run build:core-wasm && npm exec --workspace ensu -- next build --webpack",
+ "build:ensu": "npm run build:ensu-wasm && npm exec --workspace ensu -- next build --webpack",
+ "build:ensu-wasm": "npm run build --workspace ente-ensu-wasm",
"build:legacy": "npm run build:core-wasm && npm exec --workspace legacy -- next build --webpack",
"build:locker": "npm run build:core-wasm && npm exec --workspace locker -- next build --webpack",
"build:memories": "npm run build:core-wasm && npm exec --workspace memories -- next build --webpack && npm run build:post --workspace memories",
@@ -28,14 +29,14 @@
"build:space": "npm run build:core-wasm && npm run build:space-wasm && npm exec --workspace space -- next build --webpack && npm run build:post --workspace space",
"build:space-wasm": "npm run build --workspace ente-space-wasm",
"build:twoof3": "npm exec --workspace twoof3 -- next build --webpack",
- "build:wasm": "npm run build:core-wasm && npm run build:cast-wasm && npm run build:paste-wasm && npm run build:space-wasm",
+ "build:wasm": "npm run build:core-wasm && npm run build:cast-wasm && npm run build:ensu-wasm && npm run build:paste-wasm && npm run build:space-wasm",
"dev": "npm run dev:photos",
"dev:accounts": "npm run build:core-wasm && npm exec --workspace accounts -- next dev --webpack -p 3001",
"dev:albums": "npm run build:core-wasm && npm exec --workspace albums -- next dev --webpack -p 3002",
"dev:auth": "npm run build:core-wasm && npm exec --workspace auth -- next dev --webpack -p 3003",
"dev:cast": "npm run build:core-wasm && npm run build:cast-wasm && npm exec --workspace cast -- next dev --webpack -p 3004",
"dev:embed": "npm run build:core-wasm && npm exec --workspace embed -- next dev --webpack -p 3006",
- "dev:ensu": "npm run build:core-wasm && npm exec --workspace ensu -- next dev --webpack -p 3007",
+ "dev:ensu": "npm run build:ensu-wasm && npm exec --workspace ensu -- next dev --webpack -p 3007",
"dev:legacy": "npm run build:core-wasm && npm exec --workspace legacy -- next dev --webpack -p 3011",
"dev:locker": "npm run build:core-wasm && npm exec --workspace locker -- next dev --webpack -p 3009",
"dev:memories": "npm run build:core-wasm && npm exec --workspace memories -- next dev --webpack -p 3010",
diff --git a/web/packages/wasm/ensu/eslint.config.mjs b/web/packages/wasm/ensu/eslint.config.mjs
new file mode 100644
index 0000000000..e6c7d4d3b0
--- /dev/null
+++ b/web/packages/wasm/ensu/eslint.config.mjs
@@ -0,0 +1,3 @@
+import config from "ente-build-config/eslintrc-base.mjs";
+
+export default [...config, { ignores: ["pkg/"] }];
diff --git a/web/packages/wasm/ensu/index.ts b/web/packages/wasm/ensu/index.ts
new file mode 100644
index 0000000000..4018bdf7f0
--- /dev/null
+++ b/web/packages/wasm/ensu/index.ts
@@ -0,0 +1 @@
+export * from "./pkg/ente_ensu_wasm";
diff --git a/web/packages/wasm/ensu/package.json b/web/packages/wasm/ensu/package.json
new file mode 100644
index 0000000000..ec1758c95e
--- /dev/null
+++ b/web/packages/wasm/ensu/package.json
@@ -0,0 +1,20 @@
+{
+ "name": "ente-ensu-wasm",
+ "version": "0.0.0",
+ "private": true,
+ "exports": {
+ ".": {
+ "types": "./index.ts",
+ "import": "./index.ts"
+ }
+ },
+ "module": "./index.ts",
+ "types": "./index.ts",
+ "scripts": {
+ "build": "wasm-pack build ../../../../rust/bindings/wasm/ensu --target bundler --out-dir ../../../../web/packages/wasm/ensu/pkg --no-pack"
+ },
+ "devDependencies": {
+ "ente-build-config": "*",
+ "wasm-pack": "0.15.0"
+ }
+}
diff --git a/web/packages/wasm/ensu/tsconfig.json b/web/packages/wasm/ensu/tsconfig.json
new file mode 100644
index 0000000000..3f3b6cd165
--- /dev/null
+++ b/web/packages/wasm/ensu/tsconfig.json
@@ -0,0 +1 @@
+{ "extends": "ente-build-config/tsconfig-typecheck.json", "include": ["."] }