pack: support SHA-256 in v2 indices

Let's add support for handling SHA-256 in v2 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.

Author: bk2204

pack/index_v2.go

@@ -13,19 +13,25 @@ type V2 struct {
 // Name implements IndexVersion.Name by returning the 20 byte SHA-1 object name
 // for the given entry at offset "at" in the v2 index file "idx".
 func (v *V2) Name(idx *Index, at int64) ([]byte, error) {
-	var sha [20]byte
-	if _, err := idx.readAt(sha[:], v2ShaOffset(at)); err != nil {
+	var sha [maxHashSize]byte
+
+	hashlen := v.hash.Size()
+
+	if _, err := idx.readAt(sha[:hashlen], v2ShaOffset(at, int64(hashlen))); err != nil {
 		return nil, err
 	}
 
-	return sha[:], nil
+	return sha[:hashlen], nil
 }
 
 // Entry implements IndexVersion.Entry for v2 packfiles by parsing and returning
 // the IndexEntry specified at the offset "at" in the given index file.
 func (v *V2) Entry(idx *Index, at int64) (*IndexEntry, error) {
 	var offs [4]byte
-	if _, err := idx.readAt(offs[:], v2SmallOffsetOffset(at, int64(idx.Count()))); err != nil {
+
+	hashlen := v.hash.Size()
+
+	if _, err := idx.readAt(offs[:], v2SmallOffsetOffset(at, int64(idx.Count()), int64(hashlen))); err != nil {
 		return nil, err
 	}
 
@@ -36,7 +42,7 @@ func (v *V2) Entry(idx *Index, at int64) (*IndexEntry, error) {
 		//
 		// Mask away (offs&0x7fffffff) the MSB to use as an index to
 		// find the offset of the 8-byte pack offset.
-		lo := v2LargeOffsetOffset(int64(loc&0x7fffffff), int64(idx.Count()))
+		lo := v2LargeOffsetOffset(int64(loc&0x7fffffff), int64(idx.Count()), int64(hashlen))
 
 		var offs [8]byte
 		if _, err := idx.readAt(offs[:], lo); err != nil {
@@ -55,20 +61,20 @@ func (v *V2) Width() int64 {
 }
 
 // v2ShaOffset returns the offset of a SHA1 given at "at" in the V2 index file.
-func v2ShaOffset(at int64) int64 {
+func v2ShaOffset(at int64, hashlen int64) int64 {
 	// Skip the packfile index header and the L1 fanout table.
 	return indexOffsetV2Start +
 		// Skip until the desired name in the sorted names table.
-		(indexObjectNameWidth * at)
+		(hashlen * at)
 }
 
 // v2SmallOffsetOffset returns the offset of an object's small (4-byte) offset
 // given by "at".
-func v2SmallOffsetOffset(at, total int64) int64 {
+func v2SmallOffsetOffset(at, total, hashlen int64) int64 {
 	// Skip the packfile index header and the L1 fanout table.
 	return indexOffsetV2Start +
 		// Skip the name table.
-		(indexObjectNameWidth * total) +
+		(hashlen * total) +
 		// Skip the CRC table.
 		(indexObjectCRCWidth * total) +
 		// Skip until the desired index in the small offsets table.
@@ -77,11 +83,11 @@ func v2SmallOffsetOffset(at, total int64) int64 {
 
 // v2LargeOffsetOffset returns the offset of an object's large (4-byte) offset,
 // given by the index "at".
-func v2LargeOffsetOffset(at, total int64) int64 {
+func v2LargeOffsetOffset(at, total, hashlen int64) int64 {
 	// Skip the packfile index header and the L1 fanout table.
 	return indexOffsetV2Start +
 		// Skip the name table.
-		(indexObjectNameWidth * total) +
+		(hashlen * total) +
 		// Skip the CRC table.
 		(indexObjectCRCWidth * total) +
 		// Skip the small offsets table.

pack/index_v2_test.go

@@ -3,7 +3,9 @@ package pack
 import (
 	"bytes"
 	"crypto/sha1"
+	"crypto/sha256"
 	"encoding/binary"
+	"hash"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -16,20 +18,6 @@ var (
 	}
 	V2IndexFanout = make([]uint32, indexFanoutEntries)
 
-	V2IndexNames = []byte{
-		0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
-		0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
-
-		0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
-		0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,
-
-		0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-		0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-	}
-	V2IndexSmallSha  = V2IndexNames[0:20]
-	V2IndexMediumSha = V2IndexNames[20:40]
-	V2IndexLargeSha  = V2IndexNames[40:60]
-
 	V2IndexCRCs = []byte{
 		0x0, 0x0, 0x0, 0x0,
 		0x1, 0x1, 0x1, 0x1,
@@ -44,35 +32,38 @@ var (
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // filler data
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, // large offset
 	}
-
-	V2Index = &Index{
-		fanout:  V2IndexFanout,
-		version: &V2{hash: sha1.New()},
-	}
 )
 
 func TestIndexV2EntryExact(t *testing.T) {
-	v := &V2{hash: sha1.New()}
-	e, err := v.Entry(V2Index, 1)
+	for _, algo := range []hash.Hash{sha1.New(), sha256.New()} {
+		index := newV2Index(algo)
+		v := &V2{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 TestIndexV2EntryExtendedOffset(t *testing.T) {
-	v := &V2{hash: sha1.New()}
-	e, err := v.Entry(V2Index, 2)
+	for _, algo := range []hash.Hash{sha1.New(), sha256.New()} {
+		index := newV2Index(algo)
+		v := &V2{hash: algo}
+		e, err := v.Entry(index, 2)
 
-	assert.NoError(t, err)
-	assert.EqualValues(t, 3, e.PackOffset)
+		assert.NoError(t, err)
+		assert.EqualValues(t, 3, e.PackOffset)
+	}
 }
 
 func TestIndexVersionWidthV2(t *testing.T) {
-	v := &V2{hash: sha1.New()}
-	assert.EqualValues(t, 8, v.Width())
+	for _, algo := range []hash.Hash{sha1.New(), sha256.New()} {
+		v := &V2{hash: algo}
+		assert.EqualValues(t, 8, v.Width())
+	}
 }
 
-func init() {
+func newV2Index(hash hash.Hash) *Index {
 	V2IndexFanout[1] = 1
 	V2IndexFanout[2] = 2
 	V2IndexFanout[3] = 3
@@ -86,12 +77,23 @@ func init() {
 		binary.BigEndian.PutUint32(fanout[i*indexFanoutEntryWidth:], n)
 	}
 
-	buf := make([]byte, 0, indexOffsetV2Start+3*(indexObjectEntryV2Width)+indexObjectLargeOffsetWidth)
+	hashlen := hash.Size()
+	names := make([]byte, hashlen*3)
+
+	for i := range names {
+		names[i] = byte((i / hashlen) + 1)
+	}
+
+	buf := make([]byte, 0, indexOffsetV2Start+3)
 	buf = append(buf, V2IndexHeader...)
 	buf = append(buf, fanout...)
-	buf = append(buf, V2IndexNames...)
+	buf = append(buf, names...)
 	buf = append(buf, V2IndexCRCs...)
 	buf = append(buf, V2IndexOffsets...)
 
-	V2Index.r = bytes.NewReader(buf)
+	return &Index{
+		fanout:  V2IndexFanout,
+		version: &V2{hash: hash},
+		r:       bytes.NewReader(buf),
+	}
 }