arcis 0.10.4

A standard library of types and functions for writing MPC circuits with the Arcis framework.
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

#[encrypted_library]
mod arcis_library {
    // The ArcisEd25519 signature scheme. This is essentially ed25519 but we use the hash function
    // SHA3-512 instead of SHA-512 since its multiplicative depth is much lower, which
    // makes it much better suited to be evaluated in MPC.

    #[allow(non_snake_case)]
    pub struct ArcisEd25519Signature {
        R_encoded: [u8; 32],
        S: [u8; 32],
    }

    #[allow(non_snake_case, clippy::manual_memcpy)]
    impl ArcisEd25519Signature {
        pub fn from_bytes(bytes: [u8; 64]) -> Self {
            let mut R_encoded = [0u8; 32];
            let mut S = [0u8; 32];
            for i in 0..32 {
                R_encoded[i] = bytes[i];
                S[i] = bytes[32 + i];
            }
            Self { R_encoded, S }
        }

        pub fn to_bytes(self) -> [u8; 64] {
            let mut bytes = [0u8; 64];
            for i in 0..32 {
                bytes[i] = self.R_encoded[i];
                bytes[32 + i] = self.S[i];
            }
            bytes
        }
    }

    pub struct SecretKey {
        secret_key: [u8; 32],
    }

    impl SecretKey {
        pub fn from_bytes(bytes: [u8; 32]) -> Self {
            SecretKey { secret_key: bytes }
        }
        pub fn new_rand() -> Self {
            let mut bytes = [0u8; 32];
            for b in bytes.iter_mut() {
                *b = ArcisRNG::gen_integer_from_width(8) as u8;
            }
            SecretKey { secret_key: bytes }
        }
    }
    pub struct SigningKey {
        secret_key: SecretKey,
    }

    impl SigningKey {
        #[allow(dead_code)]
        pub fn new(value: SecretKey) -> Self {
            Self { secret_key: value }
        }

        #[arcis_circuit = "sign"]
        pub fn sign(&self, message: &[u8]) -> ArcisEd25519Signature {}
    }

    pub struct MXESigningKey {}

    impl MXESigningKey {
        #[arcis_circuit = "mxe-sign"]
        pub fn sign(message: &[u8]) -> ArcisEd25519Signature {}
    }

    pub struct VerifyingKey {
        public_key_encoded: [u8; 32],
    }

    impl VerifyingKey {
        #[arcis_circuit = "verifying_key_from_secret_key"]
        pub fn from_secret_key(secret_key: &SecretKey) -> Self {}

        #[arcis_circuit = "verify"]
        pub fn verify(&self, message: &[u8], signature: &ArcisEd25519Signature) -> bool {}
    }
}