201 lines
7.6 KiB
Rust
201 lines
7.6 KiB
Rust
#[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 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<u8> {
|
|
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()
|
|
);
|
|
}
|
|
}
|