openmls 0.4.1

This is a WIP Rust implementation of the Messaging Layer Security (MLS) protocol based on draft 12+.
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
127

//! This module contains the [`LeafNode`] struct and its implementation.
use openmls_traits::crypto::OpenMlsCrypto;
use serde::{Deserialize, Serialize};

use crate::{
    ciphersuite::{hash_ref::KeyPackageRef, HpkePrivateKey, HpkePublicKey},
    error::LibraryError,
    key_packages::{KeyPackage, KeyPackageBundle},
};

/// This struct implements the MLS leaf node and contains a [`KeyPackage`] and
/// potentially a corresponding `HpkePrivateKey`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LeafNode {
    key_package_ref: Option<KeyPackageRef>,
    key_package: KeyPackage,
    private_key_option: Option<HpkePrivateKey>,
}

// When comparing leaf nodes we ignore the key package reference.
// Sometimes it's not set yet. This might be remedied in #731.
// Note that the key package reference is computed deterministically from the
// key package such that there no additional value in comparing it.
impl PartialEq for LeafNode {
    fn eq(&self, other: &Self) -> bool {
        self.key_package == other.key_package && self.private_key_option == other.private_key_option
    }
}

impl LeafNode {
    /// Build a new [`LeafNode`] from a [`KeyPackage`].
    pub(crate) fn new(
        key_package: KeyPackage,
        backend: &impl OpenMlsCrypto,
    ) -> Result<Self, LibraryError> {
        let key_package_ref = Some(key_package.hash_ref(backend)?);
        Ok(Self {
            key_package_ref,
            key_package,
            private_key_option: None,
        })
    }

    /// Build a new [`LeafNode`] from a [`KeyPackage`] and the corresponding
    /// [`KeyPackageRef`].
    pub(crate) fn new_with_ref(
        key_package: KeyPackage,
        key_package_ref: Option<KeyPackageRef>,
    ) -> Self {
        Self {
            key_package_ref,
            key_package,
            private_key_option: None,
        }
    }

    /// Build a new [`LeafNode`] from a [`KeyPackageBundle`].
    pub(crate) fn new_from_bundle(
        key_package_bundle: KeyPackageBundle,
        backend: &impl OpenMlsCrypto,
    ) -> Result<Self, LibraryError> {
        let key_package = key_package_bundle.key_package;
        let private_key_option = Some(key_package_bundle.private_key);
        let key_package_ref = Some(key_package.hash_ref(backend)?);
        Ok(Self {
            key_package_ref,
            key_package,
            private_key_option,
        })
    }

    /// Return a reference to the `public_key` of the [`KeyPackage`] in this
    /// node.
    pub(crate) fn public_key(&self) -> &HpkePublicKey {
        self.key_package.hpke_init_key()
    }

    /// Return a reference to the `private_key` corresponding to the
    /// [`KeyPackage`] in this node.
    #[cfg(not(any(feature = "test-utils", test)))]
    pub(in crate::treesync) fn private_key(&self) -> Option<&HpkePrivateKey> {
        self.private_key_option.as_ref()
    }

    /// Return a reference to the `private_key` corresponding to the
    /// [`KeyPackage`] in this node.
    #[cfg(any(feature = "test-utils", test))]
    pub(crate) fn private_key(&self) -> Option<&HpkePrivateKey> {
        self.private_key_option.as_ref()
    }

    /// Set the private key in this node.
    pub(in crate::treesync) fn set_private_key(&mut self, private_key: HpkePrivateKey) {
        self.private_key_option = Some(private_key)
    }

    /// Return a reference to the `key_package` of this node.
    pub fn key_package(&self) -> &KeyPackage {
        &self.key_package
    }

    /// Return a [`KeyPackageRef`] of this node('s key package).
    /// Note that this returns `None` if the key package reference has not been
    /// set explicitly with [`Self::set_key_package_ref()`].
    pub(crate) fn key_package_ref(&self) -> Option<&KeyPackageRef> {
        self.key_package_ref.as_ref()
    }

    /// Set the [`KeyPackageRef`] for this leaf node.
    pub(crate) fn set_key_package_ref(
        &mut self,
        backend: &impl OpenMlsCrypto,
    ) -> Result<(), LibraryError> {
        self.key_package_ref = Some(self.key_package.hash_ref(backend)?);
        Ok(())
    }
}

impl From<KeyPackage> for LeafNode {
    fn from(key_package: KeyPackage) -> Self {
        LeafNode {
            key_package_ref: None,
            key_package,
            private_key_option: None,
        }
    }
}