π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use crypto_secretbox::XSalsa20Poly1305;
use crypto_secretbox::aead::generic_array::GenericArray;
use crypto_secretbox::aead::{Aead, KeyInit};
use crate::crypto::{Error, Key, Nonce, Result};
// Same as libsodium's `crypto_secretbox_MACBYTES`.
pub const MAC_BYTES: usize = 16;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EncryptedBox {
pub encrypted_data: Vec<u8>,
pub nonce: Nonce,
}
impl EncryptedBox {
pub fn decrypt(&self, key: &Key) -> Result<Vec<u8>> {
decrypt(&self.encrypted_data, &self.nonce, key)
}
}
// Wire-compatible with libsodium's `crypto_secretbox_easy`.
pub fn encrypt(data: &[u8], key: &Key) -> EncryptedBox {
let nonce = Nonce::generate();
let encrypted_data = encrypt_with_nonce(data, &nonce, key);
EncryptedBox {
encrypted_data,
nonce,
}
}
fn encrypt_with_nonce(data: &[u8], nonce: &Nonce, key: &Key) -> Vec<u8> {
let cipher = XSalsa20Poly1305::new(GenericArray::from_slice(key.as_bytes()));
let nonce_ga = GenericArray::from_slice(nonce.as_bytes());
#[expect(
clippy::expect_used,
reason = "The cipher size limit cannot be reached by an in-memory slice"
)]
cipher
.encrypt(nonce_ga, data)
.expect("XSalsa20-Poly1305 encryption cannot fail for in-memory plaintexts")
}
// Wire-compatible with libsodium's `crypto_secretbox_open_easy`.
pub fn decrypt(data: &[u8], nonce: &Nonce, key: &Key) -> Result<Vec<u8>> {
if data.len() < MAC_BYTES {
return Err(Error::CiphertextTooShort {
minimum: MAC_BYTES,
actual: data.len(),
});
}
let cipher = XSalsa20Poly1305::new(GenericArray::from_slice(key.as_bytes()));
let nonce_ga = GenericArray::from_slice(nonce.as_bytes());
cipher
.decrypt(nonce_ga, data)
.map_err(|_| Error::DecryptionFailed)
}
// The MAC || ciphertext body is wire-compatible with libsodium's
// `crypto_secretbox_easy`; prepending the nonce is an Ente convention.
pub fn encrypt_combined(data: &[u8], key: &Key) -> Vec<u8> {
let nonce = Nonce::generate();
let encrypted = encrypt_with_nonce(data, &nonce, key);
let mut combined = Vec::with_capacity(Nonce::BYTES + encrypted.len());
combined.extend_from_slice(nonce.as_bytes());
combined.extend_from_slice(&encrypted);
combined
}
// The body is wire-compatible with libsodium's `crypto_secretbox_open_easy`;
// the leading nonce is an Ente convention.
pub fn decrypt_combined(data: &[u8], key: &Key) -> Result<Vec<u8>> {
if data.len() < Nonce::BYTES + MAC_BYTES {
return Err(Error::CiphertextTooShort {
minimum: Nonce::BYTES + MAC_BYTES,
actual: data.len(),
});
}
let (nonce, encrypted) = data.split_at(Nonce::BYTES);
decrypt(encrypted, &Nonce::try_from_slice(nonce)?, key)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_nacl_vector() {
// NaCl's tests/secretbox.c vector.
let key = Key::try_from_slice(
&crate::b64::decode("GydVZHPphdRizVEZeppGx2AJVJ6sZHTyBsTuCET2g4k=").unwrap(),
)
.unwrap();
let nonce =
Nonce::try_from_slice(&crate::b64::decode("aWlu6VW2K3PNYr2odfxz1oIZ4ANregs3").unwrap())
.unwrap();
let plaintext = crate::b64::decode(
"vgdfxTyB8tXPFBMW6+sMe1IoxSpMYsvUS2aEm2QkT/zl7LqvM711GhrHKNRebGEpbNw8ASM1YfQdtmzOMUrbMQ476CUMRvBtzuo6f6E0gFfi9lVq1rExigJKg48hrx/eBIl360j1n/1JJMocYJAuUvCgibx2iXBA4IL5N3Y4SGReBwU=",
)
.unwrap();
let ciphertext = crate::b64::decode(
"8//HcD+UAOUqfftLPTMF2Y6ZO59IaBJzwpZQujL8ds5IMy6nFk2WpEdvuMUxoRhqwN/BfJjc6HtNp/AR7EjJcnHSwg+bko/iJw1vuGPVFzi0ju7jFKfMirkyFkVI5SaukCJDaFF6z+q9a7NzK8Dp2pmDK2HKAbbeViRKnojV+bN5c/YipD0UplmbH2VMtFp041Wl",
)
.unwrap();
assert_eq!(encrypt_with_nonce(&plaintext, &nonce, &key), ciphertext);
assert_eq!(decrypt(&ciphertext, &nonce, &key).unwrap(), plaintext);
}
#[test]
fn test_different_nonces_produce_different_ciphertexts() {
let key = Key::generate();
let plaintext = b"Same plaintext";
let encrypted1 = encrypt(plaintext, &key);
let encrypted2 = encrypt(plaintext, &key);
assert_ne!(encrypted1, encrypted2);
assert_eq!(encrypted1.decrypt(&key).unwrap(), plaintext);
assert_eq!(encrypted2.decrypt(&key).unwrap(), plaintext);
}
#[test]
fn test_combined_roundtrip() {
let key = Key::generate();
let plaintext = b"Combined format test";
let combined = encrypt_combined(plaintext, &key);
assert_eq!(combined.len(), Nonce::BYTES + MAC_BYTES + plaintext.len());
let decrypted = decrypt_combined(&combined, &key).unwrap();
assert_eq!(decrypted, plaintext);
}
#[test]
fn test_combined_is_split_with_nonce_prefix() {
let key = Key::generate();
let plaintext = b"Interop test";
let combined = encrypt_combined(plaintext, &key);
let (nonce, encrypted) = combined.split_at(Nonce::BYTES);
let decrypted = decrypt(encrypted, &Nonce::try_from_slice(nonce).unwrap(), &key).unwrap();
assert_eq!(decrypted, plaintext);
}
#[test]
fn test_wrong_key_fails() {
let key = Key::generate();
let wrong_key = Key::generate();
let encrypted = encrypt(b"Secret", &key);
assert!(encrypted.decrypt(&wrong_key).is_err());
let combined = encrypt_combined(b"Secret", &key);
assert!(decrypt_combined(&combined, &wrong_key).is_err());
}
#[test]
fn test_corrupted_ciphertext_fails() {
let key = Key::generate();
let mut encrypted = encrypt(b"Original", &key);
let mid = encrypted.encrypted_data.len() / 2;
encrypted.encrypted_data[mid] ^= 1;
assert!(matches!(
encrypted.decrypt(&key),
Err(Error::DecryptionFailed)
));
}
#[test]
fn test_ciphertext_too_short() {
let key = Key::generate();
assert!(matches!(
decrypt(&[0u8; 10], &Nonce::generate(), &key),
Err(Error::CiphertextTooShort { .. })
));
assert!(matches!(
decrypt_combined(&[0u8; 30], &key),
Err(Error::CiphertextTooShort { .. })
));
}
#[test]
fn test_empty_plaintext() {
let key = Key::generate();
let encrypted = encrypt(b"", &key);
assert_eq!(encrypted.decrypt(&key).unwrap(), b"");
let combined = encrypt_combined(b"", &key);
assert_eq!(decrypt_combined(&combined, &key).unwrap(), b"");
}
}