@ttsc/win32-arm64 0.33.1 → 0.34.0

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

@@ -0,0 +1,71 @@
+// 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"
+)
+
+type rttState struct {
+	minRTT          time.Duration
+	latestRTT       time.Duration
+	smoothedRTT     time.Duration
+	rttvar          time.Duration // RTT variation
+	firstSampleTime time.Time     // time of first RTT sample
+}
+
+func (r *rttState) init() {
+	r.minRTT = -1 // -1 indicates the first sample has not been taken yet
+
+	// "[...] the initial RTT SHOULD be set to 333 milliseconds."
+	// https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2-1
+	const initialRTT = 333 * time.Millisecond
+
+	// https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-12
+	r.smoothedRTT = initialRTT
+	r.rttvar = initialRTT / 2
+}
+
+func (r *rttState) establishPersistentCongestion() {
+	// "Endpoints SHOULD set the min_rtt to the newest RTT sample
+	// after persistent congestion is established."
+	// https://www.rfc-editor.org/rfc/rfc9002#section-5.2-5
+	r.minRTT = r.latestRTT
+}
+
+// updateSample is called when we generate a new RTT sample.
+// https://www.rfc-editor.org/rfc/rfc9002.html#section-5
+func (r *rttState) updateSample(now time.Time, handshakeConfirmed bool, spaceID numberSpace, latestRTT, ackDelay, maxAckDelay time.Duration) {
+	r.latestRTT = latestRTT
+
+	if r.minRTT < 0 {
+		// First RTT sample.
+		// "min_rtt MUST be set to the latest_rtt on the first RTT sample."
+		// https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-2
+		r.minRTT = latestRTT
+		// https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-14
+		r.smoothedRTT = latestRTT
+		r.rttvar = latestRTT / 2
+		r.firstSampleTime = now
+		return
+	}
+
+	// "min_rtt MUST be set to the lesser of min_rtt and latest_rtt [...]
+	// on all other samples."
+	// https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-2
+	r.minRTT = min(r.minRTT, latestRTT)
+
+	// https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-16
+	if handshakeConfirmed {
+		ackDelay = min(ackDelay, maxAckDelay)
+	}
+	adjustedRTT := latestRTT - ackDelay
+	if adjustedRTT < r.minRTT {
+		adjustedRTT = latestRTT
+	}
+	rttvarSample := abs(r.smoothedRTT - adjustedRTT)
+	r.rttvar = (3*r.rttvar + rttvarSample) / 4
+	r.smoothedRTT = ((7 * r.smoothedRTT) + adjustedRTT) / 8
+}

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

