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 = ¶ms.Src.PublicKey 669 filter2.Src = ¶ms.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 }