Format (#257)

* Add Rustfmt

* Add Taplo

src/key_exchange/group/mod.rs

@@ -5,13 +5,13 @@
 // License, Version 2.0 found in the LICENSE-APACHE file in the root directory
 // of this source tree.
 
-//! Includes the KeGroup trait and definitions for the
-//! key exchange groups
+//! Includes the KeGroup trait and definitions for the key exchange groups
 
-use crate::errors::InternalError;
 use generic_array::{ArrayLength, GenericArray};
 use rand::{CryptoRng, RngCore};
 
+use crate::errors::InternalError;
+
 /// A group representation for use in the key exchange
 pub trait KeGroup: Sized + Clone {
     /// Length of the public key

src/key_exchange/group/p256.rs

@@ -7,8 +7,6 @@
 
 //! Key Exchange group implementation for p256
 
-use super::KeGroup;
-use crate::errors::InternalError;
 use generic_array::typenum::{U32, U33};
 use generic_array::GenericArray;
 use p256_::elliptic_curve::group::GroupEncoding;
@@ -17,6 +15,9 @@ use p256_::elliptic_curve::{PublicKey, SecretKey};
 use p256_::NistP256;
 use rand::{CryptoRng, RngCore};
 
+use super::KeGroup;
+use crate::errors::InternalError;
+
 impl KeGroup for PublicKey<NistP256> {
     type PkLen = U33;
     type SkLen = U32;

src/key_exchange/group/ristretto255.rs

@@ -7,8 +7,6 @@
 
 //! Key Exchange group implementation for ristretto255
 
-use super::KeGroup;
-use crate::errors::InternalError;
 use curve25519_dalek::constants::RISTRETTO_BASEPOINT_POINT;
 use curve25519_dalek::ristretto::{CompressedRistretto, RistrettoPoint};
 use curve25519_dalek::scalar::Scalar;
@@ -16,6 +14,9 @@ use generic_array::typenum::U32;
 use generic_array::GenericArray;
 use rand::{CryptoRng, RngCore};
 
+use super::KeGroup;
+use crate::errors::InternalError;
+
 impl KeGroup for RistrettoPoint {
     type PkLen = U32;
     type SkLen = U32;
@@ -36,7 +37,8 @@ impl KeGroup for RistrettoPoint {
                     Scalar::from_bytes_mod_order_wide(&scalar_bytes)
                 }
 
-                // Tests need an exact conversion from bytes to scalar, sampling only 32 bytes from rng
+                // Tests need an exact conversion from bytes to scalar, sampling only 32 bytes
+                // from rng
                 #[cfg(test)]
                 {
                     let mut scalar_bytes = [0u8; 32];

src/key_exchange/group/x25519.rs

@@ -7,12 +7,14 @@
 
 //! Key Exchange group implementation for X25519
 
-use super::KeGroup;
-use crate::errors::InternalError;
-use generic_array::{typenum::U32, GenericArray};
+use generic_array::typenum::U32;
+use generic_array::GenericArray;
 use rand::{CryptoRng, RngCore};
 use x25519_dalek::{PublicKey, StaticSecret};
 
+use super::KeGroup;
+use crate::errors::InternalError;
+
 /// The implementation of such a subgroup for Ristretto
 impl KeGroup for PublicKey {
     type PkLen = U32;

src/key_exchange/mod.rs

@@ -5,8 +5,8 @@
 // License, Version 2.0 found in the LICENSE-APACHE file in the root directory
 // of this source tree.
 
-//! Includes instantiations of key exchange protocols used in the
-//! login step for OPAQUE
+//! Includes instantiations of key exchange protocols used in the login step for
+//! OPAQUE
 
 pub mod group;
 pub(crate) mod traits;

src/key_exchange/traits.rs

@@ -5,14 +5,6 @@
 // License, Version 2.0 found in the LICENSE-APACHE file in the root directory
 // of this source tree.
 
-use crate::hash::ProxyHash;
-use crate::key_exchange::group::KeGroup;
-use crate::{
-    ciphersuite::CipherSuite,
-    errors::ProtocolError,
-    hash::Hash,
-    keypair::{PrivateKey, PublicKey, SecretKey},
-};
 use digest::core_api::BlockSizeUser;
 use digest::Output;
 use generic_array::typenum::{IsLess, Le, NonZero, U256};
@@ -20,6 +12,12 @@ use generic_array::{ArrayLength, GenericArray};
 use rand::{CryptoRng, RngCore};
 use zeroize::Zeroize;
 
+use crate::ciphersuite::CipherSuite;
+use crate::errors::ProtocolError;
+use crate::hash::{Hash, ProxyHash};
+use crate::key_exchange::group::KeGroup;
+use crate::keypair::{PrivateKey, PublicKey, SecretKey};
+
 #[cfg(not(test))]
 pub type GenerateKe2Result<K, D, G> = (
     <K as KeyExchange<D, G>>::KE2State,

src/key_exchange/tripledh.rs

@@ -6,34 +6,29 @@
 // of this source tree.
 
 //! An implementation of the Triple Diffie-Hellman key exchange protocol
-use crate::{
-    errors::{
-        utils::{check_slice_size, check_slice_size_atleast},
-        InternalError, ProtocolError,
-    },
-    hash::{Hash, OutputSize, ProxyHash},
-    key_exchange::{
-        group::KeGroup,
-        traits::{FromBytes, GenerateKe2Result, GenerateKe3Result, KeyExchange, ToBytes},
-    },
-    keypair::{KeyPair, PrivateKey, PublicKey, SecretKey},
-    serialization::{Serialize, UpdateExt},
-};
 use core::convert::TryFrom;
 use core::ops::Add;
+
 use derive_where::DeriveWhere;
 use digest::core_api::BlockSizeUser;
 use digest::{Digest, Output};
 use generic_array::sequence::Concat;
-use generic_array::typenum::{IsLess, Le, NonZero, U256};
-use generic_array::{
-    typenum::{Sum, Unsigned, U1, U2, U32},
-    ArrayLength, GenericArray,
-};
+use generic_array::typenum::{IsLess, Le, NonZero, Sum, Unsigned, U1, U2, U256, U32};
+use generic_array::{ArrayLength, GenericArray};
 use hkdf::{Hkdf, HkdfExtract};
 use hmac::{Hmac, Mac};
 use rand::{CryptoRng, RngCore};
 
+use crate::errors::utils::{check_slice_size, check_slice_size_atleast};
+use crate::errors::{InternalError, ProtocolError};
+use crate::hash::{Hash, OutputSize, ProxyHash};
+use crate::key_exchange::group::KeGroup;
+use crate::key_exchange::traits::{
+    FromBytes, GenerateKe2Result, GenerateKe3Result, KeyExchange, ToBytes,
+};
+use crate::keypair::{KeyPair, PrivateKey, PublicKey, SecretKey};
+use crate::serialization::{Serialize, UpdateExt};
+
 ///////////////
 // Constants //
 // ========= //
@@ -363,8 +358,9 @@ type TripleDHDerivationResult<D> = (Output<D>, Output<D>, Output<D>, Output<D>);
 
 // Helper functions
 
-// Internal function which takes the public and private components of the client and server keypairs, along
-// with some auxiliary metadata, to produce the session key and two MAC keys
+// Internal function which takes the public and private components of the client
+// and server keypairs, along with some auxiliary metadata, to produce the
+// session key and two MAC keys
 fn derive_3dh_keys<D: Hash, KG: KeGroup, S: SecretKey<KG>>(
     dh: TripleDHComponents<KG, S>,
     hashed_derivation_transcript: &[u8],