Skip to content

M
mybee
Commit 2db9d81f authored by Petar Radovic's avatar Petar Radovic Committed by GitHub
Browse files
Options

Signing in handshake (#196) 

* signing in handshake & Signer interface
parent 70ff4fa9
Show whitespace changes
Inline Side-by-side
Showing with 925 additions and 284 deletions
pkg/crypto/signer.go 0 → 100644
View file @ 2db9d81f
// Copyright 2020 The Swarm Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package crypto
import (
"crypto/ecdsa"
"github.com/btcsuite/btcd/btcec"
)
type Signer interface {
Sign(data []byte) ([]byte, error)
PublicKey() (*ecdsa.PublicKey, error)
}
// Recover verifies signature with the data base provided.
// It is using `btcec.RecoverCompact` function
func Recover(signature, data []byte) (*ecdsa.PublicKey, error) {
p, _, err := btcec.RecoverCompact(btcec.S256(), signature, data)
return (*ecdsa.PublicKey)(p), err
}
type defaultSigner struct {
key *ecdsa.PrivateKey
}
func NewDefaultSigner(key *ecdsa.PrivateKey) Signer {
return &defaultSigner{
key: key,
}
}
func (d *defaultSigner) PublicKey() (*ecdsa.PublicKey, error) {
return &d.key.PublicKey, nil
}
func (d *defaultSigner) Sign(data []byte) (signature []byte, err error) {
return btcec.SignCompact(btcec.S256(), (*btcec.PrivateKey)(d.key), data, true)
}
pkg/crypto/signer_test.go 0 → 100644
View file @ 2db9d81f
// Copyright 2020 The Swarm Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package crypto_test
import (
"testing"
"github.com/ethersphere/bee/pkg/crypto"
)
func TestDefaultSigner(t *testing.T) {
testBytes := []byte("test string")
privKey, err := crypto.GenerateSecp256k1Key()
if err != nil {
t.Fatal(err)
}
signer := crypto.NewDefaultSigner(privKey)
signature, err := signer.Sign(testBytes)
if err != nil {
t.Fatal(err)
}
t.Run("OK - sign & recover", func(t *testing.T) {
pubKey, err := crypto.Recover(signature, testBytes)
if err != nil {
t.Fatal(err)
}
if pubKey.X.Cmp(privKey.PublicKey.X) != 0 || pubKey.Y.Cmp(privKey.PublicKey.Y) != 0 {
t.Fatalf("wanted %v but got %v", pubKey, &privKey.PublicKey)
}
})
t.Run("OK - recover with invalid data", func(t *testing.T) {
pubKey, err := crypto.Recover(signature, []byte("invalid"))
if err != nil {
t.Fatal(err)
}
if pubKey.X.Cmp(privKey.PublicKey.X) == 0 && pubKey.Y.Cmp(privKey.PublicKey.Y) == 0 {
t.Fatal("expected different public key")
}
})
}
pkg/node/node.go
View file @ 2db9d81f
......@@ -134,13 +134,10 @@ func NewBee(o Options) (*Bee, error) {
b.stateStoreCloser = stateStore
addressbook := addressbook.New(stateStore)
p2ps, err := libp2p.New(p2pCtx, libp2p.Options{
p2ps, err := libp2p.New(p2pCtx, crypto.NewDefaultSigner(swarmPrivateKey), o.NetworkID, address, o.Addr, libp2p.Options{
PrivateKey: libp2pPrivateKey,
Overlay: address,
Addr: o.Addr,
DisableWS: o.DisableWS,
DisableQUIC: o.DisableQUIC,
NetworkID: o.NetworkID,
Addressbook: addressbook,
Logger: logger,
Tracer: tracer,
......
pkg/p2p/libp2p/connections_test.go
View file @ 2db9d81f
......@@ -16,7 +16,7 @@ import (
)
func TestAddresses(t *testing.T) {
s, _, cleanup := newService(t, libp2p.Options{NetworkID: 1})
s, _, cleanup := newService(t, 1, libp2p.Options{})
defer cleanup()
addrs, err := s.Addresses()
......@@ -32,10 +32,10 @@ func TestConnectDisconnect(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
addr := serviceUnderlayAddress(t, s1)
......@@ -60,10 +60,10 @@ func TestDoubleConnect(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
addr := serviceUnderlayAddress(t, s1)
......@@ -87,10 +87,10 @@ func TestDoubleDisconnect(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
addr := serviceUnderlayAddress(t, s1)
......@@ -122,10 +122,10 @@ func TestMultipleConnectDisconnect(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
addr := serviceUnderlayAddress(t, s1)
......@@ -165,10 +165,10 @@ func TestConnectDisconnectOnAllAddresses(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
addrs, err := s1.Addresses()
......@@ -197,10 +197,10 @@ func TestDoubleConnectOnAllAddresses(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
addrs, err := s1.Addresses()
......@@ -235,10 +235,10 @@ func TestDifferentNetworkIDs(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, _, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, _, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, _, cleanup2 := newService(t, libp2p.Options{NetworkID: 2})
s2, _, cleanup2 := newService(t, 2, libp2p.Options{})
defer cleanup2()
addr := serviceUnderlayAddress(t, s1)
......@@ -255,15 +255,13 @@ func TestConnectWithDisabledQUICAndWSTransports(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{
NetworkID: 1,
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{
DisableQUIC: true,
DisableWS: true,
})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{
NetworkID: 1,
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{
DisableQUIC: true,
DisableWS: true,
})
......@@ -284,10 +282,10 @@ func TestConnectRepeatHandshake(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
addr := serviceUnderlayAddress(t, s1)
......
pkg/p2p/libp2p/headers_test.go
View file @ 2db9d81f
......@@ -23,10 +23,10 @@ func TestHeaders(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
var gotHeaders p2p.Headers
......@@ -72,10 +72,10 @@ func TestHeaders_empty(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
var gotHeaders p2p.Headers
......@@ -130,10 +130,10 @@ func TestHeadler(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, _, cleanup2 := newService(t, libp2p.Options{})
s2, _, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
var gotReceivedHeaders p2p.Headers
......
pkg/p2p/libp2p/internal/handshake/handshake.go
View file @ 2db9d81f
......@@ -5,11 +5,14 @@
package handshake
import (
"bytes"
"errors"
"fmt"
"strconv"
"sync"
"time"
"github.com/ethersphere/bee/pkg/crypto"
"github.com/ethersphere/bee/pkg/logging"
"github.com/ethersphere/bee/pkg/p2p"
"github.com/ethersphere/bee/pkg/p2p/libp2p/internal/handshake/pb"
......@@ -27,13 +30,19 @@ const (
messageTimeout = 5 * time.Second // maximum allowed time for a message to be read or written.
)
// ErrNetworkIDIncompatible should be returned by handshake handlers if
// response from the other peer does not have valid networkID.
var ErrNetworkIDIncompatible = errors.New("incompatible network ID")
var (
// ErrNetworkIDIncompatible is returned if response from the other peer does not have valid networkID.
ErrNetworkIDIncompatible = errors.New("incompatible network ID")
// ErrHandshakeDuplicate should be returned by handshake handlers if
// the handshake response has been received by an already processed peer.
var ErrHandshakeDuplicate = errors.New("duplicate handshake")
// ErrHandshakeDuplicate is returned if the handshake response has been received by an already processed peer.
ErrHandshakeDuplicate = errors.New("duplicate handshake")
// ErrInvalidSignature is returned if peer info was received with invalid signature
ErrInvalidSignature = errors.New("invalid signature")
// ErrInvalidAck is returned if ack does not match the syn provided
ErrInvalidAck = errors.New("invalid ack")
)
// PeerFinder has the information if the peer already exists in swarm.
type PeerFinder interface {
......@@ -42,6 +51,9 @@ type PeerFinder interface {
type Service struct {
overlay swarm.Address
underlay []byte
signature []byte
signer crypto.Signer
networkID uint64
receivedHandshakes map[libp2ppeer.ID]struct{}
receivedHandshakesMu sync.Mutex
......@@ -50,20 +62,32 @@ type Service struct {
network.Notifiee // handhsake service can be the receiver for network.Notify
}
func New(overlay swarm.Address, networkID uint64, logger logging.Logger) *Service {
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)))
if err != nil {
return nil, err
}
return &Service{
overlay: overlay,
underlay: []byte(underlay),
signature: signature,
signer: signer,
networkID: networkID,
receivedHandshakes: make(map[libp2ppeer.ID]struct{}),
logger: logger,
Notifiee: new(network.NoopNotifiee),
}
}, nil
}
func (s *Service) Handshake(stream p2p.Stream) (i *Info, err error) {
w, r := protobuf.NewWriterAndReader(stream)
if err := w.WriteMsgWithTimeout(messageTimeout, &pb.Syn{
Address: s.overlay.Bytes(),
BzzAddress: &pb.BzzAddress{
Underlay: s.underlay,
Signature: s.signature,
Overlay: s.overlay.Bytes(),
},
NetworkID: s.networkID,
}); err != nil {
return nil, fmt.Errorf("write syn message: %w", err)
......@@ -74,21 +98,25 @@ func (s *Service) Handshake(stream p2p.Stream) (i *Info, err error) {
return nil, fmt.Errorf("read synack message: %w", err)
}
address := swarm.NewAddress(resp.Syn.Address)
if resp.Syn.NetworkID != s.networkID {
return nil, ErrNetworkIDIncompatible
if err := s.checkAck(resp.Ack); err != nil {
return nil, err
}
if err := s.checkSyn(resp.Syn); err != nil {
return nil, err
}
if err := w.WriteMsgWithTimeout(messageTimeout, &pb.Ack{
Address: resp.Syn.Address,
BzzAddress: resp.Syn.BzzAddress,
}); err != nil {
return nil, fmt.Errorf("write ack message: %w", err)
}
s.logger.Tracef("handshake finished for peer %s", address)
s.logger.Tracef("handshake finished for peer %s", swarm.NewAddress(resp.Syn.BzzAddress.Overlay).String())
return &Info{
Address: address,
Overlay: swarm.NewAddress(resp.Syn.BzzAddress.Overlay),
Underlay: resp.Syn.BzzAddress.Underlay,
NetworkID: resp.Syn.NetworkID,
Light: resp.Syn.Light,
}, nil
......@@ -110,17 +138,20 @@ func (s *Service) Handle(stream p2p.Stream, peerID libp2ppeer.ID) (i *Info, err
return nil, fmt.Errorf("read syn message: %w", err)
}
address := swarm.NewAddress(req.Address)
if req.NetworkID != s.networkID {
return nil, ErrNetworkIDIncompatible
if err := s.checkSyn(&req); err != nil {
return nil, err
}
if err := w.WriteMsgWithTimeout(messageTimeout, &pb.SynAck{
Syn: &pb.Syn{
Address: s.overlay.Bytes(),
BzzAddress: &pb.BzzAddress{
Underlay: s.underlay,
Signature: s.signature,
Overlay: s.overlay.Bytes(),
},
NetworkID: s.networkID,
},
Ack: &pb.Ack{Address: req.Address},
Ack: &pb.Ack{BzzAddress: req.BzzAddress},
}); err != nil {
return nil, fmt.Errorf("write synack message: %w", err)
}
......@@ -130,9 +161,14 @@ func (s *Service) Handle(stream p2p.Stream, peerID libp2ppeer.ID) (i *Info, err
return nil, fmt.Errorf("read ack message: %w", err)
}
s.logger.Tracef("handshake finished for peer %s", address)
if err := s.checkAck(&ack); err != nil {
return nil, err
}
s.logger.Tracef("handshake finished for peer %s", req.BzzAddress.Overlay)
return &Info{
Address: address,
Overlay: swarm.NewAddress(req.BzzAddress.Overlay),
Underlay: req.BzzAddress.Underlay,
NetworkID: req.NetworkID,
Light: req.Light,
}, nil
......@@ -144,8 +180,37 @@ func (s *Service) Disconnected(_ network.Network, c network.Conn) {
delete(s.receivedHandshakes, c.RemotePeer())
}
func (s *Service) checkSyn(syn *pb.Syn) error {
if syn.NetworkID != s.networkID {
return ErrNetworkIDIncompatible
}
recoveredPK, err := crypto.Recover(syn.BzzAddress.Signature, append(syn.BzzAddress.Underlay, strconv.FormatUint(syn.NetworkID, 10)...))
if err != nil {
return ErrInvalidSignature
}
recoveredOverlay := crypto.NewOverlayAddress(*recoveredPK, syn.NetworkID)
if !bytes.Equal(recoveredOverlay.Bytes(), syn.BzzAddress.Overlay) {
return ErrInvalidSignature
}
return nil
}
func (s *Service) checkAck(ack *pb.Ack) error {
if !bytes.Equal(ack.BzzAddress.Overlay, s.overlay.Bytes()) ||
!bytes.Equal(ack.BzzAddress.Underlay, s.underlay) ||
!bytes.Equal(ack.BzzAddress.Signature, s.signature) {
return ErrInvalidAck
}
return nil
}
type Info struct {
Address swarm.Address
Overlay swarm.Address
Underlay []byte
NetworkID uint64
Light bool
}
pkg/p2p/libp2p/internal/handshake/handshake_test.go
View file @ 2db9d81f
......@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package handshake
package handshake_test
import (
"bytes"
......@@ -11,7 +11,9 @@ import (
"io/ioutil"
"testing"
"github.com/ethersphere/bee/pkg/crypto"
"github.com/ethersphere/bee/pkg/logging"
"github.com/ethersphere/bee/pkg/p2p/libp2p/internal/handshake"
"github.com/ethersphere/bee/pkg/p2p/libp2p/internal/handshake/mock"
"github.com/ethersphere/bee/pkg/p2p/libp2p/internal/handshake/pb"
"github.com/ethersphere/bee/pkg/p2p/protobuf"
......@@ -22,24 +24,67 @@ import (
)
func TestHandshake(t *testing.T) {
node1Addr := swarm.MustParseHexAddress("ca1e9f3938cc1425c6061b96ad9eb93e134dfe8734ad490164ef20af9d1cf59c")
node2Addr := swarm.MustParseHexAddress("ca1e9f3938cc1425c6061b96ad9eb93e134dfe8734ad490164ef20af9d1cf59b")
node1Underlay := []byte("underlay1")
node2Underlay := []byte("underlay2")
logger := logging.New(ioutil.Discard, 0)
info := Info{
Address: node1Addr,
privateKey1, err := crypto.GenerateSecp256k1Key()
if err != nil {
t.Fatal(err)
}
privateKey2, err := crypto.GenerateSecp256k1Key()
if err != nil {
t.Fatal(err)
}
node1Overlay := crypto.NewOverlayAddress(privateKey1.PublicKey, 0)
node2Overlay := crypto.NewOverlayAddress(privateKey2.PublicKey, 0)
signer1 := crypto.NewDefaultSigner(privateKey1)
signer2 := crypto.NewDefaultSigner(privateKey2)
signature1, err := signer1.Sign([]byte("underlay10"))
if err != nil {
t.Fatal(err)
}
signature2, err := signer2.Sign([]byte("underlay20"))
if err != nil {
t.Fatal(err)
}
node1Info := handshake.Info{
Overlay: node1Overlay,
Underlay: node1Underlay,
NetworkID: 0,
Light: false,
}
handshakeService := New(info.Address, info.NetworkID, logger)
node1BzzAddress := &pb.BzzAddress{
Overlay: node1Info.Overlay.Bytes(),
Underlay: node1Info.Underlay,
Signature: signature1,
}
t.Run("OK", func(t *testing.T) {
expectedInfo := Info{
Address: node2Addr,
node2Info := handshake.Info{
Overlay: node2Overlay,
Underlay: node2Underlay,
NetworkID: 0,
Light: false,
}
node2BzzAddress := &pb.BzzAddress{
Overlay: node2Info.Overlay.Bytes(),
Underlay: node2Info.Underlay,
Signature: signature2,
}
handshakeService, err := handshake.New(node1Info.Overlay, string(node1Info.Underlay), signer1, 0, logger)
if err != nil {
t.Fatal(err)
}
t.Run("OK", func(t *testing.T) {
var buffer1 bytes.Buffer
var buffer2 bytes.Buffer
stream1 := mock.NewStream(&buffer1, &buffer2)
......@@ -48,11 +93,11 @@ func TestHandshake(t *testing.T) {
w, r := protobuf.NewWriterAndReader(stream2)
if err := w.WriteMsg(&pb.SynAck{
Syn: &pb.Syn{
Address: expectedInfo.Address.Bytes(),
NetworkID: expectedInfo.NetworkID,
Light: expectedInfo.Light,
BzzAddress: node2BzzAddress,
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
},
Ack: &pb.Ack{Address: info.Address.Bytes()},
Ack: &pb.Ack{BzzAddress: node1BzzAddress},
}); err != nil {
t.Fatal(err)
}
......@@ -62,7 +107,7 @@ func TestHandshake(t *testing.T) {
t.Fatal(err)
}
testInfo(t, *res, expectedInfo)
testInfo(t, *res, node2Info)
if err := r.ReadMsg(&pb.Ack{}); err != nil {
t.Fatal(err)
}
......@@ -101,26 +146,20 @@ func TestHandshake(t *testing.T) {
t.Run("ERROR - ack write error", func(t *testing.T) {
testErr := errors.New("test error")
expectedErr := fmt.Errorf("write ack message: %w", testErr)
expectedInfo := Info{
Address: node2Addr,
NetworkID: 0,
Light: false,
}
var buffer1 bytes.Buffer
var buffer2 bytes.Buffer
stream1 := mock.NewStream(&buffer1, &buffer2)
stream1.SetWriteErr(testErr, 1)
stream2 := mock.NewStream(&buffer2, &buffer1)
w, _ := protobuf.NewWriterAndReader(stream2)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.SynAck{
Syn: &pb.Syn{
Address: expectedInfo.Address.Bytes(),
NetworkID: expectedInfo.NetworkID,
Light: expectedInfo.Light,
BzzAddress: node2BzzAddress,
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
},
Ack: &pb.Ack{Address: info.Address.Bytes()},
Ack: &pb.Ack{BzzAddress: node1BzzAddress},
}); err != nil {
t.Fatal(err)
}
......@@ -136,25 +175,47 @@ func TestHandshake(t *testing.T) {
})
t.Run("ERROR - networkID mismatch", func(t *testing.T) {
node2Info := Info{
Address: node2Addr,
NetworkID: 2,
Light: false,
var buffer1 bytes.Buffer
var buffer2 bytes.Buffer
stream1 := mock.NewStream(&buffer1, &buffer2)
stream2 := mock.NewStream(&buffer2, &buffer1)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.SynAck{
Syn: &pb.Syn{
BzzAddress: node2BzzAddress,
NetworkID: 5,
Light: node2Info.Light,
},
Ack: &pb.Ack{BzzAddress: node1BzzAddress},
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handshake(stream1)
if res != nil {
t.Fatal("res should be nil")
}
if err != handshake.ErrNetworkIDIncompatible {
t.Fatalf("expected %s, got %s", handshake.ErrNetworkIDIncompatible, err)
}
})
t.Run("ERROR - invalid ack", func(t *testing.T) {
var buffer1 bytes.Buffer
var buffer2 bytes.Buffer
stream1 := mock.NewStream(&buffer1, &buffer2)
stream2 := mock.NewStream(&buffer2, &buffer1)
w, _ := protobuf.NewWriterAndReader(stream2)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.SynAck{
Syn: &pb.Syn{
Address: node2Info.Address.Bytes(),
BzzAddress: node2BzzAddress,
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
},
Ack: &pb.Ack{Address: info.Address.Bytes()},
Ack: &pb.Ack{BzzAddress: node2BzzAddress},
}); err != nil {
t.Fatal(err)
}
......@@ -164,58 +225,133 @@ func TestHandshake(t *testing.T) {
t.Fatal("res should be nil")
}
if err != ErrNetworkIDIncompatible {
t.Fatalf("expected %s, got %s", ErrNetworkIDIncompatible, err)
if err != handshake.ErrInvalidAck {
t.Fatalf("expected %s, got %s", handshake.ErrInvalidAck, err)
}
})
t.Run("ERROR - invalid signature", func(t *testing.T) {
var buffer1 bytes.Buffer
var buffer2 bytes.Buffer
stream1 := mock.NewStream(&buffer1, &buffer2)
stream2 := mock.NewStream(&buffer2, &buffer1)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.SynAck{
Syn: &pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay,
Signature: []byte("wrong signature"),
Overlay: node2BzzAddress.Overlay,
},
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
},
Ack: &pb.Ack{BzzAddress: node1BzzAddress},
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handshake(stream1)
if res != nil {
t.Fatal("res should be nil")
}
if err != handshake.ErrInvalidSignature {
t.Fatalf("expected %s, got %s", handshake.ErrInvalidSignature, err)
}
})
}
func TestHandle(t *testing.T) {
node1Addr := swarm.MustParseHexAddress("ca1e9f3938cc1425c6061b96ad9eb93e134dfe8734ad490164ef20af9d1cf59c")
node2Addr := swarm.MustParseHexAddress("ca1e9f3938cc1425c6061b96ad9eb93e134dfe8734ad490164ef20af9d1cf59b")
multiaddress, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/7070/p2p/16Uiu2HAkx8ULY8cTXhdVAcMmLcH9AsTKz6uBQ7DPLKRjMLgBVYkS")
privateKey1, err := crypto.GenerateSecp256k1Key()
if err != nil {
t.Fatal(err)
}
privateKey2, err := crypto.GenerateSecp256k1Key()
if err != nil {
t.Fatal(err)
}
info, err := peer.AddrInfoFromP2pAddr(multiaddress)
node1Overlay := crypto.NewOverlayAddress(privateKey1.PublicKey, 0)
node2Overlay := crypto.NewOverlayAddress(privateKey2.PublicKey, 0)
node2ma, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/7070/p2p/16Uiu2HAkx8ULY8cTXhdVAcMmLcH9AsTKz6uBQ7DPLKRjMLgBVYkS")
if err != nil {
t.Fatal(err)
}
nodeInfo := Info{
Address: node1Addr,
node2AddrInfo, err := peer.AddrInfoFromP2pAddr(node2ma)
if err != nil {
t.Fatal(err)
}
node1Underlay := []byte("underlay1")
node2Underlay := []byte("16Uiu2HAkx8ULY8cTXhdVAcMmLcH9AsTKz6uBQ7DPLKRjMLgBVYkS")
node1Info := handshake.Info{
Overlay: node1Overlay,
Underlay: node1Underlay,
NetworkID: 0,
Light: false,
}
logger := logging.New(ioutil.Discard, 0)
t.Run("OK", func(t *testing.T) {
handshakeService := New(nodeInfo.Address, nodeInfo.NetworkID, logger)
node2Info := Info{
Address: node2Addr,
signer1 := crypto.NewDefaultSigner(privateKey1)
signer2 := crypto.NewDefaultSigner(privateKey2)
signature1, err := signer1.Sign([]byte("underlay10"))
if err != nil {
t.Fatal(err)
}
signature2, err := signer2.Sign([]byte("16Uiu2HAkx8ULY8cTXhdVAcMmLcH9AsTKz6uBQ7DPLKRjMLgBVYkS0"))
if err != nil {
t.Fatal(err)
}
node2Info := handshake.Info{
Overlay: node2Overlay,
Underlay: node2Underlay,
NetworkID: 0,
Light: false,
}
node1BzzAddress := &pb.BzzAddress{
Overlay: node1Info.Overlay.Bytes(),
Underlay: node1Info.Underlay,
Signature: signature1,
}
node2BzzAddress := &pb.BzzAddress{
Overlay: node2Info.Overlay.Bytes(),
Underlay: node2Info.Underlay,
Signature: signature2,
}
logger := logging.New(ioutil.Discard, 0)
t.Run("OK", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.Overlay, string(node1Info.Underlay), signer1, 0, logger)
if err != nil {
t.Fatal(err)
}
var buffer1 bytes.Buffer
var buffer2 bytes.Buffer
stream1 := mock.NewStream(&buffer1, &buffer2)
stream2 := mock.NewStream(&buffer2, &buffer1)
w, _ := protobuf.NewWriterAndReader(stream2)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
Address: node2Info.Address.Bytes(),
BzzAddress: node2BzzAddress,
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
}); err != nil {
t.Fatal(err)
}
if err := w.WriteMsg(&pb.Ack{Address: node2Info.Address.Bytes()}); err != nil {
if err := w.WriteMsg(&pb.Ack{BzzAddress: node1BzzAddress}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, info.ID)
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
if err != nil {
t.Fatal(err)
}
......@@ -228,20 +364,25 @@ func TestHandle(t *testing.T) {
t.Fatal(err)
}
testInfo(t, nodeInfo, Info{
Address: swarm.NewAddress(got.Syn.Address),
testInfo(t, node1Info, handshake.Info{
Overlay: swarm.NewAddress(got.Syn.BzzAddress.Overlay),
Underlay: got.Syn.BzzAddress.Underlay,
NetworkID: got.Syn.NetworkID,
Light: got.Syn.Light,
})
})
t.Run("ERROR - read error ", func(t *testing.T) {
handshakeService := New(nodeInfo.Address, nodeInfo.NetworkID, logger)
handshakeService, err := handshake.New(node1Info.Overlay, string(node1Info.Underlay), signer1, 0, logger)
if err != nil {
t.Fatal(err)
}
testErr := errors.New("test error")
expectedErr := fmt.Errorf("read syn message: %w", testErr)
stream := &mock.Stream{}
stream.SetReadErr(testErr, 0)
res, err := handshakeService.Handle(stream, info.ID)
res, err := handshakeService.Handle(stream, node2AddrInfo.ID)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatal("expected:", expectedErr, "got:", err)
}
......@@ -252,22 +393,26 @@ func TestHandle(t *testing.T) {
})
t.Run("ERROR - write error ", func(t *testing.T) {
handshakeService := New(nodeInfo.Address, nodeInfo.NetworkID, logger)
handshakeService, err := handshake.New(node1Info.Overlay, string(node1Info.Underlay), signer1, 0, logger)
if err != nil {
t.Fatal(err)
}
testErr := errors.New("test error")
expectedErr := fmt.Errorf("write synack message: %w", testErr)
var buffer bytes.Buffer
stream := mock.NewStream(&buffer, &buffer)
stream.SetWriteErr(testErr, 1)
w, _ := protobuf.NewWriterAndReader(stream)
w := protobuf.NewWriter(stream)
if err := w.WriteMsg(&pb.Syn{
Address: node1Addr.Bytes(),
NetworkID: 0,
Light: false,
BzzAddress: node2BzzAddress,
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream, info.ID)
res, err := handshakeService.Handle(stream, node2AddrInfo.ID)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatal("expected:", expectedErr, "got:", err)
}
......@@ -278,30 +423,28 @@ func TestHandle(t *testing.T) {
})
t.Run("ERROR - ack read error ", func(t *testing.T) {
handshakeService := New(nodeInfo.Address, nodeInfo.NetworkID, logger)
testErr := errors.New("test error")
expectedErr := fmt.Errorf("read ack message: %w", testErr)
node2Info := Info{
Address: node2Addr,
NetworkID: 0,
Light: false,
handshakeService, err := handshake.New(node1Info.Overlay, string(node1Info.Underlay), signer1, 0, logger)
if err != nil {
t.Fatal(err)
}
testErr := errors.New("test error")
expectedErr := fmt.Errorf("read ack message: %w", testErr)
var buffer1 bytes.Buffer
var buffer2 bytes.Buffer
stream1 := mock.NewStream(&buffer1, &buffer2)
stream2 := mock.NewStream(&buffer2, &buffer1)
stream1.SetReadErr(testErr, 1)
w, _ := protobuf.NewWriterAndReader(stream2)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
Address: node2Info.Address.Bytes(),
BzzAddress: node2BzzAddress,
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, info.ID)
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatal("expected:", expectedErr, "got:", err)
}
......@@ -312,11 +455,9 @@ func TestHandle(t *testing.T) {
})
t.Run("ERROR - networkID mismatch ", func(t *testing.T) {
handshakeService := New(nodeInfo.Address, nodeInfo.NetworkID, logger)
node2Info := Info{
Address: node2Addr,
NetworkID: 2,
Light: false,
handshakeService, err := handshake.New(node1Info.Overlay, string(node1Info.Underlay), signer1, 0, logger)
if err != nil {
t.Fatal(err)
}
var buffer1 bytes.Buffer
......@@ -324,31 +465,29 @@ func TestHandle(t *testing.T) {
stream1 := mock.NewStream(&buffer1, &buffer2)
stream2 := mock.NewStream(&buffer2, &buffer1)
w, _ := protobuf.NewWriterAndReader(stream2)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
Address: node2Info.Address.Bytes(),
NetworkID: node2Info.NetworkID,
BzzAddress: node2BzzAddress,
NetworkID: 5,
Light: node2Info.Light,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, info.ID)
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
if res != nil {
t.Fatal("res should be nil")
}
if err != ErrNetworkIDIncompatible {
t.Fatalf("expected %s, got %s", ErrNetworkIDIncompatible, err)
if err != handshake.ErrNetworkIDIncompatible {
t.Fatalf("expected %s, got %s", handshake.ErrNetworkIDIncompatible, err)
}
})
t.Run("ERROR - duplicate handshake", func(t *testing.T) {
handshakeService := New(nodeInfo.Address, nodeInfo.NetworkID, logger)
node2Info := Info{
Address: node2Addr,
NetworkID: 0,
Light: false,
handshakeService, err := handshake.New(node1Info.Overlay, string(node1Info.Underlay), signer1, 0, logger)
if err != nil {
t.Fatal(err)
}
var buffer1 bytes.Buffer
......@@ -356,20 +495,20 @@ func TestHandle(t *testing.T) {
stream1 := mock.NewStream(&buffer1, &buffer2)
stream2 := mock.NewStream(&buffer2, &buffer1)
w, _ := protobuf.NewWriterAndReader(stream2)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
Address: node2Info.Address.Bytes(),
BzzAddress: node2BzzAddress,
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
}); err != nil {
t.Fatal(err)
}
if err := w.WriteMsg(&pb.Ack{Address: node2Info.Address.Bytes()}); err != nil {
if err := w.WriteMsg(&pb.Ack{BzzAddress: node1BzzAddress}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, info.ID)
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
if err != nil {
t.Fatal(err)
}
......@@ -382,24 +521,89 @@ func TestHandle(t *testing.T) {
t.Fatal(err)
}
testInfo(t, nodeInfo, Info{
Address: swarm.NewAddress(got.Syn.Address),
testInfo(t, node1Info, handshake.Info{
Overlay: swarm.NewAddress(got.Syn.BzzAddress.Overlay),
Underlay: got.Syn.BzzAddress.Underlay,
NetworkID: got.Syn.NetworkID,
Light: got.Syn.Light,
})
_, err = handshakeService.Handle(stream1, info.ID)
if err != ErrHandshakeDuplicate {
t.Fatalf("expected %s err, got %s err", ErrHandshakeDuplicate, err)
_, err = handshakeService.Handle(stream1, node2AddrInfo.ID)
if err != handshake.ErrHandshakeDuplicate {
t.Fatalf("expected %s, got %s", handshake.ErrHandshakeDuplicate, err)
}
})
t.Run("Error - invalid ack", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.Overlay, string(node1Info.Underlay), signer1, 0, logger)
if err != nil {
t.Fatal(err)
}
var buffer1 bytes.Buffer
var buffer2 bytes.Buffer
stream1 := mock.NewStream(&buffer1, &buffer2)
stream2 := mock.NewStream(&buffer2, &buffer1)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
BzzAddress: node2BzzAddress,
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
}); err != nil {
t.Fatal(err)
}
if err := w.WriteMsg(&pb.Ack{BzzAddress: node2BzzAddress}); err != nil {
t.Fatal(err)
}
_, err = handshakeService.Handle(stream1, node2AddrInfo.ID)
if err != handshake.ErrInvalidAck {
t.Fatalf("expected %s, got %s", handshake.ErrInvalidAck, err)
}
})
t.Run("ERROR - invalid signature ", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.Overlay, string(node1Info.Underlay), signer1, 0, logger)
if err != nil {
t.Fatal(err)
}
var buffer1 bytes.Buffer
var buffer2 bytes.Buffer
stream1 := mock.NewStream(&buffer1, &buffer2)
stream2 := mock.NewStream(&buffer2, &buffer1)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay,
Signature: []byte("wrong signature"),
Overlay: node2BzzAddress.Overlay,
},
NetworkID: node2Info.NetworkID,
Light: node2Info.Light,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
if res != nil {
t.Fatal("res should be nil")
}
if err != handshake.ErrInvalidSignature {
t.Fatalf("expected %s, got %s", handshake.ErrInvalidSignature, err)
}
})
}
// testInfo validates if two Info instances are equal.
func testInfo(t *testing.T, got, want Info) {
func testInfo(t *testing.T, got, want handshake.Info) {
t.Helper()
if !got.Address.Equal(want.Address) || got.NetworkID != want.NetworkID || got.Light != want.Light {
if !got.Overlay.Equal(want.Overlay) || !bytes.Equal(got.Underlay, want.Underlay) || got.NetworkID != want.NetworkID || got.Light != want.Light {
t.Fatalf("got info %+v, want %+v", got, want)
}
}
pkg/p2p/libp2p/internal/handshake/pb/handshake.pb.go
View file @ 2db9d81f
......@@ -23,7 +23,7 @@ var _ = math.Inf
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type Syn struct {
Address []byte `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
BzzAddress *BzzAddress `protobuf:"bytes,1,opt,name=BzzAddress,proto3" json:"BzzAddress,omitempty"`
NetworkID uint64 `protobuf:"varint,2,opt,name=NetworkID,proto3" json:"NetworkID,omitempty"`
Light bool `protobuf:"varint,3,opt,name=Light,proto3" json:"Light,omitempty"`
}
......@@ -61,9 +61,9 @@ func (m *Syn) XXX_DiscardUnknown() {
var xxx_messageInfo_Syn proto.InternalMessageInfo
func (m *Syn) GetAddress() []byte {
func (m *Syn) GetBzzAddress() *BzzAddress {
if m != nil {
return m.Address
return m.BzzAddress
}
return nil
}
......@@ -82,6 +82,50 @@ func (m *Syn) GetLight() bool {
return false
}
type Ack struct {
BzzAddress *BzzAddress `protobuf:"bytes,1,opt,name=BzzAddress,proto3" json:"BzzAddress,omitempty"`
}
func (m *Ack) Reset() { *m = Ack{} }
func (m *Ack) String() string { return proto.CompactTextString(m) }
func (*Ack) ProtoMessage() {}
func (*Ack) Descriptor() ([]byte, []int) {
return fileDescriptor_a77305914d5d202f, []int{1}
}
func (m *Ack) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Ack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Ack.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Ack) XXX_Merge(src proto.Message) {
xxx_messageInfo_Ack.Merge(m, src)
}
func (m *Ack) XXX_Size() int {
return m.Size()
}
func (m *Ack) XXX_DiscardUnknown() {
xxx_messageInfo_Ack.DiscardUnknown(m)
}
var xxx_messageInfo_Ack proto.InternalMessageInfo
func (m *Ack) GetBzzAddress() *BzzAddress {
if m != nil {
return m.BzzAddress
}
return nil
}
type SynAck struct {
Syn *Syn `protobuf:"bytes,1,opt,name=Syn,proto3" json:"Syn,omitempty"`
Ack *Ack `protobuf:"bytes,2,opt,name=Ack,proto3" json:"Ack,omitempty"`
......@@ -91,7 +135,7 @@ func (m *SynAck) Reset() { *m = SynAck{} }
func (m *SynAck) String() string { return proto.CompactTextString(m) }
func (*SynAck) ProtoMessage() {}
func (*SynAck) Descriptor() ([]byte, []int) {
return fileDescriptor_a77305914d5d202f, []int{1}
return fileDescriptor_a77305914d5d202f, []int{2}
}
func (m *SynAck) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
......@@ -134,22 +178,24 @@ func (m *SynAck) GetAck() *Ack {
return nil
}
type Ack struct {
Address []byte `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
type BzzAddress struct {
Underlay []byte `protobuf:"bytes,1,opt,name=Underlay,proto3" json:"Underlay,omitempty"`
Signature []byte `protobuf:"bytes,2,opt,name=Signature,proto3" json:"Signature,omitempty"`
Overlay []byte `protobuf:"bytes,3,opt,name=Overlay,proto3" json:"Overlay,omitempty"`
}
func (m *Ack) Reset() { *m = Ack{} }
func (m *Ack) String() string { return proto.CompactTextString(m) }
func (*Ack) ProtoMessage() {}
func (*Ack) Descriptor() ([]byte, []int) {
return fileDescriptor_a77305914d5d202f, []int{2}
func (m *BzzAddress) Reset() { *m = BzzAddress{} }
func (m *BzzAddress) String() string { return proto.CompactTextString(m) }
func (*BzzAddress) ProtoMessage() {}
func (*BzzAddress) Descriptor() ([]byte, []int) {
return fileDescriptor_a77305914d5d202f, []int{3}
}
func (m *Ack) XXX_Unmarshal(b []byte) error {
func (m *BzzAddress) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Ack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *BzzAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Ack.Marshal(b, m, deterministic)
return xxx_messageInfo_BzzAddress.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
......@@ -159,48 +205,67 @@ func (m *Ack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return b[:n], nil
}
}
func (m *Ack) XXX_Merge(src proto.Message) {
xxx_messageInfo_Ack.Merge(m, src)
func (m *BzzAddress) XXX_Merge(src proto.Message) {
xxx_messageInfo_BzzAddress.Merge(m, src)
}
func (m *Ack) XXX_Size() int {
func (m *BzzAddress) XXX_Size() int {
return m.Size()
}
func (m *Ack) XXX_DiscardUnknown() {
xxx_messageInfo_Ack.DiscardUnknown(m)
func (m *BzzAddress) XXX_DiscardUnknown() {
xxx_messageInfo_BzzAddress.DiscardUnknown(m)
}
var xxx_messageInfo_Ack proto.InternalMessageInfo
var xxx_messageInfo_BzzAddress proto.InternalMessageInfo
func (m *BzzAddress) GetUnderlay() []byte {
if m != nil {
return m.Underlay
}
return nil
}
func (m *BzzAddress) GetSignature() []byte {
if m != nil {
return m.Signature
}
return nil
}
func (m *Ack) GetAddress() []byte {
func (m *BzzAddress) GetOverlay() []byte {
if m != nil {
return m.Address
return m.Overlay
}
return nil
}
func init() {
proto.RegisterType((*Syn)(nil), "handshake.Syn")
proto.RegisterType((*SynAck)(nil), "handshake.SynAck")
proto.RegisterType((*Ack)(nil), "handshake.Ack")
proto.RegisterType((*SynAck)(nil), "handshake.SynAck")
proto.RegisterType((*BzzAddress)(nil), "handshake.BzzAddress")
}
func init() { proto.RegisterFile("handshake.proto", fileDescriptor_a77305914d5d202f) }
var fileDescriptor_a77305914d5d202f = []byte{
// 199 bytes of a gzipped FileDescriptorProto
// 257 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xcf, 0x48, 0xcc, 0x4b,
0x29, 0xce, 0x48, 0xcc, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0x0b, 0x28,
0x05, 0x73, 0x31, 0x07, 0x57, 0xe6, 0x09, 0x49, 0x70, 0xb1, 0x3b, 0xa6, 0xa4, 0x14, 0xa5, 0x16,
0x17, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x04, 0xc1, 0xb8, 0x42, 0x32, 0x5c, 0x9c, 0x7e, 0xa9,
0x25, 0xe5, 0xf9, 0x45, 0xd9, 0x9e, 0x2e, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0x2c, 0x41, 0x08, 0x01,
0x21, 0x11, 0x2e, 0x56, 0x9f, 0xcc, 0xf4, 0x8c, 0x12, 0x09, 0x66, 0x05, 0x46, 0x0d, 0x8e, 0x20,
0x08, 0x47, 0xc9, 0x87, 0x8b, 0x2d, 0xb8, 0x32, 0xcf, 0x31, 0x39, 0x5b, 0x48, 0x01, 0x6c, 0x3c,
0xd8, 0x4c, 0x6e, 0x23, 0x3e, 0x3d, 0x84, 0x43, 0x82, 0x2b, 0xf3, 0x82, 0xc0, 0x36, 0x2b, 0x70,
0x31, 0x3b, 0x26, 0x67, 0x83, 0x4d, 0x46, 0x55, 0xe1, 0x98, 0x9c, 0x1d, 0x04, 0x92, 0x52, 0x92,
0x07, 0xab, 0xc0, 0xed, 0x44, 0x27, 0x99, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c,
0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63,
0x88, 0x62, 0x2a, 0x48, 0x4a, 0x62, 0x03, 0xfb, 0xd9, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x04,
0x2c, 0x04, 0x89, 0x06, 0x01, 0x00, 0x00,
0x15, 0x70, 0x31, 0x07, 0x57, 0xe6, 0x09, 0x99, 0x72, 0x71, 0x39, 0x55, 0x55, 0x39, 0xa6, 0xa4,
0x14, 0xa5, 0x16, 0x17, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x89, 0xea, 0x21, 0xf4, 0x21,
0x24, 0x83, 0x90, 0x14, 0x0a, 0xc9, 0x70, 0x71, 0xfa, 0xa5, 0x96, 0x94, 0xe7, 0x17, 0x65, 0x7b,
0xba, 0x48, 0x30, 0x29, 0x30, 0x6a, 0xb0, 0x04, 0x21, 0x04, 0x84, 0x44, 0xb8, 0x58, 0x7d, 0x32,
0xd3, 0x33, 0x4a, 0x24, 0x98, 0x15, 0x18, 0x35, 0x38, 0x82, 0x20, 0x1c, 0x25, 0x1b, 0x2e, 0x66,
0xc7, 0xe4, 0x6c, 0x32, 0x6d, 0x54, 0xf2, 0xe1, 0x62, 0x0b, 0xae, 0xcc, 0x03, 0x19, 0xa0, 0x00,
0x76, 0x39, 0x54, 0x27, 0x1f, 0x92, 0xce, 0xe0, 0xca, 0xbc, 0x20, 0xb0, 0xa7, 0x14, 0xc0, 0x36,
0x81, 0xdd, 0x85, 0xaa, 0xc2, 0x31, 0x39, 0x3b, 0x08, 0x24, 0xa5, 0x94, 0x80, 0xec, 0x08, 0x21,
0x29, 0x2e, 0x8e, 0xd0, 0xbc, 0x94, 0xd4, 0xa2, 0x9c, 0xc4, 0x4a, 0xb0, 0xb1, 0x3c, 0x41, 0x70,
0x3e, 0xc8, 0xa7, 0xc1, 0x99, 0xe9, 0x79, 0x89, 0x25, 0xa5, 0x45, 0xa9, 0x60, 0x13, 0x79, 0x82,
0x10, 0x02, 0x42, 0x12, 0x5c, 0xec, 0xfe, 0x65, 0x10, 0x8d, 0xcc, 0x60, 0x39, 0x18, 0xd7, 0x49,
0xe6, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58,
0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0xa2, 0x98, 0x0a, 0x92, 0x92, 0xd8,
0xc0, 0xf1, 0x61, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x02, 0xb3, 0x32, 0xdf, 0xa2, 0x01, 0x00,
0x00,
}
func (m *Syn) Marshal() (dAtA []byte, err error) {
......@@ -238,10 +303,50 @@ func (m *Syn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x10
}
if len(m.Address) > 0 {
i -= len(m.Address)
copy(dAtA[i:], m.Address)
i = encodeVarintHandshake(dAtA, i, uint64(len(m.Address)))
if m.BzzAddress != nil {
{
size, err := m.BzzAddress.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintHandshake(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *Ack) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Ack) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Ack) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.BzzAddress != nil {
{
size, err := m.BzzAddress.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintHandshake(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
......@@ -295,7 +400,7 @@ func (m *SynAck) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Ack) Marshal() (dAtA []byte, err error) {
func (m *BzzAddress) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
......@@ -305,20 +410,34 @@ func (m *Ack) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *Ack) MarshalTo(dAtA []byte) (int, error) {
func (m *BzzAddress) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Ack) MarshalToSizedBuffer(dAtA []byte) (int, error) {
func (m *BzzAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Address) > 0 {
i -= len(m.Address)
copy(dAtA[i:], m.Address)
i = encodeVarintHandshake(dAtA, i, uint64(len(m.Address)))
if len(m.Overlay) > 0 {
i -= len(m.Overlay)
copy(dAtA[i:], m.Overlay)
i = encodeVarintHandshake(dAtA, i, uint64(len(m.Overlay)))
i--
dAtA[i] = 0x1a
}
if len(m.Signature) > 0 {
i -= len(m.Signature)
copy(dAtA[i:], m.Signature)
i = encodeVarintHandshake(dAtA, i, uint64(len(m.Signature)))
i--
dAtA[i] = 0x12
}
if len(m.Underlay) > 0 {
i -= len(m.Underlay)
copy(dAtA[i:], m.Underlay)
i = encodeVarintHandshake(dAtA, i, uint64(len(m.Underlay)))
i--
dAtA[i] = 0xa
}
......@@ -342,8 +461,8 @@ func (m *Syn) Size() (n int) {
}
var l int
_ = l
l = len(m.Address)
if l > 0 {
if m.BzzAddress != nil {
l = m.BzzAddress.Size()
n += 1 + l + sovHandshake(uint64(l))
}
if m.NetworkID != 0 {
......@@ -355,6 +474,19 @@ func (m *Syn) Size() (n int) {
return n
}
func (m *Ack) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.BzzAddress != nil {
l = m.BzzAddress.Size()
n += 1 + l + sovHandshake(uint64(l))
}
return n
}
func (m *SynAck) Size() (n int) {
if m == nil {
return 0
......@@ -372,13 +504,21 @@ func (m *SynAck) Size() (n int) {
return n
}
func (m *Ack) Size() (n int) {
func (m *BzzAddress) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Address)
l = len(m.Underlay)
if l > 0 {
n += 1 + l + sovHandshake(uint64(l))
}
l = len(m.Signature)
if l > 0 {
n += 1 + l + sovHandshake(uint64(l))
}
l = len(m.Overlay)
if l > 0 {
n += 1 + l + sovHandshake(uint64(l))
}
......@@ -422,9 +562,9 @@ func (m *Syn) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field BzzAddress", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
......@@ -434,24 +574,26 @@ func (m *Syn) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
if msglen < 0 {
return ErrInvalidLengthHandshake
}
postIndex := iNdEx + byteLen
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthHandshake
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
if m.Address == nil {
m.Address = []byte{}
if m.BzzAddress == nil {
m.BzzAddress = &BzzAddress{}
}
if err := m.BzzAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
......@@ -517,6 +659,95 @@ func (m *Syn) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *Ack) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Ack: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Ack: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BzzAddress", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthHandshake
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthHandshake
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.BzzAddress == nil {
m.BzzAddress = &BzzAddress{}
}
if err := m.BzzAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipHandshake(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthHandshake
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthHandshake
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *SynAck) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
......@@ -642,7 +873,7 @@ func (m *SynAck) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *Ack) Unmarshal(dAtA []byte) error {
func (m *BzzAddress) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
......@@ -665,15 +896,83 @@ func (m *Ack) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Ack: wiretype end group for non-group")
return fmt.Errorf("proto: BzzAddress: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Ack: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: BzzAddress: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Underlay", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthHandshake
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthHandshake
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Underlay = append(m.Underlay[:0], dAtA[iNdEx:postIndex]...)
if m.Underlay == nil {
m.Underlay = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthHandshake
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthHandshake
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
if m.Signature == nil {
m.Signature = []byte{}
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Overlay", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
......@@ -700,9 +999,9 @@ func (m *Ack) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
if m.Address == nil {
m.Address = []byte{}
m.Overlay = append(m.Overlay[:0], dAtA[iNdEx:postIndex]...)
if m.Overlay == nil {
m.Overlay = []byte{}
}
iNdEx = postIndex
default:
......
pkg/p2p/libp2p/internal/handshake/pb/handshake.proto
View file @ 2db9d81f
......@@ -9,16 +9,22 @@ package handshake;
option go_package = "pb";
message Syn {
bytes Address = 1;
BzzAddress BzzAddress = 1;
uint64 NetworkID = 2;
bool Light = 3;
}
message Ack {
BzzAddress BzzAddress = 1;
}
message SynAck {
Syn Syn = 1;
Ack Ack = 2;
}
message Ack {
bytes Address = 1;
message BzzAddress {
bytes Underlay = 1;
bytes Signature = 2;
bytes Overlay = 3;
}
pkg/p2p/libp2p/libp2p.go
View file @ 2db9d81f
......@@ -12,6 +12,7 @@ import (
"net"
"github.com/ethersphere/bee/pkg/addressbook"
beecrypto "github.com/ethersphere/bee/pkg/crypto"
"github.com/ethersphere/bee/pkg/logging"
"github.com/ethersphere/bee/pkg/p2p"
"github.com/ethersphere/bee/pkg/p2p/libp2p/internal/breaker"
......@@ -56,18 +57,16 @@ type Service struct {
type Options struct {
PrivateKey *ecdsa.PrivateKey
Overlay swarm.Address
Addr string
DisableWS bool
DisableQUIC bool
NetworkID uint64
Addressbook addressbook.Putter
Logger logging.Logger
Tracer *tracing.Tracer
}
func New(ctx context.Context, o Options) (*Service, error) {
host, port, err := net.SplitHostPort(o.Addr)
func New(ctx context.Context, signer beecrypto.Signer, networkID uint64, overlay swarm.Address, addr string,
o Options) (*Service, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, fmt.Errorf("address: %w", err)
}
......@@ -155,14 +154,19 @@ func New(ctx context.Context, o Options) (*Service, error) {
return nil, fmt.Errorf("autonat: %w", err)
}
handshakeService, err := handshake.New(overlay, h.ID().String(), signer, networkID, o.Logger)
if err != nil {
return nil, fmt.Errorf("handshake service: %w", err)
}
peerRegistry := newPeerRegistry()
s := &Service{
ctx: ctx,
host: h,
libp2pPeerstore: libp2pPeerstore,
metrics: newMetrics(),
networkID: o.NetworkID,
handshakeService: handshake.New(o.Overlay, o.NetworkID, o.Logger),
networkID: networkID,
handshakeService: handshakeService,
peers: peerRegistry,
addrssbook: o.Addressbook,
logger: o.Logger,
......@@ -182,21 +186,13 @@ func New(ctx context.Context, o Options) (*Service, error) {
peerID := stream.Conn().RemotePeer()
i, err := s.handshakeService.Handle(NewStream(stream), peerID)
if err != nil {
if err == handshake.ErrNetworkIDIncompatible {
s.logger.Warningf("peer %s has a different network id.", peerID)
}
if err == handshake.ErrHandshakeDuplicate {
s.logger.Warningf("handshake happened for already connected peer %s", peerID)
}
s.logger.Debugf("handshake: handle %s: %v", peerID, err)
s.logger.Errorf("unable to handshake with peer %v", peerID)
_ = s.disconnect(peerID)
return
}
if exists := s.peers.addIfNotExists(stream.Conn(), i.Address); exists {
if exists := s.peers.addIfNotExists(stream.Conn(), i.Overlay); exists {
_ = stream.Close()
return
}
......@@ -210,7 +206,7 @@ func New(ctx context.Context, o Options) (*Service, error) {
return
}
err = s.addrssbook.Put(i.Address, remoteMultiaddr)
err = s.addrssbook.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)
......@@ -219,13 +215,13 @@ func New(ctx context.Context, o Options) (*Service, error) {
}
if s.peerHandler != nil {
if err := s.peerHandler(ctx, i.Address); err != nil {
if err := s.peerHandler(ctx, i.Overlay); err != nil {
s.logger.Debugf("peerhandler error: %s: %v", peerID, err)
}
}
s.metrics.HandledStreamCount.Inc()
s.logger.Infof("peer %s connected", i.Address)
s.logger.Infof("peer %s connected", i.Overlay)
})
h.Network().SetConnHandler(func(_ network.Conn) {
......@@ -335,12 +331,12 @@ func (s *Service) Connect(ctx context.Context, addr ma.Multiaddr) (overlay swarm
return swarm.Address{}, fmt.Errorf("handshake: %w", err)
}
if exists := s.peers.addIfNotExists(stream.Conn(), i.Address); exists {
if exists := s.peers.addIfNotExists(stream.Conn(), i.Overlay); exists {
if err := helpers.FullClose(stream); err != nil {
return swarm.Address{}, err
}
return i.Address, nil
return i.Overlay, nil
}
if err := helpers.FullClose(stream); err != nil {
......@@ -348,8 +344,8 @@ func (s *Service) Connect(ctx context.Context, addr ma.Multiaddr) (overlay swarm
}
s.metrics.CreatedConnectionCount.Inc()
s.logger.Infof("peer %s connected", i.Address)
return i.Address, nil
s.logger.Infof("peer %s connected", i.Overlay)
return i.Overlay, nil
}
func (s *Service) Disconnect(overlay swarm.Address) error {
......
pkg/p2p/libp2p/libp2p_test.go
View file @ 2db9d81f
......@@ -23,45 +23,33 @@ import (
)
// newService constructs a new libp2p service.
func newService(t *testing.T, o libp2p.Options) (s *libp2p.Service, overlay swarm.Address, cleanup func()) {
func newService(t *testing.T, networkID uint64, o libp2p.Options) (s *libp2p.Service, overlay swarm.Address, cleanup func()) {
t.Helper()
if o.PrivateKey == nil {
var err error
o.PrivateKey, err = crypto.GenerateSecp256k1Key()
privateKey, err := crypto.GenerateSecp256k1Key()
if err != nil {
t.Fatal(err)
}
}
if o.Overlay.IsZero() {
var err error
swarmPK, err := crypto.GenerateSecp256k1Key()
if err != nil {
t.Fatal(err)
}
o.Overlay = crypto.NewOverlayAddress(swarmPK.PublicKey, o.NetworkID)
}
overlay = crypto.NewOverlayAddress(privateKey.PublicKey, networkID)
addr := ":0"
if o.Logger == nil {
o.Logger = logging.New(ioutil.Discard, 0)
}
if o.Addr == "" {
o.Addr = ":0"
}
if o.Addressbook == nil {
statestore := mock.NewStateStore()
o.Addressbook = addressbook.New(statestore)
}
ctx, cancel := context.WithCancel(context.Background())
s, err := libp2p.New(ctx, o)
s, err = libp2p.New(ctx, crypto.NewDefaultSigner(privateKey), networkID, overlay, addr, o)
if err != nil {
t.Fatal(err)
}
return s, o.Overlay, func() {
return s, overlay, func() {
cancel()
s.Close()
}
......
pkg/p2p/libp2p/protocols_test.go
View file @ 2db9d81f
......@@ -18,10 +18,10 @@ func TestNewStream(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, _, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, _, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
if err := s1.AddProtocol(newTestProtocol(func(_ context.Context, _ p2p.Peer, _ p2p.Stream) error {
......@@ -49,10 +49,10 @@ func TestNewStream_errNotSupported(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, _, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, _, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
addr := serviceUnderlayAddress(t, s1)
......@@ -86,10 +86,10 @@ func TestNewStream_semanticVersioning(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, _, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, _, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
addr := serviceUnderlayAddress(t, s1)
......@@ -147,10 +147,10 @@ func TestDisconnectError(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{NetworkID: 1})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, overlay2, cleanup2 := newService(t, libp2p.Options{NetworkID: 1})
s2, overlay2, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
if err := s1.AddProtocol(newTestProtocol(func(_ context.Context, _ p2p.Peer, _ p2p.Stream) error {
......
pkg/p2p/libp2p/tracing_test.go
View file @ 2db9d81f
......@@ -34,10 +34,10 @@ func TestTracing(t *testing.T) {
}
defer closer2.Close()
s1, overlay1, cleanup1 := newService(t, libp2p.Options{})
s1, overlay1, cleanup1 := newService(t, 1, libp2p.Options{})
defer cleanup1()
s2, _, cleanup2 := newService(t, libp2p.Options{})
s2, _, cleanup2 := newService(t, 1, libp2p.Options{})
defer cleanup2()
var handledTracingSpan string
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment