HTTP/3 Traffic Interception in Practice: A Guide to QUIC and QPACK Parsing

HTTP/3 builds encryption into QUIC over UDP; interception requires obtaining TLS keys and fully capturing the control stream to parse QPACK.
HTTP/3 is based on QUIC over UDP with built-in TLS 1.3 encryption, largely defeating traditional TCP capture and MITM proxies. The key to intercepting QUIC traffic is obtaining TLS session keys, commonly via the SSLKEYLOGFILE environment variable for Wireshark decryption. Application-layer headers are compressed with QPACK, which uses static and dynamic tables; dynamic table updates travel on a separate control stream, so both control and request streams must be captured and updates applied in order. QPACK dynamic table references can also cause decoding blockage, leading to header parsing failures in out-of-order captures. The article recommends reproducing issues in controlled environments, capturing all QUIC streams, and checking key logs and QPACK state integrity first, while recommending tools like Wireshark, curl, and open-source QUIC libraries.
HTTP/3 is rapidly replacing HTTP/2 as the transport protocol of the modern web, but its design based on QUIC and UDP poses considerable challenges to traditional packet capture and debugging tools. Based on a technical article on Hacker News, this post outlines the core difficulties and viable approaches for intercepting HTTP/3 traffic, helping developers and security researchers understand mechanisms such as QUIC encryption and QPACK header compression, and master practical debugging strategies.
Why HTTP/3 Traffic Is Hard to Intercept
HTTP/3 swaps the transport layer from TCP to UDP-based QUIC and builds TLS 1.3 directly into the protocol. This means traditional capture methods that rely on plaintext TCP or TLS man-in-the-middle proxies are almost entirely defeated: QUIC's connection establishment, key negotiation, and encrypted transmission are all integrated, so capture tools only see encrypted UDP datagrams.
Another obstacle is QPACK. HTTP/2 uses HPACK to compress header fields, whereas HTTP/3 redesigned QPACK to accommodate QUIC's multiplexing and out-of-order delivery. QPACK uses dynamic and static tables to compress headers, and updates to the dynamic table depend on a separate control stream, which makes offline parsing of captured packets complex—you cannot reconstruct complete header information from a single stream alone.
The article points out that to truly intercept and decrypt HTTP/3 traffic, two problems must be solved simultaneously: obtaining the QUIC TLS session keys, and correctly rebuilding the QPACK dynamic table state.
QUIC (Quick UDP Internet Connections) was originally designed by Google and later became an IETF standard (RFC 9000). It implements reliable transmission, congestion control, flow control, and multiplexing on top of UDP, with TLS 1.3 built in as its handshake protocol. Unlike the layered structure of TCP+TLS, QUIC fuses the transport and encryption layers, completing connection establishment and key negotiation in a single handshake. QUIC uses connection IDs rather than IP+port to identify connections, supporting connection migration (e.g., maintaining a connection when switching from Wi-Fi to cellular). These features improve performance and security, but they also mean traditional packet analysis tools based on the TCP state machine cannot directly parse QUIC packets.
Key Approaches to Intercepting QUIC Traffic
Using TLS Key Logs
The most direct approach is to have the client export TLS session keys. Similar to HTTPS debugging, by setting the environment variable SSLKEYLOGFILE, browsers or clients write TLS 1.3 handshake keys to a file, and tools like Wireshark can read that file to decrypt QUIC traffic. The article emphasizes that this approach applies to scenarios where you control the client, such as debugging your own application or a test environment.
Adapting Man-in-the-Middle Proxies
Traditional HTTP proxies are powerless against QUIC because QUIC does not run over TCP. You need to deploy a QUIC-capable proxy between the client and server, or force downgrade on the client side to HTTP/2 so that existing tools can be used for analysis. The article notes that some debugging tools have begun to support QUIC MITM mode, but configuration is demanding and certificate trust issues must be handled.
Server-Side Packet Capture
Capturing QUIC traffic directly on the server and decrypting it with key logs is another viable option. Since the server typically has access to TLS key material, this approach is more reliable for troubleshooting server-side issues. The article recommends enabling QUIC logging in containers or test environments and using capture tools for correlated analysis.
Practical Points for QPACK Parsing
Decrypting QUIC only solves the transport layer problem; the application-layer HTTP/3 headers are still compressed with QPACK. The article discusses QPACK's static and dynamic table mechanisms in detail: the static table contains common header fields that can be restored by direct lookup; the dynamic table is updated by the encoder sending update instructions on the control stream, and the decoder must apply these instructions in order to correctly decompress subsequent header blocks.
In practice, QUIC streams must be distinguished by type: the control stream carries QPACK dynamic table updates, while request streams carry header blocks and body data. If only request streams are captured and the control stream is ignored, the dynamic table state will be missing, leading to header decoding errors. The article recommends using HTTP/3-capable parsing tools, or strictly following the state machine in the RFC when implementing a QPACK decoder manually.
Additionally, the article warns about QPACK blocking: when a dynamic table reference points to an entry that has not yet arrived, decoding is blocked, which is especially common with out-of-order captures. Understanding this helps explain why some packet analyses show missing headers or parsing failures.
QPACK dynamic table update instructions are transmitted over a dedicated control stream. Each connection has one control stream, whose stream type identifier is 0x00. Request streams carry header blocks and body data, with a stream type identifier of 0x01. During packet analysis, control streams and request streams must be distinguished by their QUIC stream type identifiers, and dynamic table updates must be applied in the state machine order specified by RFC 9204. If control stream data is lost or out of order, the decoder may encounter dynamic table entry reference errors, causing QPACK decoding failures.
Tools and Debugging Recommendations
The article recommends several categories of tools: Wireshark with TLS key logs can perform QUIC decryption; curl's HTTP/3 support makes it easy to send test requests; some open-source QUIC libraries provide logging and debugging interfaces. For scenarios requiring in-depth QPACK analysis, the article suggests manually verifying header blocks against the protocol specification, or using parsing libraries designed specifically for HTTP/3.
Practical debugging tips include: reproduce problems in a controlled environment first and ensure key logs are complete; capture all QUIC streams at the same time to avoid missing the control stream; for packets that fail to parse, first check whether the QPACK dynamic table state is complete, then investigate encryption-layer issues.
Summary and Outlook
HTTP/3's encrypted design improves security and performance, but it also makes traffic analysis more difficult. The article's core point is that intercepting HTTP/3 traffic is not impossible, but it requires a shift in mindset—from passive capture to actively obtaining keys, and from single-stream analysis to full-stream correlation. As QUIC and QPACK tools mature, the debugging experience will gradually improve, but developers still need to understand protocol details to troubleshoot efficiently.
For day-to-day development, prioritize debugging tools that support HTTP/3 and key logging mechanisms; for security research, delve into QPACK state management to accurately reconstruct application-layer semantics.
Related articles

Multi-Agent Collaborative Development: Task Card-Driven Practices for Medium-to-Large AI Projects
A Bilibili creator shares a task card-driven, PM-orchestrated multi-Agent collaboration model with local-first repository state, so any Agent tool can take over a project anytime.

Cursor vs Copilot vs Claude Code: How Laravel Developers Should Choose
Compare Cursor, GitHub Copilot, and Claude Code for Laravel development: an AI-first editor, a plugin for existing editors, and a terminal agent for multi-file tasks and testing — plus workflow-based recommendations.

AgentScope Java Edition: A Practical Guide to Enterprise-Level Agent Frameworks
An in-depth analysis of Alibaba's AgentScope Java enterprise agent framework: contrasting client-side AI and server-side AI, explaining Java's natural advantages in high concurrency and distributed state management, and outlining a complete learning path from core principles to multi-agent collaboration.