fuel-crypto 0.66.4

Fuel cryptographic primitives.
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
113
114

use crate::{
    Error,
    Message,
    PublicKey,
    SecretKey,
    Signature,
};

#[cfg(feature = "std")]
use rand::{
    SeedableRng,
    rngs::StdRng,
};

#[cfg(feature = "std")]
#[test]
fn recover() {
    let rng = &mut StdRng::seed_from_u64(8586);

    let message = b"A beast can never be as cruel as a human being, so artistically, so picturesquely cruel.";

    for _ in 0..100 {
        let message = Message::new(message);

        let secret = SecretKey::random(rng);
        let public = secret.public_key();

        let signature = Signature::sign(&secret, &message);
        let recover = signature.recover(&message).expect("Failed to recover PK");

        assert_eq!(public, recover);
    }
}

#[cfg(feature = "std")]
#[test]
fn verify() {
    let rng = &mut StdRng::seed_from_u64(8586);

    let message = b"Music expresses that which cannot be put into words and that which cannot remain silent.";

    for _ in 0..100 {
        let message = Message::new(message);

        let secret = SecretKey::random(rng);
        let public = secret.public_key();

        let pub1 = crate::secp256::backend::k1::public_key(&secret);
        let pub2 = crate::secp256::backend::k1::public_key(&secret);
        assert_eq!(pub1, pub2);

        let signature = Signature::sign(&secret, &message);

        signature
            .verify(&public, &message)
            .expect("Failed to verify signature");
    }
}

#[test]
fn corrupted_signature() {
    let rng = &mut StdRng::seed_from_u64(8586);

    let message = b"When life itself seems lunatic, who knows where madness lies?";
    let message = Message::new(message);

    let secret = SecretKey::random(rng);
    let public = secret.public_key();

    let signature = Signature::sign(&secret, &message);

    // Tamper, bit by bit, the signature and public key.
    //
    // The recover and verify operations should fail in all cases.
    (0..Signature::LEN).for_each(|i| {
        (0..7).fold(1u8, |m, _| {
            let mut s = signature;

            s.as_mut()[i] ^= m;

            match s.recover(&message) {
                Ok(pk) => assert_ne!(public, pk),
                Err(Error::InvalidSignature) => (),
                Err(e) => panic!("Unexpected error: {e}"),
            }

            m << 1
        });
    });

    (0..Signature::LEN).for_each(|i| {
        (0..7).fold(1u8, |m, _| {
            let mut s = signature;

            s.as_mut()[i] ^= m;

            assert!(s.verify(&public, &message).is_err());

            m << 1
        });
    });

    (0..PublicKey::LEN).for_each(|i| {
        (0..7).fold(1u8, |m, _| {
            let mut p = public;

            p.as_mut()[i] ^= m;

            assert!(signature.verify(&p, &message).is_err());

            m << 1
        });
    });
}