hyprstream_p2p/crypto/
ed25519.rs1use 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#[derive(Debug)]
11pub struct Ed25519KeyPair {
12 signing_key: SigningKey,
13 verifying_key: VerifyingKey,
14}
15
16#[derive(Debug, Serialize, Deserialize)]
18pub struct KeyData {
19 pub pub_key: String,
20 pub priv_key: String,
21}
22
23impl Ed25519KeyPair {
24 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 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 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 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 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 pub fn public_key_bytes(&self) -> &[u8] {
85 self.verifying_key.as_bytes()
86 }
87
88 pub fn secret_key_bytes(&self) -> &[u8] {
90 self.signing_key.as_bytes()
91 }
92
93 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 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 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 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 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 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); 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 keypair1.save_to_file(temp_file.path())?;
199
200 let keypair2 = Ed25519KeyPair::load_from_file(temp_file.path())?;
202
203 assert_eq!(keypair1.public_key_bytes(), keypair2.public_key_bytes());
205 assert_eq!(keypair1.secret_key_bytes(), keypair2.secret_key_bytes());
206
207 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 let keypair1 = Ed25519KeyPair::load_or_create(&key_path)?;
224
225 let keypair2 = Ed25519KeyPair::load_or_create(&key_path)?;
227
228 assert_eq!(keypair1.public_key_bytes(), keypair2.public_key_bytes());
229 Ok(())
230 }
231}