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  }