<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE rfc [
  <!ENTITY nbsp    "&#160;">
  <!ENTITY zwsp   "&#8203;">
  <!ENTITY nbhy   "&#8209;">
  <!ENTITY wj     "&#8288;">
]>
<!-- name="GENERATOR" content="github.com/mmarkdown/mmark Mmark Markdown Processor - mmark.miek.nl" -->
<rfc xmlns:xi="http://www.w3.org/2001/XInclude" version="3" ipr="trust200902" docName="draft-kozuka-quic-stateless-punch-00" submissionType="IETF" category="std" xml:lang="en" indexInclude="true">

<front>
<title abbrev="QUIC Stateless Punch">Stateless Server-Assisted Hole Punching for QUIC</title><seriesInfo value="draft-kozuka-quic-stateless-punch-00" stream="IETF" status="standard" name="Internet-Draft"/>
<author initials="M." surname="Kozuka" fullname="Masahiro Kozuka"><organization>Okayama University</organization><address><postal><street/>
</postal><email>kozuka@okayama-u.ac.jp</email>
</address></author><date year="2026" month="November" day="14"/>
<area>Web and Internet Transport</area>
<workgroup>QUIC</workgroup>
<keyword>QUIC</keyword>
<keyword>NAT traversal</keyword>
<keyword>hole punching</keyword>
<keyword>connection migration</keyword>

<abstract>
<t>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.</t>
</abstract>

<note title="Discussion Venues" removeInRFC="true">
<t>Discussion of this document takes place on the
    QUIC Working Group mailing list (quic@ietf.org),
    which is archived at <eref target="https://mailarchive.ietf.org/arch/browse/quic/"/>.</t>
<t>Source for this draft and an issue tracker can be found at
    <eref target="https://github.com/masa-koz/draft-kozuka-quic-stateless-punch"/>.</t>
</note>
</front>

<middle>

<section anchor="introduction"><name>Introduction</name>
<t>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
<xref target="I-D.ietf-masque-connect-udp-listen"/>, or a proxy that pairs two
authenticated clients as defined in
<xref target="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
(<xref target="RFC9000" sectionFormat="of" section="9"/>); otherwise, the endpoints keep using the
relayed path.</t>
<t><xref target="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.</t>
<t>This document specifies a smaller alternative for the probing step,
based on a design suggested by Christian Huitema in the discussion of
that draft <xref target="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 <xref target="RFC9000"/> (or <xref target="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 (<xref target="migration"/>).</t>
<t>The design has the following properties:</t>

<ul spacing="compact">
<li>The server keeps no per-attempt state.</li>
<li>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.</li>
<li>No new type of connection ID is introduced, and no special handling
is needed when QUIC multipath is used.</li>
<li>Only one new frame is defined.</li>
</ul>
<t>The cost is additional latency: the client waits roughly one round-trip
time of the relayed path before sending its first probe.</t>
<t>Address candidates are advertised using the ALTERNATIVE_ADDRESS frame
defined in <xref target="I-D.munizaga-quic-alternative-server-address"/>, as in
<xref target="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.</t>
</section>

<section anchor="conventions-and-definitions"><name>Conventions and Definitions</name>
<t>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 <xref target="RFC2119"/> <xref target="RFC8174"/> when, and only when, they appear in all
capitals, as shown here.</t>
<t>This document uses the following terms:</t>

<dl spacing="compact">
<dt>Address candidate:</dt>
<dd>A transport address (IP address and UDP port) at which an endpoint
might be reachable, as in <xref target="RFC8445"/>.</dd>
<dt>Sending base:</dt>
<dd>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 <xref target="I-D.seemann-quic-nat-traversal"/>.</dd>
<dt>Punch request:</dt>
<dd>A PUNCH_ME_NOW frame (<xref target="frame"/>) sent by the client on a validated
path, asking the server to send a punch packet.</dd>
<dt>Punch packet:</dt>
<dd>A small, opaque UDP datagram that the server sends in response to a
punch request (<xref target="punch-packet"/>). Its purpose is to create a binding
in NATs and firewalls on the server side.</dd>
<dt>Attempt:</dt>
<dd>The sequence consisting of one punch request, the resulting punch
packet, and the client's subsequent path validation for one pair of
address candidates.</dd>
</dl>
</section>