@@ -0,0 +1,119 @@
+// 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 (
+	"sync"
+	"time"
+
+	"golang.org/x/net/internal/quic/quicwire"
+)
+
+// A sentPacket tracks state related to an in-flight packet we sent,
+// to be committed when the peer acks it or resent if the packet is lost.
+type sentPacket struct {
+	num   packetNumber
+	size  int       // size in bytes
+	time  time.Time // time sent
+	ptype packetType
+
+	state        sentPacketState
+	ackEliciting bool // https://www.rfc-editor.org/rfc/rfc9002.html#section-2-3.4.1
+	inFlight     bool // https://www.rfc-editor.org/rfc/rfc9002.html#section-2-3.6.1
+
+	// Frames sent in the packet.
+	//
+	// This is an abbreviated version of the packet payload, containing only the information
+	// we need to process an ack for or loss of this packet.
+	// For example, a CRYPTO frame is recorded as the frame type (0x06), offset, and length,
+	// but does not include the sent data.
+	//
+	// This buffer is written by packetWriter.append* and read by Conn.handleAckOrLoss.
+	b []byte
+	n int // read offset into b
+}
+
+type sentPacketState uint8
+
+const (
+	sentPacketSent   = sentPacketState(iota) // sent but neither acked nor lost
+	sentPacketAcked                          // acked
+	sentPacketLost                           // declared lost
+	sentPacketUnsent                         // never sent
+)
+
+var sentPool = sync.Pool{
+	New: func() any {
+		return &sentPacket{}
+	},
+}
+
+func newSentPacket() *sentPacket {
+	sent := sentPool.Get().(*sentPacket)
+	sent.reset()
+	return sent
+}
+
+// recycle returns a sentPacket to the pool.
+func (sent *sentPacket) recycle() {
+	sentPool.Put(sent)
+}
+
+func (sent *sentPacket) reset() {
+	*sent = sentPacket{
+		b: sent.b[:0],
+	}
+}
+
+// markAckEliciting marks the packet as containing an ack-eliciting frame.
+func (sent *sentPacket) markAckEliciting() {
+	sent.ackEliciting = true
+	sent.inFlight = true
+}
+
+// The append* methods record information about frames in the packet.
+
+func (sent *sentPacket) appendNonAckElicitingFrame(frameType byte) {
+	sent.b = append(sent.b, frameType)
+}
+
+func (sent *sentPacket) appendAckElicitingFrame(frameType byte) {
+	sent.ackEliciting = true
+	sent.inFlight = true
+	sent.b = append(sent.b, frameType)
+}
+
+func (sent *sentPacket) appendInt(v uint64) {
+	sent.b = quicwire.AppendVarint(sent.b, v)
+}
+
+func (sent *sentPacket) appendOffAndSize(start int64, size int) {
+	sent.b = quicwire.AppendVarint(sent.b, uint64(start))
+	sent.b = quicwire.AppendVarint(sent.b, uint64(size))
+}
+
+// The next* methods read back information about frames in the packet.
+
+func (sent *sentPacket) next() (frameType byte) {
+	f := sent.b[sent.n]
+	sent.n++
+	return f
+}
+
+func (sent *sentPacket) nextInt() uint64 {
+	v, n := quicwire.ConsumeVarint(sent.b[sent.n:])
+	sent.n += n
+	return v
+}
+
+func (sent *sentPacket) nextRange() (start, end int64) {
+	start = int64(sent.nextInt())
+	end = start + int64(sent.nextInt())
+	return start, end
+}
+
+func (sent *sentPacket) done() bool {
+	return sent.n == len(sent.b)
+}

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

@@ -0,0 +1,93 @@
+// 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 sentPacketList is a ring buffer of sentPackets.
+//
+// Processing an ack for a packet causes all older packets past a small threshold
+// to be discarded (RFC 9002, Section 6.1.1), so the list of in-flight packets is
+// not sparse and will contain at most a few acked/lost packets we no longer
+// care about.
+type sentPacketList struct {
+	nextNum packetNumber // next packet number to add to the buffer
+	off     int          // offset of first packet in the buffer
+	size    int          // number of packets
+	p       []*sentPacket
+}
+
+// start is the first packet in the list.
+func (s *sentPacketList) start() packetNumber {
+	return s.nextNum - packetNumber(s.size)
+}
+
+// end is one after the last packet in the list.
+// If the list is empty, start == end.
+func (s *sentPacketList) end() packetNumber {
+	return s.nextNum
+}
+
+// discard clears the list.
+func (s *sentPacketList) discard() {
+	*s = sentPacketList{}
+}
+
+// add appends a packet to the list.
+func (s *sentPacketList) add(sent *sentPacket) {
+	if s.nextNum != sent.num {
+		panic("inserting out-of-order packet")
+	}
+	s.nextNum++
+	if s.size >= len(s.p) {
+		s.grow()
+	}
+	i := (s.off + s.size) % len(s.p)
+	s.size++
+	s.p[i] = sent
+}
+
+// nth returns a packet by index.
+func (s *sentPacketList) nth(n int) *sentPacket {
+	index := (s.off + n) % len(s.p)
+	return s.p[index]
+}
+
+// num returns a packet by number.
+// It returns nil if the packet is not in the list.
+func (s *sentPacketList) num(num packetNumber) *sentPacket {
+	i := int(num - s.start())
+	if i < 0 || i >= s.size {
+		return nil
+	}
+	return s.nth(i)
+}
+
+// clean removes all acked or lost packets from the head of the list.
+func (s *sentPacketList) clean() {
+	for s.size > 0 {
+		sent := s.p[s.off]
+		if sent.state == sentPacketSent {
+			return
+		}
+		sent.recycle()
+		s.p[s.off] = nil
+		s.off = (s.off + 1) % len(s.p)
+		s.size--
+	}
+	s.off = 0
+}
+
+// grow increases the buffer to hold more packaets.
+func (s *sentPacketList) grow() {
+	newSize := len(s.p) * 2
+	if newSize == 0 {
+		newSize = 64
+	}
+	p := make([]*sentPacket, newSize)
+	for i := 0; i < s.size; i++ {
+		p[i] = s.nth(i)
+	}
+	s.p = p
+	s.off = 0
+}

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

