github.com/murrekatt/go-ethereum@v1.5.8-0.20170123175102-fc52f2c007fb/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 "testing" 22 "time" 23 24 "github.com/ethereum/go-ethereum/common" 25 "github.com/ethereum/go-ethereum/crypto" 26 ) 27 28 func TestWhisperBasic(t *testing.T) { 29 w := NewWhisper(nil) 30 p := w.Protocols() 31 shh := p[0] 32 if shh.Name != ProtocolName { 33 t.Fatalf("failed Protocol Name: %v.", shh.Name) 34 } 35 if uint64(shh.Version) != ProtocolVersion { 36 t.Fatalf("failed Protocol Version: %v.", shh.Version) 37 } 38 if shh.Length != NumberOfMessageCodes { 39 t.Fatalf("failed Protocol Length: %v.", shh.Length) 40 } 41 if shh.Run == nil { 42 t.Fatalf("failed shh.Run.") 43 } 44 if uint64(w.Version()) != ProtocolVersion { 45 t.Fatalf("failed whisper Version: %v.", shh.Version) 46 } 47 if w.GetFilter(0) != nil { 48 t.Fatalf("failed GetFilter.") 49 } 50 51 peerID := make([]byte, 64) 52 randomize(peerID) 53 peer, _ := w.getPeer(peerID) 54 if peer != nil { 55 t.Fatal("found peer for random key.") 56 } 57 if err := w.MarkPeerTrusted(peerID); err == nil { 58 t.Fatalf("failed MarkPeerTrusted.") 59 } 60 if err := w.RequestHistoricMessages(peerID, peerID); err == nil { 61 t.Fatalf("failed RequestHistoricMessages.") 62 } 63 if err := w.SendP2PMessage(peerID, nil); err == nil { 64 t.Fatalf("failed SendP2PMessage.") 65 } 66 exist := w.HasSymKey("non-existing") 67 if exist { 68 t.Fatalf("failed HasSymKey.") 69 } 70 key := w.GetSymKey("non-existing") 71 if key != nil { 72 t.Fatalf("failed GetSymKey.") 73 } 74 mail := w.Envelopes() 75 if len(mail) != 0 { 76 t.Fatalf("failed w.Envelopes().") 77 } 78 m := w.Messages(0) 79 if len(m) != 0 { 80 t.Fatalf("failed w.Messages.") 81 } 82 83 var derived []byte 84 ver := uint64(0xDEADBEEF) 85 if _, err := deriveKeyMaterial(peerID, ver); err != unknownVersionError(ver) { 86 t.Fatalf("failed deriveKeyMaterial with param = %v: %s.", peerID, err) 87 } 88 derived, err := deriveKeyMaterial(peerID, 0) 89 if err != nil { 90 t.Fatalf("failed second deriveKeyMaterial with param = %v: %s.", peerID, err) 91 } 92 if !validateSymmetricKey(derived) { 93 t.Fatalf("failed validateSymmetricKey with param = %v.", derived) 94 } 95 if containsOnlyZeros(derived) { 96 t.Fatalf("failed containsOnlyZeros with param = %v.", derived) 97 } 98 99 buf := []byte{0xFF, 0xE5, 0x80, 0x2, 0} 100 le := bytesToIntLittleEndian(buf) 101 be := BytesToIntBigEndian(buf) 102 if le != uint64(0x280e5ff) { 103 t.Fatalf("failed bytesToIntLittleEndian: %d.", le) 104 } 105 if be != uint64(0xffe5800200) { 106 t.Fatalf("failed BytesToIntBigEndian: %d.", be) 107 } 108 109 pk := w.NewIdentity() 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 TestWhisperIdentityManagement(t *testing.T) { 119 w := NewWhisper(nil) 120 id1 := w.NewIdentity() 121 id2 := w.NewIdentity() 122 pub1 := common.ToHex(crypto.FromECDSAPub(&id1.PublicKey)) 123 pub2 := common.ToHex(crypto.FromECDSAPub(&id2.PublicKey)) 124 pk1 := w.GetIdentity(pub1) 125 pk2 := w.GetIdentity(pub2) 126 if !w.HasIdentity(pub1) { 127 t.Fatalf("failed HasIdentity(pub1).") 128 } 129 if !w.HasIdentity(pub2) { 130 t.Fatalf("failed HasIdentity(pub2).") 131 } 132 if pk1 != id1 { 133 t.Fatalf("failed GetIdentity(pub1).") 134 } 135 if pk2 != id2 { 136 t.Fatalf("failed GetIdentity(pub2).") 137 } 138 139 // Delete one identity 140 w.DeleteIdentity(pub1) 141 pk1 = w.GetIdentity(pub1) 142 pk2 = w.GetIdentity(pub2) 143 if w.HasIdentity(pub1) { 144 t.Fatalf("failed DeleteIdentity(pub1): still exist.") 145 } 146 if !w.HasIdentity(pub2) { 147 t.Fatalf("failed DeleteIdentity(pub1): pub2 does not exist.") 148 } 149 if pk1 != nil { 150 t.Fatalf("failed DeleteIdentity(pub1): first key still exist.") 151 } 152 if pk2 != id2 { 153 t.Fatalf("failed DeleteIdentity(pub1): second key does not exist.") 154 } 155 156 // Delete again non-existing identity 157 w.DeleteIdentity(pub1) 158 pk1 = w.GetIdentity(pub1) 159 pk2 = w.GetIdentity(pub2) 160 if w.HasIdentity(pub1) { 161 t.Fatalf("failed delete non-existing identity: exist.") 162 } 163 if !w.HasIdentity(pub2) { 164 t.Fatalf("failed delete non-existing identity: pub2 does not exist.") 165 } 166 if pk1 != nil { 167 t.Fatalf("failed delete non-existing identity: first key exist.") 168 } 169 if pk2 != id2 { 170 t.Fatalf("failed delete non-existing identity: second key does not exist.") 171 } 172 173 // Delete second identity 174 w.DeleteIdentity(pub2) 175 pk1 = w.GetIdentity(pub1) 176 pk2 = w.GetIdentity(pub2) 177 if w.HasIdentity(pub1) { 178 t.Fatalf("failed delete second identity: first identity exist.") 179 } 180 if w.HasIdentity(pub2) { 181 t.Fatalf("failed delete second identity: still exist.") 182 } 183 if pk1 != nil { 184 t.Fatalf("failed delete second identity: first key exist.") 185 } 186 if pk2 != nil { 187 t.Fatalf("failed delete second identity: second key exist.") 188 } 189 } 190 191 func TestWhisperSymKeyManagement(t *testing.T) { 192 InitSingleTest() 193 194 var k1, k2 []byte 195 w := NewWhisper(nil) 196 id1 := string("arbitrary-string-1") 197 id2 := string("arbitrary-string-2") 198 199 err := w.GenerateSymKey(id1) 200 if err != nil { 201 t.Fatalf("failed GenerateSymKey with seed %d: %s.", seed, err) 202 } 203 204 k1 = w.GetSymKey(id1) 205 k2 = w.GetSymKey(id2) 206 if !w.HasSymKey(id1) { 207 t.Fatalf("failed HasSymKey(id1).") 208 } 209 if w.HasSymKey(id2) { 210 t.Fatalf("failed HasSymKey(id2).") 211 } 212 if k1 == nil { 213 t.Fatalf("first key does not exist.") 214 } 215 if k2 != nil { 216 t.Fatalf("second key still exist.") 217 } 218 219 // add existing id, nothing should change 220 randomKey := make([]byte, 16) 221 randomize(randomKey) 222 err = w.AddSymKey(id1, randomKey) 223 if err == nil { 224 t.Fatalf("failed AddSymKey with seed %d.", seed) 225 } 226 227 k1 = w.GetSymKey(id1) 228 k2 = w.GetSymKey(id2) 229 if !w.HasSymKey(id1) { 230 t.Fatalf("failed w.HasSymKey(id1).") 231 } 232 if w.HasSymKey(id2) { 233 t.Fatalf("failed w.HasSymKey(id2).") 234 } 235 if k1 == nil { 236 t.Fatalf("first key does not exist.") 237 } 238 if bytes.Equal(k1, randomKey) { 239 t.Fatalf("k1 == randomKey.") 240 } 241 if k2 != nil { 242 t.Fatalf("second key already exist.") 243 } 244 245 err = w.AddSymKey(id2, randomKey) // add non-existing (yet) 246 if err != nil { 247 t.Fatalf("failed AddSymKey(id2) with seed %d: %s.", seed, err) 248 } 249 k1 = w.GetSymKey(id1) 250 k2 = w.GetSymKey(id2) 251 if !w.HasSymKey(id1) { 252 t.Fatalf("HasSymKey(id1) failed.") 253 } 254 if !w.HasSymKey(id2) { 255 t.Fatalf("HasSymKey(id2) failed.") 256 } 257 if k1 == nil { 258 t.Fatalf("k1 does not exist.") 259 } 260 if k2 == nil { 261 t.Fatalf("k2 does not exist.") 262 } 263 if bytes.Equal(k1, k2) { 264 t.Fatalf("k1 == k2.") 265 } 266 if bytes.Equal(k1, randomKey) { 267 t.Fatalf("k1 == randomKey.") 268 } 269 if len(k1) != aesKeyLength { 270 t.Fatalf("wrong length of k1.") 271 } 272 if len(k2) != aesKeyLength { 273 t.Fatalf("wrong length of k2.") 274 } 275 276 w.DeleteSymKey(id1) 277 k1 = w.GetSymKey(id1) 278 k2 = w.GetSymKey(id2) 279 if w.HasSymKey(id1) { 280 t.Fatalf("failed to delete first key: still exist.") 281 } 282 if !w.HasSymKey(id2) { 283 t.Fatalf("failed to delete first key: second key does not exist.") 284 } 285 if k1 != nil { 286 t.Fatalf("failed to delete first key.") 287 } 288 if k2 == nil { 289 t.Fatalf("failed to delete first key: second key is nil.") 290 } 291 292 w.DeleteSymKey(id1) 293 w.DeleteSymKey(id2) 294 k1 = w.GetSymKey(id1) 295 k2 = w.GetSymKey(id2) 296 if w.HasSymKey(id1) { 297 t.Fatalf("failed to delete second key: first key exist.") 298 } 299 if w.HasSymKey(id2) { 300 t.Fatalf("failed to delete second key: still exist.") 301 } 302 if k1 != nil { 303 t.Fatalf("failed to delete second key: first key is not nil.") 304 } 305 if k2 != nil { 306 t.Fatalf("failed to delete second key: second key is not nil.") 307 } 308 } 309 310 func TestExpiry(t *testing.T) { 311 InitSingleTest() 312 313 w := NewWhisper(nil) 314 w.test = true 315 w.Start(nil) 316 defer w.Stop() 317 318 params, err := generateMessageParams() 319 if err != nil { 320 t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 321 } 322 323 params.TTL = 1 324 msg := NewSentMessage(params) 325 env, err := msg.Wrap(params) 326 if err != nil { 327 t.Fatalf("failed Wrap with seed %d: %s.", seed, err) 328 } 329 330 err = w.Send(env) 331 if err != nil { 332 t.Fatalf("failed to send envelope with seed %d: %s.", seed, err) 333 } 334 335 // wait till received or timeout 336 var received, expired bool 337 for j := 0; j < 20; j++ { 338 time.Sleep(100 * time.Millisecond) 339 if len(w.Envelopes()) > 0 { 340 received = true 341 break 342 } 343 } 344 345 if !received { 346 t.Fatalf("did not receive the sent envelope, seed: %d.", seed) 347 } 348 349 // wait till expired or timeout 350 for j := 0; j < 20; j++ { 351 time.Sleep(100 * time.Millisecond) 352 if len(w.Envelopes()) == 0 { 353 expired = true 354 break 355 } 356 } 357 358 if !expired { 359 t.Fatalf("expire failed, seed: %d.", seed) 360 } 361 }