neoneo-go/pkg/network/message.go

254 lines
5.3 KiB
Go
Raw Normal View History

2018-01-26 18:04:13 +00:00
package network
import (
"bytes"
"crypto/sha256"
"encoding/binary"
"errors"
2018-01-28 10:12:05 +00:00
"fmt"
2018-01-26 18:04:13 +00:00
"io"
2018-01-27 15:00:28 +00:00
"github.com/anthdm/neo-go/pkg/core"
2018-01-27 15:00:28 +00:00
"github.com/anthdm/neo-go/pkg/network/payload"
2018-01-26 18:04:13 +00:00
)
2018-01-26 20:39:34 +00:00
const (
// The minimum size of a valid message.
minMessageSize = 24
2018-01-28 15:06:41 +00:00
cmdSize = 12
2018-01-26 20:39:34 +00:00
)
var (
errChecksumMismatch = errors.New("checksum mismatch")
)
2018-01-26 20:39:34 +00:00
// NetMode type that is compatible with netModes below.
type NetMode uint32
// String implements the stringer interface.
func (n NetMode) String() string {
switch n {
case ModeDevNet:
return "devnet"
case ModeTestNet:
return "testnet"
case ModeMainNet:
return "mainnet"
default:
return ""
}
}
2018-01-26 18:04:13 +00:00
// Values used for the magic field, according to the docs.
const (
2018-01-26 20:39:34 +00:00
ModeMainNet NetMode = 0x00746e41 // 7630401
ModeTestNet = 0x74746e41 // 1953787457
ModeDevNet = 56753 // docker privnet
2018-01-26 18:04:13 +00:00
)
// Message is the complete message send between nodes.
type Message struct {
2018-01-26 20:39:34 +00:00
Magic NetMode
2018-01-26 18:04:13 +00:00
// Command is utf8 code, of which the length is 12 bytes,
// the extra part is filled with 0.
2018-01-28 15:06:41 +00:00
Command [cmdSize]byte
2018-01-26 18:04:13 +00:00
// Length of the payload
Length uint32
// Checksum is the first 4 bytes of the value that two times SHA256
// hash of the payload
Checksum uint32
// Payload send with the message.
2018-01-28 15:06:41 +00:00
Payload payload.Payload
2018-01-26 18:04:13 +00:00
}
type commandType string
// valid commands used to send between nodes.
const (
cmdVersion commandType = "version"
cmdVerack = "verack"
cmdGetAddr = "getaddr"
cmdAddr = "addr"
cmdGetHeaders = "getheaders"
cmdHeaders = "headers"
cmdGetBlocks = "getblocks"
cmdInv = "inv"
cmdGetData = "getdata"
cmdBlock = "block"
cmdTX = "tx"
2018-01-30 10:56:36 +00:00
cmdConsensus = "consensus"
2018-01-26 18:04:13 +00:00
)
2018-01-28 15:06:41 +00:00
func newMessage(magic NetMode, cmd commandType, p payload.Payload) *Message {
2018-01-28 07:03:18 +00:00
var (
size uint32
checksum []byte
)
2018-01-27 15:00:28 +00:00
if p != nil {
2018-01-28 15:06:41 +00:00
buf := new(bytes.Buffer)
if err := p.EncodeBinary(buf); err != nil {
panic(err)
}
size = uint32(buf.Len())
2018-01-28 15:06:41 +00:00
checksum = sumSHA256(sumSHA256(buf.Bytes()))
2018-01-28 07:03:18 +00:00
} else {
checksum = sumSHA256(sumSHA256([]byte{}))
2018-01-27 15:00:28 +00:00
}
2018-01-28 07:03:18 +00:00
2018-01-26 18:04:13 +00:00
return &Message{
2018-01-28 07:03:18 +00:00
Magic: magic,
2018-01-28 15:06:41 +00:00
Command: cmdToByteArray(cmd),
2018-01-28 07:03:18 +00:00
Length: size,
Payload: p,
Checksum: binary.LittleEndian.Uint32(checksum[:4]),
2018-01-27 15:00:28 +00:00
}
}
2018-01-26 18:04:13 +00:00
// Converts the 12 byte command slice to a commandType.
func (m *Message) commandType() commandType {
2018-01-28 15:06:41 +00:00
cmd := cmdByteArrayToString(m.Command)
2018-01-26 18:04:13 +00:00
switch cmd {
case "version":
return cmdVersion
case "verack":
return cmdVerack
2018-01-27 07:37:07 +00:00
case "getaddr":
return cmdGetAddr
2018-01-26 18:04:13 +00:00
case "addr":
return cmdAddr
case "getheaders":
return cmdGetHeaders
case "header":
return cmdHeaders
case "getblocks":
return cmdGetBlocks
case "inv":
return cmdInv
case "getdata":
return cmdGetData
case "block":
return cmdBlock
case "tx":
return cmdTX
2018-01-30 10:56:36 +00:00
case "consensus":
return cmdConsensus
2018-01-26 18:04:13 +00:00
default:
return ""
}
}
// decode a Message from the given reader.
func (m *Message) decode(r io.Reader) error {
2018-01-28 15:06:41 +00:00
binary.Read(r, binary.LittleEndian, &m.Magic)
binary.Read(r, binary.LittleEndian, &m.Command)
binary.Read(r, binary.LittleEndian, &m.Length)
binary.Read(r, binary.LittleEndian, &m.Checksum)
2018-01-26 18:04:13 +00:00
2018-01-28 07:03:18 +00:00
// return if their is no payload.
if m.Length == 0 {
2018-01-27 15:00:28 +00:00
return nil
}
2018-01-28 15:06:41 +00:00
return m.decodePayload(r)
2018-01-27 15:47:43 +00:00
}
2018-01-28 15:06:41 +00:00
func (m *Message) decodePayload(r io.Reader) error {
buf := make([]byte, m.Length)
n, err := r.Read(buf)
2018-01-28 10:12:05 +00:00
if err != nil {
2018-01-28 07:03:18 +00:00
return err
}
2018-01-28 10:12:05 +00:00
if uint32(n) != m.Length {
return fmt.Errorf("expected to have read exactly %d bytes got %d", m.Length, n)
}
2018-01-28 07:03:18 +00:00
// Compare the checksum of the payload.
if !compareChecksum(m.Checksum, buf) {
return errChecksumMismatch
2018-01-28 07:03:18 +00:00
}
2018-01-27 15:00:28 +00:00
r = bytes.NewReader(buf)
2018-01-28 15:06:41 +00:00
var p payload.Payload
2018-01-27 15:00:28 +00:00
switch m.commandType() {
case cmdVersion:
p = &payload.Version{}
2018-01-28 17:42:22 +00:00
if err := p.DecodeBinary(r); err != nil {
return err
}
case cmdInv:
p = &payload.Inventory{}
if err := p.DecodeBinary(r); err != nil {
2018-01-28 10:12:05 +00:00
return err
}
2018-01-28 15:18:48 +00:00
case cmdAddr:
p = &payload.AddressList{}
2018-01-28 17:42:22 +00:00
if err := p.DecodeBinary(r); err != nil {
2018-01-28 15:18:48 +00:00
return err
}
case cmdBlock:
p = &core.Block{}
if err := p.DecodeBinary(r); err != nil {
return err
}
2018-01-26 18:04:13 +00:00
}
2018-01-27 15:00:28 +00:00
m.Payload = p
2018-01-26 18:04:13 +00:00
return nil
}
// encode a Message to any given io.Writer.
func (m *Message) encode(w io.Writer) error {
2018-01-28 15:06:41 +00:00
binary.Write(w, binary.LittleEndian, m.Magic)
binary.Write(w, binary.LittleEndian, m.Command)
binary.Write(w, binary.LittleEndian, m.Length)
binary.Write(w, binary.LittleEndian, m.Checksum)
2018-01-26 18:04:13 +00:00
2018-01-28 07:03:18 +00:00
if m.Payload != nil {
2018-01-28 15:06:41 +00:00
return m.Payload.EncodeBinary(w)
2018-01-28 10:12:05 +00:00
}
2018-01-27 15:00:28 +00:00
return nil
2018-01-26 18:04:13 +00:00
}
// convert a command (string) to a byte slice filled with 0 bytes till
// size 12.
2018-01-28 15:06:41 +00:00
func cmdToByteArray(cmd commandType) [cmdSize]byte {
2018-01-26 18:04:13 +00:00
cmdLen := len(cmd)
2018-01-28 15:06:41 +00:00
if cmdLen > cmdSize {
2018-01-26 18:04:13 +00:00
panic("exceeded command max length of size 12")
}
// The command can have max 12 bytes, rest is filled with 0.
2018-01-28 15:06:41 +00:00
b := [cmdSize]byte{}
for i := 0; i < cmdLen; i++ {
b[i] = cmd[i]
2018-01-26 18:04:13 +00:00
}
return b
}
2018-01-28 15:06:41 +00:00
func cmdByteArrayToString(cmd [cmdSize]byte) string {
buf := []byte{}
for i := 0; i < cmdSize; i++ {
if cmd[i] != 0 {
buf = append(buf, cmd[i])
}
}
return string(buf)
}
2018-01-26 18:04:13 +00:00
func sumSHA256(b []byte) []byte {
h := sha256.New()
h.Write(b)
return h.Sum(nil)
}
func compareChecksum(have uint32, b []byte) bool {
sum := sumSHA256(sumSHA256(b))[:4]
want := binary.LittleEndian.Uint32(sum)
return have == want
}