foundry-mpc-rs 0.1.2

shamir-secret-sharing implementation forked from Lúcás C. Meier's cait_sith protocol and ZcashFoundation's frost
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

use frost_core::SigningKey;
use frost_ed25519::{
    keys::{split, IdentifierList},
    rand_core::OsRng,
    Ed25519Sha512, Identifier,
};

use crate::point::Point256;

pub fn sss_split_ed25519(
    secret_be: [u8; 32],
    point_xs: Vec<[u8; 32]>,
    t: u32,
) -> Result<Vec<Point256>, String> {
    let mut secret_le = secret_be;
    secret_le.reverse();
    let secret_be_slice = secret_le;
    let signing_key = SigningKey::<Ed25519Sha512>::deserialize(secret_be_slice.as_slice())
        .expect("Failed to deserialize signing key");

    let max_signers = point_xs.len() as u16;
    let min_signers = t as u16;

    let identifiers = point_xs
        .iter()
        .map(|&x| Identifier::deserialize(x.as_slice()).expect("Failed to deserialize identifier"))
        .collect::<Vec<_>>();
    let identifier_list = IdentifierList::Custom(&identifiers);

    let mut rng = OsRng;
    let share_map_tup = split(
        &signing_key,
        max_signers,
        min_signers,
        identifier_list,
        &mut rng,
    )
    .expect("Failed to split");
    let share_vec = share_map_tup.0.into_iter().collect::<Vec<_>>();

    let share_points: Vec<Point256> = share_vec
        .into_iter()
        .map(|(identifier, share)| Point256 {
            x: identifier.to_scalar().to_bytes(),
            y: share.signing_share().to_scalar().to_bytes(),
        })
        .collect();

    Ok(share_points)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_sss_split_ed25519() {
        let mut secret = [0u8; 32];
        secret[31] = 1;
        let mut point_xs = vec![[0u8; 32]; 3];
        point_xs[0][31] = 1;
        point_xs[1][31] = 2;
        point_xs[2][31] = 3;
        let t = 2;

        let max_signers = point_xs.len() as u16;
        let min_signers = t as u16;

        let signing_key = SigningKey::<Ed25519Sha512>::deserialize(secret.as_slice())
            .expect("Failed to deserialize signing key");

        let identifiers = point_xs
            .iter()
            .map(|&x| {
                Identifier::deserialize(x.as_slice()).expect("Failed to deserialize identifier")
            })
            .collect::<Vec<_>>();
        let identifier_list = IdentifierList::Custom(&identifiers);

        let mut rng = OsRng;
        let out = split(
            &signing_key,
            max_signers,
            min_signers,
            identifier_list,
            &mut rng,
        )
        .expect("Failed to split");

        let i_0 = identifiers.get(0).unwrap();
        let out_0 = out.0.get(identifiers.get(0).unwrap()).unwrap();
        let out_0_signing_share = out_0.signing_share();
        println!("out_0_signing_share: {:?}", out_0_signing_share.to_scalar());
        println!("i_0: {:?}", i_0.to_scalar().to_bytes());

        let i_1 = identifiers.get(1).unwrap();
        let out_1 = out.0.get(identifiers.get(1).unwrap()).unwrap();
        let out_1_signing_share = out_1.signing_share();
        println!("out_1_signing_share: {:?}", out_1_signing_share.to_scalar());
        println!("i_1: {:?}", i_1.to_scalar().to_bytes());
    }

    #[test]
    fn test_secret_key_endian() {
        println!("test_secret_key_endian");
        let mut secret = [255u8; 32];
        secret[0] = 0;
        let signing_key = SigningKey::<Ed25519Sha512>::deserialize(secret.as_slice())
            .expect("Failed to deserialize signing key");
        println!("signing_key: {:?}", signing_key.to_scalar());
    }
}