mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-23 04:03:49 +00:00
e83c3ccc47
* p2p/enr: add entries for for IPv4/IPv6 separation This adds entry types for "ip6", "udp6", "tcp6" keys. The IP type stays around because removing it would break a lot of code and force everyone to care about the distinction. * p2p/enode: track IPv4 and IPv6 address separately LocalNode predicts the local node's UDP endpoint and updates the record. This change makes it predict IPv4 and IPv6 endpoints separately since they can now be in the record at the same time. * p2p/enode: implement base64 text format * all: switch to enode.Parse(...) This allows passing base64-encoded node records to all the places that previously accepted enode:// URLs. The URL format is still supported. * cmd/bootnode, p2p: log node URL instead of ENR ...and return the base64 record in NodeInfo.
301 lines
7.1 KiB
Go
301 lines
7.1 KiB
Go
// Copyright 2018 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package enode
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"math/bits"
|
|
"math/rand"
|
|
"net"
|
|
"strings"
|
|
|
|
"github.com/ethereum/go-ethereum/p2p/enr"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
)
|
|
|
|
var errMissingPrefix = errors.New("missing 'enr:' prefix for base64-encoded record")
|
|
|
|
// Node represents a host on the network.
|
|
type Node struct {
|
|
r enr.Record
|
|
id ID
|
|
}
|
|
|
|
// New wraps a node record. The record must be valid according to the given
|
|
// identity scheme.
|
|
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{}))
|
|
}
|
|
return node, nil
|
|
}
|
|
|
|
// MustParse parses a node record or enode:// URL. It panics if the input is invalid.
|
|
func MustParse(rawurl string) *Node {
|
|
n, err := Parse(ValidSchemes, rawurl)
|
|
if err != nil {
|
|
panic("invalid node: " + err.Error())
|
|
}
|
|
return n
|
|
}
|
|
|
|
// Parse decodes and verifies a base64-encoded node record.
|
|
func Parse(validSchemes enr.IdentityScheme, input string) (*Node, error) {
|
|
if strings.HasPrefix(input, "enode://") {
|
|
return ParseV4(input)
|
|
}
|
|
if !strings.HasPrefix(input, "enr:") {
|
|
return nil, errMissingPrefix
|
|
}
|
|
bin, err := base64.RawURLEncoding.DecodeString(input[4:])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var r enr.Record
|
|
if err := rlp.DecodeBytes(bin, &r); err != nil {
|
|
return nil, err
|
|
}
|
|
return New(validSchemes, &r)
|
|
}
|
|
|
|
// ID returns the node identifier.
|
|
func (n *Node) ID() ID {
|
|
return n.id
|
|
}
|
|
|
|
// Seq returns the sequence number of the underlying record.
|
|
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.
|
|
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
|
|
}
|
|
|
|
// UDP returns the UDP port of the node.
|
|
func (n *Node) UDP() int {
|
|
var port enr.UDP
|
|
n.Load(&port)
|
|
return int(port)
|
|
}
|
|
|
|
// UDP returns the TCP port of the node.
|
|
func (n *Node) TCP() int {
|
|
var port enr.TCP
|
|
n.Load(&port)
|
|
return int(port)
|
|
}
|
|
|
|
// Pubkey returns the secp256k1 public key of the node, if present.
|
|
func (n *Node) Pubkey() *ecdsa.PublicKey {
|
|
var key ecdsa.PublicKey
|
|
if n.Load((*Secp256k1)(&key)) != nil {
|
|
return nil
|
|
}
|
|
return &key
|
|
}
|
|
|
|
// Record returns the node's record. The return value is a copy and may
|
|
// be modified by the caller.
|
|
func (n *Node) Record() *enr.Record {
|
|
cpy := n.r
|
|
return &cpy
|
|
}
|
|
|
|
// 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() {
|
|
return errors.New("missing IP address")
|
|
}
|
|
if n.UDP() == 0 {
|
|
return errors.New("missing UDP port")
|
|
}
|
|
ip := n.IP()
|
|
if ip.IsMulticast() || ip.IsUnspecified() {
|
|
return errors.New("invalid IP (multicast/unspecified)")
|
|
}
|
|
// Validate the node key (on curve, etc.).
|
|
var key Secp256k1
|
|
return n.Load(&key)
|
|
}
|
|
|
|
// String returns the text representation of the record.
|
|
func (n *Node) String() string {
|
|
if isNewV4(n) {
|
|
return n.URLv4() // backwards-compatibility glue for NewV4 nodes
|
|
}
|
|
enc, _ := rlp.EncodeToBytes(&n.r) // always succeeds because record is valid
|
|
b64 := base64.RawURLEncoding.EncodeToString(enc)
|
|
return "enr:" + b64
|
|
}
|
|
|
|
// MarshalText implements encoding.TextMarshaler.
|
|
func (n *Node) MarshalText() ([]byte, error) {
|
|
return []byte(n.String()), nil
|
|
}
|
|
|
|
// UnmarshalText implements encoding.TextUnmarshaler.
|
|
func (n *Node) UnmarshalText(text []byte) error {
|
|
dec, err := Parse(ValidSchemes, string(text))
|
|
if err == nil {
|
|
*n = *dec
|
|
}
|
|
return err
|
|
}
|
|
|
|
// ID is a unique identifier for each node.
|
|
type ID [32]byte
|
|
|
|
// Bytes returns a byte slice representation of the ID
|
|
func (n ID) Bytes() []byte {
|
|
return n[:]
|
|
}
|
|
|
|
// ID prints as a long hexadecimal number.
|
|
func (n ID) String() string {
|
|
return fmt.Sprintf("%x", n[:])
|
|
}
|
|
|
|
// The Go syntax representation of a ID is a call to HexID.
|
|
func (n ID) GoString() string {
|
|
return fmt.Sprintf("enode.HexID(\"%x\")", n[:])
|
|
}
|
|
|
|
// TerminalString returns a shortened hex string for terminal logging.
|
|
func (n ID) TerminalString() string {
|
|
return hex.EncodeToString(n[:8])
|
|
}
|
|
|
|
// MarshalText implements the encoding.TextMarshaler interface.
|
|
func (n ID) MarshalText() ([]byte, error) {
|
|
return []byte(hex.EncodeToString(n[:])), nil
|
|
}
|
|
|
|
// UnmarshalText implements the encoding.TextUnmarshaler interface.
|
|
func (n *ID) UnmarshalText(text []byte) error {
|
|
id, err := parseID(string(text))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*n = id
|
|
return nil
|
|
}
|
|
|
|
// HexID converts a hex string to an ID.
|
|
// The string may be prefixed with 0x.
|
|
// It panics if the string is not a valid ID.
|
|
func HexID(in string) ID {
|
|
id, err := parseID(in)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return id
|
|
}
|
|
|
|
func parseID(in string) (ID, error) {
|
|
var id ID
|
|
b, err := hex.DecodeString(strings.TrimPrefix(in, "0x"))
|
|
if err != nil {
|
|
return id, err
|
|
} else if len(b) != len(id) {
|
|
return id, fmt.Errorf("wrong length, want %d hex chars", len(id)*2)
|
|
}
|
|
copy(id[:], b)
|
|
return id, nil
|
|
}
|
|
|
|
// DistCmp compares the distances a->target and b->target.
|
|
// Returns -1 if a is closer to target, 1 if b is closer to target
|
|
// and 0 if they are equal.
|
|
func DistCmp(target, a, b ID) int {
|
|
for i := range target {
|
|
da := a[i] ^ target[i]
|
|
db := b[i] ^ target[i]
|
|
if da > db {
|
|
return 1
|
|
} else if da < db {
|
|
return -1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// LogDist returns the logarithmic distance between a and b, log2(a ^ b).
|
|
func LogDist(a, b ID) int {
|
|
lz := 0
|
|
for i := range a {
|
|
x := a[i] ^ b[i]
|
|
if x == 0 {
|
|
lz += 8
|
|
} else {
|
|
lz += bits.LeadingZeros8(x)
|
|
break
|
|
}
|
|
}
|
|
return len(a)*8 - lz
|
|
}
|
|
|
|
// RandomID returns a random ID b such that logdist(a, b) == n.
|
|
func RandomID(a ID, n int) (b ID) {
|
|
if n == 0 {
|
|
return a
|
|
}
|
|
// flip bit at position n, fill the rest with random bits
|
|
b = a
|
|
pos := len(a) - n/8 - 1
|
|
bit := byte(0x01) << (byte(n%8) - 1)
|
|
if bit == 0 {
|
|
pos++
|
|
bit = 0x80
|
|
}
|
|
b[pos] = a[pos]&^bit | ^a[pos]&bit // TODO: randomize end bits
|
|
for i := pos + 1; i < len(a); i++ {
|
|
b[i] = byte(rand.Intn(255))
|
|
}
|
|
return b
|
|
}
|