Aether: A Next-Generation L4 Transport

Introduction

Motivation Transport-layer protocols have evolved slowly. TCP provides reliable, ordered delivery but suffers from head-of-line blocking and requires separate TLS for encryption. UDP is lightweight but unreliable. QUIC addresses many of TCP's shortcomings but is tightly coupled to HTTP/3. Aether is a general-purpose L4 transport protocol designed for:

Stream multiplexing without head-of-line blocking
Mandatory encryption with post-quantum resistance
Multi-path connections (seamless network switching)
Self-sovereign identity at the protocol layer
Userspace operation (no kernel modifications required)

Design Philosophy Design Principles and Application in Aether

Principle	Application in Aether
Simple core	Fixed 16-byte base header; features via extensions
Security non-optional	AEAD encryption from first packet; no plaintext mode
Versioning	First packet declares version and capabilities
Self-describing	Protocol metadata embedded in handshake
Userspace-first	No OS kernel modifications required

Wire Format

Base Header (16 bytes)

Header Fields

Field	Bits	Description
Ver	4	Protocol version. Starts at 0.
Type	6	Packet type (see )
H	1	0 = Short header, 1 = Long header
E	1	Extensions present
R	2	Reserved (MUST be 0)
Stream ID	18	Stream identifier (0..262143)
Offset	32	Byte offset in stream
Length	32	Payload length (bytes)
Cnx ID	32/64	Short: 32-bit truncated CID. Long: 64-bit full Dest CID.

Long Header Long header adds 8 additional bytes after the base header containing the Source Connection ID (64 bits). Total: Long Header = 24 bytes, Short Header = 16 bytes.

Packet Types Packet Types (6-bit Type field)

Code	Name	Purpose	Header
0x00	Initial	First packet, ClientHello	Long
0x01	Handshake	Crypto handshake	Long
0x02	Data	User stream data	Short
0x03	Ack	Packet acknowledgement	Short
0x04	Close	Connection close + code	Short
0x05	Ping	Keep-alive	Short
0x06	PathChallenge	Validate new path	Short
0x07	PathResponse	Confirm path	Short
0x08	StreamOpen	Open new stream	Short
0x09	StreamClose	Close stream (FIN)	Short
0x0A-0x3F	Reserved	For future use	-

Extension Chain When bit E is set, a TLV extension chain follows the header. Chain terminates with Ext Type 0x00. Extension Types

Code	Name	Description
0x01	Timestamp	Sender timestamp (64-bit, microseconds)
0x02	Priority	Stream priority (8 bits)
0x03	Padding	Anti-traffic-analysis padding
0x04	PathId	Multi-path identifier
0x05	FlowControl	Window update

Handshake

Handshake Phases The handshake completes in 1-RTT:

| | | |<-- Initial (ServerHello) -------------| | | |--- Handshake (ClientFinished) ------->| Client can now send Data | | |<-- Handshake (ServerFinished) --------| Server can now send Data | | |<======= Data (Encrypted) ===========>| ]]>

ClientHello CBOR-encoded, inside AEAD-encrypted Initial packet payload. Contains: protocol version (0), 64-bit random client CID, supported version list, crypto parameters (Kyber768 + X25519, AES-256-GCM, SHA-256), capabilities (multipath, max_streams, max_stream_data, ack_frequency, idle_timeout_ms), and an Ed25519 identity public key.

ServerHello CBOR-encoded response containing: echoed client CID, server CID, Kyber768 ciphertext, X25519 ephemeral public key, server capabilities, and server Ed25519 identity with proof (signature of transcript).

Key Derivation After ClientHello and ServerHello exchange:

ClientFinished and ServerFinished carry HMAC-SHA256(session_key, transcript). Symmetric keys are destroyed after 3x PTO following connection close, providing Perfect Forward Secrecy.

Streams Each stream identified by 18-bit Stream ID (0..262143). Stream ID 0 reserved for control. Client opens streams with EVEN IDs; server with ODD IDs. Streams are independent: loss in one stream does not block others. Stream lifecycle: IDLE -> (StreamOpen) -> OPEN -> (StreamClose FIN) -> HALF-CLOSED -> (StreamClose ACK) -> CLOSED. Flow control operates at two levels: Connection-level (total in-flight data) and Stream-level (in-flight data per stream). Initial windows: Stream = 1 MiB, Connection = 16 MiB. Each Data packet carries an Offset (byte position). Receivers send Ack frames with received offset ranges. Unacknowledged packets are retransmitted with exponential back-off up to MAX_RETRANSMISSIONS (10).

Multi-Path Connections are identified by Connection ID, not IP address. This enables path migration:

Client detects a new network interface (e.g., 5G after Wi-Fi).
Client sends PathChallenge from new IP to server.
Server responds with PathResponse, confirming the new path belongs to the same connection.
Server begins sending data on both paths.
Client may duplicate data on both paths for reliability.

Each path has a unique Path ID (Extension Type 0x04). Packets from different paths are multiplexed onto common streams; the receiver reassembles by Offset. When one path is lost, data automatically flows through remaining paths without connection interruption.

