π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Clean up Legacy crate structure
Manav Rathid6840228bbe8
diff --git a/rust/crates/legacy/src/client/contact.rs b/rust/crates/legacy/src/client/contact.rsnew file mode 100644index 0000000000..488787cee9--- /dev/null+++ b/rust/crates/legacy/src/client/contact.rs@@ -0,0 +1,216 @@+use ente_accounts::auth::KeyAttributes;+use ente_core::b64;+use ente_core::crypto::{self, sealed};+use ente_core::http;+use serde::{Deserialize, Serialize};+use sha2::{Digest, Sha256};++use super::LegacyClient;+use crate::{Error, Result};++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]+pub enum LegacyContactState {+ Invited,+ Revoked,+ Accepted,+ ContactLeft,+ ContactDenied,+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]+pub enum LegacyRecoveryStatus {+ Initiated,+ Waiting,+ Rejected,+ Recovered,+ Stopped,+ Ready,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct LegacyUser {+ pub id: i64,+ pub email: String,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct LegacyContactRecord {+ pub user: LegacyUser,+ pub emergency_contact: LegacyUser,+ pub state: LegacyContactState,+ pub recovery_notice_in_days: i32,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct LegacyRecoverySession {+ pub id: String,+ pub user: LegacyUser,+ pub emergency_contact: LegacyUser,+ pub status: LegacyRecoveryStatus,+ pub wait_till: i64,+ pub created_at: i64,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct LegacyInfo {+ pub contacts: Vec<LegacyContactRecord>,+ #[serde(rename = "recoverSessions")]+ pub recover_sessions: Vec<LegacyRecoverySession>,+ pub others_emergency_contact: Vec<LegacyContactRecord>,+ #[serde(rename = "othersRecoverySession")]+ pub others_recovery_session: Vec<LegacyRecoverySession>,+}++impl LegacyClient {+ pub async fn info(&self) -> Result<LegacyInfo> {+ Ok(self+ .api+ .get("/emergency-contacts/info")+ .send()+ .await?+ .error_for_status()?+ .json::<LegacyInfo>()+ .await?)+ }++ pub async fn public_key(&self, email: &str) -> Result<Option<String>> {+ let response = self+ .api+ .get("/users/public-key")+ .query(&[("email", email.trim())])+ .send()+ .await?;+ if response.status() == 404 {+ return Ok(None);+ }+ let response = response+ .error_for_status()?+ .json::<LegacyPublicKeyResponse>()+ .await?;+ Ok(Some(response.public_key))+ }++ pub fn verification_id(&self, public_key_b64: &str) -> Result<String> {+ let public_key = b64::decode(public_key_b64)?;+ let digest = Sha256::digest(&public_key);+ ente_accounts::auth::recovery_key_to_mnemonic(&b64::encode(digest.as_slice()))+ .map_err(Into::into)+ }++ pub async fn add_contact(+ &self,+ email: &str,+ current_user_key_attrs: &KeyAttributes,+ recovery_notice_in_days: Option<i32>,+ ) -> Result<()> {+ let public_key = self+ .public_key(email)+ .await?+ .ok_or(Error::ContactNotOnEnte)?;+ let recovery_key = self.current_recovery_key(current_user_key_attrs)?;+ let recipient_public_key = b64::decode(&public_key)?;+ let encrypted_key = sealed::seal(+ &recovery_key,+ &crypto::PublicKey::try_from_slice(&recipient_public_key)?,+ )?;++ self.api+ .post("/emergency-contacts/add")+ .json(&LegacyAddContactRequest {+ email: email.trim().to_string(),+ encrypted_key: b64::encode(&encrypted_key),+ recovery_notice_in_days,+ })+ .send()+ .await?+ .error_for_status()?;+ Ok(())+ }++ pub async fn update_contact(+ &self,+ user_id: i64,+ emergency_contact_id: i64,+ state: LegacyContactState,+ ) -> Result<()> {+ self.api+ .post("/emergency-contacts/update")+ .json(&LegacyUpdateContactRequest {+ user_id,+ emergency_contact_id,+ state,+ })+ .send()+ .await?+ .error_for_status()?;+ Ok(())+ }++ pub async fn update_recovery_notice(+ &self,+ emergency_contact_id: i64,+ recovery_notice_in_days: i32,+ ) -> Result<()> {+ let path = "/emergency-contacts/update-recovery-notice";+ let response = self+ .api+ .post(path)+ .json(&LegacyUpdateRecoveryNoticeRequest {+ emergency_contact_id,+ recovery_notice_in_days,+ })+ .send()+ .await?;+ if response.status() == 400 {+ return if response.text().await?.contains("active recovery session") {+ Err(Error::ActiveRecoverySession)+ } else {+ Err(http::Error::Http {+ status: 400,+ path: path.into(),+ }+ .into())+ };+ }+ response.error_for_status()?;+ Ok(())+ }+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyPublicKeyResponse {+ public_key: String,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyAddContactRequest {+ email: String,+ encrypted_key: String,+ recovery_notice_in_days: Option<i32>,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyUpdateContactRequest {+ #[serde(rename = "userID")]+ user_id: i64,+ #[serde(rename = "emergencyContactID")]+ emergency_contact_id: i64,+ state: LegacyContactState,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyUpdateRecoveryNoticeRequest {+ #[serde(rename = "emergencyContactID")]+ emergency_contact_id: i64,+ recovery_notice_in_days: i32,+}diff --git a/rust/crates/legacy/src/client/kit/mod.rs b/rust/crates/legacy/src/client/kit/mod.rsnew file mode 100644index 0000000000..87cd5e9ccf--- /dev/null+++ b/rust/crates/legacy/src/client/kit/mod.rs@@ -0,0 +1,312 @@+mod owner_blob;++use ente_accounts::auth::KeyAttributes;+use ente_core::b64;+use ente_core::crypto::{self, SecretVec, secretbox};+use ente_core::http;+use serde::{Deserialize, Serialize};+use uuid::Uuid;++use super::LegacyClient;+use crate::kit::{+ LEGACY_KIT_PAYLOAD_VERSION, LegacyKit, LegacyKitCreateResult, LegacyKitOwnerRecoverySession,+ LegacyKitRecoveryInitiator, LegacyKitRecoverySession, LegacyKitShare, LegacyKitVariant,+ checksum, derive_kit_auth_keypair, derive_kit_encryption_key, split_secret_2_of_3,+};+use crate::{Error, Result};+use owner_blob::{+ create_owner_blob, decrypt_owner_blob, encrypt_owner_blob, metadata_from_owner_blob,+};++const NOTICE_PERIOD_OPTIONS: [i32; 5] = [0, 24, 168, 360, 720];++impl LegacyClient {+ pub async fn kits(&self) -> Result<Vec<LegacyKit>> {+ let response = self+ .api+ .get("/legacy-kits")+ .send()+ .await?+ .error_for_status()?+ .json::<ListLegacyKitsResponse>()+ .await?;+ response+ .kits+ .into_iter()+ .map(|kit| decode_kit_record(kit, self.master_key.as_ref()))+ .collect()+ }++ pub async fn create_kit(+ &self,+ key_attributes: &KeyAttributes,+ part_names: [String; 3],+ notice_period_in_hours: i32,+ ) -> Result<LegacyKitCreateResult> {+ let (request, shares) = {+ let recovery_key = self.current_recovery_key(key_attributes)?;+ create_kit_request(+ &recovery_key,+ self.master_key.as_ref(),+ part_names,+ notice_period_in_hours,+ )?+ };++ let response = self+ .api+ .post("/legacy-kits")+ .json(&request)+ .send()+ .await?+ .error_for_status()?+ .json::<LegacyKitRecordResponse>()+ .await?;+ let kit = decode_kit_record(response, self.master_key.as_ref())?;+ Ok(LegacyKitCreateResult { kit, shares })+ }++ pub async fn download_kit_shares(&self, kit_id: &str) -> Result<Vec<LegacyKitShare>> {+ let response = self+ .api+ .get(&format!("/legacy-kits/{kit_id}/download-content"))+ .send()+ .await?+ .error_for_status()?+ .json::<LegacyKitDownloadContentResponse>()+ .await?;+ decode_download_content(response, self.master_key.as_ref())+ }++ pub async fn kit_recovery_session(+ &self,+ kit_id: &str,+ ) -> Result<LegacyKitOwnerRecoverySession> {+ let response = self+ .api+ .get(&format!("/legacy-kits/{kit_id}/recovery-session"))+ .send()+ .await?+ .error_for_status()?+ .json::<LegacyKitOwnerRecoverySessionResponse>()+ .await?;+ Ok(response.into())+ }++ pub async fn update_kit_recovery_notice(+ &self,+ kit_id: &str,+ notice_period_in_hours: i32,+ ) -> Result<()> {+ validate_notice_period(notice_period_in_hours)?;+ let path = "/legacy-kits/update-recovery-notice";+ let response = self+ .api+ .post(path)+ .json(&LegacyKitUpdateRecoveryNoticeRequest {+ kit_id: kit_id.to_string(),+ notice_period_in_hours,+ })+ .send()+ .await?;+ if response.status() == 400 {+ return if response.text().await?.contains("active recovery session") {+ Err(Error::ActiveRecoverySession)+ } else {+ Err(http::Error::Http {+ status: 400,+ path: path.into(),+ }+ .into())+ };+ }+ response.error_for_status()?;+ Ok(())+ }++ pub async fn block_kit_recovery(&self, kit_id: &str) -> Result<()> {+ self.api+ .post("/legacy-kits/block-recovery")+ .json(&LegacyKitOwnerActionRequest {+ kit_id: kit_id.to_string(),+ })+ .send()+ .await?+ .error_for_status()?;+ Ok(())+ }++ pub async fn delete_kit(&self, kit_id: &str) -> Result<()> {+ self.api+ .delete(&format!("/legacy-kits/{kit_id}"))+ .send()+ .await?+ .error_for_status()?;+ Ok(())+ }+}++fn create_kit_request(+ recovery_key: &[u8],+ master_key: &[u8],+ part_names: [String; 3],+ notice_period_in_hours: i32,+) -> Result<(CreateLegacyKitRequest, Vec<LegacyKitShare>)> {+ validate_notice_period(notice_period_in_hours)?;+ if part_names.iter().any(|name| name.trim().is_empty()) {+ return Err(Error::InvalidInput(+ "legacy kit part names must be non-empty".into(),+ ));+ }++ let kit_id = Uuid::new_v4().to_string();+ let variant = LegacyKitVariant::TwoOfThree;+ let kit_secret = SecretVec::new(crypto::random_bytes(32));+ let checksum = checksum(LEGACY_KIT_PAYLOAD_VERSION, variant, &kit_id, &kit_secret);+ let shares = split_secret_2_of_3(&kit_secret)?;+ let shares = shares+ .into_iter()+ .zip(part_names)+ .enumerate()+ .map(|(index, (share, part_name))| LegacyKitShare {+ payload_version: LEGACY_KIT_PAYLOAD_VERSION,+ variant,+ kit_id: kit_id.clone(),+ share_index: (index + 1) as u8,+ share: b64::encode(&share),+ checksum: checksum.clone(),+ part_name,+ })+ .collect::<Vec<_>>();++ let encryption_key = derive_kit_encryption_key(&kit_secret)?;+ let (auth_public_key, _) = derive_kit_auth_keypair(&kit_secret)?;+ let encrypted_recovery_blob =+ secretbox::encrypt_combined(recovery_key, &crypto::Key::try_from_slice(&encryption_key)?);+ let encrypted_owner_blob = encrypt_owner_blob(&create_owner_blob(&shares), master_key)?;++ Ok((+ CreateLegacyKitRequest {+ id: kit_id,+ variant,+ notice_period_in_hours,+ encrypted_recovery_blob: b64::encode(&encrypted_recovery_blob),+ auth_public_key: b64::encode(auth_public_key.as_bytes()),+ encrypted_owner_blob,+ },+ shares,+ ))+}++fn decode_kit_record(response: LegacyKitRecordResponse, master_key: &[u8]) -> Result<LegacyKit> {+ let owner_blob = decrypt_owner_blob(&response.encrypted_owner_blob, master_key)?;+ Ok(LegacyKit {+ id: response.id,+ variant: response.variant,+ notice_period_in_hours: response.notice_period_in_hours,+ legacy_url: response.legacy_url,+ metadata: metadata_from_owner_blob(&owner_blob),+ created_at: response.created_at,+ updated_at: response.updated_at,+ active_recovery_session: response.active_recovery_session,+ })+}++fn decode_download_content(+ response: LegacyKitDownloadContentResponse,+ master_key: &[u8],+) -> Result<Vec<LegacyKitShare>> {+ let owner_blob = decrypt_owner_blob(&response.encrypted_owner_blob, master_key)?;+ Ok(owner_blob+ .parts+ .into_iter()+ .map(|part| LegacyKitShare {+ payload_version: LEGACY_KIT_PAYLOAD_VERSION,+ variant: response.variant,+ kit_id: response.id.clone(),+ share_index: part.index,+ share: part.share,+ checksum: part.checksum,+ part_name: part.name,+ })+ .collect())+}++fn validate_notice_period(hours: i32) -> Result<()> {+ if NOTICE_PERIOD_OPTIONS.contains(&hours) {+ Ok(())+ } else {+ Err(Error::InvalidInput(+ "legacy kit notice period must be one of 0, 24, 168, 360, 720 hours".into(),+ ))+ }+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct CreateLegacyKitRequest {+ id: String,+ variant: LegacyKitVariant,+ notice_period_in_hours: i32,+ encrypted_recovery_blob: String,+ auth_public_key: String,+ encrypted_owner_blob: String,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitRecordResponse {+ id: String,+ variant: LegacyKitVariant,+ notice_period_in_hours: i32,+ legacy_url: String,+ encrypted_owner_blob: String,+ created_at: i64,+ updated_at: i64,+ active_recovery_session: Option<LegacyKitRecoverySession>,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct ListLegacyKitsResponse {+ kits: Vec<LegacyKitRecordResponse>,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitDownloadContentResponse {+ id: String,+ variant: LegacyKitVariant,+ encrypted_owner_blob: String,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitOwnerActionRequest {+ #[serde(rename = "kitID")]+ kit_id: String,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitUpdateRecoveryNoticeRequest {+ #[serde(rename = "kitID")]+ kit_id: String,+ notice_period_in_hours: i32,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitOwnerRecoverySessionResponse {+ session: Option<LegacyKitRecoverySession>,+ initiators: Vec<LegacyKitRecoveryInitiator>,+}++impl From<LegacyKitOwnerRecoverySessionResponse> for LegacyKitOwnerRecoverySession {+ fn from(value: LegacyKitOwnerRecoverySessionResponse) -> Self {+ Self {+ session: value.session,+ initiators: value.initiators,+ }+ }+}diff --git a/rust/crates/legacy/src/kit/owner_blob.rs b/rust/crates/legacy/src/client/kit/owner_blob.rssimilarity index 92%rename from rust/crates/legacy/src/kit/owner_blob.rsrename to rust/crates/legacy/src/client/kit/owner_blob.rsindex 5f71968ebc..bacb877aee 100644--- a/rust/crates/legacy/src/kit/owner_blob.rs+++ b/rust/crates/legacy/src/client/kit/owner_blob.rs@@ -2,12 +2,10 @@ use ente_core::b64;use ente_core::crypto::{self, secretbox};use serde::{Deserialize, Serialize, de::DeserializeOwned};-use crate::{- Error, Result,- kit_models::{LegacyKitMetadata, LegacyKitPart, LegacyKitShare},-};+use crate::kit::{LegacyKitMetadata, LegacyKitPart, LegacyKitShare};+use crate::{Error, Result};-#[derive(Debug, Clone, Serialize, Deserialize)]+#[derive(Serialize, Deserialize)]pub(super) struct StoredOwnerPart {pub(super) index: u8,pub(super) name: String,@@ -15,7 +13,7 @@ pub(super) struct StoredOwnerPart {pub(super) checksum: String,}-#[derive(Debug, Clone, Serialize, Deserialize)]+#[derive(Serialize, Deserialize)]pub(super) struct StoredOwnerBlob {pub(super) parts: Vec<StoredOwnerPart>,}@@ -48,6 +46,19 @@ pub(super) fn decrypt_owner_blob(decrypt_blob(encrypted_blob_b64, master_key, "legacy kit owner")}+pub(super) fn metadata_from_owner_blob(owner_blob: &StoredOwnerBlob) -> LegacyKitMetadata {+ LegacyKitMetadata {+ parts: owner_blob+ .parts+ .iter()+ .map(|part| LegacyKitPart {+ index: part.index,+ name: part.name.clone(),+ })+ .collect(),+ }+}+fn encrypt_blob<T: Serialize>(payload: &T, master_key: &[u8], label: &str) -> Result<String> {let payload = serde_json::to_vec(payload).map_err(|error| {Error::InvalidInput(format!("failed to encode {label} payload: {error}"))@@ -68,16 +79,3 @@ fn decrypt_blob<T: DeserializeOwned>(serde_json::from_slice(&plaintext).map_err(|error| Error::InvalidInput(format!("failed to decode {label} payload: {error}")))}--pub(super) fn metadata_from_owner_blob(owner_blob: &StoredOwnerBlob) -> LegacyKitMetadata {- LegacyKitMetadata {- parts: owner_blob- .parts- .iter()- .map(|part| LegacyKitPart {- index: part.index,- name: part.name.clone(),- })- .collect(),- }-}diff --git a/rust/crates/legacy/src/client/mod.rs b/rust/crates/legacy/src/client/mod.rsnew file mode 100644index 0000000000..b2ccec727f--- /dev/null+++ b/rust/crates/legacy/src/client/mod.rs@@ -0,0 +1,33 @@+mod contact;+mod kit;+mod recovery;++pub use contact::{+ LegacyContactRecord, LegacyContactState, LegacyInfo, LegacyRecoverySession,+ LegacyRecoveryStatus, LegacyUser,+};+pub use recovery::LegacyRecoveryBundle;++use std::sync::Arc;++use ente_accounts::auth::{self, KeyAttributes};+use ente_core::crypto::SecretVec;+use ente_core::http::Api;++use crate::Result;++pub struct LegacyClient {+ api: Arc<Api>,+ master_key: Arc<SecretVec>,+}++impl LegacyClient {+ pub fn new(api: Arc<Api>, master_key: Arc<SecretVec>) -> Self {+ Self { api, master_key }+ }++ fn current_recovery_key(&self, key_attributes: &KeyAttributes) -> Result<SecretVec> {+ let recovery_key = auth::get_recovery_key(self.master_key.as_ref(), key_attributes)?;+ Ok(auth::recovery_key_from_mnemonic_or_hex(&recovery_key)?)+ }+}diff --git a/rust/crates/legacy/src/client.rs b/rust/crates/legacy/src/client/recovery.rssimilarity index 50%rename from rust/crates/legacy/src/client.rsrename to rust/crates/legacy/src/client/recovery.rsindex cf3e3c71e9..720a56ad0b 100644--- a/rust/crates/legacy/src/client.rs+++ b/rust/crates/legacy/src/client/recovery.rs@@ -1,157 +1,19 @@-use std::sync::Arc;-use ente_accounts::auth::{self, KeyAttributes, SrpSession};use ente_core::b64;use ente_core::crypto::{self, SecretVec, sealed, secretbox};-use ente_core::http::{self, Api};-use sha2::{Digest, Sha256};+use serde::{Deserialize, Serialize};use uuid::Uuid;-use crate::error::{Error, Result};-use crate::kit::{- create_legacy_kit_request, decode_download_content, decode_legacy_kit_record,- validate_notice_period,-};-use crate::kit_models::{- LegacyKit, LegacyKitCreateResult, LegacyKitOwnerRecoverySession, LegacyKitShare,-};-use crate::kit_transport::{- LegacyKitDownloadContentResponse, LegacyKitOwnerActionRequest,- LegacyKitOwnerRecoverySessionResponse, LegacyKitRecordResponse,- LegacyKitUpdateRecoveryNoticeRequest, ListLegacyKitsResponse,-};-use crate::models::{LegacyContactState, LegacyInfo, LegacyRecoveryBundle};-use crate::transport::{- LegacyAddContactRequest, LegacyChangePasswordRequest, LegacyChangePasswordResponse,- LegacyContactIdentifier, LegacyInitChangePasswordRequest, LegacyPublicKeyResponse,- LegacyRecoveryIdentifier, LegacyRecoveryInfoResponse, LegacySetupSrpRequest,- LegacySetupSrpResponse, LegacyUpdateContactRequest, LegacyUpdateRecoveryNoticeRequest,- LegacyUpdateSrpAndKeysRequest, LegacyUpdatedKeyAttr,-};+use super::LegacyClient;+use crate::{Error, Result};-pub struct LegacyClient {- api: Arc<Api>,- master_key: Arc<SecretVec>,+#[derive(Debug)]+pub struct LegacyRecoveryBundle {+ pub recovery_key: SecretVec,+ pub user_key_attributes: KeyAttributes,}impl LegacyClient {- pub fn new(api: Arc<Api>, master_key: Arc<SecretVec>) -> Self {- Self { api, master_key }- }-- pub async fn info(&self) -> Result<LegacyInfo> {- Ok(self- .api- .get("/emergency-contacts/info")- .send()- .await?- .error_for_status()?- .json::<LegacyInfo>()- .await?)- }-- pub async fn public_key(&self, email: &str) -> Result<Option<String>> {- let response = self- .api- .get("/users/public-key")- .query(&[("email", email.trim())])- .send()- .await?;- if response.status() == 404 {- return Ok(None);- }- let response = response- .error_for_status()?- .json::<LegacyPublicKeyResponse>()- .await?;- Ok(Some(response.public_key))- }-- pub fn verification_id(&self, public_key_b64: &str) -> Result<String> {- let public_key = b64::decode(public_key_b64)?;- let digest = Sha256::digest(&public_key);- auth::recovery_key_to_mnemonic(&b64::encode(digest.as_slice())).map_err(Into::into)- }-- pub async fn add_contact(- &self,- email: &str,- current_user_key_attrs: &KeyAttributes,- recovery_notice_in_days: Option<i32>,- ) -> Result<()> {- let public_key = self- .public_key(email)- .await?- .ok_or(Error::ContactNotOnEnte)?;- let recovery_key = self.current_recovery_key(current_user_key_attrs)?;- let recipient_public_key = b64::decode(&public_key)?;- let encrypted_key = sealed::seal(- &recovery_key,- &crypto::PublicKey::try_from_slice(&recipient_public_key)?,- )?;-- self.api- .post("/emergency-contacts/add")- .json(&LegacyAddContactRequest {- email: email.trim().to_string(),- encrypted_key: b64::encode(&encrypted_key),- recovery_notice_in_days,- })- .send()- .await?- .error_for_status()?;- Ok(())- }-- pub async fn update_contact(- &self,- user_id: i64,- emergency_contact_id: i64,- state: LegacyContactState,- ) -> Result<()> {- self.api- .post("/emergency-contacts/update")- .json(&LegacyUpdateContactRequest {- user_id,- emergency_contact_id,- state,- })- .send()- .await?- .error_for_status()?;- Ok(())- }-- pub async fn update_recovery_notice(- &self,- emergency_contact_id: i64,- recovery_notice_in_days: i32,- ) -> Result<()> {- let path = "/emergency-contacts/update-recovery-notice";- let response = self- .api- .post(path)- .json(&LegacyUpdateRecoveryNoticeRequest {- emergency_contact_id,- recovery_notice_in_days,- })- .send()- .await?;- if response.status() == 400 {- return if response.text().await?.contains("active recovery session") {- Err(Error::ActiveRecoverySession)- } else {- Err(http::Error::Http {- status: 400,- path: path.into(),- }- .into())- };- }- response.error_for_status()?;- Ok(())- }-pub async fn start_recovery(&self, user_id: i64, emergency_contact_id: i64) -> Result<()> {self.contact_action("/emergency-contacts/start-recovery",@@ -285,130 +147,6 @@ impl LegacyClient {Ok(())}- pub async fn kits(&self) -> Result<Vec<LegacyKit>> {- let response = self- .api- .get("/legacy-kits")- .send()- .await?- .error_for_status()?- .json::<ListLegacyKitsResponse>()- .await?;- response- .kits- .into_iter()- .map(|kit| decode_legacy_kit_record(kit, self.master_key.as_ref()))- .collect()- }-- pub async fn create_kit(- &self,- current_user_key_attrs: &KeyAttributes,- part_names: [String; 3],- notice_period_in_hours: i32,- ) -> Result<LegacyKitCreateResult> {- let (request, shares) = {- let recovery_key = self.current_recovery_key(current_user_key_attrs)?;- create_legacy_kit_request(- &recovery_key,- self.master_key.as_ref(),- part_names,- notice_period_in_hours,- )?- };-- let response = self- .api- .post("/legacy-kits")- .json(&request)- .send()- .await?- .error_for_status()?- .json::<LegacyKitRecordResponse>()- .await?;- let kit = decode_legacy_kit_record(response, self.master_key.as_ref())?;- Ok(LegacyKitCreateResult { kit, shares })- }-- pub async fn download_kit_shares(&self, kit_id: &str) -> Result<Vec<LegacyKitShare>> {- let response = self- .api- .get(&format!("/legacy-kits/{kit_id}/download-content"))- .send()- .await?- .error_for_status()?- .json::<LegacyKitDownloadContentResponse>()- .await?;- decode_download_content(response, self.master_key.as_ref())- }-- pub async fn kit_recovery_session(- &self,- kit_id: &str,- ) -> Result<LegacyKitOwnerRecoverySession> {- let response = self- .api- .get(&format!("/legacy-kits/{kit_id}/recovery-session"))- .send()- .await?- .error_for_status()?- .json::<LegacyKitOwnerRecoverySessionResponse>()- .await?;- Ok(response.into())- }-- pub async fn update_kit_recovery_notice(- &self,- kit_id: &str,- notice_period_in_hours: i32,- ) -> Result<()> {- validate_notice_period(notice_period_in_hours)?;- let path = "/legacy-kits/update-recovery-notice";- let response = self- .api- .post(path)- .json(&LegacyKitUpdateRecoveryNoticeRequest {- kit_id: kit_id.to_string(),- notice_period_in_hours,- })- .send()- .await?;- if response.status() == 400 {- return if response.text().await?.contains("active recovery session") {- Err(Error::ActiveRecoverySession)- } else {- Err(http::Error::Http {- status: 400,- path: path.into(),- }- .into())- };- }- response.error_for_status()?;- Ok(())- }-- pub async fn block_kit_recovery(&self, kit_id: &str) -> Result<()> {- self.api- .post("/legacy-kits/block-recovery")- .json(&LegacyKitOwnerActionRequest {- kit_id: kit_id.to_string(),- })- .send()- .await?- .error_for_status()?;- Ok(())- }-- pub async fn delete_kit(&self, kit_id: &str) -> Result<()> {- self.api- .delete(&format!("/legacy-kits/{kit_id}"))- .send()- .await?- .error_for_status()?;- Ok(())- }-async fn contact_action(&self,path: &str,@@ -458,12 +196,6 @@ impl LegacyClient {.await?)}- fn current_recovery_key(&self, current_user_key_attrs: &KeyAttributes) -> Result<SecretVec> {- let recovery_key_hex =- auth::get_recovery_key(self.master_key.as_ref(), current_user_key_attrs)?;- Ok(auth::recovery_key_from_mnemonic_or_hex(&recovery_key_hex)?)- }-fn decrypt_recovery_key(&self,encrypted_key_b64: &str,@@ -552,3 +284,96 @@ fn srp_session_m1(let client_m1 = srp_session.compute_m1(&server_b)?;Ok(b64::encode(&client_m1))}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyContactIdentifier {+ #[serde(rename = "userID")]+ user_id: i64,+ #[serde(rename = "emergencyContactID")]+ emergency_contact_id: i64,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyRecoveryIdentifier {+ id: String,+ #[serde(rename = "userID")]+ user_id: i64,+ #[serde(rename = "emergencyContactID")]+ emergency_contact_id: i64,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyRecoveryInfoResponse {+ encrypted_key: String,+ #[serde(rename = "userKeyAttr")]+ user_key_attr: KeyAttributes,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacySetupSrpRequest {+ #[serde(rename = "srpUserID")]+ srp_user_id: String,+ srp_salt: String,+ srp_verifier: String,+ #[serde(rename = "srpA")]+ srp_a: String,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyInitChangePasswordRequest {+ #[serde(rename = "recoveryID")]+ recovery_id: String,+ #[serde(rename = "setupSRPRequest")]+ setup_srp_request: LegacySetupSrpRequest,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacySetupSrpResponse {+ #[serde(rename = "setupID")]+ setup_id: String,+ #[serde(rename = "srpB")]+ srp_b: String,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyUpdatedKeyAttr {+ kek_salt: String,+ encrypted_key: String,+ key_decryption_nonce: String,+ mem_limit: u32,+ ops_limit: u32,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyUpdateSrpAndKeysRequest {+ #[serde(rename = "setupID")]+ setup_id: String,+ #[serde(rename = "srpM1")]+ srp_m1: String,+ #[serde(rename = "updatedKeyAttr")]+ updated_key_attr: LegacyUpdatedKeyAttr,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyChangePasswordRequest {+ #[serde(rename = "recoveryID")]+ recovery_id: String,+ #[serde(rename = "updateSrpAndKeysRequest")]+ update_srp_and_keys_request: LegacyUpdateSrpAndKeysRequest,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyChangePasswordResponse {+ #[serde(rename = "srpM2")]+ srp_m2: String,+}diff --git a/rust/crates/legacy/src/kit/mod.rs b/rust/crates/legacy/src/kit/mod.rsindex 74717c4839..17194da356 100644--- a/rust/crates/legacy/src/kit/mod.rs+++ b/rust/crates/legacy/src/kit/mod.rs@@ -1,455 +1,33 @@-mod owner_blob;+mod models;+mod recovery;mod shares;-use std::sync::Arc;--use ente_accounts::auth::{self, KeyAttributes, SrpSession};-use ente_core::b64;-use ente_core::{- crypto::{self, SecretString, SecretVec, kdf, sealed, secretbox},- http::{Api, ApiConfig, Http, Response},-};-use uuid::Uuid;--use crate::{- Error, Result,- kit_models::{- LEGACY_KIT_PAYLOAD_VERSION, LegacyKit, LegacyKitRecoveryBundle, LegacyKitRecoverySession,- LegacyKitShare, LegacyKitVariant,- },- kit_transport::{- CreateLegacyKitRequest, LegacyKitChallengeRequest, LegacyKitChallengeResponse,- LegacyKitChangePasswordRequest, LegacyKitChangePasswordResponse,- LegacyKitDownloadContentResponse, LegacyKitInitChangePasswordRequest,- LegacyKitOpenRecoveryRequest, LegacyKitOpenRecoveryResponse, LegacyKitRecordResponse,- LegacyKitRecoveryInfoResponse, LegacyKitSessionRequest, LegacyKitSetupSrpRequest,- LegacyKitSetupSrpResponse, LegacyKitUpdateSrpAndKeysRequest, LegacyKitUpdatedKeyAttr,- },+pub use models::{+ LEGACY_KIT_PAYLOAD_VERSION, LegacyKit, LegacyKitCreateResult, LegacyKitMetadata,+ LegacyKitOwnerRecoverySession, LegacyKitPart, LegacyKitRecoveryBundle,+ LegacyKitRecoveryInitiator, LegacyKitRecoverySession, LegacyKitRecoveryStatus, LegacyKitShare,+ LegacyKitVariant,};-use owner_blob::{- create_owner_blob, decrypt_owner_blob, encrypt_owner_blob, metadata_from_owner_blob,-};-use shares::{checksum, reconstruct_secret_2_of_3, split_secret_2_of_3, used_part_indexes};--const LEGACY_KIT_NOTICE_OPTIONS: [i32; 5] = [0, 24, 168, 360, 720];--pub(crate) fn create_legacy_kit_request(- recovery_key: &[u8],- master_key: &[u8],- part_names: [String; 3],- notice_period_in_hours: i32,-) -> Result<(CreateLegacyKitRequest, Vec<LegacyKitShare>)> {- validate_notice_period(notice_period_in_hours)?;- if part_names.iter().any(|name| name.trim().is_empty()) {- return Err(Error::InvalidInput(- "legacy kit part names must be non-empty".into(),- ));- }-- let kit_id = Uuid::new_v4().to_string();- let variant = LegacyKitVariant::TwoOfThree;- let kit_secret = SecretVec::new(crypto::random_bytes(32));- let checksum = checksum(LEGACY_KIT_PAYLOAD_VERSION, variant, &kit_id, &kit_secret);- let shares = split_secret_2_of_3(&kit_secret)?;- let result_shares = shares- .into_iter()- .zip(part_names.iter())- .enumerate()- .map(|(index, (share_bytes, part_name))| LegacyKitShare {- payload_version: LEGACY_KIT_PAYLOAD_VERSION,- variant,- kit_id: kit_id.clone(),- share_index: (index + 1) as u8,- share: b64::encode(&share_bytes),- checksum: checksum.clone(),- part_name: part_name.clone(),- })- .collect::<Vec<_>>();-- let enc_key = derive_kit_enc_key(&kit_secret)?;- let (auth_public_key, _auth_secret_key) = derive_kit_auth_keypair(&kit_secret)?;-- let encrypted_recovery_blob =- secretbox::encrypt_combined(recovery_key, &crypto::Key::try_from_slice(&enc_key)?);- let owner_blob = create_owner_blob(&result_shares);- let encrypted_owner_blob = encrypt_owner_blob(&owner_blob, master_key)?;-- Ok((- CreateLegacyKitRequest {- id: kit_id,- variant,- notice_period_in_hours,- encrypted_recovery_blob: b64::encode(&encrypted_recovery_blob),- auth_public_key: b64::encode(auth_public_key.as_bytes()),- encrypted_owner_blob,- },- result_shares,- ))-}--pub(crate) fn decode_legacy_kit_record(- response: LegacyKitRecordResponse,- master_key: &[u8],-) -> Result<LegacyKit> {- let owner_blob = decrypt_owner_blob(&response.encrypted_owner_blob, master_key)?;- let metadata = metadata_from_owner_blob(&owner_blob);- Ok(LegacyKit {- id: response.id,- variant: response.variant,- notice_period_in_hours: response.notice_period_in_hours,- legacy_url: response.legacy_url,- metadata,- created_at: response.created_at,- updated_at: response.updated_at,- active_recovery_session: response.active_recovery_session,- })-}--pub(crate) fn decode_download_content(- response: LegacyKitDownloadContentResponse,- master_key: &[u8],-) -> Result<Vec<LegacyKitShare>> {- let owner_blob = decrypt_owner_blob(&response.encrypted_owner_blob, master_key)?;- Ok(owner_blob- .parts- .into_iter()- .map(|part| LegacyKitShare {- payload_version: LEGACY_KIT_PAYLOAD_VERSION,- variant: response.variant,- kit_id: response.id.clone(),- share_index: part.index,- share: part.share,- checksum: part.checksum,- part_name: part.name,- })- .collect::<Vec<_>>())-}--pub struct LegacyKitRecoveryClient {- api: Arc<Api>,-}--pub struct LegacyKitRecoveryHandle {- api: Arc<Api>,- session: LegacyKitRecoverySession,- session_token: SecretString,- kit_secret: SecretVec,-}--impl LegacyKitRecoveryClient {- pub fn new(base_url: impl Into<String>) -> Result<Self> {- Self::new_with_headers(- base_url,- None,- None,- Some("ente-rust-legacy-kit".to_string()),- )- }-- pub fn new_with_headers(- base_url: impl Into<String>,- client_package: Option<String>,- client_version: Option<String>,- user_agent: Option<String>,- ) -> Result<Self> {- let api = Api::new(- Http::new()?,- ApiConfig {- origin: base_url.into(),- client_package,- client_version,- user_agent,- auth: None,- },- );- Ok(Self { api: Arc::new(api) })- }+pub use recovery::{LegacyKitRecoveryClient, LegacyKitRecoveryHandle};- pub fn reconstruct_secret(shares: &[LegacyKitShare]) -> Result<SecretVec> {- reconstruct_secret_2_of_3(shares)- }+use ente_core::crypto::{self, SecretVec, kdf};- pub async fn open_from_shares(- &self,- shares: &[LegacyKitShare],- email: Option<&str>,- ) -> Result<LegacyKitRecoveryHandle> {- let first_share = shares.first().ok_or_else(|| {- Error::InvalidInput("at least two legacy kit shares are required".into())- })?;- let response = self- .api- .post("/legacy-kits/recovery/challenge")- .json(&LegacyKitChallengeRequest {- kit_id: first_share.kit_id.clone(),- })- .send()- .await?;- let challenge = active_kit_response(response)?- .json::<LegacyKitChallengeResponse>()- .await?;- self.open_from_encrypted_challenge(shares, &challenge.encrypted_challenge, email)- .await- }+use crate::{Error, Result};- pub async fn open_from_encrypted_challenge(- &self,- shares: &[LegacyKitShare],- encrypted_challenge: &str,- email: Option<&str>,- ) -> Result<LegacyKitRecoveryHandle> {- let kit_secret = reconstruct_secret_2_of_3(shares)?;- let first_share = shares.first().ok_or_else(|| {- Error::InvalidInput("at least two legacy kit shares are required".into())- })?;- let used_part_indexes = used_part_indexes(shares)?;- self.open_with_kit_secret(- first_share,- kit_secret,- encrypted_challenge,- Some(used_part_indexes),- email.map(ToOwned::to_owned),- )- .await- }-}--impl LegacyKitRecoveryHandle {- pub fn session(&self) -> &LegacyKitRecoverySession {- &self.session- }-- pub async fn refresh_session(&self) -> Result<LegacyKitRecoverySession> {- let response = self- .api- .post("/legacy-kits/recovery/session")- .json(&LegacyKitSessionRequest {- session_id: self.session.id.clone(),- session_token: self.session_token.as_ref().to_owned(),- })- .send()- .await?;- Ok(response.error_for_status()?.json().await?)- }-- pub async fn recovery_bundle(&self) -> Result<LegacyKitRecoveryBundle> {- let response = self- .api- .post("/legacy-kits/recovery/info")- .json(&LegacyKitSessionRequest {- session_id: self.session.id.clone(),- session_token: self.session_token.as_ref().to_owned(),- })- .send()- .await?;- let response = response- .error_for_status()?- .json::<LegacyKitRecoveryInfoResponse>()- .await?;- let enc_key = derive_kit_enc_key(&self.kit_secret)?;- let encrypted_recovery_blob = b64::decode(&response.encrypted_recovery_blob)?;- let recovery_key = secretbox::decrypt_combined(- &encrypted_recovery_blob,- &crypto::Key::try_from_slice(&enc_key)?,- )?;- Ok(LegacyKitRecoveryBundle {- recovery_key: SecretVec::new(recovery_key),- user_key_attributes: response.user_key_attr,- })- }-- pub async fn change_password(&self, new_password: &str) -> Result<()> {- let bundle = self.recovery_bundle().await?;- let target_master_key = decrypt_master_key_with_recovery_key(- &bundle.user_key_attributes,- &bundle.recovery_key,- )?;- let (updated_key_attrs, login_key) = auth::generate_key_attributes_for_new_password(- &target_master_key,- &bundle.user_key_attributes,- new_password,- )?;- let srp_user_id = Uuid::new_v4().to_string();- let (mut srp_session, setup_request) =- password_reset_setup_request(&srp_user_id, &login_key)?;- let response = self- .api- .post("/legacy-kits/recovery/init-change-password")- .json(&LegacyKitInitChangePasswordRequest {- session_id: self.session.id.clone(),- session_token: self.session_token.as_ref().to_owned(),- setup_srp_request: setup_request,- })- .send()- .await?;- let init_response = response- .error_for_status()?- .json::<LegacyKitSetupSrpResponse>()- .await?;- let srp_m1 = srp_session_m1(&mut srp_session, &init_response)?;- let updated_key_attr = LegacyKitUpdatedKeyAttr {- kek_salt: updated_key_attrs.kek_salt.clone(),- encrypted_key: updated_key_attrs.encrypted_key.clone(),- key_decryption_nonce: updated_key_attrs.key_decryption_nonce.clone(),- mem_limit: updated_key_attrs.mem_limit,- ops_limit: updated_key_attrs.ops_limit,- };- let response = self- .api- .post("/legacy-kits/recovery/change-password")- .json(&LegacyKitChangePasswordRequest {- session_id: self.session.id.clone(),- session_token: self.session_token.as_ref().to_owned(),- update_srp_and_keys_request: LegacyKitUpdateSrpAndKeysRequest {- setup_id: init_response.setup_id,- srp_m1,- updated_key_attr,- },- })- .send()- .await?;- let change_response = response- .error_for_status()?- .json::<LegacyKitChangePasswordResponse>()- .await?;- let server_m2 = b64::decode(&change_response.srp_m2)?;- srp_session.verify_m2(&server_m2)?;- Ok(())- }-}--impl LegacyKitRecoveryClient {- async fn open_with_kit_secret(- &self,- first_share: &LegacyKitShare,- kit_secret: SecretVec,- encrypted_challenge: &str,- used_part_indexes: Option<Vec<u8>>,- email: Option<String>,- ) -> Result<LegacyKitRecoveryHandle> {- let (auth_public_key, auth_secret_key) = derive_kit_auth_keypair(&kit_secret)?;- let challenge = decrypt_challenge(&auth_public_key, &auth_secret_key, encrypted_challenge)?;- let response = self- .api- .post("/legacy-kits/recovery/open")- .json(&LegacyKitOpenRecoveryRequest {- kit_id: first_share.kit_id.clone(),- challenge,- used_part_indexes,- email,- })- .send()- .await?;- let response = active_kit_response(response)?- .json::<LegacyKitOpenRecoveryResponse>()- .await?;- Ok(LegacyKitRecoveryHandle {- api: Arc::clone(&self.api),- session: response.session,- session_token: SecretString::new(response.session_token),- kit_secret,- })- }-}--fn active_kit_response(response: Response) -> Result<Response> {- if response.status() == 404 {- Err(Error::LegacyKitInactive)- } else {- Ok(response.error_for_status()?)- }-}--pub(crate) fn validate_notice_period(hours: i32) -> Result<()> {- if LEGACY_KIT_NOTICE_OPTIONS.contains(&hours) {- Ok(())- } else {- Err(Error::InvalidInput(- "legacy kit notice period must be one of 0, 24, 168, 360, 720 hours".into(),- ))- }-}+pub(crate) use shares::{+ checksum, reconstruct_secret_2_of_3, split_secret_2_of_3, used_part_indexes,+};-fn derive_kit_enc_key(kit_secret: &[u8]) -> Result<SecretVec> {+pub(crate) fn derive_kit_encryption_key(kit_secret: &[u8]) -> Result<SecretVec> {let kit_key = crypto::Key::try_from_slice(kit_secret)?;kdf::derive_subkey(&kit_key, 32, 1, b"lgkenc01").map_err(Error::from)}-fn derive_kit_auth_keypair(kit_secret: &[u8]) -> Result<(crypto::PublicKey, crypto::SecretKey)> {+pub(crate) fn derive_kit_auth_keypair(+ kit_secret: &[u8],+) -> Result<(crypto::PublicKey, crypto::SecretKey)> {let kit_key = crypto::Key::try_from_slice(kit_secret)?;let seed = kdf::derive_subkey(&kit_key, 32, 2, b"lgkauth1").map_err(Error::from)?;- let sk = crypto::SecretKey::from_seed(seed.as_ref())?;- Ok((sk.public_key(), sk))-}--fn decrypt_challenge(- auth_public_key: &crypto::PublicKey,- auth_secret_key: &crypto::SecretKey,- encrypted_challenge_b64: &str,-) -> Result<String> {- let encrypted_challenge = b64::decode(encrypted_challenge_b64)?;- let plaintext = sealed::open(&encrypted_challenge, auth_public_key, auth_secret_key)?;- String::from_utf8(plaintext).map_err(|error| {- Error::InvalidInput(format!("legacy kit challenge was not valid UTF-8: {error}"))- })-}--fn decrypt_master_key_with_recovery_key(- key_attributes: &KeyAttributes,- recovery_key: &[u8],-) -> Result<SecretVec> {- let encrypted_master_key = key_attributes- .master_key_encrypted_with_recovery_key- .as_ref()- .ok_or_else(|| {- Error::InvalidInput(- "target key attributes missing masterKeyEncryptedWithRecoveryKey".into(),- )- })?;- let master_key_nonce = key_attributes- .master_key_decryption_nonce- .as_ref()- .ok_or_else(|| {- Error::InvalidInput("target key attributes missing masterKeyDecryptionNonce".into())- })?;- let encrypted_master_key = b64::decode(encrypted_master_key)?;- let master_key_nonce = b64::decode(master_key_nonce)?;- secretbox::decrypt(- &encrypted_master_key,- &crypto::Nonce::try_from_slice(&master_key_nonce)?,- &crypto::Key::try_from_slice(recovery_key)?,- )- .map(SecretVec::new)- .map_err(Into::into)-}--fn password_reset_setup_request(- srp_user_id: &str,- login_key: &[u8],-) -> Result<(SrpSession, LegacyKitSetupSrpRequest)> {- let generated_srp = auth::generate_srp_setup_with_login_key(login_key, srp_user_id)?;- let srp_session = SrpSession::new(- srp_user_id,- &generated_srp.srp_salt,- &generated_srp.login_sub_key,- )?;- let srp_a = b64::encode(&srp_session.public_a());- Ok((- srp_session,- LegacyKitSetupSrpRequest {- srp_user_id: srp_user_id.to_string(),- srp_salt: b64::encode(&generated_srp.srp_salt),- srp_verifier: b64::encode(&generated_srp.srp_verifier),- srp_a,- },- ))-}--fn srp_session_m1(- srp_session: &mut SrpSession,- init_response: &LegacyKitSetupSrpResponse,-) -> Result<String> {- let server_b = b64::decode(&init_response.srp_b)?;- let client_m1 = srp_session.compute_m1(&server_b)?;- Ok(b64::encode(&client_m1))+ let secret_key = crypto::SecretKey::from_seed(seed.as_ref())?;+ Ok((secret_key.public_key(), secret_key))}diff --git a/rust/crates/legacy/src/kit_models.rs b/rust/crates/legacy/src/kit/models.rssimilarity index 100%rename from rust/crates/legacy/src/kit_models.rsrename to rust/crates/legacy/src/kit/models.rsdiff --git a/rust/crates/legacy/src/kit/recovery.rs b/rust/crates/legacy/src/kit/recovery.rsnew file mode 100644index 0000000000..93819dac31--- /dev/null+++ b/rust/crates/legacy/src/kit/recovery.rs@@ -0,0 +1,410 @@+use std::sync::Arc;++use ente_accounts::auth::{self, KeyAttributes, SrpSession};+use ente_core::b64;+use ente_core::crypto::{self, SecretString, SecretVec, sealed, secretbox};+use ente_core::http::{Api, ApiConfig, Http, Response};+use serde::{Deserialize, Serialize};+use uuid::Uuid;++use super::{+ LegacyKitRecoveryBundle, LegacyKitRecoverySession, LegacyKitShare, derive_kit_auth_keypair,+ derive_kit_encryption_key, reconstruct_secret_2_of_3, used_part_indexes,+};+use crate::{Error, Result};++pub struct LegacyKitRecoveryClient {+ api: Arc<Api>,+}++pub struct LegacyKitRecoveryHandle {+ api: Arc<Api>,+ session: LegacyKitRecoverySession,+ session_token: SecretString,+ kit_secret: SecretVec,+}++impl LegacyKitRecoveryClient {+ pub fn new(base_url: impl Into<String>) -> Result<Self> {+ Self::new_with_headers(+ base_url,+ None,+ None,+ Some("ente-rust-legacy-kit".to_string()),+ )+ }++ pub fn new_with_headers(+ base_url: impl Into<String>,+ client_package: Option<String>,+ client_version: Option<String>,+ user_agent: Option<String>,+ ) -> Result<Self> {+ let api = Api::new(+ Http::new()?,+ ApiConfig {+ origin: base_url.into(),+ client_package,+ client_version,+ user_agent,+ auth: None,+ },+ );+ Ok(Self { api: Arc::new(api) })+ }++ pub fn reconstruct_secret(shares: &[LegacyKitShare]) -> Result<SecretVec> {+ reconstruct_secret_2_of_3(shares)+ }++ pub async fn open_from_shares(+ &self,+ shares: &[LegacyKitShare],+ email: Option<&str>,+ ) -> Result<LegacyKitRecoveryHandle> {+ let first_share = shares.first().ok_or_else(|| {+ Error::InvalidInput("at least two legacy kit shares are required".into())+ })?;+ let response = self+ .api+ .post("/legacy-kits/recovery/challenge")+ .json(&LegacyKitChallengeRequest {+ kit_id: first_share.kit_id.clone(),+ })+ .send()+ .await?;+ let challenge = active_kit_response(response)?+ .json::<LegacyKitChallengeResponse>()+ .await?;+ self.open_from_encrypted_challenge(shares, &challenge.encrypted_challenge, email)+ .await+ }++ pub async fn open_from_encrypted_challenge(+ &self,+ shares: &[LegacyKitShare],+ encrypted_challenge: &str,+ email: Option<&str>,+ ) -> Result<LegacyKitRecoveryHandle> {+ let kit_secret = reconstruct_secret_2_of_3(shares)?;+ let first_share = shares.first().ok_or_else(|| {+ Error::InvalidInput("at least two legacy kit shares are required".into())+ })?;+ self.open(+ first_share,+ kit_secret,+ encrypted_challenge,+ Some(used_part_indexes(shares)?),+ email.map(ToOwned::to_owned),+ )+ .await+ }++ async fn open(+ &self,+ first_share: &LegacyKitShare,+ kit_secret: SecretVec,+ encrypted_challenge: &str,+ used_part_indexes: Option<Vec<u8>>,+ email: Option<String>,+ ) -> Result<LegacyKitRecoveryHandle> {+ let (auth_public_key, auth_secret_key) = derive_kit_auth_keypair(&kit_secret)?;+ let challenge = decrypt_challenge(&auth_public_key, &auth_secret_key, encrypted_challenge)?;+ let response = self+ .api+ .post("/legacy-kits/recovery/open")+ .json(&LegacyKitOpenRecoveryRequest {+ kit_id: first_share.kit_id.clone(),+ challenge,+ used_part_indexes,+ email,+ })+ .send()+ .await?;+ let response = active_kit_response(response)?+ .json::<LegacyKitOpenRecoveryResponse>()+ .await?;+ Ok(LegacyKitRecoveryHandle {+ api: Arc::clone(&self.api),+ session: response.session,+ session_token: SecretString::new(response.session_token),+ kit_secret,+ })+ }+}++impl LegacyKitRecoveryHandle {+ pub fn session(&self) -> &LegacyKitRecoverySession {+ &self.session+ }++ pub async fn refresh_session(&self) -> Result<LegacyKitRecoverySession> {+ let response = self+ .api+ .post("/legacy-kits/recovery/session")+ .json(&self.session_request())+ .send()+ .await?;+ Ok(response.error_for_status()?.json().await?)+ }++ pub async fn recovery_bundle(&self) -> Result<LegacyKitRecoveryBundle> {+ let response = self+ .api+ .post("/legacy-kits/recovery/info")+ .json(&self.session_request())+ .send()+ .await?+ .error_for_status()?+ .json::<LegacyKitRecoveryInfoResponse>()+ .await?;+ let encryption_key = derive_kit_encryption_key(&self.kit_secret)?;+ let encrypted_recovery_blob = b64::decode(&response.encrypted_recovery_blob)?;+ let recovery_key = secretbox::decrypt_combined(+ &encrypted_recovery_blob,+ &crypto::Key::try_from_slice(&encryption_key)?,+ )?;+ Ok(LegacyKitRecoveryBundle {+ recovery_key: SecretVec::new(recovery_key),+ user_key_attributes: response.user_key_attr,+ })+ }++ pub async fn change_password(&self, new_password: &str) -> Result<()> {+ let bundle = self.recovery_bundle().await?;+ let master_key = decrypt_master_key(&bundle.user_key_attributes, &bundle.recovery_key)?;+ let (updated_key_attrs, login_key) = auth::generate_key_attributes_for_new_password(+ &master_key,+ &bundle.user_key_attributes,+ new_password,+ )?;+ let srp_user_id = Uuid::new_v4().to_string();+ let (mut srp_session, setup_request) = setup_srp(&srp_user_id, &login_key)?;+ let init_response = self+ .api+ .post("/legacy-kits/recovery/init-change-password")+ .json(&LegacyKitInitChangePasswordRequest {+ session_id: self.session.id.clone(),+ session_token: self.session_token.as_ref().to_owned(),+ setup_srp_request: setup_request,+ })+ .send()+ .await?+ .error_for_status()?+ .json::<LegacyKitSetupSrpResponse>()+ .await?;+ let srp_m1 = srp_m1(&mut srp_session, &init_response)?;+ let change_response = self+ .api+ .post("/legacy-kits/recovery/change-password")+ .json(&LegacyKitChangePasswordRequest {+ session_id: self.session.id.clone(),+ session_token: self.session_token.as_ref().to_owned(),+ update_srp_and_keys_request: LegacyKitUpdateSrpAndKeysRequest {+ setup_id: init_response.setup_id,+ srp_m1,+ updated_key_attr: LegacyKitUpdatedKeyAttr {+ kek_salt: updated_key_attrs.kek_salt,+ encrypted_key: updated_key_attrs.encrypted_key,+ key_decryption_nonce: updated_key_attrs.key_decryption_nonce,+ mem_limit: updated_key_attrs.mem_limit,+ ops_limit: updated_key_attrs.ops_limit,+ },+ },+ })+ .send()+ .await?+ .error_for_status()?+ .json::<LegacyKitChangePasswordResponse>()+ .await?;++ srp_session.verify_m2(&b64::decode(&change_response.srp_m2)?)?;+ Ok(())+ }++ fn session_request(&self) -> LegacyKitSessionRequest {+ LegacyKitSessionRequest {+ session_id: self.session.id.clone(),+ session_token: self.session_token.as_ref().to_owned(),+ }+ }+}++fn active_kit_response(response: Response) -> Result<Response> {+ if response.status() == 404 {+ Err(Error::LegacyKitInactive)+ } else {+ Ok(response.error_for_status()?)+ }+}++fn decrypt_challenge(+ public_key: &crypto::PublicKey,+ secret_key: &crypto::SecretKey,+ encrypted_challenge_b64: &str,+) -> Result<String> {+ let encrypted_challenge = b64::decode(encrypted_challenge_b64)?;+ let plaintext = sealed::open(&encrypted_challenge, public_key, secret_key)?;+ String::from_utf8(plaintext).map_err(|error| {+ Error::InvalidInput(format!("legacy kit challenge was not valid UTF-8: {error}"))+ })+}++fn decrypt_master_key(key_attributes: &KeyAttributes, recovery_key: &[u8]) -> Result<SecretVec> {+ let encrypted_master_key = key_attributes+ .master_key_encrypted_with_recovery_key+ .as_ref()+ .ok_or_else(|| {+ Error::InvalidInput(+ "target key attributes missing masterKeyEncryptedWithRecoveryKey".into(),+ )+ })?;+ let nonce = key_attributes+ .master_key_decryption_nonce+ .as_ref()+ .ok_or_else(|| {+ Error::InvalidInput("target key attributes missing masterKeyDecryptionNonce".into())+ })?;+ secretbox::decrypt(+ &b64::decode(encrypted_master_key)?,+ &crypto::Nonce::try_from_slice(&b64::decode(nonce)?)?,+ &crypto::Key::try_from_slice(recovery_key)?,+ )+ .map(SecretVec::new)+ .map_err(Into::into)+}++fn setup_srp(user_id: &str, login_key: &[u8]) -> Result<(SrpSession, LegacyKitSetupSrpRequest)> {+ let generated = auth::generate_srp_setup_with_login_key(login_key, user_id)?;+ let session = SrpSession::new(user_id, &generated.srp_salt, &generated.login_sub_key)?;+ let srp_a = b64::encode(&session.public_a());+ Ok((+ session,+ LegacyKitSetupSrpRequest {+ srp_user_id: user_id.to_string(),+ srp_salt: b64::encode(&generated.srp_salt),+ srp_verifier: b64::encode(&generated.srp_verifier),+ srp_a,+ },+ ))+}++fn srp_m1(session: &mut SrpSession, response: &LegacyKitSetupSrpResponse) -> Result<String> {+ Ok(b64::encode(+ &session.compute_m1(&b64::decode(&response.srp_b)?)?,+ ))+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitChallengeRequest {+ #[serde(rename = "kitID")]+ kit_id: String,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitChallengeResponse {+ encrypted_challenge: String,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitOpenRecoveryRequest {+ #[serde(rename = "kitID")]+ kit_id: String,+ challenge: String,+ used_part_indexes: Option<Vec<u8>>,+ email: Option<String>,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitOpenRecoveryResponse {+ session: LegacyKitRecoverySession,+ session_token: String,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitSessionRequest {+ #[serde(rename = "sessionID")]+ session_id: String,+ session_token: String,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitRecoveryInfoResponse {+ encrypted_recovery_blob: String,+ #[serde(rename = "userKeyAttr")]+ user_key_attr: KeyAttributes,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitSetupSrpRequest {+ #[serde(rename = "srpUserID")]+ srp_user_id: String,+ srp_salt: String,+ srp_verifier: String,+ #[serde(rename = "srpA")]+ srp_a: String,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitInitChangePasswordRequest {+ #[serde(rename = "sessionID")]+ session_id: String,+ session_token: String,+ #[serde(rename = "setupSRPRequest")]+ setup_srp_request: LegacyKitSetupSrpRequest,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitSetupSrpResponse {+ #[serde(rename = "setupID")]+ setup_id: String,+ #[serde(rename = "srpB")]+ srp_b: String,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitUpdatedKeyAttr {+ kek_salt: String,+ encrypted_key: String,+ key_decryption_nonce: String,+ mem_limit: u32,+ ops_limit: u32,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitUpdateSrpAndKeysRequest {+ #[serde(rename = "setupID")]+ setup_id: String,+ #[serde(rename = "srpM1")]+ srp_m1: String,+ #[serde(rename = "updatedKeyAttr")]+ updated_key_attr: LegacyKitUpdatedKeyAttr,+}++#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitChangePasswordRequest {+ #[serde(rename = "sessionID")]+ session_id: String,+ session_token: String,+ #[serde(rename = "updateSrpAndKeysRequest")]+ update_srp_and_keys_request: LegacyKitUpdateSrpAndKeysRequest,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct LegacyKitChangePasswordResponse {+ #[serde(rename = "srpM2")]+ srp_m2: String,+}diff --git a/rust/crates/legacy/src/kit/shares.rs b/rust/crates/legacy/src/kit/shares.rsindex a08e24fdc2..c0c4dd7db7 100644--- a/rust/crates/legacy/src/kit/shares.rs+++ b/rust/crates/legacy/src/kit/shares.rs@@ -2,12 +2,11 @@ use ente_core::b64;use ente_core::crypto::{self, SecretVec};use sha2::{Digest, Sha256};-use crate::{- Error, Result,- kit_models::{LEGACY_KIT_PAYLOAD_VERSION, LegacyKitShare, LegacyKitVariant},-};+use crate::{Error, Result};-pub(super) fn checksum(+use super::models::{LEGACY_KIT_PAYLOAD_VERSION, LegacyKitShare, LegacyKitVariant};++pub(crate) fn checksum(payload_version: u8,variant: LegacyKitVariant,kit_id: &str,@@ -21,7 +20,7 @@ pub(super) fn checksum(b64::encode(&hash[..8])}-pub(super) fn split_secret_2_of_3(secret: &[u8]) -> Result<Vec<Vec<u8>>> {+pub(crate) fn split_secret_2_of_3(secret: &[u8]) -> Result<Vec<Vec<u8>>> {if secret.len() != 32 {return Err(Error::InvalidInput("legacy kit secret must be 32 bytes".into(),@@ -41,7 +40,7 @@ pub(super) fn split_secret_2_of_3(secret: &[u8]) -> Result<Vec<Vec<u8>>> {Ok(shares)}-pub(super) fn reconstruct_secret_2_of_3(shares: &[LegacyKitShare]) -> Result<SecretVec> {+pub(crate) fn reconstruct_secret_2_of_3(shares: &[LegacyKitShare]) -> Result<SecretVec> {if shares.len() < 2 {return Err(Error::InvalidInput("at least two legacy kit shares are required".into(),@@ -107,7 +106,7 @@ pub(super) fn reconstruct_secret_2_of_3(shares: &[LegacyKitShare]) -> Result<SecOk(SecretVec::new(secret))}-pub(super) fn used_part_indexes(shares: &[LegacyKitShare]) -> Result<Vec<u8>> {+pub(crate) fn used_part_indexes(shares: &[LegacyKitShare]) -> Result<Vec<u8>> {let first = shares.first().ok_or_else(|| Error::InvalidInput("at least two legacy kit shares are required".into()))?;diff --git a/rust/crates/legacy/src/kit_transport.rs b/rust/crates/legacy/src/kit_transport.rsdeleted file mode 100644index 20bf80a907..0000000000--- a/rust/crates/legacy/src/kit_transport.rs+++ /dev/null@@ -1,189 +0,0 @@-use ente_accounts::auth::KeyAttributes;-use serde::{Deserialize, Serialize};--use crate::kit_models::{- LegacyKitOwnerRecoverySession, LegacyKitRecoverySession, LegacyKitVariant,-};--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct CreateLegacyKitRequest {- pub id: String,- pub variant: LegacyKitVariant,- pub notice_period_in_hours: i32,- pub encrypted_recovery_blob: String,- pub auth_public_key: String,- pub encrypted_owner_blob: String,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitRecordResponse {- pub id: String,- pub variant: LegacyKitVariant,- pub notice_period_in_hours: i32,- pub legacy_url: String,- pub encrypted_owner_blob: String,- pub created_at: i64,- pub updated_at: i64,- pub active_recovery_session: Option<LegacyKitRecoverySession>,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct ListLegacyKitsResponse {- pub kits: Vec<LegacyKitRecordResponse>,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitDownloadContentResponse {- pub id: String,- pub variant: LegacyKitVariant,- pub encrypted_owner_blob: String,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitOwnerActionRequest {- #[serde(rename = "kitID")]- pub kit_id: String,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitUpdateRecoveryNoticeRequest {- #[serde(rename = "kitID")]- pub kit_id: String,- pub notice_period_in_hours: i32,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitChallengeRequest {- #[serde(rename = "kitID")]- pub kit_id: String,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitChallengeResponse {- pub encrypted_challenge: String,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitOpenRecoveryRequest {- #[serde(rename = "kitID")]- pub kit_id: String,- pub challenge: String,- pub used_part_indexes: Option<Vec<u8>>,- pub email: Option<String>,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitOpenRecoveryResponse {- pub session: LegacyKitRecoverySession,- pub session_token: String,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitOwnerRecoverySessionResponse {- pub session: Option<LegacyKitRecoverySession>,- pub initiators: Vec<crate::kit_models::LegacyKitRecoveryInitiator>,-}--impl From<LegacyKitOwnerRecoverySessionResponse> for LegacyKitOwnerRecoverySession {- fn from(value: LegacyKitOwnerRecoverySessionResponse) -> Self {- Self {- session: value.session,- initiators: value.initiators,- }- }-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitSessionRequest {- #[serde(rename = "sessionID")]- pub session_id: String,- pub session_token: String,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitRecoveryInfoResponse {- pub encrypted_recovery_blob: String,- #[serde(rename = "userKeyAttr")]- pub user_key_attr: KeyAttributes,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitSetupSrpRequest {- #[serde(rename = "srpUserID")]- pub srp_user_id: String,- pub srp_salt: String,- pub srp_verifier: String,- #[serde(rename = "srpA")]- pub srp_a: String,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitInitChangePasswordRequest {- #[serde(rename = "sessionID")]- pub session_id: String,- pub session_token: String,- #[serde(rename = "setupSRPRequest")]- pub setup_srp_request: LegacyKitSetupSrpRequest,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitSetupSrpResponse {- #[serde(rename = "setupID")]- pub setup_id: String,- #[serde(rename = "srpB")]- pub srp_b: String,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitUpdatedKeyAttr {- pub kek_salt: String,- pub encrypted_key: String,- pub key_decryption_nonce: String,- pub mem_limit: u32,- pub ops_limit: u32,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitUpdateSrpAndKeysRequest {- #[serde(rename = "setupID")]- pub setup_id: String,- #[serde(rename = "srpM1")]- pub srp_m1: String,- #[serde(rename = "updatedKeyAttr")]- pub updated_key_attr: LegacyKitUpdatedKeyAttr,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitChangePasswordRequest {- #[serde(rename = "sessionID")]- pub session_id: String,- pub session_token: String,- #[serde(rename = "updateSrpAndKeysRequest")]- pub update_srp_and_keys_request: LegacyKitUpdateSrpAndKeysRequest,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyKitChangePasswordResponse {- #[serde(rename = "srpM2")]- pub srp_m2: String,-}diff --git a/rust/crates/legacy/src/lib.rs b/rust/crates/legacy/src/lib.rsindex 16a89318c9..f0e0bac854 100644--- a/rust/crates/legacy/src/lib.rs+++ b/rust/crates/legacy/src/lib.rs@@ -1,21 +1,15 @@mod client;mod error;mod kit;-mod kit_models;-mod kit_transport;-mod models;-mod transport;-pub use client::LegacyClient;+pub use client::{+ LegacyClient, LegacyContactRecord, LegacyContactState, LegacyInfo, LegacyRecoveryBundle,+ LegacyRecoverySession, LegacyRecoveryStatus, LegacyUser,+};pub use error::{Error, Result};-pub use kit::{LegacyKitRecoveryClient, LegacyKitRecoveryHandle};-pub use kit_models::{+pub use kit::{LEGACY_KIT_PAYLOAD_VERSION, LegacyKit, LegacyKitCreateResult, LegacyKitMetadata,- LegacyKitOwnerRecoverySession, LegacyKitPart, LegacyKitRecoveryBundle,- LegacyKitRecoveryInitiator, LegacyKitRecoverySession, LegacyKitRecoveryStatus, LegacyKitShare,- LegacyKitVariant,-};-pub use models::{- LegacyContactRecord, LegacyContactState, LegacyInfo, LegacyRecoveryBundle,- LegacyRecoverySession, LegacyRecoveryStatus, LegacyUser,+ LegacyKitOwnerRecoverySession, LegacyKitPart, LegacyKitRecoveryBundle, LegacyKitRecoveryClient,+ LegacyKitRecoveryHandle, LegacyKitRecoveryInitiator, LegacyKitRecoverySession,+ LegacyKitRecoveryStatus, LegacyKitShare, LegacyKitVariant,};diff --git a/rust/crates/legacy/src/models.rs b/rust/crates/legacy/src/models.rsdeleted file mode 100644index 7661a0dc17..0000000000--- a/rust/crates/legacy/src/models.rs+++ /dev/null@@ -1,68 +0,0 @@-use ente_accounts::auth::KeyAttributes;-use ente_core::crypto::SecretVec;-use serde::{Deserialize, Serialize};--#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]-pub enum LegacyContactState {- Invited,- Revoked,- Accepted,- ContactLeft,- ContactDenied,-}--#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]-pub enum LegacyRecoveryStatus {- Initiated,- Waiting,- Rejected,- Recovered,- Stopped,- Ready,-}--#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]-#[serde(rename_all = "camelCase")]-pub struct LegacyUser {- pub id: i64,- pub email: String,-}--#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]-#[serde(rename_all = "camelCase")]-pub struct LegacyContactRecord {- pub user: LegacyUser,- pub emergency_contact: LegacyUser,- pub state: LegacyContactState,- pub recovery_notice_in_days: i32,-}--#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]-#[serde(rename_all = "camelCase")]-pub struct LegacyRecoverySession {- pub id: String,- pub user: LegacyUser,- pub emergency_contact: LegacyUser,- pub status: LegacyRecoveryStatus,- pub wait_till: i64,- pub created_at: i64,-}--#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]-#[serde(rename_all = "camelCase")]-pub struct LegacyInfo {- pub contacts: Vec<LegacyContactRecord>,- #[serde(rename = "recoverSessions")]- pub recover_sessions: Vec<LegacyRecoverySession>,- pub others_emergency_contact: Vec<LegacyContactRecord>,- #[serde(rename = "othersRecoverySession")]- pub others_recovery_session: Vec<LegacyRecoverySession>,-}--#[derive(Debug)]-pub struct LegacyRecoveryBundle {- pub recovery_key: SecretVec,- pub user_key_attributes: KeyAttributes,-}diff --git a/rust/crates/legacy/src/transport.rs b/rust/crates/legacy/src/transport.rsdeleted file mode 100644index 209e271ad4..0000000000--- a/rust/crates/legacy/src/transport.rs+++ /dev/null@@ -1,129 +0,0 @@-use ente_accounts::auth::KeyAttributes;-use serde::{Deserialize, Serialize};--use crate::models::LegacyContactState;--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyPublicKeyResponse {- pub public_key: String,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyAddContactRequest {- pub email: String,- pub encrypted_key: String,- pub recovery_notice_in_days: Option<i32>,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyUpdateContactRequest {- #[serde(rename = "userID")]- pub user_id: i64,- #[serde(rename = "emergencyContactID")]- pub emergency_contact_id: i64,- pub state: LegacyContactState,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyUpdateRecoveryNoticeRequest {- #[serde(rename = "emergencyContactID")]- pub emergency_contact_id: i64,- pub recovery_notice_in_days: i32,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyContactIdentifier {- #[serde(rename = "userID")]- pub user_id: i64,- #[serde(rename = "emergencyContactID")]- pub emergency_contact_id: i64,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyRecoveryIdentifier {- pub id: String,- #[serde(rename = "userID")]- pub user_id: i64,- #[serde(rename = "emergencyContactID")]- pub emergency_contact_id: i64,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyRecoveryInfoResponse {- pub encrypted_key: String,- #[serde(rename = "userKeyAttr")]- pub user_key_attr: KeyAttributes,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacySetupSrpRequest {- #[serde(rename = "srpUserID")]- pub srp_user_id: String,- pub srp_salt: String,- pub srp_verifier: String,- #[serde(rename = "srpA")]- pub srp_a: String,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyInitChangePasswordRequest {- #[serde(rename = "recoveryID")]- pub recovery_id: String,- #[serde(rename = "setupSRPRequest")]- pub setup_srp_request: LegacySetupSrpRequest,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacySetupSrpResponse {- #[serde(rename = "setupID")]- pub setup_id: String,- #[serde(rename = "srpB")]- pub srp_b: String,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyUpdatedKeyAttr {- pub kek_salt: String,- pub encrypted_key: String,- pub key_decryption_nonce: String,- pub mem_limit: u32,- pub ops_limit: u32,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyUpdateSrpAndKeysRequest {- #[serde(rename = "setupID")]- pub setup_id: String,- #[serde(rename = "srpM1")]- pub srp_m1: String,- #[serde(rename = "updatedKeyAttr")]- pub updated_key_attr: LegacyUpdatedKeyAttr,-}--#[derive(Debug, Clone, Serialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyChangePasswordRequest {- #[serde(rename = "recoveryID")]- pub recovery_id: String,- #[serde(rename = "updateSrpAndKeysRequest")]- pub update_srp_and_keys_request: LegacyUpdateSrpAndKeysRequest,-}--#[derive(Debug, Clone, Deserialize)]-#[serde(rename_all = "camelCase")]-pub struct LegacyChangePasswordResponse {- #[serde(rename = "srpM2")]- pub srp_m2: String,-}