Clean up and refactoring

Author: coderdan

src/crypto/sealed.rs

@@ -17,6 +17,7 @@ use super::{attrs::NormalizedProtectedAttributes, SealError, Unsealed};
 /// Wrapped to indicate that the value is encrypted
 pub struct SealedTableEntry(pub(super) TableEntry);
 
+// TODO: Remove this
 pub struct UnsealSpec<'a> {
     pub protected_attributes: Cow<'a, [Cow<'a, str>]>,
     pub plaintext_attributes: Cow<'a, [Cow<'a, str>]>,
@@ -95,7 +96,7 @@ impl SealedTableEntry {
         } else {
             let chunk_size = protected_items.len() / unprotected_items.len();
 
-            let r1 = protected_items
+            protected_items
                 .decrypt_all(cipher)
                 .await?
                 .into_iter()
@@ -104,82 +105,13 @@ impl SealedTableEntry {
                 .chunks(chunk_size)
                 .into_iter()
                 .map(|fpa| fpa.into_iter().collect::<NormalizedProtectedAttributes>())
-                .collect_vec();
-
-            dbg!(&r1);
-
-            let r = r1
                 .into_iter()
                 .zip_eq(unprotected_items.into_iter())
                 .map(|(fpa, unprotected)| {
-                    Unsealed::new_from_parts(fpa, unprotected)
+                    Ok(Unsealed::new_from_parts(fpa, unprotected))
                 })
-                .collect();
-
-            Ok(r)
-        }
-
-        /*  
-            let unprotected = unprotected
-                .into_iter()
-                .map(|(name, attribute)| {
-                    /*let attr = match name.deref() {
-                        "sk" => "__sk",
-                        _ => name,
-                    };
-
-                    attributes.get(attr)*/
-                    attribute
-                })
-                .collect::<Vec<TableAttribute>>();
-
-            unprotected_items.push(unprotected);
+                .collect()
         }
-
-        //let decrypted = async_map_somes(decryptable_items, |items| cipher.decrypt(items)).await?;
-        let decrypted = cipher.decrypt(protected_items).await?;
-        //let mut default_iter =
-        //    std::iter::repeat_with::<Plaintext, _>(|| &[]).take(plaintext_items.len());
-        //std::iter::repeat_with::<&[Option<Plaintext>], _>(|| &[]).take(plaintext_items.len());
-
-        /*let mut chunks_exact;
-        //let decrypted_iter: &mut dyn Iterator<Item = &[Option<Plaintext>]> =
-        let decrypted_iter: &mut dyn Iterator<Item = Plaintext> =
-            if protected_attributes.len() > 0 {
-                chunks_exact = decrypted.chunks_exact(protected_attributes.len());
-                &mut chunks_exact
-            } else {
-                &mut default_iter
-            };*/
-
-        // TODO: Handle if protected_attributes is empty
-        let unsealed = decrypted
-            .into_iter()
-            .chunks(protected_attributes.len())
-            .into_iter()
-            .zip(unprotected_items.into_iter())
-            .map(|(decrypted, plaintext_items)| {
-                let mut unsealed = Unsealed::new();
-
-                //println!("----->> EEEE {:?} {:?}", protected_attributes, decrypted);
-
-                for (name, plaintext) in decryptable_names.iter().zip(decrypted) {
-                    println!("DECRYPT: Inserting protected attribute: {}", name);
-                    unsealed.add_protected(name.to_string(), plaintext);
-                }
-
-                for (name, plaintext) in
-                    plaintext_attributes.iter().zip(plaintext_items.into_iter())
-                {
-                    unsealed.add_unprotected(name.to_string(), plaintext.clone());
-                }
-
-                unsealed
-            })
-            .collect::<Vec<_>>();
-
-        dbg!(&unsealed);
-        Ok(unsealed)*/
     }
 
     /// Unseal the current value and return it's plaintext representation
