Skip to content

armgit / ente

Public Imported from GitHub
0

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

Move Space post handling into Rust and simplify WASM reads

Manav Rathic610e5676e80
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rs
index a13d78a961..e92bd42fe8 100644
--- a/rust/bindings/wasm/space/src/space.rs
+++ b/rust/bindings/wasm/space/src/space.rs
@@ -1,7 +1,7 @@
use std::collections::BTreeMap;
use ente_core::b64;
-use ente_space::{AccountSpaceCtx, DecryptedMessage, DecryptedPost, MessagePayload, SpaceLinkCtx};
+use ente_space::{AccountSpaceCtx, DecryptedMessage, MessagePayload, SpaceLinkCtx};
use serde::{Deserialize, Serialize};
use serde_wasm_bindgen as swb;
use tsify::Tsify;
@@ -178,7 +178,8 @@ pub struct DecryptedSpaceProfile {
friends: i64,
#[serde(skip_serializing_if = "Option::is_none")]
posts: Option<i64>,
- profile: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ profile: Option<SpaceProfile>,
avatar: Option<ProfileAvatarResponse>,
cover: Option<ProfileAvatarResponse>,
updated_at: Option<String>,
@@ -230,7 +231,9 @@ struct SpaceActorResponse {
space_slug: String,
public_key: String,
key_version: i32,
- profile: Option<String>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ profile: Option<SpaceProfile>,
+ #[serde(skip_serializing_if = "Option::is_none")]
avatar: Option<ProfileAvatarResponse>,
}
@@ -242,12 +245,10 @@ pub struct PostResponse {
space_slug: String,
author: SpaceActorResponse,
caption: Option<String>,
- encrypted_post_key: String,
- key_version: i32,
- objects: Vec<PostObjectPayload>,
+ photos: Vec<PostPhoto>,
+ is_unavailable: bool,
created_at: String,
viewer_liked: bool,
- is_unavailable: bool,
}
#[derive(Serialize, Tsify)]
@@ -302,10 +303,8 @@ struct MessageConversationActivity {
#[derive(Serialize, Tsify)]
#[serde(rename_all = "camelCase")]
-struct PostObjectPayload {
- object_key: String,
- #[serde(skip_serializing_if = "Option::is_none")]
- size: Option<i64>,
+struct PostPhoto {
+ asset: PostAsset,
#[serde(skip_serializing_if = "Option::is_none")]
position: Option<i32>,
#[serde(skip_serializing_if = "Option::is_none")]
@@ -454,16 +453,6 @@ fn decode_b64_field(value: &str) -> Result<Vec<u8>, Error> {
.map_err(Into::into)
}
-fn utf8_field(bytes: Vec<u8>, field: &str) -> Result<String, Error> {
- String::from_utf8(bytes).map_err(|err| {
- ente_space::Error::InvalidInput(format!("invalid {field} utf8: {err}")).into()
- })
-}
-
-fn optional_utf8_field(bytes: Option<Vec<u8>>, field: &str) -> Result<Option<String>, Error> {
- bytes.map(|value| utf8_field(value, field)).transpose()
-}
-
fn created_space_to_js(value: ente_space::CreatedSpace) -> CreatedSpace {
CreatedSpace {
space_id: value.space_id,
@@ -471,183 +460,171 @@ fn created_space_to_js(value: ente_space::CreatedSpace) -> CreatedSpace {
}
}
-fn profile_to_js(value: ente_space::DecryptedSpaceProfile) -> Result<DecryptedSpaceProfile, Error> {
- let profile = String::from_utf8(value.profile).unwrap_or_else(|error| {
- log::warn!(
- "Space profile {} has invalid UTF-8: {error}",
- value.space_id
- );
- String::new()
- });
- Ok(DecryptedSpaceProfile {
+fn profile_to_js(value: ente_space::DecryptedSpaceProfile) -> DecryptedSpaceProfile {
+ DecryptedSpaceProfile {
space_id: value.space_id,
space_slug: value.space_slug,
version: value.version,
friends: value.friends,
posts: None,
- profile,
+ profile: value.profile.map(Into::into),
avatar: value.avatar.map(Into::into),
cover: value.cover.map(Into::into),
updated_at: value.updated_at,
- })
+ }
}
fn actor_to_js(
actor: ente_space::SpaceActorResponse,
- profile: Option<Vec<u8>>,
-) -> Result<SpaceActorResponse, Error> {
- Ok(SpaceActorResponse {
+ profile: Option<ente_space::SpaceProfile>,
+) -> SpaceActorResponse {
+ SpaceActorResponse {
space_id: actor.space_id,
space_slug: actor.space_slug,
public_key: actor.public_key,
key_version: actor.key_version,
- profile: optional_utf8_field(profile, "actor profile")?,
+ profile: profile.map(Into::into),
avatar: actor.avatar.map(Into::into),
- })
+ }
}
async fn account_actor_to_js(
ctx: &AccountSpaceCtx,
actor: ente_space::SpaceActorResponse,
) -> Result<SpaceActorResponse, Error> {
- let fallback = actor.clone();
- let converted = match ctx.decrypt_actor_profile(&actor).await {
- Ok(profile) => actor_to_js(actor, profile),
- Err(error) => Err(error.into()),
- };
- match converted {
- Ok(actor) => Ok(actor),
+ match ctx.decrypt_actor_profile(&actor).await.map_err(Error::from) {
+ Ok(profile) => Ok(actor_to_js(actor, profile)),
Err(error) if error.is_content_error() => {
log::warn!(
"Space profile {} fell back to public fields: {}",
- fallback.space_id,
+ actor.space_id,
error.message()
);
- public_actor_to_js(fallback)
+ Ok(public_actor_to_js(actor))
}
Err(error) => Err(error),
}
}
-fn public_actor_to_js(actor: ente_space::SpaceActorResponse) -> Result<SpaceActorResponse, Error> {
+fn public_actor_to_js(actor: ente_space::SpaceActorResponse) -> SpaceActorResponse {
actor_to_js(actor, None)
}
-fn post_object_to_js(
- post_key: Option<&[u8]>,
- object: ente_space::PostObjectPayload,
-) -> Result<PostObjectPayload, Error> {
- let metadata = match post_key {
- Some(post_key) => ente_space::client::decrypt_post_object_metadata(post_key, &object)?,
- None => None,
+fn post_to_js(post: ente_space::Post) -> PostResponse {
+ let (caption, photos, is_unavailable) = match post.content {
+ Ok(content) => (
+ content.caption,
+ content.photos.into_iter().map(Into::into).collect(),
+ false,
+ ),
+ Err(error) => {
+ log::warn!(
+ "Space post {} is unavailable: {}",
+ post.post_id,
+ ente_core::error::chain(&error)
+ );
+ (None, Vec::new(), true)
+ }
};
- Ok(PostObjectPayload {
- object_key: object.object_key,
- size: object.size,
- position: object.position,
- variant: metadata.as_ref().and_then(|value| value.variant.clone()),
- blur_hash: metadata.as_ref().and_then(|value| value.blur_hash.clone()),
- thumb_hash: metadata.as_ref().and_then(|value| value.thumb_hash.clone()),
- 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>,
-) -> Result<Vec<PostObjectPayload>, Error> {
- objects
- .into_iter()
- .map(|object| post_object_to_js(post_key, object))
- .collect()
-}
-
-async fn account_post_to_js(
- ctx: &AccountSpaceCtx,
- post: ente_space::PostResponse,
- decrypted: DecryptedPost,
-) -> Result<PostResponse, Error> {
- let author = account_actor_to_js(ctx, post.author).await?;
- Ok(PostResponse {
+ let profile = post.author.profile.unwrap_or_else(|error| {
+ log::warn!(
+ "Space profile {} fell back to public fields: {}",
+ post.author.space_id,
+ ente_core::error::chain(&error)
+ );
+ None
+ });
+ PostResponse {
post_id: post.post_id,
space_id: post.space_id,
space_slug: post.space_slug,
- author,
- 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)?,
+ author: SpaceActorResponse {
+ space_id: post.author.space_id,
+ space_slug: post.author.space_slug,
+ public_key: post.author.public_key,
+ key_version: post.author.key_version,
+ profile: profile.map(Into::into),
+ avatar: post.author.avatar.map(Into::into),
+ },
+ caption,
+ photos,
+ is_unavailable,
created_at: post.created_at,
viewer_liked: post.viewer_liked,
- is_unavailable: false,
- })
+ }
}
-fn unavailable_post_to_js(post: ente_space::PostResponse) -> Result<PostResponse, Error> {
- Ok(PostResponse {
- post_id: post.post_id,
- space_id: post.space_id,
- space_slug: post.space_slug,
- author: public_actor_to_js(post.author)?,
- caption: None,
- encrypted_post_key: post.encrypted_post_key,
- key_version: post.key_version,
- objects: Vec::new(),
- created_at: post.created_at,
- viewer_liked: post.viewer_liked,
- is_unavailable: true,
- })
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
+struct SpaceProfile {
+ #[serde(skip_serializing_if = "Option::is_none")]
+ full_name: Option<String>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ display_name: Option<String>,
}
-async fn account_post_page_to_js(
- ctx: &AccountSpaceCtx,
- page: ente_space::PostPage,
-) -> Result<PostPage, Error> {
- let mut items = Vec::with_capacity(page.items.len());
- for post in page.items {
- let fallback = post.clone();
- let converted = match ctx.decrypt_post_for_space(&post.space_id, &post).await {
- Ok(decrypted) => account_post_to_js(ctx, post, decrypted).await,
- Err(error) => Err(error.into()),
- };
- match converted {
- Ok(post) => items.push(post),
- Err(error) if error.is_content_error() => {
- log::warn!(
- "Space post {} is unavailable: {}",
- fallback.post_id,
- error.message()
- );
- items.push(unavailable_post_to_js(fallback)?);
- }
- Err(error) => return Err(error),
+impl From<ente_space::SpaceProfile> for SpaceProfile {
+ fn from(profile: ente_space::SpaceProfile) -> Self {
+ Self {
+ full_name: profile.full_name,
+ display_name: profile.display_name,
}
}
- Ok(PostPage {
- items,
- next_cursor: page.next_cursor,
- })
}
-fn link_post_to_js(
- post: ente_space::PostResponse,
- decrypted: DecryptedPost,
-) -> Result<PostResponse, Error> {
- Ok(PostResponse {
- post_id: post.post_id,
- 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")?,
- encrypted_post_key: post.encrypted_post_key,
- key_version: post.key_version,
- objects: post_objects_to_js(Some(&decrypted.post_key), post.objects)?,
- created_at: post.created_at,
- viewer_liked: false,
- is_unavailable: false,
- })
+#[derive(Serialize, Deserialize, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct PostAsset {
+ space_id: String,
+ post_id: i64,
+ object_key: String,
+ encrypted_post_key: String,
+ key_version: i32,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ size: Option<i64>,
+}
+
+impl From<PostAsset> for ente_space::PostAsset {
+ fn from(asset: PostAsset) -> Self {
+ Self {
+ space_id: asset.space_id,
+ post_id: asset.post_id,
+ object_key: asset.object_key,
+ encrypted_post_key: asset.encrypted_post_key,
+ key_version: asset.key_version,
+ size: asset.size,
+ }
+ }
+}
+
+impl From<ente_space::PostPhoto> for PostPhoto {
+ fn from(photo: ente_space::PostPhoto) -> Self {
+ let metadata = photo.metadata.unwrap_or_default();
+ Self {
+ asset: PostAsset {
+ space_id: photo.asset.space_id,
+ post_id: photo.asset.post_id,
+ object_key: photo.asset.object_key,
+ encrypted_post_key: photo.asset.encrypted_post_key,
+ key_version: photo.asset.key_version,
+ size: photo.asset.size,
+ },
+ position: photo.position,
+ variant: metadata.variant,
+ blur_hash: metadata.blur_hash,
+ thumb_hash: metadata.thumb_hash,
+ width: metadata.width,
+ height: metadata.height,
+ media_type: metadata.media_type,
+ }
+ }
+}
+
+fn post_page_to_js(page: ente_space::PostPage) -> PostPage {
+ PostPage {
+ items: page.items.into_iter().map(post_to_js).collect(),
+ next_cursor: page.next_cursor,
+ }
}
fn account_message_to_js(
@@ -884,7 +861,7 @@ pub struct SpaceLinkCtxHandle {
impl SpaceLinkCtxHandle {
#[wasm_bindgen(js_name = getProfile)]
pub fn get_profile(&self) -> Result<<DecryptedSpaceProfile as Tsify>::JsType, Error> {
- 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());
profile.into_js().map_err(Into::into)
}
@@ -892,32 +869,7 @@ impl SpaceLinkCtxHandle {
#[wasm_bindgen(js_name = listPosts)]
pub async fn list_posts(&self) -> Result<<PostPage as Tsify>::JsType, Error> {
let page = self.inner.list_posts().await?;
- let mut items = Vec::with_capacity(page.items.len());
- for post in page.items {
- let fallback = post.clone();
- let converted = match self.inner.decrypt_post(&post) {
- Ok(decrypted) => link_post_to_js(post, decrypted),
- Err(error) => Err(error.into()),
- };
- match converted {
- Ok(post) => items.push(post),
- Err(error) if error.is_content_error() => {
- log::warn!(
- "Space post {} is unavailable: {}",
- fallback.post_id,
- error.message()
- );
- items.push(unavailable_post_to_js(fallback)?);
- }
- Err(error) => return Err(error),
- }
- }
- PostPage {
- items,
- next_cursor: page.next_cursor,
- }
- .into_js()
- .map_err(Into::into)
+ post_page_to_js(page).into_js().map_err(Into::into)
}
#[wasm_bindgen(js_name = subscribeWebPush)]
@@ -944,12 +896,11 @@ impl SpaceLinkCtxHandle {
#[wasm_bindgen(js_name = downloadPostAsset)]
pub async fn download_post_asset(
&self,
- encrypted_post_key: String,
- key_version: i32,
- object_key: String,
+ asset: <PostAsset as Tsify>::JsType,
) -> Result<Vec<u8>, Error> {
+ let asset = PostAsset::from_js(asset)?;
self.inner
- .download_post_asset(&encrypted_post_key, key_version, &object_key)
+ .download_post_asset(&asset.into())
.await
.map_err(Into::into)
}
@@ -1028,7 +979,7 @@ impl SpaceAccountCtxHandle {
self.inner
.get_space_profile_for_display(&space_id, viewer_space_id.as_deref(), None)
.await?,
- )?
+ )
.into_js()
.map_err(Into::into)
}
@@ -1162,10 +1113,7 @@ impl SpaceAccountCtxHandle {
limit: Option<i32>,
) -> Result<<PostPage as Tsify>::JsType, Error> {
let page = self.inner.list_feed(&space_id, cursor, limit).await?;
- account_post_page_to_js(&self.inner, page)
- .await?
- .into_js()
- .map_err(Into::into)
+ post_page_to_js(page).into_js().map_err(Into::into)
}
#[wasm_bindgen(js_name = unreadStatus)]
@@ -1201,13 +1149,11 @@ impl SpaceAccountCtxHandle {
cursor: Option<String>,
limit: Option<i32>,
) -> Result<<PostPage as Tsify>::JsType, Error> {
- account_post_page_to_js(
- &self.inner,
+ post_page_to_js(
self.inner
.list_posts(&space_id, viewer_space_id.as_deref(), cursor, limit)
.await?,
)
- .await?
.into_js()
.map_err(Into::into)
}
@@ -1223,14 +1169,7 @@ impl SpaceAccountCtxHandle {
.inner
.get_post(&space_id, post_id, viewer_space_id.as_deref())
.await?;
- let decrypted = self
- .inner
- .decrypt_post_for_viewer(&post.space_id, viewer_space_id.as_deref(), &post)
- .await?;
- account_post_to_js(&self.inner, post, decrypted)
- .await?
- .into_js()
- .map_err(Into::into)
+ post_to_js(post).into_js().map_err(Into::into)
}
#[wasm_bindgen(js_name = createPhotoPost)]
@@ -1282,33 +1221,18 @@ impl SpaceAccountCtxHandle {
.inner
.get_post(&space_id, post_id, Some(&space_id))
.await?;
- let decrypted = self
- .inner
- .decrypt_post_for_viewer(&post.space_id, Some(&space_id), &post)
- .await?;
- account_post_to_js(&self.inner, post, decrypted)
- .await?
- .into_js()
- .map_err(Into::into)
+ post_to_js(post).into_js().map_err(Into::into)
}
- #[wasm_bindgen(js_name = downloadPostAssetWithKey)]
- pub async fn download_post_asset_with_key(
+ #[wasm_bindgen(js_name = downloadPostAsset)]
+ pub async fn download_post_asset(
&self,
- space_id: String,
- encrypted_post_key: String,
- key_version: i32,
+ asset: <PostAsset as Tsify>::JsType,
viewer_space_id: Option<String>,
- object_key: String,
) -> Result<Vec<u8>, Error> {
+ let asset = PostAsset::from_js(asset)?;
self.inner
- .download_post_asset_with_key(
- &space_id,
- &encrypted_post_key,
- key_version,
- viewer_space_id.as_deref(),
- &object_key,
- )
+ .download_post_asset(&asset.into(), viewer_space_id.as_deref())
.await
.map_err(Into::into)
}
@@ -1493,7 +1417,7 @@ impl SpaceAccountCtxHandle {
for request in response.pending_requests {
pending_requests.push(SpaceFriendRequestResponse {
request_id: request.request_id,
- requester: public_actor_to_js(request.requester)?,
+ requester: public_actor_to_js(request.requester),
created_at: request.created_at,
});
}
@@ -1565,21 +1489,8 @@ impl SpaceAccountCtxHandle {
post_id: i64,
caption: Option<String>,
) -> Result<(), Error> {
- let post = self
- .inner
- .get_post(&space_id, post_id, Some(&space_id))
- .await?;
- let decrypted_post = self
- .inner
- .decrypt_post_for_viewer(&post.space_id, Some(&space_id), &post)
- .await?;
self.inner
- .update_post_caption(
- &space_id,
- post_id,
- &decrypted_post.post_key,
- caption.as_ref().map(String::as_bytes),
- )
+ .update_post_caption(&space_id, post_id, caption.as_ref().map(String::as_bytes))
.await
.map_err(Into::into)
}
@@ -1623,7 +1534,7 @@ impl SpaceAccountCtxHandle {
items.push(
SpaceFriendRequestResponse {
request_id: request.request_id,
- requester: public_actor_to_js(request.requester)?,
+ requester: public_actor_to_js(request.requester),
created_at: request.created_at,
}
.into_js()?,
@@ -1643,7 +1554,7 @@ impl SpaceAccountCtxHandle {
items.push(
SpaceSentFriendRequestResponse {
request_id: request.request_id,
- target: public_actor_to_js(request.target)?,
+ target: public_actor_to_js(request.target),
created_at: request.created_at,
}
.into_js()?,
@@ -1698,25 +1609,6 @@ mod tests {
use super::*;
- fn post(post_id: i64, encrypted_post_key: String) -> ente_space::PostResponse {
- ente_space::PostResponse {
- post_id,
- space_id: "space-1".into(),
- space_slug: "alice".into(),
- author: ente_space::SpaceActorResponse {
- space_id: "space-1".into(),
- space_slug: "alice".into(),
- ..Default::default()
- },
- encrypted_post_key,
- caption_cipher: String::new(),
- key_version: 1,
- objects: Vec::new(),
- created_at: format!("2026-08-0{post_id}T00:00:00Z"),
- viewer_liked: false,
- }
- }
-
fn message(
message_id: &str,
encrypted_message_key: &str,
@@ -1740,54 +1632,6 @@ mod tests {
}
}
- #[tokio::test]
- async fn corrupt_post_does_not_reject_account_page() {
- let root_key = Key::generate();
- let space_key = Key::generate();
- let wrapped_space_key = secretbox::encrypt_combined(space_key.as_bytes(), &root_key);
- let valid_post_key = secretbox::encrypt_combined(Key::generate().as_bytes(), &space_key);
- let ctx = AccountSpaceCtx::open(ente_space::OpenAccountSpaceCtxInput {
- base_url: "http://localhost".into(),
- space_session_token: None,
- space_root_key: root_key.as_bytes().to_vec(),
- initial_owned_spaces: Some(vec![ente_space::SpaceKeyResponse {
- space_id: "space-1".into(),
- space_slug: "alice".into(),
- root_wrapped_space_key: b64::encode(&wrapped_space_key),
- public_key: String::new(),
- encrypted_secret_key: String::new(),
- encrypted_profile: String::new(),
- key_version: 1,
- }]),
- user_agent: None,
- client_package: None,
- client_version: None,
- })
- .unwrap();
- let mut post_with_corrupt_actor_profile = post(1, b64::encode(&valid_post_key));
- post_with_corrupt_actor_profile.author.key_version = 1;
- post_with_corrupt_actor_profile.author.encrypted_profile = "not-base64".into();
- let page = ente_space::PostPage {
- items: vec![
- post_with_corrupt_actor_profile,
- post(2, "not-base64".into()),
- post(3, b64::encode(&valid_post_key)),
- ],
- next_cursor: "next".into(),
- };
-
- let converted = match account_post_page_to_js(&ctx, page).await {
- Ok(converted) => converted,
- Err(error) => panic!("{error}"),
- };
-
- assert_eq!(converted.items.len(), 3);
- assert!(!converted.items[0].is_unavailable);
- assert!(converted.items[1].is_unavailable);
- assert!(!converted.items[2].is_unavailable);
- assert_eq!(converted.next_cursor, "next");
- }
-
fn message_context() -> (AccountSpaceCtx, Key, String) {
let root_key = Key::generate();
let secret_key = SecretKey::generate();
@@ -1968,22 +1812,4 @@ mod tests {
assert!(!error.is_content_error());
}
-
- #[test]
- fn invalid_profile_utf8_uses_empty_payload() {
- let profile = profile_to_js(ente_space::DecryptedSpaceProfile {
- space_id: "space-1".into(),
- space_slug: "alice".into(),
- version: 1,
- friends: 2,
- profile: vec![0xff],
- avatar: None,
- cover: None,
- updated_at: None,
- })
- .unwrap_or_else(|error| panic!("{error}"));
-
- assert!(profile.profile.is_empty());
- assert_eq!(profile.space_slug, "alice");
- }
}
diff --git a/rust/crates/space/src/client/keys.rs b/rust/crates/space/src/client/keys.rs
index 765f9c67e3..7bac9446cb 100644
--- a/rust/crates/space/src/client/keys.rs
+++ b/rust/crates/space/src/client/keys.rs
@@ -1,7 +1,7 @@
use std::collections::BTreeMap;
use super::{AccountSpaceCtx, build_space_key_history_map};
-use crate::crypto::{encrypt_secretbox_payload, generate_key};
+use crate::crypto::{decrypt_secretbox_payload, encrypt_secretbox_payload, generate_key};
use crate::error::{Error, Result};
use crate::models::CreatedSpace;
use crate::transport::{RotateSpaceKeyRequest, SpaceKeyResponse, SpaceKeyVersionResponse};
@@ -80,20 +80,21 @@ impl AccountSpaceCtx {
.ok_or_else(|| {
Error::InvalidInput(format!("space {space_id} is not owned by the account"))
})?;
- let current_profile = if profile.is_none() {
- Some(
- self.get_space_profile_decrypted(space_id, None, None)
- .await?,
- )
- } else {
- None
- };
let next_profile = match profile {
Some(value) => value.to_vec(),
- None => current_profile
- .as_ref()
- .map(|value| value.profile.clone())
- .ok_or_else(|| Error::InvalidInput("missing current profile".into()))?,
+ None => {
+ let profile = self.get_space_profile_raw(space_id, None, None).await?;
+ let key = self
+ .resolve_space_key_for_version(space_id, Some(profile.version))
+ .await?
+ .ok_or_else(|| Error::InvalidInput("missing current profile key".into()))?;
+ // Preserve unknown profile fields during key rotation.
+ if profile.encrypted_profile.is_empty() {
+ Vec::new()
+ } else {
+ decrypt_secretbox_payload(&key, &b64::decode(&profile.encrypted_profile)?)?
+ }
+ }
};
let next_space_key = generate_key();
let space_root_key = self.get_or_create_space_root_key()?;
diff --git a/rust/crates/space/src/client/links.rs b/rust/crates/space/src/client/links.rs
index c6db530b3a..1a01683654 100644
--- a/rust/crates/space/src/client/links.rs
+++ b/rust/crates/space/src/client/links.rs
@@ -8,14 +8,15 @@ use ente_core::{
use super::{
AccountSpaceCtx, build_api, build_space_key_history_map, cache_lock, decrypt_space_profile,
+ posts::{decrypt_post, open_post_content, opened_post},
space_profile_without_payload,
};
use crate::{
crypto::{decrypt_asset_payload, decrypt_secretbox_payload, encrypt_secretbox_payload},
error::{Error, Result},
- models::{CreatedSpaceLink, DecryptedPost, DecryptedSpaceProfile, OpenSpaceLinkCtxInput},
+ models::{CreatedSpaceLink, DecryptedSpaceProfile, OpenSpaceLinkCtxInput, PostAsset, PostPage},
transport::{
- AssetDownloadResponse, PostPage, PostResponse, SpaceKeyVersionResponse,
+ AssetDownloadResponse, PostPageResponse, SpaceKeyVersionResponse,
SpaceLinkBootstrapResponse, SpaceLinkProfileResponse, SpaceLinkStatusResponse,
SpaceLinkWriteRequest, WebPushSubscriptionKeys, WebPushSubscriptionRequest,
WebPushTargetResponse, WebPushUnsubscriptionRequest,
@@ -247,7 +248,7 @@ impl SpaceLinkCtx {
}
pub async fn list_posts(&self) -> Result<PostPage> {
- let page: PostPage = self
+ let page: PostPageResponse = self
.api
.get(&format!("{}/posts", self.prefix()))
.header(AUTH_HEADER, &self.auth_key)
@@ -267,7 +268,21 @@ impl SpaceLinkCtx {
"space link changed while posts were being loaded".into(),
));
}
- Ok(page)
+ let items = page
+ .items
+ .into_iter()
+ .map(|mut post| {
+ let decrypted = self
+ .space_key(post.key_version, "post")
+ .and_then(|space_key| decrypt_post(&space_key, &post));
+ let content = open_post_content(&mut post, decrypted)?;
+ Ok(opened_post(post, content, Ok(None)))
+ })
+ .collect::<Result<Vec<_>>>()?;
+ Ok(PostPage {
+ items,
+ next_cursor: page.next_cursor,
+ })
}
pub async fn subscribe_web_push(
@@ -303,33 +318,11 @@ impl SpaceLinkCtx {
Ok(())
}
- pub fn decrypt_post(&self, post: &PostResponse) -> Result<DecryptedPost> {
- let space_key = self.space_key(post.key_version, "post")?;
+ pub async fn download_post_asset(&self, asset: &PostAsset) -> Result<Vec<u8>> {
+ let space_key = self.space_key(asset.key_version, "post")?;
let post_key =
- decrypt_secretbox_payload(&space_key, &b64::decode(&post.encrypted_post_key)?)?;
- let caption_plaintext = if post.caption_cipher.is_empty() {
- None
- } else {
- Some(decrypt_secretbox_payload(
- &post_key,
- &b64::decode(&post.caption_cipher)?,
- )?)
- };
- Ok(DecryptedPost {
- post_key,
- caption_plaintext,
- })
- }
-
- pub async fn download_post_asset(
- &self,
- encrypted_post_key: &str,
- key_version: i32,
- object_key: &str,
- ) -> Result<Vec<u8>> {
- let space_key = self.space_key(key_version, "post")?;
- let post_key = decrypt_secretbox_payload(&space_key, &b64::decode(encrypted_post_key)?)?;
- self.download_asset(vec![("objectKey", object_key.to_owned())], &post_key)
+ decrypt_secretbox_payload(&space_key, &b64::decode(&asset.encrypted_post_key)?)?;
+ self.download_asset(vec![("objectKey", asset.object_key.clone())], &post_key)
.await
}
@@ -377,7 +370,7 @@ impl SpaceLinkCtx {
format!("/space/public/by-slug/{}/link", self.space_slug)
}
- fn has_keys_for_posts(&self, page: &PostPage) -> Result<bool> {
+ fn has_keys_for_posts(&self, page: &PostPageResponse) -> Result<bool> {
let key_history = cache_lock(&self.key_history, "space link key history")?;
Ok(page
.items
@@ -662,12 +655,48 @@ mod tests {
.await
.unwrap();
- assert_eq!(ctx.profile().profile, profile);
+ assert_eq!(
+ ctx.profile().profile,
+ Some(crate::SpaceProfile::from_bytes(profile).unwrap())
+ );
assert_eq!(ctx.profile().friends, 2);
assert_eq!(ctx.posts(), 3);
bootstrap.assert_async().await;
profile_request.assert_async().await;
versions.assert_async().await;
+ let post_key = vec![5; Key::BYTES];
+ let valid = serde_json::json!({
+ "postId": 1, "spaceId": "space-alice", "spaceSlug": "alice",
+ "author": { "spaceSlug": "alice" }, "keyVersion": 1,
+ "encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &post_key).unwrap()),
+ "captionCipher": b64::encode(&encrypt_secretbox_payload(&post_key, b"hello").unwrap()),
+ "objects": [{ "objectKey": "photo", "metadataCipher": b64::encode(&encrypt_secretbox_payload(&post_key, br#"{"width":100,"mediaType":"image/webp"}"#).unwrap()) }],
+ "createdAt": "2026-07-26T00:00:00Z", "viewerLiked": false,
+ });
+ let mut corrupt = valid.clone();
+ corrupt["postId"] = 2.into();
+ corrupt["encryptedPostKey"] = "not-base64".into();
+ let posts = server
+ .mock("GET", format!("{prefix}/posts").as_str())
+ .match_header("x-space-link-auth", auth.as_str())
+ .with_body(
+ serde_json::json!({ "items": [valid, corrupt], "nextCursor": "next" }).to_string(),
+ )
+ .create_async()
+ .await;
+
+ let page = ctx.list_posts().await.unwrap();
+ let content = page.items[0].content.as_ref().unwrap();
+ assert_eq!(content.caption.as_deref(), Some("hello"));
+ assert_eq!(content.photos[0].asset.object_key, "photo");
+ assert_eq!(
+ content.photos[0].metadata.as_ref().unwrap().width,
+ Some(100)
+ );
+ assert!(page.items[0].author.profile.as_ref().unwrap().is_none());
+ assert!(matches!(page.items[1].content, Err(Error::Base64Decode(_))));
+ assert_eq!(page.next_cursor, "next");
+ posts.assert_async().await;
}
#[tokio::test]
@@ -708,7 +737,7 @@ mod tests {
space_slug: "alice".to_owned(),
version: 1,
friends: 0,
- profile: Vec::new(),
+ profile: None,
avatar: None,
cover: None,
updated_at: None,
diff --git a/rust/crates/space/src/client/messages.rs b/rust/crates/space/src/client/messages.rs
index 159d4bdbc9..04bf5ee0c3 100644
--- a/rust/crates/space/src/client/messages.rs
+++ b/rust/crates/space/src/client/messages.rs
@@ -176,7 +176,7 @@ impl AccountSpaceCtx {
object_key: Option<&str>,
) -> Result<MessageResponse> {
let post = self
- .get_post(post_space_id, post_id, Some(sender_space_id))
+ .get_post_raw(post_space_id, post_id, Some(sender_space_id))
.await?;
if self
.resolve_owned_space_access(&post.space_id)
diff --git a/rust/crates/space/src/client/mod.rs b/rust/crates/space/src/client/mod.rs
index c3a25b246b..4c8e6a745e 100644
--- a/rust/crates/space/src/client/mod.rs
+++ b/rust/crates/space/src/client/mod.rs
@@ -666,7 +666,7 @@ fn encrypt_post_object_metadata(post_key: &[u8], metadata: &PostObjectMetadata)
)?))
}
-pub fn decrypt_post_object_metadata(
+fn decrypt_post_object_metadata(
post_key: &[u8],
object: &PostObjectPayload,
) -> Result<Option<PostObjectMetadata>> {
@@ -779,7 +779,11 @@ pub(super) fn decrypt_space_profile(
space_slug: profile.space_slug.clone(),
version: profile.version,
friends: profile.friends,
- profile: profile_bytes,
+ profile: if profile_bytes.is_empty() {
+ None
+ } else {
+ Some(crate::SpaceProfile::from_bytes(&profile_bytes)?)
+ },
avatar: profile.avatar.clone(),
cover: profile.cover.clone(),
updated_at: if profile.updated_at.is_empty() {
@@ -798,7 +802,7 @@ pub(super) fn space_profile_without_payload(
space_slug: profile.space_slug.clone(),
version: profile.version,
friends: profile.friends,
- profile: Vec::new(),
+ profile: None,
avatar: profile.avatar.clone(),
cover: profile.cover.clone(),
updated_at: if profile.updated_at.is_empty() {
diff --git a/rust/crates/space/src/client/posts.rs b/rust/crates/space/src/client/posts.rs
index f26278dd5a..d8974f7ff9 100644
--- a/rust/crates/space/src/client/posts.rs
+++ b/rust/crates/space/src/client/posts.rs
@@ -1,9 +1,11 @@
use super::{AccountSpaceCtx, decrypt_post_object_metadata, ensure_post_objects_are_photos};
use crate::crypto::{decrypt_secretbox_payload, encrypt_secretbox_payload, generate_key};
use crate::error::{Error, Result};
-use crate::models::{DecryptedPost, HydratedKeys, PostObjectMetadata};
+use crate::models::{
+ HydratedKeys, Post, PostAsset, PostContent, PostPage, PostPhoto, SpaceActor, SpaceProfile,
+};
use crate::transport::{
- CreatePostRequest, CreatePostResponse, LikePostResponse, PostObjectPayload, PostPage,
+ CreatePostRequest, CreatePostResponse, LikePostResponse, PostObjectPayload, PostPageResponse,
PostResponse, SpaceActorResponse, SpaceUnreadStatusResponse, UpdatePostCaptionRequest,
};
use ente_core::{b64, http};
@@ -80,7 +82,7 @@ impl AccountSpaceCtx {
query.push(("limit", value.to_string()));
}
let path = format!("/spaces/{space_id}/posts");
- Ok(self
+ let page = self
.api()
.get(&path)
.query(&query)
@@ -88,7 +90,8 @@ impl AccountSpaceCtx {
.await?
.error_for_status()?
.json()
- .await?)
+ .await?;
+ self.open_post_page(page).await
}
pub async fn list_feed(
@@ -120,7 +123,7 @@ impl AccountSpaceCtx {
fetch_feed,
self.list_decrypted_friend_shares_cached(space_id)
)?;
- Ok(page)
+ self.open_post_page(page).await
}
pub async fn unread_status(&self, space_id: &str) -> Result<SpaceUnreadStatusResponse> {
@@ -165,6 +168,50 @@ impl AccountSpaceCtx {
space_id: &str,
post_id: i64,
viewer_space_id: Option<&str>,
+ ) -> Result<Post> {
+ let post = self
+ .get_post_raw(space_id, post_id, viewer_space_id)
+ .await?;
+ let post = self.open_post(post, viewer_space_id).await?;
+ Ok(Post {
+ content: Ok(post.content?),
+ ..post
+ })
+ }
+
+ async fn open_post_page(&self, page: PostPageResponse) -> Result<PostPage> {
+ let mut items = Vec::with_capacity(page.items.len());
+ for post in page.items {
+ items.push(self.open_post(post, None).await?);
+ }
+ Ok(PostPage {
+ items,
+ next_cursor: page.next_cursor,
+ })
+ }
+
+ async fn open_post(
+ &self,
+ mut post: PostResponse,
+ viewer_space_id: Option<&str>,
+ ) -> Result<Post> {
+ let decrypted = self
+ .decrypt_post_for_viewer(&post.space_id, viewer_space_id, &post)
+ .await;
+ let content = open_post_content(&mut post, decrypted)?;
+ let profile = if content.is_ok() {
+ retain_content_error(self.decrypt_actor_profile(&post.author).await)?
+ } else {
+ Ok(None)
+ };
+ Ok(opened_post(post, content, profile))
+ }
+
+ pub(super) async fn get_post_raw(
+ &self,
+ space_id: &str,
+ post_id: i64,
+ viewer_space_id: Option<&str>,
) -> Result<PostResponse> {
let path = format!("/spaces/{space_id}/posts/{post_id}");
let mut query = Vec::new();
@@ -182,52 +229,28 @@ impl AccountSpaceCtx {
.await?)
}
- pub async fn fetch_post_decrypted(
- &self,
- space_id: &str,
- post_id: i64,
- viewer_space_id: Option<&str>,
- ) -> Result<DecryptedPost> {
- let post = self.get_post(space_id, post_id, viewer_space_id).await?;
- self.decrypt_post_for_viewer(&post.space_id, viewer_space_id, &post)
- .await
- }
-
pub async fn download_post_asset(
&self,
- space_id: &str,
- post_id: i64,
+ asset: &PostAsset,
viewer_space_id: Option<&str>,
- object_key: &str,
) -> Result<Vec<u8>> {
- let post = self.get_post(space_id, post_id, viewer_space_id).await?;
- let decrypted = self
- .decrypt_post_for_viewer(&post.space_id, viewer_space_id, &post)
+ let post_key = self
+ .decrypt_post_key_fields(
+ &asset.space_id,
+ viewer_space_id,
+ &asset.encrypted_post_key,
+ asset.key_version,
+ )
.await?;
self.download_decrypted_asset(
- &post.space_id,
+ &asset.space_id,
viewer_space_id,
- object_key,
- &decrypted.post_key,
+ &asset.object_key,
+ &post_key,
)
.await
}
- pub async fn download_post_asset_with_key(
- &self,
- space_id: &str,
- encrypted_post_key: &str,
- key_version: i32,
- viewer_space_id: Option<&str>,
- object_key: &str,
- ) -> Result<Vec<u8>> {
- let post_key = self
- .decrypt_post_key_fields(space_id, viewer_space_id, encrypted_post_key, key_version)
- .await?;
- self.download_decrypted_asset(space_id, viewer_space_id, object_key, &post_key)
- .await
- }
-
pub async fn hydrate_space_keys(&self) -> Result<HydratedKeys> {
let space_root_key = self.get_space_root_key()?;
let owned_records = self.list_owned_spaces().await?;
@@ -251,12 +274,7 @@ impl AccountSpaceCtx {
Ok(HydratedKeys { owned, friends })
}
- pub fn decrypt_post_key(&self, space_key: &[u8], post: &PostResponse) -> Result<Vec<u8>> {
- let packed = b64::decode(&post.encrypted_post_key)?;
- decrypt_secretbox_payload(space_key, &packed)
- }
-
- pub async fn decrypt_post_key_fields(
+ async fn decrypt_post_key_fields(
&self,
space_id: &str,
viewer_space_id: Option<&str>,
@@ -271,37 +289,7 @@ impl AccountSpaceCtx {
decrypt_secretbox_payload(&space_key, &packed)
}
- pub fn decrypt_post(&self, space_key: &[u8], post: &PostResponse) -> Result<DecryptedPost> {
- let post_key = self.decrypt_post_key(space_key, post)?;
- let caption_plaintext = if post.caption_cipher.is_empty() {
- None
- } else {
- let packed = b64::decode(&post.caption_cipher)?;
- Some(decrypt_secretbox_payload(&post_key, &packed)?)
- };
- Ok(DecryptedPost {
- post_key,
- caption_plaintext,
- })
- }
-
- pub fn decrypt_post_object_metadata(
- &self,
- post_key: &[u8],
- object: &PostObjectPayload,
- ) -> Result<Option<PostObjectMetadata>> {
- decrypt_post_object_metadata(post_key, object)
- }
-
- pub async fn decrypt_post_for_space(
- &self,
- space_id: &str,
- post: &PostResponse,
- ) -> Result<DecryptedPost> {
- self.decrypt_post_for_viewer(space_id, None, post).await
- }
-
- pub async fn decrypt_post_for_viewer(
+ async fn decrypt_post_for_viewer(
&self,
space_id: &str,
viewer_space_id: Option<&str>,
@@ -317,13 +305,13 @@ impl AccountSpaceCtx {
.ok_or_else(|| {
Error::InvalidInput(format!("no space key available for post {}", post.post_id))
})?;
- self.decrypt_post(&space_key, post)
+ decrypt_post(&space_key, post)
}
pub async fn decrypt_actor_profile(
&self,
actor: &SpaceActorResponse,
- ) -> Result<Option<Vec<u8>>> {
+ ) -> Result<Option<SpaceProfile>> {
if actor.encrypted_profile.trim().is_empty()
|| actor.space_id.trim().is_empty()
|| actor.key_version <= 0
@@ -336,22 +324,28 @@ impl AccountSpaceCtx {
else {
return Ok(None);
};
- Ok(Some(decrypt_secretbox_payload(
+ Ok(Some(SpaceProfile::from_bytes(&decrypt_secretbox_payload(
&space_key,
&b64::decode(&actor.encrypted_profile)?,
- )?))
+ )?)?))
}
pub async fn update_post_caption(
&self,
space_id: &str,
post_id: i64,
- post_key: &[u8],
caption_plaintext: Option<&[u8]>,
) -> Result<()> {
+ let post = self.get_post_raw(space_id, post_id, Some(space_id)).await?;
+ let decrypted = self
+ .decrypt_post_for_viewer(&post.space_id, Some(space_id), &post)
+ .await?;
let request = UpdatePostCaptionRequest {
caption_cipher: match caption_plaintext {
- Some(value) => Some(b64::encode(&encrypt_secretbox_payload(post_key, value)?)),
+ Some(value) => Some(b64::encode(&encrypt_secretbox_payload(
+ &decrypted.post_key,
+ value,
+ )?)),
None => None,
},
};
@@ -400,3 +394,289 @@ impl AccountSpaceCtx {
}
}
}
+
+pub(super) struct DecryptedPost {
+ post_key: Vec<u8>,
+ caption_plaintext: Option<Vec<u8>>,
+}
+
+pub(super) fn decrypt_post(space_key: &[u8], post: &PostResponse) -> Result<DecryptedPost> {
+ let post_key = decrypt_secretbox_payload(space_key, &b64::decode(&post.encrypted_post_key)?)?;
+ let caption_plaintext = if post.caption_cipher.is_empty() {
+ None
+ } else {
+ Some(decrypt_secretbox_payload(
+ &post_key,
+ &b64::decode(&post.caption_cipher)?,
+ )?)
+ };
+ Ok(DecryptedPost {
+ post_key,
+ caption_plaintext,
+ })
+}
+
+fn utf8_field(bytes: Vec<u8>, field: &str) -> Result<String> {
+ String::from_utf8(bytes)
+ .map_err(|error| Error::InvalidInput(format!("invalid {field} utf8: {error}")))
+}
+
+fn retain_content_error<T>(result: Result<T>) -> Result<Result<T>> {
+ match result {
+ Err(error) if !error.is_content_error() => Err(error),
+ result => Ok(result),
+ }
+}
+
+pub(super) fn open_post_content(
+ post: &mut PostResponse,
+ decrypted: Result<DecryptedPost>,
+) -> Result<Result<PostContent>> {
+ retain_content_error(decrypted.and_then(|decrypted| {
+ let caption = decrypted
+ .caption_plaintext
+ .map(|bytes| utf8_field(bytes, "caption"))
+ .transpose()?;
+ let photos = std::mem::take(&mut post.objects)
+ .into_iter()
+ .filter(|object| !object.object_key.trim().is_empty())
+ .map(|object| {
+ let metadata = decrypt_post_object_metadata(&decrypted.post_key, &object)?;
+ Ok(PostPhoto {
+ asset: PostAsset {
+ space_id: post.space_id.clone(),
+ post_id: post.post_id,
+ object_key: object.object_key,
+ encrypted_post_key: post.encrypted_post_key.clone(),
+ key_version: post.key_version,
+ size: object.size,
+ },
+ position: object.position,
+ metadata,
+ })
+ })
+ .collect::<Result<Vec<_>>>()?;
+ if photos.is_empty() {
+ return Err(Error::InvalidInput("post has no photos".into()));
+ }
+ Ok(PostContent { caption, photos })
+ }))
+}
+
+pub(super) fn opened_post(
+ post: PostResponse,
+ content: Result<PostContent>,
+ profile: Result<Option<SpaceProfile>>,
+) -> Post {
+ Post {
+ post_id: post.post_id,
+ space_id: post.space_id,
+ space_slug: post.space_slug,
+ author: SpaceActor {
+ space_id: post.author.space_id,
+ space_slug: post.author.space_slug,
+ public_key: post.author.public_key,
+ key_version: post.author.key_version,
+ profile,
+ avatar: post.author.avatar,
+ },
+ content,
+ created_at: post.created_at,
+ viewer_liked: post.viewer_liked,
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use ente_core::crypto::{Key, secretbox};
+
+ fn post(post_id: i64, encrypted_post_key: String) -> PostResponse {
+ PostResponse {
+ post_id,
+ space_id: "space-1".into(),
+ space_slug: "alice".into(),
+ author: crate::SpaceActorResponse {
+ space_id: "space-1".into(),
+ space_slug: "alice".into(),
+ ..Default::default()
+ },
+ encrypted_post_key,
+ caption_cipher: String::new(),
+ key_version: 1,
+ objects: vec![PostObjectPayload {
+ object_key: "photo".into(),
+ size: None,
+ position: None,
+ metadata_cipher: None,
+ }],
+ created_at: format!("2026-08-0{post_id}T00:00:00Z"),
+ viewer_liked: false,
+ }
+ }
+
+ #[tokio::test]
+ async fn corrupt_posts_reject_single_reads_but_not_pages() {
+ let mut server = mockito::Server::new_async().await;
+ let root_key = Key::generate();
+ let space_key = Key::generate();
+ let wrapped_space_key = secretbox::encrypt_combined(space_key.as_bytes(), &root_key);
+ let post_key = Key::generate();
+ let valid_post_key = secretbox::encrypt_combined(post_key.as_bytes(), &space_key);
+ let ctx = AccountSpaceCtx::open(crate::OpenAccountSpaceCtxInput {
+ base_url: server.url(),
+ space_session_token: None,
+ space_root_key: root_key.as_bytes().to_vec(),
+ initial_owned_spaces: Some(vec![crate::SpaceKeyResponse {
+ space_id: "space-1".into(),
+ space_slug: "alice".into(),
+ root_wrapped_space_key: b64::encode(&wrapped_space_key),
+ public_key: String::new(),
+ encrypted_secret_key: String::new(),
+ encrypted_profile: String::new(),
+ key_version: 1,
+ }]),
+ user_agent: None,
+ client_package: None,
+ client_version: None,
+ })
+ .unwrap();
+ let mut post_with_corrupt_actor_profile = post(1, b64::encode(&valid_post_key));
+ post_with_corrupt_actor_profile.author.key_version = 1;
+ post_with_corrupt_actor_profile.author.encrypted_profile = "not-base64".into();
+ let mut valid_post = post(3, b64::encode(&valid_post_key));
+ valid_post.author.key_version = 1;
+ valid_post.author.encrypted_profile = b64::encode(&secretbox::encrypt_combined(
+ br#"{"fullName":"Alice"}"#,
+ &space_key,
+ ));
+ let mut invalid_caption = post(4, b64::encode(&valid_post_key));
+ invalid_caption.caption_cipher =
+ b64::encode(&secretbox::encrypt_combined(&[0xff], &post_key));
+ let mut invalid_metadata = post(5, b64::encode(&valid_post_key));
+ invalid_metadata.objects.push(PostObjectPayload {
+ object_key: "photo".into(),
+ size: None,
+ position: None,
+ metadata_cipher: Some("not-base64".into()),
+ });
+ let mut corrupt_post = post(2, "not-base64".into());
+ let mut corrupt_caption = post(6, b64::encode(&valid_post_key));
+ corrupt_caption.caption_cipher =
+ b64::encode(&secretbox::encrypt_combined(b"caption", &space_key));
+ let mut empty_post = post(7, b64::encode(&valid_post_key));
+ empty_post.objects.clear();
+ let mut blank_photo = post(8, b64::encode(&valid_post_key));
+ blank_photo.objects[0].object_key = " ".into();
+ for post in [
+ &mut empty_post,
+ &mut blank_photo,
+ &mut corrupt_post,
+ &mut invalid_caption,
+ &mut invalid_metadata,
+ &mut corrupt_caption,
+ ] {
+ post.author.key_version = 2;
+ post.author.encrypted_profile = "not-base64".into();
+ }
+ let profile_keys = server
+ .mock("GET", "/account/space")
+ .with_status(503)
+ .expect(0)
+ .create_async()
+ .await;
+ let page = PostPageResponse {
+ items: vec![
+ post_with_corrupt_actor_profile,
+ corrupt_post,
+ valid_post,
+ invalid_caption,
+ invalid_metadata,
+ corrupt_caption,
+ empty_post,
+ blank_photo,
+ ],
+ next_cursor: "next".into(),
+ };
+
+ for index in [1, 3, 4, 5, 6, 7] {
+ let post = &page.items[index];
+ let read = server
+ .mock(
+ "GET",
+ format!("/spaces/space-1/posts/{}", post.post_id).as_str(),
+ )
+ .with_body(serde_json::to_string(post).unwrap())
+ .create_async()
+ .await;
+ assert!(matches!(
+ ctx.get_post("space-1", post.post_id, None).await,
+ Err(error) if error.is_content_error()
+ ));
+ read.assert_async().await;
+ }
+
+ let page = ctx.open_post_page(page).await.unwrap();
+
+ assert_eq!(page.items.len(), 8);
+ assert!(page.items[0].content.is_ok());
+ assert!(matches!(
+ page.items[0].author.profile,
+ Err(Error::Base64Decode(_))
+ ));
+ assert!(matches!(page.items[1].content, Err(Error::Base64Decode(_))));
+ assert_eq!(page.items[1].post_id, 2);
+ assert!(page.items[2].content.is_ok());
+ assert_eq!(
+ page.items[2]
+ .author
+ .profile
+ .as_ref()
+ .unwrap()
+ .as_ref()
+ .unwrap()
+ .full_name
+ .as_deref(),
+ Some("Alice")
+ );
+ assert!(
+ matches!(&page.items[3].content, Err(Error::InvalidInput(message)) if message.contains("caption utf8"))
+ );
+ assert!(matches!(page.items[4].content, Err(Error::Base64Decode(_))));
+ assert!(matches!(page.items[5].content, Err(Error::Crypto(_))));
+ assert!(matches!(page.items[6].content, Err(Error::InvalidInput(_))));
+ assert!(matches!(page.items[7].content, Err(Error::InvalidInput(_))));
+ for index in [1, 3, 4, 5, 6, 7] {
+ assert!(matches!(page.items[index].author.profile, Ok(None)));
+ }
+ assert_eq!(page.next_cursor, "next");
+ profile_keys.assert_async().await;
+ }
+
+ #[tokio::test]
+ async fn key_fetch_failure_rejects_the_page() {
+ let mut server = mockito::Server::new_async().await;
+ let ctx = crate::client::test_support::test_account_ctx(&server.url());
+ let page = PostPageResponse {
+ items: vec![post(1, "not-base64".into())],
+ next_cursor: String::new(),
+ };
+ let posts = server
+ .mock("GET", "/spaces/space-1/posts")
+ .with_body(serde_json::to_string(&page).unwrap())
+ .create_async()
+ .await;
+ let keys = server
+ .mock("GET", "/account/space")
+ .with_status(403)
+ .create_async()
+ .await;
+
+ assert!(matches!(
+ ctx.list_posts("space-1", None, None, None).await,
+ Err(Error::Http(http::Error::Http { status: 403, .. }))
+ ));
+ posts.assert_async().await;
+ keys.assert_async().await;
+ }
+}
diff --git a/rust/crates/space/src/client/tests.rs b/rust/crates/space/src/client/tests.rs
index d68066ef9e..ba227f36ee 100644
--- a/rust/crates/space/src/client/tests.rs
+++ b/rust/crates/space/src/client/tests.rs
@@ -121,7 +121,8 @@ async fn account_space_key_resolution_is_cached_within_context() {
let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());
let friend_space_key = generate_key();
let encrypted_profile = b64::encode(
- &encrypt_secretbox_payload(&friend_space_key, b"friend-profile").expect("profile wrap"),
+ &encrypt_secretbox_payload(&friend_space_key, br#"{"fullName":"Friend"}"#)
+ .expect("profile wrap"),
);
let sealed_share =
seal_with_public_key(&friend_space_key, &test_public_key(&ctx)).expect("friend share seal");
@@ -184,8 +185,8 @@ async fn account_space_key_resolution_is_cached_within_context() {
.await
.expect("second profile decrypt");
- assert_eq!(first.as_deref(), Some(b"friend-profile".as_slice()));
- assert_eq!(second.as_deref(), Some(b"friend-profile".as_slice()));
+ assert_eq!(first.unwrap().full_name.as_deref(), Some("Friend"));
+ assert_eq!(second.unwrap().full_name.as_deref(), Some("Friend"));
spaces.assert_async().await;
shares.assert_async().await;
}
@@ -290,8 +291,7 @@ async fn upload_post_photo_asset_attaches_photo_metadata() {
assert_eq!(payload.object_key, "photo-object");
assert_eq!(payload.position, Some(0));
- let metadata = ctx
- .decrypt_post_object_metadata(&post_key, &payload)
+ let metadata = decrypt_post_object_metadata(&post_key, &payload)
.expect("metadata should decrypt")
.expect("metadata should exist");
assert_eq!(metadata.width, Some(4032));
@@ -1118,8 +1118,9 @@ async fn get_space_profile_decrypted_loads_and_decrypts_profile() {
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(&space_key, b"profile-json").expect("profile wrap"));
+ let encrypted_profile = b64::encode(
+ &encrypt_secretbox_payload(&space_key, br#"{"fullName":"Owner"}"#).expect("profile wrap"),
+ );
let profile = server
.mock("GET", "/spaces/space_owner_main/profile")
.match_header("x-space-session-token", "space-session-token")
@@ -1160,7 +1161,10 @@ async fn get_space_profile_decrypted_loads_and_decrypts_profile() {
assert_eq!(decrypted.space_slug, "owner-main");
assert_eq!(decrypted.version, 3);
assert_eq!(decrypted.friends, 2);
- assert_eq!(decrypted.profile, b"profile-json");
+ assert_eq!(
+ decrypted.profile.unwrap().full_name.as_deref(),
+ Some("Owner")
+ );
profile.assert_async().await;
spaces.assert_async().await;
}
@@ -1264,7 +1268,7 @@ async fn get_space_profile_for_display_keeps_envelope_on_decryption_error() {
assert_eq!(decrypted.space_slug, "owner-main");
assert_eq!(decrypted.version, 3);
assert_eq!(decrypted.friends, 2);
- assert!(decrypted.profile.is_empty());
+ assert!(decrypted.profile.is_none());
profile.assert_async().await;
spaces.assert_async().await;
}
@@ -1317,7 +1321,42 @@ async fn space_status_mutations_accept_empty_server_responses() {
#[tokio::test]
async fn update_post_caption_uses_caption_endpoint() {
let mut server = Server::new_async().await;
- let ctx = test_account_ctx(&server.url());
+ let root_key = generate_key();
+ let space_key = generate_key();
+ let post_key = generate_key();
+ let ctx = test_account_ctx_with_space_root_key(&server.url(), root_key.clone());
+ let spaces = server
+ .mock("GET", "/account/space")
+ .with_body(owned_space_response(
+ &root_key,
+ &space_key,
+ "space_owner_main",
+ "owner",
+ 1,
+ ))
+ .create_async()
+ .await;
+ let mut post = json!({
+ "postId": 42,
+ "spaceId": "space_owner_main",
+ "spaceSlug": "owner",
+ "author": { "spaceSlug": "owner" },
+ "encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &post_key).unwrap()),
+ "captionCipher": b64::encode(&encrypt_secretbox_payload(&post_key, b"old caption").unwrap()),
+ "keyVersion": 1,
+ "objects": [],
+ "createdAt": "2026-04-16T00:00:00Z",
+ "viewerLiked": false,
+ });
+ let read = server
+ .mock("GET", "/spaces/space_owner_main/posts/42")
+ .match_query(Matcher::UrlEncoded(
+ "viewerSpaceId".into(),
+ "space_owner_main".into(),
+ ))
+ .with_body(post.to_string())
+ .create_async()
+ .await;
let update = server
.mock("POST", "/spaces/space_owner_main/posts/42/caption")
.match_header("x-space-session-token", "space-session-token")
@@ -1328,15 +1367,26 @@ async fn update_post_caption_uses_caption_endpoint() {
.create_async()
.await;
- ctx.update_post_caption(
- "space_owner_main",
- 42,
- &generate_key(),
- Some(b"updated caption".as_slice()),
- )
- .await
- .expect("caption update should succeed");
+ ctx.update_post_caption("space_owner_main", 42, Some(b"updated caption".as_slice()))
+ .await
+ .expect("caption update should succeed");
+ spaces.assert_async().await;
+ read.assert_async().await;
+ read.remove_async().await;
+ post["captionCipher"] = "not-base64".into();
+ let corrupt = server
+ .mock("GET", "/spaces/space_owner_main/posts/42")
+ .match_query(Matcher::Any)
+ .with_body(post.to_string())
+ .create_async()
+ .await;
+ assert!(matches!(
+ ctx.update_post_caption("space_owner_main", 42, Some(b"updated caption"))
+ .await,
+ Err(Error::Base64Decode(_))
+ ));
+ corrupt.assert_async().await;
update.assert_async().await;
}
@@ -1831,7 +1881,21 @@ async fn refresh_friend_shares_accepts_empty_server_response() {
#[tokio::test]
async fn list_feed_uses_feed_endpoint() {
let mut server = Server::new_async().await;
- let ctx = test_account_ctx(&server.url());
+ let root_key = generate_key();
+ let space_key = generate_key();
+ let ctx = test_account_ctx_with_space_root_key(&server.url(), root_key.clone());
+ let spaces = server
+ .mock("GET", "/account/space")
+ .with_status(200)
+ .with_body(owned_space_response(
+ &root_key,
+ &space_key,
+ "space_friend_gallery",
+ "gallery",
+ 3,
+ ))
+ .create_async()
+ .await;
let shares = server
.mock("GET", "/spaces/space_owner_main/friends/shares")
.match_header("x-space-session-token", "space-session-token")
@@ -1857,10 +1921,10 @@ async fn list_feed_uses_feed_endpoint() {
"spaceId": "space_owner_gallery",
"spaceSlug": "owner-gallery"
},
- "encryptedPostKey": "cGFja2Vk",
+ "encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &generate_key()).unwrap()),
"captionCipher": "",
"keyVersion": 3,
- "objects": [],
+ "objects": [{"objectKey": "photo"}],
"createdAt": "2026-04-16T00:00:00Z",
"viewerLiked": true
}],
@@ -1877,6 +1941,8 @@ async fn list_feed_uses_feed_endpoint() {
.expect("feed should load");
assert_eq!(page.items.len(), 1);
+ assert!(page.items[0].content.is_ok());
+ spaces.assert_async().await;
assert_eq!(page.items[0].post_id, 42);
assert_eq!(page.next_cursor, "cursor-2");
shares.assert_async().await;
@@ -1886,7 +1952,21 @@ async fn list_feed_uses_feed_endpoint() {
#[tokio::test]
async fn list_posts_uses_space_posts_page_endpoint() {
let mut server = Server::new_async().await;
- let ctx = test_account_ctx(&server.url());
+ let root_key = generate_key();
+ let space_key = generate_key();
+ let ctx = test_account_ctx_with_space_root_key(&server.url(), root_key.clone());
+ let spaces = server
+ .mock("GET", "/account/space")
+ .with_status(200)
+ .with_body(owned_space_response(
+ &root_key,
+ &space_key,
+ "space_owner_main",
+ "gallery",
+ 3,
+ ))
+ .create_async()
+ .await;
let posts = server
.mock("GET", "/spaces/space_owner_gallery/posts")
.match_header("x-space-session-token", "space-session-token")
@@ -1906,10 +1986,10 @@ async fn list_posts_uses_space_posts_page_endpoint() {
"spaceId": "space_owner_gallery",
"spaceSlug": "owner-gallery"
},
- "encryptedPostKey": "cGFja2Vk",
+ "encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &generate_key()).unwrap()),
"captionCipher": "",
"keyVersion": 3,
- "objects": [],
+ "objects": [{"objectKey": "photo"}],
"createdAt": "2026-04-16T00:00:00Z",
"viewerLiked": true
}],
@@ -1931,13 +2011,15 @@ async fn list_posts_uses_space_posts_page_endpoint() {
.expect("post page should load");
assert_eq!(page.items.len(), 1);
+ assert!(page.items[0].content.is_ok());
+ spaces.assert_async().await;
assert_eq!(page.items[0].post_id, 41);
assert_eq!(page.next_cursor, "41");
posts.assert_async().await;
}
#[tokio::test]
-async fn fetch_post_decrypted_uses_post_by_id_endpoint() {
+async fn get_post_returns_decrypted_content() {
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());
@@ -1977,7 +2059,7 @@ async fn fetch_post_decrypted_uses_post_by_id_endpoint() {
"encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &post_key).expect("post key wrap")),
"captionCipher": b64::encode(&encrypt_secretbox_payload(&post_key, caption).expect("caption wrap")),
"keyVersion": 3,
- "objects": [],
+ "objects": [{"objectKey": "photo"}],
"createdAt": "2026-04-16T00:00:00Z",
"viewerLiked": false
})
@@ -1987,14 +2069,14 @@ async fn fetch_post_decrypted_uses_post_by_id_endpoint() {
.await;
let decrypted = ctx
- .fetch_post_decrypted("space_owner_gallery", 42, None)
+ .get_post("space_owner_gallery", 42, None)
.await
.expect("post should decrypt");
- assert_eq!(decrypted.post_key, post_key);
+ assert_eq!(decrypted.post_id, 42);
assert_eq!(
- decrypted.caption_plaintext.as_deref(),
- Some(caption.as_slice())
+ decrypted.content.unwrap().caption.as_deref(),
+ Some("hello from post")
);
spaces.assert_async().await;
post.assert_async().await;
diff --git a/rust/crates/space/src/lib.rs b/rust/crates/space/src/lib.rs
index c6b5c61693..d90a72f5e6 100644
--- a/rust/crates/space/src/lib.rs
+++ b/rust/crates/space/src/lib.rs
@@ -13,16 +13,16 @@ pub use client::{
};
pub use error::{Error, Result};
pub use models::{
- CreatedSpace, CreatedSpaceLink, DecryptedFriendShare, DecryptedMessage, DecryptedPost,
- DecryptedSpaceProfile, HydratedKeys, MessagePayload, OpenAccountSpaceCtxInput,
- OpenSpaceLinkCtxInput, PostObjectMetadata,
+ CreatedSpace, CreatedSpaceLink, DecryptedFriendShare, DecryptedMessage, DecryptedSpaceProfile,
+ HydratedKeys, MessagePayload, OpenAccountSpaceCtxInput, OpenSpaceLinkCtxInput, Post, PostAsset,
+ PostContent, PostObjectMetadata, PostPage, PostPhoto, SpaceActor, SpaceProfile,
};
pub use transport::{
ConversationChatSummaryResponse, ConversationsResponse, EntityKeyPayload,
FriendRelationshipResponse, FriendShareResponse, FriendStatusResponse, LikeMessageResponse,
LikePostResponse, MessageConversationActivity, MessagePage, MessageResponse, PostObjectPayload,
- PostPage, PostResponse, PresignUploadResponse, ProfileAvatarPayload, ProfileAvatarResponse,
- ProfileCoverPayload, ProfileCoverResponse, SpaceActorResponse, SpaceFriendRequestResponse,
- SpaceFriendResponse, SpaceKeyResponse, SpaceKeyVersionResponse, SpaceLookupResponse,
- SpaceProfileResponse, SpaceSentFriendRequestResponse, SpaceUnreadStatusResponse,
+ PresignUploadResponse, ProfileAvatarPayload, ProfileAvatarResponse, ProfileCoverPayload,
+ ProfileCoverResponse, SpaceActorResponse, SpaceFriendRequestResponse, SpaceFriendResponse,
+ SpaceKeyResponse, SpaceKeyVersionResponse, SpaceLookupResponse, SpaceProfileResponse,
+ SpaceSentFriendRequestResponse, SpaceUnreadStatusResponse,
};
diff --git a/rust/crates/space/src/models.rs b/rust/crates/space/src/models.rs
index 6bf2c34653..19bbe5e15d 100644
--- a/rust/crates/space/src/models.rs
+++ b/rust/crates/space/src/models.rs
@@ -1,6 +1,7 @@
use serde::{Deserialize, Serialize};
use zeroize::ZeroizeOnDrop;
+use crate::Result;
use crate::transport::{ProfileAvatarResponse, ProfileCoverResponse, SpaceKeyResponse};
#[derive(Clone)]
@@ -47,16 +48,86 @@ pub struct DecryptedSpaceProfile {
pub space_slug: String,
pub version: i32,
pub friends: i64,
- pub profile: Vec<u8>,
+ pub profile: Option<SpaceProfile>,
pub avatar: Option<ProfileAvatarResponse>,
pub cover: Option<ProfileCoverResponse>,
pub updated_at: Option<String>,
}
-#[derive(Clone)]
-pub struct DecryptedPost {
- pub post_key: Vec<u8>,
- pub caption_plaintext: Option<Vec<u8>>,
+pub struct Post {
+ pub post_id: i64,
+ pub space_id: String,
+ pub space_slug: String,
+ pub author: SpaceActor,
+ pub content: Result<PostContent>,
+ pub created_at: String,
+ pub viewer_liked: bool,
+}
+
+pub struct SpaceActor {
+ pub space_id: String,
+ pub space_slug: String,
+ pub public_key: String,
+ pub key_version: i32,
+ pub profile: Result<Option<SpaceProfile>>,
+ pub avatar: Option<ProfileAvatarResponse>,
+}
+
+pub struct PostContent {
+ pub caption: Option<String>,
+ pub photos: Vec<PostPhoto>,
+}
+
+pub struct PostPhoto {
+ pub asset: PostAsset,
+ pub position: Option<i32>,
+ pub metadata: Option<PostObjectMetadata>,
+}
+
+pub struct PostAsset {
+ pub space_id: String,
+ pub post_id: i64,
+ pub object_key: String,
+ pub encrypted_post_key: String,
+ pub key_version: i32,
+ pub size: Option<i64>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct SpaceProfile {
+ pub full_name: Option<String>,
+ pub display_name: Option<String>,
+}
+
+impl SpaceProfile {
+ pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
+ if bytes.iter().all(u8::is_ascii_whitespace) {
+ return Ok(Self::default());
+ }
+ let value: serde_json::Value = serde_json::from_slice(bytes).map_err(|error| {
+ crate::Error::InvalidInput(format!("invalid profile JSON: {error}"))
+ })?;
+ let fields = value
+ .as_object()
+ .ok_or_else(|| crate::Error::InvalidInput("profile must be a JSON object".into()))?;
+ let text = |key| {
+ fields
+ .get(key)
+ .and_then(serde_json::Value::as_str)
+ .map(str::trim)
+ .filter(|value| !value.is_empty())
+ .map(str::to_owned)
+ };
+ Ok(Self {
+ full_name: text("fullName"),
+ display_name: text("displayName"),
+ })
+ }
+}
+
+pub struct PostPage {
+ pub items: Vec<Post>,
+ pub next_cursor: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
@@ -106,3 +177,35 @@ pub struct HydratedKeys {
pub owned: Vec<(String, Vec<u8>)>,
pub friends: Vec<DecryptedFriendShare>,
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn profile_names_are_optional_trimmed_strings() {
+ let profile = SpaceProfile::from_bytes(
+ br#"{"fullName":" Alice ","displayName":" A ","bio":"hello"}"#,
+ )
+ .unwrap();
+ assert_eq!(profile.full_name.as_deref(), Some("Alice"));
+ assert_eq!(profile.display_name.as_deref(), Some("A"));
+ for bytes in [b" ".as_slice(), br#"{"fullName":42,"displayName":" "}"#] {
+ assert_eq!(
+ SpaceProfile::from_bytes(bytes).unwrap(),
+ SpaceProfile::default()
+ );
+ }
+ }
+
+ #[test]
+ fn invalid_profile_payload_is_a_content_error() {
+ for bytes in [b"{".as_slice(), b"null", b"[]", &[0xff]] {
+ assert!(
+ SpaceProfile::from_bytes(bytes)
+ .unwrap_err()
+ .is_content_error()
+ );
+ }
+ }
+}
diff --git a/rust/crates/space/src/transport.rs b/rust/crates/space/src/transport.rs
index f23cee8c62..995d8b1311 100644
--- a/rust/crates/space/src/transport.rs
+++ b/rust/crates/space/src/transport.rs
@@ -254,7 +254,7 @@ pub struct PostResponse {
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
-pub struct PostPage {
+pub struct PostPageResponse {
pub items: Vec<PostResponse>,
#[serde(default)]
pub next_cursor: String,
diff --git a/rust/crates/space/tests/space.rs b/rust/crates/space/tests/space.rs
index d5e0c5ae4f..2e6886e2fb 100644
--- a/rust/crates/space/tests/space.rs
+++ b/rust/crates/space/tests/space.rs
@@ -94,7 +94,10 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {
.get_space_profile_decrypted(&owner_space.space_id, None, None)
.await
.expect("owner should decrypt profile");
- assert_eq!(decrypted_profile.profile, owner_profile);
+ assert_eq!(
+ decrypted_profile.profile,
+ Some(ente_space::SpaceProfile::from_bytes(&owner_profile).unwrap())
+ );
assert_eq!(decrypted_profile.space_slug, owner_slug);
space::assert_http_status(
@@ -146,12 +149,13 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {
.await
.expect("post creation should succeed");
let owner_post = owner_ctx
- .fetch_post_decrypted(&owner_space.space_id, post_id, None)
+ .get_post(&owner_space.space_id, post_id, None)
.await
.expect("owner should decrypt post");
+ let owner_content = owner_post.content.as_ref().expect("owner post content");
assert_eq!(
- owner_post.caption_plaintext.as_deref(),
- Some(br#"{"caption":"hello world"}"#.as_slice())
+ owner_content.caption.as_deref(),
+ Some(r#"{"caption":"hello world"}"#)
);
let owner_feed = owner_ctx
.list_feed(&owner_space.space_id, None, Some(10))
@@ -159,14 +163,11 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {
.expect("owner feed should load");
assert_eq!(owner_feed.items.len(), 1);
assert_eq!(owner_feed.items[0].post_id, post_id);
- let own_feed_post = owner_ctx
- .decrypt_post_for_space(&owner_space.space_id, &owner_feed.items[0])
- .await
+ let own_feed_post = owner_feed.items[0]
+ .content
+ .as_ref()
.expect("own feed post should decrypt");
- assert_eq!(
- own_feed_post.caption_plaintext,
- owner_post.caption_plaintext
- );
+ assert_eq!(own_feed_post.caption, owner_content.caption);
space::assert_http_status(
owner_ctx
@@ -214,14 +215,20 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {
.get_space_profile_decrypted(&owner_space.space_id, Some(&friend_space.space_id), None)
.await
.expect("approved friend should decrypt profile");
- assert_eq!(friend_profile.profile, updated_profile);
+ assert_eq!(
+ friend_profile.profile,
+ Some(ente_space::SpaceProfile::from_bytes(&updated_profile).unwrap())
+ );
assert_eq!(friend_profile.space_slug, updated_slug);
let owner_view_of_friend = owner_ctx
.get_space_profile_decrypted(&friend_space.space_id, Some(&owner_space.space_id), None)
.await
.expect("approved owner should decrypt friend profile");
- assert_eq!(owner_view_of_friend.profile, friend_profile_payload);
+ assert_eq!(
+ owner_view_of_friend.profile,
+ Some(ente_space::SpaceProfile::from_bytes(&friend_profile_payload).unwrap())
+ );
assert_eq!(owner_view_of_friend.space_slug, friend_slug);
let friend_feed = friend_ctx
@@ -232,22 +239,20 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {
assert_eq!(friend_feed.items[0].post_id, post_id);
assert_eq!(friend_feed.items[0].author.space_id, owner_space.space_id);
assert_eq!(friend_feed.items[0].author.space_slug, updated_slug);
- let feed_post_author_profile = friend_ctx
- .decrypt_actor_profile(&friend_feed.items[0].author)
- .await
+ let feed_post_author_profile = friend_feed.items[0]
+ .author
+ .profile
+ .as_ref()
.expect("friend should decrypt feed post author profile");
assert_eq!(
- feed_post_author_profile.as_deref(),
- Some(updated_profile.as_slice())
+ feed_post_author_profile.as_ref(),
+ Some(&ente_space::SpaceProfile::from_bytes(&updated_profile).unwrap())
);
- let friend_feed_post = friend_ctx
- .decrypt_post_for_space(&owner_space.space_id, &friend_feed.items[0])
- .await
+ let friend_feed_post = friend_feed.items[0]
+ .content
+ .as_ref()
.expect("friend feed post should decrypt");
- assert_eq!(
- friend_feed_post.caption_plaintext,
- owner_post.caption_plaintext
- );
+ assert_eq!(friend_feed_post.caption, owner_content.caption);
let liked = friend_ctx
.like_post(&friend_space.space_id, post_id, true)
@@ -276,7 +281,7 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {
space::assert_http_status(
outsider_ctx
- .fetch_post_decrypted(&owner_space.space_id, post_id, None)
+ .get_post(&owner_space.space_id, post_id, None)
.await,
403,
);
@@ -340,12 +345,18 @@ async fn space_unfriend_revokes_reciprocal_account_access_suite(endpoint: &str)
.get_space_profile_decrypted(&owner_space.space_id, Some(&friend_space.space_id), None)
.await
.expect("friend should decrypt owner profile before unfriend");
- assert_eq!(friend_owner_profile.profile, owner_profile);
+ assert_eq!(
+ friend_owner_profile.profile,
+ Some(ente_space::SpaceProfile::from_bytes(&owner_profile).unwrap())
+ );
let owner_friend_profile = owner_ctx
.get_space_profile_decrypted(&friend_space.space_id, Some(&owner_space.space_id), None)
.await
.expect("owner should decrypt friend profile before unfriend");
- assert_eq!(owner_friend_profile.profile, friend_profile);
+ assert_eq!(
+ owner_friend_profile.profile,
+ Some(ente_space::SpaceProfile::from_bytes(&friend_profile).unwrap())
+ );
let friend_feed = friend_ctx
.list_feed(&friend_space.space_id, None, Some(10))
.await
@@ -503,7 +514,7 @@ async fn space_unfriend_revokes_reciprocal_account_access_suite(endpoint: &str)
);
space::assert_http_status(
friend_ctx
- .fetch_post_decrypted(&owner_space.space_id, post_id, Some(&friend_space.space_id))
+ .get_post(&owner_space.space_id, post_id, Some(&friend_space.space_id))
.await,
403,
);
diff --git a/web/apps/space/src/services/media-cache.ts b/web/apps/space/src/services/media-cache.ts
index 258cf555d1..c43d1389f1 100644
--- a/web/apps/space/src/services/media-cache.ts
+++ b/web/apps/space/src/services/media-cache.ts
@@ -2,7 +2,6 @@ import { savedPartialLocalUser } from "ente-accounts/services/accounts-db";
import { blobCache, clearBlobCache } from "ente-base/blob-cache";
import log from "ente-base/log";
import { apiOrigin } from "ente-base/origins";
-import { blobPartForBytes } from "services/profile-payload";
const maxSpaceMediaCacheEntries = 128;
const spaceMediaURLCache = new Map<string, Promise<string>>();
@@ -30,7 +29,7 @@ const trimSpaceMediaURLCache = () => {
};
const blobForBytes = (bytes: Uint8Array, mediaType?: string) =>
- new Blob([blobPartForBytes(bytes)], { type: mediaType || undefined });
+ new Blob([new Uint8Array(bytes).buffer], { type: mediaType || undefined });
const sha256Hex = async (value: string) => {
const digest = await crypto.subtle.digest(
diff --git a/web/apps/space/src/services/profile-payload.ts b/web/apps/space/src/services/profile-payload.ts
deleted file mode 100644
index 730895a712..0000000000
--- a/web/apps/space/src/services/profile-payload.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import log from "ente-base/log";
-
-export interface SpaceProfilePayload {
- displayName?: unknown;
- fullName?: unknown;
- username?: unknown;
-}
-
-export const parseSpaceProfilePayload = (
- profile: string,
-): 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 (error) {
- log.warn("Failed to decode Space profile JSON", error);
- }
- return {};
-};
-
-export const spaceProfileTextField = (value: unknown) =>
- typeof value == "string" ? value.trim() : "";
-
-export const blobPartForBytes = (bytes: Uint8Array): ArrayBuffer => {
- const copy = new Uint8Array(bytes.byteLength);
- copy.set(bytes);
- return copy.buffer;
-};
diff --git a/web/apps/space/src/services/profile.ts b/web/apps/space/src/services/profile.ts
index 6ffa4d8a21..f95c60f913 100644
--- a/web/apps/space/src/services/profile.ts
+++ b/web/apps/space/src/services/profile.ts
@@ -28,10 +28,6 @@ import {
saveSpaceOwnedSpaces,
saveSpaceProfileAvatar,
} from "services/persistent-session";
-import {
- parseSpaceProfilePayload,
- spaceProfileTextField,
-} from "services/profile-payload";
import { spaceRootKeyFromSpaceSession } from "services/secure-session-storage";
const usernamePattern = /^[a-z0-9][a-z0-9._]*$/;
@@ -255,11 +251,9 @@ const coverURLForRemoteCover = async (
const profileFromDecryptedSpaceProfile = (
spaceProfile: DecryptedSpaceProfile,
): SetupProfile => {
- const payload = parseSpaceProfilePayload(spaceProfile.profile);
+ const payload = spaceProfile.profile;
const fullName =
- spaceProfileTextField(payload.fullName) ||
- spaceProfileTextField(payload.displayName) ||
- spaceProfile.spaceSlug;
+ payload?.fullName || payload?.displayName || spaceProfile.spaceSlug;
return {
avatarKeyVersion: spaceProfile.avatar?.keyVersion,
diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.ts
index dd73e100cd..9f6ed59ca5 100644
--- a/web/apps/space/src/services/space.ts
+++ b/web/apps/space/src/services/space.ts
@@ -8,8 +8,9 @@ import {
type DecryptedSpaceProfile,
type MessageConversationActivity,
type MessageResponse,
- type PostObjectPayload,
+ type PostAsset,
type PostPage,
+ type PostPhoto,
type PostResponse,
type ProfileAvatarResponse,
type SpaceAccountCtxHandle,
@@ -38,10 +39,6 @@ import {
persistCurrentOwnedSpaces,
releaseCurrentSpaceContext,
} from "services/profile";
-import {
- parseSpaceProfilePayload,
- spaceProfileTextField,
-} from "services/profile-payload";
import { normalizeSpaceMessageText } from "utils/message-limits";
import { spacePostDeletedEvent } from "utils/post-events";
import { postQuoteErrorState, postQuotePhotoIndex } from "utils/post-quote";
@@ -72,14 +69,7 @@ interface SpacePostBase {
isUnavailable?: boolean;
}
-export interface SpacePostAsset {
- encryptedPostKey: string;
- keyVersion: number;
- mediaType?: string;
- objectKey: string;
- postId: number;
- spaceId: string;
-}
+export type SpacePostAsset = PostAsset & { mediaType?: string };
export interface SpacePostPhoto {
height?: number;
@@ -262,11 +252,9 @@ const messageActorForSpace = (
};
const actorProfile = (actor: SpaceActorResponse): FriendProfile => {
- const payload = parseSpaceProfilePayload(actor.profile ?? "");
+ const payload = actor.profile;
const fullName =
- spaceProfileTextField(payload.fullName) ||
- spaceProfileTextField(payload.displayName) ||
- actor.spaceSlug;
+ payload?.fullName || payload?.displayName || actor.spaceSlug;
const username = actor.spaceSlug;
return {
@@ -287,11 +275,9 @@ const actorProfile = (actor: SpaceActorResponse): FriendProfile => {
const profileFromSpaceProfile = (
spaceProfile: DecryptedSpaceProfile,
): FriendProfile => {
- const payload = parseSpaceProfilePayload(spaceProfile.profile);
+ const payload = spaceProfile.profile;
const fullName =
- spaceProfileTextField(payload.fullName) ||
- spaceProfileTextField(payload.displayName) ||
- spaceProfile.spaceSlug;
+ payload?.fullName || payload?.displayName || spaceProfile.spaceSlug;
return {
avatarKeyVersion: spaceProfile.avatar?.keyVersion,
@@ -387,16 +373,9 @@ const cachedAccountAvatarURLIfPresent = async (
);
};
-const postAssetFrom = (
- post: PostResponse,
- object: PostObjectPayload,
-): SpacePostAsset => ({
- encryptedPostKey: post.encryptedPostKey,
- keyVersion: post.keyVersion,
- mediaType: object.mediaType,
- objectKey: object.objectKey,
- postId: post.postId,
- spaceId: post.spaceId,
+const postAssetFrom = (photo: PostPhoto): SpacePostAsset => ({
+ ...photo.asset,
+ mediaType: photo.mediaType,
});
const postAssetCacheKey = (asset: SpacePostAsset) =>
@@ -409,47 +388,27 @@ const accountPostAssetURLFromAsset = (
) =>
cachedSpaceMediaBlobURL(
postAssetCacheKey(asset),
- () =>
- ctx.downloadPostAssetWithKey(
- asset.spaceId,
- asset.encryptedPostKey,
- asset.keyVersion,
- viewerSpaceId ?? null,
- asset.objectKey,
- ),
+ () => ctx.downloadPostAsset(asset, viewerSpaceId ?? null),
asset.mediaType,
);
const accountPostAssetURL = (
ctx: SpaceAccountCtxHandle,
- post: PostResponse,
- object: PostObjectPayload,
+ photo: PostPhoto,
viewerSpaceId?: string,
-) =>
- accountPostAssetURLFromAsset(
- ctx,
- postAssetFrom(post, object),
- viewerSpaceId,
- );
+) => accountPostAssetURLFromAsset(ctx, postAssetFrom(photo), viewerSpaceId);
-const cacheAccountPostAssetURL = async (
- post: PostResponse,
- object: PostObjectPayload,
- blob: Blob,
-) => {
- const key = postAssetCacheKey(postAssetFrom(post, object));
+const cacheAccountPostAssetURL = async (photo: PostPhoto, blob: Blob) => {
+ const key = postAssetCacheKey(postAssetFrom(photo));
await rememberCachedSpaceMediaBlobURL(key, blob);
};
-const firstObject = (post: PostResponse) =>
- post.objects.find((object) => object.objectKey.trim()) ?? null;
-
const postPhotosFromResponse = (post: PostResponse): SpacePostPhoto[] =>
- post.objects.map((object) => ({
- height: object.height,
- imageAsset: postAssetFrom(post, object),
- thumbHash: object.thumbHash,
- width: object.width,
+ post.photos.map((photo) => ({
+ height: photo.height,
+ imageAsset: postAssetFrom(photo),
+ thumbHash: photo.thumbHash,
+ width: photo.width,
}));
const postBaseFromResponse = (
@@ -478,12 +437,12 @@ const postFromAccountPost = async (
loadMedia = true,
viewerSpaceId?: string,
): Promise<SpacePost> => {
- const object = firstObject(post);
const author = actorProfile(post.author);
const base = postBaseFromResponse(post, author);
- if (post.isUnavailable || !object) {
+ if (post.isUnavailable) {
return { ...base, isUnavailable: true };
}
+ const photo = post.photos[0]!;
if (loadMedia) {
author.avatarUrl = await accountAvatarURL(
ctx,
@@ -494,35 +453,35 @@ const postFromAccountPost = async (
}
const imageUrl = loadMedia
- ? await accountPostAssetURL(ctx, post, object, viewerSpaceId)
+ ? await accountPostAssetURL(ctx, photo, viewerSpaceId)
: undefined;
return {
...base,
avatarUrl: author.avatarUrl,
- height: object.height,
- imageAsset: postAssetFrom(post, object),
+ height: photo.height,
+ imageAsset: postAssetFrom(photo),
imageUrl,
photos: postPhotosFromResponse(post),
- thumbHash: object.thumbHash,
- width: object.width,
+ thumbHash: photo.thumbHash,
+ width: photo.width,
};
};
const profilePostFromPost = (post: PostResponse): SpaceProfilePost => {
- const object = firstObject(post);
const author = actorProfile(post.author);
const base = postBaseFromResponse(post, author);
- if (post.isUnavailable || !object) {
+ if (post.isUnavailable) {
return { ...base, avatarUrl: null, isUnavailable: true };
}
+ const photo = post.photos[0]!;
return {
...base,
avatarUrl: null,
- height: object.height,
- imageAsset: postAssetFrom(post, object),
+ height: photo.height,
+ imageAsset: postAssetFrom(photo),
photos: postPhotosFromResponse(post),
- thumbHash: object.thumbHash,
- width: object.width,
+ thumbHash: photo.thumbHash,
+ width: photo.width,
};
};
@@ -576,12 +535,7 @@ export const openPublicSpaceLink = async (
loadPostImage: (asset) =>
cachedSpaceMediaBlobURL(
postAssetCacheKey(asset),
- () =>
- ctx.downloadPostAsset(
- asset.encryptedPostKey,
- asset.keyVersion,
- asset.objectKey,
- ),
+ () => ctx.downloadPostAsset(asset),
asset.mediaType,
),
loadProfileMedia: async () => {
@@ -635,24 +589,22 @@ const messageQuoteFromPostResponse = async (
viewerSpaceId?: string,
objectKey?: string,
): Promise<SpaceMessageQuote> => {
- const photoIndex = postQuotePhotoIndex(post.objects, objectKey);
- const object = post.objects[photoIndex];
+ const photoIndex = postQuotePhotoIndex(
+ post.photos.map((photo) => photo.asset),
+ objectKey,
+ );
+ const photo = post.photos[photoIndex];
const quote: SpaceMessageQuote = {
objectKey,
- photoCount: post.objects.length,
+ photoCount: post.photos.length,
postId: post.postId,
spaceId: post.spaceId,
};
- if (!object || post.isUnavailable) return { ...quote, isUnavailable: true };
+ if (!photo || post.isUnavailable) return { ...quote, isUnavailable: true };
if (!includeImage) return quote;
try {
- const imageUrl = await accountPostAssetURL(
- ctx,
- post,
- object,
- viewerSpaceId,
- );
+ const imageUrl = await accountPostAssetURL(ctx, photo, viewerSpaceId);
if (!imageUrl) {
quote.isUnavailable = true;
return quote;
@@ -1180,8 +1132,8 @@ export const createCurrentPhotoPost = async ({
caption?.trim() || null,
);
await Promise.all(
- created.objects.map((object, index) =>
- cacheAccountPostAssetURL(created, object, images[index]!.file),
+ created.photos.map((photo, index) =>
+ cacheAccountPostAssetURL(photo, images[index]!.file),
),
);
const post = await postFromAccountPost(ctx, created, true, spaceId);
diff --git a/web/apps/space/tests/post-upload.test.ts b/web/apps/space/tests/post-upload.test.ts
index 75101939c2..54e311f68c 100644
--- a/web/apps/space/tests/post-upload.test.ts
+++ b/web/apps/space/tests/post-upload.test.ts
@@ -1,5 +1,6 @@
import { encryptBox, openSpaceAccountContext } from "ente-space-wasm";
import { afterEach, expect, test, vi } from "vitest";
+import { CachedSpacePost } from "../src/services/post-cache";
afterEach(() => vi.unstubAllGlobals());
@@ -44,13 +45,36 @@ const uploadFixture = async (failSecondUpload = false) => {
},
],
});
+ const profile = await encryptBox(
+ btoa(JSON.stringify({ fullName: " Test User " })),
+ spaceKey,
+ );
+ const author = {
+ spaceId: "test-space",
+ spaceSlug: "test",
+ keyVersion: 1,
+ encryptedProfile: Buffer.concat([
+ Buffer.from(profile.nonce, "base64"),
+ Buffer.from(profile.encryptedData, "base64"),
+ ]).toString("base64"),
+ };
const calls: string[] = [];
const uploadedAssets = new Map<string, ArrayBuffer>();
let presigned = 0;
let created: UploadedPost | undefined;
+ const record = () => ({
+ ...created,
+ postId: 501,
+ spaceId: "test-space",
+ spaceSlug: "test",
+ author,
+ createdAt: "2026-09-17T00:00:00Z",
+ viewerLiked: false,
+ });
const respond = async (request: Request) => {
const path = new URL(request.url).pathname;
calls.push(`${request.method} ${path}`);
+ if (path.endsWith("/friends/shares")) return Response.json([]);
if (path.endsWith("/uploads/presign")) {
const index = presigned++;
return Response.json({
@@ -89,15 +113,13 @@ const uploadFixture = async (failSecondUpload = false) => {
return Response.json({ postId: 501 });
}
if (request.method == "GET" && path.endsWith("/posts/501")) {
- return Response.json({
- ...created,
- postId: 501,
- spaceId: "test-space",
- spaceSlug: "test",
- author: { spaceId: "test-space", spaceSlug: "test" },
- createdAt: "2026-09-17T00:00:00Z",
- viewerLiked: false,
- });
+ return Response.json(record());
+ }
+ if (
+ request.method == "GET" &&
+ (path.endsWith("/posts") || path.endsWith("/feed"))
+ ) {
+ return Response.json({ items: [record()], nextCursor: "older" });
}
throw new Error(`Unexpected request: ${request.method} ${path}`);
};
@@ -106,7 +128,7 @@ const uploadFixture = async (failSecondUpload = false) => {
Object.defineProperty(response, "url", { value: request.url });
return response;
});
- return { ctx, calls, created: () => created };
+ return { ctx, calls, author, created: () => created };
};
test.each([1, 3, 10])(
@@ -120,13 +142,13 @@ test.each([1, 3, 10])(
"One shared caption",
);
expect(result.caption).toBe("One shared caption");
- expect(result.objects.map((object) => object.objectKey)).toEqual(
+ expect(result.photos.map((photo) => photo.asset.objectKey)).toEqual(
Array.from({ length: count }, (_, i) => `photo-${i}`),
);
- expect(result.objects.map((object) => object.width)).toEqual(
+ expect(result.photos.map((photo) => photo.width)).toEqual(
Array.from({ length: count }, (_, i) => 1200 + i),
);
- expect(result.objects.map((object) => object.thumbHash)).toEqual(
+ expect(result.photos.map((photo) => photo.thumbHash)).toEqual(
Array.from({ length: count }, (_, i) => `hash-${i}`),
);
expect(created()?.objects.map((object) => object.position)).toEqual(
@@ -168,13 +190,10 @@ test("copies typed-array photo bytes without JavaScript iteration", async () =>
"Caption",
);
expect(created()?.objects).toHaveLength(1);
- const downloaded = await ctx.downloadPostAssetWithKey(
- post.spaceId,
- post.encryptedPostKey,
- post.keyVersion,
- post.spaceId,
- post.objects[0]!.objectKey,
- );
+ const cached = CachedSpacePost.shape.imageAsset
+ .unwrap()
+ .parse(JSON.parse(JSON.stringify(post.photos[0]!.asset)));
+ const downloaded = await ctx.downloadPostAsset(cached, post.spaceId);
expect(downloaded).toEqual(photo(0).bytes);
} finally {
ctx.free();
@@ -212,3 +231,36 @@ test.each([0, 11])("rejects %i photos before uploading", async (count) => {
ctx.free();
}
});
+
+test("pages expose typed profiles and mark corrupt posts unavailable", async () => {
+ const { ctx, created, author } = await uploadFixture();
+ try {
+ const post = await ctx.createPhotoPost(
+ "test-space",
+ [photo(0)],
+ "Caption",
+ );
+ expect(post.author.profile).toEqual({ fullName: "Test User" });
+ expect(post.isUnavailable).toBe(false);
+ const metadataCipher = created()!.objects[0]!.metadataCipher;
+ created()!.objects[0]!.metadataCipher = "not-base64";
+ for (const page of [
+ await ctx.listPosts("test-space"),
+ await ctx.listFeed("test-space"),
+ ]) {
+ expect(page.nextCursor).toBe("older");
+ expect(page.items[0]!.isUnavailable).toBe(true);
+ expect(page.items[0]!.caption).toBeUndefined();
+ expect(page.items[0]!.photos).toEqual([]);
+ }
+ await expect(ctx.getPost("test-space", 501n)).rejects.toThrow();
+ created()!.objects[0]!.metadataCipher = metadataCipher;
+ author.encryptedProfile = "not-base64";
+ const [withoutProfile] = (await ctx.listPosts("test-space")).items;
+ expect(withoutProfile!.photos).toHaveLength(1);
+ expect(withoutProfile!.isUnavailable).toBe(false);
+ expect(withoutProfile!.author.profile).toBeUndefined();
+ } finally {
+ ctx.free();
+ }
+});
diff --git a/web/packages/wasm/space/index.ts b/web/packages/wasm/space/index.ts
index d184731a08..65a3e13de8 100644
--- a/web/packages/wasm/space/index.ts
+++ b/web/packages/wasm/space/index.ts
@@ -10,8 +10,9 @@ export type {
DecryptedSpaceProfile,
MessageConversationActivity,
MessageResponse,
- PostObjectPayload,
+ PostAsset,
PostPage,
+ PostPhoto,
PostResponse,
ProfileAvatarResponse,
SpaceAccountCtxHandle,