commonware_cryptography/bls12381/
scheme.rs

1//! BLS12-381 implementation of the `Scheme` trait.
2//!
3//! # Example
4//! ```rust
5//! use commonware_cryptography::{Bls12381, Scheme};
6//! use rand::rngs::OsRng;
7//!
8//! // Generate a new private key
9//! let mut signer = Bls12381::new(&mut OsRng);
10//!
11//! // Create a message to sign
12//! let namespace = Some(&b"demo"[..]);
13//! let msg = b"hello, world!";
14//!
15//! // Sign the message
16//! let signature = signer.sign(namespace, msg);
17//!
18//! // Verify the signature
19//! assert!(Bls12381::verify(namespace, msg, &signer.public_key(), &signature));
20//! ```
21
22use super::primitives::{
23    group::{self, Element, Scalar},
24    ops,
25};
26use crate::{Array, Error, Scheme};
27use commonware_utils::{hex, SizedSerialize};
28use rand::{CryptoRng, Rng};
29use std::{
30    fmt::{Debug, Display},
31    hash::{Hash, Hasher},
32    ops::Deref,
33};
34
35/// BLS12-381 implementation of the `Scheme` trait.
36///
37/// This implementation uses the `blst` crate for BLS12-381 operations. This
38/// crate implements serialization according to the "ZCash BLS12-381" specification
39/// (<https://github.com/supranational/blst/tree/master?tab=readme-ov-file#serialization-format>) and
40/// hashes messages according to RFC 9380.
41#[derive(Clone)]
42pub struct Bls12381 {
43    private: group::Private,
44    public: group::Public,
45}
46
47impl Scheme for Bls12381 {
48    type PrivateKey = PrivateKey;
49    type PublicKey = PublicKey;
50    type Signature = Signature;
51
52    fn new<R: CryptoRng + Rng>(r: &mut R) -> Self {
53        let (private, public) = ops::keypair(r);
54        Self { private, public }
55    }
56
57    fn from(private_key: PrivateKey) -> Option<Self> {
58        let private = private_key.key;
59        let mut public = group::Public::one();
60        public.mul(&private);
61        Some(Self { private, public })
62    }
63
64    fn private_key(&self) -> PrivateKey {
65        PrivateKey::from(self.private)
66    }
67
68    fn public_key(&self) -> PublicKey {
69        PublicKey::from(self.public)
70    }
71
72    fn sign(&mut self, namespace: Option<&[u8]>, message: &[u8]) -> Signature {
73        let signature = ops::sign_message(&self.private, namespace, message);
74        Signature::from(signature)
75    }
76
77    fn verify(
78        namespace: Option<&[u8]>,
79        message: &[u8],
80        public_key: &PublicKey,
81        signature: &Signature,
82    ) -> bool {
83        ops::verify_message(&public_key.key, namespace, message, &signature.signature).is_ok()
84    }
85}
86
87/// BLS12-381 private key.
88#[derive(Clone, Eq, PartialEq)]
89pub struct PrivateKey {
90    raw: [u8; group::PRIVATE_KEY_LENGTH],
91    key: group::Private,
92}
93
94impl Array for PrivateKey {}
95
96impl SizedSerialize for PrivateKey {
97    const SERIALIZED_LEN: usize = group::PRIVATE_KEY_LENGTH;
98}
99
100impl Hash for PrivateKey {
101    fn hash<H: Hasher>(&self, state: &mut H) {
102        self.raw.hash(state);
103    }
104}
105
106impl Ord for PrivateKey {
107    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
108        self.raw.cmp(&other.raw)
109    }
110}
111
112impl PartialOrd for PrivateKey {
113    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
114        Some(self.cmp(other))
115    }
116}
117
118impl AsRef<[u8]> for PrivateKey {
119    fn as_ref(&self) -> &[u8] {
120        &self.raw
121    }
122}
123
124impl Deref for PrivateKey {
125    type Target = [u8];
126    fn deref(&self) -> &[u8] {
127        &self.raw
128    }
129}
130
131impl From<Scalar> for PrivateKey {
132    fn from(key: Scalar) -> Self {
133        let raw: [u8; group::PRIVATE_KEY_LENGTH] = key.serialize().try_into().unwrap();
134        Self { raw, key }
135    }
136}
137
138impl TryFrom<&[u8]> for PrivateKey {
139    type Error = Error;
140    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
141        let raw: [u8; group::PRIVATE_KEY_LENGTH] = value
142            .try_into()
143            .map_err(|_| Error::InvalidPrivateKeyLength)?;
144        let key = Scalar::deserialize(value).ok_or(Error::InvalidPrivateKey)?;
145        Ok(Self { raw, key })
146    }
147}
148
149impl TryFrom<&Vec<u8>> for PrivateKey {
150    type Error = Error;
151    fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
152        Self::try_from(value.as_slice())
153    }
154}
155
156impl TryFrom<Vec<u8>> for PrivateKey {
157    type Error = Error;
158    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
159        Self::try_from(value.as_slice())
160    }
161}
162
163impl Debug for PrivateKey {
164    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
165        write!(f, "{}", hex(&self.raw))
166    }
167}
168
169impl Display for PrivateKey {
170    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
171        write!(f, "{}", hex(&self.raw))
172    }
173}
174
175/// BLS12-381 public key.
176#[derive(Clone, Eq, PartialEq)]
177pub struct PublicKey {
178    raw: [u8; group::PUBLIC_KEY_LENGTH],
179    key: group::Public,
180}
181
182impl Array for PublicKey {}
183
184impl SizedSerialize for PublicKey {
185    const SERIALIZED_LEN: usize = group::PUBLIC_KEY_LENGTH;
186}
187
188impl Hash for PublicKey {
189    fn hash<H: Hasher>(&self, state: &mut H) {
190        self.raw.hash(state);
191    }
192}
193
194impl Ord for PublicKey {
195    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
196        self.raw.cmp(&other.raw)
197    }
198}
199
200impl PartialOrd for PublicKey {
201    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
202        Some(self.cmp(other))
203    }
204}
205
206impl AsRef<[u8]> for PublicKey {
207    fn as_ref(&self) -> &[u8] {
208        &self.raw
209    }
210}
211
212impl Deref for PublicKey {
213    type Target = [u8];
214    fn deref(&self) -> &[u8] {
215        &self.raw
216    }
217}
218
219impl From<group::Public> for PublicKey {
220    fn from(key: group::Public) -> Self {
221        let raw = key.serialize().try_into().unwrap();
222        Self { raw, key }
223    }
224}
225
226impl TryFrom<&[u8]> for PublicKey {
227    type Error = Error;
228    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
229        let raw: [u8; group::PUBLIC_KEY_LENGTH] = value
230            .try_into()
231            .map_err(|_| Error::InvalidPublicKeyLength)?;
232        let key = group::Public::deserialize(value).ok_or(Error::InvalidPublicKey)?;
233        Ok(Self { raw, key })
234    }
235}
236
237impl TryFrom<&Vec<u8>> for PublicKey {
238    type Error = Error;
239    fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
240        Self::try_from(value.as_slice())
241    }
242}
243
244impl TryFrom<Vec<u8>> for PublicKey {
245    type Error = Error;
246    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
247        Self::try_from(value.as_slice())
248    }
249}
250
251impl Debug for PublicKey {
252    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
253        write!(f, "{}", hex(&self.raw))
254    }
255}
256
257impl Display for PublicKey {
258    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
259        write!(f, "{}", hex(&self.raw))
260    }
261}
262
263/// BLS12-381 signature.
264#[derive(Clone, Eq, PartialEq)]
265pub struct Signature {
266    raw: [u8; group::SIGNATURE_LENGTH],
267    signature: group::Signature,
268}
269
270impl Array for Signature {}
271
272impl SizedSerialize for Signature {
273    const SERIALIZED_LEN: usize = group::SIGNATURE_LENGTH;
274}
275
276impl Hash for Signature {
277    fn hash<H: Hasher>(&self, state: &mut H) {
278        self.raw.hash(state);
279    }
280}
281
282impl Ord for Signature {
283    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
284        self.raw.cmp(&other.raw)
285    }
286}
287
288impl PartialOrd for Signature {
289    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
290        Some(self.cmp(other))
291    }
292}
293
294impl AsRef<[u8]> for Signature {
295    fn as_ref(&self) -> &[u8] {
296        &self.raw
297    }
298}
299
300impl Deref for Signature {
301    type Target = [u8];
302    fn deref(&self) -> &[u8] {
303        &self.raw
304    }
305}
306
307impl From<group::Signature> for Signature {
308    fn from(signature: group::Signature) -> Self {
309        let raw = signature.serialize().try_into().unwrap();
310        Self { raw, signature }
311    }
312}
313
314impl TryFrom<&[u8]> for Signature {
315    type Error = Error;
316    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
317        let raw: [u8; group::SIGNATURE_LENGTH] = value
318            .try_into()
319            .map_err(|_| Error::InvalidSignatureLength)?;
320        let signature = group::Signature::deserialize(value).ok_or(Error::InvalidSignature)?;
321        Ok(Self { raw, signature })
322    }
323}
324
325impl TryFrom<&Vec<u8>> for Signature {
326    type Error = Error;
327    fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
328        Self::try_from(value.as_slice())
329    }
330}
331
332impl TryFrom<Vec<u8>> for Signature {
333    type Error = Error;
334    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
335        Self::try_from(value.as_slice())
336    }
337}
338
339impl Debug for Signature {
340    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
341        write!(f, "{}", hex(&self.raw))
342    }
343}
344
345impl Display for Signature {
346    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
347        write!(f, "{}", hex(&self.raw))
348    }
349}
350
351/// Test vectors sourced from https://github.com/ethereum/bls12-381-tests/releases/tag/v0.1.2.
352#[cfg(test)]
353mod tests {
354    use super::*;
355
356    #[test]
357    fn test_sign() {
358        let cases = [
359            vector_sign_1(),
360            vector_sign_2(),
361            vector_sign_3(),
362            vector_sign_4(),
363            vector_sign_5(),
364            vector_sign_6(),
365            vector_sign_7(),
366            vector_sign_8(),
367            vector_sign_9(),
368        ];
369        for (index, test) in cases.into_iter().enumerate() {
370            let (private_key, message, expected) = test;
371            let mut signer =
372                <Bls12381 as Scheme>::from(private_key).expect("unable to deserialize private key");
373            let signature = signer.sign(None, &message);
374            assert_eq!(signature, expected, "vector_sign_{}", index + 1);
375        }
376    }
377
378    #[test]
379    fn test_sign_10() {
380        let result =
381            parse_private_key("0x0000000000000000000000000000000000000000000000000000000000000000");
382        assert!(result.is_err());
383    }
384
385    #[test]
386    fn test_verify() {
387        let cases = [
388            vector_verify_1(),
389            vector_verify_2(),
390            vector_verify_3(),
391            vector_verify_4(),
392            vector_verify_5(),
393            vector_verify_6(),
394            vector_verify_7(),
395            vector_verify_8(),
396            vector_verify_9(),
397            vector_verify_10(),
398            vector_verify_11(),
399            vector_verify_12(),
400            vector_verify_13(),
401            vector_verify_14(),
402            vector_verify_15(),
403            vector_verify_16(),
404            vector_verify_17(),
405            vector_verify_18(),
406            vector_verify_19(),
407            vector_verify_20(),
408            vector_verify_21(),
409            vector_verify_22(),
410            vector_verify_23(),
411            vector_verify_24(),
412            vector_verify_25(),
413            vector_verify_26(),
414            vector_verify_27(),
415            vector_verify_28(),
416            vector_verify_29(),
417        ];
418
419        for (index, test) in cases.into_iter().enumerate() {
420            let (public_key, message, signature, expected) = test;
421            let expected = if !expected {
422                public_key.is_err()
423                    || signature.is_err()
424                    || !Bls12381::verify(None, &message, &public_key.unwrap(), &signature.unwrap())
425            } else {
426                Bls12381::verify(None, &message, &public_key.unwrap(), &signature.unwrap())
427            };
428            assert!(expected, "vector_verify_{}", index + 1);
429        }
430    }
431
432    /// Parse `sign` vector from hex encoded data.
433    fn parse_sign_vector(
434        private_key: &str,
435        msg: &str,
436        signature: &str,
437    ) -> (PrivateKey, Vec<u8>, Signature) {
438        (
439            parse_private_key(private_key).unwrap(),
440            commonware_utils::from_hex_formatted(msg).unwrap(),
441            parse_signature(signature).unwrap(),
442        )
443    }
444
445    fn parse_private_key(private_key: &str) -> Result<PrivateKey, Error> {
446        PrivateKey::try_from(commonware_utils::from_hex_formatted(private_key).unwrap())
447    }
448    fn parse_public_key(public_key: &str) -> Result<PublicKey, Error> {
449        PublicKey::try_from(commonware_utils::from_hex_formatted(public_key).unwrap())
450    }
451    fn parse_signature(signature: &str) -> Result<Signature, Error> {
452        Signature::try_from(commonware_utils::from_hex_formatted(signature).unwrap())
453    }
454
455    // sign_case_8cd3d4d0d9a5b265
456    fn vector_sign_1() -> (PrivateKey, Vec<u8>, Signature) {
457        parse_sign_vector(
458            "0x263dbd792f5b1be47ed85f8938c0f29586af0d3ac7b977f21c278fe1462040e3",
459            "0x5656565656565656565656565656565656565656565656565656565656565656",
460            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972503a43eb"
461        )
462    }
463
464    // sign_case_11b8c7cad5238946
465    fn vector_sign_2() -> (PrivateKey, Vec<u8>, Signature) {
466        parse_sign_vector(
467            "0x47b8192d77bf871b62e87859d653922725724a5c031afeabc60bcef5ff665138",
468            "0x0000000000000000000000000000000000000000000000000000000000000000",
469            "0xb23c46be3a001c63ca711f87a005c200cc550b9429d5f4eb38d74322144f1b63926da3388979e5321012fb1a0526bcd100b5ef5fe72628ce4cd5e904aeaa3279527843fae5ca9ca675f4f51ed8f83bbf7155da9ecc9663100a885d5dc6df96d9"
470        )
471    }
472
473    // sign_case_84d45c9c7cca6b92
474    fn vector_sign_3() -> (PrivateKey, Vec<u8>, Signature) {
475        parse_sign_vector(
476            "0x328388aff0d4a5b7dc9205abd374e7e98f3cd9f3418edb4eafda5fb16473d216",
477            "0xabababababababababababababababababababababababababababababababab",
478            "0xae82747ddeefe4fd64cf9cedb9b04ae3e8a43420cd255e3c7cd06a8d88b7c7f8638543719981c5d16fa3527c468c25f0026704a6951bde891360c7e8d12ddee0559004ccdbe6046b55bae1b257ee97f7cdb955773d7cf29adf3ccbb9975e4eb9"
479        )
480    }
481
482    // sign_case_142f678a8d05fcd1
483    fn vector_sign_4() -> (PrivateKey, Vec<u8>, Signature) {
484        parse_sign_vector(
485            "0x47b8192d77bf871b62e87859d653922725724a5c031afeabc60bcef5ff665138",
486            "0x5656565656565656565656565656565656565656565656565656565656565656",
487            "0xaf1390c3c47acdb37131a51216da683c509fce0e954328a59f93aebda7e4ff974ba208d9a4a2a2389f892a9d418d618418dd7f7a6bc7aa0da999a9d3a5b815bc085e14fd001f6a1948768a3f4afefc8b8240dda329f984cb345c6363272ba4fe"
488        )
489    }
490
491    // sign_case_37286e1a6d1f6eb3
492    fn vector_sign_5() -> (PrivateKey, Vec<u8>, Signature) {
493        parse_sign_vector(
494            "0x47b8192d77bf871b62e87859d653922725724a5c031afeabc60bcef5ff665138",
495            "0xabababababababababababababababababababababababababababababababab",
496            "0x9674e2228034527f4c083206032b020310face156d4a4685e2fcaec2f6f3665aa635d90347b6ce124eb879266b1e801d185de36a0a289b85e9039662634f2eea1e02e670bc7ab849d006a70b2f93b84597558a05b879c8d445f387a5d5b653df"
497        )
498    }
499
500    // sign_case_7055381f640f2c1d
501    fn vector_sign_6() -> (PrivateKey, Vec<u8>, Signature) {
502        parse_sign_vector(
503            "0x328388aff0d4a5b7dc9205abd374e7e98f3cd9f3418edb4eafda5fb16473d216",
504            "0x0000000000000000000000000000000000000000000000000000000000000000",
505            "0x948a7cb99f76d616c2c564ce9bf4a519f1bea6b0a624a02276443c245854219fabb8d4ce061d255af5330b078d5380681751aa7053da2c98bae898edc218c75f07e24d8802a17cd1f6833b71e58f5eb5b94208b4d0bb3848cecb075ea21be115"
506        )
507    }
508
509    // sign_case_c82df61aa3ee60fb
510    fn vector_sign_7() -> (PrivateKey, Vec<u8>, Signature) {
511        parse_sign_vector(
512            "0x263dbd792f5b1be47ed85f8938c0f29586af0d3ac7b977f21c278fe1462040e3",
513            "0x0000000000000000000000000000000000000000000000000000000000000000",
514            "0xb6ed936746e01f8ecf281f020953fbf1f01debd5657c4a383940b020b26507f6076334f91e2366c96e9ab279fb5158090352ea1c5b0c9274504f4f0e7053af24802e51e4568d164fe986834f41e55c8e850ce1f98458c0cfc9ab380b55285a55"
515        )
516    }
517
518    // sign_case_d0e28d7e76eb6e9c
519    fn vector_sign_8() -> (PrivateKey, Vec<u8>, Signature) {
520        parse_sign_vector(
521            "0x263dbd792f5b1be47ed85f8938c0f29586af0d3ac7b977f21c278fe1462040e3",
522            "0x5656565656565656565656565656565656565656565656565656565656565656",
523            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972503a43eb"
524        )
525    }
526
527    // sign_case_f2ae1097e7d0e18b
528    fn vector_sign_9() -> (PrivateKey, Vec<u8>, Signature) {
529        parse_sign_vector(
530            "0x263dbd792f5b1be47ed85f8938c0f29586af0d3ac7b977f21c278fe1462040e3",
531            "0xabababababababababababababababababababababababababababababababab",
532            "0x91347bccf740d859038fcdcaf233eeceb2a436bcaaee9b2aa3bfb70efe29dfb2677562ccbea1c8e061fb9971b0753c240622fab78489ce96768259fc01360346da5b9f579e5da0d941e4c6ba18a0e64906082375394f337fa1af2b7127b0d121"
533        )
534    }
535
536    /// Parse `verify` vector from hex encoded data.
537    fn parse_verify_vector(
538        public_key: &str,
539        msg: &str,
540        signature: &str,
541    ) -> (Result<PublicKey, Error>, Vec<u8>, Result<Signature, Error>) {
542        (
543            parse_public_key(public_key),
544            commonware_utils::from_hex_formatted(msg).unwrap(),
545            parse_signature(signature),
546        )
547    }
548
549    // verify_infinity_pubkey_and_infinity_signature
550    fn vector_verify_1() -> (
551        Result<PublicKey, Error>,
552        Vec<u8>,
553        Result<Signature, Error>,
554        bool,
555    ) {
556        let v = parse_verify_vector(
557                "0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
558                "0x1212121212121212121212121212121212121212121212121212121212121212",
559                "0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
560            );
561        (v.0, v.1, v.2, false)
562    }
563
564    // verify_tampered_signature_case_2ea479adf8c40300
565    fn vector_verify_2() -> (
566        Result<PublicKey, Error>,
567        Vec<u8>,
568        Result<Signature, Error>,
569        bool,
570    ) {
571        let v = parse_verify_vector(
572            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
573            "0x5656565656565656565656565656565656565656565656565656565656565656",
574            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972ffffffff",
575        );
576        (v.0, v.1, v.2, false)
577    }
578
579    // verify_tampered_signature_case_2f09d443ab8a3ac2
580    fn vector_verify_3() -> (
581        Result<PublicKey, Error>,
582        Vec<u8>,
583        Result<Signature, Error>,
584        bool,
585    ) {
586        let v = parse_verify_vector(
587            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
588            "0x0000000000000000000000000000000000000000000000000000000000000000",
589            "0xb23c46be3a001c63ca711f87a005c200cc550b9429d5f4eb38d74322144f1b63926da3388979e5321012fb1a0526bcd100b5ef5fe72628ce4cd5e904aeaa3279527843fae5ca9ca675f4f51ed8f83bbf7155da9ecc9663100a885d5dffffffff",
590        );
591        (v.0, v.1, v.2, false)
592    }
593
594    // verify_tampered_signature_case_6b3b17f6962a490c
595    fn vector_verify_4() -> (
596        Result<PublicKey, Error>,
597        Vec<u8>,
598        Result<Signature, Error>,
599        bool,
600    ) {
601        let v = parse_verify_vector(
602            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
603            "0x5656565656565656565656565656565656565656565656565656565656565656",
604            "0xa4efa926610b8bd1c8330c918b7a5e9bf374e53435ef8b7ec186abf62e1b1f65aeaaeb365677ac1d1172a1f5b44b4e6d022c252c58486c0a759fbdc7de15a756acc4d343064035667a594b4c2a6f0b0b421975977f297dba63ee2f63ffffffff",
605        );
606        (v.0, v.1, v.2, false)
607    }
608
609    // verify_tampered_signature_case_6eeb7c52dfd9baf0
610    fn vector_verify_5() -> (
611        Result<PublicKey, Error>,
612        Vec<u8>,
613        Result<Signature, Error>,
614        bool,
615    ) {
616        let v = parse_verify_vector(
617            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
618            "0xabababababababababababababababababababababababababababababababab",
619            "0x9674e2228034527f4c083206032b020310face156d4a4685e2fcaec2f6f3665aa635d90347b6ce124eb879266b1e801d185de36a0a289b85e9039662634f2eea1e02e670bc7ab849d006a70b2f93b84597558a05b879c8d445f387a5ffffffff",
620        );
621        (v.0, v.1, v.2, false)
622    }
623
624    // verify_tampered_signature_case_8761a0b7e920c323
625    fn vector_verify_6() -> (
626        Result<PublicKey, Error>,
627        Vec<u8>,
628        Result<Signature, Error>,
629        bool,
630    ) {
631        let v = parse_verify_vector(
632            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
633            "0xabababababababababababababababababababababababababababababababab",
634            "0x91347bccf740d859038fcdcaf233eeceb2a436bcaaee9b2aa3bfb70efe29dfb2677562ccbea1c8e061fb9971b0753c240622fab78489ce96768259fc01360346da5b9f579e5da0d941e4c6ba18a0e64906082375394f337fa1af2b71ffffffff",
635        );
636        (v.0, v.1, v.2, false)
637    }
638
639    // verify_tampered_signature_case_195246ee3bd3b6ec
640    fn vector_verify_7() -> (
641        Result<PublicKey, Error>,
642        Vec<u8>,
643        Result<Signature, Error>,
644        bool,
645    ) {
646        let v = parse_verify_vector(
647            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
648            "0xabababababababababababababababababababababababababababababababab",
649            "0xae82747ddeefe4fd64cf9cedb9b04ae3e8a43420cd255e3c7cd06a8d88b7c7f8638543719981c5d16fa3527c468c25f0026704a6951bde891360c7e8d12ddee0559004ccdbe6046b55bae1b257ee97f7cdb955773d7cf29adf3ccbb9ffffffff",
650        );
651        (v.0, v.1, v.2, false)
652    }
653
654    // verify_tampered_signature_case_3208262581c8fc09
655    fn vector_verify_8() -> (
656        Result<PublicKey, Error>,
657        Vec<u8>,
658        Result<Signature, Error>,
659        bool,
660    ) {
661        let v = parse_verify_vector(
662            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
663            "0x5656565656565656565656565656565656565656565656565656565656565656",
664            "0xaf1390c3c47acdb37131a51216da683c509fce0e954328a59f93aebda7e4ff974ba208d9a4a2a2389f892a9d418d618418dd7f7a6bc7aa0da999a9d3a5b815bc085e14fd001f6a1948768a3f4afefc8b8240dda329f984cb345c6363ffffffff",
665        );
666        (v.0, v.1, v.2, false)
667    }
668
669    // verify_tampered_signature_case_d34885d766d5f705
670    fn vector_verify_9() -> (
671        Result<PublicKey, Error>,
672        Vec<u8>,
673        Result<Signature, Error>,
674        bool,
675    ) {
676        let v = parse_verify_vector(
677            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
678            "0x0000000000000000000000000000000000000000000000000000000000000000",
679            "0x948a7cb99f76d616c2c564ce9bf4a519f1bea6b0a624a02276443c245854219fabb8d4ce061d255af5330b078d5380681751aa7053da2c98bae898edc218c75f07e24d8802a17cd1f6833b71e58f5eb5b94208b4d0bb3848cecb075effffffff",
680        );
681        (v.0, v.1, v.2, false)
682    }
683
684    // verify_tampered_signature_case_e8a50c445c855360
685    fn vector_verify_10() -> (
686        Result<PublicKey, Error>,
687        Vec<u8>,
688        Result<Signature, Error>,
689        bool,
690    ) {
691        let v= parse_verify_vector(
692            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
693            "0x0000000000000000000000000000000000000000000000000000000000000000",
694            "0xb6ed936746e01f8ecf281f020953fbf1f01debd5657c4a383940b020b26507f6076334f91e2366c96e9ab279fb5158090352ea1c5b0c9274504f4f0e7053af24802e51e4568d164fe986834f41e55c8e850ce1f98458c0cfc9ab380bffffffff",
695        );
696        (v.0, v.1, v.2, false)
697    }
698
699    // verify_valid_case_2ea479adf8c40300
700    fn vector_verify_11() -> (
701        Result<PublicKey, Error>,
702        Vec<u8>,
703        Result<Signature, Error>,
704        bool,
705    ) {
706        let v= parse_verify_vector(
707            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
708            "0x5656565656565656565656565656565656565656565656565656565656565656",
709            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972503a43eb",
710        );
711        (v.0, v.1, v.2, true)
712    }
713
714    // verify_valid_case_2f09d443ab8a3ac2
715    fn vector_verify_12() -> (
716        Result<PublicKey, Error>,
717        Vec<u8>,
718        Result<Signature, Error>,
719        bool,
720    ) {
721        let v = parse_verify_vector(
722            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
723            "0x0000000000000000000000000000000000000000000000000000000000000000",
724            "0xb23c46be3a001c63ca711f87a005c200cc550b9429d5f4eb38d74322144f1b63926da3388979e5321012fb1a0526bcd100b5ef5fe72628ce4cd5e904aeaa3279527843fae5ca9ca675f4f51ed8f83bbf7155da9ecc9663100a885d5dc6df96d9",
725        );
726        (v.0, v.1, v.2, true)
727    }
728
729    // verify_valid_case_6b3b17f6962a490c
730    fn vector_verify_13() -> (
731        Result<PublicKey, Error>,
732        Vec<u8>,
733        Result<Signature, Error>,
734        bool,
735    ) {
736        let v = parse_verify_vector(
737            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
738            "0x5656565656565656565656565656565656565656565656565656565656565656",
739            "0xa4efa926610b8bd1c8330c918b7a5e9bf374e53435ef8b7ec186abf62e1b1f65aeaaeb365677ac1d1172a1f5b44b4e6d022c252c58486c0a759fbdc7de15a756acc4d343064035667a594b4c2a6f0b0b421975977f297dba63ee2f63ffe47bb6",
740        );
741        (v.0, v.1, v.2, true)
742    }
743
744    // verify_valid_case_6eeb7c52dfd9baf0
745    fn vector_verify_14() -> (
746        Result<PublicKey, Error>,
747        Vec<u8>,
748        Result<Signature, Error>,
749        bool,
750    ) {
751        let v = parse_verify_vector(
752            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
753            "0xabababababababababababababababababababababababababababababababab",
754            "0x9674e2228034527f4c083206032b020310face156d4a4685e2fcaec2f6f3665aa635d90347b6ce124eb879266b1e801d185de36a0a289b85e9039662634f2eea1e02e670bc7ab849d006a70b2f93b84597558a05b879c8d445f387a5d5b653df",
755        );
756        (v.0, v.1, v.2, true)
757    }
758
759    // verify_valid_case_8761a0b7e920c323
760    fn vector_verify_15() -> (
761        Result<PublicKey, Error>,
762        Vec<u8>,
763        Result<Signature, Error>,
764        bool,
765    ) {
766        let v = parse_verify_vector(
767            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
768            "0xabababababababababababababababababababababababababababababababab",
769            "0x91347bccf740d859038fcdcaf233eeceb2a436bcaaee9b2aa3bfb70efe29dfb2677562ccbea1c8e061fb9971b0753c240622fab78489ce96768259fc01360346da5b9f579e5da0d941e4c6ba18a0e64906082375394f337fa1af2b7127b0d121",
770        );
771        (v.0, v.1, v.2, true)
772    }
773
774    // verify_valid_case_195246ee3bd3b6ec
775    fn vector_verify_16() -> (
776        Result<PublicKey, Error>,
777        Vec<u8>,
778        Result<Signature, Error>,
779        bool,
780    ) {
781        let v = parse_verify_vector(
782            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
783            "0xabababababababababababababababababababababababababababababababab",
784            "0xae82747ddeefe4fd64cf9cedb9b04ae3e8a43420cd255e3c7cd06a8d88b7c7f8638543719981c5d16fa3527c468c25f0026704a6951bde891360c7e8d12ddee0559004ccdbe6046b55bae1b257ee97f7cdb955773d7cf29adf3ccbb9975e4eb9",
785        );
786        (v.0, v.1, v.2, true)
787    }
788
789    // verify_valid_case_3208262581c8fc09
790    fn vector_verify_17() -> (
791        Result<PublicKey, Error>,
792        Vec<u8>,
793        Result<Signature, Error>,
794        bool,
795    ) {
796        let v = parse_verify_vector(
797            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
798            "0x5656565656565656565656565656565656565656565656565656565656565656",
799            "0xaf1390c3c47acdb37131a51216da683c509fce0e954328a59f93aebda7e4ff974ba208d9a4a2a2389f892a9d418d618418dd7f7a6bc7aa0da999a9d3a5b815bc085e14fd001f6a1948768a3f4afefc8b8240dda329f984cb345c6363272ba4fe",
800        );
801        (v.0, v.1, v.2, true)
802    }
803
804    // verify_valid_case_d34885d766d5f705
805    fn vector_verify_18() -> (
806        Result<PublicKey, Error>,
807        Vec<u8>,
808        Result<Signature, Error>,
809        bool,
810    ) {
811        let v = parse_verify_vector(
812            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
813            "0x0000000000000000000000000000000000000000000000000000000000000000",
814            "0x948a7cb99f76d616c2c564ce9bf4a519f1bea6b0a624a02276443c245854219fabb8d4ce061d255af5330b078d5380681751aa7053da2c98bae898edc218c75f07e24d8802a17cd1f6833b71e58f5eb5b94208b4d0bb3848cecb075ea21be115",
815        );
816        (v.0, v.1, v.2, true)
817    }
818
819    // verify_valid_case_e8a50c445c855360
820    fn vector_verify_19() -> (
821        Result<PublicKey, Error>,
822        Vec<u8>,
823        Result<Signature, Error>,
824        bool,
825    ) {
826        let v = parse_verify_vector(
827            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
828            "0x0000000000000000000000000000000000000000000000000000000000000000",
829            "0xb6ed936746e01f8ecf281f020953fbf1f01debd5657c4a383940b020b26507f6076334f91e2366c96e9ab279fb5158090352ea1c5b0c9274504f4f0e7053af24802e51e4568d164fe986834f41e55c8e850ce1f98458c0cfc9ab380b55285a55",
830        );
831        (v.0, v.1, v.2, true)
832    }
833
834    // verify_wrong_pubkey_case_2ea479adf8c40300
835    fn vector_verify_20() -> (
836        Result<PublicKey, Error>,
837        Vec<u8>,
838        Result<Signature, Error>,
839        bool,
840    ) {
841        let v = parse_verify_vector(
842            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
843            "0x5656565656565656565656565656565656565656565656565656565656565656",
844            "0xa4efa926610b8bd1c8330c918b7a5e9bf374e53435ef8b7ec186abf62e1b1f65aeaaeb365677ac1d1172a1f5b44b4e6d022c252c58486c0a759fbdc7de15a756acc4d343064035667a594b4c2a6f0b0b421975977f297dba63ee2f63ffe47bb6",
845        );
846        (v.0, v.1, v.2, false)
847    }
848
849    // verify_wrong_pubkey_case_2f09d443ab8a3ac2
850    fn vector_verify_21() -> (
851        Result<PublicKey, Error>,
852        Vec<u8>,
853        Result<Signature, Error>,
854        bool,
855    ) {
856        let v = parse_verify_vector(
857            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
858            "0x0000000000000000000000000000000000000000000000000000000000000000",
859            "0xb6ed936746e01f8ecf281f020953fbf1f01debd5657c4a383940b020b26507f6076334f91e2366c96e9ab279fb5158090352ea1c5b0c9274504f4f0e7053af24802e51e4568d164fe986834f41e55c8e850ce1f98458c0cfc9ab380b55285a55",
860        );
861        (v.0, v.1, v.2, false)
862    }
863
864    // verify_wrong_pubkey_case_6b3b17f6962a490c
865    fn vector_verify_22() -> (
866        Result<PublicKey, Error>,
867        Vec<u8>,
868        Result<Signature, Error>,
869        bool,
870    ) {
871        let v = parse_verify_vector(
872            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
873            "0x5656565656565656565656565656565656565656565656565656565656565656",
874            "0xaf1390c3c47acdb37131a51216da683c509fce0e954328a59f93aebda7e4ff974ba208d9a4a2a2389f892a9d418d618418dd7f7a6bc7aa0da999a9d3a5b815bc085e14fd001f6a1948768a3f4afefc8b8240dda329f984cb345c6363272ba4fe",
875        );
876        (v.0, v.1, v.2, false)
877    }
878
879    // verify_wrong_pubkey_case_6eeb7c52dfd9baf0
880    fn vector_verify_23() -> (
881        Result<PublicKey, Error>,
882        Vec<u8>,
883        Result<Signature, Error>,
884        bool,
885    ) {
886        let v = parse_verify_vector(
887            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
888            "0xabababababababababababababababababababababababababababababababab",
889            "0x91347bccf740d859038fcdcaf233eeceb2a436bcaaee9b2aa3bfb70efe29dfb2677562ccbea1c8e061fb9971b0753c240622fab78489ce96768259fc01360346da5b9f579e5da0d941e4c6ba18a0e64906082375394f337fa1af2b7127b0d121",
890        );
891        (v.0, v.1, v.2, false)
892    }
893
894    // verify_wrong_pubkey_case_8761a0b7e920c323
895    fn vector_verify_24() -> (
896        Result<PublicKey, Error>,
897        Vec<u8>,
898        Result<Signature, Error>,
899        bool,
900    ) {
901        let v = parse_verify_vector(
902            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
903            "0xabababababababababababababababababababababababababababababababab",
904            "0xae82747ddeefe4fd64cf9cedb9b04ae3e8a43420cd255e3c7cd06a8d88b7c7f8638543719981c5d16fa3527c468c25f0026704a6951bde891360c7e8d12ddee0559004ccdbe6046b55bae1b257ee97f7cdb955773d7cf29adf3ccbb9975e4eb9",
905        );
906        (v.0, v.1, v.2, false)
907    }
908
909    // verify_wrong_pubkey_case_195246ee3bd3b6ec
910    fn vector_verify_25() -> (
911        Result<PublicKey, Error>,
912        Vec<u8>,
913        Result<Signature, Error>,
914        bool,
915    ) {
916        let v = parse_verify_vector(
917            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
918            "0xabababababababababababababababababababababababababababababababab",
919            "0x9674e2228034527f4c083206032b020310face156d4a4685e2fcaec2f6f3665aa635d90347b6ce124eb879266b1e801d185de36a0a289b85e9039662634f2eea1e02e670bc7ab849d006a70b2f93b84597558a05b879c8d445f387a5d5b653df",
920        );
921        (v.0, v.1, v.2, false)
922    }
923
924    // verify_wrong_pubkey_case_3208262581c8fc09
925    fn vector_verify_26() -> (
926        Result<PublicKey, Error>,
927        Vec<u8>,
928        Result<Signature, Error>,
929        bool,
930    ) {
931        let v = parse_verify_vector(
932            "0xb301803f8b5ac4a1133581fc676dfedc60d891dd5fa99028805e5ea5b08d3491af75d0707adab3b70c6a6a580217bf81",
933            "0x5656565656565656565656565656565656565656565656565656565656565656",
934            "0x882730e5d03f6b42c3abc26d3372625034e1d871b65a8a6b900a56dae22da98abbe1b68f85e49fe7652a55ec3d0591c20767677e33e5cbb1207315c41a9ac03be39c2e7668edc043d6cb1d9fd93033caa8a1c5b0e84bedaeb6c64972503a43eb",
935        );
936        (v.0, v.1, v.2, false)
937    }
938
939    // verify_wrong_pubkey_case_d34885d766d5f705
940    fn vector_verify_27() -> (
941        Result<PublicKey, Error>,
942        Vec<u8>,
943        Result<Signature, Error>,
944        bool,
945    ) {
946        let v = parse_verify_vector(
947            "0xb53d21a4cfd562c469cc81514d4ce5a6b577d8403d32a394dc265dd190b47fa9f829fdd7963afdf972e5e77854051f6f",
948            "0x0000000000000000000000000000000000000000000000000000000000000000",
949            "0xb23c46be3a001c63ca711f87a005c200cc550b9429d5f4eb38d74322144f1b63926da3388979e5321012fb1a0526bcd100b5ef5fe72628ce4cd5e904aeaa3279527843fae5ca9ca675f4f51ed8f83bbf7155da9ecc9663100a885d5dc6df96d9",
950        );
951        (v.0, v.1, v.2, false)
952    }
953
954    // verify_wrong_pubkey_case_e8a50c445c855360
955    fn vector_verify_28() -> (
956        Result<PublicKey, Error>,
957        Vec<u8>,
958        Result<Signature, Error>,
959        bool,
960    ) {
961        let v = parse_verify_vector(
962            "0xa491d1b0ecd9bb917989f0e74f0dea0422eac4a873e5e2644f368dffb9a6e20fd6e10c1b77654d067c0618f6e5a7f79a",
963            "0x0000000000000000000000000000000000000000000000000000000000000000",
964            "0x948a7cb99f76d616c2c564ce9bf4a519f1bea6b0a624a02276443c245854219fabb8d4ce061d255af5330b078d5380681751aa7053da2c98bae898edc218c75f07e24d8802a17cd1f6833b71e58f5eb5b94208b4d0bb3848cecb075ea21be115",
965        );
966        (v.0, v.1, v.2, false)
967    }
968
969    // verifycase_one_privkey_47117849458281be
970    fn vector_verify_29() -> (
971        Result<PublicKey, Error>,
972        Vec<u8>,
973        Result<Signature, Error>,
974        bool,
975    ) {
976        let v= parse_verify_vector(
977            "0x97f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb",
978            "0x1212121212121212121212121212121212121212121212121212121212121212",
979            "0xa42ae16f1c2a5fa69c04cb5998d2add790764ce8dd45bf25b29b4700829232052b52352dcff1cf255b3a7810ad7269601810f03b2bc8b68cf289cf295b206770605a190b6842583e47c3d1c0f73c54907bfb2a602157d46a4353a20283018763",
980        );
981        (v.0, v.1, v.2, true)
982    }
983}
commonware_cryptography/bls12381/scheme.rs

commonware_cryptography/bls12381/
scheme.rs
