path: root/p2p/discover/node.go

// Copyright 2015 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package discover

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "encoding/hex"
    "errors"
    "fmt"
    "math/big"
    "math/rand"
    "net"
    "net/url"
    "regexp"
    "strconv"
    "strings"
    "time"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/crypto/secp256k1"
)

const NodeIDBits = 512

// Node represents a host on the network.
// The fields of Node may not be modified.
type Node struct {
    IP       net.IP // len 4 for IPv4 or 16 for IPv6
    UDP, TCP uint16 // port numbers
    ID       NodeID // the node's public key

    // This is a cached copy of sha3(ID) which is used for node
    // distance calculations. This is part of Node in order to make it
    // possible to write tests that need a node at a certain distance.
    // In those tests, the content of sha will not actually correspond
    // with ID.
    sha common.Hash

    // Time when the node was added to the table.
    addedAt time.Time
}

// NewNode creates a new node. It is mostly meant to be used for
// testing purposes.
func NewNode(id NodeID, ip net.IP, udpPort, tcpPort uint16) *Node {
    if ipv4 := ip.To4(); ipv4 != nil {
        ip = ipv4
    }
    return &Node{
        IP:  ip,
        UDP: udpPort,
        TCP: tcpPort,
        ID:  id,
        sha: crypto.Keccak256Hash(id[:]),
    }
}

func (n *Node) addr() *net.UDPAddr {
    return &net.UDPAddr{IP: n.IP, Port: int(n.UDP)}
}

// Incomplete returns true for nodes with no IP address.
func (n *Node) Incomplete() bool {
    return n.IP == nil
}

// checks whether n is a valid complete node.
func (n *Node) validateComplete() error {
    if n.Incomplete() {
        return errors.New("incomplete node")
    }
    if n.UDP == 0 {
        return errors.New("missing UDP port")
    }
    if n.TCP == 0 {
        return errors.New("missing TCP port")
    }
    if n.IP.IsMulticast() || n.IP.IsUnspecified() {
        return errors.New("invalid IP (multicast/unspecified)")
    }
    _, err := n.ID.Pubkey() // validate the key (on curve, etc.)
    return err
}

// The string representation of a Node is a URL.
// Please see ParseNode for a description of the format.
func (n *Node) String() string {
    u := url.URL{Scheme: "enode"}
    if n.Incomplete() {
        u.Host = fmt.Sprintf("%x", n.ID[:])
    } else {
        addr := net.TCPAddr{IP: n.IP, Port: int(n.TCP)}
        u.User = url.User(fmt.Sprintf("%x", n.ID[:]))
        u.Host = addr.String()
        if n.UDP != n.TCP {
            u.RawQuery = "discport=" + strconv.Itoa(int(n.UDP))
        }
    }
    return u.String()
}

var incompleteNodeURL = regexp.MustCompile("(?i)^(?:enode://)?([0-9a-f]+)$")

// ParseNode parses a node designator.
//
// There are two basic forms of node designators
//   - incomplete nodes, which only have the public key (node ID)
//   - complete nodes, which contain the public key and IP/Port information
//
// For incomplete nodes, the designator must look like one of these
//
//    enode://<hex node id>
//    <hex node id>
//
// For complete nodes, the node ID is encoded in the username portion
// of the URL, separated from the host by an @ sign. The hostname can
// only be given as an IP address, DNS domain names are not allowed.
// The port in the host name section is the TCP listening port. If the
// TCP and UDP (discovery) ports differ, the UDP port is specified as
// query parameter "discport".
//
// In the following example, the node URL describes
// a node with IP address 10.3.58.6, TCP listening port 30303
// and UDP discovery port 30301.
//
//    enode://<hex node id>@10.3.58.6:30303?discport=30301
func ParseNode(rawurl string) (*Node, error) {
    if m := incompleteNodeURL.FindStringSubmatch(rawurl); m != nil {
        id, err := HexID(m[1])
        if err != nil {
            return nil, fmt.Errorf("invalid node ID (%v)", err)
        }
        return NewNode(id, nil, 0, 0), nil
    }
    return parseComplete(rawurl)
}

func parseComplete(rawurl string) (*Node, error) {
    var (
        id               NodeID
        ip               net.IP
        tcpPort, udpPort uint64
    )
    u, err := url.Parse(rawurl)
    if err != nil {
        return nil, err
    }
    if u.Scheme != "enode" {
        return nil, errors.New("invalid URL scheme, want \"enode\"")
    }
    // Parse the Node ID from the user portion.
    if u.User == nil {
        return nil, errors.New("does not contain node ID")
    }
    if id, err = HexID(u.User.String()); err != nil {
        return nil, fmt.Errorf("invalid node ID (%v)", err)
    }
    // Parse the IP address.
    host, port, err := net.SplitHostPort(u.Host)
    if err != nil {
        return nil, fmt.Errorf("invalid host: %v", err)
    }
    if ip = net.ParseIP(host); ip == nil {
        return nil, errors.New("invalid IP address")
    }
    // Ensure the IP is 4 bytes long for IPv4 addresses.
    if ipv4 := ip.To4(); ipv4 != nil {
        ip = ipv4
    }
    // Parse the port numbers.
    if tcpPort, err = strconv.ParseUint(port, 10, 16); err != nil {
        return nil, errors.New("invalid port")
    }
    udpPort = tcpPort
    qv := u.Query()
    if qv.Get("discport") != "" {
        udpPort, err = strconv.ParseUint(qv.Get("discport"), 10, 16)
        if err != nil {
            return nil, errors.New("invalid discport in query")
        }
    }
    return NewNode(id, ip, uint16(udpPort), uint16(tcpPort)), nil
}

