rsa: hook new Signer/Verifier implementations

Signed-off-by: Dmitry Baryshkov <[email protected]>

Author: lumag

src/key.rs

@@ -15,6 +15,8 @@ use crate::errors::{Error, Result};
 
 use crate::padding::PaddingScheme;
 use crate::raw::{DecryptionPrimitive, EncryptionPrimitive};
+use crate::signer::{RsaBlindedSigner, RsaSigner};
+use crate::verifier::RsaVerifier;
 use crate::{oaep, pkcs1v15, pss};
 
 static MIN_PUB_EXPONENT: u64 = 2;
@@ -199,7 +201,7 @@ impl PublicKeyParts for RsaPublicKey {
     }
 }
 
-impl PublicKey for RsaPublicKey {
+impl<'a> PublicKey for RsaPublicKey {
     fn encrypt<R: RngCore + CryptoRng>(
         &self,
         rng: &mut R,
@@ -229,14 +231,18 @@ impl PublicKey for RsaPublicKey {
     }
 }
 
-impl RsaPublicKey {
+impl<'a> RsaPublicKey {
     /// Create a new key from its components.
     pub fn new(n: BigUint, e: BigUint) -> Result<Self> {
         let k = RsaPublicKey { n, e };
         check_public(&k)?;
 
         Ok(k)
     }
+
+    pub fn to_verifier(&'a self, padding: PaddingScheme) -> RsaVerifier<'a> {
+        RsaVerifier::new(&self, padding)
+    }
 }
 
 impl<'a> PublicKeyParts for &'a RsaPublicKey {
@@ -290,7 +296,7 @@ impl<'a> PublicKeyParts for &'a RsaPrivateKey {
 
 impl<'a> PrivateKey for &'a RsaPrivateKey {}
 
-impl RsaPrivateKey {
+impl<'a> RsaPrivateKey {
     /// Generate a new Rsa key pair of the given bit size using the passed in `rng`.
     pub fn new<R: RngCore + CryptoRng>(rng: &mut R, bit_size: usize) -> Result<RsaPrivateKey> {
         generate_multi_prime_key(rng, 2, bit_size)
@@ -547,6 +553,14 @@ impl RsaPrivateKey {
             _ => Err(Error::InvalidPaddingScheme),
         }
     }
+
+    pub fn to_signer(&'a self, padding: PaddingScheme) -> RsaSigner<'a> {
+        RsaSigner::new(&self, padding)
+    }
+
+    pub fn to_blinded_signer(&'a self, padding: PaddingScheme) -> RsaBlindedSigner<'a> {
+        RsaBlindedSigner::new(&self, padding)
+    }
 }
 
 /// Check that the public key is well formed and has an exponent within acceptable bounds.

src/lib.rs

@@ -182,6 +182,7 @@ pub use pkcs8;
 pub use self::hash::Hash;
 pub use self::key::{PublicKey, PublicKeyParts, RsaPrivateKey, RsaPublicKey};
 pub use self::padding::PaddingScheme;
+pub use self::rsa_core::RsaSignature;
 
 /// Internal raw RSA functions.
 #[cfg(not(feature = "expose-internals"))]

src/pkcs1v15.rs

@@ -224,8 +224,12 @@ mod tests {
     use num_traits::Num;
     use rand_chacha::{rand_core::SeedableRng, ChaCha8Rng};
     use sha1::{Digest, Sha1};
+    use signature::RandomizedSigner;
+    use signature::Signer;
+    use signature::Signature;
+    use signature::Verifier;
 
-    use crate::{Hash, PaddingScheme, PublicKey, PublicKeyParts, RsaPrivateKey, RsaPublicKey};
+    use crate::{Hash, PaddingScheme, PublicKey, PublicKeyParts, RsaPrivateKey, RsaPublicKey, RsaSignature};
 
     #[test]
     fn test_non_zero_bytes() {
@@ -345,6 +349,19 @@ mod tests {
                 )
                 .unwrap();
             assert_eq!(out2, expected);
+
+            let out = priv_key
+                .to_signer(PaddingScheme::new_pkcs1v15_sign(Some(Hash::SHA1)))
+                .try_sign(&digest)
+                .expect("failed to sign");
+            assert_ne!(out.as_ref(), digest);
+            assert_eq!(out.as_ref(), expected);
+
+            let out2 = priv_key
+                .to_blinded_signer(PaddingScheme::new_pkcs1v15_sign(Some(Hash::SHA1)))
+                .try_sign_with_rng(&mut rng, &digest)
+                .expect("failed to sign");
+            assert_eq!(out2.as_ref(), expected);
         }
     }
 
@@ -371,6 +388,14 @@ mod tests {
                     sig,
                 )
                 .expect("failed to verify");
+
+            pub_key
+                .to_verifier(PaddingScheme::new_pkcs1v15_sign(Some(Hash::SHA1)))
+                .verify(
+                    &digest,
+                    &RsaSignature::from_bytes(sig).expect("failed to create signature"),
+                )
+                .expect("failed to verify");
         }
     }
 

src/pss.rs

@@ -239,13 +239,16 @@ fn emsa_pss_verify(
 #[cfg(test)]
 mod test {
     use crate::hash::Hash;
-    use crate::{PaddingScheme, PublicKey, RsaPrivateKey, RsaPublicKey};
+    use crate::{PaddingScheme, PublicKey, RsaPrivateKey, RsaPublicKey, RsaSignature};
 
     use hex_literal::hex;
     use num_bigint::BigUint;
     use num_traits::{FromPrimitive, Num};
     use rand_chacha::{rand_core::SeedableRng, ChaCha8Rng};
     use sha1::{Digest, Sha1};
+    use signature::RandomizedSigner;
+    use signature::Signature;
+    use signature::Verifier;
 
     fn get_private_key() -> RsaPrivateKey {
         // In order to generate new test vectors you'll need the PEM form of this key:
@@ -288,6 +291,14 @@ mod test {
             pub_key
                 .verify(PaddingScheme::new_pss::<Sha1>(Hash::SHA1), &digest, sig)
                 .expect("failed to verify");
+
+            pub_key
+                .to_verifier(PaddingScheme::new_pss::<Sha1>(Hash::SHA1))
+                .verify(
+                    &digest,
+                    &RsaSignature::from_bytes(sig).expect("failed to create signature"),
+                )
+                .expect("failed to verify");
         }
     }
 
@@ -311,6 +322,15 @@ mod test {
             priv_key
                 .verify(PaddingScheme::new_pss::<Sha1>(Hash::SHA1), &digest, &sig)
                 .expect("failed to verify");
+
+            let sig = priv_key
+                .to_signer(PaddingScheme::new_pss::<Sha1>(Hash::SHA1))
+                .try_sign_with_rng(&mut rng.clone(), &digest)
+                .expect("failed to sign");
+            priv_key
+                .to_verifier(PaddingScheme::new_pss::<Sha1>(Hash::SHA1))
+                .verify(&digest, &sig)
+                .expect("failed to verify");
         }
     }
 
@@ -334,6 +354,15 @@ mod test {
             priv_key
                 .verify(PaddingScheme::new_pss::<Sha1>(Hash::SHA1), &digest, &sig)
                 .expect("failed to verify");
+
+            let sig = priv_key
+                .to_blinded_signer(PaddingScheme::new_pss::<Sha1>(Hash::SHA1))
+                .try_sign_with_rng(&mut rng.clone(), &digest)
+                .expect("failed to sign");
+            priv_key
+                .to_verifier(PaddingScheme::new_pss::<Sha1>(Hash::SHA1))
+                .verify(&digest, &sig)
+                .expect("failed to verify");
         }
     }
 }