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