|
@@ -1,6 +1,4 @@
|
|
|
-mod client_net;
|
|
|
-use client_net::net_request;
|
|
|
-
|
|
|
+use async_trait::async_trait;
|
|
|
use curve25519_dalek::scalar::Scalar;
|
|
|
use lox::bridge_table::BridgeLine;
|
|
|
use lox::bridge_table::ENC_BUCKET_BYTES;
|
|
@@ -14,6 +12,12 @@ use std::time::Duration;
|
|
|
// used for testing function
|
|
|
use std::io::Write;
|
|
|
|
|
|
+// provides a generic way to make network requests
|
|
|
+#[async_trait]
|
|
|
+pub trait Networking {
|
|
|
+ async fn request(&self, endpoint: String, body: Vec<u8>) -> Vec<u8>;
|
|
|
+}
|
|
|
+
|
|
|
// From https://gitlab.torproject.org/onyinyang/lox-server/-/blob/main/src/main.rs
|
|
|
// TODO: Move this to main Lox library?
|
|
|
#[serde_as]
|
|
@@ -99,35 +103,35 @@ pub fn get_cred_trust_level(cred: &lox::cred::Lox) -> i8 {
|
|
|
}
|
|
|
|
|
|
// Download Lox Auth pubkeys
|
|
|
-pub async fn get_lox_auth_keys(server_addr: &str) -> Vec<IssuerPubKey> {
|
|
|
- let resp = net_request(server_addr.to_string() + "/pubkeys", [].to_vec()).await;
|
|
|
+pub async fn get_lox_auth_keys(net: &dyn Networking) -> Vec<IssuerPubKey> {
|
|
|
+ let resp = net.request("/pubkeys".to_string(), [].to_vec()).await;
|
|
|
let lox_auth_pubkeys: Vec<IssuerPubKey> = serde_json::from_slice(&resp).unwrap();
|
|
|
lox_auth_pubkeys
|
|
|
}
|
|
|
|
|
|
// Get encrypted bridge table
|
|
|
-pub async fn get_reachability_credential(server_addr: &str) -> Vec<[u8; ENC_BUCKET_BYTES]> {
|
|
|
- let resp = net_request(server_addr.to_string() + "/reachability", [].to_vec()).await;
|
|
|
+pub async fn get_reachability_credential(net: &dyn Networking) -> Vec<[u8; ENC_BUCKET_BYTES]> {
|
|
|
+ let resp = net.request("/reachability".to_string(), [].to_vec()).await;
|
|
|
let reachability_cred: EncBridgeTable = serde_json::from_slice(&resp).unwrap();
|
|
|
reachability_cred.etable
|
|
|
}
|
|
|
|
|
|
// Get an open invitation
|
|
|
-pub async fn get_open_invitation(server_addr: &str) -> [u8; OPENINV_LENGTH] {
|
|
|
- let resp = net_request(server_addr.to_string() + "/invite", [].to_vec()).await;
|
|
|
+pub async fn get_open_invitation(net: &dyn Networking) -> [u8; OPENINV_LENGTH] {
|
|
|
+ let resp = net.request("/invite".to_string(), [].to_vec()).await;
|
|
|
let open_invite: [u8; OPENINV_LENGTH] = serde_json::from_slice::<Invite>(&resp).unwrap().invite;
|
|
|
open_invite
|
|
|
}
|
|
|
|
|
|
// Get a Lox Credential from an open invitation
|
|
|
pub async fn get_lox_credential(
|
|
|
- server_addr: &str,
|
|
|
+ net: &dyn Networking,
|
|
|
open_invite: &[u8; OPENINV_LENGTH],
|
|
|
lox_pub: &IssuerPubKey,
|
|
|
) -> (lox::cred::Lox, BridgeLine) {
|
|
|
let (req, state) = open_invite::request(&open_invite);
|
|
|
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap();
|
|
|
- let encoded_resp = net_request(server_addr.to_string() + "/openreq", 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 (cred, bridgeline) = open_invite::handle_response(state, decoded_resp, &lox_pub).unwrap();
|
|
|
(cred, bridgeline)
|
|
@@ -135,7 +139,7 @@ pub async fn get_lox_credential(
|
|
|
|
|
|
// Get a migration credential to migrate to higher trust
|
|
|
pub async fn trust_promotion(
|
|
|
- server_addr: &str,
|
|
|
+ net: &dyn Networking,
|
|
|
lox_cred: &lox::cred::Lox,
|
|
|
lox_pub: &IssuerPubKey,
|
|
|
) -> lox::cred::Migration {
|
|
@@ -147,7 +151,7 @@ pub async fn trust_promotion(
|
|
|
// trust_promotion::request(&lox_cred, &lox_pub, today(Duration::ZERO)).unwrap();
|
|
|
trust_promotion::request(&lox_cred, &lox_pub, today(Duration::from_secs(time_offset.into()))).unwrap(); // FOR TESTING ONLY
|
|
|
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap();
|
|
|
- let encoded_resp = net_request(server_addr.to_string() + "/trustpromo", 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 migration_cred = trust_promotion::handle_response(state, decoded_resp).unwrap();
|
|
|
migration_cred
|
|
@@ -155,7 +159,7 @@ pub async fn trust_promotion(
|
|
|
|
|
|
// Promote from untrusted (trust level 0) to trusted (trust level 1)
|
|
|
pub async fn trust_migration(
|
|
|
- server_addr: &str,
|
|
|
+ net: &dyn Networking,
|
|
|
lox_cred: &lox::cred::Lox,
|
|
|
migration_cred: &lox::cred::Migration,
|
|
|
lox_pub: &IssuerPubKey,
|
|
@@ -164,7 +168,7 @@ pub async fn trust_migration(
|
|
|
let (req, state) =
|
|
|
migration::request(lox_cred, migration_cred, lox_pub, migration_pub).unwrap();
|
|
|
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap();
|
|
|
- let encoded_resp = net_request(server_addr.to_string() + "/trustmig", 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 cred = migration::handle_response(state, decoded_resp, lox_pub).unwrap();
|
|
|
cred
|
|
@@ -172,7 +176,7 @@ pub async fn trust_migration(
|
|
|
|
|
|
// Increase trust from at least level 1 to higher levels
|
|
|
pub async fn level_up(
|
|
|
- server_addr: &str,
|
|
|
+ net: &dyn Networking,
|
|
|
lox_cred: &lox::cred::Lox,
|
|
|
encbuckets: &Vec<[u8; ENC_BUCKET_BYTES]>,
|
|
|
lox_pub: &IssuerPubKey,
|
|
@@ -202,7 +206,7 @@ pub async fn level_up(
|
|
|
)
|
|
|
.unwrap();
|
|
|
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap();
|
|
|
- let encoded_resp = net_request(server_addr.to_string() + "/levelup", 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 cred = level_up::handle_response(state, decoded_resp, lox_pub).unwrap();
|
|
|
cred
|
|
@@ -210,7 +214,7 @@ pub async fn level_up(
|
|
|
|
|
|
// Request an Invitation credential to give to a friend
|
|
|
pub async fn issue_invite(
|
|
|
- server_addr: &str,
|
|
|
+ net: &dyn Networking,
|
|
|
lox_cred: &lox::cred::Lox,
|
|
|
encbuckets: &Vec<[u8; ENC_BUCKET_BYTES]>,
|
|
|
lox_pub: &IssuerPubKey,
|
|
@@ -234,7 +238,7 @@ pub async fn issue_invite(
|
|
|
)
|
|
|
.unwrap();
|
|
|
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap();
|
|
|
- let encoded_resp = net_request(server_addr.to_string() + "/issueinvite", 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 (cred, invite) =
|
|
|
issue_invite::handle_response(state, decoded_resp, lox_pub, invitation_pub).unwrap();
|
|
@@ -243,7 +247,7 @@ pub async fn issue_invite(
|
|
|
|
|
|
// Redeem an Invitation credential to start at trust level 1
|
|
|
pub async fn redeem_invite(
|
|
|
- server_addr: &str,
|
|
|
+ net: &dyn Networking,
|
|
|
invite: &lox::cred::Invitation,
|
|
|
lox_pub: &IssuerPubKey,
|
|
|
invitation_pub: &IssuerPubKey,
|
|
@@ -251,7 +255,7 @@ pub async fn redeem_invite(
|
|
|
let (req, state) =
|
|
|
redeem_invite::request(invite, invitation_pub, today(Duration::ZERO)).unwrap();
|
|
|
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap();
|
|
|
- let encoded_resp = net_request(server_addr.to_string() + "/redeem", 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 cred = redeem_invite::handle_response(state, decoded_resp, lox_pub).unwrap();
|
|
|
cred
|
|
@@ -259,13 +263,13 @@ pub async fn redeem_invite(
|
|
|
|
|
|
// Check for a migration credential to move to a new bucket
|
|
|
pub async fn check_blockage(
|
|
|
- server_addr: &str,
|
|
|
+ net: &dyn Networking,
|
|
|
lox_cred: &lox::cred::Lox,
|
|
|
lox_pub: &IssuerPubKey,
|
|
|
) -> lox::cred::Migration {
|
|
|
let (req, state) = check_blockage::request(lox_cred, lox_pub).unwrap();
|
|
|
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap();
|
|
|
- let encoded_resp = net_request(server_addr.to_string() + "/checkblockage", 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 migcred = check_blockage::handle_response(state, decoded_resp).unwrap();
|
|
|
migcred
|
|
@@ -273,7 +277,7 @@ pub async fn check_blockage(
|
|
|
|
|
|
// Migrate to a new bucket (must be level >= 3)
|
|
|
pub async fn blockage_migration(
|
|
|
- server_addr: &str,
|
|
|
+ net: &dyn Networking,
|
|
|
lox_cred: &lox::cred::Lox,
|
|
|
migcred: &lox::cred::Migration,
|
|
|
lox_pub: &IssuerPubKey,
|
|
@@ -282,8 +286,9 @@ pub async fn blockage_migration(
|
|
|
let (req, state) =
|
|
|
blockage_migration::request(lox_cred, migcred, lox_pub, migration_pub).unwrap();
|
|
|
let encoded_req: Vec<u8> = serde_json::to_vec(&req).unwrap();
|
|
|
- let encoded_resp =
|
|
|
- net_request(server_addr.to_string() + "/blockagemigration", encoded_req).await;
|
|
|
+ let encoded_resp = net
|
|
|
+ .request("/blockagemigration".to_string(), encoded_req)
|
|
|
+ .await;
|
|
|
let decoded_resp: blockage_migration::Response = serde_json::from_slice(&encoded_resp).unwrap();
|
|
|
let cred = blockage_migration::handle_response(state, decoded_resp, lox_pub).unwrap();
|
|
|
cred
|