vecna
/
lox
mirror of https://gitlab.torproject.org/vecna/lox.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into 'main' 

Add preliminary testing for request handler

See merge request tpo/anti-censorship/lox-rs!1
This commit is contained in:
onyinyang 2023-06-07 00:20:08 +00:00
parent a823dd9ee2 16ced3c5e0
commit 787f959b38
7 changed files with 326 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
crates/lox-distributor/Cargo.toml
View File

@ -22,4 +22,5 @@ serde_with = "3.0.0"
serde_json = "1.0.87"
lox = { path = "../lox-library", version = "0.1.0"}
lox_utils = { path = "../lox-utils", version = "0.1.0"}
rdsys_backend = { path = "../rdsys-backend-api", version = "0.1.0"}

106
crates/lox-distributor/src/request_handler.rs
View File

@ -72,3 +72,109 @@ pub async fn handle(
},
}
}
#[cfg(test)]
mod tests {
use super::*;
use lox::{BridgeAuth, BridgeDb};
use std::sync::{Arc, Mutex};
trait LoxClient {
fn invite(&self) -> Request<Body>;
fn reachability(&self) -> Request<Body>;
fn pubkeys(&self) -> Request<Body>;
}
struct LoxClientMock {}
impl LoxClient for LoxClientMock {
fn invite(&self) -> Request<Body> {
let req = Request::builder()
.method("POST")
.uri("http://localhost/invite")
.body(Body::empty())
.unwrap();
req
}
fn reachability(&self) -> Request<Body> {
let req = Request::builder()
.method("POST")
.uri("http://localhost/reachability")
.body(Body::empty())
.unwrap();
req
}
fn pubkeys(&self) -> Request<Body> {
let req = Request::builder()
.method("POST")
.uri("http://localhost/pubkeys")
.body(Body::empty())
.unwrap();
req
}
}
struct TestHarness {
context: LoxServerContext,
}
impl TestHarness {
fn new() -> Self {
let mut bridgedb = BridgeDb::new();
let mut lox_auth = BridgeAuth::new(bridgedb.pubkey);
// Make 3 x num_buckets open invitation bridges, in sets of 3
for _ in 0..5 {
let bucket = [
lox_context::random(),
lox_context::random(),
lox_context::random(),
];
lox_auth.add_openinv_bridges(bucket, &mut bridgedb);
}
// Add hot_spare more hot spare buckets
for _ in 0..5 {
let bucket = [
lox_context::random(),
lox_context::random(),
lox_context::random(),
];
lox_auth.add_spare_bucket(bucket);
}
// Create the encrypted bridge table
lox_auth.enc_bridge_table();
let context = lox_context::LoxServerContext {
db: Arc::new(Mutex::new(bridgedb)),
ba: Arc::new(Mutex::new(lox_auth)),
extra_bridges: Arc::new(Mutex::new(Vec::new())),
unreplaced_bridges: Arc::new(Mutex::new(Vec::new())),
};
Self { context }
}
}
#[tokio::test]
async fn test_handle() {
let th = TestHarness::new();
let lc = LoxClientMock {};
// Test Invite
let invite_request = lc.invite();
let response = handle(th.context.clone(), invite_request).await.unwrap();
println!("Server response?: {:?}", response);
assert_eq!(response.status(), StatusCode::OK);
// Test Reachability
let reachability_request = lc.reachability();
let reachability_response = handle(th.context.clone(), reachability_request)
.await
.unwrap();
println!("Server response?: {:?}", reachability_response);
assert_eq!(reachability_response.status(), StatusCode::OK);
// Test Pubkeys
let pubkey_request = lc.pubkeys();
let pubkey_response = handle(th.context.clone(), pubkey_request).await.unwrap();
println!("Server response?: {:?}", pubkey_response);
assert_eq!(pubkey_response.status(), StatusCode::OK);
}
}

3
crates/lox-library/src/lib.rs
View File

