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