<section anchor="overview"><name>Overview</name>
<t>The client and server first establish a QUIC connection over a relayed
path and negotiate this extension (<xref target="negotiation"/>). 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:</t>

<ol>
<li><t>The client sends a PUNCH_ME_NOW frame on the relayed path, naming
its own candidate (C) and the server candidate (S).</t>
</li>
<li><t>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.</t>
</li>
<li><t>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.</t>
</li>
<li><t>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 (<xref target="migration"/>).</t>
</li>
</ol>
<figure><name>An attempt in which both endpoints are behind NATs
</name>
<sourcecode type="ascii-art"><![CDATA[ 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 ----|
   |              |          |           |             |
]]>
</sourcecode>
</figure>
<t>This works when both NATs use endpoint-independent mapping
(<xref target="RFC4787" sectionFormat="of" section="4.1"/>), regardless of their filtering behavior.
NATs with endpoint-dependent mapping are discussed in <xref target="open-issues"/>.</t>
</section>

<section anchor="candidates"><name>Address Candidates</name>
<t>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
<xref target="RFC8445"/>, or they MAY use address candidates provided by the
application.</t>
<t>The server advertises its candidates using ALTERNATIVE_ADDRESS frames
<xref target="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 <xref target="RFC8445"/>). How the server chooses a sending base in
that case is an open issue (<xref target="open-issues"/>).</t>
<t>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
<xref target="RFC8445"/>.</t>
<t>The client pairs server candidates with its own candidates. Section 5.1
of <xref target="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.</t>
<t>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
<xref target="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.</t>
</section>

<section anchor="requests"><name>Punch Requests</name>
<t>To start an attempt, the client sends a PUNCH_ME_NOW frame
(<xref target="frame"/>) on a validated path. The frame contains the client
candidate and the server candidate of the pair.</t>
<t>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.</t>
<t>The server MUST ignore a PUNCH_ME_NOW frame received before the
handshake is confirmed (<xref target="RFC9001" sectionFormat="of" section="4.1.2"/>). Data received
before then, such as 0-RTT data, can be replayed by an attacker
(<xref target="RFC9001" sectionFormat="of" section="9.2"/>), 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 (<xref target="negotiation"/>).</t>
<t>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.</t>

<ul>
<li><t>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.</t>
</li>
<li><t>Otherwise, the server sends one punch packet (<xref target="punch-packet"/>) from
the sending base associated with the entry to the client address
and port in the frame, subject to the limits in <xref target="limits"/>.</t>
</li>
</ul>
<t>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.</t>
<t>A server MAY decline to send a punch packet for any reason, for example
because of the limits in <xref target="limits"/> or local policy about acceptable
client addresses. The client learns of this only because its path
validation fails.</t>

<section anchor="limits"><name>Limits</name>
<t>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
<xref target="requests"/>. Together with the size limit in <xref target="punch-packet"/>, 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.</t>
<t>A client SHOULD therefore send each PUNCH_ME_NOW frame, including a
retransmitted one, in a separate packet.</t>
<t>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 <xref target="requests"/>.</t>
<t>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.</t>
<t>Because the client chooses both the destination address and the
destination port, punch requests can be used for request forgery
(<xref target="RFC9000" sectionFormat="of" section="21.5"/>). 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 <xref target="RFC9000" sectionFormat="of" section="21.5.6"/>.</t>
</section>
</section>

<section anchor="punch-packet"><name>Punch Packets</name>
<t>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.</t>
<t>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 (<xref target="limits"/>). 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 (<xref target="validation"/>).</t>
<t>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 (<xref target="RFC9000" sectionFormat="of" section="9.5"/>) 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.</t>
<t>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
(<xref target="RFC9001" sectionFormat="of" section="5.4.2"/>): 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.</t>
<t>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 <xref target="RFC9000" sectionFormat="of" section="8.2.1"/>.</t>
<t>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
(<xref target="RFC10069" sectionFormat="of" section="2.4"/>). 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 (<xref target="RFC9000" sectionFormat="of" section="21.4"/>).</t>

