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::{
bridge_table::{from_scalar, BridgeLine, BridgeTable, EncryptedBucket, MAX_BRIDGES_PER_BUCKET},
cred,
proto::{
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(
net: &dyn Networking,
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 (id, key) = from_scalar(lox_cred.bucket).unwrap();
let encbucket = match encbuckets.get(&id) {
Some(encbucket) => encbucket,
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
@ -152,18 +156,10 @@ pub async fn trust_migration(
pub async fn level_up(
net: &dyn Networking,
lox_cred: &lox_library::cred::Lox,
encbuckets: &HashMap<u32, EncryptedBucket>,
reachcred: &cred::BucketReachability,
lox_pub: &IssuerPubKey,
reachability_pub: &IssuerPubKey,
) -> (lox_library::cred::Lox, [BridgeLine; MAX_BRIDGES_PER_BUCKET]) {
// 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
) -> lox_library::cred::Lox {
let (req, state) = level_up::request(
lox_cred,
&reachcred,
@ -176,12 +172,7 @@ pub async fn level_up(
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 cred = level_up::handle_response(state, decoded_resp, lox_pub).unwrap();
// 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)
cred
}
// 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 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)
}

9
src/main.rs
View File

@ -136,22 +136,23 @@ async fn main() {
get_migration_pub(&lox_auth_pubkeys),
)
.await;
let bucket = get_bucket(&net, &cred).await;
let bucket = get_bucket(&net, &cred).await.0;
(cred, bucket)
} else {
(lox_cred, bucket)
}
} else {
if eligible_for_level_up(&net, &lox_cred).await {
let encbuckets = get_reachability_credential(&net).await;
let (cred, bucket) = level_up(
let (bucket, reachcred) = get_bucket(&net, &lox_cred).await;
let cred = level_up(
&net,
&lox_cred,
&encbuckets,
&reachcred.unwrap(),
get_lox_pub(&lox_auth_pubkeys),
get_reachability_pub(&lox_auth_pubkeys),
)
.await;
let bucket = get_bucket(&net, &lox_cred).await.0;
(cred, bucket)
} else {
(lox_cred, bucket)

52
src/tests.rs
View File

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