Const-generics + Entangled Upgrade

This commit is contained in:
Sarah Jamie Lewis 2021-02-09 23:23:50 -08:00
parent 794266980c
commit 3ebbaf640b
6 changed files with 62 additions and 46 deletions

4
.gitignore vendored
View File

@ -1,3 +1,5 @@
/target
Cargo.lock
.idea/
.idea/
*.dot
*.png

View File

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

View File

@ -18,9 +18,7 @@ use tracing_subscriber::FmtSubscriber;
#[derive(Clap)]
#[clap(version = "1.0", author = "Sarah Jamie Lewis <sarah@openprivacy.ca>")]
struct Opts {
/// Sets a custom config file. Could have been an Option<T> with no default too
#[clap(short, long, default_value = "24")]
gamma: usize,
/// the number of parties to simulate
#[clap(short, long, default_value = "10")]
num_parties: usize,
@ -52,13 +50,13 @@ fn main() {
};
let mut oracle = Oracle::new();
let mut max = 0;
let subscriber = FmtSubscriber::default();
tracing::subscriber::with_default(subscriber, || {
let mut rng = rand::thread_rng();
let mut server = SimulatedServer::new();
let simulated_parties = SimulatedParties::new_simulation(opts.num_parties, opts.gamma);
let simulated_parties = SimulatedParties::new_simulation(opts.num_parties);
{
event!(Level::INFO, "Generating {} Parties and registering them with the server", opts.num_parties);
simulated_parties.register_with_server(&mut server, &mut rng, opts.min_p, opts.max_p, &mut oracle);
@ -107,9 +105,13 @@ fn main() {
)
.unwrap();
}
server_oracle.compile_to_dot("server_event.dot", true);
let max = server_oracle.compile_to_dot("server_event.dot", true, false, 1);
println!("Max from server: {}", max);
oracle.compile_to_dot("actual_events.dot", false, false, max);
server_oracle.compile_to_dot("server_event_inverse.dot", true, true,max);
}
});
oracle.compile_to_dot("actual_events.dot", false);
}

View File

