Quiche

This project is a memory-safe implementation of the QUIC transport protocol and HTTP/3, designed for high-throughput and efficient network communication. It provides a comprehensive toolkit for building secure, low-latency network applications by managing the full lifecycle of transport connections, including protocol negotiation, stream data exchange, and connection state management.

The library distinguishes itself through a focus on performance and protocol integrity. It utilizes a formal state machine to enforce strict adherence to transport rules and employs zero-copy buffer management to minimize CPU overhead by mapping application memory directly to network buffers. To ensure resilience, it features modular congestion control, allowing for pluggable strategies, and stateless handshake validation to verify peer addresses before allocating server resources.

The project covers a broad capability surface, including advanced traffic management, path discovery, and detailed observability tools for monitoring connection health and performance metrics. It provides granular control over security primitives, such as TLS certificate management and session resumption, while supporting specialized features like unreliable datagram delivery and multi-path routing.

The implementation is written in Rust, providing a robust foundation for developers building high-performance web servers, clients, or experimental transport layer features.

Features

HTTP/3 Libraries - Implements the QUIC transport protocol and HTTP/3 for high-performance, secure, and low-latency network communication.

Connection Establishment Protocols - Manages the full lifecycle of secure network connections, including handshakes and packet processing.

HTTP/3 Implementations - Send and receive web requests and responses over a transport connection by processing headers and body data frames.

Custom Transport Protocols - Enables development of custom networking applications requiring low-latency, secure, and multiplexed communication over the QUIC transport protocol.

Network Protocol Implementations - Provides a memory-safe implementation of transport layer protocols designed for high-throughput and efficient network communication.

Packet Engines - Processes incoming and outgoing network packets while managing timers for protocol events and retransmissions.

Congestion Controllers - Applies pluggable congestion control algorithms to manage data flow and maintain consistent network performance.

Zero-Copy Networking - Directly maps application memory to network buffers to eliminate intermediate data copying and reduce CPU overhead during transmission.

Connection State Managers - Maintains protocol compliance by managing connection state and handling protocol-level errors.

Bidirectional Streaming Protocols - Supports bidirectional data exchange over streams with integrated flow control.

Transport Configurations - Provides settings and hooks for configuring transport-specific parameters during the connection handshake process.

HTTP Datagram Transports - Supports the transmission of unreliable datagrams that bypass standard stream flow control.

Data Streaming - Manages stream data with support for flow control and zero-copy operations.

Low-Latency Data Transmission - Optimizes data transmission for real-time applications by managing congestion control, zero-copy buffers, and unreliable datagram delivery.

Path Migration Managers - Manages connection paths through validation, migration, and MTU revalidation to maintain stable connectivity.

Stateless Retry Handlers - Issues stateless retry packets to validate client addresses and prevent resource exhaustion.

Cryptographic Protocols - Embeds secure handshake and encryption logic directly into the transport layer to ensure all data is authenticated and private.

Secure Connection Handlers - Provides fine-grained control over TLS handshakes, session resumption, and path validation for secure network sessions.

TLS Certificate Management - Configures local certificate chains and private keys to enable secure peer authentication.

Zero-Copy Mechanisms - Implements zero-copy mechanisms to minimize CPU overhead by mapping application memory directly to network buffers.

Protocol - Uses a formal state machine to enforce strict adherence to transport protocol rules and manage complex connection lifecycles.

HTTP Request Managers - Provides interfaces for managing the lifecycle of web requests and responses.

Connection Handshake Protocols - Verifies connection identifiers during the handshake to ensure secure session resumption.

Stream - Manages independent data streams with individual flow control windows to prevent head-of-line blocking and ensure efficient resource utilization.

Connection and Session Management - Manages transport-level connection parameters like timeouts and session resumption.

Protocol Negotiation Tools - Negotiates protocol versions during the initial handshake to ensure client-server compatibility.

Network Buffer Managers - Optimizes buffer handling by passing custom storage buffers directly to the network layer to eliminate intermediate copying.

Connection Identifier Managers - Manages connection identifiers to support multi-homing and secure path identification.

Network Connection Security - Configures protocol-level security and flow control settings for network connections.

Stateless Session Management - Enables stateless session resumption using ticket keys to maintain connection state across server instances.

Metric and Performance Monitors - Collects real-time metrics on throughput, latency, and packet loss for connections.

Connection Termination - Gracefully terminates connections by signaling error codes and ensuring final protocol cleanup.

Experimental Protocols - Supports research and implementation of experimental transport layer features, including custom congestion algorithms and protocol-specific packet handling.

Custom Connection Handlers - Allows initialization of client connections using custom buffer generation and specific destination identifiers.

Connection Management - Manages connection state transitions and signals errors for invalid operations.

Congestion Control Monitors - Tracks congestion window size and bandwidth estimates to provide visibility into network performance.

Transmission Schedulers - Schedules outbound packet transmission using precise timestamps to control network dispatch.

Protocol Feature Negotiators - Configures protocol-level capabilities such as datagram support and path discovery.

Network Identifiers - Generates unique identifiers for network sessions from raw byte sequences.

Session Identifiers - Manages the length and generation of unique identifiers for individual network sessions.

Stateless Architectures - Employs retry mechanisms and connection identifiers to verify peer addresses before allocating significant server resources to new sessions.

Packet Integrity Validators - Validates incoming packets to ensure data integrity and protocol compliance.

Protocol - Surfaces errors when peers violate transport or flow control limits.

Protocol Version Verifiers - Verifies protocol version compatibility to ensure successful connection establishment.

Packet Validation Rules - Ensures incoming network packets adhere to minimum length and protocol standards.

Stream Buffer Allocators - Provides specialized memory allocation for stream data to enable zero-copy network transmission.

Error Handling - Standardizes error reporting across network operations using unified result types.

Event-Driven Architectures - Processes incoming and outgoing network traffic through an asynchronous event loop that manages timers and retransmission logic.

Path Performance Monitors - Monitors performance and state data for individual network paths.

Protocol Header Parsers - Provides specialized logic for parsing QUIC packet headers to identify protocol structure.

cloudflarequiche

Features

Star history