Add PasswordVerifier<str> impls

argon2/src/lib.rs

@@ -649,7 +649,7 @@ impl PasswordHasher<PasswordHash> for Argon2<'_> {
         password: &[u8],
         salt: &[u8],
     ) -> password_hash::Result<PasswordHash> {
-        let salt = Salt::new(salt).map_err(|_| password_hash::Error::SaltInvalid)?;
+        let salt = Salt::new(salt)?;
 
         let output_len = self
             .params
@@ -662,7 +662,7 @@ impl PasswordHasher<PasswordHash> for Argon2<'_> {
             .ok_or(password_hash::Error::OutputSize)?;
 
         self.hash_password_into(password, &salt, out)?;
-        let output = Output::new(out).map_err(|_| password_hash::Error::OutputSize)?;
+        let output = Output::new(out)?;
 
         Ok(PasswordHash {
             algorithm: self.algorithm.ident(),
@@ -674,6 +674,13 @@ impl PasswordHasher<PasswordHash> for Argon2<'_> {
     }
 }
 
+#[cfg(all(feature = "alloc", feature = "password-hash"))]
+impl PasswordVerifier<str> for Argon2<'_> {
+    fn verify_password(&self, password: &[u8], hash: &str) -> password_hash::Result<()> {
+        self.verify_password(password, &PasswordHash::new(hash)?)
+    }
+}
+
 impl From<Params> for Argon2<'_> {
     fn from(params: Params) -> Self {
         Self::new(Algorithm::default(), Version::default(), params)

balloon-hash/src/lib.rs

@@ -234,9 +234,9 @@ where
         password: &[u8],
         salt: &[u8],
     ) -> password_hash::Result<PasswordHash> {
-        let salt = Salt::new(salt).map_err(|_| password_hash::Error::SaltInvalid)?;
+        let salt = Salt::new(salt)?;
         let hash = self.hash(password, &salt)?;
-        let output = Output::new(&hash).map_err(|_| password_hash::Error::OutputSize)?;
+        let output = Output::new(&hash)?;
 
         Ok(PasswordHash {
             algorithm: self.algorithm.ident(),
@@ -248,6 +248,17 @@ where
     }
 }
 
+#[cfg(all(feature = "alloc", feature = "password-hash"))]
+impl<D> PasswordVerifier<str> for Balloon<'_, D>
+where
+    D: Digest + FixedOutputReset,
+    Array<u8, D::OutputSize>: ArrayDecoding,
+{
+    fn verify_password(&self, password: &[u8], hash: &str) -> password_hash::Result<()> {
+        self.verify_password(password, &PasswordHash::new(hash)?)
+    }
+}
+
 impl<D: Digest + FixedOutputReset> From<Params> for Balloon<'_, D>
 where
     Array<u8, D::OutputSize>: ArrayDecoding,

pbkdf2/src/phc.rs

@@ -39,7 +39,7 @@ impl CustomizedPasswordHasher<PasswordHash> for Pbkdf2 {
             return Err(Error::Version);
         }
 
-        let salt = Salt::new(salt).map_err(|_| Error::SaltInvalid)?;
+        let salt = Salt::new(salt)?;
 
         let mut buffer = [0u8; Output::MAX_LENGTH];
         let out = buffer
@@ -54,7 +54,7 @@ impl CustomizedPasswordHasher<PasswordHash> for Pbkdf2 {
         };
 
         f(password, &salt, params.rounds, out);
-        let output = Output::new(out).map_err(|_| Error::OutputSize)?;
+        let output = Output::new(out)?;
 
         Ok(PasswordHash {
             algorithm: *algorithm.ident(),

scrypt/src/phc.rs

@@ -39,13 +39,13 @@ impl CustomizedPasswordHasher<PasswordHash> for Scrypt {
             return Err(Error::Version);
         }
 
-        let salt = Salt::new(salt).map_err(|_| Error::SaltInvalid)?;
+        let salt = Salt::new(salt)?;
         let len = params.len.unwrap_or(Params::RECOMMENDED_LEN);
 
         let mut buffer = [0u8; Output::MAX_LENGTH];
         let out = buffer.get_mut(..len).ok_or(Error::OutputSize)?;
         scrypt(password, &salt, &params, out).map_err(|_| Error::OutputSize)?;
-        let output = Output::new(out).map_err(|_| Error::OutputSize)?;
+        let output = Output::new(out)?;
 
         Ok(PasswordHash {
             algorithm: ALG_ID,

sha-crypt/src/mcf.rs

@@ -144,6 +144,17 @@ where
     }
 }
 
+impl<D> PasswordVerifier<str> for ShaCrypt<D>
+where
+    Self: ShaCryptCore,
+{
+    fn verify_password(&self, password: &[u8], hash: &str) -> password_hash::Result<()> {
+        // TODO(tarcieri): better mapping from `mcf::Error` and `password_hash::Error`?
+        let hash = PasswordHashRef::new(hash).map_err(|_| Error::EncodingInvalid)?;
+        self.verify_password(password, hash)
+    }
+}
+
 impl ShaCryptCore for ShaCrypt<Sha256> {
     const MCF_ID: &'static str = "5";
     type Output = [u8; BLOCK_SIZE_SHA256];

yescrypt/src/mcf.rs

@@ -127,3 +127,11 @@ impl PasswordVerifier<PasswordHashRef> for Yescrypt {
         Ok(())
     }
 }
+
+impl PasswordVerifier<str> for Yescrypt {
+    fn verify_password(&self, password: &[u8], hash: &str) -> Result<()> {
+        // TODO(tarcieri): better mapping from `mcf::Error` and `password_hash::Error`?
+        let hash = PasswordHashRef::new(hash).map_err(|_| Error::EncodingInvalid)?;
+        self.verify_password(password, hash)
+    }
+}