π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Add focused Ensu WASM bindings
Manav Rathifb732d66e420
diff --git a/rust/Cargo.lock b/rust/Cargo.lockindex 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.tomlindex 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.tomlindex 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 = trueente-core.workspace = trueente-ensu.workspace = true+ente-ensu-crypto.workspace = truekeyring = { version = "3", default-features = false, features = ["apple-native", "windows-native", "linux-native-sync-persistent", "crypto-rust"] }log.workspace = trueserde.workspace = truediff --git a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs b/rust/apps/ensu/src-tauri/src/commands/chat_db.rsindex 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.rsindex 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.rsindex 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.tomlnew file mode 100644index 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 = truediff --git a/rust/bindings/wasm/ensu/src/lib.rs b/rust/bindings/wasm/ensu/src/lib.rsnew file mode 100644index 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.tomlnew file mode 100644index 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 = truediff --git a/rust/crates/ensu-crypto/src/lib.rs b/rust/crates/ensu-crypto/src/lib.rsnew file mode 100644index 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.tomlindex 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 = trueente-core.workspace = true+ente-ensu-crypto.workspace = trueente-image.workspace = truememmap2 = "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.rsindex 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.rsindex 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.jsonindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.jsonindex 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.jsonindex 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.mjsnew file mode 100644index 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.tsnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 0000000000..3f3b6cd165--- /dev/null+++ b/web/packages/wasm/ensu/tsconfig.json@@ -0,0 +1 @@+{ "extends": "ente-build-config/tsconfig-typecheck.json", "include": ["."] }