bn254 0.0.1

Open source implementation of Barreto-Naehrig (BN) aggregate signatures written in Rust
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
113
114
115

use super::*;
use crate::ecdsa::check_public_keys;

/// Test for the `ECDSA::sign` function with own test vector
#[test]
fn test_sign_1() {
    // Inputs: private key and message "sample" in ASCII
    let private_key = hex::decode("2009da7287c158b126123c113d1c85241b6e3294dd75c643588630a8bc0f934c").unwrap();
    let data = hex::decode("73616d706c65").unwrap();

    let private_key = PrivateKey::try_from(private_key.as_ref()).unwrap();

    // Sign data with private key
    let signature = ECDSA::sign(data, &private_key).unwrap();

    let expected_signature = "020f047a153e94b5f109e4013d1bd078112817cf0d58cdf6ba8891f9849852ba5b";
    assert_eq!(hex::encode(signature.to_compressed().unwrap()), expected_signature);
}

/// Test `ECDSA::verify` function with own signed message
#[test]
fn test_verify_signed_msg() {
    // Public key
    let private_key = hex::decode("2009da7287c158b126123c113d1c85241b6e3294dd75c643588630a8bc0f934c").unwrap();
    let private_key = PrivateKey::try_from(private_key.as_ref()).unwrap();
    let public_key = PublicKey::from_private_key(&private_key);

    // Signature
    let signature_vec = hex::decode("020f047a153e94b5f109e4013d1bd078112817cf0d58cdf6ba8891f9849852ba5b").unwrap();
    let signature = Signature::from_compressed(signature_vec).unwrap();

    // Message signed
    let msg = hex::decode("73616d706c65").unwrap();

    // Verify signature
    assert!(
        ECDSA::verify(msg, &signature, &public_key).is_ok(),
        "Verification failed"
    );
}

/// Test aggregate signature verification
#[test]
fn test_verify_aggregate_signatures() {
    // Message
    let msg = hex::decode("73616d706c65").unwrap();

    // Signature 1
    let private_key_1_bytes = hex::decode("1ab1126ff2e37c6e6eddea943ccb3a48f83b380b856424ee552e113595525565").unwrap();
    let private_key_1 = PrivateKey::try_from(private_key_1_bytes.as_ref()).unwrap();
    let sign_1 = ECDSA::sign(&msg, &private_key_1).unwrap();

    let public_key_1 = PublicKey::from_private_key(&private_key_1);

    // Signature 2
    let secret_key_2_bytes = hex::decode("2009da7287c158b126123c113d1c85241b6e3294dd75c643588630a8bc0f934c").unwrap();
    let private_key_2 = PrivateKey::try_from(secret_key_2_bytes.as_ref()).unwrap();
    let sign_2 = ECDSA::sign(&msg, &private_key_2).unwrap();

    let public_key_2 = PublicKey::from_private_key(&private_key_2);

    // Public Key and Signature aggregation
    let agg_public_key = public_key_1 + public_key_2;
    let agg_signature = sign_1 + sign_2;

    // Verification single signatures
    assert!(
        ECDSA::verify(&msg, &sign_1, &public_key_1).is_ok(),
        "Signature 1 verification failed"
    );
    assert!(
        ECDSA::verify(&msg, &sign_2, &public_key_2).is_ok(),
        "Signature 2 signature verification failed"
    );

    // Aggregate signature verification
    assert!(
        ECDSA::verify(&msg, &agg_signature, &agg_public_key).is_ok(),
        "Aggregated signature verification failed"
    );
}

/// Test if PubKey in G1 -> PubKey in G2: e(G1, P2) = e(P1, G2)
#[test]
fn test_verify_valid_public_keys_in_g1_g2() {
    let private_key_bytes = hex::decode("1ab1126ff2e37c6e6eddea943ccb3a48f83b380b856424ee552e113595525565").unwrap();
    let private_key = PrivateKey::try_from(private_key_bytes.as_ref()).unwrap();

    // Get public keys in G1 and G2
    let public_g2 = PublicKey::from_private_key(&private_key);
    let public_g1 = PublicKeyG1::from_private_key(&private_key);

    // Check if valid
    assert!(
        check_public_keys(&public_g2, &public_g1).is_ok(),
        "Public Key in G1 DOES NOT correspond to Public Key in G2"
    );
}

/// Test (false-positive) if PubKey in G1 -> PubKey in G2: e(G1, P2) = e(P1, G2)
#[test]
fn test_verify_invalid_public_keys_in_g1_g2() {
    // Get public keys in G1 and G2 (from different private keys)
    let private_key_1_bytes = hex::decode("1ab1126ff2e37c6e6eddea943ccb3a48f83b380b856424ee552e113595525565").unwrap();
    let private_key_1 = PrivateKey::try_from(private_key_1_bytes.as_ref()).unwrap();
    let public_g2 = PublicKey::from_private_key(&private_key_1);

    let private_key_2_bytes = hex::decode("2009da7287c158b126123c113d1c85241b6e3294dd75c643588630a8bc0f934c").unwrap();
    let private_key_2 = PrivateKey::try_from(private_key_2_bytes.as_ref()).unwrap();
    let public_g1 = PublicKeyG1::from_private_key(&private_key_2);

    // Check if valid
    let result = check_public_keys(&public_g2, &public_g1);
    assert!(matches!(result, Err(Error::VerificationFailed)));
}