@@ -0,0 +1,103 @@
+// 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 sentVal tracks sending some piece of information to the peer.
+// It tracks whether the information has been sent, acked, and
+// (when in-flight) the most recent packet to carry it.
+//
+// For example, a sentVal can track sending of a RESET_STREAM frame.
+//
+//   - unset: stream is active, no need to send RESET_STREAM
+//   - unsent: we should send a RESET_STREAM, but have not yet
+//   - sent: we have sent a RESET_STREAM, but have not received an ack
+//   - received: we have sent a RESET_STREAM, and the peer has acked the packet that contained it
+//
+// In the "sent" state, a sentVal also tracks the latest packet number to carry
+// the information. (QUIC packet numbers are always at most 62 bits in size,
+// so the sentVal keeps the number in the low 62 bits and the state in the high 2 bits.)
+type sentVal uint64
+
+const (
+	sentValUnset    = 0       // unset
+	sentValUnsent   = 1 << 62 // set, not sent to the peer
+	sentValSent     = 2 << 62 // set, sent to the peer but not yet acked; pnum is set
+	sentValReceived = 3 << 62 // set, peer acked receipt
+
+	sentValStateMask = 3 << 62
+)
+
+// isSet reports whether the value is set.
+func (s sentVal) isSet() bool { return s != 0 }
+
+// shouldSend reports whether the value is set and has not been sent to the peer.
+func (s sentVal) shouldSend() bool { return s.state() == sentValUnsent }
+
+// shouldSendPTO reports whether the value needs to be sent to the peer.
+// The value needs to be sent if it is set and has not been sent.
+// If pto is true, indicating that we are sending a PTO probe, the value
+// should also be sent if it is set and has not been acknowledged.
+func (s sentVal) shouldSendPTO(pto bool) bool {
+	st := s.state()
+	return st == sentValUnsent || (pto && st == sentValSent)
+}
+
+// isReceived reports whether the value has been received by the peer.
+func (s sentVal) isReceived() bool { return s == sentValReceived }
+
+// set sets the value and records that it should be sent to the peer.
+// If the value has already been sent, it is not resent.
+func (s *sentVal) set() {
+	if *s == 0 {
+		*s = sentValUnsent
+	}
+}
+
+// reset sets the value to the unsent state.
+func (s *sentVal) setUnsent() { *s = sentValUnsent }
+
+// clear sets the value to the unset state.
+func (s *sentVal) clear() { *s = sentValUnset }
+
+// setSent sets the value to the send state and records the number of the most recent
+// packet containing the value.
+func (s *sentVal) setSent(pnum packetNumber) {
+	*s = sentValSent | sentVal(pnum)
+}
+
+// setReceived sets the value to the received state.
+func (s *sentVal) setReceived() { *s = sentValReceived }
+
+// ackOrLoss reports that an acknowledgement has been received for the value,
+// or that the packet carrying the value has been lost.
+func (s *sentVal) ackOrLoss(pnum packetNumber, fate packetFate) {
+	if fate == packetAcked {
+		*s = sentValReceived
+	} else if *s == sentVal(pnum)|sentValSent {
+		*s = sentValUnsent
+	}
+}
+
+// ackLatestOrLoss reports that an acknowledgement has been received for the value,
+// or that the packet carrying the value has been lost.
+// The value is set to the acked state only if pnum is the latest packet containing it.
+//
+// We use this to handle acks for data that varies every time it is sent.
+// For example, if we send a MAX_DATA frame followed by an updated MAX_DATA value in a
+// second packet, we consider the data sent only upon receiving an ack for the most
+// recent value.
+func (s *sentVal) ackLatestOrLoss(pnum packetNumber, fate packetFate) {
+	if fate == packetAcked {
+		if *s == sentVal(pnum)|sentValSent {
+			*s = sentValReceived
+		}
+	} else {
+		if *s == sentVal(pnum)|sentValSent {
+			*s = sentValUnsent
+		}
+	}
+}
+
+func (s sentVal) state() uint64 { return uint64(s) & sentValStateMask }

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

