blob: 458cd3a93a358608235e00e64c6d40293f5111c4 [file] [log] [blame]
// 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.
//go:build go1.21
package quic
// parseLongHeaderPacket parses a QUIC long header packet.
//
// It does not parse Version Negotiation packets.
//
// On input, pkt contains a long header packet (possibly followed by more packets),
// k the decryption keys for the packet, and pnumMax the largest packet number seen
// in the number space of this packet.
//
// parseLongHeaderPacket returns the parsed packet with protection removed
// and its length in bytes.
//
// It returns an empty packet and -1 if the packet could not be parsed.
func parseLongHeaderPacket(pkt []byte, k fixedKeys, pnumMax packetNumber) (p longPacket, n int) {
if len(pkt) < 5 || !isLongHeader(pkt[0]) {
return longPacket{}, -1
}
// Header Form (1) = 1,
// Fixed Bit (1) = 1,
// Long Packet Type (2),
// Type-Specific Bits (4),
b := pkt
p.ptype = getPacketType(b)
if p.ptype == packetTypeInvalid {
return longPacket{}, -1
}
b = b[1:]
// Version (32),
p.version, n = consumeUint32(b)
if n < 0 {
return longPacket{}, -1
}
b = b[n:]
if p.version == 0 {
// Version Negotiation packet; not handled here.
return longPacket{}, -1
}
// Destination Connection ID Length (8),
// Destination Connection ID (0..160),
p.dstConnID, n = consumeUint8Bytes(b)
if n < 0 || len(p.dstConnID) > 20 {
return longPacket{}, -1
}
b = b[n:]
// Source Connection ID Length (8),
// Source Connection ID (0..160),
p.srcConnID, n = consumeUint8Bytes(b)
if n < 0 || len(p.dstConnID) > 20 {
return longPacket{}, -1
}
b = b[n:]
switch p.ptype {
case packetTypeInitial:
// Token Length (i),
// Token (..),
p.extra, n = consumeVarintBytes(b)
if n < 0 {
return longPacket{}, -1
}
b = b[n:]
case packetTypeRetry:
// Retry Token (..),
// Retry Integrity Tag (128),
p.extra = b
return p, len(pkt)
}
// Length (i),
payLen, n := consumeVarint(b)
if n < 0 {
return longPacket{}, -1
}
b = b[n:]
if uint64(len(b)) < payLen {
return longPacket{}, -1
}
// Packet Number (8..32),
// Packet Payload (..),
pnumOff := len(pkt) - len(b)
pkt = pkt[:pnumOff+int(payLen)]
if k.isSet() {
var err error
p.payload, p.num, err = k.unprotect(pkt, pnumOff, pnumMax)
if err != nil {
return longPacket{}, -1
}
}
return p, len(pkt)
}
// skipLongHeaderPacket returns the length of the long header packet at the start of pkt,
// or -1 if the buffer does not contain a valid packet.
func skipLongHeaderPacket(pkt []byte) int {
// Header byte, 4 bytes of version.
n := 5
if len(pkt) <= n {
return -1
}
// Destination connection ID length, destination connection ID.
n += 1 + int(pkt[n])
if len(pkt) <= n {
return -1
}
// Source connection ID length, source connection ID.
n += 1 + int(pkt[n])
if len(pkt) <= n {
return -1
}
if getPacketType(pkt) == packetTypeInitial {
// Token length, token.
_, nn := consumeVarintBytes(pkt[n:])
if nn < 0 {
return -1
}
n += nn
}
// Length, packet number, payload.
_, nn := consumeVarintBytes(pkt[n:])
if nn < 0 {
return -1
}
n += nn
if len(pkt) < n {
return -1
}
return n
}
// parse1RTTPacket parses a QUIC 1-RTT (short header) packet.
//
// On input, pkt contains a short header packet, k the decryption keys for the packet,
// and pnumMax the largest packet number seen in the number space of this packet.
func parse1RTTPacket(pkt []byte, k fixedKeys, dstConnIDLen int, pnumMax packetNumber) (p shortPacket, n int) {
var err error
p.payload, p.num, err = k.unprotect(pkt, 1+dstConnIDLen, pnumMax)
if err != nil {
return shortPacket{}, -1
}
return p, len(pkt)
}
// Consume functions return n=-1 on conditions which result in FRAME_ENCODING_ERROR,
// which includes both general parse failures and specific violations of frame
// constraints.
func consumeAckFrame(frame []byte, f func(rangeIndex int, start, end packetNumber)) (largest packetNumber, ackDelay unscaledAckDelay, n int) {
b := frame[1:] // type
largestAck, n := consumeVarint(b)
if n < 0 {
return 0, 0, -1
}
b = b[n:]
v, n := consumeVarintInt64(b)
if n < 0 {
return 0, 0, -1
}
b = b[n:]
ackDelay = unscaledAckDelay(v)
ackRangeCount, n := consumeVarint(b)
if n < 0 {
return 0, 0, -1
}
b = b[n:]
rangeMax := packetNumber(largestAck)
for i := uint64(0); ; i++ {
rangeLen, n := consumeVarint(b)
if n < 0 {
return 0, 0, -1
}
b = b[n:]
rangeMin := rangeMax - packetNumber(rangeLen)
if rangeMin < 0 || rangeMin > rangeMax {
return 0, 0, -1
}
f(int(i), rangeMin, rangeMax+1)
if i == ackRangeCount {
break
}
gap, n := consumeVarint(b)
if n < 0 {
return 0, 0, -1
}
b = b[n:]
rangeMax = rangeMin - packetNumber(gap) - 2
}
if frame[0] != frameTypeAckECN {
return packetNumber(largestAck), ackDelay, len(frame) - len(b)
}
ect0Count, n := consumeVarint(b)
if n < 0 {
return 0, 0, -1
}
b = b[n:]
ect1Count, n := consumeVarint(b)
if n < 0 {
return 0, 0, -1
}
b = b[n:]
ecnCECount, n := consumeVarint(b)
if n < 0 {
return 0, 0, -1
}
b = b[n:]
// TODO: Make use of ECN feedback.
// https://www.rfc-editor.org/rfc/rfc9000.html#section-19.3.2
_ = ect0Count
_ = ect1Count
_ = ecnCECount
return packetNumber(largestAck), ackDelay, len(frame) - len(b)
}
func consumeResetStreamFrame(b []byte) (id streamID, code uint64, finalSize int64, n int) {
n = 1
idInt, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, 0, 0, -1
}
n += nn
code, nn = consumeVarint(b[n:])
if nn < 0 {
return 0, 0, 0, -1
}
n += nn
v, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, 0, 0, -1
}
n += nn
finalSize = int64(v)
return streamID(idInt), code, finalSize, n
}
func consumeStopSendingFrame(b []byte) (id streamID, code uint64, n int) {
n = 1
idInt, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, 0, -1
}
n += nn
code, nn = consumeVarint(b[n:])
if nn < 0 {
return 0, 0, -1
}
n += nn
return streamID(idInt), code, n
}
func consumeCryptoFrame(b []byte) (off int64, data []byte, n int) {
n = 1
v, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, nil, -1
}
off = int64(v)
n += nn
data, nn = consumeVarintBytes(b[n:])
if nn < 0 {
return 0, nil, -1
}
n += nn
return off, data, n
}
func consumeNewTokenFrame(b []byte) (token []byte, n int) {
n = 1
data, nn := consumeVarintBytes(b[n:])
if nn < 0 {
return nil, -1
}
if len(data) == 0 {
return nil, -1
}
n += nn
return data, n
}
func consumeStreamFrame(b []byte) (id streamID, off int64, fin bool, data []byte, n int) {
fin = (b[0] & 0x01) != 0
n = 1
idInt, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, 0, false, nil, -1
}
n += nn
if b[0]&0x04 != 0 {
v, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, 0, false, nil, -1
}
n += nn
off = int64(v)
}
if b[0]&0x02 != 0 {
data, nn = consumeVarintBytes(b[n:])
if nn < 0 {
return 0, 0, false, nil, -1
}
n += nn
} else {
data = b[n:]
n += len(data)
}
if off+int64(len(data)) >= 1<<62 {
return 0, 0, false, nil, -1
}
return streamID(idInt), off, fin, data, n
}
func consumeMaxDataFrame(b []byte) (max int64, n int) {
n = 1
v, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, -1
}
n += nn
return int64(v), n
}
func consumeMaxStreamDataFrame(b []byte) (id streamID, max int64, n int) {
n = 1
v, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, 0, -1
}
n += nn
id = streamID(v)
v, nn = consumeVarint(b[n:])
if nn < 0 {
return 0, 0, -1
}
n += nn
max = int64(v)
return id, max, n
}
func consumeMaxStreamsFrame(b []byte) (typ streamType, max int64, n int) {
switch b[0] {
case frameTypeMaxStreamsBidi:
typ = bidiStream
case frameTypeMaxStreamsUni:
typ = uniStream
default:
return 0, 0, -1
}
n = 1
v, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, 0, -1
}
n += nn
if v > maxStreamsLimit {
return 0, 0, -1
}
return typ, int64(v), n
}
func consumeStreamDataBlockedFrame(b []byte) (id streamID, max int64, n int) {
n = 1
v, nn := consumeVarint(b[n:])
if nn < 0 {
return 0, 0, -1
}
n += nn
id = streamID(v)
max, nn = consumeVarintInt64(b[n:])
if nn < 0 {
return 0, 0, -1
}
n += nn
return id, max, n
}
func consumeDataBlockedFrame(b []byte) (max int64, n int) {
n = 1
max, nn := consumeVarintInt64(b[n:])
if nn < 0 {
return 0, -1
}
n += nn
return max, n
}
func consumeStreamsBlockedFrame(b []byte) (typ streamType, max int64, n int) {
if b[0] == frameTypeStreamsBlockedBidi {
typ = bidiStream
} else {
typ = uniStream
}
n = 1
max, nn := consumeVarintInt64(b[n:])
if nn < 0 {
return 0, 0, -1
}
n += nn
return typ, max, n
}
func consumeNewConnectionIDFrame(b []byte) (seq, retire int64, connID []byte, resetToken [16]byte, n int) {
n = 1
var nn int
seq, nn = consumeVarintInt64(b[n:])
if nn < 0 {
return 0, 0, nil, [16]byte{}, -1
}
n += nn
retire, nn = consumeVarintInt64(b[n:])
if nn < 0 {
return 0, 0, nil, [16]byte{}, -1
}
n += nn
if seq < retire {
return 0, 0, nil, [16]byte{}, -1
}
connID, nn = consumeVarintBytes(b[n:])
if nn < 0 {
return 0, 0, nil, [16]byte{}, -1
}
if len(connID) < 1 || len(connID) > 20 {
return 0, 0, nil, [16]byte{}, -1
}
n += nn
if len(b[n:]) < len(resetToken) {
return 0, 0, nil, [16]byte{}, -1
}
copy(resetToken[:], b[n:])
n += len(resetToken)
return seq, retire, connID, resetToken, n
}
func consumeRetireConnectionIDFrame(b []byte) (seq int64, n int) {
n = 1
var nn int
seq, nn = consumeVarintInt64(b[n:])
if nn < 0 {
return 0, -1
}
n += nn
return seq, n
}
func consumePathChallengeFrame(b []byte) (data uint64, n int) {
n = 1
var nn int
data, nn = consumeUint64(b[n:])
if nn < 0 {
return 0, -1
}
n += nn
return data, n
}
func consumePathResponseFrame(b []byte) (data uint64, n int) {
return consumePathChallengeFrame(b) // identical frame format
}
func consumeConnectionCloseTransportFrame(b []byte) (code transportError, frameType uint64, reason string, n int) {
n = 1
var nn int
var codeInt uint64
codeInt, nn = consumeVarint(b[n:])
if nn < 0 {
return 0, 0, "", -1
}
code = transportError(codeInt)
n += nn
frameType, nn = consumeVarint(b[n:])
if nn < 0 {
return 0, 0, "", -1
}
n += nn
reasonb, nn := consumeVarintBytes(b[n:])
if nn < 0 {
return 0, 0, "", -1
}
n += nn
reason = string(reasonb)
return code, frameType, reason, n
}
func consumeConnectionCloseApplicationFrame(b []byte) (code uint64, reason string, n int) {
n = 1
var nn int
code, nn = consumeVarint(b[n:])
if nn < 0 {
return 0, "", -1
}
n += nn
reasonb, nn := consumeVarintBytes(b[n:])
if nn < 0 {
return 0, "", -1
}
n += nn
reason = string(reasonb)
return code, reason, n
}