commonware_cryptography/secp256r1/
scheme.rs

1use crate::{
2    Array, Error, Signer as CommonwareSigner, Specification, Verifier as CommonwareVerifier,
3};
4use bytes::{Buf, BufMut};
5use commonware_codec::{Codec, Error as CodecError, SizedCodec};
6use commonware_utils::{hex, union_unique};
7use p256::{
8    ecdsa::{
9        signature::{Signer, Verifier},
10        SigningKey, VerifyingKey,
11    },
12    elliptic_curve::scalar::IsHigh,
13};
14use rand::{CryptoRng, Rng};
15use std::{
16    borrow::Cow,
17    fmt::{Debug, Display},
18    hash::{Hash, Hasher},
19    ops::Deref,
20};
21
22const CURVE_NAME: &str = "secp256r1";
23const PRIVATE_KEY_LENGTH: usize = 32;
24const PUBLIC_KEY_LENGTH: usize = 33; // Y-Parity || X
25const SIGNATURE_LENGTH: usize = 64; // R || S
26
27/// Secp256r1 Signer.
28#[derive(Clone)]
29pub struct Secp256r1 {
30    signer: SigningKey,
31    verifier: VerifyingKey,
32}
33
34impl Specification for Secp256r1 {
35    type PublicKey = PublicKey;
36    type Signature = Signature;
37}
38
39impl CommonwareVerifier for Secp256r1 {
40    fn verify(
41        namespace: Option<&[u8]>,
42        message: &[u8],
43        public_key: &PublicKey,
44        signature: &Signature,
45    ) -> bool {
46        let payload = match namespace {
47            Some(namespace) => Cow::Owned(union_unique(namespace, message)),
48            None => Cow::Borrowed(message),
49        };
50        public_key
51            .key
52            .verify(&payload, &signature.signature)
53            .is_ok()
54    }
55}
56
57impl CommonwareSigner for Secp256r1 {
58    type PrivateKey = PrivateKey;
59
60    fn new<R: CryptoRng + Rng>(r: &mut R) -> Self {
61        let signer = SigningKey::random(r);
62        let verifier = signer.verifying_key().to_owned();
63        Self { signer, verifier }
64    }
65
66    fn from(private_key: PrivateKey) -> Option<Self> {
67        let signer = private_key.key;
68        let verifier = signer.verifying_key().to_owned();
69        Some(Self { signer, verifier })
70    }
71
72    fn private_key(&self) -> PrivateKey {
73        PrivateKey::from(self.signer.clone())
74    }
75
76    fn public_key(&self) -> PublicKey {
77        PublicKey::from(self.verifier)
78    }
79
80    fn sign(&mut self, namespace: Option<&[u8]>, message: &[u8]) -> Signature {
81        let signature: p256::ecdsa::Signature = match namespace {
82            Some(namespace) => self.signer.sign(&union_unique(namespace, message)),
83            None => self.signer.sign(message),
84        };
85        let signature = match signature.normalize_s() {
86            Some(normalized) => normalized,
87            None => signature,
88        };
89        Signature::from(signature)
90    }
91}
92
93/// Secp256r1 Private Key.
94#[derive(Clone, Eq, PartialEq)]
95pub struct PrivateKey {
96    raw: [u8; PRIVATE_KEY_LENGTH],
97    key: SigningKey,
98}
99
100impl Codec for PrivateKey {
101    fn write(&self, buf: &mut impl BufMut) {
102        self.raw.write(buf);
103    }
104
105    fn read(buf: &mut impl Buf) -> Result<Self, CodecError> {
106        Self::read_from(buf).map_err(|err| CodecError::Wrapped(CURVE_NAME, err.into()))
107    }
108
109    fn len_encoded(&self) -> usize {
110        PRIVATE_KEY_LENGTH
111    }
112}
113
114impl SizedCodec for PrivateKey {
115    const LEN_ENCODED: usize = PRIVATE_KEY_LENGTH;
116}
117
118impl Array for PrivateKey {
119    type Error = Error;
120}
121
122impl Hash for PrivateKey {
123    fn hash<H: Hasher>(&self, state: &mut H) {
124        self.raw.hash(state);
125    }
126}
127
128impl Ord for PrivateKey {
129    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
130        self.raw.cmp(&other.raw)
131    }
132}
133
134impl PartialOrd for PrivateKey {
135    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
136        Some(self.cmp(other))
137    }
138}
139
140impl AsRef<[u8]> for PrivateKey {
141    fn as_ref(&self) -> &[u8] {
142        &self.raw
143    }
144}
145
146impl Deref for PrivateKey {
147    type Target = [u8];
148    fn deref(&self) -> &[u8] {
149        &self.raw
150    }
151}
152
153impl From<SigningKey> for PrivateKey {
154    fn from(signer: SigningKey) -> Self {
155        let raw = signer.to_bytes().into();
156        Self { raw, key: signer }
157    }
158}
159
160impl TryFrom<&[u8]> for PrivateKey {
161    type Error = Error;
162    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
163        let raw: [u8; PRIVATE_KEY_LENGTH] = value
164            .try_into()
165            .map_err(|_| Error::InvalidPrivateKeyLength)?;
166        let key = SigningKey::from_slice(&raw).map_err(|_| Error::InvalidPrivateKey)?;
167        Ok(Self { raw, key })
168    }
169}
170
171impl TryFrom<&Vec<u8>> for PrivateKey {
172    type Error = Error;
173    fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
174        Self::try_from(value.as_slice())
175    }
176}
177
178impl TryFrom<Vec<u8>> for PrivateKey {
179    type Error = Error;
180    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
181        Self::try_from(value.as_slice())
182    }
183}
184
185impl Debug for PrivateKey {
186    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
187        write!(f, "{}", hex(&self.raw))
188    }
189}
190
191impl Display for PrivateKey {
192    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
193        write!(f, "{}", hex(&self.raw))
194    }
195}
196
197/// Secp256r1 Public Key.
198#[derive(Clone, Eq, PartialEq, Ord, PartialOrd)]
199pub struct PublicKey {
200    raw: [u8; PUBLIC_KEY_LENGTH],
201    key: VerifyingKey,
202}
203
204impl Codec for PublicKey {
205    fn write(&self, buf: &mut impl BufMut) {
206        self.raw.write(buf);
207    }
208
209    fn read(buf: &mut impl Buf) -> Result<Self, CodecError> {
210        Self::read_from(buf).map_err(|err| CodecError::Wrapped(CURVE_NAME, err.into()))
211    }
212
213    fn len_encoded(&self) -> usize {
214        PUBLIC_KEY_LENGTH
215    }
216}
217
218impl SizedCodec for PublicKey {
219    const LEN_ENCODED: usize = PUBLIC_KEY_LENGTH;
220}
221
222impl Array for PublicKey {
223    type Error = Error;
224}
225
226impl Hash for PublicKey {
227    fn hash<H: Hasher>(&self, state: &mut H) {
228        self.raw.hash(state);
229    }
230}
231
232impl AsRef<[u8]> for PublicKey {
233    fn as_ref(&self) -> &[u8] {
234        &self.raw
235    }
236}
237
238impl Deref for PublicKey {
239    type Target = [u8];
240    fn deref(&self) -> &[u8] {
241        &self.raw
242    }
243}
244
245impl From<VerifyingKey> for PublicKey {
246    fn from(verifier: VerifyingKey) -> Self {
247        let encoded = verifier.to_encoded_point(true);
248        let raw: [u8; PUBLIC_KEY_LENGTH] = encoded.as_bytes().try_into().unwrap();
249        Self { raw, key: verifier }
250    }
251}
252
253impl TryFrom<&[u8]> for PublicKey {
254    type Error = Error;
255    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
256        let raw: [u8; PUBLIC_KEY_LENGTH] = value
257            .try_into()
258            .map_err(|_| Error::InvalidPublicKeyLength)?;
259        let key = VerifyingKey::from_sec1_bytes(&raw).map_err(|_| Error::InvalidPublicKey)?;
260        Ok(Self { raw, key })
261    }
262}
263
264impl TryFrom<&Vec<u8>> for PublicKey {
265    type Error = Error;
266    fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
267        Self::try_from(value.as_slice())
268    }
269}
270
271impl TryFrom<Vec<u8>> for PublicKey {
272    type Error = Error;
273    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
274        Self::try_from(value.as_slice())
275    }
276}
277
278impl Debug for PublicKey {
279    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
280        write!(f, "{}", hex(&self.raw))
281    }
282}
283
284impl Display for PublicKey {
285    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
286        write!(f, "{}", hex(&self.raw))
287    }
288}
289
290/// Secp256r1 Signature.
291#[derive(Clone, Eq, PartialEq)]
292pub struct Signature {
293    raw: [u8; SIGNATURE_LENGTH],
294    signature: p256::ecdsa::Signature,
295}
296
297impl Codec for Signature {
298    fn write(&self, buf: &mut impl BufMut) {
299        self.raw.write(buf);
300    }
301
302    fn read(buf: &mut impl Buf) -> Result<Self, CodecError> {
303        Self::read_from(buf).map_err(|err| CodecError::Wrapped(CURVE_NAME, err.into()))
304    }
305
306    fn len_encoded(&self) -> usize {
307        SIGNATURE_LENGTH
308    }
309}
310
311impl SizedCodec for Signature {
312    const LEN_ENCODED: usize = SIGNATURE_LENGTH;
313}
314
315impl Array for Signature {
316    type Error = Error;
317}
318
319impl Hash for Signature {
320    fn hash<H: Hasher>(&self, state: &mut H) {
321        self.raw.hash(state);
322    }
323}
324
325impl Ord for Signature {
326    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
327        self.raw.cmp(&other.raw)
328    }
329}
330
331impl PartialOrd for Signature {
332    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
333        Some(self.cmp(other))
334    }
335}
336
337impl AsRef<[u8]> for Signature {
338    fn as_ref(&self) -> &[u8] {
339        &self.raw
340    }
341}
342
343impl Deref for Signature {
344    type Target = [u8];
345    fn deref(&self) -> &[u8] {
346        &self.raw
347    }
348}
349
350impl From<p256::ecdsa::Signature> for Signature {
351    fn from(signature: p256::ecdsa::Signature) -> Self {
352        let raw = signature.to_bytes().into();
353        Self { raw, signature }
354    }
355}
356
357impl TryFrom<&[u8]> for Signature {
358    type Error = Error;
359    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
360        let raw: [u8; SIGNATURE_LENGTH] = value
361            .try_into()
362            .map_err(|_| Error::InvalidSignatureLength)?;
363        let signature =
364            p256::ecdsa::Signature::from_slice(&raw).map_err(|_| Error::InvalidSignature)?;
365        if signature.s().is_high().into() {
366            // Reject any signatures with a `s` value in the upper half of the curve order.
367            return Err(Error::InvalidSignature);
368        }
369        Ok(Self { raw, signature })
370    }
371}
372
373impl TryFrom<&Vec<u8>> for Signature {
374    type Error = Error;
375    fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> {
376        Self::try_from(value.as_slice())
377    }
378}
379
380impl TryFrom<Vec<u8>> for Signature {
381    type Error = Error;
382    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
383        Self::try_from(value.as_slice())
384    }
385}
386
387impl Debug for Signature {
388    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
389        write!(f, "{}", hex(&self.raw))
390    }
391}
392
393impl Display for Signature {
394    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
395        write!(f, "{}", hex(&self.raw))
396    }
397}
398
399/// Test vectors sourced from (FIPS 186-4)
400/// https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/digital-signatures.
401#[cfg(test)]
402mod tests {
403    use super::*;
404    use bytes::Bytes;
405
406    fn create_private_key() -> PrivateKey {
407        const HEX: &str = "519b423d715f8b581f4fa8ee59f4771a5b44c8130b4e3eacca54a56dda72b464";
408        commonware_utils::from_hex_formatted(HEX)
409            .unwrap()
410            .try_into()
411            .unwrap()
412    }
413
414    fn parse_vector_keypair(private_key: &str, qx: &str, qy: &str) -> (PrivateKey, PublicKey) {
415        let public_key = parse_public_key_as_compressed(qx, qy);
416        (
417            commonware_utils::from_hex_formatted(private_key)
418                .unwrap()
419                .try_into()
420                .unwrap(),
421            public_key,
422        )
423    }
424
425    fn parse_vector_sig_verification(
426        qx: &str,
427        qy: &str,
428        r: &str,
429        s: &str,
430        m: &str,
431    ) -> (PublicKey, Vec<u8>, Vec<u8>) {
432        let public_key = parse_public_key_as_compressed(qx, qy);
433        let signature = parse_signature(r, s);
434        let message = commonware_utils::from_hex_formatted(m).unwrap();
435        (public_key, signature, message)
436    }
437
438    fn parse_signature(r: &str, s: &str) -> Vec<u8> {
439        let vec_r = commonware_utils::from_hex_formatted(r).unwrap();
440        let vec_s = commonware_utils::from_hex_formatted(s).unwrap();
441        let f1 = p256::FieldBytes::from_slice(&vec_r);
442        let f2 = p256::FieldBytes::from_slice(&vec_s);
443        let s = p256::ecdsa::Signature::from_scalars(*f1, *f2).unwrap();
444        s.to_vec()
445    }
446
447    fn parse_public_key_as_compressed(qx: &str, qy: &str) -> PublicKey {
448        parse_public_key_as_compressed_vector(qx, qy)
449            .try_into()
450            .unwrap()
451    }
452
453    fn parse_public_key_as_compressed_vector(qx: &str, qy: &str) -> Vec<u8> {
454        let qx = commonware_utils::from_hex_formatted(&padding_odd_length_hex(qx)).unwrap();
455        let qy = commonware_utils::from_hex_formatted(&padding_odd_length_hex(qy)).unwrap();
456        let mut compressed = Vec::with_capacity(qx.len() + 1);
457        if qy.last().unwrap() % 2 == 0 {
458            compressed.push(0x02);
459        } else {
460            compressed.push(0x03);
461        }
462        compressed.extend_from_slice(&qx);
463        compressed
464    }
465
466    fn parse_public_key_as_uncompressed_vector(qx: &str, qy: &str) -> Vec<u8> {
467        let qx = commonware_utils::from_hex_formatted(qx).unwrap();
468        let qy = commonware_utils::from_hex_formatted(qy).unwrap();
469        let mut uncompressed_public_key = Vec::with_capacity(65);
470        uncompressed_public_key.push(0x04);
471        uncompressed_public_key.extend_from_slice(&qx);
472        uncompressed_public_key.extend_from_slice(&qy);
473        uncompressed_public_key
474    }
475
476    fn padding_odd_length_hex(value: &str) -> String {
477        if value.len() % 2 != 0 {
478            return format!("0{}", value);
479        }
480        value.to_string()
481    }
482
483    #[test]
484    fn test_codec_private_key() {
485        let original: PrivateKey = create_private_key();
486        let encoded = original.encode();
487        assert_eq!(encoded.len(), PRIVATE_KEY_LENGTH);
488
489        let decoded = PrivateKey::decode(encoded).unwrap();
490        assert_eq!(original, decoded);
491    }
492
493    #[test]
494    fn test_codec_public_key() {
495        let private_key = create_private_key();
496        let signer = <Secp256r1 as CommonwareSigner>::from(private_key).unwrap();
497        let original: PublicKey = signer.public_key();
498
499        let encoded = original.encode();
500        assert_eq!(encoded.len(), PUBLIC_KEY_LENGTH);
501
502        let decoded = PublicKey::decode(encoded).unwrap();
503        assert_eq!(original, decoded);
504    }
505
506    #[test]
507    fn test_codec_signature() {
508        let private_key = create_private_key();
509        let mut signer = <Secp256r1 as CommonwareSigner>::from(private_key).unwrap();
510        let original = signer.sign(None, "Hello World".as_bytes());
511
512        let encoded = original.encode();
513        assert_eq!(encoded.len(), SIGNATURE_LENGTH);
514
515        let decoded = Signature::decode(encoded).unwrap();
516        assert_eq!(original, decoded);
517    }
518
519    #[test]
520    fn test_codec_signature_invalid() {
521        let (_, sig, ..) = vector_sig_verification_5();
522        let result = Signature::decode(Bytes::from(sig));
523        assert!(result.is_err());
524    }
525
526    #[test]
527    fn test_scheme_sign() {
528        let private_key: PrivateKey = commonware_utils::from_hex_formatted(
529            "519b423d715f8b581f4fa8ee59f4771a5b44c8130b4e3eacca54a56dda72b464",
530        )
531        .unwrap()
532        .try_into()
533        .unwrap();
534        let message = commonware_utils::from_hex_formatted(
535            "5905238877c77421f73e43ee3da6f2d9e2ccad5fc942dcec0cbd25482935faaf416983fe165b1a045e
536            e2bcd2e6dca3bdf46c4310a7461f9a37960ca672d3feb5473e253605fb1ddfd28065b53cb5858a8ad28175bf
537            9bd386a5e471ea7a65c17cc934a9d791e91491eb3754d03799790fe2d308d16146d5c9b0d0debd97d79ce8",
538        )
539        .unwrap();
540        let mut signer = <Secp256r1 as CommonwareSigner>::from(private_key).unwrap();
541        let signature = signer.sign(None, &message);
542        assert_eq!(SIGNATURE_LENGTH, signature.len());
543        assert!(Secp256r1::verify(
544            None,
545            &message,
546            &signer.public_key(),
547            &signature
548        ));
549    }
550
551    #[test]
552    fn test_scheme_private_key() {
553        let private_key_hex = "519b423d715f8b581f4fa8ee59f4771a5b44c8130b4e3eacca54a56dda72b464";
554        let private_key: PrivateKey = commonware_utils::from_hex_formatted(private_key_hex)
555            .unwrap()
556            .try_into()
557            .unwrap();
558        let signer = <Secp256r1 as CommonwareSigner>::from(private_key).unwrap();
559        let exported_private_key = signer.private_key();
560        assert_eq!(
561            private_key_hex,
562            commonware_utils::hex(&exported_private_key).as_str(),
563        );
564    }
565
566    // Ensure RFC6979 compliance (should also be tested by underlying library)
567    #[test]
568    fn test_rfc6979() {
569        let private_key: PrivateKey = commonware_utils::from_hex_formatted(
570            "c9afa9d845ba75166b5c215767b1d6934e50c3db36e89b127b8a622b120f6721",
571        )
572        .unwrap()
573        .try_into()
574        .unwrap();
575
576        let (message, exp_sig) = (
577            b"sample",
578            p256::ecdsa::Signature::from_slice(
579                &commonware_utils::from_hex_formatted(
580                    "efd48b2aacb6a8fd1140dd9cd45e81d69d2c877b56aaf991c34d0ea84eaf3716
581                    f7cb1c942d657c41d436c7a1b6e29f65f3e900dbb9aff4064dc4ab2f843acda8",
582                )
583                .unwrap(),
584            )
585            .unwrap(),
586        );
587        let mut signer = <Secp256r1 as CommonwareSigner>::from(private_key).unwrap();
588        let signature = signer.sign(None, message);
589        assert_eq!(signature.to_vec(), exp_sig.normalize_s().unwrap().to_vec());
590
591        let (message, exp_sig) = (
592            b"test",
593            p256::ecdsa::Signature::from_slice(
594                &commonware_utils::from_hex_formatted(
595                    "f1abb023518351cd71d881567b1ea663ed3efcf6c5132b354f28d3b0b7d38367
596                    019f4113742a2b14bd25926b49c649155f267e60d3814b4c0cc84250e46f0083",
597                )
598                .unwrap(),
599            )
600            .unwrap(),
601        );
602
603        let signature = signer.sign(None, message);
604        assert_eq!(signature.to_vec(), exp_sig.to_vec());
605    }
606
607    #[test]
608    fn test_scheme_validate_public_key_too_long() {
609        let qx_hex = "d0720dc691aa80096ba32fed1cb97c2b620690d06de0317b8618d5ce65eb728f";
610        let qy_hex = "d0720dc691aa80096ba32fed1cb97c2b620690d06de0317b8618d5ce65eb728f";
611
612        let uncompressed_public_key = parse_public_key_as_uncompressed_vector(qx_hex, qy_hex);
613        let public_key =
614            <Secp256r1 as Specification>::PublicKey::try_from(&uncompressed_public_key);
615        assert_eq!(public_key, Err(Error::InvalidPublicKeyLength));
616
617        let compressed_public_key = parse_public_key_as_compressed_vector(qx_hex, qy_hex);
618        let public_key = <Secp256r1 as Specification>::PublicKey::try_from(&compressed_public_key);
619        assert!(public_key.is_ok());
620    }
621
622    #[test]
623    fn test_scheme_verify_signature_r0() {
624        // Generate bad signature
625        let private_key: PrivateKey = commonware_utils::from_hex_formatted(
626            "c9806898a0334916c860748880a541f093b579a9b1f32934d86c363c39800357",
627        )
628        .unwrap()
629        .try_into()
630        .unwrap();
631        let message = b"sample";
632        let mut signer = <Secp256r1 as CommonwareSigner>::from(private_key).unwrap();
633        let signature = signer.sign(None, message);
634        let (_, s) = signature.split_at(32);
635        let mut signature: Vec<u8> = vec![0x00; 32];
636        signature.extend_from_slice(s);
637
638        // Try to parse signature
639        assert!(Signature::try_from(&signature).is_err());
640    }
641
642    #[test]
643    fn test_scheme_verify_signature_s0() {
644        // Generate bad signature
645        let private_key: PrivateKey = commonware_utils::from_hex_formatted(
646            "c9806898a0334916c860748880a541f093b579a9b1f32934d86c363c39800357",
647        )
648        .unwrap()
649        .try_into()
650        .unwrap();
651        let message = b"sample";
652        let mut signer = <Secp256r1 as CommonwareSigner>::from(private_key).unwrap();
653        let signature = signer.sign(None, message);
654        let (r, _) = signature.split_at(32);
655        let s: Vec<u8> = vec![0x00; 32];
656        let mut signature = r.to_vec();
657        signature.extend(s);
658
659        // Try to parse signature
660        assert!(Signature::try_from(&signature).is_err());
661    }
662
663    #[test]
664    fn test_keypairs() {
665        let cases = [
666            vector_keypair_1(),
667            vector_keypair_2(),
668            vector_keypair_3(),
669            vector_keypair_4(),
670            vector_keypair_5(),
671            vector_keypair_6(),
672            vector_keypair_7(),
673            vector_keypair_8(),
674            vector_keypair_9(),
675            vector_keypair_10(),
676        ];
677
678        for (index, test) in cases.into_iter().enumerate() {
679            let (private_key, exp_public_key) = test;
680            let signer = <Secp256r1 as CommonwareSigner>::from(private_key).unwrap();
681            assert_eq!(
682                exp_public_key,
683                signer.public_key(),
684                "vector_keypair_{}",
685                index + 1
686            );
687            assert!(signer.public_key().len() == PUBLIC_KEY_LENGTH);
688        }
689    }
690
691    #[test]
692    fn test_public_key_validation() {
693        // We use SEC 1-encoded public keys (only include y-parity) whereas vectors
694        // assume public keys are uncompressed (both x and y packed in encoding).
695        //
696        // For this reason, test vector 2 (y out of range) and 11 (y not on curve) are skipped.
697        let cases = [
698            (1, vector_public_key_validation_1()),
699            (3, vector_public_key_validation_3()),
700            (4, vector_public_key_validation_4()),
701            (5, vector_public_key_validation_5()),
702            (6, vector_public_key_validation_6()),
703            (7, vector_public_key_validation_7()),
704            (8, vector_public_key_validation_8()),
705            (9, vector_public_key_validation_9()),
706            (10, vector_public_key_validation_10()),
707            (12, vector_public_key_validation_12()),
708        ];
709
710        for (n, test) in cases.iter() {
711            let (public_key, exp_valid) = test;
712            let res = <Secp256r1 as Specification>::PublicKey::try_from(public_key);
713            assert_eq!(
714                *exp_valid,
715                res.is_ok(),
716                "vector_public_key_validation_{}",
717                n
718            );
719        }
720    }
721
722    #[test]
723    fn test_signature_verification() {
724        let cases = [
725            vector_sig_verification_1(),
726            vector_sig_verification_2(),
727            vector_sig_verification_3(),
728            vector_sig_verification_4(),
729            vector_sig_verification_5(),
730            vector_sig_verification_6(),
731            vector_sig_verification_7(),
732            vector_sig_verification_8(),
733            vector_sig_verification_9(),
734            vector_sig_verification_10(),
735            vector_sig_verification_11(),
736            vector_sig_verification_12(),
737            vector_sig_verification_13(),
738            vector_sig_verification_14(),
739            vector_sig_verification_15(),
740        ];
741
742        for (index, test) in cases.into_iter().enumerate() {
743            let (public_key, sig, message, expected) = test;
744            let expected = if expected {
745                let mut ecdsa_signature = p256::ecdsa::Signature::from_slice(&sig).unwrap();
746                if ecdsa_signature.s().is_high().into() {
747                    // Valid signatures not normalized must be considered invalid.
748                    assert!(Signature::try_from(sig.clone()).is_err());
749                    assert!(Signature::decode(Bytes::from(sig)).is_err());
750
751                    // Normalizing sig to test its validity.
752                    if let Some(normalized_sig) = ecdsa_signature.normalize_s() {
753                        ecdsa_signature = normalized_sig;
754                    }
755                }
756                let signature = Signature::from(ecdsa_signature);
757                Secp256r1::verify(None, &message, &public_key, &signature)
758            } else {
759                let tf_res = Signature::try_from(sig.clone());
760                let dc_res = Signature::decode(Bytes::from(sig));
761                if tf_res.is_err() && dc_res.is_err() {
762                    // The parsing should fail
763                    true
764                } else {
765                    // Or the validation should fail
766                    let f1 = !Secp256r1::verify(None, &message, &public_key, &tf_res.unwrap());
767                    let f2 = !Secp256r1::verify(None, &message, &public_key, &dc_res.unwrap());
768                    f1 && f2
769                }
770            };
771            assert!(expected, "vector_signature_verification_{}", index + 1);
772        }
773    }
774
775    fn vector_keypair_1() -> (PrivateKey, PublicKey) {
776        parse_vector_keypair(
777            "c9806898a0334916c860748880a541f093b579a9b1f32934d86c363c39800357",
778            "d0720dc691aa80096ba32fed1cb97c2b620690d06de0317b8618d5ce65eb728f",
779            "9681b517b1cda17d0d83d335d9c4a8a9a9b0b1b3c7106d8f3c72bc5093dc275f",
780        )
781    }
782
783    fn vector_keypair_2() -> (PrivateKey, PublicKey) {
784        parse_vector_keypair(
785            "710735c8388f48c684a97bd66751cc5f5a122d6b9a96a2dbe73662f78217446d",
786            "f6836a8add91cb182d8d258dda6680690eb724a66dc3bb60d2322565c39e4ab9",
787            "1f837aa32864870cb8e8d0ac2ff31f824e7beddc4bb7ad72c173ad974b289dc2",
788        )
789    }
790
791    fn vector_keypair_3() -> (PrivateKey, PublicKey) {
792        parse_vector_keypair(
793            "78d5d8b7b3e2c16b3e37e7e63becd8ceff61e2ce618757f514620ada8a11f6e4",
794            "76711126cbb2af4f6a5fe5665dad4c88d27b6cb018879e03e54f779f203a854e",
795            "a26df39960ab5248fd3620fd018398e788bd89a3cea509b352452b69811e6856",
796        )
797    }
798
799    fn vector_keypair_4() -> (PrivateKey, PublicKey) {
800        parse_vector_keypair(
801            "2a61a0703860585fe17420c244e1de5a6ac8c25146b208ef88ad51ae34c8cb8c",
802            "e1aa7196ceeac088aaddeeba037abb18f67e1b55c0a5c4e71ec70ad666fcddc8",
803            "d7d35bdce6dedc5de98a7ecb27a9cd066a08f586a733b59f5a2cdb54f971d5c8",
804        )
805    }
806
807    fn vector_keypair_5() -> (PrivateKey, PublicKey) {
808        parse_vector_keypair(
809            "01b965b45ff386f28c121c077f1d7b2710acc6b0cb58d8662d549391dcf5a883",
810            "1f038c5422e88eec9e88b815e8f6b3e50852333fc423134348fc7d79ef8e8a10",
811            "43a047cb20e94b4ffb361ef68952b004c0700b2962e0c0635a70269bc789b849",
812        )
813    }
814
815    fn vector_keypair_6() -> (PrivateKey, PublicKey) {
816        parse_vector_keypair(
817            "fac92c13d374c53a085376fe4101618e1e181b5a63816a84a0648f3bdc24e519",
818            "7258f2ab96fc84ef6ccb33e308cd392d8b568ea635730ceb4ebd72fa870583b9",
819            "489807ca55bdc29ca5c8fe69b94f227b0345cccdbe89975e75d385cc2f6bb1e2",
820        )
821    }
822
823    fn vector_keypair_7() -> (PrivateKey, PublicKey) {
824        parse_vector_keypair(
825            "f257a192dde44227b3568008ff73bcf599a5c45b32ab523b5b21ca582fef5a0a",
826            "d2e01411817b5512b79bbbe14d606040a4c90deb09e827d25b9f2fc068997872",
827            "503f138f8bab1df2c4507ff663a1fdf7f710e7adb8e7841eaa902703e314e793",
828        )
829    }
830
831    fn vector_keypair_8() -> (PrivateKey, PublicKey) {
832        parse_vector_keypair(
833            "add67e57c42a3d28708f0235eb86885a4ea68e0d8cfd76eb46134c596522abfd",
834            "55bed2d9c029b7f230bde934c7124ed52b1330856f13cbac65a746f9175f85d7",
835            "32805e311d583b4e007c40668185e85323948e21912b6b0d2cda8557389ae7b0",
836        )
837    }
838
839    fn vector_keypair_9() -> (PrivateKey, PublicKey) {
840        parse_vector_keypair(
841            "4494860fd2c805c5c0d277e58f802cff6d731f76314eb1554142a637a9bc5538",
842            "5190277a0c14d8a3d289292f8a544ce6ea9183200e51aec08440e0c1a463a4e4",
843            "ecd98514821bd5aaf3419ab79b71780569470e4fed3da3c1353b28fe137f36eb",
844        )
845    }
846
847    fn vector_keypair_10() -> (PrivateKey, PublicKey) {
848        parse_vector_keypair(
849            "d40b07b1ea7b86d4709ef9dc634c61229feb71abd63dc7fc85ef46711a87b210",
850            "fbcea7c2827e0e8085d7707b23a3728823ea6f4878b24747fb4fd2842d406c73",
851            "2393c85f1f710c5afc115a39ba7e18abe03f19c9d4bb3d47d19468b818efa535",
852        )
853    }
854
855    fn vector_public_key_validation_1() -> (Vec<u8>, bool) {
856        (
857            parse_public_key_as_compressed_vector(
858                "e0f7449c5588f24492c338f2bc8f7865f755b958d48edb0f2d0056e50c3fd5b7",
859                "86d7e9255d0f4b6f44fa2cd6f8ba3c0aa828321d6d8cc430ca6284ce1d5b43a0",
860            ),
861            true,
862        )
863    }
864
865    fn vector_public_key_validation_3() -> (Vec<u8>, bool) {
866        (
867            parse_public_key_as_compressed_vector(
868                "17875397ae87369365656d490e8ce956911bd97607f2aff41b56f6f3a61989826",
869                "980a3c4f61b9692633fbba5ef04c9cb546dd05cdec9fa8428b8849670e2fba92",
870            ),
871            false, // x out of range
872        )
873    }
874
875    fn vector_public_key_validation_4() -> (Vec<u8>, bool) {
876        (
877            parse_public_key_as_compressed_vector(
878                "f2d1c0dc0852c3d8a2a2500a23a44813ccce1ac4e58444175b440469ffc12273",
879                "32bfe992831b305d8c37b9672df5d29fcb5c29b4a40534683e3ace23d24647dd",
880            ),
881            false, // point not on the curve
882        )
883    }
884
885    fn vector_public_key_validation_5() -> (Vec<u8>, bool) {
886        (
887            parse_public_key_as_compressed_vector(
888                "10b0ca230fff7c04768f4b3d5c75fa9f6c539bea644dffbec5dc796a213061b58",
889                "f5edf37c11052b75f771b7f9fa050e353e464221fec916684ed45b6fead38205",
890            ),
891            false, // x out of range
892        )
893    }
894
895    fn vector_public_key_validation_6() -> (Vec<u8>, bool) {
896        (
897            parse_public_key_as_compressed_vector(
898                "2c1052f25360a15062d204a056274e93cbe8fc4c4e9b9561134ad5c15ce525da",
899                "ced9783713a8a2a09eff366987639c625753295d9a85d0f5325e32dedbcada0b",
900            ),
901            true,
902        )
903    }
904
905    fn vector_public_key_validation_7() -> (Vec<u8>, bool) {
906        (
907            parse_public_key_as_compressed_vector(
908                "a40d077a87dae157d93dcccf3fe3aca9c6479a75aa2669509d2ef05c7de6782f",
909                "503d86b87d743ba20804fd7e7884aa017414a7b5b5963e0d46e3a9611419ddf3",
910            ),
911            false, // point not on the curve
912        )
913    }
914
915    fn vector_public_key_validation_8() -> (Vec<u8>, bool) {
916        (
917            parse_public_key_as_compressed_vector(
918                "2633d398a3807b1895548adbb0ea2495ef4b930f91054891030817df87d4ac0a",
919                "d6b2f738e3873cc8364a2d364038ce7d0798bb092e3dd77cbdae7c263ba618d2",
920            ),
921            true,
922        )
923    }
924
925    fn vector_public_key_validation_9() -> (Vec<u8>, bool) {
926        (
927            parse_public_key_as_compressed_vector(
928                "14bf57f76c260b51ec6bbc72dbd49f02a56eaed070b774dc4bad75a54653c3d56",
929                "7a231a23bf8b3aa31d9600d888a0678677a30e573decd3dc56b33f365cc11236",
930            ),
931            false, // x out of range
932        )
933    }
934
935    fn vector_public_key_validation_10() -> (Vec<u8>, bool) {
936        (
937            parse_public_key_as_compressed_vector(
938                "2fa74931ae816b426f484180e517f5050c92decfc8daf756cd91f54d51b302f1",
939                "5b994346137988c58c14ae2152ac2f6ad96d97decb33099bd8a0210114cd1141",
940            ),
941            true,
942        )
943    }
944
945    fn vector_public_key_validation_12() -> (Vec<u8>, bool) {
946        (
947            parse_public_key_as_compressed_vector(
948                "7a81a7e0b015252928d8b36e4ca37e92fdc328eb25c774b4f872693028c4be38",
949                "08862f7335147261e7b1c3d055f9a316e4cab7daf99cc09d1c647f5dd6e7d5bb",
950            ),
951            false, // point not on the curve
952        )
953    }
954
955    fn vector_sig_verification_1() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
956        let (public_key, sig, message) = parse_vector_sig_verification(
957            "87f8f2b218f49845f6f10eec3877136269f5c1a54736dbdf69f89940cad41555",
958            "e15f369036f49842fac7a86c8a2b0557609776814448b8f5e84aa9f4395205e9",
959            "d19ff48b324915576416097d2544f7cbdf8768b1454ad20e0baac50e211f23b0",
960            "a3e81e59311cdfff2d4784949f7a2cb50ba6c3a91fa54710568e61aca3e847c6",
961            "e4796db5f785f207aa30d311693b3702821dff1168fd2e04c0836825aefd850d9aa60326d88cde1a23c7
962            745351392ca2288d632c264f197d05cd424a30336c19fd09bb229654f0222fcb881a4b35c290a093ac159ce1
963            3409111ff0358411133c24f5b8e2090d6db6558afc36f06ca1f6ef779785adba68db27a409859fc4c4a0",
964        );
965        (public_key, sig, message, false)
966    }
967
968    fn vector_sig_verification_2() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
969        let (public_key, sig, message) = parse_vector_sig_verification(
970            "5cf02a00d205bdfee2016f7421807fc38ae69e6b7ccd064ee689fc1a94a9f7d2",
971            "ec530ce3cc5c9d1af463f264d685afe2b4db4b5828d7e61b748930f3ce622a85",
972            "dc23d130c6117fb5751201455e99f36f59aba1a6a21cf2d0e7481a97451d6693",
973            "d6ce7708c18dbf35d4f8aa7240922dc6823f2e7058cbc1484fcad1599db5018c",
974            "069a6e6b93dfee6df6ef6997cd80dd2182c36653cef10c655d524585655462d683877f95ecc6d6c81623
975            d8fac4e900ed0019964094e7de91f1481989ae1873004565789cbf5dc56c62aedc63f62f3b894c9c6f7788c8
976            ecaadc9bd0e81ad91b2b3569ea12260e93924fdddd3972af5273198f5efda0746219475017557616170e",
977        );
978        (public_key, sig, message, false)
979    }
980
981    fn vector_sig_verification_3() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
982        let (public_key, sig, message) = parse_vector_sig_verification(
983            "2ddfd145767883ffbb0ac003ab4a44346d08fa2570b3120dcce94562422244cb",
984            "5f70c7d11ac2b7a435ccfbbae02c3df1ea6b532cc0e9db74f93fffca7c6f9a64",
985            "9913111cff6f20c5bf453a99cd2c2019a4e749a49724a08774d14e4c113edda8",
986            "9467cd4cd21ecb56b0cab0a9a453b43386845459127a952421f5c6382866c5cc",
987            "df04a346cf4d0e331a6db78cca2d456d31b0a000aa51441defdb97bbeb20b94d8d746429a393ba88840d
988            661615e07def615a342abedfa4ce912e562af714959896858af817317a840dcff85a057bb91a3c2bf9010550
989            0362754a6dd321cdd86128cfc5f04667b57aa78c112411e42da304f1012d48cd6a7052d7de44ebcc01de",
990        );
991        (public_key, sig, message, false)
992    }
993
994    fn vector_sig_verification_4() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
995        let (public_key, sig, message) = parse_vector_sig_verification(
996            "e424dc61d4bb3cb7ef4344a7f8957a0c5134e16f7a67c074f82e6e12f49abf3c",
997            "970eed7aa2bc48651545949de1dddaf0127e5965ac85d1243d6f60e7dfaee927",
998            "bf96b99aa49c705c910be33142017c642ff540c76349b9dab72f981fd9347f4f",
999            "17c55095819089c2e03b9cd415abdf12444e323075d98f31920b9e0f57ec871c",
1000            "e1130af6a38ccb412a9c8d13e15dbfc9e69a16385af3c3f1e5da954fd5e7c45fd75e2b8c36699228e928
1001            40c0562fbf3772f07e17f1add56588dd45f7450e1217ad239922dd9c32695dc71ff2424ca0dec1321aa47064
1002            a044b7fe3c2b97d03ce470a592304c5ef21eed9f93da56bb232d1eeb0035f9bf0dfafdcc4606272b20a3",
1003        );
1004        (public_key, sig, message, true)
1005    }
1006
1007    fn vector_sig_verification_5() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1008        let (public_key, sig, message) = parse_vector_sig_verification(
1009            "e0fc6a6f50e1c57475673ee54e3a57f9a49f3328e743bf52f335e3eeaa3d2864",
1010            "7f59d689c91e463607d9194d99faf316e25432870816dde63f5d4b373f12f22a",
1011            "1d75830cd36f4c9aa181b2c4221e87f176b7f05b7c87824e82e396c88315c407",
1012            "cb2acb01dac96efc53a32d4a0d85d0c2e48955214783ecf50a4f0414a319c05a",
1013            "73c5f6a67456ae48209b5f85d1e7de7758bf235300c6ae2bdceb1dcb27a7730fb68c950b7fcada0ecc46
1014            61d3578230f225a875e69aaa17f1e71c6be5c831f22663bac63d0c7a9635edb0043ff8c6f26470f02a7bc565
1015            56f1437f06dfa27b487a6c4290d8bad38d4879b334e341ba092dde4e4ae694a9c09302e2dbf443581c08",
1016        );
1017        // Valid vector we switch to invalid as the signature is not normalized.
1018        (public_key, sig, message, true)
1019    }
1020
1021    fn vector_sig_verification_6() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1022        let (public_key, sig, message) = parse_vector_sig_verification(
1023            "a849bef575cac3c6920fbce675c3b787136209f855de19ffe2e8d29b31a5ad86",
1024            "bf5fe4f7858f9b805bd8dcc05ad5e7fb889de2f822f3d8b41694e6c55c16b471",
1025            "25acc3aa9d9e84c7abf08f73fa4195acc506491d6fc37cb9074528a7db87b9d6",
1026            "9b21d5b5259ed3f2ef07dfec6cc90d3a37855d1ce122a85ba6a333f307d31537",
1027            "666036d9b4a2426ed6585a4e0fd931a8761451d29ab04bd7dc6d0c5b9e38e6c2b263ff6cb837bd04399d
1028            e3d757c6c7005f6d7a987063cf6d7e8cb38a4bf0d74a282572bd01d0f41e3fd066e3021575f0fa04f27b700d
1029            5b7ddddf50965993c3f9c7118ed78888da7cb221849b3260592b8e632d7c51e935a0ceae15207bedd548",
1030        );
1031        (public_key, sig, message, false)
1032    }
1033
1034    fn vector_sig_verification_7() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1035        let (public_key, sig, message) = parse_vector_sig_verification(
1036            "3dfb6f40f2471b29b77fdccba72d37c21bba019efa40c1c8f91ec405d7dcc5df",
1037            "f22f953f1e395a52ead7f3ae3fc47451b438117b1e04d613bc8555b7d6e6d1bb",
1038            "548886278e5ec26bed811dbb72db1e154b6f17be70deb1b210107decb1ec2a5a",
1039            "e93bfebd2f14f3d827ca32b464be6e69187f5edbd52def4f96599c37d58eee75",
1040            "7e80436bce57339ce8da1b5660149a20240b146d108deef3ec5da4ae256f8f894edcbbc57b34ce37089c
1041            0daa17f0c46cd82b5a1599314fd79d2fd2f446bd5a25b8e32fcf05b76d644573a6df4ad1dfea707b479d9723
1042            7a346f1ec632ea5660efb57e8717a8628d7f82af50a4e84b11f21bdff6839196a880ae20b2a0918d58cd",
1043        );
1044        (public_key, sig, message, false)
1045    }
1046
1047    fn vector_sig_verification_8() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1048        let (public_key, sig, message) = parse_vector_sig_verification(
1049            "69b7667056e1e11d6caf6e45643f8b21e7a4bebda463c7fdbc13bc98efbd0214",
1050            "d3f9b12eb46c7c6fda0da3fc85bc1fd831557f9abc902a3be3cb3e8be7d1aa2f",
1051            "288f7a1cd391842cce21f00e6f15471c04dc182fe4b14d92dc18910879799790",
1052            "247b3c4e89a3bcadfea73c7bfd361def43715fa382b8c3edf4ae15d6e55e9979",
1053            "1669bfb657fdc62c3ddd63269787fc1c969f1850fb04c933dda063ef74a56ce13e3a649700820f0061ef
1054            abf849a85d474326c8a541d99830eea8131eaea584f22d88c353965dabcdc4bf6b55949fd529507dfb803ab6
1055            b480cd73ca0ba00ca19c438849e2cea262a1c57d8f81cd257fb58e19dec7904da97d8386e87b84948169",
1056        );
1057        (public_key, sig, message, false)
1058    }
1059
1060    fn vector_sig_verification_9() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1061        let (public_key, sig, message) = parse_vector_sig_verification(
1062            "bf02cbcf6d8cc26e91766d8af0b164fc5968535e84c158eb3bc4e2d79c3cc682",
1063            "069ba6cb06b49d60812066afa16ecf7b51352f2c03bd93ec220822b1f3dfba03",
1064            "f5acb06c59c2b4927fb852faa07faf4b1852bbb5d06840935e849c4d293d1bad",
1065            "049dab79c89cc02f1484c437f523e080a75f134917fda752f2d5ca397addfe5d",
1066            "3fe60dd9ad6caccf5a6f583b3ae65953563446c4510b70da115ffaa0ba04c076115c7043ab8733403cd6
1067            9c7d14c212c655c07b43a7c71b9a4cffe22c2684788ec6870dc2013f269172c822256f9e7cc674791bf2d848
1068            6c0f5684283e1649576efc982ede17c7b74b214754d70402fb4bb45ad086cf2cf76b3d63f7fce39ac970",
1069        );
1070        (public_key, sig, message, false)
1071    }
1072
1073    fn vector_sig_verification_10() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1074        let (public_key, sig, message) = parse_vector_sig_verification(
1075            "224a4d65b958f6d6afb2904863efd2a734b31798884801fcab5a590f4d6da9de",
1076            "178d51fddada62806f097aa615d33b8f2404e6b1479f5fd4859d595734d6d2b9",
1077            "87b93ee2fecfda54deb8dff8e426f3c72c8864991f8ec2b3205bb3b416de93d2",
1078            "4044a24df85be0cc76f21a4430b75b8e77b932a87f51e4eccbc45c263ebf8f66",
1079            "983a71b9994d95e876d84d28946a041f8f0a3f544cfcc055496580f1dfd4e312a2ad418fe69dbc61db23
1080            0cc0c0ed97e360abab7d6ff4b81ee970a7e97466acfd9644f828ffec538abc383d0e92326d1c88c55e1f46a6
1081            68a039beaa1be631a89129938c00a81a3ae46d4aecbf9707f764dbaccea3ef7665e4c4307fa0b0a3075c",
1082        );
1083        (public_key, sig, message, false)
1084    }
1085
1086    fn vector_sig_verification_11() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1087        let (public_key, sig, message) = parse_vector_sig_verification(
1088            "43691c7795a57ead8c5c68536fe934538d46f12889680a9cb6d055a066228369",
1089            "f8790110b3c3b281aa1eae037d4f1234aff587d903d93ba3af225c27ddc9ccac",
1090            "8acd62e8c262fa50dd9840480969f4ef70f218ebf8ef9584f199031132c6b1ce",
1091            "cfca7ed3d4347fb2a29e526b43c348ae1ce6c60d44f3191b6d8ea3a2d9c92154",
1092            "4a8c071ac4fd0d52faa407b0fe5dab759f7394a5832127f2a3498f34aac287339e043b4ffa79528faf19
1093            9dc917f7b066ad65505dab0e11e6948515052ce20cfdb892ffb8aa9bf3f1aa5be30a5bbe85823bddf70b39fd
1094            7ebd4a93a2f75472c1d4f606247a9821f1a8c45a6cb80545de2e0c6c0174e2392088c754e9c8443eb5af",
1095        );
1096        (public_key, sig, message, false)
1097    }
1098
1099    fn vector_sig_verification_12() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1100        let (public_key, sig, message) = parse_vector_sig_verification(
1101            "9157dbfcf8cf385f5bb1568ad5c6e2a8652ba6dfc63bc1753edf5268cb7eb596",
1102            "972570f4313d47fc96f7c02d5594d77d46f91e949808825b3d31f029e8296405",
1103            "dfaea6f297fa320b707866125c2a7d5d515b51a503bee817de9faa343cc48eeb",
1104            "8f780ad713f9c3e5a4f7fa4c519833dfefc6a7432389b1e4af463961f09764f2",
1105            "0a3a12c3084c865daf1d302c78215d39bfe0b8bf28272b3c0b74beb4b7409db0718239de700785581514
1106            321c6440a4bbaea4c76fa47401e151e68cb6c29017f0bce4631290af5ea5e2bf3ed742ae110b04ade83a5dbd
1107            7358f29a85938e23d87ac8233072b79c94670ff0959f9c7f4517862ff829452096c78f5f2e9a7e4e9216",
1108        );
1109        (public_key, sig, message, false)
1110    }
1111
1112    fn vector_sig_verification_13() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1113        let (public_key, sig, message) = parse_vector_sig_verification(
1114            "072b10c081a4c1713a294f248aef850e297991aca47fa96a7470abe3b8acfdda",
1115            "9581145cca04a0fb94cedce752c8f0370861916d2a94e7c647c5373ce6a4c8f5",
1116            "09f5483eccec80f9d104815a1be9cc1a8e5b12b6eb482a65c6907b7480cf4f19",
1117            "a4f90e560c5e4eb8696cb276e5165b6a9d486345dedfb094a76e8442d026378d",
1118            "785d07a3c54f63dca11f5d1a5f496ee2c2f9288e55007e666c78b007d95cc28581dce51f490b30fa73dc
1119            9e2d45d075d7e3a95fb8a9e1465ad191904124160b7c60fa720ef4ef1c5d2998f40570ae2a870ef3e894c2bc
1120            617d8a1dc85c3c55774928c38789b4e661349d3f84d2441a3b856a76949b9f1f80bc161648a1cad5588e",
1121        );
1122        (public_key, sig, message, false)
1123    }
1124
1125    fn vector_sig_verification_14() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1126        let (public_key, sig, message) = parse_vector_sig_verification(
1127            "09308ea5bfad6e5adf408634b3d5ce9240d35442f7fe116452aaec0d25be8c24",
1128            "f40c93e023ef494b1c3079b2d10ef67f3170740495ce2cc57f8ee4b0618b8ee5",
1129            "5cc8aa7c35743ec0c23dde88dabd5e4fcd0192d2116f6926fef788cddb754e73",
1130            "9c9c045ebaa1b828c32f82ace0d18daebf5e156eb7cbfdc1eff4399a8a900ae7",
1131            "76f987ec5448dd72219bd30bf6b66b0775c80b394851a43ff1f537f140a6e7229ef8cd72ad58b1d2d202
1132            98539d6347dd5598812bc65323aceaf05228f738b5ad3e8d9fe4100fd767c2f098c77cb99c2992843ba3eed9
1133            1d32444f3b6db6cd212dd4e5609548f4bb62812a920f6e2bf1581be1ebeebdd06ec4e971862cc42055ca",
1134        );
1135        (public_key, sig, message, false)
1136    }
1137
1138    fn vector_sig_verification_15() -> (PublicKey, Vec<u8>, Vec<u8>, bool) {
1139        let (public_key, sig, message) = parse_vector_sig_verification(
1140            "2d98ea01f754d34bbc3003df5050200abf445ec728556d7ed7d5c54c55552b6d",
1141            "9b52672742d637a32add056dfd6d8792f2a33c2e69dafabea09b960bc61e230a",
1142            "06108e525f845d0155bf60193222b3219c98e3d49424c2fb2a0987f825c17959",
1143            "62b5cdd591e5b507e560167ba8f6f7cda74673eb315680cb89ccbc4eec477dce",
1144            "60cd64b2cd2be6c33859b94875120361a24085f3765cb8b2bf11e026fa9d8855dbe435acf7882e84f3c7
1145            857f96e2baab4d9afe4588e4a82e17a78827bfdb5ddbd1c211fbc2e6d884cddd7cb9d90d5bf4a7311b83f352
1146            508033812c776a0e00c003c7e0d628e50736c7512df0acfa9f2320bd102229f46495ae6d0857cc452a84",
1147        );
1148        (public_key, sig, message, true)
1149    }
1150}
commonware_cryptography/secp256r1/scheme.rs

commonware_cryptography/secp256r1/
scheme.rs
