Skip to main content

hyprstream_p2p/crypto/
ed25519.rs

1//! Ed25519 cryptographic operations for GitTorrent
2
3use crate::{types::MutableKey, Error, Result};
4use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey};
5use rand::rngs::OsRng;
6use serde::{Deserialize, Serialize};
7use std::path::Path;
8
9/// Ed25519 keypair for GitTorrent mutable keys
10#[derive(Debug)]
11pub struct Ed25519KeyPair {
12    signing_key: SigningKey,
13    verifying_key: VerifyingKey,
14}
15
16/// Serializable key data for storage
17#[derive(Debug, Serialize, Deserialize)]
18pub struct KeyData {
19    pub pub_key: String,
20    pub priv_key: String,
21}
22
23impl Ed25519KeyPair {
24    /// Generate a new random keypair
25    pub fn generate() -> Result<Self> {
26        let signing_key = SigningKey::generate(&mut OsRng);
27        let verifying_key = signing_key.verifying_key();
28        Ok(Ed25519KeyPair {
29            signing_key,
30            verifying_key,
31        })
32    }
33
34    /// Create keypair from existing key data
35    pub fn from_key_data(key_data: &KeyData) -> Result<Self> {
36        let secret_bytes = hex::decode(&key_data.priv_key)?;
37        if secret_bytes.len() != 32 {
38            return Err(Error::crypto("Secret key must be 32 bytes"));
39        }
40
41        let mut secret_array = [0u8; 32];
42        secret_array.copy_from_slice(&secret_bytes);
43
44        let signing_key = SigningKey::from_bytes(&secret_array);
45        let verifying_key = signing_key.verifying_key();
46
47        Ok(Ed25519KeyPair {
48            signing_key,
49            verifying_key,
50        })
51    }
52
53    /// Load keypair from file, creating if it doesn't exist
54    pub fn load_or_create<P: AsRef<Path>>(path: P) -> Result<Self> {
55        if path.as_ref().exists() {
56            Self::load_from_file(path)
57        } else {
58            let keypair = Self::generate()?;
59            keypair.save_to_file(path)?;
60            Ok(keypair)
61        }
62    }
63
64    /// Load keypair from file
65    pub fn load_from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
66        let content = std::fs::read_to_string(path)?;
67        let key_data: KeyData = serde_json::from_str(&content)?;
68        Self::from_key_data(&key_data)
69    }
70
71    /// Save keypair to file
72    pub fn save_to_file<P: AsRef<Path>>(&self, path: P) -> Result<()> {
73        let key_data = KeyData {
74            pub_key: hex::encode(self.verifying_key.as_bytes()),
75            priv_key: hex::encode(self.signing_key.as_bytes()),
76        };
77
78        let content = serde_json::to_string_pretty(&key_data)?;
79        std::fs::write(path, content)?;
80        Ok(())
81    }
82
83    /// Get the public key bytes
84    pub fn public_key_bytes(&self) -> &[u8] {
85        self.verifying_key.as_bytes()
86    }
87
88    /// Get the secret key bytes
89    pub fn secret_key_bytes(&self) -> &[u8] {
90        self.signing_key.as_bytes()
91    }
92
93    /// Get the mutable key (SHA256 of public key)
94    pub fn mutable_key(&self) -> Result<MutableKey> {
95        let hash = crate::crypto::hash::sha256(self.public_key_bytes());
96        MutableKey::new(hex::encode(hash))
97    }
98
99    /// Sign data
100    pub fn sign(&self, data: &[u8]) -> Vec<u8> {
101        let signature = self.signing_key.sign(data);
102        signature.to_bytes().to_vec()
103    }
104
105    /// Verify signature
106    pub fn verify(&self, data: &[u8], signature: &[u8]) -> Result<bool> {
107        if signature.len() != 64 {
108            return Err(Error::crypto("Signature must be 64 bytes"));
109        }
110
111        let mut sig_array = [0u8; 64];
112        sig_array.copy_from_slice(signature);
113        let signature = Signature::from_bytes(&sig_array);
114
115        Ok(self.verifying_key.verify(data, &signature).is_ok())
116    }
117
118    /// Verify signature with a different public key
119    pub fn verify_with_public_key(
120        public_key: &[u8],
121        data: &[u8],
122        signature: &[u8],
123    ) -> Result<bool> {
124        if public_key.len() != 32 {
125            return Err(Error::crypto("Public key must be 32 bytes"));
126        }
127        if signature.len() != 64 {
128            return Err(Error::crypto("Signature must be 64 bytes"));
129        }
130
131        let mut pk_array = [0u8; 32];
132        pk_array.copy_from_slice(public_key);
133        let verifying_key = VerifyingKey::from_bytes(&pk_array)
134            .map_err(|e| Error::crypto(format!("Invalid public key: {e}")))?;
135
136        let mut sig_array = [0u8; 64];
137        sig_array.copy_from_slice(signature);
138        let signature = Signature::from_bytes(&sig_array);
139
140        Ok(verifying_key.verify(data, &signature).is_ok())
141    }
142}
143
144impl Clone for Ed25519KeyPair {
145    fn clone(&self) -> Self {
146        // We need to recreate the keypair since ed25519_dalek keys don't implement Clone
147        // SAFETY: We're recreating from the same keypair's bytes, so this cannot fail
148        let signing_key = SigningKey::from_bytes(&self.signing_key.to_bytes());
149        let verifying_key = signing_key.verifying_key();
150        Self {
151            signing_key,
152            verifying_key,
153        }
154    }
155}
156
157#[cfg(test)]
158mod tests {
159    use super::*;
160    use tempfile::NamedTempFile;
161
162    #[test]
163    fn test_keypair_generation() -> crate::error::Result<()> {
164        let keypair = Ed25519KeyPair::generate()?;
165        assert_eq!(keypair.public_key_bytes().len(), 32);
166        assert_eq!(keypair.secret_key_bytes().len(), 32);
167        Ok(())
168    }
169
170    #[test]
171    fn test_sign_verify() -> crate::error::Result<()> {
172        let keypair = Ed25519KeyPair::generate()?;
173        let data = b"hello world";
174
175        let signature = keypair.sign(data);
176        assert!(keypair.verify(data, &signature)?);
177
178        // Test with different data
179        let bad_data = b"goodbye world";
180        assert!(!keypair.verify(bad_data, &signature)?);
181        Ok(())
182    }
183
184    #[test]
185    fn test_mutable_key() -> crate::error::Result<()> {
186        let keypair = Ed25519KeyPair::generate()?;
187        let mutable_key = keypair.mutable_key()?;
188        assert_eq!(mutable_key.as_str().len(), 64); // SHA256 hex string
189        Ok(())
190    }
191
192    #[test]
193    fn test_save_load() -> std::result::Result<(), Box<dyn std::error::Error>> {
194        let keypair1 = Ed25519KeyPair::generate()?;
195        let temp_file = NamedTempFile::new()?;
196
197        // Save keypair
198        keypair1.save_to_file(temp_file.path())?;
199
200        // Load keypair
201        let keypair2 = Ed25519KeyPair::load_from_file(temp_file.path())?;
202
203        // Should have same keys
204        assert_eq!(keypair1.public_key_bytes(), keypair2.public_key_bytes());
205        assert_eq!(keypair1.secret_key_bytes(), keypair2.secret_key_bytes());
206
207        // Should produce same signatures
208        let data = b"test data";
209        let sig1 = keypair1.sign(data);
210        let sig2 = keypair2.sign(data);
211
212        assert!(keypair1.verify(data, &sig2)?);
213        assert!(keypair2.verify(data, &sig1)?);
214        Ok(())
215    }
216
217    #[test]
218    fn test_load_or_create() -> std::result::Result<(), Box<dyn std::error::Error>> {
219        let temp_dir = tempfile::tempdir()?;
220        let key_path = temp_dir.path().join("test_key.json");
221
222        // Should create new keypair since file doesn't exist
223        let keypair1 = Ed25519KeyPair::load_or_create(&key_path)?;
224
225        // Should load existing keypair since file now exists
226        let keypair2 = Ed25519KeyPair::load_or_create(&key_path)?;
227
228        assert_eq!(keypair1.public_key_bytes(), keypair2.public_key_bytes());
229        Ok(())
230    }
231}