1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147 |
- /*! Unit tests that require access to the testing-only function
- BridgeLine::random() or private fields */
- use super::bridge_table::BridgeLine;
- use super::proto::*;
- use super::*;
- use statistical::{mean, standard_deviation};
- use std::time::{Duration, Instant};
- struct PerfStat {
- // Report performance metrics for each test
- req_len: usize,
- resp_len: usize,
- req_t: Duration,
- resp_t: Duration,
- resp_handle_t: Duration,
- }
- struct TestHarness {
- bdb: BridgeDb,
- pub ba: BridgeAuth,
- }
- impl TestHarness {
- fn new() -> Self {
- TestHarness::new_buckets(5, 5)
- }
- fn new_buckets(num_buckets: u8, hot_spare: u8) -> Self {
- // Create a BridegDb
- let mut bdb = BridgeDb::new();
- // Create a BridgeAuth
- let mut ba = BridgeAuth::new(bdb.pubkey);
- // Make 3 x num_buckets open invitation bridges, in sets of 3
- for _ in 0..num_buckets {
- let bucket = [
- BridgeLine::random(),
- BridgeLine::random(),
- BridgeLine::random(),
- ];
- ba.add_openinv_bridges(bucket, &mut bdb);
- }
- // Add hot_spare more hot spare buckets
- for _ in 0..hot_spare {
- let bucket = [
- BridgeLine::random(),
- BridgeLine::random(),
- BridgeLine::random(),
- ];
- ba.add_spare_bucket(bucket);
- }
- // Create the encrypted bridge table
- ba.enc_bridge_table();
- Self { bdb, ba }
- }
- fn advance_days(&mut self, days: u16) {
- self.ba.advance_days(days);
- }
- fn open_invite(&mut self) -> (PerfStat, (cred::Lox, bridge_table::BridgeLine)) {
- // Issue an open invitation
- let inv = self.bdb.invite();
- let req_start = Instant::now();
- // Use it to get a Lox credential
- let (req, state) = open_invite::request(&inv);
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_open_invite(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let (cred, bridgeline) =
- open_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- return (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- (cred, bridgeline),
- );
- }
- fn trust_promotion(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) {
- let req_start = Instant::now();
- let (promreq, promstate) =
- trust_promotion::request(&cred, &self.ba.lox_pub, self.ba.today()).unwrap();
- let encoded: Vec<u8> = bincode::serialize(&promreq).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let promresp = self.ba.handle_trust_promotion(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&promresp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let migcred = trust_promotion::handle_response(promstate, decode_resp).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- return (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- migcred,
- );
- }
- fn level0_migration(
- &mut self,
- loxcred: &cred::Lox,
- migcred: &cred::Migration,
- ) -> (PerfStat, cred::Lox) {
- let req_start = Instant::now();
- let (migreq, migstate) =
- migration::request(loxcred, migcred, &self.ba.lox_pub, &self.ba.migration_pub).unwrap();
- let encoded: Vec<u8> = bincode::serialize(&migreq).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let migresp = self.ba.handle_migration(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&migresp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp: migration::Response = bincode::deserialize(&encoded_resp[..]).unwrap();
- let cred = migration::handle_response(migstate, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- return (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- cred,
- );
- }
- fn level_up(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Lox) {
- // Read the bucket in the credential to get today's Bucket
- // Reachability credential
- let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
- let encbuckets = self.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- let reachcred = bucket.1.unwrap();
- // Use the Bucket Reachability credential to advance to the next
- // level
- let req_start = Instant::now();
- let (req, state) = level_up::request(
- &cred,
- &reachcred,
- &self.ba.lox_pub,
- &self.ba.reachability_pub,
- self.ba.today(),
- )
- .unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_level_up(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let cred = level_up::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- return (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- cred,
- );
- }
- fn issue_invite(&mut self, cred: &cred::Lox) -> (PerfStat, (cred::Lox, cred::Invitation)) {
- // Read the bucket in the credential to get today's Bucket
- // Reachability credential
- let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
- let encbuckets = self.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- let reachcred = bucket.1.unwrap();
- let req_start = Instant::now();
- let (req, state) = issue_invite::request(
- &cred,
- &reachcred,
- &self.ba.lox_pub,
- &self.ba.reachability_pub,
- self.ba.today(),
- )
- .unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_issue_invite(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let (cred, invite) = issue_invite::handle_response(
- state,
- decode_resp,
- &self.ba.lox_pub,
- &self.ba.invitation_pub,
- )
- .unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- return (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- (cred, invite),
- );
- }
- fn redeem_invite(&mut self, inv: &cred::Invitation) -> (PerfStat, cred::Lox) {
- let req_start = Instant::now();
- let (req, state) =
- redeem_invite::request(&inv, &self.ba.invitation_pub, self.ba.today()).unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_redeem_invite(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let cred = redeem_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- return (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- cred,
- );
- }
- fn check_blockage(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) {
- let req_start = Instant::now();
- let (req, state) = check_blockage::request(&cred, &self.ba.lox_pub).unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_check_blockage(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let migcred = check_blockage::handle_response(state, decode_resp).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- return (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- migcred,
- );
- }
- fn blockage_migration(
- &mut self,
- cred: &cred::Lox,
- mig: &cred::Migration,
- ) -> (PerfStat, cred::Lox) {
- let req_start = Instant::now();
- let (req, state) =
- blockage_migration::request(&cred, &mig, &self.ba.lox_pub, &self.ba.migration_pub)
- .unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_blockage_migration(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp: blockage_migration::Response =
- bincode::deserialize(&encoded_resp[..]).unwrap();
- let cred =
- blockage_migration::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- return (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- cred,
- );
- }
- }
- #[test]
- fn test_open_invite() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let (perf_stat, (cred, bridgeline)) = th.open_invite();
- // Check that we can use the credential to read a bucket
- let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
- let encbuckets = th.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- print_test_results(perf_stat);
- println!("cred = {:?}", cred);
- println!("bucket = {:?}", bucket);
- println!("bridgeline = {:?}", bridgeline);
- assert!(bucket.1.is_none());
- assert!(th.ba.verify_lox(&cred));
- assert!(bridgeline == bucket.0[0]);
- }
- #[test]
- fn test_trust_promotion() {
- let mut th = TestHarness::new();
- let cred = th.open_invite().1 .0;
- assert!(th.ba.verify_lox(&cred));
- // Time passes
- th.advance_days(47);
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- assert!(th.ba.verify_migration(&migcred));
- // Check that we can use the to_bucket in the Migration credenital
- // to read a bucket
- let (id, key) = bridge_table::from_scalar(migcred.to_bucket).unwrap();
- let encbuckets = th.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- print_test_results(perf_stat);
- println!("bucket = {:?}", bucket);
- assert!(th.ba.verify_reachability(&bucket.1.unwrap()));
- }
- #[test]
- fn test_level0_migration() {
- let mut th = TestHarness::new();
- let cred = th.open_invite().1 .0;
- assert!(th.ba.verify_lox(&cred));
- // Time passes
- th.advance_days(47);
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- assert!(th.ba.verify_migration(&migcred));
- println!("--Trust Promotion to 1--\n");
- print_test_results(perf_stat);
- let (mperf_stat, newloxcred) = th.level0_migration(&cred, &migcred);
- println!("--Level 0 migration--\n");
- print_test_results(mperf_stat);
- assert!(th.ba.verify_lox(&newloxcred));
- println!("newloxcred = {:?}", newloxcred);
- // Check that we can use the credenital to read a bucket
- let (id, key) = bridge_table::from_scalar(newloxcred.bucket).unwrap();
- let encbuckets = th.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- println!("bucket = {:?}", bucket);
- assert!(th.ba.verify_reachability(&bucket.1.unwrap()));
- }
- #[test]
- fn test_level_up() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let cred = th.open_invite().1 .0;
- // Time passes
- th.advance_days(47);
- // Go up to level 1
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- println!("--Trust Promotion to 1--\n");
- print_test_results(perf_stat);
- let (mperf_stat, cred1) = th.level0_migration(&cred, &migcred);
- println!("--New Level 1 Credential--\n");
- print_test_results(mperf_stat);
- assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
- // Time passes
- th.advance_days(20);
- let (two_perf_stat, cred2) = th.level_up(&cred1);
- assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
- println!("--Upgrade to Level 2--\n");
- print_test_results(two_perf_stat);
- println!("cred2 = {:?}", cred2);
- assert!(th.ba.verify_lox(&cred2));
- // Time passes
- th.advance_days(30);
- let (three_perf_stat, cred3) = th.level_up(&cred2);
- assert!(scalar_u32(&cred3.trust_level).unwrap() == 3);
- println!("--Upgrade to Level 3--\n");
- print_test_results(three_perf_stat);
- println!("cred3 = {:?}", cred3);
- assert!(th.ba.verify_lox(&cred3));
- // Time passes
- th.advance_days(60);
- let (four_perf_stat, cred4) = th.level_up(&cred3);
- assert!(scalar_u32(&cred3.trust_level).unwrap() == 3);
- println!("--Upgrade to Level 4--\n");
- print_test_results(four_perf_stat);
- println!("cred4 = {:?}", cred4);
- assert!(th.ba.verify_lox(&cred4));
- }
- #[test]
- fn test_issue_invite() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let cred = th.open_invite().1 .0;
- // Time passes
- th.advance_days(47);
- // Go up to level 1
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- println!("--Trust Promotion to 1--\n");
- print_test_results(perf_stat);
- let (mperf_stat, cred1) = th.level0_migration(&cred, &migcred);
- println!("--New Level 1 Credential--\n");
- print_test_results(mperf_stat);
- assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
- // Time passes
- th.advance_days(20);
- // Go up to level 2
- let (two_perf_stat, cred2) = th.level_up(&cred1);
- println!("--Upgrade to Level 2--\n");
- print_test_results(two_perf_stat);
- assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
- println!("cred2 = {:?}", cred2);
- assert!(th.ba.verify_lox(&cred2));
- // Issue an invitation
- let (invite_perf_stat, (cred2a, invite)) = th.issue_invite(&cred2);
- println!("--Issue Invitation--\n");
- print_test_results(invite_perf_stat);
- assert!(th.ba.verify_lox(&cred2a));
- assert!(th.ba.verify_invitation(&invite));
- println!("cred2a = {:?}", cred2a);
- println!("invite = {:?}", invite);
- }
- #[test]
- fn test_redeem_invite() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let cred = th.open_invite().1 .0;
- // Time passes
- th.advance_days(47);
- // Go up to level 1
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- println!("--Trust Promotion to 1--\n");
- print_test_results(perf_stat);
- let (mperf_stat, cred1) = th.level0_migration(&cred, &migcred);
- println!("--New Level 1 Credential--\n");
- print_test_results(mperf_stat);
- assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
- // Time passes
- th.advance_days(20);
- // Go up to level 2
- let (two_perf_stat, cred2) = th.level_up(&cred1);
- println!("--Upgrade to Level 2--\n");
- print_test_results(two_perf_stat);
- assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
- println!("cred2 = {:?}", cred2);
- assert!(th.ba.verify_lox(&cred2));
- // Issue an invitation to Bob
- let (invite_perf_stat, (cred2a, bob_invite)) = th.issue_invite(&cred2);
- println!("--Issue Invitation--\n");
- print_test_results(invite_perf_stat);
- assert!(th.ba.verify_lox(&cred2a));
- assert!(th.ba.verify_invitation(&bob_invite));
- println!("cred2a = {:?}", cred2a);
- println!("bob_invite = {:?}", bob_invite);
- // Time passes
- th.advance_days(12);
- // Bob joins the system
- let (bob_perf_stat, bob_cred) = th.redeem_invite(&bob_invite);
- println!("--Bob joins the system--\n");
- print_test_results(bob_perf_stat);
- assert!(th.ba.verify_lox(&bob_cred));
- println!("bob_cred = {:?}", bob_cred);
- }
- #[test]
- fn test_mark_unreachable() {
- let mut th = TestHarness::new();
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- // Mark a bridge in an untrusted bucket as unreachable
- let b6 = th.ba.bridge_table.buckets[6][0];
- th.ba.bridge_unreachable(&b6, &mut th.bdb);
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- // Mark another bridge grouped to the same trusted bucket as
- // unreachable
- let b7 = th.ba.bridge_table.buckets[7][0];
- th.ba.bridge_unreachable(&b7, &mut th.bdb);
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- // That will have introduced a blockage migration. Get the target
- let target: u32 = *th
- .ba
- .blockage_migration_table
- .table
- .iter()
- .next()
- .unwrap()
- .1;
- // Block two of the bridges in that target bucket
- let bt1 = th.ba.bridge_table.buckets[target as usize][1];
- let bt2 = th.ba.bridge_table.buckets[target as usize][2];
- th.ba.bridge_unreachable(&bt1, &mut th.bdb);
- th.ba.bridge_unreachable(&bt2, &mut th.bdb);
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- }
- #[test]
- fn test_blockage_migration() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let cred = th.open_invite().1 .0;
- // Time passes
- th.advance_days(47);
- // Go up to level 1
- let (_mperf_stat, migcred) = th.trust_promotion(&cred);
- let (_perf_stat, cred1) = th.level0_migration(&cred, &migcred);
- assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
- // Time passes
- th.advance_days(20);
- // Go up to level 2
- let (_two_perf_stat, cred2) = th.level_up(&cred1);
- assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
- println!("cred2 = {:?}", cred2);
- assert!(th.ba.verify_lox(&cred2));
- // Time passes
- th.advance_days(29);
- // Go up to level 3
- let (_three_perf_stat, cred3) = th.level_up(&cred2);
- assert!(scalar_u32(&cred3.trust_level).unwrap() == 3);
- println!("cred3 = {:?}", cred3);
- assert!(th.ba.verify_lox(&cred3));
- // Get our bridges
- let (id, key) = bridge_table::from_scalar(cred3.bucket).unwrap();
- let encbuckets = th.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- // We should have a Bridge Reachability credential
- assert!(bucket.1.is_some());
- // Oh, no! Two of our bridges are blocked!
- th.ba.bridge_unreachable(&bucket.0[0], &mut th.bdb);
- th.ba.bridge_unreachable(&bucket.0[2], &mut th.bdb);
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- // Time passes
- th.advance_days(1);
- let encbuckets2 = th.ba.enc_bridge_table();
- let bucket2 =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets2[id as usize]).unwrap();
- // We should no longer have a Bridge Reachability credential
- assert!(bucket2.1.is_none());
- // See about getting a Migration credential for the blockage
- let (_block_perf_stat, migration) = th.check_blockage(&cred3);
- println!("migration = {:?}", migration);
- // Migrate
- let (_four_perf_stat, cred4) = th.blockage_migration(&cred3, &migration);
- println!("cred4 = {:?}", cred4);
- assert!(th.ba.verify_lox(&cred4));
- }
- #[test]
- fn stats_test_open_invite() {
- let mut th = TestHarness::new_buckets(10, 10);
- println!("\n---------------Open Invitationn-------------------\n");
- let mut req_size: Vec<f64> = Vec::new();
- let mut resp_size: Vec<f64> = Vec::new();
- let mut req_t_size: Vec<f64> = Vec::new();
- let mut resp_t_size: Vec<f64> = Vec::new();
- let mut resp_handle_t_size: Vec<f64> = Vec::new();
- for _ in 0..1000 {
- let (perf_stat, _) = th.open_invite();
- req_size.push(perf_stat.req_len as f64);
- req_t_size.push(perf_stat.req_t.as_secs_f64());
- resp_size.push(perf_stat.resp_len as f64);
- resp_t_size.push(perf_stat.resp_t.as_secs_f64());
- resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
- }
- print_stats_test_results(
- req_size,
- req_t_size,
- resp_size,
- resp_t_size,
- resp_handle_t_size,
- );
- }
- #[test]
- fn stats_test_trust_promotion() {
- let mut th = TestHarness::new_buckets(10, 10);
- println!("\n-------Trust Promotion--------\n");
- let mut req_size: Vec<f64> = Vec::new();
- let mut resp_size: Vec<f64> = Vec::new();
- let mut req_t_size: Vec<f64> = Vec::new();
- let mut resp_t_size: Vec<f64> = Vec::new();
- let mut resp_handle_t_size: Vec<f64> = Vec::new();
- for _ in 0..1000 {
- let cred = th.open_invite().1 .0;
- th.advance_days(47);
- let (perf_stat, _) = th.trust_promotion(&cred);
- req_size.push(perf_stat.req_len as f64);
- req_t_size.push(perf_stat.req_t.as_secs_f64());
- resp_size.push(perf_stat.resp_len as f64);
- resp_t_size.push(perf_stat.resp_t.as_secs_f64());
- resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
- }
- print_stats_test_results(
- req_size,
- req_t_size,
- resp_size,
- resp_t_size,
- resp_handle_t_size,
- );
- }
- #[test]
- fn stats_test_trust_level0_migration() {
- let mut th = TestHarness::new_buckets(10, 10);
- println!("\n-------------Trust Level0 Migration----------------\n");
- let mut req_size: Vec<f64> = Vec::new();
- let mut resp_size: Vec<f64> = Vec::new();
- let mut req_t_size: Vec<f64> = Vec::new();
- let mut resp_t_size: Vec<f64> = Vec::new();
- let mut resp_handle_t_size: Vec<f64> = Vec::new();
- let mut tot_req_size: Vec<f64> = Vec::new();
- let mut tot_resp_size: Vec<f64> = Vec::new();
- let mut tot_req_t_size: Vec<f64> = Vec::new();
- let mut tot_resp_t_size: Vec<f64> = Vec::new();
- let mut tot_resp_handle_t_size: Vec<f64> = Vec::new();
- for _ in 0..1000 {
- let cred = th.open_invite().1 .0;
- th.advance_days(47);
- let (tp_perf_stat, migcred) = th.trust_promotion(&cred);
- let (perf_stat, _) = th.level0_migration(&cred, &migcred);
- req_size.push(perf_stat.req_len as f64);
- req_t_size.push(perf_stat.req_t.as_secs_f64());
- resp_size.push(perf_stat.resp_len as f64);
- resp_t_size.push(perf_stat.resp_t.as_secs_f64());
- resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
- tot_req_size.push((perf_stat.req_len + tp_perf_stat.req_len) as f64);
- tot_req_t_size.push((perf_stat.req_t + tp_perf_stat.req_t).as_secs_f64());
- tot_resp_size.push((perf_stat.resp_len + tp_perf_stat.resp_len) as f64);
- tot_resp_t_size.push((perf_stat.resp_t + tp_perf_stat.resp_t).as_secs_f64());
- tot_resp_handle_t_size
- .push((perf_stat.resp_handle_t + tp_perf_stat.resp_handle_t).as_secs_f64());
- }
- print_stats_test_results(
- req_size,
- req_t_size,
- resp_size,
- resp_t_size,
- resp_handle_t_size,
- );
- println!("\n-------Total Trust Promotion to Level 1-------\n");
- print_stats_test_results(
- tot_req_size,
- tot_req_t_size,
- tot_resp_size,
- tot_resp_t_size,
- tot_resp_handle_t_size,
- );
- }
- #[test]
- fn stats_test_trust_level_up() {
- let mut th = TestHarness::new_buckets(10, 10);
- println!("\n---Trust Promotion + Migration to Level 1: 30 days----\n");
- let mut req_size: Vec<f64> = Vec::new();
- let mut resp_size: Vec<f64> = Vec::new();
- let mut req_t_size: Vec<f64> = Vec::new();
- let mut resp_t_size: Vec<f64> = Vec::new();
- let mut resp_handle_t_size: Vec<f64> = Vec::new();
- let mut sec_req_size: Vec<f64> = Vec::new();
- let mut sec_resp_size: Vec<f64> = Vec::new();
- let mut sec_req_t_size: Vec<f64> = Vec::new();
- let mut sec_resp_t_size: Vec<f64> = Vec::new();
- let mut sec_resp_handle_t_size: Vec<f64> = Vec::new();
- let mut three_req_size: Vec<f64> = Vec::new();
- let mut three_resp_size: Vec<f64> = Vec::new();
- let mut three_req_t_size: Vec<f64> = Vec::new();
- let mut three_resp_t_size: Vec<f64> = Vec::new();
- let mut three_resp_handle_t_size: Vec<f64> = Vec::new();
- let mut four_req_size: Vec<f64> = Vec::new();
- let mut four_resp_size: Vec<f64> = Vec::new();
- let mut four_req_t_size: Vec<f64> = Vec::new();
- let mut four_resp_t_size: Vec<f64> = Vec::new();
- let mut four_resp_handle_t_size: Vec<f64> = Vec::new();
- for _ in 0..1000 {
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (tp_perf_stat, migcred) = th.trust_promotion(&cred);
- let (perf_stat, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (sec_perf_stat, cred2) = th.level_up(&cred1);
- th.advance_days(28);
- let (three_perf_stat, cred3) = th.level_up(&cred2);
- th.advance_days(56);
- let (four_perf_stat, _) = th.level_up(&cred3);
- req_size.push((perf_stat.req_len + tp_perf_stat.req_len) as f64);
- req_t_size.push((perf_stat.req_t + tp_perf_stat.req_t).as_secs_f64());
- resp_size.push((perf_stat.resp_len + tp_perf_stat.resp_len) as f64);
- resp_t_size.push((perf_stat.resp_t + tp_perf_stat.resp_t).as_secs_f64());
- resp_handle_t_size.push((perf_stat.resp_handle_t + tp_perf_stat.resp_handle_t).as_secs_f64());
- sec_req_size.push(sec_perf_stat.req_len as f64);
- sec_req_t_size.push(sec_perf_stat.req_t.as_secs_f64());
- sec_resp_size.push(sec_perf_stat.resp_len as f64);
- sec_resp_t_size.push(sec_perf_stat.resp_t.as_secs_f64());
- sec_resp_handle_t_size.push(sec_perf_stat.resp_handle_t.as_secs_f64());
- three_req_size.push(three_perf_stat.req_len as f64);
- three_req_t_size.push(three_perf_stat.req_t.as_secs_f64());
- three_resp_size.push(three_perf_stat.resp_len as f64);
- three_resp_t_size.push(three_perf_stat.resp_t.as_secs_f64());
- three_resp_handle_t_size.push(three_perf_stat.resp_handle_t.as_secs_f64());
- four_req_size.push(four_perf_stat.req_len as f64);
- four_req_t_size.push(four_perf_stat.req_t.as_secs_f64());
- four_resp_size.push(four_perf_stat.resp_len as f64);
- four_resp_t_size.push(four_perf_stat.resp_t.as_secs_f64());
- four_resp_handle_t_size.push(four_perf_stat.resp_handle_t.as_secs_f64());
- }
- print_stats_test_results(
- req_size,
- req_t_size,
- resp_size,
- resp_t_size,
- resp_handle_t_size,
- );
- println!("\n-------Trust Promotion to Level 2: 44 days-------\n");
- print_stats_test_results(
- sec_req_size,
- sec_req_t_size,
- sec_resp_size,
- sec_resp_t_size,
- sec_resp_handle_t_size,
- );
- println!("\n-------Trust Promotion to Level 3: 72 days------\n");
- print_stats_test_results(
- three_req_size,
- three_req_t_size,
- three_resp_size,
- three_resp_t_size,
- three_resp_handle_t_size,
- );
- println!("\n-------Trust Promotion to Level 4: 128 days------\n");
- print_stats_test_results(
- four_req_size,
- four_req_t_size,
- four_resp_size,
- four_resp_t_size,
- four_resp_handle_t_size,
- );
- }
- #[test]
- fn stats_test_invitations() {
- let mut th = TestHarness::new_buckets(10, 10);
- println!("\n---------------Issue Invitation----------------\n");
- let mut req_size: Vec<f64> = Vec::new();
- let mut resp_size: Vec<f64> = Vec::new();
- let mut req_t_size: Vec<f64> = Vec::new();
- let mut resp_t_size: Vec<f64> = Vec::new();
- let mut resp_handle_t_size: Vec<f64> = Vec::new();
- let mut red_req_size: Vec<f64> = Vec::new();
- let mut red_resp_size: Vec<f64> = Vec::new();
- let mut red_req_t_size: Vec<f64> = Vec::new();
- let mut red_resp_t_size: Vec<f64> = Vec::new();
- let mut red_resp_handle_t_size: Vec<f64> = Vec::new();
- for _ in 0..1000 {
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- th.advance_days(28);
- let (perf_stat, (cred2a, invite)) = th.issue_invite(&cred2);
- let (bob_perf_stat, bob_cred) = th.redeem_invite(&invite);
- req_size.push(perf_stat.req_len as f64);
- req_t_size.push(perf_stat.req_t.as_secs_f64());
- resp_size.push(perf_stat.resp_len as f64);
- resp_t_size.push(perf_stat.resp_t.as_secs_f64());
- resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
- red_req_size.push(bob_perf_stat.req_len as f64);
- red_req_t_size.push(bob_perf_stat.req_t.as_secs_f64());
- red_resp_size.push(bob_perf_stat.resp_len as f64);
- red_resp_t_size.push(bob_perf_stat.resp_t.as_secs_f64());
- red_resp_handle_t_size.push(bob_perf_stat.resp_handle_t.as_secs_f64());
- }
- print_stats_test_results(
- req_size,
- req_t_size,
- resp_size,
- resp_t_size,
- resp_handle_t_size,
- );
- println!("\n---------------Redeem Invitation----------------\n");
- print_stats_test_results(
- red_req_size,
- red_req_t_size,
- red_resp_size,
- red_resp_t_size,
- red_resp_handle_t_size,
- );
- }
- #[test]
- fn stats_test_blockage migration() {
- let mut th = TestHarness::new_buckets(10, 10);
- println!("\n---------------Blockage Migration----------------\n");
- let mut req_size: Vec<f64> = Vec::new();
- let mut resp_size: Vec<f64> = Vec::new();
- let mut req_t_size: Vec<f64> = Vec::new();
- let mut resp_t_size: Vec<f64> = Vec::new();
- let mut resp_handle_t_size: Vec<f64> = Vec::new();
- let mut red_req_size: Vec<f64> = Vec::new();
- let mut red_resp_size: Vec<f64> = Vec::new();
- let mut red_req_t_size: Vec<f64> = Vec::new();
- let mut red_resp_t_size: Vec<f64> = Vec::new();
- let mut red_resp_handle_t_size: Vec<f64> = Vec::new();
- for _ in 0..1000 {
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- th.advance_days(28);
- let (perf_stat, (cred2a, invite)) = th.issue_invite(&cred2);
- let (bob_perf_stat, bob_cred) = th.redeem_invite(&invite);
- req_size.push(perf_stat.req_len as f64);
- req_t_size.push(perf_stat.req_t.as_secs_f64());
- resp_size.push(perf_stat.resp_len as f64);
- resp_t_size.push(perf_stat.resp_t.as_secs_f64());
- resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
- red_req_size.push(bob_perf_stat.req_len as f64);
- red_req_t_size.push(bob_perf_stat.req_t.as_secs_f64());
- red_resp_size.push(bob_perf_stat.resp_len as f64);
- red_resp_t_size.push(bob_perf_stat.resp_t.as_secs_f64());
- red_resp_handle_t_size.push(bob_perf_stat.resp_handle_t.as_secs_f64());
- }
- print_stats_test_results(
- req_size,
- req_t_size,
- resp_size,
- resp_t_size,
- resp_handle_t_size,
- );
- println!("\n---------------Redeem Invitation----------------\n");
- print_stats_test_results(
- red_req_size,
- red_req_t_size,
- red_resp_size,
- red_resp_t_size,
- red_resp_handle_t_size,
- );
- }
- #[test]
- fn stats_test_blocked_bridges() {
- let mut th = TestHarness::new_buckets(10, 10);
- println!("\n-------Trust Promotion With Blocked Bridges--------\n");
- let mut req_size_b: Vec<f64> = Vec::new();
- let mut resp_size_b: Vec<f64> = Vec::new();
- let mut req_t_size_b: Vec<f64> = Vec::new();
- let mut resp_t_size_b: Vec<f64> = Vec::new();
- let mut resp_handle_t_size_b: Vec<f64> = Vec::new();
- for _ in 0..1000 {
- let cred = th.open_invite().1 .0;
- th.advance_days(47);
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- req_size_b.push(perf_stat.req_len as f64);
- req_t_size_b.push(perf_stat.req_t.as_secs_f64());
- resp_size_b.push(perf_stat.resp_len as f64);
- resp_t_size_b.push(perf_stat.resp_t.as_secs_f64());
- resp_handle_t_size_b.push(perf_stat.resp_handle_t.as_secs_f64());
- }
- // Mark 5 bridges in untrusted buckets as unreachable
- for i in 0..50 {
- if i % 2 == 0 {
- let b0 = th.ba.bridge_table.buckets[i][0];
- th.ba.bridge_unreachable(&b0, &mut th.bdb);
- }
- }
- print_stats_test_results(
- req_size_b,
- req_t_size_b,
- resp_size_b,
- resp_t_size_b,
- resp_handle_t_size_b,
- );
- }
- #[test]
- fn stats_test_something_else_test() {
- let mut th = TestHarness::new_buckets(10, 10);
- println!("\n---------------Block Bridges-------------------\n");
- let mut req_size2: Vec<f64> = Vec::new();
- let mut resp_size2: Vec<f64> = Vec::new();
- let mut req_t_size2: Vec<f64> = Vec::new();
- let mut resp_t_size2: Vec<f64> = Vec::new();
- let mut resp_handle_t_size2: Vec<f64> = Vec::new();
- for _ in 0..1000 {
- let (perf_stat2, _) = th.open_invite();
- req_size2.push(perf_stat2.req_len as f64);
- req_t_size2.push(perf_stat2.req_t.as_secs_f64());
- resp_size2.push(perf_stat2.resp_len as f64);
- resp_t_size2.push(perf_stat2.resp_t.as_secs_f64());
- resp_handle_t_size2.push(perf_stat2.resp_handle_t.as_secs_f64());
- }
- print_stats_test_results(
- req_size2,
- req_t_size2,
- resp_size2,
- resp_t_size2,
- resp_handle_t_size2,
- );
- }
- fn print_test_results(perf_stat: PerfStat) {
- println!("Request size = {:?}", perf_stat.req_len);
- println!("Request time = {:?}", perf_stat.req_t);
- println!("Response size = {:?}", perf_stat.resp_len);
- println!("Response time = {:?}", perf_stat.resp_t);
- println!("Response handle time = {:?}", perf_stat.resp_handle_t);
- }
- fn print_stats_test_results(
- req_size: Vec<f64>,
- req_t_size: Vec<f64>,
- resp_size: Vec<f64>,
- resp_t_size: Vec<f64>,
- resp_handle_t_size: Vec<f64>,
- ) {
- let mean_req_size = mean(&req_size);
- let req_std_dev = standard_deviation(&req_size, Some(mean_req_size));
- let mean_req_t_size = mean(&req_t_size);
- let req_t_std_dev = standard_deviation(&req_t_size, Some(mean_req_t_size));
- let mean_resp_size = mean(&resp_size);
- let resp_std_dev = standard_deviation(&resp_size, Some(mean_resp_size));
- let mean_resp_t_size = mean(&resp_t_size);
- let resp_t_std_dev = standard_deviation(&resp_t_size, Some(mean_resp_t_size));
- let mean_resp_handle_t_size = mean(&resp_t_size);
- let resp_handle_t_std_dev =
- standard_deviation(&resp_handle_t_size, Some(mean_resp_handle_t_size));
- println!("Average Request size = {}", mean_req_size);
- println!("Request Standard Deviation = {}", req_std_dev);
- println!(
- "Average Request Time = {:?}",
- Duration::from_secs_f64(mean_req_t_size)
- );
- println!(
- "Request time Standard Deviation = {:?}",
- Duration::from_secs_f64(req_t_std_dev)
- );
- println!("Average Response size = {}", mean_resp_size);
- println!("Response Standard Deviation = {}", resp_std_dev);
- println!(
- "Average Response Time = {:?}",
- Duration::from_secs_f64(mean_resp_t_size)
- );
- println!(
- "Response Time Standard Deviation = {:?}",
- Duration::from_secs_f64(resp_t_std_dev)
- );
- println!(
- "Average Response Handling Time = {:?}",
- Duration::from_secs_f64(mean_resp_handle_t_size)
- );
- println!(
- "Response Handling Time Standard Deviation = {:?}",
- Duration::from_secs_f64(resp_handle_t_std_dev)
- );
- }
|