Congestion Control The default congestion control algorithm is Aether-CC, a hybrid of BBRv3 and NewReno , optimized for high-latency satellite links, variable-bandwidth mobile networks, and noisy channels (distinguishing loss from congestion). Bandwidth estimation: delivery_rate = bytes_acked / time_delta; max_bw = max(max_bw, delivery_rate). RTT estimation: min_rtt = min(min_rtt, latest_rtt) over 10-second window. Congestion window: cwnd = max_bw * min_rtt * gain (gain: 1.25 during probing, 0.75 during drain). Loss classification: loss with low RTT and rising delivery_rate indicates congestion; loss with high RTT and stable delivery_rate indicates channel noise (window not reduced). Pluggable algorithms: "aether-cc" (default), "bbrv3", "cubic", "none" (testing).

Security Considerations Aether has no plaintext mode. All packets are encrypted: Initial packets with AEAD key derived from initial salt, Handshake packets with AEAD keys derived from shared_secret, Data packets with AEAD session_key. The handshake uses Kyber-768 as primary KEM with X25519 as classical fallback, providing post-quantum resistance as long as at least one algorithm remains secure. Metadata protection: Connection ID in short header is a 32-bit truncated value; Padding extension (0x03) allows random bytes for packet size obfuscation; Multipath data streams complicate passive traffic analysis. Each connection generates ephemeral keys. Compromise of an identity key does not reveal past sessions (Perfect Forward Secrecy).

Identity Layer Aether introduces cryptographic identity at the transport layer. Each node has an Ed25519 key pair. Identity is: identity = SHA-256("AETHER-ID-" || Ed25519_public_key). During handshake, the node proves key ownership by signing the transcript. Advantages: DNS/CA/PKI independent (self-sovereign identity), IP mobility (IP changes do not affect identity), decentralized (no central registry required), W3C DID compatible (identity representable as a DID).

Connection Close Graceful close: Sender -> Close (NO_ERROR), Receiver -> Close (NO_ERROR). Keys destroyed after 3x PTO. Error Codes

Code	Name	Description
0x00	NO_ERROR	Normal closure
0x01	INTERNAL_ERROR	Internal error
0x02	PROTOCOL_VIOLATION	Protocol violation
0x03	CRYPTO_ERROR	Cryptographic error
0x04	FLOW_CONTROL_ERROR	Flow control limit exceeded
0x05	TIMEOUT	Idle timeout
0x06	VERSION_NEGOTIATION	Incompatible version
0x07	REFUSED	Connection refused
0x08	IDENTITY_REJECTED	Identity not accepted

Discovery Local discovery (LAN): Multicast group 224.0.0.251:9000 (IPv4), ff02::fb:9000 (IPv6). Periodic announcements every 30 seconds. Announcement format: Initial packet with type "Announce" in extensions. Global discovery (WAN): Kademlia-based DHT (as in libp2p). DHT key = peer identity. DHT value = set of (IP, port, Connection ID) tuples. Enables peer location by identity without a centralized server.

Constants Protocol Constants

Constant	Value	Description
AETHER_DEFAULT_PORT	9000	Default port
AETHER_VERSION	0	Current protocol version
MAX_PACKET_SIZE	1400	Max packet size (MTU safe)
MAX_STREAM_ID	262143	Max Stream ID (18 bits)
IDLE_TIMEOUT_MS	30000	Connection idle timeout (ms)
PTO_BASE_MS	100	Base Probe Timeout (ms)
MAX_RETRANSMISSIONS	10	Max retransmit attempts
INITIAL_CWND	10 * MSS	Initial congestion window
INITIAL_STREAM_WINDOW	1048576	Initial stream window (bytes)
INITIAL_CONNECTION_WINDOW	16777216	Initial connection window (bytes)

Comparison with Existing Protocols Protocol Comparison

Feature	TCP	UDP	QUIC	SCTP	Aether
Reliable	Yes	No	Yes	Yes	Yes
Multiplexing	No	No	Yes*	Yes	Yes
Encryption	No**	No	Yes	No**	Yes
Multi-path	No	No	v2	Yes	Yes
Userspace	No	Yes	Yes	No	Yes
Identity layer	No	No	No	No	Yes
PQC-ready	No	No	WIP	No	Yes
NAT friendly	Yes	No	Yes	No	Yes
HOL blocking	Yes	No	Per stream	No	No

* HTTP-tied. ** Requires separate TLS/DTLS layer.

IANA Considerations This document requires no IANA actions. Future revisions may request a well-known port assignment for port 9000.

Reference Implementation A reference implementation of Aether Protocol v0.1 is available in the Rust programming language at . Components:

aether-core: Protocol library (framing, handshake, crypto, multipath, congestion control, identity, discovery).
aether-sdk: Enterprise SDK (identity vault, monitoring, SLA).
aether-gateway: L4 proxy for Aether-to-TCP bridging.
demo: Example application.

License: MIT OR Apache-2.0.