This project contains known security vulnerabilities. Find detailed information at the bottom.

Crate quinn

Dependencies

(11 total, 4 outdated, 3 insecure)

CrateRequiredLatestStatus
 bytes^11.12.2up to date
 futures-channel^0.3.110.3.34up to date
 futures-util^0.3.110.3.34up to date
 fxhash^0.2.10.2.1up to date
 quinn-proto ⚠️^0.8.40.11.19insecure
 rustls ⚠️^0.20.30.23.46insecure
 thiserror^1.0.212.0.21out of date
 tokio^1.0.11.54.1up to date
 tracing^0.1.100.1.44up to date
 quinn-udp ⚠️^0.1.00.6.3insecure
 webpki^0.220.22.4up to date

Dev dependencies

(13 total, 4 outdated)

CrateRequiredLatestStatus
 anyhow^1.0.221.0.104up to date
 bencher^0.1.50.1.5up to date
 crc^23.4.0out of date
 directories-next^22.0.0up to date
 futures-util^0.3.110.3.34up to date
 rand^0.80.10.4out of date
 rcgen^0.80.14.10out of date
 rustls-pemfile^0.2.12.2.0out of date
 structopt^0.3.00.3.26up to date
 tokio^1.0.11.54.1up to date
 tracing-futures^0.2.00.2.5up to date
 tracing-subscriber^0.3.00.3.23up to date
 url^22.5.8up to date

Security Vulnerabilities

quinn-proto: Denial of service in Quinn servers

RUSTSEC-2023-0063

Receiving QUIC frames containing a frame with unknown frame type could lead to a panic. Unfortunately this is issue was not found by our fuzzing infrastructure.

Thanks to the QUIC Tester research group for reporting this issue.

rustls: `rustls::ConnectionCommon::complete_io` could fall into an infinite loop based on network input

RUSTSEC-2024-0336

If a close_notify alert is received during a handshake, complete_io does not terminate.

Callers which do not call complete_io are not affected.

rustls-tokio and rustls-ffi do not call complete_io and are not affected.

rustls::Stream and rustls::StreamOwned types use complete_io and are affected.

quinn-proto: Denial of service in Quinn endpoints

RUSTSEC-2026-0037

Receiving QUIC transport parameters containing invalid values could lead to a panic.

Unfortunately the maintainers did not properly assess usage of unwrap() calls in the transport parameters parsing code, and we did not have sufficient fuzzing coverage to find this issue. We have since added a fuzzing target to cover this code path.

quinn-proto: Remote memory exhaustion in quinn-proto from unbounded out-of-order stream reassembly

RUSTSEC-2026-0185

The Assembler component that assembles unordered stream fragments into consecutive chunks of the stream incurs some overhead for non-contiguous fragments. Readers that read from a RecvStream in order (through an AsyncRead impl for example) will be sensitive to peers that send fragments while leaving out early parts of the stream, and in particular, fragments with many gaps (because these cannot be defragmented). In such a scenario, the receiving connection suffers from high buffer overhead, enabling memory exhaustion.

quinn-proto: Remote peer can panic quinn-proto with zero-length STREAM frames during unordered reads

RUSTSEC-2026-0338

When a stream is read in unordered mode (for example through RecvStream::read(false) in quinn-proto or read_unordered in quinn), quinn-proto proactively deduplicates received data by recording received ranges in a RangeSet through its replace method. When an incoming STREAM frame carried an empty payload, the Drop implementation of the iterator returned by replace inserted an empty range into the set, violating the invariant that stored ranges are non-empty. Subsequent frames overlapping that region then caused a panic while processing the stream.

A remote peer can trigger this with five small STREAM frames (two of them zero-length) once the application has put the stream in unordered-read mode. The default ordered read path is not affected.

The flaw was corrected in 0.11.18 by ignoring empty ranges in RangeSet::replace.

Thanks to Otto Hermann (@ojhermann) for reporting this issue.

quinn-proto: Unbounded growth of pending connection ID retirements in quinn-proto

RUSTSEC-2026-0339

