vecna
/
lox_cli
mirror of https://git-crysp.uwaterloo.ca/vvecna/lox_cli
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Make most functions return results

This commit is contained in:
Vecna 2024-05-28 19:05:35 -04:00
parent 3c2bd56921
commit a87bd2b9e9
3 changed files with 134 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
src/lib.rs
View File

@ -8,6 +8,7 @@ use lox_library::{
scalar_u32, IssuerPubKey, OPENINV_LENGTH, scalar_u32, IssuerPubKey, OPENINV_LENGTH,
}; };
use lox_utils::{EncBridgeTable, Invite}; use lox_utils::{EncBridgeTable, Invite};
use serde_json::error::Error;
use std::collections::HashMap; use std::collections::HashMap;
pub mod networking; pub mod networking;
@ -44,8 +45,15 @@ pub async fn eligible_for_trust_promotion(
Some(v) => v, Some(v) => v,
None => return false, None => return false,
}; };
let date = match get_today(net).await {
Ok(v) => v,
Err(e) => {
eprintln!("Failed to get date, error: {}", e);
return false;
}
};
scalar_u32(&cred.trust_level).unwrap() == 0 scalar_u32(&cred.trust_level).unwrap() == 0
&& level_since + trust_promotion::UNTRUSTED_INTERVAL <= get_today(net).await && level_since + trust_promotion::UNTRUSTED_INTERVAL <= date
} }
// Helper function to check if credential is eligible for // Helper function to check if credential is eligible for
@ -55,56 +63,68 @@ pub async fn eligible_for_level_up(net: &dyn Networking, cred: &lox_library::cre
Some(v) => v, Some(v) => v,
None => return false, None => return false,
}; };
let date = match get_today(net).await {
Ok(v) => v,
Err(e) => {
eprintln!("Failed to get date, error: {}", e);
return false;
}
};
let trust_level = scalar_u32(&cred.trust_level).unwrap(); let trust_level = scalar_u32(&cred.trust_level).unwrap();
let blockages = scalar_u32(&cred.blockages).unwrap(); let blockages = scalar_u32(&cred.blockages).unwrap();
trust_level > 0 trust_level > 0
&& blockages <= MAX_BLOCKAGES[trust_level as usize] && blockages <= MAX_BLOCKAGES[trust_level as usize]
&& level_since + LEVEL_INTERVAL[trust_level as usize] <= get_today(net).await && level_since + LEVEL_INTERVAL[trust_level as usize] <= date
} }
// Get current date from Lox Auth // Get current date from Lox Auth
pub async fn get_today(net: &dyn Networking) -> u32 { pub async fn get_today(net: &dyn Networking) -> Result<u32, Error> {
let resp = net.request("/today".to_string(), [].to_vec()).await; let resp = net.request("/today".to_string(), [].to_vec()).await;
let today: u32 = serde_json::from_slice(&resp).unwrap(); let today: u32 = serde_json::from_slice(&resp)?;
today Ok(today)
} }
// Download Lox Auth pubkeys // Download Lox Auth pubkeys
pub async fn get_lox_auth_keys(net: &dyn Networking) -> Vec<IssuerPubKey> { pub async fn get_lox_auth_keys(net: &dyn Networking) -> Result<Vec<IssuerPubKey>, Error> {
let resp = net.request("/pubkeys".to_string(), [].to_vec()).await; let resp = net.request("/pubkeys".to_string(), [].to_vec()).await;
let lox_auth_pubkeys: Vec<IssuerPubKey> = serde_json::from_slice(&resp).unwrap(); let lox_auth_pubkeys: Vec<IssuerPubKey> = serde_json::from_slice(&resp)?;
lox_auth_pubkeys Ok(lox_auth_pubkeys)
} }
// Get encrypted bridge table // Get encrypted bridge table
pub async fn get_reachability_credential(net: &dyn Networking) -> HashMap<u32, EncryptedBucket> { pub async fn get_reachability_credential(
net: &dyn Networking,
) -> Result<HashMap<u32, EncryptedBucket>, Error> {
let resp = net.request("/reachability".to_string(), [].to_vec()).await; let resp = net.request("/reachability".to_string(), [].to_vec()).await;
let reachability_cred: EncBridgeTable = serde_json::from_slice(&resp).unwrap(); let reachability_cred: EncBridgeTable = serde_json::from_slice(&resp)?;
reachability_cred.etable Ok(reachability_cred.etable)
} }
// Get encrypted bridge table from BridgeDB and decrypt our entry // Get encrypted bridge table from BridgeDB and decrypt our entry
pub async fn get_bucket( pub async fn get_bucket(
net: &dyn Networking, net: &dyn Networking,
lox_cred: &lox_library::cred::Lox, lox_cred: &lox_library::cred::Lox,
) -> ( ) -> Result<
[BridgeLine; MAX_BRIDGES_PER_BUCKET], (
Option<cred::BucketReachability>, [BridgeLine; MAX_BRIDGES_PER_BUCKET],
) { Option<cred::BucketReachability>,
let encbuckets = get_reachability_credential(net).await; ),
Error,
> {
let encbuckets = get_reachability_credential(net).await?;
let (id, key) = from_scalar(lox_cred.bucket).unwrap(); let (id, key) = from_scalar(lox_cred.bucket).unwrap();
let encbucket = match encbuckets.get(&id) { let encbucket = match encbuckets.get(&id) {
Some(encbucket) => encbucket, Some(encbucket) => encbucket,
None => panic!("Provided ID not found"), None => panic!("Provided ID not found"),
}; };
BridgeTable::decrypt_bucket(id, &key, &encbucket).unwrap() Ok(BridgeTable::decrypt_bucket(id, &key, &encbucket).unwrap())
} }
// Get an open invitation // Get an open invitation
pub async fn get_open_invitation(net: &dyn Networking) -> [u8; OPENINV_LENGTH] { pub async fn get_open_invitation(net: &dyn Networking) -> Result<[u8; OPENINV_LENGTH], Error> {
let resp = net.request("/invite".to_string(), [].to_vec()).await; let resp = net.request("/invite".to_string(), [].to_vec()).await;
let open_invite: [u8; OPENINV_LENGTH] = serde_json::from_slice::<Invite>(&resp).unwrap().invite; let open_invite: [u8; OPENINV_LENGTH] = serde_json::from_slice::<Invite>(&resp)?.invite;
open_invite Ok(open_invite)
} }
// Get a Lox Credential from an open invitation // Get a Lox Credential from an open invitation
@ -112,13 +132,13 @@ pub async fn get_lox_credential(
net: &dyn Networking, net: &dyn Networking,
open_invite: &[u8; OPENINV_LENGTH], open_invite: &[u8; OPENINV_LENGTH],
lox_pub: &IssuerPubKey, lox_pub: &IssuerPubKey,
) -> (lox_library::cred::Lox, BridgeLine) { ) -> Result<(lox_library::cred::Lox, BridgeLine), Error> {
let (req, state) = open_invite::request(&open_invite); let (req, state) = open_invite::request(&open_invite);
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap(); let encoded_req: Vec<u8> = serde_json::to_vec(&req)?;
let encoded_resp = net.request("/openreq".to_string(), encoded_req).await; let encoded_resp = net.request("/openreq".to_string(), encoded_req).await;
let decoded_resp: open_invite::Response = serde_json::from_slice(&encoded_resp).unwrap(); let decoded_resp: open_invite::Response = serde_json::from_slice(&encoded_resp)?;
let (cred, bridgeline) = open_invite::handle_response(state, decoded_resp, &lox_pub).unwrap(); let (cred, bridgeline) = open_invite::handle_response(state, decoded_resp, &lox_pub).unwrap();
(cred, bridgeline) Ok((cred, bridgeline))
} }
// Get a migration credential to migrate to higher trust // Get a migration credential to migrate to higher trust
@ -126,13 +146,14 @@ pub async fn trust_promotion(
net: &dyn Networking, net: &dyn Networking,
lox_cred: &lox_library::cred::Lox, lox_cred: &lox_library::cred::Lox,
lox_pub: &IssuerPubKey, lox_pub: &IssuerPubKey,
) -> lox_library::cred::Migration { ) -> Result<lox_library::cred::Migration, Error> {
let (req, state) = trust_promotion::request(&lox_cred, &lox_pub, get_today(net).await).unwrap(); let (req, state) =
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap(); trust_promotion::request(&lox_cred, &lox_pub, get_today(net).await?).unwrap();
let encoded_req: Vec<u8> = serde_json::to_vec(&req)?;
let encoded_resp = net.request("/trustpromo".to_string(), encoded_req).await; let encoded_resp = net.request("/trustpromo".to_string(), encoded_req).await;
let decoded_resp: trust_promotion::Response = serde_json::from_slice(&encoded_resp).unwrap(); let decoded_resp: trust_promotion::Response = serde_json::from_slice(&encoded_resp)?;
let migration_cred = trust_promotion::handle_response(state, decoded_resp).unwrap(); let migration_cred = trust_promotion::handle_response(state, decoded_resp).unwrap();
migration_cred Ok(migration_cred)
} }
// Promote from untrusted (trust level 0) to trusted (trust level 1) // Promote from untrusted (trust level 0) to trusted (trust level 1)
@ -142,14 +163,14 @@ pub async fn trust_migration(
migration_cred: &lox_library::cred::Migration, migration_cred: &lox_library::cred::Migration,
lox_pub: &IssuerPubKey, lox_pub: &IssuerPubKey,
migration_pub: &IssuerPubKey, migration_pub: &IssuerPubKey,
) -> lox_library::cred::Lox { ) -> Result<lox_library::cred::Lox, Error> {
let (req, state) = let (req, state) =
migration::request(lox_cred, migration_cred, lox_pub, migration_pub).unwrap(); migration::request(lox_cred, migration_cred, lox_pub, migration_pub).unwrap();
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap(); let encoded_req: Vec<u8> = serde_json::to_vec(&req)?;
let encoded_resp = net.request("/trustmig".to_string(), encoded_req).await; let encoded_resp = net.request("/trustmig".to_string(), encoded_req).await;
let decoded_resp: migration::Response = serde_json::from_slice(&encoded_resp).unwrap(); let decoded_resp: migration::Response = serde_json::from_slice(&encoded_resp)?;
let cred = migration::handle_response(state, decoded_resp, lox_pub).unwrap(); let cred = migration::handle_response(state, decoded_resp, lox_pub).unwrap();
cred Ok(cred)
} }
// Increase trust from at least level 1 to higher levels // Increase trust from at least level 1 to higher levels
@ -159,20 +180,20 @@ pub async fn level_up(
reachcred: &cred::BucketReachability, reachcred: &cred::BucketReachability,
lox_pub: &IssuerPubKey, lox_pub: &IssuerPubKey,
reachability_pub: &IssuerPubKey, reachability_pub: &IssuerPubKey,
) -> lox_library::cred::Lox { ) -> Result<lox_library::cred::Lox, Error> {
let (req, state) = level_up::request( let (req, state) = level_up::request(
lox_cred, lox_cred,
&reachcred, &reachcred,
lox_pub, lox_pub,
reachability_pub, reachability_pub,
get_today(net).await, get_today(net).await?,
) )
.unwrap(); .unwrap();
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap(); let encoded_req: Vec<u8> = serde_json::to_vec(&req)?;
let encoded_resp = net.request("/levelup".to_string(), encoded_req).await; let encoded_resp = net.request("/levelup".to_string(), encoded_req).await;
let decoded_resp: level_up::Response = serde_json::from_slice(&encoded_resp).unwrap(); let decoded_resp: level_up::Response = serde_json::from_slice(&encoded_resp)?;
let cred = level_up::handle_response(state, decoded_resp, lox_pub).unwrap(); let cred = level_up::handle_response(state, decoded_resp, lox_pub).unwrap();
cred Ok(cred)
} }
// Request an Invitation credential to give to a friend // Request an Invitation credential to give to a friend
@ -183,7 +204,7 @@ pub async fn issue_invite(
lox_pub: &IssuerPubKey, lox_pub: &IssuerPubKey,
reachability_pub: &IssuerPubKey, reachability_pub: &IssuerPubKey,
invitation_pub: &IssuerPubKey, invitation_pub: &IssuerPubKey,
) -> (lox_library::cred::Lox, lox_library::cred::Invitation) { ) -> Result<(lox_library::cred::Lox, lox_library::cred::Invitation), Error> {
// Read the bucket in the credential to get today's Bucket // Read the bucket in the credential to get today's Bucket
// Reachability credential // Reachability credential
@ -196,15 +217,15 @@ pub async fn issue_invite(
&reachcred, &reachcred,
lox_pub, lox_pub,
reachability_pub, reachability_pub,
get_today(net).await, get_today(net).await?,
) )
.unwrap(); .unwrap();
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap(); let encoded_req: Vec<u8> = serde_json::to_vec(&req)?;
let encoded_resp = net.request("/issueinvite".to_string(), encoded_req).await; let encoded_resp = net.request("/issueinvite".to_string(), encoded_req).await;
let decoded_resp: issue_invite::Response = serde_json::from_slice(&encoded_resp).unwrap(); let decoded_resp: issue_invite::Response = serde_json::from_slice(&encoded_resp)?;
let (cred, invite) = let (cred, invite) =
issue_invite::handle_response(state, decoded_resp, lox_pub, invitation_pub).unwrap(); issue_invite::handle_response(state, decoded_resp, lox_pub, invitation_pub).unwrap();
(cred, invite) Ok((cred, invite))
} }
// Redeem an Invitation credential to start at trust level 1 // Redeem an Invitation credential to start at trust level 1
@ -213,16 +234,16 @@ pub async fn redeem_invite(
invite: &lox_library::cred::Invitation, invite: &lox_library::cred::Invitation,
lox_pub: &IssuerPubKey, lox_pub: &IssuerPubKey,
invitation_pub: &IssuerPubKey, invitation_pub: &IssuerPubKey,
) -> (lox_library::cred::Lox, [BridgeLine; MAX_BRIDGES_PER_BUCKET]) { ) -> Result<(lox_library::cred::Lox, [BridgeLine; MAX_BRIDGES_PER_BUCKET]), Error> {
let (req, state) = let (req, state) =
redeem_invite::request(invite, invitation_pub, get_today(net).await).unwrap(); redeem_invite::request(invite, invitation_pub, get_today(net).await?).unwrap();
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap(); let encoded_req: Vec<u8> = serde_json::to_vec(&req)?;
let encoded_resp = net.request("/redeem".to_string(), encoded_req).await; let encoded_resp = net.request("/redeem".to_string(), encoded_req).await;
let decoded_resp: redeem_invite::Response = serde_json::from_slice(&encoded_resp).unwrap(); let decoded_resp: redeem_invite::Response = serde_json::from_slice(&encoded_resp)?;
let cred = redeem_invite::handle_response(state, decoded_resp, lox_pub).unwrap(); let cred = redeem_invite::handle_response(state, decoded_resp, lox_pub).unwrap();
let bucket = get_bucket(net, &cred).await.0; let bucket = get_bucket(net, &cred).await?.0;
(cred, bucket) Ok((cred, bucket))
} }
// Check for a migration credential to move to a new bucket // Check for a migration credential to move to a new bucket
@ -230,13 +251,13 @@ pub async fn check_blockage(
net: &dyn Networking, net: &dyn Networking,
lox_cred: &lox_library::cred::Lox, lox_cred: &lox_library::cred::Lox,
lox_pub: &IssuerPubKey, lox_pub: &IssuerPubKey,
) -> lox_library::cred::Migration { ) -> Result<lox_library::cred::Migration, Error> {
let (req, state) = check_blockage::request(lox_cred, lox_pub).unwrap(); let (req, state) = check_blockage::request(lox_cred, lox_pub).unwrap();
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap(); let encoded_req: Vec<u8> = serde_json::to_vec(&req)?;
let encoded_resp = net.request("/checkblockage".to_string(), encoded_req).await; let encoded_resp = net.request("/checkblockage".to_string(), encoded_req).await;
let decoded_resp: check_blockage::Response = serde_json::from_slice(&encoded_resp).unwrap(); let decoded_resp: check_blockage::Response = serde_json::from_slice(&encoded_resp)?;
let migcred = check_blockage::handle_response(state, decoded_resp).unwrap(); let migcred = check_blockage::handle_response(state, decoded_resp).unwrap();
migcred Ok(migcred)
} }
// Migrate to a new bucket (must be level >= 3) // Migrate to a new bucket (must be level >= 3)
@ -246,16 +267,16 @@ pub async fn blockage_migration(
migcred: &lox_library::cred::Migration, migcred: &lox_library::cred::Migration,
lox_pub: &IssuerPubKey, lox_pub: &IssuerPubKey,
migration_pub: &IssuerPubKey, migration_pub: &IssuerPubKey,
) -> lox_library::cred::Lox { ) -> Result<lox_library::cred::Lox, Error> {
let (req, state) = let (req, state) =
blockage_migration::request(lox_cred, migcred, lox_pub, migration_pub).unwrap(); blockage_migration::request(lox_cred, migcred, lox_pub, migration_pub).unwrap();
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap(); let encoded_req: Vec<u8> = serde_json::to_vec(&req)?;
let encoded_resp = net let encoded_resp = net
.request("/blockagemigration".to_string(), encoded_req) .request("/blockagemigration".to_string(), encoded_req)
.await; .await;
let decoded_resp: blockage_migration::Response = serde_json::from_slice(&encoded_resp).unwrap(); let decoded_resp: blockage_migration::Response = serde_json::from_slice(&encoded_resp)?;
let cred = blockage_migration::handle_response(state, decoded_resp, lox_pub).unwrap(); let cred = blockage_migration::handle_response(state, decoded_resp, lox_pub).unwrap();
cred Ok(cred)
} }
#[cfg(test)] #[cfg(test)]

