xaynet-client 0.1.0

`xaynet_client` provides an implementation of a Xayn Network client
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

use super::{Participant, ParticipantState};
use xaynet_core::{
    mask::{MaskObject, MaskSeed, Masker, Model},
    message::{Message, Update as UpdateMessage},
    CoordinatorPublicKey,
    LocalSeedDict,
    ParticipantTaskSignature,
    SumDict,
};
#[derive(Serialize, Deserialize, Clone)]
pub struct Update {
    sum_signature: ParticipantTaskSignature,
    update_signature: ParticipantTaskSignature,
}

impl Participant<Update> {
    pub fn new(
        state: ParticipantState,
        sum_signature: ParticipantTaskSignature,
        update_signature: ParticipantTaskSignature,
    ) -> Self {
        Self {
            inner: Update {
                sum_signature,
                update_signature,
            },
            state,
        }
    }

    /// Compose an update message given the coordinator public key, sum
    /// dictionary, model scalar and local model update.
    pub fn compose_update_message(
        &self,
        coordinator_pk: CoordinatorPublicKey,
        sum_dict: &SumDict,

        local_model: Model,
    ) -> Message {
        let (mask_seed, masked_model, masked_scalar) = self.mask_model(local_model);
        let local_seed_dict = Self::create_local_seed_dict(sum_dict, &mask_seed);

        Message {
            signature: None,
            participant_pk: self.state.keys.public,
            coordinator_pk,
            payload: UpdateMessage {
                sum_signature: self.inner.sum_signature,
                update_signature: self.inner.update_signature,
                masked_model,
                masked_scalar,
                local_seed_dict,
            }
            .into(),
        }
    }

    /// Generate a mask seed and mask a local model.
    fn mask_model(&self, local_model: Model) -> (MaskSeed, MaskObject, MaskObject) {
        Masker::new(self.state.aggregation_config.mask)
            .mask(self.state.aggregation_config.scalar, local_model)
    }

    // Create a local seed dictionary from a sum dictionary.
    fn create_local_seed_dict(sum_dict: &SumDict, mask_seed: &MaskSeed) -> LocalSeedDict {
        sum_dict
            .iter()
            .map(|(pk, ephm_pk)| (*pk, mask_seed.encrypt(ephm_pk)))
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use sodiumoxide::randombytes::{randombytes, randombytes_uniform};
    use std::{collections::HashMap, iter};
    use xaynet_core::{
        crypto::{ByteObject, EncryptKeyPair},
        SumParticipantEphemeralPublicKey,
        SumParticipantEphemeralSecretKey,
        SumParticipantPublicKey,
    };

    #[test]
    fn test_create_local_seed_dict() {
        let mask_seed = MaskSeed::generate();
        let ephm_dict = iter::repeat_with(|| {
            let EncryptKeyPair { public, secret } = EncryptKeyPair::generate();
            (public, secret)
        })
        .take(1 + randombytes_uniform(10) as usize)
        .collect::<HashMap<SumParticipantEphemeralPublicKey, SumParticipantEphemeralSecretKey>>();
        let sum_dict = ephm_dict
            .iter()
            .map(|(ephm_pk, _)| {
                (
                    SumParticipantPublicKey::from_slice(&randombytes(32)).unwrap(),
                    *ephm_pk,
                )
            })
            .collect();
        let seed_dict = Participant::create_local_seed_dict(&sum_dict, &mask_seed);
        assert_eq!(seed_dict.keys().len(), sum_dict.keys().len());
        assert!(seed_dict.keys().all(|pk| sum_dict.contains_key(pk)));
        assert!(seed_dict.iter().all(|(pk, seed)| {
            let ephm_pk = sum_dict.get(pk).unwrap();
            let ephm_sk = ephm_dict.get(ephm_pk).unwrap();
            mask_seed == seed.decrypt(ephm_pk, ephm_sk).unwrap()
        }));
    }
}