pack: support SHA-256 in v1 indices

Let's add support for handling SHA-256 in v1 indices by adjusting our
buffer size and computing the offsets base on the hash length.  Update
our tests to be less SHA-1 centric by creating a new index for each test
with appropriate test data.

Co-authored-by: Chris Darroch <chrisd8088@github.com>

Author: bk2204

pack/index_v1.go

@@ -13,19 +13,22 @@ type V1 struct {
 // Name implements IndexVersion.Name by returning the 20 byte SHA-1 object name
 // for the given entry at offset "at" in the v1 index file "idx".
 func (v *V1) Name(idx *Index, at int64) ([]byte, error) {
-	var sha [20]byte
-	if _, err := idx.readAt(sha[:], v1ShaOffset(at)); err != nil {
+	var sha [maxHashSize]byte
+
+	hashlen := v.hash.Size()
+
+	if _, err := idx.readAt(sha[:hashlen], v1ShaOffset(at, int64(hashlen))); err != nil {
 		return nil, err
 	}
 
-	return sha[:], nil
+	return sha[:hashlen], nil
 }
 
 // Entry implements IndexVersion.Entry for v1 packfiles by parsing and returning
 // the IndexEntry specified at the offset "at" in the given index file.
 func (v *V1) Entry(idx *Index, at int64) (*IndexEntry, error) {
 	var offs [4]byte
-	if _, err := idx.readAt(offs[:], v1EntryOffset(at)); err != nil {
+	if _, err := idx.readAt(offs[:], v1EntryOffset(at, int64(v.hash.Size()))); err != nil {
 		return nil, err
 	}
 
@@ -41,19 +44,19 @@ func (v *V1) Width() int64 {
 }
 
 // v1ShaOffset returns the location of the SHA1 of an object given at "at".
-func v1ShaOffset(at int64) int64 {
+func v1ShaOffset(at int64, hashlen int64) int64 {
 	// Skip forward until the desired entry.
-	return v1EntryOffset(at) +
+	return v1EntryOffset(at, hashlen) +
 		// Skip past the 4-byte object offset in the desired entry to
 		// the SHA1.
 		indexObjectSmallOffsetWidth
 }
 
 // v1EntryOffset returns the location of the packfile offset for the object
 // given at "at".
-func v1EntryOffset(at int64) int64 {
+func v1EntryOffset(at int64, hashlen int64) int64 {
 	// Skip the L1 fanout table
 	return indexOffsetV1Start +
 		// Skip the object entries before the one located at "at"
-		(indexObjectEntryV1Width * at)
+		((hashlen + indexObjectSmallOffsetWidth) * at)
 }

pack/index_v1_test.go

@@ -3,59 +3,37 @@ package pack
 import (
 	"bytes"
 	"crypto/sha1"
+	"crypto/sha256"
 	"encoding/binary"
+	"hash"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
 var (
 	V1IndexFanout = make([]uint32, indexFanoutEntries)
-
-	V1IndexSmallEntry = []byte{
-		0x0, 0x0, 0x0, 0x1,
-
-		0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
-		0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
-	}
-	V1IndexSmallSha = V1IndexSmallEntry[4:]
-
-	V1IndexMediumEntry = []byte{
-		0x0, 0x0, 0x0, 0x2,
-
-		0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
-		0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
-	}
-	V1IndexMediumSha = V1IndexMediumEntry[4:]
-
-	V1IndexLargeEntry = []byte{
-		0x0, 0x0, 0x0, 0x3,
-
-		0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-		0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-	}
-	V1IndexLargeSha = V1IndexLargeEntry[4:]
-
-	V1Index = &Index{
-		fanout:  V1IndexFanout,
-		version: &V1{hash: sha1.New()},
-	}
 )
 
 func TestIndexV1SearchExact(t *testing.T) {
-	v := &V1{hash: sha1.New()}
-	e, err := v.Entry(V1Index, 1)
+	for _, algo := range []hash.Hash{sha1.New(), sha256.New()} {
+		index := newV1Index(algo)
+		v := &V1{hash: algo}
+		e, err := v.Entry(index, 1)
 
-	assert.NoError(t, err)
-	assert.EqualValues(t, 2, e.PackOffset)
+		assert.NoError(t, err)
+		assert.EqualValues(t, 2, e.PackOffset)
+	}
 }
 
 func TestIndexVersionWidthV1(t *testing.T) {
-	v := &V1{hash: sha1.New()}
-	assert.EqualValues(t, 0, v.Width())
+	for _, algo := range []hash.Hash{sha1.New(), sha256.New()} {
+		v := &V1{hash: algo}
+		assert.EqualValues(t, 0, v.Width())
+	}
 }
 
-func init() {
+func newV1Index(hash hash.Hash) *Index {
 	V1IndexFanout[1] = 1
 	V1IndexFanout[2] = 2
 	V1IndexFanout[3] = 3
@@ -69,12 +47,29 @@ func init() {
 		binary.BigEndian.PutUint32(fanout[i*indexFanoutEntryWidth:], n)
 	}
 
-	buf := make([]byte, 0, indexOffsetV1Start+(3*indexObjectEntryV1Width))
+	hashlen := hash.Size()
+	entrylen := hashlen + indexObjectCRCWidth
+	entries := make([]byte, entrylen*3)
+
+	for i := 0; i < 3; i++ {
+		// For each entry, set the first three bytes to 0 and the
+		// remainder to the same value.  That creates an initial 4-byte
+		// CRC field with the value of i+1, followed by a series of data
+		// bytes which all have that same value.
+		for j := entrylen*i + 3; j < entrylen*(i+1); j++ {
+			entries[j] = byte(i + 1)
+		}
+	}
+
+	buf := make([]byte, 0, indexOffsetV1Start)
 
 	buf = append(buf, fanout...)
-	buf = append(buf, V1IndexSmallEntry...)
-	buf = append(buf, V1IndexMediumEntry...)
-	buf = append(buf, V1IndexLargeEntry...)
+	buf = append(buf, entries...)
+
+	return &Index{
+		fanout:  V1IndexFanout,
+		version: &V1{hash: hash},
+		r:       bytes.NewReader(buf),
+	}
 
-	V1Index.r = bytes.NewReader(buf)
 }