Binary encoding of networkID (#205)

* networkIID - binary encoding
* refactor handshake tests

pkg/p2p/libp2p/internal/handshake/handshake.go

@@ -6,9 +6,9 @@ package handshake
 
 import (
 	"bytes"
+	"encoding/binary"
 	"errors"
 	"fmt"
-	"strconv"
 	"sync"
 	"time"
 
@@ -55,6 +55,7 @@ type Service struct {
 	signature            []byte
 	signer               crypto.Signer
 	networkID            uint64
+	networkIDBytes       []byte
 	receivedHandshakes   map[libp2ppeer.ID]struct{}
 	receivedHandshakesMu sync.Mutex
 	logger               logging.Logger
@@ -62,18 +63,26 @@ type Service struct {
 	network.Notifiee // handhsake service can be the receiver for network.Notify
 }
 
-func New(overlay swarm.Address, underlay string, signer crypto.Signer, networkID uint64, logger logging.Logger) (*Service, error) {
-	signature, err := signer.Sign([]byte(underlay + strconv.FormatUint(networkID, 10)))
+func New(overlay swarm.Address, peerID libp2ppeer.ID, signer crypto.Signer, networkID uint64, logger logging.Logger) (*Service, error) {
+	underlay, err := peerID.MarshalBinary()
+	if err != nil {
+		return nil, err
+	}
+
+	networkIDBytes := make([]byte, 8)
+	binary.BigEndian.PutUint64(networkIDBytes, networkID)
+	signature, err := signer.Sign(append(underlay, networkIDBytes...))
 	if err != nil {
 		return nil, err
 	}
 
 	return &Service{
 		overlay:            overlay,
-		underlay:           []byte(underlay),
+		underlay:           underlay,
 		signature:          signature,
 		signer:             signer,
 		networkID:          networkID,
+		networkIDBytes:     networkIDBytes,
 		receivedHandshakes: make(map[libp2ppeer.ID]struct{}),
 		logger:             logger,
 		Notifiee:           new(network.NoopNotifiee),
@@ -113,7 +122,6 @@ func (s *Service) Handshake(stream p2p.Stream) (i *Info, err error) {
 	}
 
 	s.logger.Tracef("handshake finished for peer %s", swarm.NewAddress(resp.Syn.BzzAddress.Overlay).String())
-
 	return &Info{
 		Overlay:   swarm.NewAddress(resp.Syn.BzzAddress.Overlay),
 		Underlay:  resp.Syn.BzzAddress.Underlay,
@@ -185,7 +193,7 @@ func (s *Service) checkSyn(syn *pb.Syn) error {
 		return ErrNetworkIDIncompatible
 	}
 
-	recoveredPK, err := crypto.Recover(syn.BzzAddress.Signature, append(syn.BzzAddress.Underlay, strconv.FormatUint(syn.NetworkID, 10)...))
+	recoveredPK, err := crypto.Recover(syn.BzzAddress.Signature, append(syn.BzzAddress.Underlay, s.networkIDBytes...))
 	if err != nil {
 		return ErrInvalidSignature
 	}

pkg/p2p/libp2p/libp2p.go

@@ -47,7 +47,7 @@ type Service struct {
 	metrics          metrics
 	networkID        uint64
 	handshakeService *handshake.Service
-	addrssbook       addressbook.Putter
+	addressbook      addressbook.Putter
 	peers            *peerRegistry
 	peerHandler      func(context.Context, swarm.Address) error
 	conectionBreaker breaker.Interface
@@ -154,7 +154,7 @@ func New(ctx context.Context, signer beecrypto.Signer, networkID uint64, overlay
 		return nil, fmt.Errorf("autonat: %w", err)
 	}
 
-	handshakeService, err := handshake.New(overlay, h.ID().String(), signer, networkID, o.Logger)
+	handshakeService, err := handshake.New(overlay, h.ID(), signer, networkID, o.Logger)
 	if err != nil {
 		return nil, fmt.Errorf("handshake service: %w", err)
 	}
@@ -168,7 +168,7 @@ func New(ctx context.Context, signer beecrypto.Signer, networkID uint64, overlay
 		networkID:        networkID,
 		handshakeService: handshakeService,
 		peers:            peerRegistry,
-		addrssbook:       o.Addressbook,
+		addressbook:      o.Addressbook,
 		logger:           o.Logger,
 		tracer:           o.Tracer,
 		conectionBreaker: breaker.NewBreaker(breaker.Options{}), // todo: fill non-default options
@@ -206,7 +206,7 @@ func New(ctx context.Context, signer beecrypto.Signer, networkID uint64, overlay
 			return
 		}
 
-		err = s.addrssbook.Put(i.Overlay, remoteMultiaddr)
+		err = s.addressbook.Put(i.Overlay, remoteMultiaddr)
 		if err != nil {
 			s.logger.Debugf("handshake: addressbook put error %s: %v", peerID, err)
 			s.logger.Errorf("unable to persist peer %v", peerID)