aptos_sdk/crypto/
ed25519.rs

1//! Ed25519 signature scheme implementation.
2//!
3//! Ed25519 is the default and most commonly used signature scheme on Aptos.
4
5use crate::crypto::traits::{PublicKey, Signature, Signer, Verifier};
6use crate::error::{AptosError, AptosResult};
7use ed25519_dalek::{Signer as DalekSigner, Verifier as DalekVerifier};
8use serde::{Deserialize, Serialize};
9use std::fmt;
10use zeroize::Zeroize;
11
12/// Ed25519 private key length in bytes.
13pub const ED25519_PRIVATE_KEY_LENGTH: usize = 32;
14/// Ed25519 public key length in bytes.
15pub const ED25519_PUBLIC_KEY_LENGTH: usize = 32;
16/// Ed25519 signature length in bytes.
17pub const ED25519_SIGNATURE_LENGTH: usize = 64;
18
19/// An Ed25519 private key.
20///
21/// The private key is zeroized when dropped to prevent sensitive
22/// data from remaining in memory.
23///
24/// # Example
25///
26/// ```rust
27/// use aptos_sdk::crypto::{Ed25519PrivateKey, Signer};
28///
29/// // Generate a random key
30/// let private_key = Ed25519PrivateKey::generate();
31///
32/// // Sign a message
33/// let signature = private_key.sign(b"hello");
34///
35/// // Get the public key
36/// let public_key = private_key.public_key();
37/// ```
38#[derive(Clone, Zeroize)]
39#[zeroize(drop)]
40pub struct Ed25519PrivateKey {
41    #[zeroize(skip)]
42    #[allow(unused)] // Field is used; lint false positive from Zeroize derive
43    inner: ed25519_dalek::SigningKey,
44}
45
46impl Ed25519PrivateKey {
47    /// Generates a new random Ed25519 private key.
48    pub fn generate() -> Self {
49        let mut csprng = rand::rngs::OsRng;
50        let signing_key = ed25519_dalek::SigningKey::generate(&mut csprng);
51        Self { inner: signing_key }
52    }
53
54    /// Creates a private key from raw bytes.
55    ///
56    /// # Errors
57    ///
58    /// Returns [`AptosError::InvalidPrivateKey`] if:
59    /// - The byte slice length is not exactly 32 bytes
60    pub fn from_bytes(bytes: &[u8]) -> AptosResult<Self> {
61        if bytes.len() != ED25519_PRIVATE_KEY_LENGTH {
62            return Err(AptosError::InvalidPrivateKey(format!(
63                "expected {} bytes, got {}",
64                ED25519_PRIVATE_KEY_LENGTH,
65                bytes.len()
66            )));
67        }
68        let mut key_bytes = [0u8; ED25519_PRIVATE_KEY_LENGTH];
69        key_bytes.copy_from_slice(bytes);
70        let signing_key = ed25519_dalek::SigningKey::from_bytes(&key_bytes);
71        // SECURITY: Zeroize the temporary buffer that held private key material
72        zeroize::Zeroize::zeroize(&mut key_bytes);
73        Ok(Self { inner: signing_key })
74    }
75
76    /// Creates a private key from a hex string.
77    ///
78    /// # Errors
79    ///
80    /// Returns [`AptosError::Hex`] if the hex string is invalid.
81    /// Returns [`AptosError::InvalidPrivateKey`] if the decoded bytes are not exactly 32 bytes.
82    pub fn from_hex(hex_str: &str) -> AptosResult<Self> {
83        let bytes = const_hex::decode(hex_str)?;
84        Self::from_bytes(&bytes)
85    }
86
87    /// Creates a private key from AIP-80 format string.
88    ///
89    /// AIP-80 format: `ed25519-priv-0x{hex_bytes}`
90    ///
91    /// # Errors
92    ///
93    /// Returns an error if the format is invalid or the key bytes are invalid.
94    ///
95    /// # Example
96    ///
97    /// ```rust
98    /// use aptos_sdk::crypto::Ed25519PrivateKey;
99    ///
100    /// let key = Ed25519PrivateKey::from_aip80(
101    ///     "ed25519-priv-0x0000000000000000000000000000000000000000000000000000000000000001"
102    /// ).unwrap();
103    /// ```
104    pub fn from_aip80(s: &str) -> AptosResult<Self> {
105        const PREFIX: &str = "ed25519-priv-";
106        if let Some(hex_part) = s.strip_prefix(PREFIX) {
107            Self::from_hex(hex_part)
108        } else {
109            Err(AptosError::InvalidPrivateKey(format!(
110                "invalid AIP-80 format: expected prefix '{PREFIX}'"
111            )))
112        }
113    }
114
115    /// Returns the private key as bytes.
116    ///
117    /// **Warning**: Handle the returned bytes carefully to avoid leaking
118    /// sensitive key material.
119    pub fn to_bytes(&self) -> [u8; ED25519_PRIVATE_KEY_LENGTH] {
120        self.inner.to_bytes()
121    }
122
123    /// Returns the private key as a hex string.
124    pub fn to_hex(&self) -> String {
125        const_hex::encode_prefixed(self.inner.to_bytes())
126    }
127
128    /// Returns the private key in AIP-80 format.
129    ///
130    /// AIP-80 format: `ed25519-priv-0x{hex_bytes}`
131    ///
132    /// # Example
133    ///
134    /// ```rust
135    /// use aptos_sdk::crypto::Ed25519PrivateKey;
136    ///
137    /// let key = Ed25519PrivateKey::generate();
138    /// let aip80 = key.to_aip80();
139    /// assert!(aip80.starts_with("ed25519-priv-0x"));
140    /// ```
141    pub fn to_aip80(&self) -> String {
142        format!("ed25519-priv-{}", self.to_hex())
143    }
144
145    /// Returns the corresponding public key.
146    pub fn public_key(&self) -> Ed25519PublicKey {
147        Ed25519PublicKey {
148            inner: self.inner.verifying_key(),
149        }
150    }
151
152    /// Signs a message and returns the signature.
153    pub fn sign(&self, message: &[u8]) -> Ed25519Signature {
154        let signature = self.inner.sign(message);
155        Ed25519Signature { inner: signature }
156    }
157}
158
159impl Signer for Ed25519PrivateKey {
160    type Signature = Ed25519Signature;
161
162    fn sign(&self, message: &[u8]) -> Ed25519Signature {
163        Ed25519PrivateKey::sign(self, message)
164    }
165
166    fn public_key(&self) -> Ed25519PublicKey {
167        Ed25519PrivateKey::public_key(self)
168    }
169}
170
171impl fmt::Debug for Ed25519PrivateKey {
172    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
173        write!(f, "Ed25519PrivateKey([REDACTED])")
174    }
175}
176
177/// An Ed25519 public key.
178///
179/// # Example
180///
181/// ```rust
182/// use aptos_sdk::crypto::{Ed25519PrivateKey, Ed25519PublicKey, Signer, Verifier};
183///
184/// let private_key = Ed25519PrivateKey::generate();
185/// let public_key = private_key.public_key();
186///
187/// let message = b"hello";
188/// let signature = private_key.sign(message);
189///
190/// assert!(public_key.verify(message, &signature).is_ok());
191/// ```
192#[derive(Clone, Copy, PartialEq, Eq)]
193pub struct Ed25519PublicKey {
194    inner: ed25519_dalek::VerifyingKey,
195}
196
197impl Ed25519PublicKey {
198    /// Creates a public key from raw bytes.
199    ///
200    /// # Errors
201    ///
202    /// Returns [`AptosError::InvalidPublicKey`] if:
203    /// - The byte slice length is not exactly 32 bytes
204    /// - The bytes do not represent a valid Ed25519 public key
205    pub fn from_bytes(bytes: &[u8]) -> AptosResult<Self> {
206        if bytes.len() != ED25519_PUBLIC_KEY_LENGTH {
207            return Err(AptosError::InvalidPublicKey(format!(
208                "expected {} bytes, got {}",
209                ED25519_PUBLIC_KEY_LENGTH,
210                bytes.len()
211            )));
212        }
213        let mut key_bytes = [0u8; ED25519_PUBLIC_KEY_LENGTH];
214        key_bytes.copy_from_slice(bytes);
215        let verifying_key = ed25519_dalek::VerifyingKey::from_bytes(&key_bytes)
216            .map_err(|e| AptosError::InvalidPublicKey(e.to_string()))?;
217        Ok(Self {
218            inner: verifying_key,
219        })
220    }
221
222    /// Creates a public key from a hex string.
223    ///
224    /// # Errors
225    ///
226    /// Returns [`AptosError::Hex`] if the hex string is invalid.
227    /// Returns [`AptosError::InvalidPublicKey`] if the decoded bytes are not exactly 32 bytes or do not represent a valid Ed25519 public key.
228    pub fn from_hex(hex_str: &str) -> AptosResult<Self> {
229        let bytes = const_hex::decode(hex_str)?;
230        Self::from_bytes(&bytes)
231    }
232
233    /// Creates a public key from AIP-80 format string.
234    ///
235    /// AIP-80 format: `ed25519-pub-0x{hex_bytes}`
236    ///
237    /// # Errors
238    ///
239    /// Returns an error if the format is invalid or the key bytes are invalid.
240    pub fn from_aip80(s: &str) -> AptosResult<Self> {
241        const PREFIX: &str = "ed25519-pub-";
242        if let Some(hex_part) = s.strip_prefix(PREFIX) {
243            Self::from_hex(hex_part)
244        } else {
245            Err(AptosError::InvalidPublicKey(format!(
246                "invalid AIP-80 format: expected prefix '{PREFIX}'"
247            )))
248        }
249    }
250
251    /// Returns the public key as bytes.
252    pub fn to_bytes(&self) -> [u8; ED25519_PUBLIC_KEY_LENGTH] {
253        self.inner.to_bytes()
254    }
255
256    /// Returns the public key as a hex string.
257    pub fn to_hex(&self) -> String {
258        const_hex::encode_prefixed(self.inner.to_bytes())
259    }
260
261    /// Returns the public key in AIP-80 format.
262    ///
263    /// AIP-80 format: `ed25519-pub-0x{hex_bytes}`
264    pub fn to_aip80(&self) -> String {
265        format!("ed25519-pub-{}", self.to_hex())
266    }
267
268    /// Verifies a signature against a message.
269    ///
270    /// # Errors
271    ///
272    /// Returns [`AptosError::SignatureVerificationFailed`] if the signature is invalid or does not match the message.
273    pub fn verify(&self, message: &[u8], signature: &Ed25519Signature) -> AptosResult<()> {
274        self.inner
275            .verify(message, &signature.inner)
276            .map_err(|_| AptosError::SignatureVerificationFailed)
277    }
278
279    /// Derives the account address for this public key.
280    ///
281    /// Uses the Ed25519 single-key scheme (scheme byte 0).
282    pub fn to_address(&self) -> crate::types::AccountAddress {
283        crate::crypto::derive_address(&self.to_bytes(), crate::crypto::ED25519_SCHEME)
284    }
285
286    /// Derives the authentication key for this public key.
287    pub fn to_authentication_key(&self) -> [u8; 32] {
288        crate::crypto::derive_authentication_key(&self.to_bytes(), crate::crypto::ED25519_SCHEME)
289    }
290}
291
292impl PublicKey for Ed25519PublicKey {
293    const LENGTH: usize = ED25519_PUBLIC_KEY_LENGTH;
294
295    fn from_bytes(bytes: &[u8]) -> AptosResult<Self> {
296        Ed25519PublicKey::from_bytes(bytes)
297    }
298
299    fn to_bytes(&self) -> Vec<u8> {
300        self.inner.to_bytes().to_vec()
301    }
302}
303
304impl Verifier for Ed25519PublicKey {
305    type Signature = Ed25519Signature;
306
307    fn verify(&self, message: &[u8], signature: &Ed25519Signature) -> AptosResult<()> {
308        Ed25519PublicKey::verify(self, message, signature)
309    }
310}
311
312impl fmt::Debug for Ed25519PublicKey {
313    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
314        write!(f, "Ed25519PublicKey({})", self.to_hex())
315    }
316}
317
318impl fmt::Display for Ed25519PublicKey {
319    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
320        write!(f, "{}", self.to_hex())
321    }
322}
323
324impl Serialize for Ed25519PublicKey {
325    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
326    where
327        S: serde::Serializer,
328    {
329        if serializer.is_human_readable() {
330            serializer.serialize_str(&self.to_hex())
331        } else {
332            serializer.serialize_bytes(&self.inner.to_bytes())
333        }
334    }
335}
336
337impl<'de> Deserialize<'de> for Ed25519PublicKey {
338    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
339    where
340        D: serde::Deserializer<'de>,
341    {
342        if deserializer.is_human_readable() {
343            let s = String::deserialize(deserializer)?;
344            Self::from_hex(&s).map_err(serde::de::Error::custom)
345        } else {
346            let bytes = <[u8; ED25519_PUBLIC_KEY_LENGTH]>::deserialize(deserializer)?;
347            Self::from_bytes(&bytes).map_err(serde::de::Error::custom)
348        }
349    }
350}
351
352/// An Ed25519 signature.
353#[derive(Clone, Copy, PartialEq, Eq)]
354pub struct Ed25519Signature {
355    inner: ed25519_dalek::Signature,
356}
357
358impl Ed25519Signature {
359    /// Creates a signature from raw bytes.
360    ///
361    /// # Errors
362    ///
363    /// Returns [`AptosError::InvalidSignature`] if:
364    /// - The byte slice length is not exactly 64 bytes
365    /// - The bytes do not represent a valid Ed25519 signature
366    pub fn from_bytes(bytes: &[u8]) -> AptosResult<Self> {
367        if bytes.len() != ED25519_SIGNATURE_LENGTH {
368            return Err(AptosError::InvalidSignature(format!(
369                "expected {} bytes, got {}",
370                ED25519_SIGNATURE_LENGTH,
371                bytes.len()
372            )));
373        }
374        let signature = ed25519_dalek::Signature::from_slice(bytes)
375            .map_err(|e| AptosError::InvalidSignature(e.to_string()))?;
376        Ok(Self { inner: signature })
377    }
378
379    /// Creates a signature from a hex string.
380    ///
381    /// # Errors
382    ///
383    /// Returns [`AptosError::Hex`] if the hex string is invalid.
384    /// Returns [`AptosError::InvalidSignature`] if the decoded bytes are not exactly 64 bytes or do not represent a valid Ed25519 signature.
385    pub fn from_hex(hex_str: &str) -> AptosResult<Self> {
386        let bytes = const_hex::decode(hex_str)?;
387        Self::from_bytes(&bytes)
388    }
389
390    /// Returns the signature as bytes.
391    pub fn to_bytes(&self) -> [u8; ED25519_SIGNATURE_LENGTH] {
392        self.inner.to_bytes()
393    }
394
395    /// Returns the signature as a hex string.
396    pub fn to_hex(&self) -> String {
397        const_hex::encode_prefixed(self.inner.to_bytes())
398    }
399}
400
401impl Signature for Ed25519Signature {
402    type PublicKey = Ed25519PublicKey;
403    const LENGTH: usize = ED25519_SIGNATURE_LENGTH;
404
405    fn from_bytes(bytes: &[u8]) -> AptosResult<Self> {
406        Ed25519Signature::from_bytes(bytes)
407    }
408
409    fn to_bytes(&self) -> Vec<u8> {
410        self.inner.to_bytes().to_vec()
411    }
412}
413
414impl fmt::Debug for Ed25519Signature {
415    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
416        write!(f, "Ed25519Signature({})", self.to_hex())
417    }
418}
419
420impl fmt::Display for Ed25519Signature {
421    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
422        write!(f, "{}", self.to_hex())
423    }
424}
425
426impl Serialize for Ed25519Signature {
427    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
428    where
429        S: serde::Serializer,
430    {
431        if serializer.is_human_readable() {
432            serializer.serialize_str(&self.to_hex())
433        } else {
434            serializer.serialize_bytes(&self.inner.to_bytes())
435        }
436    }
437}
438
439impl<'de> Deserialize<'de> for Ed25519Signature {
440    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
441    where
442        D: serde::Deserializer<'de>,
443    {
444        if deserializer.is_human_readable() {
445            let s = String::deserialize(deserializer)?;
446            Self::from_hex(&s).map_err(serde::de::Error::custom)
447        } else {
448            let bytes = Vec::<u8>::deserialize(deserializer)?;
449            Self::from_bytes(&bytes).map_err(serde::de::Error::custom)
450        }
451    }
452}
453
454#[cfg(test)]
455mod tests {
456    use super::*;
457
458    #[test]
459    fn test_generate_and_sign() {
460        let private_key = Ed25519PrivateKey::generate();
461        let message = b"hello world";
462        let signature = private_key.sign(message);
463
464        let public_key = private_key.public_key();
465        assert!(public_key.verify(message, &signature).is_ok());
466    }
467
468    #[test]
469    fn test_wrong_message_fails() {
470        let private_key = Ed25519PrivateKey::generate();
471        let message = b"hello world";
472        let wrong_message = b"hello world!";
473        let signature = private_key.sign(message);
474
475        let public_key = private_key.public_key();
476        assert!(public_key.verify(wrong_message, &signature).is_err());
477    }
478
479    #[test]
480    fn test_from_bytes_roundtrip() {
481        let private_key = Ed25519PrivateKey::generate();
482        let bytes = private_key.to_bytes();
483        let restored = Ed25519PrivateKey::from_bytes(&bytes).unwrap();
484        assert_eq!(private_key.to_bytes(), restored.to_bytes());
485    }
486
487    #[test]
488    fn test_from_hex_roundtrip() {
489        let private_key = Ed25519PrivateKey::generate();
490        let hex = private_key.to_hex();
491        let restored = Ed25519PrivateKey::from_hex(&hex).unwrap();
492        assert_eq!(private_key.to_bytes(), restored.to_bytes());
493    }
494
495    #[test]
496    fn test_public_key_serialization() {
497        let private_key = Ed25519PrivateKey::generate();
498        let public_key = private_key.public_key();
499
500        let json = serde_json::to_string(&public_key).unwrap();
501        let restored: Ed25519PublicKey = serde_json::from_str(&json).unwrap();
502        assert_eq!(public_key, restored);
503    }
504
505    #[test]
506    fn test_address_derivation() {
507        let private_key = Ed25519PrivateKey::generate();
508        let public_key = private_key.public_key();
509        let address = public_key.to_address();
510
511        // Address should not be zero
512        assert!(!address.is_zero());
513
514        // Same public key should always derive same address
515        let address2 = public_key.to_address();
516        assert_eq!(address, address2);
517    }
518
519    #[test]
520    fn test_private_key_aip80_roundtrip() {
521        let private_key = Ed25519PrivateKey::generate();
522        let aip80 = private_key.to_aip80();
523
524        // Should have correct prefix
525        assert!(aip80.starts_with("ed25519-priv-0x"));
526
527        // Should roundtrip correctly
528        let restored = Ed25519PrivateKey::from_aip80(&aip80).unwrap();
529        assert_eq!(private_key.to_bytes(), restored.to_bytes());
530    }
531
532    #[test]
533    fn test_private_key_aip80_format() {
534        let bytes = [0x01; 32];
535        let private_key = Ed25519PrivateKey::from_bytes(&bytes).unwrap();
536        let aip80 = private_key.to_aip80();
537
538        // Expected format: ed25519-priv-0x0101...01
539        let expected = format!("ed25519-priv-0x{}", "01".repeat(32));
540        assert_eq!(aip80, expected);
541    }
542
543    #[test]
544    fn test_private_key_aip80_invalid_prefix() {
545        let result = Ed25519PrivateKey::from_aip80("secp256k1-priv-0x01");
546        assert!(result.is_err());
547    }
548
549    #[test]
550    fn test_public_key_aip80_roundtrip() {
551        let private_key = Ed25519PrivateKey::generate();
552        let public_key = private_key.public_key();
553        let aip80 = public_key.to_aip80();
554
555        // Should have correct prefix
556        assert!(aip80.starts_with("ed25519-pub-0x"));
557
558        // Should roundtrip correctly
559        let restored = Ed25519PublicKey::from_aip80(&aip80).unwrap();
560        assert_eq!(public_key.to_bytes(), restored.to_bytes());
561    }
562
563    #[test]
564    fn test_public_key_aip80_invalid_prefix() {
565        let result = Ed25519PublicKey::from_aip80("secp256k1-pub-0x01");
566        assert!(result.is_err());
567    }
568
569    #[test]
570    fn test_invalid_private_key_bytes_length() {
571        let bytes = vec![0u8; 16]; // Wrong length
572        let result = Ed25519PrivateKey::from_bytes(&bytes);
573        assert!(result.is_err());
574    }
575
576    #[test]
577    fn test_invalid_public_key_bytes_length() {
578        let bytes = vec![0u8; 16]; // Wrong length
579        let result = Ed25519PublicKey::from_bytes(&bytes);
580        assert!(result.is_err());
581    }
582
583    #[test]
584    fn test_invalid_signature_bytes_length() {
585        let bytes = vec![0u8; 32]; // Wrong length
586        let result = Ed25519Signature::from_bytes(&bytes);
587        assert!(result.is_err());
588    }
589
590    #[test]
591    fn test_public_key_from_hex_roundtrip() {
592        let private_key = Ed25519PrivateKey::generate();
593        let public_key = private_key.public_key();
594        let hex = public_key.to_hex();
595        let restored = Ed25519PublicKey::from_hex(&hex).unwrap();
596        assert_eq!(public_key, restored);
597    }
598
599    #[test]
600    fn test_signature_from_hex_roundtrip() {
601        let private_key = Ed25519PrivateKey::generate();
602        let signature = private_key.sign(b"test");
603        let hex = signature.to_hex();
604        let restored = Ed25519Signature::from_hex(&hex).unwrap();
605        assert_eq!(signature.to_bytes(), restored.to_bytes());
606    }
607
608    #[test]
609    fn test_public_key_bytes_roundtrip() {
610        let private_key = Ed25519PrivateKey::generate();
611        let public_key = private_key.public_key();
612        let bytes = public_key.to_bytes();
613        let restored = Ed25519PublicKey::from_bytes(&bytes).unwrap();
614        assert_eq!(public_key, restored);
615    }
616
617    #[test]
618    fn test_signature_bytes_roundtrip() {
619        let private_key = Ed25519PrivateKey::generate();
620        let signature = private_key.sign(b"test");
621        let bytes = signature.to_bytes();
622        let restored = Ed25519Signature::from_bytes(&bytes).unwrap();
623        assert_eq!(signature.to_bytes(), restored.to_bytes());
624    }
625
626    #[test]
627    fn test_private_key_debug() {
628        let private_key = Ed25519PrivateKey::generate();
629        let debug = format!("{private_key:?}");
630        assert!(debug.contains("REDACTED"));
631        assert!(!debug.contains(&private_key.to_hex()));
632    }
633
634    #[test]
635    fn test_public_key_debug() {
636        let private_key = Ed25519PrivateKey::generate();
637        let public_key = private_key.public_key();
638        let debug = format!("{public_key:?}");
639        assert!(debug.contains("Ed25519PublicKey"));
640    }
641
642    #[test]
643    fn test_public_key_display() {
644        let private_key = Ed25519PrivateKey::generate();
645        let public_key = private_key.public_key();
646        let display = format!("{public_key}");
647        assert!(display.starts_with("0x"));
648    }
649
650    #[test]
651    fn test_signature_debug() {
652        let private_key = Ed25519PrivateKey::generate();
653        let signature = private_key.sign(b"test");
654        let debug = format!("{signature:?}");
655        assert!(debug.contains("Ed25519Signature"));
656    }
657
658    #[test]
659    fn test_signature_display() {
660        let private_key = Ed25519PrivateKey::generate();
661        let signature = private_key.sign(b"test");
662        let display = format!("{signature}");
663        assert!(display.starts_with("0x"));
664    }
665
666    #[test]
667    fn test_signer_trait() {
668        use crate::crypto::traits::Signer;
669
670        let private_key = Ed25519PrivateKey::generate();
671        let message = b"trait test";
672
673        let signature = Signer::sign(&private_key, message);
674        let public_key = Signer::public_key(&private_key);
675
676        assert!(public_key.verify(message, &signature).is_ok());
677    }
678
679    #[test]
680    fn test_verifier_trait() {
681        use crate::crypto::traits::Verifier;
682
683        let private_key = Ed25519PrivateKey::generate();
684        let public_key = private_key.public_key();
685        let message = b"verifier test";
686        let signature = private_key.sign(message);
687
688        assert!(Verifier::verify(&public_key, message, &signature).is_ok());
689    }
690
691    #[test]
692    fn test_public_key_trait() {
693        use crate::crypto::traits::PublicKey;
694
695        let private_key = Ed25519PrivateKey::generate();
696        let public_key = private_key.public_key();
697        let bytes = PublicKey::to_bytes(&public_key);
698        let restored = Ed25519PublicKey::from_bytes(&bytes).unwrap();
699        assert_eq!(public_key, restored);
700    }
701
702    #[test]
703    fn test_signature_trait() {
704        use crate::crypto::traits::Signature;
705
706        let private_key = Ed25519PrivateKey::generate();
707        let signature = private_key.sign(b"test");
708        let bytes = Signature::to_bytes(&signature);
709        let restored = Ed25519Signature::from_bytes(&bytes).unwrap();
710        assert_eq!(signature.to_bytes(), restored.to_bytes());
711    }
712
713    #[test]
714    fn test_authentication_key() {
715        let private_key = Ed25519PrivateKey::generate();
716        let public_key = private_key.public_key();
717        let auth_key = public_key.to_authentication_key();
718        assert_eq!(auth_key.len(), 32);
719    }
720
721    #[test]
722    fn test_signature_json_serialization() {
723        let private_key = Ed25519PrivateKey::generate();
724        let signature = private_key.sign(b"test");
725
726        let json = serde_json::to_string(&signature).unwrap();
727        let restored: Ed25519Signature = serde_json::from_str(&json).unwrap();
728        assert_eq!(signature.to_bytes(), restored.to_bytes());
729    }
730
731    #[test]
732    fn test_private_key_clone() {
733        let private_key = Ed25519PrivateKey::generate();
734        let cloned = private_key.clone();
735        assert_eq!(private_key.to_bytes(), cloned.to_bytes());
736    }
737
738    #[test]
739    fn test_public_key_equality() {
740        let private_key = Ed25519PrivateKey::generate();
741        let pk1 = private_key.public_key();
742        let pk2 = private_key.public_key();
743        assert_eq!(pk1, pk2);
744
745        let different = Ed25519PrivateKey::generate().public_key();
746        assert_ne!(pk1, different);
747    }
748}
aptos_sdk/crypto/ed25519.rs

aptos_sdk/crypto/
ed25519.rs
