π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use ente_core::{
b64,
crypto::{self, Header, Key, blob},
};
use hkdf::Hkdf;
use sha2::{Digest, Sha256};
use thiserror::Error;
const ATTACHMENT_KEY_INFO: &[u8] = b"llmchat_attachment_v1";
pub type Result<T> = std::result::Result<T, Error>;
#[derive(Debug, Error)]
pub enum Error {
#[error("invalid blob length: expected at least {minimum} bytes, got {actual}")]
InvalidBlobLength { minimum: usize, actual: usize },
#[error("invalid encrypted field format")]
InvalidEncryptedField,
#[error(transparent)]
Crypto(#[from] crypto::Error),
#[error(transparent)]
Base64Decode(#[from] b64::DecodeError),
#[error(transparent)]
Utf8(#[from] std::string::FromUtf8Error),
}
pub struct EncryptedChatPayload {
pub encrypted_data: String,
pub header: String,
}
#[derive(Default)]
pub struct Sha256Hasher(Sha256);
impl Sha256Hasher {
pub fn new() -> Self {
Self::default()
}
pub fn update(&mut self, bytes: impl AsRef<[u8]>) {
self.0.update(bytes);
}
pub fn finalize(self) -> [u8; 32] {
self.0.finalize().into()
}
}
pub fn sha256(bytes: &[u8]) -> [u8; 32] {
sha256_parts(&[bytes])
}
pub fn sha256_parts(parts: &[&[u8]]) -> [u8; 32] {
let mut hash = Sha256Hasher::new();
for bytes in parts {
hash.update(bytes);
}
hash.finalize()
}
pub fn generate_chat_key() -> String {
b64::encode(Key::generate().as_bytes())
}
pub fn encrypt_payload(value: &str, key_b64: &str) -> Result<EncryptedChatPayload> {
let encrypted = blob::encrypt(value.as_bytes(), &key_from_b64(key_b64)?)?;
Ok(EncryptedChatPayload {
encrypted_data: b64::encode(&encrypted.encrypted_data),
header: b64::encode(encrypted.decryption_header.as_bytes()),
})
}
pub fn decrypt_payload(
encrypted_data_b64: &str,
header_b64: &str,
key_b64: &str,
) -> Result<String> {
let encrypted_data = b64::decode(encrypted_data_b64)?;
let header = b64::decode(header_b64)?;
let plaintext = blob::decrypt(
&encrypted_data,
&Header::try_from_slice(&header)?,
&key_from_b64(key_b64)?,
)?;
Ok(String::from_utf8(plaintext)?)
}
pub fn encrypt_field_b64(value: &str, key_b64: &str) -> Result<String> {
encrypt_json_field(value, &b64::decode(key_b64)?)
}
pub fn decrypt_field_b64(value: &str, key_b64: &str) -> Result<String> {
decrypt_json_field(value, &b64::decode(key_b64)?)
}
pub fn encrypt_attachment(data: &[u8], chat_key_b64: &str, session_uuid: &str) -> Result<Vec<u8>> {
encrypt_blob(data, attachment_key(chat_key_b64, session_uuid)?.as_bytes())
}
pub fn decrypt_attachment(data: &[u8], chat_key_b64: &str, session_uuid: &str) -> Result<Vec<u8>> {
decrypt_blob(data, attachment_key(chat_key_b64, session_uuid)?.as_bytes())
}
pub fn encrypt_blob(plaintext: &[u8], key: &[u8]) -> Result<Vec<u8>> {
Ok(blob::encrypt_combined(
plaintext,
&Key::try_from_slice(key)?,
)?)
}
pub fn decrypt_blob(data: &[u8], key: &[u8]) -> Result<Vec<u8>> {
if data.len() < Header::BYTES {
return Err(Error::InvalidBlobLength {
minimum: Header::BYTES,
actual: data.len(),
});
}
let (header, ciphertext) = data.split_at(Header::BYTES);
Ok(blob::decrypt(
ciphertext,
&Header::try_from_slice(header)?,
&Key::try_from_slice(key)?,
)?)
}
pub fn encrypt_string(value: &str, key: &[u8]) -> Result<Vec<u8>> {
encrypt_blob(value.as_bytes(), key)
}
pub fn decrypt_string(data: &[u8], key: &[u8]) -> Result<String> {
Ok(String::from_utf8(decrypt_blob(data, key)?)?)
}
pub fn encrypt_json_field(value: &str, key: &[u8]) -> Result<String> {
let encrypted = blob::encrypt(value.as_bytes(), &Key::try_from_slice(key)?)?;
let ciphertext_b64 = b64::encode(&encrypted.encrypted_data);
let header_b64 = b64::encode(encrypted.decryption_header.as_bytes());
Ok(format!("enc:v1:{ciphertext_b64}:{header_b64}"))
}
pub fn decrypt_json_field(value: &str, key: &[u8]) -> Result<String> {
let mut parts = value.split(':');
if parts.next() != Some("enc") || parts.next() != Some("v1") {
return Err(Error::InvalidEncryptedField);
}
let ciphertext = parts.next().ok_or(Error::InvalidEncryptedField)?;
let header = parts.next().ok_or(Error::InvalidEncryptedField)?;
if parts.next().is_some() {
return Err(Error::InvalidEncryptedField);
}
let ciphertext = b64::decode(ciphertext)?;
let header = b64::decode(header)?;
let header = Header::try_from_slice(&header).map_err(|_| Error::InvalidEncryptedField)?;
let plaintext = blob::decrypt(&ciphertext, &header, &Key::try_from_slice(key)?)?;
Ok(String::from_utf8(plaintext)?)
}
fn key_from_b64(value: &str) -> Result<Key> {
Ok(Key::try_from_slice(&b64::decode(value)?)?)
}
fn attachment_key(chat_key_b64: &str, session_uuid: &str) -> Result<Key> {
let chat_key = b64::decode(chat_key_b64)?;
let mut key = [0; 32];
Hkdf::<Sha256>::new(Some(session_uuid.as_bytes()), &chat_key)
.expand(ATTACHMENT_KEY_INFO, &mut key)
.map_err(|_| crypto::Error::KeyDerivationFailed)?;
Ok(Key::try_from_slice(&key)?)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn streaming_sha256_matches_known_vectors() {
for (input, expected) in [
(
"",
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
),
(
"abc",
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
),
(
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
"248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
),
] {
for chunk_size in [1, 7, 64] {
let mut hash = Sha256Hasher::new();
for chunk in input.as_bytes().chunks(chunk_size) {
hash.update(chunk);
}
let digest: String = hash
.finalize()
.iter()
.map(|byte| format!("{byte:02x}"))
.collect();
assert_eq!(digest, expected);
}
}
}
#[test]
fn payload_roundtrip() {
let key = generate_chat_key();
let encrypted = encrypt_payload(r#"{"text":"hello"}"#, &key).unwrap();
assert_eq!(
decrypt_payload(&encrypted.encrypted_data, &encrypted.header, &key).unwrap(),
r#"{"text":"hello"}"#
);
}
#[test]
fn field_roundtrip() {
let key = generate_chat_key();
let encrypted = encrypt_field_b64("file-name.png", &key).unwrap();
assert!(encrypted.starts_with("enc:v1:"));
assert_eq!(
decrypt_field_b64(&encrypted, &key).unwrap(),
"file-name.png"
);
}
#[test]
fn attachment_roundtrip() {
let key = generate_chat_key();
let encrypted = encrypt_attachment(b"attachment", &key, "session-id").unwrap();
assert_eq!(
decrypt_attachment(&encrypted, &key, "session-id").unwrap(),
b"attachment"
);
}
#[test]
fn attachment_key_matches_web_crypto() {
let key = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=";
let derived = attachment_key(key, "session-id").unwrap();
assert_eq!(
b64::encode(derived.as_bytes()),
"zUVLxgcjyPjOhZIESIXtjOaA8z9L7BCVIBG2wkar5NI="
);
}
}