use hide_identity::{DeviceId, Membership, device_id};
use hide_sign::VerifyingIdentity;
use mls_rs::client_builder::MlsConfig;
use mls_rs::group::ReceivedMessage;
use mls_rs::identity::SigningIdentity;
use mls_rs::identity::basic::{BasicCredential, BasicIdentityProvider};
use mls_rs::{CipherSuite, Client, CryptoProvider, MlsMessage};
use mls_rs_core::crypto::CipherSuiteProvider;
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;
#[derive(Debug, Error)]
pub enum MlsError {
#[error("this device is not trusted by the identity")]
UntrustedDevice,
#[error("the message came from a device the identity does not trust")]
UntrustedSender,
#[error("the sender's credential is not a HIDE device id")]
NotADeviceCredential,
#[error("MLS: {0}")]
Protocol(String),
}
fn protocol<E: core::fmt::Display>(error: E) -> MlsError {
MlsError::Protocol(error.to_string())
}
pub fn client_for(
membership: &Membership,
device: VerifyingIdentity,
) -> Result<Client<impl MlsConfig + use<>>, MlsError> {
let id = device_id(&device);
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 signing = SigningIdentity::new(BasicCredential::new(id.to_vec()).into_credential(), public);
Ok(Client::builder()
.identity_provider(BasicIdentityProvider)
.crypto_provider(crypto)
.signing_identity(signing, secret, SUITE)
.build())
}
fn credential_device(signing: &SigningIdentity) -> Result<DeviceId, MlsError> {
let basic = signing
.credential
.as_basic()
.ok_or(MlsError::NotADeviceCredential)?;
basic
.identifier()
.try_into()
.map_err(|_| MlsError::NotADeviceCredential)
}
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> {
MlsMessage::from_bytes(bytes).map_err(protocol)
}