<section anchor="receiving-a-punch-packet"><name>Receiving a Punch Packet</name>
<t>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 (<xref target="RFC9000" sectionFormat="of" section="5.2"/>): the packet is discarded.</t>
<t>A client that uses zero-length connection IDs associates packets with
connections by local address and port (<xref target="RFC9000" sectionFormat="of" section="5.2.1"/>), 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 (<xref target="RFC9001" sectionFormat="of" section="6.6"/>); this is
negligible, as the number of punch packets is small.</t>
<t>The client might respond with a Stateless Reset
(<xref target="RFC9000" sectionFormat="of" section="10.3"/>). This is harmless. Its size is bounded by
the rules in <xref target="RFC9000" sectionFormat="of" section="10.3"/>: it is normally smaller than the
punch packet (<xref target="RFC9000" sectionFormat="of" section="10.3.3"/>) 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.</t>
</section>
</section>

<section anchor="validation"><name>Client-Initiated Path Validation</name>
<t>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.</t>
<t>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 (<xref target="RFC9002" sectionFormat="of" section="5.3"/>) 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.</t>
<t>The client then validates the path from the base associated with the
client candidate to the server candidate.</t>

<ul>
<li><t>Without QUIC multipath, the client follows
<xref target="RFC9000" sectionFormat="of" section="8.2"/>, using a connection ID issued by the server
that has not been used on any other path.</t>
</li>
<li><t>With QUIC multipath <xref target="RFC10069"/>, the client opens a new path using
an unused Path ID, as for any other new path.</t>
</li>
</ul>
<t>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.</t>
<t>The client sends PATH_CHALLENGE frames, and handles validation timeout,
as described in <xref target="RFC9000" sectionFormat="of" section="8.2.4"/>. 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.</t>
<t>If validation fails, the client abandons the attempt:</t>

<ul>
<li><t>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.</t>
</li>
<li><t>With QUIC multipath, the client closes the path with PATH_ABANDON,
which also retires its connection IDs.</t>
</li>
</ul>
<t>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 <xref target="RFC9000" sectionFormat="of" section="9.5"/>.</t>
<t>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.</t>
<t>With QUIC multipath, a Path ID cannot be reused once its path has been
abandoned (<xref target="RFC10069" sectionFormat="of" section="3.4"/>), because the Path ID is part of
the nonce calculation (<xref target="RFC10069" sectionFormat="of" section="2.4"/>). 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
(<xref target="RFC10069" sectionFormat="of" section="3.2.1"/>). When this extension and QUIC multipath
are both in use, each endpoint SHOULD increase its maximum Path ID
using MAX_PATH_ID frames (<xref target="RFC10069" sectionFormat="of" section="4.6"/>) 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
<xref target="RFC10069" sectionFormat="of" section="3.2.1"/>: 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 (<xref target="RFC10069" sectionFormat="of" section="4.7"/>).</t>
</section>

<section anchor="migration"><name>Migration</name>
<t>Once a direct path has been validated, the client can migrate the
connection to it (<xref target="RFC9000" sectionFormat="of" section="9"/>) 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.</t>
<t>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
<xref target="RFC9000" sectionFormat="of" section="9.3"/>; 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
(<xref target="RFC9000" sectionFormat="of" section="8"/>), which can add up to one round trip of the
direct path before the server can send at full rate.</t>
<t>Because all new paths are initiated by the client, this extension does
not require the server to migrate the connection, consistent with
<xref target="RFC9000" sectionFormat="of" section="9"/>.</t>
</section>

<section anchor="negotiation"><name>Extension Negotiation</name>
<t>Endpoints advertise support for this extension by sending the
stateless_punch transport parameter (<xref target="RFC9000" sectionFormat="of" section="7.4"/>) 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.</t>
<t>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
<xref target="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.</t>
<t>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.</t>
</section>

