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

Add better error handling for bad requests

This commit is contained in:
onyinyang 2023-06-13 12:03:06 -04:00
parent e1f7cda652
commit 9c959486be
No known key found for this signature in database
GPG Key ID: 156A6435430C2036
2 changed files with 181 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
crates/lox-distributor/src/lox_context.rs
View File

@ -10,6 +10,7 @@ use lox::{
}; };
use lox_utils; use lox_utils;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use zkp::ProofError;
#[derive(Clone)] #[derive(Clone)]
pub struct LoxServerContext { pub struct LoxServerContext {
@ -119,127 +120,239 @@ impl LoxServerContext {
} }
} }
fn open_inv(&self, req: open_invite::Request) -> open_invite::Response { fn open_inv(&self, req: open_invite::Request) -> Result<open_invite::Response, ProofError> {
let mut ba_obj = self.ba.lock().unwrap(); let mut ba_obj = self.ba.lock().unwrap();
ba_obj.handle_open_invite(req).unwrap() ba_obj.handle_open_invite(req)
} }
fn trust_promo(&self, req: trust_promotion::Request) -> trust_promotion::Response { fn trust_promo(
&self,
req: trust_promotion::Request,
) -> Result<trust_promotion::Response, ProofError> {
let mut ba_obj = self.ba.lock().unwrap(); let mut ba_obj = self.ba.lock().unwrap();
ba_obj.handle_trust_promotion(req).unwrap() ba_obj.handle_trust_promotion(req)
} }
fn trust_migration(&self, req: migration::Request) -> migration::Response { fn trust_migration(&self, req: migration::Request) -> Result<migration::Response, ProofError> {
let mut ba_obj = self.ba.lock().unwrap(); let mut ba_obj = self.ba.lock().unwrap();
ba_obj.handle_migration(req).unwrap() ba_obj.handle_migration(req)
} }
fn level_up(&self, req: level_up::Request) -> level_up::Response { fn level_up(&self, req: level_up::Request) -> Result<level_up::Response, ProofError> {
let mut ba_obj = self.ba.lock().unwrap(); let mut ba_obj = self.ba.lock().unwrap();
ba_obj.handle_level_up(req).unwrap() ba_obj.handle_level_up(req)
} }
fn issue_invite(&self, req: issue_invite::Request) -> issue_invite::Response { fn issue_invite(
&self,
req: issue_invite::Request,
) -> Result<issue_invite::Response, ProofError> {
let mut ba_obj = self.ba.lock().unwrap(); let mut ba_obj = self.ba.lock().unwrap();
ba_obj.handle_issue_invite(req).unwrap() ba_obj.handle_issue_invite(req)
} }
fn redeem_invite(&self, req: redeem_invite::Request) -> redeem_invite::Response { fn redeem_invite(
&self,
req: redeem_invite::Request,
) -> Result<redeem_invite::Response, ProofError> {
let mut ba_obj = self.ba.lock().unwrap(); let mut ba_obj = self.ba.lock().unwrap();
ba_obj.handle_redeem_invite(req).unwrap() ba_obj.handle_redeem_invite(req)
} }
fn check_blockage(&self, req: check_blockage::Request) -> check_blockage::Response { fn check_blockage(
&self,
req: check_blockage::Request,
) -> Result<check_blockage::Response, ProofError> {
let mut ba_obj = self.ba.lock().unwrap(); let mut ba_obj = self.ba.lock().unwrap();
ba_obj.handle_check_blockage(req).unwrap() ba_obj.handle_check_blockage(req)
} }
fn blockage_migration(&self, req: blockage_migration::Request) -> blockage_migration::Response { fn blockage_migration(
&self,
req: blockage_migration::Request,
) -> Result<blockage_migration::Response, ProofError> {
let mut ba_obj = self.ba.lock().unwrap(); let mut ba_obj = self.ba.lock().unwrap();
ba_obj.handle_blockage_migration(req).unwrap() ba_obj.handle_blockage_migration(req)
} }
} }
// Generate and return an open invitation token // Generate and return an open invitation token
pub fn generate_invite(context: LoxServerContext) -> Response<Body> { pub fn generate_invite(context: LoxServerContext) -> Response<Body> {
let invite = context.gen_invite(); let invite = context.gen_invite();
let token = serde_json::to_string(&invite).unwrap(); match serde_json::to_string(&invite) {
prepare_header(token) Ok(resp) => prepare_header(resp),
Err(e) => {
println!("Error parsing Invite to JSON");
prepare_error_header(e.to_string())
}
}
} }
// Return the serialized encrypted bridge table // Return the serialized encrypted bridge table
pub fn send_reachability_cred(context: LoxServerContext) -> Response<Body> { pub fn send_reachability_cred(context: LoxServerContext) -> Response<Body> {
let enc_table = context.encrypt_table(); let enc_table = context.encrypt_table();
let etable = lox_utils::EncBridgeTable { etable: enc_table }; let etable = lox_utils::EncBridgeTable { etable: enc_table };
prepare_header(serde_json::to_string(&etable).unwrap()) match serde_json::to_string(&etable) {
Ok(resp) => prepare_header(resp),
Err(e) => {
println!("Error parsing encrypted bridgetable to JSON");
prepare_error_header(e.to_string())
}
}
} }
// Return the serialized pubkeys for the Bridge Authority // Return the serialized pubkeys for the Bridge Authority
pub fn send_keys(context: LoxServerContext) -> Response<Body> { pub fn send_keys(context: LoxServerContext) -> Response<Body> {
let pubkeys = context.pubkeys(); let pubkeys = context.pubkeys();
prepare_header(serde_json::to_string(&pubkeys).unwrap()) match serde_json::to_string(&pubkeys) {
Ok(resp) => prepare_header(resp),
Err(e) => {
println!("Error parsing Pubkeys to JSON");
prepare_error_header(e.to_string())
}
}
} }
pub fn verify_and_send_open_cred(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_open_cred(request: Bytes, context: LoxServerContext) -> Response<Body> {
let req: open_invite::Request = serde_json::from_slice(&request).unwrap(); let req = match serde_json::from_slice(&request) {
let response = context.open_inv(req); Ok(req) => req,
let open_invite_resp_str = serde_json::to_string(&response).unwrap(); Err(e) => return prepare_error_header(e.to_string()),
prepare_header(open_invite_resp_str) };
match context.open_inv(req) {
Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap();
prepare_header(response)
}
Err(e) => {
println!("Invalid Open Invitation request, Proof Error");
prepare_error_header(e.to_string())
}
}
} }
pub fn verify_and_send_trust_promo(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_trust_promo(request: Bytes, context: LoxServerContext) -> Response<Body> {
let req: trust_promotion::Request = serde_json::from_slice(&request).unwrap(); let req: trust_promotion::Request = match serde_json::from_slice(&request) {
let response = context.trust_promo(req); Ok(req) => req,
let trust_promo_resp_str = serde_json::to_string(&response).unwrap(); Err(e) => return prepare_error_header(e.to_string()),
prepare_header(trust_promo_resp_str) };
match context.trust_promo(req) {
Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap();
prepare_header(response)
}
Err(e) => {
println!("Invalid Trust Promotion request, Proof Error");
prepare_error_header(e.to_string())
}
}
} }
pub fn verify_and_send_trust_migration( pub fn verify_and_send_trust_migration(
request: Bytes, request: Bytes,
context: LoxServerContext, context: LoxServerContext,
) -> Response<Body> { ) -> Response<Body> {
let req: migration::Request = serde_json::from_slice(&request).unwrap(); let req: migration::Request = match serde_json::from_slice(&request) {
let response = context.trust_migration(req); Ok(req) => req,
let resp_str = serde_json::to_string(&response).unwrap(); Err(e) => return prepare_error_header(e.to_string()),
prepare_header(resp_str) };
match context.trust_migration(req) {
Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap();
prepare_header(response)
}
Err(e) => {
println!("Invalid Trust Migration request, Proof Error");
prepare_error_header(e.to_string())
}
}
} }
pub fn verify_and_send_level_up(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_level_up(request: Bytes, context: LoxServerContext) -> Response<Body> {
let req: level_up::Request = serde_json::from_slice(&request).unwrap(); let req: level_up::Request = match serde_json::from_slice(&request) {
let response = context.level_up(req); Ok(req) => req,
let level_up_resp_str = serde_json::to_string(&response).unwrap(); Err(e) => return prepare_error_header(e.to_string()),
prepare_header(level_up_resp_str) };
match context.level_up(req) {
Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap();
prepare_header(response)
}
Err(e) => {
println!("Invalid Level up request, Proof Error");
prepare_error_header(e.to_string())
}
}
} }
pub fn verify_and_send_issue_invite(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_issue_invite(request: Bytes, context: LoxServerContext) -> Response<Body> {
let req: issue_invite::Request = serde_json::from_slice(&request).unwrap(); let req: issue_invite::Request = match serde_json::from_slice(&request) {
let response = context.issue_invite(req); Ok(req) => req,
let issue_invite_resp_str = serde_json::to_string(&response).unwrap(); Err(e) => return prepare_error_header(e.to_string()),
prepare_header(issue_invite_resp_str) };
match context.issue_invite(req) {
Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap();
prepare_header(response)
}
Err(e) => {
println!("Invalid Issue invite request, Proof Error");
prepare_error_header(e.to_string())
}
}
} }
pub fn verify_and_send_redeem_invite(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_redeem_invite(request: Bytes, context: LoxServerContext) -> Response<Body> {
let req: redeem_invite::Request = serde_json::from_slice(&request).unwrap(); let req: redeem_invite::Request = match serde_json::from_slice(&request) {
let response = context.redeem_invite(req); Ok(req) => req,
let redeem_invite_resp_str = serde_json::to_string(&response).unwrap(); Err(e) => return prepare_error_header(e.to_string()),
prepare_header(redeem_invite_resp_str) };
match context.redeem_invite(req) {
Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap();
prepare_header(response)
}
Err(e) => {
println!("Invalid Redeem Invite request, Proof Error");
prepare_error_header(e.to_string())
}
}
} }
pub fn verify_and_send_check_blockage(request: Bytes, context: LoxServerContext) -> Response<Body> { pub fn verify_and_send_check_blockage(request: Bytes, context: LoxServerContext) -> Response<Body> {
let req: check_blockage::Request = serde_json::from_slice(&request).unwrap(); let req: check_blockage::Request = match serde_json::from_slice(&request) {
let response = context.check_blockage(req); Ok(req) => req,
let check_blockage_resp_str = serde_json::to_string(&response).unwrap(); Err(e) => return prepare_error_header(e.to_string()),
prepare_header(check_blockage_resp_str) };
match context.check_blockage(req) {
Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap();
prepare_header(response)
}
Err(e) => {
println!("Invalid Check blockage request, Proof Error");
prepare_error_header(e.to_string())
}
}
} }
pub fn verify_and_send_blockage_migration( pub fn verify_and_send_blockage_migration(
request: Bytes, request: Bytes,
context: LoxServerContext, context: LoxServerContext,
) -> Response<Body> { ) -> Response<Body> {
let req: blockage_migration::Request = serde_json::from_slice(&request).unwrap(); let req: blockage_migration::Request = match serde_json::from_slice(&request) {
let response = context.blockage_migration(req); Ok(req) => req,
let resp_str = serde_json::to_string(&response).unwrap(); Err(e) => return prepare_error_header(e.to_string()),
prepare_header(resp_str) };
match context.blockage_migration(req) {
Ok(resp) => {
let response = serde_json::to_string(&resp).unwrap();
prepare_header(response)
}
Err(e) => {
println!("Invalid Blockage Migration request, Proof Error");
prepare_error_header(e.to_string())
}
}
} }
fn prepare_header(response: String) -> Response<Body> { fn prepare_header(response: String) -> Response<Body> {
@ -248,3 +361,10 @@ fn prepare_header(response: String) -> Response<Body> {
.insert("Access-Control-Allow-Origin", HeaderValue::from_static("*")); .insert("Access-Control-Allow-Origin", HeaderValue::from_static("*"));
resp resp
} }
fn prepare_error_header(error: String) -> Response<Body> {
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(error))
.unwrap()
}

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

@ -336,6 +336,15 @@ mod tests {
let not_found_response = handle(th.context.clone(), four_oh_four_req).await.unwrap(); let not_found_response = handle(th.context.clone(), four_oh_four_req).await.unwrap();
assert_eq!(not_found_response.status(), StatusCode::NOT_FOUND); assert_eq!(not_found_response.status(), StatusCode::NOT_FOUND);
// Test that empty request to a credential issuing endpoint fails
let req = Request::builder()
.method("POST")
.uri("http://localhost/checkblockage")
.body(Body::empty())
.unwrap();
let not_found_response = handle(th.context.clone(), req).await.unwrap();
assert_eq!(not_found_response.status(), StatusCode::BAD_REQUEST);
// Test Invite // Test Invite
let invite_request = lc.invite(); let invite_request = lc.invite();
let invite_response = handle(th.context.clone(), invite_request).await.unwrap(); let invite_response = handle(th.context.clone(), invite_request).await.unwrap();
@ -616,7 +625,5 @@ mod tests {
.await .await
.unwrap(); .unwrap();
assert_eq!(blockagemig_response.status(), StatusCode::OK); assert_eq!(blockagemig_response.status(), StatusCode::OK);
// Test Level up
} }
} }