1// Copyright (c) 2013-2016 The btcsuite developers 2// Use of this source code is governed by an ISC 3// license that can be found in the LICENSE file. 4 5package wire 6 7import ( 8 "bytes" 9 "fmt" 10 "io" 11 "reflect" 12 "strings" 13 "testing" 14 15 "github.com/btcsuite/btcd/chaincfg/chainhash" 16 "github.com/davecgh/go-spew/spew" 17) 18 19// mainNetGenesisHash is the hash of the first block in the block chain for the 20// main network (genesis block). 21var mainNetGenesisHash = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy. 22 0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, 23 0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f, 24 0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c, 25 0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 26}) 27 28// mainNetGenesisMerkleRoot is the hash of the first transaction in the genesis 29// block for the main network. 30var mainNetGenesisMerkleRoot = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy. 31 0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, 32 0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61, 33 0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32, 34 0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a, 35}) 36 37// fakeRandReader implements the io.Reader interface and is used to force 38// errors in the RandomUint64 function. 39type fakeRandReader struct { 40 n int 41 err error 42} 43 44// Read returns the fake reader error and the lesser of the fake reader value 45// and the length of p. 46func (r *fakeRandReader) Read(p []byte) (int, error) { 47 n := r.n 48 if n > len(p) { 49 n = len(p) 50 } 51 return n, r.err 52} 53 54// TestElementWire tests wire encode and decode for various element types. This 55// is mainly to test the "fast" paths in readElement and writeElement which use 56// type assertions to avoid reflection when possible. 57func TestElementWire(t *testing.T) { 58 type writeElementReflect int32 59 60 tests := []struct { 61 in interface{} // Value to encode 62 buf []byte // Wire encoding 63 }{ 64 {int32(1), []byte{0x01, 0x00, 0x00, 0x00}}, 65 {uint32(256), []byte{0x00, 0x01, 0x00, 0x00}}, 66 { 67 int64(65536), 68 []byte{0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}, 69 }, 70 { 71 uint64(4294967296), 72 []byte{0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00}, 73 }, 74 { 75 true, 76 []byte{0x01}, 77 }, 78 { 79 false, 80 []byte{0x00}, 81 }, 82 { 83 [4]byte{0x01, 0x02, 0x03, 0x04}, 84 []byte{0x01, 0x02, 0x03, 0x04}, 85 }, 86 { 87 [CommandSize]byte{ 88 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 89 0x09, 0x0a, 0x0b, 0x0c, 90 }, 91 []byte{ 92 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 93 0x09, 0x0a, 0x0b, 0x0c, 94 }, 95 }, 96 { 97 [16]byte{ 98 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 99 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 100 }, 101 []byte{ 102 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 103 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 104 }, 105 }, 106 { 107 (*chainhash.Hash)(&[chainhash.HashSize]byte{ // Make go vet happy. 108 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 109 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 110 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 111 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 112 }), 113 []byte{ 114 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 115 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 116 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 117 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 118 }, 119 }, 120 { 121 ServiceFlag(SFNodeNetwork), 122 []byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 123 }, 124 { 125 InvType(InvTypeTx), 126 []byte{0x01, 0x00, 0x00, 0x00}, 127 }, 128 { 129 BitcoinNet(MainNet), 130 []byte{0xf9, 0xbe, 0xb4, 0xd9}, 131 }, 132 // Type not supported by the "fast" path and requires reflection. 133 { 134 writeElementReflect(1), 135 []byte{0x01, 0x00, 0x00, 0x00}, 136 }, 137 } 138 139 t.Logf("Running %d tests", len(tests)) 140 for i, test := range tests { 141 // Write to wire format. 142 var buf bytes.Buffer 143 err := writeElement(&buf, test.in) 144 if err != nil { 145 t.Errorf("writeElement #%d error %v", i, err) 146 continue 147 } 148 if !bytes.Equal(buf.Bytes(), test.buf) { 149 t.Errorf("writeElement #%d\n got: %s want: %s", i, 150 spew.Sdump(buf.Bytes()), spew.Sdump(test.buf)) 151 continue 152 } 153 154 // Read from wire format. 155 rbuf := bytes.NewReader(test.buf) 156 val := test.in 157 if reflect.ValueOf(test.in).Kind() != reflect.Ptr { 158 val = reflect.New(reflect.TypeOf(test.in)).Interface() 159 } 160 err = readElement(rbuf, val) 161 if err != nil { 162 t.Errorf("readElement #%d error %v", i, err) 163 continue 164 } 165 ival := val 166 if reflect.ValueOf(test.in).Kind() != reflect.Ptr { 167 ival = reflect.Indirect(reflect.ValueOf(val)).Interface() 168 } 169 if !reflect.DeepEqual(ival, test.in) { 170 t.Errorf("readElement #%d\n got: %s want: %s", i, 171 spew.Sdump(ival), spew.Sdump(test.in)) 172 continue 173 } 174 } 175} 176 177// TestElementWireErrors performs negative tests against wire encode and decode 178// of various element types to confirm error paths work correctly. 179func TestElementWireErrors(t *testing.T) { 180 tests := []struct { 181 in interface{} // Value to encode 182 max int // Max size of fixed buffer to induce errors 183 writeErr error // Expected write error 184 readErr error // Expected read error 185 }{ 186 {int32(1), 0, io.ErrShortWrite, io.EOF}, 187 {uint32(256), 0, io.ErrShortWrite, io.EOF}, 188 {int64(65536), 0, io.ErrShortWrite, io.EOF}, 189 {true, 0, io.ErrShortWrite, io.EOF}, 190 {[4]byte{0x01, 0x02, 0x03, 0x04}, 0, io.ErrShortWrite, io.EOF}, 191 { 192 [CommandSize]byte{ 193 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 194 0x09, 0x0a, 0x0b, 0x0c, 195 }, 196 0, io.ErrShortWrite, io.EOF, 197 }, 198 { 199 [16]byte{ 200 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 201 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 202 }, 203 0, io.ErrShortWrite, io.EOF, 204 }, 205 { 206 (*chainhash.Hash)(&[chainhash.HashSize]byte{ // Make go vet happy. 207 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 208 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 209 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 210 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 211 }), 212 0, io.ErrShortWrite, io.EOF, 213 }, 214 {ServiceFlag(SFNodeNetwork), 0, io.ErrShortWrite, io.EOF}, 215 {InvType(InvTypeTx), 0, io.ErrShortWrite, io.EOF}, 216 {BitcoinNet(MainNet), 0, io.ErrShortWrite, io.EOF}, 217 } 218 219 t.Logf("Running %d tests", len(tests)) 220 for i, test := range tests { 221 // Encode to wire format. 222 w := newFixedWriter(test.max) 223 err := writeElement(w, test.in) 224 if err != test.writeErr { 225 t.Errorf("writeElement #%d wrong error got: %v, want: %v", 226 i, err, test.writeErr) 227 continue 228 } 229 230 // Decode from wire format. 231 r := newFixedReader(test.max, nil) 232 val := test.in 233 if reflect.ValueOf(test.in).Kind() != reflect.Ptr { 234 val = reflect.New(reflect.TypeOf(test.in)).Interface() 235 } 236 err = readElement(r, val) 237 if err != test.readErr { 238 t.Errorf("readElement #%d wrong error got: %v, want: %v", 239 i, err, test.readErr) 240 continue 241 } 242 } 243} 244 245// TestVarIntWire tests wire encode and decode for variable length integers. 246func TestVarIntWire(t *testing.T) { 247 pver := ProtocolVersion 248 249 tests := []struct { 250 in uint64 // Value to encode 251 out uint64 // Expected decoded value 252 buf []byte // Wire encoding 253 pver uint32 // Protocol version for wire encoding 254 }{ 255 // Latest protocol version. 256 // Single byte 257 {0, 0, []byte{0x00}, pver}, 258 // Max single byte 259 {0xfc, 0xfc, []byte{0xfc}, pver}, 260 // Min 2-byte 261 {0xfd, 0xfd, []byte{0xfd, 0x0fd, 0x00}, pver}, 262 // Max 2-byte 263 {0xffff, 0xffff, []byte{0xfd, 0xff, 0xff}, pver}, 264 // Min 4-byte 265 {0x10000, 0x10000, []byte{0xfe, 0x00, 0x00, 0x01, 0x00}, pver}, 266 // Max 4-byte 267 {0xffffffff, 0xffffffff, []byte{0xfe, 0xff, 0xff, 0xff, 0xff}, pver}, 268 // Min 8-byte 269 { 270 0x100000000, 0x100000000, 271 []byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00}, 272 pver, 273 }, 274 // Max 8-byte 275 { 276 0xffffffffffffffff, 0xffffffffffffffff, 277 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 278 pver, 279 }, 280 } 281 282 t.Logf("Running %d tests", len(tests)) 283 for i, test := range tests { 284 // Encode to wire format. 285 var buf bytes.Buffer 286 err := WriteVarInt(&buf, test.pver, test.in) 287 if err != nil { 288 t.Errorf("WriteVarInt #%d error %v", i, err) 289 continue 290 } 291 if !bytes.Equal(buf.Bytes(), test.buf) { 292 t.Errorf("WriteVarInt #%d\n got: %s want: %s", i, 293 spew.Sdump(buf.Bytes()), spew.Sdump(test.buf)) 294 continue 295 } 296 297 // Decode from wire format. 298 rbuf := bytes.NewReader(test.buf) 299 val, err := ReadVarInt(rbuf, test.pver) 300 if err != nil { 301 t.Errorf("ReadVarInt #%d error %v", i, err) 302 continue 303 } 304 if val != test.out { 305 t.Errorf("ReadVarInt #%d\n got: %d want: %d", i, 306 val, test.out) 307 continue 308 } 309 } 310} 311 312// TestVarIntWireErrors performs negative tests against wire encode and decode 313// of variable length integers to confirm error paths work correctly. 314func TestVarIntWireErrors(t *testing.T) { 315 pver := ProtocolVersion 316 317 tests := []struct { 318 in uint64 // Value to encode 319 buf []byte // Wire encoding 320 pver uint32 // Protocol version for wire encoding 321 max int // Max size of fixed buffer to induce errors 322 writeErr error // Expected write error 323 readErr error // Expected read error 324 }{ 325 // Force errors on discriminant. 326 {0, []byte{0x00}, pver, 0, io.ErrShortWrite, io.EOF}, 327 // Force errors on 2-byte read/write. 328 {0xfd, []byte{0xfd}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, 329 // Force errors on 4-byte read/write. 330 {0x10000, []byte{0xfe}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, 331 // Force errors on 8-byte read/write. 332 {0x100000000, []byte{0xff}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, 333 } 334 335 t.Logf("Running %d tests", len(tests)) 336 for i, test := range tests { 337 // Encode to wire format. 338 w := newFixedWriter(test.max) 339 err := WriteVarInt(w, test.pver, test.in) 340 if err != test.writeErr { 341 t.Errorf("WriteVarInt #%d wrong error got: %v, want: %v", 342 i, err, test.writeErr) 343 continue 344 } 345 346 // Decode from wire format. 347 r := newFixedReader(test.max, test.buf) 348 _, err = ReadVarInt(r, test.pver) 349 if err != test.readErr { 350 t.Errorf("ReadVarInt #%d wrong error got: %v, want: %v", 351 i, err, test.readErr) 352 continue 353 } 354 } 355} 356 357// TestVarIntNonCanonical ensures variable length integers that are not encoded 358// canonically return the expected error. 359func TestVarIntNonCanonical(t *testing.T) { 360 pver := ProtocolVersion 361 362 tests := []struct { 363 name string // Test name for easier identification 364 in []byte // Value to decode 365 pver uint32 // Protocol version for wire encoding 366 }{ 367 { 368 "0 encoded with 3 bytes", []byte{0xfd, 0x00, 0x00}, 369 pver, 370 }, 371 { 372 "max single-byte value encoded with 3 bytes", 373 []byte{0xfd, 0xfc, 0x00}, pver, 374 }, 375 { 376 "0 encoded with 5 bytes", 377 []byte{0xfe, 0x00, 0x00, 0x00, 0x00}, pver, 378 }, 379 { 380 "max three-byte value encoded with 5 bytes", 381 []byte{0xfe, 0xff, 0xff, 0x00, 0x00}, pver, 382 }, 383 { 384 "0 encoded with 9 bytes", 385 []byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 386 pver, 387 }, 388 { 389 "max five-byte value encoded with 9 bytes", 390 []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00}, 391 pver, 392 }, 393 } 394 395 t.Logf("Running %d tests", len(tests)) 396 for i, test := range tests { 397 // Decode from wire format. 398 rbuf := bytes.NewReader(test.in) 399 val, err := ReadVarInt(rbuf, test.pver) 400 if _, ok := err.(*MessageError); !ok { 401 t.Errorf("ReadVarInt #%d (%s) unexpected error %v", i, 402 test.name, err) 403 continue 404 } 405 if val != 0 { 406 t.Errorf("ReadVarInt #%d (%s)\n got: %d want: 0", i, 407 test.name, val) 408 continue 409 } 410 } 411} 412 413// TestVarIntWire tests the serialize size for variable length integers. 414func TestVarIntSerializeSize(t *testing.T) { 415 tests := []struct { 416 val uint64 // Value to get the serialized size for 417 size int // Expected serialized size 418 }{ 419 // Single byte 420 {0, 1}, 421 // Max single byte 422 {0xfc, 1}, 423 // Min 2-byte 424 {0xfd, 3}, 425 // Max 2-byte 426 {0xffff, 3}, 427 // Min 4-byte 428 {0x10000, 5}, 429 // Max 4-byte 430 {0xffffffff, 5}, 431 // Min 8-byte 432 {0x100000000, 9}, 433 // Max 8-byte 434 {0xffffffffffffffff, 9}, 435 } 436 437 t.Logf("Running %d tests", len(tests)) 438 for i, test := range tests { 439 serializedSize := VarIntSerializeSize(test.val) 440 if serializedSize != test.size { 441 t.Errorf("VarIntSerializeSize #%d got: %d, want: %d", i, 442 serializedSize, test.size) 443 continue 444 } 445 } 446} 447 448// TestVarStringWire tests wire encode and decode for variable length strings. 449func TestVarStringWire(t *testing.T) { 450 pver := ProtocolVersion 451 452 // str256 is a string that takes a 2-byte varint to encode. 453 str256 := strings.Repeat("test", 64) 454 455 tests := []struct { 456 in string // String to encode 457 out string // String to decoded value 458 buf []byte // Wire encoding 459 pver uint32 // Protocol version for wire encoding 460 }{ 461 // Latest protocol version. 462 // Empty string 463 {"", "", []byte{0x00}, pver}, 464 // Single byte varint + string 465 {"Test", "Test", append([]byte{0x04}, []byte("Test")...), pver}, 466 // 2-byte varint + string 467 {str256, str256, append([]byte{0xfd, 0x00, 0x01}, []byte(str256)...), pver}, 468 } 469 470 t.Logf("Running %d tests", len(tests)) 471 for i, test := range tests { 472 // Encode to wire format. 473 var buf bytes.Buffer 474 err := WriteVarString(&buf, test.pver, test.in) 475 if err != nil { 476 t.Errorf("WriteVarString #%d error %v", i, err) 477 continue 478 } 479 if !bytes.Equal(buf.Bytes(), test.buf) { 480 t.Errorf("WriteVarString #%d\n got: %s want: %s", i, 481 spew.Sdump(buf.Bytes()), spew.Sdump(test.buf)) 482 continue 483 } 484 485 // Decode from wire format. 486 rbuf := bytes.NewReader(test.buf) 487 val, err := ReadVarString(rbuf, test.pver) 488 if err != nil { 489 t.Errorf("ReadVarString #%d error %v", i, err) 490 continue 491 } 492 if val != test.out { 493 t.Errorf("ReadVarString #%d\n got: %s want: %s", i, 494 val, test.out) 495 continue 496 } 497 } 498} 499 500// TestVarStringWireErrors performs negative tests against wire encode and 501// decode of variable length strings to confirm error paths work correctly. 502func TestVarStringWireErrors(t *testing.T) { 503 pver := ProtocolVersion 504 505 // str256 is a string that takes a 2-byte varint to encode. 506 str256 := strings.Repeat("test", 64) 507 508 tests := []struct { 509 in string // Value to encode 510 buf []byte // Wire encoding 511 pver uint32 // Protocol version for wire encoding 512 max int // Max size of fixed buffer to induce errors 513 writeErr error // Expected write error 514 readErr error // Expected read error 515 }{ 516 // Latest protocol version with intentional read/write errors. 517 // Force errors on empty string. 518 {"", []byte{0x00}, pver, 0, io.ErrShortWrite, io.EOF}, 519 // Force error on single byte varint + string. 520 {"Test", []byte{0x04}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, 521 // Force errors on 2-byte varint + string. 522 {str256, []byte{0xfd}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, 523 } 524 525 t.Logf("Running %d tests", len(tests)) 526 for i, test := range tests { 527 // Encode to wire format. 528 w := newFixedWriter(test.max) 529 err := WriteVarString(w, test.pver, test.in) 530 if err != test.writeErr { 531 t.Errorf("WriteVarString #%d wrong error got: %v, want: %v", 532 i, err, test.writeErr) 533 continue 534 } 535 536 // Decode from wire format. 537 r := newFixedReader(test.max, test.buf) 538 _, err = ReadVarString(r, test.pver) 539 if err != test.readErr { 540 t.Errorf("ReadVarString #%d wrong error got: %v, want: %v", 541 i, err, test.readErr) 542 continue 543 } 544 } 545} 546 547// TestVarStringOverflowErrors performs tests to ensure deserializing variable 548// length strings intentionally crafted to use large values for the string 549// length are handled properly. This could otherwise potentially be used as an 550// attack vector. 551func TestVarStringOverflowErrors(t *testing.T) { 552 pver := ProtocolVersion 553 554 tests := []struct { 555 buf []byte // Wire encoding 556 pver uint32 // Protocol version for wire encoding 557 err error // Expected error 558 }{ 559 {[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 560 pver, &MessageError{}}, 561 {[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 562 pver, &MessageError{}}, 563 } 564 565 t.Logf("Running %d tests", len(tests)) 566 for i, test := range tests { 567 // Decode from wire format. 568 rbuf := bytes.NewReader(test.buf) 569 _, err := ReadVarString(rbuf, test.pver) 570 if reflect.TypeOf(err) != reflect.TypeOf(test.err) { 571 t.Errorf("ReadVarString #%d wrong error got: %v, "+ 572 "want: %v", i, err, reflect.TypeOf(test.err)) 573 continue 574 } 575 } 576 577} 578 579// TestVarBytesWire tests wire encode and decode for variable length byte array. 580func TestVarBytesWire(t *testing.T) { 581 pver := ProtocolVersion 582 583 // bytes256 is a byte array that takes a 2-byte varint to encode. 584 bytes256 := bytes.Repeat([]byte{0x01}, 256) 585 586 tests := []struct { 587 in []byte // Byte Array to write 588 buf []byte // Wire encoding 589 pver uint32 // Protocol version for wire encoding 590 }{ 591 // Latest protocol version. 592 // Empty byte array 593 {[]byte{}, []byte{0x00}, pver}, 594 // Single byte varint + byte array 595 {[]byte{0x01}, []byte{0x01, 0x01}, pver}, 596 // 2-byte varint + byte array 597 {bytes256, append([]byte{0xfd, 0x00, 0x01}, bytes256...), pver}, 598 } 599 600 t.Logf("Running %d tests", len(tests)) 601 for i, test := range tests { 602 // Encode to wire format. 603 var buf bytes.Buffer 604 err := WriteVarBytes(&buf, test.pver, test.in) 605 if err != nil { 606 t.Errorf("WriteVarBytes #%d error %v", i, err) 607 continue 608 } 609 if !bytes.Equal(buf.Bytes(), test.buf) { 610 t.Errorf("WriteVarBytes #%d\n got: %s want: %s", i, 611 spew.Sdump(buf.Bytes()), spew.Sdump(test.buf)) 612 continue 613 } 614 615 // Decode from wire format. 616 rbuf := bytes.NewReader(test.buf) 617 val, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload, 618 "test payload") 619 if err != nil { 620 t.Errorf("ReadVarBytes #%d error %v", i, err) 621 continue 622 } 623 if !bytes.Equal(buf.Bytes(), test.buf) { 624 t.Errorf("ReadVarBytes #%d\n got: %s want: %s", i, 625 val, test.buf) 626 continue 627 } 628 } 629} 630 631// TestVarBytesWireErrors performs negative tests against wire encode and 632// decode of variable length byte arrays to confirm error paths work correctly. 633func TestVarBytesWireErrors(t *testing.T) { 634 pver := ProtocolVersion 635 636 // bytes256 is a byte array that takes a 2-byte varint to encode. 637 bytes256 := bytes.Repeat([]byte{0x01}, 256) 638 639 tests := []struct { 640 in []byte // Byte Array to write 641 buf []byte // Wire encoding 642 pver uint32 // Protocol version for wire encoding 643 max int // Max size of fixed buffer to induce errors 644 writeErr error // Expected write error 645 readErr error // Expected read error 646 }{ 647 // Latest protocol version with intentional read/write errors. 648 // Force errors on empty byte array. 649 {[]byte{}, []byte{0x00}, pver, 0, io.ErrShortWrite, io.EOF}, 650 // Force error on single byte varint + byte array. 651 {[]byte{0x01, 0x02, 0x03}, []byte{0x04}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, 652 // Force errors on 2-byte varint + byte array. 653 {bytes256, []byte{0xfd}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, 654 } 655 656 t.Logf("Running %d tests", len(tests)) 657 for i, test := range tests { 658 // Encode to wire format. 659 w := newFixedWriter(test.max) 660 err := WriteVarBytes(w, test.pver, test.in) 661 if err != test.writeErr { 662 t.Errorf("WriteVarBytes #%d wrong error got: %v, want: %v", 663 i, err, test.writeErr) 664 continue 665 } 666 667 // Decode from wire format. 668 r := newFixedReader(test.max, test.buf) 669 _, err = ReadVarBytes(r, test.pver, MaxMessagePayload, 670 "test payload") 671 if err != test.readErr { 672 t.Errorf("ReadVarBytes #%d wrong error got: %v, want: %v", 673 i, err, test.readErr) 674 continue 675 } 676 } 677} 678 679// TestVarBytesOverflowErrors performs tests to ensure deserializing variable 680// length byte arrays intentionally crafted to use large values for the array 681// length are handled properly. This could otherwise potentially be used as an 682// attack vector. 683func TestVarBytesOverflowErrors(t *testing.T) { 684 pver := ProtocolVersion 685 686 tests := []struct { 687 buf []byte // Wire encoding 688 pver uint32 // Protocol version for wire encoding 689 err error // Expected error 690 }{ 691 {[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 692 pver, &MessageError{}}, 693 {[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 694 pver, &MessageError{}}, 695 } 696 697 t.Logf("Running %d tests", len(tests)) 698 for i, test := range tests { 699 // Decode from wire format. 700 rbuf := bytes.NewReader(test.buf) 701 _, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload, 702 "test payload") 703 if reflect.TypeOf(err) != reflect.TypeOf(test.err) { 704 t.Errorf("ReadVarBytes #%d wrong error got: %v, "+ 705 "want: %v", i, err, reflect.TypeOf(test.err)) 706 continue 707 } 708 } 709 710} 711 712// TestRandomUint64 exercises the randomness of the random number generator on 713// the system by ensuring the probability of the generated numbers. If the RNG 714// is evenly distributed as a proper cryptographic RNG should be, there really 715// should only be 1 number < 2^56 in 2^8 tries for a 64-bit number. However, 716// use a higher number of 5 to really ensure the test doesn't fail unless the 717// RNG is just horrendous. 718func TestRandomUint64(t *testing.T) { 719 tries := 1 << 8 // 2^8 720 watermark := uint64(1 << 56) // 2^56 721 maxHits := 5 722 badRNG := "The random number generator on this system is clearly " + 723 "terrible since we got %d values less than %d in %d runs " + 724 "when only %d was expected" 725 726 numHits := 0 727 for i := 0; i < tries; i++ { 728 nonce, err := RandomUint64() 729 if err != nil { 730 t.Errorf("RandomUint64 iteration %d failed - err %v", 731 i, err) 732 return 733 } 734 if nonce < watermark { 735 numHits++ 736 } 737 if numHits > maxHits { 738 str := fmt.Sprintf(badRNG, numHits, watermark, tries, maxHits) 739 t.Errorf("Random Uint64 iteration %d failed - %v %v", i, 740 str, numHits) 741 return 742 } 743 } 744} 745 746// TestRandomUint64Errors uses a fake reader to force error paths to be executed 747// and checks the results accordingly. 748func TestRandomUint64Errors(t *testing.T) { 749 // Test short reads. 750 fr := &fakeRandReader{n: 2, err: io.EOF} 751 nonce, err := randomUint64(fr) 752 if err != io.ErrUnexpectedEOF { 753 t.Errorf("Error not expected value of %v [%v]", 754 io.ErrUnexpectedEOF, err) 755 } 756 if nonce != 0 { 757 t.Errorf("Nonce is not 0 [%v]", nonce) 758 } 759} 760