When processing a NEW_CONNECTION_ID frame, quinn-proto queues a RETIRE_CONNECTION_ID frame for each connection ID that the peer asked it to retire. The normal path bounds this queue and closes the connection with a CONNECTION_ID_LIMIT_ERROR if the bound would be exceeded. However, the path handling a connection ID that had already been retired pushed onto the queue without applying the limit and without deduplicating.

A peer that has completed the handshake can first send a NEW_CONNECTION_ID frame with a large retire_prior_to value to advance the receiver's connection ID window, and then repeatedly send NEW_CONNECTION_ID frames with sequence numbers below that window. Each such frame adds another entry to the queue. The queue is only drained by sending RETIRE_CONNECTION_ID frames, which are subject to congestion control, so a peer that withholds acknowledgements can stall the drain while continuing to flood, growing the victim's memory use without bound.

The flaw was corrected in 0.11.17 by applying the same limit on the already-retired path.

Thanks to @scadastrangelove for reporting this issue.

quinn-proto: Zero-length DATAGRAM frames bypass the receive buffer limit in quinn-proto

RUSTSEC-2026-0342

quinn-proto bounds its queue of received datagrams by charging each queued frame's payload length against TransportConfig::datagram_receive_buffer_size, evicting the oldest datagrams when the limit is exceeded. A DATAGRAM frame with an empty payload was charged zero bytes, so it never triggered eviction and was appended to the queue, which has no other bound.

DATAGRAM frames are not subject to flow control. A peer that has completed the handshake can therefore send a stream of empty DATAGRAM frames and grow the receiver's heap without limit until the process is killed. An application that reads incoming datagrams but does so more slowly than the peer sends them is still affected. Receiving datagrams is enabled by default, so all endpoints that do not explicitly set datagram_receive_buffer_size(None) are affected.

The send path had the same accounting flaw: an application could enqueue an unbounded number of empty outgoing datagrams without ever receiving SendDatagramError::Blocked.

The flaw was corrected in 0.11.17 by accounting for the fixed per-datagram overhead in both directions, so that every queued datagram consumes buffer space.

Thanks to @alexpyattaev for reporting this issue.

rustls: Unauthenticated ServerHello can downgrade later connections to classical key exchange

RUSTSEC-2026-0349

The client recorded the server-selected key exchange group for each server name when processing the ServerHello, before the server was authenticated. This record is used to predict which key share to send in future ClientHellos to that server name.

A network attacker can answer one connection attempt with a ServerHello selecting X25519, and then close the connection. Later ClientHellos for that name carry only an X25519 key share, while supported_groups still lists X25519MLKEM768 first. If the genuine server accepts that share rather than sending a HelloRetryRequest for its preferred hybrid group, the handshake completes with classical-only key exchange and no error. This persists for as long as the entry stays in the client's session store.

The impact is loss of post-quantum confidentiality for affected connections ("harvest now, decrypt later"). There is no key compromise and no authentication bypass.

The following are not affected:

  • connections to servers which send a HelloRetryRequest for their preferred group,
  • clients with resumption disabled (as nothing is stored), and
  • other server names.

This behaviour is discussed in draft-ietf-tls-key-share-prediction, so the practical impact depends largely on server policy.

quinn-udp: Receive loop can spin after a truncated datagram

RUSTSEC-2026-0538

Some targets read one datagram per recvmsg call instead of using recvmmsg: Apple platforms without the fast-apple-datapath feature, OpenBSD, NetBSD, Solaris and illumos, and from 0.6 also DragonFly BSD, Redox and GNU/Hurd. On these targets the receive loop set up its msghdr only once and looked at the MSG_TRUNC flag before checking whether recvmsg had failed. After a datagram larger than the receive buffer was dropped, a following EAGAIN still saw the old truncation flag. The loop then kept issuing non-blocking receives instead of returning WouldBlock.

When the receive buffer is smaller than a datagram that arrives, a remote sender can keep the task that drives the socket busy, before any QUIC packet authentication. The loop ends only when a later datagram fits in the buffer. Whether an application is exposed therefore depends on the receive buffer size it uses. Linux, Android, FreeBSD and Windows use other receive paths and are not affected.

The fix rebuilds the header before every recvmsg call and returns receive errors before checking the truncation flag. It is in 0.5.16 and 0.6.3.