commonware_cryptography/ed25519/
scheme.rs

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

commonware_cryptography/ed25519/
scheme.rs
