fix: eliminate TOCTOU race in latestBlock hash/number updates

Combined latestBlockHash and latestBlockNumber into a single
latestBlockInfo struct protected by ds.Locked. This ensures
atomic updates and prevents race conditions where hash and
number could become mismatched when multiple goroutines
update concurrently.

Affected handlers:
- handleBlockRangeUpdate: uses atomic Update with conditional check
- handleNewBlockHashes: uses atomic Update with conditional check
- handleNewBlock: uses atomic Set (always authoritative)

Author: minhd-vu

p2p/conns.go

@@ -587,7 +587,8 @@ func (c *Conns) GetPeerLatestBlock(peerID string) (common.Hash, uint64) {
 	defer c.mu.RUnlock()
 
 	if cn, ok := c.conns[peerID]; ok {
-		return cn.latestBlockHash.Get(), cn.latestBlockNumber.Get()
+		info := cn.latestBlock.Get()
+		return info.Hash, info.Number
 	}
 
 	return common.Hash{}, 0

p2p/protocol.go

@@ -100,11 +100,16 @@ type conn struct {
 	// version stores the negotiated eth protocol version (e.g., 68 or 69).
 	version uint
 
-	// latestBlockHash and latestBlockNumber track the most recent block
-	// information received from this peer via NewBlock, NewBlockHashes,
-	// or BlockRangeUpdate messages. Uses ds.Locked for thread-safe API access.
-	latestBlockHash   *ds.Locked[common.Hash]
-	latestBlockNumber *ds.Locked[uint64]
+	// latestBlock tracks the most recent block information received from this
+	// peer via NewBlock, NewBlockHashes, or BlockRangeUpdate messages.
+	// Hash and number are combined in a single struct to ensure consistency.
+	latestBlock *ds.Locked[latestBlock]
+}
+
+// latestBlock holds the hash and number of the latest block from a peer.
+type latestBlock struct {
+	Hash   common.Hash
+	Number uint64
 }
 
 // EthProtocolOptions is the options used when creating a new eth protocol.
@@ -162,8 +167,7 @@ func NewEthProtocol(version uint, opts EthProtocolOptions) ethp2p.Protocol {
 				blockAnnounce:              make(chan eth.NewBlockHashesPacket, maxQueuedBlockAnns),
 				closeCh:                    make(chan struct{}),
 				version:                    version,
-				latestBlockHash:            &ds.Locked[common.Hash]{},
-				latestBlockNumber:          &ds.Locked[uint64]{},
+				latestBlock:                &ds.Locked[latestBlock]{},
 			}
 
 			// Ensure cleanup happens on any exit path (including statusExchange failure)
@@ -440,11 +444,13 @@ func (c *conn) handleBlockRangeUpdate(msg ethp2p.Msg) error {
 		Hex("hash", packet.LatestBlockHash[:]).
 		Msg("Received BlockRangeUpdate")
 
-	// Update latest block info from the range update (thread-safe for API access)
-	if packet.LatestBlock > c.latestBlockNumber.Get() {
-		c.latestBlockHash.Set(packet.LatestBlockHash)
-		c.latestBlockNumber.Set(packet.LatestBlock)
-	}
+	// Update latest block info atomically if this block is newer
+	c.latestBlock.Update(func(curr latestBlock) (latestBlock, bool) {
+		if packet.LatestBlock > curr.Number {
+			return latestBlock{Hash: packet.LatestBlockHash, Number: packet.LatestBlock}, true
+		}
+		return curr, false
+	})
 
 	return nil
 }
@@ -543,11 +549,13 @@ func (c *conn) handleNewBlockHashes(ctx context.Context, msg ethp2p.Msg) error {
 	for _, entry := range packet {
 		hash := entry.Hash
 
-		// Update latest block info if this block is newer (thread-safe for API access)
-		if entry.Number > c.latestBlockNumber.Get() {
-			c.latestBlockHash.Set(hash)
-			c.latestBlockNumber.Set(entry.Number)
-		}
+		// Update latest block info atomically if this block is newer
+		c.latestBlock.Update(func(current latestBlock) (latestBlock, bool) {
+			if entry.Number > current.Number {
+				return latestBlock{Hash: hash, Number: entry.Number}, true
+			}
+			return current, false
+		})
 
 		// Mark as known from this peer
 		c.addKnownBlock(hash)
@@ -1123,9 +1131,14 @@ func (c *conn) handleNewBlock(ctx context.Context, msg ethp2p.Msg) error {
 
 	c.countMsgReceived(packet.Name(), 1)
 
-	// Update latest block info for this peer (thread-safe for API access)
-	c.latestBlockHash.Set(hash)
-	c.latestBlockNumber.Set(packet.Block.Number().Uint64())
+	// Update latest block info atomically if this block is newer
+	blockNum := packet.Block.Number().Uint64()
+	c.latestBlock.Update(func(current latestBlock) (latestBlock, bool) {
+		if blockNum > current.Number {
+			return latestBlock{Hash: hash, Number: blockNum}, true
+		}
+		return current, false
+	})
 
 	// Mark block as known from this peer
 	c.addKnownBlock(hash)