435 lines
11 KiB
Go
435 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
HandshakePacketID = 0x00
|
|
StatusRequestID = 0x00
|
|
StatusResponseID = 0x00
|
|
PingRequestID = 0x01
|
|
PongResponseID = 0x01
|
|
LoginPluginResponseID = 0x02
|
|
LoginAcknowledgedID = 0x03
|
|
)
|
|
|
|
type PrefixedByteArray struct {
|
|
Length int
|
|
Data []byte
|
|
}
|
|
|
|
type HandshakePacket struct {
|
|
ProtocolVersion int
|
|
ServerAddress string
|
|
ServerPort uint16
|
|
NextState int
|
|
}
|
|
|
|
type LoginStartPacket struct {
|
|
Name string
|
|
UUID string
|
|
}
|
|
|
|
type StatusResponse struct {
|
|
Version VersionInfo `json:"version"`
|
|
Players PlayerInfo `json:"players"`
|
|
Description Chat `json:"description"`
|
|
}
|
|
|
|
type VersionInfo struct {
|
|
Name string `json:"name"`
|
|
Protocol int `json:"protocol"`
|
|
}
|
|
|
|
type PlayerInfo struct {
|
|
Max int `json:"max"`
|
|
Online int `json:"online"`
|
|
Sample []Player `json:"sample"`
|
|
}
|
|
|
|
type Player struct {
|
|
Name string `json:"name"`
|
|
ID string `json:"id"`
|
|
}
|
|
|
|
type Property struct {
|
|
Name string `json:"name"`
|
|
Value string `json:"value"`
|
|
Signature string `json:"signature,omitempty"` // Optional field
|
|
}
|
|
|
|
type Chat struct {
|
|
Text string `json:"text"`
|
|
}
|
|
|
|
type ClientState struct {
|
|
conn net.Conn
|
|
nextState int
|
|
}
|
|
|
|
func main() {
|
|
listener, err := net.Listen("tcp", "localhost:25565")
|
|
if err != nil {
|
|
fmt.Println("Error starting server:", err)
|
|
return
|
|
}
|
|
defer listener.Close()
|
|
|
|
fmt.Println("Server started on port 25565")
|
|
|
|
for {
|
|
conn, err := listener.Accept()
|
|
if err != nil {
|
|
fmt.Println("Error accepting connection:", err)
|
|
continue
|
|
}
|
|
|
|
client := &ClientState{conn: conn, nextState: 0}
|
|
go handleConnection(client)
|
|
}
|
|
}
|
|
|
|
func handleConnection(client *ClientState) {
|
|
defer client.conn.Close()
|
|
fmt.Println("New connection from:", client.conn.RemoteAddr())
|
|
|
|
buf := make([]byte, 1024)
|
|
for {
|
|
n, err := client.conn.Read(buf)
|
|
if err != nil {
|
|
if err.Error() == "EOF" {
|
|
fmt.Println("Client disconnected:", client.conn.RemoteAddr())
|
|
} else {
|
|
fmt.Println("Error reading from client:", err)
|
|
}
|
|
break
|
|
}
|
|
|
|
reader := bytes.NewReader(buf[:n])
|
|
|
|
fmt.Println("Received data:", buf[:n])
|
|
|
|
// Read packet length
|
|
packetLength, err := readVarInt(reader)
|
|
if err != nil {
|
|
fmt.Println("Error reading packet length:", err)
|
|
break
|
|
}
|
|
|
|
// Ensure full packet is read
|
|
packetData := make([]byte, packetLength)
|
|
if _, err := io.ReadFull(reader, packetData); err != nil {
|
|
fmt.Println("Error reading full packet data:", err)
|
|
break
|
|
}
|
|
|
|
packetReader := bytes.NewReader(packetData)
|
|
|
|
packetID, err := readVarInt(packetReader)
|
|
if err != nil {
|
|
fmt.Println("Error reading packet ID:", err)
|
|
break
|
|
}
|
|
|
|
fmt.Println("Packet ID:", packetID)
|
|
|
|
switch packetID {
|
|
case HandshakePacketID: // The same packet ID is used for the Status Request
|
|
if client.nextState == 1 {
|
|
handleStatusRequest(client)
|
|
} else if client.nextState == 2 {
|
|
fmt.Println("Received Login Start")
|
|
|
|
// Login Start
|
|
loginStart, err := handleLoginStart(packetReader)
|
|
if err != nil {
|
|
fmt.Println("Error processing login start:", err)
|
|
return
|
|
}
|
|
fmt.Println("Login Start:", loginStart)
|
|
|
|
// Send Login Success
|
|
var packetData bytes.Buffer
|
|
packetData.WriteByte(0x02) // Login Success ID
|
|
|
|
// UUID
|
|
writeUUID(&packetData, loginStart.UUID)
|
|
|
|
// Username
|
|
writeString(&packetData, loginStart.Name)
|
|
|
|
writeProperties(&packetData)
|
|
|
|
var responsePacket bytes.Buffer
|
|
writeVarInt(&responsePacket, packetData.Len())
|
|
responsePacket.Write(packetData.Bytes())
|
|
|
|
fmt.Println("Login Success Packet:", responsePacket.Bytes())
|
|
|
|
if _, err := client.conn.Write(responsePacket.Bytes()); err != nil {
|
|
fmt.Println("Error sending login success:", err)
|
|
} else {
|
|
fmt.Println("Login success sent successfully")
|
|
}
|
|
} else if client.nextState == 3 {
|
|
// Transfer
|
|
fmt.Println("Received status request in the wrong state")
|
|
} else {
|
|
handshake, err := handleHandshake(packetReader)
|
|
if err != nil {
|
|
fmt.Println("Error processing handshake:", err)
|
|
return
|
|
}
|
|
client.nextState = handshake.NextState
|
|
}
|
|
case PingRequestID:
|
|
var timestamp int64
|
|
if err := binary.Read(packetReader, binary.BigEndian, ×tamp); err != nil {
|
|
fmt.Println("Error reading timestamp:", err)
|
|
break
|
|
}
|
|
|
|
var responsePacket bytes.Buffer
|
|
writeVarInt(&responsePacket, 9) // Packet length: 1 byte for ID + 8 bytes for timestamp
|
|
responsePacket.WriteByte(PongResponseID)
|
|
binary.Write(&responsePacket, binary.BigEndian, timestamp)
|
|
|
|
if _, err := client.conn.Write(responsePacket.Bytes()); err != nil {
|
|
fmt.Println("Error sending pong response:", err)
|
|
} else {
|
|
fmt.Println("Pong response sent successfully:", timestamp)
|
|
}
|
|
case LoginAcknowledgedID:
|
|
fmt.Println("Received login acknowledge")
|
|
|
|
// TODO: Switch state to configuration
|
|
case LoginPluginResponseID:
|
|
sharedSecret, err := readPrefixedByteArray(packetReader)
|
|
if err != nil {
|
|
fmt.Println("Error reading shared secret:", err)
|
|
break
|
|
}
|
|
|
|
verifyToken, err := readPrefixedByteArray(packetReader)
|
|
if err != nil {
|
|
fmt.Println("Error reading verify token:", err)
|
|
break
|
|
}
|
|
|
|
fmt.Println("Shared Secret:", sharedSecret)
|
|
fmt.Println("Verify Token:", verifyToken)
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleHandshake(reader *bytes.Reader) (HandshakePacket, error) {
|
|
var handshake HandshakePacket
|
|
var err error
|
|
|
|
handshake.ProtocolVersion, err = readVarInt(reader)
|
|
if err != nil {
|
|
return handshake, err
|
|
}
|
|
|
|
handshake.ServerAddress, err = readString(reader)
|
|
if err != nil {
|
|
return handshake, err
|
|
}
|
|
|
|
if err := binary.Read(reader, binary.BigEndian, &handshake.ServerPort); err != nil {
|
|
return handshake, err
|
|
}
|
|
|
|
handshake.NextState, err = readVarInt(reader)
|
|
if err != nil {
|
|
return handshake, err
|
|
}
|
|
|
|
fmt.Printf("Handshake received: %+v\n", handshake)
|
|
return handshake, nil
|
|
}
|
|
|
|
func handleLoginStart(reader *bytes.Reader) (LoginStartPacket, error) {
|
|
var packet LoginStartPacket
|
|
var err error
|
|
|
|
packet.Name, err = readString(reader)
|
|
if err != nil {
|
|
return packet, err
|
|
}
|
|
|
|
packet.UUID, err = readUUID(reader)
|
|
if err != nil {
|
|
return packet, err
|
|
}
|
|
|
|
return packet, nil
|
|
}
|
|
|
|
func handleStatusRequest(client *ClientState) {
|
|
status := StatusResponse{
|
|
Version: VersionInfo{"1.21.4", 769},
|
|
Players: PlayerInfo{Max: 100, Online: 5, Sample: []Player{}},
|
|
Description: Chat{Text: "A Minecraft Server"},
|
|
}
|
|
|
|
response, err := json.Marshal(status)
|
|
if err != nil {
|
|
fmt.Println("Error marshaling status response:", err)
|
|
return
|
|
}
|
|
|
|
var packetData bytes.Buffer
|
|
writeVarInt(&packetData, StatusResponseID)
|
|
writeVarInt(&packetData, len(response))
|
|
packetData.Write(response)
|
|
|
|
var responsePacket bytes.Buffer
|
|
writeVarInt(&responsePacket, packetData.Len())
|
|
responsePacket.Write(packetData.Bytes())
|
|
|
|
fmt.Println("Final Response Packet:", responsePacket.Bytes())
|
|
|
|
if _, err = client.conn.Write(responsePacket.Bytes()); err != nil {
|
|
fmt.Println("Error sending response:", err)
|
|
} else {
|
|
fmt.Println("Status response sent successfully")
|
|
}
|
|
}
|
|
|
|
func writeVarInt(buf *bytes.Buffer, value int) {
|
|
for {
|
|
temp := byte(value & 0x7F)
|
|
value >>= 7
|
|
if value > 0 {
|
|
temp |= 0x80
|
|
}
|
|
buf.WriteByte(temp)
|
|
if value == 0 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeString(buf *bytes.Buffer, value string) {
|
|
writeVarInt(buf, len(value))
|
|
buf.WriteString(value)
|
|
}
|
|
|
|
func writePrefixedByteArray(buf *bytes.Buffer, value PrefixedByteArray) {
|
|
writeVarInt(buf, value.Length)
|
|
buf.Write(value.Data)
|
|
}
|
|
|
|
func writeUUID(buf *bytes.Buffer, uuidStr string) {
|
|
// Remove hyphens from UUID (Minecraft expects raw bytes)
|
|
cleanUUID := strings.ReplaceAll(uuidStr, "-", "")
|
|
uuidBytes, err := hex.DecodeString(cleanUUID)
|
|
if err != nil {
|
|
fmt.Println("Error parsing UUID:", err)
|
|
return
|
|
}
|
|
buf.Write(uuidBytes)
|
|
}
|
|
|
|
func writeProperties(buf *bytes.Buffer) {
|
|
// Write number of properties (1 property in this case)
|
|
writeVarInt(buf, 1)
|
|
|
|
// Write "textures" property
|
|
writeString(buf, "GlitchedSteve")
|
|
|
|
// Write Base64-encoded skin data
|
|
textureData := "ewogICJ0aW1lc3RhbXAiIDogMTc0MDQyMzYwMjU3NywKICAicHJvZmlsZUlkIiA6ICI5NjFlZjYzYTE0ZDQ0ZjdhODM1ZGFiMTRlMmFmNmUwOSIsCiAgInByb2ZpbGVOYW1lIiA6ICJ1UGlwZSIsCiAgInNpZ25hdHVyZVJlcXVpcmVkIiA6IHRydWUsCiAgInRleHR1cmVzIiA6IHsKICAgICJTS0lOIiA6IHsKICAgICAgInVybCIgOiAiaHR0cDovL3RleHR1cmVzLm1pbmVjcmFmdC5uZXQvdGV4dHVyZS8zZjg1NzhlZjU2MjliOWVhZmE2NWY4MDUxMGExMzdhNTc3MjEzNTg4MDU4NDUxYjA0NmViYjQ3ZWFiN2JhZDg3IgogICAgfQogIH0KfQ=="
|
|
writeString(buf, textureData)
|
|
|
|
// Write signature
|
|
buf.WriteByte(1) // No signature
|
|
signature := "KcyYXr9cbd4Fy16JEjgcVNAEEnXvUTohvToqQjNbz2dIrCjoE88IZJeXqdPUTUu5+rFd/U1qaVQswOomyxYA+7xDHlluB89BbOtT2YlrVo5asR1h+3hp+Dwpn1wwDX+2aA7ES5dHe96Bd2oeKXpHCTYAP9s3Dk3uQrURhmdc8TcrA8JohSCoGuaFR1o8QWg3QDGenL47SxSF6fbhCS4ors5lWkkkvXvK7+XxG4hk+rYe8uavU8Z5pjUxK4RJezLAy5Bt4FX0HCTtShVHSRrdIesEV9jqzdcMAK81+q9bkT2JhYbWZYAjF9hjv1dSxzZNmsS/vdna/mhH0/1yvSKCqD8Wk/V4akHlt9DcfyanKnjyVEWc9HtBRdnFvSPRKWeYeaieADD8kX7veelhEIkG/DkzS7/CORbnetVKw34UGqlvgxecGIzZ9+tUq4fEc/MqU/EKQhMghyb0cmHT6EtZTnJSkxftgVmTNFcrqhhiFPVnhlKsK0mUPS1U5mxmfIAimRQeIEGJ/JAqOsAawUMiqhSVNp+mid2d993ODNhPI5Ldz8lORP3vvEqjH1+HF6vR8lI/ioFrnGGryBI/ETY8wgTRp+GhPG2s02x+d2FNQJmfcaV+Z4sB70S88fzFa2cuem4xaZIgknFLENUtlZCZMo8HkQXyfGh6wpBkguRI9Qg="
|
|
writeString(buf, signature)
|
|
}
|
|
|
|
func readVarInt(reader *bytes.Reader) (int, error) {
|
|
value, position := 0, 0
|
|
for {
|
|
b, err := reader.ReadByte()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
value |= int(b&0x7F) << position
|
|
if (b & 0x80) == 0 {
|
|
break
|
|
}
|
|
position += 7
|
|
if position >= 32 {
|
|
return 0, errors.New("VarInt too big")
|
|
}
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func readVarLong(reader *bytes.Reader) (int64, error) {
|
|
value, position := int64(0), 0
|
|
for {
|
|
b, err := reader.ReadByte()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
value |= int64(b&0x7F) << position
|
|
if (b & 0x80) == 0 {
|
|
break
|
|
}
|
|
position += 7
|
|
if position >= 64 {
|
|
return 0, errors.New("VarLong too big")
|
|
}
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func readString(reader *bytes.Reader) (string, error) {
|
|
length, err := readVarInt(reader)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
strBuf := make([]byte, length)
|
|
if _, err := reader.Read(strBuf); err != nil {
|
|
return "", err
|
|
}
|
|
return string(strBuf), nil
|
|
}
|
|
|
|
func readUUID(reader *bytes.Reader) (string, error) {
|
|
// UUID is 16 bytes
|
|
uuid := make([]byte, 16)
|
|
if _, err := reader.Read(uuid); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return fmt.Sprintf("%x-%x-%x-%x-%x", uuid[0:4], uuid[4:6], uuid[6:8], uuid[8:10], uuid[10:]), nil
|
|
}
|
|
|
|
func readPrefixedByteArray(reader *bytes.Reader) (PrefixedByteArray, error) {
|
|
length, err := readVarInt(reader)
|
|
if err != nil {
|
|
return PrefixedByteArray{}, err
|
|
}
|
|
|
|
data := make([]byte, length)
|
|
if _, err := reader.Read(data); err != nil {
|
|
return PrefixedByteArray{}, err
|
|
}
|
|
|
|
return PrefixedByteArray{Length: length, Data: data}, nil
|
|
}
|