π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
mod assets;
mod comments;
mod entity_keys;
mod friends;
mod keys;
mod links;
mod media;
mod messages;
mod notifications;
mod pokes;
mod posts;
mod profiles;
mod reactions;
#[cfg(test)]
mod test_support;
#[cfg(test)]
mod tests;
use std::{
cmp::Reverse,
collections::BTreeMap,
sync::{Mutex, MutexGuard},
};
pub use links::SpaceLinkCtx;
use media::{ensure_supported_photo_bytes, ensure_supported_photo_media_type};
use crate::crypto::{
ASSET_PAYLOAD_OVERHEAD_BYTES, SECRETBOX_PAYLOAD_OVERHEAD_BYTES, decrypt_secretbox_payload,
encrypt_secretbox_payload, generate_key, generate_keypair, open_with_keypair,
};
use crate::error::{Error, Result};
use crate::models::{
CreatedSpace, DecryptedFriendShare, DecryptedSpaceProfile, MessagePayload,
OpenAccountSpaceCtxInput, PostObjectMetadata,
};
use crate::transport::{
CreateSpaceRequest, FriendShareResponse, PostObjectPayload, SpaceKeyResponse,
SpaceKeyVersionResponse, SpaceLookupResponse, SpaceProfileResponse, UpdateSpaceSlugRequest,
};
use ente_core::{
b64,
crypto::SecretVec,
http::{self, Api, ApiConfig, Auth, Http},
};
const UPLOAD_PURPOSE_AVATAR: &str = "avatar";
const UPLOAD_PURPOSE_COVER: &str = "cover";
const MESSAGE_KIND_REGULAR: &str = "regular";
const MESSAGE_KIND_POKE: &str = "poke";
const MESSAGE_KIND_POST_REPLY: &str = "post_reply";
const ONLY_PHOTOS_UPLOAD_MESSAGE: &str = "only photos can be uploaded";
pub const MAX_SPACE_POST_UPLOAD_BYTES: usize = 15 * 1024 * 1024;
pub const MAX_SPACE_AVATAR_UPLOAD_BYTES: usize = 2 * 1024 * 1024;
pub const MAX_SPACE_COVER_UPLOAD_BYTES: usize = 2 * 1024 * 1024;
pub const MAX_SPACE_POST_PLAINTEXT_BYTES: usize =
MAX_SPACE_POST_UPLOAD_BYTES - ASSET_PAYLOAD_OVERHEAD_BYTES;
pub const MAX_SPACE_AVATAR_PLAINTEXT_BYTES: usize =
MAX_SPACE_AVATAR_UPLOAD_BYTES - ASSET_PAYLOAD_OVERHEAD_BYTES;
pub const MAX_SPACE_COVER_PLAINTEXT_BYTES: usize =
MAX_SPACE_COVER_UPLOAD_BYTES - ASSET_PAYLOAD_OVERHEAD_BYTES;
pub const MAX_SPACE_MESSAGE_TEXT_CHARS: usize = 1000;
pub const MAX_SPACE_MESSAGE_TEXT_BYTES: usize = 4 * 1024;
pub const MAX_SPACE_MESSAGE_CIPHER_DECODED_BYTES: usize = 6 * 1024;
pub const MAX_SPACE_MESSAGE_PAYLOAD_BYTES: usize =
MAX_SPACE_MESSAGE_CIPHER_DECODED_BYTES - SECRETBOX_PAYLOAD_OVERHEAD_BYTES;
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),
}
}
#[derive(Debug, Clone, Default)]
pub struct PostPhotoAssetOptions {
pub width: Option<i32>,
pub height: Option<i32>,
pub media_type: Option<String>,
pub thumb_hash: Option<String>,
}
pub struct PostPhotoInput {
pub bytes: Vec<u8>,
pub options: PostPhotoAssetOptions,
}
fn profile_object_id_from_key(object_key: &str) -> Result<String> {
object_key
.rsplit('/')
.next()
.filter(|value| !value.trim().is_empty() && !value.contains('/'))
.map(ToOwned::to_owned)
.ok_or_else(|| Error::InvalidInput("invalid profile asset object key".into()))
}
#[derive(Clone)]
pub(crate) struct ResolvedSpaceAccess {
space_key: Vec<u8>,
key_version: i32,
}
#[derive(Clone)]
pub(crate) struct ResolvedOwnedSpaceAccess {
space_key: Vec<u8>,
key_version: i32,
}
pub(crate) struct SpaceIdentity {
public_key: Vec<u8>,
secret_key: SecretVec,
}
impl Clone for SpaceIdentity {
fn clone(&self) -> Self {
Self {
public_key: self.public_key.clone(),
secret_key: SecretVec::new(self.secret_key.to_vec()),
}
}
}
pub struct AccountSpaceCtx {
api: Api,
space_root_key: SecretVec,
space_identity_cache: Mutex<BTreeMap<String, SpaceIdentity>>,
owned_spaces_cache: Mutex<Option<Vec<SpaceKeyResponse>>>,
friend_shares_cache: Mutex<BTreeMap<String, Vec<DecryptedFriendShare>>>,
}
impl AccountSpaceCtx {
pub fn open(input: OpenAccountSpaceCtxInput) -> Result<Self> {
let space_root_key = SecretVec::new(input.space_root_key);
let api = build_api(
&input.base_url,
input.space_session_token,
input.user_agent,
input.client_package,
input.client_version,
)?;
Ok(Self {
api,
space_root_key,
space_identity_cache: Mutex::new(BTreeMap::new()),
owned_spaces_cache: Mutex::new(input.initial_owned_spaces),
friend_shares_cache: Mutex::new(BTreeMap::new()),
})
}
pub fn api(&self) -> &Api {
&self.api
}
pub fn space_root_key(&self) -> &[u8] {
&self.space_root_key
}
pub fn get_space_root_key(&self) -> Result<Option<Vec<u8>>> {
Ok(Some(self.space_root_key.to_vec()))
}
pub fn get_or_create_space_root_key(&self) -> Result<Vec<u8>> {
Ok(self.space_root_key.to_vec())
}
pub async fn list_owned_spaces(&self) -> Result<Vec<SpaceKeyResponse>> {
if let Some(value) = cache_lock(&self.owned_spaces_cache, "owned spaces")?.clone() {
return Ok(value);
}
self.refresh_owned_spaces().await
}
async fn refresh_owned_spaces(&self) -> Result<Vec<SpaceKeyResponse>> {
let spaces: Vec<SpaceKeyResponse> = self
.api
.get("/account/space")
.send()
.await?
.error_for_status()
.map_err(map_session_error)?
.json()
.await?;
*cache_lock(&self.owned_spaces_cache, "owned spaces")? = Some(spaces.clone());
Ok(spaces)
}
pub async fn list_friend_shares(&self, space_id: &str) -> Result<Vec<FriendShareResponse>> {
let path = format!("/spaces/{space_id}/friends/shares");
Ok(self
.api
.get(&path)
.send()
.await?
.error_for_status()?
.json()
.await?)
}
pub(crate) fn decrypt_space_identity(&self, space: &SpaceKeyResponse) -> Result<SpaceIdentity> {
if space.public_key.trim().is_empty() || space.encrypted_secret_key.trim().is_empty() {
return Err(Error::MissingSecretKey);
}
let public_key = b64::decode(&space.public_key)?;
let encrypted_secret_key = b64::decode(&space.encrypted_secret_key)?;
let secret_key = decrypt_secretbox_payload(&self.space_root_key, &encrypted_secret_key)?;
Ok(SpaceIdentity {
public_key,
secret_key: SecretVec::new(secret_key),
})
}
pub(crate) async fn space_identity_for(&self, space_id: &str) -> Result<SpaceIdentity> {
let space_id = space_id.trim();
if space_id.is_empty() {
return Err(Error::InvalidInput("space id is required".into()));
}
if let Some(value) = cache_lock(&self.space_identity_cache, "space identity")?
.get(space_id)
.cloned()
{
return Ok(value);
}
let space = self
.list_owned_spaces_cached()
.await?
.into_iter()
.find(|value| value.space_id == space_id)
.ok_or_else(|| {
Error::InvalidInput(format!("space {space_id} is not owned by the account"))
})?;
let identity = self.decrypt_space_identity(&space)?;
cache_lock(&self.space_identity_cache, "space identity")?
.insert(space.space_id, identity.clone());
Ok(identity)
}
pub async fn decrypt_friend_share(
&self,
space_id: &str,
share: &FriendShareResponse,
) -> Result<DecryptedFriendShare> {
let identity = self.space_identity_for(space_id).await?;
let ciphertext = b64::decode(&share.friend_sealed_space_key)?;
if ciphertext.is_empty() {
return Err(Error::MissingFriendSealedSpaceKey);
}
let space_key = open_with_keypair(&ciphertext, &identity.public_key, &identity.secret_key)?;
Ok(DecryptedFriendShare {
friend: share.friend.clone(),
space_id: share.space_id.clone(),
space_slug: share.space_slug.clone(),
space_key,
key_version: share.key_version,
})
}
pub(crate) async fn profile_space_access(
&self,
space_id: &str,
) -> Result<(SpaceKeyResponse, Vec<u8>)> {
let space_root_key = self
.get_space_root_key()?
.ok_or_else(|| Error::InvalidInput("space root key is missing".into()))?;
let space_id = space_id.trim();
if space_id.is_empty() {
return Err(Error::InvalidInput("space id is required".into()));
}
let space = self
.list_owned_spaces()
.await?
.into_iter()
.find(|value| value.space_id == space_id)
.ok_or_else(|| {
Error::InvalidInput(format!("space {space_id} is not owned by the account"))
})?;
let packed = b64::decode(&space.root_wrapped_space_key)?;
let space_key = decrypt_secretbox_payload(&space_root_key, &packed)?;
Ok((space, space_key))
}
pub async fn resolve_owned_space_key(&self, space_id: &str) -> Result<Option<Vec<u8>>> {
Ok(self
.resolve_owned_space_access(space_id)
.await?
.map(|value| value.space_key))
}
pub async fn resolve_space_key(&self, space_id: &str) -> Result<Option<Vec<u8>>> {
Ok(self
.resolve_space_access(space_id)
.await?
.map(|value| value.space_key))
}
pub async fn create_space(&self, space_slug: &str, profile: &[u8]) -> Result<CreatedSpace> {
self.create_space_with_referrer(space_slug, profile, None)
.await
}
pub async fn create_space_with_referrer(
&self,
space_slug: &str,
profile: &[u8],
referred_by_space_id: Option<&str>,
) -> Result<CreatedSpace> {
let space_key = generate_key();
self.create_space_with_key_and_referrer(
space_slug,
&space_key,
profile,
referred_by_space_id,
)
.await
}
pub async fn create_space_with_key(
&self,
space_slug: &str,
space_key: &[u8],
profile: &[u8],
) -> Result<CreatedSpace> {
self.create_space_with_key_and_referrer(space_slug, space_key, profile, None)
.await
}
pub async fn create_space_with_key_and_referrer(
&self,
space_slug: &str,
space_key: &[u8],
profile: &[u8],
referred_by_space_id: Option<&str>,
) -> Result<CreatedSpace> {
let space_root_key = self.get_or_create_space_root_key()?;
let root_wrapped_space_key =
b64::encode(&encrypt_secretbox_payload(&space_root_key, space_key)?);
let (public_key, secret_key) = generate_keypair()?;
let encrypted_secret_key = encrypt_secretbox_payload(&space_root_key, &secret_key)?;
let encrypted_profile = b64::encode(&encrypt_secretbox_payload(space_key, profile)?);
let request = CreateSpaceRequest {
space_slug: space_slug.to_owned(),
root_wrapped_space_key: root_wrapped_space_key.clone(),
public_key: b64::encode(&public_key),
encrypted_secret_key: b64::encode(&encrypted_secret_key),
encrypted_profile: encrypted_profile.clone(),
referred_by_space_id: referred_by_space_id.map(str::to_owned),
};
let response = self
.api
.post("/account/space")
.json(&request)
.send()
.await?
.error_for_code()
.await
.map_err(map_create_space_error)?
.json::<SpaceKeyResponse>()
.await?;
self.cache_created_owned_space(SpaceKeyResponse {
space_id: response.space_id.clone(),
space_slug: response.space_slug.clone(),
root_wrapped_space_key: root_wrapped_space_key.clone(),
public_key: request.public_key.clone(),
encrypted_secret_key: request.encrypted_secret_key.clone(),
encrypted_profile: encrypted_profile.clone(),
key_version: response.key_version,
})?;
cache_lock(&self.space_identity_cache, "space identity")?.insert(
response.space_id.clone(),
SpaceIdentity {
public_key,
secret_key: SecretVec::new(secret_key),
},
);
Ok(CreatedSpace {
space_id: response.space_id,
space_slug: response.space_slug,
key_version: response.key_version,
space_key: space_key.to_vec(),
root_wrapped_space_key,
encrypted_profile,
})
}
pub async fn lookup_space_by_slug(&self, space_slug: &str) -> Result<SpaceLookupResponse> {
let path = format!("/space/public/by-slug/{}", urlencoding::encode(space_slug));
Ok(self
.api
.get(&path)
.send()
.await?
.error_for_status()
.map_err(|error| match error.status_code() {
Some(404) => Error::ProfileNotFound,
_ => error.into(),
})?
.json()
.await?)
}
pub async fn update_space_slug(
&self,
space_id: &str,
space_slug: &str,
) -> Result<SpaceLookupResponse> {
let path = format!("/spaces/{space_id}/slug");
let request = UpdateSpaceSlugRequest {
space_slug: space_slug.to_owned(),
};
let response = self
.api
.put(&path)
.json(&request)
.send()
.await?
.error_for_code()
.await
.map_err(map_space_slug_error)?
.json()
.await?;
self.clear_owned_space_cache()?;
Ok(response)
}
pub(crate) async fn resolve_owned_space_access(
&self,
space_id: &str,
) -> Result<Option<ResolvedSpaceAccess>> {
Ok(self
.resolve_owned_space_access_with_root(space_id)
.await?
.map(|value| ResolvedSpaceAccess {
space_key: value.space_key,
key_version: value.key_version,
}))
}
pub(crate) async fn resolve_owned_space_access_with_root(
&self,
space_id: &str,
) -> Result<Option<ResolvedOwnedSpaceAccess>> {
let Some(space_root_key) = self.get_space_root_key()? else {
return Ok(None);
};
let spaces = self.list_owned_spaces_cached().await?;
let Some(record) = spaces.into_iter().find(|value| value.space_id == space_id) else {
return Ok(None);
};
let packed = b64::decode(&record.root_wrapped_space_key)?;
let space_key = decrypt_secretbox_payload(&space_root_key, &packed)?;
Ok(Some(ResolvedOwnedSpaceAccess {
space_key,
key_version: record.key_version,
}))
}
pub(crate) async fn resolve_shared_space_access(
&self,
space_id: &str,
) -> Result<Option<ResolvedSpaceAccess>> {
let shares = self.list_all_decrypted_friend_shares().await?;
let Some(mut share) = shares.into_iter().find(|value| value.space_id == space_id) else {
return Ok(None);
};
Ok(Some(ResolvedSpaceAccess {
space_key: std::mem::take(&mut share.space_key),
key_version: share.key_version,
}))
}
pub(crate) async fn resolve_space_access(
&self,
space_id: &str,
) -> Result<Option<ResolvedSpaceAccess>> {
if let Some(access) = self.resolve_owned_space_access(space_id).await? {
return Ok(Some(access));
}
self.resolve_shared_space_access(space_id).await
}
pub(crate) async fn resolve_shared_space_access_for(
&self,
viewer_space_id: &str,
space_id: &str,
) -> Result<Option<ResolvedSpaceAccess>> {
let shares = self
.list_decrypted_friend_shares_cached(viewer_space_id)
.await?;
let Some(mut share) = shares.into_iter().find(|value| value.space_id == space_id) else {
return Ok(None);
};
Ok(Some(ResolvedSpaceAccess {
space_key: std::mem::take(&mut share.space_key),
key_version: share.key_version,
}))
}
pub(crate) async fn resolve_space_access_for(
&self,
viewer_space_id: &str,
space_id: &str,
) -> Result<Option<ResolvedSpaceAccess>> {
if let Some(access) = self.resolve_owned_space_access(space_id).await? {
return Ok(Some(access));
}
self.resolve_shared_space_access_for(viewer_space_id, space_id)
.await
}
pub(crate) async fn resolve_space_key_for_version(
&self,
space_id: &str,
version: Option<i32>,
) -> Result<Option<Vec<u8>>> {
let Some(mut access) = self.resolve_space_access(space_id).await? else {
return Ok(None);
};
let target_version = version.unwrap_or(access.key_version);
access = self
.refresh_owned_access_for_version(space_id, target_version, access)
.await?;
if target_version == access.key_version {
return Ok(Some(access.space_key));
}
let history = self.build_space_key_history_for_space(space_id).await?;
Ok(history.get(&target_version).cloned())
}
pub async fn resolve_space_key_for_version_for_viewer(
&self,
space_id: &str,
viewer_space_id: Option<&str>,
version: Option<i32>,
) -> Result<Option<Vec<u8>>> {
let access = match viewer_space_id.filter(|value| !value.trim().is_empty()) {
Some(viewer_space_id) => {
self.resolve_space_access_for(viewer_space_id, space_id)
.await?
}
None => self.resolve_space_access(space_id).await?,
};
let Some(mut access) = access else {
return Ok(None);
};
let target_version = version.unwrap_or(access.key_version);
access = self
.refresh_owned_access_for_version(space_id, target_version, access)
.await?;
if target_version == access.key_version {
return Ok(Some(access.space_key));
}
let history = self
.build_space_key_history_for_space_for_viewer(space_id, viewer_space_id)
.await?;
Ok(history.get(&target_version).cloned())
}
async fn refresh_owned_access_for_version(
&self,
space_id: &str,
target_version: i32,
access: ResolvedSpaceAccess,
) -> Result<ResolvedSpaceAccess> {
if target_version <= access.key_version {
return Ok(access);
}
let is_owned = cache_lock(&self.owned_spaces_cache, "owned spaces")?
.as_ref()
.is_some_and(|spaces| spaces.iter().any(|space| space.space_id == space_id));
if !is_owned {
return Ok(access);
}
self.refresh_owned_spaces().await?;
self.resolve_owned_space_access(space_id)
.await?
.ok_or_else(|| {
Error::InvalidInput(format!("space {space_id} is not owned by the account"))
})
}
pub(crate) async fn list_owned_spaces_cached(&self) -> Result<Vec<SpaceKeyResponse>> {
if let Some(value) = cache_lock(&self.owned_spaces_cache, "owned spaces")?.clone() {
return Ok(value);
}
let value = self.list_owned_spaces().await?;
*cache_lock(&self.owned_spaces_cache, "owned spaces")? = Some(value.clone());
Ok(value)
}
pub(crate) async fn list_decrypted_friend_shares_cached(
&self,
space_id: &str,
) -> Result<Vec<DecryptedFriendShare>> {
let space_id = space_id.trim();
if space_id.is_empty() {
return Err(Error::InvalidInput("space id is required".into()));
}
if let Some(value) = cache_lock(&self.friend_shares_cache, "friend shares")?
.get(space_id)
.cloned()
{
return Ok(value);
}
let shares = self.list_friend_shares(space_id).await?;
let mut value = Vec::with_capacity(shares.len());
for share in shares {
let friend = share.friend.clone();
match self.decrypt_friend_share(space_id, &share).await {
Ok(share) => value.push(share),
Err(error) if error.is_content_error() => {
log::warn!("Space friend share {friend} is unusable: {error}");
}
Err(error) => return Err(error),
}
}
cache_lock(&self.friend_shares_cache, "friend shares")?
.insert(space_id.to_owned(), value.clone());
Ok(value)
}
pub(crate) async fn list_all_decrypted_friend_shares(
&self,
) -> Result<Vec<DecryptedFriendShare>> {
let spaces = self.list_owned_spaces_cached().await?;
let mut all = Vec::new();
for space in spaces {
all.extend(
self.list_decrypted_friend_shares_cached(&space.space_id)
.await?,
);
}
Ok(all)
}
pub(crate) fn clear_owned_space_cache(&self) -> Result<()> {
*cache_lock(&self.owned_spaces_cache, "owned spaces")? = None;
Ok(())
}
pub(crate) fn cache_created_owned_space(&self, created: SpaceKeyResponse) -> Result<()> {
let mut cache = cache_lock(&self.owned_spaces_cache, "owned spaces")?;
if let Some(spaces) = cache.as_mut() {
spaces.retain(|space| space.space_id != created.space_id);
spaces.push(created);
}
Ok(())
}
pub(crate) fn update_cached_owned_space_profile(
&self,
space_id: &str,
encrypted_profile: String,
) -> Result<()> {
let mut cache = cache_lock(&self.owned_spaces_cache, "owned spaces")?;
if let Some(spaces) = cache.as_mut()
&& let Some(space) = spaces.iter_mut().find(|space| space.space_id == space_id)
{
space.encrypted_profile = encrypted_profile;
}
Ok(())
}
pub(crate) fn clear_friend_share_cache(&self) -> Result<()> {
cache_lock(&self.friend_shares_cache, "friend shares")?.clear();
Ok(())
}
}
fn ensure_space_upload_size(purpose: &str, encrypted_size: usize, max_bytes: usize) -> Result<()> {
if encrypted_size == 0 || encrypted_size > max_bytes {
return Err(Error::InvalidInput(format!(
"{purpose} upload size must be between 1 and {max_bytes} bytes"
)));
}
Ok(())
}
fn encrypt_post_object_metadata(post_key: &[u8], metadata: &PostObjectMetadata) -> Result<String> {
let plaintext = serde_json::to_vec(metadata)
.map_err(|err| Error::InvalidInput(format!("invalid post object metadata: {err}")))?;
Ok(b64::encode(&encrypt_secretbox_payload(
post_key, &plaintext,
)?))
}
fn decrypt_post_object_metadata(
post_key: &[u8],
object: &PostObjectPayload,
) -> Result<Option<PostObjectMetadata>> {
let Some(cipher) = object.metadata_cipher.as_deref() else {
return Ok(None);
};
let plaintext = decrypt_secretbox_payload(post_key, &b64::decode(cipher)?)?;
serde_json::from_slice(&plaintext)
.map(Some)
.map_err(|err| Error::InvalidInput(format!("invalid post object metadata: {err}")))
}
fn ensure_post_objects_supported(objects: &[PostObjectPayload], post_key: &[u8]) -> Result<()> {
if objects.len() > 10 {
return Err(Error::InvalidInput("Choose between 1 and 10 items".into()));
}
for object in objects {
let metadata = decrypt_post_object_metadata(post_key, object)?
.ok_or_else(|| Error::InvalidInput("post object metadata is required".into()))?;
if ensure_supported_photo_media_type(metadata.media_type.as_deref())?.is_none() {
return Err(Error::InvalidInput(ONLY_PHOTOS_UPLOAD_MESSAGE.into()));
}
if let Some(video) = &object.video {
let metadata = decrypt_post_object_metadata(post_key, video)?
.ok_or_else(|| Error::InvalidInput("video metadata is required".into()))?;
if video.video.is_some()
|| metadata.media_type.as_deref() != Some("video/mp4")
|| !metadata
.duration_ms
.is_some_and(|duration| (1..=10_000).contains(&duration))
{
return Err(Error::InvalidInput(
"Videos must be MP4 and at most 10 seconds".into(),
));
}
}
}
Ok(())
}
fn validate_message_payload(payload: &MessagePayload, plaintext_len: usize) -> Result<()> {
if payload.text.chars().count() > MAX_SPACE_MESSAGE_TEXT_CHARS {
return Err(Error::InvalidInput(format!(
"message text must be {MAX_SPACE_MESSAGE_TEXT_CHARS} characters or fewer"
)));
}
if payload.text.len() > MAX_SPACE_MESSAGE_TEXT_BYTES {
return Err(Error::InvalidInput(format!(
"message text must be {MAX_SPACE_MESSAGE_TEXT_BYTES} bytes or fewer"
)));
}
if plaintext_len > MAX_SPACE_MESSAGE_PAYLOAD_BYTES {
return Err(Error::InvalidInput(format!(
"message payload must be {MAX_SPACE_MESSAGE_PAYLOAD_BYTES} bytes or fewer"
)));
}
Ok(())
}
pub(super) fn build_api(
base_url: &str,
space_session_token: Option<String>,
user_agent: Option<String>,
client_package: Option<String>,
client_version: Option<String>,
) -> Result<Api> {
let auth = space_session_token.map(Auth::SpaceSession);
Ok(Api::new(
Http::new()?,
ApiConfig {
origin: base_url.to_owned(),
auth,
user_agent,
client_package,
client_version,
},
))
}
fn cache_lock<'a, T>(cache: &'a Mutex<T>, name: &str) -> Result<MutexGuard<'a, T>> {
cache
.lock()
.map_err(|_| Error::InvalidInput(format!("{name} cache poisoned")))
}
fn map_account_error(error: http::Error) -> Error {
match error.status_code() {
Some(403) => Error::PermissionDenied,
_ => map_session_error(error),
}
}
fn map_session_error(error: http::Error) -> Error {
match error.status_code() {
Some(401) => Error::SessionUnauthorized,
_ => error.into(),
}
}
fn map_create_space_error(error: http::Error) -> Error {
match &error {
http::Error::Api { code, .. } if code == "CONFLICT" => Error::SpaceLimitReached,
_ => map_space_slug_error(error),
}
}
fn map_space_slug_error(error: http::Error) -> Error {
match &error {
http::Error::Api { code, .. } if code == "ALREADY_EXISTS" => Error::SpaceSlugAlreadyExists,
http::Error::Api { code, .. } if code == "SPACE_SLUG_RESERVED" => Error::SpaceSlugReserved,
http::Error::Api { code, .. } if code == "BAD_REQUEST" => Error::InvalidSpaceSlug,
_ => map_account_error(error),
}
}
pub(super) fn decrypt_space_profile(
profile: &SpaceProfileResponse,
space_key: &[u8],
) -> Result<DecryptedSpaceProfile> {
let profile_bytes = if profile.encrypted_profile.is_empty() {
Vec::new()
} else {
decrypt_secretbox_payload(space_key, &b64::decode(&profile.encrypted_profile)?)?
};
Ok(DecryptedSpaceProfile {
space_id: profile.space_id.clone(),
space_slug: profile.space_slug.clone(),
version: profile.version,
friends: profile.friends,
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() {
None
} else {
Some(profile.updated_at.clone())
},
})
}
pub(super) fn space_profile_without_payload(
profile: &SpaceProfileResponse,
) -> DecryptedSpaceProfile {
DecryptedSpaceProfile {
space_id: profile.space_id.clone(),
space_slug: profile.space_slug.clone(),
version: profile.version,
friends: profile.friends,
profile: None,
avatar: profile.avatar.clone(),
cover: profile.cover.clone(),
updated_at: if profile.updated_at.is_empty() {
None
} else {
Some(profile.updated_at.clone())
},
}
}
pub(super) fn build_space_key_history_map(
current_version: i32,
current_key: &[u8],
versions: &[SpaceKeyVersionResponse],
) -> Result<BTreeMap<i32, Vec<u8>>> {
let mut history = BTreeMap::new();
history.insert(current_version, current_key.to_vec());
let mut ordered = versions.to_vec();
ordered.sort_by_key(|entry| Reverse(entry.version));
for entry in ordered {
if entry.wrapped_prev_key.is_empty() || entry.version <= 1 {
continue;
}
let Some(known_key) = history.get(&entry.version).cloned() else {
continue;
};
let packed = b64::decode(&entry.wrapped_prev_key)?;
let previous_key = decrypt_secretbox_payload(&known_key, &packed)?;
history.insert(entry.version - 1, previous_key);
}
Ok(history)
}