cargo formatted code

Author: tmthecoder

src/hotp.rs

@@ -1,7 +1,7 @@
 // Implementation of the HOTP standard according to RFC4226 by Tejas Mehta
 
-use base32::Alphabet;
 use crate::util::{get_code, hash_generic, MacDigest};
+use base32::Alphabet;
 
 /// A HOTP Generator
 ///
@@ -35,9 +35,9 @@ impl HOTP {
     /// Since only SHA1 was specified in the reference implementation and
     /// RFC specification, there's no need to initialize with a digest object
     pub fn new(secret: &[u8]) -> Self {
-       HOTP {
-           secret: secret.to_vec()
-       }
+        HOTP {
+            secret: secret.to_vec(),
+        }
     }
 
     /// Creates a new HOTP instance from a utf8-encoded string secret
@@ -55,9 +55,8 @@ impl HOTP {
     /// This method panics if the provided string is not correctly base32
     /// encoded.
     pub fn from_base32(secret: &str) -> Self {
-        let decoded = base32::decode(
-            Alphabet::RFC4648 { padding: false }, secret
-        ).expect("Failed to decode base32 string");
+        let decoded = base32::decode(Alphabet::RFC4648 { padding: false }, secret)
+            .expect("Failed to decode base32 string");
         HOTP::new(&decoded)
     }
 }
@@ -72,12 +71,12 @@ impl HOTP {
     /// # Panics
     /// This method panics if the hash's secret is incorrectly given.
     pub fn get_otp(&self, counter: u64, digits: u32) -> u32 {
-
         let hash = hash_generic(&counter.to_be_bytes(), &self.secret, &MacDigest::SHA1);
-        let offset = (hash[hash.len()-1] & 0xf) as usize;
-        let bytes: [u8; 4] = hash[offset..offset + 4].try_into().expect("Failed byte get");
+        let offset = (hash[hash.len() - 1] & 0xf) as usize;
+        let bytes: [u8; 4] = hash[offset..offset + 4]
+            .try_into()
+            .expect("Failed byte get");
 
         get_code(bytes, digits)
     }
-
-}
+}

src/lib.rs

@@ -75,4 +75,4 @@
 
 pub mod hotp;
 pub mod totp;
-pub mod util;
+pub mod util;

src/totp.rs

@@ -1,5 +1,5 @@
-use base32::Alphabet;
 use crate::util::{get_code, hash_generic, MacDigest};
+use base32::Alphabet;
 
 /// A TOTP generator
 ///
@@ -29,7 +29,7 @@ pub struct TOTP {
     ///
     /// Unless an initializer ending in 'with_digest' is used, this value
     /// defaults to [`MacDigest::SHA1`]
-    mac_digest: MacDigest
+    mac_digest: MacDigest,
 }
 
 /// All initializer implementations for the [`TOTP`] struct
