mls-spec 2.0.0

This crate is a repository of MLS / RFC9420-related data structures.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#![allow(
    clippy::unnecessary_cast,
    non_upper_case_globals,
    non_camel_case_types,
    unused_assignments
)]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![doc = include_str!("../README.md")]
mod error;
pub use self::error::*;

pub mod reexports {
    #[cfg(feature = "draft-ietf-mls-extensions-content-advertisement-parse")]
    pub use mediatype;

    pub use tls_codec;
}

pub mod credential;
pub mod crypto;
pub mod defs;
pub mod group;
pub mod key_package;
pub mod key_schedule;
pub mod messages;
pub mod tree;

pub mod drafts;

pub(crate) mod macros;
#[cfg(feature = "test-utils")]
pub mod test_utils;

#[cfg(feature = "tlspl-utils")]
pub mod tlspl;
#[cfg(not(feature = "tlspl-utils"))]
pub(crate) mod tlspl;

mod sensitive_bytes;
pub use sensitive_bytes::*;

/// This trait allows implementers to automatically get a MLS-specific representation
/// that takes in account protocol versions and the label format.
///
/// For example, the MLS 1.0 format is `MLS 1.0 {label}`.
pub trait ToPrefixedLabel: std::fmt::Display {
    fn to_prefixed_string(&self, protocol_version: crate::defs::ProtocolVersion) -> String {
        format!("{protocol_version} {self}")
    }
}

#[async_trait::async_trait]
/// Delegate trait for implementors to implement spec-compliant validation of credentials
/// with their Authentication Service (MLS AS)
pub trait AuthenticationServiceDelegate: Send + Sync {
    async fn validate_credential(&self, credential: &crate::credential::Credential) -> bool;
}

/// Trait that exposes TLS serialization
pub trait Serializable {
    fn to_tls_bytes(&self) -> MlsSpecResult<Vec<u8>>;
}

impl<T> Serializable for T
where
    T: tls_codec::Serialize,
{
    fn to_tls_bytes(&self) -> MlsSpecResult<Vec<u8>> {
        Ok(self.tls_serialize_detached()?)
    }
}

/// Trait that exposes TLS deserialization
pub trait Parsable {
    fn from_tls_bytes(bytes: &[u8]) -> MlsSpecResult<Self>
    where
        Self: Sized;
}

impl<T> Parsable for T
where
    T: tls_codec::Deserialize,
{
    fn from_tls_bytes(mut bytes: &[u8]) -> MlsSpecResult<Self>
    where
        Self: Sized,
    {
        Ok(T::tls_deserialize(&mut bytes)?)
    }
}

#[cfg(feature = "mls-rs-compat")]
pub mod mls_rs_compat {
    use crate::Serializable;

    /// Trait that allows to move from mls-spec data structs to mls-rs
    /// It is inefficient by nature because in order to bypass the Rust type system,
    /// we're using serialization/deserialization as a "boundary break"
    ///
    /// Additionally, none of the trait implementations are done here because we don't want to
    /// depend directly on `mls_rs`. So you'll have to implement it on *your* side like such:
    ///
    /// ```rust,ignore
    /// impl mls_spec::mls_rs_compat::MlsRsTranscode for mls_rs::MlsMessage {
    ///     type Target = mls_spec::messages::MlsMessage;
    /// }
    /// ```
    ///
    pub trait MlsRsTranscode: mls_rs_codec::MlsDecode + mls_rs_codec::MlsEncode {
        type Target: crate::Parsable + crate::Serializable;

        fn transcode_from_mls_spec(item: &Self::Target) -> Result<Self, crate::MlsSpecError>
        where
            Self: Sized,
        {
            let tls_bytes = item.to_tls_bytes()?;
            Ok(Self::mls_decode(&mut &tls_bytes[..])?)
        }

        fn transcode_to_mls_spec(&self) -> Result<Self::Target, crate::MlsSpecError> {
            use crate::Parsable as _;
            let tls_bytes = self.mls_encode_to_vec()?;
            Self::Target::from_tls_bytes(&tls_bytes)
        }
    }
}