Add entangled tags

Cargo.toml

@@ -7,7 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-fuzzytags = "0.2.0"
+fuzzytags = {version="0.2.1", features=["entangled"]}
 rand = "0.8.3"
 rand_distr = "0.4.0"
 hashbrown = "0.9.1"

src/main.rs

@@ -36,6 +36,9 @@ struct Opts {
 
     #[clap(short, long)]
     trace: bool,
+
+    #[clap(short, long, default_value = "0")]
+    prob_entangled: f64,
 }
 
 fn main() {
@@ -59,7 +62,7 @@ fn main() {
 
         {
             event!(Level::INFO, "Simulating message sends using {} samples from a pareto distribution...", opts.samples_per_round);
-            (0..opts.samples_per_round).for_each(|_i| simulated_parties.sample_traffic(&mut server, &mut rng, pareto));
+            (0..opts.samples_per_round).for_each(|_i| simulated_parties.sample_traffic(&mut server, &mut rng, pareto, opts.prob_entangled));
         }
 
         {

src/parties.rs

@@ -1,5 +1,5 @@
 use crate::server::SimulatedServer;
-use fuzzytags::FuzzySecretKey;
+use fuzzytags::{FuzzyPublicKey, FuzzySecretKey};
 use rand::distributions::Distribution;
 use rand::Rng;
 use rand_distr::num_traits::ToPrimitive;
@@ -8,6 +8,7 @@ use tracing::span;
 use tracing::Level;
 
 pub struct SimulatedParties {
+    gamma: usize,
     parties: Vec<FuzzySecretKey>,
 }
 
@@ -18,7 +19,7 @@ impl SimulatedParties {
             let key = FuzzySecretKey::generate(gamma);
             parties.push(key);
         }
-        SimulatedParties { parties }
+        SimulatedParties { gamma, parties }
     }
 
     pub fn register_with_server<R>(&self, server: &mut SimulatedServer, rng: &mut R, min_p: usize, max_p: usize)
@@ -38,23 +39,40 @@ impl SimulatedParties {
         }
     }
 
-    pub fn sample_traffic<R, D>(&self, server: &mut SimulatedServer, rng: &mut R, distribution: D)
+    pub fn sample_traffic<R, D>(&self, server: &mut SimulatedServer, rng: &mut R, distribution: D, probs_entangled: f64)
     where
         D: Distribution<f64>,
         R: Rng,
     {
-        let span = span!(Level::TRACE, "sample_traffic");
+        let span = span!(Level::INFO, "sample_traffic");
         let _enter = span.enter();
         let v = distribution.sample(rng).to_u16().unwrap();
         let receiver = rng.gen_range(0..self.parties.len());
         let receiver_public_key = self.parties.get(receiver).unwrap().public_key();
 
-        let span = span!(Level::TRACE, "{party}", party = receiver_public_key.id().as_str());
+        let entangle = rng.gen_bool(probs_entangled);
-        let _enter = span.enter();
+        if entangle {
-        for _i in 0..v {
+            let receiver_2 = rng.gen_range(0..self.parties.len());
-            let tag = receiver_public_key.generate_tag();
+            let receiver_public_key_2 = self.parties.get(receiver_2).unwrap().public_key();
-            event!(Level::TRACE, "message sent to {tag}", tag = tag.to_string());
+            event!(
-            server.add_message(tag);
+                Level::INFO,
+                "entangled send {party_1} {party_2}",
+                party_1 = receiver_public_key.id().as_str(),
+                party_2 = receiver_public_key_2.id().as_str()
+            );
+
+            for _i in 0..v {
+                let tag = FuzzyPublicKey::generate_entangled_tag(vec![receiver_public_key.clone(), receiver_public_key_2.clone()], self.gamma);
+                event!(Level::TRACE, "message sent to server {tag}", tag = tag.to_string());
+                server.add_message(tag);
+            }
+        } else {
+            event!(Level::INFO, "regular send {party}", party = receiver_public_key.id().as_str());
+            for _i in 0..v {
+                let tag = receiver_public_key.generate_tag();
+                event!(Level::INFO, "message sent server {tag}", tag = tag.to_string());
+                server.add_message(tag);
+            }
         }
     }
 }