use hide_identity::{DeviceId, Membership, device_id};
use hide_sign::{
SIGNATURE_LENGTH, SigningIdentity as HideSigner, VERIFYING_KEY_LENGTH, VerifyingIdentity,
};
use mls_rs::client_builder::MlsConfig;
use mls_rs::group::{ReceivedMessage, Roster, Sender};
use mls_rs::identity::SigningIdentity;
use mls_rs::mls_rules::{
CommitDirection, CommitOptions, CommitSource, EncryptionOptions, ProposalBundle,
};
use mls_rs::{CipherSuite, Client, CryptoProvider, MlsMessage, MlsRules};
use mls_rs_core::crypto::CipherSuiteProvider;
use mls_rs_core::error::IntoAnyError;
use mls_rs_core::extension::ExtensionList;
use mls_rs_core::identity::IdentityProvider;
use mls_rs_core::identity::{
Credential, CredentialType, CustomCredential, MemberValidationContext,
};
use mls_rs_core::time::MlsTime;
use mls_rs_crypto_rustcrypto::RustCryptoProvider;
use thiserror::Error;
pub const PQ_STATUS: &str = "MLS PQ ciphersuites (draft-ietf-mls-pq-ciphersuites) are an \
Internet-Draft, not an RFC, and no Rust MLS provider implements them yet. Group messages \
here use X25519, which is not post-quantum. HIDE's object encryption is hybrid PQ.";
const SUITE: CipherSuite = CipherSuite::CURVE25519_AES128;
pub const HIDE_CREDENTIAL: CredentialType = CredentialType::new(0xF01D);
const BINDING_CONTEXT: &[u8] = b"HIDE/0.7 mls binding";
const DEVICE_ID_LEN: usize = 32;
const CREDENTIAL_LEN: usize = DEVICE_ID_LEN + VERIFYING_KEY_LENGTH + SIGNATURE_LENGTH;
pub const MAX_MLS_MESSAGE: usize = 1024 * 1024;
#[derive(Debug, Error)]
pub enum MlsError {
#[error("this device is not trusted by the identity")]
UntrustedDevice,
#[error("the message is larger than {MAX_MLS_MESSAGE} bytes")]
MessageTooLarge,
#[error("the message came from a device the identity does not trust")]
UntrustedSender,
#[error("the credential is not a HIDE device binding")]
NotADeviceCredential,
#[error("the credential's binding signature does not verify")]
ForgedCredential,
#[error("MLS: {0}")]
Protocol(String),
}
fn protocol<E: core::fmt::Display>(error: E) -> MlsError {
MlsError::Protocol(error.to_string())
}
impl IntoAnyError for MlsError {
fn into_dyn_error(self) -> Result<Box<dyn std::error::Error + Send + Sync>, Self> {
Ok(Box::new(self))
}
}
fn binding_message(device: &DeviceId, mls_public_key: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(DEVICE_ID_LEN + mls_public_key.len());
out.extend_from_slice(device);
out.extend_from_slice(mls_public_key);
out
}
struct Binding {
device: DeviceId,
key: VerifyingIdentity,
signature: [u8; SIGNATURE_LENGTH],
}
impl Binding {
fn parse(credential: &Credential) -> Result<Self, MlsError> {
let custom = credential
.as_custom()
.filter(|c| c.credential_type() == HIDE_CREDENTIAL)
.ok_or(MlsError::NotADeviceCredential)?;
let data = custom.data();
if data.len() != CREDENTIAL_LEN {
return Err(MlsError::NotADeviceCredential);
}
let device: DeviceId = data[..DEVICE_ID_LEN]
.try_into()
.map_err(|_| MlsError::NotADeviceCredential)?;
let key = VerifyingIdentity::from_bytes(
&data[DEVICE_ID_LEN..DEVICE_ID_LEN + VERIFYING_KEY_LENGTH],
)
.map_err(|_| MlsError::NotADeviceCredential)?;
let signature: [u8; SIGNATURE_LENGTH] = data[DEVICE_ID_LEN + VERIFYING_KEY_LENGTH..]
.try_into()
.map_err(|_| MlsError::NotADeviceCredential)?;
if device_id(&key) != device {
return Err(MlsError::ForgedCredential);
}
Ok(Self {
device,
key,
signature,
})
}
fn verify(&self, mls_public_key: &[u8]) -> Result<(), MlsError> {
self.key
.verify(
BINDING_CONTEXT,
&binding_message(&self.device, mls_public_key),
&self.signature,
)
.map_err(|_| MlsError::ForgedCredential)
}
}
#[derive(Clone, Debug)]
pub struct HideIdentityProvider {
membership: std::sync::Arc<std::sync::RwLock<Membership>>,
}
impl HideIdentityProvider {
pub fn new(membership: Membership) -> Self {
Self {
membership: std::sync::Arc::new(std::sync::RwLock::new(membership)),
}
}
pub fn update(&self, membership: Membership) {
match self.membership.write() {
Ok(mut guard) => *guard = membership,
Err(poisoned) => *poisoned.into_inner() = membership,
}
}
pub fn membership(&self) -> Membership {
match self.membership.read() {
Ok(guard) => guard.clone(),
Err(poisoned) => poisoned.into_inner().clone(),
}
}
fn validate(&self, signing_identity: &SigningIdentity) -> Result<(), MlsError> {
let binding = Binding::parse(&signing_identity.credential)?;
binding.verify(signing_identity.signature_key.as_bytes())?;
let membership = self.membership();
let trusted = membership
.get(&binding.device)
.ok_or(MlsError::UntrustedDevice)?;
if trusted.key != binding.key {
return Err(MlsError::ForgedCredential);
}
Ok(())
}
pub fn is_trusted(&self, signing_identity: &SigningIdentity) -> bool {
self.validate(signing_identity).is_ok()
}
}
impl IdentityProvider for HideIdentityProvider {
type Error = MlsError;
fn validate_member(
&self,
signing_identity: &SigningIdentity,
_timestamp: Option<MlsTime>,
_context: MemberValidationContext<'_>,
) -> Result<(), Self::Error> {
self.validate(signing_identity)
}
fn validate_external_sender(
&self,
signing_identity: &SigningIdentity,
_timestamp: Option<MlsTime>,
_extensions: Option<&ExtensionList>,
) -> Result<(), Self::Error> {
self.validate(signing_identity)
}
fn identity(
&self,
signing_identity: &SigningIdentity,
_extensions: &ExtensionList,
) -> Result<Vec<u8>, Self::Error> {
Ok(Binding::parse(&signing_identity.credential)?
.device
.to_vec())
}
fn valid_successor(
&self,
predecessor: &SigningIdentity,
successor: &SigningIdentity,
_extensions: &ExtensionList,
) -> Result<bool, Self::Error> {
let a = Binding::parse(&predecessor.credential)?;
let b = Binding::parse(&successor.credential)?;
if a.device != b.device {
return Ok(false);
}
Ok(self.validate(successor).is_ok())
}
fn supported_types(&self) -> Vec<CredentialType> {
vec![HIDE_CREDENTIAL]
}
}
#[derive(Clone, Debug)]
pub struct HideMlsRules {
membership: HideIdentityProvider,
}
impl HideMlsRules {
pub fn new(membership: HideIdentityProvider) -> Self {
Self { membership }
}
fn trusted_member(&self, roster: &Roster<'_>, index: u32) -> bool {
roster
.member_with_index(index)
.map(|member| self.membership.is_trusted(&member.signing_identity))
.unwrap_or(false)
}
}
impl MlsRules for HideMlsRules {
type Error = MlsError;
fn filter_proposals(
&self,
direction: CommitDirection,
source: CommitSource,
current_roster: &Roster<'_>,
_current_context: &mls_rs::group::GroupContext,
mut proposals: ProposalBundle,
) -> Result<ProposalBundle, Self::Error> {
if let CommitSource::ExistingMember(member) = &source
&& !self.membership.is_trusted(&member.signing_identity)
{
return Err(MlsError::UntrustedSender);
}
let mut dropped = false;
proposals.retain(|info| {
let keep = match info.sender {
Sender::Member(index) => self.trusted_member(current_roster, index),
_ => false,
};
dropped |= !keep;
Ok::<bool, MlsError>(keep)
})?;
if dropped && matches!(direction, CommitDirection::Receive) {
return Err(MlsError::UntrustedSender);
}
Ok(proposals)
}
fn commit_options(
&self,
_new_roster: &Roster<'_>,
_new_context: &mls_rs::group::GroupContext,
_proposals: &ProposalBundle,
) -> Result<CommitOptions, Self::Error> {
Ok(CommitOptions::new().with_path_required(true))
}
fn encryption_options(
&self,
_current_roster: &Roster<'_>,
_current_context: &mls_rs::group::GroupContext,
) -> Result<EncryptionOptions, Self::Error> {
Ok(EncryptionOptions::default())
}
}
pub fn client_for(
membership: &Membership,
device: &HideSigner,
) -> Result<Client<impl MlsConfig + use<>>, MlsError> {
client_with_provider(HideIdentityProvider::new(membership.clone()), device)
}
pub fn client_with_provider(
provider_handle: HideIdentityProvider,
device: &HideSigner,
) -> Result<Client<impl MlsConfig + use<>>, MlsError> {
let membership = provider_handle.membership();
let verifying = device.verifying_key();
let id = device_id(&verifying);
if !membership.contains(&id) {
return Err(MlsError::UntrustedDevice);
}
let crypto = RustCryptoProvider::default();
let provider = crypto.cipher_suite_provider(SUITE).ok_or_else(|| {
MlsError::Protocol("the cipher suite is unavailable in this build".into())
})?;
let (secret, public) = provider.signature_key_generate().map_err(protocol)?;
let signature = device.sign(BINDING_CONTEXT, &binding_message(&id, public.as_bytes()));
let mut data = Vec::with_capacity(CREDENTIAL_LEN);
data.extend_from_slice(&id);
data.extend_from_slice(&verifying.to_bytes());
data.extend_from_slice(&signature);
let credential = Credential::Custom(CustomCredential::new(HIDE_CREDENTIAL, data));
let signing = SigningIdentity::new(credential, public);
let rules = HideMlsRules::new(provider_handle.clone());
Ok(Client::builder()
.identity_provider(provider_handle)
.mls_rules(rules)
.crypto_provider(crypto)
.signing_identity(signing, secret, SUITE)
.build())
}
fn credential_device(signing: &SigningIdentity) -> Result<DeviceId, MlsError> {
let binding = Binding::parse(&signing.credential)?;
binding.verify(signing.signature_key.as_bytes())?;
Ok(binding.device)
}
pub fn untrusted_members<C: MlsConfig>(
group: &mls_rs::Group<C>,
membership: &Membership,
) -> Result<Vec<DeviceId>, MlsError> {
let mut stale = Vec::new();
for member in group.roster().members_iter() {
let device = credential_device(&member.signing_identity)?;
if !membership.contains(&device) {
stale.push(device);
}
}
Ok(stale)
}
pub fn sender_device<C: MlsConfig>(
group: &mls_rs::Group<C>,
message: &ReceivedMessage,
) -> Result<Option<DeviceId>, MlsError> {
let ReceivedMessage::ApplicationMessage(app) = message else {
return Ok(None);
};
let member = group
.member_at_index(app.sender_index)
.ok_or_else(|| MlsError::Protocol("sender is not in the roster".into()))?;
credential_device(&member.signing_identity).map(Some)
}
pub fn accept_from_trusted<C: MlsConfig>(
group: &mls_rs::Group<C>,
message: &ReceivedMessage,
membership: &Membership,
) -> Result<(), MlsError> {
match sender_device(group, message)? {
Some(device) if !membership.contains(&device) => Err(MlsError::UntrustedSender),
_ => Ok(()),
}
}
pub use mls_rs::MlsMessage as Message;
pub use mls_rs::group::ReceivedMessage as Received;
pub fn encode_message(message: &MlsMessage) -> Result<Vec<u8>, MlsError> {
message.to_bytes().map_err(protocol)
}
pub fn decode_message(bytes: &[u8]) -> Result<MlsMessage, MlsError> {
if bytes.len() > MAX_MLS_MESSAGE {
return Err(MlsError::MessageTooLarge);
}
MlsMessage::from_bytes(bytes).map_err(protocol)
}