wamu-core 0.1.1

A Rust implementation of the core Wamu protocol for computation of threshold signatures by multiple decentralized identities.
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

//! Test utilities.

use k256::ecdsa::{signature::Signer, SigningKey};

use crate::crypto::{
    EllipticCurve, KeyEncoding, MessageDigest, Signature, SignatureAlgorithm, SignatureEncoding,
    VerifyingKey,
};
use crate::IdentityProvider;

/// A mock ECDSA/Secp256k1/SHA-256 based identity provider.
#[derive(Debug, Clone)]
pub struct MockECDSAIdentityProvider {
    secret: SigningKey,
}

impl MockECDSAIdentityProvider {
    /// Generates an ECDSA/Secp256k1/SHA-256 signing key.
    pub fn generate() -> Self {
        let mut rng = rand::thread_rng();
        Self {
            // `k256::ecdsa::SigningKey` uses `Secp256k1` and `SHA-256`.
            secret: SigningKey::random(&mut rng),
        }
    }
}

impl IdentityProvider for MockECDSAIdentityProvider {
    /// Computes and serializes the ECDSA/Secp256k1 verifying key (in SEC1 format).
    fn verifying_key(&self) -> VerifyingKey {
        VerifyingKey {
            // `k256::ecdsa::SigningKey` uses `Secp256k1` and `SHA-256`.
            key: k256::ecdsa::VerifyingKey::from(&self.secret)
                .to_sec1_bytes()
                .to_vec(),
            algo: SignatureAlgorithm::ECDSA,
            curve: EllipticCurve::Secp256k1,
            enc: KeyEncoding::SEC1,
        }
    }

    /// Computes and serializes (in DER format) the ECDSA/Secp256k1/SHA-256 signature of a message .
    fn sign(&self, msg: &[u8]) -> Signature {
        // `k256::ecdsa::SigningKey` uses `Secp256k1` and `SHA-256`.
        let signature: k256::ecdsa::Signature = self.secret.sign(msg);
        Signature {
            sig: signature.to_der().as_bytes().to_vec(),
            algo: SignatureAlgorithm::ECDSA,
            curve: EllipticCurve::Secp256k1,
            hash: MessageDigest::SHA256,
            enc: SignatureEncoding::DER,
        }
    }

    /// Computes the ECDSA/Secp256k1/SHA-256 signature for a message and returns (`r`, `s`) as (`[u8; 32]`, `[u8; 32]`).
    fn sign_message_share(&self, msg: &[u8]) -> ([u8; 32], [u8; 32]) {
        // `k256::ecdsa::SigningKey` uses `Secp256k1` and `SHA-256`.
        let signature: k256::ecdsa::Signature = self.secret.sign(msg);
        let (r, s) = signature.split_bytes();
        (r.into(), s.into())
    }
}

impl MockECDSAIdentityProvider {
    /// Returns the byte representation of the secret key.
    // Used only for testing and demos.
    pub fn export(&self) -> Vec<u8> {
        self.secret.to_bytes().to_vec()
    }
}

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

    #[test]
    fn local_identity_provider_works() {
        // Message to sign.
        let msg = b"Hello, world!";

        // Generate identity provider.
        let identity_provider = MockECDSAIdentityProvider::generate();

        // Signing.
        let signature = identity_provider.sign(msg);

        // Verifying.
        assert!(
            crypto::verify_signature(&identity_provider.verifying_key(), msg, &signature).is_ok()
        );
    }
}