Timemachine/mc-router
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Handle legacy server list ping for handshake

Browse Source
This commit is contained in:
Geoff Bourne
2019-07-13 15:40:34 -05:00
parent 3699931af0
commit 4c99daafa3
4 changed files with 300 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mcproto/read.go
+141 -14
View File
@@ -1,20 +1,38 @@
package mcproto
import (
"bufio"
"bytes"
"errors"
"encoding/binary"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
"golang.org/x/text/encoding/unicode"
"golang.org/x/text/transform"
"io"
"net"
"strings"
"time"
)
func ReadPacket(reader io.Reader, addr net.Addr) (*Packet, error) {
func ReadPacket(reader io.Reader, addr net.Addr, state State) (*Packet, error) {
logrus.
WithField("client", addr).
Debug("Reading packet")
if state == StateHandshaking {
bufReader := bufio.NewReader(reader)
data, err := bufReader.Peek(1)
if err != nil {
return nil, err
}
if data[0] == PacketIdLegacyServerListPing {
return ReadLegacyServerListPing(bufReader, addr)
} else {
reader = bufReader
}
}
frame, err := ReadFrame(reader, addr)
if err != nil {
return nil, err
@@ -38,6 +56,97 @@ func ReadPacket(reader io.Reader, addr net.Addr) (*Packet, error) {
return packet, nil
}
func ReadLegacyServerListPing(reader *bufio.Reader, addr net.Addr) (*Packet, error) {
logrus.
WithField("client", addr).
Debug("Reading legacy server list ping")
packetId, err := reader.ReadByte()
if err != nil {
return nil, err
}
if packetId != PacketIdLegacyServerListPing {
return nil, errors.Errorf("expected legacy server listing ping packet ID, got %x", packetId)
}
payload, err := reader.ReadByte()
if err != nil {
return nil, err
}
if payload != 0x01 {
return nil, errors.Errorf("expected payload=1 from legacy server listing ping, got %x", payload)
}
packetIdForPluginMsg, err := reader.ReadByte()
if err != nil {
return nil, err
}
if packetIdForPluginMsg != 0xFA {
return nil, errors.Errorf("expected packetIdForPluginMsg=0xFA from legacy server listing ping, got %x", packetIdForPluginMsg)
}
messageNameShortLen, err := ReadUnsignedShort(reader)
if err != nil {
return nil, err
}
if messageNameShortLen != 11 {
return nil, errors.Errorf("expected messageNameShortLen=11 from legacy server listing ping, got %d", messageNameShortLen)
}
messageName, err := ReadUTF16BEString(reader, messageNameShortLen)
if messageName != "MC|PingHost" {
return nil, errors.Errorf("expected messageName=MC|PingHost, got %s", messageName)
}
remainingLen, err := ReadUnsignedShort(reader)
remainingReader := io.LimitReader(reader, int64(remainingLen))
protocolVersion, err := ReadByte(remainingReader)
if err != nil {
return nil, err
}
hostnameLen, err := ReadUnsignedShort(remainingReader)
if err != nil {
return nil, err
}
hostname, err := ReadUTF16BEString(remainingReader, hostnameLen)
if err != nil {
return nil, err
}
port, err := ReadUnsignedInt(remainingReader)
if err != nil {
return nil, err
}
return &Packet{
PacketID: PacketIdLegacyServerListPing,
Length: 0,
Data: &LegacyServerListPing{
ProtocolVersion: int(protocolVersion),
ServerAddress: hostname,
ServerPort: uint16(port),
},
}, nil
}
func ReadUTF16BEString(reader io.Reader, symbolLen uint16) (string, error) {
bsUtf16be := make([]byte, symbolLen*2)
_, err := io.ReadFull(reader, bsUtf16be)
if err != nil {
return "", err
}
result, _, err := transform.Bytes(unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM).NewDecoder(), bsUtf16be)
if err != nil {
return "", err
}
return string(result), nil
}
func ReadFrame(reader io.Reader, addr net.Addr) (*Frame, error) {
logrus.
WithField("client", addr).
@@ -136,25 +245,43 @@ func ReadString(reader io.Reader) (string, error) {
return strBuilder.String(), nil
}
func ReadUnsignedShort(reader io.Reader) (uint16, error) {
upper := make([]byte, 1)
_, err := reader.Read(upper)
func ReadByte(reader io.Reader) (byte, error) {
buf := make([]byte, 1)
_, err := reader.Read(buf)
if err != nil {
return 0, err
} else {
return buf[0], nil
}
lower := make([]byte, 1)
_, err = reader.Read(lower)
if err != nil {
return 0, err
}
return (uint16(upper[0]) << 8) | uint16(lower[0]), nil
}
func ReadHandshake(data []byte) (*Handshake, error) {
func ReadUnsignedShort(reader io.Reader) (uint16, error) {
var value uint16
err := binary.Read(reader, binary.BigEndian, &value)
if err != nil {
return 0, err
}
return value, nil
}
func ReadUnsignedInt(reader io.Reader) (uint32, error) {
var value uint32
err := binary.Read(reader, binary.BigEndian, &value)
if err != nil {
return 0, err
}
return value, nil
}
func ReadHandshake(data interface{}) (*Handshake, error) {
dataBytes, ok := data.([]byte)
if !ok {
return nil, errors.New("data is not expected byte slice")
}
handshake := &Handshake{}
buffer := bytes.NewBuffer(data)
buffer := bytes.NewBuffer(dataBytes)
var err error
handshake.ProtocolVersion, err = ReadVarInt(buffer)
mcproto/read_test.go
+36
View File
@@ -0,0 +1,36 @@
package mcproto
import (
"bytes"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"testing"
)
func TestReadVarInt(t *testing.T) {
tests := []struct {
Name string
Input []byte
Expected int
}{
{
Name: "Single byte",
Input: []byte{0xFA, 0x00},
Expected: 0x7A,
},
{
Name: "Two byte",
Input: []byte{0x81, 0x04},
Expected: 0x0201,
},
}
for _, tt := range tests {
t.Run(tt.Name, func(t *testing.T) {
result, err := ReadVarInt(bytes.NewBuffer(tt.Input))
require.NoError(t, err)
assert.Equal(t, tt.Expected, result)
})
}
}
mcproto/types.go
+24 -4
View File
@@ -7,6 +7,12 @@ type Frame struct {
Payload []byte
}
type State int
const (
StateHandshaking = iota
)
var trimLimit = 64
func trimBytes(data []byte) ([]byte, string) {
@@ -25,15 +31,23 @@ func (f *Frame) String() string {
type Packet struct {
Length int
PacketID int
Data []byte
// Data is either a byte slice of raw content or a parsed message
Data interface{}
}
func (p *Packet) String() string {
trimmed, cont := trimBytes(p.Data)
return fmt.Sprintf("Frame:[len=%d, packetId=%d, data=%#X%s]", p.Length, p.PacketID, trimmed, cont)
if dataBytes, ok := p.Data.([]byte); ok {
trimmed, cont := trimBytes(dataBytes)
return fmt.Sprintf("Frame:[len=%d, packetId=%d, data=%#X%s]", p.Length, p.PacketID, trimmed, cont)
} else {
return fmt.Sprintf("Frame:[len=%d, packetId=%d, data=%+v]", p.Length, p.PacketID, p.Data)
}
}
const PacketIdHandshake = 0x00
const (
PacketIdHandshake = 0x00
PacketIdLegacyServerListPing = 0xFE
)
type Handshake struct {
ProtocolVersion int
@@ -42,6 +56,12 @@ type Handshake struct {
NextState int
}
type LegacyServerListPing struct {
ProtocolVersion int
ServerAddress string
ServerPort uint16
}
type ByteReader interface {
ReadByte() (byte, error)
}