π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use super::{
AccountSpaceCtx, PostPhotoAssetOptions, UPLOAD_PURPOSE_AVATAR, UPLOAD_PURPOSE_COVER,
encrypt_post_object_metadata, ensure_space_upload_size, ensure_supported_photo_bytes,
ensure_supported_photo_media_type, map_account_error, profile_object_id_from_key,
};
use crate::crypto::{content_md5_base64, encrypt_asset_payload};
use crate::error::{Error, Result};
use crate::models::PostObjectMetadata;
use crate::transport::{
AssetDownloadResponse, PostObjectPayload, PresignUploadRequest, PresignUploadResponse,
ProfileAvatarPayload, ProfileCoverPayload,
};
use crate::{
MAX_SPACE_AVATAR_UPLOAD_BYTES, MAX_SPACE_COVER_UPLOAD_BYTES, MAX_SPACE_POST_UPLOAD_BYTES,
};
use ente_core::http;
impl AccountSpaceCtx {
pub async fn upload_post_video_asset(
&self,
space_id: &str,
post_key: &[u8],
plaintext: &[u8],
width: i32,
height: i32,
duration_ms: u32,
) -> Result<PostObjectPayload> {
if plaintext.len() < 12
|| &plaintext[4..8] != b"ftyp"
|| width <= 0
|| height <= 0
|| !(1..=10_000).contains(&duration_ms)
{
return Err(Error::InvalidInput(
"Videos must be MP4 and at most 10 seconds".into(),
));
}
let mut object = self
.upload_post_asset(space_id, post_key, plaintext, None)
.await?;
object.metadata_cipher = Some(encrypt_post_object_metadata(
post_key,
&PostObjectMetadata {
width: Some(width),
height: Some(height),
media_type: Some("video/mp4".into()),
duration_ms: Some(duration_ms),
..Default::default()
},
)?);
Ok(object)
}
pub async fn presign_post_upload(
&self,
space_id: &str,
size: usize,
content_md5: &str,
) -> Result<PresignUploadResponse> {
ensure_space_upload_size("post", size, MAX_SPACE_POST_UPLOAD_BYTES)?;
let request = PresignUploadRequest {
size: size as i64,
content_md5: content_md5.to_owned(),
purpose: None,
};
let path = format!("/spaces/{space_id}/uploads/presign");
Ok(self
.api()
.post(&path)
.json(&request)
.send()
.await?
.error_for_code()
.await?
.json()
.await?)
}
pub async fn presign_avatar_upload(
&self,
space_id: &str,
size: usize,
content_md5: &str,
) -> Result<PresignUploadResponse> {
ensure_space_upload_size("avatar", size, MAX_SPACE_AVATAR_UPLOAD_BYTES)?;
let request = PresignUploadRequest {
size: size as i64,
content_md5: content_md5.to_owned(),
purpose: Some(UPLOAD_PURPOSE_AVATAR.to_owned()),
};
let path = format!("/spaces/{space_id}/uploads/presign");
Ok(self
.api()
.post(&path)
.json(&request)
.send()
.await?
.error_for_status()
.map_err(map_account_error)?
.json()
.await?)
}
pub async fn presign_cover_upload(
&self,
space_id: &str,
size: usize,
content_md5: &str,
) -> Result<PresignUploadResponse> {
ensure_space_upload_size("cover", size, MAX_SPACE_COVER_UPLOAD_BYTES)?;
let request = PresignUploadRequest {
size: size as i64,
content_md5: content_md5.to_owned(),
purpose: Some(UPLOAD_PURPOSE_COVER.to_owned()),
};
let path = format!("/spaces/{space_id}/uploads/presign");
Ok(self
.api()
.post(&path)
.json(&request)
.send()
.await?
.error_for_status()
.map_err(map_account_error)?
.json()
.await?)
}
pub async fn upload_bytes(&self, presign: &PresignUploadResponse, body: &[u8]) -> Result<()> {
http::retry(|| async {
let request = presign.headers.iter().fold(
self.api().http().put(&presign.url),
|request, (name, value)| request.header(name, value),
);
request
.body(body.to_vec())
.send()
.await?
.error_for_status()?;
Ok(())
})
.await?;
Ok(())
}
pub async fn upload_post_asset(
&self,
space_id: &str,
post_key: &[u8],
plaintext: &[u8],
position: Option<i32>,
) -> Result<PostObjectPayload> {
let encrypted = encrypt_asset_payload(post_key, plaintext)?;
let content_md5 = content_md5_base64(&encrypted);
let presign = self
.presign_post_upload(space_id, encrypted.len(), &content_md5)
.await?;
self.upload_bytes(&presign, &encrypted).await?;
Ok(PostObjectPayload {
video: None,
object_key: presign.object_key,
size: Some(encrypted.len() as i64),
position,
metadata_cipher: None,
})
}
pub async fn upload_post_photo_asset(
&self,
space_id: &str,
post_key: &[u8],
plaintext: &[u8],
options: PostPhotoAssetOptions,
) -> Result<PostObjectPayload> {
let inferred_media_type = ensure_supported_photo_bytes(plaintext)?;
let media_type = ensure_supported_photo_media_type(options.media_type.as_deref())?
.unwrap_or_else(|| inferred_media_type.to_owned());
let mut object = self
.upload_post_asset(space_id, post_key, plaintext, Some(0))
.await?;
object.metadata_cipher = Some(encrypt_post_object_metadata(
post_key,
&PostObjectMetadata {
width: options.width.filter(|value| *value > 0),
height: options.height.filter(|value| *value > 0),
media_type: Some(media_type),
thumb_hash: options.thumb_hash,
..Default::default()
},
)?);
Ok(object)
}
pub async fn upload_avatar(
&self,
space_id: &str,
space_key: &[u8],
plaintext: &[u8],
) -> Result<ProfileAvatarPayload> {
self.upload_profile_asset(space_id, space_key, plaintext, UPLOAD_PURPOSE_AVATAR)
.await
}
pub async fn upload_cover(
&self,
space_id: &str,
space_key: &[u8],
plaintext: &[u8],
) -> Result<ProfileCoverPayload> {
self.upload_profile_asset(space_id, space_key, plaintext, UPLOAD_PURPOSE_COVER)
.await
}
async fn upload_profile_asset(
&self,
space_id: &str,
space_key: &[u8],
plaintext: &[u8],
purpose: &str,
) -> Result<ProfileAvatarPayload> {
ensure_supported_photo_bytes(plaintext)?;
let encrypted = encrypt_asset_payload(space_key, plaintext)?;
let content_md5 = content_md5_base64(&encrypted);
let presign = match purpose {
UPLOAD_PURPOSE_AVATAR => {
self.presign_avatar_upload(space_id, encrypted.len(), &content_md5)
.await?
}
UPLOAD_PURPOSE_COVER => {
self.presign_cover_upload(space_id, encrypted.len(), &content_md5)
.await?
}
_ => {
return Err(Error::InvalidInput("invalid profile asset purpose".into()));
}
};
self.upload_bytes(&presign, &encrypted).await?;
Ok(ProfileAvatarPayload {
object_id: profile_object_id_from_key(&presign.object_key)?,
size: Some(encrypted.len() as i64),
})
}
pub async fn get_profile_asset_url(
&self,
space_id: &str,
viewer_space_id: Option<&str>,
asset_type: &str,
object_id: &str,
) -> Result<AssetDownloadResponse> {
let mut query = vec![
("assetType", asset_type.to_owned()),
("objectID", object_id.to_owned()),
];
if let Some(value) = viewer_space_id.filter(|value| !value.trim().is_empty()) {
query.push(("viewerSpaceId", value.to_owned()));
}
let path = format!("/spaces/{space_id}/assets/redirect");
Ok(self
.api()
.get(&path)
.query(&query)
.send()
.await?
.error_for_status()?
.json()
.await?)
}
pub async fn download_profile_asset(
&self,
space_id: &str,
viewer_space_id: Option<&str>,
asset_type: &str,
object_id: &str,
key_version: i32,
) -> Result<Vec<u8>> {
let space_key = self
.resolve_space_key_for_version_for_viewer(space_id, viewer_space_id, Some(key_version))
.await?
.ok_or_else(|| {
Error::InvalidInput(format!(
"no space key available for {space_id} version {key_version}"
))
})?;
let download = self
.get_profile_asset_url(space_id, viewer_space_id, asset_type, object_id)
.await?;
let encrypted = self
.api()
.http()
.get(&download.url)
.send()
.await?
.error_for_status()?
.bytes()
.await?;
crate::crypto::decrypt_asset_payload(&space_key, &encrypted)
}
pub async fn get_asset_url(
&self,
space_id: &str,
viewer_space_id: Option<&str>,
object_key: &str,
) -> Result<AssetDownloadResponse> {
let mut query = vec![("objectKey", object_key.to_owned())];
if let Some(value) = viewer_space_id.filter(|value| !value.trim().is_empty()) {
query.push(("viewerSpaceId", value.to_owned()));
}
let path = format!("/spaces/{space_id}/assets/redirect");
Ok(self
.api()
.get(&path)
.query(&query)
.send()
.await?
.error_for_status()?
.json()
.await?)
}
pub async fn download_encrypted_asset(
&self,
space_id: &str,
viewer_space_id: Option<&str>,
object_key: &str,
) -> Result<Vec<u8>> {
let download = self
.get_asset_url(space_id, viewer_space_id, object_key)
.await?;
Ok(self
.api()
.http()
.get(&download.url)
.send()
.await?
.error_for_status()?
.bytes()
.await?)
}
pub async fn download_decrypted_asset(
&self,
space_id: &str,
viewer_space_id: Option<&str>,
object_key: &str,
key: &[u8],
) -> Result<Vec<u8>> {
let encrypted = self
.download_encrypted_asset(space_id, viewer_space_id, object_key)
.await?;
crate::crypto::decrypt_asset_payload(key, &encrypted)
}
}