commonware_cryptography/ed25519/
scheme.rs

1use crate::{Array, PrivateKeyExt};
2cfg_if::cfg_if! {
3    if #[cfg(feature = "std")] {
4        use crate::BatchVerifier;
5        use std::borrow::{Cow, ToOwned};
6    } else {
7        use alloc::borrow::ToOwned;
8    }
9}
10use bytes::{Buf, BufMut};
11use commonware_codec::{Error as CodecError, FixedSize, Read, ReadExt, Write};
12use commonware_utils::{hex, union_unique, Span};
13use core::{
14    fmt::{Debug, Display},
15    hash::{Hash, Hasher},
16    ops::Deref,
17};
18use ed25519_consensus::{self, VerificationKey};
19use rand_core::CryptoRngCore;
20use zeroize::{Zeroize, ZeroizeOnDrop};
21
22const CURVE_NAME: &str = "ed25519";
23const PRIVATE_KEY_LENGTH: usize = 32;
24const PUBLIC_KEY_LENGTH: usize = 32;
25const SIGNATURE_LENGTH: usize = 64;
26
27/// Ed25519 Private Key.
28#[derive(Clone, Zeroize, ZeroizeOnDrop)]
29pub struct PrivateKey {
30    raw: [u8; PRIVATE_KEY_LENGTH],
31    key: ed25519_consensus::SigningKey,
32}
33
34impl crate::PrivateKey for PrivateKey {}
35
36impl crate::Signer for PrivateKey {
37    type Signature = Signature;
38    type PublicKey = PublicKey;
39
40    fn sign(&self, namespace: Option<&[u8]>, msg: &[u8]) -> Self::Signature {
41        let sig = match namespace {
42            Some(namespace) => self.key.sign(&union_unique(namespace, msg)),
43            None => self.key.sign(msg),
44        };
45        Signature::from(sig)
46    }
47
48    fn public_key(&self) -> Self::PublicKey {
49        let raw = self.key.verification_key().to_bytes();
50        Self::PublicKey {
51            raw,
52            key: self.key.verification_key().to_owned(),
53        }
54    }
55}
56
57impl PrivateKeyExt for PrivateKey {
58    fn from_rng<R: CryptoRngCore>(rng: &mut R) -> Self {
59        let key = ed25519_consensus::SigningKey::new(rng);
60        let raw = key.to_bytes();
61        Self { raw, key }
62    }
63}
64
65impl Write for PrivateKey {
66    fn write(&self, buf: &mut impl BufMut) {
67        self.raw.write(buf);
68    }
69}
70
71impl Read for PrivateKey {
72    type Cfg = ();
73
74    fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, CodecError> {
75        let raw = <[u8; Self::SIZE]>::read(buf)?;
76        let key = ed25519_consensus::SigningKey::from(raw);
77        Ok(Self { raw, key })
78    }
79}
80
81impl FixedSize for PrivateKey {
82    const SIZE: usize = PRIVATE_KEY_LENGTH;
83}
84
85impl Span for PrivateKey {}
86
87impl Array for PrivateKey {}
88
89impl Eq for PrivateKey {}
90
91impl Hash for PrivateKey {
92    fn hash<H: Hasher>(&self, state: &mut H) {
93        self.raw.hash(state);
94    }
95}
96
97impl PartialEq for PrivateKey {
98    fn eq(&self, other: &Self) -> bool {
99        self.raw == other.raw
100    }
101}
102
103impl Ord for PrivateKey {
104    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
105        self.raw.cmp(&other.raw)
106    }
107}
108
109impl PartialOrd for PrivateKey {
110    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
111        Some(self.cmp(other))
112    }
113}
114
115impl AsRef<[u8]> for PrivateKey {
116    fn as_ref(&self) -> &[u8] {
117        &self.raw
118    }
119}
120
121impl Deref for PrivateKey {
122    type Target = [u8];
123    fn deref(&self) -> &[u8] {
124        &self.raw
125    }
126}
127
128impl From<ed25519_consensus::SigningKey> for PrivateKey {
129    fn from(key: ed25519_consensus::SigningKey) -> Self {
130        let raw = key.to_bytes();
131        Self { raw, key }
132    }
133}
134
135impl Debug for PrivateKey {
136    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
137        write!(f, "{}", hex(&self.raw))
138    }
139}
140
141impl Display for PrivateKey {
142    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
143        write!(f, "{}", hex(&self.raw))
144    }
145}
146
147/// Ed25519 Public Key.
148#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
149pub struct PublicKey {
150    raw: [u8; PUBLIC_KEY_LENGTH],
151    key: ed25519_consensus::VerificationKey,
152}
153
154impl From<PrivateKey> for PublicKey {
155    fn from(value: PrivateKey) -> Self {
156        let raw = value.key.verification_key().to_bytes();
157        Self {
158            raw,
159            key: value.key.verification_key(),
160        }
161    }
162}
163
164impl crate::PublicKey for PublicKey {}
165
166impl crate::Verifier for PublicKey {
167    type Signature = Signature;
168
169    fn verify(&self, namespace: Option<&[u8]>, msg: &[u8], sig: &Self::Signature) -> bool {
170        match namespace {
171            Some(namespace) => {
172                let payload = union_unique(namespace, msg);
173                self.key.verify(&sig.signature, &payload).is_ok()
174            }
175            None => self.key.verify(&sig.signature, msg).is_ok(),
176        }
177    }
178}
179
180impl Write for PublicKey {
181    fn write(&self, buf: &mut impl BufMut) {
182        self.raw.write(buf);
183    }
184}
185
186impl Read for PublicKey {
187    type Cfg = ();
188
189    fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, CodecError> {
190        let raw = <[u8; Self::SIZE]>::read(buf)?;
191        let result = VerificationKey::try_from(raw);
192        #[cfg(feature = "std")]
193        let key = result.map_err(|e| CodecError::Wrapped(CURVE_NAME, e.into()))?;
194        #[cfg(not(feature = "std"))]
195        let key = result
196            .map_err(|e| CodecError::Wrapped(CURVE_NAME, alloc::format!("{:?}", e).into()))?;
197
198        Ok(Self { raw, key })
199    }
200}
201
202impl FixedSize for PublicKey {
203    const SIZE: usize = PUBLIC_KEY_LENGTH;
204}
205
206impl Span for PublicKey {}
207
208impl Array for PublicKey {}
209
210impl AsRef<[u8]> for PublicKey {
211    fn as_ref(&self) -> &[u8] {
212        &self.raw
213    }
214}
215
216impl Deref for PublicKey {
217    type Target = [u8];
218    fn deref(&self) -> &[u8] {
219        &self.raw
220    }
221}
222
223impl From<VerificationKey> for PublicKey {
224    fn from(key: VerificationKey) -> Self {
225        let raw = key.to_bytes();
226        Self { raw, key }
227    }
228}
229
230impl Debug for PublicKey {
231    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
232        write!(f, "{}", hex(&self.raw))
233    }
234}
235
236impl Display for PublicKey {
237    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
238        write!(f, "{}", hex(&self.raw))
239    }
240}
241
242/// Ed25519 Signature.
243#[derive(Clone, Eq, PartialEq)]
244pub struct Signature {
245    raw: [u8; SIGNATURE_LENGTH],
246    signature: ed25519_consensus::Signature,
247}
248
249impl crate::Signature for Signature {}
250
251impl Write for Signature {
252    fn write(&self, buf: &mut impl BufMut) {
253        self.raw.write(buf);
254    }
255}
256
257impl Read for Signature {
258    type Cfg = ();
259
260    fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, CodecError> {
261        let raw = <[u8; Self::SIZE]>::read(buf)?;
262        let signature = ed25519_consensus::Signature::from(raw);
263        Ok(Self { raw, signature })
264    }
265}
266
267impl FixedSize for Signature {
268    const SIZE: usize = SIGNATURE_LENGTH;
269}
270
271impl Span for Signature {}
272
273impl Array for Signature {}
274
275impl Hash for Signature {
276    fn hash<H: Hasher>(&self, state: &mut H) {
277        self.raw.hash(state);
278    }
279}
280
281impl Ord for Signature {
282    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
283        self.raw.cmp(&other.raw)
284    }
285}
286
287impl PartialOrd for Signature {
288    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
289        Some(self.cmp(other))
290    }
291}
292
293impl AsRef<[u8]> for Signature {
294    fn as_ref(&self) -> &[u8] {
295        &self.raw
296    }
297}
298
299impl Deref for Signature {
300    type Target = [u8];
301    fn deref(&self) -> &[u8] {
302        &self.raw
303    }
304}
305
306impl From<ed25519_consensus::Signature> for Signature {
307    fn from(value: ed25519_consensus::Signature) -> Self {
308        let raw = value.to_bytes();
309        Self {
310            raw,
311            signature: value,
312        }
313    }
314}
315
316impl Debug for Signature {
317    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
318        write!(f, "{}", hex(&self.raw))
319    }
320}
321
322impl Display for Signature {
323    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
324        write!(f, "{}", hex(&self.raw))
325    }
326}
327
328/// Ed25519 Batch Verifier.
329#[cfg(feature = "std")]
330pub struct Batch {
331    verifier: ed25519_consensus::batch::Verifier,
332}
333
334#[cfg(feature = "std")]
335impl BatchVerifier<PublicKey> for Batch {
336    fn new() -> Self {
337        Batch {
338            verifier: ed25519_consensus::batch::Verifier::new(),
339        }
340    }
341
342    fn add(
343        &mut self,
344        namespace: Option<&[u8]>,
345        message: &[u8],
346        public_key: &PublicKey,
347        signature: &Signature,
348    ) -> bool {
349        let payload = match namespace {
350            Some(namespace) => Cow::Owned(union_unique(namespace, message)),
351            None => Cow::Borrowed(message),
352        };
353        let item = ed25519_consensus::batch::Item::from((
354            public_key.key.into(),
355            signature.signature,
356            &payload,
357        ));
358        self.verifier.queue(item);
359        true
360    }
361
362    fn verify<R: CryptoRngCore>(self, rng: &mut R) -> bool {
363        self.verifier.verify(rng).is_ok()
364    }
365}
366
367/// Test vectors sourced from https://datatracker.ietf.org/doc/html/rfc8032#section-7.1.
368#[cfg(test)]
369mod tests {
370    use super::*;
371    use crate::{ed25519, Signer as _, Verifier as _};
372    use commonware_codec::{DecodeExt, Encode};
373    use rand::rngs::OsRng;
374
375    fn test_sign_and_verify(
376        private_key: PrivateKey,
377        public_key: PublicKey,
378        message: &[u8],
379        signature: Signature,
380    ) {
381        let computed_signature = private_key.sign(None, message);
382        assert_eq!(computed_signature, signature);
383        assert!(public_key.verify(None, message, &computed_signature));
384    }
385
386    fn parse_private_key(private_key: &str) -> PrivateKey {
387        PrivateKey::decode(
388            commonware_utils::from_hex_formatted(private_key)
389                .unwrap()
390                .as_ref(),
391        )
392        .unwrap()
393    }
394
395    fn parse_public_key(public_key: &str) -> PublicKey {
396        PublicKey::decode(
397            commonware_utils::from_hex_formatted(public_key)
398                .unwrap()
399                .as_ref(),
400        )
401        .unwrap()
402    }
403
404    fn parse_signature(signature: &str) -> Signature {
405        Signature::decode(
406            commonware_utils::from_hex_formatted(signature)
407                .unwrap()
408                .as_ref(),
409        )
410        .unwrap()
411    }
412
413    fn vector_1() -> (PrivateKey, PublicKey, Vec<u8>, Signature) {
414        (
415            // secret key
416            parse_private_key(
417                "
418                9d61b19deffd5a60ba844af492ec2cc4
419                4449c5697b326919703bac031cae7f60
420                ",
421            ),
422            // public key
423            parse_public_key(
424                "
425                d75a980182b10ab7d54bfed3c964073a
426                0ee172f3daa62325af021a68f707511a
427                ",
428            ),
429            // message
430            b"".to_vec(),
431            // signature
432            parse_signature(
433                "
434                e5564300c360ac729086e2cc806e828a
435                84877f1eb8e5d974d873e06522490155
436                5fb8821590a33bacc61e39701cf9b46b
437                d25bf5f0595bbe24655141438e7a100b
438                ",
439            ),
440        )
441    }
442
443    fn vector_2() -> (PrivateKey, PublicKey, Vec<u8>, Signature) {
444        (
445            // secret key
446            parse_private_key(
447                "
448                4ccd089b28ff96da9db6c346ec114e0f
449                5b8a319f35aba624da8cf6ed4fb8a6fb
450                ",
451            ),
452            // public key
453            parse_public_key(
454                "
455                3d4017c3e843895a92b70aa74d1b7ebc
456                9c982ccf2ec4968cc0cd55f12af4660c
457                ",
458            ),
459            // message
460            [0x72].to_vec(),
461            // signature
462            parse_signature(
463                "
464                92a009a9f0d4cab8720e820b5f642540
465                a2b27b5416503f8fb3762223ebdb69da
466                085ac1e43e15996e458f3613d0f11d8c
467                387b2eaeb4302aeeb00d291612bb0c00
468                ",
469            ),
470        )
471    }
472
473    #[test]
474    fn test_codec_private_key() {
475        let private_key = parse_private_key(
476            "
477            9d61b19deffd5a60ba844af492ec2cc4
478            4449c5697b326919703bac031cae7f60
479            ",
480        );
481        let encoded = private_key.encode();
482        assert_eq!(encoded.len(), PRIVATE_KEY_LENGTH);
483        let decoded = PrivateKey::decode(encoded).unwrap();
484        assert_eq!(private_key, decoded);
485    }
486
487    #[test]
488    fn test_codec_public_key() {
489        let public_key = parse_public_key(
490            "
491            d75a980182b10ab7d54bfed3c964073a
492            0ee172f3daa62325af021a68f707511a
493            ",
494        );
495        let encoded = public_key.encode();
496        assert_eq!(encoded.len(), PUBLIC_KEY_LENGTH);
497        let decoded = PublicKey::decode(encoded).unwrap();
498        assert_eq!(public_key, decoded);
499    }
500
501    #[test]
502    fn test_codec_signature() {
503        let signature = parse_signature(
504            "
505            e5564300c360ac729086e2cc806e828a
506            84877f1eb8e5d974d873e06522490155
507            5fb8821590a33bacc61e39701cf9b46b
508            d25bf5f0595bbe24655141438e7a100b
509            ",
510        );
511        let encoded = signature.encode();
512        assert_eq!(encoded.len(), SIGNATURE_LENGTH);
513        let decoded = Signature::decode(encoded).unwrap();
514        assert_eq!(signature, decoded);
515    }
516
517    #[test]
518    fn rfc8032_test_vector_1() {
519        let (private_key, public_key, message, signature) = vector_1();
520        test_sign_and_verify(private_key, public_key, &message, signature)
521    }
522
523    // sanity check the test infra rejects bad signatures
524    #[test]
525    #[should_panic]
526    fn bad_signature() {
527        let (private_key, public_key, message, _) = vector_1();
528        let private_key_2 = PrivateKey::from_rng(&mut OsRng);
529        let bad_signature = private_key_2.sign(None, message.as_ref());
530        test_sign_and_verify(private_key, public_key, &message, bad_signature);
531    }
532
533    // sanity check the test infra rejects non-matching messages
534    #[test]
535    #[should_panic]
536    fn different_message() {
537        let (private_key, public_key, _, signature) = vector_1();
538        let different_message = b"this is a different message".to_vec();
539        test_sign_and_verify(private_key, public_key, &different_message, signature);
540    }
541
542    #[test]
543    fn rfc8032_test_vector_2() {
544        let (private_key, public_key, message, signature) = vector_2();
545        test_sign_and_verify(private_key, public_key, &message, signature)
546    }
547
548    #[test]
549    fn rfc8032_test_vector_3() {
550        let private_key = parse_private_key(
551            "
552            c5aa8df43f9f837bedb7442f31dcb7b1
553            66d38535076f094b85ce3a2e0b4458f7
554            ",
555        );
556        let public_key = parse_public_key(
557            "
558            fc51cd8e6218a1a38da47ed00230f058
559            0816ed13ba3303ac5deb911548908025
560            ",
561        );
562        let message: [u8; 2] = [0xaf, 0x82];
563        let signature = parse_signature(
564            "
565            6291d657deec24024827e69c3abe01a3
566            0ce548a284743a445e3680d7db5ac3ac
567            18ff9b538d16f290ae67f760984dc659
568            4a7c15e9716ed28dc027beceea1ec40a
569            ",
570        );
571        test_sign_and_verify(private_key, public_key, &message, signature)
572    }
573
574    #[test]
575    fn rfc8032_test_vector_1024() {
576        let private_key = parse_private_key(
577            "
578            f5e5767cf153319517630f226876b86c
579            8160cc583bc013744c6bf255f5cc0ee5
580            ",
581        );
582        let public_key = parse_public_key(
583            "
584            278117fc144c72340f67d0f2316e8386
585            ceffbf2b2428c9c51fef7c597f1d426e
586            ",
587        );
588        let message = commonware_utils::from_hex_formatted(
589            "
590            08b8b2b733424243760fe426a4b54908
591            632110a66c2f6591eabd3345e3e4eb98
592            fa6e264bf09efe12ee50f8f54e9f77b1
593            e355f6c50544e23fb1433ddf73be84d8
594            79de7c0046dc4996d9e773f4bc9efe57
595            38829adb26c81b37c93a1b270b20329d
596            658675fc6ea534e0810a4432826bf58c
597            941efb65d57a338bbd2e26640f89ffbc
598            1a858efcb8550ee3a5e1998bd177e93a
599            7363c344fe6b199ee5d02e82d522c4fe
600            ba15452f80288a821a579116ec6dad2b
601            3b310da903401aa62100ab5d1a36553e
602            06203b33890cc9b832f79ef80560ccb9
603            a39ce767967ed628c6ad573cb116dbef
604            efd75499da96bd68a8a97b928a8bbc10
605            3b6621fcde2beca1231d206be6cd9ec7
606            aff6f6c94fcd7204ed3455c68c83f4a4
607            1da4af2b74ef5c53f1d8ac70bdcb7ed1
608            85ce81bd84359d44254d95629e9855a9
609            4a7c1958d1f8ada5d0532ed8a5aa3fb2
610            d17ba70eb6248e594e1a2297acbbb39d
611            502f1a8c6eb6f1ce22b3de1a1f40cc24
612            554119a831a9aad6079cad88425de6bd
613            e1a9187ebb6092cf67bf2b13fd65f270
614            88d78b7e883c8759d2c4f5c65adb7553
615            878ad575f9fad878e80a0c9ba63bcbcc
616            2732e69485bbc9c90bfbd62481d9089b
617            eccf80cfe2df16a2cf65bd92dd597b07
618            07e0917af48bbb75fed413d238f5555a
619            7a569d80c3414a8d0859dc65a46128ba
620            b27af87a71314f318c782b23ebfe808b
621            82b0ce26401d2e22f04d83d1255dc51a
622            ddd3b75a2b1ae0784504df543af8969b
623            e3ea7082ff7fc9888c144da2af58429e
624            c96031dbcad3dad9af0dcbaaaf268cb8
625            fcffead94f3c7ca495e056a9b47acdb7
626            51fb73e666c6c655ade8297297d07ad1
627            ba5e43f1bca32301651339e22904cc8c
628            42f58c30c04aafdb038dda0847dd988d
629            cda6f3bfd15c4b4c4525004aa06eeff8
630            ca61783aacec57fb3d1f92b0fe2fd1a8
631            5f6724517b65e614ad6808d6f6ee34df
632            f7310fdc82aebfd904b01e1dc54b2927
633            094b2db68d6f903b68401adebf5a7e08
634            d78ff4ef5d63653a65040cf9bfd4aca7
635            984a74d37145986780fc0b16ac451649
636            de6188a7dbdf191f64b5fc5e2ab47b57
637            f7f7276cd419c17a3ca8e1b939ae49e4
638            88acba6b965610b5480109c8b17b80e1
639            b7b750dfc7598d5d5011fd2dcc5600a3
640            2ef5b52a1ecc820e308aa342721aac09
641            43bf6686b64b2579376504ccc493d97e
642            6aed3fb0f9cd71a43dd497f01f17c0e2
643            cb3797aa2a2f256656168e6c496afc5f
644            b93246f6b1116398a346f1a641f3b041
645            e989f7914f90cc2c7fff357876e506b5
646            0d334ba77c225bc307ba537152f3f161
647            0e4eafe595f6d9d90d11faa933a15ef1
648            369546868a7f3a45a96768d40fd9d034
649            12c091c6315cf4fde7cb68606937380d
650            b2eaaa707b4c4185c32eddcdd306705e
651            4dc1ffc872eeee475a64dfac86aba41c
652            0618983f8741c5ef68d3a101e8a3b8ca
653            c60c905c15fc910840b94c00a0b9d0
654            ",
655        )
656        .unwrap();
657        let signature = parse_signature(
658            "
659            0aab4c900501b3e24d7cdf4663326a3a
660            87df5e4843b2cbdb67cbf6e460fec350
661            aa5371b1508f9f4528ecea23c436d94b
662            5e8fcd4f681e30a6ac00a9704a188a03
663            ",
664        );
665        test_sign_and_verify(private_key, public_key, &message, signature)
666    }
667
668    #[test]
669    fn rfc8032_test_vector_sha() {
670        let private_key = commonware_utils::from_hex_formatted(
671            "
672            833fe62409237b9d62ec77587520911e
673            9a759cec1d19755b7da901b96dca3d42
674            ",
675        )
676        .unwrap();
677        let public_key = commonware_utils::from_hex_formatted(
678            "
679            ec172b93ad5e563bf4932c70e1245034
680            c35467ef2efd4d64ebf819683467e2bf
681            ",
682        )
683        .unwrap();
684        let message = commonware_utils::from_hex_formatted(
685            "
686            ddaf35a193617abacc417349ae204131
687            12e6fa4e89a97ea20a9eeee64b55d39a
688            2192992a274fc1a836ba3c23a3feebbd
689            454d4423643ce80e2a9ac94fa54ca49f
690            ",
691        )
692        .unwrap();
693        let signature = commonware_utils::from_hex_formatted(
694            "
695            dc2a4459e7369633a52b1bf277839a00
696            201009a3efbf3ecb69bea2186c26b589
697            09351fc9ac90b3ecfdfbc7c66431e030
698            3dca179c138ac17ad9bef1177331a704
699            ",
700        )
701        .unwrap();
702        test_sign_and_verify(
703            PrivateKey::decode(private_key.as_ref()).unwrap(),
704            PublicKey::decode(public_key.as_ref()).unwrap(),
705            &message,
706            Signature::decode(signature.as_ref()).unwrap(),
707        )
708    }
709
710    #[test]
711    fn batch_verify_valid() {
712        let v1 = vector_1();
713        let v2 = vector_2();
714        let mut batch = ed25519::Batch::new();
715        assert!(batch.add(None, &v1.2, &v1.1, &v1.3));
716        assert!(batch.add(None, &v2.2, &v2.1, &v2.3));
717        assert!(batch.verify(&mut rand::thread_rng()));
718    }
719
720    #[test]
721    fn batch_verify_invalid() {
722        let v1 = vector_1();
723        let v2 = vector_2();
724        let mut bad_signature = v2.3.to_vec();
725        bad_signature[3] = 0xff;
726
727        let mut batch = Batch::new();
728        assert!(batch.add(None, &v1.2, &v1.1, &v1.3));
729        assert!(batch.add(
730            None,
731            &v2.2,
732            &v2.1,
733            &Signature::decode(bad_signature.as_ref()).unwrap()
734        ));
735        assert!(!batch.verify(&mut rand::thread_rng()));
736    }
737
738    #[test]
739    fn test_zero_signature_fails() {
740        let (_, public_key, message, _) = vector_1();
741        let zero_sig = Signature::decode(vec![0u8; Signature::SIZE].as_ref()).unwrap();
742        assert!(!public_key.verify(None, &message, &zero_sig));
743    }
744
745    #[test]
746    fn test_high_s_fails() {
747        let (_, public_key, message, signature) = vector_1();
748        let mut bad_signature = signature.to_vec();
749        bad_signature[63] |= 0x80; // make S non-canonical
750        let bad_signature = Signature::decode(bad_signature.as_ref()).unwrap();
751        assert!(!public_key.verify(None, &message, &bad_signature));
752    }
753
754    #[test]
755    fn test_invalid_r_fails() {
756        let (_, public_key, message, signature) = vector_1();
757        let mut bad_signature = signature.to_vec();
758        for b in bad_signature.iter_mut().take(32) {
759            *b = 0xff; // invalid R component
760        }
761        let bad_signature = Signature::decode(bad_signature.as_ref()).unwrap();
762        assert!(!public_key.verify(None, &message, &bad_signature));
763    }
764}
commonware_cryptography/ed25519/scheme.rs

commonware_cryptography/ed25519/
scheme.rs