@@ -0,0 +1,62 @@
+// Copyright 2025 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
+
+// skipState is state for optimistic ACK defenses.
+//
+// An endpoint performs an optimistic ACK attack by sending acknowledgements for packets
+// which it has not received, potentially convincing the sender's congestion controller to
+// send at rates beyond what the network supports.
+//
+// We defend against this by periodically skipping packet numbers.
+// Receiving an ACK for an unsent packet number is a PROTOCOL_VIOLATION error.
+//
+// We only skip packet numbers in the Application Data number space.
+// The total data sent in the Initial/Handshake spaces should generally fit into
+// the initial congestion window.
+//
+// https://www.rfc-editor.org/rfc/rfc9000.html#section-21.4
+type skipState struct {
+	// skip is the next packet number (in the Application Data space) we should skip.
+	skip packetNumber
+
+	// maxSkip is the maximum number of packets to send before skipping another number.
+	// Increases over time.
+	maxSkip int64
+}
+
+func (ss *skipState) init(c *Conn) {
+	ss.maxSkip = 256 // skip our first packet number within this range
+	ss.updateNumberSkip(c)
+}
+
+// shouldSkip returns whether we should skip the given packet number.
+func (ss *skipState) shouldSkip(num packetNumber) bool {
+	return ss.skip == num
+}
+
+// updateNumberSkip schedules a packet to be skipped after skipping lastSkipped.
+func (ss *skipState) updateNumberSkip(c *Conn) {
+	// Send at least this many packets before skipping.
+	// Limits the impact of skipping a little,
+	// plus allows most tests to ignore skipping.
+	const minSkip = 64
+
+	skip := minSkip + c.prng.Int64N(ss.maxSkip-minSkip)
+	ss.skip += packetNumber(skip)
+
+	// Double the size of the skip each time until we reach 128k.
+	// The idea here is that an attacker needs to correctly ack ~N packets in order
+	// to send an optimistic ack for another ~N packets.
+	// Skipping packet numbers comes with a small cost (it causes the receiver to
+	// send an immediate ACK rather than the usual delayed ACK), so we increase the
+	// time between skips as a connection's lifetime grows.
+	//
+	// The 128k cap is arbitrary, chosen so that we skip a packet number
+	// about once a second when sending full-size datagrams at 1Gbps.
+	if ss.maxSkip < 128*1024 {
+		ss.maxSkip *= 2
+	}
+}

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

@@ -0,0 +1,59 @@
+// 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 (
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/sha256"
+	"hash"
+	"sync"
+)
+
+const statelessResetTokenLen = 128 / 8
+
+// A statelessResetToken is a stateless reset token.
+// https://www.rfc-editor.org/rfc/rfc9000#section-10.3
+type statelessResetToken [statelessResetTokenLen]byte
+
+type statelessResetTokenGenerator struct {
+	canReset bool
+
+	// The hash.Hash interface is not concurrency safe,
+	// so we need a mutex here.
+	//
+	// There shouldn't be much contention on stateless reset token generation.
+	// If this proves to be a problem, we could avoid the mutex by using a separate
+	// generator per Conn, or by using a concurrency-safe generator.
+	mu  sync.Mutex
+	mac hash.Hash
+}
+
+func (g *statelessResetTokenGenerator) init(secret [32]byte) {
+	zero := true
+	for _, b := range secret {
+		if b != 0 {
+			zero = false
+			break
+		}
+	}
+	if zero {
+		// Generate tokens using a random secret, but don't send stateless resets.
+		rand.Read(secret[:])
+		g.canReset = false
+	} else {
+		g.canReset = true
+	}
+	g.mac = hmac.New(sha256.New, secret[:])
+}
+
+func (g *statelessResetTokenGenerator) tokenForConnID(cid []byte) (token statelessResetToken) {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	defer g.mac.Reset()
+	g.mac.Write(cid)
+	copy(token[:], g.mac.Sum(nil))
+	return token
+}