e83c3ccc47
* p2p/enr: add entries for for IPv4/IPv6 separation This adds entry types for "ip6", "udp6", "tcp6" keys. The IP type stays around because removing it would break a lot of code and force everyone to care about the distinction. * p2p/enode: track IPv4 and IPv6 address separately LocalNode predicts the local node's UDP endpoint and updates the record. This change makes it predict IPv4 and IPv6 endpoints separately since they can now be in the record at the same time. * p2p/enode: implement base64 text format * all: switch to enode.Parse(...) This allows passing base64-encoded node records to all the places that previously accepted enode:// URLs. The URL format is still supported. * cmd/bootnode, p2p: log node URL instead of ENR ...and return the base64 record in NodeInfo.
688 lines
24 KiB
Go
688 lines
24 KiB
Go
// Copyright 2015 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package discover
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/ecdsa"
|
|
crand "crypto/rand"
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"errors"
|
|
"io"
|
|
"math/rand"
|
|
"net"
|
|
"reflect"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/davecgh/go-spew/spew"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/internal/testlog"
|
|
"github.com/ethereum/go-ethereum/log"
|
|
"github.com/ethereum/go-ethereum/p2p/enode"
|
|
"github.com/ethereum/go-ethereum/p2p/enr"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
)
|
|
|
|
func init() {
|
|
spew.Config.DisableMethods = true
|
|
}
|
|
|
|
// shared test variables
|
|
var (
|
|
futureExp = uint64(time.Now().Add(10 * time.Hour).Unix())
|
|
testTarget = encPubkey{0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1}
|
|
testRemote = rpcEndpoint{IP: net.ParseIP("1.1.1.1").To4(), UDP: 1, TCP: 2}
|
|
testLocalAnnounced = rpcEndpoint{IP: net.ParseIP("2.2.2.2").To4(), UDP: 3, TCP: 4}
|
|
testLocal = rpcEndpoint{IP: net.ParseIP("3.3.3.3").To4(), UDP: 5, TCP: 6}
|
|
)
|
|
|
|
type udpTest struct {
|
|
t *testing.T
|
|
pipe *dgramPipe
|
|
table *Table
|
|
db *enode.DB
|
|
udp *UDPv4
|
|
sent [][]byte
|
|
localkey, remotekey *ecdsa.PrivateKey
|
|
remoteaddr *net.UDPAddr
|
|
}
|
|
|
|
func newUDPTest(t *testing.T) *udpTest {
|
|
test := &udpTest{
|
|
t: t,
|
|
pipe: newpipe(),
|
|
localkey: newkey(),
|
|
remotekey: newkey(),
|
|
remoteaddr: &net.UDPAddr{IP: net.IP{10, 0, 1, 99}, Port: 30303},
|
|
}
|
|
|
|
test.db, _ = enode.OpenDB("")
|
|
ln := enode.NewLocalNode(test.db, test.localkey)
|
|
test.udp, _ = ListenV4(test.pipe, ln, Config{
|
|
PrivateKey: test.localkey,
|
|
Log: testlog.Logger(t, log.LvlTrace),
|
|
})
|
|
test.table = test.udp.tab
|
|
// Wait for initial refresh so the table doesn't send unexpected findnode.
|
|
<-test.table.initDone
|
|
return test
|
|
}
|
|
|
|
func (test *udpTest) close() {
|
|
test.udp.Close()
|
|
test.db.Close()
|
|
}
|
|
|
|
// handles a packet as if it had been sent to the transport.
|
|
func (test *udpTest) packetIn(wantError error, data packetV4) {
|
|
test.t.Helper()
|
|
|
|
test.packetInFrom(wantError, test.remotekey, test.remoteaddr, data)
|
|
}
|
|
|
|
// handles a packet as if it had been sent to the transport by the key/endpoint.
|
|
func (test *udpTest) packetInFrom(wantError error, key *ecdsa.PrivateKey, addr *net.UDPAddr, data packetV4) {
|
|
test.t.Helper()
|
|
|
|
enc, _, err := test.udp.encode(key, data)
|
|
if err != nil {
|
|
test.t.Errorf("%s encode error: %v", data.name(), err)
|
|
}
|
|
test.sent = append(test.sent, enc)
|
|
if err = test.udp.handlePacket(addr, enc); err != wantError {
|
|
test.t.Errorf("error mismatch: got %q, want %q", err, wantError)
|
|
}
|
|
}
|
|
|
|
// waits for a packet to be sent by the transport.
|
|
// validate should have type func(X, *net.UDPAddr, []byte), where X is a packet type.
|
|
func (test *udpTest) waitPacketOut(validate interface{}) (closed bool) {
|
|
test.t.Helper()
|
|
|
|
dgram, ok := test.pipe.receive()
|
|
if !ok {
|
|
return true
|
|
}
|
|
p, _, hash, err := decodeV4(dgram.data)
|
|
if err != nil {
|
|
test.t.Errorf("sent packet decode error: %v", err)
|
|
return false
|
|
}
|
|
fn := reflect.ValueOf(validate)
|
|
exptype := fn.Type().In(0)
|
|
if !reflect.TypeOf(p).AssignableTo(exptype) {
|
|
test.t.Errorf("sent packet type mismatch, got: %v, want: %v", reflect.TypeOf(p), exptype)
|
|
return false
|
|
}
|
|
fn.Call([]reflect.Value{reflect.ValueOf(p), reflect.ValueOf(&dgram.to), reflect.ValueOf(hash)})
|
|
return false
|
|
}
|
|
|
|
func TestUDPv4_packetErrors(t *testing.T) {
|
|
test := newUDPTest(t)
|
|
defer test.close()
|
|
|
|
test.packetIn(errExpired, &pingV4{From: testRemote, To: testLocalAnnounced, Version: 4})
|
|
test.packetIn(errUnsolicitedReply, &pongV4{ReplyTok: []byte{}, Expiration: futureExp})
|
|
test.packetIn(errUnknownNode, &findnodeV4{Expiration: futureExp})
|
|
test.packetIn(errUnsolicitedReply, &neighborsV4{Expiration: futureExp})
|
|
}
|
|
|
|
func TestUDPv4_pingTimeout(t *testing.T) {
|
|
t.Parallel()
|
|
test := newUDPTest(t)
|
|
defer test.close()
|
|
|
|
key := newkey()
|
|
toaddr := &net.UDPAddr{IP: net.ParseIP("1.2.3.4"), Port: 2222}
|
|
node := enode.NewV4(&key.PublicKey, toaddr.IP, 0, toaddr.Port)
|
|
if _, err := test.udp.ping(node); err != errTimeout {
|
|
t.Error("expected timeout error, got", err)
|
|
}
|
|
}
|
|
|
|
type testPacket byte
|
|
|
|
func (req testPacket) kind() byte { return byte(req) }
|
|
func (req testPacket) name() string { return "" }
|
|
func (req testPacket) preverify(*UDPv4, *net.UDPAddr, enode.ID, encPubkey) error {
|
|
return nil
|
|
}
|
|
func (req testPacket) handle(*UDPv4, *net.UDPAddr, enode.ID, []byte) {
|
|
}
|
|
|
|
func TestUDPv4_responseTimeouts(t *testing.T) {
|
|
t.Parallel()
|
|
test := newUDPTest(t)
|
|
defer test.close()
|
|
|
|
rand.Seed(time.Now().UnixNano())
|
|
randomDuration := func(max time.Duration) time.Duration {
|
|
return time.Duration(rand.Int63n(int64(max)))
|
|
}
|
|
|
|
var (
|
|
nReqs = 200
|
|
nTimeouts = 0 // number of requests with ptype > 128
|
|
nilErr = make(chan error, nReqs) // for requests that get a reply
|
|
timeoutErr = make(chan error, nReqs) // for requests that time out
|
|
)
|
|
for i := 0; i < nReqs; i++ {
|
|
// Create a matcher for a random request in udp.loop. Requests
|
|
// with ptype <= 128 will not get a reply and should time out.
|
|
// For all other requests, a reply is scheduled to arrive
|
|
// within the timeout window.
|
|
p := &replyMatcher{
|
|
ptype: byte(rand.Intn(255)),
|
|
callback: func(interface{}) (bool, bool) { return true, true },
|
|
}
|
|
binary.BigEndian.PutUint64(p.from[:], uint64(i))
|
|
if p.ptype <= 128 {
|
|
p.errc = timeoutErr
|
|
test.udp.addReplyMatcher <- p
|
|
nTimeouts++
|
|
} else {
|
|
p.errc = nilErr
|
|
test.udp.addReplyMatcher <- p
|
|
time.AfterFunc(randomDuration(60*time.Millisecond), func() {
|
|
if !test.udp.handleReply(p.from, p.ip, testPacket(p.ptype)) {
|
|
t.Logf("not matched: %v", p)
|
|
}
|
|
})
|
|
}
|
|
time.Sleep(randomDuration(30 * time.Millisecond))
|
|
}
|
|
|
|
// Check that all timeouts were delivered and that the rest got nil errors.
|
|
// The replies must be delivered.
|
|
var (
|
|
recvDeadline = time.After(20 * time.Second)
|
|
nTimeoutsRecv, nNil = 0, 0
|
|
)
|
|
for i := 0; i < nReqs; i++ {
|
|
select {
|
|
case err := <-timeoutErr:
|
|
if err != errTimeout {
|
|
t.Fatalf("got non-timeout error on timeoutErr %d: %v", i, err)
|
|
}
|
|
nTimeoutsRecv++
|
|
case err := <-nilErr:
|
|
if err != nil {
|
|
t.Fatalf("got non-nil error on nilErr %d: %v", i, err)
|
|
}
|
|
nNil++
|
|
case <-recvDeadline:
|
|
t.Fatalf("exceeded recv deadline")
|
|
}
|
|
}
|
|
if nTimeoutsRecv != nTimeouts {
|
|
t.Errorf("wrong number of timeout errors received: got %d, want %d", nTimeoutsRecv, nTimeouts)
|
|
}
|
|
if nNil != nReqs-nTimeouts {
|
|
t.Errorf("wrong number of successful replies: got %d, want %d", nNil, nReqs-nTimeouts)
|
|
}
|
|
}
|
|
|
|
func TestUDPv4_findnodeTimeout(t *testing.T) {
|
|
t.Parallel()
|
|
test := newUDPTest(t)
|
|
defer test.close()
|
|
|
|
toaddr := &net.UDPAddr{IP: net.ParseIP("1.2.3.4"), Port: 2222}
|
|
toid := enode.ID{1, 2, 3, 4}
|
|
target := encPubkey{4, 5, 6, 7}
|
|
result, err := test.udp.findnode(toid, toaddr, target)
|
|
if err != errTimeout {
|
|
t.Error("expected timeout error, got", err)
|
|
}
|
|
if len(result) > 0 {
|
|
t.Error("expected empty result, got", result)
|
|
}
|
|
}
|
|
|
|
func TestUDPv4_findnode(t *testing.T) {
|
|
test := newUDPTest(t)
|
|
defer test.close()
|
|
|
|
// put a few nodes into the table. their exact
|
|
// distribution shouldn't matter much, although we need to
|
|
// take care not to overflow any bucket.
|
|
nodes := &nodesByDistance{target: testTarget.id()}
|
|
live := make(map[enode.ID]bool)
|
|
numCandidates := 2 * bucketSize
|
|
for i := 0; i < numCandidates; i++ {
|
|
key := newkey()
|
|
ip := net.IP{10, 13, 0, byte(i)}
|
|
n := wrapNode(enode.NewV4(&key.PublicKey, ip, 0, 2000))
|
|
// Ensure half of table content isn't verified live yet.
|
|
if i > numCandidates/2 {
|
|
n.livenessChecks = 1
|
|
live[n.ID()] = true
|
|
}
|
|
nodes.push(n, numCandidates)
|
|
}
|
|
fillTable(test.table, nodes.entries)
|
|
|
|
// ensure there's a bond with the test node,
|
|
// findnode won't be accepted otherwise.
|
|
remoteID := encodePubkey(&test.remotekey.PublicKey).id()
|
|
test.table.db.UpdateLastPongReceived(remoteID, test.remoteaddr.IP, time.Now())
|
|
|
|
// check that closest neighbors are returned.
|
|
expected := test.table.closest(testTarget.id(), bucketSize, true)
|
|
test.packetIn(nil, &findnodeV4{Target: testTarget, Expiration: futureExp})
|
|
waitNeighbors := func(want []*node) {
|
|
test.waitPacketOut(func(p *neighborsV4, to *net.UDPAddr, hash []byte) {
|
|
if len(p.Nodes) != len(want) {
|
|
t.Errorf("wrong number of results: got %d, want %d", len(p.Nodes), bucketSize)
|
|
}
|
|
for i, n := range p.Nodes {
|
|
if n.ID.id() != want[i].ID() {
|
|
t.Errorf("result mismatch at %d:\n got: %v\n want: %v", i, n, expected.entries[i])
|
|
}
|
|
if !live[n.ID.id()] {
|
|
t.Errorf("result includes dead node %v", n.ID.id())
|
|
}
|
|
}
|
|
})
|
|
}
|
|
// Receive replies.
|
|
want := expected.entries
|
|
if len(want) > maxNeighbors {
|
|
waitNeighbors(want[:maxNeighbors])
|
|
want = want[maxNeighbors:]
|
|
}
|
|
waitNeighbors(want)
|
|
}
|
|
|
|
func TestUDPv4_findnodeMultiReply(t *testing.T) {
|
|
test := newUDPTest(t)
|
|
defer test.close()
|
|
|
|
rid := enode.PubkeyToIDV4(&test.remotekey.PublicKey)
|
|
test.table.db.UpdateLastPingReceived(rid, test.remoteaddr.IP, time.Now())
|
|
|
|
// queue a pending findnode request
|
|
resultc, errc := make(chan []*node), make(chan error)
|
|
go func() {
|
|
rid := encodePubkey(&test.remotekey.PublicKey).id()
|
|
ns, err := test.udp.findnode(rid, test.remoteaddr, testTarget)
|
|
if err != nil && len(ns) == 0 {
|
|
errc <- err
|
|
} else {
|
|
resultc <- ns
|
|
}
|
|
}()
|
|
|
|
// wait for the findnode to be sent.
|
|
// after it is sent, the transport is waiting for a reply
|
|
test.waitPacketOut(func(p *findnodeV4, to *net.UDPAddr, hash []byte) {
|
|
if p.Target != testTarget {
|
|
t.Errorf("wrong target: got %v, want %v", p.Target, testTarget)
|
|
}
|
|
})
|
|
|
|
// send the reply as two packets.
|
|
list := []*node{
|
|
wrapNode(enode.MustParse("enode://ba85011c70bcc5c04d8607d3a0ed29aa6179c092cbdda10d5d32684fb33ed01bd94f588ca8f91ac48318087dcb02eaf36773a7a453f0eedd6742af668097b29c@10.0.1.16:30303?discport=30304")),
|
|
wrapNode(enode.MustParse("enode://81fa361d25f157cd421c60dcc28d8dac5ef6a89476633339c5df30287474520caca09627da18543d9079b5b288698b542d56167aa5c09111e55acdbbdf2ef799@10.0.1.16:30303")),
|
|
wrapNode(enode.MustParse("enode://9bffefd833d53fac8e652415f4973bee289e8b1a5c6c4cbe70abf817ce8a64cee11b823b66a987f51aaa9fba0d6a91b3e6bf0d5a5d1042de8e9eeea057b217f8@10.0.1.36:30301?discport=17")),
|
|
wrapNode(enode.MustParse("enode://1b5b4aa662d7cb44a7221bfba67302590b643028197a7d5214790f3bac7aaa4a3241be9e83c09cf1f6c69d007c634faae3dc1b1221793e8446c0b3a09de65960@10.0.1.16:30303")),
|
|
}
|
|
rpclist := make([]rpcNode, len(list))
|
|
for i := range list {
|
|
rpclist[i] = nodeToRPC(list[i])
|
|
}
|
|
test.packetIn(nil, &neighborsV4{Expiration: futureExp, Nodes: rpclist[:2]})
|
|
test.packetIn(nil, &neighborsV4{Expiration: futureExp, Nodes: rpclist[2:]})
|
|
|
|
// check that the sent neighbors are all returned by findnode
|
|
select {
|
|
case result := <-resultc:
|
|
want := append(list[:2], list[3:]...)
|
|
if !reflect.DeepEqual(result, want) {
|
|
t.Errorf("neighbors mismatch:\n got: %v\n want: %v", result, want)
|
|
}
|
|
case err := <-errc:
|
|
t.Errorf("findnode error: %v", err)
|
|
case <-time.After(5 * time.Second):
|
|
t.Error("findnode did not return within 5 seconds")
|
|
}
|
|
}
|
|
|
|
// This test checks that reply matching of pong verifies the ping hash.
|
|
func TestUDPv4_pingMatch(t *testing.T) {
|
|
test := newUDPTest(t)
|
|
defer test.close()
|
|
|
|
randToken := make([]byte, 32)
|
|
crand.Read(randToken)
|
|
|
|
test.packetIn(nil, &pingV4{From: testRemote, To: testLocalAnnounced, Version: 4, Expiration: futureExp})
|
|
test.waitPacketOut(func(*pongV4, *net.UDPAddr, []byte) {})
|
|
test.waitPacketOut(func(*pingV4, *net.UDPAddr, []byte) {})
|
|
test.packetIn(errUnsolicitedReply, &pongV4{ReplyTok: randToken, To: testLocalAnnounced, Expiration: futureExp})
|
|
}
|
|
|
|
// This test checks that reply matching of pong verifies the sender IP address.
|
|
func TestUDPv4_pingMatchIP(t *testing.T) {
|
|
test := newUDPTest(t)
|
|
defer test.close()
|
|
|
|
test.packetIn(nil, &pingV4{From: testRemote, To: testLocalAnnounced, Version: 4, Expiration: futureExp})
|
|
test.waitPacketOut(func(*pongV4, *net.UDPAddr, []byte) {})
|
|
|
|
test.waitPacketOut(func(p *pingV4, to *net.UDPAddr, hash []byte) {
|
|
wrongAddr := &net.UDPAddr{IP: net.IP{33, 44, 1, 2}, Port: 30000}
|
|
test.packetInFrom(errUnsolicitedReply, test.remotekey, wrongAddr, &pongV4{
|
|
ReplyTok: hash,
|
|
To: testLocalAnnounced,
|
|
Expiration: futureExp,
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestUDPv4_successfulPing(t *testing.T) {
|
|
test := newUDPTest(t)
|
|
added := make(chan *node, 1)
|
|
test.table.nodeAddedHook = func(n *node) { added <- n }
|
|
defer test.close()
|
|
|
|
// The remote side sends a ping packet to initiate the exchange.
|
|
go test.packetIn(nil, &pingV4{From: testRemote, To: testLocalAnnounced, Version: 4, Expiration: futureExp})
|
|
|
|
// The ping is replied to.
|
|
test.waitPacketOut(func(p *pongV4, to *net.UDPAddr, hash []byte) {
|
|
pinghash := test.sent[0][:macSize]
|
|
if !bytes.Equal(p.ReplyTok, pinghash) {
|
|
t.Errorf("got pong.ReplyTok %x, want %x", p.ReplyTok, pinghash)
|
|
}
|
|
wantTo := rpcEndpoint{
|
|
// The mirrored UDP address is the UDP packet sender
|
|
IP: test.remoteaddr.IP, UDP: uint16(test.remoteaddr.Port),
|
|
// The mirrored TCP port is the one from the ping packet
|
|
TCP: testRemote.TCP,
|
|
}
|
|
if !reflect.DeepEqual(p.To, wantTo) {
|
|
t.Errorf("got pong.To %v, want %v", p.To, wantTo)
|
|
}
|
|
})
|
|
|
|
// Remote is unknown, the table pings back.
|
|
test.waitPacketOut(func(p *pingV4, to *net.UDPAddr, hash []byte) {
|
|
if !reflect.DeepEqual(p.From, test.udp.ourEndpoint()) {
|
|
t.Errorf("got ping.From %#v, want %#v", p.From, test.udp.ourEndpoint())
|
|
}
|
|
wantTo := rpcEndpoint{
|
|
// The mirrored UDP address is the UDP packet sender.
|
|
IP: test.remoteaddr.IP,
|
|
UDP: uint16(test.remoteaddr.Port),
|
|
TCP: 0,
|
|
}
|
|
if !reflect.DeepEqual(p.To, wantTo) {
|
|
t.Errorf("got ping.To %v, want %v", p.To, wantTo)
|
|
}
|
|
test.packetIn(nil, &pongV4{ReplyTok: hash, Expiration: futureExp})
|
|
})
|
|
|
|
// The node should be added to the table shortly after getting the
|
|
// pong packet.
|
|
select {
|
|
case n := <-added:
|
|
rid := encodePubkey(&test.remotekey.PublicKey).id()
|
|
if n.ID() != rid {
|
|
t.Errorf("node has wrong ID: got %v, want %v", n.ID(), rid)
|
|
}
|
|
if !n.IP().Equal(test.remoteaddr.IP) {
|
|
t.Errorf("node has wrong IP: got %v, want: %v", n.IP(), test.remoteaddr.IP)
|
|
}
|
|
if int(n.UDP()) != test.remoteaddr.Port {
|
|
t.Errorf("node has wrong UDP port: got %v, want: %v", n.UDP(), test.remoteaddr.Port)
|
|
}
|
|
if n.TCP() != int(testRemote.TCP) {
|
|
t.Errorf("node has wrong TCP port: got %v, want: %v", n.TCP(), testRemote.TCP)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
t.Errorf("node was not added within 2 seconds")
|
|
}
|
|
}
|
|
|
|
// This test checks that EIP-868 requests work.
|
|
func TestUDPv4_EIP868(t *testing.T) {
|
|
test := newUDPTest(t)
|
|
defer test.close()
|
|
|
|
test.udp.localNode.Set(enr.WithEntry("foo", "bar"))
|
|
wantNode := test.udp.localNode.Node()
|
|
|
|
// ENR requests aren't allowed before endpoint proof.
|
|
test.packetIn(errUnknownNode, &enrRequestV4{Expiration: futureExp})
|
|
|
|
// Perform endpoint proof and check for sequence number in packet tail.
|
|
test.packetIn(nil, &pingV4{Expiration: futureExp})
|
|
test.waitPacketOut(func(p *pongV4, addr *net.UDPAddr, hash []byte) {
|
|
if seq := seqFromTail(p.Rest); seq != wantNode.Seq() {
|
|
t.Errorf("wrong sequence number in pong: %d, want %d", seq, wantNode.Seq())
|
|
}
|
|
})
|
|
test.waitPacketOut(func(p *pingV4, addr *net.UDPAddr, hash []byte) {
|
|
if seq := seqFromTail(p.Rest); seq != wantNode.Seq() {
|
|
t.Errorf("wrong sequence number in ping: %d, want %d", seq, wantNode.Seq())
|
|
}
|
|
test.packetIn(nil, &pongV4{Expiration: futureExp, ReplyTok: hash})
|
|
})
|
|
|
|
// Request should work now.
|
|
test.packetIn(nil, &enrRequestV4{Expiration: futureExp})
|
|
test.waitPacketOut(func(p *enrResponseV4, addr *net.UDPAddr, hash []byte) {
|
|
n, err := enode.New(enode.ValidSchemes, &p.Record)
|
|
if err != nil {
|
|
t.Fatalf("invalid record: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(n, wantNode) {
|
|
t.Fatalf("wrong node in enrResponse: %v", n)
|
|
}
|
|
})
|
|
}
|
|
|
|
// EIP-8 test vectors.
|
|
var testPackets = []struct {
|
|
input string
|
|
wantPacket interface{}
|
|
}{
|
|
{
|
|
input: "71dbda3a79554728d4f94411e42ee1f8b0d561c10e1e5f5893367948c6a7d70bb87b235fa28a77070271b6c164a2dce8c7e13a5739b53b5e96f2e5acb0e458a02902f5965d55ecbeb2ebb6cabb8b2b232896a36b737666c55265ad0a68412f250001ea04cb847f000001820cfa8215a8d790000000000000000000000000000000018208ae820d058443b9a355",
|
|
wantPacket: &pingV4{
|
|
Version: 4,
|
|
From: rpcEndpoint{net.ParseIP("127.0.0.1").To4(), 3322, 5544},
|
|
To: rpcEndpoint{net.ParseIP("::1"), 2222, 3333},
|
|
Expiration: 1136239445,
|
|
Rest: []rlp.RawValue{},
|
|
},
|
|
},
|
|
{
|
|
input: "e9614ccfd9fc3e74360018522d30e1419a143407ffcce748de3e22116b7e8dc92ff74788c0b6663aaa3d67d641936511c8f8d6ad8698b820a7cf9e1be7155e9a241f556658c55428ec0563514365799a4be2be5a685a80971ddcfa80cb422cdd0101ec04cb847f000001820cfa8215a8d790000000000000000000000000000000018208ae820d058443b9a3550102",
|
|
wantPacket: &pingV4{
|
|
Version: 4,
|
|
From: rpcEndpoint{net.ParseIP("127.0.0.1").To4(), 3322, 5544},
|
|
To: rpcEndpoint{net.ParseIP("::1"), 2222, 3333},
|
|
Expiration: 1136239445,
|
|
Rest: []rlp.RawValue{{0x01}, {0x02}},
|
|
},
|
|
},
|
|
{
|
|
input: "577be4349c4dd26768081f58de4c6f375a7a22f3f7adda654d1428637412c3d7fe917cadc56d4e5e7ffae1dbe3efffb9849feb71b262de37977e7c7a44e677295680e9e38ab26bee2fcbae207fba3ff3d74069a50b902a82c9903ed37cc993c50001f83e82022bd79020010db83c4d001500000000abcdef12820cfa8215a8d79020010db885a308d313198a2e037073488208ae82823a8443b9a355c5010203040531b9019afde696e582a78fa8d95ea13ce3297d4afb8ba6433e4154caa5ac6431af1b80ba76023fa4090c408f6b4bc3701562c031041d4702971d102c9ab7fa5eed4cd6bab8f7af956f7d565ee1917084a95398b6a21eac920fe3dd1345ec0a7ef39367ee69ddf092cbfe5b93e5e568ebc491983c09c76d922dc3",
|
|
wantPacket: &pingV4{
|
|
Version: 555,
|
|
From: rpcEndpoint{net.ParseIP("2001:db8:3c4d:15::abcd:ef12"), 3322, 5544},
|
|
To: rpcEndpoint{net.ParseIP("2001:db8:85a3:8d3:1319:8a2e:370:7348"), 2222, 33338},
|
|
Expiration: 1136239445,
|
|
Rest: []rlp.RawValue{{0xC5, 0x01, 0x02, 0x03, 0x04, 0x05}},
|
|
},
|
|
},
|
|
{
|
|
input: "09b2428d83348d27cdf7064ad9024f526cebc19e4958f0fdad87c15eb598dd61d08423e0bf66b2069869e1724125f820d851c136684082774f870e614d95a2855d000f05d1648b2d5945470bc187c2d2216fbe870f43ed0909009882e176a46b0102f846d79020010db885a308d313198a2e037073488208ae82823aa0fbc914b16819237dcd8801d7e53f69e9719adecb3cc0e790c57e91ca4461c9548443b9a355c6010203c2040506a0c969a58f6f9095004c0177a6b47f451530cab38966a25cca5cb58f055542124e",
|
|
wantPacket: &pongV4{
|
|
To: rpcEndpoint{net.ParseIP("2001:db8:85a3:8d3:1319:8a2e:370:7348"), 2222, 33338},
|
|
ReplyTok: common.Hex2Bytes("fbc914b16819237dcd8801d7e53f69e9719adecb3cc0e790c57e91ca4461c954"),
|
|
Expiration: 1136239445,
|
|
Rest: []rlp.RawValue{{0xC6, 0x01, 0x02, 0x03, 0xC2, 0x04, 0x05}, {0x06}},
|
|
},
|
|
},
|
|
{
|
|
input: "c7c44041b9f7c7e41934417ebac9a8e1a4c6298f74553f2fcfdcae6ed6fe53163eb3d2b52e39fe91831b8a927bf4fc222c3902202027e5e9eb812195f95d20061ef5cd31d502e47ecb61183f74a504fe04c51e73df81f25c4d506b26db4517490103f84eb840ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31387574077f301b421bc84df7266c44e9e6d569fc56be00812904767bf5ccd1fc7f8443b9a35582999983999999280dc62cc8255c73471e0a61da0c89acdc0e035e260add7fc0c04ad9ebf3919644c91cb247affc82b69bd2ca235c71eab8e49737c937a2c396",
|
|
wantPacket: &findnodeV4{
|
|
Target: hexEncPubkey("ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31387574077f301b421bc84df7266c44e9e6d569fc56be00812904767bf5ccd1fc7f"),
|
|
Expiration: 1136239445,
|
|
Rest: []rlp.RawValue{{0x82, 0x99, 0x99}, {0x83, 0x99, 0x99, 0x99}},
|
|
},
|
|
},
|
|
{
|
|
input: "c679fc8fe0b8b12f06577f2e802d34f6fa257e6137a995f6f4cbfc9ee50ed3710faf6e66f932c4c8d81d64343f429651328758b47d3dbc02c4042f0fff6946a50f4a49037a72bb550f3a7872363a83e1b9ee6469856c24eb4ef80b7535bcf99c0004f9015bf90150f84d846321163782115c82115db8403155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32f84984010203040101b840312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069dbf8599020010db83c4d001500000000abcdef12820d05820d05b84038643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aacf8599020010db885a308d313198a2e037073488203e78203e8b8408dcab8618c3253b558d459da53bd8fa68935a719aff8b811197101a4b2b47dd2d47295286fc00cc081bb542d760717d1bdd6bec2c37cd72eca367d6dd3b9df738443b9a355010203b525a138aa34383fec3d2719a0",
|
|
wantPacket: &neighborsV4{
|
|
Nodes: []rpcNode{
|
|
{
|
|
ID: hexEncPubkey("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"),
|
|
IP: net.ParseIP("99.33.22.55").To4(),
|
|
UDP: 4444,
|
|
TCP: 4445,
|
|
},
|
|
{
|
|
ID: hexEncPubkey("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"),
|
|
IP: net.ParseIP("1.2.3.4").To4(),
|
|
UDP: 1,
|
|
TCP: 1,
|
|
},
|
|
{
|
|
ID: hexEncPubkey("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"),
|
|
IP: net.ParseIP("2001:db8:3c4d:15::abcd:ef12"),
|
|
UDP: 3333,
|
|
TCP: 3333,
|
|
},
|
|
{
|
|
ID: hexEncPubkey("8dcab8618c3253b558d459da53bd8fa68935a719aff8b811197101a4b2b47dd2d47295286fc00cc081bb542d760717d1bdd6bec2c37cd72eca367d6dd3b9df73"),
|
|
IP: net.ParseIP("2001:db8:85a3:8d3:1319:8a2e:370:7348"),
|
|
UDP: 999,
|
|
TCP: 1000,
|
|
},
|
|
},
|
|
Expiration: 1136239445,
|
|
Rest: []rlp.RawValue{{0x01}, {0x02}, {0x03}},
|
|
},
|
|
},
|
|
}
|
|
|
|
func TestUDPv4_forwardCompatibility(t *testing.T) {
|
|
testkey, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
|
|
wantNodeKey := encodePubkey(&testkey.PublicKey)
|
|
|
|
for _, test := range testPackets {
|
|
input, err := hex.DecodeString(test.input)
|
|
if err != nil {
|
|
t.Fatalf("invalid hex: %s", test.input)
|
|
}
|
|
packet, nodekey, _, err := decodeV4(input)
|
|
if err != nil {
|
|
t.Errorf("did not accept packet %s\n%v", test.input, err)
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(packet, test.wantPacket) {
|
|
t.Errorf("got %s\nwant %s", spew.Sdump(packet), spew.Sdump(test.wantPacket))
|
|
}
|
|
if nodekey != wantNodeKey {
|
|
t.Errorf("got id %v\nwant id %v", nodekey, wantNodeKey)
|
|
}
|
|
}
|
|
}
|
|
|
|
// dgramPipe is a fake UDP socket. It queues all sent datagrams.
|
|
type dgramPipe struct {
|
|
mu *sync.Mutex
|
|
cond *sync.Cond
|
|
closing chan struct{}
|
|
closed bool
|
|
queue []dgram
|
|
}
|
|
|
|
type dgram struct {
|
|
to net.UDPAddr
|
|
data []byte
|
|
}
|
|
|
|
func newpipe() *dgramPipe {
|
|
mu := new(sync.Mutex)
|
|
return &dgramPipe{
|
|
closing: make(chan struct{}),
|
|
cond: &sync.Cond{L: mu},
|
|
mu: mu,
|
|
}
|
|
}
|
|
|
|
// WriteToUDP queues a datagram.
|
|
func (c *dgramPipe) WriteToUDP(b []byte, to *net.UDPAddr) (n int, err error) {
|
|
msg := make([]byte, len(b))
|
|
copy(msg, b)
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
if c.closed {
|
|
return 0, errors.New("closed")
|
|
}
|
|
c.queue = append(c.queue, dgram{*to, b})
|
|
c.cond.Signal()
|
|
return len(b), nil
|
|
}
|
|
|
|
// ReadFromUDP just hangs until the pipe is closed.
|
|
func (c *dgramPipe) ReadFromUDP(b []byte) (n int, addr *net.UDPAddr, err error) {
|
|
<-c.closing
|
|
return 0, nil, io.EOF
|
|
}
|
|
|
|
func (c *dgramPipe) Close() error {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
if !c.closed {
|
|
close(c.closing)
|
|
c.closed = true
|
|
}
|
|
c.cond.Broadcast()
|
|
return nil
|
|
}
|
|
|
|
func (c *dgramPipe) LocalAddr() net.Addr {
|
|
return &net.UDPAddr{IP: testLocal.IP, Port: int(testLocal.UDP)}
|
|
}
|
|
|
|
func (c *dgramPipe) receive() (dgram, bool) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
for len(c.queue) == 0 && !c.closed {
|
|
c.cond.Wait()
|
|
}
|
|
if c.closed {
|
|
return dgram{}, false
|
|
}
|
|
p := c.queue[0]
|
|
copy(c.queue, c.queue[1:])
|
|
c.queue = c.queue[:len(c.queue)-1]
|
|
return p, true
|
|
}
|