/// <summary>
/// Converts an array of bytes to readable hex representation
/// Extension method for PacketWriter
/// </summary>
/// <param name="bytes"></param>
/// <returns></returns>
public static String ToString(this PacketReader reader)
{
byte[] bytes = reader.ToArray();
StringBuilder hexed = new StringBuilder();
for (int i = 0; i < bytes.Length; i++)
{
hexed.Append(ToString(bytes[i]));
hexed.Append(' ');
}
return(hexed.ToString());
}
/// <summary>
/// Data received event handler
/// </summary>
/// <param name="iar">IAsyncResult of the data received event</param>
private void OnDataReceived(IAsyncResult iar)
{
SocketInfo socketInfo = (SocketInfo)iar.AsyncState;
try
{
int received = socketInfo.Socket.EndReceive(iar);
if (received == 0)
{
if (OnClientDisconnected != null)
{
OnClientDisconnected(this);
}
return;
}
socketInfo.Index += received;
if (socketInfo.Index == socketInfo.DataBuffer.Length)
{
switch (socketInfo.State)
{
case SocketInfo.StateEnum.Header:
if (socketInfo.NoEncryption)
{
PacketReader headerReader = new PacketReader(socketInfo.DataBuffer);
short packetHeader = headerReader.ReadShort();
socketInfo.State = SocketInfo.StateEnum.Content;
socketInfo.DataBuffer = new byte[packetHeader];
socketInfo.Index = 0;
WaitForData(socketInfo);
}
else
{
PacketReader headerReader = new PacketReader(socketInfo.DataBuffer);
byte[] packetHeaderB = headerReader.ToArray();
int packetHeader = headerReader.ReadInt();
short packetLength = (short)MapleCrypto.getPacketLength(packetHeader);
if (_type == SessionType.SERVER_TO_CLIENT && !_RIV.checkPacketToServer(BitConverter.GetBytes(packetHeader)))
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Error] Packet check failed. Disconnecting client.");
//this.Socket.Close();
}
socketInfo.State = SocketInfo.StateEnum.Content;
socketInfo.DataBuffer = new byte[packetLength];
socketInfo.Index = 0;
WaitForData(socketInfo);
}
break;
case SocketInfo.StateEnum.Content:
byte[] data = socketInfo.DataBuffer;
if (socketInfo.NoEncryption)
{
socketInfo.NoEncryption = false;
PacketReader reader = new PacketReader(data);
short version = reader.ReadShort();
string unknown = reader.ReadMapleString();
_SIV = new MapleCrypto(reader.ReadBytes(4), version);
_RIV = new MapleCrypto(reader.ReadBytes(4), version);
byte serverType = reader.ReadByte();
if (_type == SessionType.CLIENT_TO_SERVER)
{
OnInitPacketReceived(version, serverType);
}
OnPacketReceived(new PacketReader(data), true);
WaitForData();
}
else
{
_RIV.crypt(data);
MapleCustomEncryption.Decrypt(data);
if (data.Length != 0 && OnPacketReceived != null)
{
OnPacketReceived(new PacketReader(data), false);
}
WaitForData();
}
break;
}
}
else
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Warning] Not enough data");
WaitForData(socketInfo);
}
}
catch (ObjectDisposedException)
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Error] Session.OnDataReceived: Socket has been closed");
}
catch (SocketException se)
{
if (se.ErrorCode != 10054)
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Error] Session.OnDataReceived: " + se);
}
}
catch (Exception e)
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Error] Session.OnDataReceived: " + e);
}
}
/// <summary>
/// Data received event handler
/// </summary>
/// <param name="iar">IAsyncResult of the data received event</param>
private void OnDataReceived(IAsyncResult iar)
{
SocketInfo socketInfo = (SocketInfo)iar.AsyncState;
try
{
int received = socketInfo.Socket.EndReceive(iar);
if (received == 0)
{
if (OnClientDisconnected != null)
{
OnClientDisconnected(this);
}
return;
}
socketInfo.Index += received;
if (socketInfo.Index == socketInfo.DataBuffer.Length)
{
switch (socketInfo.State)
{
case SocketInfo.StateEnum.Header:
if (socketInfo.NoEncryption)
{
PacketReader headerReader = new PacketReader(socketInfo.DataBuffer);
short packetHeader = headerReader.ReadShort();
socketInfo.State = SocketInfo.StateEnum.Content;
socketInfo.DataBuffer = new byte[packetHeader];
socketInfo.Index = 0;
WaitForData(socketInfo);
}
else
{
PacketReader headerReader = new PacketReader(socketInfo.DataBuffer);
byte[] packetHeaderB = headerReader.ToArray();
int packetHeader = headerReader.ReadInt();
short packetLength = (short)MapleCrypto.getPacketLength(packetHeader);
if (_type == SessionType.SERVER_TO_CLIENT && !_RIV.checkPacketToServer(BitConverter.GetBytes(packetHeader)))
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Error] Packet check failed. Disconnecting client.");
//this.Socket.Close();
}
socketInfo.State = SocketInfo.StateEnum.Content;
socketInfo.DataBuffer = new byte[packetLength];
socketInfo.Index = 0;
WaitForData(socketInfo);
}
break;
case SocketInfo.StateEnum.Content:
byte[] data = socketInfo.DataBuffer;
if (socketInfo.NoEncryption)
{
socketInfo.NoEncryption = false;
PacketReader reader = new PacketReader(data);
short version = reader.ReadShort();
string unknown = reader.ReadMapleString();
_SIV = new MapleCrypto(reader.ReadBytes(4), version);
_RIV = new MapleCrypto(reader.ReadBytes(4), version);
byte serverType = reader.ReadByte();
if (_type == SessionType.CLIENT_TO_SERVER)
{
OnInitPacketReceived(version, serverType);
}
OnPacketReceived(new PacketReader(data), true);
WaitForData();
}
else
{
_RIV.crypt(data);
MapleCustomEncryption.Decrypt(data);
if (data.Length != 0 && OnPacketReceived != null)
{
OnPacketReceived(new PacketReader(data), false);
}
WaitForData();
}
break;
}
}
else
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Warning] Not enough data");
WaitForData(socketInfo);
}
}
catch (ObjectDisposedException)
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Error] Session.OnDataReceived: Socket has been closed");
}
catch (SocketException se)
{
if (se.ErrorCode != 10054)
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Error] Session.OnDataReceived: " + se);
}
}
catch (Exception e)
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "[Error] Session.OnDataReceived: " + e);
}
}
public Results BufferTCPPacket(TcpPacket pTCPPacket, DateTime pArrivalTime)
{
if (pTCPPacket.Fin || pTCPPacket.Rst)
{
_terminated = true;
Text += " (Terminated)";
return _packets.Count == 0 ? Results.CloseMe : Results.Terminated;
}
if (pTCPPacket.Syn && !pTCPPacket.Ack)
{
_localPort = (ushort)pTCPPacket.SourcePort;
_remotePort = (ushort)pTCPPacket.DestinationPort;
_outboundSequence = (uint)(pTCPPacket.SequenceNumber + 1);
Text = "Port " + _localPort + " - " + _remotePort;
startTime = DateTime.Now;
try
{
_remoteEndpoint = ((PacketDotNet.IPv4Packet)pTCPPacket.ParentPacket).SourceAddress.ToString() + ":" + pTCPPacket.SourcePort.ToString();
_localEndpoint = ((PacketDotNet.IPv4Packet)pTCPPacket.ParentPacket).DestinationAddress.ToString() + ":" + pTCPPacket.DestinationPort.ToString();
Console.WriteLine("[CONNECTION] From {0} to {1}", _remoteEndpoint, _localEndpoint);
return Results.Continue;
}
catch
{
return Results.CloseMe;
}
}
if (pTCPPacket.Syn && pTCPPacket.Ack) { _inboundSequence = (uint)(pTCPPacket.SequenceNumber + 1); return Results.Continue; }
if (pTCPPacket.PayloadData.Length == 0) return Results.Continue;
if (_protocol == null)
{
byte[] tcpData = pTCPPacket.PayloadData;
if (pTCPPacket.SourcePort == _localPort) _outboundSequence += (uint)tcpData.Length;
else _inboundSequence += (uint)tcpData.Length;
ushort length = (ushort)(BitConverter.ToUInt16(tcpData, 0) + 2);
byte[] headerData = new byte[tcpData.Length];
Buffer.BlockCopy(tcpData, 0, headerData, 0, tcpData.Length);
PacketReader pr = new PacketReader(headerData);
if (length != tcpData.Length || tcpData.Length < 13)
{
if (_socks5 > 0 && _socks5 < 7)
{
if (pr.ReadByte() == 5 && pr.ReadByte() == 1)
{
pr.ReadByte();
_proxyEndpoint = _localEndpoint;
_localEndpoint = "";
switch (pr.ReadByte())
{
case 1://IPv4
for (int i = 0; i < 4; i++)
{
_localEndpoint += pr.ReadByte();
if (i < 3)
{
_localEndpoint += ".";
}
}
break;
case 3://Domain
//readInt - String Length
//readAsciiString - Address
break;
case 4://IPv6
for (int i = 0; i < 16; i++)
{
pr.ReadByte();
}
break;
}
byte[] ports = new byte[2];
for (int i = 1; i >= 0; i--)
{
ports[i] = pr.ReadByte();
}
PacketReader portr = new PacketReader(ports);
_proxyPort = _remotePort;
_remotePort = portr.ReadUShort();
_localEndpoint += ":" + _remotePort;
Text = "Port " + _localPort + " - " + _remotePort + "(Proxy" + _proxyPort + ")";
Console.WriteLine("[socks5] From {0} to {1} (Proxy {2})", _remoteEndpoint, _localEndpoint, _proxyEndpoint);
}
_socks5++;
return Results.Continue;
}
else if (tcpData.Length == 3 && pr.ReadByte() == 5)
{
_socks5 = 1;
return Results.Continue;
}
Console.WriteLine("Connection on port {0} did not have a MapleStory Handshake", _localEndpoint);
return Results.CloseMe;
}
var kvp = MapleProtocol.ParseHandshake(pr.ToArray(), pArrivalTime);
if (!kvp.HasValue)
{
return Results.CloseMe;
}
_protocol = kvp.Value.Key;
var hs = kvp.Value.Value;
mPacketList.Items.Add(hs.GetListViewItem());
_packets.Add(hs);
ListView.Columns.Clear();
ListView.Columns.AddRange(_protocol.GetListViewHeaders());
MainForm.SearchForm.RefreshOpcodes(true);
}
if (pTCPPacket.SourcePort == _localPort) ProcessTCPPacket(pTCPPacket, ref _outboundSequence, _outboundBuffer, _protocol.OutboundStream, pArrivalTime);
else ProcessTCPPacket(pTCPPacket, ref _inboundSequence, _inboundBuffer, _protocol.InboundStream, pArrivalTime);
return Results.Continue;
}
void mSession_OnPacketReceived(PacketReader packet)
{
Logger.Write(Logger.LogTypes.대타, "받은 패킷 {0}", packet.ToArray().ToString2s());
IPacketHandler handler = PacketHandler.getInstance().GetHandler(packet.ReadShort());
if (handler != null)
handler.handlePacket(this, packet);
else
{
packet.Reset(0);
Logger.Write(Logger.LogTypes.경고, "!!: {0}", HexEncoding.ToHex(packet.ReadShort()));
}
}
/// <summary>
/// Data received event handler
/// </summary>
/// <param name="iar">IAsyncResult of the data received event</param>
private void OnDataReceived(IAsyncResult iar)
{
var socketInfo = (SocketInfo)iar.AsyncState;
try
{
var received = socketInfo.Socket.EndReceive(iar);
if (received == 0)
{
OnClientDisconnected?.Invoke(this);
return;
}
socketInfo.Index += received;
if (socketInfo.Index == socketInfo.DataBuffer.Length)
{
switch (socketInfo.State)
{
case SocketInfo.StateEnum.Header:
if (socketInfo.IsNoEncryption)
{
var headerReader = new PacketReader(socketInfo.DataBuffer);
var packetHeader = headerReader.ReadShort();
socketInfo.State = SocketInfo.StateEnum.Content;
socketInfo.DataBuffer = new byte[packetHeader];
socketInfo.Index = 0;
WaitForData(socketInfo);
}
else
{
var headerReader = new PacketReader(socketInfo.DataBuffer);
var packetHeaderB = headerReader.ToArray();
var packetHeader = headerReader.ReadInt();
var packetLength = (short)MapleCrypto.GetPacketLength(packetHeader);
if (Type == SessionType.SERVER_TO_CLIENT &&
!RIV.CheckPacketToServer(BitConverter.GetBytes(packetHeader)))
{
Log.LogError("Packet check failed. Disconnecting client");
Socket.Close();
}
socketInfo.State = SocketInfo.StateEnum.Content;
socketInfo.DataBuffer = new byte[packetLength];
socketInfo.Index = 0;
WaitForData(socketInfo);
}
break;
case SocketInfo.StateEnum.Content:
var data = socketInfo.DataBuffer;
if (socketInfo.IsNoEncryption)
{
socketInfo.IsNoEncryption = false;
var reader = new PacketReader(data);
var version = reader.ReadShort();
var unknown = reader.ReadMapleString();
SIV = new MapleCrypto(reader.ReadBytes(4), version);
RIV = new MapleCrypto(reader.ReadBytes(4), version);
var serverType = reader.ReadByte();
if (Type == SessionType.CLIENT_TO_SERVER)
{
OnInitPacketReceived(version, serverType);
}
OnPacketReceived(new PacketReader(data), true);
WaitForData();
}
else
{
RIV.Crypt(data);
MapleCustomEncryption.Decrypt(data);
if (data.Length != 0)
{
OnPacketReceived?.Invoke(new PacketReader(data), false);
}
WaitForData();
}
break;
}
}
else
{
Log.LogWarning("Not enough data");
WaitForData(socketInfo);
}
}
catch (ObjectDisposedException e)
{
Log.LogError("Socket has been closed", e);
}
catch (SocketException se)
{
if (se.ErrorCode != 10054)
{
Log.LogError("Session.OnDataReceived", se);
}
}
catch (Exception e)
{
Log.LogError("Session.OnDataReceived", e);
}
}
