tarsum: allow for alternate block ciphers

Not breaking the default cipher and algorithm for calculating checksums,
but allow for using alternate block ciphers during the checksum
calculation.

Docker-DCO-1.1-Signed-off-by: Vincent Batts <vbatts@redhat.com> (github: vbatts)

tarsum/tarsum.go

@@ -35,6 +35,14 @@ func NewTarSum(r io.Reader, dc bool, v Version) (TarSum, error) {
 	return &tarSum{Reader: r, DisableCompression: dc, tarSumVersion: v}, nil
 }
 
+// Create a new TarSum, providing a THash to use rather than the DefaultTHash
+func NewTarSumHash(r io.Reader, dc bool, v Version, tHash THash) (TarSum, error) {
+	if _, ok := tarSumVersions[v]; !ok {
+		return nil, ErrVersionNotImplemented
+	}
+	return &tarSum{Reader: r, DisableCompression: dc, tarSumVersion: v, tHash: tHash}, nil
+}
+
 // TarSum is the generic interface for calculating fixed time
 // checksums of a tar archive
 type TarSum interface {
@@ -42,6 +50,7 @@ type TarSum interface {
 	GetSums() FileInfoSums
 	Sum([]byte) string
 	Version() Version
+	Hash() THash
 }
 
 // tarSum struct is the structure for a Version0 checksum calculation
@@ -49,11 +58,12 @@ type tarSum struct {
 	io.Reader
 	tarR               *tar.Reader
 	tarW               *tar.Writer
-	gz                 writeCloseFlusher
+	writer             writeCloseFlusher
 	bufTar             *bytes.Buffer
-	bufGz              *bytes.Buffer
+	bufWriter          *bytes.Buffer
 	bufData            []byte
 	h                  hash.Hash
+	tHash              THash
 	sums               FileInfoSums
 	fileCounter        int64
 	currentFile        string
@@ -63,10 +73,36 @@ type tarSum struct {
 	tarSumVersion      Version // this field is not exported so it can not be mutated during use
 }
 
+func (ts tarSum) Hash() THash {
+	return ts.tHash
+}
+
 func (ts tarSum) Version() Version {
 	return ts.tarSumVersion
 }
 
+// A hash.Hash type generator and its name
+type THash interface {
+	Hash() hash.Hash
+	Name() string
+}
+
+// Convenience method for creating a THash
+func NewTHash(name string, h func() hash.Hash) THash {
+	return simpleTHash{n: name, h: h}
+}
+
+// TarSum default is "sha256"
+var DefaultTHash = NewTHash("sha256", sha256.New)
+
+type simpleTHash struct {
+	n string
+	h func() hash.Hash
+}
+
+func (sth simpleTHash) Name() string    { return sth.n }
+func (sth simpleTHash) Hash() hash.Hash { return sth.h() }
+
 func (ts tarSum) selectHeaders(h *tar.Header, v Version) (set [][2]string) {
 	for _, elem := range [][2]string{
 		{"name", h.Name},
@@ -113,25 +149,35 @@ func (ts *tarSum) encodeHeader(h *tar.Header) error {
 	return nil
 }
 
+func (ts *tarSum) initTarSum() error {
+	ts.bufTar = bytes.NewBuffer([]byte{})
+	ts.bufWriter = bytes.NewBuffer([]byte{})
+	ts.tarR = tar.NewReader(ts.Reader)
+	ts.tarW = tar.NewWriter(ts.bufTar)
+	if !ts.DisableCompression {
+		ts.writer = gzip.NewWriter(ts.bufWriter)
+	} else {
+		ts.writer = &nopCloseFlusher{Writer: ts.bufWriter}
+	}
+	if ts.tHash == nil {
+		ts.tHash = DefaultTHash
+	}
+	ts.h = ts.tHash.Hash()
+	ts.h.Reset()
+	ts.first = true
+	ts.sums = FileInfoSums{}
+	return nil
+}
+
 func (ts *tarSum) Read(buf []byte) (int, error) {
-	if ts.gz == nil {
-		ts.bufTar = bytes.NewBuffer([]byte{})
-		ts.bufGz = bytes.NewBuffer([]byte{})
-		ts.tarR = tar.NewReader(ts.Reader)
-		ts.tarW = tar.NewWriter(ts.bufTar)
-		if !ts.DisableCompression {
-			ts.gz = gzip.NewWriter(ts.bufGz)
-		} else {
-			ts.gz = &nopCloseFlusher{Writer: ts.bufGz}
+	if ts.writer == nil {
+		if err := ts.initTarSum(); err != nil {
+			return 0, err
 		}
-		ts.h = sha256.New()
-		ts.h.Reset()
-		ts.first = true
-		ts.sums = FileInfoSums{}
 	}
 
 	if ts.finished {
-		return ts.bufGz.Read(buf)
+		return ts.bufWriter.Read(buf)
 	}
 	if ts.bufData == nil {
 		switch {
@@ -167,10 +213,10 @@ func (ts *tarSum) Read(buf []byte) (int, error) {
 					if err := ts.tarW.Close(); err != nil {
 						return 0, err
 					}
-					if _, err := io.Copy(ts.gz, ts.bufTar); err != nil {
+					if _, err := io.Copy(ts.writer, ts.bufTar); err != nil {
 						return 0, err
 					}
-					if err := ts.gz.Close(); err != nil {
+					if err := ts.writer.Close(); err != nil {
 						return 0, err
 					}
 					ts.finished = true
@@ -189,12 +235,12 @@ func (ts *tarSum) Read(buf []byte) (int, error) {
 				return 0, err
 			}
 			ts.tarW.Flush()
-			if _, err := io.Copy(ts.gz, ts.bufTar); err != nil {
+			if _, err := io.Copy(ts.writer, ts.bufTar); err != nil {
 				return 0, err
 			}
-			ts.gz.Flush()
+			ts.writer.Flush()
 
-			return ts.bufGz.Read(buf)
+			return ts.bufWriter.Read(buf)
 		}
 		return n, err
 	}
@@ -210,18 +256,18 @@ func (ts *tarSum) Read(buf []byte) (int, error) {
 	}
 	ts.tarW.Flush()
 
-	// Filling the gz writter
-	if _, err = io.Copy(ts.gz, ts.bufTar); err != nil {
+	// Filling the output writer
+	if _, err = io.Copy(ts.writer, ts.bufTar); err != nil {
 		return 0, err
 	}
-	ts.gz.Flush()
+	ts.writer.Flush()
 
-	return ts.bufGz.Read(buf)
+	return ts.bufWriter.Read(buf)
 }
 
 func (ts *tarSum) Sum(extra []byte) string {
 	ts.sums.SortBySums()
-	h := sha256.New()
+	h := ts.tHash.Hash()
 	if extra != nil {
 		h.Write(extra)
 	}
@@ -229,7 +275,7 @@ func (ts *tarSum) Sum(extra []byte) string {
 		log.Debugf("-->%s<--", fis.Sum())
 		h.Write([]byte(fis.Sum()))
 	}
-	checksum := ts.Version().String() + "+sha256:" + hex.EncodeToString(h.Sum(nil))
+	checksum := ts.Version().String() + "+" + ts.tHash.Name() + ":" + hex.EncodeToString(h.Sum(nil))
 	log.Debugf("checksum processed: %s", checksum)
 	return checksum
 }