<section anchor="frame"><name>PUNCH_ME_NOW Frame</name>
<figure><name>PUNCH_ME_NOW Frame Format
</name>
<artwork><![CDATA[PUNCH_ME_NOW Frame {
  Type (i) = 0x5eea90..0x5eea91,
  Client Address (32/128),
  Client Port (16),
  Server Address (32/128),
  Server Port (16),
}
]]>
</artwork>
</figure>
<t>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.</t>

<dl spacing="compact">
<dt>Client Address and Client Port:</dt>
<dd>The client's address candidate to which the server sends the punch
packet.</dd>
<dt>Server Address and Server Port:</dt>
<dd>The server candidate, which MUST be equal to an IPv4 or IPv6 entry
that the client received in an ALTERNATIVE_ADDRESS frame.</dd>
</dl>
<t>PUNCH_ME_NOW frames are ack-eliciting and are not probing frames
(<xref target="RFC9000" sectionFormat="of" section="9.1"/>); 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 <xref target="limits"/>.</t>
<t>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.</t>
</section>

<section anchor="security-considerations"><name>Security Considerations</name>
<t>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
<xref target="RFC9000" sectionFormat="of" section="21.5"/>. The following properties limit the
exposure:</t>

<ul>
<li><t>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 (<xref target="limits"/>). The
extension therefore provides no amplification, in either packets or
bytes, and unused allowance cannot be accumulated into a burst.</t>
</li>
<li><t>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 <xref target="limits"/> address this.</t>
</li>
<li><t>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
<xref target="RFC9000" sectionFormat="of" section="8"/>.</t>
</li>
</ul>
<t>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 (<xref target="limits"/>).</t>
<t>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
<xref target="RFC9000" sectionFormat="of" section="10.3"/>, and it is sent toward the server's own
sending base.</t>
<t>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
(<xref target="requests"/>).</t>
<t>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
(<xref target="RFC9000" sectionFormat="of" section="9.5"/>). 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.</t>
</section>

<section anchor="iana-considerations"><name>IANA Considerations</name>

<section anchor="quic-transport-parameter"><name>QUIC Transport Parameter</name>
<t>This document registers the following value in the "QUIC Transport
Parameters" registry maintained at
<eref target="https://www.iana.org/assignments/quic"/>.</t>

<dl spacing="compact">
<dt>Value:</dt>
<dd>0x5eea9e7a (provisional, to be assigned)</dd>
<dt>Parameter Name:</dt>
<dd>stateless_punch</dd>
<dt>Status:</dt>
<dd>provisional</dd>
<dt>Specification:</dt>
<dd>This document</dd>
</dl>
</section>

<section anchor="quic-frame-types"><name>QUIC Frame Types</name>
<t>This document registers the following values in the "QUIC Frame Types"
registry maintained at <eref target="https://www.iana.org/assignments/quic"/>.</t>
<table><name>Frame type registrations
</name>
<thead>
<tr>
<th align="left">Value</th>
<th align="left">Frame Name</th>
<th align="left">Status</th>
<th align="left">Specification</th>
</tr>
</thead>

<tbody>
<tr>
<td align="left">0x5eea90 - 0x5eea91</td>
<td align="left">PUNCH_ME_NOW</td>
<td align="left">provisional</td>
<td align="left">This document</td>
</tr>
</tbody>
</table></section>
</section>

</middle>

<back>
<references><name>References</name>
<references><name>Normative References</name>
<reference anchor="I-D.munizaga-quic-alternative-server-address" target="https://datatracker.ietf.org/doc/html/draft-munizaga-quic-alternative-server-address-02">
  <front>
    <title>QUIC Alternative Server Address Frames</title>
    <author fullname="M. Munizaga" initials="M." surname="Munizaga"/>
    <author fullname="M. Seemann" initials="M." surname="Seemann"/>
    <date year="2026" month="September" day="25"/>
  </front>
  <seriesInfo name="Internet-Draft" value="draft-munizaga-quic-alternative-server-address-02"/>
