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