tuxmain/rust-rpxy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

use hyper-tls and hyper-trust-dns as http(s) clients

Browse source
This commit is contained in:
Jun Kurihara 2022-06-16 20:01:26 -04:00
commit 8fff4f4088
No known key found for this signature in database
GPG key ID: 48ADFD173ED22B03
4 changed files with 138 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Cargo.toml
View file

@ -14,6 +14,7 @@ publish = false
[features] [features]
default = ["tls"] default = ["tls"]
tls = ["tokio-rustls", "rustls-pemfile"] tls = ["tokio-rustls", "rustls-pemfile"]
forward-hyper-trust-dns = ["hyper-trust-dns"]
[dependencies] [dependencies]
anyhow = "1.0.57" anyhow = "1.0.57"
@ -40,6 +41,13 @@ tokio-rustls = { version = "0.23.4", features = [
"early-data", "early-data",
], optional = true } ], optional = true }
rustls-pemfile = { version = "1.0.0", optional = true } rustls-pemfile = { version = "1.0.0", optional = true }
hyper-trust-dns = { version = "0.4.2", default-features = false, features = [
"rustls-http2",
"dnssec-ring",
"dns-over-https-rustls",
"rustls-webpki",
], optional = true }
hyper-tls = "0.5.0"
[dev-dependencies] [dev-dependencies]

51
src/acceptor.rs
View file

@ -1,12 +1,12 @@
use crate::{error::*, globals::Globals, log::*}; use crate::{error::*, globals::Globals, log::*};
use futures::{ use futures::{
task::{Context, Poll}, task::{Context, Poll},
Future, Future,
}; };
use hyper::http; use hyper::{
use hyper::server::conn::Http; client::connect::Connect, http, server::conn::Http, Body, Client, HeaderMap, Method, Request,
use hyper::{Body, HeaderMap, Method, Request, Response, StatusCode}; Response, StatusCode,
};
use std::{net::SocketAddr, pin::Pin, sync::Arc}; use std::{net::SocketAddr, pin::Pin, sync::Arc};
use tokio::{ use tokio::{
io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}, io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt},
@ -46,13 +46,20 @@ where
} }
#[derive(Clone)] #[derive(Clone)]
pub struct PacketAcceptor { pub struct PacketAcceptor<T>
where
T: hyper::client::connect::Connect + Send + Sync + Clone + 'static,
{
pub listening_on: SocketAddr, pub listening_on: SocketAddr,
pub forwarder: Client<T>,
pub globals: Arc<Globals>, pub globals: Arc<Globals>,
} }
#[allow(clippy::type_complexity)] #[allow(clippy::type_complexity)]
impl hyper::service::Service<http::Request<Body>> for PacketAcceptor { impl<T> hyper::service::Service<http::Request<Body>> for PacketAcceptor<T>
where
T: Connect + Clone + Send + Sync + 'static,
{
type Response = Response<Body>; type Response = Response<Body>;
type Error = http::Error; type Error = http::Error;
@ -64,6 +71,32 @@ impl hyper::service::Service<http::Request<Body>> for PacketAcceptor {
fn call(&mut self, req: Request<Body>) -> Self::Future { fn call(&mut self, req: Request<Body>) -> Self::Future {
debug!("\nserve: {:?}\n{:?}", self.listening_on, req); debug!("\nserve: {:?}\n{:?}", self.listening_on, req);
let self_inner = self.clone();
// 1. check uri (domain queried host name)
// 2. build uri to forwarding target destination
// 3. build request from uri and body
// 4. send request to forwarding target
if *req.method() == Method::GET {
Box::pin(async move {
// let uri = req.uri();
let target_uri = hyper::Uri::builder()
.scheme("https")
.authority("www.google.com")
.path_and_query("/")
.build()
.unwrap();
println!("{:?}", target_uri);
match self_inner.forwarder.get(target_uri).await {
Ok(res) => Ok(res),
Err(e) => {
error!("{:?}", e);
http_error(StatusCode::INTERNAL_SERVER_ERROR)
}
}
})
} else {
// let globals = &self.doh.globals; // let globals = &self.doh.globals;
// let self_inner = self.clone(); // let self_inner = self.clone();
// if req.uri().path() == globals.path { // if req.uri().path() == globals.path {
@ -134,13 +167,17 @@ impl hyper::service::Service<http::Request<Body>> for PacketAcceptor {
// }) // })
// } else { // } else {
Box::pin(async { http_error(StatusCode::NOT_FOUND) }) Box::pin(async { http_error(StatusCode::NOT_FOUND) })
}
// } // }
// } // }
// } // }
} }
} }
impl PacketAcceptor { impl<T> PacketAcceptor<T>
where
T: Connect + Clone + Send + Sync + 'static,
{
pub async fn client_serve<I>(self, stream: I, server: Http<LocalExecutor>, peer_addr: SocketAddr) pub async fn client_serve<I>(self, stream: I, server: Http<LocalExecutor>, peer_addr: SocketAddr)
where where
I: AsyncRead + AsyncWrite + Send + Unpin + 'static, I: AsyncRead + AsyncWrite + Send + Unpin + 'static,

10
src/proxy.rs
View file

@ -1,5 +1,8 @@
use crate::{acceptor::PacketAcceptor, error::*, globals::Globals, log::*}; use crate::{acceptor::PacketAcceptor, error::*, globals::Globals, log::*};
use futures::future::select_all; use futures::future::select_all;
use hyper::Client;
#[cfg(feature = "forward-hyper-trust-dns")]
use hyper_trust_dns::TrustDnsResolver;
use std::sync::Arc; use std::sync::Arc;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
@ -11,9 +14,16 @@ impl Proxy {
let addresses = self.globals.listen_addresses.clone(); let addresses = self.globals.listen_addresses.clone();
let futures = select_all(addresses.into_iter().map(|addr| { let futures = select_all(addresses.into_iter().map(|addr| {
info!("Listen address: {:?}", addr); info!("Listen address: {:?}", addr);
#[cfg(feature = "forward-hyper-trust-dns")]
let connector = TrustDnsResolver::default().into_rustls_webpki_https_connector();
#[cfg(not(feature = "forward-hyper-trust-dns"))]
let connector = hyper_tls::HttpsConnector::new();
let acceptor = PacketAcceptor { let acceptor = PacketAcceptor {
listening_on: addr, listening_on: addr,
globals: self.globals.clone(), globals: self.globals.clone(),
forwarder: Client::builder().build::<_, hyper::Body>(connector),
}; };
self.globals.runtime_handle.spawn(acceptor.start()) self.globals.runtime_handle.spawn(acceptor.start())
})); }));

7
src/tls.rs
View file

@ -5,7 +5,7 @@ use std::sync::Arc;
use std::time::Duration; use std::time::Duration;
use futures::{future::FutureExt, join, select}; use futures::{future::FutureExt, join, select};
use hyper::server::conn::Http; use hyper::{client::connect::Connect, server::conn::Http};
use tokio::{ use tokio::{
net::TcpListener, net::TcpListener,
sync::mpsc::{self, Receiver}, sync::mpsc::{self, Receiver},
@ -109,7 +109,10 @@ where
Ok(TlsAcceptor::from(Arc::new(server_config))) Ok(TlsAcceptor::from(Arc::new(server_config)))
} }
impl PacketAcceptor { impl<T> PacketAcceptor<T>
where
T: Connect + Clone + Send + Sync + 'static,
{
async fn start_https_service( async fn start_https_service(
self, self,
mut tls_acceptor_receiver: Receiver<TlsAcceptor>, mut tls_acceptor_receiver: Receiver<TlsAcceptor>,