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

commonware_cryptography/bls12381/
scheme.rs
