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

core/src/signed_envelope.rs

@@ -76,7 +76,7 @@ impl SignedEnvelope {
         use quick_protobuf::MessageWrite;
 
         let envelope = proto::Envelope {
-            public_key: self.key.to_protobuf_encoding(),
+            public_key: self.key.try_to_protobuf_encoding().unwrap(),
             payload_type: self.payload_type,
             payload: self.payload,
             signature: self.signature,
@@ -101,7 +101,7 @@ impl SignedEnvelope {
             proto::Envelope::from_reader(&mut reader, bytes).map_err(DecodeError::from)?;
 
         Ok(Self {
-            key: PublicKey::from_protobuf_encoding(&envelope.public_key)?,
+            key: PublicKey::try_from_protobuf_encoding(&envelope.public_key)?,
             payload_type: envelope.payload_type.to_vec(),
             payload: envelope.payload.to_vec(),
             signature: envelope.signature.to_vec(),

examples/dcutr/src/main.rs

@@ -281,5 +281,5 @@ fn generate_ed25519(secret_key_seed: u8) -> identity::Keypair {
     let mut bytes = [0u8; 32];
     bytes[0] = secret_key_seed;
 
-    identity::Keypair::ed25519_from_bytes(bytes).expect("only errors on wrong length")
+    identity::Keypair::try_from_bytes_ed25519(bytes).expect("only errors on wrong length")
 }

examples/file-sharing/src/network.rs

@@ -39,7 +39,7 @@ pub async fn new(
         Some(seed) => {
             let mut bytes = [0u8; 32];
             bytes[0] = seed;
-            identity::Keypair::ed25519_from_bytes(bytes).unwrap()
+            identity::Keypair::try_from_bytes_ed25519(bytes).unwrap()
         }
         None => identity::Keypair::generate_ed25519(),
     };

examples/relay-server/src/main.rs

@@ -103,7 +103,7 @@ fn generate_ed25519(secret_key_seed: u8) -> identity::Keypair {
     let mut bytes = [0u8; 32];
     bytes[0] = secret_key_seed;
 
-    identity::Keypair::ed25519_from_bytes(bytes).expect("only errors on wrong length")
+    identity::Keypair::try_from_bytes_ed25519(bytes).expect("only errors on wrong length")
 }
 
 #[derive(Debug, Parser)]

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,13 @@ impl Keypair {
     pub fn secret(&self) -> &SecretKey {
         &self.secret
     }
+
+    /// Try to parse an secret key byte array into a ECDSA `SecretKey`
+    /// and promote it into a `Keypair`.
+    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 +93,7 @@ impl From<Keypair> for SecretKey {
 }
 
 /// An ECDSA secret key.
-#[derive(Clone)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct SecretKey(SigningKey);
 
 impl SecretKey {
@@ -102,14 +109,14 @@ impl SecretKey {
         signature.as_bytes().to_owned()
     }
 
-    /// Encode a secret key into a byte buffer.
+    /// Convert a secret key into a byte buffer.
     pub fn to_bytes(&self) -> Vec<u8> {
         self.0.to_bytes().to_vec()
     }
 
-    /// Decode a secret key from a byte buffer.
-    pub fn from_bytes(buf: &[u8]) -> Result<Self, DecodingError> {
-        SigningKey::from_bytes(buf)
+    /// Try to parse a secret key from a byte buffer.
+    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 +143,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 +164,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 +265,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

@@ -45,11 +45,11 @@ impl Keypair {
         self.0.to_bytes()
     }
 
-    /// Decode a keypair from the [binary format](https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.5)
+    /// Try to decode a keypair from the [binary format](https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.5)
     /// 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())
@@ -166,8 +166,8 @@ impl PublicKey {
         self.0.to_bytes()
     }
 
-    /// Decode a public key from a byte array as produced by `encode`.
-    pub fn decode(k: &[u8]) -> Result<PublicKey, DecodingError> {
+    /// Try to decode a public key from a byte array as produced by `encode`.
+    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,8 @@ 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")
     }
 }
 
@@ -209,10 +210,10 @@ impl SecretKey {
         )
     }
 
-    /// Create an Ed25519 secret key from a byte slice, zeroing the input on success.
+    /// Try to 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 +236,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 +247,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,7 @@ pub struct DecodingError {
 }
 
 impl DecodingError {
-    #[cfg(not(all(
-        feature = "ecdsa",
-        feature = "rsa",
-        feature = "secp256k1",
-        feature = "ed25519",
-        not(target_arch = "wasm32")
-    )))]
+    /// The given feature is supported but not enabled at compile time.
     pub(crate) fn missing_feature(feature_name: &'static str) -> Self {
         Self {
             msg: format!("cargo feature `{feature_name}` is not enabled"),
@@ -51,6 +45,7 @@ impl DecodingError {
         feature = "ed25519",
         feature = "rsa"
     ))]
+    /// Error occurred when parsing one type into another.
     pub(crate) fn failed_to_parse<E, S>(what: &'static str, source: S) -> Self
     where
         E: Error + Send + Sync + 'static,
@@ -80,25 +75,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 +99,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,
         }
     }
 }