</reference>
<reference anchor="RFC10069" target="https://www.rfc-editor.org/info/rfc10069">
  <front>
    <title>Managing Multiple Paths for a QUIC Connection</title>
    <author fullname="Y. Liu" initials="Y." surname="Liu" role="editor"/>
    <author fullname="Y. Ma" initials="Y." surname="Ma"/>
    <author fullname="Q. De Coninck" initials="Q." surname="De Coninck" role="editor"/>
    <author fullname="O. Bonaventure" initials="O." surname="Bonaventure"/>
    <author fullname="C. Huitema" initials="C." surname="Huitema"/>
    <author fullname="M. Kühlewind" initials="M." surname="Kühlewind" role="editor"/>
    <date year="2026" month="November"/>
  </front>
  <seriesInfo name="RFC" value="10069"/>
  <seriesInfo name="DOI" value="10.17487/RFC10069"/>
</reference>
<reference anchor="RFC2119" target="https://www.rfc-editor.org/info/rfc2119">
  <front>
    <title>Key words for use in RFCs to Indicate Requirement Levels</title>
    <author fullname="S. Bradner" initials="S." surname="Bradner"/>
    <date year="1997" month="March"/>
  </front>
  <seriesInfo name="BCP" value="14"/>
  <seriesInfo name="RFC" value="2119"/>
  <seriesInfo name="DOI" value="10.17487/RFC2119"/>
</reference>
<reference anchor="RFC8174" target="https://www.rfc-editor.org/info/rfc8174">
  <front>
    <title>Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words</title>
    <author fullname="B. Leiba" initials="B." surname="Leiba"/>
    <date year="2017" month="May"/>
  </front>
  <seriesInfo name="BCP" value="14"/>
  <seriesInfo name="RFC" value="8174"/>
  <seriesInfo name="DOI" value="10.17487/RFC8174"/>
</reference>
<reference anchor="RFC8445" target="https://www.rfc-editor.org/info/rfc8445">
  <front>
    <title>Interactive Connectivity Establishment (ICE): A Protocol for Network Address Translator (NAT) Traversal</title>
    <author fullname="A. Keranen" initials="A." surname="Keranen"/>
    <author fullname="C. Holmberg" initials="C." surname="Holmberg"/>
    <author fullname="J. Rosenberg" initials="J." surname="Rosenberg"/>
    <date year="2018" month="July"/>
  </front>
  <seriesInfo name="RFC" value="8445"/>
  <seriesInfo name="DOI" value="10.17487/RFC8445"/>
</reference>
<reference anchor="RFC9000" target="https://www.rfc-editor.org/info/rfc9000">
  <front>
    <title>QUIC: A UDP-Based Multiplexed and Secure Transport</title>
    <author fullname="J. Iyengar" initials="J." surname="Iyengar" role="editor"/>
    <author fullname="M. Thomson" initials="M." surname="Thomson" role="editor"/>
    <date year="2021" month="May"/>
  </front>
  <seriesInfo name="RFC" value="9000"/>
  <seriesInfo name="DOI" value="10.17487/RFC9000"/>
</reference>
<reference anchor="RFC9001" target="https://www.rfc-editor.org/info/rfc9001">
  <front>
    <title>Using TLS to Secure QUIC</title>
    <author fullname="M. Thomson" initials="M." surname="Thomson" role="editor"/>
    <author fullname="S. Turner" initials="S." surname="Turner" role="editor"/>
    <date year="2021" month="May"/>
  </front>
  <seriesInfo name="RFC" value="9001"/>
  <seriesInfo name="DOI" value="10.17487/RFC9001"/>
</reference>
<reference anchor="RFC9002" target="https://www.rfc-editor.org/info/rfc9002">
  <front>
    <title>QUIC Loss Detection and Congestion Control</title>
    <author fullname="J. Iyengar" initials="J." surname="Iyengar" role="editor"/>
    <author fullname="I. Swett" initials="I." surname="Swett" role="editor"/>
    <date year="2021" month="May"/>
  </front>
  <seriesInfo name="RFC" value="9002"/>
  <seriesInfo name="DOI" value="10.17487/RFC9002"/>
