fuel_crypto/secp256/
backend.rs

1//! Backends for different secp-style elliptic curves
2
3/// secp256k1 implementations
4pub mod k1 {
5    // The k256 module is always available in-crate, since it's tested against secp256k1
6    #[cfg_attr(feature = "std", allow(dead_code))]
7    pub(crate) mod k256;
8    #[cfg(feature = "std")]
9    pub(crate) mod secp256k1;
10
11    // Pick the default backend
12    #[cfg(not(feature = "std"))]
13    pub use self::k256::*;
14    #[cfg(feature = "std")]
15    pub use self::secp256k1::*;
16}
17
18/// secp256r1 implementations
19pub mod r1 {
20    pub mod p256;
21    pub use self::p256::*;
22}
23
24#[cfg(all(test, feature = "std"))]
25mod tests {
26    use rand::{
27        rngs::StdRng,
28        Rng,
29        SeedableRng,
30    };
31
32    use crate::{
33        message::Message,
34        secp256::SecretKey,
35    };
36
37    use super::k1::{
38        k256,
39        secp256k1,
40    };
41
42    /// Make sure that the k256 and secp256k1 backends produce the same results
43    #[test]
44    fn equivalent_k256_secp256k1() {
45        let rng = &mut StdRng::seed_from_u64(1234);
46
47        for case in 0..100 {
48            let secret = SecretKey::random(rng);
49            let message = Message::new(vec![rng.gen(); case]);
50
51            let public_k = k256::public_key(&secret);
52            let public_s = secp256k1::public_key(&secret);
53            assert_eq!(public_k, public_s);
54
55            let signed_k = k256::sign(&secret, &message);
56            let signed_s = secp256k1::sign(&secret, &message);
57            assert_eq!(signed_k, signed_s);
58
59            k256::verify(signed_k, *public_k, &message).expect("Failed to verify (k256)");
60            secp256k1::verify(signed_s, *public_s, &message)
61                .expect("Failed to verify (secp256k1)");
62
63            let recovered_k =
64                k256::recover(signed_k, &message).expect("Failed to recover (k256)");
65            let recovered_s = secp256k1::recover(signed_k, &message)
66                .expect("Failed to recover (secp256k1)");
67            assert_eq!(recovered_k, recovered_s);
68        }
69    }
70}