arcium-primitives 0.4.3

Arcium primitives
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

pub mod pairwise;

use itertools::enumerate;
pub use pairwise::*;
use serde::{de::DeserializeOwned, Serialize};

use crate::{errors::PrimitiveError, sharing::Reconstructible, types::PeerIndex};

/// Verify secret share/s from one or more openings.
pub trait Verifiable: Reconstructible {
    /// Verify openings from all peers.
    fn verify(&self, openings: Vec<Self::Opening>) -> Result<(), PrimitiveError>;

    /// Verify an opening from a specific peer.
    fn verify_from(
        &self,
        _opening: Self::Opening,
        _peer_index: PeerIndex,
    ) -> Result<(), PrimitiveError>;

    /// Verify all shares by opening each share towards all other peers and performing
    /// pairwise verification of the openings.
    fn verify_all(shares: Vec<Self>) -> Result<(), PrimitiveError>;
}

/// Verify secret share/s from one or more openings, with additional associated data.
pub trait VerifiableWith: Reconstructible {
    /// The associated data that is used to verify this secret shared type.
    type VerificationData: Send + Sync + Clone + Eq + Serialize + DeserializeOwned;

    /// Verify the correlated randomness from all peers given your share and all other peers'
    /// openings.
    fn verify_with(
        &self,
        openings: Vec<Self::Opening>,
        verification_data: Self::VerificationData,
    ) -> Result<(), PrimitiveError>;

    /// Verify an opening from a specific peer given your share and the opening.
    fn verify_from_peer_with(
        &self,
        _opening: Self::Opening,
        _peer_index: PeerIndex,
        _verification_data: Self::VerificationData,
    ) -> Result<(), PrimitiveError> {
        unimplemented!(
            "Type {} does not implement verify_from",
            std::any::type_name::<Self>()
        )
    }

    /// Verify all shares by opening each share towards all other peers and performing
    /// pairwise verification of the openings.
    fn verify_all_with(
        shares: Vec<Self>,
        verification_data: Self::VerificationData,
    ) -> Result<(), PrimitiveError> {
        if shares.len() < 2 {
            return Err(PrimitiveError::MinimumLength(2, shares.len()));
        }
        // Open each share to all other peers.
        let mut all_openings = shares
            .iter()
            .map(|share| share.open_to_all_others())
            .collect::<Vec<_>>();
        // Use each share to verify the openings of all other peers.
        enumerate(shares.iter()).try_for_each(|(i, share)| {
            let my_openings = enumerate(all_openings.iter_mut())
                .filter(|(j, _)| i != *j)
                .map(|(_, opening)| opening.next())
                .collect::<Option<Vec<_>>>()
                .ok_or(PrimitiveError::InvalidPeerIndex(i, shares.len() - 1))?;
            share.verify_with(my_openings, verification_data.clone())
        })
    }
}

impl<T: VerifiableWith<VerificationData = ()>> Verifiable for T {
    fn verify(&self, openings: Vec<Self::Opening>) -> Result<(), PrimitiveError> {
        self.verify_with(openings, ())
    }

    fn verify_from(
        &self,
        opening: Self::Opening,
        peer_index: PeerIndex,
    ) -> Result<(), PrimitiveError> {
        self.verify_from_peer_with(opening, peer_index, ())
    }

    fn verify_all(shares: Vec<Self>) -> Result<(), PrimitiveError> {
        Self::verify_all_with(shares, ())
    }
}