github.com/yinchengtsinghua/golang-Eos-dpos-Ethereum@v0.0.0-20190121132951-92cc4225ed8e/whisper/whisperv5/whisper_test.go (about)

     1  
     2  //此源码被清华学神尹成大魔王专业翻译分析并修改
     3  //尹成QQ77025077
     4  //尹成微信18510341407
     5  //尹成所在QQ群721929980
     6  //尹成邮箱 yinc13@mails.tsinghua.edu.cn
     7  //尹成毕业于清华大学,微软区块链领域全球最有价值专家
     8  //https://mvp.microsoft.com/zh-cn/PublicProfile/4033620
     9  //
    10  //
    11  //
    12  //
    13  //
    14  //
    15  //
    16  //
    17  //
    18  //
    19  //
    20  //
    21  //
    22  //
    23  //
    24  
    25  package whisperv5
    26  
    27  import (
    28  	"bytes"
    29  	"crypto/ecdsa"
    30  	mrand "math/rand"
    31  	"testing"
    32  	"time"
    33  
    34  	"github.com/ethereum/go-ethereum/common"
    35  )
    36  
    37  func TestWhisperBasic(t *testing.T) {
    38  	w := New(&DefaultConfig)
    39  	p := w.Protocols()
    40  	shh := p[0]
    41  	if shh.Name != ProtocolName {
    42  		t.Fatalf("failed Protocol Name: %v.", shh.Name)
    43  	}
    44  	if uint64(shh.Version) != ProtocolVersion {
    45  		t.Fatalf("failed Protocol Version: %v.", shh.Version)
    46  	}
    47  	if shh.Length != NumberOfMessageCodes {
    48  		t.Fatalf("failed Protocol Length: %v.", shh.Length)
    49  	}
    50  	if shh.Run == nil {
    51  		t.Fatalf("failed shh.Run.")
    52  	}
    53  	if uint64(w.Version()) != ProtocolVersion {
    54  		t.Fatalf("failed whisper Version: %v.", shh.Version)
    55  	}
    56  	if w.GetFilter("non-existent") != nil {
    57  		t.Fatalf("failed GetFilter.")
    58  	}
    59  
    60  	peerID := make([]byte, 64)
    61  	mrand.Read(peerID)
    62  	peer, _ := w.getPeer(peerID)
    63  	if peer != nil {
    64  		t.Fatal("found peer for random key.")
    65  	}
    66  	if err := w.AllowP2PMessagesFromPeer(peerID); err == nil {
    67  		t.Fatalf("failed MarkPeerTrusted.")
    68  	}
    69  	exist := w.HasSymKey("non-existing")
    70  	if exist {
    71  		t.Fatalf("failed HasSymKey.")
    72  	}
    73  	key, err := w.GetSymKey("non-existing")
    74  	if err == nil {
    75  		t.Fatalf("failed GetSymKey(non-existing): false positive.")
    76  	}
    77  	if key != nil {
    78  		t.Fatalf("failed GetSymKey: false positive.")
    79  	}
    80  	mail := w.Envelopes()
    81  	if len(mail) != 0 {
    82  		t.Fatalf("failed w.Envelopes().")
    83  	}
    84  	m := w.Messages("non-existent")
    85  	if len(m) != 0 {
    86  		t.Fatalf("failed w.Messages.")
    87  	}
    88  
    89  	var derived []byte
    90  	ver := uint64(0xDEADBEEF)
    91  	if _, err := deriveKeyMaterial(peerID, ver); err != unknownVersionError(ver) {
    92  		t.Fatalf("failed deriveKeyMaterial with param = %v: %s.", peerID, err)
    93  	}
    94  	derived, err = deriveKeyMaterial(peerID, 0)
    95  	if err != nil {
    96  		t.Fatalf("failed second deriveKeyMaterial with param = %v: %s.", peerID, err)
    97  	}
    98  	if !validateSymmetricKey(derived) {
    99  		t.Fatalf("failed validateSymmetricKey with param = %v.", derived)
   100  	}
   101  	if containsOnlyZeros(derived) {
   102  		t.Fatalf("failed containsOnlyZeros with param = %v.", derived)
   103  	}
   104  
   105  	buf := []byte{0xFF, 0xE5, 0x80, 0x2, 0}
   106  	le := bytesToUintLittleEndian(buf)
   107  	be := BytesToUintBigEndian(buf)
   108  	if le != uint64(0x280e5ff) {
   109  		t.Fatalf("failed bytesToIntLittleEndian: %d.", le)
   110  	}
   111  	if be != uint64(0xffe5800200) {
   112  		t.Fatalf("failed BytesToIntBigEndian: %d.", be)
   113  	}
   114  
   115  	id, err := w.NewKeyPair()
   116  	if err != nil {
   117  		t.Fatalf("failed to generate new key pair: %s.", err)
   118  	}
   119  	pk, err := w.GetPrivateKey(id)
   120  	if err != nil {
   121  		t.Fatalf("failed to retrieve new key pair: %s.", err)
   122  	}
   123  	if !validatePrivateKey(pk) {
   124  		t.Fatalf("failed validatePrivateKey: %v.", pk)
   125  	}
   126  	if !ValidatePublicKey(&pk.PublicKey) {
   127  		t.Fatalf("failed ValidatePublicKey: %v.", pk)
   128  	}
   129  }
   130  
   131  func TestWhisperAsymmetricKeyImport(t *testing.T) {
   132  	var (
   133  		w           = New(&DefaultConfig)
   134  		privateKeys []*ecdsa.PrivateKey
   135  	)
   136  
   137  	for i := 0; i < 50; i++ {
   138  		id, err := w.NewKeyPair()
   139  		if err != nil {
   140  			t.Fatalf("could not generate key: %v", err)
   141  		}
   142  
   143  		pk, err := w.GetPrivateKey(id)
   144  		if err != nil {
   145  			t.Fatalf("could not export private key: %v", err)
   146  		}
   147  
   148  		privateKeys = append(privateKeys, pk)
   149  
   150  		if !w.DeleteKeyPair(id) {
   151  			t.Fatalf("could not delete private key")
   152  		}
   153  	}
   154  
   155  	for _, pk := range privateKeys {
   156  		if _, err := w.AddKeyPair(pk); err != nil {
   157  			t.Fatalf("could not import private key: %v", err)
   158  		}
   159  	}
   160  }
   161  
   162  func TestWhisperIdentityManagement(t *testing.T) {
   163  	w := New(&DefaultConfig)
   164  	id1, err := w.NewKeyPair()
   165  	if err != nil {
   166  		t.Fatalf("failed to generate new key pair: %s.", err)
   167  	}
   168  	id2, err := w.NewKeyPair()
   169  	if err != nil {
   170  		t.Fatalf("failed to generate new key pair: %s.", err)
   171  	}
   172  	pk1, err := w.GetPrivateKey(id1)
   173  	if err != nil {
   174  		t.Fatalf("failed to retrieve the key pair: %s.", err)
   175  	}
   176  	pk2, err := w.GetPrivateKey(id2)
   177  	if err != nil {
   178  		t.Fatalf("failed to retrieve the key pair: %s.", err)
   179  	}
   180  
   181  	if !w.HasKeyPair(id1) {
   182  		t.Fatalf("failed HasIdentity(pk1).")
   183  	}
   184  	if !w.HasKeyPair(id2) {
   185  		t.Fatalf("failed HasIdentity(pk2).")
   186  	}
   187  	if pk1 == nil {
   188  		t.Fatalf("failed GetIdentity(pk1).")
   189  	}
   190  	if pk2 == nil {
   191  		t.Fatalf("failed GetIdentity(pk2).")
   192  	}
   193  
   194  	if !validatePrivateKey(pk1) {
   195  		t.Fatalf("pk1 is invalid.")
   196  	}
   197  	if !validatePrivateKey(pk2) {
   198  		t.Fatalf("pk2 is invalid.")
   199  	}
   200  
   201  //
   202  	done := w.DeleteKeyPair(id1)
   203  	if !done {
   204  		t.Fatalf("failed to delete id1.")
   205  	}
   206  	pk1, err = w.GetPrivateKey(id1)
   207  	if err == nil {
   208  		t.Fatalf("retrieve the key pair: false positive.")
   209  	}
   210  	pk2, err = w.GetPrivateKey(id2)
   211  	if err != nil {
   212  		t.Fatalf("failed to retrieve the key pair: %s.", err)
   213  	}
   214  	if w.HasKeyPair(id1) {
   215  		t.Fatalf("failed DeleteIdentity(pub1): still exist.")
   216  	}
   217  	if !w.HasKeyPair(id2) {
   218  		t.Fatalf("failed DeleteIdentity(pub1): pub2 does not exist.")
   219  	}
   220  	if pk1 != nil {
   221  		t.Fatalf("failed DeleteIdentity(pub1): first key still exist.")
   222  	}
   223  	if pk2 == nil {
   224  		t.Fatalf("failed DeleteIdentity(pub1): second key does not exist.")
   225  	}
   226  
   227  //
   228  	done = w.DeleteKeyPair(id1)
   229  	if done {
   230  		t.Fatalf("delete id1: false positive.")
   231  	}
   232  	pk1, err = w.GetPrivateKey(id1)
   233  	if err == nil {
   234  		t.Fatalf("retrieve the key pair: false positive.")
   235  	}
   236  	pk2, err = w.GetPrivateKey(id2)
   237  	if err != nil {
   238  		t.Fatalf("failed to retrieve the key pair: %s.", err)
   239  	}
   240  	if w.HasKeyPair(id1) {
   241  		t.Fatalf("failed delete non-existing identity: exist.")
   242  	}
   243  	if !w.HasKeyPair(id2) {
   244  		t.Fatalf("failed delete non-existing identity: pub2 does not exist.")
   245  	}
   246  	if pk1 != nil {
   247  		t.Fatalf("failed delete non-existing identity: first key exist.")
   248  	}
   249  	if pk2 == nil {
   250  		t.Fatalf("failed delete non-existing identity: second key does not exist.")
   251  	}
   252  
   253  //
   254  	done = w.DeleteKeyPair(id2)
   255  	if !done {
   256  		t.Fatalf("failed to delete id2.")
   257  	}
   258  	pk1, err = w.GetPrivateKey(id1)
   259  	if err == nil {
   260  		t.Fatalf("retrieve the key pair: false positive.")
   261  	}
   262  	pk2, err = w.GetPrivateKey(id2)
   263  	if err == nil {
   264  		t.Fatalf("retrieve the key pair: false positive.")
   265  	}
   266  	if w.HasKeyPair(id1) {
   267  		t.Fatalf("failed delete second identity: first identity exist.")
   268  	}
   269  	if w.HasKeyPair(id2) {
   270  		t.Fatalf("failed delete second identity: still exist.")
   271  	}
   272  	if pk1 != nil {
   273  		t.Fatalf("failed delete second identity: first key exist.")
   274  	}
   275  	if pk2 != nil {
   276  		t.Fatalf("failed delete second identity: second key exist.")
   277  	}
   278  }
   279  
   280  func TestWhisperSymKeyManagement(t *testing.T) {
   281  	InitSingleTest()
   282  
   283  	var err error
   284  	var k1, k2 []byte
   285  	w := New(&DefaultConfig)
   286  	id1 := string("arbitrary-string-1")
   287  	id2 := string("arbitrary-string-2")
   288  
   289  	id1, err = w.GenerateSymKey()
   290  	if err != nil {
   291  		t.Fatalf("failed GenerateSymKey with seed %d: %s.", seed, err)
   292  	}
   293  
   294  	k1, err = w.GetSymKey(id1)
   295  	if err != nil {
   296  		t.Fatalf("failed GetSymKey(id1).")
   297  	}
   298  	k2, err = w.GetSymKey(id2)
   299  	if err == nil {
   300  		t.Fatalf("failed GetSymKey(id2): false positive.")
   301  	}
   302  	if !w.HasSymKey(id1) {
   303  		t.Fatalf("failed HasSymKey(id1).")
   304  	}
   305  	if w.HasSymKey(id2) {
   306  		t.Fatalf("failed HasSymKey(id2): false positive.")
   307  	}
   308  	if k1 == nil {
   309  		t.Fatalf("first key does not exist.")
   310  	}
   311  	if k2 != nil {
   312  		t.Fatalf("second key still exist.")
   313  	}
   314  
   315  //
   316  	randomKey := make([]byte, aesKeyLength)
   317  	mrand.Read(randomKey)
   318  	id1, err = w.AddSymKeyDirect(randomKey)
   319  	if err != nil {
   320  		t.Fatalf("failed AddSymKey with seed %d: %s.", seed, err)
   321  	}
   322  
   323  	k1, err = w.GetSymKey(id1)
   324  	if err != nil {
   325  		t.Fatalf("failed w.GetSymKey(id1).")
   326  	}
   327  	k2, err = w.GetSymKey(id2)
   328  	if err == nil {
   329  		t.Fatalf("failed w.GetSymKey(id2): false positive.")
   330  	}
   331  	if !w.HasSymKey(id1) {
   332  		t.Fatalf("failed w.HasSymKey(id1).")
   333  	}
   334  	if w.HasSymKey(id2) {
   335  		t.Fatalf("failed w.HasSymKey(id2): false positive.")
   336  	}
   337  	if k1 == nil {
   338  		t.Fatalf("first key does not exist.")
   339  	}
   340  	if !bytes.Equal(k1, randomKey) {
   341  		t.Fatalf("k1 != randomKey.")
   342  	}
   343  	if k2 != nil {
   344  		t.Fatalf("second key already exist.")
   345  	}
   346  
   347  	id2, err = w.AddSymKeyDirect(randomKey)
   348  	if err != nil {
   349  		t.Fatalf("failed AddSymKey(id2) with seed %d: %s.", seed, err)
   350  	}
   351  	k1, err = w.GetSymKey(id1)
   352  	if err != nil {
   353  		t.Fatalf("failed w.GetSymKey(id1).")
   354  	}
   355  	k2, err = w.GetSymKey(id2)
   356  	if err != nil {
   357  		t.Fatalf("failed w.GetSymKey(id2).")
   358  	}
   359  	if !w.HasSymKey(id1) {
   360  		t.Fatalf("HasSymKey(id1) failed.")
   361  	}
   362  	if !w.HasSymKey(id2) {
   363  		t.Fatalf("HasSymKey(id2) failed.")
   364  	}
   365  	if k1 == nil {
   366  		t.Fatalf("k1 does not exist.")
   367  	}
   368  	if k2 == nil {
   369  		t.Fatalf("k2 does not exist.")
   370  	}
   371  	if !bytes.Equal(k1, k2) {
   372  		t.Fatalf("k1 != k2.")
   373  	}
   374  	if !bytes.Equal(k1, randomKey) {
   375  		t.Fatalf("k1 != randomKey.")
   376  	}
   377  	if len(k1) != aesKeyLength {
   378  		t.Fatalf("wrong length of k1.")
   379  	}
   380  	if len(k2) != aesKeyLength {
   381  		t.Fatalf("wrong length of k2.")
   382  	}
   383  
   384  	w.DeleteSymKey(id1)
   385  	k1, err = w.GetSymKey(id1)
   386  	if err == nil {
   387  		t.Fatalf("failed w.GetSymKey(id1): false positive.")
   388  	}
   389  	if k1 != nil {
   390  		t.Fatalf("failed GetSymKey(id1): false positive.")
   391  	}
   392  	k2, err = w.GetSymKey(id2)
   393  	if err != nil {
   394  		t.Fatalf("failed w.GetSymKey(id2).")
   395  	}
   396  	if w.HasSymKey(id1) {
   397  		t.Fatalf("failed to delete first key: still exist.")
   398  	}
   399  	if !w.HasSymKey(id2) {
   400  		t.Fatalf("failed to delete first key: second key does not exist.")
   401  	}
   402  	if k1 != nil {
   403  		t.Fatalf("failed to delete first key.")
   404  	}
   405  	if k2 == nil {
   406  		t.Fatalf("failed to delete first key: second key is nil.")
   407  	}
   408  
   409  	w.DeleteSymKey(id1)
   410  	w.DeleteSymKey(id2)
   411  	k1, err = w.GetSymKey(id1)
   412  	if err == nil {
   413  		t.Fatalf("failed w.GetSymKey(id1): false positive.")
   414  	}
   415  	k2, err = w.GetSymKey(id2)
   416  	if err == nil {
   417  		t.Fatalf("failed w.GetSymKey(id2): false positive.")
   418  	}
   419  	if k1 != nil || k2 != nil {
   420  		t.Fatalf("k1 or k2 is not nil")
   421  	}
   422  	if w.HasSymKey(id1) {
   423  		t.Fatalf("failed to delete second key: first key exist.")
   424  	}
   425  	if w.HasSymKey(id2) {
   426  		t.Fatalf("failed to delete second key: still exist.")
   427  	}
   428  	if k1 != nil {
   429  		t.Fatalf("failed to delete second key: first key is not nil.")
   430  	}
   431  	if k2 != nil {
   432  		t.Fatalf("failed to delete second key: second key is not nil.")
   433  	}
   434  
   435  	randomKey = make([]byte, aesKeyLength+1)
   436  	mrand.Read(randomKey)
   437  	_, err = w.AddSymKeyDirect(randomKey)
   438  	if err == nil {
   439  		t.Fatalf("added the key with wrong size, seed %d.", seed)
   440  	}
   441  
   442  	const password = "arbitrary data here"
   443  	id1, err = w.AddSymKeyFromPassword(password)
   444  	if err != nil {
   445  		t.Fatalf("failed AddSymKeyFromPassword(id1) with seed %d: %s.", seed, err)
   446  	}
   447  	id2, err = w.AddSymKeyFromPassword(password)
   448  	if err != nil {
   449  		t.Fatalf("failed AddSymKeyFromPassword(id2) with seed %d: %s.", seed, err)
   450  	}
   451  	k1, err = w.GetSymKey(id1)
   452  	if err != nil {
   453  		t.Fatalf("failed w.GetSymKey(id1).")
   454  	}
   455  	k2, err = w.GetSymKey(id2)
   456  	if err != nil {
   457  		t.Fatalf("failed w.GetSymKey(id2).")
   458  	}
   459  	if !w.HasSymKey(id1) {
   460  		t.Fatalf("HasSymKey(id1) failed.")
   461  	}
   462  	if !w.HasSymKey(id2) {
   463  		t.Fatalf("HasSymKey(id2) failed.")
   464  	}
   465  	if k1 == nil {
   466  		t.Fatalf("k1 does not exist.")
   467  	}
   468  	if k2 == nil {
   469  		t.Fatalf("k2 does not exist.")
   470  	}
   471  	if !bytes.Equal(k1, k2) {
   472  		t.Fatalf("k1 != k2.")
   473  	}
   474  	if len(k1) != aesKeyLength {
   475  		t.Fatalf("wrong length of k1.")
   476  	}
   477  	if len(k2) != aesKeyLength {
   478  		t.Fatalf("wrong length of k2.")
   479  	}
   480  	if !validateSymmetricKey(k2) {
   481  		t.Fatalf("key validation failed.")
   482  	}
   483  }
   484  
   485  func TestExpiry(t *testing.T) {
   486  	InitSingleTest()
   487  
   488  	w := New(&DefaultConfig)
   489  	w.SetMinimumPoW(0.0000001)
   490  	defer w.SetMinimumPoW(DefaultMinimumPoW)
   491  	w.Start(nil)
   492  	defer w.Stop()
   493  
   494  	params, err := generateMessageParams()
   495  	if err != nil {
   496  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   497  	}
   498  
   499  	params.TTL = 1
   500  	msg, err := NewSentMessage(params)
   501  	if err != nil {
   502  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   503  	}
   504  	env, err := msg.Wrap(params)
   505  	if err != nil {
   506  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   507  	}
   508  
   509  	err = w.Send(env)
   510  	if err != nil {
   511  		t.Fatalf("failed to send envelope with seed %d: %s.", seed, err)
   512  	}
   513  
   514  //
   515  	var received, expired bool
   516  	for j := 0; j < 20; j++ {
   517  		time.Sleep(100 * time.Millisecond)
   518  		if len(w.Envelopes()) > 0 {
   519  			received = true
   520  			break
   521  		}
   522  	}
   523  
   524  	if !received {
   525  		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
   526  	}
   527  
   528  //
   529  	for j := 0; j < 20; j++ {
   530  		time.Sleep(100 * time.Millisecond)
   531  		if len(w.Envelopes()) == 0 {
   532  			expired = true
   533  			break
   534  		}
   535  	}
   536  
   537  	if !expired {
   538  		t.Fatalf("expire failed, seed: %d.", seed)
   539  	}
   540  }
   541  
   542  func TestCustomization(t *testing.T) {
   543  	InitSingleTest()
   544  
   545  	w := New(&DefaultConfig)
   546  	defer w.SetMinimumPoW(DefaultMinimumPoW)
   547  	defer w.SetMaxMessageSize(DefaultMaxMessageSize)
   548  	w.Start(nil)
   549  	defer w.Stop()
   550  
   551  	const smallPoW = 0.00001
   552  
   553  	f, err := generateFilter(t, true)
   554  	if err != nil {
   555  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   556  	}
   557  	params, err := generateMessageParams()
   558  	if err != nil {
   559  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   560  	}
   561  
   562  	params.KeySym = f.KeySym
   563  	params.Topic = BytesToTopic(f.Topics[2])
   564  	params.PoW = smallPoW
   565  params.TTL = 3600 * 24 //
   566  	msg, err := NewSentMessage(params)
   567  	if err != nil {
   568  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   569  	}
   570  	env, err := msg.Wrap(params)
   571  	if err != nil {
   572  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   573  	}
   574  
   575  	err = w.Send(env)
   576  	if err == nil {
   577  		t.Fatalf("successfully sent envelope with PoW %.06f, false positive (seed %d).", env.PoW(), seed)
   578  	}
   579  
   580  	w.SetMinimumPoW(smallPoW / 2)
   581  	err = w.Send(env)
   582  	if err != nil {
   583  		t.Fatalf("failed to send envelope with seed %d: %s.", seed, err)
   584  	}
   585  
   586  	params.TTL++
   587  	msg, err = NewSentMessage(params)
   588  	if err != nil {
   589  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   590  	}
   591  	env, err = msg.Wrap(params)
   592  	if err != nil {
   593  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   594  	}
   595  	w.SetMaxMessageSize(uint32(env.size() - 1))
   596  	err = w.Send(env)
   597  	if err == nil {
   598  		t.Fatalf("successfully sent oversized envelope (seed %d): false positive.", seed)
   599  	}
   600  
   601  	w.SetMaxMessageSize(DefaultMaxMessageSize)
   602  	err = w.Send(env)
   603  	if err != nil {
   604  		t.Fatalf("failed to send second envelope with seed %d: %s.", seed, err)
   605  	}
   606  
   607  //
   608  	var received bool
   609  	for j := 0; j < 20; j++ {
   610  		time.Sleep(100 * time.Millisecond)
   611  		if len(w.Envelopes()) > 1 {
   612  			received = true
   613  			break
   614  		}
   615  	}
   616  
   617  	if !received {
   618  		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
   619  	}
   620  
   621  //
   622  	id, err := w.Subscribe(f)
   623  	if err != nil {
   624  		t.Fatalf("failed subscribe with seed %d: %s.", seed, err)
   625  	}
   626  	time.Sleep(5 * time.Millisecond)
   627  	mail := f.Retrieve()
   628  	if len(mail) > 0 {
   629  		t.Fatalf("received premature mail")
   630  	}
   631  
   632  	mail = w.Messages(id)
   633  	if len(mail) != 2 {
   634  		t.Fatalf("failed to get whisper messages")
   635  	}
   636  }
   637  
   638  func TestSymmetricSendCycle(t *testing.T) {
   639  	InitSingleTest()
   640  
   641  	w := New(&DefaultConfig)
   642  	defer w.SetMinimumPoW(DefaultMinimumPoW)
   643  	defer w.SetMaxMessageSize(DefaultMaxMessageSize)
   644  	w.Start(nil)
   645  	defer w.Stop()
   646  
   647  	filter1, err := generateFilter(t, true)
   648  	if err != nil {
   649  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   650  	}
   651  	filter1.PoW = DefaultMinimumPoW
   652  
   653  //
   654  //
   655  	filter2 := &Filter{
   656  		KeySym:   filter1.KeySym,
   657  		Topics:   filter1.Topics,
   658  		PoW:      filter1.PoW,
   659  		AllowP2P: filter1.AllowP2P,
   660  		Messages: make(map[common.Hash]*ReceivedMessage),
   661  	}
   662  
   663  	params, err := generateMessageParams()
   664  	if err != nil {
   665  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   666  	}
   667  
   668  	filter1.Src = &params.Src.PublicKey
   669  	filter2.Src = &params.Src.PublicKey
   670  
   671  	params.KeySym = filter1.KeySym
   672  	params.Topic = BytesToTopic(filter1.Topics[2])
   673  	params.PoW = filter1.PoW
   674  	params.WorkTime = 10
   675  	params.TTL = 50
   676  	msg, err := NewSentMessage(params)
   677  	if err != nil {
   678  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   679  	}
   680  	env, err := msg.Wrap(params)
   681  	if err != nil {
   682  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   683  	}
   684  
   685  	_, err = w.Subscribe(filter1)
   686  	if err != nil {
   687  		t.Fatalf("failed subscribe 1 with seed %d: %s.", seed, err)
   688  	}
   689  
   690  	_, err = w.Subscribe(filter2)
   691  	if err != nil {
   692  		t.Fatalf("failed subscribe 2 with seed %d: %s.", seed, err)
   693  	}
   694  
   695  	err = w.Send(env)
   696  	if err != nil {
   697  		t.Fatalf("Failed sending envelope with PoW %.06f (seed %d): %s", env.PoW(), seed, err)
   698  	}
   699  
   700  //
   701  	var received bool
   702  	for j := 0; j < 200; j++ {
   703  		time.Sleep(10 * time.Millisecond)
   704  		if len(w.Envelopes()) > 0 {
   705  			received = true
   706  			break
   707  		}
   708  	}
   709  
   710  	if !received {
   711  		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
   712  	}
   713  
   714  //
   715  	time.Sleep(5 * time.Millisecond)
   716  	mail1 := filter1.Retrieve()
   717  	mail2 := filter2.Retrieve()
   718  	if len(mail2) == 0 {
   719  		t.Fatalf("did not receive any email for filter 2")
   720  	}
   721  	if len(mail1) == 0 {
   722  		t.Fatalf("did not receive any email for filter 1")
   723  	}
   724  
   725  }
   726  
   727  func TestSymmetricSendWithoutAKey(t *testing.T) {
   728  	InitSingleTest()
   729  
   730  	w := New(&DefaultConfig)
   731  	defer w.SetMinimumPoW(DefaultMinimumPoW)
   732  	defer w.SetMaxMessageSize(DefaultMaxMessageSize)
   733  	w.Start(nil)
   734  	defer w.Stop()
   735  
   736  	filter, err := generateFilter(t, true)
   737  	if err != nil {
   738  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   739  	}
   740  	filter.PoW = DefaultMinimumPoW
   741  
   742  	params, err := generateMessageParams()
   743  	if err != nil {
   744  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   745  	}
   746  
   747  	filter.Src = nil
   748  
   749  	params.KeySym = filter.KeySym
   750  	params.Topic = BytesToTopic(filter.Topics[2])
   751  	params.PoW = filter.PoW
   752  	params.WorkTime = 10
   753  	params.TTL = 50
   754  	msg, err := NewSentMessage(params)
   755  	if err != nil {
   756  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   757  	}
   758  	env, err := msg.Wrap(params)
   759  	if err != nil {
   760  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   761  	}
   762  
   763  	_, err = w.Subscribe(filter)
   764  	if err != nil {
   765  		t.Fatalf("failed subscribe 1 with seed %d: %s.", seed, err)
   766  	}
   767  
   768  	err = w.Send(env)
   769  	if err != nil {
   770  		t.Fatalf("Failed sending envelope with PoW %.06f (seed %d): %s", env.PoW(), seed, err)
   771  	}
   772  
   773  //
   774  	var received bool
   775  	for j := 0; j < 200; j++ {
   776  		time.Sleep(10 * time.Millisecond)
   777  		if len(w.Envelopes()) > 0 {
   778  			received = true
   779  			break
   780  		}
   781  	}
   782  
   783  	if !received {
   784  		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
   785  	}
   786  
   787  //
   788  	time.Sleep(5 * time.Millisecond)
   789  	mail := filter.Retrieve()
   790  	if len(mail) == 0 {
   791  		t.Fatalf("did not receive message in spite of not setting a public key")
   792  	}
   793  }
   794  
   795  func TestSymmetricSendKeyMismatch(t *testing.T) {
   796  	InitSingleTest()
   797  
   798  	w := New(&DefaultConfig)
   799  	defer w.SetMinimumPoW(DefaultMinimumPoW)
   800  	defer w.SetMaxMessageSize(DefaultMaxMessageSize)
   801  	w.Start(nil)
   802  	defer w.Stop()
   803  
   804  	filter, err := generateFilter(t, true)
   805  	if err != nil {
   806  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   807  	}
   808  	filter.PoW = DefaultMinimumPoW
   809  
   810  	params, err := generateMessageParams()
   811  	if err != nil {
   812  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   813  	}
   814  
   815  	params.KeySym = filter.KeySym
   816  	params.Topic = BytesToTopic(filter.Topics[2])
   817  	params.PoW = filter.PoW
   818  	params.WorkTime = 10
   819  	params.TTL = 50
   820  	msg, err := NewSentMessage(params)
   821  	if err != nil {
   822  		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
   823  	}
   824  	env, err := msg.Wrap(params)
   825  	if err != nil {
   826  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   827  	}
   828  
   829  	_, err = w.Subscribe(filter)
   830  	if err != nil {
   831  		t.Fatalf("failed subscribe 1 with seed %d: %s.", seed, err)
   832  	}
   833  
   834  	err = w.Send(env)
   835  	if err != nil {
   836  		t.Fatalf("Failed sending envelope with PoW %.06f (seed %d): %s", env.PoW(), seed, err)
   837  	}
   838  
   839  //
   840  	var received bool
   841  	for j := 0; j < 200; j++ {
   842  		time.Sleep(10 * time.Millisecond)
   843  		if len(w.Envelopes()) > 0 {
   844  			received = true
   845  			break
   846  		}
   847  	}
   848  
   849  	if !received {
   850  		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
   851  	}
   852  
   853  //
   854  	time.Sleep(5 * time.Millisecond)
   855  	mail := filter.Retrieve()
   856  	if len(mail) > 0 {
   857  		t.Fatalf("received a message when keys weren't matching")
   858  	}
   859  }