π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use std::sync::Arc;
use ente_core::{
Session as InnerSession, b64,
crypto::{self, Key, Nonce, PublicKey, SecretKey},
http::{ApiConfig, Auth},
};
use serde::Deserialize;
use serde_wasm_bindgen as swb;
use tsify::{Ts, Tsify};
use wasm_bindgen::prelude::*;
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error(transparent)]
Accounts(#[from] ente_accounts::Error),
#[error(transparent)]
Input(#[from] tsify::Error),
#[error(transparent)]
Serde(#[from] swb::Error),
#[error(transparent)]
Http(#[from] ente_core::http::Error),
#[error(transparent)]
Decode(#[from] b64::DecodeError),
#[error(transparent)]
Crypto(#[from] crypto::Error),
#[error("Missing recovery key")]
MissingRecoveryKey,
}
impl Error {
fn name(&self) -> Option<&'static str> {
match self {
Self::MissingRecoveryKey => Some("missing_recovery_key"),
_ => None,
}
}
}
impl From<Error> for JsValue {
fn from(error: Error) -> Self {
crate::js_error(&error, error.name())
}
}
#[derive(Deserialize, Tsify)]
#[serde(rename_all = "camelCase")]
pub struct SessionKeyAttributes {
public_key: String,
encrypted_secret_key: String,
secret_key_decryption_nonce: String,
#[tsify(optional)]
recovery_key_encrypted_with_master_key: Option<String>,
#[tsify(optional)]
recovery_key_decryption_nonce: Option<String>,
}
#[derive(Deserialize, Tsify)]
#[serde(rename_all = "camelCase")]
pub struct OpenSessionInput {
base_url: String,
auth_token: String,
#[serde(rename = "userID")]
user_id: i64,
master_key_b64: String,
key_attributes: SessionKeyAttributes,
#[tsify(optional)]
client_package: Option<String>,
#[tsify(optional)]
client_version: Option<String>,
}
#[wasm_bindgen(js_name = openSession)]
pub fn open_session(input: Ts<OpenSessionInput>) -> Result<Session, Error> {
let OpenSessionInput {
base_url,
auth_token,
user_id,
master_key_b64,
key_attributes,
client_package,
client_version,
} = input.to_rust()?;
let master_key = Key::try_from_slice(&b64::decode(&master_key_b64)?)?;
let encrypted_recovery_key = key_attributes
.recovery_key_encrypted_with_master_key
.filter(|value| !value.is_empty())
.ok_or(Error::MissingRecoveryKey)?;
let recovery_key_nonce = key_attributes
.recovery_key_decryption_nonce
.filter(|value| !value.is_empty())
.ok_or(Error::MissingRecoveryKey)?;
let recovery_key = crypto::secretbox::decrypt(
&b64::decode(&encrypted_recovery_key)?,
&Nonce::try_from_slice(&b64::decode(&recovery_key_nonce)?)?,
&master_key,
)?;
let recovery_key = Key::try_from_slice(&recovery_key)?;
let secret_key = SecretKey::open(
&crypto::secretbox::EncryptedBox {
encrypted_data: b64::decode(&key_attributes.encrypted_secret_key)?,
nonce: Nonce::try_from_slice(&b64::decode(
&key_attributes.secret_key_decryption_nonce,
)?)?,
},
&master_key,
&PublicKey::try_from_slice(&b64::decode(&key_attributes.public_key)?)?,
)?;
Ok(Session(Arc::new(InnerSession::new(
ApiConfig {
origin: base_url,
client_package,
client_version,
user_agent: None,
auth: Some(Auth::User(auth_token)),
},
user_id,
master_key,
recovery_key,
secret_key,
)?)))
}
#[wasm_bindgen]
pub struct Session(Arc<InnerSession>);
impl Session {
pub fn inner(&self) -> &InnerSession {
&self.0
}
}
#[wasm_bindgen]
impl Session {
#[wasm_bindgen(js_name = updateAuthToken)]
pub fn update_auth_token(&self, auth_token: String) {
self.0.api.set_auth(Some(Auth::User(auth_token)));
}
}
#[wasm_bindgen(js_name = authRecoveryKeyMnemonic)]
pub fn auth_recovery_key_mnemonic(session: &Session) -> Result<String, Error> {
ente_accounts::auth::recovery_key_to_mnemonic(session.inner().recovery_key.as_bytes())
.map_err(Into::into)
}