feat(identity): implement protobuf encoding for all key types

identity/src/ecdsa.rs

@@ -34,7 +34,7 @@ use p256::{
 use void::Void;
 
 /// An ECDSA keypair.
-#[derive(Clone)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct Keypair {
     secret: SecretKey,
     public: PublicKey,
@@ -60,6 +60,11 @@ impl Keypair {
     pub fn secret(&self) -> &SecretKey {
         &self.secret
     }
+
+    pub fn try_from_bytes(pk:impl AsRef<[u8]>) -> Result<Keypair,DecodingError>{
+        let secret_key = SecretKey::try_from_bytes(pk)?;
+        Ok(secret_key.into())
+    }
 }
 
 impl fmt::Debug for Keypair {
@@ -86,7 +91,7 @@ impl From<Keypair> for SecretKey {
 }
 
 /// An ECDSA secret key.
-#[derive(Clone)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct SecretKey(SigningKey);
 
 impl SecretKey {
@@ -108,8 +113,8 @@ impl SecretKey {
     }
 
     /// Decode a secret key from a byte buffer.
-    pub fn from_bytes(buf: &[u8]) -> Result<Self, DecodingError> {
-        SigningKey::from_bytes(buf)
+    pub fn try_from_bytes(buf: impl AsRef<[u8]>) -> Result<Self, DecodingError> {
+        SigningKey::from_bytes(buf.as_ref())
             .map_err(|err| DecodingError::failed_to_parse("ecdsa p256 secret key", err))
             .map(SecretKey)
     }
@@ -136,7 +141,7 @@ impl PublicKey {
     }
 
     /// Decode a public key from a byte buffer without compression.
-    pub fn from_bytes(k: &[u8]) -> Result<PublicKey, DecodingError> {
+    pub fn try_from_bytes(k: &[u8]) -> Result<PublicKey, DecodingError> {
         let enc_pt = EncodedPoint::from_bytes(k)
             .map_err(|e| DecodingError::failed_to_parse("ecdsa p256 encoded point", e))?;
 
@@ -157,11 +162,11 @@ impl PublicKey {
     }
 
     /// Decode a public key into a DER encoded byte buffer as defined by SEC1 standard.
-    pub fn decode_der(k: &[u8]) -> Result<PublicKey, DecodingError> {
+    pub fn try_decode_der(k: &[u8]) -> Result<PublicKey, DecodingError> {
         let buf = Self::del_asn1_header(k).ok_or_else(|| {
             DecodingError::failed_to_parse::<Void, _>("ASN.1-encoded ecdsa p256 public key", None)
         })?;
-        Self::from_bytes(buf)
+        Self::try_from_bytes(buf)
     }
 
     // ecPublicKey (ANSI X9.62 public key type) OID: 1.2.840.10045.2.1
@@ -258,4 +263,11 @@ mod tests {
         let invalid_msg = "h3ll0 w0rld".as_bytes();
         assert!(!pk.verify(invalid_msg, &sig));
     }
+
+    #[test]
+    fn serialize_deserialize(){
+        let pair = Keypair::generate();
+        let bytes_secret = pair.secret().to_bytes();
+        assert_eq!(Keypair::try_from_bytes(bytes_secret).unwrap(),pair)
+    }
 }

identity/src/ed25519.rs

@@ -49,7 +49,7 @@ impl Keypair {
     /// produced by [`Keypair::encode`], zeroing the input on success.
     ///
     /// Note that this binary format is the same as `ed25519_dalek`'s and `ed25519_zebra`'s.
-    pub fn decode(kp: &mut [u8]) -> Result<Keypair, DecodingError> {
+    pub fn try_decode(kp: &mut [u8]) -> Result<Keypair, DecodingError> {
         ed25519::Keypair::from_bytes(kp)
             .map(|k| {
                 kp.zeroize();
@@ -70,7 +70,7 @@ impl Keypair {
 
     /// Get the secret key of this keypair.
     pub fn secret(&self) -> SecretKey {
-        SecretKey::from_bytes(&mut self.0.secret.to_bytes())
+        SecretKey::try_from_bytes(&mut self.0.secret.to_bytes())
             .expect("ed25519::SecretKey::from_bytes(to_bytes(k)) != k")
     }
 }
@@ -86,7 +86,7 @@ impl fmt::Debug for Keypair {
 impl Clone for Keypair {
     fn clone(&self) -> Keypair {
         let mut sk_bytes = self.0.secret.to_bytes();
-        let secret = SecretKey::from_bytes(&mut sk_bytes)
+        let secret = SecretKey::try_from_bytes(&mut sk_bytes)
             .expect("ed25519::SecretKey::from_bytes(to_bytes(k)) != k")
             .0;
         let public = ed25519::PublicKey::from_bytes(&self.0.public.to_bytes())
@@ -167,7 +167,7 @@ impl PublicKey {
     }
 
     /// Decode a public key from a byte array as produced by `encode`.
-    pub fn decode(k: &[u8]) -> Result<PublicKey, DecodingError> {
+    pub fn try_decode(k: &[u8]) -> Result<PublicKey, DecodingError> {
         ed25519::PublicKey::from_bytes(k)
             .map_err(|e| DecodingError::failed_to_parse("Ed25519 public key", e))
             .map(PublicKey)
@@ -187,7 +187,7 @@ impl AsRef<[u8]> for SecretKey {
 impl Clone for SecretKey {
     fn clone(&self) -> SecretKey {
         let mut sk_bytes = self.0.to_bytes();
-        Self::from_bytes(&mut sk_bytes).expect("ed25519::SecretKey::from_bytes(to_bytes(k)) != k")
+        Self::try_from_bytes(&mut sk_bytes).expect("ed25519::SecretKey::from_bytes(to_bytes(k)) != k")
     }
 }
 
@@ -212,7 +212,7 @@ impl SecretKey {
     /// Create an Ed25519 secret key from a byte slice, zeroing the input on success.
     /// If the bytes do not constitute a valid Ed25519 secret key, an error is
     /// returned.
-    pub fn from_bytes(mut sk_bytes: impl AsMut<[u8]>) -> Result<SecretKey, DecodingError> {
+    pub fn try_from_bytes(mut sk_bytes: impl AsMut<[u8]>) -> Result<SecretKey, DecodingError> {
         let sk_bytes = sk_bytes.as_mut();
         let secret = ed25519::SecretKey::from_bytes(&*sk_bytes)
             .map_err(|e| DecodingError::failed_to_parse("Ed25519 secret key", e))?;
@@ -235,7 +235,7 @@ mod tests {
         fn prop() -> bool {
             let kp1 = Keypair::generate();
             let mut kp1_enc = kp1.encode();
-            let kp2 = Keypair::decode(&mut kp1_enc).unwrap();
+            let kp2 = Keypair::try_decode(&mut kp1_enc).unwrap();
             eq_keypairs(&kp1, &kp2) && kp1_enc.iter().all(|b| *b == 0)
         }
         QuickCheck::new().tests(10).quickcheck(prop as fn() -> _);
@@ -246,7 +246,7 @@ mod tests {
         fn prop() -> bool {
             let kp1 = Keypair::generate();
             let mut sk = kp1.0.secret.to_bytes();
-            let kp2 = Keypair::from(SecretKey::from_bytes(&mut sk).unwrap());
+            let kp2 = Keypair::from(SecretKey::try_from_bytes(&mut sk).unwrap());
             eq_keypairs(&kp1, &kp2) && sk == [0u8; 32]
         }
         QuickCheck::new().tests(10).quickcheck(prop as fn() -> _);

identity/src/error.rs

@@ -31,13 +31,6 @@ pub struct DecodingError {
 }
 
 impl DecodingError {
-    #[cfg(not(all(
-        feature = "ecdsa",
-        feature = "rsa",
-        feature = "secp256k1",
-        feature = "ed25519",
-        not(target_arch = "wasm32")
-    )))]
     pub(crate) fn missing_feature(feature_name: &'static str) -> Self {
         Self {
             msg: format!("cargo feature `{feature_name}` is not enabled"),
@@ -80,25 +73,6 @@ impl DecodingError {
             source: Some(Box::new(source)),
         }
     }
-
-    pub(crate) fn decoding_unsupported(key_type: &'static str) -> Self {
-        Self {
-            msg: format!("decoding {key_type} key from Protobuf is unsupported"),
-            source: None,
-        }
-    }
-
-    #[cfg(any(
-        all(feature = "rsa", not(target_arch = "wasm32")),
-        feature = "secp256k1",
-        feature = "ecdsa"
-    ))]
-    pub(crate) fn encoding_unsupported(key_type: &'static str) -> Self {
-        Self {
-            msg: format!("encoding {key_type} key to Protobuf is unsupported"),
-            source: None,
-        }
-    }
 }
 
 impl fmt::Display for DecodingError {
@@ -123,18 +97,10 @@ pub struct SigningError {
 /// An error during encoding of key material.
 impl SigningError {
     #[cfg(any(feature = "secp256k1", feature = "rsa"))]
-    pub(crate) fn new<S: ToString>(msg: S) -> Self {
+    pub(crate) fn new<S: ToString>(msg: S, source: Option<Box<dyn Error + Send + Sync>>) -> Self {
         Self {
             msg: msg.to_string(),
-            source: None,
-        }
-    }
-
-    #[cfg(feature = "rsa")]
-    pub(crate) fn source(self, source: impl Error + Send + Sync + 'static) -> Self {
-        Self {
-            source: Some(Box::new(source)),
-            ..self
+            source,
         }
     }
 }