From 9a83d0c7bccb2ef05bcfa7d8f926339e189e8bb0 Mon Sep 17 00:00:00 2001 From: PinkP4nther <0x0090@protonmail.com> Date: Thu, 19 Aug 2021 14:52:54 -0700 Subject: [PATCH] Organized Code --- examples/basic/Cargo.toml | 2 +- examples/basic/{ => src}/main.rs | 8 +- src/data.rs | 139 +++++++++ src/http.rs | 314 ++++++++++++++++++++ src/lib.rs | 484 ++----------------------------- 5 files changed, 476 insertions(+), 471 deletions(-) rename examples/basic/{ => src}/main.rs (79%) create mode 100644 src/data.rs create mode 100644 src/http.rs diff --git a/examples/basic/Cargo.toml b/examples/basic/Cargo.toml index a2142a0..1863f6d 100644 --- a/examples/basic/Cargo.toml +++ b/examples/basic/Cargo.toml @@ -6,4 +6,4 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -sslrelay = {path = "../SSLRelay-lib"} \ No newline at end of file +sslrelay = {path = "../../"} diff --git a/examples/basic/main.rs b/examples/basic/src/main.rs similarity index 79% rename from examples/basic/main.rs rename to examples/basic/src/main.rs index c366b13..1fadada 100644 --- a/examples/basic/main.rs +++ b/examples/basic/src/main.rs @@ -11,22 +11,22 @@ struct Handler; impl HandlerCallbacks for Handler { // Request non blocking callback - fn req_nb_callback(&self, _in_data: Vec) { + fn ds_nb_callback(&self, _in_data: Vec) { println!("[+] Request Non Blocking CallBack!"); } // Request blocking callback - fn req_b_callback(&self, _in_data: &mut Vec) { + fn ds_b_callback(&self, _in_data: &mut Vec) { println!("[+] Request Blocking CallBack!"); } // Response non blocking callback - fn res_nb_callback(&self, _in_data: Vec) { + fn us_nb_callback(&self, _in_data: Vec) { println!("[+] Response Non Blocking CallBack!"); } // Response blocking callback - fn res_b_callback(&self, _in_data: &mut Vec) { + fn us_b_callback(&self, _in_data: &mut Vec) { println!("[+] Response Blocking CallBack!"); } } diff --git a/src/data.rs b/src/data.rs new file mode 100644 index 0000000..664c81a --- /dev/null +++ b/src/data.rs @@ -0,0 +1,139 @@ +use std::time::Duration; +use openssl::ssl::{SslConnector, SslMethod, SslStream, SslVerifyMode}; +use std::net::TcpStream; +use std::io::{self, Read, Write}; + +#[derive(PartialEq)] +pub enum StreamDirection { + Upstream,// Data coming from remote host + DownStream,// Data coming from origin host +} + +pub struct DataHandler { + pub tcp_stream: Option>, + relay_stream: Option>, + remote_host: String, + pub stream_direction: StreamDirection, +} + +impl DataHandler { + + pub fn new(tcp_stream: SslStream, remote_host: String) -> Self { + let _ = tcp_stream.get_ref().set_read_timeout(Some(Duration::from_millis(100))); + DataHandler { + tcp_stream: Some(tcp_stream), + relay_stream: None, + remote_host, + stream_direction: StreamDirection::DownStream, + } + } + + pub fn get_data_stream(&mut self, data: &mut Vec) -> usize { + + let mut data_length: usize = 0; + if self.stream_direction == StreamDirection::DownStream { + loop { + + let mut r_buf = [0; 1024]; + + match self.tcp_stream.as_mut().unwrap().read(&mut r_buf) { + + Ok(bytes_read) => { + + if bytes_read == 0 { + break; + + } else if bytes_read != 0 && bytes_read <= 1024 { + + let mut tmp_buf = r_buf.to_vec(); + tmp_buf.truncate(bytes_read); + + let _bw = data.write(&tmp_buf).unwrap(); + data_length += bytes_read; + + } else { + println!("[+] Else hit!!!!!!!!!!!!!!!!!!!!!!"); + } + }, + Err(e) => { + match e.kind() { + io::ErrorKind::WouldBlock => { + break; + }, + _ => {println!("[!!!] Got error: {}",e);} + } + }, + } + } + } else if self.stream_direction == StreamDirection::Upstream { + loop { + + let mut r_buf = [0; 1024]; + + match self.relay_stream.as_mut().unwrap().read(&mut r_buf) { + + Ok(bytes_read) => { + + if bytes_read == 0 { + break; + + } else if bytes_read != 0 && bytes_read <= 1024 { + + let mut tmp_buf = r_buf.to_vec(); + tmp_buf.truncate(bytes_read); + + let _bw = data.write(&tmp_buf).unwrap(); + data_length += bytes_read; + + } else { + println!("[+] Else hit!!!!!!!!!!!!!!!!!!!!!!"); + } + }, + Err(e) => { + match e.kind() { + io::ErrorKind::WouldBlock => { + break; + }, + _ => {println!("[!!!] Got error: {}",e);} + } + }, + } + } + } + return data_length; + } + + pub fn relay_data(&mut self, data: &Vec) -> Option { + + let mut retries = 3; + loop { + + let mut sslbuild = SslConnector::builder(SslMethod::tls()).unwrap(); + sslbuild.set_verify(SslVerifyMode::NONE); + let connector = sslbuild.build(); + let stream = TcpStream::connect(&self.remote_host).unwrap(); + let _ = stream.set_read_timeout(Some(Duration::from_millis(500))); + let mut stream = match connector.connect(&self.remote_host, stream) { + Ok(s) => s, + Err(e) => { + println!("[Error] {}", e); + if retries == 0 { + println!("[!] Request relay retries: 0"); + return None; + } + retries -= 1; + continue; + } + }; + + stream.write_all(&data).unwrap(); + let _ = stream.flush(); + //println!("[+] Relayed -> {}", host); + + //return Some(stream); Instead of returning we will now set stream object + self.relay_stream = Some(stream); + return Some(0); + } + } + +} // DataHandler \ No newline at end of file diff --git a/src/http.rs b/src/http.rs new file mode 100644 index 0000000..89e641a --- /dev/null +++ b/src/http.rs @@ -0,0 +1,314 @@ +use httparse::{self, Header}; +use chunked_transfer::Decoder; +use flate2::read::GzDecoder; +use std::thread; +use std::time::Duration; +use std::io::Read; + +pub struct RelayedResponse<'a> { + http_version: Option, + http_code: Option, + http_reason: Option, + http_headers: Option>>, + http_body: Option, +} + +pub struct RelayRequest<'a> { + http_method: Option, + http_path: Option, + http_version: Option, + http_headers: Option>>, + http_body: Option, +} + +/* +fn get_req_headers<'a>(&self, data: &'a Vec) -> Option>> { + + let mut headers = [httparse::EMPTY_HEADER; 128]; + let mut request = httparse::Request::new(&mut headers); + + let req = request.parse(data).unwrap(); + + if req.is_complete() { + return Some(headers.to_vec()); + } + None +} + +fn get_res_headers(data: &Vec) -> Option> { + + let mut headers = [httparse::EMPTY_HEADER; 128]; + let mut response = httparse::Response::new(&mut headers); + + let res = response.parse(data).unwrap(); + + if res.is_complete() { + return Some(headers.to_vec()); + } + None +} + +fn get_host(&self, data: &Vec) -> Option { + + return Some("137.220.37.67".to_string()); + let mut headers = [httparse::EMPTY_HEADER; 128]; + + let mut request = httparse::Request::new(&mut headers); + + let req = request.parse(data).unwrap(); + + if req.is_complete() { + for header in headers.iter() { + if header.name == "Host" || header.name == "host" { + //println!("Host -> {}", String::from_utf8(header.value.to_vec()).unwrap()); + return Some(String::from_utf8(header.value.to_vec()).unwrap()); + } + } + None + } else if req.is_partial() { + for header in headers.iter() { + if header.name == "Host" || header.name == "host" { + //println!("Host -> {}", String::from_utf8(header.value.to_vec()).unwrap()); + return Some(String::from_utf8(header.value.to_vec()).unwrap()); + } + } + None + } else { + None + } +} + +fn get_cookie(&self, data: &Vec) -> Option { + + let mut headers = [httparse::EMPTY_HEADER; 128]; + + let mut request = httparse::Request::new(&mut headers); + + let req = request.parse(data).unwrap(); + + if req.is_complete() { + for header in headers.iter() { + if header.name == "Cookie" || header.name == "cookie" { + //println!("Host -> {}", String::from_utf8(header.value.to_vec()).unwrap()); + return Some(String::from_utf8(header.value.to_vec()).unwrap()); + } + } + None + } else if req.is_partial() { + for header in headers.iter() { + if header.name == "Cookie" || header.name == "cookie" { + //println!("Host -> {}", String::from_utf8(header.value.to_vec()).unwrap()); + return Some(String::from_utf8(header.value.to_vec()).unwrap()); + } + } + None + } else { + None + } +} +*/ + +pub fn http_req_verbose(data: &Vec, mode: u8) { + + let req_info = get_request(&data); + let req_header_list = req_info.http_headers.unwrap(); + let mut req_header_string = String::new(); + + for header in req_header_list { + if header.value.to_vec().len() == 0 {continue;} + req_header_string.push_str(format!("[-->] {}: {}\n", header.name, String::from_utf8(header.value.to_vec()).unwrap()).as_str()); + } + if mode == 1 { + println!("================================\n[-->] HTTP Version: {}\n[-->] HTTP Method: {} {}\n[-->] HTTP Headers:\n{}\n[-->] HTTP Body:\n{}\n" + ,req_info.http_version.unwrap() + ,req_info.http_method.unwrap() + ,req_info.http_path.unwrap() + ,req_header_string + ,req_info.http_body.unwrap() + ); + } else if mode == 2 { + println!("[Req] {} {}", req_info.http_method.unwrap(), req_info.http_path.unwrap()); + } +} + +pub fn http_res_verbose(response_data: &Vec, mode: u8) { + + let res_info = get_response(&response_data); + let header_list = res_info.http_headers.unwrap(); + let mut header_string = String::new(); + + for header in header_list { + if header.value.to_vec().len() == 0 {continue;} + header_string.push_str(format!("[<--] {}: {}\n", header.name, String::from_utf8(header.value.to_vec()).unwrap()).as_str()); + } + if mode == 1 { + println!("\n[<--] HTTP Version: {}\n[<--] HTTP Code: {} {}\n[<--] HTTP Headers:\n{}\n[<--] HTTP Body:\n{}\n================================\n" + ,res_info.http_version.unwrap() + ,res_info.http_code.unwrap() + ,res_info.http_reason.unwrap() + ,header_string + ,res_info.http_body.unwrap() + ); + } else if mode == 2 { + println!("[Res] {} {}", res_info.http_code.unwrap(), res_info.http_reason.unwrap()); + } +} + +pub fn get_response<'a>(data: &'a Vec) -> RelayedResponse<'a> { + + let mut headers = [httparse::EMPTY_HEADER; 128]; + let mut res = httparse::Response::new(&mut headers); + + let res_chk = res.parse(data); + + loop { + + if !res_chk.unwrap().is_complete() { + thread::sleep(Duration::from_millis(100)); + continue; + } + + let reason = match res.reason { + Some(r) => Some(r.to_string()), + None => None, + }; + + let header_vec = res.headers.to_vec(); + + let body = get_http_body(&data, header_vec).unwrap_or(String::from("[-] Failed to get http response body!").into_bytes()); + let string_body = String::from_utf8(body).unwrap(); + + return RelayedResponse { + http_version: res.version, + http_code: res.code, + http_reason: reason, + http_headers: Some(headers.to_vec()), + http_body: Some(string_body), + }; + } +} + +pub fn get_request<'a>(data: &'a Vec) -> RelayRequest<'a> { + + let mut headers = [httparse::EMPTY_HEADER; 128]; + let mut req = httparse::Request::new(&mut headers); + + let req_chk = req.parse(data); + + loop { + + if !req_chk.unwrap().is_complete() { + thread::sleep(Duration::from_millis(100)); + continue; + } + + let method = match req.method { + Some(r) => Some(r.to_string()), + None => None, + }; + + let path = match req.path { + Some(p) => Some(p.to_string()), + None => None, + }; + + let header_vec = req.headers.to_vec(); + + let body = get_http_body(&data, header_vec).unwrap_or(String::from("[-] Failed to get http request body!").into_bytes()); + let string_body = String::from_utf8(body).unwrap(); + + return RelayRequest { + http_method: method, + http_path: path, + http_version: req.version, + http_headers: Some(headers.to_vec()), + http_body: Some(string_body), + }; + } +} + +pub fn get_http_body(data: &Vec, headers: Vec
) -> Option> { + + let mut cl: u64 = 0; + let encoding_check = headers.clone(); + for header in headers { + + if header.name == "Content-Length" || header.name == "content-length" { + let length = match String::from_utf8(header.value.to_vec()) { + Ok(s) => s, + Err(e) => { + println!("[!] ERROR: {}",e); + return None; + }, + }; + + cl += length.parse::().unwrap(); + let mut r_body = data.to_vec(); + r_body.reverse(); + r_body.truncate(cl as usize); + r_body.reverse(); + + return Some(r_body); + + } else if header.name == "Transfer-Encoding" || header.name == "transfer-encoding" { + + let te_string = String::from_utf8(header.value.to_vec()).unwrap(); + + if te_string == "chunked" { + + let mut new_vec = data.to_vec(); + let new_vec_iter = new_vec.to_vec(); + let mut new_vec_iter = new_vec_iter.iter(); + let mut i = 0; + + loop { + if let Some(&0x0d) = new_vec_iter.next() { + i += 1; + if let Some(&0x0a) = new_vec_iter.next() { + i += 1; + if let Some(&0x0d) = new_vec_iter.next() { + i += 1; + if let Some(&0x0a) = new_vec_iter.next() { + i += 1; + break; + } else {i += 1;} + } else {i += 1;} + } else {i += 1;} + } else {i += 1;} + } + + new_vec.reverse(); + new_vec.truncate(data.len() - i); + new_vec.reverse(); + + let mut decoder = Decoder::new(new_vec.as_slice()); + let mut blob = Vec::new(); + let _ = decoder.read_to_end(&mut blob); + + let mut g_encoded = false; + for header in encoding_check { + if header.name == "Content-Encoding" || header.name == "content-encoding" { + let s = String::from_utf8(header.value.to_vec()).unwrap(); + if s == "gzip" { + g_encoded = true; + } + } + } + if g_encoded { + let mut gzd = GzDecoder::new(&blob[..]); + let mut unzipped = Vec::new(); + match gzd.read_to_end(&mut unzipped) { + Ok(_) => {}, + Err(_) => return None, + } + + return Some(unzipped); + } else { + return Some(blob); + } + + } + } + } + return Some(String::from("None").into_bytes()); +} \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index 510f3f3..6b8e1ff 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,35 +1,18 @@ -use openssl::ssl::{SslAcceptor, SslConnector, SslFiletype, SslMethod, SslStream, SslVerifyMode}; -use std::io::{self, Read, Write}; +use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod, SslStream}; +use std::io::Write; use std::net::{TcpListener, TcpStream}; use std::sync::{Arc, Mutex}; use std::thread; -use std::time::Duration; use std::env; use std::fs; use toml::Value as TValue; -use chunked_transfer::Decoder; +mod data; +use data::{DataHandler, StreamDirection}; -use flate2::read::GzDecoder; - -use httparse::{self, Header}; - -struct RelayedResponse<'a> { - http_version: Option, - http_code: Option, - http_reason: Option, - http_headers: Option>>, - http_body: Option, -} - -struct RelayRequest<'a> { - http_method: Option, - http_path: Option, - http_version: Option, - http_headers: Option>>, - http_body: Option, -} +mod http; +use http as http_helper; #[derive(Clone)] struct RelayConfig { @@ -44,10 +27,10 @@ struct RelayConfig { } pub trait HandlerCallbacks { - fn req_b_callback(&self, _in_data: &mut Vec){} - fn req_nb_callback(&self, _in_data: Vec){} - fn res_b_callback(&self, _in_data: &mut Vec){} - fn res_nb_callback(&self, _in_data: Vec){} + fn ds_b_callback(&self, _in_data: &mut Vec){} + fn ds_nb_callback(&self, _in_data: Vec){} + fn us_b_callback(&self, _in_data: &mut Vec){} + fn us_nb_callback(&self, _in_data: Vec){} } pub enum ConfigType { @@ -169,437 +152,8 @@ impl SSLR acceptor.check_private_key().unwrap(); Arc::new(acceptor.build()) } - - - - }// SSLRelay -#[derive(PartialEq)] -enum StreamDirection { - Upstream,// Data coming from remote host - DownStream,// Data coming from origin host -} - -struct DataHandler { - tcp_stream: Option>, - relay_stream: Option>, - remote_host: String, - stream_direction: StreamDirection, -} - -impl DataHandler { - - fn new(tcp_stream: SslStream, remote_host: String) -> Self { - let _ = tcp_stream.get_ref().set_read_timeout(Some(Duration::from_millis(100))); - DataHandler { - tcp_stream: Some(tcp_stream), - relay_stream: None, - remote_host, - stream_direction: StreamDirection::DownStream, - } - } - - fn get_data_stream(&mut self, data: &mut Vec) -> usize { - - let mut data_length: usize = 0; - if self.stream_direction == StreamDirection::DownStream { - loop { - - let mut r_buf = [0; 1024]; - - match self.tcp_stream.as_mut().unwrap().read(&mut r_buf) { - - Ok(bytes_read) => { - - if bytes_read == 0 { - break; - - } else if bytes_read != 0 && bytes_read <= 1024 { - - let mut tmp_buf = r_buf.to_vec(); - tmp_buf.truncate(bytes_read); - - let _bw = data.write(&tmp_buf).unwrap(); - data_length += bytes_read; - - } else { - println!("[+] Else hit!!!!!!!!!!!!!!!!!!!!!!"); - } - }, - Err(e) => { - match e.kind() { - io::ErrorKind::WouldBlock => { - break; - }, - _ => {println!("[!!!] Got error: {}",e);} - } - }, - } - } - } else if self.stream_direction == StreamDirection::Upstream { - loop { - - let mut r_buf = [0; 1024]; - - match self.relay_stream.as_mut().unwrap().read(&mut r_buf) { - - Ok(bytes_read) => { - - if bytes_read == 0 { - break; - - } else if bytes_read != 0 && bytes_read <= 1024 { - - let mut tmp_buf = r_buf.to_vec(); - tmp_buf.truncate(bytes_read); - - let _bw = data.write(&tmp_buf).unwrap(); - data_length += bytes_read; - - } else { - println!("[+] Else hit!!!!!!!!!!!!!!!!!!!!!!"); - } - }, - Err(e) => { - match e.kind() { - io::ErrorKind::WouldBlock => { - break; - }, - _ => {println!("[!!!] Got error: {}",e);} - } - }, - } - } - } - return data_length; - } - - fn http_req_verbose(&self, data: &Vec, mode: u8) { - - let req_info = self.get_request(&data); - let req_header_list = req_info.http_headers.unwrap(); - let mut req_header_string = String::new(); - - for header in req_header_list { - if header.value.to_vec().len() == 0 {continue;} - req_header_string.push_str(format!("[-->] {}: {}\n", header.name, String::from_utf8(header.value.to_vec()).unwrap()).as_str()); - } - if mode == 1 { - println!("================================\n[-->] HTTP Version: {}\n[-->] HTTP Method: {} {}\n[-->] HTTP Headers:\n{}\n[-->] HTTP Body:\n{}\n" - ,req_info.http_version.unwrap() - ,req_info.http_method.unwrap() - ,req_info.http_path.unwrap() - ,req_header_string - ,req_info.http_body.unwrap() - ); - } else if mode == 2 { - println!("[Req] {} {}", req_info.http_method.unwrap(), req_info.http_path.unwrap()); - } - } - - fn http_res_verbose(&self, response_data: &Vec, mode: u8) { - - let res_info = self.get_response(&response_data); - let header_list = res_info.http_headers.unwrap(); - let mut header_string = String::new(); - - for header in header_list { - if header.value.to_vec().len() == 0 {continue;} - header_string.push_str(format!("[<--] {}: {}\n", header.name, String::from_utf8(header.value.to_vec()).unwrap()).as_str()); - } - if mode == 1 { - println!("\n[<--] HTTP Version: {}\n[<--] HTTP Code: {} {}\n[<--] HTTP Headers:\n{}\n[<--] HTTP Body:\n{}\n================================\n" - ,res_info.http_version.unwrap() - ,res_info.http_code.unwrap() - ,res_info.http_reason.unwrap() - ,header_string - ,res_info.http_body.unwrap() - ); - } else if mode == 2 { - println!("[Res] {} {}", res_info.http_code.unwrap(), res_info.http_reason.unwrap()); - } - } - - fn relay_data(&mut self, data: &Vec) -> Option { - - let mut retries = 3; - loop { - - let mut sslbuild = SslConnector::builder(SslMethod::tls()).unwrap(); - sslbuild.set_verify(SslVerifyMode::NONE); - let connector = sslbuild.build(); - let stream = TcpStream::connect(&self.remote_host).unwrap(); - let _ = stream.set_read_timeout(Some(Duration::from_millis(500))); - let mut stream = match connector.connect(&self.remote_host, stream) { - Ok(s) => s, - Err(e) => { - println!("[Error] {}", e); - if retries == 0 { - println!("[!] Request relay retries: 0"); - return None; - } - retries -= 1; - continue; - } - }; - - stream.write_all(&data).unwrap(); - let _ = stream.flush(); - //println!("[+] Relayed -> {}", host); - - //return Some(stream); Instead of returning we will now set stream object - self.relay_stream = Some(stream); - return Some(0); - } - } - /* - fn get_req_headers<'a>(&self, data: &'a Vec) -> Option>> { - - let mut headers = [httparse::EMPTY_HEADER; 128]; - let mut request = httparse::Request::new(&mut headers); - - let req = request.parse(data).unwrap(); - - if req.is_complete() { - return Some(headers.to_vec()); - } - None - } - - fn get_res_headers(data: &Vec) -> Option> { - - let mut headers = [httparse::EMPTY_HEADER; 128]; - let mut response = httparse::Response::new(&mut headers); - - let res = response.parse(data).unwrap(); - - if res.is_complete() { - return Some(headers.to_vec()); - } - None - } - - fn get_host(&self, data: &Vec) -> Option { - - return Some("137.220.37.67".to_string()); - let mut headers = [httparse::EMPTY_HEADER; 128]; - - let mut request = httparse::Request::new(&mut headers); - - let req = request.parse(data).unwrap(); - - if req.is_complete() { - for header in headers.iter() { - if header.name == "Host" || header.name == "host" { - //println!("Host -> {}", String::from_utf8(header.value.to_vec()).unwrap()); - return Some(String::from_utf8(header.value.to_vec()).unwrap()); - } - } - None - } else if req.is_partial() { - for header in headers.iter() { - if header.name == "Host" || header.name == "host" { - //println!("Host -> {}", String::from_utf8(header.value.to_vec()).unwrap()); - return Some(String::from_utf8(header.value.to_vec()).unwrap()); - } - } - None - } else { - None - } - } - - fn get_cookie(&self, data: &Vec) -> Option { - - let mut headers = [httparse::EMPTY_HEADER; 128]; - - let mut request = httparse::Request::new(&mut headers); - - let req = request.parse(data).unwrap(); - - if req.is_complete() { - for header in headers.iter() { - if header.name == "Cookie" || header.name == "cookie" { - //println!("Host -> {}", String::from_utf8(header.value.to_vec()).unwrap()); - return Some(String::from_utf8(header.value.to_vec()).unwrap()); - } - } - None - } else if req.is_partial() { - for header in headers.iter() { - if header.name == "Cookie" || header.name == "cookie" { - //println!("Host -> {}", String::from_utf8(header.value.to_vec()).unwrap()); - return Some(String::from_utf8(header.value.to_vec()).unwrap()); - } - } - None - } else { - None - } - } - */ - fn get_response<'a>(&self, data: &'a Vec) -> RelayedResponse<'a> { - - let mut headers = [httparse::EMPTY_HEADER; 128]; - let mut res = httparse::Response::new(&mut headers); - - let res_chk = res.parse(data); - - loop { - - if !res_chk.unwrap().is_complete() { - thread::sleep(Duration::from_millis(100)); - continue; - } - - let reason = match res.reason { - Some(r) => Some(r.to_string()), - None => None, - }; - - let header_vec = res.headers.to_vec(); - - let body = self.get_http_body(&data, header_vec).unwrap_or(String::from("[-] Failed to get http response body!").into_bytes()); - let string_body = String::from_utf8(body).unwrap(); - - return RelayedResponse { - http_version: res.version, - http_code: res.code, - http_reason: reason, - http_headers: Some(headers.to_vec()), - http_body: Some(string_body), - }; - } - } - - fn get_request<'a>(&self, data: &'a Vec) -> RelayRequest<'a> { - - let mut headers = [httparse::EMPTY_HEADER; 128]; - let mut req = httparse::Request::new(&mut headers); - - let req_chk = req.parse(data); - - loop { - - if !req_chk.unwrap().is_complete() { - thread::sleep(Duration::from_millis(100)); - continue; - } - - let method = match req.method { - Some(r) => Some(r.to_string()), - None => None, - }; - - let path = match req.path { - Some(p) => Some(p.to_string()), - None => None, - }; - - let header_vec = req.headers.to_vec(); - - let body = self.get_http_body(&data, header_vec).unwrap_or(String::from("[-] Failed to get http request body!").into_bytes()); - let string_body = String::from_utf8(body).unwrap(); - - return RelayRequest { - http_method: method, - http_path: path, - http_version: req.version, - http_headers: Some(headers.to_vec()), - http_body: Some(string_body), - }; - } - } - - fn get_http_body(&self, data: &Vec, headers: Vec
) -> Option> { - - let mut cl: u64 = 0; - let encoding_check = headers.clone(); - for header in headers { - - if header.name == "Content-Length" || header.name == "content-length" { - let length = match String::from_utf8(header.value.to_vec()) { - Ok(s) => s, - Err(e) => { - println!("[!] ERROR: {}",e); - return None; - }, - }; - - cl += length.parse::().unwrap(); - let mut r_body = data.to_vec(); - r_body.reverse(); - r_body.truncate(cl as usize); - r_body.reverse(); - - return Some(r_body); - - } else if header.name == "Transfer-Encoding" || header.name == "transfer-encoding" { - - let te_string = String::from_utf8(header.value.to_vec()).unwrap(); - - if te_string == "chunked" { - - let mut new_vec = data.to_vec(); - let new_vec_iter = new_vec.to_vec(); - let mut new_vec_iter = new_vec_iter.iter(); - let mut i = 0; - - loop { - if let Some(&0x0d) = new_vec_iter.next() { - i += 1; - if let Some(&0x0a) = new_vec_iter.next() { - i += 1; - if let Some(&0x0d) = new_vec_iter.next() { - i += 1; - if let Some(&0x0a) = new_vec_iter.next() { - i += 1; - break; - } else {i += 1;} - } else {i += 1;} - } else {i += 1;} - } else {i += 1;} - } - - new_vec.reverse(); - new_vec.truncate(data.len() - i); - new_vec.reverse(); - - let mut decoder = Decoder::new(new_vec.as_slice()); - let mut blob = Vec::new(); - let _ = decoder.read_to_end(&mut blob); - - let mut g_encoded = false; - for header in encoding_check { - if header.name == "Content-Encoding" || header.name == "content-encoding" { - let s = String::from_utf8(header.value.to_vec()).unwrap(); - if s == "gzip" { - g_encoded = true; - } - } - } - if g_encoded { - let mut gzd = GzDecoder::new(&blob[..]); - let mut unzipped = Vec::new(); - match gzd.read_to_end(&mut unzipped) { - Ok(_) => {}, - Err(_) => return None, - } - - return Some(unzipped); - } else { - return Some(blob); - } - - } - } - } - return Some(String::from("None").into_bytes()); - } -} // DataHandler - - /* Rewrite this to handle TCP connections until TCP connection is dropped instead of dropping it */ fn handle_stream(tcp_stream: SslStream, rc_config: Arc>, handlers: Arc>) { @@ -619,9 +173,9 @@ fn handle_stream {}, None => { @@ -653,9 +205,9 @@ fn handle_stream