Const-generics + Entangled Upgrade
This commit is contained in:
parent
794266980c
commit
3ebbaf640b
|
@ -1,3 +1,5 @@
|
|||
/target
|
||||
Cargo.lock
|
||||
.idea/
|
||||
.idea/
|
||||
*.dot
|
||||
*.png
|
|
@ -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"
|
||||
|
|
16
src/main.rs
16
src/main.rs
|
@ -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);
|
||||
|
||||
}
|
||||
|
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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![]);
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue