k8s-operator,sessionrecording: fix SPDY protocol DoS risks (#21385)

* k8s-operator,sessionrecording: fix SPDY protocol DoS risks

There was a risk that a malicious kubectl client could cause a DoS issue for the Tailscale proxy performing a k8s recording by defining large quantities of headers, or using a decompression bomb.

This change adds limits of 1000 header pairs, and a maximum of 1MB for the decompressed header block size. In addition fuzz testing is added and integrated with oss-fuzz to review for other protocol issues.

Credit to Eresus Security for reporting the header quantity DoS risk.

Fixes tailscale/corp#45112
Updates tailscale/corp#46608

Change-Id: Ie27b241b9f1cac58198560a88a44ffaa0927b96e
Signed-off-by: Mike Jensen <[email protected]>

* k8s-operator/sessionrecording/spdy: test consecutive header blocks share one zlib context

kubectl compresses every stream's header block against one zlib stream for the
life of the connection, so the proxy decodes them all through a single
zlibReader (conn.zlibReqReader). This test compresses two blocks onto one writer
and decodes both from one reader.

It fails on the second block: parseHeaders' ended() reads one byte past the
first block, which on the shared context is the start of the next block, leaving
the reader unable to decode it ("unexpected EOF"). In a real session that means
every stream after the first fails to parse and its output is never recorded.

Signed-off-by: chaosinthecrd <[email protected]>

* k8s-operator,sessionrecording: parse full 31-bit SPDY stream IDs

dataFrameStreamID masked stream IDs to 7 bits while storeStreamID kept all 32, so output on any stream with ID >= 128 was never matched against a stored stdout/stderr stream and went unrecorded. Keep the 31 spec bits in both places. controlFrameVersion gets the matching 15-bit mask for its version field.

Mask storeStreamID to 31 bits as well: the reserved flag bit in a SYN_STREAM ID field can never appear in a data frame, so an ID stored with the bit set matches nothing.

Change-Id: Icf05a29a2838f2f2492b8d2da9e821f4e2459877
Signed-off-by: Mike Jensen <[email protected]>

---------

Signed-off-by: Mike Jensen <[email protected]>
Signed-off-by: chaosinthecrd <[email protected]>
Co-authored-by: chaosinthecrd <[email protected]>
This commit is contained in:
Mike Jensenandchaosinthecrd authored and GitHub committed 2026-10-09 10:12:18 -06:00
1 parent b9262195b1
commit 144f6b20f0
5 files changed
+804 -14

No files matched your search

+7
View File
@@ -119,6 +119,13 @@ build_fuzzers() {
# disco (top-level)
build_fuzzer tailscale.com/disco FuzzDiscoParse disco_parse_fuzzer
# k8s-operator (sessionrecording/spdy)
build_fuzzer tailscale.com/k8s-operator/sessionrecording/spdy FuzzSpdyFrameParse spdy_frame_parse
build_fuzzer tailscale.com/k8s-operator/sessionrecording/spdy FuzzSpdyFrameParseHeaders spdy_frame_parse_headers
build_fuzzer tailscale.com/k8s-operator/sessionrecording/spdy FuzzParseHeaders spdy_parse_headers
build_fuzzer tailscale.com/k8s-operator/sessionrecording/spdy FuzzConnRead spdy_conn_read
build_fuzzer tailscale.com/k8s-operator/sessionrecording/spdy FuzzConnWrite spdy_conn_write
# net (dnscache, dns/resolver, packet, portmapper, stun, traffic)
build_fuzzer tailscale.com/net/dnscache FuzzGetDNSQueryCacheKey dnscache_get_dns_query_cache_key
build_fuzzer tailscale.com/net/dnscache FuzzAsciiLowerName dnscache_ascii_lower_name
+1 -1
View File
@@ -255,7 +255,7 @@ func (c *conn) storeStreamID(sf spdyFrame, header http.Header) {
const (
streamTypeHeaderKey = "Streamtype"
)
id := binary.BigEndian.Uint32(sf.Payload[0:4])
id := binary.BigEndian.Uint32(sf.Payload[0:4]) & 0x7fffffff // drop the reserved flag bit: data frames never carry it
switch header.Get(streamTypeHeaderKey) {
case corev1.StreamTypeStdout:
c.stdoutStreamID.Store(id)
+54 -10
View File
@@ -8,6 +8,7 @@ package spdy
import (
"bytes"
"encoding/binary"
"errors"
"fmt"
"io"
"net/http"
@@ -22,6 +23,18 @@ const (
SYN_PING ControlFrameType = 6 // https://www.ietf.org/archive/id/draft-mbelshe-httpbis-spdy-00.txt section 2.6.5
)
// maxHeaderCount bounds the number of Name/Value pairs parsed out of one SPDY header block.
// A 'kubectl exec/attach' session opens a few streams whose blocks carry a handful of pairs,
// so this is orders of magnitude above real traffic.
const maxHeaderCount = 1000
// errHeaderBlockTooLarge is returned when a decompressed SPDY header block
// exceeds maxHeaderBlockSize.
var errHeaderBlockTooLarge = errors.New("SPDY header block too large or malformed")
// maxHeaderBlockSize bounds the decompressed size of one Name/Value Header Block.
const maxHeaderBlockSize = 1 << 20 // 1MiB
// spdyFrame is a parsed SPDY frame as defined in
// https://www.ietf.org/archive/id/draft-mbelshe-httpbis-spdy-00.txt
// A SPDY frame can be either a control frame or a data frame.
@@ -159,8 +172,29 @@ func (sf *spdyFrame) parseHeaders(z *zlibReader, log *zap.SugaredLogger) (http.H
return nil, nil
}
// parseHeaders expects to be passed a reader that contains a compressed SPDY control
// frame Name/Value Header Block with 0 or more headers:
// limitHeaderReader caps reads at maxHeaderBlockSize bytes. Reads past the
// cap report errHeaderBlockTooLarge instead of a clean EOF.
type limitHeaderReader struct {
r io.Reader // decompressed header block
remain int64 // remaining byte budget
}
func (lr *limitHeaderReader) Read(p []byte) (int, error) {
if len(p) == 0 {
return 0, nil
} else if lr.remain == 0 {
return 0, errHeaderBlockTooLarge
}
if int64(len(p)) > lr.remain {
p = p[:lr.remain]
}
n, err := lr.r.Read(p)
lr.remain -= int64(n)
return n, err
}
// parseHeaders expects to be passed a reader that contains a compressed SPDY
// control frame Name/Value Header Block with 0 or more headers:
//
// | Number of Name/Value pairs (int32) | <+
// +------------------------------------+ |
@@ -179,14 +213,21 @@ func (sf *spdyFrame) parseHeaders(z *zlibReader, log *zap.SugaredLogger) (http.H
// See also https://www.ietf.org/archive/id/draft-mbelshe-httpbis-spdy-00.txt section 2.6.10
func parseHeaders(decompressor io.Reader, log *zap.SugaredLogger) (http.Header, error) {
buf := bufPool.Get().(*bytes.Buffer)
defer bufPool.Put(buf)
defer func() {
if buf.Cap() <= maxHeaderBlockSize { // don't retain a buffer grown by a large block
bufPool.Put(buf)
}
}()
buf.Reset()
// Limit the impact of a potential compression bomb from the header block
lr := &limitHeaderReader{r: decompressor, remain: maxHeaderBlockSize}
// readUint32 reads the next 4 decompressed bytes from the decompressor
// as a uint32.
readUint32 := func() (uint32, error) {
const uint32Length = 4
if _, err := io.CopyN(buf, decompressor, uint32Length); err != nil { // decompress
if _, err := io.CopyN(buf, lr, uint32Length); err != nil { // decompress
return 0, fmt.Errorf("error decompressing bytes: %w", err)
}
return binary.BigEndian.Uint32(buf.Next(uint32Length)), nil // return as uint32
@@ -200,7 +241,7 @@ func parseHeaders(decompressor io.Reader, log *zap.SugaredLogger) (http.Header,
if err != nil {
return nil, err
}
if _, err := io.CopyN(buf, decompressor, int64(xLen)); err != nil { // decompress
if _, err := io.CopyN(buf, lr, int64(xLen)); err != nil { // decompress
return nil, err
}
return buf.Next(int(xLen)), nil
@@ -210,6 +251,9 @@ func parseHeaders(decompressor io.Reader, log *zap.SugaredLogger) (http.Header,
if err != nil {
return nil, fmt.Errorf("error determining num headers: %v", err)
}
if numHeaders > maxHeaderCount {
return nil, fmt.Errorf("invalid data: too many headers declared: %v, maximum is %v", numHeaders, maxHeaderCount)
}
h := make(http.Header, numHeaders)
for range numHeaders {
name, err := readLenBytes()
@@ -231,7 +275,7 @@ func parseHeaders(decompressor io.Reader, log *zap.SugaredLogger) (http.Header,
return h, nil
}
// isSPDYFrame validates that the input bytes start with a valid SPDY frame
// isSPDYFrameHeader validates that the input bytes start with a valid SPDY frame
// header.
func isSPDYFrameHeader(f []byte) bool {
if hasControlBitSet(f) {
@@ -242,11 +286,11 @@ func isSPDYFrameHeader(f []byte) bool {
return dataFrameStreamID(f) != uint32(0)
}
// spdyDataFrameStreamID returns stream ID for an SPDY data frame passed as the
// dataFrameStreamID returns stream ID for an SPDY data frame passed as the
// input data slice. StreaID is contained within bits [0-31) of a data frame
// header.
func dataFrameStreamID(frame []byte) uint32 {
return binary.BigEndian.Uint32(frame[0:4]) & 0x7f
return binary.BigEndian.Uint32(frame[0:4]) & 0x7fffffff
}
// controlFrameType returns the type of a SPDY control frame.
@@ -255,11 +299,11 @@ func controlFrameType(f []byte) ControlFrameType {
return ControlFrameType(binary.BigEndian.Uint16(f[2:4]))
}
// spdyControlFrameVersion returns SPDY version extracted from input bytes that
// controlFrameVersion returns SPDY version extracted from input bytes that
// must be a SPDY control frame.
func controlFrameVersion(frame []byte) uint16 {
bs := binary.BigEndian.Uint16(frame[0:2]) // first 16 bits
return bs & 0x7f // discard control bit
return bs & 0x7fff // discard control bit
}
// hasControlBitSet returns true if the passsed bytes have SPDY control bit set.
@@ -9,10 +9,12 @@ import (
"bytes"
"compress/zlib"
"encoding/binary"
"errors"
"fmt"
"io"
"net/http"
"reflect"
"slices"
"strings"
"testing"
"time"
@@ -23,6 +25,162 @@ import (
"go.uber.org/zap"
)
func Test_limitHeaderReader(t *testing.T) {
t.Parallel()
tests := []struct {
name string
body []byte // underlying stream, never nil in practice
remain int64 // starting budget
readSize int // bytes to request per Read
wantData []byte // total bytes expected before the terminal error
wantErr error // terminal error; nil means clean EOF
}{
{
name: "under_limit",
body: []byte("hello"),
remain: 16,
readSize: 16,
wantData: []byte("hello"),
},
{
// Budget spent with the last bytes: parsing succeeded but any
// further read, including the ended() check, errors.
name: "exactly_at_limit",
body: []byte("hello"),
remain: 5,
readSize: 5,
wantData: []byte("hello"),
wantErr: errHeaderBlockTooLarge,
},
{
name: "budget_spent_mid_stream",
body: []byte("hello world"),
remain: 5,
readSize: 2,
wantData: []byte("hello"),
wantErr: errHeaderBlockTooLarge,
},
{
name: "budget_spent_mid_stream_single_reads",
body: []byte("hello world"),
remain: 5,
readSize: 1,
wantData: []byte("hello"),
wantErr: errHeaderBlockTooLarge,
},
{
// Every read after the budget is spent keeps reporting the
// sentinel while data remains.
name: "error_persists_after_trip",
body: []byte("hello world"),
remain: 5,
readSize: 5,
wantData: []byte("hello"),
wantErr: errHeaderBlockTooLarge,
},
{
name: "empty_read_no_hang",
body: []byte("hello"),
remain: 5,
readSize: 0, // zero length read must not spin the budget away
wantData: nil,
},
{
name: "eof_mid_block",
body: []byte("hi"),
remain: 5,
readSize: 1,
wantData: []byte("hi"),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
lr := &limitHeaderReader{r: bytes.NewReader(tt.body), remain: tt.remain}
var got []byte
var lastErr error
for range 10 { // bounded loop: a bug here must not hang the test
p := make([]byte, tt.readSize)
n, err := lr.Read(p)
got = append(got, p[:n]...)
if err != nil {
lastErr = err
break
}
}
if tt.wantErr != nil && lastErr == nil {
t.Errorf("limitHeaderReader.Read() got no error after %v bytes, want %v", len(got), tt.wantErr)
}
if tt.wantErr == nil {
// No error expected: the stream must end in a clean EOF, not
// the sentinel or a loop that returned (0, nil) until the cap.
if lastErr != nil && !errors.Is(lastErr, io.EOF) {
t.Errorf("limitHeaderReader.Read() error = %v, want clean EOF", lastErr)
}
} else if !errors.Is(lastErr, tt.wantErr) {
t.Errorf("limitHeaderReader.Read() error = %v, want %v", lastErr, tt.wantErr)
}
if !bytes.Equal(got, tt.wantData) {
t.Errorf("limitHeaderReader.Read() data = %q, want %q", got, tt.wantData)
}
if tt.wantErr == nil {
return
}
})
}
}
func Test_parseHeaders_oversizeBlock(t *testing.T) {
zl, err := zap.NewDevelopment()
if err != nil {
t.Fatal(err)
}
const synStreamPrefix = 10 // stream ID, priority, slot before the header block
// A block declaring one name of maxHeaderBlockSize+1 bytes, backed by
// zeros so it compresses far below the 1MiB wire limit.
block := slices.Concat(
binary.BigEndian.AppendUint32(nil, 1), // one pair
binary.BigEndian.AppendUint32(nil, maxHeaderBlockSize+1), // name length
make([]byte, maxHeaderBlockSize+1), // name bytes
)
sf := &spdyFrame{
Ctrl: true,
Type: SYN_STREAM,
Payload: append(make([]byte, synStreamPrefix), fuzzCompress(block)...),
}
var zr zlibReader
zr.Set(sf.Payload[synStreamPrefix:])
_, err = parseHeaders(&zr, zl.Sugar())
if !errors.Is(err, errHeaderBlockTooLarge) {
t.Errorf("parseHeaders() error = %v, want errHeaderBlockTooLarge", err)
}
// A block of exactly maxHeaderBlockSize has every declared byte within
// budget, so it parses cleanly rather than being cut off.
nameLen := uint32(maxHeaderBlockSize - 12) // minus the pair count, name and value length fields
block = slices.Concat(
binary.BigEndian.AppendUint32(nil, 1), // one pair
binary.BigEndian.AppendUint32(nil, nameLen), // name length
make([]byte, nameLen), // name bytes
binary.BigEndian.AppendUint32(nil, 0), // value length
)
sf = &spdyFrame{
Ctrl: true,
Type: SYN_STREAM,
Payload: append(make([]byte, synStreamPrefix), fuzzCompress(block)...),
}
var zr2 zlibReader
zr2.Set(sf.Payload[synStreamPrefix:])
hdr, err := parseHeaders(&zr2, zl.Sugar())
if err != nil {
t.Errorf("parseHeaders() error = %v for a block of exactly maxHeaderBlockSize", err)
} else if len(hdr) != 1 {
t.Errorf("parseHeaders() parsed %d headers, want 1", len(hdr))
}
}
func Test_spdyFrame_Parse(t *testing.T) {
zl, err := zap.NewDevelopment()
if err != nil {
@@ -90,9 +248,16 @@ func Test_spdyFrame_Parse(t *testing.T) {
gotBytes: []byte{0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x2}, // header specifies payload length of 2
},
{
name: "control_bit_set_not_spdy_frame",
gotBytes: []byte{0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, // header specifies payload length of 2
wantErr: true,
// Data frames keep 31 bits of stream ID: this parses with ID
// 0x01000000 rather than being rejected as not SPDY
name: "data_frame_high_stream_id",
gotBytes: []byte{0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
wantFrame: spdyFrame{
Payload: []byte{},
StreamID: 0x01000000,
Raw: []byte{0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
},
wantOk: true,
},
{
name: "control_bit_not_set_not_spdy_frame",
@@ -204,6 +369,47 @@ func Test_spdyFrame_parseHeaders(t *testing.T) {
}
}
// Test_parseHeaders_sharedContext verifies that consecutive header blocks
// decode from a single zlibReader. kubectl compresses every stream's header
// block against one zlib stream for the life of the connection, so the proxy
// reuses one zlibReader (conn.zlibReqReader) across all of them. Each block
// must decode without disturbing the bytes of the next.
func Test_parseHeaders_sharedContext(t *testing.T) {
zl := zap.NewNop().Sugar()
// Compress two header blocks onto one writer, as kubectl does across frames.
var buf bytes.Buffer
w, err := zlib.NewWriterLevelDict(&buf, zlib.BestCompression, spdyTxtDictionary)
if err != nil {
t.Fatalf("creating zlib writer: %v", err)
}
block := func(headers map[string]string) []byte {
start := buf.Len()
writeHeaderValueBlock(t, w, headers)
if err := w.Flush(); err != nil {
t.Fatalf("flushing zlib writer: %v", err)
}
return buf.Bytes()[start:]
}
first := block(map[string]string{"Streamtype": "stdout"})
second := block(map[string]string{"Streamtype": "stderr"})
// Decode both from one reader, the way the proxy does.
var z zlibReader
z.Set(first)
if _, err := parseHeaders(&z, zl); err != nil {
t.Fatalf("parseHeaders(first): %v", err)
}
z.Set(second)
got, err := parseHeaders(&z, zl)
if err != nil {
t.Fatalf("parseHeaders(second): %v", err)
}
if want := header(map[string]string{"Streamtype": "stderr"}); !reflect.DeepEqual(got, want) {
t.Errorf("parseHeaders(second) = %v, want %v", got, want)
}
}
// Test_spdyFrame_ParseRand calls spdyFrame.Parse with randomly generated bytes
// to test that it doesn't panic.
func Test_spdyFrame_ParseRand(t *testing.T) {
@@ -0,0 +1,533 @@
// Copyright (c) Tailscale Inc & contributors
// SPDX-License-Identifier: BSD-3-Clause
//go:build !plan9
package spdy
import (
"bytes"
"compress/zlib"
"encoding/binary"
"net/http"
"slices"
"strings"
"testing"
"go.uber.org/zap"
"tailscale.com/k8s-operator/sessionrecording/fakes"
"tailscale.com/k8s-operator/sessionrecording/tsrecorder"
"tailscale.com/tstest"
)
// fuzzLog is a discarding logger, needed for fuzz speed.
var fuzzLog = zap.NewNop().Sugar()
const (
fuzzStdoutStreamID uint32 = 1
fuzzStderrStreamID uint32 = 2
fuzzResizeStreamID uint32 = 3
)
// fuzzCtrlFrame returns a SPDY control frame carrying payload. version is the
// 15 bit protocol version.
func fuzzCtrlFrame(version uint16, typ ControlFrameType, payload []byte) []byte {
f := make([]byte, 8+len(payload))
v := version & 0x7fff // bit 15 is the control bit
f[0] = 0x80 | byte(v>>8)
f[1] = byte(v)
binary.BigEndian.PutUint16(f[2:4], uint16(typ))
writeFuzzLen24(f[5:8], len(payload))
copy(f[8:], payload)
return f
}
// fuzzDataFrame returns a SPDY data frame for streamID carrying payload.
func fuzzDataFrame(streamID uint32, payload []byte) []byte {
f := make([]byte, 8+len(payload))
binary.BigEndian.PutUint32(f[0:4], streamID&0x7fffffff) // bit 31 is the control bit
writeFuzzLen24(f[5:8], len(payload))
copy(f[8:], payload)
return f
}
// writeFuzzLen24 writes n as SPDY's 24 bit frame length field.
func writeFuzzLen24(b []byte, n int) {
b[0] = byte(n >> 16)
b[1] = byte(n >> 8)
b[2] = byte(n)
}
// fuzzBlock returns a decompressed Name/Value header block declaring count pairs
// followed by the given entries.
func fuzzBlock(count uint32, pairs ...[2]string) []byte {
b := binary.BigEndian.AppendUint32(nil, count)
for _, p := range pairs {
b = append(b, fuzzKV(p[0], p[1])...)
}
return b
}
// fuzzKV returns one decompressed entry of a Name/Value header block.
// Writes length followed by the value for the key then the value.
func fuzzKV(name, value string) []byte {
b := make([]byte, 8+len(name)+len(value))
binary.BigEndian.PutUint32(b[0:4], uint32(len(name)))
copy(b[4:], name)
binary.BigEndian.PutUint32(b[4+len(name):8+len(name)], uint32(len(value)))
copy(b[8+len(name):], value)
return b
}
// fuzzCompress zlib-compresses b with the SPDY header dictionary, mirroring a client
// compressing a Name/Value header block.
func fuzzCompress(b []byte) []byte {
var buf bytes.Buffer
w, err := zlib.NewWriterLevelDict(&buf, zlib.BestSpeed, spdyTxtDictionary)
if err != nil {
panic(err)
} else if _, err := w.Write(b); err != nil {
panic(err)
} else if err := w.Close(); err != nil {
panic(err)
}
return buf.Bytes()
}
// fuzzName returns a distinct three letter name for i, so one block can declare many pairs.
func fuzzName(i int) string {
return string([]byte{byte('a' + i/676%26), byte('a' + i/26%26), byte('a' + i%26)})
}
// fuzzSynStream returns a SYN_STREAM payload: the 10 bytes that precede the
// header block (stream ID, priority, slot) plus the compressed block for pairs.
func fuzzSynStream(streamID uint32, pairs ...[2]string) []byte {
p := make([]byte, 10)
binary.BigEndian.PutUint32(p[0:4], streamID)
if len(pairs) > 0 {
p = append(p, fuzzCompress(fuzzBlock(uint32(len(pairs)), pairs...))...)
}
return p
}
// fuzzSynStreamBlock returns a SYN_STREAM payload: the 10 byte prefix plus an arbitrary
// decompressed block, compressed. Lets a seed declare counts that pairs cannot express.
func fuzzSynStreamBlock(streamID uint32, block []byte) []byte {
p := make([]byte, 10)
binary.BigEndian.PutUint32(p[0:4], streamID)
return append(p, fuzzCompress(block)...)
}
// fuzzSynReply returns a SYN_REPLY payload: the 4 byte stream ID plus the
// compressed header block for pairs.
func fuzzSynReply(streamID uint32, pairs ...[2]string) []byte {
p := make([]byte, 4)
binary.BigEndian.PutUint32(p[0:4], streamID)
if len(pairs) > 0 {
p = append(p, fuzzCompress(fuzzBlock(uint32(len(pairs)), pairs...))...)
}
return p
}
func FuzzSpdyFrameParse(f *testing.F) {
// Complete frames
synStream := fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(fuzzStdoutStreamID, [2]string{"streamtype", "stdout"}))
f.Add(synStream)
f.Add(fuzzCtrlFrame(3, SYN_REPLY, fuzzSynReply(0, [2]string{"status", "200"})))
f.Add(fuzzCtrlFrame(3, SYN_PING, []byte{0, 0, 0, 1}))
f.Add(fuzzDataFrame(fuzzStdoutStreamID, []byte("hello")))
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte(`{"width":80,"height":24}`)))
// Header only frames, length field is zero
f.Add([]byte{0x80, 0x3, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0})
f.Add([]byte{0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0})
// A complete frame followed by the first bytes of the next one
f.Add(append(slices.Clone(synStream), 0x80, 0x3))
// Two whole frames in one buffer: only the first may be consumed
f.Add(slices.Concat(synStream, fuzzDataFrame(fuzzStdoutStreamID, []byte("x"))))
// Flags byte all set, sitting between version/type and the length field
f.Add([]byte{0x80, 0x3, 0x0, 0x1, 0xff, 0x0, 0x0, 0x0})
f.Add([]byte{0x0, 0x0, 0x0, 0x1, 0xff, 0x0, 0x0, 0x0}) // data frame variant
// Version is the 15 bits above the control bit: this reads as version 291
f.Add([]byte{0x81, 0x23, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0})
f.Add([]byte{0x81, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0}) // version 257, only bits above 7 set
// Control frames rejected for a zero version or type
f.Add([]byte{0x80, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0})
f.Add([]byte{0x80, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0})
// Data frame rejected for a zero stream ID
f.Add([]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0})
// Stream IDs use all 31 bits above the control bit: ID 300 and ID 44 stay
// distinct, putting their output on separate recordings
f.Add(fuzzDataFrame(300, []byte("stream 300")))
f.Add(fuzzDataFrame(44, []byte("stream 44")))
f.Add(fuzzDataFrame(0x7fffffff, []byte("max stream id")))
// An ID with bit 31 set is a control frame with a zero version, rejected
f.Add([]byte{0x80, 0x0, 0x0, 0x5, 0x0, 0x0, 0x1, 0x0})
// Truncated headers, one per boundary Parse checks
for _, n := range []int{0, 1, 4, 7} {
f.Add(slices.Clone(synStream[:n]))
}
f.Add(synStream[:len(synStream)-1]) // last payload byte missing
// Length claims more bytes than are present, up to the 16MiB field maximum
f.Add([]byte{0x80, 0x3, 0x0, 0x1, 0x0, 0xff, 0xff, 0xff})
f.Add([]byte{0x80, 0x3, 0x0, 0x1, 0x0, 0x0, 0x0, 0x2})
// Declared length above 64KiB: the first complete frame whose size needs all
// three length bytes, so a wrong use of them shows up as a size mismatch
f.Add(fuzzDataFrame(1, make([]byte, 65536)))
// Control bit boundary in the first byte
f.Add([]byte{0x7f, 0x3, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0})
f.Add([]byte{0x80, 0x3, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0})
f.Fuzz(func(t *testing.T, data []byte) {
var sf spdyFrame
ok, err := sf.Parse(data, fuzzLog)
switch {
case err != nil:
return // input rejected as not SPDY
case !ok:
if len(data) < 8 {
return // header cut off before the length field, nothing to size
} else if want := 8 + readInt24(data[5:8]); len(data) >= want {
t.Fatalf("Parse called a %d byte frame incomplete with %d bytes available", want, len(data))
}
return
}
n := 8 + readInt24(data[5:8])
if len(sf.Raw) != n {
t.Fatalf("Raw length %d, want %d", len(sf.Raw), n)
} else if cap(sf.Raw) != n {
t.Fatalf("Raw capacity %d, want %d: frame bytes can alias later input", cap(sf.Raw), n)
} else if len(sf.Payload) != n-8 {
t.Fatalf("Payload length %d, want %d", len(sf.Payload), n-8)
} else if sf.Ctrl != hasControlBitSet(data) {
t.Fatalf("Ctrl = %v, control bit says %v", sf.Ctrl, hasControlBitSet(data))
} else if !sf.Ctrl && (sf.Version != 0 || sf.Type != 0) {
t.Fatalf("data frame parsed out version %d and type %d", sf.Version, sf.Type)
} else if sf.Ctrl && sf.StreamID != 0 {
t.Fatalf("control frame parsed out stream id %d", sf.StreamID)
} else if !sf.Ctrl && sf.StreamID == 0 {
// A data frame only parses with a nonzero stream ID
t.Fatalf("data frame parsed out zero stream id")
}
})
}
// fuzzFrameCopy returns a deep copy of the provided spdyFrame.
func fuzzFrameCopy(sf spdyFrame) spdyFrame {
sf.Raw = slices.Clone(sf.Raw)
sf.Payload = sf.Raw[len(sf.Raw)-len(sf.Payload):]
return sf
}
func FuzzSpdyFrameParseHeaders(f *testing.F) {
// SYN_STREAM: 10 bytes ahead of the header block, then a zlib block
f.Add(fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(fuzzStdoutStreamID, [2]string{"streamtype", "stdout"})))
f.Add(fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(fuzzResizeStreamID, [2]string{"streamtype", "resize"})))
// SYN_STREAM with exactly the 10 byte prefix: nothing to decompress
f.Add(fuzzCtrlFrame(3, SYN_STREAM, make([]byte, 10)))
// SYN_REPLY: headers start at offset 4 and may be absent entirely
f.Add(fuzzCtrlFrame(3, SYN_REPLY, fuzzSynReply(0, [2]string{"status", "200"})))
f.Add(fuzzCtrlFrame(3, SYN_REPLY, []byte{0, 0, 0, 1}))
// SYN_PING: payload must be exactly 4 bytes long
f.Add(fuzzCtrlFrame(3, SYN_PING, []byte{0, 0, 0, 7}))
f.Add(fuzzCtrlFrame(3, SYN_PING, []byte{0, 0, 0}))
f.Add(fuzzCtrlFrame(3, SYN_PING, []byte{0, 0, 0, 7, 8}))
// Prefixes one byte short of what each type requires
f.Add(fuzzCtrlFrame(3, SYN_STREAM, make([]byte, 9)))
f.Add(fuzzCtrlFrame(3, SYN_REPLY, make([]byte, 3)))
// Where a header block is expected: zlib garbage, then a stream cut off mid deflate block
f.Add(fuzzCtrlFrame(3, SYN_STREAM, append(make([]byte, 10), 0x78, 0x9c, 0xff, 0xfe, 0xfd)))
var buf bytes.Buffer
w, err := zlib.NewWriterLevelDict(&buf, zlib.BestSpeed, spdyTxtDictionary)
if err != nil {
f.Fatalf("Failed to create zlib writer: %v", err)
} else if _, err := w.Write(fuzzBlock(1, [2]string{"streamtype", "stdout"})); err != nil {
f.Fatalf("Failed to write block: %v", err)
} else if err := w.Flush(); err != nil { // sync flush makes 'a' decodable here
f.Fatalf("Failed to flush: %v", err)
}
f.Add(fuzzCtrlFrame(3, SYN_STREAM, append(make([]byte, 10), buf.Bytes()[:buf.Len()/2]...)))
// A well formed zlib stream whose declared pair count is wrong by two
f.Add(fuzzCtrlFrame(3, SYN_REPLY, append([]byte{0, 0, 0, 0}, fuzzCompress(fuzzBlock(3, [2]string{"a", "b"}))...)))
// Control types that are not handled: headers must be skipped without error
for _, typ := range []ControlFrameType{0, 3, 4, 5, 7, 8, 9, 0xffff} {
f.Add(fuzzCtrlFrame(3, typ, fuzzSynStream(2, [2]string{"streamtype", "stdin"})))
}
// A data frame: parseHeaders must refuse it
f.Add(fuzzDataFrame(fuzzStdoutStreamID, []byte("not a control frame")))
f.Fuzz(func(t *testing.T, data []byte) {
var parsed spdyFrame
ok, err := parsed.Parse(data, fuzzLog)
if !ok || err != nil {
return
}
// If parsed without error, the same bytes as a data frame must be rejected without panic.
// Reading headers out of a data frame would advance the shared decompression context.
sf := fuzzFrameCopy(parsed)
sf.Ctrl = false
var zr zlibReader
if _, err := sf.parseHeaders(&zr, fuzzLog); err == nil {
t.Fatal("parseHeaders accepted a frame that is not a control frame")
}
// Errors are expected below, but no panics from different control types
for _, typ := range []ControlFrameType{SYN_STREAM, SYN_REPLY, SYN_PING, 0, 3, 4, 5, 7, 8, 9, 0xffff} {
sf := fuzzFrameCopy(parsed)
sf.Ctrl = true
sf.Type = typ
var zr zlibReader
_, _ = sf.parseHeaders(&zr, fuzzLog) // errors expected, but not panics
}
})
}
func FuzzParseHeaders(f *testing.F) {
// One header pair, as sent when a stream is opened
f.Add(fuzzBlock(1, [2]string{"streamtype", "stdout"}))
f.Add(fuzzBlock(1, [2]string{"streamtype", "resize"}))
f.Add(fuzzBlock(3,
[2]string{":method", "GET"},
[2]string{":path", "/api/v1/namespaces/default/pods/x/exec"},
[2]string{"user-agent", "kubectl/v1.30.0"},
))
// A block declaring no headers is valid
f.Add(binary.BigEndian.AppendUint32(nil, 0))
// Headers with 0 byte separation inside the name and values
f.Add(fuzzBlock(1, [2]string{"set-cookie", "a=1\x00b=2\x00c=3"}))
f.Add(fuzzBlock(1, [2]string{"n\x00ame", "v"}))
// Declared count does not match the entries that follow
f.Add(append(binary.BigEndian.AppendUint32(nil, 2), fuzzKV("a", "b")...)) // one pair fewer than declared
f.Add(fuzzBlock(1)) // no pairs after a count of 1
f.Add(fuzzBlock(1, [2]string{"a", "b"}, [2]string{"c", "d"})) // one pair more than declared
f.Add([]byte{0, 0, 0}) // truncated count field
// Duplicate names are rejected when looked up exactly
f.Add(fuzzBlock(2, [2]string{"dup", "1"}, [2]string{"dup", "2"}))
// Case difference so both values land on one header
f.Add(fuzzBlock(2, [2]string{"Foo", "1"}, [2]string{"foo", "2"}))
// Empty names and values still carry length fields
f.Add(fuzzBlock(1, [2]string{"", ""}))
f.Add(fuzzBlock(2, [2]string{"", "v"}, [2]string{"n", ""}))
// Length fields running past the end of the block
f.Add([]byte{0, 0, 0, 1, 0, 0, 0, 8, 'a', 'b'}) // name claims 8 bytes, 2 present
f.Add([]byte{0, 0, 0, 1, 0, 0, 0, 2, 'a', 'b', 0, 0}) // value length cut in half
f.Add([]byte{0, 0, 0, 1, 0, 0, 0, 2, 'a', 'b', 0, 0, 0, 9, 'x'}) // value claims 9 bytes, 1 present
// Zero length fields followed by unrelated bytes
f.Add([]byte{0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 'z', 'z'})
// Names that are not HTTP tokens and text that is not valid UTF-8
f.Add(fuzzBlock(1, [2]string{"foo bar", "v"}))
f.Add(fuzzBlock(1, [2]string{"foo\x00bar\nbaz", "a\nb"}))
f.Add(fuzzBlock(1, [2]string{"\xff\xfe", "\xc3\x28"}))
// Long but legal name and value
f.Add(fuzzBlock(1, [2]string{strings.Repeat("a", 4096), "v"}))
f.Add(fuzzBlock(1, [2]string{"n", strings.Repeat("v", 4096)}))
// A count with the high bit set, ensure limits are enforced on header counts
f.Add(binary.BigEndian.AppendUint32(nil, 0xffff_ffff))
// Exceed max header count
var atCap [][2]string
for i := range maxHeaderCount + 1 {
atCap = append(atCap, [2]string{fuzzName(i), "v"})
}
f.Add(fuzzBlock(maxHeaderCount+1, atCap...))
// A value made only of separators, attempting to produce many values in parser
f.Add(fuzzBlock(1, [2]string{"n", strings.Repeat("\x00", 64<<10)}))
// A decompression bomb: a name length past maxHeaderBlockSize backed by zeros
f.Add(slices.Concat(
binary.BigEndian.AppendUint32(nil, 1), // one pair
binary.BigEndian.AppendUint32(nil, 4<<20), // name claims 4MiB
make([]byte, 4<<20), // backed by compressible zeros
))
f.Fuzz(func(t *testing.T, data []byte) {
var z zlibReader
z.Set(fuzzCompress(data))
h, err := parseHeaders(&z, fuzzLog)
if err != nil {
return
}
var total int
for name, vals := range h {
total += len(name)
if len(vals) == 0 {
t.Fatalf("header %q present with no values", name)
} else if c := http.CanonicalHeaderKey(name); c != name {
t.Fatalf("header name %q is not canonicalized by Add, got %q", name, c)
}
for _, v := range vals {
total += len(v)
if strings.ContainsRune(v, 0) {
t.Fatalf("header %q value %q still holds a 0 byte separator", name, v)
}
}
}
if total > maxHeaderBlockSize {
t.Fatalf("parsed %d bytes of headers out of one block, maximum is %d", total, maxHeaderBlockSize)
}
})
}
// fuzzChunks splits the bytes into roughly equal parts, mimicking frames arriving across several reads.
func fuzzChunks(b []byte, n int) [][]byte {
if n <= 1 || len(b) == 0 {
return [][]byte{b}
}
step := max(1, (len(b)+n-1)/n)
out := make([][]byte, 0, n)
for i := 0; i < len(b); i += step {
out = append(out, b[i:min(i+step, len(b))])
}
return out
}
// fuzzConn returns a conn over tc that records to a throwaway recorder. The stored
// stream IDs match the seeds so mutated frames still land on streams we care about.
func fuzzConn(t *testing.T, tc *fakes.TestConn, hasTerm bool) *conn {
t.Helper()
cl := tstest.NewClock(tstest.ClockOpts{})
c := &conn{
Conn: tc,
ctx: t.Context(),
rec: tsrecorder.New(&fakes.TestSessionRecorder{}, cl, cl.Now(), true, fuzzLog),
log: fuzzLog,
hasTerm: hasTerm,
initialCastHeaderSent: make(chan struct{}),
}
c.stdoutStreamID.Store(fuzzStdoutStreamID)
c.stderrStreamID.Store(fuzzStderrStreamID)
c.resizeStreamID.Store(fuzzResizeStreamID)
return c
}
func FuzzConnRead(f *testing.F) {
resize := fuzzDataFrame(fuzzResizeStreamID, []byte(`{"width":80,"height":24}`))
synStdout := fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(fuzzStdoutStreamID, [2]string{"streamtype", "stdout"}))
synResize := fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(fuzzResizeStreamID, [2]string{"streamtype", "resize"}))
// A resize message on the resize stream: sets terminal size and sends the
// CastHeader on a session with a TTY attached
f.Add(resize, true, uint8(1))
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte(`{"height":24,"width":80}`)), false, uint8(1))
// Malformed resize payloads: JSON that is not an object, wrong value types and
// numbers out of int range
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte("")), true, uint8(1))
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte("{")), true, uint8(1))
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte("null")), true, uint8(1))
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte("[0,0]")), true, uint8(1))
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte(`{"width":"wide","height":null}`)), true, uint8(1))
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte(`{"width":-1,"height":-1}`)), true, uint8(1))
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte(`{"width":9223372036854775808}`)), true, uint8(1))
// A resize frame whose JSON payload is cut off mid object
f.Add(append(slices.Clone(resize[:len(resize)-1]), '{'), true, uint8(1))
// Stream opening frames: stdout, stderr and resize IDs get stored
f.Add(synStdout, true, uint8(1))
f.Add(fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(fuzzStderrStreamID, [2]string{"streamtype", "stderr"})), true, uint8(1))
f.Add(synResize, true, uint8(1))
// Stream types that are not recorded must still be parsed
f.Add(fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(7, [2]string{"streamtype", "stdin"})), true, uint8(1))
f.Add(fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(8, [2]string{"streamtype", "\x00"})), true, uint8(1))
// A stdout stream opened above ID 127: SYN_STREAM and data frames both keep
// 31 bits, so its output matches the stored ID and is recorded
f.Add(slices.Concat(
fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(300, [2]string{"streamtype", "stdout"})),
fuzzDataFrame(300, []byte("output on the stored ID"))), true, uint8(1))
// A frame on stream 259 does not match the resize stream 3: IDs must be
// equal on all 31 bits, so its payload is not parsed as a resize message
f.Add(fuzzDataFrame(259, []byte(`{"width":1,"height":1}`)), true, uint8(1))
// A SYN_STREAM whose ID field has the X flag bit set: storeStreamID drops
// the flag and keeps the 31 bit ID, so data frames on stream 3 still match
f.Add(slices.Concat(
fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(0x80000003, [2]string{"streamtype", "resize"})),
fuzzDataFrame(3, []byte(`{"width":1,"height":1}`))), true, uint8(1))
// A session opening: SYN_REPLY plus stream setup plus output and resize frames,
// sharing one decompression context across reads
f.Add(slices.Concat(
fuzzCtrlFrame(3, SYN_REPLY, fuzzSynReply(fuzzStdoutStreamID, [2]string{"status", "200"})),
synStdout, synResize, fuzzDataFrame(fuzzStdoutStreamID, []byte("hello")), resize), true, uint8(3))
f.Add(slices.Concat(synResize, resize, resize), true, uint8(2))
// The same session without a TTY: resize messages are not parsed
f.Add(slices.Concat(synResize, resize), false, uint8(4))
// A SYN_STREAM whose header block is a bomb: the pair count and the name length claim far
// more than maxHeaderBlockSize, backed by zeros. conn parses headers for every control
// frame, so this must fail or stay bounded rather than expand.
f.Add(fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStreamBlock(fuzzStdoutStreamID, slices.Concat(
binary.BigEndian.AppendUint32(nil, maxHeaderCount+1),
make([]byte, 4<<20),
))), true, uint8(1))
f.Add(fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStreamBlock(fuzzStdoutStreamID, slices.Concat(
binary.BigEndian.AppendUint32(nil, 1),
binary.BigEndian.AppendUint32(nil, 1<<20),
make([]byte, 1<<20),
))), true, uint8(1))
// A SYN_REPLY whose block declares a count with the high bit set
f.Add(fuzzCtrlFrame(3, SYN_REPLY, slices.Concat(
[]byte{0, 0, 0, 1}, fuzzCompress(binary.BigEndian.AppendUint32(nil, 0x8000_0000)))), true, uint8(1))
// A SYN_STREAM whose compressed header block is cut off mid stream
f.Add(fuzzCtrlFrame(3, SYN_STREAM, append(make([]byte, 10), 0x78, 0x9c, 0x63)), true, uint8(2))
// Non-SPDY bytes on a hijacked connection: a TLS record header parses as a
// data frame matching no stored stream, while plain HTTP parses as a data
// frame header with a huge claimed length and is buffered as incomplete
f.Add([]byte{0x16, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}, true, uint8(1))
f.Add([]byte("HTTP/1.1 200 OK\r\n\r\n"), true, uint8(1))
f.Fuzz(func(t *testing.T, data []byte, hasTerm bool, parts uint8) {
tc := &fakes.TestConn{}
c := fuzzConn(t, tc, hasTerm)
for _, chunk := range fuzzChunks(data, int(parts)%4+1) {
if err := tc.WriteReadBufBytes(chunk); err != nil {
t.Fatalf("writing bytes to test conn: %v", err)
}
if n, err := c.Read(make([]byte, len(chunk))); err != nil {
continue // unparseable frames and truncated resize messages are fine
} else if n != len(chunk) {
t.Fatalf("Read returned %d bytes, want %d", n, len(chunk))
}
}
})
}
func FuzzConnWrite(f *testing.F) {
out := fuzzDataFrame(fuzzStdoutStreamID, []byte("hello"))
errF := fuzzDataFrame(fuzzStderrStreamID, []byte("boom"))
// Output on the recorded streams, including empty payloads
f.Add(out, uint8(1))
f.Add(errF, uint8(1))
f.Add(fuzzDataFrame(fuzzStdoutStreamID, nil), uint8(1))
f.Add(fuzzDataFrame(fuzzResizeStreamID, []byte(`{"width":80,"height":24}`)), uint8(1)) // not a recorded stream
// Data frames whose IDs differ from stdout's ID 1 above bit 7: data frames
// keep 31 bits, so these are distinct streams and are not recorded
f.Add(fuzzDataFrame(129, []byte("distinct from stdout")), uint8(1))
f.Add(fuzzDataFrame(0x1000001, []byte("also distinct from stdout")), uint8(1))
// Control frames carry no output but must be forwarded whole
f.Add(fuzzCtrlFrame(3, SYN_STREAM, fuzzSynStream(fuzzStdoutStreamID, [2]string{"streamtype", "stdout"})), uint8(1))
f.Add(fuzzCtrlFrame(3, SYN_REPLY, fuzzSynReply(0, [2]string{"status", "200"})), uint8(1))
f.Add(fuzzCtrlFrame(3, SYN_PING, []byte{0, 0, 0, 7}), uint8(1))
// Payload bytes that are invalid UTF-8
f.Add(fuzzDataFrame(fuzzStdoutStreamID, []byte("\xff\xfe\x00\x01\n\r\"\\")), uint8(1))
// A frame whose length field lies about the payload present
f.Add([]byte{0x00, 0x00, 0x00, 1, 0x00, 0xff, 0xff, 0xff}, uint8(1))
// Incomplete header
f.Add(out[:4], uint8(1))
// Partial payload
f.Add(out[:len(out)-2], uint8(1))
// Several frames that must be forwarded whole and in order across writes
f.Add(slices.Concat(out, errF, out), uint8(4))
// Plain HTTP parses as a data frame header with a huge claimed length
f.Add([]byte("GET / HTTP/1.1\r\n"), uint8(1))
f.Fuzz(func(t *testing.T, data []byte, parts uint8) {
tc := &fakes.TestConn{}
c := fuzzConn(t, tc, false)
// Output can only be recorded once the CastHeader is out.
// Leaving it open would park every stdout frame on ctx.
c.writeCastHeaderOnce.Do(func() { close(c.initialCastHeaderSent) })
for _, chunk := range fuzzChunks(data, int(parts)%4+1) {
if n, err := c.Write(chunk); err != nil {
return
} else if n != len(chunk) {
t.Fatalf("Write returned %d, want %d", n, len(chunk))
}
}
})
}