commonware_cryptography/ed25519/
scheme.rs

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

commonware_cryptography/ed25519/
scheme.rs
