Format code using rustfmt

Author: Thomas Bahn

src/client.rs

@@ -2,14 +2,14 @@ use std::borrow::Cow;
 use std::io;
 
 use base64;
-use rand::distributions::IndependentSample;
 use rand::distributions::range::Range;
-use rand::{Rng, OsRng};
+use rand::distributions::IndependentSample;
+use rand::{OsRng, Rng};
 use ring::digest::SHA256_OUTPUT_LEN;
 use ring::hmac;
 
-use utils::{hash_password, find_proofs};
-use error::{Error, Kind, Field};
+use error::{Error, Field, Kind};
+use utils::{find_proofs, hash_password};
 use NONCE_LENGTH;
 
 #[deprecated(since = "0.2.0", note = "Please use `ScramClient` instead. (exported at crate root)")]
@@ -37,21 +37,20 @@ fn parse_server_first(data: &str) -> Result<(&str, Vec<u8>, u16), Error> {
         }
     };
     let salt = match parts.next() {
-        Some(part) if &part.as_bytes()[..2] == b"s=" => {
-            try!(base64::decode(part[2..].as_bytes()).map_err(|_| {
-                Error::Protocol(Kind::InvalidField(Field::Salt))
-            }))
-        }
+        Some(part) if &part.as_bytes()[..2] == b"s=" => try!(
+            base64::decode(part[2..].as_bytes())
+                .map_err(|_| Error::Protocol(Kind::InvalidField(Field::Salt)))
+        ),
         _ => {
             return Err(Error::Protocol(Kind::ExpectedField(Field::Salt)));
         }
     };
     let iterations = match parts.next() {
-        Some(part) if &part.as_bytes()[..2] == b"i=" => {
-            try!(part[2..].parse().map_err(|_| {
-                Error::Protocol(Kind::InvalidField(Field::Iterations))
-            }))
-        }
+        Some(part) if &part.as_bytes()[..2] == b"i=" => try!(
+            part[2..]
+                .parse()
+                .map_err(|_| Error::Protocol(Kind::InvalidField(Field::Iterations)))
+        ),
         _ => {
             return Err(Error::Protocol(Kind::ExpectedField(Field::Iterations)));
         }
@@ -64,11 +63,8 @@ fn parse_server_final(data: &str) -> Result<Vec<u8>, Error> {
         return Err(Error::Protocol(Kind::ExpectedField(Field::VerifyOrError)));
     }
     match &data[..2] {
-        "v=" => {
-            base64::decode(&data.as_bytes()[2..]).map_err(|_| {
-                Error::Protocol(Kind::InvalidField(Field::VerifyOrError))
-            })
-        }
+        "v=" => base64::decode(&data.as_bytes()[2..])
+            .map_err(|_| Error::Protocol(Kind::InvalidField(Field::VerifyOrError))),
         "e=" => Err(Error::Authentication(data[2..].to_string())),
         _ => Err(Error::Protocol(Kind::ExpectedField(Field::VerifyOrError))),
     }
@@ -128,7 +124,11 @@ impl<'a> ScramClient<'a> {
         let nonce: String = (0..NONCE_LENGTH)
             .map(move |_| {
                 let x: u8 = range.ind_sample(&mut rng);
-                if x > 43 { (x + 1) as char } else { x as char }
+                if x > 43 {
+                    (x + 1) as char
+                } else {
+                    x as char
+                }
             })
             .collect();
 
@@ -187,14 +187,11 @@ impl<'a> ServerFirst<'a> {
     /// * Error::Protocol
     /// * Error::UnsupportedExtension
     pub fn handle_server_first(self, server_first: &str) -> Result<ClientFinal, Error> {
-
         let (nonce, salt, iterations) = try!(parse_server_first(server_first));
         if !nonce.starts_with(&self.client_nonce) {
             return Err(Error::Protocol(Kind::InvalidNonce));
         }
-
         let salted_password = hash_password(self.password, iterations, &salt);
-
         let (client_proof, server_signature): ([u8; SHA256_OUTPUT_LEN], hmac::Signature) =
             find_proofs(
                 &self.gs2header,
@@ -233,7 +230,9 @@ impl ClientFinal {
     /// method to continue the SCRAM handshake.
     #[inline]
     pub fn client_final(self) -> (ServerFinal, String) {
-        let server_final = ServerFinal { server_signature: self.server_signature };
+        let server_final = ServerFinal {
+            server_signature: self.server_signature,
+        };
         (server_final, self.client_final)
     }
 }

src/lib.rs

@@ -136,11 +136,11 @@ const NONCE_LENGTH: usize = 24;
 
 #[macro_use]
 mod utils;
-mod error;
 pub mod client;
+mod error;
 pub mod server;
 
 pub use client::ScramClient;
-pub use error::{Error, Kind, Field};
-pub use server::{ScramServer, AuthenticationProvider, PasswordInfo, AuthenticationStatus};
+pub use error::{Error, Field, Kind};
+pub use server::{AuthenticationProvider, AuthenticationStatus, PasswordInfo, ScramServer};
 pub use utils::hash_password;

src/server.rs

@@ -2,13 +2,13 @@ use std::borrow::Cow;
 use std::io;
 
 use base64;
-use rand::distributions::IndependentSample;
 use rand::distributions::range::Range;
-use rand::{Rng, OsRng};
+use rand::distributions::IndependentSample;
+use rand::{OsRng, Rng};
 use ring::digest::SHA256_OUTPUT_LEN;
 use ring::hmac;
 
-use error::{Error, Kind, Field};
+use error::{Error, Field, Kind};
 use utils::find_proofs;
 use NONCE_LENGTH;
 
@@ -187,7 +187,11 @@ impl<'a, P: AuthenticationProvider> ServerFirst<'a, P> {
         let server_nonce: String = (0..NONCE_LENGTH)
             .map(move |_| {
                 let x: u8 = range.ind_sample(&mut *rng);
-                if x > 43 { (x + 1) as char } else { x as char }
+                if x > 43 {
+                    (x + 1) as char
+                } else {
+                    x as char
+                }
             })
             .collect();
         let mut nonce = self.client_nonce.to_string();
@@ -262,8 +266,7 @@ impl<'a, P: AuthenticationProvider> ClientFinal<'a, P> {
                         status: AuthenticationStatus::NotAuthorized,
                         signature: format!(
                             "e=User '{}' not authorized to act as '{}'",
-                            self.authcid,
-                            authzid
+                            self.authcid, authzid
                         ),
                     })
                 }
@@ -334,8 +337,8 @@ impl ServerFinal {
 
 #[cfg(test)]
 mod tests {
-    use super::{parse_client_first, parse_client_final};
-    use super::super::{Error, Kind, Field};
+    use super::super::{Error, Field, Kind};
+    use super::{parse_client_final, parse_client_first};
 
     #[test]
     fn test_parse_client_first_success() {
@@ -344,8 +347,8 @@ mod tests {
         assert!(authzid.is_none());
         assert_eq!(nonce, "abcdefghijk");
 
-        let (authcid, authzid, nonce) = parse_client_first("y,a=other user,n=user,r=abcdef=hijk")
-            .unwrap();
+        let (authcid, authzid, nonce) =
+            parse_client_first("y,a=other user,n=user,r=abcdef=hijk").unwrap();
         assert_eq!(authcid, "user");
         assert_eq!(authzid, Some("other user"));
         assert_eq!(nonce, "abcdef=hijk");

src/utils.rs

@@ -2,15 +2,15 @@ use std::borrow::Cow;
 
 use base64;
 use ring::digest::{digest, SHA256, SHA256_OUTPUT_LEN};
-use ring::hmac::{self, SigningKey, SigningContext};
+use ring::hmac::{self, SigningContext, SigningKey};
 use ring::pbkdf2;
 
 /// Parses a part of a SCRAM message, after it has been split on commas.
 /// Checks to make sure there's a key, and then verifies its the right key.
 /// Returns everything after the first '='.
 /// Returns a `ExpectedField` error when one of the above conditions fails.
 macro_rules! parse_part {
-    ($iter: expr, $field: ident, $key: expr) => (
+    ($iter:expr, $field:ident, $key:expr) => {
         if let Some(part) = $iter.next() {
             if part.len() < 2 {
                 return Err(Error::Protocol(Kind::ExpectedField(Field::$field)));
@@ -22,7 +22,7 @@ macro_rules! parse_part {
         } else {
             return Err(Error::Protocol(Kind::ExpectedField(Field::$field)));
         }
-    );
+    };
 }
 
 /// Hashes a password with SHA-256 with the given salt and number of iterations.  This should
@@ -66,8 +66,6 @@ pub fn find_proofs(
         client_final_without_proof.as_bytes(),
     ];
 
-
-
     let salted_password_signing_key = SigningKey::new(&SHA256, salted_password);
     let client_key = hmac::sign(&salted_password_signing_key, b"Client Key");
     let server_key = hmac::sign(&salted_password_signing_key, b"Server Key");

tests/client_server.rs

@@ -1,6 +1,6 @@
-extern crate scram;
 extern crate rand;
 extern crate ring;
+extern crate scram;
 
 use ring::digest::SHA256_OUTPUT_LEN;
 use scram::*;
@@ -24,20 +24,16 @@ impl TestProvider {
 impl server::AuthenticationProvider for TestProvider {
     fn get_password_for(&self, username: &str) -> Option<server::PasswordInfo> {
         match username {
-            "user" => {
-                Some(server::PasswordInfo::new(
-                    self.user_password.to_vec(),
-                    4096,
-                    "salt".bytes().collect(),
-                ))
-            }
-            "admin" => {
-                Some(server::PasswordInfo::new(
-                    self.admin_password.to_vec(),
-                    8192,
-                    "messy".bytes().collect(),
-                ))
-            }
+            "user" => Some(server::PasswordInfo::new(
+                self.user_password.to_vec(),
+                4096,
+                "salt".bytes().collect(),
+            )),
+            "admin" => Some(server::PasswordInfo::new(
+                self.admin_password.to_vec(),
+                8192,
+                "messy".bytes().collect(),
+            )),
             _ => None,
         }
     }
@@ -47,7 +43,6 @@ impl server::AuthenticationProvider for TestProvider {
     }
 }
 
-
 #[test]
 fn test_simple_success() {
     let scram_client = ScramClient::new("user", "password", None).unwrap();