690 lines
17 KiB
Go
690 lines
17 KiB
Go
// Copyright (c) 2013-2016 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package wire
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
"math"
|
|
"time"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
)
|
|
|
|
const (
|
|
// MaxVarIntPayload is the maximum payload size for a variable length integer.
|
|
MaxVarIntPayload = 9
|
|
|
|
// binaryFreeListMaxItems is the number of buffers to keep in the free
|
|
// list to use for binary serialization and deserialization.
|
|
binaryFreeListMaxItems = 1024
|
|
)
|
|
|
|
var (
|
|
// littleEndian is a convenience variable since binary.LittleEndian is
|
|
// quite long.
|
|
littleEndian = binary.LittleEndian
|
|
|
|
// bigEndian is a convenience variable since binary.BigEndian is quite
|
|
// long.
|
|
bigEndian = binary.BigEndian
|
|
)
|
|
|
|
// binaryFreeList defines a concurrent safe free list of byte slices (up to the
|
|
// maximum number defined by the binaryFreeListMaxItems constant) that have a
|
|
// cap of 8 (thus it supports up to a uint64). It is used to provide temporary
|
|
// buffers for serializing and deserializing primitive numbers to and from their
|
|
// binary encoding in order to greatly reduce the number of allocations
|
|
// required.
|
|
//
|
|
// For convenience, functions are provided for each of the primitive unsigned
|
|
// integers that automatically obtain a buffer from the free list, perform the
|
|
// necessary binary conversion, read from or write to the given io.Reader or
|
|
// io.Writer, and return the buffer to the free list.
|
|
type binaryFreeList chan []byte
|
|
|
|
// Borrow returns a byte slice from the free list with a length of 8. A new
|
|
// buffer is allocated if there are not any available on the free list.
|
|
func (l binaryFreeList) Borrow() []byte {
|
|
var buf []byte
|
|
select {
|
|
case buf = <-l:
|
|
default:
|
|
buf = make([]byte, 8)
|
|
}
|
|
return buf[:8]
|
|
}
|
|
|
|
// Return puts the provided byte slice back on the free list. The buffer MUST
|
|
// have been obtained via the Borrow function and therefore have a cap of 8.
|
|
func (l binaryFreeList) Return(buf []byte) {
|
|
select {
|
|
case l <- buf:
|
|
default:
|
|
// Let it go to the garbage collector.
|
|
}
|
|
}
|
|
|
|
// Uint8 reads a single byte from the provided reader using a buffer from the
|
|
// free list and returns it as a uint8.
|
|
func (l binaryFreeList) Uint8(r io.Reader) (uint8, error) {
|
|
buf := l.Borrow()[:1]
|
|
if _, err := io.ReadFull(r, buf); err != nil {
|
|
l.Return(buf)
|
|
return 0, err
|
|
}
|
|
rv := buf[0]
|
|
l.Return(buf)
|
|
return rv, nil
|
|
}
|
|
|
|
// Uint16 reads two bytes from the provided reader using a buffer from the
|
|
// free list, converts it to a number using the provided byte order, and returns
|
|
// the resulting uint16.
|
|
func (l binaryFreeList) Uint16(r io.Reader, byteOrder binary.ByteOrder) (uint16, error) {
|
|
buf := l.Borrow()[:2]
|
|
if _, err := io.ReadFull(r, buf); err != nil {
|
|
l.Return(buf)
|
|
return 0, err
|
|
}
|
|
rv := byteOrder.Uint16(buf)
|
|
l.Return(buf)
|
|
return rv, nil
|
|
}
|
|
|
|
// Uint32 reads four bytes from the provided reader using a buffer from the
|
|
// free list, converts it to a number using the provided byte order, and returns
|
|
// the resulting uint32.
|
|
func (l binaryFreeList) Uint32(r io.Reader, byteOrder binary.ByteOrder) (uint32, error) {
|
|
buf := l.Borrow()[:4]
|
|
if _, err := io.ReadFull(r, buf); err != nil {
|
|
l.Return(buf)
|
|
return 0, err
|
|
}
|
|
rv := byteOrder.Uint32(buf)
|
|
l.Return(buf)
|
|
return rv, nil
|
|
}
|
|
|
|
// Uint64 reads eight bytes from the provided reader using a buffer from the
|
|
// free list, converts it to a number using the provided byte order, and returns
|
|
// the resulting uint64.
|
|
func (l binaryFreeList) Uint64(r io.Reader, byteOrder binary.ByteOrder) (uint64, error) {
|
|
buf := l.Borrow()[:8]
|
|
if _, err := io.ReadFull(r, buf); err != nil {
|
|
l.Return(buf)
|
|
return 0, err
|
|
}
|
|
rv := byteOrder.Uint64(buf)
|
|
l.Return(buf)
|
|
return rv, nil
|
|
}
|
|
|
|
// PutUint8 copies the provided uint8 into a buffer from the free list and
|
|
// writes the resulting byte to the given writer.
|
|
func (l binaryFreeList) PutUint8(w io.Writer, val uint8) error {
|
|
buf := l.Borrow()[:1]
|
|
buf[0] = val
|
|
_, err := w.Write(buf)
|
|
l.Return(buf)
|
|
return err
|
|
}
|
|
|
|
// PutUint16 serializes the provided uint16 using the given byte order into a
|
|
// buffer from the free list and writes the resulting two bytes to the given
|
|
// writer.
|
|
func (l binaryFreeList) PutUint16(w io.Writer, byteOrder binary.ByteOrder, val uint16) error {
|
|
buf := l.Borrow()[:2]
|
|
byteOrder.PutUint16(buf, val)
|
|
_, err := w.Write(buf)
|
|
l.Return(buf)
|
|
return err
|
|
}
|
|
|
|
// PutUint32 serializes the provided uint32 using the given byte order into a
|
|
// buffer from the free list and writes the resulting four bytes to the given
|
|
// writer.
|
|
func (l binaryFreeList) PutUint32(w io.Writer, byteOrder binary.ByteOrder, val uint32) error {
|
|
buf := l.Borrow()[:4]
|
|
byteOrder.PutUint32(buf, val)
|
|
_, err := w.Write(buf)
|
|
l.Return(buf)
|
|
return err
|
|
}
|
|
|
|
// PutUint64 serializes the provided uint64 using the given byte order into a
|
|
// buffer from the free list and writes the resulting eight bytes to the given
|
|
// writer.
|
|
func (l binaryFreeList) PutUint64(w io.Writer, byteOrder binary.ByteOrder, val uint64) error {
|
|
buf := l.Borrow()[:8]
|
|
byteOrder.PutUint64(buf, val)
|
|
_, err := w.Write(buf)
|
|
l.Return(buf)
|
|
return err
|
|
}
|
|
|
|
// binarySerializer provides a free list of buffers to use for serializing and
|
|
// deserializing primitive integer values to and from io.Readers and io.Writers.
|
|
var binarySerializer binaryFreeList = make(chan []byte, binaryFreeListMaxItems)
|
|
|
|
// errNonCanonicalVarInt is the common format string used for non-canonically
|
|
// encoded variable length integer errors.
|
|
var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
|
|
"encode a value greater than %x"
|
|
|
|
// uint32Time represents a unix timestamp encoded with a uint32. It is used as
|
|
// a way to signal the readElement function how to decode a timestamp into a Go
|
|
// time.Time since it is otherwise ambiguous.
|
|
type uint32Time time.Time
|
|
|
|
// int64Time represents a unix timestamp encoded with an int64. It is used as
|
|
// a way to signal the readElement function how to decode a timestamp into a Go
|
|
// time.Time since it is otherwise ambiguous.
|
|
type int64Time time.Time
|
|
|
|
// readElement reads the next sequence of bytes from r using little endian
|
|
// depending on the concrete type of element pointed to.
|
|
func readElement(r io.Reader, element interface{}) error {
|
|
// Attempt to read the element based on the concrete type via fast
|
|
// type assertions first.
|
|
switch e := element.(type) {
|
|
case *int32:
|
|
rv, err := binarySerializer.Uint32(r, littleEndian)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = int32(rv)
|
|
return nil
|
|
|
|
case *uint32:
|
|
rv, err := binarySerializer.Uint32(r, littleEndian)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = rv
|
|
return nil
|
|
|
|
case *int64:
|
|
rv, err := binarySerializer.Uint64(r, littleEndian)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = int64(rv)
|
|
return nil
|
|
|
|
case *uint64:
|
|
rv, err := binarySerializer.Uint64(r, littleEndian)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = rv
|
|
return nil
|
|
|
|
case *bool:
|
|
rv, err := binarySerializer.Uint8(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if rv == 0x00 {
|
|
*e = false
|
|
} else {
|
|
*e = true
|
|
}
|
|
return nil
|
|
|
|
// Unix timestamp encoded as a uint32.
|
|
case *uint32Time:
|
|
rv, err := binarySerializer.Uint32(r, binary.LittleEndian)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = uint32Time(time.Unix(int64(rv), 0))
|
|
return nil
|
|
|
|
// Unix timestamp encoded as an int64.
|
|
case *int64Time:
|
|
rv, err := binarySerializer.Uint64(r, binary.LittleEndian)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = int64Time(time.Unix(int64(rv), 0))
|
|
return nil
|
|
|
|
// Message header checksum.
|
|
case *[4]byte:
|
|
_, err := io.ReadFull(r, e[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
// Message header command.
|
|
case *[CommandSize]uint8:
|
|
_, err := io.ReadFull(r, e[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
// IP address.
|
|
case *[16]byte:
|
|
_, err := io.ReadFull(r, e[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case *chainhash.Hash:
|
|
_, err := io.ReadFull(r, e[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case *ServiceFlag:
|
|
rv, err := binarySerializer.Uint64(r, littleEndian)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = ServiceFlag(rv)
|
|
return nil
|
|
|
|
case *InvType:
|
|
rv, err := binarySerializer.Uint32(r, littleEndian)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = InvType(rv)
|
|
return nil
|
|
|
|
case *BitcoinNet:
|
|
rv, err := binarySerializer.Uint32(r, littleEndian)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = BitcoinNet(rv)
|
|
return nil
|
|
|
|
case *BloomUpdateType:
|
|
rv, err := binarySerializer.Uint8(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = BloomUpdateType(rv)
|
|
return nil
|
|
|
|
case *RejectCode:
|
|
rv, err := binarySerializer.Uint8(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*e = RejectCode(rv)
|
|
return nil
|
|
}
|
|
|
|
// Fall back to the slower binary.Read if a fast path was not available
|
|
// above.
|
|
return binary.Read(r, littleEndian, element)
|
|
}
|
|
|
|
// readElements reads multiple items from r. It is equivalent to multiple
|
|
// calls to readElement.
|
|
func readElements(r io.Reader, elements ...interface{}) error {
|
|
for _, element := range elements {
|
|
err := readElement(r, element)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// writeElement writes the little endian representation of element to w.
|
|
func writeElement(w io.Writer, element interface{}) error {
|
|
// Attempt to write the element based on the concrete type via fast
|
|
// type assertions first.
|
|
switch e := element.(type) {
|
|
case int32:
|
|
err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case uint32:
|
|
err := binarySerializer.PutUint32(w, littleEndian, e)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case int64:
|
|
err := binarySerializer.PutUint64(w, littleEndian, uint64(e))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case uint64:
|
|
err := binarySerializer.PutUint64(w, littleEndian, e)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case bool:
|
|
var err error
|
|
if e {
|
|
err = binarySerializer.PutUint8(w, 0x01)
|
|
} else {
|
|
err = binarySerializer.PutUint8(w, 0x00)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
// Message header checksum.
|
|
case [4]byte:
|
|
_, err := w.Write(e[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
// Message header command.
|
|
case [CommandSize]uint8:
|
|
_, err := w.Write(e[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
// IP address.
|
|
case [16]byte:
|
|
_, err := w.Write(e[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case *chainhash.Hash:
|
|
_, err := w.Write(e[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case ServiceFlag:
|
|
err := binarySerializer.PutUint64(w, littleEndian, uint64(e))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case InvType:
|
|
err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case BitcoinNet:
|
|
err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case BloomUpdateType:
|
|
err := binarySerializer.PutUint8(w, uint8(e))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
|
|
case RejectCode:
|
|
err := binarySerializer.PutUint8(w, uint8(e))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Fall back to the slower binary.Write if a fast path was not available
|
|
// above.
|
|
return binary.Write(w, littleEndian, element)
|
|
}
|
|
|
|
// writeElements writes multiple items to w. It is equivalent to multiple
|
|
// calls to writeElement.
|
|
func writeElements(w io.Writer, elements ...interface{}) error {
|
|
for _, element := range elements {
|
|
err := writeElement(w, element)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ReadVarInt reads a variable length integer from r and returns it as a uint64.
|
|
func ReadVarInt(r io.Reader, pver uint32) (uint64, error) {
|
|
discriminant, err := binarySerializer.Uint8(r)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
var rv uint64
|
|
switch discriminant {
|
|
case 0xff:
|
|
sv, err := binarySerializer.Uint64(r, littleEndian)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
rv = sv
|
|
|
|
// The encoding is not canonical if the value could have been
|
|
// encoded using fewer bytes.
|
|
min := uint64(0x100000000)
|
|
if rv < min {
|
|
return 0, messageError("ReadVarInt", fmt.Sprintf(
|
|
errNonCanonicalVarInt, rv, discriminant, min))
|
|
}
|
|
|
|
case 0xfe:
|
|
sv, err := binarySerializer.Uint32(r, littleEndian)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
rv = uint64(sv)
|
|
|
|
// The encoding is not canonical if the value could have been
|
|
// encoded using fewer bytes.
|
|
min := uint64(0x10000)
|
|
if rv < min {
|
|
return 0, messageError("ReadVarInt", fmt.Sprintf(
|
|
errNonCanonicalVarInt, rv, discriminant, min))
|
|
}
|
|
|
|
case 0xfd:
|
|
sv, err := binarySerializer.Uint16(r, littleEndian)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
rv = uint64(sv)
|
|
|
|
// The encoding is not canonical if the value could have been
|
|
// encoded using fewer bytes.
|
|
min := uint64(0xfd)
|
|
if rv < min {
|
|
return 0, messageError("ReadVarInt", fmt.Sprintf(
|
|
errNonCanonicalVarInt, rv, discriminant, min))
|
|
}
|
|
|
|
default:
|
|
rv = uint64(discriminant)
|
|
}
|
|
|
|
return rv, nil
|
|
}
|
|
|
|
// WriteVarInt serializes val to w using a variable number of bytes depending
|
|
// on its value.
|
|
func WriteVarInt(w io.Writer, pver uint32, val uint64) error {
|
|
if val < 0xfd {
|
|
return binarySerializer.PutUint8(w, uint8(val))
|
|
}
|
|
|
|
if val <= math.MaxUint16 {
|
|
err := binarySerializer.PutUint8(w, 0xfd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return binarySerializer.PutUint16(w, littleEndian, uint16(val))
|
|
}
|
|
|
|
if val <= math.MaxUint32 {
|
|
err := binarySerializer.PutUint8(w, 0xfe)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return binarySerializer.PutUint32(w, littleEndian, uint32(val))
|
|
}
|
|
|
|
err := binarySerializer.PutUint8(w, 0xff)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return binarySerializer.PutUint64(w, littleEndian, val)
|
|
}
|
|
|
|
// VarIntSerializeSize returns the number of bytes it would take to serialize
|
|
// val as a variable length integer.
|
|
func VarIntSerializeSize(val uint64) int {
|
|
// The value is small enough to be represented by itself, so it's
|
|
// just 1 byte.
|
|
if val < 0xfd {
|
|
return 1
|
|
}
|
|
|
|
// Discriminant 1 byte plus 2 bytes for the uint16.
|
|
if val <= math.MaxUint16 {
|
|
return 3
|
|
}
|
|
|
|
// Discriminant 1 byte plus 4 bytes for the uint32.
|
|
if val <= math.MaxUint32 {
|
|
return 5
|
|
}
|
|
|
|
// Discriminant 1 byte plus 8 bytes for the uint64.
|
|
return 9
|
|
}
|
|
|
|
// ReadVarString reads a variable length string from r and returns it as a Go
|
|
// string. A variable length string is encoded as a variable length integer
|
|
// containing the length of the string followed by the bytes that represent the
|
|
// string itself. An error is returned if the length is greater than the
|
|
// maximum block payload size since it helps protect against memory exhaustion
|
|
// attacks and forced panics through malformed messages.
|
|
func ReadVarString(r io.Reader, pver uint32) (string, error) {
|
|
count, err := ReadVarInt(r, pver)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Prevent variable length strings that are larger than the maximum
|
|
// message size. It would be possible to cause memory exhaustion and
|
|
// panics without a sane upper bound on this count.
|
|
if count > MaxMessagePayload {
|
|
str := fmt.Sprintf("variable length string is too long "+
|
|
"[count %d, max %d]", count, MaxMessagePayload)
|
|
return "", messageError("ReadVarString", str)
|
|
}
|
|
|
|
buf := make([]byte, count)
|
|
_, err = io.ReadFull(r, buf)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(buf), nil
|
|
}
|
|
|
|
// WriteVarString serializes str to w as a variable length integer containing
|
|
// the length of the string followed by the bytes that represent the string
|
|
// itself.
|
|
func WriteVarString(w io.Writer, pver uint32, str string) error {
|
|
err := WriteVarInt(w, pver, uint64(len(str)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = w.Write([]byte(str))
|
|
return err
|
|
}
|
|
|
|
// ReadVarBytes reads a variable length byte array. A byte array is encoded
|
|
// as a varInt containing the length of the array followed by the bytes
|
|
// themselves. An error is returned if the length is greater than the
|
|
// passed maxAllowed parameter which helps protect against memory exhaustion
|
|
// attacks and forced panics through malformed messages. The fieldName
|
|
// parameter is only used for the error message so it provides more context in
|
|
// the error.
|
|
func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32,
|
|
fieldName string) ([]byte, error) {
|
|
|
|
count, err := ReadVarInt(r, pver)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Prevent byte array larger than the max message size. It would
|
|
// be possible to cause memory exhaustion and panics without a sane
|
|
// upper bound on this count.
|
|
if count > uint64(maxAllowed) {
|
|
str := fmt.Sprintf("%s is larger than the max allowed size "+
|
|
"[count %d, max %d]", fieldName, count, maxAllowed)
|
|
return nil, messageError("ReadVarBytes", str)
|
|
}
|
|
|
|
b := make([]byte, count)
|
|
_, err = io.ReadFull(r, b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b, nil
|
|
}
|
|
|
|
// WriteVarBytes serializes a variable length byte array to w as a varInt
|
|
// containing the number of bytes, followed by the bytes themselves.
|
|
func WriteVarBytes(w io.Writer, pver uint32, bytes []byte) error {
|
|
slen := uint64(len(bytes))
|
|
err := WriteVarInt(w, pver, slen)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = w.Write(bytes)
|
|
return err
|
|
}
|
|
|
|
// randomUint64 returns a cryptographically random uint64 value. This
|
|
// unexported version takes a reader primarily to ensure the error paths
|
|
// can be properly tested by passing a fake reader in the tests.
|
|
func randomUint64(r io.Reader) (uint64, error) {
|
|
rv, err := binarySerializer.Uint64(r, bigEndian)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return rv, nil
|
|
}
|
|
|
|
// RandomUint64 returns a cryptographically random uint64 value.
|
|
func RandomUint64() (uint64, error) {
|
|
return randomUint64(rand.Reader)
|
|
}
|