// MustParseNode parses a node URL. It panics if the URL is not valid.
func MustParseNode(rawurl string) *Node {
    n, err := ParseNode(rawurl)
    if err != nil {
        panic("invalid node URL: " + err.Error())
    }
    return n
}

// 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 := ParseNode(string(text))
    if err == nil {
        *n = *dec
    }
    return err
}

// NodeID is a unique identifier for each node.
// The node identifier is a marshaled elliptic curve public key.
type NodeID [NodeIDBits / 8]byte

// Bytes returns a byte slice representation of the NodeID
func (n NodeID) Bytes() []byte {
    return n[:]
}

// NodeID prints as a long hexadecimal number.
func (n NodeID) String() string {
    return fmt.Sprintf("%x", n[:])
}

// The Go syntax representation of a NodeID is a call to HexID.
func (n NodeID) GoString() string {
    return fmt.Sprintf("discover.HexID(\"%x\")", n[:])
}

// TerminalString returns a shortened hex string for terminal logging.
func (n NodeID) TerminalString() string {
    return hex.EncodeToString(n[:8])
}

// MarshalText implements the encoding.TextMarshaler interface.
func (n NodeID) MarshalText() ([]byte, error) {
    return []byte(hex.EncodeToString(n[:])), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface.
func (n *NodeID) UnmarshalText(text []byte) error {
    id, err := HexID(string(text))
    if err != nil {
        return err
    }
    *n = id
    return nil
}

// BytesID converts a byte slice to a NodeID
func BytesID(b []byte) (NodeID, error) {
    var id NodeID
    if len(b) != len(id) {
        return id, fmt.Errorf("wrong length, want %d bytes", len(id))
    }
    copy(id[:], b)
    return id, nil
}

// MustBytesID converts a byte slice to a NodeID.
// It panics if the byte slice is not a valid NodeID.
func MustBytesID(b []byte) NodeID {
    id, err := BytesID(b)
    if err != nil {
        panic(err)
    }
    return id
}

// HexID converts a hex string to a NodeID.
// The string may be prefixed with 0x.
func HexID(in string) (NodeID, error) {
    var id NodeID
    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
}

// MustHexID converts a hex string to a NodeID.
// It panics if the string is not a valid NodeID.
func MustHexID(in string) NodeID {
    id, err := HexID(in)
    if err != nil {
        panic(err)
    }
    return id
}

// PubkeyID returns a marshaled representation of the given public key.
func PubkeyID(pub *ecdsa.PublicKey) NodeID {
    var id NodeID
    pbytes := elliptic.Marshal(pub.Curve, pub.X, pub.Y)
    if len(pbytes)-1 != len(id) {
        panic(fmt.Errorf("need %d bit pubkey, got %d bits", (len(id)+1)*8, len(pbytes)))
    }
    copy(id[:], pbytes[1:])
    return id
}

// Pubkey returns the public key represented by the node ID.
// It returns an error if the ID is not a point on the curve.
func (id NodeID) Pubkey() (*ecdsa.PublicKey, error) {
    p := &ecdsa.PublicKey{Curve: crypto.S256(), X: new(big.Int), Y: new(big.Int)}
    half := len(id) / 2
    p.X.SetBytes(id[:half])
    p.Y.SetBytes(id[half:])
    if !p.Curve.IsOnCurve(p.X, p.Y) {
        return nil, errors.New("id is invalid secp256k1 curve point")
    }
    return p, nil
}

// recoverNodeID computes the public key used to sign the
// given hash from the signature.
func recoverNodeID(hash, sig []byte) (id NodeID, err error) {
    pubkey, err := secp256k1.RecoverPubkey(hash, sig)
    if err != nil {
        return id, err
    }
    if len(pubkey)-1 != len(id) {
        return id, fmt.Errorf("recovered pubkey has %d bits, want %d bits", len(pubkey)*8, (len(id)+1)*8)
    }
    for i := range id {
        id[i] = pubkey[i+1]
    }
    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 common.Hash) 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
}

// table of leading zero counts for bytes [0..255]
var lzcount = [256]int{
    8, 7, 6, 6, 5, 5, 5, 5,
    4, 4, 4, 4, 4, 4, 4, 4,
    3, 3, 3, 3, 3, 3, 3, 3,
    3, 3, 3, 3, 3, 3, 3, 3,
    2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
}

// logdist returns the logarithmic distance between a and b, log2(a ^ b).
func logdist(a, b common.Hash) int {
    lz := 0
    for i := range a {
        x := a[i] ^ b[i]
        if x == 0 {
            lz += 8
        } else {
            lz += lzcount[x]
            break
        }
    }
    return len(a)*8 - lz
}

// hashAtDistance returns a random hash such that logdist(a, b) == n
func hashAtDistance(a common.Hash, n int) (b common.Hash) {
    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
}