commonware_cryptography/bls12381/
scheme.rs

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

commonware_cryptography/bls12381/
scheme.rs
