forked from mirror/go-ethereum
The discovery RPC protocol does not yet distinguish TCP and UDP ports. But it can't hurt to do so in our internal model.poc8
Felix Lange
10 years ago
parent
56f777b2fc
commit
8564eb9f7e
@ -0,0 +1,289 @@ |
||||
package discover |
||||
|
||||
import ( |
||||
"crypto/ecdsa" |
||||
"crypto/elliptic" |
||||
"encoding/hex" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"math/rand" |
||||
"net" |
||||
"net/url" |
||||
"strconv" |
||||
"strings" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto/secp256k1" |
||||
"github.com/ethereum/go-ethereum/rlp" |
||||
) |
||||
|
||||
// Node represents a host on the network.
|
||||
type Node struct { |
||||
ID NodeID |
||||
IP net.IP |
||||
|
||||
DiscPort int // UDP listening port for discovery protocol
|
||||
TCPPort int // TCP listening port for RLPx
|
||||
|
||||
active time.Time |
||||
} |
||||
|
||||
func newNode(id NodeID, addr *net.UDPAddr) *Node { |
||||
return &Node{ |
||||
ID: id, |
||||
IP: addr.IP, |
||||
DiscPort: addr.Port, |
||||
TCPPort: addr.Port, |
||||
active: time.Now(), |
||||
} |
||||
} |
||||
|
||||
func (n *Node) isValid() bool { |
||||
// TODO: don't accept localhost, LAN addresses from internet hosts
|
||||
return !n.IP.IsMulticast() && !n.IP.IsUnspecified() && n.TCPPort != 0 && n.DiscPort != 0 |
||||
} |
||||
|
||||
// The string representation of a Node is a URL.
|
||||
// Please see ParseNode for a description of the format.
|
||||
func (n *Node) String() string { |
||||
addr := net.TCPAddr{IP: n.IP, Port: n.TCPPort} |
||||
u := url.URL{ |
||||
Scheme: "enode", |
||||
User: url.User(fmt.Sprintf("%x", n.ID[:])), |
||||
Host: addr.String(), |
||||
} |
||||
if n.DiscPort != n.TCPPort { |
||||
u.RawQuery = "discport=" + strconv.Itoa(n.DiscPort) |
||||
} |
||||
return u.String() |
||||
} |
||||
|
||||
// ParseNode parses a node URL.
|
||||
//
|
||||
// A node URL has scheme "enode".
|
||||
//
|
||||
// The hexadecimal 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) { |
||||
var n Node |
||||
u, err := url.Parse(rawurl) |
||||
if u.Scheme != "enode" { |
||||
return nil, errors.New("invalid URL scheme, want \"enode\"") |
||||
} |
||||
if u.User == nil { |
||||
return nil, errors.New("does not contain node ID") |
||||
} |
||||
if n.ID, err = HexID(u.User.String()); err != nil { |
||||
return nil, fmt.Errorf("invalid node ID (%v)", err) |
||||
} |
||||
ip, port, err := net.SplitHostPort(u.Host) |
||||
if err != nil { |
||||
return nil, fmt.Errorf("invalid host: %v", err) |
||||
} |
||||
if n.IP = net.ParseIP(ip); n.IP == nil { |
||||
return nil, errors.New("invalid IP address") |
||||
} |
||||
if n.TCPPort, err = strconv.Atoi(port); err != nil { |
||||
return nil, errors.New("invalid port") |
||||
} |
||||
qv := u.Query() |
||||
if qv.Get("discport") == "" { |
||||
n.DiscPort = n.TCPPort |
||||
} else { |
||||
if n.DiscPort, err = strconv.Atoi(qv.Get("discport")); err != nil { |
||||
return nil, errors.New("invalid discport in query") |
||||
} |
||||
} |
||||
return &n, 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 |
||||
} |
||||
|
||||
func (n Node) EncodeRLP(w io.Writer) error { |
||||
return rlp.Encode(w, rpcNode{IP: n.IP.String(), Port: uint16(n.TCPPort), ID: n.ID}) |
||||
} |
||||
func (n *Node) DecodeRLP(s *rlp.Stream) (err error) { |
||||
var ext rpcNode |
||||
if err = s.Decode(&ext); err == nil { |
||||
n.TCPPort = int(ext.Port) |
||||
n.DiscPort = int(ext.Port) |
||||
n.ID = ext.ID |
||||
if n.IP = net.ParseIP(ext.IP); n.IP == nil { |
||||
return errors.New("invalid IP string") |
||||
} |
||||
} |
||||
return err |
||||
} |
||||
|
||||
// NodeID is a unique identifier for each node.
|
||||
// The node identifier is a marshaled elliptic curve public key.
|
||||
type NodeID [512 / 8]byte |
||||
|
||||
// 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[:]) |
||||
} |
||||
|
||||
// HexID converts a hex string to a NodeID.
|
||||
// The string may be prefixed with 0x.
|
||||
func HexID(in string) (NodeID, error) { |
||||
if strings.HasPrefix(in, "0x") { |
||||
in = in[2:] |
||||
} |
||||
var id NodeID |
||||
b, err := hex.DecodeString(in) |
||||
if err != nil { |
||||
return id, err |
||||
} else if len(b) != len(id) { |
||||
return id, fmt.Errorf("wrong length, need %d hex bytes", len(id)) |
||||
} |
||||
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 |
||||
} |
||||
|
||||
// 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 NodeID) 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 NodeID) 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 |
||||
} |
||||
|
||||
// randomID returns a random NodeID such that logdist(a, b) == n
|
||||
func randomID(a NodeID, n int) (b NodeID) { |
||||
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 |
||||
} |
||||
@ -0,0 +1,201 @@ |
||||
package discover |
||||
|
||||
import ( |
||||
"math/big" |
||||
"math/rand" |
||||
"net" |
||||
"reflect" |
||||
"testing" |
||||
"testing/quick" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
) |
||||
|
||||
var ( |
||||
quickrand = rand.New(rand.NewSource(time.Now().Unix())) |
||||
quickcfg = &quick.Config{MaxCount: 5000, Rand: quickrand} |
||||
) |
||||
|
||||
var parseNodeTests = []struct { |
||||
rawurl string |
||||
wantError string |
||||
wantResult *Node |
||||
}{ |
||||
{ |
||||
rawurl: "http://foobar", |
||||
wantError: `invalid URL scheme, want "enode"`, |
||||
}, |
||||
{ |
||||
rawurl: "enode://foobar", |
||||
wantError: `does not contain node ID`, |
||||
}, |
||||
{ |
||||
rawurl: "enode://01010101@123.124.125.126:3", |
||||
wantError: `invalid node ID (wrong length, need 64 hex bytes)`, |
||||
}, |
||||
{ |
||||
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@hostname:3", |
||||
wantError: `invalid IP address`, |
||||
}, |
||||
{ |
||||
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:foo", |
||||
wantError: `invalid port`, |
||||
}, |
||||
{ |
||||
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:3?discport=foo", |
||||
wantError: `invalid discport in query`, |
||||
}, |
||||
{ |
||||
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:52150", |
||||
wantResult: &Node{ |
||||
ID: MustHexID("0x1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439"), |
||||
IP: net.ParseIP("127.0.0.1"), |
||||
DiscPort: 52150, |
||||
TCPPort: 52150, |
||||
}, |
||||
}, |
||||
{ |
||||
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@[::]:52150", |
||||
wantResult: &Node{ |
||||
ID: MustHexID("0x1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439"), |
||||
IP: net.ParseIP("::"), |
||||
DiscPort: 52150, |
||||
TCPPort: 52150, |
||||
}, |
||||
}, |
||||
{ |
||||
rawurl: "enode://1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439@127.0.0.1:52150?discport=223344", |
||||
wantResult: &Node{ |
||||
ID: MustHexID("0x1dd9d65c4552b5eb43d5ad55a2ee3f56c6cbc1c64a5c8d659f51fcd51bace24351232b8d7821617d2b29b54b81cdefb9b3e9c37d7fd5f63270bcc9e1a6f6a439"), |
||||
IP: net.ParseIP("127.0.0.1"), |
||||
DiscPort: 223344, |
||||
TCPPort: 52150, |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
func TestParseNode(t *testing.T) { |
||||
for i, test := range parseNodeTests { |
||||
n, err := ParseNode(test.rawurl) |
||||
if err == nil && test.wantError != "" { |
||||
t.Errorf("test %d: got nil error, expected %#q", i, test.wantError) |
||||
continue |
||||
} |
||||
if err != nil && err.Error() != test.wantError { |
||||
t.Errorf("test %d: got error %#q, expected %#q", i, err.Error(), test.wantError) |
||||
continue |
||||
} |
||||
if !reflect.DeepEqual(n, test.wantResult) { |
||||
t.Errorf("test %d: result mismatch:\ngot: %#v, want: %#v", i, n, test.wantResult) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestNodeString(t *testing.T) { |
||||
for i, test := range parseNodeTests { |
||||
if test.wantError != "" { |
||||
continue |
||||
} |
||||
str := test.wantResult.String() |
||||
if str != test.rawurl { |
||||
t.Errorf("test %d: Node.String() mismatch:\ngot: %s\nwant: %s", i, str, test.rawurl) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func TestHexID(t *testing.T) { |
||||
ref := NodeID{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, 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 := MustHexID("0x000000000000000000000000000000000000000000000000000000000000000000000000000000806ad9b61fa5ae014307ebdc964253adcd9f2c0a392aa11abc") |
||||
id2 := MustHexID("000000000000000000000000000000000000000000000000000000000000000000000000000000806ad9b61fa5ae014307ebdc964253adcd9f2c0a392aa11abc") |
||||
|
||||
if id1 != ref { |
||||
t.Errorf("wrong id1\ngot %v\nwant %v", id1[:], ref[:]) |
||||
} |
||||
if id2 != ref { |
||||
t.Errorf("wrong id2\ngot %v\nwant %v", id2[:], ref[:]) |
||||
} |
||||
} |
||||
|
||||
func TestNodeID_recover(t *testing.T) { |
||||
prv := newkey() |
||||
hash := make([]byte, 32) |
||||
sig, err := crypto.Sign(hash, prv) |
||||
if err != nil { |
||||
t.Fatalf("signing error: %v", err) |
||||
} |
||||
|
||||
pub := PubkeyID(&prv.PublicKey) |
||||
recpub, err := recoverNodeID(hash, sig) |
||||
if err != nil { |
||||
t.Fatalf("recovery error: %v", err) |
||||
} |
||||
if pub != recpub { |
||||
t.Errorf("recovered wrong pubkey:\ngot: %v\nwant: %v", recpub, pub) |
||||
} |
||||
} |
||||
|
||||
func TestNodeID_distcmp(t *testing.T) { |
||||
distcmpBig := func(target, a, b NodeID) int { |
||||
tbig := new(big.Int).SetBytes(target[:]) |
||||
abig := new(big.Int).SetBytes(a[:]) |
||||
bbig := new(big.Int).SetBytes(b[:]) |
||||
return new(big.Int).Xor(tbig, abig).Cmp(new(big.Int).Xor(tbig, bbig)) |
||||
} |
||||
if err := quick.CheckEqual(distcmp, distcmpBig, quickcfg); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
// the random tests is likely to miss the case where they're equal.
|
||||
func TestNodeID_distcmpEqual(t *testing.T) { |
||||
base := NodeID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15} |
||||
x := NodeID{15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0} |
||||
if distcmp(base, x, x) != 0 { |
||||
t.Errorf("distcmp(base, x, x) != 0") |
||||
} |
||||
} |
||||
|
||||
func TestNodeID_logdist(t *testing.T) { |
||||
logdistBig := func(a, b NodeID) int { |
||||
abig, bbig := new(big.Int).SetBytes(a[:]), new(big.Int).SetBytes(b[:]) |
||||
return new(big.Int).Xor(abig, bbig).BitLen() |
||||
} |
||||
if err := quick.CheckEqual(logdist, logdistBig, quickcfg); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
// the random tests is likely to miss the case where they're equal.
|
||||
func TestNodeID_logdistEqual(t *testing.T) { |
||||
x := NodeID{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15} |
||||
if logdist(x, x) != 0 { |
||||
t.Errorf("logdist(x, x) != 0") |
||||
} |
||||
} |
||||
|
||||
func TestNodeID_randomID(t *testing.T) { |
||||
// we don't use quick.Check here because its output isn't
|
||||
// very helpful when the test fails.
|
||||
for i := 0; i < quickcfg.MaxCount; i++ { |
||||
a := gen(NodeID{}, quickrand).(NodeID) |
||||
dist := quickrand.Intn(len(NodeID{}) * 8) |
||||
result := randomID(a, dist) |
||||
actualdist := logdist(result, a) |
||||
|
||||
if dist != actualdist { |
||||
t.Log("a: ", a) |
||||
t.Log("result:", result) |
||||
t.Fatalf("#%d: distance of result is %d, want %d", i, actualdist, dist) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (NodeID) Generate(rand *rand.Rand, size int) reflect.Value { |
||||
var id NodeID |
||||
m := rand.Intn(len(id)) |
||||
for i := len(id) - 1; i > m; i-- { |
||||
id[i] = byte(rand.Uint32()) |
||||
} |
||||
return reflect.ValueOf(id) |
||||
} |
||||
Loading…
Reference in new issue