Updates for password-hash trait Params bound changes (#753)

Companion PR to RustCrypto/traits#2106

The afforementioned upstream PR changed the bounds from ones which work
on PHC types like `phc::PasswordHash` and `phc::ParamsString` to core
traits like `Display` and `FromStr`.

This updates the `Params` types in `argon2`, `balloon-hash`, `pbkdf2`,
and `scrypt` to impl the traits needed to meet the new bounds. Notably
this PR is mostly additive and continues to support all the old traits,
while adding support for new ones (thunking through `phc::ParamsString`)

Author: tarcieri

Cargo.lock

@@ -5,7 +5,10 @@ use base64ct::{Base64Unpadded as B64, Encoding};
 use core::str::FromStr;
 
 #[cfg(feature = "password-hash")]
-use password_hash::{PasswordHash, phc::ParamsString};
+use {
+    core::fmt::{self, Display},
+    password_hash::{PasswordHash, phc::ParamsString},
+};
 
 /// Argon2 password hash parameters.
 ///
@@ -346,13 +349,29 @@ param_buf!(
 );
 
 #[cfg(feature = "password-hash")]
-impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
+impl Display for Params {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        ParamsString::try_from(self).map_err(|_| fmt::Error)?.fmt(f)
+    }
+}
+
+#[cfg(feature = "password-hash")]
+impl FromStr for Params {
+    type Err = password_hash::Error;
+
+    fn from_str(s: &str) -> password_hash::Result<Self> {
+        Self::try_from(&ParamsString::from_str(s)?)
+    }
+}
+
+#[cfg(feature = "password-hash")]
+impl TryFrom<&ParamsString> for Params {
     type Error = password_hash::Error;
 
-    fn try_from(hash: &'a PasswordHash<'a>) -> password_hash::Result<Self> {
+    fn try_from(params: &ParamsString) -> password_hash::Result<Self> {
         let mut builder = ParamsBuilder::new();
 
-        for (ident, value) in hash.params.iter() {
+        for (ident, value) in params.iter() {
             match ident.as_str() {
                 "m" => {
                     builder.m_cost(value.decimal()?);
@@ -373,11 +392,22 @@ impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
             }
         }
 
+        Ok(builder.build()?)
+    }
+}
+
+#[cfg(feature = "password-hash")]
+impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
+    type Error = password_hash::Error;
+
+    fn try_from(hash: &'a PasswordHash<'a>) -> password_hash::Result<Self> {
+        let mut params = Self::try_from(&hash.params)?;
+
         if let Some(output) = &hash.hash {
-            builder.output_len(output.len());
+            params.output_len = Some(output.len());
         }
 
-        Ok(builder.build()?)
+        Ok(params)
     }
 }
 

argon2/src/params.rs

@@ -2,11 +2,16 @@
 
 use crate::{Error, Result};
 use core::num::NonZeroU32;
-
 #[cfg(feature = "password-hash")]
-use password_hash::{
-    errors::InvalidValue,
-    phc::{ParamsString, PasswordHash},
+use {
+    core::{
+        fmt::{self, Display},
+        str::FromStr,
+    },
+    password_hash::{
+        errors::InvalidValue,
+        phc::{ParamsString, PasswordHash},
+    },
 };
 
 /// Balloon password hash parameters.
@@ -56,13 +61,29 @@ impl Default for Params {
 }
 
 #[cfg(feature = "password-hash")]
-impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
+impl Display for Params {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        ParamsString::try_from(self).map_err(|_| fmt::Error)?.fmt(f)
+    }
+}
+
+#[cfg(feature = "password-hash")]
+impl FromStr for Params {
+    type Err = password_hash::Error;
+
+    fn from_str(s: &str) -> password_hash::Result<Self> {
+        Self::try_from(&ParamsString::from_str(s)?)
+    }
+}
+
+#[cfg(feature = "password-hash")]
+impl TryFrom<&ParamsString> for Params {
     type Error = password_hash::Error;
 
-    fn try_from(hash: &'a PasswordHash<'a>) -> password_hash::Result<Self> {
+    fn try_from(params_string: &ParamsString) -> password_hash::Result<Self> {
         let mut params = Self::default();
 
-        for (ident, value) in hash.params.iter() {
+        for (ident, value) in params_string.iter() {
             match ident.as_str() {
                 "s" => {
                     params.s_cost = NonZeroU32::new(value.decimal()?)
@@ -84,6 +105,15 @@ impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
     }
 }
 
+#[cfg(feature = "password-hash")]
+impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
+    type Error = password_hash::Error;
+
+    fn try_from(hash: &'a PasswordHash<'a>) -> password_hash::Result<Self> {
+        Self::try_from(&hash.params)
+    }
+}
+
 #[cfg(feature = "password-hash")]
 impl TryFrom<Params> for ParamsString {
     type Error = password_hash::Error;

balloon-hash/src/params.rs

@@ -1,7 +1,11 @@
 //! Implementation of the `password-hash` crate API.
 
 use crate::pbkdf2_hmac;
-use core::{cmp::Ordering, fmt, str::FromStr};
+use core::{
+    cmp::Ordering,
+    fmt::{self, Display, Formatter},
+    str::FromStr,
+};
 use password_hash::{
     CustomizedPasswordHasher, Error, PasswordHasher, Result,
     errors::InvalidValue,
@@ -205,42 +209,59 @@ impl Default for Params {
     }
 }
 
-impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
-    type Error = Error;
+impl Display for Params {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        ParamsString::try_from(self).map_err(|_| fmt::Error)?.fmt(f)
+    }
+}
 
-    fn try_from(hash: &'a PasswordHash<'a>) -> Result<Self> {
-        let mut params = Params::default();
-        let mut output_length = None;
+impl FromStr for Params {
+    type Err = password_hash::Error;
 
-        if hash.version.is_some() {
-            return Err(Error::Version);
-        }
+    fn from_str(s: &str) -> password_hash::Result<Self> {
+        Self::try_from(&ParamsString::from_str(s)?)
+    }
+}
 
-        for (ident, value) in hash.params.iter() {
+impl TryFrom<&ParamsString> for Params {
+    type Error = password_hash::Error;
+
+    fn try_from(params_string: &ParamsString) -> password_hash::Result<Self> {
+        let mut params = Params::default();
+
+        for (ident, value) in params_string.iter() {
             match ident.as_str() {
                 "i" => params.rounds = value.decimal()?,
                 "l" => {
-                    output_length = Some(
-                        value
-                            .decimal()?
-                            .try_into()
-                            .map_err(|_| InvalidValue::Malformed.param_error())?,
-                    )
+                    params.output_length = value
+                        .decimal()?
+                        .try_into()
+                        .map_err(|_| InvalidValue::Malformed.param_error())?
                 }
                 _ => return Err(Error::ParamNameInvalid),
             }
         }
 
-        if let Some(len) = output_length {
-            if let Some(hash) = &hash.hash {
-                match hash.len().cmp(&len) {
-                    Ordering::Less => return Err(InvalidValue::TooShort.param_error()),
-                    Ordering::Greater => return Err(InvalidValue::TooLong.param_error()),
-                    Ordering::Equal => (),
-                }
-            }
+        Ok(params)
+    }
+}
+
+impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
+    type Error = Error;
 
-            params.output_length = len;
+    fn try_from(hash: &'a PasswordHash<'a>) -> Result<Self> {
+        if hash.version.is_some() {
+            return Err(Error::Version);
+        }
+
+        let params = Self::try_from(&hash.params)?;
+
+        if let Some(hash) = &hash.hash {
+            match hash.len().cmp(&params.output_length) {
+                Ordering::Less => return Err(InvalidValue::TooShort.param_error()),
+                Ordering::Greater => return Err(InvalidValue::TooLong.param_error()),
+                Ordering::Equal => (),
+            }
         }
 
         Ok(params)
@@ -250,7 +271,15 @@ impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
 impl TryFrom<Params> for ParamsString {
     type Error = Error;
 
-    fn try_from(input: Params) -> Result<ParamsString> {
+    fn try_from(params: Params) -> Result<ParamsString> {
+        Self::try_from(&params)
+    }
+}
+
+impl TryFrom<&Params> for ParamsString {
+    type Error = Error;
+
+    fn try_from(input: &Params) -> Result<ParamsString> {
         let mut output = ParamsString::new();
         output.add_decimal("i", input.rounds)?;
         output.add_decimal("l", input.output_length as u32)?;

pbkdf2/src/simple.rs

@@ -1,12 +1,16 @@
-use core::mem::size_of;
-
 use crate::errors::InvalidParams;
 
 #[cfg(feature = "simple")]
-use password_hash::{
-    Error,
-    errors::InvalidValue,
-    phc::{Output, ParamsString, PasswordHash},
+use {
+    core::{
+        fmt::{self, Display},
+        str::FromStr,
+    },
+    password_hash::{
+        Error,
+        errors::InvalidValue,
+        phc::{Output, ParamsString, PasswordHash},
+    },
 };
 
 #[cfg(all(feature = "simple", doc))]
@@ -174,19 +178,31 @@ impl Default for Params {
 }
 
 #[cfg(feature = "simple")]
-impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
-    type Error = password_hash::Error;
+impl Display for Params {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        ParamsString::try_from(self).map_err(|_| fmt::Error)?.fmt(f)
+    }
+}
 
-    fn try_from(hash: &'a PasswordHash<'a>) -> Result<Self, password_hash::Error> {
+#[cfg(feature = "simple")]
+impl FromStr for Params {
+    type Err = Error;
+
+    fn from_str(s: &str) -> password_hash::Result<Self> {
+        Self::try_from(&ParamsString::from_str(s)?)
+    }
+}
+
+#[cfg(feature = "password-hash")]
+impl TryFrom<&ParamsString> for Params {
+    type Error = Error;
+
+    fn try_from(params: &ParamsString) -> password_hash::Result<Self> {
         let mut log_n = Self::RECOMMENDED_LOG_N;
         let mut r = Self::RECOMMENDED_R;
         let mut p = Self::RECOMMENDED_P;
 
-        if hash.version.is_some() {
-            return Err(Error::Version);
-        }
-
-        for (ident, value) in hash.params.iter() {
+        for (ident, value) in params.iter() {
             match ident.as_str() {
                 "ln" => {
                     log_n = value
@@ -196,25 +212,49 @@ impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
                 }
                 "r" => r = value.decimal()?,
                 "p" => p = value.decimal()?,
-                _ => return Err(password_hash::Error::ParamNameInvalid),
+                _ => return Err(Error::ParamNameInvalid),
             }
         }
 
-        let len = hash
-            .hash
-            .map(|out| out.len())
-            .unwrap_or(Self::RECOMMENDED_LEN);
+        Params::new(log_n, r, p).map_err(|_| InvalidValue::Malformed.param_error())
+    }
+}
+
+#[cfg(feature = "simple")]
+impl<'a> TryFrom<&'a PasswordHash<'a>> for Params {
+    type Error = Error;
+
+    fn try_from(hash: &'a PasswordHash<'a>) -> password_hash::Result<Self> {
+        if hash.version.is_some() {
+            return Err(Error::Version);
+        }
+
+        let mut params = Params::try_from(&hash.params)?;
+
+        params.len = Some(
+            hash.hash
+                .map(|out| out.len())
+                .unwrap_or(Self::RECOMMENDED_LEN),
+        );
 
-        Params::new_with_output_len(log_n, r, p, len)
-            .map_err(|_| InvalidValue::Malformed.param_error())
+        Ok(params)
     }
 }
 
 #[cfg(feature = "simple")]
 impl TryFrom<Params> for ParamsString {
-    type Error = password_hash::Error;
+    type Error = Error;
+
+    fn try_from(params: Params) -> Result<ParamsString, Error> {
+        Self::try_from(&params)
+    }
+}
+
+#[cfg(feature = "simple")]
+impl TryFrom<&Params> for ParamsString {
+    type Error = Error;
 
-    fn try_from(input: Params) -> Result<ParamsString, password_hash::Error> {
+    fn try_from(input: &Params) -> Result<ParamsString, Error> {
         let mut output = ParamsString::new();
         output.add_decimal("ln", input.log_n as u32)?;
         output.add_decimal("r", input.r)?;