From 5caa33e7b955368584d6b17724126216589ddbe1 Mon Sep 17 00:00:00 2001 From: Michael Eischer Date: Sat, 16 May 2026 13:04:07 +0200 Subject: [PATCH] repository/pack: prevent packer usage after error In-depth hardening to prevent packer reuse after an error. --- internal/repository/pack/pack.go | 40 +++++++++++++++++++++------ internal/repository/pack/pack_test.go | 25 +++++++++++++++++ 2 files changed, 57 insertions(+), 8 deletions(-) diff --git a/internal/repository/pack/pack.go b/internal/repository/pack/pack.go index 4771d125d..9f5a576d8 100644 --- a/internal/repository/pack/pack.go +++ b/internal/repository/pack/pack.go @@ -15,6 +15,10 @@ import ( "github.com/restic/restic/internal/crypto" ) +// ErrBroken is returned by Add and Finalize after a write error. The packer +// must not be used again. +var ErrBroken = errors.New("packer cannot be used after a write error") + // Packer is used to create a new Pack. type Packer struct { blobs []restic.Blob @@ -22,6 +26,7 @@ type Packer struct { bytes uint k *crypto.Key wr io.Writer + err error // packer is unusable after the first error m sync.Mutex } @@ -37,17 +42,30 @@ func (p *Packer) Add(t restic.BlobType, id restic.ID, data []byte, uncompressedL p.m.Lock() defer p.m.Unlock() - c := restic.Blob{BlobHandle: restic.BlobHandle{Type: t, ID: id}} + if p.err != nil { + return 0, errors.Join(ErrBroken, p.err) + } n, err := p.wr.Write(data) - c.Length = uint(n) - c.Offset = p.bytes - c.UncompressedLength = uint(uncompressedLength) + if err != nil { + p.err = errors.Wrap(err, "Write") + return n, p.err + } + if n != len(data) { + p.err = errors.New("short write") + return n, p.err + } + + c := restic.Blob{ + BlobHandle: restic.BlobHandle{Type: t, ID: id}, + Length: uint(n), + Offset: p.bytes, + UncompressedLength: uint(uncompressedLength), + } p.bytes += uint(n) p.blobs = append(p.blobs, c) - n += CalculateEntrySize(c) - return n, errors.Wrap(err, "Write") + return n + CalculateEntrySize(c), nil } var entrySize = uint(binary.Size(restic.BlobType(0)) + 2*headerLengthSize + len(restic.ID{})) @@ -75,6 +93,10 @@ func (p *Packer) Finalize() error { p.m.Lock() defer p.m.Unlock() + if p.err != nil { + return errors.Join(ErrBroken, p.err) + } + header, err := makeHeader(p.blobs) if err != nil { return err @@ -94,11 +116,13 @@ func (p *Packer) Finalize() error { // append the header n, err := p.wr.Write(encryptedHeader) if err != nil { - return errors.Wrap(err, "Write") + p.err = errors.Wrap(err, "Write") + return p.err } if n != len(encryptedHeader) { - return errors.New("wrong number of bytes written") + p.err = errors.New("wrong number of bytes written") + return p.err } p.bytes += uint(len(encryptedHeader)) diff --git a/internal/repository/pack/pack_test.go b/internal/repository/pack/pack_test.go index e5e61330b..897aeddfe 100644 --- a/internal/repository/pack/pack_test.go +++ b/internal/repository/pack/pack_test.go @@ -12,6 +12,7 @@ import ( "github.com/restic/restic/internal/backend" "github.com/restic/restic/internal/backend/mem" "github.com/restic/restic/internal/crypto" + "github.com/restic/restic/internal/errors" "github.com/restic/restic/internal/repository/pack" "github.com/restic/restic/internal/restic" rtest "github.com/restic/restic/internal/test" @@ -149,6 +150,30 @@ func TestShortPack(t *testing.T) { verifyBlobs(t, bufs, k, backend.ReaderAt(context.TODO(), b, handle), packSize) } +type failWriter struct{} + +func (failWriter) Write([]byte) (int, error) { + return 0, errors.New("test error") +} + +func TestPackerBroken(t *testing.T) { + k := crypto.NewRandomKey() + p := pack.NewPacker(k, failWriter{}) + + bufs := createBuffers(t, []int{100}) + + _, err := p.Add(restic.DataBlob, bufs[0].id, bufs[0].data, 0) + rtest.Assert(t, err != nil, "expected error on first Add") + rtest.Assert(t, !errors.Is(err, pack.ErrBroken), "first error must not be ErrBroken: %v", err) + rtest.Equals(t, 0, p.Count()) + + _, err = p.Add(restic.DataBlob, bufs[0].id, bufs[0].data, 0) + rtest.Assert(t, errors.Is(err, pack.ErrBroken), "expected ErrBroken on reuse, got %v", err) + + err = p.Finalize() + rtest.Assert(t, errors.Is(err, pack.ErrBroken), "expected ErrBroken from Finalize, got %v", err) +} + func TestPackMerge(t *testing.T) { k := crypto.NewRandomKey()