change hashing algorithm form sha256 to blake3

j-rafique · j-rafique · commit 6723bf093bf9 · 2025-04-29T16:06:35.000+05:00
diff --git a/go.mod b/go.mod
@@ -116,6 +116,7 @@ require (
 	github.com/improbable-eng/grpc-web v0.15.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jmhodges/levigo v1.0.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
 	github.com/linxGnu/grocksdb v1.8.14 // indirect
@@ -168,6 +169,7 @@ require (
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20241202173237-19429a94021a // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gotest.tools/v3 v3.5.1 // indirect
+	lukechampine.com/blake3 v1.4.0 // indirect
 	lukechampine.com/uint128 v1.3.0 // indirect
 	nhooyr.io/websocket v1.8.6 // indirect
 	pgregory.net/rapid v1.1.0 // indirect
diff --git a/go.sum b/go.sum
@@ -517,6 +517,8 @@ github.com/klauspost/compress v1.11.7/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYs
 github.com/klauspost/compress v1.12.3/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
 github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
 github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
+github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/kolesa-team/go-webp v1.0.4 h1:wQvU4PLG/X7RS0vAeyhiivhLRoxfLVRlDq4I3frdxIQ=
 github.com/kolesa-team/go-webp v1.0.4/go.mod h1:oMvdivD6K+Q5qIIkVC2w4k2ZUnI1H+MyP7inwgWq9aA=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
@@ -1130,6 +1132,8 @@ honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+lukechampine.com/blake3 v1.4.0 h1:xDbKOZCVbnZsfzM6mHSYcGRHZ3YrLDzqz8XnV4uaD5w=
+lukechampine.com/blake3 v1.4.0/go.mod h1:MQJNQCTnR+kwOP/JEZSxj3MaQjp80FOFSNMMHXcSeX0=
 lukechampine.com/uint128 v1.3.0 h1:cDdUVfRwDUDovz610ABgFD17nXD4/uDgVHl2sC3+sbo=
 lukechampine.com/uint128 v1.3.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
 nhooyr.io/websocket v1.8.6 h1:s+C3xAMLwGmlI31Nyn/eAehUlZPwfYZu2JXM621Q5/k=
diff --git a/p2p/DEVDOCS.md b/p2p/DEVDOCS.md
@@ -132,4 +132,4 @@ Data stored in the network is:
 
 - Use `localOnly: true` with `Retrieve()` to only check local storage
 - DHT operations use a modified Kademlia with `Alpha=6` for parallelism
-- Key format is base58-encoded SHA-256 hash of the data
+- Key format is base58-encoded Blake3 hash of the data
diff --git a/p2p/client.go b/p2p/client.go
@@ -22,7 +22,7 @@ type Client interface {
 	// - the base58 encoded identifier will be returned
 	Store(ctx context.Context, data []byte, typ int) (string, error)
 
-	// StoreBatch will store a batch of values with their SHA256 hash as the key
+	// StoreBatch will store a batch of values with their Blake3 hash as the key
 	StoreBatch(ctx context.Context, values [][]byte, typ int, taskID string) error
 
 	// Delete a key, value
@@ -41,10 +41,10 @@ type Client interface {
 	// - the base58 encoded identifier will be returned
 	LocalStore(ctx context.Context, key string, data []byte) (string, error)
 
-	// DisableKey adds key to disabled keys list - It takes in a B58 encoded SHA-256 hash
+	// DisableKey adds key to disabled keys list - It takes in a B58 encoded blake3 hash
 	DisableKey(ctx context.Context, b58EncodedHash string) error
 
-	// EnableKey removes key from disabled list - It takes in a B58 encoded SHA-256 hash
+	// EnableKey removes key from disabled list - It takes in a B58 encoded blake3 hash
 	EnableKey(ctx context.Context, b58EncodedHash string) error
 
 	// GetLocalKeys returns a list of all keys stored locally
diff --git a/p2p/kademlia/dht.go b/p2p/kademlia/dht.go
@@ -207,7 +207,7 @@ func (s *DHT) retryStore(ctx context.Context, key []byte, data []byte, typ int)
 
 // Store the data into the network
 func (s *DHT) Store(ctx context.Context, data []byte, typ int) (string, error) {
-	key, _ := utils.Sha3256hash(data)
+	key, _ := utils.Blake3Hash(data)
 
 	retKey := base58.Encode(key)
 	// store the key to queries storage
@@ -224,7 +224,7 @@ func (s *DHT) Store(ctx context.Context, data []byte, typ int) (string, error) {
 	return retKey, nil
 }
 
-// StoreBatch will store a batch of values with their SHA256 hash as the key
+// StoreBatch will store a batch of values with their Blake3 hash as the key
 func (s *DHT) StoreBatch(ctx context.Context, values [][]byte, typ int, taskID string) error {
 	log.WithContext(ctx).WithField("taskID", taskID).WithField("records", len(values)).Info("store db batch begin")
 	if err := s.store.StoreBatch(ctx, values, typ, true); err != nil {
@@ -823,7 +823,7 @@ func (s *DHT) iterate(ctx context.Context, iterativeType int, target []byte, dat
 	closestNode := nl.Nodes[0]
 	// if it's a find node, reset the refresh timer
 	if iterativeType == IterateFindNode {
-		hashedTargetID, _ := utils.Sha3256hash(target)
+		hashedTargetID, _ := utils.Blake3Hash(target)
 		bucket := s.ht.bucketIndex(s.ht.self.HashedID, hashedTargetID)
 		log.P2P().WithContext(ctx).Debugf("bucket for target: %v", sKey)
 
@@ -1173,7 +1173,7 @@ func (s *DHT) storeToAlphaNodes(ctx context.Context, nl *NodeList, data []byte,
 			}
 		}(n)
 	}
-	skey, _ := utils.Sha3256hash(data)
+	skey, _ := utils.Blake3Hash(data)
 
 	// Collect results from parallel requests
 	for i := 0; i < Alpha && i < len(nl.Nodes); i++ {
@@ -1259,7 +1259,7 @@ func (s *DHT) IterateBatchStore(ctx context.Context, values [][]byte, typ int, i
 
 	log.WithContext(ctx).WithField("task-id", id).WithField("keys", len(values)).Info("iterate batch store begin")
 	for i := 0; i < len(values); i++ {
-		target, _ := utils.Sha3256hash(values[i])
+		target, _ := utils.Blake3Hash(values[i])
 		hashes[i] = target
 		top6 := s.ht.closestContactsWithInlcudingNode(Alpha, target, s.ignorelist.ToNodeList(), nil)
 
diff --git a/p2p/kademlia/fetch_and_store.go b/p2p/kademlia/fetch_and_store.go
@@ -9,9 +9,9 @@ import (
 
 	json "github.com/json-iterator/go"
 
+	"github.com/LumeraProtocol/supernode/p2p/kademlia/domain"
 	"github.com/LumeraProtocol/supernode/pkg/log"
 	"github.com/LumeraProtocol/supernode/pkg/utils"
-	"github.com/LumeraProtocol/supernode/p2p/kademlia/domain"
 	"github.com/cenkalti/backoff/v4"
 )
 
@@ -368,8 +368,8 @@ func VerifyAndFilter(decompressedMap map[string][]byte) (map[string][]byte, []st
 			continue
 		}
 
-		// Compute the SHA256 hash of the value using the helper function
-		hash, err := utils.Sha3256hash(value)
+		// Compute the Blake3 hash of the value using the helper function
+		hash, err := utils.Blake3Hash(value)
 		if err != nil {
 			failedKeys = append(failedKeys, key)
 			log.WithError(err).Error("failed to compute hash")
diff --git a/p2p/kademlia/network.go b/p2p/kademlia/network.go
@@ -143,7 +143,7 @@ func (s *Network) handleFindNode(ctx context.Context, message *Message) (res []b
 	s.dht.addNode(ctx, message.Sender)
 
 	// the closest contacts
-	hashedTargetID, _ := utils.Sha3256hash(request.Target)
+	hashedTargetID, _ := utils.Blake3Hash(request.Target)
 	closest, _ := s.dht.ht.closestContacts(K, hashedTargetID, []*Node{message.Sender})
 
 	response := &FindNodeResponse{
@@ -232,7 +232,7 @@ func (s *Network) handleStoreData(ctx context.Context, message *Message) (res []
 	s.dht.addNode(ctx, message.Sender)
 
 	// format the key
-	key, _ := utils.Sha3256hash(request.Data)
+	key, _ := utils.Blake3Hash(request.Data)
 
 	value, err := s.dht.store.Retrieve(ctx, key)
 	if err != nil || len(value) == 0 {
diff --git a/p2p/kademlia/node.go b/p2p/kademlia/node.go
@@ -29,7 +29,7 @@ type Node struct {
 // SetHashedID sets hash of ID
 func (s *Node) SetHashedID() {
 	if len(s.HashedID) == 0 {
-		s.HashedID, _ = utils.Sha3256hash(s.ID)
+		s.HashedID, _ = utils.Blake3Hash(s.ID)
 	}
 }
 
diff --git a/p2p/kademlia/store/sqlite/replication.go b/p2p/kademlia/store/sqlite/replication.go
@@ -7,8 +7,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/LumeraProtocol/supernode/pkg/log"
 	"github.com/LumeraProtocol/supernode/p2p/kademlia/domain"
+	"github.com/LumeraProtocol/supernode/pkg/log"
 	"github.com/cenkalti/backoff/v4"
 	"github.com/jmoiron/sqlx"
 )
@@ -185,7 +185,7 @@ func (s *Store) DeleteRepKey(hkey string) error {
 	return nil
 }
 
-// StoreBatchRepKeys will store a batch of values with their SHA256 hash as the key
+// StoreBatchRepKeys will store a batch of values with their Blake3 hash as the key
 func (s *Store) StoreBatchRepKeys(values []string, id string, ip string, port uint16) error {
 	operation := func() error {
 		tx, err := s.db.Beginx()
diff --git a/p2p/kademlia/store/sqlite/sqlite.go b/p2p/kademlia/store/sqlite/sqlite.go
@@ -10,9 +10,9 @@ import (
 	"strings"
 	"time"
 
+	"github.com/LumeraProtocol/supernode/p2p/kademlia/store/cloud.go"
 	"github.com/LumeraProtocol/supernode/pkg/log"
 	"github.com/LumeraProtocol/supernode/pkg/utils"
-	"github.com/LumeraProtocol/supernode/p2p/kademlia/store/cloud.go"
 
 	"github.com/cenkalti/backoff/v4"
 	"github.com/jmoiron/sqlx"
@@ -542,7 +542,7 @@ func (s *Store) storeRecord(key []byte, value []byte, typ int, isOriginal bool)
 	return nil
 }
 
-// storeBatchRecord will store a batch of values with their SHA256 hash as the key
+// storeBatchRecord will store a batch of values with their Blake3 hash as the key
 func (s *Store) storeBatchRecord(values [][]byte, typ int, isOriginal bool) error {
 	hkeys := make([]UpdateMessage, len(values))
 
@@ -565,8 +565,8 @@ func (s *Store) storeBatchRecord(values [][]byte, typ int, isOriginal bool) erro
 		// For each value, calculate its hash and insert into DB
 		now := time.Now().UTC()
 		for i := 0; i < len(values); i++ {
-			// Compute the SHA256 hash
-			hashed, err := utils.Sha3256hash(values[i])
+			// Compute the Blake3 hash
+			hashed, err := utils.Blake3Hash(values[i])
 			if err != nil {
 				tx.Rollback()
 				return fmt.Errorf("cannot compute hash: %w", err)
diff --git a/p2p/kademlia/store/sqlite/sqlite_test.go b/p2p/kademlia/store/sqlite/sqlite_test.go
@@ -14,8 +14,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/LumeraProtocol/supernode/pkg/utils"
 	"github.com/LumeraProtocol/supernode/p2p/kademlia/store/cloud.go"
+	"github.com/LumeraProtocol/supernode/pkg/utils"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -88,21 +88,21 @@ func TestStore(t *testing.T) {
 	r2 := []byte("test-record-2")
 	r3 := []byte("test-record-3")
 
-	hashed, err := utils.Sha3256hash(r1)
+	hashed, err := utils.Blake3Hash(r1)
 	if err != nil {
 		t.Fatalf("failed to hash record: %v", err)
 	}
 
 	r1Key := hex.EncodeToString(hashed)
 
-	hashed, err = utils.Sha3256hash(r2)
+	hashed, err = utils.Blake3Hash(r2)
 	if err != nil {
 		t.Fatalf("failed to hash record: %v", err)
 	}
 
 	r2Key := hex.EncodeToString(hashed)
 
-	hashed, err = utils.Sha3256hash(r3)
+	hashed, err = utils.Blake3Hash(r3)
 	if err != nil {
 		t.Fatalf("failed to hash record: %v", err)
 	}
diff --git a/p2p/p2p.go b/p2p/p2p.go
@@ -21,7 +21,7 @@ import (
 
 const (
 	logPrefix = "p2p"
-	// B is the number of bits in a SHA256 hash
+	// B is the number of bits in a Blake3 hash
 	B = 256
 )
 
@@ -122,7 +122,7 @@ func (s *p2p) Store(ctx context.Context, data []byte, typ int) (string, error) {
 	return s.dht.Store(ctx, data, typ)
 }
 
-// StoreBatch will store a batch of values with their SHA256 hash as the key
+// StoreBatch will store a batch of values with their Blake3 hash as the key
 func (s *p2p) StoreBatch(ctx context.Context, data [][]byte, typ int, taskID string) error {
 	ctx = log.ContextWithPrefix(ctx, logPrefix)
 
@@ -293,7 +293,7 @@ func (s *p2p) LocalStore(ctx context.Context, key string, data []byte) (string,
 	return s.dht.LocalStore(ctx, key, data)
 }
 
-// DisableKey adds key to disabled keys list - It takes in a B58 encoded SHA-256 hash
+// DisableKey adds key to disabled keys list - It takes in a B58 encoded Blake3 hash
 func (s *p2p) DisableKey(ctx context.Context, b58EncodedHash string) error {
 	decoded := base58.Decode(b58EncodedHash)
 	if len(decoded) != B/8 {
@@ -303,7 +303,7 @@ func (s *p2p) DisableKey(ctx context.Context, b58EncodedHash string) error {
 	return s.metaStore.Store(ctx, decoded)
 }
 
-// EnableKey removes key from disabled list - It takes in a B58 encoded SHA-256 hash
+// EnableKey removes key from disabled list - It takes in a B58 encoded Blake3 hash
 func (s *p2p) EnableKey(ctx context.Context, b58EncodedHash string) error {
 	decoded := base58.Decode(b58EncodedHash)
 	if len(decoded) != B/8 {
diff --git a/pkg/crypto/hash.go b/pkg/crypto/hash.go
@@ -0,0 +1,2 @@
+package crypto
+
diff --git a/pkg/net/credentials/alts/common/utils.go b/pkg/net/credentials/alts/common/utils.go
@@ -1,14 +1,14 @@
 package common
 
 import (
+	"crypto/sha256"
 	"encoding/binary"
 	"fmt"
 	"io"
 	"net"
-	"crypto/sha256"
 
-	"golang.org/x/crypto/hkdf"
 	"github.com/cosmos/gogoproto/proto"
+	"golang.org/x/crypto/hkdf"
 
 	lumeraidtypes "github.com/LumeraProtocol/lumera/x/lumeraid/types"
 )
@@ -24,22 +24,22 @@ func defaultSendHandshakeMessage(conn net.Conn, handshakeBytes, signature []byte
 	// Calculate total message size and allocate a single buffer
 	totalSize := MsgLenFieldSize + len(handshakeBytes) + MsgLenFieldSize + len(signature)
 	buf := make([]byte, totalSize)
-	
+
 	// Write all data into the buffer
 	offset := 0
-	
+
 	// Write handshake length
 	binary.BigEndian.PutUint32(buf[offset:], uint32(len(handshakeBytes)))
 	offset += MsgLenFieldSize
-	
+
 	// Write handshake bytes
 	copy(buf[offset:], handshakeBytes)
 	offset += len(handshakeBytes)
-	
+
 	// Write signature length
 	binary.BigEndian.PutUint32(buf[offset:], uint32(len(signature)))
 	offset += MsgLenFieldSize
-	
+
 	// Write signature
 	copy(buf[offset:], signature)
 
@@ -124,36 +124,36 @@ func defaultExpandKey(sharedSecret []byte, protocol string, info []byte) ([]byte
 	if err != nil {
 		return nil, fmt.Errorf("failed to get key size: %w", err)
 	}
-	if (keySize <= len(sharedSecret)) {
+	if keySize <= len(sharedSecret) {
 		return sharedSecret[:keySize], nil
 	}
 
-    // Use HKDF with SHA-256
-    hkdf := hkdf.New(sha256.New, sharedSecret, nil, info)
-    
-    key := make([]byte, keySize)
-    if _, err := io.ReadFull(hkdf, key); err != nil {
-        return nil, fmt.Errorf("failed to expand key: %w", err)
-    }
+	// Use HKDF with SHA-256
+	hkdf := hkdf.New(sha256.New, sharedSecret, nil, info)
+
+	key := make([]byte, keySize)
+	if _, err := io.ReadFull(hkdf, key); err != nil {
+		return nil, fmt.Errorf("failed to expand key: %w", err)
+	}
 
-    return key, nil
+	return key, nil
 }
 
 // ExpandKey derives protocol-specific keys from the shared secret using HKDF
 var ExpandKey ExpandKeyFunc = defaultExpandKey
 
 // For XChaCha20Poly1305ReKey, helper to split the expanded key into key and nonce
 func SplitKeyAndNonce(expandedKey []byte) (key, nonce []byte) {
-    if len(expandedKey) != KeySizeXChaCha20Poly1305ReKey {
-        return nil, nil
-    }
-    return expandedKey[:32], expandedKey[32:]
+	if len(expandedKey) != KeySizeXChaCha20Poly1305ReKey {
+		return nil, nil
+	}
+	return expandedKey[:32], expandedKey[32:]
 }
 
 // For AESGCMReKey, helper to split the expanded key into key and counter mask
 func SplitKeyAndCounterMask(expandedKey []byte) (key, counterMask []byte) {
-    if len(expandedKey) != KeySizeAESGCMReKey {
-        return nil, nil
-    }
-    return expandedKey[:32], expandedKey[32:]
+	if len(expandedKey) != KeySizeAESGCMReKey {
+		return nil, nil
+	}
+	return expandedKey[:32], expandedKey[32:]
 }
diff --git a/pkg/raptorq/helper.go b/pkg/raptorq/helper.go
@@ -171,7 +171,7 @@ func GetIDFiles(ctx context.Context, file []byte, ic uint32, max uint32) (ids []
 
 		idFiles = append(idFiles, compressedData)
 
-		hash, err := utils.Sha3256hash(compressedData)
+		hash, err := utils.Blake3Hash(compressedData)
 		if err != nil {
 			return ids, idFiles, errors.Errorf("sha3-256-hash error getting an id file: %w", err)
 		}
diff --git a/pkg/types/healthcheck_challenge.go b/pkg/types/healthcheck_challenge.go
@@ -158,7 +158,7 @@ type HealthCheckChallengeMessages []HealthCheckMessage
 // Hash returns the hash of the health-check-challenge challenge log data
 func (mdl HealthCheckChallengeMessages) Hash() string {
 	data, _ := json.Marshal(mdl)
-	hash, _ := utils.Sha3256hash(data)
+	hash, _ := utils.Blake3Hash(data)
 
 	return string(hash)
 }
diff --git a/pkg/types/self_healing.go b/pkg/types/self_healing.go
diff --git a/pkg/types/storage_challenge.go b/pkg/types/storage_challenge.go
diff --git a/pkg/utils/healthcheckchallenge/health_check_challenge.go b/pkg/utils/healthcheckchallenge/health_check_challenge.go
diff --git a/pkg/utils/metrics/metrics.go b/pkg/utils/metrics/metrics.go
diff --git a/pkg/utils/storagechallenge/storage_challenge.go b/pkg/utils/storagechallenge/storage_challenge.go
diff --git a/pkg/utils/utils.go b/pkg/utils/utils.go
diff --git a/tests/integration/p2p/p2p_integration_test.go b/tests/integration/p2p/p2p_integration_test.go
diff --git a/tests/integration/securegrpc/secure_connection_test.go b/tests/integration/securegrpc/secure_connection_test.go

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ type Node struct {`
`29`	`29`	`// SetHashedID sets hash of ID`
`30`	`30`	`func (s *Node) SetHashedID() {`
`31`	`31`	`if len(s.HashedID) == 0 {`
`32`		`- s.HashedID, _ = utils.Sha3256hash(s.ID)`
	`32`	`+ s.HashedID, _ = utils.Blake3Hash(s.ID)`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`