Skip to content

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

Handshake with observable underlay (#257) 

* handshake with observable underlay
parent ebb776f4
Hide whitespace changes
Inline Side-by-side
Showing with 362 additions and 685 deletions
pkg/bzz/address.go
View file @ c1bac941
......@@ -35,9 +35,12 @@ type addressJSON struct {
}
func NewAddress(signer crypto.Signer, underlay ma.Multiaddr, overlay swarm.Address, networkID uint64) (*Address, error) {
networkIDBytes := make([]byte, 8)
binary.BigEndian.PutUint64(networkIDBytes, networkID)
signature, err := signer.Sign(append(underlay.Bytes(), networkIDBytes...))
underlayBinary, err := underlay.MarshalBinary()
if err != nil {
return nil, err
}
signature, err := signer.Sign(generateSignData(underlayBinary, overlay.Bytes(), networkID))
if err != nil {
return nil, err
}
......@@ -50,9 +53,7 @@ func NewAddress(signer crypto.Signer, underlay ma.Multiaddr, overlay swarm.Addre
}
func ParseAddress(underlay, overlay, signature []byte, networkID uint64) (*Address, error) {
networkIDBytes := make([]byte, 8)
binary.BigEndian.PutUint64(networkIDBytes, networkID)
recoveredPK, err := crypto.Recover(signature, append(underlay, networkIDBytes...))
recoveredPK, err := crypto.Recover(signature, generateSignData(underlay, overlay, networkID))
if err != nil {
return nil, ErrInvalidAddress
}
......@@ -74,6 +75,13 @@ func ParseAddress(underlay, overlay, signature []byte, networkID uint64) (*Addre
}, nil
}
func generateSignData(underlay, overlay []byte, networkID uint64) []byte {
networkIDBytes := make([]byte, 8)
binary.BigEndian.PutUint64(networkIDBytes, networkID)
signData := append(underlay, overlay...)
return append(signData, networkIDBytes...)
}
func (a *Address) Equal(b *Address) bool {
return a.Overlay.Equal(b.Overlay) && a.Underlay.Equal(b.Underlay) && bytes.Equal(a.Signature, b.Signature)
}
......
pkg/p2p/libp2p/connections_test.go
View file @ c1bac941
......@@ -270,9 +270,7 @@ func TestConnectRepeatHandshake(t *testing.T) {
defer cancel()
s1, overlay1 := newService(t, 1, libp2p.Options{})
s2, overlay2 := newService(t, 1, libp2p.Options{})
addr := serviceUnderlayAddress(t, s1)
_, err := s2.Connect(ctx, addr)
......@@ -293,7 +291,7 @@ func TestConnectRepeatHandshake(t *testing.T) {
t.Fatal(err)
}
if _, err := s2.HandshakeService().Handshake(libp2p.NewStream(stream)); err == nil {
if _, err := s2.HandshakeService().Handshake(libp2p.NewStream(stream), info.Addrs[0], info.ID); err == nil {
t.Fatalf("expected stream error")
}
......
pkg/p2p/libp2p/internal/handshake/handshake.go
View file @ c1bac941
......@@ -5,7 +5,6 @@
package handshake
import (
"bytes"
"errors"
"fmt"
"sync"
......@@ -38,20 +37,17 @@ var (
// ErrHandshakeDuplicate is returned if the handshake response has been received by an already processed peer.
ErrHandshakeDuplicate = errors.New("duplicate handshake")
// ErrInvalidBzzAddress is returned if peer info was received with invalid bzz address
ErrInvalidBzzAddress = errors.New("invalid bzz address")
// ErrInvalidAck is returned if ack does not match the syn provided
// ErrInvalidAck is returned if data in received in ack is not valid (invalid signature for example).
ErrInvalidAck = errors.New("invalid ack")
)
// PeerFinder has the information if the peer already exists in swarm.
type PeerFinder interface {
Exists(overlay swarm.Address) (found bool)
}
// ErrInvalidSyn is returned if observable address in ack is not a valid..
ErrInvalidSyn = errors.New("invalid syn")
)
type Service struct {
bzzAddress bzz.Address
signer crypto.Signer
overlay swarm.Address
lightNode bool
networkID uint64
receivedHandshakes map[libp2ppeer.ID]struct{}
receivedHandshakesMu sync.Mutex
......@@ -60,30 +56,32 @@ type Service struct {
network.Notifiee // handshake service can be the receiver for network.Notify
}
func New(overlay swarm.Address, underlay ma.Multiaddr, signer crypto.Signer, networkID uint64, logger logging.Logger) (*Service, error) {
bzzAddress, err := bzz.NewAddress(signer, underlay, overlay, networkID)
if err != nil {
return nil, err
}
func New(overlay swarm.Address, signer crypto.Signer, networkID uint64, lighNode bool, logger logging.Logger) (*Service, error) {
return &Service{
bzzAddress: *bzzAddress,
signer: signer,
overlay: overlay,
networkID: networkID,
lightNode: lighNode,
receivedHandshakes: make(map[libp2ppeer.ID]struct{}),
logger: logger,
Notifiee: new(network.NoopNotifiee),
}, nil
}
func (s *Service) Handshake(stream p2p.Stream) (i *Info, err error) {
func (s *Service) Handshake(stream p2p.Stream, peerMultiaddr ma.Multiaddr, peerID libp2ppeer.ID) (i *Info, err error) {
w, r := protobuf.NewWriterAndReader(stream)
fullRemoteMA, err := buildFullMA(peerMultiaddr, peerID)
if err != nil {
return nil, err
}
fullRemoteMABytes, err := fullRemoteMA.MarshalBinary()
if err != nil {
return nil, err
}
if err := w.WriteMsgWithTimeout(messageTimeout, &pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: s.bzzAddress.Underlay.Bytes(),
Signature: s.bzzAddress.Signature,
Overlay: s.bzzAddress.Overlay.Bytes(),
},
NetworkID: s.networkID,
ObservedUnderlay: fullRemoteMABytes,
}); err != nil {
return nil, fmt.Errorf("write syn message: %w", err)
}
......@@ -93,67 +91,82 @@ func (s *Service) Handshake(stream p2p.Stream) (i *Info, err error) {
return nil, fmt.Errorf("read synack message: %w", err)
}
if err := s.checkAck(resp.Ack); err != nil {
remoteBzzAddress, err := s.parseCheckAck(resp.Ack, fullRemoteMABytes)
if err != nil {
return nil, err
}
if resp.Syn.NetworkID != s.networkID {
return nil, ErrNetworkIDIncompatible
addr, err := ma.NewMultiaddrBytes(resp.Syn.ObservedUnderlay)
if err != nil {
return nil, ErrInvalidSyn
}
bzzAddress, err := bzz.ParseAddress(resp.Syn.BzzAddress.Underlay, resp.Syn.BzzAddress.Overlay, resp.Syn.BzzAddress.Signature, resp.Syn.NetworkID)
bzzAddress, err := bzz.NewAddress(s.signer, addr, s.overlay, s.networkID)
if err != nil {
return nil, ErrInvalidBzzAddress
return nil, err
}
if err := w.WriteMsgWithTimeout(messageTimeout, &pb.Ack{
BzzAddress: resp.Syn.BzzAddress,
Overlay: bzzAddress.Overlay.Bytes(),
Signature: bzzAddress.Signature,
NetworkID: s.networkID,
Light: s.lightNode,
}); err != nil {
return nil, fmt.Errorf("write ack message: %w", err)
}
s.logger.Tracef("handshake finished for peer %s", swarm.NewAddress(resp.Syn.BzzAddress.Overlay).String())
s.logger.Tracef("handshake finished for peer %s", remoteBzzAddress.Overlay.String())
return &Info{
BzzAddress: bzzAddress,
Light: resp.Syn.Light,
BzzAddress: remoteBzzAddress,
Light: resp.Ack.Light,
}, nil
}
func (s *Service) Handle(stream p2p.Stream, peerID libp2ppeer.ID) (i *Info, err error) {
func (s *Service) Handle(stream p2p.Stream, remoteMultiaddr ma.Multiaddr, remotePeerID libp2ppeer.ID) (i *Info, err error) {
s.receivedHandshakesMu.Lock()
if _, exists := s.receivedHandshakes[peerID]; exists {
if _, exists := s.receivedHandshakes[remotePeerID]; exists {
s.receivedHandshakesMu.Unlock()
return nil, ErrHandshakeDuplicate
}
s.receivedHandshakes[peerID] = struct{}{}
s.receivedHandshakes[remotePeerID] = struct{}{}
s.receivedHandshakesMu.Unlock()
w, r := protobuf.NewWriterAndReader(stream)
fullRemoteMA, err := buildFullMA(remoteMultiaddr, remotePeerID)
if err != nil {
return nil, err
}
var req pb.Syn
if err := r.ReadMsgWithTimeout(messageTimeout, &req); err != nil {
fullRemoteMABytes, err := fullRemoteMA.MarshalBinary()
if err != nil {
return nil, err
}
var syn pb.Syn
if err := r.ReadMsgWithTimeout(messageTimeout, &syn); err != nil {
return nil, fmt.Errorf("read syn message: %w", err)
}
if req.NetworkID != s.networkID {
return nil, ErrNetworkIDIncompatible
addr, err := ma.NewMultiaddrBytes(syn.ObservedUnderlay)
if err != nil {
return nil, ErrInvalidSyn
}
bzzAddress, err := bzz.ParseAddress(req.BzzAddress.Underlay, req.BzzAddress.Overlay, req.BzzAddress.Signature, req.NetworkID)
bzzAddress, err := bzz.NewAddress(s.signer, addr, s.overlay, s.networkID)
if err != nil {
return nil, ErrInvalidBzzAddress
return nil, err
}
if err := w.WriteMsgWithTimeout(messageTimeout, &pb.SynAck{
Syn: &pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: s.bzzAddress.Underlay.Bytes(),
Signature: s.bzzAddress.Signature,
Overlay: s.bzzAddress.Overlay.Bytes(),
},
ObservedUnderlay: fullRemoteMABytes,
},
Ack: &pb.Ack{
Overlay: bzzAddress.Overlay.Bytes(),
Signature: bzzAddress.Signature,
NetworkID: s.networkID,
Light: s.lightNode,
},
Ack: &pb.Ack{BzzAddress: req.BzzAddress},
}); err != nil {
return nil, fmt.Errorf("write synack message: %w", err)
}
......@@ -163,14 +176,15 @@ func (s *Service) Handle(stream p2p.Stream, peerID libp2ppeer.ID) (i *Info, err
return nil, fmt.Errorf("read ack message: %w", err)
}
if err := s.checkAck(&ack); err != nil {
remoteBzzAddress, err := s.parseCheckAck(&ack, fullRemoteMABytes)
if err != nil {
return nil, err
}
s.logger.Tracef("handshake finished for peer %s", swarm.NewAddress(req.BzzAddress.Overlay).String())
s.logger.Tracef("handshake finished for peer %s", remoteBzzAddress.Overlay.String())
return &Info{
BzzAddress: bzzAddress,
Light: req.Light,
BzzAddress: remoteBzzAddress,
Light: ack.Light,
}, nil
}
......@@ -180,14 +194,21 @@ func (s *Service) Disconnected(_ network.Network, c network.Conn) {
delete(s.receivedHandshakes, c.RemotePeer())
}
func (s *Service) checkAck(ack *pb.Ack) error {
if !bytes.Equal(ack.BzzAddress.Overlay, s.bzzAddress.Overlay.Bytes()) ||
!bytes.Equal(ack.BzzAddress.Underlay, s.bzzAddress.Underlay.Bytes()) ||
!bytes.Equal(ack.BzzAddress.Signature, s.bzzAddress.Signature) {
return ErrInvalidAck
func buildFullMA(addr ma.Multiaddr, peerID libp2ppeer.ID) (ma.Multiaddr, error) {
return ma.NewMultiaddr(fmt.Sprintf("%s/p2p/%s", addr.String(), peerID.Pretty()))
}
func (s *Service) parseCheckAck(ack *pb.Ack, remoteMA []byte) (*bzz.Address, error) {
if ack.NetworkID != s.networkID {
return nil, ErrNetworkIDIncompatible
}
bzzAddress, err := bzz.ParseAddress(remoteMA, ack.Overlay, ack.Signature, s.networkID)
if err != nil {
return nil, ErrInvalidAck
}
return nil
return bzzAddress, nil
}
type Info struct {
......
pkg/p2p/libp2p/internal/handshake/handshake_test.go
View file @ c1bac941
......@@ -26,6 +26,7 @@ import (
func TestHandshake(t *testing.T) {
logger := logging.New(ioutil.Discard, 0)
networkID := uint64(3)
node1ma, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/7070/p2p/16Uiu2HAkx8ULY8cTXhdVAcMmLcH9AsTKz6uBQ7DPLKRjMLgBVYkA")
if err != nil {
t.Fatal(err)
......@@ -34,7 +35,14 @@ func TestHandshake(t *testing.T) {
if err != nil {
t.Fatal(err)
}
node1maBinary, err := node1ma.MarshalBinary()
if err != nil {
t.Fatal(err)
}
node2maBinary, err := node2ma.MarshalBinary()
if err != nil {
t.Fatal(err)
}
node2AddrInfo, err := libp2ppeer.AddrInfoFromP2pAddr(node2ma)
if err != nil {
t.Fatal(err)
......@@ -69,7 +77,7 @@ func TestHandshake(t *testing.T) {
Light: false,
}
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, node1Info.BzzAddress.Underlay, signer1, networkID, logger)
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, signer1, networkID, false, logger)
if err != nil {
t.Fatal(err)
}
......@@ -83,24 +91,19 @@ func TestHandshake(t *testing.T) {
w, r := protobuf.NewWriterAndReader(stream2)
if err := w.WriteMsg(&pb.SynAck{
Syn: &pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
Light: node2Info.Light,
ObservedUnderlay: node1maBinary,
},
Ack: &pb.Ack{
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
NetworkID: networkID,
Light: false,
},
Ack: &pb.Ack{BzzAddress: &pb.BzzAddress{
Underlay: node1BzzAddress.Underlay.Bytes(),
Overlay: node1BzzAddress.Overlay.Bytes(),
Signature: node1BzzAddress.Signature,
}},
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handshake(stream1)
res, err := handshakeService.Handshake(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err != nil {
t.Fatal(err)
}
......@@ -116,7 +119,7 @@ func TestHandshake(t *testing.T) {
expectedErr := fmt.Errorf("write syn message: %w", testErr)
stream := &mock.Stream{}
stream.SetWriteErr(testErr, 0)
res, err := handshakeService.Handshake(stream)
res, err := handshakeService.Handshake(stream, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatal("expected:", expectedErr, "got:", err)
}
......@@ -131,7 +134,7 @@ func TestHandshake(t *testing.T) {
expectedErr := fmt.Errorf("read synack message: %w", testErr)
stream := mock.NewStream(nil, &bytes.Buffer{})
stream.SetReadErr(testErr, 0)
res, err := handshakeService.Handshake(stream)
res, err := handshakeService.Handshake(stream, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatal("expected:", expectedErr, "got:", err)
}
......@@ -153,24 +156,20 @@ func TestHandshake(t *testing.T) {
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.SynAck{
Syn: &pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
Light: node2Info.Light,
ObservedUnderlay: node1maBinary,
},
Ack: &pb.Ack{
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
NetworkID: networkID,
Light: false,
},
Ack: &pb.Ack{BzzAddress: &pb.BzzAddress{
Underlay: node1BzzAddress.Underlay.Bytes(),
Overlay: node1BzzAddress.Overlay.Bytes(),
Signature: node1BzzAddress.Signature,
}},
}); err != nil {
},
); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handshake(stream1)
res, err := handshakeService.Handshake(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatal("expected:", expectedErr, "got:", err)
}
......@@ -189,24 +188,19 @@ func TestHandshake(t *testing.T) {
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.SynAck{
Syn: &pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
ObservedUnderlay: node1maBinary,
},
Ack: &pb.Ack{
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
NetworkID: 5,
Light: node2Info.Light,
Light: false,
},
Ack: &pb.Ack{BzzAddress: &pb.BzzAddress{
Underlay: node1BzzAddress.Underlay.Bytes(),
Overlay: node1BzzAddress.Overlay.Bytes(),
Signature: node1BzzAddress.Signature,
}},
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handshake(stream1)
res, err := handshakeService.Handshake(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if res != nil {
t.Fatal("res should be nil")
}
......@@ -225,71 +219,30 @@ func TestHandshake(t *testing.T) {
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.SynAck{
Syn: &pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
Light: node2Info.Light,
NetworkID: networkID,
ObservedUnderlay: node1maBinary,
},
Ack: &pb.Ack{BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Ack: &pb.Ack{
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
}},
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handshake(stream1)
if res != nil {
t.Fatal("res should be nil")
}
if err != handshake.ErrInvalidAck {
t.Fatalf("expected %s, got %s", handshake.ErrInvalidAck, err)
}
})
t.Run("Handshake - 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.Bytes(),
Overlay: []byte("wrong signature"),
Signature: node2BzzAddress.Signature,
},
Light: node2Info.Light,
Signature: []byte("invalid"),
NetworkID: networkID,
Light: false,
},
Ack: &pb.Ack{BzzAddress: &pb.BzzAddress{
Underlay: node1BzzAddress.Underlay.Bytes(),
Overlay: node1BzzAddress.Overlay.Bytes(),
Signature: node1BzzAddress.Signature,
}},
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handshake(stream1)
res, err := handshakeService.Handshake(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if res != nil {
t.Fatal("res should be nil")
}
if err != handshake.ErrInvalidBzzAddress {
t.Fatalf("expected %s, got %s", handshake.ErrInvalidBzzAddress, err)
if err != handshake.ErrInvalidAck {
t.Fatalf("expected %s, got %s", handshake.ErrInvalidAck, err)
}
})
t.Run("Handle - OK", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, node1Info.BzzAddress.Underlay, signer1, networkID, logger)
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, signer1, networkID, false, logger)
if err != nil {
t.Fatal(err)
}
......@@ -300,26 +253,21 @@ func TestHandshake(t *testing.T) {
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
Light: node2Info.Light,
NetworkID: networkID,
ObservedUnderlay: node1maBinary,
}); err != nil {
t.Fatal(err)
}
if err := w.WriteMsg(&pb.Ack{BzzAddress: &pb.BzzAddress{
Underlay: node1BzzAddress.Underlay.Bytes(),
Overlay: node1BzzAddress.Overlay.Bytes(),
Signature: node1BzzAddress.Signature,
}}); err != nil {
if err := w.WriteMsg(&pb.Ack{
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
NetworkID: networkID,
Light: false,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
res, err := handshakeService.Handle(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err != nil {
t.Fatal(err)
}
......@@ -332,19 +280,23 @@ func TestHandshake(t *testing.T) {
t.Fatal(err)
}
bzzAddress, err := bzz.ParseAddress(got.Syn.BzzAddress.Underlay, got.Syn.BzzAddress.Overlay, got.Syn.BzzAddress.Signature, got.Syn.NetworkID)
if !bytes.Equal(got.Syn.ObservedUnderlay, node2maBinary) {
t.Fatalf("got bad syn")
}
bzzAddress, err := bzz.ParseAddress(node1maBinary, got.Ack.Overlay, got.Ack.Signature, got.Ack.NetworkID)
if err != nil {
t.Fatal(err)
}
testInfo(t, node1Info, handshake.Info{
BzzAddress: bzzAddress,
Light: got.Syn.Light,
Light: got.Ack.Light,
})
})
t.Run("Handle - read error ", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, node1Info.BzzAddress.Underlay, signer1, networkID, logger)
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, signer1, networkID, false, logger)
if err != nil {
t.Fatal(err)
}
......@@ -352,7 +304,7 @@ func TestHandshake(t *testing.T) {
expectedErr := fmt.Errorf("read syn message: %w", testErr)
stream := &mock.Stream{}
stream.SetReadErr(testErr, 0)
res, err := handshakeService.Handle(stream, node2AddrInfo.ID)
res, err := handshakeService.Handle(stream, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatal("expected:", expectedErr, "got:", err)
}
......@@ -363,7 +315,7 @@ func TestHandshake(t *testing.T) {
})
t.Run("Handle - write error ", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, node1Info.BzzAddress.Underlay, signer1, networkID, logger)
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, signer1, networkID, false, logger)
if err != nil {
t.Fatal(err)
}
......@@ -374,18 +326,12 @@ func TestHandshake(t *testing.T) {
stream.SetWriteErr(testErr, 1)
w := protobuf.NewWriter(stream)
if err := w.WriteMsg(&pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
Light: node2Info.Light,
NetworkID: networkID,
ObservedUnderlay: node1maBinary,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream, node2AddrInfo.ID)
res, err := handshakeService.Handle(stream, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatal("expected:", expectedErr, "got:", err)
}
......@@ -396,7 +342,7 @@ func TestHandshake(t *testing.T) {
})
t.Run("Handle - ack read error ", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, node1Info.BzzAddress.Underlay, signer1, networkID, logger)
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, signer1, networkID, false, logger)
if err != nil {
t.Fatal(err)
}
......@@ -409,18 +355,12 @@ func TestHandshake(t *testing.T) {
stream1.SetReadErr(testErr, 1)
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
Light: node2Info.Light,
NetworkID: networkID,
ObservedUnderlay: node1maBinary,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
res, err := handshakeService.Handle(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err == nil || err.Error() != expectedErr.Error() {
t.Fatal("expected:", expectedErr, "got:", err)
}
......@@ -431,7 +371,7 @@ func TestHandshake(t *testing.T) {
})
t.Run("Handle - networkID mismatch ", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, node1Info.BzzAddress.Underlay, signer1, networkID, logger)
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, signer1, networkID, false, logger)
if err != nil {
t.Fatal(err)
}
......@@ -442,18 +382,21 @@ func TestHandshake(t *testing.T) {
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
ObservedUnderlay: node1maBinary,
}); err != nil {
t.Fatal(err)
}
if err := w.WriteMsg(&pb.Ack{
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
NetworkID: 5,
Light: node2Info.Light,
Light: false,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
res, err := handshakeService.Handle(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if res != nil {
t.Fatal("res should be nil")
}
......@@ -464,7 +407,7 @@ func TestHandshake(t *testing.T) {
})
t.Run("Handle - duplicate handshake", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, node1Info.BzzAddress.Underlay, signer1, networkID, logger)
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, signer1, networkID, false, logger)
if err != nil {
t.Fatal(err)
}
......@@ -475,26 +418,21 @@ func TestHandshake(t *testing.T) {
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
Light: node2Info.Light,
NetworkID: networkID,
ObservedUnderlay: node1maBinary,
}); err != nil {
t.Fatal(err)
}
if err := w.WriteMsg(&pb.Ack{BzzAddress: &pb.BzzAddress{
Underlay: node1BzzAddress.Underlay.Bytes(),
Overlay: node1BzzAddress.Overlay.Bytes(),
Signature: node1BzzAddress.Signature,
}}); err != nil {
if err := w.WriteMsg(&pb.Ack{
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
NetworkID: networkID,
Light: false,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
res, err := handshakeService.Handle(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err != nil {
t.Fatal(err)
}
......@@ -507,24 +445,28 @@ func TestHandshake(t *testing.T) {
t.Fatal(err)
}
bzzAddress, err := bzz.ParseAddress(got.Syn.BzzAddress.Underlay, got.Syn.BzzAddress.Overlay, got.Syn.BzzAddress.Signature, got.Syn.NetworkID)
if !bytes.Equal(got.Syn.ObservedUnderlay, node2maBinary) {
t.Fatalf("got bad syn")
}
bzzAddress, err := bzz.ParseAddress(node1maBinary, got.Ack.Overlay, got.Ack.Signature, got.Ack.NetworkID)
if err != nil {
t.Fatal(err)
}
testInfo(t, node1Info, handshake.Info{
BzzAddress: bzzAddress,
Light: got.Syn.Light,
Light: got.Ack.Light,
})
_, err = handshakeService.Handle(stream1, node2AddrInfo.ID)
_, err = handshakeService.Handle(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err != handshake.ErrHandshakeDuplicate {
t.Fatalf("expected %s, got %s", handshake.ErrHandshakeDuplicate, err)
}
})
t.Run("Handle - invalid ack", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, node1Info.BzzAddress.Underlay, signer1, networkID, logger)
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, signer1, networkID, false, logger)
if err != nil {
t.Fatal(err)
}
......@@ -535,61 +477,23 @@ func TestHandshake(t *testing.T) {
w := protobuf.NewWriter(stream2)
if err := w.WriteMsg(&pb.Syn{
BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
},
Light: node2Info.Light,
NetworkID: networkID,
ObservedUnderlay: node1maBinary,
}); err != nil {
t.Fatal(err)
}
if err := w.WriteMsg(&pb.Ack{BzzAddress: &pb.BzzAddress{
Underlay: node2BzzAddress.Underlay.Bytes(),
if err := w.WriteMsg(&pb.Ack{
Overlay: node2BzzAddress.Overlay.Bytes(),
Signature: node2BzzAddress.Signature,
}}); 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("Handle - invalid signature ", func(t *testing.T) {
handshakeService, err := handshake.New(node1Info.BzzAddress.Overlay, node1Info.BzzAddress.Underlay, signer1, networkID, 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.Bytes(),
Overlay: []byte("wrong signature"),
Signature: node2BzzAddress.Signature,
},
Signature: []byte("wrong signature"),
NetworkID: networkID,
Light: node2Info.Light,
Light: false,
}); err != nil {
t.Fatal(err)
}
res, err := handshakeService.Handle(stream1, node2AddrInfo.ID)
if res != nil {
t.Fatal("res should be nil")
}
if err != handshake.ErrInvalidBzzAddress {
t.Fatalf("expected %s, got %s", handshake.ErrInvalidBzzAddress, err)
_, err = handshakeService.Handle(stream1, node2AddrInfo.Addrs[0], node2AddrInfo.ID)
if err != handshake.ErrInvalidAck {
t.Fatalf("expected %s, got %s", handshake.ErrInvalidAck, err)
}
})
}
......
pkg/p2p/libp2p/internal/handshake/pb/handshake.pb.go
View file @ c1bac941
......@@ -23,9 +23,7 @@ var _ = math.Inf
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type Syn struct {
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"`
ObservedUnderlay []byte `protobuf:"bytes,1,opt,name=ObservedUnderlay,proto3" json:"ObservedUnderlay,omitempty"`
}
func (m *Syn) Reset() { *m = Syn{} }
......@@ -61,29 +59,18 @@ func (m *Syn) XXX_DiscardUnknown() {
var xxx_messageInfo_Syn proto.InternalMessageInfo
func (m *Syn) GetBzzAddress() *BzzAddress {
func (m *Syn) GetObservedUnderlay() []byte {
if m != nil {
return m.BzzAddress
return m.ObservedUnderlay
}
return nil
}
func (m *Syn) GetNetworkID() uint64 {
if m != nil {
return m.NetworkID
}
return 0
}
func (m *Syn) GetLight() bool {
if m != nil {
return m.Light
}
return false
}
type Ack struct {
BzzAddress *BzzAddress `protobuf:"bytes,1,opt,name=BzzAddress,proto3" json:"BzzAddress,omitempty"`
Overlay []byte `protobuf:"bytes,1,opt,name=Overlay,proto3" json:"Overlay,omitempty"`
Signature []byte `protobuf:"bytes,2,opt,name=Signature,proto3" json:"Signature,omitempty"`
NetworkID uint64 `protobuf:"varint,3,opt,name=NetworkID,proto3" json:"NetworkID,omitempty"`
Light bool `protobuf:"varint,4,opt,name=Light,proto3" json:"Light,omitempty"`
}
func (m *Ack) Reset() { *m = Ack{} }
......@@ -119,13 +106,34 @@ func (m *Ack) XXX_DiscardUnknown() {
var xxx_messageInfo_Ack proto.InternalMessageInfo
func (m *Ack) GetBzzAddress() *BzzAddress {
func (m *Ack) GetOverlay() []byte {
if m != nil {
return m.Overlay
}
return nil
}
func (m *Ack) GetSignature() []byte {
if m != nil {
return m.BzzAddress
return m.Signature
}
return nil
}
func (m *Ack) GetNetworkID() uint64 {
if m != nil {
return m.NetworkID
}
return 0
}
func (m *Ack) GetLight() bool {
if m != nil {
return m.Light
}
return false
}
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"`
......@@ -178,94 +186,31 @@ func (m *SynAck) GetAck() *Ack {
return nil
}
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 *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 *BzzAddress) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *BzzAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_BzzAddress.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 *BzzAddress) XXX_Merge(src proto.Message) {
xxx_messageInfo_BzzAddress.Merge(m, src)
}
func (m *BzzAddress) XXX_Size() int {
return m.Size()
}
func (m *BzzAddress) XXX_DiscardUnknown() {
xxx_messageInfo_BzzAddress.DiscardUnknown(m)
}
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 *BzzAddress) GetOverlay() []byte {
if m != nil {
return m.Overlay
}
return nil
}
func init() {
proto.RegisterType((*Syn)(nil), "handshake.Syn")
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{
// 257 bytes of a gzipped FileDescriptorProto
// 231 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,
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,
0x19, 0x72, 0x31, 0x07, 0x57, 0xe6, 0x09, 0x69, 0x71, 0x09, 0xf8, 0x27, 0x15, 0xa7, 0x16, 0x95,
0xa5, 0xa6, 0x84, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x24, 0x56, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0xf0,
0x04, 0x61, 0x88, 0x2b, 0x15, 0x72, 0x31, 0x3b, 0x26, 0x67, 0x0b, 0x49, 0x70, 0xb1, 0xfb, 0x97,
0x21, 0xab, 0x84, 0x71, 0x85, 0x64, 0xb8, 0x38, 0x83, 0x33, 0xd3, 0xf3, 0x12, 0x4b, 0x4a, 0x8b,
0x52, 0x25, 0x98, 0xc0, 0x72, 0x08, 0x01, 0x90, 0xac, 0x5f, 0x6a, 0x49, 0x79, 0x7e, 0x51, 0xb6,
0xa7, 0x8b, 0x04, 0xb3, 0x02, 0xa3, 0x06, 0x4b, 0x10, 0x42, 0x40, 0x48, 0x84, 0x8b, 0xd5, 0x27,
0x33, 0x3d, 0xa3, 0x44, 0x82, 0x45, 0x81, 0x51, 0x83, 0x23, 0x08, 0xc2, 0x51, 0xf2, 0xe1, 0x62,
0x0b, 0xae, 0xcc, 0x03, 0xd9, 0xaa, 0x00, 0x76, 0x2f, 0xd8, 0x46, 0x6e, 0x23, 0x3e, 0x3d, 0x84,
0xcf, 0x82, 0x2b, 0xf3, 0x82, 0xc0, 0x5e, 0x51, 0x00, 0x3b, 0x0f, 0x6c, 0x2f, 0xaa, 0x0a, 0xc7,
0xe4, 0xec, 0x20, 0x90, 0x94, 0x93, 0xcc, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e,
0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31,
0x44, 0x31, 0x15, 0x24, 0x25, 0xb1, 0x81, 0xc3, 0xc8, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x51,
0xf9, 0xa1, 0xf4, 0x36, 0x01, 0x00, 0x00,
}
func (m *Syn) Marshal() (dAtA []byte, err error) {
......@@ -288,30 +233,10 @@ func (m *Syn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.Light {
i--
if m.Light {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x18
}
if m.NetworkID != 0 {
i = encodeVarintHandshake(dAtA, i, uint64(m.NetworkID))
i--
dAtA[i] = 0x10
}
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))
}
if len(m.ObservedUnderlay) > 0 {
i -= len(m.ObservedUnderlay)
copy(dAtA[i:], m.ObservedUnderlay)
i = encodeVarintHandshake(dAtA, i, uint64(len(m.ObservedUnderlay)))
i--
dAtA[i] = 0xa
}
......@@ -338,16 +263,33 @@ func (m *Ack) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = 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))
if m.Light {
i--
if m.Light {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x20
}
if m.NetworkID != 0 {
i = encodeVarintHandshake(dAtA, i, uint64(m.NetworkID))
i--
dAtA[i] = 0x18
}
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.Overlay) > 0 {
i -= len(m.Overlay)
copy(dAtA[i:], m.Overlay)
i = encodeVarintHandshake(dAtA, i, uint64(len(m.Overlay)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
......@@ -400,50 +342,6 @@ func (m *SynAck) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *BzzAddress) 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 *BzzAddress) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *BzzAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
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
}
return len(dAtA) - i, nil
}
func encodeVarintHandshake(dAtA []byte, offset int, v uint64) int {
offset -= sovHandshake(v)
base := offset
......@@ -461,16 +359,10 @@ func (m *Syn) Size() (n int) {
}
var l int
_ = l
if m.BzzAddress != nil {
l = m.BzzAddress.Size()
l = len(m.ObservedUnderlay)
if l > 0 {
n += 1 + l + sovHandshake(uint64(l))
}
if m.NetworkID != 0 {
n += 1 + sovHandshake(uint64(m.NetworkID))
}
if m.Light {
n += 2
}
return n
}
......@@ -480,10 +372,20 @@ func (m *Ack) Size() (n int) {
}
var l int
_ = l
if m.BzzAddress != nil {
l = m.BzzAddress.Size()
l = len(m.Overlay)
if l > 0 {
n += 1 + l + sovHandshake(uint64(l))
}
l = len(m.Signature)
if l > 0 {
n += 1 + l + sovHandshake(uint64(l))
}
if m.NetworkID != 0 {
n += 1 + sovHandshake(uint64(m.NetworkID))
}
if m.Light {
n += 2
}
return n
}
......@@ -504,27 +406,6 @@ func (m *SynAck) Size() (n int) {
return n
}
func (m *BzzAddress) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
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))
}
return n
}
func sovHandshake(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
......@@ -562,9 +443,9 @@ func (m *Syn) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BzzAddress", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field ObservedUnderlay", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
......@@ -574,67 +455,26 @@ func (m *Syn) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthHandshake
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
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
m.ObservedUnderlay = append(m.ObservedUnderlay[:0], dAtA[iNdEx:postIndex]...)
if m.ObservedUnderlay == nil {
m.ObservedUnderlay = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field NetworkID", wireType)
}
m.NetworkID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.NetworkID |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Light", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Light = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipHandshake(dAtA[iNdEx:])
......@@ -690,9 +530,9 @@ func (m *Ack) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BzzAddress", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Overlay", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
......@@ -702,86 +542,31 @@ func (m *Ack) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthHandshake
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
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
m.Overlay = append(m.Overlay[:0], dAtA[iNdEx:postIndex]...)
if m.Overlay == nil {
m.Overlay = []byte{}
}
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
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: SynAck: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SynAck: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Syn", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
......@@ -791,33 +576,31 @@ func (m *SynAck) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthHandshake
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthHandshake
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Syn == nil {
m.Syn = &Syn{}
}
if err := m.Syn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
if m.Signature == nil {
m.Signature = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Ack", wireType)
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field NetworkID", wireType)
}
var msglen int
m.NetworkID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
......@@ -827,28 +610,31 @@ func (m *SynAck) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
m.NetworkID |= uint64(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.Ack == nil {
m.Ack = &Ack{}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Light", wireType)
}
if err := m.Ack.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
iNdEx = postIndex
m.Light = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipHandshake(dAtA[iNdEx:])
......@@ -873,7 +659,7 @@ func (m *SynAck) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *BzzAddress) Unmarshal(dAtA []byte) error {
func (m *SynAck) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
......@@ -896,17 +682,17 @@ func (m *BzzAddress) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: BzzAddress: wiretype end group for non-group")
return fmt.Errorf("proto: SynAck: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: BzzAddress: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: SynAck: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Underlay", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Syn", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
......@@ -916,31 +702,33 @@ func (m *BzzAddress) 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.Underlay = append(m.Underlay[:0], dAtA[iNdEx:postIndex]...)
if m.Underlay == nil {
m.Underlay = []byte{}
if m.Syn == nil {
m.Syn = &Syn{}
}
if err := m.Syn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Ack", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowHandshake
......@@ -950,58 +738,26 @@ func (m *BzzAddress) 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.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 {
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
if m.Ack == nil {
m.Ack = &Ack{}
}
m.Overlay = append(m.Overlay[:0], dAtA[iNdEx:postIndex]...)
if m.Overlay == nil {
m.Overlay = []byte{}
if err := m.Ack.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
......
pkg/p2p/libp2p/internal/handshake/pb/handshake.proto
View file @ c1bac941
......@@ -9,22 +9,17 @@ package handshake;
option go_package = "pb";
message Syn {
BzzAddress BzzAddress = 1;
uint64 NetworkID = 2;
bool Light = 3;
bytes ObservedUnderlay = 1;
}
message Ack {
BzzAddress BzzAddress = 1;
bytes Overlay = 1;
bytes Signature = 2;
uint64 NetworkID = 3;
bool Light = 4;
}
message SynAck {
Syn Syn = 1;
Ack Ack = 2;
}
message BzzAddress {
bytes Underlay = 1;
bytes Signature = 2;
bytes Overlay = 3;
}
}
\ No newline at end of file
pkg/p2p/libp2p/libp2p.go
View file @ c1bac941
......@@ -61,6 +61,7 @@ type Options struct {
PrivateKey *ecdsa.PrivateKey
DisableWS bool
DisableQUIC bool
LightNode bool
Addressbook addressbook.Putter
Logger logging.Logger
Tracer *tracing.Tracer
......@@ -156,13 +157,7 @@ func New(ctx context.Context, signer beecrypto.Signer, networkID uint64, overlay
return nil, fmt.Errorf("autonat: %w", err)
}
// todo: handle different underlays
underlay, err := buildUnderlayAddress(h.Addrs()[1], h.ID())
if err != nil {
return nil, fmt.Errorf("build host multiaddress: %w", err)
}
handshakeService, err := handshake.New(overlay, underlay, signer, networkID, o.Logger)
handshakeService, err := handshake.New(overlay, signer, networkID, o.LightNode, o.Logger)
if err != nil {
return nil, fmt.Errorf("handshake service: %w", err)
}
......@@ -192,7 +187,7 @@ func New(ctx context.Context, signer beecrypto.Signer, networkID uint64, overlay
// handshake
s.host.SetStreamHandlerMatch(id, matcher, func(stream network.Stream) {
peerID := stream.Conn().RemotePeer()
i, err := s.handshakeService.Handle(NewStream(stream), peerID)
i, err := s.handshakeService.Handle(NewStream(stream), stream.Conn().RemoteMultiaddr(), peerID)
if err != nil {
s.logger.Debugf("handshake: handle %s: %v", peerID, err)
s.logger.Errorf("unable to handshake with peer %v", peerID)
......@@ -334,7 +329,7 @@ func (s *Service) Connect(ctx context.Context, addr ma.Multiaddr) (address *bzz.
return nil, err
}
i, err := s.handshakeService.Handshake(NewStream(stream))
i, err := s.handshakeService.Handshake(NewStream(stream), stream.Conn().RemoteMultiaddr(), stream.Conn().RemotePeer())
if err != nil {
_ = s.disconnect(info.ID)
return nil, fmt.Errorf("handshake: %w", err)
......
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