status-im
/
nim-eth
mirror of https://github.com/status-im/nim-eth.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Allow for discv4 chronos strict usage 

And group p2p tests that can be run with strict usage along the way.
This commit is contained in:
kdeme 2021-04-18 17:10:10 +02:00
parent 0f3bb61678
commit 9fed10de88
No known key found for this signature in database
GPG Key ID: 4E8DD21420AF43F5
10 changed files with 154 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
eth.nimble
View File

@ -49,13 +49,11 @@ task test_discv4, "Run discovery v4 tests":
task test_p2p, "Run p2p tests":
test_discv5_task()
runTest("tests/p2p/all_tests")
# Code that still requires chronosStrict = false
for filename in [
"les/test_flow_control",
"test_auth",
"test_crypt",
"test_discovery",
"test_ecies",
"test_enode",
"test_rlpx_thunk",
"test_shh",
"test_shh_config",

26
eth/p2p/discovery.nim
View File

@ -103,14 +103,14 @@ proc expiration(): uint32 =
# Wire protocol
proc send(d: DiscoveryProtocol, n: Node, data: seq[byte]) =
proc send(d: DiscoveryProtocol, n: Node, data: seq[byte]) {.raises: [Defect].} =
let ta = initTAddress(n.node.address.ip, n.node.address.udpPort)
let f = d.transp.sendTo(ta, data)
f.callback = proc(data: pointer) {.gcsafe.} =
if f.failed:
debug "Discovery send failed", msg = f.readError.msg
proc sendPing*(d: DiscoveryProtocol, n: Node): seq[byte] =
proc sendPing*(d: DiscoveryProtocol, n: Node): seq[byte] {.raises: [Defect].} =
let payload = rlp.encode((PROTO_VERSION, d.address, n.node.address,
expiration()))
let msg = pack(cmdPing, payload, d.privKey)
@ -233,8 +233,8 @@ proc expirationValid(cmdId: CommandId, rlpEncodedPayload: openArray[byte]):
else:
raise newException(DiscProtocolError, "Invalid RLP list for this packet id")
proc receive*(d: DiscoveryProtocol, a: Address, msg: openArray[byte]) {.gcsafe.} =
## Can raise `DiscProtocolError` and all of `RlpError`
proc receive*(d: DiscoveryProtocol, a: Address, msg: openArray[byte])
{.raises: [DiscProtocolError, RlpError, ValueError, Defect].} =
# Note: export only needed for testing
let msgHash = validateMsgHash(msg)
if msgHash.isOk():
@ -260,23 +260,23 @@ proc receive*(d: DiscoveryProtocol, a: Address, msg: openArray[byte]) {.gcsafe.}
else:
notice "Wrong msg mac from ", a
proc processClient(transp: DatagramTransport,
raddr: TransportAddress): Future[void] {.async, gcsafe.} =
proc processClient(transp: DatagramTransport, raddr: TransportAddress):
Future[void] {.async, raises: [Defect].} =
var proto = getUserData[DiscoveryProtocol](transp)
let buf = try: transp.getMessage()
except TransportOsError as e:
# This is likely to be local network connection issues.
warn "Transport getMessage", exception = e.name, msg = e.msg
return
let a = Address(ip: raddr.address, udpPort: raddr.port, tcpPort: raddr.port)
try:
# TODO: Maybe here better to use `peekMessage()` to avoid allocation,
# but `Bytes` object is just a simple seq[byte], and `ByteRange` object
# do not support custom length.
var buf = transp.getMessage()
let a = Address(ip: raddr.address, udpPort: raddr.port, tcpPort: raddr.port)
proto.receive(a, buf)
except RlpError as e:
debug "Receive failed", exc = e.name, err = e.msg
except DiscProtocolError as e:
debug "Receive failed", exc = e.name, err = e.msg
except Exception as e:
except ValueError as e:
debug "Receive failed", exc = e.name, err = e.msg
raise e
proc open*(d: DiscoveryProtocol) =
# TODO allow binding to specific IP / IPv6 / etc

11
eth/p2p/kademlia.nim
View File

@ -26,7 +26,7 @@ type
routing: RoutingTable
pongFutures: Table[seq[byte], Future[bool]]
pingFutures: Table[Node, Future[bool]]
neighboursCallbacks: Table[Node, proc(n: seq[Node]) {.gcsafe.}]
neighboursCallbacks: Table[Node, proc(n: seq[Node]) {.gcsafe, raises: [Defect].}]
rng: ref BrHmacDrbgContext
NodeId* = UInt256
@ -255,7 +255,7 @@ proc updateRoutingTable(k: KademliaProtocol, n: Node) {.gcsafe.} =
# replacement cache.
asyncCheck k.bond(evictionCandidate)
proc doSleep(p: proc() {.gcsafe.}) {.async, gcsafe.} =
proc doSleep(p: proc() {.gcsafe, raises: [Defect].}) {.async, gcsafe.} =
await sleepAsync(REQUEST_TIMEOUT)
p()
@ -276,7 +276,7 @@ proc waitPong(k: KademliaProtocol, n: Node, pingid: seq[byte]): Future[bool] =
k.pongFutures.del(pingid)
fut.complete(false)
proc ping(k: KademliaProtocol, n: Node): seq[byte] =
proc ping(k: KademliaProtocol, n: Node): seq[byte] {.raises: [Defect].} =
doAssert(n != k.thisNode)
result = k.wire.sendPing(n)
@ -290,12 +290,13 @@ proc waitPing(k: KademliaProtocol, n: Node): Future[bool] {.gcsafe.} =
k.pingFutures.del(n)
fut.complete(false)
proc waitNeighbours(k: KademliaProtocol, remote: Node): Future[seq[Node]] =
proc waitNeighbours(k: KademliaProtocol, remote: Node):
Future[seq[Node]] {.raises: [Defect].} =
doAssert(remote notin k.neighboursCallbacks)
result = newFuture[seq[Node]]("waitNeighbours")
let fut = result
var neighbours = newSeqOfCap[Node](BUCKET_SIZE)
k.neighboursCallbacks[remote] = proc(n: seq[Node]) =
k.neighboursCallbacks[remote] = proc(n: seq[Node]) {.gcsafe, raises: [Defect].} =
# This callback is expected to be called multiple times because nodes usually
# split the neighbours replies into multiple packets, so we only complete the
# future event.set() we've received enough neighbours.

6
tests/p2p/all_tests.nim Normal file
View File

@ -0,0 +1,6 @@
import
./test_auth,
./test_crypt,
./test_discovery,
./test_ecies,
./test_enode

13
tests/p2p/p2p_test_helper.nim
View File

@ -10,12 +10,6 @@ proc localAddress*(port: int): Address =
result = Address(udpPort: port, tcpPort: port,
ip: parseIpAddress("127.0.0.1"))
proc startDiscoveryNode*(privKey: PrivateKey, address: Address,
bootnodes: seq[ENode]): Future[DiscoveryProtocol] {.async.} =
result = newDiscoveryProtocol(privKey, address, bootnodes)
result.open()
await result.bootstrap()
proc setupTestNode*(
rng: ref BrHmacDrbgContext,
capabilities: varargs[ProtocolInfo, `protocolInfo`]): EthereumNode {.gcsafe.} =
@ -27,13 +21,6 @@ proc setupTestNode*(
for capability in capabilities:
result.addCapability capability
proc packData*(payload: openArray[byte], pk: PrivateKey): seq[byte] =
let
payloadSeq = @payload
signature = @(pk.sign(payload).toRaw())
msgHash = keccak256.digest(signature & payloadSeq)
result = @(msgHash.data) & signature & payloadSeq
template sourceDir*: string = currentSourcePath.rsplit(DirSep, 1)[0]
proc recvMsgMock*(msg: openArray[byte]): tuple[msgId: int, msgData: Rlp] =

2
tests/p2p/test_auth.nim
View File

@ -7,6 +7,8 @@
# distribution, for details about the copyright.
#
{.used.}
import
std/unittest,
nimcrypto/[utils, keccak],

2
tests/p2p/test_crypt.nim
View File

@ -7,6 +7,8 @@
# distribution, for details about the copyright.
#
{.used.}
import
std/unittest,
nimcrypto/[utils, sysrand, keccak],

216
tests/p2p/test_discovery.nim
View File

@ -7,119 +7,139 @@
# distribution, for details about the copyright.
#
{.used.}
import
std/[sequtils, unittest],
chronos, stew/byteutils,
../../eth/[keys, rlp], ../../eth/p2p/[discovery, kademlia, enode],
./p2p_test_helper
std/sequtils,
chronos, stew/byteutils, nimcrypto, testutils/unittests,
../../eth/keys, ../../eth/p2p/[discovery, kademlia, enode]
proc localAddress(port: int): Address =
let port = Port(port)
result = Address(udpPort: port, tcpPort: port,
ip: parseIpAddress("127.0.0.1"))
proc initDiscoveryNode(privKey: PrivateKey, address: Address,
bootnodes: seq[ENode]): DiscoveryProtocol =
let node = newDiscoveryProtocol(privKey, address, bootnodes)
node.open()
return node
proc packData(payload: openArray[byte], pk: PrivateKey): seq[byte] =
let
payloadSeq = @payload
signature = @(pk.sign(payload).toRaw())
msgHash = keccak256.digest(signature & payloadSeq)
result = @(msgHash.data) & signature & payloadSeq
proc nodeIdInNodes(id: NodeId, nodes: openarray[Node]): bool =
for n in nodes:
if id == n.id: return true
proc test() {.async.} =
suite "Discovery Tests":
procSuite "Discovery Tests":
let
bootNodeKey = PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a617")[]
bootNodeAddr = localAddress(20301)
bootENode = ENode(pubkey: bootNodeKey.toPublicKey(), address: bootNodeAddr)
bootNode = initDiscoveryNode(bootNodeKey, bootNodeAddr, @[])
waitFor bootNode.bootstrap()
asyncTest "Discover nodes":
let nodeKeys = [
PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a618")[],
PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a619")[],
PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a620")[]
]
var nodes: seq[DiscoveryProtocol]
for i in 0..<nodeKeys.len:
let node = initDiscoveryNode(nodeKeys[i], localAddress(20302 + i),
@[bootENode])
nodes.add(node)
await allFutures(nodes.mapIt(it.bootstrap()))
nodes.add(bootNode)
for i in nodes:
for j in nodes:
if j != i:
check(nodeIdInNodes(i.thisNode.id, j.randomNodes(nodes.len - 1)))
test "Test Vectors":
# These are the test vectors from EIP-8:
# https://github.com/ethereum/EIPs/blob/master/EIPS/eip-8.md#rlpx-discovery-protocol
# However they are unpacked and the expiration is changed from 0x43b9a355
# to 0x6fd3aed7 so that they remain valid for a while
let validProtocolData = [
# ping packet with version 4, additional list elements
"01ec04cb847f000001820cfa8215a8d790000000000000000000000000000000018208ae820d05846fd3aed70102",
# ping packet with version 555, additional list elements and additional random data
"01f83e82022bd79020010db83c4d001500000000abcdef12820cfa8215a8d79020010db885a308d313198a2e037073488208ae82823a846fd3aed7c5010203040531b9019afde696e582a78fa8d95ea13ce3297d4afb8ba6433e4154caa5ac6431af1b80ba76023fa4090c408f6b4bc3701562c031041d4702971d102c9ab7fa5eed4cd6bab8f7af956f7d565ee1917084a95398b6a21eac920fe3dd1345ec0a7ef39367ee69ddf092cbfe5b93e5e568ebc491983c09c76d922dc3",
# pong packet with additional list elements and additional random data
"02f846d79020010db885a308d313198a2e037073488208ae82823aa0fbc914b16819237dcd8801d7e53f69e9719adecb3cc0e790c57e91ca4461c954846fd3aed7c6010203c2040506a0c969a58f6f9095004c0177a6b47f451530cab38966a25cca5cb58f055542124e",
# findnode packet with additional list elements and additional random data
"03f84eb840ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31387574077f301b421bc84df7266c44e9e6d569fc56be00812904767bf5ccd1fc7f846fd3aed782999983999999280dc62cc8255c73471e0a61da0c89acdc0e035e260add7fc0c04ad9ebf3919644c91cb247affc82b69bd2ca235c71eab8e49737c937a2c396",
# neighbours packet with additional list elements and additional random data
"04f9015bf90150f84d846321163782115c82115db8403155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32f84984010203040101b840312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069dbf8599020010db83c4d001500000000abcdef12820d05820d05b84038643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aacf8599020010db885a308d313198a2e037073488203e78203e8b8408dcab8618c3253b558d459da53bd8fa68935a719aff8b811197101a4b2b47dd2d47295286fc00cc081bb542d760717d1bdd6bec2c37cd72eca367d6dd3b9df73846fd3aed7010203b525a138aa34383fec3d2719a0",
]
let
bootNodeKey = PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a617")[]
bootNodeAddr = localAddress(20301)
bootENode = ENode(pubkey: bootNodeKey.toPublicKey(), address: bootNodeAddr)
bootNode = await startDiscoveryNode(bootNodeKey, bootNodeAddr, @[])
address = localAddress(20302)
nodeKey = PrivateKey.fromHex(
"b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")[]
test "Discover nodes":
let nodeKeys = [
PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a618")[],
PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a619")[],
PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a620")[]
]
var nodeAddrs = newSeqOfCap[Address](nodeKeys.len)
for i in 0 ..< nodeKeys.len: nodeAddrs.add(localAddress(20302 + i))
for data in validProtocolData:
# none of these may raise
bootNode.receive(address, packData(hexToSeqByte(data), nodeKey))
var nodes = await all(zip(nodeKeys, nodeAddrs).mapIt(
startDiscoveryNode(it[0], it[1], @[bootENode]))
)
nodes.add(bootNode)
test "Invalid protocol data":
let invalidProtocolData = [
"0x00", # invalid msg id
"0x01", # empty payload
"0x03b8", # no list but string
"0x01C0", # empty list
# FindNode target that is 1 byte too long
# We currently do not raise on this, so can't really test it
# "0x03f847b841AA0000000000000000000000000000000000000000000000000000000000000000a99a96bd988e1839272f93257bd9dfb2e558390e1f9bff28cdc8f04c9b5d06b1846fd3aed7",
]
let
address = localAddress(20302)
nodeKey = PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a618")[]
for i in nodes:
for j in nodes:
if j != i:
check(nodeIdInNodes(i.thisNode.id, j.randomNodes(nodes.len - 1)))
test "Test Vectors":
# These are the test vectors from EIP-8:
# https://github.com/ethereum/EIPs/blob/master/EIPS/eip-8.md#rlpx-discovery-protocol
# However they are unpacked and the expiration is changed from 0x43b9a355
# to 0x6fd3aed7 so that they remain valid for a while
let validProtocolData = [
# ping packet with version 4, additional list elements
"01ec04cb847f000001820cfa8215a8d790000000000000000000000000000000018208ae820d05846fd3aed70102",
# ping packet with version 555, additional list elements and additional random data
"01f83e82022bd79020010db83c4d001500000000abcdef12820cfa8215a8d79020010db885a308d313198a2e037073488208ae82823a846fd3aed7c5010203040531b9019afde696e582a78fa8d95ea13ce3297d4afb8ba6433e4154caa5ac6431af1b80ba76023fa4090c408f6b4bc3701562c031041d4702971d102c9ab7fa5eed4cd6bab8f7af956f7d565ee1917084a95398b6a21eac920fe3dd1345ec0a7ef39367ee69ddf092cbfe5b93e5e568ebc491983c09c76d922dc3",
# pong packet with additional list elements and additional random data
"02f846d79020010db885a308d313198a2e037073488208ae82823aa0fbc914b16819237dcd8801d7e53f69e9719adecb3cc0e790c57e91ca4461c954846fd3aed7c6010203c2040506a0c969a58f6f9095004c0177a6b47f451530cab38966a25cca5cb58f055542124e",
# findnode packet with additional list elements and additional random data
"03f84eb840ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31387574077f301b421bc84df7266c44e9e6d569fc56be00812904767bf5ccd1fc7f846fd3aed782999983999999280dc62cc8255c73471e0a61da0c89acdc0e035e260add7fc0c04ad9ebf3919644c91cb247affc82b69bd2ca235c71eab8e49737c937a2c396",
# neighbours packet with additional list elements and additional random data
"04f9015bf90150f84d846321163782115c82115db8403155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32f84984010203040101b840312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069dbf8599020010db83c4d001500000000abcdef12820d05820d05b84038643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aacf8599020010db885a308d313198a2e037073488203e78203e8b8408dcab8618c3253b558d459da53bd8fa68935a719aff8b811197101a4b2b47dd2d47295286fc00cc081bb542d760717d1bdd6bec2c37cd72eca367d6dd3b9df73846fd3aed7010203b525a138aa34383fec3d2719a0",
]
let
address = localAddress(20302)
nodeKey = PrivateKey.fromHex(
"b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")[]
for data in validProtocolData:
# none of these may raise
for data in invalidProtocolData:
expect DiscProtocolError:
bootNode.receive(address, packData(hexToSeqByte(data), nodeKey))
test "Invalid protocol data":
let invalidProtocolData = [
"0x00", # invalid msg id
"0x01", # empty payload
"0x03b8", # no list but string
"0x01C0", # empty list
# FindNode target that is 1 byte too long
# We currently do not raise on this, so can't really test it
# "0x03f847b841AA0000000000000000000000000000000000000000000000000000000000000000a99a96bd988e1839272f93257bd9dfb2e558390e1f9bff28cdc8f04c9b5d06b1846fd3aed7",
]
let
address = localAddress(20302)
nodeKey = PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a618")[]
# empty msg id and payload, doesn't raise, just fails and prints wrong
# msg mac
bootNode.receive(address, packData(@[], nodeKey))
for data in invalidProtocolData:
expect DiscProtocolError:
bootNode.receive(address, packData(hexToSeqByte(data), nodeKey))
asyncTest "Two findNode calls for the same peer in rapid succession":
let targetKey = PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a618")[]
let peerKey = PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a619")[]
# empty msg id and payload, doesn't raise, just fails and prints wrong
# msg mac
bootNode.receive(address, packData(@[], nodeKey))
let targetNodeId = kademlia.toNodeId(targetKey.toPublicKey)
let peerNode = kademlia.newNode(peerKey.toPublicKey, localAddress(20302))
let nodesSeen = new(HashSet[Node])
test "Two findNode calls for the same peer in rapid succession":
let targetKey = PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a618")[]
let peerKey = PrivateKey.fromHex(
"a2b50376a79b1a8c8a3296485572bdfbf54708bb46d3c25d73d2723aaaf6a619")[]
# Start `findNode` but don't `await` yet, so the reply can't be processed yet.
let neighbours1Future = bootNode.kademlia.findNode(nodesSeen, targetNodeId, peerNode)
let targetNodeId = kademlia.toNodeId(targetKey.toPublicKey)
let peerNode = kademlia.newNode(peerKey.toPublicKey, localAddress(20302))
let nodesSeen = new(HashSet[Node])
# This will raise an assertion error if `findNode` doesn't check for and ignore
# this second call to the same target and peer in rapid successfion.
let neighbours2Future = bootNode.kademlia.findNode(nodesSeen, targetNodeId, peerNode)
# Start `findNode` but don't `await` yet, so the reply can't be processed yet.
let neighbours1Future = bootNode.kademlia.findNode(nodesSeen, targetNodeId, peerNode)
# Just for completness, verify the result is empty from the second call.
let neighbours2 = await neighbours2Future
check(neighbours2.len == 0)
# This will raise an assertion error if `findNode` doesn't check for and ignore
# this second call to the same target and peer in rapid successfion.
let neighbours2Future = bootNode.kademlia.findNode(nodesSeen, targetNodeId, peerNode)
# Just for completness, verify the result is empty from the second call.
let neighbours2 = await neighbours2Future
check(neighbours2.len == 0)
# Just for completeness, wait for the first result out of order.
# Max delay 5 seconds.
discard await neighbours1Future
waitFor test()
# Just for completeness, wait for the first result out of order.
# Max delay 5 seconds.
discard await neighbours1Future

2
tests/p2p/test_ecies.nim
View File

@ -7,6 +7,8 @@
# distribution, for details about the copyright.
#
{.used.}
import
std/unittest,
nimcrypto/[utils, sha2, hmac, rijndael],

2
tests/p2p/test_enode.nim
View File

@ -7,6 +7,8 @@
# Apache License, version 2.0, (LICENSE-APACHEv2)
# MIT license (LICENSE-MIT)
{.used.}
import
std/[unittest, net, options],
../../eth/p2p/enode