1use cryptraits::convert::{FromBytes, Len, ToVec};
3use cryptraits::signature::{Sign, Verify};
4use cryptraits::{
5 key::{PublicKey as PublicKeyTrait, SecretKey as SecretKeyTrait},
6 signature::Signature as SignatureTrait,
7};
8use ed25519_dalek::{Signer, Verifier};
9
10#[cfg(feature = "serde_derive")]
11use serde::de::{Error, SeqAccess, Unexpected, Visitor};
12
13#[cfg(feature = "serde_derive")]
14use serde::{Deserialize, Serialize};
15
16#[cfg(feature = "std")]
17use std::fmt::Debug;
18
19use core::hash::Hash;
20
21#[cfg(not(feature = "std"))]
22use alloc::fmt::Display;
23
24#[cfg(feature = "std")]
25use std::fmt::Display;
26
27use zeroize::Zeroize;
28
29#[cfg(not(feature = "std"))]
30use alloc::fmt::Debug;
31
32#[cfg(not(feature = "std"))]
33use alloc::vec::Vec;
34
35use crate::errors::{KeyPairError, SignatureError};
36
37pub type KeyPair = super::KeyPair<SecretKey>;
38
39#[cfg(feature = "serde_derive")]
40impl Serialize for KeyPair {
41 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
42 where
43 S: serde::Serializer,
44 {
45 self.to_vec().serialize(serializer)
46 }
47}
48
49#[cfg(feature = "serde_derive")]
50impl<'de> Deserialize<'de> for KeyPair {
51 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
52 where
53 D: serde::Deserializer<'de>,
54 {
55 struct KeyPairVisitor;
56
57 impl<'de> Visitor<'de> for KeyPairVisitor {
58 type Value = KeyPair;
59
60 fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
61 formatter.write_str("Bytes")
62 }
63
64 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
65 where
66 A: SeqAccess<'de>,
67 {
68 let mut bytes = Vec::new();
69
70 while let Some(byte) = seq.next_element::<u8>()? {
71 bytes.push(byte);
72 }
73
74 let keypair = KeyPair::from_bytes(&bytes)
75 .or(Err(Error::invalid_type(Unexpected::Seq, &self)))?;
76
77 Ok(keypair)
78 }
79 }
80
81 deserializer.deserialize_byte_buf(KeyPairVisitor)
82 }
83}
84
85#[derive(Clone, Zeroize, PartialEq)]
86#[zeroize(drop)]
87pub struct SecretKey(ed25519_dalek::SecretKey);
88
89impl Debug for SecretKey {
90 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
91 f.debug_tuple("SecretKey").field(&self.to_vec()).finish()
92 }
93}
94
95impl SecretKeyTrait for SecretKey {
96 type PK = PublicKey;
97
98 fn to_public(&self) -> Self::PK {
99 let signing_key = ed25519_dalek::SigningKey::from_bytes(&self.0);
100 PublicKey(signing_key.verifying_key())
101 }
102}
103
104impl Len for SecretKey {
105 const LEN: usize = 32;
106}
107
108impl FromBytes for SecretKey {
109 type E = KeyPairError;
110
111 fn from_bytes(bytes: &[u8]) -> Result<Self, Self::E>
112 where
113 Self: Sized,
114 {
115 let mut secret = [0; 32];
116 secret.copy_from_slice(&bytes[..32]);
117
118 Ok(Self(secret))
119 }
120}
121
122impl ToVec for SecretKey {
123 fn to_vec(&self) -> Vec<u8>
124 where
125 Self: Sized,
126 {
127 self.0.to_vec()
128 }
129}
130
131impl Sign for SecretKey {
132 type SIG = Signature;
133
134 fn sign(&self, data: &[u8]) -> Self::SIG
135 where
136 Self: Sized,
137 {
138 let signing_key = ed25519_dalek::SigningKey::from_bytes(&self.0);
139 Signature(signing_key.sign(data))
140 }
141}
142
143#[cfg(feature = "serde_derive")]
144impl Serialize for SecretKey {
145 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
146 where
147 S: serde::Serializer,
148 {
149 self.to_vec().serialize(serializer)
150 }
151}
152
153#[cfg(feature = "serde_derive")]
154impl<'de> Deserialize<'de> for SecretKey {
155 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
156 where
157 D: serde::Deserializer<'de>,
158 {
159 struct SecretKeyVisitor;
160
161 impl<'de> Visitor<'de> for SecretKeyVisitor {
162 type Value = SecretKey;
163
164 fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
165 formatter.write_str("Bytes")
166 }
167
168 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
169 where
170 A: SeqAccess<'de>,
171 {
172 let mut bytes = Vec::new();
173
174 while let Some(byte) = seq.next_element::<u8>()? {
175 bytes.push(byte);
176 }
177
178 let secret = SecretKey::from_bytes(&bytes)
179 .or(Err(Error::invalid_type(Unexpected::Seq, &self)))?;
180
181 Ok(secret)
182 }
183 }
184
185 deserializer.deserialize_byte_buf(SecretKeyVisitor)
186 }
187}
188
189#[derive(Clone, Copy, Eq, Zeroize)]
190pub struct PublicKey(#[zeroize(skip)] ed25519_dalek::VerifyingKey);
191
192impl Debug for PublicKey {
193 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
194 f.debug_tuple("PublicKey")
195 .field(&hex::encode(self.to_vec()))
196 .finish()
197 }
198}
199
200impl PartialEq for PublicKey {
201 fn eq(&self, other: &Self) -> bool {
202 self.0 == other.0
203 }
204}
205
206impl Hash for PublicKey {
207 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
208 state.write(self.0.as_bytes());
209 }
210}
211
212impl PublicKeyTrait for PublicKey {
213 fn as_bytes(&self) -> &[u8] {
214 self.0.as_bytes()
215 }
216}
217
218impl Display for PublicKey {
219 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
220 f.write_str(&hex::encode(self.to_vec()))
221 }
222}
223
224impl Len for PublicKey {
225 const LEN: usize = 32;
226}
227
228impl FromBytes for PublicKey {
229 type E = KeyPairError;
230
231 fn from_bytes(bytes: &[u8]) -> Result<Self, Self::E>
232 where
233 Self: Sized,
234 {
235 if bytes.len() != 32 {
236 return Err(KeyPairError::BytesLengthError);
237 }
238
239 let mut public_bytes = [0; 32];
240 public_bytes.copy_from_slice(bytes);
241
242 let public = ed25519_dalek::VerifyingKey::from_bytes(&public_bytes)?;
243 Ok(Self(public))
244 }
245}
246
247impl ToVec for PublicKey {
248 fn to_vec(&self) -> Vec<u8>
249 where
250 Self: Sized,
251 {
252 Vec::from(self.0.to_bytes())
253 }
254}
255
256impl Verify for PublicKey {
257 type E = SignatureError;
258 type SIG = Signature;
259
260 fn verify(&self, data: &[u8], signature: &Self::SIG) -> Result<(), Self::E> {
261 self.0
262 .verify(data, &signature.0)
263 .or(Err(SignatureError::EquationFalse))
264 }
265}
266
267#[cfg(feature = "serde_derive")]
268impl Serialize for PublicKey {
269 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
270 where
271 S: serde::Serializer,
272 {
273 self.to_vec().serialize(serializer)
274 }
275}
276
277#[cfg(feature = "serde_derive")]
278impl<'de> Deserialize<'de> for PublicKey {
279 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
280 where
281 D: serde::Deserializer<'de>,
282 {
283 struct PublicKeyVisitor;
284
285 impl<'de> Visitor<'de> for PublicKeyVisitor {
286 type Value = PublicKey;
287
288 fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
289 formatter.write_str("Bytes")
290 }
291
292 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
293 where
294 A: SeqAccess<'de>,
295 {
296 let mut bytes = Vec::new();
297
298 while let Some(byte) = seq.next_element::<u8>()? {
299 bytes.push(byte);
300 }
301
302 let public = PublicKey::from_bytes(&bytes)
303 .or(Err(Error::invalid_type(Unexpected::Seq, &self)))?;
304
305 Ok(public)
306 }
307 }
308
309 deserializer.deserialize_byte_buf(PublicKeyVisitor)
310 }
311}
312
313#[derive(Debug, Clone, Copy, PartialEq)]
314pub struct Signature(ed25519_dalek::Signature);
315impl SignatureTrait for Signature {}
316
317impl Len for Signature {
318 const LEN: usize = 64;
319}
320
321impl FromBytes for Signature {
322 type E = SignatureError;
323
324 fn from_bytes(bytes: &[u8]) -> Result<Self, Self::E>
325 where
326 Self: Sized,
327 {
328 let signature = ed25519_dalek::Signature::from_slice(bytes)?;
329 Ok(Self(signature))
330 }
331}
332
333impl ToVec for Signature {
334 fn to_vec(&self) -> Vec<u8>
335 where
336 Self: Sized,
337 {
338 Vec::from(self.0.to_bytes())
339 }
340}
341#[cfg(test)]
342mod tests {
343 use crate::{
344 errors::SignatureError,
345 key::{ed25519::KeyPair, x25519_ristretto},
346 };
347 use cryptraits::{
348 convert::{FromBytes, ToVec},
349 key::{Generate, KeyPair as _},
350 signature::{Sign, Verify},
351 };
352
353 use super::SecretKey;
354
355 const ALICE: [u8; 64] = [
356 24, 96, 63, 231, 236, 136, 164, 225, 105, 202, 11, 198, 122, 20, 82, 211, 7, 123, 242, 95,
357 196, 12, 125, 239, 30, 213, 142, 152, 44, 190, 208, 114, 23, 48, 153, 209, 41, 119, 171,
358 75, 133, 143, 182, 126, 166, 183, 13, 200, 228, 46, 12, 196, 74, 33, 172, 184, 76, 85, 46,
359 248, 175, 115, 126, 18,
360 ];
361
362 const BOB: [u8; 64] = [
363 56, 36, 219, 22, 94, 68, 246, 204, 121, 18, 213, 150, 205, 112, 138, 10, 55, 15, 30, 205,
364 107, 246, 104, 215, 142, 131, 242, 58, 67, 51, 47, 52, 158, 148, 186, 206, 11, 99, 185,
365 148, 160, 154, 166, 185, 189, 173, 44, 238, 186, 13, 222, 208, 67, 192, 239, 191, 83, 52,
366 155, 51, 241, 231, 218, 51,
367 ];
368
369 #[test]
370 fn key_construct_from_bytes() {
371 assert!(KeyPair::from_bytes(&ALICE).is_ok());
372 }
373
374 #[test]
375 fn key_to_vec() {
376 assert_eq!(&KeyPair::from_bytes(&ALICE).unwrap().to_vec(), &ALICE);
377 }
378
379 #[test]
380 fn test_secret_key_partial_eq() {
381 let ristretto_keypair = x25519_ristretto::KeyPair::generate();
382 let secret_bytes = ristretto_keypair.secret.to_ed25519_bytes();
383
384 let alice = SecretKey::from_bytes(&secret_bytes).unwrap();
385 let bob = SecretKey::from_bytes(&secret_bytes).unwrap();
386
387 assert_eq!(alice, bob);
388 }
389
390 #[test]
391 fn key_should_verify_signature() {
392 const MSG: &[u8] = b"sw0rdfish";
393
394 let alice_keypair = KeyPair::from_bytes(&ALICE).unwrap();
395 let bob_keypair = KeyPair::from_bytes(&BOB).unwrap();
396 let alice_public = alice_keypair.to_public();
397
398 let signature = alice_keypair.sign(MSG);
399
400 assert_eq!(
401 bob_keypair.verify(MSG, &signature),
402 Err(SignatureError::EquationFalse)
403 );
404
405 assert!(alice_public.verify(MSG, &signature).is_ok());
406 }
407
408 #[cfg(feature = "serde_derive")]
409 #[test]
410 fn test_secret_key_serde() {
411 use serde_test::{assert_tokens, Token};
412
413 let secret = KeyPair::from_bytes(&ALICE).unwrap().secret().clone();
414
415 let mut tokens = Vec::new();
416
417 tokens.push(Token::Seq { len: Some(32) });
418
419 for byte in secret.to_vec().into_iter() {
420 tokens.push(Token::U8(byte));
421 }
422
423 tokens.push(Token::SeqEnd);
424
425 assert_tokens(&secret, &tokens);
426 }
427
428 #[cfg(feature = "serde_derive")]
429 #[test]
430 fn test_public_key_serde() {
431 use serde_test::{assert_tokens, Token};
432
433 let public = KeyPair::from_bytes(&ALICE).unwrap().to_public();
434
435 let mut tokens = Vec::new();
436
437 tokens.push(Token::Seq { len: Some(32) });
438
439 for byte in public.to_vec().into_iter() {
440 tokens.push(Token::U8(byte));
441 }
442
443 tokens.push(Token::SeqEnd);
444
445 assert_tokens(&public, &tokens);
446 }
447
448 #[cfg(feature = "serde_derive")]
449 #[test]
450 fn test_keypair_serde() {
451 use serde_test::{assert_tokens, Token};
452
453 let keypair = KeyPair::from_bytes(&ALICE).unwrap();
454
455 let mut tokens = Vec::new();
456
457 tokens.push(Token::Seq { len: Some(64) });
458
459 for byte in keypair.to_vec().into_iter() {
460 tokens.push(Token::U8(byte));
461 }
462
463 tokens.push(Token::SeqEnd);
464
465 assert_tokens(&keypair, &tokens);
466 }
467}