round-based 0.1.1

Driver for round-based protocols
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

use round_based::containers::push::Push;
use round_based::containers::{self, BroadcastMsgs, Store};
use round_based::Msg;
use sha2::{Digest, Sha256};

#[derive(Debug)]
pub struct Round0 {
    pub is_adversary: bool,
    pub my_ind: u16,
    pub my_seed: u32,
    pub blinding: [u8; 32],
}

impl Round0 {
    pub fn proceed<O>(self, mut output: O) -> Result<Round1>
    where
        O: Push<Msg<CommittedSeed>>,
    {
        let mut committed_seed = [0u8; 32];
        let hash = Sha256::new()
            .chain(self.blinding)
            .chain(&self.my_seed.to_be_bytes()[..])
            .finalize();
        committed_seed.copy_from_slice(&hash);

        output.push(Msg {
            sender: self.my_ind,
            receiver: None,
            body: CommittedSeed(committed_seed),
        });

        Ok(Round1 {
            is_adversary: self.is_adversary,
            my_ind: self.my_ind,
            my_seed: self.my_seed,
            blinding: self.blinding,
        })
    }
    pub fn is_expensive(&self) -> bool {
        // We assume that computing hash is expensive operation (in real-world, it's not)
        true
    }
}

#[derive(Debug)]
pub struct Round1 {
    is_adversary: bool,
    my_ind: u16,
    my_seed: u32,
    blinding: [u8; 32],
}

impl Round1 {
    pub fn proceed<O>(self, input: BroadcastMsgs<CommittedSeed>, mut output: O) -> Result<Round2>
    where
        O: Push<Msg<RevealedSeed>>,
    {
        if !self.is_adversary {
            output.push(Msg {
                sender: self.my_ind,
                receiver: None,
                body: RevealedSeed {
                    seed: self.my_seed,
                    blinding: self.blinding,
                },
            });
        }
        Ok(Round2 {
            my_seed: self.my_seed,
            committed_seeds: input,
        })
    }
    pub fn expects_messages(party_i: u16, party_n: u16) -> Store<BroadcastMsgs<CommittedSeed>> {
        containers::BroadcastMsgsStore::new(party_i, party_n)
    }
    pub fn is_expensive(&self) -> bool {
        // Sending cached message is the cheapest operation
        false
    }
}

#[derive(Debug)]
pub struct Round2 {
    my_seed: u32,
    committed_seeds: BroadcastMsgs<CommittedSeed>,
}

impl Round2 {
    pub fn proceed(self, input: BroadcastMsgs<RevealedSeed>) -> Result<OutputRandomValue> {
        let mut result = self.my_seed;
        let msgs = self
            .committed_seeds
            .into_iter_indexed()
            .zip(input.into_iter());

        let mut non_cooperative_parties: Vec<u16> = vec![];
        for ((i, commit), decommit) in msgs {
            let hash = Sha256::new()
                .chain(decommit.blinding)
                .chain(&decommit.seed.to_be_bytes()[..])
                .finalize();
            if commit.0 != hash.as_ref() {
                non_cooperative_parties.push(i)
            } else {
                result ^= decommit.seed;
            }
        }

        if !non_cooperative_parties.is_empty() {
            Err(ProceedError::PartiesDidntRevealItsSeed {
                party_ind: non_cooperative_parties,
            })
        } else {
            Ok(result)
        }
    }
    pub fn expects_messages(party_i: u16, party_n: u16) -> Store<BroadcastMsgs<RevealedSeed>> {
        containers::BroadcastMsgsStore::new(party_i, party_n)
    }
    pub fn is_expensive(&self) -> bool {
        // Round involves computing a hash, we assume it's expensive (again, in real-world it's not)
        true
    }
}

pub type OutputRandomValue = u32;

// Messages

#[derive(Clone, Debug)]
pub struct CommittedSeed([u8; 32]);

#[derive(Clone, Debug)]
pub struct RevealedSeed {
    seed: u32,
    blinding: [u8; 32],
}

// Errors

type Result<T> = std::result::Result<T, ProceedError>;

#[derive(Debug, PartialEq)]
pub enum ProceedError {
    PartiesDidntRevealItsSeed { party_ind: Vec<u16> },
}