feat(identity): mark sign as infaillible

core/src/signed_envelope.rs

@@ -28,7 +28,7 @@ impl SignedEnvelope {
     ) -> Result<Self, SigningError> {
         let buffer = signature_payload(domain_separation, &payload_type, &payload);
 
-        let signature = key.sign(&buffer)?;
+        let signature = key.sign(&buffer).unwrap();
 
         Ok(Self {
             key: key.public(),

identity/src/keypair.rs

@@ -18,6 +18,8 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
+use std::convert::Infallible;
+
 #[cfg(any(
     feature = "ecdsa",
     feature = "secp256k1",
@@ -55,7 +57,7 @@
 #[cfg(feature = "secp256k1")]
 use crate::secp256k1;
 use crate::{
     error::{DecodingError, SigningError},
     KeyType,
 };
 
@@ -176,12 +178,12 @@
     /// Sign a message using the private key of this keypair, producing
     /// a signature that can be verified using the corresponding public key.
     #[allow(unused_variables)]
-    pub fn sign(&self, msg: &[u8]) -> Result<Vec<u8>, SigningError> {
+    pub fn sign(&self, msg: &[u8]) -> Result<Vec<u8>, Infallible> {
         match self.keypair {
             #[cfg(feature = "ed25519")]
             KeyPairInner::Ed25519(ref pair) => Ok(pair.sign(msg)),
             #[cfg(all(feature = "rsa", not(target_arch = "wasm32")))]
-            KeyPairInner::Rsa(ref pair) => pair.sign(msg),
+            KeyPairInner::Rsa(ref pair) => Ok(pair.sign(msg)),
             #[cfg(feature = "secp256k1")]
             KeyPairInner::Secp256k1(ref pair) => Ok(pair.secret().sign(msg)),
             #[cfg(feature = "ecdsa")]

identity/src/rsa.rs

@@ -75,12 +75,12 @@ impl Keypair {
     }
 
     /// Sign a message with this keypair.
-    pub fn sign(&self, data: &[u8]) -> Result<Vec<u8>, SigningError> {
+    pub fn sign(&self, data: &[u8]) -> Vec<u8> {
         let mut signature = vec![0; self.0.public().modulus_len()];
         let rng = SystemRandom::new();
         match self.0.sign(&RSA_PKCS1_SHA256, &rng, data, &mut signature) {
-            Ok(()) => Ok(signature),
-            Err(e) => Err(SigningError::new("RSA").source(e)),
+            Ok(()) => signature,
+            Err(_) => unreachable!("length of pubkey remain unchanged with immutability"),
         }
     }
 }
@@ -359,7 +359,7 @@ mod tests {
     #[test]
     fn rsa_sign_verify() {
         fn prop(SomeKeypair(kp): SomeKeypair, msg: Vec<u8>) -> Result<bool, SigningError> {
-            kp.sign(&msg).map(|s| kp.public().verify(&msg, &s))
+            Ok(kp.public().verify(&msg, &kp.sign(&msg)))
         }
         QuickCheck::new()
             .tests(10)

protocols/gossipsub/src/behaviour.rs

@@ -2659,7 +2659,7 @@ where
                     // the signature is over the bytes "libp2p-pubsub:<protobuf-message>"
                     let mut signature_bytes = SIGNING_PREFIX.to_vec();
                     signature_bytes.extend_from_slice(&buf);
-                    Some(keypair.sign(&signature_bytes)?)
+                    Some(keypair.sign(&signature_bytes).unwrap())
                 };
 
                 Ok(RawMessage {

transports/noise/src/protocol.rs

@@ -90,7 +90,7 @@ impl Keypair {
         self,
         id_keys: &identity::Keypair,
     ) -> Result<AuthenticKeypair, Error> {
-        let sig = id_keys.sign(&[STATIC_KEY_DOMAIN.as_bytes(), self.public.as_ref()].concat())?;
+        let sig = id_keys.sign(&[STATIC_KEY_DOMAIN.as_bytes(), self.public.as_ref()].concat()).unwrap();
 
         let identity = KeypairIdentity {
             public: id_keys.public(),