github.com/yinchengtsinghua/golang-Eos-dpos-Ethereum@v0.0.0-20190121132951-92cc4225ed8e/whisper/whisperv5/message_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 mrand "math/rand" 30 "testing" 31 32 "github.com/ethereum/go-ethereum/crypto" 33 "github.com/ethereum/go-ethereum/rlp" 34 ) 35 36 func generateMessageParams() (*MessageParams, error) { 37 // 38 39 buf := make([]byte, 4) 40 mrand.Read(buf) 41 sz := mrand.Intn(400) 42 43 var p MessageParams 44 p.PoW = 0.01 45 p.WorkTime = 1 46 p.TTL = uint32(mrand.Intn(1024)) 47 p.Payload = make([]byte, sz) 48 p.KeySym = make([]byte, aesKeyLength) 49 mrand.Read(p.Payload) 50 mrand.Read(p.KeySym) 51 p.Topic = BytesToTopic(buf) 52 53 var err error 54 p.Src, err = crypto.GenerateKey() 55 if err != nil { 56 return nil, err 57 } 58 59 return &p, nil 60 } 61 62 func singleMessageTest(t *testing.T, symmetric bool) { 63 params, err := generateMessageParams() 64 if err != nil { 65 t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 66 } 67 68 key, err := crypto.GenerateKey() 69 if err != nil { 70 t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) 71 } 72 73 if !symmetric { 74 params.KeySym = nil 75 params.Dst = &key.PublicKey 76 } 77 78 text := make([]byte, 0, 512) 79 text = append(text, params.Payload...) 80 81 msg, err := NewSentMessage(params) 82 if err != nil { 83 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 84 } 85 env, err := msg.Wrap(params) 86 if err != nil { 87 t.Fatalf("failed Wrap with seed %d: %s.", seed, err) 88 } 89 90 var decrypted *ReceivedMessage 91 if symmetric { 92 decrypted, err = env.OpenSymmetric(params.KeySym) 93 } else { 94 decrypted, err = env.OpenAsymmetric(key) 95 } 96 97 if err != nil { 98 t.Fatalf("failed to encrypt with seed %d: %s.", seed, err) 99 } 100 101 if !decrypted.Validate() { 102 t.Fatalf("failed to validate with seed %d.", seed) 103 } 104 105 if !bytes.Equal(text, decrypted.Payload) { 106 t.Fatalf("failed with seed %d: compare payload.", seed) 107 } 108 if !isMessageSigned(decrypted.Raw[0]) { 109 t.Fatalf("failed with seed %d: unsigned.", seed) 110 } 111 if len(decrypted.Signature) != signatureLength { 112 t.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) 113 } 114 if !IsPubKeyEqual(decrypted.Src, ¶ms.Src.PublicKey) { 115 t.Fatalf("failed with seed %d: signature mismatch.", seed) 116 } 117 } 118 119 func TestMessageEncryption(t *testing.T) { 120 InitSingleTest() 121 122 var symmetric bool 123 for i := 0; i < 256; i++ { 124 singleMessageTest(t, symmetric) 125 symmetric = !symmetric 126 } 127 } 128 129 func TestMessageWrap(t *testing.T) { 130 seed = int64(1777444222) 131 mrand.Seed(seed) 132 target := 128.0 133 134 params, err := generateMessageParams() 135 if err != nil { 136 t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 137 } 138 139 msg, err := NewSentMessage(params) 140 if err != nil { 141 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 142 } 143 params.TTL = 1 144 params.WorkTime = 12 145 params.PoW = target 146 env, err := msg.Wrap(params) 147 if err != nil { 148 t.Fatalf("failed Wrap with seed %d: %s.", seed, err) 149 } 150 151 pow := env.PoW() 152 if pow < target { 153 t.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) 154 } 155 156 // 157 msg2, err := NewSentMessage(params) 158 if err != nil { 159 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 160 } 161 params.TTL = 1000000 162 params.WorkTime = 1 163 params.PoW = 10000000.0 164 _, err = msg2.Wrap(params) 165 if err == nil { 166 t.Fatalf("unexpectedly reached the PoW target with seed %d.", seed) 167 } 168 } 169 170 func TestMessageSeal(t *testing.T) { 171 // 172 seed = int64(1976726903) 173 mrand.Seed(seed) 174 175 params, err := generateMessageParams() 176 if err != nil { 177 t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 178 } 179 180 msg, err := NewSentMessage(params) 181 if err != nil { 182 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 183 } 184 params.TTL = 1 185 aesnonce := make([]byte, 12) 186 mrand.Read(aesnonce) 187 188 env := NewEnvelope(params.TTL, params.Topic, aesnonce, msg) 189 if err != nil { 190 t.Fatalf("failed Wrap with seed %d: %s.", seed, err) 191 } 192 193 env.Expiry = uint32(seed) // 194 target := 32.0 195 params.WorkTime = 4 196 params.PoW = target 197 env.Seal(params) 198 199 env.calculatePoW(0) 200 pow := env.PoW() 201 if pow < target { 202 t.Fatalf("failed Wrap with seed %d: pow < target (%f vs. %f).", seed, pow, target) 203 } 204 205 params.WorkTime = 1 206 params.PoW = 1000000000.0 207 env.Seal(params) 208 env.calculatePoW(0) 209 pow = env.PoW() 210 if pow < 2*target { 211 t.Fatalf("failed Wrap with seed %d: pow too small %f.", seed, pow) 212 } 213 } 214 215 func TestEnvelopeOpen(t *testing.T) { 216 InitSingleTest() 217 218 var symmetric bool 219 for i := 0; i < 256; i++ { 220 singleEnvelopeOpenTest(t, symmetric) 221 symmetric = !symmetric 222 } 223 } 224 225 func singleEnvelopeOpenTest(t *testing.T, symmetric bool) { 226 params, err := generateMessageParams() 227 if err != nil { 228 t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 229 } 230 231 key, err := crypto.GenerateKey() 232 if err != nil { 233 t.Fatalf("failed GenerateKey with seed %d: %s.", seed, err) 234 } 235 236 if !symmetric { 237 params.KeySym = nil 238 params.Dst = &key.PublicKey 239 } 240 241 text := make([]byte, 0, 512) 242 text = append(text, params.Payload...) 243 244 msg, err := NewSentMessage(params) 245 if err != nil { 246 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 247 } 248 env, err := msg.Wrap(params) 249 if err != nil { 250 t.Fatalf("failed Wrap with seed %d: %s.", seed, err) 251 } 252 253 f := Filter{KeyAsym: key, KeySym: params.KeySym} 254 decrypted := env.Open(&f) 255 if decrypted == nil { 256 t.Fatalf("failed to open with seed %d.", seed) 257 } 258 259 if !bytes.Equal(text, decrypted.Payload) { 260 t.Fatalf("failed with seed %d: compare payload.", seed) 261 } 262 if !isMessageSigned(decrypted.Raw[0]) { 263 t.Fatalf("failed with seed %d: unsigned.", seed) 264 } 265 if len(decrypted.Signature) != signatureLength { 266 t.Fatalf("failed with seed %d: signature len %d.", seed, len(decrypted.Signature)) 267 } 268 if !IsPubKeyEqual(decrypted.Src, ¶ms.Src.PublicKey) { 269 t.Fatalf("failed with seed %d: signature mismatch.", seed) 270 } 271 if decrypted.isAsymmetricEncryption() == symmetric { 272 t.Fatalf("failed with seed %d: asymmetric %v vs. %v.", seed, decrypted.isAsymmetricEncryption(), symmetric) 273 } 274 if decrypted.isSymmetricEncryption() != symmetric { 275 t.Fatalf("failed with seed %d: symmetric %v vs. %v.", seed, decrypted.isSymmetricEncryption(), symmetric) 276 } 277 if !symmetric { 278 if decrypted.Dst == nil { 279 t.Fatalf("failed with seed %d: dst is nil.", seed) 280 } 281 if !IsPubKeyEqual(decrypted.Dst, &key.PublicKey) { 282 t.Fatalf("failed with seed %d: Dst.", seed) 283 } 284 } 285 } 286 287 func TestEncryptWithZeroKey(t *testing.T) { 288 InitSingleTest() 289 290 params, err := generateMessageParams() 291 if err != nil { 292 t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 293 } 294 msg, err := NewSentMessage(params) 295 if err != nil { 296 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 297 } 298 params.KeySym = make([]byte, aesKeyLength) 299 _, err = msg.Wrap(params) 300 if err == nil { 301 t.Fatalf("wrapped with zero key, seed: %d.", seed) 302 } 303 304 params, err = generateMessageParams() 305 if err != nil { 306 t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 307 } 308 msg, err = NewSentMessage(params) 309 if err != nil { 310 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 311 } 312 params.KeySym = make([]byte, 0) 313 _, err = msg.Wrap(params) 314 if err == nil { 315 t.Fatalf("wrapped with empty key, seed: %d.", seed) 316 } 317 318 params, err = generateMessageParams() 319 if err != nil { 320 t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 321 } 322 msg, err = NewSentMessage(params) 323 if err != nil { 324 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 325 } 326 params.KeySym = nil 327 _, err = msg.Wrap(params) 328 if err == nil { 329 t.Fatalf("wrapped with nil key, seed: %d.", seed) 330 } 331 } 332 333 func TestRlpEncode(t *testing.T) { 334 InitSingleTest() 335 336 params, err := generateMessageParams() 337 if err != nil { 338 t.Fatalf("failed generateMessageParams with seed %d: %s.", seed, err) 339 } 340 msg, err := NewSentMessage(params) 341 if err != nil { 342 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 343 } 344 env, err := msg.Wrap(params) 345 if err != nil { 346 t.Fatalf("wrapped with zero key, seed: %d.", seed) 347 } 348 349 raw, err := rlp.EncodeToBytes(env) 350 if err != nil { 351 t.Fatalf("RLP encode failed: %s.", err) 352 } 353 354 var decoded Envelope 355 rlp.DecodeBytes(raw, &decoded) 356 if err != nil { 357 t.Fatalf("RLP decode failed: %s.", err) 358 } 359 360 he := env.Hash() 361 hd := decoded.Hash() 362 363 if he != hd { 364 t.Fatalf("Hashes are not equal: %x vs. %x", he, hd) 365 } 366 } 367 368 func singlePaddingTest(t *testing.T, padSize int) { 369 params, err := generateMessageParams() 370 if err != nil { 371 t.Fatalf("failed generateMessageParams with seed %d and sz=%d: %s.", seed, padSize, err) 372 } 373 params.Padding = make([]byte, padSize) 374 params.PoW = 0.0000000001 375 pad := make([]byte, padSize) 376 _, err = mrand.Read(pad) 377 if err != nil { 378 t.Fatalf("padding is not generated (seed %d): %s", seed, err) 379 } 380 n := copy(params.Padding, pad) 381 if n != padSize { 382 t.Fatalf("padding is not copied (seed %d): %s", seed, err) 383 } 384 msg, err := NewSentMessage(params) 385 if err != nil { 386 t.Fatalf("failed to create new message with seed %d: %s.", seed, err) 387 } 388 env, err := msg.Wrap(params) 389 if err != nil { 390 t.Fatalf("failed to wrap, seed: %d and sz=%d.", seed, padSize) 391 } 392 f := Filter{KeySym: params.KeySym} 393 decrypted := env.Open(&f) 394 if decrypted == nil { 395 t.Fatalf("failed to open, seed and sz=%d: %d.", seed, padSize) 396 } 397 if !bytes.Equal(pad, decrypted.Padding) { 398 t.Fatalf("padding is not retireved as expected with seed %d and sz=%d:\n[%x]\n[%x].", seed, padSize, pad, decrypted.Padding) 399 } 400 } 401 402 func TestPadding(t *testing.T) { 403 InitSingleTest() 404 405 for i := 1; i < 260; i++ { 406 singlePaddingTest(t, i) 407 } 408 409 lim := 256 * 256 410 for i := lim - 5; i < lim+2; i++ { 411 singlePaddingTest(t, i) 412 } 413 414 for i := 0; i < 256; i++ { 415 n := mrand.Intn(256*254) + 256 416 singlePaddingTest(t, n) 417 } 418 419 for i := 0; i < 256; i++ { 420 n := mrand.Intn(256*1024) + 256*256 421 singlePaddingTest(t, n) 422 } 423 }