1 files changed, 98 insertions, 0 deletions
diff --git a/internal/format/packfile/delta/header.go b/internal/format/packfile/delta/header.go
new file mode 100644
index 00000000..d5dd93fb
--- /dev/null
+++ b/internal/format/packfile/delta/header.go
@@ -0,0 +1,98 @@
+package delta
+
+import (
+	"errors"
+	"fmt"
+)
+
+// ErrMalformedDelta reports that
+// a delta payload is truncated, overlong,
+// declares sizes that overflow uint64,
+// contains invalid instructions,
+// or does not match the supplied base or declared sizes.
+var ErrMalformedDelta = errors.New("internal/format/packfile/delta: malformed delta")
+
+// MaxSizeVarintLen is the maximum encoded length
+// of one delta header size varint.
+// Every uint64 size is encodable within this bound,
+// and parsing rejects longer encodings.
+const MaxSizeVarintLen = 10
+
+// MaxHeaderSizesLen is the maximum encoded length
+// of the base/result size header of a delta payload.
+//
+// Callers reading a delta from a stream may inflate
+// MaxHeaderSizesLen bytes
+// (or fewer if the payload ends sooner)
+// and parse with [ParseHeaderSizes];
+// no valid header is longer.
+const MaxHeaderSizesLen = 2 * MaxSizeVarintLen
+
+// ParseHeaderSizes parses the base size and result size varints
+// at the beginning of one inflated delta payload.
+func ParseHeaderSizes(data []byte) (baseSize, resultSize uint64, consumed int, err error) {
+	baseSize, consumed, err = parseSizeVarint(data, 0)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	resultSize, consumed, err = parseSizeVarint(data, consumed)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	return baseSize, resultSize, consumed, nil
+}
+
+// AppendHeaderSizes appends the base/result size header encoding
+// of one delta payload to dst.
+func AppendHeaderSizes(dst []byte, baseSize, resultSize uint64) []byte {
+	dst = appendSizeVarint(dst, baseSize)
+
+	return appendSizeVarint(dst, resultSize)
+}
+
+// appendSizeVarint appends the encoding of one delta header size varint to dst.
+func appendSizeVarint(dst []byte, value uint64) []byte {
+	for value >= 0x80 {
+		dst = append(dst, byte(value)|0x80)
+		value >>= 7
+	}
+
+	return append(dst, byte(value))
+}
+
+// parseSizeVarint parses one delta header size varint
+// beginning at pos,
+// and returns the position past it.
+func parseSizeVarint(data []byte, pos int) (value uint64, consumed int, err error) {
+	start := pos
+
+	shift := uint(0)
+
+	for {
+		if pos-start >= MaxSizeVarintLen {
+			return 0, 0, fmt.Errorf("%w: overlong size varint", ErrMalformedDelta)
+		}
+
+		if pos >= len(data) {
+			return 0, 0, fmt.Errorf("%w: truncated size varint", ErrMalformedDelta)
+		}
+
+		b := data[pos]
+		pos++
+
+		group := uint64(b & 0x7f)
+		if group<<shift>>shift != group {
+			return 0, 0, fmt.Errorf("%w: size overflows uint64", ErrMalformedDelta)
+		}
+
+		value |= group << shift
+
+		if b&0x80 == 0 {
+			return value, pos, nil
+		}
+
+		shift += 7
+	}
+}