mls-spec 3.0.0-pre.2

This crate is a repository of MLS / RFC9420-related data structures.
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
127
128
129
130
131
132
133
134
135

use crate::{
    SensitiveBytes, crypto::HpkePublicKey, defs::SenderIndex, group::ExternalSender,
    key_schedule::GroupContext,
};

use super::mls_extensions::safe_application::{Component, ComponentId};

pub const COMPONENT_ID: ComponentId = 0x0007;

#[derive(Debug, Clone, PartialEq, Eq, thalassa::TlsplSize, thalassa::TlsplSerialize)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct AssociatedPartyEntryTBS<'a> {
    pub encryption_key: &'a HpkePublicKey<'a>,
    pub external_sender_index: &'a SenderIndex,
}

#[derive(Debug, Clone, PartialEq, Eq, thalassa::TlsplAll)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AssociatedPartyEntry<'a> {
    pub encryption_key: HpkePublicKey<'a>,
    pub external_sender_index: SenderIndex,
    pub signature: SensitiveBytes<'a>,
}

impl<'a> AssociatedPartyEntry<'a> {
    pub fn to_tbs(&self) -> AssociatedPartyEntryTBS<'_> {
        AssociatedPartyEntryTBS {
            encryption_key: &self.encryption_key,
            external_sender_index: &self.external_sender_index,
        }
    }

    /// Finds the related `ExternalSender` from the provided `GroupContext`.
    ///
    /// If this returns `None`, then you can safely consider the AssociatedParty to be invalid!
    pub fn related_external_sender_from_group_context(
        &self,
        ctx: &'a GroupContext<'a>,
    ) -> Option<&'a ExternalSender<'a>> {
        ctx.external_senders()
            .get(self.external_sender_index as usize)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, thalassa::TlsplAll)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AssociatedParties<'a> {
    pub associated_parties: Vec<AssociatedPartyEntry<'a>>,
}

impl<'a> Component<'a> for AssociatedParties<'a> {
    fn component_id() -> ComponentId {
        COMPONENT_ID
    }
}

pub mod proposals {
    use crate::defs::LeafIndex;

    use super::AssociatedPartyEntry;

    #[derive(Debug, Clone, PartialEq, Eq, thalassa::TlsplAll)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct AddAssociatedPartyProposal<'a> {
        pub new_party: AssociatedPartyEntry<'a>,
    }

    #[derive(Debug, Clone, Copy, PartialEq, Eq, thalassa::TlsplAll)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct RemoveAssociatedPartyProposal {
        pub removed_party_index: LeafIndex,
    }

    #[derive(Debug, Clone, PartialEq, Eq, thalassa::TlsplAll)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct UpdateAssociatedPartyProposal<'a> {
        pub updated_party: AssociatedPartyEntry<'a>,
    }
}

pub mod key_schedule {
    use crate::{SensitiveBytes, defs::LeafIndex, key_schedule::GroupContext};

    use super::AssociatedPartyEntry;

    #[derive(Debug, Clone, Copy, PartialEq, Eq, thalassa::TlsplSize, thalassa::TlsplSerialize)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize))]
    pub struct AssociatedPartyExportContext<'a> {
        pub ap_index: &'a LeafIndex,
        pub ap_entry: &'a AssociatedPartyEntry<'a>,
    }

    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize))]
    pub struct AssociatedPartyEncryptionContext<'a> {
        pub group_context: &'a GroupContext<'a>,
        pub ap_commit_secret_id: &'a [u8],
    }

    impl AssociatedPartyEncryptionContext<'_> {
        pub const LABEL: &'static [u8] = b"AP Commit Secret";
    }

    // impl tls_codec::Size for AssociatedPartyEncryptionContext<'_> {
    //     fn tls_serialized_len(&self) -> usize {
    //         crate::tlspl::tls_serialized_len_as_vlvec(Self::LABEL.len())
    //             + self.group_context.tls_serialized_len()
    //             + crate::tlspl::tls_serialized_len_as_vlvec(self.ap_commit_secret_id.len())
    //     }
    // }

    // impl tls_codec::Serialize for AssociatedPartyEncryptionContext<'_> {
    //     fn tls_serialize<W: std::io::Write>(
    //         &self,
    //         writer: &mut W,
    //     ) -> Result<usize, tls_codec::Error> {
    //         let mut written = crate::tlspl::bytes::tls_serialize(Self::LABEL, writer)?;
    //         written += self.group_context.tls_serialize(writer)?;
    //         written += crate::tlspl::bytes::tls_serialize(self.ap_commit_secret_id, writer)?;
    //         Ok(written)
    //     }
    // }

    #[derive(Debug, Clone, PartialEq, Eq, thalassa::TlsplAll)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct AssociatedPartySecret<'a> {
        pub associated_party_proposal_secret: SensitiveBytes<'a>,
    }

    #[derive(Debug, Clone, PartialEq, Eq, thalassa::TlsplAll)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct AssociatedPartySecrets<'a> {
        pub associated_party_init_secret: SensitiveBytes<'a>,
    }
}