验证 OpenMLS 群组完整设备名单与新世代隔离

This commit is contained in:
xhgit committed 2026-11-14 08:38:49 +08:00
1 parent 636419e948
commit 1cae8b9953
5 files changed
+223 -6

No files matched your search

+116 -5
View File
@@ -10,6 +10,21 @@ const MAX_SNAPSHOT: usize = 16 * 1024 * 1024;
type EngineResult<T> = Result<T, &'static str>;
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Enrollment {
pub device: String,
pub key: Vec<u8>,
pub package: Vec<u8>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GroupMember {
pub device: String,
pub key: Vec<u8>,
}
#[derive(Serialize, Deserialize)]
struct Snapshot {
version: u8,
@@ -120,9 +135,33 @@ impl Engine {
expected_key: &[u8],
wire: &[u8],
) -> EngineResult<Vec<u8>> {
let id = group_id_from(group_id)?;
if self.load_group(&id)?.is_some() {
return Err("conversation already exists");
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<Vec<u8>> {
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<KeyPackage> {
if wire.len() > 8192 || !valid_device(peer) {
return Err("invalid key package");
}
let message =
MlsMessageIn::tls_deserialize_exact(wire).map_err(|_| "invalid key package")?;
@@ -141,6 +180,14 @@ impl Engine {
{
return Err("unexpected peer identity");
}
Ok(package)
}
fn create_group(&self, group_id: &[u8], packages: &[KeyPackage]) -> EngineResult<Vec<u8>> {
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)
@@ -149,8 +196,11 @@ impl Engine {
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, &[package])
.add_members(&self.provider, &signer, packages)
.map_err(|_| "peer enrollment failed")?;
group
.merge_pending_commit(&self.provider)
@@ -161,6 +211,64 @@ impl Engine {
}
pub fn join(&self, peer: &str, expected_key: &[u8], wire: &[u8]) -> EngineResult<Vec<u8>> {
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<Vec<u8>> {
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<StagedWelcome> {
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");
@@ -186,10 +294,13 @@ impl Engine {
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
|| staged.members().count() != 2
{
return Err("unexpected conversation membership");
}
Ok(staged)
}
fn accept_welcome(&self, staged: StagedWelcome) -> EngineResult<Vec<u8>> {
let id = staged.group_context().group_id();
group_id_from(id.as_slice())?;
if self.load_group(id)?.is_some() {