@ -5,6 +5,7 @@ use hashbrown::HashMap;
use rand::{thread_rng, Rng};
use std::fs::File;
use std::io::Write;
use rand_distr::num_traits::FloatConst;
#[derive(Clone)]
pub struct Event {
@ -39,7 +40,7 @@ impl Oracle {
});
}
pub fn compile_to_dot(&self, filename: &str, strict: bool) {
pub fn compile_to_dot(&self, filename: &str, strict: bool, inverse: bool, max: u64) -> u64 {
let mut output = File::create(filename).unwrap();
if strict {
write!(output, "strict ");
@ -47,25 +48,30 @@ impl Oracle {
write!(output, "digraph {{\n");
write!(
output,
r#"K=2;
repulsiveforce=0.1;
r#" dim=3;
overlap=true;
splines = true;
dpi=400;
penwidth = 1;
bgcolor = "black";
"#
);
for party in self.parties.iter() {
for (i, party) in self.parties.iter().enumerate() {
let x = (((f64::PI()*2.0)/self.parties.len() as f64) * (i as f64)).cos()*10.0;
let y = (((f64::PI()*2.0)/self.parties.len() as f64) * (i as f64)).sin()*10.0;
let r = hex::decode(party).unwrap()[0];
let g = hex::decode(party).unwrap()[1];
let b = hex::decode(party).unwrap()[2];
writeln!(output, "\"{}\" [shape=point, color=\"#{:x}{:x}{:x}\"]", party, r, g, b);
writeln!(output, "\"{}\" [shape=point, color=\"#{:x}{:x}{:x}\",pos=\"{},{}!\"]", party, r, g, b,x,y);
}
let mut real_connection_map: HashMap<(String, String), u64> = HashMap::new();
let mut entangled_connection_map: HashMap<(String, String), u64> = HashMap::new();
let mut max_conn = 1;
let mut max_conn = max;
for event in self.actual_events.iter() {
let key = (event.sender.clone(), event.intended_receiver.clone());
if real_connection_map.contains_key(&key) {
@ -94,24 +100,31 @@ impl Oracle {
for ((sender, receiver), size) in real_connection_map.iter() {
let normalized = (*size as f64 / max_conn as f64);
let transparency = (normalized * 255.0) as u8;
let penwidth = (normalized * 2.0) as f64;
let mut transparency = (normalized * 172.0) as u8 + 64;
let mut penwidth = ((normalized * 2048.0) as f64).log2();
if inverse {
penwidth = 4.0 - penwidth;
transparency = 255 - transparency;
}
writeln!(
output,
"\"{}\" -> \"{}\" [arrowhead=none, penwidth={}, color=\"#000000{:x}\"]",
"\"{}\" -> \"{}\" [arrowhead=none, penwidth={}, color=\"#ffffff{:x}\"]",
sender, receiver, penwidth, transparency
);
}
for ((sender, receiver), size) in entangled_connection_map.iter() {
let normalized = (*size as f64 / max_conn as f64);
let transparency = (normalized * 255.0) as u8;
let penwidth = (normalized * 2.0) as f64;
let transparency = (normalized * 172.0) as u8 + 64;
let penwidth = ((normalized * 2048.0) as f64).log2();
writeln!(
output,
"\"{}\" -> \"{}\" [arrowhead=none, style=dashed, penwidth={}, color=\"#000000{:x}\"]",
"\"{}\" -> \"{}\" [arrowhead=none, style=dashed, penwidth={}, color=\"#ffffff{:x}\"]",
sender, receiver, penwidth, transparency
);
}
write!(output, "}}");
max_conn
}
}

View File

@ -1,26 +1,25 @@
use crate::oracle::Oracle;
use crate::server::SimulatedServer;
use fuzzytags::{FuzzyPublicKey, FuzzySecretKey};
use rand::distributions::Distribution;
use rand::Rng;
use rand_distr::num_traits::ToPrimitive;
use tracing::event;
use tracing::span;
use tracing::Level;
use fuzzytags::{RootSecret, TaggingKey};
pub struct SimulatedParties {
gamma: usize,
parties: Vec<FuzzySecretKey>,
parties: Vec<RootSecret<24>>,
}
impl SimulatedParties {
pub fn new_simulation(num_parties: usize, gamma: usize) -> SimulatedParties {
pub fn new_simulation(num_parties: usize) -> SimulatedParties {
let mut parties = vec![];
for _p in 0..num_parties {
let key = FuzzySecretKey::generate(gamma);
let key = RootSecret::<24>::generate();
parties.push(key);
}
SimulatedParties { gamma, parties }
SimulatedParties { parties }
}
pub fn register_with_server<R>(&self, server: &mut SimulatedServer, rng: &mut R, min_p: usize, max_p: usize, oracle: &mut Oracle)
@ -29,13 +28,13 @@ impl SimulatedParties {
{
for party in self.parties.iter() {
let n = rng.gen_range(min_p..max_p);
let span = span!(Level::INFO, "register", party = party.public_key().id().as_str());
let span = span!(Level::INFO, "register", party = party.tagging_key().id().as_str());
let _enter = span.enter();
let detection_key = party.extract(n);
let detection_key = party.extract_detection_key(n);
event!(Level::TRACE, "create detection key {detection_key}", detection_key = detection_key.id().as_str());
event!(Level::TRACE, "register with server");
server.register_key(&detection_key, &party.public_key());
oracle.register_party(party.public_key().id());
server.register_key(&detection_key, &party.tagging_key());
oracle.register_party(party.tagging_key().id());
}
}
@ -49,16 +48,16 @@ impl SimulatedParties {
let v = distribution.sample(rng).to_u16().unwrap();
let sender = rng.gen_range(0..self.parties.len());
let sender_public_key = self.parties.get(sender).unwrap().public_key();
let sender_public_key = self.parties.get(sender).unwrap().tagging_key();
let receiver = rng.gen_range(0..self.parties.len());
let receiver_public_key = self.parties.get(receiver).unwrap().public_key();
let receiver_public_key = self.parties.get(receiver).unwrap().tagging_key();
if sender != receiver {
let entangle = rng.gen_bool(probs_entangled);
if entangle {
let receiver_2 = rng.gen_range(0..self.parties.len());
let receiver_public_key_2 = self.parties.get(receiver_2).unwrap().public_key();
let receiver_public_key_2 = self.parties.get(receiver_2).unwrap().tagging_key();
event!(
Level::INFO,
"entangled send {party_1} {party_2}",
@ -67,7 +66,7 @@ impl SimulatedParties {
);
for _i in 0..v {
let tag = FuzzyPublicKey::generate_entangled_tag(vec![receiver_public_key.clone(), receiver_public_key_2.clone()], self.gamma);
let tag = TaggingKey::<24>::generate_entangled_tag(vec![receiver_public_key.clone(), receiver_public_key_2.clone()], 8);
event!(Level::TRACE, "message sent to server {tag}", tag = tag.to_string());
server.add_message(tag, &sender_public_key);
}

View File

@ -1,15 +1,15 @@
use crate::oracle::Oracle;
use fuzzytags::{FuzzyDetectionKey, FuzzyPublicKey, FuzzyTag};
use fuzzytags::{DetectionKey, TaggingKey, Tag};
use hashbrown::HashMap;
use tracing::event;
use tracing::span;
use tracing::Level;
pub struct SimulatedServer {
keybase: Vec<(FuzzyDetectionKey, FuzzyPublicKey)>,
messages: Vec<(FuzzyTag, FuzzyPublicKey)>,
tags_to_keys_cache: HashMap<String, Vec<FuzzyPublicKey>>,
keys_to_tags_cache: HashMap<String, Vec<FuzzyTag>>,
keybase: Vec<(DetectionKey<24>, TaggingKey<24>)>,
messages: Vec<(Tag<24>, TaggingKey<24>)>,
tags_to_keys_cache: HashMap<String, Vec<TaggingKey<24>>>,
keys_to_tags_cache: HashMap<String, Vec<Tag<24>>>,
oracle: Oracle,
}
@ -40,14 +40,14 @@ impl SimulatedServer {
}
}
pub fn register_key(&mut self, detection_key: &FuzzyDetectionKey, public_key: &FuzzyPublicKey) {
self.keybase.push((detection_key.clone(), public_key.clone()));
self.keys_to_tags_cache.insert(public_key.id(), vec![]);
self.oracle.register_party(public_key.id());
pub fn register_key(&mut self, detection_key: &DetectionKey<24>, tagging_key: &TaggingKey<24>) {
self.keybase.push((detection_key.clone(), tagging_key.clone()));
self.keys_to_tags_cache.insert(tagging_key.id(), vec![]);
self.oracle.register_party(tagging_key.id());
}
pub fn add_message(&mut self, tag: FuzzyTag, sender_public_key: &FuzzyPublicKey) {
self.messages.push((tag.clone(), sender_public_key.clone()));
pub fn add_message(&mut self, tag: Tag<24>, sender_tagging_key: &TaggingKey<24>) {
self.messages.push((tag.clone(), sender_tagging_key.clone()));
self.tags_to_keys_cache.insert(tag.to_string(), vec![]);
}