@@ -208,7 +140,6 @@ impl TryFrom<HashMap<String, AttributeValue>> for SealedTableEntry {
     type Error = ReadConversionError;
 
     fn try_from(item: HashMap<String, AttributeValue>) -> Result<Self, Self::Error> {
-        // FIXME: pk and sk should be AttributeValue and term
         let pk = item
             .get("pk")
             .ok_or(ReadConversionError::NoSuchAttribute("pk".to_string()))?
@@ -250,12 +181,7 @@ impl TryFrom<SealedTableEntry> for HashMap<String, AttributeValue> {
         }
 
         item.0.attributes.into_iter().for_each(|(k, v)| {
-            // FIXME: Why would "sk" ever be in the attributes?
             map.insert(
-                /*match k.as_str() {
-                    "sk" => "__sk".to_string(),
-                    _ => k,
-                },*/
                 k,
                 v.into(),
             );

src/crypto/sealer.rs

@@ -49,7 +49,6 @@ struct RecordsWithTerms<'a> {
 
 impl<'a> RecordsWithTerms<'a> {
     fn new(records: Vec<RecordWithTerms<'a>>, num_protected_attributes: usize) -> Self {
-        println!("Creating RecordsWithTerms with {} protected attrs", num_protected_attributes);
         Self {
             num_protected_attributes,
             records,
@@ -93,14 +92,8 @@ impl<'a> RecordsWithTerms<'a> {
                 .collect()
 
         } else {
-            println!("Protecteds before encryption: {:?}", protected);
             let encrypted = protected.encrypt_all(cipher, num_records).await?;
 
-            println!("Encrypted len = {}", encrypted.len());
-            println!("Unprotected len = {}", unprotecteds.len());
-            println!("Encrypted: {:?}", encrypted);
-            println!("Unprotected: {:?}", unprotecteds);
-
             encrypted
                 .into_iter()
                 .zip_eq(unprotecteds.into_iter())
@@ -235,124 +228,6 @@ impl Sealer {
         Self::index_all_terms(records, protected_attributes, cipher, term_length)?
             .encrypt(cipher)
             .await
-        /*let records = records.into_iter();
-        let records_len = records.size_hint().1.unwrap_or(1);
-
-        let protected_attributes = protected_attributes.as_ref();
-
-        let mut protected = Vec::with_capacity(records_len * protected_attributes.len());
-        let mut table_entries = Vec::with_capacity(records_len);
-
-        for mut record in records {
-            let mut pk = record.pk;
-            let mut sk = record.sk;
-
-            if record.is_pk_encrypted {
-                pk = b64_encode(hmac(&pk, None, cipher)?);
-            }
-
-            if record.is_sk_encrypted {
-                sk = b64_encode(hmac(&sk, Some(pk.as_str()), cipher)?);
-            }
-
-            let type_name = &record.type_name;
-
-            for attr in protected_attributes.iter() {
-                protected.extend(record.unsealed.remove_protected_with_descriptor(attr)?);
-            }
-
-            let terms: Vec<(Cow<'_, str>, IndexType, Vec<u8>)> = record
-                .unsealed_indexes
-                .into_iter()
-                .map(|(attr, index, index_name, index_type)| {
-                    let term = cipher.compound_index(
-                        &CompoundIndex::new(index),
-                        attr,
-                        Some(format!("{}#{}", type_name, index_name)),
-                        term_length,
-                    )?;
-
-                    Ok::<_, SealError>((index_name, index_type, term))
-                })
-                .map(|index_term| match index_term {
-                    Ok((index_name, index_type, IndexTerm::Binary(x))) => {
-                        Ok(vec![(index_name, index_type, x)])
-                    }
-                    Ok((index_name, index_type, IndexTerm::BinaryVec(x))) => Ok(x
-                        .into_iter()
-                        .take(MAX_TERMS_PER_INDEX)
-                        .map(|x| (index_name.clone(), index_type, x))
-                        .collect()),
-                    _ => Err(SealError::InvalidCiphertext("Invalid index term".into())),
-                })
-                .flatten_ok()
-                .try_collect()?;
-
-            table_entries.push((
-                PrimaryKeyParts { pk, sk },
-                record.unsealed.unprotected().clone(),
-                terms,
-            ));
-        }
-
-        // Only encrypt if there are actually protected attributes
-        if !protected_attributes.is_empty() {
-            let encrypted = cipher
-                .encrypt(protected.iter().map(|(a, b)| (a, b.as_str())))
-                .await?;
-
-            for (encrypted, (_, attributes, _)) in encrypted
-                .chunks_exact(protected.len())
-                .zip(table_entries.iter_mut())
-            {
-                for (enc, name) in encrypted.iter().zip(protected.iter()) {
-                    let name: &str = name.1.deref();
-
-                    println!("Inserting protected attribute: {}", name);
-
-                    attributes.insert(
-                        String::from(match name {
-                            // TODO: Possibly reinstate or move this
-                            //"pk" => "__pk",
-                            //"sk" => "__sk",
-                            _ => name,
-                        }),
-                        TableAttribute::Bytes(enc.to_vec().map_err(|_| {
-                            SealError::InvalidCiphertext(
-                                "Failed to serialize encrypted record as bytes".into(),
-                            )
-                        })?),
-                    );
-                }
-            }
-        }
-
-        let mut output = Vec::with_capacity(table_entries.len());
-
-        for (PrimaryKeyParts { pk, sk }, attributes, terms) in table_entries.into_iter() {
-            let terms = terms
-                .into_iter()
-                .enumerate()
-                .map(|(i, (index_name, index_type, term))| {
-                    let sk = b64_encode(hmac(
-                        &format_term_key(sk.as_str(), &index_name, index_type, i),
-                        Some(pk.as_str()),
-                        cipher,
-                    )?);
-
-                    Ok::<_, SealError>(Term { sk, value: term })
-                })
-                .collect::<Result<_, SealError>>()?;
-
-            output.push(dbg!(Sealed {
-                pk,
-                sk,
-                attributes,
-                terms,
-            }));
-        }
-
-        Ok(output)*/
     }
 
     pub(crate) async fn seal<'a>(
@@ -411,7 +286,6 @@ impl Sealed {
         self,
         mut index_predicate: impl FnMut(&str, &TableAttribute) -> bool,
     ) -> (SealedTableEntry, Vec<SealedTableEntry>) {
-        // TODO: Is this normalization necessary? - try removing it
         let root_attributes = self.attributes;
 
         let index_attributes: TableAttributes = root_attributes