#[cfg(any(test, target_arch = "wasm32"))] mod engine; #[cfg(target_arch = "wasm32")] mod wasm; #[cfg(test)] mod tests { use ::tls_codec::{Deserialize as _, Serialize as _}; use openmls::prelude::*; use openmls_basic_credential::SignatureKeyPair; use openmls_rust_crypto::OpenMlsRustCrypto; #[cfg(target_arch = "wasm32")] use wasm_bindgen_test::wasm_bindgen_test; #[cfg(target_arch = "wasm32")] wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser); const SUITE: Ciphersuite = Ciphersuite::MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519; #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] #[cfg_attr(not(target_arch = "wasm32"), test)] fn group_roster_is_authenticated_and_can_be_replaced() { use crate::engine::{Engine, Enrollment, GroupMember}; let owner = Engine::new("00000000-0000-4000-8000-000000000001").unwrap(); let member = Engine::new("00000000-0000-4000-8000-000000000002").unwrap(); let removed = Engine::new("00000000-0000-4000-8000-000000000003").unwrap(); let enroll = |device: &Engine| Enrollment { device: device.device().into(), key: device.public_key().into(), package: device.key_package().unwrap(), }; let verify = |device: &Engine| GroupMember { device: device.device().into(), key: device.public_key().into(), }; let group = [7; 32]; let welcome = owner .start_group(&group, &[enroll(&member), enroll(&removed)]) .unwrap(); let roster = [verify(&owner), verify(&member), verify(&removed)]; let member_copy = Engine::restore(&member.snapshot().unwrap()).unwrap(); let mut wrong = [verify(&owner), verify(&member), verify(&removed)]; wrong[2].key.fill(0); assert!( member_copy .join_group(&group, owner.device(), &wrong, &welcome) .is_err() ); assert_eq!( member .join_group(&group, owner.device(), &roster, &welcome) .unwrap(), group ); assert_eq!( removed .join_group(&group, owner.device(), &roster, &welcome) .unwrap(), group ); let old = member.encrypt(&group, b"group-v1", b"first epoch").unwrap(); assert_eq!( removed .decrypt(member.device(), member.public_key(), b"group-v1", &old) .unwrap(), b"first epoch" ); let next = [8; 32]; let welcome = owner.start_group(&next, &[enroll(&member)]).unwrap(); let roster = [verify(&owner), verify(&member)]; assert_eq!( member .join_group(&next, owner.device(), &roster, &welcome) .unwrap(), next ); let fresh = owner.encrypt(&next, b"group-v2", b"after removal").unwrap(); assert!( member .decrypt_group(&group, owner.device(), owner.public_key(), b"group-v2", &fresh) .is_err() ); assert_eq!( member .decrypt_group(&next, owner.device(), owner.public_key(), b"group-v2", &fresh) .unwrap(), b"after removal" ); assert!( removed .decrypt(owner.device(), owner.public_key(), b"group-v2", &fresh) .is_err() ); } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] #[cfg_attr(not(target_arch = "wasm32"), test)] fn device_conversation_survives_restore() { use crate::engine::Engine; let alice_id = "c82d961b-aa65-4d44-9de8-1967d32ee8d3"; let bob_id = "346c8638-f422-471a-827d-d07a1bcf8ae8"; let alice = Engine::new(alice_id).unwrap(); let bob = Engine::new(bob_id).unwrap(); let group = [5; 32]; let package = bob.key_package().unwrap(); assert!(alice.start(&group, bob_id, &[0; 32], &package).is_err()); let welcome = alice .start(&group, bob_id, bob.public_key(), &package) .unwrap(); assert!( alice .start(&group, bob_id, bob.public_key(), &package) .is_err() ); let bob_backup = bob.snapshot().unwrap(); let wrong_key = Engine::restore(&bob_backup).unwrap(); assert!(wrong_key.join(alice_id, &[0; 32], &welcome).is_err()); let bob = Engine::restore(&bob_backup).unwrap(); assert_eq!(bob.device(), bob_id); assert_eq!( bob.join(alice_id, alice.public_key(), &welcome).unwrap(), group ); let alice = Engine::restore(&alice.snapshot().unwrap()).unwrap(); let message = alice.encrypt(&group, b"message-1", b"hello").unwrap(); let bob_backup = bob.snapshot().unwrap(); let wrong_aad = Engine::restore(&bob_backup).unwrap(); assert!( wrong_aad .decrypt(alice_id, alice.public_key(), b"message-2", &message) .is_err() ); let bob = Engine::restore(&bob_backup).unwrap(); assert_eq!( bob.decrypt(alice_id, alice.public_key(), b"message-1", &message) .unwrap(), b"hello" ); let bob = Engine::restore(&bob.snapshot().unwrap()).unwrap(); assert!( bob.decrypt(alice_id, alice.public_key(), b"message-1", &message) .is_err() ); let reply = bob.encrypt(&group, b"reply", b"hello back").unwrap(); assert_eq!( alice .decrypt(bob_id, bob.public_key(), b"reply", &reply) .unwrap(), b"hello back" ); } fn identity(id: &[u8]) -> (SignatureKeyPair, CredentialWithKey) { let signer = SignatureKeyPair::new(SUITE.signature_algorithm()).unwrap(); let credential = CredentialWithKey { credential: BasicCredential::new(id.to_vec()).into(), signature_key: signer.to_public_vec().into(), }; (signer, credential) } fn protocol_message(bytes: &[u8]) -> ProtocolMessage { MlsMessageIn::tls_deserialize_exact(bytes) .unwrap() .try_into_protocol_message() .unwrap() } fn deliver(group: &mut MlsGroup, provider: &OpenMlsRustCrypto, wire: &[u8]) -> Vec { let processed = group .process_message(provider, protocol_message(wire)) .unwrap(); let ProcessedMessageContent::ApplicationMessage(message) = processed.into_content() else { panic!("expected an application message"); }; message.into_bytes() } #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] #[cfg_attr(not(target_arch = "wasm32"), test)] fn messaging_and_removal() { let alice = OpenMlsRustCrypto::default(); let bob = OpenMlsRustCrypto::default(); let carol = OpenMlsRustCrypto::default(); let (alice_key, alice_credential) = identity(b"alice-test-device"); let (bob_key, bob_credential) = identity(b"bob-test-device"); let (carol_key, carol_credential) = identity(b"carol-test-device"); let bob_package = KeyPackage::builder() .build(SUITE, &bob, &bob_key, bob_credential) .unwrap(); let carol_package = KeyPackage::builder() .build(SUITE, &carol, &carol_key, carol_credential) .unwrap(); let config = MlsGroupCreateConfig::builder() .ciphersuite(SUITE) .use_ratchet_tree_extension(true) .build(); let join = MlsGroupJoinConfig::builder() .use_ratchet_tree_extension(true) .build(); let mut group = MlsGroup::new(&alice, &alice_key, &config, alice_credential).unwrap(); let (_, welcome, _) = group .add_members( &alice, &alice_key, &[ bob_package.key_package().clone(), carol_package.key_package().clone(), ], ) .unwrap(); group.merge_pending_commit(&alice).unwrap(); let encoded_welcome = welcome.tls_serialize_detached().unwrap(); let join_group = |provider: &OpenMlsRustCrypto| { let decoded = MlsMessageIn::tls_deserialize_exact(&encoded_welcome).unwrap(); let MlsMessageBodyIn::Welcome(welcome) = decoded.extract() else { panic!("expected a Welcome message"); }; StagedWelcome::new_from_welcome(provider, &join, welcome, None) .unwrap() .into_group(provider) .unwrap() }; let mut bob_group = join_group(&bob); let mut carol_group = join_group(&carol); let plaintext = b"xhchat test: end-to-end MLS payload"; let wire = group .create_message(&alice, &alice_key, plaintext) .unwrap() .tls_serialize_detached() .unwrap(); assert!(!wire.windows(plaintext.len()).any(|part| part == plaintext)); assert_eq!(deliver(&mut bob_group, &bob, &wire), plaintext); assert_eq!(deliver(&mut carol_group, &carol, &wire), plaintext); assert!( bob_group .process_message(&bob, protocol_message(&wire)) .is_err() ); let carol_index = group .members() .find(|member| member.credential.serialized_content() == b"carol-test-device") .expect("Carol is a member") .index; let (commit, _, _) = group .remove_members(&alice, &alice_key, &[carol_index]) .unwrap(); group.merge_pending_commit(&alice).unwrap(); let wire_commit = commit.tls_serialize_detached().unwrap(); let change = bob_group .process_message(&bob, protocol_message(&wire_commit)) .unwrap(); let ProcessedMessageContent::StagedCommitMessage(staged) = change.into_content() else { panic!("expected a Commit message"); }; bob_group.merge_staged_commit(&bob, *staged).unwrap(); let wire = bob_group .create_message(&bob, &bob_key, plaintext) .unwrap() .tls_serialize_detached() .unwrap(); assert_eq!(deliver(&mut group, &alice, &wire), plaintext); assert!( carol_group .process_message(&carol, protocol_message(&wire)) .is_err() ); } }