Make it consistent with trendmicro latest implementation (#27)

* Make it consistent with trendmicro latest implementation: returning invalid hash when q3 is zero or file size is less than 50 bytes

* adapt hash interface to the latest fix

* t.Logf and gofmt

* make sure on windows we don't get crlf for these test files.

* Modifying the receiver (*t) in place and then returning its Binary() creates confusing side effects. Consider returning a zero hash directly without modifying the receiver state.

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: ljjgdfs <ljjgdfs@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: 3 people

hash.go

@@ -33,6 +33,13 @@ func (t *TLSH) Size() int {
 
 func (t *TLSH) Sum(b []byte) []byte {
 	q1, q2, q3 := quartilePoints(t.state.buckets)
+	if q3 == 0 || t.state.fileSize < 50 {
+		*t = TLSH{
+			state: t.state,
+		}
+		// Return a zero hash directly without modifying the receiver
+		return make([]byte, codeSize)
+	}
 	q1Ratio := byte(float32(q1)*100/float32(q3)) % 16
 	q2Ratio := byte(float32(q2)*100/float32(q3)) % 16
 	qRatio := ((q1Ratio & 0xF) << 4) | (q2Ratio & 0xF)

hash_test.go

@@ -1,7 +1,6 @@
 package tlsh
 
 import (
-	"fmt"
 	"hash"
 	"testing"
 )
@@ -19,7 +18,7 @@ func TestHashinterface(t *testing.T) {
 	t.Log(h.Size())
 	hash := h.Sum(nil)
 	t.Log(hash)
-	t.Log(fmt.Sprintf("%x", hash[:]))
+	t.Logf("%x", hash[:])
 }
 
 func TestHashWrite(t *testing.T) {
@@ -28,16 +27,16 @@ func TestHashWrite(t *testing.T) {
 	h1.Write([]byte("1234"))
 	h1.Write([]byte("11"))
 	h1.Write([]byte("1111111"))
-	t.Log(fmt.Sprintf("h1: %x", h1.Sum(nil)))
+	t.Logf("h1: %x", h1.Sum(nil))
 	t.Logf("checksum h1: %d, %x", h1.state.checksum, h1.checksum)
 
 	// hash from read
 	h2, err := HashBytes([]byte("1234111111111"))
-	if err != nil {
-		t.Error(err)
+	if err == nil {
+		t.Error("Missing error of less than 50 bytes")
 	}
 	t.Logf("checksum h2: %d, %x", h2.state.checksum, h2.checksum)
-	t.Log(fmt.Sprintf("h2: %x", h2.Binary()))
+	t.Logf("h2: %x", h2.Binary())
 
 	// compare hashes
 	if h1.state.fileSize != h2.state.fileSize {
@@ -50,4 +49,28 @@ func TestHashWrite(t *testing.T) {
 	if diff != 0 {
 		t.Errorf("hashes differ by: %d", diff)
 	}
+
+	h1.Write([]byte("1234567890"))
+	h1.Write([]byte("1234567890"))
+	h1.Write([]byte("1234567890"))
+	h1.Write([]byte("1234567890"))
+	t.Logf("h1: %x", h1.Sum(nil))
+	t.Logf("checksum h1: %d, %x", h1.state.checksum, h1.checksum)
+	s := "1234111111111" + "1234567890" + "1234567890" + "1234567890" + "1234567890"
+	h3, err := HashBytes([]byte(s))
+	if err != nil {
+		t.Error(err)
+	}
+	t.Logf("checksum h3: %d, %x", h3.state.checksum, h3.checksum)
+	t.Logf("h3: %x", h3.Binary())
+	if h1.state.fileSize != h3.state.fileSize {
+		t.Errorf("file size mismatch: %d != %d", h1.state.fileSize, h3.state.fileSize)
+	}
+	if h1.checksum != h3.checksum {
+		t.Errorf("checksum mismatch: %x != %x", h1.checksum, h3.checksum)
+	}
+	diff = h1.Diff(h3)
+	if diff != 0 {
+		t.Errorf("hashes differ by: %d", diff)
+	}
 }

tests/.gitattributes

@@ -0,0 +1,6 @@
+* text eol=lf
+
+*.jpg binary
+*.png binary
+*.exe binary
+

tests/test_file_49bytes

@@ -0,0 +1 @@
+MIT License is so cool license that I can't imag

tests/test_file_q3zero

@@ -0,0 +1 @@
+1234560000000000000000000000000000000000000000000

tlsh.go

@@ -18,6 +18,7 @@ import (
 	"bufio"
 	"bytes"
 	"encoding/hex"
+	"errors"
 	"io"
 	"math"
 	"os"
@@ -336,8 +337,26 @@ func hashCalculate(r FuzzyReader) (*TLSH, error) {
 	if err != nil {
 		return &TLSH{}, err
 	}
+	if fileSize < 50 {
+		return &TLSH{
+			state: chunkState{
+				buckets:  buckets,
+				fileSize: fileSize,
+				checksum: checksum,
+			},
+		}, errors.New("less than 50 bytes")
+	}
 
 	q1, q2, q3 := quartilePoints(buckets)
+	if q3 == 0 {
+		return &TLSH{
+			state: chunkState{
+				buckets:  buckets,
+				fileSize: fileSize,
+				checksum: checksum,
+			},
+		}, errors.New("q3 is zero")
+	}
 	q1Ratio := byte(float32(q1)*100/float32(q3)) % 16
 	q2Ratio := byte(float32(q2)*100/float32(q3)) % 16
 	qRatio := ((q1Ratio & 0xF) << 4) | (q2Ratio & 0xF)
@@ -360,22 +379,22 @@ type FuzzyReader interface {
 	io.ByteReader
 }
 
-//HashReader calculates the TLSH for the input reader
+// HashReader calculates the TLSH for the input reader
 func HashReader(r FuzzyReader) (*TLSH, error) {
 	t, err := hashCalculate(r)
 	if err != nil {
-		return &TLSH{}, err
+		return &TLSH{state: t.state}, err
 	}
 	return t, err
 }
 
-//HashBytes calculates the TLSH for the input byte slice
+// HashBytes calculates the TLSH for the input byte slice
 func HashBytes(blob []byte) (*TLSH, error) {
 	r := bytes.NewReader(blob)
 	return HashReader(r)
 }
 
-//HashFilename calculates the TLSH for the input file
+// HashFilename calculates the TLSH for the input file
 func HashFilename(filename string) (*TLSH, error) {
 	f, err := os.Open(filename)
 	if err != nil {

tlsh_test.go

@@ -23,6 +23,8 @@ var (
 		{"tests/test_file_9_tinyssl.exe", "67a3ad97f601c873e11a0af49d83d2d6bc7f7f709e522c9b74990b0e8d796822d1d48a"},
 		{"tests/NON_EXISTENT", "0000000000000000000000000000000000000000000000000000000000000000000000"},
 		{"tests/test_file_empty", "0000000000000000000000000000000000000000000000000000000000000000000000"},
+		{"tests/test_file_q3zero", "0000000000000000000000000000000000000000000000000000000000000000000000"},
+		{"tests/test_file_49bytes", "0000000000000000000000000000000000000000000000000000000000000000000000"},
 	}
 
 	diffTestCases = []struct {