github.com/Blockdaemon/celo-blockchain@v0.0.0-20200129231733-e667f6b08419/whisper/whisperv6/peer_test.go (about) 1 // Copyright 2016 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package whisperv6 18 19 import ( 20 "bytes" 21 "crypto/ecdsa" 22 "fmt" 23 mrand "math/rand" 24 "net" 25 "sync" 26 "sync/atomic" 27 "testing" 28 "time" 29 30 "github.com/ethereum/go-ethereum/common" 31 "github.com/ethereum/go-ethereum/common/hexutil" 32 "github.com/ethereum/go-ethereum/crypto" 33 "github.com/ethereum/go-ethereum/p2p" 34 "github.com/ethereum/go-ethereum/p2p/enode" 35 "github.com/ethereum/go-ethereum/p2p/nat" 36 "github.com/ethereum/go-ethereum/rlp" 37 ) 38 39 var keys = []string{ 40 "d49dcf37238dc8a7aac57dc61b9fee68f0a97f062968978b9fafa7d1033d03a9", 41 "73fd6143c48e80ed3c56ea159fe7494a0b6b393a392227b422f4c3e8f1b54f98", 42 "119dd32adb1daa7a4c7bf77f847fb28730785aa92947edf42fdd997b54de40dc", 43 "deeda8709dea935bb772248a3144dea449ffcc13e8e5a1fd4ef20ce4e9c87837", 44 "5bd208a079633befa349441bdfdc4d85ba9bd56081525008380a63ac38a407cf", 45 "1d27fb4912002d58a2a42a50c97edb05c1b3dffc665dbaa42df1fe8d3d95c9b5", 46 "15def52800c9d6b8ca6f3066b7767a76afc7b611786c1276165fbc61636afb68", 47 "51be6ab4b2dc89f251ff2ace10f3c1cc65d6855f3e083f91f6ff8efdfd28b48c", 48 "ef1ef7441bf3c6419b162f05da6037474664f198b58db7315a6f4de52414b4a0", 49 "09bdf6985aabc696dc1fbeb5381aebd7a6421727343872eb2fadfc6d82486fd9", 50 "15d811bf2e01f99a224cdc91d0cf76cea08e8c67905c16fee9725c9be71185c4", 51 "2f83e45cf1baaea779789f755b7da72d8857aeebff19362dd9af31d3c9d14620", 52 "73f04e34ac6532b19c2aae8f8e52f38df1ac8f5cd10369f92325b9b0494b0590", 53 "1e2e07b69e5025537fb73770f483dc8d64f84ae3403775ef61cd36e3faf162c1", 54 "8963d9bbb3911aac6d30388c786756b1c423c4fbbc95d1f96ddbddf39809e43a", 55 "0422da85abc48249270b45d8de38a4cc3c02032ede1fcf0864a51092d58a2f1f", 56 "8ae5c15b0e8c7cade201fdc149831aa9b11ff626a7ffd27188886cc108ad0fa8", 57 "acd8f5a71d4aecfcb9ad00d32aa4bcf2a602939b6a9dd071bab443154184f805", 58 "a285a922125a7481600782ad69debfbcdb0316c1e97c267aff29ef50001ec045", 59 "28fd4eee78c6cd4bf78f39f8ab30c32c67c24a6223baa40e6f9c9a0e1de7cef5", 60 "c5cca0c9e6f043b288c6f1aef448ab59132dab3e453671af5d0752961f013fc7", 61 "46df99b051838cb6f8d1b73f232af516886bd8c4d0ee07af9a0a033c391380fd", 62 "c6a06a53cbaadbb432884f36155c8f3244e244881b5ee3e92e974cfa166d793f", 63 "783b90c75c63dc72e2f8d11b6f1b4de54d63825330ec76ee8db34f06b38ea211", 64 "9450038f10ca2c097a8013e5121b36b422b95b04892232f930a29292d9935611", 65 "e215e6246ed1cfdcf7310d4d8cdbe370f0d6a8371e4eb1089e2ae05c0e1bc10f", 66 "487110939ed9d64ebbc1f300adeab358bc58875faf4ca64990fbd7fe03b78f2b", 67 "824a70ea76ac81366da1d4f4ac39de851c8ac49dca456bb3f0a186ceefa269a5", 68 "ba8f34fa40945560d1006a328fe70c42e35cc3d1017e72d26864cd0d1b150f15", 69 "30a5dfcfd144997f428901ea88a43c8d176b19c79dde54cc58eea001aa3d246c", 70 "de59f7183aca39aa245ce66a05245fecfc7e2c75884184b52b27734a4a58efa2", 71 "92629e2ff5f0cb4f5f08fffe0f64492024d36f045b901efb271674b801095c5a", 72 "7184c1701569e3a4c4d2ddce691edd983b81e42e09196d332e1ae2f1e062cff4", 73 } 74 75 type TestData struct { 76 started int64 77 counter [NumNodes]int 78 mutex sync.RWMutex 79 } 80 81 type TestNode struct { 82 shh *Whisper 83 id *ecdsa.PrivateKey 84 server *p2p.Server 85 filerID string 86 } 87 88 const NumNodes = 8 // must not exceed the number of keys (32) 89 90 var result TestData 91 var nodes [NumNodes]*TestNode 92 var sharedKey = hexutil.MustDecode("0x03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd31") 93 var wrongKey = hexutil.MustDecode("0xf91156714d7ec88d3edc1c652c2181dbb3044e8771c683f3b30d33c12b986b11") 94 var sharedTopic = TopicType{0xF, 0x1, 0x2, 0} 95 var wrongTopic = TopicType{0, 0, 0, 0} 96 var expectedMessage = []byte("per aspera ad astra") 97 var unexpectedMessage = []byte("per rectum ad astra") 98 var masterBloomFilter []byte 99 var masterPow = 0.00000001 100 var round = 1 101 var debugMode = false 102 var prevTime time.Time 103 var cntPrev int 104 105 func TestSimulation(t *testing.T) { 106 // create a chain of whisper nodes, 107 // installs the filters with shared (predefined) parameters 108 initialize(t) 109 110 // each node sends one random (not decryptable) message 111 for i := 0; i < NumNodes; i++ { 112 sendMsg(t, false, i) 113 } 114 115 // node #0 sends one expected (decryptable) message 116 sendMsg(t, true, 0) 117 118 // check if each node have received and decrypted exactly one message 119 checkPropagation(t, true) 120 121 // check if Status message was correctly decoded 122 checkBloomFilterExchange(t) 123 checkPowExchange(t) 124 125 // send new pow and bloom exchange messages 126 resetParams(t) 127 128 // node #1 sends one expected (decryptable) message 129 sendMsg(t, true, 1) 130 131 // check if each node (except node #0) have received and decrypted exactly one message 132 checkPropagation(t, false) 133 134 // check if corresponding protocol-level messages were correctly decoded 135 checkPowExchangeForNodeZero(t) 136 checkBloomFilterExchange(t) 137 138 stopServers() 139 } 140 141 func resetParams(t *testing.T) { 142 // change pow only for node zero 143 masterPow = 7777777.0 144 nodes[0].shh.SetMinimumPoW(masterPow) 145 146 // change bloom for all nodes 147 masterBloomFilter = TopicToBloom(sharedTopic) 148 for i := 0; i < NumNodes; i++ { 149 nodes[i].shh.SetBloomFilter(masterBloomFilter) 150 } 151 152 round++ 153 } 154 155 func initBloom(t *testing.T) { 156 masterBloomFilter = make([]byte, BloomFilterSize) 157 _, err := mrand.Read(masterBloomFilter) 158 if err != nil { 159 t.Fatalf("rand failed: %s.", err) 160 } 161 162 msgBloom := TopicToBloom(sharedTopic) 163 masterBloomFilter = addBloom(masterBloomFilter, msgBloom) 164 for i := 0; i < 32; i++ { 165 masterBloomFilter[i] = 0xFF 166 } 167 168 if !BloomFilterMatch(masterBloomFilter, msgBloom) { 169 t.Fatalf("bloom mismatch on initBloom.") 170 } 171 } 172 173 func initialize(t *testing.T) { 174 initBloom(t) 175 176 var err error 177 178 for i := 0; i < NumNodes; i++ { 179 var node TestNode 180 b := make([]byte, BloomFilterSize) 181 copy(b, masterBloomFilter) 182 node.shh = New(&DefaultConfig) 183 node.shh.SetMinimumPoW(masterPow) 184 node.shh.SetBloomFilter(b) 185 if !bytes.Equal(node.shh.BloomFilter(), masterBloomFilter) { 186 t.Fatalf("bloom mismatch on init.") 187 } 188 node.shh.Start(nil) 189 topics := make([]TopicType, 0) 190 topics = append(topics, sharedTopic) 191 f := Filter{KeySym: sharedKey} 192 f.Topics = [][]byte{topics[0][:]} 193 node.filerID, err = node.shh.Subscribe(&f) 194 if err != nil { 195 t.Fatalf("failed to install the filter: %s.", err) 196 } 197 node.id, err = crypto.HexToECDSA(keys[i]) 198 if err != nil { 199 t.Fatalf("failed convert the key: %s.", keys[i]) 200 } 201 name := common.MakeName("whisper-go", "2.0") 202 203 node.server = &p2p.Server{ 204 Config: p2p.Config{ 205 PrivateKey: node.id, 206 MaxPeers: NumNodes/2 + 1, 207 Name: name, 208 Protocols: node.shh.Protocols(), 209 ListenAddr: "127.0.0.1:0", 210 NAT: nat.Any(), 211 }, 212 } 213 214 go startServer(t, node.server) 215 216 nodes[i] = &node 217 } 218 219 waitForServersToStart(t) 220 221 for i := 0; i < NumNodes; i++ { 222 for j := 0; j < i; j++ { 223 peerNodeId := nodes[j].id 224 address, _ := net.ResolveTCPAddr("tcp", nodes[j].server.ListenAddr) 225 peer := enode.NewV4(&peerNodeId.PublicKey, address.IP, address.Port, address.Port) 226 nodes[i].server.AddPeer(peer, p2p.ExplicitStaticPurpose) 227 } 228 } 229 } 230 231 func startServer(t *testing.T, s *p2p.Server) { 232 err := s.Start() 233 if err != nil { 234 t.Fatalf("failed to start the first server. err: %v", err) 235 } 236 237 atomic.AddInt64(&result.started, 1) 238 } 239 240 func stopServers() { 241 for i := 0; i < NumNodes; i++ { 242 n := nodes[i] 243 if n != nil { 244 n.shh.Unsubscribe(n.filerID) 245 n.shh.Stop() 246 n.server.Stop() 247 } 248 } 249 } 250 251 func checkPropagation(t *testing.T, includingNodeZero bool) { 252 if t.Failed() { 253 return 254 } 255 256 prevTime = time.Now() 257 // (cycle * iterations) should not exceed 50 seconds, since TTL=50 258 const cycle = 200 // time in milliseconds 259 const iterations = 250 260 261 first := 0 262 if !includingNodeZero { 263 first = 1 264 } 265 266 for j := 0; j < iterations; j++ { 267 for i := first; i < NumNodes; i++ { 268 f := nodes[i].shh.GetFilter(nodes[i].filerID) 269 if f == nil { 270 t.Fatalf("failed to get filterId %s from node %d, round %d.", nodes[i].filerID, i, round) 271 } 272 273 mail := f.Retrieve() 274 validateMail(t, i, mail) 275 276 if isTestComplete() { 277 checkTestStatus() 278 return 279 } 280 } 281 282 checkTestStatus() 283 time.Sleep(cycle * time.Millisecond) 284 } 285 286 if !includingNodeZero { 287 f := nodes[0].shh.GetFilter(nodes[0].filerID) 288 if f != nil { 289 t.Fatalf("node zero received a message with low PoW.") 290 } 291 } 292 293 t.Fatalf("Test was not complete (%d round): timeout %d seconds. nodes=%v", round, iterations*cycle/1000, nodes) 294 } 295 296 func validateMail(t *testing.T, index int, mail []*ReceivedMessage) { 297 var cnt int 298 for _, m := range mail { 299 if bytes.Equal(m.Payload, expectedMessage) { 300 cnt++ 301 } 302 } 303 304 if cnt == 0 { 305 // no messages received yet: nothing is wrong 306 return 307 } 308 if cnt > 1 { 309 t.Fatalf("node %d received %d.", index, cnt) 310 } 311 312 if cnt == 1 { 313 result.mutex.Lock() 314 defer result.mutex.Unlock() 315 result.counter[index] += cnt 316 if result.counter[index] > 1 { 317 t.Fatalf("node %d accumulated %d.", index, result.counter[index]) 318 } 319 } 320 } 321 322 func checkTestStatus() { 323 var cnt int 324 var arr [NumNodes]int 325 326 for i := 0; i < NumNodes; i++ { 327 arr[i] = nodes[i].server.PeerCount() 328 envelopes := nodes[i].shh.Envelopes() 329 if len(envelopes) >= NumNodes { 330 cnt++ 331 } 332 } 333 334 if debugMode { 335 if cntPrev != cnt { 336 fmt.Printf(" %v \t number of nodes that have received all msgs: %d, number of peers per node: %v \n", 337 time.Since(prevTime), cnt, arr) 338 prevTime = time.Now() 339 cntPrev = cnt 340 } 341 } 342 } 343 344 func isTestComplete() bool { 345 result.mutex.RLock() 346 defer result.mutex.RUnlock() 347 348 for i := 0; i < NumNodes; i++ { 349 if result.counter[i] < 1 { 350 return false 351 } 352 } 353 354 for i := 0; i < NumNodes; i++ { 355 envelopes := nodes[i].shh.Envelopes() 356 if len(envelopes) < NumNodes+1 { 357 return false 358 } 359 } 360 361 return true 362 } 363 364 func sendMsg(t *testing.T, expected bool, id int) { 365 if t.Failed() { 366 return 367 } 368 369 opt := MessageParams{KeySym: sharedKey, Topic: sharedTopic, Payload: expectedMessage, PoW: 0.00000001, WorkTime: 1} 370 if !expected { 371 opt.KeySym = wrongKey 372 opt.Topic = wrongTopic 373 opt.Payload = unexpectedMessage 374 opt.Payload[0] = byte(id) 375 } 376 377 msg, err := NewSentMessage(&opt) 378 if err != nil { 379 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 380 } 381 envelope, err := msg.Wrap(&opt) 382 if err != nil { 383 t.Fatalf("failed to seal message: %s", err) 384 } 385 386 err = nodes[id].shh.Send(envelope) 387 if err != nil { 388 t.Fatalf("failed to send message: %s", err) 389 } 390 } 391 392 func TestPeerBasic(t *testing.T) { 393 InitSingleTest() 394 395 params, err := generateMessageParams() 396 if err != nil { 397 t.Fatalf("failed generateMessageParams with seed %d.", seed) 398 } 399 400 params.PoW = 0.001 401 msg, err := NewSentMessage(params) 402 if err != nil { 403 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 404 } 405 env, err := msg.Wrap(params) 406 if err != nil { 407 t.Fatalf("failed Wrap with seed %d.", seed) 408 } 409 410 p := newPeer(nil, nil, nil) 411 p.mark(env) 412 if !p.marked(env) { 413 t.Fatalf("failed mark with seed %d.", seed) 414 } 415 } 416 417 func checkPowExchangeForNodeZero(t *testing.T) { 418 const iterations = 200 419 for j := 0; j < iterations; j++ { 420 lastCycle := (j == iterations-1) 421 ok := checkPowExchangeForNodeZeroOnce(t, lastCycle) 422 if ok { 423 break 424 } 425 time.Sleep(50 * time.Millisecond) 426 } 427 } 428 429 func checkPowExchangeForNodeZeroOnce(t *testing.T, mustPass bool) bool { 430 cnt := 0 431 for i, node := range nodes { 432 for peer := range node.shh.peers { 433 if peer.peer.ID() == nodes[0].server.Self().ID() { 434 cnt++ 435 if peer.powRequirement != masterPow { 436 if mustPass { 437 t.Fatalf("node %d: failed to set the new pow requirement for node zero.", i) 438 } else { 439 return false 440 } 441 } 442 } 443 } 444 } 445 if cnt == 0 { 446 t.Fatalf("looking for node zero: no matching peers found.") 447 } 448 return true 449 } 450 451 func checkPowExchange(t *testing.T) { 452 for i, node := range nodes { 453 for peer := range node.shh.peers { 454 if peer.peer.ID() != nodes[0].server.Self().ID() { 455 if peer.powRequirement != masterPow { 456 t.Fatalf("node %d: failed to exchange pow requirement in round %d; expected %f, got %f", 457 i, round, masterPow, peer.powRequirement) 458 } 459 } 460 } 461 } 462 } 463 464 func checkBloomFilterExchangeOnce(t *testing.T, mustPass bool) bool { 465 for i, node := range nodes { 466 for peer := range node.shh.peers { 467 peer.bloomMu.Lock() 468 equals := bytes.Equal(peer.bloomFilter, masterBloomFilter) 469 peer.bloomMu.Unlock() 470 if !equals { 471 if mustPass { 472 t.Fatalf("node %d: failed to exchange bloom filter requirement in round %d. \n%x expected \n%x got", 473 i, round, masterBloomFilter, peer.bloomFilter) 474 } else { 475 return false 476 } 477 } 478 } 479 } 480 481 return true 482 } 483 484 func checkBloomFilterExchange(t *testing.T) { 485 const iterations = 200 486 for j := 0; j < iterations; j++ { 487 lastCycle := (j == iterations-1) 488 ok := checkBloomFilterExchangeOnce(t, lastCycle) 489 if ok { 490 break 491 } 492 time.Sleep(50 * time.Millisecond) 493 } 494 } 495 496 func waitForServersToStart(t *testing.T) { 497 const iterations = 200 498 var started int64 499 for j := 0; j < iterations; j++ { 500 time.Sleep(50 * time.Millisecond) 501 started = atomic.LoadInt64(&result.started) 502 if started == NumNodes { 503 return 504 } 505 } 506 t.Fatalf("Failed to start all the servers, running: %d", started) 507 } 508 509 //two generic whisper node handshake 510 func TestPeerHandshakeWithTwoFullNode(t *testing.T) { 511 w1 := Whisper{} 512 p1 := newPeer(&w1, p2p.NewPeer(enode.ID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize), false}}) 513 err := p1.handshake() 514 if err != nil { 515 t.Fatal() 516 } 517 } 518 519 //two generic whisper node handshake. one don't send light flag 520 func TestHandshakeWithOldVersionWithoutLightModeFlag(t *testing.T) { 521 w1 := Whisper{} 522 p1 := newPeer(&w1, p2p.NewPeer(enode.ID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize)}}) 523 err := p1.handshake() 524 if err != nil { 525 t.Fatal() 526 } 527 } 528 529 //two light nodes handshake. restriction disabled 530 func TestTwoLightPeerHandshakeRestrictionOff(t *testing.T) { 531 w1 := Whisper{} 532 w1.settings.Store(restrictConnectionBetweenLightClientsIdx, false) 533 w1.SetLightClientMode(true) 534 p1 := newPeer(&w1, p2p.NewPeer(enode.ID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize), true}}) 535 err := p1.handshake() 536 if err != nil { 537 t.FailNow() 538 } 539 } 540 541 //two light nodes handshake. restriction enabled 542 func TestTwoLightPeerHandshakeError(t *testing.T) { 543 w1 := Whisper{} 544 w1.settings.Store(restrictConnectionBetweenLightClientsIdx, true) 545 w1.SetLightClientMode(true) 546 p1 := newPeer(&w1, p2p.NewPeer(enode.ID{}, "test", []p2p.Cap{}), &rwStub{[]interface{}{ProtocolVersion, uint64(123), make([]byte, BloomFilterSize), true}}) 547 err := p1.handshake() 548 if err == nil { 549 t.FailNow() 550 } 551 } 552 553 type rwStub struct { 554 payload []interface{} 555 } 556 557 func (stub *rwStub) ReadMsg() (p2p.Msg, error) { 558 size, r, err := rlp.EncodeToReader(stub.payload) 559 if err != nil { 560 return p2p.Msg{}, err 561 } 562 return p2p.Msg{Code: statusCode, Size: uint32(size), Payload: r}, nil 563 } 564 565 func (stub *rwStub) WriteMsg(m p2p.Msg) error { 566 return nil 567 }