@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/vendor/golang.org/x/net/quic/quic.go

@@ -0,0 +1,221 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quic
+
+import (
+	"time"
+)
+
+// QUIC versions.
+// We only support v1 at this time.
+const (
+	quicVersion1 = 1
+	quicVersion2 = 0x6b3343cf // https://www.rfc-editor.org/rfc/rfc9369
+)
+
+// connIDLen is the length in bytes of connection IDs chosen by this package.
+// Since 1-RTT packets don't include a connection ID length field,
+// we use a consistent length for all our IDs.
+// https://www.rfc-editor.org/rfc/rfc9000.html#section-5.1-6
+const connIDLen = 8
+
+// Local values of various transport parameters.
+// https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2
+const (
+	defaultMaxIdleTimeout = 30 * time.Second // max_idle_timeout
+
+	// The max_udp_payload_size transport parameter is the size of our
+	// network receive buffer.
+	//
+	// Set this to the largest UDP packet that can be sent over
+	// Ethernet without using jumbo frames: 1500 byte Ethernet frame,
+	// minus 20 byte IPv4 header and 8 byte UDP header.
+	//
+	// The maximum possible UDP payload is 65527 bytes. Supporting this
+	// without wasting memory in unused receive buffers will require some
+	// care. For now, just limit ourselves to the most common case.
+	maxUDPPayloadSize = 1472
+
+	ackDelayExponent = 3                     // ack_delay_exponent
+	maxAckDelay      = 25 * time.Millisecond // max_ack_delay
+
+	// The active_conn_id_limit transport parameter is the maximum
+	// number of connection IDs from the peer we're willing to store.
+	//
+	// maxPeerActiveConnIDLimit is the maximum number of connection IDs
+	// we're willing to send to the peer.
+	//
+	// https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-6.2.1
+	activeConnIDLimit        = 2
+	maxPeerActiveConnIDLimit = 4
+)
+
+// Time limit for completing the handshake.
+const defaultHandshakeTimeout = 10 * time.Second
+
+// Keep-alive ping frequency.
+const defaultKeepAlivePeriod = 0
+
+// Local timer granularity.
+// https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.2-6
+const timerGranularity = 1 * time.Millisecond
+
+// The smallest allowed maximum datagram size.
+// https://www.rfc-editor.org/rfc/rfc9000#section-14
+const smallestMaxDatagramSize = 1200
+
+// Minimum size of a UDP datagram sent by a client carrying an Initial packet,
+// or a server containing an ack-eliciting Initial packet.
+// https://www.rfc-editor.org/rfc/rfc9000#section-14.1
+const paddedInitialDatagramSize = smallestMaxDatagramSize
+
+// Maximum number of streams of a given type which may be created.
+// https://www.rfc-editor.org/rfc/rfc9000.html#section-4.6-2
+const maxStreamsLimit = 1 << 60
+
+// Maximum number of streams we will allow the peer to create implicitly.
+// A stream ID that is used out of order results in all streams of that type
+// with lower-numbered IDs also being opened. To limit the amount of work we
+// will do in response to a single frame, we cap the peer's stream limit to
+// this value.
+const implicitStreamLimit = 100
+
+// A connSide distinguishes between the client and server sides of a connection.
+type connSide int8
+
+const (
+	clientSide = connSide(iota)
+	serverSide
+)
+
+func (s connSide) String() string {
+	switch s {
+	case clientSide:
+		return "client"
+	case serverSide:
+		return "server"
+	default:
+		return "BUG"
+	}
+}
+
+func (s connSide) peer() connSide {
+	if s == clientSide {
+		return serverSide
+	} else {
+		return clientSide
+	}
+}
+
+// A numberSpace is the context in which a packet number applies.
+// https://www.rfc-editor.org/rfc/rfc9000.html#section-12.3-7
+type numberSpace byte
+
+const (
+	initialSpace = numberSpace(iota)
+	handshakeSpace
+	appDataSpace
+	numberSpaceCount
+)
+
+func (n numberSpace) String() string {
+	switch n {
+	case initialSpace:
+		return "Initial"
+	case handshakeSpace:
+		return "Handshake"
+	case appDataSpace:
+		return "AppData"
+	default:
+		return "BUG"
+	}
+}
+
+// A streamType is the type of a stream: bidirectional or unidirectional.
+type streamType uint8
+
+const (
+	bidiStream = streamType(iota)
+	uniStream
+	streamTypeCount
+)
+
+func (s streamType) qlogString() string {
+	switch s {
+	case bidiStream:
+		return "bidirectional"
+	case uniStream:
+		return "unidirectional"
+	default:
+		return "BUG"
+	}
+}
+
+func (s streamType) String() string {
+	switch s {
+	case bidiStream:
+		return "bidi"
+	case uniStream:
+		return "uni"
+	default:
+		return "BUG"
+	}
+}
+
+// A streamID is a QUIC stream ID.
+// https://www.rfc-editor.org/rfc/rfc9000.html#section-2.1
+type streamID uint64
+
+// The two least significant bits of a stream ID indicate the initiator
+// and directionality of the stream. The upper bits are the stream number.
+// Each of the four possible combinations of initiator and direction
+// each has a distinct number space.
+const (
+	clientInitiatedStreamBit = 0x0
+	serverInitiatedStreamBit = 0x1
+	initiatorStreamBitMask   = 0x1
+
+	bidiStreamBit    = 0x0
+	uniStreamBit     = 0x2
+	dirStreamBitMask = 0x2
+)
+
+func newStreamID(initiator connSide, typ streamType, num int64) streamID {
+	id := streamID(num << 2)
+	if typ == uniStream {
+		id |= uniStreamBit
+	}
+	if initiator == serverSide {
+		id |= serverInitiatedStreamBit
+	}
+	return id
+}
+
+func (s streamID) initiator() connSide {
+	if s&initiatorStreamBitMask == serverInitiatedStreamBit {
+		return serverSide
+	}
+	return clientSide
+}
+
+func (s streamID) num() int64 {
+	return int64(s) >> 2
+}
+
+func (s streamID) streamType() streamType {
+	if s&dirStreamBitMask == uniStreamBit {
+		return uniStream
+	}
+	return bidiStream
+}
+
+// packetFate is the fate of a sent packet: Either acknowledged by the peer,
+// or declared lost.
+type packetFate byte
+
+const (
+	packetLost = packetFate(iota)
+	packetAcked
+)

package/bin/go/src/vendor/golang.org/x/net/quic/race_disabled.go

@@ -0,0 +1,10 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !race
+
+package quic
+
+func raceAcquire()      {}
+func raceReleaseMerge() {}

package/bin/go/src/vendor/golang.org/x/net/quic/race_enabled.go

@@ -0,0 +1,27 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build race
+
+package quic
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+// Our synchronization here is rather coarse-grained since we always use the
+// address of quicSync. As such, it will not differentiate between, for
+// example, reads and writes to different QUIC streams.
+// However, this is consistent with our synchronization for net/http, and
+// mostly only matters for testing.
+var quicSync uint64
+
+func raceAcquire() {
+	runtime.RaceAcquire(unsafe.Pointer(&quicSync))
+}
+
+func raceReleaseMerge() {
+	runtime.RaceReleaseMerge(unsafe.Pointer(&quicSync))
+}

package/bin/go/src/vendor/golang.org/x/net/quic/rangeset.go

@@ -0,0 +1,193 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quic
+
+// A rangeset is a set of int64s, stored as an ordered list of non-overlapping,
+// non-empty ranges.
+//
+// Rangesets are efficient for small numbers of ranges,
+// which is expected to be the common case.
+type rangeset[T ~int64] []i64range[T]
+
+type i64range[T ~int64] struct {
+	start, end T // [start, end)
+}
+
+// size returns the size of the range.
+func (r i64range[T]) size() T {
+	return r.end - r.start
+}
+
+// contains reports whether v is in the range.
+func (r i64range[T]) contains(v T) bool {
+	return r.start <= v && v < r.end
+}
+
+// add adds [start, end) to the set, combining it with existing ranges if necessary.
+func (s *rangeset[T]) add(start, end T) {
+	if start == end {
+		return
+	}
+	for i := range *s {
+		r := &(*s)[i]
+		if r.start > end {
+			// The new range comes before range i.
+			s.insertrange(i, start, end)
+			return
+		}
+		if start > r.end {
+			// The new range comes after range i.
+			continue
+		}
+		// The new range is adjacent to or overlapping range i.
+		if start < r.start {
+			r.start = start
+		}
+		if end <= r.end {
+			return
+		}
+		// Possibly coalesce subsequent ranges into range i.
+		r.end = end
+		j := i + 1
+		for ; j < len(*s) && r.end >= (*s)[j].start; j++ {
+			if e := (*s)[j].end; e > r.end {
+				// Range j ends after the new range.
+				r.end = e
+			}
+		}
+		s.removeranges(i+1, j)
+		return
+	}
+	*s = append(*s, i64range[T]{start, end})
+}
+
+// sub removes [start, end) from the set.
+func (s *rangeset[T]) sub(start, end T) {
+	removefrom, removeto := -1, -1
+	for i := range *s {
+		r := &(*s)[i]
+		if end < r.start {
+			break
+		}
+		if r.end < start {
+			continue
+		}
+		switch {
+		case start <= r.start && end >= r.end:
+			// Remove the entire range.
+			if removefrom == -1 {
+				removefrom = i
+			}
+			removeto = i + 1
+		case start <= r.start:
+			// Remove a prefix.
+			r.start = end
+		case end >= r.end:
+			// Remove a suffix.
+			r.end = start
+		default:
+			// Remove the middle, leaving two new ranges.
+			rend := r.end
+			r.end = start
+			s.insertrange(i+1, end, rend)
+			return
+		}
+	}
+	if removefrom != -1 {
+		s.removeranges(removefrom, removeto)
+	}
+}
+
+// contains reports whether s contains v.
+func (s rangeset[T]) contains(v T) bool {
+	for _, r := range s {
+		if v >= r.end {
+			continue
+		}
+		if r.start <= v {
+			return true
+		}
+		return false
+	}
+	return false
+}
+
+// rangeContaining returns the range containing v, or the range [0,0) if v is not in s.
+func (s rangeset[T]) rangeContaining(v T) i64range[T] {
+	for _, r := range s {
+		if v >= r.end {
+			continue
+		}
+		if r.start <= v {
+			return r
+		}
+		break
+	}
+	return i64range[T]{0, 0}
+}
+
+// min returns the minimum value in the set, or 0 if empty.
+func (s rangeset[T]) min() T {
+	if len(s) == 0 {
+		return 0
+	}
+	return s[0].start
+}
+
+// max returns the maximum value in the set, or 0 if empty.
+func (s rangeset[T]) max() T {
+	if len(s) == 0 {
+		return 0
+	}
+	return s[len(s)-1].end - 1
+}
+
+// end returns the end of the last range in the set, or 0 if empty.
+func (s rangeset[T]) end() T {
+	if len(s) == 0 {
+		return 0
+	}
+	return s[len(s)-1].end
+}
+
+// numRanges returns the number of ranges in the rangeset.
+func (s rangeset[T]) numRanges() int {
+	return len(s)
+}
+
+// size returns the size of all ranges in the rangeset.
+func (s rangeset[T]) size() (total T) {
+	for _, r := range s {
+		total += r.size()
+	}
+	return total
+}
+
+// isrange reports if the rangeset covers exactly the range [start, end).
+func (s rangeset[T]) isrange(start, end T) bool {
+	switch len(s) {
+	case 0:
+		return start == 0 && end == 0
+	case 1:
+		return s[0].start == start && s[0].end == end
+	}
+	return false
+}
+
+// removeranges removes ranges [i,j).
+func (s *rangeset[T]) removeranges(i, j int) {
+	if i == j {
+		return
+	}
+	copy((*s)[i:], (*s)[j:])
+	*s = (*s)[:len(*s)-(j-i)]
+}
+
+// insert adds a new range at index i.
+func (s *rangeset[T]) insertrange(i int, start, end T) {
+	*s = append(*s, i64range[T]{})
+	copy((*s)[i+1:], (*s)[i:])
+	(*s)[i] = i64range[T]{start, end}
+}

