๐ End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use std::fmt;
use argon2::{Algorithm, Argon2, Params as Argon2Params, Version};
use crate::crypto::{Error, Key, Result, Salt};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Params {
pub mem_limit: u64,
pub ops_limit: u32,
}
impl Params {
pub const INTERACTIVE: Self = Self {
mem_limit: 67_108_864,
ops_limit: 2,
};
pub const MODERATE: Self = Self {
mem_limit: 268_435_456,
ops_limit: 3,
};
pub const SENSITIVE: Self = Self {
mem_limit: 1_073_741_824,
ops_limit: 4,
};
// Only for inputs that are already high-entropy, never passwords.
pub const MIN: Self = Self {
mem_limit: 8_192,
ops_limit: 1,
};
pub fn validate(self) -> Result<()> {
if self.mem_limit < Self::MIN.mem_limit {
return Err(Error::InvalidKeyDerivationParams(format!(
"Memory limit {} is below minimum {}",
self.mem_limit,
Self::MIN.mem_limit
)));
}
if !self.mem_limit.is_multiple_of(1024) {
return Err(Error::InvalidKeyDerivationParams(format!(
"Memory limit {} must be a multiple of 1024 bytes",
self.mem_limit
)));
}
if self.ops_limit < Self::MIN.ops_limit {
return Err(Error::InvalidKeyDerivationParams(format!(
"Operations limit {} is below minimum {}",
self.ops_limit,
Self::MIN.ops_limit
)));
}
let max_memory = 4 * Self::SENSITIVE.mem_limit;
let max_work = max_memory * u64::from(Self::SENSITIVE.ops_limit);
let work = u128::from(self.mem_limit) * u128::from(self.ops_limit);
if self.mem_limit > max_memory || work > u128::from(max_work) {
return Err(Error::InvalidKeyDerivationParams(
"Password derivation exceeds supported resource limits".into(),
));
}
Ok(())
}
}
const MEMLIMIT_SENSITIVE_MIN: u64 = 134_217_728;
pub struct DerivedKey {
pub key: Key,
pub salt: Salt,
pub params: Params,
}
impl fmt::Debug for DerivedKey {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DerivedKey")
.field("key", &"[REDACTED]")
.field("salt", &self.salt)
.field("params", &self.params)
.finish()
}
}
// Produces the same key as libsodium's `crypto_pwhash` with
// `crypto_pwhash_ALG_ARGON2ID13`.
pub fn derive_key(password: &str, salt: &Salt, params: Params) -> Result<Key> {
derive_key_impl(password.as_bytes(), salt, params)
}
fn derive_key_impl(password: &[u8], salt: &Salt, params: Params) -> Result<Key> {
params.validate()?;
let m_cost = (params.mem_limit / 1024) as u32;
let t_cost = params.ops_limit;
let p_cost = 1;
let argon2_params = Argon2Params::new(m_cost, t_cost, p_cost, Some(Key::BYTES))
.map_err(|e| Error::InvalidKeyDerivationParams(e.to_string()))?;
let argon2 = Argon2::new(Algorithm::Argon2id, Version::V0x13, argon2_params);
let mut key = [0u8; Key::BYTES];
argon2
.hash_password_into(password, salt.as_bytes(), &mut key)
.map_err(Error::Argon2)?;
Ok(Key::from_bytes(key))
}
pub fn derive_interactive_key(password: &str) -> Result<DerivedKey> {
let salt = Salt::generate();
let key = derive_key(password, &salt, Params::INTERACTIVE)?;
Ok(DerivedKey {
key,
salt,
params: Params::INTERACTIVE,
})
}
pub fn derive_moderate_key(password: &str) -> Result<DerivedKey> {
let salt = Salt::generate();
let key = derive_key(password, &salt, Params::MODERATE)?;
Ok(DerivedKey {
key,
salt,
params: Params::MODERATE,
})
}
pub fn derive_sensitive_key(password: &str) -> Result<DerivedKey> {
let salt = Salt::generate();
derive_sensitive_adaptive(password.as_bytes(), &salt)
}
fn derive_sensitive_adaptive(password: &[u8], salt: &Salt) -> Result<DerivedKey> {
if !Params::SENSITIVE
.mem_limit
.is_multiple_of(Params::MODERATE.mem_limit)
{
return Err(Error::InvalidKeyDerivationParams(format!(
"Memory limit {} must be divisible by {}",
Params::SENSITIVE.mem_limit,
Params::MODERATE.mem_limit
)));
}
let desired_strength = Params::SENSITIVE.mem_limit * u64::from(Params::SENSITIVE.ops_limit);
let factor = (Params::SENSITIVE.mem_limit / Params::MODERATE.mem_limit) as u32;
let mut mem_limit = Params::MODERATE.mem_limit;
let mut ops_limit = Params::SENSITIVE
.ops_limit
.checked_mul(factor)
.ok_or_else(|| {
Error::InvalidKeyDerivationParams("Operations limit overflow".to_string())
})?;
if mem_limit * u64::from(ops_limit) != desired_strength {
return Err(Error::InvalidKeyDerivationParams(format!(
"Unexpected mem/ops limits: mem_limit {mem_limit}, ops_limit {ops_limit}"
)));
}
// The server rejects account key attributes below 128 MiB. Halving memory
// and doubling ops matches the web and Flutter fallback policy.
let mut last_error = None;
while mem_limit >= MEMLIMIT_SENSITIVE_MIN {
let params = Params {
mem_limit,
ops_limit,
};
match derive_key_impl(password, salt, params) {
Ok(key) => {
return Ok(DerivedKey {
key,
salt: *salt,
params,
});
}
Err(err) => {
last_error = Some(err);
}
}
mem_limit /= 2;
ops_limit = match ops_limit.checked_mul(2) {
Some(value) => value,
None => break,
};
}
Err(last_error.unwrap_or(Error::KeyDerivationFailed))
}
#[cfg(test)]
mod tests {
use super::*;
fn test_salt() -> Salt {
Salt::from_bytes([0x42u8; Salt::BYTES])
}
#[test]
fn test_sensitive_policy_matches_existing_client_bounds() {
let desired_strength = Params::SENSITIVE.mem_limit * u64::from(Params::SENSITIVE.ops_limit);
let factor = (Params::SENSITIVE.mem_limit / Params::MODERATE.mem_limit) as u32;
let mut mem_limit = Params::MODERATE.mem_limit;
let mut ops_limit = Params::SENSITIVE.ops_limit * factor;
let mut attempts = Vec::new();
while mem_limit >= MEMLIMIT_SENSITIVE_MIN {
attempts.push((mem_limit, ops_limit));
mem_limit /= 2;
ops_limit *= 2;
}
assert_eq!(
attempts.first(),
Some(&(
Params::MODERATE.mem_limit,
Params::SENSITIVE.ops_limit * factor
))
);
assert_eq!(attempts.last(), Some(&(MEMLIMIT_SENSITIVE_MIN, 32)));
assert!(
attempts
.iter()
.all(|(mem, ops)| *mem * u64::from(*ops) == desired_strength)
);
}
#[test]
fn test_derived_key_debug_redacts_secret_material() {
let result = DerivedKey {
key: Key::from_bytes([1u8; Key::BYTES]),
salt: test_salt(),
params: Params::INTERACTIVE,
};
let debug = format!("{result:?}");
assert!(debug.contains("[REDACTED]"));
assert!(!debug.contains("[1, 1, 1"));
}
#[test]
fn test_memlimit_too_low() {
let result = derive_key(
"test",
&Salt::generate(),
Params {
mem_limit: 4096,
ops_limit: Params::INTERACTIVE.ops_limit,
},
);
assert!(result.is_err());
}
#[test]
fn test_memlimit_not_aligned() {
let result = derive_key(
"test",
&Salt::generate(),
Params {
mem_limit: Params::INTERACTIVE.mem_limit + 1,
ops_limit: Params::INTERACTIVE.ops_limit,
},
);
assert!(matches!(result, Err(Error::InvalidKeyDerivationParams(_))));
}
#[test]
fn test_opslimit_zero() {
let result = derive_key(
"test",
&Salt::generate(),
Params {
mem_limit: Params::INTERACTIVE.mem_limit,
ops_limit: 0,
},
);
assert!(result.is_err());
}
#[test]
fn test_params_bound_memory_and_work() {
for (memory, operations, accepted) in [
(1 << 30, 4, true),
(1 << 28, 16, true),
(1 << 27, 32, true),
(1 << 32, 4, true),
(1 << 28, 64, true),
(8192, 1 << 21, true),
((1 << 32) + 1024, 1, false),
(1 << 32, 5, false),
(1 << 28, 65, false),
(8192, u32::MAX, false),
(u64::MAX - 1023, u32::MAX, false),
] {
assert_eq!(
Params {
mem_limit: memory,
ops_limit: operations,
}
.validate()
.is_ok(),
accepted,
"{memory} bytes, {operations} operations"
);
}
}
#[test]
fn test_unusual_passwords() {
let salt = Salt::generate();
for password in ["", &"a".repeat(1000), "ะฟะฐัะพะปั ๅฏ็ ๐"] {
derive_key(password, &salt, Params::MIN).unwrap();
}
}
}