primitives/sharing/
mod.rs

1// Secret sharing schemes.
2pub mod authenticated;
3pub mod unauthenticated;
4
5use std::borrow::Borrow;
6
7pub use authenticated::*;
8use itertools::enumerate;
9use serde::{de::DeserializeOwned, Serialize};
10
11use crate::{
12    algebra::{field::FieldExtension, ops::transpose::transpose},
13    errors::{PrimitiveError, VerificationError},
14    random::{CryptoRngCore, RandomWith},
15    types::PeerIndex,
16    utils::TakeExact,
17};
18
19// ------------------------- //
20// ---- Reconstructible ---- //
21// ------------------------- //
22/// Reconstructs a secret from a collection of openings and a local share.
23pub trait Reconstructible: Sized {
24    /// The type that is sent to / received from other peers.
25    type Opening: Serialize + Clone + DeserializeOwned + Send + Sync;
26    /// The type of the reconstructed value.
27    type Secret: Serialize + DeserializeOwned + PartialEq + Send + Sync;
28
29    /// Open the share towards another peer.
30    fn open_to(&self, peer_index: PeerIndex) -> Result<Self::Opening, PrimitiveError>;
31
32    /// Open the share towards all other peers. Returns an iterator with either one opening for
33    /// each peer or a single opening for all peers.
34    fn open_to_all_others(&self) -> impl ExactSizeIterator<Item = Self::Opening>;
35
36    /// Reconstruct a secret from openings coming from all other parties.
37    fn reconstruct(&self, openings: &[Self::Opening]) -> Result<Self::Secret, PrimitiveError>;
38
39    /// Reconstruct a secret from a collection of shares, by opening each share
40    /// towards all other peers, reconstructing `n` secrets from the openings and
41    /// checking that they are all equal.
42    fn reconstruct_all<T: Borrow<Self>>(shares: &[T]) -> Result<Self::Secret, PrimitiveError> {
43        let n_parties = shares.len();
44        if n_parties < 2 {
45            return Err(PrimitiveError::InvalidParameters(
46                "At least two shares are required for reconstruction.".to_string(),
47            ));
48        }
49        // Open each share to all other peers.
50        let mut all_openings = shares
51            .iter()
52            .map(|share| share.borrow().open_to_all_others())
53            .collect::<Vec<_>>();
54        // Reconstruct each secret.
55        enumerate(shares.iter())
56            .map(|(i, share)| {
57                let my_openings = enumerate(all_openings.iter_mut())
58                    .take_exact(n_parties)
59                    .filter(|(j, _)| i != *j)
60                    .map(|(_, opening)| opening.next())
61                    .collect::<Option<Vec<_>>>()
62                    .ok_or(VerificationError::MissingOpening(i))?;
63                share.borrow().reconstruct(my_openings.as_slice())
64            })
65            // Check that all reconstructed secrets are equal.
66            .reduce(|previous, current| match (previous, current) {
67                (Ok(prev), Ok(curr)) => match prev == curr {
68                    true => Ok(prev),
69                    false => Err(VerificationError::OpeningMismatch(
70                        serde_json::to_string(&prev).unwrap(),
71                        serde_json::to_string(&curr).unwrap(),
72                    )
73                    .into()),
74                },
75                (Err(e), _) | (_, Err(e)) => Err(e),
76            })
77            .unwrap() // Safe because `shares.len() >= 2`
78    }
79}
80
81impl<T: Reconstructible<Opening: Clone>> Reconstructible for Vec<T> {
82    type Opening = Vec<T::Opening>;
83    type Secret = Vec<T::Secret>;
84
85    fn open_to(&self, peer_index: PeerIndex) -> Result<Self::Opening, PrimitiveError> {
86        self.iter().map(|share| share.open_to(peer_index)).collect()
87    }
88
89    fn open_to_all_others(&self) -> impl ExactSizeIterator<Item = Self::Opening> {
90        let all_openings: Vec<Vec<_>> = self
91            .iter()
92            .map(|share| share.open_to_all_others().collect())
93            .collect();
94
95        transpose(all_openings).into_iter()
96    }
97
98    fn reconstruct(&self, openings: &[Self::Opening]) -> Result<Self::Secret, PrimitiveError> {
99        if openings.is_empty() {
100            return Err(PrimitiveError::InvalidParameters(
101                "At least one opening is required for reconstruction.".to_string(),
102            ));
103        }
104
105        if openings[0].len() != self.len() {
106            return Err(PrimitiveError::InvalidParameters(
107                "Number of openings must match number of shares.".to_string(),
108            ));
109        }
110
111        // Iterate over all the i-th elements of each entry of openings
112        let mut reconstructed = Vec::with_capacity(self.len());
113        for (i, share) in self.iter().enumerate() {
114            let my_openings: Vec<_> = openings
115                .iter()
116                .map(|opening| opening.get(i).cloned())
117                .collect::<Option<Vec<_>>>()
118                .ok_or(PrimitiveError::InvalidParameters(
119                    "Opening is missing for some share.".to_string(),
120                ))?;
121            reconstructed.push(share.reconstruct(my_openings.as_slice())?);
122        }
123        Ok(reconstructed)
124    }
125}
126
127// ---------------------------- //
128// ---- Random for N Peers ---- //
129// ---------------------------- //
130pub trait RandomAuthenticatedForNPeers<F: FieldExtension>:
131    RandomWith<Vec<Vec<GlobalFieldKey<F>>>>
132{
133    fn random_for_n_peers_with_alphas<Container: FromIterator<Self>>(
134        mut rng: impl CryptoRngCore,
135        n_parties: usize,
136        all_alphas: Vec<Vec<GlobalFieldKey<F>>>,
137    ) -> Container {
138        Self::random_n_with(&mut rng, n_parties, all_alphas)
139    }
140}
141
142impl<F: FieldExtension, S: RandomWith<Vec<Vec<GlobalFieldKey<F>>>>> RandomAuthenticatedForNPeers<F>
143    for S
144{
145}
146
147pub trait RandomAuthenticatedForNPeersWith<F: FieldExtension, T: Clone>:
148    RandomWith<(T, Vec<Vec<GlobalFieldKey<F>>>)>
149{
150    fn random_authenticated_for_n_peers_with<Container: FromIterator<Self>>(
151        mut rng: impl CryptoRngCore,
152        n_parties: usize,
153        value: T,
154        all_alphas: Vec<Vec<GlobalFieldKey<F>>>,
155    ) -> Container {
156        Self::random_n_with(&mut rng, n_parties, (value, all_alphas))
157    }
158}
159
160impl<F: FieldExtension, T: Clone, S: RandomWith<(T, Vec<Vec<GlobalFieldKey<F>>>)>>
161    RandomAuthenticatedForNPeersWith<F, T> for S
162{
163}
164
165/// A trait used to add a plaintext secret to its secret-shared (reconstructible) form.
166pub trait AddPlaintext: Reconstructible {
167    /// Helper information to be used when adding a constant to the share. For example in BDOZ
168    /// shares, you need to know whether the local peer is the first peer or not.
169    type AssociatedInformation: Clone + Send + Sync;
170    /// Add a constant to the share.
171    fn add_plaintext(&self, plaintext: &Self::Secret, assoc: Self::AssociatedInformation) -> Self;
172
173    /// Add a constant to the share, consuming the share and returning a new one.
174    fn add_plaintext_owned(
175        self,
176        plaintext: &Self::Secret,
177        assoc: Self::AssociatedInformation,
178    ) -> Self {
179        self.add_plaintext(plaintext, assoc)
180    }
181}
182
183#[cfg(test)]
184mod tests {
185    use super::*;
186
187    #[test]
188    fn test_transpose_empty_matrix() {
189        let matrix: Vec<Vec<i32>> = vec![];
190        let result = transpose(matrix.clone());
191        assert_eq!(result, matrix);
192    }
193
194    #[test]
195    fn test_transpose_empty_rows() {
196        let matrix: Vec<Vec<i32>> = vec![];
197        let result = transpose(matrix.clone());
198        assert_eq!(result, matrix);
199    }
200
201    #[test]
202    fn test_transpose_single_element() {
203        let matrix = vec![vec![1]];
204        let result = transpose(matrix);
205        assert_eq!(result, vec![vec![1]]);
206    }
207
208    #[test]
209    fn test_transpose_single_row() {
210        let matrix = vec![vec![1, 2, 3]];
211        let result = transpose(matrix);
212        assert_eq!(result, vec![vec![1], vec![2], vec![3]]);
213    }
214
215    #[test]
216    fn test_transpose_single_column() {
217        let matrix = vec![vec![1], vec![2], vec![3]];
218        let result = transpose(matrix);
219        assert_eq!(result, vec![vec![1, 2, 3]]);
220    }
221
222    #[test]
223    fn test_transpose_square_matrix() {
224        let matrix = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
225        let result = transpose(matrix);
226        let expected = vec![vec![1, 4, 7], vec![2, 5, 8], vec![3, 6, 9]];
227        assert_eq!(result, expected);
228    }
229
230    #[test]
231    fn test_transpose_rectangular_matrix() {
232        let matrix = vec![vec![1, 2, 3, 4], vec![5, 6, 7, 8]];
233        let result = transpose(matrix);
234        let expected = vec![vec![1, 5], vec![2, 6], vec![3, 7], vec![4, 8]];
235        assert_eq!(result, expected);
236    }
237
238    #[test]
239    fn test_transpose_with_strings() {
240        let matrix = vec![vec!["a", "b"], vec!["c", "d"], vec!["e", "f"]];
241        let result = transpose(matrix);
242        let expected = vec![vec!["a", "c", "e"], vec!["b", "d", "f"]];
243        assert_eq!(result, expected);
244    }
245
246    #[test]
247    fn test_transpose_double_transpose() {
248        let matrix = vec![vec![1, 2, 3], vec![4, 5, 6]];
249        let result = transpose(transpose(matrix.clone()));
250        assert_eq!(result, matrix);
251    }
252}
primitives/sharing/mod.rs

primitives/sharing/
mod.rs
