Skip to content

armgit / ente

Public Imported from GitHub
0

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

Return WASM data records as plain values

Manav Rathi8e5e98faaac1
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 8391edbf6c..650b173887 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -2422,7 +2422,10 @@ version = "0.0.0"
dependencies = [
"ente-cast",
"ente-wasm-lib",
+ "serde",
+ "serde-wasm-bindgen",
"thiserror 2.0.18",
+ "tsify",
"wasm-bindgen",
]
@@ -2561,7 +2564,10 @@ version = "0.0.0"
dependencies = [
"ente-ensu-crypto",
"ente-wasm-lib",
+ "serde",
+ "serde-wasm-bindgen",
"thiserror 2.0.18",
+ "tsify",
"wasm-bindgen",
]
diff --git a/rust/bindings/wasm/cast/Cargo.toml b/rust/bindings/wasm/cast/Cargo.toml
index 318732ac8d..6baff5b2b8 100644
--- a/rust/bindings/wasm/cast/Cargo.toml
+++ b/rust/bindings/wasm/cast/Cargo.toml
@@ -8,7 +8,10 @@ crate-type = ["cdylib"]
[dependencies]
ente-cast.workspace = true
ente-wasm-lib.workspace = true
+serde.workspace = true
+serde-wasm-bindgen.workspace = true
thiserror.workspace = true
+tsify.workspace = true
wasm-bindgen.workspace = true
[lints]
diff --git a/rust/bindings/wasm/cast/src/lib.rs b/rust/bindings/wasm/cast/src/lib.rs
index 15cba48a9d..704788c516 100644
--- a/rust/bindings/wasm/cast/src/lib.rs
+++ b/rust/bindings/wasm/cast/src/lib.rs
@@ -1,10 +1,15 @@
use ente_cast::ReceiverCredentials;
+use serde::Serialize;
+use serde_wasm_bindgen as swb;
+use tsify::Tsify;
use wasm_bindgen::prelude::*;
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error(transparent)]
Cast(#[from] ente_cast::Error),
+ #[error(transparent)]
+ Serde(#[from] swb::Error),
}
impl From<Error> for JsValue {
@@ -44,62 +49,35 @@ impl CastReceiver {
}
#[wasm_bindgen(js_name = openPayload)]
- pub fn open_payload(&self, encrypted_payload: &str) -> Result<CastPayload, Error> {
- Ok(self.inner.open_payload(encrypted_payload)?.into())
+ pub fn open_payload(
+ &self,
+ encrypted_payload: &str,
+ ) -> Result<<CastPayload as Tsify>::JsType, Error> {
+ let payload = self.inner.open_payload(encrypted_payload)?;
+ CastPayload {
+ collection_id: payload.collection_id,
+ cast_token: payload.cast_token,
+ collection_key: payload.collection_key,
+ }
+ .into_js()
+ .map_err(Into::into)
}
}
-#[wasm_bindgen]
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
pub struct CastPayload {
- inner: ente_cast::CastPayload,
-}
-
-impl From<ente_cast::CastPayload> for CastPayload {
- fn from(inner: ente_cast::CastPayload) -> Self {
- Self { inner }
- }
-}
-
-#[wasm_bindgen]
-impl CastPayload {
- #[wasm_bindgen(getter, js_name = collectionID)]
- pub fn collection_id(&self) -> i64 {
- self.inner.collection_id
- }
-
- #[wasm_bindgen(getter, js_name = castToken)]
- pub fn cast_token(&self) -> String {
- self.inner.cast_token.clone()
- }
-
- #[wasm_bindgen(getter, js_name = collectionKey)]
- pub fn collection_key(&self) -> String {
- self.inner.collection_key.clone()
- }
+ #[serde(rename = "collectionID")]
+ collection_id: i64,
+ cast_token: String,
+ collection_key: String,
}
-#[wasm_bindgen]
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
pub struct PreparedCastPayload {
- inner: ente_cast::PreparedCastPayload,
-}
-
-impl From<ente_cast::PreparedCastPayload> for PreparedCastPayload {
- fn from(inner: ente_cast::PreparedCastPayload) -> Self {
- Self { inner }
- }
-}
-
-#[wasm_bindgen]
-impl PreparedCastPayload {
- #[wasm_bindgen(getter, js_name = castToken)]
- pub fn cast_token(&self) -> String {
- self.inner.cast_token.clone()
- }
-
- #[wasm_bindgen(getter, js_name = encryptedPayload)]
- pub fn encrypted_payload(&self) -> String {
- self.inner.encrypted_payload.clone()
- }
+ cast_token: String,
+ encrypted_payload: String,
}
#[wasm_bindgen(js_name = preparePayload)]
@@ -108,12 +86,17 @@ pub fn prepare_payload(
pq_public_key: Option<String>,
collection_id: i64,
collection_key: &str,
-) -> Result<PreparedCastPayload, Error> {
- Ok(ente_cast::prepare_payload(
+) -> Result<<PreparedCastPayload as Tsify>::JsType, Error> {
+ let payload = ente_cast::prepare_payload(
public_key,
pq_public_key.as_deref(),
collection_id,
collection_key,
- )?
- .into())
+ )?;
+ PreparedCastPayload {
+ cast_token: payload.cast_token,
+ encrypted_payload: payload.encrypted_payload,
+ }
+ .into_js()
+ .map_err(Into::into)
}
diff --git a/rust/bindings/wasm/ensu/Cargo.toml b/rust/bindings/wasm/ensu/Cargo.toml
index 7191299b55..f914d41b3a 100644
--- a/rust/bindings/wasm/ensu/Cargo.toml
+++ b/rust/bindings/wasm/ensu/Cargo.toml
@@ -8,7 +8,10 @@ crate-type = ["cdylib"]
[dependencies]
ente-ensu-crypto.workspace = true
ente-wasm-lib.workspace = true
+serde.workspace = true
+serde-wasm-bindgen.workspace = true
thiserror.workspace = true
+tsify.workspace = true
wasm-bindgen.workspace = true
[lints]
diff --git a/rust/bindings/wasm/ensu/src/lib.rs b/rust/bindings/wasm/ensu/src/lib.rs
index f561ceca16..a72c6a2d64 100644
--- a/rust/bindings/wasm/ensu/src/lib.rs
+++ b/rust/bindings/wasm/ensu/src/lib.rs
@@ -1,9 +1,14 @@
+use serde::Serialize;
+use serde_wasm_bindgen as swb;
+use tsify::Tsify;
use wasm_bindgen::prelude::*;
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error(transparent)]
Crypto(#[from] ente_ensu_crypto::Error),
+ #[error(transparent)]
+ Serde(#[from] swb::Error),
}
impl From<Error> for JsValue {
@@ -12,20 +17,11 @@ impl From<Error> for JsValue {
}
}
-#[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()
- }
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct EncryptedChatPayload {
+ encrypted_data: String,
+ header: String,
}
#[wasm_bindgen(js_name = generateChatKey)]
@@ -34,10 +30,17 @@ pub fn generate_chat_key() -> String {
}
#[wasm_bindgen(js_name = encryptChatPayload)]
-pub fn encrypt_chat_payload(value: &str, key_b64: &str) -> Result<EncryptedChatPayload, Error> {
- ente_ensu_crypto::encrypt_payload(value, key_b64)
- .map(EncryptedChatPayload)
- .map_err(Into::into)
+pub fn encrypt_chat_payload(
+ value: &str,
+ key_b64: &str,
+) -> Result<<EncryptedChatPayload as Tsify>::JsType, Error> {
+ let payload = ente_ensu_crypto::encrypt_payload(value, key_b64)?;
+ EncryptedChatPayload {
+ encrypted_data: payload.encrypted_data,
+ header: payload.header,
+ }
+ .into_js()
+ .map_err(Into::into)
}
#[wasm_bindgen(js_name = decryptChatPayload)]
diff --git a/rust/bindings/wasm/lib/Cargo.toml b/rust/bindings/wasm/lib/Cargo.toml
index 042319632f..bc4ce184d7 100644
--- a/rust/bindings/wasm/lib/Cargo.toml
+++ b/rust/bindings/wasm/lib/Cargo.toml
@@ -3,14 +3,14 @@ name = "ente-wasm-lib"
edition.workspace = true
[features]
-accounts = ["dep:ente-accounts"]
+accounts = ["dep:ente-accounts", "dep:serde", "dep:serde-wasm-bindgen", "dep:tsify"]
collections = ["session", "dep:ente-collections"]
contacts = [
"session",
"dep:ente-contacts",
"dep:wasm-bindgen-futures",
]
-crypto = []
+crypto = ["dep:serde", "dep:serde-wasm-bindgen", "dep:tsify"]
crypto-file = ["crypto", "dep:md-5"]
crypto-seal = ["crypto"]
locker = ["session", "dep:ente-locker"]
diff --git a/rust/bindings/wasm/lib/src/accounts.rs b/rust/bindings/wasm/lib/src/accounts.rs
index 05254d5c74..59d19ce8d5 100644
--- a/rust/bindings/wasm/lib/src/accounts.rs
+++ b/rust/bindings/wasm/lib/src/accounts.rs
@@ -1,11 +1,16 @@
use ente_accounts::auth;
use ente_core::b64;
+use serde::Serialize;
+use serde_wasm_bindgen as swb;
+use tsify::Tsify;
use wasm_bindgen::prelude::*;
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error(transparent)]
Accounts(#[from] ente_accounts::Error),
+ #[error(transparent)]
+ Serde(#[from] swb::Error),
}
impl Error {
@@ -23,15 +28,12 @@ impl From<Error> for JsValue {
}
}
-#[wasm_bindgen(getter_with_clone)]
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
pub struct GeneratedKek {
- #[wasm_bindgen(readonly)]
pub key: String,
- #[wasm_bindgen(readonly)]
pub salt: String,
- #[wasm_bindgen(readonly, js_name = memLimit)]
pub mem_limit: u32,
- #[wasm_bindgen(readonly, js_name = opsLimit)]
pub ops_limit: u32,
}
@@ -47,6 +49,10 @@ impl From<auth::GeneratedKek> for GeneratedKek {
}
#[wasm_bindgen(js_name = authGenerateInteractiveKek)]
-pub fn auth_generate_interactive_kek(password: &str) -> Result<GeneratedKek, Error> {
- Ok(auth::generate_interactive_kek(password)?.into())
+pub fn auth_generate_interactive_kek(
+ password: &str,
+) -> Result<<GeneratedKek as Tsify>::JsType, Error> {
+ GeneratedKek::from(auth::generate_interactive_kek(password)?)
+ .into_js()
+ .map_err(Into::into)
}
diff --git a/rust/bindings/wasm/lib/src/contacts.rs b/rust/bindings/wasm/lib/src/contacts.rs
index 525a69828e..0fbe351922 100644
--- a/rust/bindings/wasm/lib/src/contacts.rs
+++ b/rust/bindings/wasm/lib/src/contacts.rs
@@ -1,4 +1,4 @@
-use serde::{Serialize, Serializer};
+use serde::Serialize;
use serde_wasm_bindgen as swb;
use tsify::Tsify;
use wasm_bindgen::prelude::*;
@@ -56,7 +56,7 @@ pub struct ContactsDiffOutput {
#[derive(Serialize, Tsify)]
#[serde(rename_all = "camelCase")]
pub struct ProfilePictureOutput {
- #[serde(serialize_with = "serialize_bytes")]
+ #[serde(serialize_with = "crate::types::serialize_bytes")]
#[tsify(type = "Uint8Array")]
bytes: Vec<u8>,
wrapped_root_contact_key: Option<WrappedRootContactKey>,
@@ -125,10 +125,3 @@ fn wrapped_root_contact_key(
},
)
}
-
-fn serialize_bytes<S>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error>
-where
- S: Serializer,
-{
- serializer.serialize_bytes(bytes)
-}
diff --git a/rust/bindings/wasm/lib/src/crypto.rs b/rust/bindings/wasm/lib/src/crypto.rs
index aadd30a97c..a41bf84ccd 100644
--- a/rust/bindings/wasm/lib/src/crypto.rs
+++ b/rust/bindings/wasm/lib/src/crypto.rs
@@ -1,4 +1,6 @@
use ente_core::{b64, crypto};
+use serde_wasm_bindgen as swb;
+use tsify::Tsify;
use wasm_bindgen::prelude::*;
use crate::EncryptedBox;
@@ -12,6 +14,8 @@ pub enum Error {
Crypto(#[from] crypto::Error),
#[error(transparent)]
Decode(#[from] b64::DecodeError),
+ #[error(transparent)]
+ Serde(#[from] swb::Error),
}
impl Error {
@@ -35,14 +39,25 @@ pub fn crypto_generate_key() -> String {
}
#[wasm_bindgen(js_name = cryptoEncryptBox)]
-pub fn crypto_encrypt_box(data_b64: &str, key_b64: &str) -> Result<EncryptedBox, Error> {
+pub fn crypto_encrypt_box(
+ data_b64: &str,
+ key_b64: &str,
+) -> Result<<EncryptedBox as Tsify>::JsType, Error> {
crypto_encrypt_box_bytes(&b64::decode(data_b64)?, key_b64)
}
#[wasm_bindgen(js_name = cryptoEncryptBoxBytes)]
-pub fn crypto_encrypt_box_bytes(data: &[u8], key_b64: &str) -> Result<EncryptedBox, Error> {
+pub fn crypto_encrypt_box_bytes(
+ data: &[u8],
+ key_b64: &str,
+) -> Result<<EncryptedBox as Tsify>::JsType, Error> {
let key = b64::decode(key_b64)?;
- Ok(crypto::secretbox::encrypt(data, &crypto::Key::try_from_slice(&key)?).into())
+ EncryptedBox::from(crypto::secretbox::encrypt(
+ data,
+ &crypto::Key::try_from_slice(&key)?,
+ ))
+ .into_js()
+ .map_err(Into::into)
}
#[wasm_bindgen(js_name = cryptoDecryptBox)]
diff --git a/rust/bindings/wasm/lib/src/crypto/file.rs b/rust/bindings/wasm/lib/src/crypto/file.rs
index c764e5dc7c..de2c835d7d 100644
--- a/rust/bindings/wasm/lib/src/crypto/file.rs
+++ b/rust/bindings/wasm/lib/src/crypto/file.rs
@@ -1,5 +1,7 @@
use ente_core::{b64, crypto};
use md5::{Digest, Md5};
+use serde::Serialize;
+use tsify::Tsify;
use wasm_bindgen::prelude::*;
use super::Error;
@@ -91,23 +93,27 @@ pub fn crypto_md5_base64(data: Vec<u8>) -> String {
b64::encode(&digest)
}
-#[wasm_bindgen(getter_with_clone)]
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
pub struct EncryptedBlob {
- #[wasm_bindgen(readonly, js_name = encryptedData)]
pub encrypted_data: String,
- #[wasm_bindgen(readonly, js_name = decryptionHeader)]
pub decryption_header: String,
}
#[wasm_bindgen(js_name = cryptoEncryptBlob)]
-pub fn crypto_encrypt_blob(data: &[u8], key_b64: &str) -> Result<EncryptedBlob, Error> {
+pub fn crypto_encrypt_blob(
+ data: &[u8],
+ key_b64: &str,
+) -> Result<<EncryptedBlob as Tsify>::JsType, Error> {
let key = b64::decode(key_b64)?;
let out = crypto::blob::encrypt(data, &crypto::Key::try_from_slice(&key)?)?;
- Ok(EncryptedBlob {
+ EncryptedBlob {
encrypted_data: b64::encode(&out.encrypted_data),
decryption_header: b64::encode(out.decryption_header.as_bytes()),
- })
+ }
+ .into_js()
+ .map_err(Into::into)
}
#[wasm_bindgen(js_name = cryptoDecryptBlob)]
@@ -144,13 +150,13 @@ pub fn crypto_decrypt_blob_legacy(
)?)
}
-#[wasm_bindgen(getter_with_clone)]
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
pub struct EncryptedStreamResult {
- #[wasm_bindgen(readonly, js_name = encryptedData)]
+ #[serde(serialize_with = "crate::types::serialize_bytes")]
+ #[tsify(type = "Uint8Array<ArrayBuffer>")]
pub encrypted_data: Vec<u8>,
- #[wasm_bindgen(readonly, js_name = decryptionHeader)]
pub decryption_header: String,
- #[wasm_bindgen(readonly, js_name = md5Hash)]
pub md5_hash: String,
}
@@ -158,7 +164,7 @@ pub struct EncryptedStreamResult {
pub fn crypto_encrypt_stream_with_key(
data_b64: &str,
key_b64: &str,
-) -> Result<EncryptedStreamResult, Error> {
+) -> Result<<EncryptedStreamResult as Tsify>::JsType, Error> {
let plaintext = b64::decode(data_b64)?;
let key = crypto::Key::try_from_slice(&b64::decode(key_b64)?)?;
@@ -168,9 +174,11 @@ pub fn crypto_encrypt_stream_with_key(
let header = crypto::stream::encrypt_file(&mut reader, &mut writer, &key)?;
let (encrypted, md5) = writer.finalize();
- Ok(EncryptedStreamResult {
+ EncryptedStreamResult {
encrypted_data: encrypted,
decryption_header: b64::encode(header.as_bytes()),
md5_hash: b64::encode(&md5),
- })
+ }
+ .into_js()
+ .map_err(Into::into)
}
diff --git a/rust/bindings/wasm/lib/src/prelogin.rs b/rust/bindings/wasm/lib/src/prelogin.rs
index 38bb318117..27fd97ce6b 100644
--- a/rust/bindings/wasm/lib/src/prelogin.rs
+++ b/rust/bindings/wasm/lib/src/prelogin.rs
@@ -1,15 +1,15 @@
use crate::accounts::{Error as AccountsError, GeneratedKek};
use ente_accounts::auth;
use ente_core::{b64, crypto};
+use serde::Serialize;
+use tsify::Tsify;
use wasm_bindgen::prelude::*;
-#[wasm_bindgen(getter_with_clone)]
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
pub struct GeneratedSrpSetup {
- #[wasm_bindgen(readonly, js_name = srpSalt)]
pub srp_salt: String,
- #[wasm_bindgen(readonly, js_name = srpVerifier)]
pub srp_verifier: String,
- #[wasm_bindgen(readonly, js_name = loginSubKey)]
pub login_sub_key: String,
}
@@ -32,23 +32,29 @@ pub fn auth_derive_srp_login_key(kek_b64: &str) -> Result<String, AccountsError>
}
#[wasm_bindgen(js_name = authGenerateSensitiveKek)]
-pub fn auth_generate_sensitive_kek(password: &str) -> Result<GeneratedKek, AccountsError> {
- Ok(auth::generate_sensitive_kek(password)?.into())
+pub fn auth_generate_sensitive_kek(
+ password: &str,
+) -> Result<<GeneratedKek as Tsify>::JsType, AccountsError> {
+ GeneratedKek::from(auth::generate_sensitive_kek(password)?)
+ .into_js()
+ .map_err(Into::into)
}
#[wasm_bindgen(js_name = authGenerateSrpSetup)]
pub fn auth_generate_srp_setup(
kek_b64: &str,
srp_user_id: &str,
-) -> Result<GeneratedSrpSetup, AccountsError> {
+) -> Result<<GeneratedSrpSetup as Tsify>::JsType, AccountsError> {
let kek =
b64::decode(kek_b64).map_err(|e| ente_accounts::Error::Decode(format!("kek: {e}")))?;
let generated = auth::generate_srp_setup(&kek, srp_user_id)?;
- Ok(GeneratedSrpSetup {
+ GeneratedSrpSetup {
srp_salt: b64::encode(&generated.srp_salt),
srp_verifier: b64::encode(&generated.srp_verifier),
login_sub_key: b64::encode(&generated.login_sub_key),
- })
+ }
+ .into_js()
+ .map_err(Into::into)
}
#[wasm_bindgen(js_name = authRecoveryKeyFromMnemonicOrHex)]
@@ -107,19 +113,21 @@ impl SrpSession {
}
}
-#[wasm_bindgen(getter_with_clone)]
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
pub struct CryptoKeyPair {
- #[wasm_bindgen(readonly, js_name = publicKey)]
pub public_key: String,
- #[wasm_bindgen(readonly, js_name = privateKey)]
pub private_key: String,
}
#[wasm_bindgen(js_name = cryptoGenerateKeyPair)]
-pub fn crypto_generate_key_pair() -> CryptoKeyPair {
+pub fn crypto_generate_key_pair() -> Result<<CryptoKeyPair as Tsify>::JsType, crate::crypto::Error>
+{
let secret_key = crypto::SecretKey::generate();
CryptoKeyPair {
public_key: b64::encode(secret_key.public_key().as_bytes()),
private_key: b64::encode(secret_key.as_bytes()),
}
+ .into_js()
+ .map_err(Into::into)
}
diff --git a/rust/bindings/wasm/lib/src/session.rs b/rust/bindings/wasm/lib/src/session.rs
index b52f2ffc1b..f64b438797 100644
--- a/rust/bindings/wasm/lib/src/session.rs
+++ b/rust/bindings/wasm/lib/src/session.rs
@@ -6,6 +6,7 @@ use ente_core::{
http::{ApiConfig, Auth},
};
use serde::Deserialize;
+use serde_wasm_bindgen as swb;
use tsify::{Ts, Tsify};
use wasm_bindgen::prelude::*;
@@ -18,6 +19,8 @@ pub enum Error {
#[error(transparent)]
Input(#[from] tsify::Error),
#[error(transparent)]
+ Serde(#[from] swb::Error),
+ #[error(transparent)]
Http(#[from] ente_core::http::Error),
#[error(transparent)]
Decode(#[from] b64::DecodeError),
@@ -132,8 +135,16 @@ impl Session {
#[wasm_bindgen]
impl Session {
#[wasm_bindgen(js_name = encryptWithRecoveryKey)]
- pub fn encrypt_with_recovery_key(&self, data_b64: &str) -> Result<EncryptedBox, Error> {
- Ok(crypto::secretbox::encrypt(&b64::decode(data_b64)?, &self.0.recovery_key).into())
+ pub fn encrypt_with_recovery_key(
+ &self,
+ data_b64: &str,
+ ) -> Result<<EncryptedBox as Tsify>::JsType, Error> {
+ EncryptedBox::from(crypto::secretbox::encrypt(
+ &b64::decode(data_b64)?,
+ &self.0.recovery_key,
+ ))
+ .into_js()
+ .map_err(Into::into)
}
#[wasm_bindgen(js_name = recoveryKeyMnemonic)]
diff --git a/rust/bindings/wasm/lib/src/types.rs b/rust/bindings/wasm/lib/src/types.rs
index b655815276..21ed13d7b1 100644
--- a/rust/bindings/wasm/lib/src/types.rs
+++ b/rust/bindings/wasm/lib/src/types.rs
@@ -1,14 +1,22 @@
use ente_core::{b64, crypto};
-use wasm_bindgen::prelude::*;
+use serde::Serialize;
+use tsify::Tsify;
-#[wasm_bindgen(getter_with_clone)]
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
pub struct EncryptedBox {
- #[wasm_bindgen(readonly, js_name = encryptedData)]
pub encrypted_data: String,
- #[wasm_bindgen(readonly)]
pub nonce: String,
}
+#[cfg(any(feature = "contacts", feature = "crypto-file"))]
+pub(crate) fn serialize_bytes<S>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error>
+where
+ S: serde::Serializer,
+{
+ serializer.serialize_bytes(bytes)
+}
+
impl From<crypto::secretbox::EncryptedBox> for EncryptedBox {
fn from(value: crypto::secretbox::EncryptedBox) -> Self {
Self {
diff --git a/web/apps/ensu/src/services/chat/crypto.ts b/web/apps/ensu/src/services/chat/crypto.ts
index 58ad544e53..7e7865f48d 100644
--- a/web/apps/ensu/src/services/chat/crypto.ts
+++ b/web/apps/ensu/src/services/chat/crypto.ts
@@ -3,11 +3,6 @@ import * as wasmCrypto from "ente-ensu-wasm";
type TauriCoreModule = typeof import("@tauri-apps/api/core");
-export interface EncryptedChatPayload {
- encryptedData: string;
- header: string;
-}
-
const tauriInvoke = async <T>(
...args: Parameters<TauriCoreModule["invoke"]>
) => {
@@ -35,7 +30,7 @@ export const generateChatKey = async () =>
export const encryptChatPayload = async (
payload: unknown,
chatKeyB64: string,
-): Promise<EncryptedChatPayload> => {
+): Promise<wasmCrypto.EncryptedChatPayload> => {
const value = JSON.stringify(payload);
if (isTauriRuntime()) {
return tauriInvoke("chat_crypto_encrypt_payload", {
@@ -46,7 +41,7 @@ export const encryptChatPayload = async (
};
export const decryptChatPayload = async (
- { encryptedData, header }: EncryptedChatPayload,
+ { encryptedData, header }: wasmCrypto.EncryptedChatPayload,
chatKeyB64: string,
): Promise<unknown> => {
const value = isTauriRuntime()
diff --git a/web/package-lock.json b/web/package-lock.json
index 2d097bc437..6f60e2a41c 100644
--- a/web/package-lock.json
+++ b/web/package-lock.json
@@ -11332,9 +11332,6 @@
"packages/wasm/cast": {
"name": "ente-cast-wasm",
"version": "0.0.0",
- "dependencies": {
- "ente-utils": "*"
- },
"devDependencies": {
"ente-build-config": "*",
"wasm-pack": "0.15.0"
@@ -11343,9 +11340,6 @@
"packages/wasm/ensu": {
"name": "ente-ensu-wasm",
"version": "0.0.0",
- "dependencies": {
- "ente-utils": "*"
- },
"devDependencies": {
"ente-build-config": "*",
"wasm-pack": "0.15.0"
@@ -11390,9 +11384,6 @@
"packages/wasm/photos": {
"name": "ente-photos-wasm",
"version": "0.0.0",
- "dependencies": {
- "ente-utils": "*"
- },
"devDependencies": {
"ente-build-config": "*",
"wasm-pack": "0.15.0"
@@ -11401,9 +11392,6 @@
"packages/wasm/prelogin": {
"name": "ente-prelogin-wasm",
"version": "0.0.0",
- "dependencies": {
- "ente-utils": "*"
- },
"devDependencies": {
"ente-build-config": "*",
"vite-plugin-wasm": "3.6.0",
@@ -11424,6 +11412,7 @@
"version": "0.0.0",
"devDependencies": {
"ente-build-config": "*",
+ "ente-cast-wasm": "*",
"ente-legacy-wasm": "*",
"ente-locker-wasm": "*",
"ente-photos-wasm": "*",
diff --git a/web/packages/utils/wasm.ts b/web/packages/utils/wasm.ts
deleted file mode 100644
index 5f74290786..0000000000
--- a/web/packages/utils/wasm.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-export const readAndFree = <T extends { free: () => void }, U>(
- value: T,
- read: (value: T) => U,
-) => {
- try {
- return read(value);
- } finally {
- value.free();
- }
-};
diff --git a/web/packages/wasm/cast/index.ts b/web/packages/wasm/cast/index.ts
index 889da255a4..8468130e52 100644
--- a/web/packages/wasm/cast/index.ts
+++ b/web/packages/wasm/cast/index.ts
@@ -1,19 +1,8 @@
-import { readAndFree } from "ente-utils/wasm";
+import type { CastReceiver } from "./pkg/ente_cast_wasm";
const wasm = () => import("./pkg/ente_cast_wasm");
-export type CastReceiver = import("./pkg/ente_cast_wasm").CastReceiver;
-
-interface CastPayload {
- castToken: string;
- collectionID: number;
- collectionKey: string;
-}
-
-interface PreparedCastPayload {
- castToken: string;
- encryptedPayload: string;
-}
+export type { CastReceiver } from "./pkg/ente_cast_wasm";
export const createCastReceiver = async (): Promise<CastReceiver> =>
new (await wasm()).CastReceiver();
@@ -21,28 +10,17 @@ export const createCastReceiver = async (): Promise<CastReceiver> =>
export const openCastPayload = (
receiver: CastReceiver,
encryptedPayload: string,
-): CastPayload =>
- readAndFree(receiver.openPayload(encryptedPayload), (payload) => ({
- castToken: payload.castToken,
- collectionID: Number(payload.collectionID),
- collectionKey: payload.collectionKey,
- }));
+) => receiver.openPayload(encryptedPayload);
export const prepareCastPayload = async (
publicKey: string,
pqPublicKey: string | undefined,
collectionID: number,
collectionKey: string,
-): Promise<PreparedCastPayload> =>
- readAndFree(
- (await wasm()).preparePayload(
- publicKey,
- pqPublicKey,
- BigInt(collectionID),
- collectionKey,
- ),
- (payload) => ({
- castToken: payload.castToken,
- encryptedPayload: payload.encryptedPayload,
- }),
+) =>
+ (await wasm()).preparePayload(
+ publicKey,
+ pqPublicKey,
+ BigInt(collectionID),
+ collectionKey,
);
diff --git a/web/packages/wasm/cast/package.json b/web/packages/wasm/cast/package.json
index 4493e3e48a..935b4c2655 100644
--- a/web/packages/wasm/cast/package.json
+++ b/web/packages/wasm/cast/package.json
@@ -13,9 +13,6 @@
"scripts": {
"build": "cd ../../../../rust/bindings/wasm/cast && wasm-pack build . --target bundler --out-dir ../../../../web/packages/wasm/cast/pkg --no-pack -- -Z build-std=panic_abort,std"
},
- "dependencies": {
- "ente-utils": "*"
- },
"devDependencies": {
"ente-build-config": "*",
"wasm-pack": "0.15.0"
diff --git a/web/packages/wasm/ensu/index.ts b/web/packages/wasm/ensu/index.ts
index 6afe99e246..0e1b5e1825 100644
--- a/web/packages/wasm/ensu/index.ts
+++ b/web/packages/wasm/ensu/index.ts
@@ -1,17 +1,11 @@
-import { readAndFree } from "ente-utils/wasm";
+export type { EncryptedChatPayload } from "./pkg/ente_ensu_wasm";
const wasm = () => import("./pkg/ente_ensu_wasm");
export const generateChatKey = async () => (await wasm()).generateChatKey();
export const encryptChatPayload = async (value: string, keyB64: string) =>
- readAndFree(
- (await wasm()).encryptChatPayload(value, keyB64),
- (payload) => ({
- encryptedData: payload.encryptedData,
- header: payload.header,
- }),
- );
+ (await wasm()).encryptChatPayload(value, keyB64);
export const decryptChatPayload = async (
encryptedDataB64: string,
diff --git a/web/packages/wasm/ensu/package.json b/web/packages/wasm/ensu/package.json
index 9d2d6785ca..ec1758c95e 100644
--- a/web/packages/wasm/ensu/package.json
+++ b/web/packages/wasm/ensu/package.json
@@ -13,9 +13,6 @@
"scripts": {
"build": "wasm-pack build ../../../../rust/bindings/wasm/ensu --target bundler --out-dir ../../../../web/packages/wasm/ensu/pkg --no-pack"
},
- "dependencies": {
- "ente-utils": "*"
- },
"devDependencies": {
"ente-build-config": "*",
"wasm-pack": "0.15.0"
diff --git a/web/packages/wasm/locker/index.ts b/web/packages/wasm/locker/index.ts
index 9744d7e835..5604fc01e6 100644
--- a/web/packages/wasm/locker/index.ts
+++ b/web/packages/wasm/locker/index.ts
@@ -1,5 +1,4 @@
import { wrap } from "comlink";
-import { readAndFree } from "ente-utils/wasm";
import { workerReady } from "ente-utils/worker";
import type { FileLinkWorker } from "./file-link.worker";
import type {
@@ -16,10 +15,7 @@ export const openSession = async (input: OpenSessionInput): Promise<Session> =>
(await wasm()).openSession(input);
export const encryptBoxWithRecoveryKey = (session: Session, dataB64: string) =>
- readAndFree(session.encryptWithRecoveryKey(dataB64), (box) => ({
- encryptedData: box.encryptedData,
- nonce: box.nonce,
- }));
+ session.encryptWithRecoveryKey(dataB64);
export const openCollectionKey = async (
session: Session,
@@ -106,16 +102,10 @@ export const openFileLinkSecret = async (
export const generateKey = async () => (await wasm()).cryptoGenerateKey();
export const encryptBox = async (dataB64: string, keyB64: string) =>
- readAndFree((await wasm()).cryptoEncryptBox(dataB64, keyB64), (box) => ({
- encryptedData: box.encryptedData,
- nonce: box.nonce,
- }));
+ (await wasm()).cryptoEncryptBox(dataB64, keyB64);
export const encryptBoxBytes = async (data: Uint8Array, keyB64: string) =>
- readAndFree((await wasm()).cryptoEncryptBoxBytes(data, keyB64), (box) => ({
- encryptedData: box.encryptedData,
- nonce: box.nonce,
- }));
+ (await wasm()).cryptoEncryptBoxBytes(data, keyB64);
export const decryptBox = async (
box: EncryptedBox,
@@ -138,10 +128,7 @@ export const decryptBoxBytes = async (
);
export const encryptBlob = async (data: Uint8Array, keyB64: string) =>
- readAndFree((await wasm()).cryptoEncryptBlob(data, keyB64), (blob) => ({
- encryptedData: blob.encryptedData,
- decryptionHeader: blob.decryptionHeader,
- }));
+ (await wasm()).cryptoEncryptBlob(data, keyB64);
export const decryptMetadataJSON = async (
blob: EncryptedBlob,
@@ -190,16 +177,7 @@ export const createStreamDecryptor = async (
export const encryptFileStreamWithKey = async (
dataB64: string,
keyB64: string,
-) =>
- readAndFree(
- (await wasm()).cryptoEncryptStreamWithKey(dataB64, keyB64),
- (file) => ({
- // wasm-bindgen copies returned bytes into a new ArrayBuffer.
- encryptedData: file.encryptedData as Uint8Array<ArrayBuffer>,
- decryptionHeader: file.decryptionHeader,
- md5Hash: file.md5Hash,
- }),
- );
+) => (await wasm()).cryptoEncryptStreamWithKey(dataB64, keyB64);
const toB64String = (value: Uint8Array | string): string => {
if (typeof value == "string") return value;
diff --git a/web/packages/wasm/photos/index.ts b/web/packages/wasm/photos/index.ts
index 5ed08c542e..a1b793cda1 100644
--- a/web/packages/wasm/photos/index.ts
+++ b/web/packages/wasm/photos/index.ts
@@ -1,4 +1,3 @@
-import { readAndFree } from "ente-utils/wasm";
import type {
OpenSessionInput,
Session,
@@ -13,10 +12,7 @@ export const openSession = async (input: OpenSessionInput): Promise<Session> =>
(await wasm()).openSession(input);
export const encryptBoxWithRecoveryKey = (session: Session, dataB64: string) =>
- readAndFree(session.encryptWithRecoveryKey(dataB64), (box) => ({
- encryptedData: box.encryptedData,
- nonce: box.nonce,
- }));
+ session.encryptWithRecoveryKey(dataB64);
export const generateKey = async () => (await wasm()).cryptoGenerateKey();
diff --git a/web/packages/wasm/photos/package.json b/web/packages/wasm/photos/package.json
index 88326d0278..6c2ea3401f 100644
--- a/web/packages/wasm/photos/package.json
+++ b/web/packages/wasm/photos/package.json
@@ -13,9 +13,6 @@
"scripts": {
"build": "wasm-pack build ../../../../rust/bindings/wasm/photos --target bundler --out-dir ../../../../web/packages/wasm/photos/pkg --no-pack"
},
- "dependencies": {
- "ente-utils": "*"
- },
"devDependencies": {
"ente-build-config": "*",
"wasm-pack": "0.15.0"
diff --git a/web/packages/wasm/prelogin/index.ts b/web/packages/wasm/prelogin/index.ts
index eee65afd51..ec7f7be13f 100644
--- a/web/packages/wasm/prelogin/index.ts
+++ b/web/packages/wasm/prelogin/index.ts
@@ -1,31 +1,18 @@
-import { readAndFree } from "ente-utils/wasm";
import type { SrpSession } from "./pkg/ente_prelogin_wasm";
export type EncryptedBoxB64 = Awaited<ReturnType<typeof encryptBox>>;
export type KeyPair = Awaited<ReturnType<typeof generateKeyPair>>;
+export type { GeneratedKek as DerivedKey } from "./pkg/ente_prelogin_wasm";
const wasm = () => import("./pkg/ente_prelogin_wasm");
type BytesOrB64 = Uint8Array | string;
-export interface DerivedKey {
- key: string;
- salt: string;
- opsLimit: number;
- memLimit: number;
-}
-
interface EncryptedBox {
encryptedData: BytesOrB64;
nonce: BytesOrB64;
}
-interface SRPSetupAttributes {
- srpSalt: string;
- srpVerifier: string;
- loginSubKey: string;
-}
-
export const deriveKey = async (
password: string,
saltB64: string,
@@ -33,37 +20,17 @@ export const deriveKey = async (
memLimit: number,
) => (await wasm()).authDeriveKek(password, saltB64, memLimit, opsLimit);
-export const deriveSensitiveKey = async (
- password: string,
-): Promise<DerivedKey> =>
- readAndFree(
- (await wasm()).authGenerateSensitiveKek(password),
- derivedKeyValue,
- );
+export const deriveSensitiveKey = async (password: string) =>
+ (await wasm()).authGenerateSensitiveKek(password);
-export const deriveInteractiveKey = async (
- password: string,
-): Promise<DerivedKey> =>
- readAndFree(
- (await wasm()).authGenerateInteractiveKek(password),
- derivedKeyValue,
- );
+export const deriveInteractiveKey = async (password: string) =>
+ (await wasm()).authGenerateInteractiveKek(password);
export const deriveSRPLoginKey = async (kekB64: string) =>
(await wasm()).authDeriveSrpLoginKey(kekB64);
-export const generateSRPSetup = async (
- kekB64: string,
- srpUserID: string,
-): Promise<SRPSetupAttributes> =>
- readAndFree(
- (await wasm()).authGenerateSrpSetup(kekB64, srpUserID),
- (setup) => ({
- srpSalt: setup.srpSalt,
- srpVerifier: setup.srpVerifier,
- loginSubKey: setup.loginSubKey,
- }),
- );
+export const generateSRPSetup = async (kekB64: string, srpUserID: string) =>
+ (await wasm()).authGenerateSrpSetup(kekB64, srpUserID);
export const recoveryKeyFromMnemonicOrHex = async (value: string) =>
(await wasm()).authRecoveryKeyFromMnemonicOrHex(value);
@@ -81,16 +48,10 @@ export const createSRPSession = async (
export const generateKey = async () => (await wasm()).cryptoGenerateKey();
export const generateKeyPair = async () =>
- readAndFree((await wasm()).cryptoGenerateKeyPair(), (keyPair) => ({
- publicKey: keyPair.publicKey,
- privateKey: keyPair.privateKey,
- }));
+ (await wasm()).cryptoGenerateKeyPair();
export const encryptBox = async (dataB64: string, keyB64: string) =>
- readAndFree((await wasm()).cryptoEncryptBox(dataB64, keyB64), (box) => ({
- encryptedData: box.encryptedData,
- nonce: box.nonce,
- }));
+ (await wasm()).cryptoEncryptBox(dataB64, keyB64);
export const decryptBox = async (
box: EncryptedBox,
@@ -112,13 +73,6 @@ export const boxSealOpenBytes = async (
keyPair.privateKey,
);
-const derivedKeyValue = (key: DerivedKey): DerivedKey => ({
- key: key.key,
- salt: key.salt,
- opsLimit: key.opsLimit,
- memLimit: key.memLimit,
-});
-
const toB64String = (value: Uint8Array | string): string => {
if (typeof value == "string") return value;
let binary = "";
diff --git a/web/packages/wasm/prelogin/package.json b/web/packages/wasm/prelogin/package.json
index edafa1c29d..a0bccc3f88 100644
--- a/web/packages/wasm/prelogin/package.json
+++ b/web/packages/wasm/prelogin/package.json
@@ -14,9 +14,6 @@
"build": "wasm-pack build ../../../../rust/bindings/wasm/prelogin --target bundler --out-dir ../../../../web/packages/wasm/prelogin/pkg --no-pack",
"test": "vitest --run"
},
- "dependencies": {
- "ente-utils": "*"
- },
"devDependencies": {
"ente-build-config": "*",
"vite-plugin-wasm": "3.6.0",
diff --git a/web/packages/wasm/tests/bindings.test.ts b/web/packages/wasm/tests/bindings.test.ts
index b685188983..7c59902e9a 100644
--- a/web/packages/wasm/tests/bindings.test.ts
+++ b/web/packages/wasm/tests/bindings.test.ts
@@ -1,3 +1,4 @@
+import * as cast from "ente-cast-wasm";
import * as legacy from "ente-legacy-wasm/authenticated";
import * as locker from "ente-locker-wasm";
import * as photos from "ente-photos-wasm";
@@ -13,6 +14,36 @@ import { lockerPrepareFileLinkPayload } from "../locker/pkg/ente_locker_wasm";
afterEach(() => vi.unstubAllGlobals());
+test("Cast rejects collection IDs outside JavaScript's safe integer range", async () => {
+ const receiver = await cast.createCastReceiver();
+ const collectionKey = await generateKey();
+ try {
+ for (const collectionID of [
+ Number.MAX_SAFE_INTEGER,
+ Number.MAX_SAFE_INTEGER + 1,
+ ]) {
+ const { castToken, encryptedPayload } =
+ await cast.prepareCastPayload(
+ receiver.publicKey,
+ undefined,
+ collectionID,
+ collectionKey,
+ );
+ if (Number.isSafeInteger(collectionID)) {
+ expect(
+ cast.openCastPayload(receiver, encryptedPayload),
+ ).toStrictEqual({ castToken, collectionID, collectionKey });
+ } else {
+ expect(() =>
+ cast.openCastPayload(receiver, encryptedPayload),
+ ).toThrow(Error);
+ }
+ }
+ } finally {
+ receiver.free();
+ }
+});
+
for (const [name, api] of [
["Photos", photos],
["Locker", locker],
diff --git a/web/packages/wasm/tests/package.json b/web/packages/wasm/tests/package.json
index dee6296c7b..c76b4e1f78 100644
--- a/web/packages/wasm/tests/package.json
+++ b/web/packages/wasm/tests/package.json
@@ -7,6 +7,7 @@
},
"devDependencies": {
"ente-build-config": "*",
+ "ente-cast-wasm": "*",
"ente-legacy-wasm": "*",
"ente-locker-wasm": "*",
"ente-photos-wasm": "*",