Skip to content

armgit / ente

Public Imported from GitHub
0

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

Return the base64 crate's error from b64, use b64 everywhere

Manav Rathidb6f6e91c8df
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index f4dda65bf7..56971dab38 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -2290,7 +2290,6 @@ dependencies = [
name = "ente-accounts"
version = "0.0.0"
dependencies = [
- "base64 0.22.1",
"bip39",
"ente-core",
"ente-test-support",
@@ -2325,7 +2324,6 @@ dependencies = [
name = "ente-contacts"
version = "0.0.0"
dependencies = [
- "base64 0.22.1",
"ente-accounts",
"ente-core",
"ente-test-support",
@@ -2486,7 +2484,6 @@ dependencies = [
name = "ente-rs"
version = "0.0.1"
dependencies = [
- "base64 0.22.1",
"chrono",
"clap",
"dialoguer",
@@ -2519,7 +2516,6 @@ dependencies = [
name = "ente-space"
version = "0.0.1"
dependencies = [
- "base64 0.22.1",
"ente-accounts",
"ente-core",
"ente-test-support",
diff --git a/rust/apps/cli/Cargo.toml b/rust/apps/cli/Cargo.toml
index 64ae11bf21..af4a07458b 100644
--- a/rust/apps/cli/Cargo.toml
+++ b/rust/apps/cli/Cargo.toml
@@ -24,7 +24,6 @@ tokio = { version = "1.41", features = ["full"] }
futures = "0.3"
# Cryptography - using ente-core pure Rust implementation
-base64 = "0.22"
zeroize = { version = "1.8", features = ["derive"] }
# Storage
diff --git a/rust/apps/cli/src/auth_flow.rs b/rust/apps/cli/src/auth_flow.rs
index ccebca318b..7265ee8de8 100644
--- a/rust/apps/cli/src/auth_flow.rs
+++ b/rust/apps/cli/src/auth_flow.rs
@@ -5,8 +5,8 @@ use crate::{
error::{Error, Result},
},
};
-use base64::{Engine, engine::general_purpose::URL_SAFE};
+use ente_core::b64;
use ente_core::crypto::SecretVec;
use serde::{Serialize, de::DeserializeOwned};
use std::fmt;
@@ -250,7 +250,7 @@ where
.map_err(Error::from)?,
)?;
self.app_client
- .set_token(&URL_SAFE.encode(&account.secrets.token));
+ .set_token(&b64::encode_url_safe(&account.secrets.token));
Ok(account)
}
@@ -422,7 +422,7 @@ mod tests {
let email = "[email protected]";
let encoded_email = urlencoding::encode(email).into_owned();
let signup_token_bytes = b"signup-session-token";
- let signup_token = URL_SAFE.encode(signup_token_bytes);
+ let signup_token = b64::encode_url_safe(signup_token_bytes);
let signup_state = Arc::new(Mutex::new(MockSignupState::default()));
let mut server = Server::new_async().await;
@@ -495,15 +495,9 @@ mod tests {
.with_body_from_request(move |request| {
let payload: SetupSrpPayload = parse_request_body(request);
let srp_user_id = Uuid::parse_str(&payload.srp_user_id).unwrap();
- let srp_salt = base64::engine::general_purpose::STANDARD
- .decode(&payload.srp_salt)
- .unwrap();
- let srp_verifier = base64::engine::general_purpose::STANDARD
- .decode(&payload.srp_verifier)
- .unwrap();
- let srp_a = base64::engine::general_purpose::STANDARD
- .decode(&payload.srp_a)
- .unwrap();
+ let srp_salt = b64::decode(&payload.srp_salt).unwrap();
+ let srp_verifier = b64::decode(&payload.srp_verifier).unwrap();
+ let srp_a = b64::decode(&payload.srp_a).unwrap();
let server = ServerG4096::<Sha256>::new();
let b_private = [0x33u8; 64];
let srp_b = pad_left(
@@ -552,7 +546,7 @@ mod tests {
serde_json::json!({
"setupID": setup_id,
- "srpB": base64::engine::general_purpose::STANDARD.encode(&srp_b),
+ "srpB": b64::encode(&srp_b),
})
.to_string()
.into_bytes()
@@ -569,9 +563,7 @@ mod tests {
.with_body_from_request(move |request| {
let payload: CompleteSrpSetupPayload = parse_request_body(request);
let setup_id = Uuid::parse_str(&payload.setup_id).unwrap();
- let srp_m1 = base64::engine::general_purpose::STANDARD
- .decode(&payload.srp_m1)
- .unwrap();
+ let srp_m1 = b64::decode(&payload.srp_m1).unwrap();
let mut state = state.lock().unwrap();
assert_eq!(state.pending_setup_id, Some(setup_id));
@@ -579,8 +571,7 @@ mod tests {
serde_json::json!({
"setupID": setup_id,
- "srpM2": base64::engine::general_purpose::STANDARD
- .encode(state.pending_server_proof.take().unwrap()),
+ "srpM2": b64::encode(&state.pending_server_proof.take().unwrap()),
})
.to_string()
.into_bytes()
diff --git a/rust/apps/cli/src/commands/account.rs b/rust/apps/cli/src/commands/account.rs
index f07abb96e2..ec3cafe9d7 100644
--- a/rust/apps/cli/src/commands/account.rs
+++ b/rust/apps/cli/src/commands/account.rs
@@ -7,13 +7,13 @@ use crate::{
},
storage::Storage,
};
-use base64::Engine;
use dialoguer::{Input, Password, Select};
use ente_accounts::{
AccountsClient, AccountsClientConfig, AuthFlow, AuthFlowUi, AuthenticatedAccount,
CreateAccountParams, LoginParams, OtpPurpose, SecondFactorMethod, SetupTwoFactorParams,
TotpPurpose,
};
+use ente_core::b64;
use ente_core::crypto::SecretVec;
use ente_core::urls::PRODUCTION_API_ORIGIN;
use std::{path::PathBuf, str::FromStr};
@@ -427,7 +427,7 @@ async fn enable_two_factor(
.ok_or_else(|| Error::NotFound(format!("Secrets not found for account {email}")))?;
let client = new_accounts_client(&account.endpoint, app)?;
- let token = base64::engine::general_purpose::URL_SAFE.encode(&secrets.token);
+ let token = b64::encode_url_safe(&secrets.token);
client.set_auth_token(Some(token));
let mut ui = DialoguerAuthFlowUi::new(None, totp_code, Some(SecondFactorMethod::Totp));
@@ -481,7 +481,7 @@ async fn get_token(storage: &Storage, email: &str, app_str: &str) -> Result<()>
.get_secrets(account.user_id, account.app)?
.ok_or_else(|| Error::NotFound(format!("Secrets not found for account {email}")))?;
- let token = base64::engine::general_purpose::URL_SAFE.encode(&secrets.token);
+ let token = b64::encode_url_safe(&secrets.token);
println!("{token}");
Ok(())
diff --git a/rust/apps/cli/src/commands/export.rs b/rust/apps/cli/src/commands/export.rs
index 683be9918b..d708aabe22 100644
--- a/rust/apps/cli/src/commands/export.rs
+++ b/rust/apps/cli/src/commands/export.rs
@@ -10,7 +10,7 @@ use crate::models::{
};
use crate::storage::Storage;
use crate::sync::SyncEngine;
-use base64::Engine;
+use ente_core::b64;
use ente_core::crypto;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
@@ -201,7 +201,7 @@ async fn sync_account_before_export(storage: &Storage, account: &Account) -> Res
let api_client = AppClient::new(Some(account.endpoint.clone()), account.app)?;
// Store token for this account
- let token = base64::engine::general_purpose::URL_SAFE.encode(&secrets.token);
+ let token = b64::encode_url_safe(&secrets.token);
api_client.set_token(&token);
// Get the database path to create a new Storage instance
@@ -264,7 +264,7 @@ async fn export_account(storage: &Storage, account: &Account, filter: &ExportFil
// Store token for this account
// Token is stored as raw bytes from sealed_box_open
// The Go CLI encodes it as base64 URL-encoded string WITH padding for the API
- let token = base64::engine::general_purpose::URL_SAFE.encode(&secrets.token);
+ let token = b64::encode_url_safe(&secrets.token);
api_client.set_token(&token);
let api = ApiMethods::new(&api_client);
@@ -699,9 +699,7 @@ async fn export_account(storage: &Storage, account: &Account, filter: &ExportFil
let encrypted_data = api.download_file(file.id).await?;
// The file nonce/header is stored separately in the API response
- let file_nonce = match base64::engine::general_purpose::STANDARD
- .decode(&file.file.decryption_header)
- {
+ let file_nonce = match b64::decode(&file.file.decryption_header) {
Ok(nonce) => nonce,
Err(e) => {
log::error!("Failed to decode file nonce for file {}: {}", file.id, e);
@@ -956,10 +954,8 @@ fn decrypt_collection_key(
master_key: &[u8],
_secret_key: &[u8],
) -> Result<Vec<u8>> {
- use base64::engine::general_purpose::STANDARD as BASE64;
-
- let encrypted_bytes = BASE64.decode(encrypted_key)?;
- let nonce_bytes = BASE64.decode(nonce)?;
+ let encrypted_bytes = b64::decode(encrypted_key)?;
+ let nonce_bytes = b64::decode(nonce)?;
// Collection keys are encrypted with secret_box (XSalsa20-Poly1305) using master key
Ok(crypto::secretbox::decrypt(
@@ -975,9 +971,7 @@ fn decrypt_shared_collection_key(
public_key: &[u8],
secret_key: &[u8],
) -> Result<Vec<u8>> {
- use base64::engine::general_purpose::STANDARD as BASE64;
-
- let encrypted_bytes = BASE64.decode(encrypted_key)?;
+ let encrypted_bytes = b64::decode(encrypted_key)?;
// Shared collection keys are encrypted with sealed_box (crypto_box_seal)
// which uses the recipient's public key and an ephemeral keypair
@@ -994,10 +988,8 @@ fn decrypt_collection_name(
nonce: &str,
collection_key: &[u8],
) -> Result<String> {
- use base64::engine::general_purpose::STANDARD as BASE64;
-
- let encrypted_bytes = BASE64.decode(encrypted_name)?;
- let nonce_bytes = BASE64.decode(nonce)?;
+ let encrypted_bytes = b64::decode(encrypted_name)?;
+ let nonce_bytes = b64::decode(nonce)?;
// Collection names are encrypted with secret_box using the collection key
let decrypted = crypto::secretbox::decrypt(
@@ -1013,10 +1005,8 @@ fn decrypt_collection_name(
/// Decrypt a file key using the collection key
fn decrypt_file_key(encrypted_key: &str, nonce: &str, collection_key: &[u8]) -> Result<Vec<u8>> {
- use base64::engine::general_purpose::STANDARD as BASE64;
-
- let encrypted_bytes = BASE64.decode(encrypted_key)?;
- let nonce_bytes = BASE64.decode(nonce)?;
+ let encrypted_bytes = b64::decode(encrypted_key)?;
+ let nonce_bytes = b64::decode(nonce)?;
// File keys are encrypted with secret_box (XSalsa20-Poly1305) using collection key
Ok(crypto::secretbox::decrypt(
@@ -1082,16 +1072,14 @@ fn decrypt_file_metadata(
file: &crate::api::models::File,
file_key: &[u8],
) -> Result<Option<FileMetadata>> {
- use base64::engine::general_purpose::STANDARD as BASE64;
-
// Check if metadata exists
if file.metadata.encrypted_data.is_none() || file.metadata.decryption_header.is_empty() {
return Ok(None);
}
let encrypted_data = file.metadata.encrypted_data.as_ref().unwrap();
- let encrypted_bytes = BASE64.decode(encrypted_data)?;
- let header_bytes = BASE64.decode(&file.metadata.decryption_header)?;
+ let encrypted_bytes = b64::decode(encrypted_data)?;
+ let header_bytes = b64::decode(&file.metadata.decryption_header)?;
// Decrypt the metadata using streaming XChaCha20-Poly1305
let decrypted = crypto::blob::decrypt(
@@ -1110,15 +1098,13 @@ fn decrypt_magic_metadata(
magic_metadata: &crate::api::models::MagicMetadata,
file_key: &[u8],
) -> Result<Option<serde_json::Value>> {
- use base64::engine::general_purpose::STANDARD as BASE64;
-
// Check if data exists
if magic_metadata.data.is_empty() || magic_metadata.header.is_empty() {
return Ok(None);
}
- let encrypted_bytes = BASE64.decode(&magic_metadata.data)?;
- let header_bytes = BASE64.decode(&magic_metadata.header)?;
+ let encrypted_bytes = b64::decode(&magic_metadata.data)?;
+ let header_bytes = b64::decode(&magic_metadata.header)?;
// Decrypt the metadata using streaming XChaCha20-Poly1305
let decrypted = crypto::blob::decrypt(
diff --git a/rust/apps/cli/src/commands/sync.rs b/rust/apps/cli/src/commands/sync.rs
index 70d6531e36..a3f4742a6f 100644
--- a/rust/apps/cli/src/commands/sync.rs
+++ b/rust/apps/cli/src/commands/sync.rs
@@ -4,7 +4,7 @@ use crate::api::methods::ApiMethods;
use crate::models::{account::Account, metadata::FileMetadata};
use crate::storage::Storage;
use crate::sync::{SyncEngine, SyncStats, download::DownloadManager};
-use base64::Engine;
+use ente_core::b64;
use ente_core::crypto;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
@@ -76,7 +76,7 @@ async fn sync_account(
let api_client = AppClient::new(Some(account.endpoint.clone()), account.app)?;
// Store token for this account
- let token = base64::engine::general_purpose::URL_SAFE.encode(&secrets.token);
+ let token = b64::encode_url_safe(&secrets.token);
api_client.set_token(&token);
// Clear sync state if full sync requested
@@ -235,7 +235,6 @@ fn decrypt_collection_keys(
master_key: &[u8],
_secret_key: &[u8],
) -> Result<HashMap<i64, Vec<u8>>> {
- use base64::engine::general_purpose::STANDARD as BASE64;
let mut keys = HashMap::new();
@@ -245,8 +244,8 @@ fn decrypt_collection_keys(
}
// Decrypt collection key
- let encrypted_bytes = BASE64.decode(&collection.encrypted_key)?;
- let nonce_bytes = BASE64.decode(&collection.key_decryption_nonce)?;
+ let encrypted_bytes = b64::decode(&collection.encrypted_key)?;
+ let nonce_bytes = b64::decode(&collection.key_decryption_nonce)?;
let decrypted = crypto::Nonce::try_from_slice(&nonce_bytes).and_then(|nonce| {
crypto::secretbox::decrypt(
@@ -293,7 +292,6 @@ async fn prepare_download_tasks(
collections: &[crate::api::models::Collection],
download_manager: &DownloadManager,
) -> Result<Vec<(crate::models::file::RemoteFile, PathBuf)>> {
- use base64::engine::general_purpose::STANDARD as BASE64;
use chrono::{TimeZone, Utc};
let mut tasks = Vec::new();
@@ -313,8 +311,8 @@ async fn prepare_download_tasks(
{
// Decrypt file key first
let file_key = {
- let key_bytes = BASE64.decode(&file.encrypted_key)?;
- let nonce = BASE64.decode(&file.key_decryption_nonce)?;
+ let key_bytes = b64::decode(&file.encrypted_key)?;
+ let nonce = b64::decode(&file.key_decryption_nonce)?;
crypto::secretbox::decrypt(
&key_bytes,
&crypto::Nonce::try_from_slice(&nonce)?,
@@ -325,8 +323,8 @@ async fn prepare_download_tasks(
// Decrypt regular metadata
let regular_meta = if !file.metadata.encrypted_data.is_empty() {
if !file.metadata.decryption_header.is_empty() {
- let encrypted_bytes = BASE64.decode(&file.metadata.encrypted_data)?;
- let header_bytes = BASE64.decode(&file.metadata.decryption_header)?;
+ let encrypted_bytes = b64::decode(&file.metadata.encrypted_data)?;
+ let header_bytes = b64::decode(&file.metadata.decryption_header)?;
let decrypted =
crypto::Header::try_from_slice(&header_bytes).and_then(|header| {
@@ -353,8 +351,8 @@ async fn prepare_download_tasks(
// Decrypt public magic metadata if available
let pub_meta = if let Some(ref magic) = file.pub_magic_metadata {
if !magic.data.is_empty() && !magic.header.is_empty() {
- let encrypted_bytes = BASE64.decode(&magic.data)?;
- let header_bytes = BASE64.decode(&magic.header)?;
+ let encrypted_bytes = b64::decode(&magic.data)?;
+ let header_bytes = b64::decode(&magic.header)?;
let decrypted =
crypto::Header::try_from_slice(&header_bytes).and_then(|header| {
diff --git a/rust/apps/cli/src/models/error.rs b/rust/apps/cli/src/models/error.rs
index 6eba3207be..04b6677002 100644
--- a/rust/apps/cli/src/models/error.rs
+++ b/rust/apps/cli/src/models/error.rs
@@ -1,5 +1,5 @@
use ente_accounts::auth;
-use ente_core::crypto;
+use ente_core::{b64, crypto};
use thiserror::Error;
#[derive(Error, Debug)]
@@ -32,7 +32,7 @@ pub enum Error {
Srp(String),
#[error("Base64 decode error: {0}")]
- Base64Decode(#[from] base64::DecodeError),
+ Base64Decode(#[from] b64::DecodeError),
#[error("ZIP error: {0}")]
Zip(#[from] zip::result::ZipError),
@@ -62,7 +62,6 @@ impl From<ente_paste::Error> for Error {
impl From<crypto::Error> for Error {
fn from(err: crypto::Error) -> Self {
match err {
- crypto::Error::Base64Decode(source) => Error::Base64Decode(source),
crypto::Error::Io(source) => Error::Io(source),
other => Error::Crypto(other.to_string()),
}
diff --git a/rust/apps/cli/src/sync/download.rs b/rust/apps/cli/src/sync/download.rs
index 4b92f6e761..5025ed4388 100644
--- a/rust/apps/cli/src/sync/download.rs
+++ b/rust/apps/cli/src/sync/download.rs
@@ -3,7 +3,7 @@ use crate::api::client::AppClient;
use crate::api::methods::ApiMethods;
use crate::live_photo::extract_live_photo;
use crate::models::file::RemoteFile;
-use base64::{Engine, engine::general_purpose::STANDARD as BASE64};
+use ente_core::b64;
use ente_core::crypto;
use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
use std::collections::HashMap;
@@ -250,8 +250,8 @@ impl DownloadManager {
// Decrypt file key using collection key (XSalsa20-Poly1305)
let file_key = {
- let key_bytes = BASE64.decode(&file.encrypted_key)?;
- let nonce = BASE64.decode(&file.key_decryption_nonce)?;
+ let key_bytes = b64::decode(&file.encrypted_key)?;
+ let nonce = b64::decode(&file.key_decryption_nonce)?;
crypto::secretbox::decrypt(
&key_bytes,
&crypto::Nonce::try_from_slice(&nonce)?,
@@ -260,7 +260,7 @@ impl DownloadManager {
};
// Decrypt file data using file key (Streaming XChaCha20-Poly1305)
- let file_nonce = BASE64.decode(&file.file.decryption_header)?;
+ let file_nonce = b64::decode(&file.file.decryption_header)?;
let decrypted = crypto::stream::decrypt_file_data(
encrypted_data,
&crypto::Header::try_from_slice(&file_nonce)?,
diff --git a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs b/rust/apps/ensu/src-tauri/src/commands/chat_db.rs
index 4086c47ed9..fbff917f65 100644
--- a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs
+++ b/rust/apps/ensu/src-tauri/src/commands/chat_db.rs
@@ -47,6 +47,7 @@ impl From<db::Error> for ApiError {
E::InvalidSender(_) => "db_invalid_sender",
E::NotFound { .. } => "db_not_found",
E::Crypto(_) => "db_crypto",
+ E::Base64Decode(_) => "db_base64_decode",
E::SerdeJson(_) => "db_serde_json",
E::Uuid(_) => "db_uuid",
E::Utf8(_) => "db_utf8",
diff --git a/rust/apps/ensu/src-tauri/src/commands/crypto.rs b/rust/apps/ensu/src-tauri/src/commands/crypto.rs
index dff2d36f83..ce6e6506bc 100644
--- a/rust/apps/ensu/src-tauri/src/commands/crypto.rs
+++ b/rust/apps/ensu/src-tauri/src/commands/crypto.rs
@@ -9,7 +9,6 @@ impl From<crypto::Error> for ApiError {
use crypto::Error as E;
let code = match &e {
- E::Base64Decode(_) => "base64_decode",
E::InvalidKeyLength { .. } => "invalid_key_length",
E::InvalidNonceLength { .. } => "invalid_nonce_length",
E::InvalidSaltLength { .. } => "invalid_salt_length",
@@ -37,6 +36,12 @@ impl From<crypto::Error> for ApiError {
}
}
+impl From<b64::DecodeError> for ApiError {
+ fn from(e: b64::DecodeError) -> Self {
+ ApiError::new("base64_decode", e.to_string())
+ }
+}
+
#[derive(Serialize)]
pub struct EncryptedBlob {
encrypted_data: String,
diff --git a/rust/bindings/uniffi/ensu/src/db.rs b/rust/bindings/uniffi/ensu/src/db.rs
index df864b53ae..0e5d2eeef9 100644
--- a/rust/bindings/uniffi/ensu/src/db.rs
+++ b/rust/bindings/uniffi/ensu/src/db.rs
@@ -61,6 +61,9 @@ impl From<db::Error> for DbError {
E::Crypto(err) => Self::Crypto {
detail: err.to_string(),
},
+ E::Base64Decode(err) => Self::Crypto {
+ detail: err.to_string(),
+ },
E::SerdeJson(err) => Self::Json {
detail: err.to_string(),
},
diff --git a/rust/bindings/wasm/ente-wasm/src/crypto.rs b/rust/bindings/wasm/ente-wasm/src/crypto.rs
index dd1158fc95..fceee070a5 100644
--- a/rust/bindings/wasm/ente-wasm/src/crypto.rs
+++ b/rust/bindings/wasm/ente-wasm/src/crypto.rs
@@ -32,7 +32,6 @@ impl From<crypto::Error> for CryptoError {
use crypto::Error as E;
let code = match &e {
- E::Base64Decode(_) => "base64_decode",
E::InvalidKeyLength { .. } => "invalid_key_length",
E::InvalidNonceLength { .. } => "invalid_nonce_length",
E::InvalidSaltLength { .. } => "invalid_salt_length",
@@ -64,6 +63,15 @@ impl From<crypto::Error> for CryptoError {
}
}
+impl From<b64::DecodeError> for CryptoError {
+ fn from(e: b64::DecodeError) -> Self {
+ Self {
+ code: "base64_decode".to_string(),
+ message: e.to_string(),
+ }
+ }
+}
+
/// No-op, kept only for binding compatibility.
///
/// The pure-Rust crypto needs no initialization; existing web callers invoke
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rs
index 74525d89b6..e63f02fcb7 100644
--- a/rust/bindings/wasm/space/src/space.rs
+++ b/rust/bindings/wasm/space/src/space.rs
@@ -53,6 +53,7 @@ impl From<ente_space::SpaceError> for WasmSpaceError {
ente_space::SpaceError::Http(http::Error::Network(_)) => ("network", None),
ente_space::SpaceError::Http(http::Error::Parse(_)) => ("parse", None),
ente_space::SpaceError::Crypto(_) => ("crypto", None),
+ ente_space::SpaceError::Base64Decode(_) => ("base64_decode", None),
ente_space::SpaceError::InvalidInput(_) => ("invalid_input", None),
ente_space::SpaceError::MissingSecretKey => ("missing_secret_key", None),
ente_space::SpaceError::MissingFriendSealedSpaceKey => {
diff --git a/rust/crates/accounts/Cargo.toml b/rust/crates/accounts/Cargo.toml
index 2ae143939e..f5ba017b2e 100644
--- a/rust/crates/accounts/Cargo.toml
+++ b/rust/crates/accounts/Cargo.toml
@@ -10,7 +10,6 @@ ente-core.workspace = true
serde.workspace = true
serde_json.workspace = true
thiserror.workspace = true
-base64 = "0.22"
bip39 = { version = "2", default-features = false, features = ["std"] }
getrandom = { version = "0.2", features = ["js"] }
hex = "0.4"
diff --git a/rust/crates/accounts/src/client.rs b/rust/crates/accounts/src/client.rs
index c8459a207f..a769175e19 100644
--- a/rust/crates/accounts/src/client.rs
+++ b/rust/crates/accounts/src/client.rs
@@ -1,6 +1,6 @@
//! Shared low-level account client.
-use base64::{Engine, engine::general_purpose::STANDARD};
+use ente_core::b64;
use ente_core::{
crypto::SecretVec,
http::{self, Api, ApiConfig, Auth, Http},
@@ -103,7 +103,7 @@ impl AccountsClient {
) -> Result<(AuthResponse, SecretVec)> {
let srp_attrs = self.get_srp_attributes(email).await?;
let creds = auth::derive_srp_credentials(password, &srp_attrs)?;
- let srp_salt = STANDARD.decode(&srp_attrs.srp_salt)?;
+ let srp_salt = b64::decode(&srp_attrs.srp_salt)?;
let mut srp_session = SrpSession::new(
&srp_attrs.srp_user_id.to_string(),
&srp_salt,
@@ -115,14 +115,14 @@ impl AccountsClient {
.create_srp_session(&srp_attrs.srp_user_id, &a_pub)
.await?;
- let server_b = STANDARD.decode(&session.srp_b)?;
+ let server_b = b64::decode(&session.srp_b)?;
let proof = srp_session.compute_m1(&server_b)?;
let auth_response = self
.verify_srp_session(&srp_attrs.srp_user_id, &session.session_id, &proof)
.await?;
let srp_m2 = require_srp_m2(&auth_response)?;
- let server_proof = STANDARD.decode(srp_m2)?;
+ let server_proof = b64::decode(srp_m2)?;
srp_session.verify_m2(&server_proof).map_err(|_| {
Error::AuthenticationFailed("Server proof verification failed".to_string())
})?;
@@ -138,7 +138,7 @@ impl AccountsClient {
) -> Result<CreateSrpSessionResponse> {
let request = CreateSrpSessionRequest {
srp_user_id: srp_user_id.to_string(),
- srp_a: STANDARD.encode(client_public),
+ srp_a: b64::encode(client_public),
};
Ok(http::retry(|| async {
self.api
@@ -164,7 +164,7 @@ impl AccountsClient {
let request = VerifySrpSessionRequest {
srp_user_id: srp_user_id.to_string(),
session_id: session_id.to_string(),
- srp_m1: STANDARD.encode(client_proof),
+ srp_m1: b64::encode(client_proof),
};
Ok(self
.api
diff --git a/rust/crates/accounts/src/error.rs b/rust/crates/accounts/src/error.rs
index 657c5ba9f7..59f26574b8 100644
--- a/rust/crates/accounts/src/error.rs
+++ b/rust/crates/accounts/src/error.rs
@@ -1,7 +1,6 @@
//! Shared error types for account flows.
-use base64::DecodeError;
-use ente_core::{crypto, http};
+use ente_core::{b64, crypto, http};
use thiserror::Error;
use crate::auth;
@@ -38,7 +37,7 @@ pub enum Error {
/// Base64 decode error.
#[error("Base64 decode error: {0}")]
- Base64Decode(#[from] DecodeError),
+ Base64Decode(#[from] b64::DecodeError),
/// Fallback catch-all.
#[error("{0}")]
@@ -64,7 +63,6 @@ impl Error {
impl From<crypto::Error> for Error {
fn from(err: crypto::Error) -> Self {
match err {
- crypto::Error::Base64Decode(source) => Error::Base64Decode(source),
crypto::Error::Io(source) => Error::Generic(source.to_string()),
other => Error::Crypto(other.to_string()),
}
diff --git a/rust/crates/accounts/src/flow.rs b/rust/crates/accounts/src/flow.rs
index fb2dfe556a..2d5a738d4f 100644
--- a/rust/crates/accounts/src/flow.rs
+++ b/rust/crates/accounts/src/flow.rs
@@ -3,10 +3,6 @@
//! This layer is intended for interactive CLI/e2e flows. Callers that need
//! raw server `code/message/status` should prefer [`crate::client::AccountsClient`].
-use base64::{
- Engine,
- engine::general_purpose::{STANDARD, URL_SAFE},
-};
use ente_core::b64;
use ente_core::crypto::{self, SecretVec, secretbox};
use std::fmt;
@@ -439,7 +435,7 @@ where
let srp_attributes = self.client.get_srp_attributes(&params.email).await?;
- let expected_salt = STANDARD.encode(&srp_setup.srp_salt);
+ let expected_salt = b64::encode(&srp_setup.srp_salt);
let mut mismatches = Vec::new();
if srp_attributes.srp_user_id != srp_user_id {
mismatches.push("srpUserID");
@@ -856,25 +852,25 @@ where
&srp_setup.srp_salt,
&srp_setup.login_sub_key,
)?;
- let srp_a = STANDARD.encode(pad_left(&srp_session.public_a(), SRP_A_LEN));
+ let srp_a = b64::encode(&pad_left(&srp_session.public_a(), SRP_A_LEN));
let response = self
.client
.setup_srp(&SetupSrpRequest {
srp_user_id: srp_user_id.to_string(),
- srp_salt: STANDARD.encode(&srp_setup.srp_salt),
- srp_verifier: STANDARD.encode(&srp_setup.srp_verifier),
+ srp_salt: b64::encode(&srp_setup.srp_salt),
+ srp_verifier: b64::encode(&srp_setup.srp_verifier),
srp_a,
})
.await?;
- let srp_b = STANDARD.decode(&response.srp_b)?;
- let srp_m1 = STANDARD.encode(srp_session.compute_m1(&srp_b)?);
+ let srp_b = b64::decode(&response.srp_b)?;
+ let srp_m1 = b64::encode(&srp_session.compute_m1(&srp_b)?);
let complete = self
.client
.complete_srp_setup(&response.setup_id, &srp_m1)
.await?;
- let srp_m2 = STANDARD.decode(&complete.srp_m2)?;
+ let srp_m2 = b64::decode(&complete.srp_m2)?;
srp_session.verify_m2(&srp_m2).map_err(Error::from)?;
Ok(())
}
@@ -891,20 +887,20 @@ where
&srp_setup.srp_salt,
&srp_setup.login_sub_key,
)?;
- let srp_a = STANDARD.encode(pad_left(&srp_session.public_a(), SRP_A_LEN));
+ let srp_a = b64::encode(&pad_left(&srp_session.public_a(), SRP_A_LEN));
let setup = self
.client
.setup_srp(&SetupSrpRequest {
srp_user_id: srp_user_id.to_string(),
- srp_salt: STANDARD.encode(&srp_setup.srp_salt),
- srp_verifier: STANDARD.encode(&srp_setup.srp_verifier),
+ srp_salt: b64::encode(&srp_setup.srp_salt),
+ srp_verifier: b64::encode(&srp_setup.srp_verifier),
srp_a,
})
.await?;
- let srp_b = STANDARD.decode(&setup.srp_b)?;
- let srp_m1 = STANDARD.encode(srp_session.compute_m1(&srp_b)?);
+ let srp_b = b64::decode(&setup.srp_b)?;
+ let srp_m1 = b64::encode(&srp_session.compute_m1(&srp_b)?);
let response = self
.client
@@ -916,7 +912,7 @@ where
})
.await?;
- let srp_m2 = STANDARD.decode(&response.srp_m2)?;
+ let srp_m2 = b64::decode(&response.srp_m2)?;
srp_session.verify_m2(&srp_m2).map_err(Error::from)?;
Ok(response)
}
@@ -959,9 +955,8 @@ fn pad_left(data: &[u8], len: usize) -> Vec<u8> {
}
fn decode_plain_token(token: &str) -> Result<SecretVec> {
- let bytes = URL_SAFE
- .decode(token)
- .or_else(|_| STANDARD.decode(token))
+ let bytes = b64::decode_url_safe(token)
+ .or_else(|_| b64::decode(token))
.map_err(|e| Error::Crypto(format!("token: {e}")))?;
Ok(SecretVec::new(bytes))
}
@@ -991,7 +986,7 @@ fn validate_remote_srp_attributes(
srp_setup: &GeneratedSrpSetup,
key_attributes: &KeyAttributes,
) -> Result<()> {
- let expected_salt = STANDARD.encode(&srp_setup.srp_salt);
+ let expected_salt = b64::encode(&srp_setup.srp_salt);
let mut mismatches = Vec::new();
if remote.srp_user_id != *srp_user_id {
@@ -1251,7 +1246,7 @@ mod tests {
serde_json::json!({
"attributes": {
"srpUserID": Uuid::new_v4(),
- "srpSalt": STANDARD.encode([1u8; 16]),
+ "srpSalt": b64::encode(&[1u8; 16]),
"memLimit": key_attributes.mem_limit,
"opsLimit": key_attributes.ops_limit,
"kekSalt": key_attributes.kek_salt,
@@ -1340,7 +1335,7 @@ mod tests {
serde_json::json!({
"attributes": {
"srpUserID": Uuid::new_v4(),
- "srpSalt": STANDARD.encode([1u8; 16]),
+ "srpSalt": b64::encode(&[1u8; 16]),
"memLimit": key_attributes.mem_limit,
"opsLimit": key_attributes.ops_limit,
"kekSalt": key_attributes.kek_salt,
@@ -1416,7 +1411,7 @@ mod tests {
serde_json::json!({
"attributes": {
"srpUserID": Uuid::new_v4(),
- "srpSalt": STANDARD.encode([1u8; 16]),
+ "srpSalt": b64::encode(&[1u8; 16]),
"memLimit": key_attributes.mem_limit,
"opsLimit": key_attributes.ops_limit,
"kekSalt": key_attributes.kek_salt,
@@ -1502,7 +1497,7 @@ mod tests {
serde_json::json!({
"attributes": {
"srpUserID": Uuid::new_v4(),
- "srpSalt": STANDARD.encode([1u8; 16]),
+ "srpSalt": b64::encode(&[1u8; 16]),
"memLimit": key_attributes.mem_limit,
"opsLimit": key_attributes.ops_limit,
"kekSalt": key_attributes.kek_salt,
@@ -1692,7 +1687,7 @@ mod tests {
serde_json::json!({
"attributes": {
"srpUserID": Uuid::new_v4(),
- "srpSalt": STANDARD.encode([1u8; 16]),
+ "srpSalt": b64::encode(&[1u8; 16]),
"memLimit": key_attributes.mem_limit,
"opsLimit": key_attributes.ops_limit,
"kekSalt": key_attributes.kek_salt,
@@ -1765,7 +1760,7 @@ mod tests {
let email = "[email protected]";
let encoded_email = urlencoding::encode(email).into_owned();
let signup_token_bytes = b"signup-session-token";
- let signup_token = URL_SAFE.encode(signup_token_bytes);
+ let signup_token = b64::encode_url_safe(signup_token_bytes);
let signup_state = Arc::new(Mutex::new(MockSignupState::default()));
let mut server = Server::new_async().await;
@@ -1853,9 +1848,9 @@ mod tests {
.with_body_from_request(move |request| {
let payload: SetupSrpPayload = parse_request_body(request);
let srp_user_id = Uuid::parse_str(&payload.srp_user_id).unwrap();
- let srp_salt = STANDARD.decode(&payload.srp_salt).unwrap();
- let srp_verifier = STANDARD.decode(&payload.srp_verifier).unwrap();
- let srp_a = STANDARD.decode(&payload.srp_a).unwrap();
+ let srp_salt = b64::decode(&payload.srp_salt).unwrap();
+ let srp_verifier = b64::decode(&payload.srp_verifier).unwrap();
+ let srp_a = b64::decode(&payload.srp_a).unwrap();
let server = ServerG4096::<Sha256>::new();
let b_private = [0x33u8; 64];
let srp_b = pad_left(
@@ -1904,7 +1899,7 @@ mod tests {
serde_json::json!({
"setupID": setup_id,
- "srpB": STANDARD.encode(&srp_b),
+ "srpB": b64::encode(&srp_b),
})
.to_string()
.into_bytes()
@@ -1921,7 +1916,7 @@ mod tests {
.with_body_from_request(move |request| {
let payload: CompleteSrpSetupPayload = parse_request_body(request);
let setup_id = Uuid::parse_str(&payload.setup_id).unwrap();
- let srp_m1 = STANDARD.decode(&payload.srp_m1).unwrap();
+ let srp_m1 = b64::decode(&payload.srp_m1).unwrap();
let mut state = state.lock().unwrap();
assert_eq!(state.pending_setup_id, Some(setup_id));
@@ -1929,7 +1924,7 @@ mod tests {
serde_json::json!({
"setupID": setup_id,
- "srpM2": STANDARD.encode(state.pending_server_proof.take().unwrap()),
+ "srpM2": b64::encode(&state.pending_server_proof.take().unwrap()),
})
.to_string()
.into_bytes()
@@ -2002,9 +1997,9 @@ mod tests {
.with_status(200)
.with_body_from_request(move |request| {
let payload: SetupSrpPayload = parse_request_body(request);
- let srp_salt = STANDARD.decode(&payload.srp_salt).unwrap();
- let srp_verifier = STANDARD.decode(&payload.srp_verifier).unwrap();
- let srp_a = STANDARD.decode(&payload.srp_a).unwrap();
+ let srp_salt = b64::decode(&payload.srp_salt).unwrap();
+ let srp_verifier = b64::decode(&payload.srp_verifier).unwrap();
+ let srp_a = b64::decode(&payload.srp_a).unwrap();
let server = ServerG4096::<Sha256>::new();
let b_private = [0x44u8; 64];
let srp_b = pad_left(
@@ -2052,7 +2047,7 @@ mod tests {
serde_json::json!({
"setupID": setup_id,
- "srpB": STANDARD.encode(&srp_b),
+ "srpB": b64::encode(&srp_b),
})
.to_string()
.into_bytes()
@@ -2073,7 +2068,7 @@ mod tests {
state.pending_setup_id.unwrap().to_string()
);
assert_eq!(
- STANDARD.decode(&payload.srp_m1).unwrap(),
+ b64::decode(&payload.srp_m1).unwrap(),
state.pending_client_proof.as_ref().unwrap().clone()
);
assert!(payload.log_out_other_devices);
@@ -2086,7 +2081,7 @@ mod tests {
});
serde_json::json!({
"setupID": payload.setup_id,
- "srpM2": STANDARD.encode(state.pending_server_proof.as_ref().unwrap()),
+ "srpM2": b64::encode(state.pending_server_proof.as_ref().unwrap()),
})
.to_string()
.into_bytes()
diff --git a/rust/crates/contacts/Cargo.toml b/rust/crates/contacts/Cargo.toml
index d665640100..c6c020baee 100644
--- a/rust/crates/contacts/Cargo.toml
+++ b/rust/crates/contacts/Cargo.toml
@@ -16,7 +16,6 @@ sha2 = "0.11"
uuid = { version = "1", features = ["v4", "js"] }
[dev-dependencies]
-base64 = "0.22"
ente-test-support.workspace = true
hmac = "0.13"
mockito = "1.6"
diff --git a/rust/crates/contacts/src/error.rs b/rust/crates/contacts/src/error.rs
index 960f467fe5..4a6c71f590 100644
--- a/rust/crates/contacts/src/error.rs
+++ b/rust/crates/contacts/src/error.rs
@@ -1,5 +1,5 @@
use ente_accounts::auth;
-use ente_core::{crypto, http};
+use ente_core::{b64, crypto, http};
use thiserror::Error;
#[derive(Debug, Error)]
@@ -10,6 +10,9 @@ pub enum ContactsError {
#[error(transparent)]
Crypto(#[from] crypto::Error),
+ #[error("base64 decode error: {0}")]
+ Base64Decode(#[from] b64::DecodeError),
+
#[error(transparent)]
Auth(#[from] auth::Error),
@@ -50,6 +53,7 @@ impl ContactsError {
ContactsError::Http(http::Error::Parse(_)) => ErrorKind::Parse,
ContactsError::Http(_) => ErrorKind::Http,
ContactsError::Crypto(_) => ErrorKind::Crypto,
+ ContactsError::Base64Decode(_) => ErrorKind::Crypto,
ContactsError::Auth(_) => ErrorKind::Auth,
ContactsError::InvalidInput(_) => ErrorKind::InvalidInput,
ContactsError::MissingEncryptedData => ErrorKind::MissingEncryptedData,
diff --git a/rust/crates/contacts/tests/support/auth.rs b/rust/crates/contacts/tests/support/auth.rs
index fa60666032..8d89862429 100644
--- a/rust/crates/contacts/tests/support/auth.rs
+++ b/rust/crates/contacts/tests/support/auth.rs
@@ -1,9 +1,5 @@
use std::time::{Duration, SystemTime, UNIX_EPOCH};
-use base64::{
- Engine,
- engine::general_purpose::{STANDARD, URL_SAFE},
-};
use ente_accounts::auth::{SrpSession, generate_srp_setup_with_login_key};
use ente_accounts::{
AccountsClient, AccountsClientConfig, AuthFlow, AuthFlowUi, AuthenticatedAccount,
@@ -208,15 +204,15 @@ pub async fn create_fixture_account(endpoint: &str, email_prefix: &str) -> TestA
let response = client
.setup_srp(&SetupSrpRequest {
srp_user_id: srp_user_id.to_string(),
- srp_salt: STANDARD.encode(&srp_setup.srp_salt),
- srp_verifier: STANDARD.encode(&srp_setup.srp_verifier),
- srp_a: STANDARD.encode(pad_left(&srp_session.public_a(), SRP_A_LEN)),
+ srp_salt: b64::encode(&srp_setup.srp_salt),
+ srp_verifier: b64::encode(&srp_setup.srp_verifier),
+ srp_a: b64::encode(&pad_left(&srp_session.public_a(), SRP_A_LEN)),
})
.await
.unwrap();
- let srp_m1 = STANDARD.encode(
- srp_session
- .compute_m1(&STANDARD.decode(&response.srp_b).unwrap())
+ let srp_m1 = b64::encode(
+ &srp_session
+ .compute_m1(&b64::decode(&response.srp_b).unwrap())
.unwrap(),
);
let complete = client
@@ -224,7 +220,7 @@ pub async fn create_fixture_account(endpoint: &str, email_prefix: &str) -> TestA
.await
.unwrap();
srp_session
- .verify_m2(&STANDARD.decode(&complete.srp_m2).unwrap())
+ .verify_m2(&b64::decode(&complete.srp_m2).unwrap())
.unwrap();
TestAccount {
@@ -303,7 +299,7 @@ async fn fetch_two_factor_status_with_token(
}
fn auth_token_from_authenticated(account: &AuthenticatedAccount) -> String {
- URL_SAFE.encode(&account.secrets.token)
+ b64::encode_url_safe(&account.secrets.token)
}
pub fn test_account_from_authenticated(
diff --git a/rust/crates/core/src/b64.rs b/rust/crates/core/src/b64.rs
index 5b3f3b303e..a104d04810 100644
--- a/rust/crates/core/src/b64.rs
+++ b/rust/crates/core/src/b64.rs
@@ -5,16 +5,11 @@ use base64::{
engine::general_purpose::{STANDARD, URL_SAFE, URL_SAFE_NO_PAD},
};
-use crate::crypto::Result;
+pub use base64::DecodeError;
/// Decode a standard base64 string to bytes, the inverse of [`encode`].
-///
-/// # Errors
-///
-/// Returns [`Base64Decode`](crate::crypto::Error::Base64Decode) if
-/// `input` is not valid standard base64.
-pub fn decode(input: &str) -> Result<Vec<u8>> {
- Ok(STANDARD.decode(input)?)
+pub fn decode(input: &str) -> Result<Vec<u8>, DecodeError> {
+ STANDARD.decode(input)
}
/// Encode bytes to a standard base64 string, the inverse of [`decode`].
@@ -33,6 +28,12 @@ pub fn encode_url_safe(input: &[u8]) -> String {
URL_SAFE.encode(input)
}
+/// Decode a URL-safe base64 string to bytes, the inverse of
+/// [`encode_url_safe`].
+pub fn decode_url_safe(input: &str) -> Result<Vec<u8>, DecodeError> {
+ URL_SAFE.decode(input)
+}
+
/// Encode bytes to an unpadded URL-safe base64 string.
///
/// Like [`encode_url_safe`] but without trailing "=" padding, as required
@@ -43,13 +44,8 @@ pub fn encode_url_safe_no_padding(input: &[u8]) -> String {
/// Decode an unpadded URL-safe base64 string to bytes, the inverse of
/// [`encode_url_safe_no_padding`].
-///
-/// # Errors
-///
-/// Returns [`Base64Decode`](crate::crypto::Error::Base64Decode) if
-/// `input` is not valid unpadded URL-safe base64.
-pub fn decode_url_safe_no_padding(input: &str) -> Result<Vec<u8>> {
- Ok(URL_SAFE_NO_PAD.decode(input)?)
+pub fn decode_url_safe_no_padding(input: &str) -> Result<Vec<u8>, DecodeError> {
+ URL_SAFE_NO_PAD.decode(input)
}
#[cfg(test)]
diff --git a/rust/crates/core/src/crypto/error.rs b/rust/crates/core/src/crypto/error.rs
index a520064049..cc490c5f82 100644
--- a/rust/crates/core/src/crypto/error.rs
+++ b/rust/crates/core/src/crypto/error.rs
@@ -9,10 +9,6 @@ use thiserror::Error;
/// bindings forward to non-Rust callers.
#[derive(Error, Debug)]
pub enum Error {
- /// Base64 decoding failed.
- #[error("Base64 decode error: {0}")]
- Base64Decode(#[from] base64::DecodeError),
-
/// Invalid key length.
#[error("Invalid key length: expected {expected}, got {actual}")]
InvalidKeyLength {
@@ -128,7 +124,6 @@ impl Error {
/// programmatic matching (e.g. `"invalid_key_length"`).
pub fn code(&self) -> &'static str {
match self {
- Error::Base64Decode(_) => "base64_decode",
Error::InvalidKeyLength { .. } => "invalid_key_length",
Error::InvalidNonceLength { .. } => "invalid_nonce_length",
Error::InvalidSaltLength { .. } => "invalid_salt_length",
diff --git a/rust/crates/ensu/src/db/error.rs b/rust/crates/ensu/src/db/error.rs
index e8bddaaa3a..a9d6134f65 100644
--- a/rust/crates/ensu/src/db/error.rs
+++ b/rust/crates/ensu/src/db/error.rs
@@ -30,6 +30,9 @@ pub enum Error {
#[error(transparent)]
Crypto(#[from] ente_core::crypto::Error),
+ #[error(transparent)]
+ Base64Decode(#[from] ente_core::b64::DecodeError),
+
#[error(transparent)]
SerdeJson(#[from] serde_json::Error),
diff --git a/rust/crates/paste/src/lib.rs b/rust/crates/paste/src/lib.rs
index df8de61614..202ab7e2da 100644
--- a/rust/crates/paste/src/lib.rs
+++ b/rust/crates/paste/src/lib.rs
@@ -20,6 +20,9 @@ pub enum Error {
#[error(transparent)]
Crypto(#[from] crypto::Error),
+ #[error("base64 decode error: {0}")]
+ Base64Decode(#[from] b64::DecodeError),
+
#[error("incorrect paste password")]
IncorrectPassword,
@@ -446,10 +449,7 @@ mod tests {
payload.kdf_nonce = "not base64".to_string();
let error = decrypt(&payload, &paste_key, Some("correct horse")).unwrap_err();
- assert!(matches!(
- error,
- Error::Crypto(crypto::Error::Base64Decode(_))
- ));
+ assert!(matches!(error, Error::Base64Decode(_)));
}
#[test]
@@ -460,10 +460,7 @@ mod tests {
payload.encrypted_paste_key = "not base64".to_string();
let error = decrypt(&payload, &paste_key, Some("correct horse")).unwrap_err();
- assert!(matches!(
- error,
- Error::Crypto(crypto::Error::Base64Decode(_))
- ));
+ assert!(matches!(error, Error::Base64Decode(_)));
}
#[test]
diff --git a/rust/space/Cargo.toml b/rust/space/Cargo.toml
index ccd4db9c07..58fd2b32a3 100644
--- a/rust/space/Cargo.toml
+++ b/rust/space/Cargo.toml
@@ -16,7 +16,6 @@ urlencoding = "2"
zeroize = { version = "1.8", features = ["derive"] }
[dev-dependencies]
-base64 = "0.22"
ente-accounts.workspace = true
ente-test-support.workspace = true
mockito = "1.6"
diff --git a/rust/space/src/error.rs b/rust/space/src/error.rs
index 9e8c35a679..9be10ca5e6 100644
--- a/rust/space/src/error.rs
+++ b/rust/space/src/error.rs
@@ -1,4 +1,4 @@
-use ente_core::{crypto, http};
+use ente_core::{b64, crypto, http};
use thiserror::Error;
#[derive(Debug, Error)]
@@ -9,6 +9,9 @@ pub enum SpaceError {
#[error(transparent)]
Crypto(#[from] crypto::Error),
+ #[error("base64 decode error: {0}")]
+ Base64Decode(#[from] b64::DecodeError),
+
#[error("invalid input: {0}")]
InvalidInput(String),
diff --git a/rust/space/tests/support/auth.rs b/rust/space/tests/support/auth.rs
index c0160b8404..03b09f4d24 100644
--- a/rust/space/tests/support/auth.rs
+++ b/rust/space/tests/support/auth.rs
@@ -1,4 +1,3 @@
-use base64::{Engine, engine::general_purpose::STANDARD};
use ente_accounts::{
AccountsClient, AccountsClientConfig, KeyAttributes,
auth::{SrpSession, generate_srp_setup_with_login_key},
@@ -88,15 +87,15 @@ pub async fn create_account(endpoint: &str, email_prefix: &str) -> TestAccount {
let response = client
.setup_srp(&SetupSrpRequest {
srp_user_id: srp_user_id.to_string(),
- srp_salt: STANDARD.encode(&srp_setup.srp_salt),
- srp_verifier: STANDARD.encode(&srp_setup.srp_verifier),
- srp_a: STANDARD.encode(pad_left(&srp_session.public_a(), SRP_A_LEN)),
+ srp_salt: b64::encode(&srp_setup.srp_salt),
+ srp_verifier: b64::encode(&srp_setup.srp_verifier),
+ srp_a: b64::encode(&pad_left(&srp_session.public_a(), SRP_A_LEN)),
})
.await
.unwrap();
- let srp_m1 = STANDARD.encode(
- srp_session
- .compute_m1(&STANDARD.decode(&response.srp_b).unwrap())
+ let srp_m1 = b64::encode(
+ &srp_session
+ .compute_m1(&b64::decode(&response.srp_b).unwrap())
.unwrap(),
);
let complete = client
@@ -104,7 +103,7 @@ pub async fn create_account(endpoint: &str, email_prefix: &str) -> TestAccount {
.await
.unwrap();
srp_session
- .verify_m2(&STANDARD.decode(&complete.srp_m2).unwrap())
+ .verify_m2(&b64::decode(&complete.srp_m2).unwrap())
.unwrap();
TestAccount {