tuxmain/sslrelay
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Now handles IPv6 connections correctly

Browse source
This commit is contained in:
PinkP4nther 2021-09-21 09:31:43 -07:00
commit 52a03b9045
3 changed files with 17 additions and 11 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Cargo.toml
View file

@ -1,6 +1,6 @@
[package] [package]
name = "sslrelay" name = "sslrelay"
version = "0.3.0" version = "0.3.1"
authors = ["PinkP4nther <pinkp4nther@protonmail.com>"] authors = ["PinkP4nther <pinkp4nther@protonmail.com>"]
edition = "2018" edition = "2018"

17
src/data.rs
View file

@ -327,7 +327,9 @@ where
{ {
ds_tcp_stream: Arc<Mutex<SslStream<TcpStream>>>, ds_tcp_stream: Arc<Mutex<SslStream<TcpStream>>>,
us_tcp_stream: Option<Arc<Mutex<SslStream<TcpStream>>>>, us_tcp_stream: Option<Arc<Mutex<SslStream<TcpStream>>>>,
remote_endpoint: String, //remote_endpoint: String,
remote_host: String,
remote_port: String,
ds_inner_m: Arc<Mutex<DownStreamInner>>, ds_inner_m: Arc<Mutex<DownStreamInner>>,
us_inner_m: Arc<Mutex<UpStreamInner>>, us_inner_m: Arc<Mutex<UpStreamInner>>,
inner_handlers: InnerHandlers<H>, inner_handlers: InnerHandlers<H>,
@ -335,14 +337,15 @@ where
impl<H: HandlerCallbacks + std::marker::Sync + std::marker::Send + Clone + 'static> FullDuplexTcp<H> { impl<H: HandlerCallbacks + std::marker::Sync + std::marker::Send + Clone + 'static> FullDuplexTcp<H> {
pub fn new(ds_tcp_stream: SslStream<TcpStream>, remote_endpoint: String, handlers: InnerHandlers<H>) -> Self { pub fn new(ds_tcp_stream: SslStream<TcpStream>, remote_host: String, remote_port: String, handlers: InnerHandlers<H>) -> Self {
let _ = ds_tcp_stream.get_ref().set_read_timeout(Some(Duration::from_millis(50))); let _ = ds_tcp_stream.get_ref().set_read_timeout(Some(Duration::from_millis(50)));
FullDuplexTcp { FullDuplexTcp {
ds_tcp_stream: Arc::new(Mutex::new(ds_tcp_stream)), ds_tcp_stream: Arc::new(Mutex::new(ds_tcp_stream)),
us_tcp_stream: None, us_tcp_stream: None,
remote_endpoint, remote_host,
remote_port,
ds_inner_m: Arc::new(Mutex::new(DownStreamInner{ds_stream: None, internal_data_buffer: Vec::<u8>::new()})), ds_inner_m: Arc::new(Mutex::new(DownStreamInner{ds_stream: None, internal_data_buffer: Vec::<u8>::new()})),
us_inner_m: Arc::new(Mutex::new(UpStreamInner{us_stream: None, internal_data_buffer: Vec::<u8>::new()})), us_inner_m: Arc::new(Mutex::new(UpStreamInner{us_stream: None, internal_data_buffer: Vec::<u8>::new()})),
inner_handlers: handlers, inner_handlers: handlers,
@ -519,17 +522,17 @@ impl<H: HandlerCallbacks + std::marker::Sync + std::marker::Send + Clone + 'stat
let connector = sslbuilder.build(); let connector = sslbuilder.build();
let s = match TcpStream::connect(self.remote_endpoint.as_str()) { let s = match TcpStream::connect(format!("{}:{}", self.remote_host, self.remote_port)) {
Ok(s) => s, Ok(s) => s,
Err(e) => { Err(e) => {
self.handle_error(format!("Can't connect to remote host: {}\nErr: {}", self.remote_endpoint, e).as_str()); self.handle_error(format!("Can't connect to remote host: {}\nErr: {}", format!("{}:{}", self.remote_host, self.remote_port), e).as_str());
return -1; return -1;
} }
}; };
let r_host: Vec<&str> = self.remote_endpoint.as_str().split(":").collect(); //let r_host: Vec<&str> = self.remote_endpoint.as_str().split(":").collect();
let s = match connector.connect(r_host[0], s) { let s = match connector.connect(self.remote_host.as_str(), s) {
Ok(s) => s, Ok(s) => s,
Err(e) => { Err(e) => {
self.handle_error(format!("Failed to accept TLS/SSL handshake: {}", e).as_str()); self.handle_error(format!("Failed to accept TLS/SSL handshake: {}", e).as_str());

9
src/lib.rs
View file

@ -80,7 +80,7 @@ impl<H: HandlerCallbacks + std::marker::Sync + std::marker::Send + Clone + 'stat
let rhost = rc_pointer.lock().unwrap().remote_host.clone(); let rhost = rc_pointer.lock().unwrap().remote_host.clone();
let rport = rc_pointer.lock().unwrap().remote_port.clone(); let rport = rc_pointer.lock().unwrap().remote_port.clone();
let remote_endpoint = format!("{}:{}", rhost, rport); //let remote_endpoint = format!("{}:{}", rhost, rport);
let acceptor = self.setup_ssl_config(self.config.as_ref().unwrap().ssl_private_key_path.clone(), self.config.as_ref().unwrap().ssl_cert_path.clone()); let acceptor = self.setup_ssl_config(self.config.as_ref().unwrap().ssl_private_key_path.clone(), self.config.as_ref().unwrap().ssl_cert_path.clone());
let listener = TcpListener::bind(format!("{}:{}", self.config.as_ref().unwrap().bind_host.clone(), self.config.as_ref().unwrap().bind_port.clone())).unwrap(); let listener = TcpListener::bind(format!("{}:{}", self.config.as_ref().unwrap().bind_host.clone(), self.config.as_ref().unwrap().bind_port.clone())).unwrap();
@ -93,14 +93,17 @@ impl<H: HandlerCallbacks + std::marker::Sync + std::marker::Send + Clone + 'stat
let acceptor = acceptor.clone(); let acceptor = acceptor.clone();
//let rc_config = rc_pointer.clone(); //let rc_config = rc_pointer.clone();
let handler_clone = self.handlers.as_ref().unwrap().clone(); let handler_clone = self.handlers.as_ref().unwrap().clone();
let r_endpoint = remote_endpoint.clone(); //let r_endpoint = remote_endpoint.clone();
let r_host = rhost.clone();
let r_port = rport.clone();
thread::spawn(move || { thread::spawn(move || {
match acceptor.accept(stream) { match acceptor.accept(stream) {
Ok(stream) => { Ok(stream) => {
// FULL DUPLEX OBJECT CREATION HERE // FULL DUPLEX OBJECT CREATION HERE
FullDuplexTcp::new(stream, r_endpoint, handler_clone).handle(); FullDuplexTcp::new(stream, r_host, r_port, handler_clone).handle();
}, },
Err(e) => { Err(e) => {