QUIC M. Kozuka Internet-Draft Okayama University Intended status: Standards Track 14 November 2026 Expires: 18 May 2027 Stateless Server-Assisted Hole Punching for QUIC draft-kozuka-quic-stateless-punch-00 Abstract This document specifies a QUIC extension that lets two endpoints connected through a relay establish a direct path between them when one or both are behind Network Address Translators (NATs). The client asks the server, over the existing connection, to send a single small "punch" packet toward one of the client's address candidates. The server keeps no per-attempt state and does not initiate validation of candidate paths. After a short delay, the client validates the direct path using ordinary client-initiated path validation as defined in RFC 9000, or ordinary path creation as defined in RFC 10069 when QUIC multipath is in use, and can then migrate the connection to it. Discussion Venues This note is to be removed before publishing as an RFC. Discussion of this document takes place on the QUIC Working Group mailing list (quic@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/quic/. Source for this draft and an issue tracker can be found at https://github.com/masa-koz/draft-kozuka-quic-stateless-punch. Status of This Memo This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79. Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet- Drafts is at https://datatracker.ietf.org/drafts/current/. Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress." Kozuka Expires 18 May 2027 [Page 1] Internet-Draft QUIC Stateless Punch November 2026 This Internet-Draft will expire on 18 May 2027. Copyright Notice Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved. This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/ license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License. Table of Contents 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3 2. Conventions and Definitions . . . . . . . . . . . . . . . . . 4 3. Overview . . . . . . . . . . . . . . . . . . . . . . . . . . 4 4. Address Candidates . . . . . . . . . . . . . . . . . . . . . 5 5. Punch Requests . . . . . . . . . . . . . . . . . . . . . . . 6 5.1. Limits . . . . . . . . . . . . . . . . . . . . . . . . . 7 6. Punch Packets . . . . . . . . . . . . . . . . . . . . . . . . 8 6.1. Receiving a Punch Packet . . . . . . . . . . . . . . . . 9 7. Client-Initiated Path Validation . . . . . . . . . . . . . . 10 8. Migration . . . . . . . . . . . . . . . . . . . . . . . . . . 11 9. Extension Negotiation . . . . . . . . . . . . . . . . . . . . 12 10. PUNCH_ME_NOW Frame . . . . . . . . . . . . . . . . . . . . . 12 11. Security Considerations . . . . . . . . . . . . . . . . . . . 13 12. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 14 12.1. QUIC Transport Parameter . . . . . . . . . . . . . . . . 14 12.2. QUIC Frame Types . . . . . . . . . . . . . . . . . . . . 14 13. References . . . . . . . . . . . . . . . . . . . . . . . . . 15 13.1. Normative References . . . . . . . . . . . . . . . . . . 15 13.2. Informative References . . . . . . . . . . . . . . . . . 15 Appendix A. Comparison with draft-seemann-quic-nat-traversal-04 . . . . . . . . . . . 16 Appendix B. Implementation Status . . . . . . . . . . . . . . . 18 B.1. SEERA MsQuic . . . . . . . . . . . . . . . . . . . . . . 18 Appendix C. Open Issues . . . . . . . . . . . . . . . . . . . . 19 Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . 20 Author's Address . . . . . . . . . . . . . . . . . . . . . . . . 20 Kozuka Expires 18 May 2027 [Page 2] Internet-Draft QUIC Stateless Punch November 2026 1. Introduction Two QUIC endpoints that are both behind NATs often cannot reach each other directly, but they can establish a connection through a relay, for example a proxy that supports [I-D.ietf-masque-connect-udp-listen], or a proxy that pairs two authenticated clients as defined in [I-D.seemann-masque-connect-udp-rendezvous]. Once such a relayed connection exists, it can carry application data immediately and also serve as the signaling channel for discovering a direct path. If a direct path is found, the connection can migrate to it (Section 9 of [RFC9000]); otherwise, the endpoints keep using the relayed path. [I-D.seemann-quic-nat-traversal] defines an extension for this purpose. In its current form, the server takes an active part in every traversal attempt: it accepts grants and requests, sends PATH_CHALLENGE probes on unvalidated paths, issues dedicated "punching" connection IDs, and reports the result of each attempt. This document specifies a smaller alternative for the probing step, based on a design suggested by Christian Huitema in the discussion of that draft [ISSUE20]. The server's only extension-specific action is to send one small, opaque packet per request. This packet creates the binding in the server-side NAT or firewall; it is not expected to be processed by the client. Validation of each candidate path is initiated by the client and follows [RFC9000] (or [RFC10069]) without modification. The only path validation the server performs is the ordinary validation of the client's address when the client migrates to a validated path (Section 8). The design has the following properties: * The server keeps no per-attempt state. * The server never sends PATH_CHALLENGE frames on a path before the client has validated that path, and each punch packet is no larger than the packet carrying the request that caused it. * No new type of connection ID is introduced, and no special handling is needed when QUIC multipath is used. * Only one new frame is defined. The cost is additional latency: the client waits roughly one round- trip time of the relayed path before sending its first probe. Kozuka Expires 18 May 2027 [Page 3] Internet-Draft QUIC Stateless Punch November 2026 Address candidates are advertised using the ALTERNATIVE_ADDRESS frame defined in [I-D.munizaga-quic-alternative-server-address], as in [I-D.seemann-quic-nat-traversal]. The authors' intention is that this document serve as input to the discussion of that draft. If the approach described here is adopted there, this document need not proceed further. 2. Conventions and Definitions The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here. This document uses the following terms: Address candidate: A transport address (IP address and UDP port) at which an endpoint might be reachable, as in [RFC8445]. Sending base: The local sending context used for an address candidate, such as a UDP socket on a particular network interface or a tunnel. This term is borrowed from [I-D.seemann-quic-nat-traversal]. Punch request: A PUNCH_ME_NOW frame (Section 10) sent by the client on a validated path, asking the server to send a punch packet. Punch packet: A small, opaque UDP datagram that the server sends in response to a punch request (Section 6). Its purpose is to create a binding in NATs and firewalls on the server side. Attempt: The sequence consisting of one punch request, the resulting punch packet, and the client's subsequent path validation for one pair of address candidates. 3. Overview The client and server first establish a QUIC connection over a relayed path and negotiate this extension (Section 9). The server advertises its address candidates using ALTERNATIVE_ADDRESS frames. The client pairs them with its own candidates and, for each pair it wants to try, performs an attempt: 1. The client sends a PUNCH_ME_NOW frame on the relayed path, naming its own candidate (C) and the server candidate (S). 2. The server sends one punch packet from the sending base associated with S to C. The server creates no path and keeps no state for the attempt. The punch packet creates a binding in the server-side NAT or firewall. It most likely does not reach the client, because the client-side NAT has no matching binding yet. Kozuka Expires 18 May 2027 [Page 4] Internet-Draft QUIC Stateless Punch November 2026 3. After a delay, the client sends a PATH_CHALLENGE from the base associated with C to S. This packet creates a binding in the client-side NAT and, because the server-side binding now exists, reaches the server. 4. The server answers with PATH_RESPONSE as it would for any client- initiated path validation. The response passes through both bindings, and the path is validated. The client can then migrate the connection to this path, or use it as an additional path when QUIC multipath is in use (Section 8). Client Client Relay Server Server (base C) NAT NAT (base S) | | | | | |-- PUNCH_ME_NOW(C, S) -->|------------------------>| | | | | | | x<-------------------- punch packet -| | (no binding: | (binding | | dropped) | created) | | | | | | | ... client waits ~ smoothed RTT of relayed path ... | | | | | |-- PATH_CHALLENGE (to S) ------------------------->| | (binding created) | (passes) | | | | | | |<------------------------------- PATH_RESPONSE ----| | | | | | Figure 1: An attempt in which both endpoints are behind NATs This works when both NATs use endpoint-independent mapping (Section 4.1 of [RFC4787]), regardless of their filtering behavior. NATs with endpoint-dependent mapping are discussed in Appendix C. 4. Address Candidates The gathering of address candidates is out of scope for this document. Endpoints MAY use the logic described in Sections 5.1.1 and 5.2 of [RFC8445], or they MAY use address candidates provided by the application. Kozuka Expires 18 May 2027 [Page 5] Internet-Draft QUIC Stateless Punch November 2026 The server advertises its candidates using ALTERNATIVE_ADDRESS frames [I-D.munizaga-quic-alternative-server-address]. The server records the sending base associated with each advertised address. A given address and port appear at most once in an ALTERNATIVE_ADDRESS frame, and in the common case each advertised address corresponds to a single sending base. Different sending bases can, however, share an advertised address, for example with overlapping address spaces (Appendix B.2 of [RFC8445]). How the server chooses a sending base in that case is an open issue (Appendix C). The client never advertises its candidates to the server. Instead, it names one of its candidates in each punch request. The address the client names is the one at which it expects the server's packets to arrive, for example a server-reflexive address in the terminology of [RFC8445]. The client pairs server candidates with its own candidates. Section 5.1 of [RFC8445] describes one algorithm for forming and prioritizing candidate pairs. Since pairing happens only at the client, the endpoints do not need to agree on an algorithm. When this extension has been negotiated, the client SHOULD NOT send a PATH_CHALLENGE to an advertised address for which it has not sent a punch request. The guidance in [I-D.munizaga-quic-alternative-server-address] to validate higher- priority addresses promptly still applies, but validation of each address is preceded by a punch request. 5. Punch Requests To start an attempt, the client sends a PUNCH_ME_NOW frame (Section 10) on a validated path. The frame contains the client candidate and the server candidate of the pair. The client SHOULD send punch requests as soon as candidate pairs become available. It MAY delay requests in order to prioritize pairs or to limit the number of attempts in progress. The server MUST ignore a PUNCH_ME_NOW frame received before the handshake is confirmed (Section 4.1.2 of [RFC9001]). Data received before then, such as 0-RTT data, can be replayed by an attacker (Section 9.2 of [RFC9001]), and a replayed request would cause the server to send a punch packet toward an address of the attacker's choosing. A legitimate client never sends a request this early: this extension is not remembered for 0-RTT, and PUNCH_ME_NOW frames are sent only in 1-RTT packets (Section 9). Kozuka Expires 18 May 2027 [Page 6] Internet-Draft QUIC Stateless Punch November 2026 On receiving a PUNCH_ME_NOW frame after the handshake is confirmed, the server looks up the server address and port among the IPv4 and IPv6 entries it has advertised in its most recent ALTERNATIVE_ADDRESS frame. * If there is no matching entry, the server MUST ignore the frame. This can happen legitimately, because the client's request might have been sent before it processed an ALTERNATIVE_ADDRESS frame that withdrew the address. The server MUST NOT treat this as a connection error. * Otherwise, the server sends one punch packet (Section 6) from the sending base associated with the entry to the client address and port in the frame, subject to the limits in Section 5.1. After sending the punch packet, or after ignoring the frame, the server retains no state related to the request. In particular, the server does not create a path, does not allocate a connection ID, and does not report the result of the attempt. A server MAY decline to send a punch packet for any reason, for example because of the limits in Section 5.1 or local policy about acceptable client addresses. The client learns of this only because its path validation fails. 5.1. Limits A punch request causes the server to send a packet to an address chosen by the client, before that address has been validated. To prevent the extension from being used for amplification, the server MUST NOT send more than one punch packet in response to a single received packet, regardless of how many PUNCH_ME_NOW frames that packet contains. If a packet contains more than one PUNCH_ME_NOW frame, the server processes at most one of them and ignores the others as described in Section 5. Together with the size limit in Section 6, this ensures that neither the number of packets nor the number of bytes the server sends in punch packets exceeds what it received in the corresponding requests. Because the limit applies to each received packet, a client cannot accumulate an allowance and later release it as a burst. A client SHOULD therefore send each PUNCH_ME_NOW frame, including a retransmitted one, in a separate packet. Kozuka Expires 18 May 2027 [Page 7] Internet-Draft QUIC Stateless Punch November 2026 The server MUST additionally limit the rate at which it sends punch packets on a connection, for example using a token bucket with a small burst size. Each punch packet creates a binding in the server- side NAT, and an unbounded number of requests could exhaust its mapping table and disrupt unrelated flows. Requests that exceed the limit are ignored as described in Section 5. The server MUST NOT send a punch packet to an address that it would not use as the destination of a QUIC packet, such as a multicast, broadcast, or unspecified address. Because the client chooses both the destination address and the destination port, punch requests can be used for request forgery (Section 21.5 of [RFC9000]). The server SHOULD NOT send a punch packet to a loopback or link-local address, or to an address that is reachable only from the server's own network (for example, a private address reachable through a sending base that is not behind a NAT), unless local policy explicitly permits it. The server MAY also refuse to send punch packets to destination ports that it considers sensitive, applying the countermeasures in Section 21.5.6 of [RFC9000]. 6. Punch Packets A punch packet is a UDP datagram sent by the server from the selected sending base to the client address and port given in the punch request. Its only purpose is to create a binding in NATs and firewalls on the server side. The client is not expected to receive or process it. A server MUST NOT send more than one punch packet in response to a single PUNCH_ME_NOW frame, nor more than one in response to a single received packet (Section 5.1). Punch packets are never retransmitted. If a punch packet is lost, the attempt fails, and the client can start a new attempt with a new request (Section 7). A punch packet SHOULD be formatted as a QUIC packet with a short header, so that it is treated as part of a QUIC flow by middleboxes on the path. The Destination Connection ID MUST be a random value chosen by the server for this packet. It MUST NOT be a connection ID issued by the client, so that the punch packet cannot be linked to other paths of the connection (Section 9.5 of [RFC9000]) and cannot be accepted by the client as a packet of the connection. The remainder of the packet is opaque. The server MAY construct it as a 1-RTT packet of the connection containing a single PING frame, or MAY fill it with random bytes. Kozuka Expires 18 May 2027 [Page 8] Internet-Draft QUIC Stateless Punch November 2026 If the server constructs the punch packet as a protected 1-RTT packet, the packet MUST be long enough for header protection to be applied (Section 5.4.2 of [RFC9001]): at least 4 bytes must follow the start of the Packet Number field in addition to the 16-byte sample. With a single PING frame and a short packet number encoding, this requires adding PADDING frames or using a longer packet number encoding. A punch packet SHOULD be as small as the server can make it, and MUST NOT be larger than the packet in which the corresponding PUNCH_ME_NOW frame was received. It does not need to be expanded to 1200 bytes: the path MTU is verified later by the client's PATH_CHALLENGE, which is subject to the datagram size requirements of Section 8.2.1 of [RFC9000]. If the server constructs the punch packet using the connection's packet protection, it takes the packet number from the application data packet number space of the path on which the PUNCH_ME_NOW frame was received; with QUIC multipath, this is the packet number space of that path's Path ID, which is also used to form the nonce (Section 2.4 of [RFC10069]). The packet number is consumed: the server MUST NOT use it for any other packet, as reusing a packet number with the same key and Path ID would reuse the AEAD nonce. The packet number MUST NOT be tracked for loss recovery or congestion control. The punch packet is not expected to be acknowledged, and declaring it lost would cause a spurious congestion response on the relayed path. From the peer's point of view the number is skipped, which is permitted (Section 21.4 of [RFC9000]). 6.1. Receiving a Punch Packet If a punch packet reaches the client, the client cannot associate it with a connection, because its Destination Connection ID was never issued. The client handles it as any packet with an unknown connection ID (Section 5.2 of [RFC9000]): the packet is discarded. A client that uses zero-length connection IDs associates packets with connections by local address and port (Section 5.2.1 of [RFC9000]), and might therefore attempt to process a punch packet that arrives on the base associated with its candidate. The punch packet cannot be authenticated by the client, because the client parses the header differently from how the server constructed it, or because the packet consists of random bytes. The client discards it as it would any packet that fails authentication. Such a failure counts toward the integrity limit of the connection's keys (Section 6.6 of [RFC9001]); this is negligible, as the number of punch packets is small. Kozuka Expires 18 May 2027 [Page 9] Internet-Draft QUIC Stateless Punch November 2026 The client might respond with a Stateless Reset (Section 10.3 of [RFC9000]). This is harmless. Its size is bounded by the rules in Section 10.3 of [RFC9000]: it is normally smaller than the punch packet (Section 10.3.3 of [RFC9000]) and is never three or more times larger. It cannot match a stateless reset token issued for the connection, and it is sent toward an address the server has advertised and from which the server sent the punch packet. Endpoints SHOULD NOT treat the receipt of a punch packet as an error, and implementations are encouraged not to log it at a level that suggests a fault. 7. Client-Initiated Path Validation After sending a PUNCH_ME_NOW frame, the client waits before probing the path, so that the server's punch packet has time to create the server-side binding. If the client's PATH_CHALLENGE reaches the server side first, the server-side NAT is likely to drop it. The relayed request needs roughly one one-way delay of the relayed path to reach the server. It is RECOMMENDED that the client wait for the smoothed RTT (Section 5.3 of [RFC9002]) of the path on which it sent the PUNCH_ME_NOW frame. This leaves a margin of approximately one further one-way delay. A client MAY use a shorter delay if it has better information. The client then validates the path from the base associated with the client candidate to the server candidate. * Without QUIC multipath, the client follows Section 8.2 of [RFC9000], using a connection ID issued by the server that has not been used on any other path. * With QUIC multipath [RFC10069], the client opens a new path using an unused Path ID, as for any other new path. The server responds as it would to any client-initiated path validation or new path; no behavior specific to this extension is required on the server for this step. The client sends PATH_CHALLENGE frames, and handles validation timeout, as described in Section 8.2.4 of [RFC9000]. A PATH_CHALLENGE that is dropped because it arrived before the server- side binding existed is handled like a lost packet; a subsequent PATH_CHALLENGE for the same validation can still succeed. If validation fails, the client abandons the attempt: Kozuka Expires 18 May 2027 [Page 10] Internet-Draft QUIC Stateless Punch November 2026 * Without QUIC multipath, the client retires the connection ID it used for the attempt with a RETIRE_CONNECTION_ID frame. The server issues a replacement using NEW_CONNECTION_ID as usual. * With QUIC multipath, the client closes the path with PATH_ABANDON, which also retires its connection IDs. The client MAY then start a new attempt for the same pair by sending a new PUNCH_ME_NOW frame. Each attempt consumes a fresh server- issued connection ID, as required by Section 9.5 of [RFC9000]. Without QUIC multipath, failed attempts release their connection IDs, so the number of connection IDs needed is bounded by the number of attempts in progress at the same time, not by the total number of attempts. The client controls this number through its active_connection_id_limit transport parameter. With QUIC multipath, a Path ID cannot be reused once its path has been abandoned (Section 3.4 of [RFC10069]), because the Path ID is part of the nonce calculation (Section 2.4 of [RFC10069]). Each attempt therefore consumes a Path ID permanently. Opening a path requires connection IDs for the same Path ID from both endpoints, so the number of attempts is bounded by the maximum Path ID limits of both endpoints (Section 3.2.1 of [RFC10069]). When this extension and QUIC multipath are both in use, each endpoint SHOULD increase its maximum Path ID using MAX_PATH_ID frames (Section 4.6 of [RFC10069]) as paths are abandoned, and SHOULD issue connection IDs for the newly allowed Path IDs using PATH_NEW_CONNECTION_ID frames, so that failed attempts do not prevent further attempts. A client that cannot start an attempt follows Section 3.2.1 of [RFC10069]: it sends a PATHS_BLOCKED frame if it has no unused Path ID, or a PATH_CIDS_BLOCKED frame if it has no connection ID for an unused Path ID (Section 4.7 of [RFC10069]). 8. Migration Once a direct path has been validated, the client can migrate the connection to it (Section 9 of [RFC9000]) or, when QUIC multipath is used, send application data on it. How the client chooses among validated paths, and whether it keeps the relayed path, is out of scope for this document. The client's path validation verifies only the server's address. When the client migrates by sending non-probing frames on the new path, the server validates the client's address as required by Section 9.3 of [RFC9000]; with QUIC multipath, the server likewise validates the new path before using it. This is ordinary server behavior, not part of this extension, and takes place only after the Kozuka Expires 18 May 2027 [Page 11] Internet-Draft QUIC Stateless Punch November 2026 client has validated the path, so both NAT bindings already exist and the validation is expected to succeed. Until it completes, the server is limited by the anti-amplification limit (Section 8 of [RFC9000]), which can add up to one round trip of the direct path before the server can send at full rate. Because all new paths are initiated by the client, this extension does not require the server to migrate the connection, consistent with Section 9 of [RFC9000]. 9. Extension Negotiation Endpoints advertise support for this extension by sending the stateless_punch transport parameter (Section 7.4 of [RFC9000]) with an empty value. An endpoint that understands this transport parameter MUST treat receipt of a non-empty value as a connection error of type TRANSPORT_PARAMETER_ERROR. The extension is in use on a connection only if both endpoints sent the transport parameter. A client that sends stateless_punch MUST also send the alternative_address transport parameter defined in [I-D.munizaga-quic-alternative-server-address]. A server that understands stateless_punch MUST treat receipt of stateless_punch without alternative_address as a connection error of type TRANSPORT_PARAMETER_ERROR. This transport parameter MUST NOT be remembered for use in 0-RTT. The PUNCH_ME_NOW frame MUST only be sent in 1-RTT packets. 10. PUNCH_ME_NOW Frame PUNCH_ME_NOW Frame { Type (i) = 0x5eea90..0x5eea91, Client Address (32/128), Client Port (16), Server Address (32/128), Server Port (16), } Figure 2: PUNCH_ME_NOW Frame Format The least significant bit of the frame type selects the address family: 0x5eea90 indicates IPv4, in which case both address fields are 32 bits long; 0x5eea91 indicates IPv6, in which case both address fields are 128 bits long. Client Address and Client Port: The client's address candidate to which the server sends the punch packet. Kozuka Expires 18 May 2027 [Page 12] Internet-Draft QUIC Stateless Punch November 2026 Server Address and Server Port: The server candidate, which MUST be equal to an IPv4 or IPv6 entry that the client received in an ALTERNATIVE_ADDRESS frame. PUNCH_ME_NOW frames are ack-eliciting and are not probing frames (Section 9.1 of [RFC9000]); they are sent on a validated path. A lost PUNCH_ME_NOW frame SHOULD be retransmitted unless the client has given up on the attempt. Because the server keeps no state, each received frame, including a retransmission, is processed independently and can result in a punch packet, subject to Section 5.1. This frame is only sent by the client. A client MUST treat receipt of a PUNCH_ME_NOW frame as a connection error of type PROTOCOL_VIOLATION. 11. Security Considerations This extension allows a client to cause the server to send a packet to an address of the client's choosing before that address has been validated. This is similar to the request forgery risk discussed in Section 21.5 of [RFC9000]. The following properties limit the exposure: * The server sends at most one punch packet per received packet, however many requests that packet contains, and the punch packet is no larger than the packet carrying the request (Section 5.1). The extension therefore provides no amplification, in either packets or bytes, and unused allowance cannot be accumulated into a burst. * Punch packets are not retransmitted and their contents are not chosen by the client. However, the client chooses the destination address and port, so a punch packet could reach a service, or create state in a firewall, that an off-path attacker could not reach directly. The restrictions on destinations in Section 5.1 address this. * The server does not send PATH_CHALLENGE frames or any other frames of the connection on unvalidated paths as part of this extension. All traffic on a new path beyond the punch packet is sent in response to packets received from the client on that path, and is therefore subject to the anti-amplification limits of Section 8 of [RFC9000]. Kozuka Expires 18 May 2027 [Page 13] Internet-Draft QUIC Stateless Punch November 2026 Each punch packet creates a binding in NATs on the server side. A client sending many requests could exhaust the mapping table of the server's NAT, affecting other flows. Servers rate-limit punch packets for this reason (Section 5.1). A punch packet can elicit a Stateless Reset from the client's endpoint. Its size is bounded relative to the punch packet as described in Section 10.3 of [RFC9000], and it is sent toward the server's own sending base. Punch requests are carried inside an authenticated QUIC connection and cannot be forged by an off-path attacker. A request in replayed 0-RTT data could otherwise cause a punch packet to be sent; the server therefore ignores requests received before the handshake is confirmed (Section 5). The Destination Connection ID of a punch packet is random and is not used on any other path, so punch packets cannot be correlated with other packets of the connection by an observer (Section 9.5 of [RFC9000]). A punch packet reveals the server's advertised address to the network at the client's candidate address; the server has already advertised this address to the client. 12. IANA Considerations 12.1. QUIC Transport Parameter This document registers the following value in the "QUIC Transport Parameters" registry maintained at https://www.iana.org/assignments/ quic. Value: 0x5eea9e7a (provisional, to be assigned) Parameter Name: stateless_punch Status: provisional Specification: This document 12.2. QUIC Frame Types This document registers the following values in the "QUIC Frame Types" registry maintained at https://www.iana.org/assignments/quic. +=====================+==============+=============+===============+ | Value | Frame Name | Status | Specification | +=====================+==============+=============+===============+ | 0x5eea90 - 0x5eea91 | PUNCH_ME_NOW | provisional | This document | +---------------------+--------------+-------------+---------------+ Table 1: Frame type registrations Kozuka Expires 18 May 2027 [Page 14] Internet-Draft QUIC Stateless Punch November 2026 13. References 13.1. Normative References [I-D.munizaga-quic-alternative-server-address] Munizaga, M. and M. Seemann, "QUIC Alternative Server Address Frames", Work in Progress, Internet-Draft, draft- munizaga-quic-alternative-server-address-02, 25 September 2026, . [RFC10069] Liu, Y., Ed., Ma, Y., De Coninck, Q., Ed., Bonaventure, O., Huitema, C., and M. Kühlewind, Ed., "Managing Multiple Paths for a QUIC Connection", RFC 10069, DOI 10.17487/RFC10069, November 2026, . [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997, . [RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, May 2017, . [RFC8445] Keranen, A., Holmberg, C., and J. Rosenberg, "Interactive Connectivity Establishment (ICE): A Protocol for Network Address Translator (NAT) Traversal", RFC 8445, DOI 10.17487/RFC8445, July 2018, . [RFC9000] Iyengar, J., Ed. and M. Thomson, Ed., "QUIC: A UDP-Based Multiplexed and Secure Transport", RFC 9000, DOI 10.17487/RFC9000, May 2021, . [RFC9001] Thomson, M., Ed. and S. Turner, Ed., "Using TLS to Secure QUIC", RFC 9001, DOI 10.17487/RFC9001, May 2021, . [RFC9002] Iyengar, J., Ed. and I. Swett, Ed., "QUIC Loss Detection and Congestion Control", RFC 9002, DOI 10.17487/RFC9002, May 2021, . 13.2. Informative References Kozuka Expires 18 May 2027 [Page 15] Internet-Draft QUIC Stateless Punch November 2026 [I-D.ietf-masque-connect-udp-listen] Schinazi, D. and A. Singh, "Proxying Bound UDP in HTTP", Work in Progress, Internet-Draft, draft-ietf-masque- connect-udp-listen-16, 24 August 2026, . [I-D.seemann-masque-connect-udp-rendezvous] Seemann, M., "UDP Rendezvous over HTTP", Work in Progress, Internet-Draft, draft-seemann-masque-connect-udp- rendezvous-00, 16 August 2026, . [I-D.seemann-quic-nat-traversal] Seemann, M. and E. Kinnear, "Using QUIC to traverse NATs", Work in Progress, Internet-Draft, draft-seemann-quic-nat- traversal-04, 2 November 2026, . [ISSUE20] "consider allowing probe packets to be smaller than 1200 bytes", draft-seemann-quic-nat-traversal issue #20, October 2023, . [RFC4787] Audet, F., Ed. and C. Jennings, "Network Address Translation (NAT) Behavioral Requirements for Unicast UDP", BCP 127, RFC 4787, DOI 10.17487/RFC4787, January 2007, . [RFC7942] Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, DOI 10.17487/RFC7942, July 2016, . Appendix A. Comparison with draft-seemann-quic-nat-traversal-04 This appendix explains how the design in this document relates to [I-D.seemann-quic-nat-traversal]. Both documents share the overall approach (a relayed connection, server candidates advertised with ALTERNATIVE_ADDRESS, client-side pairing, migration to a direct path) and differ only in how probing is coordinated. Kozuka Expires 18 May 2027 [Page 16] Internet-Draft QUIC Stateless Punch November 2026 +==================+============================+================+ | Aspect | seemann-04 | This document | +==================+============================+================+ | Server-initiated | Yes | No | | validation of | | | | candidate paths | | | +------------------+----------------------------+----------------+ | Server state per | Grant, two punching CIDs, | None | | attempt | status | | +------------------+----------------------------+----------------+ | Server packets | PATH_CHALLENGE probes, | One small | | before | retransmitted until | punch packet | | validation | timeout | | +------------------+----------------------------+----------------+ | New frames | 4 (PUNCH_GRANT, | 1 | | | MAX_PUNCH_GRANTS, | (PUNCH_ME_NOW) | | | PUNCH_REQUEST, PUNCH_DONE) | | +------------------+----------------------------+----------------+ | New connection | Punching connection IDs | None | | ID type | | | +------------------+----------------------------+----------------+ | Multipath | Reserved Path ID | None (ordinary | | special handling | 0xffffffff | path creation) | +------------------+----------------------------+----------------+ | Server candidate | Advertisement sequence | Address and | | reference | number and entry index | port | +------------------+----------------------------+----------------+ | Added latency | None | About one | | | | relayed | | | | smoothed RTT | +------------------+----------------------------+----------------+ Table 2: Comparison of the two approaches Several mechanisms in [I-D.seemann-quic-nat-traversal] follow from the server taking part in path validation for each attempt: * Punching connection IDs are needed because the server sends packets of the connection on each candidate path, and the number of concurrent attempts would otherwise be limited by active_connection_id_limit. In this document, the server sends no packet of the connection on an unvalidated path, and the client's validation uses ordinary connection IDs whose consumption is bounded by the number of concurrent attempts, or, with QUIC multipath, by the Path IDs that both endpoints make available (Section 7). Kozuka Expires 18 May 2027 [Page 17] Internet-Draft QUIC Stateless Punch November 2026 * PUNCH_DONE is needed so that both endpoints can release per- attempt state. A stateless server has nothing to release. * PUNCH_REQUEST is sent both on the established path and inside each probe, because a direct probe from the client can overtake the relayed request. In this document, the client probes only after a delay, so the request always arrives first in normal operation, and a PATH_CHALLENGE that arrives too early is simply retransmitted. * A reserved Path ID is needed for multipath because punching connection IDs are not associated with ordinary paths. Here, every new path is an ordinary path created by the client. * Grants and MAX_PUNCH_GRANTS let both endpoints bound the work per connection. Here, the server bounds its work with a local rate limit, and the existing connection ID and Path ID limits bound the number of concurrent attempts. * Referencing server candidates by advertisement sequence number and entry index requires rules for keeping entries stable across advertisements and a status for stale references. Naming the address directly removes these rules; a request naming a withdrawn address is ignored. The main cost of this document's approach is latency: the client's first probe is delayed by about one relayed smoothed RTT. In addition, if the single punch packet is lost, a new attempt costs one more relayed round trip. The server could mitigate the latter by sending a small, fixed number of punch packets without keeping state (see Appendix C). Appendix B. Implementation Status | Note to RFC Editor: please remove this section before publication. This section records the status of known implementations of the protocol defined by this specification at the time of posting of this Internet-Draft, and is based on a proposal described in [RFC7942]. B.1. SEERA MsQuic Organization: SEERA Networks Description: A fork of MsQuic that migrates connections carried over Kozuka Expires 18 May 2027 [Page 18] Internet-Draft QUIC Stateless Punch November 2026 a MASQUE relay to a direct path. It implements the PUNCH_ME_NOW frame (0x5eea90 and 0x5eea91) and the stateless_punch transport parameter (0x5eea9e7a) as specified in this document, with server candidates advertised using ALTERNATIVE_ADDRESS frames as defined in draft-munizaga-quic-alternative-server-address-02. Server behavior: The server looks up the named server candidate by address and port and keeps no per-attempt state. It sends at most one punch packet per received packet and at most 10 punch packets per second on a connection, using a fixed one-second window so that unused allowance is not carried over. It refuses multicast, broadcast, unspecified, loopback, and link-local destinations, and a small set of destination ports (53, 123, 137, 161, 389, 1900, and 11211). The punch packet consists of random bytes behind a short header with a random Destination Connection ID, rather than a protected 1-RTT packet, so it uses no packet number. It is no larger than the packet that carried the request, or 64 bytes, whichever is smaller. Client behavior: The client sends each PUNCH_ME_NOW frame in a separate packet and retransmits it if lost. It waits the smoothed RTT of the relayed path and then validates the path from the local address and port behind the client candidate named in the request. On failure, it retires the connection ID used for the attempt, or abandons the path when QUIC multipath is in use. Differences from this document: None known. Where this document leaves a choice open, the server uses the first matching sending base when several share an advertised address (see Appendix C). Maturity: Not yet deployed in a production environment. On a QEMU- based testbed, a direct path was established through a cone NAT, and through an IPv6 firewall that admits inbound packets only from an address and port to which an outbound packet has been sent (address- and port-dependent filtering, Section 5 of [RFC4787]). As expected, no direct path was established through a symmetric firewall that assigns a different port for each destination (endpoint-dependent mapping). The implementation has also been tested between network namespaces behind emulated NATs. Licensing: MIT Repository: https://github.com/seera-networks/msquic Contact: Masahiro Kozuka (kozuka@okayama-u.ac.jp) Appendix C. Open Issues | Note to RFC Editor: please remove this section before publication. Redundant punch packets: Should the server be allowed to send a small, fixed number of punch packets per request, spaced in time, to tolerate loss without keeping state beyond a timer? This trades a bounded increase in traffic for fewer re-requests. Multiple bases with the same advertised address: When candidates Kozuka Expires 18 May 2027 [Page 19] Internet-Draft QUIC Stateless Punch November 2026 with different sending bases share an advertised address (for example with overlapping address spaces, see Appendix B.2 of [RFC8445]), the server cannot tell from the address alone which base to use. Should the server send one punch packet from each such base, or should requests carry a disambiguator? Endpoint-dependent mapping: When a NAT uses endpoint-dependent mapping, the external port used for the punch packet differs from the advertised one. Port prediction techniques could be layered on top of this extension, at the cost of more NAT bindings. Delay selection: Is the smoothed RTT of the relayed path the right default, or should the client probe earlier and rely on PATH_CHALLENGE retransmission? Acknowledgments This document builds on the work of Marten Seemann and Eric Kinnear in [I-D.seemann-quic-nat-traversal]. The stateless approach was suggested by Christian Huitema in [ISSUE20]. Author's Address Masahiro Kozuka Okayama University Email: kozuka@okayama-u.ac.jp Kozuka Expires 18 May 2027 [Page 20]