stoffelcrypto 0.1.0

Asynchronous HoneyBadgerMPC protocols, preprocessing, and arithmetic for Stoffel.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::{
    common::share::{shamir::NonRobustShare, ShareError},
    honeybadger::{
        double_share::double_share_generation::ProtocolState, robust_interpolate::InterpolateError,
        SessionId,
    },
};
use ark_ff::FftField;
use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
use bincode::ErrorKind;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use stoffelnet::network_utils::{NetworkError, PartyId};
use thiserror::Error;
use tokio::sync::oneshot::{channel, Receiver, Sender};

pub mod double_share_generation;

/// Error for the faulty double share distribution protocol.
#[derive(Debug, Error)]
pub enum DouShaError {
    /// The sender ID does not match with the expected ID.
    #[error(
        "sender mismatch: expected sender: {expected_sender:?}, actual_sender: {actual_sender:?}"
    )]
    SenderMismatch {
        expected_sender: PartyId,
        actual_sender: PartyId,
    },
    /// There was an error when manipulating shares.
    #[error("error in share: {0:?}")]
    InterpolateError(#[from] InterpolateError),
    /// Error in the serialization using `arkworks`.
    #[error("ark serialization error: {0:?}")]
    ArkSerializationError(#[from] ark_serialize::SerializationError),
    /// Error in the serialization using `bincode`.
    #[error("bincode serialization error: {0:?}")]
    BincodeSerializationError(#[from] Box<ErrorKind>),
    /// Error during a network operation.
    #[error("error in the network: {0:?}")]
    NetworkError(#[from] NetworkError),
    #[error("error sending the result: {0:?}")]
    SendError(SessionId),
    #[error("error receiving the result: {0:?}")]
    ReceiveError(SessionId),
    #[error("ShareError: {0}")]
    ShareError(#[from] ShareError),
    #[error("Party Id is out of bounds")]
    InvalidPartyId,
    #[error("no such session ID exists: {0:?}")]
    NoSuchSessionId(SessionId),
    #[error("result already received: {0:?}")]
    ResultAlreadyReceived(SessionId),
    #[error("multiplication {0:?} did not complete in time")]
    Timeout(SessionId),
    #[error("Store Limit")]
    LimitError,
}

#[derive(Clone, Debug, CanonicalSerialize, CanonicalDeserialize)]
pub struct DoubleShamirShare<F: FftField> {
    /// Share of degree 2t.
    pub degree_2t: NonRobustShare<F>,
    // Share of degree t.
    pub degree_t: NonRobustShare<F>,
}

impl<F: FftField> DoubleShamirShare<F> {
    pub fn new(degree_t: NonRobustShare<F>, degree_2t: NonRobustShare<F>) -> Self {
        assert!(degree_t.id == degree_2t.id);
        Self {
            degree_2t,
            degree_t,
        }
    }
}

/// Payload for one or more faulty double shares.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum DouShaPayload {
    Share(Vec<u8>),
    Shares(Vec<u8>),
}

/// Generic message for the faulty double share distribution protocol.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct DouShaMessage {
    /// ID of the sender.
    pub sender_id: PartyId,
    /// ID of the session.
    pub session_id: SessionId,
    /// Payload of the message.
    payload: DouShaPayload,
}

impl DouShaMessage {
    /// Creates a new generic message for the faulty double share protocol.
    pub fn new(sender: PartyId, session_id: SessionId, payload: DouShaPayload) -> Self {
        Self {
            sender_id: sender,
            session_id,
            payload,
        }
    }
}

/// Storage for the faulty double share protocol.
#[derive(Debug)]

pub struct DouShaStorage<F>
where
    F: FftField,
{
    /// Double shares resulting from the execution of the protocol.
    pub protocol_output: Vec<DoubleShamirShare<F>>,
    pub share: BTreeMap<usize, Vec<DoubleShamirShare<F>>>,
    pub batch_size: usize,

    /// Current state of the protocol.
    pub state: ProtocolState,

    /// Tracker for the received shares.
    ///
    /// Each time tha a party receives a share, the boolean vector in its position is set to
    /// `true`. The protocol is finished once all the flags of the vector are `true`.
    reception_tracker: Vec<bool>,
    pub output_sender: Option<Sender<Vec<DoubleShamirShare<F>>>>,
    pub output_receiver: Option<Receiver<Vec<DoubleShamirShare<F>>>>,
}

impl<F> DouShaStorage<F>
where
    F: FftField,
{
    /// Creates an empty storage. The
    pub fn empty(n_parties: usize) -> Self {
        let (output_sender, output_receiver) = channel();
        Self {
            protocol_output: Vec::new(),
            share: BTreeMap::new(),
            batch_size: 1,
            reception_tracker: vec![false; n_parties],
            state: ProtocolState::NotInitialized,
            output_sender: Some(output_sender),
            output_receiver: Some(output_receiver),
        }
    }
}