</reference>
</references>
<references><name>Informative References</name>
<reference anchor="I-D.ietf-masque-connect-udp-listen" target="https://datatracker.ietf.org/doc/html/draft-ietf-masque-connect-udp-listen-16">
  <front>
    <title>Proxying Bound UDP in HTTP</title>
    <author fullname="David Schinazi" initials="D." surname="Schinazi"/>
    <author fullname="Abhi Singh" initials="A." surname="Singh"/>
    <date year="2026" month="August" day="24"/>
  </front>
  <seriesInfo name="Internet-Draft" value="draft-ietf-masque-connect-udp-listen-16"/>
</reference>
<reference anchor="I-D.seemann-masque-connect-udp-rendezvous" target="https://datatracker.ietf.org/doc/html/draft-seemann-masque-connect-udp-rendezvous-00">
  <front>
    <title>UDP Rendezvous over HTTP</title>
    <author fullname="M. Seemann" initials="M." surname="Seemann"/>
    <date year="2026" month="August" day="16"/>
  </front>
  <seriesInfo name="Internet-Draft" value="draft-seemann-masque-connect-udp-rendezvous-00"/>
</reference>
<reference anchor="I-D.seemann-quic-nat-traversal" target="https://datatracker.ietf.org/doc/html/draft-seemann-quic-nat-traversal-04">
  <front>
    <title>Using QUIC to traverse NATs</title>
    <author fullname="M. Seemann" initials="M." surname="Seemann"/>
    <author fullname="E. Kinnear" initials="E." surname="Kinnear"/>
    <date year="2026" month="November" day="2"/>
  </front>
  <seriesInfo name="Internet-Draft" value="draft-seemann-quic-nat-traversal-04"/>
</reference>
<reference anchor="ISSUE20" target="https://github.com/marten-seemann/draft-seemann-quic-nat-traversal/issues/20">
  <front>
    <title>consider allowing probe packets to be smaller than 1200 bytes</title>
    <author/>
    <date year="2023" month="October"/>
  </front>
  <refcontent>draft-seemann-quic-nat-traversal issue #20</refcontent>
</reference>
<reference anchor="RFC4787" target="https://www.rfc-editor.org/info/rfc4787">
  <front>
    <title>Network Address Translation (NAT) Behavioral Requirements for Unicast UDP</title>
    <author fullname="F. Audet" initials="F." surname="Audet" role="editor"/>
    <author fullname="C. Jennings" initials="C." surname="Jennings"/>
    <date year="2007" month="January"/>
  </front>
  <seriesInfo name="BCP" value="127"/>
  <seriesInfo name="RFC" value="4787"/>
  <seriesInfo name="DOI" value="10.17487/RFC4787"/>
</reference>
<reference anchor="RFC7942" target="https://www.rfc-editor.org/info/rfc7942">
  <front>
    <title>Improving Awareness of Running Code: The Implementation Status Section</title>
    <author fullname="Y. Sheffer" initials="Y." surname="Sheffer"/>
    <author fullname="A. Farrel" initials="A." surname="Farrel"/>
    <date year="2016" month="July"/>
  </front>
  <seriesInfo name="BCP" value="205"/>
  <seriesInfo name="RFC" value="7942"/>
  <seriesInfo name="DOI" value="10.17487/RFC7942"/>
</reference>
</references>
</references>

<section anchor="comparison"><name>Comparison with draft-seemann-quic-nat-traversal-04</name>
<t>This appendix explains how the design in this document relates to
<xref target="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.</t>
<table><name>Comparison of the two approaches
</name>
<thead>
<tr>
<th align="left">Aspect</th>
<th align="left">seemann-04</th>
<th align="left">This document</th>
</tr>
</thead>

<tbody>
<tr>
<td align="left">Server-initiated validation of candidate paths</td>
<td align="left">Yes</td>
<td align="left">No</td>
</tr>

<tr>
<td align="left">Server state per attempt</td>
<td align="left">Grant, two punching CIDs, status</td>
<td align="left">None</td>
</tr>

