/
RakNetLayer.go
268 lines (242 loc) · 6.62 KB
/
RakNetLayer.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
// Package peer can be used for communication with Roblox servers and clients, as well as
// parsing packets captured from Roblox network traffic.
package peer
import (
"bytes"
"errors"
"fmt"
"io/ioutil"
"log"
"net"
"strings"
)
func bufferToStream(buffer []byte) *extendedReader {
return &extendedReader{bytes.NewReader(buffer)}
}
func bitsToBytes(bits uint) uint {
return (bits + 7) >> 3
}
func bytesToBits(bytes uint) uint {
return bytes << 3
}
// RakNetPacket describes any packet that can be serialized and written to UDP
type RakNetPacket interface {
fmt.Stringer
Serialize(writer PacketWriter, stream *extendedWriter) error
TypeString() string
Type() byte
}
// RootLayer is a meta-layer that is container by every packet
// It contains basic information about the packet
type RootLayer struct {
logBuffer *strings.Builder
Logger *log.Logger
Source *net.UDPAddr
Destination *net.UDPAddr
FromClient bool
FromServer bool
}
// GetLog returns the accumulated log string for a packet
func (layer *RootLayer) GetLog() string {
if layer.logBuffer != nil {
return layer.logBuffer.String()
}
return ""
}
// PacketLayers contains the different layers a packet can have.
type PacketLayers struct {
// Root is the a basic layer containg information about a packet's source and destination
Root RootLayer
// RakNetLayer is the outermost layer. All packets have a RakNetLayer.
RakNet *RakNetLayer
// Most packets have a ReliabilityLayer. The exceptions to this are ACKs, NAKs and
// pre-connection packets.
Reliability *ReliablePacket
// Contains data about the split packets this packet has.
SplitPacket *SplitPacketBuffer
// Timestamped packets (i.e. physics packets) may have a Timestamp layer.
Timestamp *Packet1BLayer
// Almost all packets have a Main layer. The exceptions to this are ACKs and NAKs.
Main RakNetPacket
// Possible parsing error?
Error error
PacketType byte
Subpacket Packet83Subpacket
OfflinePayload []byte
}
// PacketNames contains the names of most packet types
var PacketNames = map[byte]string{
0x00: "ID_CONNECTED_PING",
0x01: "ID_UNCONNECTED_PING",
0x03: "ID_CONNECTED_PONG",
0x04: "ID_DETECT_LOST_CONNECTIONS",
0x05: "ID_OPEN_CONNECTION_REQUEST_1",
0x06: "ID_OPEN_CONNECTION_REPLY_1",
0x07: "ID_OPEN_CONNECTION_REQUEST_2",
0x08: "ID_OPEN_CONNECTION_REPLY_2",
0x09: "ID_CONNECTION_REQUEST",
0x10: "ID_CONNECTION_REQUEST_ACCEPTED",
0x11: "ID_CONNECTION_ATTEMPT_FAILED",
0x13: "ID_NEW_INCOMING_CONNECTION",
0x15: "ID_DISCONNECTION_NOTIFICATION",
0x18: "ID_INVALID_PASSWORD",
0x1B: "ID_TIMESTAMP",
0x1C: "ID_UNCONNECTED_PONG",
0x81: "ID_SET_GLOBALS",
0x82: "ID_TEACH_DESCRIPTOR_DICTIONARIES",
0x83: "ID_DATA",
0x84: "ID_MARKER",
0x85: "ID_PHYSICS",
0x86: "ID_TOUCHES",
0x87: "ID_CHAT_ALL",
0x88: "ID_CHAT_TEAM",
0x89: "ID_REPORT_ABUSE",
0x8A: "ID_SUBMIT_TICKET",
0x8B: "ID_CHAT_GAME",
0x8C: "ID_CHAT_PLAYER",
0x8D: "ID_CLUSTER",
0x8E: "ID_PROTOCOL_MISMATCH",
0x8F: "ID_PREFERRED_SPAWN_NAME",
0x90: "ID_PROTOCOL_SYNC",
0x91: "ID_SCHEMA_SYNC",
0x92: "ID_PLACEID_VERIFICATION",
0x93: "ID_DICTIONARY_FORMAT",
0x94: "ID_HASH_MISMATCH",
0x95: "ID_SECURITYKEY_MISMATCH",
0x96: "ID_REQUEST_STATS",
0x97: "ID_NEW_SCHEMA",
}
func (layers *PacketLayers) String() string {
if layers.Subpacket != nil {
return layers.Subpacket.String()
}
if layers.Main != nil {
return layers.Main.String()
}
if (layers.RakNet != nil && layers.RakNet.Flags.IsValid) || layers.OfflinePayload != nil {
packetName, ok := PacketNames[layers.PacketType]
if ok {
return packetName
}
return fmt.Sprintf("Packet 0x%02X", layers.PacketType)
}
return "???"
}
// ACKRange describes the range of an ACK or an NAK.
type ACKRange struct {
Min uint32
Max uint32
}
// RakNetLayer is the outermost layer of all packets. It contains basic information
// about every packet.
type RakNetLayer struct {
payload *extendedReader
// Drop any non-offline packets which don't have IsValid set.
Flags RakNetFlags
ACKs []ACKRange
// A datagram number that is used to keep the packets in order.
DatagramNumber uint32
}
// OfflineMessageID is the offline message contained in pre-connection packets.
var OfflineMessageID = []byte{0x00, 0xFF, 0xFF, 0x00, 0xFE, 0xFE, 0xFE, 0xFE, 0xFD, 0xFD, 0xFD, 0xFD, 0x12, 0x34, 0x56, 0x78}
// IsOfflineMessage checks whether the packet payload is an offline message
func IsOfflineMessage(data []byte) bool {
if len(data) < 1+len(OfflineMessageID) {
return false
}
return bytes.Compare(data[1:1+len(OfflineMessageID)], OfflineMessageID) == 0
}
func (stream *extendedReader) DecodeRakNetLayer(reader PacketReader, packetType byte, layers *PacketLayers) (*RakNetLayer, error) {
layer := &RakNetLayer{}
var err error
layer.Flags, err = stream.readRakNetFlags()
if err != nil {
return layer, err
}
if !layer.Flags.IsValid {
return layer, errors.New("layer not a valid RakNet packet")
}
if layer.Flags.IsACK || layer.Flags.IsNAK {
ackCount, err := stream.readUint16BE()
if err != nil {
return layer, err
}
var i uint16
for i = 0; i < ackCount; i++ {
var min, max uint32
minEqualToMax, err := stream.readBoolByte()
if err != nil {
return layer, err
}
min, err = stream.readUint24LE()
if err != nil {
return layer, err
}
if minEqualToMax {
max = min
} else {
max, err = stream.readUint24LE()
}
layer.ACKs = append(layer.ACKs, ACKRange{min, max})
}
return layer, nil
}
layer.DatagramNumber, err = stream.readUint24LE()
if err != nil {
return layer, err
}
layer.payload = stream
return layer, nil
}
// Serialize serializes the RakNetLayer to its network format
func (layer *RakNetLayer) Serialize(writer PacketWriter, outStream *extendedWriter) error {
err := outStream.writeRakNetFlags(layer.Flags)
if err != nil {
return err
}
if layer.Flags.IsACK || layer.Flags.IsNAK {
err = outStream.writeUint16BE(uint16(len(layer.ACKs)))
if err != nil {
return err
}
for _, ack := range layer.ACKs {
if ack.Min == ack.Max {
err = outStream.writeBoolByte(true)
if err != nil {
return err
}
err = outStream.writeUint24LE(ack.Min)
if err != nil {
return err
}
} else {
err = outStream.writeBoolByte(false)
if err != nil {
return err
}
err = outStream.writeUint24LE(ack.Min)
if err != nil {
return err
}
err = outStream.writeUint24LE(ack.Max)
if err != nil {
return err
}
}
}
} else {
err = outStream.writeUint24LE(layer.DatagramNumber)
if err != nil {
return err
}
content, err := ioutil.ReadAll(layer.payload)
if err != nil {
return err
}
err = outStream.allBytes(content)
if err != nil {
return err
}
}
return nil
}