@ -413,8 +413,7 @@ impl BridgeAuth {
if let Some(replacement) = available_bridge {
for (bucketnum, offset) in positions.iter() {
assert!(self.bridge_table.buckets[*bucketnum as usize][*offset] == *bridge);
self.bridge_table.buckets[*bucketnum as usize][*offset] =
*replacement;
self.bridge_table.buckets[*bucketnum as usize][*offset] = *replacement;
// Remove the bridge from the reachable bridges and add new bridge
self.bridge_table
.reachable

46
crates/lox-library/src/tests.rs
View File

@ -597,22 +597,48 @@ fn test_allocate_bridges() {
for _ in 0..3 {
distributor_bridges.push(BridgeLine::random());
}
assert!(!distributor_bridges.is_empty(), "No BridgeLines in distributor_bridges");
assert!(
!distributor_bridges.is_empty(),
"No BridgeLines in distributor_bridges"
);
th.ba.allocate_bridges(distributor_bridges, &mut th.bdb);
assert!(distributor_bridges.is_empty(), "BridgeLines in distributor_bridges were not allocated");
assert!(th.ba.bridge_table.buckets.len() > table_size, "Size of bridge table did not increase");
assert!(
distributor_bridges.is_empty(),
"BridgeLines in distributor_bridges were not allocated"
);
assert!(
th.ba.bridge_table.buckets.len() > table_size,
"Size of bridge table did not increase"
);
let table_size = th.ba.bridge_table.buckets.len();
for _ in 0..2 {
distributor_bridges.push(BridgeLine::random());
th.ba.bridge_table.unallocated_bridges.push(BridgeLine::random());
th.ba
.bridge_table
.unallocated_bridges
.push(BridgeLine::random());
}
assert!(!th.ba.bridge_table.unallocated_bridges.is_empty(), "No BridgeLines in unallocated bridges");
assert!(!distributor_bridges.is_empty(), "No BridgeLines in distributor_bridges");
assert!(
!th.ba.bridge_table.unallocated_bridges.is_empty(),
"No BridgeLines in unallocated bridges"
);
assert!(
!distributor_bridges.is_empty(),
"No BridgeLines in distributor_bridges"
);
th.ba.allocate_bridges(distributor_bridges, &mut th.bdb);
assert!(th.ba.bridge_table.unallocated_bridges.len() == 1, "Incorrect number of bridges remain unallocated");
assert!(distributor_bridges.is_empty(), "BridgeLines in distributor_bridges were not allocated");
assert!(th.ba.bridge_table.buckets.len() > table_size, "Size of bridge table did not increase");
assert!(
th.ba.bridge_table.unallocated_bridges.len() == 1,
"Incorrect number of bridges remain unallocated"
);
assert!(
distributor_bridges.is_empty(),
"BridgeLines in distributor_bridges were not allocated"
);
assert!(
th.ba.bridge_table.buckets.len() > table_size,
"Size of bridge table did not increase"
);
}
#[test]

2
crates/lox-utils/Cargo.toml
View File

@ -1,5 +1,5 @@
[package]
name = "lox-utils"
name = "lox_utils"
version = "0.1.0"
authors = ["The Tor Project, Inc.", "Lindsey Tulloch <onyinyang@torproject.org"]
edition = "2021"

8
crates/lox-utils/src/lib.rs
View File

@ -1,9 +1,9 @@
use lox::IssuerPubKey;
use lox::bridge_table::{BridgeLine, ENC_BUCKET_BYTES};
use lox::cred::{Invitation, Lox};
use lox::proto;
use lox::cred::{Lox, Invitation};
use lox::bridge_table::{ENC_BUCKET_BYTES, BridgeLine};
use lox::IssuerPubKey;
use serde::{Deserialize, Serialize};
use serde_with::{serde_as};
use serde_with::serde_as;
#[derive(Deserialize, Serialize)]
pub struct OpenReqState {

129
crates/lox-wasm/src/lib.rs
View File

@ -1,18 +1,19 @@
use chrono::{Duration, Utc};
use julianday::JulianDay;
use lox::bridge_table::{BridgeLine,from_scalar,BridgeTable, ENC_BUCKET_BYTES};
use lox::bridge_table::{from_scalar, BridgeLine, BridgeTable, ENC_BUCKET_BYTES};
use lox::cred::{BucketReachability, Invitation, Lox, Migration};
use lox::proto::{open_invite, trust_promotion, migration, level_up,
issue_invite, redeem_invite, check_blockage, blockage_migration};
use lox::{IssuerPubKey, OPENINV_LENGTH, scalar_u32};
use lox::proto::{
blockage_migration, check_blockage, issue_invite, level_up, migration, open_invite,
redeem_invite, trust_promotion,
};
use lox::{scalar_u32, IssuerPubKey, OPENINV_LENGTH};
use serde::{Deserialize, Serialize};
use serde_with::{serde_as};
use serde_with::serde_as;
use std::array::TryFromSliceError;
use std::{panic};
use std::panic;
use wasm_bindgen::prelude::*;
use zkp::ProofError;
#[derive(Deserialize, Serialize)]
struct OpenReqState {
request: open_invite::Request,
@ -61,8 +62,6 @@ struct BlockageMigReqState {
state: blockage_migration::State,
}
#[derive(Debug, Deserialize, Serialize)]
struct PubKeys {
lox_pub: IssuerPubKey,
@ -97,7 +96,6 @@ fn test_today(days: i64) -> u32 {
JulianDay::from(naive_now_plus).inner().try_into().unwrap()
}
//pub const MAX_LEVEL: usize = 4;
//pub const LEVEL_INTERVAL: [u32; MAX_LEVEL + 1] = [0, 14, 28, 56, 84];
fn calc_test_days(lox_cred: &Lox) -> Result<i64, ProofError> {
@ -120,7 +118,6 @@ extern "C" {
pub fn log(s: &str);
}
#[wasm_bindgen]
pub fn set_panic_hook() {
panic::set_hook(Box::new(console_error_panic_hook::hook));
@ -136,10 +133,7 @@ pub fn open_invite(invite: &[u8]) -> Result<String, JsValue> {
Err(e) => return Err(JsValue::from(e.to_string())),
};
let (request, state) = open_invite::request(&token);
let req_state = OpenReqState {
request,
state,
};
let req_state = OpenReqState { request, state };
unsafe {
log(&format!(
"Formatted open invite request: {}",
@ -246,12 +240,20 @@ pub fn handle_trust_promotion(
}
#[wasm_bindgen]
pub fn trust_migration(open_lox_cred: String, trust_promo_cred: String, lox_pub: String) -> Result<String, JsValue> {
pub fn trust_migration(
open_lox_cred: String,
trust_promo_cred: String,
lox_pub: String,
) -> Result<String, JsValue> {
let lox_cred: LoxCredential = serde_json::from_str(&open_lox_cred).unwrap();
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let mig_cred: Migration = serde_json::from_str(&trust_promo_cred).unwrap();
let tm_result =
match migration::request(&lox_cred.lox_credential, &mig_cred, &pubkeys.lox_pub, &pubkeys.migration_pub) {
let tm_result = match migration::request(
&lox_cred.lox_credential,
&mig_cred,
&pubkeys.lox_pub,
&pubkeys.migration_pub,
) {
Ok(tm_result) => tm_result,
Err(e) => {
log(&format!("Error: {:?}", e.to_string()));
@ -275,14 +277,17 @@ pub fn trust_migration(open_lox_cred: String, trust_promo_cred: String, lox_pub:
pub fn handle_trust_migration(
trust_migration_request: String,
trust_migration_response: String,
lox_pub: String
lox_pub: String,
) -> Result<String, JsValue> {
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let req_state: MigReqState = serde_json::from_str(&trust_migration_request).unwrap();
let deserialized_state = req_state.state;
let deserialized_response = serde_json::from_str(&trust_migration_response).unwrap();
let level_one_cred =
match migration::handle_response(deserialized_state, deserialized_response, &pubkeys.lox_pub) {
let level_one_cred = match migration::handle_response(
deserialized_state,
deserialized_response,
&pubkeys.lox_pub,
) {
Ok(level_1_cred) => LoxCredential {
lox_credential: level_1_cred,
bridgeline: None,
@ -310,7 +315,11 @@ fn generate_reachability_cred(lox_cred: &Lox, encrypted_table: String) -> Bucket
}
#[wasm_bindgen]
pub fn level_up(level_one_cred: String, encrypted_table: String, lox_pub: String) -> Result<String, JsValue> {
pub fn level_up(
level_one_cred: String,
encrypted_table: String,
lox_pub: String,
) -> Result<String, JsValue> {
let lox_cred: LoxCredential = serde_json::from_str(&level_one_cred).unwrap();
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let reach_cred = generate_reachability_cred(&lox_cred.lox_credential, encrypted_table);
@ -329,7 +338,8 @@ pub fn level_up(level_one_cred: String, encrypted_table: String, lox_pub: String
};
log(&format!(
"TEST ONLY: Add 31 (open invitation) + Trust Level*85 days to today's date: {}", test_today(test_cumulative_days)
"TEST ONLY: Add 31 (open invitation) + Trust Level*85 days to today's date: {}",
test_today(test_cumulative_days)
));
let lu_result =
//CHANGE add_today(31) to today() for production
@ -353,19 +363,21 @@ pub fn level_up(level_one_cred: String, encrypted_table: String, lox_pub: String
Ok(serde_json::to_string(&req_state).unwrap())
}
#[wasm_bindgen]
pub fn handle_level_up(
levelup_request: String,
levelup_response: String,
lox_pub: String
lox_pub: String,
) -> Result<String, JsValue> {
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let req_state: LevelupReqState = serde_json::from_str(&levelup_request).unwrap();
let deserialized_state = req_state.state;
let deserialized_response = serde_json::from_str(&levelup_response).unwrap();
let level_up_cred =
match level_up::handle_response(deserialized_state, deserialized_response, &pubkeys.lox_pub) {
let level_up_cred = match level_up::handle_response(
deserialized_state,
deserialized_response,
&pubkeys.lox_pub,
) {
Ok(level_up_cred) => LoxCredential {
lox_credential: level_up_cred,
bridgeline: None,
@ -386,13 +398,22 @@ pub fn handle_level_up(
}
#[wasm_bindgen]
pub fn issue_invite(trusted_cred: String, encrypted_table: String, lox_pub: String) -> Result<String, JsValue> {
pub fn issue_invite(
trusted_cred: String,
encrypted_table: String,
lox_pub: String,
) -> Result<String, JsValue> {
let lox_cred: LoxCredential = serde_json::from_str(&trusted_cred).unwrap();
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let reach_cred = generate_reachability_cred(&lox_cred.lox_credential, encrypted_table);
let issue_result =
match issue_invite::request(&lox_cred.lox_credential, &reach_cred, &pubkeys.lox_pub, &pubkeys.reachability_pub, test_today(371)) {
let issue_result = match issue_invite::request(
&lox_cred.lox_credential,
&reach_cred,
&pubkeys.lox_pub,
&pubkeys.reachability_pub,
test_today(371),
) {
Ok(issue_result) => issue_result,
Err(e) => {
log(&format!("Error: {:?}", e.to_string()));
@ -412,19 +433,22 @@ pub fn issue_invite(trusted_cred: String, encrypted_table: String, lox_pub: Stri
Ok(serde_json::to_string(&req_state).unwrap())
}
#[wasm_bindgen]
pub fn handle_issue_invite(
issue_invite_request: String,
issue_invite_response: String,
lox_pub: String
lox_pub: String,
) -> Result<String, JsValue> {
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let req_state: IssueInviteReqState = serde_json::from_str(&issue_invite_request).unwrap();
let deserialized_state = req_state.state;
let deserialized_response = serde_json::from_str(&issue_invite_response).unwrap();
let issue_invite_cred =
match issue_invite::handle_response(deserialized_state, deserialized_response, &pubkeys.lox_pub, &pubkeys.invitation_pub) {
let issue_invite_cred = match issue_invite::handle_response(
deserialized_state,
deserialized_response,
&pubkeys.lox_pub,
&pubkeys.invitation_pub,
) {
Ok(issue_invite_cred) => issue_invite_cred,
Err(e) => {
log(&format!("Error: {:?}", e.to_string()));
@ -487,14 +511,17 @@ pub fn redeem_invite(invitation: String, lox_pub: String) -> Result<String, JsVa
pub fn handle_redeem_invite(
redeem_invite_request: String,
redeem_invite_response: String,
lox_pub: String
lox_pub: String,
) -> Result<String, JsValue> {
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let req_state: RedeemReqState = serde_json::from_str(&redeem_invite_request).unwrap();
let deserialized_state = req_state.state;
let deserialized_response = serde_json::from_str(&redeem_invite_response).unwrap();
let redeem_invite_cred =
match redeem_invite::handle_response(deserialized_state, deserialized_response, &pubkeys.lox_pub) {
let redeem_invite_cred = match redeem_invite::handle_response(
deserialized_state,
deserialized_response,
&pubkeys.lox_pub,
) {
Ok(issue_invite_cred) => LoxCredential {
lox_credential: issue_invite_cred,
bridgeline: None,
@ -514,13 +541,11 @@ pub fn handle_redeem_invite(
Ok(serde_json::to_string(&redeem_invite_cred).unwrap())
}
#[wasm_bindgen]
pub fn check_blockage(lox_cred: String, lox_pub: String) -> Result<String, JsValue> {
let lox: LoxCredential = serde_json::from_str(&lox_cred).unwrap();
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let cb_result =
match check_blockage::request(&lox.lox_credential, &pubkeys.lox_pub) {
let cb_result = match check_blockage::request(&lox.lox_credential, &pubkeys.lox_pub) {
Ok(cb_result) => cb_result,
Err(e) => {
log(&format!("Error: {:?}", e.to_string()));
@ -565,14 +590,21 @@ pub fn handle_check_blockage(
Ok(serde_json::to_string(&migration_cred).unwrap())
}
#[wasm_bindgen]
pub fn blockage_migration(lox_cred: String, check_migration_cred: String, lox_pub: String) -> Result<String, JsValue> {
pub fn blockage_migration(
lox_cred: String,
check_migration_cred: String,
lox_pub: String,
) -> Result<String, JsValue> {
let lox_cred: LoxCredential = serde_json::from_str(&lox_cred).unwrap();
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let mig_cred: Migration = serde_json::from_str(&check_migration_cred).unwrap();
let bm_result =
match blockage_migration::request(&lox_cred.lox_credential, &mig_cred, &pubkeys.lox_pub, &pubkeys.migration_pub) {
let bm_result = match blockage_migration::request(
&lox_cred.lox_credential,
&mig_cred,
&pubkeys.lox_pub,
&pubkeys.migration_pub,
) {
Ok(bm_result) => bm_result,
Err(e) => {
log(&format!("Error: {:?}", e.to_string()));
@ -596,14 +628,17 @@ pub fn blockage_migration(lox_cred: String, check_migration_cred: String, lox_pu
pub fn handle_blockage_migration(
blockage_migration_request: String,
blockage_migration_response: String,
lox_pub: String
lox_pub: String,
) -> Result<String, JsValue> {
let pubkeys: PubKeys = serde_json::from_str(&lox_pub).unwrap();
let req_state: BlockageMigReqState = serde_json::from_str(&blockage_migration_request).unwrap();
let deserialized_state = req_state.state;
let deserialized_response = serde_json::from_str(&blockage_migration_response).unwrap();
let lox_cred =
match blockage_migration::handle_response(deserialized_state, deserialized_response, &pubkeys.lox_pub) {
let lox_cred = match blockage_migration::handle_response(
deserialized_state,
deserialized_response,
&pubkeys.lox_pub,
) {
Ok(lox_cred) => LoxCredential {
lox_credential: lox_cred,
bridgeline: None,