use ::tls_codec::{Deserialize as _, Serialize as _}; use openmls::prelude::*; use openmls_basic_credential::SignatureKeyPair; use openmls_rust_crypto::OpenMlsRustCrypto; use serde::{Deserialize, Serialize}; use std::collections::HashMap; const SUITE: Ciphersuite = Ciphersuite::MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519; const MAX_SNAPSHOT: usize = 16 * 1024 * 1024; type EngineResult = Result; #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct Enrollment { pub device: String, pub key: Vec, pub package: Vec, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct GroupMember { pub device: String, pub key: Vec, } #[derive(Serialize, Deserialize)] struct Snapshot { version: u8, device: String, public_key: Vec, storage: Vec<(Vec, Vec)>, } pub struct Engine { provider: OpenMlsRustCrypto, device: String, public_key: Vec, } impl Engine { pub fn new(device: &str) -> EngineResult { if !valid_device(device) { return Err("invalid device id"); } let provider = OpenMlsRustCrypto::default(); let signer = SignatureKeyPair::new(SUITE.signature_algorithm()) .map_err(|_| "signer generation failed")?; signer .store(provider.storage()) .map_err(|_| "signer storage failed")?; Ok(Self { provider, device: device.to_owned(), public_key: signer.to_public_vec(), }) } pub fn restore(bytes: &[u8]) -> EngineResult { if bytes.len() > MAX_SNAPSHOT { return Err("state too large"); } let snapshot: Snapshot = serde_json::from_slice(bytes).map_err(|_| "invalid MLS state")?; if snapshot.version != 1 || !valid_device(&snapshot.device) || snapshot.public_key.len() != 32 { return Err("invalid MLS state"); } let provider = OpenMlsRustCrypto::default(); let count = snapshot.storage.len(); let storage: HashMap<_, _> = snapshot.storage.into_iter().collect(); if storage.len() != count { return Err("invalid MLS state"); } *provider .storage() .values .write() .map_err(|_| "state unavailable")? = storage; let result = Self { provider, device: snapshot.device, public_key: snapshot.public_key, }; result.signer()?; Ok(result) } pub fn snapshot(&self) -> EngineResult> { let storage = self .provider .storage() .values .read() .map_err(|_| "state unavailable")?; let snapshot = Snapshot { version: 1, device: self.device.clone(), public_key: self.public_key.clone(), storage: storage .iter() .map(|(key, value)| (key.clone(), value.clone())) .collect(), }; let encoded = serde_json::to_vec(&snapshot).map_err(|_| "state encoding failed")?; if encoded.len() > MAX_SNAPSHOT { return Err("state too large"); } Ok(encoded) } pub fn public_key(&self) -> &[u8] { &self.public_key } pub fn device(&self) -> &str { &self.device } pub fn key_package(&self) -> EngineResult> { let package = KeyPackage::builder() .build(SUITE, &self.provider, &self.signer()?, self.credential()) .map_err(|_| "key package creation failed")?; MlsMessageOut::from(package.key_package().clone()) .tls_serialize_detached() .map_err(|_| "key package encoding failed") } pub fn start( &self, group_id: &[u8], peer: &str, expected_key: &[u8], wire: &[u8], ) -> EngineResult> { let package = self.validate_package(peer, expected_key, wire)?; self.create_group(group_id, &[package]) } pub fn start_group(&self, group_id: &[u8], members: &[Enrollment]) -> EngineResult> { if members.len() > 31 { return Err("group device limit exceeded"); } let mut seen = std::collections::HashSet::new(); let mut packages = Vec::with_capacity(members.len()); for member in members { if !seen.insert(&member.device) { return Err("duplicate group device"); } packages.push(self.validate_package(&member.device, &member.key, &member.package)?); } self.create_group(group_id, &packages) } fn validate_package( &self, peer: &str, expected_key: &[u8], wire: &[u8], ) -> EngineResult { if wire.len() > 8192 || !valid_device(peer) { return Err("invalid key package"); } let message = MlsMessageIn::tls_deserialize_exact(wire).map_err(|_| "invalid key package")?; let MlsMessageBodyIn::KeyPackage(package) = message.extract() else { return Err("invalid key package"); }; let package = package .validate(self.provider.crypto(), ProtocolVersion::Mls10) .map_err(|_| "invalid key package")?; let leaf = package.leaf_node(); if peer == self.device || package.ciphersuite() != SUITE || expected_key.len() != 32 || !matches_device(leaf.credential(), peer) || leaf.signature_key().as_slice() != expected_key { return Err("unexpected peer identity"); } Ok(package) } fn create_group(&self, group_id: &[u8], packages: &[KeyPackage]) -> EngineResult> { let id = group_id_from(group_id)?; if self.load_group(&id)?.is_some() { return Err("conversation already exists"); } let config = MlsGroupCreateConfig::builder() .ciphersuite(SUITE) .use_ratchet_tree_extension(true) .build(); let signer = self.signer()?; let mut group = MlsGroup::new_with_group_id(&self.provider, &signer, &config, id, self.credential()) .map_err(|_| "conversation creation failed")?; if packages.is_empty() { return Ok(Vec::new()); } let (_, welcome, _) = group .add_members(&self.provider, &signer, packages) .map_err(|_| "peer enrollment failed")?; group .merge_pending_commit(&self.provider) .map_err(|_| "conversation commit failed")?; welcome .tls_serialize_detached() .map_err(|_| "welcome encoding failed") } pub fn join(&self, peer: &str, expected_key: &[u8], wire: &[u8]) -> EngineResult> { let staged = self.stage_welcome(peer, expected_key, wire)?; if staged.members().count() != 2 { return Err("unexpected conversation membership"); } self.accept_welcome(staged) } pub fn join_group( &self, id: &[u8], owner: &str, members: &[GroupMember], wire: &[u8], ) -> EngineResult> { let expected = group_id_from(id)?; if !(2..=32).contains(&members.len()) { return Err("invalid group device count"); } let roster: HashMap<_, _> = members .iter() .map(|member| (member.device.as_bytes(), member.key.as_slice())) .collect(); if roster.len() != members.len() || members .iter() .any(|member| !valid_device(&member.device) || member.key.len() != 32) { return Err("invalid group roster"); } let key = roster.get(owner.as_bytes()).ok_or("unknown group owner")?; let staged = self.stage_welcome(owner, key, wire)?; if staged.group_context().group_id() != &expected || staged.members().count() != roster.len() { return Err("unexpected group context"); } let mut seen = std::collections::HashSet::new(); for member in staged.members() { let device = member.credential.serialized_content(); if member.credential.credential_type() != CredentialType::Basic || roster.get(device).copied() != Some(member.signature_key.as_slice()) || !seen.insert(device.to_vec()) { return Err("unexpected group participant"); } } self.accept_welcome(staged) } fn stage_welcome( &self, peer: &str, expected_key: &[u8], wire: &[u8], ) -> EngineResult { if wire.len() > 65536 { return Err("invalid welcome"); } let message = MlsMessageIn::tls_deserialize_exact(wire).map_err(|_| "invalid welcome")?; let MlsMessageBodyIn::Welcome(welcome) = message.extract() else { return Err("invalid welcome"); }; if welcome.ciphersuite() != SUITE { return Err("unsupported MLS ciphersuite"); } let config = MlsGroupJoinConfig::builder() .use_ratchet_tree_extension(true) .build(); let staged = StagedWelcome::new_from_welcome(&self.provider, &config, welcome, None) .map_err(|_| "welcome rejected")?; let sender = staged .welcome_sender() .map_err(|_| "unknown welcome sender")?; if peer == self.device || expected_key.len() != 32 || !matches_device(sender.credential(), peer) || sender.signature_key().as_slice() != expected_key { return Err("unexpected peer identity"); } let own = staged.own_leaf_node().ok_or("missing local device")?; if !matches_device(own.credential(), &self.device) || own.signature_key().as_slice() != self.public_key { return Err("unexpected conversation membership"); } Ok(staged) } fn accept_welcome(&self, staged: StagedWelcome) -> EngineResult> { let id = staged.group_context().group_id(); group_id_from(id.as_slice())?; if self.load_group(id)?.is_some() { return Err("conversation already exists"); } let group = staged .into_group(&self.provider) .map_err(|_| "welcome rejected")?; Ok(group.group_id().as_slice().to_vec()) } pub fn encrypt( &self, id: &[u8], associated_data: &[u8], plaintext: &[u8], ) -> EngineResult> { let mut group = self .load_group(&group_id_from(id)?)? .ok_or("unknown conversation")?; group.set_aad(associated_data.to_vec()); group .create_message(&self.provider, &self.signer()?, plaintext) .map_err(|_| "encryption failed")? .tls_serialize_detached() .map_err(|_| "ciphertext encoding failed") } pub fn decrypt( &self, peer: &str, expected_key: &[u8], associated_data: &[u8], wire: &[u8], ) -> EngineResult> { self.decrypt_message(None, peer, expected_key, associated_data, wire) } pub fn decrypt_group( &self, id: &[u8], peer: &str, expected_key: &[u8], associated_data: &[u8], wire: &[u8], ) -> EngineResult> { self.decrypt_message( Some(&group_id_from(id)?), peer, expected_key, associated_data, wire, ) } fn decrypt_message( &self, expected_group: Option<&GroupId>, peer: &str, expected_key: &[u8], associated_data: &[u8], wire: &[u8], ) -> EngineResult> { let protocol = MlsMessageIn::tls_deserialize_exact(wire) .map_err(|_| "invalid ciphertext")? .try_into_protocol_message() .map_err(|_| "invalid ciphertext")?; if expected_group.is_some_and(|id| id != protocol.group_id()) { return Err("unexpected MLS group"); } let mut group = self .load_group(protocol.group_id())? .ok_or("unknown conversation")?; if !group.members().any(|member| { matches_device(&member.credential, peer) && member.signature_key == expected_key }) { return Err("unexpected peer identity"); } let processed = group .process_message(&self.provider, protocol) .map_err(|_| "ciphertext rejected")?; let Sender::Member(index) = processed.sender() else { return Err("unexpected message sender"); }; let member = group .members() .find(|member| &member.index == index) .ok_or("unknown sender")?; if peer == self.device || expected_key.len() != 32 || !matches_device(processed.credential(), peer) || member.signature_key != expected_key || processed.aad() != associated_data { return Err("unexpected message identity"); } let ProcessedMessageContent::ApplicationMessage(application) = processed.into_content() else { return Err("unexpected MLS content"); }; Ok(application.into_bytes()) } fn signer(&self) -> EngineResult { SignatureKeyPair::read( self.provider.storage(), &self.public_key, SUITE.signature_algorithm(), ) .ok_or("missing signing key") } fn credential(&self) -> CredentialWithKey { CredentialWithKey { credential: BasicCredential::new(self.device.as_bytes().to_vec()).into(), signature_key: self.public_key.clone().into(), } } fn load_group(&self, id: &GroupId) -> EngineResult> { MlsGroup::load(self.provider.storage(), id).map_err(|_| "conversation state unavailable") } } fn valid_device(id: &str) -> bool { id.len() == 36 && id.bytes().enumerate().all(|(i, b)| { if [8, 13, 18, 23].contains(&i) { b == b'-' } else { b.is_ascii_digit() || (b'a'..=b'f').contains(&b) } }) } fn group_id_from(bytes: &[u8]) -> EngineResult { if bytes.len() != 32 { return Err("invalid conversation id"); } Ok(GroupId::from_slice(bytes)) } fn matches_device(credential: &Credential, device: &str) -> bool { credential.credential_type() == CredentialType::Basic && credential.serialized_content() == device.as_bytes() }