avalanche-types 0.0.309

Avalanche primitive types 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
116
117
118
119
120
121

use std::io::{self, Error, ErrorKind};

use crate::key::bls::{self, public_key::Key as PublicKey};
use blst::{
    min_pk::{AggregateSignature, Signature},
    BLST_ERROR,
};

#[derive(Debug, Clone)]
pub struct Sig(pub Signature);

pub const LEN: usize = 96;

impl Sig {
    /// Converts the public key to compressed bytes.
    /// ref. "avalanchego/utils/crypto/bls.SignatureToBytes"
    pub fn to_compressed_bytes(&self) -> [u8; LEN] {
        self.0.compress()
    }

    /// Loads the signature from the compressed raw scalar bytes (in big endian).
    pub fn from_bytes(compressed: &[u8]) -> io::Result<Self> {
        let sig = Signature::uncompress(compressed).map_err(|e| {
            Error::new(
                ErrorKind::Other,
                format!("failed blst::min_pk::Signature::uncompress {:?}", e),
            )
        })?;
        sig.validate(false).map_err(|e| {
            Error::new(
                ErrorKind::Other,
                format!("failed blst::min_pk::Signature::validate {:?}", e),
            )
        })?;

        Ok(Self(sig))
    }

    /// Verifies the message and the validity of its signature.
    /// Invariant: [pubkey] and [self.0] have both been validated.
    /// ref. "avalanchego/utils/crypto/bls.Verify"
    pub fn verify(&self, msg: &[u8], pubkey: &PublicKey) -> bool {
        self.0.verify(
            false,
            msg,
            &bls::private_key::CIPHER_SUITE_SIGNATURE,
            &[],
            &pubkey.0,
            false,
        ) == BLST_ERROR::BLST_SUCCESS
    }

    /// Verifies the message and the validity of its signature.
    /// Invariant: [pubkey] and [self.0] have both been validated.
    /// ref. "avalanchego/utils/crypto/bls.VerifyProofOfPossession"
    pub fn verify_proof_of_possession(&self, msg: &[u8], pubkey: &PublicKey) -> bool {
        self.0.verify(
            false,
            msg,
            &bls::private_key::CIPHER_SUITE_PROOF_OF_POSSESSION,
            &[],
            &pubkey.0,
            false,
        ) == BLST_ERROR::BLST_SUCCESS
    }
}

impl From<Signature> for Sig {
    fn from(s: Signature) -> Self {
        Self(s)
    }
}

impl From<Sig> for Signature {
    fn from(s: Sig) -> Self {
        s.0
    }
}

pub fn aggregate(sigs: &[Sig]) -> io::Result<Sig> {
    let mut ss = Vec::with_capacity(sigs.len());
    for s in sigs.iter() {
        ss.push(&s.0);
    }

    let agg_sig = AggregateSignature::aggregate(&ss, false).map_err(|e| {
        Error::new(
            ErrorKind::Other,
            format!("failed AggregateSignature::aggregate {:?}", e),
        )
    })?;
    Ok(Sig(agg_sig.to_signature()))
}

/// RUST_LOG=debug cargo test --package avalanche-types --lib -- key::bls::signature::test_signature --exact --show-output
#[test]
fn test_signature() {
    let _ = env_logger::builder()
        .filter_level(log::LevelFilter::Info)
        .is_test(true)
        .try_init();

    let sk = crate::key::bls::private_key::Key::generate().unwrap();
    let pubkey = sk.to_public_key();

    let msg = random_manager::secure_bytes(50).unwrap();
    let sig = sk.sign(&msg);
    let sig_bytes = sig.to_compressed_bytes();

    assert!(sig.verify(&msg, &pubkey));
    assert!(!sig.verify_proof_of_possession(&msg, &pubkey));

    let sig_pos = sk.sign_proof_of_possession(&msg);
    assert!(!sig_pos.verify(&msg, &pubkey));
    assert!(sig_pos.verify_proof_of_possession(&msg, &pubkey));

    let agg_sig = aggregate(&[sig]).unwrap();
    let agg_sig_bytes = agg_sig.to_compressed_bytes();

    assert_eq!(sig_bytes, agg_sig_bytes);
}