openmls 0.8.1

A Rust implementation of the Messaging Layer Security (MLS) protocol, as defined in RFC 9420.
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

use std::ops::{Deref, DerefMut};

use tls_codec::*;

use openmls_basic_credential::SignatureKeyPair;
use openmls_traits::{signatures::Signer, types::Ciphersuite, OpenMlsProvider};

use crate::{
    ciphersuite::{
        signable::{Signable, SignedStruct},
        signature::{OpenMlsSignaturePublicKey, Signature},
    },
    group::GroupContext,
    messages::group_info::GroupInfo,
};

use super::extensions::FrankenExtension;

#[derive(
    Debug, Clone, PartialEq, Eq, TlsSerialize, TlsDeserialize, TlsDeserializeBytes, TlsSize,
)]
pub struct FrankenGroupInfo {
    pub payload: FrankenGroupInfoTbs,
    pub signature: VLBytes,
}

impl FrankenGroupInfo {
    // Re-sign both the KeyPackage and the enclosed LeafNode
    pub fn resign(&mut self, signer: &impl Signer) {
        let new_self = self.payload.clone().sign(signer).unwrap();
        let _ = std::mem::replace(self, new_self);
    }
}

impl Deref for FrankenGroupInfo {
    type Target = FrankenGroupInfoTbs;

    fn deref(&self) -> &Self::Target {
        &self.payload
    }
}

impl DerefMut for FrankenGroupInfo {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.payload
    }
}

impl SignedStruct<FrankenGroupInfoTbs> for FrankenGroupInfo {
    fn from_payload(
        payload: FrankenGroupInfoTbs,
        signature: Signature,
        _serialized_payload: Vec<u8>,
    ) -> Self {
        Self {
            payload,
            signature: signature.as_slice().to_owned().into(),
        }
    }
}

const SIGNATURE_GROUP_INFO_LABEL: &str = "GroupInfoTBS";

impl Signable for FrankenGroupInfoTbs {
    type SignedOutput = FrankenGroupInfo;

    fn unsigned_payload(&self) -> Result<Vec<u8>, tls_codec::Error> {
        self.tls_serialize_detached()
    }

    fn label(&self) -> &str {
        SIGNATURE_GROUP_INFO_LABEL
    }
}

#[derive(
    Debug, Clone, PartialEq, Eq, TlsSerialize, TlsDeserialize, TlsDeserializeBytes, TlsSize,
)]
pub struct FrankenGroupInfoTbs {
    pub group_context: FrankenGroupContext,
    pub extensions: Vec<FrankenExtension>,
    pub confirmation_tag: VLBytes,
    pub signer: u32,
}

#[derive(
    Debug, Clone, PartialEq, Eq, TlsSerialize, TlsDeserialize, TlsDeserializeBytes, TlsSize,
)]
pub struct FrankenGroupContext {
    protocol_version: u16,
    ciphersuite: u16,
    group_id: VLBytes,
    epoch: u64,
    tree_hash: VLBytes,
    confirmed_transcript_hash: VLBytes,
    extensions: Vec<FrankenExtension>,
}

impl From<GroupContext> for FrankenGroupContext {
    fn from(value: GroupContext) -> Self {
        let extensions = value
            .extensions()
            .iter()
            .map(|ext| ext.clone().into())
            .collect();
        FrankenGroupContext {
            protocol_version: match value.protocol_version() {
                crate::versions::ProtocolVersion::Mls10 => 1,
                crate::versions::ProtocolVersion::Other(other) => other,
            },
            ciphersuite: value.ciphersuite().into(),
            group_id: value.group_id().as_slice().to_vec().into(),
            epoch: value.epoch().as_u64(),
            tree_hash: value.tree_hash().to_vec().into(),
            confirmed_transcript_hash: value.confirmed_transcript_hash().to_vec().into(),
            extensions,
        }
    }
}

impl From<GroupInfo> for FrankenGroupInfo {
    fn from(ln: GroupInfo) -> Self {
        FrankenGroupInfo::tls_deserialize(&mut ln.tls_serialize_detached().unwrap().as_slice())
            .unwrap()
    }
}

impl From<FrankenGroupInfo> for GroupInfo {
    fn from(fln: FrankenGroupInfo) -> Self {
        GroupInfo::tls_deserialize(&mut fln.tls_serialize_detached().unwrap().as_slice()).unwrap()
    }
}