Find, verify, and analyze leaked credentials
Go credentialsdevsecopsdynamic-analysisprecommitscanningsecretsecret-managementsecretssecuritysecurity-toolstrufflehogverification
[bug]- Invalid Seek for Non-Seekable Readers (#3095)
ahravebfbd21707e6
diff --git a/pkg/handlers/ar_test.go b/pkg/handlers/ar_test.goindex 430fc4e73..59285ca47 100644--- a/pkg/handlers/ar_test.go+++ b/pkg/handlers/ar_test.go@@ -20,6 +20,7 @@ func TestHandleARFile(t *testing.T) {rdr, err := newFileReader(file)assert.NoError(t, err)+ defer rdr.Close()handler := newARHandler()archiveChan, err := handler.HandleFile(context.AddLogger(ctx), rdr)diff --git a/pkg/handlers/archive.go b/pkg/handlers/archive.goindex 89f44eb1d..df539a43c 100644--- a/pkg/handlers/archive.go+++ b/pkg/handlers/archive.go@@ -111,6 +111,7 @@ func (h *archiveHandler) openArchive(ctx logContext.Context, depth int, reader f}return fmt.Errorf("error creating custom reader: %w", err)}+ defer rdr.Close()return h.openArchive(ctx, depth+1, rdr, archiveChan)case archiver.Extractor:@@ -194,6 +195,7 @@ func (h *archiveHandler) extractorHandler(archiveChan chan []byte) func(context.}return fmt.Errorf("error creating custom reader: %w", err)}+ defer rdr.Close()h.metrics.incFilesProcessed()h.metrics.observeFileSize(fileSize)diff --git a/pkg/handlers/archive_test.go b/pkg/handlers/archive_test.goindex 0bde50470..a24ab98a1 100644--- a/pkg/handlers/archive_test.go+++ b/pkg/handlers/archive_test.go@@ -89,6 +89,8 @@ func TestArchiveHandler(t *testing.T) {if err != nil {t.Errorf("error creating reusable reader: %s", err)}+ defer newReader.Close()+archiveChan, err := handler.HandleFile(logContext.Background(), newReader)if testCase.expectErr {assert.NoError(t, err)@@ -119,6 +121,7 @@ func TestOpenInvalidArchive(t *testing.T) {rdr, err := newFileReader(io.NopCloser(reader))assert.NoError(t, err)+ defer rdr.Close()archiveChan := make(chan []byte)diff --git a/pkg/handlers/default_test.go b/pkg/handlers/default_test.goindex b4aa15333..3d071ad6f 100644--- a/pkg/handlers/default_test.go+++ b/pkg/handlers/default_test.go@@ -20,6 +20,7 @@ func TestHandleNonArchiveFile(t *testing.T) {rdr, err := newFileReader(file)assert.NoError(t, err)+ defer rdr.Close()handler := newDefaultHandler(defaultHandlerType)archiveChan, err := handler.HandleFile(context.AddLogger(ctx), rdr)diff --git a/pkg/handlers/handlers.go b/pkg/handlers/handlers.goindex 748bf7bf3..169133043 100644--- a/pkg/handlers/handlers.go+++ b/pkg/handlers/handlers.go@@ -59,7 +59,7 @@ func newMimeTypeReaderFromFileReader(r fileReader) mimeTypeReader {// newMimeTypeReader creates a new mimeTypeReader from an io.Reader.// It uses a bufio.Reader to perform MIME type detection on the input reader-// without consuming it, by peeking into the first 512 bytes of the input.+// without consuming it, by peeking into the first 3072 bytes of the input.// This encapsulates both the original reader and the detected MIME type information.// This function is particularly useful for specialized archive handlers// that need to pass extracted content to the default handler without modifying the original reader.@@ -84,10 +84,6 @@ func newFileReader(r io.Reader) (fileReader, error) {fReader.BufferedReadSeeker = iobuf.NewBufferedReaderSeeker(r)- // Disable buffering after initial reads.- // This optimization ensures we don't continue writing to the buffer after the initial reads.- defer fReader.DisableBuffering()-mime, err := mimetype.DetectReader(fReader)if err != nil {return fReader, fmt.Errorf("unable to detect MIME type: %w", err)@@ -281,6 +277,7 @@ func HandleFile(}return fmt.Errorf("error creating custom reader: %w", err)}+ defer rdr.Close()mimeT := mimeType(rdr.mime.String())config := newFileHandlingConfig(options...)diff --git a/pkg/handlers/handlers_test.go b/pkg/handlers/handlers_test.goindex 31821dfee..f86678aaf 100644--- a/pkg/handlers/handlers_test.go+++ b/pkg/handlers/handlers_test.go@@ -27,21 +27,101 @@ func TestHandleFileCancelledContext(t *testing.T) {}func TestHandleFile(t *testing.T) {- reporter := sources.ChanReporter{Ch: make(chan *sources.Chunk, 2)}+ reporter := sources.ChanReporter{Ch: make(chan *sources.Chunk, 513)}// Only one chunk is sent on the channel.// TODO: Embed a zip without making an HTTP request.resp, err := http.Get("https://raw.githubusercontent.com/bill-rich/bad-secrets/master/aws-canary-creds.zip")assert.NoError(t, err)- if resp != nil && resp.Body != nil {- defer resp.Body.Close()- }+ defer func() {+ if resp != nil && resp.Body != nil {+ resp.Body.Close()+ }+ }()assert.Equal(t, 0, len(reporter.Ch))assert.NoError(t, HandleFile(context.Background(), resp.Body, &sources.Chunk{}, reporter))assert.Equal(t, 1, len(reporter.Ch))}+func TestHandleHTTPJson(t *testing.T) {+ resp, err := http.Get("https://raw.githubusercontent.com/ahrav/nothing-to-see-here/main/sm_random_data.json")+ assert.NoError(t, err)+ defer func() {+ if resp != nil && resp.Body != nil {+ resp.Body.Close()+ }+ }()++ chunkCh := make(chan *sources.Chunk, 1)+ go func() {+ defer close(chunkCh)+ err := HandleFile(logContext.Background(), resp.Body, &sources.Chunk{}, sources.ChanReporter{Ch: chunkCh})+ assert.NoError(t, err)+ }()++ wantCount := 513+ count := 0+ for range chunkCh {+ count+++ }+ assert.Equal(t, wantCount, count)+}++func TestHandleHTTPJsonZip(t *testing.T) {+ resp, err := http.Get("https://raw.githubusercontent.com/ahrav/nothing-to-see-here/main/sm.zip")+ assert.NoError(t, err)+ defer func() {+ if resp != nil && resp.Body != nil {+ resp.Body.Close()+ }+ }()++ chunkCh := make(chan *sources.Chunk, 1)+ go func() {+ defer close(chunkCh)+ err := HandleFile(logContext.Background(), resp.Body, &sources.Chunk{}, sources.ChanReporter{Ch: chunkCh})+ assert.NoError(t, err)+ }()++ wantCount := 513+ count := 0+ for range chunkCh {+ count+++ }+ assert.Equal(t, wantCount, count)+}++func BenchmarkHandleHTTPJsonZip(b *testing.B) {+ b.ReportAllocs()+ for i := 0; i < b.N; i++ {+ func() {+ resp, err := http.Get("https://raw.githubusercontent.com/ahrav/nothing-to-see-here/main/sm.zip")+ assert.NoError(b, err)++ defer func() {+ if resp != nil && resp.Body != nil {+ resp.Body.Close()+ }+ }()++ chunkCh := make(chan *sources.Chunk, 1)++ b.StartTimer()+ go func() {+ defer close(chunkCh)+ err := HandleFile(logContext.Background(), resp.Body, &sources.Chunk{}, sources.ChanReporter{Ch: chunkCh})+ assert.NoError(b, err)+ }()++ for range chunkCh {+ }++ b.StopTimer()+ }()+ }+}+func BenchmarkHandleFile(b *testing.B) {file, err := os.Open("testdata/test.tgz")assert.Nil(b, err)diff --git a/pkg/handlers/rpm_test.go b/pkg/handlers/rpm_test.goindex 7ef1a1c82..f90d7b672 100644--- a/pkg/handlers/rpm_test.go+++ b/pkg/handlers/rpm_test.go@@ -20,6 +20,7 @@ func TestHandleRPMFile(t *testing.T) {rdr, err := newFileReader(file)assert.NoError(t, err)+ defer rdr.Close()handler := newRPMHandler()archiveChan, err := handler.HandleFile(context.AddLogger(ctx), rdr)diff --git a/pkg/iobuf/bufferedreaderseeker.go b/pkg/iobuf/bufferedreaderseeker.goindex 9db909fc3..5480beae7 100644--- a/pkg/iobuf/bufferedreaderseeker.go+++ b/pkg/iobuf/bufferedreaderseeker.go@@ -1,123 +1,144 @@package iobufimport (- "bytes""errors"- "fmt""io"+ "os"++ "github.com/trufflesecurity/trufflehog/v3/pkg/buffers/buffer"+ "github.com/trufflesecurity/trufflehog/v3/pkg/buffers/pool"+ "github.com/trufflesecurity/trufflehog/v3/pkg/cleantemp")+const defaultBufferSize = 1 << 16 // 64KB++var defaultBufferPool *pool.Pool++func init() { defaultBufferPool = pool.NewBufferPool(defaultBufferSize) }+// BufferedReadSeeker provides a buffered reading interface with seeking capabilities.// It wraps an io.Reader and optionally an io.Seeker, allowing for efficient// reading and seeking operations, even on non-seekable underlying readers.+//+// For small amounts of data, it uses an in-memory buffer (bytes.Buffer) to store+// read bytes. When the amount of data exceeds a specified threshold, it switches+// to disk-based buffering using a temporary file. This approach balances memory+// usage and performance, allowing efficient handling of both small and large data streams.+//+// The struct manages the transition between in-memory and disk-based buffering+// transparently, providing a seamless reading and seeking experience regardless+// of the underlying data size or the seekability of the original reader.+//+// If the underlying reader is seekable, direct seeking operations are performed+// on it. For non-seekable readers, seeking is emulated using the buffer or+// temporary file.type BufferedReadSeeker struct {reader io.Readerseeker io.Seeker // If the reader supports seeking, it's stored here for direct access- buffer *bytes.Buffer // Internal buffer to store read bytes for non-seekable readers+ bufPool *pool.Pool // Pool for storing buffers for reuse.+ buf *buffer.Buffer // Buffer for storing data under the threshold in memory.bytesRead int64 // Total number of bytes read from the underlying readerindex int64 // Current position in the virtual stream- // Flag to control buffering. This flag is used to indicate whether buffering is active.- // Buffering is enabled during initial reads (e.g., for MIME type detection and format identification).- // Once these operations are done, buffering should be disabled to prevent further writes to the buffer- // and to optimize subsequent reads directly from the underlying reader. This helps avoid excessive- // memory usage while still providing the necessary functionality for initial detection operations.- activeBuffering bool+ threshold int64 // Threshold for switching to file buffering+ tempFile *os.File // Temporary file for disk-based buffering+ tempFileName string // Name of the temporary file+ diskBufferSize int64 // Size of data written to disk++ // Fields to provide a quick way to determine the total size of the reader+ // without having to seek.+ totalSize int64 // Total size of the reader+ sizeKnown bool // Whether the total size of the reader is known}// NewBufferedReaderSeeker creates and initializes a BufferedReadSeeker.// It takes an io.Reader and checks if it supports seeking.// If the reader supports seeking, it is stored in the seeker field.func NewBufferedReaderSeeker(r io.Reader) *BufferedReadSeeker {- var (- seeker io.Seeker- buffer *bytes.Buffer- activeBuffering = true- )- if s, ok := r.(io.Seeker); ok {- seeker = s- activeBuffering = false- }+ const defaultThreshold = 1 << 24 // 16MB threshold for switching to file buffering- const mimeTypeBufferSize = 3072 // Approx buffer size for MIME type detection+ seeker, _ := r.(io.Seeker)+ var buf *buffer.Bufferif seeker == nil {- buffer = bytes.NewBuffer(make([]byte, 0, mimeTypeBufferSize))+ buf = defaultBufferPool.Get()}return &BufferedReadSeeker{- reader: r,- seeker: seeker,- buffer: buffer,- bytesRead: 0,- index: 0,- activeBuffering: activeBuffering,+ reader: r,+ seeker: seeker,+ bufPool: defaultBufferPool,+ buf: buf,+ threshold: defaultThreshold,}}// Read reads len(out) bytes from the reader starting at the current index.// It handles both seekable and non-seekable underlying readers efficiently.func (br *BufferedReadSeeker) Read(out []byte) (int, error) {- // For seekable readers, read directly from the underlying reader.if br.seeker != nil {+ // For seekable readers, read directly from the underlying reader.n, err := br.reader.Read(out)- br.index += int64(n)- br.bytesRead = max(br.bytesRead, br.index)+ if n > 0 {+ br.bytesRead += int64(n)+ }return n, err}- // For non-seekable readers, use buffered reading.- outLen := int64(len(out))- if outLen == 0 {- return 0, nil- }+ var (+ totalBytesRead int+ err error+ )- // If the current read position (br.index) is within the buffer's valid data range,- // read from the buffer. This ensures previously read data (e.g., for mime type detection)- // is included in subsequent reads, providing a consistent view of the reader's content.- if br.index < int64(br.buffer.Len()) {- n := copy(out, br.buffer.Bytes()[br.index:])- br.index += int64(n)- return n, nil+ // If the current read position is within the in-memory buffer.+ if br.index < int64(br.buf.Len()) {+ totalBytesRead = copy(out, br.buf.Bytes()[br.index:])+ br.index += int64(totalBytesRead)+ if totalBytesRead == len(out) {+ return totalBytesRead, nil+ }+ out = out[totalBytesRead:]}- if !br.activeBuffering {- // If buffering is not active, read directly from the underlying reader.- n, err := br.reader.Read(out)- br.index += int64(n)- br.bytesRead = max(br.bytesRead, br.index)- return n, err+ // If we've exceeded the in-memory threshold and have a temp file.+ if br.tempFile != nil && br.index < br.diskBufferSize {+ if _, err := br.tempFile.Seek(br.index-int64(br.buf.Len()), io.SeekStart); err != nil {+ return totalBytesRead, err+ }+ m, err := br.tempFile.Read(out)+ totalBytesRead += m+ br.index += int64(m)+ if err != nil && !errors.Is(err, io.EOF) {+ return totalBytesRead, err+ }+ if totalBytesRead == len(out) {+ return totalBytesRead, nil+ }+ out = out[totalBytesRead:]}- // Ensure there are enough bytes in the buffer to read from.- if outLen+br.index > int64(br.buffer.Len()) {- bytesToRead := int(outLen + br.index - int64(br.buffer.Len()))- readerBytes := make([]byte, bytesToRead)- n, err := br.reader.Read(readerBytes)- br.buffer.Write(readerBytes[:n])- br.bytesRead += int64(n)-- if err != nil {- return n, err- }+ if len(out) == 0 {+ return totalBytesRead, nil}- // Ensure the read does not exceed the buffer length.- endIndex := br.index + outLen- bufLen := int64(br.buffer.Len())- if endIndex > bufLen {- endIndex = bufLen+ // If we still need to read more data.+ var raderBytes int+ raderBytes, err = br.reader.Read(out)+ totalBytesRead += raderBytes+ br.index += int64(raderBytes)++ if writeErr := br.writeData(out[:raderBytes]); writeErr != nil {+ return totalBytesRead, writeErr}- if br.index >= bufLen {- return 0, io.EOF+ if errors.Is(err, io.EOF) {+ br.totalSize = br.bytesRead+ br.sizeKnown = true}- n := copy(out, br.buffer.Bytes()[br.index:endIndex])- br.index += int64(n)- return n, nil+ return totalBytesRead, err}// Seek sets the offset for the next Read or Write to offset.@@ -125,45 +146,25 @@ func (br *BufferedReadSeeker) Read(out []byte) (int, error) {func (br *BufferedReadSeeker) Seek(offset int64, whence int) (int64, error) {if br.seeker != nil {// Use the underlying Seeker if available.- newIndex, err := br.seeker.Seek(offset, whence)- if err != nil {- return 0, fmt.Errorf("error seeking in reader: %w", err)- }- if newIndex > br.bytesRead {- br.bytesRead = newIndex- }- return newIndex, nil+ return br.seeker.Seek(offset, whence)}// Manual seeking for non-seekable readers.newIndex := br.index- const bufferSize = 64 * 1024 // 64KB chunk size for reading-switch whence {case io.SeekStart:newIndex = offsetcase io.SeekCurrent:newIndex += offsetcase io.SeekEnd:- // Read the entire reader to determine its length- buffer := make([]byte, bufferSize)- for {- n, err := br.reader.Read(buffer)- if n > 0 {- if br.activeBuffering {- br.buffer.Write(buffer[:n])- }- br.bytesRead += int64(n)- }- if errors.Is(err, io.EOF) {- break- }- if err != nil {+ // If we already know the total size, we can use it directly.+ if !br.sizeKnown {+ if err := br.readToEnd(); err != nil {return 0, err}}- newIndex = min(br.bytesRead+offset, br.bytesRead)+ newIndex = br.totalSize + offsetdefault:return 0, errors.New("invalid whence value")}@@ -172,27 +173,161 @@ func (br *BufferedReadSeeker) Seek(offset int64, whence int) (int64, error) {return 0, errors.New("can not seek to before start of reader")}+ // For non-seekable readers, we need to ensure we've read up to the new index.+ if br.seeker == nil && newIndex > br.bytesRead {+ if err := br.readUntil(newIndex); err != nil {+ return 0, err+ }+ }+br.index = newIndex+ // Update bytesRead only if we've moved beyond what we've read so far.+ if br.index > br.bytesRead {+ br.bytesRead = br.index+ }+return newIndex, nil}+func (br *BufferedReadSeeker) readToEnd() error {+ buf := br.bufPool.Get()+ defer br.bufPool.Put(buf)++ for {+ n, err := io.CopyN(buf, br.reader, defaultBufferSize)+ if n > 0 {+ // Write the data from the buffer.+ if writeErr := br.writeData(buf.Bytes()[:n]); writeErr != nil {+ return writeErr+ }+ }+ // Reset the buffer for the next iteration.+ buf.Reset()+ if errors.Is(err, io.EOF) {+ break+ }+ if err != nil {+ return err+ }+ }+ br.totalSize = br.bytesRead+ br.sizeKnown = true++ return nil+}++func (br *BufferedReadSeeker) writeData(data []byte) error {+ _, err := br.buf.Write(data)+ if err != nil {+ return err+ }+ br.bytesRead += int64(len(data))++ // Check if we've reached or exceeded the threshold.+ if br.buf.Len() < int(br.threshold) {+ return nil+ }++ if br.tempFile == nil {+ if err := br.createTempFile(); err != nil {+ return err+ }+ }++ // Flush the buffer to disk.+ return br.flushBufferToDisk()+}++func (br *BufferedReadSeeker) readUntil(index int64) error {+ buf := br.bufPool.Get()+ defer br.bufPool.Put(buf)++ for br.bytesRead < index {+ remaining := index - br.bytesRead+ bufSize := int64(defaultBufferSize)+ if remaining < bufSize {+ bufSize = remaining+ }++ n, err := io.CopyN(buf, br, bufSize)+ if err != nil && !errors.Is(err, io.EOF) {+ return err+ }++ if n == 0 {+ break+ }++ buf.Reset()+ }++ return nil+}++func (br *BufferedReadSeeker) createTempFile() error {+ tempFile, err := os.CreateTemp(os.TempDir(), cleantemp.MkFilename())+ if err != nil {+ return err+ }+ br.tempFile = tempFile+ br.tempFileName = tempFile.Name()++ return nil+}++func (br *BufferedReadSeeker) flushBufferToDisk() error {+ if _, err := br.buf.WriteTo(br.tempFile); err != nil {+ return err+ }+ br.diskBufferSize = int64(br.buf.Len())++ return nil+}+// ReadAt reads len(out) bytes into out starting at offset off in the underlying input source.// It uses Seek and Read to implement random access reading.func (br *BufferedReadSeeker) ReadAt(out []byte, offset int64) (int, error) {- startIndex, err := br.Seek(offset, io.SeekStart)- if err != nil {+ if br.seeker != nil {+ // Use the underlying Seeker if available.+ _, err := br.Seek(offset, io.SeekStart)+ if err != nil {+ return 0, err+ }+ return br.Read(out)+ }++ // For non-seekable readers, use our buffering logic.+ currentIndex := br.index++ if _, err := br.Seek(offset, io.SeekStart); err != nil {return 0, err}- if startIndex != offset {- return 0, io.EOF+ n, err := br.Read(out)+ if err != nil {+ return n, err}- return br.Read(out)+ // Seek back to the original position.+ if _, err = br.Seek(currentIndex, io.SeekStart); err != nil {+ return n, err+ }++ return n, err}-// DisableBuffering stops the buffering process.-// This is useful after initial reads (e.g., for MIME type detection and format identification)-// to prevent further writes to the buffer, optimizing subsequent reads.-func (br *BufferedReadSeeker) DisableBuffering() { br.activeBuffering = false }+// Close closes the BufferedReadSeeker and releases any resources used.+// It closes the temporary file if one was created and removes it from disk and+// returns the buffer to the pool.+func (br *BufferedReadSeeker) Close() error {+ if br.buf != nil {+ br.bufPool.Put(br.buf)+ }++ if br.tempFile != nil {+ br.tempFile.Close()+ return os.Remove(br.tempFileName)+ }+ return nil+}diff --git a/pkg/iobuf/bufferedreaderseeker_test.go b/pkg/iobuf/bufferedreaderseeker_test.goindex 50b067b28..4f6f86998 100644--- a/pkg/iobuf/bufferedreaderseeker_test.go+++ b/pkg/iobuf/bufferedreaderseeker_test.go@@ -13,7 +13,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {tests := []struct {name stringreader io.Reader- activeBuffering boolreads []intexpectedReads []intexpectedBytes [][]byte@@ -25,7 +24,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "read from seekable reader",reader: strings.NewReader("test data"),- activeBuffering: true,reads: []int{4},expectedReads: []int{4},expectedBytes: [][]byte{[]byte("test")},@@ -35,7 +33,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "read from non-seekable reader with buffering",reader: bytes.NewBufferString("test data"),- activeBuffering: true,reads: []int{4},expectedReads: []int{4},expectedBytes: [][]byte{[]byte("test")},@@ -46,7 +43,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "read from non-seekable reader without buffering",reader: bytes.NewBufferString("test data"),- activeBuffering: false,reads: []int{4},expectedReads: []int{4},expectedBytes: [][]byte{[]byte("test")},@@ -56,7 +52,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "read beyond buffer",reader: strings.NewReader("test data"),- activeBuffering: true,reads: []int{10},expectedReads: []int{9},expectedBytes: [][]byte{[]byte("test data")},@@ -66,7 +61,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "read with empty reader",reader: strings.NewReader(""),- activeBuffering: true,reads: []int{4},expectedReads: []int{0},expectedBytes: [][]byte{[]byte("")},@@ -77,7 +71,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "read exact buffer size",reader: strings.NewReader("test"),- activeBuffering: true,reads: []int{4},expectedReads: []int{4},expectedBytes: [][]byte{[]byte("test")},@@ -87,7 +80,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "read less than buffer size",reader: strings.NewReader("te"),- activeBuffering: true,reads: []int{4},expectedReads: []int{2},expectedBytes: [][]byte{[]byte("te")},@@ -97,7 +89,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "read more than buffer size without buffering",reader: bytes.NewBufferString("test data"),- activeBuffering: false,reads: []int{4},expectedReads: []int{4},expectedBytes: [][]byte{[]byte("test")},@@ -107,7 +98,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "multiple reads with buffering",reader: bytes.NewBufferString("test data"),- activeBuffering: true,reads: []int{4, 5},expectedReads: []int{4, 5},expectedBytes: [][]byte{[]byte("test"), []byte(" data")},@@ -118,7 +108,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {{name: "multiple reads without buffering",reader: bytes.NewBufferString("test data"),- activeBuffering: false,reads: []int{4, 5},expectedReads: []int{4, 5},expectedBytes: [][]byte{[]byte("test"), []byte(" data")},@@ -132,7 +121,6 @@ func TestBufferedReaderSeekerRead(t *testing.T) {t.Parallel()brs := NewBufferedReaderSeeker(tt.reader)- brs.activeBuffering = tt.activeBufferingfor i, readSize := range tt.reads {buf := make([]byte, readSize)@@ -151,10 +139,12 @@ func TestBufferedReaderSeekerRead(t *testing.T) {}assert.Equal(t, tt.expectedBytesRead, brs.bytesRead)- assert.Equal(t, tt.expectedIndex, brs.index)+ if brs.seeker == nil {+ assert.Equal(t, tt.expectedIndex, brs.index)+ }- if brs.buffer != nil && len(tt.expectedBuffer) > 0 {- assert.Equal(t, tt.expectedBuffer, brs.buffer.Bytes())+ if brs.buf != nil && len(tt.expectedBuffer) > 0 {+ assert.Equal(t, tt.expectedBuffer, brs.buf.Bytes())} else {assert.Nil(t, tt.expectedBuffer)}@@ -240,7 +230,7 @@ func TestBufferedReaderSeekerSeek(t *testing.T) {reader: bytes.NewBufferString("test data"),offset: 20,whence: io.SeekEnd,- expectedPos: 9,+ expectedPos: 29,expectedErr: false,expectedRead: []byte{},},