Skip to content

armgit / ente

Public Imported from GitHub
0

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

Clean up Legacy crate structure

Manav Rathid6840228bbe8
diff --git a/rust/crates/legacy/src/client/contact.rs b/rust/crates/legacy/src/client/contact.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
similarity index 92%
rename from rust/crates/legacy/src/kit/owner_blob.rs
rename to rust/crates/legacy/src/client/kit/owner_blob.rs
index 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.rs
new file mode 100644
index 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.rs
similarity index 50%
rename from rust/crates/legacy/src/client.rs
rename to rust/crates/legacy/src/client/recovery.rs
index 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.rs
index 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.rs
similarity index 100%
rename from rust/crates/legacy/src/kit_models.rs
rename to rust/crates/legacy/src/kit/models.rs
diff --git a/rust/crates/legacy/src/kit/recovery.rs b/rust/crates/legacy/src/kit/recovery.rs
new file mode 100644
index 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.rs
index 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<Sec
Ok(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.rs
deleted file mode 100644
index 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.rs
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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,
-}