From 9f3bd7368341ba1fb1a38d290e6fc914094e913e Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 12:23:09 +0800
Subject: [PATCH 01/14] fix(p2p/enode): fix endpoint determination for IPv6
#29801
---
cmd/devp2p/discv4cmd.go | 2 +-
p2p/enode/idscheme.go | 2 +-
p2p/enode/node.go | 148 +++++++++++++++++++++++++--------
p2p/enode/node_test.go | 178 ++++++++++++++++++++++++++++++++++++++++
p2p/enode/nodedb.go | 12 +--
p2p/enode/urlv4.go | 2 +-
p2p/enr/entries.go | 56 +++++++++++++
7 files changed, 359 insertions(+), 41 deletions(-)
diff --git a/cmd/devp2p/discv4cmd.go b/cmd/devp2p/discv4cmd.go
index d14755e9e684..ffef2cb71286 100644
--- a/cmd/devp2p/discv4cmd.go
+++ b/cmd/devp2p/discv4cmd.go
@@ -396,7 +396,7 @@ func pingUntil(disc *discover.UDPv4, n *enode.Node, timeout time.Duration) (time
}
func nodeEndpoint(n *enode.Node) string {
- if n.Incomplete() {
+ if !n.IPAddr().IsValid() {
return n.ID().String()
}
if n.UDP() == n.TCP() {
diff --git a/p2p/enode/idscheme.go b/p2p/enode/idscheme.go
index 04edbed0994f..9fad2357673d 100644
--- a/p2p/enode/idscheme.go
+++ b/p2p/enode/idscheme.go
@@ -156,5 +156,5 @@ func SignNull(r *enr.Record, id ID) *Node {
if err := r.SetSig(NullID{}, []byte{}); err != nil {
panic(err)
}
- return &Node{r: *r, id: id}
+ return newNodeWithID(r, id)
}
diff --git a/p2p/enode/node.go b/p2p/enode/node.go
index 574abaf874b1..2889cedd9e02 100644
--- a/p2p/enode/node.go
+++ b/p2p/enode/node.go
@@ -24,6 +24,7 @@ import (
"fmt"
"math/bits"
"net"
+ "net/netip"
"strings"
"github.com/XinFinOrg/XDPoSChain/p2p/enr"
@@ -36,6 +37,11 @@ var errMissingPrefix = errors.New("missing 'enr:' prefix for base64-encoded reco
type Node struct {
r enr.Record
id ID
+
+ // endpoint information
+ ip netip.Addr
+ udp uint16
+ tcp uint16
}
// New wraps a node record. The record must be valid according to the given
@@ -44,11 +50,86 @@ func New(validSchemes enr.IdentityScheme, r *enr.Record) (*Node, error) {
if err := r.VerifySignature(validSchemes); err != nil {
return nil, err
}
- node := &Node{r: *r}
- if n := copy(node.id[:], validSchemes.NodeAddr(&node.r)); n != len(ID{}) {
- return nil, fmt.Errorf("invalid node ID length %d, need %d", n, len(ID{}))
+ var id ID
+ if n := copy(id[:], validSchemes.NodeAddr(r)); n != len(id) {
+ return nil, fmt.Errorf("invalid node ID length %d, need %d", n, len(id))
+ }
+ return newNodeWithID(r, id), nil
+}
+
+func newNodeWithID(r *enr.Record, id ID) *Node {
+ n := &Node{r: *r, id: id}
+ // Set the preferred endpoint.
+ // Here we decide between IPv4 and IPv6, choosing the 'most global' address.
+ var ip4 netip.Addr
+ var ip6 netip.Addr
+ n.Load((*enr.IPv4Addr)(&ip4))
+ n.Load((*enr.IPv6Addr)(&ip6))
+ valid4 := validIP(ip4)
+ valid6 := validIP(ip6)
+ switch {
+ case valid4 && valid6:
+ if localityScore(ip4) >= localityScore(ip6) {
+ n.setIP4(ip4)
+ } else {
+ n.setIP6(ip6)
+ }
+ case valid4:
+ n.setIP4(ip4)
+ case valid6:
+ n.setIP6(ip6)
+ default:
+ n.setIPv4Ports()
+ }
+ return n
+}
+
+// validIP reports whether 'ip' is a valid node endpoint IP address.
+func validIP(ip netip.Addr) bool {
+ return ip.IsValid() && !ip.IsMulticast()
+}
+
+func localityScore(ip netip.Addr) int {
+ switch {
+ case ip.IsUnspecified():
+ return 0
+ case ip.IsLoopback():
+ return 1
+ case ip.IsLinkLocalUnicast():
+ return 2
+ case ip.IsPrivate():
+ return 3
+ default:
+ return 4
+ }
+}
+
+func (n *Node) setIP4(ip netip.Addr) {
+ n.ip = ip
+ n.setIPv4Ports()
+}
+
+func (n *Node) setIPv4Ports() {
+ if err := n.Load((*enr.UDP)(&n.udp)); err != nil {
+ n.Load((*enr.UDP6)(&n.udp))
+ }
+ if err := n.Load((*enr.TCP)(&n.tcp)); err != nil {
+ n.Load((*enr.TCP6)(&n.tcp))
+ }
+}
+
+func (n *Node) setIP6(ip netip.Addr) {
+ if ip.Is4In6() {
+ n.setIP4(ip)
+ return
+ }
+ n.ip = ip
+ if err := n.Load((*enr.UDP6)(&n.udp)); err != nil {
+ n.Load((*enr.UDP)(&n.udp))
+ }
+ if err := n.Load((*enr.TCP6)(&n.tcp)); err != nil {
+ n.Load((*enr.TCP)(&n.tcp))
}
- return node, nil
}
// MustParse parses a node record or enode:// URL. It panics if the input is invalid.
@@ -89,43 +170,45 @@ func (n *Node) Seq() uint64 {
return n.r.Seq()
}
-// Incomplete returns true for nodes with no IP address.
-func (n *Node) Incomplete() bool {
- return n.IP() == nil
-}
-
// Load retrieves an entry from the underlying record.
func (n *Node) Load(k enr.Entry) error {
return n.r.Load(k)
}
-// IP returns the IP address of the node. This prefers IPv4 addresses.
+// IP returns the IP address of the node.
func (n *Node) IP() net.IP {
- var (
- ip4 enr.IPv4
- ip6 enr.IPv6
- )
- if n.Load(&ip4) == nil {
- return net.IP(ip4)
- }
- if n.Load(&ip6) == nil {
- return net.IP(ip6)
- }
- return nil
+ return net.IP(n.ip.AsSlice())
+}
+
+// IPAddr returns the IP address of the node.
+func (n *Node) IPAddr() netip.Addr {
+ return n.ip
}
// UDP returns the UDP port of the node.
func (n *Node) UDP() int {
- var port enr.UDP
- n.Load(&port)
- return int(port)
+ return int(n.udp)
}
// TCP returns the TCP port of the node.
func (n *Node) TCP() int {
- var port enr.TCP
- n.Load(&port)
- return int(port)
+ return int(n.tcp)
+}
+
+// UDPEndpoint returns the announced UDP endpoint.
+func (n *Node) UDPEndpoint() (netip.AddrPort, bool) {
+ if !n.ip.IsValid() || n.ip.IsUnspecified() || n.udp == 0 {
+ return netip.AddrPort{}, false
+ }
+ return netip.AddrPortFrom(n.ip, n.udp), true
+}
+
+// TCPEndpoint returns the announced TCP endpoint.
+func (n *Node) TCPEndpoint() (netip.AddrPort, bool) {
+ if !n.ip.IsValid() || n.ip.IsUnspecified() || n.tcp == 0 {
+ return netip.AddrPort{}, false
+ }
+ return netip.AddrPortFrom(n.ip, n.tcp), true
}
// Pubkey returns the secp256k1 public key of the node, if present.
@@ -147,16 +230,15 @@ func (n *Node) Record() *enr.Record {
// ValidateComplete checks whether n has a valid IP and UDP port.
// Deprecated: don't use this method.
func (n *Node) ValidateComplete() error {
- if n.Incomplete() {
+ if !n.ip.IsValid() {
return errors.New("missing IP address")
}
- if n.UDP() == 0 {
- return errors.New("missing UDP port")
- }
- ip := n.IP()
- if ip.IsMulticast() || ip.IsUnspecified() {
+ if n.ip.IsMulticast() || n.ip.IsUnspecified() {
return errors.New("invalid IP (multicast/unspecified)")
}
+ if n.udp == 0 {
+ return errors.New("missing UDP port")
+ }
// Validate the node key (on curve, etc.).
var key Secp256k1
return n.Load(&key)
diff --git a/p2p/enode/node_test.go b/p2p/enode/node_test.go
index 4876f4ce0650..2749b8450044 100644
--- a/p2p/enode/node_test.go
+++ b/p2p/enode/node_test.go
@@ -21,6 +21,7 @@ import (
"encoding/hex"
"fmt"
"math/big"
+ "net/netip"
"testing"
"testing/quick"
@@ -64,6 +65,183 @@ func TestPythonInterop(t *testing.T) {
}
}
+func TestNodeEndpoints(t *testing.T) {
+ id := HexID("00000000000000806ad9b61fa5ae014307ebdc964253adcd9f2c0a392aa11abc")
+ type endpointTest struct {
+ name string
+ node *Node
+ wantIP netip.Addr
+ wantUDP int
+ wantTCP int
+ }
+ tests := []endpointTest{
+ {
+ name: "no-addr",
+ node: func() *Node {
+ var r enr.Record
+ return SignNull(&r, id)
+ }(),
+ },
+ {
+ name: "udp-only",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.UDP(9000))
+ return SignNull(&r, id)
+ }(),
+ wantUDP: 9000,
+ },
+ {
+ name: "tcp-only",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.TCP(9000))
+ return SignNull(&r, id)
+ }(),
+ wantTCP: 9000,
+ },
+ {
+ name: "ipv4-only-loopback",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("127.0.0.1")))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("127.0.0.1"),
+ },
+ {
+ name: "ipv4-only-unspecified",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("0.0.0.0")))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("0.0.0.0"),
+ },
+ {
+ name: "ipv4-only",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("99.22.33.1")))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("99.22.33.1"),
+ },
+ {
+ name: "ipv6-only",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv6Addr(netip.MustParseAddr("2001::ff00:0042:8329")))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("2001::ff00:0042:8329"),
+ },
+ {
+ name: "ipv4-loopback-and-ipv6-global",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("127.0.0.1")))
+ r.Set(enr.UDP(30304))
+ r.Set(enr.IPv6Addr(netip.MustParseAddr("2001::ff00:0042:8329")))
+ r.Set(enr.UDP6(30306))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("2001::ff00:0042:8329"),
+ wantUDP: 30306,
+ },
+ {
+ name: "ipv4-unspecified-and-ipv6-loopback",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("0.0.0.0")))
+ r.Set(enr.IPv6Addr(netip.MustParseAddr("::1")))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("::1"),
+ },
+ {
+ name: "ipv4-private-and-ipv6-global",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("192.168.2.2")))
+ r.Set(enr.UDP(30304))
+ r.Set(enr.IPv6Addr(netip.MustParseAddr("2001::ff00:0042:8329")))
+ r.Set(enr.UDP6(30306))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("2001::ff00:0042:8329"),
+ wantUDP: 30306,
+ },
+ {
+ name: "ipv4-local-and-ipv6-global",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("169.254.2.6")))
+ r.Set(enr.UDP(30304))
+ r.Set(enr.IPv6Addr(netip.MustParseAddr("2001::ff00:0042:8329")))
+ r.Set(enr.UDP6(30306))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("2001::ff00:0042:8329"),
+ wantUDP: 30306,
+ },
+ {
+ name: "ipv4-private-and-ipv6-private",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("192.168.2.2")))
+ r.Set(enr.UDP(30304))
+ r.Set(enr.IPv6Addr(netip.MustParseAddr("fd00::abcd:1")))
+ r.Set(enr.UDP6(30306))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("192.168.2.2"),
+ wantUDP: 30304,
+ },
+ {
+ name: "ipv4-private-and-ipv6-link-local",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("192.168.2.2")))
+ r.Set(enr.UDP(30304))
+ r.Set(enr.IPv6Addr(netip.MustParseAddr("fe80::1")))
+ r.Set(enr.UDP6(30306))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("192.168.2.2"),
+ wantUDP: 30304,
+ },
+ {
+ name: "ipv4-selected-falls-back-to-ipv6-family-ports",
+ node: func() *Node {
+ var r enr.Record
+ r.Set(enr.IPv4Addr(netip.MustParseAddr("99.22.33.1")))
+ r.Set(enr.IPv6Addr(netip.MustParseAddr("fd00::abcd:1")))
+ r.Set(enr.UDP6(30306))
+ r.Set(enr.TCP6(30307))
+ return SignNull(&r, id)
+ }(),
+ wantIP: netip.MustParseAddr("99.22.33.1"),
+ wantUDP: 30306,
+ wantTCP: 30307,
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ if test.wantIP != test.node.IPAddr() {
+ t.Errorf("node has wrong IP %v, want %v", test.node.IPAddr(), test.wantIP)
+ }
+ if test.wantUDP != test.node.UDP() {
+ t.Errorf("node has wrong UDP port %d, want %d", test.node.UDP(), test.wantUDP)
+ }
+ if test.wantTCP != test.node.TCP() {
+ t.Errorf("node has wrong TCP port %d, want %d", test.node.TCP(), test.wantTCP)
+ }
+ })
+ }
+}
+
func TestHexID(t *testing.T) {
ref := ID{0, 0, 0, 0, 0, 0, 0, 128, 106, 217, 182, 31, 165, 174, 1, 67, 7, 235, 220, 150, 66, 83, 173, 205, 159, 44, 10, 57, 42, 161, 26, 188}
id1 := HexID("0x00000000000000806ad9b61fa5ae014307ebdc964253adcd9f2c0a392aa11abc")
diff --git a/p2p/enode/nodedb.go b/p2p/enode/nodedb.go
index 147b0508e43f..4c8a468fa0d2 100644
--- a/p2p/enode/nodedb.go
+++ b/p2p/enode/nodedb.go
@@ -26,6 +26,7 @@ import (
"sync"
"time"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enr"
"github.com/XinFinOrg/XDPoSChain/rlp"
"github.com/syndtr/goleveldb/leveldb"
"github.com/syndtr/goleveldb/leveldb/errors"
@@ -238,13 +239,14 @@ func (db *DB) Node(id ID) *Node {
}
func mustDecodeNode(id, data []byte) *Node {
- node := new(Node)
- if err := rlp.DecodeBytes(data, &node.r); err != nil {
+ var r enr.Record
+ if err := rlp.DecodeBytes(data, &r); err != nil {
panic(fmt.Errorf("p2p/enode: can't decode node %x in DB: %v", id, err))
}
- // Restore node id cache.
- copy(node.id[:], id)
- return node
+ if len(id) != len(ID{}) {
+ panic(fmt.Errorf("invalid id length %d", len(id)))
+ }
+ return newNodeWithID(&r, ID(id))
}
// UpdateNode inserts - potentially overwriting - a node into the peer database.
diff --git a/p2p/enode/urlv4.go b/p2p/enode/urlv4.go
index ad3b8d26f1b2..cba5a78646e5 100644
--- a/p2p/enode/urlv4.go
+++ b/p2p/enode/urlv4.go
@@ -181,7 +181,7 @@ func (n *Node) URLv4() string {
nodeid = fmt.Sprintf("%s.%x", scheme, n.id[:])
}
u := url.URL{Scheme: "enode"}
- if n.Incomplete() {
+ if !n.ip.IsValid() {
u.Host = nodeid
} else {
addr := net.TCPAddr{IP: n.IP(), Port: n.TCP()}
diff --git a/p2p/enr/entries.go b/p2p/enr/entries.go
index 3c1c64a53286..34df83cd66d9 100644
--- a/p2p/enr/entries.go
+++ b/p2p/enr/entries.go
@@ -17,9 +17,11 @@
package enr
import (
+ "errors"
"fmt"
"io"
"net"
+ "net/netip"
"github.com/XinFinOrg/XDPoSChain/rlp"
)
@@ -166,6 +168,60 @@ func (v *IPv6) DecodeRLP(s *rlp.Stream) error {
return nil
}
+// IPv4Addr is the "ip" key, which holds the IP address of the node.
+type IPv4Addr netip.Addr
+
+func (v IPv4Addr) ENRKey() string { return "ip" }
+
+// EncodeRLP implements rlp.Encoder.
+func (v IPv4Addr) EncodeRLP(w io.Writer) error {
+ addr := netip.Addr(v)
+ if !addr.Is4() {
+ return errors.New("address is not IPv4")
+ }
+ enc := rlp.NewEncoderBuffer(w)
+ bytes := addr.As4()
+ enc.WriteBytes(bytes[:])
+ return enc.Flush()
+}
+
+// DecodeRLP implements rlp.Decoder.
+func (v *IPv4Addr) DecodeRLP(s *rlp.Stream) error {
+ var bytes [4]byte
+ if err := s.ReadBytes(bytes[:]); err != nil {
+ return err
+ }
+ *v = IPv4Addr(netip.AddrFrom4(bytes))
+ return nil
+}
+
+// IPv6Addr is the "ip6" key, which holds the IP address of the node.
+type IPv6Addr netip.Addr
+
+func (v IPv6Addr) ENRKey() string { return "ip6" }
+
+// EncodeRLP implements rlp.Encoder.
+func (v IPv6Addr) EncodeRLP(w io.Writer) error {
+ addr := netip.Addr(v)
+ if !addr.Is6() {
+ return errors.New("address is not IPv6")
+ }
+ enc := rlp.NewEncoderBuffer(w)
+ bytes := addr.As16()
+ enc.WriteBytes(bytes[:])
+ return enc.Flush()
+}
+
+// DecodeRLP implements rlp.Decoder.
+func (v *IPv6Addr) DecodeRLP(s *rlp.Stream) error {
+ var bytes [16]byte
+ if err := s.ReadBytes(bytes[:]); err != nil {
+ return err
+ }
+ *v = IPv6Addr(netip.AddrFrom16(bytes))
+ return nil
+}
+
// KeyError is an error related to a key.
type KeyError struct {
Key string
From b9d8e1f289264a8de74c5bfe3be3ce149969e0b0 Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 09:28:23 +0800
Subject: [PATCH 02/14] refactor(cmd/devp2p): improve enrdump command
---
cmd/devp2p/enrcmd.go | 29 +++++++++++++++++++----------
1 file changed, 19 insertions(+), 10 deletions(-)
diff --git a/cmd/devp2p/enrcmd.go b/cmd/devp2p/enrcmd.go
index e56506c61def..3550d54773b1 100644
--- a/cmd/devp2p/enrcmd.go
+++ b/cmd/devp2p/enrcmd.go
@@ -20,6 +20,7 @@ import (
"bytes"
"encoding/base64"
"encoding/hex"
+ "errors"
"fmt"
"io"
"net"
@@ -48,7 +49,7 @@ func enrdump(ctx *cli.Context) error {
var source string
if file := ctx.String(fileFlag.Name); file != "" {
if ctx.NArg() != 0 {
- return fmt.Errorf("can't dump record from command-line argument in -file mode")
+ return errors.New("can't dump record from command-line argument in -file mode")
}
var b []byte
var err error
@@ -64,29 +65,37 @@ func enrdump(ctx *cli.Context) error {
} else if ctx.NArg() == 1 {
source = ctx.Args().First()
} else {
- return fmt.Errorf("need record as argument")
+ return errors.New("need record as argument")
}
r, err := parseRecord(source)
if err != nil {
return fmt.Errorf("INVALID: %v", err)
}
- fmt.Print(dumpRecord(r))
+ dumpRecord(os.Stdout, r)
return nil
}
// dumpRecord creates a human-readable description of the given node record.
-func dumpRecord(r *enr.Record) string {
- out := new(bytes.Buffer)
- if n, err := enode.New(enode.ValidSchemes, r); err != nil {
+func dumpRecord(out io.Writer, r *enr.Record) {
+ n, err := enode.New(enode.ValidSchemes, r)
+ if err != nil {
fmt.Fprintf(out, "INVALID: %v\n", err)
} else {
fmt.Fprintf(out, "Node ID: %v\n", n.ID())
+ dumpNodeURL(out, n)
}
kv := r.AppendElements(nil)[1:]
fmt.Fprintf(out, "Record has sequence number %d and %d key/value pairs.\n", r.Seq(), len(kv)/2)
fmt.Fprint(out, dumpRecordKV(kv, 2))
- return out.String()
+}
+
+func dumpNodeURL(out io.Writer, n *enode.Node) {
+ var key enode.Secp256k1
+ if n.Load(&key) != nil {
+ return // no secp256k1 public key
+ }
+ fmt.Fprintf(out, "URLv4: %s\n", n.URLv4())
}
func dumpRecordKV(kv []interface{}, indent int) string {
@@ -174,8 +183,8 @@ var attrFormatters = map[string]func(rlp.RawValue) (string, bool){
}
func formatAttrRaw(v rlp.RawValue) (string, bool) {
- s := hex.EncodeToString(v)
- return s, true
+ content, _, err := rlp.SplitString(v)
+ return hex.EncodeToString(content), err == nil
}
func formatAttrString(v rlp.RawValue) (string, bool) {
@@ -185,7 +194,7 @@ func formatAttrString(v rlp.RawValue) (string, bool) {
func formatAttrIP(v rlp.RawValue) (string, bool) {
content, _, err := rlp.SplitString(v)
- if err != nil || len(content) != 4 && len(content) != 6 {
+ if err != nil || len(content) != 4 && len(content) != 16 {
return "", false
}
return net.IP(content).String(), true
From 74d7a456ae2fdfe682221014209ab966ad7a2416 Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 09:30:48 +0800
Subject: [PATCH 03/14] feat(cmd/devp2p): implement key command
---
cmd/devp2p/keycmd.go | 163 +++++++++++++++++++++++++++++++++++++++++++
cmd/devp2p/main.go | 1 +
2 files changed, 164 insertions(+)
create mode 100644 cmd/devp2p/keycmd.go
diff --git a/cmd/devp2p/keycmd.go b/cmd/devp2p/keycmd.go
new file mode 100644
index 000000000000..3ae5226cd07d
--- /dev/null
+++ b/cmd/devp2p/keycmd.go
@@ -0,0 +1,163 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see .
+
+package main
+
+import (
+ "errors"
+ "fmt"
+ "net"
+
+ "github.com/XinFinOrg/XDPoSChain/crypto"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enode"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enr"
+ "github.com/urfave/cli/v2"
+)
+
+var (
+ keyCommand = &cli.Command{
+ Name: "key",
+ Usage: "Operations on node keys",
+ Subcommands: []*cli.Command{
+ keyGenerateCommand,
+ keyToIDCommand,
+ keyToNodeCommand,
+ keyToRecordCommand,
+ },
+ }
+ keyGenerateCommand = &cli.Command{
+ Name: "generate",
+ Usage: "Generates node key files",
+ ArgsUsage: "keyfile",
+ Action: genkey,
+ }
+ keyToIDCommand = &cli.Command{
+ Name: "to-id",
+ Usage: "Creates a node ID from a node key file",
+ ArgsUsage: "keyfile",
+ Action: keyToID,
+ Flags: []cli.Flag{},
+ }
+ keyToNodeCommand = &cli.Command{
+ Name: "to-enode",
+ Usage: "Creates an enode URL from a node key file",
+ ArgsUsage: "keyfile",
+ Action: keyToURL,
+ Flags: []cli.Flag{hostFlag, tcpPortFlag, udpPortFlag},
+ }
+ keyToRecordCommand = &cli.Command{
+ Name: "to-enr",
+ Usage: "Creates an ENR from a node key file",
+ ArgsUsage: "keyfile",
+ Action: keyToRecord,
+ Flags: []cli.Flag{hostFlag, tcpPortFlag, udpPortFlag},
+ }
+)
+
+var (
+ hostFlag = &cli.StringFlag{
+ Name: "ip",
+ Usage: "IP address of the node",
+ Value: "127.0.0.1",
+ }
+ tcpPortFlag = &cli.IntFlag{
+ Name: "tcp",
+ Usage: "TCP port of the node",
+ Value: 30303,
+ }
+ udpPortFlag = &cli.IntFlag{
+ Name: "udp",
+ Usage: "UDP port of the node",
+ Value: 30303,
+ }
+)
+
+func genkey(ctx *cli.Context) error {
+ if ctx.NArg() != 1 {
+ return errors.New("need key file as argument")
+ }
+ file := ctx.Args().Get(0)
+
+ key, err := crypto.GenerateKey()
+ if err != nil {
+ return fmt.Errorf("could not generate key: %v", err)
+ }
+ return crypto.SaveECDSA(file, key)
+}
+
+func keyToID(ctx *cli.Context) error {
+ n, err := makeRecord(ctx)
+ if err != nil {
+ return err
+ }
+ fmt.Println(n.ID())
+ return nil
+}
+
+func keyToURL(ctx *cli.Context) error {
+ n, err := makeRecord(ctx)
+ if err != nil {
+ return err
+ }
+ fmt.Println(n.URLv4())
+ return nil
+}
+
+func keyToRecord(ctx *cli.Context) error {
+ n, err := makeRecord(ctx)
+ if err != nil {
+ return err
+ }
+ fmt.Println(n.String())
+ return nil
+}
+
+func makeRecord(ctx *cli.Context) (*enode.Node, error) {
+ if ctx.NArg() != 1 {
+ return nil, errors.New("need key file as argument")
+ }
+
+ var (
+ file = ctx.Args().Get(0)
+ host = ctx.String(hostFlag.Name)
+ tcp = ctx.Int(tcpPortFlag.Name)
+ udp = ctx.Int(udpPortFlag.Name)
+ )
+ key, err := crypto.LoadECDSA(file)
+ if err != nil {
+ return nil, err
+ }
+
+ var r enr.Record
+ if host != "" {
+ ip := net.ParseIP(host)
+ if ip == nil {
+ return nil, fmt.Errorf("invalid IP address %q", host)
+ }
+ r.Set(enr.IP(ip))
+ }
+ if udp != 0 {
+ r.Set(enr.UDP(udp))
+ }
+ if tcp != 0 {
+ r.Set(enr.TCP(tcp))
+ }
+
+ if err := enode.SignV4(&r, key); err != nil {
+ return nil, err
+ }
+ return enode.New(enode.ValidSchemes, &r)
+}
diff --git a/cmd/devp2p/main.go b/cmd/devp2p/main.go
index 0980a7637068..99589f89045e 100644
--- a/cmd/devp2p/main.go
+++ b/cmd/devp2p/main.go
@@ -46,6 +46,7 @@ func init() {
// Add subcommands.
app.Commands = []*cli.Command{
enrdumpCommand,
+ keyCommand,
discv4Command,
discv5Command,
dnsCommand,
From 3e7414a2b9524ca4d8410c759fd782dbaf42846d Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 10:12:11 +0800
Subject: [PATCH 04/14] feat(cmd/devp2p): upgrade crawl
---
cmd/devp2p/crawl.go | 101 ++++++++++++++++++++++++++++++++++------
cmd/devp2p/discv4cmd.go | 47 +++++++++++--------
cmd/devp2p/discv5cmd.go | 20 ++++----
3 files changed, 125 insertions(+), 43 deletions(-)
diff --git a/cmd/devp2p/crawl.go b/cmd/devp2p/crawl.go
index 98c310374c75..b6bc0c73106d 100644
--- a/cmd/devp2p/crawl.go
+++ b/cmd/devp2p/crawl.go
@@ -17,6 +17,9 @@
package main
import (
+ "errors"
+ "sync"
+ "sync/atomic"
"time"
"github.com/XinFinOrg/XDPoSChain/log"
@@ -34,13 +37,29 @@ type crawler struct {
// settings
revalidateInterval time.Duration
+ mu sync.RWMutex
}
+const (
+ nodeRemoved = iota
+ nodeSkipRecent
+ nodeSkipIncompat
+ nodeAdded
+ nodeUpdated
+)
+
type resolver interface {
RequestENR(*enode.Node) (*enode.Node, error)
}
-func newCrawler(input nodeSet, disc resolver, iters ...enode.Iterator) *crawler {
+func newCrawler(input nodeSet, bootnodes []*enode.Node, disc resolver, iters ...enode.Iterator) (*crawler, error) {
+ if len(input) == 0 {
+ input.add(bootnodes...)
+ }
+ if len(input) == 0 {
+ return nil, errors.New("no input nodes to start crawling")
+ }
+
c := &crawler{
input: input,
output: make(nodeSet, len(input)),
@@ -56,25 +75,62 @@ func newCrawler(input nodeSet, disc resolver, iters ...enode.Iterator) *crawler
for id, n := range input {
c.output[id] = n
}
- return c
+ return c, nil
}
-func (c *crawler) run(timeout time.Duration) nodeSet {
+func (c *crawler) run(timeout time.Duration, nthreads int) nodeSet {
var (
timeoutTimer = time.NewTimer(timeout)
timeoutCh <-chan time.Time
+ statusTicker = time.NewTicker(time.Second * 8)
doneCh = make(chan enode.Iterator, len(c.iters))
liveIters = len(c.iters)
)
+ if nthreads < 1 {
+ nthreads = 1
+ }
+ defer timeoutTimer.Stop()
+ defer statusTicker.Stop()
for _, it := range c.iters {
go c.runIterator(doneCh, it)
}
+ var (
+ added atomic.Uint64
+ updated atomic.Uint64
+ skipped atomic.Uint64
+ recent atomic.Uint64
+ removed atomic.Uint64
+ wg sync.WaitGroup
+ )
+ wg.Add(nthreads)
+ for i := 0; i < nthreads; i++ {
+ go func() {
+ defer wg.Done()
+ for {
+ select {
+ case n := <-c.ch:
+ switch c.updateNode(n) {
+ case nodeSkipIncompat:
+ skipped.Add(1)
+ case nodeSkipRecent:
+ recent.Add(1)
+ case nodeRemoved:
+ removed.Add(1)
+ case nodeAdded:
+ added.Add(1)
+ default:
+ updated.Add(1)
+ }
+ case <-c.closed:
+ return
+ }
+ }
+ }()
+ }
loop:
for {
select {
- case n := <-c.ch:
- c.updateNode(n)
case it := <-doneCh:
if it == c.inputIter {
// Enable timeout when we're done revalidating the input nodes.
@@ -88,6 +144,13 @@ loop:
}
case <-timeoutCh:
break loop
+ case <-statusTicker.C:
+ log.Info("Crawling in progress",
+ "added", added.Load(),
+ "updated", updated.Load(),
+ "removed", removed.Load(),
+ "ignored(recent)", recent.Load(),
+ "ignored(incompatible)", skipped.Load())
}
}
@@ -98,6 +161,7 @@ loop:
for ; liveIters > 0; liveIters-- {
<-doneCh
}
+ wg.Wait()
return c.output
}
@@ -112,22 +176,26 @@ func (c *crawler) runIterator(done chan<- enode.Iterator, it enode.Iterator) {
}
}
-func (c *crawler) updateNode(n *enode.Node) {
+// updateNode updates the info about the given node, and returns a status
+// about what changed
+func (c *crawler) updateNode(n *enode.Node) int {
+ c.mu.RLock()
node, ok := c.output[n.ID()]
+ c.mu.RUnlock()
// Skip validation of recently-seen nodes.
if ok && time.Since(node.LastCheck) < c.revalidateInterval {
- return
+ return nodeSkipRecent
}
// Request the node record.
- nn, err := c.disc.RequestENR(n)
+ status := nodeUpdated
node.LastCheck = truncNow()
- if err != nil {
+ if nn, err := c.disc.RequestENR(n); err != nil {
if node.Score == 0 {
// Node doesn't implement EIP-868.
log.Debug("Skipping node", "id", n.ID())
- return
+ return nodeSkipIncompat
}
node.Score /= 2
} else {
@@ -136,18 +204,21 @@ func (c *crawler) updateNode(n *enode.Node) {
node.Score++
if node.FirstResponse.IsZero() {
node.FirstResponse = node.LastCheck
+ status = nodeAdded
}
node.LastResponse = node.LastCheck
}
-
// Store/update node in output set.
+ c.mu.Lock()
+ defer c.mu.Unlock()
if node.Score <= 0 {
- log.Info("Removing node", "id", n.ID())
+ log.Debug("Removing node", "id", n.ID())
delete(c.output, n.ID())
- } else {
- log.Info("Updating node", "id", n.ID(), "seq", n.Seq(), "score", node.Score)
- c.output[n.ID()] = node
+ return nodeRemoved
}
+ log.Debug("Updating node", "id", n.ID(), "seq", n.Seq(), "score", node.Score)
+ c.output[n.ID()] = node
+ return status
}
func truncNow() time.Time {
diff --git a/cmd/devp2p/discv4cmd.go b/cmd/devp2p/discv4cmd.go
index ffef2cb71286..86edb3a4baa1 100644
--- a/cmd/devp2p/discv4cmd.go
+++ b/cmd/devp2p/discv4cmd.go
@@ -60,7 +60,7 @@ var (
Usage: "Ping every enode listed in a file and report UDP reachability",
Action: discv4Check,
ArgsUsage: "",
- Flags: slices.Concat(discoveryNodeFlags, []cli.Flag{pingTimeoutFlag, checkParallelFlag, checkOutputFlag}),
+ Flags: slices.Concat(discoveryNodeFlags, []cli.Flag{pingTimeoutFlag, crawlParallelismFlag, checkOutputFlag}),
}
discv4RequestRecordCommand = &cli.Command{
Name: "requestenr",
@@ -113,16 +113,16 @@ var (
Usage: "Time limit for the crawl.",
Value: 30 * time.Minute,
}
+ crawlParallelismFlag = &cli.IntFlag{
+ Name: "parallel",
+ Usage: "How many parallel discoveries to attempt.",
+ Value: 16,
+ }
pingTimeoutFlag = &cli.DurationFlag{
Name: "ping-timeout",
Usage: "Total time to wait for a pong reply",
Value: 3 * time.Second,
}
- checkParallelFlag = &cli.IntFlag{
- Name: "parallel",
- Usage: "Number of concurrent ping checks",
- Value: 8,
- }
checkOutputFlag = &cli.StringFlag{
Name: "output",
Usage: "Write results to this file (stdout if unset)",
@@ -138,7 +138,7 @@ var discoveryNodeFlags = []cli.Flag{
func discv4Ping(ctx *cli.Context) error {
n := getNodeArg(ctx)
- disc := startV4(ctx)
+ disc, _ := startV4(ctx)
defer disc.Close()
start := time.Now()
@@ -165,7 +165,7 @@ func discv4Check(ctx *cli.Context) error {
if timeout <= 0 {
return errors.New("ping-timeout must be greater than 0")
}
- parallel := ctx.Int(checkParallelFlag.Name)
+ parallel := ctx.Int(crawlParallelismFlag.Name)
if parallel < 1 {
return errors.New("parallel must be at least 1")
}
@@ -201,7 +201,7 @@ func discv4Check(ctx *cli.Context) error {
discs := make([]*discover.UDPv4, parallel)
for i := 0; i < parallel; i++ {
- discs[i] = startV4(ctx)
+ discs[i], _ = startV4(ctx)
}
defer func() {
for _, disc := range discs {
@@ -273,7 +273,7 @@ func discv4Check(ctx *cli.Context) error {
func discv4RequestRecord(ctx *cli.Context) error {
n := getNodeArg(ctx)
- disc := startV4(ctx)
+ disc, _ := startV4(ctx)
defer disc.Close()
respN, err := disc.RequestENR(n)
@@ -286,7 +286,7 @@ func discv4RequestRecord(ctx *cli.Context) error {
func discv4Resolve(ctx *cli.Context) error {
n := getNodeArg(ctx)
- disc := startV4(ctx)
+ disc, _ := startV4(ctx)
defer disc.Close()
resolved := disc.Resolve(n)
@@ -318,12 +318,15 @@ func discv4ResolveJSON(ctx *cli.Context) error {
nodeargs = append(nodeargs, n)
}
- // Run the crawler.
- disc := startV4(ctx)
+ disc, config := startV4(ctx)
defer disc.Close()
- c := newCrawler(inputSet, disc, enode.IterNodes(nodeargs))
+
+ c, err := newCrawler(inputSet, config.Bootnodes, disc, enode.IterNodes(nodeargs))
+ if err != nil {
+ return err
+ }
c.revalidateInterval = 0
- output := c.run(0)
+ output := c.run(0, 1)
writeNodesJSON(nodesFile, output)
return nil
}
@@ -338,11 +341,15 @@ func discv4Crawl(ctx *cli.Context) error {
inputSet = loadNodesJSON(nodesFile)
}
- disc := startV4(ctx)
+ disc, config := startV4(ctx)
defer disc.Close()
- c := newCrawler(inputSet, disc, disc.RandomNodes())
+
+ c, err := newCrawler(inputSet, config.Bootnodes, disc, disc.RandomNodes())
+ if err != nil {
+ return err
+ }
c.revalidateInterval = 10 * time.Minute
- output := c.run(ctx.Duration(crawlTimeoutFlag.Name))
+ output := c.run(ctx.Duration(crawlTimeoutFlag.Name), ctx.Int(crawlParallelismFlag.Name))
writeNodesJSON(nodesFile, output)
return nil
}
@@ -414,14 +421,14 @@ func formatCheckLine(index int, n *enode.Node, status string, elapsed time.Durat
}
// startV4 starts an ephemeral discovery V4 node.
-func startV4(ctx *cli.Context) *discover.UDPv4 {
+func startV4(ctx *cli.Context) (*discover.UDPv4, discover.Config) {
ln, config := makeDiscoveryConfig(ctx)
socket := listen(ln, ctx.String(listenAddrFlag.Name))
disc, err := discover.ListenV4(socket, ln, config)
if err != nil {
exit(err)
}
- return disc
+ return disc, config
}
func makeDiscoveryConfig(ctx *cli.Context) (*enode.LocalNode, discover.Config) {
diff --git a/cmd/devp2p/discv5cmd.go b/cmd/devp2p/discv5cmd.go
index 05169a18534c..2720e7c5d434 100644
--- a/cmd/devp2p/discv5cmd.go
+++ b/cmd/devp2p/discv5cmd.go
@@ -68,7 +68,7 @@ var (
func discv5Ping(ctx *cli.Context) error {
n := getNodeArg(ctx)
- disc := startV5(ctx)
+ disc, _ := startV5(ctx)
defer disc.Close()
fmt.Println(disc.Ping(n))
@@ -77,7 +77,7 @@ func discv5Ping(ctx *cli.Context) error {
func discv5Resolve(ctx *cli.Context) error {
n := getNodeArg(ctx)
- disc := startV5(ctx)
+ disc, _ := startV5(ctx)
defer disc.Close()
fmt.Println(disc.Resolve(n))
@@ -94,17 +94,21 @@ func discv5Crawl(ctx *cli.Context) error {
inputSet = loadNodesJSON(nodesFile)
}
- disc := startV5(ctx)
+ disc, config := startV5(ctx)
defer disc.Close()
- c := newCrawler(inputSet, disc, disc.RandomNodes())
+
+ c, err := newCrawler(inputSet, config.Bootnodes, disc, disc.RandomNodes())
+ if err != nil {
+ return err
+ }
c.revalidateInterval = 10 * time.Minute
- output := c.run(ctx.Duration(crawlTimeoutFlag.Name))
+ output := c.run(ctx.Duration(crawlTimeoutFlag.Name), ctx.Int(crawlParallelismFlag.Name))
writeNodesJSON(nodesFile, output)
return nil
}
func discv5Listen(ctx *cli.Context) error {
- disc := startV5(ctx)
+ disc, _ := startV5(ctx)
defer disc.Close()
fmt.Println(disc.Self())
@@ -112,12 +116,12 @@ func discv5Listen(ctx *cli.Context) error {
}
// startV5 starts an ephemeral discovery v5 node.
-func startV5(ctx *cli.Context) *discover.UDPv5 {
+func startV5(ctx *cli.Context) (*discover.UDPv5, discover.Config) {
ln, config := makeDiscoveryConfig(ctx)
socket := listen(ln, ctx.String(listenAddrFlag.Name))
disc, err := discover.ListenV5(socket, ln, config)
if err != nil {
exit(err)
}
- return disc
+ return disc, config
}
From 043cd496c68fbf50b85ad09de55186fa41500580 Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 09:55:10 +0800
Subject: [PATCH 05/14] feat(cmd/devp2p): upgrade discv4 command
---
cmd/devp2p/discv4cmd.go | 459 ++++++++++++++++++++++++++--------------
cmd/devp2p/discv5cmd.go | 2 +-
2 files changed, 297 insertions(+), 164 deletions(-)
diff --git a/cmd/devp2p/discv4cmd.go b/cmd/devp2p/discv4cmd.go
index 86edb3a4baa1..8934c0cbd864 100644
--- a/cmd/devp2p/discv4cmd.go
+++ b/cmd/devp2p/discv4cmd.go
@@ -21,14 +21,18 @@ import (
"errors"
"fmt"
"net"
+ "net/http"
+ "net/rpc"
"os"
"slices"
+ "strconv"
"strings"
"sync"
"time"
"github.com/XinFinOrg/XDPoSChain/common"
"github.com/XinFinOrg/XDPoSChain/crypto"
+ "github.com/XinFinOrg/XDPoSChain/log"
"github.com/XinFinOrg/XDPoSChain/p2p/discover"
"github.com/XinFinOrg/XDPoSChain/p2p/enode"
"github.com/XinFinOrg/XDPoSChain/params"
@@ -46,6 +50,7 @@ var (
discv4ResolveCommand,
discv4ResolveJSONCommand,
discv4CrawlCommand,
+ discv4ListenCommand,
},
}
discv4PingCommand = &cli.Command{
@@ -83,11 +88,19 @@ var (
Flags: discoveryNodeFlags,
ArgsUsage: "",
}
+ discv4ListenCommand = &cli.Command{
+ Name: "listen",
+ Usage: "Runs a discovery node",
+ Action: discv4Listen,
+ Flags: slices.Concat(discoveryNodeFlags, []cli.Flag{
+ httpAddrFlag,
+ }),
+ }
discv4CrawlCommand = &cli.Command{
Name: "crawl",
Usage: "Updates a nodes.json file with random nodes found in the DHT",
Action: discv4Crawl,
- Flags: []cli.Flag{bootnodesFlag, crawlTimeoutFlag},
+ Flags: slices.Concat(discoveryNodeFlags, []cli.Flag{crawlTimeoutFlag, crawlParallelismFlag}),
}
)
@@ -108,6 +121,10 @@ var (
Name: "addr",
Usage: "Listening address",
}
+ extAddrFlag = &cli.StringFlag{
+ Name: "extaddr",
+ Usage: "UDP endpoint announced in ENR. You can provide a bare IP address or IP:port as the value of this flag. Provide a comma-separated pair to announce both an IPv4 and an IPv6 endpoint.",
+ }
crawlTimeoutFlag = &cli.DurationFlag{
Name: "timeout",
Usage: "Time limit for the crawl.",
@@ -118,6 +135,15 @@ var (
Usage: "How many parallel discoveries to attempt.",
Value: 16,
}
+ remoteEnodeFlag = &cli.StringFlag{
+ Name: "remote",
+ Usage: "Enode of the remote node under test",
+ EnvVars: []string{"REMOTE_ENODE"},
+ }
+ httpAddrFlag = &cli.StringFlag{
+ Name: "rpc",
+ Usage: "HTTP server listening address",
+ }
pingTimeoutFlag = &cli.DurationFlag{
Name: "ping-timeout",
Usage: "Total time to wait for a pong reply",
@@ -134,6 +160,7 @@ var discoveryNodeFlags = []cli.Flag{
nodekeyFlag,
nodedbFlag,
listenAddrFlag,
+ extAddrFlag,
}
func discv4Ping(ctx *cli.Context) error {
@@ -149,6 +176,274 @@ func discv4Ping(ctx *cli.Context) error {
return nil
}
+func discv4Listen(ctx *cli.Context) error {
+ disc, _ := startV4(ctx)
+ defer disc.Close()
+
+ fmt.Println(disc.Self())
+
+ httpAddr := ctx.String(httpAddrFlag.Name)
+ if httpAddr == "" {
+ // Non-HTTP mode.
+ select {}
+ }
+
+ api := &discv4API{disc}
+ log.Info("Starting RPC API server", "addr", httpAddr)
+ srv := rpc.NewServer()
+ srv.RegisterName("discv4", api)
+ http.DefaultServeMux.Handle("/", srv)
+ httpsrv := http.Server{Addr: httpAddr, Handler: http.DefaultServeMux}
+ return httpsrv.ListenAndServe()
+}
+
+func discv4RequestRecord(ctx *cli.Context) error {
+ n := getNodeArg(ctx)
+ disc, _ := startV4(ctx)
+ defer disc.Close()
+
+ respN, err := disc.RequestENR(n)
+ if err != nil {
+ return fmt.Errorf("can't retrieve record: %v", err)
+ }
+ fmt.Println(respN.String())
+ return nil
+}
+
+func discv4Resolve(ctx *cli.Context) error {
+ n := getNodeArg(ctx)
+ disc, _ := startV4(ctx)
+ defer disc.Close()
+
+ resolved := disc.Resolve(n)
+ if resolved == nil {
+ fmt.Println("unresolved")
+ return fmt.Errorf("could not resolve node %s", n.ID())
+ }
+ fmt.Println(resolved.String())
+ return nil
+}
+
+func discv4ResolveJSON(ctx *cli.Context) error {
+ if ctx.NArg() < 1 {
+ return errors.New("need nodes file as argument")
+ }
+ nodesFile := ctx.Args().Get(0)
+ inputSet := make(nodeSet)
+ if common.FileExist(nodesFile) {
+ inputSet = loadNodesJSON(nodesFile)
+ }
+
+ // Add extra nodes from command line arguments.
+ var nodeargs []*enode.Node
+ for i := 1; i < ctx.NArg(); i++ {
+ n, err := parseNode(ctx.Args().Get(i))
+ if err != nil {
+ exit(err)
+ }
+ nodeargs = append(nodeargs, n)
+ }
+
+ disc, config := startV4(ctx)
+ defer disc.Close()
+
+ c, err := newCrawler(inputSet, config.Bootnodes, disc, enode.IterNodes(nodeargs))
+ if err != nil {
+ return err
+ }
+ c.revalidateInterval = 0
+ output := c.run(0, 1)
+ writeNodesJSON(nodesFile, output)
+ return nil
+}
+
+func discv4Crawl(ctx *cli.Context) error {
+ if ctx.NArg() < 1 {
+ return errors.New("need nodes file as argument")
+ }
+ nodesFile := ctx.Args().First()
+ inputSet := make(nodeSet)
+ if common.FileExist(nodesFile) {
+ inputSet = loadNodesJSON(nodesFile)
+ }
+
+ disc, config := startV4(ctx)
+ defer disc.Close()
+
+ c, err := newCrawler(inputSet, config.Bootnodes, disc, disc.RandomNodes())
+ if err != nil {
+ return err
+ }
+ c.revalidateInterval = 10 * time.Minute
+ output := c.run(ctx.Duration(crawlTimeoutFlag.Name), ctx.Int(crawlParallelismFlag.Name))
+ writeNodesJSON(nodesFile, output)
+ return nil
+}
+
+// startV4 starts an ephemeral discovery V4 node.
+func startV4(ctx *cli.Context) (*discover.UDPv4, discover.Config) {
+ ln, config := makeDiscoveryConfig(ctx)
+ socket := listen(ctx, ln)
+ disc, err := discover.ListenV4(socket, ln, config)
+ if err != nil {
+ exit(err)
+ }
+ return disc, config
+}
+
+func makeDiscoveryConfig(ctx *cli.Context) (*enode.LocalNode, discover.Config) {
+ var cfg discover.Config
+
+ if ctx.IsSet(nodekeyFlag.Name) {
+ key, err := crypto.HexToECDSA(ctx.String(nodekeyFlag.Name))
+ if err != nil {
+ exit(fmt.Errorf("-%s: %v", nodekeyFlag.Name, err))
+ }
+ cfg.PrivateKey = key
+ } else {
+ var err error
+ cfg.PrivateKey, err = crypto.GenerateKey()
+ if err != nil {
+ exit(err)
+ }
+ }
+
+ if commandHasFlag(ctx, bootnodesFlag) {
+ bn, err := parseBootnodes(ctx)
+ if err != nil {
+ exit(err)
+ }
+ cfg.Bootnodes = bn
+ }
+
+ dbpath := ctx.String(nodedbFlag.Name)
+ db, err := enode.OpenDB(dbpath)
+ if err != nil {
+ exit(err)
+ }
+ ln := enode.NewLocalNode(db, cfg.PrivateKey)
+ return ln, cfg
+}
+
+func parseExtAddr(spec string) (ip net.IP, port int, ok bool) {
+ ip = net.ParseIP(spec)
+ if ip != nil {
+ return ip, 0, true
+ }
+ host, portstr, err := net.SplitHostPort(spec)
+ if err != nil {
+ return nil, 0, false
+ }
+ ip = net.ParseIP(host)
+ if ip == nil {
+ return nil, 0, false
+ }
+ port, err = strconv.Atoi(portstr)
+ if err != nil {
+ return nil, 0, false
+ }
+ return ip, port, true
+}
+
+func listen(ctx *cli.Context, ln *enode.LocalNode) *net.UDPConn {
+ addr := ctx.String(listenAddrFlag.Name)
+ extAddr := ctx.String(extAddrFlag.Name)
+ var (
+ socket net.PacketConn
+ err error
+ )
+ if addr == "" {
+ // Dual-stack socket, falling back to IPv4-only where IPv6 is unavailable.
+ if socket, err = net.ListenPacket("udp", "[::]:0"); err != nil {
+ socket, err = net.ListenPacket("udp", "0.0.0.0:0")
+ }
+ } else {
+ socket, err = net.ListenPacket("udp", addr)
+ }
+ if err != nil {
+ exit(err)
+ }
+
+ // Configure the ENR endpoint from the listener address, but only without an
+ // explicit -extaddr: otherwise we'd announce a fallback IP for an address
+ // family the user didn't specify (e.g. loopback IPv4 on an IPv6-only node).
+ usocket := socket.(*net.UDPConn)
+ uaddr := socket.LocalAddr().(*net.UDPAddr)
+ if extAddr == "" {
+ if uaddr.IP.IsUnspecified() {
+ ln.SetFallbackIP(net.IP{127, 0, 0, 1})
+ } else {
+ ln.SetFallbackIP(uaddr.IP)
+ }
+ }
+ ln.SetFallbackUDP(uaddr.Port)
+
+ // Override with explicit -extaddr address(es). A static IP is set per family,
+ // and all specs share one UDP port because the node has a single socket.
+ if extAddr != "" {
+ var extPort int
+ for spec := range strings.SplitSeq(extAddr, ",") {
+ spec = strings.TrimSpace(spec)
+ if spec == "" {
+ continue
+ }
+ ip, port, ok := parseExtAddr(spec)
+ if !ok {
+ exit(fmt.Errorf("-%s: invalid external address %q", extAddrFlag.Name, spec))
+ }
+ ln.SetStaticIP(ip)
+ if port != 0 {
+ if extPort != 0 && port != extPort {
+ exit(fmt.Errorf("-%s: all addresses must announce the same UDP port, got %d and %d", extAddrFlag.Name, extPort, port))
+ }
+ extPort = port
+ }
+ }
+ if extPort != 0 {
+ ln.SetFallbackUDP(extPort)
+ }
+ }
+
+ return usocket
+}
+
+func parseBootnodes(ctx *cli.Context) ([]*enode.Node, error) {
+ s := params.MainnetBootnodes
+ if ctx.IsSet(bootnodesFlag.Name) {
+ input := ctx.String(bootnodesFlag.Name)
+ if input == "" {
+ return nil, nil
+ }
+ s = strings.Split(input, ",")
+ }
+ nodes := make([]*enode.Node, len(s))
+ var err error
+ for i, record := range s {
+ nodes[i], err = parseNode(record)
+ if err != nil {
+ return nil, fmt.Errorf("invalid bootstrap node: %v", err)
+ }
+ }
+ return nodes, nil
+}
+
+type discv4API struct {
+ host *discover.UDPv4
+}
+
+func (api *discv4API) LookupRandom(n int) (ns []*enode.Node) {
+ it := api.host.RandomNodes()
+ defer it.Close()
+ for len(ns) < n && it.Next() {
+ ns = append(ns, it.Node())
+ }
+ return ns
+}
+
+func (api *discv4API) Self() *enode.Node {
+ return api.host.Self()
+}
+
func discv4Check(ctx *cli.Context) error {
if ctx.NArg() < 1 {
return errors.New("need nodes file as argument")
@@ -271,89 +566,6 @@ func discv4Check(ctx *cli.Context) error {
return nil
}
-func discv4RequestRecord(ctx *cli.Context) error {
- n := getNodeArg(ctx)
- disc, _ := startV4(ctx)
- defer disc.Close()
-
- respN, err := disc.RequestENR(n)
- if err != nil {
- return fmt.Errorf("can't retrieve record: %v", err)
- }
- fmt.Println(respN.String())
- return nil
-}
-
-func discv4Resolve(ctx *cli.Context) error {
- n := getNodeArg(ctx)
- disc, _ := startV4(ctx)
- defer disc.Close()
-
- resolved := disc.Resolve(n)
- if resolved == nil {
- fmt.Println("unresolved")
- return fmt.Errorf("could not resolve node %s", n.ID())
- }
- fmt.Println(resolved.String())
- return nil
-}
-
-func discv4ResolveJSON(ctx *cli.Context) error {
- if ctx.NArg() < 1 {
- return fmt.Errorf("need nodes file as argument")
- }
- nodesFile := ctx.Args().Get(0)
- inputSet := make(nodeSet)
- if common.FileExist(nodesFile) {
- inputSet = loadNodesJSON(nodesFile)
- }
-
- // Add extra nodes from command line arguments.
- var nodeargs []*enode.Node
- for i := 1; i < ctx.NArg(); i++ {
- n, err := parseNode(ctx.Args().Get(i))
- if err != nil {
- exit(err)
- }
- nodeargs = append(nodeargs, n)
- }
-
- disc, config := startV4(ctx)
- defer disc.Close()
-
- c, err := newCrawler(inputSet, config.Bootnodes, disc, enode.IterNodes(nodeargs))
- if err != nil {
- return err
- }
- c.revalidateInterval = 0
- output := c.run(0, 1)
- writeNodesJSON(nodesFile, output)
- return nil
-}
-
-func discv4Crawl(ctx *cli.Context) error {
- if ctx.NArg() < 1 {
- return fmt.Errorf("need nodes file as argument")
- }
- nodesFile := ctx.Args().First()
- var inputSet nodeSet
- if common.FileExist(nodesFile) {
- inputSet = loadNodesJSON(nodesFile)
- }
-
- disc, config := startV4(ctx)
- defer disc.Close()
-
- c, err := newCrawler(inputSet, config.Bootnodes, disc, disc.RandomNodes())
- if err != nil {
- return err
- }
- c.revalidateInterval = 10 * time.Minute
- output := c.run(ctx.Duration(crawlTimeoutFlag.Name), ctx.Int(crawlParallelismFlag.Name))
- writeNodesJSON(nodesFile, output)
- return nil
-}
-
func loadNodeFile(path string) ([]*enode.Node, error) {
f, err := os.Open(path)
if err != nil {
@@ -419,82 +631,3 @@ func formatCheckLine(index int, n *enode.Node, status string, elapsed time.Durat
}
return fmt.Sprintf("%02d|%s|%s|%s|%s", index, nodeEndpoint(n), status, elapsed.Round(time.Millisecond), msg)
}
-
-// startV4 starts an ephemeral discovery V4 node.
-func startV4(ctx *cli.Context) (*discover.UDPv4, discover.Config) {
- ln, config := makeDiscoveryConfig(ctx)
- socket := listen(ln, ctx.String(listenAddrFlag.Name))
- disc, err := discover.ListenV4(socket, ln, config)
- if err != nil {
- exit(err)
- }
- return disc, config
-}
-
-func makeDiscoveryConfig(ctx *cli.Context) (*enode.LocalNode, discover.Config) {
- var cfg discover.Config
-
- if ctx.IsSet(nodekeyFlag.Name) {
- key, err := crypto.HexToECDSA(ctx.String(nodekeyFlag.Name))
- if err != nil {
- exit(fmt.Errorf("-%s: %v", nodekeyFlag.Name, err))
- }
- cfg.PrivateKey = key
- } else {
- cfg.PrivateKey, _ = crypto.GenerateKey()
- }
-
- if commandHasFlag(ctx, bootnodesFlag) {
- bn, err := parseBootnodes(ctx)
- if err != nil {
- exit(err)
- }
- cfg.Bootnodes = bn
- }
-
- dbpath := ctx.String(nodedbFlag.Name)
- db, err := enode.OpenDB(dbpath)
- if err != nil {
- exit(err)
- }
- ln := enode.NewLocalNode(db, cfg.PrivateKey)
- return ln, cfg
-}
-
-func listen(ln *enode.LocalNode, addr string) *net.UDPConn {
- if addr == "" {
- addr = "0.0.0.0:0"
- }
- udpAddr, err := net.ResolveUDPAddr("udp4", addr)
- if err != nil {
- exit(err)
- }
- socket, err := net.ListenUDP("udp4", udpAddr)
- if err != nil {
- exit(err)
- }
- uaddr := socket.LocalAddr().(*net.UDPAddr)
- ln.SetFallbackIP(net.IP{127, 0, 0, 1})
- ln.SetFallbackUDP(uaddr.Port)
- return socket
-}
-
-func parseBootnodes(ctx *cli.Context) ([]*enode.Node, error) {
- s := params.MainnetBootnodes
- if ctx.IsSet(bootnodesFlag.Name) {
- input := ctx.String(bootnodesFlag.Name)
- if input == "" {
- return nil, nil
- }
- s = strings.Split(input, ",")
- }
- nodes := make([]*enode.Node, len(s))
- var err error
- for i, record := range s {
- nodes[i], err = parseNode(record)
- if err != nil {
- return nil, fmt.Errorf("invalid bootstrap node: %v", err)
- }
- }
- return nodes, nil
-}
diff --git a/cmd/devp2p/discv5cmd.go b/cmd/devp2p/discv5cmd.go
index 2720e7c5d434..2de8dff3e43c 100644
--- a/cmd/devp2p/discv5cmd.go
+++ b/cmd/devp2p/discv5cmd.go
@@ -118,7 +118,7 @@ func discv5Listen(ctx *cli.Context) error {
// startV5 starts an ephemeral discovery v5 node.
func startV5(ctx *cli.Context) (*discover.UDPv5, discover.Config) {
ln, config := makeDiscoveryConfig(ctx)
- socket := listen(ln, ctx.String(listenAddrFlag.Name))
+ socket := listen(ctx, ln)
disc, err := discover.ListenV5(socket, ln, config)
if err != nil {
exit(err)
From 663408251982fb2ffb577507306493e410ddac88 Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 11:03:13 +0800
Subject: [PATCH 06/14] feat(cmd/devp2p): upgrade discv5 command
---
cmd/devp2p/discv5cmd.go | 26 ++++++++++++++------------
1 file changed, 14 insertions(+), 12 deletions(-)
diff --git a/cmd/devp2p/discv5cmd.go b/cmd/devp2p/discv5cmd.go
index 2de8dff3e43c..4293eda3aea7 100644
--- a/cmd/devp2p/discv5cmd.go
+++ b/cmd/devp2p/discv5cmd.go
@@ -1,4 +1,4 @@
-// Copyright 2019 The go-ethereum Authors
+// Copyright 2020 The go-ethereum Authors
// This file is part of go-ethereum.
//
// go-ethereum is free software: you can redistribute it and/or modify
@@ -17,7 +17,9 @@
package main
import (
+ "errors"
"fmt"
+ "slices"
"time"
"github.com/XinFinOrg/XDPoSChain/common"
@@ -40,29 +42,28 @@ var (
Name: "ping",
Usage: "Sends ping to a node",
Action: discv5Ping,
+ Flags: discoveryNodeFlags,
}
discv5ResolveCommand = &cli.Command{
Name: "resolve",
Usage: "Finds a node in the DHT",
Action: discv5Resolve,
- Flags: []cli.Flag{bootnodesFlag},
+ Flags: discoveryNodeFlags,
}
discv5CrawlCommand = &cli.Command{
Name: "crawl",
Usage: "Updates a nodes.json file with random nodes found in the DHT",
Action: discv5Crawl,
- Flags: []cli.Flag{bootnodesFlag, crawlTimeoutFlag},
+ Flags: slices.Concat(discoveryNodeFlags, []cli.Flag{
+ crawlTimeoutFlag,
+ crawlParallelismFlag,
+ }),
}
discv5ListenCommand = &cli.Command{
Name: "listen",
Usage: "Runs a node",
Action: discv5Listen,
- Flags: []cli.Flag{
- bootnodesFlag,
- nodekeyFlag,
- nodedbFlag,
- listenAddrFlag,
- },
+ Flags: discoveryNodeFlags,
}
)
@@ -71,7 +72,8 @@ func discv5Ping(ctx *cli.Context) error {
disc, _ := startV5(ctx)
defer disc.Close()
- fmt.Println(disc.Ping(n))
+ err := disc.Ping(n)
+ fmt.Println(err)
return nil
}
@@ -86,10 +88,10 @@ func discv5Resolve(ctx *cli.Context) error {
func discv5Crawl(ctx *cli.Context) error {
if ctx.NArg() < 1 {
- return fmt.Errorf("need nodes file as argument")
+ return errors.New("need nodes file as argument")
}
nodesFile := ctx.Args().First()
- var inputSet nodeSet
+ inputSet := make(nodeSet)
if common.FileExist(nodesFile) {
inputSet = loadNodesJSON(nodesFile)
}
From 8defbe2ac34e368175106a42127dd2f4d6090068 Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 11:26:43 +0800
Subject: [PATCH 07/14] feat(cmd/devp2p): implement DNS TXT records to Amazon
Route53
---
cmd/devp2p/dns_route53.go | 426 +++++++++++++++++++++++++++++++++
cmd/devp2p/dns_route53_test.go | 192 +++++++++++++++
cmd/devp2p/dnscmd.go | 48 ++++
go.mod | 15 ++
go.sum | 30 +++
5 files changed, 711 insertions(+)
create mode 100644 cmd/devp2p/dns_route53.go
create mode 100644 cmd/devp2p/dns_route53_test.go
diff --git a/cmd/devp2p/dns_route53.go b/cmd/devp2p/dns_route53.go
new file mode 100644
index 000000000000..81e8c0368c0a
--- /dev/null
+++ b/cmd/devp2p/dns_route53.go
@@ -0,0 +1,426 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see .
+
+package main
+
+import (
+ "cmp"
+ "context"
+ "errors"
+ "fmt"
+ "slices"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/XinFinOrg/XDPoSChain/log"
+ "github.com/XinFinOrg/XDPoSChain/p2p/dnsdisc"
+ "github.com/aws/aws-sdk-go-v2/aws"
+ "github.com/aws/aws-sdk-go-v2/config"
+ "github.com/aws/aws-sdk-go-v2/credentials"
+ "github.com/aws/aws-sdk-go-v2/service/route53"
+ "github.com/aws/aws-sdk-go-v2/service/route53/types"
+ "github.com/urfave/cli/v2"
+)
+
+const (
+ // Route53 limits change sets to 32k of 'RDATA size'. Change sets are also limited to
+ // 1000 items. UPSERTs count double.
+ // https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/DNSLimitations.html#limits-api-requests-changeresourcerecordsets
+ route53ChangeSizeLimit = 32000
+ route53ChangeCountLimit = 1000
+ maxRetryLimit = 60
+)
+
+var (
+ route53AccessKeyFlag = &cli.StringFlag{
+ Name: "access-key-id",
+ Usage: "AWS Access Key ID",
+ EnvVars: []string{"AWS_ACCESS_KEY_ID"},
+ }
+ route53AccessSecretFlag = &cli.StringFlag{
+ Name: "access-key-secret",
+ Usage: "AWS Access Key Secret",
+ EnvVars: []string{"AWS_SECRET_ACCESS_KEY"},
+ }
+ route53ZoneIDFlag = &cli.StringFlag{
+ Name: "zone-id",
+ Usage: "Route53 Zone ID",
+ }
+ route53RegionFlag = &cli.StringFlag{
+ Name: "aws-region",
+ Usage: "AWS Region",
+ Value: "eu-central-1",
+ }
+)
+
+type route53Client struct {
+ api *route53.Client
+ zoneID string
+}
+
+type recordSet struct {
+ values []string
+ ttl int64
+}
+
+// newRoute53Client sets up a Route53 API client from command line flags.
+func newRoute53Client(ctx *cli.Context) *route53Client {
+ akey := ctx.String(route53AccessKeyFlag.Name)
+ asec := ctx.String(route53AccessSecretFlag.Name)
+ if akey == "" || asec == "" {
+ exit(errors.New("need Route53 Access Key ID and secret to proceed"))
+ }
+ creds := aws.NewCredentialsCache(credentials.NewStaticCredentialsProvider(akey, asec, ""))
+ cfg, err := config.LoadDefaultConfig(context.Background(), config.WithCredentialsProvider(creds))
+ if err != nil {
+ exit(fmt.Errorf("can't initialize AWS configuration: %v", err))
+ }
+ cfg.Region = ctx.String(route53RegionFlag.Name)
+ return &route53Client{
+ api: route53.NewFromConfig(cfg),
+ zoneID: ctx.String(route53ZoneIDFlag.Name),
+ }
+}
+
+// deploy uploads the given tree to Route53.
+func (c *route53Client) deploy(name string, t *dnsdisc.Tree) error {
+ if err := c.checkZone(name); err != nil {
+ return err
+ }
+
+ // Compute DNS changes.
+ existing, err := c.collectRecords(name)
+ if err != nil {
+ return err
+ }
+ log.Info(fmt.Sprintf("Found %d TXT records", len(existing)))
+ records := t.ToTXT(name)
+ changes := c.computeChanges(name, records, existing)
+
+ // Submit to API.
+ comment := fmt.Sprintf("enrtree update of %s at seq %d", name, t.Seq())
+ return c.submitChanges(changes, comment)
+}
+
+// deleteDomain removes all TXT records of the given domain.
+func (c *route53Client) deleteDomain(name string) error {
+ if err := c.checkZone(name); err != nil {
+ return err
+ }
+
+ // Compute DNS changes.
+ existing, err := c.collectRecords(name)
+ if err != nil {
+ return err
+ }
+ log.Info(fmt.Sprintf("Found %d TXT records", len(existing)))
+ changes := makeDeletionChanges(existing, nil)
+
+ // Submit to API.
+ comment := "enrtree delete of " + name
+ return c.submitChanges(changes, comment)
+}
+
+// submitChanges submits the given DNS changes to Route53.
+func (c *route53Client) submitChanges(changes []types.Change, comment string) error {
+ if len(changes) == 0 {
+ log.Info("No DNS changes needed")
+ return nil
+ }
+
+ var err error
+ batches := splitChanges(changes, route53ChangeSizeLimit, route53ChangeCountLimit)
+ changesToCheck := make([]*route53.ChangeResourceRecordSetsOutput, len(batches))
+ for i, changes := range batches {
+ log.Info(fmt.Sprintf("Submitting %d changes to Route53", len(changes)))
+ batch := &types.ChangeBatch{
+ Changes: changes,
+ Comment: aws.String(fmt.Sprintf("%s (%d/%d)", comment, i+1, len(batches))),
+ }
+ req := &route53.ChangeResourceRecordSetsInput{HostedZoneId: &c.zoneID, ChangeBatch: batch}
+ changesToCheck[i], err = c.api.ChangeResourceRecordSets(context.TODO(), req)
+ if err != nil {
+ return err
+ }
+ }
+
+ // Wait for all change batches to propagate.
+ for _, change := range changesToCheck {
+ log.Info(fmt.Sprintf("Waiting for change request %s", *change.ChangeInfo.Id))
+ wreq := &route53.GetChangeInput{Id: change.ChangeInfo.Id}
+ var count int
+ for {
+ wresp, err := c.api.GetChange(context.TODO(), wreq)
+ if err != nil {
+ return err
+ }
+
+ count++
+
+ if wresp.ChangeInfo.Status == types.ChangeStatusInsync || count >= maxRetryLimit {
+ break
+ }
+
+ time.Sleep(30 * time.Second)
+ }
+ }
+ return nil
+}
+
+// checkZone verifies zone information for the given domain.
+func (c *route53Client) checkZone(name string) (err error) {
+ if c.zoneID == "" {
+ c.zoneID, err = c.findZoneID(name)
+ }
+ return err
+}
+
+// findZoneID searches for the Zone ID containing the given domain.
+func (c *route53Client) findZoneID(name string) (string, error) {
+ log.Info(fmt.Sprintf("Finding Route53 Zone ID for %s", name))
+ var req route53.ListHostedZonesByNameInput
+ for {
+ resp, err := c.api.ListHostedZonesByName(context.TODO(), &req)
+ if err != nil {
+ return "", err
+ }
+ for _, zone := range resp.HostedZones {
+ if isSubdomain(name, *zone.Name) {
+ return *zone.Id, nil
+ }
+ }
+ if !resp.IsTruncated {
+ break
+ }
+ req.DNSName = resp.NextDNSName
+ req.HostedZoneId = resp.NextHostedZoneId
+ }
+ return "", errors.New("can't find zone ID for " + name)
+}
+
+// computeChanges creates DNS changes for the given set of DNS discovery records.
+// The 'existing' arg is the set of records that already exist on Route53.
+func (c *route53Client) computeChanges(name string, records map[string]string, existing map[string]recordSet) []types.Change {
+ // Convert all names to lowercase.
+ lrecords := make(map[string]string, len(records))
+ for name, r := range records {
+ lrecords[strings.ToLower(name)] = r
+ }
+ records = lrecords
+
+ var (
+ changes []types.Change
+ inserts int
+ upserts int
+ skips int
+ )
+
+ for path, newValue := range records {
+ prevRecords, exists := existing[path]
+ prevValue := strings.Join(prevRecords.values, "")
+
+ // prevValue contains quoted strings, encode newValue to compare.
+ newValue = splitTXT(newValue)
+
+ // Assign TTL.
+ ttl := int64(rootTTL)
+ if path != name {
+ ttl = int64(treeNodeTTL)
+ }
+
+ if !exists {
+ // Entry is unknown, push a new one
+ log.Debug(fmt.Sprintf("Creating %s = %s", path, newValue))
+ changes = append(changes, newTXTChange("CREATE", path, ttl, newValue))
+ inserts++
+ } else if prevValue != newValue || prevRecords.ttl != ttl {
+ // Entry already exists, only change its content.
+ log.Info(fmt.Sprintf("Updating %s from %s to %s", path, prevValue, newValue))
+ changes = append(changes, newTXTChange("UPSERT", path, ttl, newValue))
+ upserts++
+ } else {
+ log.Debug(fmt.Sprintf("Skipping %s = %s", path, newValue))
+ skips++
+ }
+ }
+
+ // Iterate over the old records and delete anything stale.
+ deletions := makeDeletionChanges(existing, records)
+ changes = append(changes, deletions...)
+
+ log.Info("Computed DNS changes",
+ "changes", len(changes),
+ "inserts", inserts,
+ "skips", skips,
+ "deleted", len(deletions),
+ "upserts", upserts)
+ // Ensure changes are in the correct order.
+ sortChanges(changes)
+ return changes
+}
+
+// makeDeletionChanges creates record changes which delete all records not contained in 'keep'.
+func makeDeletionChanges(records map[string]recordSet, keep map[string]string) []types.Change {
+ var changes []types.Change
+ for path, set := range records {
+ if _, ok := keep[path]; ok {
+ continue
+ }
+ log.Debug(fmt.Sprintf("Deleting %s = %s", path, strings.Join(set.values, "")))
+ changes = append(changes, newTXTChange("DELETE", path, set.ttl, set.values...))
+ }
+ return changes
+}
+
+// sortChanges ensures DNS changes are in leaf-added -> root-changed -> leaf-deleted order.
+func sortChanges(changes []types.Change) {
+ score := map[string]int{"CREATE": 1, "UPSERT": 2, "DELETE": 3}
+ slices.SortFunc(changes, func(a, b types.Change) int {
+ if a.Action == b.Action {
+ return strings.Compare(*a.ResourceRecordSet.Name, *b.ResourceRecordSet.Name)
+ }
+ return cmp.Compare(score[string(a.Action)], score[string(b.Action)])
+ })
+}
+
+// splitChanges splits up DNS changes such that each change batch
+// is smaller than the given RDATA limit.
+func splitChanges(changes []types.Change, sizeLimit, countLimit int) [][]types.Change {
+ var (
+ batches [][]types.Change
+ batchSize int
+ batchCount int
+ )
+ for _, ch := range changes {
+ // Start new batch if this change pushes the current one over the limit.
+ count := changeCount(ch)
+ size := changeSize(ch) * count
+ overSize := batchSize+size > sizeLimit
+ overCount := batchCount+count > countLimit
+ if len(batches) == 0 || overSize || overCount {
+ batches = append(batches, nil)
+ batchSize = 0
+ batchCount = 0
+ }
+ batches[len(batches)-1] = append(batches[len(batches)-1], ch)
+ batchSize += size
+ batchCount += count
+ }
+ return batches
+}
+
+// changeSize returns the RDATA size of a DNS change.
+func changeSize(ch types.Change) int {
+ size := 0
+ for _, rr := range ch.ResourceRecordSet.ResourceRecords {
+ if rr.Value != nil {
+ size += len(*rr.Value)
+ }
+ }
+ return size
+}
+
+func changeCount(ch types.Change) int {
+ if ch.Action == types.ChangeActionUpsert {
+ return 2
+ }
+ return 1
+}
+
+// collectRecords collects all TXT records below the given name.
+func (c *route53Client) collectRecords(name string) (map[string]recordSet, error) {
+ var req route53.ListResourceRecordSetsInput
+ req.HostedZoneId = &c.zoneID
+ existing := make(map[string]recordSet)
+ log.Info("Loading existing TXT records", "name", name, "zone", c.zoneID)
+ for page := 0; ; page++ {
+ log.Debug("Loading existing TXT records", "name", name, "zone", c.zoneID, "page", page)
+ resp, err := c.api.ListResourceRecordSets(context.TODO(), &req)
+ if err != nil {
+ return existing, err
+ }
+ for _, set := range resp.ResourceRecordSets {
+ if !isSubdomain(*set.Name, name) || set.Type != types.RRTypeTxt {
+ continue
+ }
+ s := recordSet{ttl: *set.TTL}
+ for _, rec := range set.ResourceRecords {
+ s.values = append(s.values, *rec.Value)
+ }
+ name := strings.TrimSuffix(*set.Name, ".")
+ existing[name] = s
+ }
+
+ if !resp.IsTruncated {
+ break
+ }
+ // Set the cursor to the next batch. From the AWS docs:
+ //
+ // To display the next page of results, get the values of NextRecordName,
+ // NextRecordType, and NextRecordIdentifier (if any) from the response. Then submit
+ // another ListResourceRecordSets request, and specify those values for
+ // StartRecordName, StartRecordType, and StartRecordIdentifier.
+ req.StartRecordIdentifier = resp.NextRecordIdentifier
+ req.StartRecordName = resp.NextRecordName
+ req.StartRecordType = resp.NextRecordType
+ }
+ log.Info("Loaded existing TXT records", "name", name, "zone", c.zoneID, "records", len(existing))
+ return existing, nil
+}
+
+// newTXTChange creates a change to a TXT record.
+func newTXTChange(action, name string, ttl int64, values ...string) types.Change {
+ r := types.ResourceRecordSet{
+ Type: types.RRTypeTxt,
+ Name: &name,
+ TTL: &ttl,
+ }
+ var rrs []types.ResourceRecord
+ for _, val := range values {
+ var rr types.ResourceRecord
+ rr.Value = aws.String(val)
+ rrs = append(rrs, rr)
+ }
+
+ r.ResourceRecords = rrs
+
+ return types.Change{
+ Action: types.ChangeAction(action),
+ ResourceRecordSet: &r,
+ }
+}
+
+// isSubdomain returns true if name is a subdomain of domain.
+func isSubdomain(name, domain string) bool {
+ domain = strings.TrimSuffix(domain, ".")
+ name = strings.TrimSuffix(name, ".")
+ return strings.HasSuffix("."+name, "."+domain)
+}
+
+// splitTXT splits value into a list of quoted 255-character strings.
+func splitTXT(value string) string {
+ var result strings.Builder
+ for len(value) > 0 {
+ rlen := len(value)
+ if rlen > 253 {
+ rlen = 253
+ }
+ result.WriteString(strconv.Quote(value[:rlen]))
+ value = value[rlen:]
+ }
+ return result.String()
+}
diff --git a/cmd/devp2p/dns_route53_test.go b/cmd/devp2p/dns_route53_test.go
new file mode 100644
index 000000000000..af39c70a3631
--- /dev/null
+++ b/cmd/devp2p/dns_route53_test.go
@@ -0,0 +1,192 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see .
+
+package main
+
+import (
+ "reflect"
+ "testing"
+
+ "github.com/aws/aws-sdk-go-v2/service/route53/types"
+)
+
+// This test checks that computeChanges/splitChanges create DNS changes in
+// leaf-added -> root-changed -> leaf-deleted order.
+func TestRoute53ChangeSort(t *testing.T) {
+ t.Parallel()
+ testTree0 := map[string]recordSet{
+ "2kfjogvxdqtxxugbh7gs7naaai.n": {ttl: 3333, values: []string{
+ `"enr:-HW4QO1ml1DdXLeZLsUxewnthhUy8eROqkDyoMTyavfks9JlYQIlMFEUoM78PovJDPQrAkrb3LRJ-""vtrymDguKCOIAWAgmlkgnY0iXNlY3AyNTZrMaEDffaGfJzgGhUif1JqFruZlYmA31HzathLSWxfbq_QoQ4"`,
+ }},
+ "fdxn3sn67na5dka4j2gok7bvqi.n": {ttl: treeNodeTTL, values: []string{`"enrtree-branch:"`}},
+ "n": {ttl: rootTTL, values: []string{`"enrtree-root:v1 e=2KFJOGVXDQTXXUGBH7GS7NAAAI l=FDXN3SN67NA5DKA4J2GOK7BVQI seq=0 sig=v_-J_q_9ICQg5ztExFvLQhDBGMb0lZPJLhe3ts9LAcgqhOhtT3YFJsl8BWNDSwGtamUdR-9xl88_w-X42SVpjwE"`}},
+ }
+
+ testTree1 := map[string]string{
+ "n": "enrtree-root:v1 e=JWXYDBPXYWG6FX3GMDIBFA6CJ4 l=C7HRFPF3BLGF3YR4DY5KX3SMBE seq=1 sig=o908WmNp7LibOfPsr4btQwatZJ5URBr2ZAuxvK4UWHlsB9sUOTJQaGAlLPVAhM__XJesCHxLISo94z5Z2a463gA",
+ "C7HRFPF3BLGF3YR4DY5KX3SMBE.n": "enrtree://AM5FCQLWIZX2QFPNJAP7VUERCCRNGRHWZG3YYHIUV7BVDQ5FDPRT2@morenodes.example.org",
+ "JWXYDBPXYWG6FX3GMDIBFA6CJ4.n": "enrtree-branch:2XS2367YHAXJFGLZHVAWLQD4ZY,H4FHT4B454P6UXFD7JCYQ5PWDY,MHTDO6TMUBRIA2XWG5LUDACK24",
+ "2XS2367YHAXJFGLZHVAWLQD4ZY.n": "enr:-HW4QOFzoVLaFJnNhbgMoDXPnOvcdVuj7pDpqRvh6BRDO68aVi5ZcjB3vzQRZH2IcLBGHzo8uUN3snqmgTiE56CH3AMBgmlkgnY0iXNlY3AyNTZrMaECC2_24YYkYHEgdzxlSNKQEnHhuNAbNlMlWJxrJxbAFvA",
+ "H4FHT4B454P6UXFD7JCYQ5PWDY.n": "enr:-HW4QAggRauloj2SDLtIHN1XBkvhFZ1vtf1raYQp9TBW2RD5EEawDzbtSmlXUfnaHcvwOizhVYLtr7e6vw7NAf6mTuoCgmlkgnY0iXNlY3AyNTZrMaECjrXI8TLNXU0f8cthpAMxEshUyQlK-AM0PW2wfrnacNI",
+ "MHTDO6TMUBRIA2XWG5LUDACK24.n": "enr:-HW4QLAYqmrwllBEnzWWs7I5Ev2IAs7x_dZlbYdRdMUx5EyKHDXp7AV5CkuPGUPdvbv1_Ms1CPfhcGCvSElSosZmyoqAgmlkgnY0iXNlY3AyNTZrMaECriawHKWdDRk2xeZkrOXBQ0dfMFLHY4eENZwdufn1S1o",
+ }
+
+ wantChanges := []types.Change{
+ {
+ Action: "CREATE",
+ ResourceRecordSet: &types.ResourceRecordSet{
+ Name: sp("2xs2367yhaxjfglzhvawlqd4zy.n"),
+ ResourceRecords: []types.ResourceRecord{{
+ Value: sp(`"enr:-HW4QOFzoVLaFJnNhbgMoDXPnOvcdVuj7pDpqRvh6BRDO68aVi5ZcjB3vzQRZH2IcLBGHzo8uUN3snqmgTiE56CH3AMBgmlkgnY0iXNlY3AyNTZrMaECC2_24YYkYHEgdzxlSNKQEnHhuNAbNlMlWJxrJxbAFvA"`),
+ }},
+ TTL: ip(treeNodeTTL),
+ Type: "TXT",
+ },
+ },
+ {
+ Action: "CREATE",
+ ResourceRecordSet: &types.ResourceRecordSet{
+ Name: sp("c7hrfpf3blgf3yr4dy5kx3smbe.n"),
+ ResourceRecords: []types.ResourceRecord{{
+ Value: sp(`"enrtree://AM5FCQLWIZX2QFPNJAP7VUERCCRNGRHWZG3YYHIUV7BVDQ5FDPRT2@morenodes.example.org"`),
+ }},
+ TTL: ip(treeNodeTTL),
+ Type: "TXT",
+ },
+ },
+ {
+ Action: "CREATE",
+ ResourceRecordSet: &types.ResourceRecordSet{
+ Name: sp("h4fht4b454p6uxfd7jcyq5pwdy.n"),
+ ResourceRecords: []types.ResourceRecord{{
+ Value: sp(`"enr:-HW4QAggRauloj2SDLtIHN1XBkvhFZ1vtf1raYQp9TBW2RD5EEawDzbtSmlXUfnaHcvwOizhVYLtr7e6vw7NAf6mTuoCgmlkgnY0iXNlY3AyNTZrMaECjrXI8TLNXU0f8cthpAMxEshUyQlK-AM0PW2wfrnacNI"`),
+ }},
+ TTL: ip(treeNodeTTL),
+ Type: "TXT",
+ },
+ },
+ {
+ Action: "CREATE",
+ ResourceRecordSet: &types.ResourceRecordSet{
+ Name: sp("jwxydbpxywg6fx3gmdibfa6cj4.n"),
+ ResourceRecords: []types.ResourceRecord{{
+ Value: sp(`"enrtree-branch:2XS2367YHAXJFGLZHVAWLQD4ZY,H4FHT4B454P6UXFD7JCYQ5PWDY,MHTDO6TMUBRIA2XWG5LUDACK24"`),
+ }},
+ TTL: ip(treeNodeTTL),
+ Type: "TXT",
+ },
+ },
+ {
+ Action: "CREATE",
+ ResourceRecordSet: &types.ResourceRecordSet{
+ Name: sp("mhtdo6tmubria2xwg5ludack24.n"),
+ ResourceRecords: []types.ResourceRecord{{
+ Value: sp(`"enr:-HW4QLAYqmrwllBEnzWWs7I5Ev2IAs7x_dZlbYdRdMUx5EyKHDXp7AV5CkuPGUPdvbv1_Ms1CPfhcGCvSElSosZmyoqAgmlkgnY0iXNlY3AyNTZrMaECriawHKWdDRk2xeZkrOXBQ0dfMFLHY4eENZwdufn1S1o"`),
+ }},
+ TTL: ip(treeNodeTTL),
+ Type: "TXT",
+ },
+ },
+ {
+ Action: "UPSERT",
+ ResourceRecordSet: &types.ResourceRecordSet{
+ Name: sp("n"),
+ ResourceRecords: []types.ResourceRecord{{
+ Value: sp(`"enrtree-root:v1 e=JWXYDBPXYWG6FX3GMDIBFA6CJ4 l=C7HRFPF3BLGF3YR4DY5KX3SMBE seq=1 sig=o908WmNp7LibOfPsr4btQwatZJ5URBr2ZAuxvK4UWHlsB9sUOTJQaGAlLPVAhM__XJesCHxLISo94z5Z2a463gA"`),
+ }},
+ TTL: ip(rootTTL),
+ Type: "TXT",
+ },
+ },
+ {
+ Action: "DELETE",
+ ResourceRecordSet: &types.ResourceRecordSet{
+ Name: sp("2kfjogvxdqtxxugbh7gs7naaai.n"),
+ ResourceRecords: []types.ResourceRecord{
+ {Value: sp(`"enr:-HW4QO1ml1DdXLeZLsUxewnthhUy8eROqkDyoMTyavfks9JlYQIlMFEUoM78PovJDPQrAkrb3LRJ-""vtrymDguKCOIAWAgmlkgnY0iXNlY3AyNTZrMaEDffaGfJzgGhUif1JqFruZlYmA31HzathLSWxfbq_QoQ4"`)},
+ },
+ TTL: ip(3333),
+ Type: "TXT",
+ },
+ },
+ {
+ Action: "DELETE",
+ ResourceRecordSet: &types.ResourceRecordSet{
+ Name: sp("fdxn3sn67na5dka4j2gok7bvqi.n"),
+ ResourceRecords: []types.ResourceRecord{{
+ Value: sp(`"enrtree-branch:"`),
+ }},
+ TTL: ip(treeNodeTTL),
+ Type: "TXT",
+ },
+ },
+ }
+
+ var client route53Client
+ changes := client.computeChanges("n", testTree1, testTree0)
+ if !reflect.DeepEqual(changes, wantChanges) {
+ t.Fatalf("wrong changes (got %d, want %d)", len(changes), len(wantChanges))
+ }
+
+ // Check splitting according to size.
+ wantSplit := [][]types.Change{
+ wantChanges[:4],
+ wantChanges[4:6],
+ wantChanges[6:],
+ }
+ split := splitChanges(changes, 600, 4000)
+ if !reflect.DeepEqual(split, wantSplit) {
+ t.Fatalf("wrong split batches: got %d, want %d", len(split), len(wantSplit))
+ }
+
+ // Check splitting according to count.
+ wantSplit = [][]types.Change{
+ wantChanges[:5],
+ wantChanges[5:],
+ }
+ split = splitChanges(changes, 10000, 6)
+ if !reflect.DeepEqual(split, wantSplit) {
+ t.Fatalf("wrong split batches: got %d, want %d", len(split), len(wantSplit))
+ }
+}
+
+// This test checks that computeChanges compares the quoted value of the records correctly.
+func TestRoute53NoChange(t *testing.T) {
+ t.Parallel()
+ // Existing record set.
+ testTree0 := map[string]recordSet{
+ "n": {ttl: rootTTL, values: []string{
+ `"enrtree-root:v1 e=JWXYDBPXYWG6FX3GMDIBFA6CJ4 l=C7HRFPF3BLGF3YR4DY5KX3SMBE seq=1 sig=o908WmNp7LibOfPsr4btQwatZJ5URBr2ZAuxvK4UWHlsB9sUOTJQaGAlLPVAhM__XJesCHxLISo94z5Z2a463gA"`,
+ }},
+ "2xs2367yhaxjfglzhvawlqd4zy.n": {ttl: treeNodeTTL, values: []string{
+ `"enr:-HW4QOFzoVLaFJnNhbgMoDXPnOvcdVuj7pDpqRvh6BRDO68aVi5ZcjB3vzQRZH2IcLBGHzo8uUN3snqmgTiE56CH3AMBgmlkgnY0iXNlY3AyNTZrMaECC2_24YYkYHEgdzxlSNKQEnHhuNAbNlMlWJxrJxbAFvA"`,
+ }},
+ }
+ // New set.
+ testTree1 := map[string]string{
+ "n": "enrtree-root:v1 e=JWXYDBPXYWG6FX3GMDIBFA6CJ4 l=C7HRFPF3BLGF3YR4DY5KX3SMBE seq=1 sig=o908WmNp7LibOfPsr4btQwatZJ5URBr2ZAuxvK4UWHlsB9sUOTJQaGAlLPVAhM__XJesCHxLISo94z5Z2a463gA",
+ "2XS2367YHAXJFGLZHVAWLQD4ZY.n": "enr:-HW4QOFzoVLaFJnNhbgMoDXPnOvcdVuj7pDpqRvh6BRDO68aVi5ZcjB3vzQRZH2IcLBGHzo8uUN3snqmgTiE56CH3AMBgmlkgnY0iXNlY3AyNTZrMaECC2_24YYkYHEgdzxlSNKQEnHhuNAbNlMlWJxrJxbAFvA",
+ }
+
+ var client route53Client
+ changes := client.computeChanges("n", testTree1, testTree0)
+ if len(changes) > 0 {
+ t.Fatalf("wrong changes (got %d, want 0)", len(changes))
+ }
+}
+
+func sp(s string) *string { return &s }
+func ip(i int64) *int64 { return &i }
diff --git a/cmd/devp2p/dnscmd.go b/cmd/devp2p/dnscmd.go
index 859d03f6d261..771684d65904 100644
--- a/cmd/devp2p/dnscmd.go
+++ b/cmd/devp2p/dnscmd.go
@@ -42,6 +42,8 @@ var (
dnsSignCommand,
dnsTXTCommand,
dnsCloudflareCommand,
+ dnsRoute53Command,
+ dnsRoute53NukeCommand,
},
}
dnsSyncCommand = &cli.Command{
@@ -71,6 +73,30 @@ var (
Action: dnsToCloudflare,
Flags: []cli.Flag{cloudflareTokenFlag, cloudflareZoneIDFlag},
}
+ dnsRoute53Command = &cli.Command{
+ Name: "to-route53",
+ Usage: "Deploy DNS TXT records to Amazon Route53",
+ ArgsUsage: "",
+ Action: dnsToRoute53,
+ Flags: []cli.Flag{
+ route53AccessKeyFlag,
+ route53AccessSecretFlag,
+ route53ZoneIDFlag,
+ route53RegionFlag,
+ },
+ }
+ dnsRoute53NukeCommand = &cli.Command{
+ Name: "nuke-route53",
+ Usage: "Deletes DNS TXT records of a subdomain on Amazon Route53",
+ ArgsUsage: "",
+ Action: dnsNukeRoute53,
+ Flags: []cli.Flag{
+ route53AccessKeyFlag,
+ route53AccessSecretFlag,
+ route53ZoneIDFlag,
+ route53RegionFlag,
+ },
+ }
)
var (
@@ -203,6 +229,28 @@ func dnsToCloudflare(ctx *cli.Context) error {
return client.deploy(domain, t)
}
+// dnsToRoute53 performs dnsRoute53Command.
+func dnsToRoute53(ctx *cli.Context) error {
+ if ctx.NArg() != 1 {
+ return errors.New("need tree definition directory as argument")
+ }
+ domain, t, err := loadTreeDefinitionForExport(ctx.Args().Get(0))
+ if err != nil {
+ return err
+ }
+ client := newRoute53Client(ctx)
+ return client.deploy(domain, t)
+}
+
+// dnsNukeRoute53 performs dnsRoute53NukeCommand.
+func dnsNukeRoute53(ctx *cli.Context) error {
+ if ctx.NArg() != 1 {
+ return errors.New("need domain name as argument")
+ }
+ client := newRoute53Client(ctx)
+ return client.deleteDomain(ctx.Args().First())
+}
+
// loadSigningKey loads a private key in Ethereum keystore format.
func loadSigningKey(keyfile string) *ecdsa.PrivateKey {
keyjson, err := os.ReadFile(keyfile)
diff --git a/go.mod b/go.mod
index c34ae4c975b6..e43166b2983e 100644
--- a/go.mod
+++ b/go.mod
@@ -33,6 +33,10 @@ require (
require (
github.com/Microsoft/go-winio v0.6.2
+ github.com/aws/aws-sdk-go-v2 v1.42.1
+ github.com/aws/aws-sdk-go-v2/config v1.32.30
+ github.com/aws/aws-sdk-go-v2/credentials v1.19.29
+ github.com/aws/aws-sdk-go-v2/service/route53 v1.64.1
github.com/btcsuite/btcd/btcec/v2 v2.2.0
github.com/cloudflare/cloudflare-go v0.117.0
github.com/consensys/gnark-crypto v0.10.0
@@ -68,6 +72,17 @@ require (
require (
github.com/StackExchange/wmi v1.2.1 // indirect
+ github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.30 // indirect
+ github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.30 // indirect
+ github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.30 // indirect
+ github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.31 // indirect
+ github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.13 // indirect
+ github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.30 // indirect
+ github.com/aws/aws-sdk-go-v2/service/signin v1.4.1 // indirect
+ github.com/aws/aws-sdk-go-v2/service/sso v1.32.1 // indirect
+ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.37.1 // indirect
+ github.com/aws/aws-sdk-go-v2/service/sts v1.44.1 // indirect
+ github.com/aws/smithy-go v1.27.3 // indirect
github.com/bits-and-blooms/bitset v1.5.0 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/consensys/bavard v0.1.13 // indirect
diff --git a/go.sum b/go.sum
index 313315ea2bbd..1d1e7f8ee0a5 100644
--- a/go.sum
+++ b/go.sum
@@ -6,6 +6,36 @@ github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjC
github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI=
github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
+github.com/aws/aws-sdk-go-v2 v1.42.1 h1:9eOTgu1z/dVtYpNZ3/8/XbbaX0x/BqE3HUzAzs6K0ek=
+github.com/aws/aws-sdk-go-v2 v1.42.1/go.mod h1:5pKeft2eJj+gElQ38Jqg4ibCqh+/AK33/0X3hip7IjM=
+github.com/aws/aws-sdk-go-v2/config v1.32.30 h1:XwsEzpTJfQYJbFicz/QMLwAZdyeNVVoOEkbF7R3gPJk=
+github.com/aws/aws-sdk-go-v2/config v1.32.30/go.mod h1:Ud32SuMc+/9BGxfpSVld7HrE2o05JwKmXY4M3jOQNZU=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.29 h1:WHZGssHH887cO0ox07SIQZsFx3MKD4ps6w0xUEmnKYQ=
+github.com/aws/aws-sdk-go-v2/credentials v1.19.29/go.mod h1:Mhl0xR6zjguiuj00XRx2wMx22sAltk7oya39sT7fdg8=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.30 h1:/hi1JADLEW9YYryEz1w4GQu0EtP23pP553Cf9KgsDV4=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.30/go.mod h1:/3AOgy4K17Dm4ucMZVC/MJkzy5kmfKUcINRHZyo0koQ=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.30 h1:xM/Is9cKMHa8Jj8zkvWhvrFkZsXJV9E+BB4g0HW0duQ=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.30/go.mod h1:WueJeNDZvK1fMYEWJIkcivBfEzUkTpBhzlrUKKY8EuA=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.30 h1:jn46zC9LdsVR/ZpMIJqMqb8hHv31BlLx3ulVqNspUOk=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.30/go.mod h1:1hTMsAgbdS/AtUi4bw8+gUuh1pceo+eXRLfpSuSQj3M=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.31 h1:3GUprIsfmGcC5SACIyB0e7E0BM1O1b3Erl5CePYIAeQ=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.31/go.mod h1:7PuV1yl5e2xnUbm+RqvVg5i2iBM8EyijZNoI9wsOoOc=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.13 h1:mbRIur/BiHK6SKPjoBIXSE/hJ6g6JGRLuxQy1jGjlN4=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.13/go.mod h1:ITg9em2KbJx1s0y4aqRX5OYWG6HBZ5TVR//OdpEZ2CQ=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.30 h1:/Z5jmNrKsSD7EmDjzAPsm/3L9IuOkzaynklJZ1qX7S4=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.30/go.mod h1:lEzEZnOosE7zi8Z6royW1cFJTD9fpab4Ul1SBrllewk=
+github.com/aws/aws-sdk-go-v2/service/route53 v1.64.1 h1:qL5ELChQ1o1ZbzHvsl8gzQfAZdbQtrDbUyzJkjkMKcg=
+github.com/aws/aws-sdk-go-v2/service/route53 v1.64.1/go.mod h1:0hIRXFez1bZsDFMGkLZvNJbByTSVZ4sFZWpxZ39NPuM=
+github.com/aws/aws-sdk-go-v2/service/signin v1.4.1 h1:V7ZZ300WPXGjvkyore5DGe0ljVPOxCXie/thWdtSBXE=
+github.com/aws/aws-sdk-go-v2/service/signin v1.4.1/go.mod h1:mxC0nT/C8wMMS97DemZPzvUZxvIt+2Iq+eS3JdFZGgg=
+github.com/aws/aws-sdk-go-v2/service/sso v1.32.1 h1:gYFYh4iLLcAOJRLNPY2aD2g9DIhKn4eof8UkIrr1rTk=
+github.com/aws/aws-sdk-go-v2/service/sso v1.32.1/go.mod h1:u8af9Nqkmqnr96f7v9nHqzZT9XBwbXEkTiqT4ROuJSE=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.37.1 h1:arjT9Cm3/WYbGmD5TUZHk4UQn4Lle1fUNZs5FC6CtF0=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.37.1/go.mod h1:DMPWJBjYs6+3+f/qhBFEFPPlQ6NlhWjai3dJNvipJ84=
+github.com/aws/aws-sdk-go-v2/service/sts v1.44.1 h1:RvfHDg+xvAeZ+5741vUEjpOVtYSIm93W2zhx10Xtydw=
+github.com/aws/aws-sdk-go-v2/service/sts v1.44.1/go.mod h1:9gdl4RrflIdpDb2TlXshWgR1F9TeCkvqDx77Vpr4Z/Q=
+github.com/aws/smithy-go v1.27.3 h1:F3Zb497UhhskkfpJmfkXswyo+t0sh9OTBnIHjogWbVY=
+github.com/aws/smithy-go v1.27.3/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
github.com/bits-and-blooms/bitset v1.5.0 h1:NpE8frKRLGHIcEzkR+gZhiioW1+WbYV6fKwD6ZIpQT8=
github.com/bits-and-blooms/bitset v1.5.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k=
From aebad501ae8496b045a0ba3d5c5c9b00ad1b2795 Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 11:48:18 +0800
Subject: [PATCH 08/14] feat(cmd/devp2p): upgrade nodeset command
---
cmd/devp2p/nodeset.go | 21 ++++++++
cmd/devp2p/nodesetcmd.go | 106 ++++++++++++++++++++++++++++++++++-----
core/forkid/forkid.go | 3 ++
3 files changed, 117 insertions(+), 13 deletions(-)
diff --git a/cmd/devp2p/nodeset.go b/cmd/devp2p/nodeset.go
index cb3b59d7893b..b6762442eea5 100644
--- a/cmd/devp2p/nodeset.go
+++ b/cmd/devp2p/nodeset.go
@@ -18,6 +18,7 @@ package main
import (
"bytes"
+ "cmp"
"encoding/json"
"fmt"
"os"
@@ -93,6 +94,26 @@ func (ns nodeSet) add(nodes ...*enode.Node) {
}
}
+// topN returns the top n nodes by score as a new set.
+func (ns nodeSet) topN(n int) nodeSet {
+ if n >= len(ns) {
+ return ns
+ }
+
+ byscore := make([]nodeJSON, 0, len(ns))
+ for _, v := range ns {
+ byscore = append(byscore, v)
+ }
+ slices.SortFunc(byscore, func(a, b nodeJSON) int {
+ return cmp.Compare(b.Score, a.Score)
+ })
+ result := make(nodeSet, n)
+ for _, v := range byscore[:n] {
+ result[v.N.ID()] = v
+ }
+ return result
+}
+
// verify performs integrity checks on the node set.
func (ns nodeSet) verify() error {
for id, n := range ns {
diff --git a/cmd/devp2p/nodesetcmd.go b/cmd/devp2p/nodesetcmd.go
index 5efe2b4c93ac..7dd2d71bf66b 100644
--- a/cmd/devp2p/nodesetcmd.go
+++ b/cmd/devp2p/nodesetcmd.go
@@ -17,8 +17,12 @@
package main
import (
+ "errors"
"fmt"
- "net"
+ "net/netip"
+ "sort"
+ "strconv"
+ "strings"
"time"
"github.com/XinFinOrg/XDPoSChain/core/forkid"
@@ -55,30 +59,69 @@ var (
func nodesetInfo(ctx *cli.Context) error {
if ctx.NArg() < 1 {
- return fmt.Errorf("need nodes file as argument")
+ return errors.New("need nodes file as argument")
}
ns := loadNodesJSON(ctx.Args().First())
fmt.Printf("Set contains %d nodes.\n", len(ns))
+ showAttributeCounts(ns)
return nil
}
+// showAttributeCounts prints the distribution of ENR attributes in a node set.
+func showAttributeCounts(ns nodeSet) {
+ attrcount := make(map[string]int)
+ var attrlist []interface{}
+ for _, n := range ns {
+ r := n.N.Record()
+ attrlist = r.AppendElements(attrlist[:0])[1:]
+ for i := 0; i < len(attrlist); i += 2 {
+ key := attrlist[i].(string)
+ attrcount[key]++
+ }
+ }
+
+ var keys []string
+ var maxlength int
+ for key := range attrcount {
+ keys = append(keys, key)
+ if len(key) > maxlength {
+ maxlength = len(key)
+ }
+ }
+ sort.Strings(keys)
+ fmt.Println("ENR attribute counts:")
+ for _, key := range keys {
+ fmt.Printf("%s%s: %d\n", strings.Repeat(" ", maxlength-len(key)+1), key, attrcount[key])
+ }
+}
+
func nodesetFilter(ctx *cli.Context) error {
if ctx.NArg() < 1 {
- return fmt.Errorf("need nodes file as argument")
+ return errors.New("need nodes file as argument")
}
- ns := loadNodesJSON(ctx.Args().First())
+ // Parse -limit.
+ limit, err := parseFilterLimit(ctx.Args().Tail())
+ if err != nil {
+ return err
+ }
+ // Parse the filters.
filter, err := andFilter(ctx.Args().Tail())
if err != nil {
return err
}
+ // Load nodes and apply filters.
+ ns := loadNodesJSON(ctx.Args().First())
result := make(nodeSet)
for id, n := range ns {
if filter(n) {
result[id] = n
}
}
+ if limit >= 0 {
+ result = result.topN(limit)
+ }
writeNodesJSON("-", result)
return nil
}
@@ -91,12 +134,15 @@ type nodeFilterC struct {
}
var filterFlags = map[string]nodeFilterC{
+ "-limit": {1, trueFilter}, // needed to skip over -limit
"-ip": {1, ipFilter},
"-min-age": {1, minAgeFilter},
"-eth-network": {1, ethFilter},
"-les-server": {0, lesFilter},
+ "-snap": {0, snapFilter},
}
+// parseFilters parses nodeFilters from args.
func parseFilters(args []string) ([]nodeFilter, error) {
var filters []nodeFilter
for len(args) > 0 {
@@ -104,19 +150,39 @@ func parseFilters(args []string) ([]nodeFilter, error) {
if !ok {
return nil, fmt.Errorf("invalid filter %q", args[0])
}
- if len(args) < fc.narg {
- return nil, fmt.Errorf("filter %q wants %d arguments, have %d", args[0], fc.narg, len(args))
+ if len(args)-1 < fc.narg {
+ return nil, fmt.Errorf("filter %q wants %d arguments, have %d", args[0], fc.narg, len(args)-1)
}
- filter, err := fc.fn(args[1:])
+ filter, err := fc.fn(args[1 : 1+fc.narg])
if err != nil {
return nil, fmt.Errorf("%s: %v", args[0], err)
}
filters = append(filters, filter)
- args = args[fc.narg+1:]
+ args = args[1+fc.narg:]
}
return filters, nil
}
+// parseFilterLimit parses the -limit option in args. It returns -1 if there is no limit.
+func parseFilterLimit(args []string) (int, error) {
+ limit := -1
+ for i, arg := range args {
+ if arg == "-limit" {
+ if i == len(args)-1 {
+ return -1, errors.New("-limit requires an argument")
+ }
+ n, err := strconv.Atoi(args[i+1])
+ if err != nil {
+ return -1, fmt.Errorf("invalid -limit %q", args[i+1])
+ }
+ limit = n
+ }
+ }
+ return limit, nil
+}
+
+// andFilter parses node filters in args and returns a single filter that requires all
+// of them to match.
func andFilter(args []string) (nodeFilter, error) {
checks, err := parseFilters(args)
if err != nil {
@@ -133,12 +199,16 @@ func andFilter(args []string) (nodeFilter, error) {
return f, nil
}
+func trueFilter(args []string) (nodeFilter, error) {
+ return func(n nodeJSON) bool { return true }, nil
+}
+
func ipFilter(args []string) (nodeFilter, error) {
- _, cidr, err := net.ParseCIDR(args[0])
+ prefix, err := netip.ParsePrefix(args[0])
if err != nil {
return nil, err
}
- f := func(n nodeJSON) bool { return cidr.Contains(n.N.IP()) }
+ f := func(n nodeJSON) bool { return prefix.Contains(n.N.IPAddr()) }
return f, nil
}
@@ -155,7 +225,7 @@ func minAgeFilter(args []string) (nodeFilter, error) {
}
func ethFilter(args []string) (nodeFilter, error) {
- var filter func(forkid.ID) error
+ var filter forkid.Filter
switch args[0] {
case "mainnet", "xinfin":
filter = forkid.NewStaticFilter(params.MainnetChainConfig, params.MainnetGenesisHash)
@@ -170,7 +240,7 @@ func ethFilter(args []string) (nodeFilter, error) {
f := func(n nodeJSON) bool {
var eth struct {
ForkID forkid.ID
- _ []rlp.RawValue `rlp:"tail"`
+ Tail []rlp.RawValue `rlp:"tail"`
}
if n.N.Load(enr.WithEntry("eth", ð)) != nil {
return false
@@ -183,9 +253,19 @@ func ethFilter(args []string) (nodeFilter, error) {
func lesFilter(args []string) (nodeFilter, error) {
f := func(n nodeJSON) bool {
var les struct {
- _ []rlp.RawValue `rlp:"tail"`
+ Tail []rlp.RawValue `rlp:"tail"`
}
return n.N.Load(enr.WithEntry("les", &les)) == nil
}
return f, nil
}
+
+func snapFilter(args []string) (nodeFilter, error) {
+ f := func(n nodeJSON) bool {
+ var snap struct {
+ Tail []rlp.RawValue `rlp:"tail"`
+ }
+ return n.N.Load(enr.WithEntry("snap", &snap)) == nil
+ }
+ return f, nil
+}
diff --git a/core/forkid/forkid.go b/core/forkid/forkid.go
index a3eb261034fa..94228412dc8f 100644
--- a/core/forkid/forkid.go
+++ b/core/forkid/forkid.go
@@ -59,6 +59,9 @@ type ID struct {
Next uint64 // Block number of the next upcoming fork, or 0 if no forks are known
}
+// Filter is a fork id filter to validate a remotely advertised ID.
+type Filter func(id ID) error
+
// NewID calculates the XDC fork ID from the chain config, genesis hash, head.
func NewID(config *params.ChainConfig, genesis *types.Block, head uint64) ID {
// Calculate the starting checksum from the genesis hash
From a313387660b32047a833dcd4eab7836d5cabd9b0 Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 16:06:20 +0800
Subject: [PATCH 09/14] feat(cmd/devp2p): upgrade rlpx command
---
cmd/devp2p/internal/ethtest/protocol.go | 34 +++++++++++
cmd/devp2p/rlpxcmd.go | 73 +++++++++++++++---------
cmd/devp2p/rlpxcmd_test.go | 75 +++++++++++++++++++++++++
3 files changed, 154 insertions(+), 28 deletions(-)
create mode 100644 cmd/devp2p/internal/ethtest/protocol.go
create mode 100644 cmd/devp2p/rlpxcmd_test.go
diff --git a/cmd/devp2p/internal/ethtest/protocol.go b/cmd/devp2p/internal/ethtest/protocol.go
new file mode 100644
index 000000000000..e7eb62477a37
--- /dev/null
+++ b/cmd/devp2p/internal/ethtest/protocol.go
@@ -0,0 +1,34 @@
+// Copyright 2023 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see .
+
+package ethtest
+
+import (
+ "github.com/XinFinOrg/XDPoSChain/p2p"
+ "github.com/XinFinOrg/XDPoSChain/rlp"
+)
+
+// Unexported handshake structure from p2p/peer.go.
+type protoHandshake struct {
+ Version uint64
+ Name string
+ Caps []p2p.Cap
+ ListenPort uint64
+ ID []byte
+ Rest []rlp.RawValue `rlp:"tail"`
+}
+
+type Hello = protoHandshake
diff --git a/cmd/devp2p/rlpxcmd.go b/cmd/devp2p/rlpxcmd.go
index 55e22a66e4ac..d074e949a639 100644
--- a/cmd/devp2p/rlpxcmd.go
+++ b/cmd/devp2p/rlpxcmd.go
@@ -17,10 +17,12 @@
package main
import (
+ "bytes"
+ "errors"
"fmt"
"net"
- "github.com/XinFinOrg/XDPoSChain/common/hexutil"
+ "github.com/XinFinOrg/XDPoSChain/cmd/devp2p/internal/ethtest"
"github.com/XinFinOrg/XDPoSChain/crypto"
"github.com/XinFinOrg/XDPoSChain/p2p"
"github.com/XinFinOrg/XDPoSChain/p2p/rlpx"
@@ -37,66 +39,81 @@ var (
},
}
rlpxPingCommand = &cli.Command{
- Name: "ping",
- Usage: "Perform a RLPx handshake",
- ArgsUsage: "",
- Action: rlpxPing,
+ Name: "ping",
+ Usage: "Perform a RLPx handshake",
+ Action: rlpxPing,
}
)
func rlpxPing(ctx *cli.Context) error {
n := getNodeArg(ctx)
-
- fd, err := net.Dial("tcp", fmt.Sprintf("%v:%d", n.IP(), n.TCP()))
+ tcpEndpoint, ok := n.TCPEndpoint()
+ if !ok {
+ return errors.New("node has no TCP endpoint")
+ }
+ fd, err := net.Dial("tcp", tcpEndpoint.String())
if err != nil {
return err
}
defer fd.Close()
- conn := rlpx.NewConn(fd, n.Pubkey())
+ conn := rlpx.NewConn(fd, n.Pubkey())
ourKey, err := crypto.GenerateKey()
if err != nil {
return err
}
-
_, err = conn.Handshake(ourKey)
if err != nil {
return err
}
-
code, data, _, err := conn.Read()
if err != nil {
return err
}
switch code {
case 0:
- var h devp2pHandshake
+ var h ethtest.Hello
if err := rlp.DecodeBytes(data, &h); err != nil {
return fmt.Errorf("invalid handshake: %v", err)
}
fmt.Printf("%+v\n", h)
case 1:
- var msg []p2p.DiscReason
- if err := rlp.DecodeBytes(data, &msg); err != nil {
- return fmt.Errorf("invalid disconnect message: %v", err)
- }
- if len(msg) == 0 {
- return fmt.Errorf("invalid disconnect message")
+ // The disconnect message is specified as a list containing the reason,
+ // but some implementations (including older geth) send the reason as a
+ // single byte. Handle both forms, and on failure include the raw payload
+ // so the operator can see what was actually sent.
+ reason, decErr := decodeRLPxDisconnect(data)
+ if decErr != nil {
+ return fmt.Errorf("invalid disconnect message: %v (raw=0x%x)", decErr, data)
}
- return fmt.Errorf("received disconnect message: %v", msg[0])
+ return fmt.Errorf("received disconnect message: %v", reason)
default:
- return fmt.Errorf("invalid message code %d, expected handshake (code zero)", code)
+ return fmt.Errorf("invalid message code %d, expected handshake (code zero) or disconnect (code one)", code)
}
return nil
}
-// devp2pHandshake is the RLP structure of the devp2p protocol handshake.
-type devp2pHandshake struct {
- Version uint64
- Name string
- Caps []p2p.Cap
- ListenPort uint64
- ID hexutil.Bytes // secp256k1 public key
- // Ignore additional fields (for forward compatibility).
- Rest []rlp.RawValue `rlp:"tail"`
+// decodeRLPxDisconnect parses a disconnect message payload. Per the RLPx spec
+// the payload is a list containing a single reason, but some implementations
+// (including older geth) sent the reason as a bare byte. Accept both forms.
+func decodeRLPxDisconnect(data []byte) (p2p.DiscReason, error) {
+ s := rlp.NewStream(bytes.NewReader(data), uint64(len(data)))
+ k, _, err := s.Kind()
+ if err != nil {
+ return 0, err
+ }
+ var reason p2p.DiscReason
+ if k == rlp.List {
+ if _, err := s.List(); err != nil {
+ return 0, err
+ }
+ if err := s.Decode(&reason); err != nil {
+ return 0, err
+ }
+ return reason, nil
+ }
+ if err := s.Decode(&reason); err != nil {
+ return 0, err
+ }
+ return reason, nil
}
diff --git a/cmd/devp2p/rlpxcmd_test.go b/cmd/devp2p/rlpxcmd_test.go
new file mode 100644
index 000000000000..c1a2b32627f7
--- /dev/null
+++ b/cmd/devp2p/rlpxcmd_test.go
@@ -0,0 +1,75 @@
+// Copyright 2026 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see .
+
+package main
+
+import (
+ "testing"
+
+ "github.com/XinFinOrg/XDPoSChain/p2p"
+)
+
+func TestDecodeRLPxDisconnect(t *testing.T) {
+ tests := []struct {
+ name string
+ payload []byte
+ want p2p.DiscReason
+ wantErr bool
+ }{
+ {
+ name: "list form (spec-compliant)",
+ payload: []byte{0xc1, 0x04}, // [4] = TooManyPeers
+ want: p2p.DiscTooManyPeers,
+ },
+ {
+ name: "list form with reason zero",
+ payload: []byte{0xc1, 0x80}, // [0] = Requested
+ want: p2p.DiscRequested,
+ },
+ {
+ name: "bare byte form (legacy geth)",
+ payload: []byte{0x04}, // 4 = TooManyPeers
+ want: p2p.DiscTooManyPeers,
+ },
+ {
+ name: "bare byte form zero",
+ payload: []byte{0x80}, // 0 = Requested
+ want: p2p.DiscRequested,
+ },
+ {
+ name: "empty payload",
+ payload: []byte{},
+ wantErr: true,
+ },
+ }
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ got, err := decodeRLPxDisconnect(tc.payload)
+ if tc.wantErr {
+ if err == nil {
+ t.Fatalf("expected error, got reason=%v", got)
+ }
+ return
+ }
+ if err != nil {
+ t.Fatalf("unexpected error: %v", err)
+ }
+ if got != tc.want {
+ t.Fatalf("got reason %v, want %v", got, tc.want)
+ }
+ })
+ }
+}
From 5f18d9ff99db9aa8a77cc84af43ac0d8a902267c Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 16:16:31 +0800
Subject: [PATCH 10/14] docs(cmd/devp2p): add README.md
---
cmd/devp2p/README.md | 140 +++++++++++++++++++++++++++++++++++++++++++
1 file changed, 140 insertions(+)
create mode 100644 cmd/devp2p/README.md
diff --git a/cmd/devp2p/README.md b/cmd/devp2p/README.md
new file mode 100644
index 000000000000..2b091b830c58
--- /dev/null
+++ b/cmd/devp2p/README.md
@@ -0,0 +1,140 @@
+# The devp2p command
+
+The devp2p command line tool is a utility for low-level peer-to-peer debugging and
+protocol development purposes. It can do many things.
+
+## ENR Decoding
+
+Use `devp2p enrdump ` to verify and display an Ethereum Node Record.
+
+## Node Key Management
+
+The `devp2p key ...` command family deals with node key files.
+
+Run `devp2p key generate mynode.key` to create a new node key in the `mynode.key` file.
+
+Run `devp2p key to-enode mynode.key -ip 127.0.0.1 -tcp 30303` to create an enode:// URL
+corresponding to the given node key and address information.
+
+## Maintaining DNS Discovery Node Lists
+
+The devp2p command can create and publish DNS discovery node lists.
+
+Run `devp2p dns sign ` to update the signature of a DNS discovery tree.
+
+Run `devp2p dns sync ` to download a complete DNS discovery tree.
+
+Run `devp2p dns to-cloudflare ` to publish a tree to CloudFlare DNS.
+
+Run `devp2p dns to-route53 ` to publish a tree to Amazon Route53.
+
+You can find more information about these commands in the [DNS Discovery Setup Guide][dns-tutorial].
+
+## Node Set Utilities
+
+There are several commands for working with JSON node set files. These files are generated
+by the discovery crawlers and DNS client commands. Node sets also used as the input of the
+DNS deployer commands.
+
+Run `devp2p nodeset info ` to display statistics of a node set.
+
+Run `devp2p nodeset filter ` to write a new, filtered node
+set to standard output. The following filters are supported:
+
+- `-limit ` limits the output set to N entries, taking the top N nodes by score
+- `-ip ` filters nodes by IP subnet
+- `-min-age ` filters nodes by 'first seen' time
+- `-eth-network ` filters nodes by "eth" ENR entry
+- `-les-server` filters nodes by LES server support
+- `-snap` filters nodes by snap protocol support
+
+For example, given a node set in `nodes.json`, you could create a filtered set containing
+up to 20 eth mainnet nodes which also support snap sync using this command:
+
+ devp2p nodeset filter nodes.json -eth-network mainnet -snap -limit 20
+
+## Discovery v4 Utilities
+
+The `devp2p discv4 ...` command family deals with the [Node Discovery v4][discv4]
+protocol.
+
+Run `devp2p discv4 ping ` to ping a node.
+
+Run `devp2p discv4 resolve ` to find the most recent node record of a node in
+the DHT.
+
+Run `devp2p discv4 crawl ` to create or update a JSON node set.
+
+## Discovery v5 Utilities
+
+The `devp2p discv5 ...` command family deals with the [Node Discovery v5][discv5]
+protocol. This protocol is currently under active development.
+
+Run `devp2p discv5 ping ` to ping a node.
+
+Run `devp2p discv5 resolve ` to find the most recent node record of a node in
+the discv5 DHT.
+
+Run `devp2p discv5 listen` to run a Discovery v5 node.
+
+Run `devp2p discv5 crawl ` to create or update a JSON node set containing
+discv5 nodes.
+
+## Discovery Test Suites
+
+The devp2p command also contains interactive test suites for Discovery v4 and Discovery
+v5.
+
+To run these tests against your implementation, you need to set up a networking
+environment where two separate UDP listening addresses are available on the same machine.
+The two listening addresses must also be routed such that they are able to reach the node
+you want to test.
+
+For example, if you want to run the test on your local host, and the node under test is
+also on the local host, you need to assign two IP addresses (or a larger range) to your
+loopback interface. On macOS, this can be done by executing the following command:
+
+ sudo ifconfig lo0 add 127.0.0.2
+
+You can now run either test suite as follows: Start the node under test first, ensuring
+that it won't talk to the Internet (i.e. disable bootstrapping). An easy way to prevent
+unintended connections to the global DHT is listening on `127.0.0.1`.
+
+Now get the ENR of your node and store it in the `NODE` environment variable.
+
+Start the test by running `devp2p discv5 test -listen1 127.0.0.1 -listen2 127.0.0.2 $NODE`.
+
+## Eth Protocol Test Suite
+
+The Eth Protocol test suite is a conformance test suite for the [eth protocol][eth].
+
+To run the eth protocol test suite against your implementation, the node needs to be initialized
+with our test chain. The chain files are located in `./cmd/devp2p/internal/ethtest/testdata`.
+
+1. initialize the geth node with the `genesis.json` file
+2. import blocks from `chain.rlp`
+3. run the client using the resulting database. For geth, use a command like the one below:
+
+ geth \
+ --datadir \
+ --nodiscover \
+ --nat=none \
+ --networkid 3503995874084926 \
+ --verbosity 5 \
+ --authrpc.jwtsecret jwt.secret
+
+Note that the tests also require access to the engine API.
+The test suite can now be executed using the devp2p tool.
+
+ devp2p rlpx eth-test \
+ --chain internal/ethtest/testdata \
+ --node enode://.... \
+ --engineapi http://127.0.0.1:8551 \
+ --jwtsecret $(cat jwt.secret)
+
+Repeat the above process (re-initialising the node) in order to run the Eth Protocol test suite again.
+
+[eth]: https://github.com/ethereum/devp2p/blob/master/caps/eth.md
+[dns-tutorial]: https://geth.ethereum.org/docs/developers/geth-developer/dns-discovery-setup
+[discv4]: https://github.com/ethereum/devp2p/tree/master/discv4.md
+[discv5]: https://github.com/ethereum/devp2p/tree/master/discv5/discv5.md
From efbe0e6c6a63eefda697e6aa6c408c8bcbb667eb Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 17:05:23 +0800
Subject: [PATCH 11/14] feat(internal/utesting): port test suite from geth
---
internal/utesting/utesting.go | 339 +++++++++++++++++++++++++++++
internal/utesting/utesting_test.go | 145 ++++++++++++
2 files changed, 484 insertions(+)
create mode 100644 internal/utesting/utesting.go
create mode 100644 internal/utesting/utesting_test.go
diff --git a/internal/utesting/utesting.go b/internal/utesting/utesting.go
new file mode 100644
index 000000000000..8260de1d7603
--- /dev/null
+++ b/internal/utesting/utesting.go
@@ -0,0 +1,339 @@
+// Copyright 2020 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 .
+
+// Package utesting provides a standalone replacement for package testing.
+//
+// This package exists because package testing cannot easily be embedded into a
+// standalone go program. It provides an API that mirrors the standard library
+// testing API.
+package utesting
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "regexp"
+ "runtime"
+ "sync"
+ "time"
+)
+
+// Test represents a single test.
+type Test struct {
+ Name string
+ Fn func(*T)
+ Slow bool
+}
+
+// Result is the result of a test execution.
+type Result struct {
+ Name string
+ Failed bool
+ Output string
+ Duration time.Duration
+}
+
+// MatchTests returns the tests whose name matches a regular expression.
+func MatchTests(tests []Test, expr string) []Test {
+ var results []Test
+ re, err := regexp.Compile(expr)
+ if err != nil {
+ return nil
+ }
+ for _, test := range tests {
+ if re.MatchString(test.Name) {
+ results = append(results, test)
+ }
+ }
+ return results
+}
+
+// RunTests executes all given tests in order and returns their results.
+// If the report writer is non-nil, a test report is written to it in real time.
+func RunTests(tests []Test, report io.Writer) []Result {
+ if report == nil {
+ report = io.Discard
+ }
+ results := run(tests, newConsoleOutput(report))
+ fails := CountFailures(results)
+ fmt.Fprintf(report, "%v/%v tests passed.\n", len(tests)-fails, len(tests))
+ return results
+}
+
+// RunTAP runs the given tests and writes Test Anything Protocol output
+// to the report writer.
+func RunTAP(tests []Test, report io.Writer) []Result {
+ return run(tests, newTAP(report, len(tests)))
+}
+
+func run(tests []Test, output testOutput) []Result {
+ var results = make([]Result, len(tests))
+ for i, test := range tests {
+ buffer := new(bytes.Buffer)
+ logOutput := io.MultiWriter(buffer, output)
+
+ output.testStart(test.Name)
+ start := time.Now()
+ results[i].Name = test.Name
+ results[i].Failed = runTest(test, logOutput)
+ results[i].Duration = time.Since(start)
+ results[i].Output = buffer.String()
+ output.testResult(results[i])
+ }
+ return results
+}
+
+// testOutput is implemented by output formats.
+type testOutput interface {
+ testStart(name string)
+ Write([]byte) (int, error)
+ testResult(Result)
+}
+
+// consoleOutput prints test results similarly to go test.
+type consoleOutput struct {
+ out io.Writer
+ indented *indentWriter
+ curTest string
+ wroteHeader bool
+}
+
+func newConsoleOutput(w io.Writer) *consoleOutput {
+ return &consoleOutput{
+ out: w,
+ indented: newIndentWriter(" ", w),
+ }
+}
+
+// testStart signals the start of a new test.
+func (c *consoleOutput) testStart(name string) {
+ c.curTest = name
+ c.wroteHeader = false
+}
+
+// Write handles test log output.
+func (c *consoleOutput) Write(b []byte) (int, error) {
+ if !c.wroteHeader {
+ // This is the first output line from the test. Print a "-- RUN" header.
+ fmt.Fprintln(c.out, "-- RUN", c.curTest)
+ c.wroteHeader = true
+ }
+ return c.indented.Write(b)
+}
+
+// testResult prints the final test result line.
+func (c *consoleOutput) testResult(r Result) {
+ c.indented.flush()
+ pd := r.Duration.Truncate(100 * time.Microsecond)
+ if r.Failed {
+ fmt.Fprintf(c.out, "-- FAIL %s (%v)\n", r.Name, pd)
+ } else {
+ fmt.Fprintf(c.out, "-- OK %s (%v)\n", r.Name, pd)
+ }
+}
+
+// tapOutput produces Test Anything Protocol v13 output.
+type tapOutput struct {
+ out io.Writer
+ indented *indentWriter
+ counter int
+}
+
+func newTAP(out io.Writer, numTests int) *tapOutput {
+ fmt.Fprintf(out, "1..%d\n", numTests)
+ return &tapOutput{
+ out: out,
+ indented: newIndentWriter("# ", out),
+ }
+}
+
+func (t *tapOutput) testStart(name string) {
+ t.counter++
+}
+
+// Write does nothing for TAP because there is no real-time output of test logs.
+func (t *tapOutput) Write(b []byte) (int, error) {
+ return len(b), nil
+}
+
+func (t *tapOutput) testResult(r Result) {
+ status := "ok"
+ if r.Failed {
+ status = "not ok"
+ }
+ fmt.Fprintln(t.out, status, t.counter, r.Name)
+ t.indented.Write([]byte(r.Output))
+ t.indented.flush()
+}
+
+// indentWriter indents all written text.
+type indentWriter struct {
+ out io.Writer
+ indent string
+ inLine bool
+}
+
+func newIndentWriter(indent string, out io.Writer) *indentWriter {
+ return &indentWriter{out: out, indent: indent}
+}
+
+func (w *indentWriter) Write(b []byte) (n int, err error) {
+ for len(b) > 0 {
+ if !w.inLine {
+ if _, err = io.WriteString(w.out, w.indent); err != nil {
+ return n, err
+ }
+ w.inLine = true
+ }
+
+ end := bytes.IndexByte(b, '\n')
+ if end == -1 {
+ nn, err := w.out.Write(b)
+ n += nn
+ return n, err
+ }
+
+ line := b[:end+1]
+ nn, err := w.out.Write(line)
+ n += nn
+ if err != nil {
+ return n, err
+ }
+ b = b[end+1:]
+ w.inLine = false
+ }
+ return n, err
+}
+
+// flush ensures the current line is terminated.
+func (w *indentWriter) flush() {
+ if w.inLine {
+ fmt.Println(w.out)
+ w.inLine = false
+ }
+}
+
+// CountFailures returns the number of failed tests in the result slice.
+func CountFailures(rr []Result) int {
+ count := 0
+ for _, r := range rr {
+ if r.Failed {
+ count++
+ }
+ }
+ return count
+}
+
+// Run executes a single test.
+func Run(test Test) (bool, string) {
+ output := new(bytes.Buffer)
+ failed := runTest(test, output)
+ return failed, output.String()
+}
+
+func runTest(test Test, output io.Writer) bool {
+ t := &T{output: output}
+ done := make(chan struct{})
+ go func() {
+ defer close(done)
+ defer func() {
+ if err := recover(); err != nil {
+ buf := make([]byte, 4096)
+ i := runtime.Stack(buf, false)
+ t.Logf("panic: %v\n\n%s", err, buf[:i])
+ t.Fail()
+ }
+ }()
+ test.Fn(t)
+ }()
+ <-done
+ return t.failed
+}
+
+// T is the value given to the test function. The test can signal failures
+// and log output by calling methods on this object.
+type T struct {
+ mu sync.Mutex
+ failed bool
+ output io.Writer
+}
+
+// Helper exists for compatibility with testing.T.
+func (t *T) Helper() {}
+
+// FailNow marks the test as having failed and stops its execution by calling
+// runtime.Goexit (which then runs all deferred calls in the current goroutine).
+func (t *T) FailNow() {
+ t.Fail()
+ runtime.Goexit()
+}
+
+// Fail marks the test as having failed but continues execution.
+func (t *T) Fail() {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ t.failed = true
+}
+
+// Failed reports whether the test has failed.
+func (t *T) Failed() bool {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ return t.failed
+}
+
+// Log formats its arguments using default formatting, analogous to Println, and records
+// the text in the error log.
+func (t *T) Log(vs ...interface{}) {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ fmt.Fprintln(t.output, vs...)
+}
+
+// Logf formats its arguments according to the format, analogous to Printf, and records
+// the text in the error log. A final newline is added if not provided.
+func (t *T) Logf(format string, vs ...interface{}) {
+ t.mu.Lock()
+ defer t.mu.Unlock()
+ if len(format) == 0 || format[len(format)-1] != '\n' {
+ format += "\n"
+ }
+ fmt.Fprintf(t.output, format, vs...)
+}
+
+// Error is equivalent to Log followed by Fail.
+func (t *T) Error(vs ...interface{}) {
+ t.Log(vs...)
+ t.Fail()
+}
+
+// Errorf is equivalent to Logf followed by Fail.
+func (t *T) Errorf(format string, vs ...interface{}) {
+ t.Logf(format, vs...)
+ t.Fail()
+}
+
+// Fatal is equivalent to Log followed by FailNow.
+func (t *T) Fatal(vs ...interface{}) {
+ t.Log(vs...)
+ t.FailNow()
+}
+
+// Fatalf is equivalent to Logf followed by FailNow.
+func (t *T) Fatalf(format string, vs ...interface{}) {
+ t.Logf(format, vs...)
+ t.FailNow()
+}
diff --git a/internal/utesting/utesting_test.go b/internal/utesting/utesting_test.go
new file mode 100644
index 000000000000..526d36bab1e3
--- /dev/null
+++ b/internal/utesting/utesting_test.go
@@ -0,0 +1,145 @@
+// Copyright 2020 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 .
+
+package utesting
+
+import (
+ "bytes"
+ "regexp"
+ "strings"
+ "testing"
+)
+
+func TestTest(t *testing.T) {
+ t.Parallel()
+
+ tests := []Test{
+ {
+ Name: "successful test",
+ Fn: func(t *T) {},
+ },
+ {
+ Name: "failing test",
+ Fn: func(t *T) {
+ t.Log("output")
+ t.Error("failed")
+ },
+ },
+ {
+ Name: "panicking test",
+ Fn: func(t *T) {
+ panic("oh no")
+ },
+ },
+ }
+ results := RunTests(tests, nil)
+
+ if results[0].Failed || results[0].Output != "" {
+ t.Fatalf("wrong result for successful test: %#v", results[0])
+ }
+ if !results[1].Failed || results[1].Output != "output\nfailed\n" {
+ t.Fatalf("wrong result for failing test: %#v", results[1])
+ }
+ if !results[2].Failed || !strings.HasPrefix(results[2].Output, "panic: oh no\n") {
+ t.Fatalf("wrong result for panicking test: %#v", results[2])
+ }
+}
+
+var outputTests = []Test{
+ {
+ Name: "TestWithLogs",
+ Fn: func(t *T) {
+ t.Log("output line 1")
+ t.Log("output line 2\noutput line 3")
+ },
+ },
+ {
+ Name: "TestNoLogs",
+ Fn: func(t *T) {},
+ },
+ {
+ Name: "FailWithLogs",
+ Fn: func(t *T) {
+ t.Log("output line 1")
+ t.Error("failed 1")
+ },
+ },
+ {
+ Name: "FailMessage",
+ Fn: func(t *T) {
+ t.Error("failed 2")
+ },
+ },
+ {
+ Name: "FailNoOutput",
+ Fn: func(t *T) {
+ t.Fail()
+ },
+ },
+}
+
+func TestOutput(t *testing.T) {
+ t.Parallel()
+
+ var buf bytes.Buffer
+ RunTests(outputTests, &buf)
+
+ want := regexp.MustCompile(`
+^-- RUN TestWithLogs
+ output line 1
+ output line 2
+ output line 3
+-- OK TestWithLogs \([^)]+\)
+-- OK TestNoLogs \([^)]+\)
+-- RUN FailWithLogs
+ output line 1
+ failed 1
+-- FAIL FailWithLogs \([^)]+\)
+-- RUN FailMessage
+ failed 2
+-- FAIL FailMessage \([^)]+\)
+-- FAIL FailNoOutput \([^)]+\)
+2/5 tests passed.
+$`[1:])
+ if !want.MatchString(buf.String()) {
+ t.Fatalf("output does not match: %q", buf.String())
+ }
+}
+
+func TestOutputTAP(t *testing.T) {
+ t.Parallel()
+
+ var buf bytes.Buffer
+ RunTAP(outputTests, &buf)
+
+ want := `
+1..5
+ok 1 TestWithLogs
+# output line 1
+# output line 2
+# output line 3
+ok 2 TestNoLogs
+not ok 3 FailWithLogs
+# output line 1
+# failed 1
+not ok 4 FailMessage
+# failed 2
+not ok 5 FailNoOutput
+`
+ if buf.String() != want[1:] {
+ t.Fatalf("output does not match: %q", buf.String())
+ }
+}
From 83649adc83f25cc39e0fca30c7f0a960e62b6a4e Mon Sep 17 00:00:00 2001
From: Felix Lange
Date: Wed, 14 Oct 2020 12:28:17 +0200
Subject: [PATCH 12/14] feat(p2p/discover): implement v5.1 wire protocol #21647
This change implements the Discovery v5.1 wire protocol and
also adds an interactive test suite for this protocol.
---
cmd/devp2p/internal/v5test/discv5tests.go | 377 ++++++++++
cmd/devp2p/internal/v5test/framework.go | 263 +++++++
p2p/discover/node.go | 5 +-
p2p/discover/table_util_test.go | 17 +-
p2p/discover/v4_lookup_test.go | 16 +-
p2p/discover/v5_encoding.go | 659 ------------------
p2p/discover/v5_encoding_test.go | 373 ----------
p2p/discover/v5_udp.go | 463 ++++++------
p2p/discover/v5_udp_test.go | 331 ++++++---
p2p/discover/v5wire/crypto.go | 180 +++++
p2p/discover/v5wire/crypto_test.go | 124 ++++
p2p/discover/v5wire/encoding.go | 648 +++++++++++++++++
p2p/discover/v5wire/encoding_test.go | 635 +++++++++++++++++
p2p/discover/v5wire/msg.go | 249 +++++++
.../{v5_session.go => v5wire/session.go} | 81 ++-
.../testdata/v5.1-ping-handshake-enr.txt | 27 +
.../v5wire/testdata/v5.1-ping-handshake.txt | 23 +
.../v5wire/testdata/v5.1-ping-message.txt | 10 +
.../v5wire/testdata/v5.1-whoareyou.txt | 9 +
p2p/netutil/error.go | 10 +
p2p/netutil/error_test.go | 30 +
21 files changed, 3121 insertions(+), 1409 deletions(-)
create mode 100644 cmd/devp2p/internal/v5test/discv5tests.go
create mode 100644 cmd/devp2p/internal/v5test/framework.go
delete mode 100644 p2p/discover/v5_encoding.go
delete mode 100644 p2p/discover/v5_encoding_test.go
create mode 100644 p2p/discover/v5wire/crypto.go
create mode 100644 p2p/discover/v5wire/crypto_test.go
create mode 100644 p2p/discover/v5wire/encoding.go
create mode 100644 p2p/discover/v5wire/encoding_test.go
create mode 100644 p2p/discover/v5wire/msg.go
rename p2p/discover/{v5_session.go => v5wire/session.go} (58%)
create mode 100644 p2p/discover/v5wire/testdata/v5.1-ping-handshake-enr.txt
create mode 100644 p2p/discover/v5wire/testdata/v5.1-ping-handshake.txt
create mode 100644 p2p/discover/v5wire/testdata/v5.1-ping-message.txt
create mode 100644 p2p/discover/v5wire/testdata/v5.1-whoareyou.txt
diff --git a/cmd/devp2p/internal/v5test/discv5tests.go b/cmd/devp2p/internal/v5test/discv5tests.go
new file mode 100644
index 000000000000..f622b080766d
--- /dev/null
+++ b/cmd/devp2p/internal/v5test/discv5tests.go
@@ -0,0 +1,377 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see .
+
+package v5test
+
+import (
+ "bytes"
+ "net"
+ "sync"
+ "time"
+
+ "github.com/XinFinOrg/XDPoSChain/internal/utesting"
+ "github.com/XinFinOrg/XDPoSChain/p2p/discover/v5wire"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enode"
+ "github.com/XinFinOrg/XDPoSChain/p2p/netutil"
+)
+
+// Suite is the discv5 test suite.
+type Suite struct {
+ Dest *enode.Node
+ Listen1, Listen2 string // listening addresses
+}
+
+func (s *Suite) listen1(log logger) (*conn, net.PacketConn) {
+ c := newConn(s.Dest, log)
+ l := c.listen(s.Listen1)
+ return c, l
+}
+
+func (s *Suite) listen2(log logger) (*conn, net.PacketConn, net.PacketConn) {
+ c := newConn(s.Dest, log)
+ l1, l2 := c.listen(s.Listen1), c.listen(s.Listen2)
+ return c, l1, l2
+}
+
+func (s *Suite) AllTests() []utesting.Test {
+ return []utesting.Test{
+ {Name: "Ping", Fn: s.TestPing},
+ {Name: "PingLargeRequestID", Fn: s.TestPingLargeRequestID},
+ {Name: "PingMultiIP", Fn: s.TestPingMultiIP},
+ {Name: "PingHandshakeInterrupted", Fn: s.TestPingHandshakeInterrupted},
+ {Name: "TalkRequest", Fn: s.TestTalkRequest},
+ {Name: "FindnodeZeroDistance", Fn: s.TestFindnodeZeroDistance},
+ {Name: "FindnodeResults", Fn: s.TestFindnodeResults},
+ }
+}
+
+// This test sends PING and expects a PONG response.
+func (s *Suite) TestPing(t *utesting.T) {
+ conn, l1 := s.listen1(t)
+ defer conn.close()
+
+ ping := &v5wire.Ping{ReqID: conn.nextReqID()}
+ switch resp := conn.reqresp(l1, ping).(type) {
+ case *v5wire.Pong:
+ checkPong(t, resp, ping, l1)
+ default:
+ t.Fatal("expected PONG, got", resp.Name())
+ }
+}
+
+func checkPong(t *utesting.T, pong *v5wire.Pong, ping *v5wire.Ping, c net.PacketConn) {
+ if !bytes.Equal(pong.ReqID, ping.ReqID) {
+ t.Fatalf("wrong request ID %x in PONG, want %x", pong.ReqID, ping.ReqID)
+ }
+ if !pong.ToIP.Equal(laddr(c).IP) {
+ t.Fatalf("wrong destination IP %v in PONG, want %v", pong.ToIP, laddr(c).IP)
+ }
+ if int(pong.ToPort) != laddr(c).Port {
+ t.Fatalf("wrong destination port %v in PONG, want %v", pong.ToPort, laddr(c).Port)
+ }
+}
+
+// This test sends PING with a 9-byte request ID, which isn't allowed by the spec.
+// The remote node should not respond.
+func (s *Suite) TestPingLargeRequestID(t *utesting.T) {
+ conn, l1 := s.listen1(t)
+ defer conn.close()
+
+ ping := &v5wire.Ping{ReqID: make([]byte, 9)}
+ switch resp := conn.reqresp(l1, ping).(type) {
+ case *v5wire.Pong:
+ t.Errorf("PONG response with unknown request ID %x", resp.ReqID)
+ case *readError:
+ if resp.err == v5wire.ErrInvalidReqID {
+ t.Error("response with oversized request ID")
+ } else if !netutil.IsTimeout(resp.err) {
+ t.Error(resp)
+ }
+ }
+}
+
+// In this test, a session is established from one IP as usual. The session is then reused
+// on another IP, which shouldn't work. The remote node should respond with WHOAREYOU for
+// the attempt from a different IP.
+func (s *Suite) TestPingMultiIP(t *utesting.T) {
+ conn, l1, l2 := s.listen2(t)
+ defer conn.close()
+
+ // Create the session on l1.
+ ping := &v5wire.Ping{ReqID: conn.nextReqID()}
+ resp := conn.reqresp(l1, ping)
+ if resp.Kind() != v5wire.PongMsg {
+ t.Fatal("expected PONG, got", resp)
+ }
+ checkPong(t, resp.(*v5wire.Pong), ping, l1)
+
+ // Send on l2. This reuses the session because there is only one codec.
+ ping2 := &v5wire.Ping{ReqID: conn.nextReqID()}
+ conn.write(l2, ping2, nil)
+ switch resp := conn.read(l2).(type) {
+ case *v5wire.Pong:
+ t.Fatalf("remote responded to PING from %v for session on IP %v", laddr(l2).IP, laddr(l1).IP)
+ case *v5wire.Whoareyou:
+ t.Logf("got WHOAREYOU for new session as expected")
+ resp.Node = s.Dest
+ conn.write(l2, ping2, resp)
+ default:
+ t.Fatal("expected WHOAREYOU, got", resp)
+ }
+
+ // Catch the PONG on l2.
+ switch resp := conn.read(l2).(type) {
+ case *v5wire.Pong:
+ checkPong(t, resp, ping2, l2)
+ default:
+ t.Fatal("expected PONG, got", resp)
+ }
+
+ // Try on l1 again.
+ ping3 := &v5wire.Ping{ReqID: conn.nextReqID()}
+ conn.write(l1, ping3, nil)
+ switch resp := conn.read(l1).(type) {
+ case *v5wire.Pong:
+ t.Fatalf("remote responded to PING from %v for session on IP %v", laddr(l1).IP, laddr(l2).IP)
+ case *v5wire.Whoareyou:
+ t.Logf("got WHOAREYOU for new session as expected")
+ default:
+ t.Fatal("expected WHOAREYOU, got", resp)
+ }
+}
+
+// This test starts a handshake, but doesn't finish it and sends a second ordinary message
+// packet instead of a handshake message packet. The remote node should respond with
+// another WHOAREYOU challenge for the second packet.
+func (s *Suite) TestPingHandshakeInterrupted(t *utesting.T) {
+ conn, l1 := s.listen1(t)
+ defer conn.close()
+
+ // First PING triggers challenge.
+ ping := &v5wire.Ping{ReqID: conn.nextReqID()}
+ conn.write(l1, ping, nil)
+ switch resp := conn.read(l1).(type) {
+ case *v5wire.Whoareyou:
+ t.Logf("got WHOAREYOU for PING")
+ default:
+ t.Fatal("expected WHOAREYOU, got", resp)
+ }
+
+ // Send second PING.
+ ping2 := &v5wire.Ping{ReqID: conn.nextReqID()}
+ switch resp := conn.reqresp(l1, ping2).(type) {
+ case *v5wire.Pong:
+ checkPong(t, resp, ping2, l1)
+ default:
+ t.Fatal("expected WHOAREYOU, got", resp)
+ }
+}
+
+// This test sends TALKREQ and expects an empty TALKRESP response.
+func (s *Suite) TestTalkRequest(t *utesting.T) {
+ conn, l1 := s.listen1(t)
+ defer conn.close()
+
+ // Non-empty request ID.
+ id := conn.nextReqID()
+ resp := conn.reqresp(l1, &v5wire.TalkRequest{ReqID: id, Protocol: "test-protocol"})
+ switch resp := resp.(type) {
+ case *v5wire.TalkResponse:
+ if !bytes.Equal(resp.ReqID, id) {
+ t.Fatalf("wrong request ID %x in TALKRESP, want %x", resp.ReqID, id)
+ }
+ if len(resp.Message) > 0 {
+ t.Fatalf("non-empty message %x in TALKRESP", resp.Message)
+ }
+ default:
+ t.Fatal("expected TALKRESP, got", resp.Name())
+ }
+
+ // Empty request ID.
+ resp = conn.reqresp(l1, &v5wire.TalkRequest{Protocol: "test-protocol"})
+ switch resp := resp.(type) {
+ case *v5wire.TalkResponse:
+ if len(resp.ReqID) > 0 {
+ t.Fatalf("wrong request ID %x in TALKRESP, want empty byte array", resp.ReqID)
+ }
+ if len(resp.Message) > 0 {
+ t.Fatalf("non-empty message %x in TALKRESP", resp.Message)
+ }
+ default:
+ t.Fatal("expected TALKRESP, got", resp.Name())
+ }
+}
+
+// This test checks that the remote node returns itself for FINDNODE with distance zero.
+func (s *Suite) TestFindnodeZeroDistance(t *utesting.T) {
+ conn, l1 := s.listen1(t)
+ defer conn.close()
+
+ nodes, err := conn.findnode(l1, []uint{0})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(nodes) != 1 {
+ t.Fatalf("remote returned more than one node for FINDNODE [0]")
+ }
+ if nodes[0].ID() != conn.remote.ID() {
+ t.Errorf("ID of response node is %v, want %v", nodes[0].ID(), conn.remote.ID())
+ }
+}
+
+// In this test, multiple nodes ping the node under test. After waiting for them to be
+// accepted into the remote table, the test checks that they are returned by FINDNODE.
+func (s *Suite) TestFindnodeResults(t *utesting.T) {
+ // Create bystanders.
+ nodes := make([]*bystander, 5)
+ added := make(chan enode.ID, len(nodes))
+ for i := range nodes {
+ nodes[i] = newBystander(t, s, added)
+ defer nodes[i].close()
+ }
+
+ // Get them added to the remote table.
+ timeout := 60 * time.Second
+ timeoutCh := time.After(timeout)
+ for count := 0; count < len(nodes); {
+ select {
+ case id := <-added:
+ t.Logf("bystander node %v added to remote table", id)
+ count++
+ case <-timeoutCh:
+ t.Errorf("remote added %d bystander nodes in %v, need %d to continue", count, timeout, len(nodes))
+ t.Logf("this can happen if the node has a non-empty table from previous runs")
+ return
+ }
+ }
+ t.Logf("all %d bystander nodes were added", len(nodes))
+
+ // Collect our nodes by distance.
+ var dists []uint
+ expect := make(map[enode.ID]*enode.Node)
+ for _, bn := range nodes {
+ n := bn.conn.localNode.Node()
+ expect[n.ID()] = n
+ d := uint(enode.LogDist(n.ID(), s.Dest.ID()))
+ if !containsUint(dists, d) {
+ dists = append(dists, d)
+ }
+ }
+
+ // Send FINDNODE for all distances.
+ conn, l1 := s.listen1(t)
+ defer conn.close()
+ foundNodes, err := conn.findnode(l1, dists)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Logf("remote returned %d nodes for distance list %v", len(foundNodes), dists)
+ for _, n := range foundNodes {
+ delete(expect, n.ID())
+ }
+ if len(expect) > 0 {
+ t.Errorf("missing %d nodes in FINDNODE result", len(expect))
+ t.Logf("this can happen if the test is run multiple times in quick succession")
+ t.Logf("and the remote node hasn't removed dead nodes from previous runs yet")
+ } else {
+ t.Logf("all %d expected nodes were returned", len(nodes))
+ }
+}
+
+// A bystander is a node whose only purpose is filling a spot in the remote table.
+type bystander struct {
+ dest *enode.Node
+ conn *conn
+ l net.PacketConn
+
+ addedCh chan enode.ID
+ done sync.WaitGroup
+}
+
+func newBystander(t *utesting.T, s *Suite, added chan enode.ID) *bystander {
+ conn, l := s.listen1(t)
+ conn.setEndpoint(l) // bystander nodes need IP/port to get pinged
+ bn := &bystander{
+ conn: conn,
+ l: l,
+ dest: s.Dest,
+ addedCh: added,
+ }
+ bn.done.Add(1)
+ go bn.loop()
+ return bn
+}
+
+// id returns the node ID of the bystander.
+func (bn *bystander) id() enode.ID {
+ return bn.conn.localNode.ID()
+}
+
+// close shuts down loop.
+func (bn *bystander) close() {
+ bn.conn.close()
+ bn.done.Wait()
+}
+
+// loop answers packets from the remote node until quit.
+func (bn *bystander) loop() {
+ defer bn.done.Done()
+
+ var (
+ lastPing time.Time
+ wasAdded bool
+ )
+ for {
+ // Ping the remote node.
+ if !wasAdded && time.Since(lastPing) > 10*time.Second {
+ bn.conn.reqresp(bn.l, &v5wire.Ping{
+ ReqID: bn.conn.nextReqID(),
+ ENRSeq: bn.dest.Seq(),
+ })
+ lastPing = time.Now()
+ }
+ // Answer packets.
+ switch p := bn.conn.read(bn.l).(type) {
+ case *v5wire.Ping:
+ bn.conn.write(bn.l, &v5wire.Pong{
+ ReqID: p.ReqID,
+ ENRSeq: bn.conn.localNode.Seq(),
+ ToIP: bn.dest.IP(),
+ ToPort: uint16(bn.dest.UDP()),
+ }, nil)
+ wasAdded = true
+ bn.notifyAdded()
+ case *v5wire.Findnode:
+ bn.conn.write(bn.l, &v5wire.Nodes{ReqID: p.ReqID, Total: 1}, nil)
+ wasAdded = true
+ bn.notifyAdded()
+ case *v5wire.TalkRequest:
+ bn.conn.write(bn.l, &v5wire.TalkResponse{ReqID: p.ReqID}, nil)
+ case *readError:
+ if !netutil.IsTemporaryError(p.err) {
+ bn.conn.logf("shutting down: %v", p.err)
+ return
+ }
+ }
+ }
+}
+
+func (bn *bystander) notifyAdded() {
+ if bn.addedCh != nil {
+ bn.addedCh <- bn.id()
+ bn.addedCh = nil
+ }
+}
diff --git a/cmd/devp2p/internal/v5test/framework.go b/cmd/devp2p/internal/v5test/framework.go
new file mode 100644
index 000000000000..6467b3a8bc48
--- /dev/null
+++ b/cmd/devp2p/internal/v5test/framework.go
@@ -0,0 +1,263 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see .
+
+package v5test
+
+import (
+ "bytes"
+ "crypto/ecdsa"
+ "encoding/binary"
+ "fmt"
+ "net"
+ "time"
+
+ "github.com/XinFinOrg/XDPoSChain/common/mclock"
+ "github.com/XinFinOrg/XDPoSChain/crypto"
+ "github.com/XinFinOrg/XDPoSChain/p2p/discover/v5wire"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enode"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enr"
+)
+
+// readError represents an error during packet reading.
+// This exists to facilitate type-switching on the result of conn.read.
+type readError struct {
+ err error
+}
+
+func (p *readError) Kind() byte { return 99 }
+func (p *readError) Name() string { return fmt.Sprintf("error: %v", p.err) }
+func (p *readError) Error() string { return p.err.Error() }
+func (p *readError) Unwrap() error { return p.err }
+func (p *readError) RequestID() []byte { return nil }
+func (p *readError) SetRequestID([]byte) {}
+
+// readErrorf creates a readError with the given text.
+func readErrorf(format string, args ...interface{}) *readError {
+ return &readError{fmt.Errorf(format, args...)}
+}
+
+// This is the response timeout used in tests.
+const waitTime = 300 * time.Millisecond
+
+// conn is a connection to the node under test.
+type conn struct {
+ localNode *enode.LocalNode
+ localKey *ecdsa.PrivateKey
+ remote *enode.Node
+ remoteAddr *net.UDPAddr
+ listeners []net.PacketConn
+
+ log logger
+ codec *v5wire.Codec
+ lastRequest v5wire.Packet
+ lastChallenge *v5wire.Whoareyou
+ idCounter uint32
+}
+
+type logger interface {
+ Logf(string, ...interface{})
+}
+
+// newConn sets up a connection to the given node.
+func newConn(dest *enode.Node, log logger) *conn {
+ key, err := crypto.GenerateKey()
+ if err != nil {
+ panic(err)
+ }
+ db, err := enode.OpenDB("")
+ if err != nil {
+ panic(err)
+ }
+ ln := enode.NewLocalNode(db, key)
+
+ return &conn{
+ localKey: key,
+ localNode: ln,
+ remote: dest,
+ remoteAddr: &net.UDPAddr{IP: dest.IP(), Port: dest.UDP()},
+ codec: v5wire.NewCodec(ln, key, mclock.System{}),
+ log: log,
+ }
+}
+
+func (tc *conn) setEndpoint(c net.PacketConn) {
+ tc.localNode.SetStaticIP(laddr(c).IP)
+ tc.localNode.SetFallbackUDP(laddr(c).Port)
+}
+
+func (tc *conn) listen(ip string) net.PacketConn {
+ l, err := net.ListenPacket("udp", fmt.Sprintf("%v:0", ip))
+ if err != nil {
+ panic(err)
+ }
+ tc.listeners = append(tc.listeners, l)
+ return l
+}
+
+// close shuts down all listeners and the local node.
+func (tc *conn) close() {
+ for _, l := range tc.listeners {
+ l.Close()
+ }
+ tc.localNode.Database().Close()
+}
+
+// nextReqID creates a request id.
+func (tc *conn) nextReqID() []byte {
+ id := make([]byte, 4)
+ tc.idCounter++
+ binary.BigEndian.PutUint32(id, tc.idCounter)
+ return id
+}
+
+// reqresp performs a request/response interaction on the given connection.
+// The request is retried if a handshake is requested.
+func (tc *conn) reqresp(c net.PacketConn, req v5wire.Packet) v5wire.Packet {
+ reqnonce := tc.write(c, req, nil)
+ switch resp := tc.read(c).(type) {
+ case *v5wire.Whoareyou:
+ if resp.Nonce != reqnonce {
+ return readErrorf("wrong nonce %x in WHOAREYOU (want %x)", resp.Nonce[:], reqnonce[:])
+ }
+ resp.Node = tc.remote
+ tc.write(c, req, resp)
+ return tc.read(c)
+ default:
+ return resp
+ }
+}
+
+// findnode sends a FINDNODE request and waits for its responses.
+func (tc *conn) findnode(c net.PacketConn, dists []uint) ([]*enode.Node, error) {
+ var (
+ findnode = &v5wire.Findnode{ReqID: tc.nextReqID(), Distances: dists}
+ reqnonce = tc.write(c, findnode, nil)
+ first = true
+ total uint8
+ results []*enode.Node
+ )
+ for n := 1; n > 0; {
+ switch resp := tc.read(c).(type) {
+ case *v5wire.Whoareyou:
+ // Handle handshake.
+ if resp.Nonce == reqnonce {
+ resp.Node = tc.remote
+ tc.write(c, findnode, resp)
+ } else {
+ return nil, fmt.Errorf("unexpected WHOAREYOU (nonce %x), waiting for NODES", resp.Nonce[:])
+ }
+ case *v5wire.Ping:
+ // Handle ping from remote.
+ tc.write(c, &v5wire.Pong{
+ ReqID: resp.ReqID,
+ ENRSeq: tc.localNode.Seq(),
+ }, nil)
+ case *v5wire.Nodes:
+ // Got NODES! Check request ID.
+ if !bytes.Equal(resp.ReqID, findnode.ReqID) {
+ return nil, fmt.Errorf("NODES response has wrong request id %x", resp.ReqID)
+ }
+ // Check total count. It should be greater than one
+ // and needs to be the same across all responses.
+ if first {
+ if resp.Total == 0 || resp.Total > 6 {
+ return nil, fmt.Errorf("invalid NODES response 'total' %d (not in (0,7))", resp.Total)
+ }
+ total = resp.Total
+ n = int(total) - 1
+ first = false
+ } else {
+ n--
+ if resp.Total != total {
+ return nil, fmt.Errorf("invalid NODES response 'total' %d (!= %d)", resp.Total, total)
+ }
+ }
+ // Check nodes.
+ nodes, err := checkRecords(resp.Nodes)
+ if err != nil {
+ return nil, fmt.Errorf("invalid node in NODES response: %v", err)
+ }
+ results = append(results, nodes...)
+ default:
+ return nil, fmt.Errorf("expected NODES, got %v", resp)
+ }
+ }
+ return results, nil
+}
+
+// write sends a packet on the given connection.
+func (tc *conn) write(c net.PacketConn, p v5wire.Packet, challenge *v5wire.Whoareyou) v5wire.Nonce {
+ packet, nonce, err := tc.codec.Encode(tc.remote.ID(), tc.remoteAddr.String(), p, challenge)
+ if err != nil {
+ panic(fmt.Errorf("can't encode %v packet: %v", p.Name(), err))
+ }
+ if _, err := c.WriteTo(packet, tc.remoteAddr); err != nil {
+ tc.logf("Can't send %s: %v", p.Name(), err)
+ } else {
+ tc.logf(">> %s", p.Name())
+ }
+ return nonce
+}
+
+// read waits for an incoming packet on the given connection.
+func (tc *conn) read(c net.PacketConn) v5wire.Packet {
+ buf := make([]byte, 1280)
+ if err := c.SetReadDeadline(time.Now().Add(waitTime)); err != nil {
+ return &readError{err}
+ }
+ n, fromAddr, err := c.ReadFrom(buf)
+ if err != nil {
+ return &readError{err}
+ }
+ _, _, p, err := tc.codec.Decode(buf[:n], fromAddr.String())
+ if err != nil {
+ return &readError{err}
+ }
+ tc.logf("<< %s", p.Name())
+ return p
+}
+
+// logf prints to the test log.
+func (tc *conn) logf(format string, args ...interface{}) {
+ if tc.log != nil {
+ tc.log.Logf("(%s) %s", tc.localNode.ID().TerminalString(), fmt.Sprintf(format, args...))
+ }
+}
+
+func laddr(c net.PacketConn) *net.UDPAddr {
+ return c.LocalAddr().(*net.UDPAddr)
+}
+
+func checkRecords(records []*enr.Record) ([]*enode.Node, error) {
+ nodes := make([]*enode.Node, len(records))
+ for i := range records {
+ n, err := enode.New(enode.ValidSchemes, records[i])
+ if err != nil {
+ return nil, err
+ }
+ nodes[i] = n
+ }
+ return nodes, nil
+}
+
+func containsUint(ints []uint, x uint) bool {
+ for i := range ints {
+ if ints[i] == x {
+ return true
+ }
+ }
+ return false
+}
diff --git a/p2p/discover/node.go b/p2p/discover/node.go
index ac118149f5d7..727a11ed3135 100644
--- a/p2p/discover/node.go
+++ b/p2p/discover/node.go
@@ -46,7 +46,10 @@ func encodePubkey(key *ecdsa.PublicKey) encPubkey {
return e
}
-func decodePubkey(curve elliptic.Curve, e encPubkey) (*ecdsa.PublicKey, error) {
+func decodePubkey(curve elliptic.Curve, e []byte) (*ecdsa.PublicKey, error) {
+ if len(e) != len(encPubkey{}) {
+ return nil, errors.New("wrong size public key data")
+ }
p := &ecdsa.PublicKey{Curve: curve, X: new(big.Int), Y: new(big.Int)}
half := len(e) / 2
p.X.SetBytes(e[:half])
diff --git a/p2p/discover/table_util_test.go b/p2p/discover/table_util_test.go
index e241733f3960..a0138cb254d8 100644
--- a/p2p/discover/table_util_test.go
+++ b/p2p/discover/table_util_test.go
@@ -146,7 +146,6 @@ func (t *pingRecorder) updateRecord(n *enode.Node) {
func (t *pingRecorder) Self() *enode.Node { return nullNode }
func (t *pingRecorder) lookupSelf() []*enode.Node { return nil }
func (t *pingRecorder) lookupRandom() []*enode.Node { return nil }
-func (t *pingRecorder) close() {}
// ping simulates a ping request.
func (t *pingRecorder) ping(n *enode.Node) (seq uint64, err error) {
@@ -188,15 +187,17 @@ func hasDuplicates(slice []*node) bool {
return false
}
+// checkNodesEqual checks whether the two given node lists contain the same nodes.
func checkNodesEqual(got, want []*enode.Node) error {
- if len(got) == len(want) {
- for i := range got {
- if !nodeEqual(got[i], want[i]) {
- goto NotEqual
- }
- return nil
+ if len(got) != len(want) {
+ goto NotEqual
+ }
+ for i := range got {
+ if !nodeEqual(got[i], want[i]) {
+ goto NotEqual
}
}
+ return nil
NotEqual:
output := new(bytes.Buffer)
@@ -227,6 +228,7 @@ func sortedByDistanceTo(distbase enode.ID, slice []*node) bool {
})
}
+// hexEncPrivkey decodes h as a private key.
func hexEncPrivkey(h string) *ecdsa.PrivateKey {
b, err := hex.DecodeString(h)
if err != nil {
@@ -239,6 +241,7 @@ func hexEncPrivkey(h string) *ecdsa.PrivateKey {
return key
}
+// hexEncPubkey decodes h as a public key.
func hexEncPubkey(h string) (ret encPubkey) {
b, err := hex.DecodeString(h)
if err != nil {
diff --git a/p2p/discover/v4_lookup_test.go b/p2p/discover/v4_lookup_test.go
index 530e449192ef..278dff9673a2 100644
--- a/p2p/discover/v4_lookup_test.go
+++ b/p2p/discover/v4_lookup_test.go
@@ -34,7 +34,7 @@ func TestUDPv4_Lookup(t *testing.T) {
test := newUDPTest(t)
// Lookup on empty table returns no nodes.
- targetKey, _ := decodePubkey(crypto.S256(), lookupTestnet.target)
+ targetKey, _ := decodePubkey(crypto.S256(), lookupTestnet.target[:])
if results := test.udp.LookupPubkey(targetKey); len(results) > 0 {
t.Fatalf("lookup on empty table returned %d results: %#v", len(results), results)
}
@@ -279,17 +279,21 @@ func (tn *preminedTestnet) nodesAtDistance(dist int) []v4wire.Node {
return result
}
-func (tn *preminedTestnet) neighborsAtDistance(base *enode.Node, distance uint, elems int) []*enode.Node {
- nodes := nodesByDistance{target: base.ID()}
+func (tn *preminedTestnet) neighborsAtDistances(base *enode.Node, distances []uint, elems int) []*enode.Node {
+ var result []*enode.Node
for d := range lookupTestnet.dists {
for i := range lookupTestnet.dists[d] {
n := lookupTestnet.node(d, i)
- if uint(enode.LogDist(n.ID(), base.ID())) == distance {
- nodes.push(wrapNode(n), elems)
+ d := enode.LogDist(base.ID(), n.ID())
+ if containsUint(uint(d), distances) {
+ result = append(result, n)
+ if len(result) >= elems {
+ return result
+ }
}
}
}
- return unwrapNodes(nodes.entries)
+ return result
}
func (tn *preminedTestnet) closest(n int) (nodes []*enode.Node) {
diff --git a/p2p/discover/v5_encoding.go b/p2p/discover/v5_encoding.go
deleted file mode 100644
index 17c4c977c861..000000000000
--- a/p2p/discover/v5_encoding.go
+++ /dev/null
@@ -1,659 +0,0 @@
-// Copyright 2019 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 .
-
-package discover
-
-import (
- "bytes"
- "crypto/aes"
- "crypto/cipher"
- "crypto/ecdsa"
- "crypto/elliptic"
- crand "crypto/rand"
- "crypto/sha256"
- "errors"
- "fmt"
- "hash"
- "net"
- "time"
-
- "github.com/XinFinOrg/XDPoSChain/common/math"
- "github.com/XinFinOrg/XDPoSChain/common/mclock"
- "github.com/XinFinOrg/XDPoSChain/crypto"
- "github.com/XinFinOrg/XDPoSChain/p2p/enode"
- "github.com/XinFinOrg/XDPoSChain/p2p/enr"
- "github.com/XinFinOrg/XDPoSChain/rlp"
- "golang.org/x/crypto/hkdf"
-)
-
-// TODO concurrent WHOAREYOU tie-breaker
-// TODO deal with WHOAREYOU amplification factor (min packet size?)
-// TODO add counter to nonce
-// TODO rehandshake after X packets
-
-// Discovery v5 packet types.
-const (
- p_pingV5 byte = iota + 1
- p_pongV5
- p_findnodeV5
- p_nodesV5
- p_requestTicketV5
- p_ticketV5
- p_regtopicV5
- p_regconfirmationV5
- p_topicqueryV5
- p_unknownV5 = byte(255) // any non-decryptable packet
- p_whoareyouV5 = byte(254) // the WHOAREYOU packet
-)
-
-// Discovery v5 packet structures.
-type (
- // unknownV5 represents any packet that can't be decrypted.
- unknownV5 struct {
- AuthTag []byte
- }
-
- // WHOAREYOU contains the handshake challenge.
- whoareyouV5 struct {
- AuthTag []byte
- IDNonce [32]byte // To be signed by recipient.
- RecordSeq uint64 // ENR sequence number of recipient
-
- node *enode.Node
- sent mclock.AbsTime
- }
-
- // PING is sent during liveness checks.
- pingV5 struct {
- ReqID []byte
- ENRSeq uint64
- }
-
- // PONG is the reply to PING.
- pongV5 struct {
- ReqID []byte
- ENRSeq uint64
- ToIP net.IP // These fields should mirror the UDP envelope address of the ping
- ToPort uint16 // packet, which provides a way to discover the the external address (after NAT).
- }
-
- // FINDNODE is a query for nodes in the given bucket.
- findnodeV5 struct {
- ReqID []byte
- Distance uint
- }
-
- // NODES is the reply to FINDNODE and TOPICQUERY.
- nodesV5 struct {
- ReqID []byte
- Total uint8
- Nodes []*enr.Record
- }
-
- // REQUESTTICKET requests a ticket for a topic queue.
- requestTicketV5 struct {
- ReqID []byte
- Topic []byte
- }
-
- // TICKET is the response to REQUESTTICKET.
- ticketV5 struct {
- ReqID []byte
- Ticket []byte
- }
-
- // REGTOPIC registers the sender in a topic queue using a ticket.
- regtopicV5 struct {
- ReqID []byte
- Ticket []byte
- ENR *enr.Record
- }
-
- // REGCONFIRMATION is the reply to REGTOPIC.
- regconfirmationV5 struct {
- ReqID []byte
- Registered bool
- }
-
- // TOPICQUERY asks for nodes with the given topic.
- topicqueryV5 struct {
- ReqID []byte
- Topic []byte
- }
-)
-
-const (
- // Encryption/authentication parameters.
- authSchemeName = "gcm"
- aesKeySize = 16
- gcmNonceSize = 12
- idNoncePrefix = "discovery-id-nonce"
- handshakeTimeout = time.Second
-)
-
-var (
- errTooShort = errors.New("packet too short")
- errUnexpectedHandshake = errors.New("unexpected auth response, not in handshake")
- errHandshakeNonceMismatch = errors.New("wrong nonce in auth response")
- errInvalidAuthKey = errors.New("invalid ephemeral pubkey")
- errUnknownAuthScheme = errors.New("unknown auth scheme in handshake")
- errNoRecord = errors.New("expected ENR in handshake but none sent")
- errInvalidNonceSig = errors.New("invalid ID nonce signature")
- zeroNonce = make([]byte, gcmNonceSize)
-)
-
-// wireCodec encodes and decodes discovery v5 packets.
-type wireCodec struct {
- sha256 hash.Hash
- localnode *enode.LocalNode
- privkey *ecdsa.PrivateKey
- myChtagHash enode.ID
- myWhoareyouMagic []byte
-
- sc *sessionCache
-}
-
-type handshakeSecrets struct {
- writeKey, readKey, authRespKey []byte
-}
-
-type authHeader struct {
- authHeaderList
- isHandshake bool
-}
-
-type authHeaderList struct {
- Auth []byte // authentication info of packet
- IDNonce [32]byte // IDNonce of WHOAREYOU
- Scheme string // name of encryption/authentication scheme
- EphemeralKey []byte // ephemeral public key
- Response []byte // encrypted authResponse
-}
-
-type authResponse struct {
- Version uint
- Signature []byte
- Record *enr.Record `rlp:"nil"` // sender's record
-}
-
-func (h *authHeader) DecodeRLP(r *rlp.Stream) error {
- k, _, err := r.Kind()
- if err != nil {
- return err
- }
- if k == rlp.Byte || k == rlp.String {
- return r.Decode(&h.Auth)
- }
- h.isHandshake = true
- return r.Decode(&h.authHeaderList)
-}
-
-// ephemeralKey decodes the ephemeral public key in the header.
-func (h *authHeaderList) ephemeralKey(curve elliptic.Curve) *ecdsa.PublicKey {
- var key encPubkey
- copy(key[:], h.EphemeralKey)
- pubkey, _ := decodePubkey(curve, key)
- return pubkey
-}
-
-// newWireCodec creates a wire codec.
-func newWireCodec(ln *enode.LocalNode, key *ecdsa.PrivateKey, clock mclock.Clock) *wireCodec {
- c := &wireCodec{
- sha256: sha256.New(),
- localnode: ln,
- privkey: key,
- sc: newSessionCache(1024, clock),
- }
- // Create magic strings for packet matching.
- self := ln.ID()
- c.myWhoareyouMagic = c.sha256sum(self[:], []byte("WHOAREYOU"))
- copy(c.myChtagHash[:], c.sha256sum(self[:]))
- return c
-}
-
-// encode encodes a packet to a node. 'id' and 'addr' specify the destination node. The
-// 'challenge' parameter should be the most recently received WHOAREYOU packet from that
-// node.
-func (c *wireCodec) encode(id enode.ID, addr string, packet packetV5, challenge *whoareyouV5) ([]byte, []byte, error) {
- if packet.kind() == p_whoareyouV5 {
- p := packet.(*whoareyouV5)
- enc, err := c.encodeWhoareyou(id, p)
- if err == nil {
- c.sc.storeSentHandshake(id, addr, p)
- }
- return enc, nil, err
- }
- // Ensure calling code sets node if needed.
- if challenge != nil && challenge.node == nil {
- panic("BUG: missing challenge.node in encode")
- }
- writeKey := c.sc.writeKey(id, addr)
- if writeKey != nil || challenge != nil {
- return c.encodeEncrypted(id, addr, packet, writeKey, challenge)
- }
- return c.encodeRandom(id)
-}
-
-// encodeRandom encodes a random packet.
-func (c *wireCodec) encodeRandom(toID enode.ID) ([]byte, []byte, error) {
- tag := xorTag(c.sha256sum(toID[:]), c.localnode.ID())
- r := make([]byte, 44) // TODO randomize size
- if _, err := crand.Read(r); err != nil {
- return nil, nil, err
- }
- nonce := make([]byte, gcmNonceSize)
- if _, err := crand.Read(nonce); err != nil {
- return nil, nil, fmt.Errorf("can't get random data: %v", err)
- }
- b := new(bytes.Buffer)
- b.Write(tag[:])
- rlp.Encode(b, nonce)
- b.Write(r)
- return b.Bytes(), nonce, nil
-}
-
-// encodeWhoareyou encodes WHOAREYOU.
-func (c *wireCodec) encodeWhoareyou(toID enode.ID, packet *whoareyouV5) ([]byte, error) {
- // Sanity check node field to catch misbehaving callers.
- if packet.RecordSeq > 0 && packet.node == nil {
- panic("BUG: missing node in whoareyouV5 with non-zero seq")
- }
- b := new(bytes.Buffer)
- b.Write(c.sha256sum(toID[:], []byte("WHOAREYOU")))
- err := rlp.Encode(b, packet)
- return b.Bytes(), err
-}
-
-// encodeEncrypted encodes an encrypted packet.
-func (c *wireCodec) encodeEncrypted(toID enode.ID, toAddr string, packet packetV5, writeKey []byte, challenge *whoareyouV5) (enc []byte, authTag []byte, err error) {
- nonce := make([]byte, gcmNonceSize)
- if _, err := crand.Read(nonce); err != nil {
- return nil, nil, fmt.Errorf("can't get random data: %v", err)
- }
-
- var headEnc []byte
- if challenge == nil {
- // Regular packet, use existing key and simply encode nonce.
- headEnc, _ = rlp.EncodeToBytes(nonce)
- } else {
- // We're answering WHOAREYOU, generate new keys and encrypt with those.
- header, sec, err := c.makeAuthHeader(nonce, challenge)
- if err != nil {
- return nil, nil, err
- }
- if headEnc, err = rlp.EncodeToBytes(header); err != nil {
- return nil, nil, err
- }
- c.sc.storeNewSession(toID, toAddr, sec.readKey, sec.writeKey)
- writeKey = sec.writeKey
- }
-
- // Encode the packet.
- body := new(bytes.Buffer)
- body.WriteByte(packet.kind())
- if err := rlp.Encode(body, packet); err != nil {
- return nil, nil, err
- }
- tag := xorTag(c.sha256sum(toID[:]), c.localnode.ID())
- headsize := len(tag) + len(headEnc)
- headbuf := make([]byte, headsize)
- copy(headbuf[:], tag[:])
- copy(headbuf[len(tag):], headEnc)
-
- // Encrypt the body.
- enc, err = encryptGCM(headbuf, writeKey, nonce, body.Bytes(), tag[:])
- return enc, nonce, err
-}
-
-// encodeAuthHeader creates the auth header on a call packet following WHOAREYOU.
-func (c *wireCodec) makeAuthHeader(nonce []byte, challenge *whoareyouV5) (*authHeaderList, *handshakeSecrets, error) {
- resp := &authResponse{Version: 5}
-
- // Add our record to response if it's newer than what remote
- // side has.
- ln := c.localnode.Node()
- if challenge.RecordSeq < ln.Seq() {
- resp.Record = ln.Record()
- }
-
- // Create the ephemeral key. This needs to be first because the
- // key is part of the ID nonce signature.
- var remotePubkey = new(ecdsa.PublicKey)
- if err := challenge.node.Load((*enode.Secp256k1)(remotePubkey)); err != nil {
- return nil, nil, fmt.Errorf("can't find secp256k1 key for recipient")
- }
- ephkey, err := crypto.GenerateKey()
- if err != nil {
- return nil, nil, fmt.Errorf("can't generate ephemeral key")
- }
- ephpubkey := encodePubkey(&ephkey.PublicKey)
-
- // Add ID nonce signature to response.
- idsig, err := c.signIDNonce(challenge.IDNonce[:], ephpubkey[:])
- if err != nil {
- return nil, nil, fmt.Errorf("can't sign: %v", err)
- }
- resp.Signature = idsig
-
- // Create session keys.
- sec := c.deriveKeys(c.localnode.ID(), challenge.node.ID(), ephkey, remotePubkey, challenge)
- if sec == nil {
- return nil, nil, fmt.Errorf("key derivation failed")
- }
-
- // Encrypt the authentication response and assemble the auth header.
- respRLP, err := rlp.EncodeToBytes(resp)
- if err != nil {
- return nil, nil, fmt.Errorf("can't encode auth response: %v", err)
- }
- respEnc, err := encryptGCM(nil, sec.authRespKey, zeroNonce, respRLP, nil)
- if err != nil {
- return nil, nil, fmt.Errorf("can't encrypt auth response: %v", err)
- }
- head := &authHeaderList{
- Auth: nonce,
- Scheme: authSchemeName,
- IDNonce: challenge.IDNonce,
- EphemeralKey: ephpubkey[:],
- Response: respEnc,
- }
- return head, sec, err
-}
-
-// deriveKeys generates session keys using elliptic-curve Diffie-Hellman key agreement.
-func (c *wireCodec) deriveKeys(n1, n2 enode.ID, priv *ecdsa.PrivateKey, pub *ecdsa.PublicKey, challenge *whoareyouV5) *handshakeSecrets {
- eph := ecdh(priv, pub)
- if eph == nil {
- return nil
- }
-
- info := []byte("discovery v5 key agreement")
- info = append(info, n1[:]...)
- info = append(info, n2[:]...)
- kdf := hkdf.New(sha256.New, eph, challenge.IDNonce[:], info)
- sec := handshakeSecrets{
- writeKey: make([]byte, aesKeySize),
- readKey: make([]byte, aesKeySize),
- authRespKey: make([]byte, aesKeySize),
- }
- kdf.Read(sec.writeKey)
- kdf.Read(sec.readKey)
- kdf.Read(sec.authRespKey)
- for i := range eph {
- eph[i] = 0
- }
- return &sec
-}
-
-// signIDNonce creates the ID nonce signature.
-func (c *wireCodec) signIDNonce(nonce, ephkey []byte) ([]byte, error) {
- idsig, err := crypto.Sign(c.idNonceHash(nonce, ephkey), c.privkey)
- if err != nil {
- return nil, fmt.Errorf("can't sign: %v", err)
- }
- return idsig[:len(idsig)-1], nil // remove recovery ID
-}
-
-// idNonceHash computes the hash of id nonce with prefix.
-func (c *wireCodec) idNonceHash(nonce, ephkey []byte) []byte {
- h := c.sha256reset()
- h.Write([]byte(idNoncePrefix))
- h.Write(nonce)
- h.Write(ephkey)
- return h.Sum(nil)
-}
-
-// decode decodes a discovery packet.
-func (c *wireCodec) decode(input []byte, addr string) (enode.ID, *enode.Node, packetV5, error) {
- // Delete timed-out handshakes. This must happen before decoding to avoid
- // processing the same handshake twice.
- c.sc.handshakeGC()
-
- if len(input) < 32 {
- return enode.ID{}, nil, nil, errTooShort
- }
- if bytes.HasPrefix(input, c.myWhoareyouMagic) {
- p, err := c.decodeWhoareyou(input)
- return enode.ID{}, nil, p, err
- }
- sender := xorTag(input[:32], c.myChtagHash)
- p, n, err := c.decodeEncrypted(sender, addr, input)
- return sender, n, p, err
-}
-
-// decodeWhoareyou decode a WHOAREYOU packet.
-func (c *wireCodec) decodeWhoareyou(input []byte) (packetV5, error) {
- packet := new(whoareyouV5)
- err := rlp.DecodeBytes(input[32:], packet)
- return packet, err
-}
-
-// decodeEncrypted decodes an encrypted discovery packet.
-func (c *wireCodec) decodeEncrypted(fromID enode.ID, fromAddr string, input []byte) (packetV5, *enode.Node, error) {
- // Decode packet header.
- var head authHeader
- r := bytes.NewReader(input[32:])
- err := rlp.Decode(r, &head)
- if err != nil {
- return nil, nil, err
- }
-
- // Decrypt and process auth response.
- readKey, node, err := c.decodeAuth(fromID, fromAddr, &head)
- if err != nil {
- return nil, nil, err
- }
-
- // Decrypt and decode the packet body.
- headsize := len(input) - r.Len()
- bodyEnc := input[headsize:]
- body, err := decryptGCM(readKey, head.Auth, bodyEnc, input[:32])
- if err != nil {
- if !head.isHandshake {
- // Can't decrypt, start handshake.
- return &unknownV5{AuthTag: head.Auth}, nil, nil
- }
- return nil, nil, fmt.Errorf("handshake failed: %v", err)
- }
- if len(body) == 0 {
- return nil, nil, errTooShort
- }
- p, err := decodePacketBodyV5(body[0], body[1:])
- return p, node, err
-}
-
-// decodeAuth processes an auth header.
-func (c *wireCodec) decodeAuth(fromID enode.ID, fromAddr string, head *authHeader) ([]byte, *enode.Node, error) {
- if !head.isHandshake {
- return c.sc.readKey(fromID, fromAddr), nil, nil
- }
-
- // Remote is attempting handshake. Verify against our last WHOAREYOU.
- challenge := c.sc.getHandshake(fromID, fromAddr)
- if challenge == nil {
- return nil, nil, errUnexpectedHandshake
- }
- if head.IDNonce != challenge.IDNonce {
- return nil, nil, errHandshakeNonceMismatch
- }
- sec, n, err := c.decodeAuthResp(fromID, fromAddr, &head.authHeaderList, challenge)
- if err != nil {
- return nil, n, err
- }
- // Swap keys to match remote.
- sec.readKey, sec.writeKey = sec.writeKey, sec.readKey
- c.sc.storeNewSession(fromID, fromAddr, sec.readKey, sec.writeKey)
- c.sc.deleteHandshake(fromID, fromAddr)
- return sec.readKey, n, err
-}
-
-// decodeAuthResp decodes and verifies an authentication response.
-func (c *wireCodec) decodeAuthResp(fromID enode.ID, fromAddr string, head *authHeaderList, challenge *whoareyouV5) (*handshakeSecrets, *enode.Node, error) {
- // Decrypt / decode the response.
- if head.Scheme != authSchemeName {
- return nil, nil, errUnknownAuthScheme
- }
- ephkey := head.ephemeralKey(c.privkey.Curve)
- if ephkey == nil {
- return nil, nil, errInvalidAuthKey
- }
- sec := c.deriveKeys(fromID, c.localnode.ID(), c.privkey, ephkey, challenge)
- respPT, err := decryptGCM(sec.authRespKey, zeroNonce, head.Response, nil)
- if err != nil {
- return nil, nil, fmt.Errorf("can't decrypt auth response header: %v", err)
- }
- var resp authResponse
- if err := rlp.DecodeBytes(respPT, &resp); err != nil {
- return nil, nil, fmt.Errorf("invalid auth response: %v", err)
- }
-
- // Verify response node record. The remote node should include the record
- // if we don't have one or if ours is older than the latest version.
- node := challenge.node
- if resp.Record != nil {
- if node == nil || node.Seq() < resp.Record.Seq() {
- n, err := enode.New(enode.ValidSchemes, resp.Record)
- if err != nil {
- return nil, nil, fmt.Errorf("invalid node record: %v", err)
- }
- if n.ID() != fromID {
- return nil, nil, fmt.Errorf("record in auth respose has wrong ID: %v", n.ID())
- }
- node = n
- }
- }
- if node == nil {
- return nil, nil, errNoRecord
- }
-
- // Verify ID nonce signature.
- err = c.verifyIDSignature(challenge.IDNonce[:], head.EphemeralKey, resp.Signature, node)
- if err != nil {
- return nil, nil, err
- }
- return sec, node, nil
-}
-
-// verifyIDSignature checks that signature over idnonce was made by the node with given record.
-func (c *wireCodec) verifyIDSignature(nonce, ephkey, sig []byte, n *enode.Node) error {
- switch idscheme := n.Record().IdentityScheme(); idscheme {
- case "v4":
- var pk ecdsa.PublicKey
- n.Load((*enode.Secp256k1)(&pk)) // cannot fail because record is valid
- if !crypto.VerifySignature(crypto.FromECDSAPub(&pk), c.idNonceHash(nonce, ephkey), sig) {
- return errInvalidNonceSig
- }
- return nil
- default:
- return fmt.Errorf("can't verify ID nonce signature against scheme %q", idscheme)
- }
-}
-
-// decodePacketBody decodes the body of an encrypted discovery packet.
-func decodePacketBodyV5(ptype byte, body []byte) (packetV5, error) {
- var dec packetV5
- switch ptype {
- case p_pingV5:
- dec = new(pingV5)
- case p_pongV5:
- dec = new(pongV5)
- case p_findnodeV5:
- dec = new(findnodeV5)
- case p_nodesV5:
- dec = new(nodesV5)
- case p_requestTicketV5:
- dec = new(requestTicketV5)
- case p_ticketV5:
- dec = new(ticketV5)
- case p_regtopicV5:
- dec = new(regtopicV5)
- case p_regconfirmationV5:
- dec = new(regconfirmationV5)
- case p_topicqueryV5:
- dec = new(topicqueryV5)
- default:
- return nil, fmt.Errorf("unknown packet type %d", ptype)
- }
- if err := rlp.DecodeBytes(body, dec); err != nil {
- return nil, err
- }
- return dec, nil
-}
-
-// sha256reset returns the shared hash instance.
-func (c *wireCodec) sha256reset() hash.Hash {
- c.sha256.Reset()
- return c.sha256
-}
-
-// sha256sum computes sha256 on the concatenation of inputs.
-func (c *wireCodec) sha256sum(inputs ...[]byte) []byte {
- c.sha256.Reset()
- for _, b := range inputs {
- c.sha256.Write(b)
- }
- return c.sha256.Sum(nil)
-}
-
-func xorTag(a []byte, b enode.ID) enode.ID {
- var r enode.ID
- for i := range r {
- r[i] = a[i] ^ b[i]
- }
- return r
-}
-
-// ecdh creates a shared secret.
-func ecdh(privkey *ecdsa.PrivateKey, pubkey *ecdsa.PublicKey) []byte {
- secX, secY := pubkey.ScalarMult(pubkey.X, pubkey.Y, privkey.D.Bytes())
- if secX == nil {
- return nil
- }
- sec := make([]byte, 33)
- sec[0] = 0x02 | byte(secY.Bit(0))
- math.ReadBits(secX, sec[1:])
- return sec
-}
-
-// encryptGCM encrypts pt using AES-GCM with the given key and nonce.
-func encryptGCM(dest, key, nonce, pt, authData []byte) ([]byte, error) {
- block, err := aes.NewCipher(key)
- if err != nil {
- panic(fmt.Errorf("can't create block cipher: %v", err))
- }
- aesgcm, err := cipher.NewGCMWithNonceSize(block, gcmNonceSize)
- if err != nil {
- panic(fmt.Errorf("can't create GCM: %v", err))
- }
- return aesgcm.Seal(dest, nonce, pt, authData), nil
-}
-
-// decryptGCM decrypts ct using AES-GCM with the given key and nonce.
-func decryptGCM(key, nonce, ct, authData []byte) ([]byte, error) {
- block, err := aes.NewCipher(key)
- if err != nil {
- return nil, fmt.Errorf("can't create block cipher: %v", err)
- }
- if len(nonce) != gcmNonceSize {
- return nil, fmt.Errorf("invalid GCM nonce size: %d", len(nonce))
- }
- aesgcm, err := cipher.NewGCMWithNonceSize(block, gcmNonceSize)
- if err != nil {
- return nil, fmt.Errorf("can't create GCM: %v", err)
- }
- pt := make([]byte, 0, len(ct))
- return aesgcm.Open(pt, nonce, ct, authData)
-}
diff --git a/p2p/discover/v5_encoding_test.go b/p2p/discover/v5_encoding_test.go
deleted file mode 100644
index ec4388cb7f95..000000000000
--- a/p2p/discover/v5_encoding_test.go
+++ /dev/null
@@ -1,373 +0,0 @@
-// Copyright 2019 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 .
-
-package discover
-
-import (
- "bytes"
- "crypto/ecdsa"
- "encoding/hex"
- "fmt"
- "net"
- "reflect"
- "testing"
-
- "github.com/XinFinOrg/XDPoSChain/common/mclock"
- "github.com/XinFinOrg/XDPoSChain/crypto"
- "github.com/XinFinOrg/XDPoSChain/p2p/enode"
- "github.com/davecgh/go-spew/spew"
-)
-
-var (
- testKeyA, _ = crypto.HexToECDSA("eef77acb6c6a6eebc5b363a475ac583ec7eccdb42b6481424c60f59aa326547f")
- testKeyB, _ = crypto.HexToECDSA("66fb62bfbd66b9177a138c1e5cddbe4f7c30c343e94e68df8769459cb1cde628")
- testIDnonce = [32]byte{5, 6, 7, 8, 9, 10, 11, 12}
-)
-
-func TestDeriveKeysV5(t *testing.T) {
- t.Parallel()
-
- var (
- n1 = enode.ID{1}
- n2 = enode.ID{2}
- challenge = &whoareyouV5{}
- db, _ = enode.OpenDB("")
- ln = enode.NewLocalNode(db, testKeyA)
- c = newWireCodec(ln, testKeyA, mclock.System{})
- )
- defer db.Close()
-
- sec1 := c.deriveKeys(n1, n2, testKeyA, &testKeyB.PublicKey, challenge)
- sec2 := c.deriveKeys(n1, n2, testKeyB, &testKeyA.PublicKey, challenge)
- if sec1 == nil || sec2 == nil {
- t.Fatal("key agreement failed")
- }
- if !reflect.DeepEqual(sec1, sec2) {
- t.Fatalf("keys not equal:\n %+v\n %+v", sec1, sec2)
- }
-}
-
-// This test checks the basic handshake flow where A talks to B and A has no secrets.
-func TestHandshakeV5(t *testing.T) {
- t.Parallel()
- net := newHandshakeTest()
- defer net.close()
-
- // A -> B RANDOM PACKET
- packet, _ := net.nodeA.encode(t, net.nodeB, &findnodeV5{})
- resp := net.nodeB.expectDecode(t, p_unknownV5, packet)
-
- // A <- B WHOAREYOU
- challenge := &whoareyouV5{
- AuthTag: resp.(*unknownV5).AuthTag,
- IDNonce: testIDnonce,
- RecordSeq: 0,
- }
- whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
- net.nodeA.expectDecode(t, p_whoareyouV5, whoareyou)
-
- // A -> B FINDNODE
- findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &findnodeV5{})
- net.nodeB.expectDecode(t, p_findnodeV5, findnode)
- if len(net.nodeB.c.sc.handshakes) > 0 {
- t.Fatalf("node B didn't remove handshake from challenge map")
- }
-
- // A <- B NODES
- nodes, _ := net.nodeB.encode(t, net.nodeA, &nodesV5{Total: 1})
- net.nodeA.expectDecode(t, p_nodesV5, nodes)
-}
-
-// This test checks that handshake attempts are removed within the timeout.
-func TestHandshakeV5_timeout(t *testing.T) {
- t.Parallel()
- net := newHandshakeTest()
- defer net.close()
-
- // A -> B RANDOM PACKET
- packet, _ := net.nodeA.encode(t, net.nodeB, &findnodeV5{})
- resp := net.nodeB.expectDecode(t, p_unknownV5, packet)
-
- // A <- B WHOAREYOU
- challenge := &whoareyouV5{
- AuthTag: resp.(*unknownV5).AuthTag,
- IDNonce: testIDnonce,
- RecordSeq: 0,
- }
- whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
- net.nodeA.expectDecode(t, p_whoareyouV5, whoareyou)
-
- // A -> B FINDNODE after timeout
- net.clock.Run(handshakeTimeout + 1)
- findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &findnodeV5{})
- net.nodeB.expectDecodeErr(t, errUnexpectedHandshake, findnode)
-}
-
-// This test checks handshake behavior when no record is sent in the auth response.
-func TestHandshakeV5_norecord(t *testing.T) {
- t.Parallel()
- net := newHandshakeTest()
- defer net.close()
-
- // A -> B RANDOM PACKET
- packet, _ := net.nodeA.encode(t, net.nodeB, &findnodeV5{})
- resp := net.nodeB.expectDecode(t, p_unknownV5, packet)
-
- // A <- B WHOAREYOU
- nodeA := net.nodeA.n()
- if nodeA.Seq() == 0 {
- t.Fatal("need non-zero sequence number")
- }
- challenge := &whoareyouV5{
- AuthTag: resp.(*unknownV5).AuthTag,
- IDNonce: testIDnonce,
- RecordSeq: nodeA.Seq(),
- node: nodeA,
- }
- whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
- net.nodeA.expectDecode(t, p_whoareyouV5, whoareyou)
-
- // A -> B FINDNODE
- findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &findnodeV5{})
- net.nodeB.expectDecode(t, p_findnodeV5, findnode)
-
- // A <- B NODES
- nodes, _ := net.nodeB.encode(t, net.nodeA, &nodesV5{Total: 1})
- net.nodeA.expectDecode(t, p_nodesV5, nodes)
-}
-
-// In this test, A tries to send FINDNODE with existing secrets but B doesn't know
-// anything about A.
-func TestHandshakeV5_rekey(t *testing.T) {
- t.Parallel()
- net := newHandshakeTest()
- defer net.close()
-
- initKeys := &handshakeSecrets{
- readKey: []byte("BBBBBBBBBBBBBBBB"),
- writeKey: []byte("AAAAAAAAAAAAAAAA"),
- }
- net.nodeA.c.sc.storeNewSession(net.nodeB.id(), net.nodeB.addr(), initKeys.readKey, initKeys.writeKey)
-
- // A -> B FINDNODE (encrypted with zero keys)
- findnode, authTag := net.nodeA.encode(t, net.nodeB, &findnodeV5{})
- net.nodeB.expectDecode(t, p_unknownV5, findnode)
-
- // A <- B WHOAREYOU
- challenge := &whoareyouV5{AuthTag: authTag, IDNonce: testIDnonce}
- whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
- net.nodeA.expectDecode(t, p_whoareyouV5, whoareyou)
-
- // Check that new keys haven't been stored yet.
- if s := net.nodeA.c.sc.session(net.nodeB.id(), net.nodeB.addr()); !bytes.Equal(s.writeKey, initKeys.writeKey) || !bytes.Equal(s.readKey, initKeys.readKey) {
- t.Fatal("node A stored keys too early")
- }
- if s := net.nodeB.c.sc.session(net.nodeA.id(), net.nodeA.addr()); s != nil {
- t.Fatal("node B stored keys too early")
- }
-
- // A -> B FINDNODE encrypted with new keys
- findnode, _ = net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &findnodeV5{})
- net.nodeB.expectDecode(t, p_findnodeV5, findnode)
-
- // A <- B NODES
- nodes, _ := net.nodeB.encode(t, net.nodeA, &nodesV5{Total: 1})
- net.nodeA.expectDecode(t, p_nodesV5, nodes)
-}
-
-// In this test A and B have different keys before the handshake.
-func TestHandshakeV5_rekey2(t *testing.T) {
- t.Parallel()
- net := newHandshakeTest()
- defer net.close()
-
- initKeysA := &handshakeSecrets{
- readKey: []byte("BBBBBBBBBBBBBBBB"),
- writeKey: []byte("AAAAAAAAAAAAAAAA"),
- }
- initKeysB := &handshakeSecrets{
- readKey: []byte("CCCCCCCCCCCCCCCC"),
- writeKey: []byte("DDDDDDDDDDDDDDDD"),
- }
- net.nodeA.c.sc.storeNewSession(net.nodeB.id(), net.nodeB.addr(), initKeysA.readKey, initKeysA.writeKey)
- net.nodeB.c.sc.storeNewSession(net.nodeA.id(), net.nodeA.addr(), initKeysB.readKey, initKeysA.writeKey)
-
- // A -> B FINDNODE encrypted with initKeysA
- findnode, authTag := net.nodeA.encode(t, net.nodeB, &findnodeV5{Distance: 3})
- net.nodeB.expectDecode(t, p_unknownV5, findnode)
-
- // A <- B WHOAREYOU
- challenge := &whoareyouV5{AuthTag: authTag, IDNonce: testIDnonce}
- whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
- net.nodeA.expectDecode(t, p_whoareyouV5, whoareyou)
-
- // A -> B FINDNODE encrypted with new keys
- findnode, _ = net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &findnodeV5{})
- net.nodeB.expectDecode(t, p_findnodeV5, findnode)
-
- // A <- B NODES
- nodes, _ := net.nodeB.encode(t, net.nodeA, &nodesV5{Total: 1})
- net.nodeA.expectDecode(t, p_nodesV5, nodes)
-}
-
-// This test checks some malformed packets.
-func TestDecodeErrorsV5(t *testing.T) {
- t.Parallel()
- net := newHandshakeTest()
- defer net.close()
-
- net.nodeA.expectDecodeErr(t, errTooShort, []byte{})
- // TODO some more tests would be nice :)
-}
-
-// This benchmark checks performance of authHeader decoding, verification and key derivation.
-func BenchmarkV5_DecodeAuthSecp256k1(b *testing.B) {
- net := newHandshakeTest()
- defer net.close()
-
- var (
- idA = net.nodeA.id()
- addrA = net.nodeA.addr()
- challenge = &whoareyouV5{AuthTag: []byte("authresp"), RecordSeq: 0, node: net.nodeB.n()}
- nonce = make([]byte, gcmNonceSize)
- )
- header, _, _ := net.nodeA.c.makeAuthHeader(nonce, challenge)
- challenge.node = nil // force ENR signature verification in decoder
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- _, _, err := net.nodeB.c.decodeAuthResp(idA, addrA, header, challenge)
- if err != nil {
- b.Fatal(err)
- }
- }
-}
-
-// This benchmark checks how long it takes to decode an encrypted ping packet.
-func BenchmarkV5_DecodePing(b *testing.B) {
- net := newHandshakeTest()
- defer net.close()
-
- r := []byte{233, 203, 93, 195, 86, 47, 177, 186, 227, 43, 2, 141, 244, 230, 120, 17}
- w := []byte{79, 145, 252, 171, 167, 216, 252, 161, 208, 190, 176, 106, 214, 39, 178, 134}
- net.nodeA.c.sc.storeNewSession(net.nodeB.id(), net.nodeB.addr(), r, w)
- net.nodeB.c.sc.storeNewSession(net.nodeA.id(), net.nodeA.addr(), w, r)
- addrB := net.nodeA.addr()
- ping := &pingV5{ReqID: []byte("reqid"), ENRSeq: 5}
- enc, _, err := net.nodeA.c.encode(net.nodeB.id(), addrB, ping, nil)
- if err != nil {
- b.Fatalf("can't encode: %v", err)
- }
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- _, _, p, _ := net.nodeB.c.decode(enc, addrB)
- if _, ok := p.(*pingV5); !ok {
- b.Fatalf("wrong packet type %T", p)
- }
- }
-}
-
-var pp = spew.NewDefaultConfig()
-
-type handshakeTest struct {
- nodeA, nodeB handshakeTestNode
- clock mclock.Simulated
-}
-
-type handshakeTestNode struct {
- ln *enode.LocalNode
- c *wireCodec
-}
-
-func newHandshakeTest() *handshakeTest {
- t := new(handshakeTest)
- t.nodeA.init(testKeyA, net.IP{127, 0, 0, 1}, &t.clock)
- t.nodeB.init(testKeyB, net.IP{127, 0, 0, 1}, &t.clock)
- return t
-}
-
-func (t *handshakeTest) close() {
- t.nodeA.ln.Database().Close()
- t.nodeB.ln.Database().Close()
-}
-
-func (n *handshakeTestNode) init(key *ecdsa.PrivateKey, ip net.IP, clock mclock.Clock) {
- db, _ := enode.OpenDB("")
- n.ln = enode.NewLocalNode(db, key)
- n.ln.SetStaticIP(ip)
- n.c = newWireCodec(n.ln, key, clock)
-}
-
-func (n *handshakeTestNode) encode(t testing.TB, to handshakeTestNode, p packetV5) ([]byte, []byte) {
- t.Helper()
- return n.encodeWithChallenge(t, to, nil, p)
-}
-
-func (n *handshakeTestNode) encodeWithChallenge(t testing.TB, to handshakeTestNode, c *whoareyouV5, p packetV5) ([]byte, []byte) {
- t.Helper()
- // Copy challenge and add destination node. This avoids sharing 'c' among the two codecs.
- var challenge *whoareyouV5
- if c != nil {
- challengeCopy := *c
- challenge = &challengeCopy
- challenge.node = to.n()
- }
- // Encode to destination.
- enc, authTag, err := n.c.encode(to.id(), to.addr(), p, challenge)
- if err != nil {
- t.Fatal(fmt.Errorf("(%s) %v", n.ln.ID().TerminalString(), err))
- }
- t.Logf("(%s) -> (%s) %s\n%s", n.ln.ID().TerminalString(), to.id().TerminalString(), p.name(), hex.Dump(enc))
- return enc, authTag
-}
-
-func (n *handshakeTestNode) expectDecode(t *testing.T, ptype byte, p []byte) packetV5 {
- t.Helper()
- dec, err := n.decode(p)
- if err != nil {
- t.Fatal(fmt.Errorf("(%s) %v", n.ln.ID().TerminalString(), err))
- }
- t.Logf("(%s) %#v", n.ln.ID().TerminalString(), pp.NewFormatter(dec))
- if dec.kind() != ptype {
- t.Fatalf("expected packet type %d, got %d", ptype, dec.kind())
- }
- return dec
-}
-
-func (n *handshakeTestNode) expectDecodeErr(t *testing.T, wantErr error, p []byte) {
- t.Helper()
- if _, err := n.decode(p); !reflect.DeepEqual(err, wantErr) {
- t.Fatal(fmt.Errorf("(%s) got err %q, want %q", n.ln.ID().TerminalString(), err, wantErr))
- }
-}
-
-func (n *handshakeTestNode) decode(input []byte) (packetV5, error) {
- _, _, p, err := n.c.decode(input, "127.0.0.1")
- return p, err
-}
-
-func (n *handshakeTestNode) n() *enode.Node {
- return n.ln.Node()
-}
-
-func (n *handshakeTestNode) addr() string {
- return n.ln.Node().IP().String()
-}
-
-func (n *handshakeTestNode) id() enode.ID {
- return n.ln.ID()
-}
diff --git a/p2p/discover/v5_udp.go b/p2p/discover/v5_udp.go
index e70cee74ae66..2d91f950ea7e 100644
--- a/p2p/discover/v5_udp.go
+++ b/p2p/discover/v5_udp.go
@@ -31,6 +31,7 @@ import (
"github.com/XinFinOrg/XDPoSChain/common/mclock"
"github.com/XinFinOrg/XDPoSChain/log"
+ "github.com/XinFinOrg/XDPoSChain/p2p/discover/v5wire"
"github.com/XinFinOrg/XDPoSChain/p2p/enode"
"github.com/XinFinOrg/XDPoSChain/p2p/enr"
"github.com/XinFinOrg/XDPoSChain/p2p/netutil"
@@ -38,36 +39,24 @@ import (
const (
lookupRequestLimit = 3 // max requests against a single node during lookup
- findnodeResultLimit = 15 // applies in FINDNODE handler
+ findnodeResultLimit = 16 // applies in FINDNODE handler
totalNodesResponseLimit = 5 // applies in waitForNodes
nodesResponseItemLimit = 3 // applies in sendNodes
respTimeoutV5 = 700 * time.Millisecond
)
-// codecV5 is implemented by wireCodec (and testCodec).
+// codecV5 is implemented by v5wire.Codec (and testCodec).
//
// The UDPv5 transport is split into two objects: the codec object deals with
// encoding/decoding and with the handshake; the UDPv5 object handles higher-level concerns.
type codecV5 interface {
- // encode encodes a packet. The 'challenge' parameter is non-nil for calls which got a
- // WHOAREYOU response.
- encode(fromID enode.ID, fromAddr string, p packetV5, challenge *whoareyouV5) (enc []byte, authTag []byte, err error)
+ // Encode encodes a packet.
+ Encode(enode.ID, string, v5wire.Packet, *v5wire.Whoareyou) ([]byte, v5wire.Nonce, error)
- // decode decodes a packet. It returns an *unknownV5 packet if decryption fails.
- // The fromNode return value is non-nil when the input contains a handshake response.
- decode(input []byte, fromAddr string) (fromID enode.ID, fromNode *enode.Node, p packetV5, err error)
-}
-
-// packetV5 is implemented by all discv5 packet type structs.
-type packetV5 interface {
- // These methods provide information and set the request ID.
- name() string
- kind() byte
- setreqid([]byte)
- // handle should perform the appropriate action to handle the packet, i.e. this is the
- // place to send the response.
- handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr)
+ // decode decodes a packet. It returns a *v5wire.Unknown packet if decryption fails.
+ // The *enode.Node return value is non-nil when the input contains a handshake response.
+ Decode([]byte, string) (enode.ID, *enode.Node, v5wire.Packet, error)
}
// UDPv5 is the implementation of protocol version 5.
@@ -83,6 +72,10 @@ type UDPv5 struct {
clock mclock.Clock
validSchemes enr.IdentityScheme
+ // talkreq handler registry
+ trlock sync.Mutex
+ trhandlers map[string]func([]byte) []byte
+
// channels into dispatch
packetInCh chan ReadPacket
readNextCh chan struct{}
@@ -93,7 +86,7 @@ type UDPv5 struct {
// state of dispatch
codec codecV5
activeCallByNode map[enode.ID]*callV5
- activeCallByAuth map[string]*callV5
+ activeCallByAuth map[v5wire.Nonce]*callV5
callQueue map[enode.ID][]*callV5
// shutdown stuff
@@ -106,16 +99,16 @@ type UDPv5 struct {
// callV5 represents a remote procedure call against another node.
type callV5 struct {
node *enode.Node
- packet packetV5
+ packet v5wire.Packet
responseType byte // expected packet type of response
reqid []byte
- ch chan packetV5 // responses sent here
- err chan error // errors sent here
+ ch chan v5wire.Packet // responses sent here
+ err chan error // errors sent here
// Valid for active calls only:
- authTag []byte // authTag of request packet
- handshakeCount int // # times we attempted handshake for this call
- challenge *whoareyouV5 // last sent handshake challenge
+ nonce v5wire.Nonce // nonce of request packet
+ handshakeCount int // # times we attempted handshake for this call
+ challenge *v5wire.Whoareyou // last sent handshake challenge
timeout mclock.Timer
}
@@ -152,6 +145,7 @@ func newUDPv5(conn UDPConn, ln *enode.LocalNode, cfg Config) (*UDPv5, error) {
log: cfg.Log,
validSchemes: cfg.ValidSchemes,
clock: cfg.Clock,
+ trhandlers: make(map[string]func([]byte) []byte),
// channels into dispatch
packetInCh: make(chan ReadPacket, 1),
readNextCh: make(chan struct{}, 1),
@@ -159,9 +153,9 @@ func newUDPv5(conn UDPConn, ln *enode.LocalNode, cfg Config) (*UDPv5, error) {
callDoneCh: make(chan *callV5),
respTimeoutCh: make(chan *callTimeout),
// state of dispatch
- codec: newWireCodec(ln, cfg.PrivateKey, cfg.Clock),
+ codec: v5wire.NewCodec(ln, cfg.PrivateKey, cfg.Clock),
activeCallByNode: make(map[enode.ID]*callV5),
- activeCallByAuth: make(map[string]*callV5),
+ activeCallByAuth: make(map[v5wire.Nonce]*callV5),
callQueue: make(map[enode.ID][]*callV5),
// shutdown
closeCtx: closeCtx,
@@ -236,6 +230,29 @@ func (t *UDPv5) LocalNode() *enode.LocalNode {
return t.localNode
}
+// RegisterTalkHandler adds a handler for 'talk requests'. The handler function is called
+// whenever a request for the given protocol is received and should return the response
+// data or nil.
+func (t *UDPv5) RegisterTalkHandler(protocol string, handler func([]byte) []byte) {
+ t.trlock.Lock()
+ defer t.trlock.Unlock()
+ t.trhandlers[protocol] = handler
+}
+
+// TalkRequest sends a talk request to n and waits for a response.
+func (t *UDPv5) TalkRequest(n *enode.Node, protocol string, request []byte) ([]byte, error) {
+ req := &v5wire.TalkRequest{Protocol: protocol, Message: request}
+ resp := t.call(n, v5wire.TalkResponseMsg, req)
+ defer t.callDone(resp)
+ select {
+ case respMsg := <-resp.ch:
+ return respMsg.(*v5wire.TalkResponse).Message, nil
+ case err := <-resp.err:
+ return nil, err
+ }
+}
+
+// RandomNodes returns an iterator that finds random nodes in the DHT.
func (t *UDPv5) RandomNodes() enode.Iterator {
if t.tab.len() == 0 {
// All nodes were dropped, refresh. The very first query will hit this
@@ -283,16 +300,14 @@ func (t *UDPv5) lookupWorker(destNode *node, target enode.ID) ([]*node, error) {
nodes = nodesByDistance{target: target}
err error
)
- for i := 0; i < lookupRequestLimit && len(nodes.entries) < findnodeResultLimit; i++ {
- var r []*enode.Node
- r, err = t.findnode(unwrapNode(destNode), dists[i])
- if err == errClosed {
- return nil, err
- }
- for _, n := range r {
- if n.ID() != t.Self().ID() {
- nodes.push(wrapNode(n), findnodeResultLimit)
- }
+ var r []*enode.Node
+ r, err = t.findnode(unwrapNode(destNode), dists)
+ if err == errClosed {
+ return nil, err
+ }
+ for _, n := range r {
+ if n.ID() != t.Self().ID() {
+ nodes.push(wrapNode(n), findnodeResultLimit)
}
}
return nodes.entries, err
@@ -301,15 +316,15 @@ func (t *UDPv5) lookupWorker(destNode *node, target enode.ID) ([]*node, error) {
// lookupDistances computes the distance parameter for FINDNODE calls to dest.
// It chooses distances adjacent to logdist(target, dest), e.g. for a target
// with logdist(target, dest) = 255 the result is [255, 256, 254].
-func lookupDistances(target, dest enode.ID) (dists []int) {
+func lookupDistances(target, dest enode.ID) (dists []uint) {
td := enode.LogDist(target, dest)
- dists = append(dists, td)
+ dists = append(dists, uint(td))
for i := 1; len(dists) < lookupRequestLimit; i++ {
if td+i < 256 {
- dists = append(dists, td+i)
+ dists = append(dists, uint(td+i))
}
if td-i > 0 {
- dists = append(dists, td-i)
+ dists = append(dists, uint(td-i))
}
}
return dists
@@ -317,11 +332,13 @@ func lookupDistances(target, dest enode.ID) (dists []int) {
// ping calls PING on a node and waits for a PONG response.
func (t *UDPv5) ping(n *enode.Node) (uint64, error) {
- resp := t.call(n, p_pongV5, &pingV5{ENRSeq: t.localNode.Node().Seq()})
+ req := &v5wire.Ping{ENRSeq: t.localNode.Node().Seq()}
+ resp := t.call(n, v5wire.PongMsg, req)
defer t.callDone(resp)
+
select {
case pong := <-resp.ch:
- return pong.(*pongV5).ENRSeq, nil
+ return pong.(*v5wire.Pong).ENRSeq, nil
case err := <-resp.err:
return 0, err
}
@@ -329,7 +346,7 @@ func (t *UDPv5) ping(n *enode.Node) (uint64, error) {
// requestENR requests n's record.
func (t *UDPv5) RequestENR(n *enode.Node) (*enode.Node, error) {
- nodes, err := t.findnode(n, 0)
+ nodes, err := t.findnode(n, []uint{0})
if err != nil {
return nil, err
}
@@ -339,26 +356,14 @@ func (t *UDPv5) RequestENR(n *enode.Node) (*enode.Node, error) {
return nodes[0], nil
}
-// requestTicket calls REQUESTTICKET on a node and waits for a TICKET response.
-func (t *UDPv5) requestTicket(n *enode.Node) ([]byte, error) {
- resp := t.call(n, p_ticketV5, &pingV5{})
- defer t.callDone(resp)
- select {
- case response := <-resp.ch:
- return response.(*ticketV5).Ticket, nil
- case err := <-resp.err:
- return nil, err
- }
-}
-
// findnode calls FINDNODE on a node and waits for responses.
-func (t *UDPv5) findnode(n *enode.Node, distance int) ([]*enode.Node, error) {
- resp := t.call(n, p_nodesV5, &findnodeV5{Distance: uint(distance)})
- return t.waitForNodes(resp, distance)
+func (t *UDPv5) findnode(n *enode.Node, distances []uint) ([]*enode.Node, error) {
+ resp := t.call(n, v5wire.NodesMsg, &v5wire.Findnode{Distances: distances})
+ return t.waitForNodes(resp, distances)
}
// waitForNodes waits for NODES responses to the given call.
-func (t *UDPv5) waitForNodes(c *callV5, distance int) ([]*enode.Node, error) {
+func (t *UDPv5) waitForNodes(c *callV5, distances []uint) ([]*enode.Node, error) {
defer t.callDone(c)
var (
@@ -369,11 +374,11 @@ func (t *UDPv5) waitForNodes(c *callV5, distance int) ([]*enode.Node, error) {
for {
select {
case responseP := <-c.ch:
- response := responseP.(*nodesV5)
+ response := responseP.(*v5wire.Nodes)
for _, record := range response.Nodes {
- node, err := t.verifyResponseNode(c, record, distance, seen)
+ node, err := t.verifyResponseNode(c, record, distances, seen)
if err != nil {
- t.log.Debug("Invalid record in "+response.name(), "id", c.node.ID(), "err", err)
+ t.log.Debug("Invalid record in "+response.Name(), "id", c.node.ID(), "err", err)
continue
}
nodes = append(nodes, node)
@@ -391,7 +396,7 @@ func (t *UDPv5) waitForNodes(c *callV5, distance int) ([]*enode.Node, error) {
}
// verifyResponseNode checks validity of a record in a NODES response.
-func (t *UDPv5) verifyResponseNode(c *callV5, r *enr.Record, distance int, seen map[enode.ID]struct{}) (*enode.Node, error) {
+func (t *UDPv5) verifyResponseNode(c *callV5, r *enr.Record, distances []uint, seen map[enode.ID]struct{}) (*enode.Node, error) {
node, err := enode.New(t.validSchemes, r)
if err != nil {
return nil, err
@@ -402,9 +407,10 @@ func (t *UDPv5) verifyResponseNode(c *callV5, r *enr.Record, distance int, seen
if c.node.UDP() <= 1024 {
return nil, errLowPort
}
- if distance != -1 {
- if d := enode.LogDist(c.node.ID(), node.ID()); d != distance {
- return nil, fmt.Errorf("wrong distance %d", d)
+ if distances != nil {
+ nd := enode.LogDist(c.node.ID(), node.ID())
+ if !containsUint(uint(nd), distances) {
+ return nil, errors.New("does not match any requested distance")
}
}
if _, ok := seen[node.ID()]; ok {
@@ -414,20 +420,29 @@ func (t *UDPv5) verifyResponseNode(c *callV5, r *enr.Record, distance int, seen
return node, nil
}
-// call sends the given call and sets up a handler for response packets (of type c.responseType).
-// Responses are dispatched to the call's response channel.
-func (t *UDPv5) call(node *enode.Node, responseType byte, packet packetV5) *callV5 {
+func containsUint(x uint, xs []uint) bool {
+ for _, v := range xs {
+ if x == v {
+ return true
+ }
+ }
+ return false
+}
+
+// call sends the given call and sets up a handler for response packets (of message type
+// responseType). Responses are dispatched to the call's response channel.
+func (t *UDPv5) call(node *enode.Node, responseType byte, packet v5wire.Packet) *callV5 {
c := &callV5{
node: node,
packet: packet,
responseType: responseType,
reqid: make([]byte, 8),
- ch: make(chan packetV5, 1),
+ ch: make(chan v5wire.Packet, 1),
err: make(chan error, 1),
}
// Assign request ID.
crand.Read(c.reqid)
- packet.setreqid(c.reqid)
+ packet.SetRequestID(c.reqid)
// Send call to dispatch.
select {
case t.callCh <- c:
@@ -482,7 +497,7 @@ func (t *UDPv5) dispatch() {
panic("BUG: callDone for inactive call")
}
c.timeout.Stop()
- delete(t.activeCallByAuth, string(c.authTag))
+ delete(t.activeCallByAuth, c.nonce)
delete(t.activeCallByNode, id)
t.sendNextCall(id)
@@ -502,7 +517,7 @@ func (t *UDPv5) dispatch() {
for id, c := range t.activeCallByNode {
c.err <- errClosed
delete(t.activeCallByNode, id)
- delete(t.activeCallByAuth, string(c.authTag))
+ delete(t.activeCallByAuth, c.nonce)
}
return
}
@@ -548,38 +563,37 @@ func (t *UDPv5) sendNextCall(id enode.ID) {
// sendCall encodes and sends a request packet to the call's recipient node.
// This performs a handshake if needed.
func (t *UDPv5) sendCall(c *callV5) {
- if len(c.authTag) > 0 {
- // The call already has an authTag from a previous handshake attempt. Remove the
- // entry for the authTag because we're about to generate a new authTag for this
- // call.
- delete(t.activeCallByAuth, string(c.authTag))
+ // The call might have a nonce from a previous handshake attempt. Remove the entry for
+ // the old nonce because we're about to generate a new nonce for this call.
+ if c.nonce != (v5wire.Nonce{}) {
+ delete(t.activeCallByAuth, c.nonce)
}
addr := &net.UDPAddr{IP: c.node.IP(), Port: c.node.UDP()}
- newTag, _ := t.send(c.node.ID(), addr, c.packet, c.challenge)
- c.authTag = newTag
- t.activeCallByAuth[string(c.authTag)] = c
+ newNonce, _ := t.send(c.node.ID(), addr, c.packet, c.challenge)
+ c.nonce = newNonce
+ t.activeCallByAuth[newNonce] = c
t.startResponseTimeout(c)
}
// sendResponse sends a response packet to the given node.
// This doesn't trigger a handshake even if no keys are available.
-func (t *UDPv5) sendResponse(toID enode.ID, toAddr *net.UDPAddr, packet packetV5) error {
+func (t *UDPv5) sendResponse(toID enode.ID, toAddr *net.UDPAddr, packet v5wire.Packet) error {
_, err := t.send(toID, toAddr, packet, nil)
return err
}
// send sends a packet to the given node.
-func (t *UDPv5) send(toID enode.ID, toAddr *net.UDPAddr, packet packetV5, c *whoareyouV5) ([]byte, error) {
+func (t *UDPv5) send(toID enode.ID, toAddr *net.UDPAddr, packet v5wire.Packet, c *v5wire.Whoareyou) (v5wire.Nonce, error) {
addr := toAddr.String()
- enc, authTag, err := t.codec.encode(toID, addr, packet, c)
+ enc, nonce, err := t.codec.Encode(toID, addr, packet, c)
if err != nil {
- t.log.Warn(">> "+packet.name(), "id", toID, "addr", addr, "err", err)
- return authTag, err
+ t.log.Warn(">> "+packet.Name(), "id", toID, "addr", addr, "err", err)
+ return nonce, err
}
_, err = t.conn.WriteToUDP(enc, toAddr)
- t.log.Trace(">> "+packet.name(), "id", toID, "addr", addr)
- return authTag, err
+ t.log.Trace(">> "+packet.Name(), "id", toID, "addr", addr)
+ return nonce, err
}
// readLoop runs in its own goroutine and reads packets from the network.
@@ -617,7 +631,7 @@ func (t *UDPv5) dispatchReadPacket(from *net.UDPAddr, content []byte) bool {
// handlePacket decodes and processes an incoming packet from the network.
func (t *UDPv5) handlePacket(rawpacket []byte, fromAddr *net.UDPAddr) error {
addr := fromAddr.String()
- fromID, fromNode, packet, err := t.codec.decode(rawpacket, addr)
+ fromID, fromNode, packet, err := t.codec.Decode(rawpacket, addr)
if err != nil {
t.log.Debug("Bad discv5 packet", "id", fromID, "addr", addr, "err", err)
return err
@@ -626,31 +640,32 @@ func (t *UDPv5) handlePacket(rawpacket []byte, fromAddr *net.UDPAddr) error {
// Handshake succeeded, add to table.
t.tab.addSeenNode(wrapNode(fromNode))
}
- if packet.kind() != p_whoareyouV5 {
- // WHOAREYOU logged separately to report the sender ID.
- t.log.Trace("<< "+packet.name(), "id", fromID, "addr", addr)
+ if packet.Kind() != v5wire.WhoareyouPacket {
+ // WHOAREYOU logged separately to report errors.
+ t.log.Trace("<< "+packet.Name(), "id", fromID, "addr", addr)
}
- packet.handle(t, fromID, fromAddr)
+ t.handle(packet, fromID, fromAddr)
return nil
}
// handleCallResponse dispatches a response packet to the call waiting for it.
-func (t *UDPv5) handleCallResponse(fromID enode.ID, fromAddr *net.UDPAddr, reqid []byte, p packetV5) {
+func (t *UDPv5) handleCallResponse(fromID enode.ID, fromAddr *net.UDPAddr, p v5wire.Packet) bool {
ac := t.activeCallByNode[fromID]
- if ac == nil || !bytes.Equal(reqid, ac.reqid) {
- t.log.Debug(fmt.Sprintf("Unsolicited/late %s response", p.name()), "id", fromID, "addr", fromAddr)
- return
+ if ac == nil || !bytes.Equal(p.RequestID(), ac.reqid) {
+ t.log.Debug(fmt.Sprintf("Unsolicited/late %s response", p.Name()), "id", fromID, "addr", fromAddr)
+ return false
}
if !fromAddr.IP.Equal(ac.node.IP()) || fromAddr.Port != ac.node.UDP() {
- t.log.Debug(fmt.Sprintf("%s from wrong endpoint", p.name()), "id", fromID, "addr", fromAddr)
- return
+ t.log.Debug(fmt.Sprintf("%s from wrong endpoint", p.Name()), "id", fromID, "addr", fromAddr)
+ return false
}
- if p.kind() != ac.responseType {
- t.log.Debug(fmt.Sprintf("Wrong disv5 response type %s", p.name()), "id", fromID, "addr", fromAddr)
- return
+ if p.Kind() != ac.responseType {
+ t.log.Debug(fmt.Sprintf("Wrong discv5 response type %s", p.Name()), "id", fromID, "addr", fromAddr)
+ return false
}
t.startResponseTimeout(ac)
ac.ch <- p
+ return true
}
// getNode looks for a node record in table and database.
@@ -664,50 +679,65 @@ func (t *UDPv5) getNode(id enode.ID) *enode.Node {
return nil
}
-// UNKNOWN
-
-func (p *unknownV5) name() string { return "UNKNOWN/v5" }
-func (p *unknownV5) kind() byte { return p_unknownV5 }
-func (p *unknownV5) setreqid(id []byte) {}
+// handle processes incoming packets according to their message type.
+func (t *UDPv5) handle(p v5wire.Packet, fromID enode.ID, fromAddr *net.UDPAddr) {
+ switch p := p.(type) {
+ case *v5wire.Unknown:
+ t.handleUnknown(p, fromID, fromAddr)
+ case *v5wire.Whoareyou:
+ t.handleWhoareyou(p, fromID, fromAddr)
+ case *v5wire.Ping:
+ t.handlePing(p, fromID, fromAddr)
+ case *v5wire.Pong:
+ if t.handleCallResponse(fromID, fromAddr, p) {
+ t.localNode.UDPEndpointStatement(fromAddr, &net.UDPAddr{IP: p.ToIP, Port: int(p.ToPort)})
+ }
+ case *v5wire.Findnode:
+ t.handleFindnode(p, fromID, fromAddr)
+ case *v5wire.Nodes:
+ t.handleCallResponse(fromID, fromAddr, p)
+ case *v5wire.TalkRequest:
+ t.handleTalkRequest(p, fromID, fromAddr)
+ case *v5wire.TalkResponse:
+ t.handleCallResponse(fromID, fromAddr, p)
+ }
+}
-func (p *unknownV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- challenge := &whoareyouV5{AuthTag: p.AuthTag}
+// handleUnknown initiates a handshake by responding with WHOAREYOU.
+func (t *UDPv5) handleUnknown(p *v5wire.Unknown, fromID enode.ID, fromAddr *net.UDPAddr) {
+ challenge := &v5wire.Whoareyou{Nonce: p.Nonce}
crand.Read(challenge.IDNonce[:])
if n := t.getNode(fromID); n != nil {
- challenge.node = n
+ challenge.Node = n
challenge.RecordSeq = n.Seq()
}
t.sendResponse(fromID, fromAddr, challenge)
}
-// WHOAREYOU
-
-func (p *whoareyouV5) name() string { return "WHOAREYOU/v5" }
-func (p *whoareyouV5) kind() byte { return p_whoareyouV5 }
-func (p *whoareyouV5) setreqid(id []byte) {}
+var (
+ errChallengeNoCall = errors.New("no matching call")
+ errChallengeTwice = errors.New("second handshake")
+)
-func (p *whoareyouV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- c, err := p.matchWithCall(t, p.AuthTag)
+// handleWhoareyou resends the active call as a handshake packet.
+func (t *UDPv5) handleWhoareyou(p *v5wire.Whoareyou, fromID enode.ID, fromAddr *net.UDPAddr) {
+ c, err := t.matchWithCall(fromID, p.Nonce)
if err != nil {
- t.log.Debug("Invalid WHOAREYOU/v5", "addr", fromAddr, "err", err)
+ t.log.Debug("Invalid "+p.Name(), "addr", fromAddr, "err", err)
return
}
+
// Resend the call that was answered by WHOAREYOU.
- t.log.Trace("<< "+p.name(), "id", c.node.ID(), "addr", fromAddr)
+ t.log.Trace("<< "+p.Name(), "id", c.node.ID(), "addr", fromAddr)
c.handshakeCount++
c.challenge = p
- p.node = c.node
+ p.Node = c.node
t.sendCall(c)
}
-var (
- errChallengeNoCall = errors.New("no matching call")
- errChallengeTwice = errors.New("second handshake")
-)
-
-// matchWithCall checks whether the handshake attempt matches the active call.
-func (p *whoareyouV5) matchWithCall(t *UDPv5, authTag []byte) (*callV5, error) {
- c := t.activeCallByAuth[string(authTag)]
+// matchWithCall checks whether a handshake attempt matches the active call.
+func (t *UDPv5) matchWithCall(fromID enode.ID, nonce v5wire.Nonce) (*callV5, error) {
+ c := t.activeCallByAuth[nonce]
if c == nil {
return nil, errChallengeNoCall
}
@@ -717,14 +747,9 @@ func (p *whoareyouV5) matchWithCall(t *UDPv5, authTag []byte) (*callV5, error) {
return c, nil
}
-// PING
-
-func (p *pingV5) name() string { return "PING/v5" }
-func (p *pingV5) kind() byte { return p_pingV5 }
-func (p *pingV5) setreqid(id []byte) { p.ReqID = id }
-
-func (p *pingV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- t.sendResponse(fromID, fromAddr, &pongV5{
+// handlePing sends a PONG response.
+func (t *UDPv5) handlePing(p *v5wire.Ping, fromID enode.ID, fromAddr *net.UDPAddr) {
+ t.sendResponse(fromID, fromAddr, &v5wire.Pong{
ReqID: p.ReqID,
ToIP: fromAddr.IP,
ToPort: uint16(fromAddr.Port),
@@ -732,121 +757,81 @@ func (p *pingV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
})
}
-// PONG
-
-func (p *pongV5) name() string { return "PONG/v5" }
-func (p *pongV5) kind() byte { return p_pongV5 }
-func (p *pongV5) setreqid(id []byte) { p.ReqID = id }
-
-func (p *pongV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- t.localNode.UDPEndpointStatement(fromAddr, &net.UDPAddr{IP: p.ToIP, Port: int(p.ToPort)})
- t.handleCallResponse(fromID, fromAddr, p.ReqID, p)
+// handleFindnode returns nodes to the requester.
+func (t *UDPv5) handleFindnode(p *v5wire.Findnode, fromID enode.ID, fromAddr *net.UDPAddr) {
+ nodes := t.collectTableNodes(fromAddr.IP, p.Distances, findnodeResultLimit)
+ for _, resp := range packNodes(p.ReqID, nodes) {
+ t.sendResponse(fromID, fromAddr, resp)
+ }
}
-// FINDNODE
+// collectTableNodes creates a FINDNODE result set for the given distances.
+func (t *UDPv5) collectTableNodes(rip net.IP, distances []uint, limit int) []*enode.Node {
+ var nodes []*enode.Node
+ var processed = make(map[uint]struct{})
+ for _, dist := range distances {
+ // Reject duplicate / invalid distances.
+ _, seen := processed[dist]
+ if seen || dist > 256 {
+ continue
+ }
-func (p *findnodeV5) name() string { return "FINDNODE/v5" }
-func (p *findnodeV5) kind() byte { return p_findnodeV5 }
-func (p *findnodeV5) setreqid(id []byte) { p.ReqID = id }
+ // Get the nodes.
+ var bn []*enode.Node
+ if dist == 0 {
+ bn = []*enode.Node{t.Self()}
+ } else if dist <= 256 {
+ t.tab.mutex.Lock()
+ bn = unwrapNodes(t.tab.bucketAtDistance(int(dist)).entries)
+ t.tab.mutex.Unlock()
+ }
+ processed[dist] = struct{}{}
-func (p *findnodeV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- if p.Distance == 0 {
- t.sendNodes(fromID, fromAddr, p.ReqID, []*enode.Node{t.Self()})
- return
- }
- if p.Distance > 256 {
- p.Distance = 256
- }
- // Get bucket entries.
- t.tab.mutex.Lock()
- nodes := unwrapNodes(t.tab.bucketAtDistance(int(p.Distance)).entries)
- t.tab.mutex.Unlock()
- if len(nodes) > findnodeResultLimit {
- nodes = nodes[:findnodeResultLimit]
+ // Apply some pre-checks to avoid sending invalid nodes.
+ for _, n := range bn {
+ // TODO livenessChecks > 1
+ if netutil.CheckRelayIP(rip, n.IP()) != nil {
+ continue
+ }
+ nodes = append(nodes, n)
+ if len(nodes) >= limit {
+ return nodes
+ }
+ }
}
- t.sendNodes(fromID, fromAddr, p.ReqID, nodes)
+ return nodes
}
-// sendNodes sends the given records in one or more NODES packets.
-func (t *UDPv5) sendNodes(toID enode.ID, toAddr *net.UDPAddr, reqid []byte, nodes []*enode.Node) {
- // TODO livenessChecks > 1
- // TODO CheckRelayIP
- total := uint8(math.Ceil(float64(len(nodes)) / 3))
- resp := &nodesV5{ReqID: reqid, Total: total, Nodes: make([]*enr.Record, 3)}
- sent := false
+// packNodes creates NODES response packets for the given node list.
+func packNodes(reqid []byte, nodes []*enode.Node) []*v5wire.Nodes {
+ if len(nodes) == 0 {
+ return []*v5wire.Nodes{{ReqID: reqid, Total: 1}}
+ }
+
+ total := uint8(math.Ceil(float64(len(nodes)) / float64(nodesResponseItemLimit)))
+ var resp []*v5wire.Nodes
for len(nodes) > 0 {
+ p := &v5wire.Nodes{ReqID: reqid, Total: total}
items := min(nodesResponseItemLimit, len(nodes))
- resp.Nodes = resp.Nodes[:items]
for i := 0; i < items; i++ {
- resp.Nodes[i] = nodes[i].Record()
+ p.Nodes = append(p.Nodes, nodes[i].Record())
}
- t.sendResponse(toID, toAddr, resp)
nodes = nodes[items:]
- sent = true
- }
- // Ensure at least one response is sent.
- if !sent {
- resp.Total = 1
- resp.Nodes = nil
- t.sendResponse(toID, toAddr, resp)
+ resp = append(resp, p)
}
+ return resp
}
-// NODES
+// handleTalkRequest runs the talk request handler of the requested protocol.
+func (t *UDPv5) handleTalkRequest(p *v5wire.TalkRequest, fromID enode.ID, fromAddr *net.UDPAddr) {
+ t.trlock.Lock()
+ handler := t.trhandlers[p.Protocol]
+ t.trlock.Unlock()
-func (p *nodesV5) name() string { return "NODES/v5" }
-func (p *nodesV5) kind() byte { return p_nodesV5 }
-func (p *nodesV5) setreqid(id []byte) { p.ReqID = id }
-
-func (p *nodesV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- t.handleCallResponse(fromID, fromAddr, p.ReqID, p)
-}
-
-// REQUESTTICKET
-
-func (p *requestTicketV5) name() string { return "REQUESTTICKET/v5" }
-func (p *requestTicketV5) kind() byte { return p_requestTicketV5 }
-func (p *requestTicketV5) setreqid(id []byte) { p.ReqID = id }
-
-func (p *requestTicketV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- t.sendResponse(fromID, fromAddr, &ticketV5{ReqID: p.ReqID})
-}
-
-// TICKET
-
-func (p *ticketV5) name() string { return "TICKET/v5" }
-func (p *ticketV5) kind() byte { return p_ticketV5 }
-func (p *ticketV5) setreqid(id []byte) { p.ReqID = id }
-
-func (p *ticketV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- t.handleCallResponse(fromID, fromAddr, p.ReqID, p)
-}
-
-// REGTOPIC
-
-func (p *regtopicV5) name() string { return "REGTOPIC/v5" }
-func (p *regtopicV5) kind() byte { return p_regtopicV5 }
-func (p *regtopicV5) setreqid(id []byte) { p.ReqID = id }
-
-func (p *regtopicV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- t.sendResponse(fromID, fromAddr, ®confirmationV5{ReqID: p.ReqID, Registered: false})
-}
-
-// REGCONFIRMATION
-
-func (p *regconfirmationV5) name() string { return "REGCONFIRMATION/v5" }
-func (p *regconfirmationV5) kind() byte { return p_regconfirmationV5 }
-func (p *regconfirmationV5) setreqid(id []byte) { p.ReqID = id }
-
-func (p *regconfirmationV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
- t.handleCallResponse(fromID, fromAddr, p.ReqID, p)
-}
-
-// TOPICQUERY
-
-func (p *topicqueryV5) name() string { return "TOPICQUERY/v5" }
-func (p *topicqueryV5) kind() byte { return p_topicqueryV5 }
-func (p *topicqueryV5) setreqid(id []byte) { p.ReqID = id }
-
-func (p *topicqueryV5) handle(t *UDPv5, fromID enode.ID, fromAddr *net.UDPAddr) {
+ var response []byte
+ if handler != nil {
+ response = handler(p.Message)
+ }
+ resp := &v5wire.TalkResponse{ReqID: p.ReqID, Message: response}
+ t.sendResponse(fromID, fromAddr, resp)
}
diff --git a/p2p/discover/v5_udp_test.go b/p2p/discover/v5_udp_test.go
index f3af55b208d7..6779972ff7a9 100644
--- a/p2p/discover/v5_udp_test.go
+++ b/p2p/discover/v5_udp_test.go
@@ -24,22 +24,25 @@ import (
"math/rand"
"net"
"reflect"
+ "sort"
"testing"
"time"
"github.com/XinFinOrg/XDPoSChain/internal/testlog"
"github.com/XinFinOrg/XDPoSChain/log"
+ "github.com/XinFinOrg/XDPoSChain/p2p/discover/v5wire"
"github.com/XinFinOrg/XDPoSChain/p2p/enode"
"github.com/XinFinOrg/XDPoSChain/p2p/enr"
"github.com/XinFinOrg/XDPoSChain/rlp"
)
// Real sockets, real crypto: this test checks end-to-end connectivity for UDPv5.
-func TestEndToEndV5(t *testing.T) {
+func TestUDPv5_lookupE2E(t *testing.T) {
t.Parallel()
+ const N = 5
var nodes []*UDPv5
- for i := 0; i < 5; i++ {
+ for i := 0; i < N; i++ {
var cfg Config
if len(nodes) > 0 {
bn := nodes[0].Self()
@@ -49,12 +52,34 @@ func TestEndToEndV5(t *testing.T) {
nodes = append(nodes, node)
defer node.Close()
}
+ last := nodes[N-1]
+ target := nodes[rand.Intn(N-2)].Self()
- last := nodes[len(nodes)-1]
- target := nodes[rand.Intn(len(nodes)-2)].Self()
- results := last.Lookup(target.ID())
- if len(results) == 0 || results[0].ID() != target.ID() {
- t.Fatalf("lookup returned wrong results: %v", results)
+ // Do lookups until the target is discovered.
+ var results []*enode.Node
+ deadline := time.Now().Add(3 * time.Second)
+ for {
+ results = last.Lookup(target.ID())
+ found := false
+ for _, n := range results {
+ if n.ID() == target.ID() {
+ found = true
+ break
+ }
+ }
+ if found {
+ break
+ }
+ if time.Now().After(deadline) {
+ t.Fatalf("lookup failed to discover target %v, got %d nodes", target.ID(), len(results))
+ }
+ time.Sleep(50 * time.Millisecond)
+ }
+
+ if !sort.SliceIsSorted(results, func(i, j int) bool {
+ return enode.DistCmp(target.ID(), results[i].ID(), results[j].ID()) < 0
+ }) {
+ t.Fatalf("lookup returned nodes out of distance order")
}
}
@@ -88,8 +113,8 @@ func TestUDPv5_pingHandling(t *testing.T) {
test := newUDPV5Test(t)
defer test.close()
- test.packetIn(&pingV5{ReqID: []byte("foo")})
- test.waitPacketOut(func(p *pongV5, addr *net.UDPAddr, authTag []byte) {
+ test.packetIn(&v5wire.Ping{ReqID: []byte("foo")})
+ test.waitPacketOut(func(p *v5wire.Pong, addr *net.UDPAddr, _ v5wire.Nonce) {
if !bytes.Equal(p.ReqID, []byte("foo")) {
t.Error("wrong request ID in response:", p.ReqID)
}
@@ -105,13 +130,13 @@ func TestUDPv5_unknownPacket(t *testing.T) {
test := newUDPV5Test(t)
defer test.close()
- authTag := [12]byte{1, 2, 3}
- check := func(p *whoareyouV5, wantSeq uint64) {
+ nonce := v5wire.Nonce{1, 2, 3}
+ check := func(p *v5wire.Whoareyou, wantSeq uint64) {
t.Helper()
- if !bytes.Equal(p.AuthTag, authTag[:]) {
- t.Error("wrong token in WHOAREYOU:", p.AuthTag, authTag[:])
+ if p.Nonce != nonce {
+ t.Error("wrong nonce in WHOAREYOU:", p.Nonce, nonce)
}
- if p.IDNonce == ([32]byte{}) {
+ if p.IDNonce == ([16]byte{}) {
t.Error("all zero ID nonce")
}
if p.RecordSeq != wantSeq {
@@ -120,8 +145,8 @@ func TestUDPv5_unknownPacket(t *testing.T) {
}
// Unknown packet from unknown node.
- test.packetIn(&unknownV5{AuthTag: authTag[:]})
- test.waitPacketOut(func(p *whoareyouV5, addr *net.UDPAddr, _ []byte) {
+ test.packetIn(&v5wire.Unknown{Nonce: nonce})
+ test.waitPacketOut(func(p *v5wire.Whoareyou, addr *net.UDPAddr, _ v5wire.Nonce) {
check(p, 0)
})
@@ -129,8 +154,8 @@ func TestUDPv5_unknownPacket(t *testing.T) {
n := test.getNode(test.remotekey, test.remoteaddr).Node()
test.table.addSeenNode(wrapNode(n))
- test.packetIn(&unknownV5{AuthTag: authTag[:]})
- test.waitPacketOut(func(p *whoareyouV5, addr *net.UDPAddr, _ []byte) {
+ test.packetIn(&v5wire.Unknown{Nonce: nonce})
+ test.waitPacketOut(func(p *v5wire.Whoareyou, addr *net.UDPAddr, _ v5wire.Nonce) {
check(p, n.Seq())
})
}
@@ -142,24 +167,40 @@ func TestUDPv5_findnodeHandling(t *testing.T) {
defer test.close()
// Create test nodes and insert them into the table.
- nodes := nodesAtDistance(test.table.self().ID(), 253, 10)
- fillTable(test.table, wrapNodes(nodes))
+ nodes253 := nodesAtDistance(test.table.self().ID(), 253, 10)
+ nodes249 := nodesAtDistance(test.table.self().ID(), 249, 4)
+ nodes248 := nodesAtDistance(test.table.self().ID(), 248, 10)
+ fillTable(test.table, wrapNodes(nodes253))
+ fillTable(test.table, wrapNodes(nodes249))
+ fillTable(test.table, wrapNodes(nodes248))
// Requesting with distance zero should return the node's own record.
- test.packetIn(&findnodeV5{ReqID: []byte{0}, Distance: 0})
+ test.packetIn(&v5wire.Findnode{ReqID: []byte{0}, Distances: []uint{0}})
test.expectNodes([]byte{0}, 1, []*enode.Node{test.udp.Self()})
- // Requesting with distance > 256 caps it at 256.
- test.packetIn(&findnodeV5{ReqID: []byte{1}, Distance: 4234098})
+ // Requesting with distance > 256 shouldn't crash.
+ test.packetIn(&v5wire.Findnode{ReqID: []byte{1}, Distances: []uint{4234098}})
test.expectNodes([]byte{1}, 1, nil)
- // This request gets no nodes because the corresponding bucket is empty.
- test.packetIn(&findnodeV5{ReqID: []byte{2}, Distance: 254})
+ // Requesting with empty distance list shouldn't crash either.
+ test.packetIn(&v5wire.Findnode{ReqID: []byte{2}, Distances: []uint{}})
test.expectNodes([]byte{2}, 1, nil)
- // This request gets all test nodes.
- test.packetIn(&findnodeV5{ReqID: []byte{3}, Distance: 253})
- test.expectNodes([]byte{3}, 4, nodes)
+ // This request gets no nodes because the corresponding bucket is empty.
+ test.packetIn(&v5wire.Findnode{ReqID: []byte{3}, Distances: []uint{254}})
+ test.expectNodes([]byte{3}, 1, nil)
+
+ // This request gets all the distance-253 nodes.
+ test.packetIn(&v5wire.Findnode{ReqID: []byte{4}, Distances: []uint{253}})
+ test.expectNodes([]byte{4}, 4, nodes253)
+
+ // This request gets all the distance-249 nodes and some more at 248 because
+ // the bucket at 249 is not full.
+ test.packetIn(&v5wire.Findnode{ReqID: []byte{5}, Distances: []uint{249, 248}})
+ var nodes []*enode.Node
+ nodes = append(nodes, nodes249...)
+ nodes = append(nodes, nodes248[:10]...)
+ test.expectNodes([]byte{5}, 5, nodes)
}
func (test *udpV5Test) expectNodes(wantReqID []byte, wantTotal uint8, wantNodes []*enode.Node) {
@@ -167,16 +208,17 @@ func (test *udpV5Test) expectNodes(wantReqID []byte, wantTotal uint8, wantNodes
for _, n := range wantNodes {
nodeSet[n.ID()] = n.Record()
}
+
for {
- test.waitPacketOut(func(p *nodesV5, addr *net.UDPAddr, authTag []byte) {
+ test.waitPacketOut(func(p *v5wire.Nodes, addr *net.UDPAddr, _ v5wire.Nonce) {
+ if !bytes.Equal(p.ReqID, wantReqID) {
+ test.t.Fatalf("wrong request ID %v in response, want %v", p.ReqID, wantReqID)
+ }
if len(p.Nodes) > 3 {
test.t.Fatalf("too many nodes in response")
}
if p.Total != wantTotal {
- test.t.Fatalf("wrong total response count %d", p.Total)
- }
- if !bytes.Equal(p.ReqID, wantReqID) {
- test.t.Fatalf("wrong request ID in response: %v", p.ReqID)
+ test.t.Fatalf("wrong total response count %d, want %d", p.Total, wantTotal)
}
for _, record := range p.Nodes {
n, _ := enode.New(enode.ValidSchemesForTesting, record)
@@ -210,7 +252,7 @@ func TestUDPv5_pingCall(t *testing.T) {
_, err := test.udp.ping(remote)
done <- err
}()
- test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {})
+ test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {})
if err := <-done; err != errTimeout {
t.Fatalf("want errTimeout, got %q", err)
}
@@ -220,8 +262,8 @@ func TestUDPv5_pingCall(t *testing.T) {
_, err := test.udp.ping(remote)
done <- err
}()
- test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
- test.packetInFrom(test.remotekey, test.remoteaddr, &pongV5{ReqID: p.ReqID})
+ test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {
+ test.packetInFrom(test.remotekey, test.remoteaddr, &v5wire.Pong{ReqID: p.ReqID})
})
if err := <-done; err != nil {
t.Fatal(err)
@@ -232,9 +274,9 @@ func TestUDPv5_pingCall(t *testing.T) {
_, err := test.udp.ping(remote)
done <- err
}()
- test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
+ test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {
wrongAddr := &net.UDPAddr{IP: net.IP{33, 44, 55, 22}, Port: 10101}
- test.packetInFrom(test.remotekey, wrongAddr, &pongV5{ReqID: p.ReqID})
+ test.packetInFrom(test.remotekey, wrongAddr, &v5wire.Pong{ReqID: p.ReqID})
})
if err := <-done; err != errTimeout {
t.Fatalf("want errTimeout for reply from wrong IP, got %q", err)
@@ -250,29 +292,29 @@ func TestUDPv5_findnodeCall(t *testing.T) {
// Launch the request:
var (
- distance = 230
- remote = test.getNode(test.remotekey, test.remoteaddr).Node()
- nodes = nodesAtDistance(remote.ID(), distance, 8)
- done = make(chan error, 1)
- response []*enode.Node
+ distances = []uint{230}
+ remote = test.getNode(test.remotekey, test.remoteaddr).Node()
+ nodes = nodesAtDistance(remote.ID(), int(distances[0]), 8)
+ done = make(chan error, 1)
+ response []*enode.Node
)
go func() {
var err error
- response, err = test.udp.findnode(remote, distance)
+ response, err = test.udp.findnode(remote, distances)
done <- err
}()
// Serve the responses:
- test.waitPacketOut(func(p *findnodeV5, addr *net.UDPAddr, authTag []byte) {
- if p.Distance != uint(distance) {
- t.Fatalf("wrong bucket: %d", p.Distance)
+ test.waitPacketOut(func(p *v5wire.Findnode, addr *net.UDPAddr, _ v5wire.Nonce) {
+ if !reflect.DeepEqual(p.Distances, distances) {
+ t.Fatalf("wrong distances in request: %v", p.Distances)
}
- test.packetIn(&nodesV5{
+ test.packetIn(&v5wire.Nodes{
ReqID: p.ReqID,
Total: 2,
Nodes: nodesToRecords(nodes[:4]),
})
- test.packetIn(&nodesV5{
+ test.packetIn(&v5wire.Nodes{
ReqID: p.ReqID,
Total: 2,
Nodes: nodesToRecords(nodes[4:]),
@@ -309,16 +351,16 @@ func TestUDPv5_callResend(t *testing.T) {
}()
// Ping answered by WHOAREYOU.
- test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
- test.packetIn(&whoareyouV5{AuthTag: authTag})
+ test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, nonce v5wire.Nonce) {
+ test.packetIn(&v5wire.Whoareyou{Nonce: nonce})
})
// Ping should be re-sent.
- test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
- test.packetIn(&pongV5{ReqID: p.ReqID})
+ test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {
+ test.packetIn(&v5wire.Pong{ReqID: p.ReqID})
})
// Answer the other ping.
- test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
- test.packetIn(&pongV5{ReqID: p.ReqID})
+ test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, _ v5wire.Nonce) {
+ test.packetIn(&v5wire.Pong{ReqID: p.ReqID})
})
if err := <-done; err != nil {
t.Fatalf("unexpected ping error: %v", err)
@@ -342,12 +384,12 @@ func TestUDPv5_multipleHandshakeRounds(t *testing.T) {
}()
// Ping answered by WHOAREYOU.
- test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
- test.packetIn(&whoareyouV5{AuthTag: authTag})
+ test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, nonce v5wire.Nonce) {
+ test.packetIn(&v5wire.Whoareyou{Nonce: nonce})
})
// Ping answered by WHOAREYOU again.
- test.waitPacketOut(func(p *pingV5, addr *net.UDPAddr, authTag []byte) {
- test.packetIn(&whoareyouV5{AuthTag: authTag})
+ test.waitPacketOut(func(p *v5wire.Ping, addr *net.UDPAddr, nonce v5wire.Nonce) {
+ test.packetIn(&v5wire.Whoareyou{Nonce: nonce})
})
if err := <-done; err != errTimeout {
t.Fatalf("unexpected ping error: %q", err)
@@ -362,27 +404,27 @@ func TestUDPv5_callTimeoutReset(t *testing.T) {
// Launch the request:
var (
- distance = 230
+ distance = uint(230)
remote = test.getNode(test.remotekey, test.remoteaddr).Node()
- nodes = nodesAtDistance(remote.ID(), distance, 8)
+ nodes = nodesAtDistance(remote.ID(), int(distance), 8)
done = make(chan error, 1)
)
go func() {
- _, err := test.udp.findnode(remote, distance)
+ _, err := test.udp.findnode(remote, []uint{distance})
done <- err
}()
// Serve two responses, slowly.
- test.waitPacketOut(func(p *findnodeV5, addr *net.UDPAddr, authTag []byte) {
+ test.waitPacketOut(func(p *v5wire.Findnode, addr *net.UDPAddr, _ v5wire.Nonce) {
time.Sleep(respTimeout - 50*time.Millisecond)
- test.packetIn(&nodesV5{
+ test.packetIn(&v5wire.Nodes{
ReqID: p.ReqID,
Total: 2,
Nodes: nodesToRecords(nodes[:4]),
})
time.Sleep(respTimeout - 50*time.Millisecond)
- test.packetIn(&nodesV5{
+ test.packetIn(&v5wire.Nodes{
ReqID: p.ReqID,
Total: 2,
Nodes: nodesToRecords(nodes[4:]),
@@ -393,6 +435,97 @@ func TestUDPv5_callTimeoutReset(t *testing.T) {
}
}
+// This test checks that TALKREQ calls the registered handler function.
+func TestUDPv5_talkHandling(t *testing.T) {
+ t.Parallel()
+ test := newUDPV5Test(t)
+ defer test.close()
+
+ var recvMessage []byte
+ test.udp.RegisterTalkHandler("test", func(message []byte) []byte {
+ recvMessage = message
+ return []byte("test response")
+ })
+
+ // Successful case:
+ test.packetIn(&v5wire.TalkRequest{
+ ReqID: []byte("foo"),
+ Protocol: "test",
+ Message: []byte("test request"),
+ })
+ test.waitPacketOut(func(p *v5wire.TalkResponse, addr *net.UDPAddr, _ v5wire.Nonce) {
+ if !bytes.Equal(p.ReqID, []byte("foo")) {
+ t.Error("wrong request ID in response:", p.ReqID)
+ }
+ if string(p.Message) != "test response" {
+ t.Errorf("wrong talk response message: %q", p.Message)
+ }
+ if string(recvMessage) != "test request" {
+ t.Errorf("wrong message received in handler: %q", recvMessage)
+ }
+ })
+
+ // Check that empty response is returned for unregistered protocols.
+ recvMessage = nil
+ test.packetIn(&v5wire.TalkRequest{
+ ReqID: []byte("2"),
+ Protocol: "wrong",
+ Message: []byte("test request"),
+ })
+ test.waitPacketOut(func(p *v5wire.TalkResponse, addr *net.UDPAddr, _ v5wire.Nonce) {
+ if !bytes.Equal(p.ReqID, []byte("2")) {
+ t.Error("wrong request ID in response:", p.ReqID)
+ }
+ if string(p.Message) != "" {
+ t.Errorf("wrong talk response message: %q", p.Message)
+ }
+ if recvMessage != nil {
+ t.Errorf("handler was called for wrong protocol: %q", recvMessage)
+ }
+ })
+}
+
+// This test checks that outgoing TALKREQ calls work.
+func TestUDPv5_talkRequest(t *testing.T) {
+ t.Parallel()
+ test := newUDPV5Test(t)
+ defer test.close()
+
+ remote := test.getNode(test.remotekey, test.remoteaddr).Node()
+ done := make(chan error, 1)
+
+ // This request times out.
+ go func() {
+ _, err := test.udp.TalkRequest(remote, "test", []byte("test request"))
+ done <- err
+ }()
+ test.waitPacketOut(func(p *v5wire.TalkRequest, addr *net.UDPAddr, _ v5wire.Nonce) {})
+ if err := <-done; err != errTimeout {
+ t.Fatalf("want errTimeout, got %q", err)
+ }
+
+ // This request works.
+ go func() {
+ _, err := test.udp.TalkRequest(remote, "test", []byte("test request"))
+ done <- err
+ }()
+ test.waitPacketOut(func(p *v5wire.TalkRequest, addr *net.UDPAddr, _ v5wire.Nonce) {
+ if p.Protocol != "test" {
+ t.Errorf("wrong protocol ID in talk request: %q", p.Protocol)
+ }
+ if string(p.Message) != "test request" {
+ t.Errorf("wrong message talk request: %q", p.Message)
+ }
+ test.packetInFrom(test.remotekey, test.remoteaddr, &v5wire.TalkResponse{
+ ReqID: p.ReqID,
+ Message: []byte("test response"),
+ })
+ })
+ if err := <-done; err != nil {
+ t.Fatal(err)
+ }
+}
+
// This test checks that lookup works.
func TestUDPv5_lookup(t *testing.T) {
t.Parallel()
@@ -412,7 +545,8 @@ func TestUDPv5_lookup(t *testing.T) {
}
// Seed table with initial node.
- fillTable(test.table, []*node{wrapNode(lookupTestnet.node(256, 0))})
+ initialNode := lookupTestnet.node(256, 0)
+ fillTable(test.table, []*node{wrapNode(initialNode)})
// Start the lookup.
resultC := make(chan []*enode.Node, 1)
@@ -422,22 +556,30 @@ func TestUDPv5_lookup(t *testing.T) {
}()
// Answer lookup packets.
+ asked := make(map[enode.ID]bool)
for done := false; !done; {
- done = test.waitPacketOut(func(p packetV5, to *net.UDPAddr, authTag []byte) {
+ done = test.waitPacketOut(func(p v5wire.Packet, to *net.UDPAddr, _ v5wire.Nonce) {
recipient, key := lookupTestnet.nodeByAddr(to)
switch p := p.(type) {
- case *pingV5:
- test.packetInFrom(key, to, &pongV5{ReqID: p.ReqID})
- case *findnodeV5:
- nodes := lookupTestnet.neighborsAtDistance(recipient, p.Distance, 3)
- response := &nodesV5{ReqID: p.ReqID, Total: 1, Nodes: nodesToRecords(nodes)}
- test.packetInFrom(key, to, response)
+ case *v5wire.Ping:
+ test.packetInFrom(key, to, &v5wire.Pong{ReqID: p.ReqID})
+ case *v5wire.Findnode:
+ if asked[recipient.ID()] {
+ t.Error("Asked node", recipient.ID(), "twice")
+ }
+ asked[recipient.ID()] = true
+ nodes := lookupTestnet.neighborsAtDistances(recipient, p.Distances, 16)
+ t.Logf("Got FINDNODE for %v, returning %d nodes", p.Distances, len(nodes))
+ for _, resp := range packNodes(p.ReqID, nodes) {
+ test.packetInFrom(key, to, resp)
+ }
}
})
}
// Verify result nodes.
- checkLookupResults(t, lookupTestnet, <-resultC)
+ results := <-resultC
+ checkLookupResults(t, lookupTestnet, results)
}
// This test checks the local node can be utilised to set key-values.
@@ -476,6 +618,7 @@ type udpV5Test struct {
nodesByIP map[string]*enode.LocalNode
}
+// testCodec is the packet encoding used by protocol tests. This codec does not perform encryption.
type testCodec struct {
test *udpV5Test
id enode.ID
@@ -484,46 +627,44 @@ type testCodec struct {
type testCodecFrame struct {
NodeID enode.ID
- AuthTag []byte
+ AuthTag v5wire.Nonce
Ptype byte
Packet rlp.RawValue
}
-func (c *testCodec) encode(toID enode.ID, addr string, p packetV5, _ *whoareyouV5) ([]byte, []byte, error) {
+func (c *testCodec) Encode(toID enode.ID, addr string, p v5wire.Packet, _ *v5wire.Whoareyou) ([]byte, v5wire.Nonce, error) {
c.ctr++
- authTag := make([]byte, 8)
- binary.BigEndian.PutUint64(authTag, c.ctr)
+ var authTag v5wire.Nonce
+ binary.BigEndian.PutUint64(authTag[:], c.ctr)
+
penc, _ := rlp.EncodeToBytes(p)
- frame, err := rlp.EncodeToBytes(testCodecFrame{c.id, authTag, p.kind(), penc})
+ frame, err := rlp.EncodeToBytes(testCodecFrame{c.id, authTag, p.Kind(), penc})
return frame, authTag, err
}
-func (c *testCodec) decode(input []byte, addr string) (enode.ID, *enode.Node, packetV5, error) {
+func (c *testCodec) Decode(input []byte, addr string) (enode.ID, *enode.Node, v5wire.Packet, error) {
frame, p, err := c.decodeFrame(input)
if err != nil {
return enode.ID{}, nil, nil, err
}
- if p.kind() == p_whoareyouV5 {
- frame.NodeID = enode.ID{} // match wireCodec behavior
- }
return frame.NodeID, nil, p, nil
}
-func (c *testCodec) decodeFrame(input []byte) (frame testCodecFrame, p packetV5, err error) {
+func (c *testCodec) decodeFrame(input []byte) (frame testCodecFrame, p v5wire.Packet, err error) {
if err = rlp.DecodeBytes(input, &frame); err != nil {
return frame, nil, fmt.Errorf("invalid frame: %v", err)
}
switch frame.Ptype {
- case p_unknownV5:
- dec := new(unknownV5)
+ case v5wire.UnknownPacket:
+ dec := new(v5wire.Unknown)
err = rlp.DecodeBytes(frame.Packet, &dec)
p = dec
- case p_whoareyouV5:
- dec := new(whoareyouV5)
+ case v5wire.WhoareyouPacket:
+ dec := new(v5wire.Whoareyou)
err = rlp.DecodeBytes(frame.Packet, &dec)
p = dec
default:
- p, err = decodePacketBodyV5(frame.Ptype, frame.Packet)
+ p, err = v5wire.DecodeMessage(frame.Ptype, frame.Packet)
}
return frame, p, err
}
@@ -556,20 +697,20 @@ func newUDPV5Test(t *testing.T) *udpV5Test {
}
// handles a packet as if it had been sent to the transport.
-func (test *udpV5Test) packetIn(packet packetV5) {
+func (test *udpV5Test) packetIn(packet v5wire.Packet) {
test.t.Helper()
test.packetInFrom(test.remotekey, test.remoteaddr, packet)
}
// handles a packet as if it had been sent to the transport by the key/endpoint.
-func (test *udpV5Test) packetInFrom(key *ecdsa.PrivateKey, addr *net.UDPAddr, packet packetV5) {
+func (test *udpV5Test) packetInFrom(key *ecdsa.PrivateKey, addr *net.UDPAddr, packet v5wire.Packet) {
test.t.Helper()
ln := test.getNode(key, addr)
codec := &testCodec{test: test, id: ln.ID()}
- enc, _, err := codec.encode(test.udp.Self().ID(), addr.String(), packet, nil)
+ enc, _, err := codec.Encode(test.udp.Self().ID(), addr.String(), packet, nil)
if err != nil {
- test.t.Errorf("%s encode error: %v", packet.name(), err)
+ test.t.Errorf("%s encode error: %v", packet.Name(), err)
}
if test.udp.dispatchReadPacket(addr, enc) {
<-test.udp.readNextCh // unblock UDPv5.dispatch
@@ -591,8 +732,12 @@ func (test *udpV5Test) getNode(key *ecdsa.PrivateKey, addr *net.UDPAddr) *enode.
return ln
}
+// waitPacketOut waits for the next output packet and handles it using the given 'validate'
+// function. The function must be of type func (X, *net.UDPAddr, v5wire.Nonce) where X is
+// assignable to packetV5.
func (test *udpV5Test) waitPacketOut(validate interface{}) (closed bool) {
test.t.Helper()
+
fn := reflect.ValueOf(validate)
exptype := fn.Type().In(0)
diff --git a/p2p/discover/v5wire/crypto.go b/p2p/discover/v5wire/crypto.go
new file mode 100644
index 000000000000..f414d8418922
--- /dev/null
+++ b/p2p/discover/v5wire/crypto.go
@@ -0,0 +1,180 @@
+// Copyright 2020 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 .
+
+package v5wire
+
+import (
+ "crypto/aes"
+ "crypto/cipher"
+ "crypto/ecdsa"
+ "crypto/elliptic"
+ "errors"
+ "fmt"
+ "hash"
+
+ "github.com/XinFinOrg/XDPoSChain/common/math"
+ "github.com/XinFinOrg/XDPoSChain/crypto"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enode"
+ "golang.org/x/crypto/hkdf"
+)
+
+const (
+ // Encryption/authentication parameters.
+ aesKeySize = 16
+ gcmNonceSize = 12
+)
+
+// Nonce represents a nonce used for AES/GCM.
+type Nonce [gcmNonceSize]byte
+
+// EncodePubkey encodes a public key.
+func EncodePubkey(key *ecdsa.PublicKey) []byte {
+ switch key.Curve {
+ case crypto.S256():
+ return crypto.CompressPubkey(key)
+ default:
+ panic("unsupported curve " + key.Curve.Params().Name + " in EncodePubkey")
+ }
+}
+
+// DecodePubkey decodes a public key in compressed format.
+func DecodePubkey(curve elliptic.Curve, e []byte) (*ecdsa.PublicKey, error) {
+ switch curve {
+ case crypto.S256():
+ if len(e) != 33 {
+ return nil, errors.New("wrong size public key data")
+ }
+ return crypto.DecompressPubkey(e)
+ default:
+ return nil, fmt.Errorf("unsupported curve %s in DecodePubkey", curve.Params().Name)
+ }
+}
+
+// idNonceHash computes the ID signature hash used in the handshake.
+func idNonceHash(h hash.Hash, challenge, ephkey []byte, destID enode.ID) []byte {
+ h.Reset()
+ h.Write([]byte("discovery v5 identity proof"))
+ h.Write(challenge)
+ h.Write(ephkey)
+ h.Write(destID[:])
+ return h.Sum(nil)
+}
+
+// makeIDSignature creates the ID nonce signature.
+func makeIDSignature(hash hash.Hash, key *ecdsa.PrivateKey, challenge, ephkey []byte, destID enode.ID) ([]byte, error) {
+ input := idNonceHash(hash, challenge, ephkey, destID)
+ switch key.Curve {
+ case crypto.S256():
+ idsig, err := crypto.Sign(input, key)
+ if err != nil {
+ return nil, err
+ }
+ return idsig[:len(idsig)-1], nil // remove recovery ID
+ default:
+ return nil, fmt.Errorf("unsupported curve %s", key.Curve.Params().Name)
+ }
+}
+
+// s256raw is an unparsed secp256k1 public key ENR entry.
+type s256raw []byte
+
+func (s256raw) ENRKey() string { return "secp256k1" }
+
+// verifyIDSignature checks that signature over idnonce was made by the given node.
+func verifyIDSignature(hash hash.Hash, sig []byte, n *enode.Node, challenge, ephkey []byte, destID enode.ID) error {
+ switch idscheme := n.Record().IdentityScheme(); idscheme {
+ case "v4":
+ var pubkey s256raw
+ if n.Load(&pubkey) != nil {
+ return errors.New("no secp256k1 public key in record")
+ }
+ input := idNonceHash(hash, challenge, ephkey, destID)
+ if !crypto.VerifySignature(pubkey, input, sig) {
+ return errInvalidNonceSig
+ }
+ return nil
+ default:
+ return fmt.Errorf("can't verify ID nonce signature against scheme %q", idscheme)
+ }
+}
+
+type hashFn func() hash.Hash
+
+// deriveKeys creates the session keys.
+func deriveKeys(hash hashFn, priv *ecdsa.PrivateKey, pub *ecdsa.PublicKey, n1, n2 enode.ID, challenge []byte) *session {
+ const text = "discovery v5 key agreement"
+ var info = make([]byte, 0, len(text)+len(n1)+len(n2))
+ info = append(info, text...)
+ info = append(info, n1[:]...)
+ info = append(info, n2[:]...)
+
+ eph := ecdh(priv, pub)
+ if eph == nil {
+ return nil
+ }
+ kdf := hkdf.New(hash, eph, challenge, info)
+ sec := session{writeKey: make([]byte, aesKeySize), readKey: make([]byte, aesKeySize)}
+ kdf.Read(sec.writeKey)
+ kdf.Read(sec.readKey)
+ for i := range eph {
+ eph[i] = 0
+ }
+ return &sec
+}
+
+// ecdh creates a shared secret.
+func ecdh(privkey *ecdsa.PrivateKey, pubkey *ecdsa.PublicKey) []byte {
+ secX, secY := pubkey.ScalarMult(pubkey.X, pubkey.Y, privkey.D.Bytes())
+ if secX == nil {
+ return nil
+ }
+ sec := make([]byte, 33)
+ sec[0] = 0x02 | byte(secY.Bit(0))
+ math.ReadBits(secX, sec[1:])
+ return sec
+}
+
+// encryptGCM encrypts pt using AES-GCM with the given key and nonce. The ciphertext is
+// appended to dest, which must not overlap with plaintext. The resulting ciphertext is 16
+// bytes longer than plaintext because it contains an authentication tag.
+func encryptGCM(dest, key, nonce, plaintext, authData []byte) ([]byte, error) {
+ block, err := aes.NewCipher(key)
+ if err != nil {
+ panic(fmt.Errorf("can't create block cipher: %v", err))
+ }
+ aesgcm, err := cipher.NewGCMWithNonceSize(block, gcmNonceSize)
+ if err != nil {
+ panic(fmt.Errorf("can't create GCM: %v", err))
+ }
+ return aesgcm.Seal(dest, nonce, plaintext, authData), nil
+}
+
+// decryptGCM decrypts ct using AES-GCM with the given key and nonce.
+func decryptGCM(key, nonce, ct, authData []byte) ([]byte, error) {
+ block, err := aes.NewCipher(key)
+ if err != nil {
+ return nil, fmt.Errorf("can't create block cipher: %v", err)
+ }
+ if len(nonce) != gcmNonceSize {
+ return nil, fmt.Errorf("invalid GCM nonce size: %d", len(nonce))
+ }
+ aesgcm, err := cipher.NewGCMWithNonceSize(block, gcmNonceSize)
+ if err != nil {
+ return nil, fmt.Errorf("can't create GCM: %v", err)
+ }
+ pt := make([]byte, 0, len(ct))
+ return aesgcm.Open(pt, nonce, ct, authData)
+}
diff --git a/p2p/discover/v5wire/crypto_test.go b/p2p/discover/v5wire/crypto_test.go
new file mode 100644
index 000000000000..12c202daa2a3
--- /dev/null
+++ b/p2p/discover/v5wire/crypto_test.go
@@ -0,0 +1,124 @@
+// Copyright 2020 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 .
+
+package v5wire
+
+import (
+ "bytes"
+ "crypto/ecdsa"
+ "crypto/elliptic"
+ "crypto/sha256"
+ "reflect"
+ "strings"
+ "testing"
+
+ "github.com/XinFinOrg/XDPoSChain/common/hexutil"
+ "github.com/XinFinOrg/XDPoSChain/crypto"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enode"
+)
+
+func TestVector_ECDH(t *testing.T) {
+ var (
+ staticKey = hexPrivkey("0xfb757dc581730490a1d7a00deea65e9b1936924caaea8f44d476014856b68736")
+ publicKey = hexPubkey(crypto.S256(), "0x039961e4c2356d61bedb83052c115d311acb3a96f5777296dcf297351130266231")
+ want = hexutil.MustDecode("0x033b11a2a1f214567e1537ce5e509ffd9b21373247f2a3ff6841f4976f53165e7e")
+ )
+ result := ecdh(staticKey, publicKey)
+ check(t, "shared-secret", result, want)
+}
+
+func TestVector_KDF(t *testing.T) {
+ var (
+ ephKey = hexPrivkey("0xfb757dc581730490a1d7a00deea65e9b1936924caaea8f44d476014856b68736")
+ cdata = hexutil.MustDecode("0x000000000000000000000000000000006469736376350001010102030405060708090a0b0c00180102030405060708090a0b0c0d0e0f100000000000000000")
+ net = newHandshakeTest()
+ )
+ defer net.close()
+
+ destKey := &testKeyB.PublicKey
+ s := deriveKeys(sha256.New, ephKey, destKey, net.nodeA.id(), net.nodeB.id(), cdata)
+ t.Logf("ephemeral-key = %#x", ephKey.D)
+ t.Logf("dest-pubkey = %#x", EncodePubkey(destKey))
+ t.Logf("node-id-a = %#x", net.nodeA.id().Bytes())
+ t.Logf("node-id-b = %#x", net.nodeB.id().Bytes())
+ t.Logf("challenge-data = %#x", cdata)
+ check(t, "initiator-key", s.writeKey, hexutil.MustDecode("0xdccc82d81bd610f4f76d3ebe97a40571"))
+ check(t, "recipient-key", s.readKey, hexutil.MustDecode("0xac74bb8773749920b0d3a8881c173ec5"))
+}
+
+func TestVector_IDSignature(t *testing.T) {
+ var (
+ key = hexPrivkey("0xfb757dc581730490a1d7a00deea65e9b1936924caaea8f44d476014856b68736")
+ destID = enode.HexID("0xbbbb9d047f0488c0b5a93c1c3f2d8bafc7c8ff337024a55434a0d0555de64db9")
+ ephkey = hexutil.MustDecode("0x039961e4c2356d61bedb83052c115d311acb3a96f5777296dcf297351130266231")
+ cdata = hexutil.MustDecode("0x000000000000000000000000000000006469736376350001010102030405060708090a0b0c00180102030405060708090a0b0c0d0e0f100000000000000000")
+ )
+
+ sig, err := makeIDSignature(sha256.New(), key, cdata, ephkey, destID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Logf("static-key = %#x", key.D)
+ t.Logf("challenge-data = %#x", cdata)
+ t.Logf("ephemeral-pubkey = %#x", ephkey)
+ t.Logf("node-id-B = %#x", destID.Bytes())
+ expected := "0x94852a1e2318c4e5e9d422c98eaf19d1d90d876b29cd06ca7cb7546d0fff7b484fe86c09a064fe72bdbef73ba8e9c34df0cd2b53e9d65528c2c7f336d5dfc6e6"
+ check(t, "id-signature", sig, hexutil.MustDecode(expected))
+}
+
+func TestDeriveKeys(t *testing.T) {
+ t.Parallel()
+
+ var (
+ n1 = enode.ID{1}
+ n2 = enode.ID{2}
+ cdata = []byte{1, 2, 3, 4}
+ )
+ sec1 := deriveKeys(sha256.New, testKeyA, &testKeyB.PublicKey, n1, n2, cdata)
+ sec2 := deriveKeys(sha256.New, testKeyB, &testKeyA.PublicKey, n1, n2, cdata)
+ if sec1 == nil || sec2 == nil {
+ t.Fatal("key agreement failed")
+ }
+ if !reflect.DeepEqual(sec1, sec2) {
+ t.Fatalf("keys not equal:\n %+v\n %+v", sec1, sec2)
+ }
+}
+
+func check(t *testing.T, what string, x, y []byte) {
+ t.Helper()
+
+ if !bytes.Equal(x, y) {
+ t.Errorf("wrong %s: %#x != %#x", what, x, y)
+ } else {
+ t.Logf("%s = %#x", what, x)
+ }
+}
+
+func hexPrivkey(input string) *ecdsa.PrivateKey {
+ key, err := crypto.HexToECDSA(strings.TrimPrefix(input, "0x"))
+ if err != nil {
+ panic(err)
+ }
+ return key
+}
+
+func hexPubkey(curve elliptic.Curve, input string) *ecdsa.PublicKey {
+ key, err := DecodePubkey(curve, hexutil.MustDecode(input))
+ if err != nil {
+ panic(err)
+ }
+ return key
+}
diff --git a/p2p/discover/v5wire/encoding.go b/p2p/discover/v5wire/encoding.go
new file mode 100644
index 000000000000..e2d817c64b00
--- /dev/null
+++ b/p2p/discover/v5wire/encoding.go
@@ -0,0 +1,648 @@
+// Copyright 2019 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 .
+
+package v5wire
+
+import (
+ "bytes"
+ "crypto/aes"
+ "crypto/cipher"
+ "crypto/ecdsa"
+ crand "crypto/rand"
+ "crypto/sha256"
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "hash"
+
+ "github.com/XinFinOrg/XDPoSChain/common/mclock"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enode"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enr"
+ "github.com/XinFinOrg/XDPoSChain/rlp"
+)
+
+// TODO concurrent WHOAREYOU tie-breaker
+// TODO rehandshake after X packets
+
+// Header represents a packet header.
+type Header struct {
+ IV [sizeofMaskingIV]byte
+ StaticHeader
+ AuthData []byte
+
+ src enode.ID // used by decoder
+}
+
+// StaticHeader contains the static fields of a packet header.
+type StaticHeader struct {
+ ProtocolID [6]byte
+ Version uint16
+ Flag byte
+ Nonce Nonce
+ AuthSize uint16
+}
+
+// Authdata layouts.
+type (
+ whoareyouAuthData struct {
+ IDNonce [16]byte // ID proof data
+ RecordSeq uint64 // highest known ENR sequence of requester
+ }
+
+ handshakeAuthData struct {
+ h struct {
+ SrcID enode.ID
+ SigSize byte // ignature data
+ PubkeySize byte // offset of
+ }
+ // Trailing variable-size data.
+ signature, pubkey, record []byte
+ }
+
+ messageAuthData struct {
+ SrcID enode.ID
+ }
+)
+
+// Packet header flag values.
+const (
+ flagMessage = iota
+ flagWhoareyou
+ flagHandshake
+)
+
+// Protocol constants.
+const (
+ version = 1
+ minVersion = 1
+ sizeofMaskingIV = 16
+
+ minMessageSize = 48 // this refers to data after static headers
+ randomPacketMsgSize = 20
+)
+
+var protocolID = [6]byte{'d', 'i', 's', 'c', 'v', '5'}
+
+// Errors.
+var (
+ errTooShort = errors.New("packet too short")
+ errInvalidHeader = errors.New("invalid packet header")
+ errInvalidFlag = errors.New("invalid flag value in header")
+ errMinVersion = errors.New("version of packet header below minimum")
+ errMsgTooShort = errors.New("message/handshake packet below minimum size")
+ errAuthSize = errors.New("declared auth size is beyond packet length")
+ errUnexpectedHandshake = errors.New("unexpected auth response, not in handshake")
+ errInvalidAuthKey = errors.New("invalid ephemeral pubkey")
+ errNoRecord = errors.New("expected ENR in handshake but none sent")
+ errInvalidNonceSig = errors.New("invalid ID nonce signature")
+ errMessageTooShort = errors.New("message contains no data")
+ errMessageDecrypt = errors.New("cannot decrypt message")
+)
+
+// Public errors.
+var (
+ ErrInvalidReqID = errors.New("request ID larger than 8 bytes")
+)
+
+// Packet sizes.
+var (
+ sizeofStaticHeader = binary.Size(StaticHeader{})
+ sizeofWhoareyouAuthData = binary.Size(whoareyouAuthData{})
+ sizeofHandshakeAuthData = binary.Size(handshakeAuthData{}.h)
+ sizeofMessageAuthData = binary.Size(messageAuthData{})
+ sizeofStaticPacketData = sizeofMaskingIV + sizeofStaticHeader
+)
+
+// Codec encodes and decodes Discovery v5 packets.
+// This type is not safe for concurrent use.
+type Codec struct {
+ sha256 hash.Hash
+ localnode *enode.LocalNode
+ privkey *ecdsa.PrivateKey
+ sc *SessionCache
+
+ // encoder buffers
+ buf bytes.Buffer // whole packet
+ headbuf bytes.Buffer // packet header
+ msgbuf bytes.Buffer // message RLP plaintext
+ msgctbuf []byte // message data ciphertext
+
+ // decoder buffer
+ reader bytes.Reader
+}
+
+// NewCodec creates a wire codec.
+func NewCodec(ln *enode.LocalNode, key *ecdsa.PrivateKey, clock mclock.Clock) *Codec {
+ c := &Codec{
+ sha256: sha256.New(),
+ localnode: ln,
+ privkey: key,
+ sc: NewSessionCache(1024, clock),
+ }
+ return c
+}
+
+// Encode encodes a packet to a node. 'id' and 'addr' specify the destination node. The
+// 'challenge' parameter should be the most recently received WHOAREYOU packet from that
+// node.
+func (c *Codec) Encode(id enode.ID, addr string, packet Packet, challenge *Whoareyou) ([]byte, Nonce, error) {
+ // Create the packet header.
+ var (
+ head Header
+ session *session
+ msgData []byte
+ err error
+ )
+ switch {
+ case packet.Kind() == WhoareyouPacket:
+ head, err = c.encodeWhoareyou(id, packet.(*Whoareyou))
+ case challenge != nil:
+ // We have an unanswered challenge, send handshake.
+ head, session, err = c.encodeHandshakeHeader(id, addr, challenge)
+ default:
+ session = c.sc.session(id, addr)
+ if session != nil {
+ // There is a session, use it.
+ head, err = c.encodeMessageHeader(id, session)
+ } else {
+ // No keys, send random data to kick off the handshake.
+ head, msgData, err = c.encodeRandom(id)
+ }
+ }
+ if err != nil {
+ return nil, Nonce{}, err
+ }
+
+ // Generate masking IV.
+ if err := c.sc.maskingIVGen(head.IV[:]); err != nil {
+ return nil, Nonce{}, fmt.Errorf("can't generate masking IV: %v", err)
+ }
+
+ // Encode header data.
+ c.writeHeaders(&head)
+
+ // Store sent WHOAREYOU challenges.
+ if challenge, ok := packet.(*Whoareyou); ok {
+ challenge.ChallengeData = bytesCopy(&c.buf)
+ c.sc.storeSentHandshake(id, addr, challenge)
+ } else if msgData == nil {
+ headerData := c.buf.Bytes()
+ msgData, err = c.encryptMessage(session, packet, &head, headerData)
+ if err != nil {
+ return nil, Nonce{}, err
+ }
+ }
+
+ enc, err := c.EncodeRaw(id, head, msgData)
+ return enc, head.Nonce, err
+}
+
+// EncodeRaw encodes a packet with the given header.
+func (c *Codec) EncodeRaw(id enode.ID, head Header, msgdata []byte) ([]byte, error) {
+ c.writeHeaders(&head)
+
+ // Apply masking.
+ masked := c.buf.Bytes()[sizeofMaskingIV:]
+ mask := head.mask(id)
+ mask.XORKeyStream(masked[:], masked[:])
+
+ // Write message data.
+ c.buf.Write(msgdata)
+ return c.buf.Bytes(), nil
+}
+
+func (c *Codec) writeHeaders(head *Header) {
+ c.buf.Reset()
+ c.buf.Write(head.IV[:])
+ binary.Write(&c.buf, binary.BigEndian, &head.StaticHeader)
+ c.buf.Write(head.AuthData)
+}
+
+// makeHeader creates a packet header.
+func (c *Codec) makeHeader(toID enode.ID, flag byte, authsizeExtra int) Header {
+ var authsize int
+ switch flag {
+ case flagMessage:
+ authsize = sizeofMessageAuthData
+ case flagWhoareyou:
+ authsize = sizeofWhoareyouAuthData
+ case flagHandshake:
+ authsize = sizeofHandshakeAuthData
+ default:
+ panic(fmt.Errorf("BUG: invalid packet header flag %x", flag))
+ }
+ authsize += authsizeExtra
+ if authsize > int(^uint16(0)) {
+ panic(fmt.Errorf("BUG: auth size %d overflows uint16", authsize))
+ }
+ return Header{
+ StaticHeader: StaticHeader{
+ ProtocolID: protocolID,
+ Version: version,
+ Flag: flag,
+ AuthSize: uint16(authsize),
+ },
+ }
+}
+
+// encodeRandom encodes a packet with random content.
+func (c *Codec) encodeRandom(toID enode.ID) (Header, []byte, error) {
+ head := c.makeHeader(toID, flagMessage, 0)
+
+ // Encode auth data.
+ auth := messageAuthData{SrcID: c.localnode.ID()}
+ if _, err := crand.Read(head.Nonce[:]); err != nil {
+ return head, nil, fmt.Errorf("can't get random data: %v", err)
+ }
+ c.headbuf.Reset()
+ binary.Write(&c.headbuf, binary.BigEndian, auth)
+ head.AuthData = c.headbuf.Bytes()
+
+ // Fill message ciphertext buffer with random bytes.
+ c.msgctbuf = append(c.msgctbuf[:0], make([]byte, randomPacketMsgSize)...)
+ crand.Read(c.msgctbuf)
+ return head, c.msgctbuf, nil
+}
+
+// encodeWhoareyou encodes a WHOAREYOU packet.
+func (c *Codec) encodeWhoareyou(toID enode.ID, packet *Whoareyou) (Header, error) {
+ // Sanity check node field to catch misbehaving callers.
+ if packet.RecordSeq > 0 && packet.Node == nil {
+ panic("BUG: missing node in whoareyou with non-zero seq")
+ }
+
+ // Create header.
+ head := c.makeHeader(toID, flagWhoareyou, 0)
+ head.AuthData = bytesCopy(&c.buf)
+ head.Nonce = packet.Nonce
+
+ // Encode auth data.
+ auth := &whoareyouAuthData{
+ IDNonce: packet.IDNonce,
+ RecordSeq: packet.RecordSeq,
+ }
+ c.headbuf.Reset()
+ binary.Write(&c.headbuf, binary.BigEndian, auth)
+ head.AuthData = c.headbuf.Bytes()
+ return head, nil
+}
+
+// encodeHandshakeMessage encodes the handshake message packet header.
+func (c *Codec) encodeHandshakeHeader(toID enode.ID, addr string, challenge *Whoareyou) (Header, *session, error) {
+ // Ensure calling code sets challenge.node.
+ if challenge.Node == nil {
+ panic("BUG: missing challenge.Node in encode")
+ }
+
+ // Generate new secrets.
+ auth, session, err := c.makeHandshakeAuth(toID, addr, challenge)
+ if err != nil {
+ return Header{}, nil, err
+ }
+
+ // Generate nonce for message.
+ nonce, err := c.sc.nextNonce(session)
+ if err != nil {
+ return Header{}, nil, fmt.Errorf("can't generate nonce: %v", err)
+ }
+
+ // TODO: this should happen when the first authenticated message is received
+ c.sc.storeNewSession(toID, addr, session)
+
+ // Encode the auth header.
+ var (
+ authsizeExtra = len(auth.pubkey) + len(auth.signature) + len(auth.record)
+ head = c.makeHeader(toID, flagHandshake, authsizeExtra)
+ )
+ c.headbuf.Reset()
+ binary.Write(&c.headbuf, binary.BigEndian, &auth.h)
+ c.headbuf.Write(auth.signature)
+ c.headbuf.Write(auth.pubkey)
+ c.headbuf.Write(auth.record)
+ head.AuthData = c.headbuf.Bytes()
+ head.Nonce = nonce
+ return head, session, err
+}
+
+// encodeAuthHeader creates the auth header on a request packet following WHOAREYOU.
+func (c *Codec) makeHandshakeAuth(toID enode.ID, addr string, challenge *Whoareyou) (*handshakeAuthData, *session, error) {
+ auth := new(handshakeAuthData)
+ auth.h.SrcID = c.localnode.ID()
+
+ // Create the ephemeral key. This needs to be first because the
+ // key is part of the ID nonce signature.
+ var remotePubkey = new(ecdsa.PublicKey)
+ if err := challenge.Node.Load((*enode.Secp256k1)(remotePubkey)); err != nil {
+ return nil, nil, fmt.Errorf("can't find secp256k1 key for recipient")
+ }
+ ephkey, err := c.sc.ephemeralKeyGen()
+ if err != nil {
+ return nil, nil, fmt.Errorf("can't generate ephemeral key")
+ }
+ ephpubkey := EncodePubkey(&ephkey.PublicKey)
+ auth.pubkey = ephpubkey[:]
+ auth.h.PubkeySize = byte(len(auth.pubkey))
+
+ // Add ID nonce signature to response.
+ cdata := challenge.ChallengeData
+ idsig, err := makeIDSignature(c.sha256, c.privkey, cdata, ephpubkey[:], toID)
+ if err != nil {
+ return nil, nil, fmt.Errorf("can't sign: %v", err)
+ }
+ auth.signature = idsig
+ auth.h.SigSize = byte(len(auth.signature))
+
+ // Add our record to response if it's newer than what remote side has.
+ ln := c.localnode.Node()
+ if challenge.RecordSeq < ln.Seq() {
+ auth.record, _ = rlp.EncodeToBytes(ln.Record())
+ }
+
+ // Create session keys.
+ sec := deriveKeys(sha256.New, ephkey, remotePubkey, c.localnode.ID(), challenge.Node.ID(), cdata)
+ if sec == nil {
+ return nil, nil, fmt.Errorf("key derivation failed")
+ }
+ return auth, sec, err
+}
+
+// encodeMessage encodes an encrypted message packet.
+func (c *Codec) encodeMessageHeader(toID enode.ID, s *session) (Header, error) {
+ head := c.makeHeader(toID, flagMessage, 0)
+
+ // Create the header.
+ nonce, err := c.sc.nextNonce(s)
+ if err != nil {
+ return Header{}, fmt.Errorf("can't generate nonce: %v", err)
+ }
+ auth := messageAuthData{SrcID: c.localnode.ID()}
+ c.buf.Reset()
+ binary.Write(&c.buf, binary.BigEndian, &auth)
+ head.AuthData = bytesCopy(&c.buf)
+ head.Nonce = nonce
+ return head, err
+}
+
+func (c *Codec) encryptMessage(s *session, p Packet, head *Header, headerData []byte) ([]byte, error) {
+ // Encode message plaintext.
+ c.msgbuf.Reset()
+ c.msgbuf.WriteByte(p.Kind())
+ if err := rlp.Encode(&c.msgbuf, p); err != nil {
+ return nil, err
+ }
+ messagePT := c.msgbuf.Bytes()
+
+ // Encrypt into message ciphertext buffer.
+ messageCT, err := encryptGCM(c.msgctbuf[:0], s.writeKey, head.Nonce[:], messagePT, headerData)
+ if err == nil {
+ c.msgctbuf = messageCT
+ }
+ return messageCT, err
+}
+
+// Decode decodes a discovery packet.
+func (c *Codec) Decode(input []byte, addr string) (src enode.ID, n *enode.Node, p Packet, err error) {
+ // Unmask the static header.
+ if len(input) < sizeofStaticPacketData {
+ return enode.ID{}, nil, nil, errTooShort
+ }
+ var head Header
+ copy(head.IV[:], input[:sizeofMaskingIV])
+ mask := head.mask(c.localnode.ID())
+ staticHeader := input[sizeofMaskingIV:sizeofStaticPacketData]
+ mask.XORKeyStream(staticHeader, staticHeader)
+
+ // Decode and verify the static header.
+ c.reader.Reset(staticHeader)
+ binary.Read(&c.reader, binary.BigEndian, &head.StaticHeader)
+ remainingInput := len(input) - sizeofStaticPacketData
+ if err := head.checkValid(remainingInput); err != nil {
+ return enode.ID{}, nil, nil, err
+ }
+
+ // Unmask auth data.
+ authDataEnd := sizeofStaticPacketData + int(head.AuthSize)
+ authData := input[sizeofStaticPacketData:authDataEnd]
+ mask.XORKeyStream(authData, authData)
+ head.AuthData = authData
+
+ // Delete timed-out handshakes. This must happen before decoding to avoid
+ // processing the same handshake twice.
+ c.sc.handshakeGC()
+
+ // Decode auth part and message.
+ headerData := input[:authDataEnd]
+ msgData := input[authDataEnd:]
+ switch head.Flag {
+ case flagWhoareyou:
+ p, err = c.decodeWhoareyou(&head, headerData)
+ case flagHandshake:
+ n, p, err = c.decodeHandshakeMessage(addr, &head, headerData, msgData)
+ case flagMessage:
+ p, err = c.decodeMessage(addr, &head, headerData, msgData)
+ default:
+ err = errInvalidFlag
+ }
+ return head.src, n, p, err
+}
+
+// decodeWhoareyou reads packet data after the header as a WHOAREYOU packet.
+func (c *Codec) decodeWhoareyou(head *Header, headerData []byte) (Packet, error) {
+ if len(head.AuthData) != sizeofWhoareyouAuthData {
+ return nil, fmt.Errorf("invalid auth size %d for WHOAREYOU", len(head.AuthData))
+ }
+ var auth whoareyouAuthData
+ c.reader.Reset(head.AuthData)
+ binary.Read(&c.reader, binary.BigEndian, &auth)
+ p := &Whoareyou{
+ Nonce: head.Nonce,
+ IDNonce: auth.IDNonce,
+ RecordSeq: auth.RecordSeq,
+ ChallengeData: make([]byte, len(headerData)),
+ }
+ copy(p.ChallengeData, headerData)
+ return p, nil
+}
+
+func (c *Codec) decodeHandshakeMessage(fromAddr string, head *Header, headerData, msgData []byte) (n *enode.Node, p Packet, err error) {
+ node, auth, session, err := c.decodeHandshake(fromAddr, head)
+ if err != nil {
+ c.sc.deleteHandshake(auth.h.SrcID, fromAddr)
+ return nil, nil, err
+ }
+
+ // Decrypt the message using the new session keys.
+ msg, err := c.decryptMessage(msgData, head.Nonce[:], headerData, session.readKey)
+ if err != nil {
+ c.sc.deleteHandshake(auth.h.SrcID, fromAddr)
+ return node, msg, err
+ }
+
+ // Handshake OK, drop the challenge and store the new session keys.
+ c.sc.storeNewSession(auth.h.SrcID, fromAddr, session)
+ c.sc.deleteHandshake(auth.h.SrcID, fromAddr)
+ return node, msg, nil
+}
+
+func (c *Codec) decodeHandshake(fromAddr string, head *Header) (n *enode.Node, auth handshakeAuthData, s *session, err error) {
+ if auth, err = c.decodeHandshakeAuthData(head); err != nil {
+ return nil, auth, nil, err
+ }
+
+ // Verify against our last WHOAREYOU.
+ challenge := c.sc.getHandshake(auth.h.SrcID, fromAddr)
+ if challenge == nil {
+ return nil, auth, nil, errUnexpectedHandshake
+ }
+ // Get node record.
+ n, err = c.decodeHandshakeRecord(challenge.Node, auth.h.SrcID, auth.record)
+ if err != nil {
+ return nil, auth, nil, err
+ }
+ // Verify ID nonce signature.
+ sig := auth.signature
+ cdata := challenge.ChallengeData
+ err = verifyIDSignature(c.sha256, sig, n, cdata, auth.pubkey, c.localnode.ID())
+ if err != nil {
+ return nil, auth, nil, err
+ }
+ // Verify ephemeral key is on curve.
+ ephkey, err := DecodePubkey(c.privkey.Curve, auth.pubkey)
+ if err != nil {
+ return nil, auth, nil, errInvalidAuthKey
+ }
+ // Derive sesssion keys.
+ session := deriveKeys(sha256.New, c.privkey, ephkey, auth.h.SrcID, c.localnode.ID(), cdata)
+ session = session.keysFlipped()
+ return n, auth, session, nil
+}
+
+// decodeHandshakeAuthData reads the authdata section of a handshake packet.
+func (c *Codec) decodeHandshakeAuthData(head *Header) (auth handshakeAuthData, err error) {
+ // Decode fixed size part.
+ if len(head.AuthData) < sizeofHandshakeAuthData {
+ return auth, fmt.Errorf("header authsize %d too low for handshake", head.AuthSize)
+ }
+ c.reader.Reset(head.AuthData)
+ binary.Read(&c.reader, binary.BigEndian, &auth.h)
+ head.src = auth.h.SrcID
+
+ // Decode variable-size part.
+ var (
+ vardata = head.AuthData[sizeofHandshakeAuthData:]
+ sigAndKeySize = int(auth.h.SigSize) + int(auth.h.PubkeySize)
+ keyOffset = int(auth.h.SigSize)
+ recOffset = keyOffset + int(auth.h.PubkeySize)
+ )
+ if len(vardata) < sigAndKeySize {
+ return auth, errTooShort
+ }
+ auth.signature = vardata[:keyOffset]
+ auth.pubkey = vardata[keyOffset:recOffset]
+ auth.record = vardata[recOffset:]
+ return auth, nil
+}
+
+// decodeHandshakeRecord verifies the node record contained in a handshake packet. The
+// remote node should include the record if we don't have one or if ours is older than the
+// latest sequence number.
+func (c *Codec) decodeHandshakeRecord(local *enode.Node, wantID enode.ID, remote []byte) (*enode.Node, error) {
+ node := local
+ if len(remote) > 0 {
+ var record enr.Record
+ if err := rlp.DecodeBytes(remote, &record); err != nil {
+ return nil, err
+ }
+ if local == nil || local.Seq() < record.Seq() {
+ n, err := enode.New(enode.ValidSchemes, &record)
+ if err != nil {
+ return nil, fmt.Errorf("invalid node record: %v", err)
+ }
+ if n.ID() != wantID {
+ return nil, fmt.Errorf("record in handshake has wrong ID: %v", n.ID())
+ }
+ node = n
+ }
+ }
+ if node == nil {
+ return nil, errNoRecord
+ }
+ return node, nil
+}
+
+// decodeMessage reads packet data following the header as an ordinary message packet.
+func (c *Codec) decodeMessage(fromAddr string, head *Header, headerData, msgData []byte) (Packet, error) {
+ if len(head.AuthData) != sizeofMessageAuthData {
+ return nil, fmt.Errorf("invalid auth size %d for message packet", len(head.AuthData))
+ }
+ var auth messageAuthData
+ c.reader.Reset(head.AuthData)
+ binary.Read(&c.reader, binary.BigEndian, &auth)
+ head.src = auth.SrcID
+
+ // Try decrypting the message.
+ key := c.sc.readKey(auth.SrcID, fromAddr)
+ msg, err := c.decryptMessage(msgData, head.Nonce[:], headerData, key)
+ if err == errMessageDecrypt {
+ // It didn't work. Start the handshake since this is an ordinary message packet.
+ return &Unknown{Nonce: head.Nonce}, nil
+ }
+ return msg, err
+}
+
+func (c *Codec) decryptMessage(input, nonce, headerData, readKey []byte) (Packet, error) {
+ msgdata, err := decryptGCM(readKey, nonce, input, headerData)
+ if err != nil {
+ return nil, errMessageDecrypt
+ }
+ if len(msgdata) == 0 {
+ return nil, errMessageTooShort
+ }
+ return DecodeMessage(msgdata[0], msgdata[1:])
+}
+
+// checkValid performs some basic validity checks on the header.
+// The packetLen here is the length remaining after the static header.
+func (h *StaticHeader) checkValid(packetLen int) error {
+ if h.ProtocolID != protocolID {
+ return errInvalidHeader
+ }
+ if h.Version < minVersion {
+ return errMinVersion
+ }
+ if h.Flag != flagWhoareyou && packetLen < minMessageSize {
+ return errMsgTooShort
+ }
+ if int(h.AuthSize) > packetLen {
+ return errAuthSize
+ }
+ return nil
+}
+
+// headerMask returns a cipher for 'masking' / 'unmasking' packet headers.
+func (h *Header) mask(destID enode.ID) cipher.Stream {
+ block, err := aes.NewCipher(destID[:16])
+ if err != nil {
+ panic("can't create cipher")
+ }
+ return cipher.NewCTR(block, h.IV[:])
+}
+
+func bytesCopy(r *bytes.Buffer) []byte {
+ b := make([]byte, r.Len())
+ copy(b, r.Bytes())
+ return b
+}
diff --git a/p2p/discover/v5wire/encoding_test.go b/p2p/discover/v5wire/encoding_test.go
new file mode 100644
index 000000000000..18d821ee36f4
--- /dev/null
+++ b/p2p/discover/v5wire/encoding_test.go
@@ -0,0 +1,635 @@
+// Copyright 2019 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 .
+
+package v5wire
+
+import (
+ "bytes"
+ "crypto/ecdsa"
+ "encoding/hex"
+ "flag"
+ "fmt"
+ "io/ioutil"
+ "net"
+ "os"
+ "path/filepath"
+ "reflect"
+ "strings"
+ "testing"
+
+ "github.com/XinFinOrg/XDPoSChain/common/hexutil"
+ "github.com/XinFinOrg/XDPoSChain/common/mclock"
+ "github.com/XinFinOrg/XDPoSChain/crypto"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enode"
+ "github.com/davecgh/go-spew/spew"
+)
+
+// To regenerate discv5 test vectors, run
+//
+// go test -run TestVectors -write-test-vectors
+var writeTestVectorsFlag = flag.Bool("write-test-vectors", false, "Overwrite discv5 test vectors in testdata/")
+
+var (
+ testKeyA, _ = crypto.HexToECDSA("eef77acb6c6a6eebc5b363a475ac583ec7eccdb42b6481424c60f59aa326547f")
+ testKeyB, _ = crypto.HexToECDSA("66fb62bfbd66b9177a138c1e5cddbe4f7c30c343e94e68df8769459cb1cde628")
+ testEphKey, _ = crypto.HexToECDSA("0288ef00023598499cb6c940146d050d2b1fb914198c327f76aad590bead68b6")
+ testIDnonce = [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
+)
+
+// This test checks that the minPacketSize and randomPacketMsgSize constants are well-defined.
+func TestMinSizes(t *testing.T) {
+ var (
+ gcmTagSize = 16
+ emptyMsg = sizeofMessageAuthData + gcmTagSize
+ )
+ t.Log("static header size", sizeofStaticPacketData)
+ t.Log("whoareyou size", sizeofStaticPacketData+sizeofWhoareyouAuthData)
+ t.Log("empty msg size", sizeofStaticPacketData+emptyMsg)
+ if want := emptyMsg; minMessageSize != want {
+ t.Fatalf("wrong minMessageSize %d, want %d", minMessageSize, want)
+ }
+ if sizeofMessageAuthData+randomPacketMsgSize < minMessageSize {
+ t.Fatalf("randomPacketMsgSize %d too small", randomPacketMsgSize)
+ }
+}
+
+// This test checks the basic handshake flow where A talks to B and A has no secrets.
+func TestHandshake(t *testing.T) {
+ t.Parallel()
+ net := newHandshakeTest()
+ defer net.close()
+
+ // A -> B RANDOM PACKET
+ packet, _ := net.nodeA.encode(t, net.nodeB, &Findnode{})
+ resp := net.nodeB.expectDecode(t, UnknownPacket, packet)
+
+ // A <- B WHOAREYOU
+ challenge := &Whoareyou{
+ Nonce: resp.(*Unknown).Nonce,
+ IDNonce: testIDnonce,
+ RecordSeq: 0,
+ }
+ whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
+ net.nodeA.expectDecode(t, WhoareyouPacket, whoareyou)
+
+ // A -> B FINDNODE (handshake packet)
+ findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &Findnode{})
+ net.nodeB.expectDecode(t, FindnodeMsg, findnode)
+ if len(net.nodeB.c.sc.handshakes) > 0 {
+ t.Fatalf("node B didn't remove handshake from challenge map")
+ }
+
+ // A <- B NODES
+ nodes, _ := net.nodeB.encode(t, net.nodeA, &Nodes{Total: 1})
+ net.nodeA.expectDecode(t, NodesMsg, nodes)
+}
+
+// This test checks that handshake attempts are removed within the timeout.
+func TestHandshake_timeout(t *testing.T) {
+ t.Parallel()
+ net := newHandshakeTest()
+ defer net.close()
+
+ // A -> B RANDOM PACKET
+ packet, _ := net.nodeA.encode(t, net.nodeB, &Findnode{})
+ resp := net.nodeB.expectDecode(t, UnknownPacket, packet)
+
+ // A <- B WHOAREYOU
+ challenge := &Whoareyou{
+ Nonce: resp.(*Unknown).Nonce,
+ IDNonce: testIDnonce,
+ RecordSeq: 0,
+ }
+ whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
+ net.nodeA.expectDecode(t, WhoareyouPacket, whoareyou)
+
+ // A -> B FINDNODE (handshake packet) after timeout
+ net.clock.Run(handshakeTimeout + 1)
+ findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &Findnode{})
+ net.nodeB.expectDecodeErr(t, errUnexpectedHandshake, findnode)
+}
+
+// This test checks handshake behavior when no record is sent in the auth response.
+func TestHandshake_norecord(t *testing.T) {
+ t.Parallel()
+ net := newHandshakeTest()
+ defer net.close()
+
+ // A -> B RANDOM PACKET
+ packet, _ := net.nodeA.encode(t, net.nodeB, &Findnode{})
+ resp := net.nodeB.expectDecode(t, UnknownPacket, packet)
+
+ // A <- B WHOAREYOU
+ nodeA := net.nodeA.n()
+ if nodeA.Seq() == 0 {
+ t.Fatal("need non-zero sequence number")
+ }
+ challenge := &Whoareyou{
+ Nonce: resp.(*Unknown).Nonce,
+ IDNonce: testIDnonce,
+ RecordSeq: nodeA.Seq(),
+ Node: nodeA,
+ }
+ whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
+ net.nodeA.expectDecode(t, WhoareyouPacket, whoareyou)
+
+ // A -> B FINDNODE
+ findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &Findnode{})
+ net.nodeB.expectDecode(t, FindnodeMsg, findnode)
+
+ // A <- B NODES
+ nodes, _ := net.nodeB.encode(t, net.nodeA, &Nodes{Total: 1})
+ net.nodeA.expectDecode(t, NodesMsg, nodes)
+}
+
+// In this test, A tries to send FINDNODE with existing secrets but B doesn't know
+// anything about A.
+func TestHandshake_rekey(t *testing.T) {
+ t.Parallel()
+ net := newHandshakeTest()
+ defer net.close()
+
+ session := &session{
+ readKey: []byte("BBBBBBBBBBBBBBBB"),
+ writeKey: []byte("AAAAAAAAAAAAAAAA"),
+ }
+ net.nodeA.c.sc.storeNewSession(net.nodeB.id(), net.nodeB.addr(), session)
+
+ // A -> B FINDNODE (encrypted with zero keys)
+ findnode, authTag := net.nodeA.encode(t, net.nodeB, &Findnode{})
+ net.nodeB.expectDecode(t, UnknownPacket, findnode)
+
+ // A <- B WHOAREYOU
+ challenge := &Whoareyou{Nonce: authTag, IDNonce: testIDnonce}
+ whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
+ net.nodeA.expectDecode(t, WhoareyouPacket, whoareyou)
+
+ // Check that new keys haven't been stored yet.
+ sa := net.nodeA.c.sc.session(net.nodeB.id(), net.nodeB.addr())
+ if !bytes.Equal(sa.writeKey, session.writeKey) || !bytes.Equal(sa.readKey, session.readKey) {
+ t.Fatal("node A stored keys too early")
+ }
+ if s := net.nodeB.c.sc.session(net.nodeA.id(), net.nodeA.addr()); s != nil {
+ t.Fatal("node B stored keys too early")
+ }
+
+ // A -> B FINDNODE encrypted with new keys
+ findnode, _ = net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &Findnode{})
+ net.nodeB.expectDecode(t, FindnodeMsg, findnode)
+
+ // A <- B NODES
+ nodes, _ := net.nodeB.encode(t, net.nodeA, &Nodes{Total: 1})
+ net.nodeA.expectDecode(t, NodesMsg, nodes)
+}
+
+// In this test A and B have different keys before the handshake.
+func TestHandshake_rekey2(t *testing.T) {
+ t.Parallel()
+ net := newHandshakeTest()
+ defer net.close()
+
+ initKeysA := &session{
+ readKey: []byte("BBBBBBBBBBBBBBBB"),
+ writeKey: []byte("AAAAAAAAAAAAAAAA"),
+ }
+ initKeysB := &session{
+ readKey: []byte("CCCCCCCCCCCCCCCC"),
+ writeKey: []byte("DDDDDDDDDDDDDDDD"),
+ }
+ net.nodeA.c.sc.storeNewSession(net.nodeB.id(), net.nodeB.addr(), initKeysA)
+ net.nodeB.c.sc.storeNewSession(net.nodeA.id(), net.nodeA.addr(), initKeysB)
+
+ // A -> B FINDNODE encrypted with initKeysA
+ findnode, authTag := net.nodeA.encode(t, net.nodeB, &Findnode{Distances: []uint{3}})
+ net.nodeB.expectDecode(t, UnknownPacket, findnode)
+
+ // A <- B WHOAREYOU
+ challenge := &Whoareyou{Nonce: authTag, IDNonce: testIDnonce}
+ whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
+ net.nodeA.expectDecode(t, WhoareyouPacket, whoareyou)
+
+ // A -> B FINDNODE (handshake packet)
+ findnode, _ = net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &Findnode{})
+ net.nodeB.expectDecode(t, FindnodeMsg, findnode)
+
+ // A <- B NODES
+ nodes, _ := net.nodeB.encode(t, net.nodeA, &Nodes{Total: 1})
+ net.nodeA.expectDecode(t, NodesMsg, nodes)
+}
+
+func TestHandshake_BadHandshakeAttack(t *testing.T) {
+ t.Parallel()
+ net := newHandshakeTest()
+ defer net.close()
+
+ // A -> B RANDOM PACKET
+ packet, _ := net.nodeA.encode(t, net.nodeB, &Findnode{})
+ resp := net.nodeB.expectDecode(t, UnknownPacket, packet)
+
+ // A <- B WHOAREYOU
+ challenge := &Whoareyou{
+ Nonce: resp.(*Unknown).Nonce,
+ IDNonce: testIDnonce,
+ RecordSeq: 0,
+ }
+ whoareyou, _ := net.nodeB.encode(t, net.nodeA, challenge)
+ net.nodeA.expectDecode(t, WhoareyouPacket, whoareyou)
+
+ // A -> B FINDNODE
+ incorrect_challenge := &Whoareyou{
+ IDNonce: [16]byte{5, 6, 7, 8, 9, 6, 11, 12},
+ RecordSeq: challenge.RecordSeq,
+ Node: challenge.Node,
+ sent: challenge.sent,
+ }
+ incorrect_findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, incorrect_challenge, &Findnode{})
+ incorrect_findnode2 := make([]byte, len(incorrect_findnode))
+ copy(incorrect_findnode2, incorrect_findnode)
+
+ net.nodeB.expectDecodeErr(t, errInvalidNonceSig, incorrect_findnode)
+
+ // Reject new findnode as previous handshake is now deleted.
+ net.nodeB.expectDecodeErr(t, errUnexpectedHandshake, incorrect_findnode2)
+
+ // The findnode packet is again rejected even with a valid challenge this time.
+ findnode, _ := net.nodeA.encodeWithChallenge(t, net.nodeB, challenge, &Findnode{})
+ net.nodeB.expectDecodeErr(t, errUnexpectedHandshake, findnode)
+}
+
+// This test checks some malformed packets.
+func TestDecodeErrorsV5(t *testing.T) {
+ t.Parallel()
+ net := newHandshakeTest()
+ defer net.close()
+
+ net.nodeA.expectDecodeErr(t, errTooShort, []byte{})
+ // TODO some more tests would be nice :)
+ // - check invalid authdata sizes
+ // - check invalid handshake data sizes
+}
+
+// This test checks that all test vectors can be decoded.
+func TestTestVectorsV5(t *testing.T) {
+ var (
+ idA = enode.PubkeyToIDV4(&testKeyA.PublicKey)
+ idB = enode.PubkeyToIDV4(&testKeyB.PublicKey)
+ addr = "127.0.0.1"
+ session = &session{
+ writeKey: hexutil.MustDecode("0x00000000000000000000000000000000"),
+ readKey: hexutil.MustDecode("0x01010101010101010101010101010101"),
+ }
+ challenge0A, challenge1A, challenge0B Whoareyou
+ )
+
+ // Create challenge packets.
+ c := Whoareyou{
+ Nonce: Nonce{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
+ IDNonce: testIDnonce,
+ }
+ challenge0A, challenge1A, challenge0B = c, c, c
+ challenge1A.RecordSeq = 1
+ net := newHandshakeTest()
+ challenge0A.Node = net.nodeA.n()
+ challenge0B.Node = net.nodeB.n()
+ challenge1A.Node = net.nodeA.n()
+ net.close()
+
+ type testVectorTest struct {
+ name string // test vector name
+ packet Packet // the packet to be encoded
+ challenge *Whoareyou // handshake challenge passed to encoder
+ prep func(*handshakeTest) // called before encode/decode
+ }
+ tests := []testVectorTest{
+ {
+ name: "v5.1-whoareyou",
+ packet: &challenge0B,
+ },
+ {
+ name: "v5.1-ping-message",
+ packet: &Ping{
+ ReqID: []byte{0, 0, 0, 1},
+ ENRSeq: 2,
+ },
+ prep: func(net *handshakeTest) {
+ net.nodeA.c.sc.storeNewSession(idB, addr, session)
+ net.nodeB.c.sc.storeNewSession(idA, addr, session.keysFlipped())
+ },
+ },
+ {
+ name: "v5.1-ping-handshake-enr",
+ packet: &Ping{
+ ReqID: []byte{0, 0, 0, 1},
+ ENRSeq: 1,
+ },
+ challenge: &challenge0A,
+ prep: func(net *handshakeTest) {
+ // Update challenge.Header.AuthData.
+ net.nodeA.c.Encode(idB, "", &challenge0A, nil)
+ net.nodeB.c.sc.storeSentHandshake(idA, addr, &challenge0A)
+ },
+ },
+ {
+ name: "v5.1-ping-handshake",
+ packet: &Ping{
+ ReqID: []byte{0, 0, 0, 1},
+ ENRSeq: 1,
+ },
+ challenge: &challenge1A,
+ prep: func(net *handshakeTest) {
+ // Update challenge data.
+ net.nodeA.c.Encode(idB, "", &challenge1A, nil)
+ net.nodeB.c.sc.storeSentHandshake(idA, addr, &challenge1A)
+ },
+ },
+ }
+
+ for _, test := range tests {
+ test := test
+ t.Run(test.name, func(t *testing.T) {
+ net := newHandshakeTest()
+ defer net.close()
+
+ // Override all random inputs.
+ net.nodeA.c.sc.nonceGen = func(counter uint32) (Nonce, error) {
+ return Nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nil
+ }
+ net.nodeA.c.sc.maskingIVGen = func(buf []byte) error {
+ return nil // all zero
+ }
+ net.nodeA.c.sc.ephemeralKeyGen = func() (*ecdsa.PrivateKey, error) {
+ return testEphKey, nil
+ }
+
+ // Prime the codec for encoding/decoding.
+ if test.prep != nil {
+ test.prep(net)
+ }
+
+ file := filepath.Join("testdata", test.name+".txt")
+ if *writeTestVectorsFlag {
+ // Encode the packet.
+ d, nonce := net.nodeA.encodeWithChallenge(t, net.nodeB, test.challenge, test.packet)
+ comment := testVectorComment(net, test.packet, test.challenge, nonce)
+ writeTestVector(file, comment, d)
+ }
+ enc := hexFile(file)
+ net.nodeB.expectDecode(t, test.packet.Kind(), enc)
+ })
+ }
+}
+
+// testVectorComment creates the commentary for discv5 test vector files.
+func testVectorComment(net *handshakeTest, p Packet, challenge *Whoareyou, nonce Nonce) string {
+ o := new(strings.Builder)
+ printWhoareyou := func(p *Whoareyou) {
+ fmt.Fprintf(o, "whoareyou.challenge-data = %#x\n", p.ChallengeData)
+ fmt.Fprintf(o, "whoareyou.request-nonce = %#x\n", p.Nonce[:])
+ fmt.Fprintf(o, "whoareyou.id-nonce = %#x\n", p.IDNonce[:])
+ fmt.Fprintf(o, "whoareyou.enr-seq = %d\n", p.RecordSeq)
+ }
+
+ fmt.Fprintf(o, "src-node-id = %#x\n", net.nodeA.id().Bytes())
+ fmt.Fprintf(o, "dest-node-id = %#x\n", net.nodeB.id().Bytes())
+ switch p := p.(type) {
+ case *Whoareyou:
+ // WHOAREYOU packet.
+ printWhoareyou(p)
+ case *Ping:
+ fmt.Fprintf(o, "nonce = %#x\n", nonce[:])
+ fmt.Fprintf(o, "read-key = %#x\n", net.nodeA.c.sc.session(net.nodeB.id(), net.nodeB.addr()).writeKey)
+ fmt.Fprintf(o, "ping.req-id = %#x\n", p.ReqID)
+ fmt.Fprintf(o, "ping.enr-seq = %d\n", p.ENRSeq)
+ if challenge != nil {
+ // Handshake message packet.
+ fmt.Fprint(o, "\nhandshake inputs:\n\n")
+ printWhoareyou(challenge)
+ fmt.Fprintf(o, "ephemeral-key = %#x\n", testEphKey.D.Bytes())
+ fmt.Fprintf(o, "ephemeral-pubkey = %#x\n", crypto.CompressPubkey(&testEphKey.PublicKey))
+ }
+ default:
+ panic(fmt.Errorf("unhandled packet type %T", p))
+ }
+ return o.String()
+}
+
+// This benchmark checks performance of handshake packet decoding.
+func BenchmarkV5_DecodeHandshakePingSecp256k1(b *testing.B) {
+ net := newHandshakeTest()
+ defer net.close()
+
+ var (
+ idA = net.nodeA.id()
+ challenge = &Whoareyou{Node: net.nodeB.n()}
+ message = &Ping{ReqID: []byte("reqid")}
+ )
+ enc, _, err := net.nodeA.c.Encode(net.nodeB.id(), "", message, challenge)
+ if err != nil {
+ b.Fatal("can't encode handshake packet")
+ }
+ challenge.Node = nil // force ENR signature verification in decoder
+ b.ResetTimer()
+
+ input := make([]byte, len(enc))
+ for i := 0; i < b.N; i++ {
+ copy(input, enc)
+ net.nodeB.c.sc.storeSentHandshake(idA, "", challenge)
+ _, _, _, err := net.nodeB.c.Decode(input, "")
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+// This benchmark checks how long it takes to decode an encrypted ping packet.
+func BenchmarkV5_DecodePing(b *testing.B) {
+ net := newHandshakeTest()
+ defer net.close()
+
+ session := &session{
+ readKey: []byte{233, 203, 93, 195, 86, 47, 177, 186, 227, 43, 2, 141, 244, 230, 120, 17},
+ writeKey: []byte{79, 145, 252, 171, 167, 216, 252, 161, 208, 190, 176, 106, 214, 39, 178, 134},
+ }
+ net.nodeA.c.sc.storeNewSession(net.nodeB.id(), net.nodeB.addr(), session)
+ net.nodeB.c.sc.storeNewSession(net.nodeA.id(), net.nodeA.addr(), session.keysFlipped())
+ addrB := net.nodeA.addr()
+ ping := &Ping{ReqID: []byte("reqid"), ENRSeq: 5}
+ enc, _, err := net.nodeA.c.Encode(net.nodeB.id(), addrB, ping, nil)
+ if err != nil {
+ b.Fatalf("can't encode: %v", err)
+ }
+ b.ResetTimer()
+
+ input := make([]byte, len(enc))
+ for i := 0; i < b.N; i++ {
+ copy(input, enc)
+ _, _, packet, _ := net.nodeB.c.Decode(input, addrB)
+ if _, ok := packet.(*Ping); !ok {
+ b.Fatalf("wrong packet type %T", packet)
+ }
+ }
+}
+
+var pp = spew.NewDefaultConfig()
+
+type handshakeTest struct {
+ nodeA, nodeB handshakeTestNode
+ clock mclock.Simulated
+}
+
+type handshakeTestNode struct {
+ ln *enode.LocalNode
+ c *Codec
+}
+
+func newHandshakeTest() *handshakeTest {
+ t := new(handshakeTest)
+ t.nodeA.init(testKeyA, net.IP{127, 0, 0, 1}, &t.clock)
+ t.nodeB.init(testKeyB, net.IP{127, 0, 0, 1}, &t.clock)
+ return t
+}
+
+func (t *handshakeTest) close() {
+ t.nodeA.ln.Database().Close()
+ t.nodeB.ln.Database().Close()
+}
+
+func (n *handshakeTestNode) init(key *ecdsa.PrivateKey, ip net.IP, clock mclock.Clock) {
+ db, _ := enode.OpenDB("")
+ n.ln = enode.NewLocalNode(db, key)
+ n.ln.SetStaticIP(ip)
+ if n.ln.Node().Seq() == 0 {
+ panic(fmt.Errorf("unexpected seq %d", n.ln.Node().Seq()))
+ }
+ n.c = NewCodec(n.ln, key, clock)
+}
+
+func (n *handshakeTestNode) encode(t testing.TB, to handshakeTestNode, p Packet) ([]byte, Nonce) {
+ t.Helper()
+ return n.encodeWithChallenge(t, to, nil, p)
+}
+
+func (n *handshakeTestNode) encodeWithChallenge(t testing.TB, to handshakeTestNode, c *Whoareyou, p Packet) ([]byte, Nonce) {
+ t.Helper()
+
+ // Copy challenge and add destination node. This avoids sharing 'c' among the two codecs.
+ var challenge *Whoareyou
+ if c != nil {
+ challengeCopy := *c
+ challenge = &challengeCopy
+ challenge.Node = to.n()
+ }
+ // Encode to destination.
+ enc, nonce, err := n.c.Encode(to.id(), to.addr(), p, challenge)
+ if err != nil {
+ t.Fatal(fmt.Errorf("(%s) %v", n.ln.ID().TerminalString(), err))
+ }
+ t.Logf("(%s) -> (%s) %s\n%s", n.ln.ID().TerminalString(), to.id().TerminalString(), p.Name(), hex.Dump(enc))
+ return enc, nonce
+}
+
+func (n *handshakeTestNode) expectDecode(t *testing.T, ptype byte, p []byte) Packet {
+ t.Helper()
+
+ dec, err := n.decode(p)
+ if err != nil {
+ t.Fatal(fmt.Errorf("(%s) %v", n.ln.ID().TerminalString(), err))
+ }
+ t.Logf("(%s) %#v", n.ln.ID().TerminalString(), pp.NewFormatter(dec))
+ if dec.Kind() != ptype {
+ t.Fatalf("expected packet type %d, got %d", ptype, dec.Kind())
+ }
+ return dec
+}
+
+func (n *handshakeTestNode) expectDecodeErr(t *testing.T, wantErr error, p []byte) {
+ t.Helper()
+ if _, err := n.decode(p); !reflect.DeepEqual(err, wantErr) {
+ t.Fatal(fmt.Errorf("(%s) got err %q, want %q", n.ln.ID().TerminalString(), err, wantErr))
+ }
+}
+
+func (n *handshakeTestNode) decode(input []byte) (Packet, error) {
+ _, _, p, err := n.c.Decode(input, "127.0.0.1")
+ return p, err
+}
+
+func (n *handshakeTestNode) n() *enode.Node {
+ return n.ln.Node()
+}
+
+func (n *handshakeTestNode) addr() string {
+ return n.ln.Node().IP().String()
+}
+
+func (n *handshakeTestNode) id() enode.ID {
+ return n.ln.ID()
+}
+
+// hexFile reads the given file and decodes the hex data contained in it.
+// Whitespace and any lines beginning with the # character are ignored.
+func hexFile(file string) []byte {
+ fileContent, err := ioutil.ReadFile(file)
+ if err != nil {
+ panic(err)
+ }
+
+ // Gather hex data, ignore comments.
+ var text []byte
+ for _, line := range bytes.Split(fileContent, []byte("\n")) {
+ line = bytes.TrimSpace(line)
+ if len(line) > 0 && line[0] == '#' {
+ continue
+ }
+ text = append(text, line...)
+ }
+
+ // Parse the hex.
+ if bytes.HasPrefix(text, []byte("0x")) {
+ text = text[2:]
+ }
+ data := make([]byte, hex.DecodedLen(len(text)))
+ if _, err := hex.Decode(data, text); err != nil {
+ panic("invalid hex in " + file)
+ }
+ return data
+}
+
+// writeTestVector writes a test vector file with the given commentary and binary data.
+func writeTestVector(file, comment string, data []byte) {
+ fd, err := os.OpenFile(file, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+ if err != nil {
+ panic(err)
+ }
+ defer fd.Close()
+
+ if len(comment) > 0 {
+ for _, line := range strings.Split(strings.TrimSpace(comment), "\n") {
+ fmt.Fprintf(fd, "# %s\n", line)
+ }
+ fmt.Fprintln(fd)
+ }
+ for len(data) > 0 {
+ var chunk []byte
+ if len(data) < 32 {
+ chunk = data
+ } else {
+ chunk = data[:32]
+ }
+ data = data[len(chunk):]
+ fmt.Fprintf(fd, "%x\n", chunk)
+ }
+}
diff --git a/p2p/discover/v5wire/msg.go b/p2p/discover/v5wire/msg.go
new file mode 100644
index 000000000000..c9663217c7e3
--- /dev/null
+++ b/p2p/discover/v5wire/msg.go
@@ -0,0 +1,249 @@
+// Copyright 2019 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 .
+
+package v5wire
+
+import (
+ "fmt"
+ "net"
+
+ "github.com/XinFinOrg/XDPoSChain/common/mclock"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enode"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enr"
+ "github.com/XinFinOrg/XDPoSChain/rlp"
+)
+
+// Packet is implemented by all message types.
+type Packet interface {
+ Name() string // Name returns a string corresponding to the message type.
+ Kind() byte // Kind returns the message type.
+ RequestID() []byte // Returns the request ID.
+ SetRequestID([]byte) // Sets the request ID.
+}
+
+// Message types.
+const (
+ PingMsg byte = iota + 1
+ PongMsg
+ FindnodeMsg
+ NodesMsg
+ TalkRequestMsg
+ TalkResponseMsg
+ RequestTicketMsg
+ TicketMsg
+ RegtopicMsg
+ RegconfirmationMsg
+ TopicQueryMsg
+
+ UnknownPacket = byte(255) // any non-decryptable packet
+ WhoareyouPacket = byte(254) // the WHOAREYOU packet
+)
+
+// Protocol messages.
+type (
+ // Unknown represents any packet that can't be decrypted.
+ Unknown struct {
+ Nonce Nonce
+ }
+
+ // WHOAREYOU contains the handshake challenge.
+ Whoareyou struct {
+ ChallengeData []byte // Encoded challenge
+ Nonce Nonce // Nonce of request packet
+ IDNonce [16]byte // Identity proof data
+ RecordSeq uint64 // ENR sequence number of recipient
+
+ // Node is the locally known node record of recipient.
+ // This must be set by the caller of Encode.
+ Node *enode.Node
+
+ sent mclock.AbsTime // for handshake GC.
+ }
+
+ // PING is sent during liveness checks.
+ Ping struct {
+ ReqID []byte
+ ENRSeq uint64
+ }
+
+ // PONG is the reply to PING.
+ Pong struct {
+ ReqID []byte
+ ENRSeq uint64
+ ToIP net.IP // These fields should mirror the UDP envelope address of the ping
+ ToPort uint16 // packet, which provides a way to discover the the external address (after NAT).
+ }
+
+ // FINDNODE is a query for nodes in the given bucket.
+ Findnode struct {
+ ReqID []byte
+ Distances []uint
+ }
+
+ // NODES is the reply to FINDNODE and TOPICQUERY.
+ Nodes struct {
+ ReqID []byte
+ Total uint8
+ Nodes []*enr.Record
+ }
+
+ // TALKREQ is an application-level request.
+ TalkRequest struct {
+ ReqID []byte
+ Protocol string
+ Message []byte
+ }
+
+ // TALKRESP is the reply to TALKREQ.
+ TalkResponse struct {
+ ReqID []byte
+ Message []byte
+ }
+
+ // REQUESTTICKET requests a ticket for a topic queue.
+ RequestTicket struct {
+ ReqID []byte
+ Topic []byte
+ }
+
+ // TICKET is the response to REQUESTTICKET.
+ Ticket struct {
+ ReqID []byte
+ Ticket []byte
+ }
+
+ // REGTOPIC registers the sender in a topic queue using a ticket.
+ Regtopic struct {
+ ReqID []byte
+ Ticket []byte
+ ENR *enr.Record
+ }
+
+ // REGCONFIRMATION is the reply to REGTOPIC.
+ Regconfirmation struct {
+ ReqID []byte
+ Registered bool
+ }
+
+ // TOPICQUERY asks for nodes with the given topic.
+ TopicQuery struct {
+ ReqID []byte
+ Topic []byte
+ }
+)
+
+// DecodeMessage decodes the message body of a packet.
+func DecodeMessage(ptype byte, body []byte) (Packet, error) {
+ var dec Packet
+ switch ptype {
+ case PingMsg:
+ dec = new(Ping)
+ case PongMsg:
+ dec = new(Pong)
+ case FindnodeMsg:
+ dec = new(Findnode)
+ case NodesMsg:
+ dec = new(Nodes)
+ case TalkRequestMsg:
+ dec = new(TalkRequest)
+ case TalkResponseMsg:
+ dec = new(TalkResponse)
+ case RequestTicketMsg:
+ dec = new(RequestTicket)
+ case TicketMsg:
+ dec = new(Ticket)
+ case RegtopicMsg:
+ dec = new(Regtopic)
+ case RegconfirmationMsg:
+ dec = new(Regconfirmation)
+ case TopicQueryMsg:
+ dec = new(TopicQuery)
+ default:
+ return nil, fmt.Errorf("unknown packet type %d", ptype)
+ }
+ if err := rlp.DecodeBytes(body, dec); err != nil {
+ return nil, err
+ }
+ if dec.RequestID() != nil && len(dec.RequestID()) > 8 {
+ return nil, ErrInvalidReqID
+ }
+ return dec, nil
+}
+
+func (*Whoareyou) Name() string { return "WHOAREYOU/v5" }
+func (*Whoareyou) Kind() byte { return WhoareyouPacket }
+func (*Whoareyou) RequestID() []byte { return nil }
+func (*Whoareyou) SetRequestID([]byte) {}
+
+func (*Unknown) Name() string { return "UNKNOWN/v5" }
+func (*Unknown) Kind() byte { return UnknownPacket }
+func (*Unknown) RequestID() []byte { return nil }
+func (*Unknown) SetRequestID([]byte) {}
+
+func (*Ping) Name() string { return "PING/v5" }
+func (*Ping) Kind() byte { return PingMsg }
+func (p *Ping) RequestID() []byte { return p.ReqID }
+func (p *Ping) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*Pong) Name() string { return "PONG/v5" }
+func (*Pong) Kind() byte { return PongMsg }
+func (p *Pong) RequestID() []byte { return p.ReqID }
+func (p *Pong) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*Findnode) Name() string { return "FINDNODE/v5" }
+func (*Findnode) Kind() byte { return FindnodeMsg }
+func (p *Findnode) RequestID() []byte { return p.ReqID }
+func (p *Findnode) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*Nodes) Name() string { return "NODES/v5" }
+func (*Nodes) Kind() byte { return NodesMsg }
+func (p *Nodes) RequestID() []byte { return p.ReqID }
+func (p *Nodes) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*TalkRequest) Name() string { return "TALKREQ/v5" }
+func (*TalkRequest) Kind() byte { return TalkRequestMsg }
+func (p *TalkRequest) RequestID() []byte { return p.ReqID }
+func (p *TalkRequest) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*TalkResponse) Name() string { return "TALKRESP/v5" }
+func (*TalkResponse) Kind() byte { return TalkResponseMsg }
+func (p *TalkResponse) RequestID() []byte { return p.ReqID }
+func (p *TalkResponse) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*RequestTicket) Name() string { return "REQTICKET/v5" }
+func (*RequestTicket) Kind() byte { return RequestTicketMsg }
+func (p *RequestTicket) RequestID() []byte { return p.ReqID }
+func (p *RequestTicket) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*Regtopic) Name() string { return "REGTOPIC/v5" }
+func (*Regtopic) Kind() byte { return RegtopicMsg }
+func (p *Regtopic) RequestID() []byte { return p.ReqID }
+func (p *Regtopic) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*Ticket) Name() string { return "TICKET/v5" }
+func (*Ticket) Kind() byte { return TicketMsg }
+func (p *Ticket) RequestID() []byte { return p.ReqID }
+func (p *Ticket) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*Regconfirmation) Name() string { return "REGCONFIRMATION/v5" }
+func (*Regconfirmation) Kind() byte { return RegconfirmationMsg }
+func (p *Regconfirmation) RequestID() []byte { return p.ReqID }
+func (p *Regconfirmation) SetRequestID(id []byte) { p.ReqID = id }
+
+func (*TopicQuery) Name() string { return "TOPICQUERY/v5" }
+func (*TopicQuery) Kind() byte { return TopicQueryMsg }
+func (p *TopicQuery) RequestID() []byte { return p.ReqID }
+func (p *TopicQuery) SetRequestID(id []byte) { p.ReqID = id }
diff --git a/p2p/discover/v5_session.go b/p2p/discover/v5wire/session.go
similarity index 58%
rename from p2p/discover/v5_session.go
rename to p2p/discover/v5wire/session.go
index 114d56643a29..f1970e7d4720 100644
--- a/p2p/discover/v5_session.go
+++ b/p2p/discover/v5wire/session.go
@@ -14,22 +14,33 @@
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see .
-package discover
+package v5wire
import (
+ "crypto/ecdsa"
crand "crypto/rand"
+ "encoding/binary"
+ "time"
"github.com/XinFinOrg/XDPoSChain/common/mclock"
+ "github.com/XinFinOrg/XDPoSChain/crypto"
"github.com/XinFinOrg/XDPoSChain/p2p/enode"
"github.com/hashicorp/golang-lru/simplelru"
)
-// The sessionCache keeps negotiated encryption keys and
+const handshakeTimeout = time.Second
+
+// The SessionCache keeps negotiated encryption keys and
// state for in-progress handshakes in the Discovery v5 wire protocol.
-type sessionCache struct {
+type SessionCache struct {
sessions *simplelru.LRU
- handshakes map[sessionID]*whoareyouV5
+ handshakes map[sessionID]*Whoareyou
clock mclock.Clock
+
+ // hooks for overriding randomness.
+ nonceGen func(uint32) (Nonce, error)
+ maskingIVGen func([]byte) error
+ ephemeralKeyGen func() (*ecdsa.PrivateKey, error)
}
// sessionID identifies a session or handshake.
@@ -45,27 +56,45 @@ type session struct {
nonceCounter uint32
}
-func newSessionCache(maxItems int, clock mclock.Clock) *sessionCache {
+// keysFlipped returns a copy of s with the read and write keys flipped.
+func (s *session) keysFlipped() *session {
+ return &session{s.readKey, s.writeKey, s.nonceCounter}
+}
+
+func NewSessionCache(maxItems int, clock mclock.Clock) *SessionCache {
cache, err := simplelru.NewLRU(maxItems, nil)
if err != nil {
panic("can't create session cache")
}
- return &sessionCache{
- sessions: cache,
- handshakes: make(map[sessionID]*whoareyouV5),
- clock: clock,
+ return &SessionCache{
+ sessions: cache,
+ handshakes: make(map[sessionID]*Whoareyou),
+ clock: clock,
+ nonceGen: generateNonce,
+ maskingIVGen: generateMaskingIV,
+ ephemeralKeyGen: crypto.GenerateKey,
}
}
+func generateNonce(counter uint32) (n Nonce, err error) {
+ binary.BigEndian.PutUint32(n[:4], counter)
+ _, err = crand.Read(n[4:])
+ return n, err
+}
+
+func generateMaskingIV(buf []byte) error {
+ _, err := crand.Read(buf)
+ return err
+}
+
// nextNonce creates a nonce for encrypting a message to the given session.
-func (sc *sessionCache) nextNonce(id enode.ID, addr string) []byte {
- n := make([]byte, gcmNonceSize)
- crand.Read(n)
- return n
+func (sc *SessionCache) nextNonce(s *session) (Nonce, error) {
+ s.nonceCounter++
+ return sc.nonceGen(s.nonceCounter)
}
// session returns the current session for the given node, if any.
-func (sc *sessionCache) session(id enode.ID, addr string) *session {
+func (sc *SessionCache) session(id enode.ID, addr string) *session {
item, ok := sc.sessions.Get(sessionID{id, addr})
if !ok {
return nil
@@ -74,46 +103,36 @@ func (sc *sessionCache) session(id enode.ID, addr string) *session {
}
// readKey returns the current read key for the given node.
-func (sc *sessionCache) readKey(id enode.ID, addr string) []byte {
+func (sc *SessionCache) readKey(id enode.ID, addr string) []byte {
if s := sc.session(id, addr); s != nil {
return s.readKey
}
return nil
}
-// writeKey returns the current read key for the given node.
-func (sc *sessionCache) writeKey(id enode.ID, addr string) []byte {
- if s := sc.session(id, addr); s != nil {
- return s.writeKey
- }
- return nil
-}
-
// storeNewSession stores new encryption keys in the cache.
-func (sc *sessionCache) storeNewSession(id enode.ID, addr string, r, w []byte) {
- sc.sessions.Add(sessionID{id, addr}, &session{
- readKey: r, writeKey: w,
- })
+func (sc *SessionCache) storeNewSession(id enode.ID, addr string, s *session) {
+ sc.sessions.Add(sessionID{id, addr}, s)
}
// getHandshake gets the handshake challenge we previously sent to the given remote node.
-func (sc *sessionCache) getHandshake(id enode.ID, addr string) *whoareyouV5 {
+func (sc *SessionCache) getHandshake(id enode.ID, addr string) *Whoareyou {
return sc.handshakes[sessionID{id, addr}]
}
// storeSentHandshake stores the handshake challenge sent to the given remote node.
-func (sc *sessionCache) storeSentHandshake(id enode.ID, addr string, challenge *whoareyouV5) {
+func (sc *SessionCache) storeSentHandshake(id enode.ID, addr string, challenge *Whoareyou) {
challenge.sent = sc.clock.Now()
sc.handshakes[sessionID{id, addr}] = challenge
}
// deleteHandshake deletes handshake data for the given node.
-func (sc *sessionCache) deleteHandshake(id enode.ID, addr string) {
+func (sc *SessionCache) deleteHandshake(id enode.ID, addr string) {
delete(sc.handshakes, sessionID{id, addr})
}
// handshakeGC deletes timed-out handshakes.
-func (sc *sessionCache) handshakeGC() {
+func (sc *SessionCache) handshakeGC() {
deadline := sc.clock.Now().Add(-handshakeTimeout)
for key, challenge := range sc.handshakes {
if challenge.sent < deadline {
diff --git a/p2p/discover/v5wire/testdata/v5.1-ping-handshake-enr.txt b/p2p/discover/v5wire/testdata/v5.1-ping-handshake-enr.txt
new file mode 100644
index 000000000000..477f9e15a826
--- /dev/null
+++ b/p2p/discover/v5wire/testdata/v5.1-ping-handshake-enr.txt
@@ -0,0 +1,27 @@
+# src-node-id = 0xaaaa8419e9f49d0083561b48287df592939a8d19947d8c0ef88f2a4856a69fbb
+# dest-node-id = 0xbbbb9d047f0488c0b5a93c1c3f2d8bafc7c8ff337024a55434a0d0555de64db9
+# nonce = 0xffffffffffffffffffffffff
+# read-key = 0x53b1c075f41876423154e157470c2f48
+# ping.req-id = 0x00000001
+# ping.enr-seq = 1
+#
+# handshake inputs:
+#
+# whoareyou.challenge-data = 0x000000000000000000000000000000006469736376350001010102030405060708090a0b0c00180102030405060708090a0b0c0d0e0f100000000000000000
+# whoareyou.request-nonce = 0x0102030405060708090a0b0c
+# whoareyou.id-nonce = 0x0102030405060708090a0b0c0d0e0f10
+# whoareyou.enr-seq = 0
+# ephemeral-key = 0x0288ef00023598499cb6c940146d050d2b1fb914198c327f76aad590bead68b6
+# ephemeral-pubkey = 0x039a003ba6517b473fa0cd74aefe99dadfdb34627f90fec6362df85803908f53a5
+
+00000000000000000000000000000000088b3d4342774649305f313964a39e55
+ea96c005ad539c8c7560413a7008f16c9e6d2f43bbea8814a546b7409ce783d3
+4c4f53245d08da4bb23698868350aaad22e3ab8dd034f548a1c43cd246be9856
+2fafa0a1fa86d8e7a3b95ae78cc2b988ded6a5b59eb83ad58097252188b902b2
+1481e30e5e285f19735796706adff216ab862a9186875f9494150c4ae06fa4d1
+f0396c93f215fa4ef524e0ed04c3c21e39b1868e1ca8105e585ec17315e755e6
+cfc4dd6cb7fd8e1a1f55e49b4b5eb024221482105346f3c82b15fdaae36a3bb1
+2a494683b4a3c7f2ae41306252fed84785e2bbff3b022812d0882f06978df84a
+80d443972213342d04b9048fc3b1d5fcb1df0f822152eced6da4d3f6df27e70e
+4539717307a0208cd208d65093ccab5aa596a34d7511401987662d8cf62b1394
+71
diff --git a/p2p/discover/v5wire/testdata/v5.1-ping-handshake.txt b/p2p/discover/v5wire/testdata/v5.1-ping-handshake.txt
new file mode 100644
index 000000000000..b3f304766cc5
--- /dev/null
+++ b/p2p/discover/v5wire/testdata/v5.1-ping-handshake.txt
@@ -0,0 +1,23 @@
+# src-node-id = 0xaaaa8419e9f49d0083561b48287df592939a8d19947d8c0ef88f2a4856a69fbb
+# dest-node-id = 0xbbbb9d047f0488c0b5a93c1c3f2d8bafc7c8ff337024a55434a0d0555de64db9
+# nonce = 0xffffffffffffffffffffffff
+# read-key = 0x4f9fac6de7567d1e3b1241dffe90f662
+# ping.req-id = 0x00000001
+# ping.enr-seq = 1
+#
+# handshake inputs:
+#
+# whoareyou.challenge-data = 0x000000000000000000000000000000006469736376350001010102030405060708090a0b0c00180102030405060708090a0b0c0d0e0f100000000000000001
+# whoareyou.request-nonce = 0x0102030405060708090a0b0c
+# whoareyou.id-nonce = 0x0102030405060708090a0b0c0d0e0f10
+# whoareyou.enr-seq = 1
+# ephemeral-key = 0x0288ef00023598499cb6c940146d050d2b1fb914198c327f76aad590bead68b6
+# ephemeral-pubkey = 0x039a003ba6517b473fa0cd74aefe99dadfdb34627f90fec6362df85803908f53a5
+
+00000000000000000000000000000000088b3d4342774649305f313964a39e55
+ea96c005ad521d8c7560413a7008f16c9e6d2f43bbea8814a546b7409ce783d3
+4c4f53245d08da4bb252012b2cba3f4f374a90a75cff91f142fa9be3e0a5f3ef
+268ccb9065aeecfd67a999e7fdc137e062b2ec4a0eb92947f0d9a74bfbf44dfb
+a776b21301f8b65efd5796706adff216ab862a9186875f9494150c4ae06fa4d1
+f0396c93f215fa4ef524f1eadf5f0f4126b79336671cbcf7a885b1f8bd2a5d83
+9cf8
diff --git a/p2p/discover/v5wire/testdata/v5.1-ping-message.txt b/p2p/discover/v5wire/testdata/v5.1-ping-message.txt
new file mode 100644
index 000000000000..f82b99c3bc75
--- /dev/null
+++ b/p2p/discover/v5wire/testdata/v5.1-ping-message.txt
@@ -0,0 +1,10 @@
+# src-node-id = 0xaaaa8419e9f49d0083561b48287df592939a8d19947d8c0ef88f2a4856a69fbb
+# dest-node-id = 0xbbbb9d047f0488c0b5a93c1c3f2d8bafc7c8ff337024a55434a0d0555de64db9
+# nonce = 0xffffffffffffffffffffffff
+# read-key = 0x00000000000000000000000000000000
+# ping.req-id = 0x00000001
+# ping.enr-seq = 2
+
+00000000000000000000000000000000088b3d4342774649325f313964a39e55
+ea96c005ad52be8c7560413a7008f16c9e6d2f43bbea8814a546b7409ce783d3
+4c4f53245d08dab84102ed931f66d1492acb308fa1c6715b9d139b81acbdcc
diff --git a/p2p/discover/v5wire/testdata/v5.1-whoareyou.txt b/p2p/discover/v5wire/testdata/v5.1-whoareyou.txt
new file mode 100644
index 000000000000..1a75f525ee96
--- /dev/null
+++ b/p2p/discover/v5wire/testdata/v5.1-whoareyou.txt
@@ -0,0 +1,9 @@
+# src-node-id = 0xaaaa8419e9f49d0083561b48287df592939a8d19947d8c0ef88f2a4856a69fbb
+# dest-node-id = 0xbbbb9d047f0488c0b5a93c1c3f2d8bafc7c8ff337024a55434a0d0555de64db9
+# whoareyou.challenge-data = 0x000000000000000000000000000000006469736376350001010102030405060708090a0b0c00180102030405060708090a0b0c0d0e0f100000000000000000
+# whoareyou.request-nonce = 0x0102030405060708090a0b0c
+# whoareyou.id-nonce = 0x0102030405060708090a0b0c0d0e0f10
+# whoareyou.enr-seq = 0
+
+00000000000000000000000000000000088b3d434277464933a1ccc59f5967ad
+1d6035f15e528627dde75cd68292f9e6c27d6b66c8100a873fcbaed4e16b8d
diff --git a/p2p/netutil/error.go b/p2p/netutil/error.go
index cb21b9cd4ce4..98580cae78f4 100644
--- a/p2p/netutil/error.go
+++ b/p2p/netutil/error.go
@@ -16,6 +16,8 @@
package netutil
+import "errors"
+
// IsTemporaryError checks whether the given error should be considered temporary.
func IsTemporaryError(err error) bool {
tempErr, ok := err.(interface {
@@ -23,3 +25,11 @@ func IsTemporaryError(err error) bool {
})
return ok && tempErr.Temporary() || isPacketTooBig(err)
}
+
+// IsTimeout checks whether the given error is a timeout.
+func IsTimeout(err error) bool {
+ timeoutErr := new(interface {
+ Timeout() bool
+ })
+ return errors.As(err, timeoutErr) && (*timeoutErr).Timeout()
+}
diff --git a/p2p/netutil/error_test.go b/p2p/netutil/error_test.go
index 645e48f83741..c9608227d45b 100644
--- a/p2p/netutil/error_test.go
+++ b/p2p/netutil/error_test.go
@@ -17,11 +17,19 @@
package netutil
import (
+ "errors"
+ "fmt"
"net"
"testing"
"time"
)
+type timeoutErr bool
+
+func (e timeoutErr) Error() string { return "timeout" }
+func (e timeoutErr) Timeout() bool { return bool(e) }
+func (e timeoutErr) Temporary() bool { return false }
+
// This test checks that isPacketTooBig correctly identifies
// errors that result from receiving a UDP packet larger
// than the supplied receive buffer.
@@ -71,3 +79,25 @@ func TestIsPacketTooBig(t *testing.T) {
}
}
}
+
+func TestIsTimeout(t *testing.T) {
+ tests := []struct {
+ name string
+ err error
+ want bool
+ }{
+ {name: "nil", err: nil, want: false},
+ {name: "direct timeout", err: timeoutErr(true), want: true},
+ {name: "wrapped timeout", err: fmt.Errorf("wrapped: %w", timeoutErr(true)), want: true},
+ {name: "wrapped non-timeout", err: fmt.Errorf("wrapped: %w", timeoutErr(false)), want: false},
+ {name: "ordinary error", err: errors.New("no timeout"), want: false},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := IsTimeout(tt.err); got != tt.want {
+ t.Fatalf("IsTimeout(%v) = %v, want %v", tt.err, got, tt.want)
+ }
+ })
+ }
+}
From a120b3c83920dd6e09378fc5d023f16d3fff2e9b Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 14 Jul 2026 16:26:57 +0800
Subject: [PATCH 13/14] feat(cmd/devp2p): add test suite
---
cmd/devp2p/discv4cmd.go | 26 +
cmd/devp2p/discv5cmd.go | 23 +
cmd/devp2p/internal/ethtest/mkchain.sh | 10 +
cmd/devp2p/internal/ethtest/protocol.go | 58 +
cmd/devp2p/internal/ethtest/suite.go | 455 +
.../internal/ethtest/testdata/accounts.json | 62 +
.../internal/ethtest/testdata/chain.rlp | Bin 0 -> 457980 bytes
.../internal/ethtest/testdata/forkenv.json | 27 +
.../internal/ethtest/testdata/genesis.json | 145 +
.../internal/ethtest/testdata/headblock.json | 24 +
.../internal/ethtest/testdata/headfcu.json | 13 +
.../internal/ethtest/testdata/headstate.json | 3906 ++++
.../internal/ethtest/testdata/newpayload.json | 19044 ++++++++++++++++
.../internal/ethtest/testdata/txinfo.json | 3283 +++
cmd/devp2p/internal/v4test/discv4tests.go | 551 +
cmd/devp2p/internal/v4test/framework.go | 125 +
cmd/devp2p/internal/v5test/discv5tests.go | 247 +-
cmd/devp2p/internal/v5test/framework.go | 67 +-
cmd/devp2p/rlpxcmd.go | 47 +
cmd/devp2p/runtest.go | 99 +
internal/flags/categories.go | 1 +
p2p/discover/v5wire/encoding.go | 7 +
22 files changed, 28102 insertions(+), 118 deletions(-)
create mode 100644 cmd/devp2p/internal/ethtest/mkchain.sh
create mode 100644 cmd/devp2p/internal/ethtest/suite.go
create mode 100644 cmd/devp2p/internal/ethtest/testdata/accounts.json
create mode 100644 cmd/devp2p/internal/ethtest/testdata/chain.rlp
create mode 100644 cmd/devp2p/internal/ethtest/testdata/forkenv.json
create mode 100644 cmd/devp2p/internal/ethtest/testdata/genesis.json
create mode 100644 cmd/devp2p/internal/ethtest/testdata/headblock.json
create mode 100644 cmd/devp2p/internal/ethtest/testdata/headfcu.json
create mode 100644 cmd/devp2p/internal/ethtest/testdata/headstate.json
create mode 100644 cmd/devp2p/internal/ethtest/testdata/newpayload.json
create mode 100644 cmd/devp2p/internal/ethtest/testdata/txinfo.json
create mode 100644 cmd/devp2p/internal/v4test/discv4tests.go
create mode 100644 cmd/devp2p/internal/v4test/framework.go
create mode 100644 cmd/devp2p/runtest.go
diff --git a/cmd/devp2p/discv4cmd.go b/cmd/devp2p/discv4cmd.go
index 8934c0cbd864..a288a7b5076e 100644
--- a/cmd/devp2p/discv4cmd.go
+++ b/cmd/devp2p/discv4cmd.go
@@ -30,6 +30,7 @@ import (
"sync"
"time"
+ "github.com/XinFinOrg/XDPoSChain/cmd/devp2p/internal/v4test"
"github.com/XinFinOrg/XDPoSChain/common"
"github.com/XinFinOrg/XDPoSChain/crypto"
"github.com/XinFinOrg/XDPoSChain/log"
@@ -50,6 +51,7 @@ var (
discv4ResolveCommand,
discv4ResolveJSONCommand,
discv4CrawlCommand,
+ discv4TestCommand,
discv4ListenCommand,
},
}
@@ -102,6 +104,18 @@ var (
Action: discv4Crawl,
Flags: slices.Concat(discoveryNodeFlags, []cli.Flag{crawlTimeoutFlag, crawlParallelismFlag}),
}
+ discv4TestCommand = &cli.Command{
+ Name: "test",
+ Usage: "Runs tests against a node",
+ Action: discv4Test,
+ Flags: []cli.Flag{
+ remoteEnodeFlag,
+ testPatternFlag,
+ testTAPFlag,
+ testListen1Flag,
+ testListen2Flag,
+ },
+ }
)
var (
@@ -280,6 +294,18 @@ func discv4Crawl(ctx *cli.Context) error {
return nil
}
+// discv4Test runs the protocol test suite.
+func discv4Test(ctx *cli.Context) error {
+ // Configure test package globals.
+ if !ctx.IsSet(remoteEnodeFlag.Name) {
+ return fmt.Errorf("missing -%v", remoteEnodeFlag.Name)
+ }
+ v4test.Remote = ctx.String(remoteEnodeFlag.Name)
+ v4test.Listen1 = ctx.String(testListen1Flag.Name)
+ v4test.Listen2 = ctx.String(testListen2Flag.Name)
+ return runTests(ctx, v4test.AllTests)
+}
+
// startV4 starts an ephemeral discovery V4 node.
func startV4(ctx *cli.Context) (*discover.UDPv4, discover.Config) {
ln, config := makeDiscoveryConfig(ctx)
diff --git a/cmd/devp2p/discv5cmd.go b/cmd/devp2p/discv5cmd.go
index 4293eda3aea7..4c39dd9b8045 100644
--- a/cmd/devp2p/discv5cmd.go
+++ b/cmd/devp2p/discv5cmd.go
@@ -22,6 +22,7 @@ import (
"slices"
"time"
+ "github.com/XinFinOrg/XDPoSChain/cmd/devp2p/internal/v5test"
"github.com/XinFinOrg/XDPoSChain/common"
"github.com/XinFinOrg/XDPoSChain/p2p/discover"
"github.com/urfave/cli/v2"
@@ -35,6 +36,7 @@ var (
discv5PingCommand,
discv5ResolveCommand,
discv5CrawlCommand,
+ discv5TestCommand,
discv5ListenCommand,
},
}
@@ -59,6 +61,17 @@ var (
crawlParallelismFlag,
}),
}
+ discv5TestCommand = &cli.Command{
+ Name: "test",
+ Usage: "Runs protocol tests against a node",
+ Action: discv5Test,
+ Flags: []cli.Flag{
+ testPatternFlag,
+ testTAPFlag,
+ testListen1Flag,
+ testListen2Flag,
+ },
+ }
discv5ListenCommand = &cli.Command{
Name: "listen",
Usage: "Runs a node",
@@ -109,6 +122,16 @@ func discv5Crawl(ctx *cli.Context) error {
return nil
}
+// discv5Test runs the protocol test suite.
+func discv5Test(ctx *cli.Context) error {
+ suite := &v5test.Suite{
+ Dest: getNodeArg(ctx),
+ Listen1: ctx.String(testListen1Flag.Name),
+ Listen2: ctx.String(testListen2Flag.Name),
+ }
+ return runTests(ctx, suite.AllTests())
+}
+
func discv5Listen(ctx *cli.Context) error {
disc, _ := startV5(ctx)
defer disc.Close()
diff --git a/cmd/devp2p/internal/ethtest/mkchain.sh b/cmd/devp2p/internal/ethtest/mkchain.sh
new file mode 100644
index 000000000000..fab630d9775d
--- /dev/null
+++ b/cmd/devp2p/internal/ethtest/mkchain.sh
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+hivechain generate \
+ --pos \
+ --fork-interval 6 \
+ --tx-interval 1 \
+ --length 600 \
+ --outdir testdata \
+ --lastfork prague \
+ --outputs accounts,genesis,chain,headstate,txinfo,headblock,headfcu,newpayload,forkenv
diff --git a/cmd/devp2p/internal/ethtest/protocol.go b/cmd/devp2p/internal/ethtest/protocol.go
index e7eb62477a37..66e890392d31 100644
--- a/cmd/devp2p/internal/ethtest/protocol.go
+++ b/cmd/devp2p/internal/ethtest/protocol.go
@@ -21,6 +21,25 @@ import (
"github.com/XinFinOrg/XDPoSChain/rlp"
)
+// Unexported devp2p message codes from p2p/peer.go.
+const (
+ handshakeMsg = 0x00
+ discMsg = 0x01
+ pingMsg = 0x02
+ pongMsg = 0x03
+)
+
+// Unexported devp2p protocol lengths from p2p package.
+const (
+ baseProtoLen = 16
+ ethProtoLen = 18
+ // snapProtoLen accommodates snap/2 (EIP-8189) which extends snap/1 with two
+ // additional message codes (GetBlockAccessLists=0x08, BlockAccessLists=0x09).
+ // Using 10 is safe for snap/1 connections because the extra codes are simply
+ // never used on that protocol version.
+ snapProtoLen = 10
+)
+
// Unexported handshake structure from p2p/peer.go.
type protoHandshake struct {
Version uint64
@@ -32,3 +51,42 @@ type protoHandshake struct {
}
type Hello = protoHandshake
+
+// Proto is an enum representing devp2p protocol types.
+type Proto int
+
+const (
+ baseProto Proto = iota
+ ethProto
+ snapProto
+)
+
+// getProto returns the protocol a certain message code is associated with
+// (assuming the negotiated capabilities are exactly {eth,snap})
+func getProto(code uint64) Proto {
+ switch {
+ case code < baseProtoLen:
+ return baseProto
+ case code < baseProtoLen+ethProtoLen:
+ return ethProto
+ case code < baseProtoLen+ethProtoLen+snapProtoLen:
+ return snapProto
+ default:
+ panic("unhandled msg code beyond last protocol")
+ }
+}
+
+// protoOffset will return the offset at which the specified protocol's messages
+// begin.
+func protoOffset(proto Proto) uint64 {
+ switch proto {
+ case baseProto:
+ return 0
+ case ethProto:
+ return baseProtoLen
+ case snapProto:
+ return baseProtoLen + ethProtoLen
+ default:
+ panic("unhandled protocol")
+ }
+}
diff --git a/cmd/devp2p/internal/ethtest/suite.go b/cmd/devp2p/internal/ethtest/suite.go
new file mode 100644
index 000000000000..76c40f36f185
--- /dev/null
+++ b/cmd/devp2p/internal/ethtest/suite.go
@@ -0,0 +1,455 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see .
+
+package ethtest
+
+import (
+ "crypto/ecdsa"
+ "fmt"
+ "net"
+ "strings"
+ "time"
+
+ "github.com/XinFinOrg/XDPoSChain/crypto"
+ "github.com/XinFinOrg/XDPoSChain/internal/utesting"
+ "github.com/XinFinOrg/XDPoSChain/p2p"
+ "github.com/XinFinOrg/XDPoSChain/p2p/enode"
+ "github.com/XinFinOrg/XDPoSChain/p2p/rlpx"
+ "github.com/XinFinOrg/XDPoSChain/rlp"
+)
+
+const handshakeTimeout = 5 * time.Second
+
+// Suite represents a minimal conformance test set that is compatible with
+// the protocol packages available in this repository snapshot.
+type Suite struct {
+ Dest *enode.Node
+}
+
+// NewSuite creates and returns a compatibility subset suite.
+// The extra string parameters are currently unused and kept for API parity.
+func NewSuite(dest *enode.Node, _, _, _ string) (*Suite, error) {
+ return &Suite{Dest: dest}, nil
+}
+
+// EthTests returns the enabled compatibility subset.
+//
+// Scope freeze:
+// 1. Keep only tests that depend on RLPx/devp2p handshake primitives available
+// in this repository snapshot.
+// 2. Avoid extending coverage into protocol packages that are not importable in
+// this fork state.
+// 3. Maintain behavior via boundary-driven hello/message-code/payload cases.
+func (s *Suite) EthTests() []utesting.Test {
+ return []utesting.Test{
+ // Baseline.
+ {Name: "RLPxHandshake", Fn: s.TestRLPxHandshake},
+
+ // Identity-focused hello boundary tests.
+ {Name: "MalformedHello", Fn: s.TestMalformedHello},
+ {Name: "MalformedHelloShortID", Fn: s.TestMalformedHelloShortID},
+ {Name: "MalformedHelloEmptyID", Fn: s.TestMalformedHelloEmptyID},
+ {Name: "MalformedHelloLongID", Fn: s.TestMalformedHelloLongID},
+ {Name: "MalformedHelloZeroID", Fn: s.TestMalformedHelloZeroID},
+ {Name: "MalformedHelloMismatchedID", Fn: s.TestMalformedHelloMismatchedID},
+
+ // Capability-focused hello boundary tests.
+ {Name: "HelloWithoutEthCap", Fn: s.TestHelloWithoutEthCap},
+ {Name: "HelloWithEmptyCaps", Fn: s.TestHelloWithEmptyCaps},
+ {Name: "HelloWithEmptyCapName", Fn: s.TestHelloWithEmptyCapName},
+ {Name: "HelloWithLongCapName", Fn: s.TestHelloWithLongCapName},
+ {Name: "HelloWithNULCapName", Fn: s.TestHelloWithNULCapName},
+ {Name: "HelloWithMismatchedIDAndEmptyCaps", Fn: s.TestHelloWithMismatchedIDAndEmptyCaps},
+ {Name: "HelloWithUnsortedNonEthCaps", Fn: s.TestHelloWithUnsortedNonEthCaps},
+ {Name: "HelloWithDuplicateEthCaps", Fn: s.TestHelloWithDuplicateEthCaps},
+
+ // Version and mixed hello semantics.
+ {Name: "HelloWithZeroVersion", Fn: s.TestHelloWithZeroVersion},
+ {Name: "HelloWithMaxVersion", Fn: s.TestHelloWithMaxVersion},
+ {Name: "HelloWithZeroVersionAndEmptyCaps", Fn: s.TestHelloWithZeroVersionAndEmptyCaps},
+
+ // Post-RLPx first-message code handling.
+ {Name: "WrongFirstMessageCode", Fn: s.TestWrongFirstMessageCode},
+ {Name: "FirstMessageDisconnect", Fn: s.TestFirstMessageDisconnect},
+ {Name: "FirstMessageDisconnectInvalidPayload", Fn: s.TestFirstMessageDisconnectInvalidPayload},
+ {Name: "FirstMessageDisconnectEmptyPayload", Fn: s.TestFirstMessageDisconnectEmptyPayload},
+
+ // Handshake payload size/encoding/type boundaries.
+ {Name: "OversizedHelloPayload", Fn: s.TestOversizedHelloPayload},
+ {Name: "EmptyHelloPayload", Fn: s.TestEmptyHelloPayload},
+ {Name: "TruncatedHelloPayload", Fn: s.TestTruncatedHelloPayload},
+ {Name: "InvalidHelloRLP", Fn: s.TestInvalidHelloRLP},
+ {Name: "HelloPayloadWrongRLPType", Fn: s.TestHelloPayloadWrongRLPType},
+ {Name: "HelloPayloadEmptyList", Fn: s.TestHelloPayloadEmptyList},
+ {Name: "HelloPayloadShortList", Fn: s.TestHelloPayloadShortList},
+ {Name: "HelloPayloadVersionWrongType", Fn: s.TestHelloPayloadVersionWrongType},
+ }
+}
+
+func (s *Suite) TestRLPxHandshake(t *utesting.T) {
+ t.Log(`This test verifies that the peer accepts a plain RLPx handshake.`)
+ key, err := crypto.GenerateKey()
+ if err != nil {
+ t.Fatalf("failed to generate key: %v", err)
+ }
+ conn, err := s.dialConn(key)
+ if err != nil {
+ t.Fatalf("rlpx handshake failed: %v", err)
+ }
+ conn.Close()
+}
+
+func (s *Suite) TestMalformedHello(t *utesting.T) {
+ t.Log(`This test sends a malformed devp2p hello and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "MalformedHello")
+}
+
+func (s *Suite) TestMalformedHelloShortID(t *utesting.T) {
+ t.Log(`This test sends a hello with a too-short peer id and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "MalformedHelloShortID")
+}
+
+func (s *Suite) TestMalformedHelloEmptyID(t *utesting.T) {
+ t.Log(`This test sends a hello with an empty peer id and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "MalformedHelloEmptyID")
+}
+
+func (s *Suite) TestMalformedHelloLongID(t *utesting.T) {
+ t.Log(`This test sends a hello with an overly long peer id and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "MalformedHelloLongID")
+}
+
+func (s *Suite) TestMalformedHelloZeroID(t *utesting.T) {
+ t.Log(`This test sends a hello with an all-zero peer id and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "MalformedHelloZeroID")
+}
+
+func (s *Suite) TestMalformedHelloMismatchedID(t *utesting.T) {
+ t.Log(`This test sends a hello with a non-zero but mismatched peer id and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "MalformedHelloMismatchedID")
+}
+
+func (s *Suite) TestHelloWithoutEthCap(t *utesting.T) {
+ t.Log(`This test sends a hello that omits eth capability and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithoutEthCap")
+}
+
+func (s *Suite) TestHelloWithZeroVersion(t *utesting.T) {
+ t.Log(`This test sends a hello with protocol version zero and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithZeroVersion")
+}
+
+func (s *Suite) TestHelloWithMaxVersion(t *utesting.T) {
+ t.Log(`This test sends a hello with max uint64 version and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithMaxVersion")
+}
+
+func (s *Suite) TestHelloWithZeroVersionAndEmptyCaps(t *utesting.T) {
+ t.Log(`This test sends a hello with zero version and empty capabilities and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithZeroVersionAndEmptyCaps")
+}
+
+func (s *Suite) TestHelloWithEmptyCaps(t *utesting.T) {
+ t.Log(`This test sends a hello with empty capabilities and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithEmptyCaps")
+}
+
+func (s *Suite) TestHelloWithEmptyCapName(t *utesting.T) {
+ t.Log(`This test sends a hello with an empty capability name and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithEmptyCapName")
+}
+
+func (s *Suite) TestHelloWithLongCapName(t *utesting.T) {
+ t.Log(`This test sends a hello with an overly long capability name and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithLongCapName")
+}
+
+func (s *Suite) TestHelloWithNULCapName(t *utesting.T) {
+ t.Log(`This test sends a hello with a NUL byte in capability name and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithNULCapName")
+}
+
+func (s *Suite) TestHelloWithMismatchedIDAndEmptyCaps(t *utesting.T) {
+ t.Log(`This test sends a hello with mismatched id and empty capabilities and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithMismatchedIDAndEmptyCaps")
+}
+
+func (s *Suite) TestHelloWithUnsortedNonEthCaps(t *utesting.T) {
+ t.Log(`This test sends a hello with unsorted non-eth capabilities and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithUnsortedNonEthCaps")
+}
+
+func (s *Suite) TestOversizedHelloPayload(t *utesting.T) {
+ t.Log(`This test sends an oversized hello payload and expects a disconnect.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ // p2p readProtocolHandshake enforces a 2KB max size for hello.
+ oversized := make([]byte, 2049)
+ s.expectDisconnectAfterHelloPayload(t, conn, oversized)
+ })
+}
+
+func (s *Suite) TestWrongFirstMessageCode(t *utesting.T) {
+ t.Log(`This test sends a non-handshake first message code and expects a disconnect.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ // The first post-RLPx message must be handshakeMsg.
+ s.expectDisconnectAfterMessage(t, conn, pingMsg, []byte{})
+ })
+}
+
+func (s *Suite) TestFirstMessageDisconnect(t *utesting.T) {
+ t.Log(`This test sends a disconnect as first post-RLPx message and expects disconnect handling.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ reasonPayload, err := rlp.EncodeToBytes([1]p2p.DiscReason{p2p.DiscRequested})
+ if err != nil {
+ t.Fatalf("failed to encode disconnect reason: %v", err)
+ }
+ s.expectDisconnectAfterMessage(t, conn, discMsg, reasonPayload)
+ })
+}
+
+func (s *Suite) TestFirstMessageDisconnectInvalidPayload(t *utesting.T) {
+ t.Log(`This test sends a disconnect with invalid reason payload and expects disconnect handling.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ // Invalid RLP for [1]DiscReason decoding path on receiver side.
+ s.expectDisconnectAfterMessage(t, conn, discMsg, []byte{0xff})
+ })
+}
+
+func (s *Suite) TestFirstMessageDisconnectEmptyPayload(t *utesting.T) {
+ t.Log(`This test sends a disconnect with empty payload and expects disconnect handling.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ // Empty payload should fail disconnect-reason decoding on receiver side.
+ s.expectDisconnectAfterMessage(t, conn, discMsg, []byte{})
+ })
+}
+
+func (s *Suite) TestEmptyHelloPayload(t *utesting.T) {
+ t.Log(`This test sends an empty hello payload and expects a disconnect.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ s.expectDisconnectAfterHelloPayload(t, conn, []byte{})
+ })
+}
+
+func (s *Suite) TestTruncatedHelloPayload(t *utesting.T) {
+ t.Log(`This test sends a truncated hello RLP payload and expects a disconnect.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ // List length prefix (1 byte) without element content.
+ s.expectDisconnectAfterHelloPayload(t, conn, []byte{0xc1})
+ })
+}
+
+func (s *Suite) TestInvalidHelloRLP(t *utesting.T) {
+ t.Log(`This test sends invalid hello RLP bytes and expects a disconnect.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ s.expectDisconnectAfterHelloPayload(t, conn, []byte{0xff})
+ })
+}
+
+func (s *Suite) TestHelloPayloadWrongRLPType(t *utesting.T) {
+ t.Log(`This test sends hello payload with wrong RLP type and expects a disconnect.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ // RLP empty string, while hello expects a list/struct payload.
+ s.expectDisconnectAfterHelloPayload(t, conn, []byte{0x80})
+ })
+}
+
+func (s *Suite) TestHelloPayloadEmptyList(t *utesting.T) {
+ t.Log(`This test sends hello payload as an empty RLP list and expects a disconnect.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ // RLP empty list. Decoded hello has zero-value fields and invalid identity.
+ s.expectDisconnectAfterHelloPayload(t, conn, []byte{0xc0})
+ })
+}
+
+func (s *Suite) TestHelloPayloadShortList(t *utesting.T) {
+ t.Log(`This test sends hello payload as a short RLP list and expects a disconnect.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ // RLP list with a single element (version only), missing required hello fields.
+ s.expectDisconnectAfterHelloPayload(t, conn, []byte{0xc1, 0x05})
+ })
+}
+
+func (s *Suite) TestHelloPayloadVersionWrongType(t *utesting.T) {
+ t.Log(`This test sends hello payload with wrong version field type and expects a disconnect.`)
+ s.withRLPxConn(t, func(conn *rlpx.Conn) {
+ // RLP list with one element: empty list, but hello version expects uint.
+ s.expectDisconnectAfterHelloPayload(t, conn, []byte{0xc1, 0xc0})
+ })
+}
+
+func (s *Suite) TestHelloWithDuplicateEthCaps(t *utesting.T) {
+ t.Log(`This test sends a hello with duplicate eth capabilities and expects a disconnect.`)
+ s.runMalformedHelloNamedCase(t, "HelloWithDuplicateEthCaps")
+}
+
+func malformedHelloByCase(name string, pub0 []byte) *protoHandshake {
+ base := &protoHandshake{
+ Version: 5,
+ Caps: []p2p.Cap{{Name: "eth", Version: 63}},
+ ID: pub0,
+ }
+ builders := map[string]func() *protoHandshake{
+ "MalformedHello": func() *protoHandshake {
+ cpy := append([]byte(nil), pub0...)
+ return &protoHandshake{Version: base.Version, Caps: base.Caps, ID: append(cpy, byte(0))}
+ },
+ "MalformedHelloShortID": func() *protoHandshake {
+ return &protoHandshake{Version: base.Version, Caps: base.Caps, ID: pub0[:63]}
+ },
+ "MalformedHelloEmptyID": func() *protoHandshake {
+ return &protoHandshake{Version: base.Version, Caps: base.Caps, ID: nil}
+ },
+ "MalformedHelloLongID": func() *protoHandshake {
+ longID := make([]byte, 128)
+ copy(longID, pub0)
+ return &protoHandshake{Version: base.Version, Caps: base.Caps, ID: longID}
+ },
+ "MalformedHelloZeroID": func() *protoHandshake {
+ return &protoHandshake{Version: base.Version, Caps: base.Caps, ID: make([]byte, 64)}
+ },
+ "MalformedHelloMismatchedID": func() *protoHandshake {
+ mismatch := append([]byte(nil), pub0...)
+ mismatch[0] ^= 0x01
+ return &protoHandshake{Version: base.Version, Caps: base.Caps, ID: mismatch}
+ },
+ "HelloWithoutEthCap": func() *protoHandshake {
+ return &protoHandshake{Version: base.Version, Caps: []p2p.Cap{{Name: "les", Version: 2}}, ID: base.ID}
+ },
+ "HelloWithZeroVersion": func() *protoHandshake {
+ return &protoHandshake{Version: 0, Caps: base.Caps, ID: base.ID}
+ },
+ "HelloWithMaxVersion": func() *protoHandshake {
+ return &protoHandshake{Version: ^uint64(0), Caps: base.Caps, ID: base.ID}
+ },
+ "HelloWithZeroVersionAndEmptyCaps": func() *protoHandshake {
+ return &protoHandshake{Version: 0, Caps: []p2p.Cap{}, ID: base.ID}
+ },
+ "HelloWithEmptyCaps": func() *protoHandshake {
+ return &protoHandshake{Version: base.Version, Caps: []p2p.Cap{}, ID: base.ID}
+ },
+ "HelloWithEmptyCapName": func() *protoHandshake {
+ return &protoHandshake{Version: base.Version, Caps: []p2p.Cap{{Name: "", Version: 63}}, ID: base.ID}
+ },
+ "HelloWithLongCapName": func() *protoHandshake {
+ return &protoHandshake{Version: base.Version, Caps: []p2p.Cap{{Name: strings.Repeat("x", 512), Version: 1}}, ID: base.ID}
+ },
+ "HelloWithNULCapName": func() *protoHandshake {
+ return &protoHandshake{Version: base.Version, Caps: []p2p.Cap{{Name: "et\x00h", Version: 63}}, ID: base.ID}
+ },
+ "HelloWithMismatchedIDAndEmptyCaps": func() *protoHandshake {
+ mismatch := append([]byte(nil), pub0...)
+ mismatch[0] ^= 0x01
+ return &protoHandshake{Version: base.Version, Caps: []p2p.Cap{}, ID: mismatch}
+ },
+ "HelloWithUnsortedNonEthCaps": func() *protoHandshake {
+ return &protoHandshake{
+ Version: base.Version,
+ Caps: []p2p.Cap{
+ {Name: "zzz", Version: 2},
+ {Name: "les", Version: 1},
+ },
+ ID: base.ID,
+ }
+ },
+ "HelloWithDuplicateEthCaps": func() *protoHandshake {
+ return &protoHandshake{
+ Version: base.Version,
+ Caps: []p2p.Cap{
+ {Name: "eth", Version: 63},
+ {Name: "eth", Version: 63},
+ },
+ ID: base.ID,
+ }
+ },
+ }
+ if builder, ok := builders[name]; ok {
+ return builder()
+ }
+ panic("unknown malformed hello case: " + name)
+}
+
+func (s *Suite) runMalformedHelloNamedCase(t *utesting.T, caseName string) {
+ s.withRLPxConnAndKey(t, func(conn *rlpx.Conn, key *ecdsa.PrivateKey) {
+ pub0 := crypto.FromECDSAPub(&key.PublicKey)[1:]
+ s.expectDisconnectAfterHello(t, conn, malformedHelloByCase(caseName, pub0))
+ })
+}
+
+func (s *Suite) withRLPxConn(t *utesting.T, fn func(conn *rlpx.Conn)) {
+ s.withRLPxConnAndKey(t, func(conn *rlpx.Conn, _ *ecdsa.PrivateKey) {
+ fn(conn)
+ })
+}
+
+func (s *Suite) withRLPxConnAndKey(t *utesting.T, fn func(conn *rlpx.Conn, key *ecdsa.PrivateKey)) {
+ key, err := crypto.GenerateKey()
+ if err != nil {
+ t.Fatalf("failed to generate key: %v", err)
+ }
+ conn, err := s.dialConn(key)
+ if err != nil {
+ t.Fatalf("rlpx handshake failed: %v", err)
+ }
+ defer conn.Close()
+ fn(conn, key)
+}
+
+func (s *Suite) expectDisconnectAfterHello(t *utesting.T, conn *rlpx.Conn, hello *protoHandshake) {
+ payload, err := rlp.EncodeToBytes(hello)
+ if err != nil {
+ t.Fatalf("failed to encode malformed hello: %v", err)
+ }
+ s.expectDisconnectAfterHelloPayload(t, conn, payload)
+}
+
+func (s *Suite) expectDisconnectAfterHelloPayload(t *utesting.T, conn *rlpx.Conn, payload []byte) {
+ s.expectDisconnectAfterMessage(t, conn, handshakeMsg, payload)
+}
+
+func (s *Suite) expectDisconnectAfterMessage(t *utesting.T, conn *rlpx.Conn, code uint64, payload []byte) {
+ if _, err := conn.Write(code, payload); err != nil {
+ t.Fatalf("failed to write test message: %v", err)
+ }
+
+ conn.SetReadDeadline(time.Now().Add(handshakeTimeout))
+ code, _, _, err := conn.Read()
+ if err != nil {
+ return
+ }
+ if code == discMsg {
+ return
+ }
+ t.Fatalf("expected disconnect after test message, got msg code %d", code)
+}
+
+func (s *Suite) dialConn(key *ecdsa.PrivateKey) (*rlpx.Conn, error) {
+ tcpEndpoint, ok := s.Dest.TCPEndpoint()
+ if !ok {
+ return nil, fmt.Errorf("node has no TCP endpoint")
+ }
+ fd, err := net.DialTimeout("tcp", tcpEndpoint.String(), handshakeTimeout)
+ if err != nil {
+ return nil, err
+ }
+
+ conn := rlpx.NewConn(fd, s.Dest.Pubkey())
+ _, err = conn.Handshake(key)
+ if err != nil {
+ conn.Close()
+ return nil, err
+ }
+ return conn, nil
+}
diff --git a/cmd/devp2p/internal/ethtest/testdata/accounts.json b/cmd/devp2p/internal/ethtest/testdata/accounts.json
new file mode 100644
index 000000000000..c9666235a850
--- /dev/null
+++ b/cmd/devp2p/internal/ethtest/testdata/accounts.json
@@ -0,0 +1,62 @@
+{
+ "0x0c2c51a0990aee1d73c1228de158688341557508": {
+ "key": "0xbfcd0e032489319f4e5ca03e643b2025db624be6cf99cbfed90c4502e3754850"
+ },
+ "0x14e46043e63d0e3cdcf2530519f4cfaf35058cb2": {
+ "key": "0x457075f6822ac29481154792f65c5f1ec335b4fea9ca20f3fea8fa1d78a12c68"
+ },
+ "0x16c57edf7fa9d9525378b0b81bf8a3ced0620c1c": {
+ "key": "0x865898edcf43206d138c93f1bbd86311f4657b057658558888aa5ac4309626a6"
+ },
+ "0x1f4924b14f34e24159387c0a4cdbaa32f3ddb0cf": {
+ "key": "0xee7f7875d826d7443ccc5c174e38b2c436095018774248a8074ee92d8914dcdb"
+ },
+ "0x1f5bde34b4afc686f136c7a3cb6ec376f7357759": {
+ "key": "0x25e6ce8611cefb5cd338aeaa9292ed2139714668d123a4fb156cabb42051b5b7"
+ },
+ "0x2d389075be5be9f2246ad654ce152cf05990b209": {
+ "key": "0x19168cd7767604b3d19b99dc3da1302b9ccb6ee9ad61660859e07acd4a2625dd"
+ },
+ "0x3ae75c08b4c907eb63a8960c45b86e1e9ab6123c": {
+ "key": "0x71aa7d299c7607dabfc3d0e5213d612b5e4a97455b596c2f642daac43fa5eeaa"
+ },
+ "0x4340ee1b812acb40a1eb561c019c327b243b92df": {
+ "key": "0x47f666f20e2175606355acec0ea1b37870c15e5797e962340da7ad7972a537e8"
+ },
+ "0x4a0f1452281bcec5bd90c3dce6162a5995bfe9df": {
+ "key": "0xa88293fefc623644969e2ce6919fb0dbd0fd64f640293b4bf7e1a81c97e7fc7f"
+ },
+ "0x4dde844b71bcdf95512fb4dc94e84fb67b512ed8": {
+ "key": "0x6e1e16a9c15641c73bf6e237f9293ab1d4e7c12b9adf83cfc94bcf969670f72d"
+ },
+ "0x5f552da00dfb4d3749d9e62dcee3c918855a86a0": {
+ "key": "0x41be4e00aac79f7ffbb3455053ec05e971645440d594c047cdcc56a3c7458bd6"
+ },
+ "0x654aa64f5fbefb84c270ec74211b81ca8c44a72e": {
+ "key": "0xc825f31cd8792851e33a290b3d749e553983111fc1f36dfbbdb45f101973f6a9"
+ },
+ "0x717f8aa2b982bee0e29f573d31df288663e1ce16": {
+ "key": "0x8d0faa04ae0f9bc3cd4c890aa025d5f40916f4729538b19471c0beefe11d9e19"
+ },
+ "0x7435ed30a8b4aeb0877cef0c6e8cffe834eb865f": {
+ "key": "0x4552dbe6ca4699322b5d923d0c9bcdd24644f5db8bf89a085b67c6c49b8a1b91"
+ },
+ "0x83c7e323d189f18725ac510004fdc2941f8c4a78": {
+ "key": "0x34391cbbf06956bb506f45ec179cdd84df526aa364e27bbde65db9c15d866d00"
+ },
+ "0x84e75c28348fb86acea1a93a39426d7d60f4cc46": {
+ "key": "0xf6a8f1603b8368f3ca373292b7310c53bec7b508aecacd442554ebc1c5d0c856"
+ },
+ "0xc7b99a164efd027a93f147376cc7da7c67c6bbe0": {
+ "key": "0x8d56bcbcf2c1b7109e1396a28d7a0234e33544ade74ea32c460ce4a443b239b1"
+ },
+ "0xd803681e487e6ac18053afc5a6cd813c86ec3e4d": {
+ "key": "0xfc39d1c9ddbba176d806ebb42d7460189fe56ca163ad3eb6143bfc6beb6f6f72"
+ },
+ "0xe7d13f7aa2a838d24c59b40186a0aca1e21cffcc": {
+ "key": "0x9ee3fd550664b246ad7cdba07162dd25530a3b1d51476dd1d85bbc29f0592684"
+ },
+ "0xeda8645ba6948855e3b3cd596bbb07596d59c603": {
+ "key": "0x14cdde09d1640eb8c3cda063891b0453073f57719583381ff78811efa6d4199f"
+ }
+}
\ No newline at end of file
diff --git a/cmd/devp2p/internal/ethtest/testdata/chain.rlp b/cmd/devp2p/internal/ethtest/testdata/chain.rlp
new file mode 100644
index 0000000000000000000000000000000000000000..d5209ab0413ab9977afa596152879ae8d95ae556
GIT binary patch
literal 457980
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