Internet-Draft QUIC Stateless Punch November 2026
Kozuka Expires 18 May 2027 [Page]
Workgroup:
QUIC
Internet-Draft:
draft-kozuka-quic-stateless-punch-00
Published:
Intended Status:
Standards Track
Expires:
Author:
M. Kozuka
Okayama University

Stateless Server-Assisted Hole Punching for QUIC

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."

This Internet-Draft will expire on 18 May 2027.

▲

Table of Contents

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 cost is additional latency: the client waits roughly one round-trip time of the relayed path before sending its first probe.

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.

  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.

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).

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.

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.

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.

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.

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.

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:

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 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.
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:

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.

Table 1: Frame type registrations
Value Frame Name Status Specification
0x5eea90 - 0x5eea91 PUNCH_ME_NOW provisional This document

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, , <https://datatracker.ietf.org/doc/html/draft-munizaga-quic-alternative-server-address-02>.
[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, , <https://www.rfc-editor.org/info/rfc10069>.
[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[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, , <https://www.rfc-editor.org/info/rfc8445>.
[RFC9000]
Iyengar, J., Ed. and M. Thomson, Ed., "QUIC: A UDP-Based Multiplexed and Secure Transport", RFC 9000, DOI 10.17487/RFC9000, , <https://www.rfc-editor.org/info/rfc9000>.
[RFC9001]
Thomson, M., Ed. and S. Turner, Ed., "Using TLS to Secure QUIC", RFC 9001, DOI 10.17487/RFC9001, , <https://www.rfc-editor.org/info/rfc9001>.
[RFC9002]
Iyengar, J., Ed. and I. Swett, Ed., "QUIC Loss Detection and Congestion Control", RFC 9002, DOI 10.17487/RFC9002, , <https://www.rfc-editor.org/info/rfc9002>.

13.2. Informative References

[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, , <https://datatracker.ietf.org/doc/html/draft-ietf-masque-connect-udp-listen-16>.
[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, , <https://datatracker.ietf.org/doc/html/draft-seemann-masque-connect-udp-rendezvous-00>.
[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, , <https://datatracker.ietf.org/doc/html/draft-seemann-quic-nat-traversal-04>.
[ISSUE20]
"consider allowing probe packets to be smaller than 1200 bytes", draft-seemann-quic-nat-traversal issue #20, , <https://github.com/marten-seemann/draft-seemann-quic-nat-traversal/issues/20>.
[RFC4787]
Audet, F., Ed. and C. Jennings, "Network Address Translation (NAT) Behavioral Requirements for Unicast UDP", BCP 127, RFC 4787, DOI 10.17487/RFC4787, , <https://www.rfc-editor.org/info/rfc4787>.
[RFC7942]
Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, DOI 10.17487/RFC7942, , <https://www.rfc-editor.org/info/rfc7942>.

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.

Table 2: Comparison of the two approaches
Aspect seemann-04 This document
Server-initiated validation of candidate paths Yes No
Server state per attempt Grant, two punching CIDs, status None
Server packets before validation PATH_CHALLENGE probes, retransmitted until timeout One small punch packet
New frames 4 (PUNCH_GRANT, MAX_PUNCH_GRANTS, PUNCH_REQUEST, PUNCH_DONE) 1 (PUNCH_ME_NOW)
New connection ID type Punching connection IDs None
Multipath special handling Reserved Path ID 0xffffffff None (ordinary path creation)
Server candidate reference Advertisement sequence number and entry index Address and port
Added latency None About one relayed smoothed RTT

Several mechanisms in [I-D.seemann-quic-nat-traversal] follow from the server taking part in path validation for each attempt:

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 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 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