use std::sync::Mutex;
use openmls::prelude::*;
use openmls_basic_credential::SignatureKeyPair;
use serde::{Deserialize, Serialize};
use tls_codec::{Deserialize as TlsDeserialize, Serialize as TlsSerialize};
uniffi::setup_scaffolding!();
pub mod amf;
pub mod pdf;
pub mod primitives;
pub mod devlink;
pub mod provider;
pub mod callkey;
mod sealv3;
use provider::{UmberaProvider, LEGACY_SUITE, XWING_SUITE};
const CIPHERSUITE: Ciphersuite = LEGACY_SUITE;
#[uniffi::export]
pub fn mls_suite_legacy() -> u16 {
LEGACY_SUITE as u16
}
#[uniffi::export]
pub fn mls_suite_xwing() -> u16 {
XWING_SUITE as u16
}
fn suite_from(code: u16) -> R<Ciphersuite> {
match code {
c if c == LEGACY_SUITE as u16 => Ok(LEGACY_SUITE),
c if c == XWING_SUITE as u16 => Ok(XWING_SUITE),
c => Err(MlsError::Generic(format!("unsupported ciphersuite 0x{c:04x}"))),
}
}
#[derive(uniffi::Record)]
pub struct KeyPackageInfo {
pub ciphersuite: u16,
pub identity: Vec<u8>,
pub supports_xwing: bool,
}
#[uniffi::export]
pub fn key_package_info(key_package: Vec<u8>) -> R<KeyPackageInfo> {
let provider = UmberaProvider::default();
let kp = KeyPackageIn::tls_deserialize_exact(&key_package)
.mls()?
.validate(provider.crypto(), ProtocolVersion::Mls10)
.mls()?;
let leaf = kp.leaf_node();
Ok(KeyPackageInfo {
ciphersuite: kp.ciphersuite() as u16,
identity: leaf.credential().serialized_content().to_vec(),
supports_xwing: supports_suite(leaf.capabilities(), XWING_SUITE),
})
}
pub const MAX_GROUP_MEMBERS: usize = LEGACY_LEAF_CAP;
pub const LEGACY_LEAF_CAP: usize = 20;
pub const MAX_GROUP_LEAVES: usize = 100;
pub const MULTI_DEVICE_CAPABILITY: u16 = 0xF0D1;
pub const XWING_CAPABILITY: u16 = 0xF0D2;
const OUR_SUITES: [Ciphersuite; 4] = [
LEGACY_SUITE,
Ciphersuite::MLS_128_DHKEMP256_AES128GCM_SHA256_P256,
Ciphersuite::MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519,
XWING_SUITE,
];
fn our_capabilities() -> Capabilities {
Capabilities::new(
None,
Some(&OUR_SUITES),
Some(&[ExtensionType::Unknown(MULTI_DEVICE_CAPABILITY), ExtensionType::Unknown(XWING_CAPABILITY)]),
None,
None,
)
}
fn has_xwing_marker(caps: &Capabilities) -> bool {
caps.extensions().contains(&ExtensionType::Unknown(XWING_CAPABILITY))
}
fn supports_suite(caps: &Capabilities, suite: Ciphersuite) -> bool {
match suite {
XWING_SUITE => has_xwing_marker(caps) && caps.ciphersuites().iter().any(|c| *c == VerifiableCiphersuite::from(suite)),
_ => caps.ciphersuites().iter().any(|c| *c == VerifiableCiphersuite::from(suite)),
}
}
fn all_leaves_support(group: &MlsGroup, suite: Ciphersuite) -> R<bool> {
let v = serde_json::to_value(group.export_ratchet_tree()).mls()?;
let nodes: Vec<Option<Node>> = serde_json::from_value(v).mls()?;
Ok(nodes.iter().all(|n| match n {
Some(Node::LeafNode(l)) => supports_suite(l.capabilities(), suite),
_ => true,
}))
}
fn has_marker(caps: &Capabilities) -> bool {
caps.extensions().contains(&ExtensionType::Unknown(MULTI_DEVICE_CAPABILITY))
}
fn all_leaves_marked(group: &MlsGroup) -> R<bool> {
let v = serde_json::to_value(group.export_ratchet_tree()).mls()?;
let nodes: Vec<Option<Node>> = serde_json::from_value(v).mls()?;
Ok(nodes.iter().all(|n| match n {
Some(Node::LeafNode(l)) => has_marker(l.capabilities()),
_ => true,
}))
}
fn leaf_limit(group: &MlsGroup, added_all_marked: bool) -> R<usize> {
Ok(if added_all_marked && all_leaves_marked(group)? { MAX_GROUP_LEAVES } else { LEGACY_LEAF_CAP })
}
#[derive(Debug, thiserror::Error, uniffi::Error)]
pub enum MlsError {
#[error("mls: {0}")]
Generic(String),
}
type R<T> = Result<T, MlsError>;
trait IntoMls<T> {
fn mls(self) -> R<T>;
}
impl<T, E: std::fmt::Display> IntoMls<T> for Result<T, E> {
fn mls(self) -> R<T> {
self.map_err(|e| MlsError::Generic(e.to_string()))
}
}
#[uniffi::export]
pub fn quant_address(classical_hex: String, dilithium_hex: String) -> Result<String, MlsError> {
let cb = unhex(classical_hex.trim())?;
let db = unhex(dilithium_hex.trim())?;
let mut h = blake3::Hasher::new();
h.update(&cb);
h.update(&db);
let raw = h.finalize();
let raw = raw.as_bytes(); let cs = blake3::hash(raw);
let mut payload = Vec::with_capacity(36);
payload.extend_from_slice(raw);
payload.extend_from_slice(&cs.as_bytes()[..4]);
Ok(format!("quant{}", bs58::encode(payload).into_string()))
}
#[derive(uniffi::Record)]
pub struct CommitBundle {
pub commit: Vec<u8>,
pub welcome: Vec<u8>,
}
#[derive(uniffi::Enum)]
pub enum Incoming {
Application {
plaintext: Vec<u8>,
sender_identity: Vec<u8>,
},
CommitApplied,
CommitRejected,
Proposal,
Ignored,
}
#[derive(uniffi::Record)]
pub struct MemberInfo {
pub leaf_index: u32,
pub identity: Vec<u8>,
}
#[derive(Serialize, Deserialize)]
struct PersistState {
identity: Vec<u8>,
signer: Vec<u8>, storage: Vec<(String, String)>, }
#[derive(uniffi::Object)]
pub struct MlsClient {
inner: Mutex<Inner>,
}
struct Inner {
provider: UmberaProvider,
signer: SignatureKeyPair,
identity: Vec<u8>,
}
fn hex(b: &[u8]) -> String {
b.iter().map(|x| format!("{:02x}", x)).collect()
}
fn unhex(s: &str) -> R<Vec<u8>> {
fn nib(c: u8) -> Option<u8> {
match c {
b'0'..=b'9' => Some(c - b'0'),
b'a'..=b'f' => Some(c - b'a' + 10),
b'A'..=b'F' => Some(c - b'A' + 10),
_ => None,
}
}
let b = s.as_bytes();
if b.len() % 2 != 0 {
return Err(MlsError::Generic("hex: odd length".into()));
}
b.chunks_exact(2)
.map(|p| match (nib(p[0]), nib(p[1])) {
(Some(h), Some(l)) => Ok(h << 4 | l),
_ => Err(MlsError::Generic("hex: invalid digit".into())),
})
.collect()
}
impl MlsClient {
fn lock(&self) -> std::sync::MutexGuard<'_, Inner> {
self.inner.lock().unwrap_or_else(|poisoned| {
self.inner.clear_poison();
poisoned.into_inner()
})
}
fn cwk(g: &Inner) -> CredentialWithKey {
let credential = BasicCredential::new(g.identity.clone());
CredentialWithKey {
credential: credential.into(),
signature_key: g.signer.public().into(),
}
}
fn load_group(g: &Inner, gid: &[u8]) -> R<MlsGroup> {
let mut group = MlsGroup::load(g.provider.storage(), &GroupId::from_slice(gid))
.mls()?
.ok_or_else(|| MlsError::Generic("group not found".into()))?;
if *group.configuration().sender_ratchet_configuration() != sender_ratchet_config() {
let cfg = with_our_ratchet(group.configuration())?;
group.set_configuration(g.provider.storage(), &cfg).mls()?;
}
Ok(group)
}
}
pub const OUT_OF_ORDER_TOLERANCE: u32 = 1000;
pub const MAXIMUM_FORWARD_DISTANCE: u32 = 1000;
fn sender_ratchet_config() -> SenderRatchetConfiguration {
SenderRatchetConfiguration::new(OUT_OF_ORDER_TOLERANCE, MAXIMUM_FORWARD_DISTANCE)
}
fn with_our_ratchet(c: &MlsGroupJoinConfig) -> R<MlsGroupJoinConfig> {
let mut v = serde_json::to_value(c).mls()?;
let obj = v
.as_object_mut()
.ok_or_else(|| MlsError::Generic("join config: not an object".into()))?;
obj.insert(
"sender_ratchet_configuration".into(),
serde_json::to_value(sender_ratchet_config()).mls()?,
);
serde_json::from_value(v).mls()
}
#[uniffi::export]
impl MlsClient {
#[uniffi::constructor]
pub fn new(identity: Vec<u8>) -> R<std::sync::Arc<MlsClient>> {
let provider = UmberaProvider::default();
let signer = SignatureKeyPair::new(CIPHERSUITE.signature_algorithm()).mls()?;
signer.store(provider.storage()).mls()?;
Ok(std::sync::Arc::new(MlsClient {
inner: Mutex::new(Inner {
provider,
signer,
identity,
}),
}))
}
#[uniffi::constructor]
pub fn from_state(blob: Vec<u8>) -> R<std::sync::Arc<MlsClient>> {
let st: PersistState = serde_json::from_slice(&blob).mls()?;
let provider = UmberaProvider::default();
{
let store = provider.storage();
let mut map = store
.values
.write()
.map_err(|_| MlsError::Generic("storage lock".into()))?;
for (k, v) in &st.storage {
map.insert(unhex(k)?, unhex(v)?);
}
}
let signer = SignatureKeyPair::tls_deserialize_exact(&st.signer).mls()?;
Ok(std::sync::Arc::new(MlsClient {
inner: Mutex::new(Inner {
provider,
signer,
identity: st.identity,
}),
}))
}
pub fn spawn_same_identity(&self) -> R<std::sync::Arc<MlsClient>> {
let g = self.lock();
let provider = UmberaProvider::default();
let signer = SignatureKeyPair::tls_deserialize_exact(&g.signer.tls_serialize_detached().mls()?).mls()?;
signer.store(provider.storage()).mls()?;
Ok(std::sync::Arc::new(MlsClient {
inner: Mutex::new(Inner {
provider,
signer,
identity: g.identity.clone(),
}),
}))
}
pub fn export_state(&self) -> R<Vec<u8>> {
let g = self.lock();
let storage: Vec<(String, String)> = {
let map = g
.provider
.storage()
.values
.read()
.map_err(|_| MlsError::Generic("storage lock".into()))?;
map.iter().map(|(k, v)| (hex(k), hex(v))).collect()
};
let st = PersistState {
identity: g.identity.clone(),
signer: g.signer.tls_serialize_detached().mls()?,
storage,
};
serde_json::to_vec(&st).mls()
}
pub fn signature_public_key(&self) -> Vec<u8> {
self.lock().signer.public().to_vec()
}
pub fn generate_key_package(&self) -> R<Vec<u8>> {
self.generate_key_package_for(CIPHERSUITE as u16)
}
pub fn generate_key_package_for(&self, suite: u16) -> R<Vec<u8>> {
let suite = suite_from(suite)?;
let g = self.lock();
let bundle = KeyPackage::builder()
.leaf_node_capabilities(our_capabilities())
.build(suite, &g.provider, &g.signer, Self::cwk(&g))
.mls()?;
bundle.key_package().tls_serialize_detached().mls()
}
pub fn group_ciphersuite(&self, gid: Vec<u8>) -> R<u16> {
let g = self.lock();
let group = Self::load_group(&g, &gid)?;
Ok(group.ciphersuite() as u16)
}
pub fn members_support(&self, gid: Vec<u8>, suite: u16) -> R<bool> {
let suite = suite_from(suite)?;
let g = self.lock();
let group = Self::load_group(&g, &gid)?;
all_leaves_support(&group, suite)
}
pub fn create_group(&self, gid: Vec<u8>) -> R<()> {
self.create_group_for(gid, CIPHERSUITE as u16)
}
pub fn create_group_for(&self, gid: Vec<u8>, suite: u16) -> R<()> {
let suite = suite_from(suite)?;
let g = self.lock();
let cfg = MlsGroupCreateConfig::builder()
.ciphersuite(suite)
.capabilities(our_capabilities())
.use_ratchet_tree_extension(true)
.sender_ratchet_configuration(sender_ratchet_config())
.build();
MlsGroup::new_with_group_id(
&g.provider,
&g.signer,
&cfg,
GroupId::from_slice(&gid),
Self::cwk(&g),
)
.mls()?;
Ok(())
}
pub fn add_members(&self, gid: Vec<u8>, key_packages: Vec<Vec<u8>>) -> R<CommitBundle> {
let g = self.lock();
let mut group = Self::load_group(&g, &gid)?;
let current = group.members().count();
if current + key_packages.len() > MAX_GROUP_LEAVES {
return Err(MlsError::Generic(format!(
"group member cap ({}) exceeded: {} + {}",
MAX_GROUP_LEAVES,
current,
key_packages.len()
)));
}
let mut kps = Vec::with_capacity(key_packages.len());
for raw in &key_packages {
let kp_in = KeyPackageIn::tls_deserialize_exact(raw).mls()?;
let kp = kp_in
.validate(g.provider.crypto(), ProtocolVersion::Mls10)
.mls()?;
if kp.ciphersuite() != group.ciphersuite() {
return Err(MlsError::Generic(format!(
"key package ciphersuite 0x{:04x} does not match the group (0x{:04x})",
kp.ciphersuite() as u16,
group.ciphersuite() as u16
)));
}
kps.push(kp);
}
let added_marked = kps.iter().all(|k| has_marker(k.leaf_node().capabilities()));
let limit = leaf_limit(&group, added_marked)?;
if current + kps.len() > limit {
return Err(MlsError::Generic(format!(
"group member cap ({}) exceeded: {} + {} (members on an old app version keep the cap at {})",
limit,
current,
kps.len(),
LEGACY_LEAF_CAP
)));
}
let (commit, welcome, _info) = group.add_members(&g.provider, &g.signer, &kps).mls()?;
group.merge_pending_commit(&g.provider).mls()?;
Ok(CommitBundle {
commit: commit.tls_serialize_detached().mls()?,
welcome: welcome.tls_serialize_detached().mls()?,
})
}
pub fn remove_members(&self, gid: Vec<u8>, leaf_indices: Vec<u32>) -> R<Vec<u8>> {
let g = self.lock();
let mut group = Self::load_group(&g, &gid)?;
let idx: Vec<LeafNodeIndex> = leaf_indices.iter().map(|i| LeafNodeIndex::new(*i)).collect();
let (commit, _welcome, _info) = group.remove_members(&g.provider, &g.signer, &idx).mls()?;
group.merge_pending_commit(&g.provider).mls()?;
commit.tls_serialize_detached().mls()
}
pub fn update_keys(&self, gid: Vec<u8>) -> R<Vec<u8>> {
let g = self.lock();
let mut group = Self::load_group(&g, &gid)?;
let bundle = group
.self_update(&g.provider, &g.signer, LeafNodeParameters::builder().with_capabilities(our_capabilities()).build())
.mls()?;
let commit = bundle.commit().tls_serialize_detached().mls()?;
group.merge_pending_commit(&g.provider).mls()?;
Ok(commit)
}
pub fn process_welcome(&self, welcome_bytes: Vec<u8>) -> R<Vec<u8>> {
let g = self.lock();
let msg = MlsMessageIn::tls_deserialize_exact(&welcome_bytes).mls()?;
let welcome = match msg.extract() {
MlsMessageBodyIn::Welcome(w) => w,
_ => return Err(MlsError::Generic("not a welcome".into())),
};
let cfg = MlsGroupJoinConfig::builder()
.use_ratchet_tree_extension(true)
.sender_ratchet_configuration(sender_ratchet_config())
.build();
let staged = StagedWelcome::build_from_welcome(&g.provider, &cfg, welcome)
.mls()?
.skip_lifetime_validation()
.build()
.mls()?;
let group = staged.into_group(&g.provider).mls()?;
Ok(group.group_id().as_slice().to_vec())
}
pub fn encrypt(&self, gid: Vec<u8>, plaintext: Vec<u8>) -> R<Vec<u8>> {
let g = self.lock();
let mut group = Self::load_group(&g, &gid)?;
let out = group.create_message(&g.provider, &g.signer, &plaintext).mls()?;
out.tls_serialize_detached().mls()
}
pub fn process_incoming(&self, gid: Vec<u8>, message: Vec<u8>) -> R<Incoming> {
self.process_incoming_inner(gid, message, None).map(|(inc, _)| inc)
}
pub fn process_incoming_with_sender(
&self,
gid: Vec<u8>,
message: Vec<u8>,
allowed_handshake_senders: Option<Vec<Vec<u8>>>,
) -> R<IncomingWithSender> {
self.process_incoming_inner(gid, message, allowed_handshake_senders.as_deref())
.map(|(incoming, sender)| IncomingWithSender { incoming, sender })
}
pub fn export_secret(&self, gid: Vec<u8>, label: String, length: u32) -> R<Vec<u8>> {
let g = self.lock();
let group = Self::load_group(&g, &gid)?;
group
.export_secret(g.provider.crypto(), &label, &[], length as usize)
.mls()
}
pub fn epoch(&self, gid: Vec<u8>) -> R<u64> {
let g = self.lock();
let group = Self::load_group(&g, &gid)?;
Ok(group.epoch().as_u64())
}
pub fn members(&self, gid: Vec<u8>) -> R<Vec<MemberInfo>> {
let g = self.lock();
let group = Self::load_group(&g, &gid)?;
let mut out = Vec::new();
for m in group.members() {
out.push(MemberInfo {
leaf_index: m.index.u32(),
identity: m.credential.serialized_content().to_vec(),
});
}
Ok(out)
}
pub fn leaf_limit(&self, gid: Vec<u8>) -> R<u32> {
let g = self.lock();
let group = Self::load_group(&g, &gid)?;
Ok(leaf_limit(&group, true)? as u32)
}
pub fn own_leaf_marked(&self, gid: Vec<u8>) -> R<bool> {
let g = self.lock();
let group = Self::load_group(&g, &gid)?;
Ok(group
.own_leaf_node()
.map(|l| has_marker(l.capabilities()) && supports_suite(l.capabilities(), XWING_SUITE))
.unwrap_or(false))
}
}
#[cfg(test)]
impl MlsClient {
pub(crate) fn legacy_key_package(&self) -> R<Vec<u8>> {
let g = self.lock();
let store_caps = Capabilities::new(None, Some(&OUR_SUITES), None, None, None);
let bundle = KeyPackage::builder()
.leaf_node_capabilities(store_caps)
.build(CIPHERSUITE, &g.provider, &g.signer, Self::cwk(&g))
.mls()?;
bundle.key_package().tls_serialize_detached().mls()
}
}
#[derive(Debug, Clone, PartialEq, Eq, uniffi::Record)]
pub struct SenderLeaf {
pub leaf_index: u32,
pub identity: Vec<u8>,
}
#[derive(uniffi::Record)]
pub struct IncomingWithSender {
pub incoming: Incoming,
pub sender: Option<SenderLeaf>,
}
impl MlsClient {
fn process_incoming_inner(
&self,
gid: Vec<u8>,
message: Vec<u8>,
allowed_handshake_senders: Option<&[Vec<u8>]>,
) -> R<(Incoming, Option<SenderLeaf>)> {
let g = self.lock();
let mut group = Self::load_group(&g, &gid)?;
let msg = MlsMessageIn::tls_deserialize_exact(&message).mls()?;
let protocol = match msg.try_into_protocol_message() {
Ok(p) => p,
Err(_) => return Ok((Incoming::Ignored, None)),
};
let processed = match group.process_message(&g.provider, protocol) {
Ok(p) => p,
Err(_) => return Ok((Incoming::Ignored, None)),
};
let sender_identity = processed.credential().serialized_content().to_vec();
let sender = match processed.sender() {
Sender::Member(leaf) => Some(SenderLeaf { leaf_index: leaf.u32(), identity: sender_identity.clone() }),
_ => None,
};
let handshake_ok = match allowed_handshake_senders {
None => true,
Some(list) => sender.as_ref().map(|s| list.iter().any(|a| a == &s.identity)).unwrap_or(false),
};
match processed.into_content() {
ProcessedMessageContent::StagedCommitMessage(_) if !handshake_ok => Ok((Incoming::CommitRejected, sender)),
ProcessedMessageContent::ProposalMessage(_) | ProcessedMessageContent::ExternalJoinProposalMessage(_)
if !handshake_ok => Ok((Incoming::Ignored, sender)),
ProcessedMessageContent::ApplicationMessage(app) => Ok((Incoming::Application {
plaintext: app.into_bytes(),
sender_identity,
}, sender)),
ProcessedMessageContent::StagedCommitMessage(staged) => {
let current = group.members().count();
let adds = staged.add_proposals().count();
let removes = staged.remove_proposals().count();
let resulting = current.saturating_add(adds).saturating_sub(removes);
let added_marked = staged
.add_proposals()
.all(|p| has_marker(p.add_proposal().key_package().leaf_node().capabilities()));
let limit = if resulting > LEGACY_LEAF_CAP { leaf_limit(&group, added_marked)? } else { LEGACY_LEAF_CAP };
if resulting > limit {
return Ok((Incoming::CommitRejected, sender));
}
group.merge_staged_commit(&g.provider, *staged).mls()?;
Ok((Incoming::CommitApplied, sender))
}
ProcessedMessageContent::ProposalMessage(_)
| ProcessedMessageContent::ExternalJoinProposalMessage(_) => Ok((Incoming::Proposal, sender)),
ProcessedMessageContent::OwnPrivateMessage | ProcessedMessageContent::OwnPendingCommit => {
Ok((Incoming::Ignored, None))
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn panic_under_lock_does_not_disable_the_core() {
let gid = b"poison-recovery-group-0001".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
alice.create_group(gid.clone()).unwrap();
let pk = alice.signature_public_key();
let a = alice.clone();
let r = std::thread::spawn(move || {
let _g = a.lock();
panic!("panic while parsing a foreign frame");
})
.join();
assert!(r.is_err());
assert!(alice.inner.is_poisoned(), "the check must start with a poisoned lock");
assert_eq!(alice.signature_public_key(), pk);
assert!(!alice.inner.is_poisoned());
assert_eq!(alice.members(gid.clone()).unwrap().len(), 1);
assert!(!alice.encrypt(gid.clone(), b"hello".to_vec()).unwrap().is_empty());
assert!(!alice.export_state().unwrap().is_empty());
}
#[test]
fn unhex_rejects_malformed_without_panic() {
assert_eq!(unhex("00ff7A").unwrap(), vec![0x00, 0xff, 0x7a]);
assert!(unhex("").unwrap().is_empty());
for bad in ["0", "abc", "zz", "a\u{e9}b", "\u{e9}\u{e9}", "\u{1F600}", "0g", " 0"] {
assert!(unhex(bad).is_err(), "{bad:?}");
}
assert!(quant_address("abc".into(), "00".into()).is_err());
assert!(quant_address("a\u{e9}b".into(), "00".into()).is_err());
let blob = br#"{"identity":[1],"signer":[],"storage":[["abc","00"]]}"#.to_vec();
assert!(MlsClient::from_state(blob).is_err());
let blob = br#"{"identity":[1],"signer":[],"storage":[["a\u00e9b","00"]]}"#.to_vec();
assert!(MlsClient::from_state(blob).is_err());
assert!(MlsClient::from_state(vec![0xff, 0xff, 0xff, 0xff]).is_err());
}
#[test]
fn leaf_cap_depends_on_every_member_running_the_new_core() {
let gid = b"cap-multidevice-group-0001".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
alice.create_group(gid.clone()).unwrap();
assert!(alice.own_leaf_marked(gid.clone()).unwrap());
let bob = MlsClient::new(b"bob".to_vec()).unwrap();
let b = alice.add_members(gid.clone(), vec![bob.legacy_key_package().unwrap()]).unwrap();
bob.process_welcome(b.welcome).unwrap();
assert!(!bob.own_leaf_marked(gid.clone()).unwrap());
assert_eq!(alice.leaf_limit(gid.clone()).unwrap(), LEGACY_LEAF_CAP as u32);
let carol = MlsClient::new(b"carol".to_vec()).unwrap();
let c = alice.add_members(gid.clone(), vec![carol.generate_key_package().unwrap()]).unwrap();
carol.process_welcome(c.welcome).unwrap();
assert!(matches!(bob.process_incoming(gid.clone(), c.commit).unwrap(), Incoming::CommitApplied));
for i in 4..=LEGACY_LEAF_CAP {
let m = MlsClient::new(format!("m{i}").into_bytes()).unwrap();
let cb = alice.add_members(gid.clone(), vec![m.generate_key_package().unwrap()]).unwrap();
for peer in [&bob, &carol] {
assert!(matches!(peer.process_incoming(gid.clone(), cb.commit.clone()).unwrap(), Incoming::CommitApplied));
}
}
let pc = MlsClient::new(b"pc".to_vec()).unwrap();
let pc_kp = pc.generate_key_package().unwrap();
assert!(alice.add_members(gid.clone(), vec![pc_kp.clone()]).is_err());
let up = bob.update_keys(gid.clone()).unwrap();
assert!(bob.own_leaf_marked(gid.clone()).unwrap());
assert!(matches!(alice.process_incoming(gid.clone(), up.clone()).unwrap(), Incoming::CommitApplied));
assert!(matches!(carol.process_incoming(gid.clone(), up).unwrap(), Incoming::CommitApplied));
assert_eq!(alice.leaf_limit(gid.clone()).unwrap(), MAX_GROUP_LEAVES as u32);
let cb = alice.add_members(gid.clone(), vec![pc_kp]).unwrap();
for peer in [&bob, &carol] {
assert!(matches!(peer.process_incoming(gid.clone(), cb.commit.clone()).unwrap(), Incoming::CommitApplied));
}
pc.process_welcome(cb.welcome).unwrap();
assert_eq!(bob.members(gid.clone()).unwrap().len(), LEGACY_LEAF_CAP + 1);
let old = MlsClient::new(b"old".to_vec()).unwrap();
assert!(alice.add_members(gid.clone(), vec![old.legacy_key_package().unwrap()]).is_err());
let evil = {
let g = alice.inner.lock().unwrap();
let mut group = MlsClient::load_group(&g, &gid).unwrap();
let kp = KeyPackageIn::tls_deserialize_exact(&old.legacy_key_package().unwrap())
.unwrap()
.validate(g.provider.crypto(), ProtocolVersion::Mls10)
.unwrap();
let (commit, _w, _i) = group.add_members(&g.provider, &g.signer, &[kp]).unwrap();
commit.tls_serialize_detached().unwrap()
};
assert!(matches!(bob.process_incoming(gid.clone(), evil).unwrap(), Incoming::CommitRejected));
}
#[test]
fn hundred_leaves_when_all_members_are_new() {
let gid = b"cap-multidevice-group-0100".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
alice.create_group(gid.clone()).unwrap();
let kps: Vec<Vec<u8>> = (2..=MAX_GROUP_LEAVES)
.map(|i| MlsClient::new(format!("d{i}").into_bytes()).unwrap().generate_key_package().unwrap())
.collect();
alice.add_members(gid.clone(), kps).unwrap();
assert_eq!(alice.members(gid.clone()).unwrap().len(), MAX_GROUP_LEAVES);
let extra = MlsClient::new(b"d101".to_vec()).unwrap().generate_key_package().unwrap();
assert!(alice.add_members(gid, vec![extra]).is_err());
}
fn app_bytes(inc: Incoming) -> Vec<u8> {
app_parts(inc).0
}
fn app_parts(inc: Incoming) -> (Vec<u8>, Vec<u8>) {
match inc {
Incoming::Application {
plaintext,
sender_identity,
} => (plaintext, sender_identity),
_ => panic!("expected application message"),
}
}
#[test]
fn full_group_roundtrip() {
let gid = b"group-id-0123456789-abcdef-0001".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
let bob = MlsClient::new(b"bob".to_vec()).unwrap();
let carol = MlsClient::new(b"carol".to_vec()).unwrap();
alice.create_group(gid.clone()).unwrap();
let bob_kp = bob.generate_key_package().unwrap();
let bundle = alice.add_members(gid.clone(), vec![bob_kp]).unwrap();
let joined = bob.process_welcome(bundle.welcome).unwrap();
assert_eq!(joined, gid, "bob joined the right group");
let ct = alice.encrypt(gid.clone(), b"hello bob".to_vec()).unwrap();
let got = app_bytes(bob.process_incoming(gid.clone(), ct).unwrap());
assert_eq!(got, b"hello bob");
let ct2 = bob.encrypt(gid.clone(), b"hi alice".to_vec()).unwrap();
let got2 = app_bytes(alice.process_incoming(gid.clone(), ct2).unwrap());
assert_eq!(got2, b"hi alice");
let carol_kp = carol.generate_key_package().unwrap();
let bundle2 = alice.add_members(gid.clone(), vec![carol_kp]).unwrap();
matches!(
bob.process_incoming(gid.clone(), bundle2.commit).unwrap(),
Incoming::CommitApplied
);
carol.process_welcome(bundle2.welcome).unwrap();
assert_eq!(alice.members(gid.clone()).unwrap().len(), 3);
let ct3 = alice.encrypt(gid.clone(), b"welcome carol".to_vec()).unwrap();
let to_bob = app_bytes(bob.process_incoming(gid.clone(), ct3.clone()).unwrap());
let to_carol = app_bytes(carol.process_incoming(gid.clone(), ct3).unwrap());
assert_eq!(to_bob, b"welcome carol");
assert_eq!(to_carol, b"welcome carol");
let blob = alice.export_state().unwrap();
let alice2 = MlsClient::from_state(blob).unwrap();
let ct4 = alice2.encrypt(gid.clone(), b"after reload".to_vec()).unwrap();
let got4 = app_bytes(bob.process_incoming(gid.clone(), ct4).unwrap());
assert_eq!(got4, b"after reload");
}
#[test]
fn commits_and_proposals_carry_the_sender_leaf() {
let gid = b"sender-leaf-group-id-0123456789ab".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
let bob = MlsClient::new(b"bob".to_vec()).unwrap();
let carol = MlsClient::new(b"carol".to_vec()).unwrap();
alice.create_group(gid.clone()).unwrap();
let b1 = alice.add_members(gid.clone(), vec![bob.generate_key_package().unwrap()]).unwrap();
bob.process_welcome(b1.welcome).unwrap();
let b2 = alice.add_members(gid.clone(), vec![carol.generate_key_package().unwrap()]).unwrap();
let r = bob.process_incoming_with_sender(gid.clone(), b2.commit, None).unwrap();
let (inc, sender) = (r.incoming, r.sender);
assert!(matches!(inc, Incoming::CommitApplied));
let s = sender.expect("commit sender leaf");
assert_eq!(s.identity, b"alice".to_vec());
assert_eq!(s.leaf_index, 0, "alice created the group: leaf 0");
carol.process_welcome(b2.welcome).unwrap();
let up = bob.update_keys(gid.clone()).unwrap();
let r2 = carol.process_incoming_with_sender(gid.clone(), up.clone(), None).unwrap();
let (inc2, s2) = (r2.incoming, r2.sender);
assert!(matches!(alice.process_incoming(gid.clone(), up).unwrap(), Incoming::CommitApplied));
assert!(matches!(inc2, Incoming::CommitApplied));
let s2 = s2.expect("bob commit sender");
assert_eq!(s2.identity, b"bob".to_vec());
assert_eq!(s2.leaf_index, 1);
let ct = carol.encrypt(gid.clone(), b"hi".to_vec()).unwrap();
let r3 = alice.process_incoming_with_sender(gid.clone(), ct, None).unwrap();
let (inc3, s3) = (r3.incoming, r3.sender);
let (_, id) = app_parts(inc3);
let s3 = s3.unwrap();
assert_eq!(s3.identity, id);
assert_eq!(s3.identity, b"carol".to_vec());
assert_eq!(s3.leaf_index, 2);
let (inc4, s4) = alice
.process_incoming_with_sender(gid.clone(), vec![0u8; 8], None)
.map_or((Incoming::Ignored, None), |x| (x.incoming, x.sender));
assert!(matches!(inc4, Incoming::Ignored));
assert!(s4.is_none());
}
#[test]
fn handshake_sender_guard_rejects_commit_of_other_leaf() {
let gid = b"sender-guard-group-id-0123456789a".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
let bob = MlsClient::new(b"bob".to_vec()).unwrap();
let carol = MlsClient::new(b"carol".to_vec()).unwrap();
alice.create_group(gid.clone()).unwrap();
let b1 = alice.add_members(gid.clone(), vec![bob.generate_key_package().unwrap()]).unwrap();
bob.process_welcome(b1.welcome).unwrap();
let b2 = alice.add_members(gid.clone(), vec![carol.generate_key_package().unwrap()]).unwrap();
carol.process_welcome(b2.welcome).unwrap();
bob.process_incoming(gid.clone(), b2.commit).unwrap();
let up = alice.update_keys(gid.clone()).unwrap();
let e0 = carol.epoch(gid.clone()).unwrap();
let r = carol.process_incoming_with_sender(gid.clone(), up.clone(), Some(vec![b"bob".to_vec()])).unwrap();
assert!(matches!(r.incoming, Incoming::CommitRejected));
assert_eq!(r.sender.unwrap().identity, b"alice".to_vec());
assert_eq!(carol.epoch(gid.clone()).unwrap(), e0, "rejected commit must not advance the epoch");
let r0 = bob.process_incoming_with_sender(gid.clone(), up.clone(), Some(vec![])).unwrap();
assert!(matches!(r0.incoming, Incoming::CommitRejected));
assert_eq!(bob.epoch(gid.clone()).unwrap(), e0);
let up2 = bob.update_keys(gid.clone()).unwrap();
let r2 = carol.process_incoming_with_sender(gid.clone(), up2, Some(vec![b"bob".to_vec()])).unwrap();
assert!(matches!(r2.incoming, Incoming::CommitApplied));
assert_eq!(carol.epoch(gid.clone()).unwrap(), e0 + 1);
let ct = bob.encrypt(gid.clone(), b"hi".to_vec()).unwrap();
let r3 = carol.process_incoming_with_sender(gid.clone(), ct, Some(vec![b"alice".to_vec()])).unwrap();
let (pt, id) = app_parts(r3.incoming);
assert_eq!(pt, b"hi".to_vec());
assert_eq!(id, b"bob".to_vec());
}
#[test]
fn application_messages_carry_the_authenticated_sender() {
let gid = b"sender-auth-group-id-01234567890".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
let bob = MlsClient::new(b"bob".to_vec()).unwrap();
let carol = MlsClient::new(b"carol".to_vec()).unwrap();
alice.create_group(gid.clone()).unwrap();
let bundle = alice
.add_members(gid.clone(), vec![bob.generate_key_package().unwrap()])
.unwrap();
bob.process_welcome(bundle.welcome).unwrap();
let bundle2 = alice
.add_members(gid.clone(), vec![carol.generate_key_package().unwrap()])
.unwrap();
assert!(matches!(
bob.process_incoming(gid.clone(), bundle2.commit).unwrap(),
Incoming::CommitApplied
));
carol.process_welcome(bundle2.welcome).unwrap();
let forged = br#"{"sender":"alice","t":"role","content":"bob|ADMIN"}"#.to_vec();
let ct = bob.encrypt(gid.clone(), forged.clone()).unwrap();
let (plaintext, sender) = app_parts(carol.process_incoming(gid.clone(), ct).unwrap());
assert_eq!(plaintext, forged, "payload still decrypts verbatim");
assert_eq!(sender, b"bob".to_vec(), "identity is the authenticated sender");
assert_ne!(sender, b"alice".to_vec(), "impersonation must not be possible");
let ct2 = alice.encrypt(gid.clone(), b"hi".to_vec()).unwrap();
let (_, sender2) = app_parts(carol.process_incoming(gid.clone(), ct2).unwrap());
assert_eq!(sender2, b"alice".to_vec());
}
#[test]
fn member_cap_enforced_at_crypto_layer() {
let gid = b"cap-test-group-id-0123456789-001".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
alice.create_group(gid.clone()).unwrap();
let bob = MlsClient::new(b"bob".to_vec()).unwrap();
let bob_kp = bob.legacy_key_package().unwrap();
let b = alice.add_members(gid.clone(), vec![bob_kp]).unwrap();
bob.process_welcome(b.welcome).unwrap();
for i in 3..=MAX_GROUP_MEMBERS {
let m = MlsClient::new(format!("m{}", i).into_bytes()).unwrap();
let kp = m.generate_key_package().unwrap();
let cb = alice.add_members(gid.clone(), vec![kp]).unwrap();
assert!(matches!(
bob.process_incoming(gid.clone(), cb.commit).unwrap(),
Incoming::CommitApplied
));
}
assert_eq!(alice.members(gid.clone()).unwrap().len(), MAX_GROUP_MEMBERS);
assert_eq!(bob.members(gid.clone()).unwrap().len(), MAX_GROUP_MEMBERS);
let evil = MlsClient::new(b"member-21".to_vec()).unwrap();
let evil_kp = evil.generate_key_package().unwrap();
assert!(
alice.add_members(gid.clone(), vec![evil_kp.clone()]).is_err(),
"honest admin must refuse to add the (cap+1)-th member"
);
let evil_commit = {
let g = alice.inner.lock().unwrap();
let mut group = MlsClient::load_group(&g, &gid).unwrap();
let kp_in = KeyPackageIn::tls_deserialize_exact(&evil_kp).unwrap();
let kp = kp_in
.validate(g.provider.crypto(), ProtocolVersion::Mls10)
.unwrap();
let (commit, _welcome, _info) =
group.add_members(&g.provider, &g.signer, &[kp]).unwrap();
commit.tls_serialize_detached().unwrap()
};
let epoch_before = bob.epoch(gid.clone()).unwrap();
assert!(
matches!(
bob.process_incoming(gid.clone(), evil_commit).unwrap(),
Incoming::CommitRejected
),
"honest member must reject an over-cap Commit"
);
assert_eq!(bob.epoch(gid.clone()).unwrap(), epoch_before);
assert_eq!(bob.members(gid.clone()).unwrap().len(), MAX_GROUP_MEMBERS);
}
#[test]
fn xwing_group_full_life() {
let x = mls_suite_xwing();
let gid = b"xwing-group-0123456789abcdef0001".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
let bob = MlsClient::new(b"bob".to_vec()).unwrap();
let carol = MlsClient::new(b"carol".to_vec()).unwrap();
alice.create_group_for(gid.clone(), x).unwrap();
assert_eq!(alice.group_ciphersuite(gid.clone()).unwrap(), x);
let kp = bob.generate_key_package_for(x).unwrap();
let info = key_package_info(kp.clone()).unwrap();
assert_eq!(info.ciphersuite, x);
assert_eq!(info.identity, b"bob".to_vec());
assert!(info.supports_xwing);
let b = alice.add_members(gid.clone(), vec![kp]).unwrap();
assert_eq!(bob.process_welcome(b.welcome).unwrap(), gid);
assert_eq!(bob.group_ciphersuite(gid.clone()).unwrap(), x);
let ct = alice.encrypt(gid.clone(), b"pq hello".to_vec()).unwrap();
assert_eq!(app_bytes(bob.process_incoming(gid.clone(), ct).unwrap()), b"pq hello");
let ct = bob.encrypt(gid.clone(), b"pq back".to_vec()).unwrap();
assert_eq!(app_bytes(alice.process_incoming(gid.clone(), ct).unwrap()), b"pq back");
let c = alice.add_members(gid.clone(), vec![carol.generate_key_package_for(x).unwrap()]).unwrap();
assert!(matches!(bob.process_incoming(gid.clone(), c.commit).unwrap(), Incoming::CommitApplied));
carol.process_welcome(c.welcome).unwrap();
let up = carol.update_keys(gid.clone()).unwrap();
for p in [&alice, &bob] {
assert!(matches!(p.process_incoming(gid.clone(), up.clone()).unwrap(), Incoming::CommitApplied));
}
let s = [&alice, &bob, &carol].map(|p| p.export_secret(gid.clone(), "conf".into(), 32).unwrap());
assert!(s[0] == s[1] && s[1] == s[2]);
assert!(alice.members_support(gid.clone(), x).unwrap());
let bob_leaf = alice.members(gid.clone()).unwrap().into_iter().find(|m| m.identity == b"bob").unwrap().leaf_index;
let rm = alice.remove_members(gid.clone(), vec![bob_leaf]).unwrap();
assert!(matches!(carol.process_incoming(gid.clone(), rm).unwrap(), Incoming::CommitApplied));
let carol2 = MlsClient::from_state(carol.export_state().unwrap()).unwrap();
let ct = carol2.encrypt(gid.clone(), b"after reload".to_vec()).unwrap();
assert_eq!(app_bytes(alice.process_incoming(gid.clone(), ct).unwrap()), b"after reload");
assert_eq!(carol2.group_ciphersuite(gid.clone()).unwrap(), x);
}
#[test]
fn regroup_to_xwing_keeps_leaf_signature_keys() {
let (l, x) = (mls_suite_legacy(), mls_suite_xwing());
let gid = b"regroup-group-0123456789abcdef01".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
let bob = MlsClient::new(b"bob".to_vec()).unwrap();
alice.create_group(gid.clone()).unwrap();
let b = alice.add_members(gid.clone(), vec![bob.generate_key_package_for(l).unwrap()]).unwrap();
bob.process_welcome(b.welcome).unwrap();
let sig = bob.sibling_sign(gid.clone(), b"bob".to_vec(), b"alice".to_vec()).unwrap();
let bob2 = bob.spawn_same_identity().unwrap();
assert_eq!(bob2.signature_public_key(), bob.signature_public_key());
let kp = bob2.generate_key_package_for(x).unwrap();
let alice2 = alice.spawn_same_identity().unwrap();
alice2.create_group_for(gid.clone(), x).unwrap();
let w = alice2.add_members(gid.clone(), vec![kp]).unwrap().welcome;
assert_eq!(bob2.process_welcome(w).unwrap(), gid);
assert_eq!(bob2.group_ciphersuite(gid.clone()).unwrap(), x);
let ct = bob2.encrypt(gid.clone(), b"after regroup".to_vec()).unwrap();
assert_eq!(app_bytes(alice2.process_incoming(gid.clone(), ct).unwrap()), b"after regroup");
let sig2 = alice2.sibling_sign(gid.clone(), b"bob".to_vec(), b"alice".to_vec()).unwrap();
assert!(alice2.sibling_verify(gid.clone(), b"bob".to_vec(), b"alice".to_vec(), sig, sig2).unwrap());
}
#[test]
fn suites_do_not_mix() {
let (l, x) = (mls_suite_legacy(), mls_suite_xwing());
let gid = b"suite-mix-group-0123456789abcd01".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
let bob = MlsClient::new(b"bob".to_vec()).unwrap();
alice.create_group_for(gid.clone(), x).unwrap();
let legacy = bob.generate_key_package_for(l).unwrap();
assert_eq!(key_package_info(legacy.clone()).unwrap().ciphersuite, l);
assert!(key_package_info(legacy.clone()).unwrap().supports_xwing);
assert!(alice.add_members(gid.clone(), vec![legacy]).is_err());
assert_eq!(alice.epoch(gid.clone()).unwrap(), 0);
let gid2 = b"suite-mix-group-0123456789abcd02".to_vec();
alice.create_group(gid2.clone()).unwrap();
assert_eq!(alice.group_ciphersuite(gid2.clone()).unwrap(), l);
assert!(alice.add_members(gid2.clone(), vec![bob.generate_key_package_for(x).unwrap()]).is_err());
assert!(alice.generate_key_package_for(0x0002).is_err());
let old = MlsClient::new(b"old".to_vec()).unwrap();
let b = alice.add_members(gid2.clone(), vec![old.legacy_key_package().unwrap()]).unwrap();
old.process_welcome(b.welcome).unwrap();
assert!(!alice.members_support(gid2.clone(), x).unwrap());
assert!(!old.own_leaf_marked(gid2.clone()).unwrap());
let up = old.update_keys(gid2.clone()).unwrap();
assert!(matches!(alice.process_incoming(gid2.clone(), up).unwrap(), Incoming::CommitApplied));
assert!(alice.members_support(gid2.clone(), x).unwrap());
assert!(old.own_leaf_marked(gid2).unwrap());
}
#[test]
fn xwing_hundred_leaves_and_sizes() {
let x = mls_suite_xwing();
let gid = b"xwing-cap-group-0123456789abcd01".to_vec();
let alice = MlsClient::new(b"alice".to_vec()).unwrap();
alice.create_group_for(gid.clone(), x).unwrap();
let peers: Vec<_> = (2..=MAX_GROUP_LEAVES).map(|i| MlsClient::new(format!("d{i}").into_bytes()).unwrap()).collect();
let kps: Vec<Vec<u8>> = peers.iter().map(|p| p.generate_key_package_for(x).unwrap()).collect();
let kp_len = kps[0].len();
let b = alice.add_members(gid.clone(), kps).unwrap();
assert_eq!(alice.members(gid.clone()).unwrap().len(), MAX_GROUP_LEAVES);
peers[0].process_welcome(b.welcome.clone()).unwrap();
let up = peers[0].update_keys(gid.clone()).unwrap();
eprintln!("X-Wing: KeyPackage {kp_len} B, Welcome for {} leaves {} B, Commit with path {} B", MAX_GROUP_LEAVES, b.welcome.len(), up.len());
assert!(b.welcome.len() * 16 / 9 < 1024 * 1024);
let extra = MlsClient::new(b"d101".to_vec()).unwrap().generate_key_package_for(x).unwrap();
assert!(alice.add_members(gid, vec![extra]).is_err());
}
#[test]
fn quant_address_matches_backend() {
let got = quant_address(
"0374e364c795619762574ae2f1fb5b75".to_string(),
"cafebabedeadbeef00112233".to_string(),
)
.unwrap();
assert_eq!(got, "quant2dcE7nu1UsMEi4wqzzsj92SUDGbMJaYCyEhwxBpcPbcHNRbU4X");
}
}