@@ -50,7 +50,7 @@ impl TOTP {
     pub fn new_with_digest(secret: &[u8], mac_digest: MacDigest) -> Self {
         TOTP {
             secret: secret.to_vec(),
-            mac_digest
+            mac_digest,
         }
     }
 
@@ -59,7 +59,7 @@ impl TOTP {
     /// Like [`TOTP::new`], this method also defaults to using [`MacDigest::SHA1`]
     /// for HMAC operations.
     pub fn from_utf8(secret: &str) -> Self {
-       TOTP::from_utf8_with_digest(secret, MacDigest::SHA1)
+        TOTP::from_utf8_with_digest(secret, MacDigest::SHA1)
     }
 
     /// Creates a new TOTP instance from a utf8-encoded string secret
@@ -90,9 +90,8 @@ impl TOTP {
     /// # Panics
     /// This method panics if the provided string is not correctly base32 encoded.
     pub fn from_base32_with_digest(secret: &str, mac_digest: MacDigest) -> Self {
-        let decoded = base32::decode(
-            Alphabet::RFC4648 { padding: false }, secret
-        ).expect("Failed to decode base32 string");
+        let decoded = base32::decode(Alphabet::RFC4648 { padding: false }, secret)
+            .expect("Failed to decode base32 string");
         TOTP::new_with_digest(&decoded, mac_digest)
     }
 }
@@ -113,7 +112,7 @@ impl TOTP {
     /// This method panics if the called [`TOTP::get_otp_with_custom`] method
     /// does, which would happen if the hash's secret is incorrectly given.
     pub fn get_otp(&self, time: u64, digits: u32) -> u32 {
-       self.get_otp_with_custom(time, 30, 0, digits)
+        self.get_otp_with_custom(time, 30, 0, digits)
     }
 
     /// Generates and returns the TOTP value for the time with a provided step,
@@ -126,13 +125,21 @@ impl TOTP {
     ///
     /// # Panics
     /// This method panics if the hash's secret is incorrectly given.
-    pub fn get_otp_with_custom(&self, time: u64, time_step: u64, time_start: u64, digits: u32) -> u32 {
+    pub fn get_otp_with_custom(
+        &self,
+        time: u64,
+        time_step: u64,
+        time_start: u64,
+        digits: u32,
+    ) -> u32 {
         let time_count = (time - time_start) / time_step;
 
         let hash = hash_generic(&time_count.to_be_bytes(), &self.secret, &self.mac_digest);
-        let offset = (hash[hash.len()-1] & 0xf) as usize;
-        let bytes: [u8; 4] = hash[offset..offset + 4].try_into().expect("Failed byte get");
+        let offset = (hash[hash.len() - 1] & 0xf) as usize;
+        let bytes: [u8; 4] = hash[offset..offset + 4]
+            .try_into()
+            .expect("Failed byte get");
 
         get_code(bytes, digits)
     }
-}
+}

src/util.rs

@@ -16,7 +16,7 @@ use sha2::{Sha256, Sha512};
 pub enum MacDigest {
     SHA1,
     SHA256,
-    SHA512
+    SHA512,
 }
 
 /// A generic method to convert the [H/T]OTP byte-array into the
@@ -44,7 +44,7 @@ pub(crate) fn hash_generic(msg: &[u8], secret: &[u8], digest: &MacDigest) -> Vec
     match *digest {
         MacDigest::SHA1 => hash_internal::<Hmac<Sha1>>(msg, secret),
         MacDigest::SHA256 => hash_internal::<Hmac<Sha256>>(msg, secret),
-        MacDigest::SHA512 => hash_internal::<Hmac<Sha512>>(msg, secret)
+        MacDigest::SHA512 => hash_internal::<Hmac<Sha512>>(msg, secret),
     }
 }
 
@@ -58,9 +58,8 @@ pub(crate) fn hash_generic(msg: &[u8], secret: &[u8], digest: &MacDigest) -> Vec
 /// The method will panic if the provided secret is invalid and a hash
 /// cannot be generated
 
-fn hash_internal<D: Mac> (msg: &[u8], secret: &[u8]) -> Vec<u8> {
-    let mut hmac = <D>::new_from_slice(secret)
-        .expect("Failed to initialize HMAC");
+fn hash_internal<D: Mac>(msg: &[u8], secret: &[u8]) -> Vec<u8> {
+    let mut hmac = <D>::new_from_slice(secret).expect("Failed to initialize HMAC");
     hmac.update(msg);
     hmac.finalize().into_bytes()[..].into()
-}
+}

tests/hotp.rs

@@ -78,4 +78,4 @@ fn rfc_test_case_9() {
 #[test]
 fn rfc_test_case_10() {
     assert_eq!(run_rfc_test_base32(9), 520489)
-}
+}

tests/totp.rs

@@ -1,5 +1,5 @@
-use xotp::util::MacDigest;
 use xotp::totp::TOTP;
+use xotp::util::MacDigest;
 
 // RFC6238 SHA1 Secret
 static SECRET_UTF8_SHA1: &str = "12345678901234567890";
@@ -31,7 +31,11 @@ fn run_rfc_test_bytes(time: u64) -> u32 {
 /// Generic test method to get the TOTP code with
 /// the given digest's Secret Key as a byte array
 fn run_rfc_test_bytes_with_digest(time: u64, digest: MacDigest) -> u32 {
-    let secret = if let MacDigest::SHA256 = digest { SECRET_BYTES_SHA256 } else { SECRET_BYTES_SHA512 };
+    let secret = if let MacDigest::SHA256 = digest {
+        SECRET_BYTES_SHA256
+    } else {
+        SECRET_BYTES_SHA512
+    };
     let totp = TOTP::new_with_digest(secret, digest);
     totp.get_otp(time, 8)
 }
@@ -46,7 +50,11 @@ fn run_rfc_test_utf8(time: u64) -> u32 {
 /// Generic test method to get the TOTP code with
 /// the given digest's Secret Key as a string literal
 fn run_rfc_test_utf8_with_digest(time: u64, digest: MacDigest) -> u32 {
-    let secret = if let MacDigest::SHA256 = digest { SECRET_UTF8_SHA256 } else { SECRET_UTF8_SHA512 };
+    let secret = if let MacDigest::SHA256 = digest {
+        SECRET_UTF8_SHA256
+    } else {
+        SECRET_UTF8_SHA512
+    };
     let totp = TOTP::from_utf8_with_digest(secret, digest);
     totp.get_otp(time, 8)
 }
@@ -61,13 +69,15 @@ fn run_rfc_test_base32(time: u64) -> u32 {
 /// Generic test method to get the TOTP code with
 /// the given digest's Secret Key as a base32-encoded string
 fn run_rfc_test_base32_with_digest(time: u64, digest: MacDigest) -> u32 {
-    let secret = if let MacDigest::SHA256 = digest { SECRET_BASE32_SHA256 } else { SECRET_BASE32_SHA512 };
+    let secret = if let MacDigest::SHA256 = digest {
+        SECRET_BASE32_SHA256
+    } else {
+        SECRET_BASE32_SHA512
+    };
     let totp = TOTP::from_base32_with_digest(secret, digest);
     totp.get_otp_with_custom(time, 30, 0, 8)
 }
 
-
-
 // All SHA-1 Tests for TOTP from RTC6238
 // Tests 1-2 ran with 'SECRET_BYTES_SHA1'
 #[test]
@@ -168,7 +178,8 @@ fn rtc_test_1_sha512() {
 fn rtc_test_2_sha512() {
     assert_eq!(
         run_rfc_test_bytes_with_digest(1111111109, MacDigest::SHA512),
-        25091201        )
+        25091201
+    )
 }
 
 // Tests 3-4 ran with 'SECRET_UTF8_SHA512'
@@ -203,4 +214,4 @@ fn rtc_test_6_sha512() {
         run_rfc_test_base32_with_digest(20000000000, MacDigest::SHA512),
         47863826
     )
-}
+}