github.com/murrekatt/go-ethereum@v1.5.8-0.20170123175102-fc52f2c007fb/whisper/whisperv5/whisper_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 whisperv5
    18  
    19  import (
    20  	"bytes"
    21  	"testing"
    22  	"time"
    23  
    24  	"github.com/ethereum/go-ethereum/common"
    25  	"github.com/ethereum/go-ethereum/crypto"
    26  )
    27  
    28  func TestWhisperBasic(t *testing.T) {
    29  	w := NewWhisper(nil)
    30  	p := w.Protocols()
    31  	shh := p[0]
    32  	if shh.Name != ProtocolName {
    33  		t.Fatalf("failed Protocol Name: %v.", shh.Name)
    34  	}
    35  	if uint64(shh.Version) != ProtocolVersion {
    36  		t.Fatalf("failed Protocol Version: %v.", shh.Version)
    37  	}
    38  	if shh.Length != NumberOfMessageCodes {
    39  		t.Fatalf("failed Protocol Length: %v.", shh.Length)
    40  	}
    41  	if shh.Run == nil {
    42  		t.Fatalf("failed shh.Run.")
    43  	}
    44  	if uint64(w.Version()) != ProtocolVersion {
    45  		t.Fatalf("failed whisper Version: %v.", shh.Version)
    46  	}
    47  	if w.GetFilter(0) != nil {
    48  		t.Fatalf("failed GetFilter.")
    49  	}
    50  
    51  	peerID := make([]byte, 64)
    52  	randomize(peerID)
    53  	peer, _ := w.getPeer(peerID)
    54  	if peer != nil {
    55  		t.Fatal("found peer for random key.")
    56  	}
    57  	if err := w.MarkPeerTrusted(peerID); err == nil {
    58  		t.Fatalf("failed MarkPeerTrusted.")
    59  	}
    60  	if err := w.RequestHistoricMessages(peerID, peerID); err == nil {
    61  		t.Fatalf("failed RequestHistoricMessages.")
    62  	}
    63  	if err := w.SendP2PMessage(peerID, nil); err == nil {
    64  		t.Fatalf("failed SendP2PMessage.")
    65  	}
    66  	exist := w.HasSymKey("non-existing")
    67  	if exist {
    68  		t.Fatalf("failed HasSymKey.")
    69  	}
    70  	key := w.GetSymKey("non-existing")
    71  	if key != nil {
    72  		t.Fatalf("failed GetSymKey.")
    73  	}
    74  	mail := w.Envelopes()
    75  	if len(mail) != 0 {
    76  		t.Fatalf("failed w.Envelopes().")
    77  	}
    78  	m := w.Messages(0)
    79  	if len(m) != 0 {
    80  		t.Fatalf("failed w.Messages.")
    81  	}
    82  
    83  	var derived []byte
    84  	ver := uint64(0xDEADBEEF)
    85  	if _, err := deriveKeyMaterial(peerID, ver); err != unknownVersionError(ver) {
    86  		t.Fatalf("failed deriveKeyMaterial with param = %v: %s.", peerID, err)
    87  	}
    88  	derived, err := deriveKeyMaterial(peerID, 0)
    89  	if err != nil {
    90  		t.Fatalf("failed second deriveKeyMaterial with param = %v: %s.", peerID, err)
    91  	}
    92  	if !validateSymmetricKey(derived) {
    93  		t.Fatalf("failed validateSymmetricKey with param = %v.", derived)
    94  	}
    95  	if containsOnlyZeros(derived) {
    96  		t.Fatalf("failed containsOnlyZeros with param = %v.", derived)
    97  	}
    98  
    99  	buf := []byte{0xFF, 0xE5, 0x80, 0x2, 0}
   100  	le := bytesToIntLittleEndian(buf)
   101  	be := BytesToIntBigEndian(buf)
   102  	if le != uint64(0x280e5ff) {
   103  		t.Fatalf("failed bytesToIntLittleEndian: %d.", le)
   104  	}
   105  	if be != uint64(0xffe5800200) {
   106  		t.Fatalf("failed BytesToIntBigEndian: %d.", be)
   107  	}
   108  
   109  	pk := w.NewIdentity()
   110  	if !validatePrivateKey(pk) {
   111  		t.Fatalf("failed validatePrivateKey: %v.", pk)
   112  	}
   113  	if !ValidatePublicKey(&pk.PublicKey) {
   114  		t.Fatalf("failed ValidatePublicKey: %v.", pk)
   115  	}
   116  }
   117  
   118  func TestWhisperIdentityManagement(t *testing.T) {
   119  	w := NewWhisper(nil)
   120  	id1 := w.NewIdentity()
   121  	id2 := w.NewIdentity()
   122  	pub1 := common.ToHex(crypto.FromECDSAPub(&id1.PublicKey))
   123  	pub2 := common.ToHex(crypto.FromECDSAPub(&id2.PublicKey))
   124  	pk1 := w.GetIdentity(pub1)
   125  	pk2 := w.GetIdentity(pub2)
   126  	if !w.HasIdentity(pub1) {
   127  		t.Fatalf("failed HasIdentity(pub1).")
   128  	}
   129  	if !w.HasIdentity(pub2) {
   130  		t.Fatalf("failed HasIdentity(pub2).")
   131  	}
   132  	if pk1 != id1 {
   133  		t.Fatalf("failed GetIdentity(pub1).")
   134  	}
   135  	if pk2 != id2 {
   136  		t.Fatalf("failed GetIdentity(pub2).")
   137  	}
   138  
   139  	// Delete one identity
   140  	w.DeleteIdentity(pub1)
   141  	pk1 = w.GetIdentity(pub1)
   142  	pk2 = w.GetIdentity(pub2)
   143  	if w.HasIdentity(pub1) {
   144  		t.Fatalf("failed DeleteIdentity(pub1): still exist.")
   145  	}
   146  	if !w.HasIdentity(pub2) {
   147  		t.Fatalf("failed DeleteIdentity(pub1): pub2 does not exist.")
   148  	}
   149  	if pk1 != nil {
   150  		t.Fatalf("failed DeleteIdentity(pub1): first key still exist.")
   151  	}
   152  	if pk2 != id2 {
   153  		t.Fatalf("failed DeleteIdentity(pub1): second key does not exist.")
   154  	}
   155  
   156  	// Delete again non-existing identity
   157  	w.DeleteIdentity(pub1)
   158  	pk1 = w.GetIdentity(pub1)
   159  	pk2 = w.GetIdentity(pub2)
   160  	if w.HasIdentity(pub1) {
   161  		t.Fatalf("failed delete non-existing identity: exist.")
   162  	}
   163  	if !w.HasIdentity(pub2) {
   164  		t.Fatalf("failed delete non-existing identity: pub2 does not exist.")
   165  	}
   166  	if pk1 != nil {
   167  		t.Fatalf("failed delete non-existing identity: first key exist.")
   168  	}
   169  	if pk2 != id2 {
   170  		t.Fatalf("failed delete non-existing identity: second key does not exist.")
   171  	}
   172  
   173  	// Delete second identity
   174  	w.DeleteIdentity(pub2)
   175  	pk1 = w.GetIdentity(pub1)
   176  	pk2 = w.GetIdentity(pub2)
   177  	if w.HasIdentity(pub1) {
   178  		t.Fatalf("failed delete second identity: first identity exist.")
   179  	}
   180  	if w.HasIdentity(pub2) {
   181  		t.Fatalf("failed delete second identity: still exist.")
   182  	}
   183  	if pk1 != nil {
   184  		t.Fatalf("failed delete second identity: first key exist.")
   185  	}
   186  	if pk2 != nil {
   187  		t.Fatalf("failed delete second identity: second key exist.")
   188  	}
   189  }
   190  
   191  func TestWhisperSymKeyManagement(t *testing.T) {
   192  	InitSingleTest()
   193  
   194  	var k1, k2 []byte
   195  	w := NewWhisper(nil)
   196  	id1 := string("arbitrary-string-1")
   197  	id2 := string("arbitrary-string-2")
   198  
   199  	err := w.GenerateSymKey(id1)
   200  	if err != nil {
   201  		t.Fatalf("failed GenerateSymKey with seed %d: %s.", seed, err)
   202  	}
   203  
   204  	k1 = w.GetSymKey(id1)
   205  	k2 = w.GetSymKey(id2)
   206  	if !w.HasSymKey(id1) {
   207  		t.Fatalf("failed HasSymKey(id1).")
   208  	}
   209  	if w.HasSymKey(id2) {
   210  		t.Fatalf("failed HasSymKey(id2).")
   211  	}
   212  	if k1 == nil {
   213  		t.Fatalf("first key does not exist.")
   214  	}
   215  	if k2 != nil {
   216  		t.Fatalf("second key still exist.")
   217  	}
   218  
   219  	// add existing id, nothing should change
   220  	randomKey := make([]byte, 16)
   221  	randomize(randomKey)
   222  	err = w.AddSymKey(id1, randomKey)
   223  	if err == nil {
   224  		t.Fatalf("failed AddSymKey with seed %d.", seed)
   225  	}
   226  
   227  	k1 = w.GetSymKey(id1)
   228  	k2 = w.GetSymKey(id2)
   229  	if !w.HasSymKey(id1) {
   230  		t.Fatalf("failed w.HasSymKey(id1).")
   231  	}
   232  	if w.HasSymKey(id2) {
   233  		t.Fatalf("failed w.HasSymKey(id2).")
   234  	}
   235  	if k1 == nil {
   236  		t.Fatalf("first key does not exist.")
   237  	}
   238  	if bytes.Equal(k1, randomKey) {
   239  		t.Fatalf("k1 == randomKey.")
   240  	}
   241  	if k2 != nil {
   242  		t.Fatalf("second key already exist.")
   243  	}
   244  
   245  	err = w.AddSymKey(id2, randomKey) // add non-existing (yet)
   246  	if err != nil {
   247  		t.Fatalf("failed AddSymKey(id2) with seed %d: %s.", seed, err)
   248  	}
   249  	k1 = w.GetSymKey(id1)
   250  	k2 = w.GetSymKey(id2)
   251  	if !w.HasSymKey(id1) {
   252  		t.Fatalf("HasSymKey(id1) failed.")
   253  	}
   254  	if !w.HasSymKey(id2) {
   255  		t.Fatalf("HasSymKey(id2) failed.")
   256  	}
   257  	if k1 == nil {
   258  		t.Fatalf("k1 does not exist.")
   259  	}
   260  	if k2 == nil {
   261  		t.Fatalf("k2 does not exist.")
   262  	}
   263  	if bytes.Equal(k1, k2) {
   264  		t.Fatalf("k1 == k2.")
   265  	}
   266  	if bytes.Equal(k1, randomKey) {
   267  		t.Fatalf("k1 == randomKey.")
   268  	}
   269  	if len(k1) != aesKeyLength {
   270  		t.Fatalf("wrong length of k1.")
   271  	}
   272  	if len(k2) != aesKeyLength {
   273  		t.Fatalf("wrong length of k2.")
   274  	}
   275  
   276  	w.DeleteSymKey(id1)
   277  	k1 = w.GetSymKey(id1)
   278  	k2 = w.GetSymKey(id2)
   279  	if w.HasSymKey(id1) {
   280  		t.Fatalf("failed to delete first key: still exist.")
   281  	}
   282  	if !w.HasSymKey(id2) {
   283  		t.Fatalf("failed to delete first key: second key does not exist.")
   284  	}
   285  	if k1 != nil {
   286  		t.Fatalf("failed to delete first key.")
   287  	}
   288  	if k2 == nil {
   289  		t.Fatalf("failed to delete first key: second key is nil.")
   290  	}
   291  
   292  	w.DeleteSymKey(id1)
   293  	w.DeleteSymKey(id2)
   294  	k1 = w.GetSymKey(id1)
   295  	k2 = w.GetSymKey(id2)
   296  	if w.HasSymKey(id1) {
   297  		t.Fatalf("failed to delete second key: first key exist.")
   298  	}
   299  	if w.HasSymKey(id2) {
   300  		t.Fatalf("failed to delete second key: still exist.")
   301  	}
   302  	if k1 != nil {
   303  		t.Fatalf("failed to delete second key: first key is not nil.")
   304  	}
   305  	if k2 != nil {
   306  		t.Fatalf("failed to delete second key: second key is not nil.")
   307  	}
   308  }
   309  
   310  func TestExpiry(t *testing.T) {
   311  	InitSingleTest()
   312  
   313  	w := NewWhisper(nil)
   314  	w.test = true
   315  	w.Start(nil)
   316  	defer w.Stop()
   317  
   318  	params, err := generateMessageParams()
   319  	if err != nil {
   320  		t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err)
   321  	}
   322  
   323  	params.TTL = 1
   324  	msg := NewSentMessage(params)
   325  	env, err := msg.Wrap(params)
   326  	if err != nil {
   327  		t.Fatalf("failed Wrap with seed %d: %s.", seed, err)
   328  	}
   329  
   330  	err = w.Send(env)
   331  	if err != nil {
   332  		t.Fatalf("failed to send envelope with seed %d: %s.", seed, err)
   333  	}
   334  
   335  	// wait till received or timeout
   336  	var received, expired bool
   337  	for j := 0; j < 20; j++ {
   338  		time.Sleep(100 * time.Millisecond)
   339  		if len(w.Envelopes()) > 0 {
   340  			received = true
   341  			break
   342  		}
   343  	}
   344  
   345  	if !received {
   346  		t.Fatalf("did not receive the sent envelope, seed: %d.", seed)
   347  	}
   348  
   349  	// wait till expired or timeout
   350  	for j := 0; j < 20; j++ {
   351  		time.Sleep(100 * time.Millisecond)
   352  		if len(w.Envelopes()) == 0 {
   353  			expired = true
   354  			break
   355  		}
   356  	}
   357  
   358  	if !expired {
   359  		t.Fatalf("expire failed, seed: %d.", seed)
   360  	}
   361  }