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

commonware_cryptography/bls12381/
scheme.rs
