Fix: Supporting unaligned SHA-256 states

Author: ashvardanian

golang/lib.go

@@ -36,11 +36,18 @@ package sz
 // #cgo nocallback sz_hash_state_update
 // #cgo noescape sz_hash_state_digest
 // #cgo nocallback sz_hash_state_digest
+// #cgo noescape sz_sha256_state_init
+// #cgo nocallback sz_sha256_state_init
+// #cgo noescape sz_sha256_state_update
+// #cgo nocallback sz_sha256_state_update
+// #cgo noescape sz_sha256_state_digest
+// #cgo nocallback sz_sha256_state_digest
 // #define SZ_DYNAMIC_DISPATCH 1
 // #include <stringzilla/stringzilla.h>
 import "C"
 import (
 	"fmt"
+	"io"
 	"unsafe"
 )
 
@@ -185,8 +192,8 @@ func (h *Hasher) Digest() uint64 {
 	return uint64(C.sz_hash_state_digest(&h.state))
 }
 
-// SHA256 computes the SHA-256 cryptographic hash of the input data.
-func Sha256(data []byte) [32]byte {
+// HashSha256 computes the SHA-256 cryptographic hash of the input data.
+func HashSha256(data []byte) [32]byte {
 	var state C.sz_sha256_state_t
 	C.sz_sha256_state_init(&state)
 	if len(data) > 0 {
@@ -197,45 +204,66 @@ func Sha256(data []byte) [32]byte {
 	return digest
 }
 
-// Sha256Hasher is a streaming SHA-256 hasher.
-type Sha256Hasher struct {
+// Sha256 is a streaming SHA-256 hasher that implements hash.Hash and io.Writer.
+type Sha256 struct {
 	state C.sz_sha256_state_t
 }
 
+// Compile-time interface checks
+var _ io.Writer = (*Sha256)(nil)
+
 // NewSha256 creates a new streaming SHA-256 hasher.
-func NewSha256() *Sha256Hasher {
-	h := &Sha256Hasher{}
+func NewSha256() *Sha256 {
+	h := &Sha256{}
 	C.sz_sha256_state_init(&h.state)
 	return h
 }
 
-// Write adds data to the streaming SHA-256 hasher.
-func (h *Sha256Hasher) Write(p []byte) *Sha256Hasher {
-	if len(p) == 0 {
-		return h
+// Write adds data to the streaming SHA-256 hasher. Implements io.Writer.
+func (h *Sha256) Write(p []byte) (n int, err error) {
+	if len(p) > 0 {
+		C.sz_sha256_state_update(&h.state, (*C.char)(unsafe.Pointer(&p[0])), C.ulong(len(p)))
 	}
-	C.sz_sha256_state_update(&h.state, (*C.char)(unsafe.Pointer(&p[0])), C.ulong(len(p)))
-	return h
+	return len(p), nil
 }
 
-// Digest returns the current SHA-256 hash without consuming the state.
-func (h *Sha256Hasher) Digest() [32]byte {
+// Sum appends the current hash to b and returns the resulting slice.
+// It does not change the underlying hash state. Implements hash.Hash.
+func (h *Sha256) Sum(b []byte) []byte {
+	digest := h.Digest()
+	return append(b, digest[:]...)
+}
+
+// Reset resets the hasher to its initial state. Implements hash.Hash.
+func (h *Sha256) Reset() {
+	C.sz_sha256_state_init(&h.state)
+}
+
+// Size returns the number of bytes Sum will return. Implements hash.Hash.
+func (h *Sha256) Size() int {
+	return 32
+}
+
+// BlockSize returns the hash's underlying block size. Implements hash.Hash.
+func (h *Sha256) BlockSize() int {
+	return 64
+}
+
+// Digest returns the current SHA-256 hash as a 32-byte array without consuming the state.
+// This is a convenience method in addition to the standard hash.Hash interface.
+func (h *Sha256) Digest() [32]byte {
 	var digest [32]byte
 	C.sz_sha256_state_digest(&h.state, (*C.uchar)(unsafe.Pointer(&digest[0])))
 	return digest
 }
 
 // Hexdigest returns the current SHA-256 hash as a lowercase hexadecimal string.
-func (h *Sha256Hasher) Hexdigest() string {
+// This is a convenience method matching Python's hashlib interface.
+func (h *Sha256) Hexdigest() string {
 	digest := h.Digest()
 	return fmt.Sprintf("%x", digest)
 }
 
-// Reset resets the hasher to its initial state.
-func (h *Sha256Hasher) Reset() {
-	C.sz_sha256_state_init(&h.state)
-}
-
 // Count returns the number of overlapping or non-overlapping instances of `substr` in `str`.
 // If `substr` is an empty string, returns 1 + the length of the `str`.
 // https://pkg.go.dev/strings#Count

golang/lib_test.go

@@ -201,12 +201,12 @@ func TestHashing(t *testing.T) {
 // TestSha256 verifies SHA-256 hashing with NIST test vectors.
 func TestSha256(t *testing.T) {
 	// NIST test vectors
-	empty := sz.Sha256([]byte(""))
+	empty := sz.HashSha256([]byte(""))
 	if fmt.Sprintf("%x", empty) != "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" {
 		t.Fatalf("SHA-256 empty string mismatch")
 	}
 
-	abc := sz.Sha256([]byte("abc"))
+	abc := sz.HashSha256([]byte("abc"))
 	if fmt.Sprintf("%x", abc) != "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" {
 		t.Fatalf("SHA-256 'abc' mismatch")
 	}
@@ -215,14 +215,29 @@ func TestSha256(t *testing.T) {
 // TestSha256Streaming verifies streaming SHA-256 hasher.
 func TestSha256Streaming(t *testing.T) {
 	hasher := sz.NewSha256()
-	hasher.Write([]byte("Hello, ")).Write([]byte("world!"))
+	hasher.Write([]byte("Hello, "))
+	hasher.Write([]byte("world!"))
 	progressive := hasher.Digest()
 
-	oneshot := sz.Sha256([]byte("Hello, world!"))
+	oneshot := sz.HashSha256([]byte("Hello, world!"))
 	if progressive != oneshot {
 		t.Fatalf("Streaming SHA-256 mismatch: %x != %x", progressive, oneshot)
 	}
 
+	// Test hash.Hash interface compliance
+	if hasher.Size() != 32 {
+		t.Fatalf("Size() should return 32")
+	}
+	if hasher.BlockSize() != 64 {
+		t.Fatalf("BlockSize() should return 64")
+	}
+
+	// Test Sum() method
+	sum := hasher.Sum(nil)
+	if len(sum) != 32 {
+		t.Fatalf("Sum(nil) should return 32 bytes")
+	}
+
 	// Hexdigest and reset
 	if len(hasher.Hexdigest()) != 64 {
 		t.Fatalf("Hexdigest wrong length")