diff --git a/fuzz/oss-fuzz.sh b/fuzz/oss-fuzz.sh index c0ae93dea..aa982ab0d 100755 --- a/fuzz/oss-fuzz.sh +++ b/fuzz/oss-fuzz.sh @@ -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 diff --git a/k8s-operator/sessionrecording/spdy/conn.go b/k8s-operator/sessionrecording/spdy/conn.go index 682003055..0a41a80b7 100644 --- a/k8s-operator/sessionrecording/spdy/conn.go +++ b/k8s-operator/sessionrecording/spdy/conn.go @@ -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) diff --git a/k8s-operator/sessionrecording/spdy/frame.go b/k8s-operator/sessionrecording/spdy/frame.go index 3ca661e0b..e9a129dbe 100644 --- a/k8s-operator/sessionrecording/spdy/frame.go +++ b/k8s-operator/sessionrecording/spdy/frame.go @@ -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. diff --git a/k8s-operator/sessionrecording/spdy/frame_test.go b/k8s-operator/sessionrecording/spdy/frame_test.go index 1b7e54f4c..880a420d5 100644 --- a/k8s-operator/sessionrecording/spdy/frame_test.go +++ b/k8s-operator/sessionrecording/spdy/frame_test.go @@ -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) { diff --git a/k8s-operator/sessionrecording/spdy/fuzz_test.go b/k8s-operator/sessionrecording/spdy/fuzz_test.go new file mode 100644 index 000000000..734302a48 --- /dev/null +++ b/k8s-operator/sessionrecording/spdy/fuzz_test.go @@ -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)) + } + } + }) +}