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