fn encrypt_permute()

in protocol/src/private_id_multi_key/partner.rs [106:171]

• 43 lines of code
• 1 McCabe index (conditional complexity)

    fn encrypt_permute(
        &self,
        company: TPayload,
        psum: Vec<usize>,
    ) -> Result<TPayload, ProtocolError> {
        match self.company_permutation.clone().write() {
            Ok(mut permutation) => {
                let t = timer::Timer::new_silent("encrypt_permute_company");
                // This is an array of exclusive-inclusive prefix sum - hence number of keys
                // is one less than length
                let num_keys = psum.len() - 1;

                // Encrypt and unflatten
                let mut d = {
                    let e_c = self
                        .ec_cipher
                        .to_points_encrypt(&company, &self.private_keys.0);
                    t.qps("ecompany", e_c.len());

                    psum.get(0..num_keys)
                        .unwrap()
                        .iter()
                        .zip_eq(psum.get(1..num_keys + 1).unwrap().iter())
                        .map(|(&x1, &x2)| e_c.get(x1..x2).unwrap().to_vec())
                        .collect::<Vec<Vec<_>>>()
                };

                assert_eq!(d.len(), num_keys);

                permutation.clear();
                permutation.extend(gen_permute_pattern(d.len()));

                // Permute each record - outer
                permute(permutation.as_slice(), &mut d);

                // Permute each record - inner
                d.iter_mut()
                    .for_each(|v| permute(gen_permute_pattern(v.len()).as_slice(), v));

                // {
                // d.iter().for_each(|t| println!("SHUBHO d len {}", t.len()));
                // }

                // Create prefix-postfix array before flatten. This encodes the
                // ragged array structure
                let (mut d_flat, offset) = {
                    let (d_flat, mut offset, metadata) = serialize_helper(d);
                    offset.extend(metadata);

                    // Encrypt
                    (self.ec_cipher.to_bytes(&d_flat), offset)
                };

                // Append offsets array
                d_flat.extend(offset);
                Ok(d_flat)
            }

            Err(e) => {
                error!("Unable to encrypt data : {}", e);
                Err(ProtocolError::ErrorEncryption(
                    "unable to encrypt data".to_string(),
                ))
            }
        }
    }