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;
use mls_rs::identity::SigningIdentity;
use mls_rs::{CipherSuite, Client, CryptoProvider, MlsMessage};
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;
#[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 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: Membership,
}
impl HideIdentityProvider {
pub fn new(membership: Membership) -> Self {
Self { membership }
}
fn validate(&self, signing_identity: &SigningIdentity) -> Result<(), MlsError> {
let binding = Binding::parse(&signing_identity.credential)?;
binding.verify(signing_identity.signature_key.as_bytes())?;
let trusted = self
.membership
.get(&binding.device)
.ok_or(MlsError::UntrustedDevice)?;
if trusted.key != binding.key {
return Err(MlsError::ForgedCredential);
}
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)?;
Ok(a.device == b.device)
}
fn supported_types(&self) -> Vec<CredentialType> {
vec![HIDE_CREDENTIAL]
}
}
pub fn client_for(
membership: &Membership,
device: &HideSigner,
) -> Result<Client<impl MlsConfig + use<>>, MlsError> {
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);
Ok(Client::builder()
.identity_provider(HideIdentityProvider::new(membership.clone()))
.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> {
MlsMessage::from_bytes(bytes).map_err(protocol)
}