Merge pull request #146 from Cosmian/fix/fmt

Format repository

benches/benches.rs

@@ -1,5 +1,5 @@
-use cosmian_cover_crypt::{AccessPolicy, api::Covercrypt, cc_keygen, traits::KemAc};
-use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
+use cosmian_cover_crypt::{api::Covercrypt, cc_keygen, traits::KemAc, AccessPolicy};
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 
 const C_ENC_APS: [(&str, usize); 5] = [
     ("SEC::LOW && (DPT::MKG) ", 1),

examples/decrypt.rs

@@ -6,12 +6,12 @@ const HEADER: &str = "/m73Gzm5LhMZmNEpFubAuQJUu3QzyOH1fJCrJynNWprMuzGViQ1nlE6v11
 
 fn main() {
     use base64::{
-        Engine,
         alphabet::STANDARD,
         engine::{GeneralPurpose, GeneralPurposeConfig},
+        Engine,
     };
-    use cosmian_cover_crypt::UserSecretKey;
     use cosmian_cover_crypt::api::Covercrypt;
+    use cosmian_cover_crypt::UserSecretKey;
     use cosmian_crypto_core::bytes_ser_de::Serializable;
 
     let config: GeneralPurposeConfig = GeneralPurposeConfig::default();

examples/encrypt.rs

@@ -1,5 +1,5 @@
 use cosmian_cover_crypt::{
-    AccessPolicy, EncryptedHeader, MasterPublicKey, MasterSecretKey, api::Covercrypt,
+    api::Covercrypt, AccessPolicy, EncryptedHeader, MasterPublicKey, MasterSecretKey,
 };
 
 /// Generates a new USK and encrypted header and prints them.
@@ -12,9 +12,9 @@ fn generate_new(cc: &Covercrypt, _msk: &mut MasterSecretKey, mpk: &MasterPublicK
 
     {
         use base64::{
-            Engine,
             alphabet::STANDARD,
             engine::{GeneralPurpose, GeneralPurposeConfig},
+            Engine,
         };
 
         use cosmian_crypto_core::bytes_ser_de::Serializable;

examples/runme.rs

@@ -1,6 +1,6 @@
 //! This is the demo given in `README.md` and `lib.rs`
 
-use cosmian_cover_crypt::{AccessPolicy, EncryptedHeader, api::Covercrypt, test_utils::cc_keygen};
+use cosmian_cover_crypt::{api::Covercrypt, test_utils::cc_keygen, AccessPolicy, EncryptedHeader};
 
 fn main() {
     let cc = Covercrypt::default();
@@ -31,23 +31,19 @@ fn main() {
         EncryptedHeader::generate(&cc, &mpk, &enc_policy, None, None).unwrap();
 
     // user cannot decrypt the newly encrypted header
-    assert!(
-        new_encrypted_header
-            .decrypt(&cc, &usk, None)
-            .unwrap()
-            .is_none()
-    );
+    assert!(new_encrypted_header
+        .decrypt(&cc, &usk, None)
+        .unwrap()
+        .is_none());
 
     // refresh user secret key, do not grant old encryption access
     cc.refresh_usk(&mut msk, &mut usk, false).unwrap();
 
     // The user with refreshed key is able to decrypt the newly encrypted header.
-    assert!(
-        new_encrypted_header
-            .decrypt(&cc, &usk, None)
-            .unwrap()
-            .is_some()
-    );
+    assert!(new_encrypted_header
+        .decrypt(&cc, &usk, None)
+        .unwrap()
+        .is_some());
 
     // But it cannot decrypt old ciphertexts
     assert!(encrypted_header.decrypt(&cc, &usk, None).unwrap().is_none());

src/abe_policy/access_policy.rs

@@ -10,7 +10,7 @@ use std::{
     ops::{BitAnd, BitOr},
 };
 
-use crate::{Error, abe_policy::QualifiedAttribute};
+use crate::{abe_policy::QualifiedAttribute, Error};
 
 /// An access policy is a boolean expression of qualified attributes.
 #[derive(Debug, Clone, PartialEq, Eq)]

src/abe_policy/access_structure.rs

@@ -1,12 +1,12 @@
-use std::collections::{HashMap, HashSet, hash_map::Entry};
+use std::collections::{hash_map::Entry, HashMap, HashSet};
 
 use crate::{
-    Error,
     abe_policy::{
         AccessPolicy, Attribute, AttributeStatus, Dimension, EncryptionHint, QualifiedAttribute,
         Right,
     },
     data_struct::Dict,
+    Error,
 };
 
 use super::Version;
@@ -351,7 +351,7 @@ mod serialization {
 
     use super::*;
     use cosmian_crypto_core::bytes_ser_de::{
-        Deserializer, Serializable, Serializer, to_leb128_len,
+        to_leb128_len, Deserializer, Serializable, Serializer,
     };
 
     impl Serializable for AccessStructure {

src/abe_policy/dimension.rs

@@ -1,12 +1,12 @@
 use std::{
-    collections::{HashMap, hash_map::Entry},
+    collections::{hash_map::Entry, HashMap},
     fmt::Debug,
 };
 
 use serde::{Deserialize, Serialize};
 
-use super::{AttributeStatus, attribute::EncryptionHint};
-use crate::{Error, data_struct::Dict};
+use super::{attribute::EncryptionHint, AttributeStatus};
+use crate::{data_struct::Dict, Error};
 
 type Name = String;
 
@@ -240,7 +240,7 @@ impl Dimension {
 
 mod serialization {
     use cosmian_crypto_core::bytes_ser_de::{
-        Deserializer, Serializable, Serializer, to_leb128_len,
+        to_leb128_len, Deserializer, Serializable, Serializer,
     };
 
     use super::*;

src/abe_policy/rights.rs

@@ -1,4 +1,4 @@
-use cosmian_crypto_core::bytes_ser_de::{Deserializer, Serializable, Serializer, to_leb128_len};
+use cosmian_crypto_core::bytes_ser_de::{to_leb128_len, Deserializer, Serializable, Serializer};
 use std::{hash::Hash, ops::Deref};
 
 use crate::Error;

src/abe_policy/tests.rs

@@ -1,4 +1,4 @@
-use crate::{Error, abe_policy::AccessStructure};
+use crate::{abe_policy::AccessStructure, Error};
 
 use super::EncryptionHint;
 
@@ -77,21 +77,17 @@ fn test_edit_anarchic_attributes() {
     assert_eq!(structure.attributes().count(), 7);
 
     // Try renaming Research to already used name MKG
-    assert!(
-        structure
-            .rename_attribute(&QualifiedAttribute::new("DPT", "RD"), "MKG".to_string(),)
-            .is_err()
-    );
+    assert!(structure
+        .rename_attribute(&QualifiedAttribute::new("DPT", "RD"), "MKG".to_string(),)
+        .is_err());
 
     // Rename RD to Research
-    assert!(
-        structure
-            .rename_attribute(
-                &QualifiedAttribute::new("DPT", "RD"),
-                "Research".to_string(),
-            )
-            .is_ok()
-    );
+    assert!(structure
+        .rename_attribute(
+            &QualifiedAttribute::new("DPT", "RD"),
+            "Research".to_string(),
+        )
+        .is_ok());
 
     let order: Vec<_> = structure
         .attributes()
@@ -103,28 +99,22 @@ fn test_edit_anarchic_attributes() {
 
     // Add new attribute Sales
     let new_attr = QualifiedAttribute::new("DPT", "Sales");
-    assert!(
-        structure
-            .add_attribute(new_attr.clone(), EncryptionHint::Classic, None)
-            .is_ok()
-    );
+    assert!(structure
+        .add_attribute(new_attr.clone(), EncryptionHint::Classic, None)
+        .is_ok());
     assert_eq!(structure.attributes().count(), 8);
 
     // Try adding already existing attribute HR
     let duplicate_attr = QualifiedAttribute::new("DPT", "HR");
-    assert!(
-        structure
-            .add_attribute(duplicate_attr, EncryptionHint::Classic, None)
-            .is_err()
-    );
+    assert!(structure
+        .add_attribute(duplicate_attr, EncryptionHint::Classic, None)
+        .is_err());
 
     // Try adding attribute to non existing dimension
     let missing_dimension = QualifiedAttribute::new("Missing", "dimension");
-    assert!(
-        structure
-            .add_attribute(missing_dimension.clone(), EncryptionHint::Classic, None)
-            .is_err()
-    );
+    assert!(structure
+        .add_attribute(missing_dimension.clone(), EncryptionHint::Classic, None)
+        .is_err());
 
     // Remove research attribute
     let delete_attr = QualifiedAttribute::new("DPT", "Research");
@@ -201,11 +191,9 @@ fn test_edit_hierarchic_attributes() {
     );
 
     // Rename ordered dimension
-    assert!(
-        structure
-            .rename_attribute(&QualifiedAttribute::new("SEC", "LOW"), "WOL".to_string(),)
-            .is_ok()
-    );
+    assert!(structure
+        .rename_attribute(&QualifiedAttribute::new("SEC", "LOW"), "WOL".to_string(),)
+        .is_ok());
 
     let order = structure.attributes().map(|q| q.name).collect::<Vec<_>>();
     assert!(order.contains(&"WOL".to_string()));

src/ae.rs

@@ -1,10 +1,10 @@
 use cosmian_crypto_core::{
-    Aes256Gcm, Dem, FixedSizeCBytes, Instantiable, Nonce, RandomFixedSizeCBytes, SymmetricKey,
-    reexport::rand_core::CryptoRngCore,
+    reexport::rand_core::CryptoRngCore, Aes256Gcm, Dem, FixedSizeCBytes, Instantiable, Nonce,
+    RandomFixedSizeCBytes, SymmetricKey,
 };
 use zeroize::Zeroizing;
 
-use crate::{Error, traits::AE};
+use crate::{traits::AE, Error};
 
 impl AE<{ Self::KEY_LENGTH }> for Aes256Gcm {
     type Error = Error;

src/api.rs

@@ -1,20 +1,20 @@
 use std::sync::{Mutex, MutexGuard};
 
-use cosmian_crypto_core::{CsRng, Secret, SymmetricKey, kdf256, reexport::rand_core::SeedableRng};
+use cosmian_crypto_core::{kdf256, reexport::rand_core::SeedableRng, CsRng, Secret, SymmetricKey};
 use zeroize::Zeroizing;
 
 use super::{
-    core::MIN_TRACING_LEVEL,
     core::primitives::{prune, update_msk, usk_keygen},
+    core::MIN_TRACING_LEVEL,
     traits::AE,
 };
 use crate::{
-    AccessPolicy, Error,
     core::{
-        MasterPublicKey, MasterSecretKey, SHARED_SECRET_LENGTH, UserSecretKey, XEnc,
         primitives::{decaps, encaps, full_decaps, refresh, rekey, setup},
+        MasterPublicKey, MasterSecretKey, UserSecretKey, XEnc, SHARED_SECRET_LENGTH,
     },
     traits::{KemAc, PkeAc},
+    AccessPolicy, Error,
 };
 #[derive(Debug)]
 pub struct Covercrypt {

src/core/kem.rs

@@ -1,14 +1,14 @@
 use cosmian_crypto_core::bytes_ser_de::{Deserializer, Serializable, Serializer};
-use cosmian_crypto_core::{Secret, reexport::rand_core::CryptoRngCore};
+use cosmian_crypto_core::{reexport::rand_core::CryptoRngCore, Secret};
 use ml_kem::{
-    EncodedSizeUser, KemCore,
     array::Array,
     kem::{Decapsulate, Encapsulate},
+    EncodedSizeUser, KemCore,
 };
 use zeroize::Zeroize;
 
 use crate::traits::Kem;
-use crate::{Error, core::SHARED_SECRET_LENGTH};
+use crate::{core::SHARED_SECRET_LENGTH, Error};
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct EncapsulationKey512(Box<<ml_kem::MlKem512 as KemCore>::EncapsulationKey>);
@@ -135,7 +135,7 @@ impl Kem for MlKem512 {
 #[cfg(test)]
 mod tests {
     use cosmian_crypto_core::{
-        CsRng, bytes_ser_de::test_serialization, reexport::rand_core::SeedableRng,
+        bytes_ser_de::test_serialization, reexport::rand_core::SeedableRng, CsRng,
     };
 
     use super::*;

src/core/mod.rs

@@ -5,13 +5,13 @@ use std::{
     hash::Hash,
 };
 
-use cosmian_crypto_core::{SymmetricKey, reexport::rand_core::CryptoRngCore};
+use cosmian_crypto_core::{reexport::rand_core::CryptoRngCore, SymmetricKey};
 
 use crate::{
-    Error,
     abe_policy::{AccessStructure, Right},
     data_struct::{RevisionMap, RevisionVec},
     traits::{Kem, Nike},
+    Error,
 };
 
 mod kem;

src/core/nike.rs

@@ -3,9 +3,9 @@ use cosmian_crypto_core::reexport::rand_core::CryptoRngCore;
 pub use cosmian_crypto_core::R25519PrivateKey as Scalar;
 pub use cosmian_crypto_core::R25519PublicKey as EcPoint;
 
-use crate::Error;
 use crate::traits::KhNike;
 use crate::traits::Nike;
+use crate::Error;
 
 pub struct R25519;
 
@@ -36,7 +36,7 @@ impl KhNike<Scalar, EcPoint> for R25519 {}
 #[cfg(test)]
 mod tests {
     use cosmian_crypto_core::{
-        CsRng, bytes_ser_de::test_serialization, reexport::rand_core::SeedableRng,
+        bytes_ser_de::test_serialization, reexport::rand_core::SeedableRng, CsRng,
     };
 
     use super::*;