450 lines
15 KiB
Rust
450 lines
15 KiB
Rust
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<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,
|
|
device: String,
|
|
public_key: Vec<u8>,
|
|
storage: Vec<(Vec<u8>, Vec<u8>)>,
|
|
}
|
|
|
|
pub struct Engine {
|
|
provider: OpenMlsRustCrypto,
|
|
device: String,
|
|
public_key: Vec<u8>,
|
|
}
|
|
|
|
impl Engine {
|
|
pub fn new(device: &str) -> EngineResult<Self> {
|
|
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<Self> {
|
|
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<Vec<u8>> {
|
|
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<Vec<u8>> {
|
|
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<Vec<u8>> {
|
|
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")?;
|
|
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");
|
|
}
|
|
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)
|
|
.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")?;
|
|
if packages.is_empty() {
|
|
return Ok(Vec::new());
|
|
}
|
|
let (_, welcome, _) = group
|
|
.add_members(&self.provider, &signer, packages)
|
|
.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<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");
|
|
};
|
|
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
|
|
{
|
|
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() {
|
|
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<Vec<u8>> {
|
|
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<Vec<u8>> {
|
|
self.decrypt_message(None, peer, expected_key, associated_data, wire)
|
|
}
|
|
|
|
pub fn decrypt_group(
|
|
&self,
|
|
id: &[u8],
|
|
peer: &str,
|
|
expected_key: &[u8],
|
|
associated_data: &[u8],
|
|
wire: &[u8],
|
|
) -> EngineResult<Vec<u8>> {
|
|
self.decrypt_message(
|
|
Some(&group_id_from(id)?),
|
|
peer,
|
|
expected_key,
|
|
associated_data,
|
|
wire,
|
|
)
|
|
}
|
|
|
|
fn decrypt_message(
|
|
&self,
|
|
expected_group: Option<&GroupId>,
|
|
peer: &str,
|
|
expected_key: &[u8],
|
|
associated_data: &[u8],
|
|
wire: &[u8],
|
|
) -> EngineResult<Vec<u8>> {
|
|
let protocol = MlsMessageIn::tls_deserialize_exact(wire)
|
|
.map_err(|_| "invalid ciphertext")?
|
|
.try_into_protocol_message()
|
|
.map_err(|_| "invalid ciphertext")?;
|
|
if expected_group.is_some_and(|id| id != protocol.group_id()) {
|
|
return Err("unexpected MLS group");
|
|
}
|
|
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> {
|
|
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<Option<MlsGroup>> {
|
|
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<GroupId> {
|
|
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()
|
|
}
|