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