<tr>
<td align="left">Server packets before validation</td>
<td align="left">PATH_CHALLENGE probes, retransmitted until timeout</td>
<td align="left">One small punch packet</td>
</tr>

<tr>
<td align="left">New frames</td>
<td align="left">4 (PUNCH_GRANT, MAX_PUNCH_GRANTS, PUNCH_REQUEST, PUNCH_DONE)</td>
<td align="left">1 (PUNCH_ME_NOW)</td>
</tr>

<tr>
<td align="left">New connection ID type</td>
<td align="left">Punching connection IDs</td>
<td align="left">None</td>
</tr>

<tr>
<td align="left">Multipath special handling</td>
<td align="left">Reserved Path ID 0xffffffff</td>
<td align="left">None (ordinary path creation)</td>
</tr>

<tr>
<td align="left">Server candidate reference</td>
<td align="left">Advertisement sequence number and entry index</td>
<td align="left">Address and port</td>
</tr>

<tr>
<td align="left">Added latency</td>
<td align="left">None</td>
<td align="left">About one relayed smoothed RTT</td>
</tr>
</tbody>
</table><t>Several mechanisms in <xref target="I-D.seemann-quic-nat-traversal"/> follow from
the server taking part in path validation for each attempt:</t>

<ul>
<li><t>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 (<xref target="validation"/>).</t>
</li>
<li><t>PUNCH_DONE is needed so that both endpoints can release per-attempt
state. A stateless server has nothing to release.</t>
</li>
<li><t>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.</t>
</li>
<li><t>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.</t>
</li>
<li><t>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.</t>
</li>
<li><t>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.</t>
</li>
</ul>
<t>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
<xref target="open-issues"/>).</t>
</section>

<section anchor="implementation"><name>Implementation Status</name>
<blockquote><t>Note to RFC Editor: please remove this section before publication.</t>
</blockquote><t>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 <xref target="RFC7942"/>.</t>

<section anchor="seera-msquic"><name>SEERA MsQuic</name>

<dl spacing="compact">
<dt>Organization:</dt>
<dd>SEERA Networks</dd>
<dt>Description:</dt>
<dd>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.</dd>
<dt>Server behavior:</dt>
<dd>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.</dd>
<dt>Client behavior:</dt>
<dd>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.</dd>
<dt>Differences from this document:</dt>
<dd>None known. Where this document leaves a choice open, the server uses
the first matching sending base when several share an advertised
address (see <xref target="open-issues"/>).</dd>
<dt>Maturity:</dt>
<dd>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, <xref target="RFC4787" sectionFormat="of" section="5"/>). 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.</dd>
<dt>Licensing:</dt>
<dd>MIT</dd>
<dt>Repository:</dt>
<dd><eref target="https://github.com/seera-networks/msquic"/></dd>
<dt>Contact:</dt>
<dd>Masahiro Kozuka (kozuka@okayama-u.ac.jp)</dd>
</dl>
</section>
</section>

<section anchor="open-issues"><name>Open Issues</name>
<blockquote><t>Note to RFC Editor: please remove this section before publication.</t>
</blockquote>
<dl spacing="compact">
<dt>Redundant punch packets:</dt>
<dd>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.</dd>
<dt>Multiple bases with the same advertised address:</dt>
<dd>When candidates with different sending bases share an advertised
address (for example with overlapping address spaces, see Appendix B.2
of <xref target="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?</dd>
<dt>Endpoint-dependent mapping:</dt>
<dd>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.</dd>
<dt>Delay selection:</dt>
<dd>Is the smoothed RTT of the relayed path the right default, or should
the client probe earlier and rely on PATH_CHALLENGE retransmission?</dd>
</dl>
</section>

<section anchor="acknowledgments" numbered="false"><name>Acknowledgments</name>
<t>This document builds on the work of Marten Seemann and Eric Kinnear in
<xref target="I-D.seemann-quic-nat-traversal"/>. The stateless approach was suggested
by Christian Huitema in <xref target="ISSUE20"/>.</t>
</section>

</back>

</rfc>