33
src/main.rs
View File

@ -73,7 +73,7 @@ async fn main() {
serde_json::from_reader(lox_auth_pubkeys_infile).unwrap() serde_json::from_reader(lox_auth_pubkeys_infile).unwrap()
} else { } else {
// download from Lox Auth // download from Lox Auth
let pubkeys = get_lox_auth_keys(&net).await; let pubkeys = get_lox_auth_keys(&net).await.unwrap();
// save to file for next time // save to file for next time
save_object(&pubkeys, &lox_auth_pubkeys_filename); save_object(&pubkeys, &lox_auth_pubkeys_filename);
pubkeys pubkeys
@ -90,7 +90,8 @@ async fn main() {
get_lox_pub(&lox_auth_pubkeys), get_lox_pub(&lox_auth_pubkeys),
get_invitation_pub(&lox_auth_pubkeys), get_invitation_pub(&lox_auth_pubkeys),
) )
.await; .await
.unwrap();
// save to files for future use // save to files for future use
save_object(&cred, &lox_cred_filename); save_object(&cred, &lox_cred_filename);
@ -101,9 +102,10 @@ async fn main() {
|| !Path::new(bucket_filename).exists() || !Path::new(bucket_filename).exists()
{ {
// get new Lox Credential // get new Lox Credential
let open_invite = get_open_invitation(&net).await; let open_invite = get_open_invitation(&net).await.unwrap();
let (cred, bl) = let (cred, bl) = get_lox_credential(&net, &open_invite, get_lox_pub(&lox_auth_pubkeys))
get_lox_credential(&net, &open_invite, get_lox_pub(&lox_auth_pubkeys)).await; .await
.unwrap();
let mut bucket = [BridgeLine::default(); MAX_BRIDGES_PER_BUCKET]; let mut bucket = [BridgeLine::default(); MAX_BRIDGES_PER_BUCKET];
// note: this is a bucket with one real bridgeline and n-1 // note: this is a bucket with one real bridgeline and n-1
// default (zeroed out) bridgelines // default (zeroed out) bridgelines
@ -127,7 +129,9 @@ async fn main() {
let (cred, bucket) = if old_level == 0 { let (cred, bucket) = if old_level == 0 {
if eligible_for_trust_promotion(&net, &lox_cred).await { if eligible_for_trust_promotion(&net, &lox_cred).await {
let migration_cred = let migration_cred =
trust_promotion(&net, &lox_cred, get_lox_pub(&lox_auth_pubkeys)).await; trust_promotion(&net, &lox_cred, get_lox_pub(&lox_auth_pubkeys))
.await
.unwrap();
let cred = trust_migration( let cred = trust_migration(
&net, &net,
&lox_cred, &lox_cred,
@ -135,15 +139,16 @@ async fn main() {
get_lox_pub(&lox_auth_pubkeys), get_lox_pub(&lox_auth_pubkeys),
get_migration_pub(&lox_auth_pubkeys), get_migration_pub(&lox_auth_pubkeys),
) )
.await; .await
let bucket = get_bucket(&net, &cred).await.0; .unwrap();
let bucket = get_bucket(&net, &cred).await.unwrap().0;
(cred, bucket) (cred, bucket)
} else { } else {
(lox_cred, bucket) (lox_cred, bucket)
} }
} else { } else {
if eligible_for_level_up(&net, &lox_cred).await { if eligible_for_level_up(&net, &lox_cred).await {
let (bucket, reachcred) = get_bucket(&net, &lox_cred).await; let (bucket, reachcred) = get_bucket(&net, &lox_cred).await.unwrap();
let cred = level_up( let cred = level_up(
&net, &net,
&lox_cred, &lox_cred,
@ -151,8 +156,9 @@ async fn main() {
get_lox_pub(&lox_auth_pubkeys), get_lox_pub(&lox_auth_pubkeys),
get_reachability_pub(&lox_auth_pubkeys), get_reachability_pub(&lox_auth_pubkeys),
) )
.await; .await
let bucket = get_bucket(&net, &lox_cred).await.0; .unwrap();
let bucket = get_bucket(&net, &lox_cred).await.unwrap().0;
(cred, bucket) (cred, bucket)
} else { } else {
(lox_cred, bucket) (lox_cred, bucket)
@ -177,12 +183,13 @@ async fn main() {
let (cred, invite) = issue_invite( let (cred, invite) = issue_invite(
&net, &net,
&lox_cred, &lox_cred,
&get_reachability_credential(&net).await, &get_reachability_credential(&net).await.unwrap(),
get_lox_pub(&lox_auth_pubkeys), get_lox_pub(&lox_auth_pubkeys),
get_reachability_pub(&lox_auth_pubkeys), get_reachability_pub(&lox_auth_pubkeys),
get_invitation_pub(&lox_auth_pubkeys), get_invitation_pub(&lox_auth_pubkeys),
) )
.await; .await
.unwrap();
// TODO: Make this unique per-run (e.g., add timestamp) // TODO: Make this unique per-run (e.g., add timestamp)
save_object(&invite, &invite_filename); save_object(&invite, &invite_filename);
save_object(&cred, &lox_cred_filename); save_object(&cred, &lox_cred_filename);

59
src/tests.rs
View File

@ -55,7 +55,7 @@ pub async fn test_level_up(
) )
.await; .await;
assert!(eligible_for_level_up(net, cred).await); assert!(eligible_for_level_up(net, cred).await);
let (bucket, reachcred) = get_bucket(net, cred).await; let (bucket, reachcred) = get_bucket(net, cred).await.unwrap();
println!("Leveling up from level {} to {}", level, min(4, level + 1)); println!("Leveling up from level {} to {}", level, min(4, level + 1));
let new_cred = level_up( let new_cred = level_up(
net, net,
@ -64,7 +64,8 @@ pub async fn test_level_up(
get_lox_pub(la_pubkeys), get_lox_pub(la_pubkeys),
get_reachability_pub(la_pubkeys), get_reachability_pub(la_pubkeys),
) )
.await; .await
.unwrap();
new_cred new_cred
} }
@ -78,16 +79,17 @@ async fn test_credential_operations() {
let net_test = HyperNet { let net_test = HyperNet {
hostname: "http://localhost:8005".to_string(), hostname: "http://localhost:8005".to_string(),
}; };
let la_pubkeys = get_lox_auth_keys(&net).await; let la_pubkeys = get_lox_auth_keys(&net).await.unwrap();
// Get new Lox credential // Get new Lox credential
println!("Getting new open-entry Lox credential"); println!("Getting new open-entry Lox credential");
let open_inv = get_open_invitation(&net).await; let open_inv = get_open_invitation(&net).await.unwrap();
let (mut cred, bridgeline) = let (mut cred, bridgeline) = get_lox_credential(&net, &open_inv, get_lox_pub(&la_pubkeys))
get_lox_credential(&net, &open_inv, get_lox_pub(&la_pubkeys)).await; .await
let bucket = get_bucket(&net, &cred).await.0; .unwrap();
let bucket = get_bucket(&net, &cred).await.unwrap().0;
//assert_eq!(bucket[0], bridgeline); // For some reason, this sometimes fails. assert_eq!(bucket[0], bridgeline); // For some reason, this sometimes fails.
assert_eq!(bucket[1], BridgeLine::default()); assert_eq!(bucket[1], BridgeLine::default());
assert_eq!(bucket[2], BridgeLine::default()); assert_eq!(bucket[2], BridgeLine::default());
@ -98,7 +100,9 @@ async fn test_credential_operations() {
// Advance server time and trust migrate // Advance server time and trust migrate
advance_days(&net_test, u16::try_from(UNTRUSTED_INTERVAL).unwrap()).await; advance_days(&net_test, u16::try_from(UNTRUSTED_INTERVAL).unwrap()).await;
assert!(eligible_for_trust_promotion(&net, &cred).await); assert!(eligible_for_trust_promotion(&net, &cred).await);
let migration_cred = trust_promotion(&net, &cred, get_lox_pub(&la_pubkeys)).await; let migration_cred = trust_promotion(&net, &cred, get_lox_pub(&la_pubkeys))
.await
.unwrap();
cred = trust_migration( cred = trust_migration(
&net, &net,
&cred, &cred,
@ -106,11 +110,13 @@ async fn test_credential_operations() {
get_lox_pub(&la_pubkeys), get_lox_pub(&la_pubkeys),
get_migration_pub(&la_pubkeys), get_migration_pub(&la_pubkeys),
) )
.await; .await
.unwrap();
assert_eq!(scalar_u32(&cred.trust_level).unwrap(), 1); assert_eq!(scalar_u32(&cred.trust_level).unwrap(), 1);
// Advance server time and level up // Advance server time and level up
for i in 1..LEVEL_INTERVAL.len() { for i in 1..LEVEL_INTERVAL.len() {
println!("Leveling up to level {}", min(i, LEVEL_INTERVAL.len() - 1));
assert_eq!( assert_eq!(
scalar_u32(&cred.trust_level).unwrap(), scalar_u32(&cred.trust_level).unwrap(),
u32::try_from(i).unwrap() u32::try_from(i).unwrap()
@ -130,7 +136,7 @@ async fn test_credential_operations() {
// Invite as many friends as possible // Invite as many friends as possible
for j in 0..LEVEL_INVITATIONS[i] { for j in 0..LEVEL_INVITATIONS[i] {
println!("Inviting friend {}", j); println!("Inviting friend {}", j);
let encbuckets = get_reachability_credential(&net).await; let encbuckets = get_reachability_credential(&net).await.unwrap();
let (new_cred, invite) = issue_invite( let (new_cred, invite) = issue_invite(
&net, &net,
&cred, &cred,
@ -139,14 +145,16 @@ async fn test_credential_operations() {
get_reachability_pub(&la_pubkeys), get_reachability_pub(&la_pubkeys),
get_invitation_pub(&la_pubkeys), get_invitation_pub(&la_pubkeys),
) )
.await; .await
.unwrap();
let (friend_cred, friend_bucket) = redeem_invite( let (friend_cred, friend_bucket) = redeem_invite(
&net, &net,
&invite, &invite,
get_lox_pub(&la_pubkeys), get_lox_pub(&la_pubkeys),
get_invitation_pub(&la_pubkeys), get_invitation_pub(&la_pubkeys),
) )
.await; .await
.unwrap();
cred = new_cred; cred = new_cred;
assert_eq!( assert_eq!(
@ -181,7 +189,7 @@ async fn test_credential_operations() {
// Block 1 bridge // Block 1 bridge
println!("Marking one bridge blocked"); println!("Marking one bridge blocked");
let bridges = get_bucket(&net, &cred).await.0; let bridges = get_bucket(&net, &cred).await.unwrap().0;
let blocked_bridges = bridges_to_block(bridges, 1); let blocked_bridges = bridges_to_block(bridges, 1);
let response = net_tp let response = net_tp
.request( .request(
@ -195,13 +203,13 @@ async fn test_credential_operations() {
advance_days(&net_test, 1).await; advance_days(&net_test, 1).await;
// Check that we still have a Bucket Reachability credential // Check that we still have a Bucket Reachability credential
let (bucket, reachcred) = get_bucket(&net, &cred).await; let (bucket, reachcred) = get_bucket(&net, &cred).await.unwrap();
assert!(reachcred.is_some()); assert!(reachcred.is_some());
println!("Can still obtain bucket reachability credential"); println!("Can still obtain bucket reachability credential");
// Block 2 bridges // Block 2 bridges
println!("Marking two bridges blocked"); println!("Marking two bridges blocked");
let bridges = get_bucket(&net, &cred).await.0; let bridges = get_bucket(&net, &cred).await.unwrap().0;
let blocked_bridges = bridges_to_block(bridges, 2); let blocked_bridges = bridges_to_block(bridges, 2);
let response = net_tp let response = net_tp
.request( .request(
@ -215,13 +223,15 @@ async fn test_credential_operations() {
advance_days(&net_test, 1).await; advance_days(&net_test, 1).await;
// Check that we don't have a Bucket Reachability credential // Check that we don't have a Bucket Reachability credential
let (bucket, reachcred) = get_bucket(&net, &cred).await; let (bucket, reachcred) = get_bucket(&net, &cred).await.unwrap();
assert!(reachcred.is_none()); assert!(reachcred.is_none());
println!("Cannot obtain bucket reachability credential"); println!("Cannot obtain bucket reachability credential");
// Migrate to a new bucket // Migrate to a new bucket
println!("Migrating to a new bucket"); println!("Migrating to a new bucket");
let migration_cred = check_blockage(&net, &cred, get_lox_pub(&la_pubkeys)).await; let migration_cred = check_blockage(&net, &cred, get_lox_pub(&la_pubkeys))
.await
.unwrap();
cred = blockage_migration( cred = blockage_migration(
&net, &net,
&cred, &cred,
@ -229,11 +239,11 @@ async fn test_credential_operations() {
get_lox_pub(&la_pubkeys), get_lox_pub(&la_pubkeys),
get_migration_pub(&la_pubkeys), get_migration_pub(&la_pubkeys),
) )
.await; .await
.unwrap();
assert_eq!(scalar_u32(&cred.trust_level).unwrap(), 2); assert_eq!(scalar_u32(&cred.trust_level).unwrap(), 2);
assert_eq!(scalar_u32(&cred.blockages).unwrap(), 1); assert_eq!(scalar_u32(&cred.blockages).unwrap(), 1);
// TODO: Figure out why this always fails
// Level up to level 3 // Level up to level 3
cred = test_level_up(&net, &net_test, &cred, &la_pubkeys).await; cred = test_level_up(&net, &net_test, &cred, &la_pubkeys).await;
@ -242,7 +252,7 @@ async fn test_credential_operations() {
// Another blockage happens // Another blockage happens
println!("Marking three bridges blocked"); println!("Marking three bridges blocked");
let bridges = get_bucket(&net, &cred).await.0; let bridges = get_bucket(&net, &cred).await.unwrap().0;
let blocked_bridges = bridges_to_block(bridges, 3); let blocked_bridges = bridges_to_block(bridges, 3);
let response = net_tp let response = net_tp
.request( .request(
@ -257,7 +267,9 @@ async fn test_credential_operations() {
// Migrate again // Migrate again
println!("Migrating to a new bucket"); println!("Migrating to a new bucket");
let migration_cred = check_blockage(&net, &cred, get_lox_pub(&la_pubkeys)).await; let migration_cred = check_blockage(&net, &cred, get_lox_pub(&la_pubkeys))
.await
.unwrap();
cred = blockage_migration( cred = blockage_migration(
&net, &net,
&cred, &cred,
@ -265,7 +277,8 @@ async fn test_credential_operations() {
get_lox_pub(&la_pubkeys), get_lox_pub(&la_pubkeys),
get_migration_pub(&la_pubkeys), get_migration_pub(&la_pubkeys),
) )
.await; .await
.unwrap();
assert_eq!(scalar_u32(&cred.trust_level).unwrap(), 1); assert_eq!(scalar_u32(&cred.trust_level).unwrap(), 1);
// Level up to level 2 // Level up to level 2