package/bin/go/src/vendor/golang.org/x/net/quic/retry.go

@@ -0,0 +1,240 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quic
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/binary"
+	"net/netip"
+	"time"
+
+	"golang.org/x/crypto/chacha20poly1305"
+	"golang.org/x/net/internal/quic/quicwire"
+)
+
+// AEAD and nonce used to compute the Retry Integrity Tag.
+// https://www.rfc-editor.org/rfc/rfc9001#section-5.8
+var (
+	retrySecret = []byte{0xbe, 0x0c, 0x69, 0x0b, 0x9f, 0x66, 0x57, 0x5a, 0x1d, 0x76, 0x6b, 0x54, 0xe3, 0x68, 0xc8, 0x4e}
+	retryNonce  = []byte{0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2, 0x23, 0x98, 0x25, 0xbb}
+	retryAEAD   = func() cipher.AEAD {
+		c, err := aes.NewCipher(retrySecret)
+		if err != nil {
+			panic(err)
+		}
+		aead, err := cipher.NewGCM(c)
+		if err != nil {
+			panic(err)
+		}
+		return aead
+	}()
+)
+
+// retryTokenValidityPeriod is how long we accept a Retry packet token after sending it.
+const retryTokenValidityPeriod = 5 * time.Second
+
+// retryState generates and validates an endpoint's retry tokens.
+type retryState struct {
+	aead cipher.AEAD
+}
+
+func (rs *retryState) init() error {
+	// Retry tokens are authenticated using a per-server key chosen at start time.
+	// TODO: Provide a way for the user to set this key.
+	secret := make([]byte, chacha20poly1305.KeySize)
+	if _, err := rand.Read(secret); err != nil {
+		return err
+	}
+	aead, err := chacha20poly1305.NewX(secret)
+	if err != nil {
+		panic(err)
+	}
+	rs.aead = aead
+	return nil
+}
+
+// Retry tokens are encrypted with an AEAD.
+// The plaintext contains the time the token was created and
+// the original destination connection ID.
+// The additional data contains the sender's source address and original source connection ID.
+// The token nonce is randomly generated.
+// We use the nonce as the Source Connection ID of the Retry packet.
+// Since the 24-byte XChaCha20-Poly1305 nonce is too large to fit in a 20-byte connection ID,
+// we include the remaining 4 bytes of nonce in the token.
+//
+// Token {
+//   Last 4 Bytes of Nonce (32),
+//   Ciphertext (..),
+// }
+//
+// Plaintext {
+//   Timestamp (64),
+//   Original Destination Connection ID,
+// }
+//
+//
+// Additional Data {
+//   Original Source Connection ID Length (8),
+//   Original Source Connection ID (..),
+//   IP Address (32..128),
+//   Port (16),
+// }
+//
+// TODO: Consider using AES-256-GCM-SIV once crypto/tls supports it.
+
+func (rs *retryState) makeToken(now time.Time, srcConnID, origDstConnID []byte, addr netip.AddrPort) (token, newDstConnID []byte, err error) {
+	nonce := make([]byte, rs.aead.NonceSize())
+	if _, err := rand.Read(nonce); err != nil {
+		return nil, nil, err
+	}
+
+	var plaintext []byte
+	plaintext = binary.BigEndian.AppendUint64(plaintext, uint64(now.Unix()))
+	plaintext = append(plaintext, origDstConnID...)
+
+	token = append(token, nonce[maxConnIDLen:]...)
+	token = rs.aead.Seal(token, nonce, plaintext, rs.additionalData(srcConnID, addr))
+	return token, nonce[:maxConnIDLen], nil
+}
+
+func (rs *retryState) validateToken(now time.Time, token, srcConnID, dstConnID []byte, addr netip.AddrPort) (origDstConnID []byte, ok bool) {
+	tokenNonceLen := rs.aead.NonceSize() - maxConnIDLen
+	if len(token) < tokenNonceLen {
+		return nil, false
+	}
+	nonce := append([]byte{}, dstConnID...)
+	nonce = append(nonce, token[:tokenNonceLen]...)
+	ciphertext := token[tokenNonceLen:]
+	if len(nonce) != rs.aead.NonceSize() {
+		return nil, false
+	}
+
+	plaintext, err := rs.aead.Open(nil, nonce, ciphertext, rs.additionalData(srcConnID, addr))
+	if err != nil {
+		return nil, false
+	}
+	if len(plaintext) < 8 {
+		return nil, false
+	}
+	when := time.Unix(int64(binary.BigEndian.Uint64(plaintext)), 0)
+	origDstConnID = plaintext[8:]
+
+	// We allow for tokens created in the future (up to the validity period),
+	// which likely indicates that the system clock was adjusted backwards.
+	if d := abs(now.Sub(when)); d > retryTokenValidityPeriod {
+		return nil, false
+	}
+
+	return origDstConnID, true
+}
+
+func (rs *retryState) additionalData(srcConnID []byte, addr netip.AddrPort) []byte {
+	var additional []byte
+	additional = quicwire.AppendUint8Bytes(additional, srcConnID)
+	additional = append(additional, addr.Addr().AsSlice()...)
+	additional = binary.BigEndian.AppendUint16(additional, addr.Port())
+	return additional
+}
+
+func (e *Endpoint) validateInitialAddress(now time.Time, p genericLongPacket, peerAddr netip.AddrPort) (origDstConnID []byte, ok bool) {
+	// The retry token is at the start of an Initial packet's data.
+	token, n := quicwire.ConsumeUint8Bytes(p.data)
+	if n < 0 {
+		// We've already validated that the packet is at least 1200 bytes long,
+		// so there's no way for even a maximum size token to not fit.
+		// Check anyway.
+		return nil, false
+	}
+	if len(token) == 0 {
+		// The sender has not provided a token.
+		// Send a Retry packet to them with one.
+		e.sendRetry(now, p, peerAddr)
+		return nil, false
+	}
+	origDstConnID, ok = e.retry.validateToken(now, token, p.srcConnID, p.dstConnID, peerAddr)
+	if !ok {
+		// This does not seem to be a valid token.
+		// Close the connection with an INVALID_TOKEN error.
+		// https://www.rfc-editor.org/rfc/rfc9000#section-8.1.2-5
+		e.sendConnectionClose(p, peerAddr, errInvalidToken)
+		return nil, false
+	}
+	return origDstConnID, true
+}
+
+func (e *Endpoint) sendRetry(now time.Time, p genericLongPacket, peerAddr netip.AddrPort) {
+	token, srcConnID, err := e.retry.makeToken(now, p.srcConnID, p.dstConnID, peerAddr)
+	if err != nil {
+		return
+	}
+	b := encodeRetryPacket(p.dstConnID, retryPacket{
+		dstConnID: p.srcConnID,
+		srcConnID: srcConnID,
+		token:     token,
+	})
+	e.sendDatagram(datagram{
+		b:        b,
+		peerAddr: peerAddr,
+	})
+}
+
+type retryPacket struct {
+	dstConnID []byte
+	srcConnID []byte
+	token     []byte
+}
+
+func encodeRetryPacket(originalDstConnID []byte, p retryPacket) []byte {
+	// Retry packets include an integrity tag, computed by AEAD_AES_128_GCM over
+	// the original destination connection ID followed by the Retry packet
+	// (less the integrity tag itself).
+	// https://www.rfc-editor.org/rfc/rfc9001#section-5.8
+	//
+	// Create the pseudo-packet (including the original DCID), append the tag,
+	// and return the Retry packet.
+	var b []byte
+	b = quicwire.AppendUint8Bytes(b, originalDstConnID) // Original Destination Connection ID
+	start := len(b)                                     // start of the Retry packet
+	b = append(b, headerFormLong|fixedBit|longPacketTypeRetry)
+	b = binary.BigEndian.AppendUint32(b, quicVersion1) // Version
+	b = quicwire.AppendUint8Bytes(b, p.dstConnID)      // Destination Connection ID
+	b = quicwire.AppendUint8Bytes(b, p.srcConnID)      // Source Connection ID
+	b = append(b, p.token...)                          // Token
+	b = retryAEAD.Seal(b, retryNonce, nil, b)          // Retry Integrity Tag
+	return b[start:]
+}
+
+func parseRetryPacket(b, origDstConnID []byte) (p retryPacket, ok bool) {
+	const retryIntegrityTagLength = 128 / 8
+
+	lp, ok := parseGenericLongHeaderPacket(b)
+	if !ok {
+		return retryPacket{}, false
+	}
+	if len(lp.data) < retryIntegrityTagLength {
+		return retryPacket{}, false
+	}
+	gotTag := lp.data[len(lp.data)-retryIntegrityTagLength:]
+
+	// Create the pseudo-packet consisting of the original destination connection ID
+	// followed by the Retry packet (less the integrity tag).
+	// Use this to validate the packet integrity tag.
+	pseudo := quicwire.AppendUint8Bytes(nil, origDstConnID)
+	pseudo = append(pseudo, b[:len(b)-retryIntegrityTagLength]...)
+	wantTag := retryAEAD.Seal(nil, retryNonce, nil, pseudo)
+	if !bytes.Equal(gotTag, wantTag) {
+		return retryPacket{}, false
+	}
+
+	token := lp.data[:len(lp.data)-retryIntegrityTagLength]
+	return retryPacket{
+		dstConnID: lp.dstConnID,
+		srcConnID: lp.srcConnID,
+		token:     token,
+	}, true
+}