From 9c959486bea9d4886b8754fe1bb9e53f91813aac Mon Sep 17 00:00:00 2001 From: onyinyang Date: Tue, 13 Jun 2023 12:03:06 -0400 Subject: [PATCH] Add better error handling for bad requests --- crates/lox-distributor/src/lox_context.rs | 224 ++++++++++++++---- crates/lox-distributor/src/request_handler.rs | 11 +- 2 files changed, 181 insertions(+), 54 deletions(-) diff --git a/crates/lox-distributor/src/lox_context.rs b/crates/lox-distributor/src/lox_context.rs index 7ffca61..4f8920a 100644 --- a/crates/lox-distributor/src/lox_context.rs +++ b/crates/lox-distributor/src/lox_context.rs @@ -10,6 +10,7 @@ use lox::{ }; use lox_utils; use std::sync::{Arc, Mutex}; +use zkp::ProofError; #[derive(Clone)] 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 pub fn generate_invite(context: LoxServerContext) -> Response { let invite = context.gen_invite(); - let token = serde_json::to_string(&invite).unwrap(); - prepare_header(token) + match serde_json::to_string(&invite) { + 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 pub fn send_reachability_cred(context: LoxServerContext) -> Response { let enc_table = context.encrypt_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 pub fn send_keys(context: LoxServerContext) -> Response { 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 { - let req: open_invite::Request = serde_json::from_slice(&request).unwrap(); - let response = context.open_inv(req); - let open_invite_resp_str = serde_json::to_string(&response).unwrap(); - prepare_header(open_invite_resp_str) + let req = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + 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 { - let req: trust_promotion::Request = serde_json::from_slice(&request).unwrap(); - let response = context.trust_promo(req); - let trust_promo_resp_str = serde_json::to_string(&response).unwrap(); - prepare_header(trust_promo_resp_str) + let req: trust_promotion::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + 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( request: Bytes, context: LoxServerContext, ) -> Response { - let req: migration::Request = serde_json::from_slice(&request).unwrap(); - let response = context.trust_migration(req); - let resp_str = serde_json::to_string(&response).unwrap(); - prepare_header(resp_str) + let req: migration::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + 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 { - let req: level_up::Request = serde_json::from_slice(&request).unwrap(); - let response = context.level_up(req); - let level_up_resp_str = serde_json::to_string(&response).unwrap(); - prepare_header(level_up_resp_str) + let req: level_up::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + 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 { - let req: issue_invite::Request = serde_json::from_slice(&request).unwrap(); - let response = context.issue_invite(req); - let issue_invite_resp_str = serde_json::to_string(&response).unwrap(); - prepare_header(issue_invite_resp_str) + let req: issue_invite::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + 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 { - let req: redeem_invite::Request = serde_json::from_slice(&request).unwrap(); - let response = context.redeem_invite(req); - let redeem_invite_resp_str = serde_json::to_string(&response).unwrap(); - prepare_header(redeem_invite_resp_str) + let req: redeem_invite::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + 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 { - let req: check_blockage::Request = serde_json::from_slice(&request).unwrap(); - let response = context.check_blockage(req); - let check_blockage_resp_str = serde_json::to_string(&response).unwrap(); - prepare_header(check_blockage_resp_str) + let req: check_blockage::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + 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( request: Bytes, context: LoxServerContext, ) -> Response { - let req: blockage_migration::Request = serde_json::from_slice(&request).unwrap(); - let response = context.blockage_migration(req); - let resp_str = serde_json::to_string(&response).unwrap(); - prepare_header(resp_str) + let req: blockage_migration::Request = match serde_json::from_slice(&request) { + Ok(req) => req, + Err(e) => return prepare_error_header(e.to_string()), + }; + 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 { @@ -248,3 +361,10 @@ fn prepare_header(response: String) -> Response { .insert("Access-Control-Allow-Origin", HeaderValue::from_static("*")); resp } + +fn prepare_error_header(error: String) -> Response { + Response::builder() + .status(hyper::StatusCode::BAD_REQUEST) + .body(Body::from(error)) + .unwrap() +} diff --git a/crates/lox-distributor/src/request_handler.rs b/crates/lox-distributor/src/request_handler.rs index 91e01c4..5cffe12 100644 --- a/crates/lox-distributor/src/request_handler.rs +++ b/crates/lox-distributor/src/request_handler.rs @@ -336,6 +336,15 @@ mod tests { let not_found_response = handle(th.context.clone(), four_oh_four_req).await.unwrap(); 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 let invite_request = lc.invite(); let invite_response = handle(th.context.clone(), invite_request).await.unwrap(); @@ -616,7 +625,5 @@ mod tests { .await .unwrap(); assert_eq!(blockagemig_response.status(), StatusCode::OK); - - // Test Level up } }