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

Get bucket reachability credential with bucket, not level up

This commit is contained in:
Vecna 2024-04-30 01:18:17 -04:00
parent 176258afe9
commit 3c2bd56921
3 changed files with 31 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/lib.rs
View File

@ -1,5 +1,6 @@
use lox_library::{ use lox_library::{
bridge_table::{from_scalar, BridgeLine, BridgeTable, EncryptedBucket, MAX_BRIDGES_PER_BUCKET}, bridge_table::{from_scalar, BridgeLine, BridgeTable, EncryptedBucket, MAX_BRIDGES_PER_BUCKET},
cred,
proto::{ proto::{
level_up::{LEVEL_INTERVAL, MAX_BLOCKAGES}, level_up::{LEVEL_INTERVAL, MAX_BLOCKAGES},
*, *,
@ -86,14 +87,17 @@ pub async fn get_reachability_credential(net: &dyn Networking) -> HashMap<u32, E
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,
) -> [BridgeLine; MAX_BRIDGES_PER_BUCKET] { ) -> (
[BridgeLine; MAX_BRIDGES_PER_BUCKET],
Option<cred::BucketReachability>,
) {
let encbuckets = get_reachability_credential(net).await; 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().0 BridgeTable::decrypt_bucket(id, &key, &encbucket).unwrap()
} }
// Get an open invitation // Get an open invitation
@ -152,18 +156,10 @@ pub async fn trust_migration(
pub async fn level_up( pub async fn level_up(
net: &dyn Networking, net: &dyn Networking,
lox_cred: &lox_library::cred::Lox, lox_cred: &lox_library::cred::Lox,
encbuckets: &HashMap<u32, EncryptedBucket>, reachcred: &cred::BucketReachability,
lox_pub: &IssuerPubKey, lox_pub: &IssuerPubKey,
reachability_pub: &IssuerPubKey, reachability_pub: &IssuerPubKey,
) -> (lox_library::cred::Lox, [BridgeLine; MAX_BRIDGES_PER_BUCKET]) { ) -> lox_library::cred::Lox {
// Read the bucket in the credential to get today's Bucket
// Reachability credential
let (id, key) = from_scalar(lox_cred.bucket).unwrap();
let bucket = BridgeTable::decrypt_bucket(id, &key, &encbuckets.get(&id).unwrap()).unwrap();
let reachcred = bucket.1.unwrap();
// Use the Bucket Reachability credential to advance to the next
// level
let (req, state) = level_up::request( let (req, state) = level_up::request(
lox_cred, lox_cred,
&reachcred, &reachcred,
@ -176,12 +172,7 @@ pub async fn level_up(
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).unwrap();
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
// Get bucket
let (id, key) = from_scalar(lox_cred.bucket).unwrap();
let bucket = BridgeTable::decrypt_bucket(id, &key, &encbuckets.get(&id).unwrap()).unwrap();
(cred, bucket.0)
} }
// Request an Invitation credential to give to a friend // Request an Invitation credential to give to a friend
@ -230,7 +221,7 @@ pub async fn redeem_invite(
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).unwrap();
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; let bucket = get_bucket(net, &cred).await.0;
(cred, bucket) (cred, bucket)
} }

9
src/main.rs
View File

@ -136,22 +136,23 @@ async fn main() {
get_migration_pub(&lox_auth_pubkeys), get_migration_pub(&lox_auth_pubkeys),
) )
.await; .await;
let bucket = get_bucket(&net, &cred).await; let bucket = get_bucket(&net, &cred).await.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 encbuckets = get_reachability_credential(&net).await; let (bucket, reachcred) = get_bucket(&net, &lox_cred).await;
let (cred, bucket) = level_up( let cred = level_up(
&net, &net,
&lox_cred, &lox_cred,
&encbuckets, &reachcred.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),
) )
.await; .await;
let bucket = get_bucket(&net, &lox_cred).await.0;
(cred, bucket) (cred, bucket)
} else { } else {
(lox_cred, bucket) (lox_cred, bucket)

52
src/tests.rs
View File

@ -55,17 +55,16 @@ 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 encbuckets = get_reachability_credential(net).await; let (bucket, reachcred) = get_bucket(net, cred).await;
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,
cred, cred,
&encbuckets, &reachcred.unwrap(),
get_lox_pub(la_pubkeys), get_lox_pub(la_pubkeys),
get_reachability_pub(la_pubkeys), get_reachability_pub(la_pubkeys),
) )
.await .await;
.0;
new_cred new_cred
} }
@ -86,7 +85,7 @@ async fn test_credential_operations() {
let open_inv = get_open_invitation(&net).await; let open_inv = get_open_invitation(&net).await;
let (mut cred, bridgeline) = let (mut cred, bridgeline) =
get_lox_credential(&net, &open_inv, get_lox_pub(&la_pubkeys)).await; get_lox_credential(&net, &open_inv, get_lox_pub(&la_pubkeys)).await;
let bucket = get_bucket(&net, &cred).await; let bucket = get_bucket(&net, &cred).await.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());
@ -116,20 +115,6 @@ async fn test_credential_operations() {
scalar_u32(&cred.trust_level).unwrap(), scalar_u32(&cred.trust_level).unwrap(),
u32::try_from(i).unwrap() u32::try_from(i).unwrap()
); );
/*
advance_days(&net_test, u16::try_from(LEVEL_INTERVAL[i]).unwrap()).await;
assert!(eligible_for_level_up(&net, &cred).await);
let encbuckets = get_reachability_credential(&net).await;
cred = level_up(
&net,
&cred,
&encbuckets,
get_lox_pub(&la_pubkeys),
get_reachability_pub(&la_pubkeys),
)
.await
.0;
*/
cred = test_level_up(&net, &net_test, &cred, &la_pubkeys).await; cred = test_level_up(&net, &net_test, &cred, &la_pubkeys).await;
// Assert that we increased level by 1 or stayed at 4 // Assert that we increased level by 1 or stayed at 4
@ -196,7 +181,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; let bridges = get_bucket(&net, &cred).await.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(
@ -209,17 +194,14 @@ async fn test_credential_operations() {
// Time passes... // Time passes...
advance_days(&net_test, 1).await; advance_days(&net_test, 1).await;
// Check that we still have a Bridge Reachability credential // Check that we still have a Bucket Reachability credential
let etable = get_reachability_credential(&net).await; let (bucket, reachcred) = get_bucket(&net, &cred).await;
let (id, key) = from_scalar(cred.bucket).unwrap(); assert!(reachcred.is_some());
let encbucket = etable.get(&id).unwrap(); println!("Can still obtain bucket reachability credential");
let bucket = BridgeTable::decrypt_bucket(id, &key, &encbucket).unwrap();
assert!(bucket.1.is_some());
println!("Can still obtain bridge 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; let bridges = get_bucket(&net, &cred).await.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(
@ -232,13 +214,10 @@ async fn test_credential_operations() {
// Time passes... // Time passes...
advance_days(&net_test, 1).await; advance_days(&net_test, 1).await;
// Check that we don't have a Bridge Reachability credential // Check that we don't have a Bucket Reachability credential
let etable = get_reachability_credential(&net).await; let (bucket, reachcred) = get_bucket(&net, &cred).await;
let (id, key) = from_scalar(cred.bucket).unwrap(); assert!(reachcred.is_none());
let encbucket = etable.get(&id).unwrap(); println!("Cannot obtain bucket reachability credential");
let bucket = BridgeTable::decrypt_bucket(id, &key, &encbucket).unwrap();
assert!(bucket.1.is_none());
println!("Cannot obtain bridge reachability credential");
// Migrate to a new bucket // Migrate to a new bucket
println!("Migrating to a new bucket"); println!("Migrating to a new bucket");
@ -252,6 +231,7 @@ async fn test_credential_operations() {
) )
.await; .await;
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);
// TODO: Figure out why this always fails // TODO: Figure out why this always fails
// Level up to level 3 // Level up to level 3
@ -262,7 +242,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; let bridges = get_bucket(&net, &cred).await.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(