use std::net::SocketAddr;
use std::sync::Arc;
use serde::{Serialize, Deserialize};
fn ensure_crypto_provider() {
let _ = rustls::crypto::ring::default_provider().install_default();
}
pub struct TlsCertificate {
pub cert_der: Vec<u8>,
pub key_der: Vec<u8>,
pub subject: String,
}
pub fn generate_self_signed_cert(subject: &str) -> Result<TlsCertificate, String> {
use rcgen::{CertificateParams, KeyPair, PKCS_ED25519};
let params = CertificateParams::new(vec![subject.to_string()])
.map_err(|e| format!("Failed to create cert params: {}", e))?;
let key_pair = KeyPair::generate_for(&PKCS_ED25519)
.map_err(|e| format!("Failed to generate key pair: {}", e))?;
let cert = params.self_signed(&key_pair)
.map_err(|e| format!("Failed to self-sign certificate: {}", e))?;
let cert_der = cert.der().to_vec();
let key_der = key_pair.serialize_der();
Ok(TlsCertificate {
cert_der,
key_der,
subject: subject.to_string(),
})
}
pub struct QuicEndpoint {
endpoint: quinn::Endpoint,
#[allow(dead_code)]
server_config: Option<quinn::ServerConfig>,
}
impl QuicEndpoint {
pub fn new_server(port: u16, cert: &TlsCertificate) -> Result<Self, String> {
ensure_crypto_provider();
let server_crypto = build_server_crypto(cert)?;
let server_config = quinn::ServerConfig::with_crypto(Arc::new(server_crypto));
let bind_addr: SocketAddr = format!("127.0.0.1:{}", port)
.parse()
.map_err(|e| format!("Invalid bind address: {}", e))?;
let endpoint = quinn::Endpoint::server(server_config.clone(), bind_addr)
.map_err(|e| format!("Failed to bind QUIC endpoint to {}: {}", bind_addr, e))?;
Ok(Self {
endpoint,
server_config: Some(server_config),
})
}
pub fn new_client() -> Result<Self, String> {
ensure_crypto_provider();
let bind_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
let endpoint = quinn::Endpoint::client(bind_addr)
.map_err(|e| format!("Failed to create client endpoint: {}", e))?;
Ok(Self {
endpoint,
server_config: None,
})
}
pub fn new_client_with_config() -> Result<Self, String> {
ensure_crypto_provider();
let bind_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
let endpoint = quinn::Endpoint::client(bind_addr)
.map_err(|e| format!("Failed to create client endpoint: {}", e))?;
Ok(Self {
endpoint,
server_config: None,
})
}
pub async fn connect(&self, addr: &str, server_name: &str) -> Result<QuicConnection, String> {
ensure_crypto_provider();
let client_crypto = build_dangerous_client_crypto();
let quic_client_config = quinn::crypto::rustls::QuicClientConfig::try_from(client_crypto)
.map_err(|e| format!("Failed to create QUIC client config: {}", e))?;
let client_config = quinn::ClientConfig::new(Arc::new(quic_client_config));
let socket_addr: SocketAddr = addr
.parse()
.map_err(|e| format!("Invalid server address {}: {}", addr, e))?;
let connection = self.endpoint
.connect_with(client_config, socket_addr, server_name)
.map_err(|e| format!("Failed to initiate connection: {}", e))?
.await
.map_err(|e| format!("QUIC connection failed: {}", e))?;
Ok(QuicConnection { conn: connection })
}
pub async fn accept(&self) -> Result<QuicConnection, String> {
let incoming = self.endpoint.accept()
.await
.ok_or_else(|| "No incoming QUIC connection".to_string())?;
let connection = incoming.await
.map_err(|e| format!("Failed to accept QUIC connection: {}", e))?;
Ok(QuicConnection { conn: connection })
}
pub fn local_addr(&self) -> Result<SocketAddr, String> {
self.endpoint.local_addr()
.map_err(|e| format!("Failed to get local addr: {}", e))
}
pub fn close(&self) {
self.endpoint.close(0u32.into(), b"shutdown");
}
pub async fn accept_with_cancellation(
&self,
token: &tokio_util::sync::CancellationToken,
) -> Result<Option<QuicConnection>, String> {
tokio::select! {
_ = token.cancelled() => Ok(None),
res = self.accept() => res.map(Some),
}
}
pub async fn run_accept_loop<F, Fut>(
&self,
token: tokio_util::sync::CancellationToken,
handler: F,
) -> Result<(), String>
where
F: Fn(QuicConnection) -> Fut + Send + Sync + 'static,
Fut: std::future::Future<Output = ()> + Send + 'static,
{
loop {
tokio::select! {
_ = token.cancelled() => {
self.close();
break;
}
res = self.accept() => {
match res {
Ok(conn) => {
tokio::spawn(handler(conn));
}
Err(e) => {
if token.is_cancelled() {
break;
}
return Err(e);
}
}
}
}
}
Ok(())
}
}
pub struct QuicConnection {
pub conn: quinn::Connection,
}
impl QuicConnection {
pub async fn send(&self, data: &[u8]) -> Result<Vec<u8>, String> {
let (mut send_stream, mut recv_stream) = self.conn
.open_bi()
.await
.map_err(|e| format!("Failed to open bidirectional stream: {}", e))?;
send_stream.write_all(data)
.await
.map_err(|e| format!("Failed to write to QUIC stream: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish send stream: {}", e))?;
let response = recv_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read response from QUIC stream: {}", e))?;
Ok(response)
}
pub async fn send_one_way(&self, data: &[u8]) -> Result<(), String> {
let mut send_stream = self.conn
.open_uni()
.await
.map_err(|e| format!("Failed to open unidirectional stream: {}", e))?;
send_stream.write_all(data)
.await
.map_err(|e| format!("Failed to write to QUIC stream: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish send stream: {}", e))?;
Ok(())
}
pub async fn recv_bi(&self) -> Result<(Vec<u8>, quinn::SendStream, quinn::RecvStream), String> {
let (send_stream, mut recv_stream) = self.conn
.accept_bi()
.await
.map_err(|e| format!("Failed to accept bidirectional stream: {}", e))?;
let data = recv_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read from QUIC stream: {}", e))?;
Ok((data, send_stream, recv_stream))
}
pub async fn respond(
&self,
mut send_stream: quinn::SendStream,
data: &[u8],
) -> Result<(), String> {
send_stream.write_all(data)
.await
.map_err(|e| format!("Failed to write response: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish response stream: {}", e))?;
Ok(())
}
pub fn remote_address(&self) -> SocketAddr {
self.conn.remote_address()
}
pub fn stable_id(&self) -> usize {
self.conn.stable_id()
}
pub fn close(&self, reason: &str) {
self.conn.close(0u32.into(), reason.as_bytes());
}
}
#[path = "quic_transport_handshake.rs"]
mod quic_transport_handshake;
#[allow(unused_imports)]
pub use quic_transport_handshake::*;
#[cfg(test)]
#[path = "quic_transport_tests.rs"]
mod tests;