#[cfg(all(test, feature = "client"))]
mod tests {
use super::*;
use crate::{BindPolicy, RuntimePolicy, ServerBuilder, ServerConfig, ServerTransportProfile};
#[cfg(feature = "mtls")]
use crate::ClientIdentity;
use crate::{
Client, ClientConfig, ClientService, TargetConnector, TargetContext, TargetError,
TargetFuture, TargetStream,
};
use eggtunnel_proto::{RequestedBind, ServiceName, TcpTarget};
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpStream,
};
async fn test_session(
session_id: SessionId,
) -> (
Arc<SessionContext>,
Arc<Mutex<HashMap<SessionId, std::sync::Weak<SessionContext>>>>,
Counters,
) {
let counters = Counters::default();
let context = Arc::new(SessionContext {
id: session_id,
principal: None,
cancel: CancellationToken::new(),
pending: Mutex::new(HashMap::new()),
connection_admission: Arc::new(Semaphore::new(4)),
control_tx: Mutex::new(None),
counters: counters.clone(),
});
let sessions = Arc::new(Mutex::new(HashMap::new()));
sessions
.lock()
.await
.insert(session_id, Arc::downgrade(&context));
(context, sessions, counters)
}
fn test_data_stream() -> BoxStream {
let (stream, _peer) = tokio::io::duplex(32);
Box::new(stream)
}
fn builder() -> ServerBuilder {
ServerBuilder::new(ServerConfig {
listen_addr: "127.0.0.1:0".parse().unwrap(),
certificate_pem: b"cert".to_vec(),
private_key_pem: b"key".to_vec(),
token: SecretToken::new(b"test-token".to_vec()).unwrap(),
allow_public_service_binds: false,
})
.bind_policy(BindPolicy::default())
.runtime_policy(RuntimePolicy::default())
}
#[test]
fn server_builder_accepts_tcp_tls_default_profile() {
assert!(builder().validate().is_ok());
}
#[cfg(feature = "quic")]
#[test]
fn server_builder_accepts_quic() {
assert!(builder()
.transport(ServerTransportProfile::Quic)
.validate()
.is_ok());
}
#[cfg(feature = "websocket")]
#[test]
fn server_builder_accepts_websocket() {
assert!(builder()
.transport(ServerTransportProfile::WebSocket)
.validate()
.is_ok());
}
#[cfg(feature = "mtls")]
#[test]
fn server_builder_accepts_tcp_mtls() {
assert!(builder().client_ca_pem(b"client CA".to_vec()).validate().is_ok());
}
#[cfg(all(feature = "mtls", feature = "quic"))]
#[test]
fn server_builder_rejects_quic_mtls() {
assert!(builder()
.transport(ServerTransportProfile::Quic)
.client_ca_pem(b"client CA".to_vec())
.validate()
.is_err());
}
#[cfg(all(feature = "mtls", feature = "websocket"))]
#[test]
fn server_builder_rejects_websocket_mtls() {
assert!(builder()
.transport(ServerTransportProfile::WebSocket)
.client_ca_pem(b"client CA".to_vec())
.validate()
.is_err());
}
fn certificate() -> (String, String) {
let params = rcgen::CertificateParams::new(vec!["localhost".to_owned()]).unwrap();
let key = rcgen::KeyPair::generate().unwrap();
let cert = params.self_signed(&key).unwrap();
(cert.pem(), key.serialize_pem())
}
#[cfg(feature = "mtls")]
fn mtls_certificates() -> (
String,
String,
String,
ClientIdentity,
ClientIdentity,
ClientIdentity,
) {
use rcgen::{BasicConstraints, CertificateParams, ExtendedKeyUsagePurpose, IsCa, KeyPair};
let mut ca_params = CertificateParams::new(Vec::<String>::new()).unwrap();
ca_params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
let ca_key = KeyPair::generate().unwrap();
let ca_cert = ca_params.self_signed(&ca_key).unwrap();
let ca_pem = ca_cert.pem();
let mut server_params = CertificateParams::new(vec!["localhost".to_owned()]).unwrap();
server_params.extended_key_usages = vec![ExtendedKeyUsagePurpose::ServerAuth];
let server_key = KeyPair::generate().unwrap();
let server_cert = server_params
.signed_by(&server_key, &ca_cert, &ca_key)
.unwrap();
let client_identity = |common_name: &str| {
let mut params = CertificateParams::new(vec![common_name.to_owned()]).unwrap();
params.extended_key_usages = vec![ExtendedKeyUsagePurpose::ClientAuth];
let key = KeyPair::generate().unwrap();
let certificate = params.signed_by(&key, &ca_cert, &ca_key).unwrap();
ClientIdentity::new(
certificate.pem().into_bytes(),
key.serialize_pem().into_bytes(),
)
};
let trusted_identity = client_identity("trusted-client");
let trusted_identity_wrong_name = client_identity("trusted-client-wrong-name");
let mut rogue_ca_params = CertificateParams::new(Vec::<String>::new()).unwrap();
rogue_ca_params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
let rogue_ca_key = KeyPair::generate().unwrap();
let rogue_ca_cert = rogue_ca_params.self_signed(&rogue_ca_key).unwrap();
let rogue_identity = {
let mut params = CertificateParams::new(vec!["rogue-client".to_owned()]).unwrap();
params.extended_key_usages = vec![ExtendedKeyUsagePurpose::ClientAuth];
let key = KeyPair::generate().unwrap();
let certificate = params
.signed_by(&key, &rogue_ca_cert, &rogue_ca_key)
.unwrap();
ClientIdentity::new(
certificate.pem().into_bytes(),
key.serialize_pem().into_bytes(),
)
};
(
ca_pem,
server_cert.pem(),
server_key.serialize_pem(),
trusted_identity,
trusted_identity_wrong_name,
rogue_identity,
)
}
async fn roundtrip(addr: SocketAddr, bytes: &'static [u8]) -> Vec<u8> {
let mut external = TcpStream::connect(addr).await.unwrap();
external.write_all(bytes).await.unwrap();
external.shutdown().await.unwrap();
let mut received = Vec::new();
tokio::time::timeout(Duration::from_secs(5), external.read_to_end(&mut received))
.await
.unwrap()
.unwrap();
received
}
struct DuplexEchoConnector;
impl TargetConnector for DuplexEchoConnector {
fn connect(&self, service: ClientService, _context: TargetContext) -> TargetFuture {
Box::pin(async move {
if service.name.as_str() != "direct-echo" {
return Err(TargetError::Refused);
}
let (application, peer) = tokio::io::duplex(64 * 1024);
tokio::spawn(async move {
let (mut read, mut write) = tokio::io::split(peer);
let _ = tokio::io::copy(&mut read, &mut write).await;
let _ = write.shutdown().await;
});
Ok(Box::new(application) as TargetStream)
})
}
}
struct PendingConnector;
impl TargetConnector for PendingConnector {
fn connect(&self, _service: ClientService, _context: TargetContext) -> TargetFuture {
Box::pin(std::future::pending())
}
}
#[path = "../server_tests/tcp.rs"]
mod tcp;
#[cfg(feature = "mtls")]
#[path = "../server_tests/mtls.rs"]
mod mtls;
#[cfg(feature = "quic")]
#[path = "../server_tests/quic.rs"]
mod quic;
#[cfg(feature = "websocket")]
#[path = "../server_tests/websocket.rs"]
mod websocket;
#[cfg(feature = "outbound-proxy")]
#[path = "../server_tests/proxy.rs"]
mod proxy;
}