Skip to content

armgit / ente

Public Imported from GitHub
0

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

Fail Space reads on decryption errors

Anand Baburajan3bfc83d9b1df
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rs
index 1c4b257a81..07353a7b09 100644
--- a/rust/bindings/wasm/space/src/space.rs
+++ b/rust/bindings/wasm/space/src/space.rs
@@ -40,6 +40,12 @@ impl WasmSpaceError {
pub fn status(&self) -> Option<u16> {
self.status
}
+
+ /// Preserve the structured error when web logging stringifies this value.
+ #[wasm_bindgen(js_name = toString)]
+ pub fn js_to_string(&self) -> String {
+ format!("{}: {}", self.code, self.message)
+ }
}
impl From<ente_space::SpaceError> for WasmSpaceError {
@@ -301,9 +307,9 @@ fn created_space_to_js(value: CreatedSpace) -> CreatedSpaceJs {
}
}
-fn profile_to_js(value: DecryptedSpaceProfile) -> SpaceProfileJs {
- let profile = utf8_field(value.profile, "profile").unwrap_or_default();
- SpaceProfileJs {
+fn profile_to_js(value: DecryptedSpaceProfile) -> Result<SpaceProfileJs, WasmSpaceError> {
+ let profile = utf8_field(value.profile, "profile")?;
+ Ok(SpaceProfileJs {
space_id: value.space_id,
space_slug: value.space_slug,
version: value.version,
@@ -313,7 +319,7 @@ fn profile_to_js(value: DecryptedSpaceProfile) -> SpaceProfileJs {
avatar: value.avatar,
cover: value.cover,
updated_at: value.updated_at,
- }
+ })
}
fn actor_to_js(
@@ -334,15 +340,8 @@ async fn account_actor_to_js(
ctx: &AccountSpaceCtx,
actor: SpaceActorResponse,
) -> Result<ActorJs, WasmSpaceError> {
- let profile = match ctx.decrypt_actor_profile(&actor).await {
- Ok(profile) => profile,
- Err(error) if error.is_unavailable_record() => None,
- Err(error) => return Err(error.into()),
- };
- match actor_to_js(actor.clone(), profile) {
- Ok(actor) => Ok(actor),
- Err(_) => actor_to_js(actor, None),
- }
+ let profile = ctx.decrypt_actor_profile(&actor).await?;
+ actor_to_js(actor, profile)
}
fn public_actor_to_js(actor: SpaceActorResponse) -> Result<ActorJs, WasmSpaceError> {
@@ -352,14 +351,12 @@ fn public_actor_to_js(actor: SpaceActorResponse) -> Result<ActorJs, WasmSpaceErr
fn post_object_to_js(
post_key: Option<&[u8]>,
object: ente_space::PostObjectPayload,
-) -> PostObjectJs {
+) -> Result<PostObjectJs, WasmSpaceError> {
let metadata = match post_key {
- Some(post_key) => {
- ente_space::client::decrypt_post_object_metadata(post_key, &object).unwrap_or(None)
- }
+ Some(post_key) => ente_space::client::decrypt_post_object_metadata(post_key, &object)?,
None => None,
};
- PostObjectJs {
+ Ok(PostObjectJs {
object_key: object.object_key,
size: object.size,
position: object.position,
@@ -369,13 +366,13 @@ fn post_object_to_js(
width: metadata.as_ref().and_then(|value| value.width),
height: metadata.as_ref().and_then(|value| value.height),
media_type: metadata.and_then(|value| value.media_type),
- }
+ })
}
fn post_objects_to_js(
post_key: Option<&[u8]>,
objects: Vec<ente_space::PostObjectPayload>,
-) -> Vec<PostObjectJs> {
+) -> Result<Vec<PostObjectJs>, WasmSpaceError> {
objects
.into_iter()
.map(|object| post_object_to_js(post_key, object))
@@ -393,10 +390,10 @@ async fn account_post_to_js(
space_id: post.space_id,
space_slug: post.space_slug,
author,
- caption: optional_utf8_field(decrypted.caption_plaintext, "caption").unwrap_or(None),
+ caption: optional_utf8_field(decrypted.caption_plaintext, "caption")?,
encrypted_post_key: post.encrypted_post_key,
key_version: post.key_version,
- objects: post_objects_to_js(Some(&decrypted.post_key), post.objects),
+ objects: post_objects_to_js(Some(&decrypted.post_key), post.objects)?,
created_at: post.created_at,
viewer_liked: post.viewer_liked,
})
@@ -408,13 +405,7 @@ async fn account_post_page_to_js(
) -> Result<PostPageJs, WasmSpaceError> {
let mut items = Vec::with_capacity(page.items.len());
for post in page.items {
- let decrypted = match ctx.decrypt_post_for_space(&post.space_id, &post).await {
- Ok(decrypted) => decrypted,
- Err(error) if error.is_unavailable_record() => {
- continue;
- }
- Err(error) => return Err(error.into()),
- };
+ let decrypted = ctx.decrypt_post_for_space(&post.space_id, &post).await?;
items.push(account_post_to_js(ctx, post, decrypted).await?);
}
Ok(PostPageJs {
@@ -429,10 +420,10 @@ fn link_post_to_js(post: PostResponse, decrypted: DecryptedPost) -> Result<PostJ
space_id: post.space_id,
space_slug: post.space_slug,
author: public_actor_to_js(post.author)?,
- caption: optional_utf8_field(decrypted.caption_plaintext, "caption").unwrap_or(None),
+ caption: optional_utf8_field(decrypted.caption_plaintext, "caption")?,
encrypted_post_key: post.encrypted_post_key,
key_version: post.key_version,
- objects: post_objects_to_js(Some(&decrypted.post_key), post.objects),
+ objects: post_objects_to_js(Some(&decrypted.post_key), post.objects)?,
created_at: post.created_at,
viewer_liked: false,
})
@@ -471,13 +462,7 @@ async fn account_message_response_to_js(
return Ok(message_to_js(message, String::new()));
}
if message.kind != "post_like" && message.kind != "friend_added" {
- let decrypted = match ctx.decrypt_message(viewer_space_id, &message).await {
- Ok(decrypted) => decrypted,
- Err(error) if error.is_unavailable_record() => {
- return Ok(message_to_js(message, String::new()));
- }
- Err(error) => return Err(error.into()),
- };
+ let decrypted = ctx.decrypt_message(viewer_space_id, &message).await?;
return account_message_to_js(message, decrypted).await;
}
@@ -517,11 +502,8 @@ async fn message_conversation_activity_text(
created_at: activity.created_at.clone(),
updated_at: activity.created_at.clone(),
};
- match ctx.decrypt_message(viewer_space_id, &message).await {
- Ok(decrypted) => Ok(Some(decrypted.payload.text)),
- Err(error) if error.is_unavailable_record() => Ok(None),
- Err(error) => Err(error.into()),
- }
+ let decrypted = ctx.decrypt_message(viewer_space_id, &message).await?;
+ Ok(Some(decrypted.payload.text))
}
async fn message_conversation_activity_to_js(
@@ -588,7 +570,7 @@ impl SpaceLinkCtxHandle {
/// Return the decrypted profile bundled into this validated link.
#[wasm_bindgen(js_name = getProfile)]
pub fn get_profile(&self) -> Result<JsValue, WasmSpaceError> {
- let mut profile = profile_to_js(self.inner.profile().clone());
+ let mut profile = profile_to_js(self.inner.profile().clone())?;
profile.posts = Some(self.inner.posts());
swb::to_value(&profile).map_err(Into::into)
}
@@ -745,7 +727,7 @@ impl SpaceAccountCtxHandle {
self.inner
.get_space_profile_decrypted(&space_id, viewer_space_id.as_deref(), None)
.await?,
- ))
+ )?)
.map_err(Into::into)
}
@@ -979,14 +961,7 @@ impl SpaceAccountCtxHandle {
let decrypted = self
.inner
.decrypt_post_for_viewer(&post.space_id, viewer_space_id.as_deref(), &post)
- .await;
- let decrypted = match decrypted {
- Ok(decrypted) => decrypted,
- Err(error) if error.is_unavailable_record() => {
- return Ok(JsValue::NULL);
- }
- Err(error) => return Err(error.into()),
- };
+ .await?;
swb::to_value(&account_post_to_js(&self.inner, post, decrypted).await?).map_err(Into::into)
}
diff --git a/rust/space/src/client/mod.rs b/rust/space/src/client/mod.rs
index f80568ddf0..b971e7e896 100644
--- a/rust/space/src/client/mod.rs
+++ b/rust/space/src/client/mod.rs
@@ -583,11 +583,7 @@ impl AccountSpaceCtx {
let shares = self.list_friend_shares(space_id).await?;
let mut value = Vec::with_capacity(shares.len());
for share in shares {
- match self.decrypt_friend_share(space_id, &share).await {
- Ok(share) => value.push(share),
- Err(error) if error.is_unavailable_record() => {}
- Err(error) => return Err(error),
- }
+ value.push(self.decrypt_friend_share(space_id, &share).await?);
}
cache_lock(&self.friend_shares_cache, "friend shares")?
.insert(space_id.to_owned(), value.clone());
diff --git a/rust/space/src/client/posts.rs b/rust/space/src/client/posts.rs
index f91488158f..25e5bff2b1 100644
--- a/rust/space/src/client/posts.rs
+++ b/rust/space/src/client/posts.rs
@@ -252,11 +252,7 @@ impl AccountSpaceCtx {
for (space_id, _) in &owned {
let friends_records = self.list_friend_shares(space_id).await?;
for record in &friends_records {
- match self.decrypt_friend_share(space_id, record).await {
- Ok(share) => friends.push(share),
- Err(error) if error.is_unavailable_record() => {}
- Err(error) => return Err(error),
- }
+ friends.push(self.decrypt_friend_share(space_id, record).await?);
}
}
diff --git a/rust/space/src/client/profiles.rs b/rust/space/src/client/profiles.rs
index c8ce486d74..8f5445976f 100644
--- a/rust/space/src/client/profiles.rs
+++ b/rust/space/src/client/profiles.rs
@@ -58,14 +58,13 @@ impl AccountSpaceCtx {
Some(profile.version),
)
.await?;
- let Some(space_key) = space_key else {
- return Ok(fallback_space_profile(profile));
- };
- match decrypt_space_profile(&profile, &space_key) {
- Ok(profile) => Ok(profile),
- Err(error) if error.is_unavailable_record() => Ok(fallback_space_profile(profile)),
- Err(error) => Err(error),
- }
+ let space_key = space_key.ok_or_else(|| {
+ SpaceError::InvalidInput(format!(
+ "no key available for space {space_id} version {}",
+ profile.version
+ ))
+ })?;
+ decrypt_space_profile(&profile, &space_key)
}
pub async fn update_space_profile(
@@ -119,16 +118,3 @@ impl AccountSpaceCtx {
Ok(response)
}
}
-
-fn fallback_space_profile(profile: SpaceProfileResponse) -> DecryptedSpaceProfile {
- DecryptedSpaceProfile {
- space_id: profile.space_id,
- space_slug: profile.space_slug,
- version: profile.version,
- friends: profile.friends,
- profile: Vec::new(),
- avatar: profile.avatar,
- cover: profile.cover,
- updated_at: (!profile.updated_at.is_empty()).then_some(profile.updated_at),
- }
-}
diff --git a/rust/space/src/client/tests.rs b/rust/space/src/client/tests.rs
index c546cd4724..fc39bda683 100644
--- a/rust/space/src/client/tests.rs
+++ b/rust/space/src/client/tests.rs
@@ -1141,6 +1141,56 @@ async fn get_space_profile_decrypted_loads_and_decrypts_profile() {
spaces.assert_async().await;
}
+#[tokio::test]
+async fn get_space_profile_decrypted_returns_decryption_error() {
+ let mut server = Server::new_async().await;
+ let space_root_key = generate_key();
+ let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
+ let space_key = generate_key();
+ let encrypted_profile = b64::encode(
+ &encrypt_secretbox_payload(&generate_key(), b"profile-json").expect("profile wrap"),
+ );
+ let profile = server
+ .mock("GET", "/spaces/space_owner_main/profile")
+ .match_header("x-space-session-token", "space-session-token")
+ .with_status(200)
+ .with_body(
+ json!({
+ "spaceId": "space_owner_main",
+ "spaceSlug": "owner-main",
+ "version": 3,
+ "friends": 2,
+ "encryptedProfile": encrypted_profile,
+ "updatedAt": "2026-04-16T00:00:00Z"
+ })
+ .to_string(),
+ )
+ .create_async()
+ .await;
+ let spaces = server
+ .mock("GET", "/account/space")
+ .match_header("x-space-session-token", "space-session-token")
+ .with_status(200)
+ .with_body(owned_space_response(
+ &space_root_key,
+ &space_key,
+ "space_owner_main",
+ "owner-main",
+ 3,
+ ))
+ .create_async()
+ .await;
+
+ let error = ctx
+ .get_space_profile_decrypted("space_owner_main", None, None)
+ .await
+ .expect_err("profile decryption should fail");
+
+ assert!(matches!(error, SpaceError::Crypto(_)));
+ profile.assert_async().await;
+ spaces.assert_async().await;
+}
+
#[tokio::test]
async fn space_status_mutations_accept_empty_server_responses() {
let mut server = Server::new_async().await;
diff --git a/rust/space/src/error.rs b/rust/space/src/error.rs
index 9be10ca5e6..9b20cd7fa1 100644
--- a/rust/space/src/error.rs
+++ b/rust/space/src/error.rs
@@ -25,13 +25,4 @@ pub enum SpaceError {
EntityKeyConflict,
}
-impl SpaceError {
- pub fn is_unavailable_record(&self) -> bool {
- matches!(
- self,
- Self::Crypto(_) | Self::InvalidInput(_) | Self::MissingFriendSealedSpaceKey
- )
- }
-}
-
pub type Result<T> = std::result::Result<T, SpaceError>;
diff --git a/web/apps/space/src/services/spacePersistentSession.ts b/web/apps/space/src/services/spacePersistentSession.ts
index 6be428cb0e..2a1938f739 100644
--- a/web/apps/space/src/services/spacePersistentSession.ts
+++ b/web/apps/space/src/services/spacePersistentSession.ts
@@ -11,6 +11,7 @@ import {
} from "ente-accounts-rs/services/crypto";
import { accountLogout } from "ente-accounts-rs/services/logout";
import { ensureOk, publicRequestHeaders } from "ente-base/http";
+import log from "ente-base/log";
import { apiURL } from "ente-base/origins";
import { removeAuthToken } from "ente-base/token";
import {
@@ -273,7 +274,15 @@ const restoreSpaceBrowserSession = async () => {
},
bootstrap.sessionWrapKey,
);
- } catch {
+ } catch (error) {
+ const details =
+ typeof error == "object" &&
+ error &&
+ "code" in error &&
+ "message" in error
+ ? `${String(error.code)}: ${String(error.message)}`
+ : String(error);
+ log.error(`Failed to decrypt Space browser session: ${details}`);
clearSpaceBrowserSession();
return false;
}
diff --git a/web/apps/space/src/services/spaceProfilePayload.ts b/web/apps/space/src/services/spaceProfilePayload.ts
index 37271cd60e..4938f5a685 100644
--- a/web/apps/space/src/services/spaceProfilePayload.ts
+++ b/web/apps/space/src/services/spaceProfilePayload.ts
@@ -9,15 +9,11 @@ export const parseSpaceProfilePayload = (
): SpaceProfilePayload => {
const trimmed = profile.trim();
if (!trimmed) return {};
- try {
- const parsed: unknown = JSON.parse(trimmed);
- if (parsed && typeof parsed == "object" && !Array.isArray(parsed)) {
- return parsed;
- }
- } catch {
- // Fall through to the empty profile.
+ const parsed: unknown = JSON.parse(trimmed);
+ if (!parsed || typeof parsed != "object" || Array.isArray(parsed)) {
+ throw new Error("Space profile payload must be a JSON object");
}
- return {};
+ return parsed;
};
export const spaceProfileTextField = (value: unknown) =>