use hide_identity::{IdentityLog, device_id};
use hide_mls::{
HideIdentityProvider, MAX_MLS_MESSAGE, MlsError, accept_from_trusted, client_for,
client_with_provider, decode_message, encode_message, sender_device, untrusted_members,
};
use hide_sign::SigningIdentity;
fn key() -> SigningIdentity {
SigningIdentity::generate().unwrap()
}
fn identity() -> (IdentityLog, SigningIdentity, SigningIdentity) {
let laptop = key();
let phone = key();
let recovery = key();
let mut log = IdentityLog::create(&laptop, "laptop", &recovery.verifying_key()).unwrap();
log.enrol(&laptop, &phone.verifying_key(), "phone").unwrap();
(log, laptop, phone)
}
#[test]
fn a_trusted_device_gets_a_client() {
let (log, laptop, _) = identity();
assert!(client_for(&log.membership(), &laptop).is_ok());
}
#[test]
fn an_oversized_message_is_refused_before_parsing() {
let oversized = vec![0u8; MAX_MLS_MESSAGE + 1];
assert!(matches!(
decode_message(&oversized),
Err(MlsError::MessageTooLarge)
));
}
#[test]
fn a_device_the_identity_does_not_know_is_refused() {
let (log, _, _) = identity();
let stranger = key();
assert!(matches!(
client_for(&log.membership(), &stranger),
Err(MlsError::UntrustedDevice)
));
}
#[test]
fn a_revoked_device_can_no_longer_get_a_client() {
let (mut log, laptop, phone) = identity();
log.revoke(&laptop, device_id(&phone.verifying_key()))
.unwrap();
assert!(matches!(
client_for(&log.membership(), &phone),
Err(MlsError::UntrustedDevice)
));
}
#[test]
fn two_devices_exchange_a_message() {
two_devices_exchange_a_message_impl();
}
#[test]
fn a_running_client_refuses_a_device_revoked_after_it_was_built() {
let (mut log, laptop, phone) = identity();
let provider = HideIdentityProvider::new(log.membership());
let alice = client_with_provider(provider.clone(), &laptop).unwrap();
let bob = client_for(&log.membership(), &phone).unwrap();
let kp = bob
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
log.revoke(&laptop, device_id(&phone.verifying_key()))
.unwrap();
provider.update(log.membership());
assert!(
!provider
.membership()
.contains(&device_id(&phone.verifying_key()))
);
let mut group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let added = group
.commit_builder()
.add_member(kp)
.and_then(|builder| builder.build());
assert!(
added.is_err(),
"a revoked device was admitted by a stale client"
);
}
fn two_devices_exchange_a_message_impl() {
let (log, laptop, phone) = identity();
let alice = client_for(&log.membership(), &laptop).unwrap();
let bob = client_for(&log.membership(), &phone).unwrap();
let mut group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let kp = bob
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
let commit = group
.commit_builder()
.add_member(kp)
.unwrap()
.build()
.unwrap();
group.apply_pending_commit().unwrap();
let (mut bobs, _) = bob
.join_group(None, &commit.welcome_messages[0], None)
.unwrap();
let sent = group
.encrypt_application_message(b"salut", Default::default())
.unwrap();
let received = bobs.process_incoming_message(sent).unwrap();
match &received {
hide_mls::Received::ApplicationMessage(m) => assert_eq!(m.data(), b"salut"),
other => panic!("unexpected message: {other:?}"),
}
}
#[test]
fn a_revoked_device_is_reported_as_stale_group_membership() {
let (mut log, laptop, phone) = identity();
let alice = client_for(&log.membership(), &laptop).unwrap();
let bob = client_for(&log.membership(), &phone).unwrap();
let mut group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let kp = bob
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
group
.commit_builder()
.add_member(kp)
.unwrap()
.build()
.unwrap();
group.apply_pending_commit().unwrap();
assert!(
untrusted_members(&group, &log.membership())
.unwrap()
.is_empty()
);
let phone_id = device_id(&phone.verifying_key());
log.revoke(&laptop, phone_id).unwrap();
assert_eq!(
untrusted_members(&group, &log.membership()).unwrap(),
vec![phone_id]
);
}
#[test]
fn a_message_from_a_revoked_device_is_rejected() {
let (mut log, laptop, phone) = identity();
let alice = client_for(&log.membership(), &laptop).unwrap();
let bob = client_for(&log.membership(), &phone).unwrap();
let mut group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let kp = bob
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
let commit = group
.commit_builder()
.add_member(kp)
.unwrap()
.build()
.unwrap();
group.apply_pending_commit().unwrap();
let (mut bobs, _) = bob
.join_group(None, &commit.welcome_messages[0], None)
.unwrap();
let sent = bobs
.encrypt_application_message(b"still trusted", Default::default())
.unwrap();
let received = group.process_incoming_message(sent).unwrap();
assert!(accept_from_trusted(&group, &received, &log.membership()).is_ok());
log.revoke(&laptop, device_id(&phone.verifying_key()))
.unwrap();
let sent = bobs
.encrypt_application_message(b"no longer trusted", Default::default())
.unwrap();
let received = group.process_incoming_message(sent).unwrap();
assert!(matches!(
accept_from_trusted(&group, &received, &log.membership()),
Err(MlsError::UntrustedSender)
));
}
#[test]
fn the_sender_device_is_recoverable_from_a_message() {
let (log, laptop, phone) = identity();
let alice = client_for(&log.membership(), &laptop).unwrap();
let bob = client_for(&log.membership(), &phone).unwrap();
let mut group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let kp = bob
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
let commit = group
.commit_builder()
.add_member(kp)
.unwrap()
.build()
.unwrap();
group.apply_pending_commit().unwrap();
let (mut bobs, _) = bob
.join_group(None, &commit.welcome_messages[0], None)
.unwrap();
let sent = bobs
.encrypt_application_message(b"from the phone", Default::default())
.unwrap();
let received = group.process_incoming_message(sent).unwrap();
assert_eq!(
sender_device(&group, &received).unwrap(),
Some(device_id(&phone.verifying_key()))
);
}
#[test]
fn a_message_round_trips_through_its_encoding() {
let (log, laptop, phone) = identity();
let alice = client_for(&log.membership(), &laptop).unwrap();
let bob = client_for(&log.membership(), &phone).unwrap();
let mut group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let kp = bob
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
let commit = group
.commit_builder()
.add_member(kp)
.unwrap()
.build()
.unwrap();
group.apply_pending_commit().unwrap();
let (mut bobs, _) = bob
.join_group(None, &commit.welcome_messages[0], None)
.unwrap();
let sent = group
.encrypt_application_message(b"over the wire", Default::default())
.unwrap();
let bytes = encode_message(&sent).unwrap();
let decoded = decode_message(&bytes).unwrap();
match bobs.process_incoming_message(decoded).unwrap() {
hide_mls::Received::ApplicationMessage(m) => assert_eq!(m.data(), b"over the wire"),
other => panic!("unexpected: {other:?}"),
}
}
#[test]
fn a_corrupted_message_is_refused() {
let (log, laptop, phone) = identity();
let alice = client_for(&log.membership(), &laptop).unwrap();
let bob = client_for(&log.membership(), &phone).unwrap();
let mut group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let kp = bob
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
let commit = group
.commit_builder()
.add_member(kp)
.unwrap()
.build()
.unwrap();
group.apply_pending_commit().unwrap();
let (mut bobs, _) = bob
.join_group(None, &commit.welcome_messages[0], None)
.unwrap();
let sent = group
.encrypt_application_message(b"tamper me", Default::default())
.unwrap();
let mut bytes = encode_message(&sent).unwrap();
let last = bytes.len() - 1;
bytes[last] ^= 1;
let refused = match decode_message(&bytes) {
Err(_) => true,
Ok(message) => bobs.process_incoming_message(message).is_err(),
};
assert!(refused, "a corrupted message was accepted");
}
#[test]
fn the_pq_status_is_stated_and_says_group_messages_are_classical() {
assert!(hide_mls::PQ_STATUS.contains("not post-quantum"));
assert!(hide_mls::PQ_STATUS.contains("Internet-Draft"));
}
fn rogue_client(
membership: &hide_identity::Membership,
credential: mls_rs::identity::Credential,
) -> mls_rs::Client<impl mls_rs::client_builder::MlsConfig + use<>> {
use mls_rs::{CipherSuite, CryptoProvider};
use mls_rs_core::crypto::CipherSuiteProvider;
let crypto = mls_rs_crypto_rustcrypto::RustCryptoProvider::default();
let suite = CipherSuite::CURVE25519_AES128;
let provider = crypto.cipher_suite_provider(suite).unwrap();
let (secret, public) = provider.signature_key_generate().unwrap();
mls_rs::Client::builder()
.identity_provider(hide_mls::HideIdentityProvider::new(membership.clone()))
.crypto_provider(crypto)
.signing_identity(
mls_rs::identity::SigningIdentity::new(credential, public),
secret,
suite,
)
.build()
}
#[test]
fn a_credential_that_merely_names_a_trusted_device_is_refused() {
let (log, laptop, _) = identity();
let alice = client_for(&log.membership(), &laptop).unwrap();
let mut group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let laptop_id = device_id(&laptop.verifying_key());
let mallory = rogue_client(
&log.membership(),
mls_rs::identity::basic::BasicCredential::new(laptop_id.to_vec()).into_credential(),
);
let kp = mallory
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
let refused = match group.commit_builder().add_member(kp) {
Err(_) => true,
Ok(builder) => builder.build().is_err(),
};
assert!(
refused,
"a bare device id is not a HIDE credential and must not be admitted"
);
}
#[test]
fn a_real_credential_transplanted_onto_another_mls_key_is_refused() {
let (log, laptop, phone) = identity();
let alice = client_for(&log.membership(), &laptop).unwrap();
let bob = client_for(&log.membership(), &phone).unwrap();
let mut group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let bobs_kp = bob
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
let bobs_credential = bobs_kp
.as_key_package()
.unwrap()
.signing_identity()
.credential
.clone();
let mallory = rogue_client(&log.membership(), bobs_credential);
let kp = mallory
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
let refused = match group.commit_builder().add_member(kp) {
Err(_) => true,
Ok(builder) => builder.build().is_err(),
};
assert!(
refused,
"a binding for one MLS key must not admit a different MLS key"
);
}
macro_rules! two_member_group {
() => {{
let (log, laptop, phone) = identity();
let provider = HideIdentityProvider::new(log.membership());
let alice = client_with_provider(provider.clone(), &laptop).unwrap();
let bob = client_for(&log.membership(), &phone).unwrap();
let mut alice_group = alice
.create_group(Default::default(), Default::default(), None)
.unwrap();
let kp = bob
.generate_key_package_message(Default::default(), Default::default(), None)
.unwrap();
let commit = alice_group
.commit_builder()
.add_member(kp)
.unwrap()
.build()
.unwrap();
alice_group.apply_pending_commit().unwrap();
let (bob_group, _) = bob
.join_group(None, &commit.welcome_messages[0], None)
.unwrap();
(log, laptop, phone, provider, alice_group, bob_group)
}};
}
fn hostile_commit<C: mls_rs::client_builder::MlsConfig>(
bob_group: &mut mls_rs::Group<C>,
) -> mls_rs::MlsMessage {
bob_group
.commit_builder()
.remove_member(0)
.unwrap()
.build()
.unwrap()
.commit_message()
.clone()
}
#[test]
fn a_revoked_device_cannot_commit_into_a_group_it_is_still_in() {
let (mut log, laptop, phone, provider, mut alice_group, mut bob_group) = two_member_group!();
let hostile = hostile_commit(&mut bob_group);
log.revoke(&laptop, device_id(&phone.verifying_key()))
.unwrap();
provider.update(log.membership());
assert!(
alice_group.process_incoming_message(hostile).is_err(),
"a revoked device's commit was applied by an honest member"
);
assert!(
alice_group.apply_pending_commit().is_err(),
"a refused commit was left pending"
);
assert_eq!(alice_group.roster().members().len(), 2);
}
#[test]
fn the_same_commit_is_applied_while_its_author_is_trusted() {
let (_log, _laptop, _phone, _provider, mut alice_group, mut bob_group) = two_member_group!();
let hostile = hostile_commit(&mut bob_group);
let received = alice_group
.process_incoming_message(hostile)
.expect("a trusted member's commit is processed");
let _ = alice_group.apply_pending_commit();
match received {
hide_mls::Received::Commit(description) => assert!(
matches!(
description.effect,
mls_rs::group::CommitEffect::Removed { .. }
),
"expected a removal, got {:?}",
description.effect
),
other => panic!("unexpected message: {other:?}"),
}
}