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

commonware_cryptography/bls12381/
scheme.rs
