cargo fmt

Author: coderdan

src/crypto/attrs/flattened_encrypted_attributes.rs

@@ -1,6 +1,14 @@
-use cipherstash_client::{credentials::{service_credentials::ServiceToken, Credentials}, encryption::{Encryption, EncryptionError}, zero_kms::EncryptedRecord};
+use crate::{
+    crypto::{attrs::flattened_protected_attributes::FlattenedAttrName, SealError},
+    encrypted_table::TableAttributes,
+    traits::TableAttribute,
+};
+use cipherstash_client::{
+    credentials::{service_credentials::ServiceToken, Credentials},
+    encryption::{Encryption, EncryptionError},
+    zero_kms::EncryptedRecord,
+};
 use itertools::Itertools;
-use crate::{crypto::{attrs::flattened_protected_attributes::FlattenedAttrName, SealError}, encrypted_table::TableAttributes, traits::TableAttribute};
 
 use super::FlattenedProtectedAttributes;
 
@@ -14,7 +22,9 @@ pub(crate) struct FlattenedEncryptedAttributes {
 
 impl FlattenedEncryptedAttributes {
     pub(crate) fn with_capacity(capacity: usize) -> Self {
-        Self { attrs: Vec::with_capacity(capacity) }
+        Self {
+            attrs: Vec::with_capacity(capacity),
+        }
     }
 
     pub(crate) fn is_empty(&self) -> bool {
@@ -32,17 +42,16 @@ impl FlattenedEncryptedAttributes {
         self,
         cipher: &Encryption<impl Credentials<Token = ServiceToken>>,
     ) -> Result<FlattenedProtectedAttributes, SealError> {
-        let descriptors = self.attrs.iter().map(|record| record.descriptor.clone()).collect_vec();
+        let descriptors = self
+            .attrs
+            .iter()
+            .map(|record| record.descriptor.clone())
+            .collect_vec();
 
         cipher
             .decrypt(self.attrs.into_iter())
             .await
-            .map(|records| {
-                records
-                    .into_iter()
-                    .zip(descriptors.into_iter())
-                    .collect()
-            })
+            .map(|records| records.into_iter().zip(descriptors.into_iter()).collect())
             .map_err(SealError::from)
     }
 
@@ -58,37 +67,42 @@ impl FlattenedEncryptedAttributes {
                     .map(|data| (FlattenedAttrName::parse(&record.descriptor), data))
                     .map_err(EncryptionError::from)
             })
-            .fold_ok(Ok(TableAttributes::new()), |acc, (flattened_attr_name, bytes)| {
-                let (name, subkey) = flattened_attr_name.into_parts();
-                if let Some(subkey) = subkey {
-                    acc
-                    .and_then(|mut acc| acc
-                        .try_insert_map(name, subkey, bytes)
-                        .map(|_| acc))
-                } else {
-                    acc.map(|mut acc| {
-                        acc.insert(name, bytes);
-                        acc
-                    })
-                }
-            })?
+            .fold_ok(
+                Ok(TableAttributes::new()),
+                |acc, (flattened_attr_name, bytes)| {
+                    let (name, subkey) = flattened_attr_name.into_parts();
+                    if let Some(subkey) = subkey {
+                        acc.and_then(|mut acc| acc.try_insert_map(name, subkey, bytes).map(|_| acc))
+                    } else {
+                        acc.map(|mut acc| {
+                            acc.insert(name, bytes);
+                            acc
+                        })
+                    }
+                },
+            )?
     }
 
     // TODO: Test this
     /// Normalize the TableAttributes into a set of encrypted records.
     /// An error will be returned if the TableAttributes contain an unsupported attribute type
     /// (only `Bytes` and `Map` are currently supported).
-    /// 
+    ///
     /// Bytes data is converted to an [EncryptedRecord] using [TableAttribute::as_encrypted_record]
     /// which validates that the descriptor matches the key and subkey.
-    /// 
+    ///
     /// This method is used during decrypt and load operations.
-    pub(crate) fn try_extend(&mut self, attributes: TableAttributes, prefix: String) -> Result<(), SealError> {
+    pub(crate) fn try_extend(
+        &mut self,
+        attributes: TableAttributes,
+        prefix: String,
+    ) -> Result<(), SealError> {
         for (name, value) in attributes.into_iter() {
             match value {
                 TableAttribute::Map(map) => {
                     for (subkey, value) in map.into_iter() {
-                        let attr_key = FlattenedAttrName::new(Some(prefix.clone()), name.clone()).with_subkey(subkey);
+                        let attr_key = FlattenedAttrName::new(Some(prefix.clone()), name.clone())
+                            .with_subkey(subkey);
                         // Load the bytes and check for a confused deputy attack
                         let record = value.as_encrypted_record(&attr_key.descriptor())?;
                         self.attrs.push(record);
@@ -101,7 +115,9 @@ impl FlattenedEncryptedAttributes {
                     self.attrs.push(record);
                 }
                 _ => {
-                    Err(SealError::AssertionFailed("Unsupported attribute type".to_string()))?;
+                    Err(SealError::AssertionFailed(
+                        "Unsupported attribute type".to_string(),
+                    ))?;
                 }
             }
         }
@@ -118,6 +134,8 @@ impl From<Vec<EncryptedRecord>> for FlattenedEncryptedAttributes {
 
 impl FromIterator<EncryptedRecord> for FlattenedEncryptedAttributes {
     fn from_iter<T: IntoIterator<Item = EncryptedRecord>>(iter: T) -> Self {
-        Self { attrs: iter.into_iter().collect() }
+        Self {
+            attrs: iter.into_iter().collect(),
+        }
     }
-}
+}

src/crypto/attrs/flattened_protected_attributes.rs

@@ -1,5 +1,6 @@
 use super::{
-    flattened_encrypted_attributes::FlattenedEncryptedAttributes, normalized_protected_attributes::NormalizedKey
+    flattened_encrypted_attributes::FlattenedEncryptedAttributes,
+    normalized_protected_attributes::NormalizedKey,
 };
 use crate::{crypto::SealError, encrypted_table::AttributeName};
 use cipherstash_client::{
@@ -56,7 +57,11 @@ impl Extend<FlattenedProtectedAttribute> for FlattenedProtectedAttributes {
 /// Allows us to collect a list of (Plaintext, String) tuples into a [FlattenedProtectedAttributes] object.
 impl FromIterator<(Plaintext, String)> for FlattenedProtectedAttributes {
     fn from_iter<T: IntoIterator<Item = (Plaintext, String)>>(iter: T) -> Self {
-        Self(iter.into_iter().map(|(plaintext, key)| FlattenedProtectedAttribute::new(plaintext, key)).collect())
+        Self(
+            iter.into_iter()
+                .map(|(plaintext, key)| FlattenedProtectedAttribute::new(plaintext, key))
+                .collect(),
+        )
     }
 }
 
@@ -130,8 +135,14 @@ impl FlattenedAttrName {
     /// Prefix is discarded as it is not needed after decryption.
     pub(super) fn normalize(self) -> (NormalizedKey, Option<String>) {
         match self.subkey {
-            Some(_) => (NormalizedKey::new_map(self.name.as_external_name()), self.subkey),
-            None => (NormalizedKey::new_scalar(self.name.as_external_name()), None),
+            Some(_) => (
+                NormalizedKey::new_map(self.name.as_external_name()),
+                self.subkey,
+            ),
+            None => (
+                NormalizedKey::new_scalar(self.name.as_external_name()),
+                None,
+            ),
         }
     }
 
@@ -157,7 +168,9 @@ impl FlattenedAttrName {
 
     pub(crate) fn descriptor(&self) -> String {
         match (self.prefix.as_ref(), self.subkey.as_ref()) {
-            (Some(prefix), Some(subkey)) => format!("{}/{}.{}", prefix, self.name.as_stored_name(), subkey),
+            (Some(prefix), Some(subkey)) => {
+                format!("{}/{}.{}", prefix, self.name.as_stored_name(), subkey)
+            }
             (Some(prefix), None) => format!("{}/{}", prefix, self.name.as_stored_name()),
             (None, Some(subkey)) => format!("{}.{}", self.name.as_stored_name(), subkey),
             (None, None) => self.name.as_stored_name().to_string(),
@@ -222,7 +235,9 @@ mod tests {
             "pref/foo"
         );
         assert_eq!(
-            FlattenedAttrName::new(None, "foo").with_subkey("x").descriptor(),
+            FlattenedAttrName::new(None, "foo")
+                .with_subkey("x")
+                .descriptor(),
             "foo.x"
         );
         assert_eq!(
@@ -325,8 +340,17 @@ mod tests {
     #[test]
     fn test_flattened_key_parse() {
         assert_eq!(FlattenedAttrName::parse("key"), "key".into());
-        assert_eq!(FlattenedAttrName::parse("prefix/key"), ("prefix", "key").into());
-        assert_eq!(FlattenedAttrName::parse("key.subkey"), FlattenedAttrName::from("key").with_subkey("subkey"));
-        assert_eq!(FlattenedAttrName::parse("prefix/key.subkey"), FlattenedAttrName::from(("prefix", "key")).with_subkey("subkey"));
+        assert_eq!(
+            FlattenedAttrName::parse("prefix/key"),
+            ("prefix", "key").into()
+        );
+        assert_eq!(
+            FlattenedAttrName::parse("key.subkey"),
+            FlattenedAttrName::from("key").with_subkey("subkey")
+        );
+        assert_eq!(
+            FlattenedAttrName::parse("prefix/key.subkey"),
+            FlattenedAttrName::from(("prefix", "key")).with_subkey("subkey")
+        );
     }
 }

src/crypto/attrs/mod.rs

@@ -1,6 +1,6 @@
 mod flattened_encrypted_attributes;
 mod flattened_protected_attributes;
 mod normalized_protected_attributes;
+pub(crate) use flattened_encrypted_attributes::FlattenedEncryptedAttributes;
 pub(crate) use flattened_protected_attributes::FlattenedProtectedAttributes;
 pub(crate) use normalized_protected_attributes::NormalizedProtectedAttributes;
-pub(crate) use flattened_encrypted_attributes::FlattenedEncryptedAttributes;

src/crypto/attrs/normalized_protected_attributes.rs

@@ -1,8 +1,8 @@
-use std::collections::HashMap;
-use cipherstash_client::encryption::Plaintext;
 use super::flattened_protected_attributes::{
     FlattenedAttrName, FlattenedProtectedAttribute, FlattenedProtectedAttributes,
 };
+use cipherstash_client::encryption::Plaintext;
+use std::collections::HashMap;
 
 // FIXME: Remove this (only used for debugging)
 #[derive(Debug)]
@@ -87,14 +87,16 @@ impl NormalizedProtectedAttributes {
 impl FromIterator<(NormalizedKey, NormalizedValue)> for NormalizedProtectedAttributes {
     fn from_iter<T: IntoIterator<Item = (NormalizedKey, NormalizedValue)>>(iter: T) -> Self {
         let values = iter.into_iter().collect();
-        Self { values, prefix: None }
+        Self {
+            values,
+            prefix: None,
+        }
     }
 }
 
 impl FromIterator<FlattenedProtectedAttribute> for NormalizedProtectedAttributes {
     fn from_iter<T: IntoIterator<Item = FlattenedProtectedAttribute>>(iter: T) -> Self {
-        iter
-            .into_iter()
+        iter.into_iter()
             .fold(Self::new(), |mut acc, fpa| {
                 match fpa.normalize_into_parts() {
                     (plaintext, key, Some(subkey)) => {
@@ -104,7 +106,7 @@ impl FromIterator<FlattenedProtectedAttribute> for NormalizedProtectedAttributes
                         acc.insert(key, plaintext);
                     }
                 }
-                acc 
+                acc
             })
             .into()
     }

src/crypto/mod.rs

@@ -3,7 +3,6 @@ mod b64_encode;
 mod sealed;
 mod sealer;
 mod unsealed;
-use std::borrow::Cow;
 use crate::{
     traits::{PrimaryKeyError, PrimaryKeyParts, ReadConversionError, WriteConversionError},
     Identifiable, IndexType, PrimaryKey,
@@ -13,9 +12,11 @@ use cipherstash_client::{
     encryption::{
         compound_indexer::{CompoundIndex, ExactIndex},
         Encryption, EncryptionError, Plaintext, TypeParseError,
-    }, vitur_client::DecryptError,
+    },
+    vitur_client::DecryptError,
 };
 use miette::Diagnostic;
+use std::borrow::Cow;
 use thiserror::Error;
 
 // Re-exports

src/crypto/sealed.rs

@@ -1,5 +1,8 @@
 use crate::{
-    crypto::attrs::FlattenedEncryptedAttributes, encrypted_table::TableEntry, traits::{ReadConversionError, WriteConversionError}, Decryptable, Identifiable
+    crypto::attrs::FlattenedEncryptedAttributes,
+    encrypted_table::TableEntry,
+    traits::{ReadConversionError, WriteConversionError},
+    Decryptable, Identifiable,
 };
 use aws_sdk_dynamodb::{primitives::Blob, types::AttributeValue};
 use cipherstash_client::{
@@ -31,10 +34,16 @@ pub struct UnsealSpec<'a> {
 }
 
 impl UnsealSpec<'static> {
-    pub fn new_for_decryptable<D>() -> Self where D: Decryptable + Identifiable {
+    pub fn new_for_decryptable<D>() -> Self
+    where
+        D: Decryptable + Identifiable,
+    {
         Self {
             protected_attributes: D::protected_attributes(),
-            sort_key_prefix: D::sort_key_prefix().as_deref().map(ToOwned::to_owned).unwrap_or(D::type_name().to_string()),
+            sort_key_prefix: D::sort_key_prefix()
+                .as_deref()
+                .map(ToOwned::to_owned)
+                .unwrap_or(D::type_name().to_string()),
         }
     }
 }
@@ -69,7 +78,6 @@ impl SealedTableEntry {
         spec: UnsealSpec<'_>,
         cipher: &Encryption<impl Credentials<Token = ServiceToken>>,
     ) -> Result<Vec<Unsealed>, SealError> {
-
         let UnsealSpec {
             protected_attributes,
             sort_key_prefix,
@@ -96,7 +104,10 @@ impl SealedTableEntry {
                 .into_iter()
                 .map(|unprotected| {
                     // TODO: Create a new_from_unprotected method
-                    Ok(Unsealed::new_from_parts(NormalizedProtectedAttributes::new(), unprotected))
+                    Ok(Unsealed::new_from_parts(
+                        NormalizedProtectedAttributes::new(),
+                        unprotected,
+                    ))
                 })
                 .collect()
         } else {
@@ -113,9 +124,7 @@ impl SealedTableEntry {
                 .map(|fpa| fpa.into_iter().collect::<NormalizedProtectedAttributes>())
                 .into_iter()
                 .zip_eq(unprotected_items.into_iter())
-                .map(|(fpa, unprotected)| {
-                    Ok(Unsealed::new_from_parts(fpa, unprotected))
-                })
+                .map(|(fpa, unprotected)| Ok(Unsealed::new_from_parts(fpa, unprotected)))
                 .collect()
         }
     }
@@ -190,10 +199,7 @@ impl TryFrom<SealedTableEntry> for HashMap<String, AttributeValue> {
         }
 
         item.0.attributes.into_iter().for_each(|(k, v)| {
-            map.insert(
-                k.into_stored_name(),
-                v.into(),
-            );
+            map.insert(k.into_stored_name(), v.into());
         });
 
         Ok(map)