From 1e05d7a3afcb1aa67ecc623c970771bbdb2378fe Mon Sep 17 00:00:00 2001 From: xhgit Date: Fri, 13 Nov 2026 18:31:29 +0800 Subject: [PATCH] =?UTF-8?q?=E5=B0=81=E8=A3=85=E4=B8=A4=E8=AE=BE=E5=A4=87?= =?UTF-8?q?=20MLS=20=E5=AE=A2=E6=88=B7=E7=AB=AF=E5=BC=95=E6=93=8E=E4=B8=8E?= =?UTF-8?q?=E7=8A=B6=E6=80=81=E6=81=A2=E5=A4=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crypto/Cargo.lock | 2 + crypto/Cargo.toml | 2 + crypto/README.md | 9 ++ crypto/src/engine.rs | 307 +++++++++++++++++++++++++++++++++++++++++++ crypto/src/lib.rs | 63 +++++++++ crypto/src/wasm.rs | 61 +++++++++ docs/progress.md | 4 + 7 files changed, 448 insertions(+) create mode 100644 crypto/src/engine.rs create mode 100644 crypto/src/wasm.rs diff --git a/crypto/Cargo.lock b/crypto/Cargo.lock index ab8b2b1..1d7bbad 100644 --- a/crypto/Cargo.lock +++ b/crypto/Cargo.lock @@ -2081,6 +2081,8 @@ dependencies = [ "openmls", "openmls_basic_credential", "openmls_rust_crypto", + "serde", + "serde_json", "tls_codec", "wasm-bindgen", "wasm-bindgen-test", diff --git a/crypto/Cargo.toml b/crypto/Cargo.toml index d7eedb9..fbdd294 100644 --- a/crypto/Cargo.toml +++ b/crypto/Cargo.toml @@ -12,6 +12,8 @@ openmls = { version = "=0.9.2", features = ["js"] } openmls_basic_credential = "=0.6.0" openmls_rust_crypto = "=0.6.0" tls_codec = "=0.5.0" +serde = { version = "1", features = ["derive"] } +serde_json = "1" [target.'cfg(target_arch = "wasm32")'.dependencies] getrandom = { version = "0.2", features = ["js"] } diff --git a/crypto/README.md b/crypto/README.md index e87a06a..cfe50d0 100644 --- a/crypto/README.md +++ b/crypto/README.md @@ -5,3 +5,12 @@ 在本目录使用 Rust 1.95 运行 `cargo test --locked` 执行原生验证。浏览器验证需安装 Rust 的 `wasm32-unknown-unknown` 目标、wasm-bindgen-cli 0.2.130 和与本机 Chrome 匹配的 ChromeDriver。将 ChromeDriver 放入 PATH 或设置 CHROMEDRIVER,再执行 `cargo test --locked --target wasm32-unknown-unknown`。 用例用独立的三个客户端加入同一 MLS 群,使用 TLS 编码传输 Welcome、应用消息和移除 Commit。验证接收者能解密,重复消息被拒绝,且被移除的客户端无法解密新世代消息。 + +WASM 导出 `DeviceMls`,负责生成密钥包、创建和加入两设备会话、绑定应用关联数据,以及处理消息。调用方需先独立验证设备公钥。MLS 快照包含私钥和会话秘密,调用方须在本机加密保存。每次操作从已保存快照恢复,成功后原子提交新快照和待发封包或接收游标。失败时丢弃该实例。 + +使用下列命令生成浏览器绑定。构建输出存放于 `target`。 + +```sh +cargo build --locked --release --target wasm32-unknown-unknown +wasm-bindgen --target web --out-dir target/web target/wasm32-unknown-unknown/release/xhchat_mls_check.wasm +``` diff --git a/crypto/src/engine.rs b/crypto/src/engine.rs new file mode 100644 index 0000000..05bcaf1 --- /dev/null +++ b/crypto/src/engine.rs @@ -0,0 +1,307 @@ +use ::tls_codec::{Deserialize as _, Serialize as _}; +use openmls::prelude::*; +use openmls_basic_credential::SignatureKeyPair; +use openmls_rust_crypto::OpenMlsRustCrypto; +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; + +const SUITE: Ciphersuite = Ciphersuite::MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519; +const MAX_SNAPSHOT: usize = 16 * 1024 * 1024; + +type EngineResult = Result; + +#[derive(Serialize, Deserialize)] +struct Snapshot { + version: u8, + device: String, + public_key: Vec, + storage: Vec<(Vec, Vec)>, +} + +pub struct Engine { + provider: OpenMlsRustCrypto, + device: String, + public_key: Vec, +} + +impl Engine { + pub fn new(device: &str) -> EngineResult { + if !valid_device(device) { + return Err("invalid device id"); + } + let provider = OpenMlsRustCrypto::default(); + let signer = SignatureKeyPair::new(SUITE.signature_algorithm()) + .map_err(|_| "signer generation failed")?; + signer + .store(provider.storage()) + .map_err(|_| "signer storage failed")?; + Ok(Self { + provider, + device: device.to_owned(), + public_key: signer.to_public_vec(), + }) + } + + pub fn restore(bytes: &[u8]) -> EngineResult { + if bytes.len() > MAX_SNAPSHOT { + return Err("state too large"); + } + let snapshot: Snapshot = serde_json::from_slice(bytes).map_err(|_| "invalid MLS state")?; + if snapshot.version != 1 + || !valid_device(&snapshot.device) + || snapshot.public_key.len() != 32 + { + return Err("invalid MLS state"); + } + let provider = OpenMlsRustCrypto::default(); + let count = snapshot.storage.len(); + let storage: HashMap<_, _> = snapshot.storage.into_iter().collect(); + if storage.len() != count { + return Err("invalid MLS state"); + } + *provider + .storage() + .values + .write() + .map_err(|_| "state unavailable")? = storage; + let result = Self { + provider, + device: snapshot.device, + public_key: snapshot.public_key, + }; + result.signer()?; + Ok(result) + } + + pub fn snapshot(&self) -> EngineResult> { + let storage = self + .provider + .storage() + .values + .read() + .map_err(|_| "state unavailable")?; + let snapshot = Snapshot { + version: 1, + device: self.device.clone(), + public_key: self.public_key.clone(), + storage: storage + .iter() + .map(|(key, value)| (key.clone(), value.clone())) + .collect(), + }; + let encoded = serde_json::to_vec(&snapshot).map_err(|_| "state encoding failed")?; + if encoded.len() > MAX_SNAPSHOT { + return Err("state too large"); + } + Ok(encoded) + } + + pub fn public_key(&self) -> &[u8] { + &self.public_key + } + + pub fn device(&self) -> &str { + &self.device + } + + pub fn key_package(&self) -> EngineResult> { + let package = KeyPackage::builder() + .build(SUITE, &self.provider, &self.signer()?, self.credential()) + .map_err(|_| "key package creation failed")?; + MlsMessageOut::from(package.key_package().clone()) + .tls_serialize_detached() + .map_err(|_| "key package encoding failed") + } + + pub fn start( + &self, + group_id: &[u8], + peer: &str, + expected_key: &[u8], + wire: &[u8], + ) -> EngineResult> { + let id = group_id_from(group_id)?; + if self.load_group(&id)?.is_some() { + return Err("conversation already exists"); + } + let message = + MlsMessageIn::tls_deserialize_exact(wire).map_err(|_| "invalid key package")?; + let MlsMessageBodyIn::KeyPackage(package) = message.extract() else { + return Err("invalid key package"); + }; + let package = package + .validate(self.provider.crypto(), ProtocolVersion::Mls10) + .map_err(|_| "invalid key package")?; + let leaf = package.leaf_node(); + if peer == self.device + || package.ciphersuite() != SUITE + || expected_key.len() != 32 + || !matches_device(leaf.credential(), peer) + || leaf.signature_key().as_slice() != expected_key + { + return Err("unexpected peer identity"); + } + let config = MlsGroupCreateConfig::builder() + .ciphersuite(SUITE) + .use_ratchet_tree_extension(true) + .build(); + let signer = self.signer()?; + let mut group = + MlsGroup::new_with_group_id(&self.provider, &signer, &config, id, self.credential()) + .map_err(|_| "conversation creation failed")?; + let (_, welcome, _) = group + .add_members(&self.provider, &signer, &[package]) + .map_err(|_| "peer enrollment failed")?; + group + .merge_pending_commit(&self.provider) + .map_err(|_| "conversation commit failed")?; + welcome + .tls_serialize_detached() + .map_err(|_| "welcome encoding failed") + } + + pub fn join(&self, peer: &str, expected_key: &[u8], wire: &[u8]) -> EngineResult> { + let message = MlsMessageIn::tls_deserialize_exact(wire).map_err(|_| "invalid welcome")?; + let MlsMessageBodyIn::Welcome(welcome) = message.extract() else { + return Err("invalid welcome"); + }; + if welcome.ciphersuite() != SUITE { + return Err("unsupported MLS ciphersuite"); + } + let config = MlsGroupJoinConfig::builder() + .use_ratchet_tree_extension(true) + .build(); + let staged = StagedWelcome::new_from_welcome(&self.provider, &config, welcome, None) + .map_err(|_| "welcome rejected")?; + let sender = staged + .welcome_sender() + .map_err(|_| "unknown welcome sender")?; + if peer == self.device + || expected_key.len() != 32 + || !matches_device(sender.credential(), peer) + || sender.signature_key().as_slice() != expected_key + { + return Err("unexpected peer identity"); + } + 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"); + } + let id = staged.group_context().group_id(); + group_id_from(id.as_slice())?; + if self.load_group(id)?.is_some() { + return Err("conversation already exists"); + } + let group = staged + .into_group(&self.provider) + .map_err(|_| "welcome rejected")?; + Ok(group.group_id().as_slice().to_vec()) + } + + pub fn encrypt( + &self, + id: &[u8], + associated_data: &[u8], + plaintext: &[u8], + ) -> EngineResult> { + let mut group = self + .load_group(&group_id_from(id)?)? + .ok_or("unknown conversation")?; + group.set_aad(associated_data.to_vec()); + group + .create_message(&self.provider, &self.signer()?, plaintext) + .map_err(|_| "encryption failed")? + .tls_serialize_detached() + .map_err(|_| "ciphertext encoding failed") + } + + pub fn decrypt( + &self, + peer: &str, + expected_key: &[u8], + associated_data: &[u8], + wire: &[u8], + ) -> EngineResult> { + let protocol = MlsMessageIn::tls_deserialize_exact(wire) + .map_err(|_| "invalid ciphertext")? + .try_into_protocol_message() + .map_err(|_| "invalid ciphertext")?; + let mut group = self + .load_group(protocol.group_id())? + .ok_or("unknown conversation")?; + if !group.members().any(|member| { + matches_device(&member.credential, peer) && member.signature_key == expected_key + }) { + return Err("unexpected peer identity"); + } + let processed = group + .process_message(&self.provider, protocol) + .map_err(|_| "ciphertext rejected")?; + let Sender::Member(index) = processed.sender() else { + return Err("unexpected message sender"); + }; + let member = group + .members() + .find(|member| &member.index == index) + .ok_or("unknown sender")?; + if peer == self.device + || expected_key.len() != 32 + || !matches_device(processed.credential(), peer) + || member.signature_key != expected_key + || processed.aad() != associated_data + { + return Err("unexpected message identity"); + } + let ProcessedMessageContent::ApplicationMessage(application) = processed.into_content() + else { + return Err("unexpected MLS content"); + }; + Ok(application.into_bytes()) + } + + fn signer(&self) -> EngineResult { + SignatureKeyPair::read( + self.provider.storage(), + &self.public_key, + SUITE.signature_algorithm(), + ) + .ok_or("missing signing key") + } + + fn credential(&self) -> CredentialWithKey { + CredentialWithKey { + credential: BasicCredential::new(self.device.as_bytes().to_vec()).into(), + signature_key: self.public_key.clone().into(), + } + } + + fn load_group(&self, id: &GroupId) -> EngineResult> { + MlsGroup::load(self.provider.storage(), id).map_err(|_| "conversation state unavailable") + } +} + +fn valid_device(id: &str) -> bool { + id.len() == 36 + && id.bytes().enumerate().all(|(i, b)| { + if [8, 13, 18, 23].contains(&i) { + b == b'-' + } else { + b.is_ascii_digit() || (b'a'..=b'f').contains(&b) + } + }) +} + +fn group_id_from(bytes: &[u8]) -> EngineResult { + if bytes.len() != 32 { + return Err("invalid conversation id"); + } + Ok(GroupId::from_slice(bytes)) +} + +fn matches_device(credential: &Credential, device: &str) -> bool { + credential.credential_type() == CredentialType::Basic + && credential.serialized_content() == device.as_bytes() +} diff --git a/crypto/src/lib.rs b/crypto/src/lib.rs index 98e45ce..e56cd97 100644 --- a/crypto/src/lib.rs +++ b/crypto/src/lib.rs @@ -1,3 +1,9 @@ +#[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 _}; @@ -12,6 +18,63 @@ mod tests { 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 { diff --git a/crypto/src/wasm.rs b/crypto/src/wasm.rs new file mode 100644 index 0000000..4a8dfda --- /dev/null +++ b/crypto/src/wasm.rs @@ -0,0 +1,61 @@ +use crate::engine::Engine; +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +pub struct DeviceMls(Engine); + +#[wasm_bindgen] +impl DeviceMls { + #[wasm_bindgen(constructor)] + pub fn new(device: &str) -> Result { + Ok(Self(Engine::new(device).map_err(JsError::new)?)) + } + + pub fn restore(state: &[u8]) -> Result { + Ok(Self(Engine::restore(state).map_err(JsError::new)?)) + } + + pub fn snapshot(&self) -> Result, JsError> { + self.0.snapshot().map_err(JsError::new) + } + + pub fn device(&self) -> String { + self.0.device().to_owned() + } + + pub fn public_key(&self) -> Vec { + self.0.public_key().to_vec() + } + + pub fn key_package(&self) -> Result, JsError> { + self.0.key_package().map_err(JsError::new) + } + + pub fn start( + &self, + id: &[u8], + peer: &str, + key: &[u8], + wire: &[u8], + ) -> Result, JsError> { + self.0.start(id, peer, key, wire).map_err(JsError::new) + } + + pub fn join(&self, peer: &str, key: &[u8], wire: &[u8]) -> Result, JsError> { + self.0.join(peer, key, wire).map_err(JsError::new) + } + + pub fn encrypt(&self, id: &[u8], aad: &[u8], plaintext: &[u8]) -> Result, JsError> { + self.0.encrypt(id, aad, plaintext).map_err(JsError::new) + } + + pub fn decrypt( + &self, + peer: &str, + key: &[u8], + aad: &[u8], + wire: &[u8], + ) -> Result, JsError> { + self.0.decrypt(peer, key, aad, wire).map_err(JsError::new) + } +} diff --git a/docs/progress.md b/docs/progress.md index 5eb83a4..20dad72 100644 --- a/docs/progress.md +++ b/docs/progress.md @@ -40,3 +40,7 @@ Web 和 Electron 共用 Vue 客户端,独立接入同一 Go API。真实 Postg ## 设备目录与密钥包 服务端已实现联系人设备目录、设备签名校验和一次性 MLS KeyPackage 领取。Compose 集成测试验证陌生人隔离、错误签名拒绝、并发只能领取一次、重复上传不会重新开放领取和撤销后目录隐藏。接下来需在双端接入可信公钥验证及 MLS 会话持久化。 + +## 两设备 MLS 引擎 + +OpenMLS WASM 提供两设备会话创建、加入、消息加解密和端侧状态快照。原生 Rust 和 Windows Chrome WebAssembly 各通过两项测试,覆盖错误公钥、错误消息关联数据、恢复后的正常收发和重放拒绝。界面、设备身份验证、快照加密保存和发送队列仍在接入。